lustre/target/out_handler.c

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   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.
   9  *
  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).
  15  *
  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
  19  *
  20  * GPL HEADER END
  21  */
  22 /*
  23  * Copyright (c) 2013, 2017, Intel Corporation.
  24  *
  25  * lustre/target/out_handler.c
  26  *
  27  * Object update handler between targets.
  28  *
  29  * Author: di.wang <di.wang@intel.com>
  30  */
  31
  32 #define DEBUG_SUBSYSTEM S_CLASS
  33
  34 #include <llog_swab.h>
  35 #include <lustre_obdo.h>
  36 #include <lustre_swab.h>
  37 #include <lustre_update.h>
  38 #include <md_object.h>
  39 #include <obd_class.h>
  40 #include "tgt_internal.h"
  41
  42 static inline void orr_cpu_to_le(struct out_read_reply *orr_dst,
  43                                  const struct out_read_reply *orr_src)
  44 {
  45         orr_dst->orr_size = cpu_to_le32(orr_src->orr_size);
  46         orr_dst->orr_padding = cpu_to_le32(orr_src->orr_padding);
  47         orr_dst->orr_offset = cpu_to_le64(orr_dst->orr_offset);
  48 }
  49
  50 static void out_reconstruct(const struct lu_env *env, struct dt_device *dt,
  51                             struct dt_object *obj,
  52                             struct object_update_reply *reply,
  53                             int index)
  54 {
  55         CDEBUG(D_INFO, "%s: fork reply reply %p index %d: rc = %d\n",
  56                dt_obd_name(dt), reply, index, 0);
  57
  58         object_update_result_insert(reply, NULL, 0, index, 0);
  59         return;
  60 }
  61
  62 typedef void (*out_reconstruct_t)(const struct lu_env *env,
  63                                   struct dt_device *dt,
  64                                   struct dt_object *obj,
  65                                   struct object_update_reply *reply,
  66                                   int index);
  67
  68 static inline int out_check_resent(const struct lu_env *env,
  69                                    struct dt_device *dt,
  70                                    struct dt_object *obj,
  71                                    struct ptlrpc_request *req,
  72                                    out_reconstruct_t reconstruct,
  73                                    struct object_update_reply *reply,
  74                                    int index)
  75 {
  76         if (likely(!(lustre_msg_get_flags(req->rq_reqmsg) & MSG_RESENT)))
  77                 return 0;
  78
  79         if (req_xid_is_last(req)) {
  80                 struct lsd_client_data *lcd;
  81
  82                 /* XXX this does not support mulitple transactions yet, i.e.
  83                  * only 1 update RPC each time betwee MDTs */
  84                 lcd = req->rq_export->exp_target_data.ted_lcd;
  85
  86                 req->rq_transno = lcd->lcd_last_transno;
  87                 req->rq_status = lcd->lcd_last_result;
  88                 if (req->rq_status != 0)
  89                         req->rq_transno = 0;
  90                 lustre_msg_set_transno(req->rq_repmsg, req->rq_transno);
  91                 lustre_msg_set_status(req->rq_repmsg, req->rq_status);
  92
  93                 DEBUG_REQ(D_RPCTRACE, req, "restoring resent RPC");
  94
  95                 reconstruct(env, dt, obj, reply, index);
  96                 return 1;
  97         }
  98         DEBUG_REQ(D_HA, req, "no reply for RESENT req (have %lld)",
  99                  req->rq_export->exp_target_data.ted_lcd->lcd_last_xid);
 100         return 0;
 101 }
 102
 103 static int out_create(struct tgt_session_info *tsi)
 104 {
 105         struct tgt_thread_info  *tti = tgt_th_info(tsi->tsi_env);
 106         struct object_update    *update = tti->tti_u.update.tti_update;
 107         struct dt_object        *obj = tti->tti_u.update.tti_dt_object;
 108         struct dt_object_format *dof = &tti->tti_u.update.tti_update_dof;
 109         struct obdo             *lobdo = &tti->tti_u.update.tti_obdo;
 110         struct lu_attr          *attr = &tti->tti_attr;
 111         struct lu_fid           *fid = NULL;
 112         struct obdo             *wobdo;
 113         size_t                  size;
 114         int                     rc;
 115
 116         ENTRY;
 117
 118         wobdo = object_update_param_get(update, 0, &size);
 119         if (IS_ERR(wobdo) || size != sizeof(*wobdo)) {
 120                 CERROR("%s: obdo is NULL, invalid RPC: rc = %ld\n",
 121                        tgt_name(tsi->tsi_tgt), PTR_ERR(wobdo));
 122                 RETURN(PTR_ERR(wobdo));
 123         }
 124
 125         if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
 126                 lustre_swab_obdo(wobdo);
 127         lustre_get_wire_obdo(NULL, lobdo, wobdo);
 128         la_from_obdo(attr, lobdo, lobdo->o_valid);
 129
 130         dof->dof_type = dt_mode_to_dft(attr->la_mode);
 131         if (update->ou_params_count > 1) {
 132                 fid = object_update_param_get(update, 1, &size);
 133                 if (IS_ERR(fid) || size != sizeof(*fid)) {
 134                         CERROR("%s: invalid fid: rc = %ld\n",
 135                                tgt_name(tsi->tsi_tgt), PTR_ERR(fid));
 136                         RETURN(PTR_ERR(fid));
 137                 }
 138                 if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
 139                         lustre_swab_lu_fid(fid);
 140                 if (!fid_is_sane(fid)) {
 141                         CERROR("%s: invalid fid "DFID": rc = %d\n",
 142                                tgt_name(tsi->tsi_tgt), PFID(fid), -EPROTO);
 143                         RETURN(-EPROTO);
 144                 }
 145         }
 146
 147         if (lu_object_exists(&obj->do_lu))
 148                 RETURN(-EEXIST);
 149
 150         rc = out_tx_create(tsi->tsi_env, obj, attr, fid, dof,
 151                            &tti->tti_tea, tti->tti_tea.ta_handle,
 152                            tti->tti_u.update.tti_update_reply,
 153                            tti->tti_u.update.tti_update_reply_index);
 154
 155         RETURN(rc);
 156 }
 157
 158 static int out_attr_set(struct tgt_session_info *tsi)
 159 {
 160         struct tgt_thread_info  *tti = tgt_th_info(tsi->tsi_env);
 161         struct object_update    *update = tti->tti_u.update.tti_update;
 162         struct lu_attr          *attr = &tti->tti_attr;
 163         struct dt_object        *obj = tti->tti_u.update.tti_dt_object;
 164         struct obdo             *lobdo = &tti->tti_u.update.tti_obdo;
 165         struct obdo             *wobdo;
 166         size_t                   size;
 167         int                      rc;
 168
 169         ENTRY;
 170
 171         wobdo = object_update_param_get(update, 0, &size);
 172         if (IS_ERR(wobdo) || size != sizeof(*wobdo)) {
 173                 CERROR("%s: empty obdo in the update: rc = %ld\n",
 174                        tgt_name(tsi->tsi_tgt), PTR_ERR(wobdo));
 175                 RETURN(PTR_ERR(wobdo));
 176         }
 177
 178         attr->la_valid = 0;
 179         attr->la_valid = 0;
 180
 181         if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
 182                 lustre_swab_obdo(wobdo);
 183         lustre_get_wire_obdo(NULL, lobdo, wobdo);
 184         la_from_obdo(attr, lobdo, lobdo->o_valid);
 185
 186         rc = out_tx_attr_set(tsi->tsi_env, obj, attr, &tti->tti_tea,
 187                              tti->tti_tea.ta_handle,
 188                              tti->tti_u.update.tti_update_reply,
 189                              tti->tti_u.update.tti_update_reply_index);
 190
 191         RETURN(rc);
 192 }
 193
 194 static int out_attr_get(struct tgt_session_info *tsi)
 195 {
 196         const struct lu_env     *env = tsi->tsi_env;
 197         struct tgt_thread_info  *tti = tgt_th_info(env);
 198         struct object_update    *update = tti->tti_u.update.tti_update;
 199         struct obdo             *obdo = &tti->tti_u.update.tti_obdo;
 200         struct lu_attr          *la = &tti->tti_attr;
 201         struct dt_object        *obj = tti->tti_u.update.tti_dt_object;
 202         int                     idx = tti->tti_u.update.tti_update_reply_index;
 203         int                     rc;
 204
 205         ENTRY;
 206
 207         if (unlikely(update->ou_result_size < sizeof(*obdo)))
 208                 return -EPROTO;
 209
 210         if (!lu_object_exists(&obj->do_lu)) {
 211                 /* Usually, this will be called when the master MDT try
 212                  * to init a remote object(see osp_object_init), so if
 213                  * the object does not exist on slave, we need set BANSHEE flag,
 214                  * so the object can be removed from the cache immediately */
 215                 set_bit(LU_OBJECT_HEARD_BANSHEE,
 216                         &obj->do_lu.lo_header->loh_flags);
 217                 RETURN(-ENOENT);
 218         }
 219
 220         dt_read_lock(env, obj, MOR_TGT_CHILD);
 221         rc = dt_attr_get(env, obj, la);
 222         if (rc)
 223                 GOTO(out_unlock, rc);
 224
 225         obdo->o_valid = 0;
 226         obdo_from_la(obdo, la, la->la_valid);
 227
 228 out_unlock:
 229         dt_read_unlock(env, obj);
 230
 231         CDEBUG(D_INFO, "%s: insert attr get reply %p index %d: rc = %d\n",
 232                tgt_name(tsi->tsi_tgt), tti->tti_u.update.tti_update_reply,
 233                0, rc);
 234
 235         object_update_result_insert(tti->tti_u.update.tti_update_reply, obdo,
 236                                     sizeof(*obdo), idx, rc);
 237
 238         RETURN(rc);
 239 }
 240
 241 static int out_xattr_get(struct tgt_session_info *tsi)
 242 {
 243         const struct lu_env        *env = tsi->tsi_env;
 244         struct tgt_thread_info     *tti = tgt_th_info(env);
 245         struct object_update       *update = tti->tti_u.update.tti_update;
 246         struct lu_buf              *lbuf = &tti->tti_buf;
 247         struct object_update_reply *reply = tti->tti_u.update.tti_update_reply;
 248         struct dt_object           *obj = tti->tti_u.update.tti_dt_object;
 249         char                       *name;
 250         struct object_update_result *update_result;
 251         int                     idx = tti->tti_u.update.tti_update_reply_index;
 252         int                        rc;
 253
 254         ENTRY;
 255
 256         if (!lu_object_exists(&obj->do_lu)) {
 257                 set_bit(LU_OBJECT_HEARD_BANSHEE,
 258                         &obj->do_lu.lo_header->loh_flags);
 259                 RETURN(-ENOENT);
 260         }
 261
 262         name = object_update_param_get(update, 0, NULL);
 263         if (IS_ERR(name)) {
 264                 CERROR("%s: empty name for xattr get: rc = %ld\n",
 265                        tgt_name(tsi->tsi_tgt), PTR_ERR(name));
 266                 RETURN(PTR_ERR(name));
 267         }
 268
 269         update_result = object_update_result_get(reply, idx, NULL);
 270         if (update_result == NULL) {
 271                 CERROR("%s: empty name for xattr get: rc = %d\n",
 272                        tgt_name(tsi->tsi_tgt), -EPROTO);
 273                 RETURN(-EPROTO);
 274         }
 275
 276         lbuf->lb_len = (int)tti->tti_u.update.tti_update->ou_result_size;
 277         if (lbuf->lb_len == 0)
 278                 lbuf->lb_buf = NULL;
 279         else
 280                 lbuf->lb_buf = update_result->our_data;
 281
 282         dt_read_lock(env, obj, MOR_TGT_CHILD);
 283         rc = dt_xattr_get(env, obj, lbuf, name);
 284         dt_read_unlock(env, obj);
 285         if (rc <= 0) {
 286                 lbuf->lb_len = 0;
 287                 if (unlikely(!rc))
 288                         rc = -ENODATA;
 289         } else if (lbuf->lb_buf) {
 290                 lbuf->lb_len = rc;
 291         }
 292         CDEBUG(D_INFO, "%s: "DFID" get xattr %s len %d\n",
 293                tgt_name(tsi->tsi_tgt), PFID(lu_object_fid(&obj->do_lu)),
 294                name, rc);
 295
 296         GOTO(out, rc);
 297
 298 out:
 299         object_update_result_insert(reply, lbuf->lb_buf, lbuf->lb_len, idx, rc);
 300         RETURN(0);
 301 }
 302
 303 static int out_xattr_list(struct tgt_session_info *tsi)
 304 {
 305         const struct lu_env *env = tsi->tsi_env;
 306         struct tgt_thread_info *tti = tgt_th_info(env);
 307         struct lu_buf *lbuf = &tti->tti_buf;
 308         struct object_update_reply *reply = tti->tti_u.update.tti_update_reply;
 309         struct dt_object *obj = tti->tti_u.update.tti_dt_object;
 310         struct object_update_result *update_result;
 311         int idx = tti->tti_u.update.tti_update_reply_index;
 312         int rc;
 313
 314         ENTRY;
 315
 316         if (!lu_object_exists(&obj->do_lu)) {
 317                 set_bit(LU_OBJECT_HEARD_BANSHEE,
 318                         &obj->do_lu.lo_header->loh_flags);
 319                 RETURN(-ENOENT);
 320         }
 321
 322         update_result = object_update_result_get(reply, 0, NULL);
 323         if (!update_result) {
 324                 rc = -EPROTO;
 325                 CERROR("%s: empty buf for xattr list: rc = %d\n",
 326                        tgt_name(tsi->tsi_tgt), rc);
 327                 RETURN(rc);
 328         }
 329
 330         lbuf->lb_len = (int)tti->tti_u.update.tti_update->ou_result_size;
 331         lbuf->lb_buf = update_result->our_data;
 332         if (lbuf->lb_len == 0)
 333                 lbuf->lb_buf = 0;
 334
 335         dt_read_lock(env, obj, MOR_TGT_CHILD);
 336         rc = dt_xattr_list(env, obj, lbuf);
 337         dt_read_unlock(env, obj);
 338         if (rc <= 0) {
 339                 lbuf->lb_len = 0;
 340                 if (unlikely(!rc))
 341                         rc = -ENODATA;
 342         } else if (lbuf->lb_buf) {
 343                 lbuf->lb_len = rc;
 344         }
 345
 346         CDEBUG(D_INFO, "%s: "DFID" list xattr len %d\n",
 347                tgt_name(tsi->tsi_tgt), PFID(lu_object_fid(&obj->do_lu)), rc);
 348
 349         /* Since we directly use update_result->our_data as the lbuf->lb_buf,
 350          * then use NULL for result_insert to avoid unnecessary memory copy. */
 351         object_update_result_insert(reply, NULL, lbuf->lb_len, idx, rc);
 352
 353         RETURN(0);
 354 }
 355
 356 static int out_index_lookup(struct tgt_session_info *tsi)
 357 {
 358         const struct lu_env     *env = tsi->tsi_env;
 359         struct tgt_thread_info  *tti = tgt_th_info(env);
 360         struct object_update    *update = tti->tti_u.update.tti_update;
 361         struct dt_object        *obj = tti->tti_u.update.tti_dt_object;
 362         char                    *name;
 363         int                      rc;
 364
 365         ENTRY;
 366
 367         if (unlikely(update->ou_result_size < sizeof(tti->tti_fid1)))
 368                 return -EPROTO;
 369
 370         if (!lu_object_exists(&obj->do_lu))
 371                 RETURN(-ENOENT);
 372
 373         name = object_update_param_get(update, 0, NULL);
 374         if (IS_ERR(name)) {
 375                 CERROR("%s: empty name for lookup: rc = %ld\n",
 376                        tgt_name(tsi->tsi_tgt), PTR_ERR(name));
 377                 RETURN(PTR_ERR(name));
 378         }
 379
 380         dt_read_lock(env, obj, MOR_TGT_CHILD);
 381         if (!dt_try_as_dir(env, obj))
 382                 GOTO(out_unlock, rc = -ENOTDIR);
 383
 384         rc = dt_lookup(env, obj, (struct dt_rec *)&tti->tti_fid1,
 385                        (struct dt_key *)name);
 386
 387         if (rc < 0)
 388                 GOTO(out_unlock, rc);
 389
 390         if (rc == 0)
 391                 rc += 1;
 392
 393 out_unlock:
 394         dt_read_unlock(env, obj);
 395
 396         CDEBUG(D_INFO, "lookup "DFID" %s get "DFID" rc %d\n",
 397                PFID(lu_object_fid(&obj->do_lu)), name,
 398                PFID(&tti->tti_fid1), rc);
 399
 400         CDEBUG(D_INFO, "%s: insert lookup reply %p index %d: rc = %d\n",
 401                tgt_name(tsi->tsi_tgt), tti->tti_u.update.tti_update_reply,
 402                0, rc);
 403
 404         object_update_result_insert(tti->tti_u.update.tti_update_reply,
 405                             &tti->tti_fid1, sizeof(tti->tti_fid1),
 406                             tti->tti_u.update.tti_update_reply_index, rc);
 407         RETURN(rc);
 408 }
 409
 410 static int out_xattr_set(struct tgt_session_info *tsi)
 411 {
 412         struct tgt_thread_info  *tti = tgt_th_info(tsi->tsi_env);
 413         struct object_update    *update = tti->tti_u.update.tti_update;
 414         struct dt_object        *obj = tti->tti_u.update.tti_dt_object;
 415         struct lu_buf           *lbuf = &tti->tti_buf;
 416         char                    *name;
 417         char                    *buf;
 418         __u32                   *tmp;
 419         size_t                   buf_len = 0;
 420         int                      flag;
 421         size_t                   size = 0;
 422         int                      rc;
 423         ENTRY;
 424
 425         name = object_update_param_get(update, 0, NULL);
 426         if (IS_ERR(name)) {
 427                 CERROR("%s: empty name for xattr set: rc = %ld\n",
 428                        tgt_name(tsi->tsi_tgt), PTR_ERR(name));
 429                 RETURN(PTR_ERR(name));
 430         }
 431
 432         /* If buffer == NULL (-ENODATA), then it might mean delete xattr */
 433         buf = object_update_param_get(update, 1, &buf_len);
 434         if (IS_ERR(buf) && PTR_ERR(buf) != -ENODATA)
 435                 RETURN(PTR_ERR(buf));
 436
 437         lbuf->lb_buf = buf;
 438         lbuf->lb_len = buf_len;
 439
 440         tmp = object_update_param_get(update, 2, &size);
 441         if (IS_ERR(tmp) || size != sizeof(*tmp)) {
 442                 CERROR("%s: emptry or wrong size %zu flag: rc = %ld\n",
 443                        tgt_name(tsi->tsi_tgt), size, PTR_ERR(tmp));
 444                 RETURN(PTR_ERR(tmp));
 445         }
 446
 447         if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
 448                 __swab32s(tmp);
 449         flag = *tmp;
 450
 451         rc = out_tx_xattr_set(tsi->tsi_env, obj, lbuf, name, flag,
 452                               &tti->tti_tea, tti->tti_tea.ta_handle,
 453                               tti->tti_u.update.tti_update_reply,
 454                               tti->tti_u.update.tti_update_reply_index);
 455         RETURN(rc);
 456 }
 457
 458 static int out_xattr_del(struct tgt_session_info *tsi)
 459 {
 460         struct tgt_thread_info  *tti = tgt_th_info(tsi->tsi_env);
 461         struct object_update    *update = tti->tti_u.update.tti_update;
 462         struct dt_object        *obj = tti->tti_u.update.tti_dt_object;
 463         char                    *name;
 464         int                      rc;
 465         ENTRY;
 466
 467         name = object_update_param_get(update, 0, NULL);
 468         if (IS_ERR(name)) {
 469                 CERROR("%s: empty name for xattr set: rc = %ld\n",
 470                        tgt_name(tsi->tsi_tgt), PTR_ERR(name));
 471                 RETURN(PTR_ERR(name));
 472         }
 473
 474         rc = out_tx_xattr_del(tsi->tsi_env, obj, name, &tti->tti_tea,
 475                               tti->tti_tea.ta_handle,
 476                               tti->tti_u.update.tti_update_reply,
 477                               tti->tti_u.update.tti_update_reply_index);
 478         RETURN(rc);
 479 }
 480
 481 /**
 482  * increase ref of the object
 483  **/
 484 static int out_ref_add(struct tgt_session_info *tsi)
 485 {
 486         struct tgt_thread_info  *tti = tgt_th_info(tsi->tsi_env);
 487         struct dt_object        *obj = tti->tti_u.update.tti_dt_object;
 488         int                      rc;
 489
 490         ENTRY;
 491
 492         rc = out_tx_ref_add(tsi->tsi_env, obj, &tti->tti_tea,
 493                             tti->tti_tea.ta_handle,
 494                             tti->tti_u.update.tti_update_reply,
 495                             tti->tti_u.update.tti_update_reply_index);
 496         RETURN(rc);
 497 }
 498
 499 static int out_ref_del(struct tgt_session_info *tsi)
 500 {
 501         struct tgt_thread_info  *tti = tgt_th_info(tsi->tsi_env);
 502         struct dt_object        *obj = tti->tti_u.update.tti_dt_object;
 503         int                      rc;
 504
 505         ENTRY;
 506
 507         if (!lu_object_exists(&obj->do_lu))
 508                 RETURN(-ENOENT);
 509
 510         rc = out_tx_ref_del(tsi->tsi_env, obj, &tti->tti_tea,
 511                             tti->tti_tea.ta_handle,
 512                             tti->tti_u.update.tti_update_reply,
 513                             tti->tti_u.update.tti_update_reply_index);
 514         RETURN(rc);
 515 }
 516
 517 static int out_index_insert(struct tgt_session_info *tsi)
 518 {
 519         struct tgt_thread_info  *tti    = tgt_th_info(tsi->tsi_env);
 520         struct object_update    *update = tti->tti_u.update.tti_update;
 521         struct dt_object        *obj    = tti->tti_u.update.tti_dt_object;
 522         struct dt_insert_rec    *rec    = &tti->tti_rec;
 523         struct lu_fid           *fid;
 524         char                    *name;
 525         __u32                   *ptype;
 526         int                      rc     = 0;
 527         size_t                   size;
 528         ENTRY;
 529
 530         name = object_update_param_get(update, 0, NULL);
 531         if (IS_ERR(name)) {
 532                 CERROR("%s: empty name for index insert: rc = %ld\n",
 533                        tgt_name(tsi->tsi_tgt), PTR_ERR(name));
 534                 RETURN(PTR_ERR(name));
 535         }
 536
 537         fid = object_update_param_get(update, 1, &size);
 538         if (IS_ERR(fid) || size != sizeof(*fid)) {
 539                 CERROR("%s: invalid fid: rc = %ld\n",
 540                        tgt_name(tsi->tsi_tgt), PTR_ERR(fid));
 541                 RETURN(PTR_ERR(fid));
 542         }
 543
 544         if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
 545                 lustre_swab_lu_fid(fid);
 546
 547         if (!fid_is_sane(fid)) {
 548                 CERROR("%s: invalid FID "DFID": rc = %d\n",
 549                        tgt_name(tsi->tsi_tgt), PFID(fid), -EPROTO);
 550                 RETURN(-EPROTO);
 551         }
 552
 553         ptype = object_update_param_get(update, 2, &size);
 554         if (IS_ERR(ptype) || size != sizeof(*ptype)) {
 555                 CERROR("%s: invalid type for index insert: rc = %ld\n",
 556                        tgt_name(tsi->tsi_tgt), PTR_ERR(ptype));
 557                 RETURN(PTR_ERR(ptype));
 558         }
 559
 560         if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
 561                 __swab32s(ptype);
 562
 563         rec->rec_fid = fid;
 564         rec->rec_type = *ptype;
 565
 566         rc = out_tx_index_insert(tsi->tsi_env, obj, (const struct dt_rec *)rec,
 567                                  (const struct dt_key *)name, &tti->tti_tea,
 568                                  tti->tti_tea.ta_handle,
 569                                  tti->tti_u.update.tti_update_reply,
 570                                  tti->tti_u.update.tti_update_reply_index);
 571
 572         CDEBUG(D_INFO, "%s: "DFID" index insert %s: rc = %d\n",
 573                tgt_name(tsi->tsi_tgt), PFID(lu_object_fid(&obj->do_lu)),
 574                name, rc);
 575
 576         RETURN(rc);
 577 }
 578
 579 static int out_index_delete(struct tgt_session_info *tsi)
 580 {
 581         struct tgt_thread_info  *tti = tgt_th_info(tsi->tsi_env);
 582         struct object_update    *update = tti->tti_u.update.tti_update;
 583         struct dt_object        *obj = tti->tti_u.update.tti_dt_object;
 584         char                    *name;
 585         int                      rc = 0;
 586
 587         if (!lu_object_exists(&obj->do_lu))
 588                 RETURN(-ENOENT);
 589
 590         name = object_update_param_get(update, 0, NULL);
 591         if (IS_ERR(name)) {
 592                 CERROR("%s: empty name for index delete: rc = %ld\n",
 593                        tgt_name(tsi->tsi_tgt), PTR_ERR(name));
 594                 RETURN(PTR_ERR(name));
 595         }
 596
 597         rc = out_tx_index_delete(tsi->tsi_env, obj, (const struct dt_key *)name,
 598                                  &tti->tti_tea, tti->tti_tea.ta_handle,
 599                                  tti->tti_u.update.tti_update_reply,
 600                                  tti->tti_u.update.tti_update_reply_index);
 601         RETURN(rc);
 602 }
 603
 604 static int out_destroy(struct tgt_session_info *tsi)
 605 {
 606         struct tgt_thread_info  *tti = tgt_th_info(tsi->tsi_env);
 607         struct object_update    *update = tti->tti_u.update.tti_update;
 608         struct dt_object        *obj = tti->tti_u.update.tti_dt_object;
 609         struct lu_fid           *fid;
 610         int                      rc;
 611         ENTRY;
 612
 613         fid = &update->ou_fid;
 614         if (!fid_is_sane(fid)) {
 615                 CERROR("%s: invalid FID "DFID": rc = %d\n",
 616                        tgt_name(tsi->tsi_tgt), PFID(fid), -EPROTO);
 617                 RETURN(-EPROTO);
 618         }
 619
 620         if (!lu_object_exists(&obj->do_lu))
 621                 RETURN(-ENOENT);
 622
 623         rc = out_tx_destroy(tsi->tsi_env, obj, &tti->tti_tea,
 624                             tti->tti_tea.ta_handle,
 625                             tti->tti_u.update.tti_update_reply,
 626                             tti->tti_u.update.tti_update_reply_index);
 627
 628         RETURN(rc);
 629 }
 630
 631 static int out_write(struct tgt_session_info *tsi)
 632 {
 633         struct tgt_thread_info  *tti = tgt_th_info(tsi->tsi_env);
 634         struct object_update    *update = tti->tti_u.update.tti_update;
 635         struct dt_object        *obj = tti->tti_u.update.tti_dt_object;
 636         struct lu_buf           *lbuf = &tti->tti_buf;
 637         char                    *buf;
 638         __u64                   *tmp;
 639         size_t                  size = 0;
 640         size_t                  buf_len = 0;
 641         loff_t                  pos;
 642         int                      rc;
 643         ENTRY;
 644
 645         buf = object_update_param_get(update, 0, &buf_len);
 646         if (IS_ERR(buf) || buf_len == 0) {
 647                 CERROR("%s: empty buf for xattr set: rc = %ld\n",
 648                        tgt_name(tsi->tsi_tgt), PTR_ERR(buf));
 649                 RETURN(PTR_ERR(buf));
 650         }
 651         lbuf->lb_buf = buf;
 652         lbuf->lb_len = buf_len;
 653
 654         tmp = object_update_param_get(update, 1, &size);
 655         if (IS_ERR(tmp) || size != sizeof(*tmp)) {
 656                 CERROR("%s: empty or wrong size %zu pos: rc = %ld\n",
 657                        tgt_name(tsi->tsi_tgt), size, PTR_ERR(tmp));
 658                 RETURN(PTR_ERR(tmp));
 659         }
 660
 661         if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
 662                 __swab64s(tmp);
 663         pos = *tmp;
 664
 665         rc = out_tx_write(tsi->tsi_env, obj, lbuf, pos,
 666                           &tti->tti_tea, tti->tti_tea.ta_handle,
 667                           tti->tti_u.update.tti_update_reply,
 668                           tti->tti_u.update.tti_update_reply_index);
 669         RETURN(rc);
 670 }
 671
 672 static int out_read(struct tgt_session_info *tsi)
 673 {
 674         const struct lu_env     *env = tsi->tsi_env;
 675         struct tgt_thread_info  *tti = tgt_th_info(env);
 676         struct object_update    *update = tti->tti_u.update.tti_update;
 677         struct dt_object        *obj = tti->tti_u.update.tti_dt_object;
 678         struct object_update_reply *reply = tti->tti_u.update.tti_update_reply;
 679         int index = tti->tti_u.update.tti_update_reply_index;
 680         struct lu_rdbuf *rdbuf;
 681         struct object_update_result *update_result;
 682         struct out_read_reply   *orr;
 683         void *tmp;
 684         size_t size;
 685         size_t total_size = 0;
 686         __u64 pos;
 687         unsigned int i;
 688         unsigned int nbufs;
 689         int rc = 0;
 690         ENTRY;
 691
 692         update_result = object_update_result_get(reply, index, NULL);
 693         LASSERT(update_result != NULL);
 694         update_result->our_datalen = sizeof(*orr);
 695
 696         if (!lu_object_exists(&obj->do_lu))
 697                 GOTO(out, rc = -ENOENT);
 698
 699         tmp = object_update_param_get(update, 0, NULL);
 700         if (IS_ERR(tmp)) {
 701                 CERROR("%s: empty size for read: rc = %ld\n",
 702                        tgt_name(tsi->tsi_tgt), PTR_ERR(tmp));
 703                 GOTO(out, rc = PTR_ERR(tmp));
 704         }
 705         size = le64_to_cpu(*(size_t *)(tmp));
 706
 707         tmp = object_update_param_get(update, 1, NULL);
 708         if (IS_ERR(tmp)) {
 709                 CERROR("%s: empty pos for read: rc = %ld\n",
 710                        tgt_name(tsi->tsi_tgt), PTR_ERR(tmp));
 711                 GOTO(out, rc = PTR_ERR(tmp));
 712         }
 713         pos = le64_to_cpu(*(__u64 *)(tmp));
 714
 715         /* Put the offset into the begining of the buffer in reply */
 716         orr = (struct out_read_reply *)update_result->our_data;
 717
 718         nbufs = (size + OUT_BULK_BUFFER_SIZE - 1) / OUT_BULK_BUFFER_SIZE;
 719         OBD_ALLOC(rdbuf, sizeof(struct lu_rdbuf) +
 720                          nbufs * sizeof(rdbuf->rb_bufs[0]));
 721         if (rdbuf == NULL)
 722                 GOTO(out, rc = -ENOMEM);
 723
 724         rdbuf->rb_nbufs = 0;
 725         total_size = 0;
 726         for (i = 0; i < nbufs; i++) {
 727                 __u32 read_size;
 728
 729                 read_size = size > OUT_BULK_BUFFER_SIZE ?
 730                             OUT_BULK_BUFFER_SIZE : size;
 731                 OBD_ALLOC(rdbuf->rb_bufs[i].lb_buf, read_size);
 732                 if (rdbuf->rb_bufs[i].lb_buf == NULL)
 733                         GOTO(out_free, rc = -ENOMEM);
 734
 735                 rdbuf->rb_bufs[i].lb_len = read_size;
 736                 dt_read_lock(env, obj, MOR_TGT_CHILD);
 737                 rc = dt_read(env, obj, &rdbuf->rb_bufs[i], &pos);
 738                 dt_read_unlock(env, obj);
 739
 740                 total_size += rc < 0 ? 0 : rc;
 741                 if (rc <= 0)
 742                         break;
 743
 744                 rdbuf->rb_nbufs++;
 745                 size -= read_size;
 746         }
 747
 748         /* send pages to client */
 749         rc = tgt_send_buffer(tsi, rdbuf);
 750         if (rc < 0)
 751                 GOTO(out_free, rc);
 752
 753         orr->orr_size = total_size;
 754         orr->orr_offset = pos;
 755
 756         orr_cpu_to_le(orr, orr);
 757         update_result->our_datalen += orr->orr_size;
 758 out_free:
 759         for (i = 0; i < nbufs; i++) {
 760                 if (rdbuf->rb_bufs[i].lb_buf != NULL) {
 761                         OBD_FREE(rdbuf->rb_bufs[i].lb_buf,
 762                                  rdbuf->rb_bufs[i].lb_len);
 763                 }
 764         }
 765         OBD_FREE(rdbuf, sizeof(struct lu_rdbuf) +
 766                         nbufs * sizeof(rdbuf->rb_bufs[0]));
 767 out:
 768         /* Insert read buffer */
 769         update_result->our_rc = ptlrpc_status_hton(rc);
 770         reply->ourp_lens[index] = cfs_size_round(update_result->our_datalen +
 771                                                  sizeof(*update_result));
 772         RETURN(rc);
 773 }
 774
 775 static int out_noop(struct tgt_session_info *tsi)
 776 {
 777         return 0;
 778 }
 779
 780 #define DEF_OUT_HNDL(opc, name, flags, fn)     \
 781 [opc - OUT_CREATE] = {                                  \
 782         .th_name    = name,                             \
 783         .th_fail_id = 0,                                \
 784         .th_opc     = opc,                              \
 785         .th_flags   = flags,                            \
 786         .th_act     = fn,                               \
 787         .th_fmt     = NULL,                             \
 788         .th_version = 0,                                \
 789 }
 790
 791 static struct tgt_handler out_update_ops[] = {
 792         DEF_OUT_HNDL(OUT_CREATE, "out_create", IS_MUTABLE | HAS_REPLY,
 793                      out_create),
 794         DEF_OUT_HNDL(OUT_DESTROY, "out_create", IS_MUTABLE | HAS_REPLY,
 795                      out_destroy),
 796         DEF_OUT_HNDL(OUT_REF_ADD, "out_ref_add", IS_MUTABLE | HAS_REPLY,
 797                      out_ref_add),
 798         DEF_OUT_HNDL(OUT_REF_DEL, "out_ref_del", IS_MUTABLE | HAS_REPLY,
 799                      out_ref_del),
 800         DEF_OUT_HNDL(OUT_ATTR_SET, "out_attr_set",  IS_MUTABLE | HAS_REPLY,
 801                      out_attr_set),
 802         DEF_OUT_HNDL(OUT_ATTR_GET, "out_attr_get",  HAS_REPLY,
 803                      out_attr_get),
 804         DEF_OUT_HNDL(OUT_XATTR_SET, "out_xattr_set", IS_MUTABLE | HAS_REPLY,
 805                      out_xattr_set),
 806         DEF_OUT_HNDL(OUT_XATTR_DEL, "out_xattr_del", IS_MUTABLE | HAS_REPLY,
 807                      out_xattr_del),
 808         DEF_OUT_HNDL(OUT_XATTR_GET, "out_xattr_get", HAS_REPLY,
 809                      out_xattr_get),
 810         DEF_OUT_HNDL(OUT_INDEX_LOOKUP, "out_index_lookup", HAS_REPLY,
 811                      out_index_lookup),
 812         DEF_OUT_HNDL(OUT_INDEX_INSERT, "out_index_insert",
 813                      IS_MUTABLE | HAS_REPLY, out_index_insert),
 814         DEF_OUT_HNDL(OUT_INDEX_DELETE, "out_index_delete",
 815                      IS_MUTABLE | HAS_REPLY, out_index_delete),
 816         DEF_OUT_HNDL(OUT_WRITE, "out_write", IS_MUTABLE | HAS_REPLY, out_write),
 817         DEF_OUT_HNDL(OUT_READ, "out_read", HAS_REPLY, out_read),
 818         DEF_OUT_HNDL(OUT_NOOP, "out_noop", HAS_REPLY, out_noop),
 819         DEF_OUT_HNDL(OUT_XATTR_LIST, "out_xattr_list", HAS_REPLY,
 820                      out_xattr_list),
 821 };
 822
 823 static struct tgt_handler *out_handler_find(__u32 opc)
 824 {
 825         struct tgt_handler *h;
 826
 827         h = NULL;
 828         if (OUT_CREATE <= opc && opc < OUT_LAST) {
 829                 h = &out_update_ops[opc - OUT_CREATE];
 830                 LASSERTF(h->th_opc == opc, "opcode mismatch %d != %d\n",
 831                          h->th_opc, opc);
 832         } else {
 833                 h = NULL; /* unsupported opc */
 834         }
 835         return h;
 836 }
 837
 838 static int out_tx_start(const struct lu_env *env, struct dt_device *dt,
 839                         struct thandle_exec_args *ta, struct obd_export *exp)
 840 {
 841         ta->ta_argno = 0;
 842         ta->ta_handle = dt_trans_create(env, dt);
 843         if (IS_ERR(ta->ta_handle)) {
 844                 int rc;
 845
 846                 rc = PTR_ERR(ta->ta_handle);
 847                 ta->ta_handle = NULL;
 848                 CERROR("%s: start handle error: rc = %d\n", dt_obd_name(dt),
 849                        rc);
 850                 return rc;
 851         }
 852         if (exp->exp_need_sync)
 853                 ta->ta_handle->th_sync = 1;
 854
 855         return 0;
 856 }
 857
 858 static int out_trans_start(const struct lu_env *env,
 859                            struct thandle_exec_args *ta)
 860 {
 861         return dt_trans_start(env, ta->ta_handle->th_dev, ta->ta_handle);
 862 }
 863
 864 static int out_trans_stop(const struct lu_env *env,
 865                           struct thandle_exec_args *ta, int err)
 866 {
 867         int i;
 868         int rc;
 869
 870         ta->ta_handle->th_result = err;
 871         rc = dt_trans_stop(env, ta->ta_handle->th_dev, ta->ta_handle);
 872         for (i = 0; i < ta->ta_argno; i++) {
 873                 if (ta->ta_args[i]->object != NULL) {
 874                         dt_object_put(env, ta->ta_args[i]->object);
 875                         ta->ta_args[i]->object = NULL;
 876                 }
 877         }
 878         ta->ta_handle = NULL;
 879         ta->ta_argno = 0;
 880
 881         return rc;
 882 }
 883
 884 static int out_tx_end(const struct lu_env *env, struct thandle_exec_args *ta,
 885                       int declare_ret)
 886 {
 887         struct tgt_session_info *tsi = tgt_ses_info(env);
 888         int                     i;
 889         int                     rc;
 890         int                     rc1;
 891         ENTRY;
 892
 893         if (ta->ta_handle == NULL)
 894                 RETURN(0);
 895
 896         if (declare_ret != 0 || ta->ta_argno == 0)
 897                 GOTO(stop, rc = declare_ret);
 898
 899         LASSERT(ta->ta_handle->th_dev != NULL);
 900         rc = out_trans_start(env, ta);
 901         if (unlikely(rc != 0))
 902                 GOTO(stop, rc);
 903
 904         for (i = 0; i < ta->ta_argno; i++) {
 905                 rc = ta->ta_args[i]->exec_fn(env, ta->ta_handle,
 906                                              ta->ta_args[i]);
 907                 if (unlikely(rc != 0)) {
 908                         CDEBUG(D_INFO, "error during execution of #%u from"
 909                                " %s:%d: rc = %d\n", i, ta->ta_args[i]->file,
 910                                ta->ta_args[i]->line, rc);
 911                         while (--i >= 0) {
 912                                 if (ta->ta_args[i]->undo_fn != NULL)
 913                                         ta->ta_args[i]->undo_fn(env,
 914                                                                ta->ta_handle,
 915                                                                ta->ta_args[i]);
 916                                 else
 917                                         CERROR("%s: undo for %s:%d: rc = %d\n",
 918                                              dt_obd_name(ta->ta_handle->th_dev),
 919                                                ta->ta_args[i]->file,
 920                                                ta->ta_args[i]->line, -ENOTSUPP);
 921                         }
 922                         break;
 923                 }
 924                 CDEBUG(D_INFO, "%s: executed %u/%u: rc = %d\n",
 925                        dt_obd_name(ta->ta_handle->th_dev), i, ta->ta_argno, rc);
 926         }
 927
 928         /* Only fail for real updates, XXX right now llog updates will be
 929         * ignore, whose updates count is usually 1, so failover test
 930         * case will spot this FAIL_UPDATE_NET_REP precisely, and it will
 931         * be removed after async update patch is landed. */
 932         if (ta->ta_argno > 1)
 933                 tsi->tsi_reply_fail_id = OBD_FAIL_OUT_UPDATE_NET_REP;
 934
 935 stop:
 936         rc1 = out_trans_stop(env, ta, rc);
 937         if (rc == 0)
 938                 rc = rc1;
 939
 940         ta->ta_handle = NULL;
 941         ta->ta_argno = 0;
 942
 943         RETURN(rc);
 944 }
 945
 946 /**
 947  * Object updates between Targets. Because all the updates has been
 948  * dis-assemblied into object updates at sender side, so OUT will
 949  * call OSD API directly to execute these updates.
 950  *
 951  * In DNE phase I all of the updates in the request need to be executed
 952  * in one transaction, and the transaction has to be synchronously.
 953  *
 954  * Please refer to lustre/include/lustre/lustre_idl.h for req/reply
 955  * format.
 956  */
 957 int out_handle(struct tgt_session_info *tsi)
 958 {
 959         const struct lu_env             *env = tsi->tsi_env;
 960         struct tgt_thread_info          *tti = tgt_th_info(env);
 961         struct thandle_exec_args        *ta = &tti->tti_tea;
 962         struct req_capsule              *pill = tsi->tsi_pill;
 963         struct dt_device                *dt = tsi->tsi_tgt->lut_bottom;
 964         struct out_update_header        *ouh;
 965         struct out_update_buffer        *oub = NULL;
 966         struct object_update            *update;
 967         struct object_update_reply      *reply;
 968         struct ptlrpc_bulk_desc         *desc = NULL;
 969         struct l_wait_info              lwi;
 970         void                            **update_bufs;
 971         int                             current_batchid = -1;
 972         __u32                           update_buf_count;
 973         unsigned int                    i;
 974         unsigned int                    reply_index = 0;
 975         int                             rc = 0;
 976         int                             rc1 = 0;
 977         int                             ouh_size, reply_size;
 978         int                             updates;
 979         ENTRY;
 980
 981         req_capsule_set(pill, &RQF_OUT_UPDATE);
 982         ouh_size = req_capsule_get_size(pill, &RMF_OUT_UPDATE_HEADER,
 983                                         RCL_CLIENT);
 984         if (ouh_size <= 0)
 985                 RETURN(err_serious(-EPROTO));
 986
 987         ouh = req_capsule_client_get(pill, &RMF_OUT_UPDATE_HEADER);
 988         if (ouh == NULL)
 989                 RETURN(err_serious(-EPROTO));
 990
 991         if (ouh->ouh_magic != OUT_UPDATE_HEADER_MAGIC) {
 992                 CERROR("%s: invalid update buffer magic %x expect %x: "
 993                        "rc = %d\n", tgt_name(tsi->tsi_tgt), ouh->ouh_magic,
 994                        UPDATE_REQUEST_MAGIC, -EPROTO);
 995                 RETURN(err_serious(-EPROTO));
 996         }
 997
 998         update_buf_count = ouh->ouh_count;
 999         if (update_buf_count == 0)
1000                 RETURN(err_serious(-EPROTO));
1001
1002         OBD_ALLOC(update_bufs, sizeof(*update_bufs) * update_buf_count);
1003         if (update_bufs == NULL)
1004                 RETURN(err_serious(-ENOMEM));
1005
1006         if (ouh->ouh_inline_length > 0) {
1007                 update_bufs[0] = ouh->ouh_inline_data;
1008         } else {
1009                 struct out_update_buffer *tmp;
1010
1011                 oub = req_capsule_client_get(pill, &RMF_OUT_UPDATE_BUF);
1012                 if (oub == NULL)
1013                         GOTO(out_free, rc = err_serious(-EPROTO));
1014
1015                 desc = ptlrpc_prep_bulk_exp(pill->rc_req, update_buf_count,
1016                                             PTLRPC_BULK_OPS_COUNT,
1017                                             PTLRPC_BULK_GET_SINK |
1018                                             PTLRPC_BULK_BUF_KVEC,
1019                                             MDS_BULK_PORTAL,
1020                                             &ptlrpc_bulk_kvec_ops);
1021                 if (desc == NULL)
1022                         GOTO(out_free, rc = err_serious(-ENOMEM));
1023
1024                 tmp = oub;
1025                 for (i = 0; i < update_buf_count; i++, tmp++) {
1026                         if (tmp->oub_size >= OUT_MAXREQSIZE)
1027                                 GOTO(out_free, rc = err_serious(-EPROTO));
1028
1029                         OBD_ALLOC_LARGE(update_bufs[i], tmp->oub_size);
1030                         if (update_bufs[i] == NULL)
1031                                 GOTO(out_free, rc = err_serious(-ENOMEM));
1032
1033                         desc->bd_frag_ops->add_iov_frag(desc, update_bufs[i],
1034                                                         tmp->oub_size);
1035                 }
1036
1037                 pill->rc_req->rq_bulk_write = 1;
1038                 rc = sptlrpc_svc_prep_bulk(pill->rc_req, desc);
1039                 if (rc != 0)
1040                         GOTO(out_free, rc = err_serious(rc));
1041
1042                 rc = target_bulk_io(pill->rc_req->rq_export, desc, &lwi);
1043                 if (rc < 0)
1044                         GOTO(out_free, rc = err_serious(rc));
1045         }
1046         /* validate the request and calculate the total update count and
1047          * set it to reply */
1048         reply_size = 0;
1049         updates = 0;
1050         for (i = 0; i < update_buf_count; i++) {
1051                 struct object_update_request    *our;
1052                 int                              j;
1053
1054                 our = update_bufs[i];
1055                 if (ptlrpc_req_need_swab(pill->rc_req))
1056                         lustre_swab_object_update_request(our);
1057
1058                 if (our->ourq_magic != UPDATE_REQUEST_MAGIC) {
1059                         CERROR("%s: invalid update buffer magic %x"
1060                                " expect %x: rc = %d\n",
1061                                tgt_name(tsi->tsi_tgt), our->ourq_magic,
1062                                UPDATE_REQUEST_MAGIC, -EPROTO);
1063                         GOTO(out_free, rc = err_serious(-EPROTO));
1064                 }
1065                 updates += our->ourq_count;
1066
1067                 /* need to calculate reply size */
1068                 for (j = 0; j < our->ourq_count; j++) {
1069                         update = object_update_request_get(our, j, NULL);
1070                         if (update == NULL)
1071                                 GOTO(out, rc = err_serious(-EPROTO));
1072                         if (ptlrpc_req_need_swab(pill->rc_req))
1073                                 lustre_swab_object_update(update);
1074
1075                         if (!fid_is_sane(&update->ou_fid)) {
1076                                 CERROR("%s: invalid FID "DFID": rc = %d\n",
1077                                        tgt_name(tsi->tsi_tgt),
1078                                        PFID(&update->ou_fid), -EPROTO);
1079                                 GOTO(out, rc = err_serious(-EPROTO));
1080                         }
1081
1082                         /* XXX: what ou_result_size can be considered safe? */
1083
1084                         reply_size += sizeof(reply->ourp_lens[0]);
1085                         reply_size += sizeof(struct object_update_result);
1086                         reply_size += update->ou_result_size;
1087                 }
1088         }
1089         reply_size += sizeof(*reply);
1090
1091         if (unlikely(reply_size > ouh->ouh_reply_size)) {
1092                 CERROR("%s: too small reply buf %u for %u, need %u at least\n",
1093                        tgt_name(tsi->tsi_tgt), ouh->ouh_reply_size,
1094                        updates, reply_size);
1095                 GOTO(out_free, rc = err_serious(-EPROTO));
1096         }
1097
1098         req_capsule_set_size(pill, &RMF_OUT_UPDATE_REPLY, RCL_SERVER,
1099                              ouh->ouh_reply_size);
1100         rc = req_capsule_server_pack(pill);
1101         if (rc != 0) {
1102                 CERROR("%s: Can't pack response: rc = %d\n",
1103                        tgt_name(tsi->tsi_tgt), rc);
1104                 GOTO(out_free, rc = err_serious(-EPROTO));
1105         }
1106
1107         /* Prepare the update reply buffer */
1108         reply = req_capsule_server_get(pill, &RMF_OUT_UPDATE_REPLY);
1109         if (reply == NULL)
1110                 GOTO(out_free, rc = -EPROTO);
1111         reply->ourp_magic = UPDATE_REPLY_MAGIC;
1112         reply->ourp_count = updates;
1113         tti->tti_u.update.tti_update_reply = reply;
1114         tti->tti_mult_trans = !req_is_replay(tgt_ses_req(tsi));
1115
1116         /* Walk through updates in the request to execute them */
1117         for (i = 0; i < update_buf_count; i++) {
1118                 struct tgt_handler      *h;
1119                 struct dt_object        *dt_obj;
1120                 int                     update_count;
1121                 struct object_update_request *our;
1122                 int                     j;
1123
1124                 our = update_bufs[i];
1125                 update_count = our->ourq_count;
1126                 for (j = 0; j < update_count; j++) {
1127                         struct lu_object_conf conf;
1128
1129                         update = object_update_request_get(our, j, NULL);
1130                         if (update->ou_type == OUT_CREATE)
1131                                 conf.loc_flags = LOC_F_NEW;
1132                         else
1133                                 conf.loc_flags = 0;
1134
1135                         dt_obj = dt_locate_at(env, dt, &update->ou_fid,
1136                                 dt->dd_lu_dev.ld_site->ls_top_dev, &conf);
1137                         if (IS_ERR(dt_obj))
1138                                 GOTO(out, rc = PTR_ERR(dt_obj));
1139
1140                         if (dt->dd_record_fid_accessed) {
1141                                 struct lfsck_req_local *lrl = &tti->tti_lrl;
1142
1143                                 lfsck_pack_rfa(lrl,
1144                                                lu_object_fid(&dt_obj->do_lu),
1145                                                LEL_FID_ACCESSED,
1146                                                LFSCK_TYPE_LAYOUT);
1147                                 tgt_lfsck_in_notify_local(env, dt, lrl, NULL);
1148                         }
1149
1150                         tti->tti_u.update.tti_dt_object = dt_obj;
1151                         tti->tti_u.update.tti_update = update;
1152                         tti->tti_u.update.tti_update_reply_index = reply_index;
1153
1154                         h = out_handler_find(update->ou_type);
1155                         if (unlikely(h == NULL)) {
1156                                 CERROR("%s: unsupported opc: 0x%x\n",
1157                                        tgt_name(tsi->tsi_tgt), update->ou_type);
1158                                 GOTO(next, rc = -ENOTSUPP);
1159                         }
1160
1161                         /* Check resend case only for modifying RPC */
1162                         if (h->th_flags & IS_MUTABLE) {
1163                                 struct ptlrpc_request *req = tgt_ses_req(tsi);
1164
1165                                 if (out_check_resent(env, dt, dt_obj, req,
1166                                                      out_reconstruct, reply,
1167                                                      reply_index))
1168                                         GOTO(next, rc = 0);
1169
1170                                 if (dt->dd_rdonly)
1171                                         GOTO(next, rc = -EROFS);
1172                         }
1173
1174                         /* start transaction for modification RPC only */
1175                         if (h->th_flags & IS_MUTABLE && current_batchid == -1) {
1176                                 current_batchid = update->ou_batchid;
1177                                 rc = out_tx_start(env, dt, ta, tsi->tsi_exp);
1178                                 if (rc != 0)
1179                                         GOTO(next, rc);
1180
1181                                 if (update->ou_flags & UPDATE_FL_SYNC)
1182                                         ta->ta_handle->th_sync = 1;
1183                         }
1184
1185                         /* Stop the current update transaction, if the update
1186                          * has different batchid, or read-only update */
1187                         if (((current_batchid != update->ou_batchid) ||
1188                              !(h->th_flags & IS_MUTABLE)) &&
1189                              ta->ta_handle != NULL) {
1190                                 rc = out_tx_end(env, ta, rc);
1191                                 current_batchid = -1;
1192                                 if (rc != 0)
1193                                         GOTO(next, rc);
1194
1195                                 /* start a new transaction if needed */
1196                                 if (h->th_flags & IS_MUTABLE) {
1197                                         rc = out_tx_start(env, dt, ta,
1198                                                           tsi->tsi_exp);
1199                                         if (rc != 0)
1200                                                 GOTO(next, rc);
1201                                         if (update->ou_flags & UPDATE_FL_SYNC)
1202                                                 ta->ta_handle->th_sync = 1;
1203                                         current_batchid = update->ou_batchid;
1204                                 }
1205                         }
1206
1207                         rc = h->th_act(tsi);
1208 next:
1209                         reply_index++;
1210                         dt_object_put(env, dt_obj);
1211                         if (rc < 0)
1212                                 GOTO(out, rc);
1213                 }
1214         }
1215 out:
1216         if (current_batchid != -1) {
1217                 rc1 = out_tx_end(env, ta, rc);
1218                 if (rc == 0)
1219                         rc = rc1;
1220         }
1221
1222 out_free:
1223         if (update_bufs != NULL) {
1224                 if (oub != NULL) {
1225                         for (i = 0; i < update_buf_count; i++, oub++) {
1226                                 if (update_bufs[i] != NULL)
1227                                         OBD_FREE_LARGE(update_bufs[i],
1228                                                        oub->oub_size);
1229                         }
1230                 }
1231
1232                 OBD_FREE(update_bufs, sizeof(*update_bufs) * update_buf_count);
1233         }
1234
1235         if (desc != NULL)
1236                 ptlrpc_free_bulk(desc);
1237
1238         RETURN(rc);
1239 }
1240
1241 struct tgt_handler tgt_out_handlers[] = {
1242 TGT_UPDATE_HDL(IS_MUTABLE,      OUT_UPDATE,     out_handle),
1243 };
1244 EXPORT_SYMBOL(tgt_out_handlers);
1245