Return to vfs_syscalls.c CVS log

Up to [Net/2] / Net2 / kern

Annotation of Net2/kern/vfs_syscalls.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1989 The Regents of the University of California.
        !             3:  * All rights reserved.
        !             4:  *
        !             5:  * Redistribution and use in source and binary forms, with or without
        !             6:  * modification, are permitted provided that the following conditions
        !             7:  * are met:
        !             8:  * 1. Redistributions of source code must retain the above copyright
        !             9:  *    notice, this list of conditions and the following disclaimer.
        !            10:  * 2. Redistributions in binary form must reproduce the above copyright
        !            11:  *    notice, this list of conditions and the following disclaimer in the
        !            12:  *    documentation and/or other materials provided with the distribution.
        !            13:  * 3. All advertising materials mentioning features or use of this software
        !            14:  *    must display the following acknowledgement:
        !            15:  *     This product includes software developed by the University of
        !            16:  *     California, Berkeley and its contributors.
        !            17:  * 4. Neither the name of the University nor the names of its contributors
        !            18:  *    may be used to endorse or promote products derived from this software
        !            19:  *    without specific prior written permission.
        !            20:  *
        !            21:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
        !            22:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
        !            23:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
        !            24:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
        !            25:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
        !            26:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
        !            27:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
        !            28:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
        !            29:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
        !            30:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
        !            31:  * SUCH DAMAGE.
        !            32:  *
        !            33:  *     @(#)vfs_syscalls.c      7.74 (Berkeley) 6/21/91
        !            34:  */
        !            35: 
        !            36: #include "param.h"
        !            37: #include "systm.h"
        !            38: #include "namei.h"
        !            39: #include "filedesc.h"
        !            40: #include "kernel.h"
        !            41: #include "file.h"
        !            42: #include "stat.h"
        !            43: #include "vnode.h"
        !            44: #include "mount.h"
        !            45: #include "proc.h"
        !            46: #include "uio.h"
        !            47: #include "malloc.h"
        !            48: 
        !            49: /*
        !            50:  * Virtual File System System Calls
        !            51:  */
        !            52: 
        !            53: /*
        !            54:  * Mount system call.
        !            55:  */
        !            56: /* ARGSUSED */
        !            57: mount(p, uap, retval)
        !            58:        struct proc *p;
        !            59:        register struct args {
        !            60:                int     type;
        !            61:                char    *dir;
        !            62:                int     flags;
        !            63:                caddr_t data;
        !            64:        } *uap;
        !            65:        int *retval;
        !            66: {
        !            67:        register struct nameidata *ndp;
        !            68:        register struct vnode *vp;
        !            69:        register struct mount *mp;
        !            70:        int error, flag;
        !            71:        struct nameidata nd;
        !            72: 
        !            73:        /*
        !            74:         * Must be super user
        !            75:         */
        !            76:        if (error = suser(p->p_ucred, &p->p_acflag))
        !            77:                return (error);
        !            78:        /*
        !            79:         * Get vnode to be covered
        !            80:         */
        !            81:        ndp = &nd;
        !            82:        ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
        !            83:        ndp->ni_segflg = UIO_USERSPACE;
        !            84:        ndp->ni_dirp = uap->dir;
        !            85:        if (error = namei(ndp, p))
        !            86:                return (error);
        !            87:        vp = ndp->ni_vp;
        !            88:        if (uap->flags & MNT_UPDATE) {
        !            89:                if ((vp->v_flag & VROOT) == 0) {
        !            90:                        vput(vp);
        !            91:                        return (EINVAL);
        !            92:                }
        !            93:                mp = vp->v_mount;
        !            94:                /*
        !            95:                 * We allow going from read-only to read-write,
        !            96:                 * but not from read-write to read-only.
        !            97:                 */
        !            98:                if ((mp->mnt_flag & MNT_RDONLY) == 0 &&
        !            99:                    (uap->flags & MNT_RDONLY) != 0) {
        !           100:                        vput(vp);
        !           101:                        return (EOPNOTSUPP);    /* Needs translation */
        !           102:                }
        !           103:                flag = mp->mnt_flag;
        !           104:                mp->mnt_flag |= MNT_UPDATE;
        !           105:                VOP_UNLOCK(vp);
        !           106:                goto update;
        !           107:        }
        !           108:        vinvalbuf(vp, 1);
        !           109:        if (vp->v_usecount != 1) {
        !           110:                vput(vp);
        !           111:                return (EBUSY);
        !           112:        }
        !           113:        if (vp->v_type != VDIR) {
        !           114:                vput(vp);
        !           115:                return (ENOTDIR);
        !           116:        }
        !           117:        if ((unsigned long)uap->type > MOUNT_MAXTYPE ||
        !           118:            vfssw[uap->type] == (struct vfsops *)0) {
        !           119:                vput(vp);
        !           120:                return (ENODEV);
        !           121:        }
        !           122: 
        !           123:        /*
        !           124:         * Allocate and initialize the file system.
        !           125:         */
        !           126:        mp = (struct mount *)malloc((u_long)sizeof(struct mount),
        !           127:                M_MOUNT, M_WAITOK);
        !           128:        mp->mnt_op = vfssw[uap->type];
        !           129:        mp->mnt_flag = 0;
        !           130:        mp->mnt_exroot = 0;
        !           131:        mp->mnt_mounth = NULLVP;
        !           132:        if (error = vfs_lock(mp)) {
        !           133:                free((caddr_t)mp, M_MOUNT);
        !           134:                vput(vp);
        !           135:                return (error);
        !           136:        }
        !           137:        if (vp->v_mountedhere != (struct mount *)0) {
        !           138:                vfs_unlock(mp);
        !           139:                free((caddr_t)mp, M_MOUNT);
        !           140:                vput(vp);
        !           141:                return (EBUSY);
        !           142:        }
        !           143:        vp->v_mountedhere = mp;
        !           144:        mp->mnt_vnodecovered = vp;
        !           145: update:
        !           146:        /*
        !           147:         * Set the mount level flags.
        !           148:         */
        !           149:        if (uap->flags & MNT_RDONLY)
        !           150:                mp->mnt_flag |= MNT_RDONLY;
        !           151:        else
        !           152:                mp->mnt_flag &= ~MNT_RDONLY;
        !           153:        if (uap->flags & MNT_NOSUID)
        !           154:                mp->mnt_flag |= MNT_NOSUID;
        !           155:        else
        !           156:                mp->mnt_flag &= ~MNT_NOSUID;
        !           157:        if (uap->flags & MNT_NOEXEC)
        !           158:                mp->mnt_flag |= MNT_NOEXEC;
        !           159:        else
        !           160:                mp->mnt_flag &= ~MNT_NOEXEC;
        !           161:        if (uap->flags & MNT_NODEV)
        !           162:                mp->mnt_flag |= MNT_NODEV;
        !           163:        else
        !           164:                mp->mnt_flag &= ~MNT_NODEV;
        !           165:        if (uap->flags & MNT_SYNCHRONOUS)
        !           166:                mp->mnt_flag |= MNT_SYNCHRONOUS;
        !           167:        else
        !           168:                mp->mnt_flag &= ~MNT_SYNCHRONOUS;
        !           169:        /*
        !           170:         * Mount the filesystem.
        !           171:         */
        !           172:        error = VFS_MOUNT(mp, uap->dir, uap->data, ndp, p);
        !           173:        if (mp->mnt_flag & MNT_UPDATE) {
        !           174:                mp->mnt_flag &= ~MNT_UPDATE;
        !           175:                vrele(vp);
        !           176:                if (error)
        !           177:                        mp->mnt_flag = flag;
        !           178:                return (error);
        !           179:        }
        !           180:        /*
        !           181:         * Put the new filesystem on the mount list after root.
        !           182:         */
        !           183:        mp->mnt_next = rootfs->mnt_next;
        !           184:        mp->mnt_prev = rootfs;
        !           185:        rootfs->mnt_next = mp;
        !           186:        mp->mnt_next->mnt_prev = mp;
        !           187:        cache_purge(vp);
        !           188:        if (!error) {
        !           189:                VOP_UNLOCK(vp);
        !           190:                vfs_unlock(mp);
        !           191:                error = VFS_START(mp, 0, p);
        !           192:        } else {
        !           193:                vfs_remove(mp);
        !           194:                free((caddr_t)mp, M_MOUNT);
        !           195:                vput(vp);
        !           196:        }
        !           197:        return (error);
        !           198: }
        !           199: 
        !           200: /*
        !           201:  * Unmount system call.
        !           202:  *
        !           203:  * Note: unmount takes a path to the vnode mounted on as argument,
        !           204:  * not special file (as before).
        !           205:  */
        !           206: /* ARGSUSED */
        !           207: unmount(p, uap, retval)
        !           208:        struct proc *p;
        !           209:        register struct args {
        !           210:                char    *pathp;
        !           211:                int     flags;
        !           212:        } *uap;
        !           213:        int *retval;
        !           214: {
        !           215:        register struct vnode *vp;
        !           216:        register struct nameidata *ndp;
        !           217:        struct mount *mp;
        !           218:        int error;
        !           219:        struct nameidata nd;
        !           220: 
        !           221:        /*
        !           222:         * Must be super user
        !           223:         */
        !           224:        if (error = suser(p->p_ucred, &p->p_acflag))
        !           225:                return (error);
        !           226: 
        !           227:        ndp = &nd;
        !           228:        ndp->ni_nameiop = LOOKUP | LOCKLEAF | FOLLOW;
        !           229:        ndp->ni_segflg = UIO_USERSPACE;
        !           230:        ndp->ni_dirp = uap->pathp;
        !           231:        if (error = namei(ndp, p))
        !           232:                return (error);
        !           233:        vp = ndp->ni_vp;
        !           234:        /*
        !           235:         * Must be the root of the filesystem
        !           236:         */
        !           237:        if ((vp->v_flag & VROOT) == 0) {
        !           238:                vput(vp);
        !           239:                return (EINVAL);
        !           240:        }
        !           241:        mp = vp->v_mount;
        !           242:        vput(vp);
        !           243:        return (dounmount(mp, uap->flags, p));
        !           244: }
        !           245: 
        !           246: /*
        !           247:  * Do an unmount.
        !           248:  */
        !           249: dounmount(mp, flags, p)
        !           250:        register struct mount *mp;
        !           251:        int flags;
        !           252:        struct proc *p;
        !           253: {
        !           254:        struct vnode *coveredvp;
        !           255:        int error;
        !           256: 
        !           257:        coveredvp = mp->mnt_vnodecovered;
        !           258:        if (vfs_busy(mp))
        !           259:                return (EBUSY);
        !           260:        mp->mnt_flag |= MNT_UNMOUNT;
        !           261:        if (error = vfs_lock(mp))
        !           262:                return (error);
        !           263: 
        !           264:        vnode_pager_umount(mp); /* release cached vnodes */
        !           265:        cache_purgevfs(mp);     /* remove cache entries for this file sys */
        !           266:        if ((error = VFS_SYNC(mp, MNT_WAIT)) == 0 || (flags & MNT_FORCE))
        !           267:                error = VFS_UNMOUNT(mp, flags, p);
        !           268:        mp->mnt_flag &= ~MNT_UNMOUNT;
        !           269:        vfs_unbusy(mp);
        !           270:        if (error) {
        !           271:                vfs_unlock(mp);
        !           272:        } else {
        !           273:                vrele(coveredvp);
        !           274:                vfs_remove(mp);
        !           275:                free((caddr_t)mp, M_MOUNT);
        !           276:        }
        !           277:        return (error);
        !           278: }
        !           279: 
        !           280: /*
        !           281:  * Sync system call.
        !           282:  * Sync each mounted filesystem.
        !           283:  */
        !           284: /* ARGSUSED */
        !           285: sync(p, uap, retval)
        !           286:        struct proc *p;
        !           287:        void *uap;
        !           288:        int *retval;
        !           289: {
        !           290:        register struct mount *mp;
        !           291:        struct mount *omp;
        !           292: 
        !           293:        mp = rootfs;
        !           294:        do {
        !           295:                /*
        !           296:                 * The lock check below is to avoid races with mount
        !           297:                 * and unmount.
        !           298:                 */
        !           299:                if ((mp->mnt_flag & (MNT_MLOCK|MNT_RDONLY|MNT_MPBUSY)) == 0 &&
        !           300:                    !vfs_busy(mp)) {
        !           301:                        VFS_SYNC(mp, MNT_NOWAIT);
        !           302:                        omp = mp;
        !           303:                        mp = mp->mnt_next;
        !           304:                        vfs_unbusy(omp);
        !           305:                } else
        !           306:                        mp = mp->mnt_next;
        !           307:        } while (mp != rootfs);
        !           308:        return (0);
        !           309: }
        !           310: 
        !           311: /*
        !           312:  * Operate on filesystem quotas.
        !           313:  */
        !           314: /* ARGSUSED */
        !           315: quotactl(p, uap, retval)
        !           316:        struct proc *p;
        !           317:        register struct args {
        !           318:                char *path;
        !           319:                int cmd;
        !           320:                int uid;
        !           321:                caddr_t arg;
        !           322:        } *uap;
        !           323:        int *retval;
        !           324: {
        !           325:        register struct mount *mp;
        !           326:        register struct nameidata *ndp;
        !           327:        int error;
        !           328:        struct nameidata nd;
        !           329: 
        !           330:        ndp = &nd;
        !           331:        ndp->ni_nameiop = LOOKUP | FOLLOW;
        !           332:        ndp->ni_segflg = UIO_USERSPACE;
        !           333:        ndp->ni_dirp = uap->path;
        !           334:        if (error = namei(ndp, p))
        !           335:                return (error);
        !           336:        mp = ndp->ni_vp->v_mount;
        !           337:        vrele(ndp->ni_vp);
        !           338:        return (VFS_QUOTACTL(mp, uap->cmd, uap->uid, uap->arg, p));
        !           339: }
        !           340: 
        !           341: /*
        !           342:  * Get filesystem statistics.
        !           343:  */
        !           344: /* ARGSUSED */
        !           345: statfs(p, uap, retval)
        !           346:        struct proc *p;
        !           347:        register struct args {
        !           348:                char *path;
        !           349:                struct statfs *buf;
        !           350:        } *uap;
        !           351:        int *retval;
        !           352: {
        !           353:        register struct mount *mp;
        !           354:        register struct nameidata *ndp;
        !           355:        register struct statfs *sp;
        !           356:        int error;
        !           357:        struct nameidata nd;
        !           358: 
        !           359:        ndp = &nd;
        !           360:        ndp->ni_nameiop = LOOKUP | FOLLOW;
        !           361:        ndp->ni_segflg = UIO_USERSPACE;
        !           362:        ndp->ni_dirp = uap->path;
        !           363:        if (error = namei(ndp, p))
        !           364:                return (error);
        !           365:        mp = ndp->ni_vp->v_mount;
        !           366:        sp = &mp->mnt_stat;
        !           367:        vrele(ndp->ni_vp);
        !           368:        if (error = VFS_STATFS(mp, sp, p))
        !           369:                return (error);
        !           370:        sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
        !           371:        return (copyout((caddr_t)sp, (caddr_t)uap->buf, sizeof(*sp)));
        !           372: }
        !           373: 
        !           374: /*
        !           375:  * Get filesystem statistics.
        !           376:  */
        !           377: /* ARGSUSED */
        !           378: fstatfs(p, uap, retval)
        !           379:        struct proc *p;
        !           380:        register struct args {
        !           381:                int fd;
        !           382:                struct statfs *buf;
        !           383:        } *uap;
        !           384:        int *retval;
        !           385: {
        !           386:        struct file *fp;
        !           387:        struct mount *mp;
        !           388:        register struct statfs *sp;
        !           389:        int error;
        !           390: 
        !           391:        if (error = getvnode(p->p_fd, uap->fd, &fp))
        !           392:                return (error);
        !           393:        mp = ((struct vnode *)fp->f_data)->v_mount;
        !           394:        sp = &mp->mnt_stat;
        !           395:        if (error = VFS_STATFS(mp, sp, p))
        !           396:                return (error);
        !           397:        sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
        !           398:        return (copyout((caddr_t)sp, (caddr_t)uap->buf, sizeof(*sp)));
        !           399: }
        !           400: 
        !           401: /*
        !           402:  * Get statistics on all filesystems.
        !           403:  */
        !           404: getfsstat(p, uap, retval)
        !           405:        struct proc *p;
        !           406:        register struct args {
        !           407:                struct statfs *buf;
        !           408:                long bufsize;
        !           409:                int flags;
        !           410:        } *uap;
        !           411:        int *retval;
        !           412: {
        !           413:        register struct mount *mp;
        !           414:        register struct statfs *sp;
        !           415:        caddr_t sfsp;
        !           416:        long count, maxcount, error;
        !           417: 
        !           418:        maxcount = uap->bufsize / sizeof(struct statfs);
        !           419:        sfsp = (caddr_t)uap->buf;
        !           420:        mp = rootfs;
        !           421:        count = 0;
        !           422:        do {
        !           423:                if (sfsp && count < maxcount &&
        !           424:                    ((mp->mnt_flag & MNT_MLOCK) == 0)) {
        !           425:                        sp = &mp->mnt_stat;
        !           426:                        /*
        !           427:                         * If MNT_NOWAIT is specified, do not refresh the
        !           428:                         * fsstat cache. MNT_WAIT overrides MNT_NOWAIT.
        !           429:                         */
        !           430:                        if (((uap->flags & MNT_NOWAIT) == 0 ||
        !           431:                            (uap->flags & MNT_WAIT)) &&
        !           432:                            (error = VFS_STATFS(mp, sp, p))) {
        !           433:                                mp = mp->mnt_prev;
        !           434:                                continue;
        !           435:                        }
        !           436:                        sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
        !           437:                        if (error = copyout((caddr_t)sp, sfsp, sizeof(*sp)))
        !           438:                                return (error);
        !           439:                        sfsp += sizeof(*sp);
        !           440:                }
        !           441:                count++;
        !           442:                mp = mp->mnt_prev;
        !           443:        } while (mp != rootfs);
        !           444:        if (sfsp && count > maxcount)
        !           445:                *retval = maxcount;
        !           446:        else
        !           447:                *retval = count;
        !           448:        return (0);
        !           449: }
        !           450: 
        !           451: /*
        !           452:  * Change current working directory to a given file descriptor.
        !           453:  */
        !           454: /* ARGSUSED */
        !           455: fchdir(p, uap, retval)
        !           456:        struct proc *p;
        !           457:        struct args {
        !           458:                int     fd;
        !           459:        } *uap;
        !           460:        int *retval;
        !           461: {
        !           462:        register struct filedesc *fdp = p->p_fd;
        !           463:        register struct vnode *vp;
        !           464:        struct file *fp;
        !           465:        int error;
        !           466: 
        !           467:        if (error = getvnode(fdp, uap->fd, &fp))
        !           468:                return (error);
        !           469:        vp = (struct vnode *)fp->f_data;
        !           470:        VOP_LOCK(vp);
        !           471:        if (vp->v_type != VDIR)
        !           472:                error = ENOTDIR;
        !           473:        else
        !           474:                error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p);
        !           475:        VOP_UNLOCK(vp);
        !           476:        if (error)
        !           477:                return (error);
        !           478:        VREF(vp);
        !           479:        vrele(fdp->fd_cdir);
        !           480:        fdp->fd_cdir = vp;
        !           481:        return (0);
        !           482: }
        !           483: 
        !           484: /*
        !           485:  * Change current working directory (``.'').
        !           486:  */
        !           487: /* ARGSUSED */
        !           488: chdir(p, uap, retval)
        !           489:        struct proc *p;
        !           490:        struct args {
        !           491:                char    *fname;
        !           492:        } *uap;
        !           493:        int *retval;
        !           494: {
        !           495:        register struct nameidata *ndp;
        !           496:        register struct filedesc *fdp = p->p_fd;
        !           497:        int error;
        !           498:        struct nameidata nd;
        !           499: 
        !           500:        ndp = &nd;
        !           501:        ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
        !           502:        ndp->ni_segflg = UIO_USERSPACE;
        !           503:        ndp->ni_dirp = uap->fname;
        !           504:        if (error = chdirec(ndp, p))
        !           505:                return (error);
        !           506:        vrele(fdp->fd_cdir);
        !           507:        fdp->fd_cdir = ndp->ni_vp;
        !           508:        return (0);
        !           509: }
        !           510: 
        !           511: /*
        !           512:  * Change notion of root (``/'') directory.
        !           513:  */
        !           514: /* ARGSUSED */
        !           515: chroot(p, uap, retval)
        !           516:        struct proc *p;
        !           517:        struct args {
        !           518:                char    *fname;
        !           519:        } *uap;
        !           520:        int *retval;
        !           521: {
        !           522:        register struct nameidata *ndp;
        !           523:        register struct filedesc *fdp = p->p_fd;
        !           524:        int error;
        !           525:        struct nameidata nd;
        !           526: 
        !           527:        if (error = suser(p->p_ucred, &p->p_acflag))
        !           528:                return (error);
        !           529:        ndp = &nd;
        !           530:        ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
        !           531:        ndp->ni_segflg = UIO_USERSPACE;
        !           532:        ndp->ni_dirp = uap->fname;
        !           533:        if (error = chdirec(ndp, p))
        !           534:                return (error);
        !           535:        if (fdp->fd_rdir != NULL)
        !           536:                vrele(fdp->fd_rdir);
        !           537:        fdp->fd_rdir = ndp->ni_vp;
        !           538:        return (0);
        !           539: }
        !           540: 
        !           541: /*
        !           542:  * Common routine for chroot and chdir.
        !           543:  */
        !           544: chdirec(ndp, p)
        !           545:        struct nameidata *ndp;
        !           546:        struct proc *p;
        !           547: {
        !           548:        struct vnode *vp;
        !           549:        int error;
        !           550: 
        !           551:        if (error = namei(ndp, p))
        !           552:                return (error);
        !           553:        vp = ndp->ni_vp;
        !           554:        if (vp->v_type != VDIR)
        !           555:                error = ENOTDIR;
        !           556:        else
        !           557:                error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p);
        !           558:        VOP_UNLOCK(vp);
        !           559:        if (error)
        !           560:                vrele(vp);
        !           561:        return (error);
        !           562: }
        !           563: 
        !           564: /*
        !           565:  * Open system call.
        !           566:  * Check permissions, allocate an open file structure,
        !           567:  * and call the device open routine if any.
        !           568:  */
        !           569: open(p, uap, retval)
        !           570:        struct proc *p;
        !           571:        register struct args {
        !           572:                char    *fname;
        !           573:                int     mode;
        !           574:                int     crtmode;
        !           575:        } *uap;
        !           576:        int *retval;
        !           577: {
        !           578:        struct nameidata *ndp;
        !           579:        register struct filedesc *fdp = p->p_fd;
        !           580:        register struct file *fp;
        !           581:        register struct vnode *vp;
        !           582:        int fmode, cmode;
        !           583:        struct file *nfp;
        !           584:        int type, indx, error;
        !           585:        struct flock lf;
        !           586:        struct nameidata nd;
        !           587:        extern struct fileops vnops;
        !           588: 
        !           589:        if (error = falloc(p, &nfp, &indx))
        !           590:                return (error);
        !           591:        fp = nfp;
        !           592:        fmode = FFLAGS(uap->mode);
        !           593:        cmode = ((uap->crtmode &~ fdp->fd_cmask) & 07777) &~ S_ISVTX;
        !           594:        ndp = &nd;
        !           595:        ndp->ni_segflg = UIO_USERSPACE;
        !           596:        ndp->ni_dirp = uap->fname;
        !           597:        p->p_dupfd = -indx - 1;                 /* XXX check for fdopen */
        !           598:        if (error = vn_open(ndp, p, fmode, cmode)) {
        !           599:                ffree(fp);
        !           600:                if (error == ENODEV &&          /* XXX from fdopen */
        !           601:                    p->p_dupfd >= 0 &&
        !           602:                    (error = dupfdopen(fdp, indx, p->p_dupfd, fmode)) == 0) {
        !           603:                        *retval = indx;
        !           604:                        return (0);
        !           605:                }
        !           606:                if (error == ERESTART)
        !           607:                        error = EINTR;
        !           608:                fdp->fd_ofiles[indx] = NULL;
        !           609:                return (error);
        !           610:        }
        !           611:        vp = ndp->ni_vp;
        !           612:        fp->f_flag = fmode & FMASK;
        !           613:        if (fmode & (O_EXLOCK | O_SHLOCK)) {
        !           614:                lf.l_whence = SEEK_SET;
        !           615:                lf.l_start = 0;
        !           616:                lf.l_len = 0;
        !           617:                if (fmode & O_EXLOCK)
        !           618:                        lf.l_type = F_WRLCK;
        !           619:                else
        !           620:                        lf.l_type = F_RDLCK;
        !           621:                type = F_FLOCK;
        !           622:                if ((fmode & FNONBLOCK) == 0)
        !           623:                        type |= F_WAIT;
        !           624:                if (error = VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf, type)) {
        !           625:                        VOP_UNLOCK(vp);
        !           626:                        (void) vn_close(vp, fp->f_flag, fp->f_cred, p);
        !           627:                        ffree(fp);
        !           628:                        fdp->fd_ofiles[indx] = NULL;
        !           629:                        return (error);
        !           630:                }
        !           631:                fp->f_flag |= FHASLOCK;
        !           632:        }
        !           633:        VOP_UNLOCK(vp);
        !           634:        fp->f_type = DTYPE_VNODE;
        !           635:        fp->f_ops = &vnops;
        !           636:        fp->f_data = (caddr_t)vp;
        !           637:        *retval = indx;
        !           638:        return (0);
        !           639: }
        !           640: 
        !           641: #ifdef COMPAT_43
        !           642: /*
        !           643:  * Creat system call.
        !           644:  */
        !           645: ocreat(p, uap, retval)
        !           646:        struct proc *p;
        !           647:        register struct args {
        !           648:                char    *fname;
        !           649:                int     fmode;
        !           650:        } *uap;
        !           651:        int *retval;
        !           652: {
        !           653:        struct args {
        !           654:                char    *fname;
        !           655:                int     mode;
        !           656:                int     crtmode;
        !           657:        } openuap;
        !           658: 
        !           659:        openuap.fname = uap->fname;
        !           660:        openuap.crtmode = uap->fmode;
        !           661:        openuap.mode = O_WRONLY | O_CREAT | O_TRUNC;
        !           662:        return (open(p, &openuap, retval));
        !           663: }
        !           664: #endif /* COMPAT_43 */
        !           665: 
        !           666: /*
        !           667:  * Mknod system call.
        !           668:  */
        !           669: /* ARGSUSED */
        !           670: mknod(p, uap, retval)
        !           671:        struct proc *p;
        !           672:        register struct args {
        !           673:                char    *fname;
        !           674:                int     fmode;
        !           675:                int     dev;
        !           676:        } *uap;
        !           677:        int *retval;
        !           678: {
        !           679:        register struct nameidata *ndp;
        !           680:        register struct vnode *vp;
        !           681:        struct vattr vattr;
        !           682:        int error;
        !           683:        struct nameidata nd;
        !           684: 
        !           685:        if (error = suser(p->p_ucred, &p->p_acflag))
        !           686:                return (error);
        !           687:        ndp = &nd;
        !           688:        ndp->ni_nameiop = CREATE | LOCKPARENT;
        !           689:        ndp->ni_segflg = UIO_USERSPACE;
        !           690:        ndp->ni_dirp = uap->fname;
        !           691:        if (error = namei(ndp, p))
        !           692:                return (error);
        !           693:        vp = ndp->ni_vp;
        !           694:        if (vp != NULL) {
        !           695:                error = EEXIST;
        !           696:                goto out;
        !           697:        }
        !           698:        VATTR_NULL(&vattr);
        !           699:        switch (uap->fmode & S_IFMT) {
        !           700: 
        !           701:        case S_IFMT:    /* used by badsect to flag bad sectors */
        !           702:                vattr.va_type = VBAD;
        !           703:                break;
        !           704:        case S_IFCHR:
        !           705:                vattr.va_type = VCHR;
        !           706:                break;
        !           707:        case S_IFBLK:
        !           708:                vattr.va_type = VBLK;
        !           709:                break;
        !           710:        default:
        !           711:                error = EINVAL;
        !           712:                goto out;
        !           713:        }
        !           714:        vattr.va_mode = (uap->fmode & 07777) &~ p->p_fd->fd_cmask;
        !           715:        vattr.va_rdev = uap->dev;
        !           716: out:
        !           717:        if (!error) {
        !           718:                error = VOP_MKNOD(ndp, &vattr, p->p_ucred, p);
        !           719:        } else {
        !           720:                VOP_ABORTOP(ndp);
        !           721:                if (ndp->ni_dvp == vp)
        !           722:                        vrele(ndp->ni_dvp);
        !           723:                else
        !           724:                        vput(ndp->ni_dvp);
        !           725:                if (vp)
        !           726:                        vrele(vp);
        !           727:        }
        !           728:        return (error);
        !           729: }
        !           730: 
        !           731: /*
        !           732:  * Mkfifo system call.
        !           733:  */
        !           734: /* ARGSUSED */
        !           735: mkfifo(p, uap, retval)
        !           736:        struct proc *p;
        !           737:        register struct args {
        !           738:                char    *fname;
        !           739:                int     fmode;
        !           740:        } *uap;
        !           741:        int *retval;
        !           742: {
        !           743:        register struct nameidata *ndp;
        !           744:        struct vattr vattr;
        !           745:        int error;
        !           746:        struct nameidata nd;
        !           747: 
        !           748: #ifndef FIFO
        !           749:        return (EOPNOTSUPP);
        !           750: #else
        !           751:        ndp = &nd;
        !           752:        ndp->ni_nameiop = CREATE | LOCKPARENT;
        !           753:        ndp->ni_segflg = UIO_USERSPACE;
        !           754:        ndp->ni_dirp = uap->fname;
        !           755:        if (error = namei(ndp, p))
        !           756:                return (error);
        !           757:        if (ndp->ni_vp != NULL) {
        !           758:                VOP_ABORTOP(ndp);
        !           759:                if (ndp->ni_dvp == ndp->ni_vp)
        !           760:                        vrele(ndp->ni_dvp);
        !           761:                else
        !           762:                        vput(ndp->ni_dvp);
        !           763:                vrele(ndp->ni_vp);
        !           764:                return (EEXIST);
        !           765:        }
        !           766:        VATTR_NULL(&vattr);
        !           767:        vattr.va_type = VFIFO;
        !           768:        vattr.va_mode = (uap->fmode & 07777) &~ p->p_fd->fd_cmask;
        !           769:        return (VOP_MKNOD(ndp, &vattr, p->p_ucred, p));
        !           770: #endif /* FIFO */
        !           771: }
        !           772: 
        !           773: /*
        !           774:  * Link system call.
        !           775:  */
        !           776: /* ARGSUSED */
        !           777: link(p, uap, retval)
        !           778:        struct proc *p;
        !           779:        register struct args {
        !           780:                char    *target;
        !           781:                char    *linkname;
        !           782:        } *uap;
        !           783:        int *retval;
        !           784: {
        !           785:        register struct nameidata *ndp;
        !           786:        register struct vnode *vp, *xp;
        !           787:        int error;
        !           788:        struct nameidata nd;
        !           789: 
        !           790:        ndp = &nd;
        !           791:        ndp->ni_nameiop = LOOKUP | FOLLOW;
        !           792:        ndp->ni_segflg = UIO_USERSPACE;
        !           793:        ndp->ni_dirp = uap->target;
        !           794:        if (error = namei(ndp, p))
        !           795:                return (error);
        !           796:        vp = ndp->ni_vp;
        !           797:        if (vp->v_type == VDIR &&
        !           798:            (error = suser(p->p_ucred, &p->p_acflag)))
        !           799:                goto out1;
        !           800:        ndp->ni_nameiop = CREATE | LOCKPARENT;
        !           801:        ndp->ni_dirp = (caddr_t)uap->linkname;
        !           802:        if (error = namei(ndp, p))
        !           803:                goto out1;
        !           804:        xp = ndp->ni_vp;
        !           805:        if (xp != NULL) {
        !           806:                error = EEXIST;
        !           807:                goto out;
        !           808:        }
        !           809:        xp = ndp->ni_dvp;
        !           810:        if (vp->v_mount != xp->v_mount)
        !           811:                error = EXDEV;
        !           812: out:
        !           813:        if (!error) {
        !           814:                error = VOP_LINK(vp, ndp, p);
        !           815:        } else {
        !           816:                VOP_ABORTOP(ndp);
        !           817:                if (ndp->ni_dvp == ndp->ni_vp)
        !           818:                        vrele(ndp->ni_dvp);
        !           819:                else
        !           820:                        vput(ndp->ni_dvp);
        !           821:                if (ndp->ni_vp)
        !           822:                        vrele(ndp->ni_vp);
        !           823:        }
        !           824: out1:
        !           825:        vrele(vp);
        !           826:        return (error);
        !           827: }
        !           828: 
        !           829: /*
        !           830:  * Make a symbolic link.
        !           831:  */
        !           832: /* ARGSUSED */
        !           833: symlink(p, uap, retval)
        !           834:        struct proc *p;
        !           835:        register struct args {
        !           836:                char    *target;
        !           837:                char    *linkname;
        !           838:        } *uap;
        !           839:        int *retval;
        !           840: {
        !           841:        register struct nameidata *ndp;
        !           842:        struct vattr vattr;
        !           843:        char *target;
        !           844:        int error;
        !           845:        struct nameidata nd;
        !           846: 
        !           847:        ndp = &nd;
        !           848:        ndp->ni_segflg = UIO_USERSPACE;
        !           849:        ndp->ni_dirp = uap->linkname;
        !           850:        MALLOC(target, char *, MAXPATHLEN, M_NAMEI, M_WAITOK);
        !           851:        if (error = copyinstr(uap->target, target, MAXPATHLEN, (u_int *)0))
        !           852:                goto out;
        !           853:        ndp->ni_nameiop = CREATE | LOCKPARENT;
        !           854:        if (error = namei(ndp, p))
        !           855:                goto out;
        !           856:        if (ndp->ni_vp) {
        !           857:                VOP_ABORTOP(ndp);
        !           858:                if (ndp->ni_dvp == ndp->ni_vp)
        !           859:                        vrele(ndp->ni_dvp);
        !           860:                else
        !           861:                        vput(ndp->ni_dvp);
        !           862:                vrele(ndp->ni_vp);
        !           863:                error = EEXIST;
        !           864:                goto out;
        !           865:        }
        !           866:        VATTR_NULL(&vattr);
        !           867:        vattr.va_mode = 0777 &~ p->p_fd->fd_cmask;
        !           868:        error = VOP_SYMLINK(ndp, &vattr, target, p);
        !           869: out:
        !           870:        FREE(target, M_NAMEI);
        !           871:        return (error);
        !           872: }
        !           873: 
        !           874: /*
        !           875:  * Delete a name from the filesystem.
        !           876:  */
        !           877: /* ARGSUSED */
        !           878: unlink(p, uap, retval)
        !           879:        struct proc *p;
        !           880:        struct args {
        !           881:                char    *fname;
        !           882:        } *uap;
        !           883:        int *retval;
        !           884: {
        !           885:        register struct nameidata *ndp;
        !           886:        register struct vnode *vp;
        !           887:        int error;
        !           888:        struct nameidata nd;
        !           889: 
        !           890:        ndp = &nd;
        !           891:        ndp->ni_nameiop = DELETE | LOCKPARENT | LOCKLEAF;
        !           892:        ndp->ni_segflg = UIO_USERSPACE;
        !           893:        ndp->ni_dirp = uap->fname;
        !           894:        if (error = namei(ndp, p))
        !           895:                return (error);
        !           896:        vp = ndp->ni_vp;
        !           897:        if (vp->v_type == VDIR &&
        !           898:            (error = suser(p->p_ucred, &p->p_acflag)))
        !           899:                goto out;
        !           900:        /*
        !           901:         * The root of a mounted filesystem cannot be deleted.
        !           902:         */
        !           903:        if (vp->v_flag & VROOT) {
        !           904:                error = EBUSY;
        !           905:                goto out;
        !           906:        }
        !           907:        (void) vnode_pager_uncache(vp);
        !           908: out:
        !           909:        if (!error) {
        !           910:                error = VOP_REMOVE(ndp, p);
        !           911:        } else {
        !           912:                VOP_ABORTOP(ndp);
        !           913:                if (ndp->ni_dvp == vp)
        !           914:                        vrele(ndp->ni_dvp);
        !           915:                else
        !           916:                        vput(ndp->ni_dvp);
        !           917:                vput(vp);
        !           918:        }
        !           919:        return (error);
        !           920: }
        !           921: 
        !           922: /*
        !           923:  * Seek system call.
        !           924:  */
        !           925: lseek(p, uap, retval)
        !           926:        struct proc *p;
        !           927:        register struct args {
        !           928:                int     fdes;
        !           929:                off_t   off;
        !           930:                int     sbase;
        !           931:        } *uap;
        !           932:        off_t *retval;
        !           933: {
        !           934:        struct ucred *cred = p->p_ucred;
        !           935:        register struct filedesc *fdp = p->p_fd;
        !           936:        register struct file *fp;
        !           937:        struct vattr vattr;
        !           938:        int error;
        !           939: 
        !           940:        if ((unsigned)uap->fdes >= fdp->fd_nfiles ||
        !           941:            (fp = fdp->fd_ofiles[uap->fdes]) == NULL)
        !           942:                return (EBADF);
        !           943:        if (fp->f_type != DTYPE_VNODE)
        !           944:                return (ESPIPE);
        !           945:        switch (uap->sbase) {
        !           946: 
        !           947:        case L_INCR:
        !           948:                fp->f_offset += uap->off;
        !           949:                break;
        !           950: 
        !           951:        case L_XTND:
        !           952:                if (error = VOP_GETATTR((struct vnode *)fp->f_data,
        !           953:                    &vattr, cred, p))
        !           954:                        return (error);
        !           955:                fp->f_offset = uap->off + vattr.va_size;
        !           956:                break;
        !           957: 
        !           958:        case L_SET:
        !           959:                fp->f_offset = uap->off;
        !           960:                break;
        !           961: 
        !           962:        default:
        !           963:                return (EINVAL);
        !           964:        }
        !           965:        *retval = fp->f_offset;
        !           966:        return (0);
        !           967: }
        !           968: 
        !           969: /*
        !           970:  * Check access permissions.
        !           971:  */
        !           972: /* ARGSUSED */
        !           973: saccess(p, uap, retval)
        !           974:        struct proc *p;
        !           975:        register struct args {
        !           976:                char    *fname;
        !           977:                int     fmode;
        !           978:        } *uap;
        !           979:        int *retval;
        !           980: {
        !           981:        register struct nameidata *ndp;
        !           982:        register struct ucred *cred = p->p_ucred;
        !           983:        register struct vnode *vp;
        !           984:        int error, mode, svuid, svgid;
        !           985:        struct nameidata nd;
        !           986: 
        !           987:        ndp = &nd;
        !           988:        svuid = cred->cr_uid;
        !           989:        svgid = cred->cr_groups[0];
        !           990:        cred->cr_uid = p->p_cred->p_ruid;
        !           991:        cred->cr_groups[0] = p->p_cred->p_rgid;
        !           992:        ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
        !           993:        ndp->ni_segflg = UIO_USERSPACE;
        !           994:        ndp->ni_dirp = uap->fname;
        !           995:        if (error = namei(ndp, p))
        !           996:                goto out1;
        !           997:        vp = ndp->ni_vp;
        !           998:        /*
        !           999:         * fmode == 0 means only check for exist
        !          1000:         */
        !          1001:        if (uap->fmode) {
        !          1002:                mode = 0;
        !          1003:                if (uap->fmode & R_OK)
        !          1004:                        mode |= VREAD;
        !          1005:                if (uap->fmode & W_OK)
        !          1006:                        mode |= VWRITE;
        !          1007:                if (uap->fmode & X_OK)
        !          1008:                        mode |= VEXEC;
        !          1009:                if ((mode & VWRITE) == 0 || (error = vn_writechk(vp)) == 0)
        !          1010:                        error = VOP_ACCESS(vp, mode, cred, p);
        !          1011:        }
        !          1012:        vput(vp);
        !          1013: out1:
        !          1014:        cred->cr_uid = svuid;
        !          1015:        cred->cr_groups[0] = svgid;
        !          1016:        return (error);
        !          1017: }
        !          1018: 
        !          1019: /*
        !          1020:  * Stat system call.
        !          1021:  * This version follows links.
        !          1022:  */
        !          1023: /* ARGSUSED */
        !          1024: stat(p, uap, retval)
        !          1025:        struct proc *p;
        !          1026:        register struct args {
        !          1027:                char    *fname;
        !          1028:                struct stat *ub;
        !          1029:        } *uap;
        !          1030:        int *retval;
        !          1031: {
        !          1032:        register struct nameidata *ndp;
        !          1033:        struct stat sb;
        !          1034:        int error;
        !          1035:        struct nameidata nd;
        !          1036: 
        !          1037:        ndp = &nd;
        !          1038:        ndp->ni_nameiop = LOOKUP | LOCKLEAF | FOLLOW;
        !          1039:        ndp->ni_segflg = UIO_USERSPACE;
        !          1040:        ndp->ni_dirp = uap->fname;
        !          1041:        if (error = namei(ndp, p))
        !          1042:                return (error);
        !          1043:        error = vn_stat(ndp->ni_vp, &sb, p);
        !          1044:        vput(ndp->ni_vp);
        !          1045:        if (error)
        !          1046:                return (error);
        !          1047:        error = copyout((caddr_t)&sb, (caddr_t)uap->ub, sizeof (sb));
        !          1048:        return (error);
        !          1049: }
        !          1050: 
        !          1051: /*
        !          1052:  * Lstat system call.
        !          1053:  * This version does not follow links.
        !          1054:  */
        !          1055: /* ARGSUSED */
        !          1056: lstat(p, uap, retval)
        !          1057:        struct proc *p;
        !          1058:        register struct args {
        !          1059:                char    *fname;
        !          1060:                struct stat *ub;
        !          1061:        } *uap;
        !          1062:        int *retval;
        !          1063: {
        !          1064:        register struct nameidata *ndp;
        !          1065:        struct stat sb;
        !          1066:        int error;
        !          1067:        struct nameidata nd;
        !          1068: 
        !          1069:        ndp = &nd;
        !          1070:        ndp->ni_nameiop = LOOKUP | LOCKLEAF | NOFOLLOW;
        !          1071:        ndp->ni_segflg = UIO_USERSPACE;
        !          1072:        ndp->ni_dirp = uap->fname;
        !          1073:        if (error = namei(ndp, p))
        !          1074:                return (error);
        !          1075:        error = vn_stat(ndp->ni_vp, &sb, p);
        !          1076:        vput(ndp->ni_vp);
        !          1077:        if (error)
        !          1078:                return (error);
        !          1079:        error = copyout((caddr_t)&sb, (caddr_t)uap->ub, sizeof (sb));
        !          1080:        return (error);
        !          1081: }
        !          1082: 
        !          1083: /*
        !          1084:  * Return target name of a symbolic link.
        !          1085:  */
        !          1086: /* ARGSUSED */
        !          1087: readlink(p, uap, retval)
        !          1088:        struct proc *p;
        !          1089:        register struct args {
        !          1090:                char    *name;
        !          1091:                char    *buf;
        !          1092:                int     count;
        !          1093:        } *uap;
        !          1094:        int *retval;
        !          1095: {
        !          1096:        register struct nameidata *ndp;
        !          1097:        register struct vnode *vp;
        !          1098:        struct iovec aiov;
        !          1099:        struct uio auio;
        !          1100:        int error;
        !          1101:        struct nameidata nd;
        !          1102: 
        !          1103:        ndp = &nd;
        !          1104:        ndp->ni_nameiop = LOOKUP | LOCKLEAF;
        !          1105:        ndp->ni_segflg = UIO_USERSPACE;
        !          1106:        ndp->ni_dirp = uap->name;
        !          1107:        if (error = namei(ndp, p))
        !          1108:                return (error);
        !          1109:        vp = ndp->ni_vp;
        !          1110:        if (vp->v_type != VLNK) {
        !          1111:                error = EINVAL;
        !          1112:                goto out;
        !          1113:        }
        !          1114:        aiov.iov_base = uap->buf;
        !          1115:        aiov.iov_len = uap->count;
        !          1116:        auio.uio_iov = &aiov;
        !          1117:        auio.uio_iovcnt = 1;
        !          1118:        auio.uio_offset = 0;
        !          1119:        auio.uio_rw = UIO_READ;
        !          1120:        auio.uio_segflg = UIO_USERSPACE;
        !          1121:        auio.uio_procp = p;
        !          1122:        auio.uio_resid = uap->count;
        !          1123:        error = VOP_READLINK(vp, &auio, p->p_ucred);
        !          1124: out:
        !          1125:        vput(vp);
        !          1126:        *retval = uap->count - auio.uio_resid;
        !          1127:        return (error);
        !          1128: }
        !          1129: 
        !          1130: /*
        !          1131:  * Change flags of a file given path name.
        !          1132:  */
        !          1133: /* ARGSUSED */
        !          1134: chflags(p, uap, retval)
        !          1135:        struct proc *p;
        !          1136:        register struct args {
        !          1137:                char    *fname;
        !          1138:                int     flags;
        !          1139:        } *uap;
        !          1140:        int *retval;
        !          1141: {
        !          1142:        register struct nameidata *ndp;
        !          1143:        register struct vnode *vp;
        !          1144:        struct vattr vattr;
        !          1145:        int error;
        !          1146:        struct nameidata nd;
        !          1147: 
        !          1148:        ndp = &nd;
        !          1149:        ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
        !          1150:        ndp->ni_segflg = UIO_USERSPACE;
        !          1151:        ndp->ni_dirp = uap->fname;
        !          1152:        if (error = namei(ndp, p))
        !          1153:                return (error);
        !          1154:        vp = ndp->ni_vp;
        !          1155:        if (vp->v_mount->mnt_flag & MNT_RDONLY) {
        !          1156:                error = EROFS;
        !          1157:                goto out;
        !          1158:        }
        !          1159:        VATTR_NULL(&vattr);
        !          1160:        vattr.va_flags = uap->flags;
        !          1161:        error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
        !          1162: out:
        !          1163:        vput(vp);
        !          1164:        return (error);
        !          1165: }
        !          1166: 
        !          1167: /*
        !          1168:  * Change flags of a file given a file descriptor.
        !          1169:  */
        !          1170: /* ARGSUSED */
        !          1171: fchflags(p, uap, retval)
        !          1172:        struct proc *p;
        !          1173:        register struct args {
        !          1174:                int     fd;
        !          1175:                int     flags;
        !          1176:        } *uap;
        !          1177:        int *retval;
        !          1178: {
        !          1179:        struct vattr vattr;
        !          1180:        struct vnode *vp;
        !          1181:        struct file *fp;
        !          1182:        int error;
        !          1183: 
        !          1184:        if (error = getvnode(p->p_fd, uap->fd, &fp))
        !          1185:                return (error);
        !          1186:        vp = (struct vnode *)fp->f_data;
        !          1187:        VOP_LOCK(vp);
        !          1188:        if (vp->v_mount->mnt_flag & MNT_RDONLY) {
        !          1189:                error = EROFS;
        !          1190:                goto out;
        !          1191:        }
        !          1192:        VATTR_NULL(&vattr);
        !          1193:        vattr.va_flags = uap->flags;
        !          1194:        error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
        !          1195: out:
        !          1196:        VOP_UNLOCK(vp);
        !          1197:        return (error);
        !          1198: }
        !          1199: 
        !          1200: /*
        !          1201:  * Change mode of a file given path name.
        !          1202:  */
        !          1203: /* ARGSUSED */
        !          1204: chmod(p, uap, retval)
        !          1205:        struct proc *p;
        !          1206:        register struct args {
        !          1207:                char    *fname;
        !          1208:                int     fmode;
        !          1209:        } *uap;
        !          1210:        int *retval;
        !          1211: {
        !          1212:        register struct nameidata *ndp;
        !          1213:        register struct vnode *vp;
        !          1214:        struct vattr vattr;
        !          1215:        int error;
        !          1216:        struct nameidata nd;
        !          1217: 
        !          1218:        ndp = &nd;
        !          1219:        ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
        !          1220:        ndp->ni_segflg = UIO_USERSPACE;
        !          1221:        ndp->ni_dirp = uap->fname;
        !          1222:        if (error = namei(ndp, p))
        !          1223:                return (error);
        !          1224:        vp = ndp->ni_vp;
        !          1225:        if (vp->v_mount->mnt_flag & MNT_RDONLY) {
        !          1226:                error = EROFS;
        !          1227:                goto out;
        !          1228:        }
        !          1229:        VATTR_NULL(&vattr);
        !          1230:        vattr.va_mode = uap->fmode & 07777;
        !          1231:        error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
        !          1232: out:
        !          1233:        vput(vp);
        !          1234:        return (error);
        !          1235: }
        !          1236: 
        !          1237: /*
        !          1238:  * Change mode of a file given a file descriptor.
        !          1239:  */
        !          1240: /* ARGSUSED */
        !          1241: fchmod(p, uap, retval)
        !          1242:        struct proc *p;
        !          1243:        register struct args {
        !          1244:                int     fd;
        !          1245:                int     fmode;
        !          1246:        } *uap;
        !          1247:        int *retval;
        !          1248: {
        !          1249:        struct vattr vattr;
        !          1250:        struct vnode *vp;
        !          1251:        struct file *fp;
        !          1252:        int error;
        !          1253: 
        !          1254:        if (error = getvnode(p->p_fd, uap->fd, &fp))
        !          1255:                return (error);
        !          1256:        vp = (struct vnode *)fp->f_data;
        !          1257:        VOP_LOCK(vp);
        !          1258:        if (vp->v_mount->mnt_flag & MNT_RDONLY) {
        !          1259:                error = EROFS;
        !          1260:                goto out;
        !          1261:        }
        !          1262:        VATTR_NULL(&vattr);
        !          1263:        vattr.va_mode = uap->fmode & 07777;
        !          1264:        error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
        !          1265: out:
        !          1266:        VOP_UNLOCK(vp);
        !          1267:        return (error);
        !          1268: }
        !          1269: 
        !          1270: /*
        !          1271:  * Set ownership given a path name.
        !          1272:  */
        !          1273: /* ARGSUSED */
        !          1274: chown(p, uap, retval)
        !          1275:        struct proc *p;
        !          1276:        register struct args {
        !          1277:                char    *fname;
        !          1278:                int     uid;
        !          1279:                int     gid;
        !          1280:        } *uap;
        !          1281:        int *retval;
        !          1282: {
        !          1283:        register struct nameidata *ndp;
        !          1284:        register struct vnode *vp;
        !          1285:        struct vattr vattr;
        !          1286:        int error;
        !          1287:        struct nameidata nd;
        !          1288: 
        !          1289:        ndp = &nd;
        !          1290:        ndp->ni_nameiop = LOOKUP | NOFOLLOW | LOCKLEAF;
        !          1291:        ndp->ni_segflg = UIO_USERSPACE;
        !          1292:        ndp->ni_dirp = uap->fname;
        !          1293:        if (error = namei(ndp, p))
        !          1294:                return (error);
        !          1295:        vp = ndp->ni_vp;
        !          1296:        if (vp->v_mount->mnt_flag & MNT_RDONLY) {
        !          1297:                error = EROFS;
        !          1298:                goto out;
        !          1299:        }
        !          1300:        VATTR_NULL(&vattr);
        !          1301:        vattr.va_uid = uap->uid;
        !          1302:        vattr.va_gid = uap->gid;
        !          1303:        error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
        !          1304: out:
        !          1305:        vput(vp);
        !          1306:        return (error);
        !          1307: }
        !          1308: 
        !          1309: /*
        !          1310:  * Set ownership given a file descriptor.
        !          1311:  */
        !          1312: /* ARGSUSED */
        !          1313: fchown(p, uap, retval)
        !          1314:        struct proc *p;
        !          1315:        register struct args {
        !          1316:                int     fd;
        !          1317:                int     uid;
        !          1318:                int     gid;
        !          1319:        } *uap;
        !          1320:        int *retval;
        !          1321: {
        !          1322:        struct vattr vattr;
        !          1323:        struct vnode *vp;
        !          1324:        struct file *fp;
        !          1325:        int error;
        !          1326: 
        !          1327:        if (error = getvnode(p->p_fd, uap->fd, &fp))
        !          1328:                return (error);
        !          1329:        vp = (struct vnode *)fp->f_data;
        !          1330:        VOP_LOCK(vp);
        !          1331:        if (vp->v_mount->mnt_flag & MNT_RDONLY) {
        !          1332:                error = EROFS;
        !          1333:                goto out;
        !          1334:        }
        !          1335:        VATTR_NULL(&vattr);
        !          1336:        vattr.va_uid = uap->uid;
        !          1337:        vattr.va_gid = uap->gid;
        !          1338:        error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
        !          1339: out:
        !          1340:        VOP_UNLOCK(vp);
        !          1341:        return (error);
        !          1342: }
        !          1343: 
        !          1344: /*
        !          1345:  * Set the access and modification times of a file.
        !          1346:  */
        !          1347: /* ARGSUSED */
        !          1348: utimes(p, uap, retval)
        !          1349:        struct proc *p;
        !          1350:        register struct args {
        !          1351:                char    *fname;
        !          1352:                struct  timeval *tptr;
        !          1353:        } *uap;
        !          1354:        int *retval;
        !          1355: {
        !          1356:        register struct nameidata *ndp;
        !          1357:        register struct vnode *vp;
        !          1358:        struct timeval tv[2];
        !          1359:        struct vattr vattr;
        !          1360:        int error;
        !          1361:        struct nameidata nd;
        !          1362: 
        !          1363:        if (error = copyin((caddr_t)uap->tptr, (caddr_t)tv, sizeof (tv)))
        !          1364:                return (error);
        !          1365:        ndp = &nd;
        !          1366:        ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
        !          1367:        ndp->ni_segflg = UIO_USERSPACE;
        !          1368:        ndp->ni_dirp = uap->fname;
        !          1369:        if (error = namei(ndp, p))
        !          1370:                return (error);
        !          1371:        vp = ndp->ni_vp;
        !          1372:        if (vp->v_mount->mnt_flag & MNT_RDONLY) {
        !          1373:                error = EROFS;
        !          1374:                goto out;
        !          1375:        }
        !          1376:        VATTR_NULL(&vattr);
        !          1377:        vattr.va_atime = tv[0];
        !          1378:        vattr.va_mtime = tv[1];
        !          1379:        error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
        !          1380: out:
        !          1381:        vput(vp);
        !          1382:        return (error);
        !          1383: }
        !          1384: 
        !          1385: /*
        !          1386:  * Truncate a file given its path name.
        !          1387:  */
        !          1388: /* ARGSUSED */
        !          1389: truncate(p, uap, retval)
        !          1390:        struct proc *p;
        !          1391:        register struct args {
        !          1392:                char    *fname;
        !          1393:                off_t   length;
        !          1394:        } *uap;
        !          1395:        int *retval;
        !          1396: {
        !          1397:        register struct nameidata *ndp;
        !          1398:        register struct vnode *vp;
        !          1399:        struct vattr vattr;
        !          1400:        int error;
        !          1401:        struct nameidata nd;
        !          1402: 
        !          1403:        ndp = &nd;
        !          1404:        ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
        !          1405:        ndp->ni_segflg = UIO_USERSPACE;
        !          1406:        ndp->ni_dirp = uap->fname;
        !          1407:        if (error = namei(ndp, p))
        !          1408:                return (error);
        !          1409:        vp = ndp->ni_vp;
        !          1410:        if (vp->v_type == VDIR) {
        !          1411:                error = EISDIR;
        !          1412:                goto out;
        !          1413:        }
        !          1414:        if ((error = vn_writechk(vp)) ||
        !          1415:            (error = VOP_ACCESS(vp, VWRITE, p->p_ucred, p)))
        !          1416:                goto out;
        !          1417:        VATTR_NULL(&vattr);
        !          1418:        vattr.va_size = uap->length;
        !          1419:        error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
        !          1420: out:
        !          1421:        vput(vp);
        !          1422:        return (error);
        !          1423: }
        !          1424: 
        !          1425: /*
        !          1426:  * Truncate a file given a file descriptor.
        !          1427:  */
        !          1428: /* ARGSUSED */
        !          1429: ftruncate(p, uap, retval)
        !          1430:        struct proc *p;
        !          1431:        register struct args {
        !          1432:                int     fd;
        !          1433:                off_t   length;
        !          1434:        } *uap;
        !          1435:        int *retval;
        !          1436: {
        !          1437:        struct vattr vattr;
        !          1438:        struct vnode *vp;
        !          1439:        struct file *fp;
        !          1440:        int error;
        !          1441: 
        !          1442:        if (error = getvnode(p->p_fd, uap->fd, &fp))
        !          1443:                return (error);
        !          1444:        if ((fp->f_flag & FWRITE) == 0)
        !          1445:                return (EINVAL);
        !          1446:        vp = (struct vnode *)fp->f_data;
        !          1447:        VOP_LOCK(vp);
        !          1448:        if (vp->v_type == VDIR) {
        !          1449:                error = EISDIR;
        !          1450:                goto out;
        !          1451:        }
        !          1452:        if (error = vn_writechk(vp))
        !          1453:                goto out;
        !          1454:        VATTR_NULL(&vattr);
        !          1455:        vattr.va_size = uap->length;
        !          1456:        error = VOP_SETATTR(vp, &vattr, fp->f_cred, p);
        !          1457: out:
        !          1458:        VOP_UNLOCK(vp);
        !          1459:        return (error);
        !          1460: }
        !          1461: 
        !          1462: /*
        !          1463:  * Synch an open file.
        !          1464:  */
        !          1465: /* ARGSUSED */
        !          1466: fsync(p, uap, retval)
        !          1467:        struct proc *p;
        !          1468:        struct args {
        !          1469:                int     fd;
        !          1470:        } *uap;
        !          1471:        int *retval;
        !          1472: {
        !          1473:        register struct vnode *vp;
        !          1474:        struct file *fp;
        !          1475:        int error;
        !          1476: 
        !          1477:        if (error = getvnode(p->p_fd, uap->fd, &fp))
        !          1478:                return (error);
        !          1479:        vp = (struct vnode *)fp->f_data;
        !          1480:        VOP_LOCK(vp);
        !          1481:        error = VOP_FSYNC(vp, fp->f_flag, fp->f_cred, MNT_WAIT, p);
        !          1482:        VOP_UNLOCK(vp);
        !          1483:        return (error);
        !          1484: }
        !          1485: 
        !          1486: /*
        !          1487:  * Rename system call.
        !          1488:  *
        !          1489:  * Source and destination must either both be directories, or both
        !          1490:  * not be directories.  If target is a directory, it must be empty.
        !          1491:  */
        !          1492: /* ARGSUSED */
        !          1493: rename(p, uap, retval)
        !          1494:        struct proc *p;
        !          1495:        register struct args {
        !          1496:                char    *from;
        !          1497:                char    *to;
        !          1498:        } *uap;
        !          1499:        int *retval;
        !          1500: {
        !          1501:        register struct vnode *tvp, *fvp, *tdvp;
        !          1502:        struct nameidata fromnd, tond;
        !          1503:        int error;
        !          1504: 
        !          1505:        fromnd.ni_nameiop = DELETE | WANTPARENT | SAVESTART;
        !          1506:        fromnd.ni_segflg = UIO_USERSPACE;
        !          1507:        fromnd.ni_dirp = uap->from;
        !          1508:        if (error = namei(&fromnd, p))
        !          1509:                return (error);
        !          1510:        fvp = fromnd.ni_vp;
        !          1511:        tond.ni_nameiop = RENAME | LOCKPARENT | LOCKLEAF | NOCACHE | SAVESTART;
        !          1512:        tond.ni_segflg = UIO_USERSPACE;
        !          1513:        tond.ni_dirp = uap->to;
        !          1514:        if (error = namei(&tond, p)) {
        !          1515:                VOP_ABORTOP(&fromnd);
        !          1516:                vrele(fromnd.ni_dvp);
        !          1517:                vrele(fvp);
        !          1518:                goto out1;
        !          1519:        }
        !          1520:        tdvp = tond.ni_dvp;
        !          1521:        tvp = tond.ni_vp;
        !          1522:        if (tvp != NULL) {
        !          1523:                if (fvp->v_type == VDIR && tvp->v_type != VDIR) {
        !          1524:                        error = ENOTDIR;
        !          1525:                        goto out;
        !          1526:                } else if (fvp->v_type != VDIR && tvp->v_type == VDIR) {
        !          1527:                        error = EISDIR;
        !          1528:                        goto out;
        !          1529:                }
        !          1530:                if (fvp->v_mount != tvp->v_mount) {
        !          1531:                        error = EXDEV;
        !          1532:                        goto out;
        !          1533:                }
        !          1534:        }
        !          1535:        if (fvp->v_mount != tdvp->v_mount) {
        !          1536:                error = EXDEV;
        !          1537:                goto out;
        !          1538:        }
        !          1539:        if (fvp == tdvp)
        !          1540:                error = EINVAL;
        !          1541:        /*
        !          1542:         * If source is the same as the destination (that is the
        !          1543:         * same inode number with the same name in the same directory),
        !          1544:         * then there is nothing to do.
        !          1545:         */
        !          1546:        if (fvp == tvp && fromnd.ni_dvp == tdvp &&
        !          1547:            fromnd.ni_namelen == tond.ni_namelen &&
        !          1548:            !bcmp(fromnd.ni_ptr, tond.ni_ptr, fromnd.ni_namelen))
        !          1549:                error = -1;
        !          1550: out:
        !          1551:        if (!error) {
        !          1552:                error = VOP_RENAME(&fromnd, &tond, p);
        !          1553:        } else {
        !          1554:                VOP_ABORTOP(&tond);
        !          1555:                if (tdvp == tvp)
        !          1556:                        vrele(tdvp);
        !          1557:                else
        !          1558:                        vput(tdvp);
        !          1559:                if (tvp)
        !          1560:                        vput(tvp);
        !          1561:                VOP_ABORTOP(&fromnd);
        !          1562:                vrele(fromnd.ni_dvp);
        !          1563:                vrele(fvp);
        !          1564:        }
        !          1565:        vrele(tond.ni_startdir);
        !          1566:        FREE(tond.ni_pnbuf, M_NAMEI);
        !          1567: out1:
        !          1568:        vrele(fromnd.ni_startdir);
        !          1569:        FREE(fromnd.ni_pnbuf, M_NAMEI);
        !          1570:        if (error == -1)
        !          1571:                return (0);
        !          1572:        return (error);
        !          1573: }
        !          1574: 
        !          1575: /*
        !          1576:  * Mkdir system call.
        !          1577:  */
        !          1578: /* ARGSUSED */
        !          1579: mkdir(p, uap, retval)
        !          1580:        struct proc *p;
        !          1581:        register struct args {
        !          1582:                char    *name;
        !          1583:                int     dmode;
        !          1584:        } *uap;
        !          1585:        int *retval;
        !          1586: {
        !          1587:        register struct nameidata *ndp;
        !          1588:        register struct vnode *vp;
        !          1589:        struct vattr vattr;
        !          1590:        int error;
        !          1591:        struct nameidata nd;
        !          1592: 
        !          1593:        ndp = &nd;
        !          1594:        ndp->ni_nameiop = CREATE | LOCKPARENT;
        !          1595:        ndp->ni_segflg = UIO_USERSPACE;
        !          1596:        ndp->ni_dirp = uap->name;
        !          1597:        if (error = namei(ndp, p))
        !          1598:                return (error);
        !          1599:        vp = ndp->ni_vp;
        !          1600:        if (vp != NULL) {
        !          1601:                VOP_ABORTOP(ndp);
        !          1602:                if (ndp->ni_dvp == vp)
        !          1603:                        vrele(ndp->ni_dvp);
        !          1604:                else
        !          1605:                        vput(ndp->ni_dvp);
        !          1606:                vrele(vp);
        !          1607:                return (EEXIST);
        !          1608:        }
        !          1609:        VATTR_NULL(&vattr);
        !          1610:        vattr.va_type = VDIR;
        !          1611:        vattr.va_mode = (uap->dmode & 0777) &~ p->p_fd->fd_cmask;
        !          1612:        error = VOP_MKDIR(ndp, &vattr, p);
        !          1613:        if (!error)
        !          1614:                vput(ndp->ni_vp);
        !          1615:        return (error);
        !          1616: }
        !          1617: 
        !          1618: /*
        !          1619:  * Rmdir system call.
        !          1620:  */
        !          1621: /* ARGSUSED */
        !          1622: rmdir(p, uap, retval)
        !          1623:        struct proc *p;
        !          1624:        struct args {
        !          1625:                char    *name;
        !          1626:        } *uap;
        !          1627:        int *retval;
        !          1628: {
        !          1629:        register struct nameidata *ndp;
        !          1630:        register struct vnode *vp;
        !          1631:        int error;
        !          1632:        struct nameidata nd;
        !          1633: 
        !          1634:        ndp = &nd;
        !          1635:        ndp->ni_nameiop = DELETE | LOCKPARENT | LOCKLEAF;
        !          1636:        ndp->ni_segflg = UIO_USERSPACE;
        !          1637:        ndp->ni_dirp = uap->name;
        !          1638:        if (error = namei(ndp, p))
        !          1639:                return (error);
        !          1640:        vp = ndp->ni_vp;
        !          1641:        if (vp->v_type != VDIR) {
        !          1642:                error = ENOTDIR;
        !          1643:                goto out;
        !          1644:        }
        !          1645:        /*
        !          1646:         * No rmdir "." please.
        !          1647:         */
        !          1648:        if (ndp->ni_dvp == vp) {
        !          1649:                error = EINVAL;
        !          1650:                goto out;
        !          1651:        }
        !          1652:        /*
        !          1653:         * The root of a mounted filesystem cannot be deleted.
        !          1654:         */
        !          1655:        if (vp->v_flag & VROOT)
        !          1656:                error = EBUSY;
        !          1657: out:
        !          1658:        if (!error) {
        !          1659:                error = VOP_RMDIR(ndp, p);
        !          1660:        } else {
        !          1661:                VOP_ABORTOP(ndp);
        !          1662:                if (ndp->ni_dvp == vp)
        !          1663:                        vrele(ndp->ni_dvp);
        !          1664:                else
        !          1665:                        vput(ndp->ni_dvp);
        !          1666:                vput(vp);
        !          1667:        }
        !          1668:        return (error);
        !          1669: }
        !          1670: 
        !          1671: /*
        !          1672:  * Read a block of directory entries in a file system independent format.
        !          1673:  */
        !          1674: getdirentries(p, uap, retval)
        !          1675:        struct proc *p;
        !          1676:        register struct args {
        !          1677:                int     fd;
        !          1678:                char    *buf;
        !          1679:                unsigned count;
        !          1680:                long    *basep;
        !          1681:        } *uap;
        !          1682:        int *retval;
        !          1683: {
        !          1684:        register struct vnode *vp;
        !          1685:        struct file *fp;
        !          1686:        struct uio auio;
        !          1687:        struct iovec aiov;
        !          1688:        off_t off;
        !          1689:        int error, eofflag;
        !          1690: 
        !          1691:        if (error = getvnode(p->p_fd, uap->fd, &fp))
        !          1692:                return (error);
        !          1693:        if ((fp->f_flag & FREAD) == 0)
        !          1694:                return (EBADF);
        !          1695:        vp = (struct vnode *)fp->f_data;
        !          1696:        if (vp->v_type != VDIR)
        !          1697:                return (EINVAL);
        !          1698:        aiov.iov_base = uap->buf;
        !          1699:        aiov.iov_len = uap->count;
        !          1700:        auio.uio_iov = &aiov;
        !          1701:        auio.uio_iovcnt = 1;
        !          1702:        auio.uio_rw = UIO_READ;
        !          1703:        auio.uio_segflg = UIO_USERSPACE;
        !          1704:        auio.uio_procp = p;
        !          1705:        auio.uio_resid = uap->count;
        !          1706:        VOP_LOCK(vp);
        !          1707:        auio.uio_offset = off = fp->f_offset;
        !          1708:        error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag);
        !          1709:        fp->f_offset = auio.uio_offset;
        !          1710:        VOP_UNLOCK(vp);
        !          1711:        if (error)
        !          1712:                return (error);
        !          1713:        error = copyout((caddr_t)&off, (caddr_t)uap->basep, sizeof(long));
        !          1714:        *retval = uap->count - auio.uio_resid;
        !          1715:        return (error);
        !          1716: }
        !          1717: 
        !          1718: /*
        !          1719:  * Set the mode mask for creation of filesystem nodes.
        !          1720:  */
        !          1721: mode_t
        !          1722: umask(p, uap, retval)
        !          1723:        struct proc *p;
        !          1724:        struct args {
        !          1725:                int     mask;
        !          1726:        } *uap;
        !          1727:        int *retval;
        !          1728: {
        !          1729:        register struct filedesc *fdp = p->p_fd;
        !          1730: 
        !          1731:        *retval = fdp->fd_cmask;
        !          1732:        fdp->fd_cmask = uap->mask & 07777;
        !          1733:        return (0);
        !          1734: }
        !          1735: 
        !          1736: /*
        !          1737:  * Void all references to file by ripping underlying filesystem
        !          1738:  * away from vnode.
        !          1739:  */
        !          1740: /* ARGSUSED */
        !          1741: revoke(p, uap, retval)
        !          1742:        struct proc *p;
        !          1743:        register struct args {
        !          1744:                char    *fname;
        !          1745:        } *uap;
        !          1746:        int *retval;
        !          1747: {
        !          1748:        register struct nameidata *ndp;
        !          1749:        register struct vnode *vp;
        !          1750:        struct vattr vattr;
        !          1751:        int error;
        !          1752:        struct nameidata nd;
        !          1753: 
        !          1754:        ndp = &nd;
        !          1755:        ndp->ni_nameiop = LOOKUP | FOLLOW;
        !          1756:        ndp->ni_segflg = UIO_USERSPACE;
        !          1757:        ndp->ni_dirp = uap->fname;
        !          1758:        if (error = namei(ndp, p))
        !          1759:                return (error);
        !          1760:        vp = ndp->ni_vp;
        !          1761:        if (vp->v_type != VCHR && vp->v_type != VBLK) {
        !          1762:                error = EINVAL;
        !          1763:                goto out;
        !          1764:        }
        !          1765:        if (error = VOP_GETATTR(vp, &vattr, p->p_ucred, p))
        !          1766:                goto out;
        !          1767:        if (p->p_ucred->cr_uid != vattr.va_uid &&
        !          1768:            (error = suser(p->p_ucred, &p->p_acflag)))
        !          1769:                goto out;
        !          1770:        if (vp->v_usecount > 1 || (vp->v_flag & VALIASED))
        !          1771:                vgoneall(vp);
        !          1772: out:
        !          1773:        vrele(vp);
        !          1774:        return (error);
        !          1775: }
        !          1776: 
        !          1777: /*
        !          1778:  * Convert a user file descriptor to a kernel file entry.
        !          1779:  */
        !          1780: getvnode(fdp, fdes, fpp)
        !          1781:        struct filedesc *fdp;
        !          1782:        struct file **fpp;
        !          1783:        int fdes;
        !          1784: {
        !          1785:        struct file *fp;
        !          1786: 
        !          1787:        if ((unsigned)fdes >= fdp->fd_nfiles ||
        !          1788:            (fp = fdp->fd_ofiles[fdes]) == NULL)
        !          1789:                return (EBADF);
        !          1790:        if (fp->f_type != DTYPE_VNODE)
        !          1791:                return (EINVAL);
        !          1792:        *fpp = fp;
        !          1793:        return (0);
        !          1794: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.