leandrof/linux
1
0
Fork 0
forked from Minki/linux
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[GFS2] An update of the GFS2 lock modules

Browse Source 
This brings the lock modules uptodate and removes the stray
.mod.c file which accidently got included in the last check in.

Signed-off-by: David Teigland <teigland@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
This commit is contained in:
David Teigland 2006-01-17 08:47:12 +00:00 committed by Steven Whitehouse
parent a8f2d64728
commit 869d81df53
11 changed files with 792 additions and 490 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
fs/gfs2/locking/dlm/Makefile
View File

@ -1,3 +1,3 @@
obj-$(CONFIG_GFS2_FS) += lock_dlm.o
lock_dlm-y := lock.o main.o mount.o sysfs.o thread.o
lock_dlm-y := lock.o main.o mount.o sysfs.o thread.o plock.o

104
fs/gfs2/locking/dlm/lock.c
View File

@ -1,15 +1,11 @@
/******************************************************************************
*******************************************************************************
**
** 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.
**
*******************************************************************************
******************************************************************************/
/*
* 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"
@ -38,7 +34,7 @@ static inline void gdlm_bast(void *astarg, int mode)
struct gdlm_ls *ls = lp->ls;
if (!mode) {
printk("lock_dlm: bast mode zero %x,%"PRIx64"\n",
printk("lock_dlm: bast mode zero %x,%llx\n",
lp->lockname.ln_type, lp->lockname.ln_number);
return;
}
@ -75,9 +71,9 @@ static int16_t make_mode(int16_t lmstate)
return DLM_LOCK_CW;
case LM_ST_SHARED:
return DLM_LOCK_PR;
default:
GDLM_ASSERT(0, printk("unknown LM state %d\n", lmstate););
}
gdlm_assert(0, "unknown LM state %d", lmstate);
return -1;
}
/* convert dlm lock-mode to gfs lock-state */
@ -94,9 +90,9 @@ int16_t gdlm_make_lmstate(int16_t dlmmode)
return LM_ST_DEFERRED;
case DLM_LOCK_PR:
return LM_ST_SHARED;
default:
GDLM_ASSERT(0, printk("unknown DLM mode %d\n", dlmmode););
}
gdlm_assert(0, "unknown DLM mode %d", dlmmode);
return -1;
}
/* verify agreement with GFS on the current lock state, NB: DLM_LOCK_NL and
@ -106,7 +102,7 @@ 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););
gdlm_assert(lp->cur == cur, "%d, %d", lp->cur, cur);
}
static inline unsigned int make_flags(struct gdlm_lock *lp,
@ -157,7 +153,7 @@ static inline unsigned int make_flags(struct gdlm_lock *lp,
static inline void make_strname(struct lm_lockname *lockname,
struct gdlm_strname *str)
{
sprintf(str->name, "%8x%16"PRIx64, lockname->ln_type,
sprintf(str->name, "%8x%16llx", lockname->ln_type,
lockname->ln_number);
str->namelen = GDLM_STRNAME_BYTES;
}
@ -167,11 +163,10 @@ int gdlm_create_lp(struct gdlm_ls *ls, struct lm_lockname *name,
{
struct gdlm_lock *lp;
lp = kmalloc(sizeof(struct gdlm_lock), GFP_KERNEL);
lp = kzalloc(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;
@ -202,7 +197,8 @@ void gdlm_delete_lp(struct gdlm_lock *lp)
list_del_init(&lp->blist);
if (!list_empty(&lp->delay_list))
list_del_init(&lp->delay_list);
GDLM_ASSERT(!list_empty(&lp->all_list),);
gdlm_assert(!list_empty(&lp->all_list),
"%x,%llx", lp->lockname.ln_type, lp->lockname.ln_number);
list_del_init(&lp->all_list);
ls->all_locks_count--;
spin_unlock(&ls->async_lock);
@ -227,7 +223,7 @@ 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)
unsigned int gdlm_do_lock(struct gdlm_lock *lp, struct dlm_range *range)
{
struct gdlm_ls *ls = lp->ls;
struct gdlm_strname str;
@ -242,7 +238,7 @@ void gdlm_do_lock(struct gdlm_lock *lp, struct dlm_range *range)
if (test_bit(DFL_BLOCK_LOCKS, &ls->flags) &&
!test_bit(LFL_NOBLOCK, &lp->flags) && lp->req != DLM_LOCK_NL) {
gdlm_queue_delayed(lp);
return;
return LM_OUT_ASYNC;
}
/*
@ -256,7 +252,7 @@ void gdlm_do_lock(struct gdlm_lock *lp, struct dlm_range *range)
set_bit(LFL_ACTIVE, &lp->flags);
log_debug("lk %x,%"PRIx64" id %x %d,%d %x", lp->lockname.ln_type,
log_debug("lk %x,%llx id %x %d,%d %x", lp->lockname.ln_type,
lp->lockname.ln_number, lp->lksb.sb_lkid,
lp->cur, lp->req, lp->lkf);
@ -270,15 +266,19 @@ void gdlm_do_lock(struct gdlm_lock *lp, struct dlm_range *range)
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,
if (error) {
log_debug("%s: gdlm_lock %x,%llx err=%d cur=%d req=%d lkf=%x "
"flags=%lx", ls->fsname, lp->lockname.ln_type,
lp->lockname.ln_number, error, lp->cur, lp->req,
lp->lkf););
lp->lkf, lp->flags);
return LM_OUT_ERROR;
}
return LM_OUT_ASYNC;
}
void gdlm_do_unlock(struct gdlm_lock *lp)
unsigned int gdlm_do_unlock(struct gdlm_lock *lp)
{
struct gdlm_ls *ls = lp->ls;
unsigned int lkf = 0;
int error;
@ -288,16 +288,19 @@ void gdlm_do_unlock(struct gdlm_lock *lp)
if (lp->lvb)
lkf = DLM_LKF_VALBLK;
log_debug("un %x,%"PRIx64" %x %d %x", lp->lockname.ln_type,
log_debug("un %x,%llx %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);
error = dlm_unlock(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););
if (error) {
log_debug("%s: gdlm_unlock %x,%llx err=%d cur=%d req=%d lkf=%x "
"flags=%lx", ls->fsname, lp->lockname.ln_type,
lp->lockname.ln_number, error, lp->cur, lp->req,
lp->lkf, lp->flags);
return LM_OUT_ERROR;
}
return LM_OUT_ASYNC;
}
unsigned int gdlm_lock(lm_lock_t *lock, unsigned int cur_state,
@ -313,8 +316,7 @@ unsigned int gdlm_lock(lm_lock_t *lock, unsigned int 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;
return gdlm_do_lock(lp, NULL);
}
unsigned int gdlm_unlock(lm_lock_t *lock, unsigned int cur_state)
@ -324,8 +326,7 @@ unsigned int gdlm_unlock(lm_lock_t *lock, unsigned int cur_state)
clear_bit(LFL_DLM_CANCEL, &lp->flags);
if (lp->cur == DLM_LOCK_IV)
return 0;
gdlm_do_unlock(lp);
return LM_OUT_ASYNC;
return gdlm_do_unlock(lp);
}
void gdlm_cancel(lm_lock_t *lock)
@ -337,8 +338,8 @@ void gdlm_cancel(lm_lock_t *lock)
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);
log_info("gdlm_cancel %x,%llx flags %lx",
lp->lockname.ln_type, lp->lockname.ln_number, lp->flags);
spin_lock(&ls->async_lock);
if (!list_empty(&lp->delay_list)) {
@ -356,9 +357,9 @@ void gdlm_cancel(lm_lock_t *lock)
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);
log_info("gdlm_cancel skip %x,%llx flags %lx",
lp->lockname.ln_type, lp->lockname.ln_number,
lp->flags);
return;
}
@ -370,8 +371,8 @@ void gdlm_cancel(lm_lock_t *lock)
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);
log_info("gdlm_cancel rv %d %x,%llx flags %lx", error,
lp->lockname.ln_type, lp->lockname.ln_number, lp->flags);
if (error == -EBUSY)
clear_bit(LFL_DLM_CANCEL, &lp->flags);
@ -381,12 +382,10 @@ int gdlm_add_lvb(struct gdlm_lock *lp)
{
char *lvb;
lvb = kmalloc(GDLM_LVB_SIZE, GFP_KERNEL);
lvb = kzalloc(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;
@ -448,7 +447,8 @@ static void unhold_null_lock(struct gdlm_lock *lp)
{
struct gdlm_lock *lpn = lp->hold_null;
GDLM_ASSERT(lpn,);
gdlm_assert(lpn, "%x,%llx",
lp->lockname.ln_type, lp->lockname.ln_number);
lpn->lksb.sb_lvbptr = NULL;
lpn->lvb = NULL;
set_bit(LFL_UNLOCK_DELETE, &lpn->flags);

191
fs/gfs2/locking/dlm/lock_dlm.h Normal file
View File

@ -0,0 +1,191 @@
/*
* 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.
*/
#ifndef LOCK_DLM_DOT_H
#define LOCK_DLM_DOT_H
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/list.h>
#include <linux/socket.h>
#include <linux/delay.h>
#include <linux/kthread.h>
#include <linux/kobject.h>
#include <linux/fcntl.h>
#include <linux/wait.h>
#include <net/sock.h>
#include <linux/dlm.h>
#include "../../lm_interface.h"
/*
* Internally, we prefix things with gdlm_ and GDLM_ (for gfs-dlm) since a
* prefix of lock_dlm_ gets awkward. Externally, GFS refers to this module
* as "lock_dlm".
*/
#define GDLM_STRNAME_BYTES 24
#define GDLM_LVB_SIZE 32
#define GDLM_DROP_COUNT 50000
#define GDLM_DROP_PERIOD 60
#define GDLM_NAME_LEN 128
/* GFS uses 12 bytes to identify a resource (32 bit type + 64 bit number).
We sprintf these numbers into a 24 byte string of hex values to make them
human-readable (to make debugging simpler.) */
struct gdlm_strname {
unsigned char name[GDLM_STRNAME_BYTES];
unsigned short namelen;
};
enum {
DFL_BLOCK_LOCKS = 0,
DFL_SPECTATOR = 1,
DFL_WITHDRAW = 2,
};
struct gdlm_ls {
uint32_t id;
int jid;
int first;
int first_done;
unsigned long flags;
struct kobject kobj;
char clustername[GDLM_NAME_LEN];
char fsname[GDLM_NAME_LEN];
int fsflags;
dlm_lockspace_t *dlm_lockspace;
lm_callback_t fscb;
lm_fsdata_t *fsdata;
int recover_jid;
int recover_jid_done;
spinlock_t async_lock;
struct list_head complete;
struct list_head blocking;
struct list_head delayed;
struct list_head submit;
struct list_head all_locks;
uint32_t all_locks_count;
wait_queue_head_t wait_control;
struct task_struct *thread1;
struct task_struct *thread2;
wait_queue_head_t thread_wait;
unsigned long drop_time;
int drop_locks_count;
int drop_locks_period;
};
enum {
LFL_NOBLOCK = 0,
LFL_NOCACHE = 1,
LFL_DLM_UNLOCK = 2,
LFL_DLM_CANCEL = 3,
LFL_SYNC_LVB = 4,
LFL_FORCE_PROMOTE = 5,
LFL_REREQUEST = 6,
LFL_ACTIVE = 7,
LFL_INLOCK = 8,
LFL_CANCEL = 9,
LFL_NOBAST = 10,
LFL_HEADQUE = 11,
LFL_UNLOCK_DELETE = 12,
};
struct gdlm_lock {
struct gdlm_ls *ls;
struct lm_lockname lockname;
char *lvb;
struct dlm_lksb lksb;
int16_t cur;
int16_t req;
int16_t prev_req;
uint32_t lkf; /* dlm flags DLM_LKF_ */
unsigned long flags; /* lock_dlm flags LFL_ */
int bast_mode; /* protected by async_lock */
struct completion ast_wait;
struct list_head clist; /* complete */
struct list_head blist; /* blocking */
struct list_head delay_list; /* delayed */
struct list_head all_list; /* all locks for the fs */
struct gdlm_lock *hold_null; /* NL lock for hold_lvb */
};
#define gdlm_assert(assertion, fmt, args...) \
do { \
if (unlikely(!(assertion))) { \
printk(KERN_EMERG "lock_dlm: fatal assertion failed \"%s\"\n" \
"lock_dlm: " fmt "\n", \
#assertion, ##args); \
BUG(); \
} \
} while (0)
#define log_print(lev, fmt, arg...) printk(lev "lock_dlm: " fmt "\n" , ## arg)
#define log_info(fmt, arg...) log_print(KERN_INFO , fmt , ## arg)
#define log_error(fmt, arg...) log_print(KERN_ERR , fmt , ## arg)
#ifdef LOCK_DLM_LOG_DEBUG
#define log_debug(fmt, arg...) log_print(KERN_DEBUG , fmt , ## arg)
#else
#define log_debug(fmt, arg...)
#endif
/* sysfs.c */
int gdlm_sysfs_init(void);
void gdlm_sysfs_exit(void);
int gdlm_kobject_setup(struct gdlm_ls *, struct kobject *);
void gdlm_kobject_release(struct gdlm_ls *);
/* thread.c */
int gdlm_init_threads(struct gdlm_ls *);
void gdlm_release_threads(struct gdlm_ls *);
/* lock.c */
int16_t gdlm_make_lmstate(int16_t);
void gdlm_queue_delayed(struct gdlm_lock *);
void gdlm_submit_delayed(struct gdlm_ls *);
int gdlm_release_all_locks(struct gdlm_ls *);
int gdlm_create_lp(struct gdlm_ls *, struct lm_lockname *, struct gdlm_lock **);
void gdlm_delete_lp(struct gdlm_lock *);
int gdlm_add_lvb(struct gdlm_lock *);
void gdlm_del_lvb(struct gdlm_lock *);
unsigned int gdlm_do_lock(struct gdlm_lock *, struct dlm_range *);
unsigned int gdlm_do_unlock(struct gdlm_lock *);
int gdlm_get_lock(lm_lockspace_t *, struct lm_lockname *, lm_lock_t **);
void gdlm_put_lock(lm_lock_t *);
unsigned int gdlm_lock(lm_lock_t *, unsigned int, unsigned int, unsigned int);
unsigned int gdlm_unlock(lm_lock_t *, unsigned int);
void gdlm_cancel(lm_lock_t *);
int gdlm_hold_lvb(lm_lock_t *, char **);
void gdlm_unhold_lvb(lm_lock_t *, char *);
void gdlm_sync_lvb(lm_lock_t *, char *);
/* plock.c */
int gdlm_plock_init(void);
void gdlm_plock_exit(void);
int gdlm_plock(lm_lockspace_t *, struct lm_lockname *, struct file *, int,
struct file_lock *);
int gdlm_plock_get(lm_lockspace_t *, struct lm_lockname *, struct file *,
struct file_lock *);
int gdlm_punlock(lm_lockspace_t *, struct lm_lockname *, struct file *,
struct file_lock *);
#endif

34
fs/gfs2/locking/dlm/main.c
View File

@ -1,15 +1,11 @@
/******************************************************************************
*******************************************************************************
**
** 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.
**
*******************************************************************************
******************************************************************************/
/*
* 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>
@ -24,7 +20,7 @@ int __init init_lock_dlm(void)
{
int error;
error = lm_register_proto(&gdlm_ops);
error = gfs_register_lockproto(&gdlm_ops);
if (error) {
printk("lock_dlm: can't register protocol: %d\n", error);
return error;
@ -32,7 +28,14 @@ int __init init_lock_dlm(void)
error = gdlm_sysfs_init();
if (error) {
lm_unregister_proto(&gdlm_ops);
gfs_unregister_lockproto(&gdlm_ops);
return error;
}
error = gdlm_plock_init();
if (error) {
gdlm_sysfs_exit();
gfs_unregister_lockproto(&gdlm_ops);
return error;
}
@ -45,8 +48,9 @@ int __init init_lock_dlm(void)
void __exit exit_lock_dlm(void)
{
lm_unregister_proto(&gdlm_ops);
gdlm_plock_exit();
gdlm_sysfs_exit();
gfs_unregister_lockproto(&gdlm_ops);
}
module_init(init_lock_dlm);

189
fs/gfs2/locking/dlm/mount.c
View File

@ -1,15 +1,11 @@
/******************************************************************************
*******************************************************************************
**
** 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.
**
*******************************************************************************
******************************************************************************/
/*
* 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"
@ -24,27 +20,21 @@ static struct gdlm_ls *init_gdlm(lm_callback_t cb, lm_fsdata_t *fsdata,
struct gdlm_ls *ls;
char buf[256], *p;
ls = kmalloc(sizeof(struct gdlm_ls), GFP_KERNEL);
ls = kzalloc(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;
@ -57,23 +47,75 @@ static struct gdlm_ls *init_gdlm(lm_callback_t cb, lm_fsdata_t *fsdata,
p = strstr(buf, ":");
if (!p) {
printk("lock_dlm: invalid table_name \"%s\"\n", table_name);
log_info("invalid table_name \"%s\"", table_name);
kfree(ls);
return NULL;
}
*p = '\0';
p++;
strncpy(ls->clustername, buf, 128);
strncpy(ls->fsname, p, 128);
strncpy(ls->clustername, buf, GDLM_NAME_LEN);
strncpy(ls->fsname, p, GDLM_NAME_LEN);
return ls;
}
static int make_args(struct gdlm_ls *ls, char *data_arg)
{
char data[256];
char *options, *x, *y;
int error = 0;
memset(data, 0, 256);
strncpy(data, data_arg, 255);
for (options = data; (x = strsep(&options, ":")); ) {
if (!*x)
continue;
y = strchr(x, '=');
if (y)
*y++ = 0;
if (!strcmp(x, "jid")) {
if (!y) {
log_error("need argument to jid");
error = -EINVAL;
break;
}
sscanf(y, "%u", &ls->jid);
} else if (!strcmp(x, "first")) {
if (!y) {
log_error("need argument to first");
error = -EINVAL;
break;
}
sscanf(y, "%u", &ls->first);
} else if (!strcmp(x, "id")) {
if (!y) {
log_error("need argument to id");
error = -EINVAL;
break;
}
sscanf(y, "%u", &ls->id);
} else {
log_error("unkonwn option: %s", x);
error = -EINVAL;
break;
}
}
return error;
}
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 lm_lockstruct *lockstruct,
struct kobject *fskobj)
{
struct gdlm_ls *ls;
int error = -ENOMEM;
@ -92,30 +134,18 @@ static int gdlm_mount(char *table_name, char *host_data,
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);
log_error("dlm_new_lockspace error %d", error);
goto out_thread;
}
error = gdlm_kobject_setup(ls);
error = gdlm_kobject_setup(ls, fskobj);
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));
error = make_args(ls, host_data);
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;
@ -143,22 +173,19 @@ static void gdlm_unmount(lm_lockspace_t *lockspace)
log_debug("unmount flags %lx", ls->flags);
if (test_bit(DFL_WITHDRAW, &ls->flags)) {
gdlm_kobject_release(ls);
/* FIXME: serialize unmount and withdraw in case they
happen at once. Also, if unmount follows withdraw,
wait for withdraw to finish. */
if (test_bit(DFL_WITHDRAW, &ls->flags))
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);
log_info("gdlm_unmount: %d stray locks freed", rv);
out:
kfree(ls);
}
@ -167,7 +194,7 @@ 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;
ls->recover_jid_done = jid;
kobject_uevent(&ls->kobj, KOBJ_CHANGE, NULL);
}
@ -178,12 +205,14 @@ static void gdlm_others_may_mount(lm_lockspace_t *lockspace)
kobject_uevent(&ls->kobj, KOBJ_CHANGE, NULL);
}
/* Userspace gets the offline uevent, blocks new gfs locks on
other mounters, and lets us know (sets WITHDRAW flag). Then,
userspace leaves the mount group while we leave the lockspace. */
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,
@ -192,49 +221,27 @@ static void gdlm_withdraw(lm_lockspace_t *lockspace)
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;
gdlm_kobject_release(ls);
}
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,
.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,
};

