This results in smaller list heads, so that we can have more chains
in the same amount of memory (twice as many). I've multiplied the
size of the table by four though - this is because we are saving
memory by not having one lock per chain any more. So we land up
using about the same amount of memory for the hash table as we
did before I started these changes, the difference being that we
now have four times as many hash chains.
The reason that I say "about the same amount of memory" is that the
actual amount now depends upon the NR_CPUS and some of the config
variables, so that its not exact and in some cases we do use more
memory. Eventually we might want to scale the hash table size
according to the size of physical ram as measured on module load.
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
};
struct gfs2_gl_hash_bucket {
};
struct gfs2_gl_hash_bucket {
- struct list_head hb_list;
+ struct hlist_head hb_list;
};
typedef void (*glock_examiner) (struct gfs2_glock * gl);
};
typedef void (*glock_examiner) (struct gfs2_glock * gl);
static int dump_glock(struct gfs2_glock *gl);
static int dump_inode(struct gfs2_inode *ip);
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)
#define GFS2_GL_HASH_SIZE (1 << GFS2_GL_HASH_SHIFT)
#define GFS2_GL_HASH_MASK (GFS2_GL_HASH_SIZE - 1)
write_lock(gl_lock_addr(gl->gl_hash));
if (kref_put(&gl->gl_ref, kill_glock)) {
write_lock(gl_lock_addr(gl->gl_hash));
if (kref_put(&gl->gl_ref, kill_glock)) {
- list_del_init(&gl->gl_list);
+ hlist_del(&gl->gl_list);
write_unlock(gl_lock_addr(gl->gl_hash));
BUG_ON(spin_is_locked(&gl->gl_spin));
glock_free(gl);
write_unlock(gl_lock_addr(gl->gl_hash));
BUG_ON(spin_is_locked(&gl->gl_spin));
glock_free(gl);
const struct lm_lockname *name)
{
struct gfs2_glock *gl;
const struct lm_lockname *name)
{
struct gfs2_glock *gl;
- list_for_each_entry(gl, &gl_hash_table[hash].hb_list, gl_list) {
+ 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)
if (!lm_name_equal(&gl->gl_name, name))
continue;
if (gl->gl_sbd != sdp)
glock_free(gl);
gl = tmp;
} else {
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));
}
write_unlock(gl_lock_addr(hash));
}
{
struct gfs2_glock *gl, *prev = NULL;
int has_entries = 0;
{
struct gfs2_glock *gl, *prev = NULL;
int has_entries = 0;
- struct list_head *head = &gl_hash_table[hash].hb_list;
+ struct hlist_head *head = &gl_hash_table[hash].hb_list;
read_lock(gl_lock_addr(hash));
read_lock(gl_lock_addr(hash));
- /* Can't use list_for_each_entry - don't want prefetch here */
- if (list_empty(head))
+ /* Can't use hlist_for_each_entry - don't want prefetch here */
+ if (hlist_empty(head))
goto out;
has_entries = 1;
goto out;
has_entries = 1;
- gl = list_entry(head->next, struct gfs2_glock, gl_list);
- while(&gl->gl_list != head) {
+ 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 (gl->gl_sbd == sdp) {
gfs2_glock_hold(gl);
read_unlock(gl_lock_addr(hash));
examiner(gl);
read_lock(gl_lock_addr(hash));
}
examiner(gl);
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:
gl = list_entry(gl->gl_list.next, struct gfs2_glock, gl_list);
}
out:
static int gfs2_dump_lockstate(struct gfs2_sbd *sdp)
{
struct gfs2_glock *gl;
static int gfs2_dump_lockstate(struct gfs2_sbd *sdp)
{
struct gfs2_glock *gl;
unsigned int x;
int error = 0;
unsigned int x;
int error = 0;
read_lock(gl_lock_addr(x));
read_lock(gl_lock_addr(x));
- list_for_each_entry(gl, &gl_hash_table[x].hb_list, gl_list) {
+ hlist_for_each_entry(gl, h, &gl_hash_table[x].hb_list, gl_list) {
if (gl->gl_sbd != sdp)
continue;
if (gl->gl_sbd != sdp)
continue;
{
unsigned i;
for(i = 0; i < GFS2_GL_HASH_SIZE; i++) {
{
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++) {
}
#ifdef GL_HASH_LOCK_SZ
for(i = 0; i < GL_HASH_LOCK_SZ; i++) {
- struct list_head gl_list;
+ struct hlist_node gl_list;
unsigned long gl_flags; /* GLF_... */
struct lm_lockname gl_name;
struct kref gl_ref;
unsigned long gl_flags; /* GLF_... */
struct lm_lockname gl_name;
struct kref gl_ref;
struct gfs2_glock *gl = foo;
if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
SLAB_CTOR_CONSTRUCTOR) {
struct gfs2_glock *gl = foo;
if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
SLAB_CTOR_CONSTRUCTOR) {
- INIT_LIST_HEAD(&gl->gl_list);
+ INIT_HLIST_NODE(&gl->gl_list);
spin_lock_init(&gl->gl_spin);
INIT_LIST_HEAD(&gl->gl_holders);
INIT_LIST_HEAD(&gl->gl_waiters1);
spin_lock_init(&gl->gl_spin);
INIT_LIST_HEAD(&gl->gl_holders);
INIT_LIST_HEAD(&gl->gl_waiters1);