Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/teigland/dlm (7d8a804c) · Commits · 戴 / test

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;

Admin message