Commit 29b7998d authored by David Teigland's avatar David Teigland Committed by Steven Whitehouse
Browse files

[GFS2] The lock modules for GFS2 



This patch contains the pluggable locking modules
for GFS2.

Signed-off-by: default avatarDavid Teigland <teigland@redhat.com>
Signed-off-by: default avatarSteven Whitehouse <swhiteho@redhat.com>
parent b3b94faa

fs/gfs2/locking/dlm/Makefile

0 → 100644
+3 −0
Original line number Diff line number Diff line 
obj-$(CONFIG_GFS2_FS) += lock_dlm.o

lock_dlm-y := lock.o main.o mount.o sysfs.o thread.o

fs/gfs2/locking/dlm/lock.c

0 → 100644
+537 −0
Original line number Diff line number Diff line 
/******************************************************************************

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

**

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

**  Copyright (C) 2004-2005 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

**  of the GNU General Public License v.2.

**

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

******************************************************************************/



#include "lock_dlm.h"



static char junk_lvb[GDLM_LVB_SIZE];



static void queue_complete(struct gdlm_lock *lp)

{

	struct gdlm_ls *ls = lp->ls;



	clear_bit(LFL_ACTIVE, &lp->flags);



	spin_lock(&ls->async_lock);

	list_add_tail(&lp->clist, &ls->complete);

	spin_unlock(&ls->async_lock);

	wake_up(&ls->thread_wait);

}



static inline void gdlm_ast(void *astarg)

{

	queue_complete((struct gdlm_lock *) astarg);

}



static inline void gdlm_bast(void *astarg, int mode)

{

	struct gdlm_lock *lp = astarg;

	struct gdlm_ls *ls = lp->ls;



	if (!mode) {

		printk("lock_dlm: bast mode zero %x,%"PRIx64"\n",

			lp->lockname.ln_type, lp->lockname.ln_number);

		return;

	}



	spin_lock(&ls->async_lock);

	if (!lp->bast_mode) {

		list_add_tail(&lp->blist, &ls->blocking);

		lp->bast_mode = mode;

	} else if (lp->bast_mode < mode)

		lp->bast_mode = mode;

	spin_unlock(&ls->async_lock);

	wake_up(&ls->thread_wait);

}



void gdlm_queue_delayed(struct gdlm_lock *lp)

{

	struct gdlm_ls *ls = lp->ls;



	spin_lock(&ls->async_lock);

	list_add_tail(&lp->delay_list, &ls->delayed);

	spin_unlock(&ls->async_lock);

}



/* convert gfs lock-state to dlm lock-mode */



static int16_t make_mode(int16_t lmstate)

{

	switch (lmstate) {

	case LM_ST_UNLOCKED:

		return DLM_LOCK_NL;

	case LM_ST_EXCLUSIVE:

		return DLM_LOCK_EX;

	case LM_ST_DEFERRED:

		return DLM_LOCK_CW;

	case LM_ST_SHARED:

		return DLM_LOCK_PR;

	default:

		GDLM_ASSERT(0, printk("unknown LM state %d\n", lmstate););

	}

}



/* convert dlm lock-mode to gfs lock-state */



int16_t gdlm_make_lmstate(int16_t dlmmode)

{

	switch (dlmmode) {

	case DLM_LOCK_IV:

	case DLM_LOCK_NL:

		return LM_ST_UNLOCKED;

	case DLM_LOCK_EX:

		return LM_ST_EXCLUSIVE;

	case DLM_LOCK_CW:

		return LM_ST_DEFERRED;

	case DLM_LOCK_PR:

		return LM_ST_SHARED;

	default:

		GDLM_ASSERT(0, printk("unknown DLM mode %d\n", dlmmode););

	}

}



/* verify agreement with GFS on the current lock state, NB: DLM_LOCK_NL and

   DLM_LOCK_IV are both considered LM_ST_UNLOCKED by GFS. */



static void check_cur_state(struct gdlm_lock *lp, unsigned int cur_state)

