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