sys/vfs/devfs/devfs_vfsops.c

   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 <sys/lock.h>
  41 #include <vfs/devfs/devfs.h>
  42
  43 MALLOC_DECLARE(M_DEVFS);
  44
  45 extern struct vop_ops devfs_vnode_norm_vops;
  46 extern struct vop_ops devfs_vnode_dev_vops;
  47 extern struct lock      devfs_lock;
  48
  49 static int      devfs_mount (struct mount *mp, char *path, caddr_t data,
  50                                   struct ucred *cred);
  51 static int      devfs_statfs (struct mount *mp, struct statfs *sbp,
  52                                 struct ucred *cred);
  53 static int      devfs_unmount (struct mount *mp, int mntflags);
  54 int                     devfs_root(struct mount *mp, struct vnode **vpp);
  55 static int      devfs_vget(struct mount *mp, struct vnode *dvp,
  56                                 ino_t ino, struct vnode **vpp);
  57 static int      devfs_fhtovp(struct mount *mp, struct vnode *rootvp,
  58                                 struct fid *fhp, struct vnode **vpp);
  59 static int      devfs_vptofh(struct vnode *vp, struct fid *fhp);
  60
  61
  62 /*
  63  * VFS Operations.
  64  *
  65  * mount system call
  66  */
  67 /* ARGSUSED */
  68 static int
  69 devfs_mount(struct mount *mp, char *path, caddr_t data, struct ucred *cred)
  70 {
  71         struct devfs_mnt_data *mnt;
  72         size_t size;
  73
  74         devfs_debug(DEVFS_DEBUG_DEBUG, "(vfsops) devfs_mount() called!\n");
  75
  76         if (mp->mnt_flag & MNT_UPDATE)
  77                 return (EOPNOTSUPP);
  78
  79
  80         mp->mnt_flag |= MNT_LOCAL;
  81         mp->mnt_kern_flag |= MNTK_NOSTKMNT;
  82         mp->mnt_data = NULL;
  83         vfs_getnewfsid(mp);
  84
  85         size = sizeof("devfs") - 1;
  86         bcopy("devfs", mp->mnt_stat.f_mntfromname, size);
  87         bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
  88         devfs_statfs(mp, &mp->mnt_stat, cred);
  89
  90         /*
  91          * XXX: save other mount info passed from userland or so.
  92          */
  93         mnt = kmalloc(sizeof(*mnt), M_DEVFS, M_WAITOK | M_ZERO);
  94
  95         lockmgr(&devfs_lock, LK_EXCLUSIVE);
  96         mp->mnt_data = (qaddr_t)mnt;
  97         mnt->jailed = jailed(cred);
  98         mnt->leak_count = 0;
  99         mnt->mp = mp;
 100         TAILQ_INIT(&mnt->orphan_list);
 101         mnt->mntonnamelen = strlen(mp->mnt_stat.f_mntonname);
 102         mnt->root_node = devfs_allocp(Proot, "", NULL, mp, NULL);
 103         KKASSERT(mnt->root_node);
 104         lockmgr(&devfs_lock, LK_RELEASE);
 105
 106         vfs_add_vnodeops(mp, &devfs_vnode_norm_vops, &mp->mnt_vn_norm_ops);
 107         vfs_add_vnodeops(mp, &devfs_vnode_dev_vops, &mp->mnt_vn_spec_ops);
 108
 109         devfs_debug(DEVFS_DEBUG_DEBUG, "calling devfs_mount_add\n");
 110         devfs_mount_add(mnt);
 111
 112         return (0);
 113 }
 114
 115 /*
 116  * unmount system call
 117  */
 118 static int
 119 devfs_unmount(struct mount *mp, int mntflags)
 120 {
 121         int error = 0;
 122         int flags = 0;
 123
 124         devfs_debug(DEVFS_DEBUG_DEBUG, "(vfsops) devfs_unmount() called!\n");
 125
 126         if (mntflags & MNT_FORCE)
 127                 flags |= FORCECLOSE;
 128
 129         error = vflush(mp, 0, flags);
 130
 131         if (error)
 132                 return (error);
 133         devfs_tracer_orphan_count(mp, 1);
 134         devfs_mount_del(DEVFS_MNTDATA(mp));
 135         kfree(mp->mnt_data, M_DEVFS);
 136         mp->mnt_data = NULL;
 137
 138         return (0);
 139 }
 140
 141 /*
 142  * Sets *vpp to the root procfs vnode, referenced and exclusively locked
 143  */
 144 int
 145 devfs_root(struct mount *mp, struct vnode **vpp)
 146 {
 147         int ret;
 148         devfs_debug(DEVFS_DEBUG_DEBUG, "(vfsops) devfs_root() called!\n");
 149         lockmgr(&devfs_lock, LK_EXCLUSIVE);
 150         ret = devfs_allocv(vpp, DEVFS_MNTDATA(mp)->root_node);
 151         lockmgr(&devfs_lock, LK_RELEASE);
 152         return ret;
 153 }
 154
 155 /*
 156  * Get file system statistics.
 157  */
 158 static int
 159 devfs_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred)
 160 {
 161         devfs_debug(DEVFS_DEBUG_DEBUG, "(vfsops) devfs_stat() called!\n");
 162         sbp->f_bsize = DEV_BSIZE;
 163         sbp->f_iosize = DEV_BSIZE;
 164         sbp->f_blocks = 2;      /* avoid divide by zero in some df's */
 165         sbp->f_bfree = 0;
 166         sbp->f_bavail = 0;
 167         sbp->f_files = 0;
 168         sbp->f_ffree = 0;
 169
 170         if (sbp != &mp->mnt_stat) {
 171                 sbp->f_type = mp->mnt_vfc->vfc_typenum;
 172                 bcopy(&mp->mnt_stat.f_fsid, &sbp->f_fsid, sizeof(sbp->f_fsid));
 173                 bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN);
 174         }
 175
 176         return (0);
 177 }
 178
 179 static int
 180 devfs_fhtovp(struct mount *mp, struct vnode *rootvp,
 181            struct fid *fhp, struct vnode **vpp)
 182 {
 183         struct vnode            *vp;
 184         struct devfs_fid        *dfhp;
 185
 186         dfhp = (struct devfs_fid *)fhp;
 187
 188         if (dfhp->fid_gen != boottime.tv_sec)
 189                 return EINVAL;
 190
 191         vp = devfs_inode_to_vnode(mp, dfhp->fid_ino);
 192
 193         if (vp == NULL)
 194                 return ENOENT;
 195
 196         *vpp = vp;
 197         return 0;
 198 }
 199
 200 /*
 201  * Vnode pointer to File handle
 202  */
 203 /* ARGSUSED */
 204 static int
 205 devfs_vptofh(struct vnode *vp, struct fid *fhp)
 206 {
 207         struct devfs_node       *node;
 208         struct devfs_fid        *dfhp;
 209
 210         if ((node = DEVFS_NODE(vp)) != NULL) {
 211                 dfhp = (struct devfs_fid *)fhp;
 212                 dfhp->fid_len = sizeof(struct devfs_fid);
 213                 dfhp->fid_ino = node->d_dir.d_ino;
 214                 dfhp->fid_gen = boottime.tv_sec;
 215         } else {
 216                 return ENOENT;
 217         }
 218
 219         return (0);
 220 }
 221
 222 static int
 223 devfs_vget(struct mount *mp, struct vnode *dvp, ino_t ino, struct vnode **vpp)
 224 {
 225         struct vnode *vp;
 226         vp = devfs_inode_to_vnode(mp, ino);
 227
 228         if (vp == NULL)
 229                 return ENOENT;
 230
 231         *vpp = vp;
 232         return 0;
 233 }
 234
 235
 236 static struct vfsops devfs_vfsops = {
 237         .vfs_mount      =   devfs_mount,
 238         .vfs_unmount =  devfs_unmount,
 239         .vfs_root       =   devfs_root,
 240         .vfs_statfs =   devfs_statfs,
 241         .vfs_sync       =   vfs_stdsync,
 242         .vfs_vget       =       devfs_vget,
 243         .vfs_vptofh     =       devfs_vptofh,
 244         .vfs_fhtovp     =       devfs_fhtovp
 245 };
 246
 247 VFS_SET(devfs_vfsops, devfs, VFCF_SYNTHETIC);
 248 MODULE_VERSION(devfs, 1);