int fid_is_on_ost(struct osd_thread_info *info, struct osd_device *osd,
const struct lu_fid *fid, enum oi_check_flags flags)
{
struct lu_seq_range *range = &info->oti_seq_range;
int rc;
ENTRY;
if (flags & OI_KNOWN_ON_OST)
RETURN(1);
if (unlikely(fid_is_local_file(fid) || fid_is_igif(fid) ||
fid_is_llog(fid)) || fid_is_name_llog(fid) ||
fid_is_quota(fid))
RETURN(0);
if (fid_is_idif(fid) || fid_is_last_id(fid))
RETURN(1);
if (!(flags & OI_CHECK_FLD))
RETURN(0);
rc = osd_fld_lookup(info->oti_env, osd, fid_seq(fid), range);
if (rc != 0) {
if (rc != -ENOENT)
CERROR("%s: lookup FLD "DFID": rc = %d\n",
osd_name(osd), PFID(fid), rc);
RETURN(0);
}
if (fld_range_is_ost(range))
RETURN(1);
RETURN(0);
}
static dmu_buf_t *osd_mkreg(const struct lu_env *env, struct osd_object *obj,
struct lu_attr *la, struct osd_thandle *oh)
{
const struct lu_fid *fid = lu_object_fid(&obj->oo_dt.do_lu);
dmu_buf_t *db;
int rc;
struct osd_device *osd = osd_obj2dev(obj);
LASSERT(S_ISREG(la->la_mode));
rc = __osd_object_create(env, obj, &db, oh->ot_tx, la);
if (rc)
return ERR_PTR(rc);
if ((fid_is_idif(fid) || fid_is_norm(fid) || fid_is_echo(fid)) &&
osd->od_is_ost) {
/* The minimum block size must be at least page size otherwise
* it will break the assumption in tgt_thread_big_cache where
* the array size is PTLRPC_MAX_BRW_PAGES. It will also affect
* RDMA due to subpage transfer size */
rc = -dmu_object_set_blocksize(osd->od_os, db->db_object,
PAGE_SIZE, 0, oh->ot_tx);
if (unlikely(rc)) {
CERROR("%s: can't change blocksize: %d\n",
osd->od_svname, rc);
return ERR_PTR(rc);
}
}
return db;
}
static inline int osp_objs_precreated(const struct lu_env *env,
struct osp_device *osp)
{
struct lu_fid *fid1 = &osp->opd_pre_last_created_fid;
struct lu_fid *fid2 = &osp->opd_pre_used_fid;
LASSERTF(fid_seq(fid1) == fid_seq(fid2),
"Created fid"DFID" Next fid "DFID"\n", PFID(fid1), PFID(fid2));
if (fid_is_idif(fid1)) {
struct ost_id *oi1 = &osp_env_info(env)->osi_oi;
struct ost_id *oi2 = &osp_env_info(env)->osi_oi2;
LASSERT(fid_is_idif(fid1) && fid_is_idif(fid2));
fid_to_ostid(fid1, oi1);
fid_to_ostid(fid2, oi2);
LASSERT(ostid_id(oi1) >= ostid_id(oi2));
return ostid_id(oi1) - ostid_id(oi2);
}
return fid_oid(fid1) - fid_oid(fid2);
}
/**
* alloc fids for precreation.
* rc = 0 Success, @grow is the count of real allocation.
* rc = 1 Current seq is used up.
* rc < 0 Other error.
**/
static int osp_precreate_fids(const struct lu_env *env, struct osp_device *osp,
struct lu_fid *fid, int *grow)
{
struct osp_thread_info *osi = osp_env_info(env);
__u64 end;
int i = 0;
if (fid_is_idif(fid)) {
struct lu_fid *last_fid;
struct ost_id *oi = &osi->osi_oi;
spin_lock(&osp->opd_pre_lock);
last_fid = &osp->opd_pre_last_created_fid;
fid_to_ostid(last_fid, oi);
end = min(ostid_id(oi) + *grow, IDIF_MAX_OID);
*grow = end - ostid_id(oi);
ostid_set_id(oi, ostid_id(oi) + *grow);
spin_unlock(&osp->opd_pre_lock);
if (*grow == 0)
return 1;
ostid_to_fid(fid, oi, osp->opd_index);
return 0;
}
spin_lock(&osp->opd_pre_lock);
*fid = osp->opd_pre_last_created_fid;
end = fid->f_oid;
end = min((end + *grow), (__u64)LUSTRE_DATA_SEQ_MAX_WIDTH);
*grow = end - fid->f_oid;
fid->f_oid += end - fid->f_oid;
spin_unlock(&osp->opd_pre_lock);
CDEBUG(D_INFO, "Expect %d, actual %d ["DFID" -- "DFID"]\n",
*grow, i, PFID(fid), PFID(&osp->opd_pre_last_created_fid));
return *grow > 0 ? 0 : 1;
}
static int osp_precreate_send(const struct lu_env *env, struct osp_device *d)
{
struct osp_thread_info *oti = osp_env_info(env);
struct ptlrpc_request *req;
struct obd_import *imp;
struct ost_body *body;
int rc, grow, diff;
struct lu_fid *fid = &oti->osi_fid;
ENTRY;
/* don't precreate new objects till OST healthy and has free space */
if (unlikely(d->opd_pre_status)) {
CDEBUG(D_INFO, "%s: don't send new precreate: rc = %d\n",
d->opd_obd->obd_name, d->opd_pre_status);
RETURN(0);
}
/*
* if not connection/initialization is compeleted, ignore
*/
imp = d->opd_obd->u.cli.cl_import;
LASSERT(imp);
req = ptlrpc_request_alloc(imp, &RQF_OST_CREATE);
if (req == NULL)
RETURN(-ENOMEM);
req->rq_request_portal = OST_CREATE_PORTAL;
/* we should not resend create request - anyway we will have delorphan
* and kill these objects */
req->rq_no_delay = req->rq_no_resend = 1;
rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, OST_CREATE);
if (rc) {
ptlrpc_request_free(req);
RETURN(rc);
}
spin_lock(&d->opd_pre_lock);
if (d->opd_pre_grow_count > d->opd_pre_max_grow_count / 2)
d->opd_pre_grow_count = d->opd_pre_max_grow_count / 2;
grow = d->opd_pre_grow_count;
spin_unlock(&d->opd_pre_lock);
body = req_capsule_client_get(&req->rq_pill, &RMF_OST_BODY);
LASSERT(body);
*fid = d->opd_pre_last_created_fid;
rc = osp_precreate_fids(env, d, fid, &grow);
if (rc == 1) {
/* Current seq has been used up*/
if (!osp_is_fid_client(d)) {
osp_pre_update_status(d, -ENOSPC);
rc = -ENOSPC;
}
wake_up(&d->opd_pre_waitq);
GOTO(out_req, rc);
}
if (!osp_is_fid_client(d)) {
/* Non-FID client will always send seq 0 because of
* compatiblity */
LASSERTF(fid_is_idif(fid), "Invalid fid "DFID"\n", PFID(fid));
fid->f_seq = 0;
}
fid_to_ostid(fid, &body->oa.o_oi);
body->oa.o_valid = OBD_MD_FLGROUP;
ptlrpc_request_set_replen(req);
rc = ptlrpc_queue_wait(req);
if (rc) {
CERROR("%s: can't precreate: rc = %d\n", d->opd_obd->obd_name,
rc);
GOTO(out_req, rc);
}
LASSERT(req->rq_transno == 0);
body = req_capsule_server_get(&req->rq_pill, &RMF_OST_BODY);
if (body == NULL)
GOTO(out_req, rc = -EPROTO);
ostid_to_fid(fid, &body->oa.o_oi, d->opd_index);
LASSERTF(lu_fid_diff(fid, &d->opd_pre_used_fid) > 0,
"reply fid "DFID" pre used fid "DFID"\n", PFID(fid),
PFID(&d->opd_pre_used_fid));
diff = lu_fid_diff(fid, &d->opd_pre_last_created_fid);
spin_lock(&d->opd_pre_lock);
if (diff < grow) {
/* the OST has not managed to create all the
* objects we asked for */
d->opd_pre_grow_count = max(diff, OST_MIN_PRECREATE);
d->opd_pre_grow_slow = 1;
} else {
/* the OST is able to keep up with the work,
* we could consider increasing grow_count
* next time if needed */
d->opd_pre_grow_slow = 0;
}
d->opd_pre_last_created_fid = *fid;
spin_unlock(&d->opd_pre_lock);
CDEBUG(D_HA, "%s: current precreated pool: "DFID"-"DFID"\n",
d->opd_obd->obd_name, PFID(&d->opd_pre_used_fid),
PFID(&d->opd_pre_last_created_fid));
out_req:
/* now we can wakeup all users awaiting for objects */
osp_pre_update_status(d, rc);
wake_up(&d->opd_pre_user_waitq);
ptlrpc_req_finished(req);
RETURN(rc);
}
static int lfsck_master_oit_engine(const struct lu_env *env,
struct lfsck_instance *lfsck)
{
struct lfsck_thread_info *info = lfsck_env_info(env);
const struct dt_it_ops *iops =
&lfsck->li_obj_oit->do_index_ops->dio_it;
struct dt_it *di = lfsck->li_di_oit;
struct lu_fid *fid = &info->lti_fid;
struct lfsck_bookmark *bk = &lfsck->li_bookmark_ram;
struct ptlrpc_thread *thread = &lfsck->li_thread;
__u32 idx =
lfsck_dev_idx(lfsck->li_bottom);
int rc;
ENTRY;
do {
struct dt_object *target;
bool update_lma = false;
if (lfsck->li_di_dir != NULL) {
rc = lfsck_master_dir_engine(env, lfsck);
if (rc <= 0)
RETURN(rc);
}
if (unlikely(lfsck->li_oit_over))
RETURN(1);
if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_DELAY1) &&
cfs_fail_val > 0) {
struct l_wait_info lwi;
lwi = LWI_TIMEOUT(cfs_time_seconds(cfs_fail_val),
NULL, NULL);
l_wait_event(thread->t_ctl_waitq,
!thread_is_running(thread),
&lwi);
}
if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_CRASH))
RETURN(0);
lfsck->li_current_oit_processed = 1;
lfsck->li_new_scanned++;
rc = iops->rec(env, di, (struct dt_rec *)fid, 0);
if (rc != 0) {
lfsck_fail(env, lfsck, true);
if (rc < 0 && bk->lb_param & LPF_FAILOUT)
RETURN(rc);
else
goto checkpoint;
}
if (fid_is_idif(fid)) {
__u32 idx1 = fid_idif_ost_idx(fid);
LASSERT(!lfsck->li_master);
/* It is an old format device, update the LMA. */
if (idx != idx1) {
struct ost_id *oi = &info->lti_oi;
fid_to_ostid(fid, oi);
ostid_to_fid(fid, oi, idx);
update_lma = true;
}
} else if (!fid_is_norm(fid) && !fid_is_igif(fid) &&
!fid_is_last_id(fid) && !fid_is_root(fid) &&
!fid_seq_is_dot(fid_seq(fid))) {
/* If the FID/object is only used locally and invisible
* to external nodes, then LFSCK will not handle it. */
goto checkpoint;
}
target = lfsck_object_find(env, lfsck, fid);
if (target == NULL) {
goto checkpoint;
} else if (IS_ERR(target)) {
lfsck_fail(env, lfsck, true);
if (bk->lb_param & LPF_FAILOUT)
RETURN(PTR_ERR(target));
else
goto checkpoint;
}
/* XXX: Currently, skip remote object, the consistency for
* remote object will be processed in LFSCK phase III. */
if (dt_object_exists(target) && !dt_object_remote(target)) {
if (update_lma)
rc = lfsck_update_lma(env, lfsck, target);
if (rc == 0)
rc = lfsck_exec_oit(env, lfsck, target);
}
lfsck_object_put(env, target);
if (rc != 0 && bk->lb_param & LPF_FAILOUT)
RETURN(rc);
checkpoint:
rc = lfsck_checkpoint(env, lfsck);
if (rc != 0 && bk->lb_param & LPF_FAILOUT)
RETURN(rc);
/* Rate control. */
lfsck_control_speed(lfsck);
if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_FATAL1)) {
spin_lock(&lfsck->li_lock);
thread_set_flags(thread, SVC_STOPPING);
spin_unlock(&lfsck->li_lock);
RETURN(-EINVAL);
}
rc = iops->next(env, di);
if (unlikely(rc > 0))
lfsck->li_oit_over = 1;
else if (likely(rc == 0))
lfsck->li_current_oit_processed = 0;
if (unlikely(!thread_is_running(thread)))
RETURN(0);
} while (rc == 0 || lfsck->li_di_dir != NULL);
RETURN(rc);
}
