Merge git://git.kernel.org/pub/scm/linux/kernel/git/steve/gfs2-2.6-nmw (3ae2a1ce) · Commits · e / devices / android_kernel_fairphone_FP3

fs/gfs2/acl.c

+5 −2

Original line number	Diff line number	Diff line
		@@ -80,8 +80,11 @@ int gfs2_check_acl(struct inode *inode, int mask, unsigned int flags)
		struct posix_acl *acl;
		int error;

		if (flags & IPERM_FLAG_RCU)
		if (flags & IPERM_FLAG_RCU) {
		if (!negative_cached_acl(inode, ACL_TYPE_ACCESS))
		return -ECHILD;
		return -EAGAIN;
		}

		acl = gfs2_acl_get(GFS2_I(inode), ACL_TYPE_ACCESS);
		if (IS_ERR(acl))

fs/gfs2/aops.c

+1 −0

Original line number	Diff line number	Diff line
		@@ -695,6 +695,7 @@ static int gfs2_write_begin(struct file file, struct address_space mapping,
		if (error == 0)
		return 0;

		unlock_page(page);
		page_cache_release(page);

		gfs2_trans_end(sdp);

fs/gfs2/bmap.c

+15 −5

Original line number	Diff line number	Diff line
		@@ -21,6 +21,7 @@
		#include "meta_io.h"
		#include "quota.h"
		#include "rgrp.h"
		#include "super.h"
		#include "trans.h"
		#include "dir.h"
		#include "util.h"
		@@ -757,7 +758,7 @@ static int do_strip(struct gfs2_inode ip, struct buffer_head dibh,
		struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
		struct gfs2_rgrp_list rlist;
		u64 bn, bstart;
		u32 blen;
		u32 blen, btotal;
		__be64 *p;
		unsigned int rg_blocks = 0;
		int metadata;
		@@ -839,6 +840,7 @@ static int do_strip(struct gfs2_inode ip, struct buffer_head dibh,

		bstart = 0;
		blen = 0;
		btotal = 0;

		for (p = top; p < bottom; p++) {
		if (!*p)
		@@ -851,9 +853,11 @@ static int do_strip(struct gfs2_inode ip, struct buffer_head dibh,
		else {
		if (bstart) {
		if (metadata)
		gfs2_free_meta(ip, bstart, blen);
		__gfs2_free_meta(ip, bstart, blen);
		else
		gfs2_free_data(ip, bstart, blen);
		__gfs2_free_data(ip, bstart, blen);

		btotal += blen;
		}

		bstart = bn;
		@@ -865,11 +869,17 @@ static int do_strip(struct gfs2_inode ip, struct buffer_head dibh,
		}
		if (bstart) {
		if (metadata)
		gfs2_free_meta(ip, bstart, blen);
		__gfs2_free_meta(ip, bstart, blen);
		else
		gfs2_free_data(ip, bstart, blen);
		__gfs2_free_data(ip, bstart, blen);

		btotal += blen;
		}

		gfs2_statfs_change(sdp, 0, +btotal, 0);
		gfs2_quota_change(ip, -(s64)btotal, ip->i_inode.i_uid,
		ip->i_inode.i_gid);

		ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;

		gfs2_dinode_out(ip, dibh->b_data);

fs/gfs2/file.c

+45 −32

Original line number	Diff line number	Diff line
		@@ -448,15 +448,20 @@ static int gfs2_mmap(struct file file, struct vm_area_struct vma)
		{
		struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);

		if (!(file->f_flags & O_NOATIME)) {
		if (!(file->f_flags & O_NOATIME) &&
		!IS_NOATIME(&ip->i_inode)) {
		struct gfs2_holder i_gh;
		int error;

		gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);
		gfs2_holder_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
		error = gfs2_glock_nq(&i_gh);
		if (error == 0) {
		file_accessed(file);
		if (error == 0)
		gfs2_glock_dq_uninit(&i_gh);
		gfs2_glock_dq(&i_gh);
		}
		gfs2_holder_uninit(&i_gh);
		if (error)
		return error;
		}
		vma->vm_ops = &gfs2_vm_ops;
		vma->vm_flags \|= VM_CAN_NONLINEAR;
		@@ -617,8 +622,7 @@ static void empty_write_end(struct page *page, unsigned from,
		{
		struct gfs2_inode *ip = GFS2_I(page->mapping->host);

		page_zero_new_buffers(page, from, to);
		flush_dcache_page(page);
		zero_user(page, from, to-from);
		mark_page_accessed(page);

		if (!gfs2_is_writeback(ip))
		@@ -627,36 +631,43 @@ static void empty_write_end(struct page *page, unsigned from,
		block_commit_write(page, from, to);
		}

		static int write_empty_blocks(struct page *page, unsigned from, unsigned to)
		static int needs_empty_write(sector_t block, struct inode *inode)
		{
		unsigned start, end, next;
		struct buffer_head bh, head;
		int error;
		struct buffer_head bh_map = { .b_state = 0, .b_blocknr = 0 };

		if (!page_has_buffers(page)) {
		error = __block_write_begin(page, from, to - from, gfs2_block_map);
		bh_map.b_size = 1 << inode->i_blkbits;
		error = gfs2_block_map(inode, block, &bh_map, 0);
		if (unlikely(error))
		return error;

		empty_write_end(page, from, to);
		return 0;
		return !buffer_mapped(&bh_map);
		}

		bh = head = page_buffers(page);
		static int write_empty_blocks(struct page *page, unsigned from, unsigned to)
		{
		struct inode *inode = page->mapping->host;
		unsigned start, end, next, blksize;
		sector_t block = page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits);
		int ret;

		blksize = 1 << inode->i_blkbits;
		next = end = 0;
		while (next < from) {
		next += bh->b_size;
		bh = bh->b_this_page;
		next += blksize;
		block++;
		}
		start = next;
		do {
		next += bh->b_size;
		if (buffer_mapped(bh)) {
		next += blksize;
		ret = needs_empty_write(block, inode);
		if (unlikely(ret < 0))
		return ret;
		if (ret == 0) {
		if (end) {
		error = __block_write_begin(page, start, end - start,
		ret = __block_write_begin(page, start, end - start,
		gfs2_block_map);
		if (unlikely(error))
		return error;
		if (unlikely(ret))
		return ret;
		empty_write_end(page, start, end);
		end = 0;
		}
		@@ -664,13 +675,13 @@ static int write_empty_blocks(struct page *page, unsigned from, unsigned to)
		}
		else
		end = next;
		bh = bh->b_this_page;
		block++;
		} while (next < to);

		if (end) {
		error = __block_write_begin(page, start, end - start, gfs2_block_map);
		if (unlikely(error))
		return error;
		ret = __block_write_begin(page, start, end - start, gfs2_block_map);
		if (unlikely(ret))
		return ret;
		empty_write_end(page, start, end);
		}

		@@ -976,8 +987,10 @@ static void do_unflock(struct file file, struct file_lock fl)

		mutex_lock(&fp->f_fl_mutex);
		flock_lock_file_wait(file, fl);
		if (fl_gh->gh_gl)
		gfs2_glock_dq_uninit(fl_gh);
		if (fl_gh->gh_gl) {
		gfs2_glock_dq_wait(fl_gh);
		gfs2_holder_uninit(fl_gh);
		}
		mutex_unlock(&fp->f_fl_mutex);
		}

fs/gfs2/glock.c

+158 −252

Original line number	Diff line number	Diff line
		@@ -26,6 +26,9 @@
		#include <linux/freezer.h>
		#include <linux/workqueue.h>
		#include <linux/jiffies.h>
		#include <linux/rcupdate.h>
		#include <linux/rculist_bl.h>
		#include <linux/bit_spinlock.h>

		#include "gfs2.h"
		#include "incore.h"
		@@ -41,10 +44,6 @@
		#define CREATE_TRACE_POINTS
		#include "trace_gfs2.h"

		struct gfs2_gl_hash_bucket {
		struct hlist_head hb_list;
		};

		struct gfs2_glock_iter {
		int hash; /* hash bucket index */
		struct gfs2_sbd sdp; / incore superblock */
		@@ -54,7 +53,6 @@ struct gfs2_glock_iter {

		typedef void (glock_examiner) (struct gfs2_glock gl);

		static int gfs2_dump_lockstate(struct gfs2_sbd *sdp);
		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);
		@@ -70,57 +68,9 @@ static DEFINE_SPINLOCK(lru_lock);
		#define GFS2_GL_HASH_SIZE (1 << GFS2_GL_HASH_SHIFT)
		#define GFS2_GL_HASH_MASK (GFS2_GL_HASH_SIZE - 1)

		static struct gfs2_gl_hash_bucket gl_hash_table[GFS2_GL_HASH_SIZE];
		static struct hlist_bl_head gl_hash_table[GFS2_GL_HASH_SIZE];
		static struct dentry *gfs2_root;

		/*
		* Despite what you might think, the numbers below are not arbitrary :-)
		* They are taken from the ipv4 routing hash code, which is well tested
		* and thus should be nearly optimal. Later on we might tweek the numbers
		* but for now this should be fine.
		*
		* The reason for putting the locks in a separate array from the list heads
		* is that we can have fewer locks than list heads and save memory. We use
		* the same hash function for both, but with a different hash mask.
		*/
		#if defined(CONFIG_SMP) \|\| defined(CONFIG_DEBUG_SPINLOCK) \|\| \
		defined(CONFIG_PROVE_LOCKING)

		#ifdef CONFIG_LOCKDEP
		# define GL_HASH_LOCK_SZ 256
		#else
		# if NR_CPUS >= 32
		# define GL_HASH_LOCK_SZ 4096
		# elif NR_CPUS >= 16
		# define GL_HASH_LOCK_SZ 2048
		# elif NR_CPUS >= 8
		# define GL_HASH_LOCK_SZ 1024
		# elif NR_CPUS >= 4
		# define GL_HASH_LOCK_SZ 512
		# else
		# define GL_HASH_LOCK_SZ 256
		# endif
		#endif

		/* We never want more locks than chains */
		#if GFS2_GL_HASH_SIZE < GL_HASH_LOCK_SZ
		# undef GL_HASH_LOCK_SZ
		# define GL_HASH_LOCK_SZ GFS2_GL_HASH_SIZE
		#endif

		static rwlock_t gl_hash_locks[GL_HASH_LOCK_SZ];

		static inline rwlock_t *gl_lock_addr(unsigned int x)
		{
		return &gl_hash_locks[x & (GL_HASH_LOCK_SZ-1)];
		}
		#else /* not SMP, so no spinlocks required */
		static inline rwlock_t *gl_lock_addr(unsigned int x)
		{
		return NULL;
		}
		#endif

		/**
		* gl_hash() - Turn glock number into hash bucket number
		* @lock: The glock number
		@@ -141,25 +91,35 @@ static unsigned int gl_hash(const struct gfs2_sbd *sdp,
		return h;
		}

		/**
		* glock_free() - Perform a few checks and then release struct gfs2_glock
		* @gl: The glock to release
		*
		* Also calls lock module to release its internal structure for this glock.
		*
		*/
		static inline void spin_lock_bucket(unsigned int hash)
		{
		struct hlist_bl_head *bl = &gl_hash_table[hash];
		bit_spin_lock(0, (unsigned long *)bl);
		}

		static inline void spin_unlock_bucket(unsigned int hash)
		{
		struct hlist_bl_head *bl = &gl_hash_table[hash];
		__bit_spin_unlock(0, (unsigned long *)bl);
		}

		static void gfs2_glock_dealloc(struct rcu_head *rcu)
		{
		struct gfs2_glock *gl = container_of(rcu, struct gfs2_glock, gl_rcu);

		static void glock_free(struct gfs2_glock *gl)
		if (gl->gl_ops->go_flags & GLOF_ASPACE)
		kmem_cache_free(gfs2_glock_aspace_cachep, gl);
		else
		kmem_cache_free(gfs2_glock_cachep, gl);
		}

		void gfs2_glock_free(struct gfs2_glock *gl)
		{
		struct gfs2_sbd *sdp = gl->gl_sbd;
		struct address_space *mapping = gfs2_glock2aspace(gl);
		struct kmem_cache *cachep = gfs2_glock_cachep;

		GLOCK_BUG_ON(gl, mapping && mapping->nrpages);
		trace_gfs2_glock_put(gl);
		if (mapping)
		cachep = gfs2_glock_aspace_cachep;
		sdp->sd_lockstruct.ls_ops->lm_put_lock(cachep, gl);
		call_rcu(&gl->gl_rcu, gfs2_glock_dealloc);
		if (atomic_dec_and_test(&sdp->sd_glock_disposal))
		wake_up(&sdp->sd_glock_wait);
		}

		/**
		@@ -185,35 +145,50 @@ static int demote_ok(const struct gfs2_glock *gl)
		{
		const struct gfs2_glock_operations *glops = gl->gl_ops;

		/* assert_spin_locked(&gl->gl_spin); */

		if (gl->gl_state == LM_ST_UNLOCKED)
		return 0;
		if (!list_empty(&gl->gl_holders))
		if (test_bit(GLF_LFLUSH, &gl->gl_flags))
		return 0;
		if ((gl->gl_name.ln_type != LM_TYPE_INODE) &&
		!list_empty(&gl->gl_holders))
		return 0;
		if (glops->go_demote_ok)
		return glops->go_demote_ok(gl);
		return 1;
		}


		/**
		* gfs2_glock_schedule_for_reclaim - Add a glock to the reclaim list
		* __gfs2_glock_schedule_for_reclaim - Add a glock to the reclaim list
		* @gl: the glock
		*
		* If the glock is demotable, then we add it (or move it) to the end
		* of the glock LRU list.
		*/

		static void gfs2_glock_schedule_for_reclaim(struct gfs2_glock *gl)
		static void __gfs2_glock_schedule_for_reclaim(struct gfs2_glock *gl)
		{
		int may_reclaim;
		may_reclaim = (demote_ok(gl) &&
		(atomic_read(&gl->gl_ref) == 1 \|\|
		(gl->gl_name.ln_type == LM_TYPE_INODE &&
		atomic_read(&gl->gl_ref) <= 2)));
		if (demote_ok(gl)) {
		spin_lock(&lru_lock);
		if (list_empty(&gl->gl_lru) && may_reclaim) {
		list_add_tail(&gl->gl_lru, &lru_list);

		if (!list_empty(&gl->gl_lru))
		list_del_init(&gl->gl_lru);
		else
		atomic_inc(&lru_count);
		}

		list_add_tail(&gl->gl_lru, &lru_list);
		spin_unlock(&lru_lock);
		}
		}

		void gfs2_glock_schedule_for_reclaim(struct gfs2_glock *gl)
		{
		spin_lock(&gl->gl_spin);
		__gfs2_glock_schedule_for_reclaim(gl);
		spin_unlock(&gl->gl_spin);
		}

		/**
		* gfs2_glock_put_nolock() - Decrement reference count on glock
		@@ -227,7 +202,6 @@ void gfs2_glock_put_nolock(struct gfs2_glock *gl)
		{
		if (atomic_dec_and_test(&gl->gl_ref))
		GLOCK_BUG_ON(gl, 1);
		gfs2_glock_schedule_for_reclaim(gl);
		}

		/**
		@@ -236,30 +210,26 @@ void gfs2_glock_put_nolock(struct gfs2_glock *gl)
		*
		*/

		int gfs2_glock_put(struct gfs2_glock *gl)
		void gfs2_glock_put(struct gfs2_glock *gl)
		{
		int rv = 0;
		struct gfs2_sbd *sdp = gl->gl_sbd;
		struct address_space *mapping = gfs2_glock2aspace(gl);

		write_lock(gl_lock_addr(gl->gl_hash));
		if (atomic_dec_and_lock(&gl->gl_ref, &lru_lock)) {
		hlist_del(&gl->gl_list);
		if (atomic_dec_and_test(&gl->gl_ref)) {
		spin_lock_bucket(gl->gl_hash);
		hlist_bl_del_rcu(&gl->gl_list);
		spin_unlock_bucket(gl->gl_hash);
		spin_lock(&lru_lock);
		if (!list_empty(&gl->gl_lru)) {
		list_del_init(&gl->gl_lru);
		atomic_dec(&lru_count);
		}
		spin_unlock(&lru_lock);
		write_unlock(gl_lock_addr(gl->gl_hash));
		GLOCK_BUG_ON(gl, !list_empty(&gl->gl_holders));
		glock_free(gl);
		rv = 1;
		goto out;
		GLOCK_BUG_ON(gl, mapping && mapping->nrpages);
		trace_gfs2_glock_put(gl);
		sdp->sd_lockstruct.ls_ops->lm_put_lock(gl);
		}
		spin_lock(&gl->gl_spin);
		gfs2_glock_schedule_for_reclaim(gl);
		spin_unlock(&gl->gl_spin);
		write_unlock(gl_lock_addr(gl->gl_hash));
		out:
		return rv;
		}

		/**
		@@ -275,16 +245,14 @@ static struct gfs2_glock *search_bucket(unsigned int hash,
		const struct lm_lockname *name)
		{
		struct gfs2_glock *gl;
		struct hlist_node *h;
		struct hlist_bl_node *h;

		hlist_for_each_entry(gl, h, &gl_hash_table[hash].hb_list, gl_list) {
		hlist_bl_for_each_entry_rcu(gl, h, &gl_hash_table[hash], gl_list) {
		if (!lm_name_equal(&gl->gl_name, name))
		continue;
		if (gl->gl_sbd != sdp)
		continue;

		atomic_inc(&gl->gl_ref);

		if (atomic_inc_not_zero(&gl->gl_ref))
		return gl;
		}

		@@ -743,10 +711,11 @@ int gfs2_glock_get(struct gfs2_sbd *sdp, u64 number,
		struct gfs2_glock gl, tmp;
		unsigned int hash = gl_hash(sdp, &name);
		struct address_space *mapping;
		struct kmem_cache *cachep;

		read_lock(gl_lock_addr(hash));
		rcu_read_lock();
		gl = search_bucket(hash, sdp, &name);
		read_unlock(gl_lock_addr(hash));
		rcu_read_unlock();

		*glp = gl;
		if (gl)
		@@ -755,9 +724,10 @@ int gfs2_glock_get(struct gfs2_sbd *sdp, u64 number,
		return -ENOENT;

		if (glops->go_flags & GLOF_ASPACE)
		gl = kmem_cache_alloc(gfs2_glock_aspace_cachep, GFP_KERNEL);
		cachep = gfs2_glock_aspace_cachep;
		else
		gl = kmem_cache_alloc(gfs2_glock_cachep, GFP_KERNEL);
		cachep = gfs2_glock_cachep;
		gl = kmem_cache_alloc(cachep, GFP_KERNEL);
		if (!gl)
		return -ENOMEM;

		@@ -790,15 +760,16 @@ int gfs2_glock_get(struct gfs2_sbd *sdp, u64 number,
		mapping->writeback_index = 0;
		}

		write_lock(gl_lock_addr(hash));
		spin_lock_bucket(hash);
		tmp = search_bucket(hash, sdp, &name);
		if (tmp) {
		write_unlock(gl_lock_addr(hash));
		glock_free(gl);
		spin_unlock_bucket(hash);
		kmem_cache_free(cachep, gl);
		atomic_dec(&sdp->sd_glock_disposal);
		gl = tmp;
		} else {
		hlist_add_head(&gl->gl_list, &gl_hash_table[hash].hb_list);
		write_unlock(gl_lock_addr(hash));
		hlist_bl_add_head_rcu(&gl->gl_list, &gl_hash_table[hash]);
		spin_unlock_bucket(hash);
		}

		*glp = gl;
		@@ -1007,13 +978,13 @@ __acquires(&gl->gl_spin)
		insert_pt = &gh2->gh_list;
		}
		set_bit(GLF_QUEUED, &gl->gl_flags);
		trace_gfs2_glock_queue(gh, 1);
		if (likely(insert_pt == NULL)) {
		list_add_tail(&gh->gh_list, &gl->gl_holders);
		if (unlikely(gh->gh_flags & LM_FLAG_PRIORITY))
		goto do_cancel;
		return;
		}
		trace_gfs2_glock_queue(gh, 1);
		list_add_tail(&gh->gh_list, insert_pt);
		do_cancel:
		gh = list_entry(gl->gl_holders.next, struct gfs2_holder, gh_list);
		@@ -1113,6 +1084,7 @@ void gfs2_glock_dq(struct gfs2_holder *gh)
		!test_bit(GLF_DEMOTE, &gl->gl_flags))
		fast_path = 1;
		}
		__gfs2_glock_schedule_for_reclaim(gl);
		trace_gfs2_glock_queue(gh, 0);
		spin_unlock(&gl->gl_spin);
		if (likely(fast_path))
		@@ -1276,10 +1248,8 @@ int gfs2_glock_nq_m(unsigned int num_gh, struct gfs2_holder *ghs)

		void gfs2_glock_dq_m(unsigned int num_gh, struct gfs2_holder *ghs)
		{
		unsigned int x;

		for (x = 0; x < num_gh; x++)
		gfs2_glock_dq(&ghs[x]);
		while (num_gh--)
		gfs2_glock_dq(&ghs[num_gh]);
		}

		/**
		@@ -1291,10 +1261,8 @@ void gfs2_glock_dq_m(unsigned int num_gh, struct gfs2_holder *ghs)

		void gfs2_glock_dq_uninit_m(unsigned int num_gh, struct gfs2_holder *ghs)
		{
		unsigned int x;

		for (x = 0; x < num_gh; x++)
		gfs2_glock_dq_uninit(&ghs[x]);
		while (num_gh--)
		gfs2_glock_dq_uninit(&ghs[num_gh]);
		}

		void gfs2_glock_cb(struct gfs2_glock *gl, unsigned int state)
		@@ -1440,42 +1408,30 @@ static struct shrinker glock_shrinker = {
		* @sdp: the filesystem
		* @bucket: the bucket
		*
		* Returns: 1 if the bucket has entries
		*/

		static int examine_bucket(glock_examiner examiner, struct gfs2_sbd *sdp,
		static void examine_bucket(glock_examiner examiner, const struct gfs2_sbd *sdp,
		unsigned int hash)
		{
		struct gfs2_glock gl, prev = NULL;
		int has_entries = 0;
		struct hlist_head *head = &gl_hash_table[hash].hb_list;
		struct gfs2_glock *gl;
		struct hlist_bl_head *head = &gl_hash_table[hash];
		struct hlist_bl_node *pos;

		read_lock(gl_lock_addr(hash));
		/* Can't use hlist_for_each_entry - don't want prefetch here */
		if (hlist_empty(head))
		goto out;
		gl = list_entry(head->first, struct gfs2_glock, gl_list);
		while(1) {
		if (!sdp \|\| gl->gl_sbd == sdp) {
		gfs2_glock_hold(gl);
		read_unlock(gl_lock_addr(hash));
		if (prev)
		gfs2_glock_put(prev);
		prev = gl;
		rcu_read_lock();
		hlist_bl_for_each_entry_rcu(gl, pos, head, gl_list) {
		if ((gl->gl_sbd == sdp) && atomic_read(&gl->gl_ref))
		examiner(gl);
		has_entries = 1;
		read_lock(gl_lock_addr(hash));
		}
		if (gl->gl_list.next == NULL)
		break;
		gl = list_entry(gl->gl_list.next, struct gfs2_glock, gl_list);
		}
		out:
		read_unlock(gl_lock_addr(hash));
		if (prev)
		gfs2_glock_put(prev);
		rcu_read_unlock();
		cond_resched();
		return has_entries;
		}

		static void glock_hash_walk(glock_examiner examiner, const struct gfs2_sbd *sdp)
		{
		unsigned x;

		for (x = 0; x < GFS2_GL_HASH_SIZE; x++)
		examine_bucket(examiner, sdp, x);
		}


		@@ -1529,10 +1485,21 @@ static void clear_glock(struct gfs2_glock *gl)

		void gfs2_glock_thaw(struct gfs2_sbd *sdp)
		{
		unsigned x;
		glock_hash_walk(thaw_glock, sdp);
		}

		for (x = 0; x < GFS2_GL_HASH_SIZE; x++)
		examine_bucket(thaw_glock, sdp, x);
		static int dump_glock(struct seq_file seq, struct gfs2_glock gl)
		{
		int ret;
		spin_lock(&gl->gl_spin);
		ret = __dump_glock(seq, gl);
		spin_unlock(&gl->gl_spin);
		return ret;
		}

		static void dump_glock_func(struct gfs2_glock *gl)
		{
		dump_glock(NULL, gl);
		}

		/**
		@@ -1545,13 +1512,10 @@ void gfs2_glock_thaw(struct gfs2_sbd *sdp)

		void gfs2_gl_hash_clear(struct gfs2_sbd *sdp)
		{
		unsigned int x;

		for (x = 0; x < GFS2_GL_HASH_SIZE; x++)
		examine_bucket(clear_glock, sdp, x);
		glock_hash_walk(clear_glock, sdp);
		flush_workqueue(glock_workqueue);
		wait_event(sdp->sd_glock_wait, atomic_read(&sdp->sd_glock_disposal) == 0);
		gfs2_dump_lockstate(sdp);
		glock_hash_walk(dump_glock_func, sdp);
		}

		void gfs2_glock_finish_truncate(struct gfs2_inode *ip)
		@@ -1717,66 +1681,15 @@ static int __dump_glock(struct seq_file seq, const struct gfs2_glock gl)
		return error;
		}

		static int dump_glock(struct seq_file seq, struct gfs2_glock gl)
		{
		int ret;
		spin_lock(&gl->gl_spin);
		ret = __dump_glock(seq, gl);
		spin_unlock(&gl->gl_spin);
		return ret;
		}

		/**
		* gfs2_dump_lockstate - print out the current lockstate
		* @sdp: the filesystem
		* @ub: the buffer to copy the information into
		*
		* If @ub is NULL, dump the lockstate to the console.
		*
		*/

		static int gfs2_dump_lockstate(struct gfs2_sbd *sdp)
		{
		struct gfs2_glock *gl;
		struct hlist_node *h;
		unsigned int x;
		int error = 0;

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

		read_lock(gl_lock_addr(x));

		hlist_for_each_entry(gl, h, &gl_hash_table[x].hb_list, gl_list) {
		if (gl->gl_sbd != sdp)
		continue;

		error = dump_glock(NULL, gl);
		if (error)
		break;
		}

		read_unlock(gl_lock_addr(x));

		if (error)
		break;
		}


		return error;
		}


		int __init gfs2_glock_init(void)
		{
		unsigned i;
		for(i = 0; i < GFS2_GL_HASH_SIZE; i++) {
		INIT_HLIST_HEAD(&gl_hash_table[i].hb_list);
		INIT_HLIST_BL_HEAD(&gl_hash_table[i]);
		}
		#ifdef GL_HASH_LOCK_SZ
		for(i = 0; i < GL_HASH_LOCK_SZ; i++) {
		rwlock_init(&gl_hash_locks[i]);
		}
		#endif

		glock_workqueue = alloc_workqueue("glock_workqueue", WQ_MEM_RECLAIM \|
		WQ_HIGHPRI \| WQ_FREEZABLE, 0);
		@@ -1802,48 +1715,41 @@ void gfs2_glock_exit(void)
		destroy_workqueue(gfs2_delete_workqueue);
		}

		static inline struct gfs2_glock *glock_hash_chain(unsigned hash)
		{
		return hlist_bl_entry(hlist_bl_first_rcu(&gl_hash_table[hash]),
		struct gfs2_glock, gl_list);
		}

		static inline struct gfs2_glock glock_hash_next(struct gfs2_glock gl)
		{
		return hlist_bl_entry(rcu_dereference(gl->gl_list.next),
		struct gfs2_glock, gl_list);
		}

		static int gfs2_glock_iter_next(struct gfs2_glock_iter *gi)
		{
		struct gfs2_glock *gl;

		restart:
		read_lock(gl_lock_addr(gi->hash));
		do {
		gl = gi->gl;
		if (gl) {
		gi->gl = hlist_entry(gl->gl_list.next,
		struct gfs2_glock, gl_list);
		gi->gl = glock_hash_next(gl);
		} else {
		gi->gl = hlist_entry(gl_hash_table[gi->hash].hb_list.first,
		struct gfs2_glock, gl_list);
		gi->gl = glock_hash_chain(gi->hash);
		}
		if (gi->gl)
		gfs2_glock_hold(gi->gl);
		read_unlock(gl_lock_addr(gi->hash));
		if (gl)
		gfs2_glock_put(gl);
		while (gi->gl == NULL) {
		gi->hash++;
		if (gi->hash >= GFS2_GL_HASH_SIZE)
		if (gi->hash >= GFS2_GL_HASH_SIZE) {
		rcu_read_unlock();
		return 1;
		read_lock(gl_lock_addr(gi->hash));
		gi->gl = hlist_entry(gl_hash_table[gi->hash].hb_list.first,
		struct gfs2_glock, gl_list);
		if (gi->gl)
		gfs2_glock_hold(gi->gl);
		read_unlock(gl_lock_addr(gi->hash));
		}

		if (gi->sdp != gi->gl->gl_sbd)
		goto restart;

		return 0;
		gi->gl = glock_hash_chain(gi->hash);
		}
		/* Skip entries for other sb and dead entries */
		} while (gi->sdp != gi->gl->gl_sbd \|\| atomic_read(&gi->gl->gl_ref) == 0);

		static void gfs2_glock_iter_free(struct gfs2_glock_iter *gi)
		{
		if (gi->gl)
		gfs2_glock_put(gi->gl);
		gi->gl = NULL;
		return 0;
		}

		static void gfs2_glock_seq_start(struct seq_file seq, loff_t *pos)
		@@ -1852,12 +1758,11 @@ static void gfs2_glock_seq_start(struct seq_file seq, loff_t *pos)
		loff_t n = *pos;

		gi->hash = 0;
		rcu_read_lock();

		do {
		if (gfs2_glock_iter_next(gi)) {
		gfs2_glock_iter_free(gi);
		if (gfs2_glock_iter_next(gi))
		return NULL;
		}
		} while (n--);

		return gi->gl;
		@@ -1870,10 +1775,8 @@ static void gfs2_glock_seq_next(struct seq_file seq, void *iter_ptr,

		(*pos)++;

		if (gfs2_glock_iter_next(gi)) {
		gfs2_glock_iter_free(gi);
		if (gfs2_glock_iter_next(gi))
		return NULL;
		}

		return gi->gl;
		}
		@@ -1881,7 +1784,10 @@ static void gfs2_glock_seq_next(struct seq_file seq, void *iter_ptr,
		static void gfs2_glock_seq_stop(struct seq_file seq, void iter_ptr)
		{
		struct gfs2_glock_iter *gi = seq->private;
		gfs2_glock_iter_free(gi);

		if (gi->gl)
		rcu_read_unlock();
		gi->gl = NULL;
		}

		static int gfs2_glock_seq_show(struct seq_file seq, void iter_ptr)