LU-8127 lfsck: compile XATTR_NAME_LFSCK_NAMESPACE_OLD

[fs/lustre-release.git] / lustre / target / tgt_handler.c

diff --git a/lustre/target/tgt_handler.c b/lustre/target/tgt_handler.c
index f7a1171..e2b9ab3 100644 (file)
--- a/lustre/target/tgt_handler.c
+++ b/lustre/target/tgt_handler.c
@@ -634,10 +634,8 @@ static int process_req_last_xid(struct ptlrpc_request *req)
                 *   exp_last_xid on server;
                 * - The former RPC got chance to be processed;
                 */
-               if (!(lustre_msg_get_flags(req->rq_reqmsg) & MSG_REPLAY)) {
-                       req->rq_status = -EPROTO;
-                       RETURN(ptlrpc_error(req));
-               }
+               if (!(lustre_msg_get_flags(req->rq_reqmsg) & MSG_REPLAY))
+                       RETURN(-EPROTO);
        }
 
        /* try to release in-memory reply data */
@@ -732,8 +730,11 @@ int tgt_request_handle(struct ptlrpc_request *req)
        } else if (obd->obd_recovery_data.trd_processing_task !=
                   current_pid()) {
                rc = process_req_last_xid(req);
-               if (rc)
+               if (rc) {
+                       req->rq_status = rc;
+                       rc = ptlrpc_error(req);
                        GOTO(out, rc);
+               }
        }
 
        request_fail_id = tgt->lut_request_fail_id;
@@ -1284,6 +1285,7 @@ int tgt_sync(const struct lu_env *env, struct lu_target *tgt,
                   tgt->lut_obd->obd_last_committed) {
                rc = dt_object_sync(env, obj, start, end);
        }
+       atomic_inc(&tgt->lut_sync_count);
 
        RETURN(rc);
 }
@@ -1292,14 +1294,27 @@ EXPORT_SYMBOL(tgt_sync);
  * Unified target DLM handlers.
  */
 
-/* Ensure that data and metadata are synced to the disk when lock is cancelled
- * (if requested) */
+/**
+ * Unified target BAST
+ *
+ * Ensure data and metadata are synced to disk when lock is canceled if Sync on
+ * Cancel (SOC) is enabled. If it's extent lock, normally sync obj is enough,
+ * but if it's cross-MDT lock, because remote object version is not set, a
+ * filesystem sync is needed.
+ *
+ * \param lock server side lock
+ * \param desc lock desc
+ * \param data ldlm_cb_set_arg
+ * \param flag indicates whether this cancelling or blocking callback
+ * \retval     0 on success
+ * \retval     negative number on error
+ */
 static int tgt_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc,
                            void *data, int flag)
 {
        struct lu_env            env;
        struct lu_target        *tgt;
-       struct dt_object        *obj;
+       struct dt_object        *obj = NULL;
        struct lu_fid            fid;
        int                      rc = 0;
 
@@ -1314,10 +1329,12 @@ static int tgt_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc,
        }
 
        if (flag == LDLM_CB_CANCELING &&
-           (lock->l_granted_mode & (LCK_PW | LCK_GROUP)) &&
+           (lock->l_granted_mode & (LCK_EX | LCK_PW | LCK_GROUP)) &&
            (tgt->lut_sync_lock_cancel == ALWAYS_SYNC_ON_CANCEL ||
             (tgt->lut_sync_lock_cancel == BLOCKING_SYNC_ON_CANCEL &&
-             lock->l_flags & LDLM_FL_CBPENDING))) {
+             ldlm_is_cbpending(lock))) &&
+           ((exp_connect_flags(lock->l_export) & OBD_CONNECT_MDS_MDS) ||
+            lock->l_resource->lr_type == LDLM_EXTENT)) {
                __u64 start = 0;
                __u64 end = OBD_OBJECT_EOF;
 
@@ -1327,14 +1344,15 @@ static int tgt_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc,
 
                ost_fid_from_resid(&fid, &lock->l_resource->lr_name,
                                   tgt->lut_lsd.lsd_osd_index);
-               obj = dt_locate(&env, tgt->lut_bottom, &fid);
-               if (IS_ERR(obj))
-                       GOTO(err_env, rc = PTR_ERR(obj));
-
-               if (!dt_object_exists(obj))
-                       GOTO(err_put, rc = -ENOENT);
 
                if (lock->l_resource->lr_type == LDLM_EXTENT) {
+                       obj = dt_locate(&env, tgt->lut_bottom, &fid);
+                       if (IS_ERR(obj))
+                               GOTO(err_env, rc = PTR_ERR(obj));
+
+                       if (!dt_object_exists(obj))
+                               GOTO(err_put, rc = -ENOENT);
+
                        start = lock->l_policy_data.l_extent.start;
                        end = lock->l_policy_data.l_extent.end;
                }
@@ -1348,7 +1366,8 @@ static int tgt_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc,
                               lock->l_policy_data.l_extent.end, rc);
                }
 err_put:
-               lu_object_put(&env, &obj->do_lu);
+               if (obj != NULL)
+                       lu_object_put(&env, &obj->do_lu);
 err_env:
                lu_env_fini(&env);
        }
@@ -1548,11 +1567,15 @@ EXPORT_SYMBOL(tgt_register_lfsck_in_notify);
 
 static int (*tgt_lfsck_query)(const struct lu_env *env,
                              struct dt_device *key,
-                             struct lfsck_request *lr) = NULL;
+                             struct lfsck_request *req,
+                             struct lfsck_reply *rep,
+                             struct lfsck_query *que) = NULL;
 
 void tgt_register_lfsck_query(int (*query)(const struct lu_env *,
                                           struct dt_device *,
-                                          struct lfsck_request *))
+                                          struct lfsck_request *,
+                                          struct lfsck_reply *,
+                                          struct lfsck_query *))
 {
        tgt_lfsck_query = query;
 }
@@ -1591,8 +1614,8 @@ static int tgt_handle_lfsck_query(struct tgt_session_info *tsi)
        if (reply == NULL)
                RETURN(-ENOMEM);
 
-       rc = tgt_lfsck_query(tsi->tsi_env, tsi->tsi_tgt->lut_bottom, request);
-       reply->lr_status = rc;
+       rc = tgt_lfsck_query(tsi->tsi_env, tsi->tsi_tgt->lut_bottom,
+                            request, reply, NULL);
 
        RETURN(rc < 0 ? rc : 0);
 }