{

	int16_t cur = make_mode(cur_state);

	if (lp->cur != DLM_LOCK_IV)

		GDLM_ASSERT(lp->cur == cur, printk("%d, %d\n", lp->cur, cur););

}



static inline unsigned int make_flags(struct gdlm_lock *lp,

				      unsigned int gfs_flags,

				      int16_t cur, int16_t req)

{

	unsigned int lkf = 0;



	if (gfs_flags & LM_FLAG_TRY)

		lkf |= DLM_LKF_NOQUEUE;



	if (gfs_flags & LM_FLAG_TRY_1CB) {

		lkf |= DLM_LKF_NOQUEUE;

		lkf |= DLM_LKF_NOQUEUEBAST;

	}



	if (gfs_flags & LM_FLAG_PRIORITY) {

		lkf |= DLM_LKF_NOORDER;

		lkf |= DLM_LKF_HEADQUE;

	}



	if (gfs_flags & LM_FLAG_ANY) {

		if (req == DLM_LOCK_PR)

			lkf |= DLM_LKF_ALTCW;

		else if (req == DLM_LOCK_CW)

			lkf |= DLM_LKF_ALTPR;

	}



	if (lp->lksb.sb_lkid != 0) {

		lkf |= DLM_LKF_CONVERT;



		/* Conversion deadlock avoidance by DLM */



		if (!test_bit(LFL_FORCE_PROMOTE, &lp->flags) &&

		    !(lkf & DLM_LKF_NOQUEUE) &&

		    cur > DLM_LOCK_NL && req > DLM_LOCK_NL && cur != req)

			lkf |= DLM_LKF_CONVDEADLK;

	}



	if (lp->lvb)

		lkf |= DLM_LKF_VALBLK;



	return lkf;

}



/* make_strname - convert GFS lock numbers to a string */



static inline void make_strname(struct lm_lockname *lockname,

				struct gdlm_strname *str)

{

	sprintf(str->name, "%8x%16"PRIx64, lockname->ln_type,

		lockname->ln_number);

	str->namelen = GDLM_STRNAME_BYTES;

}



int gdlm_create_lp(struct gdlm_ls *ls, struct lm_lockname *name,

		   struct gdlm_lock **lpp)

{

	struct gdlm_lock *lp;



	lp = kmalloc(sizeof(struct gdlm_lock), GFP_KERNEL);

	if (!lp)

		return -ENOMEM;



	memset(lp, 0, sizeof(struct gdlm_lock));

	lp->lockname = *name;

	lp->ls = ls;

	lp->cur = DLM_LOCK_IV;

	lp->lvb = NULL;

	lp->hold_null = NULL;

	init_completion(&lp->ast_wait);

	INIT_LIST_HEAD(&lp->clist);

	INIT_LIST_HEAD(&lp->blist);

	INIT_LIST_HEAD(&lp->delay_list);



	spin_lock(&ls->async_lock);

	list_add(&lp->all_list, &ls->all_locks);

	ls->all_locks_count++;

	spin_unlock(&ls->async_lock);



	*lpp = lp;

	return 0;

}



void gdlm_delete_lp(struct gdlm_lock *lp)

{

	struct gdlm_ls *ls = lp->ls;



	spin_lock(&ls->async_lock);

	if (!list_empty(&lp->clist))

		list_del_init(&lp->clist);

	if (!list_empty(&lp->blist))

		list_del_init(&lp->blist);

	if (!list_empty(&lp->delay_list))

		list_del_init(&lp->delay_list);

	GDLM_ASSERT(!list_empty(&lp->all_list),);

	list_del_init(&lp->all_list);

	ls->all_locks_count--;

	spin_unlock(&ls->async_lock);



	kfree(lp);

}



int gdlm_get_lock(lm_lockspace_t *lockspace, struct lm_lockname *name,

		  lm_lock_t **lockp)

{

	struct gdlm_lock *lp;

	int error;



	error = gdlm_create_lp((struct gdlm_ls *) lockspace, name, &lp);



	*lockp = (lm_lock_t *) lp;

	return error;

}



void gdlm_put_lock(lm_lock_t *lock)

