/**
* Prepare buffers for read request processing.
*
* This function converts remote buffers from client to local buffers
* and prepares the latter.
*
* \param[in] env execution environment
* \param[in] exp OBD export of client
* \param[in] ofd OFD device
* \param[in] fid FID of object
* \param[in] la object attributes
* \param[in] oa OBDO structure from client
* \param[in] niocount number of remote buffers
* \param[in] rnb remote buffers
* \param[in] nr_local number of local buffers
* \param[in] lnb local buffers
* \param[in] jobid job ID name
*
* \retval 0 on successful prepare
* \retval negative value on error
*/
static int ofd_preprw_read(const struct lu_env *env, struct obd_export *exp,
struct ofd_device *ofd, const struct lu_fid *fid,
struct lu_attr *la, struct obdo *oa, int niocount,
struct niobuf_remote *rnb, int *nr_local,
struct niobuf_local *lnb, char *jobid)
{
struct ofd_object *fo;
int i, j, rc, tot_bytes = 0;
ENTRY;
LASSERT(env != NULL);
fo = ofd_object_find(env, ofd, fid);
if (IS_ERR(fo))
RETURN(PTR_ERR(fo));
LASSERT(fo != NULL);
ofd_read_lock(env, fo);
if (!ofd_object_exists(fo))
GOTO(unlock, rc = -ENOENT);
if (ofd->ofd_lfsck_verify_pfid && oa->o_valid & OBD_MD_FLFID) {
rc = ofd_verify_ff(env, fo, oa);
if (rc != 0)
GOTO(unlock, rc);
}
*nr_local = 0;
for (i = 0, j = 0; i < niocount; i++) {
rc = dt_bufs_get(env, ofd_object_child(fo), rnb + i,
lnb + j, 0);
if (unlikely(rc < 0))
GOTO(buf_put, rc);
LASSERT(rc <= PTLRPC_MAX_BRW_PAGES);
/* correct index for local buffers to continue with */
j += rc;
*nr_local += rc;
LASSERT(j <= PTLRPC_MAX_BRW_PAGES);
tot_bytes += rnb[i].rnb_len;
}
LASSERT(*nr_local > 0 && *nr_local <= PTLRPC_MAX_BRW_PAGES);
rc = dt_attr_get(env, ofd_object_child(fo), la);
if (unlikely(rc))
GOTO(buf_put, rc);
rc = dt_read_prep(env, ofd_object_child(fo), lnb, *nr_local);
if (unlikely(rc))
GOTO(buf_put, rc);
ofd_counter_incr(exp, LPROC_OFD_STATS_READ, jobid, tot_bytes);
RETURN(0);
buf_put:
dt_bufs_put(env, ofd_object_child(fo), lnb, *nr_local);
unlock:
ofd_read_unlock(env, fo);
ofd_object_put(env, fo);
return rc;
}
/**
* Drop reference on local buffers for read bulk IO.
*
* This will free all local buffers use by this read request.
*
* \param[in] env execution environment
* \param[in] ofd OFD device
* \param[in] fid object FID
* \param[in] objcount always 1
* \param[in] niocount number of local buffers
* \param[in] lnb local buffers
*
* \retval 0 on successful execution
* \retval negative value on error
*/
static int
ofd_commitrw_read(const struct lu_env *env, struct ofd_device *ofd,
const struct lu_fid *fid, int objcount, int niocount,
struct niobuf_local *lnb)
{
struct ofd_object *fo;
ENTRY;
LASSERT(niocount > 0);
fo = ofd_object_find(env, ofd, fid);
if (IS_ERR(fo))
RETURN(PTR_ERR(fo));
LASSERT(fo != NULL);
LASSERT(ofd_object_exists(fo));
dt_bufs_put(env, ofd_object_child(fo), lnb, niocount);
ofd_read_unlock(env, fo);
ofd_object_put(env, fo);
/* second put is pair to object_get in ofd_preprw_read */
ofd_object_put(env, fo);
RETURN(0);
}
/**
* Implementation of ldlm_valblock_ops::lvbo_init for OFD.
*
* This function allocates and initializes new LVB data for the given
* LDLM resource if it is not allocated yet. New LVB is filled with attributes
* of the object associated with that resource. Function does nothing if LVB
* for the given LDLM resource is allocated already.
*
* Called with res->lr_lvb_sem held.
*
* \param[in] res LDLM resource
*
* \retval 0 on successful setup
* \retval negative value on error
*/
static int ofd_lvbo_init(struct ldlm_resource *res)
{
struct ost_lvb *lvb;
struct ofd_device *ofd;
struct ofd_object *fo;
struct ofd_thread_info *info;
struct lu_env env;
int rc = 0;
ENTRY;
LASSERT(res);
LASSERT(mutex_is_locked(&res->lr_lvb_mutex));
if (res->lr_lvb_data != NULL)
RETURN(0);
ofd = ldlm_res_to_ns(res)->ns_lvbp;
LASSERT(ofd != NULL);
if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_OST_LVB))
RETURN(-ENOMEM);
rc = lu_env_init(&env, LCT_DT_THREAD);
if (rc)
RETURN(rc);
OBD_ALLOC_PTR(lvb);
if (lvb == NULL)
GOTO(out_env, rc = -ENOMEM);
res->lr_lvb_data = lvb;
res->lr_lvb_len = sizeof(*lvb);
info = ofd_info_init(&env, NULL);
ost_fid_from_resid(&info->fti_fid, &res->lr_name,
ofd->ofd_lut.lut_lsd.lsd_osd_index);
fo = ofd_object_find(&env, ofd, &info->fti_fid);
if (IS_ERR(fo))
GOTO(out_lvb, rc = PTR_ERR(fo));
rc = ofd_attr_get(&env, fo, &info->fti_attr);
if (rc)
GOTO(out_obj, rc);
lvb->lvb_size = info->fti_attr.la_size;
lvb->lvb_blocks = info->fti_attr.la_blocks;
lvb->lvb_mtime = info->fti_attr.la_mtime;
lvb->lvb_atime = info->fti_attr.la_atime;
lvb->lvb_ctime = info->fti_attr.la_ctime;
CDEBUG(D_DLMTRACE, "res: "DFID" initial lvb size: "LPU64", "
"mtime: "LPX64", blocks: "LPX64"\n",
PFID(&info->fti_fid), lvb->lvb_size,
lvb->lvb_mtime, lvb->lvb_blocks);
EXIT;
out_obj:
ofd_object_put(&env, fo);
out_lvb:
if (rc != 0)
OST_LVB_SET_ERR(lvb->lvb_blocks, rc);
out_env:
lu_env_fini(&env);
/* Don't free lvb data on lookup error */
return rc;
}
/**
* Implementation of ldlm_valblock_ops::lvbo_update for OFD.
*
* When a client generates a glimpse enqueue, it wants to get the current
* file size and updated attributes for a stat() type operation, but these
* attributes may be writeback cached on another client. The client with
* the DLM extent lock at the highest offset is asked for its current
* attributes via a glimpse callback on its extent lock, on the assumption
* that it has the highest file size and the newest timestamps. The timestamps
* are guaranteed to be correct if there is only a single writer on the file,
* but may be slightly inaccurate if there are multiple concurrent writers on
* the same object. In order to avoid race conditions between the glimpse AST
* and the client cancelling the lock, ofd_lvbo_update() also updates
* the attributes from the local object. If the last client hasn't done any
* writes yet, or has already written its data and cancelled its lock before
* it processed the glimpse, then the local inode will have more uptodate
* information.
*
* This is called in two ways:
* \a req != NULL : called by the DLM itself after a glimpse callback
* \a req == NULL : called by the OFD after a disk write
*
* \param[in] res LDLM resource
* \param[in] req PTLRPC request
* \param[in] increase_only don't allow LVB values to decrease
*
* \retval 0 on successful setup
* \retval negative value on error
*/
static int ofd_lvbo_update(struct ldlm_resource *res,
struct ptlrpc_request *req, int increase_only)
{
struct ofd_device *ofd;
struct ofd_object *fo;
struct ofd_thread_info *info;
struct ost_lvb *lvb;
struct lu_env env;
int rc = 0;
ENTRY;
LASSERT(res != NULL);
ofd = ldlm_res_to_ns(res)->ns_lvbp;
LASSERT(ofd != NULL);
rc = lu_env_init(&env, LCT_DT_THREAD);
if (rc)
RETURN(rc);
info = ofd_info_init(&env, NULL);
fid_extract_from_res_name(&info->fti_fid, &res->lr_name);
lvb = res->lr_lvb_data;
if (lvb == NULL) {
CERROR("%s: no LVB data for "DFID"\n",
ofd_name(ofd), PFID(&info->fti_fid));
GOTO(out_env, rc = 0);
}
/* Update the LVB from the network message */
if (req != NULL) {
struct ost_lvb *rpc_lvb;
bool lvb_type;
if (req->rq_import != NULL)
lvb_type = imp_connect_lvb_type(req->rq_import);
else
lvb_type = exp_connect_lvb_type(req->rq_export);
if (!lvb_type) {
struct ost_lvb_v1 *lvb_v1;
lvb_v1 = req_capsule_server_swab_get(&req->rq_pill,
&RMF_DLM_LVB, lustre_swab_ost_lvb_v1);
if (lvb_v1 == NULL)
goto disk_update;
rpc_lvb = &info->fti_lvb;
memcpy(rpc_lvb, lvb_v1, sizeof *lvb_v1);
rpc_lvb->lvb_mtime_ns = 0;
rpc_lvb->lvb_atime_ns = 0;
rpc_lvb->lvb_ctime_ns = 0;
} else {
rpc_lvb = req_capsule_server_swab_get(&req->rq_pill,
&RMF_DLM_LVB,
lustre_swab_ost_lvb);
if (rpc_lvb == NULL)
goto disk_update;
}
lock_res(res);
if (rpc_lvb->lvb_size > lvb->lvb_size || !increase_only) {
CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb size: "
LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
lvb->lvb_size, rpc_lvb->lvb_size);
lvb->lvb_size = rpc_lvb->lvb_size;
}
if (rpc_lvb->lvb_mtime > lvb->lvb_mtime || !increase_only) {
CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb mtime: "
LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
lvb->lvb_mtime, rpc_lvb->lvb_mtime);
lvb->lvb_mtime = rpc_lvb->lvb_mtime;
}
if (rpc_lvb->lvb_atime > lvb->lvb_atime || !increase_only) {
CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb atime: "
LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
lvb->lvb_atime, rpc_lvb->lvb_atime);
lvb->lvb_atime = rpc_lvb->lvb_atime;
}
if (rpc_lvb->lvb_ctime > lvb->lvb_ctime || !increase_only) {
CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb ctime: "
LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
lvb->lvb_ctime, rpc_lvb->lvb_ctime);
lvb->lvb_ctime = rpc_lvb->lvb_ctime;
}
if (rpc_lvb->lvb_blocks > lvb->lvb_blocks || !increase_only) {
CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb blocks: "
LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
lvb->lvb_blocks, rpc_lvb->lvb_blocks);
lvb->lvb_blocks = rpc_lvb->lvb_blocks;
}
unlock_res(res);
}
disk_update:
/* Update the LVB from the disk inode */
ost_fid_from_resid(&info->fti_fid, &res->lr_name,
ofd->ofd_lut.lut_lsd.lsd_osd_index);
fo = ofd_object_find(&env, ofd, &info->fti_fid);
if (IS_ERR(fo))
GOTO(out_env, rc = PTR_ERR(fo));
rc = ofd_attr_get(&env, fo, &info->fti_attr);
if (rc)
GOTO(out_obj, rc);
lock_res(res);
if (info->fti_attr.la_size > lvb->lvb_size || !increase_only) {
CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb size from disk: "
LPU64" -> %llu\n", PFID(&info->fti_fid),
lvb->lvb_size, info->fti_attr.la_size);
lvb->lvb_size = info->fti_attr.la_size;
}
if (info->fti_attr.la_mtime >lvb->lvb_mtime || !increase_only) {
CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb mtime from disk: "
LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
lvb->lvb_mtime, info->fti_attr.la_mtime);
lvb->lvb_mtime = info->fti_attr.la_mtime;
}
if (info->fti_attr.la_atime >lvb->lvb_atime || !increase_only) {
CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb atime from disk: "
LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
lvb->lvb_atime, info->fti_attr.la_atime);
lvb->lvb_atime = info->fti_attr.la_atime;
}
if (info->fti_attr.la_ctime >lvb->lvb_ctime || !increase_only) {
CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb ctime from disk: "
LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
lvb->lvb_ctime, info->fti_attr.la_ctime);
lvb->lvb_ctime = info->fti_attr.la_ctime;
}
if (info->fti_attr.la_blocks > lvb->lvb_blocks || !increase_only) {
CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb blocks from disk: "
LPU64" -> %llu\n", PFID(&info->fti_fid), lvb->lvb_blocks,
(unsigned long long)info->fti_attr.la_blocks);
lvb->lvb_blocks = info->fti_attr.la_blocks;
}
unlock_res(res);
out_obj:
ofd_object_put(&env, fo);
out_env:
lu_env_fini(&env);
return rc;
}
/**
* Prepare buffers for write request processing.
*
* This function converts remote buffers from client to local buffers
* and prepares the latter. If there is recovery in progress and required
* object is missing then it can be re-created before write.
*
* \param[in] env execution environment
* \param[in] exp OBD export of client
* \param[in] ofd OFD device
* \param[in] fid FID of object
* \param[in] la object attributes
* \param[in] oa OBDO structure from client
* \param[in] objcount always 1
* \param[in] obj object data
* \param[in] rnb remote buffers
* \param[in] nr_local number of local buffers
* \param[in] lnb local buffers
* \param[in] jobid job ID name
*
* \retval 0 on successful prepare
* \retval negative value on error
*/
static int ofd_preprw_write(const struct lu_env *env, struct obd_export *exp,
struct ofd_device *ofd, const struct lu_fid *fid,
struct lu_attr *la, struct obdo *oa,
int objcount, struct obd_ioobj *obj,
struct niobuf_remote *rnb, int *nr_local,
struct niobuf_local *lnb, char *jobid)
{
struct ofd_object *fo;
int i, j, k, rc = 0, tot_bytes = 0;
ENTRY;
LASSERT(env != NULL);
LASSERT(objcount == 1);
if (unlikely(exp->exp_obd->obd_recovering)) {
u64 seq = fid_seq(fid);
u64 oid = fid_oid(fid);
struct ofd_seq *oseq;
oseq = ofd_seq_load(env, ofd, seq);
if (IS_ERR(oseq)) {
CERROR("%s: Can't find FID Sequence "LPX64": rc = %d\n",
ofd_name(ofd), seq, (int)PTR_ERR(oseq));
GOTO(out, rc = -EINVAL);
}
if (oid > ofd_seq_last_oid(oseq)) {
int sync = 0;
int diff;
mutex_lock(&oseq->os_create_lock);
diff = oid - ofd_seq_last_oid(oseq);
/* Do sync create if the seq is about to used up */
if (fid_seq_is_idif(seq) || fid_seq_is_mdt0(seq)) {
if (unlikely(oid >= IDIF_MAX_OID - 1))
sync = 1;
} else if (fid_seq_is_norm(seq)) {
if (unlikely(oid >=
LUSTRE_DATA_SEQ_MAX_WIDTH - 1))
sync = 1;
} else {
CERROR("%s : invalid o_seq "DOSTID"\n",
ofd_name(ofd), POSTID(&oa->o_oi));
mutex_unlock(&oseq->os_create_lock);
ofd_seq_put(env, oseq);
GOTO(out, rc = -EINVAL);
}
while (diff > 0) {
u64 next_id = ofd_seq_last_oid(oseq) + 1;
int count = ofd_precreate_batch(ofd, diff);
rc = ofd_precreate_objects(env, ofd, next_id,
oseq, count, sync);
if (rc < 0) {
mutex_unlock(&oseq->os_create_lock);
ofd_seq_put(env, oseq);
GOTO(out, rc);
}
diff -= rc;
}
mutex_unlock(&oseq->os_create_lock);
}
ofd_seq_put(env, oseq);
}
fo = ofd_object_find(env, ofd, fid);
if (IS_ERR(fo))
GOTO(out, rc = PTR_ERR(fo));
LASSERT(fo != NULL);
ofd_read_lock(env, fo);
if (!ofd_object_exists(fo)) {
CERROR("%s: BRW to missing obj "DOSTID"\n",
exp->exp_obd->obd_name, POSTID(&obj->ioo_oid));
ofd_read_unlock(env, fo);
ofd_object_put(env, fo);
GOTO(out, rc = -ENOENT);
}
if (ofd->ofd_lfsck_verify_pfid && oa->o_valid & OBD_MD_FLFID) {
rc = ofd_verify_ff(env, fo, oa);
if (rc != 0) {
ofd_read_unlock(env, fo);
ofd_object_put(env, fo);
GOTO(out, rc);
}
}
/* Process incoming grant info, set OBD_BRW_GRANTED flag and grant some
* space back if possible */
ofd_grant_prepare_write(env, exp, oa, rnb, obj->ioo_bufcnt);
/* parse remote buffers to local buffers and prepare the latter */
*nr_local = 0;
for (i = 0, j = 0; i < obj->ioo_bufcnt; i++) {
rc = dt_bufs_get(env, ofd_object_child(fo),
rnb + i, lnb + j, 1);
if (unlikely(rc < 0))
GOTO(err, rc);
LASSERT(rc <= PTLRPC_MAX_BRW_PAGES);
/* correct index for local buffers to continue with */
for (k = 0; k < rc; k++) {
lnb[j+k].lnb_flags = rnb[i].rnb_flags;
if (!(rnb[i].rnb_flags & OBD_BRW_GRANTED))
lnb[j+k].lnb_rc = -ENOSPC;
}
j += rc;
*nr_local += rc;
LASSERT(j <= PTLRPC_MAX_BRW_PAGES);
tot_bytes += rnb[i].rnb_len;
}
LASSERT(*nr_local > 0 && *nr_local <= PTLRPC_MAX_BRW_PAGES);
rc = dt_write_prep(env, ofd_object_child(fo), lnb, *nr_local);
if (unlikely(rc != 0))
GOTO(err, rc);
ofd_counter_incr(exp, LPROC_OFD_STATS_WRITE, jobid, tot_bytes);
RETURN(0);
err:
dt_bufs_put(env, ofd_object_child(fo), lnb, *nr_local);
ofd_read_unlock(env, fo);
ofd_object_put(env, fo);
/* ofd_grant_prepare_write() was called, so we must commit */
ofd_grant_commit(exp, oa->o_grant_used, rc);
out:
/* let's still process incoming grant information packed in the oa,
* but without enforcing grant since we won't proceed with the write.
* Just like a read request actually. */
ofd_grant_prepare_read(env, exp, oa);
return rc;
}
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);
}
/**
* Implementation of ldlm_valblock_ops::lvbo_init for OFD.
*
* This function allocates and initializes new LVB data for the given
* LDLM resource if it is not allocated yet. New LVB is filled with attributes
* of the object associated with that resource. Function does nothing if LVB
* for the given LDLM resource is allocated already.
*
* Called with res->lr_lvb_sem held.
*
* \param[in] lock LDLM lock on resource
*
* \retval 0 on successful setup
* \retval negative value on error
*/
static int ofd_lvbo_init(const struct lu_env *env, struct ldlm_resource *res)
{
struct ost_lvb *lvb;
struct ofd_device *ofd;
struct ofd_object *fo;
struct ofd_thread_info *info;
struct lu_env _env;
int rc = 0;
ENTRY;
LASSERT(res);
LASSERT(mutex_is_locked(&res->lr_lvb_mutex));
if (res->lr_lvb_data != NULL)
RETURN(0);
ofd = ldlm_res_to_ns(res)->ns_lvbp;
LASSERT(ofd != NULL);
if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_OST_LVB))
RETURN(-ENOMEM);
if (!env) {
rc = lu_env_init(&_env, LCT_DT_THREAD);
if (rc)
RETURN(rc);
env = &_env;
}
OBD_ALLOC_PTR(lvb);
if (lvb == NULL)
GOTO(out, rc = -ENOMEM);
info = ofd_info(env);
res->lr_lvb_data = lvb;
res->lr_lvb_len = sizeof(*lvb);
ost_fid_from_resid(&info->fti_fid, &res->lr_name,
ofd->ofd_lut.lut_lsd.lsd_osd_index);
fo = ofd_object_find(env, ofd, &info->fti_fid);
if (IS_ERR(fo))
GOTO(out_lvb, rc = PTR_ERR(fo));
rc = ofd_attr_get(env, fo, &info->fti_attr);
if (rc) {
struct ofd_seq *oseq;
__u64 seq;
/* Object could be recreated during the first
* CLEANUP_ORPHAN request. */
if (rc == -ENOENT) {
seq = fid_seq(&info->fti_fid);
oseq = ofd_seq_load(env, ofd, fid_seq_is_idif(seq) ?
FID_SEQ_OST_MDT0 : seq);
if (!IS_ERR_OR_NULL(oseq)) {
if (!oseq->os_last_id_synced)
rc = -EAGAIN;
ofd_seq_put(env, oseq);
}
}
GOTO(out_obj, rc);
}
lvb->lvb_size = info->fti_attr.la_size;
lvb->lvb_blocks = info->fti_attr.la_blocks;
lvb->lvb_mtime = info->fti_attr.la_mtime;
lvb->lvb_atime = info->fti_attr.la_atime;
lvb->lvb_ctime = info->fti_attr.la_ctime;
CDEBUG(D_DLMTRACE, "res: "DFID" initial lvb size: %llu, "
"mtime: %#llx, blocks: %#llx\n",
PFID(&info->fti_fid), lvb->lvb_size,
lvb->lvb_mtime, lvb->lvb_blocks);
info->fti_attr.la_valid = 0;
EXIT;
out_obj:
ofd_object_put(env, fo);
out_lvb:
if (rc != 0)
OST_LVB_SET_ERR(lvb->lvb_blocks, rc);
out:
/* Don't free lvb data on lookup error */
if (env && env == &_env)
lu_env_fini(&_env);
return rc;
}
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;
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;
/* prepare objects */
ostid_set_seq(&info->fti_ostid, ostid_seq(&oseq->os_oi));
for (i = 0; i < nr; i++) {
ostid_set_id(&info->fti_ostid, id + i);
rc = ostid_to_fid(&info->fti_fid, &info->fti_ostid, 0);
if (rc) {
if (i == 0)
GOTO(out, rc);
nr = i;
break;
}
fo = ofd_object_find(env, ofd, &info->fti_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, sizeof(tmp),
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(&info->fti_fid));
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(&info->fti_fid), nr);
for (i = 0; i < nr; i++) {
fo = batch[i];
LASSERT(fo);
if (likely(!ofd_object_exists(fo))) {
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;
if (objects > 0) {
tmp = cpu_to_le64(ofd_seq_last_oid(oseq));
rc = dt_record_write(env, oseq->os_lastid_obj,
&info->fti_buf, &info->fti_off, th);
}
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);
}
static int ofd_preprw_write(const struct lu_env *env, struct obd_export *exp,
struct ofd_device *ofd, struct lu_fid *fid,
struct lu_attr *la, struct obdo *oa,
int objcount, struct obd_ioobj *obj,
struct niobuf_remote *rnb, int *nr_local,
struct niobuf_local *lnb, char *jobid)
{
struct ofd_object *fo;
int i, j, k, rc = 0, tot_bytes = 0;
ENTRY;
LASSERT(env != NULL);
LASSERT(objcount == 1);
if (unlikely(exp->exp_obd->obd_recovering)) {
struct ofd_thread_info *info = ofd_info(env);
/* copied from ofd_precreate_object */
/* XXX this should be consolidated to use the same code
* instead of a copy, due to the ongoing risk of bugs. */
memset(&info->fti_attr, 0, sizeof(info->fti_attr));
info->fti_attr.la_valid = LA_TYPE | LA_MODE;
info->fti_attr.la_mode = S_IFREG | S_ISUID | S_ISGID | 0666;
info->fti_attr.la_valid |= LA_ATIME | LA_MTIME | LA_CTIME;
/* 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_atime = 0;
info->fti_attr.la_mtime = 0;
info->fti_attr.la_ctime = 0;
fo = ofd_object_find_or_create(env, ofd, fid, &info->fti_attr);
} else {
fo = ofd_object_find(env, ofd, fid);
}
if (IS_ERR(fo))
GOTO(out, rc = PTR_ERR(fo));
LASSERT(fo != NULL);
ofd_read_lock(env, fo);
if (!ofd_object_exists(fo)) {
CERROR("%s: BRW to missing obj "DOSTID"\n",
exp->exp_obd->obd_name, POSTID(&obj->ioo_oid));
ofd_read_unlock(env, fo);
ofd_object_put(env, fo);
GOTO(out, rc = -ENOENT);
}
/* Process incoming grant info, set OBD_BRW_GRANTED flag and grant some
* space back if possible */
ofd_grant_prepare_write(env, exp, oa, rnb, obj->ioo_bufcnt);
/* parse remote buffers to local buffers and prepare the latter */
*nr_local = 0;
for (i = 0, j = 0; i < obj->ioo_bufcnt; i++) {
rc = dt_bufs_get(env, ofd_object_child(fo),
rnb + i, lnb + j, 1,
ofd_object_capa(env, fo));
if (unlikely(rc < 0))
GOTO(err, rc);
LASSERT(rc <= PTLRPC_MAX_BRW_PAGES);
/* correct index for local buffers to continue with */
for (k = 0; k < rc; k++) {
lnb[j+k].lnb_flags = rnb[i].rnb_flags;
if (!(rnb[i].rnb_flags & OBD_BRW_GRANTED))
lnb[j+k].lnb_rc = -ENOSPC;
/* remote client can't break through quota */
if (exp_connect_rmtclient(exp))
lnb[j+k].lnb_flags &= ~OBD_BRW_NOQUOTA;
}
j += rc;
*nr_local += rc;
LASSERT(j <= PTLRPC_MAX_BRW_PAGES);
tot_bytes += rnb[i].rnb_len;
}
LASSERT(*nr_local > 0 && *nr_local <= PTLRPC_MAX_BRW_PAGES);
rc = dt_write_prep(env, ofd_object_child(fo), lnb, *nr_local);
if (unlikely(rc != 0))
GOTO(err, rc);
ofd_counter_incr(exp, LPROC_OFD_STATS_WRITE, jobid, tot_bytes);
RETURN(0);
err:
dt_bufs_put(env, ofd_object_child(fo), lnb, *nr_local);
ofd_read_unlock(env, fo);
/* ofd_grant_prepare_write() was called, so we must commit */
ofd_grant_commit(env, exp, rc);
out:
/* let's still process incoming grant information packed in the oa,
* but without enforcing grant since we won't proceed with the write.
* Just like a read request actually. */
ofd_grant_prepare_read(env, exp, oa);
return rc;
}
