lustre/mdd/mdd_lfsck.c

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 only,
   8  * as published by the Free Software Foundation.
   9
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License version 2 for more details.  A copy is
  14  * included in the COPYING file that accompanied this code.
  15
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  19  *
  20  * GPL HEADER END
  21  */
  22 /*
  23  * Copyright (c) 2012, Intel Corporation.
  24  */
  25 /*
  26  * lustre/mdd/mdd_lfsck.c
  27  *
  28  * Top-level entry points into mdd module
  29  *
  30  * LFSCK controller, which scans the whole device through low layer
  31  * iteration APIs, drives all lfsck compeonents, controls the speed.
  32  *
  33  * Author: Fan Yong <yong.fan@whamcloud.com>
  34  */
  35
  36 #ifndef EXPORT_SYMTAB
  37 # define EXPORT_SYMTAB
  38 #endif
  39 #define DEBUG_SUBSYSTEM S_MDS
  40
  41 #include <lustre/lustre_idl.h>
  42 #include <lustre_fid.h>
  43 #include <obd_support.h>
  44
  45 #include "mdd_internal.h"
  46 #include "mdd_lfsck.h"
  47
  48 #define HALF_SEC                        (CFS_HZ >> 1)
  49 #define LFSCK_CHECKPOINT_INTERVAL       60
  50 #define MDS_DIR_DUMMY_START             0xffffffffffffffffULL
  51
  52 #define LFSCK_NAMEENTRY_DEAD            1 /* The object has been unlinked. */
  53 #define LFSCK_NAMEENTRY_REMOVED         2 /* The entry has been removed. */
  54 #define LFSCK_NAMEENTRY_RECREATED       3 /* The entry has been recreated. */
  55
  56 const char lfsck_bookmark_name[] = "lfsck_bookmark";
  57 const char lfsck_namespace_name[] = "lfsck_namespace";
  58
  59 static const char *lfsck_status_names[] = {
  60         "init",
  61         "scanning-phase1",
  62         "scanning-phase2",
  63         "completed",
  64         "failed",
  65         "stopped",
  66         "paused",
  67         "crashed",
  68         NULL
  69 };
  70
  71 static const char *lfsck_flags_names[] = {
  72         "scanned-once",
  73         "inconsistent",
  74         "upgrade",
  75         NULL
  76 };
  77
  78 static const char *lfsck_param_names[] = {
  79         "failout",
  80         "dryrun",
  81         NULL
  82 };
  83
  84 /* misc functions */
  85
  86 static inline struct mdd_device *mdd_lfsck2mdd(struct md_lfsck *lfsck)
  87 {
  88         return container_of0(lfsck, struct mdd_device, mdd_lfsck);
  89 }
  90
  91 static inline char *mdd_lfsck2name(struct md_lfsck *lfsck)
  92 {
  93         struct mdd_device *mdd = mdd_lfsck2mdd(lfsck);
  94
  95         return mdd2obd_dev(mdd)->obd_name;
  96 }
  97
  98 static inline void mdd_lfsck_component_get(struct lfsck_component *com)
  99 {
 100         atomic_inc(&com->lc_ref);
 101 }
 102
 103 static inline void mdd_lfsck_component_put(const struct lu_env *env,
 104                                            struct lfsck_component *com)
 105 {
 106         if (atomic_dec_and_test(&com->lc_ref)) {
 107                 if (com->lc_obj != NULL)
 108                         lu_object_put(env, &com->lc_obj->do_lu);
 109                 if (com->lc_file_ram != NULL)
 110                         OBD_FREE(com->lc_file_ram, com->lc_file_size);
 111                 if (com->lc_file_disk != NULL)
 112                         OBD_FREE(com->lc_file_disk, com->lc_file_size);
 113                 OBD_FREE_PTR(com);
 114         }
 115 }
 116
 117 static inline struct lfsck_component *
 118 __mdd_lfsck_component_find(struct md_lfsck *lfsck, __u16 type, cfs_list_t *list)
 119 {
 120         struct lfsck_component *com;
 121
 122         cfs_list_for_each_entry(com, list, lc_link) {
 123                 if (com->lc_type == type)
 124                         return com;
 125         }
 126         return NULL;
 127 }
 128
 129 static struct lfsck_component *
 130 mdd_lfsck_component_find(struct md_lfsck *lfsck, __u16 type)
 131 {
 132         struct lfsck_component *com;
 133
 134         spin_lock(&lfsck->ml_lock);
 135         com = __mdd_lfsck_component_find(lfsck, type, &lfsck->ml_list_scan);
 136         if (com != NULL)
 137                 goto unlock;
 138
 139         com = __mdd_lfsck_component_find(lfsck, type,
 140                                          &lfsck->ml_list_double_scan);
 141         if (com != NULL)
 142                 goto unlock;
 143
 144         com = __mdd_lfsck_component_find(lfsck, type, &lfsck->ml_list_idle);
 145
 146 unlock:
 147         if (com != NULL)
 148                 mdd_lfsck_component_get(com);
 149         spin_unlock(&lfsck->ml_lock);
 150         return com;
 151 }
 152
 153 static void mdd_lfsck_component_cleanup(const struct lu_env *env,
 154                                         struct lfsck_component *com)
 155 {
 156         if (!cfs_list_empty(&com->lc_link))
 157                 cfs_list_del_init(&com->lc_link);
 158         if (!cfs_list_empty(&com->lc_link_dir))
 159                 cfs_list_del_init(&com->lc_link_dir);
 160
 161         mdd_lfsck_component_put(env, com);
 162 }
 163
 164 static int lfsck_bits_dump(char **buf, int *len, int bits, const char *names[],
 165                            const char *prefix)
 166 {
 167         int save = *len;
 168         int flag;
 169         int rc;
 170         int i;
 171
 172         rc = snprintf(*buf, *len, "%s:%c", prefix, bits != 0 ? ' ' : '\n');
 173         if (rc <= 0)
 174                 return -ENOSPC;
 175
 176         *buf += rc;
 177         *len -= rc;
 178         for (i = 0, flag = 1; bits != 0; i++, flag = 1 << i) {
 179                 if (flag & bits) {
 180                         bits &= ~flag;
 181                         rc = snprintf(*buf, *len, "%s%c", names[i],
 182                                       bits != 0 ? ',' : '\n');
 183                         if (rc <= 0)
 184                                 return -ENOSPC;
 185
 186                         *buf += rc;
 187                         *len -= rc;
 188                 }
 189         }
 190         return save - *len;
 191 }
 192
 193 static int lfsck_time_dump(char **buf, int *len, __u64 time, const char *prefix)
 194 {
 195         int rc;
 196
 197         if (time != 0)
 198                 rc = snprintf(*buf, *len, "%s: "LPU64" seconds\n", prefix,
 199                               cfs_time_current_sec() - time);
 200         else
 201                 rc = snprintf(*buf, *len, "%s: N/A\n", prefix);
 202         if (rc <= 0)
 203                 return -ENOSPC;
 204
 205         *buf += rc;
 206         *len -= rc;
 207         return rc;
 208 }
 209
 210 static int lfsck_pos_dump(char **buf, int *len, struct lfsck_position *pos,
 211                           const char *prefix)
 212 {
 213         int rc;
 214
 215         if (fid_is_zero(&pos->lp_dir_parent)) {
 216                 if (pos->lp_oit_cookie == 0)
 217                         rc = snprintf(*buf, *len, "%s: N/A, N/A, N/A\n",
 218                                       prefix);
 219                 else
 220                         rc = snprintf(*buf, *len, "%s: "LPU64", N/A, N/A\n",
 221                                       prefix, pos->lp_oit_cookie);
 222         } else {
 223                 rc = snprintf(*buf, *len, "%s: "LPU64", "DFID", "LPU64"\n",
 224                               prefix, pos->lp_oit_cookie,
 225                               PFID(&pos->lp_dir_parent), pos->lp_dir_cookie);
 226         }
 227         if (rc <= 0)
 228                 return -ENOSPC;
 229
 230         *buf += rc;
 231         *len -= rc;
 232         return rc;
 233 }
 234
 235 static void mdd_lfsck_pos_fill(const struct lu_env *env, struct md_lfsck *lfsck,
 236                                struct lfsck_position *pos, bool oit_processed,
 237                                bool dir_processed)
 238 {
 239         const struct dt_it_ops *iops = &lfsck->ml_obj_oit->do_index_ops->dio_it;
 240
 241         spin_lock(&lfsck->ml_lock);
 242         if (unlikely(lfsck->ml_di_oit == NULL)) {
 243                 spin_unlock(&lfsck->ml_lock);
 244                 memset(pos, 0, sizeof(*pos));
 245                 return;
 246         }
 247
 248         pos->lp_oit_cookie = iops->store(env, lfsck->ml_di_oit);
 249
 250         LASSERT(pos->lp_oit_cookie > 0);
 251
 252         if (!oit_processed)
 253                 pos->lp_oit_cookie--;
 254
 255         if (lfsck->ml_di_dir != NULL) {
 256                 struct dt_object *dto = lfsck->ml_obj_dir;
 257
 258                 pos->lp_dir_parent = *lu_object_fid(&dto->do_lu);
 259                 pos->lp_dir_cookie = dto->do_index_ops->dio_it.store(env,
 260                                                         lfsck->ml_di_dir);
 261
 262                 LASSERT(pos->lp_dir_cookie != MDS_DIR_DUMMY_START);
 263
 264                 if (pos->lp_dir_cookie == MDS_DIR_END_OFF)
 265                         LASSERT(dir_processed);
 266
 267                 /* For the dir which just to be processed,
 268                  * lp_dir_cookie will become MDS_DIR_DUMMY_START,
 269                  * which can be correctly handled by mdd_lfsck_prep. */
 270                 if (!dir_processed)
 271                         pos->lp_dir_cookie--;
 272         } else {
 273                 fid_zero(&pos->lp_dir_parent);
 274                 pos->lp_dir_cookie = 0;
 275         }
 276         spin_unlock(&lfsck->ml_lock);
 277 }
 278
 279 static inline void mdd_lfsck_pos_set_zero(struct lfsck_position *pos)
 280 {
 281         memset(pos, 0, sizeof(*pos));
 282 }
 283
 284 static inline int mdd_lfsck_pos_is_zero(const struct lfsck_position *pos)
 285 {
 286         return pos->lp_oit_cookie == 0 && fid_is_zero(&pos->lp_dir_parent);
 287 }
 288
 289 static inline int mdd_lfsck_pos_is_eq(const struct lfsck_position *pos1,
 290                                       const struct lfsck_position *pos2)
 291 {
 292         if (pos1->lp_oit_cookie < pos2->lp_oit_cookie)
 293                 return -1;
 294
 295         if (pos1->lp_oit_cookie > pos2->lp_oit_cookie)
 296                 return 1;
 297
 298         if (fid_is_zero(&pos1->lp_dir_parent) &&
 299             !fid_is_zero(&pos2->lp_dir_parent))
 300                 return -1;
 301
 302         if (!fid_is_zero(&pos1->lp_dir_parent) &&
 303             fid_is_zero(&pos2->lp_dir_parent))
 304                 return 1;
 305
 306         if (fid_is_zero(&pos1->lp_dir_parent) &&
 307             fid_is_zero(&pos2->lp_dir_parent))
 308                 return 0;
 309
 310         LASSERT(lu_fid_eq(&pos1->lp_dir_parent, &pos2->lp_dir_parent));
 311
 312         if (pos1->lp_dir_cookie < pos2->lp_dir_cookie)
 313                 return -1;
 314
 315         if (pos1->lp_dir_cookie > pos2->lp_dir_cookie)
 316                 return 1;
 317
 318         return 0;
 319 }
 320
 321 static void mdd_lfsck_close_dir(const struct lu_env *env,
 322                                 struct md_lfsck *lfsck)
 323 {
 324         struct dt_object        *dir_obj  = lfsck->ml_obj_dir;
 325         const struct dt_it_ops  *dir_iops = &dir_obj->do_index_ops->dio_it;
 326         struct dt_it            *dir_di   = lfsck->ml_di_dir;
 327
 328         spin_lock(&lfsck->ml_lock);
 329         lfsck->ml_di_dir = NULL;
 330         spin_unlock(&lfsck->ml_lock);
 331
 332         dir_iops->put(env, dir_di);
 333         dir_iops->fini(env, dir_di);
 334         lfsck->ml_obj_dir = NULL;
 335         lu_object_put(env, &dir_obj->do_lu);
 336 }
 337
 338 static void __mdd_lfsck_set_speed(struct md_lfsck *lfsck, __u32 limit)
 339 {
 340         lfsck->ml_bookmark_ram.lb_speed_limit = limit;
 341         if (limit != LFSCK_SPEED_NO_LIMIT) {
 342                 if (limit > CFS_HZ) {
 343                         lfsck->ml_sleep_rate = limit / CFS_HZ;
 344                         lfsck->ml_sleep_jif = 1;
 345                 } else {
 346                         lfsck->ml_sleep_rate = 1;
 347                         lfsck->ml_sleep_jif = CFS_HZ / limit;
 348                 }
 349         } else {
 350                 lfsck->ml_sleep_jif = 0;
 351                 lfsck->ml_sleep_rate = 0;
 352         }
 353 }
 354
 355 static void mdd_lfsck_control_speed(struct md_lfsck *lfsck)
 356 {
 357         struct ptlrpc_thread *thread = &lfsck->ml_thread;
 358         struct l_wait_info    lwi;
 359
 360         if (lfsck->ml_sleep_jif > 0 &&
 361             lfsck->ml_new_scanned >= lfsck->ml_sleep_rate) {
 362                 spin_lock(&lfsck->ml_lock);
 363                 if (likely(lfsck->ml_sleep_jif > 0 &&
 364                            lfsck->ml_new_scanned >= lfsck->ml_sleep_rate)) {
 365                         lwi = LWI_TIMEOUT_INTR(lfsck->ml_sleep_jif, NULL,
 366                                                LWI_ON_SIGNAL_NOOP, NULL);
 367                         spin_unlock(&lfsck->ml_lock);
 368
 369                         l_wait_event(thread->t_ctl_waitq,
 370                                      !thread_is_running(thread),
 371                                      &lwi);
 372                         lfsck->ml_new_scanned = 0;
 373                 } else {
 374                         spin_unlock(&lfsck->ml_lock);
 375                 }
 376         }
 377 }
 378
 379 /* lfsck_bookmark file ops */
 380
 381 static void inline mdd_lfsck_bookmark_to_cpu(struct lfsck_bookmark *des,
 382                                              struct lfsck_bookmark *src)
 383 {
 384         des->lb_magic = le32_to_cpu(src->lb_magic);
 385         des->lb_version = le16_to_cpu(src->lb_version);
 386         des->lb_param = le16_to_cpu(src->lb_param);
 387         des->lb_speed_limit = le32_to_cpu(src->lb_speed_limit);
 388 }
 389
 390 static void inline mdd_lfsck_bookmark_to_le(struct lfsck_bookmark *des,
 391                                             struct lfsck_bookmark *src)
 392 {
 393         des->lb_magic = cpu_to_le32(src->lb_magic);
 394         des->lb_version = cpu_to_le16(src->lb_version);
 395         des->lb_param = cpu_to_le16(src->lb_param);
 396         des->lb_speed_limit = cpu_to_le32(src->lb_speed_limit);
 397 }
 398
 399 static int mdd_lfsck_bookmark_load(const struct lu_env *env,
 400                                    struct md_lfsck *lfsck)
 401 {
 402         loff_t pos = 0;
 403         int    len = sizeof(struct lfsck_bookmark);
 404         int    rc;
 405
 406         rc = dt_record_read(env, lfsck->ml_bookmark_obj,
 407                             mdd_buf_get(env, &lfsck->ml_bookmark_disk, len),
 408                             &pos);
 409         if (rc == 0) {
 410                 struct lfsck_bookmark *bm = &lfsck->ml_bookmark_ram;
 411
 412                 mdd_lfsck_bookmark_to_cpu(bm, &lfsck->ml_bookmark_disk);
 413                 if (bm->lb_magic != LFSCK_BOOKMARK_MAGIC) {
 414                         CWARN("%.16s: invalid lfsck_bookmark magic "
 415                               "0x%x != 0x%x\n", mdd_lfsck2name(lfsck),
 416                               bm->lb_magic, LFSCK_BOOKMARK_MAGIC);
 417                         /* Process it as new lfsck_bookmark. */
 418                         rc = -ENODATA;
 419                 }
 420         } else {
 421                 if (rc == -EFAULT && pos == 0)
 422                         /* return -ENODATA for empty lfsck_bookmark. */
 423                         rc = -ENODATA;
 424                 else
 425                         CERROR("%.16s: fail to load lfsck_bookmark, "
 426                                "expected = %d, rc = %d\n",
 427                                mdd_lfsck2name(lfsck), len, rc);
 428         }
 429         return rc;
 430 }
 431
 432 static int mdd_lfsck_bookmark_store(const struct lu_env *env,
 433                                     struct md_lfsck *lfsck)
 434 {
 435         struct mdd_device *mdd    = mdd_lfsck2mdd(lfsck);
 436         struct thandle    *handle;
 437         struct dt_object  *obj    = lfsck->ml_bookmark_obj;
 438         loff_t             pos    = 0;
 439         int                len    = sizeof(struct lfsck_bookmark);
 440         int                rc;
 441         ENTRY;
 442
 443         mdd_lfsck_bookmark_to_le(&lfsck->ml_bookmark_disk,
 444                                  &lfsck->ml_bookmark_ram);
 445         handle = dt_trans_create(env, mdd->mdd_bottom);
 446         if (IS_ERR(handle)) {
 447                 rc = PTR_ERR(handle);
 448                 CERROR("%.16s: fail to create trans for storing "
 449                        "lfsck_bookmark: %d\n,", mdd_lfsck2name(lfsck), rc);
 450                 RETURN(rc);
 451         }
 452
 453         rc = dt_declare_record_write(env, obj, len, 0, handle);
 454         if (rc != 0) {
 455                 CERROR("%.16s: fail to declare trans for storing "
 456                        "lfsck_bookmark: %d\n,", mdd_lfsck2name(lfsck), rc);
 457                 GOTO(out, rc);
 458         }
 459
 460         rc = dt_trans_start_local(env, mdd->mdd_bottom, handle);
 461         if (rc != 0) {
 462                 CERROR("%.16s: fail to start trans for storing "
 463                        "lfsck_bookmark: %d\n,", mdd_lfsck2name(lfsck), rc);
 464                 GOTO(out, rc);
 465         }
 466
 467         rc = dt_record_write(env, obj,
 468                              mdd_buf_get(env, &lfsck->ml_bookmark_disk, len),
 469                              &pos, handle);
 470         if (rc != 0)
 471                 CERROR("%.16s: fail to store lfsck_bookmark, expected = %d, "
 472                        "rc = %d\n", mdd_lfsck2name(lfsck), len, rc);
 473
 474         GOTO(out, rc);
 475
 476 out:
 477         dt_trans_stop(env, mdd->mdd_bottom, handle);
 478         return rc;
 479 }
 480
 481 static int mdd_lfsck_bookmark_init(const struct lu_env *env,
 482                                    struct md_lfsck *lfsck)
 483 {
 484         struct lfsck_bookmark *mb = &lfsck->ml_bookmark_ram;
 485         int rc;
 486
 487         memset(mb, 0, sizeof(mb));
 488         mb->lb_magic = LFSCK_BOOKMARK_MAGIC;
 489         mb->lb_version = LFSCK_VERSION_V2;
 490         mutex_lock(&lfsck->ml_mutex);
 491         rc = mdd_lfsck_bookmark_store(env, lfsck);
 492         mutex_unlock(&lfsck->ml_mutex);
 493         return rc;
 494 }
 495
 496 /* lfsck_namespace file ops */
 497
 498 static void inline mdd_lfsck_position_to_cpu(struct lfsck_position *des,
 499                                              struct lfsck_position *src)
 500 {
 501         des->lp_oit_cookie = le64_to_cpu(src->lp_oit_cookie);
 502         fid_le_to_cpu(&des->lp_dir_parent, &src->lp_dir_parent);
 503         des->lp_dir_cookie = le64_to_cpu(src->lp_dir_cookie);
 504 }
 505
 506 static void inline mdd_lfsck_position_to_le(struct lfsck_position *des,
 507                                              struct lfsck_position *src)
 508 {
 509         des->lp_oit_cookie = cpu_to_le64(src->lp_oit_cookie);
 510         fid_cpu_to_le(&des->lp_dir_parent, &src->lp_dir_parent);
 511         des->lp_dir_cookie = cpu_to_le64(src->lp_dir_cookie);
 512 }
 513
 514 static void inline mdd_lfsck_namespace_to_cpu(struct lfsck_namespace *des,
 515                                               struct lfsck_namespace *src)
 516 {
 517         des->ln_magic = le32_to_cpu(src->ln_magic);
 518         des->ln_status = le32_to_cpu(src->ln_status);
 519         des->ln_flags = le32_to_cpu(src->ln_flags);
 520         des->ln_success_count = le32_to_cpu(src->ln_success_count);
 521         des->ln_run_time_phase1 = le32_to_cpu(src->ln_run_time_phase1);
 522         des->ln_run_time_phase2 = le32_to_cpu(src->ln_run_time_phase2);
 523         des->ln_time_last_complete = le64_to_cpu(src->ln_time_last_complete);
 524         des->ln_time_latest_start = le64_to_cpu(src->ln_time_latest_start);
 525         des->ln_time_last_checkpoint =
 526                                 le64_to_cpu(src->ln_time_last_checkpoint);
 527         mdd_lfsck_position_to_cpu(&des->ln_pos_latest_start,
 528                                   &src->ln_pos_latest_start);
 529         mdd_lfsck_position_to_cpu(&des->ln_pos_last_checkpoint,
 530                                   &src->ln_pos_last_checkpoint);
 531         mdd_lfsck_position_to_cpu(&des->ln_pos_first_inconsistent,
 532                                   &src->ln_pos_first_inconsistent);
 533         des->ln_items_checked = le64_to_cpu(src->ln_items_checked);
 534         des->ln_items_repaired = le64_to_cpu(src->ln_items_repaired);
 535         des->ln_items_failed = le64_to_cpu(src->ln_items_failed);
 536         des->ln_dirs_checked = le64_to_cpu(src->ln_dirs_checked);
 537         des->ln_mlinked_checked = le64_to_cpu(src->ln_mlinked_checked);
 538         des->ln_objs_checked_phase2 = le64_to_cpu(src->ln_objs_checked_phase2);
 539         des->ln_objs_repaired_phase2 =
 540                                 le64_to_cpu(src->ln_objs_repaired_phase2);
 541         des->ln_objs_failed_phase2 = le64_to_cpu(src->ln_objs_failed_phase2);
 542         des->ln_objs_nlink_repaired = le64_to_cpu(src->ln_objs_nlink_repaired);
 543         des->ln_objs_lost_found = le64_to_cpu(src->ln_objs_lost_found);
 544         fid_le_to_cpu(&des->ln_fid_latest_scanned_phase2,
 545                       &src->ln_fid_latest_scanned_phase2);
 546 }
 547
 548 static void inline mdd_lfsck_namespace_to_le(struct lfsck_namespace *des,
 549                                              struct lfsck_namespace *src)
 550 {
 551         des->ln_magic = cpu_to_le32(src->ln_magic);
 552         des->ln_status = cpu_to_le32(src->ln_status);
 553         des->ln_flags = cpu_to_le32(src->ln_flags);
 554         des->ln_success_count = cpu_to_le32(src->ln_success_count);
 555         des->ln_run_time_phase1 = cpu_to_le32(src->ln_run_time_phase1);
 556         des->ln_run_time_phase2 = cpu_to_le32(src->ln_run_time_phase2);
 557         des->ln_time_last_complete = cpu_to_le64(src->ln_time_last_complete);
 558         des->ln_time_latest_start = cpu_to_le64(src->ln_time_latest_start);
 559         des->ln_time_last_checkpoint =
 560                                 cpu_to_le64(src->ln_time_last_checkpoint);
 561         mdd_lfsck_position_to_le(&des->ln_pos_latest_start,
 562                                  &src->ln_pos_latest_start);
 563         mdd_lfsck_position_to_le(&des->ln_pos_last_checkpoint,
 564                                  &src->ln_pos_last_checkpoint);
 565         mdd_lfsck_position_to_le(&des->ln_pos_first_inconsistent,
 566                                  &src->ln_pos_first_inconsistent);
 567         des->ln_items_checked = cpu_to_le64(src->ln_items_checked);
 568         des->ln_items_repaired = cpu_to_le64(src->ln_items_repaired);
 569         des->ln_items_failed = cpu_to_le64(src->ln_items_failed);
 570         des->ln_dirs_checked = cpu_to_le64(src->ln_dirs_checked);
 571         des->ln_mlinked_checked = cpu_to_le64(src->ln_mlinked_checked);
 572         des->ln_objs_checked_phase2 = cpu_to_le64(src->ln_objs_checked_phase2);
 573         des->ln_objs_repaired_phase2 =
 574                                 cpu_to_le64(src->ln_objs_repaired_phase2);
 575         des->ln_objs_failed_phase2 = cpu_to_le64(src->ln_objs_failed_phase2);
 576         des->ln_objs_nlink_repaired = cpu_to_le64(src->ln_objs_nlink_repaired);
 577         des->ln_objs_lost_found = cpu_to_le64(src->ln_objs_lost_found);
 578         fid_cpu_to_le(&des->ln_fid_latest_scanned_phase2,
 579                       &src->ln_fid_latest_scanned_phase2);
 580 }
 581
 582 /**
 583  * \retval +ve: the lfsck_namespace is broken, the caller should reset it.
 584  * \retval 0: succeed.
 585  * \retval -ve: failed cases.
 586  */
 587 static int mdd_lfsck_namespace_load(const struct lu_env *env,
 588                                     struct lfsck_component *com)
 589 {
 590         int len = com->lc_file_size;
 591         int rc;
 592
 593         rc = dt_xattr_get(env, com->lc_obj,
 594                           mdd_buf_get(env, com->lc_file_disk, len),
 595                           XATTR_NAME_LFSCK_NAMESPACE, BYPASS_CAPA);
 596         if (rc == len) {
 597                 struct lfsck_namespace *ns = com->lc_file_ram;
 598
 599                 mdd_lfsck_namespace_to_cpu(ns,
 600                                 (struct lfsck_namespace *)com->lc_file_disk);
 601                 if (ns->ln_magic != LFSCK_NAMESPACE_MAGIC) {
 602                         CWARN("%.16s: invalid lfsck_namespace magic "
 603                               "0x%x != 0x%x\n",
 604                               mdd_lfsck2name(com->lc_lfsck),
 605                               ns->ln_magic, LFSCK_NAMESPACE_MAGIC);
 606                         rc = 1;
 607                 } else {
 608                         rc = 0;
 609                 }
 610         } else if (rc != -ENODATA) {
 611                 CERROR("%.16s: fail to load lfsck_namespace, expected = %d, "
 612                        "rc = %d\n", mdd_lfsck2name(com->lc_lfsck), len, rc);
 613                 if (rc >= 0)
 614                         rc = 1;
 615         }
 616         return rc;
 617 }
 618
 619 static int mdd_lfsck_namespace_store(const struct lu_env *env,
 620                                      struct lfsck_component *com, bool init)
 621 {
 622         struct dt_object  *obj    = com->lc_obj;
 623         struct md_lfsck   *lfsck  = com->lc_lfsck;
 624         struct mdd_device *mdd    = mdd_lfsck2mdd(lfsck);
 625         struct thandle    *handle;
 626         int                len    = com->lc_file_size;
 627         int                rc;
 628         ENTRY;
 629
 630         mdd_lfsck_namespace_to_le((struct lfsck_namespace *)com->lc_file_disk,
 631                                   (struct lfsck_namespace *)com->lc_file_ram);
 632         handle = dt_trans_create(env, mdd->mdd_bottom);
 633         if (IS_ERR(handle)) {
 634                 rc = PTR_ERR(handle);
 635                 CERROR("%.16s: fail to create trans for storing "
 636                        "lfsck_namespace: %d\n,", mdd_lfsck2name(lfsck), rc);
 637                 RETURN(rc);
 638         }
 639
 640         rc = dt_declare_xattr_set(env, obj,
 641                                   mdd_buf_get(env, com->lc_file_disk, len),
 642                                   XATTR_NAME_LFSCK_NAMESPACE, 0, handle);
 643         if (rc != 0) {
 644                 CERROR("%.16s: fail to declare trans for storing "
 645                        "lfsck_namespace: %d\n,", mdd_lfsck2name(lfsck), rc);
 646                 GOTO(out, rc);
 647         }
 648
 649         rc = dt_trans_start_local(env, mdd->mdd_bottom, handle);
 650         if (rc != 0) {
 651                 CERROR("%.16s: fail to start trans for storing "
 652                        "lfsck_namespace: %d\n,", mdd_lfsck2name(lfsck), rc);
 653                 GOTO(out, rc);
 654         }
 655
 656         rc = dt_xattr_set(env, obj,
 657                           mdd_buf_get(env, com->lc_file_disk, len),
 658                           XATTR_NAME_LFSCK_NAMESPACE,
 659                           init ? LU_XATTR_CREATE : LU_XATTR_REPLACE,
 660                           handle, BYPASS_CAPA);
 661         if (rc != 0)
 662                 CERROR("%.16s: fail to store lfsck_namespace, len = %d, "
 663                        "rc = %d\n", mdd_lfsck2name(lfsck), len, rc);
 664
 665         GOTO(out, rc);
 666
 667 out:
 668         dt_trans_stop(env, mdd->mdd_bottom, handle);
 669         return rc;
 670 }
 671
 672 static int mdd_lfsck_namespace_init(const struct lu_env *env,
 673                                     struct lfsck_component *com)
 674 {
 675         struct lfsck_namespace *ns = (struct lfsck_namespace *)com->lc_file_ram;
 676         int rc;
 677
 678         memset(ns, 0, sizeof(*ns));
 679         ns->ln_magic = LFSCK_NAMESPACE_MAGIC;
 680         ns->ln_status = LS_INIT;
 681         down_write(&com->lc_sem);
 682         rc = mdd_lfsck_namespace_store(env, com, true);
 683         up_write(&com->lc_sem);
 684         return rc;
 685 }
 686
 687 static int mdd_declare_lfsck_namespace_unlink(const struct lu_env *env,
 688                                               struct mdd_device *mdd,
 689                                               struct dt_object *p,
 690                                               struct dt_object *c,
 691                                               const char *name,
 692                                               struct thandle *handle)
 693 {
 694         int rc;
 695
 696         rc = dt_declare_delete(env, p, (const struct dt_key *)name, handle);
 697         if (rc != 0)
 698                 return rc;
 699
 700         rc = dt_declare_ref_del(env, c, handle);
 701         if (rc != 0)
 702                 return rc;
 703
 704         rc = dt_declare_destroy(env, c, handle);
 705         return rc;
 706 }
 707
 708 static int mdd_lfsck_namespace_unlink(const struct lu_env *env,
 709                                       struct mdd_device *mdd,
 710                                       struct lfsck_component *com)
 711 {
 712         struct mdd_thread_info  *info   = mdd_env_info(env);
 713         struct lu_fid           *fid    = &info->mti_fid;
 714         struct dt_object        *child  = com->lc_obj;
 715         struct dt_object        *parent;
 716         struct thandle          *handle;
 717         bool                     locked = false;
 718         int                      rc;
 719         ENTRY;
 720
 721         parent = dt_store_resolve(env, mdd->mdd_bottom, "", fid);
 722         if (IS_ERR(parent))
 723                 RETURN(rc = PTR_ERR(parent));
 724
 725         if (!dt_try_as_dir(env, parent))
 726                 GOTO(out, rc = -ENOTDIR);
 727
 728         handle = dt_trans_create(env, mdd->mdd_bottom);
 729         if (IS_ERR(handle))
 730                 GOTO(out, rc = PTR_ERR(handle));
 731
 732         rc = mdd_declare_lfsck_namespace_unlink(env, mdd, parent, child,
 733                                                 lfsck_namespace_name, handle);
 734         if (rc != 0)
 735                 GOTO(stop, rc);
 736
 737         rc = dt_trans_start_local(env, mdd->mdd_bottom, handle);
 738         if (rc != 0)
 739                 GOTO(stop, rc);
 740
 741         dt_write_lock(env, child, MOR_TGT_CHILD);
 742         locked = true;
 743         rc = dt_delete(env, parent, (struct dt_key *)lfsck_namespace_name,
 744                        handle, BYPASS_CAPA);
 745         if (rc != 0)
 746                 GOTO(stop, rc);
 747
 748         rc = child->do_ops->do_ref_del(env, child, handle);
 749         if (rc != 0) {
 750                 lu_local_obj_fid(fid, LFSCK_NAMESPACE_OID);
 751                 rc = dt_insert(env, parent,
 752                                (const struct dt_rec*)fid,
 753                                (const struct dt_key *)lfsck_namespace_name,
 754                                handle, BYPASS_CAPA, 1);
 755
 756                 GOTO(stop, rc);
 757         }
 758
 759
 760         rc = dt_destroy(env, child, handle);
 761
 762         GOTO(stop, rc);
 763
 764 stop:
 765         if (locked)
 766                 dt_write_unlock(env, child);
 767
 768         if (rc == 0) {
 769                 lu_object_put(env, &child->do_lu);
 770                 com->lc_obj = NULL;
 771         }
 772
 773         dt_trans_stop(env, mdd->mdd_bottom, handle);
 774
 775 out:
 776         lu_object_put(env, &parent->do_lu);
 777         return rc;
 778 }
 779
 780 static int mdd_lfsck_namespace_lookup(const struct lu_env *env,
 781                                       struct lfsck_component *com,
 782                                       const struct lu_fid *fid,
 783                                       __u8 *flags)
 784 {
 785         struct lu_fid *key = &mdd_env_info(env)->mti_fid;
 786         int            rc;
 787
 788         fid_cpu_to_be(key, fid);
 789         rc = dt_lookup(env, com->lc_obj, (struct dt_rec *)flags,
 790                        (const struct dt_key *)key, BYPASS_CAPA);
 791         return rc;
 792 }
 793
 794 static int mdd_lfsck_namespace_delete(const struct lu_env *env,
 795                                       struct lfsck_component *com,
 796                                       const struct lu_fid *fid)
 797 {
 798         struct mdd_device *mdd    = mdd_lfsck2mdd(com->lc_lfsck);
 799         struct lu_fid     *key    = &mdd_env_info(env)->mti_fid;
 800         struct thandle    *handle;
 801         struct dt_object *obj     = com->lc_obj;
 802         int               rc;
 803         ENTRY;
 804
 805         handle = dt_trans_create(env, mdd->mdd_bottom);
 806         if (IS_ERR(handle))
 807                 RETURN(PTR_ERR(handle));
 808
 809         rc = dt_declare_delete(env, obj, (const struct dt_key *)fid, handle);
 810         if (rc != 0)
 811                 GOTO(out, rc);
 812
 813         rc = dt_trans_start_local(env, mdd->mdd_bottom, handle);
 814         if (rc != 0)
 815                 GOTO(out, rc);
 816
 817         fid_cpu_to_be(key, fid);
 818         rc = dt_delete(env, obj, (const struct dt_key *)key, handle,
 819                        BYPASS_CAPA);
 820
 821         GOTO(out, rc);
 822
 823 out:
 824         dt_trans_stop(env, mdd->mdd_bottom, handle);
 825         return rc;
 826 }
 827
 828 static int mdd_lfsck_namespace_update(const struct lu_env *env,
 829                                       struct lfsck_component *com,
 830                                       const struct lu_fid *fid,
 831                                       __u8 flags, bool force)
 832 {
 833         struct mdd_device *mdd    = mdd_lfsck2mdd(com->lc_lfsck);
 834         struct lu_fid     *key    = &mdd_env_info(env)->mti_fid;
 835         struct thandle    *handle;
 836         struct dt_object *obj     = com->lc_obj;
 837         int               rc;
 838         bool              exist   = false;
 839         __u8              tf;
 840         ENTRY;
 841
 842         rc = mdd_lfsck_namespace_lookup(env, com, fid, &tf);
 843         if (rc != 0 && rc != -ENOENT)
 844                 RETURN(rc);
 845
 846         if (rc == 0) {
 847                 if (!force || flags == tf)
 848                         RETURN(0);
 849
 850                 exist = true;
 851                 handle = dt_trans_create(env, mdd->mdd_bottom);
 852                 if (IS_ERR(handle))
 853                         RETURN(PTR_ERR(handle));
 854
 855                 rc = dt_declare_delete(env, obj, (const struct dt_key *)fid,
 856                                        handle);
 857                 if (rc != 0)
 858                         GOTO(out, rc);
 859         } else {
 860                 handle = dt_trans_create(env, mdd->mdd_bottom);
 861                 if (IS_ERR(handle))
 862                         RETURN(PTR_ERR(handle));
 863         }
 864
 865         rc = dt_declare_insert(env, obj, (const struct dt_rec *)&flags,
 866                                (const struct dt_key *)fid, handle);
 867         if (rc != 0)
 868                 GOTO(out, rc);
 869
 870         rc = dt_trans_start_local(env, mdd->mdd_bottom, handle);
 871         if (rc != 0)
 872                 GOTO(out, rc);
 873
 874         fid_cpu_to_be(key, fid);
 875         if (exist) {
 876                 rc = dt_delete(env, obj, (const struct dt_key *)key, handle,
 877                                BYPASS_CAPA);
 878                 if (rc != 0) {
 879                         CERROR("%s: fail to insert "DFID", rc = %d\n",
 880                                mdd_lfsck2name(com->lc_lfsck), PFID(fid), rc);
 881                         GOTO(out, rc);
 882                 }
 883         }
 884
 885         rc = dt_insert(env, obj, (const struct dt_rec *)&flags,
 886                        (const struct dt_key *)key, handle, BYPASS_CAPA, 1);
 887
 888         GOTO(out, rc);
 889
 890 out:
 891         dt_trans_stop(env, mdd->mdd_bottom, handle);
 892         return rc;
 893 }
 894
 895 /**
 896  * \retval +ve  repaired
 897  * \retval 0    no need to repair
 898  * \retval -ve  error cases
 899  */
 900 static int mdd_lfsck_namespace_double_scan_one(const struct lu_env *env,
 901                                                struct lfsck_component *com,
 902                                                struct mdd_object *child,
 903                                                __u8 flags)
 904 {
 905         struct mdd_thread_info  *info     = mdd_env_info(env);
 906         struct lu_attr          *la       = &info->mti_la;
 907         struct lu_name          *cname    = &info->mti_name;
 908         struct lu_fid           *pfid     = &info->mti_fid;
 909         struct lu_fid           *cfid     = &info->mti_fid2;
 910         struct md_lfsck         *lfsck    = com->lc_lfsck;
 911         struct mdd_device       *mdd      = mdd_lfsck2mdd(lfsck);
 912         struct lfsck_bookmark   *bk       = &lfsck->ml_bookmark_ram;
 913         struct lfsck_namespace  *ns       =
 914                                 (struct lfsck_namespace *)com->lc_file_ram;
 915         struct linkea_data       ldata    = { 0 };
 916         struct thandle          *handle   = NULL;
 917         bool                     locked   = false;
 918         bool                     update   = false;
 919         int                      count;
 920         int                      rc;
 921         ENTRY;
 922
 923         if (com->lc_journal) {
 924
 925 again:
 926                 LASSERT(!locked);
 927
 928                 com->lc_journal = 1;
 929                 handle = mdd_trans_create(env, mdd);
 930                 if (IS_ERR(handle))
 931                         RETURN(rc = PTR_ERR(handle));
 932
 933                 rc = mdd_declare_links_add(env, child, handle, NULL);
 934                 if (rc != 0)
 935                         GOTO(stop, rc);
 936
 937                 rc = mdd_trans_start(env, mdd, handle);
 938                 if (rc != 0)
 939                         GOTO(stop, rc);
 940
 941                 mdd_write_lock(env, child, MOR_TGT_CHILD);
 942                 locked = true;
 943         }
 944
 945         if (unlikely(mdd_is_dead_obj(child)))
 946                 GOTO(stop, rc = 0);
 947
 948         rc = mdd_links_read(env, child, &ldata);
 949         if (rc != 0) {
 950                 if ((bk->lb_param & LPF_DRYRUN) &&
 951                     (rc == -EINVAL || rc == -ENODATA))
 952                         rc = 1;
 953
 954                 GOTO(stop, rc);
 955         }
 956
 957         rc = mdd_la_get(env, child, la, BYPASS_CAPA);
 958         if (rc != 0)
 959                 GOTO(stop, rc);
 960
 961         ldata.ld_lee = LINKEA_FIRST_ENTRY(ldata);
 962         count = ldata.ld_leh->leh_reccount;
 963         while (count-- > 0) {
 964                 struct mdd_object *parent = NULL;
 965                 struct dt_object *dir;
 966
 967                 linkea_entry_unpack(ldata.ld_lee, &ldata.ld_reclen, cname,
 968                                     pfid);
 969                 if (!fid_is_sane(pfid))
 970                         goto shrink;
 971
 972                 parent = mdd_object_find(env, mdd, pfid);
 973                 if (parent == NULL)
 974                         goto shrink;
 975                 else if (IS_ERR(parent))
 976                         GOTO(stop, rc = PTR_ERR(parent));
 977
 978                 if (!mdd_object_exists(parent))
 979                         goto shrink;
 980
 981                 /* XXX: need more processing for remote object in the future. */
 982                 if (mdd_object_remote(parent)) {
 983                         mdd_object_put(env, parent);
 984                         ldata.ld_lee = LINKEA_NEXT_ENTRY(ldata);
 985                         continue;
 986                 }
 987
 988                 dir = mdd_object_child(parent);
 989                 if (unlikely(!dt_try_as_dir(env, dir)))
 990                         goto shrink;
 991
 992                 /* To guarantee the 'name' is terminated with '0'. */
 993                 memcpy(info->mti_key, cname->ln_name, cname->ln_namelen);
 994                 info->mti_key[cname->ln_namelen] = 0;
 995                 cname->ln_name = info->mti_key;
 996                 rc = dt_lookup(env, dir, (struct dt_rec *)cfid,
 997                                (const struct dt_key *)cname->ln_name,
 998                                BYPASS_CAPA);
 999                 if (rc != 0 && rc != -ENOENT) {
1000                         mdd_object_put(env, parent);
1001                         GOTO(stop, rc);
1002                 }
1003
1004                 if (rc == 0) {
1005                         if (lu_fid_eq(cfid, mdo2fid(child))) {
1006                                 mdd_object_put(env, parent);
1007                                 ldata.ld_lee = LINKEA_NEXT_ENTRY(ldata);
1008                                 continue;
1009                         }
1010
1011                         goto shrink;
1012                 }
1013
1014                 if (ldata.ld_leh->leh_reccount > la->la_nlink)
1015                         goto shrink;
1016
1017                 /* XXX: For the case of there is linkea entry, but without name
1018                  *      entry pointing to the object, and the object link count
1019                  *      isn't less than the count of name entries, then add the
1020                  *      name entry back to namespace.
1021                  *
1022                  *      It is out of LFSCK 1.5 scope, will implement it in the
1023                  *      future. Keep the linkEA entry. */
1024                 mdd_object_put(env, parent);
1025                 ldata.ld_lee = LINKEA_NEXT_ENTRY(ldata);
1026                 continue;
1027
1028 shrink:
1029                 if (parent != NULL)
1030                         mdd_object_put(env, parent);
1031                 if (bk->lb_param & LPF_DRYRUN)
1032                         RETURN(1);
1033
1034                 CDEBUG(D_LFSCK, "Remove linkEA: "DFID"[%.*s], "DFID"\n",
1035                        PFID(mdo2fid(child)), cname->ln_namelen, cname->ln_name,
1036                        PFID(pfid));
1037                 linkea_del_buf(&ldata, cname);
1038                 update = true;
1039         }
1040
1041         if (update) {
1042                 if (!com->lc_journal) {
1043                         com->lc_journal = 1;
1044                         goto again;
1045                 }
1046
1047                 rc = mdd_links_write(env, child, &ldata, handle);
1048         }
1049
1050         GOTO(stop, rc);
1051
1052 stop:
1053         if (locked)
1054                 mdd_write_unlock(env, child);
1055
1056         if (handle != NULL)
1057                 mdd_trans_stop(env, mdd, rc, handle);
1058
1059         if (rc == 0 && update) {
1060                 ns->ln_objs_nlink_repaired++;
1061                 rc = 1;
1062         }
1063         return rc;
1064 }
1065
1066 /* namespace APIs */
1067
1068 static int mdd_lfsck_namespace_reset(const struct lu_env *env,
1069                                      struct lfsck_component *com, bool init)
1070 {
1071         struct mdd_thread_info  *info = mdd_env_info(env);
1072         struct lu_fid           *fid  = &info->mti_fid;
1073         struct lfsck_namespace  *ns   = (struct lfsck_namespace *)com->lc_file_ram;
1074         struct mdd_device       *mdd  = mdd_lfsck2mdd(com->lc_lfsck);
1075         struct md_object        *mdo;
1076         struct dt_object        *dto;
1077         int                      rc;
1078         ENTRY;
1079
1080         down_write(&com->lc_sem);
1081         if (init) {
1082                 memset(ns, 0, sizeof(*ns));
1083         } else {
1084                 __u32 count = ns->ln_success_count;
1085                 __u64 last_time = ns->ln_time_last_complete;
1086
1087                 memset(ns, 0, sizeof(*ns));
1088                 ns->ln_success_count = count;
1089                 ns->ln_time_last_complete = last_time;
1090         }
1091         ns->ln_magic = LFSCK_NAMESPACE_MAGIC;
1092         ns->ln_status = LS_INIT;
1093
1094         rc = mdd_lfsck_namespace_unlink(env, mdd, com);
1095         if (rc != 0)
1096                 GOTO(out, rc);
1097
1098         lu_local_obj_fid(fid, LFSCK_NAMESPACE_OID);
1099         mdo = llo_store_create_index(env, &mdd->mdd_md_dev, mdd->mdd_bottom, "",
1100                                      lfsck_namespace_name, fid,
1101                                      &dt_lfsck_features);
1102         if (IS_ERR(mdo))
1103                 GOTO(out, rc = PTR_ERR(mdo));
1104
1105         lu_object_put(env, &mdo->mo_lu);
1106         dto = dt_store_open(env, mdd->mdd_bottom, "", lfsck_namespace_name, fid);
1107         if (IS_ERR(dto))
1108                 GOTO(out, rc = PTR_ERR(dto));
1109
1110         com->lc_obj = dto;
1111         rc = dto->do_ops->do_index_try(env, dto, &dt_lfsck_features);
1112         if (rc != 0)
1113                 GOTO(out, rc);
1114
1115         rc = mdd_lfsck_namespace_store(env, com, true);
1116
1117         GOTO(out, rc);
1118
1119 out:
1120         up_write(&com->lc_sem);
1121         return rc;
1122 }
1123
1124 static void
1125 mdd_lfsck_namespace_fail(const struct lu_env *env, struct lfsck_component *com,
1126                          bool oit, bool new_checked)
1127 {
1128         struct lfsck_namespace *ns = (struct lfsck_namespace *)com->lc_file_ram;
1129
1130         down_write(&com->lc_sem);
1131         if (new_checked)
1132                 com->lc_new_checked++;
1133         ns->ln_items_failed++;
1134         if (mdd_lfsck_pos_is_zero(&ns->ln_pos_first_inconsistent))
1135                 mdd_lfsck_pos_fill(env, com->lc_lfsck,
1136                                    &ns->ln_pos_first_inconsistent, oit, !oit);
1137         up_write(&com->lc_sem);
1138 }
1139
1140 static int mdd_lfsck_namespace_checkpoint(const struct lu_env *env,
1141                                           struct lfsck_component *com,
1142                                           bool init)
1143 {
1144         struct md_lfsck         *lfsck = com->lc_lfsck;
1145         struct lfsck_namespace  *ns    =
1146                                 (struct lfsck_namespace *)com->lc_file_ram;
1147         int                      rc;
1148
1149         if (com->lc_new_checked == 0 && !init)
1150                 return 0;
1151
1152         down_write(&com->lc_sem);
1153
1154         ns->ln_pos_last_checkpoint = lfsck->ml_pos_current;
1155         if (init) {
1156                 ns->ln_time_last_checkpoint = ns->ln_time_latest_start;
1157                 ns->ln_pos_latest_start = lfsck->ml_pos_current;
1158         } else {
1159                 ns->ln_run_time_phase1 += cfs_duration_sec(cfs_time_current() +
1160                                 HALF_SEC - lfsck->ml_time_last_checkpoint);
1161                 ns->ln_time_last_checkpoint = cfs_time_current_sec();
1162                 ns->ln_items_checked += com->lc_new_checked;
1163                 com->lc_new_checked = 0;
1164         }
1165
1166         rc = mdd_lfsck_namespace_store(env, com, false);
1167
1168         up_write(&com->lc_sem);
1169         return rc;
1170 }
1171
1172 static int mdd_lfsck_namespace_prep(const struct lu_env *env,
1173                                     struct lfsck_component *com)
1174 {
1175         struct md_lfsck         *lfsck  = com->lc_lfsck;
1176         struct lfsck_namespace  *ns     =
1177                                 (struct lfsck_namespace *)com->lc_file_ram;
1178         struct lfsck_position   *pos    = &com->lc_pos_start;
1179
1180         if (ns->ln_status == LS_COMPLETED) {
1181                 int rc;
1182
1183                 rc = mdd_lfsck_namespace_reset(env, com, false);
1184                 if (rc != 0)
1185                         return rc;
1186         }
1187
1188         down_write(&com->lc_sem);
1189
1190         ns->ln_time_latest_start = cfs_time_current_sec();
1191
1192         spin_lock(&lfsck->ml_lock);
1193         if (ns->ln_flags & LF_SCANNED_ONCE) {
1194                 if (!lfsck->ml_drop_dryrun ||
1195                     mdd_lfsck_pos_is_zero(&ns->ln_pos_first_inconsistent)) {
1196                         ns->ln_status = LS_SCANNING_PHASE2;
1197                         cfs_list_del_init(&com->lc_link);
1198                         cfs_list_add_tail(&com->lc_link,
1199                                           &lfsck->ml_list_double_scan);
1200                         if (!cfs_list_empty(&com->lc_link_dir))
1201                                 cfs_list_del_init(&com->lc_link_dir);
1202                         mdd_lfsck_pos_set_zero(pos);
1203                 } else {
1204                         ns->ln_status = LS_SCANNING_PHASE1;
1205                         ns->ln_run_time_phase1 = 0;
1206                         ns->ln_run_time_phase2 = 0;
1207                         ns->ln_items_checked = 0;
1208                         ns->ln_items_repaired = 0;
1209                         ns->ln_items_failed = 0;
1210                         ns->ln_dirs_checked = 0;
1211                         ns->ln_mlinked_checked = 0;
1212                         ns->ln_objs_checked_phase2 = 0;
1213                         ns->ln_objs_repaired_phase2 = 0;
1214                         ns->ln_objs_failed_phase2 = 0;
1215                         ns->ln_objs_nlink_repaired = 0;
1216                         ns->ln_objs_lost_found = 0;
1217                         fid_zero(&ns->ln_fid_latest_scanned_phase2);
1218                         if (cfs_list_empty(&com->lc_link_dir))
1219                                 cfs_list_add_tail(&com->lc_link_dir,
1220                                                   &lfsck->ml_list_dir);
1221                         *pos = ns->ln_pos_first_inconsistent;
1222                 }
1223         } else {
1224                 ns->ln_status = LS_SCANNING_PHASE1;
1225                 if (cfs_list_empty(&com->lc_link_dir))
1226                         cfs_list_add_tail(&com->lc_link_dir,
1227                                           &lfsck->ml_list_dir);
1228                 if (!lfsck->ml_drop_dryrun ||
1229                     mdd_lfsck_pos_is_zero(&ns->ln_pos_first_inconsistent)) {
1230                         *pos = ns->ln_pos_last_checkpoint;
1231                         pos->lp_oit_cookie++;
1232                         if (!fid_is_zero(&pos->lp_dir_parent)) {
1233                                 if (pos->lp_dir_cookie == MDS_DIR_END_OFF) {
1234                                         fid_zero(&pos->lp_dir_parent);
1235                                 } else {
1236                                         pos->lp_dir_cookie++;
1237                                 }
1238                         }
1239                 } else {
1240                         *pos = ns->ln_pos_first_inconsistent;
1241                 }
1242         }
1243         spin_unlock(&lfsck->ml_lock);
1244
1245         up_write(&com->lc_sem);
1246         return 0;
1247 }
1248
1249 static int mdd_lfsck_namespace_exec_oit(const struct lu_env *env,
1250                                         struct lfsck_component *com,
1251                                         struct mdd_object *obj)
1252 {
1253         down_write(&com->lc_sem);
1254         com->lc_new_checked++;
1255         if (S_ISDIR(mdd_object_type(obj)))
1256                 ((struct lfsck_namespace *)com->lc_file_ram)->ln_dirs_checked++;
1257         up_write(&com->lc_sem);
1258         return 0;
1259 }
1260
1261 static int mdd_declare_lfsck_namespace_exec_dir(const struct lu_env *env,
1262                                                 struct mdd_object *obj,
1263                                                 struct thandle *handle)
1264 {
1265         int rc;
1266
1267         /* For destroying all invalid linkEA entries. */
1268         rc = mdo_declare_xattr_del(env, obj, XATTR_NAME_LINK, handle);
1269         if (rc != 0)
1270                 return rc;
1271
1272         /* For insert new linkEA entry. */
1273         rc = mdd_declare_links_add(env, obj, handle, NULL);
1274         return rc;
1275 }
1276
1277 static int mdd_lfsck_namespace_check_exist(const struct lu_env *env,
1278                                            struct md_lfsck *lfsck,
1279                                            struct mdd_object *obj,
1280                                            const char *name)
1281 {
1282         struct dt_object *dir = lfsck->ml_obj_dir;
1283         struct lu_fid    *fid = &mdd_env_info(env)->mti_fid;
1284         int               rc;
1285         ENTRY;
1286
1287         if (unlikely(mdd_is_dead_obj(obj)))
1288                 RETURN(LFSCK_NAMEENTRY_DEAD);
1289
1290         rc = dt_lookup(env, dir, (struct dt_rec *)fid,
1291                        (const struct dt_key *)name, BYPASS_CAPA);
1292         if (rc == -ENOENT)
1293                 RETURN(LFSCK_NAMEENTRY_REMOVED);
1294
1295         if (rc < 0)
1296                 RETURN(rc);
1297
1298         if (!lu_fid_eq(fid, mdo2fid(obj)))
1299                 RETURN(LFSCK_NAMEENTRY_RECREATED);
1300
1301         RETURN(0);
1302 }
1303
1304 static int mdd_lfsck_namespace_exec_dir(const struct lu_env *env,
1305                                         struct lfsck_component *com,
1306                                         struct mdd_object *obj,
1307                                         struct lu_dirent *ent)
1308 {
1309         struct mdd_thread_info     *info     = mdd_env_info(env);
1310         struct lu_attr             *la       = &info->mti_la;
1311         struct md_lfsck            *lfsck    = com->lc_lfsck;
1312         struct lfsck_bookmark      *bk       = &lfsck->ml_bookmark_ram;
1313         struct lfsck_namespace     *ns       =
1314                                 (struct lfsck_namespace *)com->lc_file_ram;
1315         struct mdd_device          *mdd      = mdd_lfsck2mdd(lfsck);
1316         struct linkea_data          ldata    = { 0 };
1317         const struct lu_fid        *pfid     =
1318                                 lu_object_fid(&lfsck->ml_obj_dir->do_lu);
1319         const struct lu_fid        *cfid     = mdo2fid(obj);
1320         const struct lu_name       *cname;
1321         struct thandle             *handle   = NULL;
1322         bool                        repaired = false;
1323         bool                        locked   = false;
1324         int                         count    = 0;
1325         int                         rc;
1326         ENTRY;
1327
1328         cname = mdd_name_get_const(env, ent->lde_name, ent->lde_namelen);
1329         down_write(&com->lc_sem);
1330         com->lc_new_checked++;
1331
1332         if (ent->lde_attrs & LUDA_UPGRADE) {
1333                 ns->ln_flags |= LF_UPGRADE;
1334                 repaired = true;
1335         } else if (ent->lde_attrs & LUDA_REPAIR) {
1336                 ns->ln_flags |= LF_INCONSISTENT;
1337                 repaired = true;
1338         }
1339
1340         if (ent->lde_name[0] == '.' &&
1341             (ent->lde_namelen == 1 ||
1342              (ent->lde_namelen == 2 && ent->lde_name[1] == '.')))
1343                 GOTO(out, rc = 0);
1344
1345         if (!(bk->lb_param & LPF_DRYRUN) &&
1346             (com->lc_journal || repaired)) {
1347
1348 again:
1349                 LASSERT(!locked);
1350
1351                 com->lc_journal = 1;
1352                 handle = mdd_trans_create(env, mdd);
1353                 if (IS_ERR(handle))
1354                         GOTO(out, rc = PTR_ERR(handle));
1355
1356                 rc = mdd_declare_lfsck_namespace_exec_dir(env, obj, handle);
1357                 if (rc != 0)
1358                         GOTO(stop, rc);
1359
1360                 rc = mdd_trans_start(env, mdd, handle);
1361                 if (rc != 0)
1362                         GOTO(stop, rc);
1363
1364                 mdd_write_lock(env, obj, MOR_TGT_CHILD);
1365                 locked = true;
1366         }
1367
1368         rc = mdd_lfsck_namespace_check_exist(env, lfsck, obj, ent->lde_name);
1369         if (rc != 0)
1370                 GOTO(stop, rc);
1371
1372         rc = mdd_links_read(env, obj, &ldata);
1373         if (rc == 0) {
1374                 count = ldata.ld_leh->leh_reccount;
1375                 rc = linkea_links_find(&ldata, cname, pfid);
1376                 if (rc == 0) {
1377                         /* For dir, if there are more than one linkea entries,
1378                          * then remove all the other redundant linkea entries.*/
1379                         if (unlikely(count > 1 &&
1380                                      S_ISDIR(mdd_object_type(obj))))
1381                                 goto unmatch;
1382
1383                         goto record;
1384                 } else {
1385
1386 unmatch:
1387                         ns->ln_flags |= LF_INCONSISTENT;
1388                         if (bk->lb_param & LPF_DRYRUN) {
1389                                 repaired = true;
1390                                 goto record;
1391                         }
1392
1393                         /*For dir, remove the unmatched linkea entry directly.*/
1394                         if (S_ISDIR(mdd_object_type(obj))) {
1395                                 if (!com->lc_journal)
1396                                         goto again;
1397
1398                                 rc = mdo_xattr_del(env, obj, XATTR_NAME_LINK,
1399                                                    handle, BYPASS_CAPA);
1400                                 if (rc != 0)
1401                                         GOTO(stop, rc);
1402
1403                                 goto nodata;
1404                         } else {
1405                                 goto add;
1406                         }
1407                 }
1408         } else if (unlikely(rc == -EINVAL)) {
1409                 ns->ln_flags |= LF_INCONSISTENT;
1410                 if (bk->lb_param & LPF_DRYRUN) {
1411                         count = 1;
1412                         repaired = true;
1413                         goto record;
1414                 }
1415
1416                 if (!com->lc_journal)
1417                         goto again;
1418
1419                 /* The magic crashed, we are not sure whether there are more
1420                  * corrupt data in the linkea, so remove all linkea entries. */
1421                 rc = mdo_xattr_del(env, obj, XATTR_NAME_LINK, handle,
1422                                    BYPASS_CAPA);
1423                 if (rc != 0)
1424                         GOTO(stop, rc);
1425
1426                 goto nodata;
1427         } else if (rc == -ENODATA) {
1428                 ns->ln_flags |= LF_UPGRADE;
1429                 if (bk->lb_param & LPF_DRYRUN) {
1430                         count = 1;
1431                         repaired = true;
1432                         goto record;
1433                 }
1434
1435 nodata:
1436                 rc = linkea_data_new(&ldata, &mdd_env_info(env)->mti_link_buf);
1437                 if (rc != 0)
1438                         GOTO(stop, rc);
1439
1440 add:
1441                 if (!com->lc_journal)
1442                         goto again;
1443
1444                 rc = linkea_add_buf(&ldata, cname, pfid);
1445                 if (rc != 0)
1446                         GOTO(stop, rc);
1447
1448                 rc = mdd_links_write(env, obj, &ldata, handle);
1449                 if (rc != 0)
1450                         GOTO(stop, rc);
1451
1452                 count = ldata.ld_leh->leh_reccount;
1453                 repaired = true;
1454         } else {
1455                 GOTO(stop, rc);
1456         }
1457
1458 record:
1459         LASSERT(count > 0);
1460
1461         rc = mdd_la_get(env, obj, la, BYPASS_CAPA);
1462         if (rc != 0)
1463                 GOTO(stop, rc);
1464
1465         if ((count == 1) &&
1466             (la->la_nlink == 1 || S_ISDIR(mdd_object_type(obj))))
1467                 /* Usually, it is for single linked object or dir, do nothing.*/
1468                 GOTO(stop, rc);
1469
1470         /* Following modification will be in another transaction.  */
1471         if (handle != NULL) {
1472                 LASSERT(mdd_write_locked(env, obj));
1473
1474                 mdd_write_unlock(env, obj);
1475                 locked = false;
1476
1477                 mdd_trans_stop(env, mdd, 0, handle);
1478                 handle = NULL;
1479         }
1480
1481         ns->ln_mlinked_checked++;
1482         rc = mdd_lfsck_namespace_update(env, com, cfid,
1483                         count != la->la_nlink ? LLF_UNMATCH_NLINKS : 0, false);
1484
1485         GOTO(out, rc);
1486
1487 stop:
1488         if (locked)
1489                 mdd_write_unlock(env, obj);
1490
1491         if (handle != NULL)
1492                 mdd_trans_stop(env, mdd, rc, handle);
1493
1494 out:
1495         if (rc < 0) {
1496                 ns->ln_items_failed++;
1497                 if (mdd_lfsck_pos_is_zero(&ns->ln_pos_first_inconsistent))
1498                         mdd_lfsck_pos_fill(env, lfsck,
1499                                            &ns->ln_pos_first_inconsistent,
1500                                            true, false);
1501                 if (!(bk->lb_param & LPF_FAILOUT))
1502                         rc = 0;
1503         } else {
1504                 if (repaired)
1505                         ns->ln_items_repaired++;
1506                 else
1507                         com->lc_journal = 0;
1508                 rc = 0;
1509         }
1510         up_write(&com->lc_sem);
1511         return rc;
1512 }
1513
1514 static int mdd_lfsck_namespace_post(const struct lu_env *env,
1515                                     struct lfsck_component *com,
1516                                     int result)
1517 {
1518         struct md_lfsck         *lfsck = com->lc_lfsck;
1519         struct lfsck_namespace  *ns    =
1520                                 (struct lfsck_namespace *)com->lc_file_ram;
1521         int                      rc;
1522
1523         down_write(&com->lc_sem);
1524
1525         spin_lock(&lfsck->ml_lock);
1526         if (result > 0) {
1527                 ns->ln_status = LS_SCANNING_PHASE2;
1528                 ns->ln_flags |= LF_SCANNED_ONCE;
1529                 ns->ln_flags &= ~LF_UPGRADE;
1530                 cfs_list_del_init(&com->lc_link);
1531                 cfs_list_del_init(&com->lc_link_dir);
1532                 cfs_list_add_tail(&com->lc_link, &lfsck->ml_list_double_scan);
1533         } else if (result == 0) {
1534                 if (lfsck->ml_paused) {
1535                         ns->ln_status = LS_PAUSED;
1536                 } else {
1537                         ns->ln_status = LS_STOPPED;
1538                         cfs_list_del_init(&com->lc_link);
1539                         cfs_list_del_init(&com->lc_link_dir);
1540                         cfs_list_add_tail(&com->lc_link, &lfsck->ml_list_idle);
1541                 }
1542         } else {
1543                 ns->ln_status = LS_FAILED;
1544                 cfs_list_del_init(&com->lc_link);
1545                 cfs_list_del_init(&com->lc_link_dir);
1546                 cfs_list_add_tail(&com->lc_link, &lfsck->ml_list_idle);
1547         }
1548         spin_unlock(&lfsck->ml_lock);
1549
1550         ns->ln_run_time_phase1 += cfs_duration_sec(cfs_time_current() +
1551                                 HALF_SEC - lfsck->ml_time_last_checkpoint);
1552         ns->ln_time_last_checkpoint = cfs_time_current_sec();
1553         ns->ln_items_checked += com->lc_new_checked;
1554         com->lc_new_checked = 0;
1555
1556         rc = mdd_lfsck_namespace_store(env, com, false);
1557
1558         up_write(&com->lc_sem);
1559         return rc;
1560 }
1561
1562 static int
1563 mdd_lfsck_namespace_dump(const struct lu_env *env, struct lfsck_component *com,
1564                          char *buf, int len)
1565 {
1566         struct md_lfsck         *lfsck = com->lc_lfsck;
1567         struct lfsck_bookmark   *bk    = &lfsck->ml_bookmark_ram;
1568         struct lfsck_namespace  *ns    =
1569                                 (struct lfsck_namespace *)com->lc_file_ram;
1570         int                      save  = len;
1571         int                      ret   = -ENOSPC;
1572         int                      rc;
1573
1574         down_read(&com->lc_sem);
1575         rc = snprintf(buf, len,
1576                       "name: lfsck_namespace\n"
1577                       "magic: 0x%x\n"
1578                       "version: %d\n"
1579                       "status: %s\n",
1580                       ns->ln_magic,
1581                       bk->lb_version,
1582                       lfsck_status_names[ns->ln_status]);
1583         if (rc <= 0)
1584                 goto out;
1585
1586         buf += rc;
1587         len -= rc;
1588         rc = lfsck_bits_dump(&buf, &len, ns->ln_flags, lfsck_flags_names,
1589                              "flags");
1590         if (rc < 0)
1591                 goto out;
1592
1593         rc = lfsck_bits_dump(&buf, &len, bk->lb_param, lfsck_param_names,
1594                              "param");
1595         if (rc < 0)
1596                 goto out;
1597
1598         rc = lfsck_time_dump(&buf, &len, ns->ln_time_last_complete,
1599                              "time_since_last_completed");
1600         if (rc < 0)
1601                 goto out;
1602
1603         rc = lfsck_time_dump(&buf, &len, ns->ln_time_latest_start,
1604                              "time_since_latest_start");
1605         if (rc < 0)
1606                 goto out;
1607
1608         rc = lfsck_time_dump(&buf, &len, ns->ln_time_last_checkpoint,
1609                              "time_since_last_checkpoint");
1610         if (rc < 0)
1611                 goto out;
1612
1613         rc = lfsck_pos_dump(&buf, &len, &ns->ln_pos_latest_start,
1614                             "latest_start_position");
1615         if (rc < 0)
1616                 goto out;
1617
1618         rc = lfsck_pos_dump(&buf, &len, &ns->ln_pos_last_checkpoint,
1619                             "last_checkpoint_position");
1620         if (rc < 0)
1621                 goto out;
1622
1623         rc = lfsck_pos_dump(&buf, &len, &ns->ln_pos_first_inconsistent,
1624                             "first_failure_position");
1625         if (rc < 0)
1626                 goto out;
1627
1628         if (ns->ln_status == LS_SCANNING_PHASE1) {
1629                 struct lfsck_position pos;
1630                 cfs_duration_t duration = cfs_time_current() -
1631                                           lfsck->ml_time_last_checkpoint;
1632                 __u64 checked = ns->ln_items_checked + com->lc_new_checked;
1633                 __u64 speed = checked;
1634                 __u64 new_checked = com->lc_new_checked * CFS_HZ;
1635                 __u32 rtime = ns->ln_run_time_phase1 +
1636                               cfs_duration_sec(duration + HALF_SEC);
1637
1638                 if (duration != 0)
1639                         do_div(new_checked, duration);
1640                 if (rtime != 0)
1641                         do_div(speed, rtime);
1642                 rc = snprintf(buf, len,
1643                               "checked_phase1: "LPU64"\n"
1644                               "checked_phase2: "LPU64"\n"
1645                               "updated_phase1: "LPU64"\n"
1646                               "updated_phase2: "LPU64"\n"
1647                               "failed_phase1: "LPU64"\n"
1648                               "failed_phase2: "LPU64"\n"
1649                               "dirs: "LPU64"\n"
1650                               "M-linked: "LPU64"\n"
1651                               "nlinks_repaired: "LPU64"\n"
1652                               "lost_found: "LPU64"\n"
1653                               "success_count: %u\n"
1654                               "run_time_phase1: %u seconds\n"
1655                               "run_time_phase2: %u seconds\n"
1656                               "average_speed_phase1: "LPU64" items/sec\n"
1657                               "average_speed_phase2: N/A\n"
1658                               "real-time_speed_phase1: "LPU64" items/sec\n"
1659                               "real-time_speed_phase2: N/A\n",
1660                               checked,
1661                               ns->ln_objs_checked_phase2,
1662                               ns->ln_items_repaired,
1663                               ns->ln_objs_repaired_phase2,
1664                               ns->ln_items_failed,
1665                               ns->ln_objs_failed_phase2,
1666                               ns->ln_dirs_checked,
1667                               ns->ln_mlinked_checked,
1668                               ns->ln_objs_nlink_repaired,
1669                               ns->ln_objs_lost_found,
1670                               ns->ln_success_count,
1671                               rtime,
1672                               ns->ln_run_time_phase2,
1673                               speed,
1674                               new_checked);
1675                 if (rc <= 0)
1676                         goto out;
1677
1678                 buf += rc;
1679                 len -= rc;
1680                 mdd_lfsck_pos_fill(env, lfsck, &pos, true, true);
1681                 rc = lfsck_pos_dump(&buf, &len, &pos, "current_position");
1682                 if (rc <= 0)
1683                         goto out;
1684         } else if (ns->ln_status == LS_SCANNING_PHASE2) {
1685                 cfs_duration_t duration = cfs_time_current() -
1686                                           lfsck->ml_time_last_checkpoint;
1687                 __u64 checked = ns->ln_objs_checked_phase2 +
1688                                 com->lc_new_checked;
1689                 __u64 speed1 = ns->ln_items_checked;
1690                 __u64 speed2 = checked;
1691                 __u64 new_checked = com->lc_new_checked * CFS_HZ;
1692                 __u32 rtime = ns->ln_run_time_phase2 +
1693                               cfs_duration_sec(duration + HALF_SEC);
1694
1695                 if (duration != 0)
1696                         do_div(new_checked, duration);
1697                 if (ns->ln_run_time_phase1 != 0)
1698                         do_div(speed1, ns->ln_run_time_phase1);
1699                 if (rtime != 0)
1700                         do_div(speed2, rtime);
1701                 rc = snprintf(buf, len,
1702                               "checked_phase1: "LPU64"\n"
1703                               "checked_phase2: "LPU64"\n"
1704                               "updated_phase1: "LPU64"\n"
1705                               "updated_phase2: "LPU64"\n"
1706                               "failed_phase1: "LPU64"\n"
1707                               "failed_phase2: "LPU64"\n"
1708                               "dirs: "LPU64"\n"
1709                               "M-linked: "LPU64"\n"
1710                               "nlinks_repaired: "LPU64"\n"
1711                               "lost_found: "LPU64"\n"
1712                               "success_count: %u\n"
1713                               "run_time_phase1: %u seconds\n"
1714                               "run_time_phase2: %u seconds\n"
1715                               "average_speed_phase1: "LPU64" items/sec\n"
1716                               "average_speed_phase2: "LPU64" objs/sec\n"
1717                               "real-time_speed_phase1: N/A\n"
1718                               "real-time_speed_phase2: "LPU64" objs/sec\n"
1719                               "current_position: "DFID"\n",
1720                               ns->ln_items_checked,
1721                               checked,
1722                               ns->ln_items_repaired,
1723                               ns->ln_objs_repaired_phase2,
1724                               ns->ln_items_failed,
1725                               ns->ln_objs_failed_phase2,
1726                               ns->ln_dirs_checked,
1727                               ns->ln_mlinked_checked,
1728                               ns->ln_objs_nlink_repaired,
1729                               ns->ln_objs_lost_found,
1730                               ns->ln_success_count,
1731                               ns->ln_run_time_phase1,
1732                               rtime,
1733                               speed1,
1734                               speed2,
1735                               new_checked,
1736                               PFID(&ns->ln_fid_latest_scanned_phase2));
1737                 if (rc <= 0)
1738                         goto out;
1739
1740                 buf += rc;
1741                 len -= rc;
1742         } else {
1743                 __u64 speed1 = ns->ln_items_checked;
1744                 __u64 speed2 = ns->ln_objs_checked_phase2;
1745
1746                 if (ns->ln_run_time_phase1 != 0)
1747                         do_div(speed1, ns->ln_run_time_phase1);
1748                 if (ns->ln_run_time_phase2 != 0)
1749                         do_div(speed2, ns->ln_run_time_phase2);
1750                 rc = snprintf(buf, len,
1751                               "checked_phase1: "LPU64"\n"
1752                               "checked_phase2: "LPU64"\n"
1753                               "updated_phase1: "LPU64"\n"
1754                               "updated_phase2: "LPU64"\n"
1755                               "failed_phase1: "LPU64"\n"
1756                               "failed_phase2: "LPU64"\n"
1757                               "dirs: "LPU64"\n"
1758                               "M-linked: "LPU64"\n"
1759                               "nlinks_repaired: "LPU64"\n"
1760                               "lost_found: "LPU64"\n"
1761                               "success_count: %u\n"
1762                               "run_time_phase1: %u seconds\n"
1763                               "run_time_phase2: %u seconds\n"
1764                               "average_speed_phase1: "LPU64" items/sec\n"
1765                               "average_speed_phase2: "LPU64" objs/sec\n"
1766                               "real-time_speed_phase1: N/A\n"
1767                               "real-time_speed_phase2: N/A\n"
1768                               "current_position: N/A\n",
1769                               ns->ln_items_checked,
1770                               ns->ln_objs_checked_phase2,
1771                               ns->ln_items_repaired,
1772                               ns->ln_objs_repaired_phase2,
1773                               ns->ln_items_failed,
1774                               ns->ln_objs_failed_phase2,
1775                               ns->ln_dirs_checked,
1776                               ns->ln_mlinked_checked,
1777                               ns->ln_objs_nlink_repaired,
1778                               ns->ln_objs_lost_found,
1779                               ns->ln_success_count,
1780                               ns->ln_run_time_phase1,
1781                               ns->ln_run_time_phase2,
1782                               speed1,
1783                               speed2);
1784                 if (rc <= 0)
1785                         goto out;
1786
1787                 buf += rc;
1788                 len -= rc;
1789         }
1790         ret = save - len;
1791
1792 out:
1793         up_read(&com->lc_sem);
1794         return ret;
1795 }
1796
1797 static int mdd_lfsck_namespace_double_scan(const struct lu_env *env,
1798                                            struct lfsck_component *com)
1799 {
1800         struct md_lfsck         *lfsck  = com->lc_lfsck;
1801         struct ptlrpc_thread    *thread = &lfsck->ml_thread;
1802         struct mdd_device       *mdd    = mdd_lfsck2mdd(lfsck);
1803         struct lfsck_bookmark   *bk     = &lfsck->ml_bookmark_ram;
1804         struct lfsck_namespace  *ns     =
1805                                 (struct lfsck_namespace *)com->lc_file_ram;
1806         struct dt_object        *obj    = com->lc_obj;
1807         const struct dt_it_ops  *iops   = &obj->do_index_ops->dio_it;
1808         struct mdd_object       *target;
1809         struct dt_it            *di;
1810         struct dt_key           *key;
1811         struct lu_fid            fid;
1812         int                      rc;
1813         __u8                     flags;
1814         ENTRY;
1815
1816         lfsck->ml_new_scanned = 0;
1817         lfsck->ml_time_last_checkpoint = cfs_time_current();
1818         lfsck->ml_time_next_checkpoint = lfsck->ml_time_last_checkpoint +
1819                                 cfs_time_seconds(LFSCK_CHECKPOINT_INTERVAL);
1820
1821         di = iops->init(env, obj, 0, BYPASS_CAPA);
1822         if (IS_ERR(di))
1823                 RETURN(PTR_ERR(di));
1824
1825         fid_cpu_to_be(&fid, &ns->ln_fid_latest_scanned_phase2);
1826         rc = iops->get(env, di, (const struct dt_key *)&fid);
1827         if (rc < 0)
1828                 GOTO(fini, rc);
1829
1830         /* Skip the start one, which either has been processed or non-exist. */
1831         rc = iops->next(env, di);
1832         if (rc != 0)
1833                 GOTO(put, rc);
1834
1835         if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_NO_DOUBLESCAN))
1836                 GOTO(put, rc = 0);
1837
1838         do {
1839                 if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_DELAY3) &&
1840                     cfs_fail_val > 0) {
1841                         struct l_wait_info lwi;
1842
1843                         lwi = LWI_TIMEOUT(cfs_time_seconds(cfs_fail_val),
1844                                           NULL, NULL);
1845                         l_wait_event(thread->t_ctl_waitq,
1846                                      !thread_is_running(thread),
1847                                      &lwi);
1848                 }
1849
1850                 key = iops->key(env, di);
1851                 fid_be_to_cpu(&fid, (const struct lu_fid *)key);
1852                 target = mdd_object_find(env, mdd, &fid);
1853                 down_write(&com->lc_sem);
1854                 if (target == NULL) {
1855                         rc = 0;
1856                         goto checkpoint;
1857                 } else if (IS_ERR(target)) {
1858                         rc = PTR_ERR(target);
1859                         goto checkpoint;
1860                 }
1861
1862                 /* XXX: need more processing for remote object in the future. */
1863                 if (!mdd_object_exists(target) || mdd_object_remote(target))
1864                         goto obj_put;
1865
1866                 rc = iops->rec(env, di, (struct dt_rec *)&flags, 0);
1867                 if (rc == 0)
1868                         rc = mdd_lfsck_namespace_double_scan_one(env, com,
1869                                                                  target, flags);
1870
1871 obj_put:
1872                 mdd_object_put(env, target);
1873
1874 checkpoint:
1875                 lfsck->ml_new_scanned++;
1876                 com->lc_new_checked++;
1877                 ns->ln_fid_latest_scanned_phase2 = fid;
1878                 if (rc > 0)
1879                         ns->ln_objs_repaired_phase2++;
1880                 else if (rc < 0)
1881                         ns->ln_objs_failed_phase2++;
1882                 up_write(&com->lc_sem);
1883
1884                 if ((rc == 0) || ((rc > 0) && !(bk->lb_param & LPF_DRYRUN))) {
1885                         mdd_lfsck_namespace_delete(env, com, &fid);
1886                 } else if (rc < 0) {
1887                         flags |= LLF_REPAIR_FAILED;
1888                         mdd_lfsck_namespace_update(env, com, &fid, flags, true);
1889                 }
1890
1891                 if (rc < 0 && bk->lb_param & LPF_FAILOUT)
1892                         GOTO(put, rc);
1893
1894                 if (likely(cfs_time_beforeq(cfs_time_current(),
1895                                             lfsck->ml_time_next_checkpoint)) ||
1896                     com->lc_new_checked == 0)
1897                         goto speed;
1898
1899                 down_write(&com->lc_sem);
1900                 ns->ln_run_time_phase2 += cfs_duration_sec(cfs_time_current() +
1901                                 HALF_SEC - lfsck->ml_time_last_checkpoint);
1902                 ns->ln_time_last_checkpoint = cfs_time_current_sec();
1903                 ns->ln_objs_checked_phase2 += com->lc_new_checked;
1904                 com->lc_new_checked = 0;
1905                 rc = mdd_lfsck_namespace_store(env, com, false);
1906                 up_write(&com->lc_sem);
1907                 if (rc != 0)
1908                         GOTO(put, rc);
1909
1910                 lfsck->ml_time_last_checkpoint = cfs_time_current();
1911                 lfsck->ml_time_next_checkpoint = lfsck->ml_time_last_checkpoint +
1912                                 cfs_time_seconds(LFSCK_CHECKPOINT_INTERVAL);
1913
1914 speed:
1915                 mdd_lfsck_control_speed(lfsck);
1916                 if (unlikely(!thread_is_running(thread)))
1917                         GOTO(put, rc = 0);
1918
1919                 rc = iops->next(env, di);
1920         } while (rc == 0);
1921
1922         GOTO(put, rc);
1923
1924 put:
1925         iops->put(env, di);
1926
1927 fini:
1928         iops->fini(env, di);
1929         down_write(&com->lc_sem);
1930
1931         ns->ln_run_time_phase2 += cfs_duration_sec(cfs_time_current() +
1932                                 HALF_SEC - lfsck->ml_time_last_checkpoint);
1933         ns->ln_time_last_checkpoint = cfs_time_current_sec();
1934         ns->ln_objs_checked_phase2 += com->lc_new_checked;
1935         com->lc_new_checked = 0;
1936
1937         if (rc > 0) {
1938                 com->lc_journal = 0;
1939                 ns->ln_status = LS_COMPLETED;
1940                 if (!(bk->lb_param & LPF_DRYRUN))
1941                         ns->ln_flags &=
1942                         ~(LF_SCANNED_ONCE | LF_INCONSISTENT | LF_UPGRADE);
1943                 ns->ln_time_last_complete = ns->ln_time_last_checkpoint;
1944                 ns->ln_success_count++;
1945         } else if (rc == 0) {
1946                 if (lfsck->ml_paused)
1947                         ns->ln_status = LS_PAUSED;
1948                 else
1949                         ns->ln_status = LS_STOPPED;
1950         } else {
1951                 ns->ln_status = LS_FAILED;
1952         }
1953
1954         if (ns->ln_status != LS_PAUSED) {
1955                 spin_lock(&lfsck->ml_lock);
1956                 cfs_list_del_init(&com->lc_link);
1957                 cfs_list_add_tail(&com->lc_link, &lfsck->ml_list_idle);
1958                 spin_unlock(&lfsck->ml_lock);
1959         }
1960
1961         rc = mdd_lfsck_namespace_store(env, com, false);
1962
1963         up_write(&com->lc_sem);
1964         return rc;
1965 }
1966
1967 static struct lfsck_operations mdd_lfsck_namespace_ops = {
1968         .lfsck_reset            = mdd_lfsck_namespace_reset,
1969         .lfsck_fail             = mdd_lfsck_namespace_fail,
1970         .lfsck_checkpoint       = mdd_lfsck_namespace_checkpoint,
1971         .lfsck_prep             = mdd_lfsck_namespace_prep,
1972         .lfsck_exec_oit         = mdd_lfsck_namespace_exec_oit,
1973         .lfsck_exec_dir         = mdd_lfsck_namespace_exec_dir,
1974         .lfsck_post             = mdd_lfsck_namespace_post,
1975         .lfsck_dump             = mdd_lfsck_namespace_dump,
1976         .lfsck_double_scan      = mdd_lfsck_namespace_double_scan,
1977 };
1978
1979 /* LFSCK component setup/cleanup functions */
1980
1981 static int mdd_lfsck_namespace_setup(const struct lu_env *env,
1982                                      struct md_lfsck *lfsck)
1983 {
1984         struct mdd_device      *mdd = mdd_lfsck2mdd(lfsck);
1985         struct lfsck_component *com;
1986         struct lfsck_namespace *ns;
1987         struct dt_object       *obj;
1988         int                     rc;
1989         ENTRY;
1990
1991         OBD_ALLOC_PTR(com);
1992         if (com == NULL)
1993                 RETURN(-ENOMEM);
1994
1995         CFS_INIT_LIST_HEAD(&com->lc_link);
1996         CFS_INIT_LIST_HEAD(&com->lc_link_dir);
1997         init_rwsem(&com->lc_sem);
1998         atomic_set(&com->lc_ref, 1);
1999         com->lc_lfsck = lfsck;
2000         com->lc_type = LT_NAMESPACE;
2001         com->lc_ops = &mdd_lfsck_namespace_ops;
2002         com->lc_file_size = sizeof(struct lfsck_namespace);
2003         OBD_ALLOC(com->lc_file_ram, com->lc_file_size);
2004         if (com->lc_file_ram == NULL)
2005                 GOTO(out, rc = -ENOMEM);
2006
2007         OBD_ALLOC(com->lc_file_disk, com->lc_file_size);
2008         if (com->lc_file_disk == NULL)
2009                 GOTO(out, rc = -ENOMEM);
2010
2011         obj = dt_store_open(env, mdd->mdd_bottom, "", lfsck_namespace_name,
2012                             &mdd_env_info(env)->mti_fid);
2013         if (IS_ERR(obj))
2014                 GOTO(out, rc = PTR_ERR(obj));
2015
2016         com->lc_obj = obj;
2017         rc = obj->do_ops->do_index_try(env, obj, &dt_lfsck_features);
2018         if (rc != 0)
2019                 GOTO(out, rc);
2020
2021         rc = mdd_lfsck_namespace_load(env, com);
2022         if (rc > 0)
2023                 rc = mdd_lfsck_namespace_reset(env, com, true);
2024         else if (rc == -ENODATA)
2025                 rc = mdd_lfsck_namespace_init(env, com);
2026         if (rc != 0)
2027                 GOTO(out, rc);
2028
2029         ns = (struct lfsck_namespace *)com->lc_file_ram;
2030         switch (ns->ln_status) {
2031         case LS_INIT:
2032         case LS_COMPLETED:
2033         case LS_FAILED:
2034         case LS_STOPPED:
2035                 cfs_list_add_tail(&com->lc_link, &lfsck->ml_list_idle);
2036                 break;
2037         default:
2038                 CERROR("%s: unknown status: %u\n",
2039                        mdd_lfsck2name(lfsck), ns->ln_status);
2040                 /* fall through */
2041         case LS_SCANNING_PHASE1:
2042         case LS_SCANNING_PHASE2:
2043                 /* No need to store the status to disk right now.
2044                  * If the system crashed before the status stored,
2045                  * it will be loaded back when next time. */
2046                 ns->ln_status = LS_CRASHED;
2047                 /* fall through */
2048         case LS_PAUSED:
2049         case LS_CRASHED:
2050                 cfs_list_add_tail(&com->lc_link, &lfsck->ml_list_scan);
2051                 cfs_list_add_tail(&com->lc_link_dir, &lfsck->ml_list_dir);
2052                 break;
2053         }
2054
2055         GOTO(out, rc = 0);
2056
2057 out:
2058         if (rc != 0)
2059                 mdd_lfsck_component_cleanup(env, com);
2060         return rc;
2061 }
2062
2063 /* helper functions for framework */
2064
2065 static int object_is_client_visible(const struct lu_env *env,
2066                                     struct mdd_device *mdd,
2067                                     struct mdd_object *obj)
2068 {
2069         struct lu_fid *fid   = &mdd_env_info(env)->mti_fid;
2070         int            depth = 0;
2071         int            rc;
2072
2073         LASSERT(S_ISDIR(mdd_object_type(obj)));
2074
2075         while (1) {
2076                 if (mdd_is_root(mdd, mdo2fid(obj))) {
2077                         if (depth > 0)
2078                                 mdd_object_put(env, obj);
2079                         return 1;
2080                 }
2081
2082                 mdd_read_lock(env, obj, MOR_TGT_CHILD);
2083                 if (unlikely(mdd_is_dead_obj(obj))) {
2084                         mdd_read_unlock(env, obj);
2085                         if (depth > 0)
2086                                 mdd_object_put(env, obj);
2087                         return 0;
2088                 }
2089
2090                 rc = dt_xattr_get(env, mdd_object_child(obj),
2091                                   mdd_buf_get(env, NULL, 0), XATTR_NAME_LINK,
2092                                   BYPASS_CAPA);
2093                 mdd_read_unlock(env, obj);
2094                 if (rc >= 0) {
2095                         if (depth > 0)
2096                                 mdd_object_put(env, obj);
2097                         return 1;
2098                 }
2099
2100                 if (rc < 0 && rc != -ENODATA) {
2101                         if (depth > 0)
2102                                 mdd_object_put(env, obj);
2103                         return rc;
2104                 }
2105
2106                 rc = mdd_parent_fid(env, obj, fid);
2107                 if (depth > 0)
2108                         mdd_object_put(env, obj);
2109                 if (rc != 0)
2110                         return rc;
2111
2112                 if (unlikely(lu_fid_eq(fid, &mdd->mdd_local_root_fid)))
2113                         return 0;
2114
2115                 obj = mdd_object_find(env, mdd, fid);
2116                 if (obj == NULL)
2117                         return 0;
2118                 else if (IS_ERR(obj))
2119                         return PTR_ERR(obj);
2120
2121                 /* XXX: need more processing for remote object in the future. */
2122                 if (!mdd_object_exists(obj) || mdd_object_remote(obj)) {
2123                         mdd_object_put(env, obj);
2124                         return 0;
2125                 }
2126
2127                 depth++;
2128         }
2129         return 0;
2130 }
2131
2132 static void mdd_lfsck_unpack_ent(struct lu_dirent *ent)
2133 {
2134         fid_le_to_cpu(&ent->lde_fid, &ent->lde_fid);
2135         ent->lde_hash = le64_to_cpu(ent->lde_hash);
2136         ent->lde_reclen = le16_to_cpu(ent->lde_reclen);
2137         ent->lde_namelen = le16_to_cpu(ent->lde_namelen);
2138         ent->lde_attrs = le32_to_cpu(ent->lde_attrs);
2139
2140         /* Make sure the name is terminated with '0'.
2141          * The data (type) after ent::lde_name maybe
2142          * broken, but we do not care. */
2143         ent->lde_name[ent->lde_namelen] = 0;
2144 }
2145
2146 /* LFSCK wrap functions */
2147
2148 static void mdd_lfsck_fail(const struct lu_env *env, struct md_lfsck *lfsck,
2149                            bool oit, bool new_checked)
2150 {
2151         struct lfsck_component *com;
2152
2153         cfs_list_for_each_entry(com, &lfsck->ml_list_scan, lc_link) {
2154                 com->lc_ops->lfsck_fail(env, com, oit, new_checked);
2155         }
2156 }
2157
2158 static int mdd_lfsck_checkpoint(const struct lu_env *env,
2159                                 struct md_lfsck *lfsck, bool oit)
2160 {
2161         struct lfsck_component *com;
2162         int                     rc;
2163
2164         if (likely(cfs_time_beforeq(cfs_time_current(),
2165                                     lfsck->ml_time_next_checkpoint)))
2166                 return 0;
2167
2168         mdd_lfsck_pos_fill(env, lfsck, &lfsck->ml_pos_current, oit, !oit);
2169         cfs_list_for_each_entry(com, &lfsck->ml_list_scan, lc_link) {
2170                 rc = com->lc_ops->lfsck_checkpoint(env, com, false);
2171                 if (rc != 0)
2172                         return rc;;
2173         }
2174
2175         lfsck->ml_time_last_checkpoint = cfs_time_current();
2176         lfsck->ml_time_next_checkpoint = lfsck->ml_time_last_checkpoint +
2177                                 cfs_time_seconds(LFSCK_CHECKPOINT_INTERVAL);
2178         return 0;
2179 }
2180
2181 static int mdd_lfsck_prep(struct lu_env *env, struct md_lfsck *lfsck)
2182 {
2183         struct mdd_device      *mdd     = mdd_lfsck2mdd(lfsck);
2184         struct mdd_object      *obj     = NULL;
2185         struct dt_object       *dt_obj;
2186         struct lfsck_component *com;
2187         struct lfsck_component *next;
2188         struct lfsck_position  *pos     = NULL;
2189         const struct dt_it_ops *iops    =
2190                                 &lfsck->ml_obj_oit->do_index_ops->dio_it;
2191         struct dt_it           *di;
2192         int                     rc;
2193         ENTRY;
2194
2195         LASSERT(lfsck->ml_obj_dir == NULL);
2196         LASSERT(lfsck->ml_di_dir == NULL);
2197
2198         cfs_list_for_each_entry_safe(com, next, &lfsck->ml_list_scan, lc_link) {
2199                 com->lc_new_checked = 0;
2200                 if (lfsck->ml_bookmark_ram.lb_param & LPF_DRYRUN)
2201                         com->lc_journal = 0;
2202
2203                 rc = com->lc_ops->lfsck_prep(env, com);
2204                 if (rc != 0)
2205                         RETURN(rc);
2206
2207                 if ((pos == NULL) ||
2208                     (!mdd_lfsck_pos_is_zero(&com->lc_pos_start) &&
2209                      mdd_lfsck_pos_is_eq(pos, &com->lc_pos_start) > 0))
2210                         pos = &com->lc_pos_start;
2211         }
2212
2213         /* Init otable-based iterator. */
2214         if (pos == NULL) {
2215                 rc = iops->load(env, lfsck->ml_di_oit, 0);
2216                 GOTO(out, rc = (rc >= 0 ? 0 : rc));
2217         }
2218
2219         rc = iops->load(env, lfsck->ml_di_oit, pos->lp_oit_cookie);
2220         if (rc < 0)
2221                 GOTO(out, rc);
2222
2223         if (fid_is_zero(&pos->lp_dir_parent))
2224                 GOTO(out, rc = 0);
2225
2226         /* Find the directory for namespace-based traverse. */
2227         obj = mdd_object_find(env, mdd, &pos->lp_dir_parent);
2228         if (obj == NULL)
2229                 GOTO(out, rc = 0);
2230         else if (IS_ERR(obj))
2231                 RETURN(PTR_ERR(obj));
2232
2233         /* XXX: need more processing for remote object in the future. */
2234         if (!mdd_object_exists(obj) || mdd_object_remote(obj) ||
2235             unlikely(!S_ISDIR(mdd_object_type(obj))))
2236                 GOTO(out, rc = 0);
2237
2238         if (unlikely(mdd_is_dead_obj(obj)))
2239                 GOTO(out, rc = 0);
2240
2241         dt_obj = mdd_object_child(obj);
2242         if (unlikely(!dt_try_as_dir(env, dt_obj)))
2243                 GOTO(out, rc = -ENOTDIR);
2244
2245         /* Init the namespace-based directory traverse. */
2246         iops = &dt_obj->do_index_ops->dio_it;
2247         di = iops->init(env, dt_obj, lfsck->ml_args_dir, BYPASS_CAPA);
2248         if (IS_ERR(di))
2249                 GOTO(out, rc = PTR_ERR(di));
2250
2251         rc = iops->load(env, di, pos->lp_dir_cookie);
2252         if (rc == 0)
2253                 rc = iops->next(env, di);
2254         else if (rc > 0)
2255                 rc = 0;
2256
2257         if (rc != 0) {
2258                 iops->put(env, di);
2259                 iops->fini(env, di);
2260                 GOTO(out, rc);
2261         }
2262
2263         lfsck->ml_obj_dir = dt_obj;
2264         spin_lock(&lfsck->ml_lock);
2265         lfsck->ml_di_dir = di;
2266         spin_unlock(&lfsck->ml_lock);
2267         obj = NULL;
2268
2269         GOTO(out, rc = 0);
2270
2271 out:
2272         if (obj != NULL)
2273                 mdd_object_put(env, obj);
2274
2275         if (rc != 0)
2276                 return (rc > 0 ? 0 : rc);
2277
2278         mdd_lfsck_pos_fill(env, lfsck, &lfsck->ml_pos_current, false, false);
2279         cfs_list_for_each_entry(com, &lfsck->ml_list_scan, lc_link) {
2280                 rc = com->lc_ops->lfsck_checkpoint(env, com, true);
2281                 if (rc != 0)
2282                         break;
2283         }
2284
2285         lfsck->ml_time_last_checkpoint = cfs_time_current();
2286         lfsck->ml_time_next_checkpoint = lfsck->ml_time_last_checkpoint +
2287                                 cfs_time_seconds(LFSCK_CHECKPOINT_INTERVAL);
2288         return rc;
2289 }
2290
2291 static int mdd_lfsck_exec_oit(const struct lu_env *env, struct md_lfsck *lfsck,
2292                               struct mdd_object *obj)
2293 {
2294         struct lfsck_component *com;
2295         struct dt_object       *dt_obj;
2296         const struct dt_it_ops *iops;
2297         struct dt_it           *di;
2298         int                     rc;
2299         ENTRY;
2300
2301         LASSERT(lfsck->ml_obj_dir == NULL);
2302
2303         cfs_list_for_each_entry(com, &lfsck->ml_list_scan, lc_link) {
2304                 rc = com->lc_ops->lfsck_exec_oit(env, com, obj);
2305                 if (rc != 0)
2306                         RETURN(rc);
2307         }
2308
2309         if (!S_ISDIR(mdd_object_type(obj)) ||
2310             cfs_list_empty(&lfsck->ml_list_dir))
2311                RETURN(0);
2312
2313         rc = object_is_client_visible(env, mdd_lfsck2mdd(lfsck), obj);
2314         if (rc <= 0)
2315                 GOTO(out, rc);
2316
2317         if (unlikely(mdd_is_dead_obj(obj)))
2318                 GOTO(out, rc = 0);
2319
2320         dt_obj = mdd_object_child(obj);
2321         if (unlikely(!dt_try_as_dir(env, dt_obj)))
2322                 GOTO(out, rc = -ENOTDIR);
2323
2324         iops = &dt_obj->do_index_ops->dio_it;
2325         di = iops->init(env, dt_obj, lfsck->ml_args_dir, BYPASS_CAPA);
2326         if (IS_ERR(di))
2327                 GOTO(out, rc = PTR_ERR(di));
2328
2329         rc = iops->load(env, di, 0);
2330         if (rc == 0)
2331                 rc = iops->next(env, di);
2332         else if (rc > 0)
2333                 rc = 0;
2334
2335         if (rc != 0) {
2336                 iops->put(env, di);
2337                 iops->fini(env, di);
2338                 GOTO(out, rc);
2339         }
2340
2341         mdd_object_get(obj);
2342         lfsck->ml_obj_dir = dt_obj;
2343         spin_lock(&lfsck->ml_lock);
2344         lfsck->ml_di_dir = di;
2345         spin_unlock(&lfsck->ml_lock);
2346
2347         GOTO(out, rc = 0);
2348
2349 out:
2350         if (rc < 0)
2351                 mdd_lfsck_fail(env, lfsck, false, false);
2352         return (rc > 0 ? 0 : rc);
2353 }
2354
2355 static int mdd_lfsck_exec_dir(const struct lu_env *env, struct md_lfsck *lfsck,
2356                               struct mdd_object *obj, struct lu_dirent *ent)
2357 {
2358         struct lfsck_component *com;
2359         int                     rc;
2360
2361         cfs_list_for_each_entry(com, &lfsck->ml_list_scan, lc_link) {
2362                 rc = com->lc_ops->lfsck_exec_dir(env, com, obj, ent);
2363                 if (rc != 0)
2364                         return rc;
2365         }
2366         return 0;
2367 }
2368
2369 static int mdd_lfsck_post(const struct lu_env *env, struct md_lfsck *lfsck,
2370                           int result)
2371 {
2372         struct lfsck_component *com;
2373         struct lfsck_component *next;
2374         int                     rc;
2375
2376         mdd_lfsck_pos_fill(env, lfsck, &lfsck->ml_pos_current, true, true);
2377         cfs_list_for_each_entry_safe(com, next, &lfsck->ml_list_scan, lc_link) {
2378                 rc = com->lc_ops->lfsck_post(env, com, result);
2379                 if (rc != 0)
2380                         return rc;
2381         }
2382
2383         lfsck->ml_time_last_checkpoint = cfs_time_current();
2384         lfsck->ml_time_next_checkpoint = lfsck->ml_time_last_checkpoint +
2385                                 cfs_time_seconds(LFSCK_CHECKPOINT_INTERVAL);
2386         return result;
2387 }
2388
2389 static int mdd_lfsck_double_scan(const struct lu_env *env,
2390                                  struct md_lfsck *lfsck)
2391 {
2392         struct lfsck_component *com;
2393         struct lfsck_component *next;
2394         int                     rc;
2395
2396         cfs_list_for_each_entry_safe(com, next, &lfsck->ml_list_double_scan,
2397                                      lc_link) {
2398                 if (lfsck->ml_bookmark_ram.lb_param & LPF_DRYRUN)
2399                         com->lc_journal = 0;
2400
2401                 rc = com->lc_ops->lfsck_double_scan(env, com);
2402                 if (rc != 0)
2403                         return rc;
2404         }
2405         return 0;
2406 }
2407
2408 /* LFSCK engines */
2409
2410 static int mdd_lfsck_dir_engine(const struct lu_env *env,
2411                                 struct md_lfsck *lfsck)
2412 {
2413         struct mdd_thread_info  *info   = mdd_env_info(env);
2414         struct mdd_device       *mdd    = mdd_lfsck2mdd(lfsck);
2415         const struct dt_it_ops  *iops   =
2416                         &lfsck->ml_obj_dir->do_index_ops->dio_it;
2417         struct dt_it            *di     = lfsck->ml_di_dir;
2418         struct lu_dirent        *ent    = &info->mti_ent;
2419         struct lu_fid           *fid    = &info->mti_fid;
2420         struct lfsck_bookmark   *bk     = &lfsck->ml_bookmark_ram;
2421         struct ptlrpc_thread    *thread = &lfsck->ml_thread;
2422         int                      rc;
2423         ENTRY;
2424
2425         do {
2426                 struct mdd_object *child;
2427
2428                 if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_DELAY2) &&
2429                     cfs_fail_val > 0) {
2430                         struct l_wait_info lwi;
2431
2432                         lwi = LWI_TIMEOUT(cfs_time_seconds(cfs_fail_val),
2433                                           NULL, NULL);
2434                         l_wait_event(thread->t_ctl_waitq,
2435                                      !thread_is_running(thread),
2436                                      &lwi);
2437                 }
2438
2439                 lfsck->ml_new_scanned++;
2440                 rc = iops->rec(env, di, (struct dt_rec *)ent,
2441                                lfsck->ml_args_dir);
2442                 if (rc != 0) {
2443                         mdd_lfsck_fail(env, lfsck, false, true);
2444                         if (bk->lb_param & LPF_FAILOUT)
2445                                 RETURN(rc);
2446                         else
2447                                 goto checkpoint;
2448                 }
2449
2450                 mdd_lfsck_unpack_ent(ent);
2451                 if (ent->lde_attrs & LUDA_IGNORE)
2452                         goto checkpoint;
2453
2454                 *fid = ent->lde_fid;
2455                 child = mdd_object_find(env, mdd, fid);
2456                 if (child == NULL) {
2457                         goto checkpoint;
2458                 } else if (IS_ERR(child)) {
2459                         mdd_lfsck_fail(env, lfsck, false, true);
2460                         if (bk->lb_param & LPF_FAILOUT)
2461                                 RETURN(PTR_ERR(child));
2462                         else
2463                                 goto checkpoint;
2464                 }
2465
2466                 /* XXX: need more processing for remote object in the future. */
2467                 if (mdd_object_exists(child) && !mdd_object_remote(child))
2468                         rc = mdd_lfsck_exec_dir(env, lfsck, child, ent);
2469                 mdd_object_put(env, child);
2470                 if (rc != 0 && bk->lb_param & LPF_FAILOUT)
2471                         RETURN(rc);
2472
2473 checkpoint:
2474                 rc = mdd_lfsck_checkpoint(env, lfsck, false);
2475                 if (rc != 0 && bk->lb_param & LPF_FAILOUT)
2476                         RETURN(rc);
2477
2478                 /* Rate control. */
2479                 mdd_lfsck_control_speed(lfsck);
2480                 if (unlikely(!thread_is_running(thread)))
2481                         RETURN(0);
2482
2483                 if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_FATAL2)) {
2484                         spin_lock(&lfsck->ml_lock);
2485                         thread_set_flags(thread, SVC_STOPPING);
2486                         spin_unlock(&lfsck->ml_lock);
2487                         RETURN(-EINVAL);
2488                 }
2489
2490                 rc = iops->next(env, di);
2491         } while (rc == 0);
2492
2493         if (rc > 0 && !lfsck->ml_oit_over)
2494                 mdd_lfsck_close_dir(env, lfsck);
2495
2496         RETURN(rc);
2497 }
2498
2499 static int mdd_lfsck_oit_engine(const struct lu_env *env,
2500                                 struct md_lfsck *lfsck)
2501 {
2502         struct mdd_thread_info  *info   = mdd_env_info(env);
2503         struct mdd_device       *mdd    = mdd_lfsck2mdd(lfsck);
2504         const struct dt_it_ops  *iops   =
2505                                 &lfsck->ml_obj_oit->do_index_ops->dio_it;
2506         struct dt_it            *di     = lfsck->ml_di_oit;
2507         struct lu_fid           *fid    = &info->mti_fid;
2508         struct lfsck_bookmark   *bk     = &lfsck->ml_bookmark_ram;
2509         struct ptlrpc_thread    *thread = &lfsck->ml_thread;
2510         int                      rc;
2511         ENTRY;
2512
2513         do {
2514                 struct mdd_object *target;
2515
2516                 if (lfsck->ml_di_dir != NULL) {
2517                         rc = mdd_lfsck_dir_engine(env, lfsck);
2518                         if (rc <= 0)
2519                                 RETURN(rc);
2520                 }
2521
2522                 if (unlikely(lfsck->ml_oit_over))
2523                         RETURN(1);
2524
2525                 if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_DELAY1) &&
2526                     cfs_fail_val > 0) {
2527                         struct l_wait_info lwi;
2528
2529                         lwi = LWI_TIMEOUT(cfs_time_seconds(cfs_fail_val),
2530                                           NULL, NULL);
2531                         l_wait_event(thread->t_ctl_waitq,
2532                                      !thread_is_running(thread),
2533                                      &lwi);
2534                 }
2535
2536                 if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_CRASH))
2537                         RETURN(0);
2538
2539                 lfsck->ml_new_scanned++;
2540                 rc = iops->rec(env, di, (struct dt_rec *)fid, 0);
2541                 if (rc != 0) {
2542                         mdd_lfsck_fail(env, lfsck, true, true);
2543                         if (bk->lb_param & LPF_FAILOUT)
2544                                 RETURN(rc);
2545                         else
2546                                 goto checkpoint;
2547                 }
2548
2549                 target = mdd_object_find(env, mdd, fid);
2550                 if (target == NULL) {
2551                         goto checkpoint;
2552                 } else if (IS_ERR(target)) {
2553                         mdd_lfsck_fail(env, lfsck, true, true);
2554                         if (bk->lb_param & LPF_FAILOUT)
2555                                 RETURN(PTR_ERR(target));
2556                         else
2557                                 goto checkpoint;
2558                 }
2559
2560                 /* XXX: In fact, low layer otable-based iteration should not
2561                  *      return agent object. But before LU-2646 resolved, we
2562                  *      need more processing for agent object. */
2563                 if (mdd_object_exists(target) && !mdd_object_remote(target))
2564                         rc = mdd_lfsck_exec_oit(env, lfsck, target);
2565                 mdd_object_put(env, target);
2566                 if (rc != 0 && bk->lb_param & LPF_FAILOUT)
2567                         RETURN(rc);
2568
2569 checkpoint:
2570                 rc = mdd_lfsck_checkpoint(env, lfsck, true);
2571                 if (rc != 0 && bk->lb_param & LPF_FAILOUT)
2572                         RETURN(rc);
2573
2574                 /* Rate control. */
2575                 mdd_lfsck_control_speed(lfsck);
2576
2577                 if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_FATAL1)) {
2578                         spin_lock(&lfsck->ml_lock);
2579                         thread_set_flags(thread, SVC_STOPPING);
2580                         spin_unlock(&lfsck->ml_lock);
2581                         RETURN(-EINVAL);
2582                 }
2583
2584                 rc = iops->next(env, di);
2585                 if (rc > 0)
2586                         lfsck->ml_oit_over = 1;
2587
2588                 if (unlikely(!thread_is_running(thread)))
2589                         RETURN(0);
2590         } while (rc == 0 || lfsck->ml_di_dir != NULL);
2591
2592         RETURN(rc);
2593 }
2594
2595 static int mdd_lfsck_main(void *args)
2596 {
2597         struct lu_env            env;
2598         struct md_lfsck         *lfsck    = (struct md_lfsck *)args;
2599         struct ptlrpc_thread    *thread   = &lfsck->ml_thread;
2600         struct dt_object        *oit_obj  = lfsck->ml_obj_oit;
2601         const struct dt_it_ops  *oit_iops = &oit_obj->do_index_ops->dio_it;
2602         struct dt_it            *oit_di;
2603         int                      rc;
2604         ENTRY;
2605
2606         cfs_daemonize("lfsck");
2607         rc = lu_env_init(&env, LCT_MD_THREAD | LCT_DT_THREAD);
2608         if (rc != 0) {
2609                 CERROR("%s: LFSCK, fail to init env, rc = %d\n",
2610                        mdd_lfsck2name(lfsck), rc);
2611                 GOTO(noenv, rc);
2612         }
2613
2614         oit_di = oit_iops->init(&env, oit_obj, lfsck->ml_args_oit, BYPASS_CAPA);
2615         if (IS_ERR(oit_di)) {
2616                 rc = PTR_ERR(oit_di);
2617                 CERROR("%s: LFSCK, fail to init iteration, rc = %d\n",
2618                        mdd_lfsck2name(lfsck), rc);
2619                 GOTO(fini_env, rc);
2620         }
2621
2622         spin_lock(&lfsck->ml_lock);
2623         lfsck->ml_di_oit = oit_di;
2624         spin_unlock(&lfsck->ml_lock);
2625         rc = mdd_lfsck_prep(&env, lfsck);
2626         if (rc != 0)
2627                 GOTO(fini_oit, rc);
2628
2629         CDEBUG(D_LFSCK, "LFSCK entry: oit_flags = 0x%x, dir_flags = 0x%x, "
2630                "oit_cookie = "LPU64", dir_cookie = "LPU64", parent = "DFID
2631                ", pid = %d\n", lfsck->ml_args_oit, lfsck->ml_args_dir,
2632                lfsck->ml_pos_current.lp_oit_cookie,
2633                lfsck->ml_pos_current.lp_dir_cookie,
2634                PFID(&lfsck->ml_pos_current.lp_dir_parent),
2635                cfs_curproc_pid());
2636
2637         spin_lock(&lfsck->ml_lock);
2638         thread_set_flags(thread, SVC_RUNNING);
2639         spin_unlock(&lfsck->ml_lock);
2640         cfs_waitq_broadcast(&thread->t_ctl_waitq);
2641
2642         if (!cfs_list_empty(&lfsck->ml_list_scan) ||
2643             cfs_list_empty(&lfsck->ml_list_double_scan))
2644                 rc = mdd_lfsck_oit_engine(&env, lfsck);
2645         else
2646                 rc = 1;
2647
2648         CDEBUG(D_LFSCK, "LFSCK exit: oit_flags = 0x%x, dir_flags = 0x%x, "
2649                "oit_cookie = "LPU64", dir_cookie = "LPU64", parent = "DFID
2650                ", pid = %d, rc = %d\n", lfsck->ml_args_oit, lfsck->ml_args_dir,
2651                lfsck->ml_pos_current.lp_oit_cookie,
2652                lfsck->ml_pos_current.lp_dir_cookie,
2653                PFID(&lfsck->ml_pos_current.lp_dir_parent),
2654                cfs_curproc_pid(), rc);
2655
2656         if (lfsck->ml_paused && cfs_list_empty(&lfsck->ml_list_scan))
2657                 oit_iops->put(&env, oit_di);
2658
2659         if (!OBD_FAIL_CHECK(OBD_FAIL_LFSCK_CRASH))
2660                 rc = mdd_lfsck_post(&env, lfsck, rc);
2661         if (lfsck->ml_di_dir != NULL)
2662                 mdd_lfsck_close_dir(&env, lfsck);
2663
2664 fini_oit:
2665         spin_lock(&lfsck->ml_lock);
2666         lfsck->ml_di_oit = NULL;
2667         spin_unlock(&lfsck->ml_lock);
2668
2669         oit_iops->fini(&env, oit_di);
2670         if (rc == 1) {
2671                 if (!cfs_list_empty(&lfsck->ml_list_double_scan))
2672                         rc = mdd_lfsck_double_scan(&env, lfsck);
2673                 else
2674                         rc = 0;
2675         }
2676
2677         /* XXX: Purge the pinned objects in the future. */
2678
2679 fini_env:
2680         lu_env_fini(&env);
2681
2682 noenv:
2683         spin_lock(&lfsck->ml_lock);
2684         thread_set_flags(thread, SVC_STOPPED);
2685         cfs_waitq_broadcast(&thread->t_ctl_waitq);
2686         spin_unlock(&lfsck->ml_lock);
2687         return rc;
2688 }
2689
2690 /* external interfaces */
2691
2692 int mdd_lfsck_set_speed(const struct lu_env *env, struct md_lfsck *lfsck,
2693                         __u32 limit)
2694 {
2695         int rc;
2696
2697         mutex_lock(&lfsck->ml_mutex);
2698         __mdd_lfsck_set_speed(lfsck, limit);
2699         rc = mdd_lfsck_bookmark_store(env, lfsck);
2700         mutex_unlock(&lfsck->ml_mutex);
2701         return rc;
2702 }
2703
2704 int mdd_lfsck_dump(const struct lu_env *env, struct md_lfsck *lfsck,
2705                    __u16 type, char *buf, int len)
2706 {
2707         struct lfsck_component *com;
2708         int                     rc;
2709
2710         if (!lfsck->ml_initialized)
2711                 return -ENODEV;
2712
2713         com = mdd_lfsck_component_find(lfsck, type);
2714         if (com == NULL)
2715                 return -ENOTSUPP;
2716
2717         rc = com->lc_ops->lfsck_dump(env, com, buf, len);
2718         mdd_lfsck_component_put(env, com);
2719         return rc;
2720 }
2721
2722 int mdd_lfsck_start(const struct lu_env *env, struct md_lfsck *lfsck,
2723                     struct lfsck_start *start)
2724 {
2725         struct lfsck_bookmark  *bk     = &lfsck->ml_bookmark_ram;
2726         struct ptlrpc_thread   *thread = &lfsck->ml_thread;
2727         struct lfsck_component *com;
2728         struct l_wait_info      lwi    = { 0 };
2729         bool                    dirty  = false;
2730         int                     rc     = 0;
2731         __u16                   valid  = 0;
2732         __u16                   flags  = 0;
2733         ENTRY;
2734
2735         if (lfsck->ml_obj_oit == NULL)
2736                 RETURN(-ENOTSUPP);
2737
2738         /* start == NULL means auto trigger paused LFSCK. */
2739         if ((start == NULL) &&
2740             (cfs_list_empty(&lfsck->ml_list_scan) ||
2741              OBD_FAIL_CHECK(OBD_FAIL_LFSCK_NO_AUTO)))
2742                 RETURN(0);
2743
2744         mutex_lock(&lfsck->ml_mutex);
2745         spin_lock(&lfsck->ml_lock);
2746         if (!thread_is_init(thread) && !thread_is_stopped(thread)) {
2747                 spin_unlock(&lfsck->ml_lock);
2748                 mutex_unlock(&lfsck->ml_mutex);
2749                 RETURN(-EALREADY);
2750         }
2751
2752         spin_unlock(&lfsck->ml_lock);
2753
2754         lfsck->ml_paused = 0;
2755         lfsck->ml_oit_over = 0;
2756         lfsck->ml_drop_dryrun = 0;
2757         lfsck->ml_new_scanned = 0;
2758
2759         /* For auto trigger. */
2760         if (start == NULL)
2761                 goto trigger;
2762
2763         start->ls_version = bk->lb_version;
2764         if (start->ls_valid & LSV_SPEED_LIMIT) {
2765                 __mdd_lfsck_set_speed(lfsck, start->ls_speed_limit);
2766                 dirty = true;
2767         }
2768
2769         if (start->ls_valid & LSV_ERROR_HANDLE) {
2770                 valid |= DOIV_ERROR_HANDLE;
2771                 if (start->ls_flags & LPF_FAILOUT)
2772                         flags |= DOIF_FAILOUT;
2773
2774                 if ((start->ls_flags & LPF_FAILOUT) &&
2775                     !(bk->lb_param & LPF_FAILOUT)) {
2776                         bk->lb_param |= LPF_FAILOUT;
2777                         dirty = true;
2778                 } else if (!(start->ls_flags & LPF_FAILOUT) &&
2779                            (bk->lb_param & LPF_FAILOUT)) {
2780                         bk->lb_param &= ~LPF_FAILOUT;
2781                         dirty = true;
2782                 }
2783         }
2784
2785         if (start->ls_valid & LSV_DRYRUN) {
2786                 if ((start->ls_flags & LPF_DRYRUN) &&
2787                     !(bk->lb_param & LPF_DRYRUN)) {
2788                         bk->lb_param |= LPF_DRYRUN;
2789                         dirty = true;
2790                 } else if (!(start->ls_flags & LPF_DRYRUN) &&
2791                            (bk->lb_param & LPF_DRYRUN)) {
2792                         bk->lb_param &= ~LPF_DRYRUN;
2793                         lfsck->ml_drop_dryrun = 1;
2794                         dirty = true;
2795                 }
2796         }
2797
2798         if (dirty) {
2799                 rc = mdd_lfsck_bookmark_store(env, lfsck);
2800                 if (rc != 0)
2801                         GOTO(out, rc);
2802         }
2803
2804         if (start->ls_flags & LPF_RESET)
2805                 flags |= DOIF_RESET;
2806
2807         if (start->ls_active != 0) {
2808                 struct lfsck_component *next;
2809                 __u16 type = 1;
2810
2811                 if (start->ls_active == LFSCK_TYPES_ALL)
2812                         start->ls_active = LFSCK_TYPES_SUPPORTED;
2813
2814                 if (start->ls_active & ~LFSCK_TYPES_SUPPORTED) {
2815                         start->ls_active &= ~LFSCK_TYPES_SUPPORTED;
2816                         GOTO(out, rc = -ENOTSUPP);
2817                 }
2818
2819                 cfs_list_for_each_entry_safe(com, next,
2820                                              &lfsck->ml_list_scan, lc_link) {
2821                         if (!(com->lc_type & start->ls_active)) {
2822                                 rc = com->lc_ops->lfsck_post(env, com, 0);
2823                                 if (rc != 0)
2824                                         GOTO(out, rc);
2825                         }
2826                 }
2827
2828                 while (start->ls_active != 0) {
2829                         if (type & start->ls_active) {
2830                                 com = __mdd_lfsck_component_find(lfsck, type,
2831                                                         &lfsck->ml_list_idle);
2832                                 if (com != NULL) {
2833                                         /* The component status will be updated
2834                                          * when its prep() is called later by
2835                                          * the LFSCK main engine. */
2836                                         cfs_list_del_init(&com->lc_link);
2837                                         cfs_list_add_tail(&com->lc_link,
2838                                                           &lfsck->ml_list_scan);
2839                                 }
2840                                 start->ls_active &= ~type;
2841                         }
2842                         type <<= 1;
2843                 }
2844         }
2845
2846         cfs_list_for_each_entry(com, &lfsck->ml_list_scan, lc_link) {
2847                 start->ls_active |= com->lc_type;
2848                 if (flags & DOIF_RESET) {
2849                         rc = com->lc_ops->lfsck_reset(env, com, false);
2850                         if (rc != 0)
2851                                 GOTO(out, rc);
2852                 }
2853         }
2854
2855 trigger:
2856         lfsck->ml_args_dir = LUDA_64BITHASH | LUDA_VERIFY;
2857         if (bk->lb_param & LPF_DRYRUN)
2858                 lfsck->ml_args_dir |= LUDA_VERIFY_DRYRUN;
2859
2860         if (bk->lb_param & LPF_FAILOUT) {
2861                 valid |= DOIV_ERROR_HANDLE;
2862                 flags |= DOIF_FAILOUT;
2863         }
2864
2865         if (!cfs_list_empty(&lfsck->ml_list_scan))
2866                 flags |= DOIF_OUTUSED;
2867
2868         lfsck->ml_args_oit = (flags << DT_OTABLE_IT_FLAGS_SHIFT) | valid;
2869         thread_set_flags(thread, 0);
2870         rc = cfs_create_thread(mdd_lfsck_main, lfsck, 0);
2871         if (rc < 0)
2872                 CERROR("%s: cannot start LFSCK thread, rc = %d\n",
2873                        mdd_lfsck2name(lfsck), rc);
2874         else
2875                 l_wait_event(thread->t_ctl_waitq,
2876                              thread_is_running(thread) ||
2877                              thread_is_stopped(thread),
2878                              &lwi);
2879
2880         GOTO(out, rc = 0);
2881
2882 out:
2883         mutex_unlock(&lfsck->ml_mutex);
2884         return (rc < 0 ? rc : 0);
2885 }
2886
2887 int mdd_lfsck_stop(const struct lu_env *env, struct md_lfsck *lfsck,
2888                    bool pause)
2889 {
2890         struct ptlrpc_thread *thread = &lfsck->ml_thread;
2891         struct l_wait_info    lwi    = { 0 };
2892         ENTRY;
2893
2894         if (!lfsck->ml_initialized)
2895                 RETURN(0);
2896
2897         mutex_lock(&lfsck->ml_mutex);
2898         spin_lock(&lfsck->ml_lock);
2899         if (thread_is_init(thread) || thread_is_stopped(thread)) {
2900                 spin_unlock(&lfsck->ml_lock);
2901                 mutex_unlock(&lfsck->ml_mutex);
2902                 RETURN(-EALREADY);
2903         }
2904
2905         if (pause)
2906                 lfsck->ml_paused = 1;
2907         thread_set_flags(thread, SVC_STOPPING);
2908         /* The LFSCK thread may be sleeping on low layer wait queue,
2909          * wake it up. */
2910         if (likely(lfsck->ml_di_oit != NULL))
2911                 lfsck->ml_obj_oit->do_index_ops->dio_it.put(env,
2912                                                             lfsck->ml_di_oit);
2913         spin_unlock(&lfsck->ml_lock);
2914
2915         cfs_waitq_broadcast(&thread->t_ctl_waitq);
2916         l_wait_event(thread->t_ctl_waitq,
2917                      thread_is_stopped(thread),
2918                      &lwi);
2919         mutex_unlock(&lfsck->ml_mutex);
2920
2921         RETURN(0);
2922 }
2923
2924 static const struct lu_fid lfsck_it_fid = { .f_seq = FID_SEQ_LOCAL_FILE,
2925                                             .f_oid = OTABLE_IT_OID,
2926                                             .f_ver = 0 };
2927
2928 int mdd_lfsck_setup(const struct lu_env *env, struct mdd_device *mdd)
2929 {
2930         struct md_lfsck  *lfsck = &mdd->mdd_lfsck;
2931         struct dt_object *obj;
2932         int               rc;
2933         ENTRY;
2934
2935         LASSERT(!lfsck->ml_initialized);
2936
2937         lfsck->ml_initialized = 1;
2938         mutex_init(&lfsck->ml_mutex);
2939         spin_lock_init(&lfsck->ml_lock);
2940         CFS_INIT_LIST_HEAD(&lfsck->ml_list_scan);
2941         CFS_INIT_LIST_HEAD(&lfsck->ml_list_dir);
2942         CFS_INIT_LIST_HEAD(&lfsck->ml_list_double_scan);
2943         CFS_INIT_LIST_HEAD(&lfsck->ml_list_idle);
2944         cfs_waitq_init(&lfsck->ml_thread.t_ctl_waitq);
2945
2946         obj = dt_locate(env, mdd->mdd_bottom, &lfsck_it_fid);
2947         if (IS_ERR(obj))
2948                 RETURN(PTR_ERR(obj));
2949
2950         lfsck->ml_obj_oit = obj;
2951         rc = obj->do_ops->do_index_try(env, obj, &dt_otable_features);
2952         if (rc != 0) {
2953                 if (rc == -ENOTSUPP)
2954                         rc = 0;
2955
2956                 RETURN(rc);
2957         }
2958
2959         obj = dt_store_open(env, mdd->mdd_bottom, "", lfsck_bookmark_name,
2960                             &mdd_env_info(env)->mti_fid);
2961         if (IS_ERR(obj))
2962                 RETURN(PTR_ERR(obj));
2963
2964         lfsck->ml_bookmark_obj = obj;
2965         rc = mdd_lfsck_bookmark_load(env, lfsck);
2966         if (rc == -ENODATA)
2967                 rc = mdd_lfsck_bookmark_init(env, lfsck);
2968         if (rc != 0)
2969                 RETURN(rc);
2970
2971         rc = mdd_lfsck_namespace_setup(env, lfsck);
2972         /* XXX: LFSCK components initialization to be added here. */
2973
2974         RETURN(rc);
2975 }
2976
2977 void mdd_lfsck_cleanup(const struct lu_env *env, struct mdd_device *mdd)
2978 {
2979         struct md_lfsck         *lfsck  = &mdd->mdd_lfsck;
2980         struct ptlrpc_thread    *thread = &lfsck->ml_thread;
2981         struct lfsck_component  *com;
2982
2983         if (!lfsck->ml_initialized)
2984                 return;
2985
2986         LASSERT(thread_is_init(thread) || thread_is_stopped(thread));
2987
2988         if (lfsck->ml_obj_oit != NULL) {
2989                 lu_object_put(env, &lfsck->ml_obj_oit->do_lu);
2990                 lfsck->ml_obj_oit = NULL;
2991         }
2992
2993         LASSERT(lfsck->ml_obj_dir == NULL);
2994
2995         if (lfsck->ml_bookmark_obj != NULL) {
2996                 lu_object_put(env, &lfsck->ml_bookmark_obj->do_lu);
2997                 lfsck->ml_bookmark_obj = NULL;
2998         }
2999
3000         while (!cfs_list_empty(&lfsck->ml_list_scan)) {
3001                 com = cfs_list_entry(lfsck->ml_list_scan.next,
3002                                      struct lfsck_component,
3003                                      lc_link);
3004                 mdd_lfsck_component_cleanup(env, com);
3005         }
3006
3007         LASSERT(cfs_list_empty(&lfsck->ml_list_dir));
3008
3009         while (!cfs_list_empty(&lfsck->ml_list_double_scan)) {
3010                 com = cfs_list_entry(lfsck->ml_list_double_scan.next,
3011                                      struct lfsck_component,
3012                                      lc_link);
3013                 mdd_lfsck_component_cleanup(env, com);
3014         }
3015
3016         while (!cfs_list_empty(&lfsck->ml_list_idle)) {
3017                 com = cfs_list_entry(lfsck->ml_list_idle.next,
3018                                      struct lfsck_component,
3019                                      lc_link);
3020                 mdd_lfsck_component_cleanup(env, com);
3021         }
3022 }