297
fs/gfs2/locking/dlm/plock.c Normal file
View File

@ -0,0 +1,297 @@
/*
* Copyright (C) 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/miscdevice.h>
#include <linux/lock_dlm_plock.h>
#include "lock_dlm.h"
static spinlock_t ops_lock;
static struct list_head send_list;
static struct list_head recv_list;
static wait_queue_head_t send_wq;
static wait_queue_head_t recv_wq;
struct plock_op {
struct list_head list;
int done;
struct gdlm_plock_info info;
};
static inline void set_version(struct gdlm_plock_info *info)
{
info->version[0] = GDLM_PLOCK_VERSION_MAJOR;
info->version[1] = GDLM_PLOCK_VERSION_MINOR;
info->version[2] = GDLM_PLOCK_VERSION_PATCH;
}
static int check_version(struct gdlm_plock_info *info)
{
if ((GDLM_PLOCK_VERSION_MAJOR != info->version[0]) ||
(GDLM_PLOCK_VERSION_MINOR < info->version[1])) {
log_error("plock device version mismatch: "
"kernel (%u.%u.%u), user (%u.%u.%u)",
GDLM_PLOCK_VERSION_MAJOR,
GDLM_PLOCK_VERSION_MINOR,
GDLM_PLOCK_VERSION_PATCH,
info->version[0],
info->version[1],
info->version[2]);
return -EINVAL;
}
return 0;
}
static void send_op(struct plock_op *op)
{
set_version(&op->info);
INIT_LIST_HEAD(&op->list);
spin_lock(&ops_lock);
list_add_tail(&op->list, &send_list);
spin_unlock(&ops_lock);
wake_up(&send_wq);
}
int gdlm_plock(lm_lockspace_t *lockspace, struct lm_lockname *name,
struct file *file, int cmd, struct file_lock *fl)
{
struct gdlm_ls *ls = (struct gdlm_ls *) lockspace;
struct plock_op *op;
int rv;
op = kzalloc(sizeof(*op), GFP_KERNEL);
if (!op)
return -ENOMEM;
op->info.optype = GDLM_PLOCK_OP_LOCK;
op->info.pid = (uint32_t) fl->fl_owner;
op->info.ex = (fl->fl_type == F_WRLCK);
op->info.wait = IS_SETLKW(cmd);
op->info.fsid = ls->id;
op->info.number = name->ln_number;
op->info.start = fl->fl_start;
op->info.end = fl->fl_end;
send_op(op);
wait_event(recv_wq, (op->done != 0));
spin_lock(&ops_lock);
if (!list_empty(&op->list)) {
printk("plock op on list\n");
list_del(&op->list);
}
spin_unlock(&ops_lock);
rv = op->info.rv;
if (!rv) {
if (posix_lock_file_wait(file, fl) < 0)
log_error("gdlm_plock: vfs lock error %x,%llx",
name->ln_type, name->ln_number);
}
kfree(op);
return rv;
}
int gdlm_punlock(lm_lockspace_t *lockspace, struct lm_lockname *name,
struct file *file, struct file_lock *fl)
{
struct gdlm_ls *ls = (struct gdlm_ls *) lockspace;
struct plock_op *op;
int rv;
op = kzalloc(sizeof(*op), GFP_KERNEL);
if (!op)
return -ENOMEM;
if (posix_lock_file_wait(file, fl) < 0)
log_error("gdlm_punlock: vfs unlock error %x,%llx",
name->ln_type, name->ln_number);
op->info.optype = GDLM_PLOCK_OP_UNLOCK;
op->info.pid = (uint32_t) fl->fl_owner;
op->info.fsid = ls->id;
op->info.number = name->ln_number;
op->info.start = fl->fl_start;
op->info.end = fl->fl_end;
send_op(op);
wait_event(recv_wq, (op->done != 0));
spin_lock(&ops_lock);
if (!list_empty(&op->list)) {
printk("punlock op on list\n");
list_del(&op->list);
}
spin_unlock(&ops_lock);
rv = op->info.rv;
kfree(op);
return rv;
}
int gdlm_plock_get(lm_lockspace_t *lockspace, struct lm_lockname *name,
struct file *file, struct file_lock *fl)
{
struct gdlm_ls *ls = (struct gdlm_ls *) lockspace;
struct plock_op *op;
int rv;
op = kzalloc(sizeof(*op), GFP_KERNEL);
if (!op)
return -ENOMEM;
op->info.optype = GDLM_PLOCK_OP_GET;
op->info.pid = (uint32_t) fl->fl_owner;
op->info.ex = (fl->fl_type == F_WRLCK);
op->info.fsid = ls->id;
op->info.number = name->ln_number;
op->info.start = fl->fl_start;
op->info.end = fl->fl_end;
send_op(op);
wait_event(recv_wq, (op->done != 0));
spin_lock(&ops_lock);
if (!list_empty(&op->list)) {
printk("plock_get op on list\n");
list_del(&op->list);
}
spin_unlock(&ops_lock);
rv = op->info.rv;
if (rv == 0)
fl->fl_type = F_UNLCK;
else if (rv > 0) {
fl->fl_type = (op->info.ex) ? F_WRLCK : F_RDLCK;
fl->fl_pid = op->info.pid;
fl->fl_start = op->info.start;
fl->fl_end = op->info.end;
}
kfree(op);
return rv;
}
/* a read copies out one plock request from the send list */
static ssize_t dev_read(struct file *file, char __user *u, size_t count,
loff_t *ppos)
{
struct gdlm_plock_info info;
struct plock_op *op = NULL;
if (count < sizeof(info))
return -EINVAL;
spin_lock(&ops_lock);
if (!list_empty(&send_list)) {
op = list_entry(send_list.next, struct plock_op, list);
list_move(&op->list, &recv_list);
memcpy(&info, &op->info, sizeof(info));
}
spin_unlock(&ops_lock);
if (!op)
return -EAGAIN;
if (copy_to_user(u, &info, sizeof(info)))
return -EFAULT;
return sizeof(info);
}
/* a write copies in one plock result that should match a plock_op
on the recv list */
static ssize_t dev_write(struct file *file, const char __user *u, size_t count,
loff_t *ppos)
{
struct gdlm_plock_info info;
struct plock_op *op;
int found = 0;
if (count != sizeof(info))
return -EINVAL;
if (copy_from_user(&info, u, sizeof(info)))
return -EFAULT;
if (check_version(&info))
return -EINVAL;
spin_lock(&ops_lock);
list_for_each_entry(op, &recv_list, list) {
if (op->info.fsid == info.fsid &&
op->info.number == info.number) {
list_del_init(&op->list);
found = 1;
op->done = 1;
memcpy(&op->info, &info, sizeof(info));
break;
}
}
spin_unlock(&ops_lock);
if (found)
wake_up(&recv_wq);
else
printk("gdlm dev_write no op %x %llx\n", info.fsid,
info.number);
return count;
}
static unsigned int dev_poll(struct file *file, poll_table *wait)
{
poll_wait(file, &send_wq, wait);
spin_lock(&ops_lock);
if (!list_empty(&send_list)) {
spin_unlock(&ops_lock);
return POLLIN | POLLRDNORM;
}
spin_unlock(&ops_lock);
return 0;
}
static struct file_operations dev_fops = {
.read = dev_read,
.write = dev_write,
.poll = dev_poll,
.owner = THIS_MODULE
};
static struct miscdevice plock_dev_misc = {
.minor = MISC_DYNAMIC_MINOR,
.name = GDLM_PLOCK_MISC_NAME,
.fops = &dev_fops
};
int gdlm_plock_init(void)
{
int rv;
spin_lock_init(&ops_lock);
INIT_LIST_HEAD(&send_list);
INIT_LIST_HEAD(&recv_list);
init_waitqueue_head(&send_wq);
init_waitqueue_head(&recv_wq);
rv = misc_register(&plock_dev_misc);
if (rv)
printk("gdlm_plock_init: misc_register failed %d", rv);
return rv;
}
void gdlm_plock_exit(void)
{
if (misc_deregister(&plock_dev_misc) < 0)
printk("gdlm_plock_exit: misc_deregister failed");
}