{

	gdlm_delete_lp((struct gdlm_lock *) lock);

}



void gdlm_do_lock(struct gdlm_lock *lp, struct dlm_range *range)

{

	struct gdlm_ls *ls = lp->ls;

	struct gdlm_strname str;

	int error, bast = 1;



	/*

	 * When recovery is in progress, delay lock requests for submission

	 * once recovery is done.  Requests for recovery (NOEXP) and unlocks

	 * can pass.

	 */



	if (test_bit(DFL_BLOCK_LOCKS, &ls->flags) &&

	    !test_bit(LFL_NOBLOCK, &lp->flags) && lp->req != DLM_LOCK_NL) {

		gdlm_queue_delayed(lp);

		return;

	}



	/*

	 * Submit the actual lock request.

	 */



	if (test_bit(LFL_NOBAST, &lp->flags))

		bast = 0;



	make_strname(&lp->lockname, &str);



	set_bit(LFL_ACTIVE, &lp->flags);



	log_debug("lk %x,%"PRIx64" id %x %d,%d %x", lp->lockname.ln_type,

		  lp->lockname.ln_number, lp->lksb.sb_lkid,

		  lp->cur, lp->req, lp->lkf);



	error = dlm_lock(ls->dlm_lockspace, lp->req, &lp->lksb, lp->lkf,

			 str.name, str.namelen, 0, gdlm_ast, (void *) lp,

			 bast ? gdlm_bast : NULL, range);



	if ((error == -EAGAIN) && (lp->lkf & DLM_LKF_NOQUEUE)) {

		lp->lksb.sb_status = -EAGAIN;

		queue_complete(lp);

		error = 0;

	}



	GDLM_ASSERT(!error,

		   printk("%s: num=%x,%"PRIx64" err=%d cur=%d req=%d lkf=%x\n",

			  ls->fsname, lp->lockname.ln_type,

			  lp->lockname.ln_number, error, lp->cur, lp->req,

			  lp->lkf););

}



void gdlm_do_unlock(struct gdlm_lock *lp)

{

	unsigned int lkf = 0;

	int error;



	set_bit(LFL_DLM_UNLOCK, &lp->flags);

	set_bit(LFL_ACTIVE, &lp->flags);



	if (lp->lvb)

		lkf = DLM_LKF_VALBLK;



	log_debug("un %x,%"PRIx64" %x %d %x", lp->lockname.ln_type,

		  lp->lockname.ln_number, lp->lksb.sb_lkid, lp->cur, lkf);



	error = dlm_unlock(lp->ls->dlm_lockspace, lp->lksb.sb_lkid, lkf,

			   NULL, lp);



	GDLM_ASSERT(!error,

		   printk("%s: error=%d num=%x,%"PRIx64" lkf=%x flags=%lx\n",

			  lp->ls->fsname, error, lp->lockname.ln_type,

			  lp->lockname.ln_number, lkf, lp->flags););

}



unsigned int gdlm_lock(lm_lock_t *lock, unsigned int cur_state,

		       unsigned int req_state, unsigned int flags)

{

	struct gdlm_lock *lp = (struct gdlm_lock *) lock;



	clear_bit(LFL_DLM_CANCEL, &lp->flags);

	if (flags & LM_FLAG_NOEXP)

		set_bit(LFL_NOBLOCK, &lp->flags);



	check_cur_state(lp, cur_state);

	lp->req = make_mode(req_state);

	lp->lkf = make_flags(lp, flags, lp->cur, lp->req);



	gdlm_do_lock(lp, NULL);

	return LM_OUT_ASYNC;

}



unsigned int gdlm_unlock(lm_lock_t *lock, unsigned int cur_state)

{

	struct gdlm_lock *lp = (struct gdlm_lock *) lock;



	clear_bit(LFL_DLM_CANCEL, &lp->flags);

	if (lp->cur == DLM_LOCK_IV)

		return 0;

	gdlm_do_unlock(lp);

	return LM_OUT_ASYNC;

}



void gdlm_cancel(lm_lock_t *lock)

