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 	.destructor	= afs_cm_destructor,
45 	.work		= SRXAFSCB_CallBack,
46 };
47 
48 /*
49  * CB.InitCallBackState operation type
50  */
51 static CM_NAME(InitCallBackState);
52 static const struct afs_call_type afs_SRXCBInitCallBackState = {
53 	.name		= afs_SRXCBInitCallBackState_name,
54 	.deliver	= afs_deliver_cb_init_call_back_state,
55 	.destructor	= afs_cm_destructor,
56 	.work		= SRXAFSCB_InitCallBackState,
57 };
58 
59 /*
60  * CB.InitCallBackState3 operation type
61  */
62 static CM_NAME(InitCallBackState3);
63 static const struct afs_call_type afs_SRXCBInitCallBackState3 = {
64 	.name		= afs_SRXCBInitCallBackState3_name,
65 	.deliver	= afs_deliver_cb_init_call_back_state3,
66 	.destructor	= afs_cm_destructor,
67 	.work		= SRXAFSCB_InitCallBackState,
68 };
69 
70 /*
71  * CB.Probe operation type
72  */
73 static CM_NAME(Probe);
74 static const struct afs_call_type afs_SRXCBProbe = {
75 	.name		= afs_SRXCBProbe_name,
76 	.deliver	= afs_deliver_cb_probe,
77 	.destructor	= afs_cm_destructor,
78 	.work		= SRXAFSCB_Probe,
79 };
80 
81 /*
82  * CB.ProbeUuid operation type
83  */
84 static CM_NAME(ProbeUuid);
85 static const struct afs_call_type afs_SRXCBProbeUuid = {
86 	.name		= afs_SRXCBProbeUuid_name,
87 	.deliver	= afs_deliver_cb_probe_uuid,
88 	.destructor	= afs_cm_destructor,
89 	.work		= SRXAFSCB_ProbeUuid,
90 };
91 
92 /*
93  * CB.TellMeAboutYourself operation type
94  */
95 static CM_NAME(TellMeAboutYourself);
96 static const struct afs_call_type afs_SRXCBTellMeAboutYourself = {
97 	.name		= afs_SRXCBTellMeAboutYourself_name,
98 	.deliver	= afs_deliver_cb_tell_me_about_yourself,
99 	.destructor	= afs_cm_destructor,
100 	.work		= SRXAFSCB_TellMeAboutYourself,
101 };
102 
103 /*
104  * route an incoming cache manager call
105  * - return T if supported, F if not
106  */
afs_cm_incoming_call(struct afs_call * call)107 bool afs_cm_incoming_call(struct afs_call *call)
108 {
109 	_enter("{CB.OP %u}", call->operation_ID);
110 
111 	switch (call->operation_ID) {
112 	case CBCallBack:
113 		call->type = &afs_SRXCBCallBack;
114 		return true;
115 	case CBInitCallBackState:
116 		call->type = &afs_SRXCBInitCallBackState;
117 		return true;
118 	case CBInitCallBackState3:
119 		call->type = &afs_SRXCBInitCallBackState3;
120 		return true;
121 	case CBProbe:
122 		call->type = &afs_SRXCBProbe;
123 		return true;
124 	case CBProbeUuid:
125 		call->type = &afs_SRXCBProbeUuid;
126 		return true;
127 	case CBTellMeAboutYourself:
128 		call->type = &afs_SRXCBTellMeAboutYourself;
129 		return true;
130 	default:
131 		return false;
132 	}
133 }
134 
135 /*
136  * Clean up a cache manager call.
137  */
afs_cm_destructor(struct afs_call * call)138 static void afs_cm_destructor(struct afs_call *call)
139 {
140 	kfree(call->buffer);
141 	call->buffer = NULL;
142 }
143 
144 /*
145  * The server supplied a list of callbacks that it wanted to break.
146  */
SRXAFSCB_CallBack(struct work_struct * work)147 static void SRXAFSCB_CallBack(struct work_struct *work)
148 {
149 	struct afs_call *call = container_of(work, struct afs_call, work);
150 
151 	_enter("");
152 
153 	/* We need to break the callbacks before sending the reply as the
154 	 * server holds up change visibility till it receives our reply so as
155 	 * to maintain cache coherency.
156 	 */
157 	if (call->cm_server)
158 		afs_break_callbacks(call->cm_server, call->count, call->request);
159 
160 	afs_send_empty_reply(call);
161 	afs_put_call(call);
162 	_leave("");
163 }
164 
165 /*
166  * deliver request data to a CB.CallBack call
167  */
afs_deliver_cb_callback(struct afs_call * call)168 static int afs_deliver_cb_callback(struct afs_call *call)
169 {
170 	struct afs_callback_break *cb;
171 	struct sockaddr_rxrpc srx;
172 	__be32 *bp;
173 	int ret, loop;
174 
175 	_enter("{%u}", call->unmarshall);
176 
177 	switch (call->unmarshall) {
178 	case 0:
179 		call->offset = 0;
180 		call->unmarshall++;
181 
182 		/* extract the FID array and its count in two steps */
183 	case 1:
184 		_debug("extract FID count");
185 		ret = afs_extract_data(call, &call->tmp, 4, true);
186 		if (ret < 0)
187 			return ret;
188 
189 		call->count = ntohl(call->tmp);
190 		_debug("FID count: %u", call->count);
191 		if (call->count > AFSCBMAX)
192 			return afs_protocol_error(call, -EBADMSG);
193 
194 		call->buffer = kmalloc(array3_size(call->count, 3, 4),
195 				       GFP_KERNEL);
196 		if (!call->buffer)
197 			return -ENOMEM;
198 		call->offset = 0;
199 		call->unmarshall++;
200 
201 	case 2:
202 		_debug("extract FID array");
203 		ret = afs_extract_data(call, call->buffer,
204 				       call->count * 3 * 4, true);
205 		if (ret < 0)
206 			return ret;
207 
208 		_debug("unmarshall FID array");
209 		call->request = kcalloc(call->count,
210 					sizeof(struct afs_callback_break),
211 					GFP_KERNEL);
212 		if (!call->request)
213 			return -ENOMEM;
214 
215 		cb = call->request;
216 		bp = call->buffer;
217 		for (loop = call->count; loop > 0; loop--, cb++) {
218 			cb->fid.vid	= ntohl(*bp++);
219 			cb->fid.vnode	= ntohl(*bp++);
220 			cb->fid.unique	= ntohl(*bp++);
221 			cb->cb.type	= AFSCM_CB_UNTYPED;
222 		}
223 
224 		call->offset = 0;
225 		call->unmarshall++;
226 
227 		/* extract the callback array and its count in two steps */
228 	case 3:
229 		_debug("extract CB count");
230 		ret = afs_extract_data(call, &call->tmp, 4, true);
231 		if (ret < 0)
232 			return ret;
233 
234 		call->count2 = ntohl(call->tmp);
235 		_debug("CB count: %u", call->count2);
236 		if (call->count2 != call->count && call->count2 != 0)
237 			return afs_protocol_error(call, -EBADMSG);
238 		call->offset = 0;
239 		call->unmarshall++;
240 
241 	case 4:
242 		_debug("extract CB array");
243 		ret = afs_extract_data(call, call->buffer,
244 				       call->count2 * 3 * 4, false);
245 		if (ret < 0)
246 			return ret;
247 
248 		_debug("unmarshall CB array");
249 		cb = call->request;
250 		bp = call->buffer;
251 		for (loop = call->count2; loop > 0; loop--, cb++) {
252 			cb->cb.version	= ntohl(*bp++);
253 			cb->cb.expiry	= ntohl(*bp++);
254 			cb->cb.type	= ntohl(*bp++);
255 		}
256 
257 		call->offset = 0;
258 		call->unmarshall++;
259 	case 5:
260 		break;
261 	}
262 
263 	if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING))
264 		return -EIO;
265 
266 	/* we'll need the file server record as that tells us which set of
267 	 * vnodes to operate upon */
268 	rxrpc_kernel_get_peer(call->net->socket, call->rxcall, &srx);
269 	call->cm_server = afs_find_server(call->net, &srx);
270 	if (!call->cm_server)
271 		trace_afs_cm_no_server(call, &srx);
272 
273 	return afs_queue_call_work(call);
274 }
275 
276 /*
277  * allow the fileserver to request callback state (re-)initialisation
278  */
SRXAFSCB_InitCallBackState(struct work_struct * work)279 static void SRXAFSCB_InitCallBackState(struct work_struct *work)
280 {
281 	struct afs_call *call = container_of(work, struct afs_call, work);
282 
283 	_enter("{%p}", call->cm_server);
284 
285 	if (call->cm_server)
286 		afs_init_callback_state(call->cm_server);
287 	afs_send_empty_reply(call);
288 	afs_put_call(call);
289 	_leave("");
290 }
291 
292 /*
293  * deliver request data to a CB.InitCallBackState call
294  */
afs_deliver_cb_init_call_back_state(struct afs_call * call)295 static int afs_deliver_cb_init_call_back_state(struct afs_call *call)
296 {
297 	struct sockaddr_rxrpc srx;
298 	int ret;
299 
300 	_enter("");
301 
302 	rxrpc_kernel_get_peer(call->net->socket, call->rxcall, &srx);
303 
304 	ret = afs_extract_data(call, NULL, 0, false);
305 	if (ret < 0)
306 		return ret;
307 
308 	/* we'll need the file server record as that tells us which set of
309 	 * vnodes to operate upon */
310 	call->cm_server = afs_find_server(call->net, &srx);
311 	if (!call->cm_server)
312 		trace_afs_cm_no_server(call, &srx);
313 
314 	return afs_queue_call_work(call);
315 }
316 
317 /*
318  * deliver request data to a CB.InitCallBackState3 call
319  */
afs_deliver_cb_init_call_back_state3(struct afs_call * call)320 static int afs_deliver_cb_init_call_back_state3(struct afs_call *call)
321 {
322 	struct afs_uuid *r;
323 	unsigned loop;
324 	__be32 *b;
325 	int ret;
326 
327 	_enter("");
328 
329 	_enter("{%u}", call->unmarshall);
330 
331 	switch (call->unmarshall) {
332 	case 0:
333 		call->offset = 0;
334 		call->buffer = kmalloc_array(11, sizeof(__be32), GFP_KERNEL);
335 		if (!call->buffer)
336 			return -ENOMEM;
337 		call->unmarshall++;
338 
339 	case 1:
340 		_debug("extract UUID");
341 		ret = afs_extract_data(call, call->buffer,
342 				       11 * sizeof(__be32), false);
343 		switch (ret) {
344 		case 0:		break;
345 		case -EAGAIN:	return 0;
346 		default:	return ret;
347 		}
348 
349 		_debug("unmarshall UUID");
350 		call->request = kmalloc(sizeof(struct afs_uuid), GFP_KERNEL);
351 		if (!call->request)
352 			return -ENOMEM;
353 
354 		b = call->buffer;
355 		r = call->request;
356 		r->time_low			= b[0];
357 		r->time_mid			= htons(ntohl(b[1]));
358 		r->time_hi_and_version		= htons(ntohl(b[2]));
359 		r->clock_seq_hi_and_reserved 	= ntohl(b[3]);
360 		r->clock_seq_low		= ntohl(b[4]);
361 
362 		for (loop = 0; loop < 6; loop++)
363 			r->node[loop] = ntohl(b[loop + 5]);
364 
365 		call->offset = 0;
366 		call->unmarshall++;
367 
368 	case 2:
369 		break;
370 	}
371 
372 	if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING))
373 		return -EIO;
374 
375 	/* we'll need the file server record as that tells us which set of
376 	 * vnodes to operate upon */
377 	rcu_read_lock();
378 	call->cm_server = afs_find_server_by_uuid(call->net, call->request);
379 	rcu_read_unlock();
380 	if (!call->cm_server)
381 		trace_afs_cm_no_server_u(call, call->request);
382 
383 	return afs_queue_call_work(call);
384 }
385 
386 /*
387  * allow the fileserver to see if the cache manager is still alive
388  */
SRXAFSCB_Probe(struct work_struct * work)389 static void SRXAFSCB_Probe(struct work_struct *work)
390 {
391 	struct afs_call *call = container_of(work, struct afs_call, work);
392 
393 	_enter("");
394 	afs_send_empty_reply(call);
395 	afs_put_call(call);
396 	_leave("");
397 }
398 
399 /*
400  * deliver request data to a CB.Probe call
401  */
afs_deliver_cb_probe(struct afs_call * call)402 static int afs_deliver_cb_probe(struct afs_call *call)
403 {
404 	int ret;
405 
406 	_enter("");
407 
408 	ret = afs_extract_data(call, NULL, 0, false);
409 	if (ret < 0)
410 		return ret;
411 
412 	if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING))
413 		return -EIO;
414 
415 	return afs_queue_call_work(call);
416 }
417 
418 /*
419  * allow the fileserver to quickly find out if the fileserver has been rebooted
420  */
SRXAFSCB_ProbeUuid(struct work_struct * work)421 static void SRXAFSCB_ProbeUuid(struct work_struct *work)
422 {
423 	struct afs_call *call = container_of(work, struct afs_call, work);
424 	struct afs_uuid *r = call->request;
425 
426 	_enter("");
427 
428 	if (memcmp(r, &call->net->uuid, sizeof(call->net->uuid)) == 0)
429 		afs_send_empty_reply(call);
430 	else
431 		rxrpc_kernel_abort_call(call->net->socket, call->rxcall,
432 					1, 1, "K-1");
433 
434 	afs_put_call(call);
435 	_leave("");
436 }
437 
438 /*
439  * deliver request data to a CB.ProbeUuid call
440  */
afs_deliver_cb_probe_uuid(struct afs_call * call)441 static int afs_deliver_cb_probe_uuid(struct afs_call *call)
442 {
443 	struct afs_uuid *r;
444 	unsigned loop;
445 	__be32 *b;
446 	int ret;
447 
448 	_enter("{%u}", call->unmarshall);
449 
450 	switch (call->unmarshall) {
451 	case 0:
452 		call->offset = 0;
453 		call->buffer = kmalloc_array(11, sizeof(__be32), GFP_KERNEL);
454 		if (!call->buffer)
455 			return -ENOMEM;
456 		call->unmarshall++;
457 
458 	case 1:
459 		_debug("extract UUID");
460 		ret = afs_extract_data(call, call->buffer,
461 				       11 * sizeof(__be32), false);
462 		switch (ret) {
463 		case 0:		break;
464 		case -EAGAIN:	return 0;
465 		default:	return ret;
466 		}
467 
468 		_debug("unmarshall UUID");
469 		call->request = kmalloc(sizeof(struct afs_uuid), GFP_KERNEL);
470 		if (!call->request)
471 			return -ENOMEM;
472 
473 		b = call->buffer;
474 		r = call->request;
475 		r->time_low			= b[0];
476 		r->time_mid			= htons(ntohl(b[1]));
477 		r->time_hi_and_version		= htons(ntohl(b[2]));
478 		r->clock_seq_hi_and_reserved 	= ntohl(b[3]);
479 		r->clock_seq_low		= ntohl(b[4]);
480 
481 		for (loop = 0; loop < 6; loop++)
482 			r->node[loop] = ntohl(b[loop + 5]);
483 
484 		call->offset = 0;
485 		call->unmarshall++;
486 
487 	case 2:
488 		break;
489 	}
490 
491 	if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING))
492 		return -EIO;
493 
494 	return afs_queue_call_work(call);
495 }
496 
497 /*
498  * allow the fileserver to ask about the cache manager's capabilities
499  */
SRXAFSCB_TellMeAboutYourself(struct work_struct * work)500 static void SRXAFSCB_TellMeAboutYourself(struct work_struct *work)
501 {
502 	struct afs_interface *ifs;
503 	struct afs_call *call = container_of(work, struct afs_call, work);
504 	int loop, nifs;
505 
506 	struct {
507 		struct /* InterfaceAddr */ {
508 			__be32 nifs;
509 			__be32 uuid[11];
510 			__be32 ifaddr[32];
511 			__be32 netmask[32];
512 			__be32 mtu[32];
513 		} ia;
514 		struct /* Capabilities */ {
515 			__be32 capcount;
516 			__be32 caps[1];
517 		} cap;
518 	} reply;
519 
520 	_enter("");
521 
522 	nifs = 0;
523 	ifs = kcalloc(32, sizeof(*ifs), GFP_KERNEL);
524 	if (ifs) {
525 		nifs = afs_get_ipv4_interfaces(call->net, ifs, 32, false);
526 		if (nifs < 0) {
527 			kfree(ifs);
528 			ifs = NULL;
529 			nifs = 0;
530 		}
531 	}
532 
533 	memset(&reply, 0, sizeof(reply));
534 	reply.ia.nifs = htonl(nifs);
535 
536 	reply.ia.uuid[0] = call->net->uuid.time_low;
537 	reply.ia.uuid[1] = htonl(ntohs(call->net->uuid.time_mid));
538 	reply.ia.uuid[2] = htonl(ntohs(call->net->uuid.time_hi_and_version));
539 	reply.ia.uuid[3] = htonl((s8) call->net->uuid.clock_seq_hi_and_reserved);
540 	reply.ia.uuid[4] = htonl((s8) call->net->uuid.clock_seq_low);
541 	for (loop = 0; loop < 6; loop++)
542 		reply.ia.uuid[loop + 5] = htonl((s8) call->net->uuid.node[loop]);
543 
544 	if (ifs) {
545 		for (loop = 0; loop < nifs; loop++) {
546 			reply.ia.ifaddr[loop] = ifs[loop].address.s_addr;
547 			reply.ia.netmask[loop] = ifs[loop].netmask.s_addr;
548 			reply.ia.mtu[loop] = htonl(ifs[loop].mtu);
549 		}
550 		kfree(ifs);
551 	}
552 
553 	reply.cap.capcount = htonl(1);
554 	reply.cap.caps[0] = htonl(AFS_CAP_ERROR_TRANSLATION);
555 	afs_send_simple_reply(call, &reply, sizeof(reply));
556 	afs_put_call(call);
557 	_leave("");
558 }
559 
560 /*
561  * deliver request data to a CB.TellMeAboutYourself call
562  */
afs_deliver_cb_tell_me_about_yourself(struct afs_call * call)563 static int afs_deliver_cb_tell_me_about_yourself(struct afs_call *call)
564 {
565 	int ret;
566 
567 	_enter("");
568 
569 	ret = afs_extract_data(call, NULL, 0, false);
570 	if (ret < 0)
571 		return ret;
572 
573 	if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING))
574 		return -EIO;
575 
576 	return afs_queue_call_work(call);
577 }
578