static int out_attr_set(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 lu_attr *attr = &tti->tti_attr;
struct dt_object *obj = tti->tti_u.update.tti_dt_object;
struct obdo *lobdo = &tti->tti_u.update.tti_obdo;
struct obdo *wobdo;
size_t size;
int rc;
ENTRY;
wobdo = object_update_param_get(update, 0, &size);
if (IS_ERR(wobdo) || size != sizeof(*wobdo)) {
CERROR("%s: empty obdo in the update: rc = %ld\n",
tgt_name(tsi->tsi_tgt), PTR_ERR(wobdo));
RETURN(PTR_ERR(wobdo));
}
attr->la_valid = 0;
attr->la_valid = 0;
if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
lustre_swab_obdo(wobdo);
lustre_get_wire_obdo(NULL, lobdo, wobdo);
la_from_obdo(attr, lobdo, lobdo->o_valid);
rc = out_tx_attr_set(tsi->tsi_env, obj, attr, &tti->tti_tea,
tti->tti_tea.ta_handle,
tti->tti_u.update.tti_update_reply,
tti->tti_u.update.tti_update_reply_index);
RETURN(rc);
}
static int out_attr_set(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 lu_attr *attr = &tti->tti_attr;
struct dt_object *obj = tti->tti_u.update.tti_dt_object;
struct obdo *lobdo = &tti->tti_u.update.tti_obdo;
struct obdo *wobdo;
int size;
int rc;
ENTRY;
wobdo = object_update_param_get(update, 0, &size);
if (wobdo == NULL || size != sizeof(*wobdo)) {
CERROR("%s: empty obdo in the update: rc = %d\n",
tgt_name(tsi->tsi_tgt), -EPROTO);
RETURN(err_serious(-EPROTO));
}
attr->la_valid = 0;
attr->la_valid = 0;
obdo_le_to_cpu(wobdo, wobdo);
lustre_get_wire_obdo(NULL, lobdo, wobdo);
la_from_obdo(attr, lobdo, lobdo->o_valid);
rc = out_tx_attr_set(tsi->tsi_env, obj, attr, &tti->tti_tea,
tti->tti_u.update.tti_update_reply,
tti->tti_u.update.tti_update_reply_index);
RETURN(rc);
}
static int out_destroy(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 lu_fid *fid;
int rc;
ENTRY;
fid = &update->ou_fid;
if (!fid_is_sane(fid)) {
CERROR("%s: invalid FID "DFID": rc = %d\n",
tgt_name(tsi->tsi_tgt), PFID(fid), -EPROTO);
RETURN(-EPROTO);
}
if (!lu_object_exists(&obj->do_lu))
RETURN(-ENOENT);
rc = out_tx_destroy(tsi->tsi_env, obj, &tti->tti_tea,
tti->tti_tea.ta_handle,
tti->tti_u.update.tti_update_reply,
tti->tti_u.update.tti_update_reply_index);
RETURN(rc);
}
static int out_xattr_set(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 lu_buf *lbuf = &tti->tti_buf;
char *name;
char *buf;
__u32 *tmp;
size_t buf_len = 0;
int flag;
size_t size = 0;
int rc;
ENTRY;
name = object_update_param_get(update, 0, NULL);
if (IS_ERR(name)) {
CERROR("%s: empty name for xattr set: rc = %ld\n",
tgt_name(tsi->tsi_tgt), PTR_ERR(name));
RETURN(PTR_ERR(name));
}
/* If buffer == NULL (-ENODATA), then it might mean delete xattr */
buf = object_update_param_get(update, 1, &buf_len);
if (IS_ERR(buf) && PTR_ERR(buf) != -ENODATA)
RETURN(PTR_ERR(buf));
lbuf->lb_buf = buf;
lbuf->lb_len = buf_len;
tmp = object_update_param_get(update, 2, &size);
if (IS_ERR(tmp) || size != sizeof(*tmp)) {
CERROR("%s: emptry or wrong size %zu flag: rc = %ld\n",
tgt_name(tsi->tsi_tgt), size, PTR_ERR(tmp));
RETURN(PTR_ERR(tmp));
}
if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
__swab32s(tmp);
flag = *tmp;
rc = out_tx_xattr_set(tsi->tsi_env, obj, lbuf, name, flag,
&tti->tti_tea, tti->tti_tea.ta_handle,
tti->tti_u.update.tti_update_reply,
tti->tti_u.update.tti_update_reply_index);
RETURN(rc);
}
static int out_xattr_set(struct tgt_session_info *tsi)
{
struct tgt_thread_info *tti = tgt_th_info(tsi->tsi_env);
struct update *update = tti->tti_u.update.tti_update;
struct dt_object *obj = tti->tti_u.update.tti_dt_object;
struct lu_buf *lbuf = &tti->tti_buf;
char *name;
char *buf;
char *tmp;
int buf_len = 0;
int flag;
int rc;
ENTRY;
name = update_param_buf(update, 0, NULL);
if (name == NULL) {
CERROR("%s: empty name for xattr set: rc = %d\n",
tgt_name(tsi->tsi_tgt), -EPROTO);
RETURN(err_serious(-EPROTO));
}
buf = (char *)update_param_buf(update, 1, &buf_len);
if (buf == NULL || buf_len == 0) {
CERROR("%s: empty buf for xattr set: rc = %d\n",
tgt_name(tsi->tsi_tgt), -EPROTO);
RETURN(err_serious(-EPROTO));
}
lbuf->lb_buf = buf;
lbuf->lb_len = buf_len;
tmp = (char *)update_param_buf(update, 2, NULL);
if (tmp == NULL) {
CERROR("%s: empty flag for xattr set: rc = %d\n",
tgt_name(tsi->tsi_tgt), -EPROTO);
RETURN(err_serious(-EPROTO));
}
flag = le32_to_cpu(*(int *)tmp);
rc = out_tx_xattr_set(tsi->tsi_env, obj, lbuf, name, flag,
&tti->tti_tea,
tti->tti_u.update.tti_update_reply,
tti->tti_u.update.tti_update_reply_index);
RETURN(rc);
}
static int out_index_insert(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 lu_fid *fid;
char *name;
int rc = 0;
int size;
ENTRY;
name = object_update_param_get(update, 0, NULL);
if (name == NULL) {
CERROR("%s: empty name for index insert: rc = %d\n",
tgt_name(tsi->tsi_tgt), -EPROTO);
RETURN(err_serious(-EPROTO));
}
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));
}
rc = out_tx_index_insert(tsi->tsi_env, obj, name, fid,
&tti->tti_tea,
tti->tti_u.update.tti_update_reply,
tti->tti_u.update.tti_update_reply_index);
RETURN(rc);
}
static int out_write(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 lu_buf *lbuf = &tti->tti_buf;
char *buf;
__u64 *tmp;
size_t size = 0;
size_t buf_len = 0;
loff_t pos;
int rc;
ENTRY;
buf = object_update_param_get(update, 0, &buf_len);
if (IS_ERR(buf) || buf_len == 0) {
CERROR("%s: empty buf for xattr set: rc = %ld\n",
tgt_name(tsi->tsi_tgt), PTR_ERR(buf));
RETURN(PTR_ERR(buf));
}
lbuf->lb_buf = buf;
lbuf->lb_len = buf_len;
tmp = object_update_param_get(update, 1, &size);
if (IS_ERR(tmp) || size != sizeof(*tmp)) {
CERROR("%s: empty or wrong size %zu pos: rc = %ld\n",
tgt_name(tsi->tsi_tgt), size, PTR_ERR(tmp));
RETURN(PTR_ERR(tmp));
}
if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
__swab64s(tmp);
pos = *tmp;
rc = out_tx_write(tsi->tsi_env, obj, lbuf, pos,
&tti->tti_tea, tti->tti_tea.ta_handle,
tti->tti_u.update.tti_update_reply,
tti->tti_u.update.tti_update_reply_index);
RETURN(rc);
}
static int out_write(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 lu_buf *lbuf = &tti->tti_buf;
char *buf;
char *tmp;
int buf_len = 0;
loff_t pos;
int rc;
ENTRY;
buf = object_update_param_get(update, 0, &buf_len);
if (buf == NULL || buf_len == 0) {
CERROR("%s: empty buf for xattr set: rc = %d\n",
tgt_name(tsi->tsi_tgt), -EPROTO);
RETURN(err_serious(-EPROTO));
}
lbuf->lb_buf = buf;
lbuf->lb_len = buf_len;
tmp = (char *)object_update_param_get(update, 1, NULL);
if (tmp == NULL) {
CERROR("%s: empty flag for xattr set: rc = %d\n",
tgt_name(tsi->tsi_tgt), -EPROTO);
RETURN(err_serious(-EPROTO));
}
if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
__swab64s((__u64 *)tmp);
pos = *(loff_t *)tmp;
rc = out_tx_write(tsi->tsi_env, obj, lbuf, pos,
&tti->tti_tea,
tti->tti_u.update.tti_update_reply,
tti->tti_u.update.tti_update_reply_index);
RETURN(rc);
}
static int out_attr_get(struct tgt_session_info *tsi)
{
const struct lu_env *env = tsi->tsi_env;
struct tgt_thread_info *tti = tgt_th_info(env);
struct object_update *update = tti->tti_u.update.tti_update;
struct obdo *obdo = &tti->tti_u.update.tti_obdo;
struct lu_attr *la = &tti->tti_attr;
struct dt_object *obj = tti->tti_u.update.tti_dt_object;
int idx = tti->tti_u.update.tti_update_reply_index;
int rc;
ENTRY;
if (unlikely(update->ou_result_size < sizeof(*obdo)))
return -EPROTO;
if (!lu_object_exists(&obj->do_lu)) {
/* Usually, this will be called when the master MDT try
* to init a remote object(see osp_object_init), so if
* the object does not exist on slave, we need set BANSHEE flag,
* so the object can be removed from the cache immediately */
set_bit(LU_OBJECT_HEARD_BANSHEE,
&obj->do_lu.lo_header->loh_flags);
RETURN(-ENOENT);
}
dt_read_lock(env, obj, MOR_TGT_CHILD);
rc = dt_attr_get(env, obj, la);
if (rc)
GOTO(out_unlock, rc);
obdo->o_valid = 0;
obdo_from_la(obdo, la, la->la_valid);
lustre_set_wire_obdo(NULL, obdo, obdo);
out_unlock:
dt_read_unlock(env, obj);
CDEBUG(D_INFO, "%s: insert attr get reply %p index %d: rc = %d\n",
tgt_name(tsi->tsi_tgt), tti->tti_u.update.tti_update_reply,
0, rc);
object_update_result_insert(tti->tti_u.update.tti_update_reply, obdo,
sizeof(*obdo), idx, rc);
RETURN(rc);
}
static int out_xattr_del(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;
char *name;
int rc;
ENTRY;
name = object_update_param_get(update, 0, NULL);
if (IS_ERR(name)) {
CERROR("%s: empty name for xattr set: rc = %ld\n",
tgt_name(tsi->tsi_tgt), PTR_ERR(name));
RETURN(PTR_ERR(name));
}
rc = out_tx_xattr_del(tsi->tsi_env, obj, name, &tti->tti_tea,
tti->tti_tea.ta_handle,
tti->tti_u.update.tti_update_reply,
tti->tti_u.update.tti_update_reply_index);
RETURN(rc);
}
static int out_index_delete(struct tgt_session_info *tsi)
{
struct tgt_thread_info *tti = tgt_th_info(tsi->tsi_env);
struct update *update = tti->tti_u.update.tti_update;
struct dt_object *obj = tti->tti_u.update.tti_dt_object;
char *name;
int rc = 0;
if (!lu_object_exists(&obj->do_lu))
RETURN(-ENOENT);
name = (char *)update_param_buf(update, 0, NULL);
if (name == NULL) {
CERROR("%s: empty name for index delete: rc = %d\n",
tgt_name(tsi->tsi_tgt), -EPROTO);
RETURN(err_serious(-EPROTO));
}
rc = out_tx_index_delete(tsi->tsi_env, obj, name, &tti->tti_tea,
tti->tti_u.update.tti_update_reply,
tti->tti_u.update.tti_update_reply_index);
RETURN(rc);
}
static int out_index_delete(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;
char *name;
int rc = 0;
if (!lu_object_exists(&obj->do_lu))
RETURN(-ENOENT);
name = object_update_param_get(update, 0, NULL);
if (IS_ERR(name)) {
CERROR("%s: empty name for index delete: rc = %ld\n",
tgt_name(tsi->tsi_tgt), PTR_ERR(name));
RETURN(PTR_ERR(name));
}
rc = out_tx_index_delete(tsi->tsi_env, obj, (const struct dt_key *)name,
&tti->tti_tea, tti->tti_tea.ta_handle,
tti->tti_u.update.tti_update_reply,
tti->tti_u.update.tti_update_reply_index);
RETURN(rc);
}
int mdt_init_idmap(struct tgt_session_info *tsi)
{
struct ptlrpc_request *req = tgt_ses_req(tsi);
struct mdt_export_data *med = mdt_req2med(req);
struct obd_export *exp = req->rq_export;
char *client = libcfs_nid2str(req->rq_peer.nid);
int rc = 0;
ENTRY;
if (exp_connect_rmtclient(exp)) {
mutex_lock(&med->med_idmap_mutex);
if (!med->med_idmap)
med->med_idmap = lustre_idmap_init();
mutex_unlock(&med->med_idmap_mutex);
if (IS_ERR(med->med_idmap)) {
long err = PTR_ERR(med->med_idmap);
med->med_idmap = NULL;
CERROR("%s: client %s -> target %s "
"failed to init idmap [%ld]!\n",
tgt_name(tsi->tsi_tgt), client,
tgt_name(tsi->tsi_tgt), err);
RETURN(err);
} else if (!med->med_idmap) {
CERROR("%s: client %s -> target %s "
"failed to init(2) idmap!\n",
tgt_name(tsi->tsi_tgt), client,
tgt_name(tsi->tsi_tgt));
RETURN(-ENOMEM);
}
CDEBUG(D_SEC, "%s: client %s -> target %s is remote.\n",
tgt_name(tsi->tsi_tgt), client,
tgt_name(tsi->tsi_tgt));
/* NB, MDS_CONNECT establish root idmap too! */
rc = mdt_handle_idmap(tsi);
}
RETURN(rc);
}
static int out_attr_get(struct tgt_session_info *tsi)
{
const struct lu_env *env = tsi->tsi_env;
struct tgt_thread_info *tti = tgt_th_info(env);
struct obdo *obdo = &tti->tti_u.update.tti_obdo;
struct lu_attr *la = &tti->tti_attr;
struct dt_object *obj = tti->tti_u.update.tti_dt_object;
int rc;
ENTRY;
if (!lu_object_exists(&obj->do_lu))
RETURN(-ENOENT);
dt_read_lock(env, obj, MOR_TGT_CHILD);
rc = dt_attr_get(env, obj, la, NULL);
if (rc)
GOTO(out_unlock, rc);
/*
* If it is a directory, we will also check whether the
* directory is empty.
* la_flags = 0 : Empty.
* = 1 : Not empty.
*/
la->la_flags = 0;
if (S_ISDIR(la->la_mode)) {
struct dt_it *it;
const struct dt_it_ops *iops;
if (!dt_try_as_dir(env, obj))
GOTO(out_unlock, rc = -ENOTDIR);
iops = &obj->do_index_ops->dio_it;
it = iops->init(env, obj, LUDA_64BITHASH, BYPASS_CAPA);
if (!IS_ERR(it)) {
int result;
result = iops->get(env, it, (const void *)"");
if (result > 0) {
int i;
for (result = 0, i = 0; result == 0 && i < 3;
++i)
result = iops->next(env, it);
if (result == 0)
la->la_flags = 1;
} else if (result == 0)
/*
* Huh? Index contains no zero key?
*/
rc = -EIO;
iops->put(env, it);
iops->fini(env, it);
}
}
obdo->o_valid = 0;
obdo_from_la(obdo, la, la->la_valid);
obdo_cpu_to_le(obdo, obdo);
lustre_set_wire_obdo(NULL, obdo, obdo);
out_unlock:
dt_read_unlock(env, obj);
CDEBUG(D_INFO, "%s: insert attr get reply %p index %d: rc = %d\n",
tgt_name(tsi->tsi_tgt), tti->tti_u.update.tti_update_reply,
0, rc);
update_insert_reply(tti->tti_u.update.tti_update_reply, obdo,
sizeof(*obdo), 0, rc);
RETURN(rc);
}
/**
* Object updates between Targets. Because all the updates has been
* dis-assemblied into object updates at sender side, so OUT will
* call OSD API directly to execute these updates.
*
* In DNE phase I all of the updates in the request need to be executed
* in one transaction, and the transaction has to be synchronously.
*
* Please refer to lustre/include/lustre/lustre_idl.h for req/reply
* format.
*/
int out_handle(struct tgt_session_info *tsi)
{
const struct lu_env *env = tsi->tsi_env;
struct tgt_thread_info *tti = tgt_th_info(env);
struct thandle_exec_args *ta = &tti->tti_tea;
struct req_capsule *pill = tsi->tsi_pill;
struct dt_device *dt = tsi->tsi_tgt->lut_bottom;
struct update_buf *ubuf;
struct update *update;
struct update_reply *update_reply;
int bufsize;
int count;
int old_batchid = -1;
unsigned off;
int i;
int rc = 0;
int rc1 = 0;
ENTRY;
req_capsule_set(pill, &RQF_UPDATE_OBJ);
bufsize = req_capsule_get_size(pill, &RMF_UPDATE, RCL_CLIENT);
if (bufsize != UPDATE_BUFFER_SIZE) {
CERROR("%s: invalid bufsize %d: rc = %d\n",
tgt_name(tsi->tsi_tgt), bufsize, -EPROTO);
RETURN(err_serious(-EPROTO));
}
ubuf = req_capsule_client_get(pill, &RMF_UPDATE);
if (ubuf == NULL) {
CERROR("%s: No buf!: rc = %d\n", tgt_name(tsi->tsi_tgt),
-EPROTO);
RETURN(err_serious(-EPROTO));
}
if (le32_to_cpu(ubuf->ub_magic) != UPDATE_BUFFER_MAGIC) {
CERROR("%s: invalid magic %x expect %x: rc = %d\n",
tgt_name(tsi->tsi_tgt), le32_to_cpu(ubuf->ub_magic),
UPDATE_BUFFER_MAGIC, -EPROTO);
RETURN(err_serious(-EPROTO));
}
count = le32_to_cpu(ubuf->ub_count);
if (count <= 0) {
CERROR("%s: No update!: rc = %d\n",
tgt_name(tsi->tsi_tgt), -EPROTO);
RETURN(err_serious(-EPROTO));
}
req_capsule_set_size(pill, &RMF_UPDATE_REPLY, RCL_SERVER,
UPDATE_BUFFER_SIZE);
rc = req_capsule_server_pack(pill);
if (rc != 0) {
CERROR("%s: Can't pack response: rc = %d\n",
tgt_name(tsi->tsi_tgt), rc);
RETURN(rc);
}
/* Prepare the update reply buffer */
update_reply = req_capsule_server_get(pill, &RMF_UPDATE_REPLY);
if (update_reply == NULL)
RETURN(err_serious(-EPROTO));
update_init_reply_buf(update_reply, count);
tti->tti_u.update.tti_update_reply = update_reply;
rc = out_tx_start(env, dt, ta);
if (rc != 0)
RETURN(rc);
tti->tti_mult_trans = !req_is_replay(tgt_ses_req(tsi));
/* Walk through updates in the request to execute them synchronously */
off = cfs_size_round(offsetof(struct update_buf, ub_bufs[0]));
for (i = 0; i < count; i++) {
struct tgt_handler *h;
struct dt_object *dt_obj;
update = (struct update *)((char *)ubuf + off);
if (old_batchid == -1) {
old_batchid = update->u_batchid;
} else if (old_batchid != update->u_batchid) {
/* Stop the current update transaction,
* create a new one */
rc = out_tx_end(env, ta);
if (rc != 0)
RETURN(rc);
rc = out_tx_start(env, dt, ta);
if (rc != 0)
RETURN(rc);
old_batchid = update->u_batchid;
}
fid_le_to_cpu(&update->u_fid, &update->u_fid);
if (!fid_is_sane(&update->u_fid)) {
CERROR("%s: invalid FID "DFID": rc = %d\n",
tgt_name(tsi->tsi_tgt), PFID(&update->u_fid),
-EPROTO);
GOTO(out, rc = err_serious(-EPROTO));
}
dt_obj = dt_locate(env, dt, &update->u_fid);
if (IS_ERR(dt_obj))
GOTO(out, rc = PTR_ERR(dt_obj));
tti->tti_u.update.tti_dt_object = dt_obj;
tti->tti_u.update.tti_update = update;
tti->tti_u.update.tti_update_reply_index = i;
h = out_handler_find(update->u_type);
if (likely(h != NULL)) {
/* For real modification RPC, check if the update
* has been executed */
if (h->th_flags & MUTABOR) {
struct ptlrpc_request *req = tgt_ses_req(tsi);
if (out_check_resent(env, dt, dt_obj, req,
out_reconstruct,
update_reply, i))
GOTO(next, rc);
}
rc = h->th_act(tsi);
} else {
CERROR("%s: The unsupported opc: 0x%x\n",
tgt_name(tsi->tsi_tgt), update->u_type);
lu_object_put(env, &dt_obj->do_lu);
GOTO(out, rc = -ENOTSUPP);
}
next:
lu_object_put(env, &dt_obj->do_lu);
if (rc < 0)
GOTO(out, rc);
off += cfs_size_round(update_size(update));
}
out:
rc1 = out_tx_end(env, ta);
if (rc == 0)
rc = rc1;
RETURN(rc);
}
/**
* Object updates between Targets. Because all the updates has been
* dis-assemblied into object updates at sender side, so OUT will
* call OSD API directly to execute these updates.
*
* In DNE phase I all of the updates in the request need to be executed
* in one transaction, and the transaction has to be synchronously.
*
* Please refer to lustre/include/lustre/lustre_idl.h for req/reply
* format.
*/
int out_handle(struct tgt_session_info *tsi)
{
const struct lu_env *env = tsi->tsi_env;
struct tgt_thread_info *tti = tgt_th_info(env);
struct thandle_exec_args *ta = &tti->tti_tea;
struct req_capsule *pill = tsi->tsi_pill;
struct dt_device *dt = tsi->tsi_tgt->lut_bottom;
struct out_update_header *ouh;
struct out_update_buffer *oub = NULL;
struct object_update *update;
struct object_update_reply *reply;
struct ptlrpc_bulk_desc *desc = NULL;
struct l_wait_info lwi;
void **update_bufs;
int current_batchid = -1;
__u32 update_buf_count;
unsigned int i;
unsigned int reply_index = 0;
int rc = 0;
int rc1 = 0;
int ouh_size, reply_size;
int updates;
ENTRY;
req_capsule_set(pill, &RQF_OUT_UPDATE);
ouh_size = req_capsule_get_size(pill, &RMF_OUT_UPDATE_HEADER,
RCL_CLIENT);
if (ouh_size <= 0)
RETURN(err_serious(-EPROTO));
ouh = req_capsule_client_get(pill, &RMF_OUT_UPDATE_HEADER);
if (ouh == NULL)
RETURN(err_serious(-EPROTO));
if (ouh->ouh_magic != OUT_UPDATE_HEADER_MAGIC) {
CERROR("%s: invalid update buffer magic %x expect %x: "
"rc = %d\n", tgt_name(tsi->tsi_tgt), ouh->ouh_magic,
UPDATE_REQUEST_MAGIC, -EPROTO);
RETURN(err_serious(-EPROTO));
}
update_buf_count = ouh->ouh_count;
if (update_buf_count == 0)
RETURN(err_serious(-EPROTO));
OBD_ALLOC(update_bufs, sizeof(*update_bufs) * update_buf_count);
if (update_bufs == NULL)
RETURN(err_serious(-ENOMEM));
if (ouh->ouh_inline_length > 0) {
update_bufs[0] = ouh->ouh_inline_data;
} else {
struct out_update_buffer *tmp;
oub = req_capsule_client_get(pill, &RMF_OUT_UPDATE_BUF);
if (oub == NULL)
GOTO(out_free, rc = err_serious(-EPROTO));
desc = ptlrpc_prep_bulk_exp(pill->rc_req, update_buf_count,
PTLRPC_BULK_OPS_COUNT,
PTLRPC_BULK_GET_SINK |
PTLRPC_BULK_BUF_KVEC,
MDS_BULK_PORTAL,
&ptlrpc_bulk_kvec_ops);
if (desc == NULL)
GOTO(out_free, rc = err_serious(-ENOMEM));
tmp = oub;
for (i = 0; i < update_buf_count; i++, tmp++) {
if (tmp->oub_size >= OUT_MAXREQSIZE)
GOTO(out_free, rc = err_serious(-EPROTO));
OBD_ALLOC(update_bufs[i], tmp->oub_size);
if (update_bufs[i] == NULL)
GOTO(out_free, rc = err_serious(-ENOMEM));
desc->bd_frag_ops->add_iov_frag(desc, update_bufs[i],
tmp->oub_size);
}
pill->rc_req->rq_bulk_write = 1;
rc = sptlrpc_svc_prep_bulk(pill->rc_req, desc);
if (rc != 0)
GOTO(out_free, rc = err_serious(rc));
rc = target_bulk_io(pill->rc_req->rq_export, desc, &lwi);
if (rc < 0)
GOTO(out_free, rc = err_serious(rc));
}
/* validate the request and calculate the total update count and
* set it to reply */
reply_size = 0;
updates = 0;
for (i = 0; i < update_buf_count; i++) {
struct object_update_request *our;
int j;
our = update_bufs[i];
if (ptlrpc_req_need_swab(pill->rc_req))
lustre_swab_object_update_request(our);
if (our->ourq_magic != UPDATE_REQUEST_MAGIC) {
CERROR("%s: invalid update buffer magic %x"
" expect %x: rc = %d\n",
tgt_name(tsi->tsi_tgt), our->ourq_magic,
UPDATE_REQUEST_MAGIC, -EPROTO);
GOTO(out_free, rc = err_serious(-EPROTO));
}
updates += our->ourq_count;
/* need to calculate reply size */
for (j = 0; j < our->ourq_count; j++) {
update = object_update_request_get(our, j, NULL);
if (update == NULL)
GOTO(out, rc = err_serious(-EPROTO));
if (ptlrpc_req_need_swab(pill->rc_req))
lustre_swab_object_update(update);
if (!fid_is_sane(&update->ou_fid)) {
CERROR("%s: invalid FID "DFID": rc = %d\n",
tgt_name(tsi->tsi_tgt),
PFID(&update->ou_fid), -EPROTO);
GOTO(out, rc = err_serious(-EPROTO));
}
/* XXX: what ou_result_size can be considered safe? */
reply_size += sizeof(reply->ourp_lens[0]);
reply_size += sizeof(struct object_update_result);
reply_size += update->ou_result_size;
}
}
reply_size += sizeof(*reply);
if (unlikely(reply_size > ouh->ouh_reply_size)) {
CERROR("%s: too small reply buf %u for %u, need %u at least\n",
tgt_name(tsi->tsi_tgt), ouh->ouh_reply_size,
updates, reply_size);
GOTO(out_free, rc = err_serious(-EPROTO));
}
req_capsule_set_size(pill, &RMF_OUT_UPDATE_REPLY, RCL_SERVER,
ouh->ouh_reply_size);
rc = req_capsule_server_pack(pill);
if (rc != 0) {
CERROR("%s: Can't pack response: rc = %d\n",
tgt_name(tsi->tsi_tgt), rc);
GOTO(out_free, rc = err_serious(-EPROTO));
}
/* Prepare the update reply buffer */
reply = req_capsule_server_get(pill, &RMF_OUT_UPDATE_REPLY);
if (reply == NULL)
GOTO(out_free, rc = -EPROTO);
reply->ourp_magic = UPDATE_REPLY_MAGIC;
reply->ourp_count = updates;
tti->tti_u.update.tti_update_reply = reply;
tti->tti_mult_trans = !req_is_replay(tgt_ses_req(tsi));
/* Walk through updates in the request to execute them */
for (i = 0; i < update_buf_count; i++) {
struct tgt_handler *h;
struct dt_object *dt_obj;
int update_count;
struct object_update_request *our;
int j;
our = update_bufs[i];
update_count = our->ourq_count;
for (j = 0; j < update_count; j++) {
update = object_update_request_get(our, j, NULL);
dt_obj = dt_locate(env, dt, &update->ou_fid);
if (IS_ERR(dt_obj))
GOTO(out, rc = PTR_ERR(dt_obj));
if (dt->dd_record_fid_accessed) {
lfsck_pack_rfa(&tti->tti_lr,
lu_object_fid(&dt_obj->do_lu),
LE_FID_ACCESSED,
LFSCK_TYPE_LAYOUT);
tgt_lfsck_in_notify(env, dt, &tti->tti_lr,
NULL);
}
tti->tti_u.update.tti_dt_object = dt_obj;
tti->tti_u.update.tti_update = update;
tti->tti_u.update.tti_update_reply_index = reply_index;
h = out_handler_find(update->ou_type);
if (unlikely(h == NULL)) {
CERROR("%s: unsupported opc: 0x%x\n",
tgt_name(tsi->tsi_tgt), update->ou_type);
GOTO(next, rc = -ENOTSUPP);
}
/* Check resend case only for modifying RPC */
if (h->th_flags & MUTABOR) {
struct ptlrpc_request *req = tgt_ses_req(tsi);
if (out_check_resent(env, dt, dt_obj, req,
out_reconstruct, reply,
reply_index))
GOTO(next, rc = 0);
}
/* start transaction for modification RPC only */
if (h->th_flags & MUTABOR && current_batchid == -1) {
current_batchid = update->ou_batchid;
rc = out_tx_start(env, dt, ta, tsi->tsi_exp);
if (rc != 0)
GOTO(next, rc);
if (update->ou_flags & UPDATE_FL_SYNC)
ta->ta_handle->th_sync = 1;
}
/* Stop the current update transaction, if the update
* has different batchid, or read-only update */
if (((current_batchid != update->ou_batchid) ||
!(h->th_flags & MUTABOR)) &&
ta->ta_handle != NULL) {
rc = out_tx_end(env, ta, rc);
current_batchid = -1;
if (rc != 0)
GOTO(next, rc);
/* start a new transaction if needed */
if (h->th_flags & MUTABOR) {
rc = out_tx_start(env, dt, ta,
tsi->tsi_exp);
if (rc != 0)
GOTO(next, rc);
if (update->ou_flags & UPDATE_FL_SYNC)
ta->ta_handle->th_sync = 1;
current_batchid = update->ou_batchid;
}
}
rc = h->th_act(tsi);
next:
reply_index++;
lu_object_put(env, &dt_obj->do_lu);
if (rc < 0)
GOTO(out, rc);
}
}
out:
if (current_batchid != -1) {
rc1 = out_tx_end(env, ta, rc);
if (rc == 0)
rc = rc1;
}
out_free:
if (update_bufs != NULL) {
if (oub != NULL) {
for (i = 0; i < update_buf_count; i++, oub++) {
if (update_bufs[i] != NULL)
OBD_FREE(update_bufs[i], oub->oub_size);
}
}
OBD_FREE(update_bufs, sizeof(*update_bufs) * update_buf_count);
}
if (desc != NULL)
ptlrpc_free_bulk(desc);
RETURN(rc);
}
static int out_read(struct tgt_session_info *tsi)
{
const struct lu_env *env = tsi->tsi_env;
struct tgt_thread_info *tti = tgt_th_info(env);
struct object_update *update = tti->tti_u.update.tti_update;
struct dt_object *obj = tti->tti_u.update.tti_dt_object;
struct object_update_reply *reply = tti->tti_u.update.tti_update_reply;
int index = tti->tti_u.update.tti_update_reply_index;
struct lu_rdbuf *rdbuf;
struct object_update_result *update_result;
struct out_read_reply *orr;
void *tmp;
size_t size;
size_t total_size = 0;
__u64 pos;
unsigned int i;
unsigned int nbufs;
int rc = 0;
ENTRY;
update_result = object_update_result_get(reply, index, NULL);
LASSERT(update_result != NULL);
update_result->our_datalen = sizeof(*orr);
if (!lu_object_exists(&obj->do_lu))
GOTO(out, rc = -ENOENT);
tmp = object_update_param_get(update, 0, NULL);
if (IS_ERR(tmp)) {
CERROR("%s: empty size for read: rc = %ld\n",
tgt_name(tsi->tsi_tgt), PTR_ERR(tmp));
GOTO(out, rc = PTR_ERR(tmp));
}
size = le64_to_cpu(*(size_t *)(tmp));
tmp = object_update_param_get(update, 1, NULL);
if (IS_ERR(tmp)) {
CERROR("%s: empty pos for read: rc = %ld\n",
tgt_name(tsi->tsi_tgt), PTR_ERR(tmp));
GOTO(out, rc = PTR_ERR(tmp));
}
pos = le64_to_cpu(*(__u64 *)(tmp));
/* Put the offset into the begining of the buffer in reply */
orr = (struct out_read_reply *)update_result->our_data;
nbufs = (size + OUT_BULK_BUFFER_SIZE - 1) / OUT_BULK_BUFFER_SIZE;
OBD_ALLOC(rdbuf, sizeof(struct lu_rdbuf) +
nbufs * sizeof(rdbuf->rb_bufs[0]));
if (rdbuf == NULL)
GOTO(out, rc = -ENOMEM);
rdbuf->rb_nbufs = 0;
total_size = 0;
for (i = 0; i < nbufs; i++) {
__u32 read_size;
read_size = size > OUT_BULK_BUFFER_SIZE ?
OUT_BULK_BUFFER_SIZE : size;
OBD_ALLOC(rdbuf->rb_bufs[i].lb_buf, read_size);
if (rdbuf->rb_bufs[i].lb_buf == NULL)
GOTO(out_free, rc = -ENOMEM);
rdbuf->rb_bufs[i].lb_len = read_size;
dt_read_lock(env, obj, MOR_TGT_CHILD);
rc = dt_read(env, obj, &rdbuf->rb_bufs[i], &pos);
dt_read_unlock(env, obj);
total_size += rc < 0 ? 0 : rc;
if (rc <= 0)
break;
rdbuf->rb_nbufs++;
size -= read_size;
}
/* send pages to client */
rc = tgt_send_buffer(tsi, rdbuf);
if (rc < 0)
GOTO(out_free, rc);
orr->orr_size = total_size;
orr->orr_offset = pos;
orr_cpu_to_le(orr, orr);
update_result->our_datalen += orr->orr_size;
out_free:
for (i = 0; i < nbufs; i++) {
if (rdbuf->rb_bufs[i].lb_buf != NULL) {
OBD_FREE(rdbuf->rb_bufs[i].lb_buf,
rdbuf->rb_bufs[i].lb_len);
}
}
OBD_FREE(rdbuf, sizeof(struct lu_rdbuf) +
nbufs * sizeof(rdbuf->rb_bufs[0]));
out:
/* Insert read buffer */
update_result->our_rc = ptlrpc_status_hton(rc);
reply->ourp_lens[index] = cfs_size_round(update_result->our_datalen +
sizeof(*update_result));
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;
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;
}
/**
* Object updates between Targets. Because all the updates has been
* dis-assemblied into object updates at sender side, so OUT will
* call OSD API directly to execute these updates.
*
* In DNE phase I all of the updates in the request need to be executed
* in one transaction, and the transaction has to be synchronously.
*
* Please refer to lustre/include/lustre/lustre_idl.h for req/reply
* format.
*/
int out_handle(struct tgt_session_info *tsi)
{
const struct lu_env *env = tsi->tsi_env;
struct tgt_thread_info *tti = tgt_th_info(env);
struct thandle_exec_args *ta = &tti->tti_tea;
struct req_capsule *pill = tsi->tsi_pill;
struct dt_device *dt = tsi->tsi_tgt->lut_bottom;
struct object_update_request *ureq;
struct object_update *update;
struct object_update_reply *reply;
int bufsize;
int count;
int old_batchid = -1;
int i;
int rc = 0;
int rc1 = 0;
ENTRY;
req_capsule_set(pill, &RQF_OUT_UPDATE);
ureq = req_capsule_client_get(pill, &RMF_OUT_UPDATE);
if (ureq == NULL) {
CERROR("%s: No buf!: rc = %d\n", tgt_name(tsi->tsi_tgt),
-EPROTO);
RETURN(err_serious(-EPROTO));
}
bufsize = req_capsule_get_size(pill, &RMF_OUT_UPDATE, RCL_CLIENT);
if (bufsize != object_update_request_size(ureq)) {
CERROR("%s: invalid bufsize %d: rc = %d\n",
tgt_name(tsi->tsi_tgt), bufsize, -EPROTO);
RETURN(err_serious(-EPROTO));
}
if (ureq->ourq_magic != UPDATE_REQUEST_MAGIC) {
CERROR("%s: invalid update buffer magic %x expect %x: "
"rc = %d\n", tgt_name(tsi->tsi_tgt), ureq->ourq_magic,
UPDATE_REQUEST_MAGIC, -EPROTO);
RETURN(err_serious(-EPROTO));
}
count = ureq->ourq_count;
if (count <= 0) {
CERROR("%s: empty update: rc = %d\n", tgt_name(tsi->tsi_tgt),
-EPROTO);
RETURN(err_serious(-EPROTO));
}
req_capsule_set_size(pill, &RMF_OUT_UPDATE_REPLY, RCL_SERVER,
OUT_UPDATE_REPLY_SIZE);
rc = req_capsule_server_pack(pill);
if (rc != 0) {
CERROR("%s: Can't pack response: rc = %d\n",
tgt_name(tsi->tsi_tgt), rc);
RETURN(rc);
}
/* Prepare the update reply buffer */
reply = req_capsule_server_get(pill, &RMF_OUT_UPDATE_REPLY);
if (reply == NULL)
RETURN(err_serious(-EPROTO));
object_update_reply_init(reply, count);
tti->tti_u.update.tti_update_reply = reply;
rc = out_tx_start(env, dt, ta, tsi->tsi_exp);
if (rc != 0)
RETURN(rc);
tti->tti_mult_trans = !req_is_replay(tgt_ses_req(tsi));
/* Walk through updates in the request to execute them synchronously */
for (i = 0; i < count; i++) {
struct tgt_handler *h;
struct dt_object *dt_obj;
update = object_update_request_get(ureq, i, NULL);
if (update == NULL)
GOTO(out, rc = -EPROTO);
if (ptlrpc_req_need_swab(pill->rc_req))
lustre_swab_object_update(update);
if (old_batchid == -1) {
old_batchid = update->ou_batchid;
} else if (old_batchid != update->ou_batchid) {
/* Stop the current update transaction,
* create a new one */
rc = out_tx_end(env, ta);
if (rc < 0)
RETURN(rc);
rc = out_tx_start(env, dt, ta, tsi->tsi_exp);
if (rc != 0)
RETURN(rc);
old_batchid = update->ou_batchid;
}
if (!fid_is_sane(&update->ou_fid)) {
CERROR("%s: invalid FID "DFID": rc = %d\n",
tgt_name(tsi->tsi_tgt), PFID(&update->ou_fid),
-EPROTO);
GOTO(out, rc = err_serious(-EPROTO));
}
dt_obj = dt_locate(env, dt, &update->ou_fid);
if (IS_ERR(dt_obj))
GOTO(out, rc = PTR_ERR(dt_obj));
if (dt->dd_record_fid_accessed) {
lfsck_pack_rfa(&tti->tti_lr,
lu_object_fid(&dt_obj->do_lu));
tgt_lfsck_in_notify(env, dt, &tti->tti_lr);
}
tti->tti_u.update.tti_dt_object = dt_obj;
tti->tti_u.update.tti_update = update;
tti->tti_u.update.tti_update_reply_index = i;
h = out_handler_find(update->ou_type);
if (likely(h != NULL)) {
/* For real modification RPC, check if the update
* has been executed */
if (h->th_flags & MUTABOR) {
struct ptlrpc_request *req = tgt_ses_req(tsi);
if (out_check_resent(env, dt, dt_obj, req,
out_reconstruct, reply, i))
GOTO(next, rc);
}
rc = h->th_act(tsi);
} else {
CERROR("%s: The unsupported opc: 0x%x\n",
tgt_name(tsi->tsi_tgt), update->ou_type);
lu_object_put(env, &dt_obj->do_lu);
GOTO(out, rc = -ENOTSUPP);
}
next:
lu_object_put(env, &dt_obj->do_lu);
if (rc < 0)
GOTO(out, rc);
}
out:
rc1 = out_tx_end(env, ta);
if (rc == 0)
rc = rc1;
RETURN(rc);
}
static int out_xattr_get(struct tgt_session_info *tsi)
{
const struct lu_env *env = tsi->tsi_env;
struct tgt_thread_info *tti = tgt_th_info(env);
struct object_update *update = tti->tti_u.update.tti_update;
struct lu_buf *lbuf = &tti->tti_buf;
struct object_update_reply *reply = tti->tti_u.update.tti_update_reply;
struct dt_object *obj = tti->tti_u.update.tti_dt_object;
char *name;
struct object_update_result *update_result;
int idx = tti->tti_u.update.tti_update_reply_index;
int rc;
ENTRY;
if (!lu_object_exists(&obj->do_lu)) {
set_bit(LU_OBJECT_HEARD_BANSHEE,
&obj->do_lu.lo_header->loh_flags);
RETURN(-ENOENT);
}
name = object_update_param_get(update, 0, NULL);
if (name == NULL) {
CERROR("%s: empty name for xattr get: rc = %d\n",
tgt_name(tsi->tsi_tgt), -EPROTO);
RETURN(err_serious(-EPROTO));
}
update_result = object_update_result_get(reply, 0, NULL);
if (update_result == NULL) {
CERROR("%s: empty name for xattr get: rc = %d\n",
tgt_name(tsi->tsi_tgt), -EPROTO);
RETURN(err_serious(-EPROTO));
}
lbuf->lb_buf = update_result->our_data;
lbuf->lb_len = OUT_UPDATE_REPLY_SIZE -
cfs_size_round((unsigned long)update_result->our_data -
(unsigned long)update_result);
dt_read_lock(env, obj, MOR_TGT_CHILD);
rc = dt_xattr_get(env, obj, lbuf, name, NULL);
dt_read_unlock(env, obj);
if (rc < 0) {
lbuf->lb_len = 0;
GOTO(out, rc);
}
if (rc == 0) {
lbuf->lb_len = 0;
GOTO(out, rc = -ENOENT);
}
lbuf->lb_len = rc;
rc = 0;
CDEBUG(D_INFO, "%s: "DFID" get xattr %s len %d\n",
tgt_name(tsi->tsi_tgt), PFID(lu_object_fid(&obj->do_lu)),
name, (int)lbuf->lb_len);
GOTO(out, rc);
out:
object_update_result_insert(reply, lbuf->lb_buf, lbuf->lb_len, idx, rc);
RETURN(rc);
}
static int out_attr_get(struct tgt_session_info *tsi)
{
const struct lu_env *env = tsi->tsi_env;
struct tgt_thread_info *tti = tgt_th_info(env);
struct obdo *obdo = &tti->tti_u.update.tti_obdo;
struct lu_attr *la = &tti->tti_attr;
struct dt_object *obj = tti->tti_u.update.tti_dt_object;
int idx = tti->tti_u.update.tti_update_reply_index;
int rc;
ENTRY;
if (!lu_object_exists(&obj->do_lu)) {
/* Usually, this will be called when the master MDT try
* to init a remote object(see osp_object_init), so if
* the object does not exist on slave, we need set BANSHEE flag,
* so the object can be removed from the cache immediately */
set_bit(LU_OBJECT_HEARD_BANSHEE,
&obj->do_lu.lo_header->loh_flags);
RETURN(-ENOENT);
}
dt_read_lock(env, obj, MOR_TGT_CHILD);
rc = dt_attr_get(env, obj, la, NULL);
if (rc)
GOTO(out_unlock, rc);
/*
* If it is a directory, we will also check whether the
* directory is empty.
* la_flags = 0 : Empty.
* = 1 : Not empty.
*/
la->la_flags = 0;
if (S_ISDIR(la->la_mode)) {
struct dt_it *it;
const struct dt_it_ops *iops;
if (!dt_try_as_dir(env, obj))
GOTO(out_unlock, rc = -ENOTDIR);
iops = &obj->do_index_ops->dio_it;
it = iops->init(env, obj, LUDA_64BITHASH, BYPASS_CAPA);
if (!IS_ERR(it)) {
int result;
result = iops->get(env, it, (const void *)"");
if (result > 0) {
int i;
for (result = 0, i = 0; result == 0 && i < 3;
++i)
result = iops->next(env, it);
if (result == 0)
la->la_flags = 1;
} else if (result == 0)
/*
* Huh? Index contains no zero key?
*/
rc = -EIO;
iops->put(env, it);
iops->fini(env, it);
}
}
obdo->o_valid = 0;
obdo_from_la(obdo, la, la->la_valid);
obdo_cpu_to_le(obdo, obdo);
lustre_set_wire_obdo(NULL, obdo, obdo);
out_unlock:
dt_read_unlock(env, obj);
CDEBUG(D_INFO, "%s: insert attr get reply %p index %d: rc = %d\n",
tgt_name(tsi->tsi_tgt), tti->tti_u.update.tti_update_reply,
0, rc);
object_update_result_insert(tti->tti_u.update.tti_update_reply, obdo,
sizeof(*obdo), idx, rc);
RETURN(rc);
}
