LU-4524 ldlm: improve ldlm_lock_create() return value

[fs/lustre-release.git] / lustre / lfsck / lfsck_bookmark.c

diff --git a/lustre/lfsck/lfsck_bookmark.c b/lustre/lfsck/lfsck_bookmark.c
index 8275bf1..cf31418 100644 (file)
--- a/lustre/lfsck/lfsck_bookmark.c
+++ b/lustre/lfsck/lfsck_bookmark.c
@@ -48,15 +48,21 @@ static void lfsck_bookmark_le_to_cpu(struct lfsck_bookmark *des,
        des->lb_version = le16_to_cpu(src->lb_version);
        des->lb_param = le16_to_cpu(src->lb_param);
        des->lb_speed_limit = le32_to_cpu(src->lb_speed_limit);
+       des->lb_async_windows = le16_to_cpu(src->lb_async_windows);
+       fid_le_to_cpu(&des->lb_lpf_fid, &src->lb_lpf_fid);
+       fid_le_to_cpu(&des->lb_last_fid, &src->lb_last_fid);
 }
 
-static void lfsck_bookmark_cpu_to_le(struct lfsck_bookmark *des,
-                                    struct lfsck_bookmark *src)
+void lfsck_bookmark_cpu_to_le(struct lfsck_bookmark *des,
+                             struct lfsck_bookmark *src)
 {
        des->lb_magic = cpu_to_le32(src->lb_magic);
        des->lb_version = cpu_to_le16(src->lb_version);
        des->lb_param = cpu_to_le16(src->lb_param);
        des->lb_speed_limit = cpu_to_le32(src->lb_speed_limit);
+       des->lb_async_windows = cpu_to_le16(src->lb_async_windows);
+       fid_cpu_to_le(&des->lb_lpf_fid, &src->lb_lpf_fid);
+       fid_cpu_to_le(&des->lb_last_fid, &src->lb_last_fid);
 }
 
 static int lfsck_bookmark_load(const struct lu_env *env,
@@ -111,7 +117,10 @@ int lfsck_bookmark_store(const struct lu_env *env, struct lfsck_instance *lfsck)
                RETURN(rc);
        }
 
