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 void out_reconstruct(const struct lu_env *env, struct dt_device *dt,
40 struct dt_object *obj,
41 struct object_update_reply *reply,
44 CDEBUG(D_INFO, "%s: fork reply reply %p index %d: rc = %d\n",
45 dt_obd_name(dt), reply, index, 0);
47 object_update_result_insert(reply, NULL, 0, index, 0);
51 typedef void (*out_reconstruct_t)(const struct lu_env *env,
53 struct dt_object *obj,
54 struct object_update_reply *reply,
57 static inline int out_check_resent(const struct lu_env *env,
59 struct dt_object *obj,
60 struct ptlrpc_request *req,
61 out_reconstruct_t reconstruct,
62 struct object_update_reply *reply,
65 if (likely(!(lustre_msg_get_flags(req->rq_reqmsg) & MSG_RESENT)))
68 if (req_xid_is_last(req)) {
69 struct lsd_client_data *lcd;
71 /* XXX this does not support mulitple transactions yet, i.e.
72 * only 1 update RPC each time betwee MDTs */
73 lcd = req->rq_export->exp_target_data.ted_lcd;
75 req->rq_transno = lcd->lcd_last_transno;
76 req->rq_status = lcd->lcd_last_result;
77 if (req->rq_status != 0)
79 lustre_msg_set_transno(req->rq_repmsg, req->rq_transno);
80 lustre_msg_set_status(req->rq_repmsg, req->rq_status);
82 DEBUG_REQ(D_RPCTRACE, req, "restoring transno "LPD64"status %d",
83 req->rq_transno, req->rq_status);
85 reconstruct(env, dt, obj, reply, index);
88 DEBUG_REQ(D_HA, req, "no reply for RESENT req (have "LPD64")",
89 req->rq_export->exp_target_data.ted_lcd->lcd_last_xid);
93 static int out_create(struct tgt_session_info *tsi)
95 struct tgt_thread_info *tti = tgt_th_info(tsi->tsi_env);
96 struct object_update *update = tti->tti_u.update.tti_update;
97 struct dt_object *obj = tti->tti_u.update.tti_dt_object;
98 struct dt_object_format *dof = &tti->tti_u.update.tti_update_dof;
99 struct obdo *lobdo = &tti->tti_u.update.tti_obdo;
100 struct lu_attr *attr = &tti->tti_attr;
101 struct lu_fid *fid = NULL;
108 wobdo = object_update_param_get(update, 0, &size);
109 if (wobdo == NULL || IS_ERR(wobdo) || size != sizeof(*wobdo)) {
110 CERROR("%s: obdo is NULL, invalid RPC: rc = %d\n",
111 tgt_name(tsi->tsi_tgt), -EPROTO);
112 RETURN(err_serious(-EPROTO));
115 if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
116 lustre_swab_obdo(wobdo);
117 lustre_get_wire_obdo(NULL, lobdo, wobdo);
118 la_from_obdo(attr, lobdo, lobdo->o_valid);
120 dof->dof_type = dt_mode_to_dft(attr->la_mode);
121 if (update->ou_params_count > 1) {
122 fid = object_update_param_get(update, 1, &size);
123 if (fid == NULL || IS_ERR(fid) || size != sizeof(*fid)) {
124 CERROR("%s: invalid fid: rc = %d\n",
125 tgt_name(tsi->tsi_tgt), -EPROTO);
126 RETURN(err_serious(-EPROTO));
128 if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
129 lustre_swab_lu_fid(fid);
130 if (!fid_is_sane(fid)) {
131 CERROR("%s: invalid fid "DFID": rc = %d\n",
132 tgt_name(tsi->tsi_tgt), PFID(fid), -EPROTO);
133 RETURN(err_serious(-EPROTO));
137 if (lu_object_exists(&obj->do_lu))
140 rc = out_tx_create(tsi->tsi_env, obj, attr, fid, dof,
141 &tti->tti_tea, tti->tti_tea.ta_handle,
142 tti->tti_u.update.tti_update_reply,
143 tti->tti_u.update.tti_update_reply_index);
148 static int out_attr_set(struct tgt_session_info *tsi)
150 struct tgt_thread_info *tti = tgt_th_info(tsi->tsi_env);
151 struct object_update *update = tti->tti_u.update.tti_update;
152 struct lu_attr *attr = &tti->tti_attr;
153 struct dt_object *obj = tti->tti_u.update.tti_dt_object;
154 struct obdo *lobdo = &tti->tti_u.update.tti_obdo;
161 wobdo = object_update_param_get(update, 0, &size);
162 if (wobdo == NULL || IS_ERR(wobdo) || size != sizeof(*wobdo)) {
163 CERROR("%s: empty obdo in the update: rc = %d\n",
164 tgt_name(tsi->tsi_tgt), -EPROTO);
165 RETURN(err_serious(-EPROTO));
171 if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
172 lustre_swab_obdo(wobdo);
173 lustre_get_wire_obdo(NULL, lobdo, wobdo);
174 la_from_obdo(attr, lobdo, lobdo->o_valid);
176 rc = out_tx_attr_set(tsi->tsi_env, obj, attr, &tti->tti_tea,
177 tti->tti_tea.ta_handle,
178 tti->tti_u.update.tti_update_reply,
179 tti->tti_u.update.tti_update_reply_index);
184 static int out_attr_get(struct tgt_session_info *tsi)
186 const struct lu_env *env = tsi->tsi_env;
187 struct tgt_thread_info *tti = tgt_th_info(env);
188 struct obdo *obdo = &tti->tti_u.update.tti_obdo;
189 struct lu_attr *la = &tti->tti_attr;
190 struct dt_object *obj = tti->tti_u.update.tti_dt_object;
191 int idx = tti->tti_u.update.tti_update_reply_index;
196 if (!lu_object_exists(&obj->do_lu)) {
197 /* Usually, this will be called when the master MDT try
198 * to init a remote object(see osp_object_init), so if
199 * the object does not exist on slave, we need set BANSHEE flag,
200 * so the object can be removed from the cache immediately */
201 set_bit(LU_OBJECT_HEARD_BANSHEE,
202 &obj->do_lu.lo_header->loh_flags);
206 dt_read_lock(env, obj, MOR_TGT_CHILD);
207 rc = dt_attr_get(env, obj, la);
209 GOTO(out_unlock, rc);
212 obdo_from_la(obdo, la, la->la_valid);
213 lustre_set_wire_obdo(NULL, obdo, obdo);
216 dt_read_unlock(env, obj);
218 CDEBUG(D_INFO, "%s: insert attr get reply %p index %d: rc = %d\n",
219 tgt_name(tsi->tsi_tgt), tti->tti_u.update.tti_update_reply,
222 object_update_result_insert(tti->tti_u.update.tti_update_reply, obdo,
223 sizeof(*obdo), idx, rc);
228 static int out_xattr_get(struct tgt_session_info *tsi)
230 const struct lu_env *env = tsi->tsi_env;
231 struct tgt_thread_info *tti = tgt_th_info(env);
232 struct object_update *update = tti->tti_u.update.tti_update;
233 struct lu_buf *lbuf = &tti->tti_buf;
234 struct object_update_reply *reply = tti->tti_u.update.tti_update_reply;
235 struct dt_object *obj = tti->tti_u.update.tti_dt_object;
237 struct object_update_result *update_result;
238 int idx = tti->tti_u.update.tti_update_reply_index;
243 if (!lu_object_exists(&obj->do_lu)) {
244 set_bit(LU_OBJECT_HEARD_BANSHEE,
245 &obj->do_lu.lo_header->loh_flags);
249 name = object_update_param_get(update, 0, NULL);
250 if (name == NULL || IS_ERR(name)) {
251 CERROR("%s: empty name for xattr get: rc = %d\n",
252 tgt_name(tsi->tsi_tgt), -EPROTO);
253 RETURN(err_serious(-EPROTO));
256 update_result = object_update_result_get(reply, 0, NULL);
257 if (update_result == NULL) {
258 CERROR("%s: empty name for xattr get: rc = %d\n",
259 tgt_name(tsi->tsi_tgt), -EPROTO);
260 RETURN(err_serious(-EPROTO));
263 lbuf->lb_buf = update_result->our_data;
264 lbuf->lb_len = OUT_UPDATE_REPLY_SIZE -
265 cfs_size_round((unsigned long)update_result->our_data -
266 (unsigned long)update_result);
267 dt_read_lock(env, obj, MOR_TGT_CHILD);
268 rc = dt_xattr_get(env, obj, lbuf, name);
269 dt_read_unlock(env, obj);
276 CDEBUG(D_INFO, "%s: "DFID" get xattr %s len %d\n",
277 tgt_name(tsi->tsi_tgt), PFID(lu_object_fid(&obj->do_lu)),
278 name, (int)lbuf->lb_len);
283 object_update_result_insert(reply, lbuf->lb_buf, lbuf->lb_len, idx, rc);
287 static int out_index_lookup(struct tgt_session_info *tsi)
289 const struct lu_env *env = tsi->tsi_env;
290 struct tgt_thread_info *tti = tgt_th_info(env);
291 struct object_update *update = tti->tti_u.update.tti_update;
292 struct dt_object *obj = tti->tti_u.update.tti_dt_object;
298 if (!lu_object_exists(&obj->do_lu))
301 name = object_update_param_get(update, 0, NULL);
302 if (name == NULL || IS_ERR(name)) {
303 CERROR("%s: empty name for lookup: rc = %d\n",
304 tgt_name(tsi->tsi_tgt), -EPROTO);
305 RETURN(err_serious(-EPROTO));
308 dt_read_lock(env, obj, MOR_TGT_CHILD);
309 if (!dt_try_as_dir(env, obj))
310 GOTO(out_unlock, rc = -ENOTDIR);
312 rc = dt_lookup(env, obj, (struct dt_rec *)&tti->tti_fid1,
313 (struct dt_key *)name);
316 GOTO(out_unlock, rc);
322 dt_read_unlock(env, obj);
324 CDEBUG(D_INFO, "lookup "DFID" %s get "DFID" rc %d\n",
325 PFID(lu_object_fid(&obj->do_lu)), name,
326 PFID(&tti->tti_fid1), rc);
328 CDEBUG(D_INFO, "%s: insert lookup reply %p index %d: rc = %d\n",
329 tgt_name(tsi->tsi_tgt), tti->tti_u.update.tti_update_reply,
332 object_update_result_insert(tti->tti_u.update.tti_update_reply,
333 &tti->tti_fid1, sizeof(tti->tti_fid1),
334 tti->tti_u.update.tti_update_reply_index, rc);
338 static int out_xattr_set(struct tgt_session_info *tsi)
340 struct tgt_thread_info *tti = tgt_th_info(tsi->tsi_env);
341 struct object_update *update = tti->tti_u.update.tti_update;
342 struct dt_object *obj = tti->tti_u.update.tti_dt_object;
343 struct lu_buf *lbuf = &tti->tti_buf;
353 name = object_update_param_get(update, 0, NULL);
354 if (name == NULL || IS_ERR(name)) {
355 CERROR("%s: empty name for xattr set: rc = %d\n",
356 tgt_name(tsi->tsi_tgt), -EPROTO);
357 RETURN(err_serious(-EPROTO));
360 buf = object_update_param_get(update, 1, &buf_len);
362 RETURN(err_serious(-EPROTO));
365 lbuf->lb_len = buf_len;
367 tmp = object_update_param_get(update, 2, &size);
368 if (tmp == NULL || size != sizeof(*tmp)) {
369 CERROR("%s: emptry or wrong size %zu flag: rc = %d\n",
370 tgt_name(tsi->tsi_tgt), size, -EPROTO);
371 RETURN(err_serious(-EPROTO));
374 if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
378 rc = out_tx_xattr_set(tsi->tsi_env, obj, lbuf, name, flag,
379 &tti->tti_tea, tti->tti_tea.ta_handle,
380 tti->tti_u.update.tti_update_reply,
381 tti->tti_u.update.tti_update_reply_index);
385 static int out_xattr_del(struct tgt_session_info *tsi)
387 struct tgt_thread_info *tti = tgt_th_info(tsi->tsi_env);
388 struct object_update *update = tti->tti_u.update.tti_update;
389 struct dt_object *obj = tti->tti_u.update.tti_dt_object;
394 name = object_update_param_get(update, 0, NULL);
395 if (name == NULL || IS_ERR(name)) {
396 CERROR("%s: empty name for xattr set: rc = %d\n",
397 tgt_name(tsi->tsi_tgt), -EPROTO);
398 RETURN(err_serious(-EPROTO));
401 rc = out_tx_xattr_del(tsi->tsi_env, obj, name, &tti->tti_tea,
402 tti->tti_tea.ta_handle,
403 tti->tti_u.update.tti_update_reply,
404 tti->tti_u.update.tti_update_reply_index);
409 * increase ref of the object
411 static int out_ref_add(struct tgt_session_info *tsi)
413 struct tgt_thread_info *tti = tgt_th_info(tsi->tsi_env);
414 struct dt_object *obj = tti->tti_u.update.tti_dt_object;
419 rc = out_tx_ref_add(tsi->tsi_env, obj, &tti->tti_tea,
420 tti->tti_tea.ta_handle,
421 tti->tti_u.update.tti_update_reply,
422 tti->tti_u.update.tti_update_reply_index);
426 static int out_ref_del(struct tgt_session_info *tsi)
428 struct tgt_thread_info *tti = tgt_th_info(tsi->tsi_env);
429 struct dt_object *obj = tti->tti_u.update.tti_dt_object;
434 if (!lu_object_exists(&obj->do_lu))
437 rc = out_tx_ref_del(tsi->tsi_env, obj, &tti->tti_tea,
438 tti->tti_tea.ta_handle,
439 tti->tti_u.update.tti_update_reply,
440 tti->tti_u.update.tti_update_reply_index);
444 static int out_index_insert(struct tgt_session_info *tsi)
446 struct tgt_thread_info *tti = tgt_th_info(tsi->tsi_env);
447 struct object_update *update = tti->tti_u.update.tti_update;
448 struct dt_object *obj = tti->tti_u.update.tti_dt_object;
449 struct dt_insert_rec *rec = &tti->tti_rec;
457 name = object_update_param_get(update, 0, NULL);
458 if (name == NULL || IS_ERR(name)) {
459 CERROR("%s: empty name for index insert: rc = %d\n",
460 tgt_name(tsi->tsi_tgt), -EPROTO);
461 RETURN(err_serious(-EPROTO));
464 fid = object_update_param_get(update, 1, &size);
465 if (fid == NULL || IS_ERR(fid) || size != sizeof(*fid)) {
466 CERROR("%s: invalid fid: rc = %d\n",
467 tgt_name(tsi->tsi_tgt), -EPROTO);
468 RETURN(err_serious(-EPROTO));
471 if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
472 lustre_swab_lu_fid(fid);
474 if (!fid_is_sane(fid)) {
475 CERROR("%s: invalid FID "DFID": rc = %d\n",
476 tgt_name(tsi->tsi_tgt), PFID(fid), -EPROTO);
477 RETURN(err_serious(-EPROTO));
480 ptype = object_update_param_get(update, 2, &size);
481 if (ptype == NULL || IS_ERR(ptype) || size != sizeof(*ptype)) {
482 CERROR("%s: invalid type for index insert: rc = %d\n",
483 tgt_name(tsi->tsi_tgt), -EPROTO);
484 RETURN(err_serious(-EPROTO));
487 if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
491 rec->rec_type = *ptype;
493 rc = out_tx_index_insert(tsi->tsi_env, obj, (const struct dt_rec *)rec,
494 (const struct dt_key *)name, &tti->tti_tea,
495 tti->tti_tea.ta_handle,
496 tti->tti_u.update.tti_update_reply,
497 tti->tti_u.update.tti_update_reply_index);
501 static int out_index_delete(struct tgt_session_info *tsi)
503 struct tgt_thread_info *tti = tgt_th_info(tsi->tsi_env);
504 struct object_update *update = tti->tti_u.update.tti_update;
505 struct dt_object *obj = tti->tti_u.update.tti_dt_object;
509 if (!lu_object_exists(&obj->do_lu))
512 name = object_update_param_get(update, 0, NULL);
513 if (name == NULL || IS_ERR(name)) {
514 CERROR("%s: empty name for index delete: rc = %d\n",
515 tgt_name(tsi->tsi_tgt), -EPROTO);
516 RETURN(err_serious(-EPROTO));
519 rc = out_tx_index_delete(tsi->tsi_env, obj, (const struct dt_key *)name,
520 &tti->tti_tea, tti->tti_tea.ta_handle,
521 tti->tti_u.update.tti_update_reply,
522 tti->tti_u.update.tti_update_reply_index);
526 static int out_destroy(struct tgt_session_info *tsi)
528 struct tgt_thread_info *tti = tgt_th_info(tsi->tsi_env);
529 struct object_update *update = tti->tti_u.update.tti_update;
530 struct dt_object *obj = tti->tti_u.update.tti_dt_object;
535 fid = &update->ou_fid;
536 if (!fid_is_sane(fid)) {
537 CERROR("%s: invalid FID "DFID": rc = %d\n",
538 tgt_name(tsi->tsi_tgt), PFID(fid), -EPROTO);
539 RETURN(err_serious(-EPROTO));
542 if (!lu_object_exists(&obj->do_lu))
545 rc = out_tx_destroy(tsi->tsi_env, obj, &tti->tti_tea,
546 tti->tti_tea.ta_handle,
547 tti->tti_u.update.tti_update_reply,
548 tti->tti_u.update.tti_update_reply_index);
553 static int out_write(struct tgt_session_info *tsi)
555 struct tgt_thread_info *tti = tgt_th_info(tsi->tsi_env);
556 struct object_update *update = tti->tti_u.update.tti_update;
557 struct dt_object *obj = tti->tti_u.update.tti_dt_object;
558 struct lu_buf *lbuf = &tti->tti_buf;
567 buf = object_update_param_get(update, 0, &buf_len);
568 if (buf == NULL || IS_ERR(buf) || buf_len == 0) {
569 CERROR("%s: empty buf for xattr set: rc = %d\n",
570 tgt_name(tsi->tsi_tgt), -EPROTO);
571 RETURN(err_serious(-EPROTO));
574 lbuf->lb_len = buf_len;
576 tmp = object_update_param_get(update, 1, &size);
577 if (tmp == NULL || IS_ERR(tmp) || size != sizeof(*tmp)) {
578 CERROR("%s: empty or wrong size %zu pos: rc = %d\n",
579 tgt_name(tsi->tsi_tgt), size, -EPROTO);
580 RETURN(err_serious(-EPROTO));
583 if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
587 rc = out_tx_write(tsi->tsi_env, obj, lbuf, pos,
588 &tti->tti_tea, tti->tti_tea.ta_handle,
589 tti->tti_u.update.tti_update_reply,
590 tti->tti_u.update.tti_update_reply_index);
594 static int out_read(struct tgt_session_info *tsi)
596 const struct lu_env *env = tsi->tsi_env;
597 struct tgt_thread_info *tti = tgt_th_info(env);
598 struct object_update *update = tti->tti_u.update.tti_update;
599 struct dt_object *obj = tti->tti_u.update.tti_dt_object;
600 struct object_update_reply *reply = tti->tti_u.update.tti_update_reply;
601 int index = tti->tti_u.update.tti_update_reply_index;
602 struct object_update_result *update_result;
603 struct lu_buf *lbuf = &tti->tti_buf;
604 struct out_read_reply *orr;
611 update_result = object_update_result_get(reply, index, NULL);
612 LASSERT(update_result != NULL);
613 update_result->our_datalen = sizeof(*orr);
615 if (!lu_object_exists(&obj->do_lu))
616 GOTO(out, rc = -ENOENT);
618 tmp = object_update_param_get(update, 0, NULL);
620 CERROR("%s: empty size for read: rc = %d\n",
621 tgt_name(tsi->tsi_tgt), -EPROTO);
622 GOTO(out, rc = err_serious(-EPROTO));
624 size = le64_to_cpu(*(size_t *)(tmp));
626 tmp = object_update_param_get(update, 1, NULL);
628 CERROR("%s: empty pos for read: rc = %d\n",
629 tgt_name(tsi->tsi_tgt), -EPROTO);
630 GOTO(out, rc = err_serious(-EPROTO));
632 pos = le64_to_cpu(*(__u64 *)(tmp));
634 if (size > OUT_UPDATE_REPLY_SIZE -
635 cfs_size_round((unsigned long)update_result->our_data -
636 (unsigned long)update_result) - sizeof(pos)) {
637 CERROR("%s: get %zu the biggest read size is %d: rc = %d\n",
638 tgt_name(tsi->tsi_tgt), size, OUT_UPDATE_REPLY_SIZE,
640 GOTO(out, rc = err_serious(-EPROTO));
643 /* Put the offset into the begining of the buffer in reply */
644 orr = (struct out_read_reply *)update_result->our_data;
646 lbuf->lb_buf = orr->orr_data;
649 dt_read_lock(env, obj, MOR_TGT_CHILD);
650 rc = dt_read(env, obj, lbuf, &pos);
651 dt_read_unlock(env, obj);
652 orr->orr_size = rc < 0 ? 0 : rc;
653 orr->orr_offset = pos;
655 orr_cpu_to_le(orr, orr);
656 update_result->our_datalen += orr->orr_size;
658 /* Insert read buffer */
659 update_result->our_rc = ptlrpc_status_hton(rc);
660 reply->ourp_lens[index] = cfs_size_round(update_result->our_datalen +
661 sizeof(*update_result));
665 #define DEF_OUT_HNDL(opc, name, flags, fn) \
666 [opc - OUT_CREATE] = { \
676 static struct tgt_handler out_update_ops[] = {
677 DEF_OUT_HNDL(OUT_CREATE, "out_create", MUTABOR | HABEO_REFERO,
679 DEF_OUT_HNDL(OUT_DESTROY, "out_create", MUTABOR | HABEO_REFERO,
681 DEF_OUT_HNDL(OUT_REF_ADD, "out_ref_add", MUTABOR | HABEO_REFERO,
683 DEF_OUT_HNDL(OUT_REF_DEL, "out_ref_del", MUTABOR | HABEO_REFERO,
685 DEF_OUT_HNDL(OUT_ATTR_SET, "out_attr_set", MUTABOR | HABEO_REFERO,
687 DEF_OUT_HNDL(OUT_ATTR_GET, "out_attr_get", HABEO_REFERO,
689 DEF_OUT_HNDL(OUT_XATTR_SET, "out_xattr_set", MUTABOR | HABEO_REFERO,
691 DEF_OUT_HNDL(OUT_XATTR_DEL, "out_xattr_del", MUTABOR | HABEO_REFERO,
693 DEF_OUT_HNDL(OUT_XATTR_GET, "out_xattr_get", HABEO_REFERO,
695 DEF_OUT_HNDL(OUT_INDEX_LOOKUP, "out_index_lookup", HABEO_REFERO,
697 DEF_OUT_HNDL(OUT_INDEX_INSERT, "out_index_insert",
698 MUTABOR | HABEO_REFERO, out_index_insert),
699 DEF_OUT_HNDL(OUT_INDEX_DELETE, "out_index_delete",
700 MUTABOR | HABEO_REFERO, out_index_delete),
701 DEF_OUT_HNDL(OUT_WRITE, "out_write", MUTABOR | HABEO_REFERO, out_write),
702 DEF_OUT_HNDL(OUT_READ, "out_read", HABEO_REFERO, out_read),
706 static struct tgt_handler *out_handler_find(__u32 opc)
708 struct tgt_handler *h;
711 if (OUT_CREATE <= opc && opc < OUT_LAST) {
712 h = &out_update_ops[opc - OUT_CREATE];
713 LASSERTF(h->th_opc == opc, "opcode mismatch %d != %d\n",
716 h = NULL; /* unsupported opc */
721 static int out_tx_start(const struct lu_env *env, struct dt_device *dt,
722 struct thandle_exec_args *ta, struct obd_export *exp)
725 ta->ta_handle = dt_trans_create(env, dt);
726 if (IS_ERR(ta->ta_handle)) {
729 rc = PTR_ERR(ta->ta_handle);
730 ta->ta_handle = NULL;
731 CERROR("%s: start handle error: rc = %d\n", dt_obd_name(dt),
735 if (exp->exp_need_sync)
736 ta->ta_handle->th_sync = 1;
741 static int out_trans_start(const struct lu_env *env,
742 struct thandle_exec_args *ta)
744 return dt_trans_start(env, ta->ta_handle->th_dev, ta->ta_handle);
747 static int out_trans_stop(const struct lu_env *env,
748 struct thandle_exec_args *ta, int err)
753 ta->ta_handle->th_result = err;
754 rc = dt_trans_stop(env, ta->ta_handle->th_dev, ta->ta_handle);
755 for (i = 0; i < ta->ta_argno; i++) {
756 if (ta->ta_args[i]->object != NULL) {
757 struct dt_object *obj = ta->ta_args[i]->object;
759 /* If the object is being created during this
760 * transaction, we need to remove them from the
761 * cache immediately, because a few layers are
762 * missing in OUT handler, i.e. the object might
763 * not be initialized in all layers */
764 if (ta->ta_args[i]->exec_fn == out_tx_create_exec)
765 set_bit(LU_OBJECT_HEARD_BANSHEE,
766 &obj->do_lu.lo_header->loh_flags);
767 lu_object_put(env, &ta->ta_args[i]->object->do_lu);
768 ta->ta_args[i]->object = NULL;
771 ta->ta_handle = NULL;
777 static int out_tx_end(const struct lu_env *env, struct thandle_exec_args *ta,
780 struct tgt_session_info *tsi = tgt_ses_info(env);
786 if (ta->ta_handle == NULL)
789 if (declare_ret != 0 || ta->ta_argno == 0)
790 GOTO(stop, rc = declare_ret);
792 LASSERT(ta->ta_handle->th_dev != NULL);
793 rc = out_trans_start(env, ta);
794 if (unlikely(rc != 0))
797 for (i = 0; i < ta->ta_argno; i++) {
798 rc = ta->ta_args[i]->exec_fn(env, ta->ta_handle,
800 if (unlikely(rc != 0)) {
801 CDEBUG(D_INFO, "error during execution of #%u from"
802 " %s:%d: rc = %d\n", i, ta->ta_args[i]->file,
803 ta->ta_args[i]->line, rc);
805 if (ta->ta_args[i]->undo_fn != NULL)
806 ta->ta_args[i]->undo_fn(env,
810 CERROR("%s: undo for %s:%d: rc = %d\n",
811 dt_obd_name(ta->ta_handle->th_dev),
812 ta->ta_args[i]->file,
813 ta->ta_args[i]->line, -ENOTSUPP);
817 CDEBUG(D_INFO, "%s: executed %u/%u: rc = %d\n",
818 dt_obd_name(ta->ta_handle->th_dev), i, ta->ta_argno, rc);
821 /* Only fail for real updates, XXX right now llog updates will be
822 * ignore, whose updates count is usually 1, so failover test
823 * case will spot this FAIL_UPDATE_NET_REP precisely, and it will
824 * be removed after async update patch is landed. */
825 if (ta->ta_argno > 1)
826 tsi->tsi_reply_fail_id = OBD_FAIL_OUT_UPDATE_NET_REP;
829 rc1 = out_trans_stop(env, ta, rc);
833 ta->ta_handle = NULL;
840 * Object updates between Targets. Because all the updates has been
841 * dis-assemblied into object updates at sender side, so OUT will
842 * call OSD API directly to execute these updates.
844 * In DNE phase I all of the updates in the request need to be executed
845 * in one transaction, and the transaction has to be synchronously.
847 * Please refer to lustre/include/lustre/lustre_idl.h for req/reply
850 int out_handle(struct tgt_session_info *tsi)
852 const struct lu_env *env = tsi->tsi_env;
853 struct tgt_thread_info *tti = tgt_th_info(env);
854 struct thandle_exec_args *ta = &tti->tti_tea;
855 struct req_capsule *pill = tsi->tsi_pill;
856 struct dt_device *dt = tsi->tsi_tgt->lut_bottom;
857 struct object_update_request *ureq;
858 struct object_update *update;
859 struct object_update_reply *reply;
862 int current_batchid = -1;
869 req_capsule_set(pill, &RQF_OUT_UPDATE);
870 ureq = req_capsule_client_get(pill, &RMF_OUT_UPDATE);
872 CERROR("%s: No buf!: rc = %d\n", tgt_name(tsi->tsi_tgt),
874 RETURN(err_serious(-EPROTO));
877 bufsize = req_capsule_get_size(pill, &RMF_OUT_UPDATE, RCL_CLIENT);
878 if (bufsize != object_update_request_size(ureq)) {
879 CERROR("%s: invalid bufsize %d: rc = %d\n",
880 tgt_name(tsi->tsi_tgt), bufsize, -EPROTO);
881 RETURN(err_serious(-EPROTO));
884 if (ureq->ourq_magic != UPDATE_REQUEST_MAGIC) {
885 CERROR("%s: invalid update buffer magic %x expect %x: "
886 "rc = %d\n", tgt_name(tsi->tsi_tgt), ureq->ourq_magic,
887 UPDATE_REQUEST_MAGIC, -EPROTO);
888 RETURN(err_serious(-EPROTO));
891 count = ureq->ourq_count;
893 CERROR("%s: empty update: rc = %d\n", tgt_name(tsi->tsi_tgt),
895 RETURN(err_serious(-EPROTO));
898 req_capsule_set_size(pill, &RMF_OUT_UPDATE_REPLY, RCL_SERVER,
899 OUT_UPDATE_REPLY_SIZE);
900 rc = req_capsule_server_pack(pill);
902 CERROR("%s: Can't pack response: rc = %d\n",
903 tgt_name(tsi->tsi_tgt), rc);
907 /* Prepare the update reply buffer */
908 reply = req_capsule_server_get(pill, &RMF_OUT_UPDATE_REPLY);
910 RETURN(err_serious(-EPROTO));
911 object_update_reply_init(reply, count);
912 tti->tti_u.update.tti_update_reply = reply;
913 tti->tti_mult_trans = !req_is_replay(tgt_ses_req(tsi));
915 /* Walk through updates in the request to execute them synchronously */
916 for (i = 0; i < count; i++) {
917 struct tgt_handler *h;
918 struct dt_object *dt_obj;
920 update = object_update_request_get(ureq, i, NULL);
922 GOTO(out, rc = -EPROTO);
924 if (ptlrpc_req_need_swab(pill->rc_req))
925 lustre_swab_object_update(update);
927 if (!fid_is_sane(&update->ou_fid)) {
928 CERROR("%s: invalid FID "DFID": rc = %d\n",
929 tgt_name(tsi->tsi_tgt), PFID(&update->ou_fid),
931 GOTO(out, rc = err_serious(-EPROTO));
934 dt_obj = dt_locate(env, dt, &update->ou_fid);
936 GOTO(out, rc = PTR_ERR(dt_obj));
938 if (dt->dd_record_fid_accessed) {
939 lfsck_pack_rfa(&tti->tti_lr,
940 lu_object_fid(&dt_obj->do_lu),
943 tgt_lfsck_in_notify(env, dt, &tti->tti_lr, NULL);
946 tti->tti_u.update.tti_dt_object = dt_obj;
947 tti->tti_u.update.tti_update = update;
948 tti->tti_u.update.tti_update_reply_index = i;
950 h = out_handler_find(update->ou_type);
951 if (unlikely(h == NULL)) {
952 CERROR("%s: unsupported opc: 0x%x\n",
953 tgt_name(tsi->tsi_tgt), update->ou_type);
954 GOTO(next, rc = -ENOTSUPP);
957 /* Check resend case only for modifying RPC */
958 if (h->th_flags & MUTABOR) {
959 struct ptlrpc_request *req = tgt_ses_req(tsi);
961 if (out_check_resent(env, dt, dt_obj, req,
962 out_reconstruct, reply, i))
966 /* start transaction for modification RPC only */
967 if (h->th_flags & MUTABOR && current_batchid == -1) {
968 current_batchid = update->ou_batchid;
969 rc = out_tx_start(env, dt, ta, tsi->tsi_exp);
973 if (update->ou_flags & UPDATE_FL_SYNC)
974 ta->ta_handle->th_sync = 1;
977 /* Stop the current update transaction, if the update has
978 * different batchid, or read-only update */
979 if (((current_batchid != update->ou_batchid) ||
980 !(h->th_flags & MUTABOR)) && ta->ta_handle != NULL) {
981 rc = out_tx_end(env, ta, rc);
982 current_batchid = -1;
986 /* start a new transaction if needed */
987 if (h->th_flags & MUTABOR) {
988 rc = out_tx_start(env, dt, ta, tsi->tsi_exp);
992 if (update->ou_flags & UPDATE_FL_SYNC)
993 ta->ta_handle->th_sync = 1;
995 current_batchid = update->ou_batchid;
1001 lu_object_put(env, &dt_obj->do_lu);
1006 if (current_batchid != -1) {
1007 rc1 = out_tx_end(env, ta, rc);
1015 struct tgt_handler tgt_out_handlers[] = {
1016 TGT_UPDATE_HDL(MUTABOR, OUT_UPDATE, out_handle),
1018 EXPORT_SYMBOL(tgt_out_handlers);