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