?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ipc/shm: Fix shmat mmap nil-page protection
[cris-mirror.git] / fs / afs / cmservice.c
blob2edbdcbf6432add190464b5a5f414592953c944a
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 u32 tmp;
191 int ret, loop;
192
193 _enter("{%u}", call->unmarshall);
194
195 switch (call->unmarshall) {
196 case 0:
197 rxrpc_kernel_get_peer(afs_socket, call->rxcall, &srx);
198 call->offset = 0;
199 call->unmarshall++;
200
201 /* extract the FID array and its count in two steps */
202 case 1:
203 _debug("extract FID count");
204 ret = afs_extract_data(call, &call->tmp, 4, true);
205 if (ret < 0)
206 return ret;
207
208 call->count = ntohl(call->tmp);
209 _debug("FID count: %u", call->count);
210 if (call->count > AFSCBMAX)
211 return -EBADMSG;
212
213 call->buffer = kmalloc(call->count * 3 * 4, GFP_KERNEL);
214 if (!call->buffer)
215 return -ENOMEM;
216 call->offset = 0;
217 call->unmarshall++;
218
219 case 2:
220 _debug("extract FID array");
221 ret = afs_extract_data(call, call->buffer,
222 call->count * 3 * 4, true);
223 if (ret < 0)
224 return ret;
225
226 _debug("unmarshall FID array");
227 call->request = kcalloc(call->count,
228 sizeof(struct afs_callback),
229 GFP_KERNEL);
230 if (!call->request)
231 return -ENOMEM;
232
233 cb = call->request;
234 bp = call->buffer;
235 for (loop = call->count; loop > 0; loop--, cb++) {
236 cb->fid.vid = ntohl(*bp++);
237 cb->fid.vnode = ntohl(*bp++);
238 cb->fid.unique = ntohl(*bp++);
239 cb->type = AFSCM_CB_UNTYPED;
240 }
241
242 call->offset = 0;
243 call->unmarshall++;
244
245 /* extract the callback array and its count in two steps */
246 case 3:
247 _debug("extract CB count");
248 ret = afs_extract_data(call, &call->tmp, 4, true);
249 if (ret < 0)
250 return ret;
251
252 tmp = ntohl(call->tmp);
253 _debug("CB count: %u", tmp);
254 if (tmp != call->count && tmp != 0)
255 return -EBADMSG;
256 call->offset = 0;
257 call->unmarshall++;
258
259 case 4:
260 _debug("extract CB array");
261 ret = afs_extract_data(call, call->buffer,
262 call->count * 3 * 4, false);
263 if (ret < 0)
264 return ret;
265
266 _debug("unmarshall CB array");
267 cb = call->request;
268 bp = call->buffer;
269 for (loop = call->count; loop > 0; loop--, cb++) {
270 cb->version = ntohl(*bp++);
271 cb->expiry = ntohl(*bp++);
272 cb->type = ntohl(*bp++);
273 }
274
275 call->offset = 0;
276 call->unmarshall++;
277
278 /* Record that the message was unmarshalled successfully so
279 * that the call destructor can know do the callback breaking
280 * work, even if the final ACK isn't received.
281 *
282 * If the step number changes, then afs_cm_destructor() must be
283 * updated also.
284 */
285 call->unmarshall++;
286 case 5:
287 break;
288 }
289
290 call->state = AFS_CALL_REPLYING;
291
292 /* we'll need the file server record as that tells us which set of
293 * vnodes to operate upon */
294 server = afs_find_server(&srx);
295 if (!server)
296 return -ENOTCONN;
297 call->server = server;
298
299 return afs_queue_call_work(call);
300 }
301
302 /*
303 * allow the fileserver to request callback state (re-)initialisation
304 */
305 static void SRXAFSCB_InitCallBackState(struct work_struct *work)
306 {
307 struct afs_call *call = container_of(work, struct afs_call, work);
308
309 _enter("{%p}", call->server);
310
311 afs_init_callback_state(call->server);
312 afs_send_empty_reply(call);
313 afs_put_call(call);
314 _leave("");
315 }
316
317 /*
318 * deliver request data to a CB.InitCallBackState call
319 */
320 static int afs_deliver_cb_init_call_back_state(struct afs_call *call)
321 {
322 struct sockaddr_rxrpc srx;
323 struct afs_server *server;
324 int ret;
325
326 _enter("");
327
328 rxrpc_kernel_get_peer(afs_socket, call->rxcall, &srx);
329
330 ret = afs_extract_data(call, NULL, 0, false);
331 if (ret < 0)
332 return ret;
333
334 /* no unmarshalling required */
335 call->state = AFS_CALL_REPLYING;
336
337 /* we'll need the file server record as that tells us which set of
338 * vnodes to operate upon */
339 server = afs_find_server(&srx);
340 if (!server)
341 return -ENOTCONN;
342 call->server = server;
343
344 return afs_queue_call_work(call);
345 }
346
347 /*
348 * deliver request data to a CB.InitCallBackState3 call
349 */
350 static int afs_deliver_cb_init_call_back_state3(struct afs_call *call)
351 {
352 struct sockaddr_rxrpc srx;
353 struct afs_server *server;
354 struct uuid_v1 *r;
355 unsigned loop;
356 __be32 *b;
357 int ret;
358
359 _enter("");
360
361 rxrpc_kernel_get_peer(afs_socket, call->rxcall, &srx);
362
363 _enter("{%u}", call->unmarshall);
364
365 switch (call->unmarshall) {
366 case 0:
367 call->offset = 0;
368 call->buffer = kmalloc(11 * sizeof(__be32), GFP_KERNEL);
369 if (!call->buffer)
370 return -ENOMEM;
371 call->unmarshall++;
372
373 case 1:
374 _debug("extract UUID");
375 ret = afs_extract_data(call, call->buffer,
376 11 * sizeof(__be32), false);
377 switch (ret) {
378 case 0: break;
379 case -EAGAIN: return 0;
380 default: return ret;
381 }
382
383 _debug("unmarshall UUID");
384 call->request = kmalloc(sizeof(struct uuid_v1), GFP_KERNEL);
385 if (!call->request)
386 return -ENOMEM;
387
388 b = call->buffer;
389 r = call->request;
390 r->time_low = b[0];
391 r->time_mid = htons(ntohl(b[1]));
392 r->time_hi_and_version = htons(ntohl(b[2]));
393 r->clock_seq_hi_and_reserved = ntohl(b[3]);
394 r->clock_seq_low = ntohl(b[4]);
395
396 for (loop = 0; loop < 6; loop++)
397 r->node[loop] = ntohl(b[loop + 5]);
398
399 call->offset = 0;
400 call->unmarshall++;
401
402 case 2:
403 break;
404 }
405
406 /* no unmarshalling required */
407 call->state = AFS_CALL_REPLYING;
408
409 /* we'll need the file server record as that tells us which set of
410 * vnodes to operate upon */
411 server = afs_find_server(&srx);
412 if (!server)
413 return -ENOTCONN;
414 call->server = server;
415
416 return afs_queue_call_work(call);
417 }
418
419 /*
420 * allow the fileserver to see if the cache manager is still alive
421 */
422 static void SRXAFSCB_Probe(struct work_struct *work)
423 {
424 struct afs_call *call = container_of(work, struct afs_call, work);
425
426 _enter("");
427 afs_send_empty_reply(call);
428 afs_put_call(call);
429 _leave("");
430 }
431
432 /*
433 * deliver request data to a CB.Probe call
434 */
435 static int afs_deliver_cb_probe(struct afs_call *call)
436 {
437 int ret;
438
439 _enter("");
440
441 ret = afs_extract_data(call, NULL, 0, false);
442 if (ret < 0)
443 return ret;
444
445 /* no unmarshalling required */
446 call->state = AFS_CALL_REPLYING;
447
448 return afs_queue_call_work(call);
449 }
450
451 /*
452 * allow the fileserver to quickly find out if the fileserver has been rebooted
453 */
454 static void SRXAFSCB_ProbeUuid(struct work_struct *work)
455 {
456 struct afs_call *call = container_of(work, struct afs_call, work);
457 struct uuid_v1 *r = call->request;
458
459 struct {
460 __be32 match;
461 } reply;
462
463 _enter("");
464
465 if (memcmp(r, &afs_uuid, sizeof(afs_uuid)) == 0)
466 reply.match = htonl(0);
467 else
468 reply.match = htonl(1);
469
470 afs_send_simple_reply(call, &reply, sizeof(reply));
471 afs_put_call(call);
472 _leave("");
473 }
474
475 /*
476 * deliver request data to a CB.ProbeUuid call
477 */
478 static int afs_deliver_cb_probe_uuid(struct afs_call *call)
479 {
480 struct uuid_v1 *r;
481 unsigned loop;
482 __be32 *b;
483 int ret;
484
485 _enter("{%u}", call->unmarshall);
486
487 switch (call->unmarshall) {
488 case 0:
489 call->offset = 0;
490 call->buffer = kmalloc(11 * sizeof(__be32), GFP_KERNEL);
491 if (!call->buffer)
492 return -ENOMEM;
493 call->unmarshall++;
494
495 case 1:
496 _debug("extract UUID");
497 ret = afs_extract_data(call, call->buffer,
498 11 * sizeof(__be32), false);
499 switch (ret) {
500 case 0: break;
501 case -EAGAIN: return 0;
502 default: return ret;
503 }
504
505 _debug("unmarshall UUID");
506 call->request = kmalloc(sizeof(struct uuid_v1), GFP_KERNEL);
507 if (!call->request)
508 return -ENOMEM;
509
510 b = call->buffer;
511 r = call->request;
512 r->time_low = b[0];
513 r->time_mid = htons(ntohl(b[1]));
514 r->time_hi_and_version = htons(ntohl(b[2]));
515 r->clock_seq_hi_and_reserved = ntohl(b[3]);
516 r->clock_seq_low = ntohl(b[4]);
517
518 for (loop = 0; loop < 6; loop++)
519 r->node[loop] = ntohl(b[loop + 5]);
520
521 call->offset = 0;
522 call->unmarshall++;
523
524 case 2:
525 break;
526 }
527
528 call->state = AFS_CALL_REPLYING;
529
530 return afs_queue_call_work(call);
531 }
532
533 /*
534 * allow the fileserver to ask about the cache manager's capabilities
535 */
536 static void SRXAFSCB_TellMeAboutYourself(struct work_struct *work)
537 {
538 struct afs_interface *ifs;
539 struct afs_call *call = container_of(work, struct afs_call, work);
540 int loop, nifs;
541
542 struct {
543 struct /* InterfaceAddr */ {
544 __be32 nifs;
545 __be32 uuid[11];
546 __be32 ifaddr[32];
547 __be32 netmask[32];
548 __be32 mtu[32];
549 } ia;
550 struct /* Capabilities */ {
551 __be32 capcount;
552 __be32 caps[1];
553 } cap;
554 } reply;
555
556 _enter("");
557
558 nifs = 0;
559 ifs = kcalloc(32, sizeof(*ifs), GFP_KERNEL);
560 if (ifs) {
561 nifs = afs_get_ipv4_interfaces(ifs, 32, false);
562 if (nifs < 0) {
563 kfree(ifs);
564 ifs = NULL;
565 nifs = 0;
566 }
567 }
568
569 memset(&reply, 0, sizeof(reply));
570 reply.ia.nifs = htonl(nifs);
571
572 reply.ia.uuid[0] = afs_uuid.time_low;
573 reply.ia.uuid[1] = htonl(ntohs(afs_uuid.time_mid));
574 reply.ia.uuid[2] = htonl(ntohs(afs_uuid.time_hi_and_version));
575 reply.ia.uuid[3] = htonl((s8) afs_uuid.clock_seq_hi_and_reserved);
576 reply.ia.uuid[4] = htonl((s8) afs_uuid.clock_seq_low);
577 for (loop = 0; loop < 6; loop++)
578 reply.ia.uuid[loop + 5] = htonl((s8) afs_uuid.node[loop]);
579
580 if (ifs) {
581 for (loop = 0; loop < nifs; loop++) {
582 reply.ia.ifaddr[loop] = ifs[loop].address.s_addr;
583 reply.ia.netmask[loop] = ifs[loop].netmask.s_addr;
584 reply.ia.mtu[loop] = htonl(ifs[loop].mtu);
585 }
586 kfree(ifs);
587 }
588
589 reply.cap.capcount = htonl(1);
590 reply.cap.caps[0] = htonl(AFS_CAP_ERROR_TRANSLATION);
591 afs_send_simple_reply(call, &reply, sizeof(reply));
592 afs_put_call(call);
593 _leave("");
594 }
595
596 /*
597 * deliver request data to a CB.TellMeAboutYourself call
598 */
599 static int afs_deliver_cb_tell_me_about_yourself(struct afs_call *call)
600 {
601 int ret;
602
603 _enter("");
604
605 ret = afs_extract_data(call, NULL, 0, false);
606 if (ret < 0)
607 return ret;
608
609 /* no unmarshalling required */
610 call->state = AFS_CALL_REPLYING;
611
612 return afs_queue_call_work(call);
613 }
CRIS linux kernel tree