Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7d8a804c authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/teigland/dlm 

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/teigland/dlm:
  dlm: fs/dlm/ast.c: fix warning
  dlm: add new debugfs entry
  dlm: add time stamp of blocking callback
  dlm: change lock time stamping
  dlm: improve how bast mode handling
  dlm: remove extra blocking callback check
  dlm: replace schedule with cond_resched
  dlm: remove kmap/kunmap
  dlm: trivial annotation of be16 value
  dlm: fix up memory allocation flags
parents c58bd34d 722d7421

fs/dlm/ast.c

+24 −32
Original line number Diff line number Diff line
@@ -2,7 +2,7 @@ 
*******************************************************************************

**

**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.

**  Copyright (C) 2004-2005 Red Hat, Inc.  All rights reserved.

**  Copyright (C) 2004-2008 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
@@ -33,10 +33,10 @@ void dlm_del_ast(struct dlm_lkb *lkb) 
	spin_unlock(&ast_queue_lock);

}



void dlm_add_ast(struct dlm_lkb *lkb, int type)

void dlm_add_ast(struct dlm_lkb *lkb, int type, int bastmode)

{

	if (lkb->lkb_flags & DLM_IFL_USER) {

		dlm_user_add_ast(lkb, type);

		dlm_user_add_ast(lkb, type, bastmode);

		return;

	}
@@ -46,6 +46,8 @@ void dlm_add_ast(struct dlm_lkb *lkb, int type) 
		list_add_tail(&lkb->lkb_astqueue, &ast_queue);

	}

	lkb->lkb_ast_type |= type;

	if (bastmode)

		lkb->lkb_bastmode = bastmode;

	spin_unlock(&ast_queue_lock);



	set_bit(WAKE_ASTS, &astd_wakeflags);
@@ -59,10 +61,9 @@ static void process_asts(void) 
	struct dlm_lkb *lkb;

	void (*cast) (void *astparam);

	void (*bast) (void *astparam, int mode);

	int type = 0, found, bmode;

	int type = 0, bastmode;



	for (;;) {

		found = 0;

repeat:

	spin_lock(&ast_queue_lock);

	list_for_each_entry(lkb, &ast_queue, lkb_astqueue) {

		r = lkb->lkb_resource;
@@ -74,35 +75,26 @@ static void process_asts(void) 
		list_del(&lkb->lkb_astqueue);

		type = lkb->lkb_ast_type;

		lkb->lkb_ast_type = 0;

			found = 1;

			break;

		}

		spin_unlock(&ast_queue_lock);



		if (!found)

			break;

		bastmode = lkb->lkb_bastmode;



		spin_unlock(&ast_queue_lock);

		cast = lkb->lkb_astfn;

		bast = lkb->lkb_bastfn;

		bmode = lkb->lkb_bastmode;



		if ((type & AST_COMP) && cast)

			cast(lkb->lkb_astparam);



		/* FIXME: Is it safe to look at lkb_grmode here

		   without doing a lock_rsb() ?

		   Look at other checks in v1 to avoid basts. */



		if ((type & AST_BAST) && bast)

			if (!dlm_modes_compat(lkb->lkb_grmode, bmode))

				bast(lkb->lkb_astparam, bmode);

			bast(lkb->lkb_astparam, bastmode);



		/* this removes the reference added by dlm_add_ast

		   and may result in the lkb being freed */

		dlm_put_lkb(lkb);



		schedule();

		cond_resched();

		goto repeat;

	}

	spin_unlock(&ast_queue_lock);

}



static inline int no_asts(void)

fs/dlm/ast.h

