Current code still contains obsoleted LKM_* constants for dlm levels, the patch
tries to replace the
obsoleted ones with DLM_LOCK_* constants which are from <linux/dlmconstants.h>.
Signed-off-by: Coly Li <[EMAIL PROTECTED]>
---
fs/ocfs2/dlm/dlmapi.h | 11 -------
fs/ocfs2/dlm/dlmast.c | 16 +++++-----
fs/ocfs2/dlm/dlmcommon.h | 15 +++++----
fs/ocfs2/dlm/dlmconvert.c | 18 ++++++------
fs/ocfs2/dlm/dlmfs.c | 7 ++--
fs/ocfs2/dlm/dlmlock.c | 8 ++--
fs/ocfs2/dlm/dlmrecovery.c | 38 ++++++++++++------------
fs/ocfs2/dlm/dlmthread.c | 20 ++++++------
fs/ocfs2/dlm/dlmunlock.c | 12 ++++----
fs/ocfs2/dlm/userdlm.c | 64 +++++++++++++++++++++---------------------
fs/ocfs2/dlmglue.c | 4 +-
fs/ocfs2/locks.c | 4 +-
fs/ocfs2/stack_o2cb.c | 24 +---------------
include/linux/dlmconstants.h | 1 +
14 files changed, 106 insertions(+), 136 deletions(-)
diff --git a/fs/ocfs2/dlm/dlmapi.h b/fs/ocfs2/dlm/dlmapi.h
index b5786a7..95838f0 100644
--- a/fs/ocfs2/dlm/dlmapi.h
+++ b/fs/ocfs2/dlm/dlmapi.h
@@ -115,17 +115,6 @@ struct dlm_lockstatus {
char lvb[DLM_LVB_LEN];
};
-/* Valid lock modes. */
-#define LKM_IVMODE (-1) /* invalid mode */
-#define LKM_NLMODE 0 /* null lock */
-#define LKM_CRMODE 1 /* concurrent read unsupported */
-#define LKM_CWMODE 2 /* concurrent write unsupported */
-#define LKM_PRMODE 3 /* protected read */
-#define LKM_PWMODE 4 /* protected write unsupported */
-#define LKM_EXMODE 5 /* exclusive */
-#define LKM_MAXMODE 5
-#define LKM_MODEMASK 0xff
-
/* Flags passed to dlmlock and dlmunlock:
* reserved: flags used by the "real" dlm
* only a few are supported by this dlm
diff --git a/fs/ocfs2/dlm/dlmast.c b/fs/ocfs2/dlm/dlmast.c
index 644bee5..3d85a6b 100644
--- a/fs/ocfs2/dlm/dlmast.c
+++ b/fs/ocfs2/dlm/dlmast.c
@@ -68,22 +68,22 @@ static int dlm_should_cancel_bast(struct dlm_ctxt *dlm,
struct dlm_lock *lock)
assert_spin_locked(&dlm->ast_lock);
assert_spin_locked(&lock->spinlock);
- if (lock->ml.highest_blocked == LKM_IVMODE)
+ if (lock->ml.highest_blocked == DLM_LOCK_IV)
return 0;
- BUG_ON(lock->ml.highest_blocked == LKM_NLMODE);
+ BUG_ON(lock->ml.highest_blocked == DLM_LOCK_NL);
if (lock->bast_pending &&
list_empty(&lock->bast_list))
/* old bast already sent, ok */
return 0;
- if (lock->ml.type == LKM_EXMODE)
+ if (lock->ml.type == DLM_LOCK_EX)
/* EX blocks anything left, any bast still valid */
return 0;
- else if (lock->ml.type == LKM_NLMODE)
+ else if (lock->ml.type == DLM_LOCK_NL)
/* NL blocks nothing, no reason to send any bast, cancel it */
return 1;
- else if (lock->ml.highest_blocked != LKM_EXMODE)
+ else if (lock->ml.highest_blocked != DLM_LOCK_EX)
/* PR only blocks EX */
return 1;
@@ -118,7 +118,7 @@ static void __dlm_queue_ast(struct dlm_ctxt *dlm, struct
dlm_lock *lock)
dlm->name, res->lockname.len, res->lockname.name);
lock->bast_pending = 0;
list_del_init(&lock->bast_list);
- lock->ml.highest_blocked = LKM_IVMODE;
+ lock->ml.highest_blocked = DLM_LOCK_IV;
/* removing lock from list, remove a ref. guaranteed
* this won't be the last ref because of the get above,
* so res->spinlock will not be taken here */
@@ -385,9 +385,9 @@ do_ast:
list_move_tail(&lock->list, &res->granted);
mlog(0, "ast: adding to granted list... type=%d, "
"convert_type=%d\n", lock->ml.type,
lock->ml.convert_type);
- if (lock->ml.convert_type != LKM_IVMODE) {
+ if (lock->ml.convert_type != DLM_LOCK_IV) {
lock->ml.type = lock->ml.convert_type;
- lock->ml.convert_type = LKM_IVMODE;
+ lock->ml.convert_type = DLM_LOCK_IV;
} else {
// should already be there....
}
diff --git a/fs/ocfs2/dlm/dlmcommon.h b/fs/ocfs2/dlm/dlmcommon.h
index d5a86fb..59790a9 100644
--- a/fs/ocfs2/dlm/dlmcommon.h
+++ b/fs/ocfs2/dlm/dlmcommon.h
@@ -26,6 +26,7 @@
#define DLMCOMMON_H
#include <linux/kref.h>
+#include <linux/dlmconstants.h>
#define DLM_HB_NODE_DOWN_PRI (0xf000000)
#define DLM_HB_NODE_UP_PRI (0x8000000)
@@ -1027,11 +1028,11 @@ int __dlm_lockres_unused(struct dlm_lock_resource *res);
static inline const char * dlm_lock_mode_name(int mode)
{
switch (mode) {
- case LKM_EXMODE:
+ case DLM_LOCK_EX:
return "EX";
- case LKM_PRMODE:
+ case DLM_LOCK_PR:
return "PR";
- case LKM_NLMODE:
+ case DLM_LOCK_NL:
return "NL";
}
return "UNKNOWN";
@@ -1041,16 +1042,16 @@ static inline const char * dlm_lock_mode_name(int mode)
static inline int dlm_lock_compatible(int existing, int request)
{
/* NO_LOCK compatible with all */
- if (request == LKM_NLMODE ||
- existing == LKM_NLMODE)
+ if (request == DLM_LOCK_NL ||
+ existing == DLM_LOCK_NL)
return 1;
/* EX incompatible with all non-NO_LOCK */
- if (request == LKM_EXMODE)
+ if (request == DLM_LOCK_EX)
return 0;
/* request must be PR, which is compatible with PR */
- if (existing == LKM_PRMODE)
+ if (existing == DLM_LOCK_PR)
return 1;
return 0;
diff --git a/fs/ocfs2/dlm/dlmconvert.c b/fs/ocfs2/dlm/dlmconvert.c
index 75997b4..f117cf8 100644
--- a/fs/ocfs2/dlm/dlmconvert.c
+++ b/fs/ocfs2/dlm/dlmconvert.c
@@ -136,7 +136,7 @@ static enum dlm_status __dlmconvert_master(struct dlm_ctxt
*dlm,
spin_lock(&lock->spinlock);
/* already converting? */
- if (lock->ml.convert_type != LKM_IVMODE) {
+ if (lock->ml.convert_type != DLM_LOCK_IV) {
mlog(ML_ERROR, "attempted to convert a lock with a lock "
"conversion pending\n");
status = DLM_DENIED;
@@ -153,17 +153,17 @@ static enum dlm_status __dlmconvert_master(struct
dlm_ctxt *dlm,
if (flags & LKM_VALBLK) {
switch (lock->ml.type) {
- case LKM_EXMODE:
+ case DLM_LOCK_EX:
/* EX + LKM_VALBLK + convert == set lvb */
mlog(0, "will set lvb: converting %s->%s\n",
dlm_lock_mode_name(lock->ml.type),
dlm_lock_mode_name(type));
lock->lksb->flags |= DLM_LKSB_PUT_LVB;
break;
- case LKM_PRMODE:
- case LKM_NLMODE:
+ case DLM_LOCK_PR:
+ case DLM_LOCK_NL:
/* refetch if new level is not NL */
- if (type > LKM_NLMODE) {
+ if (type > DLM_LOCK_NL) {
mlog(0, "will fetch new value into "
"lvb: converting %s->%s\n",
dlm_lock_mode_name(lock->ml.type),
@@ -251,7 +251,7 @@ void dlm_revert_pending_convert(struct dlm_lock_resource
*res,
{
/* do not alter lock refcount. switching lists. */
list_move_tail(&lock->list, &res->granted);
- lock->ml.convert_type = LKM_IVMODE;
+ lock->ml.convert_type = DLM_LOCK_IV;
lock->lksb->flags &= ~(DLM_LKSB_GET_LVB|DLM_LKSB_PUT_LVB);
}
@@ -282,7 +282,7 @@ enum dlm_status dlmconvert_remote(struct dlm_ctxt *dlm,
/* will exit this call with spinlock held */
__dlm_wait_on_lockres(res);
- if (lock->ml.convert_type != LKM_IVMODE) {
+ if (lock->ml.convert_type != DLM_LOCK_IV) {
__dlm_print_one_lock_resource(res);
mlog(ML_ERROR, "converting a remote lock that is already "
"converting! (cookie=%u:%llu, conv=%d)\n",
@@ -300,11 +300,11 @@ enum dlm_status dlmconvert_remote(struct dlm_ctxt *dlm,
lock->ml.convert_type = type;
if (flags & LKM_VALBLK) {
- if (lock->ml.type == LKM_EXMODE) {
+ if (lock->ml.type == DLM_LOCK_EX) {
flags |= LKM_PUT_LVB;
lock->lksb->flags |= DLM_LKSB_PUT_LVB;
} else {
- if (lock->ml.convert_type == LKM_NLMODE)
+ if (lock->ml.convert_type == DLM_LOCK_NL)
flags &= ~LKM_VALBLK;
else {
flags |= LKM_GET_LVB;
diff --git a/fs/ocfs2/dlm/dlmfs.c b/fs/ocfs2/dlm/dlmfs.c
index 533a789..2aae623 100644
--- a/fs/ocfs2/dlm/dlmfs.c
+++ b/fs/ocfs2/dlm/dlmfs.c
@@ -43,6 +43,7 @@
#include <linux/init.h>
#include <linux/string.h>
#include <linux/backing-dev.h>
+#include <linux/dlmconstants.h>
#include <asm/uaccess.h>
@@ -95,9 +96,9 @@ static int dlmfs_decode_open_flags(int open_flags,
int *flags)
{
if (open_flags & (O_WRONLY|O_RDWR))
- *level = LKM_EXMODE;
+ *level = DLM_LOCK_EX;
else
- *level = LKM_PRMODE;
+ *level = DLM_LOCK_PR;
*flags = 0;
if (open_flags & O_NONBLOCK)
@@ -169,7 +170,7 @@ static int dlmfs_file_release(struct inode *inode,
status = 0;
if (fp) {
level = fp->fp_lock_level;
- if (level != LKM_IVMODE)
+ if (level != DLM_LOCK_IV)
user_dlm_cluster_unlock(&ip->ip_lockres, level);
kfree(fp);
diff --git a/fs/ocfs2/dlm/dlmlock.c b/fs/ocfs2/dlm/dlmlock.c
index 83a9f29..b2e76ab 100644
--- a/fs/ocfs2/dlm/dlmlock.c
+++ b/fs/ocfs2/dlm/dlmlock.c
@@ -403,8 +403,8 @@ static void dlm_init_lock(struct dlm_lock *newlock, int
type,
INIT_LIST_HEAD(&newlock->bast_list);
spin_lock_init(&newlock->spinlock);
newlock->ml.type = type;
- newlock->ml.convert_type = LKM_IVMODE;
- newlock->ml.highest_blocked = LKM_IVMODE;
+ newlock->ml.convert_type = DLM_LOCK_IV;
+ newlock->ml.highest_blocked = DLM_LOCK_IV;
newlock->ml.node = node;
newlock->ml.pad1 = 0;
newlock->ml.list = 0;
@@ -580,7 +580,7 @@ enum dlm_status dlmlock(struct dlm_ctxt *dlm, int mode,
}
status = DLM_BADPARAM;
- if (mode != LKM_EXMODE && mode != LKM_PRMODE && mode != LKM_NLMODE) {
+ if (mode != DLM_LOCK_EX && mode != DLM_LOCK_PR && mode != DLM_LOCK_NL) {
dlm_error(status);
goto error;
}
@@ -703,7 +703,7 @@ retry_lock:
/* LVB requests for non PR, PW or EX locks are
* ignored. */
- if (mode < LKM_PRMODE)
+ if (mode < DLM_LOCK_PR)
flags &= ~LKM_VALBLK;
else {
flags |= LKM_GET_LVB;
diff --git a/fs/ocfs2/dlm/dlmrecovery.c b/fs/ocfs2/dlm/dlmrecovery.c
index bcb9260..947f70c 100644
--- a/fs/ocfs2/dlm/dlmrecovery.c
+++ b/fs/ocfs2/dlm/dlmrecovery.c
@@ -1183,12 +1183,12 @@ static int dlm_add_lock_to_array(struct dlm_lock *lock,
if (lock->lksb) {
ml->flags = lock->lksb->flags;
/* send our current lvb */
- if (ml->type == LKM_EXMODE ||
- ml->type == LKM_PRMODE) {
+ if (ml->type == DLM_LOCK_EX ||
+ ml->type == DLM_LOCK_PR) {
/* if it is already set, this had better be a PR
* and it has to match */
if (!dlm_lvb_is_empty(mres->lvb) &&
- (ml->type == LKM_EXMODE ||
+ (ml->type == DLM_LOCK_EX ||
memcmp(mres->lvb, lock->lksb->lvb, DLM_LVB_LEN))) {
mlog(ML_ERROR, "mismatched lvbs!\n");
dlm_print_one_lock_resource(lock->lockres);
@@ -1211,9 +1211,9 @@ static void dlm_add_dummy_lock(struct dlm_ctxt *dlm,
struct dlm_lock dummy;
memset(&dummy, 0, sizeof(dummy));
dummy.ml.cookie = 0;
- dummy.ml.type = LKM_IVMODE;
- dummy.ml.convert_type = LKM_IVMODE;
- dummy.ml.highest_blocked = LKM_IVMODE;
+ dummy.ml.type = DLM_LOCK_IV;
+ dummy.ml.convert_type = DLM_LOCK_IV;
+ dummy.ml.highest_blocked = DLM_LOCK_IV;
dummy.lksb = NULL;
dummy.ml.node = dlm->node_num;
dlm_add_lock_to_array(&dummy, mres, DLM_BLOCKED_LIST);
@@ -1224,9 +1224,9 @@ static inline int dlm_is_dummy_lock(struct dlm_ctxt *dlm,
u8 *nodenum)
{
if (unlikely(ml->cookie == 0 &&
- ml->type == LKM_IVMODE &&
- ml->convert_type == LKM_IVMODE &&
- ml->highest_blocked == LKM_IVMODE &&
+ ml->type == DLM_LOCK_IV &&
+ ml->convert_type == DLM_LOCK_IV &&
+ ml->highest_blocked == DLM_LOCK_IV &&
ml->list == DLM_BLOCKED_LIST)) {
*nodenum = ml->node;
return 1;
@@ -1748,7 +1748,7 @@ static int dlm_process_recovery_data(struct dlm_ctxt *dlm,
added++;
break;
}
- BUG_ON(ml->highest_blocked != LKM_IVMODE);
+ BUG_ON(ml->highest_blocked != DLM_LOCK_IV);
newlock = NULL;
lksb = NULL;
@@ -1818,14 +1818,14 @@ static int dlm_process_recovery_data(struct dlm_ctxt
*dlm,
lksb = newlock->lksb;
dlm_lock_attach_lockres(newlock, res);
- if (ml->convert_type != LKM_IVMODE) {
+ if (ml->convert_type != DLM_LOCK_IV) {
BUG_ON(queue != &res->converting);
newlock->ml.convert_type = ml->convert_type;
}
lksb->flags |= (ml->flags &
(DLM_LKSB_PUT_LVB|DLM_LKSB_GET_LVB));
- if (ml->type == LKM_NLMODE)
+ if (ml->type == DLM_LOCK_NL)
goto skip_lvb;
if (!dlm_lvb_is_empty(mres->lvb)) {
@@ -1842,10 +1842,10 @@ static int dlm_process_recovery_data(struct dlm_ctxt
*dlm,
} else {
/* otherwise, the node is sending its
* most recent valid lvb info */
- BUG_ON(ml->type != LKM_EXMODE &&
- ml->type != LKM_PRMODE);
+ BUG_ON(ml->type != DLM_LOCK_EX &&
+ ml->type != DLM_LOCK_PR);
if (!dlm_lvb_is_empty(res->lvb) &&
- (ml->type == LKM_EXMODE ||
+ (ml->type == DLM_LOCK_EX ||
memcmp(res->lvb, mres->lvb, DLM_LVB_LEN)))
{
int i;
mlog(ML_ERROR, "%s:%.*s: received bad "
@@ -2094,10 +2094,10 @@ static void dlm_finish_local_lockres_recovery(struct
dlm_ctxt *dlm,
static inline int dlm_lvb_needs_invalidation(struct dlm_lock *lock, int local)
{
if (local) {
- if (lock->ml.type != LKM_EXMODE &&
- lock->ml.type != LKM_PRMODE)
+ if (lock->ml.type != DLM_LOCK_EX &&
+ lock->ml.type != DLM_LOCK_PR)
return 1;
- } else if (lock->ml.type == LKM_EXMODE)
+ } else if (lock->ml.type == DLM_LOCK_EX)
return 1;
return 0;
}
@@ -2428,7 +2428,7 @@ static int dlm_pick_recovery_master(struct dlm_ctxt *dlm)
again:
memset(&lksb, 0, sizeof(lksb));
- ret = dlmlock(dlm, LKM_EXMODE, &lksb, LKM_NOQUEUE|LKM_RECOVERY,
+ ret = dlmlock(dlm, DLM_LOCK_EX, &lksb, LKM_NOQUEUE|LKM_RECOVERY,
DLM_RECOVERY_LOCK_NAME, DLM_RECOVERY_LOCK_NAME_LEN,
dlm_reco_ast, dlm, dlm_reco_bast);
diff --git a/fs/ocfs2/dlm/dlmthread.c b/fs/ocfs2/dlm/dlmthread.c
index 4060bb3..80f1c29 100644
--- a/fs/ocfs2/dlm/dlmthread.c
+++ b/fs/ocfs2/dlm/dlmthread.c
@@ -303,7 +303,7 @@ converting:
res->lockname.name);
target = list_entry(res->converting.next, struct dlm_lock, list);
- if (target->ml.convert_type == LKM_IVMODE) {
+ if (target->ml.convert_type == DLM_LOCK_IV) {
mlog(ML_ERROR, "%.*s: converting a lock with no "
"convert_type!\n", res->lockname.len, res->lockname.name);
BUG();
@@ -317,7 +317,7 @@ converting:
target->ml.convert_type)) {
can_grant = 0;
/* queue the BAST if not already */
- if (lock->ml.highest_blocked == LKM_IVMODE) {
+ if (lock->ml.highest_blocked == DLM_LOCK_IV) {
__dlm_lockres_reserve_ast(res);
dlm_queue_bast(dlm, lock);
}
@@ -335,7 +335,7 @@ converting:
if (!dlm_lock_compatible(lock->ml.type,
target->ml.convert_type)) {
can_grant = 0;
- if (lock->ml.highest_blocked == LKM_IVMODE) {
+ if (lock->ml.highest_blocked == DLM_LOCK_IV) {
__dlm_lockres_reserve_ast(res);
dlm_queue_bast(dlm, lock);
}
@@ -348,7 +348,7 @@ converting:
/* we can convert the lock */
if (can_grant) {
spin_lock(&target->spinlock);
- BUG_ON(target->ml.highest_blocked != LKM_IVMODE);
+ BUG_ON(target->ml.highest_blocked != DLM_LOCK_IV);
mlog(0, "calling ast for converting lock: %.*s, have: %d, "
"granting: %d, node: %u\n", res->lockname.len,
@@ -356,7 +356,7 @@ converting:
target->ml.convert_type, target->ml.node);
target->ml.type = target->ml.convert_type;
- target->ml.convert_type = LKM_IVMODE;
+ target->ml.convert_type = DLM_LOCK_IV;
list_move_tail(&target->list, &res->granted);
BUG_ON(!target->lksb);
@@ -382,7 +382,7 @@ blocked:
continue;
if (!dlm_lock_compatible(lock->ml.type, target->ml.type)) {
can_grant = 0;
- if (lock->ml.highest_blocked == LKM_IVMODE) {
+ if (lock->ml.highest_blocked == DLM_LOCK_IV) {
__dlm_lockres_reserve_ast(res);
dlm_queue_bast(dlm, lock);
}
@@ -398,7 +398,7 @@ blocked:
continue;
if (!dlm_lock_compatible(lock->ml.type, target->ml.type)) {
can_grant = 0;
- if (lock->ml.highest_blocked == LKM_IVMODE) {
+ if (lock->ml.highest_blocked == DLM_LOCK_IV) {
__dlm_lockres_reserve_ast(res);
dlm_queue_bast(dlm, lock);
}
@@ -411,7 +411,7 @@ blocked:
* possible if converting list empty) */
if (can_grant) {
spin_lock(&target->spinlock);
- BUG_ON(target->ml.highest_blocked != LKM_IVMODE);
+ BUG_ON(target->ml.highest_blocked != DLM_LOCK_IV);
mlog(0, "calling ast for blocked lock: %.*s, granting: %d, "
"node: %u\n", res->lockname.len, res->lockname.name,
@@ -565,9 +565,9 @@ static void dlm_flush_asts(struct dlm_ctxt *dlm)
/* get the highest blocked lock, and reset */
spin_lock(&lock->spinlock);
- BUG_ON(lock->ml.highest_blocked <= LKM_IVMODE);
+ BUG_ON(lock->ml.highest_blocked <= DLM_LOCK_IV);
hi = lock->ml.highest_blocked;
- lock->ml.highest_blocked = LKM_IVMODE;
+ lock->ml.highest_blocked = DLM_LOCK_IV;
spin_unlock(&lock->spinlock);
/* remove from list (including ref) */
diff --git a/fs/ocfs2/dlm/dlmunlock.c b/fs/ocfs2/dlm/dlmunlock.c
index 86ca085..940978a 100644
--- a/fs/ocfs2/dlm/dlmunlock.c
+++ b/fs/ocfs2/dlm/dlmunlock.c
@@ -227,7 +227,7 @@ static enum dlm_status dlmunlock_common(struct dlm_ctxt
*dlm,
if (actions & DLM_UNLOCK_CLEAR_CONVERT_TYPE) {
mlog(0, "clearing convert_type at %smaster node\n",
master_node ? "" : "non-");
- lock->ml.convert_type = LKM_IVMODE;
+ lock->ml.convert_type = DLM_LOCK_IV;
}
/* remove the extra ref on lock */
@@ -236,9 +236,9 @@ static enum dlm_status dlmunlock_common(struct dlm_ctxt
*dlm,
leave:
res->state &= ~DLM_LOCK_RES_IN_PROGRESS;
if (!dlm_lock_on_list(&res->converting, lock))
- BUG_ON(lock->ml.convert_type != LKM_IVMODE);
+ BUG_ON(lock->ml.convert_type != DLM_LOCK_IV);
else
- BUG_ON(lock->ml.convert_type == LKM_IVMODE);
+ BUG_ON(lock->ml.convert_type == DLM_LOCK_IV);
spin_unlock(&lock->spinlock);
spin_unlock(&res->spinlock);
wake_up(&res->wq);
@@ -275,7 +275,7 @@ void dlm_commit_pending_cancel(struct dlm_lock_resource
*res,
struct dlm_lock *lock)
{
list_move_tail(&lock->list, &res->granted);
- lock->ml.convert_type = LKM_IVMODE;
+ lock->ml.convert_type = DLM_LOCK_IV;
}
@@ -482,7 +482,7 @@ int dlm_unlock_lock_handler(struct o2net_msg *msg, u32 len,
void *data,
/* lock was found on queue */
lksb = lock->lksb;
if (flags & (LKM_VALBLK|LKM_PUT_LVB) &&
- lock->ml.type != LKM_EXMODE)
+ lock->ml.type != DLM_LOCK_EX)
flags &= ~(LKM_VALBLK|LKM_PUT_LVB);
/* unlockast only called on originating node */
@@ -625,7 +625,7 @@ retry:
spin_lock(&res->spinlock);
is_master = (res->owner == dlm->node_num);
- if (flags & LKM_VALBLK && lock->ml.type != LKM_EXMODE)
+ if (flags & LKM_VALBLK && lock->ml.type != DLM_LOCK_EX)
flags &= ~LKM_VALBLK;
spin_unlock(&res->spinlock);
diff --git a/fs/ocfs2/dlm/userdlm.c b/fs/ocfs2/dlm/userdlm.c
index 4cb1d3d..6d0bd96 100644
--- a/fs/ocfs2/dlm/userdlm.c
+++ b/fs/ocfs2/dlm/userdlm.c
@@ -33,7 +33,7 @@
#include <linux/fs.h>
#include <linux/types.h>
#include <linux/crc32.h>
-
+#include <linux/dlmconstants.h>
#include "cluster/nodemanager.h"
#include "cluster/heartbeat.h"
@@ -113,12 +113,12 @@ static inline void user_recover_from_dlm_error(struct
user_lock_res *lockres)
* lock types are added. */
static inline int user_highest_compat_lock_level(int level)
{
- int new_level = LKM_EXMODE;
+ int new_level = DLM_LOCK_EX;
- if (level == LKM_EXMODE)
- new_level = LKM_NLMODE;
- else if (level == LKM_PRMODE)
- new_level = LKM_PRMODE;
+ if (level == DLM_LOCK_EX)
+ new_level = DLM_LOCK_NL;
+ else if (level == DLM_LOCK_PR)
+ new_level = DLM_LOCK_PR;
return new_level;
}
@@ -140,7 +140,7 @@ static void user_ast(void *opaque)
return;
}
- mlog_bug_on_msg(lockres->l_requested == LKM_IVMODE,
+ mlog_bug_on_msg(lockres->l_requested == DLM_LOCK_IV,
"Lockres %.*s, requested ivmode. flags 0x%x\n",
lockres->l_namelen, lockres->l_name, lockres->l_flags);
@@ -148,13 +148,13 @@ static void user_ast(void *opaque)
if (lockres->l_requested < lockres->l_level) {
if (lockres->l_requested <=
user_highest_compat_lock_level(lockres->l_blocking)) {
- lockres->l_blocking = LKM_NLMODE;
+ lockres->l_blocking = DLM_LOCK_NL;
lockres->l_flags &= ~USER_LOCK_BLOCKED;
}
}
lockres->l_level = lockres->l_requested;
- lockres->l_requested = LKM_IVMODE;
+ lockres->l_requested = DLM_LOCK_IV;
lockres->l_flags |= USER_LOCK_ATTACHED;
lockres->l_flags &= ~USER_LOCK_BUSY;
@@ -193,11 +193,11 @@ static void __user_dlm_cond_queue_lockres(struct
user_lock_res *lockres)
return;
switch (lockres->l_blocking) {
- case LKM_EXMODE:
+ case DLM_LOCK_EX:
if (!lockres->l_ex_holders && !lockres->l_ro_holders)
queue = 1;
break;
- case LKM_PRMODE:
+ case DLM_LOCK_PR:
if (!lockres->l_ex_holders)
queue = 1;
break;
@@ -243,7 +243,7 @@ static void user_unlock_ast(void *opaque, enum dlm_status
status)
* for a concurrent cancel. */
if (lockres->l_flags & USER_LOCK_IN_TEARDOWN
&& !(lockres->l_flags & USER_LOCK_IN_CANCEL)) {
- lockres->l_level = LKM_IVMODE;
+ lockres->l_level = DLM_LOCK_IV;
} else if (status == DLM_CANCELGRANT) {
/* We tried to cancel a convert request, but it was
* already granted. Don't clear the busy flag - the
@@ -254,7 +254,7 @@ static void user_unlock_ast(void *opaque, enum dlm_status
status)
} else {
BUG_ON(!(lockres->l_flags & USER_LOCK_IN_CANCEL));
/* Cancel succeeded, we want to re-queue */
- lockres->l_requested = LKM_IVMODE; /* cancel an
+ lockres->l_requested = DLM_LOCK_IV; /* cancel an
* upconvert
* request. */
lockres->l_flags &= ~USER_LOCK_IN_CANCEL;
@@ -335,7 +335,7 @@ static void user_dlm_unblock_lock(struct work_struct *work)
/* If there are still incompat holders, we can exit safely
* without worrying about re-queueing this lock as that will
* happen on the last call to user_cluster_unlock. */
- if ((lockres->l_blocking == LKM_EXMODE)
+ if ((lockres->l_blocking == DLM_LOCK_EX)
&& (lockres->l_ex_holders || lockres->l_ro_holders)) {
spin_unlock(&lockres->l_lock);
mlog(0, "can't downconvert for ex: ro = %u, ex = %u\n",
@@ -343,7 +343,7 @@ static void user_dlm_unblock_lock(struct work_struct *work)
goto drop_ref;
}
- if ((lockres->l_blocking == LKM_PRMODE)
+ if ((lockres->l_blocking == DLM_LOCK_PR)
&& lockres->l_ex_holders) {
spin_unlock(&lockres->l_lock);
mlog(0, "can't downconvert for pr: ex = %u\n",
@@ -382,10 +382,10 @@ static inline void user_dlm_inc_holders(struct
user_lock_res *lockres,
int level)
{
switch(level) {
- case LKM_EXMODE:
+ case DLM_LOCK_EX:
lockres->l_ex_holders++;
break;
- case LKM_PRMODE:
+ case DLM_LOCK_PR:
lockres->l_ro_holders++;
break;
default:
@@ -412,8 +412,8 @@ int user_dlm_cluster_lock(struct user_lock_res *lockres,
int status, local_flags;
struct dlm_ctxt *dlm = dlm_ctxt_from_user_lockres(lockres);
- if (level != LKM_EXMODE &&
- level != LKM_PRMODE) {
+ if (level != DLM_LOCK_EX &&
+ level != DLM_LOCK_PR) {
mlog(ML_ERROR, "lockres %.*s: invalid request!\n",
lockres->l_namelen, lockres->l_name);
status = -EINVAL;
@@ -422,7 +422,7 @@ int user_dlm_cluster_lock(struct user_lock_res *lockres,
mlog(0, "lockres %.*s: asking for %s lock, passed flags = 0x%x\n",
lockres->l_namelen, lockres->l_name,
- (level == LKM_EXMODE) ? "LKM_EXMODE" : "LKM_PRMODE",
+ (level == DLM_LOCK_EX) ? "DLM_LOCK_EX" : "DLM_LOCK_PR",
lkm_flags);
again:
@@ -458,15 +458,15 @@ again:
if (level > lockres->l_level) {
local_flags = lkm_flags | LKM_VALBLK;
- if (lockres->l_level != LKM_IVMODE)
+ if (lockres->l_level != DLM_LOCK_IV)
local_flags |= LKM_CONVERT;
lockres->l_requested = level;
lockres->l_flags |= USER_LOCK_BUSY;
spin_unlock(&lockres->l_lock);
- BUG_ON(level == LKM_IVMODE);
- BUG_ON(level == LKM_NLMODE);
+ BUG_ON(level == DLM_LOCK_IV);
+ BUG_ON(level == DLM_LOCK_NL);
/* call dlm_lock to upgrade lock now */
status = dlmlock(dlm,
@@ -506,11 +506,11 @@ static inline void user_dlm_dec_holders(struct
user_lock_res *lockres,
int level)
{
switch(level) {
- case LKM_EXMODE:
+ case DLM_LOCK_EX:
BUG_ON(!lockres->l_ex_holders);
lockres->l_ex_holders--;
break;
- case LKM_PRMODE:
+ case DLM_LOCK_PR:
BUG_ON(!lockres->l_ro_holders);
lockres->l_ro_holders--;
break;
@@ -522,8 +522,8 @@ static inline void user_dlm_dec_holders(struct
user_lock_res *lockres,
void user_dlm_cluster_unlock(struct user_lock_res *lockres,
int level)
{
- if (level != LKM_EXMODE &&
- level != LKM_PRMODE) {
+ if (level != DLM_LOCK_EX &&
+ level != DLM_LOCK_PR) {
mlog(ML_ERROR, "lockres %.*s: invalid request!\n",
lockres->l_namelen, lockres->l_name);
return;
@@ -546,7 +546,7 @@ void user_dlm_write_lvb(struct inode *inode,
spin_lock(&lockres->l_lock);
- BUG_ON(lockres->l_level < LKM_EXMODE);
+ BUG_ON(lockres->l_level < DLM_LOCK_EX);
memcpy(lvb, val, len);
spin_unlock(&lockres->l_lock);
@@ -563,7 +563,7 @@ void user_dlm_read_lvb(struct inode *inode,
spin_lock(&lockres->l_lock);
- BUG_ON(lockres->l_level < LKM_PRMODE);
+ BUG_ON(lockres->l_level < DLM_LOCK_PR);
memcpy(val, lvb, len);
spin_unlock(&lockres->l_lock);
@@ -576,9 +576,9 @@ void user_dlm_lock_res_init(struct user_lock_res *lockres,
spin_lock_init(&lockres->l_lock);
init_waitqueue_head(&lockres->l_event);
- lockres->l_level = LKM_IVMODE;
- lockres->l_requested = LKM_IVMODE;
- lockres->l_blocking = LKM_IVMODE;
+ lockres->l_level = DLM_LOCK_IV;
+ lockres->l_requested = DLM_LOCK_IV;
+ lockres->l_blocking = DLM_LOCK_IV;
/* should have been checked before getting here. */
BUG_ON(dentry->d_name.len >= USER_DLM_LOCK_ID_MAX_LEN);
diff --git a/fs/ocfs2/dlmglue.c b/fs/ocfs2/dlmglue.c
index ec68442..b1b47bd 100644
--- a/fs/ocfs2/dlmglue.c
+++ b/fs/ocfs2/dlmglue.c
@@ -392,12 +392,12 @@ static void ocfs2_update_lock_stats(struct ocfs2_lock_res
*res, int level,
struct timespec ts = current_kernel_time();
unsigned long long time = timespec_to_ns(&ts) - mw->mw_lock_start;
- if (level == LKM_PRMODE) {
+ if (level == DLM_LOCK_PR) {
num = &res->l_lock_num_prmode;
sum = &res->l_lock_total_prmode;
max = &res->l_lock_max_prmode;
failed = &res->l_lock_num_prmode_failed;
- } else if (level == LKM_EXMODE) {
+ } else if (level == DLM_LOCK_EX) {
num = &res->l_lock_num_exmode;
sum = &res->l_lock_total_exmode;
max = &res->l_lock_max_exmode;
diff --git a/fs/ocfs2/locks.c b/fs/ocfs2/locks.c
index 544ac62..eb0a42d 100644
--- a/fs/ocfs2/locks.c
+++ b/fs/ocfs2/locks.c
@@ -51,10 +51,10 @@ static int ocfs2_do_flock(struct file *file, struct inode
*inode,
mutex_lock(&fp->fp_mutex);
if (lockres->l_flags & OCFS2_LOCK_ATTACHED &&
- lockres->l_level > LKM_NLMODE) {
+ lockres->l_level > DLM_LOCK_NL) {
int old_level = 0;
- if (lockres->l_level == LKM_EXMODE)
+ if (lockres->l_level == DLM_LOCK_EX)
old_level = 1;
if (level == old_level)
diff --git a/fs/ocfs2/stack_o2cb.c b/fs/ocfs2/stack_o2cb.c
index fcd120f..351a06f 100644
--- a/fs/ocfs2/stack_o2cb.c
+++ b/fs/ocfs2/stack_o2cb.c
@@ -35,31 +35,9 @@ struct o2dlm_private {
static struct ocfs2_stack_plugin o2cb_stack;
-/* These should be identical */
-#if (DLM_LOCK_IV != LKM_IVMODE)
-# error Lock modes do not match
-#endif
-#if (DLM_LOCK_NL != LKM_NLMODE)
-# error Lock modes do not match
-#endif
-#if (DLM_LOCK_CR != LKM_CRMODE)
-# error Lock modes do not match
-#endif
-#if (DLM_LOCK_CW != LKM_CWMODE)
-# error Lock modes do not match
-#endif
-#if (DLM_LOCK_PR != LKM_PRMODE)
-# error Lock modes do not match
-#endif
-#if (DLM_LOCK_PW != LKM_PWMODE)
-# error Lock modes do not match
-#endif
-#if (DLM_LOCK_EX != LKM_EXMODE)
-# error Lock modes do not match
-#endif
static inline int mode_to_o2dlm(int mode)
{
- BUG_ON(mode > LKM_MAXMODE);
+ BUG_ON(mode > DLM_LOCK_MAX);
return mode;
}
diff --git a/include/linux/dlmconstants.h b/include/linux/dlmconstants.h
index 47bf08d..f87bbc1 100644
--- a/include/linux/dlmconstants.h
+++ b/include/linux/dlmconstants.h
@@ -33,6 +33,7 @@
#define DLM_LOCK_PR 3 /* protected read */
#define DLM_LOCK_PW 4 /* protected write */
#define DLM_LOCK_EX 5 /* exclusive */
+#define DLM_LOCK_MAX 5
/*
--
Coly Li
SuSE PRC Labs
_______________________________________________
Ocfs2-devel mailing list
[email protected]
http://oss.oracle.com/mailman/listinfo/ocfs2-devel
