Eric Lee / linux-smarc-t335x-v3.2

Commit cd81a4bac67d44742ab0aa1848f4a78e9d7e1093

Authored by Robert Peterson 2007-05-15 01:42:18 +0800

Committed by Steven Whitehouse 2007-07-09 15:22:19 +0800

Exists in master and in 4 other branches

[GFS2] Addendum patch 2 for gfs2_grow

This addendum patch 2 corrects three things:

1. It fixes a stupid mistake in the previous addendum that broke gfs2.
   Ref: https://www.redhat.com/archives/cluster-devel/2007-May/msg00162.html
2. It fixes a problem that Dave Teigland pointed out regarding the
   external declarations in ops_address.h being in the wrong place.
3. It recasts a couple more %llu printks to (unsigned long long)
   as requested by Steve Whitehouse.

I would have loved to put this all in one revised patch, but there was
a rush to get some patches for RHEL5.	Therefore, the previous patches
were applied to the git tree "as is" and therefore, I'm posting another
addendum.  Sorry.

Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>

Showing 5 changed files with 9 additions and 9 deletions Inline Diff

fs/gfs2/glock.c
fs/gfs2/ops_address.c
fs/gfs2/ops_address.h
fs/gfs2/rgrp.c
fs/gfs2/rgrp.h

fs/gfs2/glock.c