-       rc = dt_declare_record_write(env, obj, len, 0, handle);
+       rc = dt_declare_record_write(env, obj,
+                                    lfsck_buf_get(env,
+                                    &lfsck->li_bookmark_disk, len),
+                                    0, handle);
        if (rc != 0) {
                CERROR("%s: fail to declare trans for storing lfsck_bookmark: "
                       "rc = %d\n", lfsck_lfsck2name(lfsck), rc);
@@ -148,6 +157,7 @@ static int lfsck_bookmark_init(const struct lu_env *env,
        memset(mb, 0, sizeof(*mb));
        mb->lb_magic = LFSCK_BOOKMARK_MAGIC;
        mb->lb_version = LFSCK_VERSION_V2;
+       mb->lb_async_windows = LFSCK_ASYNC_WIN_DEFAULT;
        mutex_lock(&lfsck->li_mutex);
        rc = lfsck_bookmark_store(env, lfsck);
        mutex_unlock(&lfsck->li_mutex);
@@ -186,3 +196,130 @@ int lfsck_bookmark_setup(const struct lu_env *env,
 
        RETURN(rc);
 }
+
+int lfsck_set_param(const struct lu_env *env, struct lfsck_instance *lfsck,
+                   struct lfsck_start *start, bool reset)
+{
+       struct lfsck_bookmark   *bk     = &lfsck->li_bookmark_ram;
+       int                      rc     = 0;
+       bool                     dirty  = false;
+
+       if (start == NULL) {
+               LASSERT(reset);
+
+               if (bk->lb_param & LPF_ALL_TGT) {
+                       bk->lb_param &= ~LPF_ALL_TGT;
+                       dirty = true;
+               }
+
+               if (bk->lb_param & LPF_CREATE_OSTOBJ) {
+                       bk->lb_param &= ~LPF_CREATE_OSTOBJ;
+                       dirty = true;
+               }
+
+               if (bk->lb_param & LPF_FAILOUT) {
+                       bk->lb_param &= ~LPF_FAILOUT;
+                       dirty = true;
+               }
+
+               if (bk->lb_param & LPF_DRYRUN) {
+                       bk->lb_param &= ~LPF_DRYRUN;
+                       dirty = true;
+               }
+
+               if (bk->lb_param & LPF_ORPHAN) {
+                       bk->lb_param &= ~LPF_ORPHAN;
+                       dirty = true;
+               }
+
+               if (__lfsck_set_speed(lfsck, LFSCK_SPEED_NO_LIMIT))
+                       dirty = true;
+
+               if (bk->lb_async_windows != LFSCK_ASYNC_WIN_DEFAULT) {
+                       bk->lb_async_windows = LFSCK_ASYNC_WIN_DEFAULT;
+                       dirty = true;
+               }
+       } else {
+               if ((bk->lb_param & LPF_ALL_TGT) &&
+                   !(start->ls_flags & LPF_ALL_TGT)) {
+                       bk->lb_param &= ~LPF_ALL_TGT;
+                       dirty = true;
+               } else if (!(bk->lb_param & LPF_ALL_TGT) &&
+                          (start->ls_flags & LPF_ALL_TGT)) {
+                       bk->lb_param |= LPF_ALL_TGT;
+                       dirty = true;
+               }
+
+               if ((start->ls_valid & LSV_CREATE_OSTOBJ) || reset) {
+                       if ((bk->lb_param & LPF_CREATE_OSTOBJ) &&
+                           !(start->ls_valid & LSV_CREATE_OSTOBJ)) {
+                               bk->lb_param &= ~LPF_CREATE_OSTOBJ;
+                               dirty = true;
+                       } else if (!(bk->lb_param & LPF_CREATE_OSTOBJ) &&
+                                  (start->ls_flags & LPF_CREATE_OSTOBJ)) {
+                               bk->lb_param |= LPF_CREATE_OSTOBJ;
+                               dirty = true;
+                       }
+               }
+
+               if ((start->ls_valid & LSV_ERROR_HANDLE) || reset) {
+                       if ((bk->lb_param & LPF_FAILOUT) &&
+                           !(start->ls_valid & LSV_ERROR_HANDLE)) {
+                               bk->lb_param &= ~LPF_FAILOUT;
+                               dirty = true;
+                       } else if (!(start->ls_flags & LPF_FAILOUT) &&
+                                  (bk->lb_param & LPF_FAILOUT)) {
+                               bk->lb_param &= ~LPF_FAILOUT;
+                               dirty = true;
+                       }
+               }
+
+               if ((start->ls_valid & LSV_DRYRUN) || reset) {
+                       if ((bk->lb_param & LPF_DRYRUN) &&
+                          !(start->ls_valid & LSV_DRYRUN)) {
+                               bk->lb_param &= ~LPF_DRYRUN;
+                               dirty = true;
+                       } else if (!(start->ls_flags & LPF_DRYRUN) &&
+                                  (bk->lb_param & LPF_DRYRUN)) {
+                               bk->lb_param &= ~LPF_DRYRUN;
+                               lfsck->li_drop_dryrun = 1;
+                               dirty = true;
+                       }
+               }
+
+               if ((bk->lb_param & LPF_ORPHAN) &&
+                   !(start->ls_flags & LPF_ORPHAN)) {
+                       bk->lb_param &= ~LPF_ORPHAN;
+                       dirty = true;
+               } else if (!(bk->lb_param & LPF_ORPHAN) &&
+                          (start->ls_flags & LPF_ORPHAN)) {
+                       bk->lb_param |= LPF_ORPHAN;
+                       dirty = true;
+               }
+
+               if (start->ls_valid & LSV_SPEED_LIMIT) {
+                       if (__lfsck_set_speed(lfsck, start->ls_speed_limit))
+                               dirty = true;
+               } else if (reset) {
+                       if (__lfsck_set_speed(lfsck, LFSCK_SPEED_NO_LIMIT))
+                               dirty = true;
+               }
+
+               if (start->ls_valid & LSV_ASYNC_WINDOWS) {
+                       if (bk->lb_async_windows != start->ls_async_windows) {
+                               bk->lb_async_windows = start->ls_async_windows;
+                               dirty = true;
+                       }
+               } else if (reset &&
+                          bk->lb_async_windows != LFSCK_ASYNC_WIN_DEFAULT) {
+                       bk->lb_async_windows = LFSCK_ASYNC_WIN_DEFAULT;
+                       dirty = true;
+               }
+       }
+
+       if (dirty)
+               rc = lfsck_bookmark_store(env, lfsck);
+
+       return rc;
+}
+