1 /* AFS superblock handling 2 * 3 * Copyright (c) 2002, 2007 Red Hat, Inc. All rights reserved. 4 * 5 * This software may be freely redistributed under the terms of the 6 * GNU General Public License. 7 * 8 * You should have received a copy of the GNU General Public License 9 * along with this program; if not, write to the Free Software 10 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 11 * 12 * Authors: David Howells <dhowells@redhat.com> 13 * David Woodhouse <dwmw2@infradead.org> 14 * 15 */ 16 17 #include <linux/kernel.h> 18 #include <linux/module.h> 19 #include <linux/mount.h> 20 #include <linux/init.h> 21 #include <linux/slab.h> 22 #include <linux/fs.h> 23 #include <linux/pagemap.h> 24 #include <linux/parser.h> 25 #include <linux/statfs.h> 26 #include <linux/sched.h> 27 #include "internal.h" 28 29 #define AFS_FS_MAGIC 0x6B414653 /* 'kAFS' */ 30 31 static void afs_i_init_once(void *foo); 32 static struct dentry *afs_mount(struct file_system_type *fs_type, 33 int flags, const char *dev_name, void *data); 34 static struct inode *afs_alloc_inode(struct super_block *sb); 35 static void afs_put_super(struct super_block *sb); 36 static void afs_destroy_inode(struct inode *inode); 37 static int afs_statfs(struct dentry *dentry, struct kstatfs *buf); 38 39 struct file_system_type afs_fs_type = { 40 .owner = THIS_MODULE, 41 .name = "afs", 42 .mount = afs_mount, 43 .kill_sb = kill_anon_super, 44 .fs_flags = 0, 45 }; 46 47 static const struct super_operations afs_super_ops = { 48 .statfs = afs_statfs, 49 .alloc_inode = afs_alloc_inode, 50 .drop_inode = afs_drop_inode, 51 .destroy_inode = afs_destroy_inode, 52 .evict_inode = afs_evict_inode, 53 .put_super = afs_put_super, 54 .show_options = generic_show_options, 55 }; 56 57 static struct kmem_cache *afs_inode_cachep; 58 static atomic_t afs_count_active_inodes; 59 60 enum { 61 afs_no_opt, 62 afs_opt_cell, 63 afs_opt_rwpath, 64 afs_opt_vol, 65 afs_opt_autocell, 66 }; 67 68 static const match_table_t afs_options_list = { 69 { afs_opt_cell, "cell=%s" }, 70 { afs_opt_rwpath, "rwpath" }, 71 { afs_opt_vol, "vol=%s" }, 72 { afs_opt_autocell, "autocell" }, 73 { afs_no_opt, NULL }, 74 }; 75 76 /* 77 * initialise the filesystem 78 */ 79 int __init afs_fs_init(void) 80 { 81 int ret; 82 83 _enter(""); 84 85 /* create ourselves an inode cache */ 86 atomic_set(&afs_count_active_inodes, 0); 87 88 ret = -ENOMEM; 89 afs_inode_cachep = kmem_cache_create("afs_inode_cache", 90 sizeof(struct afs_vnode), 91 0, 92 SLAB_HWCACHE_ALIGN, 93 afs_i_init_once); 94 if (!afs_inode_cachep) { 95 printk(KERN_NOTICE "kAFS: Failed to allocate inode cache\n"); 96 return ret; 97 } 98 99 /* now export our filesystem to lesser mortals */ 100 ret = register_filesystem(&afs_fs_type); 101 if (ret < 0) { 102 kmem_cache_destroy(afs_inode_cachep); 103 _leave(" = %d", ret); 104 return ret; 105 } 106 107 _leave(" = 0"); 108 return 0; 109 } 110 111 /* 112 * clean up the filesystem 113 */ 114 void __exit afs_fs_exit(void) 115 { 116 _enter(""); 117 118 afs_mntpt_kill_timer(); 119 unregister_filesystem(&afs_fs_type); 120 121 if (atomic_read(&afs_count_active_inodes) != 0) { 122 printk("kAFS: %d active inode objects still present\n", 123 atomic_read(&afs_count_active_inodes)); 124 BUG(); 125 } 126 127 kmem_cache_destroy(afs_inode_cachep); 128 _leave(""); 129 } 130 131 /* 132 * parse the mount options 133 * - this function has been shamelessly adapted from the ext3 fs which 134 * shamelessly adapted it from the msdos fs 135 */ 136 static int afs_parse_options(struct afs_mount_params *params, 137 char *options, const char **devname) 138 { 139 struct afs_cell *cell; 140 substring_t args[MAX_OPT_ARGS]; 141 char *p; 142 int token; 143 144 _enter("%s", options); 145 146 options[PAGE_SIZE - 1] = 0; 147 148 while ((p = strsep(&options, ","))) { 149 if (!*p) 150 continue; 151 152 token = match_token(p, afs_options_list, args); 153 switch (token) { 154 case afs_opt_cell: 155 cell = afs_cell_lookup(args[0].from, 156 args[0].to - args[0].from, 157 false); 158 if (IS_ERR(cell)) 159 return PTR_ERR(cell); 160 afs_put_cell(params->cell); 161 params->cell = cell; 162 break; 163 164 case afs_opt_rwpath: 165 params->rwpath = 1; 166 break; 167 168 case afs_opt_vol: 169 *devname = args[0].from; 170 break; 171 172 case afs_opt_autocell: 173 params->autocell = 1; 174 break; 175 176 default: 177 printk(KERN_ERR "kAFS:" 178 " Unknown or invalid mount option: '%s'\n", p); 179 return -EINVAL; 180 } 181 } 182 183 _leave(" = 0"); 184 return 0; 185 } 186 187 /* 188 * parse a device name to get cell name, volume name, volume type and R/W 189 * selector 190 * - this can be one of the following: 191 * "%[cell:]volume[.]" R/W volume 192 * "#[cell:]volume[.]" R/O or R/W volume (rwpath=0), 193 * or R/W (rwpath=1) volume 194 * "%[cell:]volume.readonly" R/O volume 195 * "#[cell:]volume.readonly" R/O volume 196 * "%[cell:]volume.backup" Backup volume 197 * "#[cell:]volume.backup" Backup volume 198 */ 199 static int afs_parse_device_name(struct afs_mount_params *params, 200 const char *name) 201 { 202 struct afs_cell *cell; 203 const char *cellname, *suffix; 204 int cellnamesz; 205 206 _enter(",%s", name); 207 208 if (!name) { 209 printk(KERN_ERR "kAFS: no volume name specified\n"); 210 return -EINVAL; 211 } 212 213 if ((name[0] != '%' && name[0] != '#') || !name[1]) { 214 printk(KERN_ERR "kAFS: unparsable volume name\n"); 215 return -EINVAL; 216 } 217 218 /* determine the type of volume we're looking for */ 219 params->type = AFSVL_ROVOL; 220 params->force = false; 221 if (params->rwpath || name[0] == '%') { 222 params->type = AFSVL_RWVOL; 223 params->force = true; 224 } 225 name++; 226 227 /* split the cell name out if there is one */ 228 params->volname = strchr(name, ':'); 229 if (params->volname) { 230 cellname = name; 231 cellnamesz = params->volname - name; 232 params->volname++; 233 } else { 234 params->volname = name; 235 cellname = NULL; 236 cellnamesz = 0; 237 } 238 239 /* the volume type is further affected by a possible suffix */ 240 suffix = strrchr(params->volname, '.'); 241 if (suffix) { 242 if (strcmp(suffix, ".readonly") == 0) { 243 params->type = AFSVL_ROVOL; 244 params->force = true; 245 } else if (strcmp(suffix, ".backup") == 0) { 246 params->type = AFSVL_BACKVOL; 247 params->force = true; 248 } else if (suffix[1] == 0) { 249 } else { 250 suffix = NULL; 251 } 252 } 253 254 params->volnamesz = suffix ? 255 suffix - params->volname : strlen(params->volname); 256 257 _debug("cell %*.*s [%p]", 258 cellnamesz, cellnamesz, cellname ?: "", params->cell); 259 260 /* lookup the cell record */ 261 if (cellname || !params->cell) { 262 cell = afs_cell_lookup(cellname, cellnamesz, true); 263 if (IS_ERR(cell)) { 264 printk(KERN_ERR "kAFS: unable to lookup cell '%*.*s'\n", 265 cellnamesz, cellnamesz, cellname ?: ""); 266 return PTR_ERR(cell); 267 } 268 afs_put_cell(params->cell); 269 params->cell = cell; 270 } 271 272 _debug("CELL:%s [%p] VOLUME:%*.*s SUFFIX:%s TYPE:%d%s", 273 params->cell->name, params->cell, 274 params->volnamesz, params->volnamesz, params->volname, 275 suffix ?: "-", params->type, params->force ? " FORCE" : ""); 276 277 return 0; 278 } 279 280 /* 281 * check a superblock to see if it's the one we're looking for 282 */ 283 static int afs_test_super(struct super_block *sb, void *data) 284 { 285 struct afs_mount_params *params = data; 286 struct afs_super_info *as = sb->s_fs_info; 287 288 return as->volume == params->volume; 289 } 290 291 /* 292 * fill in the superblock 293 */ 294 static int afs_fill_super(struct super_block *sb, void *data) 295 { 296 struct afs_mount_params *params = data; 297 struct afs_super_info *as = NULL; 298 struct afs_fid fid; 299 struct dentry *root = NULL; 300 struct inode *inode = NULL; 301 int ret; 302 303 _enter(""); 304 305 /* allocate a superblock info record */ 306 as = kzalloc(sizeof(struct afs_super_info), GFP_KERNEL); 307 if (!as) { 308 _leave(" = -ENOMEM"); 309 return -ENOMEM; 310 } 311 312 afs_get_volume(params->volume); 313 as->volume = params->volume; 314 315 /* fill in the superblock */ 316 sb->s_blocksize = PAGE_CACHE_SIZE; 317 sb->s_blocksize_bits = PAGE_CACHE_SHIFT; 318 sb->s_magic = AFS_FS_MAGIC; 319 sb->s_op = &afs_super_ops; 320 sb->s_fs_info = as; 321 sb->s_bdi = &as->volume->bdi; 322 323 /* allocate the root inode and dentry */ 324 fid.vid = as->volume->vid; 325 fid.vnode = 1; 326 fid.unique = 1; 327 inode = afs_iget(sb, params->key, &fid, NULL, NULL); 328 if (IS_ERR(inode)) 329 goto error_inode; 330 331 if (params->autocell) 332 set_bit(AFS_VNODE_AUTOCELL, &AFS_FS_I(inode)->flags); 333 334 ret = -ENOMEM; 335 root = d_alloc_root(inode); 336 if (!root) 337 goto error; 338 339 sb->s_root = root; 340 341 _leave(" = 0"); 342 return 0; 343 344 error_inode: 345 ret = PTR_ERR(inode); 346 inode = NULL; 347 error: 348 iput(inode); 349 afs_put_volume(as->volume); 350 kfree(as); 351 352 sb->s_fs_info = NULL; 353 354 _leave(" = %d", ret); 355 return ret; 356 } 357 358 /* 359 * get an AFS superblock 360 */ 361 static struct dentry *afs_mount(struct file_system_type *fs_type, 362 int flags, const char *dev_name, void *options) 363 { 364 struct afs_mount_params params; 365 struct super_block *sb; 366 struct afs_volume *vol; 367 struct key *key; 368 char *new_opts = kstrdup(options, GFP_KERNEL); 369 int ret; 370 371 _enter(",,%s,%p", dev_name, options); 372 373 memset(¶ms, 0, sizeof(params)); 374 375 /* parse the options and device name */ 376 if (options) { 377 ret = afs_parse_options(¶ms, options, &dev_name); 378 if (ret < 0) 379 goto error; 380 } 381 382 ret = afs_parse_device_name(¶ms, dev_name); 383 if (ret < 0) 384 goto error; 385 386 /* try and do the mount securely */ 387 key = afs_request_key(params.cell); 388 if (IS_ERR(key)) { 389 _leave(" = %ld [key]", PTR_ERR(key)); 390 ret = PTR_ERR(key); 391 goto error; 392 } 393 params.key = key; 394 395 /* parse the device name */ 396 vol = afs_volume_lookup(¶ms); 397 if (IS_ERR(vol)) { 398 ret = PTR_ERR(vol); 399 goto error; 400 } 401 params.volume = vol; 402 403 /* allocate a deviceless superblock */ 404 sb = sget(fs_type, afs_test_super, set_anon_super, ¶ms); 405 if (IS_ERR(sb)) { 406 ret = PTR_ERR(sb); 407 goto error; 408 } 409 410 if (!sb->s_root) { 411 /* initial superblock/root creation */ 412 _debug("create"); 413 sb->s_flags = flags; 414 ret = afs_fill_super(sb, ¶ms); 415 if (ret < 0) { 416 deactivate_locked_super(sb); 417 goto error; 418 } 419 save_mount_options(sb, new_opts); 420 sb->s_flags |= MS_ACTIVE; 421 } else { 422 _debug("reuse"); 423 ASSERTCMP(sb->s_flags, &, MS_ACTIVE); 424 } 425 426 afs_put_volume(params.volume); 427 afs_put_cell(params.cell); 428 kfree(new_opts); 429 _leave(" = 0 [%p]", sb); 430 return dget(sb->s_root); 431 432 error: 433 afs_put_volume(params.volume); 434 afs_put_cell(params.cell); 435 key_put(params.key); 436 kfree(new_opts); 437 _leave(" = %d", ret); 438 return ERR_PTR(ret); 439 } 440 441 /* 442 * finish the unmounting process on the superblock 443 */ 444 static void afs_put_super(struct super_block *sb) 445 { 446 struct afs_super_info *as = sb->s_fs_info; 447 448 _enter(""); 449 450 afs_put_volume(as->volume); 451 452 _leave(""); 453 } 454 455 /* 456 * initialise an inode cache slab element prior to any use 457 */ 458 static void afs_i_init_once(void *_vnode) 459 { 460 struct afs_vnode *vnode = _vnode; 461 462 memset(vnode, 0, sizeof(*vnode)); 463 inode_init_once(&vnode->vfs_inode); 464 init_waitqueue_head(&vnode->update_waitq); 465 mutex_init(&vnode->permits_lock); 466 mutex_init(&vnode->validate_lock); 467 spin_lock_init(&vnode->writeback_lock); 468 spin_lock_init(&vnode->lock); 469 INIT_LIST_HEAD(&vnode->writebacks); 470 INIT_LIST_HEAD(&vnode->pending_locks); 471 INIT_LIST_HEAD(&vnode->granted_locks); 472 INIT_DELAYED_WORK(&vnode->lock_work, afs_lock_work); 473 INIT_WORK(&vnode->cb_broken_work, afs_broken_callback_work); 474 } 475 476 /* 477 * allocate an AFS inode struct from our slab cache 478 */ 479 static struct inode *afs_alloc_inode(struct super_block *sb) 480 { 481 struct afs_vnode *vnode; 482 483 vnode = kmem_cache_alloc(afs_inode_cachep, GFP_KERNEL); 484 if (!vnode) 485 return NULL; 486 487 atomic_inc(&afs_count_active_inodes); 488 489 memset(&vnode->fid, 0, sizeof(vnode->fid)); 490 memset(&vnode->status, 0, sizeof(vnode->status)); 491 492 vnode->volume = NULL; 493 vnode->update_cnt = 0; 494 vnode->flags = 1 << AFS_VNODE_UNSET; 495 vnode->cb_promised = false; 496 497 _leave(" = %p", &vnode->vfs_inode); 498 return &vnode->vfs_inode; 499 } 500 501 static void afs_i_callback(struct rcu_head *head) 502 { 503 struct inode *inode = container_of(head, struct inode, i_rcu); 504 struct afs_vnode *vnode = AFS_FS_I(inode); 505 INIT_LIST_HEAD(&inode->i_dentry); 506 kmem_cache_free(afs_inode_cachep, vnode); 507 } 508 509 /* 510 * destroy an AFS inode struct 511 */ 512 static void afs_destroy_inode(struct inode *inode) 513 { 514 struct afs_vnode *vnode = AFS_FS_I(inode); 515 516 _enter("%p{%x:%u}", inode, vnode->fid.vid, vnode->fid.vnode); 517 518 _debug("DESTROY INODE %p", inode); 519 520 ASSERTCMP(vnode->server, ==, NULL); 521 522 call_rcu(&inode->i_rcu, afs_i_callback); 523 atomic_dec(&afs_count_active_inodes); 524 } 525 526 /* 527 * return information about an AFS volume 528 */ 529 static int afs_statfs(struct dentry *dentry, struct kstatfs *buf) 530 { 531 struct afs_volume_status vs; 532 struct afs_vnode *vnode = AFS_FS_I(dentry->d_inode); 533 struct key *key; 534 int ret; 535 536 key = afs_request_key(vnode->volume->cell); 537 if (IS_ERR(key)) 538 return PTR_ERR(key); 539 540 ret = afs_vnode_get_volume_status(vnode, key, &vs); 541 key_put(key); 542 if (ret < 0) { 543 _leave(" = %d", ret); 544 return ret; 545 } 546 547 buf->f_type = dentry->d_sb->s_magic; 548 buf->f_bsize = AFS_BLOCK_SIZE; 549 buf->f_namelen = AFSNAMEMAX - 1; 550 551 if (vs.max_quota == 0) 552 buf->f_blocks = vs.part_max_blocks; 553 else 554 buf->f_blocks = vs.max_quota; 555 buf->f_bavail = buf->f_bfree = buf->f_blocks - vs.blocks_in_use; 556 return 0; 557 } 558