Whamcloud - gitweb
git://git.whamcloud.com / fs / lustre-release.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
LU-12616 obclass: fix MDS start/stop race
[fs/lustre-release.git] / lustre / lfsck / lfsck_bookmark.c
diff --git a/lustre/lfsck/lfsck_bookmark.c b/lustre/lfsck/lfsck_bookmark.c
index ffaa73d..0aa94fa 100644 (file)
--- a/lustre/lfsck/lfsck_bookmark.c
+++ b/lustre/lfsck/lfsck_bookmark.c
@@ -20,7 +20,7 @@
  * GPL HEADER END
  */
 /*
- * Copyright (c) 2012, 2013, Intel Corporation.
+ * Copyright (c) 2013, 2017, Intel Corporation.
  */
 /*
  * lustre/lfsck/lfsck_bookmark.c
@@ -33,14 +33,11 @@
 #include <lu_object.h>
 #include <dt_object.h>
 #include <lustre_fid.h>
-#include <lustre/lustre_user.h>
 
 #include "lfsck_internal.h"
 
 #define LFSCK_BOOKMARK_MAGIC   0x20130C1D
 
-static const char lfsck_bookmark_name[] = "lfsck_bookmark";
-
 static void lfsck_bookmark_le_to_cpu(struct lfsck_bookmark *des,
                                     struct lfsck_bookmark *src)
 {
@@ -102,6 +99,7 @@ int lfsck_bookmark_store(const struct lu_env *env, struct lfsck_instance *lfsck)
 {
        struct thandle    *handle;
        struct dt_object  *obj    = lfsck->li_bookmark_obj;
+       struct dt_device  *dev    = lfsck_obj2dev(obj);
        loff_t             pos    = 0;
        int                len    = sizeof(struct lfsck_bookmark);
        int                rc;
@@ -109,7 +107,7 @@ int lfsck_bookmark_store(const struct lu_env *env, struct lfsck_instance *lfsck)
 
        lfsck_bookmark_cpu_to_le(&lfsck->li_bookmark_disk,
                                 &lfsck->li_bookmark_ram);
-       handle = dt_trans_create(env, lfsck->li_bottom);
+       handle = dt_trans_create(env, dev);
        if (IS_ERR(handle))
                GOTO(log, rc = PTR_ERR(handle));
 
@@ -120,7 +118,7 @@ int lfsck_bookmark_store(const struct lu_env *env, struct lfsck_instance *lfsck)
        if (rc != 0)
                GOTO(out, rc);
 
-       rc = dt_trans_start_local(env, lfsck->li_bottom, handle);
+       rc = dt_trans_start_local(env, dev, handle);
        if (rc != 0)
                GOTO(out, rc);
 
@@ -131,7 +129,7 @@ int lfsck_bookmark_store(const struct lu_env *env, struct lfsck_instance *lfsck)
        GOTO(out, rc);
 
 out:
-       dt_trans_stop(env, lfsck->li_bottom, handle);
+       dt_trans_stop(env, dev, handle);
 
 log:
        if (rc != 0)
@@ -169,22 +167,34 @@ int lfsck_bookmark_setup(const struct lu_env *env,
                RETURN(PTR_ERR(root));
 
        if (unlikely(!dt_try_as_dir(env, root))) {
-               lu_object_put(env, &root->do_lu);
+               lfsck_object_put(env, root);
 
                RETURN(-ENOTDIR);
        }
 
        obj = local_file_find_or_create(env, lfsck->li_los, root,
-                                       lfsck_bookmark_name,
+                                       LFSCK_BOOKMARK,
                                        S_IFREG | S_IRUGO | S_IWUSR);
-       lu_object_put(env, &root->do_lu);
+       lfsck_object_put(env, root);
        if (IS_ERR(obj))
                RETURN(PTR_ERR(obj));
 
        lfsck->li_bookmark_obj = obj;
        rc = lfsck_bookmark_load(env, lfsck);
-       if (rc == -ENODATA)
+       if (rc == 0) {
+               struct lfsck_bookmark *mb = &lfsck->li_bookmark_ram;
+
+               /* It is upgraded from old release, set it as
+                * LFSCK_ASYNC_WIN_DEFAULT to avoid memory pressure. */
+               if (unlikely(mb->lb_async_windows == 0)) {
+                       mb->lb_async_windows = LFSCK_ASYNC_WIN_DEFAULT;
+                       mutex_lock(&lfsck->li_mutex);
+                       rc = lfsck_bookmark_store(env, lfsck);
+                       mutex_unlock(&lfsck->li_mutex);
+               }
+       } else if (rc == -ENODATA) {
                rc = lfsck_bookmark_init(env, lfsck);
+       }
 
        RETURN(rc);
 }
@@ -209,6 +219,16 @@ int lfsck_set_param(const struct lu_env *env, struct lfsck_instance *lfsck,
                        dirty = true;
                }
 
