int osp_init_pre_fid(struct osp_device *osp)
{
struct lu_env env;
struct osp_thread_info *osi;
struct lu_client_seq *cli_seq;
struct lu_fid *last_fid;
int rc;
ENTRY;
LASSERT(osp->opd_pre != NULL);
/* Return if last_used fid has been initialized */
if (!fid_is_zero(&osp->opd_last_used_fid))
RETURN(0);
rc = lu_env_init(&env, osp->opd_dt_dev.dd_lu_dev.ld_type->ldt_ctx_tags);
if (rc) {
CERROR("%s: init env error: rc = %d\n",
osp->opd_obd->obd_name, rc);
RETURN(rc);
}
osi = osp_env_info(&env);
last_fid = &osi->osi_fid;
fid_zero(last_fid);
/* For a freshed fs, it will allocate a new sequence first */
if (osp_is_fid_client(osp) && osp->opd_group != 0) {
cli_seq = osp->opd_obd->u.cli.cl_seq;
rc = seq_client_get_seq(&env, cli_seq, &last_fid->f_seq);
if (rc != 0) {
CERROR("%s: alloc fid error: rc = %d\n",
osp->opd_obd->obd_name, rc);
GOTO(out, rc);
}
} else {
last_fid->f_seq = fid_idif_seq(0, osp->opd_index);
}
last_fid->f_oid = 1;
last_fid->f_ver = 0;
spin_lock(&osp->opd_pre_lock);
osp->opd_last_used_fid = *last_fid;
osp->opd_pre_used_fid = *last_fid;
osp->opd_pre_last_created_fid = *last_fid;
spin_unlock(&osp->opd_pre_lock);
rc = osp_write_last_oid_seq_files(&env, osp, last_fid, 1);
if (rc != 0) {
CERROR("%s: write fid error: rc = %d\n",
osp->opd_obd->obd_name, rc);
GOTO(out, rc);
}
out:
lu_env_fini(&env);
RETURN(rc);
}
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 osp_object_create(const struct lu_env *env, struct dt_object *dt,
struct lu_attr *attr,
struct dt_allocation_hint *hint,
struct dt_object_format *dof, struct thandle *th)
{
struct osp_thread_info *osi = osp_env_info(env);
struct osp_device *d = lu2osp_dev(dt->do_lu.lo_dev);
struct osp_object *o = dt2osp_obj(dt);
int rc = 0;
struct lu_fid *fid = &osi->osi_fid;
ENTRY;
if (o->opo_reserved) {
/* regular case, fid is assigned holding trunsaction open */
osp_object_assign_fid(env, d, o);
}
memcpy(fid, lu_object_fid(&dt->do_lu), sizeof(*fid));
LASSERTF(fid_is_sane(fid), "fid for osp_obj %p is insane"DFID"!\n",
osp_obj, PFID(fid));
if (!o->opo_reserved) {
/* special case, id was assigned outside of transaction
* see comments in osp_declare_attr_set */
spin_lock(&d->opd_pre_lock);
osp_update_last_fid(d, fid);
spin_unlock(&d->opd_pre_lock);
}
CDEBUG(D_INODE, "fid for osp_obj %p is "DFID"!\n", osp_obj, PFID(fid));
/* If the precreate ends, it means it will be ready to rollover to
* the new sequence soon, all the creation should be synchronized,
* otherwise during replay, the replay fid will be inconsistent with
* last_used/create fid */
if (osp_precreate_end_seq(env, d) && osp_is_fid_client(d))
th->th_sync = 1;
/*
* it's OK if the import is inactive by this moment - id was created
* by OST earlier, we just need to maintain it consistently on the disk
* once import is reconnected, OSP will claim this and other objects
* used and OST either keep them, if they exist or recreate
*/
/* we might have lost precreated objects */
if (unlikely(d->opd_gap_count) > 0) {
spin_lock(&d->opd_pre_lock);
if (d->opd_gap_count > 0) {
int count = d->opd_gap_count;
ostid_set_id(&osi->osi_oi,
fid_oid(&d->opd_gap_start_fid));
d->opd_gap_count = 0;
spin_unlock(&d->opd_pre_lock);
CDEBUG(D_HA, "Writting gap "DFID"+%d in llog\n",
PFID(&d->opd_gap_start_fid), count);
/* real gap handling is disabled intil ORI-692 will be
* fixed, now we only report gaps */
} else {
spin_unlock(&d->opd_pre_lock);
}
}
/* new object, the very first ->attr_set()
* initializing attributes needs no logging */
o->opo_new = 1;
/* Only need update last_used oid file, seq file will only be update
* during seq rollover */
osp_objid_buf_prep(&osi->osi_lb, &osi->osi_off,
&d->opd_last_used_fid.f_oid, d->opd_index);
rc = dt_record_write(env, d->opd_last_used_oid_file, &osi->osi_lb,
&osi->osi_off, th);
CDEBUG(D_HA, "%s: Wrote last used FID: "DFID", index %d: %d\n",
d->opd_obd->obd_name, PFID(fid), d->opd_index, rc);
RETURN(rc);
}