{

	struct gdlm_lock *lp = (struct gdlm_lock *) lock;

	struct gdlm_ls *ls = lp->ls;

	int error, delay_list = 0;



	if (test_bit(LFL_DLM_CANCEL, &lp->flags))

		return;



	log_all("gdlm_cancel %x,%"PRIx64" flags %lx",

		lp->lockname.ln_type, lp->lockname.ln_number, lp->flags);



	spin_lock(&ls->async_lock);

	if (!list_empty(&lp->delay_list)) {

		list_del_init(&lp->delay_list);

		delay_list = 1;

	}

	spin_unlock(&ls->async_lock);



	if (delay_list) {

		set_bit(LFL_CANCEL, &lp->flags);

		set_bit(LFL_ACTIVE, &lp->flags);

		queue_complete(lp);

		return;

	}



	if (!test_bit(LFL_ACTIVE, &lp->flags) ||

	    test_bit(LFL_DLM_UNLOCK, &lp->flags))	{

		log_all("gdlm_cancel skip %x,%"PRIx64" flags %lx",

			lp->lockname.ln_type, lp->lockname.ln_number,

			lp->flags);

		return;

	}



	/* the lock is blocked in the dlm */



	set_bit(LFL_DLM_CANCEL, &lp->flags);

	set_bit(LFL_ACTIVE, &lp->flags);



	error = dlm_unlock(ls->dlm_lockspace, lp->lksb.sb_lkid, DLM_LKF_CANCEL,

			   NULL, lp);



	log_all("gdlm_cancel rv %d %x,%"PRIx64" flags %lx", error,

		lp->lockname.ln_type, lp->lockname.ln_number, lp->flags);



	if (error == -EBUSY)

		clear_bit(LFL_DLM_CANCEL, &lp->flags);

}



int gdlm_add_lvb(struct gdlm_lock *lp)

{

	char *lvb;



	lvb = kmalloc(GDLM_LVB_SIZE, GFP_KERNEL);

	if (!lvb)

		return -ENOMEM;



	memset(lvb, 0, GDLM_LVB_SIZE);



	lp->lksb.sb_lvbptr = lvb;

	lp->lvb = lvb;

	return 0;

}



void gdlm_del_lvb(struct gdlm_lock *lp)

{

	kfree(lp->lvb);

	lp->lvb = NULL;

	lp->lksb.sb_lvbptr = NULL;

}



/* This can do a synchronous dlm request (requiring a lock_dlm thread to get

   the completion) because gfs won't call hold_lvb() during a callback (from

   the context of a lock_dlm thread). */



static int hold_null_lock(struct gdlm_lock *lp)

{

	struct gdlm_lock *lpn = NULL;

	int error;



	if (lp->hold_null) {

		printk("lock_dlm: lvb already held\n");

		return 0;

	}



	error = gdlm_create_lp(lp->ls, &lp->lockname, &lpn);

	if (error)

		goto out;



	lpn->lksb.sb_lvbptr = junk_lvb;

	lpn->lvb = junk_lvb;



	lpn->req = DLM_LOCK_NL;

	lpn->lkf = DLM_LKF_VALBLK | DLM_LKF_EXPEDITE;

	set_bit(LFL_NOBAST, &lpn->flags);

	set_bit(LFL_INLOCK, &lpn->flags);



	init_completion(&lpn->ast_wait);

	gdlm_do_lock(lpn, NULL);

	wait_for_completion(&lpn->ast_wait);

	error = lp->lksb.sb_status;

	if (error) {

		printk("lock_dlm: hold_null_lock dlm error %d\n", error);

		gdlm_delete_lp(lpn);

		lpn = NULL;

	}

 out:

	lp->hold_null = lpn;

	return error;

}



/* This cannot do a synchronous dlm request (requiring a lock_dlm thread to get

   the completion) because gfs may call unhold_lvb() during a callback (from

   the context of a lock_dlm thread) which could cause a deadlock since the

   other lock_dlm thread could be engaged in recovery. */



static void unhold_null_lock(struct gdlm_lock *lp)

