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