[AFS]: Clean up the AFS sources
[linux-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/sched.h>
15 #include <linux/completion.h>
16 #include "server.h"
17 #include "cell.h"
18 #include "transport.h"
19 #include <rxrpc/rxrpc.h>
20 #include <rxrpc/transport.h>
21 #include <rxrpc/connection.h>
22 #include <rxrpc/call.h>
23 #include "cmservice.h"
24 #include "internal.h"
25
26 static unsigned afscm_usage;            /* AFS cache manager usage count */
27 static struct rw_semaphore afscm_sem;   /* AFS cache manager start/stop semaphore */
28
29 static int afscm_new_call(struct rxrpc_call *call);
30 static void afscm_attention(struct rxrpc_call *call);
31 static void afscm_error(struct rxrpc_call *call);
32 static void afscm_aemap(struct rxrpc_call *call);
33
34 static void _SRXAFSCM_CallBack(struct rxrpc_call *call);
35 static void _SRXAFSCM_InitCallBackState(struct rxrpc_call *call);
36 static void _SRXAFSCM_Probe(struct rxrpc_call *call);
37
38 typedef void (*_SRXAFSCM_xxxx_t)(struct rxrpc_call *call);
39
40 static const struct rxrpc_operation AFSCM_ops[] = {
41         {
42                 .id     = 204,
43                 .asize  = RXRPC_APP_MARK_EOF,
44                 .name   = "CallBack",
45                 .user   = _SRXAFSCM_CallBack,
46         },
47         {
48                 .id     = 205,
49                 .asize  = RXRPC_APP_MARK_EOF,
50                 .name   = "InitCallBackState",
51                 .user   = _SRXAFSCM_InitCallBackState,
52         },
53         {
54                 .id     = 206,
55                 .asize  = RXRPC_APP_MARK_EOF,
56                 .name   = "Probe",
57                 .user   = _SRXAFSCM_Probe,
58         },
59 #if 0
60         {
61                 .id     = 207,
62                 .asize  = RXRPC_APP_MARK_EOF,
63                 .name   = "GetLock",
64                 .user   = _SRXAFSCM_GetLock,
65         },
66         {
67                 .id     = 208,
68                 .asize  = RXRPC_APP_MARK_EOF,
69                 .name   = "GetCE",
70                 .user   = _SRXAFSCM_GetCE,
71         },
72         {
73                 .id     = 209,
74                 .asize  = RXRPC_APP_MARK_EOF,
75                 .name   = "GetXStatsVersion",
76                 .user   = _SRXAFSCM_GetXStatsVersion,
77         },
78         {
79                 .id     = 210,
80                 .asize  = RXRPC_APP_MARK_EOF,
81                 .name   = "GetXStats",
82                 .user   = _SRXAFSCM_GetXStats,
83         }
84 #endif
85 };
86
87 static struct rxrpc_service AFSCM_service = {
88         .name           = "AFS/CM",
89         .owner          = THIS_MODULE,
90         .link           = LIST_HEAD_INIT(AFSCM_service.link),
91         .new_call       = afscm_new_call,
92         .service_id     = 1,
93         .attn_func      = afscm_attention,
94         .error_func     = afscm_error,
95         .aemap_func     = afscm_aemap,
96         .ops_begin      = &AFSCM_ops[0],
97         .ops_end        = &AFSCM_ops[ARRAY_SIZE(AFSCM_ops)],
98 };
99
100 static DECLARE_COMPLETION(kafscmd_alive);
101 static DECLARE_COMPLETION(kafscmd_dead);
102 static DECLARE_WAIT_QUEUE_HEAD(kafscmd_sleepq);
103 static LIST_HEAD(kafscmd_attention_list);
104 static LIST_HEAD(afscm_calls);
105 static DEFINE_SPINLOCK(afscm_calls_lock);
106 static DEFINE_SPINLOCK(kafscmd_attention_lock);
107 static int kafscmd_die;
108
109 /*
110  * AFS Cache Manager kernel thread
111  */
112 static int kafscmd(void *arg)
113 {
114         DECLARE_WAITQUEUE(myself, current);
115
116         struct rxrpc_call *call;
117         _SRXAFSCM_xxxx_t func;
118         int die;
119
120         printk(KERN_INFO "kAFS: Started kafscmd %d\n", current->pid);
121
122         daemonize("kafscmd");
123
124         complete(&kafscmd_alive);
125
126         /* loop around looking for things to attend to */
127         do {
128                 if (list_empty(&kafscmd_attention_list)) {
129                         set_current_state(TASK_INTERRUPTIBLE);
130                         add_wait_queue(&kafscmd_sleepq, &myself);
131
132                         for (;;) {
133                                 set_current_state(TASK_INTERRUPTIBLE);
134                                 if (!list_empty(&kafscmd_attention_list) ||
135                                     signal_pending(current) ||
136                                     kafscmd_die)
137                                         break;
138
139                                 schedule();
140                         }
141
142                         remove_wait_queue(&kafscmd_sleepq, &myself);
143                         set_current_state(TASK_RUNNING);
144                 }
145
146                 die = kafscmd_die;
147
148                 /* dequeue the next call requiring attention */
149                 call = NULL;
150                 spin_lock(&kafscmd_attention_lock);
151
152                 if (!list_empty(&kafscmd_attention_list)) {
153                         call = list_entry(kafscmd_attention_list.next,
154                                           struct rxrpc_call,
155                                           app_attn_link);
156                         list_del_init(&call->app_attn_link);
157                         die = 0;
158                 }
159
160                 spin_unlock(&kafscmd_attention_lock);
161
162                 if (call) {
163                         /* act upon it */
164                         _debug("@@@ Begin Attend Call %p", call);
165
166                         func = call->app_user;
167                         if (func)
168                                 func(call);
169
170                         rxrpc_put_call(call);
171
172                         _debug("@@@ End Attend Call %p", call);
173                 }
174
175         } while(!die);
176
177         /* and that's all */
178         complete_and_exit(&kafscmd_dead, 0);
179 }
180
181 /*
182  * handle a call coming in to the cache manager
183  * - if I want to keep the call, I must increment its usage count
184  * - the return value will be negated and passed back in an abort packet if
185  *   non-zero
186  * - serialised by virtue of there only being one krxiod
187  */
188 static int afscm_new_call(struct rxrpc_call *call)
189 {
190         _enter("%p{cid=%u u=%d}",
191                call, ntohl(call->call_id), atomic_read(&call->usage));
192
193         rxrpc_get_call(call);
194
195         /* add to my current call list */
196         spin_lock(&afscm_calls_lock);
197         list_add(&call->app_link,&afscm_calls);
198         spin_unlock(&afscm_calls_lock);
199
200         _leave(" = 0");
201         return 0;
202 }
203
204 /*
205  * queue on the kafscmd queue for attention
206  */
207 static void afscm_attention(struct rxrpc_call *call)
208 {
209         _enter("%p{cid=%u u=%d}",
210                call, ntohl(call->call_id), atomic_read(&call->usage));
211
212         spin_lock(&kafscmd_attention_lock);
213
214         if (list_empty(&call->app_attn_link)) {
215                 list_add_tail(&call->app_attn_link, &kafscmd_attention_list);
216                 rxrpc_get_call(call);
217         }
218
219         spin_unlock(&kafscmd_attention_lock);
220
221         wake_up(&kafscmd_sleepq);
222
223         _leave(" {u=%d}", atomic_read(&call->usage));
224 }
225
226 /*
227  * handle my call being aborted
228  * - clean up, dequeue and put my ref to the call
229  */
230 static void afscm_error(struct rxrpc_call *call)
231 {
232         int removed;
233
234         _enter("%p{est=%s ac=%u er=%d}",
235                call,
236                rxrpc_call_error_states[call->app_err_state],
237                call->app_abort_code,
238                call->app_errno);
239
240         spin_lock(&kafscmd_attention_lock);
241
242         if (list_empty(&call->app_attn_link)) {
243                 list_add_tail(&call->app_attn_link, &kafscmd_attention_list);
244                 rxrpc_get_call(call);
245         }
246
247         spin_unlock(&kafscmd_attention_lock);
248
249         removed = 0;
250         spin_lock(&afscm_calls_lock);
251         if (!list_empty(&call->app_link)) {
252                 list_del_init(&call->app_link);
253                 removed = 1;
254         }
255         spin_unlock(&afscm_calls_lock);
256
257         if (removed)
258                 rxrpc_put_call(call);
259
260         wake_up(&kafscmd_sleepq);
261
262         _leave("");
263 }
264
265 /*
266  * map afs abort codes to/from Linux error codes
267  * - called with call->lock held
268  */
269 static void afscm_aemap(struct rxrpc_call *call)
270 {
271         switch (call->app_err_state) {
272         case RXRPC_ESTATE_LOCAL_ABORT:
273                 call->app_abort_code = -call->app_errno;
274                 break;
275         case RXRPC_ESTATE_PEER_ABORT:
276                 call->app_errno = -ECONNABORTED;
277                 break;
278         default:
279                 break;
280         }
281 }
282
283 /*
284  * start the cache manager service if not already started
285  */
286 int afscm_start(void)
287 {
288         int ret;
289
290         down_write(&afscm_sem);
291         if (!afscm_usage) {
292                 ret = kernel_thread(kafscmd, NULL, 0);
293                 if (ret < 0)
294                         goto out;
295
296                 wait_for_completion(&kafscmd_alive);
297
298                 ret = rxrpc_add_service(afs_transport, &AFSCM_service);
299                 if (ret < 0)
300                         goto kill;
301
302                 afs_kafstimod_add_timer(&afs_mntpt_expiry_timer,
303                                         afs_mntpt_expiry_timeout * HZ);
304         }
305
306         afscm_usage++;
307         up_write(&afscm_sem);
308
309         return 0;
310
311 kill:
312         kafscmd_die = 1;
313         wake_up(&kafscmd_sleepq);
314         wait_for_completion(&kafscmd_dead);
315
316 out:
317         up_write(&afscm_sem);
318         return ret;
319 }
320
321 /*
322  * stop the cache manager service
323  */
324 void afscm_stop(void)
325 {
326         struct rxrpc_call *call;
327
328         down_write(&afscm_sem);
329
330         BUG_ON(afscm_usage == 0);
331         afscm_usage--;
332
333         if (afscm_usage == 0) {
334                 /* don't want more incoming calls */
335                 rxrpc_del_service(afs_transport, &AFSCM_service);
336
337                 /* abort any calls I've still got open (the afscm_error() will
338                  * dequeue them) */
339                 spin_lock(&afscm_calls_lock);
340                 while (!list_empty(&afscm_calls)) {
341                         call = list_entry(afscm_calls.next,
342                                           struct rxrpc_call,
343                                           app_link);
344
345                         list_del_init(&call->app_link);
346                         rxrpc_get_call(call);
347                         spin_unlock(&afscm_calls_lock);
348
349                         rxrpc_call_abort(call, -ESRCH); /* abort, dequeue and
350                                                          * put */
351
352                         _debug("nuking active call %08x.%d",
353                                ntohl(call->conn->conn_id),
354                                ntohl(call->call_id));
355                         rxrpc_put_call(call);
356                         rxrpc_put_call(call);
357
358                         spin_lock(&afscm_calls_lock);
359                 }
360                 spin_unlock(&afscm_calls_lock);
361
362                 /* get rid of my daemon */
363                 kafscmd_die = 1;
364                 wake_up(&kafscmd_sleepq);
365                 wait_for_completion(&kafscmd_dead);
366
367                 /* dispose of any calls waiting for attention */
368                 spin_lock(&kafscmd_attention_lock);
369                 while (!list_empty(&kafscmd_attention_list)) {
370                         call = list_entry(kafscmd_attention_list.next,
371                                           struct rxrpc_call,
372                                           app_attn_link);
373
374                         list_del_init(&call->app_attn_link);
375                         spin_unlock(&kafscmd_attention_lock);
376
377                         rxrpc_put_call(call);
378
379                         spin_lock(&kafscmd_attention_lock);
380                 }
381                 spin_unlock(&kafscmd_attention_lock);
382
383                 afs_kafstimod_del_timer(&afs_mntpt_expiry_timer);
384         }
385
386         up_write(&afscm_sem);
387 }
388
389 /*
390  * handle the fileserver breaking a set of callbacks
391  */
392 static void _SRXAFSCM_CallBack(struct rxrpc_call *call)
393 {
394         struct afs_server *server;
395         size_t count, qty, tmp;
396         int ret = 0, removed;
397
398         _enter("%p{acs=%s}", call, rxrpc_call_states[call->app_call_state]);
399
400         server = afs_server_get_from_peer(call->conn->peer);
401
402         switch (call->app_call_state) {
403                 /* we've received the last packet
404                  * - drain all the data from the call and send the reply
405                  */
406         case RXRPC_CSTATE_SRVR_GOT_ARGS:
407                 ret = -EBADMSG;
408                 qty = call->app_ready_qty;
409                 if (qty < 8 || qty > 50 * (6 * 4) + 8)
410                         break;
411
412                 {
413                         struct afs_callback *cb, *pcb;
414                         int loop;
415                         __be32 *fp, *bp;
416
417                         fp = rxrpc_call_alloc_scratch(call, qty);
418
419                         /* drag the entire argument block out to the scratch
420                          * space */
421                         ret = rxrpc_call_read_data(call, fp, qty, 0);
422                         if (ret < 0)
423                                 break;
424
425                         /* and unmarshall the parameter block */
426                         ret = -EBADMSG;
427                         count = ntohl(*fp++);
428                         if (count>AFSCBMAX ||
429                             (count * (3 * 4) + 8 != qty &&
430                              count * (6 * 4) + 8 != qty))
431                                 break;
432
433                         bp = fp + count*3;
434                         tmp = ntohl(*bp++);
435                         if (tmp > 0 && tmp != count)
436                                 break;
437                         if (tmp == 0)
438                                 bp = NULL;
439
440                         pcb = cb = rxrpc_call_alloc_scratch_s(
441                                 call, struct afs_callback);
442
443                         for (loop = count - 1; loop >= 0; loop--) {
444                                 pcb->fid.vid    = ntohl(*fp++);
445                                 pcb->fid.vnode  = ntohl(*fp++);
446                                 pcb->fid.unique = ntohl(*fp++);
447                                 if (bp) {
448                                         pcb->version    = ntohl(*bp++);
449                                         pcb->expiry     = ntohl(*bp++);
450                                         pcb->type       = ntohl(*bp++);
451                                 } else {
452                                         pcb->version    = 0;
453                                         pcb->expiry     = 0;
454                                         pcb->type       = AFSCM_CB_UNTYPED;
455                                 }
456                                 pcb++;
457                         }
458
459                         /* invoke the actual service routine */
460                         ret = SRXAFSCM_CallBack(server, count, cb);
461                         if (ret < 0)
462                                 break;
463                 }
464
465                 /* send the reply */
466                 ret = rxrpc_call_write_data(call, 0, NULL, RXRPC_LAST_PACKET,
467                                             GFP_KERNEL, 0, &count);
468                 if (ret < 0)
469                         break;
470                 break;
471
472                 /* operation complete */
473         case RXRPC_CSTATE_COMPLETE:
474                 call->app_user = NULL;
475                 removed = 0;
476                 spin_lock(&afscm_calls_lock);
477                 if (!list_empty(&call->app_link)) {
478                         list_del_init(&call->app_link);
479                         removed = 1;
480                 }
481                 spin_unlock(&afscm_calls_lock);
482
483                 if (removed)
484                         rxrpc_put_call(call);
485                 break;
486
487                 /* operation terminated on error */
488         case RXRPC_CSTATE_ERROR:
489                 call->app_user = NULL;
490                 break;
491
492         default:
493                 break;
494         }
495
496         if (ret < 0)
497                 rxrpc_call_abort(call, ret);
498
499         afs_put_server(server);
500
501         _leave(" = %d", ret);
502 }
503
504 /*
505  * handle the fileserver asking us to initialise our callback state
506  */
507 static void _SRXAFSCM_InitCallBackState(struct rxrpc_call *call)
508 {
509         struct afs_server *server;
510         size_t count;
511         int ret = 0, removed;
512
513         _enter("%p{acs=%s}", call, rxrpc_call_states[call->app_call_state]);
514
515         server = afs_server_get_from_peer(call->conn->peer);
516
517         switch (call->app_call_state) {
518                 /* we've received the last packet - drain all the data from the
519                  * call */
520         case RXRPC_CSTATE_SRVR_GOT_ARGS:
521                 /* shouldn't be any args */
522                 ret = -EBADMSG;
523                 break;
524
525                 /* send the reply when asked for it */
526         case RXRPC_CSTATE_SRVR_SND_REPLY:
527                 /* invoke the actual service routine */
528                 ret = SRXAFSCM_InitCallBackState(server);
529                 if (ret < 0)
530                         break;
531
532                 ret = rxrpc_call_write_data(call, 0, NULL, RXRPC_LAST_PACKET,
533                                             GFP_KERNEL, 0, &count);
534                 if (ret < 0)
535                         break;
536                 break;
537
538                 /* operation complete */
539         case RXRPC_CSTATE_COMPLETE:
540                 call->app_user = NULL;
541                 removed = 0;
542                 spin_lock(&afscm_calls_lock);
543                 if (!list_empty(&call->app_link)) {
544                         list_del_init(&call->app_link);
545                         removed = 1;
546                 }
547                 spin_unlock(&afscm_calls_lock);
548
549                 if (removed)
550                         rxrpc_put_call(call);
551                 break;
552
553                 /* operation terminated on error */
554         case RXRPC_CSTATE_ERROR:
555                 call->app_user = NULL;
556                 break;
557
558         default:
559                 break;
560         }
561
562         if (ret < 0)
563                 rxrpc_call_abort(call, ret);
564
565         afs_put_server(server);
566
567         _leave(" = %d", ret);
568 }
569
570 /*
571  * handle a probe from a fileserver
572  */
573 static void _SRXAFSCM_Probe(struct rxrpc_call *call)
574 {
575         struct afs_server *server;
576         size_t count;
577         int ret = 0, removed;
578
579         _enter("%p{acs=%s}", call, rxrpc_call_states[call->app_call_state]);
580
581         server = afs_server_get_from_peer(call->conn->peer);
582
583         switch (call->app_call_state) {
584                 /* we've received the last packet - drain all the data from the
585                  * call */
586         case RXRPC_CSTATE_SRVR_GOT_ARGS:
587                 /* shouldn't be any args */
588                 ret = -EBADMSG;
589                 break;
590
591                 /* send the reply when asked for it */
592         case RXRPC_CSTATE_SRVR_SND_REPLY:
593                 /* invoke the actual service routine */
594                 ret = SRXAFSCM_Probe(server);
595                 if (ret < 0)
596                         break;
597
598                 ret = rxrpc_call_write_data(call, 0, NULL, RXRPC_LAST_PACKET,
599                                             GFP_KERNEL, 0, &count);
600                 if (ret < 0)
601                         break;
602                 break;
603
604                 /* operation complete */
605         case RXRPC_CSTATE_COMPLETE:
606                 call->app_user = NULL;
607                 removed = 0;
608                 spin_lock(&afscm_calls_lock);
609                 if (!list_empty(&call->app_link)) {
610                         list_del_init(&call->app_link);
611                         removed = 1;
612                 }
613                 spin_unlock(&afscm_calls_lock);
614
615                 if (removed)
616                         rxrpc_put_call(call);
617                 break;
618
619                 /* operation terminated on error */
620         case RXRPC_CSTATE_ERROR:
621                 call->app_user = NULL;
622                 break;
623
624         default:
625                 break;
626         }
627
628         if (ret < 0)
629                 rxrpc_call_abort(call, ret);
630
631         afs_put_server(server);
632
633         _leave(" = %d", ret);
634 }