]> git.kernelconcepts.de Git - karo-tx-linux.git/blob - fs/afs/cmservice.c
Merge tag 'soc2-for-3.16' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc
[karo-tx-linux.git] / fs / afs / cmservice.c
1 /* AFS Cache Manager Service
2  *
3  * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
4  * Written by David Howells (dhowells@redhat.com)
5  *
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.
10  */
11
12 #include <linux/module.h>
13 #include <linux/init.h>
14 #include <linux/slab.h>
15 #include <linux/sched.h>
16 #include <linux/ip.h>
17 #include "internal.h"
18 #include "afs_cm.h"
19
20 #if 0
21 struct workqueue_struct *afs_cm_workqueue;
22 #endif  /*  0  */
23
24 static int afs_deliver_cb_init_call_back_state(struct afs_call *,
25                                                struct sk_buff *, bool);
26 static int afs_deliver_cb_init_call_back_state3(struct afs_call *,
27                                                 struct sk_buff *, bool);
28 static int afs_deliver_cb_probe(struct afs_call *, struct sk_buff *, bool);
29 static int afs_deliver_cb_callback(struct afs_call *, struct sk_buff *, bool);
30 static int afs_deliver_cb_probe_uuid(struct afs_call *, struct sk_buff *, bool);
31 static int afs_deliver_cb_tell_me_about_yourself(struct afs_call *,
32                                                  struct sk_buff *, bool);
33 static void afs_cm_destructor(struct afs_call *);
34
35 /*
36  * CB.CallBack operation type
37  */
38 static const struct afs_call_type afs_SRXCBCallBack = {
39         .name           = "CB.CallBack",
40         .deliver        = afs_deliver_cb_callback,
41         .abort_to_error = afs_abort_to_error,
42         .destructor     = afs_cm_destructor,
43 };
44
45 /*
46  * CB.InitCallBackState operation type
47  */
48 static const struct afs_call_type afs_SRXCBInitCallBackState = {
49         .name           = "CB.InitCallBackState",
50         .deliver        = afs_deliver_cb_init_call_back_state,
51         .abort_to_error = afs_abort_to_error,
52         .destructor     = afs_cm_destructor,
53 };
54
55 /*
56  * CB.InitCallBackState3 operation type
57  */
58 static const struct afs_call_type afs_SRXCBInitCallBackState3 = {
59         .name           = "CB.InitCallBackState3",
60         .deliver        = afs_deliver_cb_init_call_back_state3,
61         .abort_to_error = afs_abort_to_error,
62         .destructor     = afs_cm_destructor,
63 };
64
65 /*
66  * CB.Probe operation type
67  */
68 static const struct afs_call_type afs_SRXCBProbe = {
69         .name           = "CB.Probe",
70         .deliver        = afs_deliver_cb_probe,
71         .abort_to_error = afs_abort_to_error,
72         .destructor     = afs_cm_destructor,
73 };
74
75 /*
76  * CB.ProbeUuid operation type
77  */
78 static const struct afs_call_type afs_SRXCBProbeUuid = {
79         .name           = "CB.ProbeUuid",
80         .deliver        = afs_deliver_cb_probe_uuid,
81         .abort_to_error = afs_abort_to_error,
82         .destructor     = afs_cm_destructor,
83 };
84
85 /*
86  * CB.TellMeAboutYourself operation type
87  */
88 static const struct afs_call_type afs_SRXCBTellMeAboutYourself = {
89         .name           = "CB.TellMeAboutYourself",
90         .deliver        = afs_deliver_cb_tell_me_about_yourself,
91         .abort_to_error = afs_abort_to_error,
92         .destructor     = afs_cm_destructor,
93 };
94
95 /*
96  * route an incoming cache manager call
97  * - return T if supported, F if not
98  */
99 bool afs_cm_incoming_call(struct afs_call *call)
100 {
101         u32 operation_id = ntohl(call->operation_ID);
102
103         _enter("{CB.OP %u}", operation_id);
104
105         switch (operation_id) {
106         case CBCallBack:
107                 call->type = &afs_SRXCBCallBack;
108                 return true;
109         case CBInitCallBackState:
110                 call->type = &afs_SRXCBInitCallBackState;
111                 return true;
112         case CBInitCallBackState3:
113                 call->type = &afs_SRXCBInitCallBackState3;
114                 return true;
115         case CBProbe:
116                 call->type = &afs_SRXCBProbe;
117                 return true;
118         case CBTellMeAboutYourself:
119                 call->type = &afs_SRXCBTellMeAboutYourself;
120                 return true;
121         default:
122                 return false;
123         }
124 }
125
126 /*
127  * clean up a cache manager call
128  */
129 static void afs_cm_destructor(struct afs_call *call)
130 {
131         _enter("");
132
133         /* Break the callbacks here so that we do it after the final ACK is
134          * received.  The step number here must match the final number in
135          * afs_deliver_cb_callback().
136          */
137         if (call->unmarshall == 6) {
138                 ASSERT(call->server && call->count && call->request);
139                 afs_break_callbacks(call->server, call->count, call->request);
140         }
141
142         afs_put_server(call->server);
143         call->server = NULL;
144         kfree(call->buffer);
145         call->buffer = NULL;
146 }
147
148 /*
149  * allow the fileserver to see if the cache manager is still alive
150  */
151 static void SRXAFSCB_CallBack(struct work_struct *work)
152 {
153         struct afs_call *call = container_of(work, struct afs_call, work);
154
155         _enter("");
156
157         /* be sure to send the reply *before* attempting to spam the AFS server
158          * with FSFetchStatus requests on the vnodes with broken callbacks lest
159          * the AFS server get into a vicious cycle of trying to break further
160          * callbacks because it hadn't received completion of the CBCallBack op
161          * yet */
162         afs_send_empty_reply(call);
163
164         afs_break_callbacks(call->server, call->count, call->request);
165         _leave("");
166 }
167
168 /*
169  * deliver request data to a CB.CallBack call
170  */
171 static int afs_deliver_cb_callback(struct afs_call *call, struct sk_buff *skb,
172                                    bool last)
173 {
174         struct afs_callback *cb;
175         struct afs_server *server;
176         struct in_addr addr;
177         __be32 *bp;
178         u32 tmp;
179         int ret, loop;
180
181         _enter("{%u},{%u},%d", call->unmarshall, skb->len, last);
182
183         switch (call->unmarshall) {
184         case 0:
185                 call->offset = 0;
186                 call->unmarshall++;
187
188                 /* extract the FID array and its count in two steps */
189         case 1:
190                 _debug("extract FID count");
191                 ret = afs_extract_data(call, skb, last, &call->tmp, 4);
192                 switch (ret) {
193                 case 0:         break;
194                 case -EAGAIN:   return 0;
195                 default:        return ret;
196                 }
197
198                 call->count = ntohl(call->tmp);
199                 _debug("FID count: %u", call->count);
200                 if (call->count > AFSCBMAX)
201                         return -EBADMSG;
202
203                 call->buffer = kmalloc(call->count * 3 * 4, GFP_KERNEL);
204                 if (!call->buffer)
205                         return -ENOMEM;
206                 call->offset = 0;
207                 call->unmarshall++;
208
209         case 2:
210                 _debug("extract FID array");
211                 ret = afs_extract_data(call, skb, last, call->buffer,
212                                        call->count * 3 * 4);
213                 switch (ret) {
214                 case 0:         break;
215                 case -EAGAIN:   return 0;
216                 default:        return ret;
217                 }
218
219                 _debug("unmarshall FID array");
220                 call->request = kcalloc(call->count,
221                                         sizeof(struct afs_callback),
222                                         GFP_KERNEL);
223                 if (!call->request)
224                         return -ENOMEM;
225
226                 cb = call->request;
227                 bp = call->buffer;
228                 for (loop = call->count; loop > 0; loop--, cb++) {
229                         cb->fid.vid     = ntohl(*bp++);
230                         cb->fid.vnode   = ntohl(*bp++);
231                         cb->fid.unique  = ntohl(*bp++);
232                         cb->type        = AFSCM_CB_UNTYPED;
233                 }
234
235                 call->offset = 0;
236                 call->unmarshall++;
237
238                 /* extract the callback array and its count in two steps */
239         case 3:
240                 _debug("extract CB count");
241                 ret = afs_extract_data(call, skb, last, &call->tmp, 4);
242                 switch (ret) {
243                 case 0:         break;
244                 case -EAGAIN:   return 0;
245                 default:        return ret;
246                 }
247
248                 tmp = ntohl(call->tmp);
249                 _debug("CB count: %u", tmp);
250                 if (tmp != call->count && tmp != 0)
251                         return -EBADMSG;
252                 call->offset = 0;
253                 call->unmarshall++;
254                 if (tmp == 0)
255                         goto empty_cb_array;
256
257         case 4:
258                 _debug("extract CB array");
259                 ret = afs_extract_data(call, skb, last, call->request,
260                                        call->count * 3 * 4);
261                 switch (ret) {
262                 case 0:         break;
263                 case -EAGAIN:   return 0;
264                 default:        return ret;
265                 }
266
267                 _debug("unmarshall CB array");
268                 cb = call->request;
269                 bp = call->buffer;
270                 for (loop = call->count; loop > 0; loop--, cb++) {
271                         cb->version     = ntohl(*bp++);
272                         cb->expiry      = ntohl(*bp++);
273                         cb->type        = ntohl(*bp++);
274                 }
275
276         empty_cb_array:
277                 call->offset = 0;
278                 call->unmarshall++;
279
280         case 5:
281                 _debug("trailer");
282                 if (skb->len != 0)
283                         return -EBADMSG;
284
285                 /* Record that the message was unmarshalled successfully so
286                  * that the call destructor can know do the callback breaking
287                  * work, even if the final ACK isn't received.
288                  *
289                  * If the step number changes, then afs_cm_destructor() must be
290                  * updated also.
291                  */
292                 call->unmarshall++;
293         case 6:
294                 break;
295         }
296
297         if (!last)
298                 return 0;
299
300         call->state = AFS_CALL_REPLYING;
301
302         /* we'll need the file server record as that tells us which set of
303          * vnodes to operate upon */
304         memcpy(&addr, &ip_hdr(skb)->saddr, 4);
305         server = afs_find_server(&addr);
306         if (!server)
307                 return -ENOTCONN;
308         call->server = server;
309
310         INIT_WORK(&call->work, SRXAFSCB_CallBack);
311         queue_work(afs_wq, &call->work);
312         return 0;
313 }
314
315 /*
316  * allow the fileserver to request callback state (re-)initialisation
317  */
318 static void SRXAFSCB_InitCallBackState(struct work_struct *work)
319 {
320         struct afs_call *call = container_of(work, struct afs_call, work);
321
322         _enter("{%p}", call->server);
323
324         afs_init_callback_state(call->server);
325         afs_send_empty_reply(call);
326         _leave("");
327 }
328
329 /*
330  * deliver request data to a CB.InitCallBackState call
331  */
332 static int afs_deliver_cb_init_call_back_state(struct afs_call *call,
333                                                struct sk_buff *skb,
334                                                bool last)
335 {
336         struct afs_server *server;
337         struct in_addr addr;
338
339         _enter(",{%u},%d", skb->len, last);
340
341         if (skb->len > 0)
342                 return -EBADMSG;
343         if (!last)
344                 return 0;
345
346         /* no unmarshalling required */
347         call->state = AFS_CALL_REPLYING;
348
349         /* we'll need the file server record as that tells us which set of
350          * vnodes to operate upon */
351         memcpy(&addr, &ip_hdr(skb)->saddr, 4);
352         server = afs_find_server(&addr);
353         if (!server)
354                 return -ENOTCONN;
355         call->server = server;
356
357         INIT_WORK(&call->work, SRXAFSCB_InitCallBackState);
358         queue_work(afs_wq, &call->work);
359         return 0;
360 }
361
362 /*
363  * deliver request data to a CB.InitCallBackState3 call
364  */
365 static int afs_deliver_cb_init_call_back_state3(struct afs_call *call,
366                                                 struct sk_buff *skb,
367                                                 bool last)
368 {
369         struct afs_server *server;
370         struct in_addr addr;
371
372         _enter(",{%u},%d", skb->len, last);
373
374         if (!last)
375                 return 0;
376
377         /* no unmarshalling required */
378         call->state = AFS_CALL_REPLYING;
379
380         /* we'll need the file server record as that tells us which set of
381          * vnodes to operate upon */
382         memcpy(&addr, &ip_hdr(skb)->saddr, 4);
383         server = afs_find_server(&addr);
384         if (!server)
385                 return -ENOTCONN;
386         call->server = server;
387
388         INIT_WORK(&call->work, SRXAFSCB_InitCallBackState);
389         queue_work(afs_wq, &call->work);
390         return 0;
391 }
392
393 /*
394  * allow the fileserver to see if the cache manager is still alive
395  */
396 static void SRXAFSCB_Probe(struct work_struct *work)
397 {
398         struct afs_call *call = container_of(work, struct afs_call, work);
399
400         _enter("");
401         afs_send_empty_reply(call);
402         _leave("");
403 }
404
405 /*
406  * deliver request data to a CB.Probe call
407  */
408 static int afs_deliver_cb_probe(struct afs_call *call, struct sk_buff *skb,
409                                 bool last)
410 {
411         _enter(",{%u},%d", skb->len, last);
412
413         if (skb->len > 0)
414                 return -EBADMSG;
415         if (!last)
416                 return 0;
417
418         /* no unmarshalling required */
419         call->state = AFS_CALL_REPLYING;
420
421         INIT_WORK(&call->work, SRXAFSCB_Probe);
422         queue_work(afs_wq, &call->work);
423         return 0;
424 }
425
426 /*
427  * allow the fileserver to quickly find out if the fileserver has been rebooted
428  */
429 static void SRXAFSCB_ProbeUuid(struct work_struct *work)
430 {
431         struct afs_call *call = container_of(work, struct afs_call, work);
432         struct afs_uuid *r = call->request;
433
434         struct {
435                 __be32  match;
436         } reply;
437
438         _enter("");
439
440
441         if (memcmp(r, &afs_uuid, sizeof(afs_uuid)) == 0)
442                 reply.match = htonl(0);
443         else
444                 reply.match = htonl(1);
445
446         afs_send_simple_reply(call, &reply, sizeof(reply));
447         _leave("");
448 }
449
450 /*
451  * deliver request data to a CB.ProbeUuid call
452  */
453 static int afs_deliver_cb_probe_uuid(struct afs_call *call, struct sk_buff *skb,
454                                      bool last)
455 {
456         struct afs_uuid *r;
457         unsigned loop;
458         __be32 *b;
459         int ret;
460
461         _enter("{%u},{%u},%d", call->unmarshall, skb->len, last);
462
463         if (skb->len > 0)
464                 return -EBADMSG;
465         if (!last)
466                 return 0;
467
468         switch (call->unmarshall) {
469         case 0:
470                 call->offset = 0;
471                 call->buffer = kmalloc(11 * sizeof(__be32), GFP_KERNEL);
472                 if (!call->buffer)
473                         return -ENOMEM;
474                 call->unmarshall++;
475
476         case 1:
477                 _debug("extract UUID");
478                 ret = afs_extract_data(call, skb, last, call->buffer,
479                                        11 * sizeof(__be32));
480                 switch (ret) {
481                 case 0:         break;
482                 case -EAGAIN:   return 0;
483                 default:        return ret;
484                 }
485
486                 _debug("unmarshall UUID");
487                 call->request = kmalloc(sizeof(struct afs_uuid), GFP_KERNEL);
488                 if (!call->request)
489                         return -ENOMEM;
490
491                 b = call->buffer;
492                 r = call->request;
493                 r->time_low                     = ntohl(b[0]);
494                 r->time_mid                     = ntohl(b[1]);
495                 r->time_hi_and_version          = ntohl(b[2]);
496                 r->clock_seq_hi_and_reserved    = ntohl(b[3]);
497                 r->clock_seq_low                = ntohl(b[4]);
498
499                 for (loop = 0; loop < 6; loop++)
500                         r->node[loop] = ntohl(b[loop + 5]);
501
502                 call->offset = 0;
503                 call->unmarshall++;
504
505         case 2:
506                 _debug("trailer");
507                 if (skb->len != 0)
508                         return -EBADMSG;
509                 break;
510         }
511
512         if (!last)
513                 return 0;
514
515         call->state = AFS_CALL_REPLYING;
516
517         INIT_WORK(&call->work, SRXAFSCB_ProbeUuid);
518         queue_work(afs_wq, &call->work);
519         return 0;
520 }
521
522 /*
523  * allow the fileserver to ask about the cache manager's capabilities
524  */
525 static void SRXAFSCB_TellMeAboutYourself(struct work_struct *work)
526 {
527         struct afs_interface *ifs;
528         struct afs_call *call = container_of(work, struct afs_call, work);
529         int loop, nifs;
530
531         struct {
532                 struct /* InterfaceAddr */ {
533                         __be32 nifs;
534                         __be32 uuid[11];
535                         __be32 ifaddr[32];
536                         __be32 netmask[32];
537                         __be32 mtu[32];
538                 } ia;
539                 struct /* Capabilities */ {
540                         __be32 capcount;
541                         __be32 caps[1];
542                 } cap;
543         } reply;
544
545         _enter("");
546
547         nifs = 0;
548         ifs = kcalloc(32, sizeof(*ifs), GFP_KERNEL);
549         if (ifs) {
550                 nifs = afs_get_ipv4_interfaces(ifs, 32, false);
551                 if (nifs < 0) {
552                         kfree(ifs);
553                         ifs = NULL;
554                         nifs = 0;
555                 }
556         }
557
558         memset(&reply, 0, sizeof(reply));
559         reply.ia.nifs = htonl(nifs);
560
561         reply.ia.uuid[0] = htonl(afs_uuid.time_low);
562         reply.ia.uuid[1] = htonl(afs_uuid.time_mid);
563         reply.ia.uuid[2] = htonl(afs_uuid.time_hi_and_version);
564         reply.ia.uuid[3] = htonl((s8) afs_uuid.clock_seq_hi_and_reserved);
565         reply.ia.uuid[4] = htonl((s8) afs_uuid.clock_seq_low);
566         for (loop = 0; loop < 6; loop++)
567                 reply.ia.uuid[loop + 5] = htonl((s8) afs_uuid.node[loop]);
568
569         if (ifs) {
570                 for (loop = 0; loop < nifs; loop++) {
571                         reply.ia.ifaddr[loop] = ifs[loop].address.s_addr;
572                         reply.ia.netmask[loop] = ifs[loop].netmask.s_addr;
573                         reply.ia.mtu[loop] = htonl(ifs[loop].mtu);
574                 }
575                 kfree(ifs);
576         }
577
578         reply.cap.capcount = htonl(1);
579         reply.cap.caps[0] = htonl(AFS_CAP_ERROR_TRANSLATION);
580         afs_send_simple_reply(call, &reply, sizeof(reply));
581
582         _leave("");
583 }
584
585 /*
586  * deliver request data to a CB.TellMeAboutYourself call
587  */
588 static int afs_deliver_cb_tell_me_about_yourself(struct afs_call *call,
589                                                  struct sk_buff *skb, bool last)
590 {
591         _enter(",{%u},%d", skb->len, last);
592
593         if (skb->len > 0)
594                 return -EBADMSG;
595         if (!last)
596                 return 0;
597
598         /* no unmarshalling required */
599         call->state = AFS_CALL_REPLYING;
600
601         INIT_WORK(&call->work, SRXAFSCB_TellMeAboutYourself);
602         queue_work(afs_wq, &call->work);
603         return 0;
604 }