b=18551 wrapper functions for ldlm->namespace & res->namespace

bug 18551 attachment 31642

o=zhen.liang
i=oleg.drokin
i=andreas.dilger

diff --git a/lustre/include/lustre_dlm.h b/lustre/include/lustre_dlm.h
index bf0d9f8..161d55f 100644 (file)
--- a/lustre/include/lustre_dlm.h
+++ b/lustre/include/lustre_dlm.h
@@ -789,6 +789,30 @@ struct ldlm_resource {
         struct inode          *lr_lvb_inode;
 };
 
+static inline struct ldlm_namespace *
+ldlm_res_to_ns(struct ldlm_resource *res)
+{
+        return res->lr_namespace;
+}
+
+static inline struct ldlm_namespace *
+ldlm_lock_to_ns(struct ldlm_lock *lock)
+{
+        return ldlm_res_to_ns(lock->l_resource);
+}
+
+static inline char *
+ldlm_lock_to_ns_name(struct ldlm_lock *lock)
+{
+        return ldlm_lock_to_ns(lock)->ns_name;
+}
+
+static inline struct adaptive_timeout *
+ldlm_lock_to_ns_at(struct ldlm_lock *lock)
+{
+        return &ldlm_lock_to_ns(lock)->ns_at_estimate;
+}
+
 struct ldlm_ast_work {
         struct ldlm_lock      *w_lock;
         int                    w_blocking;
@@ -943,10 +967,10 @@ ldlm_handle2lock_long(const struct lustre_handle *h, int flags)
 static inline int ldlm_res_lvbo_update(struct ldlm_resource *res,
                                        struct ptlrpc_request *r, int increase)
 {
-        if (res->lr_namespace->ns_lvbo &&
-            res->lr_namespace->ns_lvbo->lvbo_update) {
-                return res->lr_namespace->ns_lvbo->lvbo_update(res, r,
-                                                               increase);
+        if (ldlm_res_to_ns(res)->ns_lvbo &&
+            ldlm_res_to_ns(res)->ns_lvbo->lvbo_update) {
+                return ldlm_res_to_ns(res)->ns_lvbo->lvbo_update(res, r,
+                                                                 increase);
         }
         return 0;
 }

diff --git a/lustre/ldlm/l_lock.c b/lustre/ldlm/l_lock.c
index ce2bdad..0d21d24 100644 (file)
--- a/lustre/ldlm/l_lock.c
+++ b/lustre/ldlm/l_lock.c
@@ -57,7 +57,7 @@ struct ldlm_resource * lock_res_and_lock(struct ldlm_lock *lock)
         cfs_spin_lock(&lock->l_lock);
         res = lock->l_resource;
 
-        if (ns_is_server(res->lr_namespace))
+        if (ns_is_server(ldlm_res_to_ns(res)))
                 /* on server-side resource of lock doesn't change */
                 cfs_spin_unlock(&lock->l_lock);
 
@@ -69,7 +69,7 @@ void unlock_res_and_lock(struct ldlm_lock *lock)
 {
         struct ldlm_resource *res = lock->l_resource;
 
-        if (ns_is_server(res->lr_namespace)) {
+        if (ns_is_server(ldlm_res_to_ns(res))) {
                 /* on server-side resource of lock doesn't change */
                 unlock_res(res);
                 return;

diff --git a/lustre/ldlm/ldlm_extent.c b/lustre/ldlm/ldlm_extent.c
index 1c504a1..a8aa5ec 100644 (file)
--- a/lustre/ldlm/ldlm_extent.c
+++ b/lustre/ldlm/ldlm_extent.c
@@ -289,10 +289,10 @@ static int ldlm_check_contention(struct ldlm_lock *lock, int contended_locks)
                 return 1;
 
         CDEBUG(D_DLMTRACE, "contended locks = %d\n", contended_locks);
-        if (contended_locks > res->lr_namespace->ns_contended_locks)
+        if (contended_locks > ldlm_res_to_ns(res)->ns_contended_locks)
                 res->lr_contention_time = now;
         return cfs_time_before(now, cfs_time_add(res->lr_contention_time,
-                cfs_time_seconds(res->lr_namespace->ns_contention_time)));
+                cfs_time_seconds(ldlm_res_to_ns(res)->ns_contention_time)));
 }
 
 struct ldlm_extent_compat_args {
@@ -600,7 +600,7 @@ ldlm_extent_compat_queue(cfs_list_t *queue, struct ldlm_lock *req,
             (*flags & LDLM_FL_DENY_ON_CONTENTION) &&
             req->l_req_mode != LCK_GROUP &&
             req_end - req_start <=
-            req->l_resource->lr_namespace->ns_max_nolock_size)
+            ldlm_res_to_ns(req->l_resource)->ns_max_nolock_size)
                 GOTO(destroylock, compat = -EUSERS);
 
         RETURN(compat);
@@ -711,7 +711,7 @@ int ldlm_process_extent_lock(struct ldlm_lock *lock, int *flags, int first_enq,
                 rc = ldlm_run_ast_work(&rpc_list, LDLM_WORK_BL_AST);
 
                 if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_OST_FAIL_RACE) &&
-                    !ns_is_client(res->lr_namespace))
+                    !ns_is_client(ldlm_res_to_ns(res)))
                         class_fail_export(lock->l_export);
  
                 lock_res(res);

