struct lfsck_instance *lfsck = com->lc_lfsck;
struct lfsck_namespace *ns = com->lc_file_ram;
struct lfsck_assistant_data *lad = com->lc_data;
+ struct dt_device *dev = lfsck_obj2dev(obj);
cfs_bitmap_t *bitmap = NULL;
struct thandle *handle;
__u32 nbits = 0;
ns->ln_bitmap_size = nbits;
lfsck_namespace_cpu_to_le((struct lfsck_namespace *)com->lc_file_disk,
ns);
- handle = dt_trans_create(env, lfsck->li_bottom);
+ handle = dt_trans_create(env, dev);
if (IS_ERR(handle))
GOTO(log, rc = PTR_ERR(handle));
}
#endif
- rc = dt_trans_start_local(env, lfsck->li_bottom, handle);
+ rc = dt_trans_start_local(env, dev, handle);
if (rc != 0)
GOTO(out, rc);
GOTO(out, rc);
out:
- dt_trans_stop(env, lfsck->li_bottom, handle);
+ dt_trans_stop(env, dev, handle);
log:
if (rc != 0)
lfsck_namespace_load_one_trace_file(const struct lu_env *env,
struct lfsck_component *com,
struct dt_object *parent,
- const char *name,
- const struct dt_index_features *ft,
- bool reset)
+ const char *name, bool reset)
{
struct lfsck_instance *lfsck = com->lc_lfsck;
struct dt_object *obj;
return ERR_PTR(rc);
}
- if (ft != NULL)
- obj = local_index_find_or_create(env, lfsck->li_los, parent,
- name, S_IFREG | S_IRUGO | S_IWUSR, ft);
- else
- obj = local_file_find_or_create(env, lfsck->li_los, parent,
- name, S_IFREG | S_IRUGO | S_IWUSR);
+ obj = local_index_find_or_create(env, lfsck->li_los, parent, name,
+ S_IFREG | S_IRUGO | S_IWUSR,
+ &dt_lfsck_features);
return obj;
}
if (!reset)
continue;
- lu_object_put(env, &lsto->lsto_obj->do_lu);
+ lfsck_object_put(env, lsto->lsto_obj);
lsto->lsto_obj = NULL;
}
obj = lfsck_namespace_load_one_trace_file(env, com,
- com->lc_lfsck->li_lfsck_dir,
- name, &dt_lfsck_features, reset);
+ com->lc_lfsck->li_lfsck_dir, name, reset);
if (IS_ERR(obj))
return PTR_ERR(obj);
struct lfsck_instance *lfsck = com->lc_lfsck;
struct dt_object *obj;
struct lu_fid *key = &lfsck_env_info(env)->lti_fid3;
- struct dt_device *dev = lfsck->li_bottom;
+ struct dt_device *dev;
struct thandle *th = NULL;
int idx;
int rc = 0;
idx = lfsck_sub_trace_file_fid2idx(fid);
obj = com->lc_sub_trace_objs[idx].lsto_obj;
+ dev = lfsck_obj2dev(obj);
mutex_lock(&com->lc_sub_trace_objs[idx].lsto_mutex);
fid_cpu_to_be(key, fid);
rc = dt_lookup(env, obj, (struct dt_rec *)&old,
struct dt_object *obj)
{
struct lfsck_instance *lfsck = com->lc_lfsck;
- struct dt_device *dev = lfsck->li_bottom;
+ struct dt_device *dev = lfsck_obj2dev(obj);
struct thandle *th = NULL;
int rc = 0;
ENTRY;
const struct lu_fid *pfid;
struct lu_fid tfid;
struct lfsck_instance *lfsck = com->lc_lfsck;
- struct dt_device *dev = lfsck->li_bottom;
+ struct dt_device *dev = lfsck_obj2dev(orphan);
struct dt_object *parent;
struct thandle *th = NULL;
- struct lustre_handle plh = { 0 };
+ struct lfsck_lock_handle *pllh = &info->lti_llh;
struct lustre_handle clh = { 0 };
struct linkea_data ldata = { NULL };
struct lu_buf linkea_buf;
parent = lfsck->li_lpf_obj;
pfid = lfsck_dto2fid(parent);
- /* Hold update lock on the parent to prevent others to access. */
- rc = lfsck_ibits_lock(env, lfsck, parent, &plh,
- MDS_INODELOCK_UPDATE, LCK_EX);
- if (rc != 0)
- GOTO(log, rc);
-
+again:
do {
namelen = snprintf(info->lti_key, NAME_MAX, DFID"%s-%s-%d",
PFID(cfid), infix, type, idx++);
exist = true;
} while (rc == 0 && !exist);
+ rc = lfsck_lock(env, lfsck, parent, info->lti_key, pllh,
+ MDS_INODELOCK_UPDATE, LCK_PW);
+ if (rc != 0)
+ GOTO(log, rc);
+
+ /* Re-check whether the name conflict with othrs after taken
+ * the ldlm lock. */
+ rc = dt_lookup(env, parent, (struct dt_rec *)&tfid,
+ (const struct dt_key *)info->lti_key, BYPASS_CAPA);
+ if (rc == 0) {
+ if (!lu_fid_eq(cfid, &tfid)) {
+ exist = false;
+ lfsck_unlock(pllh);
+ goto again;
+ }
+
+ exist = true;
+ } else if (rc != -ENOENT) {
+ GOTO(log, rc);
+ } else {
+ exist = false;
+ }
+
cname->ln_name = info->lti_key;
cname->ln_namelen = namelen;
rc = linkea_data_new(&ldata, &info->lti_linkea_buf2);
GOTO(log, rc);
rc = lfsck_ibits_lock(env, lfsck, orphan, &clh,
- MDS_INODELOCK_UPDATE | MDS_INODELOCK_LOOKUP,
- LCK_EX);
+ MDS_INODELOCK_UPDATE | MDS_INODELOCK_LOOKUP |
+ MDS_INODELOCK_XATTR, LCK_EX);
if (rc != 0)
GOTO(log, rc);
log:
lfsck_ibits_unlock(&clh, LCK_EX);
- lfsck_ibits_unlock(&plh, LCK_EX);
+ lfsck_unlock(pllh);
CDEBUG(D_LFSCK, "%s: namespace LFSCK insert orphan for the "
"object "DFID", name = %s: rc = %d\n",
lfsck_lfsck2name(lfsck), PFID(cfid),
struct lu_attr *la = &info->lti_la;
struct dt_insert_rec *rec = &info->lti_dt_rec;
struct lfsck_instance *lfsck = com->lc_lfsck;
+ /* The child and its name may be on different MDTs. */
struct dt_device *dev = lfsck->li_next;
+ struct dt_object *pobj = NULL;
+ struct dt_object *cobj = NULL;
struct thandle *th = NULL;
- struct lustre_handle lh = { 0 };
+ struct lfsck_lock_handle *llh = &info->lti_llh;
int rc = 0;
ENTRY;
- if (unlikely(!dt_try_as_dir(env, parent)))
+ /* @parent/@child may be based on lfsck->li_bottom,
+ * but here we need the object based on the lfsck->li_next. */
+
+ pobj = lfsck_object_locate(dev, parent);
+ if (IS_ERR(pobj))
+ GOTO(log, rc = PTR_ERR(pobj));
+
+ if (unlikely(!dt_try_as_dir(env, pobj)))
GOTO(log, rc = -ENOTDIR);
+ cobj = lfsck_object_locate(dev, child);
+ if (IS_ERR(cobj))
+ GOTO(log, rc = PTR_ERR(cobj));
+
if (lfsck->li_bookmark_ram.lb_param & LPF_DRYRUN)
GOTO(log, rc = 1);
- /* Hold update lock on the parent to prevent others to access. */
- rc = lfsck_ibits_lock(env, lfsck, parent, &lh,
- MDS_INODELOCK_UPDATE, LCK_EX);
+ rc = lfsck_lock(env, lfsck, parent, name, llh,
+ MDS_INODELOCK_UPDATE, LCK_PW);
if (rc != 0)
GOTO(log, rc);
if (IS_ERR(th))
GOTO(unlock, rc = PTR_ERR(th));
- rec->rec_type = lfsck_object_type(child) & S_IFMT;
- rec->rec_fid = lfsck_dto2fid(child);
- rc = dt_declare_insert(env, parent, (const struct dt_rec *)rec,
+ rec->rec_type = lfsck_object_type(cobj) & S_IFMT;
+ rec->rec_fid = lfsck_dto2fid(cobj);
+ rc = dt_declare_insert(env, pobj, (const struct dt_rec *)rec,
(const struct dt_key *)name, th);
if (rc != 0)
GOTO(stop, rc);
if (S_ISDIR(rec->rec_type)) {
- rc = dt_declare_ref_add(env, parent, th);
+ rc = dt_declare_ref_add(env, pobj, th);
if (rc != 0)
GOTO(stop, rc);
}
memset(la, 0, sizeof(*la));
la->la_ctime = cfs_time_current_sec();
la->la_valid = LA_CTIME;
- rc = dt_declare_attr_set(env, parent, la, th);
+ rc = dt_declare_attr_set(env, pobj, la, th);
if (rc != 0)
GOTO(stop, rc);
- rc = dt_declare_attr_set(env, child, la, th);
+ rc = dt_declare_attr_set(env, cobj, la, th);
if (rc != 0)
GOTO(stop, rc);
if (rc != 0)
GOTO(stop, rc);
- rc = dt_insert(env, parent, (const struct dt_rec *)rec,
+ rc = dt_insert(env, pobj, (const struct dt_rec *)rec,
(const struct dt_key *)name, th, BYPASS_CAPA, 1);
if (rc != 0)
GOTO(stop, rc);
if (S_ISDIR(rec->rec_type)) {
- dt_write_lock(env, parent, 0);
- rc = dt_ref_add(env, parent, th);
- dt_write_unlock(env, parent);
+ dt_write_lock(env, pobj, 0);
+ rc = dt_ref_add(env, pobj, th);
+ dt_write_unlock(env, pobj);
if (rc != 0)
GOTO(stop, rc);
}
la->la_ctime = cfs_time_current_sec();
- rc = dt_attr_set(env, parent, la, th, BYPASS_CAPA);
+ rc = dt_attr_set(env, pobj, la, th, BYPASS_CAPA);
if (rc != 0)
GOTO(stop, rc);
- rc = dt_attr_set(env, child, la, th, BYPASS_CAPA);
+ rc = dt_attr_set(env, cobj, la, th, BYPASS_CAPA);
GOTO(stop, rc = (rc == 0 ? 1 : rc));
dt_trans_stop(env, dev, th);
unlock:
- lfsck_ibits_unlock(&lh, LCK_EX);
+ lfsck_unlock(llh);
log:
CDEBUG(D_LFSCK, "%s: namespace LFSCK insert object "DFID" with "
struct lu_fid tfid;
struct lfsck_instance *lfsck = com->lc_lfsck;
struct lfsck_namespace *ns = com->lc_file_ram;
- struct dt_device *dev;
+ struct dt_device *dev = lfsck_obj2dev(orphan);
struct dt_object *parent = NULL;
- struct dt_object *child = NULL;
struct thandle *th = NULL;
- struct lustre_handle lh = { 0 };
+ struct lfsck_lock_handle *llh = &info->lti_llh;
struct linkea_data ldata = { NULL };
struct lu_buf linkea_buf;
struct lu_buf lmv_buf;
if (IS_ERR(dev))
GOTO(log, rc = PTR_ERR(dev));
- child = lfsck_object_find_by_dev(env, dev, cfid);
- if (IS_ERR(child))
- GOTO(log, rc = PTR_ERR(child));
-
- /* Hold update lock on the parent to prevent others to access. */
- rc = lfsck_ibits_lock(env, lfsck, parent, &lh,
- MDS_INODELOCK_UPDATE, LCK_EX);
- if (rc != 0)
- GOTO(log, rc);
-
idx = 0;
+
+again:
do {
namelen = snprintf(name, 31, DFID"-P-%d",
PFID(cfid), idx++);
rc = dt_lookup(env, parent, (struct dt_rec *)&tfid,
(const struct dt_key *)name, BYPASS_CAPA);
if (rc != 0 && rc != -ENOENT)
- GOTO(unlock1, rc);
+ GOTO(log, rc);
} while (rc == 0);
+ rc = lfsck_lock(env, lfsck, parent, name, llh,
+ MDS_INODELOCK_UPDATE, LCK_PW);
+ if (rc != 0)
+ GOTO(log, rc);
+
+ /* Re-check whether the name conflict with othrs after taken
+ * the ldlm lock. */
+ rc = dt_lookup(env, parent, (struct dt_rec *)&tfid,
+ (const struct dt_key *)name, BYPASS_CAPA);
+ if (unlikely(rc == 0)) {
+ lfsck_unlock(llh);
+ goto again;
+ }
+
+ if (rc != -ENOENT)
+ GOTO(unlock1, rc);
+
cname->ln_name = name;
cname->ln_namelen = namelen;
la->la_valid = LA_TYPE | LA_MODE | LA_UID | LA_GID |
LA_ATIME | LA_MTIME | LA_CTIME;
- child->do_ops->do_ah_init(env, hint, parent, child,
- la->la_mode & S_IFMT);
+ orphan->do_ops->do_ah_init(env, hint, parent, orphan,
+ la->la_mode & S_IFMT);
memset(dof, 0, sizeof(*dof));
dof->dof_type = dt_mode_to_dft(S_IFDIR);
if (dt_object_remote(orphan))
th->th_sync = 1;
- rc = dt_declare_create(env, child, la, hint, dof, th);
+ rc = dt_declare_create(env, orphan, la, hint, dof, th);
if (rc != 0)
GOTO(stop, rc);
- if (unlikely(!dt_try_as_dir(env, child)))
+ if (unlikely(!dt_try_as_dir(env, orphan)))
GOTO(stop, rc = -ENOTDIR);
rec->rec_type = S_IFDIR;
rec->rec_fid = cfid;
- rc = dt_declare_insert(env, child, (const struct dt_rec *)rec,
+ rc = dt_declare_insert(env, orphan, (const struct dt_rec *)rec,
(const struct dt_key *)dot, th);
if (rc != 0)
GOTO(stop, rc);
rec->rec_fid = lfsck_dto2fid(parent);
- rc = dt_declare_insert(env, child, (const struct dt_rec *)rec,
+ rc = dt_declare_insert(env, orphan, (const struct dt_rec *)rec,
(const struct dt_key *)dotdot, th);
if (rc == 0)
- rc = dt_declare_ref_add(env, child, th);
+ rc = dt_declare_ref_add(env, orphan, th);
if (rc != 0)
GOTO(stop, rc);
- rc = dt_declare_ref_add(env, child, th);
+ rc = dt_declare_ref_add(env, orphan, th);
if (rc != 0)
GOTO(stop, rc);
if (lmv != NULL) {
lmv->lmv_magic = LMV_MAGIC;
- lmv->lmv_master_mdt_index = lfsck_dev_idx(dev);
+ lmv->lmv_master_mdt_index = lfsck_dev_idx(lfsck);
lfsck_lmv_header_cpu_to_le(lmv2, lmv);
lfsck_buf_init(&lmv_buf, lmv2, sizeof(*lmv2));
- rc = dt_declare_xattr_set(env, child, &lmv_buf,
+ rc = dt_declare_xattr_set(env, orphan, &lmv_buf,
XATTR_NAME_LMV, 0, th);
if (rc != 0)
GOTO(stop, rc);
lfsck_buf_init(&linkea_buf, ldata.ld_buf->lb_buf,
ldata.ld_leh->leh_len);
- rc = dt_declare_xattr_set(env, child, &linkea_buf,
+ rc = dt_declare_xattr_set(env, orphan, &linkea_buf,
XATTR_NAME_LINK, 0, th);
if (rc != 0)
GOTO(stop, rc);
if (rc != 0)
GOTO(stop, rc);
- dt_write_lock(env, child, 0);
- rc = dt_create(env, child, la, hint, dof, th);
+ dt_write_lock(env, orphan, 0);
+ rc = dt_create(env, orphan, la, hint, dof, th);
if (rc != 0)
GOTO(unlock2, rc);
rec->rec_fid = cfid;
- rc = dt_insert(env, child, (const struct dt_rec *)rec,
+ rc = dt_insert(env, orphan, (const struct dt_rec *)rec,
(const struct dt_key *)dot, th, BYPASS_CAPA, 1);
if (rc != 0)
GOTO(unlock2, rc);
rec->rec_fid = lfsck_dto2fid(parent);
- rc = dt_insert(env, child, (const struct dt_rec *)rec,
+ rc = dt_insert(env, orphan, (const struct dt_rec *)rec,
(const struct dt_key *)dotdot, th,
BYPASS_CAPA, 1);
if (rc != 0)
GOTO(unlock2, rc);
- rc = dt_ref_add(env, child, th);
+ rc = dt_ref_add(env, orphan, th);
if (rc != 0)
GOTO(unlock2, rc);
if (lmv != NULL) {
- rc = dt_xattr_set(env, child, &lmv_buf, XATTR_NAME_LMV, 0,
+ rc = dt_xattr_set(env, orphan, &lmv_buf, XATTR_NAME_LMV, 0,
th, BYPASS_CAPA);
if (rc != 0)
GOTO(unlock2, rc);
}
- rc = dt_xattr_set(env, child, &linkea_buf,
+ rc = dt_xattr_set(env, orphan, &linkea_buf,
XATTR_NAME_LINK, 0, th, BYPASS_CAPA);
- dt_write_unlock(env, child);
+ dt_write_unlock(env, orphan);
if (rc != 0)
GOTO(stop, rc);
GOTO(stop, rc = (rc == 0 ? 1 : rc));
unlock2:
- dt_write_unlock(env, child);
+ dt_write_unlock(env, orphan);
stop:
dt_trans_stop(env, dev, th);
unlock1:
- lfsck_ibits_unlock(&lh, LCK_EX);
+ lfsck_unlock(llh);
log:
CDEBUG(D_LFSCK, "%s: namespace LFSCK create orphan dir for "
lfsck_lfsck2name(lfsck), PFID(cfid),
cname->ln_name != NULL ? cname->ln_name : "<NULL>", rc);
- if (child != NULL && !IS_ERR(child))
- lfsck_object_put(env, child);
-
if (parent != NULL && !IS_ERR(parent) && parent != lfsck->li_lpf_obj)
lfsck_object_put(env, parent);
bool next)
{
struct lfsck_instance *lfsck = com->lc_lfsck;
- struct dt_device *dev = lfsck->li_bottom;
+ struct dt_device *dev = lfsck_obj2dev(obj);
struct lfsck_bookmark *bk = &lfsck->li_bookmark_ram;
struct thandle *th = NULL;
struct lustre_handle lh = { 0 };
ENTRY;
rc = lfsck_ibits_lock(env, lfsck, obj, &lh,
- MDS_INODELOCK_UPDATE |
- MDS_INODELOCK_XATTR, LCK_EX);
+ MDS_INODELOCK_UPDATE | MDS_INODELOCK_XATTR,
+ LCK_EX);
if (rc != 0)
GOTO(log, rc);
struct lu_name *cname,
struct lu_fid *pfid)
{
- struct lu_fid *cfid = &lfsck_env_info(env)->lti_fid3;
- struct lustre_handle lh = { 0 };
- int rc;
+ struct lfsck_thread_info *info = lfsck_env_info(env);
+ struct lu_fid *cfid = &info->lti_fid3;
+ struct lfsck_lock_handle *llh = &info->lti_llh;
+ int rc;
ENTRY;
- rc = lfsck_ibits_lock(env, com->lc_lfsck, parent, &lh,
- MDS_INODELOCK_UPDATE, LCK_EX);
+ rc = lfsck_lock(env, com->lc_lfsck, parent, cname->ln_name, llh,
+ MDS_INODELOCK_UPDATE, LCK_PR);
if (rc != 0)
RETURN(rc);
dt_read_lock(env, parent, 0);
if (unlikely(lfsck_is_dead_obj(parent))) {
dt_read_unlock(env, parent);
- lfsck_ibits_unlock(&lh, LCK_EX);
+ lfsck_unlock(llh);
rc = lfsck_namespace_shrink_linkea(env, com, child, ldata,
cname, pfid, true);
* has removed the specified linkEA entry by race, then it is OK,
* because the subsequent lfsck_namespace_shrink_linkea() can handle
* such case. */
- lfsck_ibits_unlock(&lh, LCK_EX);
+ lfsck_unlock(llh);
if (rc == -ENOENT) {
rc = lfsck_namespace_shrink_linkea(env, com, child, ldata,
cname, pfid, true);
struct dt_insert_rec *rec = &info->lti_dt_rec;
struct lu_fid tfid;
struct lfsck_instance *lfsck = com->lc_lfsck;
+ /* The child and its name may be on different MDTs. */
struct dt_device *dev = lfsck->li_next;
const char *name = cname->ln_name;
- struct dt_object *obj = NULL;
- struct lustre_handle plh = { 0 };
+ struct dt_object *pobj = NULL;
+ struct dt_object *cobj = NULL;
+ struct lfsck_lock_handle *pllh = &info->lti_llh;
struct lustre_handle clh = { 0 };
struct linkea_data ldata = { NULL };
struct thandle *th = NULL;
int rc = 0;
ENTRY;
- rc = lfsck_ibits_lock(env, lfsck, parent, &plh,
- MDS_INODELOCK_UPDATE, LCK_EX);
+ /* @parent/@child may be based on lfsck->li_bottom,
+ * but here we need the object based on the lfsck->li_next. */
+
+ pobj = lfsck_object_locate(dev, parent);
+ if (IS_ERR(pobj))
+ GOTO(log, rc = PTR_ERR(pobj));
+
+ if (unlikely(!dt_try_as_dir(env, pobj)))
+ GOTO(log, rc = -ENOTDIR);
+
+ rc = lfsck_lock(env, lfsck, parent, name, pllh,
+ MDS_INODELOCK_UPDATE, LCK_PW);
if (rc != 0)
GOTO(log, rc);
goto replace;
}
- obj = lfsck_object_find(env, lfsck, cfid);
- if (IS_ERR(obj)) {
- rc = PTR_ERR(obj);
+ cobj = lfsck_object_find_by_dev(env, dev, cfid);
+ if (IS_ERR(cobj)) {
+ rc = PTR_ERR(cobj);
if (rc == -ENOENT) {
exist = false;
goto replace;
GOTO(log, rc);
}
- if (!dt_object_exists(obj)) {
+ if (!dt_object_exists(cobj)) {
exist = false;
goto replace;
}
- rc = dt_lookup(env, parent, (struct dt_rec *)&tfid,
+ rc = dt_lookup(env, pobj, (struct dt_rec *)&tfid,
(const struct dt_key *)name, BYPASS_CAPA);
if (rc == -ENOENT) {
exist = false;
GOTO(log, rc = 0);
/* lock the object to be destroyed. */
- rc = lfsck_ibits_lock(env, lfsck, obj, &clh,
+ rc = lfsck_ibits_lock(env, lfsck, cobj, &clh,
MDS_INODELOCK_UPDATE |
- MDS_INODELOCK_XATTR, LCK_EX);
+ MDS_INODELOCK_UPDATE | MDS_INODELOCK_XATTR,
+ LCK_EX);
if (rc != 0)
GOTO(log, rc);
- if (unlikely(lfsck_is_dead_obj(obj))) {
+ if (unlikely(lfsck_is_dead_obj(cobj))) {
exist = false;
goto replace;
}
- rc = dt_attr_get(env, obj, la, BYPASS_CAPA);
+ rc = dt_attr_get(env, cobj, la, BYPASS_CAPA);
if (rc != 0)
GOTO(log, rc);
GOTO(log, rc);
if (S_ISREG(la->la_mode)) {
- rc = dt_xattr_get(env, obj, &LU_BUF_NULL, XATTR_NAME_LOV,
+ rc = dt_xattr_get(env, cobj, &LU_BUF_NULL, XATTR_NAME_LOV,
BYPASS_CAPA);
/* If someone has created related OST-object(s),
* then keep it. */
if (rc != 0)
GOTO(log, rc);
- rc = linkea_links_find(&ldata, cname, lfsck_dto2fid(parent));
+ rc = linkea_links_find(&ldata, cname, lfsck_dto2fid(pobj));
/* Someone moved the child, no need to replace. */
if (rc != 0)
GOTO(log, rc = 0);
GOTO(log, rc = PTR_ERR(th));
if (exist) {
- rc = dt_declare_destroy(env, obj, th);
+ rc = dt_declare_destroy(env, cobj, th);
if (rc != 0)
GOTO(stop, rc);
}
- rc = dt_declare_delete(env, parent, (const struct dt_key *)name, th);
+ rc = dt_declare_delete(env, pobj, (const struct dt_key *)name, th);
if (rc != 0)
GOTO(stop, rc);
rec->rec_type = S_IFDIR;
rec->rec_fid = lfsck_dto2fid(child);
- rc = dt_declare_insert(env, parent, (const struct dt_rec *)rec,
+ rc = dt_declare_insert(env, pobj, (const struct dt_rec *)rec,
(const struct dt_key *)name, th);
if (rc != 0)
GOTO(stop, rc);
- rc = dt_trans_start(env, dev, th);
+ rc = dt_trans_start_local(env, dev, th);
if (rc != 0)
GOTO(stop, rc);
if (exist) {
- rc = dt_destroy(env, obj, th);
+ rc = dt_destroy(env, cobj, th);
if (rc != 0)
GOTO(stop, rc);
}
/* The old name entry maybe not exist. */
- dt_delete(env, parent, (const struct dt_key *)name, th,
- BYPASS_CAPA);
+ rc = dt_delete(env, pobj, (const struct dt_key *)name, th, BYPASS_CAPA);
+ if (rc != 0 && rc != -ENOENT)
+ GOTO(stop, rc);
- rc = dt_insert(env, parent, (const struct dt_rec *)rec,
+ rc = dt_insert(env, pobj, (const struct dt_rec *)rec,
(const struct dt_key *)name, th, BYPASS_CAPA, 1);
GOTO(stop, rc = (rc == 0 ? 1 : rc));
log:
lfsck_ibits_unlock(&clh, LCK_EX);
- lfsck_ibits_unlock(&plh, LCK_EX);
- if (obj != NULL && !IS_ERR(obj))
- lfsck_object_put(env, obj);
+ lfsck_unlock(pllh);
+
+ if (cobj != NULL && !IS_ERR(cobj))
+ lfsck_object_put(env, cobj);
CDEBUG(D_LFSCK, "%s: namespace LFSCK conditionally destroy the "
"object "DFID" because of conflict with the object "DFID
struct linkea_data *ldata)
{
struct lfsck_instance *lfsck = com->lc_lfsck;
- struct dt_device *dev = lfsck->li_bottom;
+ struct dt_device *dev = lfsck_obj2dev(obj);
struct thandle *th = NULL;
struct lu_buf linkea_buf;
int rc = 0;
const char *name, const char *name2,
__u16 type, bool update, bool dec)
{
- struct dt_insert_rec *rec = &lfsck_env_info(env)->lti_dt_rec;
- const struct lu_fid *cfid = lfsck_dto2fid(child);
- struct lu_fid tfid;
- struct lfsck_instance *lfsck = com->lc_lfsck;
- struct dt_device *dev = lfsck->li_next;
- struct thandle *th = NULL;
- struct lustre_handle lh = { 0 };
- int rc = 0;
+ struct lfsck_thread_info *info = lfsck_env_info(env);
+ struct dt_insert_rec *rec = &info->lti_dt_rec;
+ const struct lu_fid *cfid = lfsck_dto2fid(child);
+ struct lu_fid tfid;
+ struct lfsck_instance *lfsck = com->lc_lfsck;
+ struct dt_device *dev = lfsck->li_next;
+ struct thandle *th = NULL;
+ struct lfsck_lock_handle *llh = &info->lti_llh;
+ struct lustre_handle lh = { 0 };
+ int rc = 0;
ENTRY;
if (unlikely(!dt_try_as_dir(env, parent)))
GOTO(log, rc = -ENOTDIR);
- rc = lfsck_ibits_lock(env, lfsck, parent, &lh,
- MDS_INODELOCK_UPDATE, LCK_EX);
+ if (!update || strcmp(name, name2) == 0)
+ rc = lfsck_lock(env, lfsck, parent, name, llh,
+ MDS_INODELOCK_UPDATE, LCK_PW);
+ else
+ rc = lfsck_ibits_lock(env, lfsck, parent, &lh,
+ MDS_INODELOCK_UPDATE, LCK_PW);
if (rc != 0)
GOTO(log, rc);
GOTO(stop, rc);
}
- rc = dt_trans_start(env, dev, th);
+ rc = dt_trans_start_local(env, dev, th);
if (rc != 0)
GOTO(stop, rc);
LNTF_CHECK_LINKEA, true);
unlock1:
- lfsck_ibits_unlock(&lh, LCK_EX);
+ /* It is harmless even if unlock the unused lock_handle */
+ lfsck_ibits_unlock(&lh, LCK_PW);
+ lfsck_unlock(llh);
log:
CDEBUG(D_LFSCK, "%s: namespace LFSCK assistant found bad name "
struct lfsck_thread_info *info = lfsck_env_info(env);
struct dt_insert_rec *rec = &info->lti_dt_rec;
struct lfsck_instance *lfsck = com->lc_lfsck;
- struct dt_device *dev = lfsck->li_bottom;
+ struct dt_device *dev = lfsck_obj2dev(obj);
struct thandle *th = NULL;
struct linkea_data ldata = { NULL };
struct lu_buf linkea_buf;
struct lu_fid *tfid = &info->lti_fid3;
struct lfsck_namespace *ns = com->lc_file_ram;
struct lfsck_instance *lfsck = com->lc_lfsck;
- struct dt_device *dev = lfsck->li_bottom;
+ struct dt_device *dev = lfsck_obj2dev(obj);
const struct lu_fid *cfid = lfsck_dto2fid(obj);
- struct dt_object *child = NULL;
struct thandle *th = NULL;
struct linkea_data ldata = { NULL };
struct lustre_handle lh = { 0 };
LASSERT(!dt_object_remote(obj));
LASSERT(S_ISREG(lfsck_object_type(obj)));
- child = lfsck_object_find_by_dev(env, dev, cfid);
- if (IS_ERR(child))
- GOTO(log, rc = PTR_ERR(child));
-
- rc = lfsck_ibits_lock(env, lfsck, child, &lh,
- MDS_INODELOCK_UPDATE |
- MDS_INODELOCK_XATTR, LCK_EX);
+ rc = lfsck_ibits_lock(env, lfsck, obj, &lh,
+ MDS_INODELOCK_UPDATE, LCK_PW);
if (rc != 0)
GOTO(log, rc);
GOTO(log, rc = PTR_ERR(th));
la->la_valid = LA_NLINK;
- rc = dt_declare_attr_set(env, child, la, th);
+ rc = dt_declare_attr_set(env, obj, la, th);
if (rc != 0)
GOTO(stop, rc);
if (rc != 0)
GOTO(stop, rc);
- dt_write_lock(env, child, 0);
+ dt_write_lock(env, obj, 0);
/* If the LFSCK is marked as LF_INCOMPLETE, then means some MDT has
* ever tried to verify some remote MDT-object that resides on this
* MDT, but this MDT failed to respond such request. So means there
if (flags & LNTF_SKIP_NLINK)
GOTO(unlock, rc = 0);
- rc = dt_attr_get(env, child, la, BYPASS_CAPA);
+ rc = dt_attr_get(env, obj, la, BYPASS_CAPA);
if (rc != 0)
GOTO(unlock, rc = (rc == -ENOENT ? 0 : rc));
- rc = lfsck_links_read2(env, child, &ldata);
+ rc = lfsck_links_read2(env, obj, &ldata);
if (rc != 0)
GOTO(unlock, rc = (rc == -ENODATA ? 0 : rc));
if (lfsck->li_bookmark_ram.lb_param & LPF_DRYRUN)
GOTO(unlock, rc = 1);
- rc = dt_attr_set(env, child, la, th, BYPASS_CAPA);
+ rc = dt_attr_set(env, obj, la, th, BYPASS_CAPA);
GOTO(unlock, rc = (rc == 0 ? 1 : rc));
unlock:
- dt_write_unlock(env, child);
+ dt_write_unlock(env, obj);
stop:
dt_trans_stop(env, dev, th);
log:
- lfsck_ibits_unlock(&lh, LCK_EX);
- if (child != NULL && !IS_ERR(child))
- lfsck_object_put(env, child);
-
+ lfsck_ibits_unlock(&lh, LCK_PW);
CDEBUG(D_LFSCK, "%s: namespace LFSCK repaired the object "DFID"'s "
"nlink count from %u to %u: rc = %d\n",
lfsck_lfsck2name(lfsck), PFID(cfid), old, la->la_nlink, rc);
lfsck_object_put(env, com->lc_obj);
com->lc_obj = NULL;
dto = lfsck_namespace_load_one_trace_file(env, com, root,
- LFSCK_NAMESPACE, NULL, true);
+ LFSCK_NAMESPACE, true);
if (IS_ERR(dto))
GOTO(out, rc = PTR_ERR(dto));
up_write(&com->lc_sem);
put:
- lu_object_put(env, &root->do_lu);
+ lfsck_object_put(env, root);
log:
CDEBUG(D_LFSCK, "%s: namespace LFSCK reset: rc = %d\n",
lfsck_lfsck2name(lfsck), rc);
if (llmv->ll_lmv_master) {
struct lmv_mds_md_v1 *lmv = &llmv->ll_lmv;
- if (lmv->lmv_master_mdt_index !=
- lfsck_dev_idx(lfsck->li_bottom)) {
+ if (lmv->lmv_master_mdt_index != lfsck_dev_idx(lfsck)) {
lmv->lmv_master_mdt_index =
- lfsck_dev_idx(lfsck->li_bottom);
+ lfsck_dev_idx(lfsck);
ns->ln_flags |= LF_INCONSISTENT;
llmv->ll_lmv_updated = 1;
}
struct lu_fid *pfid = &info->lti_fid2;
struct lu_name *cname = &info->lti_name;
struct lu_seq_range *range = &info->lti_range;
- struct dt_device *dev = lfsck->li_bottom;
- struct seq_server_site *ss =
- lu_site2seq(dev->dd_lu_dev.ld_site);
+ struct seq_server_site *ss = lfsck_dev_site(lfsck);
struct linkea_data ldata = { NULL };
- __u32 idx = lfsck_dev_idx(dev);
+ __u32 idx = lfsck_dev_idx(lfsck);
int rc;
ENTRY;
bool wakeup = false;
l_wait_event(mthread->t_ctl_waitq,
- bk->lb_async_windows == 0 ||
lad->lad_prefetched < bk->lb_async_windows ||
!thread_is_running(mthread) ||
thread_is_stopped(athread),
case LE_SET_LMV_MASTER: {
struct dt_object *obj;
- obj = lfsck_object_find_by_dev(env, lfsck->li_bottom,
- &lr->lr_fid);
+ obj = lfsck_object_find_bottom(env, lfsck, &lr->lr_fid);
if (IS_ERR(obj))
RETURN(PTR_ERR(obj));
struct dt_object_format *dof = &info->lti_dof;
struct dt_insert_rec *rec = &info->lti_dt_rec;
struct lmv_mds_md_v1 *lmv2 = &info->lti_lmv2;
+ struct dt_object *pobj = NULL;
+ struct dt_object *cobj = NULL;
const struct lu_name *cname;
struct linkea_data ldata = { NULL };
- struct lustre_handle lh = { 0 };
+ struct lfsck_lock_handle *llh = &info->lti_llh;
struct lu_buf linkea_buf;
struct lu_buf lmv_buf;
struct lfsck_instance *lfsck = com->lc_lfsck;
struct lfsck_bookmark *bk = &lfsck->li_bookmark_ram;
- struct dt_device *dev = lfsck_obj2dt_dev(child);
+ struct dt_device *dev = lfsck->li_next;
struct thandle *th = NULL;
int rc = 0;
__u16 type = lnr->lnr_type;
if (!create || bk->lb_param & LPF_DRYRUN)
GOTO(log, rc = 0);
+ /* We may need to create the sub-objects of the @child via LOD,
+ * so make the modification based on lfsck->li_next. */
+
+ pobj = lfsck_object_locate(dev, parent);
+ if (IS_ERR(pobj))
+ GOTO(log, rc = PTR_ERR(pobj));
+
+ if (unlikely(!dt_try_as_dir(env, pobj)))
+ GOTO(log, rc = -ENOTDIR);
+
+ cobj = lfsck_object_locate(dev, child);
+ if (IS_ERR(cobj))
+ GOTO(log, rc = PTR_ERR(cobj));
+
rc = linkea_data_new(&ldata, &info->lti_linkea_buf2);
if (rc != 0)
GOTO(log, rc);
- rc = linkea_add_buf(&ldata, cname, lfsck_dto2fid(parent));
+ rc = linkea_add_buf(&ldata, cname, lfsck_dto2fid(pobj));
if (rc != 0)
GOTO(log, rc);
- rc = lfsck_ibits_lock(env, lfsck, parent, &lh,
- MDS_INODELOCK_UPDATE, LCK_EX);
+ rc = lfsck_lock(env, lfsck, parent, lnr->lnr_name, llh,
+ MDS_INODELOCK_UPDATE, LCK_PR);
if (rc != 0)
GOTO(log, rc);
- rc = lfsck_namespace_check_exist(env, parent, child, lnr->lnr_name);
+ rc = lfsck_namespace_check_exist(env, pobj, cobj, lnr->lnr_name);
if (rc != 0)
GOTO(log, rc);
- th = dt_trans_create(env, dev);
- if (IS_ERR(th))
- GOTO(log, rc = PTR_ERR(th));
-
/* Set the ctime as zero, then others can know it is created for
* repairing dangling name entry by LFSCK. And if the LFSCK made
* wrong decision and the real MDT-object has been found later,
la->la_valid = LA_TYPE | LA_MODE | LA_UID | LA_GID |
LA_ATIME | LA_MTIME | LA_CTIME;
- child->do_ops->do_ah_init(env, hint, parent, child,
- la->la_mode & S_IFMT);
+ cobj->do_ops->do_ah_init(env, hint, pobj, cobj,
+ la->la_mode & S_IFMT);
memset(dof, 0, sizeof(*dof));
dof->dof_type = dt_mode_to_dft(type);
* the MDT-object without stripes (dof->dof_reg.striped = 0). related
* OST-objects will be created when write open. */
+ th = dt_trans_create(env, dev);
+ if (IS_ERR(th))
+ GOTO(log, rc = PTR_ERR(th));
+
/* 1a. create child. */
- rc = dt_declare_create(env, child, la, hint, dof, th);
+ rc = dt_declare_create(env, cobj, la, hint, dof, th);
if (rc != 0)
GOTO(stop, rc);
if (S_ISDIR(type)) {
- if (unlikely(!dt_try_as_dir(env, child)))
+ if (unlikely(!dt_try_as_dir(env, cobj)))
GOTO(stop, rc = -ENOTDIR);
/* 2a. insert dot into child dir */
rec->rec_type = S_IFDIR;
- rec->rec_fid = lfsck_dto2fid(child);
- rc = dt_declare_insert(env, child,
+ rec->rec_fid = lfsck_dto2fid(cobj);
+ rc = dt_declare_insert(env, cobj,
(const struct dt_rec *)rec,
(const struct dt_key *)dot, th);
if (rc != 0)
GOTO(stop, rc);
/* 3a. insert dotdot into child dir */
- rec->rec_fid = lfsck_dto2fid(parent);
- rc = dt_declare_insert(env, child,
+ rec->rec_fid = lfsck_dto2fid(pobj);
+ rc = dt_declare_insert(env, cobj,
(const struct dt_rec *)rec,
(const struct dt_key *)dotdot, th);
if (rc != 0)
GOTO(stop, rc);
/* 4a. increase child nlink */
- rc = dt_declare_ref_add(env, child, th);
+ rc = dt_declare_ref_add(env, cobj, th);
if (rc != 0)
GOTO(stop, rc);
idx = lfsck_shard_name_to_index(env,
lnr->lnr_name, lnr->lnr_namelen,
- type, lfsck_dto2fid(child));
+ type, lfsck_dto2fid(cobj));
if (unlikely(idx < 0))
GOTO(stop, rc = idx);
lfsck_lmv_header_cpu_to_le(lmv2, lmv2);
lfsck_buf_init(&lmv_buf, lmv2, sizeof(*lmv2));
- rc = dt_declare_xattr_set(env, child, &lmv_buf,
+ rc = dt_declare_xattr_set(env, cobj, &lmv_buf,
XATTR_NAME_LMV, 0, th);
if (rc != 0)
GOTO(stop, rc);
/* 6a. insert linkEA for child */
lfsck_buf_init(&linkea_buf, ldata.ld_buf->lb_buf,
ldata.ld_leh->leh_len);
- rc = dt_declare_xattr_set(env, child, &linkea_buf,
+ rc = dt_declare_xattr_set(env, cobj, &linkea_buf,
XATTR_NAME_LINK, 0, th);
if (rc != 0)
GOTO(stop, rc);
- rc = dt_trans_start(env, dev, th);
+ rc = dt_trans_start_local(env, dev, th);
if (rc != 0)
GOTO(stop, rc = (rc == -EEXIST ? 1 : rc));
- dt_write_lock(env, child, 0);
+ dt_write_lock(env, cobj, 0);
/* 1b. create child */
- rc = dt_create(env, child, la, hint, dof, th);
+ rc = dt_create(env, cobj, la, hint, dof, th);
if (rc != 0)
GOTO(unlock, rc = (rc == -EEXIST ? 1 : rc));
if (S_ISDIR(type)) {
- if (unlikely(!dt_try_as_dir(env, child)))
- GOTO(unlock, rc = -ENOTDIR);
-
/* 2b. insert dot into child dir */
rec->rec_type = S_IFDIR;
- rec->rec_fid = lfsck_dto2fid(child);
- rc = dt_insert(env, child, (const struct dt_rec *)rec,
+ rec->rec_fid = lfsck_dto2fid(cobj);
+ rc = dt_insert(env, cobj, (const struct dt_rec *)rec,
(const struct dt_key *)dot, th, BYPASS_CAPA, 1);
if (rc != 0)
GOTO(unlock, rc);
/* 3b. insert dotdot into child dir */
- rec->rec_fid = lfsck_dto2fid(parent);
- rc = dt_insert(env, child, (const struct dt_rec *)rec,
+ rec->rec_fid = lfsck_dto2fid(pobj);
+ rc = dt_insert(env, cobj, (const struct dt_rec *)rec,
(const struct dt_key *)dotdot, th,
BYPASS_CAPA, 1);
if (rc != 0)
GOTO(unlock, rc);
/* 4b. increase child nlink */
- rc = dt_ref_add(env, child, th);
+ rc = dt_ref_add(env, cobj, th);
if (rc != 0)
GOTO(unlock, rc);
/* 5b. generate slave LMV EA. */
if (lnr->lnr_lmv != NULL && lnr->lnr_lmv->ll_lmv_master) {
- rc = dt_xattr_set(env, child, &lmv_buf, XATTR_NAME_LMV,
+ rc = dt_xattr_set(env, cobj, &lmv_buf, XATTR_NAME_LMV,
0, th, BYPASS_CAPA);
if (rc != 0)
GOTO(unlock, rc);
}
/* 6b. insert linkEA for child. */
- rc = dt_xattr_set(env, child, &linkea_buf,
+ rc = dt_xattr_set(env, cobj, &linkea_buf,
XATTR_NAME_LINK, 0, th, BYPASS_CAPA);
GOTO(unlock, rc);
unlock:
- dt_write_unlock(env, child);
+ dt_write_unlock(env, cobj);
stop:
dt_trans_stop(env, dev, th);
log:
- lfsck_ibits_unlock(&lh, LCK_EX);
+ lfsck_unlock(llh);
CDEBUG(D_LFSCK, "%s: namespace LFSCK assistant found dangling "
"reference for: parent "DFID", child "DFID", type %u, "
"name %s. %s: rc = %d\n", lfsck_lfsck2name(lfsck),
- PFID(lfsck_dto2fid(parent)), PFID(lfsck_dto2fid(child)),
+ PFID(&lnr->lnr_lar.lar_fid), PFID(lfsck_dto2fid(child)),
type, cname->ln_name,
create ? "Create the lost OST-object as required" :
"Keep the MDT-object there by default", rc);
if (unlikely(lfsck_is_dead_obj(dir)))
GOTO(put_dir, rc = 0);
+ if (unlikely(!dt_try_as_dir(env, dir)))
+ GOTO(put_dir, rc = -ENOTDIR);
+
pfid = lfsck_dto2fid(dir);
la->la_nlink = 0;
if (lnr->lnr_attr & LUDA_UPGRADE) {
GOTO(put_dir, rc);
}
- if (lnr->lnr_name[0] == '.' &&
- (lnr->lnr_namelen == 1 || fid_seq_is_dot(fid_seq(&lnr->lnr_fid))))
+ if (fid_seq_is_dot(fid_seq(&lnr->lnr_fid)))
GOTO(out, rc = 0);
if (lnr->lnr_lmv != NULL && lnr->lnr_lmv->ll_lmv_master) {
if (idx < 0)
GOTO(out, rc = idx);
- if (idx == lfsck_dev_idx(lfsck->li_bottom)) {
+ if (idx == lfsck_dev_idx(lfsck)) {
if (unlikely(strcmp(lnr->lnr_name, dotdot) == 0))
GOTO(out, rc = 0);
if (rc != 0)
GOTO(stop, rc);
- rc = dt_trans_start(env, dev, handle);
+ rc = dt_trans_start_local(env, dev, handle);
if (rc != 0)
GOTO(stop, rc);
if ((rc == -ENOTCONN || rc == -ESHUTDOWN || rc == -EREMCHG ||
rc == -ETIMEDOUT || rc == -EHOSTDOWN ||
rc == -EHOSTUNREACH || rc == -EINPROGRESS) &&
- dev != NULL && dev != lfsck->li_next)
+ dev != NULL && dev != lfsck->li_bottom)
lfsck_lad_set_bitmap(env, com, idx);
if (!(bk->lb_param & LPF_FAILOUT))
lfsck_object_put(env, obj);
put_dir:
- lu_object_put(env, &dir->do_lu);
+ lfsck_object_put(env, dir);
return rc;
}
dt_trans_stop(env, dev, th);
out:
- lu_object_put(env, &child->do_lu);
+ lfsck_object_put(env, child);
return rc;
}
struct lfsck_instance *lfsck = com->lc_lfsck;
struct ptlrpc_thread *thread = &lfsck->li_thread;
struct lfsck_bookmark *bk = &lfsck->li_bookmark_ram;
- struct dt_device *dev = lfsck->li_bottom;
struct lfsck_namespace *ns = com->lc_file_ram;
struct dt_object *parent;
const struct dt_it_ops *iops;
struct dt_it *di;
- struct seq_server_site *ss =
- lu_site2seq(dev->dd_lu_dev.ld_site);
+ struct seq_server_site *ss = lfsck_dev_site(lfsck);
__u64 cookie;
+ __u32 idx = lfsck_dev_idx(lfsck);
int rc = 0;
__u16 type;
ENTRY;
- parent = lfsck_object_find_by_dev(env, dev, &LU_BACKEND_LPF_FID);
+ parent = lfsck_object_find_by_dev(env, lfsck->li_bottom,
+ &LU_BACKEND_LPF_FID);
if (IS_ERR(parent)) {
CERROR("%s: fail to find backend /lost+found: rc = %ld\n",
lfsck_lfsck2name(lfsck), PTR_ERR(parent));
fid_seq(&ent->lde_fid), range);
if (rc != 0)
goto skip;
- } else if (lfsck_dev_idx(dev) != 0) {
+ } else if (idx != 0) {
/* If the returned FID is IGIF, then there are three
* possible cases:
*
"in the backend /lost+found on the MDT %04x, "
"to be safe, skip it.\n",
lfsck_lfsck2name(lfsck), ent->lde_namelen,
- ent->lde_name, PFID(&ent->lde_fid),
- lfsck_dev_idx(dev));
+ ent->lde_name, PFID(&ent->lde_fid), idx);
goto skip;
}
CDEBUG(D_LFSCK, "%s: stop to scan backend /lost+found: rc = %d\n",
lfsck_lfsck2name(lfsck), rc);
- lu_object_put(env, &parent->do_lu);
+ lfsck_object_put(env, parent);
}
/**
goto checkpoint;
}
- target = lfsck_object_find_by_dev(env, lfsck->li_bottom, &fid);
+ target = lfsck_object_find_bottom(env, lfsck, &fid);
if (IS_ERR(target)) {
rc = PTR_ERR(target);
goto checkpoint;
* entries, then re-generate the linkEA with the given information.
*
* \param[in] env pointer to the thread context
- * \param[in] dev pointer to the dt_device
* \param[in] obj pointer to the dt_object to be handled
* \param[in] cname the name for the child in the parent directory
* \param[in] pfid the parent directory's FID for the linkEA
* \retval 0 for success
* \retval negative error number on failure
*/
-int lfsck_verify_linkea(const struct lu_env *env, struct dt_device *dev,
- struct dt_object *obj, const struct lu_name *cname,
- const struct lu_fid *pfid)
+int lfsck_verify_linkea(const struct lu_env *env, struct dt_object *obj,
+ const struct lu_name *cname, const struct lu_fid *pfid)
{
+ struct dt_device *dev = lfsck_obj2dev(obj);
struct linkea_data ldata = { NULL };
struct lu_buf linkea_buf;
struct thandle *th;
*
* \param[in] env pointer to the thread context
* \param[in] lfsck pointer to the lfsck instance
- * \param[in] parent pointer to the parent directory that holds
+ * \param[in] dir pointer to the directory that holds
* the name entry
* \param[in] name the name for the entry to be updated
- * \param[in] pfid the new PFID for the name entry
+ * \param[in] fid the new FID for the name entry referenced
* \param[in] type the type for the name entry to be updated
*
* \retval 0 for success
*/
int lfsck_update_name_entry(const struct lu_env *env,
struct lfsck_instance *lfsck,
- struct dt_object *parent, const char *name,
- const struct lu_fid *pfid, __u32 type)
+ struct dt_object *dir, const char *name,
+ const struct lu_fid *fid, __u32 type)
{
- struct dt_insert_rec *rec = &lfsck_env_info(env)->lti_dt_rec;
- struct dt_device *dev = lfsck->li_next;
- struct lustre_handle lh = { 0 };
- struct thandle *th;
- int rc;
- bool exists = true;
+ struct lfsck_thread_info *info = lfsck_env_info(env);
+ struct dt_insert_rec *rec = &info->lti_dt_rec;
+ struct lfsck_lock_handle *llh = &info->lti_llh;
+ struct dt_device *dev = lfsck_obj2dev(dir);
+ struct thandle *th;
+ int rc;
+ bool exists = true;
ENTRY;
- rc = lfsck_ibits_lock(env, lfsck, parent, &lh,
- MDS_INODELOCK_UPDATE, LCK_EX);
+ rc = lfsck_lock(env, lfsck, dir, name, llh,
+ MDS_INODELOCK_UPDATE, LCK_PW);
if (rc != 0)
RETURN(rc);
if (IS_ERR(th))
GOTO(unlock, rc = PTR_ERR(th));
- rc = dt_declare_delete(env, parent, (const struct dt_key *)name, th);
+ rc = dt_declare_delete(env, dir, (const struct dt_key *)name, th);
if (rc != 0)
GOTO(stop, rc);
rec->rec_type = type;
- rec->rec_fid = pfid;
- rc = dt_declare_insert(env, parent, (const struct dt_rec *)rec,
+ rec->rec_fid = fid;
+ rc = dt_declare_insert(env, dir, (const struct dt_rec *)rec,
(const struct dt_key *)name, th);
if (rc != 0)
GOTO(stop, rc);
- rc = dt_declare_ref_add(env, parent, th);
+ rc = dt_declare_ref_add(env, dir, th);
if (rc != 0)
GOTO(stop, rc);
- rc = dt_trans_start(env, dev, th);
+ rc = dt_trans_start_local(env, dev, th);
if (rc != 0)
GOTO(stop, rc);
- rc = dt_delete(env, parent, (const struct dt_key *)name, th,
+ rc = dt_delete(env, dir, (const struct dt_key *)name, th,
BYPASS_CAPA);
if (rc == -ENOENT) {
exists = false;
if (rc != 0)
GOTO(stop, rc);
- rc = dt_insert(env, parent, (const struct dt_rec *)rec,
+ rc = dt_insert(env, dir, (const struct dt_rec *)rec,
(const struct dt_key *)name, th, BYPASS_CAPA, 1);
if (rc == 0 && S_ISDIR(type) && !exists) {
- dt_write_lock(env, parent, 0);
- rc = dt_ref_add(env, parent, th);
- dt_write_unlock(env, parent);
+ dt_write_lock(env, dir, 0);
+ rc = dt_ref_add(env, dir, th);
+ dt_write_unlock(env, dir);
}
GOTO(stop, rc);
dt_trans_stop(env, dev, th);
unlock:
- lfsck_ibits_unlock(&lh, LCK_EX);
-
+ lfsck_unlock(llh);
CDEBUG(D_LFSCK, "%s: update name entry "DFID"/%s with the FID "DFID
" and the type %o: rc = %d\n", lfsck_lfsck2name(lfsck),
- PFID(lfsck_dto2fid(parent)), name, PFID(pfid), type, rc);
+ PFID(lfsck_dto2fid(dir)), name, PFID(fid), type, rc);
return rc;
}
if (unlikely(!dt_try_as_dir(env, root)))
GOTO(out, rc = -ENOTDIR);
- obj = local_file_find_or_create(env, lfsck->li_los, root,
- LFSCK_NAMESPACE,
- S_IFREG | S_IRUGO | S_IWUSR);
+ obj = local_index_find_or_create(env, lfsck->li_los, root,
+ LFSCK_NAMESPACE,
+ S_IFREG | S_IRUGO | S_IWUSR,
+ &dt_lfsck_features);
if (IS_ERR(obj))
GOTO(out, rc = PTR_ERR(obj));
out:
if (root != NULL && !IS_ERR(root))
- lu_object_put(env, &root->do_lu);
+ lfsck_object_put(env, root);
if (rc != 0) {
lfsck_component_cleanup(env, com);
CERROR("%s: fail to init namespace LFSCK component: rc = %d\n",