LU-10810 clio: SEEK_HOLE/SEEK_DATA on client side

[fs/lustre-release.git] / lustre / mdc / mdc_dev.c

diff --git a/lustre/mdc/mdc_dev.c b/lustre/mdc/mdc_dev.c
index 72cf45c..cbe0201 100644 (file)
--- a/lustre/mdc/mdc_dev.c
+++ b/lustre/mdc/mdc_dev.c
@@ -39,10 +39,14 @@
 #include "mdc_internal.h"
 
 static void mdc_lock_build_policy(const struct lu_env *env,
+                                 const struct cl_lock *lock,
                                  union ldlm_policy_data *policy)
 {
        memset(policy, 0, sizeof *policy);
        policy->l_inodebits.bits = MDS_INODELOCK_DOM;
+       if (lock) {
+               policy->l_inodebits.li_gid = lock->cll_descr.cld_gid;
+       }
 }
 
 int mdc_ldlm_glimpse_ast(struct ldlm_lock *dlmlock, void *data)
@@ -91,7 +95,8 @@ int mdc_dom_lock_match(const struct lu_env *env, struct obd_export *exp,
                       struct ldlm_res_id *res_id, enum ldlm_type type,
                       union ldlm_policy_data *policy, enum ldlm_mode mode,
                       __u64 *flags, struct osc_object *obj,
-                      struct lustre_handle *lockh, int unref)
+                      struct lustre_handle *lockh,
+                      enum ldlm_match_flags match_flags)
 {
        struct obd_device *obd = exp->exp_obd;
        __u64 lflags = *flags;
@@ -99,8 +104,9 @@ int mdc_dom_lock_match(const struct lu_env *env, struct obd_export *exp,
 
        ENTRY;
 
-       rc = ldlm_lock_match(obd->obd_namespace, lflags,
-                            res_id, type, policy, mode, lockh, unref);
+       rc = ldlm_lock_match_with_skip(obd->obd_namespace, lflags, 0,
+                            res_id, type, policy, mode, lockh, match_flags);
+
        if (rc == 0 || lflags & LDLM_FL_TEST_LOCK)
                RETURN(rc);
 
@@ -140,16 +146,24 @@ struct ldlm_lock *mdc_dlmlock_at_pgoff(const struct lu_env *env,
        struct ldlm_lock *lock = NULL;
        enum ldlm_mode mode;
        __u64 flags;
+       enum ldlm_match_flags match_flags = 0;
 
        ENTRY;
 
        fid_build_reg_res_name(lu_object_fid(osc2lu(obj)), resname);
-       mdc_lock_build_policy(env, policy);
+       mdc_lock_build_policy(env, NULL, policy);
+       policy->l_inodebits.li_gid = LDLM_GID_ANY;
 
        flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_CBPENDING;
        if (dap_flags & OSC_DAP_FL_TEST_LOCK)
                flags |= LDLM_FL_TEST_LOCK;
 
+       if (dap_flags & OSC_DAP_FL_AST)
+               match_flags |= LDLM_MATCH_AST;
+
+       if (dap_flags & OSC_DAP_FL_CANCELING)
+               match_flags |= LDLM_MATCH_UNREF;
+
 again:
        /* Next, search for already existing extent locks that will cover us */
        /* If we're trying to read, we also search for an existing PW lock.  The
@@ -157,8 +171,7 @@ again:
         * writers can share a single PW lock. */
        mode = mdc_dom_lock_match(env, osc_export(obj), resname, LDLM_IBITS,
                                  policy, LCK_PR | LCK_PW | LCK_GROUP, &flags,
-                                 obj, &lockh,
-                                 dap_flags & OSC_DAP_FL_CANCELING);
+                                 obj, &lockh, match_flags);
        if (mode != 0) {
                lock = ldlm_handle2lock(&lockh);
                /* RACE: the lock is cancelled so let's try again */
@@ -186,7 +199,7 @@ static bool mdc_check_and_discard_cb(const struct lu_env *env, struct cl_io *io,
 
                /* refresh non-overlapped index */
                tmp = mdc_dlmlock_at_pgoff(env, osc, index,
-                                          OSC_DAP_FL_TEST_LOCK);
+                                          OSC_DAP_FL_TEST_LOCK | OSC_DAP_FL_AST);
                if (tmp != NULL) {
                        info->oti_fn_index = CL_PAGE_EOF;
                        LDLM_LOCK_PUT(tmp);
@@ -709,7 +722,7 @@ int mdc_enqueue_send(const struct lu_env *env, struct obd_export *exp,
         * such locks should be skipped.
         */
        mode = ldlm_lock_match(obd->obd_namespace, match_flags, res_id,
-                              einfo->ei_type, policy, mode, &lockh, 0);
+                              einfo->ei_type, policy, mode, &lockh);
        if (mode) {
                struct ldlm_lock *matched;
 
@@ -877,7 +890,7 @@ enqueue_base:
         * osc_lock.
         */
        fid_build_reg_res_name(lu_object_fid(osc2lu(osc)), resname);
-       mdc_lock_build_policy(env, policy);
+       mdc_lock_build_policy(env, lock, policy);
        LASSERT(!oscl->ols_speculative);
        result = mdc_enqueue_send(env, osc_export(osc), resname,
                                  &oscl->ols_flags, policy,
@@ -943,6 +956,8 @@ int mdc_lock_init(const struct lu_env *env, struct cl_object *obj,
 
        ols->ols_flags = flags;
        ols->ols_speculative = !!(enqflags & CEF_SPECULATIVE);
+       if (lock->cll_descr.cld_mode == CLM_GROUP)
+               ols->ols_flags |= LDLM_FL_ATOMIC_CB;
 
        if (ols->ols_flags & LDLM_FL_HAS_INTENT) {
                ols->ols_flags |= LDLM_FL_BLOCK_GRANTED;
@@ -1311,6 +1326,10 @@ static struct cl_io_operations mdc_io_ops = {
                        .cio_start = mdc_io_fsync_start,
                        .cio_end   = osc_io_fsync_end,
                },
+               [CIT_LSEEK] = {
+                       .cio_start  = osc_io_lseek_start,
+                       .cio_end    = osc_io_lseek_end,
+               },
        },
        .cio_read_ahead   = mdc_io_read_ahead,
        .cio_submit       = osc_io_submit,