Diff comments View file @ cd81a4b

 /*
  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
  * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
  *
  * This copyrighted material is made available to anyone wishing to use,
  * modify, copy, or redistribute it subject to the terms and conditions
  * of the GNU General Public License version 2.
  */
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <linux/completion.h>
 #include <linux/buffer_head.h>
 #include <linux/delay.h>
 #include <linux/sort.h>
 #include <linux/jhash.h>
 #include <linux/kallsyms.h>
 #include <linux/gfs2_ondisk.h>
 #include <linux/list.h>
 #include <linux/lm_interface.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>
 #include <linux/module.h>
 #include <linux/kallsyms.h>
 #include "gfs2.h"
 #include "incore.h"
 #include "glock.h"
 #include "glops.h"
 #include "inode.h"
 #include "lm.h"
 #include "lops.h"
 #include "meta_io.h"
 #include "quota.h"
 #include "super.h"
 #include "util.h"
 struct gfs2_gl_hash_bucket {
         struct hlist_head hb_list;
 };
 struct glock_iter {
 	int hash;                     /* hash bucket index         */
 	struct gfs2_sbd *sdp;         /* incore superblock         */
 	struct gfs2_glock *gl;        /* current glock struct      */
 	struct hlist_head *hb_list;   /* current hash bucket ptr   */
 	struct seq_file *seq;         /* sequence file for debugfs */
 	char string[512];             /* scratch space             */
 };
 typedef void (*glock_examiner) (struct gfs2_glock * gl);
 static int gfs2_dump_lockstate(struct gfs2_sbd *sdp);
 static int dump_glock(struct glock_iter *gi, struct gfs2_glock *gl);
 static void gfs2_glock_xmote_th(struct gfs2_glock *gl, struct gfs2_holder *gh);
 static void gfs2_glock_drop_th(struct gfs2_glock *gl);
 static DECLARE_RWSEM(gfs2_umount_flush_sem);
 static struct dentry *gfs2_root;
 #define GFS2_GL_HASH_SHIFT      15
 #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 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
 /**
  * relaxed_state_ok - is a requested lock compatible with the current lock mode?
  * @actual: the current state of the lock
  * @requested: the lock state that was requested by the caller
  * @flags: the modifier flags passed in by the caller
  *
  * Returns: 1 if the locks are compatible, 0 otherwise
  */
 static inline int relaxed_state_ok(unsigned int actual, unsigned requested,
 				   int flags)
 {
 	if (actual == requested)
 		return 1;
 	if (flags & GL_EXACT)
 		return 0;
 	if (actual == LM_ST_EXCLUSIVE && requested == LM_ST_SHARED)
 		return 1;
 	if (actual != LM_ST_UNLOCKED && (flags & LM_FLAG_ANY))
 		return 1;
 	return 0;
 }
 /**
  * gl_hash() - Turn glock number into hash bucket number
  * @lock: The glock number
  *
  * Returns: The number of the corresponding hash bucket
  */
 static unsigned int gl_hash(const struct gfs2_sbd *sdp,
 			    const struct lm_lockname *name)
 {
 	unsigned int h;
 	h = jhash(&name->ln_number, sizeof(u64), 0);
 	h = jhash(&name->ln_type, sizeof(unsigned int), h);
 	h = jhash(&sdp, sizeof(struct gfs2_sbd *), h);
 	h &= GFS2_GL_HASH_MASK;
 	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 void glock_free(struct gfs2_glock *gl)
 {
 	struct gfs2_sbd *sdp = gl->gl_sbd;
 	struct inode *aspace = gl->gl_aspace;
 	gfs2_lm_put_lock(sdp, gl->gl_lock);
 	if (aspace)
 		gfs2_aspace_put(aspace);
 	kmem_cache_free(gfs2_glock_cachep, gl);
 }
 /**
  * gfs2_glock_hold() - increment reference count on glock
  * @gl: The glock to hold
  *
  */
 void gfs2_glock_hold(struct gfs2_glock *gl)
 {
 	atomic_inc(&gl->gl_ref);
 }
 /**
  * gfs2_glock_put() - Decrement reference count on glock
  * @gl: The glock to put
  *
  */
 int gfs2_glock_put(struct gfs2_glock *gl)
 {
 	int rv = 0;
 	struct gfs2_sbd *sdp = gl->gl_sbd;
 	write_lock(gl_lock_addr(gl->gl_hash));
 	if (atomic_dec_and_test(&gl->gl_ref)) {
 		hlist_del(&gl->gl_list);
 		write_unlock(gl_lock_addr(gl->gl_hash));
 		BUG_ON(spin_is_locked(&gl->gl_spin));
 		gfs2_assert(sdp, gl->gl_state == LM_ST_UNLOCKED);
 		gfs2_assert(sdp, list_empty(&gl->gl_reclaim));
 		gfs2_assert(sdp, list_empty(&gl->gl_holders));
 		gfs2_assert(sdp, list_empty(&gl->gl_waiters1));
 		gfs2_assert(sdp, list_empty(&gl->gl_waiters3));
 		glock_free(gl);
 		rv = 1;
 		goto out;
 	}
 	write_unlock(gl_lock_addr(gl->gl_hash));
 out:
 	return rv;
 }
 /**
  * search_bucket() - Find struct gfs2_glock by lock number
  * @bucket: the bucket to search
  * @name: The lock name
  *
  * Returns: NULL, or the struct gfs2_glock with the requested number
  */
 static struct gfs2_glock *search_bucket(unsigned int hash,
 					const struct gfs2_sbd *sdp,
 					const struct lm_lockname *name)
 {
 	struct gfs2_glock *gl;
 	struct hlist_node *h;
 	hlist_for_each_entry(gl, h, &gl_hash_table[hash].hb_list, gl_list) {
 		if (!lm_name_equal(&gl->gl_name, name))
 			continue;
 		if (gl->gl_sbd != sdp)
 			continue;
 		atomic_inc(&gl->gl_ref);
 		return gl;
 	}
 	return NULL;
 }
 /**
  * gfs2_glock_find() - Find glock by lock number
  * @sdp: The GFS2 superblock
  * @name: The lock name
  *
  * Returns: NULL, or the struct gfs2_glock with the requested number
  */
 static struct gfs2_glock *gfs2_glock_find(const struct gfs2_sbd *sdp,
 					  const struct lm_lockname *name)
 {
 	unsigned int hash = gl_hash(sdp, name);
 	struct gfs2_glock *gl;
 	read_lock(gl_lock_addr(hash));
 	gl = search_bucket(hash, sdp, name);
 	read_unlock(gl_lock_addr(hash));
 	return gl;
 }
 /**
  * gfs2_glock_get() - Get a glock, or create one if one doesn't exist
  * @sdp: The GFS2 superblock
  * @number: the lock number
  * @glops: The glock_operations to use
  * @create: If 0, don't create the glock if it doesn't exist
  * @glp: the glock is returned here
  *
  * This does not lock a glock, just finds/creates structures for one.
  *
  * Returns: errno
  */
 int gfs2_glock_get(struct gfs2_sbd *sdp, u64 number,
 		   const struct gfs2_glock_operations *glops, int create,
 		   struct gfs2_glock **glp)
 {
 	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;
 	read_lock(gl_lock_addr(hash));
 	gl = search_bucket(hash, sdp, &name);
 	read_unlock(gl_lock_addr(hash));
 	if (gl || !create) {
 		*glp = gl;
 		return 0;
 	}
 	gl = kmem_cache_alloc(gfs2_glock_cachep, GFP_KERNEL);
 	if (!gl)
 		return -ENOMEM;
 	gl->gl_flags = 0;
 	gl->gl_name = name;
 	atomic_set(&gl->gl_ref, 1);
 	gl->gl_state = LM_ST_UNLOCKED;
 	gl->gl_hash = hash;
 	gl->gl_owner_pid = 0;
 	gl->gl_ip = 0;
 	gl->gl_ops = glops;
 	gl->gl_req_gh = NULL;
 	gl->gl_req_bh = NULL;
 	gl->gl_vn = 0;
 	gl->gl_stamp = jiffies;
 	gl->gl_object = NULL;
 	gl->gl_sbd = sdp;
 	gl->gl_aspace = NULL;
 	lops_init_le(&gl->gl_le, &gfs2_glock_lops);
 	/* 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;
 		}
 	}
 	error = gfs2_lm_get_lock(sdp, &name, &gl->gl_lock);
 	if (error)
 		goto fail_aspace;
 	write_lock(gl_lock_addr(hash));
 	tmp = search_bucket(hash, sdp, &name);
 	if (tmp) {
 		write_unlock(gl_lock_addr(hash));
 		glock_free(gl);
 		gl = tmp;
 	} else {
 		hlist_add_head(&gl->gl_list, &gl_hash_table[hash].hb_list);
 		write_unlock(gl_lock_addr(hash));
 	}
 	*glp = gl;
 	return 0;
 fail_aspace:
 	if (gl->gl_aspace)
 		gfs2_aspace_put(gl->gl_aspace);
 fail:
 	kmem_cache_free(gfs2_glock_cachep, gl);
 	return error;
 }
 /**
  * gfs2_holder_init - initialize a struct gfs2_holder in the default way
  * @gl: the glock
  * @state: the state we're requesting
  * @flags: the modifier flags
  * @gh: the holder structure
  *
  */
 void gfs2_holder_init(struct gfs2_glock *gl, unsigned int state, unsigned flags,
 		      struct gfs2_holder *gh)
 {
 	INIT_LIST_HEAD(&gh->gh_list);
 	gh->gh_gl = gl;
 	gh->gh_ip = (unsigned long)__builtin_return_address(0);
 	gh->gh_owner_pid = current->pid;
 	gh->gh_state = state;
 	gh->gh_flags = flags;
 	gh->gh_error = 0;
 	gh->gh_iflags = 0;
 	gfs2_glock_hold(gl);
 }
 /**
  * gfs2_holder_reinit - reinitialize a struct gfs2_holder so we can requeue it
  * @state: the state we're requesting
  * @flags: the modifier flags
  * @gh: the holder structure
  *
  * Don't mess with the glock.
  *
  */
 void gfs2_holder_reinit(unsigned int state, unsigned flags, struct gfs2_holder *gh)
 {
 	gh->gh_state = state;
 	gh->gh_flags = flags;
 	gh->gh_iflags = 0;
 	gh->gh_ip = (unsigned long)__builtin_return_address(0);
 }
 /**
  * gfs2_holder_uninit - uninitialize a holder structure (drop glock reference)
  * @gh: the holder structure
  *
  */
 void gfs2_holder_uninit(struct gfs2_holder *gh)
 {
 	gfs2_glock_put(gh->gh_gl);
 	gh->gh_gl = NULL;
 	gh->gh_ip = 0;
 }
 static void gfs2_holder_wake(struct gfs2_holder *gh)
 {
 	clear_bit(HIF_WAIT, &gh->gh_iflags);
 	smp_mb();
 	wake_up_bit(&gh->gh_iflags, HIF_WAIT);
 }
 static int holder_wait(void *word)
 {
         schedule();
         return 0;
 }
 static void wait_on_holder(struct gfs2_holder *gh)
 {
 	might_sleep();
 	wait_on_bit(&gh->gh_iflags, HIF_WAIT, holder_wait, TASK_UNINTERRUPTIBLE);
 }
 /**
  * rq_mutex - process a mutex request in the queue
  * @gh: the glock holder
  *
  * Returns: 1 if the queue is blocked
  */
 static int rq_mutex(struct gfs2_holder *gh)
 {
 	struct gfs2_glock *gl = gh->gh_gl;
 	list_del_init(&gh->gh_list);
 	/*  gh->gh_error never examined.  */
 	set_bit(GLF_LOCK, &gl->gl_flags);
 	clear_bit(HIF_WAIT, &gh->gh_iflags);
 	smp_mb();
 	wake_up_bit(&gh->gh_iflags, HIF_WAIT);
 	return 1;
 }
 /**
  * rq_promote - process a promote request in the queue
  * @gh: the glock holder
  *
  * Acquire a new inter-node lock, or change a lock state to more restrictive.
  *
  * Returns: 1 if the queue is blocked
  */
 static int rq_promote(struct gfs2_holder *gh)
 {
 	struct gfs2_glock *gl = gh->gh_gl;
 	struct gfs2_sbd *sdp = gl->gl_sbd;
 	if (!relaxed_state_ok(gl->gl_state, gh->gh_state, gh->gh_flags)) {
 		if (list_empty(&gl->gl_holders)) {
 			gl->gl_req_gh = gh;
 			set_bit(GLF_LOCK, &gl->gl_flags);
 			spin_unlock(&gl->gl_spin);
 			if (atomic_read(&sdp->sd_reclaim_count) >
 			    gfs2_tune_get(sdp, gt_reclaim_limit) &&
 			    !(gh->gh_flags & LM_FLAG_PRIORITY)) {
 				gfs2_reclaim_glock(sdp);
 				gfs2_reclaim_glock(sdp);
 			}
 			gfs2_glock_xmote_th(gh->gh_gl, gh);
 			spin_lock(&gl->gl_spin);
 		}
 		return 1;
 	}
 	if (list_empty(&gl->gl_holders)) {
 		set_bit(HIF_FIRST, &gh->gh_iflags);
 		set_bit(GLF_LOCK, &gl->gl_flags);
 	} else {
 		struct gfs2_holder *next_gh;
 		if (gh->gh_state == LM_ST_EXCLUSIVE)
 			return 1;
 		next_gh = list_entry(gl->gl_holders.next, struct gfs2_holder,
 				     gh_list);
 		if (next_gh->gh_state == LM_ST_EXCLUSIVE)
 			 return 1;
 	}
 	list_move_tail(&gh->gh_list, &gl->gl_holders);
 	gh->gh_error = 0;
 	set_bit(HIF_HOLDER, &gh->gh_iflags);
 	gfs2_holder_wake(gh);
 	return 0;
 }
 /**
  * rq_demote - process a demote request in the queue
  * @gh: the glock holder
  *
  * Returns: 1 if the queue is blocked
  */
 static int rq_demote(struct gfs2_glock *gl)
 {
 	if (!list_empty(&gl->gl_holders))
 		return 1;
 	if (gl->gl_state == gl->gl_demote_state ||
 	    gl->gl_state == LM_ST_UNLOCKED) {
 		clear_bit(GLF_DEMOTE, &gl->gl_flags);
 		return 0;
 	}
 	set_bit(GLF_LOCK, &gl->gl_flags);
 	spin_unlock(&gl->gl_spin);
 	if (gl->gl_demote_state == LM_ST_UNLOCKED ||
 	    gl->gl_state != LM_ST_EXCLUSIVE)
 		gfs2_glock_drop_th(gl);
 	else
 		gfs2_glock_xmote_th(gl, NULL);
 	spin_lock(&gl->gl_spin);
 	return 0;
 }
 /**
  * run_queue - process holder structures on a glock
  * @gl: the glock
  *
  */
 static void run_queue(struct gfs2_glock *gl)
 {
 	struct gfs2_holder *gh;
 	int blocked = 1;
 	for (;;) {
 		if (test_bit(GLF_LOCK, &gl->gl_flags))
 			break;
 		if (!list_empty(&gl->gl_waiters1)) {
 			gh = list_entry(gl->gl_waiters1.next,
 					struct gfs2_holder, gh_list);
 			if (test_bit(HIF_MUTEX, &gh->gh_iflags))
 				blocked = rq_mutex(gh);
 			else
 				gfs2_assert_warn(gl->gl_sbd, 0);
 		} else if (test_bit(GLF_DEMOTE, &gl->gl_flags)) {
 			blocked = rq_demote(gl);
 		} else if (!list_empty(&gl->gl_waiters3)) {
 			gh = list_entry(gl->gl_waiters3.next,
 					struct gfs2_holder, gh_list);
 			if (test_bit(HIF_PROMOTE, &gh->gh_iflags))
 				blocked = rq_promote(gh);
 			else
 				gfs2_assert_warn(gl->gl_sbd, 0);
 		} else
 			break;
 		if (blocked)
 			break;
 	}
 }
 /**
  * gfs2_glmutex_lock - acquire a local lock on a glock
  * @gl: the glock
  *
  * Gives caller exclusive access to manipulate a glock structure.
  */
 static void gfs2_glmutex_lock(struct gfs2_glock *gl)
 {
 	struct gfs2_holder gh;
 	gfs2_holder_init(gl, 0, 0, &gh);
 	set_bit(HIF_MUTEX, &gh.gh_iflags);
 	if (test_and_set_bit(HIF_WAIT, &gh.gh_iflags))
 		BUG();
 	spin_lock(&gl->gl_spin);
 	if (test_and_set_bit(GLF_LOCK, &gl->gl_flags)) {
 		list_add_tail(&gh.gh_list, &gl->gl_waiters1);
 	} else {
 		gl->gl_owner_pid = current->pid;
 		gl->gl_ip = (unsigned long)__builtin_return_address(0);
 		clear_bit(HIF_WAIT, &gh.gh_iflags);
 		smp_mb();
 		wake_up_bit(&gh.gh_iflags, HIF_WAIT);
 	}
 	spin_unlock(&gl->gl_spin);
 	wait_on_holder(&gh);
 	gfs2_holder_uninit(&gh);
 }
 /**
  * gfs2_glmutex_trylock - try to acquire a local lock on a glock
  * @gl: the glock
  *
  * Returns: 1 if the glock is acquired
  */
 static int gfs2_glmutex_trylock(struct gfs2_glock *gl)
 {
 	int acquired = 1;
 	spin_lock(&gl->gl_spin);
 	if (test_and_set_bit(GLF_LOCK, &gl->gl_flags)) {
 		acquired = 0;
 	} else {
 		gl->gl_owner_pid = current->pid;
 		gl->gl_ip = (unsigned long)__builtin_return_address(0);
 	}
 	spin_unlock(&gl->gl_spin);
 	return acquired;
 }
 /**
  * gfs2_glmutex_unlock - release a local lock on a glock
  * @gl: the glock
  *
  */
 static void gfs2_glmutex_unlock(struct gfs2_glock *gl)
 {
 	spin_lock(&gl->gl_spin);
 	clear_bit(GLF_LOCK, &gl->gl_flags);
 	gl->gl_owner_pid = 0;
 	gl->gl_ip = 0;
 	run_queue(gl);
 	BUG_ON(!spin_is_locked(&gl->gl_spin));
 	spin_unlock(&gl->gl_spin);
 }
 /**
  * handle_callback - process a demote request
  * @gl: the glock
  * @state: the state the caller wants us to change to
  *
  * There are only two requests that we are going to see in actual
  * practise: LM_ST_SHARED and LM_ST_UNLOCKED
  */
 static void handle_callback(struct gfs2_glock *gl, unsigned int state)
 {
 	spin_lock(&gl->gl_spin);
 	if (test_and_set_bit(GLF_DEMOTE, &gl->gl_flags) == 0) {
 		gl->gl_demote_state = state;
 		gl->gl_demote_time = jiffies;
 	} else if (gl->gl_demote_state != LM_ST_UNLOCKED) {
 		gl->gl_demote_state = state;
 	}
 	spin_unlock(&gl->gl_spin);
 }
 /**
  * state_change - record that the glock is now in a different state
  * @gl: the glock
  * @new_state the new state
  *
  */
 static void state_change(struct gfs2_glock *gl, unsigned int new_state)
 {
 	int held1, held2;
 	held1 = (gl->gl_state != LM_ST_UNLOCKED);
 	held2 = (new_state != LM_ST_UNLOCKED);
 	if (held1 != held2) {
 		if (held2)
 			gfs2_glock_hold(gl);
 		else
 			gfs2_glock_put(gl);
 	}
 	gl->gl_state = new_state;
 }
 /**
  * xmote_bh - Called after the lock module is done acquiring a lock
  * @gl: The glock in question
  * @ret: the int returned from the lock module
  *
  */
 static void xmote_bh(struct gfs2_glock *gl, unsigned int ret)
 {
 	struct gfs2_sbd *sdp = gl->gl_sbd;
 	const struct gfs2_glock_operations *glops = gl->gl_ops;
 	struct gfs2_holder *gh = gl->gl_req_gh;
 	int prev_state = gl->gl_state;
 	int op_done = 1;
 	gfs2_assert_warn(sdp, test_bit(GLF_LOCK, &gl->gl_flags));
 	gfs2_assert_warn(sdp, list_empty(&gl->gl_holders));
 	gfs2_assert_warn(sdp, !(ret & LM_OUT_ASYNC));
 	state_change(gl, ret & LM_OUT_ST_MASK);
 	if (prev_state != LM_ST_UNLOCKED && !(ret & LM_OUT_CACHEABLE)) {
 		if (glops->go_inval)
 			glops->go_inval(gl, DIO_METADATA);
 	} else if (gl->gl_state == LM_ST_DEFERRED) {
 		/* We might not want to do this here.
 		   Look at moving to the inode glops. */
 		if (glops->go_inval)
 			glops->go_inval(gl, 0);
 	}
 	/*  Deal with each possible exit condition  */
 	if (!gh) {
 		gl->gl_stamp = jiffies;
 		if (ret & LM_OUT_CANCELED)
 			op_done = 0;
 		else
 			clear_bit(GLF_DEMOTE, &gl->gl_flags);
 	} else {
 		spin_lock(&gl->gl_spin);
 		list_del_init(&gh->gh_list);
 		gh->gh_error = -EIO;
 		if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
 			goto out;
 		gh->gh_error = GLR_CANCELED;
 		if (ret & LM_OUT_CANCELED)
 			goto out;
 		if (relaxed_state_ok(gl->gl_state, gh->gh_state, gh->gh_flags)) {
 			list_add_tail(&gh->gh_list, &gl->gl_holders);
 			gh->gh_error = 0;
 			set_bit(HIF_HOLDER, &gh->gh_iflags);
 			set_bit(HIF_FIRST, &gh->gh_iflags);
 			op_done = 0;
 			goto out;
 		}
 		gh->gh_error = GLR_TRYFAILED;
 		if (gh->gh_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB))
 			goto out;
 		gh->gh_error = -EINVAL;
 		if (gfs2_assert_withdraw(sdp, 0) == -1)
 			fs_err(sdp, "ret = 0x%.8X\n", ret);
 out:
 		spin_unlock(&gl->gl_spin);
 	}
 	if (glops->go_xmote_bh)
 		glops->go_xmote_bh(gl);
 	if (op_done) {
 		spin_lock(&gl->gl_spin);
 		gl->gl_req_gh = NULL;
 		gl->gl_req_bh = NULL;
 		clear_bit(GLF_LOCK, &gl->gl_flags);
 		run_queue(gl);
 		spin_unlock(&gl->gl_spin);
 	}
 	gfs2_glock_put(gl);
 	if (gh)
 		gfs2_holder_wake(gh);
 }
 /**
  * gfs2_glock_xmote_th - Call into the lock module to acquire or change a glock
  * @gl: The glock in question
  * @state: the requested state
  * @flags: modifier flags to the lock call
  *
  */
 void gfs2_glock_xmote_th(struct gfs2_glock *gl, struct gfs2_holder *gh)
 {
 	struct gfs2_sbd *sdp = gl->gl_sbd;
 	int flags = gh ? gh->gh_flags : 0;
 	unsigned state = gh ? gh->gh_state : gl->gl_demote_state;
 	const struct gfs2_glock_operations *glops = gl->gl_ops;
 	int lck_flags = flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB |
 				 LM_FLAG_NOEXP | LM_FLAG_ANY |
 				 LM_FLAG_PRIORITY);
 	unsigned int lck_ret;
 	if (glops->go_xmote_th)
 		glops->go_xmote_th(gl);
 	gfs2_assert_warn(sdp, test_bit(GLF_LOCK, &gl->gl_flags));
 	gfs2_assert_warn(sdp, list_empty(&gl->gl_holders));
 	gfs2_assert_warn(sdp, state != LM_ST_UNLOCKED);
 	gfs2_assert_warn(sdp, state != gl->gl_state);
 	gfs2_glock_hold(gl);
 	gl->gl_req_bh = xmote_bh;
 	lck_ret = gfs2_lm_lock(sdp, gl->gl_lock, gl->gl_state, state, lck_flags);
 	if (gfs2_assert_withdraw(sdp, !(lck_ret & LM_OUT_ERROR)))
 		return;
 	if (lck_ret & LM_OUT_ASYNC)
 		gfs2_assert_warn(sdp, lck_ret == LM_OUT_ASYNC);
 	else
 		xmote_bh(gl, lck_ret);
 }
 /**
  * drop_bh - Called after a lock module unlock completes
  * @gl: the glock
  * @ret: the return status
  *
  * Doesn't wake up the process waiting on the struct gfs2_holder (if any)
  * Doesn't drop the reference on the glock the top half took out
  *
  */
 static void drop_bh(struct gfs2_glock *gl, unsigned int ret)
 {
 	struct gfs2_sbd *sdp = gl->gl_sbd;
 	const struct gfs2_glock_operations *glops = gl->gl_ops;
 	struct gfs2_holder *gh = gl->gl_req_gh;
 	gfs2_assert_warn(sdp, test_bit(GLF_LOCK, &gl->gl_flags));
 	gfs2_assert_warn(sdp, list_empty(&gl->gl_holders));
 	gfs2_assert_warn(sdp, !ret);
 	state_change(gl, LM_ST_UNLOCKED);
 	clear_bit(GLF_DEMOTE, &gl->gl_flags);
 	if (glops->go_inval)
 		glops->go_inval(gl, DIO_METADATA);
 	if (gh) {
 		spin_lock(&gl->gl_spin);
 		list_del_init(&gh->gh_list);
 		gh->gh_error = 0;
 		spin_unlock(&gl->gl_spin);
 	}
 	spin_lock(&gl->gl_spin);
 	gl->gl_req_gh = NULL;
 	gl->gl_req_bh = NULL;
 	clear_bit(GLF_LOCK, &gl->gl_flags);
 	run_queue(gl);
 	spin_unlock(&gl->gl_spin);
 	gfs2_glock_put(gl);
 	if (gh)
 		gfs2_holder_wake(gh);
 }
 /**
  * gfs2_glock_drop_th - call into the lock module to unlock a lock
  * @gl: the glock
  *
  */
 static void gfs2_glock_drop_th(struct gfs2_glock *gl)
 {
 	struct gfs2_sbd *sdp = gl->gl_sbd;
 	const struct gfs2_glock_operations *glops = gl->gl_ops;
 	unsigned int ret;
 	if (glops->go_drop_th)
 		glops->go_drop_th(gl);
 	gfs2_assert_warn(sdp, test_bit(GLF_LOCK, &gl->gl_flags));
 	gfs2_assert_warn(sdp, list_empty(&gl->gl_holders));
 	gfs2_assert_warn(sdp, gl->gl_state != LM_ST_UNLOCKED);
 	gfs2_glock_hold(gl);
 	gl->gl_req_bh = drop_bh;
 	ret = gfs2_lm_unlock(sdp, gl->gl_lock, gl->gl_state);
 	if (gfs2_assert_withdraw(sdp, !(ret & LM_OUT_ERROR)))
 		return;
 	if (!ret)
 		drop_bh(gl, ret);
 	else
 		gfs2_assert_warn(sdp, ret == LM_OUT_ASYNC);
 }
 /**
  * do_cancels - cancel requests for locks stuck waiting on an expire flag
  * @gh: the LM_FLAG_PRIORITY holder waiting to acquire the lock
  *
  * Don't cancel GL_NOCANCEL requests.
  */
 static void do_cancels(struct gfs2_holder *gh)
 {
 	struct gfs2_glock *gl = gh->gh_gl;
 	spin_lock(&gl->gl_spin);
 	while (gl->gl_req_gh != gh &&
 	       !test_bit(HIF_HOLDER, &gh->gh_iflags) &&
 	       !list_empty(&gh->gh_list)) {
 		if (gl->gl_req_bh && !(gl->gl_req_gh &&
 				     (gl->gl_req_gh->gh_flags & GL_NOCANCEL))) {
 			spin_unlock(&gl->gl_spin);
 			gfs2_lm_cancel(gl->gl_sbd, gl->gl_lock);
 			msleep(100);
 			spin_lock(&gl->gl_spin);
 		} else {
 			spin_unlock(&gl->gl_spin);
 			msleep(100);
 			spin_lock(&gl->gl_spin);
 		}
 	}
 	spin_unlock(&gl->gl_spin);
 }
 /**
  * glock_wait_internal - wait on a glock acquisition
  * @gh: the glock holder
  *
  * Returns: 0 on success
  */
 static int glock_wait_internal(struct gfs2_holder *gh)
 {
 	struct gfs2_glock *gl = gh->gh_gl;
 	struct gfs2_sbd *sdp = gl->gl_sbd;
 	const struct gfs2_glock_operations *glops = gl->gl_ops;
 	if (test_bit(HIF_ABORTED, &gh->gh_iflags))
 		return -EIO;
 	if (gh->gh_flags & (LM_FLAG_TRY | LM_FLAG_TRY_1CB)) {
 		spin_lock(&gl->gl_spin);
 		if (gl->gl_req_gh != gh &&
 		    !test_bit(HIF_HOLDER, &gh->gh_iflags) &&
 		    !list_empty(&gh->gh_list)) {
 			list_del_init(&gh->gh_list);
 			gh->gh_error = GLR_TRYFAILED;
 			run_queue(gl);
 			spin_unlock(&gl->gl_spin);
 			return gh->gh_error;
 		}
 		spin_unlock(&gl->gl_spin);
 	}
 	if (gh->gh_flags & LM_FLAG_PRIORITY)
 		do_cancels(gh);
 	wait_on_holder(gh);
 	if (gh->gh_error)
 		return gh->gh_error;
 	gfs2_assert_withdraw(sdp, test_bit(HIF_HOLDER, &gh->gh_iflags));
 	gfs2_assert_withdraw(sdp, relaxed_state_ok(gl->gl_state, gh->gh_state,
 						   gh->gh_flags));
 	if (test_bit(HIF_FIRST, &gh->gh_iflags)) {
 		gfs2_assert_warn(sdp, test_bit(GLF_LOCK, &gl->gl_flags));
 		if (glops->go_lock) {
 			gh->gh_error = glops->go_lock(gh);
 			if (gh->gh_error) {
 				spin_lock(&gl->gl_spin);
 				list_del_init(&gh->gh_list);
 				spin_unlock(&gl->gl_spin);
 			}
 		}
 		spin_lock(&gl->gl_spin);
 		gl->gl_req_gh = NULL;
 		gl->gl_req_bh = NULL;
 		clear_bit(GLF_LOCK, &gl->gl_flags);
 		run_queue(gl);
 		spin_unlock(&gl->gl_spin);
 	}
 	return gh->gh_error;
 }
 static inline struct gfs2_holder *
 find_holder_by_owner(struct list_head *head, pid_t pid)
 {
 	struct gfs2_holder *gh;
 	list_for_each_entry(gh, head, gh_list) {
 		if (gh->gh_owner_pid == pid)
 			return gh;
 	}
 	return NULL;
 }
 static void print_dbg(struct glock_iter *gi, const char *fmt, ...)
 {
 	va_list args;
 	va_start(args, fmt);
 	if (gi) {
 		vsprintf(gi->string, fmt, args);
 		seq_printf(gi->seq, gi->string);
 	}
 	else
 		vprintk(fmt, args);
 	va_end(args);
 }
 /**
  * add_to_queue - Add a holder to the wait queue (but look for recursion)
  * @gh: the holder structure to add
  *
  */
 static void add_to_queue(struct gfs2_holder *gh)
 {
 	struct gfs2_glock *gl = gh->gh_gl;
 	struct gfs2_holder *existing;
 	BUG_ON(!gh->gh_owner_pid);
 	if (test_and_set_bit(HIF_WAIT, &gh->gh_iflags))
 		BUG();
 	existing = find_holder_by_owner(&gl->gl_holders, gh->gh_owner_pid);
 	if (existing) {
 		print_symbol(KERN_WARNING "original: %s\n", existing->gh_ip);
 		printk(KERN_INFO "pid : %d\n", existing->gh_owner_pid);
 		printk(KERN_INFO "lock type : %d lock state : %d\n",
 				existing->gh_gl->gl_name.ln_type, existing->gh_gl->gl_state);
 		print_symbol(KERN_WARNING "new: %s\n", gh->gh_ip);
 		printk(KERN_INFO "pid : %d\n", gh->gh_owner_pid);
 		printk(KERN_INFO "lock type : %d lock state : %d\n",
 				gl->gl_name.ln_type, gl->gl_state);
 		BUG();
 	}
 	existing = find_holder_by_owner(&gl->gl_waiters3, gh->gh_owner_pid);
 	if (existing) {
 		print_symbol(KERN_WARNING "original: %s\n", existing->gh_ip);
 		print_symbol(KERN_WARNING "new: %s\n", gh->gh_ip);
 		BUG();
 	}
 	if (gh->gh_flags & LM_FLAG_PRIORITY)
 		list_add(&gh->gh_list, &gl->gl_waiters3);
 	else
 		list_add_tail(&gh->gh_list, &gl->gl_waiters3);
 }
 /**
  * gfs2_glock_nq - enqueue a struct gfs2_holder onto a glock (acquire a glock)
  * @gh: the holder structure
  *
  * if (gh->gh_flags & GL_ASYNC), this never returns an error
  *
  * Returns: 0, GLR_TRYFAILED, or errno on failure
  */
 int gfs2_glock_nq(struct gfs2_holder *gh)
 {
 	struct gfs2_glock *gl = gh->gh_gl;
 	struct gfs2_sbd *sdp = gl->gl_sbd;
 	int error = 0;
 restart:
 	if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags))) {
 		set_bit(HIF_ABORTED, &gh->gh_iflags);
 		return -EIO;
 	}
 	set_bit(HIF_PROMOTE, &gh->gh_iflags);
 	spin_lock(&gl->gl_spin);
 	add_to_queue(gh);
 	run_queue(gl);
 	spin_unlock(&gl->gl_spin);
 	if (!(gh->gh_flags & GL_ASYNC)) {
 		error = glock_wait_internal(gh);
 		if (error == GLR_CANCELED) {
 			msleep(100);
 			goto restart;
 		}
 	}
 	return error;
 }
 /**
  * gfs2_glock_poll - poll to see if an async request has been completed
  * @gh: the holder
  *
  * Returns: 1 if the request is ready to be gfs2_glock_wait()ed on
  */
 int gfs2_glock_poll(struct gfs2_holder *gh)
 {
 	struct gfs2_glock *gl = gh->gh_gl;
 	int ready = 0;
 	spin_lock(&gl->gl_spin);
 	if (test_bit(HIF_HOLDER, &gh->gh_iflags))
 		ready = 1;
 	else if (list_empty(&gh->gh_list)) {
 		if (gh->gh_error == GLR_CANCELED) {
 			spin_unlock(&gl->gl_spin);
 			msleep(100);
 			if (gfs2_glock_nq(gh))
 				return 1;
 			return 0;
 		} else
 			ready = 1;
 	}
 	spin_unlock(&gl->gl_spin);
 	return ready;
 }
 /**
  * gfs2_glock_wait - wait for a lock acquisition that ended in a GLR_ASYNC
  * @gh: the holder structure
  *
  * Returns: 0, GLR_TRYFAILED, or errno on failure
  */
 int gfs2_glock_wait(struct gfs2_holder *gh)
 {
 	int error;
 	error = glock_wait_internal(gh);
 	if (error == GLR_CANCELED) {
 		msleep(100);
 		gh->gh_flags &= ~GL_ASYNC;
 		error = gfs2_glock_nq(gh);
 	}
 	return error;
 }
 /**
  * gfs2_glock_dq - dequeue a struct gfs2_holder from a glock (release a glock)
  * @gh: the glock holder
  *
  */
 void gfs2_glock_dq(struct gfs2_holder *gh)
 {
 	struct gfs2_glock *gl = gh->gh_gl;
 	const struct gfs2_glock_operations *glops = gl->gl_ops;
 	if (gh->gh_flags & GL_NOCACHE)
 		handle_callback(gl, LM_ST_UNLOCKED);
 	gfs2_glmutex_lock(gl);
 	spin_lock(&gl->gl_spin);
 	list_del_init(&gh->gh_list);
 	if (list_empty(&gl->gl_holders)) {
 		spin_unlock(&gl->gl_spin);
 		if (glops->go_unlock)
 			glops->go_unlock(gh);
 		spin_lock(&gl->gl_spin);
 		gl->gl_stamp = jiffies;
 	}
 	clear_bit(GLF_LOCK, &gl->gl_flags);
 	run_queue(gl);
 	spin_unlock(&gl->gl_spin);
 }
 /**
  * gfs2_glock_dq_uninit - dequeue a holder from a glock and initialize it
  * @gh: the holder structure
  *
  */
 void gfs2_glock_dq_uninit(struct gfs2_holder *gh)
 {
 	gfs2_glock_dq(gh);
 	gfs2_holder_uninit(gh);
 }
 /**
  * gfs2_glock_nq_num - acquire a glock based on lock number
  * @sdp: the filesystem
  * @number: the lock number
  * @glops: the glock operations for the type of glock
  * @state: the state to acquire the glock in
  * @flags: modifier flags for the aquisition
  * @gh: the struct gfs2_holder
  *
  * Returns: errno
  */
 int gfs2_glock_nq_num(struct gfs2_sbd *sdp, u64 number,
 		      const struct gfs2_glock_operations *glops,
 		      unsigned int state, int flags, struct gfs2_holder *gh)
 {
 	struct gfs2_glock *gl;
 	int error;
 	error = gfs2_glock_get(sdp, number, glops, CREATE, &gl);
 	if (!error) {
 		error = gfs2_glock_nq_init(gl, state, flags, gh);
 		gfs2_glock_put(gl);
 	}
 	return error;
 }
 /**
  * glock_compare - Compare two struct gfs2_glock structures for sorting
  * @arg_a: the first structure
  * @arg_b: the second structure
  *
  */
 static int glock_compare(const void *arg_a, const void *arg_b)
 {
 	const struct gfs2_holder *gh_a = *(const struct gfs2_holder **)arg_a;
 	const struct gfs2_holder *gh_b = *(const struct gfs2_holder **)arg_b;
 	const struct lm_lockname *a = &gh_a->gh_gl->gl_name;
 	const struct lm_lockname *b = &gh_b->gh_gl->gl_name;
 	if (a->ln_number > b->ln_number)
 		return 1;
 	if (a->ln_number < b->ln_number)
 		return -1;
 	BUG_ON(gh_a->gh_gl->gl_ops->go_type == gh_b->gh_gl->gl_ops->go_type);
 	return 0;
 }
 /**
  * nq_m_sync - synchonously acquire more than one glock in deadlock free order
  * @num_gh: the number of structures
  * @ghs: an array of struct gfs2_holder structures
  *
  * Returns: 0 on success (all glocks acquired),
  *          errno on failure (no glocks acquired)
  */
 static int nq_m_sync(unsigned int num_gh, struct gfs2_holder *ghs,
 		     struct gfs2_holder **p)
 {
 	unsigned int x;
 	int error = 0;
 	for (x = 0; x < num_gh; x++)
 		p[x] = &ghs[x];
 	sort(p, num_gh, sizeof(struct gfs2_holder *), glock_compare, NULL);
 	for (x = 0; x < num_gh; x++) {
 		p[x]->gh_flags &= ~(LM_FLAG_TRY | GL_ASYNC);
 		error = gfs2_glock_nq(p[x]);
 		if (error) {
 			while (x--)
 				gfs2_glock_dq(p[x]);
 			break;
 		}
 	}
 	return error;
 }
 /**
  * gfs2_glock_nq_m - acquire multiple glocks
  * @num_gh: the number of structures
  * @ghs: an array of struct gfs2_holder structures
  *
  * Figure out how big an impact this function has.  Either:
  * 1) Replace this code with code that calls gfs2_glock_prefetch()
  * 2) Forget async stuff and just call nq_m_sync()
  * 3) Leave it like it is
  *
  * Returns: 0 on success (all glocks acquired),
  *          errno on failure (no glocks acquired)
  */
 int gfs2_glock_nq_m(unsigned int num_gh, struct gfs2_holder *ghs)
 {
 	int *e;
 	unsigned int x;
 	int borked = 0, serious = 0;
 	int error = 0;
 	if (!num_gh)
 		return 0;
 	if (num_gh == 1) {
 		ghs->gh_flags &= ~(LM_FLAG_TRY | GL_ASYNC);
 		return gfs2_glock_nq(ghs);
 	}
 	e = kcalloc(num_gh, sizeof(struct gfs2_holder *), GFP_KERNEL);
 	if (!e)
 		return -ENOMEM;
 	for (x = 0; x < num_gh; x++) {
 		ghs[x].gh_flags |= LM_FLAG_TRY | GL_ASYNC;
 		error = gfs2_glock_nq(&ghs[x]);
 		if (error) {
 			borked = 1;
 			serious = error;
 			num_gh = x;
 			break;
 		}
 	}
 	for (x = 0; x < num_gh; x++) {
 		error = e[x] = glock_wait_internal(&ghs[x]);
 		if (error) {
 			borked = 1;
 			if (error != GLR_TRYFAILED && error != GLR_CANCELED)
 				serious = error;
 		}
 	}
 	if (!borked) {
 		kfree(e);
 		return 0;
 	}
 	for (x = 0; x < num_gh; x++)
 		if (!e[x])
 			gfs2_glock_dq(&ghs[x]);
 	if (serious)
 		error = serious;
 	else {
 		for (x = 0; x < num_gh; x++)
 			gfs2_holder_reinit(ghs[x].gh_state, ghs[x].gh_flags,
 					  &ghs[x]);
 		error = nq_m_sync(num_gh, ghs, (struct gfs2_holder **)e);
 	}
 	kfree(e);
 	return error;
 }
 /**
  * gfs2_glock_dq_m - release multiple glocks
  * @num_gh: the number of structures
  * @ghs: an array of struct gfs2_holder structures
  *
  */
 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]);
 }
 /**
  * gfs2_glock_dq_uninit_m - release multiple glocks
  * @num_gh: the number of structures
  * @ghs: an array of struct gfs2_holder structures
  *
  */
 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]);
 }
 /**
  * gfs2_lvb_hold - attach a LVB from a glock
  * @gl: The glock in question
  *
  */
 int gfs2_lvb_hold(struct gfs2_glock *gl)
 {
 	int error;
 	gfs2_glmutex_lock(gl);
 	if (!atomic_read(&gl->gl_lvb_count)) {
 		error = gfs2_lm_hold_lvb(gl->gl_sbd, gl->gl_lock, &gl->gl_lvb);
 		if (error) {
 			gfs2_glmutex_unlock(gl);
 			return error;
 		}
 		gfs2_glock_hold(gl);
 	}
 	atomic_inc(&gl->gl_lvb_count);
 	gfs2_glmutex_unlock(gl);
 	return 0;
 }
 /**
  * gfs2_lvb_unhold - detach a LVB from a glock
  * @gl: The glock in question
  *
  */
 void gfs2_lvb_unhold(struct gfs2_glock *gl)
 {
 	gfs2_glock_hold(gl);
 	gfs2_glmutex_lock(gl);
 	gfs2_assert(gl->gl_sbd, atomic_read(&gl->gl_lvb_count) > 0);
 	if (atomic_dec_and_test(&gl->gl_lvb_count)) {
 		gfs2_lm_unhold_lvb(gl->gl_sbd, gl->gl_lock, gl->gl_lvb);
 		gl->gl_lvb = NULL;
 		gfs2_glock_put(gl);
 	}
 	gfs2_glmutex_unlock(gl);
 	gfs2_glock_put(gl);
 }
 static void blocking_cb(struct gfs2_sbd *sdp, struct lm_lockname *name,
 			unsigned int state)
 {
 	struct gfs2_glock *gl;
 	gl = gfs2_glock_find(sdp, name);
 	if (!gl)
 		return;
 	handle_callback(gl, state);
 	spin_lock(&gl->gl_spin);
 	run_queue(gl);
 	spin_unlock(&gl->gl_spin);
 	gfs2_glock_put(gl);
 }
 /**
  * gfs2_glock_cb - Callback used by locking module
  * @sdp: Pointer to the superblock
  * @type: Type of callback
  * @data: Type dependent data pointer
  *
  * Called by the locking module when it wants to tell us something.
  * Either we need to drop a lock, one of our ASYNC requests completed, or
  * a journal from another client needs to be recovered.
  */
 void gfs2_glock_cb(void *cb_data, unsigned int type, void *data)
 {
 	struct gfs2_sbd *sdp = cb_data;
 	switch (type) {
 	case LM_CB_NEED_E:
 		blocking_cb(sdp, data, LM_ST_UNLOCKED);
 		return;
 	case LM_CB_NEED_D:
 		blocking_cb(sdp, data, LM_ST_DEFERRED);
 		return;
 	case LM_CB_NEED_S:
 		blocking_cb(sdp, data, LM_ST_SHARED);
 		return;
 	case LM_CB_ASYNC: {
 		struct lm_async_cb *async = data;
 		struct gfs2_glock *gl;
 		down_read(&gfs2_umount_flush_sem);
 		gl = gfs2_glock_find(sdp, &async->lc_name);
 		if (gfs2_assert_warn(sdp, gl))
 			return;
 		if (!gfs2_assert_warn(sdp, gl->gl_req_bh))
 			gl->gl_req_bh(gl, async->lc_ret);
 		gfs2_glock_put(gl);
 		up_read(&gfs2_umount_flush_sem);
 		return;
 	}
 	case LM_CB_NEED_RECOVERY:
 		gfs2_jdesc_make_dirty(sdp, *(unsigned int *)data);
 		if (sdp->sd_recoverd_process)
 			wake_up_process(sdp->sd_recoverd_process);
 		return;
 	case LM_CB_DROPLOCKS:
 		gfs2_gl_hash_clear(sdp, NO_WAIT);
 		gfs2_quota_scan(sdp);
 		return;
 	default:
 		gfs2_assert_warn(sdp, 0);
 		return;
 	}
 }
 /**
  * demote_ok - Check to see if it's ok to unlock a glock
  * @gl: the glock
  *
  * Returns: 1 if it's ok
  */
 static int demote_ok(struct gfs2_glock *gl)
 {
 	const struct gfs2_glock_operations *glops = gl->gl_ops;
 	int demote = 1;
 	if (test_bit(GLF_STICKY, &gl->gl_flags))
 		demote = 0;
 	else if (glops->go_demote_ok)
 		demote = glops->go_demote_ok(gl);
 	return demote;
 }
 /**
  * gfs2_glock_schedule_for_reclaim - Add a glock to the reclaim list
  * @gl: the glock
  *
  */
 void gfs2_glock_schedule_for_reclaim(struct gfs2_glock *gl)
 {
 	struct gfs2_sbd *sdp = gl->gl_sbd;
 	spin_lock(&sdp->sd_reclaim_lock);
 	if (list_empty(&gl->gl_reclaim)) {
 		gfs2_glock_hold(gl);
 		list_add(&gl->gl_reclaim, &sdp->sd_reclaim_list);
 		atomic_inc(&sdp->sd_reclaim_count);
 	}
 	spin_unlock(&sdp->sd_reclaim_lock);
 	wake_up(&sdp->sd_reclaim_wq);
 }
 /**
  * gfs2_reclaim_glock - process the next glock on the filesystem's reclaim list
  * @sdp: the filesystem
  *
  * Called from gfs2_glockd() glock reclaim daemon, or when promoting a
  * different glock and we notice that there are a lot of glocks in the
  * reclaim list.
  *
  */
 void gfs2_reclaim_glock(struct gfs2_sbd *sdp)
 {
 	struct gfs2_glock *gl;
 	spin_lock(&sdp->sd_reclaim_lock);
 	if (list_empty(&sdp->sd_reclaim_list)) {
 		spin_unlock(&sdp->sd_reclaim_lock);
 		return;
 	}
 	gl = list_entry(sdp->sd_reclaim_list.next,
 			struct gfs2_glock, gl_reclaim);
 	list_del_init(&gl->gl_reclaim);
 	spin_unlock(&sdp->sd_reclaim_lock);
 	atomic_dec(&sdp->sd_reclaim_count);
 	atomic_inc(&sdp->sd_reclaimed);
 	if (gfs2_glmutex_trylock(gl)) {
 		if (list_empty(&gl->gl_holders) &&
 		    gl->gl_state != LM_ST_UNLOCKED && demote_ok(gl))
 			handle_callback(gl, LM_ST_UNLOCKED);
 		gfs2_glmutex_unlock(gl);
 	}
 	gfs2_glock_put(gl);
 }
 /**
  * examine_bucket - Call a function for glock in a hash bucket
  * @examiner: the function
  * @sdp: the filesystem
  * @bucket: the bucket
  *
  * Returns: 1 if the bucket has entries
  */
 static int examine_bucket(glock_examiner examiner, 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;
 	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 (gl->gl_sbd == sdp) {
 			gfs2_glock_hold(gl);
 			read_unlock(gl_lock_addr(hash));
 			if (prev)
 				gfs2_glock_put(prev);
 			prev = gl;
 			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);
 	return has_entries;
 }
 /**
  * scan_glock - look at a glock and see if we can reclaim it
  * @gl: the glock to look at
  *
  */
 static void scan_glock(struct gfs2_glock *gl)
 {
 	if (gl->gl_ops == &gfs2_inode_glops && gl->gl_object)
 		return;
 	if (gfs2_glmutex_trylock(gl)) {
 		if (list_empty(&gl->gl_holders) &&
 		    gl->gl_state != LM_ST_UNLOCKED && demote_ok(gl))
 			goto out_schedule;
 		gfs2_glmutex_unlock(gl);
 	}
 	return;
 out_schedule:
 	gfs2_glmutex_unlock(gl);
 	gfs2_glock_schedule_for_reclaim(gl);
 }
 /**
  * gfs2_scand_internal - Look for glocks and inodes to toss from memory
  * @sdp: the filesystem
  *
  */
 void gfs2_scand_internal(struct gfs2_sbd *sdp)
 {
 	unsigned int x;
 	for (x = 0; x < GFS2_GL_HASH_SIZE; x++)
 		examine_bucket(scan_glock, sdp, x);
 }
 /**
  * clear_glock - look at a glock and see if we can free it from glock cache
  * @gl: the glock to look at
  *
  */
 static void clear_glock(struct gfs2_glock *gl)
 {
 	struct gfs2_sbd *sdp = gl->gl_sbd;
 	int released;
 	spin_lock(&sdp->sd_reclaim_lock);
 	if (!list_empty(&gl->gl_reclaim)) {
 		list_del_init(&gl->gl_reclaim);
 		atomic_dec(&sdp->sd_reclaim_count);
 		spin_unlock(&sdp->sd_reclaim_lock);
 		released = gfs2_glock_put(gl);
 		gfs2_assert(sdp, !released);
 	} else {
 		spin_unlock(&sdp->sd_reclaim_lock);
 	}
 	if (gfs2_glmutex_trylock(gl)) {
 		if (list_empty(&gl->gl_holders) &&
 		    gl->gl_state != LM_ST_UNLOCKED)
 			handle_callback(gl, LM_ST_UNLOCKED);
 		gfs2_glmutex_unlock(gl);
 	}
 }
 /**
  * gfs2_gl_hash_clear - Empty out the glock hash table
  * @sdp: the filesystem
  * @wait: wait until it's all gone
  *
  * Called when unmounting the filesystem, or when inter-node lock manager
  * requests DROPLOCKS because it is running out of capacity.
  */
 void gfs2_gl_hash_clear(struct gfs2_sbd *sdp, int wait)
 {
 	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 (!wait || !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);
 	}
 }
 /*
  *  Diagnostic routines to help debug distributed deadlock
  */
 static void gfs2_print_symbol(struct glock_iter *gi, const char *fmt,
                               unsigned long address)
 {
 	char buffer[KSYM_SYMBOL_LEN];
 	sprint_symbol(buffer, address);
 	print_dbg(gi, fmt, buffer);
 }
 /**
  * dump_holder - print information about a glock holder
  * @str: a string naming the type of holder
  * @gh: the glock holder
  *
  * Returns: 0 on success, -ENOBUFS when we run out of space
  */
 static int dump_holder(struct glock_iter *gi, char *str,
 		       struct gfs2_holder *gh)
 {
 	unsigned int x;
 	struct task_struct *gh_owner;
 	print_dbg(gi, "  %s\n", str);
 	if (gh->gh_owner_pid) {
 		print_dbg(gi, "    owner = %ld ", (long)gh->gh_owner_pid);
 		gh_owner = find_task_by_pid(gh->gh_owner_pid);
 		if (gh_owner)
 			print_dbg(gi, "(%s)\n", gh_owner->comm);
 		else
 			print_dbg(gi, "(ended)\n");
 	} else
 		print_dbg(gi, "    owner = -1\n");
 	print_dbg(gi, "    gh_state = %u\n", gh->gh_state);
 	print_dbg(gi, "    gh_flags =");
 	for (x = 0; x < 32; x++)
 		if (gh->gh_flags & (1 << x))
 			print_dbg(gi, " %u", x);
 	print_dbg(gi, " \n");
 	print_dbg(gi, "    error = %d\n", gh->gh_error);
 	print_dbg(gi, "    gh_iflags =");
 	for (x = 0; x < 32; x++)
 		if (test_bit(x, &gh->gh_iflags))
 			print_dbg(gi, " %u", x);
 	print_dbg(gi, " \n");
         gfs2_print_symbol(gi, "    initialized at: %s\n", gh->gh_ip);
 	return 0;
 }
 /**
  * dump_inode - print information about an inode
  * @ip: the inode
  *
  * Returns: 0 on success, -ENOBUFS when we run out of space
  */
 static int dump_inode(struct glock_iter *gi, struct gfs2_inode *ip)
 {
 	unsigned int x;
 	print_dbg(gi, "  Inode:\n");
 	print_dbg(gi, "    num = %llu/%llu\n",
-		    ip->i_num.no_formal_ino, ip->i_num.no_addr);
+		  (unsigned long long)ip->i_num.no_formal_ino,
+		  (unsigned long long)ip->i_num.no_addr);
 	print_dbg(gi, "    type = %u\n", IF2DT(ip->i_inode.i_mode));
 	print_dbg(gi, "    i_flags =");
 	for (x = 0; x < 32; x++)
 		if (test_bit(x, &ip->i_flags))
 			print_dbg(gi, " %u", x);
 	print_dbg(gi, " \n");
 	return 0;
 }
 /**
  * dump_glock - print information about a glock
  * @gl: the glock
  * @count: where we are in the buffer
  *
  * Returns: 0 on success, -ENOBUFS when we run out of space
  */
 static int dump_glock(struct glock_iter *gi, struct gfs2_glock *gl)
 {
 	struct gfs2_holder *gh;
 	unsigned int x;
 	int error = -ENOBUFS;
 	struct task_struct *gl_owner;
 	spin_lock(&gl->gl_spin);
 	print_dbg(gi, "Glock 0x%p (%u, %llu)\n", gl, gl->gl_name.ln_type,
 		   (unsigned long long)gl->gl_name.ln_number);
 	print_dbg(gi, "  gl_flags =");
 	for (x = 0; x < 32; x++) {
 		if (test_bit(x, &gl->gl_flags))
 			print_dbg(gi, " %u", x);
 	}
 	if (!test_bit(GLF_LOCK, &gl->gl_flags))
 		print_dbg(gi, " (unlocked)");
 	print_dbg(gi, " \n");
 	print_dbg(gi, "  gl_ref = %d\n", atomic_read(&gl->gl_ref));
 	print_dbg(gi, "  gl_state = %u\n", gl->gl_state);
 	if (gl->gl_owner_pid) {
 		gl_owner = find_task_by_pid(gl->gl_owner_pid);
 		if (gl_owner)
 			print_dbg(gi, "  gl_owner = pid %d (%s)\n",
 				  gl->gl_owner_pid, gl_owner->comm);
 		else
 			print_dbg(gi, "  gl_owner = %d (ended)\n",
 				  gl->gl_owner_pid);
 	} else
 		print_dbg(gi, "  gl_owner = -1\n");
 	print_dbg(gi, "  gl_ip = %lu\n", gl->gl_ip);
 	print_dbg(gi, "  req_gh = %s\n", (gl->gl_req_gh) ? "yes" : "no");
 	print_dbg(gi, "  req_bh = %s\n", (gl->gl_req_bh) ? "yes" : "no");
 	print_dbg(gi, "  lvb_count = %d\n", atomic_read(&gl->gl_lvb_count));
 	print_dbg(gi, "  object = %s\n", (gl->gl_object) ? "yes" : "no");
 	print_dbg(gi, "  le = %s\n",
 		   (list_empty(&gl->gl_le.le_list)) ? "no" : "yes");
 	print_dbg(gi, "  reclaim = %s\n",
 		   (list_empty(&gl->gl_reclaim)) ? "no" : "yes");
 	if (gl->gl_aspace)
 		print_dbg(gi, "  aspace = 0x%p nrpages = %lu\n", gl->gl_aspace,
 			   gl->gl_aspace->i_mapping->nrpages);
 	else
 		print_dbg(gi, "  aspace = no\n");
 	print_dbg(gi, "  ail = %d\n", atomic_read(&gl->gl_ail_count));
 	if (gl->gl_req_gh) {
 		error = dump_holder(gi, "Request", gl->gl_req_gh);
 		if (error)
 			goto out;
 	}
 	list_for_each_entry(gh, &gl->gl_holders, gh_list) {
 		error = dump_holder(gi, "Holder", gh);
 		if (error)
 			goto out;
 	}
 	list_for_each_entry(gh, &gl->gl_waiters1, gh_list) {
 		error = dump_holder(gi, "Waiter1", gh);
 		if (error)
 			goto out;
 	}
 	list_for_each_entry(gh, &gl->gl_waiters3, gh_list) {
 		error = dump_holder(gi, "Waiter3", gh);
 		if (error)
 			goto out;
 	}
 	if (test_bit(GLF_DEMOTE, &gl->gl_flags)) {
 		print_dbg(gi, "  Demotion req to state %u (%llu uS ago)\n",
-			  gl->gl_demote_state,
+			  gl->gl_demote_state, (unsigned long long)
-			  (u64)(jiffies - gl->gl_demote_time)*(1000000/HZ));
+			  (jiffies - gl->gl_demote_time)*(1000000/HZ));
 	}
 	if (gl->gl_ops == &gfs2_inode_glops && gl->gl_object) {
 		if (!test_bit(GLF_LOCK, &gl->gl_flags) &&
 			list_empty(&gl->gl_holders)) {
 			error = dump_inode(gi, gl->gl_object);
 			if (error)
 				goto out;
 		} else {
 			error = -ENOBUFS;
 			print_dbg(gi, "  Inode: busy\n");
 		}
 	}
 	error = 0;
 out:
 	spin_unlock(&gl->gl_spin);
 	return error;
 }
 /**
  * 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);
 	}
 #ifdef GL_HASH_LOCK_SZ
 	for(i = 0; i < GL_HASH_LOCK_SZ; i++) {
 		rwlock_init(&gl_hash_locks[i]);
 	}
 #endif
 	return 0;
 }
 static int gfs2_glock_iter_next(struct glock_iter *gi)
 {
 	read_lock(gl_lock_addr(gi->hash));
 	while (1) {
 		if (!gi->hb_list) {  /* If we don't have a hash bucket yet */
 			gi->hb_list = &gl_hash_table[gi->hash].hb_list;
 			if (hlist_empty(gi->hb_list)) {
 				read_unlock(gl_lock_addr(gi->hash));
 				gi->hash++;
 				read_lock(gl_lock_addr(gi->hash));
 				gi->hb_list = NULL;
 				if (gi->hash >= GFS2_GL_HASH_SIZE) {
 					read_unlock(gl_lock_addr(gi->hash));
 					return 1;
 				}
 				else
 					continue;
 			}
 			if (!hlist_empty(gi->hb_list)) {
 				gi->gl = list_entry(gi->hb_list->first,
 						    struct gfs2_glock,
 						    gl_list);
 			}
 		} else {
 			if (gi->gl->gl_list.next == NULL) {
 				read_unlock(gl_lock_addr(gi->hash));
 				gi->hash++;
 				read_lock(gl_lock_addr(gi->hash));
 				gi->hb_list = NULL;
 				continue;
 			}
 			gi->gl = list_entry(gi->gl->gl_list.next,
 					    struct gfs2_glock, gl_list);
 		}
 		if (gi->gl)
 			break;
 	}
 	read_unlock(gl_lock_addr(gi->hash));
 	return 0;
 }
 static void gfs2_glock_iter_free(struct glock_iter *gi)
 {
 	kfree(gi);
 }
 static struct glock_iter *gfs2_glock_iter_init(struct gfs2_sbd *sdp)
 {
 	struct glock_iter *gi;
 	gi = kmalloc(sizeof (*gi), GFP_KERNEL);
 	if (!gi)
 		return NULL;
 	gi->sdp = sdp;
 	gi->hash = 0;
 	gi->gl = NULL;
 	gi->hb_list = NULL;
 	gi->seq = NULL;
 	memset(gi->string, 0, sizeof(gi->string));
 	if (gfs2_glock_iter_next(gi)) {
 		gfs2_glock_iter_free(gi);
 		return NULL;
 	}
 	return gi;
 }
 static void *gfs2_glock_seq_start(struct seq_file *file, loff_t *pos)
 {
 	struct glock_iter *gi;
 	loff_t n = *pos;
 	gi = gfs2_glock_iter_init(file->private);
 	if (!gi)
 		return NULL;
 	while (n--) {
 		if (gfs2_glock_iter_next(gi)) {
 			gfs2_glock_iter_free(gi);
 			return NULL;
 		}
 	}
 	return gi;
 }
 static void *gfs2_glock_seq_next(struct seq_file *file, void *iter_ptr,
 				 loff_t *pos)
 {
 	struct glock_iter *gi = iter_ptr;
 	(*pos)++;
 	if (gfs2_glock_iter_next(gi)) {
 		gfs2_glock_iter_free(gi);
 		return NULL;
 	}
 	return gi;
 }
 static void gfs2_glock_seq_stop(struct seq_file *file, void *iter_ptr)
 {
 	/* nothing for now */
 }
 static int gfs2_glock_seq_show(struct seq_file *file, void *iter_ptr)
 {
 	struct glock_iter *gi = iter_ptr;
 	gi->seq = file;
 	dump_glock(gi, gi->gl);
 	return 0;
 }
 static struct seq_operations gfs2_glock_seq_ops = {
 	.start = gfs2_glock_seq_start,
 	.next  = gfs2_glock_seq_next,
 	.stop  = gfs2_glock_seq_stop,
 	.show  = gfs2_glock_seq_show,
 };
 static int gfs2_debugfs_open(struct inode *inode, struct file *file)
 {
 	struct seq_file *seq;
 	int ret;
 	ret = seq_open(file, &gfs2_glock_seq_ops);
 	if (ret)
 		return ret;
 	seq = file->private_data;
 	seq->private = inode->i_private;
 	return 0;
 }
 static const struct file_operations gfs2_debug_fops = {
 	.owner   = THIS_MODULE,
 	.open    = gfs2_debugfs_open,
 	.read    = seq_read,
 	.llseek  = seq_lseek,
 	.release = seq_release
 };
 int gfs2_create_debugfs_file(struct gfs2_sbd *sdp)
 {
 	sdp->debugfs_dir = debugfs_create_dir(sdp->sd_table_name, gfs2_root);
 	if (!sdp->debugfs_dir)
 		return -ENOMEM;
 	sdp->debugfs_dentry_glocks = debugfs_create_file("glocks",
 							 S_IFREG | S_IRUGO,
 							 sdp->debugfs_dir, sdp,
 							 &gfs2_debug_fops);
 	if (!sdp->debugfs_dentry_glocks)
 		return -ENOMEM;
 	return 0;
 }
 void gfs2_delete_debugfs_file(struct gfs2_sbd *sdp)
 {
 	if (sdp && sdp->debugfs_dir) {
 		if (sdp->debugfs_dentry_glocks) {
 			debugfs_remove(sdp->debugfs_dentry_glocks);
 			sdp->debugfs_dentry_glocks = NULL;
 		}
 		debugfs_remove(sdp->debugfs_dir);
 		sdp->debugfs_dir = NULL;
 	}
 }
 int gfs2_register_debugfs(void)
 {
 	gfs2_root = debugfs_create_dir("gfs2", NULL);
 	return gfs2_root ? 0 : -ENOMEM;
 }
 void gfs2_unregister_debugfs(void)
 {
 	debugfs_remove(gfs2_root);
 	gfs2_root = NULL;
 }

