~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/9p/v9fs.c

Version: ~ [ linux-5.15-rc1 ] ~ [ linux-5.14.5 ] ~ [ linux-5.13.18 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.66 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.147 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.206 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.246 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.282 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.283 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp