4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
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.
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.
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
23 * Copyright (c) 2012, 2013, Intel Corporation.
26 * lustre/lfsck/lfsck_namespace.c
28 * Author: Fan, Yong <fan.yong@intel.com>
32 # define EXPORT_SYMTAB
34 #define DEBUG_SUBSYSTEM S_LFSCK
36 #include <lustre/lustre_idl.h>
37 #include <lu_object.h>
38 #include <dt_object.h>
39 #include <lustre_linkea.h>
40 #include <lustre_fid.h>
41 #include <lustre_lib.h>
42 #include <lustre_net.h>
43 #include <lustre/lustre_user.h>
45 #include "lfsck_internal.h"
47 #define LFSCK_NAMESPACE_MAGIC 0xA0629D03
49 static const char lfsck_namespace_name[] = "lfsck_namespace";
51 static void lfsck_namespace_le_to_cpu(struct lfsck_namespace *des,
52 struct lfsck_namespace *src)
54 des->ln_magic = le32_to_cpu(src->ln_magic);
55 des->ln_status = le32_to_cpu(src->ln_status);
56 des->ln_flags = le32_to_cpu(src->ln_flags);
57 des->ln_success_count = le32_to_cpu(src->ln_success_count);
58 des->ln_run_time_phase1 = le32_to_cpu(src->ln_run_time_phase1);
59 des->ln_run_time_phase2 = le32_to_cpu(src->ln_run_time_phase2);
60 des->ln_time_last_complete = le64_to_cpu(src->ln_time_last_complete);
61 des->ln_time_latest_start = le64_to_cpu(src->ln_time_latest_start);
62 des->ln_time_last_checkpoint =
63 le64_to_cpu(src->ln_time_last_checkpoint);
64 lfsck_position_le_to_cpu(&des->ln_pos_latest_start,
65 &src->ln_pos_latest_start);
66 lfsck_position_le_to_cpu(&des->ln_pos_last_checkpoint,
67 &src->ln_pos_last_checkpoint);
68 lfsck_position_le_to_cpu(&des->ln_pos_first_inconsistent,
69 &src->ln_pos_first_inconsistent);
70 des->ln_items_checked = le64_to_cpu(src->ln_items_checked);
71 des->ln_items_repaired = le64_to_cpu(src->ln_items_repaired);
72 des->ln_items_failed = le64_to_cpu(src->ln_items_failed);
73 des->ln_dirs_checked = le64_to_cpu(src->ln_dirs_checked);
74 des->ln_mlinked_checked = le64_to_cpu(src->ln_mlinked_checked);
75 des->ln_objs_checked_phase2 = le64_to_cpu(src->ln_objs_checked_phase2);
76 des->ln_objs_repaired_phase2 =
77 le64_to_cpu(src->ln_objs_repaired_phase2);
78 des->ln_objs_failed_phase2 = le64_to_cpu(src->ln_objs_failed_phase2);
79 des->ln_objs_nlink_repaired = le64_to_cpu(src->ln_objs_nlink_repaired);
80 des->ln_objs_lost_found = le64_to_cpu(src->ln_objs_lost_found);
81 fid_le_to_cpu(&des->ln_fid_latest_scanned_phase2,
82 &src->ln_fid_latest_scanned_phase2);
85 static void lfsck_namespace_cpu_to_le(struct lfsck_namespace *des,
86 struct lfsck_namespace *src)
88 des->ln_magic = cpu_to_le32(src->ln_magic);
89 des->ln_status = cpu_to_le32(src->ln_status);
90 des->ln_flags = cpu_to_le32(src->ln_flags);
91 des->ln_success_count = cpu_to_le32(src->ln_success_count);
92 des->ln_run_time_phase1 = cpu_to_le32(src->ln_run_time_phase1);
93 des->ln_run_time_phase2 = cpu_to_le32(src->ln_run_time_phase2);
94 des->ln_time_last_complete = cpu_to_le64(src->ln_time_last_complete);
95 des->ln_time_latest_start = cpu_to_le64(src->ln_time_latest_start);
96 des->ln_time_last_checkpoint =
97 cpu_to_le64(src->ln_time_last_checkpoint);
98 lfsck_position_cpu_to_le(&des->ln_pos_latest_start,
99 &src->ln_pos_latest_start);
100 lfsck_position_cpu_to_le(&des->ln_pos_last_checkpoint,
101 &src->ln_pos_last_checkpoint);
102 lfsck_position_cpu_to_le(&des->ln_pos_first_inconsistent,
103 &src->ln_pos_first_inconsistent);
104 des->ln_items_checked = cpu_to_le64(src->ln_items_checked);
105 des->ln_items_repaired = cpu_to_le64(src->ln_items_repaired);
106 des->ln_items_failed = cpu_to_le64(src->ln_items_failed);
107 des->ln_dirs_checked = cpu_to_le64(src->ln_dirs_checked);
108 des->ln_mlinked_checked = cpu_to_le64(src->ln_mlinked_checked);
109 des->ln_objs_checked_phase2 = cpu_to_le64(src->ln_objs_checked_phase2);
110 des->ln_objs_repaired_phase2 =
111 cpu_to_le64(src->ln_objs_repaired_phase2);
112 des->ln_objs_failed_phase2 = cpu_to_le64(src->ln_objs_failed_phase2);
113 des->ln_objs_nlink_repaired = cpu_to_le64(src->ln_objs_nlink_repaired);
114 des->ln_objs_lost_found = cpu_to_le64(src->ln_objs_lost_found);
115 fid_cpu_to_le(&des->ln_fid_latest_scanned_phase2,
116 &src->ln_fid_latest_scanned_phase2);
120 * \retval +ve: the lfsck_namespace is broken, the caller should reset it.
121 * \retval 0: succeed.
122 * \retval -ve: failed cases.
124 static int lfsck_namespace_load(const struct lu_env *env,
125 struct lfsck_component *com)
127 int len = com->lc_file_size;
130 rc = dt_xattr_get(env, com->lc_obj,
131 lfsck_buf_get(env, com->lc_file_disk, len),
132 XATTR_NAME_LFSCK_NAMESPACE, BYPASS_CAPA);
134 struct lfsck_namespace *ns = com->lc_file_ram;
136 lfsck_namespace_le_to_cpu(ns,
137 (struct lfsck_namespace *)com->lc_file_disk);
138 if (ns->ln_magic != LFSCK_NAMESPACE_MAGIC) {
139 CWARN("%.16s: invalid lfsck_namespace magic "
141 lfsck_lfsck2name(com->lc_lfsck),
142 ns->ln_magic, LFSCK_NAMESPACE_MAGIC);
147 } else if (rc != -ENODATA) {
148 CERROR("%.16s: fail to load lfsck_namespace, expected = %d, "
149 "rc = %d\n", lfsck_lfsck2name(com->lc_lfsck), len, rc);
156 static int lfsck_namespace_store(const struct lu_env *env,
157 struct lfsck_component *com, bool init)
159 struct dt_object *obj = com->lc_obj;
160 struct lfsck_instance *lfsck = com->lc_lfsck;
161 struct thandle *handle;
162 int len = com->lc_file_size;
166 lfsck_namespace_cpu_to_le((struct lfsck_namespace *)com->lc_file_disk,
167 (struct lfsck_namespace *)com->lc_file_ram);
168 handle = dt_trans_create(env, lfsck->li_bottom);
169 if (IS_ERR(handle)) {
170 rc = PTR_ERR(handle);
171 CERROR("%.16s: fail to create trans for storing "
172 "lfsck_namespace: %d\n,", lfsck_lfsck2name(lfsck), rc);
176 rc = dt_declare_xattr_set(env, obj,
177 lfsck_buf_get(env, com->lc_file_disk, len),
178 XATTR_NAME_LFSCK_NAMESPACE, 0, handle);
180 CERROR("%.16s: fail to declare trans for storing "
181 "lfsck_namespace: %d\n,", lfsck_lfsck2name(lfsck), rc);
185 rc = dt_trans_start_local(env, lfsck->li_bottom, handle);
187 CERROR("%.16s: fail to start trans for storing "
188 "lfsck_namespace: %d\n,", lfsck_lfsck2name(lfsck), rc);
192 rc = dt_xattr_set(env, obj,
193 lfsck_buf_get(env, com->lc_file_disk, len),
194 XATTR_NAME_LFSCK_NAMESPACE,
195 init ? LU_XATTR_CREATE : LU_XATTR_REPLACE,
196 handle, BYPASS_CAPA);
198 CERROR("%.16s: fail to store lfsck_namespace, len = %d, "
199 "rc = %d\n", lfsck_lfsck2name(lfsck), len, rc);
204 dt_trans_stop(env, lfsck->li_bottom, handle);
208 static int lfsck_namespace_init(const struct lu_env *env,
209 struct lfsck_component *com)
211 struct lfsck_namespace *ns = (struct lfsck_namespace *)com->lc_file_ram;
214 memset(ns, 0, sizeof(*ns));
215 ns->ln_magic = LFSCK_NAMESPACE_MAGIC;
216 ns->ln_status = LS_INIT;
217 down_write(&com->lc_sem);
218 rc = lfsck_namespace_store(env, com, true);
219 up_write(&com->lc_sem);
223 static int lfsck_namespace_lookup(const struct lu_env *env,
224 struct lfsck_component *com,
225 const struct lu_fid *fid, __u8 *flags)
227 struct lu_fid *key = &lfsck_env_info(env)->lti_fid;
230 fid_cpu_to_be(key, fid);
231 rc = dt_lookup(env, com->lc_obj, (struct dt_rec *)flags,
232 (const struct dt_key *)key, BYPASS_CAPA);
236 static int lfsck_namespace_delete(const struct lu_env *env,
237 struct lfsck_component *com,
238 const struct lu_fid *fid)
240 struct lfsck_instance *lfsck = com->lc_lfsck;
241 struct lu_fid *key = &lfsck_env_info(env)->lti_fid;
242 struct thandle *handle;
243 struct dt_object *obj = com->lc_obj;
247 handle = dt_trans_create(env, lfsck->li_bottom);
249 RETURN(PTR_ERR(handle));
251 rc = dt_declare_delete(env, obj, (const struct dt_key *)fid, handle);
255 rc = dt_trans_start_local(env, lfsck->li_bottom, handle);
259 fid_cpu_to_be(key, fid);
260 rc = dt_delete(env, obj, (const struct dt_key *)key, handle,
266 dt_trans_stop(env, lfsck->li_bottom, handle);
270 static int lfsck_namespace_update(const struct lu_env *env,
271 struct lfsck_component *com,
272 const struct lu_fid *fid,
273 __u8 flags, bool force)
275 struct lfsck_instance *lfsck = com->lc_lfsck;
276 struct lu_fid *key = &lfsck_env_info(env)->lti_fid;
277 struct thandle *handle;
278 struct dt_object *obj = com->lc_obj;
284 rc = lfsck_namespace_lookup(env, com, fid, &tf);
285 if (rc != 0 && rc != -ENOENT)
289 if (!force || flags == tf)
293 handle = dt_trans_create(env, lfsck->li_bottom);
295 RETURN(PTR_ERR(handle));
297 rc = dt_declare_delete(env, obj, (const struct dt_key *)fid,
302 handle = dt_trans_create(env, lfsck->li_bottom);
304 RETURN(PTR_ERR(handle));
307 rc = dt_declare_insert(env, obj, (const struct dt_rec *)&flags,
308 (const struct dt_key *)fid, handle);
312 rc = dt_trans_start_local(env, lfsck->li_bottom, handle);
316 fid_cpu_to_be(key, fid);
318 rc = dt_delete(env, obj, (const struct dt_key *)key, handle,
321 CERROR("%s: fail to insert "DFID", rc = %d\n",
322 lfsck_lfsck2name(com->lc_lfsck), PFID(fid), rc);
327 rc = dt_insert(env, obj, (const struct dt_rec *)&flags,
328 (const struct dt_key *)key, handle, BYPASS_CAPA, 1);
333 dt_trans_stop(env, lfsck->li_bottom, handle);
337 static int lfsck_namespace_check_exist(const struct lu_env *env,
338 struct lfsck_instance *lfsck,
339 struct dt_object *obj, const char *name)
341 struct dt_object *dir = lfsck->li_obj_dir;
342 struct lu_fid *fid = &lfsck_env_info(env)->lti_fid;
346 if (unlikely(lfsck_is_dead_obj(obj)))
347 RETURN(LFSCK_NAMEENTRY_DEAD);
349 rc = dt_lookup(env, dir, (struct dt_rec *)fid,
350 (const struct dt_key *)name, BYPASS_CAPA);
352 RETURN(LFSCK_NAMEENTRY_REMOVED);
357 if (!lu_fid_eq(fid, lfsck_dto2fid(obj)))
358 RETURN(LFSCK_NAMEENTRY_RECREATED);
363 static int lfsck_declare_namespace_exec_dir(const struct lu_env *env,
364 struct dt_object *obj,
365 struct thandle *handle)
369 /* For destroying all invalid linkEA entries. */
370 rc = dt_declare_xattr_del(env, obj, XATTR_NAME_LINK, handle);
374 /* For insert new linkEA entry. */
375 rc = dt_declare_xattr_set(env, obj,
376 lfsck_buf_get_const(env, NULL, DEFAULT_LINKEA_SIZE),
377 XATTR_NAME_LINK, 0, handle);
381 static int lfsck_links_read(const struct lu_env *env, struct dt_object *obj,
382 struct linkea_data *ldata)
387 lu_buf_check_and_alloc(&lfsck_env_info(env)->lti_linkea_buf,
389 if (ldata->ld_buf->lb_buf == NULL)
392 if (!dt_object_exists(obj))
395 rc = dt_xattr_get(env, obj, ldata->ld_buf, XATTR_NAME_LINK, BYPASS_CAPA);
397 /* Buf was too small, figure out what we need. */
398 lu_buf_free(ldata->ld_buf);
399 rc = dt_xattr_get(env, obj, ldata->ld_buf, XATTR_NAME_LINK,
404 ldata->ld_buf = lu_buf_check_and_alloc(ldata->ld_buf, rc);
405 if (ldata->ld_buf->lb_buf == NULL)
408 rc = dt_xattr_get(env, obj, ldata->ld_buf, XATTR_NAME_LINK,
419 static int lfsck_links_write(const struct lu_env *env, struct dt_object *obj,
420 struct linkea_data *ldata, struct thandle *handle)
422 const struct lu_buf *buf = lfsck_buf_get_const(env,
423 ldata->ld_buf->lb_buf,
424 ldata->ld_leh->leh_len);
426 return dt_xattr_set(env, obj, buf, XATTR_NAME_LINK, 0, handle,
431 * \retval +ve repaired
432 * \retval 0 no need to repair
433 * \retval -ve error cases
435 static int lfsck_namespace_double_scan_one(const struct lu_env *env,
436 struct lfsck_component *com,
437 struct dt_object *child, __u8 flags)
439 struct lfsck_thread_info *info = lfsck_env_info(env);
440 struct lu_attr *la = &info->lti_la;
441 struct lu_name *cname = &info->lti_name;
442 struct lu_fid *pfid = &info->lti_fid;
443 struct lu_fid *cfid = &info->lti_fid2;
444 struct lfsck_instance *lfsck = com->lc_lfsck;
445 struct lfsck_bookmark *bk = &lfsck->li_bookmark_ram;
446 struct lfsck_namespace *ns =
447 (struct lfsck_namespace *)com->lc_file_ram;
448 struct linkea_data ldata = { 0 };
449 struct thandle *handle = NULL;
456 if (com->lc_journal) {
462 handle = dt_trans_create(env, lfsck->li_next);
464 RETURN(rc = PTR_ERR(handle));
466 rc = dt_declare_xattr_set(env, child,
467 lfsck_buf_get_const(env, NULL, DEFAULT_LINKEA_SIZE),
468 XATTR_NAME_LINK, 0, handle);
472 rc = dt_trans_start(env, lfsck->li_next, handle);
476 dt_write_lock(env, child, MOR_TGT_CHILD);
480 if (unlikely(lfsck_is_dead_obj(child)))
483 rc = dt_attr_get(env, child, la, BYPASS_CAPA);
485 rc = lfsck_links_read(env, child, &ldata);
487 if ((bk->lb_param & LPF_DRYRUN) &&
488 (rc == -EINVAL || rc == -ENODATA))
494 ldata.ld_lee = LINKEA_FIRST_ENTRY(ldata);
495 count = ldata.ld_leh->leh_reccount;
496 while (count-- > 0) {
497 struct dt_object *parent = NULL;
499 linkea_entry_unpack(ldata.ld_lee, &ldata.ld_reclen, cname,
501 if (!fid_is_sane(pfid))
504 parent = lfsck_object_find(env, lfsck, pfid);
507 else if (IS_ERR(parent))
508 GOTO(stop, rc = PTR_ERR(parent));
510 if (!dt_object_exists(parent))
513 /* XXX: Currently, skip remote object, the consistency for
514 * remote object will be processed in LFSCK phase III. */
515 if (dt_object_remote(parent)) {
516 lfsck_object_put(env, parent);
517 ldata.ld_lee = LINKEA_NEXT_ENTRY(ldata);
521 if (unlikely(!dt_try_as_dir(env, parent)))
524 /* To guarantee the 'name' is terminated with '0'. */
525 memcpy(info->lti_key, cname->ln_name, cname->ln_namelen);
526 info->lti_key[cname->ln_namelen] = 0;
527 cname->ln_name = info->lti_key;
528 rc = dt_lookup(env, parent, (struct dt_rec *)cfid,
529 (const struct dt_key *)cname->ln_name,
531 if (rc != 0 && rc != -ENOENT) {
532 lfsck_object_put(env, parent);
537 if (lu_fid_eq(cfid, lfsck_dto2fid(child))) {
538 lfsck_object_put(env, parent);
539 ldata.ld_lee = LINKEA_NEXT_ENTRY(ldata);
546 if (ldata.ld_leh->leh_reccount > la->la_nlink)
549 /* XXX: For the case of there is linkea entry, but without name
550 * entry pointing to the object, and the object link count
551 * isn't less than the count of name entries, then add the
552 * name entry back to namespace.
554 * It is out of LFSCK 1.5 scope, will implement it in the
555 * future. Keep the linkEA entry. */
556 lfsck_object_put(env, parent);
557 ldata.ld_lee = LINKEA_NEXT_ENTRY(ldata);
562 lfsck_object_put(env, parent);
563 if (bk->lb_param & LPF_DRYRUN)
566 CDEBUG(D_LFSCK, "Remove linkEA: "DFID"[%.*s], "DFID"\n",
567 PFID(lfsck_dto2fid(child)), cname->ln_namelen, cname->ln_name,
569 linkea_del_buf(&ldata, cname);
574 if (!com->lc_journal) {
579 rc = lfsck_links_write(env, child, &ldata, handle);
586 dt_write_unlock(env, child);
589 dt_trans_stop(env, lfsck->li_next, handle);
591 if (rc == 0 && update) {
592 ns->ln_objs_nlink_repaired++;
600 static int lfsck_namespace_reset(const struct lu_env *env,
601 struct lfsck_component *com, bool init)
603 struct lfsck_instance *lfsck = com->lc_lfsck;
604 struct lfsck_namespace *ns =
605 (struct lfsck_namespace *)com->lc_file_ram;
606 struct dt_object *dto;
610 down_write(&com->lc_sem);
612 memset(ns, 0, sizeof(*ns));
614 __u32 count = ns->ln_success_count;
615 __u64 last_time = ns->ln_time_last_complete;
617 memset(ns, 0, sizeof(*ns));
618 ns->ln_success_count = count;
619 ns->ln_time_last_complete = last_time;
621 ns->ln_magic = LFSCK_NAMESPACE_MAGIC;
622 ns->ln_status = LS_INIT;
624 rc = local_object_unlink(env, lfsck->li_bottom, lfsck->li_local_root,
625 lfsck_namespace_name);
629 dto = local_index_find_or_create(env, lfsck->li_los, lfsck->li_local_root,
630 lfsck_namespace_name,
631 S_IFREG | S_IRUGO | S_IWUSR,
634 GOTO(out, rc = PTR_ERR(dto));
636 rc = dto->do_ops->do_index_try(env, dto, &dt_lfsck_features);
641 rc = lfsck_namespace_store(env, com, true);
646 up_write(&com->lc_sem);
651 lfsck_namespace_fail(const struct lu_env *env, struct lfsck_component *com,
654 struct lfsck_namespace *ns = (struct lfsck_namespace *)com->lc_file_ram;
656 down_write(&com->lc_sem);
658 com->lc_new_checked++;
659 ns->ln_items_failed++;
660 if (lfsck_pos_is_zero(&ns->ln_pos_first_inconsistent))
661 lfsck_pos_fill(env, com->lc_lfsck,
662 &ns->ln_pos_first_inconsistent, false);
663 up_write(&com->lc_sem);
666 static int lfsck_namespace_checkpoint(const struct lu_env *env,
667 struct lfsck_component *com, bool init)
669 struct lfsck_instance *lfsck = com->lc_lfsck;
670 struct lfsck_namespace *ns =
671 (struct lfsck_namespace *)com->lc_file_ram;
674 if (com->lc_new_checked == 0 && !init)
677 down_write(&com->lc_sem);
680 ns->ln_pos_latest_start = lfsck->li_pos_current;
682 ns->ln_pos_last_checkpoint = lfsck->li_pos_current;
683 ns->ln_run_time_phase1 += cfs_duration_sec(cfs_time_current() +
684 HALF_SEC - lfsck->li_time_last_checkpoint);
685 ns->ln_time_last_checkpoint = cfs_time_current_sec();
686 ns->ln_items_checked += com->lc_new_checked;
687 com->lc_new_checked = 0;
690 rc = lfsck_namespace_store(env, com, false);
692 up_write(&com->lc_sem);
696 static int lfsck_namespace_prep(const struct lu_env *env,
697 struct lfsck_component *com)
699 struct lfsck_instance *lfsck = com->lc_lfsck;
700 struct lfsck_namespace *ns =
701 (struct lfsck_namespace *)com->lc_file_ram;
702 struct lfsck_position *pos = &com->lc_pos_start;
704 if (ns->ln_status == LS_COMPLETED) {
707 rc = lfsck_namespace_reset(env, com, false);
712 down_write(&com->lc_sem);
714 ns->ln_time_latest_start = cfs_time_current_sec();
716 spin_lock(&lfsck->li_lock);
717 if (ns->ln_flags & LF_SCANNED_ONCE) {
718 if (!lfsck->li_drop_dryrun ||
719 lfsck_pos_is_zero(&ns->ln_pos_first_inconsistent)) {
720 ns->ln_status = LS_SCANNING_PHASE2;
721 cfs_list_del_init(&com->lc_link);
722 cfs_list_add_tail(&com->lc_link,
723 &lfsck->li_list_double_scan);
724 if (!cfs_list_empty(&com->lc_link_dir))
725 cfs_list_del_init(&com->lc_link_dir);
726 lfsck_pos_set_zero(pos);
728 ns->ln_status = LS_SCANNING_PHASE1;
729 ns->ln_run_time_phase1 = 0;
730 ns->ln_run_time_phase2 = 0;
731 ns->ln_items_checked = 0;
732 ns->ln_items_repaired = 0;
733 ns->ln_items_failed = 0;
734 ns->ln_dirs_checked = 0;
735 ns->ln_mlinked_checked = 0;
736 ns->ln_objs_checked_phase2 = 0;
737 ns->ln_objs_repaired_phase2 = 0;
738 ns->ln_objs_failed_phase2 = 0;
739 ns->ln_objs_nlink_repaired = 0;
740 ns->ln_objs_lost_found = 0;
741 fid_zero(&ns->ln_fid_latest_scanned_phase2);
742 if (cfs_list_empty(&com->lc_link_dir))
743 cfs_list_add_tail(&com->lc_link_dir,
744 &lfsck->li_list_dir);
745 *pos = ns->ln_pos_first_inconsistent;
748 ns->ln_status = LS_SCANNING_PHASE1;
749 if (cfs_list_empty(&com->lc_link_dir))
750 cfs_list_add_tail(&com->lc_link_dir,
751 &lfsck->li_list_dir);
752 if (!lfsck->li_drop_dryrun ||
753 lfsck_pos_is_zero(&ns->ln_pos_first_inconsistent)) {
754 *pos = ns->ln_pos_last_checkpoint;
755 pos->lp_oit_cookie++;
757 *pos = ns->ln_pos_first_inconsistent;
760 spin_unlock(&lfsck->li_lock);
762 up_write(&com->lc_sem);
766 static int lfsck_namespace_exec_oit(const struct lu_env *env,
767 struct lfsck_component *com,
768 struct dt_object *obj)
770 down_write(&com->lc_sem);
771 com->lc_new_checked++;
772 if (S_ISDIR(lfsck_object_type(obj)))
773 ((struct lfsck_namespace *)com->lc_file_ram)->ln_dirs_checked++;
774 up_write(&com->lc_sem);
778 static int lfsck_namespace_exec_dir(const struct lu_env *env,
779 struct lfsck_component *com,
780 struct dt_object *obj,
781 struct lu_dirent *ent)
783 struct lfsck_thread_info *info = lfsck_env_info(env);
784 struct lu_attr *la = &info->lti_la;
785 struct lfsck_instance *lfsck = com->lc_lfsck;
786 struct lfsck_bookmark *bk = &lfsck->li_bookmark_ram;
787 struct lfsck_namespace *ns =
788 (struct lfsck_namespace *)com->lc_file_ram;
789 struct linkea_data ldata = { 0 };
790 const struct lu_fid *pfid =
791 lu_object_fid(&lfsck->li_obj_dir->do_lu);
792 const struct lu_fid *cfid = lfsck_dto2fid(obj);
793 const struct lu_name *cname;
794 struct thandle *handle = NULL;
795 bool repaired = false;
801 cname = lfsck_name_get_const(env, ent->lde_name, ent->lde_namelen);
802 down_write(&com->lc_sem);
803 com->lc_new_checked++;
805 if (ent->lde_attrs & LUDA_UPGRADE) {
806 ns->ln_flags |= LF_UPGRADE;
808 } else if (ent->lde_attrs & LUDA_REPAIR) {
809 ns->ln_flags |= LF_INCONSISTENT;
813 if (ent->lde_name[0] == '.' &&
814 (ent->lde_namelen == 1 ||
815 (ent->lde_namelen == 2 && ent->lde_name[1] == '.') ||
816 fid_is_dot_lustre(&ent->lde_fid)))
819 if (!(bk->lb_param & LPF_DRYRUN) &&
820 (com->lc_journal || repaired)) {
826 handle = dt_trans_create(env, lfsck->li_next);
828 GOTO(out, rc = PTR_ERR(handle));
830 rc = lfsck_declare_namespace_exec_dir(env, obj, handle);
834 rc = dt_trans_start(env, lfsck->li_next, handle);
838 dt_write_lock(env, obj, MOR_TGT_CHILD);
842 rc = lfsck_namespace_check_exist(env, lfsck, obj, ent->lde_name);
846 rc = lfsck_links_read(env, obj, &ldata);
848 count = ldata.ld_leh->leh_reccount;
849 rc = linkea_links_find(&ldata, cname, pfid);
851 /* For dir, if there are more than one linkea entries,
852 * then remove all the other redundant linkea entries.*/
853 if (unlikely(count > 1 &&
854 S_ISDIR(lfsck_object_type(obj))))
861 ns->ln_flags |= LF_INCONSISTENT;
862 if (bk->lb_param & LPF_DRYRUN) {
867 /*For dir, remove the unmatched linkea entry directly.*/
868 if (S_ISDIR(lfsck_object_type(obj))) {
869 if (!com->lc_journal)
872 rc = dt_xattr_del(env, obj, XATTR_NAME_LINK,
873 handle, BYPASS_CAPA);
882 } else if (unlikely(rc == -EINVAL)) {
883 ns->ln_flags |= LF_INCONSISTENT;
884 if (bk->lb_param & LPF_DRYRUN) {
890 if (!com->lc_journal)
893 /* The magic crashed, we are not sure whether there are more
894 * corrupt data in the linkea, so remove all linkea entries. */
895 rc = dt_xattr_del(env, obj, XATTR_NAME_LINK, handle,
901 } else if (rc == -ENODATA) {
902 ns->ln_flags |= LF_UPGRADE;
903 if (bk->lb_param & LPF_DRYRUN) {
910 rc = linkea_data_new(&ldata,
911 &lfsck_env_info(env)->lti_linkea_buf);
916 if (!com->lc_journal)
919 rc = linkea_add_buf(&ldata, cname, pfid);
923 rc = lfsck_links_write(env, obj, &ldata, handle);
927 count = ldata.ld_leh->leh_reccount;
936 rc = dt_attr_get(env, obj, la, BYPASS_CAPA);
941 (la->la_nlink == 1 || S_ISDIR(lfsck_object_type(obj))))
942 /* Usually, it is for single linked object or dir, do nothing.*/
945 /* Following modification will be in another transaction. */
946 if (handle != NULL) {
947 LASSERT(dt_write_locked(env, obj));
949 dt_write_unlock(env, obj);
952 dt_trans_stop(env, lfsck->li_next, handle);
956 ns->ln_mlinked_checked++;
957 rc = lfsck_namespace_update(env, com, cfid,
958 count != la->la_nlink ? LLF_UNMATCH_NLINKS : 0, false);
964 dt_write_unlock(env, obj);
967 dt_trans_stop(env, lfsck->li_next, handle);
971 ns->ln_items_failed++;
972 if (lfsck_pos_is_zero(&ns->ln_pos_first_inconsistent))
973 lfsck_pos_fill(env, lfsck,
974 &ns->ln_pos_first_inconsistent, false);
975 if (!(bk->lb_param & LPF_FAILOUT))
979 ns->ln_items_repaired++;
984 up_write(&com->lc_sem);
988 static int lfsck_namespace_post(const struct lu_env *env,
989 struct lfsck_component *com,
990 int result, bool init)
992 struct lfsck_instance *lfsck = com->lc_lfsck;
993 struct lfsck_namespace *ns =
994 (struct lfsck_namespace *)com->lc_file_ram;
997 down_write(&com->lc_sem);
999 spin_lock(&lfsck->li_lock);
1001 ns->ln_pos_last_checkpoint = lfsck->li_pos_current;
1003 ns->ln_status = LS_SCANNING_PHASE2;
1004 ns->ln_flags |= LF_SCANNED_ONCE;
1005 ns->ln_flags &= ~LF_UPGRADE;
1006 cfs_list_del_init(&com->lc_link);
1007 cfs_list_del_init(&com->lc_link_dir);
1008 cfs_list_add_tail(&com->lc_link, &lfsck->li_list_double_scan);
1009 } else if (result == 0) {
1010 if (lfsck->li_paused) {
1011 ns->ln_status = LS_PAUSED;
1013 ns->ln_status = LS_STOPPED;
1014 cfs_list_del_init(&com->lc_link);
1015 cfs_list_del_init(&com->lc_link_dir);
1016 cfs_list_add_tail(&com->lc_link, &lfsck->li_list_idle);
1019 ns->ln_status = LS_FAILED;
1020 cfs_list_del_init(&com->lc_link);
1021 cfs_list_del_init(&com->lc_link_dir);
1022 cfs_list_add_tail(&com->lc_link, &lfsck->li_list_idle);
1024 spin_unlock(&lfsck->li_lock);
1027 ns->ln_run_time_phase1 += cfs_duration_sec(cfs_time_current() +
1028 HALF_SEC - lfsck->li_time_last_checkpoint);
1029 ns->ln_time_last_checkpoint = cfs_time_current_sec();
1030 ns->ln_items_checked += com->lc_new_checked;
1031 com->lc_new_checked = 0;
1034 rc = lfsck_namespace_store(env, com, false);
1036 up_write(&com->lc_sem);
1041 lfsck_namespace_dump(const struct lu_env *env, struct lfsck_component *com,
1044 struct lfsck_instance *lfsck = com->lc_lfsck;
1045 struct lfsck_bookmark *bk = &lfsck->li_bookmark_ram;
1046 struct lfsck_namespace *ns =
1047 (struct lfsck_namespace *)com->lc_file_ram;
1052 down_read(&com->lc_sem);
1053 rc = snprintf(buf, len,
1054 "name: lfsck_namespace\n"
1060 lfsck_status_names[ns->ln_status]);
1066 rc = lfsck_bits_dump(&buf, &len, ns->ln_flags, lfsck_flags_names,
1071 rc = lfsck_bits_dump(&buf, &len, bk->lb_param, lfsck_param_names,
1076 rc = lfsck_time_dump(&buf, &len, ns->ln_time_last_complete,
1077 "time_since_last_completed");
1081 rc = lfsck_time_dump(&buf, &len, ns->ln_time_latest_start,
1082 "time_since_latest_start");
1086 rc = lfsck_time_dump(&buf, &len, ns->ln_time_last_checkpoint,
1087 "time_since_last_checkpoint");
1091 rc = lfsck_pos_dump(&buf, &len, &ns->ln_pos_latest_start,
1092 "latest_start_position");
1096 rc = lfsck_pos_dump(&buf, &len, &ns->ln_pos_last_checkpoint,
1097 "last_checkpoint_position");
1101 rc = lfsck_pos_dump(&buf, &len, &ns->ln_pos_first_inconsistent,
1102 "first_failure_position");
1106 if (ns->ln_status == LS_SCANNING_PHASE1) {
1107 struct lfsck_position pos;
1108 cfs_duration_t duration = cfs_time_current() -
1109 lfsck->li_time_last_checkpoint;
1110 __u64 checked = ns->ln_items_checked + com->lc_new_checked;
1111 __u64 speed = checked;
1112 __u64 new_checked = com->lc_new_checked * CFS_HZ;
1113 __u32 rtime = ns->ln_run_time_phase1 +
1114 cfs_duration_sec(duration + HALF_SEC);
1117 do_div(new_checked, duration);
1119 do_div(speed, rtime);
1120 rc = snprintf(buf, len,
1121 "checked_phase1: "LPU64"\n"
1122 "checked_phase2: "LPU64"\n"
1123 "updated_phase1: "LPU64"\n"
1124 "updated_phase2: "LPU64"\n"
1125 "failed_phase1: "LPU64"\n"
1126 "failed_phase2: "LPU64"\n"
1128 "M-linked: "LPU64"\n"
1129 "nlinks_repaired: "LPU64"\n"
1130 "lost_found: "LPU64"\n"
1131 "success_count: %u\n"
1132 "run_time_phase1: %u seconds\n"
1133 "run_time_phase2: %u seconds\n"
1134 "average_speed_phase1: "LPU64" items/sec\n"
1135 "average_speed_phase2: N/A\n"
1136 "real-time_speed_phase1: "LPU64" items/sec\n"
1137 "real-time_speed_phase2: N/A\n",
1139 ns->ln_objs_checked_phase2,
1140 ns->ln_items_repaired,
1141 ns->ln_objs_repaired_phase2,
1142 ns->ln_items_failed,
1143 ns->ln_objs_failed_phase2,
1144 ns->ln_dirs_checked,
1145 ns->ln_mlinked_checked,
1146 ns->ln_objs_nlink_repaired,
1147 ns->ln_objs_lost_found,
1148 ns->ln_success_count,
1150 ns->ln_run_time_phase2,
1158 lfsck_pos_fill(env, lfsck, &pos, false);
1159 rc = lfsck_pos_dump(&buf, &len, &pos, "current_position");
1162 } else if (ns->ln_status == LS_SCANNING_PHASE2) {
1163 cfs_duration_t duration = cfs_time_current() -
1164 lfsck->li_time_last_checkpoint;
1165 __u64 checked = ns->ln_objs_checked_phase2 +
1166 com->lc_new_checked;
1167 __u64 speed1 = ns->ln_items_checked;
1168 __u64 speed2 = checked;
1169 __u64 new_checked = com->lc_new_checked * CFS_HZ;
1170 __u32 rtime = ns->ln_run_time_phase2 +
1171 cfs_duration_sec(duration + HALF_SEC);
1174 do_div(new_checked, duration);
1175 if (ns->ln_run_time_phase1 != 0)
1176 do_div(speed1, ns->ln_run_time_phase1);
1178 do_div(speed2, rtime);
1179 rc = snprintf(buf, len,
1180 "checked_phase1: "LPU64"\n"
1181 "checked_phase2: "LPU64"\n"
1182 "updated_phase1: "LPU64"\n"
1183 "updated_phase2: "LPU64"\n"
1184 "failed_phase1: "LPU64"\n"
1185 "failed_phase2: "LPU64"\n"
1187 "M-linked: "LPU64"\n"
1188 "nlinks_repaired: "LPU64"\n"
1189 "lost_found: "LPU64"\n"
1190 "success_count: %u\n"
1191 "run_time_phase1: %u seconds\n"
1192 "run_time_phase2: %u seconds\n"
1193 "average_speed_phase1: "LPU64" items/sec\n"
1194 "average_speed_phase2: "LPU64" objs/sec\n"
1195 "real-time_speed_phase1: N/A\n"
1196 "real-time_speed_phase2: "LPU64" objs/sec\n"
1197 "current_position: "DFID"\n",
1198 ns->ln_items_checked,
1200 ns->ln_items_repaired,
1201 ns->ln_objs_repaired_phase2,
1202 ns->ln_items_failed,
1203 ns->ln_objs_failed_phase2,
1204 ns->ln_dirs_checked,
1205 ns->ln_mlinked_checked,
1206 ns->ln_objs_nlink_repaired,
1207 ns->ln_objs_lost_found,
1208 ns->ln_success_count,
1209 ns->ln_run_time_phase1,
1214 PFID(&ns->ln_fid_latest_scanned_phase2));
1221 __u64 speed1 = ns->ln_items_checked;
1222 __u64 speed2 = ns->ln_objs_checked_phase2;
1224 if (ns->ln_run_time_phase1 != 0)
1225 do_div(speed1, ns->ln_run_time_phase1);
1226 if (ns->ln_run_time_phase2 != 0)
1227 do_div(speed2, ns->ln_run_time_phase2);
1228 rc = snprintf(buf, len,
1229 "checked_phase1: "LPU64"\n"
1230 "checked_phase2: "LPU64"\n"
1231 "updated_phase1: "LPU64"\n"
1232 "updated_phase2: "LPU64"\n"
1233 "failed_phase1: "LPU64"\n"
1234 "failed_phase2: "LPU64"\n"
1236 "M-linked: "LPU64"\n"
1237 "nlinks_repaired: "LPU64"\n"
1238 "lost_found: "LPU64"\n"
1239 "success_count: %u\n"
1240 "run_time_phase1: %u seconds\n"
1241 "run_time_phase2: %u seconds\n"
1242 "average_speed_phase1: "LPU64" items/sec\n"
1243 "average_speed_phase2: "LPU64" objs/sec\n"
1244 "real-time_speed_phase1: N/A\n"
1245 "real-time_speed_phase2: N/A\n"
1246 "current_position: N/A\n",
1247 ns->ln_items_checked,
1248 ns->ln_objs_checked_phase2,
1249 ns->ln_items_repaired,
1250 ns->ln_objs_repaired_phase2,
1251 ns->ln_items_failed,
1252 ns->ln_objs_failed_phase2,
1253 ns->ln_dirs_checked,
1254 ns->ln_mlinked_checked,
1255 ns->ln_objs_nlink_repaired,
1256 ns->ln_objs_lost_found,
1257 ns->ln_success_count,
1258 ns->ln_run_time_phase1,
1259 ns->ln_run_time_phase2,
1271 up_read(&com->lc_sem);
1275 static int lfsck_namespace_double_scan(const struct lu_env *env,
1276 struct lfsck_component *com)
1278 struct lfsck_instance *lfsck = com->lc_lfsck;
1279 struct ptlrpc_thread *thread = &lfsck->li_thread;
1280 struct lfsck_bookmark *bk = &lfsck->li_bookmark_ram;
1281 struct lfsck_namespace *ns =
1282 (struct lfsck_namespace *)com->lc_file_ram;
1283 struct dt_object *obj = com->lc_obj;
1284 const struct dt_it_ops *iops = &obj->do_index_ops->dio_it;
1285 struct dt_object *target;
1293 lfsck->li_new_scanned = 0;
1294 lfsck->li_time_last_checkpoint = cfs_time_current();
1295 lfsck->li_time_next_checkpoint = lfsck->li_time_last_checkpoint +
1296 cfs_time_seconds(LFSCK_CHECKPOINT_INTERVAL);
1298 di = iops->init(env, obj, 0, BYPASS_CAPA);
1300 RETURN(PTR_ERR(di));
1302 fid_cpu_to_be(&fid, &ns->ln_fid_latest_scanned_phase2);
1303 rc = iops->get(env, di, (const struct dt_key *)&fid);
1307 /* Skip the start one, which either has been processed or non-exist. */
1308 rc = iops->next(env, di);
1312 if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_NO_DOUBLESCAN))
1316 if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_DELAY3) &&
1318 struct l_wait_info lwi;
1320 lwi = LWI_TIMEOUT(cfs_time_seconds(cfs_fail_val),
1322 l_wait_event(thread->t_ctl_waitq,
1323 !thread_is_running(thread),
1327 key = iops->key(env, di);
1328 fid_be_to_cpu(&fid, (const struct lu_fid *)key);
1329 target = lfsck_object_find(env, lfsck, &fid);
1330 down_write(&com->lc_sem);
1331 if (target == NULL) {
1334 } else if (IS_ERR(target)) {
1335 rc = PTR_ERR(target);
1339 /* XXX: Currently, skip remote object, the consistency for
1340 * remote object will be processed in LFSCK phase III. */
1341 if (!dt_object_exists(target) || dt_object_remote(target))
1344 rc = iops->rec(env, di, (struct dt_rec *)&flags, 0);
1346 rc = lfsck_namespace_double_scan_one(env, com,
1350 lfsck_object_put(env, target);
1353 lfsck->li_new_scanned++;
1354 com->lc_new_checked++;
1355 ns->ln_fid_latest_scanned_phase2 = fid;
1357 ns->ln_objs_repaired_phase2++;
1359 ns->ln_objs_failed_phase2++;
1360 up_write(&com->lc_sem);
1362 if ((rc == 0) || ((rc > 0) && !(bk->lb_param & LPF_DRYRUN))) {
1363 lfsck_namespace_delete(env, com, &fid);
1364 } else if (rc < 0) {
1365 flags |= LLF_REPAIR_FAILED;
1366 lfsck_namespace_update(env, com, &fid, flags, true);
1369 if (rc < 0 && bk->lb_param & LPF_FAILOUT)
1372 if (likely(cfs_time_beforeq(cfs_time_current(),
1373 lfsck->li_time_next_checkpoint)) ||
1374 com->lc_new_checked == 0)
1377 down_write(&com->lc_sem);
1378 ns->ln_run_time_phase2 += cfs_duration_sec(cfs_time_current() +
1379 HALF_SEC - lfsck->li_time_last_checkpoint);
1380 ns->ln_time_last_checkpoint = cfs_time_current_sec();
1381 ns->ln_objs_checked_phase2 += com->lc_new_checked;
1382 com->lc_new_checked = 0;
1383 rc = lfsck_namespace_store(env, com, false);
1384 up_write(&com->lc_sem);
1388 lfsck->li_time_last_checkpoint = cfs_time_current();
1389 lfsck->li_time_next_checkpoint = lfsck->li_time_last_checkpoint +
1390 cfs_time_seconds(LFSCK_CHECKPOINT_INTERVAL);
1393 lfsck_control_speed(lfsck);
1394 if (unlikely(!thread_is_running(thread)))
1397 rc = iops->next(env, di);
1406 iops->fini(env, di);
1407 down_write(&com->lc_sem);
1409 ns->ln_run_time_phase2 += cfs_duration_sec(cfs_time_current() +
1410 HALF_SEC - lfsck->li_time_last_checkpoint);
1411 ns->ln_time_last_checkpoint = cfs_time_current_sec();
1412 ns->ln_objs_checked_phase2 += com->lc_new_checked;
1413 com->lc_new_checked = 0;
1416 com->lc_journal = 0;
1417 ns->ln_status = LS_COMPLETED;
1418 if (!(bk->lb_param & LPF_DRYRUN))
1420 ~(LF_SCANNED_ONCE | LF_INCONSISTENT | LF_UPGRADE);
1421 ns->ln_time_last_complete = ns->ln_time_last_checkpoint;
1422 ns->ln_success_count++;
1423 } else if (rc == 0) {
1424 if (lfsck->li_paused)
1425 ns->ln_status = LS_PAUSED;
1427 ns->ln_status = LS_STOPPED;
1429 ns->ln_status = LS_FAILED;
1432 if (ns->ln_status != LS_PAUSED) {
1433 spin_lock(&lfsck->li_lock);
1434 cfs_list_del_init(&com->lc_link);
1435 cfs_list_add_tail(&com->lc_link, &lfsck->li_list_idle);
1436 spin_unlock(&lfsck->li_lock);
1439 rc = lfsck_namespace_store(env, com, false);
1441 up_write(&com->lc_sem);
1445 static struct lfsck_operations lfsck_namespace_ops = {
1446 .lfsck_reset = lfsck_namespace_reset,
1447 .lfsck_fail = lfsck_namespace_fail,
1448 .lfsck_checkpoint = lfsck_namespace_checkpoint,
1449 .lfsck_prep = lfsck_namespace_prep,
1450 .lfsck_exec_oit = lfsck_namespace_exec_oit,
1451 .lfsck_exec_dir = lfsck_namespace_exec_dir,
1452 .lfsck_post = lfsck_namespace_post,
1453 .lfsck_dump = lfsck_namespace_dump,
1454 .lfsck_double_scan = lfsck_namespace_double_scan,
1457 int lfsck_namespace_setup(const struct lu_env *env,
1458 struct lfsck_instance *lfsck)
1460 struct lfsck_component *com;
1461 struct lfsck_namespace *ns;
1462 struct dt_object *obj;
1466 LASSERT(lfsck->li_master);
1472 CFS_INIT_LIST_HEAD(&com->lc_link);
1473 CFS_INIT_LIST_HEAD(&com->lc_link_dir);
1474 init_rwsem(&com->lc_sem);
1475 atomic_set(&com->lc_ref, 1);
1476 com->lc_lfsck = lfsck;
1477 com->lc_type = LT_NAMESPACE;
1478 com->lc_ops = &lfsck_namespace_ops;
1479 com->lc_file_size = sizeof(struct lfsck_namespace);
1480 OBD_ALLOC(com->lc_file_ram, com->lc_file_size);
1481 if (com->lc_file_ram == NULL)
1482 GOTO(out, rc = -ENOMEM);
1484 OBD_ALLOC(com->lc_file_disk, com->lc_file_size);
1485 if (com->lc_file_disk == NULL)
1486 GOTO(out, rc = -ENOMEM);
1488 obj = local_index_find_or_create(env, lfsck->li_los,
1489 lfsck->li_local_root,
1490 lfsck_namespace_name,
1491 S_IFREG | S_IRUGO | S_IWUSR,
1492 &dt_lfsck_features);
1494 GOTO(out, rc = PTR_ERR(obj));
1497 rc = obj->do_ops->do_index_try(env, obj, &dt_lfsck_features);
1501 rc = lfsck_namespace_load(env, com);
1503 rc = lfsck_namespace_reset(env, com, true);
1504 else if (rc == -ENODATA)
1505 rc = lfsck_namespace_init(env, com);
1509 ns = (struct lfsck_namespace *)com->lc_file_ram;
1510 switch (ns->ln_status) {
1515 cfs_list_add_tail(&com->lc_link, &lfsck->li_list_idle);
1518 CERROR("%s: unknown status: %u\n",
1519 lfsck_lfsck2name(lfsck), ns->ln_status);
1521 case LS_SCANNING_PHASE1:
1522 case LS_SCANNING_PHASE2:
1523 /* No need to store the status to disk right now.
1524 * If the system crashed before the status stored,
1525 * it will be loaded back when next time. */
1526 ns->ln_status = LS_CRASHED;
1530 cfs_list_add_tail(&com->lc_link, &lfsck->li_list_scan);
1531 cfs_list_add_tail(&com->lc_link_dir, &lfsck->li_list_dir);
1539 lfsck_component_cleanup(env, com);