/**
* Verify single object for parent FID consistency.
*
* Part of LFSCK processing which checks single object PFID stored in extended
* attribute (XATTR) against real FID of MDT parent object received by LFSCK.
* This verifies that the OST object is being referenced by only a single MDT
* object.
*
* \param[in] env execution environment
* \param[in] ofd OFD device
* \param[in] oii object-related local data
* \param[in] lr LFSCK request data
*/
static void ofd_inconsistency_verify_one(const struct lu_env *env,
struct ofd_device *ofd,
struct ofd_inconsistency_item *oii,
struct lfsck_request *lr)
{
struct ofd_object *fo = oii->oii_obj;
struct lu_fid *pfid = &fo->ofo_pfid;
int rc;
LASSERT(fo->ofo_pfid_checking);
LASSERT(!fo->ofo_pfid_verified);
lr->lr_fid = fo->ofo_header.loh_fid; /* OST-object itself FID. */
lr->lr_fid2 = oii->oii_pfid; /* client given PFID. */
lr->lr_fid3 = *pfid; /* OST local stored PFID. */
rc = lfsck_in_notify(env, ofd->ofd_osd, lr, NULL);
ofd_write_lock(env, fo);
switch (lr->lr_status) {
case LPVS_INIT:
LASSERT(rc <= 0);
if (rc < 0)
CDEBUG(D_LFSCK, "%s: fail to verify OST local stored "
"PFID xattr for "DFID", the client given PFID "
DFID", OST local stored PFID "DFID": rc = %d\n",
ofd_name(ofd), PFID(&fo->ofo_header.loh_fid),
PFID(&oii->oii_pfid), PFID(pfid), rc);
else
fo->ofo_pfid_verified = 1;
break;
case LPVS_INCONSISTENT:
LASSERT(rc != 0);
ofd->ofd_inconsistency_self_detected++;
if (rc < 0)
CDEBUG(D_LFSCK, "%s: fail to verify the client given "
"PFID for "DFID", the client given PFID "DFID
", local stored PFID "DFID": rc = %d\n",
ofd_name(ofd), PFID(&fo->ofo_header.loh_fid),
PFID(&oii->oii_pfid), PFID(pfid), rc);
else
CDEBUG(D_LFSCK, "%s: both the client given PFID and "
"the OST local stored PFID are stale for the "
"OST-object "DFID", client given PFID is "DFID
", local stored PFID is "DFID"\n",
ofd_name(ofd), PFID(&fo->ofo_header.loh_fid),
PFID(&oii->oii_pfid), PFID(pfid));
break;
case LPVS_INCONSISTENT_TOFIX:
ofd->ofd_inconsistency_self_detected++;
if (rc == 0) {
ofd->ofd_inconsistency_self_repaired++;
CDEBUG(D_LFSCK, "%s: fixed the staled OST PFID xattr "
"for "DFID", with the client given PFID "DFID
", the old stored PFID "DFID"\n",
ofd_name(ofd), PFID(&fo->ofo_header.loh_fid),
PFID(&oii->oii_pfid), PFID(pfid));
} else if (rc < 0) {
CDEBUG(D_LFSCK, "%s: fail to fix the OST PFID xattr "
"for "DFID", client given PFID "DFID", local "
"stored PFID "DFID": rc = %d\n",
ofd_name(ofd), PFID(&fo->ofo_header.loh_fid),
PFID(&oii->oii_pfid), PFID(pfid), rc);
}
*pfid = oii->oii_pfid;
fo->ofo_pfid_verified = 1;
break;
default:
break;
}
fo->ofo_pfid_checking = 0;
ofd_write_unlock(env, fo);
lu_object_put(env, &fo->ofo_obj.do_lu);
OBD_FREE_PTR(oii);
}
int ofd_precreate_objects(const struct lu_env *env, struct ofd_device *ofd,
obd_id id, struct ofd_seq *oseq, int nr, int sync)
{
struct ofd_thread_info *info = ofd_info(env);
struct ofd_object *fo = NULL;
struct dt_object *next;
struct thandle *th;
struct ofd_object **batch;
struct lu_fid *fid = &info->fti_fid;
obd_id tmp;
int rc;
int i;
int objects = 0;
int nr_saved = nr;
ENTRY;
/* Don't create objects beyond the valid range for this SEQ */
if (unlikely(fid_seq_is_mdt0(ostid_seq(&oseq->os_oi)) &&
(id + nr) >= IDIF_MAX_OID)) {
CERROR("%s:"DOSTID" hit the IDIF_MAX_OID (1<<48)!\n",
ofd_name(ofd), id, ostid_seq(&oseq->os_oi));
RETURN(rc = -ENOSPC);
} else if (unlikely(!fid_seq_is_mdt0(ostid_seq(&oseq->os_oi)) &&
(id + nr) >= OBIF_MAX_OID)) {
CERROR("%s:"DOSTID" hit the OBIF_MAX_OID (1<<32)!\n",
ofd_name(ofd), id, ostid_seq(&oseq->os_oi));
RETURN(rc = -ENOSPC);
}
OBD_ALLOC(batch, nr_saved * sizeof(struct ofd_object *));
if (batch == NULL)
RETURN(-ENOMEM);
info->fti_attr.la_valid = LA_TYPE | LA_MODE;
/*
* We mark object SUID+SGID to flag it for accepting UID+GID from
* client on first write. Currently the permission bits on the OST are
* never used, so this is OK.
*/
info->fti_attr.la_mode = S_IFREG | S_ISUID | S_ISGID | 0666;
info->fti_dof.dof_type = dt_mode_to_dft(S_IFREG);
/* Initialize a/c/m time so any client timestamp will always
* be newer and update the inode. ctime = 0 is also handled
* specially in osd_inode_setattr(). See LU-221, LU-1042 */
info->fti_attr.la_valid |= LA_ATIME | LA_MTIME | LA_CTIME;
info->fti_attr.la_atime = 0;
info->fti_attr.la_mtime = 0;
info->fti_attr.la_ctime = 0;
LASSERT(id != 0);
/* prepare objects */
*fid = *lu_object_fid(&oseq->os_lastid_obj->do_lu);
for (i = 0; i < nr; i++) {
rc = fid_set_id(fid, id + i);
if (rc != 0) {
if (i == 0)
GOTO(out, rc);
nr = i;
break;
}
fo = ofd_object_find(env, ofd, fid);
if (IS_ERR(fo)) {
if (i == 0)
GOTO(out, rc = PTR_ERR(fo));
nr = i;
break;
}
ofd_write_lock(env, fo);
batch[i] = fo;
}
info->fti_buf.lb_buf = &tmp;
info->fti_buf.lb_len = sizeof(tmp);
info->fti_off = 0;
th = ofd_trans_create(env, ofd);
if (IS_ERR(th))
GOTO(out, rc = PTR_ERR(th));
th->th_sync |= sync;
rc = dt_declare_record_write(env, oseq->os_lastid_obj, &info->fti_buf,
info->fti_off, th);
if (rc)
GOTO(trans_stop, rc);
for (i = 0; i < nr; i++) {
fo = batch[i];
LASSERT(fo);
if (unlikely(ofd_object_exists(fo))) {
/* object may exist being re-created by write replay */
CDEBUG(D_INODE, "object "LPX64"/"LPX64" exists: "
DFID"\n", ostid_seq(&oseq->os_oi), id,
PFID(lu_object_fid(&fo->ofo_obj.do_lu)));
continue;
}
next = ofd_object_child(fo);
LASSERT(next != NULL);
rc = dt_declare_create(env, next, &info->fti_attr, NULL,
&info->fti_dof, th);
if (rc) {
nr = i;
break;
}
}
rc = dt_trans_start_local(env, ofd->ofd_osd, th);
if (rc)
GOTO(trans_stop, rc);
CDEBUG(D_OTHER, "%s: create new object "DFID" nr %d\n",
ofd_name(ofd), PFID(fid), nr);
LASSERT(nr > 0);
/* When the LFSCK scanning the whole device to verify the LAST_ID file
* consistency, it will load the last_id into RAM firstly, and compare
* the last_id with each OST-object's ID. If the later one is larger,
* then it will regard the LAST_ID file crashed. But during the LFSCK
* scanning, the OFD may continue to create new OST-objects. Those new
* created OST-objects will have larger IDs than the LFSCK known ones.
* So from the LFSCK view, it needs to re-load the last_id from disk
* file, and if the latest last_id is still smaller than the object's
* ID, then the LAST_ID file is real crashed.
*
* To make above mechanism to work, before OFD pre-create OST-objects,
* it needs to update the LAST_ID file firstly, otherwise, the LFSCK
* may cannot get latest last_id although new OST-object created. */
if (!OBD_FAIL_CHECK(OBD_FAIL_LFSCK_SKIP_LASTID)) {
tmp = cpu_to_le64(id + nr - 1);
dt_write_lock(env, oseq->os_lastid_obj, 0);
rc = dt_record_write(env, oseq->os_lastid_obj,
&info->fti_buf, &info->fti_off, th);
dt_write_unlock(env, oseq->os_lastid_obj);
if (rc != 0)
GOTO(trans_stop, rc);
}
for (i = 0; i < nr; i++) {
fo = batch[i];
LASSERT(fo);
/* Only the new created objects need to be recorded. */
if (ofd->ofd_osd->dd_record_fid_accessed) {
lfsck_pack_rfa(&ofd_info(env)->fti_lr,
lu_object_fid(&fo->ofo_obj.do_lu));
lfsck_in_notify(env, ofd->ofd_osd,
&ofd_info(env)->fti_lr);
}
if (likely(!ofd_object_exists(fo) &&
!OBD_FAIL_CHECK(OBD_FAIL_LFSCK_DANGLING))) {
next = ofd_object_child(fo);
LASSERT(next != NULL);
rc = dt_create(env, next, &info->fti_attr, NULL,
&info->fti_dof, th);
if (rc)
break;
LASSERT(ofd_object_exists(fo));
}
ofd_seq_last_oid_set(oseq, id + i);
}
objects = i;
/* NOT all the wanted objects have been created,
* set the LAST_ID as the real created. */
if (unlikely(objects < nr)) {
int rc1;
info->fti_off = 0;
tmp = cpu_to_le64(ofd_seq_last_oid(oseq));
dt_write_lock(env, oseq->os_lastid_obj, 0);
rc1 = dt_record_write(env, oseq->os_lastid_obj,
&info->fti_buf, &info->fti_off, th);
dt_write_unlock(env, oseq->os_lastid_obj);
if (rc1 != 0)
CERROR("%s: fail to reset the LAST_ID for seq ("LPX64
") from "LPU64" to "LPU64"\n", ofd_name(ofd),
ostid_seq(&oseq->os_oi), id + nr - 1,
ofd_seq_last_oid(oseq));
}
trans_stop:
ofd_trans_stop(env, ofd, th, rc);
out:
for (i = 0; i < nr_saved; i++) {
fo = batch[i];
if (fo) {
ofd_write_unlock(env, fo);
ofd_object_put(env, fo);
}
}
OBD_FREE(batch, nr_saved * sizeof(struct ofd_object *));
CDEBUG((objects == 0 && rc == 0) ? D_ERROR : D_OTHER,
"created %d/%d objects: %d\n", objects, nr_saved, rc);
LASSERT(ergo(objects == 0, rc < 0));
RETURN(objects > 0 ? objects : rc);
}