Whamcloud - gitweb
git://git.whamcloud.com / fs / lustre-release.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
LU-6142 lfsck: Fix style issues under lustre/lfsck
[fs/lustre-release.git] / lustre / lfsck / lfsck_bookmark.c
diff --git a/lustre/lfsck/lfsck_bookmark.c b/lustre/lfsck/lfsck_bookmark.c
index 4663328..e1efaab 100644 (file)
--- a/lustre/lfsck/lfsck_bookmark.c
+++ b/lustre/lfsck/lfsck_bookmark.c
@@ -20,7 +20,7 @@
  * GPL HEADER END
  */
 /*
- * Copyright (c) 2013, 2015, Intel Corporation.
+ * Copyright (c) 2013, 2017, Intel Corporation.
  */
 /*
  * lustre/lfsck/lfsck_bookmark.c
@@ -33,7 +33,7 @@
 #include <lu_object.h>
 #include <dt_object.h>
 #include <lustre_fid.h>
-#include <lustre/lustre_user.h>
+#include <lu_target.h>
 
 #include "lfsck_internal.h"
 
@@ -67,8 +67,8 @@ static int lfsck_bookmark_load(const struct lu_env *env,
                               struct lfsck_instance *lfsck)
 {
        loff_t pos = 0;
-       int    len = sizeof(struct lfsck_bookmark);
-       int    rc;
+       int len = sizeof(struct lfsck_bookmark);
+       int rc;
 
        rc = dt_record_read(env, lfsck->li_bookmark_obj,
                            lfsck_buf_get(env, &lfsck->li_bookmark_disk, len),
@@ -78,9 +78,10 @@ static int lfsck_bookmark_load(const struct lu_env *env,
 
                lfsck_bookmark_le_to_cpu(bm, &lfsck->li_bookmark_disk);
                if (bm->lb_magic != LFSCK_BOOKMARK_MAGIC) {
-                       CDEBUG(D_LFSCK, "%s: invalid lfsck_bookmark magic "
-                             "%#x != %#x\n", lfsck_lfsck2name(lfsck),
-                             bm->lb_magic, LFSCK_BOOKMARK_MAGIC);
+                       CDEBUG(D_LFSCK,
+                              "%s: invalid lfsck_bookmark magic %#x != %#x\n",
+                              lfsck_lfsck2name(lfsck), bm->lb_magic,
+                              LFSCK_BOOKMARK_MAGIC);
                        /* Process it as new lfsck_bookmark. */
                        rc = -ENODATA;
                }
@@ -89,8 +90,8 @@ static int lfsck_bookmark_load(const struct lu_env *env,
                        /* return -ENODATA for empty lfsck_bookmark. */
                        rc = -ENODATA;
                else
-                       CDEBUG(D_LFSCK, "%s: fail to load lfsck_bookmark, "
-                              "expected = %d: rc = %d\n",
+                       CDEBUG(D_LFSCK,
+                              "%s: fail to load lfsck_bookmark, expected = %d: rc = %d\n",
                               lfsck_lfsck2name(lfsck), len, rc);
        }
        return rc;
@@ -98,12 +99,13 @@ static int lfsck_bookmark_load(const struct lu_env *env,
 
 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;
+       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;
+
        ENTRY;
 
        lfsck_bookmark_cpu_to_le(&lfsck->li_bookmark_disk,
@@ -160,14 +162,14 @@ int lfsck_bookmark_setup(const struct lu_env *env,
 {
        struct dt_object *root;
        struct dt_object *obj;
-       int               rc;
-       ENTRY;
+       int rc;
 
+       ENTRY;
        root = dt_locate(env, lfsck->li_bottom, &lfsck->li_local_root_fid);
        if (IS_ERR(root))
                RETURN(PTR_ERR(root));
 
-       if (unlikely(!dt_try_as_dir(env, root))) {
+       if (unlikely(!dt_try_as_dir(env, root, true))) {
                lfsck_object_put(env, root);
 
                RETURN(-ENOTDIR);
@@ -186,7 +188,8 @@ int lfsck_bookmark_setup(const struct lu_env *env,
                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. */
+                * 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);
@@ -203,9 +206,9 @@ int lfsck_bookmark_setup(const struct lu_env *env,
 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;
+       struct lfsck_bookmark *bk = &lfsck->li_bookmark_ram;
+       int rc = 0;
+       bool dirty = false;
 
        if (start == NULL) {
                LASSERT(reset);
@@ -263,9 +266,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) &&
@@ -277,7 +290,7 @@ 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_valid & LSV_CREATE_MDTOBJ)) {
+                           !(start->ls_flags & LPF_CREATE_MDTOBJ)) {
                                bk->lb_param &= ~LPF_CREATE_MDTOBJ;
                                dirty = true;
                        } else if (!(bk->lb_param & LPF_CREATE_MDTOBJ) &&
@@ -289,7 +302,7 @@ int lfsck_set_param(const struct lu_env *env, struct lfsck_instance *lfsck,
 
                if ((start->ls_valid & LSV_DELAY_CREATE_OSTOBJ) || reset) {
                        if ((bk->lb_param & LPF_DELAY_CREATE_OSTOBJ) &&
-                           !(start->ls_valid & LSV_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) &&
@@ -301,39 +314,29 @@ int lfsck_set_param(const struct lu_env *env, struct lfsck_instance *lfsck,
 
                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;
@@ -343,8 +346,7 @@ 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 ||
-                           start->ls_async_windows > LFSCK_ASYNC_WIN_MAX)
+                       if (start->ls_async_windows < 1)
                                return -EINVAL;
 
                        if (bk->lb_async_windows != start->ls_async_windows) {
Lustre primary development and releases