LU-11164 ldlm: pass env to lvbo methods

[fs/lustre-release.git] / lustre / ldlm / ldlm_lockd.c

diff --git a/lustre/ldlm/ldlm_lockd.c b/lustre/ldlm/ldlm_lockd.c
index c0b4edc..21a3c96 100644 (file)
--- a/lustre/ldlm/ldlm_lockd.c
+++ b/lustre/ldlm/ldlm_lockd.c
@@ -633,7 +633,8 @@ static void ldlm_failed_ast(struct ldlm_lock *lock, int rc,
 /**
  * Perform lock cleanup if AST reply came with error.
  */
-static int ldlm_handle_ast_error(struct ldlm_lock *lock,
+static int ldlm_handle_ast_error(const struct lu_env *env,
+                                struct ldlm_lock *lock,
                                 struct ptlrpc_request *req, int rc,
                                 const char *ast_type)
 {
@@ -692,7 +693,7 @@ static int ldlm_handle_ast_error(struct ldlm_lock *lock,
                        /* update lvbo to return proper attributes.
                         * see bug 23174 */
                        ldlm_resource_getref(res);
-                       ldlm_lvbo_update(res, lock, NULL, 1);
+                       ldlm_lvbo_update(env, res, lock, NULL, 1);
                        ldlm_resource_putref(res);
                }
                ldlm_lock_cancel(lock);
@@ -727,20 +728,24 @@ static int ldlm_cb_interpret(const struct lu_env *env,
                } else if (rc == -ELDLM_NO_LOCK_DATA) {
                        LDLM_DEBUG(lock, "lost race - client has a lock but no "
                                   "inode");
-                       ldlm_lvbo_update(lock->l_resource, lock, NULL, 1);
+                       ldlm_lvbo_update(env, lock->l_resource, lock, NULL, 1);
                } else if (rc != 0) {
-                       rc = ldlm_handle_ast_error(lock, req, rc, "glimpse");
+                       rc = ldlm_handle_ast_error(env, lock, req,
+                                                  rc, "glimpse");
                } else {
-                       rc = ldlm_lvbo_update(lock->l_resource, lock, req, 1);
+                       rc = ldlm_lvbo_update(env, lock->l_resource,
+                                             lock, req, 1);
                }
                break;
        case LDLM_BL_CALLBACK:
                if (rc != 0)
-                       rc = ldlm_handle_ast_error(lock, req, rc, "blocking");
+                       rc = ldlm_handle_ast_error(env, lock, req,
+                                                  rc, "blocking");
                break;
        case LDLM_CP_CALLBACK:
                if (rc != 0)
-                       rc = ldlm_handle_ast_error(lock, req, rc, "completion");
+                       rc = ldlm_handle_ast_error(env, lock, req,
+                                                  rc, "completion");
                break;
        default:
                LDLM_ERROR(lock, "invalid opcode for lock callback %d",
@@ -988,8 +993,12 @@ int ldlm_server_completion_ast(struct ldlm_lock *lock, __u64 flags, void *data)
         ldlm_lock2desc(lock, &body->lock_desc);
        if (lvb_len > 0) {
                void *lvb = req_capsule_client_get(&req->rq_pill, &RMF_DLM_LVB);
+               const struct lu_env *env = NULL;
 
-               lvb_len = ldlm_lvbo_fill(lock, lvb, lvb_len);
+               if (req->rq_svc_thread)
+                       env = req->rq_svc_thread->t_env;
+
+               lvb_len = ldlm_lvbo_fill(env, lock, lvb, lvb_len);
                if (lvb_len < 0) {
                        /* We still need to send the RPC to wake up the blocked
                         * enqueue thread on the client.
@@ -1174,6 +1183,7 @@ int ldlm_handle_enqueue0(struct ldlm_namespace *ns,
        void *cookie = NULL;
        int rc = 0;
        struct ldlm_resource *res = NULL;
+       const struct lu_env *env = req->rq_svc_thread->t_env;
        ENTRY;
 
        LDLM_DEBUG_NOLOCK("server-side enqueue handler START");
@@ -1254,7 +1264,7 @@ int ldlm_handle_enqueue0(struct ldlm_namespace *ns,
        res = lock->l_resource;
        if (!(flags & LDLM_FL_REPLAY)) {
                /* non-replayed lock, delayed lvb init may need to be done */
-               rc = ldlm_lvbo_init(res);
+               rc = ldlm_lvbo_init(env, res);
                if (rc < 0) {
                        LDLM_DEBUG(lock, "delayed lvb init failed (rc %d)", rc);
                        GOTO(out, rc);
@@ -1302,25 +1312,25 @@ existing_lock:
                req_capsule_set_size(&req->rq_pill, &RMF_DLM_LVB,
                                     RCL_SERVER, ldlm_lvbo_size(lock));
 
-                if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_ENQUEUE_EXTENT_ERR))
-                        GOTO(out, rc = -ENOMEM);
+               if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_ENQUEUE_EXTENT_ERR))
+                       GOTO(out, rc = -ENOMEM);
 
-                rc = req_capsule_server_pack(&req->rq_pill);
-                if (rc)
-                        GOTO(out, rc);
-        }
+               rc = req_capsule_server_pack(&req->rq_pill);
+               if (rc)
+                       GOTO(out, rc);
+       }
 
-       err = ldlm_lock_enqueue(ns, &lock, cookie, &flags);
+       err = ldlm_lock_enqueue(env, ns, &lock, cookie, &flags);
        if (err) {
                if ((int)err < 0)
                        rc = (int)err;
                GOTO(out, err);
        }
 
-        dlm_rep = req_capsule_server_get(&req->rq_pill, &RMF_DLM_REP);
+       dlm_rep = req_capsule_server_get(&req->rq_pill, &RMF_DLM_REP);
 
-        ldlm_lock2desc(lock, &dlm_rep->lock_desc);
-        ldlm_lock2handle(lock, &dlm_rep->lock_handle);
+       ldlm_lock2desc(lock, &dlm_rep->lock_desc);
+       ldlm_lock2handle(lock, &dlm_rep->lock_handle);
 
        if (lock && lock->l_resource->lr_type == LDLM_EXTENT)
                OBD_FAIL_TIMEOUT(OBD_FAIL_LDLM_BL_EVICT, 6);
@@ -1410,7 +1420,7 @@ existing_lock:
                                /* non-replayed lock, delayed lvb init may
                                 * need to be occur now */
                                if ((buflen > 0) && !(flags & LDLM_FL_REPLAY)) {
-                                       buflen = ldlm_lvbo_fill(lock, buf,
+                                       buflen = ldlm_lvbo_fill(env, lock, buf,
                                                                buflen);
                                        if (buflen >= 0)
                                                req_capsule_shrink(
@@ -1550,6 +1560,7 @@ int ldlm_request_cancel(struct ptlrpc_request *req,
                        const struct ldlm_request *dlm_req,
                        int first, enum lustre_at_flags flags)
 {
+       const struct lu_env *env = req->rq_svc_thread->t_env;
         struct ldlm_resource *res, *pres = NULL;
         struct ldlm_lock *lock;
         int i, count, done = 0;
@@ -1591,15 +1602,16 @@ int ldlm_request_cancel(struct ptlrpc_request *req,
                                 LDLM_RESOURCE_DELREF(pres);
                                 ldlm_resource_putref(pres);
                         }
-                        if (res != NULL) {
-                                ldlm_resource_getref(res);
-                                LDLM_RESOURCE_ADDREF(res);
+                       if (res != NULL) {
+                               ldlm_resource_getref(res);
+                               LDLM_RESOURCE_ADDREF(res);
 
                                if (!ldlm_is_discard_data(lock))
-                                       ldlm_lvbo_update(res, lock, NULL, 1);
-                        }
-                        pres = res;
-                }
+                                       ldlm_lvbo_update(env, res, lock,
+                                                        NULL, 1);
+                       }
+                       pres = res;
+               }
 
                if ((flags & LATF_STATS) && ldlm_is_ast_sent(lock) &&
                    lock->l_blast_sent != 0) {