1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* AFS Cache Manager Service |
3 | * |
4 | * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved. |
5 | * Written by David Howells (dhowells@redhat.com) |
6 | */ |
7 | |
8 | #include <linux/module.h> |
9 | #include <linux/init.h> |
10 | #include <linux/slab.h> |
11 | #include <linux/sched.h> |
12 | #include <linux/ip.h> |
13 | #include "internal.h" |
14 | #include "afs_cm.h" |
15 | #include "protocol_yfs.h" |
16 | #define RXRPC_TRACE_ONLY_DEFINE_ENUMS |
17 | #include <trace/events/rxrpc.h> |
18 | |
19 | static int afs_deliver_cb_init_call_back_state(struct afs_call *); |
20 | static int afs_deliver_cb_init_call_back_state3(struct afs_call *); |
21 | static int afs_deliver_cb_probe(struct afs_call *); |
22 | static int afs_deliver_cb_callback(struct afs_call *); |
23 | static int afs_deliver_cb_probe_uuid(struct afs_call *); |
24 | static int afs_deliver_cb_tell_me_about_yourself(struct afs_call *); |
25 | static void afs_cm_destructor(struct afs_call *); |
26 | static void SRXAFSCB_CallBack(struct work_struct *); |
27 | static void SRXAFSCB_InitCallBackState(struct work_struct *); |
28 | static void SRXAFSCB_Probe(struct work_struct *); |
29 | static void SRXAFSCB_ProbeUuid(struct work_struct *); |
30 | static void SRXAFSCB_TellMeAboutYourself(struct work_struct *); |
31 | |
32 | static int afs_deliver_yfs_cb_callback(struct afs_call *); |
33 | |
34 | /* |
35 | * CB.CallBack operation type |
36 | */ |
37 | static const struct afs_call_type afs_SRXCBCallBack = { |
38 | .name = "CB.CallBack" , |
39 | .deliver = afs_deliver_cb_callback, |
40 | .destructor = afs_cm_destructor, |
41 | .work = SRXAFSCB_CallBack, |
42 | }; |
43 | |
44 | /* |
45 | * CB.InitCallBackState operation type |
46 | */ |
47 | static const struct afs_call_type afs_SRXCBInitCallBackState = { |
48 | .name = "CB.InitCallBackState" , |
49 | .deliver = afs_deliver_cb_init_call_back_state, |
50 | .destructor = afs_cm_destructor, |
51 | .work = SRXAFSCB_InitCallBackState, |
52 | }; |
53 | |
54 | /* |
55 | * CB.InitCallBackState3 operation type |
56 | */ |
57 | static const struct afs_call_type afs_SRXCBInitCallBackState3 = { |
58 | .name = "CB.InitCallBackState3" , |
59 | .deliver = afs_deliver_cb_init_call_back_state3, |
60 | .destructor = afs_cm_destructor, |
61 | .work = SRXAFSCB_InitCallBackState, |
62 | }; |
63 | |
64 | /* |
65 | * CB.Probe operation type |
66 | */ |
67 | static const struct afs_call_type afs_SRXCBProbe = { |
68 | .name = "CB.Probe" , |
69 | .deliver = afs_deliver_cb_probe, |
70 | .destructor = afs_cm_destructor, |
71 | .work = SRXAFSCB_Probe, |
72 | }; |
73 | |
74 | /* |
75 | * CB.ProbeUuid operation type |
76 | */ |
77 | static const struct afs_call_type afs_SRXCBProbeUuid = { |
78 | .name = "CB.ProbeUuid" , |
79 | .deliver = afs_deliver_cb_probe_uuid, |
80 | .destructor = afs_cm_destructor, |
81 | .work = SRXAFSCB_ProbeUuid, |
82 | }; |
83 | |
84 | /* |
85 | * CB.TellMeAboutYourself operation type |
86 | */ |
87 | static const struct afs_call_type afs_SRXCBTellMeAboutYourself = { |
88 | .name = "CB.TellMeAboutYourself" , |
89 | .deliver = afs_deliver_cb_tell_me_about_yourself, |
90 | .destructor = afs_cm_destructor, |
91 | .work = SRXAFSCB_TellMeAboutYourself, |
92 | }; |
93 | |
94 | /* |
95 | * YFS CB.CallBack operation type |
96 | */ |
97 | static const struct afs_call_type afs_SRXYFSCB_CallBack = { |
98 | .name = "YFSCB.CallBack" , |
99 | .deliver = afs_deliver_yfs_cb_callback, |
100 | .destructor = afs_cm_destructor, |
101 | .work = SRXAFSCB_CallBack, |
102 | }; |
103 | |
104 | /* |
105 | * route an incoming cache manager call |
106 | * - return T if supported, F if not |
107 | */ |
108 | bool afs_cm_incoming_call(struct afs_call *call) |
109 | { |
110 | _enter("{%u, CB.OP %u}" , call->service_id, call->operation_ID); |
111 | |
112 | switch (call->operation_ID) { |
113 | case CBCallBack: |
114 | call->type = &afs_SRXCBCallBack; |
115 | return true; |
116 | case CBInitCallBackState: |
117 | call->type = &afs_SRXCBInitCallBackState; |
118 | return true; |
119 | case CBInitCallBackState3: |
120 | call->type = &afs_SRXCBInitCallBackState3; |
121 | return true; |
122 | case CBProbe: |
123 | call->type = &afs_SRXCBProbe; |
124 | return true; |
125 | case CBProbeUuid: |
126 | call->type = &afs_SRXCBProbeUuid; |
127 | return true; |
128 | case CBTellMeAboutYourself: |
129 | call->type = &afs_SRXCBTellMeAboutYourself; |
130 | return true; |
131 | case YFSCBCallBack: |
132 | if (call->service_id != YFS_CM_SERVICE) |
133 | return false; |
134 | call->type = &afs_SRXYFSCB_CallBack; |
135 | return true; |
136 | default: |
137 | return false; |
138 | } |
139 | } |
140 | |
141 | /* |
142 | * Find the server record by peer address and record a probe to the cache |
143 | * manager from a server. |
144 | */ |
145 | static int afs_find_cm_server_by_peer(struct afs_call *call) |
146 | { |
147 | struct sockaddr_rxrpc srx; |
148 | struct afs_server *server; |
149 | struct rxrpc_peer *peer; |
150 | |
151 | peer = rxrpc_kernel_get_call_peer(sock: call->net->socket, call: call->rxcall); |
152 | |
153 | server = afs_find_server(call->net, peer); |
154 | if (!server) { |
155 | trace_afs_cm_no_server(call, srx: &srx); |
156 | return 0; |
157 | } |
158 | |
159 | call->server = server; |
160 | return 0; |
161 | } |
162 | |
163 | /* |
164 | * Find the server record by server UUID and record a probe to the cache |
165 | * manager from a server. |
166 | */ |
167 | static int afs_find_cm_server_by_uuid(struct afs_call *call, |
168 | struct afs_uuid *uuid) |
169 | { |
170 | struct afs_server *server; |
171 | |
172 | rcu_read_lock(); |
173 | server = afs_find_server_by_uuid(call->net, call->request); |
174 | rcu_read_unlock(); |
175 | if (!server) { |
176 | trace_afs_cm_no_server_u(call, uuid: call->request); |
177 | return 0; |
178 | } |
179 | |
180 | call->server = server; |
181 | return 0; |
182 | } |
183 | |
184 | /* |
185 | * Clean up a cache manager call. |
186 | */ |
187 | static void afs_cm_destructor(struct afs_call *call) |
188 | { |
189 | kfree(objp: call->buffer); |
190 | call->buffer = NULL; |
191 | } |
192 | |
193 | /* |
194 | * Abort a service call from within an action function. |
195 | */ |
196 | static void afs_abort_service_call(struct afs_call *call, u32 abort_code, int error, |
197 | enum rxrpc_abort_reason why) |
198 | { |
199 | rxrpc_kernel_abort_call(call->net->socket, call->rxcall, |
200 | abort_code, error, why); |
201 | afs_set_call_complete(call, error, remote_abort: 0); |
202 | } |
203 | |
204 | /* |
205 | * The server supplied a list of callbacks that it wanted to break. |
206 | */ |
207 | static void SRXAFSCB_CallBack(struct work_struct *work) |
208 | { |
209 | struct afs_call *call = container_of(work, struct afs_call, work); |
210 | |
211 | _enter("" ); |
212 | |
213 | /* We need to break the callbacks before sending the reply as the |
214 | * server holds up change visibility till it receives our reply so as |
215 | * to maintain cache coherency. |
216 | */ |
217 | if (call->server) { |
218 | trace_afs_server(server_debug_id: call->server->debug_id, |
219 | ref: refcount_read(r: &call->server->ref), |
220 | active: atomic_read(v: &call->server->active), |
221 | reason: afs_server_trace_callback); |
222 | afs_break_callbacks(call->server, call->count, call->request); |
223 | } |
224 | |
225 | afs_send_empty_reply(call); |
226 | afs_put_call(call); |
227 | _leave("" ); |
228 | } |
229 | |
230 | /* |
231 | * deliver request data to a CB.CallBack call |
232 | */ |
233 | static int afs_deliver_cb_callback(struct afs_call *call) |
234 | { |
235 | struct afs_callback_break *cb; |
236 | __be32 *bp; |
237 | int ret, loop; |
238 | |
239 | _enter("{%u}" , call->unmarshall); |
240 | |
241 | switch (call->unmarshall) { |
242 | case 0: |
243 | afs_extract_to_tmp(call); |
244 | call->unmarshall++; |
245 | |
246 | /* extract the FID array and its count in two steps */ |
247 | fallthrough; |
248 | case 1: |
249 | _debug("extract FID count" ); |
250 | ret = afs_extract_data(call, true); |
251 | if (ret < 0) |
252 | return ret; |
253 | |
254 | call->count = ntohl(call->tmp); |
255 | _debug("FID count: %u" , call->count); |
256 | if (call->count > AFSCBMAX) |
257 | return afs_protocol_error(call, afs_eproto_cb_fid_count); |
258 | |
259 | call->buffer = kmalloc(array3_size(call->count, 3, 4), |
260 | GFP_KERNEL); |
261 | if (!call->buffer) |
262 | return -ENOMEM; |
263 | afs_extract_to_buf(call, size: call->count * 3 * 4); |
264 | call->unmarshall++; |
265 | |
266 | fallthrough; |
267 | case 2: |
268 | _debug("extract FID array" ); |
269 | ret = afs_extract_data(call, true); |
270 | if (ret < 0) |
271 | return ret; |
272 | |
273 | _debug("unmarshall FID array" ); |
274 | call->request = kcalloc(n: call->count, |
275 | size: sizeof(struct afs_callback_break), |
276 | GFP_KERNEL); |
277 | if (!call->request) |
278 | return -ENOMEM; |
279 | |
280 | cb = call->request; |
281 | bp = call->buffer; |
282 | for (loop = call->count; loop > 0; loop--, cb++) { |
283 | cb->fid.vid = ntohl(*bp++); |
284 | cb->fid.vnode = ntohl(*bp++); |
285 | cb->fid.unique = ntohl(*bp++); |
286 | } |
287 | |
288 | afs_extract_to_tmp(call); |
289 | call->unmarshall++; |
290 | |
291 | /* extract the callback array and its count in two steps */ |
292 | fallthrough; |
293 | case 3: |
294 | _debug("extract CB count" ); |
295 | ret = afs_extract_data(call, true); |
296 | if (ret < 0) |
297 | return ret; |
298 | |
299 | call->count2 = ntohl(call->tmp); |
300 | _debug("CB count: %u" , call->count2); |
301 | if (call->count2 != call->count && call->count2 != 0) |
302 | return afs_protocol_error(call, afs_eproto_cb_count); |
303 | call->iter = &call->def_iter; |
304 | iov_iter_discard(i: &call->def_iter, ITER_DEST, count: call->count2 * 3 * 4); |
305 | call->unmarshall++; |
306 | |
307 | fallthrough; |
308 | case 4: |
309 | _debug("extract discard %zu/%u" , |
310 | iov_iter_count(call->iter), call->count2 * 3 * 4); |
311 | |
312 | ret = afs_extract_data(call, false); |
313 | if (ret < 0) |
314 | return ret; |
315 | |
316 | call->unmarshall++; |
317 | fallthrough; |
318 | |
319 | case 5: |
320 | break; |
321 | } |
322 | |
323 | if (!afs_check_call_state(call, state: AFS_CALL_SV_REPLYING)) |
324 | return afs_io_error(call, where: afs_io_error_cm_reply); |
325 | |
326 | /* we'll need the file server record as that tells us which set of |
327 | * vnodes to operate upon */ |
328 | return afs_find_cm_server_by_peer(call); |
329 | } |
330 | |
331 | /* |
332 | * allow the fileserver to request callback state (re-)initialisation |
333 | */ |
334 | static void SRXAFSCB_InitCallBackState(struct work_struct *work) |
335 | { |
336 | struct afs_call *call = container_of(work, struct afs_call, work); |
337 | |
338 | _enter("{%p}" , call->server); |
339 | |
340 | if (call->server) |
341 | afs_init_callback_state(call->server); |
342 | afs_send_empty_reply(call); |
343 | afs_put_call(call); |
344 | _leave("" ); |
345 | } |
346 | |
347 | /* |
348 | * deliver request data to a CB.InitCallBackState call |
349 | */ |
350 | static int afs_deliver_cb_init_call_back_state(struct afs_call *call) |
351 | { |
352 | int ret; |
353 | |
354 | _enter("" ); |
355 | |
356 | afs_extract_discard(call, size: 0); |
357 | ret = afs_extract_data(call, false); |
358 | if (ret < 0) |
359 | return ret; |
360 | |
361 | /* we'll need the file server record as that tells us which set of |
362 | * vnodes to operate upon */ |
363 | return afs_find_cm_server_by_peer(call); |
364 | } |
365 | |
366 | /* |
367 | * deliver request data to a CB.InitCallBackState3 call |
368 | */ |
369 | static int afs_deliver_cb_init_call_back_state3(struct afs_call *call) |
370 | { |
371 | struct afs_uuid *r; |
372 | unsigned loop; |
373 | __be32 *b; |
374 | int ret; |
375 | |
376 | _enter("" ); |
377 | |
378 | _enter("{%u}" , call->unmarshall); |
379 | |
380 | switch (call->unmarshall) { |
381 | case 0: |
382 | call->buffer = kmalloc_array(n: 11, size: sizeof(__be32), GFP_KERNEL); |
383 | if (!call->buffer) |
384 | return -ENOMEM; |
385 | afs_extract_to_buf(call, size: 11 * sizeof(__be32)); |
386 | call->unmarshall++; |
387 | |
388 | fallthrough; |
389 | case 1: |
390 | _debug("extract UUID" ); |
391 | ret = afs_extract_data(call, false); |
392 | switch (ret) { |
393 | case 0: break; |
394 | case -EAGAIN: return 0; |
395 | default: return ret; |
396 | } |
397 | |
398 | _debug("unmarshall UUID" ); |
399 | call->request = kmalloc(size: sizeof(struct afs_uuid), GFP_KERNEL); |
400 | if (!call->request) |
401 | return -ENOMEM; |
402 | |
403 | b = call->buffer; |
404 | r = call->request; |
405 | r->time_low = b[0]; |
406 | r->time_mid = htons(ntohl(b[1])); |
407 | r->time_hi_and_version = htons(ntohl(b[2])); |
408 | r->clock_seq_hi_and_reserved = ntohl(b[3]); |
409 | r->clock_seq_low = ntohl(b[4]); |
410 | |
411 | for (loop = 0; loop < 6; loop++) |
412 | r->node[loop] = ntohl(b[loop + 5]); |
413 | |
414 | call->unmarshall++; |
415 | fallthrough; |
416 | |
417 | case 2: |
418 | break; |
419 | } |
420 | |
421 | if (!afs_check_call_state(call, state: AFS_CALL_SV_REPLYING)) |
422 | return afs_io_error(call, where: afs_io_error_cm_reply); |
423 | |
424 | /* we'll need the file server record as that tells us which set of |
425 | * vnodes to operate upon */ |
426 | return afs_find_cm_server_by_uuid(call, uuid: call->request); |
427 | } |
428 | |
429 | /* |
430 | * allow the fileserver to see if the cache manager is still alive |
431 | */ |
432 | static void SRXAFSCB_Probe(struct work_struct *work) |
433 | { |
434 | struct afs_call *call = container_of(work, struct afs_call, work); |
435 | |
436 | _enter("" ); |
437 | afs_send_empty_reply(call); |
438 | afs_put_call(call); |
439 | _leave("" ); |
440 | } |
441 | |
442 | /* |
443 | * deliver request data to a CB.Probe call |
444 | */ |
445 | static int afs_deliver_cb_probe(struct afs_call *call) |
446 | { |
447 | int ret; |
448 | |
449 | _enter("" ); |
450 | |
451 | afs_extract_discard(call, size: 0); |
452 | ret = afs_extract_data(call, false); |
453 | if (ret < 0) |
454 | return ret; |
455 | |
456 | if (!afs_check_call_state(call, state: AFS_CALL_SV_REPLYING)) |
457 | return afs_io_error(call, where: afs_io_error_cm_reply); |
458 | return afs_find_cm_server_by_peer(call); |
459 | } |
460 | |
461 | /* |
462 | * Allow the fileserver to quickly find out if the cache manager has been |
463 | * rebooted. |
464 | */ |
465 | static void SRXAFSCB_ProbeUuid(struct work_struct *work) |
466 | { |
467 | struct afs_call *call = container_of(work, struct afs_call, work); |
468 | struct afs_uuid *r = call->request; |
469 | |
470 | _enter("" ); |
471 | |
472 | if (memcmp(p: r, q: &call->net->uuid, size: sizeof(call->net->uuid)) == 0) |
473 | afs_send_empty_reply(call); |
474 | else |
475 | afs_abort_service_call(call, abort_code: 1, error: 1, why: afs_abort_probeuuid_negative); |
476 | |
477 | afs_put_call(call); |
478 | _leave("" ); |
479 | } |
480 | |
481 | /* |
482 | * deliver request data to a CB.ProbeUuid call |
483 | */ |
484 | static int afs_deliver_cb_probe_uuid(struct afs_call *call) |
485 | { |
486 | struct afs_uuid *r; |
487 | unsigned loop; |
488 | __be32 *b; |
489 | int ret; |
490 | |
491 | _enter("{%u}" , call->unmarshall); |
492 | |
493 | switch (call->unmarshall) { |
494 | case 0: |
495 | call->buffer = kmalloc_array(n: 11, size: sizeof(__be32), GFP_KERNEL); |
496 | if (!call->buffer) |
497 | return -ENOMEM; |
498 | afs_extract_to_buf(call, size: 11 * sizeof(__be32)); |
499 | call->unmarshall++; |
500 | |
501 | fallthrough; |
502 | case 1: |
503 | _debug("extract UUID" ); |
504 | ret = afs_extract_data(call, false); |
505 | switch (ret) { |
506 | case 0: break; |
507 | case -EAGAIN: return 0; |
508 | default: return ret; |
509 | } |
510 | |
511 | _debug("unmarshall UUID" ); |
512 | call->request = kmalloc(size: sizeof(struct afs_uuid), GFP_KERNEL); |
513 | if (!call->request) |
514 | return -ENOMEM; |
515 | |
516 | b = call->buffer; |
517 | r = call->request; |
518 | r->time_low = b[0]; |
519 | r->time_mid = htons(ntohl(b[1])); |
520 | r->time_hi_and_version = htons(ntohl(b[2])); |
521 | r->clock_seq_hi_and_reserved = ntohl(b[3]); |
522 | r->clock_seq_low = ntohl(b[4]); |
523 | |
524 | for (loop = 0; loop < 6; loop++) |
525 | r->node[loop] = ntohl(b[loop + 5]); |
526 | |
527 | call->unmarshall++; |
528 | fallthrough; |
529 | |
530 | case 2: |
531 | break; |
532 | } |
533 | |
534 | if (!afs_check_call_state(call, state: AFS_CALL_SV_REPLYING)) |
535 | return afs_io_error(call, where: afs_io_error_cm_reply); |
536 | return afs_find_cm_server_by_peer(call); |
537 | } |
538 | |
539 | /* |
540 | * allow the fileserver to ask about the cache manager's capabilities |
541 | */ |
542 | static void SRXAFSCB_TellMeAboutYourself(struct work_struct *work) |
543 | { |
544 | struct afs_call *call = container_of(work, struct afs_call, work); |
545 | int loop; |
546 | |
547 | struct { |
548 | struct /* InterfaceAddr */ { |
549 | __be32 nifs; |
550 | __be32 uuid[11]; |
551 | __be32 ifaddr[32]; |
552 | __be32 netmask[32]; |
553 | __be32 mtu[32]; |
554 | } ia; |
555 | struct /* Capabilities */ { |
556 | __be32 capcount; |
557 | __be32 caps[1]; |
558 | } cap; |
559 | } reply; |
560 | |
561 | _enter("" ); |
562 | |
563 | memset(&reply, 0, sizeof(reply)); |
564 | |
565 | reply.ia.uuid[0] = call->net->uuid.time_low; |
566 | reply.ia.uuid[1] = htonl(ntohs(call->net->uuid.time_mid)); |
567 | reply.ia.uuid[2] = htonl(ntohs(call->net->uuid.time_hi_and_version)); |
568 | reply.ia.uuid[3] = htonl((s8) call->net->uuid.clock_seq_hi_and_reserved); |
569 | reply.ia.uuid[4] = htonl((s8) call->net->uuid.clock_seq_low); |
570 | for (loop = 0; loop < 6; loop++) |
571 | reply.ia.uuid[loop + 5] = htonl((s8) call->net->uuid.node[loop]); |
572 | |
573 | reply.cap.capcount = htonl(1); |
574 | reply.cap.caps[0] = htonl(AFS_CAP_ERROR_TRANSLATION); |
575 | afs_send_simple_reply(call, &reply, sizeof(reply)); |
576 | afs_put_call(call); |
577 | _leave("" ); |
578 | } |
579 | |
580 | /* |
581 | * deliver request data to a CB.TellMeAboutYourself call |
582 | */ |
583 | static int afs_deliver_cb_tell_me_about_yourself(struct afs_call *call) |
584 | { |
585 | int ret; |
586 | |
587 | _enter("" ); |
588 | |
589 | afs_extract_discard(call, size: 0); |
590 | ret = afs_extract_data(call, false); |
591 | if (ret < 0) |
592 | return ret; |
593 | |
594 | if (!afs_check_call_state(call, state: AFS_CALL_SV_REPLYING)) |
595 | return afs_io_error(call, where: afs_io_error_cm_reply); |
596 | return afs_find_cm_server_by_peer(call); |
597 | } |
598 | |
599 | /* |
600 | * deliver request data to a YFS CB.CallBack call |
601 | */ |
602 | static int afs_deliver_yfs_cb_callback(struct afs_call *call) |
603 | { |
604 | struct afs_callback_break *cb; |
605 | struct yfs_xdr_YFSFid *bp; |
606 | size_t size; |
607 | int ret, loop; |
608 | |
609 | _enter("{%u}" , call->unmarshall); |
610 | |
611 | switch (call->unmarshall) { |
612 | case 0: |
613 | afs_extract_to_tmp(call); |
614 | call->unmarshall++; |
615 | |
616 | /* extract the FID array and its count in two steps */ |
617 | fallthrough; |
618 | case 1: |
619 | _debug("extract FID count" ); |
620 | ret = afs_extract_data(call, true); |
621 | if (ret < 0) |
622 | return ret; |
623 | |
624 | call->count = ntohl(call->tmp); |
625 | _debug("FID count: %u" , call->count); |
626 | if (call->count > YFSCBMAX) |
627 | return afs_protocol_error(call, afs_eproto_cb_fid_count); |
628 | |
629 | size = array_size(call->count, sizeof(struct yfs_xdr_YFSFid)); |
630 | call->buffer = kmalloc(size, GFP_KERNEL); |
631 | if (!call->buffer) |
632 | return -ENOMEM; |
633 | afs_extract_to_buf(call, size); |
634 | call->unmarshall++; |
635 | |
636 | fallthrough; |
637 | case 2: |
638 | _debug("extract FID array" ); |
639 | ret = afs_extract_data(call, false); |
640 | if (ret < 0) |
641 | return ret; |
642 | |
643 | _debug("unmarshall FID array" ); |
644 | call->request = kcalloc(n: call->count, |
645 | size: sizeof(struct afs_callback_break), |
646 | GFP_KERNEL); |
647 | if (!call->request) |
648 | return -ENOMEM; |
649 | |
650 | cb = call->request; |
651 | bp = call->buffer; |
652 | for (loop = call->count; loop > 0; loop--, cb++) { |
653 | cb->fid.vid = xdr_to_u64(x: bp->volume); |
654 | cb->fid.vnode = xdr_to_u64(x: bp->vnode.lo); |
655 | cb->fid.vnode_hi = ntohl(bp->vnode.hi); |
656 | cb->fid.unique = ntohl(bp->vnode.unique); |
657 | bp++; |
658 | } |
659 | |
660 | afs_extract_to_tmp(call); |
661 | call->unmarshall++; |
662 | fallthrough; |
663 | |
664 | case 3: |
665 | break; |
666 | } |
667 | |
668 | if (!afs_check_call_state(call, state: AFS_CALL_SV_REPLYING)) |
669 | return afs_io_error(call, where: afs_io_error_cm_reply); |
670 | |
671 | /* We'll need the file server record as that tells us which set of |
672 | * vnodes to operate upon. |
673 | */ |
674 | return afs_find_cm_server_by_peer(call); |
675 | } |
676 | |