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