1 /* 2 * Copyright (c) 2009 The DragonFly Project. All rights reserved. 3 * 4 * This code is derived from software contributed to The DragonFly Project 5 * by Alex Hornung <ahornung@gmail.com> 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * 3. Neither the name of The DragonFly Project nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific, prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, 27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 */ 34 #include <sys/param.h> 35 #include <sys/systm.h> 36 #include <sys/kernel.h> 37 #include <sys/mount.h> 38 #include <sys/vnode.h> 39 #include <sys/jail.h> 40 #include <vfs/devfs/devfs.h> 41 42 MALLOC_DECLARE(M_DEVFS); 43 44 extern struct vop_ops devfs_vnode_norm_vops; 45 extern struct vop_ops devfs_vnode_dev_vops; 46 extern struct lock devfs_lock; 47 48 static int devfs_mount (struct mount *mp, char *path, caddr_t data, 49 struct ucred *cred); 50 static int devfs_statfs (struct mount *mp, struct statfs *sbp, 51 struct ucred *cred); 52 static int devfs_unmount (struct mount *mp, int mntflags); 53 int devfs_root(struct mount *mp, struct vnode **vpp); 54 55 /* 56 * VFS Operations. 57 * 58 * mount system call 59 */ 60 /* ARGSUSED */ 61 static int 62 devfs_mount(struct mount *mp, char *path, caddr_t data, struct ucred *cred) 63 { 64 size_t size; 65 66 devfs_debug(DEVFS_DEBUG_DEBUG, "(vfsops) devfs_mount() called!\n"); 67 68 if (mp->mnt_flag & MNT_UPDATE) 69 return (EOPNOTSUPP); 70 71 72 mp->mnt_flag |= MNT_LOCAL; 73 mp->mnt_kern_flag |= MNTK_NOSTKMNT; 74 mp->mnt_data = 0; 75 vfs_getnewfsid(mp); 76 77 size = sizeof("devfs") - 1; 78 bcopy("devfs", mp->mnt_stat.f_mntfromname, size); 79 bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size); 80 devfs_statfs(mp, &mp->mnt_stat, cred); 81 82 //XXX: save other mount info passed from userland or so. 83 mp->mnt_data = kmalloc(sizeof(struct devfs_mnt_data), M_DEVFS, M_WAITOK); 84 85 lockmgr(&devfs_lock, LK_EXCLUSIVE); 86 DEVFS_MNTDATA(mp)->jailed = jailed(cred); 87 DEVFS_MNTDATA(mp)->mntonnamelen = strlen(mp->mnt_stat.f_mntonname); 88 DEVFS_MNTDATA(mp)->leak_count = 0; 89 DEVFS_MNTDATA(mp)->root_node = devfs_allocp(Proot, "", NULL, mp, NULL); 90 KKASSERT(DEVFS_MNTDATA(mp)->root_node); 91 TAILQ_INIT(DEVFS_ORPHANLIST(mp)); 92 lockmgr(&devfs_lock, LK_RELEASE); 93 94 vfs_add_vnodeops(mp, &devfs_vnode_norm_vops, &mp->mnt_vn_norm_ops); 95 vfs_add_vnodeops(mp, &devfs_vnode_dev_vops, &mp->mnt_vn_spec_ops); 96 97 devfs_debug(DEVFS_DEBUG_DEBUG, "calling devfs_mount_add\n"); 98 devfs_mount_add(DEVFS_MNTDATA(mp)); 99 100 return (0); 101 } 102 103 /* 104 * unmount system call 105 */ 106 static int 107 devfs_unmount(struct mount *mp, int mntflags) 108 { 109 int error = 0; 110 int flags = 0; 111 112 devfs_debug(DEVFS_DEBUG_DEBUG, "(vfsops) devfs_unmount() called!\n"); 113 114 if (mntflags & MNT_FORCE) 115 flags |= FORCECLOSE; 116 117 error = vflush(mp, 0, flags); 118 119 if (error) 120 return (error); 121 122 devfs_debug(DEVFS_DEBUG_DEBUG, "There were %d devfs_node orphans left\n", devfs_tracer_orphan_count(mp, 1)); 123 devfs_debug(DEVFS_DEBUG_DEBUG, "There are %d devfs_node orphans left\n", devfs_tracer_orphan_count(mp, 0)); 124 devfs_mount_del(DEVFS_MNTDATA(mp)); 125 kfree(mp->mnt_data, M_DEVFS); 126 127 return (0); 128 } 129 130 /* 131 * Sets *vpp to the root procfs vnode, referenced and exclusively locked 132 */ 133 int 134 devfs_root(struct mount *mp, struct vnode **vpp) 135 { 136 int ret; 137 devfs_debug(DEVFS_DEBUG_DEBUG, "(vfsops) devfs_root() called!\n"); 138 lockmgr(&devfs_lock, LK_EXCLUSIVE); 139 ret = devfs_allocv(vpp, DEVFS_MNTDATA(mp)->root_node); 140 lockmgr(&devfs_lock, LK_RELEASE); 141 return ret; 142 } 143 144 /* 145 * Get file system statistics. 146 */ 147 static int 148 devfs_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred) 149 { 150 devfs_debug(DEVFS_DEBUG_DEBUG, "(vfsops) devfs_stat() called!\n"); 151 sbp->f_bsize = DEV_BSIZE; 152 sbp->f_iosize = DEV_BSIZE; 153 sbp->f_blocks = 2; /* avoid divide by zero in some df's */ 154 sbp->f_bfree = 0; 155 sbp->f_bavail = 0; 156 sbp->f_files = 0; 157 sbp->f_ffree = 0; 158 159 if (sbp != &mp->mnt_stat) { 160 sbp->f_type = mp->mnt_vfc->vfc_typenum; 161 bcopy(&mp->mnt_stat.f_fsid, &sbp->f_fsid, sizeof(sbp->f_fsid)); 162 bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN); 163 } 164 165 return (0); 166 } 167 168 static struct vfsops devfs_vfsops = { 169 .vfs_mount = devfs_mount, 170 .vfs_unmount = devfs_unmount, 171 .vfs_root = devfs_root, 172 .vfs_statfs = devfs_statfs, 173 .vfs_sync = vfs_stdsync 174 }; 175 176 VFS_SET(devfs_vfsops, devfs, VFCF_SYNTHETIC); 177 MODULE_VERSION(devfs, 1); 178