xref: /openbmc/linux/fs/afs/vlclient.c (revision d5cb9783536a41df9f9cba5b0a1d78047ed787f7)
1 /* vlclient.c: AFS Volume Location Service client
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/init.h>
13 #include <linux/sched.h>
14 #include <rxrpc/rxrpc.h>
15 #include <rxrpc/transport.h>
16 #include <rxrpc/connection.h>
17 #include <rxrpc/call.h>
18 #include "server.h"
19 #include "volume.h"
20 #include "vlclient.h"
21 #include "kafsasyncd.h"
22 #include "kafstimod.h"
23 #include "errors.h"
24 #include "internal.h"
25 
26 #define VLGETENTRYBYID		503	/* AFS Get Cache Entry By ID operation ID */
27 #define VLGETENTRYBYNAME	504	/* AFS Get Cache Entry By Name operation ID */
28 #define VLPROBE			514	/* AFS Probe Volume Location Service operation ID */
29 
30 static void afs_rxvl_get_entry_by_id_attn(struct rxrpc_call *call);
31 static void afs_rxvl_get_entry_by_id_error(struct rxrpc_call *call);
32 
33 /*****************************************************************************/
34 /*
35  * map afs VL abort codes to/from Linux error codes
36  * - called with call->lock held
37  */
38 static void afs_rxvl_aemap(struct rxrpc_call *call)
39 {
40 	int err;
41 
42 	_enter("{%u,%u,%d}",
43 	       call->app_err_state, call->app_abort_code, call->app_errno);
44 
45 	switch (call->app_err_state) {
46 	case RXRPC_ESTATE_LOCAL_ABORT:
47 		call->app_abort_code = -call->app_errno;
48 		return;
49 
50 	case RXRPC_ESTATE_PEER_ABORT:
51 		switch (call->app_abort_code) {
52 		case AFSVL_IDEXIST:		err = -EEXIST;		break;
53 		case AFSVL_IO:			err = -EREMOTEIO;	break;
54 		case AFSVL_NAMEEXIST:		err = -EEXIST;		break;
55 		case AFSVL_CREATEFAIL:		err = -EREMOTEIO;	break;
56 		case AFSVL_NOENT:		err = -ENOMEDIUM;	break;
57 		case AFSVL_EMPTY:		err = -ENOMEDIUM;	break;
58 		case AFSVL_ENTDELETED:		err = -ENOMEDIUM;	break;
59 		case AFSVL_BADNAME:		err = -EINVAL;		break;
60 		case AFSVL_BADINDEX:		err = -EINVAL;		break;
61 		case AFSVL_BADVOLTYPE:		err = -EINVAL;		break;
62 		case AFSVL_BADSERVER:		err = -EINVAL;		break;
63 		case AFSVL_BADPARTITION:	err = -EINVAL;		break;
64 		case AFSVL_REPSFULL:		err = -EFBIG;		break;
65 		case AFSVL_NOREPSERVER:		err = -ENOENT;		break;
66 		case AFSVL_DUPREPSERVER:	err = -EEXIST;		break;
67 		case AFSVL_RWNOTFOUND:		err = -ENOENT;		break;
68 		case AFSVL_BADREFCOUNT:		err = -EINVAL;		break;
69 		case AFSVL_SIZEEXCEEDED:	err = -EINVAL;		break;
70 		case AFSVL_BADENTRY:		err = -EINVAL;		break;
71 		case AFSVL_BADVOLIDBUMP:	err = -EINVAL;		break;
72 		case AFSVL_IDALREADYHASHED:	err = -EINVAL;		break;
73 		case AFSVL_ENTRYLOCKED:		err = -EBUSY;		break;
74 		case AFSVL_BADVOLOPER:		err = -EBADRQC;		break;
75 		case AFSVL_BADRELLOCKTYPE:	err = -EINVAL;		break;
76 		case AFSVL_RERELEASE:		err = -EREMOTEIO;	break;
77 		case AFSVL_BADSERVERFLAG:	err = -EINVAL;		break;
78 		case AFSVL_PERM:		err = -EACCES;		break;
79 		case AFSVL_NOMEM:		err = -EREMOTEIO;	break;
80 		default:
81 			err = afs_abort_to_error(call->app_abort_code);
82 			break;
83 		}
84 		call->app_errno = err;
85 		return;
86 
87 	default:
88 		return;
89 	}
90 } /* end afs_rxvl_aemap() */
91 
92 #if 0
93 /*****************************************************************************/
94 /*
95  * probe a volume location server to see if it is still alive -- unused
96  */
97 static int afs_rxvl_probe(struct afs_server *server, int alloc_flags)
98 {
99 	struct rxrpc_connection *conn;
100 	struct rxrpc_call *call;
101 	struct kvec piov[1];
102 	size_t sent;
103 	int ret;
104 	__be32 param[1];
105 
106 	DECLARE_WAITQUEUE(myself, current);
107 
108 	/* get hold of the vlserver connection */
109 	ret = afs_server_get_vlconn(server, &conn);
110 	if (ret < 0)
111 		goto out;
112 
113 	/* create a call through that connection */
114 	ret = rxrpc_create_call(conn, NULL, NULL, afs_rxvl_aemap, &call);
115 	if (ret < 0) {
116 		printk("kAFS: Unable to create call: %d\n", ret);
117 		goto out_put_conn;
118 	}
119 	call->app_opcode = VLPROBE;
120 
121 	/* we want to get event notifications from the call */
122 	add_wait_queue(&call->waitq, &myself);
123 
124 	/* marshall the parameters */
125 	param[0] = htonl(VLPROBE);
126 	piov[0].iov_len = sizeof(param);
127 	piov[0].iov_base = param;
128 
129 	/* send the parameters to the server */
130 	ret = rxrpc_call_write_data(call, 1, piov, RXRPC_LAST_PACKET,
131 				    alloc_flags, 0, &sent);
132 	if (ret < 0)
133 		goto abort;
134 
135 	/* wait for the reply to completely arrive */
136 	for (;;) {
137 		set_current_state(TASK_INTERRUPTIBLE);
138 		if (call->app_call_state != RXRPC_CSTATE_CLNT_RCV_REPLY ||
139 		    signal_pending(current))
140 			break;
141 		schedule();
142 	}
143 	set_current_state(TASK_RUNNING);
144 
145 	ret = -EINTR;
146 	if (signal_pending(current))
147 		goto abort;
148 
149 	switch (call->app_call_state) {
150 	case RXRPC_CSTATE_ERROR:
151 		ret = call->app_errno;
152 		goto out_unwait;
153 
154 	case RXRPC_CSTATE_CLNT_GOT_REPLY:
155 		ret = 0;
156 		goto out_unwait;
157 
158 	default:
159 		BUG();
160 	}
161 
162  abort:
163 	set_current_state(TASK_UNINTERRUPTIBLE);
164 	rxrpc_call_abort(call, ret);
165 	schedule();
166 
167  out_unwait:
168 	set_current_state(TASK_RUNNING);
169 	remove_wait_queue(&call->waitq, &myself);
170 	rxrpc_put_call(call);
171  out_put_conn:
172 	rxrpc_put_connection(conn);
173  out:
174 	return ret;
175 
176 } /* end afs_rxvl_probe() */
177 #endif
178 
179 /*****************************************************************************/
180 /*
181  * look up a volume location database entry by name
182  */
183 int afs_rxvl_get_entry_by_name(struct afs_server *server,
184 			       const char *volname,
185 			       unsigned volnamesz,
186 			       struct afs_cache_vlocation *entry)
187 {
188 	DECLARE_WAITQUEUE(myself, current);
189 
190 	struct rxrpc_connection *conn;
191 	struct rxrpc_call *call;
192 	struct kvec piov[3];
193 	unsigned tmp;
194 	size_t sent;
195 	int ret, loop;
196 	__be32 *bp, param[2], zero;
197 
198 	_enter(",%*.*s,%u,", volnamesz, volnamesz, volname, volnamesz);
199 
200 	memset(entry, 0, sizeof(*entry));
201 
202 	/* get hold of the vlserver connection */
203 	ret = afs_server_get_vlconn(server, &conn);
204 	if (ret < 0)
205 		goto out;
206 
207 	/* create a call through that connection */
208 	ret = rxrpc_create_call(conn, NULL, NULL, afs_rxvl_aemap, &call);
209 	if (ret < 0) {
210 		printk("kAFS: Unable to create call: %d\n", ret);
211 		goto out_put_conn;
212 	}
213 	call->app_opcode = VLGETENTRYBYNAME;
214 
215 	/* we want to get event notifications from the call */
216 	add_wait_queue(&call->waitq, &myself);
217 
218 	/* marshall the parameters */
219 	piov[1].iov_len = volnamesz;
220 	piov[1].iov_base = (char *) volname;
221 
222 	zero = 0;
223 	piov[2].iov_len = (4 - (piov[1].iov_len & 3)) & 3;
224 	piov[2].iov_base = &zero;
225 
226 	param[0] = htonl(VLGETENTRYBYNAME);
227 	param[1] = htonl(piov[1].iov_len);
228 
229 	piov[0].iov_len = sizeof(param);
230 	piov[0].iov_base = param;
231 
232 	/* send the parameters to the server */
233 	ret = rxrpc_call_write_data(call, 3, piov, RXRPC_LAST_PACKET, GFP_NOFS,
234 				    0, &sent);
235 	if (ret < 0)
236 		goto abort;
237 
238 	/* wait for the reply to completely arrive */
239 	bp = rxrpc_call_alloc_scratch(call, 384);
240 
241 	ret = rxrpc_call_read_data(call, bp, 384,
242 				   RXRPC_CALL_READ_BLOCK |
243 				   RXRPC_CALL_READ_ALL);
244 	if (ret < 0) {
245 		if (ret == -ECONNABORTED) {
246 			ret = call->app_errno;
247 			goto out_unwait;
248 		}
249 		goto abort;
250 	}
251 
252 	/* unmarshall the reply */
253 	for (loop = 0; loop < 64; loop++)
254 		entry->name[loop] = ntohl(*bp++);
255 	bp++; /* final NUL */
256 
257 	bp++; /* type */
258 	entry->nservers = ntohl(*bp++);
259 
260 	for (loop = 0; loop < 8; loop++)
261 		entry->servers[loop].s_addr = *bp++;
262 
263 	bp += 8; /* partition IDs */
264 
265 	for (loop = 0; loop < 8; loop++) {
266 		tmp = ntohl(*bp++);
267 		if (tmp & AFS_VLSF_RWVOL)
268 			entry->srvtmask[loop] |= AFS_VOL_VTM_RW;
269 		if (tmp & AFS_VLSF_ROVOL)
270 			entry->srvtmask[loop] |= AFS_VOL_VTM_RO;
271 		if (tmp & AFS_VLSF_BACKVOL)
272 			entry->srvtmask[loop] |= AFS_VOL_VTM_BAK;
273 	}
274 
275 	entry->vid[0] = ntohl(*bp++);
276 	entry->vid[1] = ntohl(*bp++);
277 	entry->vid[2] = ntohl(*bp++);
278 
279 	bp++; /* clone ID */
280 
281 	tmp = ntohl(*bp++); /* flags */
282 	if (tmp & AFS_VLF_RWEXISTS)
283 		entry->vidmask |= AFS_VOL_VTM_RW;
284 	if (tmp & AFS_VLF_ROEXISTS)
285 		entry->vidmask |= AFS_VOL_VTM_RO;
286 	if (tmp & AFS_VLF_BACKEXISTS)
287 		entry->vidmask |= AFS_VOL_VTM_BAK;
288 
289 	ret = -ENOMEDIUM;
290 	if (!entry->vidmask)
291 		goto abort;
292 
293 	/* success */
294 	entry->rtime = get_seconds();
295 	ret = 0;
296 
297  out_unwait:
298 	set_current_state(TASK_RUNNING);
299 	remove_wait_queue(&call->waitq, &myself);
300 	rxrpc_put_call(call);
301  out_put_conn:
302 	rxrpc_put_connection(conn);
303  out:
304 	_leave(" = %d", ret);
305 	return ret;
306 
307  abort:
308 	set_current_state(TASK_UNINTERRUPTIBLE);
309 	rxrpc_call_abort(call, ret);
310 	schedule();
311 	goto out_unwait;
312 } /* end afs_rxvl_get_entry_by_name() */
313 
314 /*****************************************************************************/
315 /*
316  * look up a volume location database entry by ID
317  */
318 int afs_rxvl_get_entry_by_id(struct afs_server *server,
319 			     afs_volid_t volid,
320 			     afs_voltype_t voltype,
321 			     struct afs_cache_vlocation *entry)
322 {
323 	DECLARE_WAITQUEUE(myself, current);
324 
325 	struct rxrpc_connection *conn;
326 	struct rxrpc_call *call;
327 	struct kvec piov[1];
328 	unsigned tmp;
329 	size_t sent;
330 	int ret, loop;
331 	__be32 *bp, param[3];
332 
333 	_enter(",%x,%d,", volid, voltype);
334 
335 	memset(entry, 0, sizeof(*entry));
336 
337 	/* get hold of the vlserver connection */
338 	ret = afs_server_get_vlconn(server, &conn);
339 	if (ret < 0)
340 		goto out;
341 
342 	/* create a call through that connection */
343 	ret = rxrpc_create_call(conn, NULL, NULL, afs_rxvl_aemap, &call);
344 	if (ret < 0) {
345 		printk("kAFS: Unable to create call: %d\n", ret);
346 		goto out_put_conn;
347 	}
348 	call->app_opcode = VLGETENTRYBYID;
349 
350 	/* we want to get event notifications from the call */
351 	add_wait_queue(&call->waitq, &myself);
352 
353 	/* marshall the parameters */
354 	param[0] = htonl(VLGETENTRYBYID);
355 	param[1] = htonl(volid);
356 	param[2] = htonl(voltype);
357 
358 	piov[0].iov_len = sizeof(param);
359 	piov[0].iov_base = param;
360 
361 	/* send the parameters to the server */
362 	ret = rxrpc_call_write_data(call, 1, piov, RXRPC_LAST_PACKET, GFP_NOFS,
363 				    0, &sent);
364 	if (ret < 0)
365 		goto abort;
366 
367 	/* wait for the reply to completely arrive */
368 	bp = rxrpc_call_alloc_scratch(call, 384);
369 
370 	ret = rxrpc_call_read_data(call, bp, 384,
371 				   RXRPC_CALL_READ_BLOCK |
372 				   RXRPC_CALL_READ_ALL);
373 	if (ret < 0) {
374 		if (ret == -ECONNABORTED) {
375 			ret = call->app_errno;
376 			goto out_unwait;
377 		}
378 		goto abort;
379 	}
380 
381 	/* unmarshall the reply */
382 	for (loop = 0; loop < 64; loop++)
383 		entry->name[loop] = ntohl(*bp++);
384 	bp++; /* final NUL */
385 
386 	bp++; /* type */
387 	entry->nservers = ntohl(*bp++);
388 
389 	for (loop = 0; loop < 8; loop++)
390 		entry->servers[loop].s_addr = *bp++;
391 
392 	bp += 8; /* partition IDs */
393 
394 	for (loop = 0; loop < 8; loop++) {
395 		tmp = ntohl(*bp++);
396 		if (tmp & AFS_VLSF_RWVOL)
397 			entry->srvtmask[loop] |= AFS_VOL_VTM_RW;
398 		if (tmp & AFS_VLSF_ROVOL)
399 			entry->srvtmask[loop] |= AFS_VOL_VTM_RO;
400 		if (tmp & AFS_VLSF_BACKVOL)
401 			entry->srvtmask[loop] |= AFS_VOL_VTM_BAK;
402 	}
403 
404 	entry->vid[0] = ntohl(*bp++);
405 	entry->vid[1] = ntohl(*bp++);
406 	entry->vid[2] = ntohl(*bp++);
407 
408 	bp++; /* clone ID */
409 
410 	tmp = ntohl(*bp++); /* flags */
411 	if (tmp & AFS_VLF_RWEXISTS)
412 		entry->vidmask |= AFS_VOL_VTM_RW;
413 	if (tmp & AFS_VLF_ROEXISTS)
414 		entry->vidmask |= AFS_VOL_VTM_RO;
415 	if (tmp & AFS_VLF_BACKEXISTS)
416 		entry->vidmask |= AFS_VOL_VTM_BAK;
417 
418 	ret = -ENOMEDIUM;
419 	if (!entry->vidmask)
420 		goto abort;
421 
422 #if 0 /* TODO: remove */
423 	entry->nservers = 3;
424 	entry->servers[0].s_addr = htonl(0xac101249);
425 	entry->servers[1].s_addr = htonl(0xac101243);
426 	entry->servers[2].s_addr = htonl(0xac10125b /*0xac10125b*/);
427 
428 	entry->srvtmask[0] = AFS_VOL_VTM_RO;
429 	entry->srvtmask[1] = AFS_VOL_VTM_RO;
430 	entry->srvtmask[2] = AFS_VOL_VTM_RO | AFS_VOL_VTM_RW;
431 #endif
432 
433 	/* success */
434 	entry->rtime = get_seconds();
435 	ret = 0;
436 
437  out_unwait:
438 	set_current_state(TASK_RUNNING);
439 	remove_wait_queue(&call->waitq, &myself);
440 	rxrpc_put_call(call);
441  out_put_conn:
442 	rxrpc_put_connection(conn);
443  out:
444 	_leave(" = %d", ret);
445 	return ret;
446 
447  abort:
448 	set_current_state(TASK_UNINTERRUPTIBLE);
449 	rxrpc_call_abort(call, ret);
450 	schedule();
451 	goto out_unwait;
452 } /* end afs_rxvl_get_entry_by_id() */
453 
454 /*****************************************************************************/
455 /*
456  * look up a volume location database entry by ID asynchronously
457  */
458 int afs_rxvl_get_entry_by_id_async(struct afs_async_op *op,
459 				   afs_volid_t volid,
460 				   afs_voltype_t voltype)
461 {
462 	struct rxrpc_connection *conn;
463 	struct rxrpc_call *call;
464 	struct kvec piov[1];
465 	size_t sent;
466 	int ret;
467 	__be32 param[3];
468 
469 	_enter(",%x,%d,", volid, voltype);
470 
471 	/* get hold of the vlserver connection */
472 	ret = afs_server_get_vlconn(op->server, &conn);
473 	if (ret < 0) {
474 		_leave(" = %d", ret);
475 		return ret;
476 	}
477 
478 	/* create a call through that connection */
479 	ret = rxrpc_create_call(conn,
480 				afs_rxvl_get_entry_by_id_attn,
481 				afs_rxvl_get_entry_by_id_error,
482 				afs_rxvl_aemap,
483 				&op->call);
484 	rxrpc_put_connection(conn);
485 
486 	if (ret < 0) {
487 		printk("kAFS: Unable to create call: %d\n", ret);
488 		_leave(" = %d", ret);
489 		return ret;
490 	}
491 
492 	op->call->app_opcode = VLGETENTRYBYID;
493 	op->call->app_user = op;
494 
495 	call = op->call;
496 	rxrpc_get_call(call);
497 
498 	/* send event notifications from the call to kafsasyncd */
499 	afs_kafsasyncd_begin_op(op);
500 
501 	/* marshall the parameters */
502 	param[0] = htonl(VLGETENTRYBYID);
503 	param[1] = htonl(volid);
504 	param[2] = htonl(voltype);
505 
506 	piov[0].iov_len = sizeof(param);
507 	piov[0].iov_base = param;
508 
509 	/* allocate result read buffer in scratch space */
510 	call->app_scr_ptr = rxrpc_call_alloc_scratch(op->call, 384);
511 
512 	/* send the parameters to the server */
513 	ret = rxrpc_call_write_data(call, 1, piov, RXRPC_LAST_PACKET, GFP_NOFS,
514 				    0, &sent);
515 	if (ret < 0) {
516 		rxrpc_call_abort(call, ret); /* handle from kafsasyncd */
517 		ret = 0;
518 		goto out;
519 	}
520 
521 	/* wait for the reply to completely arrive */
522 	ret = rxrpc_call_read_data(call, call->app_scr_ptr, 384, 0);
523 	switch (ret) {
524 	case 0:
525 	case -EAGAIN:
526 	case -ECONNABORTED:
527 		ret = 0;
528 		break;	/* all handled by kafsasyncd */
529 
530 	default:
531 		rxrpc_call_abort(call, ret); /* make kafsasyncd handle it */
532 		ret = 0;
533 		break;
534 	}
535 
536  out:
537 	rxrpc_put_call(call);
538 	_leave(" = %d", ret);
539 	return ret;
540 
541 } /* end afs_rxvl_get_entry_by_id_async() */
542 
543 /*****************************************************************************/
544 /*
545  * attend to the asynchronous get VLDB entry by ID
546  */
547 int afs_rxvl_get_entry_by_id_async2(struct afs_async_op *op,
548 				    struct afs_cache_vlocation *entry)
549 {
550 	__be32 *bp;
551 	__u32 tmp;
552 	int loop, ret;
553 
554 	_enter("{op=%p cst=%u}", op, op->call->app_call_state);
555 
556 	memset(entry, 0, sizeof(*entry));
557 
558 	if (op->call->app_call_state == RXRPC_CSTATE_COMPLETE) {
559 		/* operation finished */
560 		afs_kafsasyncd_terminate_op(op);
561 
562 		bp = op->call->app_scr_ptr;
563 
564 		/* unmarshall the reply */
565 		for (loop = 0; loop < 64; loop++)
566 			entry->name[loop] = ntohl(*bp++);
567 		bp++; /* final NUL */
568 
569 		bp++; /* type */
570 		entry->nservers = ntohl(*bp++);
571 
572 		for (loop = 0; loop < 8; loop++)
573 			entry->servers[loop].s_addr = *bp++;
574 
575 		bp += 8; /* partition IDs */
576 
577 		for (loop = 0; loop < 8; loop++) {
578 			tmp = ntohl(*bp++);
579 			if (tmp & AFS_VLSF_RWVOL)
580 				entry->srvtmask[loop] |= AFS_VOL_VTM_RW;
581 			if (tmp & AFS_VLSF_ROVOL)
582 				entry->srvtmask[loop] |= AFS_VOL_VTM_RO;
583 			if (tmp & AFS_VLSF_BACKVOL)
584 				entry->srvtmask[loop] |= AFS_VOL_VTM_BAK;
585 		}
586 
587 		entry->vid[0] = ntohl(*bp++);
588 		entry->vid[1] = ntohl(*bp++);
589 		entry->vid[2] = ntohl(*bp++);
590 
591 		bp++; /* clone ID */
592 
593 		tmp = ntohl(*bp++); /* flags */
594 		if (tmp & AFS_VLF_RWEXISTS)
595 			entry->vidmask |= AFS_VOL_VTM_RW;
596 		if (tmp & AFS_VLF_ROEXISTS)
597 			entry->vidmask |= AFS_VOL_VTM_RO;
598 		if (tmp & AFS_VLF_BACKEXISTS)
599 			entry->vidmask |= AFS_VOL_VTM_BAK;
600 
601 		ret = -ENOMEDIUM;
602 		if (!entry->vidmask) {
603 			rxrpc_call_abort(op->call, ret);
604 			goto done;
605 		}
606 
607 #if 0 /* TODO: remove */
608 		entry->nservers = 3;
609 		entry->servers[0].s_addr = htonl(0xac101249);
610 		entry->servers[1].s_addr = htonl(0xac101243);
611 		entry->servers[2].s_addr = htonl(0xac10125b /*0xac10125b*/);
612 
613 		entry->srvtmask[0] = AFS_VOL_VTM_RO;
614 		entry->srvtmask[1] = AFS_VOL_VTM_RO;
615 		entry->srvtmask[2] = AFS_VOL_VTM_RO | AFS_VOL_VTM_RW;
616 #endif
617 
618 		/* success */
619 		entry->rtime = get_seconds();
620 		ret = 0;
621 		goto done;
622 	}
623 
624 	if (op->call->app_call_state == RXRPC_CSTATE_ERROR) {
625 		/* operation error */
626 		ret = op->call->app_errno;
627 		goto done;
628 	}
629 
630 	_leave(" = -EAGAIN");
631 	return -EAGAIN;
632 
633  done:
634 	rxrpc_put_call(op->call);
635 	op->call = NULL;
636 	_leave(" = %d", ret);
637 	return ret;
638 } /* end afs_rxvl_get_entry_by_id_async2() */
639 
640 /*****************************************************************************/
641 /*
642  * handle attention events on an async get-entry-by-ID op
643  * - called from krxiod
644  */
645 static void afs_rxvl_get_entry_by_id_attn(struct rxrpc_call *call)
646 {
647 	struct afs_async_op *op = call->app_user;
648 
649 	_enter("{op=%p cst=%u}", op, call->app_call_state);
650 
651 	switch (call->app_call_state) {
652 	case RXRPC_CSTATE_COMPLETE:
653 		afs_kafsasyncd_attend_op(op);
654 		break;
655 	case RXRPC_CSTATE_CLNT_RCV_REPLY:
656 		if (call->app_async_read)
657 			break;
658 	case RXRPC_CSTATE_CLNT_GOT_REPLY:
659 		if (call->app_read_count == 0)
660 			break;
661 		printk("kAFS: Reply bigger than expected"
662 		       " {cst=%u asyn=%d mark=%Zu rdy=%Zu pr=%u%s}",
663 		       call->app_call_state,
664 		       call->app_async_read,
665 		       call->app_mark,
666 		       call->app_ready_qty,
667 		       call->pkt_rcv_count,
668 		       call->app_last_rcv ? " last" : "");
669 
670 		rxrpc_call_abort(call, -EBADMSG);
671 		break;
672 	default:
673 		BUG();
674 	}
675 
676 	_leave("");
677 
678 } /* end afs_rxvl_get_entry_by_id_attn() */
679 
680 /*****************************************************************************/
681 /*
682  * handle error events on an async get-entry-by-ID op
683  * - called from krxiod
684  */
685 static void afs_rxvl_get_entry_by_id_error(struct rxrpc_call *call)
686 {
687 	struct afs_async_op *op = call->app_user;
688 
689 	_enter("{op=%p cst=%u}", op, call->app_call_state);
690 
691 	afs_kafsasyncd_attend_op(op);
692 
693 	_leave("");
694 
695 } /* end afs_rxvl_get_entry_by_id_error() */
696