Merge master.kernel.org:/pub/scm/linux/kernel/git/davej/cpufreq
[linux-2.6] / fs / afs / vlclient.c
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() */