UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

[DLM] Remove range locks from the DLM 

This patch removes support for range locking from the DLM

Signed-off-by: David Teigland <teigland@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
This commit is contained in:
David Teigland 2006-02-23 09:56:38 +00:00 committed by Steven Whitehouse
parent d35462b4bb
commit 3bcd3687f8
10 changed files with 13 additions and 170 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
fs/dlm/debug_fs.c
View File

@ -59,20 +59,6 @@ static void print_lock(struct seq_file *s, struct dlm_lkb *lkb,
|| lkb->lkb_status == DLM_LKSTS_WAITING)
seq_printf(s, " (%s)", print_lockmode(lkb->lkb_rqmode));
if (lkb->lkb_range) {
/* FIXME: this warns on Alpha */
if (lkb->lkb_status == DLM_LKSTS_CONVERT
|| lkb->lkb_status == DLM_LKSTS_GRANTED)
seq_printf(s, " %llx-%llx",
lkb->lkb_range[GR_RANGE_START],
lkb->lkb_range[GR_RANGE_END]);
if (lkb->lkb_status == DLM_LKSTS_CONVERT
|| lkb->lkb_status == DLM_LKSTS_WAITING)
seq_printf(s, " (%llx-%llx)",
lkb->lkb_range[RQ_RANGE_START],
lkb->lkb_range[RQ_RANGE_END]);
}
if (lkb->lkb_nodeid) {
if (lkb->lkb_nodeid != res->res_nodeid)
seq_printf(s, " Remote: %3d %08x", lkb->lkb_nodeid,

6
fs/dlm/device.c
View File

@ -532,8 +532,7 @@ static int dlm_close(struct inode *inode, struct file *file)
status = dlm_lock(f->fi_ls->ls_lockspace,
old_li->li_grmode, &li.li_lksb,
DLM_LKF_CONVERT|DLM_LKF_ORPHAN,
NULL, 0, 0, ast_routine, NULL,
NULL, NULL);
NULL, 0, 0, ast_routine, NULL, NULL);
if (status != 0)
printk("dlm: Error orphaning lock %x: %d\n",
old_li->li_lksb.sb_lkid, status);
@ -878,8 +877,7 @@ static int do_user_lock(struct file_info *fi, uint8_t cmd,
ast_routine,
li,
(li->li_pend_bastaddr || li->li_bastaddr) ?
bast_routine : NULL,
kparams->range.ra_end ? &kparams->range : NULL);
bast_routine : NULL);
if (status)
goto out_err;

12
fs/dlm/dlm_internal.h
View File