{

	struct gdlm_lock *lpn = lp->hold_null;



	GDLM_ASSERT(lpn,);

	lpn->lksb.sb_lvbptr = NULL;

	lpn->lvb = NULL;

	set_bit(LFL_UNLOCK_DELETE, &lpn->flags);

	gdlm_do_unlock(lpn);

	lp->hold_null = NULL;

}



/* Acquire a NL lock because gfs requires the value block to remain

   intact on the resource while the lvb is "held" even if it's holding no locks

   on the resource. */



int gdlm_hold_lvb(lm_lock_t *lock, char **lvbp)

{

	struct gdlm_lock *lp = (struct gdlm_lock *) lock;

	int error;



	error = gdlm_add_lvb(lp);

	if (error)

		return error;



	*lvbp = lp->lvb;



	error = hold_null_lock(lp);

	if (error)

		gdlm_del_lvb(lp);



	return error;

}



void gdlm_unhold_lvb(lm_lock_t *lock, char *lvb)

{

	struct gdlm_lock *lp = (struct gdlm_lock *) lock;



	unhold_null_lock(lp);

	gdlm_del_lvb(lp);

}



void gdlm_sync_lvb(lm_lock_t *lock, char *lvb)

{

	struct gdlm_lock *lp = (struct gdlm_lock *) lock;



	if (lp->cur != DLM_LOCK_EX)

		return;



	init_completion(&lp->ast_wait);

	set_bit(LFL_SYNC_LVB, &lp->flags);



	lp->req = DLM_LOCK_EX;

	lp->lkf = make_flags(lp, 0, lp->cur, lp->req);



	gdlm_do_lock(lp, NULL);

	wait_for_completion(&lp->ast_wait);

}



void gdlm_submit_delayed(struct gdlm_ls *ls)

{

	struct gdlm_lock *lp, *safe;



	spin_lock(&ls->async_lock);

	list_for_each_entry_safe(lp, safe, &ls->delayed, delay_list) {

		list_del_init(&lp->delay_list);

		list_add_tail(&lp->delay_list, &ls->submit);

	}

	spin_unlock(&ls->async_lock);

	wake_up(&ls->thread_wait);

}



int gdlm_release_all_locks(struct gdlm_ls *ls)

{

	struct gdlm_lock *lp, *safe;

	int count = 0;



	spin_lock(&ls->async_lock);

	list_for_each_entry_safe(lp, safe, &ls->all_locks, all_list) {

		list_del_init(&lp->all_list);



		if (lp->lvb && lp->lvb != junk_lvb)

			kfree(lp->lvb);

		kfree(lp);

		count++;

	}

	spin_unlock(&ls->async_lock);



	return count;

}

fs/gfs2/locking/dlm/main.c

0 → 100644
+58 −0
Original line number Diff line number Diff line 
/******************************************************************************

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

**

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

**  Copyright (C) 2004-2005 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

**  of the GNU General Public License v.2.

**

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

******************************************************************************/



#include <linux/init.h>



#include "lock_dlm.h"



extern int gdlm_drop_count;

extern int gdlm_drop_period;



extern struct lm_lockops gdlm_ops;



int __init init_lock_dlm(void)

{

	int error;



	error = lm_register_proto(&gdlm_ops);

	if (error) {

		printk("lock_dlm:  can't register protocol: %d\n", error);

		return error;

	}



	error = gdlm_sysfs_init();

	if (error) {

		lm_unregister_proto(&gdlm_ops);

		return error;

	}



	gdlm_drop_count = GDLM_DROP_COUNT;

	gdlm_drop_period = GDLM_DROP_PERIOD;



	printk("Lock_DLM (built %s %s) installed\n", __DATE__, __TIME__);

	return 0;

}



void __exit exit_lock_dlm(void)

{

	lm_unregister_proto(&gdlm_ops);

	gdlm_sysfs_exit();

}



module_init(init_lock_dlm);

module_exit(exit_lock_dlm);



MODULE_DESCRIPTION("GFS DLM Locking Module");

MODULE_AUTHOR("Red Hat, Inc.");

MODULE_LICENSE("GPL");

