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/dns_resolver.h>
17 #include <linux/sched.h>
18 #include <keys/rxrpc-type.h>
21 DECLARE_RWSEM(afs_proc_cells_sem
);
22 LIST_HEAD(afs_proc_cells
);
24 static LIST_HEAD(afs_cells
);
25 static DEFINE_RWLOCK(afs_cells_lock
);
26 static DECLARE_RWSEM(afs_cells_sem
); /* add/remove serialisation */
27 static DECLARE_WAIT_QUEUE_HEAD(afs_cells_freeable_wq
);
28 static struct afs_cell
*afs_cell_root
;
31 * allocate a cell record and fill in its name, VL server address list and
32 * allocate an anonymous key
34 static struct afs_cell
*afs_cell_alloc(const char *name
, unsigned namelen
,
37 struct afs_cell
*cell
;
39 char keyname
[4 + AFS_MAXCELLNAME
+ 1], *cp
, *dp
, *next
;
40 char *dvllist
= NULL
, *_vllist
= NULL
;
44 _enter("%*.*s,%s", namelen
, namelen
, name
?: "", vllist
);
46 BUG_ON(!name
); /* TODO: want to look up "this cell" in the cache */
48 if (namelen
> AFS_MAXCELLNAME
) {
49 _leave(" = -ENAMETOOLONG");
50 return ERR_PTR(-ENAMETOOLONG
);
53 /* allocate and initialise a cell record */
54 cell
= kzalloc(sizeof(struct afs_cell
) + namelen
+ 1, GFP_KERNEL
);
57 return ERR_PTR(-ENOMEM
);
60 memcpy(cell
->name
, name
, namelen
);
61 cell
->name
[namelen
] = 0;
63 atomic_set(&cell
->usage
, 1);
64 INIT_LIST_HEAD(&cell
->link
);
65 rwlock_init(&cell
->servers_lock
);
66 INIT_LIST_HEAD(&cell
->servers
);
67 init_rwsem(&cell
->vl_sem
);
68 INIT_LIST_HEAD(&cell
->vl_list
);
69 spin_lock_init(&cell
->vl_lock
);
71 /* if the ip address is invalid, try dns query */
72 if (!vllist
|| strlen(vllist
) < 7) {
73 ret
= dns_query("afsdb", name
, namelen
, "ipv4", &dvllist
, NULL
);
75 if (ret
== -ENODATA
|| ret
== -EAGAIN
|| ret
== -ENOKEY
)
76 /* translate these errors into something
77 * userspace might understand */
84 /* change the delimiter for user-space reply */
91 /* fill in the VL server list from the rest of the string */
95 next
= strchr(_vllist
, delimiter
);
99 if (sscanf(_vllist
, "%u.%u.%u.%u", &a
, &b
, &c
, &d
) != 4)
102 if (a
> 255 || b
> 255 || c
> 255 || d
> 255)
105 cell
->vl_addrs
[cell
->vl_naddrs
++].s_addr
=
106 htonl((a
<< 24) | (b
<< 16) | (c
<< 8) | d
);
108 } while (cell
->vl_naddrs
< AFS_CELL_MAX_ADDRS
&& (_vllist
= next
));
110 /* create a key to represent an anonymous user */
111 memcpy(keyname
, "afs@", 4);
115 *dp
++ = toupper(*cp
);
118 key
= rxrpc_get_null_key(keyname
);
124 cell
->anonymous_key
= key
;
126 _debug("anon key %p{%x}",
127 cell
->anonymous_key
, key_serial(cell
->anonymous_key
));
129 _leave(" = %p", cell
);
133 printk(KERN_ERR
"kAFS: bad VL server IP address\n");
136 key_put(cell
->anonymous_key
);
139 _leave(" = %d", ret
);
144 * afs_cell_crate() - create a cell record
145 * @name: is the name of the cell.
146 * @namsesz: is the strlen of the cell name.
147 * @vllist: is a colon separated list of IP addresses in "a.b.c.d" format.
148 * @retref: is T to return the cell reference when the cell exists.
150 struct afs_cell
*afs_cell_create(const char *name
, unsigned namesz
,
151 char *vllist
, bool retref
)
153 struct afs_cell
*cell
;
156 _enter("%*.*s,%s", namesz
, namesz
, name
?: "", vllist
);
158 down_write(&afs_cells_sem
);
159 read_lock(&afs_cells_lock
);
160 list_for_each_entry(cell
, &afs_cells
, link
) {
161 if (strncasecmp(cell
->name
, name
, namesz
) == 0)
164 read_unlock(&afs_cells_lock
);
166 cell
= afs_cell_alloc(name
, namesz
, vllist
);
168 _leave(" = %ld", PTR_ERR(cell
));
169 up_write(&afs_cells_sem
);
173 /* add a proc directory for this cell */
174 ret
= afs_proc_cell_setup(cell
);
178 #ifdef CONFIG_AFS_FSCACHE
179 /* put it up for caching (this never returns an error) */
180 cell
->cache
= fscache_acquire_cookie(afs_cache_netfs
.primary_index
,
181 &afs_cell_cache_index_def
,
185 /* add to the cell lists */
186 write_lock(&afs_cells_lock
);
187 list_add_tail(&cell
->link
, &afs_cells
);
188 write_unlock(&afs_cells_lock
);
190 down_write(&afs_proc_cells_sem
);
191 list_add_tail(&cell
->proc_link
, &afs_proc_cells
);
192 up_write(&afs_proc_cells_sem
);
193 up_write(&afs_cells_sem
);
195 _leave(" = %p", cell
);
199 up_write(&afs_cells_sem
);
200 key_put(cell
->anonymous_key
);
202 _leave(" = %d", ret
);
206 if (retref
&& !IS_ERR(cell
))
209 read_unlock(&afs_cells_lock
);
210 up_write(&afs_cells_sem
);
213 _leave(" = %p", cell
);
217 _leave(" = -EEXIST");
218 return ERR_PTR(-EEXIST
);
222 * set the root cell information
223 * - can be called with a module parameter string
224 * - can be called from a write to /proc/fs/afs/rootcell
226 int afs_cell_init(char *rootcell
)
228 struct afs_cell
*old_root
, *new_root
;
234 /* module is loaded with no parameters, or built statically.
235 * - in the future we might initialize cell DB here.
237 _leave(" = 0 [no root]");
241 cp
= strchr(rootcell
, ':');
243 _debug("kAFS: no VL server IP addresses specified");
247 /* allocate a cell record for the root cell */
248 new_root
= afs_cell_create(rootcell
, strlen(rootcell
), cp
, false);
249 if (IS_ERR(new_root
)) {
250 _leave(" = %ld", PTR_ERR(new_root
));
251 return PTR_ERR(new_root
);
254 /* install the new cell */
255 write_lock(&afs_cells_lock
);
256 old_root
= afs_cell_root
;
257 afs_cell_root
= new_root
;
258 write_unlock(&afs_cells_lock
);
259 afs_put_cell(old_root
);
266 * lookup a cell record
268 struct afs_cell
*afs_cell_lookup(const char *name
, unsigned namesz
,
271 struct afs_cell
*cell
;
273 _enter("\"%*.*s\",", namesz
, namesz
, name
?: "");
275 down_read(&afs_cells_sem
);
276 read_lock(&afs_cells_lock
);
279 /* if the cell was named, look for it in the cell record list */
280 list_for_each_entry(cell
, &afs_cells
, link
) {
281 if (strncmp(cell
->name
, name
, namesz
) == 0) {
286 cell
= ERR_PTR(-ENOENT
);
292 cell
= afs_cell_root
;
294 /* this should not happen unless user tries to mount
295 * when root cell is not set. Return an impossibly
296 * bizarre errno to alert the user. Things like
297 * ENOENT might be "more appropriate" but they happen
300 cell
= ERR_PTR(-EDESTADDRREQ
);
307 read_unlock(&afs_cells_lock
);
308 up_read(&afs_cells_sem
);
309 _leave(" = %p", cell
);
313 read_unlock(&afs_cells_lock
);
314 up_read(&afs_cells_sem
);
316 cell
= afs_cell_create(name
, namesz
, NULL
, true);
318 _leave(" = %p", cell
);
324 * try and get a cell record
326 struct afs_cell
*afs_get_cell_maybe(struct afs_cell
*cell
)
328 write_lock(&afs_cells_lock
);
330 if (cell
&& !list_empty(&cell
->link
))
335 write_unlock(&afs_cells_lock
);
341 * destroy a cell record
343 void afs_put_cell(struct afs_cell
*cell
)
348 _enter("%p{%d,%s}", cell
, atomic_read(&cell
->usage
), cell
->name
);
350 ASSERTCMP(atomic_read(&cell
->usage
), >, 0);
352 /* to prevent a race, the decrement and the dequeue must be effectively
354 write_lock(&afs_cells_lock
);
356 if (likely(!atomic_dec_and_test(&cell
->usage
))) {
357 write_unlock(&afs_cells_lock
);
362 ASSERT(list_empty(&cell
->servers
));
363 ASSERT(list_empty(&cell
->vl_list
));
365 write_unlock(&afs_cells_lock
);
367 wake_up(&afs_cells_freeable_wq
);
373 * destroy a cell record
374 * - must be called with the afs_cells_sem write-locked
375 * - cell->link should have been broken by the caller
377 static void afs_cell_destroy(struct afs_cell
*cell
)
379 _enter("%p{%d,%s}", cell
, atomic_read(&cell
->usage
), cell
->name
);
381 ASSERTCMP(atomic_read(&cell
->usage
), >=, 0);
382 ASSERT(list_empty(&cell
->link
));
384 /* wait for everyone to stop using the cell */
385 if (atomic_read(&cell
->usage
) > 0) {
386 DECLARE_WAITQUEUE(myself
, current
);
388 _debug("wait for cell %s", cell
->name
);
389 set_current_state(TASK_UNINTERRUPTIBLE
);
390 add_wait_queue(&afs_cells_freeable_wq
, &myself
);
392 while (atomic_read(&cell
->usage
) > 0) {
394 set_current_state(TASK_UNINTERRUPTIBLE
);
397 remove_wait_queue(&afs_cells_freeable_wq
, &myself
);
398 set_current_state(TASK_RUNNING
);
402 ASSERTCMP(atomic_read(&cell
->usage
), ==, 0);
403 ASSERT(list_empty(&cell
->servers
));
404 ASSERT(list_empty(&cell
->vl_list
));
406 afs_proc_cell_remove(cell
);
408 down_write(&afs_proc_cells_sem
);
409 list_del_init(&cell
->proc_link
);
410 up_write(&afs_proc_cells_sem
);
412 #ifdef CONFIG_AFS_FSCACHE
413 fscache_relinquish_cookie(cell
->cache
, 0);
415 key_put(cell
->anonymous_key
);
418 _leave(" [destroyed]");
422 * purge in-memory cell database on module unload or afs_init() failure
423 * - the timeout daemon is stopped before calling this
425 void afs_cell_purge(void)
427 struct afs_cell
*cell
;
431 afs_put_cell(afs_cell_root
);
433 down_write(&afs_cells_sem
);
435 while (!list_empty(&afs_cells
)) {
438 /* remove the next cell from the front of the list */
439 write_lock(&afs_cells_lock
);
441 if (!list_empty(&afs_cells
)) {
442 cell
= list_entry(afs_cells
.next
,
443 struct afs_cell
, link
);
444 list_del_init(&cell
->link
);
447 write_unlock(&afs_cells_lock
);
450 _debug("PURGING CELL %s (%d)",
451 cell
->name
, atomic_read(&cell
->usage
));
453 /* now the cell should be left with no references */
454 afs_cell_destroy(cell
);
458 up_write(&afs_cells_sem
);
This page took 0.042626 seconds and 5 git commands to generate.