[PATCH] affs: replace kmalloc+memset with kzalloc
[linux-3.10.git] / fs / afs / server.c
1 /* server.c: AFS server record management
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/sched.h>
13 #include <linux/slab.h>
14 #include <rxrpc/peer.h>
15 #include <rxrpc/connection.h>
16 #include "volume.h"
17 #include "cell.h"
18 #include "server.h"
19 #include "transport.h"
20 #include "vlclient.h"
21 #include "kafstimod.h"
22 #include "internal.h"
23
24 DEFINE_SPINLOCK(afs_server_peer_lock);
25
26 #define FS_SERVICE_ID           1       /* AFS Volume Location Service ID */
27 #define VL_SERVICE_ID           52      /* AFS Volume Location Service ID */
28
29 static void __afs_server_timeout(struct afs_timer *timer)
30 {
31         struct afs_server *server =
32                 list_entry(timer, struct afs_server, timeout);
33
34         _debug("SERVER TIMEOUT [%p{u=%d}]",
35                server, atomic_read(&server->usage));
36
37         afs_server_do_timeout(server);
38 }
39
40 static const struct afs_timer_ops afs_server_timer_ops = {
41         .timed_out      = __afs_server_timeout,
42 };
43
44 /*****************************************************************************/
45 /*
46  * lookup a server record in a cell
47  * - TODO: search the cell's server list
48  */
49 int afs_server_lookup(struct afs_cell *cell, const struct in_addr *addr,
50                       struct afs_server **_server)
51 {
52         struct afs_server *server, *active, *zombie;
53         int loop;
54
55         _enter("%p,%08x,", cell, ntohl(addr->s_addr));
56
57         /* allocate and initialise a server record */
58         server = kzalloc(sizeof(struct afs_server), GFP_KERNEL);
59         if (!server) {
60                 _leave(" = -ENOMEM");
61                 return -ENOMEM;
62         }
63
64         atomic_set(&server->usage, 1);
65
66         INIT_LIST_HEAD(&server->link);
67         init_rwsem(&server->sem);
68         INIT_LIST_HEAD(&server->fs_callq);
69         spin_lock_init(&server->fs_lock);
70         INIT_LIST_HEAD(&server->cb_promises);
71         spin_lock_init(&server->cb_lock);
72
73         for (loop = 0; loop < AFS_SERVER_CONN_LIST_SIZE; loop++)
74                 server->fs_conn_cnt[loop] = 4;
75
76         memcpy(&server->addr, addr, sizeof(struct in_addr));
77         server->addr.s_addr = addr->s_addr;
78
79         afs_timer_init(&server->timeout, &afs_server_timer_ops);
80
81         /* add to the cell */
82         write_lock(&cell->sv_lock);
83
84         /* check the active list */
85         list_for_each_entry(active, &cell->sv_list, link) {
86                 if (active->addr.s_addr == addr->s_addr)
87                         goto use_active_server;
88         }
89
90         /* check the inactive list */
91         spin_lock(&cell->sv_gylock);
92         list_for_each_entry(zombie, &cell->sv_graveyard, link) {
93                 if (zombie->addr.s_addr == addr->s_addr)
94                         goto resurrect_server;
95         }
96         spin_unlock(&cell->sv_gylock);
97
98         afs_get_cell(cell);
99         server->cell = cell;
100         list_add_tail(&server->link, &cell->sv_list);
101
102         write_unlock(&cell->sv_lock);
103
104         *_server = server;
105         _leave(" = 0 (%p)", server);
106         return 0;
107
108         /* found a matching active server */
109  use_active_server:
110         _debug("active server");
111         afs_get_server(active);
112         write_unlock(&cell->sv_lock);
113
114         kfree(server);
115
116         *_server = active;
117         _leave(" = 0 (%p)", active);
118         return 0;
119
120         /* found a matching server in the graveyard, so resurrect it and
121          * dispose of the new record */
122  resurrect_server:
123         _debug("resurrecting server");
124
125         list_move_tail(&zombie->link, &cell->sv_list);
126         afs_get_server(zombie);
127         afs_kafstimod_del_timer(&zombie->timeout);
128         spin_unlock(&cell->sv_gylock);
129         write_unlock(&cell->sv_lock);
130
131         kfree(server);
132
133         *_server = zombie;
134         _leave(" = 0 (%p)", zombie);
135         return 0;
136
137 } /* end afs_server_lookup() */
138
139 /*****************************************************************************/
140 /*
141  * destroy a server record
142  * - removes from the cell list
143  */
144 void afs_put_server(struct afs_server *server)
145 {
146         struct afs_cell *cell;
147
148         if (!server)
149                 return;
150
151         _enter("%p", server);
152
153         cell = server->cell;
154
155         /* sanity check */
156         BUG_ON(atomic_read(&server->usage) <= 0);
157
158         /* to prevent a race, the decrement and the dequeue must be effectively
159          * atomic */
160         write_lock(&cell->sv_lock);
161
162         if (likely(!atomic_dec_and_test(&server->usage))) {
163                 write_unlock(&cell->sv_lock);
164                 _leave("");
165                 return;
166         }
167
168         spin_lock(&cell->sv_gylock);
169         list_move_tail(&server->link, &cell->sv_graveyard);
170
171         /* time out in 10 secs */
172         afs_kafstimod_add_timer(&server->timeout, 10 * HZ);
173
174         spin_unlock(&cell->sv_gylock);
175         write_unlock(&cell->sv_lock);
176
177         _leave(" [killed]");
178 } /* end afs_put_server() */
179
180 /*****************************************************************************/
181 /*
182  * timeout server record
183  * - removes from the cell's graveyard if the usage count is zero
184  */
185 void afs_server_do_timeout(struct afs_server *server)
186 {
187         struct rxrpc_peer *peer;
188         struct afs_cell *cell;
189         int loop;
190
191         _enter("%p", server);
192
193         cell = server->cell;
194
195         BUG_ON(atomic_read(&server->usage) < 0);
196
197         /* remove from graveyard if still dead */
198         spin_lock(&cell->vl_gylock);
199         if (atomic_read(&server->usage) == 0)
200                 list_del_init(&server->link);
201         else
202                 server = NULL;
203         spin_unlock(&cell->vl_gylock);
204
205         if (!server) {
206                 _leave("");
207                 return; /* resurrected */
208         }
209
210         /* we can now destroy it properly */
211         afs_put_cell(cell);
212
213         /* uncross-point the structs under a global lock */
214         spin_lock(&afs_server_peer_lock);
215         peer = server->peer;
216         if (peer) {
217                 server->peer = NULL;
218                 peer->user = NULL;
219         }
220         spin_unlock(&afs_server_peer_lock);
221
222         /* finish cleaning up the server */
223         for (loop = AFS_SERVER_CONN_LIST_SIZE - 1; loop >= 0; loop--)
224                 if (server->fs_conn[loop])
225                         rxrpc_put_connection(server->fs_conn[loop]);
226
227         if (server->vlserver)
228                 rxrpc_put_connection(server->vlserver);
229
230         kfree(server);
231
232         _leave(" [destroyed]");
233 } /* end afs_server_do_timeout() */
234
235 /*****************************************************************************/
236 /*
237  * get a callslot on a connection to the fileserver on the specified server
238  */
239 int afs_server_request_callslot(struct afs_server *server,
240                                 struct afs_server_callslot *callslot)
241 {
242         struct afs_server_callslot *pcallslot;
243         struct rxrpc_connection *conn;
244         int nconn, ret;
245
246         _enter("%p,",server);
247
248         INIT_LIST_HEAD(&callslot->link);
249         callslot->task = current;
250         callslot->conn = NULL;
251         callslot->nconn = -1;
252         callslot->ready = 0;
253
254         ret = 0;
255         conn = NULL;
256
257         /* get hold of a callslot first */
258         spin_lock(&server->fs_lock);
259
260         /* resurrect the server if it's death timeout has expired */
261         if (server->fs_state) {
262                 if (time_before(jiffies, server->fs_dead_jif)) {
263                         ret = server->fs_state;
264                         spin_unlock(&server->fs_lock);
265                         _leave(" = %d [still dead]", ret);
266                         return ret;
267                 }
268
269                 server->fs_state = 0;
270         }
271
272         /* try and find a connection that has spare callslots */
273         for (nconn = 0; nconn < AFS_SERVER_CONN_LIST_SIZE; nconn++) {
274                 if (server->fs_conn_cnt[nconn] > 0) {
275                         server->fs_conn_cnt[nconn]--;
276                         spin_unlock(&server->fs_lock);
277                         callslot->nconn = nconn;
278                         goto obtained_slot;
279                 }
280         }
281
282         /* none were available - wait interruptibly for one to become
283          * available */
284         set_current_state(TASK_INTERRUPTIBLE);
285         list_add_tail(&callslot->link, &server->fs_callq);
286         spin_unlock(&server->fs_lock);
287
288         while (!callslot->ready && !signal_pending(current)) {
289                 schedule();
290                 set_current_state(TASK_INTERRUPTIBLE);
291         }
292
293         set_current_state(TASK_RUNNING);
294
295         /* even if we were interrupted we may still be queued */
296         if (!callslot->ready) {
297                 spin_lock(&server->fs_lock);
298                 list_del_init(&callslot->link);
299                 spin_unlock(&server->fs_lock);
300         }
301
302         nconn = callslot->nconn;
303
304         /* if interrupted, we must release any slot we also got before
305          * returning an error */
306         if (signal_pending(current)) {
307                 ret = -EINTR;
308                 goto error_release;
309         }
310
311         /* if we were woken up with an error, then pass that error back to the
312          * called */
313         if (nconn < 0) {
314                 _leave(" = %d", callslot->errno);
315                 return callslot->errno;
316         }
317
318         /* were we given a connection directly? */
319         if (callslot->conn) {
320                 /* yes - use it */
321                 _leave(" = 0 (nc=%d)", nconn);
322                 return 0;
323         }
324
325         /* got a callslot, but no connection */
326  obtained_slot:
327
328         /* need to get hold of the RxRPC connection */
329         down_write(&server->sem);
330
331         /* quick check to see if there's an outstanding error */
332         ret = server->fs_state;
333         if (ret)
334                 goto error_release_upw;
335
336         if (server->fs_conn[nconn]) {
337                 /* reuse an existing connection */
338                 rxrpc_get_connection(server->fs_conn[nconn]);
339                 callslot->conn = server->fs_conn[nconn];
340         }
341         else {
342                 /* create a new connection */
343                 ret = rxrpc_create_connection(afs_transport,
344                                               htons(7000),
345                                               server->addr.s_addr,
346                                               FS_SERVICE_ID,
347                                               NULL,
348                                               &server->fs_conn[nconn]);
349
350                 if (ret < 0)
351                         goto error_release_upw;
352
353                 callslot->conn = server->fs_conn[0];
354                 rxrpc_get_connection(callslot->conn);
355         }
356
357         up_write(&server->sem);
358
359         _leave(" = 0");
360         return 0;
361
362         /* handle an error occurring */
363  error_release_upw:
364         up_write(&server->sem);
365
366  error_release:
367         /* either release the callslot or pass it along to another deserving
368          * task */
369         spin_lock(&server->fs_lock);
370
371         if (nconn < 0) {
372                 /* no callslot allocated */
373         }
374         else if (list_empty(&server->fs_callq)) {
375                 /* no one waiting */
376                 server->fs_conn_cnt[nconn]++;
377                 spin_unlock(&server->fs_lock);
378         }
379         else {
380                 /* someone's waiting - dequeue them and wake them up */
381                 pcallslot = list_entry(server->fs_callq.next,
382                                        struct afs_server_callslot, link);
383                 list_del_init(&pcallslot->link);
384
385                 pcallslot->errno = server->fs_state;
386                 if (!pcallslot->errno) {
387                         /* pass them out callslot details */
388                         callslot->conn = xchg(&pcallslot->conn,
389                                               callslot->conn);
390                         pcallslot->nconn = nconn;
391                         callslot->nconn = nconn = -1;
392                 }
393                 pcallslot->ready = 1;
394                 wake_up_process(pcallslot->task);
395                 spin_unlock(&server->fs_lock);
396         }
397
398         rxrpc_put_connection(callslot->conn);
399         callslot->conn = NULL;
400
401         _leave(" = %d", ret);
402         return ret;
403
404 } /* end afs_server_request_callslot() */
405
406 /*****************************************************************************/
407 /*
408  * release a callslot back to the server
409  * - transfers the RxRPC connection to the next pending callslot if possible
410  */
411 void afs_server_release_callslot(struct afs_server *server,
412                                  struct afs_server_callslot *callslot)
413 {
414         struct afs_server_callslot *pcallslot;
415
416         _enter("{ad=%08x,cnt=%u},{%d}",
417                ntohl(server->addr.s_addr),
418                server->fs_conn_cnt[callslot->nconn],
419                callslot->nconn);
420
421         BUG_ON(callslot->nconn < 0);
422
423         spin_lock(&server->fs_lock);
424
425         if (list_empty(&server->fs_callq)) {
426                 /* no one waiting */
427                 server->fs_conn_cnt[callslot->nconn]++;
428                 spin_unlock(&server->fs_lock);
429         }
430         else {
431                 /* someone's waiting - dequeue them and wake them up */
432                 pcallslot = list_entry(server->fs_callq.next,
433                                        struct afs_server_callslot, link);
434                 list_del_init(&pcallslot->link);
435
436                 pcallslot->errno = server->fs_state;
437                 if (!pcallslot->errno) {
438                         /* pass them out callslot details */
439                         callslot->conn = xchg(&pcallslot->conn, callslot->conn);
440                         pcallslot->nconn = callslot->nconn;
441                         callslot->nconn = -1;
442                 }
443
444                 pcallslot->ready = 1;
445                 wake_up_process(pcallslot->task);
446                 spin_unlock(&server->fs_lock);
447         }
448
449         rxrpc_put_connection(callslot->conn);
450
451         _leave("");
452 } /* end afs_server_release_callslot() */
453
454 /*****************************************************************************/
455 /*
456  * get a handle to a connection to the vlserver (volume location) on the
457  * specified server
458  */
459 int afs_server_get_vlconn(struct afs_server *server,
460                           struct rxrpc_connection **_conn)
461 {
462         struct rxrpc_connection *conn;
463         int ret;
464
465         _enter("%p,", server);
466
467         ret = 0;
468         conn = NULL;
469         down_read(&server->sem);
470
471         if (server->vlserver) {
472                 /* reuse an existing connection */
473                 rxrpc_get_connection(server->vlserver);
474                 conn = server->vlserver;
475                 up_read(&server->sem);
476         }
477         else {
478                 /* create a new connection */
479                 up_read(&server->sem);
480                 down_write(&server->sem);
481                 if (!server->vlserver) {
482                         ret = rxrpc_create_connection(afs_transport,
483                                                       htons(7003),
484                                                       server->addr.s_addr,
485                                                       VL_SERVICE_ID,
486                                                       NULL,
487                                                       &server->vlserver);
488                 }
489                 if (ret == 0) {
490                         rxrpc_get_connection(server->vlserver);
491                         conn = server->vlserver;
492                 }
493                 up_write(&server->sem);
494         }
495
496         *_conn = conn;
497         _leave(" = %d", ret);
498         return ret;
499 } /* end afs_server_get_vlconn() */