static int out_create(struct tgt_session_info *tsi)
{
struct tgt_thread_info *tti = tgt_th_info(tsi->tsi_env);
struct object_update *update = tti->tti_u.update.tti_update;
struct dt_object *obj = tti->tti_u.update.tti_dt_object;
struct dt_object_format *dof = &tti->tti_u.update.tti_update_dof;
struct obdo *lobdo = &tti->tti_u.update.tti_obdo;
struct lu_attr *attr = &tti->tti_attr;
struct lu_fid *fid = NULL;
struct obdo *wobdo;
int size;
int rc;
ENTRY;
wobdo = object_update_param_get(update, 0, &size);
if (wobdo == NULL || size != sizeof(*wobdo)) {
CERROR("%s: obdo is NULL, invalid RPC: rc = %d\n",
tgt_name(tsi->tsi_tgt), -EPROTO);
RETURN(err_serious(-EPROTO));
}
obdo_le_to_cpu(wobdo, wobdo);
lustre_get_wire_obdo(NULL, lobdo, wobdo);
la_from_obdo(attr, lobdo, lobdo->o_valid);
dof->dof_type = dt_mode_to_dft(attr->la_mode);
if (update->ou_params_count > 1) {
int size;
fid = object_update_param_get(update, 1, &size);
if (fid == NULL || size != sizeof(*fid)) {
CERROR("%s: invalid fid: rc = %d\n",
tgt_name(tsi->tsi_tgt), -EPROTO);
RETURN(err_serious(-EPROTO));
}
if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
lustre_swab_lu_fid(fid);
if (!fid_is_sane(fid)) {
CERROR("%s: invalid fid "DFID": rc = %d\n",
tgt_name(tsi->tsi_tgt), PFID(fid), -EPROTO);
RETURN(err_serious(-EPROTO));
}
}
if (lu_object_exists(&obj->do_lu))
RETURN(-EEXIST);
rc = out_tx_create(tsi->tsi_env, obj, attr, fid, dof,
&tti->tti_tea,
tti->tti_u.update.tti_update_reply,
tti->tti_u.update.tti_update_reply_index);
RETURN(rc);
}
/**
* Implementation of the llog_operations::lop_create
*
* This function is a wrapper over local_storage API function
* local_object_create().
*
* \param[in] env execution environment
* \param[in] los local_storage for bottom storage device
* \param[in] o dt_object to create
* \param[in] th current transaction handle
*
* \retval 0 on successful creation of the new object
* \retval negative error if creation was failed
*/
static int llog_osd_create_new_object(const struct lu_env *env,
struct local_oid_storage *los,
struct dt_object *o,
struct thandle *th)
{
struct llog_thread_info *lgi = llog_info(env);
lgi->lgi_attr.la_valid = LA_MODE;
lgi->lgi_attr.la_mode = S_IFREG | S_IRUGO | S_IWUSR;
lgi->lgi_dof.dof_type = dt_mode_to_dft(S_IFREG);
return local_object_create(env, los, o, &lgi->lgi_attr,
&lgi->lgi_dof, th);
}
static int out_create(struct mdt_thread_info *info)
{
struct update *update = info->mti_u.update.mti_update;
struct dt_object *obj = info->mti_u.update.mti_dt_object;
struct dt_object_format *dof = &info->mti_u.update.mti_update_dof;
struct obdo *lobdo = &info->mti_u.update.mti_obdo;
struct lu_attr *attr = &info->mti_attr.ma_attr;
struct lu_fid *fid = NULL;
struct obdo *wobdo;
int size;
int rc;
ENTRY;
wobdo = update_param_buf(update, 0, &size);
if (wobdo == NULL || size != sizeof(*wobdo)) {
CERROR("%s: obdo is NULL, invalid RPC: rc = %d\n",
mdt_obd_name(info->mti_mdt), -EPROTO);
RETURN(err_serious(-EPROTO));
}
obdo_le_to_cpu(wobdo, wobdo);
lustre_get_wire_obdo(lobdo, wobdo);
la_from_obdo(attr, lobdo, lobdo->o_valid);
dof->dof_type = dt_mode_to_dft(attr->la_mode);
if (S_ISDIR(attr->la_mode)) {
int size;
fid = update_param_buf(update, 1, &size);
if (fid == NULL || size != sizeof(*fid)) {
CERROR("%s: invalid fid: rc = %d\n",
mdt_obd_name(info->mti_mdt), -EPROTO);
RETURN(err_serious(-EPROTO));
}
fid_le_to_cpu(fid, fid);
if (!fid_is_sane(fid)) {
CERROR("%s: invalid fid "DFID": rc = %d\n",
mdt_obd_name(info->mti_mdt),
PFID(fid), -EPROTO);
RETURN(err_serious(-EPROTO));
}
}
rc = out_tx_create(info, obj, attr, fid, dof, &info->mti_handle,
info->mti_u.update.mti_update_reply,
info->mti_u.update.mti_update_reply_index);
RETURN(rc);
}
int tgt_init(const struct lu_env *env, struct lu_target *lut,
struct obd_device *obd, struct dt_device *dt)
{
struct dt_object_format dof;
struct lu_attr attr;
struct lu_fid fid;
struct dt_object *o;
int rc = 0;
ENTRY;
LASSERT(lut);
LASSERT(obd);
lut->lut_obd = obd;
lut->lut_bottom = dt;
lut->lut_last_rcvd = NULL;
obd->u.obt.obt_lut = lut;
obd->u.obt.obt_magic = OBT_MAGIC;
spin_lock_init(&lut->lut_translock);
OBD_ALLOC(lut->lut_client_bitmap, LR_MAX_CLIENTS >> 3);
if (lut->lut_client_bitmap == NULL)
RETURN(-ENOMEM);
memset(&attr, 0, sizeof(attr));
attr.la_valid = LA_MODE;
attr.la_mode = S_IFREG | S_IRUGO | S_IWUSR;
dof.dof_type = dt_mode_to_dft(S_IFREG);
lu_local_obj_fid(&fid, LAST_RECV_OID);
o = dt_find_or_create(env, lut->lut_bottom, &fid, &dof, &attr);
if (!IS_ERR(o)) {
lut->lut_last_rcvd = o;
} else {
OBD_FREE(lut->lut_client_bitmap, LR_MAX_CLIENTS >> 3);
lut->lut_client_bitmap = NULL;
rc = PTR_ERR(o);
CERROR("cannot open %s: rc = %d\n", LAST_RCVD, rc);
}
RETURN(rc);
}
struct ofd_object *ofd_object_find_or_create(const struct lu_env *env,
struct ofd_device *ofd,
const struct lu_fid *fid,
struct lu_attr *attr)
{
struct ofd_thread_info *info = ofd_info(env);
struct lu_object *fo_obj;
struct dt_object *dto;
ENTRY;
info->fti_dof.dof_type = dt_mode_to_dft(S_IFREG);
dto = dt_find_or_create(env, ofd->ofd_osd, fid, &info->fti_dof, attr);
if (IS_ERR(dto))
RETURN(ERR_CAST(dto));
fo_obj = lu_object_locate(dto->do_lu.lo_header,
ofd->ofd_dt_dev.dd_lu_dev.ld_type);
RETURN(ofd_obj(fo_obj));
}
/**
* Read the special file which contains the list of llog catalogs IDs
*
* This function reads the CATALOGS file which contains the array of llog
* catalogs IDs. The main purpose of this file is to store OSP llogs indexed
* by OST/MDT number.
*
* \param[in] env execution environment
* \param[in] d corresponding storage device
* \param[in] idx position to start from, usually OST/MDT index
* \param[in] count how many catalog IDs to read
* \param[out] idarray the buffer for the data. If it is NULL then
* function returns just number of catalog IDs
* in the file.
* \param[in] fid LLOG_CATALOGS_OID for CATALOG object
*
* \retval 0 on successful read of catalog IDs
* \retval negative value on error
* \retval positive value which is number of records in
* the file if \a idarray is NULL
*/
int llog_osd_get_cat_list(const struct lu_env *env, struct dt_device *d,
int idx, int count, struct llog_catid *idarray,
const struct lu_fid *fid)
{
struct llog_thread_info *lgi = llog_info(env);
struct dt_object *o = NULL;
struct thandle *th;
int rc, size;
ENTRY;
LASSERT(d);
size = sizeof(*idarray) * count;
lgi->lgi_off = idx * sizeof(*idarray);
lgi->lgi_fid = *fid;
o = dt_locate(env, d, &lgi->lgi_fid);
if (IS_ERR(o))
RETURN(PTR_ERR(o));
if (!dt_object_exists(o)) {
th = dt_trans_create(env, d);
if (IS_ERR(th))
GOTO(out, rc = PTR_ERR(th));
lgi->lgi_attr.la_valid = LA_MODE;
lgi->lgi_attr.la_mode = S_IFREG | S_IRUGO | S_IWUSR;
lgi->lgi_dof.dof_type = dt_mode_to_dft(S_IFREG);
rc = dt_declare_create(env, o, &lgi->lgi_attr, NULL,
&lgi->lgi_dof, th);
if (rc)
GOTO(out_trans, rc);
rc = dt_trans_start_local(env, d, th);
if (rc)
GOTO(out_trans, rc);
dt_write_lock(env, o, 0);
if (!dt_object_exists(o))
rc = dt_create(env, o, &lgi->lgi_attr, NULL,
&lgi->lgi_dof, th);
dt_write_unlock(env, o);
out_trans:
dt_trans_stop(env, d, th);
if (rc)
GOTO(out, rc);
}
rc = dt_attr_get(env, o, &lgi->lgi_attr, BYPASS_CAPA);
if (rc)
GOTO(out, rc);
if (!S_ISREG(lgi->lgi_attr.la_mode)) {
CERROR("%s: CATALOGS is not a regular file!: mode = %o\n",
o->do_lu.lo_dev->ld_obd->obd_name,
lgi->lgi_attr.la_mode);
GOTO(out, rc = -ENOENT);
}
CDEBUG(D_CONFIG, "cat list: disk size=%d, read=%d\n",
(int)lgi->lgi_attr.la_size, size);
/* return just number of llogs */
if (idarray == NULL) {
rc = lgi->lgi_attr.la_size / sizeof(*idarray);
GOTO(out, rc);
}
/* read for new ost index or for empty file */
memset(idarray, 0, size);
if (lgi->lgi_attr.la_size <= lgi->lgi_off)
GOTO(out, rc = 0);
if (lgi->lgi_attr.la_size < lgi->lgi_off + size)
size = lgi->lgi_attr.la_size - lgi->lgi_off;
lgi->lgi_buf.lb_buf = idarray;
lgi->lgi_buf.lb_len = size;
rc = dt_record_read(env, o, &lgi->lgi_buf, &lgi->lgi_off);
if (rc) {
CERROR("%s: error reading CATALOGS: rc = %d\n",
o->do_lu.lo_dev->ld_obd->obd_name, rc);
GOTO(out, rc);
}
EXIT;
out:
lu_object_put(env, &o->do_lu);
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);
}
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);
}
int tgt_init(const struct lu_env *env, struct lu_target *lut,
struct obd_device *obd, struct dt_device *dt,
struct tgt_opc_slice *slice, int request_fail_id,
int reply_fail_id)
{
struct dt_object_format dof;
struct lu_attr attr;
struct lu_fid fid;
struct dt_object *o;
int rc = 0;
ENTRY;
LASSERT(lut);
LASSERT(obd);
lut->lut_obd = obd;
lut->lut_bottom = dt;
lut->lut_last_rcvd = NULL;
lut->lut_client_bitmap = NULL;
obd->u.obt.obt_lut = lut;
obd->u.obt.obt_magic = OBT_MAGIC;
/* set request handler slice and parameters */
lut->lut_slice = slice;
lut->lut_reply_fail_id = reply_fail_id;
lut->lut_request_fail_id = request_fail_id;
/* sptlrcp variables init */
rwlock_init(&lut->lut_sptlrpc_lock);
sptlrpc_rule_set_init(&lut->lut_sptlrpc_rset);
lut->lut_mds_capa = 1;
lut->lut_oss_capa = 1;
spin_lock_init(&lut->lut_flags_lock);
lut->lut_sync_lock_cancel = NEVER_SYNC_ON_CANCEL;
/* last_rcvd initialization is needed by replayable targets only */
if (!obd->obd_replayable)
RETURN(0);
spin_lock_init(&lut->lut_translock);
OBD_ALLOC(lut->lut_client_bitmap, LR_MAX_CLIENTS >> 3);
if (lut->lut_client_bitmap == NULL)
RETURN(-ENOMEM);
memset(&attr, 0, sizeof(attr));
attr.la_valid = LA_MODE;
attr.la_mode = S_IFREG | S_IRUGO | S_IWUSR;
dof.dof_type = dt_mode_to_dft(S_IFREG);
lu_local_obj_fid(&fid, LAST_RECV_OID);
o = dt_find_or_create(env, lut->lut_bottom, &fid, &dof, &attr);
if (IS_ERR(o)) {
rc = PTR_ERR(o);
CERROR("%s: cannot open LAST_RCVD: rc = %d\n", tgt_name(lut),
rc);
GOTO(out_bitmap, rc);
}
lut->lut_last_rcvd = o;
rc = tgt_server_data_init(env, lut);
if (rc < 0)
GOTO(out_obj, rc);
/* prepare transactions callbacks */
lut->lut_txn_cb.dtc_txn_start = tgt_txn_start_cb;
lut->lut_txn_cb.dtc_txn_stop = tgt_txn_stop_cb;
lut->lut_txn_cb.dtc_txn_commit = NULL;
lut->lut_txn_cb.dtc_cookie = lut;
lut->lut_txn_cb.dtc_tag = LCT_DT_THREAD | LCT_MD_THREAD;
CFS_INIT_LIST_HEAD(&lut->lut_txn_cb.dtc_linkage);
dt_txn_callback_add(lut->lut_bottom, &lut->lut_txn_cb);
RETURN(0);
out_obj:
lu_object_put(env, &lut->lut_last_rcvd->do_lu);
lut->lut_last_rcvd = NULL;
out_bitmap:
OBD_FREE(lut->lut_client_bitmap, LR_MAX_CLIENTS >> 3);
lut->lut_client_bitmap = NULL;
return rc;
}
int tgt_init(const struct lu_env *env, struct lu_target *lut,
struct obd_device *obd, struct dt_device *dt,
struct tgt_opc_slice *slice, int request_fail_id,
int reply_fail_id)
{
struct dt_object_format dof;
struct lu_attr attr;
struct lu_fid fid;
struct dt_object *o;
int rc = 0;
ENTRY;
LASSERT(lut);
LASSERT(obd);
lut->lut_obd = obd;
lut->lut_bottom = dt;
lut->lut_last_rcvd = NULL;
lut->lut_client_bitmap = NULL;
obd->u.obt.obt_lut = lut;
obd->u.obt.obt_magic = OBT_MAGIC;
/* set request handler slice and parameters */
lut->lut_slice = slice;
lut->lut_reply_fail_id = reply_fail_id;
lut->lut_request_fail_id = request_fail_id;
/* sptlrcp variables init */
rwlock_init(&lut->lut_sptlrpc_lock);
sptlrpc_rule_set_init(&lut->lut_sptlrpc_rset);
lut->lut_mds_capa = 1;
lut->lut_oss_capa = 1;
/* last_rcvd initialization is needed by replayable targets only */
if (!obd->obd_replayable)
RETURN(0);
spin_lock_init(&lut->lut_translock);
OBD_ALLOC(lut->lut_client_bitmap, LR_MAX_CLIENTS >> 3);
if (lut->lut_client_bitmap == NULL)
RETURN(-ENOMEM);
memset(&attr, 0, sizeof(attr));
attr.la_valid = LA_MODE;
attr.la_mode = S_IFREG | S_IRUGO | S_IWUSR;
dof.dof_type = dt_mode_to_dft(S_IFREG);
lu_local_obj_fid(&fid, LAST_RECV_OID);
o = dt_find_or_create(env, lut->lut_bottom, &fid, &dof, &attr);
if (!IS_ERR(o)) {
lut->lut_last_rcvd = o;
} else {
OBD_FREE(lut->lut_client_bitmap, LR_MAX_CLIENTS >> 3);
lut->lut_client_bitmap = NULL;
rc = PTR_ERR(o);
CERROR("cannot open %s: rc = %d\n", LAST_RCVD, rc);
}
RETURN(rc);
}
