LU-11158 mdt: grow lvb buffer to hold layout

[fs/lustre-release.git] / lustre / include / lustre_dlm.h

diff --git a/lustre/include/lustre_dlm.h b/lustre/include/lustre_dlm.h
index ae5a599..738154b 100644 (file)
--- a/lustre/include/lustre_dlm.h
+++ b/lustre/include/lustre_dlm.h
@@ -272,9 +272,10 @@ struct ldlm_pool {
        struct completion        pl_kobj_unregister;
 };
 
-typedef int (*ldlm_res_policy)(struct ldlm_namespace *, struct ldlm_lock **,
-                              void *req_cookie, enum ldlm_mode mode,
-                              __u64 flags, void *data);
+typedef int (*ldlm_res_policy)(const struct lu_env *env,
+                              struct ldlm_namespace *,
+                              struct ldlm_lock **, void *req_cookie,
+                              enum ldlm_mode mode, __u64 flags, void *data);
 
 typedef int (*ldlm_cancel_cbt)(struct ldlm_lock *lock);
 
@@ -292,14 +293,16 @@ typedef int (*ldlm_cancel_cbt)(struct ldlm_lock *lock);
  * of ldlm_[res_]lvbo_[init,update,fill]() functions.
  */
 struct ldlm_valblock_ops {
-       int (*lvbo_init)(struct ldlm_resource *res);
-       int (*lvbo_update)(struct ldlm_resource *res, struct ldlm_lock *lock,
-                          struct ptlrpc_request *r,  int increase);
+       int (*lvbo_init)(const struct lu_env *env, struct ldlm_resource *res);
+       int (*lvbo_update)(const struct lu_env *env, struct ldlm_resource *res,
+                          struct ldlm_lock *lock, struct ptlrpc_request *r,
+                          int increase);
        int (*lvbo_free)(struct ldlm_resource *res);
        /* Return size of lvb data appropriate RPC size can be reserved */
        int (*lvbo_size)(struct ldlm_lock *lock);
        /* Called to fill in lvb data to RPC buffer @buf */
-       int (*lvbo_fill)(struct ldlm_lock *lock, void *buf, int buflen);
+       int (*lvbo_fill)(const struct lu_env *env, struct ldlm_lock *lock,
+                        void *buf, int *buflen);
 };
 
 /**
@@ -378,6 +381,9 @@ struct ldlm_namespace {
        /** Flag indicating if namespace is on client instead of server */
        enum ldlm_side          ns_client;
 
+       /** name of this namespace */
+       char                    *ns_name;
+
        /** Resource hash table for namespace. */
        struct cfs_hash         *ns_rs_hash;
 
