handful of conflict-causing DLM changes

diff --git a/lustre/include/linux/lustre_dlm.h b/lustre/include/linux/lustre_dlm.h
index cabe734..673775a 100644 (file)
--- a/lustre/include/linux/lustre_dlm.h
+++ b/lustre/include/linux/lustre_dlm.h
@@ -30,9 +30,8 @@ typedef enum {
 #define LDLM_FL_BLOCK_GRANTED  (1 << 1)
 #define LDLM_FL_BLOCK_CONV     (1 << 2)
 #define LDLM_FL_BLOCK_WAIT     (1 << 3)
-#define LDLM_FL_DYING          (1 << 4)
+#define LDLM_FL_CBPENDING      (1 << 4)
 #define LDLM_FL_AST_SENT       (1 << 5)
-#define LDLM_FL_BLOCKED_PENDING (1 << 6)
 
 #define L2B(c) (1 << c)
 
@@ -100,9 +99,9 @@ struct ldlm_namespace {
 
 struct ldlm_lock;
 
-typedef int (*ldlm_lock_callback)(struct ldlm_lock *lock, struct ldlm_lock *new,
-                                  void *data, __u32 data_len,
-                                  struct ptlrpc_request **req);
+typedef int (*ldlm_lock_callback)(struct ldlm_lock *lock,
+                                  struct ldlm_lock_desc *new, void *data,
+                                  __u32 data_len, struct ptlrpc_request **req);
 
 struct ldlm_lock {
         struct ldlm_resource *l_resource;
@@ -200,29 +199,28 @@ int ldlm_extent_compat(struct ldlm_lock *, struct ldlm_lock *);
 int ldlm_extent_policy(struct ldlm_lock *, void *, ldlm_mode_t, void *);
 
 /* ldlm_lock.c */
+struct ldlm_lock *ldlm_handle2lock(struct lustre_handle *handle);
+void ldlm_lock_put(struct ldlm_lock *lock);
 void ldlm_lock_free(struct ldlm_lock *lock);
 void ldlm_lock2desc(struct ldlm_lock *lock, struct ldlm_lock_desc *desc);
 void ldlm_lock_addref(struct ldlm_lock *lock, __u32 mode);
 void ldlm_lock_decref(struct ldlm_lock *lock, __u32 mode);
-void ldlm_grant_lock(struct ldlm_resource *res, struct ldlm_lock *lock);
-int ldlm_local_lock_match(struct ldlm_namespace *ns, __u64 *res_id, __u32 type,
-                          void *cookie, int cookielen, ldlm_mode_t mode,
-                          struct lustre_handle *lockh);
-ldlm_error_t ldlm_local_lock_create(struct ldlm_namespace *ns,
-                                    struct lustre_handle *parent_lock_handle,
-                                    __u64 *res_id, __u32 type,
-                                     ldlm_mode_t mode,
-                                    void *data,
-                                    __u32 data_len,
-                                    struct lustre_handle *lockh);
-ldlm_error_t ldlm_local_lock_enqueue(struct lustre_handle *lockh,
-                                     void *cookie, int cookie_len,
-                                     int *flags,
-                                     ldlm_lock_callback completion,
-                                     ldlm_lock_callback blocking);
-struct ldlm_resource *ldlm_local_lock_convert(struct lustre_handle *lockh,
-                                              int new_mode, int *flags);
-struct ldlm_resource *ldlm_local_lock_cancel(struct ldlm_lock *lock);
+void ldlm_grant_lock(struct ldlm_lock *lock);
+int ldlm_match(struct ldlm_namespace *ns, __u64 *res_id, __u32 type,
+               void *cookie, int cookielen, ldlm_mode_t mode,
+               struct lustre_handle *lockh);
+struct ldlm_lock *
+ldlm_lock_create(struct ldlm_namespace *ns,
+                 struct lustre_handle *parent_lock_handle,
+                 __u64 *res_id, __u32 type, ldlm_mode_t mode, void *data,
+                 __u32 data_len);
+ldlm_error_t ldlm_lock_enqueue(struct ldlm_lock *lock, void *cookie,
+                               int cookie_len, int *flags,
+                               ldlm_lock_callback completion,
+                               ldlm_lock_callback blocking);
+struct ldlm_resource *ldlm_lock_convert(struct ldlm_lock *lock, int new_mode,
+                                        int *flags);
+struct ldlm_resource *ldlm_lock_cancel(struct ldlm_lock *lock);
 void ldlm_reprocess_all(struct ldlm_resource *res);
 void ldlm_lock_dump(struct ldlm_lock *lock);
 
@@ -244,6 +242,7 @@ void ldlm_resource_add_lock(struct ldlm_resource *res, struct list_head *head,
 void ldlm_resource_del_lock(struct ldlm_lock *lock);
 void ldlm_res2desc(struct ldlm_resource *res, struct ldlm_resource_desc *desc);
 void ldlm_resource_dump(struct ldlm_resource *res);
+int ldlm_lock_change_resource(struct ldlm_lock *lock, __u64 new_resid[3]);
 
 /* ldlm_request.c */
 int ldlm_cli_enqueue(struct ptlrpc_client *cl, 

diff --git a/lustre/ldlm/ldlm_lockd.c b/lustre/ldlm/ldlm_lockd.c
index 5bb4a37..da992b6 100644 (file)
--- a/lustre/ldlm/ldlm_lockd.c
+++ b/lustre/ldlm/ldlm_lockd.c
@@ -30,7 +30,6 @@ static int ldlm_handle_enqueue(struct obd_device *obddev, struct ptlrpc_service
         __u32 flags;
         ldlm_error_t err;
         struct ldlm_lock *lock = NULL;
-        struct lustre_handle lockh;
         void *cookie = NULL;
         ENTRY;
 
@@ -110,7 +109,6 @@ static int ldlm_handle_convert(struct ptlrpc_service *svc, struct ptlrpc_request
 {
         struct ldlm_request *dlm_req;
         struct ldlm_reply *dlm_rep;
-        struct ldlm_resource *res;
         struct ldlm_lock *lock;
         int rc, size = sizeof(*dlm_rep);
         ENTRY;
@@ -137,7 +135,7 @@ static int ldlm_handle_convert(struct ptlrpc_service *svc, struct ptlrpc_request
         if (ptlrpc_reply(svc, req) != 0)
                 LBUG();
 
-        ldlm_reprocess_all(lock->res);
+        ldlm_reprocess_all(lock->l_resource);
         ldlm_lock_put(lock); 
         LDLM_DEBUG(lock, "server-side convert handler END");
 
@@ -148,7 +146,6 @@ static int ldlm_handle_cancel(struct ptlrpc_service *svc, struct ptlrpc_request
 {
         struct ldlm_request *dlm_req;
         struct ldlm_lock *lock;
-        struct ldlm_resource *res;
         int rc;
         ENTRY;
 
@@ -172,7 +169,7 @@ static int ldlm_handle_cancel(struct ptlrpc_service *svc, struct ptlrpc_request
                 LBUG();
 
         ldlm_reprocess_all(lock->l_resource);
-        ldlm_lock_put(put);
+        ldlm_lock_put(lock);
         LDLM_DEBUG_NOLOCK("server-side cancel handler END");
 
         RETURN(0);
@@ -212,12 +209,12 @@ static int ldlm_handle_callback(struct ptlrpc_service *svc,
 
         if (!lock) { 
                 CERROR("callback on lock %Lx - lock disappeared\n", 
-                       dlm_req->lock_handle.addr);
+                       dlm_req->lock_handle1.addr);
                 RETURN(0);
         }
 
         LDLM_DEBUG(lock, "client %s callback handler START",
-                   new == NULL ? "completion" : "blocked");
+                   is_blocking_ast ? "blocked" : "completion");
 
         if (is_blocking_ast) {
                 int do_ast; 
@@ -299,7 +296,7 @@ static int lustre_handle(struct obd_device *dev, struct ptlrpc_service *svc,
         case LDLM_CANCEL:
                 CDEBUG(D_INODE, "cancel\n");
                 OBD_FAIL_RETURN(OBD_FAIL_LDLM_CANCEL, 0);
-                rc = ldlm_hanel_cancel(svc, req);
+                rc = ldlm_handle_cancel(svc, req);
                 break;
 
         case LDLM_CALLBACK:

diff --git a/lustre/ldlm/ldlm_test.c b/lustre/ldlm/ldlm_test.c
index 633df30..c763090 100644 (file)
--- a/lustre/ldlm/ldlm_test.c
+++ b/lustre/ldlm/ldlm_test.c
@@ -24,7 +24,8 @@ static spinlock_t ctl_lock = SPIN_LOCK_UNLOCKED;
 static struct list_head ctl_threads;
 static int regression_running = 0;
 
-static int ldlm_test_callback(struct ldlm_lock *lock, struct ldlm_lock *new,
+static int ldlm_test_callback(struct ldlm_lock *lock,
+                              struct ldlm_lock_desc *new,
                               void *data, __u32 data_len,
                               struct ptlrpc_request **reqp)
 {
@@ -38,24 +39,26 @@ int ldlm_test_basics(struct obd_device *obddev)
         struct ldlm_resource *res;
         __u64 res_id[RES_NAME_SIZE] = {1, 2, 3};
         ldlm_error_t err;
-        struct lustre_handle lockh_1, lockh_2;
+        struct ldlm_lock *lock1, *lock;
         int flags;
 
         ns = ldlm_namespace_new("test_server", LDLM_NAMESPACE_SERVER);
         if (ns == NULL)
                 LBUG();
 
-        err = ldlm_local_lock_create(ns, NULL, res_id, LDLM_PLAIN, LCK_CR,
-                                     NULL, 0, &lockh_1);
-        err = ldlm_local_lock_enqueue(&lockh_1, NULL, 0, &flags,
-                                      ldlm_test_callback, ldlm_test_callback);
+        lock1 = ldlm_lock_create(ns, NULL, res_id, LDLM_PLAIN, LCK_CR, NULL, 0);
+        if (lock1 == NULL)
+                LBUG();
+        err = ldlm_lock_enqueue(lock1, NULL, 0, &flags,
+                                ldlm_test_callback, ldlm_test_callback);
         if (err != ELDLM_OK)
                 LBUG();
 
-        err = ldlm_local_lock_create(ns, NULL, res_id, LDLM_PLAIN, LCK_EX,
-                                     NULL, 0, &lockh_2);
-        err = ldlm_local_lock_enqueue(&lockh_2, NULL, 0, &flags,
-                                      ldlm_test_callback, ldlm_test_callback);
+        lock = ldlm_lock_create(ns, NULL, res_id, LDLM_PLAIN, LCK_EX, NULL, 0);
+        if (lock == NULL)
+                LBUG();
+        err = ldlm_lock_enqueue(lock, NULL, 0, &flags,
+                                ldlm_test_callback, ldlm_test_callback);
         if (err != ELDLM_OK)
                 LBUG();
         if (!(flags & LDLM_FL_BLOCK_GRANTED))
@@ -66,7 +69,7 @@ int ldlm_test_basics(struct obd_device *obddev)
                 LBUG();
         ldlm_resource_dump(res);
 
-        res = ldlm_local_lock_convert(&lockh_1, LCK_NL, &flags);
+        res = ldlm_lock_convert(lock1, LCK_NL, &flags);
         if (res != NULL)
                 ldlm_reprocess_all(res);
 
@@ -80,10 +83,9 @@ int ldlm_test_extents(struct obd_device *obddev)
 {
         struct ldlm_namespace *ns;
         struct ldlm_resource *res;
-        struct ldlm_lock *lock;
+        struct ldlm_lock *lock, *lock1, *lock2;
         __u64 res_id[RES_NAME_SIZE] = {0, 0, 0};
         struct ldlm_extent ext1 = {4, 6}, ext2 = {6, 9}, ext3 = {10, 11};
-        struct lustre_handle ext1_h, ext2_h, ext3_h;
         ldlm_error_t err;
         int flags;
 
@@ -92,30 +94,31 @@ int ldlm_test_extents(struct obd_device *obddev)
                 LBUG();
 
         flags = 0;
-        err = ldlm_local_lock_create(ns, NULL, res_id, LDLM_EXTENT, LCK_PR,
-                                     NULL, 0, &ext1_h);
-        err = ldlm_local_lock_enqueue(&ext1_h, &ext1, sizeof(ext1), &flags,
-                                      NULL, NULL);
+        lock1 = ldlm_lock_create(ns, NULL, res_id, LDLM_EXTENT, LCK_PR, NULL,
+                                 0);
+        if (lock1 == NULL)
+                LBUG();
+        err = ldlm_lock_enqueue(lock1, &ext1, sizeof(ext1), &flags, NULL, NULL);
         if (err != ELDLM_OK)
                 LBUG();
         if (!(flags & LDLM_FL_LOCK_CHANGED))
                 LBUG();
 
         flags = 0;
-        err = ldlm_local_lock_create(ns, NULL, res_id, LDLM_EXTENT, LCK_PR,
-                                     NULL, 0, &ext2_h);
-        err = ldlm_local_lock_enqueue(&ext2_h, &ext2, sizeof(ext2), &flags,
-                                      NULL, NULL);
+        lock2 = ldlm_lock_create(ns, NULL, res_id, LDLM_EXTENT, LCK_PR,
+                                NULL, 0);
+        err = ldlm_lock_enqueue(lock2, &ext2, sizeof(ext2), &flags, NULL, NULL);
         if (err != ELDLM_OK)
                 LBUG();
         if (!(flags & LDLM_FL_LOCK_CHANGED))
                 LBUG();
 
         flags = 0;
-        err = ldlm_local_lock_create(ns, NULL, res_id, LDLM_EXTENT, LCK_EX,
-                                     NULL, 0, &ext3_h);
-        err = ldlm_local_lock_enqueue(&ext3_h, &ext3, sizeof(ext3), &flags,
-                                      NULL, NULL);
+        lock = ldlm_lock_create(ns, NULL, res_id, LDLM_EXTENT, LCK_EX, NULL, 0);
+        if (lock == NULL)
+                LBUG();
+        err = ldlm_lock_enqueue(lock, &ext3, sizeof(ext3), &flags,
+                                NULL, NULL);
         if (err != ELDLM_OK)
                 LBUG();
         if (!(flags & LDLM_FL_BLOCK_GRANTED))
@@ -125,13 +128,11 @@ int ldlm_test_extents(struct obd_device *obddev)
 
         /* Convert/cancel blocking locks */
         flags = 0;
-        res = ldlm_local_lock_convert(&ext1_h, LCK_NL, &flags);
+        res = ldlm_convert(lock1, LCK_NL, &flags);
         if (res != NULL)
                 ldlm_reprocess_all(res);
 
-        flags = 0;
-        lock = lustre_handle2object(&ext2_h);
-        res = ldlm_local_lock_cancel(lock);
+        res = ldlm_cancel(lock2);
         if (res != NULL)
                 ldlm_reprocess_all(res);