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