![Steven Whitehouse](/assets/img/avatar_default.png)
The previous patch didn't change all the gfs_ to gfs2_ so this is the remainder. Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
192 lines
4.4 KiB
C
192 lines
4.4 KiB
C
/*
|
|
* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
|
|
* Copyright (C) 2004-2006 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/init.h>
|
|
#include <linux/string.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/wait.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/kmod.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/delay.h>
|
|
|
|
#include "lm_interface.h"
|
|
|
|
struct lmh_wrapper {
|
|
struct list_head lw_list;
|
|
struct lm_lockops *lw_ops;
|
|
};
|
|
|
|
/* List of registered low-level locking protocols. A file system selects one
|
|
of them by name at mount time, e.g. lock_nolock, lock_dlm. */
|
|
|
|
static struct list_head lmh_list;
|
|
static struct mutex lmh_lock;
|
|
|
|
/**
|
|
* gfs2_register_lockproto - Register a low-level locking protocol
|
|
* @proto: the protocol definition
|
|
*
|
|
* Returns: 0 on success, -EXXX on failure
|
|
*/
|
|
|
|
int gfs2_register_lockproto(struct lm_lockops *proto)
|
|
{
|
|
struct lmh_wrapper *lw;
|
|
|
|
mutex_lock(&lmh_lock);
|
|
|
|
list_for_each_entry(lw, &lmh_list, lw_list) {
|
|
if (!strcmp(lw->lw_ops->lm_proto_name, proto->lm_proto_name)) {
|
|
mutex_unlock(&lmh_lock);
|
|
printk(KERN_INFO "GFS2: protocol %s already exists\n",
|
|
proto->lm_proto_name);
|
|
return -EEXIST;
|
|
}
|
|
}
|
|
|
|
lw = kzalloc(sizeof(struct lmh_wrapper), GFP_KERNEL);
|
|
if (!lw) {
|
|
mutex_unlock(&lmh_lock);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
lw->lw_ops = proto;
|
|
list_add(&lw->lw_list, &lmh_list);
|
|
|
|
mutex_unlock(&lmh_lock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* gfs2_unregister_lockproto - Unregister a low-level locking protocol
|
|
* @proto: the protocol definition
|
|
*
|
|
*/
|
|
|
|
void gfs2_unregister_lockproto(struct lm_lockops *proto)
|
|
{
|
|
struct lmh_wrapper *lw;
|
|
|
|
mutex_lock(&lmh_lock);
|
|
|
|
list_for_each_entry(lw, &lmh_list, lw_list) {
|
|
if (!strcmp(lw->lw_ops->lm_proto_name, proto->lm_proto_name)) {
|
|
list_del(&lw->lw_list);
|
|
mutex_unlock(&lmh_lock);
|
|
kfree(lw);
|
|
return;
|
|
}
|
|
}
|
|
|
|
mutex_unlock(&lmh_lock);
|
|
|
|
printk(KERN_WARNING "GFS2: can't unregister lock protocol %s\n",
|
|
proto->lm_proto_name);
|
|
}
|
|
|
|
/**
|
|
* gfs2_mount_lockproto - Mount a lock protocol
|
|
* @proto_name - the name of the protocol
|
|
* @table_name - the name of the lock space
|
|
* @host_data - data specific to this host
|
|
* @cb - the callback to the code using the lock module
|
|
* @fsdata - data to pass back with the callback
|
|
* @min_lvb_size - the mininum LVB size that the caller can deal with
|
|
* @flags - LM_MFLAG_*
|
|
* @lockstruct - a structure returned describing the mount
|
|
*
|
|
* Returns: 0 on success, -EXXX on failure
|
|
*/
|
|
|
|
int gfs2_mount_lockproto(char *proto_name, 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 kobject *fskobj)
|
|
{
|
|
struct lmh_wrapper *lw = NULL;
|
|
int try = 0;
|
|
int error, found;
|
|
|
|
retry:
|
|
mutex_lock(&lmh_lock);
|
|
|
|
found = 0;
|
|
list_for_each_entry(lw, &lmh_list, lw_list) {
|
|
if (!strcmp(lw->lw_ops->lm_proto_name, proto_name)) {
|
|
found = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!found) {
|
|
if (!try && capable(CAP_SYS_MODULE)) {
|
|
try = 1;
|
|
mutex_unlock(&lmh_lock);
|
|
request_module(proto_name);
|
|
goto retry;
|
|
}
|
|
printk(KERN_INFO "GFS2: can't find protocol %s\n", proto_name);
|
|
error = -ENOENT;
|
|
goto out;
|
|
}
|
|
|
|
if (!try_module_get(lw->lw_ops->lm_owner)) {
|
|
try = 0;
|
|
mutex_unlock(&lmh_lock);
|
|
msleep(1000);
|
|
goto retry;
|
|
}
|
|
|
|
error = lw->lw_ops->lm_mount(table_name, host_data, cb, fsdata,
|
|
min_lvb_size, flags, lockstruct, fskobj);
|
|
if (error)
|
|
module_put(lw->lw_ops->lm_owner);
|
|
out:
|
|
mutex_unlock(&lmh_lock);
|
|
return error;
|
|
}
|
|
|
|
void gfs2_unmount_lockproto(struct lm_lockstruct *lockstruct)
|
|
{
|
|
mutex_lock(&lmh_lock);
|
|
lockstruct->ls_ops->lm_unmount(lockstruct->ls_lockspace);
|
|
if (lockstruct->ls_ops->lm_owner)
|
|
module_put(lockstruct->ls_ops->lm_owner);
|
|
mutex_unlock(&lmh_lock);
|
|
}
|
|
|
|
/**
|
|
* gfs2_withdraw_lockproto - abnormally unmount a lock module
|
|
* @lockstruct: the lockstruct passed into mount
|
|
*
|
|
*/
|
|
|
|
void gfs2_withdraw_lockproto(struct lm_lockstruct *lockstruct)
|
|
{
|
|
mutex_lock(&lmh_lock);
|
|
lockstruct->ls_ops->lm_withdraw(lockstruct->ls_lockspace);
|
|
if (lockstruct->ls_ops->lm_owner)
|
|
module_put(lockstruct->ls_ops->lm_owner);
|
|
mutex_unlock(&lmh_lock);
|
|
}
|
|
|
|
void __init gfs2_init_lmh(void)
|
|
{
|
|
mutex_init(&lmh_lock);
|
|
INIT_LIST_HEAD(&lmh_list);
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(gfs2_register_lockproto);
|
|
EXPORT_SYMBOL_GPL(gfs2_unregister_lockproto);
|
|
|