203
fs/gfs2/locking/dlm/sysfs.c
View File

@ -1,21 +1,25 @@
/******************************************************************************
*******************************************************************************
**
** Copyright (C) 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.
**
*******************************************************************************
******************************************************************************/
/*
* 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/ctype.h>
#include <linux/stat.h>
#include "lock_dlm.h"
static ssize_t gdlm_block_show(struct gdlm_ls *ls, char *buf)
extern struct lm_lockops gdlm_ops;
static ssize_t proto_name_show(struct gdlm_ls *ls, char *buf)
{
return sprintf(buf, "%s\n", gdlm_ops.lm_proto_name);
}
static ssize_t block_show(struct gdlm_ls *ls, char *buf)
{
ssize_t ret;
int val = 0;
@ -26,7 +30,7 @@ static ssize_t gdlm_block_show(struct gdlm_ls *ls, char *buf)
return ret;
}
static ssize_t gdlm_block_store(struct gdlm_ls *ls, const char *buf, size_t len)
static ssize_t block_store(struct gdlm_ls *ls, const char *buf, size_t len)
{
ssize_t ret = len;
int val;
@ -43,43 +47,7 @@ static ssize_t gdlm_block_store(struct gdlm_ls *ls, const char *buf, size_t len)
return ret;
}
static ssize_t gdlm_mounted_show(struct gdlm_ls *ls, char *buf)
{
ssize_t ret;
int val = -2;
if (test_bit(DFL_TERMINATE, &ls->flags))
val = -1;
else if (test_bit(DFL_LEAVE_DONE, &ls->flags))
val = 0;
else if (test_bit(DFL_JOIN_DONE, &ls->flags))
val = 1;
ret = sprintf(buf, "%d\n", val);
return ret;
}
static ssize_t gdlm_mounted_store(struct gdlm_ls *ls, const char *buf, size_t len)
{
ssize_t ret = len;
int val;
val = simple_strtol(buf, NULL, 0);
if (val == 1)
set_bit(DFL_JOIN_DONE, &ls->flags);
else if (val == 0)
set_bit(DFL_LEAVE_DONE, &ls->flags);
else if (val == -1) {
set_bit(DFL_TERMINATE, &ls->flags);
set_bit(DFL_JOIN_DONE, &ls->flags);
set_bit(DFL_LEAVE_DONE, &ls->flags);
} else
ret = -EINVAL;
wake_up(&ls->wait_control);
return ret;
}
static ssize_t gdlm_withdraw_show(struct gdlm_ls *ls, char *buf)
static ssize_t withdraw_show(struct gdlm_ls *ls, char *buf)
{
ssize_t ret;
int val = 0;
@ -90,7 +58,7 @@ static ssize_t gdlm_withdraw_show(struct gdlm_ls *ls, char *buf)
return ret;
}
static ssize_t gdlm_withdraw_store(struct gdlm_ls *ls, const char *buf, size_t len)
static ssize_t withdraw_store(struct gdlm_ls *ls, const char *buf, size_t len)
{
ssize_t ret = len;
int val;
@ -105,67 +73,41 @@ static ssize_t gdlm_withdraw_store(struct gdlm_ls *ls, const char *buf, size_t l
return ret;
}
static ssize_t gdlm_jid_show(struct gdlm_ls *ls, char *buf)
static ssize_t id_show(struct gdlm_ls *ls, char *buf)
{
return sprintf(buf, "%u\n", ls->jid);
return sprintf(buf, "%u\n", ls->id);
}
static ssize_t gdlm_jid_store(struct gdlm_ls *ls, const char *buf, size_t len)
static ssize_t jid_show(struct gdlm_ls *ls, char *buf)
{
ls->jid = simple_strtol(buf, NULL, 0);
return len;
return sprintf(buf, "%d\n", ls->jid);
}
static ssize_t gdlm_first_show(struct gdlm_ls *ls, char *buf)
static ssize_t first_show(struct gdlm_ls *ls, char *buf)
{
return sprintf(buf, "%u\n", ls->first);
return sprintf(buf, "%d\n", ls->first);
}
static ssize_t gdlm_first_store(struct gdlm_ls *ls, const char *buf, size_t len)
{
ls->first = simple_strtol(buf, NULL, 0);
return len;
}
static ssize_t gdlm_first_done_show(struct gdlm_ls *ls, char *buf)
static ssize_t first_done_show(struct gdlm_ls *ls, char *buf)
{
return sprintf(buf, "%d\n", ls->first_done);
}
static ssize_t gdlm_recover_show(struct gdlm_ls *ls, char *buf)
static ssize_t recover_show(struct gdlm_ls *ls, char *buf)
{
return sprintf(buf, "%u\n", ls->recover_jid);
return sprintf(buf, "%d\n", ls->recover_jid);
}
static ssize_t gdlm_recover_store(struct gdlm_ls *ls, const char *buf, size_t len)
static ssize_t recover_store(struct gdlm_ls *ls, const char *buf, size_t len)
{
ls->recover_jid = simple_strtol(buf, NULL, 0);
ls->fscb(ls->fsdata, LM_CB_NEED_RECOVERY, &ls->recover_jid);
return len;
}
static ssize_t gdlm_recover_done_show(struct gdlm_ls *ls, char *buf)
static ssize_t recover_done_show(struct gdlm_ls *ls, char *buf)
{
ssize_t ret;
ret = sprintf(buf, "%d\n", ls->recover_done);
return ret;
}
static ssize_t gdlm_cluster_show(struct gdlm_ls *ls, char *buf)
{
ssize_t ret;
ret = sprintf(buf, "%s\n", ls->clustername);
return ret;
}
static ssize_t gdlm_options_show(struct gdlm_ls *ls, char *buf)
{
ssize_t ret = 0;
if (ls->fsflags & LM_MFLAG_SPECTATOR)
ret += sprintf(buf, "spectator ");
return ret;
return sprintf(buf, "%d\n", ls->recover_jid_done);
}
struct gdlm_attr {
@ -174,73 +116,29 @@ struct gdlm_attr {
ssize_t (*store)(struct gdlm_ls *, const char *, size_t);
};
static struct gdlm_attr gdlm_attr_block = {
.attr = {.name = "block", .mode = S_IRUGO | S_IWUSR},
.show = gdlm_block_show,
.store = gdlm_block_store
};
#define GDLM_ATTR(_name,_mode,_show,_store) \
static struct gdlm_attr gdlm_attr_##_name = __ATTR(_name,_mode,_show,_store)
static struct gdlm_attr gdlm_attr_mounted = {
.attr = {.name = "mounted", .mode = S_IRUGO | S_IWUSR},
.show = gdlm_mounted_show,
.store = gdlm_mounted_store
};
static struct gdlm_attr gdlm_attr_withdraw = {
.attr = {.name = "withdraw", .mode = S_IRUGO | S_IWUSR},
.show = gdlm_withdraw_show,
.store = gdlm_withdraw_store
};
static struct gdlm_attr gdlm_attr_jid = {
.attr = {.name = "jid", .mode = S_IRUGO | S_IWUSR},
.show = gdlm_jid_show,
.store = gdlm_jid_store
};
static struct gdlm_attr gdlm_attr_first = {
.attr = {.name = "first", .mode = S_IRUGO | S_IWUSR},
.show = gdlm_first_show,
.store = gdlm_first_store
};
static struct gdlm_attr gdlm_attr_first_done = {
.attr = {.name = "first_done", .mode = S_IRUGO},
.show = gdlm_first_done_show,
};
static struct gdlm_attr gdlm_attr_recover = {
.attr = {.name = "recover", .mode = S_IRUGO | S_IWUSR},
.show = gdlm_recover_show,
.store = gdlm_recover_store
};
static struct gdlm_attr gdlm_attr_recover_done = {
.attr = {.name = "recover_done", .mode = S_IRUGO | S_IWUSR},
.show = gdlm_recover_done_show,
};
static struct gdlm_attr gdlm_attr_cluster = {
.attr = {.name = "cluster", .mode = S_IRUGO | S_IWUSR},
.show = gdlm_cluster_show,
};
static struct gdlm_attr gdlm_attr_options = {
.attr = {.name = "options", .mode = S_IRUGO | S_IWUSR},
.show = gdlm_options_show,
};
GDLM_ATTR(proto_name, 0444, proto_name_show, NULL);
GDLM_ATTR(block, 0644, block_show, block_store);
GDLM_ATTR(withdraw, 0644, withdraw_show, withdraw_store);
GDLM_ATTR(id, 0444, id_show, NULL);
GDLM_ATTR(jid, 0444, jid_show, NULL);
GDLM_ATTR(first, 0444, first_show, NULL);
GDLM_ATTR(first_done, 0444, first_done_show, NULL);
GDLM_ATTR(recover, 0644, recover_show, recover_store);
GDLM_ATTR(recover_done, 0444, recover_done_show, NULL);
static struct attribute *gdlm_attrs[] = {
&gdlm_attr_proto_name.attr,
&gdlm_attr_block.attr,
&gdlm_attr_mounted.attr,
&gdlm_attr_withdraw.attr,
&gdlm_attr_id.attr,
&gdlm_attr_jid.attr,
&gdlm_attr_first.attr,
&gdlm_attr_first_done.attr,
&gdlm_attr_recover.attr,
&gdlm_attr_recover_done.attr,
&gdlm_attr_cluster.attr,
&gdlm_attr_options.attr,
NULL,
};
@ -276,20 +174,25 @@ static struct kset gdlm_kset = {
.ktype = &gdlm_ktype,
};
int gdlm_kobject_setup(struct gdlm_ls *ls)
int gdlm_kobject_setup(struct gdlm_ls *ls, struct kobject *fskobj)
{
int error;
error = kobject_set_name(&ls->kobj, "%s", ls->fsname);
if (error)
error = kobject_set_name(&ls->kobj, "%s", "lock_module");
if (error) {
log_error("can't set kobj name %d", error);
return error;
}
ls->kobj.kset = &gdlm_kset;
ls->kobj.ktype = &gdlm_ktype;
ls->kobj.parent = fskobj;
error = kobject_register(&ls->kobj);
if (error)
log_error("can't register kobj %d", error);
return 0;
return error;
}
void gdlm_kobject_release(struct gdlm_ls *ls)

65
fs/gfs2/locking/dlm/thread.c
View File

@ -1,15 +1,11 @@
/******************************************************************************
*******************************************************************************
**
** 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.
**
*******************************************************************************
******************************************************************************/
/*
* 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"
@ -26,15 +22,10 @@ static void queue_submit(struct gdlm_lock *lp)
wake_up(&ls->thread_wait);
}
static void process_submit(struct gdlm_lock *lp)
{
gdlm_do_lock(lp, NULL);
}
static void process_blocking(struct gdlm_lock *lp, int bast_mode)
{
struct gdlm_ls *ls = lp->ls;
unsigned int cb;
unsigned int cb = 0;
switch (gdlm_make_lmstate(bast_mode)) {
case LM_ST_EXCLUSIVE:
@ -47,7 +38,7 @@ static void process_blocking(struct gdlm_lock *lp, int bast_mode)
cb = LM_CB_NEED_S;
break;
default:
GDLM_ASSERT(0, printk("unknown bast mode %u\n",lp->bast_mode););
gdlm_assert(0, "unknown bast mode %u", lp->bast_mode);
}
ls->fscb(ls->fsdata, cb, &lp->lockname);
@ -62,9 +53,9 @@ static void process_complete(struct gdlm_lock *lp)
memset(&acb, 0, sizeof(acb));
if (lp->lksb.sb_status == -DLM_ECANCEL) {
log_all("complete dlm cancel %x,%"PRIx64" flags %lx",
lp->lockname.ln_type, lp->lockname.ln_number,
lp->flags);
log_info("complete dlm cancel %x,%llx flags %lx",
lp->lockname.ln_type, lp->lockname.ln_number,
lp->flags);
lp->req = lp->cur;
acb.lc_ret |= LM_OUT_CANCELED;
@ -75,9 +66,9 @@ static void process_complete(struct gdlm_lock *lp)
if (test_and_clear_bit(LFL_DLM_UNLOCK, &lp->flags)) {
if (lp->lksb.sb_status != -DLM_EUNLOCK) {
log_all("unlock sb_status %d %x,%"PRIx64" flags %lx",
lp->lksb.sb_status, lp->lockname.ln_type,
lp->lockname.ln_number, lp->flags);
log_info("unlock sb_status %d %x,%llx flags %lx",
lp->lksb.sb_status, lp->lockname.ln_type,
lp->lockname.ln_number, lp->flags);
return;
}
@ -108,8 +99,8 @@ static void process_complete(struct gdlm_lock *lp)
*/
if (test_and_clear_bit(LFL_CANCEL, &lp->flags)) {
log_all("complete internal cancel %x,%"PRIx64"",
lp->lockname.ln_type, lp->lockname.ln_number);
log_info("complete internal cancel %x,%llx",
lp->lockname.ln_type, lp->lockname.ln_number);
lp->req = lp->cur;
acb.lc_ret |= LM_OUT_CANCELED;
goto out;
@ -130,9 +121,9 @@ static void process_complete(struct gdlm_lock *lp)
}
/* this could only happen with cancels I think */
log_all("ast sb_status %d %x,%"PRIx64" flags %lx",
lp->lksb.sb_status, lp->lockname.ln_type,
lp->lockname.ln_number, lp->flags);
log_info("ast sb_status %d %x,%llx flags %lx",
lp->lksb.sb_status, lp->lockname.ln_type,
lp->lockname.ln_number, lp->flags);
return;
}
@ -152,8 +143,10 @@ static void process_complete(struct gdlm_lock *lp)
*/
if (test_and_clear_bit(LFL_REREQUEST, &lp->flags)) {
GDLM_ASSERT(lp->req == DLM_LOCK_NL,);
GDLM_ASSERT(lp->prev_req > DLM_LOCK_NL,);
gdlm_assert(lp->req == DLM_LOCK_NL, "%x,%llx",
lp->lockname.ln_type, lp->lockname.ln_number);
gdlm_assert(lp->prev_req > DLM_LOCK_NL, "%x,%llx",
lp->lockname.ln_type, lp->lockname.ln_number);
lp->cur = DLM_LOCK_NL;
lp->req = lp->prev_req;
@ -189,7 +182,7 @@ static void process_complete(struct gdlm_lock *lp)
lp->lkf |= DLM_LKF_CONVERT;
lp->lkf &= ~DLM_LKF_CONVDEADLK;
log_debug("rereq %x,%"PRIx64" id %x %d,%d",
log_debug("rereq %x,%llx id %x %d,%d",
lp->lockname.ln_type, lp->lockname.ln_number,
lp->lksb.sb_lkid, lp->cur, lp->req);
@ -315,7 +308,7 @@ static int gdlm_thread(void *data)
process_blocking(lp, blocking);
else if (submit)
process_submit(lp);
gdlm_do_lock(lp, NULL);
if (drop)
ls->fscb(ls->fsdata, LM_CB_DROPLOCKS, NULL);
@ -334,7 +327,7 @@ int gdlm_init_threads(struct gdlm_ls *ls)
p = kthread_run(gdlm_thread, ls, "lock_dlm1");
error = IS_ERR(p);
if (error) {
log_all("can't start lock_dlm1 thread %d", error);
log_error("can't start lock_dlm1 thread %d", error);
return error;
}
ls->thread1 = p;
@ -342,7 +335,7 @@ int gdlm_init_threads(struct gdlm_ls *ls)
p = kthread_run(gdlm_thread, ls, "lock_dlm2");
error = IS_ERR(p);
if (error) {
log_all("can't start lock_dlm2 thread %d", error);
log_error("can't start lock_dlm2 thread %d", error);
kthread_stop(ls->thread1);
return error;
}

44
fs/gfs2/locking/nolock/lock_nolock.mod.c
View File

@ -1,44 +0,0 @@
#include <linux/module.h>
#include <linux/vermagic.h>
#include <linux/compiler.h>
MODULE_INFO(vermagic, VERMAGIC_STRING);
#undef unix
struct module __this_module
__attribute__((section(".gnu.linkonce.this_module"))) = {
.name = __stringify(KBUILD_MODNAME),
.init = init_module,
#ifdef CONFIG_MODULE_UNLOAD
.exit = cleanup_module,
#endif
};
static const struct modversion_info ____versions[]
__attribute_used__
__attribute__((section("__versions"))) = {
{ 0x316962fc, "struct_module" },
{ 0x5a34a45c, "__kmalloc" },
{ 0x724beef2, "malloc_sizes" },
{ 0x3fa03a97, "memset" },
{ 0xc16fe12d, "__memcpy" },
{ 0xdd132261, "printk" },
{ 0x859204af, "sscanf" },
{ 0x3656bf5a, "lock_kernel" },
{ 0x1e6d26a8, "strstr" },
{ 0x41ede9df, "lm_register_proto" },
{ 0xb1f975aa, "unlock_kernel" },
{ 0x87b0b01f, "posix_lock_file_wait" },
{ 0x75f29cfd, "kmem_cache_alloc" },
{ 0x69384280, "lm_unregister_proto" },
{ 0x37a0cba, "kfree" },
{ 0x5d16bfe6, "posix_test_lock" },
};
static const char __module_depends[]
__attribute_used__
__attribute__((section(".modinfo"))) =
"depends=gfs2";
MODULE_INFO(srcversion, "123E446F965A386A0C017C4");

113
fs/gfs2/locking/nolock/main.c
View File

@ -1,15 +1,11 @@
/******************************************************************************
*******************************************************************************
**
** 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.
**
*******************************************************************************
******************************************************************************/
/*
* 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/module.h>
#include <linux/slab.h>
@ -27,23 +23,11 @@ struct nolock_lockspace {
struct lm_lockops nolock_ops;
/**
* nolock_mount - mount a nolock lockspace
* @table_name: the name of the space to mount
* @host_data: host specific data
* @cb: the callback
* @fsdata:
* @min_lvb_size:
* @flags:
* @lockstruct: the structure of crap to fill in
*
* Returns: 0 on success, -EXXX on failure
*/
static int nolock_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 lm_lockstruct *lockstruct,
struct kobject *fskobj)
{
char *c;
unsigned int jid;
@ -77,34 +61,16 @@ static int nolock_mount(char *table_name, char *host_data,
return 0;
}
/**
* nolock_others_may_mount - unmount a lock space
* @lockspace: the lockspace to unmount
*
*/
static void nolock_others_may_mount(lm_lockspace_t *lockspace)
{
}
/**
* nolock_unmount - unmount a lock space
* @lockspace: the lockspace to unmount
*
*/
static void nolock_unmount(lm_lockspace_t *lockspace)
{
struct nolock_lockspace *nl = (struct nolock_lockspace *)lockspace;
kfree(nl);
}
/**
* nolock_withdraw - withdraw from a lock space
* @lockspace: the lockspace
*
*/
static void nolock_withdraw(lm_lockspace_t *lockspace)
{
}
@ -164,12 +130,6 @@ static unsigned int nolock_unlock(lm_lock_t *lock, unsigned int cur_state)
return 0;
}
/**
* nolock_cancel - cancel a request on a lock
* @lock: the lock to cancel request for
*
*/
static void nolock_cancel(lm_lock_t *lock)
{
}
@ -219,16 +179,6 @@ static void nolock_sync_lvb(lm_lock_t *lock, char *lvb)
{
}
/**
* nolock_plock_get -
* @lockspace: the lockspace
* @name:
* @file:
* @fl:
*
* Returns: errno
*/
static int nolock_plock_get(lm_lockspace_t *lockspace, struct lm_lockname *name,
struct file *file, struct file_lock *fl)
{
@ -244,17 +194,6 @@ static int nolock_plock_get(lm_lockspace_t *lockspace, struct lm_lockname *name,
return 0;
}
/**
* nolock_plock -
* @lockspace: the lockspace
* @name:
* @file:
* @cmd:
* @fl:
*
* Returns: errno
*/
static int nolock_plock(lm_lockspace_t *lockspace, struct lm_lockname *name,
struct file *file, int cmd, struct file_lock *fl)
{
@ -265,16 +204,6 @@ static int nolock_plock(lm_lockspace_t *lockspace, struct lm_lockname *name,
return error;
}
/**
* nolock_punlock -
* @lockspace: the lockspace
* @name:
* @file:
* @fl:
*
* Returns: errno
*/
static int nolock_punlock(lm_lockspace_t *lockspace, struct lm_lockname *name,
struct file *file, struct file_lock *fl)
{
@ -285,13 +214,6 @@ static int nolock_punlock(lm_lockspace_t *lockspace, struct lm_lockname *name,
return error;
}
/**
* nolock_recovery_done - reset the expired locks for a given jid
* @lockspace: the lockspace
* @jid: the jid
*
*/
static void nolock_recovery_done(lm_lockspace_t *lockspace, unsigned int jid,
unsigned int message)
{
@ -318,17 +240,11 @@ struct lm_lockops nolock_ops = {
.lm_owner = THIS_MODULE,
};
/**
* init_nolock - Initialize the nolock module
*
* Returns: 0 on success, -EXXX on failure
*/
int __init init_nolock(void)
{
int error;
error = lm_register_proto(&nolock_ops);
error = gfs_register_lockproto(&nolock_ops);
if (error) {
printk("lock_nolock: can't register protocol: %d\n", error);
return error;
@ -338,14 +254,9 @@ int __init init_nolock(void)
return 0;
}
/**
* exit_nolock - cleanup the nolock module
*
*/
void __exit exit_nolock(void)
{
lm_unregister_proto(&nolock_ops);
gfs_unregister_lockproto(&nolock_ops);
}
module_init(init_nolock);

40
include/linux/lock_dlm_plock.h Normal file
View File

@ -0,0 +1,40 @@
/*
* Copyright (C) 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.
*/
#ifndef __LOCK_DLM_PLOCK_DOT_H__
#define __LOCK_DLM_PLOCK_DOT_H__
#define GDLM_PLOCK_MISC_NAME "lock_dlm_plock"
#define GDLM_PLOCK_VERSION_MAJOR 1
#define GDLM_PLOCK_VERSION_MINOR 0
#define GDLM_PLOCK_VERSION_PATCH 0
enum {
GDLM_PLOCK_OP_LOCK = 1,
GDLM_PLOCK_OP_UNLOCK,
GDLM_PLOCK_OP_GET,
};
struct gdlm_plock_info {
__u32 version[3];
__u8 optype;
__u8 ex;
__u8 wait;
__u8 pad;
__u32 pid;
__s32 nodeid;
__s32 rv;
__u32 fsid;
__u64 number;
__u64 start;
__u64 end;
};
#endif