#define DEBUG_SUBSYSTEM S_LFSCK
+#include <linux/kthread.h>
#include <libcfs/list.h>
#include <lu_object.h>
#include <dt_object.h>
}
cfs_foreach_bit(ltds->ltd_tgts_bitmap, idx) {
- ltd = LTD_TGT(ltds, idx);
+ ltd = lfsck_ltd2tgt(ltds, idx);
if (likely(ltd != NULL)) {
LASSERT(list_empty(<d->ltd_layout_list));
LASSERT(list_empty(<d->ltd_layout_phase_list));
ltds->ltd_tgtnr--;
cfs_bitmap_clear(ltds->ltd_tgts_bitmap, idx);
- LTD_TGT(ltds, idx) = NULL;
+ lfsck_assign_tgt(ltds, NULL, idx);
lfsck_tgt_put(ltd);
}
}
GOTO(unlock, rc = -ENOMEM);
}
- LTD_TGT(ltds, index) = ltd;
+ lfsck_assign_tgt(ltds, ltd, index);
cfs_bitmap_set(ltds->ltd_tgts_bitmap, index);
ltds->ltd_tgtnr++;
RETURN(rc);
}
-/**
- * Request the specified ibits lock for the given object.
- *
- * Before the LFSCK modifying on the namespace visible object,
- * it needs to acquire related ibits ldlm lock.
- *
- * \param[in] env pointer to the thread context
- * \param[in] lfsck pointer to the lfsck instance
- * \param[in] obj pointer to the dt_object to be locked
- * \param[out] lh pointer to the lock handle
- * \param[in] ibits the bits for the ldlm lock to be acquired
- * \param[in] mode the mode for the ldlm lock to be acquired
- *
- * \retval 0 for success
- * \retval negative error number on failure
- */
-int lfsck_ibits_lock(const struct lu_env *env, struct lfsck_instance *lfsck,
- struct dt_object *obj, struct lustre_handle *lh,
- __u64 bits, ldlm_mode_t mode)
+static int __lfsck_ibits_lock(const struct lu_env *env,
+ struct lfsck_instance *lfsck,
+ struct dt_object *obj,
+ struct ldlm_res_id *resid,
+ struct lustre_handle *lh,
+ __u64 bits, ldlm_mode_t mode)
{
struct lfsck_thread_info *info = lfsck_env_info(env);
ldlm_policy_data_t *policy = &info->lti_policy;
- struct ldlm_res_id *resid = &info->lti_resid;
__u64 flags = LDLM_FL_ATOMIC_CB;
int rc;
memset(policy, 0, sizeof(*policy));
policy->l_inodebits.bits = bits;
- fid_build_reg_res_name(lfsck_dto2fid(obj), resid);
if (dt_object_remote(obj)) {
struct ldlm_enqueue_info *einfo = &info->lti_einfo;
}
/**
+ * Request the specified ibits lock for the given object.
+ *
+ * Before the LFSCK modifying on the namespace visible object,
+ * it needs to acquire related ibits ldlm lock.
+ *
+ * \param[in] env pointer to the thread context
+ * \param[in] lfsck pointer to the lfsck instance
+ * \param[in] obj pointer to the dt_object to be locked
+ * \param[out] lh pointer to the lock handle
+ * \param[in] bits the bits for the ldlm lock to be acquired
+ * \param[in] mode the mode for the ldlm lock to be acquired
+ *
+ * \retval 0 for success
+ * \retval negative error number on failure
+ */
+int lfsck_ibits_lock(const struct lu_env *env, struct lfsck_instance *lfsck,
+ struct dt_object *obj, struct lustre_handle *lh,
+ __u64 bits, ldlm_mode_t mode)
+{
+ struct ldlm_res_id *resid = &lfsck_env_info(env)->lti_resid;
+
+ LASSERT(!lustre_handle_is_used(lh));
+
+ fid_build_reg_res_name(lfsck_dto2fid(obj), resid);
+ return __lfsck_ibits_lock(env, lfsck, obj, resid, lh, bits, mode);
+}
+
+/**
* Release the the specified ibits lock.
*
* If the lock has been acquired before, release it
}
}
+/**
+ * Request compound ibits locks for the given <obj, name> pairs.
+ *
+ * Before the LFSCK modifying on the namespace visible object, it needs to
+ * acquire related ibits ldlm lock. Usually, we can use lfsck_ibits_lock for
+ * the lock purpose. But the simple lfsck_ibits_lock for directory-based
+ * modificationis (such as insert name entry to the directory) may be too
+ * coarse-grained and not efficient.
+ *
+ * The lfsck_lock() will request compound ibits locks on the specified
+ * <obj, name> pairs: the PDO (Parallel Directory Operations) ibits (UPDATE)
+ * lock on the directory object, and the regular ibits lock on the name hash.
+ *
+ * \param[in] env pointer to the thread context
+ * \param[in] lfsck pointer to the lfsck instance
+ * \param[in] obj pointer to the dt_object to be locked
+ * \param[in] name used for building the PDO lock resource
+ * \param[out] llh pointer to the lfsck_lock_handle
+ * \param[in] bits the bits for the ldlm lock to be acquired
+ * \param[in] mode the mode for the ldlm lock to be acquired
+ *
+ * \retval 0 for success
+ * \retval negative error number on failure
+ */
+int lfsck_lock(const struct lu_env *env, struct lfsck_instance *lfsck,
+ struct dt_object *obj, const char *name,
+ struct lfsck_lock_handle *llh, __u64 bits, ldlm_mode_t mode)
+{
+ struct ldlm_res_id *resid = &lfsck_env_info(env)->lti_resid;
+ int rc;
+
+ LASSERT(S_ISDIR(lfsck_object_type(obj)));
+ LASSERT(name != NULL);
+ LASSERT(!lustre_handle_is_used(&llh->llh_pdo_lh));
+ LASSERT(!lustre_handle_is_used(&llh->llh_reg_lh));
+
+ switch (mode) {
+ case LCK_EX:
+ llh->llh_pdo_mode = LCK_EX;
+ break;
+ case LCK_PW:
+ llh->llh_pdo_mode = LCK_CW;
+ break;
+ case LCK_PR:
+ llh->llh_pdo_mode = LCK_CR;
+ break;
+ default:
+ CDEBUG(D_LFSCK, "%s: unexpected PDO lock mode %u on the obj "
+ DFID"\n", lfsck_lfsck2name(lfsck), mode,
+ PFID(lfsck_dto2fid(obj)));
+ LBUG();
+ }
+
+ fid_build_reg_res_name(lfsck_dto2fid(obj), resid);
+ rc = __lfsck_ibits_lock(env, lfsck, obj, resid, &llh->llh_pdo_lh,
+ MDS_INODELOCK_UPDATE, llh->llh_pdo_mode);
+ if (rc != 0)
+ return rc;
+
+ llh->llh_reg_mode = mode;
+ resid->name[LUSTRE_RES_ID_HSH_OFF] = full_name_hash(name, strlen(name));
+ rc = __lfsck_ibits_lock(env, lfsck, obj, resid, &llh->llh_reg_lh,
+ bits, llh->llh_reg_mode);
+ if (rc != 0)
+ lfsck_ibits_unlock(&llh->llh_pdo_lh, llh->llh_pdo_mode);
+
+ return rc;
+}
+
+/**
+ * Release the the compound ibits locks.
+ *
+ * \param[in] llh pointer to the lfsck_lock_handle to be released
+ */
+void lfsck_unlock(struct lfsck_lock_handle *llh)
+{
+ lfsck_ibits_unlock(&llh->llh_reg_lh, llh->llh_reg_mode);
+ lfsck_ibits_unlock(&llh->llh_pdo_lh, llh->llh_pdo_mode);
+}
+
int lfsck_find_mdt_idx_by_fid(const struct lu_env *env,
struct lfsck_instance *lfsck,
const struct lu_fid *fid)
struct dt_object *parent = lfsck->li_lpf_root_obj;
struct dt_device *dev = lfsck_obj2dev(parent);
struct thandle *th;
- struct lustre_handle lh = { 0 };
+ struct lfsck_lock_handle *llh = &lfsck_env_info(env)->lti_llh;
int rc;
ENTRY;
- 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)
RETURN(rc);
if (rc != 0)
GOTO(stop, rc);
- rc = dt_delete(env, parent, (const struct dt_key *)name, th,
- BYPASS_CAPA);
+ rc = dt_delete(env, parent, (const struct dt_key *)name, th);
if (rc != 0)
GOTO(stop, rc);
dt_trans_stop(env, dev, th);
unlock:
- lfsck_ibits_unlock(&lh, LCK_EX);
+ lfsck_unlock(llh);
CDEBUG(D_LFSCK, "%s: remove name entry "DFID"/%s: rc = %d\n",
lfsck_lfsck2name(lfsck), PFID(lfsck_dto2fid(parent)), name, rc);
/* 1b.2. insert dot into child dir */
rec->rec_fid = cfid;
rc = dt_insert(env, child, (const struct dt_rec *)rec,
- (const struct dt_key *)dot, th, BYPASS_CAPA, 1);
+ (const struct dt_key *)dot, th, 1);
if (rc != 0)
GOTO(unlock, rc);
/* 1b.3. insert dotdot into child dir */
rec->rec_fid = &LU_LPF_FID;
rc = dt_insert(env, child, (const struct dt_rec *)rec,
- (const struct dt_key *)dotdot, th, BYPASS_CAPA, 1);
+ (const struct dt_key *)dotdot, th, 1);
if (rc != 0)
GOTO(unlock, rc);
/* 3b. insert linkEA for child. */
rc = dt_xattr_set(env, child, &linkea_buf,
- XATTR_NAME_LINK, 0, th, BYPASS_CAPA);
+ XATTR_NAME_LINK, 0, th);
dt_write_unlock(env, child);
if (rc != 0)
GOTO(stop, rc);
/* 4b. insert name into parent dir */
rec->rec_fid = cfid;
rc = dt_insert(env, parent, (const struct dt_rec *)rec,
- (const struct dt_key *)name, th, BYPASS_CAPA, 1);
+ (const struct dt_key *)name, th, 1);
if (rc != 0)
GOTO(stop, rc);
rec->rec_type = S_IFDIR;
rec->rec_fid = cfid;
rc = dt_insert(env, child, (const struct dt_rec *)rec,
- (const struct dt_key *)dot, th, BYPASS_CAPA, 1);
+ (const struct dt_key *)dot, th, 1);
if (rc != 0)
GOTO(unlock, rc);
/* 1b.3. insert dotdot into child dir */
rec->rec_fid = &LU_LPF_FID;
rc = dt_insert(env, child, (const struct dt_rec *)rec,
- (const struct dt_key *)dotdot, th, BYPASS_CAPA, 1);
+ (const struct dt_key *)dotdot, th, 1);
if (rc != 0)
GOTO(unlock, rc);
/* 3b. insert linkEA for child */
rc = dt_xattr_set(env, child, &linkea_buf,
- XATTR_NAME_LINK, 0, th, BYPASS_CAPA);
+ XATTR_NAME_LINK, 0, th);
if (rc != 0)
GOTO(unlock, rc);
/* 5b. insert name into parent dir */
rc = dt_insert(env, parent, (const struct dt_rec *)rec,
- (const struct dt_key *)name, th, BYPASS_CAPA, 1);
+ (const struct dt_key *)name, th, 1);
if (rc != 0)
GOTO(stop, rc);
struct dt_object_format *dof = &info->lti_dof;
struct dt_object *parent = lfsck->li_lpf_root_obj;
struct dt_object *child = NULL;
- struct lustre_handle lh = { 0 };
+ struct lfsck_lock_handle *llh = &info->lti_llh;
char name[8];
int node = lfsck_dev_idx(lfsck);
int rc = 0;
LASSERT(parent != NULL);
LASSERT(lfsck->li_lpf_obj == NULL);
- 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)
RETURN(rc);
* the lfsck_bookmark::lb_lpf_fid successfully. So need lookup
* it from MDT0 firstly. */
rc = dt_lookup(env, parent, (struct dt_rec *)cfid,
- (const struct dt_key *)name, BYPASS_CAPA);
+ (const struct dt_key *)name);
if (rc != 0 && rc != -ENOENT)
GOTO(unlock, rc);
GOTO(unlock, rc);
unlock:
- lfsck_ibits_unlock(&lh, LCK_EX);
+ lfsck_unlock(llh);
if (rc != 0 && child != NULL && !IS_ERR(child))
lfsck_object_put(env, child);
int rc;
ENTRY;
- it = iops->init(env, parent, LUDA_64BITHASH, BYPASS_CAPA);
+ it = iops->init(env, parent, LUDA_64BITHASH);
if (IS_ERR(it))
RETURN(PTR_ERR(it));
fid_zero(fid);
rc = dt_lookup(env, child, (struct dt_rec *)fid,
- (const struct dt_key *)dotdot, BYPASS_CAPA);
+ (const struct dt_key *)dotdot);
if (rc != 0)
GOTO(linkea, rc);
}
rc = dt_lookup(env, parent2, (struct dt_rec *)fid,
- (const struct dt_key *)name2, BYPASS_CAPA);
+ (const struct dt_key *)name2);
dt_read_unlock(env, child);
lfsck_ibits_unlock(&lh, LCK_PR);
if (rc != 0 && rc != -ENOENT)
find_child2:
snprintf(name, 8, "MDT%04x", node);
rc = dt_lookup(env, parent, (struct dt_rec *)cfid,
- (const struct dt_key *)name, BYPASS_CAPA);
+ (const struct dt_key *)name);
if (rc == -ENOENT) {
if (!fid_is_zero(&bk->lb_lpf_fid))
goto check_child1;
int flag;
int i;
bool newline = (bits != 0 ? false : true);
+ int rc;
- seq_printf(m, "%s:%c", prefix, bits != 0 ? ' ' : '\n');
+ rc = seq_printf(m, "%s:%c", prefix, bits != 0 ? ' ' : '\n');
+ if (rc < 0)
+ return rc;
for (i = 0, flag = 1; bits != 0; i++, flag = 1 << i) {
if (flag & bits) {
if (bits == 0)
newline = true;
- seq_printf(m, "%s%c", names[i],
- newline ? '\n' : ',');
+ rc = seq_printf(m, "%s%c", names[i],
+ newline ? '\n' : ',');
+ if (rc < 0)
+ return rc;
}
}
}
if (!newline)
- seq_printf(m, "\n");
- return 0;
+ rc = seq_printf(m, "\n");
+
+ return rc;
}
-int lfsck_time_dump(struct seq_file *m, __u64 time, const char *prefix)
+int lfsck_time_dump(struct seq_file *m, __u64 time, const char *name)
{
- if (time != 0)
- seq_printf(m, "%s: "LPU64" seconds\n", prefix,
- cfs_time_current_sec() - time);
- else
- seq_printf(m, "%s: N/A\n", prefix);
- return 0;
+ int rc;
+
+ if (time == 0) {
+ rc = seq_printf(m, "%s_time: N/A\n", name);
+ if (rc == 0)
+ rc = seq_printf(m, "time_since_%s: N/A\n", name);
+
+ return rc;
+ }
+
+ rc = seq_printf(m, "%s_time: "LPU64"\n", name, time);
+ if (rc == 0)
+ rc = seq_printf(m, "time_since_%s: "LPU64" seconds\n",
+ name, cfs_time_current_sec() - time);
+
+ return rc;
}
int lfsck_pos_dump(struct seq_file *m, struct lfsck_position *pos,
{
if (fid_is_zero(&pos->lp_dir_parent)) {
if (pos->lp_oit_cookie == 0)
- seq_printf(m, "%s: N/A, N/A, N/A\n",
- prefix);
- else
- seq_printf(m, "%s: "LPU64", N/A, N/A\n",
- prefix, pos->lp_oit_cookie);
- } else {
- seq_printf(m, "%s: "LPU64", "DFID", "LPX64"\n",
- prefix, pos->lp_oit_cookie,
- PFID(&pos->lp_dir_parent), pos->lp_dir_cookie);
+ return seq_printf(m, "%s: N/A, N/A, N/A\n", prefix);
+
+ return seq_printf(m, "%s: "LPU64", N/A, N/A\n",
+ prefix, pos->lp_oit_cookie);
}
- return 0;
+
+ return seq_printf(m, "%s: "LPU64", "DFID", "LPX64"\n",
+ prefix, pos->lp_oit_cookie,
+ PFID(&pos->lp_dir_parent), pos->lp_dir_cookie);
}
void lfsck_pos_fill(const struct lu_env *env, struct lfsck_instance *lfsck,
return lad;
}
+struct lfsck_assistant_object *
+lfsck_assistant_object_init(const struct lu_env *env, const struct lu_fid *fid,
+ const struct lu_attr *attr, __u64 cookie,
+ bool is_dir)
+{
+ struct lfsck_assistant_object *lso;
+
+ OBD_ALLOC_PTR(lso);
+ if (lso == NULL)
+ return ERR_PTR(-ENOMEM);
+
+ lso->lso_fid = *fid;
+ if (attr != NULL)
+ lso->lso_attr = *attr;
+
+ atomic_set(&lso->lso_ref, 1);
+ lso->lso_oit_cookie = cookie;
+ if (is_dir)
+ lso->lso_is_dir = 1;
+
+ return lso;
+}
+
+struct dt_object *
+lfsck_assistant_object_load(const struct lu_env *env,
+ struct lfsck_instance *lfsck,
+ struct lfsck_assistant_object *lso)
+{
+ struct dt_object *obj;
+
+ obj = lfsck_object_find_bottom(env, lfsck, &lso->lso_fid);
+ if (IS_ERR(obj))
+ return obj;
+
+ if (unlikely(!dt_object_exists(obj) || lfsck_is_dead_obj(obj))) {
+ lso->lso_dead = 1;
+ lfsck_object_put(env, obj);
+
+ return ERR_PTR(-ENOENT);
+ }
+
+ if (lso->lso_is_dir && unlikely(!dt_try_as_dir(env, obj))) {
+ lfsck_object_put(env, obj);
+
+ return ERR_PTR(-ENOTDIR);
+ }
+
+ return obj;
+}
+
/**
* Generic LFSCK asynchronous communication interpretor function.
* The LFSCK RPC reply for both the event notification and status
lad->lad_to_double_scan = 0;
lad->lad_in_double_scan = 0;
lad->lad_exit = 0;
+ lad->lad_advance_lock = false;
thread_set_flags(athread, 0);
lta = lfsck_thread_args_init(lfsck, com, lsp);
struct ptlrpc_thread *athread = &lad->lad_thread;
struct l_wait_info lwi = { 0 };
- if (com->lc_new_checked == 0)
- return LFSCK_CHECKPOINT_SKIP;
-
l_wait_event(mthread->t_ctl_waitq,
list_empty(&lad->lad_req_list) ||
!thread_is_running(mthread) ||
lfsck = lfsck_instance_find(key, true, false);
if (likely(lfsck != NULL)) {
- if (val > LFSCK_ASYNC_WIN_MAX) {
- CWARN("%s: Too large async window size, which "
- "may cause memory issues. The valid range "
- "is [0 - %u]. If you do not want to restrict "
- "the window size for async requests pipeline, "
- "just set it as 0.\n",
+ if (val < 1 || val > LFSCK_ASYNC_WIN_MAX) {
+ CWARN("%s: invalid async windows size that may "
+ "cause memory issues. The valid range is "
+ "[1 - %u].\n",
lfsck_lfsck2name(lfsck), LFSCK_ASYNC_WIN_MAX);
rc = -EINVAL;
} else if (lfsck->li_bookmark_ram.lb_async_windows != val) {
rc = dt_lookup(env, root,
(struct dt_rec *)(&lfsck->li_global_root_fid),
- (const struct dt_key *)"ROOT", BYPASS_CAPA);
+ (const struct dt_key *)"ROOT");
if (rc != 0)
GOTO(out, rc);
GOTO(out, rc = -ENOTDIR);
rc = dt_lookup(env, obj, (struct dt_rec *)fid,
- (const struct dt_key *)dotlustre, BYPASS_CAPA);
+ (const struct dt_key *)dotlustre);
if (rc != 0)
GOTO(out, rc);
*pfid = *fid;
rc = dt_lookup(env, obj, (struct dt_rec *)fid,
- (const struct dt_key *)lostfound,
- BYPASS_CAPA);
+ (const struct dt_key *)lostfound);
if (rc != 0)
GOTO(out, rc);
if (unlikely(index >= ltds->ltd_tgts_bitmap->size))
goto unlock;
- ltd = LTD_TGT(ltds, index);
+ ltd = lfsck_ltd2tgt(ltds, index);
if (unlikely(ltd == NULL))
goto unlock;
ltds->ltd_tgtnr--;
cfs_bitmap_clear(ltds->ltd_tgts_bitmap, index);
- LTD_TGT(ltds, index) = NULL;
+ lfsck_assign_tgt(ltds, NULL, index);
unlock:
if (ltd == NULL) {
MODULE_AUTHOR("Intel Corporation <http://www.intel.com/>");
MODULE_DESCRIPTION("LFSCK");
+MODULE_VERSION(LUSTRE_VERSION_STRING);
MODULE_LICENSE("GPL");
-cfs_module(lfsck, LUSTRE_VERSION_STRING, lfsck_init, lfsck_exit);
+module_init(lfsck_init);
+module_exit(lfsck_exit);
git://git.whamcloud.com / fs / lustre-release.git / blobdiff