Whamcloud - gitweb
LU-6245 libcfs: remove wrappers for timer functions
[fs/lustre-release.git] / 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, 2016, 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         lustre_set_wire_obdo(NULL, obdo, obdo);
228
229 out_unlock:
230         dt_read_unlock(env, obj);
231
232         CDEBUG(D_INFO, "%s: insert attr get reply %p index %d: rc = %d\n",
233                tgt_name(tsi->tsi_tgt), tti->tti_u.update.tti_update_reply,
234                0, rc);
235
236         object_update_result_insert(tti->tti_u.update.tti_update_reply, obdo,
237                                     sizeof(*obdo), idx, rc);
238
239         RETURN(rc);
240 }
241
242 static int out_xattr_get(struct tgt_session_info *tsi)
243 {
244         const struct lu_env        *env = tsi->tsi_env;
245         struct tgt_thread_info     *tti = tgt_th_info(env);
246         struct object_update       *update = tti->tti_u.update.tti_update;
247         struct lu_buf              *lbuf = &tti->tti_buf;
248         struct object_update_reply *reply = tti->tti_u.update.tti_update_reply;
249         struct dt_object           *obj = tti->tti_u.update.tti_dt_object;
250         char                       *name;
251         struct object_update_result *update_result;
252         int                     idx = tti->tti_u.update.tti_update_reply_index;
253         int                        rc;
254
255         ENTRY;
256
257         if (!lu_object_exists(&obj->do_lu)) {
258                 set_bit(LU_OBJECT_HEARD_BANSHEE,
259                         &obj->do_lu.lo_header->loh_flags);
260                 RETURN(-ENOENT);
261         }
262
263         name = object_update_param_get(update, 0, NULL);
264         if (IS_ERR(name)) {
265                 CERROR("%s: empty name for xattr get: rc = %ld\n",
266                        tgt_name(tsi->tsi_tgt), PTR_ERR(name));
267                 RETURN(PTR_ERR(name));
268         }
269
270         update_result = object_update_result_get(reply, 0, NULL);
271         if (update_result == NULL) {
272                 CERROR("%s: empty name for xattr get: rc = %d\n",
273                        tgt_name(tsi->tsi_tgt), -EPROTO);
274                 RETURN(-EPROTO);
275         }
276
277         lbuf->lb_len = (int)tti->tti_u.update.tti_update->ou_result_size;
278         lbuf->lb_buf = update_result->our_data;
279         if (lbuf->lb_len == 0)
280                 lbuf->lb_buf = 0;
281         dt_read_lock(env, obj, MOR_TGT_CHILD);
282         rc = dt_xattr_get(env, obj, lbuf, name);
283         dt_read_unlock(env, obj);
284         if (rc < 0)
285                 lbuf->lb_len = 0;
286         CDEBUG(D_INFO, "%s: "DFID" get xattr %s len %d\n",
287                tgt_name(tsi->tsi_tgt), PFID(lu_object_fid(&obj->do_lu)),
288                name, (int)lbuf->lb_len);
289
290         GOTO(out, rc);
291
292 out:
293         object_update_result_insert(reply, lbuf->lb_buf, lbuf->lb_len, idx, rc);
294         RETURN(0);
295 }
296
297 static int out_index_lookup(struct tgt_session_info *tsi)
298 {
299         const struct lu_env     *env = tsi->tsi_env;
300         struct tgt_thread_info  *tti = tgt_th_info(env);
301         struct object_update    *update = tti->tti_u.update.tti_update;
302         struct dt_object        *obj = tti->tti_u.update.tti_dt_object;
303         char                    *name;
304         int                      rc;
305
306         ENTRY;
307
308         if (unlikely(update->ou_result_size < sizeof(tti->tti_fid1)))
309                 return -EPROTO;
310
311         if (!lu_object_exists(&obj->do_lu))
312                 RETURN(-ENOENT);
313
314         name = object_update_param_get(update, 0, NULL);
315         if (IS_ERR(name)) {
316                 CERROR("%s: empty name for lookup: rc = %ld\n",
317                        tgt_name(tsi->tsi_tgt), PTR_ERR(name));
318                 RETURN(PTR_ERR(name));
319         }
320
321         dt_read_lock(env, obj, MOR_TGT_CHILD);
322         if (!dt_try_as_dir(env, obj))
323                 GOTO(out_unlock, rc = -ENOTDIR);
324
325         rc = dt_lookup(env, obj, (struct dt_rec *)&tti->tti_fid1,
326                        (struct dt_key *)name);
327
328         if (rc < 0)
329                 GOTO(out_unlock, rc);
330
331         if (rc == 0)
332                 rc += 1;
333
334 out_unlock:
335         dt_read_unlock(env, obj);
336
337         CDEBUG(D_INFO, "lookup "DFID" %s get "DFID" rc %d\n",
338                PFID(lu_object_fid(&obj->do_lu)), name,
339                PFID(&tti->tti_fid1), rc);
340
341         CDEBUG(D_INFO, "%s: insert lookup reply %p index %d: rc = %d\n",
342                tgt_name(tsi->tsi_tgt), tti->tti_u.update.tti_update_reply,
343                0, rc);
344
345         object_update_result_insert(tti->tti_u.update.tti_update_reply,
346                             &tti->tti_fid1, sizeof(tti->tti_fid1),
347                             tti->tti_u.update.tti_update_reply_index, rc);
348         RETURN(rc);
349 }
350
351 static int out_xattr_set(struct tgt_session_info *tsi)
352 {
353         struct tgt_thread_info  *tti = tgt_th_info(tsi->tsi_env);
354         struct object_update    *update = tti->tti_u.update.tti_update;
355         struct dt_object        *obj = tti->tti_u.update.tti_dt_object;
356         struct lu_buf           *lbuf = &tti->tti_buf;
357         char                    *name;
358         char                    *buf;
359         __u32                   *tmp;
360         size_t                   buf_len = 0;
361         int                      flag;
362         size_t                   size = 0;
363         int                      rc;
364         ENTRY;
365
366         name = object_update_param_get(update, 0, NULL);
367         if (IS_ERR(name)) {
368                 CERROR("%s: empty name for xattr set: rc = %ld\n",
369                        tgt_name(tsi->tsi_tgt), PTR_ERR(name));
370                 RETURN(PTR_ERR(name));
371         }
372
373         /* If buffer == NULL (-ENODATA), then it might mean delete xattr */
374         buf = object_update_param_get(update, 1, &buf_len);
375         if (IS_ERR(buf) && PTR_ERR(buf) != -ENODATA)
376                 RETURN(PTR_ERR(buf));
377
378         lbuf->lb_buf = buf;
379         lbuf->lb_len = buf_len;
380
381         tmp = object_update_param_get(update, 2, &size);
382         if (IS_ERR(tmp) || size != sizeof(*tmp)) {
383                 CERROR("%s: emptry or wrong size %zu flag: rc = %ld\n",
384                        tgt_name(tsi->tsi_tgt), size, PTR_ERR(tmp));
385                 RETURN(PTR_ERR(tmp));
386         }
387
388         if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
389                 __swab32s(tmp);
390         flag = *tmp;
391
392         rc = out_tx_xattr_set(tsi->tsi_env, obj, lbuf, name, flag,
393                               &tti->tti_tea, tti->tti_tea.ta_handle,
394                               tti->tti_u.update.tti_update_reply,
395                               tti->tti_u.update.tti_update_reply_index);
396         RETURN(rc);
397 }
398
399 static int out_xattr_del(struct tgt_session_info *tsi)
400 {
401         struct tgt_thread_info  *tti = tgt_th_info(tsi->tsi_env);
402         struct object_update    *update = tti->tti_u.update.tti_update;
403         struct dt_object        *obj = tti->tti_u.update.tti_dt_object;
404         char                    *name;
405         int                      rc;
406         ENTRY;
407
408         name = object_update_param_get(update, 0, NULL);
409         if (IS_ERR(name)) {
410                 CERROR("%s: empty name for xattr set: rc = %ld\n",
411                        tgt_name(tsi->tsi_tgt), PTR_ERR(name));
412                 RETURN(PTR_ERR(name));
413         }
414
415         rc = out_tx_xattr_del(tsi->tsi_env, obj, name, &tti->tti_tea,
416                               tti->tti_tea.ta_handle,
417                               tti->tti_u.update.tti_update_reply,
418                               tti->tti_u.update.tti_update_reply_index);
419         RETURN(rc);
420 }
421
422 /**
423  * increase ref of the object
424  **/
425 static int out_ref_add(struct tgt_session_info *tsi)
426 {
427         struct tgt_thread_info  *tti = tgt_th_info(tsi->tsi_env);
428         struct dt_object        *obj = tti->tti_u.update.tti_dt_object;
429         int                      rc;
430
431         ENTRY;
432
433         rc = out_tx_ref_add(tsi->tsi_env, obj, &tti->tti_tea,
434                             tti->tti_tea.ta_handle,
435                             tti->tti_u.update.tti_update_reply,
436                             tti->tti_u.update.tti_update_reply_index);
437         RETURN(rc);
438 }
439
440 static int out_ref_del(struct tgt_session_info *tsi)
441 {
442         struct tgt_thread_info  *tti = tgt_th_info(tsi->tsi_env);
443         struct dt_object        *obj = tti->tti_u.update.tti_dt_object;
444         int                      rc;
445
446         ENTRY;
447
448         if (!lu_object_exists(&obj->do_lu))
449                 RETURN(-ENOENT);
450
451         rc = out_tx_ref_del(tsi->tsi_env, obj, &tti->tti_tea,
452                             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_index_insert(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         struct dt_insert_rec    *rec    = &tti->tti_rec;
464         struct lu_fid           *fid;
465         char                    *name;
466         __u32                   *ptype;
467         int                      rc     = 0;
468         size_t                   size;
469         ENTRY;
470
471         name = object_update_param_get(update, 0, NULL);
472         if (IS_ERR(name)) {
473                 CERROR("%s: empty name for index insert: rc = %ld\n",
474                        tgt_name(tsi->tsi_tgt), PTR_ERR(name));
475                 RETURN(PTR_ERR(name));
476         }
477
478         fid = object_update_param_get(update, 1, &size);
479         if (IS_ERR(fid) || size != sizeof(*fid)) {
480                 CERROR("%s: invalid fid: rc = %ld\n",
481                        tgt_name(tsi->tsi_tgt), PTR_ERR(fid));
482                 RETURN(PTR_ERR(fid));
483         }
484
485         if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
486                 lustre_swab_lu_fid(fid);
487
488         if (!fid_is_sane(fid)) {
489                 CERROR("%s: invalid FID "DFID": rc = %d\n",
490                        tgt_name(tsi->tsi_tgt), PFID(fid), -EPROTO);
491                 RETURN(-EPROTO);
492         }
493
494         ptype = object_update_param_get(update, 2, &size);
495         if (IS_ERR(ptype) || size != sizeof(*ptype)) {
496                 CERROR("%s: invalid type for index insert: rc = %ld\n",
497                        tgt_name(tsi->tsi_tgt), PTR_ERR(ptype));
498                 RETURN(PTR_ERR(ptype));
499         }
500
501         if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
502                 __swab32s(ptype);
503
504         rec->rec_fid = fid;
505         rec->rec_type = *ptype;
506
507         rc = out_tx_index_insert(tsi->tsi_env, obj, (const struct dt_rec *)rec,
508                                  (const struct dt_key *)name, &tti->tti_tea,
509                                  tti->tti_tea.ta_handle,
510                                  tti->tti_u.update.tti_update_reply,
511                                  tti->tti_u.update.tti_update_reply_index);
512         RETURN(rc);
513 }
514
515 static int out_index_delete(struct tgt_session_info *tsi)
516 {
517         struct tgt_thread_info  *tti = tgt_th_info(tsi->tsi_env);
518         struct object_update    *update = tti->tti_u.update.tti_update;
519         struct dt_object        *obj = tti->tti_u.update.tti_dt_object;
520         char                    *name;
521         int                      rc = 0;
522
523         if (!lu_object_exists(&obj->do_lu))
524                 RETURN(-ENOENT);
525
526         name = object_update_param_get(update, 0, NULL);
527         if (IS_ERR(name)) {
528                 CERROR("%s: empty name for index delete: rc = %ld\n",
529                        tgt_name(tsi->tsi_tgt), PTR_ERR(name));
530                 RETURN(PTR_ERR(name));
531         }
532
533         rc = out_tx_index_delete(tsi->tsi_env, obj, (const struct dt_key *)name,
534                                  &tti->tti_tea, tti->tti_tea.ta_handle,
535                                  tti->tti_u.update.tti_update_reply,
536                                  tti->tti_u.update.tti_update_reply_index);
537         RETURN(rc);
538 }
539
540 static int out_destroy(struct tgt_session_info *tsi)
541 {
542         struct tgt_thread_info  *tti = tgt_th_info(tsi->tsi_env);
543         struct object_update    *update = tti->tti_u.update.tti_update;
544         struct dt_object        *obj = tti->tti_u.update.tti_dt_object;
545         struct lu_fid           *fid;
546         int                      rc;
547         ENTRY;
548
549         fid = &update->ou_fid;
550         if (!fid_is_sane(fid)) {
551                 CERROR("%s: invalid FID "DFID": rc = %d\n",
552                        tgt_name(tsi->tsi_tgt), PFID(fid), -EPROTO);
553                 RETURN(-EPROTO);
554         }
555
556         if (!lu_object_exists(&obj->do_lu))
557                 RETURN(-ENOENT);
558
559         rc = out_tx_destroy(tsi->tsi_env, obj, &tti->tti_tea,
560                             tti->tti_tea.ta_handle,
561                             tti->tti_u.update.tti_update_reply,
562                             tti->tti_u.update.tti_update_reply_index);
563
564         RETURN(rc);
565 }
566
567 static int out_write(struct tgt_session_info *tsi)
568 {
569         struct tgt_thread_info  *tti = tgt_th_info(tsi->tsi_env);
570         struct object_update    *update = tti->tti_u.update.tti_update;
571         struct dt_object        *obj = tti->tti_u.update.tti_dt_object;
572         struct lu_buf           *lbuf = &tti->tti_buf;
573         char                    *buf;
574         __u64                   *tmp;
575         size_t                  size = 0;
576         size_t                  buf_len = 0;
577         loff_t                  pos;
578         int                      rc;
579         ENTRY;
580
581         buf = object_update_param_get(update, 0, &buf_len);
582         if (IS_ERR(buf) || buf_len == 0) {
583                 CERROR("%s: empty buf for xattr set: rc = %ld\n",
584                        tgt_name(tsi->tsi_tgt), PTR_ERR(buf));
585                 RETURN(PTR_ERR(buf));
586         }
587         lbuf->lb_buf = buf;
588         lbuf->lb_len = buf_len;
589
590         tmp = object_update_param_get(update, 1, &size);
591         if (IS_ERR(tmp) || size != sizeof(*tmp)) {
592                 CERROR("%s: empty or wrong size %zu pos: rc = %ld\n",
593                        tgt_name(tsi->tsi_tgt), size, PTR_ERR(tmp));
594                 RETURN(PTR_ERR(tmp));
595         }
596
597         if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
598                 __swab64s(tmp);
599         pos = *tmp;
600
601         rc = out_tx_write(tsi->tsi_env, obj, lbuf, pos,
602                           &tti->tti_tea, tti->tti_tea.ta_handle,
603                           tti->tti_u.update.tti_update_reply,
604                           tti->tti_u.update.tti_update_reply_index);
605         RETURN(rc);
606 }
607
608 static int out_read(struct tgt_session_info *tsi)
609 {
610         const struct lu_env     *env = tsi->tsi_env;
611         struct tgt_thread_info  *tti = tgt_th_info(env);
612         struct object_update    *update = tti->tti_u.update.tti_update;
613         struct dt_object        *obj = tti->tti_u.update.tti_dt_object;
614         struct object_update_reply *reply = tti->tti_u.update.tti_update_reply;
615         int index = tti->tti_u.update.tti_update_reply_index;
616         struct lu_rdbuf *rdbuf;
617         struct object_update_result *update_result;
618         struct out_read_reply   *orr;
619         void *tmp;
620         size_t size;
621         size_t total_size = 0;
622         __u64 pos;
623         unsigned int i;
624         unsigned int nbufs;
625         int rc = 0;
626         ENTRY;
627
628         update_result = object_update_result_get(reply, index, NULL);
629         LASSERT(update_result != NULL);
630         update_result->our_datalen = sizeof(*orr);
631
632         if (!lu_object_exists(&obj->do_lu))
633                 GOTO(out, rc = -ENOENT);
634
635         tmp = object_update_param_get(update, 0, NULL);
636         if (IS_ERR(tmp)) {
637                 CERROR("%s: empty size for read: rc = %ld\n",
638                        tgt_name(tsi->tsi_tgt), PTR_ERR(tmp));
639                 GOTO(out, rc = PTR_ERR(tmp));
640         }
641         size = le64_to_cpu(*(size_t *)(tmp));
642
643         tmp = object_update_param_get(update, 1, NULL);
644         if (IS_ERR(tmp)) {
645                 CERROR("%s: empty pos for read: rc = %ld\n",
646                        tgt_name(tsi->tsi_tgt), PTR_ERR(tmp));
647                 GOTO(out, rc = PTR_ERR(tmp));
648         }
649         pos = le64_to_cpu(*(__u64 *)(tmp));
650
651         /* Put the offset into the begining of the buffer in reply */
652         orr = (struct out_read_reply *)update_result->our_data;
653
654         nbufs = (size + OUT_BULK_BUFFER_SIZE - 1) / OUT_BULK_BUFFER_SIZE;
655         OBD_ALLOC(rdbuf, sizeof(struct lu_rdbuf) +
656                          nbufs * sizeof(rdbuf->rb_bufs[0]));
657         if (rdbuf == NULL)
658                 GOTO(out, rc = -ENOMEM);
659
660         rdbuf->rb_nbufs = 0;
661         total_size = 0;
662         for (i = 0; i < nbufs; i++) {
663                 __u32 read_size;
664
665                 read_size = size > OUT_BULK_BUFFER_SIZE ?
666                             OUT_BULK_BUFFER_SIZE : size;
667                 OBD_ALLOC(rdbuf->rb_bufs[i].lb_buf, read_size);
668                 if (rdbuf->rb_bufs[i].lb_buf == NULL)
669                         GOTO(out_free, rc = -ENOMEM);
670
671                 rdbuf->rb_bufs[i].lb_len = read_size;
672                 dt_read_lock(env, obj, MOR_TGT_CHILD);
673                 rc = dt_read(env, obj, &rdbuf->rb_bufs[i], &pos);
674                 dt_read_unlock(env, obj);
675
676                 total_size += rc < 0 ? 0 : rc;
677                 if (rc <= 0)
678                         break;
679
680                 rdbuf->rb_nbufs++;
681                 size -= read_size;
682         }
683
684         /* send pages to client */
685         rc = tgt_send_buffer(tsi, rdbuf);
686         if (rc < 0)
687                 GOTO(out_free, rc);
688
689         orr->orr_size = total_size;
690         orr->orr_offset = pos;
691
692         orr_cpu_to_le(orr, orr);
693         update_result->our_datalen += orr->orr_size;
694 out_free:
695         for (i = 0; i < nbufs; i++) {
696                 if (rdbuf->rb_bufs[i].lb_buf != NULL) {
697                         OBD_FREE(rdbuf->rb_bufs[i].lb_buf,
698                                  rdbuf->rb_bufs[i].lb_len);
699                 }
700         }
701         OBD_FREE(rdbuf, sizeof(struct lu_rdbuf) +
702                         nbufs * sizeof(rdbuf->rb_bufs[0]));
703 out:
704         /* Insert read buffer */
705         update_result->our_rc = ptlrpc_status_hton(rc);
706         reply->ourp_lens[index] = cfs_size_round(update_result->our_datalen +
707                                                  sizeof(*update_result));
708         RETURN(rc);
709 }
710
711 static int out_noop(struct tgt_session_info *tsi)
712 {
713         return 0;
714 }
715
716 #define DEF_OUT_HNDL(opc, name, flags, fn)     \
717 [opc - OUT_CREATE] = {                                  \
718         .th_name    = name,                             \
719         .th_fail_id = 0,                                \
720         .th_opc     = opc,                              \
721         .th_flags   = flags,                            \
722         .th_act     = fn,                               \
723         .th_fmt     = NULL,                             \
724         .th_version = 0,                                \
725 }
726
727 static struct tgt_handler out_update_ops[] = {
728         DEF_OUT_HNDL(OUT_CREATE, "out_create", MUTABOR | HABEO_REFERO,
729                      out_create),
730         DEF_OUT_HNDL(OUT_DESTROY, "out_create", MUTABOR | HABEO_REFERO,
731                      out_destroy),
732         DEF_OUT_HNDL(OUT_REF_ADD, "out_ref_add", MUTABOR | HABEO_REFERO,
733                      out_ref_add),
734         DEF_OUT_HNDL(OUT_REF_DEL, "out_ref_del", MUTABOR | HABEO_REFERO,
735                      out_ref_del),
736         DEF_OUT_HNDL(OUT_ATTR_SET, "out_attr_set",  MUTABOR | HABEO_REFERO,
737                      out_attr_set),
738         DEF_OUT_HNDL(OUT_ATTR_GET, "out_attr_get",  HABEO_REFERO,
739                      out_attr_get),
740         DEF_OUT_HNDL(OUT_XATTR_SET, "out_xattr_set", MUTABOR | HABEO_REFERO,
741                      out_xattr_set),
742         DEF_OUT_HNDL(OUT_XATTR_DEL, "out_xattr_del", MUTABOR | HABEO_REFERO,
743                      out_xattr_del),
744         DEF_OUT_HNDL(OUT_XATTR_GET, "out_xattr_get", HABEO_REFERO,
745                      out_xattr_get),
746         DEF_OUT_HNDL(OUT_INDEX_LOOKUP, "out_index_lookup", HABEO_REFERO,
747                      out_index_lookup),
748         DEF_OUT_HNDL(OUT_INDEX_INSERT, "out_index_insert",
749                      MUTABOR | HABEO_REFERO, out_index_insert),
750         DEF_OUT_HNDL(OUT_INDEX_DELETE, "out_index_delete",
751                      MUTABOR | HABEO_REFERO, out_index_delete),
752         DEF_OUT_HNDL(OUT_WRITE, "out_write", MUTABOR | HABEO_REFERO, out_write),
753         DEF_OUT_HNDL(OUT_READ, "out_read", HABEO_REFERO, out_read),
754         DEF_OUT_HNDL(OUT_NOOP, "out_noop", HABEO_REFERO, out_noop),
755 };
756
757 static struct tgt_handler *out_handler_find(__u32 opc)
758 {
759         struct tgt_handler *h;
760
761         h = NULL;
762         if (OUT_CREATE <= opc && opc < OUT_LAST) {
763                 h = &out_update_ops[opc - OUT_CREATE];
764                 LASSERTF(h->th_opc == opc, "opcode mismatch %d != %d\n",
765                          h->th_opc, opc);
766         } else {
767                 h = NULL; /* unsupported opc */
768         }
769         return h;
770 }
771
772 static int out_tx_start(const struct lu_env *env, struct dt_device *dt,
773                         struct thandle_exec_args *ta, struct obd_export *exp)
774 {
775         ta->ta_argno = 0;
776         ta->ta_handle = dt_trans_create(env, dt);
777         if (IS_ERR(ta->ta_handle)) {
778                 int rc;
779
780                 rc = PTR_ERR(ta->ta_handle);
781                 ta->ta_handle = NULL;
782                 CERROR("%s: start handle error: rc = %d\n", dt_obd_name(dt),
783                        rc);
784                 return rc;
785         }
786         if (exp->exp_need_sync)
787                 ta->ta_handle->th_sync = 1;
788
789         return 0;
790 }
791
792 static int out_trans_start(const struct lu_env *env,
793                            struct thandle_exec_args *ta)
794 {
795         return dt_trans_start(env, ta->ta_handle->th_dev, ta->ta_handle);
796 }
797
798 static int out_trans_stop(const struct lu_env *env,
799                           struct thandle_exec_args *ta, int err)
800 {
801         int i;
802         int rc;
803
804         ta->ta_handle->th_result = err;
805         rc = dt_trans_stop(env, ta->ta_handle->th_dev, ta->ta_handle);
806         for (i = 0; i < ta->ta_argno; i++) {
807                 if (ta->ta_args[i]->object != NULL) {
808                         struct dt_object *obj = ta->ta_args[i]->object;
809
810                         /* If the object is being created during this
811                          * transaction, we need to remove them from the
812                          * cache immediately, because a few layers are
813                          * missing in OUT handler, i.e. the object might
814                          * not be initialized in all layers */
815                         if (ta->ta_args[i]->exec_fn == out_tx_create_exec)
816                                 set_bit(LU_OBJECT_HEARD_BANSHEE,
817                                         &obj->do_lu.lo_header->loh_flags);
818                         lu_object_put(env, &ta->ta_args[i]->object->do_lu);
819                         ta->ta_args[i]->object = NULL;
820                 }
821         }
822         ta->ta_handle = NULL;
823         ta->ta_argno = 0;
824
825         return rc;
826 }
827
828 static int out_tx_end(const struct lu_env *env, struct thandle_exec_args *ta,
829                       int declare_ret)
830 {
831         struct tgt_session_info *tsi = tgt_ses_info(env);
832         int                     i;
833         int                     rc;
834         int                     rc1;
835         ENTRY;
836
837         if (ta->ta_handle == NULL)
838                 RETURN(0);
839
840         if (declare_ret != 0 || ta->ta_argno == 0)
841                 GOTO(stop, rc = declare_ret);
842
843         LASSERT(ta->ta_handle->th_dev != NULL);
844         rc = out_trans_start(env, ta);
845         if (unlikely(rc != 0))
846                 GOTO(stop, rc);
847
848         for (i = 0; i < ta->ta_argno; i++) {
849                 rc = ta->ta_args[i]->exec_fn(env, ta->ta_handle,
850                                              ta->ta_args[i]);
851                 if (unlikely(rc != 0)) {
852                         CDEBUG(D_INFO, "error during execution of #%u from"
853                                " %s:%d: rc = %d\n", i, ta->ta_args[i]->file,
854                                ta->ta_args[i]->line, rc);
855                         while (--i >= 0) {
856                                 if (ta->ta_args[i]->undo_fn != NULL)
857                                         ta->ta_args[i]->undo_fn(env,
858                                                                ta->ta_handle,
859                                                                ta->ta_args[i]);
860                                 else
861                                         CERROR("%s: undo for %s:%d: rc = %d\n",
862                                              dt_obd_name(ta->ta_handle->th_dev),
863                                                ta->ta_args[i]->file,
864                                                ta->ta_args[i]->line, -ENOTSUPP);
865                         }
866                         break;
867                 }
868                 CDEBUG(D_INFO, "%s: executed %u/%u: rc = %d\n",
869                        dt_obd_name(ta->ta_handle->th_dev), i, ta->ta_argno, rc);
870         }
871
872         /* Only fail for real updates, XXX right now llog updates will be
873         * ignore, whose updates count is usually 1, so failover test
874         * case will spot this FAIL_UPDATE_NET_REP precisely, and it will
875         * be removed after async update patch is landed. */
876         if (ta->ta_argno > 1)
877                 tsi->tsi_reply_fail_id = OBD_FAIL_OUT_UPDATE_NET_REP;
878
879 stop:
880         rc1 = out_trans_stop(env, ta, rc);
881         if (rc == 0)
882                 rc = rc1;
883
884         ta->ta_handle = NULL;
885         ta->ta_argno = 0;
886
887         RETURN(rc);
888 }
889
890 /**
891  * Object updates between Targets. Because all the updates has been
892  * dis-assemblied into object updates at sender side, so OUT will
893  * call OSD API directly to execute these updates.
894  *
895  * In DNE phase I all of the updates in the request need to be executed
896  * in one transaction, and the transaction has to be synchronously.
897  *
898  * Please refer to lustre/include/lustre/lustre_idl.h for req/reply
899  * format.
900  */
901 int out_handle(struct tgt_session_info *tsi)
902 {
903         const struct lu_env             *env = tsi->tsi_env;
904         struct tgt_thread_info          *tti = tgt_th_info(env);
905         struct thandle_exec_args        *ta = &tti->tti_tea;
906         struct req_capsule              *pill = tsi->tsi_pill;
907         struct dt_device                *dt = tsi->tsi_tgt->lut_bottom;
908         struct out_update_header        *ouh;
909         struct out_update_buffer        *oub = NULL;
910         struct object_update            *update;
911         struct object_update_reply      *reply;
912         struct ptlrpc_bulk_desc         *desc = NULL;
913         struct l_wait_info              lwi;
914         void                            **update_bufs;
915         int                             current_batchid = -1;
916         __u32                           update_buf_count;
917         unsigned int                    i;
918         unsigned int                    reply_index = 0;
919         int                             rc = 0;
920         int                             rc1 = 0;
921         int                             ouh_size, reply_size;
922         int                             updates;
923         ENTRY;
924
925         req_capsule_set(pill, &RQF_OUT_UPDATE);
926         ouh_size = req_capsule_get_size(pill, &RMF_OUT_UPDATE_HEADER,
927                                         RCL_CLIENT);
928         if (ouh_size <= 0)
929                 RETURN(err_serious(-EPROTO));
930
931         ouh = req_capsule_client_get(pill, &RMF_OUT_UPDATE_HEADER);
932         if (ouh == NULL)
933                 RETURN(err_serious(-EPROTO));
934
935         if (ouh->ouh_magic != OUT_UPDATE_HEADER_MAGIC) {
936                 CERROR("%s: invalid update buffer magic %x expect %x: "
937                        "rc = %d\n", tgt_name(tsi->tsi_tgt), ouh->ouh_magic,
938                        UPDATE_REQUEST_MAGIC, -EPROTO);
939                 RETURN(err_serious(-EPROTO));
940         }
941
942         update_buf_count = ouh->ouh_count;
943         if (update_buf_count == 0)
944                 RETURN(err_serious(-EPROTO));
945
946         OBD_ALLOC(update_bufs, sizeof(*update_bufs) * update_buf_count);
947         if (update_bufs == NULL)
948                 RETURN(err_serious(-ENOMEM));
949
950         if (ouh->ouh_inline_length > 0) {
951                 update_bufs[0] = ouh->ouh_inline_data;
952         } else {
953                 struct out_update_buffer *tmp;
954
955                 oub = req_capsule_client_get(pill, &RMF_OUT_UPDATE_BUF);
956                 if (oub == NULL)
957                         GOTO(out_free, rc = err_serious(-EPROTO));
958
959                 desc = ptlrpc_prep_bulk_exp(pill->rc_req, update_buf_count,
960                                             PTLRPC_BULK_OPS_COUNT,
961                                             PTLRPC_BULK_GET_SINK |
962                                             PTLRPC_BULK_BUF_KVEC,
963                                             MDS_BULK_PORTAL,
964                                             &ptlrpc_bulk_kvec_ops);
965                 if (desc == NULL)
966                         GOTO(out_free, rc = err_serious(-ENOMEM));
967
968                 tmp = oub;
969                 for (i = 0; i < update_buf_count; i++, tmp++) {
970                         if (tmp->oub_size >= OUT_MAXREQSIZE)
971                                 GOTO(out_free, rc = err_serious(-EPROTO));
972
973                         OBD_ALLOC(update_bufs[i], tmp->oub_size);
974                         if (update_bufs[i] == NULL)
975                                 GOTO(out_free, rc = err_serious(-ENOMEM));
976
977                         desc->bd_frag_ops->add_iov_frag(desc, update_bufs[i],
978                                                         tmp->oub_size);
979                 }
980
981                 pill->rc_req->rq_bulk_write = 1;
982                 rc = sptlrpc_svc_prep_bulk(pill->rc_req, desc);
983                 if (rc != 0)
984                         GOTO(out_free, rc = err_serious(rc));
985
986                 rc = target_bulk_io(pill->rc_req->rq_export, desc, &lwi);
987                 if (rc < 0)
988                         GOTO(out_free, rc = err_serious(rc));
989         }
990         /* validate the request and calculate the total update count and
991          * set it to reply */
992         reply_size = 0;
993         updates = 0;
994         for (i = 0; i < update_buf_count; i++) {
995                 struct object_update_request    *our;
996                 int                              j;
997
998                 our = update_bufs[i];
999                 if (ptlrpc_req_need_swab(pill->rc_req))
1000                         lustre_swab_object_update_request(our);
1001
1002                 if (our->ourq_magic != UPDATE_REQUEST_MAGIC) {
1003                         CERROR("%s: invalid update buffer magic %x"
1004                                " expect %x: rc = %d\n",
1005                                tgt_name(tsi->tsi_tgt), our->ourq_magic,
1006                                UPDATE_REQUEST_MAGIC, -EPROTO);
1007                         GOTO(out_free, rc = err_serious(-EPROTO));
1008                 }
1009                 updates += our->ourq_count;
1010
1011                 /* need to calculate reply size */
1012                 for (j = 0; j < our->ourq_count; j++) {
1013                         update = object_update_request_get(our, j, NULL);
1014                         if (update == NULL)
1015                                 GOTO(out, rc = err_serious(-EPROTO));
1016                         if (ptlrpc_req_need_swab(pill->rc_req))
1017                                 lustre_swab_object_update(update);
1018
1019                         if (!fid_is_sane(&update->ou_fid)) {
1020                                 CERROR("%s: invalid FID "DFID": rc = %d\n",
1021                                        tgt_name(tsi->tsi_tgt),
1022                                        PFID(&update->ou_fid), -EPROTO);
1023                                 GOTO(out, rc = err_serious(-EPROTO));
1024                         }
1025
1026                         /* XXX: what ou_result_size can be considered safe? */
1027
1028                         reply_size += sizeof(reply->ourp_lens[0]);
1029                         reply_size += sizeof(struct object_update_result);
1030                         reply_size += update->ou_result_size;
1031                 }
1032         }
1033         reply_size += sizeof(*reply);
1034
1035         if (unlikely(reply_size > ouh->ouh_reply_size)) {
1036                 CERROR("%s: too small reply buf %u for %u, need %u at least\n",
1037                        tgt_name(tsi->tsi_tgt), ouh->ouh_reply_size,
1038                        updates, reply_size);
1039                 GOTO(out_free, rc = err_serious(-EPROTO));
1040         }
1041
1042         req_capsule_set_size(pill, &RMF_OUT_UPDATE_REPLY, RCL_SERVER,
1043                              ouh->ouh_reply_size);
1044         rc = req_capsule_server_pack(pill);
1045         if (rc != 0) {
1046                 CERROR("%s: Can't pack response: rc = %d\n",
1047                        tgt_name(tsi->tsi_tgt), rc);
1048                 GOTO(out_free, rc = err_serious(-EPROTO));
1049         }
1050
1051         /* Prepare the update reply buffer */
1052         reply = req_capsule_server_get(pill, &RMF_OUT_UPDATE_REPLY);
1053         if (reply == NULL)
1054                 GOTO(out_free, rc = -EPROTO);
1055         reply->ourp_magic = UPDATE_REPLY_MAGIC;
1056         reply->ourp_count = updates;
1057         tti->tti_u.update.tti_update_reply = reply;
1058         tti->tti_mult_trans = !req_is_replay(tgt_ses_req(tsi));
1059
1060         /* Walk through updates in the request to execute them */
1061         for (i = 0; i < update_buf_count; i++) {
1062                 struct tgt_handler      *h;
1063                 struct dt_object        *dt_obj;
1064                 int                     update_count;
1065                 struct object_update_request *our;
1066                 int                     j;
1067
1068                 our = update_bufs[i];
1069                 update_count = our->ourq_count;
1070                 for (j = 0; j < update_count; j++) {
1071                         struct lu_object_conf conf;
1072
1073                         update = object_update_request_get(our, j, NULL);
1074                         if (update->ou_type == OUT_CREATE)
1075                                 conf.loc_flags = LOC_F_NEW;
1076                         else
1077                                 conf.loc_flags = 0;
1078
1079                         dt_obj = dt_locate_at(env, dt, &update->ou_fid,
1080                                 dt->dd_lu_dev.ld_site->ls_top_dev, &conf);
1081                         if (IS_ERR(dt_obj))
1082                                 GOTO(out, rc = PTR_ERR(dt_obj));
1083
1084                         if (dt->dd_record_fid_accessed) {
1085                                 lfsck_pack_rfa(&tti->tti_lr,
1086                                                lu_object_fid(&dt_obj->do_lu),
1087                                                LE_FID_ACCESSED,
1088                                                LFSCK_TYPE_LAYOUT);
1089                                 tgt_lfsck_in_notify(env, dt, &tti->tti_lr,
1090                                                     NULL);
1091                         }
1092
1093                         tti->tti_u.update.tti_dt_object = dt_obj;
1094                         tti->tti_u.update.tti_update = update;
1095                         tti->tti_u.update.tti_update_reply_index = reply_index;
1096
1097                         h = out_handler_find(update->ou_type);
1098                         if (unlikely(h == NULL)) {
1099                                 CERROR("%s: unsupported opc: 0x%x\n",
1100                                        tgt_name(tsi->tsi_tgt), update->ou_type);
1101                                 GOTO(next, rc = -ENOTSUPP);
1102                         }
1103
1104                         /* Check resend case only for modifying RPC */
1105                         if (h->th_flags & MUTABOR) {
1106                                 struct ptlrpc_request *req = tgt_ses_req(tsi);
1107
1108                                 if (out_check_resent(env, dt, dt_obj, req,
1109                                                      out_reconstruct, reply,
1110                                                      reply_index))
1111                                         GOTO(next, rc = 0);
1112                         }
1113
1114                         /* start transaction for modification RPC only */
1115                         if (h->th_flags & MUTABOR && current_batchid == -1) {
1116                                 current_batchid = update->ou_batchid;
1117                                 rc = out_tx_start(env, dt, ta, tsi->tsi_exp);
1118                                 if (rc != 0)
1119                                         GOTO(next, rc);
1120
1121                                 if (update->ou_flags & UPDATE_FL_SYNC)
1122                                         ta->ta_handle->th_sync = 1;
1123                         }
1124
1125                         /* Stop the current update transaction, if the update
1126                          * has different batchid, or read-only update */
1127                         if (((current_batchid != update->ou_batchid) ||
1128                              !(h->th_flags & MUTABOR)) &&
1129                              ta->ta_handle != NULL) {
1130                                 rc = out_tx_end(env, ta, rc);
1131                                 current_batchid = -1;
1132                                 if (rc != 0)
1133                                         GOTO(next, rc);
1134
1135                                 /* start a new transaction if needed */
1136                                 if (h->th_flags & MUTABOR) {
1137                                         rc = out_tx_start(env, dt, ta,
1138                                                           tsi->tsi_exp);
1139                                         if (rc != 0)
1140                                                 GOTO(next, rc);
1141                                         if (update->ou_flags & UPDATE_FL_SYNC)
1142                                                 ta->ta_handle->th_sync = 1;
1143                                         current_batchid = update->ou_batchid;
1144                                 }
1145                         }
1146
1147                         rc = h->th_act(tsi);
1148 next:
1149                         reply_index++;
1150                         lu_object_put(env, &dt_obj->do_lu);
1151                         if (rc < 0)
1152                                 GOTO(out, rc);
1153                 }
1154         }
1155 out:
1156         if (current_batchid != -1) {
1157                 rc1 = out_tx_end(env, ta, rc);
1158                 if (rc == 0)
1159                         rc = rc1;
1160         }
1161
1162 out_free:
1163         if (update_bufs != NULL) {
1164                 if (oub != NULL) {
1165                         for (i = 0; i < update_buf_count; i++, oub++) {
1166                                 if (update_bufs[i] != NULL)
1167                                         OBD_FREE(update_bufs[i], oub->oub_size);
1168                         }
1169                 }
1170
1171                 OBD_FREE(update_bufs, sizeof(*update_bufs) * update_buf_count);
1172         }
1173
1174         if (desc != NULL)
1175                 ptlrpc_free_bulk(desc);
1176
1177         RETURN(rc);
1178 }
1179
1180 struct tgt_handler tgt_out_handlers[] = {
1181 TGT_UPDATE_HDL(MUTABOR, OUT_UPDATE,     out_handle),
1182 };
1183 EXPORT_SYMBOL(tgt_out_handlers);
1184