diff --git a/lustre/ldlm/ldlm_flock.c b/lustre/ldlm/ldlm_flock.c
index 9b24bed..d22e99e 100644 (file)
--- a/lustre/ldlm/ldlm_flock.c
+++ b/lustre/ldlm/ldlm_flock.c
@@ -158,7 +158,7 @@ ldlm_process_flock_lock(struct ldlm_lock *req, int *flags, int first_enq,
                         ldlm_error_t *err, cfs_list_t *work_list)
 {
         struct ldlm_resource *res = req->l_resource;
-        struct ldlm_namespace *ns = res->lr_namespace;
+        struct ldlm_namespace *ns = ldlm_res_to_ns(res);
         cfs_list_t *tmp;
         cfs_list_t *ownlocks = NULL;
         struct ldlm_lock *lock = NULL;
@@ -652,7 +652,7 @@ int ldlm_flock_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc,
         LASSERT(lock);
         LASSERT(flag == LDLM_CB_CANCELING);
 
-        ns = lock->l_resource->lr_namespace;
+        ns = ldlm_lock_to_ns(lock);
 
         /* take lock off the deadlock detection waitq. */
         cfs_spin_lock(&ldlm_flock_waitq_lock);

diff --git a/lustre/ldlm/ldlm_lock.c b/lustre/ldlm/ldlm_lock.c
index 91be27b..88aacc8 100644 (file)
--- a/lustre/ldlm/ldlm_lock.c
+++ b/lustre/ldlm/ldlm_lock.c
@@ -159,7 +159,7 @@ void ldlm_lock_put(struct ldlm_lock *lock)
                 LASSERT(cfs_list_empty(&lock->l_res_link));
                 LASSERT(cfs_list_empty(&lock->l_pending_chain));
 
-                cfs_atomic_dec(&res->lr_namespace->ns_locks);
+                cfs_atomic_dec(&ldlm_res_to_ns(res)->ns_locks);
                 lu_ref_del(&res->lr_reference, "lock", lock);
                 ldlm_resource_putref(res);
                 lock->l_resource = NULL;
@@ -184,7 +184,8 @@ int ldlm_lock_remove_from_lru_nolock(struct ldlm_lock *lock)
 {
         int rc = 0;
         if (!cfs_list_empty(&lock->l_lru)) {
-                struct ldlm_namespace *ns = lock->l_resource->lr_namespace;
+                struct ldlm_namespace *ns = ldlm_lock_to_ns(lock);
+
                 LASSERT(lock->l_resource->lr_type != LDLM_FLOCK);
                 cfs_list_del_init(&lock->l_lru);
                 if (lock->l_flags & LDLM_FL_SKIPPED)
@@ -198,8 +199,9 @@ int ldlm_lock_remove_from_lru_nolock(struct ldlm_lock *lock)
 
 int ldlm_lock_remove_from_lru(struct ldlm_lock *lock)
 {
-        struct ldlm_namespace *ns = lock->l_resource->lr_namespace;
+        struct ldlm_namespace *ns = ldlm_lock_to_ns(lock);
         int rc;
+
         ENTRY;
         cfs_spin_lock(&ns->ns_unused_lock);
         rc = ldlm_lock_remove_from_lru_nolock(lock);
@@ -210,7 +212,8 @@ int ldlm_lock_remove_from_lru(struct ldlm_lock *lock)
 
 void ldlm_lock_add_to_lru_nolock(struct ldlm_lock *lock)
 {
-        struct ldlm_namespace *ns = lock->l_resource->lr_namespace;
+        struct ldlm_namespace *ns = ldlm_lock_to_ns(lock);
+
         lock->l_last_used = cfs_time_current();
         LASSERT(cfs_list_empty(&lock->l_lru));
         LASSERT(lock->l_resource->lr_type != LDLM_FLOCK);
@@ -221,7 +224,8 @@ void ldlm_lock_add_to_lru_nolock(struct ldlm_lock *lock)
 
 void ldlm_lock_add_to_lru(struct ldlm_lock *lock)
 {
-        struct ldlm_namespace *ns = lock->l_resource->lr_namespace;
+        struct ldlm_namespace *ns = ldlm_lock_to_ns(lock);
+
         ENTRY;
         cfs_spin_lock(&ns->ns_unused_lock);
         ldlm_lock_add_to_lru_nolock(lock);
@@ -231,7 +235,8 @@ void ldlm_lock_add_to_lru(struct ldlm_lock *lock)
 
 void ldlm_lock_touch_in_lru(struct ldlm_lock *lock)
 {
-        struct ldlm_namespace *ns = lock->l_resource->lr_namespace;
+        struct ldlm_namespace *ns = ldlm_lock_to_ns(lock);
+
         ENTRY;
         cfs_spin_lock(&ns->ns_unused_lock);
         if (!cfs_list_empty(&lock->l_lru)) {
@@ -362,7 +367,7 @@ static struct ldlm_lock *ldlm_lock_new(struct ldlm_resource *resource)
         CFS_INIT_LIST_HEAD(&lock->l_sl_policy);
         CFS_INIT_HLIST_NODE(&lock->l_exp_hash);
 
-        cfs_atomic_inc(&resource->lr_namespace->ns_locks);
+        cfs_atomic_inc(&ldlm_res_to_ns(resource)->ns_locks);
         CFS_INIT_LIST_HEAD(&lock->l_handle.h_link);
         class_handle_hash(&lock->l_handle, lock_handle_addref);
 
@@ -467,7 +472,7 @@ struct ldlm_lock *__ldlm_handle2lock(const struct lustre_handle *handle,
                 RETURN(NULL);
 
         LASSERT(lock->l_resource != NULL);
-        ns = lock->l_resource->lr_namespace;
+        ns = ldlm_lock_to_ns(lock);
         LASSERT(ns != NULL);
 
         lu_ref_add_atomic(&lock->l_reference, "handle", cfs_current());
@@ -677,7 +682,7 @@ void ldlm_lock_decref_internal(struct ldlm_lock *lock, __u32 mode)
 
         lock_res_and_lock(lock);
 
-        ns = lock->l_resource->lr_namespace;
+        ns = ldlm_lock_to_ns(lock);
 
         ldlm_lock_decref_internal_nolock(lock, mode);
 
@@ -927,7 +932,7 @@ void ldlm_grant_lock(struct ldlm_lock *lock, cfs_list_t *work_list)
         if (work_list && lock->l_completion_ast != NULL)
                 ldlm_add_ast_work_item(lock, NULL, work_list);
 
-        ldlm_pool_add(&res->lr_namespace->ns_pool, lock);
+        ldlm_pool_add(&ldlm_res_to_ns(res)->ns_pool, lock);
         EXIT;
 }
 
@@ -1058,7 +1063,7 @@ ldlm_mode_t ldlm_lock_match(struct ldlm_namespace *ns, int flags,
                 old_lock = ldlm_handle2lock(lockh);
                 LASSERT(old_lock);
 
-                ns = old_lock->l_resource->lr_namespace;
+                ns = ldlm_lock_to_ns(old_lock);
                 res_id = &old_lock->l_resource->lr_name;
                 type = old_lock->l_resource->lr_type;
                 mode = old_lock->l_req_mode;
@@ -1220,7 +1225,7 @@ ldlm_error_t ldlm_lock_enqueue(struct ldlm_namespace *ns,
 {
         struct ldlm_lock *lock = *lockp;
         struct ldlm_resource *res = lock->l_resource;
-        int local = ns_is_client(res->lr_namespace);
+        int local = ns_is_client(ldlm_res_to_ns(res));
         ldlm_processing_policy policy;
         ldlm_error_t rc = ELDLM_OK;
         struct ldlm_interval *node = NULL;
@@ -1572,7 +1577,7 @@ void ldlm_reprocess_all(struct ldlm_resource *res)
         ENTRY;
 
         /* Local lock trees don't get reprocessed. */
-        if (ns_is_client(res->lr_namespace)) {
+        if (ns_is_client(ldlm_res_to_ns(res))) {
                 EXIT;
                 return;
         }
@@ -1629,7 +1634,7 @@ void ldlm_lock_cancel(struct ldlm_lock *lock)
         lock_res_and_lock(lock);
 
         res = lock->l_resource;
-        ns = res->lr_namespace;
+        ns  = ldlm_res_to_ns(res);
 
         /* Please do not, no matter how tempting, remove this LBUG without
          * talking to me first. -phik */
@@ -1722,7 +1727,7 @@ void ldlm_lock_downgrade(struct ldlm_lock *lock, int new_mode)
          * Remove the lock from pool as it will be added again in
          * ldlm_grant_lock() called below.
          */
-        ns = lock->l_resource->lr_namespace;
+        ns = ldlm_lock_to_ns(lock);
         ldlm_pool_del(&ns->ns_pool, lock);
 
         lock->l_req_mode = new_mode;
@@ -1763,7 +1768,7 @@ struct ldlm_resource *ldlm_lock_convert(struct ldlm_lock *lock, int new_mode,
         lock_res_and_lock(lock);
 
         res = lock->l_resource;
-        ns = res->lr_namespace;
+        ns  = ldlm_res_to_ns(res);
 
         old_mode = lock->l_req_mode;
         lock->l_req_mode = new_mode;
@@ -1794,7 +1799,7 @@ struct ldlm_resource *ldlm_lock_convert(struct ldlm_lock *lock, int new_mode,
         ldlm_pool_del(&ns->ns_pool, lock);
 
         /* If this is a local resource, put it on the appropriate list. */
-        if (ns_is_client(res->lr_namespace)) {
+        if (ns_is_client(ldlm_res_to_ns(res))) {
                 if (*flags & (LDLM_FL_BLOCK_CONV | LDLM_FL_BLOCK_GRANTED)) {
                         ldlm_resource_add_lock(res, &res->lr_converting, lock);
                 } else {
@@ -1943,7 +1948,7 @@ void _ldlm_lock_debug(struct ldlm_lock *lock, __u32 level,
                        "res: "LPU64"/"LPU64" rrc: %d type: %s ["LPU64"->"LPU64
                        "] (req "LPU64"->"LPU64") flags: "LPX64" remote: "LPX64
                        " expref: %d pid: %u timeout %lu\n",
-                       lock->l_resource->lr_namespace->ns_name, lock,
+                       ldlm_lock_to_ns_name(lock), lock,
                        lock->l_handle.h_cookie, cfs_atomic_read(&lock->l_refc),
                        lock->l_readers, lock->l_writers,
                        ldlm_lockname[lock->l_granted_mode],
@@ -1968,7 +1973,7 @@ void _ldlm_lock_debug(struct ldlm_lock *lock, __u32 level,
                        "res: "LPU64"/"LPU64" rrc: %d type: %s pid: %d "
                        "["LPU64"->"LPU64"] flags: "LPX64" remote: "LPX64
                        " expref: %d pid: %u timeout: %lu\n",
-                       lock->l_resource->lr_namespace->ns_name, lock,
+                       ldlm_lock_to_ns_name(lock), lock,
                        lock->l_handle.h_cookie, cfs_atomic_read(&lock->l_refc),
                        lock->l_readers, lock->l_writers,
                        ldlm_lockname[lock->l_granted_mode],
@@ -1993,7 +1998,7 @@ void _ldlm_lock_debug(struct ldlm_lock *lock, __u32 level,
                        "res: "LPU64"/"LPU64" bits "LPX64" rrc: %d type: %s "
                        "flags: "LPX64" remote: "LPX64" expref: %d "
                        "pid: %u timeout: %lu\n",
-                       lock->l_resource->lr_namespace->ns_name,
+                       ldlm_lock_to_ns_name(lock),
                        lock, lock->l_handle.h_cookie,
                        cfs_atomic_read (&lock->l_refc),
                        lock->l_readers, lock->l_writers,
@@ -2016,7 +2021,7 @@ void _ldlm_lock_debug(struct ldlm_lock *lock, __u32 level,
                        " ns: %s lock: %p/"LPX64" lrc: %d/%d,%d mode: %s/%s "
                        "res: "LPU64"/"LPU64" rrc: %d type: %s flags: "LPX64" "
                        "remote: "LPX64" expref: %d pid: %u timeout %lu\n",
-                       lock->l_resource->lr_namespace->ns_name,
+                       ldlm_lock_to_ns_name(lock),
                        lock, lock->l_handle.h_cookie,
                        cfs_atomic_read (&lock->l_refc),
                        lock->l_readers, lock->l_writers,

diff --git a/lustre/ldlm/ldlm_lockd.c b/lustre/ldlm/ldlm_lockd.c
index 746a29a..98f038c 100644 (file)
--- a/lustre/ldlm/ldlm_lockd.c
+++ b/lustre/ldlm/ldlm_lockd.c
@@ -340,7 +340,7 @@ repeat:
                         LDLM_LOCK_RELEASE(lock);
                         continue;
                 }
-                lock->l_resource->lr_namespace->ns_timeouts++;
+                ldlm_lock_to_ns(lock)->ns_timeouts++;
                 LDLM_ERROR(lock, "lock callback timer expired after %lds: "
                            "evicting client at %s ",
                            cfs_time_current_sec()- lock->l_last_activity,
@@ -863,7 +863,7 @@ int ldlm_server_completion_ast(struct ldlm_lock *lock, int flags, void *data)
         /* Server-side enqueue wait time estimate, used in
             __ldlm_add_waiting_lock to set future enqueue timers */
         if (total_enqueue_wait < ldlm_get_enq_timeout(lock))
-                at_measured(&lock->l_resource->lr_namespace->ns_at_estimate,
+                at_measured(ldlm_lock_to_ns_at(lock),
                             total_enqueue_wait);
         else
                 /* bz18618. Don't add lock enqueue time we spend waiting for a
@@ -873,7 +873,7 @@ int ldlm_server_completion_ast(struct ldlm_lock *lock, int flags, void *data)
                 LDLM_DEBUG(lock, "lock completed after %lus; estimate was %ds. "
                        "It is likely that a previous callback timed out.",
                        total_enqueue_wait,
-                       at_get(&lock->l_resource->lr_namespace->ns_at_estimate));
+                       at_get(ldlm_lock_to_ns_at(lock)));
 
         ptlrpc_request_set_replen(req);
 

diff --git a/lustre/ldlm/ldlm_request.c b/lustre/ldlm/ldlm_request.c
index da3914f..50bdf14 100644 (file)
--- a/lustre/ldlm/ldlm_request.c
+++ b/lustre/ldlm/ldlm_request.c
@@ -90,7 +90,7 @@ int ldlm_expired_completion_wait(void *data)
                         last_dump = next_dump;
                         next_dump = cfs_time_shift(300);
                         ldlm_namespace_dump(D_DLMTRACE,
-                                            lock->l_resource->lr_namespace);
+                                            ldlm_lock_to_ns(lock));
                         if (last_dump == 0)
                                 libcfs_debug_dumplog();
                 }
@@ -113,7 +113,7 @@ int ldlm_expired_completion_wait(void *data)
    from a single node. */
 int ldlm_get_enq_timeout(struct ldlm_lock *lock)
 {
-        int timeout = at_get(&lock->l_resource->lr_namespace->ns_at_estimate);
+        int timeout = at_get(ldlm_lock_to_ns_at(lock));
         if (AT_OFF)
                 return obd_timeout / 2;
         /* Since these are non-updating timeouts, we should be conservative.
@@ -143,7 +143,7 @@ static int ldlm_completion_tail(struct ldlm_lock *lock)
                            CFS_DURATION_T"s", delay);
 
                 /* Update our time estimate */
-                at_measured(&lock->l_resource->lr_namespace->ns_at_estimate,
+                at_measured(ldlm_lock_to_ns_at(lock),
                             delay);
                 result = 0;
         }
@@ -255,7 +255,7 @@ noreproc:
                 cfs_spin_unlock(&imp->imp_lock);
         }
 
-        if (ns_is_client(lock->l_resource->lr_namespace) &&
+        if (ns_is_client(ldlm_lock_to_ns(lock)) &&
             OBD_FAIL_CHECK_RESET(OBD_FAIL_LDLM_INTR_CP_AST,
                                  OBD_FAIL_LDLM_CP_BL_RACE | OBD_FAIL_ONCE)) {
                 lock->l_flags |= LDLM_FL_FAIL_LOC;
@@ -905,7 +905,7 @@ static int ldlm_cli_convert_local(struct ldlm_lock *lock, int new_mode,
         struct ldlm_resource *res;
         int rc;
         ENTRY;
-        if (ns_is_client(lock->l_resource->lr_namespace)) {
+        if (ns_is_client(ldlm_lock_to_ns(lock))) {
                 CERROR("Trying to cancel local lock\n");
                 LBUG();
         }
@@ -1028,7 +1028,7 @@ static int ldlm_cli_cancel_local(struct ldlm_lock *lock)
                 }
                 ldlm_lock_cancel(lock);
         } else {
-                if (ns_is_client(lock->l_resource->lr_namespace)) {
+                if (ns_is_client(ldlm_lock_to_ns(lock))) {
                         LDLM_ERROR(lock, "Trying to cancel local lock");
                         LBUG();
                 }
@@ -1260,7 +1260,7 @@ int ldlm_cli_cancel(struct lustre_handle *lockh)
                                                   RCL_CLIENT, 0);
                 LASSERT(avail > 0);
 
-                ns = lock->l_resource->lr_namespace;
+                ns = ldlm_lock_to_ns(lock);
                 flags = ns_connect_lru_resize(ns) ?
                         LDLM_CANCEL_LRUR : LDLM_CANCEL_AGED;
                 count += ldlm_cancel_lru_local(ns, &cancels, 0, avail - 1,

diff --git a/lustre/ldlm/ldlm_resource.c b/lustre/ldlm/ldlm_resource.c
index 2d947fe..b718fbc 100644 (file)
--- a/lustre/ldlm/ldlm_resource.c
+++ b/lustre/ldlm/ldlm_resource.c
@@ -414,7 +414,7 @@ static void cleanup_resource(struct ldlm_resource *res, cfs_list_t *q,
                              int flags)
 {
         cfs_list_t *tmp;
-        int rc = 0, client = ns_is_client(res->lr_namespace);
+        int rc = 0, client = ns_is_client(ldlm_res_to_ns(res));
         int local_only = (flags & LDLM_FL_LOCAL_ONLY);
         ENTRY;
 
@@ -957,7 +957,7 @@ struct ldlm_resource *ldlm_resource_getref(struct ldlm_resource *res)
 
 void __ldlm_resource_putref_final(struct ldlm_resource *res)
 {
-        struct ldlm_namespace *ns = res->lr_namespace;
+        struct ldlm_namespace *ns = ldlm_res_to_ns(res);
 
         LASSERT_SPIN_LOCKED(&ns->ns_hash_lock);
 
@@ -995,7 +995,7 @@ void __ldlm_resource_putref_final(struct ldlm_resource *res)
 
 int ldlm_resource_putref_internal(struct ldlm_resource *res, int locked)
 {
-        struct ldlm_namespace *ns = res->lr_namespace;
+        struct ldlm_namespace *ns = ldlm_res_to_ns(res);
         ENTRY;
 
         CDEBUG(D_INFO, "putref res: %p count: %d\n", res,

diff --git a/lustre/mdt/mdt_handler.c b/lustre/mdt/mdt_handler.c
index d748f76..6a249bb 100644 (file)
--- a/lustre/mdt/mdt_handler.c
+++ b/lustre/mdt/mdt_handler.c
@@ -2138,7 +2138,7 @@ static inline int mdt_is_lock_sync(struct ldlm_lock *lock)
 int mdt_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc,
                      void *data, int flag)
 {
-        struct obd_device *obd = lock->l_resource->lr_namespace->ns_obd;
+        struct obd_device *obd = ldlm_lock_to_ns(lock)->ns_obd;
         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
         int rc;
         ENTRY;

diff --git a/lustre/obdfilter/filter.c b/lustre/obdfilter/filter.c
index 6f55d0e..f3ddd57 100644 (file)
--- a/lustre/obdfilter/filter.c
+++ b/lustre/obdfilter/filter.c
@@ -1699,7 +1699,7 @@ static int filter_intent_policy(struct ldlm_namespace *ns,
          * lock, and should not be granted if the lock will be blocked.
          */
 
-        LASSERT(ns == res->lr_namespace);
+        LASSERT(ns == ldlm_res_to_ns(res));
         lock_res(res);
         rc = policy(lock, &tmpflags, 0, &err, &rpc_list);
         check_res_locked(res);

diff --git a/lustre/obdfilter/filter_lvb.c b/lustre/obdfilter/filter_lvb.c
index b223812..5010eb6 100644 (file)
--- a/lustre/obdfilter/filter_lvb.c
+++ b/lustre/obdfilter/filter_lvb.c
@@ -88,7 +88,7 @@ static int filter_lvbo_init(struct ldlm_resource *res)
         res->lr_lvb_data = lvb;
         res->lr_lvb_len = sizeof(*lvb);
 
-        obd = res->lr_namespace->ns_lvbp;
+        obd = ldlm_res_to_ns(res)->ns_lvbp;
         LASSERT(obd != NULL);
 
         CDEBUG(D_INODE, "%s: filter_lvbo_init(o_seq="LPU64", o_id="
@@ -191,7 +191,7 @@ static int filter_lvbo_update(struct ldlm_resource *res,
 
  disk_update:
         /* Update the LVB from the disk inode */
-        obd = res->lr_namespace->ns_lvbp;
+        obd = ldlm_res_to_ns(res)->ns_lvbp;
         LASSERT(obd);
 
         inode = res->lr_lvb_inode;