struct work_struct gr_work;
};
+struct gfs2_gl_hash_bucket {
+ struct list_head hb_list;
+};
+
typedef void (*glock_examiner) (struct gfs2_glock * gl);
static int gfs2_dump_lockstate(struct gfs2_sbd *sdp);
static int dump_glock(struct gfs2_glock *gl);
+#define GFS2_GL_HASH_SHIFT 13
+#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];
+
+/*
+ * 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(x)
+{
+ return NULL;
+}
+#endif
+
/**
* relaxed_state_ok - is a requested lock compatible with the current lock mode?
* @actual: the current state of the lock
int gfs2_glock_put(struct gfs2_glock *gl)
{
- struct gfs2_gl_hash_bucket *bucket = gl->gl_bucket;
int rv = 0;
- write_lock(&bucket->hb_lock);
+ write_lock(gl_lock_addr(gl->gl_hash));
if (kref_put(&gl->gl_ref, kill_glock)) {
- list_del_init(&gl->gl_list);
- write_unlock(&bucket->hb_lock);
+ list_del_init(&gl_hash_table[gl->gl_hash].hb_list);
+ write_unlock(gl_lock_addr(gl->gl_hash));
BUG_ON(spin_is_locked(&gl->gl_spin));
glock_free(gl);
rv = 1;
goto out;
}
- write_unlock(&bucket->hb_lock);
+ write_unlock(gl_lock_addr(gl->gl_hash));
out:
return rv;
}
* Returns: NULL, or the struct gfs2_glock with the requested number
*/
-static struct gfs2_glock *search_bucket(struct gfs2_gl_hash_bucket *bucket,
+static struct gfs2_glock *search_bucket(unsigned int hash,
const struct gfs2_sbd *sdp,
const struct lm_lockname *name)
{
struct gfs2_glock *gl;
- list_for_each_entry(gl, &bucket->hb_list, gl_list) {
+ list_for_each_entry(gl, &gl_hash_table[hash].hb_list, gl_list) {
if (test_bit(GLF_PLUG, &gl->gl_flags))
continue;
if (!lm_name_equal(&gl->gl_name, name))
* Returns: NULL, or the struct gfs2_glock with the requested number
*/
-static struct gfs2_glock *gfs2_glock_find(struct gfs2_sbd *sdp,
+static struct gfs2_glock *gfs2_glock_find(const struct gfs2_sbd *sdp,
const struct lm_lockname *name)
{
- struct gfs2_gl_hash_bucket *bucket = &sdp->sd_gl_hash[gl_hash(sdp, name)];
+ unsigned int hash = gl_hash(sdp, name);
struct gfs2_glock *gl;
- read_lock(&bucket->hb_lock);
- gl = search_bucket(bucket, sdp, name);
- read_unlock(&bucket->hb_lock);
+ read_lock(gl_lock_addr(hash));
+ gl = search_bucket(hash, sdp, name);
+ read_unlock(gl_lock_addr(hash));
return gl;
}
const struct gfs2_glock_operations *glops, int create,
struct gfs2_glock **glp)
{
- struct lm_lockname name;
+ struct lm_lockname name = { .ln_number = number, .ln_type = glops->go_type };
struct gfs2_glock *gl, *tmp;
- struct gfs2_gl_hash_bucket *bucket;
+ unsigned int hash = gl_hash(sdp, &name);
int error;
- name.ln_number = number;
- name.ln_type = glops->go_type;
- bucket = &sdp->sd_gl_hash[gl_hash(sdp, &name)];
-
- read_lock(&bucket->hb_lock);
- gl = search_bucket(bucket, sdp, &name);
- read_unlock(&bucket->hb_lock);
+ read_lock(gl_lock_addr(hash));
+ gl = search_bucket(hash, sdp, &name);
+ read_unlock(gl_lock_addr(hash));
if (gl || !create) {
*glp = gl;
gl->gl_name = name;
kref_init(&gl->gl_ref);
gl->gl_state = LM_ST_UNLOCKED;
+ gl->gl_hash = hash;
gl->gl_owner = NULL;
gl->gl_ip = 0;
gl->gl_ops = glops;
gl->gl_vn = 0;
gl->gl_stamp = jiffies;
gl->gl_object = NULL;
- gl->gl_bucket = bucket;
gl->gl_sbd = sdp;
gl->gl_aspace = NULL;
lops_init_le(&gl->gl_le, &gfs2_glock_lops);
if (error)
goto fail_aspace;
- write_lock(&bucket->hb_lock);
- tmp = search_bucket(bucket, sdp, &name);
+ write_lock(gl_lock_addr(hash));
+ tmp = search_bucket(hash, sdp, &name);
if (tmp) {
- write_unlock(&bucket->hb_lock);
+ write_unlock(gl_lock_addr(hash));
glock_free(gl);
gl = tmp;
} else {
- list_add_tail(&gl->gl_list, &bucket->hb_list);
- write_unlock(&bucket->hb_lock);
+ list_add_tail(&gl->gl_list, &gl_hash_table[hash].hb_list);
+ write_unlock(gl_lock_addr(hash));
}
*glp = gl;
set_bit(HIF_MUTEX, &gh.gh_iflags);
spin_lock(&gl->gl_spin);
- if (test_and_set_bit(GLF_LOCK, &gl->gl_flags))
+ if (test_and_set_bit(GLF_LOCK, &gl->gl_flags)) {
list_add_tail(&gh.gh_list, &gl->gl_waiters1);
- else {
+ } else {
gl->gl_owner = current;
gl->gl_ip = (unsigned long)__builtin_return_address(0);
complete(&gh.gh_wait);
int acquired = 1;
spin_lock(&gl->gl_spin);
- if (test_and_set_bit(GLF_LOCK, &gl->gl_flags))
+ if (test_and_set_bit(GLF_LOCK, &gl->gl_flags)) {
acquired = 0;
- else {
+ } else {
gl->gl_owner = current;
gl->gl_ip = (unsigned long)__builtin_return_address(0);
}
spin_lock(&gl->gl_spin);
list_del_init(&gh->gh_list);
if (gl->gl_state == gh->gh_state ||
- gl->gl_state == LM_ST_UNLOCKED)
+ gl->gl_state == LM_ST_UNLOCKED) {
gh->gh_error = 0;
- else {
+ } else {
if (gfs2_assert_warn(sdp, gh->gh_flags &
(LM_FLAG_TRY | LM_FLAG_TRY_1CB)) == -1)
fs_warn(sdp, "ret = 0x%.8X\n", ret);
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,
+ gfs2_assert_withdraw(sdp, relaxed_state_ok(gl->gl_state, gh->gh_state,
gh->gh_flags));
if (test_bit(HIF_FIRST, &gh->gh_iflags)) {
static int glock_compare(const void *arg_a, const void *arg_b)
{
- struct gfs2_holder *gh_a = *(struct gfs2_holder **)arg_a;
- struct gfs2_holder *gh_b = *(struct gfs2_holder **)arg_b;
- struct lm_lockname *a = &gh_a->gh_gl->gl_name;
- struct lm_lockname *b = &gh_b->gh_gl->gl_name;
- int ret = 0;
+ 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)
- ret = 1;
- else if (a->ln_number < b->ln_number)
- ret = -1;
- else {
- if (gh_a->gh_state == LM_ST_SHARED &&
- gh_b->gh_state == LM_ST_EXCLUSIVE)
- ret = 1;
- else if (!(gh_a->gh_flags & GL_LOCAL_EXCL) &&
- (gh_b->gh_flags & GL_LOCAL_EXCL))
- ret = 1;
- }
-
- return ret;
+ return 1;
+ if (a->ln_number < b->ln_number)
+ return -1;
+ if (gh_a->gh_state == LM_ST_SHARED && gh_b->gh_state == LM_ST_EXCLUSIVE)
+ return 1;
+ if (!(gh_a->gh_flags & GL_LOCAL_EXCL) && (gh_b->gh_flags & GL_LOCAL_EXCL))
+ return 1;
+ return 0;
}
/**
/**
* gfs2_glock_cb - Callback used by locking module
- * @fsdata: Pointer to the superblock
+ * @sdp: Pointer to the superblock
* @type: Type of callback
* @data: Type dependent data pointer
*
* a journal from another client needs to be recovered.
*/
-void gfs2_glock_cb(lm_fsdata_t *fsdata, unsigned int type, void *data)
+void gfs2_glock_cb(void *cb_data, unsigned int type, void *data)
{
- struct gfs2_sbd *sdp = (struct gfs2_sbd *)fsdata;
+ struct gfs2_sbd *sdp = cb_data;
switch (type) {
case LM_CB_NEED_E:
}
}
-/**
- * gfs2_iopen_go_callback - Try to kick the inode/vnode associated with an
- * iopen glock from memory
- * @io_gl: the iopen glock
- * @state: the state into which the glock should be put
- *
- */
-
-void gfs2_iopen_go_callback(struct gfs2_glock *io_gl, unsigned int state)
-{
-
- if (state != LM_ST_UNLOCKED)
- return;
- /* FIXME: remove this? */
-}
-
/**
* demote_ok - Check to see if it's ok to unlock a glock
* @gl: the glock
*/
static int examine_bucket(glock_examiner examiner, struct gfs2_sbd *sdp,
- struct gfs2_gl_hash_bucket *bucket)
+ unsigned int hash)
{
struct glock_plug plug;
struct list_head *tmp;
memset(&plug.gl_flags, 0, sizeof(unsigned long));
set_bit(GLF_PLUG, &plug.gl_flags);
- write_lock(&bucket->hb_lock);
- list_add(&plug.gl_list, &bucket->hb_list);
- write_unlock(&bucket->hb_lock);
+ write_lock(gl_lock_addr(hash));
+ list_add(&plug.gl_list, &gl_hash_table[hash].hb_list);
+ write_unlock(gl_lock_addr(hash));
for (;;) {
- write_lock(&bucket->hb_lock);
+ write_lock(gl_lock_addr(hash));
for (;;) {
tmp = plug.gl_list.next;
- if (tmp == &bucket->hb_list) {
+ if (tmp == &gl_hash_table[hash].hb_list) {
list_del(&plug.gl_list);
- entries = !list_empty(&bucket->hb_list);
- write_unlock(&bucket->hb_lock);
+ entries = !list_empty(&gl_hash_table[hash].hb_list);
+ write_unlock(gl_lock_addr(hash));
return entries;
}
gl = list_entry(tmp, struct gfs2_glock, gl_list);
if (test_bit(GLF_PLUG, &gl->gl_flags))
continue;
+ if (gl->gl_sbd != sdp)
+ continue;
/* examiner() must glock_put() */
gfs2_glock_hold(gl);
break;
}
- write_unlock(&bucket->hb_lock);
+ write_unlock(gl_lock_addr(hash));
examiner(gl);
}
{
unsigned int x;
- for (x = 0; x < GFS2_GL_HASH_SIZE; x++) {
- examine_bucket(scan_glock, sdp, &sdp->sd_gl_hash[x]);
- cond_resched();
- }
+ for (x = 0; x < GFS2_GL_HASH_SIZE; x++)
+ examine_bucket(scan_glock, sdp, x);
}
/**
cont = 0;
for (x = 0; x < GFS2_GL_HASH_SIZE; x++)
- if (examine_bucket(clear_glock, sdp, &sdp->sd_gl_hash[x]))
+ if (examine_bucket(clear_glock, sdp, x))
cont = 1;
if (!wait || !cont)
spin_lock(&gl->gl_spin);
- printk(KERN_INFO "Glock 0x%p (%u, %llu)\n",
- gl,
- gl->gl_name.ln_type,
+ printk(KERN_INFO "Glock 0x%p (%u, %llu)\n", gl, gl->gl_name.ln_type,
(unsigned long long)gl->gl_name.ln_number);
printk(KERN_INFO " gl_flags =");
- for (x = 0; x < 32; x++)
+ for (x = 0; x < 32; x++) {
if (test_bit(x, &gl->gl_flags))
printk(" %u", x);
+ }
printk(" \n");
printk(KERN_INFO " gl_ref = %d\n", atomic_read(&gl->gl_ref.refcount));
printk(KERN_INFO " gl_state = %u\n", gl->gl_state);
printk(KERN_INFO " reclaim = %s\n",
(list_empty(&gl->gl_reclaim)) ? "no" : "yes");
if (gl->gl_aspace)
- printk(KERN_INFO " aspace = 0x%p nrpages = %lu\n",
- gl->gl_aspace,
+ printk(KERN_INFO " aspace = 0x%p nrpages = %lu\n", gl->gl_aspace,
gl->gl_aspace->i_mapping->nrpages);
else
printk(KERN_INFO " aspace = no\n");
static int gfs2_dump_lockstate(struct gfs2_sbd *sdp)
{
- struct gfs2_gl_hash_bucket *bucket;
struct gfs2_glock *gl;
unsigned int x;
int error = 0;
for (x = 0; x < GFS2_GL_HASH_SIZE; x++) {
- bucket = &sdp->sd_gl_hash[x];
- read_lock(&bucket->hb_lock);
+ read_lock(gl_lock_addr(x));
- list_for_each_entry(gl, &bucket->hb_list, gl_list) {
+ list_for_each_entry(gl, &gl_hash_table[x].hb_list, gl_list) {
if (test_bit(GLF_PLUG, &gl->gl_flags))
continue;
+ if (gl->gl_sbd != sdp)
+ continue;
error = dump_glock(gl);
if (error)
break;
}
- read_unlock(&bucket->hb_lock);
+ 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_LIST_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;
+}
+
projects / linux-2.6 / blobdiff