fs/gfs2/locking/dlm/mount.c

0 → 100644
+240 −0
Original line number Diff line number Diff line 
/******************************************************************************

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

**

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

**  Copyright (C) 2004-2005 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

**  of the GNU General Public License v.2.

**

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

******************************************************************************/



#include "lock_dlm.h"



int gdlm_drop_count;

int gdlm_drop_period;

struct lm_lockops gdlm_ops;





static struct gdlm_ls *init_gdlm(lm_callback_t cb, lm_fsdata_t *fsdata,

				 int flags, char *table_name)

{

	struct gdlm_ls *ls;

	char buf[256], *p;



	ls = kmalloc(sizeof(struct gdlm_ls), GFP_KERNEL);

	if (!ls)

		return NULL;



	memset(ls, 0, sizeof(struct gdlm_ls));



	ls->drop_locks_count = gdlm_drop_count;

	ls->drop_locks_period = gdlm_drop_period;



	ls->fscb = cb;

	ls->fsdata = fsdata;

	ls->fsflags = flags;



	spin_lock_init(&ls->async_lock);



	INIT_LIST_HEAD(&ls->complete);

	INIT_LIST_HEAD(&ls->blocking);

	INIT_LIST_HEAD(&ls->delayed);

	INIT_LIST_HEAD(&ls->submit);

	INIT_LIST_HEAD(&ls->all_locks);



	init_waitqueue_head(&ls->thread_wait);

	init_waitqueue_head(&ls->wait_control);

	ls->thread1 = NULL;

	ls->thread2 = NULL;

	ls->drop_time = jiffies;

	ls->jid = -1;



	strncpy(buf, table_name, 256);

	buf[255] = '\0';



	p = strstr(buf, ":");

	if (!p) {

		printk("lock_dlm: invalid table_name \"%s\"\n", table_name);

		kfree(ls);

		return NULL;

	}

	*p = '\0';

	p++;



	strncpy(ls->clustername, buf, 128);

	strncpy(ls->fsname, p, 128);



	return ls;

}



static int gdlm_mount(char *table_name, char *host_data,

			lm_callback_t cb, lm_fsdata_t *fsdata,

			unsigned int min_lvb_size, int flags,

			struct lm_lockstruct *lockstruct)

{

	struct gdlm_ls *ls;

	int error = -ENOMEM;



	if (min_lvb_size > GDLM_LVB_SIZE)

		goto out;



	ls = init_gdlm(cb, fsdata, flags, table_name);

	if (!ls)

		goto out;



	error = gdlm_init_threads(ls);

	if (error)

		goto out_free;



	error = dlm_new_lockspace(ls->fsname, strlen(ls->fsname),

				  &ls->dlm_lockspace, 0, GDLM_LVB_SIZE);

	if (error) {

		printk("lock_dlm: dlm_new_lockspace error %d\n", error);

		goto out_thread;

	}



	error = gdlm_kobject_setup(ls);

	if (error)

		goto out_dlm;

	kobject_uevent(&ls->kobj, KOBJ_MOUNT, NULL);



	/* Now we depend on userspace to notice the new mount,

	   join the appropriate group, and do a write to our sysfs

	   "mounted" or "terminate" file.  Before the start, userspace

	   must set "jid" and "first". */



	error = wait_event_interruptible(ls->wait_control,

			test_bit(DFL_JOIN_DONE, &ls->flags));

	if (error)

		goto out_sysfs;



	if (test_bit(DFL_TERMINATE, &ls->flags)) {

		error = -ERESTARTSYS;

		goto out_sysfs;

	}



	lockstruct->ls_jid = ls->jid;

	lockstruct->ls_first = ls->first;

	lockstruct->ls_lockspace = ls;

	lockstruct->ls_ops = &gdlm_ops;

	lockstruct->ls_flags = 0;

	lockstruct->ls_lvb_size = GDLM_LVB_SIZE;

	return 0;



 out_sysfs:

	gdlm_kobject_release(ls);

 out_dlm:

	dlm_release_lockspace(ls->dlm_lockspace, 2);

 out_thread:

