pseudofs.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*-
    2  * Copyright (c) 2001 Dag-Erling Coïdan Smørgrav
    3  * All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer
   10  *    in this position and unchanged.
   11  * 2. Redistributions in binary form must reproduce the above copyright
   12  *    notice, this list of conditions and the following disclaimer in the
   13  *    documentation and/or other materials provided with the distribution.
   14  * 3. The name of the author may not be used to endorse or promote products
   15  *    derived from this software without specific prior written permission.
   16  *
   17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   27  */
   28 
   29 #include <sys/cdefs.h>
   30 __FBSDID("$FreeBSD: releng/6.1/sys/fs/pseudofs/pseudofs.c 144058 2005-03-24 07:36:16Z jeff $");
   31 
   32 #include "opt_pseudofs.h"
   33 
   34 #include <sys/param.h>
   35 #include <sys/kernel.h>
   36 #include <sys/systm.h>
   37 #include <sys/lock.h>
   38 #include <sys/malloc.h>
   39 #include <sys/module.h>
   40 #include <sys/mount.h>
   41 #include <sys/mutex.h>
   42 #include <sys/proc.h>
   43 #include <sys/sbuf.h>
   44 #include <sys/sysctl.h>
   45 #include <sys/vnode.h>
   46 
   47 #include <fs/pseudofs/pseudofs.h>
   48 #include <fs/pseudofs/pseudofs_internal.h>
   49 
   50 static MALLOC_DEFINE(M_PFSNODES, "pfs_nodes", "pseudofs nodes");
   51 
   52 SYSCTL_NODE(_vfs, OID_AUTO, pfs, CTLFLAG_RW, 0,
   53     "pseudofs");
   54 
   55 #if PFS_FSNAMELEN != MFSNAMELEN
   56 #error "PFS_FSNAMELEN is not equal to MFSNAMELEN"
   57 #endif
   58 
   59 /*
   60  * Add a node to a directory
   61  */
   62 static int
   63 _pfs_add_node(struct pfs_node *parent, struct pfs_node *node)
   64 {
   65         KASSERT(parent != NULL,
   66             ("%s(): parent is NULL", __func__));
   67         KASSERT(parent->pn_info != NULL,
   68             ("%s(): parent has no pn_info", __func__));
   69         KASSERT(parent->pn_type == pfstype_dir ||
   70             parent->pn_type == pfstype_procdir ||
   71             parent->pn_type == pfstype_root,
   72             ("%s(): parent is not a directory", __func__));
   73 
   74         /* XXX should check for duplicate names etc. */
   75 
   76         mtx_lock(&parent->pn_info->pi_mutex);
   77         node->pn_info = parent->pn_info;
   78         node->pn_parent = parent;
   79         node->pn_next = parent->pn_nodes;
   80         parent->pn_nodes = node;
   81         /* Propagate flag to all child nodes (and thus their vnodes) */
   82         if ((parent->pn_flags & PFS_PROCDEP) != 0)
   83                 node->pn_flags |= PFS_PROCDEP;
   84         mtx_unlock(&parent->pn_info->pi_mutex);
   85 
   86         return (0);
   87 }
   88 
   89 /*
   90  * Add . and .. to a directory
   91  */
   92 static int
   93 _pfs_fixup_dir(struct pfs_node *parent)
   94 {
   95         struct pfs_node *dir;
   96 
   97         MALLOC(dir, struct pfs_node *, sizeof *dir,
   98             M_PFSNODES, M_WAITOK|M_ZERO);
   99         dir->pn_name[0] = '.';
  100         dir->pn_type = pfstype_this;
  101 
  102         if (_pfs_add_node(parent, dir) != 0) {
  103                 FREE(dir, M_PFSNODES);
  104                 return (-1);
  105         }
  106 
  107         MALLOC(dir, struct pfs_node *, sizeof *dir,
  108             M_PFSNODES, M_WAITOK|M_ZERO);
  109         dir->pn_name[0] = dir->pn_name[1] = '.';
  110         dir->pn_type = pfstype_parent;
  111 
  112         if (_pfs_add_node(parent, dir) != 0) {
  113                 FREE(dir, M_PFSNODES);
  114                 return (-1);
  115         }
  116 
  117         return (0);
  118 }
  119 
  120 /*
  121  * Create a directory
  122  */
  123 struct pfs_node *
  124 pfs_create_dir(struct pfs_node *parent, const char *name,
  125                pfs_attr_t attr, pfs_vis_t vis, int flags)
  126 {
  127         struct pfs_node *dir;
  128 
  129         KASSERT(strlen(name) < PFS_NAMELEN,
  130             ("%s(): node name is too long", __func__));
  131 
  132         MALLOC(dir, struct pfs_node *, sizeof *dir,
  133             M_PFSNODES, M_WAITOK|M_ZERO);
  134         strcpy(dir->pn_name, name);
  135         dir->pn_type = (flags & PFS_PROCDEP) ? pfstype_procdir : pfstype_dir;
  136         dir->pn_attr = attr;
  137         dir->pn_vis = vis;
  138         dir->pn_flags = flags;
  139 
  140         if (_pfs_add_node(parent, dir) != 0) {
  141                 FREE(dir, M_PFSNODES);
  142                 return (NULL);
  143         }
  144 
  145         if (_pfs_fixup_dir(dir) != 0) {
  146                 pfs_destroy(dir);
  147                 return (NULL);
  148         }
  149 
  150         return (dir);
  151 }
  152 
  153 /*
  154  * Create a file
  155  */
  156 struct pfs_node *
  157 pfs_create_file(struct pfs_node *parent, const char *name, pfs_fill_t fill,
  158                 pfs_attr_t attr, pfs_vis_t vis, int flags)
  159 {
  160         struct pfs_node *node;
  161 
  162         KASSERT(strlen(name) < PFS_NAMELEN,
  163             ("%s(): node name is too long", __func__));
  164 
  165         MALLOC(node, struct pfs_node *, sizeof *node,
  166             M_PFSNODES, M_WAITOK|M_ZERO);
  167         strcpy(node->pn_name, name);
  168         node->pn_type = pfstype_file;
  169         node->pn_func = fill;
  170         node->pn_attr = attr;
  171         node->pn_vis = vis;
  172         node->pn_flags = flags;
  173 
  174         if (_pfs_add_node(parent, node) != 0) {
  175                 FREE(node, M_PFSNODES);
  176                 return (NULL);
  177         }
  178 
  179         return (node);
  180 }
  181 
  182 /*
  183  * Create a symlink
  184  */
  185 struct pfs_node *
  186 pfs_create_link(struct pfs_node *parent, const char *name, pfs_fill_t fill,
  187                 pfs_attr_t attr, pfs_vis_t vis, int flags)
  188 {
  189         struct pfs_node *node;
  190 
  191         node = pfs_create_file(parent, name, fill, attr, vis, flags);
  192         if (node == NULL)
  193                 return (NULL);
  194         node->pn_type = pfstype_symlink;
  195         return (node);
  196 }
  197 
  198 /*
  199  * Locate a node by name
  200  */
  201 struct pfs_node *
  202 pfs_find_node(struct pfs_node *parent, const char *name)
  203 {
  204         struct pfs_node *node;
  205 
  206         for (node = parent->pn_nodes; node != NULL; node = node->pn_next)
  207                 if (strcmp(node->pn_name, name) == 0)
  208                         return (node);
  209         return (NULL);
  210 }
  211 
  212 /*
  213  * Destroy a node or a tree of nodes
  214  */
  215 int
  216 pfs_destroy(struct pfs_node *node)
  217 {
  218         struct pfs_node *parent, *rover;
  219 
  220         KASSERT(node != NULL,
  221             ("%s(): node is NULL", __func__));
  222         KASSERT(node->pn_info != NULL,
  223             ("%s(): node has no pn_info", __func__));
  224 
  225         /* destroy children */
  226         if (node->pn_type == pfstype_dir ||
  227             node->pn_type == pfstype_procdir ||
  228             node->pn_type == pfstype_root)
  229                 while (node->pn_nodes != NULL)
  230                         pfs_destroy(node->pn_nodes);
  231 
  232         /* unlink from parent */
  233         if ((parent = node->pn_parent) != NULL) {
  234                 KASSERT(parent->pn_info == node->pn_info,
  235                     ("%s(): parent has different pn_info", __func__));
  236                 mtx_lock(&node->pn_info->pi_mutex);
  237                 if (parent->pn_nodes == node) {
  238                         parent->pn_nodes = node->pn_next;
  239                 } else {
  240                         rover = parent->pn_nodes;
  241                         while (rover->pn_next != NULL) {
  242                                 if (rover->pn_next == node) {
  243                                         rover->pn_next = node->pn_next;
  244                                         break;
  245                                 }
  246                                 rover = rover->pn_next;
  247                         }
  248                 }
  249                 mtx_unlock(&node->pn_info->pi_mutex);
  250         }
  251 
  252         /* revoke vnodes and release memory */
  253         pfs_disable(node);
  254         FREE(node, M_PFSNODES);
  255 
  256         return (0);
  257 }
  258 
  259 /*
  260  * Mount a pseudofs instance
  261  */
  262 int
  263 pfs_mount(struct pfs_info *pi, struct mount *mp, struct thread *td)
  264 {
  265         struct statfs *sbp;
  266 
  267         if (mp->mnt_flag & MNT_UPDATE)
  268                 return (EOPNOTSUPP);
  269 
  270         mp->mnt_flag |= MNT_LOCAL;
  271         mp->mnt_data = (qaddr_t)pi;
  272         vfs_getnewfsid(mp);
  273 
  274         sbp = &mp->mnt_stat;
  275         vfs_mountedfrom(mp, pi->pi_name);
  276         sbp->f_bsize = PAGE_SIZE;
  277         sbp->f_iosize = PAGE_SIZE;
  278         sbp->f_blocks = 1;
  279         sbp->f_bfree = 0;
  280         sbp->f_bavail = 0;
  281         sbp->f_files = 1;
  282         sbp->f_ffree = 0;
  283 
  284         return (0);
  285 }
  286 
  287 /*
  288  * Unmount a pseudofs instance
  289  */
  290 int
  291 pfs_unmount(struct mount *mp, int mntflags, struct thread *td)
  292 {
  293         struct pfs_info *pi;
  294         int error;
  295 
  296         pi = (struct pfs_info *)mp->mnt_data;
  297 
  298         /* XXX do stuff with pi... */
  299 
  300         error = vflush(mp, 0, (mntflags & MNT_FORCE) ?  FORCECLOSE : 0, td);
  301         return (error);
  302 }
  303 
  304 /*
  305  * Return a root vnode
  306  */
  307 int
  308 pfs_root(struct mount *mp, int flags, struct vnode **vpp, struct thread *td)
  309 {
  310         struct pfs_info *pi;
  311 
  312         pi = (struct pfs_info *)mp->mnt_data;
  313         return pfs_vncache_alloc(mp, vpp, pi->pi_root, NO_PID);
  314 }
  315 
  316 /*
  317  * Return filesystem stats
  318  */
  319 int
  320 pfs_statfs(struct mount *mp, struct statfs *sbp, struct thread *td)
  321 {
  322         /* no-op:  always called with mp->mnt_stat */
  323         return (0);
  324 }
  325 
  326 /*
  327  * Initialize a pseudofs instance
  328  */
  329 int
  330 pfs_init(struct pfs_info *pi, struct vfsconf *vfc)
  331 {
  332         struct pfs_node *root;
  333         int error;
  334 
  335         mtx_init(&pi->pi_mutex, "pseudofs", NULL, MTX_DEF);
  336 
  337         /* set up the root diretory */
  338         MALLOC(root, struct pfs_node *, sizeof *root,
  339             M_PFSNODES, M_WAITOK|M_ZERO);
  340         root->pn_type = pfstype_root;
  341         root->pn_name[0] = '/';
  342         root->pn_info = pi;
  343         if (_pfs_fixup_dir(root) != 0) {
  344                 FREE(root, M_PFSNODES);
  345                 return (ENODEV); /* XXX not really the right errno */
  346         }
  347         pi->pi_root = root;
  348 
  349         /* construct file hierarchy */
  350         error = (pi->pi_init)(pi, vfc);
  351         if (error) {
  352                 pfs_destroy(root);
  353                 pi->pi_root = NULL;
  354                 mtx_destroy(&pi->pi_mutex);
  355                 return (error);
  356         }
  357 
  358         pfs_fileno_init(pi);
  359         if (bootverbose)
  360                 printf("%s registered\n", pi->pi_name);
  361         return (0);
  362 }
  363 
  364 /*
  365  * Destroy a pseudofs instance
  366  */
  367 int
  368 pfs_uninit(struct pfs_info *pi, struct vfsconf *vfc)
  369 {
  370         int error;
  371 
  372         pfs_fileno_uninit(pi);
  373         pfs_destroy(pi->pi_root);
  374         pi->pi_root = NULL;
  375         mtx_destroy(&pi->pi_mutex);
  376         if (bootverbose)
  377                 printf("%s unregistered\n", pi->pi_name);
  378         error = (pi->pi_uninit)(pi, vfc);
  379         return (error);
  380 }
  381 
  382 /*
  383  * Handle load / unload events
  384  */
  385 static int
  386 pfs_modevent(module_t mod, int evt, void *arg)
  387 {
  388         switch (evt) {
  389         case MOD_LOAD:
  390                 pfs_vncache_load();
  391                 break;
  392         case MOD_UNLOAD:
  393         case MOD_SHUTDOWN:
  394                 pfs_vncache_unload();
  395                 break;
  396         default:
  397                 return EOPNOTSUPP;
  398                 break;
  399         }
  400         return 0;
  401 }
  402 
  403 /*
  404  * Module declaration
  405  */
  406 static moduledata_t pseudofs_data = {
  407         "pseudofs",
  408         pfs_modevent,
  409         NULL
  410 };
  411 DECLARE_MODULE(pseudofs, pseudofs_data, SI_SUB_EXEC, SI_ORDER_FIRST);
  412 MODULE_VERSION(pseudofs, 1);
Cache object: a547ec877e055dc1079b1fd367279a4c
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/fs/pseudofs/pseudofs.c

FreeBSD/Linux Kernel Cross Reference
sys/fs/pseudofs/pseudofs.c
