1 /* AFS cell and server record management
3 * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
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.
12 #include <linux/module.h>
13 #include <linux/slab.h>
14 #include <linux/key.h>
15 #include <linux/ctype.h>
16 #include <linux/sched.h>
17 #include <keys/rxrpc-type.h>
20 DECLARE_RWSEM(afs_proc_cells_sem
);
21 LIST_HEAD(afs_proc_cells
);
23 static LIST_HEAD(afs_cells
);
24 static DEFINE_RWLOCK(afs_cells_lock
);
25 static DECLARE_RWSEM(afs_cells_sem
); /* add/remove serialisation */
26 static DECLARE_WAIT_QUEUE_HEAD(afs_cells_freeable_wq
);
27 static struct afs_cell
*afs_cell_root
;
30 * allocate a cell record and fill in its name, VL server address list and
31 * allocate an anonymous key
33 static struct afs_cell
*afs_cell_alloc(const char *name
, char *vllist
)
35 struct afs_cell
*cell
;
38 char keyname
[4 + AFS_MAXCELLNAME
+ 1], *cp
, *dp
, *next
;
41 _enter("%s,%s", name
, vllist
);
43 BUG_ON(!name
); /* TODO: want to look up "this cell" in the cache */
45 namelen
= strlen(name
);
46 if (namelen
> AFS_MAXCELLNAME
)
47 return ERR_PTR(-ENAMETOOLONG
);
49 /* allocate and initialise a cell record */
50 cell
= kzalloc(sizeof(struct afs_cell
) + namelen
+ 1, GFP_KERNEL
);
53 return ERR_PTR(-ENOMEM
);
56 memcpy(cell
->name
, name
, namelen
);
57 cell
->name
[namelen
] = 0;
59 atomic_set(&cell
->usage
, 1);
60 INIT_LIST_HEAD(&cell
->link
);
61 rwlock_init(&cell
->servers_lock
);
62 INIT_LIST_HEAD(&cell
->servers
);
63 init_rwsem(&cell
->vl_sem
);
64 INIT_LIST_HEAD(&cell
->vl_list
);
65 spin_lock_init(&cell
->vl_lock
);
67 /* fill in the VL server list from the rest of the string */
71 next
= strchr(vllist
, ':');
75 if (sscanf(vllist
, "%u.%u.%u.%u", &a
, &b
, &c
, &d
) != 4)
78 if (a
> 255 || b
> 255 || c
> 255 || d
> 255)
81 cell
->vl_addrs
[cell
->vl_naddrs
++].s_addr
=
82 htonl((a
<< 24) | (b
<< 16) | (c
<< 8) | d
);
84 } while (cell
->vl_naddrs
< AFS_CELL_MAX_ADDRS
&& (vllist
= next
));
86 /* create a key to represent an anonymous user */
87 memcpy(keyname
, "afs@", 4);
94 key
= rxrpc_get_null_key(keyname
);
100 cell
->anonymous_key
= key
;
102 _debug("anon key %p{%x}",
103 cell
->anonymous_key
, key_serial(cell
->anonymous_key
));
105 _leave(" = %p", cell
);
109 printk(KERN_ERR
"kAFS: bad VL server IP address\n");
112 key_put(cell
->anonymous_key
);
114 _leave(" = %d", ret
);
119 * create a cell record
120 * - "name" is the name of the cell
121 * - "vllist" is a colon separated list of IP addresses in "a.b.c.d" format
123 struct afs_cell
*afs_cell_create(const char *name
, char *vllist
)
125 struct afs_cell
*cell
;
128 _enter("%s,%s", name
, vllist
);
130 down_write(&afs_cells_sem
);
131 read_lock(&afs_cells_lock
);
132 list_for_each_entry(cell
, &afs_cells
, link
) {
133 if (strcasecmp(cell
->name
, name
) == 0)
136 read_unlock(&afs_cells_lock
);
138 cell
= afs_cell_alloc(name
, vllist
);
140 _leave(" = %ld", PTR_ERR(cell
));
141 up_write(&afs_cells_sem
);
145 /* add a proc directory for this cell */
146 ret
= afs_proc_cell_setup(cell
);
150 #ifdef CONFIG_AFS_FSCACHE
151 /* put it up for caching (this never returns an error) */
152 cell
->cache
= fscache_acquire_cookie(afs_cache_netfs
.primary_index
,
153 &afs_cell_cache_index_def
,
157 /* add to the cell lists */
158 write_lock(&afs_cells_lock
);
159 list_add_tail(&cell
->link
, &afs_cells
);
160 write_unlock(&afs_cells_lock
);
162 down_write(&afs_proc_cells_sem
);
163 list_add_tail(&cell
->proc_link
, &afs_proc_cells
);
164 up_write(&afs_proc_cells_sem
);
165 up_write(&afs_cells_sem
);
167 _leave(" = %p", cell
);
171 up_write(&afs_cells_sem
);
172 key_put(cell
->anonymous_key
);
174 _leave(" = %d", ret
);
178 read_unlock(&afs_cells_lock
);
179 up_write(&afs_cells_sem
);
180 return ERR_PTR(-EEXIST
);
184 * set the root cell information
185 * - can be called with a module parameter string
186 * - can be called from a write to /proc/fs/afs/rootcell
188 int afs_cell_init(char *rootcell
)
190 struct afs_cell
*old_root
, *new_root
;
196 /* module is loaded with no parameters, or built statically.
197 * - in the future we might initialize cell DB here.
199 _leave(" = 0 [no root]");
203 cp
= strchr(rootcell
, ':');
205 printk(KERN_ERR
"kAFS: no VL server IP addresses specified\n");
206 _leave(" = -EINVAL");
210 /* allocate a cell record for the root cell */
212 new_root
= afs_cell_create(rootcell
, cp
);
213 if (IS_ERR(new_root
)) {
214 _leave(" = %ld", PTR_ERR(new_root
));
215 return PTR_ERR(new_root
);
218 /* install the new cell */
219 write_lock(&afs_cells_lock
);
220 old_root
= afs_cell_root
;
221 afs_cell_root
= new_root
;
222 write_unlock(&afs_cells_lock
);
223 afs_put_cell(old_root
);
230 * lookup a cell record
232 struct afs_cell
*afs_cell_lookup(const char *name
, unsigned namesz
)
234 struct afs_cell
*cell
;
236 _enter("\"%*.*s\",", namesz
, namesz
, name
? name
: "");
238 down_read(&afs_cells_sem
);
239 read_lock(&afs_cells_lock
);
242 /* if the cell was named, look for it in the cell record list */
243 list_for_each_entry(cell
, &afs_cells
, link
) {
244 if (strncmp(cell
->name
, name
, namesz
) == 0) {
249 cell
= ERR_PTR(-ENOENT
);
253 cell
= afs_cell_root
;
255 /* this should not happen unless user tries to mount
256 * when root cell is not set. Return an impossibly
257 * bizzare errno to alert the user. Things like
258 * ENOENT might be "more appropriate" but they happen
261 cell
= ERR_PTR(-EDESTADDRREQ
);
268 read_unlock(&afs_cells_lock
);
269 up_read(&afs_cells_sem
);
270 _leave(" = %p", cell
);
276 * try and get a cell record
278 struct afs_cell
*afs_get_cell_maybe(struct afs_cell
*cell
)
280 write_lock(&afs_cells_lock
);
282 if (cell
&& !list_empty(&cell
->link
))
287 write_unlock(&afs_cells_lock
);
293 * destroy a cell record
295 void afs_put_cell(struct afs_cell
*cell
)
300 _enter("%p{%d,%s}", cell
, atomic_read(&cell
->usage
), cell
->name
);
302 ASSERTCMP(atomic_read(&cell
->usage
), >, 0);
304 /* to prevent a race, the decrement and the dequeue must be effectively
306 write_lock(&afs_cells_lock
);
308 if (likely(!atomic_dec_and_test(&cell
->usage
))) {
309 write_unlock(&afs_cells_lock
);
314 ASSERT(list_empty(&cell
->servers
));
315 ASSERT(list_empty(&cell
->vl_list
));
317 write_unlock(&afs_cells_lock
);
319 wake_up(&afs_cells_freeable_wq
);
325 * destroy a cell record
326 * - must be called with the afs_cells_sem write-locked
327 * - cell->link should have been broken by the caller
329 static void afs_cell_destroy(struct afs_cell
*cell
)
331 _enter("%p{%d,%s}", cell
, atomic_read(&cell
->usage
), cell
->name
);
333 ASSERTCMP(atomic_read(&cell
->usage
), >=, 0);
334 ASSERT(list_empty(&cell
->link
));
336 /* wait for everyone to stop using the cell */
337 if (atomic_read(&cell
->usage
) > 0) {
338 DECLARE_WAITQUEUE(myself
, current
);
340 _debug("wait for cell %s", cell
->name
);
341 set_current_state(TASK_UNINTERRUPTIBLE
);
342 add_wait_queue(&afs_cells_freeable_wq
, &myself
);
344 while (atomic_read(&cell
->usage
) > 0) {
346 set_current_state(TASK_UNINTERRUPTIBLE
);
349 remove_wait_queue(&afs_cells_freeable_wq
, &myself
);
350 set_current_state(TASK_RUNNING
);
354 ASSERTCMP(atomic_read(&cell
->usage
), ==, 0);
355 ASSERT(list_empty(&cell
->servers
));
356 ASSERT(list_empty(&cell
->vl_list
));
358 afs_proc_cell_remove(cell
);
360 down_write(&afs_proc_cells_sem
);
361 list_del_init(&cell
->proc_link
);
362 up_write(&afs_proc_cells_sem
);
364 #ifdef CONFIG_AFS_FSCACHE
365 fscache_relinquish_cookie(cell
->cache
, 0);
367 key_put(cell
->anonymous_key
);
370 _leave(" [destroyed]");
374 * purge in-memory cell database on module unload or afs_init() failure
375 * - the timeout daemon is stopped before calling this
377 void afs_cell_purge(void)
379 struct afs_cell
*cell
;
383 afs_put_cell(afs_cell_root
);
385 down_write(&afs_cells_sem
);
387 while (!list_empty(&afs_cells
)) {
390 /* remove the next cell from the front of the list */
391 write_lock(&afs_cells_lock
);
393 if (!list_empty(&afs_cells
)) {
394 cell
= list_entry(afs_cells
.next
,
395 struct afs_cell
, link
);
396 list_del_init(&cell
->link
);
399 write_unlock(&afs_cells_lock
);
402 _debug("PURGING CELL %s (%d)",
403 cell
->name
, atomic_read(&cell
->usage
));
405 /* now the cell should be left with no references */
406 afs_cell_destroy(cell
);
410 up_write(&afs_cells_sem
);
This page took 0.039169 seconds and 5 git commands to generate.