	gdlm_release_threads(ls);

 out_free:

	kfree(ls);

 out:

	return error;

}



static void gdlm_unmount(lm_lockspace_t *lockspace)

{

	struct gdlm_ls *ls = (struct gdlm_ls *) lockspace;

	int rv;



	log_debug("unmount flags %lx", ls->flags);



	if (test_bit(DFL_WITHDRAW, &ls->flags)) {

		gdlm_kobject_release(ls);

		goto out;

	}



	kobject_uevent(&ls->kobj, KOBJ_UMOUNT, NULL);



	wait_event_interruptible(ls->wait_control,

				 test_bit(DFL_LEAVE_DONE, &ls->flags));



	gdlm_kobject_release(ls);

	dlm_release_lockspace(ls->dlm_lockspace, 2);

	gdlm_release_threads(ls);

	rv = gdlm_release_all_locks(ls);

	if (rv)

		log_all("lm_dlm_unmount: %d stray locks freed", rv);

 out:

	kfree(ls);

}



static void gdlm_recovery_done(lm_lockspace_t *lockspace, unsigned int jid,

                               unsigned int message)

{

	struct gdlm_ls *ls = (struct gdlm_ls *) lockspace;

	ls->recover_done = jid;

	kobject_uevent(&ls->kobj, KOBJ_CHANGE, NULL);

}



static void gdlm_others_may_mount(lm_lockspace_t *lockspace)

{

	struct gdlm_ls *ls = (struct gdlm_ls *) lockspace;

	ls->first_done = 1;

	kobject_uevent(&ls->kobj, KOBJ_CHANGE, NULL);

}



static void gdlm_withdraw(lm_lockspace_t *lockspace)

{

	struct gdlm_ls *ls = (struct gdlm_ls *) lockspace;



	/* userspace suspends locking on all other members */



	kobject_uevent(&ls->kobj, KOBJ_OFFLINE, NULL);



	wait_event_interruptible(ls->wait_control,

				 test_bit(DFL_WITHDRAW, &ls->flags));



	dlm_release_lockspace(ls->dlm_lockspace, 2);

	gdlm_release_threads(ls);

	gdlm_release_all_locks(ls);



	kobject_uevent(&ls->kobj, KOBJ_UMOUNT, NULL);



	/* userspace leaves the mount group, we don't need to wait for

	   that to complete */

}



int gdlm_plock_get(lm_lockspace_t *lockspace, struct lm_lockname *name,

		   struct file *file, struct file_lock *fl)

{

	return -ENOSYS;

}



int gdlm_punlock(lm_lockspace_t *lockspace, struct lm_lockname *name,

		   struct file *file, struct file_lock *fl)

{

	return -ENOSYS;

}



int gdlm_plock(lm_lockspace_t *lockspace, struct lm_lockname *name,

	       struct file *file, int cmd, struct file_lock *fl)

{

	return -ENOSYS;

}



struct lm_lockops gdlm_ops = {

	lm_proto_name:"lock_dlm",

	lm_mount:gdlm_mount,

	lm_others_may_mount:gdlm_others_may_mount,

	lm_unmount:gdlm_unmount,

	lm_withdraw:gdlm_withdraw,

	lm_get_lock:gdlm_get_lock,

	lm_put_lock:gdlm_put_lock,

	lm_lock:gdlm_lock,

	lm_unlock:gdlm_unlock,

	lm_plock:gdlm_plock,

	lm_punlock:gdlm_punlock,

	lm_plock_get:gdlm_plock_get,

	lm_cancel:gdlm_cancel,

	lm_hold_lvb:gdlm_hold_lvb,

	lm_unhold_lvb:gdlm_unhold_lvb,

	lm_sync_lvb:gdlm_sync_lvb,

	lm_recovery_done:gdlm_recovery_done,

	lm_owner:THIS_MODULE,

};

fs/gfs2/locking/dlm/sysfs.c

0 → 100644
+315 −0

File added.

Preview size limit exceeded, changes collapsed.

CRA Git | Maintained and supported by SUSTech CRA and CCSE