struct osd_device *dev,
const struct lu_fid *fid,
const struct osd_inode_id *id,
- int ops, enum oi_check_flags flags)
+ int ops, bool force,
+ enum oi_check_flags flags)
{
- const struct lu_env *env = info->oti_env;
- struct thandle *th;
- struct osd_thandle *oh;
- int rc;
+ handle_t *th;
+ int rc;
ENTRY;
- th = dt_trans_create(env, &dev->od_dt_dev);
- if (IS_ERR(th))
- RETURN(PTR_ERR(th));
+ if (dev->od_scrub.os_file.sf_param & SP_DRYRUN && !force)
+ RETURN(0);
- oh = container_of0(th, struct osd_thandle, ot_super);
- LASSERT(oh->ot_handle == NULL);
+ /* DTO_INDEX_INSERT is enough for other two ops:
+ * delete/update, but save stack. */
+ th = ldiskfs_journal_start_sb(osd_sb(dev),
+ osd_dto_credits_noquota[DTO_INDEX_INSERT]);
+ if (IS_ERR(th)) {
+ rc = PTR_ERR(th);
+ CERROR("%s: fail to start trans for scrub %d: rc = %d\n",
+ osd_name(dev), ops, rc);
+ RETURN(rc);
+ }
switch (ops) {
case DTO_INDEX_UPDATE:
- osd_trans_declare_op(env, oh, OSD_OT_UPDATE,
- osd_dto_credits_noquota[DTO_INDEX_UPDATE]);
- rc = dt_trans_start_local(env, &dev->od_dt_dev, th);
- if (rc != 0)
- GOTO(stop, rc);
-
rc = osd_oi_update(info, dev, fid, id, th, flags);
if (unlikely(rc == -ENOENT)) {
/* Some unlink thread may removed the OI mapping. */
}
break;
case DTO_INDEX_INSERT:
- osd_trans_declare_op(env, oh, OSD_OT_INSERT,
- osd_dto_credits_noquota[DTO_INDEX_INSERT]);
- rc = dt_trans_start_local(env, &dev->od_dt_dev, th);
- if (rc != 0)
- GOTO(stop, rc);
-
rc = osd_oi_insert(info, dev, fid, id, th, flags);
if (unlikely(rc == -EEXIST)) {
rc = 1;
}
break;
case DTO_INDEX_DELETE:
- osd_trans_declare_op(env, oh, OSD_OT_DELETE,
- osd_dto_credits_noquota[DTO_INDEX_DELETE]);
- rc = dt_trans_start_local(env, &dev->od_dt_dev, th);
- if (rc != 0)
- GOTO(stop, rc);
-
rc = osd_oi_delete(info, dev, fid, th, flags);
if (rc == -ENOENT) {
/* It is normal that the unlink thread has removed the
break;
}
- GOTO(stop, rc);
-
-stop:
- dt_trans_stop(env, &dev->od_dt_dev, th);
+ ldiskfs_journal_stop(th);
return rc;
}
memcpy(sf->sf_uuid, uuid, 16);
sf->sf_status = SS_INIT;
sf->sf_flags |= flags;
- sf->sf_param = 0;
sf->sf_run_time = 0;
sf->sf_time_latest_start = 0;
sf->sf_time_last_checkpoint = 0;
dev = container_of0(scrub, struct osd_device, od_scrub);
credits = osd_dto_credits_noquota[DTO_WRITE_BASE] +
osd_dto_credits_noquota[DTO_WRITE_BLOCK];
- jh = ldiskfs_journal_start_sb(osd_sb(dev), credits);
+ jh = osd_journal_start_sb(osd_sb(dev), LDISKFS_HT_MISC, credits);
if (IS_ERR(jh)) {
rc = PTR_ERR(jh);
CERROR("%.16s: fail to start trans for scrub store, rc = %d\n",
return rc;
}
-/* OI scrub APIs */
-
-static int osd_scrub_prep(struct osd_device *dev)
-{
- struct osd_scrub *scrub = &dev->od_scrub;
- struct ptlrpc_thread *thread = &scrub->os_thread;
- struct scrub_file *sf = &scrub->os_file;
- __u32 flags = scrub->os_start_flags;
- int rc;
- ENTRY;
-
- down_write(&scrub->os_rwsem);
- if (flags & SS_SET_FAILOUT)
- sf->sf_param |= SP_FAILOUT;
-
- if (flags & SS_CLEAR_FAILOUT)
- sf->sf_param &= ~SP_FAILOUT;
-
- if (flags & SS_RESET)
- osd_scrub_file_reset(scrub,
- LDISKFS_SB(osd_sb(dev))->s_es->s_uuid, 0);
-
- if (flags & SS_AUTO) {
- scrub->os_full_speed = 1;
- sf->sf_flags |= SF_AUTO;
- } else {
- scrub->os_full_speed = 0;
- }
-
- if (sf->sf_flags & (SF_RECREATED | SF_INCONSISTENT | SF_UPGRADE))
- scrub->os_full_speed = 1;
-
- scrub->os_in_prior = 0;
- spin_lock(&scrub->os_lock);
- scrub->os_waiting = 0;
- scrub->os_paused = 0;
- spin_unlock(&scrub->os_lock);
- scrub->os_new_checked = 0;
- if (sf->sf_pos_last_checkpoint != 0)
- sf->sf_pos_latest_start = sf->sf_pos_last_checkpoint + 1;
- else
- sf->sf_pos_latest_start = LDISKFS_FIRST_INO(osd_sb(dev)) + 1;
-
- scrub->os_pos_current = sf->sf_pos_latest_start;
- sf->sf_status = SS_SCANNING;
- sf->sf_time_latest_start = cfs_time_current_sec();
- sf->sf_time_last_checkpoint = sf->sf_time_latest_start;
- rc = osd_scrub_file_store(scrub);
- if (rc == 0) {
- spin_lock(&scrub->os_lock);
- thread_set_flags(thread, SVC_RUNNING);
- spin_unlock(&scrub->os_lock);
- wake_up_all(&thread->t_ctl_waitq);
- }
- up_write(&scrub->os_rwsem);
-
- RETURN(rc);
-}
-
static int
osd_scrub_convert_ff(struct osd_thread_info *info, struct osd_device *dev,
struct inode *inode, const struct lu_fid *fid)
bool reset = true;
ENTRY;
+ if (dev->od_scrub.os_file.sf_param & SP_DRYRUN)
+ RETURN(0);
+
/* We want the LMA to fit into the 256-byte OST inode, so operate
* as following:
* 1) read old XATTR_NAME_FID and save the parent FID;
* Making the LMA to fit into the 256-byte OST inode can save time for
* normal osd_check_lma() and for other OI scrub scanning in future.
* So it is worth to make some slow conversion here. */
- jh = ldiskfs_journal_start_sb(osd_sb(dev),
+ jh = osd_journal_start_sb(osd_sb(dev), LDISKFS_HT_MISC,
osd_dto_credits_noquota[DTO_XATTR_SET] * 3);
if (IS_ERR(jh)) {
rc = PTR_ERR(jh);
GOTO(out, rc = val);
if (scrub->os_in_prior)
- oii = cfs_list_entry(oic, struct osd_inconsistent_item,
- oii_cache);
+ oii = list_entry(oic, struct osd_inconsistent_item,
+ oii_cache);
if (lid->oii_ino < sf->sf_pos_latest_start && oii == NULL)
GOTO(out, rc = 0);
sf->sf_internal_flags &= ~SIF_NO_HANDLE_OLD_FID;
dev->od_check_ff = 1;
rc = osd_scrub_convert_ff(info, dev, inode, fid);
- rc = osd_ea_fid_set(info, inode, fid,
- LMAC_FID_ON_OST, 0);
if (rc != 0)
GOTO(out, rc);
(val == SCRUB_NEXT_OSTOBJ ||
val == SCRUB_NEXT_OSTOBJ_OLD) ? OI_KNOWN_ON_OST : 0);
if (rc != 0) {
- if (rc != -ENOENT)
+ if (rc != -ENOENT && rc != -ESTALE)
GOTO(out, rc);
iget:
switch (val) {
case SCRUB_NEXT_NOLMA:
sf->sf_flags |= SF_UPGRADE;
- rc = osd_ea_fid_set(info, inode, fid, 0, 0);
- if (rc != 0)
- GOTO(out, rc);
+ if (!(sf->sf_param & SP_DRYRUN)) {
+ rc = osd_ea_fid_set(info, inode, fid, 0, 0);
+ if (rc != 0)
+ GOTO(out, rc);
+ }
if (!(sf->sf_flags & SF_INCONSISTENT))
dev->od_igif_inoi = 0;
dev->od_igif_inoi = 1;
}
- rc = osd_scrub_refresh_mapping(info, dev, fid, lid, ops,
+ rc = osd_scrub_refresh_mapping(info, dev, fid, lid, ops, false,
(val == SCRUB_NEXT_OSTOBJ ||
val == SCRUB_NEXT_OSTOBJ_OLD) ? OI_KNOWN_ON_OST : 0);
if (rc == 0) {
if (ops == DTO_INDEX_INSERT && inode != NULL && !IS_ERR(inode) &&
unlikely(inode->i_nlink == 0))
osd_scrub_refresh_mapping(info, dev, fid, lid,
- DTO_INDEX_DELETE,
+ DTO_INDEX_DELETE, false,
(val == SCRUB_NEXT_OSTOBJ ||
val == SCRUB_NEXT_OSTOBJ_OLD) ?
OI_KNOWN_ON_OST : 0);
iput(inode);
if (oii != NULL) {
- LASSERT(!cfs_list_empty(&oii->oii_list));
+ LASSERT(!list_empty(&oii->oii_list));
spin_lock(&scrub->os_lock);
- cfs_list_del_init(&oii->oii_list);
+ list_del_init(&oii->oii_list);
spin_unlock(&scrub->os_lock);
OBD_FREE_PTR(oii);
}
RETURN(sf->sf_param & SP_FAILOUT ? rc : 0);
}
+/* OI scrub APIs */
+
+static int osd_scrub_prep(struct osd_device *dev)
+{
+ struct osd_scrub *scrub = &dev->od_scrub;
+ struct ptlrpc_thread *thread = &scrub->os_thread;
+ struct scrub_file *sf = &scrub->os_file;
+ __u32 flags = scrub->os_start_flags;
+ int rc;
+ bool drop_dryrun = false;
+ ENTRY;
+
+ down_write(&scrub->os_rwsem);
+ if (flags & SS_SET_FAILOUT)
+ sf->sf_param |= SP_FAILOUT;
+
+ if (flags & SS_CLEAR_FAILOUT)
+ sf->sf_param &= ~SP_FAILOUT;
+
+ if (flags & SS_SET_DRYRUN)
+ sf->sf_param |= SP_DRYRUN;
+
+ if (flags & SS_CLEAR_DRYRUN && sf->sf_param & SP_DRYRUN) {
+ sf->sf_param &= ~SP_DRYRUN;
+ drop_dryrun = true;
+ }
+
+ if (flags & SS_RESET)
+ osd_scrub_file_reset(scrub,
+ LDISKFS_SB(osd_sb(dev))->s_es->s_uuid, 0);
+
+ if (flags & SS_AUTO) {
+ scrub->os_full_speed = 1;
+ sf->sf_flags |= SF_AUTO;
+ /* For the case of OI scrub auto triggered, NOT dryrun. */
+ sf->sf_param &= ~SP_FAILOUT;
+ } else {
+ scrub->os_full_speed = 0;
+ }
+
+ if (sf->sf_flags & (SF_RECREATED | SF_INCONSISTENT | SF_UPGRADE))
+ scrub->os_full_speed = 1;
+
+ scrub->os_in_prior = 0;
+ spin_lock(&scrub->os_lock);
+ scrub->os_waiting = 0;
+ scrub->os_paused = 0;
+ spin_unlock(&scrub->os_lock);
+ scrub->os_new_checked = 0;
+ if (drop_dryrun && sf->sf_pos_first_inconsistent != 0)
+ sf->sf_pos_latest_start = sf->sf_pos_first_inconsistent;
+ else if (sf->sf_pos_last_checkpoint != 0)
+ sf->sf_pos_latest_start = sf->sf_pos_last_checkpoint + 1;
+ else
+ sf->sf_pos_latest_start = LDISKFS_FIRST_INO(osd_sb(dev)) + 1;
+
+ scrub->os_pos_current = sf->sf_pos_latest_start;
+ sf->sf_status = SS_SCANNING;
+ sf->sf_time_latest_start = cfs_time_current_sec();
+ sf->sf_time_last_checkpoint = sf->sf_time_latest_start;
+ rc = osd_scrub_file_store(scrub);
+ if (rc == 0) {
+ spin_lock(&scrub->os_lock);
+ thread_set_flags(thread, SVC_RUNNING);
+ spin_unlock(&scrub->os_lock);
+ wake_up_all(&thread->t_ctl_waitq);
+ }
+ up_write(&scrub->os_rwsem);
+
+ RETURN(rc);
+}
+
static int osd_scrub_checkpoint(struct osd_scrub *scrub)
{
struct scrub_file *sf = &scrub->os_file;
dev->od_igif_inoi = 1;
dev->od_check_ff = 0;
sf->sf_status = SS_COMPLETED;
- memset(sf->sf_oi_bitmap, 0, SCRUB_OI_BITMAP_SIZE);
- sf->sf_flags &= ~(SF_RECREATED | SF_INCONSISTENT |
- SF_UPGRADE | SF_AUTO);
+ if (!(sf->sf_param & SP_DRYRUN)) {
+ memset(sf->sf_oi_bitmap, 0, SCRUB_OI_BITMAP_SIZE);
+ sf->sf_flags &= ~(SF_RECREATED | SF_INCONSISTENT |
+ SF_UPGRADE | SF_AUTO);
+ }
sf->sf_time_last_complete = sf->sf_time_last_checkpoint;
sf->sf_success_count++;
} else if (result == 0) {
* a small local FLDB according to the <seq>. If the given FID
* is in the local FLDB, then it is FID-on-OST; otherwise it's
* quite possible for FID-on-MDT. */
- return 0;
+ if (dev->od_is_ost)
+ return SCRUB_NEXT_OSTOBJ_OLD;
+ else
+ return 0;
}
static int osd_scrub_get_fid(struct osd_thread_info *info,
rc = osd_get_lma(info, inode, &info->oti_obj_dentry, lma);
if (rc == 0) {
has_lma = true;
- if (lma->lma_compat & LMAC_NOT_IN_OI) {
- ldiskfs_set_inode_state(inode,
- LDISKFS_STATE_LUSTRE_NO_OI);
+ if (lma->lma_compat & LMAC_NOT_IN_OI ||
+ lma->lma_incompat & LMAI_AGENT)
return SCRUB_NEXT_CONTINUE;
- }
*fid = lma->lma_self_fid;
- if (fid_is_internal(&lma->lma_self_fid)) {
- if (!scrub)
- rc = SCRUB_NEXT_CONTINUE;
- return rc;
- }
-
if (!scrub)
return 0;
- if (fid_is_namespace_visible(fid) && !fid_is_norm(fid))
- return 0;
-
if (lma->lma_compat & LMAC_FID_ON_OST)
return SCRUB_NEXT_OSTOBJ;
- if (fid_is_idif(fid) || fid_is_last_id(fid))
+ if (fid_is_idif(fid))
return SCRUB_NEXT_OSTOBJ_OLD;
- if (lma->lma_incompat & LMAI_AGENT)
- return SCRUB_NEXT_CONTINUE;
+ /* For local object. */
+ if (fid_is_internal(fid))
+ return 0;
+
+ /* For external visible MDT-object with non-normal FID. */
+ if (fid_is_namespace_visible(fid) && !fid_is_norm(fid))
+ return 0;
- /* Here, it may be MDT-object, or may be 2.4 OST-object.
- * Fall through. */
+ /* For the object with normal FID, it may be MDT-object,
+ * or may be 2.4 OST-object, need further distinguish.
+ * Fall through to next section. */
}
if (rc == -ENODATA || rc == 0) {
RETURN(rc);
}
- /* If the inode has no OI mapping, then it is special locally used,
- * should be invisible to OI scrub or up layer LFSCK. */
- if (ldiskfs_test_inode_state(inode, LDISKFS_STATE_LUSTRE_NO_OI))
- GOTO(put, rc = SCRUB_NEXT_CONTINUE);
-
if (scrub &&
ldiskfs_test_inode_state(inode, LDISKFS_STATE_LUSTRE_NOSCRUB)) {
/* Only skip it for the first OI scrub accessing. */
lwi = LWI_TIMEOUT(cfs_time_seconds(cfs_fail_val), NULL, NULL);
l_wait_event(thread->t_ctl_waitq,
- !cfs_list_empty(&scrub->os_inconsistent_items) ||
+ !list_empty(&scrub->os_inconsistent_items) ||
!thread_is_running(thread),
&lwi);
}
if (unlikely(!thread_is_running(thread)))
return SCRUB_NEXT_EXIT;
- if (!cfs_list_empty(&scrub->os_inconsistent_items)) {
+ if (!list_empty(&scrub->os_inconsistent_items)) {
struct osd_inconsistent_item *oii;
- oii = cfs_list_entry(scrub->os_inconsistent_items.next,
- struct osd_inconsistent_item, oii_list);
+ oii = list_entry(scrub->os_inconsistent_items.next,
+ struct osd_inconsistent_item, oii_list);
*oic = &oii->oii_cache;
scrub->os_in_prior = 1;
return 0;
{
spin_lock(&scrub->os_lock);
if (osd_scrub_has_window(scrub, &it->ooi_cache) ||
- !cfs_list_empty(&scrub->os_inconsistent_items) ||
+ !list_empty(&scrub->os_inconsistent_items) ||
it->ooi_waiting || !thread_is_running(&scrub->os_thread))
scrub->os_waiting = 0;
else
if (scrub->os_full_speed || rc == SCRUB_NEXT_CONTINUE)
return 0;
- if (osd_scrub_has_window(scrub, ooc)) {
+ if (ooc != NULL && osd_scrub_has_window(scrub, ooc)) {
*noslot = 0;
return 0;
}
- l_wait_event(thread->t_ctl_waitq,
- osd_scrub_wakeup(scrub, it),
- &lwi);
+ if (it != NULL)
+ l_wait_event(thread->t_ctl_waitq, osd_scrub_wakeup(scrub, it),
+ &lwi);
- if (osd_scrub_has_window(scrub, ooc))
+ if (ooc != NULL && osd_scrub_has_window(scrub, ooc))
*noslot = 0;
else
*noslot = 1;
rc, scrub->os_pos_current);
out:
- while (!cfs_list_empty(&scrub->os_inconsistent_items)) {
+ while (!list_empty(&scrub->os_inconsistent_items)) {
struct osd_inconsistent_item *oii;
- oii = cfs_list_entry(scrub->os_inconsistent_items.next,
+ oii = list_entry(scrub->os_inconsistent_items.next,
struct osd_inconsistent_item, oii_list);
- cfs_list_del_init(&oii->oii_list);
+ list_del_init(&oii->oii_list);
OBD_FREE_PTR(oii);
}
lu_env_fini(&env);
loff_t offset, __u64 ino, unsigned d_type);
static int osd_ios_lf_fill(void *buf, const char *name, int namelen,
loff_t offset, __u64 ino, unsigned d_type);
+static int osd_ios_dl_fill(void *buf, const char *name, int namelen,
+ loff_t offset, __u64 ino, unsigned d_type);
static int
osd_ios_general_scan(struct osd_thread_info *info, struct osd_device *dev,
{ "LAST_GROUP", { FID_SEQ_LOCAL_FILE, OFD_LAST_GROUP_OID, 0 },
OLF_SHOW_NAME, NULL, NULL },
+ /* SLAVE_LOG, llog for destroy slave stripes of striped dir */
+ { "SLAVE_LOG", { FID_SEQ_LOCAL_FILE, SLAVE_LLOG_CATALOGS_OID, 0 },
+ OLF_SHOW_NAME, NULL, NULL },
+
/* lost+found */
{ "lost+found", { 0, 0, 0 }, OLF_SCAN_SUBITEMS | OLF_NO_OI,
osd_ios_general_scan, osd_ios_lf_fill },
{ NULL, { 0, 0, 0 }, 0, NULL, NULL }
};
+/* Add the new introduced files under .lustre/ in the list in the future. */
+static const struct osd_lf_map osd_dl_maps[] = {
+ /* .lustre/fid */
+ { "fid", { FID_SEQ_DOT_LUSTRE, FID_OID_DOT_LUSTRE_OBF, 0 }, 0,
+ NULL, NULL },
+
+ /* .lustre/lost+found */
+ { "lost+found", { FID_SEQ_DOT_LUSTRE, FID_OID_DOT_LUSTRE_LPF, 0 }, 0,
+ NULL, NULL },
+
+ { NULL, { 0, 0, 0 }, 0, NULL, NULL }
+};
+
struct osd_ios_item {
- cfs_list_t oii_list;
+ struct list_head oii_list;
struct dentry *oii_dentry;
scandir_t oii_scandir;
filldir_t oii_filldir;
};
struct osd_ios_filldir_buf {
+#ifdef HAVE_DIR_CONTEXT
+ /* please keep it as first member */
+ struct dir_context ctx;
+#endif
struct osd_thread_info *oifb_info;
struct osd_device *oifb_dev;
struct dentry *oifb_dentry;
{
struct dentry *dentry;
+ CDEBUG(D_LFSCK, "init lookup one: parent = %.*s, name = %.*s\n",
+ parent->d_name.len, parent->d_name.name, namelen, name);
+
dentry = ll_lookup_one_len(name, parent, namelen);
if (!IS_ERR(dentry) && dentry->d_inode == NULL) {
dput(dentry);
scandir_t scandir, filldir_t filldir)
{
struct osd_ios_item *item;
+ ENTRY;
OBD_ALLOC_PTR(item);
if (item == NULL)
- return -ENOMEM;
+ RETURN(-ENOMEM);
- CFS_INIT_LIST_HEAD(&item->oii_list);
+ INIT_LIST_HEAD(&item->oii_list);
item->oii_dentry = dget(dentry);
item->oii_scandir = scandir;
item->oii_filldir = filldir;
- cfs_list_add_tail(&item->oii_list, &dev->od_ios_list);
- return 0;
+ list_add_tail(&item->oii_list, &dev->od_ios_list);
+
+ RETURN(0);
}
/**
int rc;
ENTRY;
+ CDEBUG(D_LFSCK, "init scan one: ino = %ld\n", inode->i_ino);
+
rc = osd_get_lma(info, inode, &info->oti_obj_dentry, lma);
if (rc != 0 && rc != -ENODATA)
RETURN(rc);
RETURN(rc);
rc = osd_scrub_refresh_mapping(info, dev, &tfid, id,
- DTO_INDEX_INSERT, 0);
+ DTO_INDEX_INSERT, true, 0);
if (rc > 0)
rc = 0;
}
rc = osd_scrub_refresh_mapping(info, dev, &tfid, id,
- DTO_INDEX_UPDATE, 0);
+ DTO_INDEX_UPDATE, true, 0);
if (rc > 0)
rc = 0;
RETURN(rc);
}
+static int osd_ios_dl_fill(void *buf, const char *name, int namelen,
+ loff_t offset, __u64 ino, unsigned d_type)
+{
+ struct osd_ios_filldir_buf *fill_buf = buf;
+ struct osd_device *dev = fill_buf->oifb_dev;
+ const struct osd_lf_map *map;
+ struct dentry *child;
+ int rc = 0;
+ ENTRY;
+
+ /* skip any '.' started names */
+ if (name[0] == '.')
+ RETURN(0);
+
+ for (map = osd_dl_maps; map->olm_name != NULL; map++) {
+ if (strlen(map->olm_name) != namelen)
+ continue;
+
+ if (strncmp(map->olm_name, name, namelen) == 0)
+ break;
+ }
+
+ if (map->olm_name == NULL)
+ RETURN(0);
+
+ child = osd_ios_lookup_one_len(name, fill_buf->oifb_dentry, namelen);
+ if (IS_ERR(child))
+ RETURN(PTR_ERR(child));
+
+ rc = osd_ios_scan_one(fill_buf->oifb_info, dev, child->d_inode,
+ &map->olm_fid, map->olm_flags);
+ dput(child);
+
+ RETURN(rc);
+}
+
static int osd_ios_root_fill(void *buf, const char *name, int namelen,
loff_t offset, __u64 ino, unsigned d_type)
{
osd_ios_general_scan(struct osd_thread_info *info, struct osd_device *dev,
struct dentry *dentry, filldir_t filldir)
{
- struct osd_ios_filldir_buf buf = { info, dev, dentry };
+ struct osd_ios_filldir_buf buf = {
+#ifdef HAVE_DIR_CONTEXT
+ .ctx.actor = filldir,
+#endif
+ .oifb_info = info,
+ .oifb_dev = dev,
+ .oifb_dentry = dentry };
struct file *filp = &info->oti_it_ea.oie_file;
struct inode *inode = dentry->d_inode;
const struct file_operations *fops = inode->i_fop;
filp->f_mapping = inode->i_mapping;
filp->f_op = fops;
filp->private_data = NULL;
+ set_file_inode(filp, inode);
+#ifdef HAVE_DIR_CONTEXT
+ buf.ctx.pos = filp->f_pos;
+ rc = fops->iterate(filp, &buf.ctx);
+ filp->f_pos = buf.ctx.pos;
+#else
rc = fops->readdir(filp, &buf, filldir);
+#endif
fops->release(inode, filp);
RETURN(rc);
* to the solution 2). */
rc = osd_ios_scan_one(info, dev, child->d_inode,
&LU_DOT_LUSTRE_FID, 0);
+ if (rc == 0)
+ rc = osd_ios_new_item(dev, child, osd_ios_general_scan,
+ osd_ios_dl_fill);
dput(child);
}
int rc;
ENTRY;
+ /* Lookup IGIF in OI by force for initial OI scrub. */
+ dev->od_igif_inoi = 1;
+
while (1) {
rc = scandir(info, dev, dentry, filldir);
if (item != NULL) {
if (rc != 0)
break;
- if (cfs_list_empty(&dev->od_ios_list))
+ if (list_empty(&dev->od_ios_list))
break;
- item = cfs_list_entry(dev->od_ios_list.next,
- struct osd_ios_item, oii_list);
- cfs_list_del_init(&item->oii_list);
+ item = list_entry(dev->od_ios_list.next,
+ struct osd_ios_item, oii_list);
+ list_del_init(&item->oii_list);
LASSERT(item->oii_scandir != NULL);
scandir = item->oii_scandir;
dentry = item->oii_dentry;
}
- while (!cfs_list_empty(&dev->od_ios_list)) {
- item = cfs_list_entry(dev->od_ios_list.next,
- struct osd_ios_item, oii_list);
- cfs_list_del_init(&item->oii_list);
+ while (!list_empty(&dev->od_ios_list)) {
+ item = list_entry(dev->od_ios_list.next,
+ struct osd_ios_item, oii_list);
+ list_del_init(&item->oii_list);
dput(item->oii_dentry);
OBD_FREE_PTR(item);
}
dput(child);
else if (PTR_ERR(child) == -ENOENT)
osd_scrub_refresh_mapping(info, dev, &map->olm_fid,
- NULL, DTO_INDEX_DELETE, 0);
+ NULL, DTO_INDEX_DELETE,
+ true, 0);
map++;
}
struct osd_scrub *scrub = &dev->od_scrub;
struct ptlrpc_thread *thread = &scrub->os_thread;
struct l_wait_info lwi = { 0 };
+ struct task_struct *task;
int rc;
ENTRY;
}
spin_unlock(&scrub->os_lock);
- if (scrub->os_file.sf_status == SS_COMPLETED)
+ if (scrub->os_file.sf_status == SS_COMPLETED) {
+ if (!(flags & SS_SET_FAILOUT))
+ flags |= SS_CLEAR_FAILOUT;
+
+ if (!(flags & SS_SET_DRYRUN))
+ flags |= SS_CLEAR_DRYRUN;
+
flags |= SS_RESET;
+ }
scrub->os_start_flags = flags;
thread_set_flags(thread, 0);
- rc = PTR_ERR(kthread_run(osd_scrub_main, dev, "OI_scrub"));
- if (IS_ERR_VALUE(rc)) {
- CERROR("%.16s: cannot start iteration thread, rc = %d\n",
+ task = kthread_run(osd_scrub_main, dev, "OI_scrub");
+ if (IS_ERR(task)) {
+ rc = PTR_ERR(task);
+ CERROR("%.16s: cannot start iteration thread: rc = %d\n",
LDISKFS_SB(osd_sb(dev))->s_es->s_volume_name, rc);
RETURN(rc);
}
init_waitqueue_head(&scrub->os_thread.t_ctl_waitq);
init_rwsem(&scrub->os_rwsem);
spin_lock_init(&scrub->os_lock);
- CFS_INIT_LIST_HEAD(&scrub->os_inconsistent_items);
+ INIT_LIST_HEAD(&scrub->os_inconsistent_items);
- push_ctxt(&saved, ctxt, NULL);
+ push_ctxt(&saved, ctxt);
filp = filp_open(osd_scrub_name, O_RDWR | O_CREAT, 0644);
if (IS_ERR(filp)) {
- pop_ctxt(&saved, ctxt, NULL);
+ pop_ctxt(&saved, ctxt);
RETURN(PTR_ERR(filp));
}
inode = filp->f_dentry->d_inode;
- ldiskfs_set_inode_state(inode, LDISKFS_STATE_LUSTRE_NO_OI);
/* 'What the @fid is' is not imporatant, because the object
* has no OI mapping, and only is visible inside the OSD.*/
lu_igif_build(fid, inode->i_ino, inode->i_generation);
rc = osd_ea_fid_set(info, inode, fid, LMAC_NOT_IN_OI, 0);
if (rc != 0) {
filp_close(filp, 0);
- pop_ctxt(&saved, ctxt, NULL);
+ pop_ctxt(&saved, ctxt);
RETURN(rc);
}
scrub->os_inode = igrab(inode);
filp_close(filp, 0);
- pop_ctxt(&saved, ctxt, NULL);
+ pop_ctxt(&saved, ctxt);
rc = osd_scrub_file_load(scrub);
if (rc == -ENOENT) {
!(sf->sf_internal_flags & SIF_NO_HANDLE_OLD_FID ||
sf->sf_success_count > 0)) {
dev->od_igif_inoi = 0;
- dev->od_check_ff = 1;
+ dev->od_check_ff = dev->od_is_ost;
} else {
dev->od_igif_inoi = 1;
dev->od_check_ff = 0;
start |= SS_CLEAR_FAILOUT;
}
+ if (valid & DOIV_DRYRUN) {
+ if (flags & DOIF_DRYRUN)
+ start |= SS_SET_DRYRUN;
+ else
+ start |= SS_CLEAR_DRYRUN;
+ }
+
rc = do_osd_scrub_start(dev, start);
if (rc < 0 && rc != -EALREADY) {
dev->od_otable_it = NULL;
if (unlikely(oii == NULL))
RETURN(-ENOMEM);
- CFS_INIT_LIST_HEAD(&oii->oii_list);
+ INIT_LIST_HEAD(&oii->oii_list);
oii->oii_cache = *oic;
oii->oii_insert = insert;
RETURN(-EAGAIN);
}
- if (cfs_list_empty(&scrub->os_inconsistent_items))
+ if (list_empty(&scrub->os_inconsistent_items))
wakeup = 1;
- cfs_list_add_tail(&oii->oii_list, &scrub->os_inconsistent_items);
+ list_add_tail(&oii->oii_list, &scrub->os_inconsistent_items);
spin_unlock(&scrub->os_lock);
if (wakeup != 0)
ENTRY;
spin_lock(&scrub->os_lock);
- cfs_list_for_each_entry(oii, &scrub->os_inconsistent_items, oii_list) {
+ list_for_each_entry(oii, &scrub->os_inconsistent_items, oii_list) {
if (lu_fid_eq(fid, &oii->oii_cache.oic_fid)) {
*id = oii->oii_cache.oic_lid;
spin_unlock(&scrub->os_lock);
static const char *scrub_param_names[] = {
"failout",
+ "dryrun",
NULL
};
-static int scrub_bits_dump(char **buf, int *len, int bits, const char *names[],
+static int scrub_bits_dump(struct seq_file *m, int bits, const char *names[],
const char *prefix)
{
- int save = *len;
int flag;
int rc;
int i;
- rc = snprintf(*buf, *len, "%s:%c", prefix, bits != 0 ? ' ' : '\n');
- if (rc <= 0)
- return -ENOSPC;
+ rc = seq_printf(m, "%s:%c", prefix, bits != 0 ? ' ' : '\n');
+ if (rc < 0)
+ return rc;
- *buf += rc;
- *len -= rc;
for (i = 0, flag = 1; bits != 0; i++, flag = 1 << i) {
if (flag & bits) {
bits &= ~flag;
- rc = snprintf(*buf, *len, "%s%c", names[i],
- bits != 0 ? ',' : '\n');
- if (rc <= 0)
- return -ENOSPC;
-
- *buf += rc;
- *len -= rc;
+ rc = seq_printf(m, "%s%c", names[i],
+ bits != 0 ? ',' : '\n');
+ if (rc < 0)
+ return rc;
}
}
- return save - *len;
+ return 0;
}
-static int scrub_time_dump(char **buf, int *len, __u64 time, const char *prefix)
+static int scrub_time_dump(struct seq_file *m, __u64 time, const char *prefix)
{
int rc;
if (time != 0)
- rc = snprintf(*buf, *len, "%s: "LPU64" seconds\n", prefix,
+ rc = seq_printf(m, "%s: "LPU64" seconds\n", prefix,
cfs_time_current_sec() - time);
else
- rc = snprintf(*buf, *len, "%s: N/A\n", prefix);
- if (rc <= 0)
- return -ENOSPC;
-
- *buf += rc;
- *len -= rc;
+ rc = seq_printf(m, "%s: N/A\n", prefix);
return rc;
}
-static int scrub_pos_dump(char **buf, int *len, __u64 pos, const char *prefix)
+static int scrub_pos_dump(struct seq_file *m, __u64 pos, const char *prefix)
{
int rc;
if (pos != 0)
- rc = snprintf(*buf, *len, "%s: "LPU64"\n", prefix, pos);
+ rc = seq_printf(m, "%s: "LPU64"\n", prefix, pos);
else
- rc = snprintf(*buf, *len, "%s: N/A\n", prefix);
- if (rc <= 0)
- return -ENOSPC;
-
- *buf += rc;
- *len -= rc;
+ rc = seq_printf(m, "%s: N/A\n", prefix);
return rc;
}
-int osd_scrub_dump(struct osd_device *dev, char *buf, int len)
+int osd_scrub_dump(struct seq_file *m, struct osd_device *dev)
{
struct osd_scrub *scrub = &dev->od_scrub;
struct scrub_file *sf = &scrub->os_file;
__u64 checked;
__u64 speed;
- int save = len;
- int ret = -ENOSPC;
int rc;
down_read(&scrub->os_rwsem);
- rc = snprintf(buf, len,
- "name: OI_scrub\n"
- "magic: 0x%x\n"
- "oi_files: %d\n"
- "status: %s\n",
- sf->sf_magic, (int)sf->sf_oi_count,
- scrub_status_names[sf->sf_status]);
- if (rc <= 0)
+ rc = seq_printf(m, "name: OI_scrub\n"
+ "magic: 0x%x\n"
+ "oi_files: %d\n"
+ "status: %s\n",
+ sf->sf_magic, (int)sf->sf_oi_count,
+ scrub_status_names[sf->sf_status]);
+ if (rc < 0)
goto out;
- buf += rc;
- len -= rc;
- rc = scrub_bits_dump(&buf, &len, sf->sf_flags, scrub_flags_names,
+ rc = scrub_bits_dump(m, sf->sf_flags, scrub_flags_names,
"flags");
if (rc < 0)
goto out;
- rc = scrub_bits_dump(&buf, &len, sf->sf_param, scrub_param_names,
+ rc = scrub_bits_dump(m, sf->sf_param, scrub_param_names,
"param");
if (rc < 0)
goto out;
- rc = scrub_time_dump(&buf, &len, sf->sf_time_last_complete,
+ rc = scrub_time_dump(m, sf->sf_time_last_complete,
"time_since_last_completed");
if (rc < 0)
goto out;
- rc = scrub_time_dump(&buf, &len, sf->sf_time_latest_start,
+ rc = scrub_time_dump(m, sf->sf_time_latest_start,
"time_since_latest_start");
if (rc < 0)
goto out;
- rc = scrub_time_dump(&buf, &len, sf->sf_time_last_checkpoint,
+ rc = scrub_time_dump(m, sf->sf_time_last_checkpoint,
"time_since_last_checkpoint");
if (rc < 0)
goto out;
- rc = scrub_pos_dump(&buf, &len, sf->sf_pos_latest_start,
+ rc = scrub_pos_dump(m, sf->sf_pos_latest_start,
"latest_start_position");
if (rc < 0)
goto out;
- rc = scrub_pos_dump(&buf, &len, sf->sf_pos_last_checkpoint,
+ rc = scrub_pos_dump(m, sf->sf_pos_last_checkpoint,
"last_checkpoint_position");
if (rc < 0)
goto out;
- rc = scrub_pos_dump(&buf, &len, sf->sf_pos_first_inconsistent,
+ rc = scrub_pos_dump(m, sf->sf_pos_first_inconsistent,
"first_failure_position");
if (rc < 0)
goto out;
checked = sf->sf_items_checked + scrub->os_new_checked;
- rc = snprintf(buf, len,
- "checked: "LPU64"\n"
+ rc = seq_printf(m, "checked: "LPU64"\n"
"updated: "LPU64"\n"
"failed: "LPU64"\n"
"prior_updated: "LPU64"\n"
checked, sf->sf_items_updated, sf->sf_items_failed,
sf->sf_items_updated_prior, sf->sf_items_noscrub,
sf->sf_items_igif, sf->sf_success_count);
- if (rc <= 0)
+ if (rc < 0)
goto out;
- buf += rc;
- len -= rc;
speed = checked;
if (thread_is_running(&scrub->os_thread)) {
cfs_duration_t duration = cfs_time_current() -
do_div(new_checked, duration);
if (rtime != 0)
do_div(speed, rtime);
- rc = snprintf(buf, len,
- "run_time: %u seconds\n"
+ rc = seq_printf(m, "run_time: %u seconds\n"
"average_speed: "LPU64" objects/sec\n"
"real-time_speed: "LPU64" objects/sec\n"
"current_position: %u\n"
} else {
if (sf->sf_run_time != 0)
do_div(speed, sf->sf_run_time);
- rc = snprintf(buf, len,
- "run_time: %u seconds\n"
+ rc = seq_printf(m, "run_time: %u seconds\n"
"average_speed: "LPU64" objects/sec\n"
"real-time_speed: N/A\n"
"current_position: N/A\n"
sf->sf_run_time, speed, scrub->os_lf_scanned,
scrub->os_lf_repaired, scrub->os_lf_failed);
}
- if (rc <= 0)
- goto out;
-
- buf += rc;
- len -= rc;
- ret = save - len;
out:
up_read(&scrub->os_rwsem);
- return ret;
+ return (rc < 0 ? -ENOSPC : 0);
}