#include <linux/delay.h>
#include <linux/sort.h>
#include <linux/jhash.h>
-#include <linux/kref.h>
#include <linux/kallsyms.h>
#include <linux/gfs2_ondisk.h>
+#include <linux/list.h>
+#include <linux/lm_interface.h>
#include <asm/uaccess.h>
#include "gfs2.h"
-#include "lm_interface.h"
#include "incore.h"
#include "glock.h"
#include "glops.h"
#include "super.h"
#include "util.h"
-/* Must be kept in sync with the beginning of struct gfs2_glock */
-struct glock_plug {
- struct list_head gl_list;
- unsigned long gl_flags;
-};
-
struct greedy {
struct gfs2_holder gr_gh;
- struct work_struct gr_work;
+ struct delayed_work gr_work;
};
struct gfs2_gl_hash_bucket {
- struct list_head hb_list;
+ struct hlist_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);
+static int dump_inode(struct gfs2_inode *ip);
-#define GFS2_GL_HASH_SHIFT 13
+#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 inline rwlock_t *gl_lock_addr(unsigned int x)
{
- return &gl_hash_locks[(x) & (GL_HASH_LOCK_SZ-1)];
+ 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)
void gfs2_glock_hold(struct gfs2_glock *gl)
{
- kref_get(&gl->gl_ref);
-}
-
-/* All work is done after the return from kref_put() so we
- can release the write_lock before the free. */
-
-static void kill_glock(struct kref *kref)
-{
- struct gfs2_glock *gl = container_of(kref, struct gfs2_glock, gl_ref);
- struct gfs2_sbd *sdp = gl->gl_sbd;
-
- 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_waiters2));
- gfs2_assert(sdp, list_empty(&gl->gl_waiters3));
+ atomic_inc(&gl->gl_ref);
}
/**
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 (kref_put(&gl->gl_ref, kill_glock)) {
- list_del_init(&gl_hash_table[gl->gl_hash].hb_list);
+ 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_waiters2));
+ gfs2_assert(sdp, list_empty(&gl->gl_waiters3));
glock_free(gl);
rv = 1;
goto out;
const struct lm_lockname *name)
{
struct gfs2_glock *gl;
+ struct hlist_node *h;
- list_for_each_entry(gl, &gl_hash_table[hash].hb_list, gl_list) {
- if (test_bit(GLF_PLUG, &gl->gl_flags))
- continue;
+ 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;
- kref_get(&gl->gl_ref);
+ atomic_inc(&gl->gl_ref);
return gl;
}
gl->gl_flags = 0;
gl->gl_name = name;
- kref_init(&gl->gl_ref);
+ atomic_set(&gl->gl_ref, 1);
gl->gl_state = LM_ST_UNLOCKED;
gl->gl_hash = hash;
gl->gl_owner = NULL;
glock_free(gl);
gl = tmp;
} else {
- list_add_tail(&gl->gl_list, &gl_hash_table[hash].hb_list);
+ hlist_add_head(&gl->gl_list, &gl_hash_table[hash].hb_list);
write_unlock(gl_lock_addr(hash));
}
if (gl->gl_aspace)
gfs2_aspace_put(gl->gl_aspace);
fail:
- kmem_cache_free(gfs2_glock_cachep, gl);
+ kmem_cache_free(gfs2_glock_cachep, gl);
return error;
}
gfs2_holder_uninit(gh);
kfree(container_of(gh, struct greedy, gr_gh));
- spin_lock(&gl->gl_spin);
+ spin_lock(&gl->gl_spin);
return 0;
}
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",
+ 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",
+ printk(KERN_INFO "lock type : %d lock state : %d\n",
gl->gl_name.ln_type, gl->gl_state);
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);
+ list_add_tail(&gh->gh_list, &gl->gl_waiters3);
}
/**
glops->go_xmote_th(gl, state, flags);
}
-static void greedy_work(void *data)
+static void greedy_work(struct work_struct *work)
{
- struct greedy *gr = data;
+ struct greedy *gr = container_of(work, struct greedy, gr_work.work);
struct gfs2_holder *gh = &gr->gr_gh;
struct gfs2_glock *gl = gh->gh_gl;
const struct gfs2_glock_operations *glops = gl->gl_ops;
gfs2_holder_init(gl, 0, 0, gh);
set_bit(HIF_GREEDY, &gh->gh_iflags);
- INIT_WORK(&gr->gr_work, greedy_work, gr);
+ INIT_DELAYED_WORK(&gr->gr_work, greedy_work);
set_bit(GLF_SKIP_WAITERS2, &gl->gl_flags);
schedule_delayed_work(&gr->gr_work, time);
}
}
-/**
- * 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,
unsigned int hash)
{
- struct glock_plug plug;
- struct list_head *tmp;
- struct gfs2_glock *gl;
- int entries;
-
- /* Add "plug" to end of bucket list, work back up list from there */
- memset(&plug.gl_flags, 0, sizeof(unsigned long));
- set_bit(GLF_PLUG, &plug.gl_flags);
-
- 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(gl_lock_addr(hash));
-
- for (;;) {
- tmp = plug.gl_list.next;
-
- if (tmp == &gl_hash_table[hash].hb_list) {
- list_del(&plug.gl_list);
- 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);
+ struct gfs2_glock *gl, *prev = NULL;
+ int has_entries = 0;
+ struct hlist_head *head = &gl_hash_table[hash].hb_list;
- /* Move plug up list */
- list_move(&plug.gl_list, &gl->gl_list);
-
- if (test_bit(GLF_PLUG, &gl->gl_flags))
- continue;
- if (gl->gl_sbd != sdp)
- continue;
-
- /* examiner() must glock_put() */
+ 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);
-
- break;
+ 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));
}
-
- write_unlock(gl_lock_addr(hash));
-
- examiner(gl);
+ 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;
}
/**
static void scan_glock(struct gfs2_glock *gl)
{
if (gl->gl_ops == &gfs2_inode_glops)
- goto out;
+ return;
if (gfs2_glmutex_trylock(gl)) {
if (queue_empty(gl, &gl->gl_holders) &&
- gl->gl_state != LM_ST_UNLOCKED &&
- demote_ok(gl))
+ gl->gl_state != LM_ST_UNLOCKED && demote_ok(gl))
goto out_schedule;
gfs2_glmutex_unlock(gl);
}
-out:
- gfs2_glock_put(gl);
return;
out_schedule:
gfs2_glmutex_unlock(gl);
gfs2_glock_schedule_for_reclaim(gl);
- gfs2_glock_put(gl);
}
/**
{
unsigned int x;
- for (x = 0; x < GFS2_GL_HASH_SIZE; x++) {
+ for (x = 0; x < GFS2_GL_HASH_SIZE; x++)
examine_bucket(scan_glock, sdp, x);
- cond_resched();
- }
}
/**
if (queue_empty(gl, &gl->gl_holders) &&
gl->gl_state != LM_ST_UNLOCKED)
handle_callback(gl, LM_ST_UNLOCKED);
-
gfs2_glmutex_unlock(gl);
}
-
- gfs2_glock_put(gl);
}
/**
for (;;) {
cont = 0;
-
- for (x = 0; x < GFS2_GL_HASH_SIZE; x++)
+ for (x = 0; x < GFS2_GL_HASH_SIZE; x++) {
if (examine_bucket(clear_glock, sdp, x))
cont = 1;
+ }
if (!wait || !cont)
break;
printk(" %u", x);
}
printk(" \n");
- printk(KERN_INFO " gl_ref = %d\n", atomic_read(&gl->gl_ref.refcount));
+ printk(KERN_INFO " gl_ref = %d\n", atomic_read(&gl->gl_ref));
printk(KERN_INFO " gl_state = %u\n", gl->gl_state);
printk(KERN_INFO " gl_owner = %s\n", gl->gl_owner->comm);
print_symbol(KERN_INFO " gl_ip = %s\n", gl->gl_ip);
static int gfs2_dump_lockstate(struct gfs2_sbd *sdp)
{
struct gfs2_glock *gl;
+ struct hlist_node *h;
unsigned int x;
int error = 0;
read_lock(gl_lock_addr(x));
- list_for_each_entry(gl, &gl_hash_table[x].hb_list, gl_list) {
- if (test_bit(GLF_PLUG, &gl->gl_flags))
- continue;
+ hlist_for_each_entry(gl, h, &gl_hash_table[x].hb_list, gl_list) {
if (gl->gl_sbd != sdp)
continue;
{
unsigned i;
for(i = 0; i < GFS2_GL_HASH_SIZE; i++) {
- INIT_LIST_HEAD(&gl_hash_table[i].hb_list);
+ INIT_HLIST_HEAD(&gl_hash_table[i].hb_list);
}
#ifdef GL_HASH_LOCK_SZ
for(i = 0; i < GL_HASH_LOCK_SZ; i++) {