4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 only,
8 * as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License version 2 for more details (a copy is included
14 * in the LICENSE file that accompanied this code).
16 * You should have received a copy of the GNU General Public License
17 * version 2 along with this program; If not, see
18 * http://www.gnu.org/licenses/gpl-2.0.html
23 * Copyright (c) 2013, 2014, Intel Corporation.
25 * lustre/target/out_handler.c
27 * Object update handler between targets.
29 * Author: di.wang <di.wang@intel.com>
32 #define DEBUG_SUBSYSTEM S_CLASS
34 #include <obd_class.h>
35 #include <md_object.h>
36 #include "tgt_internal.h"
37 #include <lustre_update.h>
39 static int tx_extend_args(struct thandle_exec_args *ta, int new_alloc_ta)
41 struct tx_arg **new_ta;
45 if (ta->ta_alloc_args >= new_alloc_ta)
48 OBD_ALLOC(new_ta, sizeof(*new_ta) * new_alloc_ta);
52 for (i = 0; i < new_alloc_ta; i++) {
53 if (i < ta->ta_alloc_args) {
54 /* copy the old args to new one */
55 new_ta[i] = ta->ta_args[i];
57 OBD_ALLOC_PTR(new_ta[i]);
58 if (new_ta[i] == NULL)
59 GOTO(out, rc = -ENOMEM);
63 /* free the old args */
64 if (ta->ta_args != NULL)
65 OBD_FREE(ta->ta_args, sizeof(ta->ta_args[0]) *
69 ta->ta_alloc_args = new_alloc_ta;
72 for (i = 0; i < new_alloc_ta; i++) {
73 if (new_ta[i] != NULL)
74 OBD_FREE_PTR(new_ta[i]);
76 OBD_FREE(new_ta, sizeof(*new_ta) * new_alloc_ta);
81 #define TX_ALLOC_STEP 8
82 static struct tx_arg *tx_add_exec(struct thandle_exec_args *ta,
83 tx_exec_func_t func, tx_exec_func_t undo,
84 const char *file, int line)
90 LASSERT(func != NULL);
92 if (ta->ta_argno + 1 >= ta->ta_alloc_args) {
93 rc = tx_extend_args(ta, ta->ta_alloc_args + TX_ALLOC_STEP);
102 ta->ta_args[i]->exec_fn = func;
103 ta->ta_args[i]->undo_fn = undo;
104 ta->ta_args[i]->file = file;
105 ta->ta_args[i]->line = line;
107 return ta->ta_args[i];
110 static void out_reconstruct(const struct lu_env *env, struct dt_device *dt,
111 struct dt_object *obj,
112 struct object_update_reply *reply,
115 CDEBUG(D_INFO, "%s: fork reply reply %p index %d: rc = %d\n",
116 dt_obd_name(dt), reply, index, 0);
118 object_update_result_insert(reply, NULL, 0, index, 0);
122 typedef void (*out_reconstruct_t)(const struct lu_env *env,
123 struct dt_device *dt,
124 struct dt_object *obj,
125 struct object_update_reply *reply,
128 static inline int out_check_resent(const struct lu_env *env,
129 struct dt_device *dt,
130 struct dt_object *obj,
131 struct ptlrpc_request *req,
132 out_reconstruct_t reconstruct,
133 struct object_update_reply *reply,
136 if (likely(!(lustre_msg_get_flags(req->rq_reqmsg) & MSG_RESENT)))
139 if (req_xid_is_last(req)) {
140 reconstruct(env, dt, obj, reply, index);
143 DEBUG_REQ(D_HA, req, "no reply for RESENT req (have "LPD64")",
144 req->rq_export->exp_target_data.ted_lcd->lcd_last_xid);
148 static int out_obj_destroy(const struct lu_env *env, struct dt_object *dt_obj,
153 CDEBUG(D_INFO, "%s: destroy "DFID"\n", dt_obd_name(th->th_dev),
154 PFID(lu_object_fid(&dt_obj->do_lu)));
156 dt_write_lock(env, dt_obj, MOR_TGT_CHILD);
157 rc = dt_destroy(env, dt_obj, th);
158 dt_write_unlock(env, dt_obj);
164 * All of the xxx_undo will be used once execution failed,
165 * But because all of the required resource has been reserved in
166 * declare phase, i.e. if declare succeed, it should make sure
167 * the following executing phase succeed in anyway, so these undo
168 * should be useless for most of the time in Phase I
170 static int out_tx_create_undo(const struct lu_env *env, struct thandle *th,
175 rc = out_obj_destroy(env, arg->object, th);
177 CERROR("%s: undo failure, we are doomed!: rc = %d\n",
178 dt_obd_name(th->th_dev), rc);
182 static int out_tx_create_exec(const struct lu_env *env, struct thandle *th,
185 struct dt_object *dt_obj = arg->object;
188 CDEBUG(D_OTHER, "%s: create "DFID": dof %u, mode %o\n",
189 dt_obd_name(th->th_dev),
190 PFID(lu_object_fid(&arg->object->do_lu)),
191 arg->u.create.dof.dof_type,
192 arg->u.create.attr.la_mode & S_IFMT);
194 dt_write_lock(env, dt_obj, MOR_TGT_CHILD);
195 rc = dt_create(env, dt_obj, &arg->u.create.attr,
196 &arg->u.create.hint, &arg->u.create.dof, th);
198 dt_write_unlock(env, dt_obj);
200 CDEBUG(D_INFO, "%s: insert create reply %p index %d: rc = %d\n",
201 dt_obd_name(th->th_dev), arg->reply, arg->index, rc);
203 object_update_result_insert(arg->reply, NULL, 0, arg->index, rc);
208 static int __out_tx_create(const struct lu_env *env, struct dt_object *obj,
209 struct lu_attr *attr, struct lu_fid *parent_fid,
210 struct dt_object_format *dof,
211 struct thandle_exec_args *ta,
212 struct object_update_reply *reply,
213 int index, const char *file, int line)
218 LASSERT(ta->ta_handle != NULL);
219 rc = dt_declare_create(env, obj, attr, NULL, dof,
224 arg = tx_add_exec(ta, out_tx_create_exec, out_tx_create_undo, file,
229 /* release the object in out_trans_stop */
230 lu_object_get(&obj->do_lu);
232 arg->u.create.attr = *attr;
233 if (parent_fid != NULL)
234 arg->u.create.fid = *parent_fid;
235 memset(&arg->u.create.hint, 0, sizeof(arg->u.create.hint));
236 arg->u.create.dof = *dof;
243 static int out_create(struct tgt_session_info *tsi)
245 struct tgt_thread_info *tti = tgt_th_info(tsi->tsi_env);
246 struct object_update *update = tti->tti_u.update.tti_update;
247 struct dt_object *obj = tti->tti_u.update.tti_dt_object;
248 struct dt_object_format *dof = &tti->tti_u.update.tti_update_dof;
249 struct obdo *lobdo = &tti->tti_u.update.tti_obdo;
250 struct lu_attr *attr = &tti->tti_attr;
251 struct lu_fid *fid = NULL;
258 wobdo = object_update_param_get(update, 0, &size);
259 if (wobdo == NULL || IS_ERR(wobdo) || size != sizeof(*wobdo)) {
260 CERROR("%s: obdo is NULL, invalid RPC: rc = %d\n",
261 tgt_name(tsi->tsi_tgt), -EPROTO);
262 RETURN(err_serious(-EPROTO));
265 if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
266 lustre_swab_obdo(wobdo);
267 lustre_get_wire_obdo(NULL, lobdo, wobdo);
268 la_from_obdo(attr, lobdo, lobdo->o_valid);
270 dof->dof_type = dt_mode_to_dft(attr->la_mode);
271 if (update->ou_params_count > 1) {
272 fid = object_update_param_get(update, 1, &size);
273 if (fid == NULL || IS_ERR(fid) || size != sizeof(*fid)) {
274 CERROR("%s: invalid fid: rc = %d\n",
275 tgt_name(tsi->tsi_tgt), -EPROTO);
276 RETURN(err_serious(-EPROTO));
278 if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
279 lustre_swab_lu_fid(fid);
280 if (!fid_is_sane(fid)) {
281 CERROR("%s: invalid fid "DFID": rc = %d\n",
282 tgt_name(tsi->tsi_tgt), PFID(fid), -EPROTO);
283 RETURN(err_serious(-EPROTO));
287 if (lu_object_exists(&obj->do_lu))
290 rc = out_tx_create(tsi->tsi_env, obj, attr, fid, dof,
292 tti->tti_u.update.tti_update_reply,
293 tti->tti_u.update.tti_update_reply_index);
298 static int out_tx_attr_set_undo(const struct lu_env *env,
299 struct thandle *th, struct tx_arg *arg)
301 CERROR("%s: attr set undo "DFID" unimplemented yet!: rc = %d\n",
302 dt_obd_name(th->th_dev),
303 PFID(lu_object_fid(&arg->object->do_lu)), -ENOTSUPP);
308 static int out_tx_attr_set_exec(const struct lu_env *env, struct thandle *th,
311 struct dt_object *dt_obj = arg->object;
314 CDEBUG(D_OTHER, "%s: attr set "DFID"\n", dt_obd_name(th->th_dev),
315 PFID(lu_object_fid(&dt_obj->do_lu)));
317 dt_write_lock(env, dt_obj, MOR_TGT_CHILD);
318 rc = dt_attr_set(env, dt_obj, &arg->u.attr_set.attr, th);
319 dt_write_unlock(env, dt_obj);
321 CDEBUG(D_INFO, "%s: insert attr_set reply %p index %d: rc = %d\n",
322 dt_obd_name(th->th_dev), arg->reply, arg->index, rc);
324 object_update_result_insert(arg->reply, NULL, 0, arg->index, rc);
329 static int __out_tx_attr_set(const struct lu_env *env,
330 struct dt_object *dt_obj,
331 const struct lu_attr *attr,
332 struct thandle_exec_args *th,
333 struct object_update_reply *reply,
334 int index, const char *file, int line)
339 LASSERT(th->ta_handle != NULL);
340 rc = dt_declare_attr_set(env, dt_obj, attr, th->ta_handle);
344 arg = tx_add_exec(th, out_tx_attr_set_exec, out_tx_attr_set_undo,
349 lu_object_get(&dt_obj->do_lu);
350 arg->object = dt_obj;
351 arg->u.attr_set.attr = *attr;
357 static int out_attr_set(struct tgt_session_info *tsi)
359 struct tgt_thread_info *tti = tgt_th_info(tsi->tsi_env);
360 struct object_update *update = tti->tti_u.update.tti_update;
361 struct lu_attr *attr = &tti->tti_attr;
362 struct dt_object *obj = tti->tti_u.update.tti_dt_object;
363 struct obdo *lobdo = &tti->tti_u.update.tti_obdo;
370 wobdo = object_update_param_get(update, 0, &size);
371 if (wobdo == NULL || IS_ERR(wobdo) || size != sizeof(*wobdo)) {
372 CERROR("%s: empty obdo in the update: rc = %d\n",
373 tgt_name(tsi->tsi_tgt), -EPROTO);
374 RETURN(err_serious(-EPROTO));
380 if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
381 lustre_swab_obdo(wobdo);
382 lustre_get_wire_obdo(NULL, lobdo, wobdo);
383 la_from_obdo(attr, lobdo, lobdo->o_valid);
385 rc = out_tx_attr_set(tsi->tsi_env, obj, attr, &tti->tti_tea,
386 tti->tti_u.update.tti_update_reply,
387 tti->tti_u.update.tti_update_reply_index);
392 static int out_attr_get(struct tgt_session_info *tsi)
394 const struct lu_env *env = tsi->tsi_env;
395 struct tgt_thread_info *tti = tgt_th_info(env);
396 struct obdo *obdo = &tti->tti_u.update.tti_obdo;
397 struct lu_attr *la = &tti->tti_attr;
398 struct dt_object *obj = tti->tti_u.update.tti_dt_object;
399 int idx = tti->tti_u.update.tti_update_reply_index;
404 if (!lu_object_exists(&obj->do_lu)) {
405 /* Usually, this will be called when the master MDT try
406 * to init a remote object(see osp_object_init), so if
407 * the object does not exist on slave, we need set BANSHEE flag,
408 * so the object can be removed from the cache immediately */
409 set_bit(LU_OBJECT_HEARD_BANSHEE,
410 &obj->do_lu.lo_header->loh_flags);
414 dt_read_lock(env, obj, MOR_TGT_CHILD);
415 rc = dt_attr_get(env, obj, la);
417 GOTO(out_unlock, rc);
420 obdo_from_la(obdo, la, la->la_valid);
421 lustre_set_wire_obdo(NULL, obdo, obdo);
424 dt_read_unlock(env, obj);
426 CDEBUG(D_INFO, "%s: insert attr get reply %p index %d: rc = %d\n",
427 tgt_name(tsi->tsi_tgt), tti->tti_u.update.tti_update_reply,
430 object_update_result_insert(tti->tti_u.update.tti_update_reply, obdo,
431 sizeof(*obdo), idx, rc);
436 static int out_xattr_get(struct tgt_session_info *tsi)
438 const struct lu_env *env = tsi->tsi_env;
439 struct tgt_thread_info *tti = tgt_th_info(env);
440 struct object_update *update = tti->tti_u.update.tti_update;
441 struct lu_buf *lbuf = &tti->tti_buf;
442 struct object_update_reply *reply = tti->tti_u.update.tti_update_reply;
443 struct dt_object *obj = tti->tti_u.update.tti_dt_object;
445 struct object_update_result *update_result;
446 int idx = tti->tti_u.update.tti_update_reply_index;
451 if (!lu_object_exists(&obj->do_lu)) {
452 set_bit(LU_OBJECT_HEARD_BANSHEE,
453 &obj->do_lu.lo_header->loh_flags);
457 name = object_update_param_get(update, 0, NULL);
458 if (name == NULL || IS_ERR(name)) {
459 CERROR("%s: empty name for xattr get: rc = %d\n",
460 tgt_name(tsi->tsi_tgt), -EPROTO);
461 RETURN(err_serious(-EPROTO));
464 update_result = object_update_result_get(reply, 0, NULL);
465 if (update_result == NULL) {
466 CERROR("%s: empty name for xattr get: rc = %d\n",
467 tgt_name(tsi->tsi_tgt), -EPROTO);
468 RETURN(err_serious(-EPROTO));
471 lbuf->lb_buf = update_result->our_data;
472 lbuf->lb_len = OUT_UPDATE_REPLY_SIZE -
473 cfs_size_round((unsigned long)update_result->our_data -
474 (unsigned long)update_result);
475 dt_read_lock(env, obj, MOR_TGT_CHILD);
476 rc = dt_xattr_get(env, obj, lbuf, name);
477 dt_read_unlock(env, obj);
484 CDEBUG(D_INFO, "%s: "DFID" get xattr %s len %d\n",
485 tgt_name(tsi->tsi_tgt), PFID(lu_object_fid(&obj->do_lu)),
486 name, (int)lbuf->lb_len);
491 object_update_result_insert(reply, lbuf->lb_buf, lbuf->lb_len, idx, rc);
495 static int out_index_lookup(struct tgt_session_info *tsi)
497 const struct lu_env *env = tsi->tsi_env;
498 struct tgt_thread_info *tti = tgt_th_info(env);
499 struct object_update *update = tti->tti_u.update.tti_update;
500 struct dt_object *obj = tti->tti_u.update.tti_dt_object;
506 if (!lu_object_exists(&obj->do_lu))
509 name = object_update_param_get(update, 0, NULL);
510 if (name == NULL || IS_ERR(name)) {
511 CERROR("%s: empty name for lookup: rc = %d\n",
512 tgt_name(tsi->tsi_tgt), -EPROTO);
513 RETURN(err_serious(-EPROTO));
516 dt_read_lock(env, obj, MOR_TGT_CHILD);
517 if (!dt_try_as_dir(env, obj))
518 GOTO(out_unlock, rc = -ENOTDIR);
520 rc = dt_lookup(env, obj, (struct dt_rec *)&tti->tti_fid1,
521 (struct dt_key *)name);
524 GOTO(out_unlock, rc);
530 dt_read_unlock(env, obj);
532 CDEBUG(D_INFO, "lookup "DFID" %s get "DFID" rc %d\n",
533 PFID(lu_object_fid(&obj->do_lu)), name,
534 PFID(&tti->tti_fid1), rc);
536 CDEBUG(D_INFO, "%s: insert lookup reply %p index %d: rc = %d\n",
537 tgt_name(tsi->tsi_tgt), tti->tti_u.update.tti_update_reply,
540 object_update_result_insert(tti->tti_u.update.tti_update_reply,
541 &tti->tti_fid1, sizeof(tti->tti_fid1),
542 tti->tti_u.update.tti_update_reply_index, rc);
546 static int out_tx_xattr_set_exec(const struct lu_env *env,
550 struct dt_object *dt_obj = arg->object;
553 CDEBUG(D_INFO, "%s: set xattr buf %p name %s flag %d\n",
554 dt_obd_name(th->th_dev), arg->u.xattr_set.buf.lb_buf,
555 arg->u.xattr_set.name, arg->u.xattr_set.flags);
557 if (!lu_object_exists(&dt_obj->do_lu))
558 GOTO(out, rc = -ENOENT);
560 dt_write_lock(env, dt_obj, MOR_TGT_CHILD);
561 rc = dt_xattr_set(env, dt_obj, &arg->u.xattr_set.buf,
562 arg->u.xattr_set.name, arg->u.xattr_set.flags, th);
564 * Ignore errors if this is LINK EA
566 if (unlikely(rc != 0 &&
567 strcmp(arg->u.xattr_set.name, XATTR_NAME_LINK) == 0)) {
568 /* XXX: If the linkEA is overflow, then we need to notify the
569 * namespace LFSCK to skip "nlink" attribute verification
570 * on this object to avoid the "nlink" to be shrinked by
571 * wrong. It may be not good an interaction with LFSCK
572 * like this. We will consider to replace it with other
573 * mechanism in future. LU-5802. */
575 struct lfsck_request *lr = &tgt_th_info(env)->tti_lr;
577 lfsck_pack_rfa(lr, lu_object_fid(&dt_obj->do_lu),
578 LE_SKIP_NLINK, LFSCK_TYPE_NAMESPACE);
579 tgt_lfsck_in_notify(env,
580 tgt_ses_info(env)->tsi_tgt->lut_bottom, lr, th);
585 dt_write_unlock(env, dt_obj);
588 CDEBUG(D_INFO, "%s: insert xattr set reply %p index %d: rc = %d\n",
589 dt_obd_name(th->th_dev), arg->reply, arg->index, rc);
591 object_update_result_insert(arg->reply, NULL, 0, arg->index, rc);
596 static int __out_tx_xattr_set(const struct lu_env *env,
597 struct dt_object *dt_obj,
598 const struct lu_buf *buf,
599 const char *name, int flags,
600 struct thandle_exec_args *ta,
601 struct object_update_reply *reply,
602 int index, const char *file, int line)
607 LASSERT(ta->ta_handle != NULL);
608 rc = dt_declare_xattr_set(env, dt_obj, buf, name, flags, ta->ta_handle);
612 if (strcmp(name, XATTR_NAME_LINK) == 0) {
613 struct lfsck_request *lr = &tgt_th_info(env)->tti_lr;
615 /* XXX: If the linkEA is overflow, then we need to notify the
616 * namespace LFSCK to skip "nlink" attribute verification
617 * on this object to avoid the "nlink" to be shrinked by
618 * wrong. It may be not good an interaction with LFSCK
619 * like this. We will consider to replace it with other
620 * mechanism in future. LU-5802. */
621 lfsck_pack_rfa(lr, lu_object_fid(&dt_obj->do_lu),
622 LE_SKIP_NLINK_DECLARE, LFSCK_TYPE_NAMESPACE);
623 rc = tgt_lfsck_in_notify(env,
624 tgt_ses_info(env)->tsi_tgt->lut_bottom,
630 arg = tx_add_exec(ta, out_tx_xattr_set_exec, NULL, file, line);
634 lu_object_get(&dt_obj->do_lu);
635 arg->object = dt_obj;
636 arg->u.xattr_set.name = name;
637 arg->u.xattr_set.flags = flags;
638 arg->u.xattr_set.buf = *buf;
641 arg->u.xattr_set.csum = 0;
645 static int out_xattr_set(struct tgt_session_info *tsi)
647 struct tgt_thread_info *tti = tgt_th_info(tsi->tsi_env);
648 struct object_update *update = tti->tti_u.update.tti_update;
649 struct dt_object *obj = tti->tti_u.update.tti_dt_object;
650 struct lu_buf *lbuf = &tti->tti_buf;
660 name = object_update_param_get(update, 0, NULL);
661 if (name == NULL || IS_ERR(name)) {
662 CERROR("%s: empty name for xattr set: rc = %d\n",
663 tgt_name(tsi->tsi_tgt), -EPROTO);
664 RETURN(err_serious(-EPROTO));
667 buf = object_update_param_get(update, 1, &buf_len);
669 RETURN(err_serious(-EPROTO));
672 lbuf->lb_len = buf_len;
674 tmp = object_update_param_get(update, 2, &size);
675 if (tmp == NULL || size != sizeof(*tmp)) {
676 CERROR("%s: emptry or wrong size %zu flag: rc = %d\n",
677 tgt_name(tsi->tsi_tgt), size, -EPROTO);
678 RETURN(err_serious(-EPROTO));
681 if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
685 rc = out_tx_xattr_set(tsi->tsi_env, obj, lbuf, name, flag,
687 tti->tti_u.update.tti_update_reply,
688 tti->tti_u.update.tti_update_reply_index);
692 static int out_tx_xattr_del_exec(const struct lu_env *env, struct thandle *th,
695 struct dt_object *dt_obj = arg->object;
698 CDEBUG(D_INFO, "%s: del xattr name '%s' on "DFID"\n",
699 dt_obd_name(th->th_dev), arg->u.xattr_set.name,
700 PFID(lu_object_fid(&dt_obj->do_lu)));
702 if (!lu_object_exists(&dt_obj->do_lu))
703 GOTO(out, rc = -ENOENT);
705 dt_write_lock(env, dt_obj, MOR_TGT_CHILD);
706 rc = dt_xattr_del(env, dt_obj, arg->u.xattr_set.name, th);
707 dt_write_unlock(env, dt_obj);
709 CDEBUG(D_INFO, "%s: insert xattr del reply %p index %d: rc = %d\n",
710 dt_obd_name(th->th_dev), arg->reply, arg->index, rc);
712 object_update_result_insert(arg->reply, NULL, 0, arg->index, rc);
717 static int __out_tx_xattr_del(const struct lu_env *env,
718 struct dt_object *dt_obj, const char *name,
719 struct thandle_exec_args *ta,
720 struct object_update_reply *reply,
721 int index, const char *file, int line)
726 rc = dt_declare_xattr_del(env, dt_obj, name, ta->ta_handle);
730 arg = tx_add_exec(ta, out_tx_xattr_del_exec, NULL, file, line);
734 lu_object_get(&dt_obj->do_lu);
735 arg->object = dt_obj;
736 arg->u.xattr_set.name = name;
742 static int out_xattr_del(struct tgt_session_info *tsi)
744 struct tgt_thread_info *tti = tgt_th_info(tsi->tsi_env);
745 struct object_update *update = tti->tti_u.update.tti_update;
746 struct dt_object *obj = tti->tti_u.update.tti_dt_object;
751 name = object_update_param_get(update, 0, NULL);
752 if (name == NULL || IS_ERR(name)) {
753 CERROR("%s: empty name for xattr set: rc = %d\n",
754 tgt_name(tsi->tsi_tgt), -EPROTO);
755 RETURN(err_serious(-EPROTO));
758 rc = out_tx_xattr_del(tsi->tsi_env, obj, name, &tti->tti_tea,
759 tti->tti_u.update.tti_update_reply,
760 tti->tti_u.update.tti_update_reply_index);
764 static int out_obj_ref_add(const struct lu_env *env,
765 struct dt_object *dt_obj,
770 dt_write_lock(env, dt_obj, MOR_TGT_CHILD);
771 rc = dt_ref_add(env, dt_obj, th);
772 dt_write_unlock(env, dt_obj);
777 static int out_obj_ref_del(const struct lu_env *env,
778 struct dt_object *dt_obj,
783 dt_write_lock(env, dt_obj, MOR_TGT_CHILD);
784 rc = dt_ref_del(env, dt_obj, th);
785 dt_write_unlock(env, dt_obj);
790 static int out_tx_ref_add_exec(const struct lu_env *env, struct thandle *th,
793 struct dt_object *dt_obj = arg->object;
796 rc = out_obj_ref_add(env, dt_obj, th);
798 CDEBUG(D_INFO, "%s: insert ref_add reply %p index %d: rc = %d\n",
799 dt_obd_name(th->th_dev), arg->reply, arg->index, rc);
801 object_update_result_insert(arg->reply, NULL, 0, arg->index, rc);
805 static int out_tx_ref_add_undo(const struct lu_env *env, struct thandle *th,
808 return out_obj_ref_del(env, arg->object, th);
811 static int __out_tx_ref_add(const struct lu_env *env,
812 struct dt_object *dt_obj,
813 struct thandle_exec_args *ta,
814 struct object_update_reply *reply,
815 int index, const char *file, int line)
820 LASSERT(ta->ta_handle != NULL);
821 rc = dt_declare_ref_add(env, dt_obj, ta->ta_handle);
825 arg = tx_add_exec(ta, out_tx_ref_add_exec, out_tx_ref_add_undo, file,
830 lu_object_get(&dt_obj->do_lu);
831 arg->object = dt_obj;
838 * increase ref of the object
840 static int out_ref_add(struct tgt_session_info *tsi)
842 struct tgt_thread_info *tti = tgt_th_info(tsi->tsi_env);
843 struct dt_object *obj = tti->tti_u.update.tti_dt_object;
848 rc = out_tx_ref_add(tsi->tsi_env, obj, &tti->tti_tea,
849 tti->tti_u.update.tti_update_reply,
850 tti->tti_u.update.tti_update_reply_index);
854 static int out_tx_ref_del_exec(const struct lu_env *env, struct thandle *th,
857 struct dt_object *dt_obj = arg->object;
860 rc = out_obj_ref_del(env, dt_obj, th);
862 CDEBUG(D_INFO, "%s: insert ref_del reply %p index %d: rc = %d\n",
863 dt_obd_name(th->th_dev), arg->reply, arg->index, 0);
865 object_update_result_insert(arg->reply, NULL, 0, arg->index, rc);
870 static int out_tx_ref_del_undo(const struct lu_env *env, struct thandle *th,
873 return out_obj_ref_add(env, arg->object, th);
876 static int __out_tx_ref_del(const struct lu_env *env,
877 struct dt_object *dt_obj,
878 struct thandle_exec_args *ta,
879 struct object_update_reply *reply,
880 int index, const char *file, int line)
885 LASSERT(ta->ta_handle != NULL);
886 rc = dt_declare_ref_del(env, dt_obj, ta->ta_handle);
890 arg = tx_add_exec(ta, out_tx_ref_del_exec, out_tx_ref_del_undo, file,
895 lu_object_get(&dt_obj->do_lu);
896 arg->object = dt_obj;
902 static int out_ref_del(struct tgt_session_info *tsi)
904 struct tgt_thread_info *tti = tgt_th_info(tsi->tsi_env);
905 struct dt_object *obj = tti->tti_u.update.tti_dt_object;
910 if (!lu_object_exists(&obj->do_lu))
913 rc = out_tx_ref_del(tsi->tsi_env, obj, &tti->tti_tea,
914 tti->tti_u.update.tti_update_reply,
915 tti->tti_u.update.tti_update_reply_index);
919 static int out_obj_index_insert(const struct lu_env *env,
920 struct dt_object *dt_obj,
921 const struct dt_rec *rec,
922 const struct dt_key *key,
927 CDEBUG(D_INFO, "%s: index insert "DFID" name: %s fid "DFID", type %u\n",
928 dt_obd_name(th->th_dev), PFID(lu_object_fid(&dt_obj->do_lu)),
929 (char *)key, PFID(((struct dt_insert_rec *)rec)->rec_fid),
930 ((struct dt_insert_rec *)rec)->rec_type);
932 if (dt_try_as_dir(env, dt_obj) == 0)
935 dt_write_lock(env, dt_obj, MOR_TGT_CHILD);
936 rc = dt_insert(env, dt_obj, rec, key, th, 0);
937 dt_write_unlock(env, dt_obj);
942 static int out_obj_index_delete(const struct lu_env *env,
943 struct dt_object *dt_obj,
944 const struct dt_key *key,
949 CDEBUG(D_INFO, "%s: index delete "DFID" name: %s\n",
950 dt_obd_name(th->th_dev), PFID(lu_object_fid(&dt_obj->do_lu)),
953 if (dt_try_as_dir(env, dt_obj) == 0)
956 dt_write_lock(env, dt_obj, MOR_TGT_CHILD);
957 rc = dt_delete(env, dt_obj, key, th);
958 dt_write_unlock(env, dt_obj);
963 static int out_tx_index_insert_exec(const struct lu_env *env,
964 struct thandle *th, struct tx_arg *arg)
966 struct dt_object *dt_obj = arg->object;
969 if (unlikely(!dt_object_exists(dt_obj)))
972 rc = out_obj_index_insert(env, dt_obj,
973 (const struct dt_rec *)&arg->u.insert.rec,
974 arg->u.insert.key, th);
976 CDEBUG(D_INFO, "%s: insert idx insert reply %p index %d: rc = %d\n",
977 dt_obd_name(th->th_dev), arg->reply, arg->index, rc);
979 object_update_result_insert(arg->reply, NULL, 0, arg->index, rc);
984 static int out_tx_index_insert_undo(const struct lu_env *env,
985 struct thandle *th, struct tx_arg *arg)
987 return out_obj_index_delete(env, arg->object, arg->u.insert.key, th);
990 static int __out_tx_index_insert(const struct lu_env *env,
991 struct dt_object *dt_obj,
992 const struct dt_rec *rec,
993 const struct dt_key *key,
994 struct thandle_exec_args *ta,
995 struct object_update_reply *reply,
996 int index, const char *file, int line)
1001 LASSERT(ta->ta_handle != NULL);
1002 if (dt_try_as_dir(env, dt_obj) == 0) {
1007 rc = dt_declare_insert(env, dt_obj, rec, key, ta->ta_handle);
1011 arg = tx_add_exec(ta, out_tx_index_insert_exec,
1012 out_tx_index_insert_undo, file, line);
1014 return PTR_ERR(arg);
1016 lu_object_get(&dt_obj->do_lu);
1017 arg->object = dt_obj;
1020 arg->u.insert.rec = *(const struct dt_insert_rec *)rec;
1021 arg->u.insert.key = key;
1026 static int out_index_insert(struct tgt_session_info *tsi)
1028 struct tgt_thread_info *tti = tgt_th_info(tsi->tsi_env);
1029 struct object_update *update = tti->tti_u.update.tti_update;
1030 struct dt_object *obj = tti->tti_u.update.tti_dt_object;
1031 struct dt_insert_rec *rec = &tti->tti_rec;
1039 name = object_update_param_get(update, 0, NULL);
1040 if (name == NULL || IS_ERR(name)) {
1041 CERROR("%s: empty name for index insert: rc = %d\n",
1042 tgt_name(tsi->tsi_tgt), -EPROTO);
1043 RETURN(err_serious(-EPROTO));
1046 fid = object_update_param_get(update, 1, &size);
1047 if (fid == NULL || IS_ERR(fid) || size != sizeof(*fid)) {
1048 CERROR("%s: invalid fid: rc = %d\n",
1049 tgt_name(tsi->tsi_tgt), -EPROTO);
1050 RETURN(err_serious(-EPROTO));
1053 if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
1054 lustre_swab_lu_fid(fid);
1056 if (!fid_is_sane(fid)) {
1057 CERROR("%s: invalid FID "DFID": rc = %d\n",
1058 tgt_name(tsi->tsi_tgt), PFID(fid), -EPROTO);
1059 RETURN(err_serious(-EPROTO));
1062 ptype = object_update_param_get(update, 2, &size);
1063 if (ptype == NULL || IS_ERR(ptype) || size != sizeof(*ptype)) {
1064 CERROR("%s: invalid type for index insert: rc = %d\n",
1065 tgt_name(tsi->tsi_tgt), -EPROTO);
1066 RETURN(err_serious(-EPROTO));
1069 if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
1073 rec->rec_type = *ptype;
1075 rc = out_tx_index_insert(tsi->tsi_env, obj, (const struct dt_rec *)rec,
1076 (const struct dt_key *)name, &tti->tti_tea,
1077 tti->tti_u.update.tti_update_reply,
1078 tti->tti_u.update.tti_update_reply_index);
1082 static int out_tx_index_delete_exec(const struct lu_env *env,
1088 rc = out_obj_index_delete(env, arg->object, arg->u.insert.key, th);
1090 CDEBUG(D_INFO, "%s: delete idx insert reply %p index %d: rc = %d\n",
1091 dt_obd_name(th->th_dev), arg->reply, arg->index, rc);
1093 object_update_result_insert(arg->reply, NULL, 0, arg->index, rc);
1098 static int out_tx_index_delete_undo(const struct lu_env *env,
1102 CERROR("%s: Oops, can not rollback index_delete yet: rc = %d\n",
1103 dt_obd_name(th->th_dev), -ENOTSUPP);
1107 static int __out_tx_index_delete(const struct lu_env *env,
1108 struct dt_object *dt_obj,
1109 const struct dt_key *key,
1110 struct thandle_exec_args *ta,
1111 struct object_update_reply *reply,
1112 int index, const char *file, int line)
1117 if (dt_try_as_dir(env, dt_obj) == 0) {
1122 LASSERT(ta->ta_handle != NULL);
1123 rc = dt_declare_delete(env, dt_obj, key, ta->ta_handle);
1127 arg = tx_add_exec(ta, out_tx_index_delete_exec,
1128 out_tx_index_delete_undo, file, line);
1130 return PTR_ERR(arg);
1132 lu_object_get(&dt_obj->do_lu);
1133 arg->object = dt_obj;
1136 arg->u.insert.key = key;
1140 static int out_index_delete(struct tgt_session_info *tsi)
1142 struct tgt_thread_info *tti = tgt_th_info(tsi->tsi_env);
1143 struct object_update *update = tti->tti_u.update.tti_update;
1144 struct dt_object *obj = tti->tti_u.update.tti_dt_object;
1148 if (!lu_object_exists(&obj->do_lu))
1151 name = object_update_param_get(update, 0, NULL);
1152 if (name == NULL || IS_ERR(name)) {
1153 CERROR("%s: empty name for index delete: rc = %d\n",
1154 tgt_name(tsi->tsi_tgt), -EPROTO);
1155 RETURN(err_serious(-EPROTO));
1158 rc = out_tx_index_delete(tsi->tsi_env, obj, (const struct dt_key *)name,
1160 tti->tti_u.update.tti_update_reply,
1161 tti->tti_u.update.tti_update_reply_index);
1165 static int out_tx_destroy_exec(const struct lu_env *env, struct thandle *th,
1168 struct dt_object *dt_obj = arg->object;
1171 rc = out_obj_destroy(env, dt_obj, th);
1173 CDEBUG(D_INFO, "%s: insert destroy reply %p index %d: rc = %d\n",
1174 dt_obd_name(th->th_dev), arg->reply, arg->index, rc);
1176 object_update_result_insert(arg->reply, NULL, 0, arg->index, rc);
1181 static int out_tx_destroy_undo(const struct lu_env *env, struct thandle *th,
1184 CERROR("%s: not support destroy undo yet!: rc = %d\n",
1185 dt_obd_name(th->th_dev), -ENOTSUPP);
1189 static int __out_tx_destroy(const struct lu_env *env, struct dt_object *dt_obj,
1190 struct thandle_exec_args *ta,
1191 struct object_update_reply *reply,
1192 int index, const char *file, int line)
1197 LASSERT(ta->ta_handle != NULL);
1198 rc = dt_declare_destroy(env, dt_obj, ta->ta_handle);
1202 arg = tx_add_exec(ta, out_tx_destroy_exec, out_tx_destroy_undo,
1205 return PTR_ERR(arg);
1207 lu_object_get(&dt_obj->do_lu);
1208 arg->object = dt_obj;
1214 static int out_destroy(struct tgt_session_info *tsi)
1216 struct tgt_thread_info *tti = tgt_th_info(tsi->tsi_env);
1217 struct object_update *update = tti->tti_u.update.tti_update;
1218 struct dt_object *obj = tti->tti_u.update.tti_dt_object;
1223 fid = &update->ou_fid;
1224 if (!fid_is_sane(fid)) {
1225 CERROR("%s: invalid FID "DFID": rc = %d\n",
1226 tgt_name(tsi->tsi_tgt), PFID(fid), -EPROTO);
1227 RETURN(err_serious(-EPROTO));
1230 if (!lu_object_exists(&obj->do_lu))
1233 rc = out_tx_destroy(tsi->tsi_env, obj, &tti->tti_tea,
1234 tti->tti_u.update.tti_update_reply,
1235 tti->tti_u.update.tti_update_reply_index);
1240 static int out_tx_write_exec(const struct lu_env *env, struct thandle *th,
1243 struct dt_object *dt_obj = arg->object;
1246 CDEBUG(D_INFO, "write "DFID" pos "LPU64" buf %p, len %lu\n",
1247 PFID(lu_object_fid(&dt_obj->do_lu)), arg->u.write.pos,
1248 arg->u.write.buf.lb_buf, (unsigned long)arg->u.write.buf.lb_len);
1250 dt_write_lock(env, dt_obj, MOR_TGT_CHILD);
1251 rc = dt_record_write(env, dt_obj, &arg->u.write.buf,
1252 &arg->u.write.pos, th);
1253 dt_write_unlock(env, dt_obj);
1256 rc = arg->u.write.buf.lb_len;
1258 object_update_result_insert(arg->reply, NULL, 0, arg->index, rc);
1260 return rc > 0 ? 0 : rc;
1263 static int __out_tx_write(const struct lu_env *env,
1264 struct dt_object *dt_obj,
1265 const struct lu_buf *buf,
1266 loff_t pos, struct thandle_exec_args *ta,
1267 struct object_update_reply *reply,
1268 int index, const char *file, int line)
1273 LASSERT(ta->ta_handle != NULL);
1274 rc = dt_declare_record_write(env, dt_obj, buf, pos, ta->ta_handle);
1278 arg = tx_add_exec(ta, out_tx_write_exec, NULL, file, line);
1280 return PTR_ERR(arg);
1282 lu_object_get(&dt_obj->do_lu);
1283 arg->object = dt_obj;
1284 arg->u.write.buf = *buf;
1285 arg->u.write.pos = pos;
1291 static int out_write(struct tgt_session_info *tsi)
1293 struct tgt_thread_info *tti = tgt_th_info(tsi->tsi_env);
1294 struct object_update *update = tti->tti_u.update.tti_update;
1295 struct dt_object *obj = tti->tti_u.update.tti_dt_object;
1296 struct lu_buf *lbuf = &tti->tti_buf;
1305 buf = object_update_param_get(update, 0, &buf_len);
1306 if (buf == NULL || IS_ERR(buf) || buf_len == 0) {
1307 CERROR("%s: empty buf for xattr set: rc = %d\n",
1308 tgt_name(tsi->tsi_tgt), -EPROTO);
1309 RETURN(err_serious(-EPROTO));
1312 lbuf->lb_len = buf_len;
1314 tmp = object_update_param_get(update, 1, &size);
1315 if (tmp == NULL || IS_ERR(tmp) || size != sizeof(*tmp)) {
1316 CERROR("%s: empty or wrong size %zu pos: rc = %d\n",
1317 tgt_name(tsi->tsi_tgt), size, -EPROTO);
1318 RETURN(err_serious(-EPROTO));
1321 if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
1325 rc = out_tx_write(tsi->tsi_env, obj, lbuf, pos,
1327 tti->tti_u.update.tti_update_reply,
1328 tti->tti_u.update.tti_update_reply_index);
1332 static int out_read(struct tgt_session_info *tsi)
1334 const struct lu_env *env = tsi->tsi_env;
1335 struct tgt_thread_info *tti = tgt_th_info(env);
1336 struct object_update *update = tti->tti_u.update.tti_update;
1337 struct dt_object *obj = tti->tti_u.update.tti_dt_object;
1338 struct object_update_reply *reply = tti->tti_u.update.tti_update_reply;
1339 int index = tti->tti_u.update.tti_update_reply_index;
1340 struct object_update_result *update_result;
1341 struct lu_buf *lbuf = &tti->tti_buf;
1342 struct out_read_reply *orr;
1349 update_result = object_update_result_get(reply, index, NULL);
1350 LASSERT(update_result != NULL);
1351 update_result->our_datalen = sizeof(*orr);
1353 if (!lu_object_exists(&obj->do_lu))
1354 GOTO(out, rc = -ENOENT);
1356 tmp = object_update_param_get(update, 0, NULL);
1358 CERROR("%s: empty size for read: rc = %d\n",
1359 tgt_name(tsi->tsi_tgt), -EPROTO);
1360 GOTO(out, rc = err_serious(-EPROTO));
1362 size = le64_to_cpu(*(size_t *)(tmp));
1364 tmp = object_update_param_get(update, 1, NULL);
1366 CERROR("%s: empty pos for read: rc = %d\n",
1367 tgt_name(tsi->tsi_tgt), -EPROTO);
1368 GOTO(out, rc = err_serious(-EPROTO));
1370 pos = le64_to_cpu(*(__u64 *)(tmp));
1372 if (size > OUT_UPDATE_REPLY_SIZE -
1373 cfs_size_round((unsigned long)update_result->our_data -
1374 (unsigned long)update_result) - sizeof(pos)) {
1375 CERROR("%s: get %zu the biggest read size is %d: rc = %d\n",
1376 tgt_name(tsi->tsi_tgt), size, OUT_UPDATE_REPLY_SIZE,
1378 GOTO(out, rc = err_serious(-EPROTO));
1381 /* Put the offset into the begining of the buffer in reply */
1382 orr = (struct out_read_reply *)update_result->our_data;
1384 lbuf->lb_buf = orr->orr_data;
1385 lbuf->lb_len = size;
1387 dt_read_lock(env, obj, MOR_TGT_CHILD);
1388 rc = dt_read(env, obj, lbuf, &pos);
1389 dt_read_unlock(env, obj);
1390 orr->orr_size = rc < 0 ? 0 : rc;
1391 orr->orr_offset = pos;
1393 orr_cpu_to_le(orr, orr);
1394 update_result->our_datalen += orr->orr_size;
1396 /* Insert read buffer */
1397 update_result->our_rc = ptlrpc_status_hton(rc);
1398 reply->ourp_lens[index] = cfs_size_round(update_result->our_datalen +
1399 sizeof(*update_result));
1403 #define DEF_OUT_HNDL(opc, name, flags, fn) \
1404 [opc - OUT_CREATE] = { \
1408 .th_flags = flags, \
1414 static struct tgt_handler out_update_ops[] = {
1415 DEF_OUT_HNDL(OUT_CREATE, "out_create", MUTABOR | HABEO_REFERO,
1417 DEF_OUT_HNDL(OUT_DESTROY, "out_create", MUTABOR | HABEO_REFERO,
1419 DEF_OUT_HNDL(OUT_REF_ADD, "out_ref_add", MUTABOR | HABEO_REFERO,
1421 DEF_OUT_HNDL(OUT_REF_DEL, "out_ref_del", MUTABOR | HABEO_REFERO,
1423 DEF_OUT_HNDL(OUT_ATTR_SET, "out_attr_set", MUTABOR | HABEO_REFERO,
1425 DEF_OUT_HNDL(OUT_ATTR_GET, "out_attr_get", HABEO_REFERO,
1427 DEF_OUT_HNDL(OUT_XATTR_SET, "out_xattr_set", MUTABOR | HABEO_REFERO,
1429 DEF_OUT_HNDL(OUT_XATTR_DEL, "out_xattr_del", MUTABOR | HABEO_REFERO,
1431 DEF_OUT_HNDL(OUT_XATTR_GET, "out_xattr_get", HABEO_REFERO,
1433 DEF_OUT_HNDL(OUT_INDEX_LOOKUP, "out_index_lookup", HABEO_REFERO,
1435 DEF_OUT_HNDL(OUT_INDEX_INSERT, "out_index_insert",
1436 MUTABOR | HABEO_REFERO, out_index_insert),
1437 DEF_OUT_HNDL(OUT_INDEX_DELETE, "out_index_delete",
1438 MUTABOR | HABEO_REFERO, out_index_delete),
1439 DEF_OUT_HNDL(OUT_WRITE, "out_write", MUTABOR | HABEO_REFERO, out_write),
1440 DEF_OUT_HNDL(OUT_READ, "out_read", HABEO_REFERO, out_read),
1444 static struct tgt_handler *out_handler_find(__u32 opc)
1446 struct tgt_handler *h;
1449 if (OUT_CREATE <= opc && opc < OUT_LAST) {
1450 h = &out_update_ops[opc - OUT_CREATE];
1451 LASSERTF(h->th_opc == opc, "opcode mismatch %d != %d\n",
1454 h = NULL; /* unsupported opc */
1459 static int out_tx_start(const struct lu_env *env, struct dt_device *dt,
1460 struct thandle_exec_args *ta, struct obd_export *exp)
1463 ta->ta_handle = dt_trans_create(env, dt);
1464 if (IS_ERR(ta->ta_handle)) {
1467 rc = PTR_ERR(ta->ta_handle);
1468 ta->ta_handle = NULL;
1469 CERROR("%s: start handle error: rc = %d\n", dt_obd_name(dt),
1473 if (exp->exp_need_sync)
1474 ta->ta_handle->th_sync = 1;
1479 static int out_trans_start(const struct lu_env *env,
1480 struct thandle_exec_args *ta)
1482 return dt_trans_start(env, ta->ta_handle->th_dev, ta->ta_handle);
1485 static int out_trans_stop(const struct lu_env *env,
1486 struct thandle_exec_args *ta, int err)
1491 ta->ta_handle->th_result = err;
1492 rc = dt_trans_stop(env, ta->ta_handle->th_dev, ta->ta_handle);
1493 for (i = 0; i < ta->ta_argno; i++) {
1494 if (ta->ta_args[i]->object != NULL) {
1495 struct dt_object *obj = ta->ta_args[i]->object;
1497 /* If the object is being created during this
1498 * transaction, we need to remove them from the
1499 * cache immediately, because a few layers are
1500 * missing in OUT handler, i.e. the object might
1501 * not be initialized in all layers */
1502 if (ta->ta_args[i]->exec_fn == out_tx_create_exec)
1503 set_bit(LU_OBJECT_HEARD_BANSHEE,
1504 &obj->do_lu.lo_header->loh_flags);
1505 lu_object_put(env, &ta->ta_args[i]->object->do_lu);
1506 ta->ta_args[i]->object = NULL;
1509 ta->ta_handle = NULL;
1515 static int out_tx_end(const struct lu_env *env, struct thandle_exec_args *ta,
1518 struct tgt_session_info *tsi = tgt_ses_info(env);
1524 if (ta->ta_handle == NULL)
1527 if (declare_ret != 0 || ta->ta_argno == 0)
1528 GOTO(stop, rc = declare_ret);
1530 LASSERT(ta->ta_handle->th_dev != NULL);
1531 rc = out_trans_start(env, ta);
1532 if (unlikely(rc != 0))
1535 for (i = 0; i < ta->ta_argno; i++) {
1536 rc = ta->ta_args[i]->exec_fn(env, ta->ta_handle,
1538 if (unlikely(rc != 0)) {
1539 CDEBUG(D_INFO, "error during execution of #%u from"
1540 " %s:%d: rc = %d\n", i, ta->ta_args[i]->file,
1541 ta->ta_args[i]->line, rc);
1543 if (ta->ta_args[i]->undo_fn != NULL)
1544 ta->ta_args[i]->undo_fn(env,
1548 CERROR("%s: undo for %s:%d: rc = %d\n",
1549 dt_obd_name(ta->ta_handle->th_dev),
1550 ta->ta_args[i]->file,
1551 ta->ta_args[i]->line, -ENOTSUPP);
1555 CDEBUG(D_INFO, "%s: executed %u/%u: rc = %d\n",
1556 dt_obd_name(ta->ta_handle->th_dev), i, ta->ta_argno, rc);
1559 /* Only fail for real updates, XXX right now llog updates will be
1560 * ignore, whose updates count is usually 1, so failover test
1561 * case will spot this FAIL_UPDATE_NET_REP precisely, and it will
1562 * be removed after async update patch is landed. */
1563 if (ta->ta_argno > 1)
1564 tsi->tsi_reply_fail_id = OBD_FAIL_OUT_UPDATE_NET_REP;
1567 rc1 = out_trans_stop(env, ta, rc);
1571 ta->ta_handle = NULL;
1578 * Object updates between Targets. Because all the updates has been
1579 * dis-assemblied into object updates at sender side, so OUT will
1580 * call OSD API directly to execute these updates.
1582 * In DNE phase I all of the updates in the request need to be executed
1583 * in one transaction, and the transaction has to be synchronously.
1585 * Please refer to lustre/include/lustre/lustre_idl.h for req/reply
1588 int out_handle(struct tgt_session_info *tsi)
1590 const struct lu_env *env = tsi->tsi_env;
1591 struct tgt_thread_info *tti = tgt_th_info(env);
1592 struct thandle_exec_args *ta = &tti->tti_tea;
1593 struct req_capsule *pill = tsi->tsi_pill;
1594 struct dt_device *dt = tsi->tsi_tgt->lut_bottom;
1595 struct object_update_request *ureq;
1596 struct object_update *update;
1597 struct object_update_reply *reply;
1600 int current_batchid = -1;
1607 req_capsule_set(pill, &RQF_OUT_UPDATE);
1608 ureq = req_capsule_client_get(pill, &RMF_OUT_UPDATE);
1610 CERROR("%s: No buf!: rc = %d\n", tgt_name(tsi->tsi_tgt),
1612 RETURN(err_serious(-EPROTO));
1615 bufsize = req_capsule_get_size(pill, &RMF_OUT_UPDATE, RCL_CLIENT);
1616 if (bufsize != object_update_request_size(ureq)) {
1617 CERROR("%s: invalid bufsize %d: rc = %d\n",
1618 tgt_name(tsi->tsi_tgt), bufsize, -EPROTO);
1619 RETURN(err_serious(-EPROTO));
1622 if (ureq->ourq_magic != UPDATE_REQUEST_MAGIC) {
1623 CERROR("%s: invalid update buffer magic %x expect %x: "
1624 "rc = %d\n", tgt_name(tsi->tsi_tgt), ureq->ourq_magic,
1625 UPDATE_REQUEST_MAGIC, -EPROTO);
1626 RETURN(err_serious(-EPROTO));
1629 count = ureq->ourq_count;
1631 CERROR("%s: empty update: rc = %d\n", tgt_name(tsi->tsi_tgt),
1633 RETURN(err_serious(-EPROTO));
1636 req_capsule_set_size(pill, &RMF_OUT_UPDATE_REPLY, RCL_SERVER,
1637 OUT_UPDATE_REPLY_SIZE);
1638 rc = req_capsule_server_pack(pill);
1640 CERROR("%s: Can't pack response: rc = %d\n",
1641 tgt_name(tsi->tsi_tgt), rc);
1645 /* Prepare the update reply buffer */
1646 reply = req_capsule_server_get(pill, &RMF_OUT_UPDATE_REPLY);
1648 RETURN(err_serious(-EPROTO));
1649 object_update_reply_init(reply, count);
1650 tti->tti_u.update.tti_update_reply = reply;
1651 tti->tti_mult_trans = !req_is_replay(tgt_ses_req(tsi));
1653 /* Walk through updates in the request to execute them synchronously */
1654 for (i = 0; i < count; i++) {
1655 struct tgt_handler *h;
1656 struct dt_object *dt_obj;
1658 update = object_update_request_get(ureq, i, NULL);
1660 GOTO(out, rc = -EPROTO);
1662 if (ptlrpc_req_need_swab(pill->rc_req))
1663 lustre_swab_object_update(update);
1665 if (!fid_is_sane(&update->ou_fid)) {
1666 CERROR("%s: invalid FID "DFID": rc = %d\n",
1667 tgt_name(tsi->tsi_tgt), PFID(&update->ou_fid),
1669 GOTO(out, rc = err_serious(-EPROTO));
1672 dt_obj = dt_locate(env, dt, &update->ou_fid);
1674 GOTO(out, rc = PTR_ERR(dt_obj));
1676 if (dt->dd_record_fid_accessed) {
1677 lfsck_pack_rfa(&tti->tti_lr,
1678 lu_object_fid(&dt_obj->do_lu),
1681 tgt_lfsck_in_notify(env, dt, &tti->tti_lr, NULL);
1684 tti->tti_u.update.tti_dt_object = dt_obj;
1685 tti->tti_u.update.tti_update = update;
1686 tti->tti_u.update.tti_update_reply_index = i;
1688 h = out_handler_find(update->ou_type);
1689 if (unlikely(h == NULL)) {
1690 CERROR("%s: unsupported opc: 0x%x\n",
1691 tgt_name(tsi->tsi_tgt), update->ou_type);
1692 GOTO(next, rc = -ENOTSUPP);
1695 /* Check resend case only for modifying RPC */
1696 if (h->th_flags & MUTABOR) {
1697 struct ptlrpc_request *req = tgt_ses_req(tsi);
1699 if (out_check_resent(env, dt, dt_obj, req,
1700 out_reconstruct, reply, i))
1704 /* start transaction for modification RPC only */
1705 if (h->th_flags & MUTABOR && current_batchid == -1) {
1706 current_batchid = update->ou_batchid;
1707 rc = out_tx_start(env, dt, ta, tsi->tsi_exp);
1711 if (update->ou_flags & UPDATE_FL_SYNC)
1712 ta->ta_handle->th_sync = 1;
1715 /* Stop the current update transaction, if the update has
1716 * different batchid, or read-only update */
1717 if (((current_batchid != update->ou_batchid) ||
1718 !(h->th_flags & MUTABOR)) && ta->ta_handle != NULL) {
1719 rc = out_tx_end(env, ta, rc);
1720 current_batchid = -1;
1724 /* start a new transaction if needed */
1725 if (h->th_flags & MUTABOR) {
1726 rc = out_tx_start(env, dt, ta, tsi->tsi_exp);
1730 if (update->ou_flags & UPDATE_FL_SYNC)
1731 ta->ta_handle->th_sync = 1;
1733 current_batchid = update->ou_batchid;
1737 rc = h->th_act(tsi);
1739 lu_object_put(env, &dt_obj->do_lu);
1744 if (current_batchid != -1) {
1745 rc1 = out_tx_end(env, ta, rc);
1753 struct tgt_handler tgt_out_handlers[] = {
1754 TGT_UPDATE_HDL(MUTABOR, OUT_UPDATE, out_handle),
1756 EXPORT_SYMBOL(tgt_out_handlers);