v9fs.c 16 KB

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