4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 only,
8 * as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License version 2 for more details (a copy is included
14 * in the LICENSE file that accompanied this code).
16 * You should have received a copy of the GNU General Public License
17 * version 2 along with this program; If not, see
18 * http://www.gnu.org/licenses/gpl-2.0.html
23 * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Use is subject to license terms.
26 * Copyright (c) 2011, 2017, Intel Corporation.
29 * This file is part of Lustre, http://www.lustre.org/
31 * lustre/ptlrpc/pack_generic.c
33 * (Un)packing of OST requests
35 * Author: Peter J. Braam <braam@clusterfs.com>
36 * Author: Phil Schwan <phil@clusterfs.com>
37 * Author: Eric Barton <eeb@clusterfs.com>
40 #define DEBUG_SUBSYSTEM S_RPC
42 #include <linux/crc32.h>
44 #include <libcfs/libcfs.h>
46 #include <llog_swab.h>
47 #include <lustre_net.h>
48 #include <lustre_swab.h>
49 #include <obd_cksum.h>
50 #include <obd_class.h>
51 #include <obd_support.h>
52 #include "ptlrpc_internal.h"
54 static inline __u32 lustre_msg_hdr_size_v2(__u32 count)
56 return round_up(offsetof(struct lustre_msg_v2, lm_buflens[count]), 8);
59 __u32 lustre_msg_hdr_size(__u32 magic, __u32 count)
64 case LUSTRE_MSG_MAGIC_V2:
65 return lustre_msg_hdr_size_v2(count);
67 LASSERTF(0, "incorrect message magic: %08x\n", magic);
72 static inline int lustre_msg_check_version_v2(struct lustre_msg_v2 *msg,
73 enum lustre_msg_version version)
75 enum lustre_msg_version ver = lustre_msg_get_version(msg);
77 return (ver & LUSTRE_VERSION_MASK) != version;
80 int lustre_msg_check_version(struct lustre_msg *msg,
81 enum lustre_msg_version version)
83 #define LUSTRE_MSG_MAGIC_V1 0x0BD00BD0
84 switch (msg->lm_magic) {
85 case LUSTRE_MSG_MAGIC_V1:
86 CERROR("msg v1 not supported - please upgrade you system\n");
88 case LUSTRE_MSG_MAGIC_V2:
89 return lustre_msg_check_version_v2(msg, version);
91 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
94 #undef LUSTRE_MSG_MAGIC_V1
97 __u32 lustre_msg_early_size;
98 EXPORT_SYMBOL(lustre_msg_early_size);
100 /* early reply size */
101 void lustre_msg_early_size_init(void)
103 __u32 pblen = sizeof(struct ptlrpc_body);
105 lustre_msg_early_size = lustre_msg_size(LUSTRE_MSG_MAGIC_V2, 1, &pblen);
108 __u32 lustre_msg_size_v2(int count, __u32 *lengths)
114 size = lustre_msg_hdr_size_v2(count);
115 for (i = 0; i < count; i++)
116 size += round_up(lengths[i], 8);
120 EXPORT_SYMBOL(lustre_msg_size_v2);
123 * This returns the size of the buffer that is required to hold a lustre_msg
124 * with the given sub-buffer lengths.
125 * NOTE: this should only be used for NEW requests, and should always be
126 * in the form of a v2 request. If this is a connection to a v1
127 * target then the first buffer will be stripped because the ptlrpc
128 * data is part of the lustre_msg_v1 header. b=14043
130 __u32 lustre_msg_size(__u32 magic, int count, __u32 *lens)
132 __u32 size[] = { sizeof(struct ptlrpc_body) };
140 LASSERT(lens[MSG_PTLRPC_BODY_OFF] >= sizeof(struct ptlrpc_body_v2));
143 case LUSTRE_MSG_MAGIC_V2:
144 return lustre_msg_size_v2(count, lens);
146 LASSERTF(0, "incorrect message magic: %08x\n", magic);
152 * This is used to determine the size of a buffer that was already packed
153 * and will correctly handle the different message formats.
155 __u32 lustre_packed_msg_size(struct lustre_msg *msg)
157 switch (msg->lm_magic) {
158 case LUSTRE_MSG_MAGIC_V2:
159 return lustre_msg_size_v2(msg->lm_bufcount, msg->lm_buflens);
161 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
165 EXPORT_SYMBOL(lustre_packed_msg_size);
167 void lustre_init_msg_v2(struct lustre_msg_v2 *msg, int count, __u32 *lens,
175 msg->lm_bufcount = count;
176 /* XXX: lm_secflvr uninitialized here */
177 msg->lm_magic = LUSTRE_MSG_MAGIC_V2;
179 for (i = 0; i < count; i++)
180 msg->lm_buflens[i] = lens[i];
185 ptr = (char *)msg + lustre_msg_hdr_size_v2(count);
186 for (i = 0; i < count; i++) {
190 memcpy(ptr, tmp, lens[i]);
191 ptr += round_up(lens[i], 8);
194 EXPORT_SYMBOL(lustre_init_msg_v2);
196 static int lustre_pack_request_v2(struct ptlrpc_request *req,
197 int count, __u32 *lens, char **bufs)
201 reqlen = lustre_msg_size_v2(count, lens);
203 rc = sptlrpc_cli_alloc_reqbuf(req, reqlen);
207 req->rq_reqlen = reqlen;
209 lustre_init_msg_v2(req->rq_reqmsg, count, lens, bufs);
210 lustre_msg_add_version(req->rq_reqmsg, PTLRPC_MSG_VERSION);
214 int lustre_pack_request(struct ptlrpc_request *req, __u32 magic, int count,
215 __u32 *lens, char **bufs)
217 __u32 size[] = { sizeof(struct ptlrpc_body) };
225 LASSERT(lens[MSG_PTLRPC_BODY_OFF] == sizeof(struct ptlrpc_body));
227 /* only use new format, we don't need to be compatible with 1.4 */
228 magic = LUSTRE_MSG_MAGIC_V2;
231 case LUSTRE_MSG_MAGIC_V2:
232 return lustre_pack_request_v2(req, count, lens, bufs);
234 LASSERTF(0, "incorrect message magic: %08x\n", magic);
240 struct list_head ptlrpc_rs_debug_lru =
241 LIST_HEAD_INIT(ptlrpc_rs_debug_lru);
242 spinlock_t ptlrpc_rs_debug_lock;
244 #define PTLRPC_RS_DEBUG_LRU_ADD(rs) \
246 spin_lock(&ptlrpc_rs_debug_lock); \
247 list_add_tail(&(rs)->rs_debug_list, &ptlrpc_rs_debug_lru); \
248 spin_unlock(&ptlrpc_rs_debug_lock); \
251 #define PTLRPC_RS_DEBUG_LRU_DEL(rs) \
253 spin_lock(&ptlrpc_rs_debug_lock); \
254 list_del(&(rs)->rs_debug_list); \
255 spin_unlock(&ptlrpc_rs_debug_lock); \
258 # define PTLRPC_RS_DEBUG_LRU_ADD(rs) do {} while(0)
259 # define PTLRPC_RS_DEBUG_LRU_DEL(rs) do {} while(0)
262 struct ptlrpc_reply_state *
263 lustre_get_emerg_rs(struct ptlrpc_service_part *svcpt)
265 struct ptlrpc_reply_state *rs = NULL;
267 spin_lock(&svcpt->scp_rep_lock);
269 /* See if we have anything in a pool, and wait if nothing */
270 while (list_empty(&svcpt->scp_rep_idle)) {
273 spin_unlock(&svcpt->scp_rep_lock);
274 /* If we cannot get anything for some long time, we better
275 * bail out instead of waiting infinitely */
276 rc = wait_event_idle_timeout(svcpt->scp_rep_waitq,
277 !list_empty(&svcpt->scp_rep_idle),
278 cfs_time_seconds(10));
281 spin_lock(&svcpt->scp_rep_lock);
284 rs = list_first_entry(&svcpt->scp_rep_idle,
285 struct ptlrpc_reply_state, rs_list);
286 list_del(&rs->rs_list);
288 spin_unlock(&svcpt->scp_rep_lock);
290 memset(rs, 0, svcpt->scp_service->srv_max_reply_size);
291 rs->rs_size = svcpt->scp_service->srv_max_reply_size;
292 rs->rs_svcpt = svcpt;
298 void lustre_put_emerg_rs(struct ptlrpc_reply_state *rs)
300 struct ptlrpc_service_part *svcpt = rs->rs_svcpt;
302 spin_lock(&svcpt->scp_rep_lock);
303 list_add(&rs->rs_list, &svcpt->scp_rep_idle);
304 spin_unlock(&svcpt->scp_rep_lock);
305 wake_up(&svcpt->scp_rep_waitq);
308 int lustre_pack_reply_v2(struct ptlrpc_request *req, int count,
309 __u32 *lens, char **bufs, int flags)
311 struct ptlrpc_reply_state *rs;
315 LASSERT(req->rq_reply_state == NULL);
318 if ((flags & LPRFL_EARLY_REPLY) == 0) {
319 spin_lock(&req->rq_lock);
320 req->rq_packed_final = 1;
321 spin_unlock(&req->rq_lock);
324 msg_len = lustre_msg_size_v2(count, lens);
325 rc = sptlrpc_svc_alloc_rs(req, msg_len);
329 rs = req->rq_reply_state;
330 atomic_set(&rs->rs_refcount, 1); /* 1 ref for rq_reply_state */
331 rs->rs_cb_id.cbid_fn = reply_out_callback;
332 rs->rs_cb_id.cbid_arg = rs;
333 rs->rs_svcpt = req->rq_rqbd->rqbd_svcpt;
334 INIT_LIST_HEAD(&rs->rs_exp_list);
335 INIT_LIST_HEAD(&rs->rs_obd_list);
336 INIT_LIST_HEAD(&rs->rs_list);
337 spin_lock_init(&rs->rs_lock);
339 req->rq_replen = msg_len;
340 req->rq_reply_state = rs;
341 req->rq_repmsg = rs->rs_msg;
343 lustre_init_msg_v2(rs->rs_msg, count, lens, bufs);
344 lustre_msg_add_version(rs->rs_msg, PTLRPC_MSG_VERSION);
346 PTLRPC_RS_DEBUG_LRU_ADD(rs);
350 EXPORT_SYMBOL(lustre_pack_reply_v2);
352 int lustre_pack_reply_flags(struct ptlrpc_request *req, int count, __u32 *lens,
353 char **bufs, int flags)
356 __u32 size[] = { sizeof(struct ptlrpc_body) };
364 LASSERT(lens[MSG_PTLRPC_BODY_OFF] == sizeof(struct ptlrpc_body));
366 switch (req->rq_reqmsg->lm_magic) {
367 case LUSTRE_MSG_MAGIC_V2:
368 rc = lustre_pack_reply_v2(req, count, lens, bufs, flags);
371 LASSERTF(0, "incorrect message magic: %08x\n",
372 req->rq_reqmsg->lm_magic);
376 CERROR("lustre_pack_reply failed: rc=%d size=%d\n", rc,
377 lustre_msg_size(req->rq_reqmsg->lm_magic, count, lens));
381 int lustre_pack_reply(struct ptlrpc_request *req, int count, __u32 *lens,
384 return lustre_pack_reply_flags(req, count, lens, bufs, 0);
386 EXPORT_SYMBOL(lustre_pack_reply);
388 void *lustre_msg_buf_v2(struct lustre_msg_v2 *m, __u32 n, __u32 min_size)
390 __u32 i, offset, buflen, bufcount;
393 LASSERT(m->lm_bufcount > 0);
395 bufcount = m->lm_bufcount;
396 if (unlikely(n >= bufcount)) {
397 CDEBUG(D_INFO, "msg %p buffer[%d] not present (count %d)\n",
402 buflen = m->lm_buflens[n];
403 if (unlikely(buflen < min_size)) {
404 CERROR("msg %p buffer[%d] size %d too small "
405 "(required %d, opc=%d)\n", m, n, buflen, min_size,
406 n == MSG_PTLRPC_BODY_OFF ? -1 : lustre_msg_get_opc(m));
410 offset = lustre_msg_hdr_size_v2(bufcount);
411 for (i = 0; i < n; i++)
412 offset += round_up(m->lm_buflens[i], 8);
414 return (char *)m + offset;
417 void *lustre_msg_buf(struct lustre_msg *m, __u32 n, __u32 min_size)
419 switch (m->lm_magic) {
420 case LUSTRE_MSG_MAGIC_V2:
421 return lustre_msg_buf_v2(m, n, min_size);
423 LASSERTF(0, "incorrect message magic: %08x (msg:%p)\n",
428 EXPORT_SYMBOL(lustre_msg_buf);
430 static int lustre_shrink_msg_v2(struct lustre_msg_v2 *msg, __u32 segment,
431 unsigned int newlen, int move_data)
433 char *tail = NULL, *newpos;
437 LASSERT(msg->lm_bufcount > segment);
438 LASSERT(msg->lm_buflens[segment] >= newlen);
440 if (msg->lm_buflens[segment] == newlen)
443 if (move_data && msg->lm_bufcount > segment + 1) {
444 tail = lustre_msg_buf_v2(msg, segment + 1, 0);
445 for (n = segment + 1; n < msg->lm_bufcount; n++)
446 tail_len += round_up(msg->lm_buflens[n], 8);
449 msg->lm_buflens[segment] = newlen;
451 if (tail && tail_len) {
452 newpos = lustre_msg_buf_v2(msg, segment + 1, 0);
453 LASSERT(newpos <= tail);
455 memmove(newpos, tail, tail_len);
458 return lustre_msg_size_v2(msg->lm_bufcount, msg->lm_buflens);
462 * for @msg, shrink @segment to size @newlen. if @move_data is non-zero,
463 * we also move data forward from @segment + 1.
465 * if @newlen == 0, we remove the segment completely, but we still keep the
466 * totally bufcount the same to save possible data moving. this will leave a
467 * unused segment with size 0 at the tail, but that's ok.
469 * return new msg size after shrinking.
472 * + if any buffers higher than @segment has been filled in, must call shrink
473 * with non-zero @move_data.
474 * + caller should NOT keep pointers to msg buffers which higher than @segment
477 int lustre_shrink_msg(struct lustre_msg *msg, int segment,
478 unsigned int newlen, int move_data)
480 switch (msg->lm_magic) {
481 case LUSTRE_MSG_MAGIC_V2:
482 return lustre_shrink_msg_v2(msg, segment, newlen, move_data);
484 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
487 EXPORT_SYMBOL(lustre_shrink_msg);
489 static int lustre_grow_msg_v2(struct lustre_msg_v2 *msg, __u32 segment,
492 char *tail = NULL, *newpos;
496 LASSERT(msg->lm_bufcount > segment);
497 LASSERT(msg->lm_buflens[segment] <= newlen);
499 if (msg->lm_buflens[segment] == newlen)
502 if (msg->lm_bufcount > segment + 1) {
503 tail = lustre_msg_buf_v2(msg, segment + 1, 0);
504 for (n = segment + 1; n < msg->lm_bufcount; n++)
505 tail_len += round_up(msg->lm_buflens[n], 8);
508 msg->lm_buflens[segment] = newlen;
510 if (tail && tail_len) {
511 newpos = lustre_msg_buf_v2(msg, segment + 1, 0);
512 memmove(newpos, tail, tail_len);
515 return lustre_msg_size_v2(msg->lm_bufcount, msg->lm_buflens);
519 * for @msg, grow @segment to size @newlen.
520 * Always move higher buffer forward.
522 * return new msg size after growing.
525 * - caller must make sure there is enough space in allocated message buffer
526 * - caller should NOT keep pointers to msg buffers which higher than @segment
529 int lustre_grow_msg(struct lustre_msg *msg, int segment, unsigned int newlen)
531 switch (msg->lm_magic) {
532 case LUSTRE_MSG_MAGIC_V2:
533 return lustre_grow_msg_v2(msg, segment, newlen);
535 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
538 EXPORT_SYMBOL(lustre_grow_msg);
540 void lustre_free_reply_state(struct ptlrpc_reply_state *rs)
542 PTLRPC_RS_DEBUG_LRU_DEL(rs);
544 LASSERT(atomic_read(&rs->rs_refcount) == 0);
545 LASSERT(!rs->rs_difficult || rs->rs_handled);
546 LASSERT(!rs->rs_difficult || rs->rs_unlinked);
547 LASSERT(!rs->rs_scheduled);
548 LASSERT(rs->rs_export == NULL);
549 LASSERT(rs->rs_nlocks == 0);
550 LASSERT(list_empty(&rs->rs_exp_list));
551 LASSERT(list_empty(&rs->rs_obd_list));
553 sptlrpc_svc_free_rs(rs);
556 static int lustre_unpack_msg_v2(struct lustre_msg_v2 *m, int len)
558 int swabbed, required_len, i, buflen;
560 /* Now we know the sender speaks my language. */
561 required_len = lustre_msg_hdr_size_v2(0);
562 if (len < required_len) {
563 /* can't even look inside the message */
564 CERROR("message length %d too small for lustre_msg\n", len);
568 swabbed = (m->lm_magic == LUSTRE_MSG_MAGIC_V2_SWABBED);
571 __swab32s(&m->lm_magic);
572 __swab32s(&m->lm_bufcount);
573 __swab32s(&m->lm_secflvr);
574 __swab32s(&m->lm_repsize);
575 __swab32s(&m->lm_cksum);
576 __swab32s(&m->lm_flags);
577 __swab32s(&m->lm_opc);
578 BUILD_BUG_ON(offsetof(typeof(*m), lm_padding_3) == 0);
581 if (m->lm_bufcount == 0 || m->lm_bufcount > PTLRPC_MAX_BUFCOUNT) {
582 CERROR("message bufcount %d is not valid\n", m->lm_bufcount);
585 required_len = lustre_msg_hdr_size_v2(m->lm_bufcount);
586 if (len < required_len) {
587 /* didn't receive all the buffer lengths */
588 CERROR("message length %d too small for %d buflens\n",
589 len, m->lm_bufcount);
593 for (i = 0; i < m->lm_bufcount; i++) {
595 __swab32s(&m->lm_buflens[i]);
596 buflen = round_up(m->lm_buflens[i], 8);
597 if (buflen < 0 || buflen > PTLRPC_MAX_BUFLEN) {
598 CERROR("buffer %d length %d is not valid\n", i, buflen);
601 required_len += buflen;
603 if (len < required_len || required_len > PTLRPC_MAX_BUFLEN) {
604 CERROR("len: %d, required_len %d, bufcount: %d\n",
605 len, required_len, m->lm_bufcount);
606 for (i = 0; i < m->lm_bufcount; i++)
607 CERROR("buffer %d length %d\n", i, m->lm_buflens[i]);
614 int __lustre_unpack_msg(struct lustre_msg *m, int len)
616 int required_len, rc;
620 * We can provide a slightly better error log, if we check the
621 * message magic and version first. In the future, struct
622 * lustre_msg may grow, and we'd like to log a version mismatch,
623 * rather than a short message.
625 required_len = offsetof(struct lustre_msg, lm_magic) +
627 if (len < required_len) {
628 /* can't even look inside the message */
629 CERROR("message length %d too small for magic/version check\n",
634 rc = lustre_unpack_msg_v2(m, len);
638 EXPORT_SYMBOL(__lustre_unpack_msg);
640 int ptlrpc_unpack_req_msg(struct ptlrpc_request *req, int len)
644 rc = __lustre_unpack_msg(req->rq_reqmsg, len);
646 req_capsule_set_req_swabbed(&req->rq_pill,
647 MSG_PTLRPC_HEADER_OFF);
653 int ptlrpc_unpack_rep_msg(struct ptlrpc_request *req, int len)
657 rc = __lustre_unpack_msg(req->rq_repmsg, len);
659 req_capsule_set_rep_swabbed(&req->rq_pill,
660 MSG_PTLRPC_HEADER_OFF);
667 lustre_unpack_ptlrpc_body_v2(struct ptlrpc_request *req,
668 enum req_location loc, int offset)
670 struct ptlrpc_body *pb;
671 struct lustre_msg_v2 *m;
673 m = loc == RCL_CLIENT ? req->rq_reqmsg : req->rq_repmsg;
675 pb = lustre_msg_buf_v2(m, offset, sizeof(struct ptlrpc_body_v2));
677 CERROR("error unpacking ptlrpc body\n");
680 if (req_capsule_need_swab(&req->rq_pill, loc, offset)) {
681 lustre_swab_ptlrpc_body(pb);
682 req_capsule_set_swabbed(&req->rq_pill, loc, offset);
685 if ((pb->pb_version & ~LUSTRE_VERSION_MASK) != PTLRPC_MSG_VERSION) {
686 CERROR("wrong lustre_msg version %08x\n", pb->pb_version);
690 if (loc == RCL_SERVER)
691 pb->pb_status = ptlrpc_status_ntoh(pb->pb_status);
696 int lustre_unpack_req_ptlrpc_body(struct ptlrpc_request *req, int offset)
698 switch (req->rq_reqmsg->lm_magic) {
699 case LUSTRE_MSG_MAGIC_V2:
700 return lustre_unpack_ptlrpc_body_v2(req, RCL_CLIENT, offset);
702 CERROR("bad lustre msg magic: %08x\n",
703 req->rq_reqmsg->lm_magic);
708 int lustre_unpack_rep_ptlrpc_body(struct ptlrpc_request *req, int offset)
710 switch (req->rq_repmsg->lm_magic) {
711 case LUSTRE_MSG_MAGIC_V2:
712 return lustre_unpack_ptlrpc_body_v2(req, RCL_SERVER, offset);
714 CERROR("bad lustre msg magic: %08x\n",
715 req->rq_repmsg->lm_magic);
720 static inline __u32 lustre_msg_buflen_v2(struct lustre_msg_v2 *m, __u32 n)
722 if (n >= m->lm_bufcount)
725 return m->lm_buflens[n];
729 * lustre_msg_buflen - return the length of buffer \a n in message \a m
730 * \param m lustre_msg (request or reply) to look at
731 * \param n message index (base 0)
733 * returns zero for non-existent message indices
735 __u32 lustre_msg_buflen(struct lustre_msg *m, __u32 n)
737 switch (m->lm_magic) {
738 case LUSTRE_MSG_MAGIC_V2:
739 return lustre_msg_buflen_v2(m, n);
741 CERROR("incorrect message magic: %08x\n", m->lm_magic);
745 EXPORT_SYMBOL(lustre_msg_buflen);
748 lustre_msg_set_buflen_v2(struct lustre_msg_v2 *m, __u32 n, __u32 len)
750 if (n >= m->lm_bufcount)
753 m->lm_buflens[n] = len;
756 void lustre_msg_set_buflen(struct lustre_msg *m, __u32 n, __u32 len)
758 switch (m->lm_magic) {
759 case LUSTRE_MSG_MAGIC_V2:
760 lustre_msg_set_buflen_v2(m, n, len);
763 LASSERTF(0, "incorrect message magic: %08x\n", m->lm_magic);
768 * NB return the bufcount for lustre_msg_v2 format, so if message is packed
769 * in V1 format, the result is one bigger. (add struct ptlrpc_body).
771 __u32 lustre_msg_bufcount(struct lustre_msg *m)
773 switch (m->lm_magic) {
774 case LUSTRE_MSG_MAGIC_V2:
775 return m->lm_bufcount;
777 CERROR("incorrect message magic: %08x\n", m->lm_magic);
782 char *lustre_msg_string(struct lustre_msg *m, __u32 index, __u32 max_len)
784 /* max_len == 0 means the string should fill the buffer */
788 switch (m->lm_magic) {
789 case LUSTRE_MSG_MAGIC_V2:
790 str = lustre_msg_buf_v2(m, index, 0);
791 blen = lustre_msg_buflen_v2(m, index);
794 LASSERTF(0, "incorrect message magic: %08x\n", m->lm_magic);
798 CERROR("can't unpack string in msg %p buffer[%d]\n", m, index);
802 slen = strnlen(str, blen);
804 if (slen == blen) { /* not NULL terminated */
805 CERROR("can't unpack non-NULL terminated string in msg %p buffer[%d] len %d\n",
809 if (blen > PTLRPC_MAX_BUFLEN) {
810 CERROR("buffer length of msg %p buffer[%d] is invalid(%d)\n",
816 if (slen != blen - 1) {
817 CERROR("can't unpack short string in msg %p buffer[%d] len %d: strlen %d\n",
818 m, index, blen, slen);
821 } else if (slen > max_len) {
822 CERROR("can't unpack oversized string in msg %p buffer[%d] len %d strlen %d: max %d expected\n",
823 m, index, blen, slen, max_len);
830 /* Wrap up the normal fixed length cases */
831 static inline void *__lustre_swab_buf(struct lustre_msg *msg, __u32 index,
832 __u32 min_size, void *swabber)
836 LASSERT(msg != NULL);
837 switch (msg->lm_magic) {
838 case LUSTRE_MSG_MAGIC_V2:
839 ptr = lustre_msg_buf_v2(msg, index, min_size);
842 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
845 if (ptr != NULL && swabber != NULL)
846 ((void (*)(void *))swabber)(ptr);
851 static inline struct ptlrpc_body *lustre_msg_ptlrpc_body(struct lustre_msg *msg)
853 return lustre_msg_buf_v2(msg, MSG_PTLRPC_BODY_OFF,
854 sizeof(struct ptlrpc_body_v2));
857 enum lustre_msghdr lustre_msghdr_get_flags(struct lustre_msg *msg)
859 switch (msg->lm_magic) {
860 case LUSTRE_MSG_MAGIC_V2:
861 /* already in host endian */
862 return msg->lm_flags;
864 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
868 EXPORT_SYMBOL(lustre_msghdr_get_flags);
870 void lustre_msghdr_set_flags(struct lustre_msg *msg, __u32 flags)
872 switch (msg->lm_magic) {
873 case LUSTRE_MSG_MAGIC_V2:
874 msg->lm_flags = flags;
877 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
881 __u32 lustre_msg_get_flags(struct lustre_msg *msg)
883 switch (msg->lm_magic) {
884 case LUSTRE_MSG_MAGIC_V2: {
885 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
889 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
894 * flags might be printed in debug code while message
900 EXPORT_SYMBOL(lustre_msg_get_flags);
902 void lustre_msg_add_flags(struct lustre_msg *msg, __u32 flags)
904 switch (msg->lm_magic) {
905 case LUSTRE_MSG_MAGIC_V2: {
906 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
907 LASSERTF(pb != NULL, "invalid msg %p: no ptlrpc body!\n", msg);
908 pb->pb_flags |= flags;
912 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
915 EXPORT_SYMBOL(lustre_msg_add_flags);
917 void lustre_msg_set_flags(struct lustre_msg *msg, __u32 flags)
919 switch (msg->lm_magic) {
920 case LUSTRE_MSG_MAGIC_V2: {
921 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
922 LASSERTF(pb != NULL, "invalid msg %p: no ptlrpc body!\n", msg);
923 pb->pb_flags = flags;
927 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
931 void lustre_msg_clear_flags(struct lustre_msg *msg, __u32 flags)
933 switch (msg->lm_magic) {
934 case LUSTRE_MSG_MAGIC_V2: {
935 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
936 LASSERTF(pb != NULL, "invalid msg %p: no ptlrpc body!\n", msg);
937 pb->pb_flags &= ~flags;
942 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
945 EXPORT_SYMBOL(lustre_msg_clear_flags);
947 __u32 lustre_msg_get_op_flags(struct lustre_msg *msg)
949 switch (msg->lm_magic) {
950 case LUSTRE_MSG_MAGIC_V2: {
951 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
953 return pb->pb_op_flags;
955 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
963 void lustre_msg_add_op_flags(struct lustre_msg *msg, __u32 flags)
965 switch (msg->lm_magic) {
966 case LUSTRE_MSG_MAGIC_V2: {
967 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
968 LASSERTF(pb != NULL, "invalid msg %p: no ptlrpc body!\n", msg);
969 pb->pb_op_flags |= flags;
973 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
976 EXPORT_SYMBOL(lustre_msg_add_op_flags);
978 struct lustre_handle *lustre_msg_get_handle(struct lustre_msg *msg)
980 switch (msg->lm_magic) {
981 case LUSTRE_MSG_MAGIC_V2: {
982 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
984 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
987 return &pb->pb_handle;
990 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
995 __u32 lustre_msg_get_type(struct lustre_msg *msg)
997 switch (msg->lm_magic) {
998 case LUSTRE_MSG_MAGIC_V2: {
999 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1001 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1002 return PTL_RPC_MSG_ERR;
1007 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1008 return PTL_RPC_MSG_ERR;
1011 EXPORT_SYMBOL(lustre_msg_get_type);
1013 enum lustre_msg_version lustre_msg_get_version(struct lustre_msg *msg)
1015 switch (msg->lm_magic) {
1016 case LUSTRE_MSG_MAGIC_V2: {
1017 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1019 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1022 return pb->pb_version;
1025 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1030 void lustre_msg_add_version(struct lustre_msg *msg, __u32 version)
1032 switch (msg->lm_magic) {
1033 case LUSTRE_MSG_MAGIC_V2: {
1034 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1035 LASSERTF(pb != NULL, "invalid msg %p: no ptlrpc body!\n", msg);
1036 pb->pb_version |= version;
1040 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1044 __u32 lustre_msg_get_opc(struct lustre_msg *msg)
1046 switch (msg->lm_magic) {
1047 case LUSTRE_MSG_MAGIC_V2: {
1048 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1050 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1056 CERROR("incorrect message magic: %08x (msg:%p)\n",
1057 msg->lm_magic, msg);
1061 EXPORT_SYMBOL(lustre_msg_get_opc);
1063 __u64 lustre_msg_get_last_xid(struct lustre_msg *msg)
1065 switch (msg->lm_magic) {
1066 case LUSTRE_MSG_MAGIC_V2: {
1067 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1069 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1072 return pb->pb_last_xid;
1075 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1079 EXPORT_SYMBOL(lustre_msg_get_last_xid);
1081 __u16 lustre_msg_get_tag(struct lustre_msg *msg)
1083 switch (msg->lm_magic) {
1084 case LUSTRE_MSG_MAGIC_V2: {
1085 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1087 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1093 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1097 EXPORT_SYMBOL(lustre_msg_get_tag);
1099 __u64 lustre_msg_get_last_committed(struct lustre_msg *msg)
1101 switch (msg->lm_magic) {
1102 case LUSTRE_MSG_MAGIC_V2: {
1103 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1105 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1108 return pb->pb_last_committed;
1111 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1115 EXPORT_SYMBOL(lustre_msg_get_last_committed);
1117 __u64 *lustre_msg_get_versions(struct lustre_msg *msg)
1119 switch (msg->lm_magic) {
1120 case LUSTRE_MSG_MAGIC_V2: {
1121 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1123 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1126 return pb->pb_pre_versions;
1129 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1133 EXPORT_SYMBOL(lustre_msg_get_versions);
1135 __u64 lustre_msg_get_transno(struct lustre_msg *msg)
1137 switch (msg->lm_magic) {
1138 case LUSTRE_MSG_MAGIC_V2: {
1139 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1141 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1144 return pb->pb_transno;
1147 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1151 EXPORT_SYMBOL(lustre_msg_get_transno);
1153 int lustre_msg_get_status(struct lustre_msg *msg)
1155 switch (msg->lm_magic) {
1156 case LUSTRE_MSG_MAGIC_V2: {
1157 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1159 return pb->pb_status;
1160 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1165 * status might be printed in debug code while message
1171 EXPORT_SYMBOL(lustre_msg_get_status);
1173 __u64 lustre_msg_get_slv(struct lustre_msg *msg)
1175 switch (msg->lm_magic) {
1176 case LUSTRE_MSG_MAGIC_V2: {
1177 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1179 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1185 CERROR("invalid msg magic %08x\n", msg->lm_magic);
1191 void lustre_msg_set_slv(struct lustre_msg *msg, __u64 slv)
1193 switch (msg->lm_magic) {
1194 case LUSTRE_MSG_MAGIC_V2: {
1195 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1197 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1204 CERROR("invalid msg magic %x\n", msg->lm_magic);
1209 __u32 lustre_msg_get_limit(struct lustre_msg *msg)
1211 switch (msg->lm_magic) {
1212 case LUSTRE_MSG_MAGIC_V2: {
1213 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1215 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1218 return pb->pb_limit;
1221 CERROR("invalid msg magic %x\n", msg->lm_magic);
1227 void lustre_msg_set_limit(struct lustre_msg *msg, __u64 limit)
1229 switch (msg->lm_magic) {
1230 case LUSTRE_MSG_MAGIC_V2: {
1231 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1233 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1236 pb->pb_limit = limit;
1240 CERROR("invalid msg magic %08x\n", msg->lm_magic);
1245 __u32 lustre_msg_get_conn_cnt(struct lustre_msg *msg)
1247 switch (msg->lm_magic) {
1248 case LUSTRE_MSG_MAGIC_V2: {
1249 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1251 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1254 return pb->pb_conn_cnt;
1257 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1261 EXPORT_SYMBOL(lustre_msg_get_conn_cnt);
1263 __u32 lustre_msg_get_magic(struct lustre_msg *msg)
1265 switch (msg->lm_magic) {
1266 case LUSTRE_MSG_MAGIC_V2:
1267 return msg->lm_magic;
1269 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1274 timeout_t lustre_msg_get_timeout(struct lustre_msg *msg)
1276 switch (msg->lm_magic) {
1277 case LUSTRE_MSG_MAGIC_V2: {
1278 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1281 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1284 return pb->pb_timeout;
1287 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1292 timeout_t lustre_msg_get_service_timeout(struct lustre_msg *msg)
1294 switch (msg->lm_magic) {
1295 case LUSTRE_MSG_MAGIC_V2: {
1296 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1299 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1302 return pb->pb_service_time;
1305 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1310 int lustre_msg_get_uid_gid(struct lustre_msg *msg, __u32 *uid, __u32 *gid)
1312 switch (msg->lm_magic) {
1313 case LUSTRE_MSG_MAGIC_V2: {
1314 struct ptlrpc_body *pb;
1316 /* the old pltrpc_body_v2 is smaller; doesn't include uid/gid */
1317 if (msg->lm_buflens[MSG_PTLRPC_BODY_OFF] <
1318 sizeof(struct ptlrpc_body))
1321 pb = lustre_msg_buf_v2(msg, MSG_PTLRPC_BODY_OFF,
1322 sizeof(struct ptlrpc_body));
1324 if (!pb || !(pb->pb_flags & MSG_PACK_UID_GID))
1335 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1339 EXPORT_SYMBOL(lustre_msg_get_uid_gid);
1341 char *lustre_msg_get_jobid(struct lustre_msg *msg)
1343 switch (msg->lm_magic) {
1344 case LUSTRE_MSG_MAGIC_V2: {
1345 struct ptlrpc_body *pb;
1347 /* the old pltrpc_body_v2 is smaller; doesn't include jobid */
1348 if (msg->lm_buflens[MSG_PTLRPC_BODY_OFF] <
1349 sizeof(struct ptlrpc_body))
1352 pb = lustre_msg_buf_v2(msg, MSG_PTLRPC_BODY_OFF,
1353 sizeof(struct ptlrpc_body));
1357 /* If clients send unterminated jobids, terminate them here
1358 * so that there is no chance of string overflow later.
1360 if (unlikely(pb->pb_jobid[LUSTRE_JOBID_SIZE - 1] != '\0'))
1361 pb->pb_jobid[LUSTRE_JOBID_SIZE - 1] = '\0';
1363 return pb->pb_jobid;
1366 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1370 EXPORT_SYMBOL(lustre_msg_get_jobid);
1372 __u32 lustre_msg_get_cksum(struct lustre_msg *msg)
1374 switch (msg->lm_magic) {
1375 case LUSTRE_MSG_MAGIC_V2:
1376 return msg->lm_cksum;
1378 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1383 __u64 lustre_msg_get_mbits(struct lustre_msg *msg)
1385 switch (msg->lm_magic) {
1386 case LUSTRE_MSG_MAGIC_V2: {
1387 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1389 CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1392 return pb->pb_mbits;
1395 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1400 __u32 lustre_msg_calc_cksum(struct lustre_msg *msg, __u32 buf)
1402 switch (msg->lm_magic) {
1403 case LUSTRE_MSG_MAGIC_V2: {
1404 struct ptlrpc_body *pb = lustre_msg_buf_v2(msg, buf, 0);
1405 __u32 len = lustre_msg_buflen(msg, buf);
1408 #if IS_ENABLED(CONFIG_CRC32)
1409 /* about 10x faster than crypto_hash for small buffers */
1410 crc = crc32_le(~(__u32)0, (unsigned char *)pb, len);
1411 #elif IS_ENABLED(CONFIG_CRYPTO_CRC32)
1412 unsigned int hsize = 4;
1414 cfs_crypto_hash_digest(CFS_HASH_ALG_CRC32, (unsigned char *)pb,
1415 len, NULL, 0, (unsigned char *)&crc,
1418 #error "need either CONFIG_CRC32 or CONFIG_CRYPTO_CRC32 enabled in the kernel"
1423 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1428 void lustre_msg_set_handle(struct lustre_msg *msg, struct lustre_handle *handle)
1430 switch (msg->lm_magic) {
1431 case LUSTRE_MSG_MAGIC_V2: {
1432 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1433 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1434 pb->pb_handle = *handle;
1438 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1442 void lustre_msg_set_type(struct lustre_msg *msg, __u32 type)
1444 switch (msg->lm_magic) {
1445 case LUSTRE_MSG_MAGIC_V2: {
1446 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1447 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1452 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1456 void lustre_msg_set_opc(struct lustre_msg *msg, __u32 opc)
1458 switch (msg->lm_magic) {
1459 case LUSTRE_MSG_MAGIC_V2: {
1460 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1461 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1466 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1470 void lustre_msg_set_last_xid(struct lustre_msg *msg, __u64 last_xid)
1472 switch (msg->lm_magic) {
1473 case LUSTRE_MSG_MAGIC_V2: {
1474 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1475 LASSERTF(pb != NULL, "invalid msg %p: no ptlrpc body!\n", msg);
1476 pb->pb_last_xid = last_xid;
1480 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1483 EXPORT_SYMBOL(lustre_msg_set_last_xid);
1485 void lustre_msg_set_tag(struct lustre_msg *msg, __u16 tag)
1487 switch (msg->lm_magic) {
1488 case LUSTRE_MSG_MAGIC_V2: {
1489 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1490 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1495 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1498 EXPORT_SYMBOL(lustre_msg_set_tag);
1500 void lustre_msg_set_last_committed(struct lustre_msg *msg, __u64 last_committed)
1502 switch (msg->lm_magic) {
1503 case LUSTRE_MSG_MAGIC_V2: {
1504 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1505 LASSERTF(pb != NULL, "invalid msg %p: no ptlrpc body!\n", msg);
1506 pb->pb_last_committed = last_committed;
1510 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1514 void lustre_msg_set_versions(struct lustre_msg *msg, __u64 *versions)
1516 switch (msg->lm_magic) {
1517 case LUSTRE_MSG_MAGIC_V2: {
1518 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1519 LASSERTF(pb != NULL, "invalid msg %p: no ptlrpc body!\n", msg);
1520 pb->pb_pre_versions[0] = versions[0];
1521 pb->pb_pre_versions[1] = versions[1];
1522 pb->pb_pre_versions[2] = versions[2];
1523 pb->pb_pre_versions[3] = versions[3];
1527 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1530 EXPORT_SYMBOL(lustre_msg_set_versions);
1532 void lustre_msg_set_transno(struct lustre_msg *msg, __u64 transno)
1534 switch (msg->lm_magic) {
1535 case LUSTRE_MSG_MAGIC_V2: {
1536 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1537 LASSERTF(pb != NULL, "invalid msg %p: no ptlrpc body!\n", msg);
1538 pb->pb_transno = transno;
1542 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1545 EXPORT_SYMBOL(lustre_msg_set_transno);
1547 void lustre_msg_set_status(struct lustre_msg *msg, __u32 status)
1549 switch (msg->lm_magic) {
1550 case LUSTRE_MSG_MAGIC_V2: {
1551 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1552 LASSERTF(pb != NULL, "invalid msg %p: no ptlrpc body!\n", msg);
1553 pb->pb_status = status;
1557 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1560 EXPORT_SYMBOL(lustre_msg_set_status);
1562 void lustre_msg_set_conn_cnt(struct lustre_msg *msg, __u32 conn_cnt)
1564 switch (msg->lm_magic) {
1565 case LUSTRE_MSG_MAGIC_V2: {
1566 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1567 LASSERTF(pb != NULL, "invalid msg %p: no ptlrpc body!\n", msg);
1568 pb->pb_conn_cnt = conn_cnt;
1572 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1576 void lustre_msg_set_timeout(struct lustre_msg *msg, timeout_t timeout)
1578 switch (msg->lm_magic) {
1579 case LUSTRE_MSG_MAGIC_V2: {
1580 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1582 LASSERT(timeout >= 0);
1583 LASSERTF(pb != NULL, "invalid msg %p: no ptlrpc body!\n", msg);
1584 pb->pb_timeout = timeout;
1588 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1592 void lustre_msg_set_service_timeout(struct lustre_msg *msg,
1593 timeout_t service_timeout)
1595 switch (msg->lm_magic) {
1596 case LUSTRE_MSG_MAGIC_V2: {
1597 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1599 LASSERT(service_timeout >= 0);
1600 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1601 pb->pb_service_time = service_timeout;
1605 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1609 void lustre_msg_set_uid_gid(struct lustre_msg *msg, __u32 *uid, __u32 *gid)
1611 switch (msg->lm_magic) {
1612 case LUSTRE_MSG_MAGIC_V2: {
1613 __u32 opc = lustre_msg_get_opc(msg);
1614 struct ptlrpc_body *pb;
1616 /* Don't set uid/gid for ldlm ast RPCs */
1617 if (!opc || opc == LDLM_BL_CALLBACK ||
1618 opc == LDLM_CP_CALLBACK || opc == LDLM_GL_CALLBACK)
1621 pb = lustre_msg_buf_v2(msg, MSG_PTLRPC_BODY_OFF,
1622 sizeof(struct ptlrpc_body));
1623 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1628 pb->pb_flags |= MSG_PACK_UID_GID;
1629 } else if (!(pb->pb_flags & MSG_PACK_UID_GID)) {
1630 pb->pb_uid = from_kuid(&init_user_ns, current_uid());
1631 pb->pb_gid = from_kgid(&init_user_ns, current_gid());
1632 pb->pb_flags |= MSG_PACK_UID_GID;
1638 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1641 EXPORT_SYMBOL(lustre_msg_set_uid_gid);
1643 void lustre_msg_set_jobid(struct lustre_msg *msg, char *jobid)
1645 switch (msg->lm_magic) {
1646 case LUSTRE_MSG_MAGIC_V2: {
1647 __u32 opc = lustre_msg_get_opc(msg);
1648 struct ptlrpc_body *pb;
1650 /* Don't set jobid for ldlm ast RPCs, they've been shrinked.
1651 * See the comment in ptlrpc_request_pack(). */
1652 if (!opc || opc == LDLM_BL_CALLBACK ||
1653 opc == LDLM_CP_CALLBACK || opc == LDLM_GL_CALLBACK)
1656 pb = lustre_msg_buf_v2(msg, MSG_PTLRPC_BODY_OFF,
1657 sizeof(struct ptlrpc_body));
1658 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1661 memcpy(pb->pb_jobid, jobid, sizeof(pb->pb_jobid));
1662 else if (pb->pb_jobid[0] == '\0')
1663 lustre_get_jobid(pb->pb_jobid, sizeof(pb->pb_jobid));
1667 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1670 EXPORT_SYMBOL(lustre_msg_set_jobid);
1672 void lustre_msg_set_cksum(struct lustre_msg *msg, __u32 cksum)
1674 switch (msg->lm_magic) {
1675 case LUSTRE_MSG_MAGIC_V2:
1676 msg->lm_cksum = cksum;
1679 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1683 void lustre_msg_set_mbits(struct lustre_msg *msg, __u64 mbits)
1685 switch (msg->lm_magic) {
1686 case LUSTRE_MSG_MAGIC_V2: {
1687 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1689 LASSERTF(pb != NULL, "invalid msg %p: no ptlrpc body!\n", msg);
1690 pb->pb_mbits = mbits;
1694 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1698 void ptlrpc_request_set_replen(struct ptlrpc_request *req)
1700 int count = req_capsule_filled_sizes(&req->rq_pill, RCL_SERVER);
1702 req->rq_replen = lustre_msg_size(req->rq_reqmsg->lm_magic, count,
1703 req->rq_pill.rc_area[RCL_SERVER]);
1704 if (req->rq_reqmsg->lm_magic == LUSTRE_MSG_MAGIC_V2)
1705 req->rq_reqmsg->lm_repsize = req->rq_replen;
1707 EXPORT_SYMBOL(ptlrpc_request_set_replen);
1709 void ptlrpc_req_set_repsize(struct ptlrpc_request *req, int count, __u32 *lens)
1711 req->rq_replen = lustre_msg_size(req->rq_reqmsg->lm_magic, count, lens);
1712 if (req->rq_reqmsg->lm_magic == LUSTRE_MSG_MAGIC_V2)
1713 req->rq_reqmsg->lm_repsize = req->rq_replen;
1717 * Send a remote set_info_async.
1719 * This may go from client to server or server to client.
1721 int do_set_info_async(struct obd_import *imp,
1722 int opcode, int version,
1723 size_t keylen, void *key,
1724 size_t vallen, void *val,
1725 struct ptlrpc_request_set *set)
1727 struct ptlrpc_request *req;
1733 req = ptlrpc_request_alloc(imp, KEY_IS(KEY_CHANGELOG_CLEAR) ?
1739 req_capsule_set_size(&req->rq_pill, &RMF_SETINFO_KEY,
1740 RCL_CLIENT, keylen);
1741 req_capsule_set_size(&req->rq_pill, &RMF_SETINFO_VAL,
1742 RCL_CLIENT, vallen);
1743 rc = ptlrpc_request_pack(req, version, opcode);
1745 ptlrpc_request_free(req);
1749 if (KEY_IS(KEY_CHANGELOG_CLEAR))
1752 tmp = req_capsule_client_get(&req->rq_pill, &RMF_SETINFO_KEY);
1753 memcpy(tmp, key, keylen);
1754 tmp = req_capsule_client_get(&req->rq_pill, &RMF_SETINFO_VAL);
1755 memcpy(tmp, val, vallen);
1757 ptlrpc_request_set_replen(req);
1760 ptlrpc_set_add_req(set, req);
1761 ptlrpc_check_set(NULL, set);
1763 rc = ptlrpc_queue_wait(req);
1764 ptlrpc_req_finished(req);
1769 EXPORT_SYMBOL(do_set_info_async);
1771 /* byte flipping routines for all wire types declared in
1772 * lustre_idl.h implemented here.
1774 void lustre_swab_ptlrpc_body(struct ptlrpc_body *body)
1776 __swab32s(&body->pb_type);
1777 __swab32s(&body->pb_version);
1778 __swab32s(&body->pb_opc);
1779 __swab32s(&body->pb_status);
1780 __swab64s(&body->pb_last_xid);
1781 __swab16s(&body->pb_tag);
1782 BUILD_BUG_ON(offsetof(typeof(*body), pb_padding0) == 0);
1783 BUILD_BUG_ON(offsetof(typeof(*body), pb_padding1) == 0);
1784 __swab64s(&body->pb_last_committed);
1785 __swab64s(&body->pb_transno);
1786 __swab32s(&body->pb_flags);
1787 __swab32s(&body->pb_op_flags);
1788 __swab32s(&body->pb_conn_cnt);
1789 __swab32s(&body->pb_timeout);
1790 __swab32s(&body->pb_service_time);
1791 __swab32s(&body->pb_limit);
1792 __swab64s(&body->pb_slv);
1793 __swab64s(&body->pb_pre_versions[0]);
1794 __swab64s(&body->pb_pre_versions[1]);
1795 __swab64s(&body->pb_pre_versions[2]);
1796 __swab64s(&body->pb_pre_versions[3]);
1797 __swab64s(&body->pb_mbits);
1798 BUILD_BUG_ON(offsetof(typeof(*body), pb_padding64_0) == 0);
1799 BUILD_BUG_ON(offsetof(typeof(*body), pb_padding64_1) == 0);
1800 __swab32s(&body->pb_uid);
1801 __swab32s(&body->pb_gid);
1803 * While we need to maintain compatibility between
1804 * clients and servers without ptlrpc_body_v2 (< 2.3)
1805 * do not swab any fields beyond pb_jobid, as we are
1806 * using this swab function for both ptlrpc_body
1807 * and ptlrpc_body_v2.
1809 /* pb_jobid is an ASCII string and should not be swabbed */
1810 BUILD_BUG_ON(offsetof(typeof(*body), pb_jobid) == 0);
1813 void lustre_swab_connect(struct obd_connect_data *ocd)
1815 __swab64s(&ocd->ocd_connect_flags);
1816 __swab32s(&ocd->ocd_version);
1817 __swab32s(&ocd->ocd_grant);
1818 __swab64s(&ocd->ocd_ibits_known);
1819 __swab32s(&ocd->ocd_index);
1820 __swab32s(&ocd->ocd_brw_size);
1822 * ocd_blocksize and ocd_inodespace don't need to be swabbed because
1823 * they are 8-byte values
1825 __swab16s(&ocd->ocd_grant_tax_kb);
1826 __swab32s(&ocd->ocd_grant_max_blks);
1827 __swab64s(&ocd->ocd_transno);
1828 __swab32s(&ocd->ocd_group);
1829 __swab32s(&ocd->ocd_cksum_types);
1830 __swab32s(&ocd->ocd_instance);
1832 * Fields after ocd_cksum_types are only accessible by the receiver
1833 * if the corresponding flag in ocd_connect_flags is set. Accessing
1834 * any field after ocd_maxbytes on the receiver without a valid flag
1835 * may result in out-of-bound memory access and kernel oops.
1837 if (ocd->ocd_connect_flags & OBD_CONNECT_MAX_EASIZE)
1838 __swab32s(&ocd->ocd_max_easize);
1839 if (ocd->ocd_connect_flags & OBD_CONNECT_MAXBYTES)
1840 __swab64s(&ocd->ocd_maxbytes);
1841 if (ocd->ocd_connect_flags & OBD_CONNECT_MULTIMODRPCS)
1842 __swab16s(&ocd->ocd_maxmodrpcs);
1843 BUILD_BUG_ON(offsetof(typeof(*ocd), padding0) == 0);
1844 BUILD_BUG_ON(offsetof(typeof(*ocd), padding1) == 0);
1845 if (ocd->ocd_connect_flags & OBD_CONNECT_FLAGS2) {
1846 __swab64s(&ocd->ocd_connect_flags2);
1847 if (ocd->ocd_connect_flags2 & OBD_CONNECT2_COMPRESS)
1848 __swab64s(&ocd->ocd_compr_type);
1850 BUILD_BUG_ON(offsetof(typeof(*ocd), padding4) == 0);
1851 BUILD_BUG_ON(offsetof(typeof(*ocd), padding5) == 0);
1852 BUILD_BUG_ON(offsetof(typeof(*ocd), padding6) == 0);
1853 BUILD_BUG_ON(offsetof(typeof(*ocd), padding7) == 0);
1854 BUILD_BUG_ON(offsetof(typeof(*ocd), padding8) == 0);
1855 BUILD_BUG_ON(offsetof(typeof(*ocd), padding9) == 0);
1856 BUILD_BUG_ON(offsetof(typeof(*ocd), paddingA) == 0);
1857 BUILD_BUG_ON(offsetof(typeof(*ocd), paddingB) == 0);
1858 BUILD_BUG_ON(offsetof(typeof(*ocd), paddingC) == 0);
1859 BUILD_BUG_ON(offsetof(typeof(*ocd), paddingD) == 0);
1860 BUILD_BUG_ON(offsetof(typeof(*ocd), paddingE) == 0);
1861 BUILD_BUG_ON(offsetof(typeof(*ocd), paddingF) == 0);
1864 static void lustre_swab_ost_layout(struct ost_layout *ol)
1866 __swab32s(&ol->ol_stripe_size);
1867 __swab32s(&ol->ol_stripe_count);
1868 __swab64s(&ol->ol_comp_start);
1869 __swab64s(&ol->ol_comp_end);
1870 __swab32s(&ol->ol_comp_id);
1873 void lustre_swab_obdo(struct obdo *o)
1875 __swab64s(&o->o_valid);
1876 lustre_swab_ost_id(&o->o_oi);
1877 __swab64s(&o->o_parent_seq);
1878 __swab64s(&o->o_size);
1879 __swab64s(&o->o_mtime);
1880 __swab64s(&o->o_atime);
1881 __swab64s(&o->o_ctime);
1882 __swab64s(&o->o_blocks);
1883 __swab64s(&o->o_grant);
1884 __swab32s(&o->o_blksize);
1885 __swab32s(&o->o_mode);
1886 __swab32s(&o->o_uid);
1887 __swab32s(&o->o_gid);
1888 __swab32s(&o->o_flags);
1889 __swab32s(&o->o_nlink);
1890 __swab32s(&o->o_parent_oid);
1891 __swab32s(&o->o_misc);
1892 __swab64s(&o->o_ioepoch);
1893 __swab32s(&o->o_stripe_idx);
1894 __swab32s(&o->o_parent_ver);
1895 lustre_swab_ost_layout(&o->o_layout);
1896 __swab32s(&o->o_layout_version);
1897 __swab32s(&o->o_uid_h);
1898 __swab32s(&o->o_gid_h);
1899 __swab64s(&o->o_data_version);
1900 __swab32s(&o->o_projid);
1901 BUILD_BUG_ON(offsetof(typeof(*o), o_padding_4) == 0);
1902 BUILD_BUG_ON(offsetof(typeof(*o), o_padding_5) == 0);
1903 BUILD_BUG_ON(offsetof(typeof(*o), o_padding_6) == 0);
1906 EXPORT_SYMBOL(lustre_swab_obdo);
1908 void lustre_swab_obd_statfs(struct obd_statfs *os)
1910 __swab64s(&os->os_type);
1911 __swab64s(&os->os_blocks);
1912 __swab64s(&os->os_bfree);
1913 __swab64s(&os->os_bavail);
1914 __swab64s(&os->os_files);
1915 __swab64s(&os->os_ffree);
1916 /* no need to swab os_fsid */
1917 __swab32s(&os->os_bsize);
1918 __swab32s(&os->os_namelen);
1919 __swab64s(&os->os_maxbytes);
1920 __swab32s(&os->os_state);
1921 __swab32s(&os->os_fprecreated);
1922 __swab32s(&os->os_granted);
1923 BUILD_BUG_ON(offsetof(typeof(*os), os_spare3) == 0);
1924 BUILD_BUG_ON(offsetof(typeof(*os), os_spare4) == 0);
1925 BUILD_BUG_ON(offsetof(typeof(*os), os_spare5) == 0);
1926 BUILD_BUG_ON(offsetof(typeof(*os), os_spare6) == 0);
1927 BUILD_BUG_ON(offsetof(typeof(*os), os_spare7) == 0);
1928 BUILD_BUG_ON(offsetof(typeof(*os), os_spare8) == 0);
1929 BUILD_BUG_ON(offsetof(typeof(*os), os_spare9) == 0);
1932 void lustre_swab_obd_ioobj(struct obd_ioobj *ioo)
1934 lustre_swab_ost_id(&ioo->ioo_oid);
1935 __swab32s(&ioo->ioo_max_brw);
1936 __swab32s(&ioo->ioo_bufcnt);
1939 void lustre_swab_niobuf_remote(struct niobuf_remote *nbr)
1941 __swab64s(&nbr->rnb_offset);
1942 __swab32s(&nbr->rnb_len);
1943 __swab32s(&nbr->rnb_flags);
1946 void lustre_swab_ost_body(struct ost_body *b)
1948 lustre_swab_obdo(&b->oa);
1951 void lustre_swab_ost_last_id(u64 *id)
1956 void lustre_swab_generic_32s(__u32 *val)
1961 void lustre_swab_gl_lquota_desc(struct ldlm_gl_lquota_desc *desc)
1963 lustre_swab_lu_fid(&desc->gl_id.qid_fid);
1964 __swab64s(&desc->gl_flags);
1965 __swab64s(&desc->gl_ver);
1966 __swab64s(&desc->gl_hardlimit);
1967 __swab64s(&desc->gl_softlimit);
1968 __swab64s(&desc->gl_time);
1969 BUILD_BUG_ON(offsetof(typeof(*desc), gl_pad2) == 0);
1971 EXPORT_SYMBOL(lustre_swab_gl_lquota_desc);
1973 void lustre_swab_gl_barrier_desc(struct ldlm_gl_barrier_desc *desc)
1975 __swab32s(&desc->lgbd_status);
1976 __swab32s(&desc->lgbd_timeout);
1977 BUILD_BUG_ON(offsetof(typeof(*desc), lgbd_padding) == 0);
1979 EXPORT_SYMBOL(lustre_swab_gl_barrier_desc);
1981 void lustre_swab_ost_lvb_v1(struct ost_lvb_v1 *lvb)
1983 __swab64s(&lvb->lvb_size);
1984 __swab64s(&lvb->lvb_mtime);
1985 __swab64s(&lvb->lvb_atime);
1986 __swab64s(&lvb->lvb_ctime);
1987 __swab64s(&lvb->lvb_blocks);
1989 EXPORT_SYMBOL(lustre_swab_ost_lvb_v1);
1991 void lustre_swab_ost_lvb(struct ost_lvb *lvb)
1993 __swab64s(&lvb->lvb_size);
1994 __swab64s(&lvb->lvb_mtime);
1995 __swab64s(&lvb->lvb_atime);
1996 __swab64s(&lvb->lvb_ctime);
1997 __swab64s(&lvb->lvb_blocks);
1998 __swab32s(&lvb->lvb_mtime_ns);
1999 __swab32s(&lvb->lvb_atime_ns);
2000 __swab32s(&lvb->lvb_ctime_ns);
2001 __swab32s(&lvb->lvb_padding);
2003 EXPORT_SYMBOL(lustre_swab_ost_lvb);
2005 void lustre_swab_lquota_lvb(struct lquota_lvb *lvb)
2007 __swab64s(&lvb->lvb_flags);
2008 __swab64s(&lvb->lvb_id_may_rel);
2009 __swab64s(&lvb->lvb_id_rel);
2010 __swab64s(&lvb->lvb_id_qunit);
2011 __swab64s(&lvb->lvb_pad1);
2013 EXPORT_SYMBOL(lustre_swab_lquota_lvb);
2015 void lustre_swab_barrier_lvb(struct barrier_lvb *lvb)
2017 __swab32s(&lvb->lvb_status);
2018 __swab32s(&lvb->lvb_index);
2019 BUILD_BUG_ON(offsetof(typeof(*lvb), lvb_padding) == 0);
2021 EXPORT_SYMBOL(lustre_swab_barrier_lvb);
2023 void lustre_swab_mdt_body(struct mdt_body *b)
2025 lustre_swab_lu_fid(&b->mbo_fid1);
2026 lustre_swab_lu_fid(&b->mbo_fid2);
2027 /* handle is opaque */
2028 __swab64s(&b->mbo_valid);
2029 __swab64s(&b->mbo_size);
2030 __swab64s(&b->mbo_mtime);
2031 __swab64s(&b->mbo_atime);
2032 __swab64s(&b->mbo_ctime);
2033 __swab64s(&b->mbo_blocks);
2034 __swab64s(&b->mbo_version);
2035 __swab64s(&b->mbo_t_state);
2036 __swab32s(&b->mbo_fsuid);
2037 __swab32s(&b->mbo_fsgid);
2038 __swab32s(&b->mbo_capability);
2039 __swab32s(&b->mbo_mode);
2040 __swab32s(&b->mbo_uid);
2041 __swab32s(&b->mbo_gid);
2042 __swab32s(&b->mbo_flags);
2043 __swab32s(&b->mbo_rdev);
2044 __swab32s(&b->mbo_nlink);
2045 __swab32s(&b->mbo_layout_gen);
2046 __swab32s(&b->mbo_suppgid);
2047 __swab32s(&b->mbo_eadatasize);
2048 __swab32s(&b->mbo_aclsize);
2049 __swab32s(&b->mbo_max_mdsize);
2050 BUILD_BUG_ON(offsetof(typeof(*b), mbo_unused3) == 0);
2051 __swab32s(&b->mbo_uid_h);
2052 __swab32s(&b->mbo_gid_h);
2053 __swab32s(&b->mbo_projid);
2054 __swab64s(&b->mbo_dom_size);
2055 __swab64s(&b->mbo_dom_blocks);
2056 __swab64s(&b->mbo_btime);
2057 BUILD_BUG_ON(offsetof(typeof(*b), mbo_padding_9) == 0);
2058 BUILD_BUG_ON(offsetof(typeof(*b), mbo_padding_10) == 0);
2061 void lustre_swab_mdt_ioepoch(struct mdt_ioepoch *b)
2063 /* mio_open_handle is opaque */
2064 BUILD_BUG_ON(offsetof(typeof(*b), mio_unused1) == 0);
2065 BUILD_BUG_ON(offsetof(typeof(*b), mio_unused2) == 0);
2066 BUILD_BUG_ON(offsetof(typeof(*b), mio_padding) == 0);
2069 void lustre_swab_mgs_target_info(struct mgs_target_info *mti)
2073 __swab32s(&mti->mti_lustre_ver);
2074 __swab32s(&mti->mti_stripe_index);
2075 __swab32s(&mti->mti_config_ver);
2076 __swab32s(&mti->mti_flags);
2077 __swab32s(&mti->mti_instance);
2078 __swab32s(&mti->mti_nid_count);
2079 BUILD_BUG_ON(sizeof(lnet_nid_t) != sizeof(__u64));
2080 for (i = 0; i < MTI_NIDS_MAX; i++)
2081 __swab64s(&mti->mti_nids[i]);
2084 void lustre_swab_mgs_nidtbl_entry(struct mgs_nidtbl_entry *entry)
2088 __swab64s(&entry->mne_version);
2089 __swab32s(&entry->mne_instance);
2090 __swab32s(&entry->mne_index);
2091 __swab32s(&entry->mne_length);
2093 /* mne_nid_(count|type) must be one byte size because we're gonna
2094 * access it w/o swapping. */
2095 BUILD_BUG_ON(sizeof(entry->mne_nid_count) != sizeof(__u8));
2096 BUILD_BUG_ON(sizeof(entry->mne_nid_type) != sizeof(__u8));
2098 /* remove this assertion if ipv6 is supported. */
2099 LASSERT(entry->mne_nid_type == 0);
2100 for (i = 0; i < entry->mne_nid_count; i++) {
2101 BUILD_BUG_ON(sizeof(lnet_nid_t) != sizeof(__u64));
2102 __swab64s(&entry->u.nids[i]);
2105 EXPORT_SYMBOL(lustre_swab_mgs_nidtbl_entry);
2107 void lustre_swab_mgs_config_body(struct mgs_config_body *body)
2109 __swab64s(&body->mcb_offset);
2110 __swab32s(&body->mcb_units);
2111 __swab16s(&body->mcb_type);
2114 void lustre_swab_mgs_config_res(struct mgs_config_res *body)
2116 __swab64s(&body->mcr_offset);
2117 __swab64s(&body->mcr_size);
2120 static void lustre_swab_obd_dqinfo(struct obd_dqinfo *i)
2122 __swab64s(&i->dqi_bgrace);
2123 __swab64s(&i->dqi_igrace);
2124 __swab32s(&i->dqi_flags);
2125 __swab32s(&i->dqi_valid);
2128 static void lustre_swab_obd_dqblk(struct obd_dqblk *b)
2130 __swab64s(&b->dqb_ihardlimit);
2131 __swab64s(&b->dqb_isoftlimit);
2132 __swab64s(&b->dqb_curinodes);
2133 __swab64s(&b->dqb_bhardlimit);
2134 __swab64s(&b->dqb_bsoftlimit);
2135 __swab64s(&b->dqb_curspace);
2136 __swab64s(&b->dqb_btime);
2137 __swab64s(&b->dqb_itime);
2138 __swab32s(&b->dqb_valid);
2139 BUILD_BUG_ON(offsetof(typeof(*b), dqb_padding) == 0);
2142 int lustre_swab_obd_quotactl(struct obd_quotactl *q, __u32 len)
2144 if (unlikely(len <= sizeof(struct obd_quotactl)))
2147 __swab32s(&q->qc_cmd);
2148 __swab32s(&q->qc_type);
2149 __swab32s(&q->qc_id);
2150 __swab32s(&q->qc_stat);
2151 lustre_swab_obd_dqinfo(&q->qc_dqinfo);
2152 lustre_swab_obd_dqblk(&q->qc_dqblk);
2157 void lustre_swab_fid2path(struct getinfo_fid2path *gf)
2159 lustre_swab_lu_fid(&gf->gf_fid);
2160 __swab64s(&gf->gf_recno);
2161 __swab32s(&gf->gf_linkno);
2162 __swab32s(&gf->gf_pathlen);
2164 EXPORT_SYMBOL(lustre_swab_fid2path);
2166 static void lustre_swab_fiemap_extent(struct fiemap_extent *fm_extent)
2168 __swab64s(&fm_extent->fe_logical);
2169 __swab64s(&fm_extent->fe_physical);
2170 __swab64s(&fm_extent->fe_length);
2171 __swab32s(&fm_extent->fe_flags);
2172 __swab32s(&fm_extent->fe_device);
2175 static void lustre_swab_fiemap_hdr(struct fiemap *fiemap)
2177 __swab64s(&fiemap->fm_start);
2178 __swab64s(&fiemap->fm_length);
2179 __swab32s(&fiemap->fm_flags);
2180 __swab32s(&fiemap->fm_mapped_extents);
2181 __swab32s(&fiemap->fm_extent_count);
2182 __swab32s(&fiemap->fm_reserved);
2185 int lustre_swab_fiemap(struct fiemap *fiemap, __u32 len)
2187 __u32 i, size, count;
2189 lustre_swab_fiemap_hdr(fiemap);
2191 size = fiemap_count_to_size(fiemap->fm_mapped_extents);
2192 count = fiemap->fm_mapped_extents;
2193 if (unlikely(size > len)) {
2194 count = (len - sizeof(struct fiemap)) /
2195 sizeof(struct fiemap_extent);
2196 fiemap->fm_mapped_extents = count;
2199 /* still swab extents as we cannot yet pass rc to callers */
2200 for (i = 0; i < count; i++)
2201 lustre_swab_fiemap_extent(&fiemap->fm_extents[i]);
2206 void lustre_swab_fiemap_info_key(struct ll_fiemap_info_key *fiemap_info)
2208 lustre_swab_obdo(&fiemap_info->lfik_oa);
2209 lustre_swab_fiemap_hdr(&fiemap_info->lfik_fiemap);
2212 void lustre_swab_idx_info(struct idx_info *ii)
2214 __swab32s(&ii->ii_magic);
2215 __swab32s(&ii->ii_flags);
2216 __swab16s(&ii->ii_count);
2217 __swab32s(&ii->ii_attrs);
2218 lustre_swab_lu_fid(&ii->ii_fid);
2219 __swab64s(&ii->ii_version);
2220 __swab64s(&ii->ii_hash_start);
2221 __swab64s(&ii->ii_hash_end);
2222 __swab16s(&ii->ii_keysize);
2223 __swab16s(&ii->ii_recsize);
2226 void lustre_swab_lip_header(struct lu_idxpage *lip)
2229 __swab32s(&lip->lip_magic);
2230 __swab16s(&lip->lip_flags);
2231 __swab16s(&lip->lip_nr);
2233 EXPORT_SYMBOL(lustre_swab_lip_header);
2235 void lustre_swab_mdt_rec_reint (struct mdt_rec_reint *rr)
2237 __swab32s(&rr->rr_opcode);
2238 __swab32s(&rr->rr_cap);
2239 __swab32s(&rr->rr_fsuid);
2240 /* rr_fsuid_h is unused */
2241 __swab32s(&rr->rr_fsgid);
2242 /* rr_fsgid_h is unused */
2243 __swab32s(&rr->rr_suppgid1);
2244 /* rr_suppgid1_h is unused */
2245 __swab32s(&rr->rr_suppgid2);
2246 /* rr_suppgid2_h is unused */
2247 lustre_swab_lu_fid(&rr->rr_fid1);
2248 lustre_swab_lu_fid(&rr->rr_fid2);
2249 __swab64s(&rr->rr_mtime);
2250 __swab64s(&rr->rr_atime);
2251 __swab64s(&rr->rr_ctime);
2252 __swab64s(&rr->rr_size);
2253 __swab64s(&rr->rr_blocks);
2254 __swab32s(&rr->rr_bias);
2255 __swab32s(&rr->rr_mode);
2256 __swab32s(&rr->rr_flags);
2257 __swab32s(&rr->rr_flags_h);
2258 __swab32s(&rr->rr_umask);
2259 __swab16s(&rr->rr_mirror_id);
2261 BUILD_BUG_ON(offsetof(typeof(*rr), rr_padding_4) == 0);
2264 void lustre_swab_lov_desc(struct lov_desc *ld)
2266 __swab32s(&ld->ld_tgt_count);
2267 __swab32s(&ld->ld_active_tgt_count);
2268 __swab32s(&ld->ld_default_stripe_count);
2269 __swab32s(&ld->ld_pattern);
2270 __swab64s(&ld->ld_default_stripe_size);
2271 __swab64s(&ld->ld_default_stripe_offset);
2272 __swab32s(&ld->ld_qos_maxage);
2273 /* uuid endian insensitive */
2275 EXPORT_SYMBOL(lustre_swab_lov_desc);
2277 void lustre_swab_lmv_desc(struct lmv_desc *ld)
2279 __swab32s(&ld->ld_tgt_count);
2280 __swab32s(&ld->ld_active_tgt_count);
2281 __swab32s(&ld->ld_default_stripe_count);
2282 __swab32s(&ld->ld_pattern);
2283 __swab64s(&ld->ld_default_hash_size);
2284 __swab32s(&ld->ld_qos_maxage);
2285 /* uuid endian insensitive */
2288 /* This structure is always in little-endian */
2289 static void lustre_swab_lmv_mds_md_v1(struct lmv_mds_md_v1 *lmm1)
2293 __swab32s(&lmm1->lmv_magic);
2294 __swab32s(&lmm1->lmv_stripe_count);
2295 __swab32s(&lmm1->lmv_master_mdt_index);
2296 __swab32s(&lmm1->lmv_hash_type);
2297 __swab32s(&lmm1->lmv_layout_version);
2298 for (i = 0; i < lmm1->lmv_stripe_count; i++)
2299 lustre_swab_lu_fid(&lmm1->lmv_stripe_fids[i]);
2302 void lustre_swab_lmv_mds_md(union lmv_mds_md *lmm)
2304 switch (lmm->lmv_magic) {
2306 lustre_swab_lmv_mds_md_v1(&lmm->lmv_md_v1);
2312 EXPORT_SYMBOL(lustre_swab_lmv_mds_md);
2314 void lustre_swab_lmv_user_md_objects(struct lmv_user_mds_data *lmd,
2319 for (i = 0; i < stripe_count; i++)
2320 __swab32s(&(lmd[i].lum_mds));
2322 EXPORT_SYMBOL(lustre_swab_lmv_user_md_objects);
2325 void lustre_swab_lmv_user_md(struct lmv_user_md *lum)
2329 if (lum->lum_magic == LMV_MAGIC_FOREIGN) {
2330 __swab32s(&lum->lum_magic);
2331 __swab32s(&((struct lmv_foreign_md *)lum)->lfm_length);
2332 __swab32s(&((struct lmv_foreign_md *)lum)->lfm_type);
2333 __swab32s(&((struct lmv_foreign_md *)lum)->lfm_flags);
2337 count = lum->lum_stripe_count;
2338 __swab32s(&lum->lum_magic);
2339 __swab32s(&lum->lum_stripe_count);
2340 __swab32s(&lum->lum_stripe_offset);
2341 __swab32s(&lum->lum_hash_type);
2342 __swab32s(&lum->lum_type);
2343 /* lum_max_inherit and lum_max_inherit_rr do not need to be swabbed */
2344 BUILD_BUG_ON(offsetof(typeof(*lum), lum_padding1) == 0);
2345 BUILD_BUG_ON(offsetof(typeof(*lum), lum_padding2) == 0);
2346 BUILD_BUG_ON(offsetof(typeof(*lum), lum_padding3) == 0);
2347 switch (lum->lum_magic) {
2348 case LMV_USER_MAGIC_SPECIFIC:
2349 count = lum->lum_stripe_count;
2351 case __swab32(LMV_USER_MAGIC_SPECIFIC):
2352 lustre_swab_lmv_user_md_objects(lum->lum_objects, count);
2358 EXPORT_SYMBOL(lustre_swab_lmv_user_md);
2360 static void lustre_print_v1v3(unsigned int lvl, struct lov_user_md *lum,
2363 CDEBUG(lvl, "%s lov_user_md %p:\n", msg, lum);
2364 CDEBUG(lvl, "\tlmm_magic: %#x\n", lum->lmm_magic);
2365 CDEBUG(lvl, "\tlmm_pattern: %#x\n", lum->lmm_pattern);
2366 CDEBUG(lvl, "\tlmm_object_id: %llu\n", lmm_oi_id(&lum->lmm_oi));
2367 CDEBUG(lvl, "\tlmm_object_gr: %llu\n", lmm_oi_seq(&lum->lmm_oi));
2368 CDEBUG(lvl, "\tlmm_stripe_size: %#x\n", lum->lmm_stripe_size);
2369 CDEBUG(lvl, "\tlmm_stripe_count: %#x\n", lum->lmm_stripe_count);
2370 CDEBUG(lvl, "\tlmm_stripe_offset/lmm_layout_gen: %#x\n",
2371 lum->lmm_stripe_offset);
2372 if (lum->lmm_magic == LOV_USER_MAGIC_V3) {
2373 struct lov_user_md_v3 *v3 = (void *)lum;
2374 CDEBUG(lvl, "\tlmm_pool_name: %s\n", v3->lmm_pool_name);
2376 if (lum->lmm_magic == LOV_USER_MAGIC_SPECIFIC) {
2377 struct lov_user_md_v3 *v3 = (void *)lum;
2380 if (v3->lmm_pool_name[0] != '\0')
2381 CDEBUG(lvl, "\tlmm_pool_name: %s\n", v3->lmm_pool_name);
2383 CDEBUG(lvl, "\ttarget list:\n");
2384 for (i = 0; i < v3->lmm_stripe_count; i++)
2385 CDEBUG(lvl, "\t\t%u\n", v3->lmm_objects[i].l_ost_idx);
2389 void lustre_print_user_md(unsigned int lvl, struct lov_user_md *lum,
2392 struct lov_comp_md_v1 *comp_v1;
2395 if (likely(!cfs_cdebug_show(lvl, DEBUG_SUBSYSTEM)))
2398 if (lum->lmm_magic == LOV_USER_MAGIC_V1 ||
2399 lum->lmm_magic == LOV_USER_MAGIC_V3) {
2400 lustre_print_v1v3(lvl, lum, msg);
2404 if (lum->lmm_magic != LOV_USER_MAGIC_COMP_V1) {
2405 CDEBUG(lvl, "%s: bad magic: %x\n", msg, lum->lmm_magic);
2409 comp_v1 = (struct lov_comp_md_v1 *)lum;
2410 CDEBUG(lvl, "%s: lov_comp_md_v1 %p:\n", msg, lum);
2411 CDEBUG(lvl, "\tlcm_magic: %#x\n", comp_v1->lcm_magic);
2412 CDEBUG(lvl, "\tlcm_size: %#x\n", comp_v1->lcm_size);
2413 CDEBUG(lvl, "\tlcm_layout_gen: %#x\n", comp_v1->lcm_layout_gen);
2414 CDEBUG(lvl, "\tlcm_flags: %#x\n", comp_v1->lcm_flags);
2415 CDEBUG(lvl, "\tlcm_entry_count: %#x\n\n", comp_v1->lcm_entry_count);
2416 CDEBUG(lvl, "\tlcm_mirror_count: %#x\n\n", comp_v1->lcm_mirror_count);
2418 for (i = 0; i < comp_v1->lcm_entry_count; i++) {
2419 struct lov_comp_md_entry_v1 *ent = &comp_v1->lcm_entries[i];
2420 struct lov_user_md *v1;
2422 CDEBUG(lvl, "\tentry %d:\n", i);
2423 CDEBUG(lvl, "\tlcme_id: %#x\n", ent->lcme_id);
2424 CDEBUG(lvl, "\tlcme_flags: %#x\n", ent->lcme_flags);
2425 if (ent->lcme_flags & LCME_FL_NOSYNC)
2426 CDEBUG(lvl, "\tlcme_timestamp: %llu\n",
2427 ent->lcme_timestamp);
2428 CDEBUG(lvl, "\tlcme_extent.e_start: %llu\n",
2429 ent->lcme_extent.e_start);
2430 CDEBUG(lvl, "\tlcme_extent.e_end: %llu\n",
2431 ent->lcme_extent.e_end);
2432 CDEBUG(lvl, "\tlcme_offset: %#x\n", ent->lcme_offset);
2433 CDEBUG(lvl, "\tlcme_size: %#x\n\n", ent->lcme_size);
2435 v1 = (struct lov_user_md *)((char *)comp_v1 +
2436 comp_v1->lcm_entries[i].lcme_offset);
2437 lustre_print_v1v3(lvl, v1, msg);
2440 EXPORT_SYMBOL(lustre_print_user_md);
2442 static void lustre_swab_lmm_oi(struct ost_id *oi)
2444 __swab64s(&oi->oi.oi_id);
2445 __swab64s(&oi->oi.oi_seq);
2448 static void lustre_swab_lov_user_md_common(struct lov_user_md_v1 *lum)
2451 __swab32s(&lum->lmm_magic);
2452 __swab32s(&lum->lmm_pattern);
2453 lustre_swab_lmm_oi(&lum->lmm_oi);
2454 __swab32s(&lum->lmm_stripe_size);
2455 __swab16s(&lum->lmm_stripe_count);
2456 __swab16s(&lum->lmm_stripe_offset);
2460 void lustre_swab_lov_user_md_v1(struct lov_user_md_v1 *lum)
2463 CDEBUG(D_IOCTL, "swabbing lov_user_md v1\n");
2464 lustre_swab_lov_user_md_common(lum);
2467 EXPORT_SYMBOL(lustre_swab_lov_user_md_v1);
2469 void lustre_swab_lov_user_md_v3(struct lov_user_md_v3 *lum)
2472 CDEBUG(D_IOCTL, "swabbing lov_user_md v3\n");
2473 lustre_swab_lov_user_md_common((struct lov_user_md_v1 *)lum);
2474 /* lmm_pool_name nothing to do with char */
2477 EXPORT_SYMBOL(lustre_swab_lov_user_md_v3);
2479 void lustre_swab_lov_comp_md_v1(struct lov_comp_md_v1 *lum)
2481 struct lov_comp_md_entry_v1 *ent;
2482 struct lov_user_md_v1 *v1;
2483 struct lov_user_md_v3 *v3;
2487 __u16 ent_count, stripe_count;
2490 cpu_endian = lum->lcm_magic == LOV_USER_MAGIC_COMP_V1;
2491 ent_count = lum->lcm_entry_count;
2493 __swab16s(&ent_count);
2495 CDEBUG(D_IOCTL, "swabbing lov_user_comp_md v1\n");
2496 __swab32s(&lum->lcm_magic);
2497 __swab32s(&lum->lcm_size);
2498 __swab32s(&lum->lcm_layout_gen);
2499 __swab16s(&lum->lcm_flags);
2500 __swab16s(&lum->lcm_entry_count);
2501 __swab16s(&lum->lcm_mirror_count);
2502 /* no need to swab lcm_ec_count */
2503 BUILD_BUG_ON(offsetof(typeof(*lum), lcm_padding1) == 0);
2504 BUILD_BUG_ON(offsetof(typeof(*lum), lcm_padding2) == 0);
2505 BUILD_BUG_ON(offsetof(typeof(*lum), lcm_padding3) == 0);
2507 for (i = 0; i < ent_count; i++) {
2508 ent = &lum->lcm_entries[i];
2509 off = ent->lcme_offset;
2510 size = ent->lcme_size;
2516 __swab32s(&ent->lcme_id);
2517 __swab32s(&ent->lcme_flags);
2518 __swab64s(&ent->lcme_timestamp);
2519 __swab64s(&ent->lcme_extent.e_start);
2520 __swab64s(&ent->lcme_extent.e_end);
2521 __swab32s(&ent->lcme_offset);
2522 __swab32s(&ent->lcme_size);
2523 __swab32s(&ent->lcme_layout_gen);
2524 /* no need to swab lcme_dstripe_count */
2525 /* no need to swab lcme_cstripe_count */
2527 v1 = (struct lov_user_md_v1 *)((char *)lum + off);
2528 stripe_count = v1->lmm_stripe_count;
2530 __swab16s(&stripe_count);
2532 if (v1->lmm_magic == __swab32(LOV_USER_MAGIC_V1) ||
2533 v1->lmm_magic == LOV_USER_MAGIC_V1) {
2534 lustre_swab_lov_user_md_v1(v1);
2535 if (size > sizeof(*v1))
2536 lustre_swab_lov_user_md_objects(v1->lmm_objects,
2538 } else if (v1->lmm_magic == __swab32(LOV_USER_MAGIC_V3) ||
2539 v1->lmm_magic == LOV_USER_MAGIC_V3 ||
2540 v1->lmm_magic == __swab32(LOV_USER_MAGIC_SPECIFIC) ||
2541 v1->lmm_magic == LOV_USER_MAGIC_SPECIFIC) {
2542 v3 = (struct lov_user_md_v3 *)v1;
2543 lustre_swab_lov_user_md_v3(v3);
2544 if (size > sizeof(*v3))
2545 lustre_swab_lov_user_md_objects(v3->lmm_objects,
2548 CERROR("Invalid magic %#x\n", v1->lmm_magic);
2552 EXPORT_SYMBOL(lustre_swab_lov_comp_md_v1);
2554 void lustre_swab_lov_user_md_objects(struct lov_user_ost_data *lod,
2560 for (i = 0; i < stripe_count; i++) {
2561 lustre_swab_ost_id(&(lod[i].l_ost_oi));
2562 __swab32s(&(lod[i].l_ost_gen));
2563 __swab32s(&(lod[i].l_ost_idx));
2567 EXPORT_SYMBOL(lustre_swab_lov_user_md_objects);
2569 void lustre_swab_lov_user_md(struct lov_user_md *lum, size_t size)
2571 struct lov_user_md_v1 *v1;
2572 struct lov_user_md_v3 *v3;
2573 struct lov_foreign_md *lfm;
2577 CDEBUG(D_IOCTL, "swabbing lov_user_md\n");
2578 switch (lum->lmm_magic) {
2579 case __swab32(LOV_MAGIC_V1):
2580 case LOV_USER_MAGIC_V1:
2582 v1 = (struct lov_user_md_v1 *)lum;
2583 stripe_count = v1->lmm_stripe_count;
2585 if (lum->lmm_magic != LOV_USER_MAGIC_V1)
2586 __swab16s(&stripe_count);
2588 lustre_swab_lov_user_md_v1(v1);
2589 if (size > sizeof(*v1))
2590 lustre_swab_lov_user_md_objects(v1->lmm_objects,
2595 case __swab32(LOV_MAGIC_V3):
2596 case LOV_USER_MAGIC_V3:
2598 v3 = (struct lov_user_md_v3 *)lum;
2599 stripe_count = v3->lmm_stripe_count;
2601 if (lum->lmm_magic != LOV_USER_MAGIC_V3)
2602 __swab16s(&stripe_count);
2604 lustre_swab_lov_user_md_v3(v3);
2605 if (size > sizeof(*v3))
2606 lustre_swab_lov_user_md_objects(v3->lmm_objects,
2610 case __swab32(LOV_USER_MAGIC_SPECIFIC):
2611 case LOV_USER_MAGIC_SPECIFIC:
2613 v3 = (struct lov_user_md_v3 *)lum;
2614 stripe_count = v3->lmm_stripe_count;
2616 if (lum->lmm_magic != LOV_USER_MAGIC_SPECIFIC)
2617 __swab16s(&stripe_count);
2619 lustre_swab_lov_user_md_v3(v3);
2620 lustre_swab_lov_user_md_objects(v3->lmm_objects, stripe_count);
2623 case __swab32(LOV_MAGIC_COMP_V1):
2624 case LOV_USER_MAGIC_COMP_V1:
2625 lustre_swab_lov_comp_md_v1((struct lov_comp_md_v1 *)lum);
2627 case __swab32(LOV_MAGIC_FOREIGN):
2628 case LOV_USER_MAGIC_FOREIGN:
2630 lfm = (struct lov_foreign_md *)lum;
2631 __swab32s(&lfm->lfm_magic);
2632 __swab32s(&lfm->lfm_length);
2633 __swab32s(&lfm->lfm_type);
2634 __swab32s(&lfm->lfm_flags);
2638 CDEBUG(D_IOCTL, "Invalid LOV magic %08x\n", lum->lmm_magic);
2641 EXPORT_SYMBOL(lustre_swab_lov_user_md);
2643 void lustre_swab_lov_mds_md(struct lov_mds_md *lmm)
2646 CDEBUG(D_IOCTL, "swabbing lov_mds_md\n");
2647 __swab32s(&lmm->lmm_magic);
2648 __swab32s(&lmm->lmm_pattern);
2649 lustre_swab_lmm_oi(&lmm->lmm_oi);
2650 __swab32s(&lmm->lmm_stripe_size);
2651 __swab16s(&lmm->lmm_stripe_count);
2652 __swab16s(&lmm->lmm_layout_gen);
2655 EXPORT_SYMBOL(lustre_swab_lov_mds_md);
2657 void lustre_swab_ldlm_res_id(struct ldlm_res_id *id)
2661 for (i = 0; i < RES_NAME_SIZE; i++)
2662 __swab64s(&id->name[i]);
2665 void lustre_swab_ldlm_policy_data(union ldlm_wire_policy_data *d)
2667 /* the lock data is a union and the first two fields are always an
2668 * extent so it's ok to process an LDLM_EXTENT and LDLM_FLOCK lock
2669 * data the same way.
2671 __swab64s(&d->l_extent.start);
2672 __swab64s(&d->l_extent.end);
2673 __swab64s(&d->l_extent.gid);
2674 __swab32s(&d->l_flock.lfw_padding);
2675 __swab32s(&d->l_flock.lfw_pid);
2678 void lustre_swab_ldlm_intent(struct ldlm_intent *i)
2683 void lustre_swab_ldlm_resource_desc(struct ldlm_resource_desc *r)
2685 __swab32s(&r->lr_type);
2686 BUILD_BUG_ON(offsetof(typeof(*r), lr_pad) == 0);
2687 lustre_swab_ldlm_res_id(&r->lr_name);
2690 void lustre_swab_ldlm_lock_desc(struct ldlm_lock_desc *l)
2692 lustre_swab_ldlm_resource_desc(&l->l_resource);
2693 __swab32s(&l->l_req_mode);
2694 __swab32s(&l->l_granted_mode);
2695 lustre_swab_ldlm_policy_data(&l->l_policy_data);
2698 void lustre_swab_ldlm_request(struct ldlm_request *rq)
2700 __swab32s(&rq->lock_flags);
2701 lustre_swab_ldlm_lock_desc(&rq->lock_desc);
2702 __swab32s(&rq->lock_count);
2703 /* lock_handle[] opaque */
2706 void lustre_swab_ldlm_reply(struct ldlm_reply *r)
2708 __swab32s(&r->lock_flags);
2709 BUILD_BUG_ON(offsetof(typeof(*r), lock_padding) == 0);
2710 lustre_swab_ldlm_lock_desc(&r->lock_desc);
2711 /* lock_handle opaque */
2712 __swab64s(&r->lock_policy_res1);
2713 __swab64s(&r->lock_policy_res2);
2716 void lustre_swab_quota_body(struct quota_body *b)
2718 lustre_swab_lu_fid(&b->qb_fid);
2719 lustre_swab_lu_fid((struct lu_fid *)&b->qb_id);
2720 __swab32s(&b->qb_flags);
2721 __swab64s(&b->qb_count);
2722 __swab64s(&b->qb_usage);
2723 __swab64s(&b->qb_slv_ver);
2726 /* Dump functions */
2727 void dump_ioo(struct obd_ioobj *ioo)
2730 "obd_ioobj: ioo_oid="DOSTID", ioo_max_brw=%#x, "
2731 "ioo_bufct=%d\n", POSTID(&ioo->ioo_oid), ioo->ioo_max_brw,
2735 void dump_rniobuf(struct niobuf_remote *nb)
2737 CDEBUG(D_RPCTRACE, "niobuf_remote: offset=%llu, len=%d, flags=%x\n",
2738 nb->rnb_offset, nb->rnb_len, nb->rnb_flags);
2741 static void dump_obdo(struct obdo *oa)
2743 u64 valid = oa->o_valid;
2745 CDEBUG(D_RPCTRACE, "obdo: o_valid = %#llx\n", valid);
2746 if (valid & OBD_MD_FLID)
2747 CDEBUG(D_RPCTRACE, "obdo: id = "DOSTID"\n", POSTID(&oa->o_oi));
2748 if (valid & OBD_MD_FLFID)
2749 CDEBUG(D_RPCTRACE, "obdo: o_parent_seq = %#llx\n",
2751 if (valid & OBD_MD_FLSIZE)
2752 CDEBUG(D_RPCTRACE, "obdo: o_size = %lld\n", oa->o_size);
2753 if (valid & OBD_MD_FLMTIME)
2754 CDEBUG(D_RPCTRACE, "obdo: o_mtime = %lld\n", oa->o_mtime);
2755 if (valid & OBD_MD_FLATIME)
2756 CDEBUG(D_RPCTRACE, "obdo: o_atime = %lld\n", oa->o_atime);
2757 if (valid & OBD_MD_FLCTIME)
2758 CDEBUG(D_RPCTRACE, "obdo: o_ctime = %lld\n", oa->o_ctime);
2759 if (valid & OBD_MD_FLBLOCKS) /* allocation of space */
2760 CDEBUG(D_RPCTRACE, "obdo: o_blocks = %lld\n", oa->o_blocks);
2761 if (valid & OBD_MD_FLGRANT)
2762 CDEBUG(D_RPCTRACE, "obdo: o_grant = %lld\n", oa->o_grant);
2763 if (valid & OBD_MD_FLBLKSZ)
2764 CDEBUG(D_RPCTRACE, "obdo: o_blksize = %d\n", oa->o_blksize);
2765 if (valid & (OBD_MD_FLTYPE | OBD_MD_FLMODE))
2766 CDEBUG(D_RPCTRACE, "obdo: o_mode = %o\n",
2767 oa->o_mode & ((valid & OBD_MD_FLTYPE ? S_IFMT : 0) |
2768 (valid & OBD_MD_FLMODE ? ~S_IFMT : 0)));
2769 if (valid & OBD_MD_FLUID)
2770 CDEBUG(D_RPCTRACE, "obdo: o_uid = %u\n", oa->o_uid);
2771 if (valid & OBD_MD_FLUID)
2772 CDEBUG(D_RPCTRACE, "obdo: o_uid_h = %u\n", oa->o_uid_h);
2773 if (valid & OBD_MD_FLGID)
2774 CDEBUG(D_RPCTRACE, "obdo: o_gid = %u\n", oa->o_gid);
2775 if (valid & OBD_MD_FLGID)
2776 CDEBUG(D_RPCTRACE, "obdo: o_gid_h = %u\n", oa->o_gid_h);
2777 if (valid & OBD_MD_FLFLAGS)
2778 CDEBUG(D_RPCTRACE, "obdo: o_flags = %x\n", oa->o_flags);
2779 if (valid & OBD_MD_FLNLINK)
2780 CDEBUG(D_RPCTRACE, "obdo: o_nlink = %u\n", oa->o_nlink);
2781 else if (valid & OBD_MD_FLCKSUM)
2782 CDEBUG(D_RPCTRACE, "obdo: o_checksum (o_nlink) = %u\n",
2784 if (valid & OBD_MD_FLPARENT)
2785 CDEBUG(D_RPCTRACE, "obdo: o_parent_oid = %x\n",
2787 if (valid & OBD_MD_FLFID) {
2788 CDEBUG(D_RPCTRACE, "obdo: o_stripe_idx = %u\n",
2790 CDEBUG(D_RPCTRACE, "obdo: o_parent_ver = %x\n",
2793 if (valid & OBD_MD_FLHANDLE)
2794 CDEBUG(D_RPCTRACE, "obdo: o_handle = %lld\n",
2795 oa->o_handle.cookie);
2798 void dump_ost_body(struct ost_body *ob)
2803 void dump_rcs(__u32 *rc)
2805 CDEBUG(D_RPCTRACE, "rmf_rcs: %d\n", *rc);
2808 static inline int req_ptlrpc_body_swabbed(struct ptlrpc_request *req)
2810 LASSERT(req->rq_reqmsg);
2812 switch (req->rq_reqmsg->lm_magic) {
2813 case LUSTRE_MSG_MAGIC_V2:
2814 return req_capsule_req_swabbed(&req->rq_pill,
2815 MSG_PTLRPC_BODY_OFF);
2817 CERROR("bad lustre msg magic: %#08X\n",
2818 req->rq_reqmsg->lm_magic);
2823 static inline int rep_ptlrpc_body_swabbed(struct ptlrpc_request *req)
2825 if (unlikely(!req->rq_repmsg))
2828 switch (req->rq_repmsg->lm_magic) {
2829 case LUSTRE_MSG_MAGIC_V2:
2830 return req_capsule_rep_swabbed(&req->rq_pill,
2831 MSG_PTLRPC_BODY_OFF);
2833 /* uninitialized yet */
2838 void _debug_req(struct ptlrpc_request *req,
2839 struct libcfs_debug_msg_data *msgdata, const char *fmt, ...)
2841 bool req_ok = req->rq_reqmsg != NULL;
2842 bool rep_ok = false;
2843 struct lnet_nid *nid = NULL;
2844 struct va_format vaf;
2847 int rep_status = -1;
2848 __u64 req_transno = 0;
2850 __u32 req_flags = (__u32) -1;
2851 __u32 req_uid = (__u32) -1;
2852 __u32 req_gid = (__u32) -1;
2853 char *req_jobid = NULL;
2855 spin_lock(&req->rq_early_free_lock);
2859 if (req_capsule_req_need_swab(&req->rq_pill)) {
2860 req_ok = req_ok && req_ptlrpc_body_swabbed(req);
2861 rep_ok = rep_ok && rep_ptlrpc_body_swabbed(req);
2865 rep_flags = lustre_msg_get_flags(req->rq_repmsg);
2866 rep_status = lustre_msg_get_status(req->rq_repmsg);
2868 spin_unlock(&req->rq_early_free_lock);
2870 if (req->rq_import && req->rq_import->imp_connection)
2871 nid = &req->rq_import->imp_connection->c_peer.nid;
2872 else if (req->rq_export && req->rq_export->exp_connection)
2873 nid = &req->rq_export->exp_connection->c_peer.nid;
2876 req_transno = lustre_msg_get_transno(req->rq_reqmsg);
2877 req_opc = lustre_msg_get_opc(req->rq_reqmsg);
2878 req_jobid = lustre_msg_get_jobid(req->rq_reqmsg);
2879 lustre_msg_get_uid_gid(req->rq_reqmsg, &req_uid, &req_gid);
2880 req_flags = lustre_msg_get_flags(req->rq_reqmsg);
2883 va_start(args, fmt);
2886 libcfs_debug_msg(msgdata,
2887 "%pV req@%p x%llu/t%lld(%llu) o%d->%s@%s:%d/%d lens %d/%d e %d to %lld dl %lld ref %d fl " REQ_FLAGS_FMT "/%x/%x rc %d/%d uid:%u gid:%u job:'%s'\n",
2889 req, req->rq_xid, req->rq_transno, req_transno,
2892 req->rq_import->imp_obd->obd_name :
2894 req->rq_export->exp_client_uuid.uuid :
2896 nid ? libcfs_nidstr(nid) : "<unknown>",
2897 req->rq_request_portal, req->rq_reply_portal,
2898 req->rq_reqlen, req->rq_replen,
2899 req->rq_early_count, (s64)req->rq_timedout,
2900 (s64)req->rq_deadline,
2901 atomic_read(&req->rq_refcount),
2902 DEBUG_REQ_FLAGS(req), req_flags, rep_flags,
2903 req->rq_status, rep_status,
2904 req_uid, req_gid, req_jobid ?: "");
2907 EXPORT_SYMBOL(_debug_req);
2909 void lustre_swab_hsm_user_state(struct hsm_user_state *state)
2911 __swab32s(&state->hus_states);
2912 __swab32s(&state->hus_archive_id);
2915 void lustre_swab_hsm_state_set(struct hsm_state_set *hss)
2917 __swab32s(&hss->hss_valid);
2918 __swab64s(&hss->hss_setmask);
2919 __swab64s(&hss->hss_clearmask);
2920 __swab32s(&hss->hss_archive_id);
2923 static void lustre_swab_hsm_extent(struct hsm_extent *extent)
2925 __swab64s(&extent->offset);
2926 __swab64s(&extent->length);
2929 void lustre_swab_hsm_current_action(struct hsm_current_action *action)
2931 __swab32s(&action->hca_state);
2932 __swab32s(&action->hca_action);
2933 lustre_swab_hsm_extent(&action->hca_location);
2936 void lustre_swab_hsm_user_item(struct hsm_user_item *hui)
2938 lustre_swab_lu_fid(&hui->hui_fid);
2939 lustre_swab_hsm_extent(&hui->hui_extent);
2942 static void lustre_swab_lu_extent(struct lu_extent *le)
2944 __swab64s(&le->e_start);
2945 __swab64s(&le->e_end);
2948 void lustre_swab_layout_intent(struct layout_intent *li)
2950 __swab32s(&li->li_opc);
2951 __swab32s(&li->li_flags);
2952 lustre_swab_lu_extent(&li->li_extent);
2955 void lustre_swab_hsm_progress_kernel(struct hsm_progress_kernel *hpk)
2957 lustre_swab_lu_fid(&hpk->hpk_fid);
2958 __swab64s(&hpk->hpk_cookie);
2959 __swab64s(&hpk->hpk_extent.offset);
2960 __swab64s(&hpk->hpk_extent.length);
2961 __swab16s(&hpk->hpk_flags);
2962 __swab16s(&hpk->hpk_errval);
2965 void lustre_swab_hsm_request(struct hsm_request *hr)
2967 __swab32s(&hr->hr_action);
2968 __swab32s(&hr->hr_archive_id);
2969 __swab64s(&hr->hr_flags);
2970 __swab32s(&hr->hr_itemcount);
2971 __swab32s(&hr->hr_data_len);
2974 /* TODO: swab each sub request message */
2975 void lustre_swab_batch_update_request(struct batch_update_request *bur)
2977 __swab32s(&bur->burq_magic);
2978 __swab16s(&bur->burq_count);
2979 __swab16s(&bur->burq_padding);
2982 /* TODO: swab each sub reply message. */
2983 void lustre_swab_batch_update_reply(struct batch_update_reply *bur)
2985 __swab32s(&bur->burp_magic);
2986 __swab16s(&bur->burp_count);
2987 __swab16s(&bur->burp_padding);
2990 void lustre_swab_but_update_header(struct but_update_header *buh)
2992 __swab32s(&buh->buh_magic);
2993 __swab32s(&buh->buh_count);
2994 __swab32s(&buh->buh_inline_length);
2995 __swab32s(&buh->buh_reply_size);
2996 __swab32s(&buh->buh_update_count);
2998 EXPORT_SYMBOL(lustre_swab_but_update_header);
3000 void lustre_swab_but_update_buffer(struct but_update_buffer *bub)
3002 __swab32s(&bub->bub_size);
3003 __swab32s(&bub->bub_padding);
3005 EXPORT_SYMBOL(lustre_swab_but_update_buffer);
3007 void lustre_swab_swap_layouts(struct mdc_swap_layouts *msl)
3009 __swab64s(&msl->msl_flags);
3012 void lustre_swab_close_data(struct close_data *cd)
3014 lustre_swab_lu_fid(&cd->cd_fid);
3015 __swab64s(&cd->cd_data_version);
3018 void lustre_swab_close_data_resync_done(struct close_data_resync_done *resync)
3022 __swab32s(&resync->resync_count);
3023 /* after swab, resync_count must in CPU endian */
3024 if (resync->resync_count <= INLINE_RESYNC_ARRAY_SIZE) {
3025 for (i = 0; i < resync->resync_count; i++)
3026 __swab32s(&resync->resync_ids_inline[i]);
3029 EXPORT_SYMBOL(lustre_swab_close_data_resync_done);
3031 void lustre_swab_lfsck_request(struct lfsck_request *lr)
3033 __swab32s(&lr->lr_event);
3034 __swab32s(&lr->lr_index);
3035 __swab32s(&lr->lr_flags);
3036 __swab32s(&lr->lr_valid);
3037 __swab32s(&lr->lr_speed);
3038 __swab16s(&lr->lr_version);
3039 __swab16s(&lr->lr_active);
3040 __swab16s(&lr->lr_param);
3041 __swab16s(&lr->lr_async_windows);
3042 __swab32s(&lr->lr_flags);
3043 lustre_swab_lu_fid(&lr->lr_fid);
3044 lustre_swab_lu_fid(&lr->lr_fid2);
3045 __swab32s(&lr->lr_comp_id);
3046 BUILD_BUG_ON(offsetof(typeof(*lr), lr_padding_0) == 0);
3047 BUILD_BUG_ON(offsetof(typeof(*lr), lr_padding_1) == 0);
3048 BUILD_BUG_ON(offsetof(typeof(*lr), lr_padding_2) == 0);
3049 BUILD_BUG_ON(offsetof(typeof(*lr), lr_padding_3) == 0);
3052 void lustre_swab_lfsck_reply(struct lfsck_reply *lr)
3054 __swab32s(&lr->lr_status);
3055 BUILD_BUG_ON(offsetof(typeof(*lr), lr_padding_1) == 0);
3056 __swab64s(&lr->lr_repaired);
3059 static void lustre_swab_orphan_rec(struct lu_orphan_rec *rec)
3061 lustre_swab_lu_fid(&rec->lor_fid);
3062 __swab32s(&rec->lor_uid);
3063 __swab32s(&rec->lor_gid);
3066 void lustre_swab_orphan_ent(struct lu_orphan_ent *ent)
3068 lustre_swab_lu_fid(&ent->loe_key);
3069 lustre_swab_orphan_rec(&ent->loe_rec);
3071 EXPORT_SYMBOL(lustre_swab_orphan_ent);
3073 void lustre_swab_orphan_ent_v2(struct lu_orphan_ent_v2 *ent)
3075 lustre_swab_lu_fid(&ent->loe_key);
3076 lustre_swab_orphan_rec(&ent->loe_rec.lor_rec);
3077 lustre_swab_ost_layout(&ent->loe_rec.lor_layout);
3078 BUILD_BUG_ON(offsetof(typeof(ent->loe_rec), lor_padding) == 0);
3080 EXPORT_SYMBOL(lustre_swab_orphan_ent_v2);
3082 void lustre_swab_orphan_ent_v3(struct lu_orphan_ent_v3 *ent)
3084 lustre_swab_lu_fid(&ent->loe_key);
3085 lustre_swab_orphan_rec(&ent->loe_rec.lor_rec);
3086 lustre_swab_ost_layout(&ent->loe_rec.lor_layout);
3087 __swab32s(&ent->loe_rec.lor_layout_version);
3088 __swab32s(&ent->loe_rec.lor_range);
3089 BUILD_BUG_ON(offsetof(typeof(ent->loe_rec), lor_padding_1) == 0);
3090 BUILD_BUG_ON(offsetof(typeof(ent->loe_rec), lor_padding_2) == 0);
3092 EXPORT_SYMBOL(lustre_swab_orphan_ent_v3);
3094 void lustre_swab_ladvise(struct lu_ladvise *ladvise)
3096 __swab16s(&ladvise->lla_advice);
3097 __swab16s(&ladvise->lla_value1);
3098 __swab32s(&ladvise->lla_value2);
3099 __swab64s(&ladvise->lla_start);
3100 __swab64s(&ladvise->lla_end);
3101 __swab32s(&ladvise->lla_value3);
3102 __swab32s(&ladvise->lla_value4);
3104 EXPORT_SYMBOL(lustre_swab_ladvise);
3106 void lustre_swab_ladvise_hdr(struct ladvise_hdr *ladvise_hdr)
3108 __swab32s(&ladvise_hdr->lah_magic);
3109 __swab32s(&ladvise_hdr->lah_count);
3110 __swab64s(&ladvise_hdr->lah_flags);
3111 __swab32s(&ladvise_hdr->lah_value1);
3112 __swab32s(&ladvise_hdr->lah_value2);
3113 __swab64s(&ladvise_hdr->lah_value3);
3115 EXPORT_SYMBOL(lustre_swab_ladvise_hdr);