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 */
afs_cm_incoming_call(struct afs_call * call)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 * Clean up a cache manager call.
143 */
afs_cm_destructor(struct afs_call * call)144 static void afs_cm_destructor(struct afs_call *call)
145 {
146 kfree(call->buffer);
147 call->buffer = NULL;
148 }
149
150 /*
151 * Abort a service call from within an action function.
152 */
afs_abort_service_call(struct afs_call * call,u32 abort_code,int error,enum rxrpc_abort_reason why)153 static void afs_abort_service_call(struct afs_call *call, u32 abort_code, int error,
154 enum rxrpc_abort_reason why)
155 {
156 rxrpc_kernel_abort_call(call->net->socket, call->rxcall,
157 abort_code, error, why);
158 afs_set_call_complete(call, error, 0);
159 }
160
161 /*
162 * The server supplied a list of callbacks that it wanted to break.
163 */
SRXAFSCB_CallBack(struct work_struct * work)164 static void SRXAFSCB_CallBack(struct work_struct *work)
165 {
166 struct afs_call *call = container_of(work, struct afs_call, work);
167
168 _enter("");
169
170 /* We need to break the callbacks before sending the reply as the
171 * server holds up change visibility till it receives our reply so as
172 * to maintain cache coherency.
173 */
174 if (call->server) {
175 trace_afs_server(call->server->debug_id,
176 refcount_read(&call->server->ref),
177 atomic_read(&call->server->active),
178 afs_server_trace_callback);
179 afs_break_callbacks(call->server, call->count, call->request);
180 }
181
182 afs_send_empty_reply(call);
183 afs_put_call(call);
184 _leave("");
185 }
186
187 /*
188 * deliver request data to a CB.CallBack call
189 */
afs_deliver_cb_callback(struct afs_call * call)190 static int afs_deliver_cb_callback(struct afs_call *call)
191 {
192 struct afs_callback_break *cb;
193 __be32 *bp;
194 int ret, loop;
195
196 _enter("{%u}", call->unmarshall);
197
198 switch (call->unmarshall) {
199 case 0:
200 afs_extract_to_tmp(call);
201 call->unmarshall++;
202
203 /* extract the FID array and its count in two steps */
204 fallthrough;
205 case 1:
206 _debug("extract FID count");
207 ret = afs_extract_data(call, true);
208 if (ret < 0)
209 return ret;
210
211 call->count = ntohl(call->tmp);
212 _debug("FID count: %u", call->count);
213 if (call->count > AFSCBMAX)
214 return afs_protocol_error(call, afs_eproto_cb_fid_count);
215
216 call->buffer = kmalloc(array3_size(call->count, 3, 4),
217 GFP_KERNEL);
218 if (!call->buffer)
219 return -ENOMEM;
220 afs_extract_to_buf(call, call->count * 3 * 4);
221 call->unmarshall++;
222
223 fallthrough;
224 case 2:
225 _debug("extract FID array");
226 ret = afs_extract_data(call, true);
227 if (ret < 0)
228 return ret;
229
230 _debug("unmarshall FID array");
231 call->request = kzalloc_objs(struct afs_callback_break,
232 call->count);
233 if (!call->request)
234 return -ENOMEM;
235
236 cb = call->request;
237 bp = call->buffer;
238 for (loop = call->count; loop > 0; loop--, cb++) {
239 cb->fid.vid = ntohl(*bp++);
240 cb->fid.vnode = ntohl(*bp++);
241 cb->fid.unique = ntohl(*bp++);
242 }
243
244 afs_extract_to_tmp(call);
245 call->unmarshall++;
246
247 /* extract the callback array and its count in two steps */
248 fallthrough;
249 case 3:
250 _debug("extract CB count");
251 ret = afs_extract_data(call, true);
252 if (ret < 0)
253 return ret;
254
255 call->count2 = ntohl(call->tmp);
256 _debug("CB count: %u", call->count2);
257 if (call->count2 != call->count && call->count2 != 0)
258 return afs_protocol_error(call, afs_eproto_cb_count);
259 call->iter = &call->def_iter;
260 iov_iter_discard(&call->def_iter, ITER_DEST, call->count2 * 3 * 4);
261 call->unmarshall++;
262
263 fallthrough;
264 case 4:
265 _debug("extract discard %zu/%u",
266 iov_iter_count(call->iter), call->count2 * 3 * 4);
267
268 ret = afs_extract_data(call, false);
269 if (ret < 0)
270 return ret;
271
272 call->unmarshall++;
273 fallthrough;
274
275 case 5:
276 break;
277 }
278
279 if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING))
280 return afs_io_error(call, afs_io_error_cm_reply);
281 return 0;
282 }
283
284 /*
285 * allow the fileserver to request callback state (re-)initialisation
286 */
SRXAFSCB_InitCallBackState(struct work_struct * work)287 static void SRXAFSCB_InitCallBackState(struct work_struct *work)
288 {
289 struct afs_call *call = container_of(work, struct afs_call, work);
290
291 _enter("{%p}", call->server);
292
293 if (call->server)
294 afs_init_callback_state(call->server);
295 afs_send_empty_reply(call);
296 afs_put_call(call);
297 _leave("");
298 }
299
300 /*
301 * deliver request data to a CB.InitCallBackState call
302 */
afs_deliver_cb_init_call_back_state(struct afs_call * call)303 static int afs_deliver_cb_init_call_back_state(struct afs_call *call)
304 {
305 _enter("");
306
307 afs_extract_discard(call, 0);
308 return afs_extract_data(call, false);
309 }
310
311 /*
312 * deliver request data to a CB.InitCallBackState3 call
313 */
afs_deliver_cb_init_call_back_state3(struct afs_call * call)314 static int afs_deliver_cb_init_call_back_state3(struct afs_call *call)
315 {
316 struct afs_uuid *r;
317 unsigned loop;
318 __be32 *b;
319 int ret;
320
321 _enter("{%u}", call->unmarshall);
322
323 switch (call->unmarshall) {
324 case 0:
325 call->buffer = kmalloc_array(11, sizeof(__be32), GFP_KERNEL);
326 if (!call->buffer)
327 return -ENOMEM;
328 afs_extract_to_buf(call, 11 * sizeof(__be32));
329 call->unmarshall++;
330
331 fallthrough;
332 case 1:
333 _debug("extract UUID");
334 ret = afs_extract_data(call, false);
335 switch (ret) {
336 case 0: break;
337 default: return ret;
338 }
339
340 _debug("unmarshall UUID");
341 call->request = kmalloc_obj(struct afs_uuid);
342 if (!call->request)
343 return -ENOMEM;
344
345 b = call->buffer;
346 r = call->request;
347 r->time_low = b[0];
348 r->time_mid = htons(ntohl(b[1]));
349 r->time_hi_and_version = htons(ntohl(b[2]));
350 r->clock_seq_hi_and_reserved = ntohl(b[3]);
351 r->clock_seq_low = ntohl(b[4]);
352
353 for (loop = 0; loop < 6; loop++)
354 r->node[loop] = ntohl(b[loop + 5]);
355
356 call->unmarshall++;
357 fallthrough;
358
359 case 2:
360 break;
361 }
362
363 if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING))
364 return afs_io_error(call, afs_io_error_cm_reply);
365
366 if (!call->server) {
367 trace_afs_cm_no_server_u(call, call->request);
368 return 0;
369 }
370
371 if (memcmp(call->request, &call->server->_uuid, sizeof(call->server->_uuid)) != 0) {
372 pr_notice("Callback UUID does not match fileserver UUID\n");
373 trace_afs_cm_no_server_u(call, call->request);
374 return 0;
375 }
376
377 return 0;
378 }
379
380 /*
381 * allow the fileserver to see if the cache manager is still alive
382 */
SRXAFSCB_Probe(struct work_struct * work)383 static void SRXAFSCB_Probe(struct work_struct *work)
384 {
385 struct afs_call *call = container_of(work, struct afs_call, work);
386
387 _enter("");
388 afs_send_empty_reply(call);
389 afs_put_call(call);
390 _leave("");
391 }
392
393 /*
394 * deliver request data to a CB.Probe call
395 */
afs_deliver_cb_probe(struct afs_call * call)396 static int afs_deliver_cb_probe(struct afs_call *call)
397 {
398 int ret;
399
400 _enter("");
401
402 afs_extract_discard(call, 0);
403 ret = afs_extract_data(call, false);
404 if (ret < 0)
405 return ret;
406
407 if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING))
408 return afs_io_error(call, afs_io_error_cm_reply);
409 return 0;
410 }
411
412 /*
413 * Allow the fileserver to quickly find out if the cache manager has been
414 * rebooted.
415 */
SRXAFSCB_ProbeUuid(struct work_struct * work)416 static void SRXAFSCB_ProbeUuid(struct work_struct *work)
417 {
418 struct afs_call *call = container_of(work, struct afs_call, work);
419 struct afs_uuid *r = call->request;
420
421 _enter("");
422
423 if (memcmp(r, &call->net->uuid, sizeof(call->net->uuid)) == 0)
424 afs_send_empty_reply(call);
425 else
426 afs_abort_service_call(call, 1, 1, afs_abort_probeuuid_negative);
427
428 afs_put_call(call);
429 _leave("");
430 }
431
432 /*
433 * deliver request data to a CB.ProbeUuid call
434 */
afs_deliver_cb_probe_uuid(struct afs_call * call)435 static int afs_deliver_cb_probe_uuid(struct afs_call *call)
436 {
437 struct afs_uuid *r;
438 unsigned loop;
439 __be32 *b;
440 int ret;
441
442 _enter("{%u}", call->unmarshall);
443
444 switch (call->unmarshall) {
445 case 0:
446 call->buffer = kmalloc_array(11, sizeof(__be32), GFP_KERNEL);
447 if (!call->buffer)
448 return -ENOMEM;
449 afs_extract_to_buf(call, 11 * sizeof(__be32));
450 call->unmarshall++;
451
452 fallthrough;
453 case 1:
454 _debug("extract UUID");
455 ret = afs_extract_data(call, false);
456 switch (ret) {
457 case 0: break;
458 default: return ret;
459 }
460
461 _debug("unmarshall UUID");
462 call->request = kmalloc_obj(struct afs_uuid);
463 if (!call->request)
464 return -ENOMEM;
465
466 b = call->buffer;
467 r = call->request;
468 r->time_low = b[0];
469 r->time_mid = htons(ntohl(b[1]));
470 r->time_hi_and_version = htons(ntohl(b[2]));
471 r->clock_seq_hi_and_reserved = ntohl(b[3]);
472 r->clock_seq_low = ntohl(b[4]);
473
474 for (loop = 0; loop < 6; loop++)
475 r->node[loop] = ntohl(b[loop + 5]);
476
477 call->unmarshall++;
478 fallthrough;
479
480 case 2:
481 break;
482 }
483
484 if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING))
485 return afs_io_error(call, afs_io_error_cm_reply);
486 return 0;
487 }
488
489 /*
490 * allow the fileserver to ask about the cache manager's capabilities
491 */
SRXAFSCB_TellMeAboutYourself(struct work_struct * work)492 static void SRXAFSCB_TellMeAboutYourself(struct work_struct *work)
493 {
494 struct afs_call *call = container_of(work, struct afs_call, work);
495 int loop;
496
497 struct {
498 struct /* InterfaceAddr */ {
499 __be32 nifs;
500 __be32 uuid[11];
501 __be32 ifaddr[32];
502 __be32 netmask[32];
503 __be32 mtu[32];
504 } ia;
505 struct /* Capabilities */ {
506 __be32 capcount;
507 __be32 caps[1];
508 } cap;
509 } reply;
510
511 _enter("");
512
513 memset(&reply, 0, sizeof(reply));
514
515 reply.ia.uuid[0] = call->net->uuid.time_low;
516 reply.ia.uuid[1] = htonl(ntohs(call->net->uuid.time_mid));
517 reply.ia.uuid[2] = htonl(ntohs(call->net->uuid.time_hi_and_version));
518 reply.ia.uuid[3] = htonl((s8) call->net->uuid.clock_seq_hi_and_reserved);
519 reply.ia.uuid[4] = htonl((s8) call->net->uuid.clock_seq_low);
520 for (loop = 0; loop < 6; loop++)
521 reply.ia.uuid[loop + 5] = htonl((s8) call->net->uuid.node[loop]);
522
523 reply.cap.capcount = htonl(1);
524 reply.cap.caps[0] = htonl(AFS_CAP_ERROR_TRANSLATION);
525 afs_send_simple_reply(call, &reply, sizeof(reply));
526 afs_put_call(call);
527 _leave("");
528 }
529
530 /*
531 * deliver request data to a CB.TellMeAboutYourself call
532 */
afs_deliver_cb_tell_me_about_yourself(struct afs_call * call)533 static int afs_deliver_cb_tell_me_about_yourself(struct afs_call *call)
534 {
535 int ret;
536
537 _enter("");
538
539 afs_extract_discard(call, 0);
540 ret = afs_extract_data(call, false);
541 if (ret < 0)
542 return ret;
543
544 if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING))
545 return afs_io_error(call, afs_io_error_cm_reply);
546 return 0;
547 }
548
549 /*
550 * deliver request data to a YFS CB.CallBack call
551 */
afs_deliver_yfs_cb_callback(struct afs_call * call)552 static int afs_deliver_yfs_cb_callback(struct afs_call *call)
553 {
554 struct afs_callback_break *cb;
555 struct yfs_xdr_YFSFid *bp;
556 size_t size;
557 int ret, loop;
558
559 _enter("{%u}", call->unmarshall);
560
561 switch (call->unmarshall) {
562 case 0:
563 afs_extract_to_tmp(call);
564 call->unmarshall++;
565
566 /* extract the FID array and its count in two steps */
567 fallthrough;
568 case 1:
569 _debug("extract FID count");
570 ret = afs_extract_data(call, true);
571 if (ret < 0)
572 return ret;
573
574 call->count = ntohl(call->tmp);
575 _debug("FID count: %u", call->count);
576 if (call->count > YFSCBMAX)
577 return afs_protocol_error(call, afs_eproto_cb_fid_count);
578
579 size = array_size(call->count, sizeof(struct yfs_xdr_YFSFid));
580 call->buffer = kmalloc(size, GFP_KERNEL);
581 if (!call->buffer)
582 return -ENOMEM;
583 afs_extract_to_buf(call, size);
584 call->unmarshall++;
585
586 fallthrough;
587 case 2:
588 _debug("extract FID array");
589 ret = afs_extract_data(call, false);
590 if (ret < 0)
591 return ret;
592
593 _debug("unmarshall FID array");
594 call->request = kzalloc_objs(struct afs_callback_break,
595 call->count);
596 if (!call->request)
597 return -ENOMEM;
598
599 cb = call->request;
600 bp = call->buffer;
601 for (loop = call->count; loop > 0; loop--, cb++) {
602 cb->fid.vid = xdr_to_u64(bp->volume);
603 cb->fid.vnode = xdr_to_u64(bp->vnode.lo);
604 cb->fid.vnode_hi = ntohl(bp->vnode.hi);
605 cb->fid.unique = ntohl(bp->vnode.unique);
606 bp++;
607 }
608
609 afs_extract_to_tmp(call);
610 call->unmarshall++;
611 fallthrough;
612
613 case 3:
614 break;
615 }
616
617 if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING))
618 return afs_io_error(call, afs_io_error_cm_reply);
619 return 0;
620 }
621