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) 2007, 2010, Oracle and/or its affiliates. All rights reserved. | |
24 | * Use is subject to license terms. | |
25 | * | |
1dc563a6 | 26 | * Copyright (c) 2011, 2015, Intel Corporation. |
d7e09d03 PT |
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/layout.c | |
33 | * | |
34 | * Lustre Metadata Target (mdt) request handler | |
35 | * | |
36 | * Author: Nikita Danilov <nikita@clusterfs.com> | |
37 | */ | |
38 | /* | |
39 | * This file contains the "capsule/pill" abstraction layered above PTLRPC. | |
40 | * | |
41 | * Every struct ptlrpc_request contains a "pill", which points to a description | |
42 | * of the format that the request conforms to. | |
43 | */ | |
44 | ||
45 | #if !defined(__REQ_LAYOUT_USER__) | |
46 | ||
47 | #define DEBUG_SUBSYSTEM S_RPC | |
48 | ||
49 | #include <linux/module.h> | |
50 | ||
51 | /* LUSTRE_VERSION_CODE */ | |
e27db149 | 52 | #include "../include/lustre_ver.h" |
d7e09d03 | 53 | |
e27db149 | 54 | #include "../include/obd_support.h" |
d7e09d03 | 55 | /* lustre_swab_mdt_body */ |
e27db149 | 56 | #include "../include/lustre/lustre_idl.h" |
d7e09d03 | 57 | /* obd2cli_tgt() (required by DEBUG_REQ()) */ |
e27db149 | 58 | #include "../include/obd.h" |
d7e09d03 PT |
59 | |
60 | /* __REQ_LAYOUT_USER__ */ | |
61 | #endif | |
62 | /* struct ptlrpc_request, lustre_msg* */ | |
e27db149 | 63 | #include "../include/lustre_req_layout.h" |
e27db149 GKH |
64 | #include "../include/lustre_acl.h" |
65 | #include "../include/lustre_debug.h" | |
d7e09d03 PT |
66 | |
67 | /* | |
68 | * RQFs (see below) refer to two struct req_msg_field arrays describing the | |
69 | * client request and server reply, respectively. | |
70 | */ | |
71 | /* empty set of fields... for suitable definition of emptiness. */ | |
72 | static const struct req_msg_field *empty[] = { | |
73 | &RMF_PTLRPC_BODY | |
74 | }; | |
75 | ||
76 | static const struct req_msg_field *mgs_target_info_only[] = { | |
77 | &RMF_PTLRPC_BODY, | |
78 | &RMF_MGS_TARGET_INFO | |
79 | }; | |
80 | ||
81 | static const struct req_msg_field *mgs_set_info[] = { | |
82 | &RMF_PTLRPC_BODY, | |
83 | &RMF_MGS_SEND_PARAM | |
84 | }; | |
85 | ||
86 | static const struct req_msg_field *mgs_config_read_client[] = { | |
87 | &RMF_PTLRPC_BODY, | |
88 | &RMF_MGS_CONFIG_BODY | |
89 | }; | |
90 | ||
91 | static const struct req_msg_field *mgs_config_read_server[] = { | |
92 | &RMF_PTLRPC_BODY, | |
93 | &RMF_MGS_CONFIG_RES | |
94 | }; | |
95 | ||
96 | static const struct req_msg_field *log_cancel_client[] = { | |
97 | &RMF_PTLRPC_BODY, | |
98 | &RMF_LOGCOOKIES | |
99 | }; | |
100 | ||
101 | static const struct req_msg_field *mdt_body_only[] = { | |
102 | &RMF_PTLRPC_BODY, | |
103 | &RMF_MDT_BODY | |
104 | }; | |
105 | ||
106 | static const struct req_msg_field *mdt_body_capa[] = { | |
107 | &RMF_PTLRPC_BODY, | |
108 | &RMF_MDT_BODY, | |
109 | &RMF_CAPA1 | |
110 | }; | |
111 | ||
112 | static const struct req_msg_field *quotactl_only[] = { | |
113 | &RMF_PTLRPC_BODY, | |
114 | &RMF_OBD_QUOTACTL | |
115 | }; | |
116 | ||
d7e09d03 PT |
117 | static const struct req_msg_field *mdt_close_client[] = { |
118 | &RMF_PTLRPC_BODY, | |
119 | &RMF_MDT_EPOCH, | |
120 | &RMF_REC_REINT, | |
121 | &RMF_CAPA1 | |
122 | }; | |
123 | ||
48d23e61 JX |
124 | static const struct req_msg_field *mdt_release_close_client[] = { |
125 | &RMF_PTLRPC_BODY, | |
126 | &RMF_MDT_EPOCH, | |
127 | &RMF_REC_REINT, | |
128 | &RMF_CAPA1, | |
129 | &RMF_CLOSE_DATA | |
130 | }; | |
131 | ||
d7e09d03 PT |
132 | static const struct req_msg_field *obd_statfs_server[] = { |
133 | &RMF_PTLRPC_BODY, | |
134 | &RMF_OBD_STATFS | |
135 | }; | |
136 | ||
137 | static const struct req_msg_field *seq_query_client[] = { | |
138 | &RMF_PTLRPC_BODY, | |
139 | &RMF_SEQ_OPC, | |
140 | &RMF_SEQ_RANGE | |
141 | }; | |
142 | ||
143 | static const struct req_msg_field *seq_query_server[] = { | |
144 | &RMF_PTLRPC_BODY, | |
145 | &RMF_SEQ_RANGE | |
146 | }; | |
147 | ||
148 | static const struct req_msg_field *fld_query_client[] = { | |
149 | &RMF_PTLRPC_BODY, | |
150 | &RMF_FLD_OPC, | |
151 | &RMF_FLD_MDFLD | |
152 | }; | |
153 | ||
154 | static const struct req_msg_field *fld_query_server[] = { | |
155 | &RMF_PTLRPC_BODY, | |
156 | &RMF_FLD_MDFLD | |
157 | }; | |
158 | ||
b78c2b9b | 159 | static const struct req_msg_field *fld_read_client[] = { |
160 | &RMF_PTLRPC_BODY, | |
161 | &RMF_FLD_MDFLD | |
162 | }; | |
163 | ||
164 | static const struct req_msg_field *fld_read_server[] = { | |
165 | &RMF_PTLRPC_BODY, | |
166 | &RMF_GENERIC_DATA | |
167 | }; | |
168 | ||
d7e09d03 PT |
169 | static const struct req_msg_field *mds_getattr_name_client[] = { |
170 | &RMF_PTLRPC_BODY, | |
171 | &RMF_MDT_BODY, | |
172 | &RMF_CAPA1, | |
173 | &RMF_NAME | |
174 | }; | |
175 | ||
176 | static const struct req_msg_field *mds_reint_client[] = { | |
177 | &RMF_PTLRPC_BODY, | |
178 | &RMF_REC_REINT | |
179 | }; | |
180 | ||
181 | static const struct req_msg_field *mds_reint_create_client[] = { | |
182 | &RMF_PTLRPC_BODY, | |
183 | &RMF_REC_REINT, | |
184 | &RMF_CAPA1, | |
185 | &RMF_NAME | |
186 | }; | |
187 | ||
188 | static const struct req_msg_field *mds_reint_create_slave_client[] = { | |
189 | &RMF_PTLRPC_BODY, | |
190 | &RMF_REC_REINT, | |
191 | &RMF_CAPA1, | |
192 | &RMF_NAME, | |
193 | &RMF_EADATA, | |
194 | &RMF_DLM_REQ | |
195 | }; | |
196 | ||
341f1f0a | 197 | static const struct req_msg_field *mds_reint_create_acl_client[] = { |
d7e09d03 PT |
198 | &RMF_PTLRPC_BODY, |
199 | &RMF_REC_REINT, | |
200 | &RMF_CAPA1, | |
201 | &RMF_NAME, | |
202 | &RMF_EADATA, | |
203 | &RMF_DLM_REQ | |
204 | }; | |
205 | ||
206 | static const struct req_msg_field *mds_reint_create_sym_client[] = { | |
207 | &RMF_PTLRPC_BODY, | |
208 | &RMF_REC_REINT, | |
209 | &RMF_CAPA1, | |
210 | &RMF_NAME, | |
211 | &RMF_SYMTGT, | |
212 | &RMF_DLM_REQ | |
213 | }; | |
214 | ||
215 | static const struct req_msg_field *mds_reint_open_client[] = { | |
216 | &RMF_PTLRPC_BODY, | |
217 | &RMF_REC_REINT, | |
218 | &RMF_CAPA1, | |
219 | &RMF_CAPA2, | |
220 | &RMF_NAME, | |
221 | &RMF_EADATA | |
222 | }; | |
223 | ||
224 | static const struct req_msg_field *mds_reint_open_server[] = { | |
225 | &RMF_PTLRPC_BODY, | |
226 | &RMF_MDT_BODY, | |
227 | &RMF_MDT_MD, | |
228 | &RMF_ACL, | |
229 | &RMF_CAPA1, | |
230 | &RMF_CAPA2 | |
231 | }; | |
232 | ||
233 | static const struct req_msg_field *mds_reint_unlink_client[] = { | |
234 | &RMF_PTLRPC_BODY, | |
235 | &RMF_REC_REINT, | |
236 | &RMF_CAPA1, | |
237 | &RMF_NAME, | |
238 | &RMF_DLM_REQ | |
239 | }; | |
240 | ||
241 | static const struct req_msg_field *mds_reint_link_client[] = { | |
242 | &RMF_PTLRPC_BODY, | |
243 | &RMF_REC_REINT, | |
244 | &RMF_CAPA1, | |
245 | &RMF_CAPA2, | |
246 | &RMF_NAME, | |
247 | &RMF_DLM_REQ | |
248 | }; | |
249 | ||
250 | static const struct req_msg_field *mds_reint_rename_client[] = { | |
251 | &RMF_PTLRPC_BODY, | |
252 | &RMF_REC_REINT, | |
253 | &RMF_CAPA1, | |
254 | &RMF_CAPA2, | |
255 | &RMF_NAME, | |
256 | &RMF_SYMTGT, | |
257 | &RMF_DLM_REQ | |
258 | }; | |
259 | ||
260 | static const struct req_msg_field *mds_last_unlink_server[] = { | |
261 | &RMF_PTLRPC_BODY, | |
262 | &RMF_MDT_BODY, | |
263 | &RMF_MDT_MD, | |
264 | &RMF_LOGCOOKIES, | |
265 | &RMF_CAPA1, | |
266 | &RMF_CAPA2 | |
267 | }; | |
268 | ||
269 | static const struct req_msg_field *mds_reint_setattr_client[] = { | |
270 | &RMF_PTLRPC_BODY, | |
271 | &RMF_REC_REINT, | |
272 | &RMF_CAPA1, | |
273 | &RMF_MDT_EPOCH, | |
274 | &RMF_EADATA, | |
275 | &RMF_LOGCOOKIES, | |
276 | &RMF_DLM_REQ | |
277 | }; | |
278 | ||
279 | static const struct req_msg_field *mds_reint_setxattr_client[] = { | |
280 | &RMF_PTLRPC_BODY, | |
281 | &RMF_REC_REINT, | |
282 | &RMF_CAPA1, | |
283 | &RMF_NAME, | |
e93a3082 AP |
284 | &RMF_EADATA, |
285 | &RMF_DLM_REQ | |
d7e09d03 PT |
286 | }; |
287 | ||
288 | static const struct req_msg_field *mdt_swap_layouts[] = { | |
289 | &RMF_PTLRPC_BODY, | |
290 | &RMF_MDT_BODY, | |
291 | &RMF_SWAP_LAYOUTS, | |
292 | &RMF_CAPA1, | |
293 | &RMF_CAPA2, | |
294 | &RMF_DLM_REQ | |
295 | }; | |
296 | ||
297 | static const struct req_msg_field *obd_connect_client[] = { | |
298 | &RMF_PTLRPC_BODY, | |
299 | &RMF_TGTUUID, | |
300 | &RMF_CLUUID, | |
301 | &RMF_CONN, | |
302 | &RMF_CONNECT_DATA | |
303 | }; | |
304 | ||
305 | static const struct req_msg_field *obd_connect_server[] = { | |
306 | &RMF_PTLRPC_BODY, | |
307 | &RMF_CONNECT_DATA | |
308 | }; | |
309 | ||
310 | static const struct req_msg_field *obd_set_info_client[] = { | |
311 | &RMF_PTLRPC_BODY, | |
312 | &RMF_SETINFO_KEY, | |
313 | &RMF_SETINFO_VAL | |
314 | }; | |
315 | ||
316 | static const struct req_msg_field *ost_grant_shrink_client[] = { | |
317 | &RMF_PTLRPC_BODY, | |
318 | &RMF_SETINFO_KEY, | |
319 | &RMF_OST_BODY | |
320 | }; | |
321 | ||
322 | static const struct req_msg_field *mds_getinfo_client[] = { | |
323 | &RMF_PTLRPC_BODY, | |
324 | &RMF_GETINFO_KEY, | |
325 | &RMF_GETINFO_VALLEN | |
326 | }; | |
327 | ||
328 | static const struct req_msg_field *mds_getinfo_server[] = { | |
329 | &RMF_PTLRPC_BODY, | |
330 | &RMF_GETINFO_VAL, | |
331 | }; | |
332 | ||
333 | static const struct req_msg_field *ldlm_enqueue_client[] = { | |
334 | &RMF_PTLRPC_BODY, | |
335 | &RMF_DLM_REQ | |
336 | }; | |
337 | ||
338 | static const struct req_msg_field *ldlm_enqueue_server[] = { | |
339 | &RMF_PTLRPC_BODY, | |
340 | &RMF_DLM_REP | |
341 | }; | |
342 | ||
343 | static const struct req_msg_field *ldlm_enqueue_lvb_server[] = { | |
344 | &RMF_PTLRPC_BODY, | |
345 | &RMF_DLM_REP, | |
346 | &RMF_DLM_LVB | |
347 | }; | |
348 | ||
349 | static const struct req_msg_field *ldlm_cp_callback_client[] = { | |
350 | &RMF_PTLRPC_BODY, | |
351 | &RMF_DLM_REQ, | |
352 | &RMF_DLM_LVB | |
353 | }; | |
354 | ||
355 | static const struct req_msg_field *ldlm_gl_callback_desc_client[] = { | |
356 | &RMF_PTLRPC_BODY, | |
357 | &RMF_DLM_REQ, | |
358 | &RMF_DLM_GL_DESC | |
359 | }; | |
360 | ||
361 | static const struct req_msg_field *ldlm_gl_callback_server[] = { | |
362 | &RMF_PTLRPC_BODY, | |
363 | &RMF_DLM_LVB | |
364 | }; | |
365 | ||
366 | static const struct req_msg_field *ldlm_intent_basic_client[] = { | |
367 | &RMF_PTLRPC_BODY, | |
368 | &RMF_DLM_REQ, | |
369 | &RMF_LDLM_INTENT, | |
370 | }; | |
371 | ||
372 | static const struct req_msg_field *ldlm_intent_client[] = { | |
373 | &RMF_PTLRPC_BODY, | |
374 | &RMF_DLM_REQ, | |
375 | &RMF_LDLM_INTENT, | |
376 | &RMF_REC_REINT | |
377 | }; | |
378 | ||
379 | static const struct req_msg_field *ldlm_intent_server[] = { | |
380 | &RMF_PTLRPC_BODY, | |
381 | &RMF_DLM_REP, | |
382 | &RMF_MDT_BODY, | |
383 | &RMF_MDT_MD, | |
384 | &RMF_ACL | |
385 | }; | |
386 | ||
387 | static const struct req_msg_field *ldlm_intent_layout_client[] = { | |
388 | &RMF_PTLRPC_BODY, | |
389 | &RMF_DLM_REQ, | |
390 | &RMF_LDLM_INTENT, | |
391 | &RMF_LAYOUT_INTENT, | |
392 | &RMF_EADATA /* for new layout to be set up */ | |
393 | }; | |
c9f6bb96 | 394 | |
d7e09d03 PT |
395 | static const struct req_msg_field *ldlm_intent_open_server[] = { |
396 | &RMF_PTLRPC_BODY, | |
397 | &RMF_DLM_REP, | |
398 | &RMF_MDT_BODY, | |
399 | &RMF_MDT_MD, | |
400 | &RMF_ACL, | |
401 | &RMF_CAPA1, | |
402 | &RMF_CAPA2 | |
403 | }; | |
404 | ||
405 | static const struct req_msg_field *ldlm_intent_getattr_client[] = { | |
406 | &RMF_PTLRPC_BODY, | |
407 | &RMF_DLM_REQ, | |
408 | &RMF_LDLM_INTENT, | |
409 | &RMF_MDT_BODY, /* coincides with mds_getattr_name_client[] */ | |
410 | &RMF_CAPA1, | |
411 | &RMF_NAME | |
412 | }; | |
413 | ||
414 | static const struct req_msg_field *ldlm_intent_getattr_server[] = { | |
415 | &RMF_PTLRPC_BODY, | |
416 | &RMF_DLM_REP, | |
417 | &RMF_MDT_BODY, | |
418 | &RMF_MDT_MD, | |
419 | &RMF_ACL, | |
420 | &RMF_CAPA1 | |
421 | }; | |
422 | ||
423 | static const struct req_msg_field *ldlm_intent_create_client[] = { | |
424 | &RMF_PTLRPC_BODY, | |
425 | &RMF_DLM_REQ, | |
426 | &RMF_LDLM_INTENT, | |
427 | &RMF_REC_REINT, /* coincides with mds_reint_create_client[] */ | |
428 | &RMF_CAPA1, | |
429 | &RMF_NAME, | |
430 | &RMF_EADATA | |
431 | }; | |
432 | ||
433 | static const struct req_msg_field *ldlm_intent_open_client[] = { | |
434 | &RMF_PTLRPC_BODY, | |
435 | &RMF_DLM_REQ, | |
436 | &RMF_LDLM_INTENT, | |
437 | &RMF_REC_REINT, /* coincides with mds_reint_open_client[] */ | |
438 | &RMF_CAPA1, | |
439 | &RMF_CAPA2, | |
440 | &RMF_NAME, | |
441 | &RMF_EADATA | |
442 | }; | |
443 | ||
444 | static const struct req_msg_field *ldlm_intent_unlink_client[] = { | |
445 | &RMF_PTLRPC_BODY, | |
446 | &RMF_DLM_REQ, | |
447 | &RMF_LDLM_INTENT, | |
448 | &RMF_REC_REINT, /* coincides with mds_reint_unlink_client[] */ | |
449 | &RMF_CAPA1, | |
450 | &RMF_NAME | |
451 | }; | |
452 | ||
7fc1f831 AP |
453 | static const struct req_msg_field *ldlm_intent_getxattr_client[] = { |
454 | &RMF_PTLRPC_BODY, | |
455 | &RMF_DLM_REQ, | |
456 | &RMF_LDLM_INTENT, | |
457 | &RMF_MDT_BODY, | |
458 | &RMF_CAPA1, | |
459 | }; | |
460 | ||
461 | static const struct req_msg_field *ldlm_intent_getxattr_server[] = { | |
462 | &RMF_PTLRPC_BODY, | |
463 | &RMF_DLM_REP, | |
464 | &RMF_MDT_BODY, | |
465 | &RMF_MDT_MD, | |
466 | &RMF_ACL, /* for req_capsule_extend/mdt_intent_policy */ | |
467 | &RMF_EADATA, | |
468 | &RMF_EAVALS, | |
469 | &RMF_EAVALS_LENS | |
470 | }; | |
471 | ||
d7e09d03 PT |
472 | static const struct req_msg_field *mds_getxattr_client[] = { |
473 | &RMF_PTLRPC_BODY, | |
474 | &RMF_MDT_BODY, | |
475 | &RMF_CAPA1, | |
476 | &RMF_NAME, | |
477 | &RMF_EADATA | |
478 | }; | |
479 | ||
480 | static const struct req_msg_field *mds_getxattr_server[] = { | |
481 | &RMF_PTLRPC_BODY, | |
482 | &RMF_MDT_BODY, | |
483 | &RMF_EADATA | |
484 | }; | |
485 | ||
486 | static const struct req_msg_field *mds_getattr_server[] = { | |
487 | &RMF_PTLRPC_BODY, | |
488 | &RMF_MDT_BODY, | |
489 | &RMF_MDT_MD, | |
490 | &RMF_ACL, | |
491 | &RMF_CAPA1, | |
492 | &RMF_CAPA2 | |
493 | }; | |
494 | ||
495 | static const struct req_msg_field *mds_setattr_server[] = { | |
496 | &RMF_PTLRPC_BODY, | |
497 | &RMF_MDT_BODY, | |
498 | &RMF_MDT_MD, | |
499 | &RMF_ACL, | |
500 | &RMF_CAPA1, | |
501 | &RMF_CAPA2 | |
502 | }; | |
503 | ||
d7e09d03 PT |
504 | static const struct req_msg_field *llog_origin_handle_create_client[] = { |
505 | &RMF_PTLRPC_BODY, | |
506 | &RMF_LLOGD_BODY, | |
507 | &RMF_NAME | |
508 | }; | |
509 | ||
510 | static const struct req_msg_field *llogd_body_only[] = { | |
511 | &RMF_PTLRPC_BODY, | |
512 | &RMF_LLOGD_BODY | |
513 | }; | |
514 | ||
515 | static const struct req_msg_field *llog_log_hdr_only[] = { | |
516 | &RMF_PTLRPC_BODY, | |
517 | &RMF_LLOG_LOG_HDR | |
518 | }; | |
519 | ||
520 | static const struct req_msg_field *llogd_conn_body_only[] = { | |
521 | &RMF_PTLRPC_BODY, | |
522 | &RMF_LLOGD_CONN_BODY | |
523 | }; | |
524 | ||
525 | static const struct req_msg_field *llog_origin_handle_next_block_server[] = { | |
526 | &RMF_PTLRPC_BODY, | |
527 | &RMF_LLOGD_BODY, | |
528 | &RMF_EADATA | |
529 | }; | |
530 | ||
d7e09d03 PT |
531 | static const struct req_msg_field *ost_body_only[] = { |
532 | &RMF_PTLRPC_BODY, | |
533 | &RMF_OST_BODY | |
534 | }; | |
535 | ||
536 | static const struct req_msg_field *ost_body_capa[] = { | |
537 | &RMF_PTLRPC_BODY, | |
538 | &RMF_OST_BODY, | |
539 | &RMF_CAPA1 | |
540 | }; | |
541 | ||
542 | static const struct req_msg_field *ost_destroy_client[] = { | |
543 | &RMF_PTLRPC_BODY, | |
544 | &RMF_OST_BODY, | |
545 | &RMF_DLM_REQ, | |
546 | &RMF_CAPA1 | |
547 | }; | |
548 | ||
d7e09d03 PT |
549 | static const struct req_msg_field *ost_brw_client[] = { |
550 | &RMF_PTLRPC_BODY, | |
551 | &RMF_OST_BODY, | |
552 | &RMF_OBD_IOOBJ, | |
553 | &RMF_NIOBUF_REMOTE, | |
554 | &RMF_CAPA1 | |
555 | }; | |
556 | ||
557 | static const struct req_msg_field *ost_brw_read_server[] = { | |
558 | &RMF_PTLRPC_BODY, | |
559 | &RMF_OST_BODY | |
560 | }; | |
561 | ||
562 | static const struct req_msg_field *ost_brw_write_server[] = { | |
563 | &RMF_PTLRPC_BODY, | |
564 | &RMF_OST_BODY, | |
565 | &RMF_RCS | |
566 | }; | |
567 | ||
568 | static const struct req_msg_field *ost_get_info_generic_server[] = { | |
569 | &RMF_PTLRPC_BODY, | |
570 | &RMF_GENERIC_DATA, | |
571 | }; | |
572 | ||
573 | static const struct req_msg_field *ost_get_info_generic_client[] = { | |
574 | &RMF_PTLRPC_BODY, | |
45fe5b13 | 575 | &RMF_GETINFO_KEY |
d7e09d03 PT |
576 | }; |
577 | ||
578 | static const struct req_msg_field *ost_get_last_id_server[] = { | |
579 | &RMF_PTLRPC_BODY, | |
580 | &RMF_OBD_ID | |
581 | }; | |
582 | ||
45fe5b13 MP |
583 | static const struct req_msg_field *ost_get_last_fid_client[] = { |
584 | &RMF_PTLRPC_BODY, | |
585 | &RMF_GETINFO_KEY, | |
586 | &RMF_FID, | |
587 | }; | |
588 | ||
d7e09d03 PT |
589 | static const struct req_msg_field *ost_get_last_fid_server[] = { |
590 | &RMF_PTLRPC_BODY, | |
591 | &RMF_FID, | |
592 | }; | |
593 | ||
594 | static const struct req_msg_field *ost_get_fiemap_client[] = { | |
595 | &RMF_PTLRPC_BODY, | |
596 | &RMF_FIEMAP_KEY, | |
597 | &RMF_FIEMAP_VAL | |
598 | }; | |
599 | ||
600 | static const struct req_msg_field *ost_get_fiemap_server[] = { | |
601 | &RMF_PTLRPC_BODY, | |
602 | &RMF_FIEMAP_VAL | |
603 | }; | |
604 | ||
605 | static const struct req_msg_field *mdt_hsm_progress[] = { | |
606 | &RMF_PTLRPC_BODY, | |
607 | &RMF_MDT_BODY, | |
608 | &RMF_MDS_HSM_PROGRESS, | |
609 | }; | |
610 | ||
611 | static const struct req_msg_field *mdt_hsm_ct_register[] = { | |
612 | &RMF_PTLRPC_BODY, | |
613 | &RMF_MDT_BODY, | |
614 | &RMF_MDS_HSM_ARCHIVE, | |
615 | }; | |
616 | ||
617 | static const struct req_msg_field *mdt_hsm_ct_unregister[] = { | |
618 | &RMF_PTLRPC_BODY, | |
619 | &RMF_MDT_BODY, | |
620 | }; | |
621 | ||
622 | static const struct req_msg_field *mdt_hsm_action_server[] = { | |
623 | &RMF_PTLRPC_BODY, | |
624 | &RMF_MDT_BODY, | |
625 | &RMF_MDS_HSM_CURRENT_ACTION, | |
626 | }; | |
627 | ||
628 | static const struct req_msg_field *mdt_hsm_state_get_server[] = { | |
629 | &RMF_PTLRPC_BODY, | |
630 | &RMF_MDT_BODY, | |
631 | &RMF_HSM_USER_STATE, | |
632 | }; | |
633 | ||
634 | static const struct req_msg_field *mdt_hsm_state_set[] = { | |
635 | &RMF_PTLRPC_BODY, | |
636 | &RMF_MDT_BODY, | |
637 | &RMF_CAPA1, | |
638 | &RMF_HSM_STATE_SET, | |
639 | }; | |
640 | ||
641 | static const struct req_msg_field *mdt_hsm_request[] = { | |
642 | &RMF_PTLRPC_BODY, | |
643 | &RMF_MDT_BODY, | |
644 | &RMF_MDS_HSM_REQUEST, | |
645 | &RMF_MDS_HSM_USER_ITEM, | |
646 | &RMF_GENERIC_DATA, | |
647 | }; | |
648 | ||
649 | static struct req_format *req_formats[] = { | |
650 | &RQF_OBD_PING, | |
651 | &RQF_OBD_SET_INFO, | |
d7e09d03 PT |
652 | &RQF_SEC_CTX, |
653 | &RQF_MGS_TARGET_REG, | |
654 | &RQF_MGS_SET_INFO, | |
655 | &RQF_MGS_CONFIG_READ, | |
656 | &RQF_SEQ_QUERY, | |
657 | &RQF_FLD_QUERY, | |
b78c2b9b | 658 | &RQF_FLD_READ, |
d7e09d03 PT |
659 | &RQF_MDS_CONNECT, |
660 | &RQF_MDS_DISCONNECT, | |
661 | &RQF_MDS_GET_INFO, | |
662 | &RQF_MDS_GETSTATUS, | |
663 | &RQF_MDS_STATFS, | |
664 | &RQF_MDS_GETATTR, | |
665 | &RQF_MDS_GETATTR_NAME, | |
666 | &RQF_MDS_GETXATTR, | |
667 | &RQF_MDS_SYNC, | |
668 | &RQF_MDS_CLOSE, | |
48d23e61 | 669 | &RQF_MDS_RELEASE_CLOSE, |
d7e09d03 PT |
670 | &RQF_MDS_READPAGE, |
671 | &RQF_MDS_WRITEPAGE, | |
d7e09d03 PT |
672 | &RQF_MDS_DONE_WRITING, |
673 | &RQF_MDS_REINT, | |
674 | &RQF_MDS_REINT_CREATE, | |
341f1f0a | 675 | &RQF_MDS_REINT_CREATE_ACL, |
d7e09d03 PT |
676 | &RQF_MDS_REINT_CREATE_SLAVE, |
677 | &RQF_MDS_REINT_CREATE_SYM, | |
678 | &RQF_MDS_REINT_OPEN, | |
679 | &RQF_MDS_REINT_UNLINK, | |
680 | &RQF_MDS_REINT_LINK, | |
681 | &RQF_MDS_REINT_RENAME, | |
682 | &RQF_MDS_REINT_SETATTR, | |
683 | &RQF_MDS_REINT_SETXATTR, | |
684 | &RQF_MDS_QUOTACHECK, | |
685 | &RQF_MDS_QUOTACTL, | |
686 | &RQF_MDS_HSM_PROGRESS, | |
687 | &RQF_MDS_HSM_CT_REGISTER, | |
688 | &RQF_MDS_HSM_CT_UNREGISTER, | |
689 | &RQF_MDS_HSM_STATE_GET, | |
690 | &RQF_MDS_HSM_STATE_SET, | |
691 | &RQF_MDS_HSM_ACTION, | |
692 | &RQF_MDS_HSM_REQUEST, | |
693 | &RQF_MDS_SWAP_LAYOUTS, | |
d7e09d03 PT |
694 | &RQF_QC_CALLBACK, |
695 | &RQF_OST_CONNECT, | |
696 | &RQF_OST_DISCONNECT, | |
697 | &RQF_OST_QUOTACHECK, | |
698 | &RQF_OST_QUOTACTL, | |
699 | &RQF_OST_GETATTR, | |
700 | &RQF_OST_SETATTR, | |
701 | &RQF_OST_CREATE, | |
702 | &RQF_OST_PUNCH, | |
703 | &RQF_OST_SYNC, | |
704 | &RQF_OST_DESTROY, | |
705 | &RQF_OST_BRW_READ, | |
706 | &RQF_OST_BRW_WRITE, | |
707 | &RQF_OST_STATFS, | |
708 | &RQF_OST_SET_GRANT_INFO, | |
45fe5b13 | 709 | &RQF_OST_GET_INFO, |
d7e09d03 PT |
710 | &RQF_OST_GET_INFO_LAST_ID, |
711 | &RQF_OST_GET_INFO_LAST_FID, | |
712 | &RQF_OST_SET_INFO_LAST_FID, | |
713 | &RQF_OST_GET_INFO_FIEMAP, | |
714 | &RQF_LDLM_ENQUEUE, | |
715 | &RQF_LDLM_ENQUEUE_LVB, | |
716 | &RQF_LDLM_CONVERT, | |
717 | &RQF_LDLM_CANCEL, | |
718 | &RQF_LDLM_CALLBACK, | |
719 | &RQF_LDLM_CP_CALLBACK, | |
720 | &RQF_LDLM_BL_CALLBACK, | |
721 | &RQF_LDLM_GL_CALLBACK, | |
722 | &RQF_LDLM_GL_DESC_CALLBACK, | |
723 | &RQF_LDLM_INTENT, | |
724 | &RQF_LDLM_INTENT_BASIC, | |
725 | &RQF_LDLM_INTENT_LAYOUT, | |
726 | &RQF_LDLM_INTENT_GETATTR, | |
727 | &RQF_LDLM_INTENT_OPEN, | |
728 | &RQF_LDLM_INTENT_CREATE, | |
729 | &RQF_LDLM_INTENT_UNLINK, | |
7fc1f831 | 730 | &RQF_LDLM_INTENT_GETXATTR, |
d7e09d03 PT |
731 | &RQF_LOG_CANCEL, |
732 | &RQF_LLOG_ORIGIN_HANDLE_CREATE, | |
733 | &RQF_LLOG_ORIGIN_HANDLE_DESTROY, | |
734 | &RQF_LLOG_ORIGIN_HANDLE_NEXT_BLOCK, | |
735 | &RQF_LLOG_ORIGIN_HANDLE_PREV_BLOCK, | |
736 | &RQF_LLOG_ORIGIN_HANDLE_READ_HEADER, | |
65f1c781 MP |
737 | &RQF_LLOG_ORIGIN_CONNECT, |
738 | &RQF_CONNECT, | |
d7e09d03 PT |
739 | }; |
740 | ||
741 | struct req_msg_field { | |
742 | const __u32 rmf_flags; | |
743 | const char *rmf_name; | |
744 | /** | |
745 | * Field length. (-1) means "variable length". If the | |
746 | * \a RMF_F_STRUCT_ARRAY flag is set the field is also variable-length, | |
747 | * but the actual size must be a whole multiple of \a rmf_size. | |
748 | */ | |
749 | const int rmf_size; | |
750 | void (*rmf_swabber)(void *); | |
751 | void (*rmf_dumper)(void *); | |
752 | int rmf_offset[ARRAY_SIZE(req_formats)][RCL_NR]; | |
753 | }; | |
754 | ||
755 | enum rmf_flags { | |
756 | /** | |
757 | * The field is a string, must be NUL-terminated. | |
758 | */ | |
6876a143 | 759 | RMF_F_STRING = BIT(0), |
d7e09d03 PT |
760 | /** |
761 | * The field's buffer size need not match the declared \a rmf_size. | |
762 | */ | |
6876a143 | 763 | RMF_F_NO_SIZE_CHECK = BIT(1), |
d7e09d03 PT |
764 | /** |
765 | * The field's buffer size must be a whole multiple of the declared \a | |
766 | * rmf_size and the \a rmf_swabber function must work on the declared \a | |
767 | * rmf_size worth of bytes. | |
768 | */ | |
6876a143 | 769 | RMF_F_STRUCT_ARRAY = BIT(2) |
d7e09d03 PT |
770 | }; |
771 | ||
772 | struct req_capsule; | |
773 | ||
774 | /* | |
775 | * Request fields. | |
776 | */ | |
d0bfef31 CH |
777 | #define DEFINE_MSGF(name, flags, size, swabber, dumper) { \ |
778 | .rmf_name = (name), \ | |
779 | .rmf_flags = (flags), \ | |
780 | .rmf_size = (size), \ | |
781 | .rmf_swabber = (void (*)(void *))(swabber), \ | |
cf9cac22 | 782 | .rmf_dumper = (void (*)(void *))(dumper) \ |
d7e09d03 PT |
783 | } |
784 | ||
785 | struct req_msg_field RMF_GENERIC_DATA = | |
786 | DEFINE_MSGF("generic_data", 0, | |
787 | -1, NULL, NULL); | |
788 | EXPORT_SYMBOL(RMF_GENERIC_DATA); | |
789 | ||
790 | struct req_msg_field RMF_MGS_TARGET_INFO = | |
791 | DEFINE_MSGF("mgs_target_info", 0, | |
792 | sizeof(struct mgs_target_info), | |
793 | lustre_swab_mgs_target_info, NULL); | |
794 | EXPORT_SYMBOL(RMF_MGS_TARGET_INFO); | |
795 | ||
796 | struct req_msg_field RMF_MGS_SEND_PARAM = | |
797 | DEFINE_MSGF("mgs_send_param", 0, | |
798 | sizeof(struct mgs_send_param), | |
799 | NULL, NULL); | |
800 | EXPORT_SYMBOL(RMF_MGS_SEND_PARAM); | |
801 | ||
802 | struct req_msg_field RMF_MGS_CONFIG_BODY = | |
803 | DEFINE_MSGF("mgs_config_read request", 0, | |
804 | sizeof(struct mgs_config_body), | |
805 | lustre_swab_mgs_config_body, NULL); | |
806 | EXPORT_SYMBOL(RMF_MGS_CONFIG_BODY); | |
807 | ||
808 | struct req_msg_field RMF_MGS_CONFIG_RES = | |
809 | DEFINE_MSGF("mgs_config_read reply ", 0, | |
810 | sizeof(struct mgs_config_res), | |
811 | lustre_swab_mgs_config_res, NULL); | |
812 | EXPORT_SYMBOL(RMF_MGS_CONFIG_RES); | |
813 | ||
814 | struct req_msg_field RMF_U32 = | |
815 | DEFINE_MSGF("generic u32", 0, | |
816 | sizeof(__u32), lustre_swab_generic_32s, NULL); | |
817 | EXPORT_SYMBOL(RMF_U32); | |
818 | ||
819 | struct req_msg_field RMF_SETINFO_VAL = | |
820 | DEFINE_MSGF("setinfo_val", 0, -1, NULL, NULL); | |
821 | EXPORT_SYMBOL(RMF_SETINFO_VAL); | |
822 | ||
823 | struct req_msg_field RMF_GETINFO_KEY = | |
824 | DEFINE_MSGF("getinfo_key", 0, -1, NULL, NULL); | |
825 | EXPORT_SYMBOL(RMF_GETINFO_KEY); | |
826 | ||
827 | struct req_msg_field RMF_GETINFO_VALLEN = | |
828 | DEFINE_MSGF("getinfo_vallen", 0, | |
829 | sizeof(__u32), lustre_swab_generic_32s, NULL); | |
830 | EXPORT_SYMBOL(RMF_GETINFO_VALLEN); | |
831 | ||
832 | struct req_msg_field RMF_GETINFO_VAL = | |
833 | DEFINE_MSGF("getinfo_val", 0, -1, NULL, NULL); | |
834 | EXPORT_SYMBOL(RMF_GETINFO_VAL); | |
835 | ||
836 | struct req_msg_field RMF_SEQ_OPC = | |
837 | DEFINE_MSGF("seq_query_opc", 0, | |
838 | sizeof(__u32), lustre_swab_generic_32s, NULL); | |
839 | EXPORT_SYMBOL(RMF_SEQ_OPC); | |
840 | ||
841 | struct req_msg_field RMF_SEQ_RANGE = | |
842 | DEFINE_MSGF("seq_query_range", 0, | |
843 | sizeof(struct lu_seq_range), | |
844 | lustre_swab_lu_seq_range, NULL); | |
845 | EXPORT_SYMBOL(RMF_SEQ_RANGE); | |
846 | ||
847 | struct req_msg_field RMF_FLD_OPC = | |
848 | DEFINE_MSGF("fld_query_opc", 0, | |
849 | sizeof(__u32), lustre_swab_generic_32s, NULL); | |
850 | EXPORT_SYMBOL(RMF_FLD_OPC); | |
851 | ||
852 | struct req_msg_field RMF_FLD_MDFLD = | |
853 | DEFINE_MSGF("fld_query_mdfld", 0, | |
854 | sizeof(struct lu_seq_range), | |
855 | lustre_swab_lu_seq_range, NULL); | |
856 | EXPORT_SYMBOL(RMF_FLD_MDFLD); | |
857 | ||
858 | struct req_msg_field RMF_MDT_BODY = | |
859 | DEFINE_MSGF("mdt_body", 0, | |
860 | sizeof(struct mdt_body), lustre_swab_mdt_body, NULL); | |
861 | EXPORT_SYMBOL(RMF_MDT_BODY); | |
862 | ||
863 | struct req_msg_field RMF_OBD_QUOTACTL = | |
864 | DEFINE_MSGF("obd_quotactl", 0, | |
865 | sizeof(struct obd_quotactl), | |
866 | lustre_swab_obd_quotactl, NULL); | |
867 | EXPORT_SYMBOL(RMF_OBD_QUOTACTL); | |
868 | ||
d7e09d03 PT |
869 | struct req_msg_field RMF_MDT_EPOCH = |
870 | DEFINE_MSGF("mdt_ioepoch", 0, | |
871 | sizeof(struct mdt_ioepoch), lustre_swab_mdt_ioepoch, NULL); | |
872 | EXPORT_SYMBOL(RMF_MDT_EPOCH); | |
873 | ||
874 | struct req_msg_field RMF_PTLRPC_BODY = | |
875 | DEFINE_MSGF("ptlrpc_body", 0, | |
876 | sizeof(struct ptlrpc_body), lustre_swab_ptlrpc_body, NULL); | |
877 | EXPORT_SYMBOL(RMF_PTLRPC_BODY); | |
878 | ||
48d23e61 JX |
879 | struct req_msg_field RMF_CLOSE_DATA = |
880 | DEFINE_MSGF("data_version", 0, | |
881 | sizeof(struct close_data), lustre_swab_close_data, NULL); | |
882 | EXPORT_SYMBOL(RMF_CLOSE_DATA); | |
883 | ||
d7e09d03 PT |
884 | struct req_msg_field RMF_OBD_STATFS = |
885 | DEFINE_MSGF("obd_statfs", 0, | |
886 | sizeof(struct obd_statfs), lustre_swab_obd_statfs, NULL); | |
887 | EXPORT_SYMBOL(RMF_OBD_STATFS); | |
888 | ||
889 | struct req_msg_field RMF_SETINFO_KEY = | |
890 | DEFINE_MSGF("setinfo_key", 0, -1, NULL, NULL); | |
891 | EXPORT_SYMBOL(RMF_SETINFO_KEY); | |
892 | ||
893 | struct req_msg_field RMF_NAME = | |
894 | DEFINE_MSGF("name", RMF_F_STRING, -1, NULL, NULL); | |
895 | EXPORT_SYMBOL(RMF_NAME); | |
896 | ||
897 | struct req_msg_field RMF_SYMTGT = | |
898 | DEFINE_MSGF("symtgt", RMF_F_STRING, -1, NULL, NULL); | |
899 | EXPORT_SYMBOL(RMF_SYMTGT); | |
900 | ||
901 | struct req_msg_field RMF_TGTUUID = | |
902 | DEFINE_MSGF("tgtuuid", RMF_F_STRING, sizeof(struct obd_uuid) - 1, NULL, | |
30c0aa39 | 903 | NULL); |
d7e09d03 PT |
904 | EXPORT_SYMBOL(RMF_TGTUUID); |
905 | ||
906 | struct req_msg_field RMF_CLUUID = | |
907 | DEFINE_MSGF("cluuid", RMF_F_STRING, sizeof(struct obd_uuid) - 1, NULL, | |
30c0aa39 | 908 | NULL); |
d7e09d03 PT |
909 | EXPORT_SYMBOL(RMF_CLUUID); |
910 | ||
911 | struct req_msg_field RMF_STRING = | |
912 | DEFINE_MSGF("string", RMF_F_STRING, -1, NULL, NULL); | |
913 | EXPORT_SYMBOL(RMF_STRING); | |
914 | ||
915 | struct req_msg_field RMF_LLOGD_BODY = | |
916 | DEFINE_MSGF("llogd_body", 0, | |
917 | sizeof(struct llogd_body), lustre_swab_llogd_body, NULL); | |
918 | EXPORT_SYMBOL(RMF_LLOGD_BODY); | |
919 | ||
920 | struct req_msg_field RMF_LLOG_LOG_HDR = | |
921 | DEFINE_MSGF("llog_log_hdr", 0, | |
922 | sizeof(struct llog_log_hdr), lustre_swab_llog_hdr, NULL); | |
923 | EXPORT_SYMBOL(RMF_LLOG_LOG_HDR); | |
924 | ||
925 | struct req_msg_field RMF_LLOGD_CONN_BODY = | |
926 | DEFINE_MSGF("llogd_conn_body", 0, | |
927 | sizeof(struct llogd_conn_body), | |
928 | lustre_swab_llogd_conn_body, NULL); | |
929 | EXPORT_SYMBOL(RMF_LLOGD_CONN_BODY); | |
930 | ||
931 | /* | |
932 | * connection handle received in MDS_CONNECT request. | |
933 | * | |
934 | * No swabbing needed because struct lustre_handle contains only a 64-bit cookie | |
935 | * that the client does not interpret at all. | |
936 | */ | |
937 | struct req_msg_field RMF_CONN = | |
938 | DEFINE_MSGF("conn", 0, sizeof(struct lustre_handle), NULL, NULL); | |
939 | EXPORT_SYMBOL(RMF_CONN); | |
940 | ||
941 | struct req_msg_field RMF_CONNECT_DATA = | |
942 | DEFINE_MSGF("cdata", | |
943 | RMF_F_NO_SIZE_CHECK /* we allow extra space for interop */, | |
d7e09d03 | 944 | sizeof(struct obd_connect_data), |
d7e09d03 PT |
945 | lustre_swab_connect, NULL); |
946 | EXPORT_SYMBOL(RMF_CONNECT_DATA); | |
947 | ||
948 | struct req_msg_field RMF_DLM_REQ = | |
949 | DEFINE_MSGF("dlm_req", RMF_F_NO_SIZE_CHECK /* ldlm_request_bufsize */, | |
950 | sizeof(struct ldlm_request), | |
951 | lustre_swab_ldlm_request, NULL); | |
952 | EXPORT_SYMBOL(RMF_DLM_REQ); | |
953 | ||
954 | struct req_msg_field RMF_DLM_REP = | |
955 | DEFINE_MSGF("dlm_rep", 0, | |
956 | sizeof(struct ldlm_reply), lustre_swab_ldlm_reply, NULL); | |
957 | EXPORT_SYMBOL(RMF_DLM_REP); | |
958 | ||
959 | struct req_msg_field RMF_LDLM_INTENT = | |
960 | DEFINE_MSGF("ldlm_intent", 0, | |
961 | sizeof(struct ldlm_intent), lustre_swab_ldlm_intent, NULL); | |
962 | EXPORT_SYMBOL(RMF_LDLM_INTENT); | |
963 | ||
964 | struct req_msg_field RMF_DLM_LVB = | |
965 | DEFINE_MSGF("dlm_lvb", 0, -1, NULL, NULL); | |
966 | EXPORT_SYMBOL(RMF_DLM_LVB); | |
967 | ||
968 | struct req_msg_field RMF_DLM_GL_DESC = | |
969 | DEFINE_MSGF("dlm_gl_desc", 0, sizeof(union ldlm_gl_desc), | |
970 | lustre_swab_gl_desc, NULL); | |
971 | EXPORT_SYMBOL(RMF_DLM_GL_DESC); | |
972 | ||
973 | struct req_msg_field RMF_MDT_MD = | |
974 | DEFINE_MSGF("mdt_md", RMF_F_NO_SIZE_CHECK, MIN_MD_SIZE, NULL, NULL); | |
975 | EXPORT_SYMBOL(RMF_MDT_MD); | |
976 | ||
977 | struct req_msg_field RMF_REC_REINT = | |
978 | DEFINE_MSGF("rec_reint", 0, sizeof(struct mdt_rec_reint), | |
979 | lustre_swab_mdt_rec_reint, NULL); | |
980 | EXPORT_SYMBOL(RMF_REC_REINT); | |
981 | ||
982 | /* FIXME: this length should be defined as a macro */ | |
983 | struct req_msg_field RMF_EADATA = DEFINE_MSGF("eadata", 0, -1, | |
984 | NULL, NULL); | |
985 | EXPORT_SYMBOL(RMF_EADATA); | |
986 | ||
7fc1f831 AP |
987 | struct req_msg_field RMF_EAVALS = DEFINE_MSGF("eavals", 0, -1, NULL, NULL); |
988 | EXPORT_SYMBOL(RMF_EAVALS); | |
989 | ||
d7e09d03 PT |
990 | struct req_msg_field RMF_ACL = |
991 | DEFINE_MSGF("acl", RMF_F_NO_SIZE_CHECK, | |
992 | LUSTRE_POSIX_ACL_MAX_SIZE, NULL, NULL); | |
993 | EXPORT_SYMBOL(RMF_ACL); | |
994 | ||
995 | /* FIXME: this should be made to use RMF_F_STRUCT_ARRAY */ | |
996 | struct req_msg_field RMF_LOGCOOKIES = | |
997 | DEFINE_MSGF("logcookies", RMF_F_NO_SIZE_CHECK /* multiple cookies */, | |
998 | sizeof(struct llog_cookie), NULL, NULL); | |
999 | EXPORT_SYMBOL(RMF_LOGCOOKIES); | |
1000 | ||
1001 | struct req_msg_field RMF_CAPA1 = | |
1002 | DEFINE_MSGF("capa", 0, sizeof(struct lustre_capa), | |
1003 | lustre_swab_lustre_capa, NULL); | |
1004 | EXPORT_SYMBOL(RMF_CAPA1); | |
1005 | ||
1006 | struct req_msg_field RMF_CAPA2 = | |
1007 | DEFINE_MSGF("capa", 0, sizeof(struct lustre_capa), | |
1008 | lustre_swab_lustre_capa, NULL); | |
1009 | EXPORT_SYMBOL(RMF_CAPA2); | |
1010 | ||
1011 | struct req_msg_field RMF_LAYOUT_INTENT = | |
1012 | DEFINE_MSGF("layout_intent", 0, | |
1013 | sizeof(struct layout_intent), lustre_swab_layout_intent, | |
1014 | NULL); | |
1015 | EXPORT_SYMBOL(RMF_LAYOUT_INTENT); | |
1016 | ||
1017 | /* | |
1018 | * OST request field. | |
1019 | */ | |
1020 | struct req_msg_field RMF_OST_BODY = | |
1021 | DEFINE_MSGF("ost_body", 0, | |
1022 | sizeof(struct ost_body), lustre_swab_ost_body, dump_ost_body); | |
1023 | EXPORT_SYMBOL(RMF_OST_BODY); | |
1024 | ||
1025 | struct req_msg_field RMF_OBD_IOOBJ = | |
1026 | DEFINE_MSGF("obd_ioobj", RMF_F_STRUCT_ARRAY, | |
1027 | sizeof(struct obd_ioobj), lustre_swab_obd_ioobj, dump_ioo); | |
1028 | EXPORT_SYMBOL(RMF_OBD_IOOBJ); | |
1029 | ||
1030 | struct req_msg_field RMF_NIOBUF_REMOTE = | |
1031 | DEFINE_MSGF("niobuf_remote", RMF_F_STRUCT_ARRAY, | |
1032 | sizeof(struct niobuf_remote), lustre_swab_niobuf_remote, | |
1033 | dump_rniobuf); | |
1034 | EXPORT_SYMBOL(RMF_NIOBUF_REMOTE); | |
1035 | ||
1036 | struct req_msg_field RMF_RCS = | |
1037 | DEFINE_MSGF("niobuf_remote", RMF_F_STRUCT_ARRAY, sizeof(__u32), | |
1038 | lustre_swab_generic_32s, dump_rcs); | |
1039 | EXPORT_SYMBOL(RMF_RCS); | |
1040 | ||
7fc1f831 AP |
1041 | struct req_msg_field RMF_EAVALS_LENS = |
1042 | DEFINE_MSGF("eavals_lens", RMF_F_STRUCT_ARRAY, sizeof(__u32), | |
30c0aa39 | 1043 | lustre_swab_generic_32s, NULL); |
7fc1f831 AP |
1044 | EXPORT_SYMBOL(RMF_EAVALS_LENS); |
1045 | ||
d7e09d03 | 1046 | struct req_msg_field RMF_OBD_ID = |
21aef7d9 OD |
1047 | DEFINE_MSGF("u64", 0, |
1048 | sizeof(u64), lustre_swab_ost_last_id, NULL); | |
d7e09d03 PT |
1049 | EXPORT_SYMBOL(RMF_OBD_ID); |
1050 | ||
1051 | struct req_msg_field RMF_FID = | |
1052 | DEFINE_MSGF("fid", 0, | |
1053 | sizeof(struct lu_fid), lustre_swab_lu_fid, NULL); | |
1054 | EXPORT_SYMBOL(RMF_FID); | |
1055 | ||
1056 | struct req_msg_field RMF_OST_ID = | |
1057 | DEFINE_MSGF("ost_id", 0, | |
1058 | sizeof(struct ost_id), lustre_swab_ost_id, NULL); | |
1059 | EXPORT_SYMBOL(RMF_OST_ID); | |
1060 | ||
1061 | struct req_msg_field RMF_FIEMAP_KEY = | |
1062 | DEFINE_MSGF("fiemap", 0, sizeof(struct ll_fiemap_info_key), | |
1063 | lustre_swab_fiemap, NULL); | |
1064 | EXPORT_SYMBOL(RMF_FIEMAP_KEY); | |
1065 | ||
1066 | struct req_msg_field RMF_FIEMAP_VAL = | |
1067 | DEFINE_MSGF("fiemap", 0, -1, lustre_swab_fiemap, NULL); | |
1068 | EXPORT_SYMBOL(RMF_FIEMAP_VAL); | |
1069 | ||
d7e09d03 PT |
1070 | struct req_msg_field RMF_HSM_USER_STATE = |
1071 | DEFINE_MSGF("hsm_user_state", 0, sizeof(struct hsm_user_state), | |
1072 | lustre_swab_hsm_user_state, NULL); | |
1073 | EXPORT_SYMBOL(RMF_HSM_USER_STATE); | |
1074 | ||
1075 | struct req_msg_field RMF_HSM_STATE_SET = | |
1076 | DEFINE_MSGF("hsm_state_set", 0, sizeof(struct hsm_state_set), | |
1077 | lustre_swab_hsm_state_set, NULL); | |
1078 | EXPORT_SYMBOL(RMF_HSM_STATE_SET); | |
1079 | ||
1080 | struct req_msg_field RMF_MDS_HSM_PROGRESS = | |
1081 | DEFINE_MSGF("hsm_progress", 0, sizeof(struct hsm_progress_kernel), | |
1082 | lustre_swab_hsm_progress_kernel, NULL); | |
1083 | EXPORT_SYMBOL(RMF_MDS_HSM_PROGRESS); | |
1084 | ||
1085 | struct req_msg_field RMF_MDS_HSM_CURRENT_ACTION = | |
1086 | DEFINE_MSGF("hsm_current_action", 0, sizeof(struct hsm_current_action), | |
1087 | lustre_swab_hsm_current_action, NULL); | |
1088 | EXPORT_SYMBOL(RMF_MDS_HSM_CURRENT_ACTION); | |
1089 | ||
1090 | struct req_msg_field RMF_MDS_HSM_USER_ITEM = | |
1091 | DEFINE_MSGF("hsm_user_item", RMF_F_STRUCT_ARRAY, | |
1092 | sizeof(struct hsm_user_item), lustre_swab_hsm_user_item, | |
1093 | NULL); | |
1094 | EXPORT_SYMBOL(RMF_MDS_HSM_USER_ITEM); | |
1095 | ||
1096 | struct req_msg_field RMF_MDS_HSM_ARCHIVE = | |
1097 | DEFINE_MSGF("hsm_archive", 0, | |
1098 | sizeof(__u32), lustre_swab_generic_32s, NULL); | |
1099 | EXPORT_SYMBOL(RMF_MDS_HSM_ARCHIVE); | |
1100 | ||
1101 | struct req_msg_field RMF_MDS_HSM_REQUEST = | |
1102 | DEFINE_MSGF("hsm_request", 0, sizeof(struct hsm_request), | |
1103 | lustre_swab_hsm_request, NULL); | |
1104 | EXPORT_SYMBOL(RMF_MDS_HSM_REQUEST); | |
1105 | ||
d7e09d03 PT |
1106 | struct req_msg_field RMF_SWAP_LAYOUTS = |
1107 | DEFINE_MSGF("swap_layouts", 0, sizeof(struct mdc_swap_layouts), | |
1108 | lustre_swab_swap_layouts, NULL); | |
1109 | EXPORT_SYMBOL(RMF_SWAP_LAYOUTS); | |
1110 | /* | |
1111 | * Request formats. | |
1112 | */ | |
1113 | ||
1114 | struct req_format { | |
1115 | const char *rf_name; | |
d0bfef31 | 1116 | int rf_idx; |
d7e09d03 | 1117 | struct { |
d0bfef31 | 1118 | int nr; |
d7e09d03 PT |
1119 | const struct req_msg_field **d; |
1120 | } rf_fields[RCL_NR]; | |
1121 | }; | |
1122 | ||
d0bfef31 CH |
1123 | #define DEFINE_REQ_FMT(name, client, client_nr, server, server_nr) { \ |
1124 | .rf_name = name, \ | |
1125 | .rf_fields = { \ | |
d7e09d03 PT |
1126 | [RCL_CLIENT] = { \ |
1127 | .nr = client_nr, \ | |
d0bfef31 CH |
1128 | .d = client \ |
1129 | }, \ | |
d7e09d03 PT |
1130 | [RCL_SERVER] = { \ |
1131 | .nr = server_nr, \ | |
d0bfef31 CH |
1132 | .d = server \ |
1133 | } \ | |
1134 | } \ | |
d7e09d03 PT |
1135 | } |
1136 | ||
1137 | #define DEFINE_REQ_FMT0(name, client, server) \ | |
1138 | DEFINE_REQ_FMT(name, client, ARRAY_SIZE(client), server, ARRAY_SIZE(server)) | |
1139 | ||
1140 | struct req_format RQF_OBD_PING = | |
1141 | DEFINE_REQ_FMT0("OBD_PING", empty, empty); | |
1142 | EXPORT_SYMBOL(RQF_OBD_PING); | |
1143 | ||
1144 | struct req_format RQF_OBD_SET_INFO = | |
1145 | DEFINE_REQ_FMT0("OBD_SET_INFO", obd_set_info_client, empty); | |
1146 | EXPORT_SYMBOL(RQF_OBD_SET_INFO); | |
1147 | ||
d7e09d03 PT |
1148 | struct req_format RQF_SEC_CTX = |
1149 | DEFINE_REQ_FMT0("SEC_CTX", empty, empty); | |
1150 | EXPORT_SYMBOL(RQF_SEC_CTX); | |
1151 | ||
1152 | struct req_format RQF_MGS_TARGET_REG = | |
1153 | DEFINE_REQ_FMT0("MGS_TARGET_REG", mgs_target_info_only, | |
30c0aa39 | 1154 | mgs_target_info_only); |
d7e09d03 PT |
1155 | EXPORT_SYMBOL(RQF_MGS_TARGET_REG); |
1156 | ||
1157 | struct req_format RQF_MGS_SET_INFO = | |
1158 | DEFINE_REQ_FMT0("MGS_SET_INFO", mgs_set_info, | |
30c0aa39 | 1159 | mgs_set_info); |
d7e09d03 PT |
1160 | EXPORT_SYMBOL(RQF_MGS_SET_INFO); |
1161 | ||
1162 | struct req_format RQF_MGS_CONFIG_READ = | |
1163 | DEFINE_REQ_FMT0("MGS_CONFIG_READ", mgs_config_read_client, | |
30c0aa39 | 1164 | mgs_config_read_server); |
d7e09d03 PT |
1165 | EXPORT_SYMBOL(RQF_MGS_CONFIG_READ); |
1166 | ||
1167 | struct req_format RQF_SEQ_QUERY = | |
1168 | DEFINE_REQ_FMT0("SEQ_QUERY", seq_query_client, seq_query_server); | |
1169 | EXPORT_SYMBOL(RQF_SEQ_QUERY); | |
1170 | ||
1171 | struct req_format RQF_FLD_QUERY = | |
1172 | DEFINE_REQ_FMT0("FLD_QUERY", fld_query_client, fld_query_server); | |
1173 | EXPORT_SYMBOL(RQF_FLD_QUERY); | |
1174 | ||
b78c2b9b | 1175 | struct req_format RQF_FLD_READ = |
1176 | DEFINE_REQ_FMT0("FLD_READ", fld_read_client, fld_read_server); | |
1177 | EXPORT_SYMBOL(RQF_FLD_READ); | |
1178 | ||
d7e09d03 PT |
1179 | struct req_format RQF_LOG_CANCEL = |
1180 | DEFINE_REQ_FMT0("OBD_LOG_CANCEL", log_cancel_client, empty); | |
1181 | EXPORT_SYMBOL(RQF_LOG_CANCEL); | |
1182 | ||
1183 | struct req_format RQF_MDS_QUOTACHECK = | |
1184 | DEFINE_REQ_FMT0("MDS_QUOTACHECK", quotactl_only, empty); | |
1185 | EXPORT_SYMBOL(RQF_MDS_QUOTACHECK); | |
1186 | ||
1187 | struct req_format RQF_OST_QUOTACHECK = | |
1188 | DEFINE_REQ_FMT0("OST_QUOTACHECK", quotactl_only, empty); | |
1189 | EXPORT_SYMBOL(RQF_OST_QUOTACHECK); | |
1190 | ||
1191 | struct req_format RQF_MDS_QUOTACTL = | |
1192 | DEFINE_REQ_FMT0("MDS_QUOTACTL", quotactl_only, quotactl_only); | |
1193 | EXPORT_SYMBOL(RQF_MDS_QUOTACTL); | |
1194 | ||
1195 | struct req_format RQF_OST_QUOTACTL = | |
1196 | DEFINE_REQ_FMT0("OST_QUOTACTL", quotactl_only, quotactl_only); | |
1197 | EXPORT_SYMBOL(RQF_OST_QUOTACTL); | |
1198 | ||
1199 | struct req_format RQF_QC_CALLBACK = | |
1200 | DEFINE_REQ_FMT0("QC_CALLBACK", quotactl_only, empty); | |
1201 | EXPORT_SYMBOL(RQF_QC_CALLBACK); | |
1202 | ||
d7e09d03 PT |
1203 | struct req_format RQF_MDS_GETSTATUS = |
1204 | DEFINE_REQ_FMT0("MDS_GETSTATUS", mdt_body_only, mdt_body_capa); | |
1205 | EXPORT_SYMBOL(RQF_MDS_GETSTATUS); | |
1206 | ||
1207 | struct req_format RQF_MDS_STATFS = | |
1208 | DEFINE_REQ_FMT0("MDS_STATFS", empty, obd_statfs_server); | |
1209 | EXPORT_SYMBOL(RQF_MDS_STATFS); | |
1210 | ||
1211 | struct req_format RQF_MDS_SYNC = | |
1212 | DEFINE_REQ_FMT0("MDS_SYNC", mdt_body_capa, mdt_body_only); | |
1213 | EXPORT_SYMBOL(RQF_MDS_SYNC); | |
1214 | ||
1215 | struct req_format RQF_MDS_GETATTR = | |
1216 | DEFINE_REQ_FMT0("MDS_GETATTR", mdt_body_capa, mds_getattr_server); | |
1217 | EXPORT_SYMBOL(RQF_MDS_GETATTR); | |
1218 | ||
1219 | struct req_format RQF_MDS_GETXATTR = | |
1220 | DEFINE_REQ_FMT0("MDS_GETXATTR", | |
1221 | mds_getxattr_client, mds_getxattr_server); | |
1222 | EXPORT_SYMBOL(RQF_MDS_GETXATTR); | |
1223 | ||
1224 | struct req_format RQF_MDS_GETATTR_NAME = | |
1225 | DEFINE_REQ_FMT0("MDS_GETATTR_NAME", | |
1226 | mds_getattr_name_client, mds_getattr_server); | |
1227 | EXPORT_SYMBOL(RQF_MDS_GETATTR_NAME); | |
1228 | ||
1229 | struct req_format RQF_MDS_REINT = | |
1230 | DEFINE_REQ_FMT0("MDS_REINT", mds_reint_client, mdt_body_only); | |
1231 | EXPORT_SYMBOL(RQF_MDS_REINT); | |
1232 | ||
1233 | struct req_format RQF_MDS_REINT_CREATE = | |
1234 | DEFINE_REQ_FMT0("MDS_REINT_CREATE", | |
1235 | mds_reint_create_client, mdt_body_capa); | |
1236 | EXPORT_SYMBOL(RQF_MDS_REINT_CREATE); | |
1237 | ||
341f1f0a FY |
1238 | struct req_format RQF_MDS_REINT_CREATE_ACL = |
1239 | DEFINE_REQ_FMT0("MDS_REINT_CREATE_ACL", | |
1240 | mds_reint_create_acl_client, mdt_body_capa); | |
1241 | EXPORT_SYMBOL(RQF_MDS_REINT_CREATE_ACL); | |
d7e09d03 PT |
1242 | |
1243 | struct req_format RQF_MDS_REINT_CREATE_SLAVE = | |
1244 | DEFINE_REQ_FMT0("MDS_REINT_CREATE_EA", | |
1245 | mds_reint_create_slave_client, mdt_body_capa); | |
1246 | EXPORT_SYMBOL(RQF_MDS_REINT_CREATE_SLAVE); | |
1247 | ||
1248 | struct req_format RQF_MDS_REINT_CREATE_SYM = | |
1249 | DEFINE_REQ_FMT0("MDS_REINT_CREATE_SYM", | |
1250 | mds_reint_create_sym_client, mdt_body_capa); | |
1251 | EXPORT_SYMBOL(RQF_MDS_REINT_CREATE_SYM); | |
1252 | ||
1253 | struct req_format RQF_MDS_REINT_OPEN = | |
1254 | DEFINE_REQ_FMT0("MDS_REINT_OPEN", | |
1255 | mds_reint_open_client, mds_reint_open_server); | |
1256 | EXPORT_SYMBOL(RQF_MDS_REINT_OPEN); | |
1257 | ||
1258 | struct req_format RQF_MDS_REINT_UNLINK = | |
1259 | DEFINE_REQ_FMT0("MDS_REINT_UNLINK", mds_reint_unlink_client, | |
1260 | mds_last_unlink_server); | |
1261 | EXPORT_SYMBOL(RQF_MDS_REINT_UNLINK); | |
1262 | ||
1263 | struct req_format RQF_MDS_REINT_LINK = | |
1264 | DEFINE_REQ_FMT0("MDS_REINT_LINK", | |
1265 | mds_reint_link_client, mdt_body_only); | |
1266 | EXPORT_SYMBOL(RQF_MDS_REINT_LINK); | |
1267 | ||
1268 | struct req_format RQF_MDS_REINT_RENAME = | |
1269 | DEFINE_REQ_FMT0("MDS_REINT_RENAME", mds_reint_rename_client, | |
1270 | mds_last_unlink_server); | |
1271 | EXPORT_SYMBOL(RQF_MDS_REINT_RENAME); | |
1272 | ||
1273 | struct req_format RQF_MDS_REINT_SETATTR = | |
1274 | DEFINE_REQ_FMT0("MDS_REINT_SETATTR", | |
1275 | mds_reint_setattr_client, mds_setattr_server); | |
1276 | EXPORT_SYMBOL(RQF_MDS_REINT_SETATTR); | |
1277 | ||
1278 | struct req_format RQF_MDS_REINT_SETXATTR = | |
1279 | DEFINE_REQ_FMT0("MDS_REINT_SETXATTR", | |
1280 | mds_reint_setxattr_client, mdt_body_only); | |
1281 | EXPORT_SYMBOL(RQF_MDS_REINT_SETXATTR); | |
1282 | ||
1283 | struct req_format RQF_MDS_CONNECT = | |
1284 | DEFINE_REQ_FMT0("MDS_CONNECT", | |
1285 | obd_connect_client, obd_connect_server); | |
1286 | EXPORT_SYMBOL(RQF_MDS_CONNECT); | |
1287 | ||
1288 | struct req_format RQF_MDS_DISCONNECT = | |
1289 | DEFINE_REQ_FMT0("MDS_DISCONNECT", empty, empty); | |
1290 | EXPORT_SYMBOL(RQF_MDS_DISCONNECT); | |
1291 | ||
1292 | struct req_format RQF_MDS_GET_INFO = | |
1293 | DEFINE_REQ_FMT0("MDS_GET_INFO", mds_getinfo_client, | |
1294 | mds_getinfo_server); | |
1295 | EXPORT_SYMBOL(RQF_MDS_GET_INFO); | |
1296 | ||
d7e09d03 PT |
1297 | struct req_format RQF_LDLM_ENQUEUE = |
1298 | DEFINE_REQ_FMT0("LDLM_ENQUEUE", | |
1299 | ldlm_enqueue_client, ldlm_enqueue_lvb_server); | |
1300 | EXPORT_SYMBOL(RQF_LDLM_ENQUEUE); | |
1301 | ||
1302 | struct req_format RQF_LDLM_ENQUEUE_LVB = | |
1303 | DEFINE_REQ_FMT0("LDLM_ENQUEUE_LVB", | |
1304 | ldlm_enqueue_client, ldlm_enqueue_lvb_server); | |
1305 | EXPORT_SYMBOL(RQF_LDLM_ENQUEUE_LVB); | |
1306 | ||
1307 | struct req_format RQF_LDLM_CONVERT = | |
1308 | DEFINE_REQ_FMT0("LDLM_CONVERT", | |
1309 | ldlm_enqueue_client, ldlm_enqueue_server); | |
1310 | EXPORT_SYMBOL(RQF_LDLM_CONVERT); | |
1311 | ||
1312 | struct req_format RQF_LDLM_CANCEL = | |
1313 | DEFINE_REQ_FMT0("LDLM_CANCEL", ldlm_enqueue_client, empty); | |
1314 | EXPORT_SYMBOL(RQF_LDLM_CANCEL); | |
1315 | ||
1316 | struct req_format RQF_LDLM_CALLBACK = | |
1317 | DEFINE_REQ_FMT0("LDLM_CALLBACK", ldlm_enqueue_client, empty); | |
1318 | EXPORT_SYMBOL(RQF_LDLM_CALLBACK); | |
1319 | ||
1320 | struct req_format RQF_LDLM_CP_CALLBACK = | |
1321 | DEFINE_REQ_FMT0("LDLM_CP_CALLBACK", ldlm_cp_callback_client, empty); | |
1322 | EXPORT_SYMBOL(RQF_LDLM_CP_CALLBACK); | |
1323 | ||
1324 | struct req_format RQF_LDLM_BL_CALLBACK = | |
1325 | DEFINE_REQ_FMT0("LDLM_BL_CALLBACK", ldlm_enqueue_client, empty); | |
1326 | EXPORT_SYMBOL(RQF_LDLM_BL_CALLBACK); | |
1327 | ||
1328 | struct req_format RQF_LDLM_GL_CALLBACK = | |
1329 | DEFINE_REQ_FMT0("LDLM_GL_CALLBACK", ldlm_enqueue_client, | |
1330 | ldlm_gl_callback_server); | |
1331 | EXPORT_SYMBOL(RQF_LDLM_GL_CALLBACK); | |
1332 | ||
1333 | struct req_format RQF_LDLM_GL_DESC_CALLBACK = | |
1334 | DEFINE_REQ_FMT0("LDLM_GL_CALLBACK", ldlm_gl_callback_desc_client, | |
1335 | ldlm_gl_callback_server); | |
1336 | EXPORT_SYMBOL(RQF_LDLM_GL_DESC_CALLBACK); | |
1337 | ||
1338 | struct req_format RQF_LDLM_INTENT_BASIC = | |
1339 | DEFINE_REQ_FMT0("LDLM_INTENT_BASIC", | |
1340 | ldlm_intent_basic_client, ldlm_enqueue_lvb_server); | |
1341 | EXPORT_SYMBOL(RQF_LDLM_INTENT_BASIC); | |
1342 | ||
1343 | struct req_format RQF_LDLM_INTENT = | |
1344 | DEFINE_REQ_FMT0("LDLM_INTENT", | |
1345 | ldlm_intent_client, ldlm_intent_server); | |
1346 | EXPORT_SYMBOL(RQF_LDLM_INTENT); | |
1347 | ||
1348 | struct req_format RQF_LDLM_INTENT_LAYOUT = | |
1349 | DEFINE_REQ_FMT0("LDLM_INTENT_LAYOUT ", | |
1350 | ldlm_intent_layout_client, ldlm_enqueue_lvb_server); | |
1351 | EXPORT_SYMBOL(RQF_LDLM_INTENT_LAYOUT); | |
1352 | ||
1353 | struct req_format RQF_LDLM_INTENT_GETATTR = | |
1354 | DEFINE_REQ_FMT0("LDLM_INTENT_GETATTR", | |
1355 | ldlm_intent_getattr_client, ldlm_intent_getattr_server); | |
1356 | EXPORT_SYMBOL(RQF_LDLM_INTENT_GETATTR); | |
1357 | ||
1358 | struct req_format RQF_LDLM_INTENT_OPEN = | |
1359 | DEFINE_REQ_FMT0("LDLM_INTENT_OPEN", | |
1360 | ldlm_intent_open_client, ldlm_intent_open_server); | |
1361 | EXPORT_SYMBOL(RQF_LDLM_INTENT_OPEN); | |
1362 | ||
1363 | struct req_format RQF_LDLM_INTENT_CREATE = | |
1364 | DEFINE_REQ_FMT0("LDLM_INTENT_CREATE", | |
1365 | ldlm_intent_create_client, ldlm_intent_getattr_server); | |
1366 | EXPORT_SYMBOL(RQF_LDLM_INTENT_CREATE); | |
1367 | ||
1368 | struct req_format RQF_LDLM_INTENT_UNLINK = | |
1369 | DEFINE_REQ_FMT0("LDLM_INTENT_UNLINK", | |
1370 | ldlm_intent_unlink_client, ldlm_intent_server); | |
1371 | EXPORT_SYMBOL(RQF_LDLM_INTENT_UNLINK); | |
1372 | ||
7fc1f831 AP |
1373 | struct req_format RQF_LDLM_INTENT_GETXATTR = |
1374 | DEFINE_REQ_FMT0("LDLM_INTENT_GETXATTR", | |
1375 | ldlm_intent_getxattr_client, | |
1376 | ldlm_intent_getxattr_server); | |
1377 | EXPORT_SYMBOL(RQF_LDLM_INTENT_GETXATTR); | |
1378 | ||
d7e09d03 PT |
1379 | struct req_format RQF_MDS_CLOSE = |
1380 | DEFINE_REQ_FMT0("MDS_CLOSE", | |
1381 | mdt_close_client, mds_last_unlink_server); | |
1382 | EXPORT_SYMBOL(RQF_MDS_CLOSE); | |
48d23e61 JX |
1383 | |
1384 | struct req_format RQF_MDS_RELEASE_CLOSE = | |
1385 | DEFINE_REQ_FMT0("MDS_CLOSE", | |
1386 | mdt_release_close_client, mds_last_unlink_server); | |
1387 | EXPORT_SYMBOL(RQF_MDS_RELEASE_CLOSE); | |
d7e09d03 | 1388 | |
d7e09d03 PT |
1389 | struct req_format RQF_MDS_DONE_WRITING = |
1390 | DEFINE_REQ_FMT0("MDS_DONE_WRITING", | |
1391 | mdt_close_client, mdt_body_only); | |
1392 | EXPORT_SYMBOL(RQF_MDS_DONE_WRITING); | |
1393 | ||
1394 | struct req_format RQF_MDS_READPAGE = | |
1395 | DEFINE_REQ_FMT0("MDS_READPAGE", | |
1396 | mdt_body_capa, mdt_body_only); | |
1397 | EXPORT_SYMBOL(RQF_MDS_READPAGE); | |
1398 | ||
1399 | struct req_format RQF_MDS_HSM_ACTION = | |
1400 | DEFINE_REQ_FMT0("MDS_HSM_ACTION", mdt_body_capa, mdt_hsm_action_server); | |
1401 | EXPORT_SYMBOL(RQF_MDS_HSM_ACTION); | |
1402 | ||
1403 | struct req_format RQF_MDS_HSM_PROGRESS = | |
1404 | DEFINE_REQ_FMT0("MDS_HSM_PROGRESS", mdt_hsm_progress, empty); | |
1405 | EXPORT_SYMBOL(RQF_MDS_HSM_PROGRESS); | |
1406 | ||
1407 | struct req_format RQF_MDS_HSM_CT_REGISTER = | |
1408 | DEFINE_REQ_FMT0("MDS_HSM_CT_REGISTER", mdt_hsm_ct_register, empty); | |
1409 | EXPORT_SYMBOL(RQF_MDS_HSM_CT_REGISTER); | |
1410 | ||
1411 | struct req_format RQF_MDS_HSM_CT_UNREGISTER = | |
1412 | DEFINE_REQ_FMT0("MDS_HSM_CT_UNREGISTER", mdt_hsm_ct_unregister, empty); | |
1413 | EXPORT_SYMBOL(RQF_MDS_HSM_CT_UNREGISTER); | |
1414 | ||
1415 | struct req_format RQF_MDS_HSM_STATE_GET = | |
1416 | DEFINE_REQ_FMT0("MDS_HSM_STATE_GET", | |
1417 | mdt_body_capa, mdt_hsm_state_get_server); | |
1418 | EXPORT_SYMBOL(RQF_MDS_HSM_STATE_GET); | |
1419 | ||
1420 | struct req_format RQF_MDS_HSM_STATE_SET = | |
1421 | DEFINE_REQ_FMT0("MDS_HSM_STATE_SET", mdt_hsm_state_set, empty); | |
1422 | EXPORT_SYMBOL(RQF_MDS_HSM_STATE_SET); | |
1423 | ||
1424 | struct req_format RQF_MDS_HSM_REQUEST = | |
1425 | DEFINE_REQ_FMT0("MDS_HSM_REQUEST", mdt_hsm_request, empty); | |
1426 | EXPORT_SYMBOL(RQF_MDS_HSM_REQUEST); | |
1427 | ||
1428 | struct req_format RQF_MDS_SWAP_LAYOUTS = | |
1429 | DEFINE_REQ_FMT0("MDS_SWAP_LAYOUTS", | |
1430 | mdt_swap_layouts, empty); | |
1431 | EXPORT_SYMBOL(RQF_MDS_SWAP_LAYOUTS); | |
1432 | ||
1433 | /* This is for split */ | |
1434 | struct req_format RQF_MDS_WRITEPAGE = | |
1435 | DEFINE_REQ_FMT0("MDS_WRITEPAGE", | |
1436 | mdt_body_capa, mdt_body_only); | |
1437 | EXPORT_SYMBOL(RQF_MDS_WRITEPAGE); | |
1438 | ||
d7e09d03 PT |
1439 | struct req_format RQF_LLOG_ORIGIN_HANDLE_CREATE = |
1440 | DEFINE_REQ_FMT0("LLOG_ORIGIN_HANDLE_CREATE", | |
1441 | llog_origin_handle_create_client, llogd_body_only); | |
1442 | EXPORT_SYMBOL(RQF_LLOG_ORIGIN_HANDLE_CREATE); | |
1443 | ||
1444 | struct req_format RQF_LLOG_ORIGIN_HANDLE_DESTROY = | |
1445 | DEFINE_REQ_FMT0("LLOG_ORIGIN_HANDLE_DESTROY", | |
1446 | llogd_body_only, llogd_body_only); | |
1447 | EXPORT_SYMBOL(RQF_LLOG_ORIGIN_HANDLE_DESTROY); | |
1448 | ||
1449 | struct req_format RQF_LLOG_ORIGIN_HANDLE_NEXT_BLOCK = | |
1450 | DEFINE_REQ_FMT0("LLOG_ORIGIN_HANDLE_NEXT_BLOCK", | |
1451 | llogd_body_only, llog_origin_handle_next_block_server); | |
1452 | EXPORT_SYMBOL(RQF_LLOG_ORIGIN_HANDLE_NEXT_BLOCK); | |
1453 | ||
1454 | struct req_format RQF_LLOG_ORIGIN_HANDLE_PREV_BLOCK = | |
1455 | DEFINE_REQ_FMT0("LLOG_ORIGIN_HANDLE_PREV_BLOCK", | |
1456 | llogd_body_only, llog_origin_handle_next_block_server); | |
1457 | EXPORT_SYMBOL(RQF_LLOG_ORIGIN_HANDLE_PREV_BLOCK); | |
1458 | ||
1459 | struct req_format RQF_LLOG_ORIGIN_HANDLE_READ_HEADER = | |
1460 | DEFINE_REQ_FMT0("LLOG_ORIGIN_HANDLE_READ_HEADER", | |
1461 | llogd_body_only, llog_log_hdr_only); | |
1462 | EXPORT_SYMBOL(RQF_LLOG_ORIGIN_HANDLE_READ_HEADER); | |
1463 | ||
1464 | struct req_format RQF_LLOG_ORIGIN_CONNECT = | |
1465 | DEFINE_REQ_FMT0("LLOG_ORIGIN_CONNECT", llogd_conn_body_only, empty); | |
1466 | EXPORT_SYMBOL(RQF_LLOG_ORIGIN_CONNECT); | |
1467 | ||
65f1c781 MP |
1468 | struct req_format RQF_CONNECT = |
1469 | DEFINE_REQ_FMT0("CONNECT", obd_connect_client, obd_connect_server); | |
1470 | EXPORT_SYMBOL(RQF_CONNECT); | |
1471 | ||
d7e09d03 PT |
1472 | struct req_format RQF_OST_CONNECT = |
1473 | DEFINE_REQ_FMT0("OST_CONNECT", | |
1474 | obd_connect_client, obd_connect_server); | |
1475 | EXPORT_SYMBOL(RQF_OST_CONNECT); | |
1476 | ||
1477 | struct req_format RQF_OST_DISCONNECT = | |
1478 | DEFINE_REQ_FMT0("OST_DISCONNECT", empty, empty); | |
1479 | EXPORT_SYMBOL(RQF_OST_DISCONNECT); | |
1480 | ||
1481 | struct req_format RQF_OST_GETATTR = | |
1482 | DEFINE_REQ_FMT0("OST_GETATTR", ost_body_capa, ost_body_only); | |
1483 | EXPORT_SYMBOL(RQF_OST_GETATTR); | |
1484 | ||
1485 | struct req_format RQF_OST_SETATTR = | |
1486 | DEFINE_REQ_FMT0("OST_SETATTR", ost_body_capa, ost_body_only); | |
1487 | EXPORT_SYMBOL(RQF_OST_SETATTR); | |
1488 | ||
1489 | struct req_format RQF_OST_CREATE = | |
1490 | DEFINE_REQ_FMT0("OST_CREATE", ost_body_only, ost_body_only); | |
1491 | EXPORT_SYMBOL(RQF_OST_CREATE); | |
1492 | ||
1493 | struct req_format RQF_OST_PUNCH = | |
1494 | DEFINE_REQ_FMT0("OST_PUNCH", ost_body_capa, ost_body_only); | |
1495 | EXPORT_SYMBOL(RQF_OST_PUNCH); | |
1496 | ||
1497 | struct req_format RQF_OST_SYNC = | |
1498 | DEFINE_REQ_FMT0("OST_SYNC", ost_body_capa, ost_body_only); | |
1499 | EXPORT_SYMBOL(RQF_OST_SYNC); | |
1500 | ||
1501 | struct req_format RQF_OST_DESTROY = | |
1502 | DEFINE_REQ_FMT0("OST_DESTROY", ost_destroy_client, ost_body_only); | |
1503 | EXPORT_SYMBOL(RQF_OST_DESTROY); | |
1504 | ||
1505 | struct req_format RQF_OST_BRW_READ = | |
1506 | DEFINE_REQ_FMT0("OST_BRW_READ", ost_brw_client, ost_brw_read_server); | |
1507 | EXPORT_SYMBOL(RQF_OST_BRW_READ); | |
1508 | ||
1509 | struct req_format RQF_OST_BRW_WRITE = | |
1510 | DEFINE_REQ_FMT0("OST_BRW_WRITE", ost_brw_client, ost_brw_write_server); | |
1511 | EXPORT_SYMBOL(RQF_OST_BRW_WRITE); | |
1512 | ||
1513 | struct req_format RQF_OST_STATFS = | |
1514 | DEFINE_REQ_FMT0("OST_STATFS", empty, obd_statfs_server); | |
1515 | EXPORT_SYMBOL(RQF_OST_STATFS); | |
1516 | ||
1517 | struct req_format RQF_OST_SET_GRANT_INFO = | |
1518 | DEFINE_REQ_FMT0("OST_SET_GRANT_INFO", ost_grant_shrink_client, | |
30c0aa39 | 1519 | ost_body_only); |
d7e09d03 PT |
1520 | EXPORT_SYMBOL(RQF_OST_SET_GRANT_INFO); |
1521 | ||
45fe5b13 | 1522 | struct req_format RQF_OST_GET_INFO = |
d7e09d03 | 1523 | DEFINE_REQ_FMT0("OST_GET_INFO", ost_get_info_generic_client, |
30c0aa39 | 1524 | ost_get_info_generic_server); |
45fe5b13 | 1525 | EXPORT_SYMBOL(RQF_OST_GET_INFO); |
d7e09d03 PT |
1526 | |
1527 | struct req_format RQF_OST_GET_INFO_LAST_ID = | |
1528 | DEFINE_REQ_FMT0("OST_GET_INFO_LAST_ID", ost_get_info_generic_client, | |
30c0aa39 | 1529 | ost_get_last_id_server); |
d7e09d03 PT |
1530 | EXPORT_SYMBOL(RQF_OST_GET_INFO_LAST_ID); |
1531 | ||
1532 | struct req_format RQF_OST_GET_INFO_LAST_FID = | |
45fe5b13 | 1533 | DEFINE_REQ_FMT0("OST_GET_INFO_LAST_FID", ost_get_last_fid_client, |
30c0aa39 | 1534 | ost_get_last_fid_server); |
d7e09d03 PT |
1535 | EXPORT_SYMBOL(RQF_OST_GET_INFO_LAST_FID); |
1536 | ||
1537 | struct req_format RQF_OST_SET_INFO_LAST_FID = | |
1538 | DEFINE_REQ_FMT0("OST_SET_INFO_LAST_FID", obd_set_info_client, | |
30c0aa39 | 1539 | empty); |
d7e09d03 PT |
1540 | EXPORT_SYMBOL(RQF_OST_SET_INFO_LAST_FID); |
1541 | ||
1542 | struct req_format RQF_OST_GET_INFO_FIEMAP = | |
1543 | DEFINE_REQ_FMT0("OST_GET_INFO_FIEMAP", ost_get_fiemap_client, | |
30c0aa39 | 1544 | ost_get_fiemap_server); |
d7e09d03 PT |
1545 | EXPORT_SYMBOL(RQF_OST_GET_INFO_FIEMAP); |
1546 | ||
1547 | #if !defined(__REQ_LAYOUT_USER__) | |
1548 | ||
1549 | /* Convenience macro */ | |
1550 | #define FMT_FIELD(fmt, i, j) (fmt)->rf_fields[(i)].d[(j)] | |
1551 | ||
1552 | /** | |
1553 | * Initializes the capsule abstraction by computing and setting the \a rf_idx | |
1554 | * field of RQFs and the \a rmf_offset field of RMFs. | |
1555 | */ | |
1556 | int req_layout_init(void) | |
1557 | { | |
1558 | int i; | |
1559 | int j; | |
1560 | int k; | |
1561 | struct req_format *rf = NULL; | |
1562 | ||
1563 | for (i = 0; i < ARRAY_SIZE(req_formats); ++i) { | |
1564 | rf = req_formats[i]; | |
1565 | rf->rf_idx = i; | |
1566 | for (j = 0; j < RCL_NR; ++j) { | |
1567 | LASSERT(rf->rf_fields[j].nr <= REQ_MAX_FIELD_NR); | |
1568 | for (k = 0; k < rf->rf_fields[j].nr; ++k) { | |
1569 | struct req_msg_field *field; | |
1570 | ||
1571 | field = (typeof(field))rf->rf_fields[j].d[k]; | |
1572 | LASSERT(!(field->rmf_flags & RMF_F_STRUCT_ARRAY) | |
1573 | || field->rmf_size > 0); | |
1574 | LASSERT(field->rmf_offset[i][j] == 0); | |
1575 | /* | |
1576 | * k + 1 to detect unused format/field | |
1577 | * combinations. | |
1578 | */ | |
1579 | field->rmf_offset[i][j] = k + 1; | |
1580 | } | |
1581 | } | |
1582 | } | |
1583 | return 0; | |
1584 | } | |
1585 | EXPORT_SYMBOL(req_layout_init); | |
1586 | ||
1587 | void req_layout_fini(void) | |
1588 | { | |
1589 | } | |
1590 | EXPORT_SYMBOL(req_layout_fini); | |
1591 | ||
1592 | /** | |
1593 | * Initializes the expected sizes of each RMF in a \a pill (\a rc_area) to -1. | |
1594 | * | |
1595 | * Actual/expected field sizes are set elsewhere in functions in this file: | |
1596 | * req_capsule_init(), req_capsule_server_pack(), req_capsule_set_size() and | |
1597 | * req_capsule_msg_size(). The \a rc_area information is used by. | |
1598 | * ptlrpc_request_set_replen(). | |
1599 | */ | |
98e0a288 | 1600 | static void req_capsule_init_area(struct req_capsule *pill) |
d7e09d03 PT |
1601 | { |
1602 | int i; | |
1603 | ||
1604 | for (i = 0; i < ARRAY_SIZE(pill->rc_area[RCL_CLIENT]); i++) { | |
1605 | pill->rc_area[RCL_CLIENT][i] = -1; | |
1606 | pill->rc_area[RCL_SERVER][i] = -1; | |
1607 | } | |
1608 | } | |
d7e09d03 PT |
1609 | |
1610 | /** | |
1611 | * Initialize a pill. | |
1612 | * | |
1613 | * The \a location indicates whether the caller is executing on the client side | |
1614 | * (RCL_CLIENT) or server side (RCL_SERVER).. | |
1615 | */ | |
1616 | void req_capsule_init(struct req_capsule *pill, | |
1617 | struct ptlrpc_request *req, | |
1618 | enum req_location location) | |
1619 | { | |
1620 | LASSERT(location == RCL_SERVER || location == RCL_CLIENT); | |
1621 | ||
1622 | /* | |
1623 | * Today all capsules are embedded in ptlrpc_request structs, | |
1624 | * but just in case that ever isn't the case, we don't reach | |
1625 | * into req unless req != NULL and pill is the one embedded in | |
1626 | * the req. | |
1627 | * | |
1628 | * The req->rq_pill_init flag makes it safe to initialize a pill | |
1629 | * twice, which might happen in the OST paths as a result of the | |
1630 | * high-priority RPC queue getting peeked at before ost_handle() | |
1631 | * handles an OST RPC. | |
1632 | */ | |
8b382089 | 1633 | if (req && pill == &req->rq_pill && req->rq_pill_init) |
d7e09d03 PT |
1634 | return; |
1635 | ||
ec83e611 | 1636 | memset(pill, 0, sizeof(*pill)); |
d7e09d03 PT |
1637 | pill->rc_req = req; |
1638 | pill->rc_loc = location; | |
1639 | req_capsule_init_area(pill); | |
1640 | ||
8b382089 | 1641 | if (req && pill == &req->rq_pill) |
d7e09d03 PT |
1642 | req->rq_pill_init = 1; |
1643 | } | |
1644 | EXPORT_SYMBOL(req_capsule_init); | |
1645 | ||
1646 | void req_capsule_fini(struct req_capsule *pill) | |
1647 | { | |
1648 | } | |
1649 | EXPORT_SYMBOL(req_capsule_fini); | |
1650 | ||
1651 | static int __req_format_is_sane(const struct req_format *fmt) | |
1652 | { | |
1653 | return | |
1654 | 0 <= fmt->rf_idx && fmt->rf_idx < ARRAY_SIZE(req_formats) && | |
1655 | req_formats[fmt->rf_idx] == fmt; | |
1656 | } | |
1657 | ||
1658 | static struct lustre_msg *__req_msg(const struct req_capsule *pill, | |
1659 | enum req_location loc) | |
1660 | { | |
1661 | struct ptlrpc_request *req; | |
1662 | ||
1663 | req = pill->rc_req; | |
1664 | return loc == RCL_CLIENT ? req->rq_reqmsg : req->rq_repmsg; | |
1665 | } | |
1666 | ||
1667 | /** | |
1668 | * Set the format (\a fmt) of a \a pill; format changes are not allowed here | |
1669 | * (see req_capsule_extend()). | |
1670 | */ | |
1671 | void req_capsule_set(struct req_capsule *pill, const struct req_format *fmt) | |
1672 | { | |
8b382089 | 1673 | LASSERT(!pill->rc_fmt || pill->rc_fmt == fmt); |
d7e09d03 PT |
1674 | LASSERT(__req_format_is_sane(fmt)); |
1675 | ||
1676 | pill->rc_fmt = fmt; | |
1677 | } | |
1678 | EXPORT_SYMBOL(req_capsule_set); | |
1679 | ||
1680 | /** | |
1681 | * Fills in any parts of the \a rc_area of a \a pill that haven't been filled in | |
1682 | * yet. | |
1683 | ||
1684 | * \a rc_area is an array of REQ_MAX_FIELD_NR elements, used to store sizes of | |
1685 | * variable-sized fields. The field sizes come from the declared \a rmf_size | |
1686 | * field of a \a pill's \a rc_fmt's RMF's. | |
1687 | */ | |
1688 | int req_capsule_filled_sizes(struct req_capsule *pill, | |
d0bfef31 | 1689 | enum req_location loc) |
d7e09d03 PT |
1690 | { |
1691 | const struct req_format *fmt = pill->rc_fmt; | |
d0bfef31 | 1692 | int i; |
d7e09d03 | 1693 | |
d7e09d03 PT |
1694 | for (i = 0; i < fmt->rf_fields[loc].nr; ++i) { |
1695 | if (pill->rc_area[loc][i] == -1) { | |
1696 | pill->rc_area[loc][i] = | |
1697 | fmt->rf_fields[loc].d[i]->rmf_size; | |
1698 | if (pill->rc_area[loc][i] == -1) { | |
1699 | /* | |
1700 | * Skip the following fields. | |
1701 | * | |
1702 | * If this LASSERT() trips then you're missing a | |
1703 | * call to req_capsule_set_size(). | |
1704 | */ | |
1705 | LASSERT(loc != RCL_SERVER); | |
1706 | break; | |
1707 | } | |
1708 | } | |
1709 | } | |
1710 | return i; | |
1711 | } | |
1712 | EXPORT_SYMBOL(req_capsule_filled_sizes); | |
1713 | ||
1714 | /** | |
1715 | * Capsule equivalent of lustre_pack_request() and lustre_pack_reply(). | |
1716 | * | |
1717 | * This function uses the \a pill's \a rc_area as filled in by | |
1718 | * req_capsule_set_size() or req_capsule_filled_sizes() (the latter is called by | |
1719 | * this function). | |
1720 | */ | |
1721 | int req_capsule_server_pack(struct req_capsule *pill) | |
1722 | { | |
1723 | const struct req_format *fmt; | |
d0bfef31 CH |
1724 | int count; |
1725 | int rc; | |
d7e09d03 PT |
1726 | |
1727 | LASSERT(pill->rc_loc == RCL_SERVER); | |
1728 | fmt = pill->rc_fmt; | |
8b382089 | 1729 | LASSERT(fmt); |
d7e09d03 PT |
1730 | |
1731 | count = req_capsule_filled_sizes(pill, RCL_SERVER); | |
1732 | rc = lustre_pack_reply(pill->rc_req, count, | |
1733 | pill->rc_area[RCL_SERVER], NULL); | |
1734 | if (rc != 0) { | |
1735 | DEBUG_REQ(D_ERROR, pill->rc_req, | |
30c0aa39 OD |
1736 | "Cannot pack %d fields in format `%s': ", |
1737 | count, fmt->rf_name); | |
d7e09d03 PT |
1738 | } |
1739 | return rc; | |
1740 | } | |
1741 | EXPORT_SYMBOL(req_capsule_server_pack); | |
1742 | ||
1743 | /** | |
1744 | * Returns the PTLRPC request or reply (\a loc) buffer offset of a \a pill | |
1745 | * corresponding to the given RMF (\a field). | |
1746 | */ | |
1747 | static int __req_capsule_offset(const struct req_capsule *pill, | |
1748 | const struct req_msg_field *field, | |
1749 | enum req_location loc) | |
1750 | { | |
1751 | int offset; | |
1752 | ||
1753 | offset = field->rmf_offset[pill->rc_fmt->rf_idx][loc]; | |
30c0aa39 OD |
1754 | LASSERTF(offset > 0, "%s:%s, off=%d, loc=%d\n", pill->rc_fmt->rf_name, |
1755 | field->rmf_name, offset, loc); | |
5dd70706 | 1756 | offset--; |
d7e09d03 PT |
1757 | |
1758 | LASSERT(0 <= offset && offset < REQ_MAX_FIELD_NR); | |
1759 | return offset; | |
1760 | } | |
1761 | ||
1762 | /** | |
1763 | * Helper for __req_capsule_get(); swabs value / array of values and/or dumps | |
1764 | * them if desired. | |
1765 | */ | |
1766 | static | |
1767 | void | |
1768 | swabber_dumper_helper(struct req_capsule *pill, | |
1769 | const struct req_msg_field *field, | |
1770 | enum req_location loc, | |
1771 | int offset, | |
3949015e | 1772 | void *value, int len, int dump, void (*swabber)(void *)) |
d7e09d03 | 1773 | { |
d0bfef31 CH |
1774 | void *p; |
1775 | int i; | |
1776 | int n; | |
1777 | int do_swab; | |
1778 | int inout = loc == RCL_CLIENT; | |
d7e09d03 PT |
1779 | |
1780 | swabber = swabber ?: field->rmf_swabber; | |
1781 | ||
1782 | if (ptlrpc_buf_need_swab(pill->rc_req, inout, offset) && | |
8b382089 | 1783 | swabber && value) |
d7e09d03 PT |
1784 | do_swab = 1; |
1785 | else | |
1786 | do_swab = 0; | |
1787 | ||
358bd68c MN |
1788 | if (!field->rmf_dumper) |
1789 | dump = 0; | |
1790 | ||
d7e09d03 | 1791 | if (!(field->rmf_flags & RMF_F_STRUCT_ARRAY)) { |
358bd68c | 1792 | if (dump) { |
d7e09d03 PT |
1793 | CDEBUG(D_RPCTRACE, "Dump of %sfield %s follows\n", |
1794 | do_swab ? "unswabbed " : "", field->rmf_name); | |
1795 | field->rmf_dumper(value); | |
1796 | } | |
1797 | if (!do_swab) | |
1798 | return; | |
1799 | swabber(value); | |
1800 | ptlrpc_buf_set_swabbed(pill->rc_req, inout, offset); | |
a739735c | 1801 | if (dump && field->rmf_dumper) { |
2d00bd17 JP |
1802 | CDEBUG(D_RPCTRACE, "Dump of swabbed field %s follows\n", |
1803 | field->rmf_name); | |
d7e09d03 PT |
1804 | field->rmf_dumper(value); |
1805 | } | |
1806 | ||
1807 | return; | |
1808 | } | |
1809 | ||
1810 | /* | |
1811 | * We're swabbing an array; swabber() swabs a single array element, so | |
1812 | * swab every element. | |
1813 | */ | |
1814 | LASSERT((len % field->rmf_size) == 0); | |
1815 | for (p = value, i = 0, n = len / field->rmf_size; | |
1816 | i < n; | |
1817 | i++, p += field->rmf_size) { | |
358bd68c | 1818 | if (dump) { |
2d00bd17 | 1819 | CDEBUG(D_RPCTRACE, "Dump of %sarray field %s, element %d follows\n", |
d7e09d03 PT |
1820 | do_swab ? "unswabbed " : "", field->rmf_name, i); |
1821 | field->rmf_dumper(p); | |
1822 | } | |
1823 | if (!do_swab) | |
1824 | continue; | |
1825 | swabber(p); | |
358bd68c | 1826 | if (dump) { |
2d00bd17 JP |
1827 | CDEBUG(D_RPCTRACE, "Dump of swabbed array field %s, element %d follows\n", |
1828 | field->rmf_name, i); | |
d7e09d03 PT |
1829 | field->rmf_dumper(value); |
1830 | } | |
1831 | } | |
1832 | if (do_swab) | |
1833 | ptlrpc_buf_set_swabbed(pill->rc_req, inout, offset); | |
1834 | } | |
1835 | ||
1836 | /** | |
1837 | * Returns the pointer to a PTLRPC request or reply (\a loc) buffer of a \a pill | |
1838 | * corresponding to the given RMF (\a field). | |
1839 | * | |
1840 | * The buffer will be swabbed using the given \a swabber. If \a swabber == NULL | |
1841 | * then the \a rmf_swabber from the RMF will be used. Soon there will be no | |
1842 | * calls to __req_capsule_get() with a non-NULL \a swabber; \a swabber will then | |
1843 | * be removed. Fields with the \a RMF_F_STRUCT_ARRAY flag set will have each | |
1844 | * element of the array swabbed. | |
1845 | */ | |
1846 | static void *__req_capsule_get(struct req_capsule *pill, | |
1847 | const struct req_msg_field *field, | |
1848 | enum req_location loc, | |
3949015e | 1849 | void (*swabber)(void *), |
d7e09d03 PT |
1850 | int dump) |
1851 | { | |
1852 | const struct req_format *fmt; | |
d0bfef31 CH |
1853 | struct lustre_msg *msg; |
1854 | void *value; | |
1855 | int len; | |
1856 | int offset; | |
d7e09d03 PT |
1857 | |
1858 | void *(*getter)(struct lustre_msg *m, int n, int minlen); | |
1859 | ||
1860 | static const char *rcl_names[RCL_NR] = { | |
1861 | [RCL_CLIENT] = "client", | |
1862 | [RCL_SERVER] = "server" | |
1863 | }; | |
1864 | ||
d7e09d03 | 1865 | fmt = pill->rc_fmt; |
8b382089 | 1866 | LASSERT(fmt); |
d7e09d03 PT |
1867 | LASSERT(fmt != LP_POISON); |
1868 | LASSERT(__req_format_is_sane(fmt)); | |
1869 | ||
1870 | offset = __req_capsule_offset(pill, field, loc); | |
1871 | ||
1872 | msg = __req_msg(pill, loc); | |
8b382089 | 1873 | LASSERT(msg); |
d7e09d03 PT |
1874 | |
1875 | getter = (field->rmf_flags & RMF_F_STRING) ? | |
1876 | (typeof(getter))lustre_msg_string : lustre_msg_buf; | |
1877 | ||
1878 | if (field->rmf_flags & RMF_F_STRUCT_ARRAY) { | |
1879 | /* | |
1880 | * We've already asserted that field->rmf_size > 0 in | |
1881 | * req_layout_init(). | |
1882 | */ | |
1883 | len = lustre_msg_buflen(msg, offset); | |
1884 | if ((len % field->rmf_size) != 0) { | |
2d00bd17 | 1885 | CERROR("%s: array field size mismatch %d modulo %d != 0 (%d)\n", |
d7e09d03 PT |
1886 | field->rmf_name, len, field->rmf_size, loc); |
1887 | return NULL; | |
1888 | } | |
1889 | } else if (pill->rc_area[loc][offset] != -1) { | |
1890 | len = pill->rc_area[loc][offset]; | |
1891 | } else { | |
1892 | len = max(field->rmf_size, 0); | |
1893 | } | |
1894 | value = getter(msg, offset, len); | |
1895 | ||
8b382089 | 1896 | if (!value) { |
d7e09d03 | 1897 | DEBUG_REQ(D_ERROR, pill->rc_req, |
2d00bd17 | 1898 | "Wrong buffer for field `%s' (%d of %d) in format `%s': %d vs. %d (%s)\n", |
d7e09d03 PT |
1899 | field->rmf_name, offset, lustre_msg_bufcount(msg), |
1900 | fmt->rf_name, lustre_msg_buflen(msg, offset), len, | |
1901 | rcl_names[loc]); | |
1902 | } else { | |
1903 | swabber_dumper_helper(pill, field, loc, offset, value, len, | |
1904 | dump, swabber); | |
1905 | } | |
1906 | ||
1907 | return value; | |
1908 | } | |
1909 | ||
d7e09d03 PT |
1910 | /** |
1911 | * Trivial wrapper around __req_capsule_get(), that returns the PTLRPC request | |
1912 | * buffer corresponding to the given RMF (\a field) of a \a pill. | |
1913 | */ | |
1914 | void *req_capsule_client_get(struct req_capsule *pill, | |
1915 | const struct req_msg_field *field) | |
1916 | { | |
1917 | return __req_capsule_get(pill, field, RCL_CLIENT, NULL, 0); | |
1918 | } | |
1919 | EXPORT_SYMBOL(req_capsule_client_get); | |
1920 | ||
1921 | /** | |
1922 | * Same as req_capsule_client_get(), but with a \a swabber argument. | |
1923 | * | |
1924 | * Currently unused; will be removed when req_capsule_server_swab_get() is | |
1925 | * unused too. | |
1926 | */ | |
1927 | void *req_capsule_client_swab_get(struct req_capsule *pill, | |
1928 | const struct req_msg_field *field, | |
1929 | void *swabber) | |
1930 | { | |
1931 | return __req_capsule_get(pill, field, RCL_CLIENT, swabber, 0); | |
1932 | } | |
1933 | EXPORT_SYMBOL(req_capsule_client_swab_get); | |
1934 | ||
1935 | /** | |
1936 | * Utility that combines req_capsule_set_size() and req_capsule_client_get(). | |
1937 | * | |
1938 | * First the \a pill's request \a field's size is set (\a rc_area) using | |
1939 | * req_capsule_set_size() with the given \a len. Then the actual buffer is | |
1940 | * returned. | |
1941 | */ | |
1942 | void *req_capsule_client_sized_get(struct req_capsule *pill, | |
1943 | const struct req_msg_field *field, | |
1944 | int len) | |
1945 | { | |
1946 | req_capsule_set_size(pill, field, RCL_CLIENT, len); | |
1947 | return __req_capsule_get(pill, field, RCL_CLIENT, NULL, 0); | |
1948 | } | |
1949 | EXPORT_SYMBOL(req_capsule_client_sized_get); | |
1950 | ||
1951 | /** | |
1952 | * Trivial wrapper around __req_capsule_get(), that returns the PTLRPC reply | |
1953 | * buffer corresponding to the given RMF (\a field) of a \a pill. | |
1954 | */ | |
1955 | void *req_capsule_server_get(struct req_capsule *pill, | |
1956 | const struct req_msg_field *field) | |
1957 | { | |
1958 | return __req_capsule_get(pill, field, RCL_SERVER, NULL, 0); | |
1959 | } | |
1960 | EXPORT_SYMBOL(req_capsule_server_get); | |
1961 | ||
1962 | /** | |
1963 | * Same as req_capsule_server_get(), but with a \a swabber argument. | |
1964 | * | |
1965 | * Ideally all swabbing should be done pursuant to RMF definitions, with no | |
1966 | * swabbing done outside this capsule abstraction. | |
1967 | */ | |
1968 | void *req_capsule_server_swab_get(struct req_capsule *pill, | |
1969 | const struct req_msg_field *field, | |
1970 | void *swabber) | |
1971 | { | |
1972 | return __req_capsule_get(pill, field, RCL_SERVER, swabber, 0); | |
1973 | } | |
1974 | EXPORT_SYMBOL(req_capsule_server_swab_get); | |
1975 | ||
1976 | /** | |
1977 | * Utility that combines req_capsule_set_size() and req_capsule_server_get(). | |
1978 | * | |
1979 | * First the \a pill's request \a field's size is set (\a rc_area) using | |
1980 | * req_capsule_set_size() with the given \a len. Then the actual buffer is | |
1981 | * returned. | |
1982 | */ | |
1983 | void *req_capsule_server_sized_get(struct req_capsule *pill, | |
1984 | const struct req_msg_field *field, | |
1985 | int len) | |
1986 | { | |
1987 | req_capsule_set_size(pill, field, RCL_SERVER, len); | |
1988 | return __req_capsule_get(pill, field, RCL_SERVER, NULL, 0); | |
1989 | } | |
1990 | EXPORT_SYMBOL(req_capsule_server_sized_get); | |
1991 | ||
1992 | void *req_capsule_server_sized_swab_get(struct req_capsule *pill, | |
1993 | const struct req_msg_field *field, | |
1994 | int len, void *swabber) | |
1995 | { | |
1996 | req_capsule_set_size(pill, field, RCL_SERVER, len); | |
1997 | return __req_capsule_get(pill, field, RCL_SERVER, swabber, 0); | |
1998 | } | |
1999 | EXPORT_SYMBOL(req_capsule_server_sized_swab_get); | |
2000 | ||
d7e09d03 PT |
2001 | /** |
2002 | * Set the size of the PTLRPC request/reply (\a loc) buffer for the given \a | |
2003 | * field of the given \a pill. | |
2004 | * | |
2005 | * This function must be used when constructing variable sized fields of a | |
2006 | * request or reply. | |
2007 | */ | |
2008 | void req_capsule_set_size(struct req_capsule *pill, | |
2009 | const struct req_msg_field *field, | |
2010 | enum req_location loc, int size) | |
2011 | { | |
2012 | LASSERT(loc == RCL_SERVER || loc == RCL_CLIENT); | |
2013 | ||
2014 | if ((size != field->rmf_size) && | |
2015 | (field->rmf_size != -1) && | |
2016 | !(field->rmf_flags & RMF_F_NO_SIZE_CHECK) && | |
2017 | (size > 0)) { | |
2018 | if ((field->rmf_flags & RMF_F_STRUCT_ARRAY) && | |
2019 | (size % field->rmf_size != 0)) { | |
2d00bd17 | 2020 | CERROR("%s: array field size mismatch %d %% %d != 0 (%d)\n", |
d7e09d03 PT |
2021 | field->rmf_name, size, field->rmf_size, loc); |
2022 | LBUG(); | |
2023 | } else if (!(field->rmf_flags & RMF_F_STRUCT_ARRAY) && | |
2024 | size < field->rmf_size) { | |
2025 | CERROR("%s: field size mismatch %d != %d (%d)\n", | |
2026 | field->rmf_name, size, field->rmf_size, loc); | |
2027 | LBUG(); | |
2028 | } | |
2029 | } | |
2030 | ||
2031 | pill->rc_area[loc][__req_capsule_offset(pill, field, loc)] = size; | |
2032 | } | |
2033 | EXPORT_SYMBOL(req_capsule_set_size); | |
2034 | ||
2035 | /** | |
2036 | * Return the actual PTLRPC buffer length of a request or reply (\a loc) | |
2037 | * for the given \a pill's given \a field. | |
2038 | * | |
2039 | * NB: this function doesn't correspond with req_capsule_set_size(), which | |
2040 | * actually sets the size in pill.rc_area[loc][offset], but this function | |
2041 | * returns the message buflen[offset], maybe we should use another name. | |
2042 | */ | |
2043 | int req_capsule_get_size(const struct req_capsule *pill, | |
2044 | const struct req_msg_field *field, | |
2045 | enum req_location loc) | |
2046 | { | |
2047 | LASSERT(loc == RCL_SERVER || loc == RCL_CLIENT); | |
2048 | ||
2049 | return lustre_msg_buflen(__req_msg(pill, loc), | |
2050 | __req_capsule_offset(pill, field, loc)); | |
2051 | } | |
2052 | EXPORT_SYMBOL(req_capsule_get_size); | |
2053 | ||
2054 | /** | |
2055 | * Wrapper around lustre_msg_size() that returns the PTLRPC size needed for the | |
2056 | * given \a pill's request or reply (\a loc) given the field size recorded in | |
2057 | * the \a pill's rc_area. | |
2058 | * | |
2059 | * See also req_capsule_set_size(). | |
2060 | */ | |
2061 | int req_capsule_msg_size(struct req_capsule *pill, enum req_location loc) | |
2062 | { | |
2063 | return lustre_msg_size(pill->rc_req->rq_import->imp_msg_magic, | |
2064 | pill->rc_fmt->rf_fields[loc].nr, | |
2065 | pill->rc_area[loc]); | |
2066 | } | |
2067 | ||
2068 | /** | |
2069 | * While req_capsule_msg_size() computes the size of a PTLRPC request or reply | |
2070 | * (\a loc) given a \a pill's \a rc_area, this function computes the size of a | |
2071 | * PTLRPC request or reply given only an RQF (\a fmt). | |
2072 | * | |
2073 | * This function should not be used for formats which contain variable size | |
2074 | * fields. | |
2075 | */ | |
2076 | int req_capsule_fmt_size(__u32 magic, const struct req_format *fmt, | |
2077 | enum req_location loc) | |
2078 | { | |
2079 | int size, i = 0; | |
2080 | ||
2081 | /* | |
2082 | * This function should probably LASSERT() that fmt has no fields with | |
2083 | * RMF_F_STRUCT_ARRAY in rmf_flags, since we can't know here how many | |
2084 | * elements in the array there will ultimately be, but then, we could | |
2085 | * assume that there will be at least one element, and that's just what | |
2086 | * we do. | |
2087 | */ | |
2088 | size = lustre_msg_hdr_size(magic, fmt->rf_fields[loc].nr); | |
2089 | if (size < 0) | |
2090 | return size; | |
2091 | ||
2092 | for (; i < fmt->rf_fields[loc].nr; ++i) | |
2093 | if (fmt->rf_fields[loc].d[i]->rmf_size != -1) | |
2094 | size += cfs_size_round(fmt->rf_fields[loc].d[i]-> | |
2095 | rmf_size); | |
2096 | return size; | |
2097 | } | |
2098 | ||
2099 | /** | |
2100 | * Changes the format of an RPC. | |
2101 | * | |
2102 | * The pill must already have been initialized, which means that it already has | |
2103 | * a request format. The new format \a fmt must be an extension of the pill's | |
2104 | * old format. Specifically: the new format must have as many request and reply | |
2105 | * fields as the old one, and all fields shared by the old and new format must | |
2106 | * be at least as large in the new format. | |
2107 | * | |
2108 | * The new format's fields may be of different "type" than the old format, but | |
2109 | * only for fields that are "opaque" blobs: fields which have a) have no | |
2110 | * \a rmf_swabber, b) \a rmf_flags == 0 or RMF_F_NO_SIZE_CHECK, and c) \a | |
2111 | * rmf_size == -1 or \a rmf_flags == RMF_F_NO_SIZE_CHECK. For example, | |
2112 | * OBD_SET_INFO has a key field and an opaque value field that gets interpreted | |
2113 | * according to the key field. When the value, according to the key, contains a | |
2114 | * structure (or array thereof) to be swabbed, the format should be changed to | |
2115 | * one where the value field has \a rmf_size/rmf_flags/rmf_swabber set | |
2116 | * accordingly. | |
2117 | */ | |
2118 | void req_capsule_extend(struct req_capsule *pill, const struct req_format *fmt) | |
2119 | { | |
2120 | int i; | |
2121 | int j; | |
2122 | ||
2123 | const struct req_format *old; | |
2124 | ||
8b382089 | 2125 | LASSERT(pill->rc_fmt); |
d7e09d03 PT |
2126 | LASSERT(__req_format_is_sane(fmt)); |
2127 | ||
2128 | old = pill->rc_fmt; | |
2129 | /* | |
2130 | * Sanity checking... | |
2131 | */ | |
2132 | for (i = 0; i < RCL_NR; ++i) { | |
2133 | LASSERT(fmt->rf_fields[i].nr >= old->rf_fields[i].nr); | |
2134 | for (j = 0; j < old->rf_fields[i].nr - 1; ++j) { | |
2135 | const struct req_msg_field *ofield = FMT_FIELD(old, i, j); | |
2136 | ||
2137 | /* "opaque" fields can be transmogrified */ | |
8b382089 | 2138 | if (!ofield->rmf_swabber && |
d7e09d03 PT |
2139 | (ofield->rmf_flags & ~RMF_F_NO_SIZE_CHECK) == 0 && |
2140 | (ofield->rmf_size == -1 || | |
2141 | ofield->rmf_flags == RMF_F_NO_SIZE_CHECK)) | |
2142 | continue; | |
2143 | LASSERT(FMT_FIELD(fmt, i, j) == FMT_FIELD(old, i, j)); | |
2144 | } | |
2145 | /* | |
2146 | * Last field in old format can be shorter than in new. | |
2147 | */ | |
2148 | LASSERT(FMT_FIELD(fmt, i, j)->rmf_size >= | |
2149 | FMT_FIELD(old, i, j)->rmf_size); | |
2150 | } | |
2151 | ||
2152 | pill->rc_fmt = fmt; | |
2153 | } | |
2154 | EXPORT_SYMBOL(req_capsule_extend); | |
2155 | ||
2156 | /** | |
2157 | * This function returns a non-zero value if the given \a field is present in | |
2158 | * the format (\a rc_fmt) of \a pill's PTLRPC request or reply (\a loc), else it | |
2159 | * returns 0. | |
2160 | */ | |
2161 | int req_capsule_has_field(const struct req_capsule *pill, | |
2162 | const struct req_msg_field *field, | |
2163 | enum req_location loc) | |
2164 | { | |
2165 | LASSERT(loc == RCL_SERVER || loc == RCL_CLIENT); | |
2166 | ||
2167 | return field->rmf_offset[pill->rc_fmt->rf_idx][loc]; | |
2168 | } | |
2169 | EXPORT_SYMBOL(req_capsule_has_field); | |
2170 | ||
2171 | /** | |
2172 | * Returns a non-zero value if the given \a field is present in the given \a | |
2173 | * pill's PTLRPC request or reply (\a loc), else it returns 0. | |
2174 | */ | |
98e0a288 SB |
2175 | static int req_capsule_field_present(const struct req_capsule *pill, |
2176 | const struct req_msg_field *field, | |
2177 | enum req_location loc) | |
d7e09d03 PT |
2178 | { |
2179 | int offset; | |
2180 | ||
2181 | LASSERT(loc == RCL_SERVER || loc == RCL_CLIENT); | |
2182 | LASSERT(req_capsule_has_field(pill, field, loc)); | |
2183 | ||
2184 | offset = __req_capsule_offset(pill, field, loc); | |
2185 | return lustre_msg_bufcount(__req_msg(pill, loc)) > offset; | |
2186 | } | |
d7e09d03 PT |
2187 | |
2188 | /** | |
2189 | * This function shrinks the size of the _buffer_ of the \a pill's PTLRPC | |
2190 | * request or reply (\a loc). | |
2191 | * | |
2192 | * This is not the opposite of req_capsule_extend(). | |
2193 | */ | |
2194 | void req_capsule_shrink(struct req_capsule *pill, | |
2195 | const struct req_msg_field *field, | |
2196 | unsigned int newlen, | |
2197 | enum req_location loc) | |
2198 | { | |
2199 | const struct req_format *fmt; | |
d0bfef31 CH |
2200 | struct lustre_msg *msg; |
2201 | int len; | |
2202 | int offset; | |
d7e09d03 PT |
2203 | |
2204 | fmt = pill->rc_fmt; | |
8b382089 | 2205 | LASSERT(fmt); |
d7e09d03 PT |
2206 | LASSERT(__req_format_is_sane(fmt)); |
2207 | LASSERT(req_capsule_has_field(pill, field, loc)); | |
2208 | LASSERT(req_capsule_field_present(pill, field, loc)); | |
2209 | ||
2210 | offset = __req_capsule_offset(pill, field, loc); | |
2211 | ||
2212 | msg = __req_msg(pill, loc); | |
2213 | len = lustre_msg_buflen(msg, offset); | |
2214 | LASSERTF(newlen <= len, "%s:%s, oldlen=%d, newlen=%d\n", | |
30c0aa39 | 2215 | fmt->rf_name, field->rmf_name, len, newlen); |
d7e09d03 PT |
2216 | |
2217 | if (loc == RCL_CLIENT) | |
2218 | pill->rc_req->rq_reqlen = lustre_shrink_msg(msg, offset, newlen, | |
2219 | 1); | |
2220 | else | |
2221 | pill->rc_req->rq_replen = lustre_shrink_msg(msg, offset, newlen, | |
2222 | 1); | |
2223 | } | |
2224 | EXPORT_SYMBOL(req_capsule_shrink); | |
2225 | ||
d7e09d03 PT |
2226 | /* __REQ_LAYOUT_USER__ */ |
2227 | #endif |