bsd/miscfs/fdesc/fdesc_vfsops.c

   1 /*
   2  * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23 /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
  24 /*
  25  * Copyright (c) 1992, 1993, 1995
  26  *      The Regents of the University of California.  All rights reserved.
  27  *
  28  * This code is derived from software donated to Berkeley by
  29  * Jan-Simon Pendry.
  30  *
  31  * Redistribution and use in source and binary forms, with or without
  32  * modification, are permitted provided that the following conditions
  33  * are met:
  34  * 1. Redistributions of source code must retain the above copyright
  35  *    notice, this list of conditions and the following disclaimer.
  36  * 2. Redistributions in binary form must reproduce the above copyright
  37  *    notice, this list of conditions and the following disclaimer in the
  38  *    documentation and/or other materials provided with the distribution.
  39  * 3. All advertising materials mentioning features or use of this software
  40  *    must display the following acknowledgement:
  41  *      This product includes software developed by the University of
  42  *      California, Berkeley and its contributors.
  43  * 4. Neither the name of the University nor the names of its contributors
  44  *    may be used to endorse or promote products derived from this software
  45  *    without specific prior written permission.
  46  *
  47  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  48  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  49  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  50  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  51  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  52  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  53  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  54  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  55  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  56  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  57  * SUCH DAMAGE.
  58  *
  59  *      @(#)fdesc_vfsops.c      8.10 (Berkeley) 5/14/95
  60  *
  61  */
  62
  63 /*
  64  * /dev/fd Filesystem
  65  */
  66
  67 #include <sys/param.h>
  68 #include <sys/systm.h>
  69 #include <sys/time.h>
  70 #include <sys/types.h>
  71 #include <sys/proc_internal.h>
  72 #include <sys/resourcevar.h>
  73 #include <sys/filedesc.h>
  74 #include <sys/vnode.h>
  75 #include <sys/mount_internal.h>
  76 #include <sys/namei.h>
  77 #include <sys/malloc.h>
  78 #include <miscfs/fdesc/fdesc.h>
  79
  80 /*
  81  * Mount the per-process file descriptors (/dev/fd)
  82  */
  83 int
  84 fdesc_mount(struct mount *mp, vnode_t devvp, __unused user_addr_t data, vfs_context_t context)
  85 {
  86         int error = 0;
  87         struct fdescmount *fmp;
  88         struct vnode *rvp;
  89
  90         /*
  91          * Update is a no-op
  92          */
  93         if (mp->mnt_flag & MNT_UPDATE)
  94                 return (ENOTSUP);
  95
  96         error = fdesc_allocvp(Froot, FD_ROOT, mp, &rvp, VDIR);
  97         if (error)
  98                 return (error);
  99
 100         MALLOC(fmp, struct fdescmount *, sizeof(struct fdescmount),
 101                                 M_UFSMNT, M_WAITOK);    /* XXX */
 102
 103         vnode_setnoflush(rvp);
 104         vnode_ref(rvp);
 105         vnode_put(rvp);
 106
 107         fmp->f_root = rvp;
 108         /* XXX -- don't mark as local to work around fts() problems */
 109         /*mp->mnt_flag |= MNT_LOCAL;*/
 110         mp->mnt_data = (qaddr_t) fmp;
 111         vfs_getnewfsid(mp);
 112
 113         bzero(mp->mnt_vfsstat.f_mntfromname, MAXPATHLEN);
 114         bcopy("fdesc", mp->mnt_vfsstat.f_mntfromname, sizeof("fdesc"));
 115         return (0);
 116 }
 117
 118 int
 119 fdesc_start(mp, flags, context)
 120         struct mount *mp;
 121         int flags;
 122         vfs_context_t context;
 123 {
 124         return (0);
 125 }
 126
 127 int
 128 fdesc_unmount(mp, mntflags, context)
 129         struct mount *mp;
 130         int mntflags;
 131         vfs_context_t context;
 132 {
 133         int error;
 134         int flags = 0;
 135         int force = 0;
 136         struct vnode *rvp = VFSTOFDESC(mp)->f_root;
 137
 138         if (mntflags & MNT_FORCE) {
 139                 flags |= FORCECLOSE;
 140                 force = 1;
 141         }
 142
 143         if ( vnode_isinuse(rvp, 1) && !force )
 144                 return (EBUSY);
 145         if ( (error = vflush(mp, rvp, flags|SKIPSYSTEM)) && !force )
 146                 return (error);
 147
 148         /*
 149          * And mark for recycle after we drop its reference; it away for future re-use
 150          */
 151         vnode_recycle(rvp);
 152         /*
 153          * Release reference on underlying root vnode
 154          */
 155         vnode_rele(rvp);
 156         /*
 157          * Finally, throw away the fdescmount structure
 158          */
 159         _FREE(mp->mnt_data, M_UFSMNT);  /* XXX */
 160         mp->mnt_data = 0;
 161
 162         return (0);
 163 }
 164
 165 int
 166 fdesc_root(mp, vpp, context)
 167         struct mount *mp;
 168         struct vnode **vpp;
 169         vfs_context_t context;
 170 {
 171         struct vnode *vp;
 172
 173         /*
 174          * Return locked reference to root.
 175          */
 176         vp = VFSTOFDESC(mp)->f_root;
 177         vnode_get(vp);
 178         *vpp = vp;
 179         return (0);
 180 }
 181
 182 int
 183 fdesc_statfs(mp, sbp, context)
 184         struct mount *mp;
 185         struct vfsstatfs *sbp;
 186         vfs_context_t context;
 187 {
 188         struct proc *p = vfs_context_proc(context);
 189         struct filedesc *fdp;
 190         int lim;
 191         int i;
 192         int last;
 193         int freefd;
 194
 195         /*
 196          * Compute number of free file descriptors.
 197          * [ Strange results will ensue if the open file
 198          * limit is ever reduced below the current number
 199          * of open files... ]
 200          */
 201         lim = p->p_rlimit[RLIMIT_NOFILE].rlim_cur;
 202         fdp = p->p_fd;
 203         last = min(fdp->fd_nfiles, lim);
 204         freefd = 0;
 205         for (i = fdp->fd_freefile; i < last; i++)
 206                 if (fdp->fd_ofiles[i] == NULL &&
 207                                 !(fdp->fd_ofileflags[i] & UF_RESERVED))
 208                         freefd++;
 209
 210         /*
 211          * Adjust for the fact that the fdesc array may not
 212          * have been fully allocated yet.
 213          */
 214         if (fdp->fd_nfiles < lim)
 215                 freefd += (lim - fdp->fd_nfiles);
 216
 217         sbp->f_flags = 0;
 218         sbp->f_bsize = DEV_BSIZE;
 219         sbp->f_iosize = DEV_BSIZE;
 220         sbp->f_blocks = (uint64_t)2;            /* 1K to keep df happy */
 221         sbp->f_bfree = 0;
 222         sbp->f_bavail = 0;
 223         sbp->f_files = (uint64_t)((unsigned long)(lim + 1));            /* Allow for "." */
 224         sbp->f_ffree = (uint64_t)((unsigned long)freefd);               /* See comments above */
 225
 226         return (0);
 227 }
 228
 229 static int
 230 fdesc_vfs_getattr(mount_t mp, struct vfs_attr *fsap, vfs_context_t context)
 231 {
 232         VFSATTR_RETURN(fsap, f_bsize, DEV_BSIZE);
 233         VFSATTR_RETURN(fsap, f_iosize, DEV_BSIZE);
 234         VFSATTR_RETURN(fsap, f_blocks, 2);
 235         VFSATTR_RETURN(fsap, f_bfree, 0);
 236         VFSATTR_RETURN(fsap, f_bavail, 0);
 237         VFSATTR_RETURN(fsap, f_fssubtype, 0);
 238
 239         if (VFSATTR_IS_ACTIVE(fsap, f_objcount) ||
 240             VFSATTR_IS_ACTIVE(fsap, f_maxobjcount) ||
 241             VFSATTR_IS_ACTIVE(fsap, f_files) ||
 242             VFSATTR_IS_ACTIVE(fsap, f_ffree))
 243         {
 244                 struct proc *p = vfs_context_proc(context);
 245                 struct filedesc *fdp;
 246                 int lim;
 247                 int i;
 248                 int last;
 249                 int freefd;
 250
 251                 /*
 252                  * Compute number of free file descriptors.
 253                  * [ Strange results will ensue if the open file
 254                  * limit is ever reduced below the current number
 255                  * of open files... ]
 256                  */
 257                 lim = p->p_rlimit[RLIMIT_NOFILE].rlim_cur;
 258                 fdp = p->p_fd;
 259                 last = min(fdp->fd_nfiles, lim);
 260                 freefd = 0;
 261                 for (i = fdp->fd_freefile; i < last; i++)
 262                         if (fdp->fd_ofiles[i] == NULL &&
 263                                         !(fdp->fd_ofileflags[i] & UF_RESERVED))
 264                                 freefd++;
 265
 266                 /*
 267                  * Adjust for the fact that the fdesc array may not
 268                  * have been fully allocated yet.
 269                  */
 270                 if (fdp->fd_nfiles < lim)
 271                         freefd += (lim - fdp->fd_nfiles);
 272
 273                 VFSATTR_RETURN(fsap, f_objcount, lim+1);
 274                 VFSATTR_RETURN(fsap, f_maxobjcount, lim+1);
 275                 VFSATTR_RETURN(fsap, f_files, lim+1);
 276                 VFSATTR_RETURN(fsap, f_ffree, freefd);
 277         }
 278
 279         return 0;
 280 }
 281
 282 int
 283 fdesc_sync(mp, waitfor, context)
 284         struct mount *mp;
 285         int waitfor;
 286         vfs_context_t context;
 287 {
 288
 289         return (0);
 290 }
 291
 292 #define fdesc_fhtovp (int (*) (mount_t, int, unsigned char *, vnode_t *, vfs_context_t))eopnotsupp
 293 #define fdesc_sysctl (int (*) (int *, u_int, user_addr_t, size_t *, user_addr_t, size_t, vfs_context_t))eopnotsupp
 294 #define fdesc_vget (int (*) (mount_t, ino64_t, vnode_t *, vfs_context_t))eopnotsupp
 295 #define fdesc_vptofh (int (*) (vnode_t, int *, unsigned char *, vfs_context_t))eopnotsupp
 296
 297 struct vfsops fdesc_vfsops = {
 298         fdesc_mount,
 299         fdesc_start,
 300         fdesc_unmount,
 301         fdesc_root,
 302         NULL,                   /* quotactl */
 303         fdesc_vfs_getattr,
 304         fdesc_sync,
 305         fdesc_vget,
 306         fdesc_fhtovp,
 307         fdesc_vptofh,
 308         fdesc_init,
 309         fdesc_sysctl
 310 };