1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45#define DEBUG_SUBSYSTEM S_RPC
46
47#include <linux/libcfs/libcfs.h>
48
49#include <obd_support.h>
50#include <obd_class.h>
51#include <lustre_net.h>
52#include <obd_cksum.h>
53#include <lustre/ll_fiemap.h>
54
55static inline int lustre_msg_hdr_size_v2(int count)
56{
57 return cfs_size_round(offsetof(struct lustre_msg_v2,
58 lm_buflens[count]));
59}
60
61int lustre_msg_hdr_size(__u32 magic, int count)
62{
63 switch (magic) {
64 case LUSTRE_MSG_MAGIC_V2:
65 return lustre_msg_hdr_size_v2(count);
66 default:
67 LASSERTF(0, "incorrect message magic: %08x\n", magic);
68 return -EINVAL;
69 }
70}
71EXPORT_SYMBOL(lustre_msg_hdr_size);
72
73void ptlrpc_buf_set_swabbed(struct ptlrpc_request *req, const int inout,
74 int index)
75{
76 if (inout)
77 lustre_set_req_swabbed(req, index);
78 else
79 lustre_set_rep_swabbed(req, index);
80}
81EXPORT_SYMBOL(ptlrpc_buf_set_swabbed);
82
83int ptlrpc_buf_need_swab(struct ptlrpc_request *req, const int inout,
84 int index)
85{
86 if (inout)
87 return (ptlrpc_req_need_swab(req) &&
88 !lustre_req_swabbed(req, index));
89 else
90 return (ptlrpc_rep_need_swab(req) &&
91 !lustre_rep_swabbed(req, index));
92}
93EXPORT_SYMBOL(ptlrpc_buf_need_swab);
94
95static inline int lustre_msg_check_version_v2(struct lustre_msg_v2 *msg,
96 __u32 version)
97{
98 __u32 ver = lustre_msg_get_version(msg);
99 return (ver & LUSTRE_VERSION_MASK) != version;
100}
101
102int lustre_msg_check_version(struct lustre_msg *msg, __u32 version)
103{
104 switch (msg->lm_magic) {
105 case LUSTRE_MSG_MAGIC_V1:
106 CERROR("msg v1 not supported - please upgrade you system\n");
107 return -EINVAL;
108 case LUSTRE_MSG_MAGIC_V2:
109 return lustre_msg_check_version_v2(msg, version);
110 default:
111 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
112 return 0;
113 }
114}
115EXPORT_SYMBOL(lustre_msg_check_version);
116
117
118int lustre_msg_early_size(void)
119{
120 static int size = 0;
121 if (!size) {
122
123
124
125
126
127
128
129 __u32 pblen = sizeof(struct ptlrpc_body_v2);
130 size = lustre_msg_size(LUSTRE_MSG_MAGIC_V2, 1, &pblen);
131 }
132 return size;
133}
134EXPORT_SYMBOL(lustre_msg_early_size);
135
136int lustre_msg_size_v2(int count, __u32 *lengths)
137{
138 int size;
139 int i;
140
141 size = lustre_msg_hdr_size_v2(count);
142 for (i = 0; i < count; i++)
143 size += cfs_size_round(lengths[i]);
144
145 return size;
146}
147EXPORT_SYMBOL(lustre_msg_size_v2);
148
149
150
151
152
153
154
155int lustre_msg_size(__u32 magic, int count, __u32 *lens)
156{
157 __u32 size[] = { sizeof(struct ptlrpc_body) };
158
159 if (!lens) {
160 LASSERT(count == 1);
161 lens = size;
162 }
163
164 LASSERT(count > 0);
165 LASSERT(lens[MSG_PTLRPC_BODY_OFF] >= sizeof(struct ptlrpc_body_v2));
166
167 switch (magic) {
168 case LUSTRE_MSG_MAGIC_V2:
169 return lustre_msg_size_v2(count, lens);
170 default:
171 LASSERTF(0, "incorrect message magic: %08x\n", magic);
172 return -EINVAL;
173 }
174}
175EXPORT_SYMBOL(lustre_msg_size);
176
177
178
179int lustre_packed_msg_size(struct lustre_msg *msg)
180{
181 switch (msg->lm_magic) {
182 case LUSTRE_MSG_MAGIC_V2:
183 return lustre_msg_size_v2(msg->lm_bufcount, msg->lm_buflens);
184 default:
185 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
186 return 0;
187 }
188}
189EXPORT_SYMBOL(lustre_packed_msg_size);
190
191void lustre_init_msg_v2(struct lustre_msg_v2 *msg, int count, __u32 *lens,
192 char **bufs)
193{
194 char *ptr;
195 int i;
196
197 msg->lm_bufcount = count;
198
199 msg->lm_magic = LUSTRE_MSG_MAGIC_V2;
200
201 for (i = 0; i < count; i++)
202 msg->lm_buflens[i] = lens[i];
203
204 if (bufs == NULL)
205 return;
206
207 ptr = (char *)msg + lustre_msg_hdr_size_v2(count);
208 for (i = 0; i < count; i++) {
209 char *tmp = bufs[i];
210 LOGL(tmp, lens[i], ptr);
211 }
212}
213EXPORT_SYMBOL(lustre_init_msg_v2);
214
215static int lustre_pack_request_v2(struct ptlrpc_request *req,
216 int count, __u32 *lens, char **bufs)
217{
218 int reqlen, rc;
219
220 reqlen = lustre_msg_size_v2(count, lens);
221
222 rc = sptlrpc_cli_alloc_reqbuf(req, reqlen);
223 if (rc)
224 return rc;
225
226 req->rq_reqlen = reqlen;
227
228 lustre_init_msg_v2(req->rq_reqmsg, count, lens, bufs);
229 lustre_msg_add_version(req->rq_reqmsg, PTLRPC_MSG_VERSION);
230 return 0;
231}
232
233int lustre_pack_request(struct ptlrpc_request *req, __u32 magic, int count,
234 __u32 *lens, char **bufs)
235{
236 __u32 size[] = { sizeof(struct ptlrpc_body) };
237
238 if (!lens) {
239 LASSERT(count == 1);
240 lens = size;
241 }
242
243 LASSERT(count > 0);
244 LASSERT(lens[MSG_PTLRPC_BODY_OFF] == sizeof(struct ptlrpc_body));
245
246
247 magic = LUSTRE_MSG_MAGIC_V2;
248
249 switch (magic) {
250 case LUSTRE_MSG_MAGIC_V2:
251 return lustre_pack_request_v2(req, count, lens, bufs);
252 default:
253 LASSERTF(0, "incorrect message magic: %08x\n", magic);
254 return -EINVAL;
255 }
256}
257EXPORT_SYMBOL(lustre_pack_request);
258
259#if RS_DEBUG
260LIST_HEAD(ptlrpc_rs_debug_lru);
261spinlock_t ptlrpc_rs_debug_lock;
262
263#define PTLRPC_RS_DEBUG_LRU_ADD(rs) \
264do { \
265 spin_lock(&ptlrpc_rs_debug_lock); \
266 list_add_tail(&(rs)->rs_debug_list, &ptlrpc_rs_debug_lru); \
267 spin_unlock(&ptlrpc_rs_debug_lock); \
268} while (0)
269
270#define PTLRPC_RS_DEBUG_LRU_DEL(rs) \
271do { \
272 spin_lock(&ptlrpc_rs_debug_lock); \
273 list_del(&(rs)->rs_debug_list); \
274 spin_unlock(&ptlrpc_rs_debug_lock); \
275} while (0)
276#else
277# define PTLRPC_RS_DEBUG_LRU_ADD(rs) do {} while(0)
278# define PTLRPC_RS_DEBUG_LRU_DEL(rs) do {} while(0)
279#endif
280
281struct ptlrpc_reply_state *
282lustre_get_emerg_rs(struct ptlrpc_service_part *svcpt)
283{
284 struct ptlrpc_reply_state *rs = NULL;
285
286 spin_lock(&svcpt->scp_rep_lock);
287
288
289 while (list_empty(&svcpt->scp_rep_idle)) {
290 struct l_wait_info lwi;
291 int rc;
292
293 spin_unlock(&svcpt->scp_rep_lock);
294
295
296 lwi = LWI_TIMEOUT(cfs_time_seconds(10), NULL, NULL);
297 rc = l_wait_event(svcpt->scp_rep_waitq,
298 !list_empty(&svcpt->scp_rep_idle), &lwi);
299 if (rc != 0)
300 goto out;
301 spin_lock(&svcpt->scp_rep_lock);
302 }
303
304 rs = list_entry(svcpt->scp_rep_idle.next,
305 struct ptlrpc_reply_state, rs_list);
306 list_del(&rs->rs_list);
307
308 spin_unlock(&svcpt->scp_rep_lock);
309
310 memset(rs, 0, svcpt->scp_service->srv_max_reply_size);
311 rs->rs_svcpt = svcpt;
312 rs->rs_prealloc = 1;
313out:
314 return rs;
315}
316
317void lustre_put_emerg_rs(struct ptlrpc_reply_state *rs)
318{
319 struct ptlrpc_service_part *svcpt = rs->rs_svcpt;
320
321 spin_lock(&svcpt->scp_rep_lock);
322 list_add(&rs->rs_list, &svcpt->scp_rep_idle);
323 spin_unlock(&svcpt->scp_rep_lock);
324 wake_up(&svcpt->scp_rep_waitq);
325}
326
327int lustre_pack_reply_v2(struct ptlrpc_request *req, int count,
328 __u32 *lens, char **bufs, int flags)
329{
330 struct ptlrpc_reply_state *rs;
331 int msg_len, rc;
332
333 LASSERT(req->rq_reply_state == NULL);
334
335 if ((flags & LPRFL_EARLY_REPLY) == 0) {
336 spin_lock(&req->rq_lock);
337 req->rq_packed_final = 1;
338 spin_unlock(&req->rq_lock);
339 }
340
341 msg_len = lustre_msg_size_v2(count, lens);
342 rc = sptlrpc_svc_alloc_rs(req, msg_len);
343 if (rc)
344 return rc;
345
346 rs = req->rq_reply_state;
347 atomic_set(&rs->rs_refcount, 1);
348 rs->rs_cb_id.cbid_fn = reply_out_callback;
349 rs->rs_cb_id.cbid_arg = rs;
350 rs->rs_svcpt = req->rq_rqbd->rqbd_svcpt;
351 INIT_LIST_HEAD(&rs->rs_exp_list);
352 INIT_LIST_HEAD(&rs->rs_obd_list);
353 INIT_LIST_HEAD(&rs->rs_list);
354 spin_lock_init(&rs->rs_lock);
355
356 req->rq_replen = msg_len;
357 req->rq_reply_state = rs;
358 req->rq_repmsg = rs->rs_msg;
359
360 lustre_init_msg_v2(rs->rs_msg, count, lens, bufs);
361 lustre_msg_add_version(rs->rs_msg, PTLRPC_MSG_VERSION);
362
363 PTLRPC_RS_DEBUG_LRU_ADD(rs);
364
365 return 0;
366}
367EXPORT_SYMBOL(lustre_pack_reply_v2);
368
369int lustre_pack_reply_flags(struct ptlrpc_request *req, int count, __u32 *lens,
370 char **bufs, int flags)
371{
372 int rc = 0;
373 __u32 size[] = { sizeof(struct ptlrpc_body) };
374
375 if (!lens) {
376 LASSERT(count == 1);
377 lens = size;
378 }
379
380 LASSERT(count > 0);
381 LASSERT(lens[MSG_PTLRPC_BODY_OFF] == sizeof(struct ptlrpc_body));
382
383 switch (req->rq_reqmsg->lm_magic) {
384 case LUSTRE_MSG_MAGIC_V2:
385 rc = lustre_pack_reply_v2(req, count, lens, bufs, flags);
386 break;
387 default:
388 LASSERTF(0, "incorrect message magic: %08x\n",
389 req->rq_reqmsg->lm_magic);
390 rc = -EINVAL;
391 }
392 if (rc != 0)
393 CERROR("lustre_pack_reply failed: rc=%d size=%d\n", rc,
394 lustre_msg_size(req->rq_reqmsg->lm_magic, count, lens));
395 return rc;
396}
397EXPORT_SYMBOL(lustre_pack_reply_flags);
398
399int lustre_pack_reply(struct ptlrpc_request *req, int count, __u32 *lens,
400 char **bufs)
401{
402 return lustre_pack_reply_flags(req, count, lens, bufs, 0);
403}
404EXPORT_SYMBOL(lustre_pack_reply);
405
406void *lustre_msg_buf_v2(struct lustre_msg_v2 *m, int n, int min_size)
407{
408 int i, offset, buflen, bufcount;
409
410 LASSERT(m != NULL);
411 LASSERT(n >= 0);
412
413 bufcount = m->lm_bufcount;
414 if (unlikely(n >= bufcount)) {
415 CDEBUG(D_INFO, "msg %p buffer[%d] not present (count %d)\n",
416 m, n, bufcount);
417 return NULL;
418 }
419
420 buflen = m->lm_buflens[n];
421 if (unlikely(buflen < min_size)) {
422 CERROR("msg %p buffer[%d] size %d too small "
423 "(required %d, opc=%d)\n", m, n, buflen, min_size,
424 n == MSG_PTLRPC_BODY_OFF ? -1 : lustre_msg_get_opc(m));
425 return NULL;
426 }
427
428 offset = lustre_msg_hdr_size_v2(bufcount);
429 for (i = 0; i < n; i++)
430 offset += cfs_size_round(m->lm_buflens[i]);
431
432 return (char *)m + offset;
433}
434
435void *lustre_msg_buf(struct lustre_msg *m, int n, int min_size)
436{
437 switch (m->lm_magic) {
438 case LUSTRE_MSG_MAGIC_V2:
439 return lustre_msg_buf_v2(m, n, min_size);
440 default:
441 LASSERTF(0, "incorrect message magic: %08x(msg:%p)\n", m->lm_magic, m);
442 return NULL;
443 }
444}
445EXPORT_SYMBOL(lustre_msg_buf);
446
447int lustre_shrink_msg_v2(struct lustre_msg_v2 *msg, int segment,
448 unsigned int newlen, int move_data)
449{
450 char *tail = NULL, *newpos;
451 int tail_len = 0, n;
452
453 LASSERT(msg);
454 LASSERT(msg->lm_bufcount > segment);
455 LASSERT(msg->lm_buflens[segment] >= newlen);
456
457 if (msg->lm_buflens[segment] == newlen)
458 goto out;
459
460 if (move_data && msg->lm_bufcount > segment + 1) {
461 tail = lustre_msg_buf_v2(msg, segment + 1, 0);
462 for (n = segment + 1; n < msg->lm_bufcount; n++)
463 tail_len += cfs_size_round(msg->lm_buflens[n]);
464 }
465
466 msg->lm_buflens[segment] = newlen;
467
468 if (tail && tail_len) {
469 newpos = lustre_msg_buf_v2(msg, segment + 1, 0);
470 LASSERT(newpos <= tail);
471 if (newpos != tail)
472 memmove(newpos, tail, tail_len);
473 }
474out:
475 return lustre_msg_size_v2(msg->lm_bufcount, msg->lm_buflens);
476}
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494int lustre_shrink_msg(struct lustre_msg *msg, int segment,
495 unsigned int newlen, int move_data)
496{
497 switch (msg->lm_magic) {
498 case LUSTRE_MSG_MAGIC_V2:
499 return lustre_shrink_msg_v2(msg, segment, newlen, move_data);
500 default:
501 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
502 }
503}
504EXPORT_SYMBOL(lustre_shrink_msg);
505
506void lustre_free_reply_state(struct ptlrpc_reply_state *rs)
507{
508 PTLRPC_RS_DEBUG_LRU_DEL(rs);
509
510 LASSERT (atomic_read(&rs->rs_refcount) == 0);
511 LASSERT (!rs->rs_difficult || rs->rs_handled);
512 LASSERT (!rs->rs_on_net);
513 LASSERT (!rs->rs_scheduled);
514 LASSERT (rs->rs_export == NULL);
515 LASSERT (rs->rs_nlocks == 0);
516 LASSERT (list_empty(&rs->rs_exp_list));
517 LASSERT (list_empty(&rs->rs_obd_list));
518
519 sptlrpc_svc_free_rs(rs);
520}
521EXPORT_SYMBOL(lustre_free_reply_state);
522
523static int lustre_unpack_msg_v2(struct lustre_msg_v2 *m, int len)
524{
525 int swabbed, required_len, i;
526
527
528 required_len = lustre_msg_hdr_size_v2(0);
529 if (len < required_len) {
530
531 CERROR("message length %d too small for lustre_msg\n", len);
532 return -EINVAL;
533 }
534
535 swabbed = (m->lm_magic == LUSTRE_MSG_MAGIC_V2_SWABBED);
536
537 if (swabbed) {
538 __swab32s(&m->lm_magic);
539 __swab32s(&m->lm_bufcount);
540 __swab32s(&m->lm_secflvr);
541 __swab32s(&m->lm_repsize);
542 __swab32s(&m->lm_cksum);
543 __swab32s(&m->lm_flags);
544 CLASSERT(offsetof(typeof(*m), lm_padding_2) != 0);
545 CLASSERT(offsetof(typeof(*m), lm_padding_3) != 0);
546 }
547
548 required_len = lustre_msg_hdr_size_v2(m->lm_bufcount);
549 if (len < required_len) {
550
551 CERROR ("message length %d too small for %d buflens\n",
552 len, m->lm_bufcount);
553 return -EINVAL;
554 }
555
556 for (i = 0; i < m->lm_bufcount; i++) {
557 if (swabbed)
558 __swab32s(&m->lm_buflens[i]);
559 required_len += cfs_size_round(m->lm_buflens[i]);
560 }
561
562 if (len < required_len) {
563 CERROR("len: %d, required_len %d\n", len, required_len);
564 CERROR("bufcount: %d\n", m->lm_bufcount);
565 for (i = 0; i < m->lm_bufcount; i++)
566 CERROR("buffer %d length %d\n", i, m->lm_buflens[i]);
567 return -EINVAL;
568 }
569
570 return swabbed;
571}
572
573int __lustre_unpack_msg(struct lustre_msg *m, int len)
574{
575 int required_len, rc;
576
577
578
579
580
581
582
583 required_len = offsetof(struct lustre_msg, lm_magic) +
584 sizeof(m->lm_magic);
585 if (len < required_len) {
586
587 CERROR("message length %d too small for magic/version check\n",
588 len);
589 return -EINVAL;
590 }
591
592 rc = lustre_unpack_msg_v2(m, len);
593
594 return rc;
595}
596EXPORT_SYMBOL(__lustre_unpack_msg);
597
598int ptlrpc_unpack_req_msg(struct ptlrpc_request *req, int len)
599{
600 int rc;
601 rc = __lustre_unpack_msg(req->rq_reqmsg, len);
602 if (rc == 1) {
603 lustre_set_req_swabbed(req, MSG_PTLRPC_HEADER_OFF);
604 rc = 0;
605 }
606 return rc;
607}
608EXPORT_SYMBOL(ptlrpc_unpack_req_msg);
609
610int ptlrpc_unpack_rep_msg(struct ptlrpc_request *req, int len)
611{
612 int rc;
613 rc = __lustre_unpack_msg(req->rq_repmsg, len);
614 if (rc == 1) {
615 lustre_set_rep_swabbed(req, MSG_PTLRPC_HEADER_OFF);
616 rc = 0;
617 }
618 return rc;
619}
620EXPORT_SYMBOL(ptlrpc_unpack_rep_msg);
621
622static inline int lustre_unpack_ptlrpc_body_v2(struct ptlrpc_request *req,
623 const int inout, int offset)
624{
625 struct ptlrpc_body *pb;
626 struct lustre_msg_v2 *m = inout ? req->rq_reqmsg : req->rq_repmsg;
627
628 pb = lustre_msg_buf_v2(m, offset, sizeof(struct ptlrpc_body_v2));
629 if (!pb) {
630 CERROR("error unpacking ptlrpc body\n");
631 return -EFAULT;
632 }
633 if (ptlrpc_buf_need_swab(req, inout, offset)) {
634 lustre_swab_ptlrpc_body(pb);
635 ptlrpc_buf_set_swabbed(req, inout, offset);
636 }
637
638 if ((pb->pb_version & ~LUSTRE_VERSION_MASK) != PTLRPC_MSG_VERSION) {
639 CERROR("wrong lustre_msg version %08x\n", pb->pb_version);
640 return -EINVAL;
641 }
642
643 if (!inout)
644 pb->pb_status = ptlrpc_status_ntoh(pb->pb_status);
645
646 return 0;
647}
648
649int lustre_unpack_req_ptlrpc_body(struct ptlrpc_request *req, int offset)
650{
651 switch (req->rq_reqmsg->lm_magic) {
652 case LUSTRE_MSG_MAGIC_V2:
653 return lustre_unpack_ptlrpc_body_v2(req, 1, offset);
654 default:
655 CERROR("bad lustre msg magic: %08x\n",
656 req->rq_reqmsg->lm_magic);
657 return -EINVAL;
658 }
659}
660
661int lustre_unpack_rep_ptlrpc_body(struct ptlrpc_request *req, int offset)
662{
663 switch (req->rq_repmsg->lm_magic) {
664 case LUSTRE_MSG_MAGIC_V2:
665 return lustre_unpack_ptlrpc_body_v2(req, 0, offset);
666 default:
667 CERROR("bad lustre msg magic: %08x\n",
668 req->rq_repmsg->lm_magic);
669 return -EINVAL;
670 }
671}
672
673static inline int lustre_msg_buflen_v2(struct lustre_msg_v2 *m, int n)
674{
675 if (n >= m->lm_bufcount)
676 return 0;
677
678 return m->lm_buflens[n];
679}
680
681
682
683
684
685
686
687
688int lustre_msg_buflen(struct lustre_msg *m, int n)
689{
690 switch (m->lm_magic) {
691 case LUSTRE_MSG_MAGIC_V2:
692 return lustre_msg_buflen_v2(m, n);
693 default:
694 CERROR("incorrect message magic: %08x\n", m->lm_magic);
695 return -EINVAL;
696 }
697}
698EXPORT_SYMBOL(lustre_msg_buflen);
699
700static inline void
701lustre_msg_set_buflen_v2(struct lustre_msg_v2 *m, int n, int len)
702{
703 if (n >= m->lm_bufcount)
704 LBUG();
705
706 m->lm_buflens[n] = len;
707}
708
709void lustre_msg_set_buflen(struct lustre_msg *m, int n, int len)
710{
711 switch (m->lm_magic) {
712 case LUSTRE_MSG_MAGIC_V2:
713 lustre_msg_set_buflen_v2(m, n, len);
714 return;
715 default:
716 LASSERTF(0, "incorrect message magic: %08x\n", m->lm_magic);
717 }
718}
719
720EXPORT_SYMBOL(lustre_msg_set_buflen);
721
722
723
724int lustre_msg_bufcount(struct lustre_msg *m)
725{
726 switch (m->lm_magic) {
727 case LUSTRE_MSG_MAGIC_V2:
728 return m->lm_bufcount;
729 default:
730 CERROR("incorrect message magic: %08x\n", m->lm_magic);
731 return -EINVAL;
732 }
733}
734EXPORT_SYMBOL(lustre_msg_bufcount);
735
736char *lustre_msg_string(struct lustre_msg *m, int index, int max_len)
737{
738
739 char *str;
740 int slen, blen;
741
742 switch (m->lm_magic) {
743 case LUSTRE_MSG_MAGIC_V2:
744 str = lustre_msg_buf_v2(m, index, 0);
745 blen = lustre_msg_buflen_v2(m, index);
746 break;
747 default:
748 LASSERTF(0, "incorrect message magic: %08x\n", m->lm_magic);
749 }
750
751 if (str == NULL) {
752 CERROR ("can't unpack string in msg %p buffer[%d]\n", m, index);
753 return NULL;
754 }
755
756 slen = strnlen(str, blen);
757
758 if (slen == blen) {
759 CERROR("can't unpack non-NULL terminated string in "
760 "msg %p buffer[%d] len %d\n", m, index, blen);
761 return NULL;
762 }
763
764 if (max_len == 0) {
765 if (slen != blen - 1) {
766 CERROR("can't unpack short string in msg %p "
767 "buffer[%d] len %d: strlen %d\n",
768 m, index, blen, slen);
769 return NULL;
770 }
771 } else if (slen > max_len) {
772 CERROR("can't unpack oversized string in msg %p "
773 "buffer[%d] len %d strlen %d: max %d expected\n",
774 m, index, blen, slen, max_len);
775 return NULL;
776 }
777
778 return str;
779}
780EXPORT_SYMBOL(lustre_msg_string);
781
782
783static inline void *__lustre_swab_buf(struct lustre_msg *msg, int index,
784 int min_size, void *swabber)
785{
786 void *ptr = NULL;
787
788 LASSERT(msg != NULL);
789 switch (msg->lm_magic) {
790 case LUSTRE_MSG_MAGIC_V2:
791 ptr = lustre_msg_buf_v2(msg, index, min_size);
792 break;
793 default:
794 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
795 }
796
797 if (ptr && swabber)
798 ((void (*)(void *))swabber)(ptr);
799
800 return ptr;
801}
802
803static inline struct ptlrpc_body *lustre_msg_ptlrpc_body(struct lustre_msg *msg)
804{
805 return lustre_msg_buf_v2(msg, MSG_PTLRPC_BODY_OFF,
806 sizeof(struct ptlrpc_body_v2));
807}
808
809__u32 lustre_msghdr_get_flags(struct lustre_msg *msg)
810{
811 switch (msg->lm_magic) {
812 case LUSTRE_MSG_MAGIC_V1:
813 case LUSTRE_MSG_MAGIC_V1_SWABBED:
814 return 0;
815 case LUSTRE_MSG_MAGIC_V2:
816
817 return msg->lm_flags;
818 default:
819 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
820 return 0;
821 }
822}
823EXPORT_SYMBOL(lustre_msghdr_get_flags);
824
825void lustre_msghdr_set_flags(struct lustre_msg *msg, __u32 flags)
826{
827 switch (msg->lm_magic) {
828 case LUSTRE_MSG_MAGIC_V1:
829 return;
830 case LUSTRE_MSG_MAGIC_V2:
831 msg->lm_flags = flags;
832 return;
833 default:
834 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
835 }
836}
837
838__u32 lustre_msg_get_flags(struct lustre_msg *msg)
839{
840 switch (msg->lm_magic) {
841 case LUSTRE_MSG_MAGIC_V2: {
842 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
843 if (!pb) {
844 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
845 return 0;
846 }
847 return pb->pb_flags;
848 }
849 default:
850
851
852 return 0;
853 }
854}
855EXPORT_SYMBOL(lustre_msg_get_flags);
856
857void lustre_msg_add_flags(struct lustre_msg *msg, int flags)
858{
859 switch (msg->lm_magic) {
860 case LUSTRE_MSG_MAGIC_V2: {
861 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
862 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
863 pb->pb_flags |= flags;
864 return;
865 }
866 default:
867 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
868 }
869}
870EXPORT_SYMBOL(lustre_msg_add_flags);
871
872void lustre_msg_set_flags(struct lustre_msg *msg, int flags)
873{
874 switch (msg->lm_magic) {
875 case LUSTRE_MSG_MAGIC_V2: {
876 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
877 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
878 pb->pb_flags = flags;
879 return;
880 }
881 default:
882 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
883 }
884}
885EXPORT_SYMBOL(lustre_msg_set_flags);
886
887void lustre_msg_clear_flags(struct lustre_msg *msg, int flags)
888{
889 switch (msg->lm_magic) {
890 case LUSTRE_MSG_MAGIC_V2: {
891 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
892 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
893 pb->pb_flags &= ~(MSG_GEN_FLAG_MASK & flags);
894 return;
895 }
896 default:
897 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
898 }
899}
900EXPORT_SYMBOL(lustre_msg_clear_flags);
901
902__u32 lustre_msg_get_op_flags(struct lustre_msg *msg)
903{
904 switch (msg->lm_magic) {
905 case LUSTRE_MSG_MAGIC_V2: {
906 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
907 if (!pb) {
908 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
909 return 0;
910 }
911 return pb->pb_op_flags;
912 }
913 default:
914 return 0;
915 }
916}
917EXPORT_SYMBOL(lustre_msg_get_op_flags);
918
919void lustre_msg_add_op_flags(struct lustre_msg *msg, int flags)
920{
921 switch (msg->lm_magic) {
922 case LUSTRE_MSG_MAGIC_V2: {
923 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
924 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
925 pb->pb_op_flags |= flags;
926 return;
927 }
928 default:
929 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
930 }
931}
932EXPORT_SYMBOL(lustre_msg_add_op_flags);
933
934void lustre_msg_set_op_flags(struct lustre_msg *msg, int flags)
935{
936 switch (msg->lm_magic) {
937 case LUSTRE_MSG_MAGIC_V2: {
938 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
939 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
940 pb->pb_op_flags |= flags;
941 return;
942 }
943 default:
944 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
945 }
946}
947EXPORT_SYMBOL(lustre_msg_set_op_flags);
948
949struct lustre_handle *lustre_msg_get_handle(struct lustre_msg *msg)
950{
951 switch (msg->lm_magic) {
952 case LUSTRE_MSG_MAGIC_V2: {
953 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
954 if (!pb) {
955 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
956 return NULL;
957 }
958 return &pb->pb_handle;
959 }
960 default:
961 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
962 return NULL;
963 }
964}
965EXPORT_SYMBOL(lustre_msg_get_handle);
966
967__u32 lustre_msg_get_type(struct lustre_msg *msg)
968{
969 switch (msg->lm_magic) {
970 case LUSTRE_MSG_MAGIC_V2: {
971 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
972 if (!pb) {
973 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
974 return PTL_RPC_MSG_ERR;
975 }
976 return pb->pb_type;
977 }
978 default:
979 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
980 return PTL_RPC_MSG_ERR;
981 }
982}
983EXPORT_SYMBOL(lustre_msg_get_type);
984
985__u32 lustre_msg_get_version(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_version;
995 }
996 default:
997 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
998 return 0;
999 }
1000}
1001EXPORT_SYMBOL(lustre_msg_get_version);
1002
1003void lustre_msg_add_version(struct lustre_msg *msg, int version)
1004{
1005 switch (msg->lm_magic) {
1006 case LUSTRE_MSG_MAGIC_V2: {
1007 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1008 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1009 pb->pb_version |= version;
1010 return;
1011 }
1012 default:
1013 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1014 }
1015}
1016EXPORT_SYMBOL(lustre_msg_add_version);
1017
1018__u32 lustre_msg_get_opc(struct lustre_msg *msg)
1019{
1020 switch (msg->lm_magic) {
1021 case LUSTRE_MSG_MAGIC_V2: {
1022 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1023 if (!pb) {
1024 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1025 return 0;
1026 }
1027 return pb->pb_opc;
1028 }
1029 default:
1030 CERROR("incorrect message magic: %08x(msg:%p)\n", msg->lm_magic, msg);
1031 LBUG();
1032 return 0;
1033 }
1034}
1035EXPORT_SYMBOL(lustre_msg_get_opc);
1036
1037__u64 lustre_msg_get_last_xid(struct lustre_msg *msg)
1038{
1039 switch (msg->lm_magic) {
1040 case LUSTRE_MSG_MAGIC_V2: {
1041 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1042 if (!pb) {
1043 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1044 return 0;
1045 }
1046 return pb->pb_last_xid;
1047 }
1048 default:
1049 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1050 return 0;
1051 }
1052}
1053EXPORT_SYMBOL(lustre_msg_get_last_xid);
1054
1055__u64 lustre_msg_get_last_committed(struct lustre_msg *msg)
1056{
1057 switch (msg->lm_magic) {
1058 case LUSTRE_MSG_MAGIC_V2: {
1059 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1060 if (!pb) {
1061 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1062 return 0;
1063 }
1064 return pb->pb_last_committed;
1065 }
1066 default:
1067 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1068 return 0;
1069 }
1070}
1071EXPORT_SYMBOL(lustre_msg_get_last_committed);
1072
1073__u64 *lustre_msg_get_versions(struct lustre_msg *msg)
1074{
1075 switch (msg->lm_magic) {
1076 case LUSTRE_MSG_MAGIC_V1:
1077 return NULL;
1078 case LUSTRE_MSG_MAGIC_V2: {
1079 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1080 if (!pb) {
1081 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1082 return NULL;
1083 }
1084 return pb->pb_pre_versions;
1085 }
1086 default:
1087 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1088 return NULL;
1089 }
1090}
1091EXPORT_SYMBOL(lustre_msg_get_versions);
1092
1093__u64 lustre_msg_get_transno(struct lustre_msg *msg)
1094{
1095 switch (msg->lm_magic) {
1096 case LUSTRE_MSG_MAGIC_V2: {
1097 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1098 if (!pb) {
1099 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1100 return 0;
1101 }
1102 return pb->pb_transno;
1103 }
1104 default:
1105 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1106 return 0;
1107 }
1108}
1109EXPORT_SYMBOL(lustre_msg_get_transno);
1110
1111int lustre_msg_get_status(struct lustre_msg *msg)
1112{
1113 switch (msg->lm_magic) {
1114 case LUSTRE_MSG_MAGIC_V2: {
1115 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1116 if (!pb) {
1117 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1118 return -EINVAL;
1119 }
1120 return pb->pb_status;
1121 }
1122 default:
1123
1124
1125 return -EINVAL;
1126 }
1127}
1128EXPORT_SYMBOL(lustre_msg_get_status);
1129
1130__u64 lustre_msg_get_slv(struct lustre_msg *msg)
1131{
1132 switch (msg->lm_magic) {
1133 case LUSTRE_MSG_MAGIC_V2: {
1134 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1135 if (!pb) {
1136 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1137 return -EINVAL;
1138 }
1139 return pb->pb_slv;
1140 }
1141 default:
1142 CERROR("invalid msg magic %08x\n", msg->lm_magic);
1143 return -EINVAL;
1144 }
1145}
1146EXPORT_SYMBOL(lustre_msg_get_slv);
1147
1148
1149void lustre_msg_set_slv(struct lustre_msg *msg, __u64 slv)
1150{
1151 switch (msg->lm_magic) {
1152 case LUSTRE_MSG_MAGIC_V2: {
1153 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1154 if (!pb) {
1155 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1156 return;
1157 }
1158 pb->pb_slv = slv;
1159 return;
1160 }
1161 default:
1162 CERROR("invalid msg magic %x\n", msg->lm_magic);
1163 return;
1164 }
1165}
1166EXPORT_SYMBOL(lustre_msg_set_slv);
1167
1168__u32 lustre_msg_get_limit(struct lustre_msg *msg)
1169{
1170 switch (msg->lm_magic) {
1171 case LUSTRE_MSG_MAGIC_V2: {
1172 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1173 if (!pb) {
1174 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1175 return -EINVAL;
1176 }
1177 return pb->pb_limit;
1178 }
1179 default:
1180 CERROR("invalid msg magic %x\n", msg->lm_magic);
1181 return -EINVAL;
1182 }
1183}
1184EXPORT_SYMBOL(lustre_msg_get_limit);
1185
1186
1187void lustre_msg_set_limit(struct lustre_msg *msg, __u64 limit)
1188{
1189 switch (msg->lm_magic) {
1190 case LUSTRE_MSG_MAGIC_V2: {
1191 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1192 if (!pb) {
1193 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1194 return;
1195 }
1196 pb->pb_limit = limit;
1197 return;
1198 }
1199 default:
1200 CERROR("invalid msg magic %08x\n", msg->lm_magic);
1201 return;
1202 }
1203}
1204EXPORT_SYMBOL(lustre_msg_set_limit);
1205
1206__u32 lustre_msg_get_conn_cnt(struct lustre_msg *msg)
1207{
1208 switch (msg->lm_magic) {
1209 case LUSTRE_MSG_MAGIC_V2: {
1210 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1211 if (!pb) {
1212 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1213 return 0;
1214 }
1215 return pb->pb_conn_cnt;
1216 }
1217 default:
1218 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1219 return 0;
1220 }
1221}
1222EXPORT_SYMBOL(lustre_msg_get_conn_cnt);
1223
1224int lustre_msg_is_v1(struct lustre_msg *msg)
1225{
1226 switch (msg->lm_magic) {
1227 case LUSTRE_MSG_MAGIC_V1:
1228 case LUSTRE_MSG_MAGIC_V1_SWABBED:
1229 return 1;
1230 default:
1231 return 0;
1232 }
1233}
1234EXPORT_SYMBOL(lustre_msg_is_v1);
1235
1236__u32 lustre_msg_get_magic(struct lustre_msg *msg)
1237{
1238 switch (msg->lm_magic) {
1239 case LUSTRE_MSG_MAGIC_V2:
1240 return msg->lm_magic;
1241 default:
1242 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1243 return 0;
1244 }
1245}
1246EXPORT_SYMBOL(lustre_msg_get_magic);
1247
1248__u32 lustre_msg_get_timeout(struct lustre_msg *msg)
1249{
1250 switch (msg->lm_magic) {
1251 case LUSTRE_MSG_MAGIC_V1:
1252 case LUSTRE_MSG_MAGIC_V1_SWABBED:
1253 return 0;
1254 case LUSTRE_MSG_MAGIC_V2: {
1255 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1256 if (!pb) {
1257 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1258 return 0;
1259
1260 }
1261 return pb->pb_timeout;
1262 }
1263 default:
1264 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1265 return 0;
1266 }
1267}
1268
1269__u32 lustre_msg_get_service_time(struct lustre_msg *msg)
1270{
1271 switch (msg->lm_magic) {
1272 case LUSTRE_MSG_MAGIC_V1:
1273 case LUSTRE_MSG_MAGIC_V1_SWABBED:
1274 return 0;
1275 case LUSTRE_MSG_MAGIC_V2: {
1276 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1277 if (!pb) {
1278 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1279 return 0;
1280
1281 }
1282 return pb->pb_service_time;
1283 }
1284 default:
1285 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1286 return 0;
1287 }
1288}
1289
1290char *lustre_msg_get_jobid(struct lustre_msg *msg)
1291{
1292 switch (msg->lm_magic) {
1293 case LUSTRE_MSG_MAGIC_V1:
1294 case LUSTRE_MSG_MAGIC_V1_SWABBED:
1295 return NULL;
1296 case LUSTRE_MSG_MAGIC_V2: {
1297 struct ptlrpc_body *pb =
1298 lustre_msg_buf_v2(msg, MSG_PTLRPC_BODY_OFF,
1299 sizeof(struct ptlrpc_body));
1300 if (!pb)
1301 return NULL;
1302
1303 return pb->pb_jobid;
1304 }
1305 default:
1306 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1307 return NULL;
1308 }
1309}
1310EXPORT_SYMBOL(lustre_msg_get_jobid);
1311
1312__u32 lustre_msg_get_cksum(struct lustre_msg *msg)
1313{
1314 switch (msg->lm_magic) {
1315 case LUSTRE_MSG_MAGIC_V2:
1316 return msg->lm_cksum;
1317 default:
1318 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1319 return 0;
1320 }
1321}
1322
1323#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 7, 50, 0)
1324
1325
1326
1327
1328
1329
1330# define ptlrpc_body_cksum_size_compat18 88
1331
1332__u32 lustre_msg_calc_cksum(struct lustre_msg *msg, int compat18)
1333#else
1334# warning "remove checksum compatibility support for b1_8"
1335__u32 lustre_msg_calc_cksum(struct lustre_msg *msg)
1336#endif
1337{
1338 switch (msg->lm_magic) {
1339 case LUSTRE_MSG_MAGIC_V2: {
1340 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1341#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 7, 50, 0)
1342 __u32 crc;
1343 unsigned int hsize = 4;
1344 __u32 len = compat18 ? ptlrpc_body_cksum_size_compat18 :
1345 lustre_msg_buflen(msg, MSG_PTLRPC_BODY_OFF);
1346 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1347 cfs_crypto_hash_digest(CFS_HASH_ALG_CRC32, (unsigned char *)pb,
1348 len, NULL, 0, (unsigned char *)&crc,
1349 &hsize);
1350 return crc;
1351#else
1352# warning "remove checksum compatibility support for b1_8"
1353 __u32 crc;
1354 unsigned int hsize = 4;
1355 cfs_crypto_hash_digest(CFS_HASH_ALG_CRC32, (unsigned char *)pb,
1356 lustre_msg_buflen(msg, MSG_PTLRPC_BODY_OFF),
1357 NULL, 0, (unsigned char *)&crc, &hsize);
1358 return crc;
1359#endif
1360 }
1361 default:
1362 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1363 return 0;
1364 }
1365}
1366
1367void lustre_msg_set_handle(struct lustre_msg *msg, struct lustre_handle *handle)
1368{
1369 switch (msg->lm_magic) {
1370 case LUSTRE_MSG_MAGIC_V2: {
1371 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1372 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1373 pb->pb_handle = *handle;
1374 return;
1375 }
1376 default:
1377 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1378 }
1379}
1380EXPORT_SYMBOL(lustre_msg_set_handle);
1381
1382void lustre_msg_set_type(struct lustre_msg *msg, __u32 type)
1383{
1384 switch (msg->lm_magic) {
1385 case LUSTRE_MSG_MAGIC_V2: {
1386 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1387 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1388 pb->pb_type = type;
1389 return;
1390 }
1391 default:
1392 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1393 }
1394}
1395EXPORT_SYMBOL(lustre_msg_set_type);
1396
1397void lustre_msg_set_opc(struct lustre_msg *msg, __u32 opc)
1398{
1399 switch (msg->lm_magic) {
1400 case LUSTRE_MSG_MAGIC_V2: {
1401 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1402 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1403 pb->pb_opc = opc;
1404 return;
1405 }
1406 default:
1407 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1408 }
1409}
1410EXPORT_SYMBOL(lustre_msg_set_opc);
1411
1412void lustre_msg_set_last_xid(struct lustre_msg *msg, __u64 last_xid)
1413{
1414 switch (msg->lm_magic) {
1415 case LUSTRE_MSG_MAGIC_V2: {
1416 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1417 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1418 pb->pb_last_xid = last_xid;
1419 return;
1420 }
1421 default:
1422 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1423 }
1424}
1425EXPORT_SYMBOL(lustre_msg_set_last_xid);
1426
1427void lustre_msg_set_last_committed(struct lustre_msg *msg, __u64 last_committed)
1428{
1429 switch (msg->lm_magic) {
1430 case LUSTRE_MSG_MAGIC_V2: {
1431 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1432 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1433 pb->pb_last_committed = last_committed;
1434 return;
1435 }
1436 default:
1437 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1438 }
1439}
1440EXPORT_SYMBOL(lustre_msg_set_last_committed);
1441
1442void lustre_msg_set_versions(struct lustre_msg *msg, __u64 *versions)
1443{
1444 switch (msg->lm_magic) {
1445 case LUSTRE_MSG_MAGIC_V1:
1446 return;
1447 case LUSTRE_MSG_MAGIC_V2: {
1448 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1449 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1450 pb->pb_pre_versions[0] = versions[0];
1451 pb->pb_pre_versions[1] = versions[1];
1452 pb->pb_pre_versions[2] = versions[2];
1453 pb->pb_pre_versions[3] = versions[3];
1454 return;
1455 }
1456 default:
1457 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1458 }
1459}
1460EXPORT_SYMBOL(lustre_msg_set_versions);
1461
1462void lustre_msg_set_transno(struct lustre_msg *msg, __u64 transno)
1463{
1464 switch (msg->lm_magic) {
1465 case LUSTRE_MSG_MAGIC_V2: {
1466 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1467 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1468 pb->pb_transno = transno;
1469 return;
1470 }
1471 default:
1472 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1473 }
1474}
1475EXPORT_SYMBOL(lustre_msg_set_transno);
1476
1477void lustre_msg_set_status(struct lustre_msg *msg, __u32 status)
1478{
1479 switch (msg->lm_magic) {
1480 case LUSTRE_MSG_MAGIC_V2: {
1481 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1482 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1483 pb->pb_status = status;
1484 return;
1485 }
1486 default:
1487 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1488 }
1489}
1490EXPORT_SYMBOL(lustre_msg_set_status);
1491
1492void lustre_msg_set_conn_cnt(struct lustre_msg *msg, __u32 conn_cnt)
1493{
1494 switch (msg->lm_magic) {
1495 case LUSTRE_MSG_MAGIC_V2: {
1496 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1497 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1498 pb->pb_conn_cnt = conn_cnt;
1499 return;
1500 }
1501 default:
1502 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1503 }
1504}
1505EXPORT_SYMBOL(lustre_msg_set_conn_cnt);
1506
1507void lustre_msg_set_timeout(struct lustre_msg *msg, __u32 timeout)
1508{
1509 switch (msg->lm_magic) {
1510 case LUSTRE_MSG_MAGIC_V1:
1511 return;
1512 case LUSTRE_MSG_MAGIC_V2: {
1513 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1514 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1515 pb->pb_timeout = timeout;
1516 return;
1517 }
1518 default:
1519 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1520 }
1521}
1522
1523void lustre_msg_set_service_time(struct lustre_msg *msg, __u32 service_time)
1524{
1525 switch (msg->lm_magic) {
1526 case LUSTRE_MSG_MAGIC_V1:
1527 return;
1528 case LUSTRE_MSG_MAGIC_V2: {
1529 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1530 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1531 pb->pb_service_time = service_time;
1532 return;
1533 }
1534 default:
1535 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1536 }
1537}
1538
1539void lustre_msg_set_jobid(struct lustre_msg *msg, char *jobid)
1540{
1541 switch (msg->lm_magic) {
1542 case LUSTRE_MSG_MAGIC_V1:
1543 return;
1544 case LUSTRE_MSG_MAGIC_V2: {
1545 __u32 opc = lustre_msg_get_opc(msg);
1546 struct ptlrpc_body *pb;
1547
1548
1549
1550 if (!opc || opc == LDLM_BL_CALLBACK ||
1551 opc == LDLM_CP_CALLBACK || opc == LDLM_GL_CALLBACK)
1552 return;
1553
1554 pb = lustre_msg_buf_v2(msg, MSG_PTLRPC_BODY_OFF,
1555 sizeof(struct ptlrpc_body));
1556 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1557
1558 if (jobid != NULL)
1559 memcpy(pb->pb_jobid, jobid, JOBSTATS_JOBID_SIZE);
1560 else if (pb->pb_jobid[0] == '\0')
1561 lustre_get_jobid(pb->pb_jobid);
1562 return;
1563 }
1564 default:
1565 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1566 }
1567}
1568EXPORT_SYMBOL(lustre_msg_set_jobid);
1569
1570void lustre_msg_set_cksum(struct lustre_msg *msg, __u32 cksum)
1571{
1572 switch (msg->lm_magic) {
1573 case LUSTRE_MSG_MAGIC_V1:
1574 return;
1575 case LUSTRE_MSG_MAGIC_V2:
1576 msg->lm_cksum = cksum;
1577 return;
1578 default:
1579 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1580 }
1581}
1582
1583
1584void ptlrpc_request_set_replen(struct ptlrpc_request *req)
1585{
1586 int count = req_capsule_filled_sizes(&req->rq_pill, RCL_SERVER);
1587
1588 req->rq_replen = lustre_msg_size(req->rq_reqmsg->lm_magic, count,
1589 req->rq_pill.rc_area[RCL_SERVER]);
1590 if (req->rq_reqmsg->lm_magic == LUSTRE_MSG_MAGIC_V2)
1591 req->rq_reqmsg->lm_repsize = req->rq_replen;
1592}
1593EXPORT_SYMBOL(ptlrpc_request_set_replen);
1594
1595void ptlrpc_req_set_repsize(struct ptlrpc_request *req, int count, __u32 *lens)
1596{
1597 req->rq_replen = lustre_msg_size(req->rq_reqmsg->lm_magic, count, lens);
1598 if (req->rq_reqmsg->lm_magic == LUSTRE_MSG_MAGIC_V2)
1599 req->rq_reqmsg->lm_repsize = req->rq_replen;
1600}
1601EXPORT_SYMBOL(ptlrpc_req_set_repsize);
1602
1603
1604
1605
1606
1607
1608int do_set_info_async(struct obd_import *imp,
1609 int opcode, int version,
1610 obd_count keylen, void *key,
1611 obd_count vallen, void *val,
1612 struct ptlrpc_request_set *set)
1613{
1614 struct ptlrpc_request *req;
1615 char *tmp;
1616 int rc;
1617
1618 req = ptlrpc_request_alloc(imp, &RQF_OBD_SET_INFO);
1619 if (req == NULL)
1620 return -ENOMEM;
1621
1622 req_capsule_set_size(&req->rq_pill, &RMF_SETINFO_KEY,
1623 RCL_CLIENT, keylen);
1624 req_capsule_set_size(&req->rq_pill, &RMF_SETINFO_VAL,
1625 RCL_CLIENT, vallen);
1626 rc = ptlrpc_request_pack(req, version, opcode);
1627 if (rc) {
1628 ptlrpc_request_free(req);
1629 return rc;
1630 }
1631
1632 tmp = req_capsule_client_get(&req->rq_pill, &RMF_SETINFO_KEY);
1633 memcpy(tmp, key, keylen);
1634 tmp = req_capsule_client_get(&req->rq_pill, &RMF_SETINFO_VAL);
1635 memcpy(tmp, val, vallen);
1636
1637 ptlrpc_request_set_replen(req);
1638
1639 if (set) {
1640 ptlrpc_set_add_req(set, req);
1641 ptlrpc_check_set(NULL, set);
1642 } else {
1643 rc = ptlrpc_queue_wait(req);
1644 ptlrpc_req_finished(req);
1645 }
1646
1647 return rc;
1648}
1649EXPORT_SYMBOL(do_set_info_async);
1650
1651
1652
1653
1654void lustre_swab_ptlrpc_body(struct ptlrpc_body *b)
1655{
1656 __swab32s (&b->pb_type);
1657 __swab32s (&b->pb_version);
1658 __swab32s (&b->pb_opc);
1659 __swab32s (&b->pb_status);
1660 __swab64s (&b->pb_last_xid);
1661 __swab64s (&b->pb_last_seen);
1662 __swab64s (&b->pb_last_committed);
1663 __swab64s (&b->pb_transno);
1664 __swab32s (&b->pb_flags);
1665 __swab32s (&b->pb_op_flags);
1666 __swab32s (&b->pb_conn_cnt);
1667 __swab32s (&b->pb_timeout);
1668 __swab32s (&b->pb_service_time);
1669 __swab32s (&b->pb_limit);
1670 __swab64s (&b->pb_slv);
1671 __swab64s (&b->pb_pre_versions[0]);
1672 __swab64s (&b->pb_pre_versions[1]);
1673 __swab64s (&b->pb_pre_versions[2]);
1674 __swab64s (&b->pb_pre_versions[3]);
1675 CLASSERT(offsetof(typeof(*b), pb_padding) != 0);
1676
1677
1678
1679
1680
1681 CLASSERT(offsetof(typeof(*b), pb_jobid) != 0);
1682}
1683EXPORT_SYMBOL(lustre_swab_ptlrpc_body);
1684
1685void lustre_swab_connect(struct obd_connect_data *ocd)
1686{
1687 __swab64s(&ocd->ocd_connect_flags);
1688 __swab32s(&ocd->ocd_version);
1689 __swab32s(&ocd->ocd_grant);
1690 __swab64s(&ocd->ocd_ibits_known);
1691 __swab32s(&ocd->ocd_index);
1692 __swab32s(&ocd->ocd_brw_size);
1693
1694
1695 __swab16s(&ocd->ocd_grant_extent);
1696 __swab32s(&ocd->ocd_unused);
1697 __swab64s(&ocd->ocd_transno);
1698 __swab32s(&ocd->ocd_group);
1699 __swab32s(&ocd->ocd_cksum_types);
1700 __swab32s(&ocd->ocd_instance);
1701
1702
1703
1704
1705 if (ocd->ocd_connect_flags & OBD_CONNECT_MAX_EASIZE)
1706 __swab32s(&ocd->ocd_max_easize);
1707 if (ocd->ocd_connect_flags & OBD_CONNECT_MAXBYTES)
1708 __swab64s(&ocd->ocd_maxbytes);
1709 CLASSERT(offsetof(typeof(*ocd), padding1) != 0);
1710 CLASSERT(offsetof(typeof(*ocd), padding2) != 0);
1711 CLASSERT(offsetof(typeof(*ocd), padding3) != 0);
1712 CLASSERT(offsetof(typeof(*ocd), padding4) != 0);
1713 CLASSERT(offsetof(typeof(*ocd), padding5) != 0);
1714 CLASSERT(offsetof(typeof(*ocd), padding6) != 0);
1715 CLASSERT(offsetof(typeof(*ocd), padding7) != 0);
1716 CLASSERT(offsetof(typeof(*ocd), padding8) != 0);
1717 CLASSERT(offsetof(typeof(*ocd), padding9) != 0);
1718 CLASSERT(offsetof(typeof(*ocd), paddingA) != 0);
1719 CLASSERT(offsetof(typeof(*ocd), paddingB) != 0);
1720 CLASSERT(offsetof(typeof(*ocd), paddingC) != 0);
1721 CLASSERT(offsetof(typeof(*ocd), paddingD) != 0);
1722 CLASSERT(offsetof(typeof(*ocd), paddingE) != 0);
1723 CLASSERT(offsetof(typeof(*ocd), paddingF) != 0);
1724}
1725
1726void lustre_swab_obdo (struct obdo *o)
1727{
1728 __swab64s (&o->o_valid);
1729 lustre_swab_ost_id(&o->o_oi);
1730 __swab64s (&o->o_parent_seq);
1731 __swab64s (&o->o_size);
1732 __swab64s (&o->o_mtime);
1733 __swab64s (&o->o_atime);
1734 __swab64s (&o->o_ctime);
1735 __swab64s (&o->o_blocks);
1736 __swab64s (&o->o_grant);
1737 __swab32s (&o->o_blksize);
1738 __swab32s (&o->o_mode);
1739 __swab32s (&o->o_uid);
1740 __swab32s (&o->o_gid);
1741 __swab32s (&o->o_flags);
1742 __swab32s (&o->o_nlink);
1743 __swab32s (&o->o_parent_oid);
1744 __swab32s (&o->o_misc);
1745 __swab64s (&o->o_ioepoch);
1746 __swab32s (&o->o_stripe_idx);
1747 __swab32s (&o->o_parent_ver);
1748
1749
1750 __swab32s (&o->o_uid_h);
1751 __swab32s (&o->o_gid_h);
1752 __swab64s (&o->o_data_version);
1753 CLASSERT(offsetof(typeof(*o), o_padding_4) != 0);
1754 CLASSERT(offsetof(typeof(*o), o_padding_5) != 0);
1755 CLASSERT(offsetof(typeof(*o), o_padding_6) != 0);
1756
1757}
1758EXPORT_SYMBOL(lustre_swab_obdo);
1759
1760void lustre_swab_obd_statfs (struct obd_statfs *os)
1761{
1762 __swab64s (&os->os_type);
1763 __swab64s (&os->os_blocks);
1764 __swab64s (&os->os_bfree);
1765 __swab64s (&os->os_bavail);
1766 __swab64s (&os->os_files);
1767 __swab64s (&os->os_ffree);
1768
1769 __swab32s (&os->os_bsize);
1770 __swab32s (&os->os_namelen);
1771 __swab64s (&os->os_maxbytes);
1772 __swab32s (&os->os_state);
1773 CLASSERT(offsetof(typeof(*os), os_fprecreated) != 0);
1774 CLASSERT(offsetof(typeof(*os), os_spare2) != 0);
1775 CLASSERT(offsetof(typeof(*os), os_spare3) != 0);
1776 CLASSERT(offsetof(typeof(*os), os_spare4) != 0);
1777 CLASSERT(offsetof(typeof(*os), os_spare5) != 0);
1778 CLASSERT(offsetof(typeof(*os), os_spare6) != 0);
1779 CLASSERT(offsetof(typeof(*os), os_spare7) != 0);
1780 CLASSERT(offsetof(typeof(*os), os_spare8) != 0);
1781 CLASSERT(offsetof(typeof(*os), os_spare9) != 0);
1782}
1783EXPORT_SYMBOL(lustre_swab_obd_statfs);
1784
1785void lustre_swab_obd_ioobj(struct obd_ioobj *ioo)
1786{
1787 lustre_swab_ost_id(&ioo->ioo_oid);
1788 __swab32s(&ioo->ioo_max_brw);
1789 __swab32s(&ioo->ioo_bufcnt);
1790}
1791EXPORT_SYMBOL(lustre_swab_obd_ioobj);
1792
1793void lustre_swab_niobuf_remote (struct niobuf_remote *nbr)
1794{
1795 __swab64s (&nbr->offset);
1796 __swab32s (&nbr->len);
1797 __swab32s (&nbr->flags);
1798}
1799EXPORT_SYMBOL(lustre_swab_niobuf_remote);
1800
1801void lustre_swab_ost_body (struct ost_body *b)
1802{
1803 lustre_swab_obdo (&b->oa);
1804}
1805EXPORT_SYMBOL(lustre_swab_ost_body);
1806
1807void lustre_swab_ost_last_id(obd_id *id)
1808{
1809 __swab64s(id);
1810}
1811EXPORT_SYMBOL(lustre_swab_ost_last_id);
1812
1813void lustre_swab_generic_32s(__u32 *val)
1814{
1815 __swab32s(val);
1816}
1817EXPORT_SYMBOL(lustre_swab_generic_32s);
1818
1819void lustre_swab_gl_desc(union ldlm_gl_desc *desc)
1820{
1821 lustre_swab_lu_fid(&desc->lquota_desc.gl_id.qid_fid);
1822 __swab64s(&desc->lquota_desc.gl_flags);
1823 __swab64s(&desc->lquota_desc.gl_ver);
1824 __swab64s(&desc->lquota_desc.gl_hardlimit);
1825 __swab64s(&desc->lquota_desc.gl_softlimit);
1826 __swab64s(&desc->lquota_desc.gl_time);
1827 CLASSERT(offsetof(typeof(desc->lquota_desc), gl_pad2) != 0);
1828}
1829
1830void lustre_swab_ost_lvb_v1(struct ost_lvb_v1 *lvb)
1831{
1832 __swab64s(&lvb->lvb_size);
1833 __swab64s(&lvb->lvb_mtime);
1834 __swab64s(&lvb->lvb_atime);
1835 __swab64s(&lvb->lvb_ctime);
1836 __swab64s(&lvb->lvb_blocks);
1837}
1838EXPORT_SYMBOL(lustre_swab_ost_lvb_v1);
1839
1840void lustre_swab_ost_lvb(struct ost_lvb *lvb)
1841{
1842 __swab64s(&lvb->lvb_size);
1843 __swab64s(&lvb->lvb_mtime);
1844 __swab64s(&lvb->lvb_atime);
1845 __swab64s(&lvb->lvb_ctime);
1846 __swab64s(&lvb->lvb_blocks);
1847 __swab32s(&lvb->lvb_mtime_ns);
1848 __swab32s(&lvb->lvb_atime_ns);
1849 __swab32s(&lvb->lvb_ctime_ns);
1850 __swab32s(&lvb->lvb_padding);
1851}
1852EXPORT_SYMBOL(lustre_swab_ost_lvb);
1853
1854void lustre_swab_lquota_lvb(struct lquota_lvb *lvb)
1855{
1856 __swab64s(&lvb->lvb_flags);
1857 __swab64s(&lvb->lvb_id_may_rel);
1858 __swab64s(&lvb->lvb_id_rel);
1859 __swab64s(&lvb->lvb_id_qunit);
1860 __swab64s(&lvb->lvb_pad1);
1861}
1862EXPORT_SYMBOL(lustre_swab_lquota_lvb);
1863
1864void lustre_swab_mdt_body (struct mdt_body *b)
1865{
1866 lustre_swab_lu_fid (&b->fid1);
1867 lustre_swab_lu_fid (&b->fid2);
1868
1869 __swab64s (&b->valid);
1870 __swab64s (&b->size);
1871 __swab64s (&b->mtime);
1872 __swab64s (&b->atime);
1873 __swab64s (&b->ctime);
1874 __swab64s (&b->blocks);
1875 __swab64s (&b->ioepoch);
1876 CLASSERT(offsetof(typeof(*b), unused1) != 0);
1877 __swab32s (&b->fsuid);
1878 __swab32s (&b->fsgid);
1879 __swab32s (&b->capability);
1880 __swab32s (&b->mode);
1881 __swab32s (&b->uid);
1882 __swab32s (&b->gid);
1883 __swab32s (&b->flags);
1884 __swab32s (&b->rdev);
1885 __swab32s (&b->nlink);
1886 CLASSERT(offsetof(typeof(*b), unused2) != 0);
1887 __swab32s (&b->suppgid);
1888 __swab32s (&b->eadatasize);
1889 __swab32s (&b->aclsize);
1890 __swab32s (&b->max_mdsize);
1891 __swab32s (&b->max_cookiesize);
1892 __swab32s (&b->uid_h);
1893 __swab32s (&b->gid_h);
1894 CLASSERT(offsetof(typeof(*b), padding_5) != 0);
1895}
1896EXPORT_SYMBOL(lustre_swab_mdt_body);
1897
1898void lustre_swab_mdt_ioepoch (struct mdt_ioepoch *b)
1899{
1900
1901 __swab64s (&b->ioepoch);
1902 __swab32s (&b->flags);
1903 CLASSERT(offsetof(typeof(*b), padding) != 0);
1904}
1905EXPORT_SYMBOL(lustre_swab_mdt_ioepoch);
1906
1907void lustre_swab_mgs_target_info(struct mgs_target_info *mti)
1908{
1909 int i;
1910 __swab32s(&mti->mti_lustre_ver);
1911 __swab32s(&mti->mti_stripe_index);
1912 __swab32s(&mti->mti_config_ver);
1913 __swab32s(&mti->mti_flags);
1914 __swab32s(&mti->mti_instance);
1915 __swab32s(&mti->mti_nid_count);
1916 CLASSERT(sizeof(lnet_nid_t) == sizeof(__u64));
1917 for (i = 0; i < MTI_NIDS_MAX; i++)
1918 __swab64s(&mti->mti_nids[i]);
1919}
1920EXPORT_SYMBOL(lustre_swab_mgs_target_info);
1921
1922void lustre_swab_mgs_nidtbl_entry(struct mgs_nidtbl_entry *entry)
1923{
1924 int i;
1925
1926 __swab64s(&entry->mne_version);
1927 __swab32s(&entry->mne_instance);
1928 __swab32s(&entry->mne_index);
1929 __swab32s(&entry->mne_length);
1930
1931
1932
1933 CLASSERT(sizeof(entry->mne_nid_count) == sizeof(__u8));
1934 CLASSERT(sizeof(entry->mne_nid_type) == sizeof(__u8));
1935
1936
1937 LASSERT(entry->mne_nid_type == 0);
1938 for (i = 0; i < entry->mne_nid_count; i++) {
1939 CLASSERT(sizeof(lnet_nid_t) == sizeof(__u64));
1940 __swab64s(&entry->u.nids[i]);
1941 }
1942}
1943EXPORT_SYMBOL(lustre_swab_mgs_nidtbl_entry);
1944
1945void lustre_swab_mgs_config_body(struct mgs_config_body *body)
1946{
1947 __swab64s(&body->mcb_offset);
1948 __swab32s(&body->mcb_units);
1949 __swab16s(&body->mcb_type);
1950}
1951EXPORT_SYMBOL(lustre_swab_mgs_config_body);
1952
1953void lustre_swab_mgs_config_res(struct mgs_config_res *body)
1954{
1955 __swab64s(&body->mcr_offset);
1956 __swab64s(&body->mcr_size);
1957}
1958EXPORT_SYMBOL(lustre_swab_mgs_config_res);
1959
1960static void lustre_swab_obd_dqinfo (struct obd_dqinfo *i)
1961{
1962 __swab64s (&i->dqi_bgrace);
1963 __swab64s (&i->dqi_igrace);
1964 __swab32s (&i->dqi_flags);
1965 __swab32s (&i->dqi_valid);
1966}
1967
1968static void lustre_swab_obd_dqblk (struct obd_dqblk *b)
1969{
1970 __swab64s (&b->dqb_ihardlimit);
1971 __swab64s (&b->dqb_isoftlimit);
1972 __swab64s (&b->dqb_curinodes);
1973 __swab64s (&b->dqb_bhardlimit);
1974 __swab64s (&b->dqb_bsoftlimit);
1975 __swab64s (&b->dqb_curspace);
1976 __swab64s (&b->dqb_btime);
1977 __swab64s (&b->dqb_itime);
1978 __swab32s (&b->dqb_valid);
1979 CLASSERT(offsetof(typeof(*b), dqb_padding) != 0);
1980}
1981
1982void lustre_swab_obd_quotactl (struct obd_quotactl *q)
1983{
1984 __swab32s (&q->qc_cmd);
1985 __swab32s (&q->qc_type);
1986 __swab32s (&q->qc_id);
1987 __swab32s (&q->qc_stat);
1988 lustre_swab_obd_dqinfo (&q->qc_dqinfo);
1989 lustre_swab_obd_dqblk (&q->qc_dqblk);
1990}
1991EXPORT_SYMBOL(lustre_swab_obd_quotactl);
1992
1993void lustre_swab_mdt_remote_perm (struct mdt_remote_perm *p)
1994{
1995 __swab32s (&p->rp_uid);
1996 __swab32s (&p->rp_gid);
1997 __swab32s (&p->rp_fsuid);
1998 __swab32s (&p->rp_fsuid_h);
1999 __swab32s (&p->rp_fsgid);
2000 __swab32s (&p->rp_fsgid_h);
2001 __swab32s (&p->rp_access_perm);
2002 __swab32s (&p->rp_padding);
2003};
2004EXPORT_SYMBOL(lustre_swab_mdt_remote_perm);
2005
2006void lustre_swab_fid2path(struct getinfo_fid2path *gf)
2007{
2008 lustre_swab_lu_fid(&gf->gf_fid);
2009 __swab64s(&gf->gf_recno);
2010 __swab32s(&gf->gf_linkno);
2011 __swab32s(&gf->gf_pathlen);
2012}
2013EXPORT_SYMBOL(lustre_swab_fid2path);
2014
2015void lustre_swab_fiemap_extent(struct ll_fiemap_extent *fm_extent)
2016{
2017 __swab64s(&fm_extent->fe_logical);
2018 __swab64s(&fm_extent->fe_physical);
2019 __swab64s(&fm_extent->fe_length);
2020 __swab32s(&fm_extent->fe_flags);
2021 __swab32s(&fm_extent->fe_device);
2022}
2023
2024void lustre_swab_fiemap(struct ll_user_fiemap *fiemap)
2025{
2026 int i;
2027
2028 __swab64s(&fiemap->fm_start);
2029 __swab64s(&fiemap->fm_length);
2030 __swab32s(&fiemap->fm_flags);
2031 __swab32s(&fiemap->fm_mapped_extents);
2032 __swab32s(&fiemap->fm_extent_count);
2033 __swab32s(&fiemap->fm_reserved);
2034
2035 for (i = 0; i < fiemap->fm_mapped_extents; i++)
2036 lustre_swab_fiemap_extent(&fiemap->fm_extents[i]);
2037}
2038EXPORT_SYMBOL(lustre_swab_fiemap);
2039
2040void lustre_swab_idx_info(struct idx_info *ii)
2041{
2042 __swab32s(&ii->ii_magic);
2043 __swab32s(&ii->ii_flags);
2044 __swab16s(&ii->ii_count);
2045 __swab32s(&ii->ii_attrs);
2046 lustre_swab_lu_fid(&ii->ii_fid);
2047 __swab64s(&ii->ii_version);
2048 __swab64s(&ii->ii_hash_start);
2049 __swab64s(&ii->ii_hash_end);
2050 __swab16s(&ii->ii_keysize);
2051 __swab16s(&ii->ii_recsize);
2052}
2053
2054void lustre_swab_lip_header(struct lu_idxpage *lip)
2055{
2056
2057 __swab32s(&lip->lip_magic);
2058 __swab16s(&lip->lip_flags);
2059 __swab16s(&lip->lip_nr);
2060}
2061EXPORT_SYMBOL(lustre_swab_lip_header);
2062
2063void lustre_swab_mdt_rec_reint (struct mdt_rec_reint *rr)
2064{
2065 __swab32s(&rr->rr_opcode);
2066 __swab32s(&rr->rr_cap);
2067 __swab32s(&rr->rr_fsuid);
2068
2069 __swab32s(&rr->rr_fsgid);
2070
2071 __swab32s(&rr->rr_suppgid1);
2072
2073 __swab32s(&rr->rr_suppgid2);
2074
2075 lustre_swab_lu_fid(&rr->rr_fid1);
2076 lustre_swab_lu_fid(&rr->rr_fid2);
2077 __swab64s(&rr->rr_mtime);
2078 __swab64s(&rr->rr_atime);
2079 __swab64s(&rr->rr_ctime);
2080 __swab64s(&rr->rr_size);
2081 __swab64s(&rr->rr_blocks);
2082 __swab32s(&rr->rr_bias);
2083 __swab32s(&rr->rr_mode);
2084 __swab32s(&rr->rr_flags);
2085 __swab32s(&rr->rr_flags_h);
2086 __swab32s(&rr->rr_umask);
2087
2088 CLASSERT(offsetof(typeof(*rr), rr_padding_4) != 0);
2089};
2090EXPORT_SYMBOL(lustre_swab_mdt_rec_reint);
2091
2092void lustre_swab_lov_desc (struct lov_desc *ld)
2093{
2094 __swab32s (&ld->ld_tgt_count);
2095 __swab32s (&ld->ld_active_tgt_count);
2096 __swab32s (&ld->ld_default_stripe_count);
2097 __swab32s (&ld->ld_pattern);
2098 __swab64s (&ld->ld_default_stripe_size);
2099 __swab64s (&ld->ld_default_stripe_offset);
2100 __swab32s (&ld->ld_qos_maxage);
2101
2102}
2103EXPORT_SYMBOL(lustre_swab_lov_desc);
2104
2105void lustre_swab_lmv_desc (struct lmv_desc *ld)
2106{
2107 __swab32s (&ld->ld_tgt_count);
2108 __swab32s (&ld->ld_active_tgt_count);
2109 __swab32s (&ld->ld_default_stripe_count);
2110 __swab32s (&ld->ld_pattern);
2111 __swab64s (&ld->ld_default_hash_size);
2112 __swab32s (&ld->ld_qos_maxage);
2113
2114}
2115
2116void lustre_swab_lmv_stripe_md (struct lmv_stripe_md *mea)
2117{
2118 __swab32s(&mea->mea_magic);
2119 __swab32s(&mea->mea_count);
2120 __swab32s(&mea->mea_master);
2121 CLASSERT(offsetof(typeof(*mea), mea_padding) != 0);
2122}
2123
2124void lustre_swab_lmv_user_md(struct lmv_user_md *lum)
2125{
2126 int i;
2127
2128 __swab32s(&lum->lum_magic);
2129 __swab32s(&lum->lum_stripe_count);
2130 __swab32s(&lum->lum_stripe_offset);
2131 __swab32s(&lum->lum_hash_type);
2132 __swab32s(&lum->lum_type);
2133 CLASSERT(offsetof(typeof(*lum), lum_padding1) != 0);
2134 CLASSERT(offsetof(typeof(*lum), lum_padding2) != 0);
2135 CLASSERT(offsetof(typeof(*lum), lum_padding3) != 0);
2136
2137 for (i = 0; i < lum->lum_stripe_count; i++) {
2138 __swab32s(&lum->lum_objects[i].lum_mds);
2139 lustre_swab_lu_fid(&lum->lum_objects[i].lum_fid);
2140 }
2141
2142}
2143EXPORT_SYMBOL(lustre_swab_lmv_user_md);
2144
2145static void print_lum (struct lov_user_md *lum)
2146{
2147 CDEBUG(D_OTHER, "lov_user_md %p:\n", lum);
2148 CDEBUG(D_OTHER, "\tlmm_magic: %#x\n", lum->lmm_magic);
2149 CDEBUG(D_OTHER, "\tlmm_pattern: %#x\n", lum->lmm_pattern);
2150 CDEBUG(D_OTHER, "\tlmm_object_id: "LPU64"\n", lmm_oi_id(&lum->lmm_oi));
2151 CDEBUG(D_OTHER, "\tlmm_object_gr: "LPU64"\n", lmm_oi_seq(&lum->lmm_oi));
2152 CDEBUG(D_OTHER, "\tlmm_stripe_size: %#x\n", lum->lmm_stripe_size);
2153 CDEBUG(D_OTHER, "\tlmm_stripe_count: %#x\n", lum->lmm_stripe_count);
2154 CDEBUG(D_OTHER, "\tlmm_stripe_offset/lmm_layout_gen: %#x\n",
2155 lum->lmm_stripe_offset);
2156}
2157
2158static void lustre_swab_lmm_oi(struct ost_id *oi)
2159{
2160 __swab64s(&oi->oi.oi_id);
2161 __swab64s(&oi->oi.oi_seq);
2162}
2163
2164static void lustre_swab_lov_user_md_common(struct lov_user_md_v1 *lum)
2165{
2166 __swab32s(&lum->lmm_magic);
2167 __swab32s(&lum->lmm_pattern);
2168 lustre_swab_lmm_oi(&lum->lmm_oi);
2169 __swab32s(&lum->lmm_stripe_size);
2170 __swab16s(&lum->lmm_stripe_count);
2171 __swab16s(&lum->lmm_stripe_offset);
2172 print_lum(lum);
2173}
2174
2175void lustre_swab_lov_user_md_v1(struct lov_user_md_v1 *lum)
2176{
2177 CDEBUG(D_IOCTL, "swabbing lov_user_md v1\n");
2178 lustre_swab_lov_user_md_common(lum);
2179}
2180EXPORT_SYMBOL(lustre_swab_lov_user_md_v1);
2181
2182void lustre_swab_lov_user_md_v3(struct lov_user_md_v3 *lum)
2183{
2184 CDEBUG(D_IOCTL, "swabbing lov_user_md v3\n");
2185 lustre_swab_lov_user_md_common((struct lov_user_md_v1 *)lum);
2186
2187}
2188EXPORT_SYMBOL(lustre_swab_lov_user_md_v3);
2189
2190void lustre_swab_lov_mds_md(struct lov_mds_md *lmm)
2191{
2192 CDEBUG(D_IOCTL, "swabbing lov_mds_md\n");
2193 __swab32s(&lmm->lmm_magic);
2194 __swab32s(&lmm->lmm_pattern);
2195 lustre_swab_lmm_oi(&lmm->lmm_oi);
2196 __swab32s(&lmm->lmm_stripe_size);
2197 __swab16s(&lmm->lmm_stripe_count);
2198 __swab16s(&lmm->lmm_layout_gen);
2199}
2200EXPORT_SYMBOL(lustre_swab_lov_mds_md);
2201
2202void lustre_swab_lov_user_md_objects(struct lov_user_ost_data *lod,
2203 int stripe_count)
2204{
2205 int i;
2206
2207 for (i = 0; i < stripe_count; i++) {
2208 lustre_swab_ost_id(&(lod[i].l_ost_oi));
2209 __swab32s(&(lod[i].l_ost_gen));
2210 __swab32s(&(lod[i].l_ost_idx));
2211 }
2212}
2213EXPORT_SYMBOL(lustre_swab_lov_user_md_objects);
2214
2215void lustre_swab_ldlm_res_id (struct ldlm_res_id *id)
2216{
2217 int i;
2218
2219 for (i = 0; i < RES_NAME_SIZE; i++)
2220 __swab64s (&id->name[i]);
2221}
2222EXPORT_SYMBOL(lustre_swab_ldlm_res_id);
2223
2224void lustre_swab_ldlm_policy_data (ldlm_wire_policy_data_t *d)
2225{
2226
2227
2228
2229 __swab64s(&d->l_extent.start);
2230 __swab64s(&d->l_extent.end);
2231 __swab64s(&d->l_extent.gid);
2232 __swab64s(&d->l_flock.lfw_owner);
2233 __swab32s(&d->l_flock.lfw_pid);
2234}
2235EXPORT_SYMBOL(lustre_swab_ldlm_policy_data);
2236
2237void lustre_swab_ldlm_intent (struct ldlm_intent *i)
2238{
2239 __swab64s (&i->opc);
2240}
2241EXPORT_SYMBOL(lustre_swab_ldlm_intent);
2242
2243void lustre_swab_ldlm_resource_desc (struct ldlm_resource_desc *r)
2244{
2245 __swab32s (&r->lr_type);
2246 CLASSERT(offsetof(typeof(*r), lr_padding) != 0);
2247 lustre_swab_ldlm_res_id (&r->lr_name);
2248}
2249EXPORT_SYMBOL(lustre_swab_ldlm_resource_desc);
2250
2251void lustre_swab_ldlm_lock_desc (struct ldlm_lock_desc *l)
2252{
2253 lustre_swab_ldlm_resource_desc (&l->l_resource);
2254 __swab32s (&l->l_req_mode);
2255 __swab32s (&l->l_granted_mode);
2256 lustre_swab_ldlm_policy_data (&l->l_policy_data);
2257}
2258EXPORT_SYMBOL(lustre_swab_ldlm_lock_desc);
2259
2260void lustre_swab_ldlm_request (struct ldlm_request *rq)
2261{
2262 __swab32s (&rq->lock_flags);
2263 lustre_swab_ldlm_lock_desc (&rq->lock_desc);
2264 __swab32s (&rq->lock_count);
2265
2266}
2267EXPORT_SYMBOL(lustre_swab_ldlm_request);
2268
2269void lustre_swab_ldlm_reply (struct ldlm_reply *r)
2270{
2271 __swab32s (&r->lock_flags);
2272 CLASSERT(offsetof(typeof(*r), lock_padding) != 0);
2273 lustre_swab_ldlm_lock_desc (&r->lock_desc);
2274
2275 __swab64s (&r->lock_policy_res1);
2276 __swab64s (&r->lock_policy_res2);
2277}
2278EXPORT_SYMBOL(lustre_swab_ldlm_reply);
2279
2280void lustre_swab_quota_body(struct quota_body *b)
2281{
2282 lustre_swab_lu_fid(&b->qb_fid);
2283 lustre_swab_lu_fid((struct lu_fid *)&b->qb_id);
2284 __swab32s(&b->qb_flags);
2285 __swab64s(&b->qb_count);
2286 __swab64s(&b->qb_usage);
2287 __swab64s(&b->qb_slv_ver);
2288}
2289
2290
2291void dump_ioo(struct obd_ioobj *ioo)
2292{
2293 CDEBUG(D_RPCTRACE,
2294 "obd_ioobj: ioo_oid="DOSTID", ioo_max_brw=%#x, "
2295 "ioo_bufct=%d\n", POSTID(&ioo->ioo_oid), ioo->ioo_max_brw,
2296 ioo->ioo_bufcnt);
2297}
2298EXPORT_SYMBOL(dump_ioo);
2299
2300void dump_rniobuf(struct niobuf_remote *nb)
2301{
2302 CDEBUG(D_RPCTRACE, "niobuf_remote: offset="LPU64", len=%d, flags=%x\n",
2303 nb->offset, nb->len, nb->flags);
2304}
2305EXPORT_SYMBOL(dump_rniobuf);
2306
2307void dump_obdo(struct obdo *oa)
2308{
2309 __u32 valid = oa->o_valid;
2310
2311 CDEBUG(D_RPCTRACE, "obdo: o_valid = %08x\n", valid);
2312 if (valid & OBD_MD_FLID)
2313 CDEBUG(D_RPCTRACE, "obdo: id = "DOSTID"\n", POSTID(&oa->o_oi));
2314 if (valid & OBD_MD_FLFID)
2315 CDEBUG(D_RPCTRACE, "obdo: o_parent_seq = "LPX64"\n",
2316 oa->o_parent_seq);
2317 if (valid & OBD_MD_FLSIZE)
2318 CDEBUG(D_RPCTRACE, "obdo: o_size = "LPD64"\n", oa->o_size);
2319 if (valid & OBD_MD_FLMTIME)
2320 CDEBUG(D_RPCTRACE, "obdo: o_mtime = "LPD64"\n", oa->o_mtime);
2321 if (valid & OBD_MD_FLATIME)
2322 CDEBUG(D_RPCTRACE, "obdo: o_atime = "LPD64"\n", oa->o_atime);
2323 if (valid & OBD_MD_FLCTIME)
2324 CDEBUG(D_RPCTRACE, "obdo: o_ctime = "LPD64"\n", oa->o_ctime);
2325 if (valid & OBD_MD_FLBLOCKS)
2326 CDEBUG(D_RPCTRACE, "obdo: o_blocks = "LPD64"\n", oa->o_blocks);
2327 if (valid & OBD_MD_FLGRANT)
2328 CDEBUG(D_RPCTRACE, "obdo: o_grant = "LPD64"\n", oa->o_grant);
2329 if (valid & OBD_MD_FLBLKSZ)
2330 CDEBUG(D_RPCTRACE, "obdo: o_blksize = %d\n", oa->o_blksize);
2331 if (valid & (OBD_MD_FLTYPE | OBD_MD_FLMODE))
2332 CDEBUG(D_RPCTRACE, "obdo: o_mode = %o\n",
2333 oa->o_mode & ((valid & OBD_MD_FLTYPE ? S_IFMT : 0) |
2334 (valid & OBD_MD_FLMODE ? ~S_IFMT : 0)));
2335 if (valid & OBD_MD_FLUID)
2336 CDEBUG(D_RPCTRACE, "obdo: o_uid = %u\n", oa->o_uid);
2337 if (valid & OBD_MD_FLUID)
2338 CDEBUG(D_RPCTRACE, "obdo: o_uid_h = %u\n", oa->o_uid_h);
2339 if (valid & OBD_MD_FLGID)
2340 CDEBUG(D_RPCTRACE, "obdo: o_gid = %u\n", oa->o_gid);
2341 if (valid & OBD_MD_FLGID)
2342 CDEBUG(D_RPCTRACE, "obdo: o_gid_h = %u\n", oa->o_gid_h);
2343 if (valid & OBD_MD_FLFLAGS)
2344 CDEBUG(D_RPCTRACE, "obdo: o_flags = %x\n", oa->o_flags);
2345 if (valid & OBD_MD_FLNLINK)
2346 CDEBUG(D_RPCTRACE, "obdo: o_nlink = %u\n", oa->o_nlink);
2347 else if (valid & OBD_MD_FLCKSUM)
2348 CDEBUG(D_RPCTRACE, "obdo: o_checksum (o_nlink) = %u\n",
2349 oa->o_nlink);
2350 if (valid & OBD_MD_FLGENER)
2351 CDEBUG(D_RPCTRACE, "obdo: o_parent_oid = %x\n",
2352 oa->o_parent_oid);
2353 if (valid & OBD_MD_FLEPOCH)
2354 CDEBUG(D_RPCTRACE, "obdo: o_ioepoch = "LPD64"\n",
2355 oa->o_ioepoch);
2356 if (valid & OBD_MD_FLFID) {
2357 CDEBUG(D_RPCTRACE, "obdo: o_stripe_idx = %u\n",
2358 oa->o_stripe_idx);
2359 CDEBUG(D_RPCTRACE, "obdo: o_parent_ver = %x\n",
2360 oa->o_parent_ver);
2361 }
2362 if (valid & OBD_MD_FLHANDLE)
2363 CDEBUG(D_RPCTRACE, "obdo: o_handle = "LPD64"\n",
2364 oa->o_handle.cookie);
2365 if (valid & OBD_MD_FLCOOKIE)
2366 CDEBUG(D_RPCTRACE, "obdo: o_lcookie = "
2367 "(llog_cookie dumping not yet implemented)\n");
2368}
2369EXPORT_SYMBOL(dump_obdo);
2370
2371void dump_ost_body(struct ost_body *ob)
2372{
2373 dump_obdo(&ob->oa);
2374}
2375EXPORT_SYMBOL(dump_ost_body);
2376
2377void dump_rcs(__u32 *rc)
2378{
2379 CDEBUG(D_RPCTRACE, "rmf_rcs: %d\n", *rc);
2380}
2381EXPORT_SYMBOL(dump_rcs);
2382
2383static inline int req_ptlrpc_body_swabbed(struct ptlrpc_request *req)
2384{
2385 LASSERT(req->rq_reqmsg);
2386
2387 switch (req->rq_reqmsg->lm_magic) {
2388 case LUSTRE_MSG_MAGIC_V2:
2389 return lustre_req_swabbed(req, MSG_PTLRPC_BODY_OFF);
2390 default:
2391 CERROR("bad lustre msg magic: %#08X\n",
2392 req->rq_reqmsg->lm_magic);
2393 }
2394 return 0;
2395}
2396
2397static inline int rep_ptlrpc_body_swabbed(struct ptlrpc_request *req)
2398{
2399 LASSERT(req->rq_repmsg);
2400
2401 switch (req->rq_repmsg->lm_magic) {
2402 case LUSTRE_MSG_MAGIC_V2:
2403 return lustre_rep_swabbed(req, MSG_PTLRPC_BODY_OFF);
2404 default:
2405
2406 return 0;
2407 }
2408}
2409
2410void _debug_req(struct ptlrpc_request *req,
2411 struct libcfs_debug_msg_data *msgdata,
2412 const char *fmt, ... )
2413{
2414 int req_ok = req->rq_reqmsg != NULL;
2415 int rep_ok = req->rq_repmsg != NULL;
2416 lnet_nid_t nid = LNET_NID_ANY;
2417 va_list args;
2418
2419 if (ptlrpc_req_need_swab(req)) {
2420 req_ok = req_ok && req_ptlrpc_body_swabbed(req);
2421 rep_ok = rep_ok && rep_ptlrpc_body_swabbed(req);
2422 }
2423
2424 if (req->rq_import && req->rq_import->imp_connection)
2425 nid = req->rq_import->imp_connection->c_peer.nid;
2426 else if (req->rq_export && req->rq_export->exp_connection)
2427 nid = req->rq_export->exp_connection->c_peer.nid;
2428
2429 va_start(args, fmt);
2430 libcfs_debug_vmsg2(msgdata, fmt, args,
2431 " req@%p x"LPU64"/t"LPD64"("LPD64") o%d->%s@%s:%d/%d"
2432 " lens %d/%d e %d to %d dl "CFS_TIME_T" ref %d "
2433 "fl "REQ_FLAGS_FMT"/%x/%x rc %d/%d\n",
2434 req, req->rq_xid, req->rq_transno,
2435 req_ok ? lustre_msg_get_transno(req->rq_reqmsg) : 0,
2436 req_ok ? lustre_msg_get_opc(req->rq_reqmsg) : -1,
2437 req->rq_import ?
2438 req->rq_import->imp_obd->obd_name :
2439 req->rq_export ?
2440 req->rq_export->exp_client_uuid.uuid :
2441 "<?>",
2442 libcfs_nid2str(nid),
2443 req->rq_request_portal, req->rq_reply_portal,
2444 req->rq_reqlen, req->rq_replen,
2445 req->rq_early_count, req->rq_timedout,
2446 req->rq_deadline,
2447 atomic_read(&req->rq_refcount),
2448 DEBUG_REQ_FLAGS(req),
2449 req_ok ? lustre_msg_get_flags(req->rq_reqmsg) : -1,
2450 rep_ok ? lustre_msg_get_flags(req->rq_repmsg) : -1,
2451 req->rq_status,
2452 rep_ok ? lustre_msg_get_status(req->rq_repmsg) : -1);
2453 va_end(args);
2454}
2455EXPORT_SYMBOL(_debug_req);
2456
2457void lustre_swab_lustre_capa(struct lustre_capa *c)
2458{
2459 lustre_swab_lu_fid(&c->lc_fid);
2460 __swab64s (&c->lc_opc);
2461 __swab64s (&c->lc_uid);
2462 __swab64s (&c->lc_gid);
2463 __swab32s (&c->lc_flags);
2464 __swab32s (&c->lc_keyid);
2465 __swab32s (&c->lc_timeout);
2466 __swab32s (&c->lc_expiry);
2467}
2468EXPORT_SYMBOL(lustre_swab_lustre_capa);
2469
2470void lustre_swab_lustre_capa_key(struct lustre_capa_key *k)
2471{
2472 __swab64s (&k->lk_seq);
2473 __swab32s (&k->lk_keyid);
2474 CLASSERT(offsetof(typeof(*k), lk_padding) != 0);
2475}
2476EXPORT_SYMBOL(lustre_swab_lustre_capa_key);
2477
2478void lustre_swab_hsm_user_state(struct hsm_user_state *state)
2479{
2480 __swab32s(&state->hus_states);
2481 __swab32s(&state->hus_archive_id);
2482}
2483EXPORT_SYMBOL(lustre_swab_hsm_user_state);
2484
2485void lustre_swab_hsm_state_set(struct hsm_state_set *hss)
2486{
2487 __swab32s(&hss->hss_valid);
2488 __swab64s(&hss->hss_setmask);
2489 __swab64s(&hss->hss_clearmask);
2490 __swab32s(&hss->hss_archive_id);
2491}
2492EXPORT_SYMBOL(lustre_swab_hsm_state_set);
2493
2494void lustre_swab_hsm_extent(struct hsm_extent *extent)
2495{
2496 __swab64s(&extent->offset);
2497 __swab64s(&extent->length);
2498}
2499
2500void lustre_swab_hsm_current_action(struct hsm_current_action *action)
2501{
2502 __swab32s(&action->hca_state);
2503 __swab32s(&action->hca_action);
2504 lustre_swab_hsm_extent(&action->hca_location);
2505}
2506EXPORT_SYMBOL(lustre_swab_hsm_current_action);
2507
2508void lustre_swab_hsm_user_item(struct hsm_user_item *hui)
2509{
2510 lustre_swab_lu_fid(&hui->hui_fid);
2511 lustre_swab_hsm_extent(&hui->hui_extent);
2512}
2513EXPORT_SYMBOL(lustre_swab_hsm_user_item);
2514
2515void lustre_swab_layout_intent(struct layout_intent *li)
2516{
2517 __swab32s(&li->li_opc);
2518 __swab32s(&li->li_flags);
2519 __swab64s(&li->li_start);
2520 __swab64s(&li->li_end);
2521}
2522EXPORT_SYMBOL(lustre_swab_layout_intent);
2523
2524void lustre_swab_hsm_progress_kernel(struct hsm_progress_kernel *hpk)
2525{
2526 lustre_swab_lu_fid(&hpk->hpk_fid);
2527 __swab64s(&hpk->hpk_cookie);
2528 __swab64s(&hpk->hpk_extent.offset);
2529 __swab64s(&hpk->hpk_extent.length);
2530 __swab16s(&hpk->hpk_flags);
2531 __swab16s(&hpk->hpk_errval);
2532}
2533EXPORT_SYMBOL(lustre_swab_hsm_progress_kernel);
2534
2535void lustre_swab_hsm_request(struct hsm_request *hr)
2536{
2537 __swab32s(&hr->hr_action);
2538 __swab32s(&hr->hr_archive_id);
2539 __swab64s(&hr->hr_flags);
2540 __swab32s(&hr->hr_itemcount);
2541 __swab32s(&hr->hr_data_len);
2542}
2543EXPORT_SYMBOL(lustre_swab_hsm_request);
2544
2545void lustre_swab_update_buf(struct update_buf *ub)
2546{
2547 __swab32s(&ub->ub_magic);
2548 __swab32s(&ub->ub_count);
2549}
2550EXPORT_SYMBOL(lustre_swab_update_buf);
2551
2552void lustre_swab_update_reply_buf(struct update_reply *ur)
2553{
2554 int i;
2555
2556 __swab32s(&ur->ur_version);
2557 __swab32s(&ur->ur_count);
2558 for (i = 0; i < ur->ur_count; i++)
2559 __swab32s(&ur->ur_lens[i]);
2560}
2561EXPORT_SYMBOL(lustre_swab_update_reply_buf);
2562
2563void lustre_swab_swap_layouts(struct mdc_swap_layouts *msl)
2564{
2565 __swab64s(&msl->msl_flags);
2566}
2567EXPORT_SYMBOL(lustre_swab_swap_layouts);
2568