Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 4850f524 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge git://git.kernel.org/pub/scm/linux/kernel/git/steve/gfs2-2.6-nmw 

* git://git.kernel.org/pub/scm/linux/kernel/git/steve/gfs2-2.6-nmw:
  GFS2: print glock numbers in hex
  GFS2: ordered writes are backwards
  GFS2: Remove old, unused linked list code from quota
  GFS2: Remove loopy umount code
  GFS2: Metadata address space clean up
parents 3ff1562e 4818972e

fs/gfs2/aops.c

+2 −2
Original line number Diff line number Diff line
@@ -1061,8 +1061,8 @@ static ssize_t gfs2_direct_IO(int rw, struct kiocb *iocb, 


int gfs2_releasepage(struct page *page, gfp_t gfp_mask)

{

	struct inode *aspace = page->mapping->host;

	struct gfs2_sbd *sdp = aspace->i_sb->s_fs_info;

	struct address_space *mapping = page->mapping;

	struct gfs2_sbd *sdp = gfs2_mapping2sbd(mapping);

	struct buffer_head *bh, *head;

	struct gfs2_bufdata *bd;

fs/gfs2/glock.c

+24 −51
Original line number Diff line number Diff line
@@ -19,7 +19,6 @@ 
#include <linux/list.h>

#include <linux/wait.h>

#include <linux/module.h>

#include <linux/rwsem.h>

#include <asm/uaccess.h>

#include <linux/seq_file.h>

#include <linux/debugfs.h>
@@ -60,7 +59,6 @@ static int __dump_glock(struct seq_file *seq, const struct gfs2_glock *gl); 
#define GLOCK_BUG_ON(gl,x) do { if (unlikely(x)) { __dump_glock(NULL, gl); BUG(); } } while(0)

static void do_xmote(struct gfs2_glock *gl, struct gfs2_holder *gh, unsigned int target);



static DECLARE_RWSEM(gfs2_umount_flush_sem);

static struct dentry *gfs2_root;

static struct workqueue_struct *glock_workqueue;

struct workqueue_struct *gfs2_delete_workqueue;
@@ -154,12 +152,14 @@ static unsigned int gl_hash(const struct gfs2_sbd *sdp, 
static void glock_free(struct gfs2_glock *gl)

{

	struct gfs2_sbd *sdp = gl->gl_sbd;

	struct inode *aspace = gl->gl_aspace;

	struct address_space *mapping = gfs2_glock2aspace(gl);

	struct kmem_cache *cachep = gfs2_glock_cachep;



	if (aspace)

		gfs2_aspace_put(aspace);

	GLOCK_BUG_ON(gl, mapping && mapping->nrpages);

	trace_gfs2_glock_put(gl);

	sdp->sd_lockstruct.ls_ops->lm_put_lock(gfs2_glock_cachep, gl);

	if (mapping)

		cachep = gfs2_glock_aspace_cachep;

	sdp->sd_lockstruct.ls_ops->lm_put_lock(cachep, gl);

}



/**
@@ -712,7 +712,6 @@ static void glock_work_func(struct work_struct *work) 
		finish_xmote(gl, gl->gl_reply);

		drop_ref = 1;

	}

	down_read(&gfs2_umount_flush_sem);

	spin_lock(&gl->gl_spin);

	if (test_and_clear_bit(GLF_PENDING_DEMOTE, &gl->gl_flags) &&

	    gl->gl_state != LM_ST_UNLOCKED &&
@@ -725,7 +724,6 @@ static void glock_work_func(struct work_struct *work) 
	}

	run_queue(gl, 0);

	spin_unlock(&gl->gl_spin);

	up_read(&gfs2_umount_flush_sem);

	if (!delay ||

	    queue_delayed_work(glock_workqueue, &gl->gl_work, delay) == 0)

		gfs2_glock_put(gl);
@@ -750,10 +748,11 @@ int gfs2_glock_get(struct gfs2_sbd *sdp, u64 number, 
		   const struct gfs2_glock_operations *glops, int create,

		   struct gfs2_glock **glp)

{

	struct super_block *s = sdp->sd_vfs;

	struct lm_lockname name = { .ln_number = number, .ln_type = glops->go_type };

	struct gfs2_glock *gl, *tmp;

	unsigned int hash = gl_hash(sdp, &name);

	int error;

	struct address_space *mapping;



	read_lock(gl_lock_addr(hash));

	gl = search_bucket(hash, sdp, &name);
@@ -765,6 +764,9 @@ int gfs2_glock_get(struct gfs2_sbd *sdp, u64 number, 
	if (!create)

		return -ENOENT;



	if (glops->go_flags & GLOF_ASPACE)

		gl = kmem_cache_alloc(gfs2_glock_aspace_cachep, GFP_KERNEL);

	else

		gl = kmem_cache_alloc(gfs2_glock_cachep, GFP_KERNEL);

	if (!gl)

		return -ENOMEM;
@@ -784,18 +786,18 @@ int gfs2_glock_get(struct gfs2_sbd *sdp, u64 number, 
	gl->gl_tchange = jiffies;

	gl->gl_object = NULL;

	gl->gl_sbd = sdp;

	gl->gl_aspace = NULL;

	INIT_DELAYED_WORK(&gl->gl_work, glock_work_func);

	INIT_WORK(&gl->gl_delete, delete_work_func);



	/* If this glock protects actual on-disk data or metadata blocks,

	   create a VFS inode to manage the pages/buffers holding them. */

	if (glops == &gfs2_inode_glops || glops == &gfs2_rgrp_glops) {

		gl->gl_aspace = gfs2_aspace_get(sdp);

		if (!gl->gl_aspace) {

			error = -ENOMEM;

			goto fail;

		}

	mapping = gfs2_glock2aspace(gl);

	if (mapping) {

                mapping->a_ops = &gfs2_meta_aops;

		mapping->host = s->s_bdev->bd_inode;

		mapping->flags = 0;

		mapping_set_gfp_mask(mapping, GFP_NOFS);

		mapping->assoc_mapping = NULL;

		mapping->backing_dev_info = s->s_bdi;

		mapping->writeback_index = 0;

	}



	write_lock(gl_lock_addr(hash));
@@ -812,10 +814,6 @@ int gfs2_glock_get(struct gfs2_sbd *sdp, u64 number, 
	*glp = gl;



	return 0;



fail:

	kmem_cache_free(gfs2_glock_cachep, gl);

	return error;

}



/**
@@ -1510,35 +1508,10 @@ void gfs2_glock_thaw(struct gfs2_sbd *sdp) 


void gfs2_gl_hash_clear(struct gfs2_sbd *sdp)

{

	unsigned long t;

	unsigned int x;

	int cont;



	t = jiffies;



	for (;;) {

		cont = 0;

		for (x = 0; x < GFS2_GL_HASH_SIZE; x++) {

			if (examine_bucket(clear_glock, sdp, x))

				cont = 1;

		}



		if (!cont)

			break;



		if (time_after_eq(jiffies,

				  t + gfs2_tune_get(sdp, gt_stall_secs) * HZ)) {

			fs_warn(sdp, "Unmount seems to be stalled. "

				     "Dumping lock state...\n");

			gfs2_dump_lockstate(sdp);

			t = jiffies;

		}



		down_write(&gfs2_umount_flush_sem);

		invalidate_inodes(sdp->sd_vfs);

		up_write(&gfs2_umount_flush_sem);

		msleep(10);

	}

	for (x = 0; x < GFS2_GL_HASH_SIZE; x++)

		examine_bucket(clear_glock, sdp, x);

	flush_workqueue(glock_workqueue);

	wait_event(sdp->sd_glock_wait, atomic_read(&sdp->sd_glock_disposal) == 0);

	gfs2_dump_lockstate(sdp);
@@ -1685,7 +1658,7 @@ static int __dump_glock(struct seq_file *seq, const struct gfs2_glock *gl) 
	dtime *= 1000000/HZ; /* demote time in uSec */

	if (!test_bit(GLF_DEMOTE, &gl->gl_flags))

		dtime = 0;

	gfs2_print_dbg(seq, "G:  s:%s n:%u/%llu f:%s t:%s d:%s/%llu a:%d r:%d\n",

	gfs2_print_dbg(seq, "G:  s:%s n:%u/%llx f:%s t:%s d:%s/%llu a:%d r:%d\n",

		  state2str(gl->gl_state),

		  gl->gl_name.ln_type,

		  (unsigned long long)gl->gl_name.ln_number,

fs/gfs2/glock.h

+7 −0
Original line number Diff line number Diff line
@@ -180,6 +180,13 @@ static inline int gfs2_glock_is_held_shrd(struct gfs2_glock *gl) 
	return gl->gl_state == LM_ST_SHARED;

}



static inline struct address_space *gfs2_glock2aspace(struct gfs2_glock *gl)

{

	if (gl->gl_ops->go_flags & GLOF_ASPACE)

		return (struct address_space *)(gl + 1);

	return NULL;

}



int gfs2_glock_get(struct gfs2_sbd *sdp,

		   u64 number, const struct gfs2_glock_operations *glops,

		   int create, struct gfs2_glock **glp);

fs/gfs2/glops.c

+9 −7
Original line number Diff line number Diff line
@@ -87,7 +87,7 @@ static void gfs2_ail_empty_gl(struct gfs2_glock *gl) 


static void rgrp_go_sync(struct gfs2_glock *gl)

{

	struct address_space *metamapping = gl->gl_aspace->i_mapping;

	struct address_space *metamapping = gfs2_glock2aspace(gl);

	int error;



	if (!test_and_clear_bit(GLF_DIRTY, &gl->gl_flags))
@@ -113,7 +113,7 @@ static void rgrp_go_sync(struct gfs2_glock *gl) 


static void rgrp_go_inval(struct gfs2_glock *gl, int flags)

{

	struct address_space *mapping = gl->gl_aspace->i_mapping;

	struct address_space *mapping = gfs2_glock2aspace(gl);



	BUG_ON(!(flags & DIO_METADATA));

	gfs2_assert_withdraw(gl->gl_sbd, !atomic_read(&gl->gl_ail_count));
@@ -134,7 +134,7 @@ static void rgrp_go_inval(struct gfs2_glock *gl, int flags) 
static void inode_go_sync(struct gfs2_glock *gl)

{

	struct gfs2_inode *ip = gl->gl_object;

	struct address_space *metamapping = gl->gl_aspace->i_mapping;

	struct address_space *metamapping = gfs2_glock2aspace(gl);

	int error;



	if (ip && !S_ISREG(ip->i_inode.i_mode))
@@ -183,7 +183,7 @@ static void inode_go_inval(struct gfs2_glock *gl, int flags) 
	gfs2_assert_withdraw(gl->gl_sbd, !atomic_read(&gl->gl_ail_count));



	if (flags & DIO_METADATA) {

		struct address_space *mapping = gl->gl_aspace->i_mapping;

		struct address_space *mapping = gfs2_glock2aspace(gl);

		truncate_inode_pages(mapping, 0);

		if (ip) {

			set_bit(GIF_INVALID, &ip->i_flags);
@@ -282,7 +282,8 @@ static int inode_go_dump(struct seq_file *seq, const struct gfs2_glock *gl) 


static int rgrp_go_demote_ok(const struct gfs2_glock *gl)

{

	return !gl->gl_aspace->i_mapping->nrpages;

	const struct address_space *mapping = (const struct address_space *)(gl + 1);

	return !mapping->nrpages;

}



/**
@@ -387,8 +388,7 @@ static void iopen_go_callback(struct gfs2_glock *gl) 
	struct gfs2_inode *ip = (struct gfs2_inode *)gl->gl_object;



	if (gl->gl_demote_state == LM_ST_UNLOCKED &&

	    gl->gl_state == LM_ST_SHARED &&

	    ip && test_bit(GIF_USER, &ip->i_flags)) {

	    gl->gl_state == LM_ST_SHARED && ip) {

		gfs2_glock_hold(gl);

		if (queue_work(gfs2_delete_workqueue, &gl->gl_delete) == 0)

			gfs2_glock_put_nolock(gl);
@@ -407,6 +407,7 @@ const struct gfs2_glock_operations gfs2_inode_glops = { 
	.go_dump = inode_go_dump,

	.go_type = LM_TYPE_INODE,

	.go_min_hold_time = HZ / 5,

	.go_flags = GLOF_ASPACE,

};



const struct gfs2_glock_operations gfs2_rgrp_glops = {
@@ -418,6 +419,7 @@ const struct gfs2_glock_operations gfs2_rgrp_glops = { 
	.go_dump = gfs2_rgrp_dump,

	.go_type = LM_TYPE_RGRP,

	.go_min_hold_time = HZ / 5,

	.go_flags = GLOF_ASPACE,

};



const struct gfs2_glock_operations gfs2_trans_glops = {

fs/gfs2/incore.h

+2 −3
Original line number Diff line number Diff line
@@ -162,6 +162,8 @@ struct gfs2_glock_operations { 
	void (*go_callback) (struct gfs2_glock *gl);

	const int go_type;

	const unsigned long go_min_hold_time;

	const unsigned long go_flags;

#define GLOF_ASPACE 1

};



enum {
@@ -225,7 +227,6 @@ struct gfs2_glock { 


	struct gfs2_sbd *gl_sbd;



	struct inode *gl_aspace;

	struct list_head gl_ail_list;

	atomic_t gl_ail_count;

	struct delayed_work gl_work;
@@ -258,7 +259,6 @@ enum { 
	GIF_INVALID		= 0,

	GIF_QD_LOCKED		= 1,

	GIF_SW_PAGED		= 3,

	GIF_USER                = 4, /* user inode, not metadata addr space */

};
@@ -451,7 +451,6 @@ struct gfs2_tune { 
	unsigned int gt_quota_quantum; /* Secs between syncs to quota file */

	unsigned int gt_new_files_jdata;

	unsigned int gt_max_readahead; /* Max bytes to read-ahead from disk */

	unsigned int gt_stall_secs; /* Detects trouble! */

	unsigned int gt_complain_secs;

	unsigned int gt_statfs_quantum;

	unsigned int gt_statfs_slow;