fs/gfs2/ops_address.c

Diff comments View file @ cd81a4b

 /*
  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
  * Copyright (C) 2004-2007 Red Hat, Inc.  All rights reserved.
  *
  * This copyrighted material is made available to anyone wishing to use,
  * modify, copy, or redistribute it subject to the terms and conditions
  * of the GNU General Public License version 2.
  */
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <linux/completion.h>
 #include <linux/buffer_head.h>
 #include <linux/pagemap.h>
 #include <linux/pagevec.h>
 #include <linux/mpage.h>
 #include <linux/fs.h>
 #include <linux/writeback.h>
 #include <linux/gfs2_ondisk.h>
 #include <linux/lm_interface.h>
 #include "gfs2.h"
 #include "incore.h"
 #include "bmap.h"
 #include "glock.h"
 #include "inode.h"
 #include "log.h"
 #include "meta_io.h"
 #include "ops_address.h"
 #include "quota.h"
 #include "trans.h"
 #include "rgrp.h"
 #include "ops_file.h"
+#include "super.h"
 #include "util.h"
 #include "glops.h"
 static void gfs2_page_add_databufs(struct gfs2_inode *ip, struct page *page,
 				   unsigned int from, unsigned int to)
 {
 	struct buffer_head *head = page_buffers(page);
 	unsigned int bsize = head->b_size;
 	struct buffer_head *bh;
 	unsigned int start, end;
 	for (bh = head, start = 0; bh != head || !start;
 	     bh = bh->b_this_page, start = end) {
 		end = start + bsize;
 		if (end <= from || start >= to)
 			continue;
 		gfs2_trans_add_bh(ip->i_gl, bh, 0);
 	}
 }
 /**
  * gfs2_get_block - Fills in a buffer head with details about a block
  * @inode: The inode
  * @lblock: The block number to look up
  * @bh_result: The buffer head to return the result in
  * @create: Non-zero if we may add block to the file
  *
  * Returns: errno
  */
 int gfs2_get_block(struct inode *inode, sector_t lblock,
 	           struct buffer_head *bh_result, int create)
 {
 	return gfs2_block_map(inode, lblock, create, bh_result);
 }
 /**
  * gfs2_get_block_noalloc - Fills in a buffer head with details about a block
  * @inode: The inode
  * @lblock: The block number to look up
  * @bh_result: The buffer head to return the result in
  * @create: Non-zero if we may add block to the file
  *
  * Returns: errno
  */
 static int gfs2_get_block_noalloc(struct inode *inode, sector_t lblock,
 				  struct buffer_head *bh_result, int create)
 {
 	int error;
 	error = gfs2_block_map(inode, lblock, 0, bh_result);
 	if (error)
 		return error;
 	if (bh_result->b_blocknr == 0)
 		return -EIO;
 	return 0;
 }
 static int gfs2_get_block_direct(struct inode *inode, sector_t lblock,
 				 struct buffer_head *bh_result, int create)
 {
 	return gfs2_block_map(inode, lblock, 0, bh_result);
 }
 /**
  * gfs2_writepage - Write complete page
  * @page: Page to write
  *
  * Returns: errno
  *
  * Some of this is copied from block_write_full_page() although we still
  * call it to do most of the work.
  */
 static int gfs2_writepage(struct page *page, struct writeback_control *wbc)
 {
 	struct inode *inode = page->mapping->host;
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_sbd *sdp = GFS2_SB(inode);
 	loff_t i_size = i_size_read(inode);
 	pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT;
 	unsigned offset;
 	int error;
 	int done_trans = 0;
 	if (gfs2_assert_withdraw(sdp, gfs2_glock_is_held_excl(ip->i_gl))) {
 		unlock_page(page);
 		return -EIO;
 	}
 	if (current->journal_info)
 		goto out_ignore;
 	/* Is the page fully outside i_size? (truncate in progress) */
         offset = i_size & (PAGE_CACHE_SIZE-1);
 	if (page->index > end_index || (page->index == end_index && !offset)) {
 		page->mapping->a_ops->invalidatepage(page, 0);
 		unlock_page(page);
 		return 0; /* don't care */
 	}
 	if (sdp->sd_args.ar_data == GFS2_DATA_ORDERED || gfs2_is_jdata(ip)) {
 		error = gfs2_trans_begin(sdp, RES_DINODE + 1, 0);
 		if (error)
 			goto out_ignore;
 		if (!page_has_buffers(page)) {
 			create_empty_buffers(page, inode->i_sb->s_blocksize,
 					     (1 << BH_Dirty)|(1 << BH_Uptodate));
 		}
 		gfs2_page_add_databufs(ip, page, 0, sdp->sd_vfs->s_blocksize-1);
 		done_trans = 1;
 	}
 	error = block_write_full_page(page, gfs2_get_block_noalloc, wbc);
 	if (done_trans)
 		gfs2_trans_end(sdp);
 	gfs2_meta_cache_flush(ip);
 	return error;
 out_ignore:
 	redirty_page_for_writepage(wbc, page);
 	unlock_page(page);
 	return 0;
 }
 /**
  * gfs2_writepages - Write a bunch of dirty pages back to disk
  * @mapping: The mapping to write
  * @wbc: Write-back control
  *
  * For journaled files and/or ordered writes this just falls back to the
  * kernel's default writepages path for now. We will probably want to change
  * that eventually (i.e. when we look at allocate on flush).
  *
  * For the data=writeback case though we can already ignore buffer heads
  * and write whole extents at once. This is a big reduction in the
  * number of I/O requests we send and the bmap calls we make in this case.
  */
 static int gfs2_writepages(struct address_space *mapping,
 			   struct writeback_control *wbc)
 {
 	struct inode *inode = mapping->host;
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_sbd *sdp = GFS2_SB(inode);
 	if (sdp->sd_args.ar_data == GFS2_DATA_WRITEBACK && !gfs2_is_jdata(ip))
 		return mpage_writepages(mapping, wbc, gfs2_get_block_noalloc);
 	return generic_writepages(mapping, wbc);
 }
 /**
  * stuffed_readpage - Fill in a Linux page with stuffed file data
  * @ip: the inode
  * @page: the page
  *
  * Returns: errno
  */
 static int stuffed_readpage(struct gfs2_inode *ip, struct page *page)
 {
 	struct buffer_head *dibh;
 	void *kaddr;
 	int error;
 	/*
 	 * Due to the order of unstuffing files and ->nopage(), we can be
 	 * asked for a zero page in the case of a stuffed file being extended,
 	 * so we need to supply one here. It doesn't happen often.
 	 */
 	if (unlikely(page->index)) {
 		kaddr = kmap_atomic(page, KM_USER0);
 		memset(kaddr, 0, PAGE_CACHE_SIZE);
 		kunmap_atomic(kaddr, KM_USER0);
 		flush_dcache_page(page);
 		SetPageUptodate(page);
 		return 0;
 	}
 	error = gfs2_meta_inode_buffer(ip, &dibh);
 	if (error)
 		return error;
 	kaddr = kmap_atomic(page, KM_USER0);
 	memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode),
 	       ip->i_di.di_size);
 	memset(kaddr + ip->i_di.di_size, 0, PAGE_CACHE_SIZE - ip->i_di.di_size);
 	kunmap_atomic(kaddr, KM_USER0);
 	flush_dcache_page(page);
 	brelse(dibh);
 	SetPageUptodate(page);
 	return 0;
 }
 /**
  * gfs2_readpage - readpage with locking
  * @file: The file to read a page for. N.B. This may be NULL if we are
  * reading an internal file.
  * @page: The page to read
  *
  * Returns: errno
  */
 static int gfs2_readpage(struct file *file, struct page *page)
 {
 	struct gfs2_inode *ip = GFS2_I(page->mapping->host);
 	struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
 	struct gfs2_file *gf = NULL;
 	struct gfs2_holder gh;
 	int error;
 	int do_unlock = 0;
 	if (likely(file != &gfs2_internal_file_sentinel)) {
 		if (file) {
 			gf = file->private_data;
 			if (test_bit(GFF_EXLOCK, &gf->f_flags))
 				/* gfs2_sharewrite_nopage has grabbed the ip->i_gl already */
 				goto skip_lock;
 		}
 		gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME|LM_FLAG_TRY_1CB, &gh);
 		do_unlock = 1;
 		error = gfs2_glock_nq_atime(&gh);
 		if (unlikely(error))
 			goto out_unlock;
 	}
 skip_lock:
 	if (gfs2_is_stuffed(ip)) {
 		error = stuffed_readpage(ip, page);
 		unlock_page(page);
 	} else
 		error = mpage_readpage(page, gfs2_get_block);
 	if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
 		error = -EIO;
 	if (do_unlock) {
 		gfs2_glock_dq_m(1, &gh);
 		gfs2_holder_uninit(&gh);
 	}
 out:
 	return error;
 out_unlock:
 	unlock_page(page);
 	if (error == GLR_TRYFAILED) {
 		error = AOP_TRUNCATED_PAGE;
 		yield();
 	}
 	if (do_unlock)
 		gfs2_holder_uninit(&gh);
 	goto out;
 }
 /**
  * gfs2_readpages - Read a bunch of pages at once
  *
  * Some notes:
  * 1. This is only for readahead, so we can simply ignore any things
  *    which are slightly inconvenient (such as locking conflicts between
  *    the page lock and the glock) and return having done no I/O. Its
  *    obviously not something we'd want to do on too regular a basis.
  *    Any I/O we ignore at this time will be done via readpage later.
  * 2. We don't handle stuffed files here we let readpage do the honours.
  * 3. mpage_readpages() does most of the heavy lifting in the common case.
  * 4. gfs2_get_block() is relied upon to set BH_Boundary in the right places.
  * 5. We use LM_FLAG_TRY_1CB here, effectively we then have lock-ahead as
  *    well as read-ahead.
  */
 static int gfs2_readpages(struct file *file, struct address_space *mapping,
 			  struct list_head *pages, unsigned nr_pages)
 {
 	struct inode *inode = mapping->host;
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_sbd *sdp = GFS2_SB(inode);
 	struct gfs2_holder gh;
 	int ret = 0;
 	int do_unlock = 0;
 	if (likely(file != &gfs2_internal_file_sentinel)) {
 		if (file) {
 			struct gfs2_file *gf = file->private_data;
 			if (test_bit(GFF_EXLOCK, &gf->f_flags))
 				goto skip_lock;
 		}
 		gfs2_holder_init(ip->i_gl, LM_ST_SHARED,
 				 LM_FLAG_TRY_1CB|GL_ATIME, &gh);
 		do_unlock = 1;
 		ret = gfs2_glock_nq_atime(&gh);
 		if (ret == GLR_TRYFAILED)
 			goto out_noerror;
 		if (unlikely(ret))
 			goto out_unlock;
 	}
 skip_lock:
 	if (!gfs2_is_stuffed(ip))
 		ret = mpage_readpages(mapping, pages, nr_pages, gfs2_get_block);
 	if (do_unlock) {
 		gfs2_glock_dq_m(1, &gh);
 		gfs2_holder_uninit(&gh);
 	}
 out:
 	if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
 		ret = -EIO;
 	return ret;
 out_noerror:
 	ret = 0;
 out_unlock:
 	if (do_unlock)
 		gfs2_holder_uninit(&gh);
 	goto out;
 }
 /**
  * gfs2_prepare_write - Prepare to write a page to a file
  * @file: The file to write to
  * @page: The page which is to be prepared for writing
  * @from: From (byte range within page)
  * @to: To (byte range within page)
  *
  * Returns: errno
  */
 static int gfs2_prepare_write(struct file *file, struct page *page,
 			      unsigned from, unsigned to)
 {
 	struct gfs2_inode *ip = GFS2_I(page->mapping->host);
 	struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
 	unsigned int data_blocks, ind_blocks, rblocks;
 	int alloc_required;
 	int error = 0;
 	loff_t pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + from;
 	loff_t end = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
 	struct gfs2_alloc *al;
 	unsigned int write_len = to - from;
 	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_ATIME|LM_FLAG_TRY_1CB, &ip->i_gh);
 	error = gfs2_glock_nq_atime(&ip->i_gh);
 	if (unlikely(error)) {
 		if (error == GLR_TRYFAILED) {
 			unlock_page(page);
 			error = AOP_TRUNCATED_PAGE;
 			yield();
 		}
 		goto out_uninit;
 	}
 	gfs2_write_calc_reserv(ip, write_len, &data_blocks, &ind_blocks);
 	error = gfs2_write_alloc_required(ip, pos, write_len, &alloc_required);
 	if (error)
 		goto out_unlock;
 	ip->i_alloc.al_requested = 0;
 	if (alloc_required) {
 		al = gfs2_alloc_get(ip);
 		error = gfs2_quota_lock(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
 		if (error)
 			goto out_alloc_put;
 		error = gfs2_quota_check(ip, ip->i_inode.i_uid, ip->i_inode.i_gid);
 		if (error)
 			goto out_qunlock;
 		al->al_requested = data_blocks + ind_blocks;
 		error = gfs2_inplace_reserve(ip);
 		if (error)
 			goto out_qunlock;
 	}
 	rblocks = RES_DINODE + ind_blocks;
 	if (gfs2_is_jdata(ip))
 		rblocks += data_blocks ? data_blocks : 1;
 	if (ind_blocks || data_blocks)
 		rblocks += RES_STATFS + RES_QUOTA;
 	error = gfs2_trans_begin(sdp, rblocks, 0);
 	if (error)
 		goto out;
 	if (gfs2_is_stuffed(ip)) {
 		if (end > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)) {
 			error = gfs2_unstuff_dinode(ip, page);
 			if (error == 0)
 				goto prepare_write;
 		} else if (!PageUptodate(page))
 			error = stuffed_readpage(ip, page);
 		goto out;
 	}
 prepare_write:
 	error = block_prepare_write(page, from, to, gfs2_get_block);
 out:
 	if (error) {
 		gfs2_trans_end(sdp);
 		if (alloc_required) {
 			gfs2_inplace_release(ip);
 out_qunlock:
 			gfs2_quota_unlock(ip);
 out_alloc_put:
 			gfs2_alloc_put(ip);
 		}
 out_unlock:
 		gfs2_glock_dq_m(1, &ip->i_gh);
 out_uninit:
 		gfs2_holder_uninit(&ip->i_gh);
 	}
 	return error;
 }
 /**
  * adjust_fs_space - Adjusts the free space available due to gfs2_grow
  * @inode: the rindex inode
  */
 static void adjust_fs_space(struct inode *inode)
 {
 	struct gfs2_sbd *sdp = inode->i_sb->s_fs_info;
 	struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master;
 	struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;
 	u64 fs_total, new_free;
 	/* Total up the file system space, according to the latest rindex. */
 	fs_total = gfs2_ri_total(sdp);
 	spin_lock(&sdp->sd_statfs_spin);
 	if (fs_total > (m_sc->sc_total + l_sc->sc_total))
 		new_free = fs_total - (m_sc->sc_total + l_sc->sc_total);
 	else
 		new_free = 0;
 	spin_unlock(&sdp->sd_statfs_spin);
 	fs_warn(sdp, "File system extended by %llu blocks.\n",
 		(unsigned long long)new_free);
 	gfs2_statfs_change(sdp, new_free, new_free, 0);
 }
 /**
  * gfs2_commit_write - Commit write to a file
  * @file: The file to write to
  * @page: The page containing the data
  * @from: From (byte range within page)
  * @to: To (byte range within page)
  *
  * Returns: errno
  */
 static int gfs2_commit_write(struct file *file, struct page *page,
 			     unsigned from, unsigned to)
 {
 	struct inode *inode = page->mapping->host;
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_sbd *sdp = GFS2_SB(inode);
 	int error = -EOPNOTSUPP;
 	struct buffer_head *dibh;
 	struct gfs2_alloc *al = &ip->i_alloc;
 	struct gfs2_dinode *di;
 	if (gfs2_assert_withdraw(sdp, gfs2_glock_is_locked_by_me(ip->i_gl)))
                 goto fail_nounlock;
 	error = gfs2_meta_inode_buffer(ip, &dibh);
 	if (error)
 		goto fail_endtrans;
 	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
 	di = (struct gfs2_dinode *)dibh->b_data;
 	if (gfs2_is_stuffed(ip)) {
 		u64 file_size;
 		void *kaddr;
 		file_size = ((u64)page->index << PAGE_CACHE_SHIFT) + to;
 		kaddr = kmap_atomic(page, KM_USER0);
 		memcpy(dibh->b_data + sizeof(struct gfs2_dinode) + from,
 		       kaddr + from, to - from);
 		kunmap_atomic(kaddr, KM_USER0);
 		SetPageUptodate(page);
 		if (inode->i_size < file_size) {
 			i_size_write(inode, file_size);
 			mark_inode_dirty(inode);
 		}
 	} else {
 		if (sdp->sd_args.ar_data == GFS2_DATA_ORDERED ||
 		    gfs2_is_jdata(ip))
 			gfs2_page_add_databufs(ip, page, from, to);
 		error = generic_commit_write(file, page, from, to);
 		if (error)
 			goto fail;
 	}
 	if (ip->i_di.di_size < inode->i_size) {
 		ip->i_di.di_size = inode->i_size;
 		di->di_size = cpu_to_be64(inode->i_size);
 	}
 	if (inode == sdp->sd_rindex)
 		adjust_fs_space(inode);
 	brelse(dibh);
 	gfs2_trans_end(sdp);
 	if (al->al_requested) {
 		gfs2_inplace_release(ip);
 		gfs2_quota_unlock(ip);
 		gfs2_alloc_put(ip);
 	}
 	unlock_page(page);
 	gfs2_glock_dq_m(1, &ip->i_gh);
 	lock_page(page);
 	gfs2_holder_uninit(&ip->i_gh);
 	return 0;
 fail:
 	brelse(dibh);
 fail_endtrans:
 	gfs2_trans_end(sdp);
 	if (al->al_requested) {
 		gfs2_inplace_release(ip);
 		gfs2_quota_unlock(ip);
 		gfs2_alloc_put(ip);
 	}
 	unlock_page(page);
 	gfs2_glock_dq_m(1, &ip->i_gh);
 	lock_page(page);
 	gfs2_holder_uninit(&ip->i_gh);
 fail_nounlock:
 	ClearPageUptodate(page);
 	return error;
 }
 /**
  * gfs2_bmap - Block map function
  * @mapping: Address space info
  * @lblock: The block to map
  *
  * Returns: The disk address for the block or 0 on hole or error
  */
 static sector_t gfs2_bmap(struct address_space *mapping, sector_t lblock)
 {
 	struct gfs2_inode *ip = GFS2_I(mapping->host);
 	struct gfs2_holder i_gh;
 	sector_t dblock = 0;
 	int error;
 	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
 	if (error)
 		return 0;
 	if (!gfs2_is_stuffed(ip))
 		dblock = generic_block_bmap(mapping, lblock, gfs2_get_block);
 	gfs2_glock_dq_uninit(&i_gh);
 	return dblock;
 }
 static void discard_buffer(struct gfs2_sbd *sdp, struct buffer_head *bh)
 {
 	struct gfs2_bufdata *bd;
 	gfs2_log_lock(sdp);
 	bd = bh->b_private;
 	if (bd) {
 		bd->bd_bh = NULL;
 		bh->b_private = NULL;
 	}
 	gfs2_log_unlock(sdp);
 	lock_buffer(bh);
 	clear_buffer_dirty(bh);
 	bh->b_bdev = NULL;
 	clear_buffer_mapped(bh);
 	clear_buffer_req(bh);
 	clear_buffer_new(bh);
 	clear_buffer_delay(bh);
 	unlock_buffer(bh);
 }
 static void gfs2_invalidatepage(struct page *page, unsigned long offset)
 {
 	struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
 	struct buffer_head *head, *bh, *next;
 	unsigned int curr_off = 0;
 	BUG_ON(!PageLocked(page));
 	if (!page_has_buffers(page))
 		return;
 	bh = head = page_buffers(page);
 	do {
 		unsigned int next_off = curr_off + bh->b_size;
 		next = bh->b_this_page;
 		if (offset <= curr_off)
 			discard_buffer(sdp, bh);
 		curr_off = next_off;
 		bh = next;
 	} while (bh != head);
 	if (!offset)
 		try_to_release_page(page, 0);
 	return;
 }
 /**
  * gfs2_ok_for_dio - check that dio is valid on this file
  * @ip: The inode
  * @rw: READ or WRITE
  * @offset: The offset at which we are reading or writing
  *
  * Returns: 0 (to ignore the i/o request and thus fall back to buffered i/o)
  *          1 (to accept the i/o request)
  */
 static int gfs2_ok_for_dio(struct gfs2_inode *ip, int rw, loff_t offset)
 {
 	/*
 	 * Should we return an error here? I can't see that O_DIRECT for
 	 * a journaled file makes any sense. For now we'll silently fall
 	 * back to buffered I/O, likewise we do the same for stuffed
 	 * files since they are (a) small and (b) unaligned.
 	 */
 	if (gfs2_is_jdata(ip))
 		return 0;
 	if (gfs2_is_stuffed(ip))
 		return 0;
 	if (offset > i_size_read(&ip->i_inode))
 		return 0;
 	return 1;
 }
 static ssize_t gfs2_direct_IO(int rw, struct kiocb *iocb,
 			      const struct iovec *iov, loff_t offset,
 			      unsigned long nr_segs)
 {
 	struct file *file = iocb->ki_filp;
 	struct inode *inode = file->f_mapping->host;
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_holder gh;
 	int rv;
 	/*
 	 * Deferred lock, even if its a write, since we do no allocation
 	 * on this path. All we need change is atime, and this lock mode
 	 * ensures that other nodes have flushed their buffered read caches
 	 * (i.e. their page cache entries for this inode). We do not,
 	 * unfortunately have the option of only flushing a range like
 	 * the VFS does.
 	 */
 	gfs2_holder_init(ip->i_gl, LM_ST_DEFERRED, GL_ATIME, &gh);
 	rv = gfs2_glock_nq_atime(&gh);
 	if (rv)
 		return rv;
 	rv = gfs2_ok_for_dio(ip, rw, offset);
 	if (rv != 1)
 		goto out; /* dio not valid, fall back to buffered i/o */
 	rv = blockdev_direct_IO_no_locking(rw, iocb, inode, inode->i_sb->s_bdev,
 					   iov, offset, nr_segs,
 					   gfs2_get_block_direct, NULL);
 out:
 	gfs2_glock_dq_m(1, &gh);
 	gfs2_holder_uninit(&gh);
 	return rv;
 }
 /**
  * stuck_releasepage - We're stuck in gfs2_releasepage().  Print stuff out.
  * @bh: the buffer we're stuck on
  *
  */
 static void stuck_releasepage(struct buffer_head *bh)
 {
 	struct inode *inode = bh->b_page->mapping->host;
 	struct gfs2_sbd *sdp = inode->i_sb->s_fs_info;
 	struct gfs2_bufdata *bd = bh->b_private;
 	struct gfs2_glock *gl;
 static unsigned limit = 0;
 	if (limit > 3)
 		return;
 	limit++;
 	fs_warn(sdp, "stuck in gfs2_releasepage() %p\n", inode);
 	fs_warn(sdp, "blkno = %llu, bh->b_count = %d\n",
 		(unsigned long long)bh->b_blocknr, atomic_read(&bh->b_count));
 	fs_warn(sdp, "pinned = %u\n", buffer_pinned(bh));
 	fs_warn(sdp, "bh->b_private = %s\n", (bd) ? "!NULL" : "NULL");
 	if (!bd)
 		return;
 	gl = bd->bd_gl;
 	fs_warn(sdp, "gl = (%u, %llu)\n",
 		gl->gl_name.ln_type, (unsigned long long)gl->gl_name.ln_number);
 	fs_warn(sdp, "bd_list_tr = %s, bd_le.le_list = %s\n",
 		(list_empty(&bd->bd_list_tr)) ? "no" : "yes",
 		(list_empty(&bd->bd_le.le_list)) ? "no" : "yes");
 	if (gl->gl_ops == &gfs2_inode_glops) {
 		struct gfs2_inode *ip = gl->gl_object;
 		unsigned int x;
 		if (!ip)
 			return;
 		fs_warn(sdp, "ip = %llu %llu\n",
 			(unsigned long long)ip->i_num.no_formal_ino,
 			(unsigned long long)ip->i_num.no_addr);
 		for (x = 0; x < GFS2_MAX_META_HEIGHT; x++)
 			fs_warn(sdp, "ip->i_cache[%u] = %s\n",
 				x, (ip->i_cache[x]) ? "!NULL" : "NULL");
 	}
 }
 /**
  * gfs2_releasepage - free the metadata associated with a page
  * @page: the page that's being released
  * @gfp_mask: passed from Linux VFS, ignored by us
  *
  * Call try_to_free_buffers() if the buffers in this page can be
  * released.
  *
  * Returns: 0
  */
 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 buffer_head *bh, *head;
 	struct gfs2_bufdata *bd;
 	unsigned long t = jiffies + gfs2_tune_get(sdp, gt_stall_secs) * HZ;
 	if (!page_has_buffers(page))
 		goto out;
 	head = bh = page_buffers(page);
 	do {
 		while (atomic_read(&bh->b_count)) {
 			if (!atomic_read(&aspace->i_writecount))
 				return 0;
 			if (!(gfp_mask & __GFP_WAIT))
 				return 0;
 			if (time_after_eq(jiffies, t)) {
 				stuck_releasepage(bh);
 				/* should we withdraw here? */
 				return 0;
 			}
 			yield();
 		}
 		gfs2_assert_warn(sdp, !buffer_pinned(bh));
 		gfs2_assert_warn(sdp, !buffer_dirty(bh));
 		gfs2_log_lock(sdp);
 		bd = bh->b_private;
 		if (bd) {
 			gfs2_assert_warn(sdp, bd->bd_bh == bh);
 			gfs2_assert_warn(sdp, list_empty(&bd->bd_list_tr));
 			gfs2_assert_warn(sdp, !bd->bd_ail);
 			bd->bd_bh = NULL;
 			if (!list_empty(&bd->bd_le.le_list))
 				bd = NULL;
 			bh->b_private = NULL;
 		}
 		gfs2_log_unlock(sdp);
 		if (bd)
 			kmem_cache_free(gfs2_bufdata_cachep, bd);
 		bh = bh->b_this_page;
 	} while (bh != head);
 out:
 	return try_to_free_buffers(page);
 }
 const struct address_space_operations gfs2_file_aops = {
 	.writepage = gfs2_writepage,
 	.writepages = gfs2_writepages,
 	.readpage = gfs2_readpage,
 	.readpages = gfs2_readpages,
 	.sync_page = block_sync_page,
 	.prepare_write = gfs2_prepare_write,
 	.commit_write = gfs2_commit_write,
 	.bmap = gfs2_bmap,
 	.invalidatepage = gfs2_invalidatepage,
 	.releasepage = gfs2_releasepage,
 	.direct_IO = gfs2_direct_IO,
 };

