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