1 /* 2 * linux/fs/9p/v9fs.c 3 * 4 * This file contains functions assisting in mapping VFS to 9P2000 5 * 6 * Copyright (C) 2004-2008 by Eric Van Hensbergen <ericvh@gmail.com> 7 * Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov> 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License version 2 11 * as published by the Free Software Foundation. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to: 20 * Free Software Foundation 21 * 51 Franklin Street, Fifth Floor 22 * Boston, MA 02111-1301 USA 23 * 24 */ 25 26 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 27 28 #include <linux/module.h> 29 #include <linux/errno.h> 30 #include <linux/fs.h> 31 #include <linux/sched.h> 32 #include <linux/cred.h> 33 #include <linux/parser.h> 34 #include <linux/idr.h> 35 #include <linux/slab.h> 36 #include <linux/seq_file.h> 37 #include <net/9p/9p.h> 38 #include <net/9p/client.h> 39 #include <net/9p/transport.h> 40 #include "v9fs.h" 41 #include "v9fs_vfs.h" 42 #include "cache.h" 43 44 static DEFINE_SPINLOCK(v9fs_sessionlist_lock); 45 static LIST_HEAD(v9fs_sessionlist); 46 struct kmem_cache *v9fs_inode_cache; 47 48 /* 49 * Option Parsing (code inspired by NFS code) 50 * NOTE: each transport will parse its own options 51 */ 52 53 enum { 54 /* Options that take integer arguments */ 55 Opt_debug, Opt_dfltuid, Opt_dfltgid, Opt_afid, 56 /* String options */ 57 Opt_uname, Opt_remotename, Opt_cache, Opt_cachetag, 58 /* Options that take no arguments */ 59 Opt_nodevmap, 60 /* Cache options */ 61 Opt_cache_loose, Opt_fscache, Opt_mmap, 62 /* Access options */ 63 Opt_access, Opt_posixacl, 64 /* Error token */ 65 Opt_err 66 }; 67 68 static const match_table_t tokens = { 69 {Opt_debug, "debug=%x"}, 70 {Opt_dfltuid, "dfltuid=%u"}, 71 {Opt_dfltgid, "dfltgid=%u"}, 72 {Opt_afid, "afid=%u"}, 73 {Opt_uname, "uname=%s"}, 74 {Opt_remotename, "aname=%s"}, 75 {Opt_nodevmap, "nodevmap"}, 76 {Opt_cache, "cache=%s"}, 77 {Opt_cache_loose, "loose"}, 78 {Opt_fscache, "fscache"}, 79 {Opt_mmap, "mmap"}, 80 {Opt_cachetag, "cachetag=%s"}, 81 {Opt_access, "access=%s"}, 82 {Opt_posixacl, "posixacl"}, 83 {Opt_err, NULL} 84 }; 85 86 static const char *const v9fs_cache_modes[nr__p9_cache_modes] = { 87 [CACHE_NONE] = "none", 88 [CACHE_MMAP] = "mmap", 89 [CACHE_LOOSE] = "loose", 90 [CACHE_FSCACHE] = "fscache", 91 }; 92 93 /* Interpret mount options for cache mode */ 94 static int get_cache_mode(char *s) 95 { 96 int version = -EINVAL; 97 98 if (!strcmp(s, "loose")) { 99 version = CACHE_LOOSE; 100 p9_debug(P9_DEBUG_9P, "Cache mode: loose\n"); 101 } else if (!strcmp(s, "fscache")) { 102 version = CACHE_FSCACHE; 103 p9_debug(P9_DEBUG_9P, "Cache mode: fscache\n"); 104 } else if (!strcmp(s, "mmap")) { 105 version = CACHE_MMAP; 106 p9_debug(P9_DEBUG_9P, "Cache mode: mmap\n"); 107 } else if (!strcmp(s, "none")) { 108 version = CACHE_NONE; 109 p9_debug(P9_DEBUG_9P, "Cache mode: none\n"); 110 } else 111 pr_info("Unknown Cache mode %s\n", s); 112 return version; 113 } 114 115 /* 116 * Display the mount options in /proc/mounts. 117 */ 118 int v9fs_show_options(struct seq_file *m, struct dentry *root) 119 { 120 struct v9fs_session_info *v9ses = root->d_sb->s_fs_info; 121 122 if (v9ses->debug) 123 seq_printf(m, ",debug=%x", v9ses->debug); 124 if (!uid_eq(v9ses->dfltuid, V9FS_DEFUID)) 125 seq_printf(m, ",dfltuid=%u", 126 from_kuid_munged(&init_user_ns, v9ses->dfltuid)); 127 if (!gid_eq(v9ses->dfltgid, V9FS_DEFGID)) 128 seq_printf(m, ",dfltgid=%u", 129 from_kgid_munged(&init_user_ns, v9ses->dfltgid)); 130 if (v9ses->afid != ~0) 131 seq_printf(m, ",afid=%u", v9ses->afid); 132 if (strcmp(v9ses->uname, V9FS_DEFUSER) != 0) 133 seq_printf(m, ",uname=%s", v9ses->uname); 134 if (strcmp(v9ses->aname, V9FS_DEFANAME) != 0) 135 seq_printf(m, ",aname=%s", v9ses->aname); 136 if (v9ses->nodev) 137 seq_puts(m, ",nodevmap"); 138 if (v9ses->cache) 139 seq_printf(m, ",%s", v9fs_cache_modes[v9ses->cache]); 140 #ifdef CONFIG_9P_FSCACHE 141 if (v9ses->cachetag && v9ses->cache == CACHE_FSCACHE) 142 seq_printf(m, ",cachetag=%s", v9ses->cachetag); 143 #endif 144 145 switch (v9ses->flags & V9FS_ACCESS_MASK) { 146 case V9FS_ACCESS_USER: 147 seq_puts(m, ",access=user"); 148 break; 149 case V9FS_ACCESS_ANY: 150 seq_puts(m, ",access=any"); 151 break; 152 case V9FS_ACCESS_CLIENT: 153 seq_puts(m, ",access=client"); 154 break; 155 case V9FS_ACCESS_SINGLE: 156 seq_printf(m, ",access=%u", 157 from_kuid_munged(&init_user_ns, v9ses->uid)); 158 break; 159 } 160 161 if (v9ses->flags & V9FS_POSIX_ACL) 162 seq_puts(m, ",posixacl"); 163 164 return p9_show_client_options(m, v9ses->clnt); 165 } 166 167 /** 168 * v9fs_parse_options - parse mount options into session structure 169 * @v9ses: existing v9fs session information 170 * 171 * Return 0 upon success, -ERRNO upon failure. 172 */ 173 174 static int v9fs_parse_options(struct v9fs_session_info *v9ses, char *opts) 175 { 176 char *options, *tmp_options; 177 substring_t args[MAX_OPT_ARGS]; 178 char *p; 179 int option = 0; 180 char *s, *e; 181 int ret = 0; 182 183 /* setup defaults */ 184 v9ses->afid = ~0; 185 v9ses->debug = 0; 186 v9ses->cache = CACHE_NONE; 187 #ifdef CONFIG_9P_FSCACHE 188 v9ses->cachetag = NULL; 189 #endif 190 191 if (!opts) 192 return 0; 193 194 tmp_options = kstrdup(opts, GFP_KERNEL); 195 if (!tmp_options) { 196 ret = -ENOMEM; 197 goto fail_option_alloc; 198 } 199 options = tmp_options; 200 201 while ((p = strsep(&options, ",")) != NULL) { 202 int token, r; 203 if (!*p) 204 continue; 205 token = match_token(p, tokens, args); 206 switch (token) { 207 case Opt_debug: 208 r = match_int(&args[0], &option); 209 if (r < 0) { 210 p9_debug(P9_DEBUG_ERROR, 211 "integer field, but no integer?\n"); 212 ret = r; 213 continue; 214 } 215 v9ses->debug = option; 216 #ifdef CONFIG_NET_9P_DEBUG 217 p9_debug_level = option; 218 #endif 219 break; 220 221 case Opt_dfltuid: 222 r = match_int(&args[0], &option); 223 if (r < 0) { 224 p9_debug(P9_DEBUG_ERROR, 225 "integer field, but no integer?\n"); 226 ret = r; 227 continue; 228 } 229 v9ses->dfltuid = make_kuid(current_user_ns(), option); 230 if (!uid_valid(v9ses->dfltuid)) { 231 p9_debug(P9_DEBUG_ERROR, 232 "uid field, but not a uid?\n"); 233 ret = -EINVAL; 234 continue; 235 } 236 break; 237 case Opt_dfltgid: 238 r = match_int(&args[0], &option); 239 if (r < 0) { 240 p9_debug(P9_DEBUG_ERROR, 241 "integer field, but no integer?\n"); 242 ret = r; 243 continue; 244 } 245 v9ses->dfltgid = make_kgid(current_user_ns(), option); 246 if (!gid_valid(v9ses->dfltgid)) { 247 p9_debug(P9_DEBUG_ERROR, 248 "gid field, but not a gid?\n"); 249 ret = -EINVAL; 250 continue; 251 } 252 break; 253 case Opt_afid: 254 r = match_int(&args[0], &option); 255 if (r < 0) { 256 p9_debug(P9_DEBUG_ERROR, 257 "integer field, but no integer?\n"); 258 ret = r; 259 continue; 260 } 261 v9ses->afid = option; 262 break; 263 case Opt_uname: 264 kfree(v9ses->uname); 265 v9ses->uname = match_strdup(&args[0]); 266 if (!v9ses->uname) { 267 ret = -ENOMEM; 268 goto free_and_return; 269 } 270 break; 271 case Opt_remotename: 272 kfree(v9ses->aname); 273 v9ses->aname = match_strdup(&args[0]); 274 if (!v9ses->aname) { 275 ret = -ENOMEM; 276 goto free_and_return; 277 } 278 break; 279 case Opt_nodevmap: 280 v9ses->nodev = 1; 281 break; 282 case Opt_cache_loose: 283 v9ses->cache = CACHE_LOOSE; 284 break; 285 case Opt_fscache: 286 v9ses->cache = CACHE_FSCACHE; 287 break; 288 case Opt_mmap: 289 v9ses->cache = CACHE_MMAP; 290 break; 291 case Opt_cachetag: 292 #ifdef CONFIG_9P_FSCACHE 293 kfree(v9ses->cachetag); 294 v9ses->cachetag = match_strdup(&args[0]); 295 #endif 296 break; 297 case Opt_cache: 298 s = match_strdup(&args[0]); 299 if (!s) { 300 ret = -ENOMEM; 301 p9_debug(P9_DEBUG_ERROR, 302 "problem allocating copy of cache arg\n"); 303 goto free_and_return; 304 } 305 ret = get_cache_mode(s); 306 if (ret == -EINVAL) { 307 kfree(s); 308 goto free_and_return; 309 } 310 311 v9ses->cache = ret; 312 kfree(s); 313 break; 314 315 case Opt_access: 316 s = match_strdup(&args[0]); 317 if (!s) { 318 ret = -ENOMEM; 319 p9_debug(P9_DEBUG_ERROR, 320 "problem allocating copy of access arg\n"); 321 goto free_and_return; 322 } 323 324 v9ses->flags &= ~V9FS_ACCESS_MASK; 325 if (strcmp(s, "user") == 0) 326 v9ses->flags |= V9FS_ACCESS_USER; 327 else if (strcmp(s, "any") == 0) 328 v9ses->flags |= V9FS_ACCESS_ANY; 329 else if (strcmp(s, "client") == 0) { 330 v9ses->flags |= V9FS_ACCESS_CLIENT; 331 } else { 332 uid_t uid; 333 v9ses->flags |= V9FS_ACCESS_SINGLE; 334 uid = simple_strtoul(s, &e, 10); 335 if (*e != '\0') { 336 ret = -EINVAL; 337 pr_info("Unknown access argument %s\n", 338 s); 339 kfree(s); 340 goto free_and_return; 341 } 342 v9ses->uid = make_kuid(current_user_ns(), uid); 343 if (!uid_valid(v9ses->uid)) { 344 ret = -EINVAL; 345 pr_info("Uknown uid %s\n", s); 346 kfree(s); 347 goto free_and_return; 348 } 349 } 350 351 kfree(s); 352 break; 353 354 case Opt_posixacl: 355 #ifdef CONFIG_9P_FS_POSIX_ACL 356 v9ses->flags |= V9FS_POSIX_ACL; 357 #else 358 p9_debug(P9_DEBUG_ERROR, 359 "Not defined CONFIG_9P_FS_POSIX_ACL. Ignoring posixacl option\n"); 360 #endif 361 break; 362 363 default: 364 continue; 365 } 366 } 367 368 free_and_return: 369 kfree(tmp_options); 370 fail_option_alloc: 371 return ret; 372 } 373 374 /** 375 * v9fs_session_init - initialize session 376 * @v9ses: session information structure 377 * @dev_name: device being mounted 378 * @data: options 379 * 380 */ 381 382 struct p9_fid *v9fs_session_init(struct v9fs_session_info *v9ses, 383 const char *dev_name, char *data) 384 { 385 struct p9_fid *fid; 386 int rc = -ENOMEM; 387 388 v9ses->uname = kstrdup(V9FS_DEFUSER, GFP_KERNEL); 389 if (!v9ses->uname) 390 goto err_names; 391 392 v9ses->aname = kstrdup(V9FS_DEFANAME, GFP_KERNEL); 393 if (!v9ses->aname) 394 goto err_names; 395 init_rwsem(&v9ses->rename_sem); 396 397 v9ses->uid = INVALID_UID; 398 v9ses->dfltuid = V9FS_DEFUID; 399 v9ses->dfltgid = V9FS_DEFGID; 400 401 v9ses->clnt = p9_client_create(dev_name, data); 402 if (IS_ERR(v9ses->clnt)) { 403 rc = PTR_ERR(v9ses->clnt); 404 p9_debug(P9_DEBUG_ERROR, "problem initializing 9p client\n"); 405 goto err_names; 406 } 407 408 v9ses->flags = V9FS_ACCESS_USER; 409 410 if (p9_is_proto_dotl(v9ses->clnt)) { 411 v9ses->flags = V9FS_ACCESS_CLIENT; 412 v9ses->flags |= V9FS_PROTO_2000L; 413 } else if (p9_is_proto_dotu(v9ses->clnt)) { 414 v9ses->flags |= V9FS_PROTO_2000U; 415 } 416 417 rc = v9fs_parse_options(v9ses, data); 418 if (rc < 0) 419 goto err_clnt; 420 421 v9ses->maxdata = v9ses->clnt->msize - P9_IOHDRSZ; 422 423 if (!v9fs_proto_dotl(v9ses) && 424 ((v9ses->flags & V9FS_ACCESS_MASK) == V9FS_ACCESS_CLIENT)) { 425 /* 426 * We support ACCESS_CLIENT only for dotl. 427 * Fall back to ACCESS_USER 428 */ 429 v9ses->flags &= ~V9FS_ACCESS_MASK; 430 v9ses->flags |= V9FS_ACCESS_USER; 431 } 432 /*FIXME !! */ 433 /* for legacy mode, fall back to V9FS_ACCESS_ANY */ 434 if (!(v9fs_proto_dotu(v9ses) || v9fs_proto_dotl(v9ses)) && 435 ((v9ses->flags&V9FS_ACCESS_MASK) == V9FS_ACCESS_USER)) { 436 437 v9ses->flags &= ~V9FS_ACCESS_MASK; 438 v9ses->flags |= V9FS_ACCESS_ANY; 439 v9ses->uid = INVALID_UID; 440 } 441 if (!v9fs_proto_dotl(v9ses) || 442 !((v9ses->flags & V9FS_ACCESS_MASK) == V9FS_ACCESS_CLIENT)) { 443 /* 444 * We support ACL checks on clinet only if the protocol is 445 * 9P2000.L and access is V9FS_ACCESS_CLIENT. 446 */ 447 v9ses->flags &= ~V9FS_ACL_MASK; 448 } 449 450 fid = p9_client_attach(v9ses->clnt, NULL, v9ses->uname, INVALID_UID, 451 v9ses->aname); 452 if (IS_ERR(fid)) { 453 rc = PTR_ERR(fid); 454 p9_debug(P9_DEBUG_ERROR, "cannot attach\n"); 455 goto err_clnt; 456 } 457 458 if ((v9ses->flags & V9FS_ACCESS_MASK) == V9FS_ACCESS_SINGLE) 459 fid->uid = v9ses->uid; 460 else 461 fid->uid = INVALID_UID; 462 463 #ifdef CONFIG_9P_FSCACHE 464 /* register the session for caching */ 465 v9fs_cache_session_get_cookie(v9ses); 466 #endif 467 spin_lock(&v9fs_sessionlist_lock); 468 list_add(&v9ses->slist, &v9fs_sessionlist); 469 spin_unlock(&v9fs_sessionlist_lock); 470 471 return fid; 472 473 err_clnt: 474 p9_client_destroy(v9ses->clnt); 475 err_names: 476 kfree(v9ses->uname); 477 kfree(v9ses->aname); 478 return ERR_PTR(rc); 479 } 480 481 /** 482 * v9fs_session_close - shutdown a session 483 * @v9ses: session information structure 484 * 485 */ 486 487 void v9fs_session_close(struct v9fs_session_info *v9ses) 488 { 489 if (v9ses->clnt) { 490 p9_client_destroy(v9ses->clnt); 491 v9ses->clnt = NULL; 492 } 493 494 #ifdef CONFIG_9P_FSCACHE 495 if (v9ses->fscache) { 496 v9fs_cache_session_put_cookie(v9ses); 497 kfree(v9ses->cachetag); 498 } 499 #endif 500 kfree(v9ses->uname); 501 kfree(v9ses->aname); 502 503 spin_lock(&v9fs_sessionlist_lock); 504 list_del(&v9ses->slist); 505 spin_unlock(&v9fs_sessionlist_lock); 506 } 507 508 /** 509 * v9fs_session_cancel - terminate a session 510 * @v9ses: session to terminate 511 * 512 * mark transport as disconnected and cancel all pending requests. 513 */ 514 515 void v9fs_session_cancel(struct v9fs_session_info *v9ses) { 516 p9_debug(P9_DEBUG_ERROR, "cancel session %p\n", v9ses); 517 p9_client_disconnect(v9ses->clnt); 518 } 519 520 /** 521 * v9fs_session_begin_cancel - Begin terminate of a session 522 * @v9ses: session to terminate 523 * 524 * After this call we don't allow any request other than clunk. 525 */ 526 527 void v9fs_session_begin_cancel(struct v9fs_session_info *v9ses) 528 { 529 p9_debug(P9_DEBUG_ERROR, "begin cancel session %p\n", v9ses); 530 p9_client_begin_disconnect(v9ses->clnt); 531 } 532 533 extern int v9fs_error_init(void); 534 535 static struct kobject *v9fs_kobj; 536 537 #ifdef CONFIG_9P_FSCACHE 538 /** 539 * caches_show - list caches associated with a session 540 * 541 * Returns the size of buffer written. 542 */ 543 544 static ssize_t caches_show(struct kobject *kobj, 545 struct kobj_attribute *attr, 546 char *buf) 547 { 548 ssize_t n = 0, count = 0, limit = PAGE_SIZE; 549 struct v9fs_session_info *v9ses; 550 551 spin_lock(&v9fs_sessionlist_lock); 552 list_for_each_entry(v9ses, &v9fs_sessionlist, slist) { 553 if (v9ses->cachetag) { 554 n = snprintf(buf, limit, "%s\n", v9ses->cachetag); 555 if (n < 0) { 556 count = n; 557 break; 558 } 559 560 count += n; 561 limit -= n; 562 } 563 } 564 565 spin_unlock(&v9fs_sessionlist_lock); 566 return count; 567 } 568 569 static struct kobj_attribute v9fs_attr_cache = __ATTR_RO(caches); 570 #endif /* CONFIG_9P_FSCACHE */ 571 572 static struct attribute *v9fs_attrs[] = { 573 #ifdef CONFIG_9P_FSCACHE 574 &v9fs_attr_cache.attr, 575 #endif 576 NULL, 577 }; 578 579 static struct attribute_group v9fs_attr_group = { 580 .attrs = v9fs_attrs, 581 }; 582 583 /** 584 * v9fs_sysfs_init - Initialize the v9fs sysfs interface 585 * 586 */ 587 588 static int __init v9fs_sysfs_init(void) 589 { 590 v9fs_kobj = kobject_create_and_add("9p", fs_kobj); 591 if (!v9fs_kobj) 592 return -ENOMEM; 593 594 if (sysfs_create_group(v9fs_kobj, &v9fs_attr_group)) { 595 kobject_put(v9fs_kobj); 596 return -ENOMEM; 597 } 598 599 return 0; 600 } 601 602 /** 603 * v9fs_sysfs_cleanup - Unregister the v9fs sysfs interface 604 * 605 */ 606 607 static void v9fs_sysfs_cleanup(void) 608 { 609 sysfs_remove_group(v9fs_kobj, &v9fs_attr_group); 610 kobject_put(v9fs_kobj); 611 } 612 613 static void v9fs_inode_init_once(void *foo) 614 { 615 struct v9fs_inode *v9inode = (struct v9fs_inode *)foo; 616 #ifdef CONFIG_9P_FSCACHE 617 v9inode->fscache = NULL; 618 #endif 619 memset(&v9inode->qid, 0, sizeof(v9inode->qid)); 620 inode_init_once(&v9inode->vfs_inode); 621 } 622 623 /** 624 * v9fs_init_inode_cache - initialize a cache for 9P 625 * Returns 0 on success. 626 */ 627 static int v9fs_init_inode_cache(void) 628 { 629 v9fs_inode_cache = kmem_cache_create("v9fs_inode_cache", 630 sizeof(struct v9fs_inode), 631 0, (SLAB_RECLAIM_ACCOUNT| 632 SLAB_MEM_SPREAD|SLAB_ACCOUNT), 633 v9fs_inode_init_once); 634 if (!v9fs_inode_cache) 635 return -ENOMEM; 636 637 return 0; 638 } 639 640 /** 641 * v9fs_destroy_inode_cache - destroy the cache of 9P inode 642 * 643 */ 644 static void v9fs_destroy_inode_cache(void) 645 { 646 /* 647 * Make sure all delayed rcu free inodes are flushed before we 648 * destroy cache. 649 */ 650 rcu_barrier(); 651 kmem_cache_destroy(v9fs_inode_cache); 652 } 653 654 static int v9fs_cache_register(void) 655 { 656 int ret; 657 ret = v9fs_init_inode_cache(); 658 if (ret < 0) 659 return ret; 660 #ifdef CONFIG_9P_FSCACHE 661 ret = fscache_register_netfs(&v9fs_cache_netfs); 662 if (ret < 0) 663 v9fs_destroy_inode_cache(); 664 #endif 665 return ret; 666 } 667 668 static void v9fs_cache_unregister(void) 669 { 670 v9fs_destroy_inode_cache(); 671 #ifdef CONFIG_9P_FSCACHE 672 fscache_unregister_netfs(&v9fs_cache_netfs); 673 #endif 674 } 675 676 /** 677 * init_v9fs - Initialize module 678 * 679 */ 680 681 static int __init init_v9fs(void) 682 { 683 int err; 684 pr_info("Installing v9fs 9p2000 file system support\n"); 685 /* TODO: Setup list of registered trasnport modules */ 686 687 err = v9fs_cache_register(); 688 if (err < 0) { 689 pr_err("Failed to register v9fs for caching\n"); 690 return err; 691 } 692 693 err = v9fs_sysfs_init(); 694 if (err < 0) { 695 pr_err("Failed to register with sysfs\n"); 696 goto out_cache; 697 } 698 err = register_filesystem(&v9fs_fs_type); 699 if (err < 0) { 700 pr_err("Failed to register filesystem\n"); 701 goto out_sysfs_cleanup; 702 } 703 704 return 0; 705 706 out_sysfs_cleanup: 707 v9fs_sysfs_cleanup(); 708 709 out_cache: 710 v9fs_cache_unregister(); 711 712 return err; 713 } 714 715 /** 716 * exit_v9fs - shutdown module 717 * 718 */ 719 720 static void __exit exit_v9fs(void) 721 { 722 v9fs_sysfs_cleanup(); 723 v9fs_cache_unregister(); 724 unregister_filesystem(&v9fs_fs_type); 725 } 726 727 module_init(init_v9fs) 728 module_exit(exit_v9fs) 729 730 MODULE_AUTHOR("Latchesar Ionkov <lucho@ionkov.net>"); 731 MODULE_AUTHOR("Eric Van Hensbergen <ericvh@gmail.com>"); 732 MODULE_AUTHOR("Ron Minnich <rminnich@lanl.gov>"); 733 MODULE_LICENSE("GPL"); 734