1 /* AFS Cache Manager Service
3 * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
12 #include <linux/module.h>
13 #include <linux/init.h>
14 #include <linux/slab.h>
15 #include <linux/sched.h>
20 static int afs_deliver_cb_init_call_back_state(struct afs_call
*);
21 static int afs_deliver_cb_init_call_back_state3(struct afs_call
*);
22 static int afs_deliver_cb_probe(struct afs_call
*);
23 static int afs_deliver_cb_callback(struct afs_call
*);
24 static int afs_deliver_cb_probe_uuid(struct afs_call
*);
25 static int afs_deliver_cb_tell_me_about_yourself(struct afs_call
*);
26 static void afs_cm_destructor(struct afs_call
*);
27 static void SRXAFSCB_CallBack(struct work_struct
*);
28 static void SRXAFSCB_InitCallBackState(struct work_struct
*);
29 static void SRXAFSCB_Probe(struct work_struct
*);
30 static void SRXAFSCB_ProbeUuid(struct work_struct
*);
31 static void SRXAFSCB_TellMeAboutYourself(struct work_struct
*);
33 #define CM_NAME(name) \
34 const char afs_SRXCB##name##_name[] __tracepoint_string = \
38 * CB.CallBack operation type
40 static CM_NAME(CallBack
);
41 static const struct afs_call_type afs_SRXCBCallBack
= {
42 .name
= afs_SRXCBCallBack_name
,
43 .deliver
= afs_deliver_cb_callback
,
44 .abort_to_error
= afs_abort_to_error
,
45 .destructor
= afs_cm_destructor
,
46 .work
= SRXAFSCB_CallBack
,
50 * CB.InitCallBackState operation type
52 static CM_NAME(InitCallBackState
);
53 static const struct afs_call_type afs_SRXCBInitCallBackState
= {
54 .name
= afs_SRXCBInitCallBackState_name
,
55 .deliver
= afs_deliver_cb_init_call_back_state
,
56 .abort_to_error
= afs_abort_to_error
,
57 .destructor
= afs_cm_destructor
,
58 .work
= SRXAFSCB_InitCallBackState
,
62 * CB.InitCallBackState3 operation type
64 static CM_NAME(InitCallBackState3
);
65 static const struct afs_call_type afs_SRXCBInitCallBackState3
= {
66 .name
= afs_SRXCBInitCallBackState3_name
,
67 .deliver
= afs_deliver_cb_init_call_back_state3
,
68 .abort_to_error
= afs_abort_to_error
,
69 .destructor
= afs_cm_destructor
,
70 .work
= SRXAFSCB_InitCallBackState
,
74 * CB.Probe operation type
76 static CM_NAME(Probe
);
77 static const struct afs_call_type afs_SRXCBProbe
= {
78 .name
= afs_SRXCBProbe_name
,
79 .deliver
= afs_deliver_cb_probe
,
80 .abort_to_error
= afs_abort_to_error
,
81 .destructor
= afs_cm_destructor
,
82 .work
= SRXAFSCB_Probe
,
86 * CB.ProbeUuid operation type
88 static CM_NAME(ProbeUuid
);
89 static const struct afs_call_type afs_SRXCBProbeUuid
= {
90 .name
= afs_SRXCBProbeUuid_name
,
91 .deliver
= afs_deliver_cb_probe_uuid
,
92 .abort_to_error
= afs_abort_to_error
,
93 .destructor
= afs_cm_destructor
,
94 .work
= SRXAFSCB_ProbeUuid
,
98 * CB.TellMeAboutYourself operation type
100 static CM_NAME(TellMeAboutYourself
);
101 static const struct afs_call_type afs_SRXCBTellMeAboutYourself
= {
102 .name
= afs_SRXCBTellMeAboutYourself_name
,
103 .deliver
= afs_deliver_cb_tell_me_about_yourself
,
104 .abort_to_error
= afs_abort_to_error
,
105 .destructor
= afs_cm_destructor
,
106 .work
= SRXAFSCB_TellMeAboutYourself
,
110 * route an incoming cache manager call
111 * - return T if supported, F if not
113 bool afs_cm_incoming_call(struct afs_call
*call
)
115 _enter("{CB.OP %u}", call
->operation_ID
);
117 switch (call
->operation_ID
) {
119 call
->type
= &afs_SRXCBCallBack
;
121 case CBInitCallBackState
:
122 call
->type
= &afs_SRXCBInitCallBackState
;
124 case CBInitCallBackState3
:
125 call
->type
= &afs_SRXCBInitCallBackState3
;
128 call
->type
= &afs_SRXCBProbe
;
130 case CBTellMeAboutYourself
:
131 call
->type
= &afs_SRXCBTellMeAboutYourself
;
139 * clean up a cache manager call
141 static void afs_cm_destructor(struct afs_call
*call
)
145 /* Break the callbacks here so that we do it after the final ACK is
146 * received. The step number here must match the final number in
147 * afs_deliver_cb_callback().
149 if (call
->unmarshall
== 5) {
150 ASSERT(call
->server
&& call
->count
&& call
->request
);
151 afs_break_callbacks(call
->server
, call
->count
, call
->request
);
154 afs_put_server(call
->server
);
161 * allow the fileserver to see if the cache manager is still alive
163 static void SRXAFSCB_CallBack(struct work_struct
*work
)
165 struct afs_call
*call
= container_of(work
, struct afs_call
, work
);
169 /* be sure to send the reply *before* attempting to spam the AFS server
170 * with FSFetchStatus requests on the vnodes with broken callbacks lest
171 * the AFS server get into a vicious cycle of trying to break further
172 * callbacks because it hadn't received completion of the CBCallBack op
174 afs_send_empty_reply(call
);
176 afs_break_callbacks(call
->server
, call
->count
, call
->request
);
182 * deliver request data to a CB.CallBack call
184 static int afs_deliver_cb_callback(struct afs_call
*call
)
186 struct sockaddr_rxrpc srx
;
187 struct afs_callback
*cb
;
188 struct afs_server
*server
;
192 _enter("{%u}", call
->unmarshall
);
194 switch (call
->unmarshall
) {
196 rxrpc_kernel_get_peer(afs_socket
, call
->rxcall
, &srx
);
200 /* extract the FID array and its count in two steps */
202 _debug("extract FID count");
203 ret
= afs_extract_data(call
, &call
->tmp
, 4, true);
207 call
->count
= ntohl(call
->tmp
);
208 _debug("FID count: %u", call
->count
);
209 if (call
->count
> AFSCBMAX
)
212 call
->buffer
= kmalloc(call
->count
* 3 * 4, GFP_KERNEL
);
219 _debug("extract FID array");
220 ret
= afs_extract_data(call
, call
->buffer
,
221 call
->count
* 3 * 4, true);
225 _debug("unmarshall FID array");
226 call
->request
= kcalloc(call
->count
,
227 sizeof(struct afs_callback
),
234 for (loop
= call
->count
; loop
> 0; loop
--, cb
++) {
235 cb
->fid
.vid
= ntohl(*bp
++);
236 cb
->fid
.vnode
= ntohl(*bp
++);
237 cb
->fid
.unique
= ntohl(*bp
++);
238 cb
->type
= AFSCM_CB_UNTYPED
;
244 /* extract the callback array and its count in two steps */
246 _debug("extract CB count");
247 ret
= afs_extract_data(call
, &call
->tmp
, 4, true);
251 call
->count2
= ntohl(call
->tmp
);
252 _debug("CB count: %u", call
->count2
);
253 if (call
->count2
!= call
->count
&& call
->count2
!= 0)
259 _debug("extract CB array");
260 ret
= afs_extract_data(call
, call
->buffer
,
261 call
->count2
* 3 * 4, false);
265 _debug("unmarshall CB array");
268 for (loop
= call
->count2
; loop
> 0; loop
--, cb
++) {
269 cb
->version
= ntohl(*bp
++);
270 cb
->expiry
= ntohl(*bp
++);
271 cb
->type
= ntohl(*bp
++);
277 /* Record that the message was unmarshalled successfully so
278 * that the call destructor can know do the callback breaking
279 * work, even if the final ACK isn't received.
281 * If the step number changes, then afs_cm_destructor() must be
289 call
->state
= AFS_CALL_REPLYING
;
291 /* we'll need the file server record as that tells us which set of
292 * vnodes to operate upon */
293 server
= afs_find_server(&srx
);
296 call
->server
= server
;
298 return afs_queue_call_work(call
);
302 * allow the fileserver to request callback state (re-)initialisation
304 static void SRXAFSCB_InitCallBackState(struct work_struct
*work
)
306 struct afs_call
*call
= container_of(work
, struct afs_call
, work
);
308 _enter("{%p}", call
->server
);
310 afs_init_callback_state(call
->server
);
311 afs_send_empty_reply(call
);
317 * deliver request data to a CB.InitCallBackState call
319 static int afs_deliver_cb_init_call_back_state(struct afs_call
*call
)
321 struct sockaddr_rxrpc srx
;
322 struct afs_server
*server
;
327 rxrpc_kernel_get_peer(afs_socket
, call
->rxcall
, &srx
);
329 ret
= afs_extract_data(call
, NULL
, 0, false);
333 /* no unmarshalling required */
334 call
->state
= AFS_CALL_REPLYING
;
336 /* we'll need the file server record as that tells us which set of
337 * vnodes to operate upon */
338 server
= afs_find_server(&srx
);
341 call
->server
= server
;
343 return afs_queue_call_work(call
);
347 * deliver request data to a CB.InitCallBackState3 call
349 static int afs_deliver_cb_init_call_back_state3(struct afs_call
*call
)
351 struct sockaddr_rxrpc srx
;
352 struct afs_server
*server
;
360 rxrpc_kernel_get_peer(afs_socket
, call
->rxcall
, &srx
);
362 _enter("{%u}", call
->unmarshall
);
364 switch (call
->unmarshall
) {
367 call
->buffer
= kmalloc(11 * sizeof(__be32
), GFP_KERNEL
);
373 _debug("extract UUID");
374 ret
= afs_extract_data(call
, call
->buffer
,
375 11 * sizeof(__be32
), false);
378 case -EAGAIN
: return 0;
382 _debug("unmarshall UUID");
383 call
->request
= kmalloc(sizeof(struct uuid_v1
), GFP_KERNEL
);
390 r
->time_mid
= htons(ntohl(b
[1]));
391 r
->time_hi_and_version
= htons(ntohl(b
[2]));
392 r
->clock_seq_hi_and_reserved
= ntohl(b
[3]);
393 r
->clock_seq_low
= ntohl(b
[4]);
395 for (loop
= 0; loop
< 6; loop
++)
396 r
->node
[loop
] = ntohl(b
[loop
+ 5]);
405 /* no unmarshalling required */
406 call
->state
= AFS_CALL_REPLYING
;
408 /* we'll need the file server record as that tells us which set of
409 * vnodes to operate upon */
410 server
= afs_find_server(&srx
);
413 call
->server
= server
;
415 return afs_queue_call_work(call
);
419 * allow the fileserver to see if the cache manager is still alive
421 static void SRXAFSCB_Probe(struct work_struct
*work
)
423 struct afs_call
*call
= container_of(work
, struct afs_call
, work
);
426 afs_send_empty_reply(call
);
432 * deliver request data to a CB.Probe call
434 static int afs_deliver_cb_probe(struct afs_call
*call
)
440 ret
= afs_extract_data(call
, NULL
, 0, false);
444 /* no unmarshalling required */
445 call
->state
= AFS_CALL_REPLYING
;
447 return afs_queue_call_work(call
);
451 * allow the fileserver to quickly find out if the fileserver has been rebooted
453 static void SRXAFSCB_ProbeUuid(struct work_struct
*work
)
455 struct afs_call
*call
= container_of(work
, struct afs_call
, work
);
456 struct uuid_v1
*r
= call
->request
;
464 if (memcmp(r
, &afs_uuid
, sizeof(afs_uuid
)) == 0)
465 reply
.match
= htonl(0);
467 reply
.match
= htonl(1);
469 afs_send_simple_reply(call
, &reply
, sizeof(reply
));
475 * deliver request data to a CB.ProbeUuid call
477 static int afs_deliver_cb_probe_uuid(struct afs_call
*call
)
484 _enter("{%u}", call
->unmarshall
);
486 switch (call
->unmarshall
) {
489 call
->buffer
= kmalloc(11 * sizeof(__be32
), GFP_KERNEL
);
495 _debug("extract UUID");
496 ret
= afs_extract_data(call
, call
->buffer
,
497 11 * sizeof(__be32
), false);
500 case -EAGAIN
: return 0;
504 _debug("unmarshall UUID");
505 call
->request
= kmalloc(sizeof(struct uuid_v1
), GFP_KERNEL
);
512 r
->time_mid
= htons(ntohl(b
[1]));
513 r
->time_hi_and_version
= htons(ntohl(b
[2]));
514 r
->clock_seq_hi_and_reserved
= ntohl(b
[3]);
515 r
->clock_seq_low
= ntohl(b
[4]);
517 for (loop
= 0; loop
< 6; loop
++)
518 r
->node
[loop
] = ntohl(b
[loop
+ 5]);
527 call
->state
= AFS_CALL_REPLYING
;
529 return afs_queue_call_work(call
);
533 * allow the fileserver to ask about the cache manager's capabilities
535 static void SRXAFSCB_TellMeAboutYourself(struct work_struct
*work
)
537 struct afs_interface
*ifs
;
538 struct afs_call
*call
= container_of(work
, struct afs_call
, work
);
542 struct /* InterfaceAddr */ {
549 struct /* Capabilities */ {
558 ifs
= kcalloc(32, sizeof(*ifs
), GFP_KERNEL
);
560 nifs
= afs_get_ipv4_interfaces(ifs
, 32, false);
568 memset(&reply
, 0, sizeof(reply
));
569 reply
.ia
.nifs
= htonl(nifs
);
571 reply
.ia
.uuid
[0] = afs_uuid
.time_low
;
572 reply
.ia
.uuid
[1] = htonl(ntohs(afs_uuid
.time_mid
));
573 reply
.ia
.uuid
[2] = htonl(ntohs(afs_uuid
.time_hi_and_version
));
574 reply
.ia
.uuid
[3] = htonl((s8
) afs_uuid
.clock_seq_hi_and_reserved
);
575 reply
.ia
.uuid
[4] = htonl((s8
) afs_uuid
.clock_seq_low
);
576 for (loop
= 0; loop
< 6; loop
++)
577 reply
.ia
.uuid
[loop
+ 5] = htonl((s8
) afs_uuid
.node
[loop
]);
580 for (loop
= 0; loop
< nifs
; loop
++) {
581 reply
.ia
.ifaddr
[loop
] = ifs
[loop
].address
.s_addr
;
582 reply
.ia
.netmask
[loop
] = ifs
[loop
].netmask
.s_addr
;
583 reply
.ia
.mtu
[loop
] = htonl(ifs
[loop
].mtu
);
588 reply
.cap
.capcount
= htonl(1);
589 reply
.cap
.caps
[0] = htonl(AFS_CAP_ERROR_TRANSLATION
);
590 afs_send_simple_reply(call
, &reply
, sizeof(reply
));
596 * deliver request data to a CB.TellMeAboutYourself call
598 static int afs_deliver_cb_tell_me_about_yourself(struct afs_call
*call
)
604 ret
= afs_extract_data(call
, NULL
, 0, false);
608 /* no unmarshalling required */
609 call
->state
= AFS_CALL_REPLYING
;
611 return afs_queue_call_work(call
);