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