@@ -825,12 +831,6 @@ struct ldlm_lock {
        wait_queue_head_t       l_waitq;
 
        /**
-        * Seconds. It will be updated if there is any activity related to
-        * the lock, e.g. enqueue the lock or send blocking AST.
-        */
-       time64_t                l_last_activity;
-
-       /**
         * Time, in nanoseconds, last used by e.g. being matched by lock match.
         */
        ktime_t                 l_last_used;
@@ -853,6 +853,17 @@ struct ldlm_lock {
 
        /** Private storage for lock user. Opaque to LDLM. */
        void                    *l_ast_data;
+
+       union {
+       /**
+        * Seconds. It will be updated if there is any activity related to
+        * the lock at client, e.g. enqueue the lock. For server it is the
+        * time when blocking ast was sent.
+        */
+               time64_t        l_activity;
+               time64_t        l_blast_sent;
+       };
+
        /* separate ost_lvb used mostly by Data-on-MDT for now.
         * It is introduced to don't mix with layout lock data. */
        struct ost_lvb           l_ost_lvb;
@@ -1041,7 +1052,7 @@ static inline bool ldlm_has_dom(struct ldlm_lock *lock)
 static inline char *
 ldlm_ns_name(struct ldlm_namespace *ns)
 {
-        return ns->ns_rs_hash->hs_name;
+       return ns->ns_name;
 }
 
 static inline struct ldlm_namespace *
@@ -1068,7 +1079,8 @@ ldlm_lock_to_ns_at(struct ldlm_lock *lock)
         return &lock->l_resource->lr_ns_bucket->nsb_at_estimate;
 }
 
-static inline int ldlm_lvbo_init(struct ldlm_resource *res)
+static inline int ldlm_lvbo_init(const struct lu_env *env,
+                                struct ldlm_resource *res)
 {
        struct ldlm_namespace *ns = ldlm_res_to_ns(res);
        int rc = 0;
@@ -1083,7 +1095,7 @@ static inline int ldlm_lvbo_init(struct ldlm_resource *res)
                mutex_unlock(&res->lr_lvb_mutex);
                return 0;
        }
-       rc = ns->ns_lvbo->lvbo_init(res);
+       rc = ns->ns_lvbo->lvbo_init(env, res);
        if (rc < 0) {
                CDEBUG(D_DLMTRACE, "lvbo_init failed for resource : rc = %d\n",
                       rc);
@@ -1109,7 +1121,8 @@ static inline int ldlm_lvbo_size(struct ldlm_lock *lock)
        return 0;
 }
 
-static inline int ldlm_lvbo_fill(struct ldlm_lock *lock, void *buf, int len)
+static inline int ldlm_lvbo_fill(const struct lu_env *env,
+                                struct ldlm_lock *lock, void *buf, int *len)
 {
        struct ldlm_namespace *ns = ldlm_lock_to_ns(lock);
        int rc;
@@ -1117,13 +1130,13 @@ static inline int ldlm_lvbo_fill(struct ldlm_lock *lock, void *buf, int len)
        if (ns->ns_lvbo != NULL) {
                LASSERT(ns->ns_lvbo->lvbo_fill != NULL);
                /* init lvb now if not already */
-               rc = ldlm_lvbo_init(lock->l_resource);
+               rc = ldlm_lvbo_init(env, lock->l_resource);
                if (rc < 0) {
                        CERROR("lock %p: delayed lvb init failed (rc %d)",
                               lock, rc);
                        return rc;
                }
-               return ns->ns_lvbo->lvbo_fill(lock, buf, len);
+               return ns->ns_lvbo->lvbo_fill(env, lock, buf, len);
        }
        return 0;
 }
@@ -1384,7 +1397,8 @@ ldlm_handle2lock_long(const struct lustre_handle *h, __u64 flags)
  * Update Lock Value Block Operations (LVBO) on a resource taking into account
  * data from request \a r
  */
-static inline int ldlm_lvbo_update(struct ldlm_resource *res,
+static inline int ldlm_lvbo_update(const struct lu_env *env,
+                                  struct ldlm_resource *res,
                                   struct ldlm_lock *lock,
                                   struct ptlrpc_request *req, int increase)
 {
@@ -1392,22 +1406,24 @@ static inline int ldlm_lvbo_update(struct ldlm_resource *res,
        int rc;
 
        /* delayed lvb init may be required */
-       rc = ldlm_lvbo_init(res);
+       rc = ldlm_lvbo_init(env, res);
        if (rc < 0) {
                CERROR("delayed lvb init failed (rc %d)\n", rc);
                return rc;
        }
 
        if (ns->ns_lvbo && ns->ns_lvbo->lvbo_update)
-               return ns->ns_lvbo->lvbo_update(res, lock, req, increase);
+               return ns->ns_lvbo->lvbo_update(env, res, lock, req, increase);
 
        return 0;
 }
 
-static inline int ldlm_res_lvbo_update(struct ldlm_resource *res,
-                                      struct ptlrpc_request *req, int increase)
+static inline int ldlm_res_lvbo_update(const struct lu_env *env,
+                                      struct ldlm_resource *res,
+                                      struct ptlrpc_request *req,
+                                      int increase)
 {
-       return ldlm_lvbo_update(res, NULL, req, increase);
+       return ldlm_lvbo_update(env, res, NULL, req, increase);
 }
 
 int ldlm_error2errno(enum ldlm_error error);
@@ -1605,7 +1621,8 @@ int ldlm_cli_enqueue_fini(struct obd_export *exp, struct ptlrpc_request *req,
                          enum ldlm_mode mode, __u64 *flags, void *lvb,
                          __u32 lvb_len,
                          const struct lustre_handle *lockh, int rc);
-int ldlm_cli_enqueue_local(struct ldlm_namespace *ns,
+int ldlm_cli_enqueue_local(const struct lu_env *env,
+                          struct ldlm_namespace *ns,
                           const struct ldlm_res_id *res_id,
                           enum ldlm_type type, union ldlm_policy_data *policy,
                           enum ldlm_mode mode, __u64 *flags,
@@ -1693,7 +1710,6 @@ void unlock_res_and_lock(struct ldlm_lock *lock);
  * There are not used outside of ldlm.
  * @{
  */
-time64_t ldlm_pools_recalc(enum ldlm_side client);
 int ldlm_pools_init(void);
 void ldlm_pools_fini(void);