Index: head/sys/fs/pseudofs/pseudofs.c =================================================================== --- head/sys/fs/pseudofs/pseudofs.c (revision 168386) +++ head/sys/fs/pseudofs/pseudofs.c (revision 168387) @@ -1,430 +1,430 @@ /*- * Copyright (c) 2001 Dag-Erling Coïdan Smørgrav * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer * in this position and unchanged. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include "opt_pseudofs.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include static MALLOC_DEFINE(M_PFSNODES, "pfs_nodes", "pseudofs nodes"); SYSCTL_NODE(_vfs, OID_AUTO, pfs, CTLFLAG_RW, 0, "pseudofs"); #if PFS_FSNAMELEN != MFSNAMELEN #error "PFS_FSNAMELEN is not equal to MFSNAMELEN" #endif /* * Add a node to a directory */ static int _pfs_add_node(struct pfs_node *parent, struct pfs_node *node) { KASSERT(parent != NULL, ("%s(): parent is NULL", __func__)); KASSERT(parent->pn_info != NULL, ("%s(): parent has no pn_info", __func__)); KASSERT(parent->pn_type == pfstype_dir || parent->pn_type == pfstype_procdir || parent->pn_type == pfstype_root, ("%s(): parent is not a directory", __func__)); /* XXX should check for duplicate names etc. */ mtx_lock(&parent->pn_info->pi_mutex); node->pn_info = parent->pn_info; node->pn_parent = parent; node->pn_next = parent->pn_nodes; parent->pn_nodes = node; /* Propagate flag to all child nodes (and thus their vnodes) */ if ((parent->pn_flags & PFS_PROCDEP) != 0) node->pn_flags |= PFS_PROCDEP; mtx_unlock(&parent->pn_info->pi_mutex); return (0); } /* * Add . and .. to a directory */ static int _pfs_fixup_dir(struct pfs_node *parent) { struct pfs_node *dir; MALLOC(dir, struct pfs_node *, sizeof *dir, M_PFSNODES, M_WAITOK|M_ZERO); dir->pn_name[0] = '.'; dir->pn_type = pfstype_this; if (_pfs_add_node(parent, dir) != 0) { FREE(dir, M_PFSNODES); return (-1); } MALLOC(dir, struct pfs_node *, sizeof *dir, M_PFSNODES, M_WAITOK|M_ZERO); dir->pn_name[0] = dir->pn_name[1] = '.'; dir->pn_type = pfstype_parent; if (_pfs_add_node(parent, dir) != 0) { FREE(dir, M_PFSNODES); return (-1); } return (0); } /* * Create a directory */ struct pfs_node * pfs_create_dir(struct pfs_node *parent, const char *name, pfs_attr_t attr, pfs_vis_t vis, pfs_destroy_t destroy, int flags) { struct pfs_node *dir; KASSERT(strlen(name) < PFS_NAMELEN, ("%s(): node name is too long", __func__)); MALLOC(dir, struct pfs_node *, sizeof *dir, M_PFSNODES, M_WAITOK|M_ZERO); strcpy(dir->pn_name, name); dir->pn_type = (flags & PFS_PROCDEP) ? pfstype_procdir : pfstype_dir; dir->pn_attr = attr; dir->pn_vis = vis; dir->pn_destroy = destroy; dir->pn_flags = flags; if (_pfs_add_node(parent, dir) != 0) { FREE(dir, M_PFSNODES); return (NULL); } if (_pfs_fixup_dir(dir) != 0) { pfs_destroy(dir); return (NULL); } return (dir); } /* * Create a file */ struct pfs_node * pfs_create_file(struct pfs_node *parent, const char *name, pfs_fill_t fill, pfs_attr_t attr, pfs_vis_t vis, pfs_destroy_t destroy, int flags) { struct pfs_node *node; KASSERT(strlen(name) < PFS_NAMELEN, ("%s(): node name is too long", __func__)); MALLOC(node, struct pfs_node *, sizeof *node, M_PFSNODES, M_WAITOK|M_ZERO); strcpy(node->pn_name, name); node->pn_type = pfstype_file; node->pn_func = fill; node->pn_attr = attr; node->pn_vis = vis; node->pn_destroy = destroy; node->pn_flags = flags; if (_pfs_add_node(parent, node) != 0) { FREE(node, M_PFSNODES); return (NULL); } return (node); } /* * Create a symlink */ struct pfs_node * pfs_create_link(struct pfs_node *parent, const char *name, pfs_fill_t fill, - pfs_attr_t attr, pfs_vis_t vis, pfs_destroy_t destroy, + pfs_attr_t attr, pfs_vis_t vis, pfs_destroy_t destroy, int flags) { struct pfs_node *node; node = pfs_create_file(parent, name, fill, attr, vis, destroy, flags); if (node == NULL) return (NULL); node->pn_type = pfstype_symlink; return (node); } /* * Locate a node by name */ struct pfs_node * pfs_find_node(struct pfs_node *parent, const char *name) { struct pfs_node *node; for (node = parent->pn_nodes; node != NULL; node = node->pn_next) if (strcmp(node->pn_name, name) == 0) return (node); return (NULL); } /* * Destroy a node or a tree of nodes */ int pfs_destroy(struct pfs_node *node) { struct pfs_node *parent, *rover; KASSERT(node != NULL, ("%s(): node is NULL", __func__)); KASSERT(node->pn_info != NULL, ("%s(): node has no pn_info", __func__)); /* destroy children */ if (node->pn_type == pfstype_dir || node->pn_type == pfstype_procdir || node->pn_type == pfstype_root) while (node->pn_nodes != NULL) pfs_destroy(node->pn_nodes); /* unlink from parent */ if ((parent = node->pn_parent) != NULL) { KASSERT(parent->pn_info == node->pn_info, ("%s(): parent has different pn_info", __func__)); mtx_lock(&node->pn_info->pi_mutex); if (parent->pn_nodes == node) { parent->pn_nodes = node->pn_next; } else { rover = parent->pn_nodes; while (rover->pn_next != NULL) { if (rover->pn_next == node) { rover->pn_next = node->pn_next; break; } rover = rover->pn_next; } } mtx_unlock(&node->pn_info->pi_mutex); } /* callback to free any private resources */ - if(node->pn_destroy != NULL) + if (node->pn_destroy != NULL) (node->pn_destroy)(node); - + /* revoke vnodes and release memory */ pfs_disable(node); FREE(node, M_PFSNODES); return (0); } /* * Mount a pseudofs instance */ int pfs_mount(struct pfs_info *pi, struct mount *mp, struct thread *td) { struct statfs *sbp; if (mp->mnt_flag & MNT_UPDATE) return (EOPNOTSUPP); mp->mnt_flag |= MNT_LOCAL; mp->mnt_data = (qaddr_t)pi; vfs_getnewfsid(mp); sbp = &mp->mnt_stat; vfs_mountedfrom(mp, pi->pi_name); sbp->f_bsize = PAGE_SIZE; sbp->f_iosize = PAGE_SIZE; sbp->f_blocks = 1; sbp->f_bfree = 0; sbp->f_bavail = 0; sbp->f_files = 1; sbp->f_ffree = 0; return (0); } /* * Compatibility shim for old mount(2) system call. */ int pfs_cmount(struct mntarg *ma, void *data, int flags, struct thread *td) { return kernel_mount(ma, flags); } /* * Unmount a pseudofs instance */ int pfs_unmount(struct mount *mp, int mntflags, struct thread *td) { struct pfs_info *pi; int error; pi = (struct pfs_info *)mp->mnt_data; /* XXX do stuff with pi... */ error = vflush(mp, 0, (mntflags & MNT_FORCE) ? FORCECLOSE : 0, td); return (error); } /* * Return a root vnode */ int pfs_root(struct mount *mp, int flags, struct vnode **vpp, struct thread *td) { struct pfs_info *pi; pi = (struct pfs_info *)mp->mnt_data; return pfs_vncache_alloc(mp, vpp, pi->pi_root, NO_PID); } /* * Return filesystem stats */ int pfs_statfs(struct mount *mp, struct statfs *sbp, struct thread *td) { /* no-op: always called with mp->mnt_stat */ return (0); } /* * Initialize a pseudofs instance */ int pfs_init(struct pfs_info *pi, struct vfsconf *vfc) { struct pfs_node *root; int error; mtx_init(&pi->pi_mutex, "pseudofs", NULL, MTX_DEF); /* set up the root diretory */ MALLOC(root, struct pfs_node *, sizeof *root, M_PFSNODES, M_WAITOK|M_ZERO); root->pn_type = pfstype_root; root->pn_name[0] = '/'; root->pn_info = pi; if (_pfs_fixup_dir(root) != 0) { FREE(root, M_PFSNODES); return (ENODEV); /* XXX not really the right errno */ } pi->pi_root = root; /* construct file hierarchy */ error = (pi->pi_init)(pi, vfc); if (error) { pfs_destroy(root); pi->pi_root = NULL; mtx_destroy(&pi->pi_mutex); return (error); } pfs_fileno_init(pi); if (bootverbose) printf("%s registered\n", pi->pi_name); return (0); } /* * Destroy a pseudofs instance */ int pfs_uninit(struct pfs_info *pi, struct vfsconf *vfc) { int error; pfs_fileno_uninit(pi); pfs_destroy(pi->pi_root); pi->pi_root = NULL; mtx_destroy(&pi->pi_mutex); if (bootverbose) printf("%s unregistered\n", pi->pi_name); error = (pi->pi_uninit)(pi, vfc); return (error); } /* * Handle load / unload events */ static int pfs_modevent(module_t mod, int evt, void *arg) { switch (evt) { case MOD_LOAD: pfs_vncache_load(); break; case MOD_UNLOAD: case MOD_SHUTDOWN: pfs_vncache_unload(); break; default: return EOPNOTSUPP; break; } return 0; } /* * Module declaration */ static moduledata_t pseudofs_data = { "pseudofs", pfs_modevent, NULL }; DECLARE_MODULE(pseudofs, pseudofs_data, SI_SUB_EXEC, SI_ORDER_FIRST); MODULE_VERSION(pseudofs, 1); Index: head/sys/fs/pseudofs/pseudofs.h =================================================================== --- head/sys/fs/pseudofs/pseudofs.h (revision 168386) +++ head/sys/fs/pseudofs/pseudofs.h (revision 168387) @@ -1,282 +1,282 @@ /*- * Copyright (c) 2001 Dag-Erling Coïdan Smørgrav * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer * in this position and unchanged. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * $FreeBSD$ */ #ifndef _PSEUDOFS_H_INCLUDED #define _PSEUDOFS_H_INCLUDED /* * Opaque structures */ struct mntarg; struct mount; struct nameidata; struct proc; struct sbuf; struct statfs; struct thread; struct uio; struct vfsconf; struct vnode; /* * Limits and constants */ #define PFS_NAMELEN 24 #define PFS_FSNAMELEN 16 /* equal to MFSNAMELEN */ #define PFS_DELEN (8 + PFS_NAMELEN) typedef enum { pfstype_none = 0, pfstype_root, pfstype_dir, pfstype_this, pfstype_parent, pfstype_file, pfstype_symlink, pfstype_procdir } pfs_type_t; /* * Flags */ #define PFS_RD 0x0001 /* readable */ #define PFS_WR 0x0002 /* writeable */ #define PFS_RDWR (PFS_RD|PFS_WR) #define PFS_RAWRD 0x0004 /* raw reader */ #define PFS_RAWWR 0x0008 /* raw writer */ #define PFS_RAW (PFS_RAWRD|PFS_RAWWR) #define PFS_PROCDEP 0x0010 /* process-dependent */ #define PFS_DISABLED 0x8000 /* node is disabled */ /* * Data structures */ struct pfs_info; struct pfs_node; struct pfs_bitmap; /* * Init / uninit callback */ #define PFS_INIT_ARGS \ struct pfs_info *pi, struct vfsconf *vfc #define PFS_INIT_PROTO(name) \ int name(PFS_INIT_ARGS); typedef int (*pfs_init_t)(PFS_INIT_ARGS); /* * Filler callback */ #define PFS_FILL_ARGS \ struct thread *td, struct proc *p, struct pfs_node *pn, \ struct sbuf *sb, struct uio *uio #define PFS_FILL_PROTO(name) \ int name(PFS_FILL_ARGS); typedef int (*pfs_fill_t)(PFS_FILL_ARGS); /* * Attribute callback */ struct vattr; #define PFS_ATTR_ARGS \ struct thread *td, struct proc *p, struct pfs_node *pn, \ struct vattr *vap #define PFS_ATTR_PROTO(name) \ int name(PFS_ATTR_ARGS); typedef int (*pfs_attr_t)(PFS_ATTR_ARGS); struct pfs_bitmap; /* opaque */ /* * Visibility callback */ #define PFS_VIS_ARGS \ struct thread *td, struct proc *p, struct pfs_node *pn #define PFS_VIS_PROTO(name) \ int name(PFS_VIS_ARGS); typedef int (*pfs_vis_t)(PFS_VIS_ARGS); /* * Ioctl callback */ #define PFS_IOCTL_ARGS \ struct thread *td, struct proc *p, struct pfs_node *pn, \ unsigned long cmd, void *data #define PFS_IOCTL_PROTO(name) \ int name(PFS_IOCTL_ARGS); typedef int (*pfs_ioctl_t)(PFS_IOCTL_ARGS); /* * Getextattr callback */ #define PFS_GETEXTATTR_ARGS \ struct thread *td, struct proc *p, struct pfs_node *pn, \ int attrnamespace, const char *name, struct uio *uio, \ size_t *size, struct ucred *cred #define PFS_GETEXTATTR_PROTO(name) \ int name(PFS_GETEXTATTR_ARGS); struct ucred; typedef int (*pfs_getextattr_t)(PFS_GETEXTATTR_ARGS); /* * Last-close callback */ #define PFS_CLOSE_ARGS \ struct thread *td, struct proc *p, struct pfs_node *pn #define PFS_CLOSE_PROTO(name) \ int name(PFS_CLOSE_ARGS); typedef int (*pfs_close_t)(PFS_CLOSE_ARGS); /* * Destroy callback */ #define PFS_DESTROY_ARGS \ struct pfs_node *pn #define PFS_DESTROY_PROTO(name) \ int name(PFS_DESTROY_ARGS); typedef int (*pfs_destroy_t)(PFS_DESTROY_ARGS); /* * pfs_info: describes a pseudofs instance */ struct pfs_info { char pi_name[PFS_FSNAMELEN]; pfs_init_t pi_init; pfs_init_t pi_uninit; /* members below this line aren't initialized */ struct pfs_node *pi_root; /* currently, the mutex is only used to protect the bitmap */ struct mtx pi_mutex; struct unrhdr *pi_unrhdr; }; /* * pfs_node: describes a node (file or directory) within a pseudofs */ struct pfs_node { char pn_name[PFS_NAMELEN]; pfs_type_t pn_type; union { void *_pn_dummy; pfs_fill_t _pn_func; struct pfs_node *_pn_nodes; } u1; #define pn_func u1._pn_func #define pn_nodes u1._pn_nodes pfs_ioctl_t pn_ioctl; pfs_close_t pn_close; pfs_attr_t pn_attr; pfs_vis_t pn_vis; pfs_getextattr_t pn_getextattr; pfs_destroy_t pn_destroy; void *pn_data; int pn_flags; struct pfs_info *pn_info; struct pfs_node *pn_parent; struct pfs_node *pn_next; u_int32_t pn_fileno; }; /* * VFS interface */ int pfs_mount (struct pfs_info *pi, struct mount *mp, struct thread *td); int pfs_cmount (struct mntarg *ma, void *data, int flags, struct thread *td); int pfs_unmount (struct mount *mp, int mntflags, struct thread *td); int pfs_root (struct mount *mp, int flags, struct vnode **vpp, struct thread *td); int pfs_statfs (struct mount *mp, struct statfs *sbp, struct thread *td); int pfs_init (struct pfs_info *pi, struct vfsconf *vfc); int pfs_uninit (struct pfs_info *pi, struct vfsconf *vfc); /* * Directory structure construction and manipulation */ struct pfs_node *pfs_create_dir (struct pfs_node *parent, const char *name, - pfs_attr_t attr, pfs_vis_t vis, + pfs_attr_t attr, pfs_vis_t vis, pfs_destroy_t destroy, int flags); struct pfs_node *pfs_create_file(struct pfs_node *parent, const char *name, pfs_fill_t fill, pfs_attr_t attr, pfs_vis_t vis, pfs_destroy_t destroy, int flags); struct pfs_node *pfs_create_link(struct pfs_node *parent, const char *name, pfs_fill_t fill, pfs_attr_t attr, pfs_vis_t vis, pfs_destroy_t destroy, int flags); struct pfs_node *pfs_find_node (struct pfs_node *parent, const char *name); int pfs_disable (struct pfs_node *pn); int pfs_enable (struct pfs_node *pn); int pfs_destroy (struct pfs_node *pn); /* * Now for some initialization magic... */ #define PSEUDOFS(name, version) \ \ static struct pfs_info name##_info = { \ #name, \ name##_init, \ name##_uninit, \ }; \ \ static int \ _##name##_mount(struct mount *mp, struct thread *td) { \ return pfs_mount(&name##_info, mp, td); \ } \ \ static int \ _##name##_init(struct vfsconf *vfc) { \ return pfs_init(&name##_info, vfc); \ } \ \ static int \ _##name##_uninit(struct vfsconf *vfc) { \ return pfs_uninit(&name##_info, vfc); \ } \ \ static struct vfsops name##_vfsops = { \ .vfs_cmount = pfs_cmount, \ .vfs_init = _##name##_init, \ .vfs_mount = _##name##_mount, \ .vfs_root = pfs_root, \ .vfs_statfs = pfs_statfs, \ .vfs_uninit = _##name##_uninit, \ .vfs_unmount = pfs_unmount, \ }; \ VFS_SET(name##_vfsops, name, VFCF_SYNTHETIC); \ MODULE_VERSION(name, version); \ MODULE_DEPEND(name, pseudofs, 1, 1, 1); #endif