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