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.sun.com/software/products/lustre/docs/GPLv2.pdf
20 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21 * CA 95054 USA or visit www.sun.com if you need additional information or
27 * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
28 * Use is subject to license terms.
30 * Copyright (c) 2011, 2012, Intel Corporation.
33 * This file is part of Lustre, http://www.lustre.org/
34 * Lustre is a trademark of Sun Microsystems, Inc.
36 * lustre/ptlrpc/pack_generic.c
38 * (Un)packing of OST requests
40 * Author: Peter J. Braam <braam@clusterfs.com>
41 * Author: Phil Schwan <phil@clusterfs.com>
42 * Author: Eric Barton <eeb@clusterfs.com>
45 #define DEBUG_SUBSYSTEM S_RPC
47 #include "../../include/linux/libcfs/libcfs.h"
49 #include "../include/obd_support.h"
50 #include "../include/obd_class.h"
51 #include "../include/lustre_net.h"
52 #include "../include/obd_cksum.h"
53 #include "../include/lustre/ll_fiemap.h"
55 #include "ptlrpc_internal.h"
57 static inline int lustre_msg_hdr_size_v2(int count
)
59 return cfs_size_round(offsetof(struct lustre_msg_v2
,
63 int lustre_msg_hdr_size(__u32 magic
, int count
)
66 case LUSTRE_MSG_MAGIC_V2
:
67 return lustre_msg_hdr_size_v2(count
);
69 LASSERTF(0, "incorrect message magic: %08x\n", magic
);
73 EXPORT_SYMBOL(lustre_msg_hdr_size
);
75 void ptlrpc_buf_set_swabbed(struct ptlrpc_request
*req
, const int inout
,
79 lustre_set_req_swabbed(req
, index
);
81 lustre_set_rep_swabbed(req
, index
);
83 EXPORT_SYMBOL(ptlrpc_buf_set_swabbed
);
85 int ptlrpc_buf_need_swab(struct ptlrpc_request
*req
, const int inout
,
89 return (ptlrpc_req_need_swab(req
) &&
90 !lustre_req_swabbed(req
, index
));
92 return (ptlrpc_rep_need_swab(req
) &&
93 !lustre_rep_swabbed(req
, index
));
95 EXPORT_SYMBOL(ptlrpc_buf_need_swab
);
97 /* early reply size */
98 int lustre_msg_early_size(void)
103 /* Always reply old ptlrpc_body_v2 to keep interoperability
104 * with the old client (< 2.3) which doesn't have pb_jobid
105 * in the ptlrpc_body.
107 * XXX Remove this whenever we drop interoperability with such
110 __u32 pblen
= sizeof(struct ptlrpc_body_v2
);
112 size
= lustre_msg_size(LUSTRE_MSG_MAGIC_V2
, 1, &pblen
);
116 EXPORT_SYMBOL(lustre_msg_early_size
);
118 int lustre_msg_size_v2(int count
, __u32
*lengths
)
123 size
= lustre_msg_hdr_size_v2(count
);
124 for (i
= 0; i
< count
; i
++)
125 size
+= cfs_size_round(lengths
[i
]);
129 EXPORT_SYMBOL(lustre_msg_size_v2
);
131 /* This returns the size of the buffer that is required to hold a lustre_msg
132 * with the given sub-buffer lengths.
133 * NOTE: this should only be used for NEW requests, and should always be
134 * in the form of a v2 request. If this is a connection to a v1
135 * target then the first buffer will be stripped because the ptlrpc
136 * data is part of the lustre_msg_v1 header. b=14043 */
137 int lustre_msg_size(__u32 magic
, int count
, __u32
*lens
)
139 __u32 size
[] = { sizeof(struct ptlrpc_body
) };
147 LASSERT(lens
[MSG_PTLRPC_BODY_OFF
] >= sizeof(struct ptlrpc_body_v2
));
150 case LUSTRE_MSG_MAGIC_V2
:
151 return lustre_msg_size_v2(count
, lens
);
153 LASSERTF(0, "incorrect message magic: %08x\n", magic
);
157 EXPORT_SYMBOL(lustre_msg_size
);
159 /* This is used to determine the size of a buffer that was already packed
160 * and will correctly handle the different message formats. */
161 int lustre_packed_msg_size(struct lustre_msg
*msg
)
163 switch (msg
->lm_magic
) {
164 case LUSTRE_MSG_MAGIC_V2
:
165 return lustre_msg_size_v2(msg
->lm_bufcount
, msg
->lm_buflens
);
167 CERROR("incorrect message magic: %08x\n", msg
->lm_magic
);
171 EXPORT_SYMBOL(lustre_packed_msg_size
);
173 void lustre_init_msg_v2(struct lustre_msg_v2
*msg
, int count
, __u32
*lens
,
179 msg
->lm_bufcount
= count
;
180 /* XXX: lm_secflvr uninitialized here */
181 msg
->lm_magic
= LUSTRE_MSG_MAGIC_V2
;
183 for (i
= 0; i
< count
; i
++)
184 msg
->lm_buflens
[i
] = lens
[i
];
189 ptr
= (char *)msg
+ lustre_msg_hdr_size_v2(count
);
190 for (i
= 0; i
< count
; i
++) {
193 LOGL(tmp
, lens
[i
], ptr
);
196 EXPORT_SYMBOL(lustre_init_msg_v2
);
198 static int lustre_pack_request_v2(struct ptlrpc_request
*req
,
199 int count
, __u32
*lens
, char **bufs
)
203 reqlen
= lustre_msg_size_v2(count
, lens
);
205 rc
= sptlrpc_cli_alloc_reqbuf(req
, reqlen
);
209 req
->rq_reqlen
= reqlen
;
211 lustre_init_msg_v2(req
->rq_reqmsg
, count
, lens
, bufs
);
212 lustre_msg_add_version(req
->rq_reqmsg
, PTLRPC_MSG_VERSION
);
216 int lustre_pack_request(struct ptlrpc_request
*req
, __u32 magic
, int count
,
217 __u32
*lens
, char **bufs
)
219 __u32 size
[] = { sizeof(struct ptlrpc_body
) };
227 LASSERT(lens
[MSG_PTLRPC_BODY_OFF
] == sizeof(struct ptlrpc_body
));
229 /* only use new format, we don't need to be compatible with 1.4 */
230 return lustre_pack_request_v2(req
, count
, lens
, bufs
);
232 EXPORT_SYMBOL(lustre_pack_request
);
235 LIST_HEAD(ptlrpc_rs_debug_lru
);
236 spinlock_t ptlrpc_rs_debug_lock
;
238 #define PTLRPC_RS_DEBUG_LRU_ADD(rs) \
240 spin_lock(&ptlrpc_rs_debug_lock); \
241 list_add_tail(&(rs)->rs_debug_list, &ptlrpc_rs_debug_lru); \
242 spin_unlock(&ptlrpc_rs_debug_lock); \
245 #define PTLRPC_RS_DEBUG_LRU_DEL(rs) \
247 spin_lock(&ptlrpc_rs_debug_lock); \
248 list_del(&(rs)->rs_debug_list); \
249 spin_unlock(&ptlrpc_rs_debug_lock); \
252 # define PTLRPC_RS_DEBUG_LRU_ADD(rs) do {} while (0)
253 # define PTLRPC_RS_DEBUG_LRU_DEL(rs) do {} while (0)
256 struct ptlrpc_reply_state
*
257 lustre_get_emerg_rs(struct ptlrpc_service_part
*svcpt
)
259 struct ptlrpc_reply_state
*rs
= NULL
;
261 spin_lock(&svcpt
->scp_rep_lock
);
263 /* See if we have anything in a pool, and wait if nothing */
264 while (list_empty(&svcpt
->scp_rep_idle
)) {
265 struct l_wait_info lwi
;
268 spin_unlock(&svcpt
->scp_rep_lock
);
269 /* If we cannot get anything for some long time, we better
270 * bail out instead of waiting infinitely */
271 lwi
= LWI_TIMEOUT(cfs_time_seconds(10), NULL
, NULL
);
272 rc
= l_wait_event(svcpt
->scp_rep_waitq
,
273 !list_empty(&svcpt
->scp_rep_idle
), &lwi
);
276 spin_lock(&svcpt
->scp_rep_lock
);
279 rs
= list_entry(svcpt
->scp_rep_idle
.next
,
280 struct ptlrpc_reply_state
, rs_list
);
281 list_del(&rs
->rs_list
);
283 spin_unlock(&svcpt
->scp_rep_lock
);
285 memset(rs
, 0, svcpt
->scp_service
->srv_max_reply_size
);
286 rs
->rs_size
= svcpt
->scp_service
->srv_max_reply_size
;
287 rs
->rs_svcpt
= svcpt
;
293 void lustre_put_emerg_rs(struct ptlrpc_reply_state
*rs
)
295 struct ptlrpc_service_part
*svcpt
= rs
->rs_svcpt
;
297 spin_lock(&svcpt
->scp_rep_lock
);
298 list_add(&rs
->rs_list
, &svcpt
->scp_rep_idle
);
299 spin_unlock(&svcpt
->scp_rep_lock
);
300 wake_up(&svcpt
->scp_rep_waitq
);
303 int lustre_pack_reply_v2(struct ptlrpc_request
*req
, int count
,
304 __u32
*lens
, char **bufs
, int flags
)
306 struct ptlrpc_reply_state
*rs
;
309 LASSERT(req
->rq_reply_state
== NULL
);
311 if ((flags
& LPRFL_EARLY_REPLY
) == 0) {
312 spin_lock(&req
->rq_lock
);
313 req
->rq_packed_final
= 1;
314 spin_unlock(&req
->rq_lock
);
317 msg_len
= lustre_msg_size_v2(count
, lens
);
318 rc
= sptlrpc_svc_alloc_rs(req
, msg_len
);
322 rs
= req
->rq_reply_state
;
323 atomic_set(&rs
->rs_refcount
, 1); /* 1 ref for rq_reply_state */
324 rs
->rs_cb_id
.cbid_fn
= reply_out_callback
;
325 rs
->rs_cb_id
.cbid_arg
= rs
;
326 rs
->rs_svcpt
= req
->rq_rqbd
->rqbd_svcpt
;
327 INIT_LIST_HEAD(&rs
->rs_exp_list
);
328 INIT_LIST_HEAD(&rs
->rs_obd_list
);
329 INIT_LIST_HEAD(&rs
->rs_list
);
330 spin_lock_init(&rs
->rs_lock
);
332 req
->rq_replen
= msg_len
;
333 req
->rq_reply_state
= rs
;
334 req
->rq_repmsg
= rs
->rs_msg
;
336 lustre_init_msg_v2(rs
->rs_msg
, count
, lens
, bufs
);
337 lustre_msg_add_version(rs
->rs_msg
, PTLRPC_MSG_VERSION
);
339 PTLRPC_RS_DEBUG_LRU_ADD(rs
);
343 EXPORT_SYMBOL(lustre_pack_reply_v2
);
345 int lustre_pack_reply_flags(struct ptlrpc_request
*req
, int count
, __u32
*lens
,
346 char **bufs
, int flags
)
349 __u32 size
[] = { sizeof(struct ptlrpc_body
) };
357 LASSERT(lens
[MSG_PTLRPC_BODY_OFF
] == sizeof(struct ptlrpc_body
));
359 switch (req
->rq_reqmsg
->lm_magic
) {
360 case LUSTRE_MSG_MAGIC_V2
:
361 rc
= lustre_pack_reply_v2(req
, count
, lens
, bufs
, flags
);
364 LASSERTF(0, "incorrect message magic: %08x\n",
365 req
->rq_reqmsg
->lm_magic
);
369 CERROR("lustre_pack_reply failed: rc=%d size=%d\n", rc
,
370 lustre_msg_size(req
->rq_reqmsg
->lm_magic
, count
, lens
));
373 EXPORT_SYMBOL(lustre_pack_reply_flags
);
375 int lustre_pack_reply(struct ptlrpc_request
*req
, int count
, __u32
*lens
,
378 return lustre_pack_reply_flags(req
, count
, lens
, bufs
, 0);
380 EXPORT_SYMBOL(lustre_pack_reply
);
382 void *lustre_msg_buf_v2(struct lustre_msg_v2
*m
, int n
, int min_size
)
384 int i
, offset
, buflen
, bufcount
;
389 bufcount
= m
->lm_bufcount
;
390 if (unlikely(n
>= bufcount
)) {
391 CDEBUG(D_INFO
, "msg %p buffer[%d] not present (count %d)\n",
396 buflen
= m
->lm_buflens
[n
];
397 if (unlikely(buflen
< min_size
)) {
398 CERROR("msg %p buffer[%d] size %d too small (required %d, opc=%d)\n",
399 m
, n
, buflen
, min_size
,
400 n
== MSG_PTLRPC_BODY_OFF
? -1 : lustre_msg_get_opc(m
));
404 offset
= lustre_msg_hdr_size_v2(bufcount
);
405 for (i
= 0; i
< n
; i
++)
406 offset
+= cfs_size_round(m
->lm_buflens
[i
]);
408 return (char *)m
+ offset
;
411 void *lustre_msg_buf(struct lustre_msg
*m
, int n
, int min_size
)
413 switch (m
->lm_magic
) {
414 case LUSTRE_MSG_MAGIC_V2
:
415 return lustre_msg_buf_v2(m
, n
, min_size
);
417 LASSERTF(0, "incorrect message magic: %08x (msg:%p)\n",
422 EXPORT_SYMBOL(lustre_msg_buf
);
424 static int lustre_shrink_msg_v2(struct lustre_msg_v2
*msg
, int segment
,
425 unsigned int newlen
, int move_data
)
427 char *tail
= NULL
, *newpos
;
431 LASSERT(msg
->lm_bufcount
> segment
);
432 LASSERT(msg
->lm_buflens
[segment
] >= newlen
);
434 if (msg
->lm_buflens
[segment
] == newlen
)
437 if (move_data
&& msg
->lm_bufcount
> segment
+ 1) {
438 tail
= lustre_msg_buf_v2(msg
, segment
+ 1, 0);
439 for (n
= segment
+ 1; n
< msg
->lm_bufcount
; n
++)
440 tail_len
+= cfs_size_round(msg
->lm_buflens
[n
]);
443 msg
->lm_buflens
[segment
] = newlen
;
445 if (tail
&& tail_len
) {
446 newpos
= lustre_msg_buf_v2(msg
, segment
+ 1, 0);
447 LASSERT(newpos
<= tail
);
449 memmove(newpos
, tail
, tail_len
);
452 return lustre_msg_size_v2(msg
->lm_bufcount
, msg
->lm_buflens
);
456 * for @msg, shrink @segment to size @newlen. if @move_data is non-zero,
457 * we also move data forward from @segment + 1.
459 * if @newlen == 0, we remove the segment completely, but we still keep the
460 * totally bufcount the same to save possible data moving. this will leave a
461 * unused segment with size 0 at the tail, but that's ok.
463 * return new msg size after shrinking.
466 * + if any buffers higher than @segment has been filled in, must call shrink
467 * with non-zero @move_data.
468 * + caller should NOT keep pointers to msg buffers which higher than @segment
471 int lustre_shrink_msg(struct lustre_msg
*msg
, int segment
,
472 unsigned int newlen
, int move_data
)
474 switch (msg
->lm_magic
) {
475 case LUSTRE_MSG_MAGIC_V2
:
476 return lustre_shrink_msg_v2(msg
, segment
, newlen
, move_data
);
478 LASSERTF(0, "incorrect message magic: %08x\n", msg
->lm_magic
);
481 EXPORT_SYMBOL(lustre_shrink_msg
);
483 void lustre_free_reply_state(struct ptlrpc_reply_state
*rs
)
485 PTLRPC_RS_DEBUG_LRU_DEL(rs
);
487 LASSERT(atomic_read(&rs
->rs_refcount
) == 0);
488 LASSERT(!rs
->rs_difficult
|| rs
->rs_handled
);
489 LASSERT(!rs
->rs_on_net
);
490 LASSERT(!rs
->rs_scheduled
);
491 LASSERT(rs
->rs_export
== NULL
);
492 LASSERT(rs
->rs_nlocks
== 0);
493 LASSERT(list_empty(&rs
->rs_exp_list
));
494 LASSERT(list_empty(&rs
->rs_obd_list
));
496 sptlrpc_svc_free_rs(rs
);
498 EXPORT_SYMBOL(lustre_free_reply_state
);
500 static int lustre_unpack_msg_v2(struct lustre_msg_v2
*m
, int len
)
502 int swabbed
, required_len
, i
;
504 /* Now we know the sender speaks my language. */
505 required_len
= lustre_msg_hdr_size_v2(0);
506 if (len
< required_len
) {
507 /* can't even look inside the message */
508 CERROR("message length %d too small for lustre_msg\n", len
);
512 swabbed
= (m
->lm_magic
== LUSTRE_MSG_MAGIC_V2_SWABBED
);
515 __swab32s(&m
->lm_magic
);
516 __swab32s(&m
->lm_bufcount
);
517 __swab32s(&m
->lm_secflvr
);
518 __swab32s(&m
->lm_repsize
);
519 __swab32s(&m
->lm_cksum
);
520 __swab32s(&m
->lm_flags
);
521 CLASSERT(offsetof(typeof(*m
), lm_padding_2
) != 0);
522 CLASSERT(offsetof(typeof(*m
), lm_padding_3
) != 0);
525 required_len
= lustre_msg_hdr_size_v2(m
->lm_bufcount
);
526 if (len
< required_len
) {
527 /* didn't receive all the buffer lengths */
528 CERROR("message length %d too small for %d buflens\n",
529 len
, m
->lm_bufcount
);
533 for (i
= 0; i
< m
->lm_bufcount
; i
++) {
535 __swab32s(&m
->lm_buflens
[i
]);
536 required_len
+= cfs_size_round(m
->lm_buflens
[i
]);
539 if (len
< required_len
) {
540 CERROR("len: %d, required_len %d\n", len
, required_len
);
541 CERROR("bufcount: %d\n", m
->lm_bufcount
);
542 for (i
= 0; i
< m
->lm_bufcount
; i
++)
543 CERROR("buffer %d length %d\n", i
, m
->lm_buflens
[i
]);
550 int __lustre_unpack_msg(struct lustre_msg
*m
, int len
)
552 int required_len
, rc
;
554 /* We can provide a slightly better error log, if we check the
555 * message magic and version first. In the future, struct
556 * lustre_msg may grow, and we'd like to log a version mismatch,
557 * rather than a short message.
560 required_len
= offsetof(struct lustre_msg
, lm_magic
) +
562 if (len
< required_len
) {
563 /* can't even look inside the message */
564 CERROR("message length %d too small for magic/version check\n",
569 rc
= lustre_unpack_msg_v2(m
, len
);
573 EXPORT_SYMBOL(__lustre_unpack_msg
);
575 int ptlrpc_unpack_req_msg(struct ptlrpc_request
*req
, int len
)
579 rc
= __lustre_unpack_msg(req
->rq_reqmsg
, len
);
581 lustre_set_req_swabbed(req
, MSG_PTLRPC_HEADER_OFF
);
586 EXPORT_SYMBOL(ptlrpc_unpack_req_msg
);
588 int ptlrpc_unpack_rep_msg(struct ptlrpc_request
*req
, int len
)
592 rc
= __lustre_unpack_msg(req
->rq_repmsg
, len
);
594 lustre_set_rep_swabbed(req
, MSG_PTLRPC_HEADER_OFF
);
599 EXPORT_SYMBOL(ptlrpc_unpack_rep_msg
);
601 static inline int lustre_unpack_ptlrpc_body_v2(struct ptlrpc_request
*req
,
602 const int inout
, int offset
)
604 struct ptlrpc_body
*pb
;
605 struct lustre_msg_v2
*m
= inout
? req
->rq_reqmsg
: req
->rq_repmsg
;
607 pb
= lustre_msg_buf_v2(m
, offset
, sizeof(struct ptlrpc_body_v2
));
609 CERROR("error unpacking ptlrpc body\n");
612 if (ptlrpc_buf_need_swab(req
, inout
, offset
)) {
613 lustre_swab_ptlrpc_body(pb
);
614 ptlrpc_buf_set_swabbed(req
, inout
, offset
);
617 if ((pb
->pb_version
& ~LUSTRE_VERSION_MASK
) != PTLRPC_MSG_VERSION
) {
618 CERROR("wrong lustre_msg version %08x\n", pb
->pb_version
);
623 pb
->pb_status
= ptlrpc_status_ntoh(pb
->pb_status
);
628 int lustre_unpack_req_ptlrpc_body(struct ptlrpc_request
*req
, int offset
)
630 switch (req
->rq_reqmsg
->lm_magic
) {
631 case LUSTRE_MSG_MAGIC_V2
:
632 return lustre_unpack_ptlrpc_body_v2(req
, 1, offset
);
634 CERROR("bad lustre msg magic: %08x\n",
635 req
->rq_reqmsg
->lm_magic
);
640 int lustre_unpack_rep_ptlrpc_body(struct ptlrpc_request
*req
, int offset
)
642 switch (req
->rq_repmsg
->lm_magic
) {
643 case LUSTRE_MSG_MAGIC_V2
:
644 return lustre_unpack_ptlrpc_body_v2(req
, 0, offset
);
646 CERROR("bad lustre msg magic: %08x\n",
647 req
->rq_repmsg
->lm_magic
);
652 static inline int lustre_msg_buflen_v2(struct lustre_msg_v2
*m
, int n
)
654 if (n
>= m
->lm_bufcount
)
657 return m
->lm_buflens
[n
];
661 * lustre_msg_buflen - return the length of buffer \a n in message \a m
662 * \param m lustre_msg (request or reply) to look at
663 * \param n message index (base 0)
665 * returns zero for non-existent message indices
667 int lustre_msg_buflen(struct lustre_msg
*m
, int n
)
669 switch (m
->lm_magic
) {
670 case LUSTRE_MSG_MAGIC_V2
:
671 return lustre_msg_buflen_v2(m
, n
);
673 CERROR("incorrect message magic: %08x\n", m
->lm_magic
);
677 EXPORT_SYMBOL(lustre_msg_buflen
);
679 /* NB return the bufcount for lustre_msg_v2 format, so if message is packed
680 * in V1 format, the result is one bigger. (add struct ptlrpc_body). */
681 int lustre_msg_bufcount(struct lustre_msg
*m
)
683 switch (m
->lm_magic
) {
684 case LUSTRE_MSG_MAGIC_V2
:
685 return m
->lm_bufcount
;
687 CERROR("incorrect message magic: %08x\n", m
->lm_magic
);
691 EXPORT_SYMBOL(lustre_msg_bufcount
);
693 char *lustre_msg_string(struct lustre_msg
*m
, int index
, int max_len
)
695 /* max_len == 0 means the string should fill the buffer */
699 switch (m
->lm_magic
) {
700 case LUSTRE_MSG_MAGIC_V2
:
701 str
= lustre_msg_buf_v2(m
, index
, 0);
702 blen
= lustre_msg_buflen_v2(m
, index
);
705 LASSERTF(0, "incorrect message magic: %08x\n", m
->lm_magic
);
709 CERROR("can't unpack string in msg %p buffer[%d]\n", m
, index
);
713 slen
= strnlen(str
, blen
);
715 if (slen
== blen
) { /* not NULL terminated */
716 CERROR("can't unpack non-NULL terminated string in msg %p buffer[%d] len %d\n",
722 if (slen
!= blen
- 1) {
723 CERROR("can't unpack short string in msg %p buffer[%d] len %d: strlen %d\n",
724 m
, index
, blen
, slen
);
727 } else if (slen
> max_len
) {
728 CERROR("can't unpack oversized string in msg %p buffer[%d] len %d strlen %d: max %d expected\n",
729 m
, index
, blen
, slen
, max_len
);
735 EXPORT_SYMBOL(lustre_msg_string
);
737 /* Wrap up the normal fixed length cases */
738 static inline void *__lustre_swab_buf(struct lustre_msg
*msg
, int index
,
739 int min_size
, void *swabber
)
743 LASSERT(msg
!= NULL
);
744 switch (msg
->lm_magic
) {
745 case LUSTRE_MSG_MAGIC_V2
:
746 ptr
= lustre_msg_buf_v2(msg
, index
, min_size
);
749 CERROR("incorrect message magic: %08x\n", msg
->lm_magic
);
753 ((void (*)(void *))swabber
)(ptr
);
758 static inline struct ptlrpc_body
*lustre_msg_ptlrpc_body(struct lustre_msg
*msg
)
760 return lustre_msg_buf_v2(msg
, MSG_PTLRPC_BODY_OFF
,
761 sizeof(struct ptlrpc_body_v2
));
764 __u32
lustre_msghdr_get_flags(struct lustre_msg
*msg
)
766 switch (msg
->lm_magic
) {
767 case LUSTRE_MSG_MAGIC_V2
:
768 /* already in host endian */
769 return msg
->lm_flags
;
771 CERROR("incorrect message magic: %08x\n", msg
->lm_magic
);
775 EXPORT_SYMBOL(lustre_msghdr_get_flags
);
777 void lustre_msghdr_set_flags(struct lustre_msg
*msg
, __u32 flags
)
779 switch (msg
->lm_magic
) {
780 case LUSTRE_MSG_MAGIC_V2
:
781 msg
->lm_flags
= flags
;
784 LASSERTF(0, "incorrect message magic: %08x\n", msg
->lm_magic
);
788 __u32
lustre_msg_get_flags(struct lustre_msg
*msg
)
790 switch (msg
->lm_magic
) {
791 case LUSTRE_MSG_MAGIC_V2
: {
792 struct ptlrpc_body
*pb
= lustre_msg_ptlrpc_body(msg
);
797 CERROR("invalid msg %p: no ptlrpc body!\n", msg
);
801 /* flags might be printed in debug code while message
806 EXPORT_SYMBOL(lustre_msg_get_flags
);
808 void lustre_msg_add_flags(struct lustre_msg
*msg
, int flags
)
810 switch (msg
->lm_magic
) {
811 case LUSTRE_MSG_MAGIC_V2
: {
812 struct ptlrpc_body
*pb
= lustre_msg_ptlrpc_body(msg
);
814 LASSERTF(pb
, "invalid msg %p: no ptlrpc body!\n", msg
);
815 pb
->pb_flags
|= flags
;
819 LASSERTF(0, "incorrect message magic: %08x\n", msg
->lm_magic
);
822 EXPORT_SYMBOL(lustre_msg_add_flags
);
824 void lustre_msg_set_flags(struct lustre_msg
*msg
, int flags
)
826 switch (msg
->lm_magic
) {
827 case LUSTRE_MSG_MAGIC_V2
: {
828 struct ptlrpc_body
*pb
= lustre_msg_ptlrpc_body(msg
);
830 LASSERTF(pb
, "invalid msg %p: no ptlrpc body!\n", msg
);
831 pb
->pb_flags
= flags
;
835 LASSERTF(0, "incorrect message magic: %08x\n", msg
->lm_magic
);
838 EXPORT_SYMBOL(lustre_msg_set_flags
);
840 void lustre_msg_clear_flags(struct lustre_msg
*msg
, int flags
)
842 switch (msg
->lm_magic
) {
843 case LUSTRE_MSG_MAGIC_V2
: {
844 struct ptlrpc_body
*pb
= lustre_msg_ptlrpc_body(msg
);
846 LASSERTF(pb
, "invalid msg %p: no ptlrpc body!\n", msg
);
847 pb
->pb_flags
&= ~(flags
& MSG_GEN_FLAG_MASK
);
851 LASSERTF(0, "incorrect message magic: %08x\n", msg
->lm_magic
);
854 EXPORT_SYMBOL(lustre_msg_clear_flags
);
856 __u32
lustre_msg_get_op_flags(struct lustre_msg
*msg
)
858 switch (msg
->lm_magic
) {
859 case LUSTRE_MSG_MAGIC_V2
: {
860 struct ptlrpc_body
*pb
= lustre_msg_ptlrpc_body(msg
);
863 return pb
->pb_op_flags
;
865 CERROR("invalid msg %p: no ptlrpc body!\n", msg
);
872 EXPORT_SYMBOL(lustre_msg_get_op_flags
);
874 void lustre_msg_add_op_flags(struct lustre_msg
*msg
, int flags
)
876 switch (msg
->lm_magic
) {
877 case LUSTRE_MSG_MAGIC_V2
: {
878 struct ptlrpc_body
*pb
= lustre_msg_ptlrpc_body(msg
);
880 LASSERTF(pb
, "invalid msg %p: no ptlrpc body!\n", msg
);
881 pb
->pb_op_flags
|= flags
;
885 LASSERTF(0, "incorrect message magic: %08x\n", msg
->lm_magic
);
888 EXPORT_SYMBOL(lustre_msg_add_op_flags
);
890 struct lustre_handle
*lustre_msg_get_handle(struct lustre_msg
*msg
)
892 switch (msg
->lm_magic
) {
893 case LUSTRE_MSG_MAGIC_V2
: {
894 struct ptlrpc_body
*pb
= lustre_msg_ptlrpc_body(msg
);
897 CERROR("invalid msg %p: no ptlrpc body!\n", msg
);
900 return &pb
->pb_handle
;
903 CERROR("incorrect message magic: %08x\n", msg
->lm_magic
);
907 EXPORT_SYMBOL(lustre_msg_get_handle
);
909 __u32
lustre_msg_get_type(struct lustre_msg
*msg
)
911 switch (msg
->lm_magic
) {
912 case LUSTRE_MSG_MAGIC_V2
: {
913 struct ptlrpc_body
*pb
= lustre_msg_ptlrpc_body(msg
);
916 CERROR("invalid msg %p: no ptlrpc body!\n", msg
);
917 return PTL_RPC_MSG_ERR
;
922 CERROR("incorrect message magic: %08x\n", msg
->lm_magic
);
923 return PTL_RPC_MSG_ERR
;
926 EXPORT_SYMBOL(lustre_msg_get_type
);
928 void lustre_msg_add_version(struct lustre_msg
*msg
, int version
)
930 switch (msg
->lm_magic
) {
931 case LUSTRE_MSG_MAGIC_V2
: {
932 struct ptlrpc_body
*pb
= lustre_msg_ptlrpc_body(msg
);
934 LASSERTF(pb
, "invalid msg %p: no ptlrpc body!\n", msg
);
935 pb
->pb_version
|= version
;
939 LASSERTF(0, "incorrect message magic: %08x\n", msg
->lm_magic
);
942 EXPORT_SYMBOL(lustre_msg_add_version
);
944 __u32
lustre_msg_get_opc(struct lustre_msg
*msg
)
946 switch (msg
->lm_magic
) {
947 case LUSTRE_MSG_MAGIC_V2
: {
948 struct ptlrpc_body
*pb
= lustre_msg_ptlrpc_body(msg
);
951 CERROR("invalid msg %p: no ptlrpc body!\n", msg
);
957 CERROR("incorrect message magic: %08x (msg:%p)\n",
962 EXPORT_SYMBOL(lustre_msg_get_opc
);
964 __u64
lustre_msg_get_last_committed(struct lustre_msg
*msg
)
966 switch (msg
->lm_magic
) {
967 case LUSTRE_MSG_MAGIC_V2
: {
968 struct ptlrpc_body
*pb
= lustre_msg_ptlrpc_body(msg
);
971 CERROR("invalid msg %p: no ptlrpc body!\n", msg
);
974 return pb
->pb_last_committed
;
977 CERROR("incorrect message magic: %08x\n", msg
->lm_magic
);
981 EXPORT_SYMBOL(lustre_msg_get_last_committed
);
983 __u64
*lustre_msg_get_versions(struct lustre_msg
*msg
)
985 switch (msg
->lm_magic
) {
986 case LUSTRE_MSG_MAGIC_V2
: {
987 struct ptlrpc_body
*pb
= lustre_msg_ptlrpc_body(msg
);
990 CERROR("invalid msg %p: no ptlrpc body!\n", msg
);
993 return pb
->pb_pre_versions
;
996 CERROR("incorrect message magic: %08x\n", msg
->lm_magic
);
1000 EXPORT_SYMBOL(lustre_msg_get_versions
);
1002 __u64
lustre_msg_get_transno(struct lustre_msg
*msg
)
1004 switch (msg
->lm_magic
) {
1005 case LUSTRE_MSG_MAGIC_V2
: {
1006 struct ptlrpc_body
*pb
= lustre_msg_ptlrpc_body(msg
);
1009 CERROR("invalid msg %p: no ptlrpc body!\n", msg
);
1012 return pb
->pb_transno
;
1015 CERROR("incorrect message magic: %08x\n", msg
->lm_magic
);
1019 EXPORT_SYMBOL(lustre_msg_get_transno
);
1021 int lustre_msg_get_status(struct lustre_msg
*msg
)
1023 switch (msg
->lm_magic
) {
1024 case LUSTRE_MSG_MAGIC_V2
: {
1025 struct ptlrpc_body
*pb
= lustre_msg_ptlrpc_body(msg
);
1028 return pb
->pb_status
;
1030 CERROR("invalid msg %p: no ptlrpc body!\n", msg
);
1034 /* status might be printed in debug code while message
1039 EXPORT_SYMBOL(lustre_msg_get_status
);
1041 __u64
lustre_msg_get_slv(struct lustre_msg
*msg
)
1043 switch (msg
->lm_magic
) {
1044 case LUSTRE_MSG_MAGIC_V2
: {
1045 struct ptlrpc_body
*pb
= lustre_msg_ptlrpc_body(msg
);
1048 CERROR("invalid msg %p: no ptlrpc body!\n", msg
);
1054 CERROR("invalid msg magic %08x\n", msg
->lm_magic
);
1058 EXPORT_SYMBOL(lustre_msg_get_slv
);
1060 void lustre_msg_set_slv(struct lustre_msg
*msg
, __u64 slv
)
1062 switch (msg
->lm_magic
) {
1063 case LUSTRE_MSG_MAGIC_V2
: {
1064 struct ptlrpc_body
*pb
= lustre_msg_ptlrpc_body(msg
);
1067 CERROR("invalid msg %p: no ptlrpc body!\n", msg
);
1074 CERROR("invalid msg magic %x\n", msg
->lm_magic
);
1078 EXPORT_SYMBOL(lustre_msg_set_slv
);
1080 __u32
lustre_msg_get_limit(struct lustre_msg
*msg
)
1082 switch (msg
->lm_magic
) {
1083 case LUSTRE_MSG_MAGIC_V2
: {
1084 struct ptlrpc_body
*pb
= lustre_msg_ptlrpc_body(msg
);
1087 CERROR("invalid msg %p: no ptlrpc body!\n", msg
);
1090 return pb
->pb_limit
;
1093 CERROR("invalid msg magic %x\n", msg
->lm_magic
);
1097 EXPORT_SYMBOL(lustre_msg_get_limit
);
1099 void lustre_msg_set_limit(struct lustre_msg
*msg
, __u64 limit
)
1101 switch (msg
->lm_magic
) {
1102 case LUSTRE_MSG_MAGIC_V2
: {
1103 struct ptlrpc_body
*pb
= lustre_msg_ptlrpc_body(msg
);
1106 CERROR("invalid msg %p: no ptlrpc body!\n", msg
);
1109 pb
->pb_limit
= limit
;
1113 CERROR("invalid msg magic %08x\n", msg
->lm_magic
);
1117 EXPORT_SYMBOL(lustre_msg_set_limit
);
1119 __u32
lustre_msg_get_conn_cnt(struct lustre_msg
*msg
)
1121 switch (msg
->lm_magic
) {
1122 case LUSTRE_MSG_MAGIC_V2
: {
1123 struct ptlrpc_body
*pb
= lustre_msg_ptlrpc_body(msg
);
1126 CERROR("invalid msg %p: no ptlrpc body!\n", msg
);
1129 return pb
->pb_conn_cnt
;
1132 CERROR("incorrect message magic: %08x\n", msg
->lm_magic
);
1136 EXPORT_SYMBOL(lustre_msg_get_conn_cnt
);
1138 __u32
lustre_msg_get_magic(struct lustre_msg
*msg
)
1140 switch (msg
->lm_magic
) {
1141 case LUSTRE_MSG_MAGIC_V2
:
1142 return msg
->lm_magic
;
1144 CERROR("incorrect message magic: %08x\n", msg
->lm_magic
);
1148 EXPORT_SYMBOL(lustre_msg_get_magic
);
1150 __u32
lustre_msg_get_timeout(struct lustre_msg
*msg
)
1152 switch (msg
->lm_magic
) {
1153 case LUSTRE_MSG_MAGIC_V2
: {
1154 struct ptlrpc_body
*pb
= lustre_msg_ptlrpc_body(msg
);
1157 CERROR("invalid msg %p: no ptlrpc body!\n", msg
);
1161 return pb
->pb_timeout
;
1164 CERROR("incorrect message magic: %08x\n", msg
->lm_magic
);
1169 __u32
lustre_msg_get_service_time(struct lustre_msg
*msg
)
1171 switch (msg
->lm_magic
) {
1172 case LUSTRE_MSG_MAGIC_V2
: {
1173 struct ptlrpc_body
*pb
= lustre_msg_ptlrpc_body(msg
);
1176 CERROR("invalid msg %p: no ptlrpc body!\n", msg
);
1180 return pb
->pb_service_time
;
1183 CERROR("incorrect message magic: %08x\n", msg
->lm_magic
);
1188 __u32
lustre_msg_get_cksum(struct lustre_msg
*msg
)
1190 switch (msg
->lm_magic
) {
1191 case LUSTRE_MSG_MAGIC_V2
:
1192 return msg
->lm_cksum
;
1194 CERROR("incorrect message magic: %08x\n", msg
->lm_magic
);
1199 __u32
lustre_msg_calc_cksum(struct lustre_msg
*msg
)
1201 switch (msg
->lm_magic
) {
1202 case LUSTRE_MSG_MAGIC_V2
: {
1203 struct ptlrpc_body
*pb
= lustre_msg_ptlrpc_body(msg
);
1205 unsigned int hsize
= 4;
1207 cfs_crypto_hash_digest(CFS_HASH_ALG_CRC32
, (unsigned char *)pb
,
1208 lustre_msg_buflen(msg
, MSG_PTLRPC_BODY_OFF
),
1209 NULL
, 0, (unsigned char *)&crc
, &hsize
);
1213 CERROR("incorrect message magic: %08x\n", msg
->lm_magic
);
1218 void lustre_msg_set_handle(struct lustre_msg
*msg
, struct lustre_handle
*handle
)
1220 switch (msg
->lm_magic
) {
1221 case LUSTRE_MSG_MAGIC_V2
: {
1222 struct ptlrpc_body
*pb
= lustre_msg_ptlrpc_body(msg
);
1224 LASSERTF(pb
, "invalid msg %p: no ptlrpc body!\n", msg
);
1225 pb
->pb_handle
= *handle
;
1229 LASSERTF(0, "incorrect message magic: %08x\n", msg
->lm_magic
);
1232 EXPORT_SYMBOL(lustre_msg_set_handle
);
1234 void lustre_msg_set_type(struct lustre_msg
*msg
, __u32 type
)
1236 switch (msg
->lm_magic
) {
1237 case LUSTRE_MSG_MAGIC_V2
: {
1238 struct ptlrpc_body
*pb
= lustre_msg_ptlrpc_body(msg
);
1240 LASSERTF(pb
, "invalid msg %p: no ptlrpc body!\n", msg
);
1245 LASSERTF(0, "incorrect message magic: %08x\n", msg
->lm_magic
);
1248 EXPORT_SYMBOL(lustre_msg_set_type
);
1250 void lustre_msg_set_opc(struct lustre_msg
*msg
, __u32 opc
)
1252 switch (msg
->lm_magic
) {
1253 case LUSTRE_MSG_MAGIC_V2
: {
1254 struct ptlrpc_body
*pb
= lustre_msg_ptlrpc_body(msg
);
1256 LASSERTF(pb
, "invalid msg %p: no ptlrpc body!\n", msg
);
1261 LASSERTF(0, "incorrect message magic: %08x\n", msg
->lm_magic
);
1264 EXPORT_SYMBOL(lustre_msg_set_opc
);
1266 void lustre_msg_set_versions(struct lustre_msg
*msg
, __u64
*versions
)
1268 switch (msg
->lm_magic
) {
1269 case LUSTRE_MSG_MAGIC_V2
: {
1270 struct ptlrpc_body
*pb
= lustre_msg_ptlrpc_body(msg
);
1272 LASSERTF(pb
, "invalid msg %p: no ptlrpc body!\n", msg
);
1273 pb
->pb_pre_versions
[0] = versions
[0];
1274 pb
->pb_pre_versions
[1] = versions
[1];
1275 pb
->pb_pre_versions
[2] = versions
[2];
1276 pb
->pb_pre_versions
[3] = versions
[3];
1280 LASSERTF(0, "incorrect message magic: %08x\n", msg
->lm_magic
);
1283 EXPORT_SYMBOL(lustre_msg_set_versions
);
1285 void lustre_msg_set_transno(struct lustre_msg
*msg
, __u64 transno
)
1287 switch (msg
->lm_magic
) {
1288 case LUSTRE_MSG_MAGIC_V2
: {
1289 struct ptlrpc_body
*pb
= lustre_msg_ptlrpc_body(msg
);
1291 LASSERTF(pb
, "invalid msg %p: no ptlrpc body!\n", msg
);
1292 pb
->pb_transno
= transno
;
1296 LASSERTF(0, "incorrect message magic: %08x\n", msg
->lm_magic
);
1299 EXPORT_SYMBOL(lustre_msg_set_transno
);
1301 void lustre_msg_set_status(struct lustre_msg
*msg
, __u32 status
)
1303 switch (msg
->lm_magic
) {
1304 case LUSTRE_MSG_MAGIC_V2
: {
1305 struct ptlrpc_body
*pb
= lustre_msg_ptlrpc_body(msg
);
1307 LASSERTF(pb
, "invalid msg %p: no ptlrpc body!\n", msg
);
1308 pb
->pb_status
= status
;
1312 LASSERTF(0, "incorrect message magic: %08x\n", msg
->lm_magic
);
1315 EXPORT_SYMBOL(lustre_msg_set_status
);
1317 void lustre_msg_set_conn_cnt(struct lustre_msg
*msg
, __u32 conn_cnt
)
1319 switch (msg
->lm_magic
) {
1320 case LUSTRE_MSG_MAGIC_V2
: {
1321 struct ptlrpc_body
*pb
= lustre_msg_ptlrpc_body(msg
);
1323 LASSERTF(pb
, "invalid msg %p: no ptlrpc body!\n", msg
);
1324 pb
->pb_conn_cnt
= conn_cnt
;
1328 LASSERTF(0, "incorrect message magic: %08x\n", msg
->lm_magic
);
1331 EXPORT_SYMBOL(lustre_msg_set_conn_cnt
);
1333 void lustre_msg_set_timeout(struct lustre_msg
*msg
, __u32 timeout
)
1335 switch (msg
->lm_magic
) {
1336 case LUSTRE_MSG_MAGIC_V2
: {
1337 struct ptlrpc_body
*pb
= lustre_msg_ptlrpc_body(msg
);
1339 LASSERTF(pb
, "invalid msg %p: no ptlrpc body!\n", msg
);
1340 pb
->pb_timeout
= timeout
;
1344 LASSERTF(0, "incorrect message magic: %08x\n", msg
->lm_magic
);
1348 void lustre_msg_set_service_time(struct lustre_msg
*msg
, __u32 service_time
)
1350 switch (msg
->lm_magic
) {
1351 case LUSTRE_MSG_MAGIC_V2
: {
1352 struct ptlrpc_body
*pb
= lustre_msg_ptlrpc_body(msg
);
1354 LASSERTF(pb
, "invalid msg %p: no ptlrpc body!\n", msg
);
1355 pb
->pb_service_time
= service_time
;
1359 LASSERTF(0, "incorrect message magic: %08x\n", msg
->lm_magic
);
1363 void lustre_msg_set_jobid(struct lustre_msg
*msg
, char *jobid
)
1365 switch (msg
->lm_magic
) {
1366 case LUSTRE_MSG_MAGIC_V2
: {
1367 __u32 opc
= lustre_msg_get_opc(msg
);
1368 struct ptlrpc_body
*pb
;
1370 /* Don't set jobid for ldlm ast RPCs, they've been shrunk.
1371 * See the comment in ptlrpc_request_pack(). */
1372 if (!opc
|| opc
== LDLM_BL_CALLBACK
||
1373 opc
== LDLM_CP_CALLBACK
|| opc
== LDLM_GL_CALLBACK
)
1376 pb
= lustre_msg_buf_v2(msg
, MSG_PTLRPC_BODY_OFF
,
1377 sizeof(struct ptlrpc_body
));
1378 LASSERTF(pb
, "invalid msg %p: no ptlrpc body!\n", msg
);
1381 memcpy(pb
->pb_jobid
, jobid
, JOBSTATS_JOBID_SIZE
);
1382 else if (pb
->pb_jobid
[0] == '\0')
1383 lustre_get_jobid(pb
->pb_jobid
);
1387 LASSERTF(0, "incorrect message magic: %08x\n", msg
->lm_magic
);
1390 EXPORT_SYMBOL(lustre_msg_set_jobid
);
1392 void lustre_msg_set_cksum(struct lustre_msg
*msg
, __u32 cksum
)
1394 switch (msg
->lm_magic
) {
1395 case LUSTRE_MSG_MAGIC_V2
:
1396 msg
->lm_cksum
= cksum
;
1399 LASSERTF(0, "incorrect message magic: %08x\n", msg
->lm_magic
);
1403 void ptlrpc_request_set_replen(struct ptlrpc_request
*req
)
1405 int count
= req_capsule_filled_sizes(&req
->rq_pill
, RCL_SERVER
);
1407 req
->rq_replen
= lustre_msg_size(req
->rq_reqmsg
->lm_magic
, count
,
1408 req
->rq_pill
.rc_area
[RCL_SERVER
]);
1409 if (req
->rq_reqmsg
->lm_magic
== LUSTRE_MSG_MAGIC_V2
)
1410 req
->rq_reqmsg
->lm_repsize
= req
->rq_replen
;
1412 EXPORT_SYMBOL(ptlrpc_request_set_replen
);
1415 * Send a remote set_info_async.
1417 * This may go from client to server or server to client.
1419 int do_set_info_async(struct obd_import
*imp
,
1420 int opcode
, int version
,
1421 u32 keylen
, void *key
,
1422 u32 vallen
, void *val
,
1423 struct ptlrpc_request_set
*set
)
1425 struct ptlrpc_request
*req
;
1429 req
= ptlrpc_request_alloc(imp
, &RQF_OBD_SET_INFO
);
1433 req_capsule_set_size(&req
->rq_pill
, &RMF_SETINFO_KEY
,
1434 RCL_CLIENT
, keylen
);
1435 req_capsule_set_size(&req
->rq_pill
, &RMF_SETINFO_VAL
,
1436 RCL_CLIENT
, vallen
);
1437 rc
= ptlrpc_request_pack(req
, version
, opcode
);
1439 ptlrpc_request_free(req
);
1443 tmp
= req_capsule_client_get(&req
->rq_pill
, &RMF_SETINFO_KEY
);
1444 memcpy(tmp
, key
, keylen
);
1445 tmp
= req_capsule_client_get(&req
->rq_pill
, &RMF_SETINFO_VAL
);
1446 memcpy(tmp
, val
, vallen
);
1448 ptlrpc_request_set_replen(req
);
1451 ptlrpc_set_add_req(set
, req
);
1452 ptlrpc_check_set(NULL
, set
);
1454 rc
= ptlrpc_queue_wait(req
);
1455 ptlrpc_req_finished(req
);
1460 EXPORT_SYMBOL(do_set_info_async
);
1462 /* byte flipping routines for all wire types declared in
1463 * lustre_idl.h implemented here.
1465 void lustre_swab_ptlrpc_body(struct ptlrpc_body
*b
)
1467 __swab32s(&b
->pb_type
);
1468 __swab32s(&b
->pb_version
);
1469 __swab32s(&b
->pb_opc
);
1470 __swab32s(&b
->pb_status
);
1471 __swab64s(&b
->pb_last_xid
);
1472 __swab64s(&b
->pb_last_seen
);
1473 __swab64s(&b
->pb_last_committed
);
1474 __swab64s(&b
->pb_transno
);
1475 __swab32s(&b
->pb_flags
);
1476 __swab32s(&b
->pb_op_flags
);
1477 __swab32s(&b
->pb_conn_cnt
);
1478 __swab32s(&b
->pb_timeout
);
1479 __swab32s(&b
->pb_service_time
);
1480 __swab32s(&b
->pb_limit
);
1481 __swab64s(&b
->pb_slv
);
1482 __swab64s(&b
->pb_pre_versions
[0]);
1483 __swab64s(&b
->pb_pre_versions
[1]);
1484 __swab64s(&b
->pb_pre_versions
[2]);
1485 __swab64s(&b
->pb_pre_versions
[3]);
1486 CLASSERT(offsetof(typeof(*b
), pb_padding
) != 0);
1487 /* While we need to maintain compatibility between
1488 * clients and servers without ptlrpc_body_v2 (< 2.3)
1489 * do not swab any fields beyond pb_jobid, as we are
1490 * using this swab function for both ptlrpc_body
1491 * and ptlrpc_body_v2. */
1492 CLASSERT(offsetof(typeof(*b
), pb_jobid
) != 0);
1494 EXPORT_SYMBOL(lustre_swab_ptlrpc_body
);
1496 void lustre_swab_connect(struct obd_connect_data
*ocd
)
1498 __swab64s(&ocd
->ocd_connect_flags
);
1499 __swab32s(&ocd
->ocd_version
);
1500 __swab32s(&ocd
->ocd_grant
);
1501 __swab64s(&ocd
->ocd_ibits_known
);
1502 __swab32s(&ocd
->ocd_index
);
1503 __swab32s(&ocd
->ocd_brw_size
);
1504 /* ocd_blocksize and ocd_inodespace don't need to be swabbed because
1505 * they are 8-byte values */
1506 __swab16s(&ocd
->ocd_grant_extent
);
1507 __swab32s(&ocd
->ocd_unused
);
1508 __swab64s(&ocd
->ocd_transno
);
1509 __swab32s(&ocd
->ocd_group
);
1510 __swab32s(&ocd
->ocd_cksum_types
);
1511 __swab32s(&ocd
->ocd_instance
);
1512 /* Fields after ocd_cksum_types are only accessible by the receiver
1513 * if the corresponding flag in ocd_connect_flags is set. Accessing
1514 * any field after ocd_maxbytes on the receiver without a valid flag
1515 * may result in out-of-bound memory access and kernel oops. */
1516 if (ocd
->ocd_connect_flags
& OBD_CONNECT_MAX_EASIZE
)
1517 __swab32s(&ocd
->ocd_max_easize
);
1518 if (ocd
->ocd_connect_flags
& OBD_CONNECT_MAXBYTES
)
1519 __swab64s(&ocd
->ocd_maxbytes
);
1520 CLASSERT(offsetof(typeof(*ocd
), padding1
) != 0);
1521 CLASSERT(offsetof(typeof(*ocd
), padding2
) != 0);
1522 CLASSERT(offsetof(typeof(*ocd
), padding3
) != 0);
1523 CLASSERT(offsetof(typeof(*ocd
), padding4
) != 0);
1524 CLASSERT(offsetof(typeof(*ocd
), padding5
) != 0);
1525 CLASSERT(offsetof(typeof(*ocd
), padding6
) != 0);
1526 CLASSERT(offsetof(typeof(*ocd
), padding7
) != 0);
1527 CLASSERT(offsetof(typeof(*ocd
), padding8
) != 0);
1528 CLASSERT(offsetof(typeof(*ocd
), padding9
) != 0);
1529 CLASSERT(offsetof(typeof(*ocd
), paddingA
) != 0);
1530 CLASSERT(offsetof(typeof(*ocd
), paddingB
) != 0);
1531 CLASSERT(offsetof(typeof(*ocd
), paddingC
) != 0);
1532 CLASSERT(offsetof(typeof(*ocd
), paddingD
) != 0);
1533 CLASSERT(offsetof(typeof(*ocd
), paddingE
) != 0);
1534 CLASSERT(offsetof(typeof(*ocd
), paddingF
) != 0);
1537 static void lustre_swab_obdo(struct obdo
*o
)
1539 __swab64s(&o
->o_valid
);
1540 lustre_swab_ost_id(&o
->o_oi
);
1541 __swab64s(&o
->o_parent_seq
);
1542 __swab64s(&o
->o_size
);
1543 __swab64s(&o
->o_mtime
);
1544 __swab64s(&o
->o_atime
);
1545 __swab64s(&o
->o_ctime
);
1546 __swab64s(&o
->o_blocks
);
1547 __swab64s(&o
->o_grant
);
1548 __swab32s(&o
->o_blksize
);
1549 __swab32s(&o
->o_mode
);
1550 __swab32s(&o
->o_uid
);
1551 __swab32s(&o
->o_gid
);
1552 __swab32s(&o
->o_flags
);
1553 __swab32s(&o
->o_nlink
);
1554 __swab32s(&o
->o_parent_oid
);
1555 __swab32s(&o
->o_misc
);
1556 __swab64s(&o
->o_ioepoch
);
1557 __swab32s(&o
->o_stripe_idx
);
1558 __swab32s(&o
->o_parent_ver
);
1559 /* o_handle is opaque */
1560 /* o_lcookie is swabbed elsewhere */
1561 __swab32s(&o
->o_uid_h
);
1562 __swab32s(&o
->o_gid_h
);
1563 __swab64s(&o
->o_data_version
);
1564 CLASSERT(offsetof(typeof(*o
), o_padding_4
) != 0);
1565 CLASSERT(offsetof(typeof(*o
), o_padding_5
) != 0);
1566 CLASSERT(offsetof(typeof(*o
), o_padding_6
) != 0);
1570 void lustre_swab_obd_statfs(struct obd_statfs
*os
)
1572 __swab64s(&os
->os_type
);
1573 __swab64s(&os
->os_blocks
);
1574 __swab64s(&os
->os_bfree
);
1575 __swab64s(&os
->os_bavail
);
1576 __swab64s(&os
->os_files
);
1577 __swab64s(&os
->os_ffree
);
1578 /* no need to swab os_fsid */
1579 __swab32s(&os
->os_bsize
);
1580 __swab32s(&os
->os_namelen
);
1581 __swab64s(&os
->os_maxbytes
);
1582 __swab32s(&os
->os_state
);
1583 CLASSERT(offsetof(typeof(*os
), os_fprecreated
) != 0);
1584 CLASSERT(offsetof(typeof(*os
), os_spare2
) != 0);
1585 CLASSERT(offsetof(typeof(*os
), os_spare3
) != 0);
1586 CLASSERT(offsetof(typeof(*os
), os_spare4
) != 0);
1587 CLASSERT(offsetof(typeof(*os
), os_spare5
) != 0);
1588 CLASSERT(offsetof(typeof(*os
), os_spare6
) != 0);
1589 CLASSERT(offsetof(typeof(*os
), os_spare7
) != 0);
1590 CLASSERT(offsetof(typeof(*os
), os_spare8
) != 0);
1591 CLASSERT(offsetof(typeof(*os
), os_spare9
) != 0);
1593 EXPORT_SYMBOL(lustre_swab_obd_statfs
);
1595 void lustre_swab_obd_ioobj(struct obd_ioobj
*ioo
)
1597 lustre_swab_ost_id(&ioo
->ioo_oid
);
1598 __swab32s(&ioo
->ioo_max_brw
);
1599 __swab32s(&ioo
->ioo_bufcnt
);
1601 EXPORT_SYMBOL(lustre_swab_obd_ioobj
);
1603 void lustre_swab_niobuf_remote(struct niobuf_remote
*nbr
)
1605 __swab64s(&nbr
->offset
);
1606 __swab32s(&nbr
->len
);
1607 __swab32s(&nbr
->flags
);
1609 EXPORT_SYMBOL(lustre_swab_niobuf_remote
);
1611 void lustre_swab_ost_body(struct ost_body
*b
)
1613 lustre_swab_obdo(&b
->oa
);
1615 EXPORT_SYMBOL(lustre_swab_ost_body
);
1617 void lustre_swab_ost_last_id(u64
*id
)
1621 EXPORT_SYMBOL(lustre_swab_ost_last_id
);
1623 void lustre_swab_generic_32s(__u32
*val
)
1627 EXPORT_SYMBOL(lustre_swab_generic_32s
);
1629 void lustre_swab_gl_desc(union ldlm_gl_desc
*desc
)
1631 lustre_swab_lu_fid(&desc
->lquota_desc
.gl_id
.qid_fid
);
1632 __swab64s(&desc
->lquota_desc
.gl_flags
);
1633 __swab64s(&desc
->lquota_desc
.gl_ver
);
1634 __swab64s(&desc
->lquota_desc
.gl_hardlimit
);
1635 __swab64s(&desc
->lquota_desc
.gl_softlimit
);
1636 __swab64s(&desc
->lquota_desc
.gl_time
);
1637 CLASSERT(offsetof(typeof(desc
->lquota_desc
), gl_pad2
) != 0);
1640 void lustre_swab_ost_lvb_v1(struct ost_lvb_v1
*lvb
)
1642 __swab64s(&lvb
->lvb_size
);
1643 __swab64s(&lvb
->lvb_mtime
);
1644 __swab64s(&lvb
->lvb_atime
);
1645 __swab64s(&lvb
->lvb_ctime
);
1646 __swab64s(&lvb
->lvb_blocks
);
1648 EXPORT_SYMBOL(lustre_swab_ost_lvb_v1
);
1650 void lustre_swab_ost_lvb(struct ost_lvb
*lvb
)
1652 __swab64s(&lvb
->lvb_size
);
1653 __swab64s(&lvb
->lvb_mtime
);
1654 __swab64s(&lvb
->lvb_atime
);
1655 __swab64s(&lvb
->lvb_ctime
);
1656 __swab64s(&lvb
->lvb_blocks
);
1657 __swab32s(&lvb
->lvb_mtime_ns
);
1658 __swab32s(&lvb
->lvb_atime_ns
);
1659 __swab32s(&lvb
->lvb_ctime_ns
);
1660 __swab32s(&lvb
->lvb_padding
);
1662 EXPORT_SYMBOL(lustre_swab_ost_lvb
);
1664 void lustre_swab_lquota_lvb(struct lquota_lvb
*lvb
)
1666 __swab64s(&lvb
->lvb_flags
);
1667 __swab64s(&lvb
->lvb_id_may_rel
);
1668 __swab64s(&lvb
->lvb_id_rel
);
1669 __swab64s(&lvb
->lvb_id_qunit
);
1670 __swab64s(&lvb
->lvb_pad1
);
1672 EXPORT_SYMBOL(lustre_swab_lquota_lvb
);
1674 void lustre_swab_mdt_body(struct mdt_body
*b
)
1676 lustre_swab_lu_fid(&b
->fid1
);
1677 lustre_swab_lu_fid(&b
->fid2
);
1678 /* handle is opaque */
1679 __swab64s(&b
->valid
);
1680 __swab64s(&b
->size
);
1681 __swab64s(&b
->mtime
);
1682 __swab64s(&b
->atime
);
1683 __swab64s(&b
->ctime
);
1684 __swab64s(&b
->blocks
);
1685 __swab64s(&b
->ioepoch
);
1686 __swab64s(&b
->t_state
);
1687 __swab32s(&b
->fsuid
);
1688 __swab32s(&b
->fsgid
);
1689 __swab32s(&b
->capability
);
1690 __swab32s(&b
->mode
);
1693 __swab32s(&b
->flags
);
1694 __swab32s(&b
->rdev
);
1695 __swab32s(&b
->nlink
);
1696 CLASSERT(offsetof(typeof(*b
), unused2
) != 0);
1697 __swab32s(&b
->suppgid
);
1698 __swab32s(&b
->eadatasize
);
1699 __swab32s(&b
->aclsize
);
1700 __swab32s(&b
->max_mdsize
);
1701 __swab32s(&b
->max_cookiesize
);
1702 __swab32s(&b
->uid_h
);
1703 __swab32s(&b
->gid_h
);
1704 CLASSERT(offsetof(typeof(*b
), padding_5
) != 0);
1706 EXPORT_SYMBOL(lustre_swab_mdt_body
);
1708 void lustre_swab_mdt_ioepoch(struct mdt_ioepoch
*b
)
1710 /* handle is opaque */
1711 __swab64s(&b
->ioepoch
);
1712 __swab32s(&b
->flags
);
1713 CLASSERT(offsetof(typeof(*b
), padding
) != 0);
1715 EXPORT_SYMBOL(lustre_swab_mdt_ioepoch
);
1717 void lustre_swab_mgs_target_info(struct mgs_target_info
*mti
)
1721 __swab32s(&mti
->mti_lustre_ver
);
1722 __swab32s(&mti
->mti_stripe_index
);
1723 __swab32s(&mti
->mti_config_ver
);
1724 __swab32s(&mti
->mti_flags
);
1725 __swab32s(&mti
->mti_instance
);
1726 __swab32s(&mti
->mti_nid_count
);
1727 CLASSERT(sizeof(lnet_nid_t
) == sizeof(__u64
));
1728 for (i
= 0; i
< MTI_NIDS_MAX
; i
++)
1729 __swab64s(&mti
->mti_nids
[i
]);
1731 EXPORT_SYMBOL(lustre_swab_mgs_target_info
);
1733 void lustre_swab_mgs_nidtbl_entry(struct mgs_nidtbl_entry
*entry
)
1737 __swab64s(&entry
->mne_version
);
1738 __swab32s(&entry
->mne_instance
);
1739 __swab32s(&entry
->mne_index
);
1740 __swab32s(&entry
->mne_length
);
1742 /* mne_nid_(count|type) must be one byte size because we're gonna
1743 * access it w/o swapping. */
1744 CLASSERT(sizeof(entry
->mne_nid_count
) == sizeof(__u8
));
1745 CLASSERT(sizeof(entry
->mne_nid_type
) == sizeof(__u8
));
1747 /* remove this assertion if ipv6 is supported. */
1748 LASSERT(entry
->mne_nid_type
== 0);
1749 for (i
= 0; i
< entry
->mne_nid_count
; i
++) {
1750 CLASSERT(sizeof(lnet_nid_t
) == sizeof(__u64
));
1751 __swab64s(&entry
->u
.nids
[i
]);
1754 EXPORT_SYMBOL(lustre_swab_mgs_nidtbl_entry
);
1756 void lustre_swab_mgs_config_body(struct mgs_config_body
*body
)
1758 __swab64s(&body
->mcb_offset
);
1759 __swab32s(&body
->mcb_units
);
1760 __swab16s(&body
->mcb_type
);
1762 EXPORT_SYMBOL(lustre_swab_mgs_config_body
);
1764 void lustre_swab_mgs_config_res(struct mgs_config_res
*body
)
1766 __swab64s(&body
->mcr_offset
);
1767 __swab64s(&body
->mcr_size
);
1769 EXPORT_SYMBOL(lustre_swab_mgs_config_res
);
1771 static void lustre_swab_obd_dqinfo(struct obd_dqinfo
*i
)
1773 __swab64s(&i
->dqi_bgrace
);
1774 __swab64s(&i
->dqi_igrace
);
1775 __swab32s(&i
->dqi_flags
);
1776 __swab32s(&i
->dqi_valid
);
1779 static void lustre_swab_obd_dqblk(struct obd_dqblk
*b
)
1781 __swab64s(&b
->dqb_ihardlimit
);
1782 __swab64s(&b
->dqb_isoftlimit
);
1783 __swab64s(&b
->dqb_curinodes
);
1784 __swab64s(&b
->dqb_bhardlimit
);
1785 __swab64s(&b
->dqb_bsoftlimit
);
1786 __swab64s(&b
->dqb_curspace
);
1787 __swab64s(&b
->dqb_btime
);
1788 __swab64s(&b
->dqb_itime
);
1789 __swab32s(&b
->dqb_valid
);
1790 CLASSERT(offsetof(typeof(*b
), dqb_padding
) != 0);
1793 void lustre_swab_obd_quotactl(struct obd_quotactl
*q
)
1795 __swab32s(&q
->qc_cmd
);
1796 __swab32s(&q
->qc_type
);
1797 __swab32s(&q
->qc_id
);
1798 __swab32s(&q
->qc_stat
);
1799 lustre_swab_obd_dqinfo(&q
->qc_dqinfo
);
1800 lustre_swab_obd_dqblk(&q
->qc_dqblk
);
1802 EXPORT_SYMBOL(lustre_swab_obd_quotactl
);
1804 void lustre_swab_mdt_remote_perm(struct mdt_remote_perm
*p
)
1806 __swab32s(&p
->rp_uid
);
1807 __swab32s(&p
->rp_gid
);
1808 __swab32s(&p
->rp_fsuid
);
1809 __swab32s(&p
->rp_fsuid_h
);
1810 __swab32s(&p
->rp_fsgid
);
1811 __swab32s(&p
->rp_fsgid_h
);
1812 __swab32s(&p
->rp_access_perm
);
1813 __swab32s(&p
->rp_padding
);
1815 EXPORT_SYMBOL(lustre_swab_mdt_remote_perm
);
1817 void lustre_swab_fid2path(struct getinfo_fid2path
*gf
)
1819 lustre_swab_lu_fid(&gf
->gf_fid
);
1820 __swab64s(&gf
->gf_recno
);
1821 __swab32s(&gf
->gf_linkno
);
1822 __swab32s(&gf
->gf_pathlen
);
1824 EXPORT_SYMBOL(lustre_swab_fid2path
);
1826 static void lustre_swab_fiemap_extent(struct ll_fiemap_extent
*fm_extent
)
1828 __swab64s(&fm_extent
->fe_logical
);
1829 __swab64s(&fm_extent
->fe_physical
);
1830 __swab64s(&fm_extent
->fe_length
);
1831 __swab32s(&fm_extent
->fe_flags
);
1832 __swab32s(&fm_extent
->fe_device
);
1835 void lustre_swab_fiemap(struct ll_user_fiemap
*fiemap
)
1839 __swab64s(&fiemap
->fm_start
);
1840 __swab64s(&fiemap
->fm_length
);
1841 __swab32s(&fiemap
->fm_flags
);
1842 __swab32s(&fiemap
->fm_mapped_extents
);
1843 __swab32s(&fiemap
->fm_extent_count
);
1844 __swab32s(&fiemap
->fm_reserved
);
1846 for (i
= 0; i
< fiemap
->fm_mapped_extents
; i
++)
1847 lustre_swab_fiemap_extent(&fiemap
->fm_extents
[i
]);
1849 EXPORT_SYMBOL(lustre_swab_fiemap
);
1851 void lustre_swab_idx_info(struct idx_info
*ii
)
1853 __swab32s(&ii
->ii_magic
);
1854 __swab32s(&ii
->ii_flags
);
1855 __swab16s(&ii
->ii_count
);
1856 __swab32s(&ii
->ii_attrs
);
1857 lustre_swab_lu_fid(&ii
->ii_fid
);
1858 __swab64s(&ii
->ii_version
);
1859 __swab64s(&ii
->ii_hash_start
);
1860 __swab64s(&ii
->ii_hash_end
);
1861 __swab16s(&ii
->ii_keysize
);
1862 __swab16s(&ii
->ii_recsize
);
1865 void lustre_swab_mdt_rec_reint (struct mdt_rec_reint
*rr
)
1867 __swab32s(&rr
->rr_opcode
);
1868 __swab32s(&rr
->rr_cap
);
1869 __swab32s(&rr
->rr_fsuid
);
1870 /* rr_fsuid_h is unused */
1871 __swab32s(&rr
->rr_fsgid
);
1872 /* rr_fsgid_h is unused */
1873 __swab32s(&rr
->rr_suppgid1
);
1874 /* rr_suppgid1_h is unused */
1875 __swab32s(&rr
->rr_suppgid2
);
1876 /* rr_suppgid2_h is unused */
1877 lustre_swab_lu_fid(&rr
->rr_fid1
);
1878 lustre_swab_lu_fid(&rr
->rr_fid2
);
1879 __swab64s(&rr
->rr_mtime
);
1880 __swab64s(&rr
->rr_atime
);
1881 __swab64s(&rr
->rr_ctime
);
1882 __swab64s(&rr
->rr_size
);
1883 __swab64s(&rr
->rr_blocks
);
1884 __swab32s(&rr
->rr_bias
);
1885 __swab32s(&rr
->rr_mode
);
1886 __swab32s(&rr
->rr_flags
);
1887 __swab32s(&rr
->rr_flags_h
);
1888 __swab32s(&rr
->rr_umask
);
1890 CLASSERT(offsetof(typeof(*rr
), rr_padding_4
) != 0);
1892 EXPORT_SYMBOL(lustre_swab_mdt_rec_reint
);
1894 void lustre_swab_lov_desc(struct lov_desc
*ld
)
1896 __swab32s(&ld
->ld_tgt_count
);
1897 __swab32s(&ld
->ld_active_tgt_count
);
1898 __swab32s(&ld
->ld_default_stripe_count
);
1899 __swab32s(&ld
->ld_pattern
);
1900 __swab64s(&ld
->ld_default_stripe_size
);
1901 __swab64s(&ld
->ld_default_stripe_offset
);
1902 __swab32s(&ld
->ld_qos_maxage
);
1903 /* uuid endian insensitive */
1905 EXPORT_SYMBOL(lustre_swab_lov_desc
);
1907 static void print_lum(struct lov_user_md
*lum
)
1909 CDEBUG(D_OTHER
, "lov_user_md %p:\n", lum
);
1910 CDEBUG(D_OTHER
, "\tlmm_magic: %#x\n", lum
->lmm_magic
);
1911 CDEBUG(D_OTHER
, "\tlmm_pattern: %#x\n", lum
->lmm_pattern
);
1912 CDEBUG(D_OTHER
, "\tlmm_object_id: %llu\n", lmm_oi_id(&lum
->lmm_oi
));
1913 CDEBUG(D_OTHER
, "\tlmm_object_gr: %llu\n", lmm_oi_seq(&lum
->lmm_oi
));
1914 CDEBUG(D_OTHER
, "\tlmm_stripe_size: %#x\n", lum
->lmm_stripe_size
);
1915 CDEBUG(D_OTHER
, "\tlmm_stripe_count: %#x\n", lum
->lmm_stripe_count
);
1916 CDEBUG(D_OTHER
, "\tlmm_stripe_offset/lmm_layout_gen: %#x\n",
1917 lum
->lmm_stripe_offset
);
1920 static void lustre_swab_lmm_oi(struct ost_id
*oi
)
1922 __swab64s(&oi
->oi
.oi_id
);
1923 __swab64s(&oi
->oi
.oi_seq
);
1926 static void lustre_swab_lov_user_md_common(struct lov_user_md_v1
*lum
)
1928 __swab32s(&lum
->lmm_magic
);
1929 __swab32s(&lum
->lmm_pattern
);
1930 lustre_swab_lmm_oi(&lum
->lmm_oi
);
1931 __swab32s(&lum
->lmm_stripe_size
);
1932 __swab16s(&lum
->lmm_stripe_count
);
1933 __swab16s(&lum
->lmm_stripe_offset
);
1937 void lustre_swab_lov_user_md_v1(struct lov_user_md_v1
*lum
)
1939 CDEBUG(D_IOCTL
, "swabbing lov_user_md v1\n");
1940 lustre_swab_lov_user_md_common(lum
);
1942 EXPORT_SYMBOL(lustre_swab_lov_user_md_v1
);
1944 void lustre_swab_lov_user_md_v3(struct lov_user_md_v3
*lum
)
1946 CDEBUG(D_IOCTL
, "swabbing lov_user_md v3\n");
1947 lustre_swab_lov_user_md_common((struct lov_user_md_v1
*)lum
);
1948 /* lmm_pool_name nothing to do with char */
1950 EXPORT_SYMBOL(lustre_swab_lov_user_md_v3
);
1952 void lustre_swab_lov_mds_md(struct lov_mds_md
*lmm
)
1954 CDEBUG(D_IOCTL
, "swabbing lov_mds_md\n");
1955 __swab32s(&lmm
->lmm_magic
);
1956 __swab32s(&lmm
->lmm_pattern
);
1957 lustre_swab_lmm_oi(&lmm
->lmm_oi
);
1958 __swab32s(&lmm
->lmm_stripe_size
);
1959 __swab16s(&lmm
->lmm_stripe_count
);
1960 __swab16s(&lmm
->lmm_layout_gen
);
1962 EXPORT_SYMBOL(lustre_swab_lov_mds_md
);
1964 void lustre_swab_lov_user_md_objects(struct lov_user_ost_data
*lod
,
1969 for (i
= 0; i
< stripe_count
; i
++) {
1970 lustre_swab_ost_id(&(lod
[i
].l_ost_oi
));
1971 __swab32s(&(lod
[i
].l_ost_gen
));
1972 __swab32s(&(lod
[i
].l_ost_idx
));
1975 EXPORT_SYMBOL(lustre_swab_lov_user_md_objects
);
1977 static void lustre_swab_ldlm_res_id(struct ldlm_res_id
*id
)
1981 for (i
= 0; i
< RES_NAME_SIZE
; i
++)
1982 __swab64s(&id
->name
[i
]);
1985 static void lustre_swab_ldlm_policy_data(ldlm_wire_policy_data_t
*d
)
1987 /* the lock data is a union and the first two fields are always an
1988 * extent so it's ok to process an LDLM_EXTENT and LDLM_FLOCK lock
1989 * data the same way. */
1990 __swab64s(&d
->l_extent
.start
);
1991 __swab64s(&d
->l_extent
.end
);
1992 __swab64s(&d
->l_extent
.gid
);
1993 __swab64s(&d
->l_flock
.lfw_owner
);
1994 __swab32s(&d
->l_flock
.lfw_pid
);
1997 void lustre_swab_ldlm_intent(struct ldlm_intent
*i
)
2001 EXPORT_SYMBOL(lustre_swab_ldlm_intent
);
2003 static void lustre_swab_ldlm_resource_desc(struct ldlm_resource_desc
*r
)
2005 __swab32s(&r
->lr_type
);
2006 CLASSERT(offsetof(typeof(*r
), lr_padding
) != 0);
2007 lustre_swab_ldlm_res_id(&r
->lr_name
);
2010 static void lustre_swab_ldlm_lock_desc(struct ldlm_lock_desc
*l
)
2012 lustre_swab_ldlm_resource_desc(&l
->l_resource
);
2013 __swab32s(&l
->l_req_mode
);
2014 __swab32s(&l
->l_granted_mode
);
2015 lustre_swab_ldlm_policy_data(&l
->l_policy_data
);
2018 void lustre_swab_ldlm_request(struct ldlm_request
*rq
)
2020 __swab32s(&rq
->lock_flags
);
2021 lustre_swab_ldlm_lock_desc(&rq
->lock_desc
);
2022 __swab32s(&rq
->lock_count
);
2023 /* lock_handle[] opaque */
2025 EXPORT_SYMBOL(lustre_swab_ldlm_request
);
2027 void lustre_swab_ldlm_reply(struct ldlm_reply
*r
)
2029 __swab32s(&r
->lock_flags
);
2030 CLASSERT(offsetof(typeof(*r
), lock_padding
) != 0);
2031 lustre_swab_ldlm_lock_desc(&r
->lock_desc
);
2032 /* lock_handle opaque */
2033 __swab64s(&r
->lock_policy_res1
);
2034 __swab64s(&r
->lock_policy_res2
);
2036 EXPORT_SYMBOL(lustre_swab_ldlm_reply
);
2038 void lustre_swab_quota_body(struct quota_body
*b
)
2040 lustre_swab_lu_fid(&b
->qb_fid
);
2041 lustre_swab_lu_fid((struct lu_fid
*)&b
->qb_id
);
2042 __swab32s(&b
->qb_flags
);
2043 __swab64s(&b
->qb_count
);
2044 __swab64s(&b
->qb_usage
);
2045 __swab64s(&b
->qb_slv_ver
);
2048 /* Dump functions */
2049 void dump_ioo(struct obd_ioobj
*ioo
)
2052 "obd_ioobj: ioo_oid=" DOSTID
", ioo_max_brw=%#x, ioo_bufct=%d\n",
2053 POSTID(&ioo
->ioo_oid
), ioo
->ioo_max_brw
,
2056 EXPORT_SYMBOL(dump_ioo
);
2058 void dump_rniobuf(struct niobuf_remote
*nb
)
2060 CDEBUG(D_RPCTRACE
, "niobuf_remote: offset=%llu, len=%d, flags=%x\n",
2061 nb
->offset
, nb
->len
, nb
->flags
);
2063 EXPORT_SYMBOL(dump_rniobuf
);
2065 static void dump_obdo(struct obdo
*oa
)
2067 __u32 valid
= oa
->o_valid
;
2069 CDEBUG(D_RPCTRACE
, "obdo: o_valid = %08x\n", valid
);
2070 if (valid
& OBD_MD_FLID
)
2071 CDEBUG(D_RPCTRACE
, "obdo: id = "DOSTID
"\n", POSTID(&oa
->o_oi
));
2072 if (valid
& OBD_MD_FLFID
)
2073 CDEBUG(D_RPCTRACE
, "obdo: o_parent_seq = %#llx\n",
2075 if (valid
& OBD_MD_FLSIZE
)
2076 CDEBUG(D_RPCTRACE
, "obdo: o_size = %lld\n", oa
->o_size
);
2077 if (valid
& OBD_MD_FLMTIME
)
2078 CDEBUG(D_RPCTRACE
, "obdo: o_mtime = %lld\n", oa
->o_mtime
);
2079 if (valid
& OBD_MD_FLATIME
)
2080 CDEBUG(D_RPCTRACE
, "obdo: o_atime = %lld\n", oa
->o_atime
);
2081 if (valid
& OBD_MD_FLCTIME
)
2082 CDEBUG(D_RPCTRACE
, "obdo: o_ctime = %lld\n", oa
->o_ctime
);
2083 if (valid
& OBD_MD_FLBLOCKS
) /* allocation of space */
2084 CDEBUG(D_RPCTRACE
, "obdo: o_blocks = %lld\n", oa
->o_blocks
);
2085 if (valid
& OBD_MD_FLGRANT
)
2086 CDEBUG(D_RPCTRACE
, "obdo: o_grant = %lld\n", oa
->o_grant
);
2087 if (valid
& OBD_MD_FLBLKSZ
)
2088 CDEBUG(D_RPCTRACE
, "obdo: o_blksize = %d\n", oa
->o_blksize
);
2089 if (valid
& (OBD_MD_FLTYPE
| OBD_MD_FLMODE
))
2090 CDEBUG(D_RPCTRACE
, "obdo: o_mode = %o\n",
2091 oa
->o_mode
& ((valid
& OBD_MD_FLTYPE
? S_IFMT
: 0) |
2092 (valid
& OBD_MD_FLMODE
? ~S_IFMT
: 0)));
2093 if (valid
& OBD_MD_FLUID
)
2094 CDEBUG(D_RPCTRACE
, "obdo: o_uid = %u\n", oa
->o_uid
);
2095 if (valid
& OBD_MD_FLUID
)
2096 CDEBUG(D_RPCTRACE
, "obdo: o_uid_h = %u\n", oa
->o_uid_h
);
2097 if (valid
& OBD_MD_FLGID
)
2098 CDEBUG(D_RPCTRACE
, "obdo: o_gid = %u\n", oa
->o_gid
);
2099 if (valid
& OBD_MD_FLGID
)
2100 CDEBUG(D_RPCTRACE
, "obdo: o_gid_h = %u\n", oa
->o_gid_h
);
2101 if (valid
& OBD_MD_FLFLAGS
)
2102 CDEBUG(D_RPCTRACE
, "obdo: o_flags = %x\n", oa
->o_flags
);
2103 if (valid
& OBD_MD_FLNLINK
)
2104 CDEBUG(D_RPCTRACE
, "obdo: o_nlink = %u\n", oa
->o_nlink
);
2105 else if (valid
& OBD_MD_FLCKSUM
)
2106 CDEBUG(D_RPCTRACE
, "obdo: o_checksum (o_nlink) = %u\n",
2108 if (valid
& OBD_MD_FLGENER
)
2109 CDEBUG(D_RPCTRACE
, "obdo: o_parent_oid = %x\n",
2111 if (valid
& OBD_MD_FLEPOCH
)
2112 CDEBUG(D_RPCTRACE
, "obdo: o_ioepoch = %lld\n",
2114 if (valid
& OBD_MD_FLFID
) {
2115 CDEBUG(D_RPCTRACE
, "obdo: o_stripe_idx = %u\n",
2117 CDEBUG(D_RPCTRACE
, "obdo: o_parent_ver = %x\n",
2120 if (valid
& OBD_MD_FLHANDLE
)
2121 CDEBUG(D_RPCTRACE
, "obdo: o_handle = %lld\n",
2122 oa
->o_handle
.cookie
);
2123 if (valid
& OBD_MD_FLCOOKIE
)
2124 CDEBUG(D_RPCTRACE
, "obdo: o_lcookie = (llog_cookie dumping not yet implemented)\n");
2127 void dump_ost_body(struct ost_body
*ob
)
2131 EXPORT_SYMBOL(dump_ost_body
);
2133 void dump_rcs(__u32
*rc
)
2135 CDEBUG(D_RPCTRACE
, "rmf_rcs: %d\n", *rc
);
2137 EXPORT_SYMBOL(dump_rcs
);
2139 static inline int req_ptlrpc_body_swabbed(struct ptlrpc_request
*req
)
2141 LASSERT(req
->rq_reqmsg
);
2143 switch (req
->rq_reqmsg
->lm_magic
) {
2144 case LUSTRE_MSG_MAGIC_V2
:
2145 return lustre_req_swabbed(req
, MSG_PTLRPC_BODY_OFF
);
2147 CERROR("bad lustre msg magic: %#08X\n",
2148 req
->rq_reqmsg
->lm_magic
);
2153 static inline int rep_ptlrpc_body_swabbed(struct ptlrpc_request
*req
)
2155 LASSERT(req
->rq_repmsg
);
2157 switch (req
->rq_repmsg
->lm_magic
) {
2158 case LUSTRE_MSG_MAGIC_V2
:
2159 return lustre_rep_swabbed(req
, MSG_PTLRPC_BODY_OFF
);
2161 /* uninitialized yet */
2166 void _debug_req(struct ptlrpc_request
*req
,
2167 struct libcfs_debug_msg_data
*msgdata
,
2168 const char *fmt
, ...)
2170 int req_ok
= req
->rq_reqmsg
!= NULL
;
2171 int rep_ok
= req
->rq_repmsg
!= NULL
;
2172 lnet_nid_t nid
= LNET_NID_ANY
;
2175 if (ptlrpc_req_need_swab(req
)) {
2176 req_ok
= req_ok
&& req_ptlrpc_body_swabbed(req
);
2177 rep_ok
= rep_ok
&& rep_ptlrpc_body_swabbed(req
);
2180 if (req
->rq_import
&& req
->rq_import
->imp_connection
)
2181 nid
= req
->rq_import
->imp_connection
->c_peer
.nid
;
2182 else if (req
->rq_export
&& req
->rq_export
->exp_connection
)
2183 nid
= req
->rq_export
->exp_connection
->c_peer
.nid
;
2185 va_start(args
, fmt
);
2186 libcfs_debug_vmsg2(msgdata
, fmt
, args
,
2187 " req@%p x%llu/t%lld(%lld) 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\n",
2188 req
, req
->rq_xid
, req
->rq_transno
,
2189 req_ok
? lustre_msg_get_transno(req
->rq_reqmsg
) : 0,
2190 req_ok
? lustre_msg_get_opc(req
->rq_reqmsg
) : -1,
2192 req
->rq_import
->imp_obd
->obd_name
:
2194 req
->rq_export
->exp_client_uuid
.uuid
:
2196 libcfs_nid2str(nid
),
2197 req
->rq_request_portal
, req
->rq_reply_portal
,
2198 req
->rq_reqlen
, req
->rq_replen
,
2199 req
->rq_early_count
, (s64
)req
->rq_timedout
,
2200 (s64
)req
->rq_deadline
,
2201 atomic_read(&req
->rq_refcount
),
2202 DEBUG_REQ_FLAGS(req
),
2203 req_ok
? lustre_msg_get_flags(req
->rq_reqmsg
) : -1,
2204 rep_ok
? lustre_msg_get_flags(req
->rq_repmsg
) : -1,
2206 rep_ok
? lustre_msg_get_status(req
->rq_repmsg
) : -1);
2209 EXPORT_SYMBOL(_debug_req
);
2211 void lustre_swab_lustre_capa(struct lustre_capa
*c
)
2213 lustre_swab_lu_fid(&c
->lc_fid
);
2214 __swab64s(&c
->lc_opc
);
2215 __swab64s(&c
->lc_uid
);
2216 __swab64s(&c
->lc_gid
);
2217 __swab32s(&c
->lc_flags
);
2218 __swab32s(&c
->lc_keyid
);
2219 __swab32s(&c
->lc_timeout
);
2220 __swab32s(&c
->lc_expiry
);
2222 EXPORT_SYMBOL(lustre_swab_lustre_capa
);
2224 void lustre_swab_hsm_user_state(struct hsm_user_state
*state
)
2226 __swab32s(&state
->hus_states
);
2227 __swab32s(&state
->hus_archive_id
);
2229 EXPORT_SYMBOL(lustre_swab_hsm_user_state
);
2231 void lustre_swab_hsm_state_set(struct hsm_state_set
*hss
)
2233 __swab32s(&hss
->hss_valid
);
2234 __swab64s(&hss
->hss_setmask
);
2235 __swab64s(&hss
->hss_clearmask
);
2236 __swab32s(&hss
->hss_archive_id
);
2238 EXPORT_SYMBOL(lustre_swab_hsm_state_set
);
2240 static void lustre_swab_hsm_extent(struct hsm_extent
*extent
)
2242 __swab64s(&extent
->offset
);
2243 __swab64s(&extent
->length
);
2246 void lustre_swab_hsm_current_action(struct hsm_current_action
*action
)
2248 __swab32s(&action
->hca_state
);
2249 __swab32s(&action
->hca_action
);
2250 lustre_swab_hsm_extent(&action
->hca_location
);
2252 EXPORT_SYMBOL(lustre_swab_hsm_current_action
);
2254 void lustre_swab_hsm_user_item(struct hsm_user_item
*hui
)
2256 lustre_swab_lu_fid(&hui
->hui_fid
);
2257 lustre_swab_hsm_extent(&hui
->hui_extent
);
2259 EXPORT_SYMBOL(lustre_swab_hsm_user_item
);
2261 void lustre_swab_layout_intent(struct layout_intent
*li
)
2263 __swab32s(&li
->li_opc
);
2264 __swab32s(&li
->li_flags
);
2265 __swab64s(&li
->li_start
);
2266 __swab64s(&li
->li_end
);
2268 EXPORT_SYMBOL(lustre_swab_layout_intent
);
2270 void lustre_swab_hsm_progress_kernel(struct hsm_progress_kernel
*hpk
)
2272 lustre_swab_lu_fid(&hpk
->hpk_fid
);
2273 __swab64s(&hpk
->hpk_cookie
);
2274 __swab64s(&hpk
->hpk_extent
.offset
);
2275 __swab64s(&hpk
->hpk_extent
.length
);
2276 __swab16s(&hpk
->hpk_flags
);
2277 __swab16s(&hpk
->hpk_errval
);
2279 EXPORT_SYMBOL(lustre_swab_hsm_progress_kernel
);
2281 void lustre_swab_hsm_request(struct hsm_request
*hr
)
2283 __swab32s(&hr
->hr_action
);
2284 __swab32s(&hr
->hr_archive_id
);
2285 __swab64s(&hr
->hr_flags
);
2286 __swab32s(&hr
->hr_itemcount
);
2287 __swab32s(&hr
->hr_data_len
);
2289 EXPORT_SYMBOL(lustre_swab_hsm_request
);
2291 void lustre_swab_update_buf(struct update_buf
*ub
)
2293 __swab32s(&ub
->ub_magic
);
2294 __swab32s(&ub
->ub_count
);
2296 EXPORT_SYMBOL(lustre_swab_update_buf
);
2298 void lustre_swab_update_reply_buf(struct update_reply
*ur
)
2302 __swab32s(&ur
->ur_version
);
2303 __swab32s(&ur
->ur_count
);
2304 for (i
= 0; i
< ur
->ur_count
; i
++)
2305 __swab32s(&ur
->ur_lens
[i
]);
2307 EXPORT_SYMBOL(lustre_swab_update_reply_buf
);
2309 void lustre_swab_swap_layouts(struct mdc_swap_layouts
*msl
)
2311 __swab64s(&msl
->msl_flags
);
2313 EXPORT_SYMBOL(lustre_swab_swap_layouts
);
2315 void lustre_swab_close_data(struct close_data
*cd
)
2317 lustre_swab_lu_fid(&cd
->cd_fid
);
2318 __swab64s(&cd
->cd_data_version
);
2320 EXPORT_SYMBOL(lustre_swab_close_data
);