Whamcloud - gitweb
03dbcca3e8623f1f2a0ea0ed08e63560b54f9250
[fs/lustre-release.git] / lustre / ptlrpc / pack_generic.c
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  * GPL HEADER START
5  *
6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 only,
10  * as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * General Public License version 2 for more details (a copy is included
16  * in the LICENSE file that accompanied this code).
17  *
18  * You should have received a copy of the GNU General Public License
19  * version 2 along with this program; If not, see
20  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
21  *
22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
23  * CA 95054 USA or visit www.sun.com if you need additional information or
24  * have any questions.
25  *
26  * GPL HEADER END
27  */
28 /*
29  * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
30  * Use is subject to license terms.
31  */
32 /*
33  * This file is part of Lustre, http://www.lustre.org/
34  * Lustre is a trademark of Sun Microsystems, Inc.
35  *
36  * lustre/ptlrpc/pack_generic.c
37  *
38  * (Un)packing of OST requests
39  *
40  * Author: Peter J. Braam <braam@clusterfs.com>
41  * Author: Phil Schwan <phil@clusterfs.com>
42  * Author: Eric Barton <eeb@clusterfs.com>
43  */
44
45 #define DEBUG_SUBSYSTEM S_RPC
46 #ifndef __KERNEL__
47 # include <liblustre.h>
48 #endif
49
50 #include <libcfs/libcfs.h>
51
52 #include <obd_support.h>
53 #include <obd_class.h>
54 #include <lustre_net.h>
55 #include <obd_cksum.h>
56 #include <lustre/ll_fiemap.h>
57
58 static inline int lustre_msg_hdr_size_v2(int count)
59 {
60         return cfs_size_round(offsetof(struct lustre_msg_v2,
61                                        lm_buflens[count]));
62 }
63
64 int lustre_msg_hdr_size(__u32 magic, int count)
65 {
66         switch (magic) {
67         case LUSTRE_MSG_MAGIC_V2:
68                 return lustre_msg_hdr_size_v2(count);
69         default:
70                 LASSERTF(0, "incorrect message magic: %08x\n", magic);
71                 return -EINVAL;
72         }
73 }
74 EXPORT_SYMBOL(lustre_msg_hdr_size);
75
76 void ptlrpc_buf_set_swabbed(struct ptlrpc_request *req, const int inout,
77                             int index)
78 {
79         if (inout)
80                 lustre_set_req_swabbed(req, index);
81         else
82                 lustre_set_rep_swabbed(req, index);
83 }
84
85 int ptlrpc_buf_need_swab(struct ptlrpc_request *req, const int inout,
86                          int index)
87 {
88         if (inout)
89                 return (ptlrpc_req_need_swab(req) &&
90                         !lustre_req_swabbed(req, index));
91         else
92                 return (ptlrpc_rep_need_swab(req) &&
93                         !lustre_rep_swabbed(req, index));
94 }
95
96 static inline int lustre_msg_check_version_v2(struct lustre_msg_v2 *msg,
97                                               __u32 version)
98 {
99         __u32 ver = lustre_msg_get_version(msg);
100         return (ver & LUSTRE_VERSION_MASK) != version;
101 }
102
103 int lustre_msg_check_version(struct lustre_msg *msg, __u32 version)
104 {
105         switch (msg->lm_magic) {
106         case LUSTRE_MSG_MAGIC_V1:
107                 CERROR("msg v1 not supported - please upgrade you system\n");
108                 return -EINVAL;
109         case LUSTRE_MSG_MAGIC_V2:
110                 return lustre_msg_check_version_v2(msg, version);
111         default:
112                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
113                 return 0;
114         }
115 }
116
117 /* early reply size */
118 int lustre_msg_early_size()
119 {
120         static int size = 0;
121         if (!size)
122                 size = lustre_msg_size(LUSTRE_MSG_MAGIC_V2, 1, NULL);
123         return size;
124 }
125 EXPORT_SYMBOL(lustre_msg_early_size);
126
127 int lustre_msg_size_v2(int count, __u32 *lengths)
128 {
129         int size;
130         int i;
131
132         size = lustre_msg_hdr_size_v2(count);
133         for (i = 0; i < count; i++)
134                 size += cfs_size_round(lengths[i]);
135
136         return size;
137 }
138 EXPORT_SYMBOL(lustre_msg_size_v2);
139
140 /* This returns the size of the buffer that is required to hold a lustre_msg
141  * with the given sub-buffer lengths.
142  * NOTE: this should only be used for NEW requests, and should always be
143  *       in the form of a v2 request.  If this is a connection to a v1
144  *       target then the first buffer will be stripped because the ptlrpc
145  *       data is part of the lustre_msg_v1 header. b=14043 */
146 int lustre_msg_size(__u32 magic, int count, __u32 *lens)
147 {
148         __u32 size[] = { sizeof(struct ptlrpc_body) };
149
150         if (!lens) {
151                 LASSERT(count == 1);
152                 lens = size;
153         }
154
155         LASSERT(count > 0);
156         LASSERT(lens[MSG_PTLRPC_BODY_OFF] == sizeof(struct ptlrpc_body));
157
158         switch (magic) {
159         case LUSTRE_MSG_MAGIC_V2:
160                 return lustre_msg_size_v2(count, lens);
161         default:
162                 LASSERTF(0, "incorrect message magic: %08x\n", magic);
163                 return -EINVAL;
164         }
165 }
166
167 /* This is used to determine the size of a buffer that was already packed
168  * and will correctly handle the different message formats. */
169 int lustre_packed_msg_size(struct lustre_msg *msg)
170 {
171         switch (msg->lm_magic) {
172         case LUSTRE_MSG_MAGIC_V2:
173                 return lustre_msg_size_v2(msg->lm_bufcount, msg->lm_buflens);
174         default:
175                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
176                 return 0;
177         }
178 }
179
180 void lustre_init_msg_v2(struct lustre_msg_v2 *msg, int count, __u32 *lens,
181                         char **bufs)
182 {
183         char *ptr;
184         int i;
185
186         msg->lm_bufcount = count;
187         /* XXX: lm_secflvr uninitialized here */
188         msg->lm_magic = LUSTRE_MSG_MAGIC_V2;
189
190         for (i = 0; i < count; i++)
191                 msg->lm_buflens[i] = lens[i];
192
193         if (bufs == NULL)
194                 return;
195
196         ptr = (char *)msg + lustre_msg_hdr_size_v2(count);
197         for (i = 0; i < count; i++) {
198                 char *tmp = bufs[i];
199                 LOGL(tmp, lens[i], ptr);
200         }
201 }
202 EXPORT_SYMBOL(lustre_init_msg_v2);
203
204 static int lustre_pack_request_v2(struct ptlrpc_request *req,
205                                   int count, __u32 *lens, char **bufs)
206 {
207         int reqlen, rc;
208
209         reqlen = lustre_msg_size_v2(count, lens);
210
211         rc = sptlrpc_cli_alloc_reqbuf(req, reqlen);
212         if (rc)
213                 return rc;
214
215         req->rq_reqlen = reqlen;
216
217         lustre_init_msg_v2(req->rq_reqmsg, count, lens, bufs);
218         lustre_msg_add_version(req->rq_reqmsg, PTLRPC_MSG_VERSION);
219         return 0;
220 }
221
222 int lustre_pack_request(struct ptlrpc_request *req, __u32 magic, int count,
223                         __u32 *lens, char **bufs)
224 {
225         __u32 size[] = { sizeof(struct ptlrpc_body) };
226
227         if (!lens) {
228                 LASSERT(count == 1);
229                 lens = size;
230         }
231
232         LASSERT(count > 0);
233         LASSERT(lens[MSG_PTLRPC_BODY_OFF] == sizeof(struct ptlrpc_body));
234
235         /* only use new format, we don't need to be compatible with 1.4 */
236         magic = LUSTRE_MSG_MAGIC_V2;
237
238         switch (magic) {
239         case LUSTRE_MSG_MAGIC_V2:
240                 return lustre_pack_request_v2(req, count, lens, bufs);
241         default:
242                 LASSERTF(0, "incorrect message magic: %08x\n", magic);
243                 return -EINVAL;
244         }
245 }
246
247 #if RS_DEBUG
248 CFS_LIST_HEAD(ptlrpc_rs_debug_lru);
249 cfs_spinlock_t ptlrpc_rs_debug_lock;
250
251 #define PTLRPC_RS_DEBUG_LRU_ADD(rs)                                     \
252 do {                                                                    \
253         cfs_spin_lock(&ptlrpc_rs_debug_lock);                           \
254         cfs_list_add_tail(&(rs)->rs_debug_list, &ptlrpc_rs_debug_lru);  \
255         cfs_spin_unlock(&ptlrpc_rs_debug_lock);                         \
256 } while (0)
257
258 #define PTLRPC_RS_DEBUG_LRU_DEL(rs)             \
259 do {                                            \
260         cfs_spin_lock(&ptlrpc_rs_debug_lock);   \
261         cfs_list_del(&(rs)->rs_debug_list);     \
262         cfs_spin_unlock(&ptlrpc_rs_debug_lock); \
263 } while (0)
264 #else
265 # define PTLRPC_RS_DEBUG_LRU_ADD(rs) do {} while(0)
266 # define PTLRPC_RS_DEBUG_LRU_DEL(rs) do {} while(0)
267 #endif
268
269 struct ptlrpc_reply_state *lustre_get_emerg_rs(struct ptlrpc_service *svc)
270 {
271         struct ptlrpc_reply_state *rs = NULL;
272
273         cfs_spin_lock(&svc->srv_rs_lock);
274         /* See if we have anything in a pool, and wait if nothing */
275         while (cfs_list_empty(&svc->srv_free_rs_list)) {
276                 struct l_wait_info lwi;
277                 int rc;
278                 cfs_spin_unlock(&svc->srv_rs_lock);
279                 /* If we cannot get anything for some long time, we better
280                    bail out instead of waiting infinitely */
281                 lwi = LWI_TIMEOUT(cfs_time_seconds(10), NULL, NULL);
282                 rc = l_wait_event(svc->srv_free_rs_waitq,
283                                   !cfs_list_empty(&svc->srv_free_rs_list),
284                                   &lwi);
285                 if (rc)
286                         goto out;
287                 cfs_spin_lock(&svc->srv_rs_lock);
288         }
289
290         rs = cfs_list_entry(svc->srv_free_rs_list.next,
291                             struct ptlrpc_reply_state, rs_list);
292         cfs_list_del(&rs->rs_list);
293         cfs_spin_unlock(&svc->srv_rs_lock);
294         LASSERT(rs);
295         memset(rs, 0, svc->srv_max_reply_size);
296         rs->rs_service = svc;
297         rs->rs_prealloc = 1;
298 out:
299         return rs;
300 }
301
302 void lustre_put_emerg_rs(struct ptlrpc_reply_state *rs)
303 {
304         struct ptlrpc_service *svc = rs->rs_service;
305
306         LASSERT(svc);
307
308         cfs_spin_lock(&svc->srv_rs_lock);
309         cfs_list_add(&rs->rs_list, &svc->srv_free_rs_list);
310         cfs_spin_unlock(&svc->srv_rs_lock);
311         cfs_waitq_signal(&svc->srv_free_rs_waitq);
312 }
313
314 int lustre_pack_reply_v2(struct ptlrpc_request *req, int count,
315                          __u32 *lens, char **bufs, int flags)
316 {
317         struct ptlrpc_reply_state *rs;
318         int                        msg_len, rc;
319         ENTRY;
320
321         LASSERT(req->rq_reply_state == NULL);
322
323         if ((flags & LPRFL_EARLY_REPLY) == 0) {
324                 cfs_spin_lock(&req->rq_lock);
325                 req->rq_packed_final = 1;
326                 cfs_spin_unlock(&req->rq_lock);
327         }
328
329         msg_len = lustre_msg_size_v2(count, lens);
330         rc = sptlrpc_svc_alloc_rs(req, msg_len);
331         if (rc)
332                 RETURN(rc);
333
334         rs = req->rq_reply_state;
335         cfs_atomic_set(&rs->rs_refcount, 1);    /* 1 ref for rq_reply_state */
336         rs->rs_cb_id.cbid_fn = reply_out_callback;
337         rs->rs_cb_id.cbid_arg = rs;
338         rs->rs_service = req->rq_rqbd->rqbd_service;
339         CFS_INIT_LIST_HEAD(&rs->rs_exp_list);
340         CFS_INIT_LIST_HEAD(&rs->rs_obd_list);
341         CFS_INIT_LIST_HEAD(&rs->rs_list);
342         cfs_spin_lock_init(&rs->rs_lock);
343
344         req->rq_replen = msg_len;
345         req->rq_reply_state = rs;
346         req->rq_repmsg = rs->rs_msg;
347
348         lustre_init_msg_v2(rs->rs_msg, count, lens, bufs);
349         lustre_msg_add_version(rs->rs_msg, PTLRPC_MSG_VERSION);
350
351         PTLRPC_RS_DEBUG_LRU_ADD(rs);
352
353         RETURN(0);
354 }
355 EXPORT_SYMBOL(lustre_pack_reply_v2);
356
357 int lustre_pack_reply_flags(struct ptlrpc_request *req, int count, __u32 *lens,
358                             char **bufs, int flags)
359 {
360         int rc = 0;
361         __u32 size[] = { sizeof(struct ptlrpc_body) };
362
363         if (!lens) {
364                 LASSERT(count == 1);
365                 lens = size;
366         }
367
368         LASSERT(count > 0);
369         LASSERT(lens[MSG_PTLRPC_BODY_OFF] == sizeof(struct ptlrpc_body));
370
371         switch (req->rq_reqmsg->lm_magic) {
372         case LUSTRE_MSG_MAGIC_V2:
373                 rc = lustre_pack_reply_v2(req, count, lens, bufs, flags);
374                 break;
375         default:
376                 LASSERTF(0, "incorrect message magic: %08x\n",
377                          req->rq_reqmsg->lm_magic);
378                 rc = -EINVAL;
379         }
380         if (rc != 0)
381                 CERROR("lustre_pack_reply failed: rc=%d size=%d\n", rc,
382                        lustre_msg_size(req->rq_reqmsg->lm_magic, count, lens));
383         return rc;
384 }
385
386 int lustre_pack_reply(struct ptlrpc_request *req, int count, __u32 *lens,
387                       char **bufs)
388 {
389         return lustre_pack_reply_flags(req, count, lens, bufs, 0);
390 }
391
392 void *lustre_msg_buf_v2(struct lustre_msg_v2 *m, int n, int min_size)
393 {
394         int i, offset, buflen, bufcount;
395
396         LASSERT(m != NULL);
397         LASSERT(n >= 0);
398
399         bufcount = m->lm_bufcount;
400         if (unlikely(n >= bufcount)) {
401                 CDEBUG(D_INFO, "msg %p buffer[%d] not present (count %d)\n",
402                        m, n, bufcount);
403                 return NULL;
404         }
405
406         buflen = m->lm_buflens[n];
407         if (unlikely(buflen < min_size)) {
408                 CERROR("msg %p buffer[%d] size %d too small "
409                        "(required %d, opc=%d)\n", m, n, buflen, min_size,
410                        n == MSG_PTLRPC_BODY_OFF ? -1 : lustre_msg_get_opc(m));
411                 return NULL;
412         }
413
414         offset = lustre_msg_hdr_size_v2(bufcount);
415         for (i = 0; i < n; i++)
416                 offset += cfs_size_round(m->lm_buflens[i]);
417
418         return (char *)m + offset;
419 }
420
421 void *lustre_msg_buf(struct lustre_msg *m, int n, int min_size)
422 {
423         switch (m->lm_magic) {
424         case LUSTRE_MSG_MAGIC_V2:
425                 return lustre_msg_buf_v2(m, n, min_size);
426         default:
427                 LASSERTF(0, "incorrect message magic: %08x(msg:%p)\n", m->lm_magic, m);
428                 return NULL;
429         }
430 }
431
432 int lustre_shrink_msg_v2(struct lustre_msg_v2 *msg, int segment,
433                          unsigned int newlen, int move_data)
434 {
435         char   *tail = NULL, *newpos;
436         int     tail_len = 0, n;
437
438         LASSERT(msg);
439         LASSERT(msg->lm_bufcount > segment);
440         LASSERT(msg->lm_buflens[segment] >= newlen);
441
442         if (msg->lm_buflens[segment] == newlen)
443                 goto out;
444
445         if (move_data && msg->lm_bufcount > segment + 1) {
446                 tail = lustre_msg_buf_v2(msg, segment + 1, 0);
447                 for (n = segment + 1; n < msg->lm_bufcount; n++)
448                         tail_len += cfs_size_round(msg->lm_buflens[n]);
449         }
450
451         msg->lm_buflens[segment] = newlen;
452
453         if (tail && tail_len) {
454                 newpos = lustre_msg_buf_v2(msg, segment + 1, 0);
455                 LASSERT(newpos <= tail);
456                 if (newpos != tail)
457                         memmove(newpos, tail, tail_len);
458         }
459 out:
460         return lustre_msg_size_v2(msg->lm_bufcount, msg->lm_buflens);
461 }
462
463 /*
464  * for @msg, shrink @segment to size @newlen. if @move_data is non-zero,
465  * we also move data forward from @segment + 1.
466  *
467  * if @newlen == 0, we remove the segment completely, but we still keep the
468  * totally bufcount the same to save possible data moving. this will leave a
469  * unused segment with size 0 at the tail, but that's ok.
470  *
471  * return new msg size after shrinking.
472  *
473  * CAUTION:
474  * + if any buffers higher than @segment has been filled in, must call shrink
475  *   with non-zero @move_data.
476  * + caller should NOT keep pointers to msg buffers which higher than @segment
477  *   after call shrink.
478  */
479 int lustre_shrink_msg(struct lustre_msg *msg, int segment,
480                       unsigned int newlen, int move_data)
481 {
482         switch (msg->lm_magic) {
483         case LUSTRE_MSG_MAGIC_V2:
484                 return lustre_shrink_msg_v2(msg, segment, newlen, move_data);
485         default:
486                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
487         }
488 }
489
490 void lustre_free_reply_state(struct ptlrpc_reply_state *rs)
491 {
492         PTLRPC_RS_DEBUG_LRU_DEL(rs);
493
494         LASSERT (cfs_atomic_read(&rs->rs_refcount) == 0);
495         LASSERT (!rs->rs_difficult || rs->rs_handled);
496         LASSERT (!rs->rs_on_net);
497         LASSERT (!rs->rs_scheduled);
498         LASSERT (rs->rs_export == NULL);
499         LASSERT (rs->rs_nlocks == 0);
500         LASSERT (cfs_list_empty(&rs->rs_exp_list));
501         LASSERT (cfs_list_empty(&rs->rs_obd_list));
502
503         sptlrpc_svc_free_rs(rs);
504 }
505
506 static int lustre_unpack_msg_v2(struct lustre_msg_v2 *m, int len)
507 {
508         int swabbed, required_len, i;
509
510         /* Now we know the sender speaks my language. */
511         required_len = lustre_msg_hdr_size_v2(0);
512         if (len < required_len) {
513                 /* can't even look inside the message */
514                 CERROR("message length %d too small for lustre_msg\n", len);
515                 return -EINVAL;
516         }
517
518         swabbed = (m->lm_magic == LUSTRE_MSG_MAGIC_V2_SWABBED);
519
520         if (swabbed) {
521                 __swab32s(&m->lm_magic);
522                 __swab32s(&m->lm_bufcount);
523                 __swab32s(&m->lm_secflvr);
524                 __swab32s(&m->lm_repsize);
525                 __swab32s(&m->lm_cksum);
526                 __swab32s(&m->lm_flags);
527                 CLASSERT(offsetof(typeof(*m), lm_padding_2) != 0);
528                 CLASSERT(offsetof(typeof(*m), lm_padding_3) != 0);
529         }
530
531         required_len = lustre_msg_hdr_size_v2(m->lm_bufcount);
532         if (len < required_len) {
533                 /* didn't receive all the buffer lengths */
534                 CERROR ("message length %d too small for %d buflens\n",
535                         len, m->lm_bufcount);
536                 return -EINVAL;
537         }
538
539         for (i = 0; i < m->lm_bufcount; i++) {
540                 if (swabbed)
541                         __swab32s(&m->lm_buflens[i]);
542                 required_len += cfs_size_round(m->lm_buflens[i]);
543         }
544
545         if (len < required_len) {
546                 CERROR("len: %d, required_len %d\n", len, required_len);
547                 CERROR("bufcount: %d\n", m->lm_bufcount);
548                 for (i = 0; i < m->lm_bufcount; i++)
549                         CERROR("buffer %d length %d\n", i, m->lm_buflens[i]);
550                 return -EINVAL;
551         }
552
553         return swabbed;
554 }
555
556 int __lustre_unpack_msg(struct lustre_msg *m, int len)
557 {
558         int required_len, rc;
559         ENTRY;
560
561         /* We can provide a slightly better error log, if we check the
562          * message magic and version first.  In the future, struct
563          * lustre_msg may grow, and we'd like to log a version mismatch,
564          * rather than a short message.
565          *
566          */
567         required_len = offsetof(struct lustre_msg, lm_magic) +
568                        sizeof(m->lm_magic);
569         if (len < required_len) {
570                 /* can't even look inside the message */
571                 CERROR("message length %d too small for magic/version check\n",
572                        len);
573                 RETURN(-EINVAL);
574         }
575
576         rc = lustre_unpack_msg_v2(m, len);
577
578         RETURN(rc);
579 }
580 EXPORT_SYMBOL(__lustre_unpack_msg);
581
582 int ptlrpc_unpack_req_msg(struct ptlrpc_request *req, int len)
583 {
584         int rc;
585         rc = __lustre_unpack_msg(req->rq_reqmsg, len);
586         if (rc == 1) {
587                 lustre_set_req_swabbed(req, MSG_PTLRPC_HEADER_OFF);
588                 rc = 0;
589         }
590         return rc;
591 }
592
593 int ptlrpc_unpack_rep_msg(struct ptlrpc_request *req, int len)
594 {
595         int rc;
596         rc = __lustre_unpack_msg(req->rq_repmsg, len);
597         if (rc == 1) {
598                 lustre_set_rep_swabbed(req, MSG_PTLRPC_HEADER_OFF);
599                 rc = 0;
600         }
601         return rc;
602 }
603
604 static inline int lustre_unpack_ptlrpc_body_v2(struct ptlrpc_request *req,
605                                                const int inout, int offset)
606 {
607         struct ptlrpc_body *pb;
608         struct lustre_msg_v2 *m = inout ? req->rq_reqmsg : req->rq_repmsg;
609
610         pb = lustre_msg_buf_v2(m, offset, sizeof(*pb));
611         if (!pb) {
612                 CERROR("error unpacking ptlrpc body\n");
613                 return -EFAULT;
614         }
615         if (ptlrpc_buf_need_swab(req, inout, offset)) {
616                 lustre_swab_ptlrpc_body(pb);
617                 ptlrpc_buf_set_swabbed(req, inout, offset);
618         }
619
620         if ((pb->pb_version & ~LUSTRE_VERSION_MASK) != PTLRPC_MSG_VERSION) {
621                  CERROR("wrong lustre_msg version %08x\n", pb->pb_version);
622                  return -EINVAL;
623         }
624
625         return 0;
626 }
627
628 int lustre_unpack_req_ptlrpc_body(struct ptlrpc_request *req, int offset)
629 {
630         switch (req->rq_reqmsg->lm_magic) {
631         case LUSTRE_MSG_MAGIC_V2:
632                 return lustre_unpack_ptlrpc_body_v2(req, 1, offset);
633         default:
634                 CERROR("bad lustre msg magic: %08x\n",
635                        req->rq_reqmsg->lm_magic);
636                 return -EINVAL;
637         }
638 }
639
640 int lustre_unpack_rep_ptlrpc_body(struct ptlrpc_request *req, int offset)
641 {
642         switch (req->rq_repmsg->lm_magic) {
643         case LUSTRE_MSG_MAGIC_V2:
644                 return lustre_unpack_ptlrpc_body_v2(req, 0, offset);
645         default:
646                 CERROR("bad lustre msg magic: %08x\n",
647                        req->rq_repmsg->lm_magic);
648                 return -EINVAL;
649         }
650 }
651
652 static inline int lustre_msg_buflen_v2(struct lustre_msg_v2 *m, int n)
653 {
654         if (n >= m->lm_bufcount)
655                 return 0;
656
657         return m->lm_buflens[n];
658 }
659
660 /**
661  * lustre_msg_buflen - return the length of buffer \a n in message \a m
662  * \param m lustre_msg (request or reply) to look at
663  * \param n message index (base 0)
664  *
665  * returns zero for non-existent message indices
666  */
667 int lustre_msg_buflen(struct lustre_msg *m, int n)
668 {
669         switch (m->lm_magic) {
670         case LUSTRE_MSG_MAGIC_V2:
671                 return lustre_msg_buflen_v2(m, n);
672         default:
673                 CERROR("incorrect message magic: %08x\n", m->lm_magic);
674                 return -EINVAL;
675         }
676 }
677 EXPORT_SYMBOL(lustre_msg_buflen);
678
679 static inline void
680 lustre_msg_set_buflen_v2(struct lustre_msg_v2 *m, int n, int len)
681 {
682         if (n >= m->lm_bufcount)
683                 LBUG();
684
685         m->lm_buflens[n] = len;
686 }
687
688 void lustre_msg_set_buflen(struct lustre_msg *m, int n, int len)
689 {
690         switch (m->lm_magic) {
691         case LUSTRE_MSG_MAGIC_V2:
692                 lustre_msg_set_buflen_v2(m, n, len);
693                 return;
694         default:
695                 LASSERTF(0, "incorrect message magic: %08x\n", m->lm_magic);
696         }
697 }
698
699 EXPORT_SYMBOL(lustre_msg_set_buflen);
700
701 /* NB return the bufcount for lustre_msg_v2 format, so if message is packed
702  * in V1 format, the result is one bigger. (add struct ptlrpc_body). */
703 int lustre_msg_bufcount(struct lustre_msg *m)
704 {
705         switch (m->lm_magic) {
706         case LUSTRE_MSG_MAGIC_V2:
707                 return m->lm_bufcount;
708         default:
709                 CERROR("incorrect message magic: %08x\n", m->lm_magic);
710                 return -EINVAL;
711         }
712 }
713 EXPORT_SYMBOL(lustre_msg_bufcount);
714
715 char *lustre_msg_string(struct lustre_msg *m, int index, int max_len)
716 {
717         /* max_len == 0 means the string should fill the buffer */
718         char *str;
719         int slen, blen;
720
721         switch (m->lm_magic) {
722         case LUSTRE_MSG_MAGIC_V2:
723                 str = lustre_msg_buf_v2(m, index, 0);
724                 blen = lustre_msg_buflen_v2(m, index);
725                 break;
726         default:
727                 LASSERTF(0, "incorrect message magic: %08x\n", m->lm_magic);
728         }
729
730         if (str == NULL) {
731                 CERROR ("can't unpack string in msg %p buffer[%d]\n", m, index);
732                 return NULL;
733         }
734
735         slen = strnlen(str, blen);
736
737         if (slen == blen) {                     /* not NULL terminated */
738                 CERROR("can't unpack non-NULL terminated string in "
739                         "msg %p buffer[%d] len %d\n", m, index, blen);
740                 return NULL;
741         }
742
743         if (max_len == 0) {
744                 if (slen != blen - 1) {
745                         CERROR("can't unpack short string in msg %p "
746                                "buffer[%d] len %d: strlen %d\n",
747                                m, index, blen, slen);
748                         return NULL;
749                 }
750         } else if (slen > max_len) {
751                 CERROR("can't unpack oversized string in msg %p "
752                        "buffer[%d] len %d strlen %d: max %d expected\n",
753                        m, index, blen, slen, max_len);
754                 return NULL;
755         }
756
757         return str;
758 }
759
760 /* Wrap up the normal fixed length cases */
761 static inline void *__lustre_swab_buf(struct lustre_msg *msg, int index,
762                                       int min_size, void *swabber)
763 {
764         void *ptr = NULL;
765
766         LASSERT(msg != NULL);
767         switch (msg->lm_magic) {
768         case LUSTRE_MSG_MAGIC_V2:
769                 ptr = lustre_msg_buf_v2(msg, index, min_size);
770                 break;
771         default:
772                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
773         }
774
775         if (ptr && swabber)
776                 ((void (*)(void *))swabber)(ptr);
777
778         return ptr;
779 }
780
781 static inline struct ptlrpc_body *lustre_msg_ptlrpc_body(struct lustre_msg *msg)
782 {
783         return lustre_msg_buf_v2(msg, MSG_PTLRPC_BODY_OFF,
784                                  sizeof(struct ptlrpc_body));
785 }
786
787 __u32 lustre_msghdr_get_flags(struct lustre_msg *msg)
788 {
789         switch (msg->lm_magic) {
790         case LUSTRE_MSG_MAGIC_V1:
791         case LUSTRE_MSG_MAGIC_V1_SWABBED:
792                 return 0;
793         case LUSTRE_MSG_MAGIC_V2:
794                 /* already in host endian */
795                 return msg->lm_flags;
796         default:
797                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
798                 return 0;
799         }
800 }
801 EXPORT_SYMBOL(lustre_msghdr_get_flags);
802
803 void lustre_msghdr_set_flags(struct lustre_msg *msg, __u32 flags)
804 {
805         switch (msg->lm_magic) {
806         case LUSTRE_MSG_MAGIC_V1:
807                 return;
808         case LUSTRE_MSG_MAGIC_V2:
809                 msg->lm_flags = flags;
810                 return;
811         default:
812                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
813         }
814 }
815
816 __u32 lustre_msg_get_flags(struct lustre_msg *msg)
817 {
818         switch (msg->lm_magic) {
819         case LUSTRE_MSG_MAGIC_V2: {
820                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
821                 if (!pb) {
822                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
823                         return 0;
824                 }
825                 return pb->pb_flags;
826         }
827         default:
828                 /* flags might be printed in debug code while message
829                  * uninitialized */
830                 return 0;
831         }
832 }
833
834 void lustre_msg_add_flags(struct lustre_msg *msg, int flags)
835 {
836         switch (msg->lm_magic) {
837         case LUSTRE_MSG_MAGIC_V2: {
838                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
839                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
840                 pb->pb_flags |= flags;
841                 return;
842         }
843         default:
844                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
845         }
846 }
847
848 void lustre_msg_set_flags(struct lustre_msg *msg, int flags)
849 {
850         switch (msg->lm_magic) {
851         case LUSTRE_MSG_MAGIC_V2: {
852                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
853                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
854                 pb->pb_flags = flags;
855                 return;
856         }
857         default:
858                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
859         }
860 }
861
862 void lustre_msg_clear_flags(struct lustre_msg *msg, int flags)
863 {
864         switch (msg->lm_magic) {
865         case LUSTRE_MSG_MAGIC_V2: {
866                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
867                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
868                 pb->pb_flags &= ~(MSG_GEN_FLAG_MASK & flags);
869                 return;
870         }
871         default:
872                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
873         }
874 }
875
876 __u32 lustre_msg_get_op_flags(struct lustre_msg *msg)
877 {
878         switch (msg->lm_magic) {
879         case LUSTRE_MSG_MAGIC_V2: {
880                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
881                 if (!pb) {
882                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
883                         return 0;
884                 }
885                 return pb->pb_op_flags;
886         }
887         default:
888                 return 0;
889         }
890 }
891
892 void lustre_msg_add_op_flags(struct lustre_msg *msg, int flags)
893 {
894         switch (msg->lm_magic) {
895         case LUSTRE_MSG_MAGIC_V2: {
896                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
897                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
898                 pb->pb_op_flags |= flags;
899                 return;
900         }
901         default:
902                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
903         }
904 }
905
906 void lustre_msg_set_op_flags(struct lustre_msg *msg, int flags)
907 {
908         switch (msg->lm_magic) {
909         case LUSTRE_MSG_MAGIC_V2: {
910                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
911                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
912                 pb->pb_op_flags |= flags;
913                 return;
914         }
915         default:
916                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
917         }
918 }
919
920 struct lustre_handle *lustre_msg_get_handle(struct lustre_msg *msg)
921 {
922         switch (msg->lm_magic) {
923         case LUSTRE_MSG_MAGIC_V2: {
924                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
925                 if (!pb) {
926                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
927                         return NULL;
928                 }
929                 return &pb->pb_handle;
930         }
931         default:
932                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
933                 return NULL;
934         }
935 }
936
937 __u32 lustre_msg_get_type(struct lustre_msg *msg)
938 {
939         switch (msg->lm_magic) {
940         case LUSTRE_MSG_MAGIC_V2: {
941                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
942                 if (!pb) {
943                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
944                         return PTL_RPC_MSG_ERR;
945                 }
946                 return pb->pb_type;
947         }
948         default:
949                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
950                 return PTL_RPC_MSG_ERR;
951         }
952 }
953
954 __u32 lustre_msg_get_version(struct lustre_msg *msg)
955 {
956         switch (msg->lm_magic) {
957         case LUSTRE_MSG_MAGIC_V2: {
958                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
959                 if (!pb) {
960                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
961                         return 0;
962                 }
963                 return pb->pb_version;
964         }
965         default:
966                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
967                 return 0;
968         }
969 }
970
971 void lustre_msg_add_version(struct lustre_msg *msg, int version)
972 {
973         switch (msg->lm_magic) {
974         case LUSTRE_MSG_MAGIC_V2: {
975                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
976                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
977                 pb->pb_version |= version;
978                 return;
979         }
980         default:
981                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
982         }
983 }
984
985 __u32 lustre_msg_get_opc(struct lustre_msg *msg)
986 {
987         switch (msg->lm_magic) {
988         case LUSTRE_MSG_MAGIC_V2: {
989                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
990                 if (!pb) {
991                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
992                         return 0;
993                 }
994                 return pb->pb_opc;
995         }
996         default:
997                 CERROR("incorrect message magic: %08x(msg:%p)\n", msg->lm_magic, msg);
998                 LBUG();
999                 return 0;
1000         }
1001 }
1002
1003 __u64 lustre_msg_get_last_xid(struct lustre_msg *msg)
1004 {
1005         switch (msg->lm_magic) {
1006         case LUSTRE_MSG_MAGIC_V2: {
1007                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1008                 if (!pb) {
1009                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1010                         return 0;
1011                 }
1012                 return pb->pb_last_xid;
1013         }
1014         default:
1015                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1016                 return 0;
1017         }
1018 }
1019
1020 __u64 lustre_msg_get_last_committed(struct lustre_msg *msg)
1021 {
1022         switch (msg->lm_magic) {
1023         case LUSTRE_MSG_MAGIC_V2: {
1024                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1025                 if (!pb) {
1026                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1027                         return 0;
1028                 }
1029                 return pb->pb_last_committed;
1030         }
1031         default:
1032                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1033                 return 0;
1034         }
1035 }
1036
1037 __u64 *lustre_msg_get_versions(struct lustre_msg *msg)
1038 {
1039         switch (msg->lm_magic) {
1040         case LUSTRE_MSG_MAGIC_V1:
1041                 return NULL;
1042         case LUSTRE_MSG_MAGIC_V2: {
1043                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1044                 if (!pb) {
1045                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1046                         return NULL;
1047                 }
1048                 return pb->pb_pre_versions;
1049         }
1050         default:
1051                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1052                 return NULL;
1053         }
1054 }
1055
1056 __u64 lustre_msg_get_transno(struct lustre_msg *msg)
1057 {
1058         switch (msg->lm_magic) {
1059         case LUSTRE_MSG_MAGIC_V2: {
1060                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1061                 if (!pb) {
1062                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1063                         return 0;
1064                 }
1065                 return pb->pb_transno;
1066         }
1067         default:
1068                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1069                 return 0;
1070         }
1071 }
1072
1073 int lustre_msg_get_status(struct lustre_msg *msg)
1074 {
1075         switch (msg->lm_magic) {
1076         case LUSTRE_MSG_MAGIC_V2: {
1077                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1078                 if (!pb) {
1079                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1080                         return -EINVAL;
1081                 }
1082                 return pb->pb_status;
1083         }
1084         default:
1085                 /* status might be printed in debug code while message
1086                  * uninitialized */
1087                 return -EINVAL;
1088         }
1089 }
1090
1091 __u64 lustre_msg_get_slv(struct lustre_msg *msg)
1092 {
1093         switch (msg->lm_magic) {
1094         case LUSTRE_MSG_MAGIC_V2: {
1095                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1096                 if (!pb) {
1097                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1098                         return -EINVAL;
1099                 }
1100                 return pb->pb_slv;
1101         }
1102         default:
1103                 CERROR("invalid msg magic %08x\n", msg->lm_magic);
1104                 return -EINVAL;
1105         }
1106 }
1107
1108
1109 void lustre_msg_set_slv(struct lustre_msg *msg, __u64 slv)
1110 {
1111         switch (msg->lm_magic) {
1112         case LUSTRE_MSG_MAGIC_V2: {
1113                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1114                 if (!pb) {
1115                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1116                         return;
1117                 }
1118                 pb->pb_slv = slv;
1119                 return;
1120         }
1121         default:
1122                 CERROR("invalid msg magic %x\n", msg->lm_magic);
1123                 return;
1124         }
1125 }
1126
1127 __u32 lustre_msg_get_limit(struct lustre_msg *msg)
1128 {
1129         switch (msg->lm_magic) {
1130         case LUSTRE_MSG_MAGIC_V2: {
1131                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1132                 if (!pb) {
1133                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1134                         return -EINVAL;
1135                 }
1136                 return pb->pb_limit;
1137         }
1138         default:
1139                 CERROR("invalid msg magic %x\n", msg->lm_magic);
1140                 return -EINVAL;
1141         }
1142 }
1143
1144
1145 void lustre_msg_set_limit(struct lustre_msg *msg, __u64 limit)
1146 {
1147         switch (msg->lm_magic) {
1148         case LUSTRE_MSG_MAGIC_V2: {
1149                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1150                 if (!pb) {
1151                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1152                         return;
1153                 }
1154                 pb->pb_limit = limit;
1155                 return;
1156         }
1157         default:
1158                 CERROR("invalid msg magic %08x\n", msg->lm_magic);
1159                 return;
1160         }
1161 }
1162
1163 __u32 lustre_msg_get_conn_cnt(struct lustre_msg *msg)
1164 {
1165         switch (msg->lm_magic) {
1166         case LUSTRE_MSG_MAGIC_V2: {
1167                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1168                 if (!pb) {
1169                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1170                         return 0;
1171                 }
1172                 return pb->pb_conn_cnt;
1173         }
1174         default:
1175                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1176                 return 0;
1177         }
1178 }
1179
1180 int lustre_msg_is_v1(struct lustre_msg *msg)
1181 {
1182         switch (msg->lm_magic) {
1183         case LUSTRE_MSG_MAGIC_V1:
1184         case LUSTRE_MSG_MAGIC_V1_SWABBED:
1185                 return 1;
1186         default:
1187                 return 0;
1188         }
1189 }
1190
1191 __u32 lustre_msg_get_magic(struct lustre_msg *msg)
1192 {
1193         switch (msg->lm_magic) {
1194         case LUSTRE_MSG_MAGIC_V2:
1195                 return msg->lm_magic;
1196         default:
1197                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1198                 return 0;
1199         }
1200 }
1201
1202 __u32 lustre_msg_get_timeout(struct lustre_msg *msg)
1203 {
1204         switch (msg->lm_magic) {
1205         case LUSTRE_MSG_MAGIC_V1:
1206         case LUSTRE_MSG_MAGIC_V1_SWABBED:
1207                 return 0;
1208         case LUSTRE_MSG_MAGIC_V2: {
1209                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1210                 if (!pb) {
1211                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1212                         return 0;
1213
1214                 }
1215                 return pb->pb_timeout;
1216         }
1217         default:
1218                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1219                 return 0;
1220         }
1221 }
1222
1223 __u32 lustre_msg_get_service_time(struct lustre_msg *msg)
1224 {
1225         switch (msg->lm_magic) {
1226         case LUSTRE_MSG_MAGIC_V1:
1227         case LUSTRE_MSG_MAGIC_V1_SWABBED:
1228                 return 0;
1229         case LUSTRE_MSG_MAGIC_V2: {
1230                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1231                 if (!pb) {
1232                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1233                         return 0;
1234
1235                 }
1236                 return pb->pb_service_time;
1237         }
1238         default:
1239                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1240                 return 0;
1241         }
1242 }
1243
1244 __u32 lustre_msg_get_cksum(struct lustre_msg *msg)
1245 {
1246         switch (msg->lm_magic) {
1247         case LUSTRE_MSG_MAGIC_V2:
1248                 return msg->lm_cksum;
1249         default:
1250                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1251                 return 0;
1252         }
1253 }
1254
1255 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 9, 0, 0)
1256 /*
1257  * In 1.6 and 1.8 the checksum was computed only on struct ptlrpc_body as
1258  * it was in 1.6 (88 bytes, smaller than the full size in 1.8).  It makes
1259  * more sense to compute the checksum on the full ptlrpc_body, regardless
1260  * of what size it is, but in order to keep interoperability with 1.8 we
1261  * can optionally also checksum only the first 88 bytes (caller decides). */
1262 # define ptlrpc_body_cksum_size_compat18         88
1263
1264 __u32 lustre_msg_calc_cksum(struct lustre_msg *msg, int compat18)
1265 #else
1266 # warning "remove checksum compatibility support for b1_8"
1267 __u32 lustre_msg_calc_cksum(struct lustre_msg *msg)
1268 #endif
1269 {
1270         switch (msg->lm_magic) {
1271         case LUSTRE_MSG_MAGIC_V2: {
1272                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1273 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 9, 0, 0)
1274                 __u32 len = compat18 ? ptlrpc_body_cksum_size_compat18 :
1275                             lustre_msg_buflen(msg, MSG_PTLRPC_BODY_OFF);
1276                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1277                 return crc32_le(~(__u32)0, (unsigned char *)pb, len);
1278 #else
1279 # warning "remove checksum compatibility support for b1_8"
1280                 return crc32_le(~(__u32)0, (unsigned char *)pb,
1281                                 lustre_msg_buflen(msg, MSG_PTLRPC_BODY_OFF));
1282 #endif
1283         }
1284         default:
1285                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1286                 return 0;
1287         }
1288 }
1289
1290 void lustre_msg_set_handle(struct lustre_msg *msg, struct lustre_handle *handle)
1291 {
1292         switch (msg->lm_magic) {
1293         case LUSTRE_MSG_MAGIC_V2: {
1294                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1295                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1296                 pb->pb_handle = *handle;
1297                 return;
1298         }
1299         default:
1300                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1301         }
1302 }
1303
1304 void lustre_msg_set_type(struct lustre_msg *msg, __u32 type)
1305 {
1306         switch (msg->lm_magic) {
1307         case LUSTRE_MSG_MAGIC_V2: {
1308                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1309                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1310                 pb->pb_type = type;
1311                 return;
1312         }
1313         default:
1314                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1315         }
1316 }
1317
1318 void lustre_msg_set_opc(struct lustre_msg *msg, __u32 opc)
1319 {
1320         switch (msg->lm_magic) {
1321         case LUSTRE_MSG_MAGIC_V2: {
1322                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1323                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1324                 pb->pb_opc = opc;
1325                 return;
1326         }
1327         default:
1328                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1329         }
1330 }
1331
1332 void lustre_msg_set_last_xid(struct lustre_msg *msg, __u64 last_xid)
1333 {
1334         switch (msg->lm_magic) {
1335         case LUSTRE_MSG_MAGIC_V2: {
1336                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1337                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1338                 pb->pb_last_xid = last_xid;
1339                 return;
1340         }
1341         default:
1342                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1343         }
1344 }
1345
1346 void lustre_msg_set_last_committed(struct lustre_msg *msg, __u64 last_committed)
1347 {
1348         switch (msg->lm_magic) {
1349         case LUSTRE_MSG_MAGIC_V2: {
1350                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1351                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1352                 pb->pb_last_committed = last_committed;
1353                 return;
1354         }
1355         default:
1356                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1357         }
1358 }
1359
1360 void lustre_msg_set_versions(struct lustre_msg *msg, __u64 *versions)
1361 {
1362         switch (msg->lm_magic) {
1363         case LUSTRE_MSG_MAGIC_V1:
1364                 return;
1365         case LUSTRE_MSG_MAGIC_V2: {
1366                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1367                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1368                 pb->pb_pre_versions[0] = versions[0];
1369                 pb->pb_pre_versions[1] = versions[1];
1370                 pb->pb_pre_versions[2] = versions[2];
1371                 pb->pb_pre_versions[3] = versions[3];
1372                 return;
1373         }
1374         default:
1375                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1376         }
1377 }
1378
1379 void lustre_msg_set_transno(struct lustre_msg *msg, __u64 transno)
1380 {
1381         switch (msg->lm_magic) {
1382         case LUSTRE_MSG_MAGIC_V2: {
1383                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1384                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1385                 pb->pb_transno = transno;
1386                 return;
1387         }
1388         default:
1389                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1390         }
1391 }
1392
1393 void lustre_msg_set_status(struct lustre_msg *msg, __u32 status)
1394 {
1395         switch (msg->lm_magic) {
1396         case LUSTRE_MSG_MAGIC_V2: {
1397                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1398                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1399                 pb->pb_status = status;
1400                 return;
1401         }
1402         default:
1403                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1404         }
1405 }
1406
1407 void lustre_msg_set_conn_cnt(struct lustre_msg *msg, __u32 conn_cnt)
1408 {
1409         switch (msg->lm_magic) {
1410         case LUSTRE_MSG_MAGIC_V2: {
1411                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1412                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1413                 pb->pb_conn_cnt = conn_cnt;
1414                 return;
1415         }
1416         default:
1417                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1418         }
1419 }
1420
1421 void lustre_msg_set_timeout(struct lustre_msg *msg, __u32 timeout)
1422 {
1423         switch (msg->lm_magic) {
1424         case LUSTRE_MSG_MAGIC_V1:
1425                 return;
1426         case LUSTRE_MSG_MAGIC_V2: {
1427                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1428                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1429                 pb->pb_timeout = timeout;
1430                 return;
1431         }
1432         default:
1433                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1434         }
1435 }
1436
1437 void lustre_msg_set_service_time(struct lustre_msg *msg, __u32 service_time)
1438 {
1439         switch (msg->lm_magic) {
1440         case LUSTRE_MSG_MAGIC_V1:
1441                 return;
1442         case LUSTRE_MSG_MAGIC_V2: {
1443                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1444                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1445                 pb->pb_service_time = service_time;
1446                 return;
1447         }
1448         default:
1449                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1450         }
1451 }
1452
1453 void lustre_msg_set_cksum(struct lustre_msg *msg, __u32 cksum)
1454 {
1455         switch (msg->lm_magic) {
1456         case LUSTRE_MSG_MAGIC_V1:
1457                 return;
1458         case LUSTRE_MSG_MAGIC_V2:
1459                 msg->lm_cksum = cksum;
1460                 return;
1461         default:
1462                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1463         }
1464 }
1465
1466
1467 void ptlrpc_request_set_replen(struct ptlrpc_request *req)
1468 {
1469         int count = req_capsule_filled_sizes(&req->rq_pill, RCL_SERVER);
1470
1471         req->rq_replen = lustre_msg_size(req->rq_reqmsg->lm_magic, count,
1472                                          req->rq_pill.rc_area[RCL_SERVER]);
1473         if (req->rq_reqmsg->lm_magic == LUSTRE_MSG_MAGIC_V2)
1474                 req->rq_reqmsg->lm_repsize = req->rq_replen;
1475 }
1476
1477 void ptlrpc_req_set_repsize(struct ptlrpc_request *req, int count, __u32 *lens)
1478 {
1479         req->rq_replen = lustre_msg_size(req->rq_reqmsg->lm_magic, count, lens);
1480         if (req->rq_reqmsg->lm_magic == LUSTRE_MSG_MAGIC_V2)
1481                 req->rq_reqmsg->lm_repsize = req->rq_replen;
1482 }
1483
1484 /**
1485  * Send a remote set_info_async.
1486  *
1487  * This may go from client to server or server to client.
1488  */
1489 int do_set_info_async(struct obd_import *imp,
1490                       int opcode, int version,
1491                       obd_count keylen, void *key,
1492                       obd_count vallen, void *val,
1493                       struct ptlrpc_request_set *set)
1494 {
1495         struct ptlrpc_request *req;
1496         char                  *tmp;
1497         int                    rc;
1498         ENTRY;
1499
1500         req = ptlrpc_request_alloc(imp, &RQF_OBD_SET_INFO);
1501         if (req == NULL)
1502                 RETURN(-ENOMEM);
1503
1504         req_capsule_set_size(&req->rq_pill, &RMF_SETINFO_KEY,
1505                              RCL_CLIENT, keylen);
1506         req_capsule_set_size(&req->rq_pill, &RMF_SETINFO_VAL,
1507                              RCL_CLIENT, vallen);
1508         rc = ptlrpc_request_pack(req, version, opcode);
1509         if (rc) {
1510                 ptlrpc_request_free(req);
1511                 RETURN(rc);
1512         }
1513
1514         tmp = req_capsule_client_get(&req->rq_pill, &RMF_SETINFO_KEY);
1515         memcpy(tmp, key, keylen);
1516         tmp = req_capsule_client_get(&req->rq_pill, &RMF_SETINFO_VAL);
1517         memcpy(tmp, val, vallen);
1518
1519         ptlrpc_request_set_replen(req);
1520
1521         if (set) {
1522                 ptlrpc_set_add_req(set, req);
1523                 ptlrpc_check_set(NULL, set);
1524         } else {
1525                 rc = ptlrpc_queue_wait(req);
1526                 ptlrpc_req_finished(req);
1527         }
1528
1529         RETURN(rc);
1530 }
1531 EXPORT_SYMBOL(do_set_info_async);
1532
1533 /* byte flipping routines for all wire types declared in
1534  * lustre_idl.h implemented here.
1535  */
1536 void lustre_swab_ptlrpc_body(struct ptlrpc_body *b)
1537 {
1538         __swab32s (&b->pb_type);
1539         __swab32s (&b->pb_version);
1540         __swab32s (&b->pb_opc);
1541         __swab32s (&b->pb_status);
1542         __swab64s (&b->pb_last_xid);
1543         __swab64s (&b->pb_last_seen);
1544         __swab64s (&b->pb_last_committed);
1545         __swab64s (&b->pb_transno);
1546         __swab32s (&b->pb_flags);
1547         __swab32s (&b->pb_op_flags);
1548         __swab32s (&b->pb_conn_cnt);
1549         __swab32s (&b->pb_timeout);
1550         __swab32s (&b->pb_service_time);
1551         __swab32s (&b->pb_limit);
1552         __swab64s (&b->pb_slv);
1553         __swab64s (&b->pb_pre_versions[0]);
1554         __swab64s (&b->pb_pre_versions[1]);
1555         __swab64s (&b->pb_pre_versions[2]);
1556         __swab64s (&b->pb_pre_versions[3]);
1557         CLASSERT(offsetof(typeof(*b), pb_padding) != 0);
1558 }
1559
1560 void lustre_swab_connect(struct obd_connect_data *ocd)
1561 {
1562         __swab64s(&ocd->ocd_connect_flags);
1563         __swab32s(&ocd->ocd_version);
1564         __swab32s(&ocd->ocd_grant);
1565         __swab64s(&ocd->ocd_ibits_known);
1566         __swab32s(&ocd->ocd_index);
1567         __swab32s(&ocd->ocd_brw_size);
1568         __swab32s(&ocd->ocd_nllu);
1569         __swab32s(&ocd->ocd_nllg);
1570         __swab64s(&ocd->ocd_transno);
1571         __swab32s(&ocd->ocd_group);
1572         __swab32s(&ocd->ocd_cksum_types);
1573         CLASSERT(offsetof(typeof(*ocd), padding1) != 0);
1574         CLASSERT(offsetof(typeof(*ocd), padding2) != 0);
1575 }
1576
1577 void lustre_swab_obdo (struct obdo  *o)
1578 {
1579         __swab64s (&o->o_valid);
1580         __swab64s (&o->o_id);
1581         __swab64s (&o->o_seq);
1582         __swab64s (&o->o_parent_seq);
1583         __swab64s (&o->o_size);
1584         __swab64s (&o->o_mtime);
1585         __swab64s (&o->o_atime);
1586         __swab64s (&o->o_ctime);
1587         __swab64s (&o->o_blocks);
1588         __swab64s (&o->o_grant);
1589         __swab32s (&o->o_blksize);
1590         __swab32s (&o->o_mode);
1591         __swab32s (&o->o_uid);
1592         __swab32s (&o->o_gid);
1593         __swab32s (&o->o_flags);
1594         __swab32s (&o->o_nlink);
1595         __swab32s (&o->o_parent_oid);
1596         __swab32s (&o->o_misc);
1597         __swab64s (&o->o_ioepoch);
1598         __swab32s (&o->o_stripe_idx);
1599         __swab32s (&o->o_parent_ver);
1600         /* o_handle is opaque */
1601         /* o_lcookie is swabbed elsewhere */
1602         __swab32s (&o->o_uid_h);
1603         __swab32s (&o->o_gid_h);
1604         CLASSERT(offsetof(typeof(*o), o_padding_3) != 0);
1605         CLASSERT(offsetof(typeof(*o), o_padding_4) != 0);
1606         CLASSERT(offsetof(typeof(*o), o_padding_5) != 0);
1607         CLASSERT(offsetof(typeof(*o), o_padding_6) != 0);
1608
1609 }
1610
1611 void lustre_swab_obd_statfs (struct obd_statfs *os)
1612 {
1613         __swab64s (&os->os_type);
1614         __swab64s (&os->os_blocks);
1615         __swab64s (&os->os_bfree);
1616         __swab64s (&os->os_bavail);
1617         __swab64s (&os->os_files);
1618         __swab64s (&os->os_ffree);
1619         /* no need to swab os_fsid */
1620         __swab32s (&os->os_bsize);
1621         __swab32s (&os->os_namelen);
1622         __swab64s (&os->os_maxbytes);
1623         __swab32s (&os->os_state);
1624         CLASSERT(offsetof(typeof(*os), os_spare1) != 0);
1625         CLASSERT(offsetof(typeof(*os), os_spare2) != 0);
1626         CLASSERT(offsetof(typeof(*os), os_spare3) != 0);
1627         CLASSERT(offsetof(typeof(*os), os_spare4) != 0);
1628         CLASSERT(offsetof(typeof(*os), os_spare5) != 0);
1629         CLASSERT(offsetof(typeof(*os), os_spare6) != 0);
1630         CLASSERT(offsetof(typeof(*os), os_spare7) != 0);
1631         CLASSERT(offsetof(typeof(*os), os_spare8) != 0);
1632         CLASSERT(offsetof(typeof(*os), os_spare9) != 0);
1633 }
1634
1635 void lustre_swab_obd_ioobj (struct obd_ioobj *ioo)
1636 {
1637         __swab64s (&ioo->ioo_id);
1638         __swab64s (&ioo->ioo_seq);
1639         __swab32s (&ioo->ioo_type);
1640         __swab32s (&ioo->ioo_bufcnt);
1641 }
1642
1643 void lustre_swab_niobuf_remote (struct niobuf_remote *nbr)
1644 {
1645         __swab64s (&nbr->offset);
1646         __swab32s (&nbr->len);
1647         __swab32s (&nbr->flags);
1648 }
1649
1650 void lustre_swab_ost_body (struct ost_body *b)
1651 {
1652         lustre_swab_obdo (&b->oa);
1653 }
1654
1655 void lustre_swab_ost_last_id(obd_id *id)
1656 {
1657         __swab64s(id);
1658 }
1659
1660 void lustre_swab_generic_32s(__u32 *val)
1661 {
1662         __swab32s(val);
1663 }
1664
1665 void lustre_swab_ost_lvb(struct ost_lvb *lvb)
1666 {
1667         __swab64s(&lvb->lvb_size);
1668         __swab64s(&lvb->lvb_mtime);
1669         __swab64s(&lvb->lvb_atime);
1670         __swab64s(&lvb->lvb_ctime);
1671         __swab64s(&lvb->lvb_blocks);
1672 }
1673
1674 void lustre_swab_mds_status_req (struct mds_status_req *r)
1675 {
1676         __swab32s (&r->flags);
1677         __swab32s (&r->repbuf);
1678 }
1679
1680 void lustre_swab_mds_body (struct mds_body *b)
1681 {
1682         lustre_swab_ll_fid (&b->fid1);
1683         lustre_swab_ll_fid (&b->fid2);
1684         /* handle is opaque */
1685         __swab64s (&b->valid);
1686         __swab64s (&b->size);
1687         __swab64s (&b->mtime);
1688         __swab64s (&b->atime);
1689         __swab64s (&b->ctime);
1690         __swab64s (&b->blocks);
1691         __swab64s (&b->io_epoch);
1692         __swab64s (&b->ino);
1693         __swab32s (&b->fsuid);
1694         __swab32s (&b->fsgid);
1695         __swab32s (&b->capability);
1696         __swab32s (&b->mode);
1697         __swab32s (&b->uid);
1698         __swab32s (&b->gid);
1699         __swab32s (&b->flags);
1700         __swab32s (&b->rdev);
1701         __swab32s (&b->nlink);
1702         __swab32s (&b->generation);
1703         __swab32s (&b->suppgid);
1704         __swab32s (&b->eadatasize);
1705         __swab32s (&b->aclsize);
1706         __swab32s (&b->max_mdsize);
1707         __swab32s (&b->max_cookiesize);
1708         CLASSERT(offsetof(typeof(*b), padding_4) != 0);
1709 }
1710
1711 void lustre_swab_mdt_body (struct mdt_body *b)
1712 {
1713         lustre_swab_lu_fid (&b->fid1);
1714         lustre_swab_lu_fid (&b->fid2);
1715         /* handle is opaque */
1716         __swab64s (&b->valid);
1717         __swab64s (&b->size);
1718         __swab64s (&b->mtime);
1719         __swab64s (&b->atime);
1720         __swab64s (&b->ctime);
1721         __swab64s (&b->blocks);
1722         __swab64s (&b->ioepoch);
1723         __swab64s (&b->ino);
1724         __swab32s (&b->fsuid);
1725         __swab32s (&b->fsgid);
1726         __swab32s (&b->capability);
1727         __swab32s (&b->mode);
1728         __swab32s (&b->uid);
1729         __swab32s (&b->gid);
1730         __swab32s (&b->flags);
1731         __swab32s (&b->rdev);
1732         __swab32s (&b->nlink);
1733         __swab32s (&b->generation);
1734         __swab32s (&b->suppgid);
1735         __swab32s (&b->eadatasize);
1736         __swab32s (&b->aclsize);
1737         __swab32s (&b->max_mdsize);
1738         __swab32s (&b->max_cookiesize);
1739         __swab32s (&b->uid_h);
1740         __swab32s (&b->gid_h);
1741         CLASSERT(offsetof(typeof(*b), padding_5) != 0);
1742 }
1743
1744 void lustre_swab_mdt_ioepoch (struct mdt_ioepoch *b)
1745 {
1746         /* handle is opaque */
1747          __swab64s (&b->ioepoch);
1748          __swab32s (&b->flags);
1749          CLASSERT(offsetof(typeof(*b), padding) != 0);
1750 }
1751
1752 void lustre_swab_mgs_target_info(struct mgs_target_info *mti)
1753 {
1754         int i;
1755         __swab32s(&mti->mti_lustre_ver);
1756         __swab32s(&mti->mti_stripe_index);
1757         __swab32s(&mti->mti_config_ver);
1758         __swab32s(&mti->mti_flags);
1759         __swab32s(&mti->mti_nid_count);
1760         CLASSERT(sizeof(lnet_nid_t) == sizeof(__u64));
1761         for (i = 0; i < MTI_NIDS_MAX; i++)
1762                 __swab64s(&mti->mti_nids[i]);
1763 }
1764
1765 static void lustre_swab_obd_dqinfo (struct obd_dqinfo *i)
1766 {
1767         __swab64s (&i->dqi_bgrace);
1768         __swab64s (&i->dqi_igrace);
1769         __swab32s (&i->dqi_flags);
1770         __swab32s (&i->dqi_valid);
1771 }
1772
1773 static void lustre_swab_obd_dqblk (struct obd_dqblk *b)
1774 {
1775         __swab64s (&b->dqb_ihardlimit);
1776         __swab64s (&b->dqb_isoftlimit);
1777         __swab64s (&b->dqb_curinodes);
1778         __swab64s (&b->dqb_bhardlimit);
1779         __swab64s (&b->dqb_bsoftlimit);
1780         __swab64s (&b->dqb_curspace);
1781         __swab64s (&b->dqb_btime);
1782         __swab64s (&b->dqb_itime);
1783         __swab32s (&b->dqb_valid);
1784         CLASSERT(offsetof(typeof(*b), padding) != 0);
1785 }
1786
1787 void lustre_swab_obd_quotactl (struct obd_quotactl *q)
1788 {
1789         __swab32s (&q->qc_cmd);
1790         __swab32s (&q->qc_type);
1791         __swab32s (&q->qc_id);
1792         __swab32s (&q->qc_stat);
1793         lustre_swab_obd_dqinfo (&q->qc_dqinfo);
1794         lustre_swab_obd_dqblk (&q->qc_dqblk);
1795 }
1796
1797 void lustre_swab_quota_adjust_qunit (struct quota_adjust_qunit *q)
1798 {
1799         __swab32s (&q->qaq_flags);
1800         __swab32s (&q->qaq_id);
1801         __swab64s (&q->qaq_bunit_sz);
1802         __swab64s (&q->qaq_iunit_sz);
1803         __swab64s (&q->padding1);
1804 }
1805
1806 void lustre_swab_mds_remote_perm (struct mds_remote_perm *p)
1807 {
1808         __swab32s (&p->rp_uid);
1809         __swab32s (&p->rp_gid);
1810         __swab32s (&p->rp_fsuid);
1811         __swab32s (&p->rp_fsgid);
1812         __swab32s (&p->rp_access_perm);
1813 };
1814
1815 void lustre_swab_mdt_remote_perm (struct mdt_remote_perm *p)
1816 {
1817         __swab32s (&p->rp_uid);
1818         __swab32s (&p->rp_gid);
1819         __swab32s (&p->rp_fsuid);
1820         __swab32s (&p->rp_fsuid_h);
1821         __swab32s (&p->rp_fsgid);
1822         __swab32s (&p->rp_fsgid_h);
1823         __swab32s (&p->rp_access_perm);
1824 };
1825
1826 void lustre_swab_fid2path(struct getinfo_fid2path *gf)
1827 {
1828         lustre_swab_lu_fid(&gf->gf_fid);
1829         __swab64s(&gf->gf_recno);
1830         __swab32s(&gf->gf_linkno);
1831         __swab32s(&gf->gf_pathlen);
1832 }
1833 EXPORT_SYMBOL(lustre_swab_fid2path);
1834
1835 void lustre_swab_fiemap_extent(struct ll_fiemap_extent *fm_extent)
1836 {
1837         __swab64s(&fm_extent->fe_logical);
1838         __swab64s(&fm_extent->fe_physical);
1839         __swab64s(&fm_extent->fe_length);
1840         __swab32s(&fm_extent->fe_flags);
1841         __swab32s(&fm_extent->fe_device);
1842 }
1843
1844 void lustre_swab_fiemap(struct ll_user_fiemap *fiemap)
1845 {
1846         int i;
1847
1848         __swab64s(&fiemap->fm_start);
1849         __swab64s(&fiemap->fm_length);
1850         __swab32s(&fiemap->fm_flags);
1851         __swab32s(&fiemap->fm_mapped_extents);
1852         __swab32s(&fiemap->fm_extent_count);
1853         __swab32s(&fiemap->fm_reserved);
1854
1855         for (i = 0; i < fiemap->fm_mapped_extents; i++)
1856                 lustre_swab_fiemap_extent(&fiemap->fm_extents[i]);
1857 }
1858
1859 void lustre_swab_mdt_rec_reint (struct mdt_rec_reint *rr)
1860 {
1861         __swab32s (&rr->rr_opcode);
1862         __swab32s (&rr->rr_cap);
1863         __swab32s (&rr->rr_fsuid);
1864         /* rr_fsuid_h is unused */
1865         __swab32s (&rr->rr_fsgid);
1866         /* rr_fsgid_h is unused */
1867         __swab32s (&rr->rr_suppgid1);
1868         /* rr_suppgid1_h is unused */
1869         __swab32s (&rr->rr_suppgid2);
1870         /* rr_suppgid2_h is unused */
1871         lustre_swab_lu_fid (&rr->rr_fid1);
1872         lustre_swab_lu_fid (&rr->rr_fid2);
1873         __swab64s (&rr->rr_mtime);
1874         __swab64s (&rr->rr_atime);
1875         __swab64s (&rr->rr_ctime);
1876         __swab64s (&rr->rr_size);
1877         __swab64s (&rr->rr_blocks);
1878         __swab32s (&rr->rr_bias);
1879         __swab32s (&rr->rr_mode);
1880         __swab32s (&rr->rr_flags);
1881
1882         CLASSERT(offsetof(typeof(*rr), rr_padding_2) != 0);
1883         CLASSERT(offsetof(typeof(*rr), rr_padding_3) != 0);
1884         CLASSERT(offsetof(typeof(*rr), rr_padding_4) != 0);
1885 };
1886
1887 void lustre_swab_lov_desc (struct lov_desc *ld)
1888 {
1889         __swab32s (&ld->ld_tgt_count);
1890         __swab32s (&ld->ld_active_tgt_count);
1891         __swab32s (&ld->ld_default_stripe_count);
1892         __swab32s (&ld->ld_pattern);
1893         __swab64s (&ld->ld_default_stripe_size);
1894         __swab64s (&ld->ld_default_stripe_offset);
1895         __swab32s (&ld->ld_qos_maxage);
1896         /* uuid endian insensitive */
1897 }
1898
1899 void lustre_swab_lmv_desc (struct lmv_desc *ld)
1900 {
1901         __swab32s (&ld->ld_tgt_count);
1902         __swab32s (&ld->ld_active_tgt_count);
1903         __swab32s (&ld->ld_default_stripe_count);
1904         __swab32s (&ld->ld_pattern);
1905         __swab64s (&ld->ld_default_hash_size);
1906         __swab32s (&ld->ld_qos_maxage);
1907         /* uuid endian insensitive */
1908 }
1909
1910 void lustre_swab_lmv_stripe_md (struct lmv_stripe_md *mea)
1911 {
1912         __swab32s(&mea->mea_magic);
1913         __swab32s(&mea->mea_count);
1914         __swab32s(&mea->mea_master);
1915         CLASSERT(offsetof(typeof(*mea), mea_padding) != 0);
1916 }
1917
1918
1919 static void print_lum (struct lov_user_md *lum)
1920 {
1921         CDEBUG(D_OTHER, "lov_user_md %p:\n", lum);
1922         CDEBUG(D_OTHER, "\tlmm_magic: %#x\n", lum->lmm_magic);
1923         CDEBUG(D_OTHER, "\tlmm_pattern: %#x\n", lum->lmm_pattern);
1924         CDEBUG(D_OTHER, "\tlmm_object_id: "LPU64"\n", lum->lmm_object_id);
1925         CDEBUG(D_OTHER, "\tlmm_object_gr: "LPU64"\n", lum->lmm_object_seq);
1926         CDEBUG(D_OTHER, "\tlmm_stripe_size: %#x\n", lum->lmm_stripe_size);
1927         CDEBUG(D_OTHER, "\tlmm_stripe_count: %#x\n", lum->lmm_stripe_count);
1928         CDEBUG(D_OTHER, "\tlmm_stripe_offset: %#x\n", lum->lmm_stripe_offset);
1929 }
1930
1931 static void lustre_swab_lov_user_md_common(struct lov_user_md_v1 *lum)
1932 {
1933         ENTRY;
1934         __swab32s(&lum->lmm_magic);
1935         __swab32s(&lum->lmm_pattern);
1936         __swab64s(&lum->lmm_object_id);
1937         __swab64s(&lum->lmm_object_seq);
1938         __swab32s(&lum->lmm_stripe_size);
1939         __swab16s(&lum->lmm_stripe_count);
1940         __swab16s(&lum->lmm_stripe_offset);
1941         print_lum(lum);
1942         EXIT;
1943 }
1944
1945 void lustre_swab_lov_user_md_v1(struct lov_user_md_v1 *lum)
1946 {
1947         ENTRY;
1948         CDEBUG(D_IOCTL, "swabbing lov_user_md v1\n");
1949         lustre_swab_lov_user_md_common(lum);
1950         EXIT;
1951 }
1952
1953 void lustre_swab_lov_user_md_v3(struct lov_user_md_v3 *lum)
1954 {
1955         ENTRY;
1956         CDEBUG(D_IOCTL, "swabbing lov_user_md v3\n");
1957         lustre_swab_lov_user_md_common((struct lov_user_md_v1 *)lum);
1958         /* lmm_pool_name nothing to do with char */
1959         EXIT;
1960 }
1961
1962 void lustre_swab_lov_mds_md(struct lov_mds_md *lmm)
1963 {
1964         ENTRY;
1965         CDEBUG(D_IOCTL, "swabbing lov_mds_md\n");
1966         __swab32s(&lmm->lmm_magic);
1967         __swab32s(&lmm->lmm_pattern);
1968         __swab64s(&lmm->lmm_object_id);
1969         __swab64s(&lmm->lmm_object_seq);
1970         __swab32s(&lmm->lmm_stripe_size);
1971         __swab32s(&lmm->lmm_stripe_count);
1972         EXIT;
1973 }
1974
1975 void lustre_swab_lov_user_md_objects(struct lov_user_ost_data *lod,
1976                                      int stripe_count)
1977 {
1978         int i;
1979         ENTRY;
1980         for (i = 0; i < stripe_count; i++) {
1981                 __swab64s(&(lod[i].l_object_id));
1982                 __swab64s(&(lod[i].l_object_seq));
1983                 __swab32s(&(lod[i].l_ost_gen));
1984                 __swab32s(&(lod[i].l_ost_idx));
1985         }
1986         EXIT;
1987 }
1988
1989
1990 void lustre_swab_ldlm_res_id (struct ldlm_res_id *id)
1991 {
1992         int  i;
1993
1994         for (i = 0; i < RES_NAME_SIZE; i++)
1995                 __swab64s (&id->name[i]);
1996 }
1997
1998 void lustre_swab_ldlm_policy_data (ldlm_policy_data_t *d)
1999 {
2000         /* the lock data is a union and the first two fields are always an
2001          * extent so it's ok to process an LDLM_EXTENT and LDLM_FLOCK lock
2002          * data the same way. */
2003         __swab64s(&d->l_extent.start);
2004         __swab64s(&d->l_extent.end);
2005         __swab64s(&d->l_extent.gid);
2006         __swab32s(&d->l_flock.pid);
2007 }
2008
2009 void lustre_swab_ldlm_intent (struct ldlm_intent *i)
2010 {
2011         __swab64s (&i->opc);
2012 }
2013
2014 void lustre_swab_ldlm_resource_desc (struct ldlm_resource_desc *r)
2015 {
2016         __swab32s (&r->lr_type);
2017         CLASSERT(offsetof(typeof(*r), lr_padding) != 0);
2018         lustre_swab_ldlm_res_id (&r->lr_name);
2019 }
2020
2021 void lustre_swab_ldlm_lock_desc (struct ldlm_lock_desc *l)
2022 {
2023         lustre_swab_ldlm_resource_desc (&l->l_resource);
2024         __swab32s (&l->l_req_mode);
2025         __swab32s (&l->l_granted_mode);
2026         lustre_swab_ldlm_policy_data (&l->l_policy_data);
2027 }
2028
2029 void lustre_swab_ldlm_request (struct ldlm_request *rq)
2030 {
2031         __swab32s (&rq->lock_flags);
2032         lustre_swab_ldlm_lock_desc (&rq->lock_desc);
2033         __swab32s (&rq->lock_count);
2034         /* lock_handle[] opaque */
2035 }
2036
2037 void lustre_swab_ldlm_reply (struct ldlm_reply *r)
2038 {
2039         __swab32s (&r->lock_flags);
2040         CLASSERT(offsetof(typeof(*r), lock_padding) != 0);
2041         lustre_swab_ldlm_lock_desc (&r->lock_desc);
2042         /* lock_handle opaque */
2043         __swab64s (&r->lock_policy_res1);
2044         __swab64s (&r->lock_policy_res2);
2045 }
2046
2047 /* no one calls this */
2048 int llog_log_swabbed(struct llog_log_hdr *hdr)
2049 {
2050         if (hdr->llh_hdr.lrh_type == __swab32(LLOG_HDR_MAGIC))
2051                 return 1;
2052         if (hdr->llh_hdr.lrh_type == LLOG_HDR_MAGIC)
2053                 return 0;
2054         return -1;
2055 }
2056
2057 void lustre_swab_qdata(struct qunit_data *d)
2058 {
2059         __swab32s (&d->qd_id);
2060         __swab32s (&d->qd_flags);
2061         __swab64s (&d->qd_count);
2062         __swab64s (&d->qd_qunit);
2063         CLASSERT(offsetof(typeof(*d), padding) != 0);
2064 }
2065
2066 /* Dump functions */
2067 void dump_ioo(struct obd_ioobj *ioo)
2068 {
2069         CDEBUG(D_RPCTRACE,
2070                "obd_ioobj: ioo_id="LPD64", ioo_seq="LPD64", ioo_type=%d, "
2071                "ioo_bufct=%d\n", ioo->ioo_id, ioo->ioo_seq, ioo->ioo_type,
2072                ioo->ioo_bufcnt);
2073 }
2074
2075 void dump_rniobuf(struct niobuf_remote *nb)
2076 {
2077         CDEBUG(D_RPCTRACE, "niobuf_remote: offset="LPU64", len=%d, flags=%x\n",
2078                nb->offset, nb->len, nb->flags);
2079 }
2080
2081 void dump_obdo(struct obdo *oa)
2082 {
2083         __u32 valid = oa->o_valid;
2084
2085         CDEBUG(D_RPCTRACE, "obdo: o_valid = %08x\n", valid);
2086         if (valid & OBD_MD_FLID)
2087                 CDEBUG(D_RPCTRACE, "obdo: o_id = "LPD64"\n", oa->o_id);
2088         if (valid & OBD_MD_FLGROUP)
2089                 CDEBUG(D_RPCTRACE, "obdo: o_seq = "LPD64"\n", oa->o_seq);
2090         if (valid & OBD_MD_FLFID)
2091                 CDEBUG(D_RPCTRACE, "obdo: o_parent_seq = "LPX64"\n",
2092                        oa->o_parent_seq);
2093         if (valid & OBD_MD_FLSIZE)
2094                 CDEBUG(D_RPCTRACE, "obdo: o_size = "LPD64"\n", oa->o_size);
2095         if (valid & OBD_MD_FLMTIME)
2096                 CDEBUG(D_RPCTRACE, "obdo: o_mtime = "LPD64"\n", oa->o_mtime);
2097         if (valid & OBD_MD_FLATIME)
2098                 CDEBUG(D_RPCTRACE, "obdo: o_atime = "LPD64"\n", oa->o_atime);
2099         if (valid & OBD_MD_FLCTIME)
2100                 CDEBUG(D_RPCTRACE, "obdo: o_ctime = "LPD64"\n", oa->o_ctime);
2101         if (valid & OBD_MD_FLBLOCKS)   /* allocation of space */
2102                 CDEBUG(D_RPCTRACE, "obdo: o_blocks = "LPD64"\n", oa->o_blocks);
2103         if (valid & OBD_MD_FLGRANT)
2104                 CDEBUG(D_RPCTRACE, "obdo: o_grant = "LPD64"\n", oa->o_grant);
2105         if (valid & OBD_MD_FLBLKSZ)
2106                 CDEBUG(D_RPCTRACE, "obdo: o_blksize = %d\n", oa->o_blksize);
2107         if (valid & (OBD_MD_FLTYPE | OBD_MD_FLMODE))
2108                 CDEBUG(D_RPCTRACE, "obdo: o_mode = %o\n",
2109                        oa->o_mode & ((valid & OBD_MD_FLTYPE ?  S_IFMT : 0) |
2110                                      (valid & OBD_MD_FLMODE ? ~S_IFMT : 0)));
2111         if (valid & OBD_MD_FLUID)
2112                 CDEBUG(D_RPCTRACE, "obdo: o_uid = %u\n", oa->o_uid);
2113         if (valid & OBD_MD_FLUID)
2114                 CDEBUG(D_RPCTRACE, "obdo: o_uid_h = %u\n", oa->o_uid_h);
2115         if (valid & OBD_MD_FLGID)
2116                 CDEBUG(D_RPCTRACE, "obdo: o_gid = %u\n", oa->o_gid);
2117         if (valid & OBD_MD_FLGID)
2118                 CDEBUG(D_RPCTRACE, "obdo: o_gid_h = %u\n", oa->o_gid_h);
2119         if (valid & OBD_MD_FLFLAGS)
2120                 CDEBUG(D_RPCTRACE, "obdo: o_flags = %x\n", oa->o_flags);
2121         if (valid & OBD_MD_FLNLINK)
2122                 CDEBUG(D_RPCTRACE, "obdo: o_nlink = %u\n", oa->o_nlink);
2123         else if (valid & OBD_MD_FLCKSUM)
2124                 CDEBUG(D_RPCTRACE, "obdo: o_checksum (o_nlink) = %u\n",
2125                        oa->o_nlink);
2126         if (valid & OBD_MD_FLGENER)
2127                 CDEBUG(D_RPCTRACE, "obdo: o_parent_oid = %x\n",
2128                        oa->o_parent_oid);
2129         if (valid & OBD_MD_FLEPOCH)
2130                 CDEBUG(D_RPCTRACE, "obdo: o_ioepoch = "LPD64"\n",
2131                        oa->o_ioepoch);
2132         if (valid & OBD_MD_FLFID) {
2133                 CDEBUG(D_RPCTRACE, "obdo: o_stripe_idx = %u\n",
2134                        oa->o_stripe_idx);
2135                 CDEBUG(D_RPCTRACE, "obdo: o_parent_ver = %x\n",
2136                        oa->o_parent_ver);
2137         }
2138         if (valid & OBD_MD_FLHANDLE)
2139                 CDEBUG(D_RPCTRACE, "obdo: o_handle = "LPD64"\n",
2140                        oa->o_handle.cookie);
2141         if (valid & OBD_MD_FLCOOKIE)
2142                 CDEBUG(D_RPCTRACE, "obdo: o_lcookie = "
2143                        "(llog_cookie dumping not yet implemented)\n");
2144 }
2145
2146 void dump_ost_body(struct ost_body *ob)
2147 {
2148         dump_obdo(&ob->oa);
2149 }
2150
2151 void dump_rcs(__u32 *rc)
2152 {
2153         CDEBUG(D_RPCTRACE, "rmf_rcs: %d\n", *rc);
2154 }
2155
2156 #ifdef __KERNEL__
2157
2158 /**
2159  * got qdata from request(req/rep)
2160  */
2161 struct qunit_data *quota_get_qdata(void *r, int is_req, int is_exp)
2162 {
2163         struct ptlrpc_request *req = (struct ptlrpc_request *)r;
2164         struct qunit_data *qdata;
2165         __u64  flags = is_exp ? req->rq_export->exp_connect_flags :
2166                        req->rq_import->imp_connect_data.ocd_connect_flags;
2167
2168         LASSERT(req);
2169         /* support for quota64 */
2170         LASSERT(flags & OBD_CONNECT_QUOTA64);
2171         /* support for change_qs */
2172         LASSERT(flags & OBD_CONNECT_CHANGE_QS);
2173
2174         if (is_req == QUOTA_REQUEST)
2175                 qdata = req_capsule_client_get(&req->rq_pill, &RMF_QUNIT_DATA);
2176         else
2177                 qdata = req_capsule_server_get(&req->rq_pill, &RMF_QUNIT_DATA);
2178         if (qdata == NULL)
2179                 return ERR_PTR(-EPROTO);
2180
2181         QDATA_SET_CHANGE_QS(qdata);
2182         return qdata;
2183 }
2184 EXPORT_SYMBOL(quota_get_qdata);
2185
2186 /**
2187  * copy qdata to request(req/rep)
2188  */
2189 int quota_copy_qdata(void *r, struct qunit_data *qdata, int is_req,
2190                      int is_exp)
2191 {
2192         struct ptlrpc_request *req = (struct ptlrpc_request *)r;
2193         void *target;
2194         __u64  flags = is_exp ? req->rq_export->exp_connect_flags :
2195                 req->rq_import->imp_connect_data.ocd_connect_flags;
2196
2197         LASSERT(req);
2198         LASSERT(qdata);
2199         /* support for quota64 */
2200         LASSERT(flags & OBD_CONNECT_QUOTA64);
2201         /* support for change_qs */
2202         LASSERT(flags & OBD_CONNECT_CHANGE_QS);
2203
2204         if (is_req == QUOTA_REQUEST)
2205                 target = req_capsule_client_get(&req->rq_pill, &RMF_QUNIT_DATA);
2206         else
2207                 target = req_capsule_server_get(&req->rq_pill, &RMF_QUNIT_DATA);
2208         if (target == NULL)
2209                 return -EPROTO;
2210
2211         LASSERT(target != qdata);
2212         memcpy(target, qdata, sizeof(*qdata));
2213         return 0;
2214 }
2215 EXPORT_SYMBOL(quota_copy_qdata);
2216 #endif /* __KERNEL__ */
2217
2218 static inline int req_ptlrpc_body_swabbed(struct ptlrpc_request *req)
2219 {
2220         LASSERT(req->rq_reqmsg);
2221
2222         switch (req->rq_reqmsg->lm_magic) {
2223         case LUSTRE_MSG_MAGIC_V2:
2224                 return lustre_req_swabbed(req, MSG_PTLRPC_BODY_OFF);
2225         default:
2226                 CERROR("bad lustre msg magic: %#08X\n",
2227                        req->rq_reqmsg->lm_magic);
2228         }
2229         return 0;
2230 }
2231
2232 static inline int rep_ptlrpc_body_swabbed(struct ptlrpc_request *req)
2233 {
2234         LASSERT(req->rq_repmsg);
2235
2236         switch (req->rq_repmsg->lm_magic) {
2237         case LUSTRE_MSG_MAGIC_V2:
2238                 return lustre_rep_swabbed(req, MSG_PTLRPC_BODY_OFF);
2239         default:
2240                 /* uninitialized yet */
2241                 return 0;
2242         }
2243 }
2244
2245 void _debug_req(struct ptlrpc_request *req, __u32 mask,
2246                 struct libcfs_debug_msg_data *data, const char *fmt, ... )
2247 {
2248         va_list args;
2249         va_start(args, fmt);
2250         libcfs_debug_vmsg2(data->msg_cdls, data->msg_subsys, mask, data->msg_file,
2251                            data->msg_fn, data->msg_line, fmt, args,
2252                            " req@%p x"LPU64"/t"LPD64"("LPD64") o%d->%s@%s:%d/%d"
2253                            " lens %d/%d e %d to %d dl "CFS_TIME_T" ref %d "
2254                            "fl "REQ_FLAGS_FMT"/%x/%x rc %d/%d\n",
2255                            req, req->rq_xid, req->rq_transno,
2256                            req->rq_reqmsg ? lustre_msg_get_transno(req->rq_reqmsg) : 0,
2257                            req->rq_reqmsg && req_ptlrpc_body_swabbed(req) ?
2258                            lustre_msg_get_opc(req->rq_reqmsg) : -1,
2259                            req->rq_import ? obd2cli_tgt(req->rq_import->imp_obd) :
2260                            req->rq_export ?
2261                            (char*)req->rq_export->exp_client_uuid.uuid : "<?>",
2262                            req->rq_import ?
2263                            (char *)req->rq_import->imp_connection->c_remote_uuid.uuid :
2264                            req->rq_export ?
2265                            (char *)req->rq_export->exp_connection->c_remote_uuid.uuid : "<?>",
2266                            req->rq_request_portal, req->rq_reply_portal,
2267                            req->rq_reqlen, req->rq_replen,
2268                            req->rq_early_count, req->rq_timedout,
2269                            req->rq_deadline,
2270                            cfs_atomic_read(&req->rq_refcount),
2271                            DEBUG_REQ_FLAGS(req),
2272                            req->rq_reqmsg && req_ptlrpc_body_swabbed(req) ?
2273                            lustre_msg_get_flags(req->rq_reqmsg) : -1,
2274                            req->rq_repmsg && rep_ptlrpc_body_swabbed(req) ?
2275                            lustre_msg_get_flags(req->rq_repmsg) : -1,
2276                            req->rq_status,
2277                            req->rq_repmsg && rep_ptlrpc_body_swabbed(req) ?
2278                            lustre_msg_get_status(req->rq_repmsg) : -1);
2279 }
2280 EXPORT_SYMBOL(_debug_req);
2281
2282 void lustre_swab_lustre_capa(struct lustre_capa *c)
2283 {
2284         lustre_swab_lu_fid(&c->lc_fid);
2285         __swab64s (&c->lc_opc);
2286         __swab64s (&c->lc_uid);
2287         __swab64s (&c->lc_gid);
2288         __swab32s (&c->lc_flags);
2289         __swab32s (&c->lc_keyid);
2290         __swab32s (&c->lc_timeout);
2291         __swab32s (&c->lc_expiry);
2292 }
2293
2294 void lustre_swab_lustre_capa_key(struct lustre_capa_key *k)
2295 {
2296         __swab64s (&k->lk_seq);
2297         __swab32s (&k->lk_keyid);
2298         CLASSERT(offsetof(typeof(*k), lk_padding) != 0);
2299 }
2300
2301 void lustre_swab_hsm_state(struct hsm_state_set_ioc *hssi)
2302 {
2303         lustre_swab_lu_fid(&hssi->hssi_fid);
2304         __swab64s(&hssi->hssi_setmask);
2305         __swab64s(&hssi->hssi_clearmask);
2306 }
2307 EXPORT_SYMBOL(lustre_swab_hsm_state);
2308
2309 void lustre_swab_hsm_user_request(struct hsm_user_request *hur)
2310 {
2311         int i;
2312
2313         __swab32s(&hur->hur_action);
2314         __swab32s(&hur->hur_itemcount);
2315         __swab32s(&hur->hur_data_len);
2316         for (i = 0; i < hur->hur_itemcount; i++) {
2317                 struct hsm_user_item *hui = &hur->hur_user_item[i];
2318                 lustre_swab_lu_fid(&hui->hui_fid);
2319                 __swab64s(&hui->hui_extent.offset);
2320                 __swab64s(&hui->hui_extent.length);
2321         }
2322         /* Note: data blob is not swabbed here */
2323 }
2324 EXPORT_SYMBOL(lustre_swab_hsm_user_request);
2325
2326 void lustre_swab_hsm_progress(struct hsm_progress *hp)
2327 {
2328         lustre_swab_lu_fid(&hp->hp_fid);
2329         __swab64s(&hp->hp_cookie);
2330         __swab64s(&hp->hp_extent.offset);
2331         __swab64s(&hp->hp_extent.length);
2332         __swab16s(&hp->hp_flags);
2333         __swab16s(&hp->hp_errval);
2334 }
2335 EXPORT_SYMBOL(lustre_swab_hsm_progress);
2336
2337