[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>

diff --git a/fs/dlm/debug_fs.c b/fs/dlm/debug_fs.c
index 5080bbffd586a7d3feb92a1a573c2007f674de05..49deca845dbaf66ffd7091653436796085ff195c 100644 (file)
--- a/fs/dlm/debug_fs.c
+++ b/fs/dlm/debug_fs.c
@@ -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,

diff --git a/fs/dlm/device.c b/fs/dlm/device.c
index 899d4f92a4d714abd9ff87746bfe990260da0563..99d8b6b07fbafcad3b0178c273060e1f127144ba 100644 (file)
--- a/fs/dlm/device.c
+++ b/fs/dlm/device.c
@@ -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;
 

diff --git a/fs/dlm/dlm_internal.h b/fs/dlm/dlm_internal.h
index 16f20cfd9197c9ea3e45adbc99271789ff64f45d..c3299020c8f318423175c30e4dc713c844d4789e 100644 (file)
--- a/fs/dlm/dlm_internal.h
+++ b/fs/dlm/dlm_internal.h
@@ -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];
 };

diff --git a/fs/dlm/lock.c b/fs/dlm/lock.c
index 29d3b95dbb63699224eaaeb53d70d31ed2e2e45a..80487703d58210d2eb09f019791a9d68003b3f21 100644 (file)
--- a/fs/dlm/lock.c
+++ b/fs/dlm/lock.c
@@ -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)

diff --git a/fs/dlm/memory.c b/fs/dlm/memory.c
index 0b9851d0bdb2d926487b420f3e87bea4d7881913..f7cf4589fae8fca03d5d5afeeedb4e26328b9fb8 100644 (file)
--- a/fs/dlm/memory.c
+++ b/fs/dlm/memory.c
@@ -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 */
 

diff --git a/fs/dlm/memory.h b/fs/dlm/memory.h
index 7b235132b0b437caa9fc0847afb7bc7c5ab89e5c..6ead158ccc5c661cb4138bfd756bb05d69382989 100644 (file)
--- a/fs/dlm/memory.h
+++ b/fs/dlm/memory.h
@@ -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__ */
 

diff --git a/fs/dlm/rcom.c b/fs/dlm/rcom.c
index 4c5c08a8860e927a0488e6a038d0f60f68abb8ea..55fbe313340e59a212788ba5cefedd92ded4a6c6 100644 (file)
--- a/fs/dlm/rcom.c
+++ b/fs/dlm/rcom.c
@@ -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);
 

diff --git a/fs/dlm/util.c b/fs/dlm/util.c
index 826d122edf559bb055f44a60a43d93241100a78d..767197db994404749e6411eb2eebf1158ad44de6 100644 (file)
--- a/fs/dlm/util.c
+++ b/fs/dlm/util.c
@@ -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)

diff --git a/include/linux/dlm.h b/include/linux/dlm.h
index dd324ba44d80045b260f65cf4dadb9b53540c1d5..1b1dcb9a40bbab9facb21a13ece1cb23cab28534 100644 (file)
--- a/include/linux/dlm.h
+++ b/include/linux/dlm.h
@@ -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

diff --git a/include/linux/dlm_device.h b/include/linux/dlm_device.h
index 5e17d295544b3c69366befeb12bf90fb5ef5fa07..f8ba1981aa96cf70e58532c155f377dc2e374bbb 100644 (file)
--- a/include/linux/dlm_device.h
+++ b/include/linux/dlm_device.h
@@ -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;