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