+2 −2
Original line number Diff line number Diff line 
/******************************************************************************

*******************************************************************************

**

**  Copyright (C) 2005 Red Hat, Inc.  All rights reserved.

**  Copyright (C) 2005-2008 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
@@ -13,7 +13,7 @@ 
#ifndef __ASTD_DOT_H__

#define __ASTD_DOT_H__



void dlm_add_ast(struct dlm_lkb *lkb, int type);

void dlm_add_ast(struct dlm_lkb *lkb, int type, int bastmode);

void dlm_del_ast(struct dlm_lkb *lkb);



void dlm_astd_wake(void);

fs/dlm/debug_fs.c

+253 −57
Original line number Diff line number Diff line 
/******************************************************************************

*******************************************************************************

**

**  Copyright (C) 2005 Red Hat, Inc.  All rights reserved.

**  Copyright (C) 2005-2008 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
@@ -27,7 +27,7 @@ static struct dentry *dlm_root; 


struct rsb_iter {

	int entry;

	int locks;

	int format;

	int header;

	struct dlm_ls *ls;

	struct list_head *next;
@@ -60,7 +60,7 @@ static char *print_lockmode(int mode) 
	}

}



static void print_resource_lock(struct seq_file *s, struct dlm_lkb *lkb,

static void print_format1_lock(struct seq_file *s, struct dlm_lkb *lkb,

			       struct dlm_rsb *res)

{

	seq_printf(s, "%08x %s", lkb->lkb_id, print_lockmode(lkb->lkb_grmode));
@@ -83,7 +83,7 @@ static void print_resource_lock(struct seq_file *s, struct dlm_lkb *lkb, 
	seq_printf(s, "\n");

}



static int print_resource(struct dlm_rsb *res, struct seq_file *s)

static int print_format1(struct dlm_rsb *res, struct seq_file *s)

{

	struct dlm_lkb *lkb;

	int i, lvblen = res->res_ls->ls_lvblen, recover_list, root_list;
@@ -134,15 +134,15 @@ static int print_resource(struct dlm_rsb *res, struct seq_file *s) 
	/* Print the locks attached to this resource */

	seq_printf(s, "Granted Queue\n");

	list_for_each_entry(lkb, &res->res_grantqueue, lkb_statequeue)

		print_resource_lock(s, lkb, res);

		print_format1_lock(s, lkb, res);



	seq_printf(s, "Conversion Queue\n");

	list_for_each_entry(lkb, &res->res_convertqueue, lkb_statequeue)

		print_resource_lock(s, lkb, res);

		print_format1_lock(s, lkb, res);



	seq_printf(s, "Waiting Queue\n");

	list_for_each_entry(lkb, &res->res_waitqueue, lkb_statequeue)

		print_resource_lock(s, lkb, res);

		print_format1_lock(s, lkb, res);



	if (list_empty(&res->res_lookup))

		goto out;
@@ -160,23 +160,24 @@ static int print_resource(struct dlm_rsb *res, struct seq_file *s) 
	return 0;

}



static void print_lock(struct seq_file *s, struct dlm_lkb *lkb, struct dlm_rsb *r)

static void print_format2_lock(struct seq_file *s, struct dlm_lkb *lkb,

			       struct dlm_rsb *r)

{

	unsigned int waiting = 0;

	uint64_t xid = 0;

	u64 xid = 0;

	u64 us;



	if (lkb->lkb_flags & DLM_IFL_USER) {

		if (lkb->lkb_ua)

			xid = lkb->lkb_ua->xid;

	}



	if (lkb->lkb_timestamp)

		waiting = jiffies_to_msecs(jiffies - lkb->lkb_timestamp);

	/* microseconds since lkb was added to current queue */

	us = ktime_to_us(ktime_sub(ktime_get(), lkb->lkb_timestamp));



	/* id nodeid remid pid xid exflags flags sts grmode rqmode time_ms

	/* id nodeid remid pid xid exflags flags sts grmode rqmode time_us

	   r_nodeid r_len r_name */



