struct ost_id *oi2 = &osp_env_info(env)->osi_oi2;
LASSERT(fid_is_idif(fid1) && fid_is_idif(fid2));
- ostid_idif_pack(fid1, oi1);
- ostid_idif_pack(fid2, oi2);
- LASSERT(oi1->oi_id >= oi2->oi_id);
+ fid_to_ostid(fid1, oi1);
+ fid_to_ostid(fid2, oi2);
+ LASSERT(ostid_id(oi1) >= ostid_id(oi2));
- return oi1->oi_id - oi2->oi_id;
+ return ostid_id(oi1) - ostid_id(oi2);
}
return fid_oid(fid1) - fid_oid(fid2);
return rc;
}
+static inline int osp_create_end_seq(const struct lu_env *env,
+ struct osp_device *osp)
+{
+ struct lu_fid *fid = &osp->opd_pre_used_fid;
+ int rc;
+
+ spin_lock(&osp->opd_pre_lock);
+ rc = osp_fid_end_seq(env, fid);
+ spin_unlock(&osp->opd_pre_lock);
+ return rc;
+}
+
/**
* Write fid into last_oid/last_seq file.
**/
RETURN(rc);
}
+int osp_precreate_rollover_new_seq(struct lu_env *env, struct osp_device *osp)
+{
+ struct lu_fid *fid = &osp_env_info(env)->osi_fid;
+ struct lu_fid *last_fid = &osp->opd_last_used_fid;
+ int rc;
+ ENTRY;
+
+ rc = seq_client_get_seq(env, osp->opd_obd->u.cli.cl_seq, &fid->f_seq);
+ if (rc != 0) {
+ CERROR("%s: alloc fid error: rc = %d\n",
+ osp->opd_obd->obd_name, rc);
+ RETURN(rc);
+ }
+
+ fid->f_oid = 1;
+ fid->f_ver = 0;
+ LASSERTF(fid_seq(fid) != fid_seq(last_fid),
+ "fid "DFID", last_fid "DFID"\n", PFID(fid),
+ PFID(last_fid));
+
+ rc = osp_write_last_oid_seq_files(env, osp, fid, 1);
+ if (rc != 0) {
+ CERROR("%s: Can not update oid/seq file: rc = %d\n",
+ osp->opd_obd->obd_name, rc);
+ RETURN(rc);
+ }
+
+ LCONSOLE_INFO("%s: update sequence from "LPX64" to "LPX64"\n",
+ osp->opd_obd->obd_name, fid_seq(last_fid),
+ fid_seq(fid));
+ /* Update last_xxx to the new seq */
+ spin_lock(&osp->opd_pre_lock);
+ osp->opd_last_used_fid = *fid;
+ osp->opd_gap_start_fid = *fid;
+ osp->opd_pre_used_fid = *fid;
+ osp->opd_pre_last_created_fid = *fid;
+ spin_unlock(&osp->opd_pre_lock);
+
+ RETURN(rc);
+}
+
/**
* alloc fids for precreation.
* rc = 0 Success, @grow is the count of real allocation.
spin_lock(&osp->opd_pre_lock);
last_fid = &osp->opd_pre_last_created_fid;
- ostid_idif_pack(last_fid, oi);
- end = min(oi->oi_id + *grow, IDIF_MAX_OID);
- *grow = end - oi->oi_id;
- oi->oi_id += *grow;
+ 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_idif_unpack(oi, fid, osp->opd_index);
+ ostid_to_fid(fid, oi, osp->opd_index);
return 0;
}
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*/
fid->f_seq = 0;
}
- ostid_fid_pack(fid, &body->oa.o_oi);
+ fid_to_ostid(fid, &body->oa.o_oi);
body->oa.o_valid = OBD_MD_FLGROUP;
ptlrpc_request_set_replen(req);
if (body == NULL)
GOTO(out_req, rc = -EPROTO);
- fid_ostid_unpack(fid, &body->oa.o_oi, d->opd_index);
+ 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));
- CDEBUG(D_HA, "%s: new last_created "DFID"\n", d->opd_obd->obd_name,
- PFID(fid));
-
diff = lu_fid_diff(fid, &d->opd_pre_last_created_fid);
spin_lock(&d->opd_pre_lock);
d->opd_pre_last_created_fid = *fid;
spin_unlock(&d->opd_pre_lock);
- CDEBUG(D_OTHER, "current precreated pool: "DFID"-"DFID"\n",
- PFID(&d->opd_pre_used_fid), PFID(&d->opd_pre_last_created_fid));
+ 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);
RETURN(rc);
}
-static int osp_get_lastfid_from_ost(struct osp_device *d)
+static int osp_get_lastfid_from_ost(const struct lu_env *env,
+ struct osp_device *d)
{
struct ptlrpc_request *req = NULL;
struct obd_import *imp;
- struct lu_fid *last_fid = &d->opd_last_used_fid;
+ struct lu_fid *last_fid;
char *tmp;
int rc;
ENTRY;
if (req == NULL)
RETURN(-ENOMEM);
- req_capsule_set_size(&req->rq_pill, &RMF_SETINFO_KEY,
- RCL_CLIENT, sizeof(KEY_LAST_FID));
+ req_capsule_set_size(&req->rq_pill, &RMF_SETINFO_KEY, RCL_CLIENT,
+ sizeof(KEY_LAST_FID));
- req_capsule_set_size(&req->rq_pill, &RMF_SETINFO_VAL,
- RCL_CLIENT, sizeof(*last_fid));
+ req_capsule_set_size(&req->rq_pill, &RMF_SETINFO_VAL, RCL_CLIENT,
+ sizeof(struct lu_fid));
rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, OST_GET_INFO);
if (rc) {
memcpy(tmp, KEY_LAST_FID, sizeof(KEY_LAST_FID));
req->rq_no_delay = req->rq_no_resend = 1;
- fid_cpu_to_le(last_fid, last_fid);
tmp = req_capsule_client_get(&req->rq_pill, &RMF_SETINFO_VAL);
- memcpy(tmp, last_fid, sizeof(*last_fid));
+ fid_cpu_to_le((struct lu_fid *)tmp, &d->opd_last_used_fid);
ptlrpc_request_set_replen(req);
rc = ptlrpc_queue_wait(req);
}
last_fid = req_capsule_server_get(&req->rq_pill, &RMF_FID);
- if (last_fid == NULL || !fid_is_sane(last_fid)) {
+ if (last_fid == NULL) {
+ CERROR("%s: Got last_fid failed.\n", d->opd_obd->obd_name);
+ GOTO(out, rc = -EPROTO);
+ }
+
+ if (!fid_is_sane(last_fid)) {
CERROR("%s: Got insane last_fid "DFID"\n",
d->opd_obd->obd_name, PFID(last_fid));
GOTO(out, rc = -EPROTO);
if (fid_oid(last_fid) > 0)
d->opd_last_used_fid = *last_fid;
- CDEBUG(D_HA, "%s: Got insane last_fid "DFID"\n", d->opd_obd->obd_name,
+ CDEBUG(D_HA, "%s: Got last_fid "DFID"\n", d->opd_obd->obd_name,
PFID(last_fid));
out:
LASSERT(!fid_is_zero(last_fid));
if (fid_oid(&d->opd_last_used_fid) < 2) {
/* lastfid looks strange... ask OST */
- rc = osp_get_lastfid_from_ost(d);
+ rc = osp_get_lastfid_from_ost(env, d);
if (rc)
GOTO(out, rc);
}
body->oa.o_flags = OBD_FL_DELORPHAN;
body->oa.o_valid = OBD_MD_FLFLAGS | OBD_MD_FLGROUP;
- if (osp_is_fid_client(d))
- body->oa.o_seq = fid_seq(&d->opd_last_used_fid);
- else
- body->oa.o_seq = 0;
- /* remove from NEXT after used one */
- body->oa.o_id = fid_oid(&d->opd_last_used_fid);
+
+ fid_to_ostid(&d->opd_last_used_fid, &body->oa.o_oi);
ptlrpc_request_set_replen(req);
/*
* OST provides us with id new pool starts from in body->oa.o_id
*/
- fid_ostid_unpack(last_fid, &body->oa.o_oi, d->opd_index);
- CDEBUG(D_INFO, "%s: last_fid "DFID" server last fid "DFID"\n",
- d->opd_obd->obd_name, PFID(&d->opd_last_used_fid),
- PFID(last_fid));
+ ostid_to_fid(last_fid, &body->oa.o_oi, d->opd_index);
spin_lock(&d->opd_pre_lock);
diff = lu_fid_diff(&d->opd_last_used_fid, last_fid);
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)) {
+ 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) {
GOTO(out, rc);
}
} else {
- last_fid->f_seq = fid_idif_seq(1, osp->opd_index);
+ last_fid->f_seq = fid_idif_seq(0, osp->opd_index);
}
last_fid->f_oid = 1;
last_fid->f_ver = 0;
ENTRY;
- sprintf(pname, "osp-pre-%u\n", d->opd_index);
+ sprintf(pname, "osp-pre-%u", d->opd_index);
cfs_daemonize(pname);
rc = lu_env_init(&env, d->opd_dt_dev.dd_lu_dev.ld_type->ldt_ctx_tags);
d->opd_new_connection,
&lwi);
- if (!osp_precreate_running(d))
- break;
-
if (!d->opd_new_connection)
continue;
break;
}
+ if (!osp_precreate_running(d))
+ break;
+
+ LASSERT(d->opd_obd->u.cli.cl_seq != NULL);
if (d->opd_obd->u.cli.cl_seq->lcs_exp == NULL) {
/* Get new sequence for client first */
LASSERT(d->opd_exp != NULL);
if (osp_statfs_need_update(d))
osp_statfs_update(d);
+ /* To avoid handling different seq in precreate/orphan
+ * cleanup, it will hold precreate until current seq is
+ * used up. */
+ if (unlikely(osp_precreate_end_seq(&env, d) &&
+ !osp_create_end_seq(&env, d)))
+ continue;
+
+ if (unlikely(osp_precreate_end_seq(&env, d) &&
+ osp_create_end_seq(&env, d))) {
+ LCONSOLE_INFO("%s:"LPX64" is used up."
+ " Update to new seq\n",
+ d->opd_obd->obd_name,
+ fid_seq(&d->opd_pre_last_created_fid));
+ rc = osp_precreate_rollover_new_seq(&env, d);
+ if (rc)
+ continue;
+ }
+
if (osp_precreate_near_empty(&env, d)) {
rc = osp_precreate_send(&env, d);
/* osp_precreate_send() sets opd_pre_status
struct l_wait_info lwi;
cfs_time_t expire = cfs_time_shift(obd_timeout);
int precreated, rc;
- int count = 0;
ENTRY;
while ((rc = d->opd_pre_status) == 0 || rc == -ENOSPC ||
rc == -ENODEV || rc == -EAGAIN) {
-#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 3, 90, 0)
- /*
- * to address Andreas's concern on possible busy-loop
- * between this thread and osp_precreate_send()
- */
- if (unlikely(count++ == 1000)) {
- osp_precreate_timeout_condition(d);
- LBUG();
- }
-#endif
-
/*
* increase number of precreations
*/
rc = 0;
/* XXX: don't wake up if precreation is in progress */
- if (osp_precreate_near_empty_nolock(env, d))
+ if (osp_precreate_near_empty_nolock(env, d) &&
+ !osp_precreate_end_seq_nolock(env, d))
cfs_waitq_signal(&d->opd_pre_waitq);
break;
lwi = LWI_TIMEOUT(expire - cfs_time_current(),
osp_precreate_timeout_condition, d);
- if (cfs_time_aftereq(cfs_time_current(), expire))
+ if (cfs_time_aftereq(cfs_time_current(), expire)) {
+ rc = -ETIMEDOUT;
break;
+ }
l_wait_event(d->opd_pre_user_waitq,
osp_precreate_ready_condition(env, d), &lwi);
if (oa == NULL)
GOTO(out, rc = -ENOMEM);
- rc = fid_ostid_pack(lu_object_fid(&dt->do_lu), &oa->o_oi);
+ rc = fid_to_ostid(lu_object_fid(&dt->do_lu), &oa->o_oi);
LASSERT(rc == 0);
oa->o_size = size;
oa->o_blocks = OBD_OBJECT_EOF;
git://git.whamcloud.com / fs / lustre-release.git / blobdiff