* GPL HEADER END
*/
/*
- * Copyright (c) 2013, 2016, Intel Corporation.
+ * Copyright (c) 2013, 2017, Intel Corporation.
*
* lustre/target/out_handler.c
*
dt_obd_name(dt), reply, index, 0);
object_update_result_insert(reply, NULL, 0, index, 0);
- return;
}
typedef void (*out_reconstruct_t)(const struct lu_env *env,
RETURN(-ENOENT);
}
- dt_read_lock(env, obj, MOR_TGT_CHILD);
+ dt_read_lock(env, obj, DT_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);
RETURN(PTR_ERR(name));
}
- update_result = object_update_result_get(reply, 0, NULL);
+ update_result = object_update_result_get(reply, idx, NULL);
if (update_result == NULL) {
CERROR("%s: empty name for xattr get: rc = %d\n",
tgt_name(tsi->tsi_tgt), -EPROTO);
}
lbuf->lb_len = (int)tti->tti_u.update.tti_update->ou_result_size;
- lbuf->lb_buf = update_result->our_data;
if (lbuf->lb_len == 0)
lbuf->lb_buf = NULL;
- dt_read_lock(env, obj, MOR_TGT_CHILD);
+ else
+ lbuf->lb_buf = update_result->our_data;
+
+ dt_read_lock(env, obj, DT_TGT_CHILD);
rc = dt_xattr_get(env, obj, lbuf, name);
dt_read_unlock(env, obj);
if (rc <= 0) {
} else if (lbuf->lb_buf) {
lbuf->lb_len = rc;
}
-
- CDEBUG(D_INFO, "%s: "DFID" get xattr %s len %d: rc = %d\n",
+ 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, rc);
+ name, rc);
+
+ GOTO(out, rc);
+out:
object_update_result_insert(reply, lbuf->lb_buf, lbuf->lb_len, idx, rc);
RETURN(0);
}
+static int out_xattr_list(struct tgt_session_info *tsi)
+{
+ const struct lu_env *env = tsi->tsi_env;
+ struct tgt_thread_info *tti = tgt_th_info(env);
+ 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;
+ 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);
+ }
+
+ update_result = object_update_result_get(reply, 0, NULL);
+ if (!update_result) {
+ rc = -EPROTO;
+ CERROR("%s: empty buf for xattr list: rc = %d\n",
+ tgt_name(tsi->tsi_tgt), rc);
+ RETURN(rc);
+ }
+
+ lbuf->lb_len = (int)tti->tti_u.update.tti_update->ou_result_size;
+ lbuf->lb_buf = update_result->our_data;
+ if (lbuf->lb_len == 0)
+ lbuf->lb_buf = 0;
+
+ dt_read_lock(env, obj, DT_TGT_CHILD);
+ rc = dt_xattr_list(env, obj, lbuf);
+ dt_read_unlock(env, obj);
+ if (rc <= 0) {
+ lbuf->lb_len = 0;
+ if (unlikely(!rc))
+ rc = -ENODATA;
+ } else if (lbuf->lb_buf) {
+ lbuf->lb_len = rc;
+ }
+
+ CDEBUG(D_INFO, "%s: "DFID" list xattr len %d\n",
+ tgt_name(tsi->tsi_tgt), PFID(lu_object_fid(&obj->do_lu)), rc);
+
+ /* Since we directly use update_result->our_data as the lbuf->lb_buf,
+ * then use NULL for result_insert to avoid unnecessary memory copy. */
+ object_update_result_insert(reply, NULL, lbuf->lb_len, idx, rc);
+
+ RETURN(0);
+}
+
static int out_index_lookup(struct tgt_session_info *tsi)
{
const struct lu_env *env = tsi->tsi_env;
RETURN(PTR_ERR(name));
}
- dt_read_lock(env, obj, MOR_TGT_CHILD);
+ dt_read_lock(env, obj, DT_TGT_CHILD);
if (!dt_try_as_dir(env, obj))
GOTO(out_unlock, rc = -ENOTDIR);
tti->tti_tea.ta_handle,
tti->tti_u.update.tti_update_reply,
tti->tti_u.update.tti_update_reply_index);
+
+ CDEBUG(D_INFO, "%s: "DFID" index insert %s: rc = %d\n",
+ tgt_name(tsi->tsi_tgt), PFID(lu_object_fid(&obj->do_lu)),
+ name, rc);
+
RETURN(rc);
}
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]));
+ OBD_ALLOC(rdbuf, sizeof(*rdbuf) + nbufs * sizeof(rdbuf->rb_bufs[0]));
if (rdbuf == NULL)
GOTO(out, rc = -ENOMEM);
GOTO(out_free, rc = -ENOMEM);
rdbuf->rb_bufs[i].lb_len = read_size;
- dt_read_lock(env, obj, MOR_TGT_CHILD);
+ dt_read_lock(env, obj, DT_TGT_CHILD);
rc = dt_read(env, obj, &rdbuf->rb_bufs[i], &pos);
dt_read_unlock(env, obj);
rdbuf->rb_bufs[i].lb_len);
}
}
- OBD_FREE(rdbuf, sizeof(struct lu_rdbuf) +
+ OBD_FREE(rdbuf, sizeof(*rdbuf) +
nbufs * sizeof(rdbuf->rb_bufs[0]));
out:
/* Insert read buffer */
}
static struct tgt_handler out_update_ops[] = {
- DEF_OUT_HNDL(OUT_CREATE, "out_create", MUTABOR | HABEO_REFERO,
+ DEF_OUT_HNDL(OUT_CREATE, "out_create", IS_MUTABLE | HAS_REPLY,
out_create),
- DEF_OUT_HNDL(OUT_DESTROY, "out_create", MUTABOR | HABEO_REFERO,
+ DEF_OUT_HNDL(OUT_DESTROY, "out_create", IS_MUTABLE | HAS_REPLY,
out_destroy),
- DEF_OUT_HNDL(OUT_REF_ADD, "out_ref_add", MUTABOR | HABEO_REFERO,
+ DEF_OUT_HNDL(OUT_REF_ADD, "out_ref_add", IS_MUTABLE | HAS_REPLY,
out_ref_add),
- DEF_OUT_HNDL(OUT_REF_DEL, "out_ref_del", MUTABOR | HABEO_REFERO,
+ DEF_OUT_HNDL(OUT_REF_DEL, "out_ref_del", IS_MUTABLE | HAS_REPLY,
out_ref_del),
- DEF_OUT_HNDL(OUT_ATTR_SET, "out_attr_set", MUTABOR | HABEO_REFERO,
+ DEF_OUT_HNDL(OUT_ATTR_SET, "out_attr_set", IS_MUTABLE | HAS_REPLY,
out_attr_set),
- DEF_OUT_HNDL(OUT_ATTR_GET, "out_attr_get", HABEO_REFERO,
+ DEF_OUT_HNDL(OUT_ATTR_GET, "out_attr_get", HAS_REPLY,
out_attr_get),
- DEF_OUT_HNDL(OUT_XATTR_SET, "out_xattr_set", MUTABOR | HABEO_REFERO,
+ DEF_OUT_HNDL(OUT_XATTR_SET, "out_xattr_set", IS_MUTABLE | HAS_REPLY,
out_xattr_set),
- DEF_OUT_HNDL(OUT_XATTR_DEL, "out_xattr_del", MUTABOR | HABEO_REFERO,
+ DEF_OUT_HNDL(OUT_XATTR_DEL, "out_xattr_del", IS_MUTABLE | HAS_REPLY,
out_xattr_del),
- DEF_OUT_HNDL(OUT_XATTR_GET, "out_xattr_get", HABEO_REFERO,
+ DEF_OUT_HNDL(OUT_XATTR_GET, "out_xattr_get", HAS_REPLY,
out_xattr_get),
- DEF_OUT_HNDL(OUT_INDEX_LOOKUP, "out_index_lookup", HABEO_REFERO,
+ DEF_OUT_HNDL(OUT_INDEX_LOOKUP, "out_index_lookup", HAS_REPLY,
out_index_lookup),
DEF_OUT_HNDL(OUT_INDEX_INSERT, "out_index_insert",
- MUTABOR | HABEO_REFERO, out_index_insert),
+ IS_MUTABLE | HAS_REPLY, out_index_insert),
DEF_OUT_HNDL(OUT_INDEX_DELETE, "out_index_delete",
- MUTABOR | HABEO_REFERO, out_index_delete),
- DEF_OUT_HNDL(OUT_WRITE, "out_write", MUTABOR | HABEO_REFERO, out_write),
- DEF_OUT_HNDL(OUT_READ, "out_read", HABEO_REFERO, out_read),
- DEF_OUT_HNDL(OUT_NOOP, "out_noop", HABEO_REFERO, out_noop),
+ IS_MUTABLE | HAS_REPLY, out_index_delete),
+ DEF_OUT_HNDL(OUT_WRITE, "out_write", IS_MUTABLE | HAS_REPLY, out_write),
+ DEF_OUT_HNDL(OUT_READ, "out_read", HAS_REPLY, out_read),
+ DEF_OUT_HNDL(OUT_NOOP, "out_noop", HAS_REPLY, out_noop),
+ DEF_OUT_HNDL(OUT_XATTR_LIST, "out_xattr_list", HAS_REPLY,
+ out_xattr_list),
};
static struct tgt_handler *out_handler_find(__u32 opc)
rc = dt_trans_stop(env, ta->ta_handle->th_dev, ta->ta_handle);
for (i = 0; i < ta->ta_argno; i++) {
if (ta->ta_args[i]->object != NULL) {
- struct dt_object *obj = ta->ta_args[i]->object;
-
- /* If the object is being created during this
- * transaction, we need to remove them from the
- * cache immediately, because a few layers are
- * missing in OUT handler, i.e. the object might
- * not be initialized in all layers */
- if (ta->ta_args[i]->exec_fn == out_tx_create_exec)
- set_bit(LU_OBJECT_HEARD_BANSHEE,
- &obj->do_lu.lo_header->loh_flags);
- lu_object_put(env, &ta->ta_args[i]->object->do_lu);
+ dt_object_put(env, ta->ta_args[i]->object);
ta->ta_args[i]->object = 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;
update_bufs[0] = ouh->ouh_inline_data;
} else {
struct out_update_buffer *tmp;
+ int page_count = 0;
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,
+ for (i = 0; i < update_buf_count; i++)
+ /* First *and* last might be partial pages, hence +1 */
+ page_count += DIV_ROUND_UP(oub[i].oub_size,
+ PAGE_SIZE) + 1;
+
+ desc = ptlrpc_prep_bulk_exp(pill->rc_req, page_count,
PTLRPC_BULK_OPS_COUNT,
PTLRPC_BULK_GET_SINK |
- PTLRPC_BULK_BUF_KVEC,
+ PTLRPC_BULK_BUF_KIOV,
MDS_BULK_PORTAL,
- &ptlrpc_bulk_kvec_ops);
+ &ptlrpc_bulk_kiov_nopin_ops);
if (desc == NULL)
GOTO(out_free, rc = err_serious(-ENOMEM));
if (tmp->oub_size >= OUT_MAXREQSIZE)
GOTO(out_free, rc = err_serious(-EPROTO));
- OBD_ALLOC(update_bufs[i], tmp->oub_size);
+ OBD_ALLOC_LARGE(update_bufs[i], tmp->oub_size);
if (update_bufs[i] == NULL)
GOTO(out_free, rc = err_serious(-ENOMEM));
if (rc != 0)
GOTO(out_free, rc = err_serious(rc));
- rc = target_bulk_io(pill->rc_req->rq_export, desc, &lwi);
+ rc = target_bulk_io(pill->rc_req->rq_export, desc);
if (rc < 0)
GOTO(out_free, rc = err_serious(rc));
}
GOTO(out, rc = PTR_ERR(dt_obj));
if (dt->dd_record_fid_accessed) {
- lfsck_pack_rfa(&tti->tti_lr,
+ struct lfsck_req_local *lrl = &tti->tti_lrl;
+
+ lfsck_pack_rfa(lrl,
lu_object_fid(&dt_obj->do_lu),
- LE_FID_ACCESSED,
+ LEL_FID_ACCESSED,
LFSCK_TYPE_LAYOUT);
- tgt_lfsck_in_notify(env, dt, &tti->tti_lr,
- NULL);
+ tgt_lfsck_in_notify_local(env, dt, lrl, NULL);
}
tti->tti_u.update.tti_dt_object = dt_obj;
}
/* Check resend case only for modifying RPC */
- if (h->th_flags & MUTABOR) {
+ if (h->th_flags & IS_MUTABLE) {
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);
+
+ if (dt->dd_rdonly)
+ GOTO(next, rc = -EROFS);
}
/* start transaction for modification RPC only */
- if (h->th_flags & MUTABOR && current_batchid == -1) {
+ if (h->th_flags & IS_MUTABLE && current_batchid == -1) {
current_batchid = update->ou_batchid;
rc = out_tx_start(env, dt, ta, tsi->tsi_exp);
if (rc != 0)
/* 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)) &&
+ !(h->th_flags & IS_MUTABLE)) &&
ta->ta_handle != NULL) {
rc = out_tx_end(env, ta, rc);
current_batchid = -1;
GOTO(next, rc);
/* start a new transaction if needed */
- if (h->th_flags & MUTABOR) {
+ if (h->th_flags & IS_MUTABLE) {
rc = out_tx_start(env, dt, ta,
tsi->tsi_exp);
if (rc != 0)
rc = h->th_act(tsi);
next:
reply_index++;
- lu_object_put(env, &dt_obj->do_lu);
+ dt_object_put(env, dt_obj);
if (rc < 0)
GOTO(out, rc);
}
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_LARGE(update_bufs[i],
+ oub->oub_size);
}
}
}
struct tgt_handler tgt_out_handlers[] = {
-TGT_UPDATE_HDL(MUTABOR, OUT_UPDATE, out_handle),
+TGT_UPDATE_HDL(IS_MUTABLE, OUT_UPDATE, out_handle),
};
EXPORT_SYMBOL(tgt_out_handlers);
git://git.whamcloud.com / fs / lustre-release.git / blobdiff