	seq_printf(s, "%x %d %x %u %llu %x %x %d %d %d %u %u %d \"%s\"\n",

	seq_printf(s, "%x %d %x %u %llu %x %x %d %d %d %llu %u %d \"%s\"\n",

		   lkb->lkb_id,

		   lkb->lkb_nodeid,

		   lkb->lkb_remid,
@@ -187,26 +188,114 @@ static void print_lock(struct seq_file *s, struct dlm_lkb *lkb, struct dlm_rsb * 
		   lkb->lkb_status,

		   lkb->lkb_grmode,

		   lkb->lkb_rqmode,

		   waiting,

		   (unsigned long long)us,

		   r->res_nodeid,

		   r->res_length,

		   r->res_name);

}



static int print_locks(struct dlm_rsb *r, struct seq_file *s)

static int print_format2(struct dlm_rsb *r, struct seq_file *s)

{

	struct dlm_lkb *lkb;



	lock_rsb(r);



	list_for_each_entry(lkb, &r->res_grantqueue, lkb_statequeue)

		print_lock(s, lkb, r);

		print_format2_lock(s, lkb, r);



	list_for_each_entry(lkb, &r->res_convertqueue, lkb_statequeue)

		print_lock(s, lkb, r);

		print_format2_lock(s, lkb, r);



	list_for_each_entry(lkb, &r->res_waitqueue, lkb_statequeue)

		print_lock(s, lkb, r);

		print_format2_lock(s, lkb, r);



	unlock_rsb(r);

	return 0;

}



static void print_format3_lock(struct seq_file *s, struct dlm_lkb *lkb,

			       int rsb_lookup)

{

	u64 xid = 0;



	if (lkb->lkb_flags & DLM_IFL_USER) {

		if (lkb->lkb_ua)

			xid = lkb->lkb_ua->xid;

	}



	seq_printf(s, "lkb %x %d %x %u %llu %x %x %d %d %d %d %d %d %u %llu %llu\n",

		   lkb->lkb_id,

		   lkb->lkb_nodeid,

		   lkb->lkb_remid,

		   lkb->lkb_ownpid,

		   (unsigned long long)xid,

		   lkb->lkb_exflags,

		   lkb->lkb_flags,

		   lkb->lkb_status,

		   lkb->lkb_grmode,

		   lkb->lkb_rqmode,

		   lkb->lkb_highbast,

		   rsb_lookup,

		   lkb->lkb_wait_type,

		   lkb->lkb_lvbseq,

		   (unsigned long long)ktime_to_ns(lkb->lkb_timestamp),

		   (unsigned long long)ktime_to_ns(lkb->lkb_time_bast));

}



static int print_format3(struct dlm_rsb *r, struct seq_file *s)

{

	struct dlm_lkb *lkb;

	int i, lvblen = r->res_ls->ls_lvblen;

	int print_name = 1;



	lock_rsb(r);



	seq_printf(s, "rsb %p %d %x %lx %d %d %u %d ",

		   r,

		   r->res_nodeid,

		   r->res_first_lkid,

		   r->res_flags,

		   !list_empty(&r->res_root_list),

		   !list_empty(&r->res_recover_list),

		   r->res_recover_locks_count,

		   r->res_length);



	for (i = 0; i < r->res_length; i++) {

		if (!isascii(r->res_name[i]) || !isprint(r->res_name[i]))

			print_name = 0;

	}



	seq_printf(s, "%s", print_name ? "str " : "hex");



	for (i = 0; i < r->res_length; i++) {

		if (print_name)

			seq_printf(s, "%c", r->res_name[i]);

		else

			seq_printf(s, " %02x", (unsigned char)r->res_name[i]);

	}

	seq_printf(s, "\n");



	if (!r->res_lvbptr)

		goto do_locks;



	seq_printf(s, "lvb %u %d", r->res_lvbseq, lvblen);



	for (i = 0; i < lvblen; i++)

		seq_printf(s, " %02x", (unsigned char)r->res_lvbptr[i]);

	seq_printf(s, "\n");



 do_locks:

	list_for_each_entry(lkb, &r->res_grantqueue, lkb_statequeue)

		print_format3_lock(s, lkb, 0);



	list_for_each_entry(lkb, &r->res_convertqueue, lkb_statequeue)

		print_format3_lock(s, lkb, 0);



	list_for_each_entry(lkb, &r->res_waitqueue, lkb_statequeue)

		print_format3_lock(s, lkb, 0);



	list_for_each_entry(lkb, &r->res_lookup, lkb_rsb_lookup)

		print_format3_lock(s, lkb, 1);



	unlock_rsb(r);

	return 0;
@@ -274,6 +363,7 @@ static struct rsb_iter *rsb_iter_init(struct dlm_ls *ls) 
	ri->ls = ls;

	ri->entry = 0;

	ri->next = NULL;

	ri->format = 1;



	if (rsb_iter_next(ri)) {

		rsb_iter_free(ri);
@@ -325,16 +415,26 @@ static int rsb_seq_show(struct seq_file *file, void *iter_ptr) 
{

	struct rsb_iter *ri = iter_ptr;



	if (ri->locks) {

	switch (ri->format) {

	case 1:

		print_format1(ri->rsb, file);

		break;

	case 2:

		if (ri->header) {

			seq_printf(file, "id nodeid remid pid xid exflags flags "

					 "sts grmode rqmode time_ms r_nodeid "

					 "r_len r_name\n");

			seq_printf(file, "id nodeid remid pid xid exflags "

					 "flags sts grmode rqmode time_ms "

					 "r_nodeid r_len r_name\n");

			ri->header = 0;

		}

		print_locks(ri->rsb, file);

	} else {

		print_resource(ri->rsb, file);

		print_format2(ri->rsb, file);

		break;

	case 3:

		if (ri->header) {

			seq_printf(file, "version rsb 1.1 lvb 1.1 lkb 1.1\n");

			ri->header = 0;

		}

		print_format3(ri->rsb, file);

		break;

	}



	return 0;
@@ -385,7 +485,7 @@ static struct rsb_iter *locks_iter_init(struct dlm_ls *ls, loff_t *pos) 
	ri->ls = ls;

	ri->entry = 0;

	ri->next = NULL;

	ri->locks = 1;

	ri->format = 2;



	if (*pos == 0)

		ri->header = 1;
@@ -447,6 +547,84 @@ static const struct file_operations locks_fops = { 
	.release = seq_release

};



/*

 * Dump all rsb/lvb/lkb state in compact listing, more complete than _locks

 * This can replace both formats 1 and 2 eventually.

 */



static struct rsb_iter *all_iter_init(struct dlm_ls *ls, loff_t *pos)

{

	struct rsb_iter *ri;



	ri = kzalloc(sizeof *ri, GFP_KERNEL);

	if (!ri)

		return NULL;



	ri->ls = ls;

	ri->entry = 0;

	ri->next = NULL;

	ri->format = 3;



	if (*pos == 0)

		ri->header = 1;



	if (rsb_iter_next(ri)) {

		rsb_iter_free(ri);

		return NULL;

	}



	return ri;

}



static void *all_seq_start(struct seq_file *file, loff_t *pos)

{

	struct rsb_iter *ri;

	loff_t n = *pos;



	ri = all_iter_init(file->private, pos);

	if (!ri)

		return NULL;



	while (n--) {

		if (rsb_iter_next(ri)) {

			rsb_iter_free(ri);

			return NULL;

		}

	}



	return ri;

}



static struct seq_operations all_seq_ops = {

	.start = all_seq_start,

	.next  = rsb_seq_next,

	.stop  = rsb_seq_stop,

	.show  = rsb_seq_show,

};



static int all_open(struct inode *inode, struct file *file)

{

	struct seq_file *seq;

	int ret;



	ret = seq_open(file, &all_seq_ops);

	if (ret)

		return ret;



	seq = file->private_data;

	seq->private = inode->i_private;



	return 0;

}



static const struct file_operations all_fops = {

	.owner   = THIS_MODULE,

	.open    = all_open,

	.read    = seq_read,

	.llseek  = seq_lseek,

	.release = seq_release

};



/*

 * dump lkb's on the ls_waiters list

 */
@@ -489,56 +667,74 @@ static const struct file_operations waiters_fops = { 
	.read    = waiters_read

};



void dlm_delete_debug_file(struct dlm_ls *ls)

{

	if (ls->ls_debug_rsb_dentry)

		debugfs_remove(ls->ls_debug_rsb_dentry);

	if (ls->ls_debug_waiters_dentry)

		debugfs_remove(ls->ls_debug_waiters_dentry);

	if (ls->ls_debug_locks_dentry)

		debugfs_remove(ls->ls_debug_locks_dentry);

	if (ls->ls_debug_all_dentry)

		debugfs_remove(ls->ls_debug_all_dentry);

}



int dlm_create_debug_file(struct dlm_ls *ls)

{

	char name[DLM_LOCKSPACE_LEN+8];



	/* format 1 */



	ls->ls_debug_rsb_dentry = debugfs_create_file(ls->ls_name,

						      S_IFREG | S_IRUGO,

						      dlm_root,

						      ls,

						      &rsb_fops);

	if (!ls->ls_debug_rsb_dentry)

		return -ENOMEM;

		goto fail;



	/* format 2 */



	memset(name, 0, sizeof(name));

	snprintf(name, DLM_LOCKSPACE_LEN+8, "%s_waiters", ls->ls_name);

	snprintf(name, DLM_LOCKSPACE_LEN+8, "%s_locks", ls->ls_name);



	ls->ls_debug_waiters_dentry = debugfs_create_file(name,

	ls->ls_debug_locks_dentry = debugfs_create_file(name,

							S_IFREG | S_IRUGO,

							dlm_root,

							ls,

							  &waiters_fops);

	if (!ls->ls_debug_waiters_dentry) {

		debugfs_remove(ls->ls_debug_rsb_dentry);

		return -ENOMEM;

	}

							&locks_fops);

	if (!ls->ls_debug_locks_dentry)

		goto fail;



	/* format 3 */



	memset(name, 0, sizeof(name));

	snprintf(name, DLM_LOCKSPACE_LEN+8, "%s_locks", ls->ls_name);

	snprintf(name, DLM_LOCKSPACE_LEN+8, "%s_all", ls->ls_name);



	ls->ls_debug_locks_dentry = debugfs_create_file(name,

	ls->ls_debug_all_dentry = debugfs_create_file(name,

						      S_IFREG | S_IRUGO,

						      dlm_root,

						      ls,

							&locks_fops);

	if (!ls->ls_debug_locks_dentry) {

		debugfs_remove(ls->ls_debug_waiters_dentry);

		debugfs_remove(ls->ls_debug_rsb_dentry);

		return -ENOMEM;

	}

						      &all_fops);

	if (!ls->ls_debug_all_dentry)

		goto fail;



	memset(name, 0, sizeof(name));

	snprintf(name, DLM_LOCKSPACE_LEN+8, "%s_waiters", ls->ls_name);



	ls->ls_debug_waiters_dentry = debugfs_create_file(name,

							  S_IFREG | S_IRUGO,

							  dlm_root,

							  ls,

							  &waiters_fops);

	if (!ls->ls_debug_waiters_dentry)

		goto fail;



	return 0;

}



void dlm_delete_debug_file(struct dlm_ls *ls)

{

	if (ls->ls_debug_rsb_dentry)

		debugfs_remove(ls->ls_debug_rsb_dentry);

	if (ls->ls_debug_waiters_dentry)

		debugfs_remove(ls->ls_debug_waiters_dentry);

	if (ls->ls_debug_locks_dentry)

		debugfs_remove(ls->ls_debug_locks_dentry);

 fail:

	dlm_delete_debug_file(ls);

	return -ENOMEM;

}



int __init dlm_register_debugfs(void)

fs/dlm/dir.c

+9 −9
Original line number Diff line number Diff line
@@ -374,7 +374,7 @@ void dlm_copy_master_names(struct dlm_ls *ls, char *inbuf, int inlen, 
	struct list_head *list;

	struct dlm_rsb *r;

	int offset = 0, dir_nodeid;

	uint16_t be_namelen;

	__be16 be_namelen;



	down_read(&ls->ls_root_sem);
@@ -410,15 +410,15 @@ void dlm_copy_master_names(struct dlm_ls *ls, char *inbuf, int inlen, 


		if (offset + sizeof(uint16_t)*2 + r->res_length > outlen) {

			/* Write end-of-block record */

			be_namelen = 0;

			memcpy(outbuf + offset, &be_namelen, sizeof(uint16_t));

			offset += sizeof(uint16_t);

			be_namelen = cpu_to_be16(0);

			memcpy(outbuf + offset, &be_namelen, sizeof(__be16));

			offset += sizeof(__be16);

			goto out;

		}



		be_namelen = cpu_to_be16(r->res_length);

		memcpy(outbuf + offset, &be_namelen, sizeof(uint16_t));

		offset += sizeof(uint16_t);

		memcpy(outbuf + offset, &be_namelen, sizeof(__be16));

		offset += sizeof(__be16);

		memcpy(outbuf + offset, r->res_name, r->res_length);

		offset += r->res_length;

	}
@@ -430,9 +430,9 @@ void dlm_copy_master_names(struct dlm_ls *ls, char *inbuf, int inlen, 


	if ((list == &ls->ls_root_list) &&

	    (offset + sizeof(uint16_t) <= outlen)) {

		be_namelen = 0xFFFF;

		memcpy(outbuf + offset, &be_namelen, sizeof(uint16_t));

		offset += sizeof(uint16_t);

		be_namelen = cpu_to_be16(0xFFFF);

		memcpy(outbuf + offset, &be_namelen, sizeof(__be16));

		offset += sizeof(__be16);

	}



 out:

fs/dlm/dlm_internal.h

+3 −1
Original line number Diff line number Diff line
@@ -245,7 +245,8 @@ struct dlm_lkb { 
	struct list_head	lkb_astqueue;	/* need ast to be sent */

	struct list_head	lkb_ownqueue;	/* list of locks for a process */

	struct list_head	lkb_time_list;

	unsigned long		lkb_timestamp;

	ktime_t			lkb_time_bast;	/* for debugging */

	ktime_t			lkb_timestamp;

	unsigned long		lkb_timeout_cs;



	char			*lkb_lvbptr;
@@ -481,6 +482,7 @@ struct dlm_ls { 
	struct dentry		*ls_debug_rsb_dentry; /* debugfs */

	struct dentry		*ls_debug_waiters_dentry; /* debugfs */

	struct dentry		*ls_debug_locks_dentry; /* debugfs */

	struct dentry		*ls_debug_all_dentry; /* debugfs */



	wait_queue_head_t	ls_uevent_wait;	/* user part of join/leave */

	int			ls_uevent_result;