+               if (bk->lb_param & LPF_CREATE_MDTOBJ) {
+                       bk->lb_param &= ~LPF_CREATE_MDTOBJ;
+                       dirty = true;
+               }
+
+               if (bk->lb_param & LPF_DELAY_CREATE_OSTOBJ) {
+                       bk->lb_param &= ~LPF_DELAY_CREATE_OSTOBJ;
+                       dirty = true;
+               }
+
                if (bk->lb_param & LPF_FAILOUT) {
                        bk->lb_param &= ~LPF_FAILOUT;
                        dirty = true;
@@ -242,9 +262,19 @@ int lfsck_set_param(const struct lu_env *env, struct lfsck_instance *lfsck,
                        dirty = true;
                }
 
+               if ((bk->lb_param & LPF_OST_ORPHAN) &&
+                   !(start->ls_flags & LPF_OST_ORPHAN)) {
+                       bk->lb_param &= ~LPF_OST_ORPHAN;
+                       dirty = true;
+               } else if (!(bk->lb_param & LPF_OST_ORPHAN) &&
+                          (start->ls_flags & LPF_OST_ORPHAN)) {
+                       bk->lb_param |= LPF_OST_ORPHAN;
+                       dirty = true;
+               }
+
                if ((start->ls_valid & LSV_CREATE_OSTOBJ) || reset) {
                        if ((bk->lb_param & LPF_CREATE_OSTOBJ) &&
-                           !(start->ls_valid & LSV_CREATE_OSTOBJ)) {
+                           !(start->ls_flags & LPF_CREATE_OSTOBJ)) {
                                bk->lb_param &= ~LPF_CREATE_OSTOBJ;
                                dirty = true;
                        } else if (!(bk->lb_param & LPF_CREATE_OSTOBJ) &&
@@ -254,41 +284,55 @@ int lfsck_set_param(const struct lu_env *env, struct lfsck_instance *lfsck,
                        }
                }
 
+               if ((start->ls_valid & LSV_CREATE_MDTOBJ) || reset) {
+                       if ((bk->lb_param & LPF_CREATE_MDTOBJ) &&
+                           !(start->ls_flags & LPF_CREATE_MDTOBJ)) {
+                               bk->lb_param &= ~LPF_CREATE_MDTOBJ;
+                               dirty = true;
+                       } else if (!(bk->lb_param & LPF_CREATE_MDTOBJ) &&
+                                  (start->ls_flags & LPF_CREATE_MDTOBJ)) {
+                               bk->lb_param |= LPF_CREATE_MDTOBJ;
+                               dirty = true;
+                       }
+               }
+
+               if ((start->ls_valid & LSV_DELAY_CREATE_OSTOBJ) || reset) {
+                       if ((bk->lb_param & LPF_DELAY_CREATE_OSTOBJ) &&
+                           !(start->ls_flags & LPF_DELAY_CREATE_OSTOBJ)) {
+                               bk->lb_param &= ~LPF_DELAY_CREATE_OSTOBJ;
+                               dirty = true;
+                       } else if (!(bk->lb_param & LPF_DELAY_CREATE_OSTOBJ) &&
+                                  start->ls_flags & LPF_DELAY_CREATE_OSTOBJ) {
+                               bk->lb_param |= LPF_DELAY_CREATE_OSTOBJ;
+                               dirty = true;
+                       }
+               }
+
                if ((start->ls_valid & LSV_ERROR_HANDLE) || reset) {
                        if ((bk->lb_param & LPF_FAILOUT) &&
-                           !(start->ls_valid & LSV_ERROR_HANDLE)) {
+                           !(start->ls_flags & LPF_FAILOUT)) {
                                bk->lb_param &= ~LPF_FAILOUT;
                                dirty = true;
-                       } else if (!(start->ls_flags & LPF_FAILOUT) &&
-                                  (bk->lb_param & LPF_FAILOUT)) {
-                               bk->lb_param &= ~LPF_FAILOUT;
+                       } else if (!(bk->lb_param & LPF_FAILOUT) &&
+                                  (start->ls_flags & 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)) {
+                           !(start->ls_flags & LPF_DRYRUN)) {
                                bk->lb_param &= ~LPF_DRYRUN;
                                lfsck->li_drop_dryrun = 1;
                                dirty = true;
+                       } else if (!(bk->lb_param & LPF_DRYRUN) &&
+                                  (start->ls_flags & LPF_DRYRUN)) {
+                               bk->lb_param |= LPF_DRYRUN;
+                               dirty = true;
                        }
                }
 
-               if ((bk->lb_param & LPF_OST_ORPHAN) &&
-                   !(start->ls_flags & LPF_OST_ORPHAN)) {
-                       bk->lb_param &= ~LPF_OST_ORPHAN;
-                       dirty = true;
-               } else if (!(bk->lb_param & LPF_OST_ORPHAN) &&
-                          (start->ls_flags & LPF_OST_ORPHAN)) {
-                       bk->lb_param |= LPF_OST_ORPHAN;
-                       dirty = true;
-               }
-
                if (start->ls_valid & LSV_SPEED_LIMIT) {
                        if (__lfsck_set_speed(lfsck, start->ls_speed_limit))
                                dirty = true;
@@ -298,6 +342,9 @@ int lfsck_set_param(const struct lu_env *env, struct lfsck_instance *lfsck,
                }
 
                if (start->ls_valid & LSV_ASYNC_WINDOWS) {
+                       if (start->ls_async_windows < 1)
+                               return -EINVAL;
+
                        if (bk->lb_async_windows != start->ls_async_windows) {
                                bk->lb_async_windows = start->ls_async_windows;
                                dirty = true;
Lustre primary development and releases