@ -146,7 +146,6 @@ struct dlm_args {
void *bastaddr;
int mode;
struct dlm_lksb *lksb;
struct dlm_range *range;
};
@ -195,13 +194,6 @@ struct dlm_args {
#define AST_COMP 1
#define AST_BAST 2
/* lkb_range[] */
#define GR_RANGE_START 0
#define GR_RANGE_END 1
#define RQ_RANGE_START 2
#define RQ_RANGE_END 3
/* lkb_status */
#define DLM_LKSTS_WAITING 1
@ -212,7 +204,6 @@ struct dlm_args {
#define DLM_IFL_MSTCPY 0x00010000
#define DLM_IFL_RESEND 0x00020000
#define DLM_IFL_RANGE 0x00000001
struct dlm_lkb {
struct dlm_rsb *lkb_resource; /* the rsb */
@ -241,7 +232,6 @@ struct dlm_lkb {
struct list_head lkb_wait_reply; /* waiting for remote reply */
struct list_head lkb_astqueue; /* need ast to be sent */
uint64_t *lkb_range; /* array of gr/rq ranges */
char *lkb_lvbptr;
struct dlm_lksb *lkb_lksb; /* caller's status block */
void *lkb_astaddr; /* caller's ast function */
@ -360,7 +350,6 @@ struct dlm_message {
int m_bastmode;
int m_asts;
int m_result; /* 0 or -EXXX */
uint64_t m_range[2];
char m_extra[0]; /* name or lvb */
};
@ -413,7 +402,6 @@ struct rcom_lock {
int8_t rl_asts;
uint16_t rl_wait_type;
uint16_t rl_namelen;
uint64_t rl_range[4];
char rl_name[DLM_RESNAME_MAXLEN];
char rl_lvb[0];
};

103
fs/dlm/lock.c
View File

@ -606,8 +606,6 @@ static int put_lkb(struct dlm_lkb *lkb)
/* for local/process lkbs, lvbptr points to caller's lksb */
if (lkb->lkb_lvbptr && is_master_copy(lkb))
free_lvb(lkb->lkb_lvbptr);
if (lkb->lkb_range)
free_range(lkb->lkb_range);
free_lkb(lkb);
return 1;
} else {
@ -988,11 +986,6 @@ static void _grant_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
}
lkb->lkb_rqmode = DLM_LOCK_IV;
if (lkb->lkb_range) {
lkb->lkb_range[GR_RANGE_START] = lkb->lkb_range[RQ_RANGE_START];
lkb->lkb_range[GR_RANGE_END] = lkb->lkb_range[RQ_RANGE_END];
}
}
static void grant_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
@ -1032,21 +1025,6 @@ static inline int first_in_list(struct dlm_lkb *lkb, struct list_head *head)
return 0;
}
/* Return 1 if the locks' ranges overlap. If the lkb has no range then it is
assumed to cover 0-ffffffff.ffffffff */
static inline int ranges_overlap(struct dlm_lkb *lkb1, struct dlm_lkb *lkb2)
{
if (!lkb1->lkb_range || !lkb2->lkb_range)
return 1;
if (lkb1->lkb_range[RQ_RANGE_END] < lkb2->lkb_range[GR_RANGE_START] ||
lkb1->lkb_range[RQ_RANGE_START] > lkb2->lkb_range[GR_RANGE_END])
return 0;
return 1;
}
/* Check if the given lkb conflicts with another lkb on the queue. */
static int queue_conflict(struct list_head *head, struct dlm_lkb *lkb)
@ -1056,7 +1034,7 @@ static int queue_conflict(struct list_head *head, struct dlm_lkb *lkb)
list_for_each_entry(this, head, lkb_statequeue) {
if (this == lkb)
continue;
if (ranges_overlap(lkb, this) && !modes_compat(this, lkb))
if (!modes_compat(this, lkb))
return 1;
}
return 0;
@ -1099,9 +1077,6 @@ static int conversion_deadlock_detect(struct dlm_rsb *rsb, struct dlm_lkb *lkb)
continue;
}
if (!ranges_overlap(lkb, this))
continue;
if (!modes_compat(this, lkb) && !modes_compat(lkb, this))
return 1;
}
@ -1203,8 +1178,8 @@ static int _can_be_granted(struct dlm_rsb *r, struct dlm_lkb *lkb, int now)
return 1;
/*
* When using range locks the NOORDER flag is set to avoid the standard
* vms rules on grant order.
* The NOORDER flag is set to avoid the standard vms rules on grant
* order.
*/
if (lkb->lkb_exflags & DLM_LKF_NOORDER)
@ -1358,8 +1333,7 @@ static void grant_pending_locks(struct dlm_rsb *r)
/*
* If there are locks left on the wait/convert queue then send blocking
* ASTs to granted locks based on the largest requested mode (high)
* found above. This can generate spurious blocking ASTs for range
* locks. FIXME: highbast < high comparison not valid for PR/CW.
* found above. FIXME: highbast < high comparison not valid for PR/CW.
*/
list_for_each_entry_safe(lkb, s, &r->res_grantqueue, lkb_statequeue) {
@ -1379,7 +1353,7 @@ static void send_bast_queue(struct dlm_rsb *r, struct list_head *head,
list_for_each_entry(gr, head, lkb_statequeue) {
if (gr->lkb_bastaddr &&
gr->lkb_highbast < lkb->lkb_rqmode &&
ranges_overlap(lkb, gr) && !modes_compat(gr, lkb)) {
!modes_compat(gr, lkb)) {
queue_bast(r, gr, lkb->lkb_rqmode);
gr->lkb_highbast = lkb->lkb_rqmode;
}
@ -1530,8 +1504,7 @@ static void confirm_master(struct dlm_rsb *r, int error)
static int set_lock_args(int mode, struct dlm_lksb *lksb, uint32_t flags,
int namelen, uint32_t parent_lkid, void *ast,
void *astarg, void *bast, struct dlm_range *range,
struct dlm_args *args)
void *astarg, void *bast, struct dlm_args *args)
{
int rv = -EINVAL;
@ -1590,7 +1563,6 @@ static int set_lock_args(int mode, struct dlm_lksb *lksb, uint32_t flags,
args->bastaddr = bast;
args->mode = mode;
args->lksb = lksb;
args->range = range;
rv = 0;
out:
return rv;
@ -1637,26 +1609,6 @@ static int validate_lock_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
lkb->lkb_lksb = args->lksb;
lkb->lkb_lvbptr = args->lksb->sb_lvbptr;
lkb->lkb_ownpid = (int) current->pid;
rv = 0;
if (!args->range)
goto out;
if (!lkb->lkb_range) {
rv = -ENOMEM;
lkb->lkb_range = allocate_range(ls);
if (!lkb->lkb_range)
goto out;
/* This is needed for conversions that contain ranges
where the original lock didn't but it's harmless for
new locks too. */
lkb->lkb_range[GR_RANGE_START] = 0LL;
lkb->lkb_range[GR_RANGE_END] = 0xffffffffffffffffULL;
}
lkb->lkb_range[RQ_RANGE_START] = args->range->ra_start;
lkb->lkb_range[RQ_RANGE_END] = args->range->ra_end;
lkb->lkb_flags |= DLM_IFL_RANGE;
rv = 0;
out:
return rv;
@ -1805,7 +1757,7 @@ static int _request_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
return error;
}
/* change some property of an existing lkb, e.g. mode, range */
/* change some property of an existing lkb, e.g. mode */
static int _convert_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
{
@ -1962,8 +1914,7 @@ int dlm_lock(dlm_lockspace_t *lockspace,
uint32_t parent_lkid,
void (*ast) (void *astarg),
void *astarg,
void (*bast) (void *astarg, int mode),
struct dlm_range *range)
void (*bast) (void *astarg, int mode))
{
struct dlm_ls *ls;
struct dlm_lkb *lkb;
@ -1985,7 +1936,7 @@ int dlm_lock(dlm_lockspace_t *lockspace,
goto out;
error = set_lock_args(mode, lksb, flags, namelen, parent_lkid, ast,
astarg, bast, range, &args);
astarg, bast, &args);
if (error)
goto out_put;
@ -2154,11 +2105,6 @@ static void send_args(struct dlm_rsb *r, struct dlm_lkb *lkb,
if (lkb->lkb_astaddr)
ms->m_asts |= AST_COMP;
if (lkb->lkb_range) {
ms->m_range[0] = lkb->lkb_range[RQ_RANGE_START];
ms->m_range[1] = lkb->lkb_range[RQ_RANGE_END];
}
if (ms->m_type == DLM_MSG_REQUEST || ms->m_type == DLM_MSG_LOOKUP)
memcpy(ms->m_extra, r->res_name, r->res_length);
@ -2402,20 +2348,6 @@ static int receive_extralen(struct dlm_message *ms)
return (ms->m_header.h_length - sizeof(struct dlm_message));
}
static int receive_range(struct dlm_ls *ls, struct dlm_lkb *lkb,
struct dlm_message *ms)
{
if (lkb->lkb_flags & DLM_IFL_RANGE) {
if (!lkb->lkb_range)
lkb->lkb_range = allocate_range(ls);
if (!lkb->lkb_range)
return -ENOMEM;
lkb->lkb_range[RQ_RANGE_START] = ms->m_range[0];
lkb->lkb_range[RQ_RANGE_END] = ms->m_range[1];
}
return 0;
}
static int receive_lvb(struct dlm_ls *ls, struct dlm_lkb *lkb,
struct dlm_message *ms)
{
@ -2445,9 +2377,6 @@ static int receive_request_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
DLM_ASSERT(is_master_copy(lkb), dlm_print_lkb(lkb););
if (receive_range(ls, lkb, ms))
return -ENOMEM;
if (receive_lvb(ls, lkb, ms))
return -ENOMEM;
@ -2470,13 +2399,6 @@ static int receive_convert_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
if (lkb->lkb_status != DLM_LKSTS_GRANTED)
return -EBUSY;
if (receive_range(ls, lkb, ms))
return -ENOMEM;
if (lkb->lkb_range) {
lkb->lkb_range[GR_RANGE_START] = 0LL;
lkb->lkb_range[GR_RANGE_END] = 0xffffffffffffffffULL;
}
if (receive_lvb(ls, lkb, ms))
return -ENOMEM;
@ -3476,13 +3398,6 @@ static int receive_rcom_lock_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
lkb->lkb_bastaddr = (void *) (long) (rl->rl_asts & AST_BAST);
lkb->lkb_astaddr = (void *) (long) (rl->rl_asts & AST_COMP);
if (lkb->lkb_flags & DLM_IFL_RANGE) {
lkb->lkb_range = allocate_range(ls);
if (!lkb->lkb_range)
return -ENOMEM;
memcpy(lkb->lkb_range, rl->rl_range, 4*sizeof(uint64_t));
}
if (lkb->lkb_exflags & DLM_LKF_VALBLK) {
lkb->lkb_lvbptr = allocate_lvb(ls);
if (!lkb->lkb_lvbptr)

16
fs/dlm/memory.c
View File

@ -50,22 +50,6 @@ void free_lvb(char *p)
kfree(p);
}
uint64_t *allocate_range(struct dlm_ls *ls)
{
int ralen = 4*sizeof(uint64_t);
uint64_t *p;
p = kmalloc(ralen, GFP_KERNEL);
if (p)
memset(p, 0, ralen);
return p;
}
void free_range(uint64_t *p)
{
kfree(p);
}
/* FIXME: have some minimal space built-in to rsb for the name and
kmalloc a separate name if needed, like dentries are done */

2
fs/dlm/memory.h
View File

@ -24,8 +24,6 @@ struct dlm_direntry *allocate_direntry(struct dlm_ls *ls, int namelen);
void free_direntry(struct dlm_direntry *de);
char *allocate_lvb(struct dlm_ls *ls);
void free_lvb(char *l);
uint64_t *allocate_range(struct dlm_ls *ls);
void free_range(uint64_t *l);
#endif /* __MEMORY_DOT_H__ */

3
fs/dlm/rcom.c
View File

@ -284,9 +284,6 @@ static void pack_rcom_lock(struct dlm_rsb *r, struct dlm_lkb *lkb,
if (lkb->lkb_astaddr)
rl->rl_asts |= AST_COMP;
if (lkb->lkb_range)
memcpy(rl->rl_range, lkb->lkb_range, 4*sizeof(uint64_t));
rl->rl_namelen = r->res_length;
memcpy(rl->rl_name, r->res_name, r->res_length);

12
fs/dlm/util.c
View File

@ -54,8 +54,6 @@ void dlm_message_out(struct dlm_message *ms)
ms->m_bastmode = cpu_to_le32(ms->m_bastmode);
ms->m_asts = cpu_to_le32(ms->m_asts);
ms->m_result = cpu_to_le32(ms->m_result);
ms->m_range[0] = cpu_to_le64(ms->m_range[0]);
ms->m_range[1] = cpu_to_le64(ms->m_range[1]);
}
void dlm_message_in(struct dlm_message *ms)
@ -82,8 +80,6 @@ void dlm_message_in(struct dlm_message *ms)
ms->m_bastmode = le32_to_cpu(ms->m_bastmode);
ms->m_asts = le32_to_cpu(ms->m_asts);
ms->m_result = le32_to_cpu(ms->m_result);
ms->m_range[0] = le64_to_cpu(ms->m_range[0]);
ms->m_range[1] = le64_to_cpu(ms->m_range[1]);
}
static void rcom_lock_out(struct rcom_lock *rl)
@ -99,10 +95,6 @@ static void rcom_lock_out(struct rcom_lock *rl)
rl->rl_result = cpu_to_le32(rl->rl_result);
rl->rl_wait_type = cpu_to_le16(rl->rl_wait_type);
rl->rl_namelen = cpu_to_le16(rl->rl_namelen);
rl->rl_range[0] = cpu_to_le64(rl->rl_range[0]);
rl->rl_range[1] = cpu_to_le64(rl->rl_range[1]);
rl->rl_range[2] = cpu_to_le64(rl->rl_range[2]);
rl->rl_range[3] = cpu_to_le64(rl->rl_range[3]);
}
static void rcom_lock_in(struct rcom_lock *rl)
@ -118,10 +110,6 @@ static void rcom_lock_in(struct rcom_lock *rl)
rl->rl_result = le32_to_cpu(rl->rl_result);
rl->rl_wait_type = le16_to_cpu(rl->rl_wait_type);
rl->rl_namelen = le16_to_cpu(rl->rl_namelen);
rl->rl_range[0] = le64_to_cpu(rl->rl_range[0]);
rl->rl_range[1] = le64_to_cpu(rl->rl_range[1]);
rl->rl_range[2] = le64_to_cpu(rl->rl_range[2]);
rl->rl_range[3] = le64_to_cpu(rl->rl_range[3]);
}
static void rcom_config_out(struct rcom_config *rf)

12
include/linux/dlm.h
View File

@ -159,15 +159,6 @@
typedef void dlm_lockspace_t;
/*
* Lock range structure
*/
struct dlm_range {
uint64_t ra_start;
uint64_t ra_end;
};
/*
* Lock status block
*
@ -277,8 +268,7 @@ int dlm_lock(dlm_lockspace_t *lockspace,
uint32_t parent_lkid,
void (*lockast) (void *astarg),
void *astarg,
void (*bast) (void *astarg, int mode),
struct dlm_range *range);
void (*bast) (void *astarg, int mode));
/*
* dlm_unlock

3
include/linux/dlm_device.h
View File

@ -18,7 +18,7 @@
#define DLM_USER_LVB_LEN 32
/* Version of the device interface */
#define DLM_DEVICE_VERSION_MAJOR 3
#define DLM_DEVICE_VERSION_MAJOR 4
#define DLM_DEVICE_VERSION_MINOR 0
#define DLM_DEVICE_VERSION_PATCH 0
@ -28,7 +28,6 @@ struct dlm_lock_params {
__u16 flags;
__u32 lkid;
__u32 parent;
struct dlm_range range;
__u8 namelen;
void __user *castparam;
void __user *castaddr;