9b1311a1df51d328921952d9159e46d88a6fc0cd
[linux-2.6.git] / fs / afs / cell.c
1 /* AFS cell and 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/module.h>
13 #include <linux/slab.h>
14 #include <linux/key.h>
15 #include <linux/ctype.h>
16 #include <keys/rxrpc-type.h>
17 #include "internal.h"
18
19 DECLARE_RWSEM(afs_proc_cells_sem);
20 LIST_HEAD(afs_proc_cells);
21
22 static struct list_head afs_cells = LIST_HEAD_INIT(afs_cells);
23 static DEFINE_RWLOCK(afs_cells_lock);
24 static DECLARE_RWSEM(afs_cells_sem); /* add/remove serialisation */
25 static DECLARE_WAIT_QUEUE_HEAD(afs_cells_freeable_wq);
26 static struct afs_cell *afs_cell_root;
27
28 /*
29  * allocate a cell record and fill in its name, VL server address list and
30  * allocate an anonymous key
31  */
32 static struct afs_cell *afs_cell_alloc(const char *name, char *vllist)
33 {
34         struct afs_cell *cell;
35         size_t namelen;
36         char keyname[4 + AFS_MAXCELLNAME + 1], *cp, *dp, *next;
37         int ret;
38
39         _enter("%s,%s", name, vllist);
40
41         BUG_ON(!name); /* TODO: want to look up "this cell" in the cache */
42
43         namelen = strlen(name);
44         if (namelen > AFS_MAXCELLNAME)
45                 return ERR_PTR(-ENAMETOOLONG);
46
47         /* allocate and initialise a cell record */
48         cell = kzalloc(sizeof(struct afs_cell) + namelen + 1, GFP_KERNEL);
49         if (!cell) {
50                 _leave(" = -ENOMEM");
51                 return ERR_PTR(-ENOMEM);
52         }
53
54         memcpy(cell->name, name, namelen);
55         cell->name[namelen] = 0;
56
57         atomic_set(&cell->usage, 1);
58         INIT_LIST_HEAD(&cell->link);
59         rwlock_init(&cell->servers_lock);
60         INIT_LIST_HEAD(&cell->servers);
61         init_rwsem(&cell->vl_sem);
62         INIT_LIST_HEAD(&cell->vl_list);
63         spin_lock_init(&cell->vl_lock);
64
65         /* fill in the VL server list from the rest of the string */
66         do {
67                 unsigned a, b, c, d;
68
69                 next = strchr(vllist, ':');
70                 if (next)
71                         *next++ = 0;
72
73                 if (sscanf(vllist, "%u.%u.%u.%u", &a, &b, &c, &d) != 4)
74                         goto bad_address;
75
76                 if (a > 255 || b > 255 || c > 255 || d > 255)
77                         goto bad_address;
78
79                 cell->vl_addrs[cell->vl_naddrs++].s_addr =
80                         htonl((a << 24) | (b << 16) | (c << 8) | d);
81
82         } while (cell->vl_naddrs < AFS_CELL_MAX_ADDRS && (vllist = next));
83
84         /* create a key to represent an anonymous user */
85         memcpy(keyname, "afs@", 4);
86         dp = keyname + 4;
87         cp = cell->name;
88         do {
89                 *dp++ = toupper(*cp);
90         } while (*cp++);
91         cell->anonymous_key = key_alloc(&key_type_rxrpc, keyname, 0, 0, current,
92                                         KEY_POS_SEARCH, KEY_ALLOC_NOT_IN_QUOTA);
93         if (IS_ERR(cell->anonymous_key)) {
94                 _debug("no key");
95                 ret = PTR_ERR(cell->anonymous_key);
96                 goto error;
97         }
98
99         ret = key_instantiate_and_link(cell->anonymous_key, NULL, 0,
100                                        NULL, NULL);
101         if (ret < 0) {
102                 _debug("instantiate failed");
103                 goto error;
104         }
105
106         _debug("anon key %p{%x}",
107                cell->anonymous_key, key_serial(cell->anonymous_key));
108
109         _leave(" = %p", cell);
110         return cell;
111
112 bad_address:
113         printk(KERN_ERR "kAFS: bad VL server IP address\n");
114         ret = -EINVAL;
115 error:
116         key_put(cell->anonymous_key);
117         kfree(cell);
118         _leave(" = %d", ret);
119         return ERR_PTR(ret);
120 }
121
122 /*
123  * create a cell record
124  * - "name" is the name of the cell
125  * - "vllist" is a colon separated list of IP addresses in "a.b.c.d" format
126  */
127 struct afs_cell *afs_cell_create(const char *name, char *vllist)
128 {
129         struct afs_cell *cell;
130         int ret;
131
132         _enter("%s,%s", name, vllist);
133
134         cell = afs_cell_alloc(name, vllist);
135         if (IS_ERR(cell)) {
136                 _leave(" = %ld", PTR_ERR(cell));
137                 return cell;
138         }
139
140         down_write(&afs_cells_sem);
141
142         /* add a proc directory for this cell */
143         ret = afs_proc_cell_setup(cell);
144         if (ret < 0)
145                 goto error;
146
147 #ifdef AFS_CACHING_SUPPORT
148         /* put it up for caching */
149         cachefs_acquire_cookie(afs_cache_netfs.primary_index,
150                                &afs_vlocation_cache_index_def,
151                                cell,
152                                &cell->cache);
153 #endif
154
155         /* add to the cell lists */
156         write_lock(&afs_cells_lock);
157         list_add_tail(&cell->link, &afs_cells);
158         write_unlock(&afs_cells_lock);
159
160         down_write(&afs_proc_cells_sem);
161         list_add_tail(&cell->proc_link, &afs_proc_cells);
162         up_write(&afs_proc_cells_sem);
163         up_write(&afs_cells_sem);
164
165         _leave(" = %p", cell);
166         return cell;
167
168 error:
169         up_write(&afs_cells_sem);
170         key_put(cell->anonymous_key);
171         kfree(cell);
172         _leave(" = %d", ret);
173         return ERR_PTR(ret);
174 }
175
176 /*
177  * set the root cell information
178  * - can be called with a module parameter string
179  * - can be called from a write to /proc/fs/afs/rootcell
180  */
181 int afs_cell_init(char *rootcell)
182 {
183         struct afs_cell *old_root, *new_root;
184         char *cp;
185
186         _enter("");
187
188         if (!rootcell) {
189                 /* module is loaded with no parameters, or built statically.
190                  * - in the future we might initialize cell DB here.
191                  */
192                 _leave(" = 0 [no root]");
193                 return 0;
194         }
195
196         cp = strchr(rootcell, ':');
197         if (!cp) {
198                 printk(KERN_ERR "kAFS: no VL server IP addresses specified\n");
199                 _leave(" = -EINVAL");
200                 return -EINVAL;
201         }
202
203         /* allocate a cell record for the root cell */
204         *cp++ = 0;
205         new_root = afs_cell_create(rootcell, cp);
206         if (IS_ERR(new_root)) {
207                 _leave(" = %ld", PTR_ERR(new_root));
208                 return PTR_ERR(new_root);
209         }
210
211         /* install the new cell */
212         write_lock(&afs_cells_lock);
213         old_root = afs_cell_root;
214         afs_cell_root = new_root;
215         write_unlock(&afs_cells_lock);
216         afs_put_cell(old_root);
217
218         _leave(" = 0");
219         return 0;
220 }
221
222 /*
223  * lookup a cell record
224  */
225 struct afs_cell *afs_cell_lookup(const char *name, unsigned namesz)
226 {
227         struct afs_cell *cell;
228
229         _enter("\"%*.*s\",", namesz, namesz, name ? name : "");
230
231         down_read(&afs_cells_sem);
232         read_lock(&afs_cells_lock);
233
234         if (name) {
235                 /* if the cell was named, look for it in the cell record list */
236                 list_for_each_entry(cell, &afs_cells, link) {
237                         if (strncmp(cell->name, name, namesz) == 0) {
238                                 afs_get_cell(cell);
239                                 goto found;
240                         }
241                 }
242                 cell = ERR_PTR(-ENOENT);
243         found:
244                 ;
245         } else {
246                 cell = afs_cell_root;
247                 if (!cell) {
248                         /* this should not happen unless user tries to mount
249                          * when root cell is not set. Return an impossibly
250                          * bizzare errno to alert the user. Things like
251                          * ENOENT might be "more appropriate" but they happen
252                          * for other reasons.
253                          */
254                         cell = ERR_PTR(-EDESTADDRREQ);
255                 } else {
256                         afs_get_cell(cell);
257                 }
258
259         }
260
261         read_unlock(&afs_cells_lock);
262         up_read(&afs_cells_sem);
263         _leave(" = %p", cell);
264         return cell;
265 }
266
267 /*
268  * try and get a cell record
269  */
270 struct afs_cell *afs_get_cell_maybe(struct afs_cell *cell)
271 {
272         write_lock(&afs_cells_lock);
273
274         if (cell && !list_empty(&cell->link))
275                 afs_get_cell(cell);
276         else
277                 cell = NULL;
278
279         write_unlock(&afs_cells_lock);
280         return cell;
281 }
282
283 /*
284  * destroy a cell record
285  */
286 void afs_put_cell(struct afs_cell *cell)
287 {
288         if (!cell)
289                 return;
290
291         _enter("%p{%d,%s}", cell, atomic_read(&cell->usage), cell->name);
292
293         ASSERTCMP(atomic_read(&cell->usage), >, 0);
294
295         /* to prevent a race, the decrement and the dequeue must be effectively
296          * atomic */
297         write_lock(&afs_cells_lock);
298
299         if (likely(!atomic_dec_and_test(&cell->usage))) {
300                 write_unlock(&afs_cells_lock);
301                 _leave("");
302                 return;
303         }
304
305         ASSERT(list_empty(&cell->servers));
306         ASSERT(list_empty(&cell->vl_list));
307
308         write_unlock(&afs_cells_lock);
309
310         wake_up(&afs_cells_freeable_wq);
311
312         _leave(" [unused]");
313 }
314
315 /*
316  * destroy a cell record
317  * - must be called with the afs_cells_sem write-locked
318  * - cell->link should have been broken by the caller
319  */
320 static void afs_cell_destroy(struct afs_cell *cell)
321 {
322         _enter("%p{%d,%s}", cell, atomic_read(&cell->usage), cell->name);
323
324         ASSERTCMP(atomic_read(&cell->usage), >=, 0);
325         ASSERT(list_empty(&cell->link));
326
327         /* wait for everyone to stop using the cell */
328         if (atomic_read(&cell->usage) > 0) {
329                 DECLARE_WAITQUEUE(myself, current);
330
331                 _debug("wait for cell %s", cell->name);
332                 set_current_state(TASK_UNINTERRUPTIBLE);
333                 add_wait_queue(&afs_cells_freeable_wq, &myself);
334
335                 while (atomic_read(&cell->usage) > 0) {
336                         schedule();
337                         set_current_state(TASK_UNINTERRUPTIBLE);
338                 }
339
340                 remove_wait_queue(&afs_cells_freeable_wq, &myself);
341                 set_current_state(TASK_RUNNING);
342         }
343
344         _debug("cell dead");
345         ASSERTCMP(atomic_read(&cell->usage), ==, 0);
346         ASSERT(list_empty(&cell->servers));
347         ASSERT(list_empty(&cell->vl_list));
348
349         afs_proc_cell_remove(cell);
350
351         down_write(&afs_proc_cells_sem);
352         list_del_init(&cell->proc_link);
353         up_write(&afs_proc_cells_sem);
354
355 #ifdef AFS_CACHING_SUPPORT
356         cachefs_relinquish_cookie(cell->cache, 0);
357 #endif
358
359         key_put(cell->anonymous_key);
360         kfree(cell);
361
362         _leave(" [destroyed]");
363 }
364
365 /*
366  * purge in-memory cell database on module unload or afs_init() failure
367  * - the timeout daemon is stopped before calling this
368  */
369 void afs_cell_purge(void)
370 {
371         struct afs_cell *cell;
372
373         _enter("");
374
375         afs_put_cell(afs_cell_root);
376
377         down_write(&afs_cells_sem);
378
379         while (!list_empty(&afs_cells)) {
380                 cell = NULL;
381
382                 /* remove the next cell from the front of the list */
383                 write_lock(&afs_cells_lock);
384
385                 if (!list_empty(&afs_cells)) {
386                         cell = list_entry(afs_cells.next,
387                                           struct afs_cell, link);
388                         list_del_init(&cell->link);
389                 }
390
391                 write_unlock(&afs_cells_lock);
392
393                 if (cell) {
394                         _debug("PURGING CELL %s (%d)",
395                                cell->name, atomic_read(&cell->usage));
396
397                         /* now the cell should be left with no references */
398                         afs_cell_destroy(cell);
399                 }
400         }
401
402         up_write(&afs_cells_sem);
403         _leave("");
404 }