fs/gfs2/ops_address.h

Diff comments View file @ cd81a4b

 /*
  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
  * Copyright (C) 2004-2007 Red Hat, Inc.  All rights reserved.
  *
  * This copyrighted material is made available to anyone wishing to use,
  * modify, copy, or redistribute it subject to the terms and conditions
  * of the GNU General Public License version 2.
  */
 #ifndef __OPS_ADDRESS_DOT_H__
 #define __OPS_ADDRESS_DOT_H__
 #include <linux/fs.h>
 #include <linux/buffer_head.h>
 #include <linux/mm.h>
 extern const struct address_space_operations gfs2_file_aops;
 extern int gfs2_get_block(struct inode *inode, sector_t lblock,
 			  struct buffer_head *bh_result, int create);
 extern int gfs2_releasepage(struct page *page, gfp_t gfp_mask);
-extern u64 gfs2_ri_total(struct gfs2_sbd *sdp);
-extern void gfs2_statfs_change(struct gfs2_sbd *sdp, s64 total, s64 free,
-			       s64 dinodes);
 #endif /* __OPS_ADDRESS_DOT_H__ */

fs/gfs2/rgrp.c

Diff comments View file @ cd81a4b

1	/*	1	/*
2	* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.	2	* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3	* Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.	3	* Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
4	*	4	*
5	* This copyrighted material is made available to anyone wishing to use,	5	* This copyrighted material is made available to anyone wishing to use,
6	* modify, copy, or redistribute it subject to the terms and conditions	6	* modify, copy, or redistribute it subject to the terms and conditions
7	* of the GNU General Public License version 2.	7	* of the GNU General Public License version 2.
8	*/	8	*/
9		9
10	#include <linux/slab.h>	10	#include <linux/slab.h>
11	#include <linux/spinlock.h>	11	#include <linux/spinlock.h>
12	#include <linux/completion.h>	12	#include <linux/completion.h>
13	#include <linux/buffer_head.h>	13	#include <linux/buffer_head.h>
14	#include <linux/fs.h>	14	#include <linux/fs.h>
15	#include <linux/gfs2_ondisk.h>	15	#include <linux/gfs2_ondisk.h>
16	#include <linux/lm_interface.h>	16	#include <linux/lm_interface.h>
17		17
18	#include "gfs2.h"	18	#include "gfs2.h"
19	#include "incore.h"	19	#include "incore.h"
20	#include "glock.h"	20	#include "glock.h"
21	#include "glops.h"	21	#include "glops.h"
22	#include "lops.h"	22	#include "lops.h"
23	#include "meta_io.h"	23	#include "meta_io.h"
24	#include "quota.h"	24	#include "quota.h"
25	#include "rgrp.h"	25	#include "rgrp.h"
26	#include "super.h"	26	#include "super.h"
27	#include "trans.h"	27	#include "trans.h"
28	#include "ops_file.h"	28	#include "ops_file.h"
29	#include "util.h"	29	#include "util.h"
30	#include "log.h"	30	#include "log.h"
31		31
32	#define BFITNOENT ((u32)~0)	32	#define BFITNOENT ((u32)~0)
33		33
34	/*	34	/*
35	* These routines are used by the resource group routines (rgrp.c)	35	* These routines are used by the resource group routines (rgrp.c)
36	* to keep track of block allocation. Each block is represented by two	36	* to keep track of block allocation. Each block is represented by two
37	* bits. So, each byte represents GFS2_NBBY (i.e. 4) blocks.	37	* bits. So, each byte represents GFS2_NBBY (i.e. 4) blocks.
38	*	38	*
39	* 0 = Free	39	* 0 = Free
40	* 1 = Used (not metadata)	40	* 1 = Used (not metadata)
41	* 2 = Unlinked (still in use) inode	41	* 2 = Unlinked (still in use) inode
42	* 3 = Used (metadata)	42	* 3 = Used (metadata)
43	*/	43	*/
44		44
45	static const char valid_change[16] = {	45	static const char valid_change[16] = {
46	/* current */	46	/* current */
47	/* n */ 0, 1, 1, 1,	47	/* n */ 0, 1, 1, 1,
48	/* e */ 1, 0, 0, 0,	48	/* e */ 1, 0, 0, 0,
49	/* w */ 0, 0, 0, 1,	49	/* w */ 0, 0, 0, 1,
50	1, 0, 0, 0	50	1, 0, 0, 0
51	};	51	};
52		52
53	/**	53	/**
54	* gfs2_setbit - Set a bit in the bitmaps	54	* gfs2_setbit - Set a bit in the bitmaps
55	* @buffer: the buffer that holds the bitmaps	55	* @buffer: the buffer that holds the bitmaps
56	* @buflen: the length (in bytes) of the buffer	56	* @buflen: the length (in bytes) of the buffer
57	* @block: the block to set	57	* @block: the block to set
58	* @new_state: the new state of the block	58	* @new_state: the new state of the block
59	*	59	*
60	*/	60	*/
61		61
62	static void gfs2_setbit(struct gfs2_rgrpd rgd, unsigned char buffer,	62	static void gfs2_setbit(struct gfs2_rgrpd rgd, unsigned char buffer,
63	unsigned int buflen, u32 block,	63	unsigned int buflen, u32 block,
64	unsigned char new_state)	64	unsigned char new_state)
65	{	65	{
66	unsigned char byte, end, cur_state;	66	unsigned char byte, end, cur_state;
67	unsigned int bit;	67	unsigned int bit;
68		68
69	byte = buffer + (block / GFS2_NBBY);	69	byte = buffer + (block / GFS2_NBBY);
70	bit = (block % GFS2_NBBY) * GFS2_BIT_SIZE;	70	bit = (block % GFS2_NBBY) * GFS2_BIT_SIZE;
71	end = buffer + buflen;	71	end = buffer + buflen;
72		72
73	gfs2_assert(rgd->rd_sbd, byte < end);	73	gfs2_assert(rgd->rd_sbd, byte < end);
74		74
75	cur_state = (*byte >> bit) & GFS2_BIT_MASK;	75	cur_state = (*byte >> bit) & GFS2_BIT_MASK;
76		76
77	if (valid_change[new_state * 4 + cur_state]) {	77	if (valid_change[new_state * 4 + cur_state]) {
78	*byte ^= cur_state << bit;	78	*byte ^= cur_state << bit;
79	*byte \|= new_state << bit;	79	*byte \|= new_state << bit;
80	} else	80	} else
81	gfs2_consist_rgrpd(rgd);	81	gfs2_consist_rgrpd(rgd);
82	}	82	}
83		83
84	/**	84	/**
85	* gfs2_testbit - test a bit in the bitmaps	85	* gfs2_testbit - test a bit in the bitmaps
86	* @buffer: the buffer that holds the bitmaps	86	* @buffer: the buffer that holds the bitmaps
87	* @buflen: the length (in bytes) of the buffer	87	* @buflen: the length (in bytes) of the buffer
88	* @block: the block to read	88	* @block: the block to read
89	*	89	*
90	*/	90	*/
91		91
92	static unsigned char gfs2_testbit(struct gfs2_rgrpd rgd, unsigned char buffer,	92	static unsigned char gfs2_testbit(struct gfs2_rgrpd rgd, unsigned char buffer,
93	unsigned int buflen, u32 block)	93	unsigned int buflen, u32 block)
94	{	94	{
95	unsigned char byte, end, cur_state;	95	unsigned char byte, end, cur_state;
96	unsigned int bit;	96	unsigned int bit;
97		97
98	byte = buffer + (block / GFS2_NBBY);	98	byte = buffer + (block / GFS2_NBBY);
99	bit = (block % GFS2_NBBY) * GFS2_BIT_SIZE;	99	bit = (block % GFS2_NBBY) * GFS2_BIT_SIZE;
100	end = buffer + buflen;	100	end = buffer + buflen;
101		101
102	gfs2_assert(rgd->rd_sbd, byte < end);	102	gfs2_assert(rgd->rd_sbd, byte < end);
103		103
104	cur_state = (*byte >> bit) & GFS2_BIT_MASK;	104	cur_state = (*byte >> bit) & GFS2_BIT_MASK;
105		105
106	return cur_state;	106	return cur_state;
107	}	107	}
108		108
109	/**	109	/**
110	* gfs2_bitfit - Search an rgrp's bitmap buffer to find a bit-pair representing	110	* gfs2_bitfit - Search an rgrp's bitmap buffer to find a bit-pair representing
111	* a block in a given allocation state.	111	* a block in a given allocation state.
112	* @buffer: the buffer that holds the bitmaps	112	* @buffer: the buffer that holds the bitmaps
113	* @buflen: the length (in bytes) of the buffer	113	* @buflen: the length (in bytes) of the buffer
114	* @goal: start search at this block's bit-pair (within @buffer)	114	* @goal: start search at this block's bit-pair (within @buffer)
115	* @old_state: GFS2_BLKST_XXX the state of the block we're looking for;	115	* @old_state: GFS2_BLKST_XXX the state of the block we're looking for;
116	* bit 0 = alloc(1)/free(0), bit 1 = meta(1)/data(0)	116	* bit 0 = alloc(1)/free(0), bit 1 = meta(1)/data(0)
117	*	117	*
118	* Scope of @goal and returned block number is only within this bitmap buffer,	118	* Scope of @goal and returned block number is only within this bitmap buffer,
119	* not entire rgrp or filesystem. @buffer will be offset from the actual	119	* not entire rgrp or filesystem. @buffer will be offset from the actual
120	* beginning of a bitmap block buffer, skipping any header structures.	120	* beginning of a bitmap block buffer, skipping any header structures.
121	*	121	*
122	* Return: the block number (bitmap buffer scope) that was found	122	* Return: the block number (bitmap buffer scope) that was found
123	*/	123	*/
124		124
125	static u32 gfs2_bitfit(struct gfs2_rgrpd rgd, unsigned char buffer,	125	static u32 gfs2_bitfit(struct gfs2_rgrpd rgd, unsigned char buffer,
126	unsigned int buflen, u32 goal,	126	unsigned int buflen, u32 goal,
127	unsigned char old_state)	127	unsigned char old_state)
128	{	128	{
129	unsigned char byte, end, alloc;	129	unsigned char byte, end, alloc;
130	u32 blk = goal;	130	u32 blk = goal;
131	unsigned int bit;	131	unsigned int bit;
132		132
133	byte = buffer + (goal / GFS2_NBBY);	133	byte = buffer + (goal / GFS2_NBBY);
134	bit = (goal % GFS2_NBBY) * GFS2_BIT_SIZE;	134	bit = (goal % GFS2_NBBY) * GFS2_BIT_SIZE;
135	end = buffer + buflen;	135	end = buffer + buflen;
136	alloc = (old_state & 1) ? 0 : 0x55;	136	alloc = (old_state & 1) ? 0 : 0x55;
137		137
138	while (byte < end) {	138	while (byte < end) {
139	if ((*byte & 0x55) == alloc) {	139	if ((*byte & 0x55) == alloc) {
140	blk += (8 - bit) >> 1;	140	blk += (8 - bit) >> 1;
141		141
142	bit = 0;	142	bit = 0;
143	byte++;	143	byte++;
144		144
145	continue;	145	continue;
146	}	146	}
147		147
148	if (((*byte >> bit) & GFS2_BIT_MASK) == old_state)	148	if (((*byte >> bit) & GFS2_BIT_MASK) == old_state)
149	return blk;	149	return blk;
150		150
151	bit += GFS2_BIT_SIZE;	151	bit += GFS2_BIT_SIZE;
152	if (bit >= 8) {	152	if (bit >= 8) {
153	bit = 0;	153	bit = 0;
154	byte++;	154	byte++;
155	}	155	}
156		156
157	blk++;	157	blk++;
158	}	158	}
159		159
160	return BFITNOENT;	160	return BFITNOENT;
161	}	161	}
162		162
163	/**	163	/**
164	* gfs2_bitcount - count the number of bits in a certain state	164	* gfs2_bitcount - count the number of bits in a certain state
165	* @buffer: the buffer that holds the bitmaps	165	* @buffer: the buffer that holds the bitmaps
166	* @buflen: the length (in bytes) of the buffer	166	* @buflen: the length (in bytes) of the buffer
167	* @state: the state of the block we're looking for	167	* @state: the state of the block we're looking for
168	*	168	*
169	* Returns: The number of bits	169	* Returns: The number of bits
170	*/	170	*/
171		171
172	static u32 gfs2_bitcount(struct gfs2_rgrpd rgd, unsigned char buffer,	172	static u32 gfs2_bitcount(struct gfs2_rgrpd rgd, unsigned char buffer,
173	unsigned int buflen, unsigned char state)	173	unsigned int buflen, unsigned char state)
174	{	174	{
175	unsigned char *byte = buffer;	175	unsigned char *byte = buffer;
176	unsigned char *end = buffer + buflen;	176	unsigned char *end = buffer + buflen;
177	unsigned char state1 = state << 2;	177	unsigned char state1 = state << 2;
178	unsigned char state2 = state << 4;	178	unsigned char state2 = state << 4;
179	unsigned char state3 = state << 6;	179	unsigned char state3 = state << 6;
180	u32 count = 0;	180	u32 count = 0;
181		181
182	for (; byte < end; byte++) {	182	for (; byte < end; byte++) {
183	if (((*byte) & 0x03) == state)	183	if (((*byte) & 0x03) == state)
184	count++;	184	count++;
185	if (((*byte) & 0x0C) == state1)	185	if (((*byte) & 0x0C) == state1)
186	count++;	186	count++;
187	if (((*byte) & 0x30) == state2)	187	if (((*byte) & 0x30) == state2)
188	count++;	188	count++;
189	if (((*byte) & 0xC0) == state3)	189	if (((*byte) & 0xC0) == state3)
190	count++;	190	count++;
191	}	191	}
192		192
193	return count;	193	return count;
194	}	194	}
195		195
196	/**	196	/**
197	* gfs2_rgrp_verify - Verify that a resource group is consistent	197	* gfs2_rgrp_verify - Verify that a resource group is consistent
198	* @sdp: the filesystem	198	* @sdp: the filesystem
199	* @rgd: the rgrp	199	* @rgd: the rgrp
200	*	200	*
201	*/	201	*/
202		202
203	void gfs2_rgrp_verify(struct gfs2_rgrpd *rgd)	203	void gfs2_rgrp_verify(struct gfs2_rgrpd *rgd)
204	{	204	{
205	struct gfs2_sbd *sdp = rgd->rd_sbd;	205	struct gfs2_sbd *sdp = rgd->rd_sbd;
206	struct gfs2_bitmap *bi = NULL;	206	struct gfs2_bitmap *bi = NULL;
207	u32 length = rgd->rd_ri.ri_length;	207	u32 length = rgd->rd_ri.ri_length;
208	u32 count[4], tmp;	208	u32 count[4], tmp;
209	int buf, x;	209	int buf, x;
210		210
211	memset(count, 0, 4 * sizeof(u32));	211	memset(count, 0, 4 * sizeof(u32));
212		212
213	/* Count # blocks in each of 4 possible allocation states */	213	/* Count # blocks in each of 4 possible allocation states */
214	for (buf = 0; buf < length; buf++) {	214	for (buf = 0; buf < length; buf++) {
215	bi = rgd->rd_bits + buf;	215	bi = rgd->rd_bits + buf;
216	for (x = 0; x < 4; x++)	216	for (x = 0; x < 4; x++)
217	count[x] += gfs2_bitcount(rgd,	217	count[x] += gfs2_bitcount(rgd,
218	bi->bi_bh->b_data +	218	bi->bi_bh->b_data +
219	bi->bi_offset,	219	bi->bi_offset,
220	bi->bi_len, x);	220	bi->bi_len, x);
221	}	221	}
222		222
223	if (count[0] != rgd->rd_rg.rg_free) {	223	if (count[0] != rgd->rd_rg.rg_free) {
224	if (gfs2_consist_rgrpd(rgd))	224	if (gfs2_consist_rgrpd(rgd))
225	fs_err(sdp, "free data mismatch: %u != %u\n",	225	fs_err(sdp, "free data mismatch: %u != %u\n",
226	count[0], rgd->rd_rg.rg_free);	226	count[0], rgd->rd_rg.rg_free);
227	return;	227	return;
228	}	228	}
229		229
230	tmp = rgd->rd_ri.ri_data -	230	tmp = rgd->rd_ri.ri_data -
231	rgd->rd_rg.rg_free -	231	rgd->rd_rg.rg_free -
232	rgd->rd_rg.rg_dinodes;	232	rgd->rd_rg.rg_dinodes;
233	if (count[1] + count[2] != tmp) {	233	if (count[1] + count[2] != tmp) {
234	if (gfs2_consist_rgrpd(rgd))	234	if (gfs2_consist_rgrpd(rgd))
235	fs_err(sdp, "used data mismatch: %u != %u\n",	235	fs_err(sdp, "used data mismatch: %u != %u\n",
236	count[1], tmp);	236	count[1], tmp);
237	return;	237	return;
238	}	238	}
239		239
240	if (count[3] != rgd->rd_rg.rg_dinodes) {	240	if (count[3] != rgd->rd_rg.rg_dinodes) {
241	if (gfs2_consist_rgrpd(rgd))	241	if (gfs2_consist_rgrpd(rgd))
242	fs_err(sdp, "used metadata mismatch: %u != %u\n",	242	fs_err(sdp, "used metadata mismatch: %u != %u\n",
243	count[3], rgd->rd_rg.rg_dinodes);	243	count[3], rgd->rd_rg.rg_dinodes);
244	return;	244	return;
245	}	245	}
246		246
247	if (count[2] > count[3]) {	247	if (count[2] > count[3]) {
248	if (gfs2_consist_rgrpd(rgd))	248	if (gfs2_consist_rgrpd(rgd))
249	fs_err(sdp, "unlinked inodes > inodes: %u\n",	249	fs_err(sdp, "unlinked inodes > inodes: %u\n",
250	count[2]);	250	count[2]);
251	return;	251	return;
252	}	252	}
253		253
254	}	254	}
255		255
256	static inline int rgrp_contains_block(struct gfs2_rindex_host *ri, u64 block)	256	static inline int rgrp_contains_block(struct gfs2_rindex_host *ri, u64 block)
257	{	257	{
258	u64 first = ri->ri_data0;	258	u64 first = ri->ri_data0;
259	u64 last = first + ri->ri_data;	259	u64 last = first + ri->ri_data;
260	return first <= block && block < last;	260	return first <= block && block < last;
261	}	261	}
262		262
263	/**	263	/**
264	* gfs2_blk2rgrpd - Find resource group for a given data/meta block number	264	* gfs2_blk2rgrpd - Find resource group for a given data/meta block number
265	* @sdp: The GFS2 superblock	265	* @sdp: The GFS2 superblock
266	* @n: The data block number	266	* @n: The data block number
267	*	267	*
268	* Returns: The resource group, or NULL if not found	268	* Returns: The resource group, or NULL if not found
269	*/	269	*/
270		270
271	struct gfs2_rgrpd gfs2_blk2rgrpd(struct gfs2_sbd sdp, u64 blk)	271	struct gfs2_rgrpd gfs2_blk2rgrpd(struct gfs2_sbd sdp, u64 blk)
272	{	272	{
273	struct gfs2_rgrpd *rgd;	273	struct gfs2_rgrpd *rgd;
274		274
275	spin_lock(&sdp->sd_rindex_spin);	275	spin_lock(&sdp->sd_rindex_spin);
276		276
277	list_for_each_entry(rgd, &sdp->sd_rindex_mru_list, rd_list_mru) {	277	list_for_each_entry(rgd, &sdp->sd_rindex_mru_list, rd_list_mru) {
278	if (rgrp_contains_block(&rgd->rd_ri, blk)) {	278	if (rgrp_contains_block(&rgd->rd_ri, blk)) {
279	list_move(&rgd->rd_list_mru, &sdp->sd_rindex_mru_list);	279	list_move(&rgd->rd_list_mru, &sdp->sd_rindex_mru_list);
280	spin_unlock(&sdp->sd_rindex_spin);	280	spin_unlock(&sdp->sd_rindex_spin);
281	return rgd;	281	return rgd;
282	}	282	}
283	}	283	}
284		284
285	spin_unlock(&sdp->sd_rindex_spin);	285	spin_unlock(&sdp->sd_rindex_spin);
286		286
287	return NULL;	287	return NULL;
288	}	288	}
289		289
290	/**	290	/**
291	* gfs2_rgrpd_get_first - get the first Resource Group in the filesystem	291	* gfs2_rgrpd_get_first - get the first Resource Group in the filesystem
292	* @sdp: The GFS2 superblock	292	* @sdp: The GFS2 superblock
293	*	293	*
294	* Returns: The first rgrp in the filesystem	294	* Returns: The first rgrp in the filesystem
295	*/	295	*/
296		296
297	struct gfs2_rgrpd gfs2_rgrpd_get_first(struct gfs2_sbd sdp)	297	struct gfs2_rgrpd gfs2_rgrpd_get_first(struct gfs2_sbd sdp)
298	{	298	{
299	gfs2_assert(sdp, !list_empty(&sdp->sd_rindex_list));	299	gfs2_assert(sdp, !list_empty(&sdp->sd_rindex_list));
300	return list_entry(sdp->sd_rindex_list.next, struct gfs2_rgrpd, rd_list);	300	return list_entry(sdp->sd_rindex_list.next, struct gfs2_rgrpd, rd_list);
301	}	301	}
302		302
303	/**	303	/**
304	* gfs2_rgrpd_get_next - get the next RG	304	* gfs2_rgrpd_get_next - get the next RG
305	* @rgd: A RG	305	* @rgd: A RG
306	*	306	*
307	* Returns: The next rgrp	307	* Returns: The next rgrp
308	*/	308	*/
309		309
310	struct gfs2_rgrpd gfs2_rgrpd_get_next(struct gfs2_rgrpd rgd)	310	struct gfs2_rgrpd gfs2_rgrpd_get_next(struct gfs2_rgrpd rgd)
311	{	311	{
312	if (rgd->rd_list.next == &rgd->rd_sbd->sd_rindex_list)	312	if (rgd->rd_list.next == &rgd->rd_sbd->sd_rindex_list)
313	return NULL;	313	return NULL;
314	return list_entry(rgd->rd_list.next, struct gfs2_rgrpd, rd_list);	314	return list_entry(rgd->rd_list.next, struct gfs2_rgrpd, rd_list);
315	}	315	}
316		316
317	static void clear_rgrpdi(struct gfs2_sbd *sdp)	317	static void clear_rgrpdi(struct gfs2_sbd *sdp)
318	{	318	{
319	struct list_head *head;	319	struct list_head *head;
320	struct gfs2_rgrpd *rgd;	320	struct gfs2_rgrpd *rgd;
321	struct gfs2_glock *gl;	321	struct gfs2_glock *gl;
322		322
323	spin_lock(&sdp->sd_rindex_spin);	323	spin_lock(&sdp->sd_rindex_spin);
324	sdp->sd_rindex_forward = NULL;	324	sdp->sd_rindex_forward = NULL;
325	head = &sdp->sd_rindex_recent_list;	325	head = &sdp->sd_rindex_recent_list;
326	while (!list_empty(head)) {	326	while (!list_empty(head)) {
327	rgd = list_entry(head->next, struct gfs2_rgrpd, rd_recent);	327	rgd = list_entry(head->next, struct gfs2_rgrpd, rd_recent);
328	list_del(&rgd->rd_recent);	328	list_del(&rgd->rd_recent);
329	}	329	}
330	spin_unlock(&sdp->sd_rindex_spin);	330	spin_unlock(&sdp->sd_rindex_spin);
331		331
332	head = &sdp->sd_rindex_list;	332	head = &sdp->sd_rindex_list;
333	while (!list_empty(head)) {	333	while (!list_empty(head)) {
334	rgd = list_entry(head->next, struct gfs2_rgrpd, rd_list);	334	rgd = list_entry(head->next, struct gfs2_rgrpd, rd_list);
335	gl = rgd->rd_gl;	335	gl = rgd->rd_gl;
336		336
337	list_del(&rgd->rd_list);	337	list_del(&rgd->rd_list);
338	list_del(&rgd->rd_list_mru);	338	list_del(&rgd->rd_list_mru);
339		339
340	if (gl) {	340	if (gl) {
341	gl->gl_object = NULL;	341	gl->gl_object = NULL;
342	gfs2_glock_put(gl);	342	gfs2_glock_put(gl);
343	}	343	}
344		344
345	kfree(rgd->rd_bits);	345	kfree(rgd->rd_bits);
346	kfree(rgd);	346	kfree(rgd);
347	}	347	}
348	}	348	}
349		349
350	void gfs2_clear_rgrpd(struct gfs2_sbd *sdp)	350	void gfs2_clear_rgrpd(struct gfs2_sbd *sdp)
351	{	351	{
352	mutex_lock(&sdp->sd_rindex_mutex);	352	mutex_lock(&sdp->sd_rindex_mutex);
353	clear_rgrpdi(sdp);	353	clear_rgrpdi(sdp);
354	mutex_unlock(&sdp->sd_rindex_mutex);	354	mutex_unlock(&sdp->sd_rindex_mutex);
355	}	355	}
356		356
357	/**	357	/**
358	* gfs2_compute_bitstructs - Compute the bitmap sizes	358	* gfs2_compute_bitstructs - Compute the bitmap sizes
359	* @rgd: The resource group descriptor	359	* @rgd: The resource group descriptor
360	*	360	*
361	* Calculates bitmap descriptors, one for each block that contains bitmap data	361	* Calculates bitmap descriptors, one for each block that contains bitmap data
362	*	362	*
363	* Returns: errno	363	* Returns: errno
364	*/	364	*/
365		365
366	static int compute_bitstructs(struct gfs2_rgrpd *rgd)	366	static int compute_bitstructs(struct gfs2_rgrpd *rgd)
367	{	367	{
368	struct gfs2_sbd *sdp = rgd->rd_sbd;	368	struct gfs2_sbd *sdp = rgd->rd_sbd;
369	struct gfs2_bitmap *bi;	369	struct gfs2_bitmap *bi;
370	u32 length = rgd->rd_ri.ri_length; /* # blocks in hdr & bitmap */	370	u32 length = rgd->rd_ri.ri_length; /* # blocks in hdr & bitmap */
371	u32 bytes_left, bytes;	371	u32 bytes_left, bytes;
372	int x;	372	int x;
373		373
374	if (!length)	374	if (!length)
375	return -EINVAL;	375	return -EINVAL;
376		376
377	rgd->rd_bits = kcalloc(length, sizeof(struct gfs2_bitmap), GFP_NOFS);	377	rgd->rd_bits = kcalloc(length, sizeof(struct gfs2_bitmap), GFP_NOFS);
378	if (!rgd->rd_bits)	378	if (!rgd->rd_bits)
379	return -ENOMEM;	379	return -ENOMEM;
380		380
381	bytes_left = rgd->rd_ri.ri_bitbytes;	381	bytes_left = rgd->rd_ri.ri_bitbytes;
382		382
383	for (x = 0; x < length; x++) {	383	for (x = 0; x < length; x++) {
384	bi = rgd->rd_bits + x;	384	bi = rgd->rd_bits + x;
385		385
386	/* small rgrp; bitmap stored completely in header block */	386	/* small rgrp; bitmap stored completely in header block */
387	if (length == 1) {	387	if (length == 1) {
388	bytes = bytes_left;	388	bytes = bytes_left;
389	bi->bi_offset = sizeof(struct gfs2_rgrp);	389	bi->bi_offset = sizeof(struct gfs2_rgrp);
390	bi->bi_start = 0;	390	bi->bi_start = 0;
391	bi->bi_len = bytes;	391	bi->bi_len = bytes;
392	/* header block */	392	/* header block */
393	} else if (x == 0) {	393	} else if (x == 0) {
394	bytes = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_rgrp);	394	bytes = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_rgrp);
395	bi->bi_offset = sizeof(struct gfs2_rgrp);	395	bi->bi_offset = sizeof(struct gfs2_rgrp);
396	bi->bi_start = 0;	396	bi->bi_start = 0;
397	bi->bi_len = bytes;	397	bi->bi_len = bytes;
398	/* last block */	398	/* last block */
399	} else if (x + 1 == length) {	399	} else if (x + 1 == length) {
400	bytes = bytes_left;	400	bytes = bytes_left;
401	bi->bi_offset = sizeof(struct gfs2_meta_header);	401	bi->bi_offset = sizeof(struct gfs2_meta_header);
402	bi->bi_start = rgd->rd_ri.ri_bitbytes - bytes_left;	402	bi->bi_start = rgd->rd_ri.ri_bitbytes - bytes_left;
403	bi->bi_len = bytes;	403	bi->bi_len = bytes;
404	/* other blocks */	404	/* other blocks */
405	} else {	405	} else {
406	bytes = sdp->sd_sb.sb_bsize -	406	bytes = sdp->sd_sb.sb_bsize -
407	sizeof(struct gfs2_meta_header);	407	sizeof(struct gfs2_meta_header);
408	bi->bi_offset = sizeof(struct gfs2_meta_header);	408	bi->bi_offset = sizeof(struct gfs2_meta_header);
409	bi->bi_start = rgd->rd_ri.ri_bitbytes - bytes_left;	409	bi->bi_start = rgd->rd_ri.ri_bitbytes - bytes_left;
410	bi->bi_len = bytes;	410	bi->bi_len = bytes;
411	}	411	}
412		412
413	bytes_left -= bytes;	413	bytes_left -= bytes;
414	}	414	}
415		415
416	if (bytes_left) {	416	if (bytes_left) {
417	gfs2_consist_rgrpd(rgd);	417	gfs2_consist_rgrpd(rgd);
418	return -EIO;	418	return -EIO;
419	}	419	}
420	bi = rgd->rd_bits + (length - 1);	420	bi = rgd->rd_bits + (length - 1);
421	if ((bi->bi_start + bi->bi_len) * GFS2_NBBY != rgd->rd_ri.ri_data) {	421	if ((bi->bi_start + bi->bi_len) * GFS2_NBBY != rgd->rd_ri.ri_data) {
422	if (gfs2_consist_rgrpd(rgd)) {	422	if (gfs2_consist_rgrpd(rgd)) {
423	gfs2_rindex_print(&rgd->rd_ri);	423	gfs2_rindex_print(&rgd->rd_ri);
424	fs_err(sdp, "start=%u len=%u offset=%u\n",	424	fs_err(sdp, "start=%u len=%u offset=%u\n",
425	bi->bi_start, bi->bi_len, bi->bi_offset);	425	bi->bi_start, bi->bi_len, bi->bi_offset);
426	}	426	}
427	return -EIO;	427	return -EIO;
428	}	428	}
429		429
430	return 0;	430	return 0;
431	}	431	}
432		432
433	/**	433	/**
434	* gfs2_ri_total - Total up the file system space, according to the rindex.	434	* gfs2_ri_total - Total up the file system space, according to the rindex.
435	*	435	*
436	*/	436	*/
437	u64 gfs2_ri_total(struct gfs2_sbd *sdp)	437	u64 gfs2_ri_total(struct gfs2_sbd *sdp)
438	{	438	{
439	u64 total_data = 0;	439	u64 total_data = 0;
440	struct inode *inode = sdp->sd_rindex;	440	struct inode *inode = sdp->sd_rindex;
441	struct gfs2_inode *ip = GFS2_I(inode);	441	struct gfs2_inode *ip = GFS2_I(inode);
442	struct gfs2_rindex_host ri;	442	struct gfs2_rindex_host ri;
443	char buf[sizeof(struct gfs2_rindex)];	443	char buf[sizeof(struct gfs2_rindex)];
444	struct file_ra_state ra_state;	444	struct file_ra_state ra_state;
445	int error, rgrps;	445	int error, rgrps;
446		446
447	mutex_lock(&sdp->sd_rindex_mutex);	447	mutex_lock(&sdp->sd_rindex_mutex);
448	file_ra_state_init(&ra_state, inode->i_mapping);	448	file_ra_state_init(&ra_state, inode->i_mapping);
449	for (rgrps = 0;; rgrps++) {	449	for (rgrps = 0;; rgrps++) {
450	loff_t pos = rgrps * sizeof(struct gfs2_rindex);	450	loff_t pos = rgrps * sizeof(struct gfs2_rindex);
451		451
452	if (pos + sizeof(struct gfs2_rindex) >= ip->i_di.di_size)	452	if (pos + sizeof(struct gfs2_rindex) >= ip->i_di.di_size)
453	break;	453	break;
454	error = gfs2_internal_read(ip, &ra_state, buf, &pos,	454	error = gfs2_internal_read(ip, &ra_state, buf, &pos,
455	sizeof(struct gfs2_rindex));	455	sizeof(struct gfs2_rindex));
456	if (error != sizeof(struct gfs2_rindex))	456	if (error != sizeof(struct gfs2_rindex))
457	break;	457	break;
458	gfs2_rindex_in(&ri, buf);	458	gfs2_rindex_in(&ri, buf);
459	total_data += ri.ri_data;	459	total_data += ri.ri_data;
460	}	460	}
461	mutex_unlock(&sdp->sd_rindex_mutex);	461	mutex_unlock(&sdp->sd_rindex_mutex);
462	return total_data;	462	return total_data;
463	}	463	}
464		464
465	/**	465	/**
466	* read_rindex_entry - Pull in a new resource index entry from the disk	466	* read_rindex_entry - Pull in a new resource index entry from the disk
467	* @gl: The glock covering the rindex inode	467	* @gl: The glock covering the rindex inode
468	*	468	*
469	* Returns: 0 on success, error code otherwise	469	* Returns: 0 on success, error code otherwise
470	*/	470	*/
471		471
472	static int read_rindex_entry(struct gfs2_inode *ip,	472	static int read_rindex_entry(struct gfs2_inode *ip,
473	struct file_ra_state *ra_state)	473	struct file_ra_state *ra_state)
474	{	474	{
475	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);	475	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
476	loff_t pos = sdp->sd_rgrps * sizeof(struct gfs2_rindex);	476	loff_t pos = sdp->sd_rgrps * sizeof(struct gfs2_rindex);
477	char buf[sizeof(struct gfs2_rindex)];	477	char buf[sizeof(struct gfs2_rindex)];
478	int error;	478	int error;
479	struct gfs2_rgrpd *rgd;	479	struct gfs2_rgrpd *rgd;
480		480
481	error = gfs2_internal_read(ip, ra_state, buf, &pos,	481	error = gfs2_internal_read(ip, ra_state, buf, &pos,
482	sizeof(struct gfs2_rindex));	482	sizeof(struct gfs2_rindex));
483	if (!error)	483	if (!error)
484	return 0;	484	return 0;
485	if (error != sizeof(struct gfs2_rindex)) {	485	if (error != sizeof(struct gfs2_rindex)) {
486	if (error > 0)	486	if (error > 0)
487	error = -EIO;	487	error = -EIO;
488	return error;	488	return error;
489	}	489	}
490		490
491	rgd = kzalloc(sizeof(struct gfs2_rgrpd), GFP_NOFS);	491	rgd = kzalloc(sizeof(struct gfs2_rgrpd), GFP_NOFS);
492	error = -ENOMEM;	492	error = -ENOMEM;
493	if (!rgd)	493	if (!rgd)
494	return error;	494	return error;
495		495
496	mutex_init(&rgd->rd_mutex);	496	mutex_init(&rgd->rd_mutex);
497	lops_init_le(&rgd->rd_le, &gfs2_rg_lops);	497	lops_init_le(&rgd->rd_le, &gfs2_rg_lops);
498	rgd->rd_sbd = sdp;	498	rgd->rd_sbd = sdp;
499		499
500	list_add_tail(&rgd->rd_list, &sdp->sd_rindex_list);	500	list_add_tail(&rgd->rd_list, &sdp->sd_rindex_list);
501	list_add_tail(&rgd->rd_list_mru, &sdp->sd_rindex_mru_list);	501	list_add_tail(&rgd->rd_list_mru, &sdp->sd_rindex_mru_list);
502		502
503	gfs2_rindex_in(&rgd->rd_ri, buf);	503	gfs2_rindex_in(&rgd->rd_ri, buf);
504	error = compute_bitstructs(rgd);	504	error = compute_bitstructs(rgd);
505	if (error)	505	if (error)
506	return error;	506	return error;
507		507
508	error = gfs2_glock_get(sdp, rgd->rd_ri.ri_addr,	508	error = gfs2_glock_get(sdp, rgd->rd_ri.ri_addr,
509	&gfs2_rgrp_glops, CREATE, &rgd->rd_gl);	509	&gfs2_rgrp_glops, CREATE, &rgd->rd_gl);
510	if (error)	510	if (error)
511	return error;	511	return error;
512		512
513	rgd->rd_gl->gl_object = rgd;	513	rgd->rd_gl->gl_object = rgd;
514	rgd->rd_rg_vn = rgd->rd_gl->gl_vn - 1;	514	rgd->rd_rg_vn = rgd->rd_gl->gl_vn - 1;
515	return error;	515	return error;
516	}	516	}
517		517
518	/**	518	/**
519	* gfs2_ri_update - Pull in a new resource index from the disk	519	* gfs2_ri_update - Pull in a new resource index from the disk
520	* @ip: pointer to the rindex inode	520	* @ip: pointer to the rindex inode
521	*	521	*
522	* Returns: 0 on successful update, error code otherwise	522	* Returns: 0 on successful update, error code otherwise
523	*/	523	*/
524		524
525	static int gfs2_ri_update(struct gfs2_inode *ip)	525	static int gfs2_ri_update(struct gfs2_inode *ip)
526	{	526	{
527	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);	527	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
528	struct inode *inode = &ip->i_inode;	528	struct inode *inode = &ip->i_inode;
529	struct file_ra_state ra_state;	529	struct file_ra_state ra_state;
530	u64 junk = ip->i_di.di_size;	530	u64 rgrp_count = ip->i_di.di_size;
531	int error;	531	int error;
532		532
533	if (do_div(junk, sizeof(struct gfs2_rindex))) {	533	if (do_div(rgrp_count, sizeof(struct gfs2_rindex))) {
534	gfs2_consist_inode(ip);	534	gfs2_consist_inode(ip);
535	return -EIO;	535	return -EIO;
536	}	536	}
537		537
538	clear_rgrpdi(sdp);	538	clear_rgrpdi(sdp);
539		539
540	file_ra_state_init(&ra_state, inode->i_mapping);	540	file_ra_state_init(&ra_state, inode->i_mapping);
541	for (sdp->sd_rgrps = 0;; sdp->sd_rgrps++) {	541	for (sdp->sd_rgrps = 0; sdp->sd_rgrps < rgrp_count; sdp->sd_rgrps++) {
542	error = read_rindex_entry(ip, &ra_state);	542	error = read_rindex_entry(ip, &ra_state);
543	if (error) {	543	if (error) {
544	clear_rgrpdi(sdp);	544	clear_rgrpdi(sdp);
545	return error;	545	return error;
546	}	546	}
547	}	547	}
548		548
549	sdp->sd_rindex_vn = ip->i_gl->gl_vn;	549	sdp->sd_rindex_vn = ip->i_gl->gl_vn;
550	return 0;	550	return 0;
551	}	551	}
552		552
553	/**	553	/**
554	* gfs2_ri_update_special - Pull in a new resource index from the disk	554	* gfs2_ri_update_special - Pull in a new resource index from the disk
555	*	555	*
556	* This is a special version that's safe to call from gfs2_inplace_reserve_i.	556	* This is a special version that's safe to call from gfs2_inplace_reserve_i.
557	* In this case we know that we don't have any resource groups in memory yet.	557	* In this case we know that we don't have any resource groups in memory yet.
558	*	558	*
559	* @ip: pointer to the rindex inode	559	* @ip: pointer to the rindex inode
560	*	560	*
561	* Returns: 0 on successful update, error code otherwise	561	* Returns: 0 on successful update, error code otherwise
562	*/	562	*/
563	static int gfs2_ri_update_special(struct gfs2_inode *ip)	563	static int gfs2_ri_update_special(struct gfs2_inode *ip)
564	{	564	{
565	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);	565	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
566	struct inode *inode = &ip->i_inode;	566	struct inode *inode = &ip->i_inode;
567	struct file_ra_state ra_state;	567	struct file_ra_state ra_state;
568	int error;	568	int error;
569		569
570	file_ra_state_init(&ra_state, inode->i_mapping);	570	file_ra_state_init(&ra_state, inode->i_mapping);
571	for (sdp->sd_rgrps = 0;; sdp->sd_rgrps++) {	571	for (sdp->sd_rgrps = 0;; sdp->sd_rgrps++) {
572	/* Ignore partials */	572	/* Ignore partials */
573	if ((sdp->sd_rgrps + 1) * sizeof(struct gfs2_rindex) >	573	if ((sdp->sd_rgrps + 1) * sizeof(struct gfs2_rindex) >
574	ip->i_di.di_size)	574	ip->i_di.di_size)
575	break;	575	break;
576	error = read_rindex_entry(ip, &ra_state);	576	error = read_rindex_entry(ip, &ra_state);
577	if (error) {	577	if (error) {
578	clear_rgrpdi(sdp);	578	clear_rgrpdi(sdp);
579	return error;	579	return error;
580	}	580	}
581	}	581	}
582		582
583	sdp->sd_rindex_vn = ip->i_gl->gl_vn;	583	sdp->sd_rindex_vn = ip->i_gl->gl_vn;
584	return 0;	584	return 0;
585	}	585	}
586		586
587	/**	587	/**
588	* gfs2_rindex_hold - Grab a lock on the rindex	588	* gfs2_rindex_hold - Grab a lock on the rindex
589	* @sdp: The GFS2 superblock	589	* @sdp: The GFS2 superblock
590	* @ri_gh: the glock holder	590	* @ri_gh: the glock holder
591	*	591	*
592	* We grab a lock on the rindex inode to make sure that it doesn't	592	* We grab a lock on the rindex inode to make sure that it doesn't
593	* change whilst we are performing an operation. We keep this lock	593	* change whilst we are performing an operation. We keep this lock
594	* for quite long periods of time compared to other locks. This	594	* for quite long periods of time compared to other locks. This
595	* doesn't matter, since it is shared and it is very, very rarely	595	* doesn't matter, since it is shared and it is very, very rarely
596	* accessed in the exclusive mode (i.e. only when expanding the filesystem).	596	* accessed in the exclusive mode (i.e. only when expanding the filesystem).
597	*	597	*
598	* This makes sure that we're using the latest copy of the resource index	598	* This makes sure that we're using the latest copy of the resource index
599	* special file, which might have been updated if someone expanded the	599	* special file, which might have been updated if someone expanded the
600	* filesystem (via gfs2_grow utility), which adds new resource groups.	600	* filesystem (via gfs2_grow utility), which adds new resource groups.
601	*	601	*
602	* Returns: 0 on success, error code otherwise	602	* Returns: 0 on success, error code otherwise
603	*/	603	*/
604		604
605	int gfs2_rindex_hold(struct gfs2_sbd sdp, struct gfs2_holder ri_gh)	605	int gfs2_rindex_hold(struct gfs2_sbd sdp, struct gfs2_holder ri_gh)
606	{	606	{
607	struct gfs2_inode *ip = GFS2_I(sdp->sd_rindex);	607	struct gfs2_inode *ip = GFS2_I(sdp->sd_rindex);
608	struct gfs2_glock *gl = ip->i_gl;	608	struct gfs2_glock *gl = ip->i_gl;
609	int error;	609	int error;
610		610
611	error = gfs2_glock_nq_init(gl, LM_ST_SHARED, 0, ri_gh);	611	error = gfs2_glock_nq_init(gl, LM_ST_SHARED, 0, ri_gh);
612	if (error)	612	if (error)
613	return error;	613	return error;
614		614
615	/* Read new copy from disk if we don't have the latest */	615	/* Read new copy from disk if we don't have the latest */
616	if (sdp->sd_rindex_vn != gl->gl_vn) {	616	if (sdp->sd_rindex_vn != gl->gl_vn) {
617	mutex_lock(&sdp->sd_rindex_mutex);	617	mutex_lock(&sdp->sd_rindex_mutex);
618	if (sdp->sd_rindex_vn != gl->gl_vn) {	618	if (sdp->sd_rindex_vn != gl->gl_vn) {
619	error = gfs2_ri_update(ip);	619	error = gfs2_ri_update(ip);
620	if (error)	620	if (error)
621	gfs2_glock_dq_uninit(ri_gh);	621	gfs2_glock_dq_uninit(ri_gh);
622	}	622	}
623	mutex_unlock(&sdp->sd_rindex_mutex);	623	mutex_unlock(&sdp->sd_rindex_mutex);
624	}	624	}
625		625
626	return error;	626	return error;
627	}	627	}
628		628
629	/**	629	/**
630	* gfs2_rgrp_bh_get - Read in a RG's header and bitmaps	630	* gfs2_rgrp_bh_get - Read in a RG's header and bitmaps
631	* @rgd: the struct gfs2_rgrpd describing the RG to read in	631	* @rgd: the struct gfs2_rgrpd describing the RG to read in
632	*	632	*
633	* Read in all of a Resource Group's header and bitmap blocks.	633	* Read in all of a Resource Group's header and bitmap blocks.
634	* Caller must eventually call gfs2_rgrp_relse() to free the bitmaps.	634	* Caller must eventually call gfs2_rgrp_relse() to free the bitmaps.
635	*	635	*
636	* Returns: errno	636	* Returns: errno
637	*/	637	*/
638		638
639	int gfs2_rgrp_bh_get(struct gfs2_rgrpd *rgd)	639	int gfs2_rgrp_bh_get(struct gfs2_rgrpd *rgd)
640	{	640	{
641	struct gfs2_sbd *sdp = rgd->rd_sbd;	641	struct gfs2_sbd *sdp = rgd->rd_sbd;
642	struct gfs2_glock *gl = rgd->rd_gl;	642	struct gfs2_glock *gl = rgd->rd_gl;
643	unsigned int length = rgd->rd_ri.ri_length;	643	unsigned int length = rgd->rd_ri.ri_length;
644	struct gfs2_bitmap *bi;	644	struct gfs2_bitmap *bi;
645	unsigned int x, y;	645	unsigned int x, y;
646	int error;	646	int error;
647		647
648	mutex_lock(&rgd->rd_mutex);	648	mutex_lock(&rgd->rd_mutex);
649		649
650	spin_lock(&sdp->sd_rindex_spin);	650	spin_lock(&sdp->sd_rindex_spin);
651	if (rgd->rd_bh_count) {	651	if (rgd->rd_bh_count) {
652	rgd->rd_bh_count++;	652	rgd->rd_bh_count++;
653	spin_unlock(&sdp->sd_rindex_spin);	653	spin_unlock(&sdp->sd_rindex_spin);
654	mutex_unlock(&rgd->rd_mutex);	654	mutex_unlock(&rgd->rd_mutex);
655	return 0;	655	return 0;
656	}	656	}
657	spin_unlock(&sdp->sd_rindex_spin);	657	spin_unlock(&sdp->sd_rindex_spin);
658		658
659	for (x = 0; x < length; x++) {	659	for (x = 0; x < length; x++) {
660	bi = rgd->rd_bits + x;	660	bi = rgd->rd_bits + x;
661	error = gfs2_meta_read(gl, rgd->rd_ri.ri_addr + x, 0, &bi->bi_bh);	661	error = gfs2_meta_read(gl, rgd->rd_ri.ri_addr + x, 0, &bi->bi_bh);
662	if (error)	662	if (error)
663	goto fail;	663	goto fail;
664	}	664	}
665		665
666	for (y = length; y--;) {	666	for (y = length; y--;) {
667	bi = rgd->rd_bits + y;	667	bi = rgd->rd_bits + y;
668	error = gfs2_meta_wait(sdp, bi->bi_bh);	668	error = gfs2_meta_wait(sdp, bi->bi_bh);
669	if (error)	669	if (error)
670	goto fail;	670	goto fail;
671	if (gfs2_metatype_check(sdp, bi->bi_bh, y ? GFS2_METATYPE_RB :	671	if (gfs2_metatype_check(sdp, bi->bi_bh, y ? GFS2_METATYPE_RB :
672	GFS2_METATYPE_RG)) {	672	GFS2_METATYPE_RG)) {
673	error = -EIO;	673	error = -EIO;
674	goto fail;	674	goto fail;
675	}	675	}
676	}	676	}
677		677
678	if (rgd->rd_rg_vn != gl->gl_vn) {	678	if (rgd->rd_rg_vn != gl->gl_vn) {
679	gfs2_rgrp_in(&rgd->rd_rg, (rgd->rd_bits[0].bi_bh)->b_data);	679	gfs2_rgrp_in(&rgd->rd_rg, (rgd->rd_bits[0].bi_bh)->b_data);
680	rgd->rd_rg_vn = gl->gl_vn;	680	rgd->rd_rg_vn = gl->gl_vn;
681	}	681	}
682		682
683	spin_lock(&sdp->sd_rindex_spin);	683	spin_lock(&sdp->sd_rindex_spin);
684	rgd->rd_free_clone = rgd->rd_rg.rg_free;	684	rgd->rd_free_clone = rgd->rd_rg.rg_free;
685	rgd->rd_bh_count++;	685	rgd->rd_bh_count++;
686	spin_unlock(&sdp->sd_rindex_spin);	686	spin_unlock(&sdp->sd_rindex_spin);
687		687
688	mutex_unlock(&rgd->rd_mutex);	688	mutex_unlock(&rgd->rd_mutex);
689		689
690	return 0;	690	return 0;
691		691
692	fail:	692	fail:
693	while (x--) {	693	while (x--) {
694	bi = rgd->rd_bits + x;	694	bi = rgd->rd_bits + x;
695	brelse(bi->bi_bh);	695	brelse(bi->bi_bh);
696	bi->bi_bh = NULL;	696	bi->bi_bh = NULL;
697	gfs2_assert_warn(sdp, !bi->bi_clone);	697	gfs2_assert_warn(sdp, !bi->bi_clone);
698	}	698	}
699	mutex_unlock(&rgd->rd_mutex);	699	mutex_unlock(&rgd->rd_mutex);
700		700
701	return error;	701	return error;
702	}	702	}
703		703
704	void gfs2_rgrp_bh_hold(struct gfs2_rgrpd *rgd)	704	void gfs2_rgrp_bh_hold(struct gfs2_rgrpd *rgd)
705	{	705	{
706	struct gfs2_sbd *sdp = rgd->rd_sbd;	706	struct gfs2_sbd *sdp = rgd->rd_sbd;
707		707
708	spin_lock(&sdp->sd_rindex_spin);	708	spin_lock(&sdp->sd_rindex_spin);
709	gfs2_assert_warn(rgd->rd_sbd, rgd->rd_bh_count);	709	gfs2_assert_warn(rgd->rd_sbd, rgd->rd_bh_count);
710	rgd->rd_bh_count++;	710	rgd->rd_bh_count++;
711	spin_unlock(&sdp->sd_rindex_spin);	711	spin_unlock(&sdp->sd_rindex_spin);
712	}	712	}
713		713
714	/**	714	/**
715	* gfs2_rgrp_bh_put - Release RG bitmaps read in with gfs2_rgrp_bh_get()	715	* gfs2_rgrp_bh_put - Release RG bitmaps read in with gfs2_rgrp_bh_get()
716	* @rgd: the struct gfs2_rgrpd describing the RG to read in	716	* @rgd: the struct gfs2_rgrpd describing the RG to read in
717	*	717	*
718	*/	718	*/
719		719
720	void gfs2_rgrp_bh_put(struct gfs2_rgrpd *rgd)	720	void gfs2_rgrp_bh_put(struct gfs2_rgrpd *rgd)
721	{	721	{
722	struct gfs2_sbd *sdp = rgd->rd_sbd;	722	struct gfs2_sbd *sdp = rgd->rd_sbd;
723	int x, length = rgd->rd_ri.ri_length;	723	int x, length = rgd->rd_ri.ri_length;
724		724
725	spin_lock(&sdp->sd_rindex_spin);	725	spin_lock(&sdp->sd_rindex_spin);
726	gfs2_assert_warn(rgd->rd_sbd, rgd->rd_bh_count);	726	gfs2_assert_warn(rgd->rd_sbd, rgd->rd_bh_count);
727	if (--rgd->rd_bh_count) {	727	if (--rgd->rd_bh_count) {
728	spin_unlock(&sdp->sd_rindex_spin);	728	spin_unlock(&sdp->sd_rindex_spin);
729	return;	729	return;
730	}	730	}
731		731
732	for (x = 0; x < length; x++) {	732	for (x = 0; x < length; x++) {
733	struct gfs2_bitmap *bi = rgd->rd_bits + x;	733	struct gfs2_bitmap *bi = rgd->rd_bits + x;
734	kfree(bi->bi_clone);	734	kfree(bi->bi_clone);
735	bi->bi_clone = NULL;	735	bi->bi_clone = NULL;
736	brelse(bi->bi_bh);	736	brelse(bi->bi_bh);
737	bi->bi_bh = NULL;	737	bi->bi_bh = NULL;
738	}	738	}
739		739
740	spin_unlock(&sdp->sd_rindex_spin);	740	spin_unlock(&sdp->sd_rindex_spin);
741	}	741	}
742		742
743	void gfs2_rgrp_repolish_clones(struct gfs2_rgrpd *rgd)	743	void gfs2_rgrp_repolish_clones(struct gfs2_rgrpd *rgd)
744	{	744	{
745	struct gfs2_sbd *sdp = rgd->rd_sbd;	745	struct gfs2_sbd *sdp = rgd->rd_sbd;
746	unsigned int length = rgd->rd_ri.ri_length;	746	unsigned int length = rgd->rd_ri.ri_length;
747	unsigned int x;	747	unsigned int x;
748		748
749	for (x = 0; x < length; x++) {	749	for (x = 0; x < length; x++) {
750	struct gfs2_bitmap *bi = rgd->rd_bits + x;	750	struct gfs2_bitmap *bi = rgd->rd_bits + x;
751	if (!bi->bi_clone)	751	if (!bi->bi_clone)
752	continue;	752	continue;
753	memcpy(bi->bi_clone + bi->bi_offset,	753	memcpy(bi->bi_clone + bi->bi_offset,
754	bi->bi_bh->b_data + bi->bi_offset, bi->bi_len);	754	bi->bi_bh->b_data + bi->bi_offset, bi->bi_len);
755	}	755	}
756		756
757	spin_lock(&sdp->sd_rindex_spin);	757	spin_lock(&sdp->sd_rindex_spin);
758	rgd->rd_free_clone = rgd->rd_rg.rg_free;	758	rgd->rd_free_clone = rgd->rd_rg.rg_free;
759	spin_unlock(&sdp->sd_rindex_spin);	759	spin_unlock(&sdp->sd_rindex_spin);
760	}	760	}
761		761
762	/**	762	/**
763	* gfs2_alloc_get - get the struct gfs2_alloc structure for an inode	763	* gfs2_alloc_get - get the struct gfs2_alloc structure for an inode
764	* @ip: the incore GFS2 inode structure	764	* @ip: the incore GFS2 inode structure
765	*	765	*
766	* Returns: the struct gfs2_alloc	766	* Returns: the struct gfs2_alloc
767	*/	767	*/
768		768
769	struct gfs2_alloc gfs2_alloc_get(struct gfs2_inode ip)	769	struct gfs2_alloc gfs2_alloc_get(struct gfs2_inode ip)
770	{	770	{
771	struct gfs2_alloc *al = &ip->i_alloc;	771	struct gfs2_alloc *al = &ip->i_alloc;
772		772
773	/* FIXME: Should assert that the correct locks are held here... */	773	/* FIXME: Should assert that the correct locks are held here... */
774	memset(al, 0, sizeof(*al));	774	memset(al, 0, sizeof(*al));
775	return al;	775	return al;
776	}	776	}
777		777
778	/**	778	/**
779	* try_rgrp_fit - See if a given reservation will fit in a given RG	779	* try_rgrp_fit - See if a given reservation will fit in a given RG
780	* @rgd: the RG data	780	* @rgd: the RG data
781	* @al: the struct gfs2_alloc structure describing the reservation	781	* @al: the struct gfs2_alloc structure describing the reservation
782	*	782	*
783	* If there's room for the requested blocks to be allocated from the RG:	783	* If there's room for the requested blocks to be allocated from the RG:
784	* Sets the $al_rgd field in @al.	784	* Sets the $al_rgd field in @al.
785	*	785	*
786	* Returns: 1 on success (it fits), 0 on failure (it doesn't fit)	786	* Returns: 1 on success (it fits), 0 on failure (it doesn't fit)
787	*/	787	*/
788		788
789	static int try_rgrp_fit(struct gfs2_rgrpd rgd, struct gfs2_alloc al)	789	static int try_rgrp_fit(struct gfs2_rgrpd rgd, struct gfs2_alloc al)
790	{	790	{
791	struct gfs2_sbd *sdp = rgd->rd_sbd;	791	struct gfs2_sbd *sdp = rgd->rd_sbd;
792	int ret = 0;	792	int ret = 0;
793		793
794	if (rgd->rd_rg.rg_flags & GFS2_RGF_NOALLOC)	794	if (rgd->rd_rg.rg_flags & GFS2_RGF_NOALLOC)
795	return 0;	795	return 0;
796		796
797	spin_lock(&sdp->sd_rindex_spin);	797	spin_lock(&sdp->sd_rindex_spin);
798	if (rgd->rd_free_clone >= al->al_requested) {	798	if (rgd->rd_free_clone >= al->al_requested) {
799	al->al_rgd = rgd;	799	al->al_rgd = rgd;
800	ret = 1;	800	ret = 1;
801	}	801	}
802	spin_unlock(&sdp->sd_rindex_spin);	802	spin_unlock(&sdp->sd_rindex_spin);
803		803
804	return ret;	804	return ret;
805	}	805	}
806		806
807	/**	807	/**
808	* recent_rgrp_first - get first RG from "recent" list	808	* recent_rgrp_first - get first RG from "recent" list
809	* @sdp: The GFS2 superblock	809	* @sdp: The GFS2 superblock
810	* @rglast: address of the rgrp used last	810	* @rglast: address of the rgrp used last
811	*	811	*
812	* Returns: The first rgrp in the recent list	812	* Returns: The first rgrp in the recent list
813	*/	813	*/
814		814
815	static struct gfs2_rgrpd recent_rgrp_first(struct gfs2_sbd sdp,	815	static struct gfs2_rgrpd recent_rgrp_first(struct gfs2_sbd sdp,
816	u64 rglast)	816	u64 rglast)
817	{	817	{
818	struct gfs2_rgrpd *rgd = NULL;	818	struct gfs2_rgrpd *rgd = NULL;
819		819
820	spin_lock(&sdp->sd_rindex_spin);	820	spin_lock(&sdp->sd_rindex_spin);
821		821
822	if (list_empty(&sdp->sd_rindex_recent_list))	822	if (list_empty(&sdp->sd_rindex_recent_list))
823	goto out;	823	goto out;
824		824
825	if (!rglast)	825	if (!rglast)
826	goto first;	826	goto first;
827		827
828	list_for_each_entry(rgd, &sdp->sd_rindex_recent_list, rd_recent) {	828	list_for_each_entry(rgd, &sdp->sd_rindex_recent_list, rd_recent) {
829	if (rgd->rd_ri.ri_addr == rglast)	829	if (rgd->rd_ri.ri_addr == rglast)
830	goto out;	830	goto out;
831	}	831	}
832		832
833	first:	833	first:
834	rgd = list_entry(sdp->sd_rindex_recent_list.next, struct gfs2_rgrpd,	834	rgd = list_entry(sdp->sd_rindex_recent_list.next, struct gfs2_rgrpd,
835	rd_recent);	835	rd_recent);
836	out:	836	out:
837	spin_unlock(&sdp->sd_rindex_spin);	837	spin_unlock(&sdp->sd_rindex_spin);
838	return rgd;	838	return rgd;
839	}	839	}
840		840
841	/**	841	/**
842	* recent_rgrp_next - get next RG from "recent" list	842	* recent_rgrp_next - get next RG from "recent" list
843	* @cur_rgd: current rgrp	843	* @cur_rgd: current rgrp
844	* @remove:	844	* @remove:
845	*	845	*
846	* Returns: The next rgrp in the recent list	846	* Returns: The next rgrp in the recent list
847	*/	847	*/
848		848
849	static struct gfs2_rgrpd recent_rgrp_next(struct gfs2_rgrpd cur_rgd,	849	static struct gfs2_rgrpd recent_rgrp_next(struct gfs2_rgrpd cur_rgd,
850	int remove)	850	int remove)
851	{	851	{
852	struct gfs2_sbd *sdp = cur_rgd->rd_sbd;	852	struct gfs2_sbd *sdp = cur_rgd->rd_sbd;
853	struct list_head *head;	853	struct list_head *head;
854	struct gfs2_rgrpd *rgd;	854	struct gfs2_rgrpd *rgd;
855		855
856	spin_lock(&sdp->sd_rindex_spin);	856	spin_lock(&sdp->sd_rindex_spin);
857		857
858	head = &sdp->sd_rindex_recent_list;	858	head = &sdp->sd_rindex_recent_list;
859		859
860	list_for_each_entry(rgd, head, rd_recent) {	860	list_for_each_entry(rgd, head, rd_recent) {
861	if (rgd == cur_rgd) {	861	if (rgd == cur_rgd) {
862	if (cur_rgd->rd_recent.next != head)	862	if (cur_rgd->rd_recent.next != head)
863	rgd = list_entry(cur_rgd->rd_recent.next,	863	rgd = list_entry(cur_rgd->rd_recent.next,
864	struct gfs2_rgrpd, rd_recent);	864	struct gfs2_rgrpd, rd_recent);
865	else	865	else
866	rgd = NULL;	866	rgd = NULL;
867		867
868	if (remove)	868	if (remove)
869	list_del(&cur_rgd->rd_recent);	869	list_del(&cur_rgd->rd_recent);
870		870
871	goto out;	871	goto out;
872	}	872	}
873	}	873	}
874		874
875	rgd = NULL;	875	rgd = NULL;
876	if (!list_empty(head))	876	if (!list_empty(head))
877	rgd = list_entry(head->next, struct gfs2_rgrpd, rd_recent);	877	rgd = list_entry(head->next, struct gfs2_rgrpd, rd_recent);
878		878
879	out:	879	out:
880	spin_unlock(&sdp->sd_rindex_spin);	880	spin_unlock(&sdp->sd_rindex_spin);
881	return rgd;	881	return rgd;
882	}	882	}
883		883
884	/**	884	/**
885	* recent_rgrp_add - add an RG to tail of "recent" list	885	* recent_rgrp_add - add an RG to tail of "recent" list
886	* @new_rgd: The rgrp to add	886	* @new_rgd: The rgrp to add
887	*	887	*
888	*/	888	*/
889		889
890	static void recent_rgrp_add(struct gfs2_rgrpd *new_rgd)	890	static void recent_rgrp_add(struct gfs2_rgrpd *new_rgd)
891	{	891	{
892	struct gfs2_sbd *sdp = new_rgd->rd_sbd;	892	struct gfs2_sbd *sdp = new_rgd->rd_sbd;
893	struct gfs2_rgrpd *rgd;	893	struct gfs2_rgrpd *rgd;
894	unsigned int count = 0;	894	unsigned int count = 0;
895	unsigned int max = sdp->sd_rgrps / gfs2_jindex_size(sdp);	895	unsigned int max = sdp->sd_rgrps / gfs2_jindex_size(sdp);
896		896
897	spin_lock(&sdp->sd_rindex_spin);	897	spin_lock(&sdp->sd_rindex_spin);
898		898
899	list_for_each_entry(rgd, &sdp->sd_rindex_recent_list, rd_recent) {	899	list_for_each_entry(rgd, &sdp->sd_rindex_recent_list, rd_recent) {
900	if (rgd == new_rgd)	900	if (rgd == new_rgd)
901	goto out;	901	goto out;
902		902
903	if (++count >= max)	903	if (++count >= max)
904	goto out;	904	goto out;
905	}	905	}
906	list_add_tail(&new_rgd->rd_recent, &sdp->sd_rindex_recent_list);	906	list_add_tail(&new_rgd->rd_recent, &sdp->sd_rindex_recent_list);
907		907
908	out:	908	out:
909	spin_unlock(&sdp->sd_rindex_spin);	909	spin_unlock(&sdp->sd_rindex_spin);
910	}	910	}
911		911
912	/**	912	/**
913	* forward_rgrp_get - get an rgrp to try next from full list	913	* forward_rgrp_get - get an rgrp to try next from full list
914	* @sdp: The GFS2 superblock	914	* @sdp: The GFS2 superblock
915	*	915	*
916	* Returns: The rgrp to try next	916	* Returns: The rgrp to try next
917	*/	917	*/
918		918
919	static struct gfs2_rgrpd forward_rgrp_get(struct gfs2_sbd sdp)	919	static struct gfs2_rgrpd forward_rgrp_get(struct gfs2_sbd sdp)
920	{	920	{
921	struct gfs2_rgrpd *rgd;	921	struct gfs2_rgrpd *rgd;
922	unsigned int journals = gfs2_jindex_size(sdp);	922	unsigned int journals = gfs2_jindex_size(sdp);
923	unsigned int rg = 0, x;	923	unsigned int rg = 0, x;
924		924
925	spin_lock(&sdp->sd_rindex_spin);	925	spin_lock(&sdp->sd_rindex_spin);
926		926
927	rgd = sdp->sd_rindex_forward;	927	rgd = sdp->sd_rindex_forward;
928	if (!rgd) {	928	if (!rgd) {
929	if (sdp->sd_rgrps >= journals)	929	if (sdp->sd_rgrps >= journals)
930	rg = sdp->sd_rgrps * sdp->sd_jdesc->jd_jid / journals;	930	rg = sdp->sd_rgrps * sdp->sd_jdesc->jd_jid / journals;
931		931
932	for (x = 0, rgd = gfs2_rgrpd_get_first(sdp); x < rg;	932	for (x = 0, rgd = gfs2_rgrpd_get_first(sdp); x < rg;
933	x++, rgd = gfs2_rgrpd_get_next(rgd))	933	x++, rgd = gfs2_rgrpd_get_next(rgd))
934	/* Do Nothing */;	934	/* Do Nothing */;
935		935
936	sdp->sd_rindex_forward = rgd;	936	sdp->sd_rindex_forward = rgd;
937	}	937	}
938		938
939	spin_unlock(&sdp->sd_rindex_spin);	939	spin_unlock(&sdp->sd_rindex_spin);
940		940
941	return rgd;	941	return rgd;
942	}	942	}
943		943
944	/**	944	/**
945	* forward_rgrp_set - set the forward rgrp pointer	945	* forward_rgrp_set - set the forward rgrp pointer
946	* @sdp: the filesystem	946	* @sdp: the filesystem
947	* @rgd: The new forward rgrp	947	* @rgd: The new forward rgrp
948	*	948	*
949	*/	949	*/
950		950
951	static void forward_rgrp_set(struct gfs2_sbd sdp, struct gfs2_rgrpd rgd)	951	static void forward_rgrp_set(struct gfs2_sbd sdp, struct gfs2_rgrpd rgd)
952	{	952	{
953	spin_lock(&sdp->sd_rindex_spin);	953	spin_lock(&sdp->sd_rindex_spin);
954	sdp->sd_rindex_forward = rgd;	954	sdp->sd_rindex_forward = rgd;
955	spin_unlock(&sdp->sd_rindex_spin);	955	spin_unlock(&sdp->sd_rindex_spin);
956	}	956	}
957		957
958	/**	958	/**
959	* get_local_rgrp - Choose and lock a rgrp for allocation	959	* get_local_rgrp - Choose and lock a rgrp for allocation
960	* @ip: the inode to reserve space for	960	* @ip: the inode to reserve space for
961	* @rgp: the chosen and locked rgrp	961	* @rgp: the chosen and locked rgrp
962	*	962	*
963	* Try to acquire rgrp in way which avoids contending with others.	963	* Try to acquire rgrp in way which avoids contending with others.
964	*	964	*
965	* Returns: errno	965	* Returns: errno
966	*/	966	*/
967		967
968	static int get_local_rgrp(struct gfs2_inode *ip)	968	static int get_local_rgrp(struct gfs2_inode *ip)
969	{	969	{
970	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);	970	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
971	struct gfs2_rgrpd rgd, begin = NULL;	971	struct gfs2_rgrpd rgd, begin = NULL;
972	struct gfs2_alloc *al = &ip->i_alloc;	972	struct gfs2_alloc *al = &ip->i_alloc;
973	int flags = LM_FLAG_TRY;	973	int flags = LM_FLAG_TRY;
974	int skipped = 0;	974	int skipped = 0;
975	int loops = 0;	975	int loops = 0;
976	int error;	976	int error;
977		977
978	/* Try recently successful rgrps */	978	/* Try recently successful rgrps */
979		979
980	rgd = recent_rgrp_first(sdp, ip->i_last_rg_alloc);	980	rgd = recent_rgrp_first(sdp, ip->i_last_rg_alloc);
981		981
982	while (rgd) {	982	while (rgd) {
983	error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE,	983	error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE,
984	LM_FLAG_TRY, &al->al_rgd_gh);	984	LM_FLAG_TRY, &al->al_rgd_gh);
985	switch (error) {	985	switch (error) {
986	case 0:	986	case 0:
987	if (try_rgrp_fit(rgd, al))	987	if (try_rgrp_fit(rgd, al))
988	goto out;	988	goto out;
989	gfs2_glock_dq_uninit(&al->al_rgd_gh);	989	gfs2_glock_dq_uninit(&al->al_rgd_gh);
990	rgd = recent_rgrp_next(rgd, 1);	990	rgd = recent_rgrp_next(rgd, 1);
991	break;	991	break;
992		992
993	case GLR_TRYFAILED:	993	case GLR_TRYFAILED:
994	rgd = recent_rgrp_next(rgd, 0);	994	rgd = recent_rgrp_next(rgd, 0);
995	break;	995	break;
996		996
997	default:	997	default:
998	return error;	998	return error;
999	}	999	}
1000	}	1000	}
1001		1001
1002	/* Go through full list of rgrps */	1002	/* Go through full list of rgrps */
1003		1003
1004	begin = rgd = forward_rgrp_get(sdp);	1004	begin = rgd = forward_rgrp_get(sdp);
1005		1005
1006	for (;;) {	1006	for (;;) {
1007	error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, flags,	1007	error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, flags,
1008	&al->al_rgd_gh);	1008	&al->al_rgd_gh);
1009	switch (error) {	1009	switch (error) {
1010	case 0:	1010	case 0:
1011	if (try_rgrp_fit(rgd, al))	1011	if (try_rgrp_fit(rgd, al))
1012	goto out;	1012	goto out;
1013	gfs2_glock_dq_uninit(&al->al_rgd_gh);	1013	gfs2_glock_dq_uninit(&al->al_rgd_gh);
1014	break;	1014	break;
1015		1015
1016	case GLR_TRYFAILED:	1016	case GLR_TRYFAILED:
1017	skipped++;	1017	skipped++;
1018	break;	1018	break;
1019		1019
1020	default:	1020	default:
1021	return error;	1021	return error;
1022	}	1022	}
1023		1023
1024	rgd = gfs2_rgrpd_get_next(rgd);	1024	rgd = gfs2_rgrpd_get_next(rgd);
1025	if (!rgd)	1025	if (!rgd)
1026	rgd = gfs2_rgrpd_get_first(sdp);	1026	rgd = gfs2_rgrpd_get_first(sdp);
1027		1027
1028	if (rgd == begin) {	1028	if (rgd == begin) {
1029	if (++loops >= 3)	1029	if (++loops >= 3)
1030	return -ENOSPC;	1030	return -ENOSPC;
1031	if (!skipped)	1031	if (!skipped)
1032	loops++;	1032	loops++;
1033	flags = 0;	1033	flags = 0;
1034	if (loops == 2)	1034	if (loops == 2)
1035	gfs2_log_flush(sdp, NULL);	1035	gfs2_log_flush(sdp, NULL);
1036	}	1036	}
1037	}	1037	}
1038		1038
1039	out:	1039	out:
1040	ip->i_last_rg_alloc = rgd->rd_ri.ri_addr;	1040	ip->i_last_rg_alloc = rgd->rd_ri.ri_addr;
1041		1041
1042	if (begin) {	1042	if (begin) {
1043	recent_rgrp_add(rgd);	1043	recent_rgrp_add(rgd);
1044	rgd = gfs2_rgrpd_get_next(rgd);	1044	rgd = gfs2_rgrpd_get_next(rgd);
1045	if (!rgd)	1045	if (!rgd)
1046	rgd = gfs2_rgrpd_get_first(sdp);	1046	rgd = gfs2_rgrpd_get_first(sdp);
1047	forward_rgrp_set(sdp, rgd);	1047	forward_rgrp_set(sdp, rgd);
1048	}	1048	}
1049		1049
1050	return 0;	1050	return 0;
1051	}	1051	}
1052		1052
1053	/**	1053	/**
1054	* gfs2_inplace_reserve_i - Reserve space in the filesystem	1054	* gfs2_inplace_reserve_i - Reserve space in the filesystem
1055	* @ip: the inode to reserve space for	1055	* @ip: the inode to reserve space for
1056	*	1056	*
1057	* Returns: errno	1057	* Returns: errno
1058	*/	1058	*/
1059		1059
1060	int gfs2_inplace_reserve_i(struct gfs2_inode ip, char file, unsigned int line)	1060	int gfs2_inplace_reserve_i(struct gfs2_inode ip, char file, unsigned int line)
1061	{	1061	{
1062	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);	1062	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1063	struct gfs2_alloc *al = &ip->i_alloc;	1063	struct gfs2_alloc *al = &ip->i_alloc;
1064	int error = 0;	1064	int error = 0;
1065		1065
1066	if (gfs2_assert_warn(sdp, al->al_requested))	1066	if (gfs2_assert_warn(sdp, al->al_requested))
1067	return -EINVAL;	1067	return -EINVAL;
1068		1068
1069	/* We need to hold the rindex unless the inode we're using is	1069	/* We need to hold the rindex unless the inode we're using is
1070	the rindex itself, in which case it's already held. */	1070	the rindex itself, in which case it's already held. */
1071	if (ip != GFS2_I(sdp->sd_rindex))	1071	if (ip != GFS2_I(sdp->sd_rindex))
1072	error = gfs2_rindex_hold(sdp, &al->al_ri_gh);	1072	error = gfs2_rindex_hold(sdp, &al->al_ri_gh);
1073	else if (!sdp->sd_rgrps) /* We may not have the rindex read in, so: */	1073	else if (!sdp->sd_rgrps) /* We may not have the rindex read in, so: */
1074	error = gfs2_ri_update_special(ip);	1074	error = gfs2_ri_update_special(ip);
1075		1075
1076	if (error)	1076	if (error)
1077	return error;	1077	return error;
1078		1078
1079	error = get_local_rgrp(ip);	1079	error = get_local_rgrp(ip);
1080	if (error) {	1080	if (error) {
1081	if (ip != GFS2_I(sdp->sd_rindex))	1081	if (ip != GFS2_I(sdp->sd_rindex))
1082	gfs2_glock_dq_uninit(&al->al_ri_gh);	1082	gfs2_glock_dq_uninit(&al->al_ri_gh);
1083	return error;	1083	return error;
1084	}	1084	}
1085		1085
1086	al->al_file = file;	1086	al->al_file = file;
1087	al->al_line = line;	1087	al->al_line = line;
1088		1088
1089	return 0;	1089	return 0;
1090	}	1090	}
1091		1091
1092	/**	1092	/**
1093	* gfs2_inplace_release - release an inplace reservation	1093	* gfs2_inplace_release - release an inplace reservation
1094	* @ip: the inode the reservation was taken out on	1094	* @ip: the inode the reservation was taken out on
1095	*	1095	*
1096	* Release a reservation made by gfs2_inplace_reserve().	1096	* Release a reservation made by gfs2_inplace_reserve().
1097	*/	1097	*/
1098		1098
1099	void gfs2_inplace_release(struct gfs2_inode *ip)	1099	void gfs2_inplace_release(struct gfs2_inode *ip)
1100	{	1100	{
1101	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);	1101	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1102	struct gfs2_alloc *al = &ip->i_alloc;	1102	struct gfs2_alloc *al = &ip->i_alloc;
1103		1103
1104	if (gfs2_assert_warn(sdp, al->al_alloced <= al->al_requested) == -1)	1104	if (gfs2_assert_warn(sdp, al->al_alloced <= al->al_requested) == -1)
1105	fs_warn(sdp, "al_alloced = %u, al_requested = %u "	1105	fs_warn(sdp, "al_alloced = %u, al_requested = %u "
1106	"al_file = %s, al_line = %u\n",	1106	"al_file = %s, al_line = %u\n",
1107	al->al_alloced, al->al_requested, al->al_file,	1107	al->al_alloced, al->al_requested, al->al_file,
1108	al->al_line);	1108	al->al_line);
1109		1109
1110	al->al_rgd = NULL;	1110	al->al_rgd = NULL;
1111	gfs2_glock_dq_uninit(&al->al_rgd_gh);	1111	gfs2_glock_dq_uninit(&al->al_rgd_gh);
1112	if (ip != GFS2_I(sdp->sd_rindex))	1112	if (ip != GFS2_I(sdp->sd_rindex))
1113	gfs2_glock_dq_uninit(&al->al_ri_gh);	1113	gfs2_glock_dq_uninit(&al->al_ri_gh);
1114	}	1114	}
1115		1115
1116	/**	1116	/**
1117	* gfs2_get_block_type - Check a block in a RG is of given type	1117	* gfs2_get_block_type - Check a block in a RG is of given type
1118	* @rgd: the resource group holding the block	1118	* @rgd: the resource group holding the block
1119	* @block: the block number	1119	* @block: the block number
1120	*	1120	*
1121	* Returns: The block type (GFS2_BLKST_*)	1121	* Returns: The block type (GFS2_BLKST_*)
1122	*/	1122	*/
1123		1123
1124	unsigned char gfs2_get_block_type(struct gfs2_rgrpd *rgd, u64 block)	1124	unsigned char gfs2_get_block_type(struct gfs2_rgrpd *rgd, u64 block)
1125	{	1125	{
1126	struct gfs2_bitmap *bi = NULL;	1126	struct gfs2_bitmap *bi = NULL;
1127	u32 length, rgrp_block, buf_block;	1127	u32 length, rgrp_block, buf_block;
1128	unsigned int buf;	1128	unsigned int buf;
1129	unsigned char type;	1129	unsigned char type;
1130		1130
1131	length = rgd->rd_ri.ri_length;	1131	length = rgd->rd_ri.ri_length;
1132	rgrp_block = block - rgd->rd_ri.ri_data0;	1132	rgrp_block = block - rgd->rd_ri.ri_data0;
1133		1133
1134	for (buf = 0; buf < length; buf++) {	1134	for (buf = 0; buf < length; buf++) {
1135	bi = rgd->rd_bits + buf;	1135	bi = rgd->rd_bits + buf;
1136	if (rgrp_block < (bi->bi_start + bi->bi_len) * GFS2_NBBY)	1136	if (rgrp_block < (bi->bi_start + bi->bi_len) * GFS2_NBBY)
1137	break;	1137	break;
1138	}	1138	}
1139		1139
1140	gfs2_assert(rgd->rd_sbd, buf < length);	1140	gfs2_assert(rgd->rd_sbd, buf < length);
1141	buf_block = rgrp_block - bi->bi_start * GFS2_NBBY;	1141	buf_block = rgrp_block - bi->bi_start * GFS2_NBBY;
1142		1142
1143	type = gfs2_testbit(rgd, bi->bi_bh->b_data + bi->bi_offset,	1143	type = gfs2_testbit(rgd, bi->bi_bh->b_data + bi->bi_offset,
1144	bi->bi_len, buf_block);	1144	bi->bi_len, buf_block);
1145		1145
1146	return type;	1146	return type;
1147	}	1147	}
1148		1148
1149	/**	1149	/**
1150	* rgblk_search - find a block in @old_state, change allocation	1150	* rgblk_search - find a block in @old_state, change allocation
1151	* state to @new_state	1151	* state to @new_state
1152	* @rgd: the resource group descriptor	1152	* @rgd: the resource group descriptor
1153	* @goal: the goal block within the RG (start here to search for avail block)	1153	* @goal: the goal block within the RG (start here to search for avail block)
1154	* @old_state: GFS2_BLKST_XXX the before-allocation state to find	1154	* @old_state: GFS2_BLKST_XXX the before-allocation state to find
1155	* @new_state: GFS2_BLKST_XXX the after-allocation block state	1155	* @new_state: GFS2_BLKST_XXX the after-allocation block state
1156	*	1156	*
1157	* Walk rgrp's bitmap to find bits that represent a block in @old_state.	1157	* Walk rgrp's bitmap to find bits that represent a block in @old_state.
1158	* Add the found bitmap buffer to the transaction.	1158	* Add the found bitmap buffer to the transaction.
1159	* Set the found bits to @new_state to change block's allocation state.	1159	* Set the found bits to @new_state to change block's allocation state.
1160	*	1160	*
1161	* This function never fails, because we wouldn't call it unless we	1161	* This function never fails, because we wouldn't call it unless we
1162	* know (from reservation results, etc.) that a block is available.	1162	* know (from reservation results, etc.) that a block is available.
1163	*	1163	*
1164	* Scope of @goal and returned block is just within rgrp, not the whole	1164	* Scope of @goal and returned block is just within rgrp, not the whole
1165	* filesystem.	1165	* filesystem.
1166	*	1166	*
1167	* Returns: the block number allocated	1167	* Returns: the block number allocated
1168	*/	1168	*/
1169		1169
1170	static u32 rgblk_search(struct gfs2_rgrpd *rgd, u32 goal,	1170	static u32 rgblk_search(struct gfs2_rgrpd *rgd, u32 goal,
1171	unsigned char old_state, unsigned char new_state)	1171	unsigned char old_state, unsigned char new_state)
1172	{	1172	{
1173	struct gfs2_bitmap *bi = NULL;	1173	struct gfs2_bitmap *bi = NULL;
1174	u32 length = rgd->rd_ri.ri_length;	1174	u32 length = rgd->rd_ri.ri_length;
1175	u32 blk = 0;	1175	u32 blk = 0;
1176	unsigned int buf, x;	1176	unsigned int buf, x;
1177		1177
1178	/* Find bitmap block that contains bits for goal block */	1178	/* Find bitmap block that contains bits for goal block */
1179	for (buf = 0; buf < length; buf++) {	1179	for (buf = 0; buf < length; buf++) {
1180	bi = rgd->rd_bits + buf;	1180	bi = rgd->rd_bits + buf;
1181	if (goal < (bi->bi_start + bi->bi_len) * GFS2_NBBY)	1181	if (goal < (bi->bi_start + bi->bi_len) * GFS2_NBBY)
1182	break;	1182	break;
1183	}	1183	}
1184		1184
1185	gfs2_assert(rgd->rd_sbd, buf < length);	1185	gfs2_assert(rgd->rd_sbd, buf < length);
1186		1186
1187	/* Convert scope of "goal" from rgrp-wide to within found bit block */	1187	/* Convert scope of "goal" from rgrp-wide to within found bit block */
1188	goal -= bi->bi_start * GFS2_NBBY;	1188	goal -= bi->bi_start * GFS2_NBBY;
1189		1189
1190	/* Search (up to entire) bitmap in this rgrp for allocatable block.	1190	/* Search (up to entire) bitmap in this rgrp for allocatable block.
1191	"x <= length", instead of "x < length", because we typically start	1191	"x <= length", instead of "x < length", because we typically start
1192	the search in the middle of a bit block, but if we can't find an	1192	the search in the middle of a bit block, but if we can't find an
1193	allocatable block anywhere else, we want to be able wrap around and	1193	allocatable block anywhere else, we want to be able wrap around and
1194	search in the first part of our first-searched bit block. */	1194	search in the first part of our first-searched bit block. */
1195	for (x = 0; x <= length; x++) {	1195	for (x = 0; x <= length; x++) {
1196	if (bi->bi_clone)	1196	if (bi->bi_clone)
1197	blk = gfs2_bitfit(rgd, bi->bi_clone + bi->bi_offset,	1197	blk = gfs2_bitfit(rgd, bi->bi_clone + bi->bi_offset,
1198	bi->bi_len, goal, old_state);	1198	bi->bi_len, goal, old_state);
1199	else	1199	else
1200	blk = gfs2_bitfit(rgd,	1200	blk = gfs2_bitfit(rgd,
1201	bi->bi_bh->b_data + bi->bi_offset,	1201	bi->bi_bh->b_data + bi->bi_offset,
1202	bi->bi_len, goal, old_state);	1202	bi->bi_len, goal, old_state);
1203	if (blk != BFITNOENT)	1203	if (blk != BFITNOENT)
1204	break;	1204	break;
1205		1205
1206	/* Try next bitmap block (wrap back to rgrp header if at end) */	1206	/* Try next bitmap block (wrap back to rgrp header if at end) */
1207	buf = (buf + 1) % length;	1207	buf = (buf + 1) % length;
1208	bi = rgd->rd_bits + buf;	1208	bi = rgd->rd_bits + buf;
1209	goal = 0;	1209	goal = 0;
1210	}	1210	}
1211		1211
1212	if (gfs2_assert_withdraw(rgd->rd_sbd, x <= length))	1212	if (gfs2_assert_withdraw(rgd->rd_sbd, x <= length))
1213	blk = 0;	1213	blk = 0;
1214		1214
1215	gfs2_trans_add_bh(rgd->rd_gl, bi->bi_bh, 1);	1215	gfs2_trans_add_bh(rgd->rd_gl, bi->bi_bh, 1);
1216	gfs2_setbit(rgd, bi->bi_bh->b_data + bi->bi_offset,	1216	gfs2_setbit(rgd, bi->bi_bh->b_data + bi->bi_offset,
1217	bi->bi_len, blk, new_state);	1217	bi->bi_len, blk, new_state);
1218	if (bi->bi_clone)	1218	if (bi->bi_clone)
1219	gfs2_setbit(rgd, bi->bi_clone + bi->bi_offset,	1219	gfs2_setbit(rgd, bi->bi_clone + bi->bi_offset,
1220	bi->bi_len, blk, new_state);	1220	bi->bi_len, blk, new_state);
1221		1221
1222	return bi->bi_start * GFS2_NBBY + blk;	1222	return bi->bi_start * GFS2_NBBY + blk;
1223	}	1223	}
1224		1224
1225	/**	1225	/**
1226	* rgblk_free - Change alloc state of given block(s)	1226	* rgblk_free - Change alloc state of given block(s)
1227	* @sdp: the filesystem	1227	* @sdp: the filesystem
1228	* @bstart: the start of a run of blocks to free	1228	* @bstart: the start of a run of blocks to free
1229	* @blen: the length of the block run (all must lie within ONE RG!)	1229	* @blen: the length of the block run (all must lie within ONE RG!)
1230	* @new_state: GFS2_BLKST_XXX the after-allocation block state	1230	* @new_state: GFS2_BLKST_XXX the after-allocation block state
1231	*	1231	*
1232	* Returns: Resource group containing the block(s)	1232	* Returns: Resource group containing the block(s)
1233	*/	1233	*/
1234		1234
1235	static struct gfs2_rgrpd rgblk_free(struct gfs2_sbd sdp, u64 bstart,	1235	static struct gfs2_rgrpd rgblk_free(struct gfs2_sbd sdp, u64 bstart,
1236	u32 blen, unsigned char new_state)	1236	u32 blen, unsigned char new_state)
1237	{	1237	{
1238	struct gfs2_rgrpd *rgd;	1238	struct gfs2_rgrpd *rgd;
1239	struct gfs2_bitmap *bi = NULL;	1239	struct gfs2_bitmap *bi = NULL;
1240	u32 length, rgrp_blk, buf_blk;	1240	u32 length, rgrp_blk, buf_blk;
1241	unsigned int buf;	1241	unsigned int buf;
1242		1242
1243	rgd = gfs2_blk2rgrpd(sdp, bstart);	1243	rgd = gfs2_blk2rgrpd(sdp, bstart);
1244	if (!rgd) {	1244	if (!rgd) {
1245	if (gfs2_consist(sdp))	1245	if (gfs2_consist(sdp))
1246	fs_err(sdp, "block = %llu\n", (unsigned long long)bstart);	1246	fs_err(sdp, "block = %llu\n", (unsigned long long)bstart);
1247	return NULL;	1247	return NULL;
1248	}	1248	}
1249		1249
1250	length = rgd->rd_ri.ri_length;	1250	length = rgd->rd_ri.ri_length;
1251		1251
1252	rgrp_blk = bstart - rgd->rd_ri.ri_data0;	1252	rgrp_blk = bstart - rgd->rd_ri.ri_data0;
1253		1253
1254	while (blen--) {	1254	while (blen--) {
1255	for (buf = 0; buf < length; buf++) {	1255	for (buf = 0; buf < length; buf++) {
1256	bi = rgd->rd_bits + buf;	1256	bi = rgd->rd_bits + buf;
1257	if (rgrp_blk < (bi->bi_start + bi->bi_len) * GFS2_NBBY)	1257	if (rgrp_blk < (bi->bi_start + bi->bi_len) * GFS2_NBBY)
1258	break;	1258	break;
1259	}	1259	}
1260		1260
1261	gfs2_assert(rgd->rd_sbd, buf < length);	1261	gfs2_assert(rgd->rd_sbd, buf < length);
1262		1262
1263	buf_blk = rgrp_blk - bi->bi_start * GFS2_NBBY;	1263	buf_blk = rgrp_blk - bi->bi_start * GFS2_NBBY;
1264	rgrp_blk++;	1264	rgrp_blk++;
1265		1265
1266	if (!bi->bi_clone) {	1266	if (!bi->bi_clone) {
1267	bi->bi_clone = kmalloc(bi->bi_bh->b_size,	1267	bi->bi_clone = kmalloc(bi->bi_bh->b_size,
1268	GFP_NOFS \| __GFP_NOFAIL);	1268	GFP_NOFS \| __GFP_NOFAIL);
1269	memcpy(bi->bi_clone + bi->bi_offset,	1269	memcpy(bi->bi_clone + bi->bi_offset,
1270	bi->bi_bh->b_data + bi->bi_offset,	1270	bi->bi_bh->b_data + bi->bi_offset,
1271	bi->bi_len);	1271	bi->bi_len);
1272	}	1272	}
1273	gfs2_trans_add_bh(rgd->rd_gl, bi->bi_bh, 1);	1273	gfs2_trans_add_bh(rgd->rd_gl, bi->bi_bh, 1);
1274	gfs2_setbit(rgd, bi->bi_bh->b_data + bi->bi_offset,	1274	gfs2_setbit(rgd, bi->bi_bh->b_data + bi->bi_offset,
1275	bi->bi_len, buf_blk, new_state);	1275	bi->bi_len, buf_blk, new_state);
1276	}	1276	}
1277		1277
1278	return rgd;	1278	return rgd;
1279	}	1279	}
1280		1280
1281	/**	1281	/**
1282	* gfs2_alloc_data - Allocate a data block	1282	* gfs2_alloc_data - Allocate a data block
1283	* @ip: the inode to allocate the data block for	1283	* @ip: the inode to allocate the data block for
1284	*	1284	*
1285	* Returns: the allocated block	1285	* Returns: the allocated block
1286	*/	1286	*/
1287		1287
1288	u64 gfs2_alloc_data(struct gfs2_inode *ip)	1288	u64 gfs2_alloc_data(struct gfs2_inode *ip)
1289	{	1289	{
1290	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);	1290	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1291	struct gfs2_alloc *al = &ip->i_alloc;	1291	struct gfs2_alloc *al = &ip->i_alloc;
1292	struct gfs2_rgrpd *rgd = al->al_rgd;	1292	struct gfs2_rgrpd *rgd = al->al_rgd;
1293	u32 goal, blk;	1293	u32 goal, blk;
1294	u64 block;	1294	u64 block;
1295		1295
1296	if (rgrp_contains_block(&rgd->rd_ri, ip->i_di.di_goal_data))	1296	if (rgrp_contains_block(&rgd->rd_ri, ip->i_di.di_goal_data))
1297	goal = ip->i_di.di_goal_data - rgd->rd_ri.ri_data0;	1297	goal = ip->i_di.di_goal_data - rgd->rd_ri.ri_data0;
1298	else	1298	else
1299	goal = rgd->rd_last_alloc_data;	1299	goal = rgd->rd_last_alloc_data;
1300		1300
1301	blk = rgblk_search(rgd, goal, GFS2_BLKST_FREE, GFS2_BLKST_USED);	1301	blk = rgblk_search(rgd, goal, GFS2_BLKST_FREE, GFS2_BLKST_USED);
1302	rgd->rd_last_alloc_data = blk;	1302	rgd->rd_last_alloc_data = blk;
1303		1303
1304	block = rgd->rd_ri.ri_data0 + blk;	1304	block = rgd->rd_ri.ri_data0 + blk;
1305	ip->i_di.di_goal_data = block;	1305	ip->i_di.di_goal_data = block;
1306		1306
1307	gfs2_assert_withdraw(sdp, rgd->rd_rg.rg_free);	1307	gfs2_assert_withdraw(sdp, rgd->rd_rg.rg_free);
1308	rgd->rd_rg.rg_free--;	1308	rgd->rd_rg.rg_free--;
1309		1309
1310	gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);	1310	gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
1311	gfs2_rgrp_out(&rgd->rd_rg, rgd->rd_bits[0].bi_bh->b_data);	1311	gfs2_rgrp_out(&rgd->rd_rg, rgd->rd_bits[0].bi_bh->b_data);
1312		1312
1313	al->al_alloced++;	1313	al->al_alloced++;
1314		1314
1315	gfs2_statfs_change(sdp, 0, -1, 0);	1315	gfs2_statfs_change(sdp, 0, -1, 0);
1316	gfs2_quota_change(ip, +1, ip->i_inode.i_uid, ip->i_inode.i_gid);	1316	gfs2_quota_change(ip, +1, ip->i_inode.i_uid, ip->i_inode.i_gid);
1317		1317
1318	spin_lock(&sdp->sd_rindex_spin);	1318	spin_lock(&sdp->sd_rindex_spin);
1319	rgd->rd_free_clone--;	1319	rgd->rd_free_clone--;
1320	spin_unlock(&sdp->sd_rindex_spin);	1320	spin_unlock(&sdp->sd_rindex_spin);
1321		1321
1322	return block;	1322	return block;
1323	}	1323	}
1324		1324
1325	/**	1325	/**
1326	* gfs2_alloc_meta - Allocate a metadata block	1326	* gfs2_alloc_meta - Allocate a metadata block
1327	* @ip: the inode to allocate the metadata block for	1327	* @ip: the inode to allocate the metadata block for
1328	*	1328	*
1329	* Returns: the allocated block	1329	* Returns: the allocated block
1330	*/	1330	*/
1331		1331
1332	u64 gfs2_alloc_meta(struct gfs2_inode *ip)	1332	u64 gfs2_alloc_meta(struct gfs2_inode *ip)
1333	{	1333	{
1334	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);	1334	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1335	struct gfs2_alloc *al = &ip->i_alloc;	1335	struct gfs2_alloc *al = &ip->i_alloc;
1336	struct gfs2_rgrpd *rgd = al->al_rgd;	1336	struct gfs2_rgrpd *rgd = al->al_rgd;
1337	u32 goal, blk;	1337	u32 goal, blk;
1338	u64 block;	1338	u64 block;
1339		1339
1340	if (rgrp_contains_block(&rgd->rd_ri, ip->i_di.di_goal_meta))	1340	if (rgrp_contains_block(&rgd->rd_ri, ip->i_di.di_goal_meta))
1341	goal = ip->i_di.di_goal_meta - rgd->rd_ri.ri_data0;	1341	goal = ip->i_di.di_goal_meta - rgd->rd_ri.ri_data0;
1342	else	1342	else
1343	goal = rgd->rd_last_alloc_meta;	1343	goal = rgd->rd_last_alloc_meta;
1344		1344
1345	blk = rgblk_search(rgd, goal, GFS2_BLKST_FREE, GFS2_BLKST_USED);	1345	blk = rgblk_search(rgd, goal, GFS2_BLKST_FREE, GFS2_BLKST_USED);
1346	rgd->rd_last_alloc_meta = blk;	1346	rgd->rd_last_alloc_meta = blk;
1347		1347
1348	block = rgd->rd_ri.ri_data0 + blk;	1348	block = rgd->rd_ri.ri_data0 + blk;
1349	ip->i_di.di_goal_meta = block;	1349	ip->i_di.di_goal_meta = block;
1350		1350
1351	gfs2_assert_withdraw(sdp, rgd->rd_rg.rg_free);	1351	gfs2_assert_withdraw(sdp, rgd->rd_rg.rg_free);
1352	rgd->rd_rg.rg_free--;	1352	rgd->rd_rg.rg_free--;
1353		1353
1354	gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);	1354	gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
1355	gfs2_rgrp_out(&rgd->rd_rg, rgd->rd_bits[0].bi_bh->b_data);	1355	gfs2_rgrp_out(&rgd->rd_rg, rgd->rd_bits[0].bi_bh->b_data);
1356		1356
1357	al->al_alloced++;	1357	al->al_alloced++;
1358		1358
1359	gfs2_statfs_change(sdp, 0, -1, 0);	1359	gfs2_statfs_change(sdp, 0, -1, 0);
1360	gfs2_quota_change(ip, +1, ip->i_inode.i_uid, ip->i_inode.i_gid);	1360	gfs2_quota_change(ip, +1, ip->i_inode.i_uid, ip->i_inode.i_gid);
1361	gfs2_trans_add_unrevoke(sdp, block);	1361	gfs2_trans_add_unrevoke(sdp, block);
1362		1362
1363	spin_lock(&sdp->sd_rindex_spin);	1363	spin_lock(&sdp->sd_rindex_spin);
1364	rgd->rd_free_clone--;	1364	rgd->rd_free_clone--;
1365	spin_unlock(&sdp->sd_rindex_spin);	1365	spin_unlock(&sdp->sd_rindex_spin);
1366		1366
1367	return block;	1367	return block;
1368	}	1368	}
1369		1369
1370	/**	1370	/**
1371	* gfs2_alloc_di - Allocate a dinode	1371	* gfs2_alloc_di - Allocate a dinode
1372	* @dip: the directory that the inode is going in	1372	* @dip: the directory that the inode is going in
1373	*	1373	*
1374	* Returns: the block allocated	1374	* Returns: the block allocated
1375	*/	1375	*/
1376		1376
1377	u64 gfs2_alloc_di(struct gfs2_inode dip, u64 generation)	1377	u64 gfs2_alloc_di(struct gfs2_inode dip, u64 generation)
1378	{	1378	{
1379	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);	1379	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
1380	struct gfs2_alloc *al = &dip->i_alloc;	1380	struct gfs2_alloc *al = &dip->i_alloc;
1381	struct gfs2_rgrpd *rgd = al->al_rgd;	1381	struct gfs2_rgrpd *rgd = al->al_rgd;
1382	u32 blk;	1382	u32 blk;
1383	u64 block;	1383	u64 block;
1384		1384
1385	blk = rgblk_search(rgd, rgd->rd_last_alloc_meta,	1385	blk = rgblk_search(rgd, rgd->rd_last_alloc_meta,
1386	GFS2_BLKST_FREE, GFS2_BLKST_DINODE);	1386	GFS2_BLKST_FREE, GFS2_BLKST_DINODE);
1387		1387
1388	rgd->rd_last_alloc_meta = blk;	1388	rgd->rd_last_alloc_meta = blk;
1389		1389
1390	block = rgd->rd_ri.ri_data0 + blk;	1390	block = rgd->rd_ri.ri_data0 + blk;
1391		1391
1392	gfs2_assert_withdraw(sdp, rgd->rd_rg.rg_free);	1392	gfs2_assert_withdraw(sdp, rgd->rd_rg.rg_free);
1393	rgd->rd_rg.rg_free--;	1393	rgd->rd_rg.rg_free--;
1394	rgd->rd_rg.rg_dinodes++;	1394	rgd->rd_rg.rg_dinodes++;
1395	*generation = rgd->rd_rg.rg_igeneration++;	1395	*generation = rgd->rd_rg.rg_igeneration++;
1396	gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);	1396	gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
1397	gfs2_rgrp_out(&rgd->rd_rg, rgd->rd_bits[0].bi_bh->b_data);	1397	gfs2_rgrp_out(&rgd->rd_rg, rgd->rd_bits[0].bi_bh->b_data);
1398		1398
1399	al->al_alloced++;	1399	al->al_alloced++;
1400		1400
1401	gfs2_statfs_change(sdp, 0, -1, +1);	1401	gfs2_statfs_change(sdp, 0, -1, +1);
1402	gfs2_trans_add_unrevoke(sdp, block);	1402	gfs2_trans_add_unrevoke(sdp, block);
1403		1403
1404	spin_lock(&sdp->sd_rindex_spin);	1404	spin_lock(&sdp->sd_rindex_spin);
1405	rgd->rd_free_clone--;	1405	rgd->rd_free_clone--;
1406	spin_unlock(&sdp->sd_rindex_spin);	1406	spin_unlock(&sdp->sd_rindex_spin);
1407		1407
1408	return block;	1408	return block;
1409	}	1409	}
1410		1410
1411	/**	1411	/**
1412	* gfs2_free_data - free a contiguous run of data block(s)	1412	* gfs2_free_data - free a contiguous run of data block(s)
1413	* @ip: the inode these blocks are being freed from	1413	* @ip: the inode these blocks are being freed from
1414	* @bstart: first block of a run of contiguous blocks	1414	* @bstart: first block of a run of contiguous blocks
1415	* @blen: the length of the block run	1415	* @blen: the length of the block run
1416	*	1416	*
1417	*/	1417	*/
1418		1418
1419	void gfs2_free_data(struct gfs2_inode *ip, u64 bstart, u32 blen)	1419	void gfs2_free_data(struct gfs2_inode *ip, u64 bstart, u32 blen)
1420	{	1420	{
1421	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);	1421	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1422	struct gfs2_rgrpd *rgd;	1422	struct gfs2_rgrpd *rgd;
1423		1423
1424	rgd = rgblk_free(sdp, bstart, blen, GFS2_BLKST_FREE);	1424	rgd = rgblk_free(sdp, bstart, blen, GFS2_BLKST_FREE);
1425	if (!rgd)	1425	if (!rgd)
1426	return;	1426	return;
1427		1427
1428	rgd->rd_rg.rg_free += blen;	1428	rgd->rd_rg.rg_free += blen;
1429		1429
1430	gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);	1430	gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
1431	gfs2_rgrp_out(&rgd->rd_rg, rgd->rd_bits[0].bi_bh->b_data);	1431	gfs2_rgrp_out(&rgd->rd_rg, rgd->rd_bits[0].bi_bh->b_data);
1432		1432
1433	gfs2_trans_add_rg(rgd);	1433	gfs2_trans_add_rg(rgd);
1434		1434
1435	gfs2_statfs_change(sdp, 0, +blen, 0);	1435	gfs2_statfs_change(sdp, 0, +blen, 0);
1436	gfs2_quota_change(ip, -(s64)blen, ip->i_inode.i_uid, ip->i_inode.i_gid);	1436	gfs2_quota_change(ip, -(s64)blen, ip->i_inode.i_uid, ip->i_inode.i_gid);
1437	}	1437	}
1438		1438
1439	/**	1439	/**
1440	* gfs2_free_meta - free a contiguous run of data block(s)	1440	* gfs2_free_meta - free a contiguous run of data block(s)
1441	* @ip: the inode these blocks are being freed from	1441	* @ip: the inode these blocks are being freed from
1442	* @bstart: first block of a run of contiguous blocks	1442	* @bstart: first block of a run of contiguous blocks
1443	* @blen: the length of the block run	1443	* @blen: the length of the block run
1444	*	1444	*
1445	*/	1445	*/
1446		1446
1447	void gfs2_free_meta(struct gfs2_inode *ip, u64 bstart, u32 blen)	1447	void gfs2_free_meta(struct gfs2_inode *ip, u64 bstart, u32 blen)
1448	{	1448	{
1449	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);	1449	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1450	struct gfs2_rgrpd *rgd;	1450	struct gfs2_rgrpd *rgd;
1451		1451
1452	rgd = rgblk_free(sdp, bstart, blen, GFS2_BLKST_FREE);	1452	rgd = rgblk_free(sdp, bstart, blen, GFS2_BLKST_FREE);
1453	if (!rgd)	1453	if (!rgd)
1454	return;	1454	return;
1455		1455
1456	rgd->rd_rg.rg_free += blen;	1456	rgd->rd_rg.rg_free += blen;
1457		1457
1458	gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);	1458	gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
1459	gfs2_rgrp_out(&rgd->rd_rg, rgd->rd_bits[0].bi_bh->b_data);	1459	gfs2_rgrp_out(&rgd->rd_rg, rgd->rd_bits[0].bi_bh->b_data);
1460		1460
1461	gfs2_trans_add_rg(rgd);	1461	gfs2_trans_add_rg(rgd);
1462		1462
1463	gfs2_statfs_change(sdp, 0, +blen, 0);	1463	gfs2_statfs_change(sdp, 0, +blen, 0);
1464	gfs2_quota_change(ip, -(s64)blen, ip->i_inode.i_uid, ip->i_inode.i_gid);	1464	gfs2_quota_change(ip, -(s64)blen, ip->i_inode.i_uid, ip->i_inode.i_gid);
1465	gfs2_meta_wipe(ip, bstart, blen);	1465	gfs2_meta_wipe(ip, bstart, blen);
1466	}	1466	}
1467		1467
1468	void gfs2_unlink_di(struct inode *inode)	1468	void gfs2_unlink_di(struct inode *inode)
1469	{	1469	{
1470	struct gfs2_inode *ip = GFS2_I(inode);	1470	struct gfs2_inode *ip = GFS2_I(inode);
1471	struct gfs2_sbd *sdp = GFS2_SB(inode);	1471	struct gfs2_sbd *sdp = GFS2_SB(inode);
1472	struct gfs2_rgrpd *rgd;	1472	struct gfs2_rgrpd *rgd;
1473	u64 blkno = ip->i_num.no_addr;	1473	u64 blkno = ip->i_num.no_addr;
1474		1474
1475	rgd = rgblk_free(sdp, blkno, 1, GFS2_BLKST_UNLINKED);	1475	rgd = rgblk_free(sdp, blkno, 1, GFS2_BLKST_UNLINKED);
1476	if (!rgd)	1476	if (!rgd)
1477	return;	1477	return;
1478	gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);	1478	gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
1479	gfs2_rgrp_out(&rgd->rd_rg, rgd->rd_bits[0].bi_bh->b_data);	1479	gfs2_rgrp_out(&rgd->rd_rg, rgd->rd_bits[0].bi_bh->b_data);
1480	gfs2_trans_add_rg(rgd);	1480	gfs2_trans_add_rg(rgd);
1481	}	1481	}
1482		1482
1483	static void gfs2_free_uninit_di(struct gfs2_rgrpd *rgd, u64 blkno)	1483	static void gfs2_free_uninit_di(struct gfs2_rgrpd *rgd, u64 blkno)
1484	{	1484	{
1485	struct gfs2_sbd *sdp = rgd->rd_sbd;	1485	struct gfs2_sbd *sdp = rgd->rd_sbd;
1486	struct gfs2_rgrpd *tmp_rgd;	1486	struct gfs2_rgrpd *tmp_rgd;
1487		1487
1488	tmp_rgd = rgblk_free(sdp, blkno, 1, GFS2_BLKST_FREE);	1488	tmp_rgd = rgblk_free(sdp, blkno, 1, GFS2_BLKST_FREE);
1489	if (!tmp_rgd)	1489	if (!tmp_rgd)
1490	return;	1490	return;
1491	gfs2_assert_withdraw(sdp, rgd == tmp_rgd);	1491	gfs2_assert_withdraw(sdp, rgd == tmp_rgd);
1492		1492
1493	if (!rgd->rd_rg.rg_dinodes)	1493	if (!rgd->rd_rg.rg_dinodes)
1494	gfs2_consist_rgrpd(rgd);	1494	gfs2_consist_rgrpd(rgd);
1495	rgd->rd_rg.rg_dinodes--;	1495	rgd->rd_rg.rg_dinodes--;
1496	rgd->rd_rg.rg_free++;	1496	rgd->rd_rg.rg_free++;
1497		1497
1498	gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);	1498	gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
1499	gfs2_rgrp_out(&rgd->rd_rg, rgd->rd_bits[0].bi_bh->b_data);	1499	gfs2_rgrp_out(&rgd->rd_rg, rgd->rd_bits[0].bi_bh->b_data);
1500		1500
1501	gfs2_statfs_change(sdp, 0, +1, -1);	1501	gfs2_statfs_change(sdp, 0, +1, -1);
1502	gfs2_trans_add_rg(rgd);	1502	gfs2_trans_add_rg(rgd);
1503	}	1503	}
1504		1504
1505		1505
1506	void gfs2_free_di(struct gfs2_rgrpd rgd, struct gfs2_inode ip)	1506	void gfs2_free_di(struct gfs2_rgrpd rgd, struct gfs2_inode ip)
1507	{	1507	{
1508	gfs2_free_uninit_di(rgd, ip->i_num.no_addr);	1508	gfs2_free_uninit_di(rgd, ip->i_num.no_addr);
1509	gfs2_quota_change(ip, -1, ip->i_inode.i_uid, ip->i_inode.i_gid);	1509	gfs2_quota_change(ip, -1, ip->i_inode.i_uid, ip->i_inode.i_gid);
1510	gfs2_meta_wipe(ip, ip->i_num.no_addr, 1);	1510	gfs2_meta_wipe(ip, ip->i_num.no_addr, 1);
1511	}	1511	}
1512		1512
1513	/**	1513	/**
1514	* gfs2_rlist_add - add a RG to a list of RGs	1514	* gfs2_rlist_add - add a RG to a list of RGs
1515	* @sdp: the filesystem	1515	* @sdp: the filesystem
1516	* @rlist: the list of resource groups	1516	* @rlist: the list of resource groups
1517	* @block: the block	1517	* @block: the block
1518	*	1518	*
1519	* Figure out what RG a block belongs to and add that RG to the list	1519	* Figure out what RG a block belongs to and add that RG to the list
1520	*	1520	*
1521	* FIXME: Don't use NOFAIL	1521	* FIXME: Don't use NOFAIL
1522	*	1522	*
1523	*/	1523	*/
1524		1524
1525	void gfs2_rlist_add(struct gfs2_sbd sdp, struct gfs2_rgrp_list rlist,	1525	void gfs2_rlist_add(struct gfs2_sbd sdp, struct gfs2_rgrp_list rlist,
1526	u64 block)	1526	u64 block)
1527	{	1527	{
1528	struct gfs2_rgrpd *rgd;	1528	struct gfs2_rgrpd *rgd;
1529	struct gfs2_rgrpd **tmp;	1529	struct gfs2_rgrpd **tmp;
1530	unsigned int new_space;	1530	unsigned int new_space;
1531	unsigned int x;	1531	unsigned int x;
1532		1532
1533	if (gfs2_assert_warn(sdp, !rlist->rl_ghs))	1533	if (gfs2_assert_warn(sdp, !rlist->rl_ghs))
1534	return;	1534	return;
1535		1535
1536	rgd = gfs2_blk2rgrpd(sdp, block);	1536	rgd = gfs2_blk2rgrpd(sdp, block);
1537	if (!rgd) {	1537	if (!rgd) {
1538	if (gfs2_consist(sdp))	1538	if (gfs2_consist(sdp))
1539	fs_err(sdp, "block = %llu\n", (unsigned long long)block);	1539	fs_err(sdp, "block = %llu\n", (unsigned long long)block);
1540	return;	1540	return;
1541	}	1541	}
1542		1542
1543	for (x = 0; x < rlist->rl_rgrps; x++)	1543	for (x = 0; x < rlist->rl_rgrps; x++)
1544	if (rlist->rl_rgd[x] == rgd)	1544	if (rlist->rl_rgd[x] == rgd)
1545	return;	1545	return;
1546		1546
1547	if (rlist->rl_rgrps == rlist->rl_space) {	1547	if (rlist->rl_rgrps == rlist->rl_space) {
1548	new_space = rlist->rl_space + 10;	1548	new_space = rlist->rl_space + 10;
1549		1549
1550	tmp = kcalloc(new_space, sizeof(struct gfs2_rgrpd *),	1550	tmp = kcalloc(new_space, sizeof(struct gfs2_rgrpd *),
1551	GFP_NOFS \| __GFP_NOFAIL);	1551	GFP_NOFS \| __GFP_NOFAIL);
1552		1552
1553	if (rlist->rl_rgd) {	1553	if (rlist->rl_rgd) {
1554	memcpy(tmp, rlist->rl_rgd,	1554	memcpy(tmp, rlist->rl_rgd,
1555	rlist->rl_space * sizeof(struct gfs2_rgrpd *));	1555	rlist->rl_space * sizeof(struct gfs2_rgrpd *));
1556	kfree(rlist->rl_rgd);	1556	kfree(rlist->rl_rgd);
1557	}	1557	}
1558		1558
1559	rlist->rl_space = new_space;	1559	rlist->rl_space = new_space;
1560	rlist->rl_rgd = tmp;	1560	rlist->rl_rgd = tmp;
1561	}	1561	}
1562		1562
1563	rlist->rl_rgd[rlist->rl_rgrps++] = rgd;	1563	rlist->rl_rgd[rlist->rl_rgrps++] = rgd;
1564	}	1564	}
1565		1565
1566	/**	1566	/**
1567	* gfs2_rlist_alloc - all RGs have been added to the rlist, now allocate	1567	* gfs2_rlist_alloc - all RGs have been added to the rlist, now allocate
1568	* and initialize an array of glock holders for them	1568	* and initialize an array of glock holders for them
1569	* @rlist: the list of resource groups	1569	* @rlist: the list of resource groups
1570	* @state: the lock state to acquire the RG lock in	1570	* @state: the lock state to acquire the RG lock in
1571	* @flags: the modifier flags for the holder structures	1571	* @flags: the modifier flags for the holder structures
1572	*	1572	*
1573	* FIXME: Don't use NOFAIL	1573	* FIXME: Don't use NOFAIL
1574	*	1574	*
1575	*/	1575	*/
1576		1576
1577	void gfs2_rlist_alloc(struct gfs2_rgrp_list *rlist, unsigned int state,	1577	void gfs2_rlist_alloc(struct gfs2_rgrp_list *rlist, unsigned int state,
1578	int flags)	1578	int flags)
1579	{	1579	{
1580	unsigned int x;	1580	unsigned int x;
1581		1581
1582	rlist->rl_ghs = kcalloc(rlist->rl_rgrps, sizeof(struct gfs2_holder),	1582	rlist->rl_ghs = kcalloc(rlist->rl_rgrps, sizeof(struct gfs2_holder),
1583	GFP_NOFS \| __GFP_NOFAIL);	1583	GFP_NOFS \| __GFP_NOFAIL);
1584	for (x = 0; x < rlist->rl_rgrps; x++)	1584	for (x = 0; x < rlist->rl_rgrps; x++)
1585	gfs2_holder_init(rlist->rl_rgd[x]->rd_gl,	1585	gfs2_holder_init(rlist->rl_rgd[x]->rd_gl,
1586	state, flags,	1586	state, flags,
1587	&rlist->rl_ghs[x]);	1587	&rlist->rl_ghs[x]);
1588	}	1588	}
1589		1589
1590	/**	1590	/**
1591	* gfs2_rlist_free - free a resource group list	1591	* gfs2_rlist_free - free a resource group list
1592	* @list: the list of resource groups	1592	* @list: the list of resource groups
1593	*	1593	*
1594	*/	1594	*/
1595		1595
1596	void gfs2_rlist_free(struct gfs2_rgrp_list *rlist)	1596	void gfs2_rlist_free(struct gfs2_rgrp_list *rlist)
1597	{	1597	{
1598	unsigned int x;	1598	unsigned int x;
1599		1599
1600	kfree(rlist->rl_rgd);	1600	kfree(rlist->rl_rgd);
1601		1601
1602	if (rlist->rl_ghs) {	1602	if (rlist->rl_ghs) {
1603	for (x = 0; x < rlist->rl_rgrps; x++)	1603	for (x = 0; x < rlist->rl_rgrps; x++)
1604	gfs2_holder_uninit(&rlist->rl_ghs[x]);	1604	gfs2_holder_uninit(&rlist->rl_ghs[x]);
1605	kfree(rlist->rl_ghs);	1605	kfree(rlist->rl_ghs);
1606	}	1606	}
1607	}	1607	}
1608		1608
1609		1609

