Merge tag 'pinctrl-v4.15-1' of git://git.kernel.org/pub/scm/linux/kernel/git/linusw...
[sfrench/cifs-2.6.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 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 *);
32
33 #define CM_NAME(name) \
34         const char afs_SRXCB##name##_name[] __tracepoint_string =       \
35                 "CB." #name
36
37 /*
38  * CB.CallBack operation type
39  */
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,
47 };
48
49 /*
50  * CB.InitCallBackState operation type
51  */
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,
59 };
60
61 /*
62  * CB.InitCallBackState3 operation type
63  */
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,
71 };
72
73 /*
74  * CB.Probe operation type
75  */
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,
83 };
84
85 /*
86  * CB.ProbeUuid operation type
87  */
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,
95 };
96
97 /*
98  * CB.TellMeAboutYourself operation type
99  */
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,
107 };
108
109 /*
110  * route an incoming cache manager call
111  * - return T if supported, F if not
112  */
113 bool afs_cm_incoming_call(struct afs_call *call)
114 {
115         _enter("{CB.OP %u}", call->operation_ID);
116
117         switch (call->operation_ID) {
118         case CBCallBack:
119                 call->type = &afs_SRXCBCallBack;
120                 return true;
121         case CBInitCallBackState:
122                 call->type = &afs_SRXCBInitCallBackState;
123                 return true;
124         case CBInitCallBackState3:
125                 call->type = &afs_SRXCBInitCallBackState3;
126                 return true;
127         case CBProbe:
128                 call->type = &afs_SRXCBProbe;
129                 return true;
130         case CBTellMeAboutYourself:
131                 call->type = &afs_SRXCBTellMeAboutYourself;
132                 return true;
133         default:
134                 return false;
135         }
136 }
137
138 /*
139  * clean up a cache manager call
140  */
141 static void afs_cm_destructor(struct afs_call *call)
142 {
143         _enter("");
144
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().
148          */
149         if (call->unmarshall == 5) {
150                 ASSERT(call->server && call->count && call->request);
151                 afs_break_callbacks(call->server, call->count, call->request);
152         }
153
154         afs_put_server(call->server);
155         call->server = NULL;
156         kfree(call->buffer);
157         call->buffer = NULL;
158 }
159
160 /*
161  * allow the fileserver to see if the cache manager is still alive
162  */
163 static void SRXAFSCB_CallBack(struct work_struct *work)
164 {
165         struct afs_call *call = container_of(work, struct afs_call, work);
166
167         _enter("");
168
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
173          * yet */
174         afs_send_empty_reply(call);
175
176         afs_break_callbacks(call->server, call->count, call->request);
177         afs_put_call(call);
178         _leave("");
179 }
180
181 /*
182  * deliver request data to a CB.CallBack call
183  */
184 static int afs_deliver_cb_callback(struct afs_call *call)
185 {
186         struct sockaddr_rxrpc srx;
187         struct afs_callback *cb;
188         struct afs_server *server;
189         __be32 *bp;
190         int ret, loop;
191
192         _enter("{%u}", call->unmarshall);
193
194         switch (call->unmarshall) {
195         case 0:
196                 rxrpc_kernel_get_peer(afs_socket, call->rxcall, &srx);
197                 call->offset = 0;
198                 call->unmarshall++;
199
200                 /* extract the FID array and its count in two steps */
201         case 1:
202                 _debug("extract FID count");
203                 ret = afs_extract_data(call, &call->tmp, 4, true);
204                 if (ret < 0)
205                         return ret;
206
207                 call->count = ntohl(call->tmp);
208                 _debug("FID count: %u", call->count);
209                 if (call->count > AFSCBMAX)
210                         return -EBADMSG;
211
212                 call->buffer = kmalloc(call->count * 3 * 4, GFP_KERNEL);
213                 if (!call->buffer)
214                         return -ENOMEM;
215                 call->offset = 0;
216                 call->unmarshall++;
217
218         case 2:
219                 _debug("extract FID array");
220                 ret = afs_extract_data(call, call->buffer,
221                                        call->count * 3 * 4, true);
222                 if (ret < 0)
223                         return ret;
224
225                 _debug("unmarshall FID array");
226                 call->request = kcalloc(call->count,
227                                         sizeof(struct afs_callback),
228                                         GFP_KERNEL);
229                 if (!call->request)
230                         return -ENOMEM;
231
232                 cb = call->request;
233                 bp = call->buffer;
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;
239                 }
240
241                 call->offset = 0;
242                 call->unmarshall++;
243
244                 /* extract the callback array and its count in two steps */
245         case 3:
246                 _debug("extract CB count");
247                 ret = afs_extract_data(call, &call->tmp, 4, true);
248                 if (ret < 0)
249                         return ret;
250
251                 call->count2 = ntohl(call->tmp);
252                 _debug("CB count: %u", call->count2);
253                 if (call->count2 != call->count && call->count2 != 0)
254                         return -EBADMSG;
255                 call->offset = 0;
256                 call->unmarshall++;
257
258         case 4:
259                 _debug("extract CB array");
260                 ret = afs_extract_data(call, call->buffer,
261                                        call->count2 * 3 * 4, false);
262                 if (ret < 0)
263                         return ret;
264
265                 _debug("unmarshall CB array");
266                 cb = call->request;
267                 bp = call->buffer;
268                 for (loop = call->count2; loop > 0; loop--, cb++) {
269                         cb->version     = ntohl(*bp++);
270                         cb->expiry      = ntohl(*bp++);
271                         cb->type        = ntohl(*bp++);
272                 }
273
274                 call->offset = 0;
275                 call->unmarshall++;
276
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.
280                  *
281                  * If the step number changes, then afs_cm_destructor() must be
282                  * updated also.
283                  */
284                 call->unmarshall++;
285         case 5:
286                 break;
287         }
288
289         call->state = AFS_CALL_REPLYING;
290
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);
294         if (!server)
295                 return -ENOTCONN;
296         call->server = server;
297
298         return afs_queue_call_work(call);
299 }
300
301 /*
302  * allow the fileserver to request callback state (re-)initialisation
303  */
304 static void SRXAFSCB_InitCallBackState(struct work_struct *work)
305 {
306         struct afs_call *call = container_of(work, struct afs_call, work);
307
308         _enter("{%p}", call->server);
309
310         afs_init_callback_state(call->server);
311         afs_send_empty_reply(call);
312         afs_put_call(call);
313         _leave("");
314 }
315
316 /*
317  * deliver request data to a CB.InitCallBackState call
318  */
319 static int afs_deliver_cb_init_call_back_state(struct afs_call *call)
320 {
321         struct sockaddr_rxrpc srx;
322         struct afs_server *server;
323         int ret;
324
325         _enter("");
326
327         rxrpc_kernel_get_peer(afs_socket, call->rxcall, &srx);
328
329         ret = afs_extract_data(call, NULL, 0, false);
330         if (ret < 0)
331                 return ret;
332
333         /* no unmarshalling required */
334         call->state = AFS_CALL_REPLYING;
335
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);
339         if (!server)
340                 return -ENOTCONN;
341         call->server = server;
342
343         return afs_queue_call_work(call);
344 }
345
346 /*
347  * deliver request data to a CB.InitCallBackState3 call
348  */
349 static int afs_deliver_cb_init_call_back_state3(struct afs_call *call)
350 {
351         struct sockaddr_rxrpc srx;
352         struct afs_server *server;
353         struct afs_uuid *r;
354         unsigned loop;
355         __be32 *b;
356         int ret;
357
358         _enter("");
359
360         rxrpc_kernel_get_peer(afs_socket, call->rxcall, &srx);
361
362         _enter("{%u}", call->unmarshall);
363
364         switch (call->unmarshall) {
365         case 0:
366                 call->offset = 0;
367                 call->buffer = kmalloc(11 * sizeof(__be32), GFP_KERNEL);
368                 if (!call->buffer)
369                         return -ENOMEM;
370                 call->unmarshall++;
371
372         case 1:
373                 _debug("extract UUID");
374                 ret = afs_extract_data(call, call->buffer,
375                                        11 * sizeof(__be32), false);
376                 switch (ret) {
377                 case 0:         break;
378                 case -EAGAIN:   return 0;
379                 default:        return ret;
380                 }
381
382                 _debug("unmarshall UUID");
383                 call->request = kmalloc(sizeof(struct afs_uuid), GFP_KERNEL);
384                 if (!call->request)
385                         return -ENOMEM;
386
387                 b = call->buffer;
388                 r = call->request;
389                 r->time_low                     = b[0];
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]);
394
395                 for (loop = 0; loop < 6; loop++)
396                         r->node[loop] = ntohl(b[loop + 5]);
397
398                 call->offset = 0;
399                 call->unmarshall++;
400
401         case 2:
402                 break;
403         }
404
405         /* no unmarshalling required */
406         call->state = AFS_CALL_REPLYING;
407
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);
411         if (!server)
412                 return -ENOTCONN;
413         call->server = server;
414
415         return afs_queue_call_work(call);
416 }
417
418 /*
419  * allow the fileserver to see if the cache manager is still alive
420  */
421 static void SRXAFSCB_Probe(struct work_struct *work)
422 {
423         struct afs_call *call = container_of(work, struct afs_call, work);
424
425         _enter("");
426         afs_send_empty_reply(call);
427         afs_put_call(call);
428         _leave("");
429 }
430
431 /*
432  * deliver request data to a CB.Probe call
433  */
434 static int afs_deliver_cb_probe(struct afs_call *call)
435 {
436         int ret;
437
438         _enter("");
439
440         ret = afs_extract_data(call, NULL, 0, false);
441         if (ret < 0)
442                 return ret;
443
444         /* no unmarshalling required */
445         call->state = AFS_CALL_REPLYING;
446
447         return afs_queue_call_work(call);
448 }
449
450 /*
451  * allow the fileserver to quickly find out if the fileserver has been rebooted
452  */
453 static void SRXAFSCB_ProbeUuid(struct work_struct *work)
454 {
455         struct afs_call *call = container_of(work, struct afs_call, work);
456         struct afs_uuid *r = call->request;
457
458         struct {
459                 __be32  match;
460         } reply;
461
462         _enter("");
463
464         if (memcmp(r, &afs_uuid, sizeof(afs_uuid)) == 0)
465                 reply.match = htonl(0);
466         else
467                 reply.match = htonl(1);
468
469         afs_send_simple_reply(call, &reply, sizeof(reply));
470         afs_put_call(call);
471         _leave("");
472 }
473
474 /*
475  * deliver request data to a CB.ProbeUuid call
476  */
477 static int afs_deliver_cb_probe_uuid(struct afs_call *call)
478 {
479         struct afs_uuid *r;
480         unsigned loop;
481         __be32 *b;
482         int ret;
483
484         _enter("{%u}", call->unmarshall);
485
486         switch (call->unmarshall) {
487         case 0:
488                 call->offset = 0;
489                 call->buffer = kmalloc(11 * sizeof(__be32), GFP_KERNEL);
490                 if (!call->buffer)
491                         return -ENOMEM;
492                 call->unmarshall++;
493
494         case 1:
495                 _debug("extract UUID");
496                 ret = afs_extract_data(call, call->buffer,
497                                        11 * sizeof(__be32), false);
498                 switch (ret) {
499                 case 0:         break;
500                 case -EAGAIN:   return 0;
501                 default:        return ret;
502                 }
503
504                 _debug("unmarshall UUID");
505                 call->request = kmalloc(sizeof(struct afs_uuid), GFP_KERNEL);
506                 if (!call->request)
507                         return -ENOMEM;
508
509                 b = call->buffer;
510                 r = call->request;
511                 r->time_low                     = ntohl(b[0]);
512                 r->time_mid                     = ntohl(b[1]);
513                 r->time_hi_and_version          = ntohl(b[2]);
514                 r->clock_seq_hi_and_reserved    = ntohl(b[3]);
515                 r->clock_seq_low                = ntohl(b[4]);
516
517                 for (loop = 0; loop < 6; loop++)
518                         r->node[loop] = ntohl(b[loop + 5]);
519
520                 call->offset = 0;
521                 call->unmarshall++;
522
523         case 2:
524                 break;
525         }
526
527         call->state = AFS_CALL_REPLYING;
528
529         return afs_queue_call_work(call);
530 }
531
532 /*
533  * allow the fileserver to ask about the cache manager's capabilities
534  */
535 static void SRXAFSCB_TellMeAboutYourself(struct work_struct *work)
536 {
537         struct afs_interface *ifs;
538         struct afs_call *call = container_of(work, struct afs_call, work);
539         int loop, nifs;
540
541         struct {
542                 struct /* InterfaceAddr */ {
543                         __be32 nifs;
544                         __be32 uuid[11];
545                         __be32 ifaddr[32];
546                         __be32 netmask[32];
547                         __be32 mtu[32];
548                 } ia;
549                 struct /* Capabilities */ {
550                         __be32 capcount;
551                         __be32 caps[1];
552                 } cap;
553         } reply;
554
555         _enter("");
556
557         nifs = 0;
558         ifs = kcalloc(32, sizeof(*ifs), GFP_KERNEL);
559         if (ifs) {
560                 nifs = afs_get_ipv4_interfaces(ifs, 32, false);
561                 if (nifs < 0) {
562                         kfree(ifs);
563                         ifs = NULL;
564                         nifs = 0;
565                 }
566         }
567
568         memset(&reply, 0, sizeof(reply));
569         reply.ia.nifs = htonl(nifs);
570
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]);
578
579         if (ifs) {
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);
584                 }
585                 kfree(ifs);
586         }
587
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));
591         afs_put_call(call);
592         _leave("");
593 }
594
595 /*
596  * deliver request data to a CB.TellMeAboutYourself call
597  */
598 static int afs_deliver_cb_tell_me_about_yourself(struct afs_call *call)
599 {
600         int ret;
601
602         _enter("");
603
604         ret = afs_extract_data(call, NULL, 0, false);
605         if (ret < 0)
606                 return ret;
607
608         /* no unmarshalling required */
609         call->state = AFS_CALL_REPLYING;
610
611         return afs_queue_call_work(call);
612 }