fs/gfs2/rgrp.h

Diff comments View file @ cd81a4b

 /*
  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
  * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
  *
  * This copyrighted material is made available to anyone wishing to use,
  * modify, copy, or redistribute it subject to the terms and conditions
  * of the GNU General Public License version 2.
  */
 #ifndef __RGRP_DOT_H__
 #define __RGRP_DOT_H__
 struct gfs2_rgrpd;
 struct gfs2_sbd;
 struct gfs2_holder;
 void gfs2_rgrp_verify(struct gfs2_rgrpd *rgd);
 struct gfs2_rgrpd *gfs2_blk2rgrpd(struct gfs2_sbd *sdp, u64 blk);
 struct gfs2_rgrpd *gfs2_rgrpd_get_first(struct gfs2_sbd *sdp);
 struct gfs2_rgrpd *gfs2_rgrpd_get_next(struct gfs2_rgrpd *rgd);
 void gfs2_clear_rgrpd(struct gfs2_sbd *sdp);
 int gfs2_rindex_hold(struct gfs2_sbd *sdp, struct gfs2_holder *ri_gh);
 int gfs2_rgrp_bh_get(struct gfs2_rgrpd *rgd);
 void gfs2_rgrp_bh_hold(struct gfs2_rgrpd *rgd);
 void gfs2_rgrp_bh_put(struct gfs2_rgrpd *rgd);
 void gfs2_rgrp_repolish_clones(struct gfs2_rgrpd *rgd);
 struct gfs2_alloc *gfs2_alloc_get(struct gfs2_inode *ip);
 static inline void gfs2_alloc_put(struct gfs2_inode *ip)
 {
 	return; /* So we can see where ip->i_alloc is used */
 }
 int gfs2_inplace_reserve_i(struct gfs2_inode *ip,
 			 char *file, unsigned int line);
 #define gfs2_inplace_reserve(ip) \
 gfs2_inplace_reserve_i((ip), __FILE__, __LINE__)
 void gfs2_inplace_release(struct gfs2_inode *ip);
 unsigned char gfs2_get_block_type(struct gfs2_rgrpd *rgd, u64 block);
 u64 gfs2_alloc_data(struct gfs2_inode *ip);
 u64 gfs2_alloc_meta(struct gfs2_inode *ip);
 u64 gfs2_alloc_di(struct gfs2_inode *ip, u64 *generation);
 void gfs2_free_data(struct gfs2_inode *ip, u64 bstart, u32 blen);
 void gfs2_free_meta(struct gfs2_inode *ip, u64 bstart, u32 blen);
 void gfs2_free_di(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip);
 void gfs2_unlink_di(struct inode *inode);
 struct gfs2_rgrp_list {
 	unsigned int rl_rgrps;
 	unsigned int rl_space;
 	struct gfs2_rgrpd **rl_rgd;
 	struct gfs2_holder *rl_ghs;
 };
 void gfs2_rlist_add(struct gfs2_sbd *sdp, struct gfs2_rgrp_list *rlist,
 		    u64 block);
 void gfs2_rlist_alloc(struct gfs2_rgrp_list *rlist, unsigned int state,
 		      int flags);
 void gfs2_rlist_free(struct gfs2_rgrp_list *rlist);
+u64 gfs2_ri_total(struct gfs2_sbd *sdp);
 #endif /* __RGRP_DOT_H__ */