root/kern/vfs_syscalls.c

DEFINITIONS

1. sys_mount
2. checkdirs
3. sys_unmount
4. dounmount
5. sys_sync
6. sys_quotactl
7. copyout_statfs
8. sys_statfs
9. sys_fstatfs
10. sys_getfsstat
11. sys_fchdir
12. sys_chdir
13. sys_chroot
14. change_dir
15. sys_open
16. sys_getfh
17. sys_fhopen
18. sys_fhstat
19. sys_fhstatfs
20. sys_mknod
21. sys_mkfifo
22. sys_link
23. sys_symlink
24. sys_unlink
25. sys_lseek
26. sys_access
27. sys_stat
28. sys_lstat
29. sys_pathconf
30. sys_readlink
31. sys_chflags
32. sys_fchflags
33. sys_chmod
34. sys_fchmod
35. sys_chown
36. sys_lchown
37. sys_fchown
38. sys_utimes
39. sys_futimes
40. sys_truncate
41. sys_ftruncate
42. sys_fsync
43. sys_rename
44. sys_mkdir
45. sys_rmdir
46. sys_getdirentries
47. sys_umask
48. sys_revoke
49. getvnode
50. sys_pread
51. sys_preadv
52. sys_pwrite
53. sys_pwritev

    1 /*      $OpenBSD: vfs_syscalls.c,v 1.141 2007/08/06 16:58:26 millert Exp $      */
    2 /*      $NetBSD: vfs_syscalls.c,v 1.71 1996/04/23 10:29:02 mycroft Exp $        */
    4 /*
    5  * Copyright (c) 1989, 1993
    6  *      The Regents of the University of California.  All rights reserved.
    7  * (c) UNIX System Laboratories, Inc.
    8  * All or some portions of this file are derived from material licensed
    9  * to the University of California by American Telephone and Telegraph
   10  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
   11  * the permission of UNIX System Laboratories, Inc.
   12  *
   13  * Redistribution and use in source and binary forms, with or without
   14  * modification, are permitted provided that the following conditions
   15  * are met:
   16  * 1. Redistributions of source code must retain the above copyright
   17  *    notice, this list of conditions and the following disclaimer.
   18  * 2. Redistributions in binary form must reproduce the above copyright
   19  *    notice, this list of conditions and the following disclaimer in the
   20  *    documentation and/or other materials provided with the distribution.
   21  * 3. Neither the name of the University nor the names of its contributors
   22  *    may be used to endorse or promote products derived from this software
   23  *    without specific prior written permission.
   24  *
   25  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   35  * SUCH DAMAGE.
   36  *
   37  *      @(#)vfs_syscalls.c      8.28 (Berkeley) 12/10/94
   38  */
   40 #include <sys/param.h>
   41 #include <sys/systm.h>
   42 #include <sys/namei.h>
   43 #include <sys/filedesc.h>
   44 #include <sys/kernel.h>
   45 #include <sys/file.h>
   46 #include <sys/stat.h>
   47 #include <sys/vnode.h>
   48 #include <sys/mount.h>
   49 #include <sys/proc.h>
   50 #include <sys/uio.h>
   51 #include <sys/malloc.h>
   52 #include <sys/pool.h>
   53 #include <sys/dirent.h>
   54 #include <sys/dkio.h>
   55 #include <sys/disklabel.h>
   57 #include <sys/syscallargs.h>
   59 #include <uvm/uvm_extern.h>
   60 #include <sys/sysctl.h>
   62 extern int suid_clear;
   63 int     usermount = 0;          /* sysctl: by default, users may not mount */
   65 static int change_dir(struct nameidata *, struct proc *);
   67 void checkdirs(struct vnode *);
   69 int copyout_statfs(struct statfs *, void *, struct proc *);
   71 /*
   72  * Virtual File System System Calls
   73  */
   75 /*
   76  * Mount a file system.
   77  */
   78 /* ARGSUSED */
   79 int
sys_mount(struct proc *p, void *v, register_t *retval)
   81 {
   82         struct sys_mount_args /* {
   83                 syscallarg(const char *) type;
   84                 syscallarg(const char *) path;
   85                 syscallarg(int) flags;
   86                 syscallarg(void *) data;
   87         } */ *uap = v;
   88         struct vnode *vp;
   89         struct mount *mp;
   90         int error, flag = 0;
   91 #ifdef COMPAT_43
u_long fstypenum = 0;
   93 #endif
   94         char fstypename[MFSNAMELEN];
   95         char fspath[MNAMELEN];
   96         struct vattr va;
   97         struct nameidata nd;
   98         struct vfsconf *vfsp;
  100         if (usermount == 0 && (error = suser(p, 0)))
  101                 return (error);
  103         /*
  104          * Mount points must fit in MNAMELEN, not MAXPATHLEN.
  105          */
error = copyinstr(SCARG(uap, path), fspath, MNAMELEN, NULL);
  107         if (error)
  108                 return(error);
  110         /*
  111          * Get vnode to be covered
  112          */
NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, fspath, p);
  114         if ((error = namei(&nd)) != 0)
  115                 return (error);
vp = nd.ni_vp;
  117         if (SCARG(uap, flags) & MNT_UPDATE) {
  118                 if ((vp->v_flag & VROOT) == 0) {
vput(vp);
  120                         return (EINVAL);
  121                 }
mp = vp->v_mount;
flag = mp->mnt_flag;
  124                 /*
  125                  * We only allow the filesystem to be reloaded if it
  126                  * is currently mounted read-only.
  127                  */
  128                 if ((SCARG(uap, flags) & MNT_RELOAD) &&
  129                     ((mp->mnt_flag & MNT_RDONLY) == 0)) {
vput(vp);
  131                         return (EOPNOTSUPP);    /* Needs translation */
  132                 }
  134                 /*
  135                  * Only root, or the user that did the original mount is
  136                  * permitted to update it.
  137                  */
  138                 if (mp->mnt_stat.f_owner != p->p_ucred->cr_uid &&
  139                     (error = suser(p, 0))) {
vput(vp);
  141                         return (error);
  142                 }
  143                 /*
  144                  * Do not allow NFS export by non-root users. Silently
  145                  * enforce MNT_NOSUID and MNT_NODEV for non-root users, and
  146                  * inherit MNT_NOEXEC from the mount point.
  147                  */
  148                 if (p->p_ucred->cr_uid != 0) {
  149                         if (SCARG(uap, flags) & MNT_EXPORTED) {
vput(vp);
  151                                 return (EPERM);
  152                         }
SCARG(uap, flags) |= MNT_NOSUID | MNT_NODEV;
  154                         if (flag & MNT_NOEXEC)
SCARG(uap, flags) |= MNT_NOEXEC;
  156                 }
  157                 if ((error = vfs_busy(mp, VB_READ|VB_NOWAIT)) != 0) {
vput(vp);
  159                         return (error);
  160                 }
VOP_UNLOCK(vp, 0, p);
mp->mnt_flag |= SCARG(uap, flags) & (MNT_RELOAD | MNT_UPDATE);
  163                 goto update;
  164         }
  165         /*
  166          * If the user is not root, ensure that they own the directory
  167          * onto which we are attempting to mount.
  168          */
  169         if ((error = VOP_GETATTR(vp, &va, p->p_ucred, p)) ||
  170             (va.va_uid != p->p_ucred->cr_uid &&
  171             (error = suser(p, 0)))) {
vput(vp);
  173                 return (error);
  174         }
  175         /*
  176          * Do not allow NFS export by non-root users. Silently
  177          * enforce MNT_NOSUID and MNT_NODEV for non-root users, and inherit
  178          * MNT_NOEXEC from the mount point.
  179          */
  180         if (p->p_ucred->cr_uid != 0) {
  181                 if (SCARG(uap, flags) & MNT_EXPORTED) {
vput(vp);
  183                         return (EPERM);
  184                 }
SCARG(uap, flags) |= MNT_NOSUID | MNT_NODEV;
  186                 if (vp->v_mount->mnt_flag & MNT_NOEXEC)
SCARG(uap, flags) |= MNT_NOEXEC;
  188         }
  189         if ((error = vinvalbuf(vp, V_SAVE, p->p_ucred, p, 0, 0)) != 0) {
vput(vp);
  191                 return (error);
  192         }
  193         if (vp->v_type != VDIR) {
vput(vp);
  195                 return (ENOTDIR);
  196         }
error = copyinstr(SCARG(uap, type), fstypename, MFSNAMELEN, NULL);
  198         if (error) {
  199 #ifdef COMPAT_43
  200                 /*
  201                  * Historically filesystem types were identified by number.
  202                  * If we get an integer for the filesystem type instead of a
  203                  * string, we check to see if it matches one of the historic
  204                  * filesystem types.
  205                  */
fstypenum = (u_long)SCARG(uap, type);
  208                 for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next)
  209                         if (vfsp->vfc_typenum == fstypenum)
  210                                 break;
  211                 if (vfsp == NULL) {
vput(vp);
  213                         return (ENODEV);
  214                 }
strncpy(fstypename, vfsp->vfc_name, MFSNAMELEN);
  217 #else
vput(vp);
  219                 return (error);
  220 #endif
  221         }
  222         for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next) {
  223                 if (!strcmp(vfsp->vfc_name, fstypename))
  224                         break;
  225         }
  227         if (vfsp == NULL) {
vput(vp);
  229                 return (EOPNOTSUPP);
  230         }
  232         if (vp->v_mountedhere != NULL) {
vput(vp);
  234                 return (EBUSY);
  235         }
  237         /*
  238          * Allocate and initialize the file system.
  239          */
mp = (struct mount *)malloc((u_long)sizeof(struct mount),
M_MOUNT, M_WAITOK);
bzero((char *)mp, (u_long)sizeof(struct mount));
  243         (void) vfs_busy(mp, VB_READ|VB_NOWAIT);
mp->mnt_op = vfsp->vfc_vfsops;
mp->mnt_vfc = vfsp;
mp->mnt_flag |= (vfsp->vfc_flags & MNT_VISFLAGMASK);
strncpy(mp->mnt_stat.f_fstypename, vfsp->vfc_name, MFSNAMELEN);
mp->mnt_vnodecovered = vp;
mp->mnt_stat.f_owner = p->p_ucred->cr_uid;
update:
  251         /*
  252          * Set the mount level flags.
  253          */
  254         if (SCARG(uap, flags) & MNT_RDONLY)
mp->mnt_flag |= MNT_RDONLY;
  256         else if (mp->mnt_flag & MNT_RDONLY)
mp->mnt_flag |= MNT_WANTRDWR;
mp->mnt_flag &=~ (MNT_NOSUID | MNT_NOEXEC | MNT_NODEV |
MNT_SYNCHRONOUS | MNT_ASYNC | MNT_SOFTDEP | MNT_NOATIME |
MNT_FORCE);
mp->mnt_flag |= SCARG(uap, flags) & (MNT_NOSUID | MNT_NOEXEC |
MNT_NODEV | MNT_SYNCHRONOUS | MNT_ASYNC | MNT_SOFTDEP |
MNT_NOATIME | MNT_FORCE);
  264         /*
  265          * Mount the filesystem.
  266          */
error = VFS_MOUNT(mp, SCARG(uap, path), SCARG(uap, data), &nd, p);
  268         if (!error) {
mp->mnt_stat.f_ctime = time_second;
  270         }
  271         if (mp->mnt_flag & MNT_UPDATE) {
vrele(vp);
  273                 if (mp->mnt_flag & MNT_WANTRDWR)
mp->mnt_flag &= ~MNT_RDONLY;
mp->mnt_flag &=~
  276                     (MNT_UPDATE | MNT_RELOAD | MNT_FORCE | MNT_WANTRDWR);
  277                 if (error)
mp->mnt_flag = flag;
  280                 if ((mp->mnt_flag & MNT_RDONLY) == 0) {
  281                         if (mp->mnt_syncer == NULL)
error = vfs_allocate_syncvnode(mp);
  283                 } else {
  284                         if (mp->mnt_syncer != NULL)
vgone(mp->mnt_syncer);
mp->mnt_syncer = NULL;
  287                 }
vfs_unbusy(mp);
  290                 return (error);
  291         }
vp->v_mountedhere = mp;
  295         /*
  296          * Put the new filesystem on the mount list after root.
  297          */
cache_purge(vp);
  299         if (!error) {
vfsp->vfc_refcount++;
CIRCLEQ_INSERT_TAIL(&mountlist, mp, mnt_list);
checkdirs(vp);
VOP_UNLOCK(vp, 0, p);
  304                 if ((mp->mnt_flag & MNT_RDONLY) == 0)
error = vfs_allocate_syncvnode(mp);
vfs_unbusy(mp);
  307                 (void) VFS_STATFS(mp, &mp->mnt_stat, p);
  308                 if ((error = VFS_START(mp, 0, p)) != 0)
vrele(vp);
  310         } else {
mp->mnt_vnodecovered->v_mountedhere = (struct mount *)0;
vfs_unbusy(mp);
free(mp, M_MOUNT);
vput(vp);
  315         }
  316         return (error);
  317 }
  319 /*
  320  * Scan all active processes to see if any of them have a current
  321  * or root directory onto which the new filesystem has just been
  322  * mounted. If so, replace them with the new mount point.
  323  */
  324 void
checkdirs(struct vnode *olddp)
  326 {
  327         struct filedesc *fdp;
  328         struct vnode *newdp;
  329         struct proc *p;
  331         if (olddp->v_usecount == 1)
  332                 return;
  333         if (VFS_ROOT(olddp->v_mountedhere, &newdp))
panic("mount: lost mount");
  335         for (p = LIST_FIRST(&allproc); p != 0; p = LIST_NEXT(p, p_list)) {
fdp = p->p_fd;
  337                 if (fdp->fd_cdir == olddp) {
vrele(fdp->fd_cdir);
VREF(newdp);
fdp->fd_cdir = newdp;
  341                 }
  342                 if (fdp->fd_rdir == olddp) {
vrele(fdp->fd_rdir);
VREF(newdp);
fdp->fd_rdir = newdp;
  346                 }
  347         }
  348         if (rootvnode == olddp) {
vrele(rootvnode);
VREF(newdp);
rootvnode = newdp;
  352         }
vput(newdp);
  354 }
  356 /*
  357  * Unmount a file system.
  358  *
  359  * Note: unmount takes a path to the vnode mounted on as argument,
  360  * not special file (as before).
  361  */
  362 /* ARGSUSED */
  363 int
sys_unmount(struct proc *p, void *v, register_t *retval)
  365 {
  366         struct sys_unmount_args /* {
  367                 syscallarg(const char *) path;
  368                 syscallarg(int) flags;
  369         } */ *uap = v;
  370         struct vnode *vp;
  371         struct mount *mp;
  372         int error;
  373         struct nameidata nd;
NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
SCARG(uap, path), p);
  377         if ((error = namei(&nd)) != 0)
  378                 return (error);
vp = nd.ni_vp;
mp = vp->v_mount;
  382         /*
  383          * Only root, or the user that did the original mount is
  384          * permitted to unmount this filesystem.
  385          */
  386         if ((mp->mnt_stat.f_owner != p->p_ucred->cr_uid) &&
  387             (error = suser(p, 0))) {
vput(vp);
  389                 return (error);
  390         }
  392         /*
  393          * Don't allow unmounting the root file system.
  394          */
  395         if (mp->mnt_flag & MNT_ROOTFS) {
vput(vp);
  397                 return (EINVAL);
  398         }
  400         /*
  401          * Must be the root of the filesystem
  402          */
  403         if ((vp->v_flag & VROOT) == 0) {
vput(vp);
  405                 return (EINVAL);
  406         }
vput(vp);
  409         if (vfs_busy(mp, VB_WRITE|VB_WAIT))
  410                 return (EBUSY);
  412         return (dounmount(mp, SCARG(uap, flags), p, vp));
  413 }
  415 /*
  416  * Do the actual file system unmount.
  417  */
  418 int
dounmount(struct mount *mp, int flags, struct proc *p, struct vnode *olddp)
  420 {
  421         struct vnode *coveredvp;
  422         int error;
  423         int hadsyncer = 0;
mp->mnt_flag &=~ MNT_ASYNC;
cache_purgevfs(mp);     /* remove cache entries for this file sys */
  427         if (mp->mnt_syncer != NULL) {
hadsyncer = 1;
vgone(mp->mnt_syncer);
mp->mnt_syncer = NULL;
  431         }
  432         if (((mp->mnt_flag & MNT_RDONLY) ||
  433             (error = VFS_SYNC(mp, MNT_WAIT, p->p_ucred, p)) == 0) ||
  434             (flags & MNT_FORCE))
error = VFS_UNMOUNT(mp, flags, p);
  437         if (error && error != EIO && !(flags & MNT_DOOMED)) {
  438                 if ((mp->mnt_flag & MNT_RDONLY) == 0 && hadsyncer)
  439                         (void) vfs_allocate_syncvnode(mp);
vfs_unbusy(mp);
  441                 return (error);
  442         }
CIRCLEQ_REMOVE(&mountlist, mp, mnt_list);
  445         if ((coveredvp = mp->mnt_vnodecovered) != NULLVP) {
coveredvp->v_mountedhere = NULL;
vrele(coveredvp);
  448         }
mp->mnt_vfc->vfc_refcount--;
  452         if (!LIST_EMPTY(&mp->mnt_vnodelist))
panic("unmount: dangling vnode");
vfs_unbusy(mp);
free(mp, M_MOUNT);
  458         return (0);
  459 }
  461 /*
  462  * Sync each mounted filesystem.
  463  */
  464 #ifdef DEBUG
  465 int syncprt = 0;
  466 struct ctldebug debug0 = { "syncprt", &syncprt };
  467 #endif
  469 /* ARGSUSED */
  470 int
sys_sync(struct proc *p, void *v, register_t *retval)
  472 {
  473         struct mount *mp, *nmp;
  474         int asyncflag;
  476         for (mp = CIRCLEQ_LAST(&mountlist); mp != CIRCLEQ_END(&mountlist);
mp = nmp) {
  478                 if (vfs_busy(mp, VB_READ|VB_NOWAIT)) {
nmp = CIRCLEQ_PREV(mp, mnt_list);
  480                         continue;
  481                 }
  482                 if ((mp->mnt_flag & MNT_RDONLY) == 0) {
asyncflag = mp->mnt_flag & MNT_ASYNC;
mp->mnt_flag &= ~MNT_ASYNC;
uvm_vnp_sync(mp);
VFS_SYNC(mp, MNT_NOWAIT, p->p_ucred, p);
  487                         if (asyncflag)
mp->mnt_flag |= MNT_ASYNC;
  489                 }
nmp = CIRCLEQ_PREV(mp, mnt_list);
vfs_unbusy(mp);
  492         }
  494 #ifdef DEBUG
  495         if (syncprt)
vfs_bufstats();
  497 #endif /* DEBUG */
  498         return (0);
  499 }
  501 /*
  502  * Change filesystem quotas.
  503  */
  504 /* ARGSUSED */
  505 int
sys_quotactl(struct proc *p, void *v, register_t *retval)
  507 {
  508         struct sys_quotactl_args /* {
  509                 syscallarg(const char *) path;
  510                 syscallarg(int) cmd;
  511                 syscallarg(int) uid;
  512                 syscallarg(char *) arg;
  513         } */ *uap = v;
  514         struct mount *mp;
  515         int error;
  516         struct nameidata nd;
NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p);
  519         if ((error = namei(&nd)) != 0)
  520                 return (error);
mp = nd.ni_vp->v_mount;
vrele(nd.ni_vp);
  523         return (VFS_QUOTACTL(mp, SCARG(uap, cmd), SCARG(uap, uid),
SCARG(uap, arg), p));
  525 }
  527 int
copyout_statfs(struct statfs *sp, void *uaddr, struct proc *p)
  529 {
size_t co_sz1 = offsetof(struct statfs, f_fsid);
size_t co_off2 = co_sz1 + sizeof(fsid_t);
size_t co_sz2 = sizeof(struct statfs) - co_off2;
  533         char *s, *d;
  534         int error;
  536         /* Don't let non-root see filesystem id (for NFS security) */
  537         if (suser(p, 0)) {
fsid_t fsid;
s = (char *)sp;
d = (char *)uaddr;
memset(&fsid, 0, sizeof(fsid));
  545                 if ((error = copyout(s, d, co_sz1)) != 0)
  546                         return (error);
  547                 if ((error = copyout(&fsid, d + co_sz1, sizeof(fsid))) != 0)
  548                         return (error);
  549                 return (copyout(s + co_off2, d + co_off2, co_sz2));
  550         }
  552         return (copyout(sp, uaddr, sizeof(*sp)));
  553 }
  555 /*
  556  * Get filesystem statistics.
  557  */
  558 /* ARGSUSED */
  559 int
sys_statfs(struct proc *p, void *v, register_t *retval)
  561 {
  562         struct sys_statfs_args /* {
  563                 syscallarg(const char *) path;
  564                 syscallarg(struct statfs *) buf;
  565         } */ *uap = v;
  566         struct mount *mp;
  567         struct statfs *sp;
  568         int error;
  569         struct nameidata nd;
NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p);
  572         if ((error = namei(&nd)) != 0)
  573                 return (error);
mp = nd.ni_vp->v_mount;
sp = &mp->mnt_stat;
vrele(nd.ni_vp);
  577         if ((error = VFS_STATFS(mp, sp, p)) != 0)
  578                 return (error);
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
  580 #if notyet
  581         if (mp->mnt_flag & MNT_SOFTDEP)
sp->f_eflags = STATFS_SOFTUPD;
  583 #endif
  584         return (copyout_statfs(sp, SCARG(uap, buf), p));
  585 }
  587 /*
  588  * Get filesystem statistics.
  589  */
  590 /* ARGSUSED */
  591 int
sys_fstatfs(struct proc *p, void *v, register_t *retval)
  593 {
  594         struct sys_fstatfs_args /* {
  595                 syscallarg(int) fd;
  596                 syscallarg(struct statfs *) buf;
  597         } */ *uap = v;
  598         struct file *fp;
  599         struct mount *mp;
  600         struct statfs *sp;
  601         int error;
  603         if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0)
  604                 return (error);
mp = ((struct vnode *)fp->f_data)->v_mount;
  606         if (!mp) {
FRELE(fp);
  608                 return (ENOENT);
  609         }
sp = &mp->mnt_stat;
error = VFS_STATFS(mp, sp, p);
FRELE(fp);
  613         if (error)
  614                 return (error);
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
  616 #if notyet
  617         if (mp->mnt_flag & MNT_SOFTDEP)
sp->f_eflags = STATFS_SOFTUPD;
  619 #endif
  620         return (copyout_statfs(sp, SCARG(uap, buf), p));
  621 }
  623 /*
  624  * Get statistics on all filesystems.
  625  */
  626 int
sys_getfsstat(struct proc *p, void *v, register_t *retval)
  628 {
  629         struct sys_getfsstat_args /* {
  630                 syscallarg(struct statfs *) buf;
  631                 syscallarg(size_t) bufsize;
  632                 syscallarg(int) flags;
  633         } */ *uap = v;
  634         struct mount *mp, *nmp;
  635         struct statfs *sp;
  636         struct statfs *sfsp;
size_t count, maxcount;
  638         int error, flags = SCARG(uap, flags);
maxcount = SCARG(uap, bufsize) / sizeof(struct statfs);
sfsp = SCARG(uap, buf);
count = 0;
  644         for (mp = CIRCLEQ_FIRST(&mountlist); mp != CIRCLEQ_END(&mountlist);
mp = nmp) {
  646                 if (vfs_busy(mp, VB_READ|VB_NOWAIT)) {
nmp = CIRCLEQ_NEXT(mp, mnt_list);
  648                         continue;
  649                 }
  650                 if (sfsp && count < maxcount) {
sp = &mp->mnt_stat;
  653                         /* Refresh stats unless MNT_NOWAIT is specified */
  654                         if (flags != MNT_NOWAIT &&
flags != MNT_LAZY &&
  656                             (flags == MNT_WAIT ||
flags == 0) &&
  658                             (error = VFS_STATFS(mp, sp, p))) {
nmp = CIRCLEQ_NEXT(mp, mnt_list);
vfs_unbusy(mp);
  661                                 continue;
  662                         }
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
  665 #if notyet
  666                         if (mp->mnt_flag & MNT_SOFTDEP)
sp->f_eflags = STATFS_SOFTUPD;
  668 #endif
error = (copyout_statfs(sp, sfsp, p));
  670                         if (error) {
vfs_unbusy(mp);
  672                                 return (error);
  673                         }
sfsp++;
  675                 }
count++;
nmp = CIRCLEQ_NEXT(mp, mnt_list);
vfs_unbusy(mp);
  679         }
  681         if (sfsp && count > maxcount)
  682                 *retval = maxcount;
  683         else
  684                 *retval = count;
  686         return (0);
  687 }
  689 /*
  690  * Change current working directory to a given file descriptor.
  691  */
  692 /* ARGSUSED */
  693 int
sys_fchdir(struct proc *p, void *v, register_t *retval)
  695 {
  696         struct sys_fchdir_args /* {
  697                 syscallarg(int) fd;
  698         } */ *uap = v;
  699         struct filedesc *fdp = p->p_fd;
  700         struct vnode *vp, *tdp;
  701         struct mount *mp;
  702         struct file *fp;
  703         int error;
  705         if ((error = getvnode(fdp, SCARG(uap, fd), &fp)) != 0)
  706                 return (error);
vp = (struct vnode *)fp->f_data;
VREF(vp);
FRELE(fp);
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
  711         if (vp->v_type != VDIR)
error = ENOTDIR;
  713         else
error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p);
  716         while (!error && (mp = vp->v_mountedhere) != NULL) {
  717                 if (vfs_busy(mp, VB_READ|VB_WAIT))
  718                         continue;
error = VFS_ROOT(mp, &tdp);
vfs_unbusy(mp);
  721                 if (error)
  722                         break;
vput(vp);
vp = tdp;
  725         }
  726         if (error) {
vput(vp);
  728                 return (error);
  729         }
VOP_UNLOCK(vp, 0, p);
vrele(fdp->fd_cdir);
fdp->fd_cdir = vp;
  733         return (0);
  734 }
  736 /*
  737  * Change current working directory (``.'').
  738  */
  739 /* ARGSUSED */
  740 int
sys_chdir(struct proc *p, void *v, register_t *retval)
  742 {
  743         struct sys_chdir_args /* {
  744                 syscallarg(const char *) path;
  745         } */ *uap = v;
  746         struct filedesc *fdp = p->p_fd;
  747         int error;
  748         struct nameidata nd;
NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
SCARG(uap, path), p);
  752         if ((error = change_dir(&nd, p)) != 0)
  753                 return (error);
vrele(fdp->fd_cdir);
fdp->fd_cdir = nd.ni_vp;
  756         return (0);
  757 }
  759 /*
  760  * Change notion of root (``/'') directory.
  761  */
  762 /* ARGSUSED */
  763 int
sys_chroot(struct proc *p, void *v, register_t *retval)
  765 {
  766         struct sys_chroot_args /* {
  767                 syscallarg(const char *) path;
  768         } */ *uap = v;
  769         struct filedesc *fdp = p->p_fd;
  770         int error;
  771         struct nameidata nd;
  773         if ((error = suser(p, 0)) != 0)
  774                 return (error);
NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
SCARG(uap, path), p);
  777         if ((error = change_dir(&nd, p)) != 0)
  778                 return (error);
  779         if (fdp->fd_rdir != NULL) {
  780                 /*
  781                  * A chroot() done inside a changed root environment does
  782                  * an automatic chdir to avoid the out-of-tree experience.
  783                  */
vrele(fdp->fd_rdir);
vrele(fdp->fd_cdir);
VREF(nd.ni_vp);
fdp->fd_cdir = nd.ni_vp;
  788         }
fdp->fd_rdir = nd.ni_vp;
  790         return (0);
  791 }
  793 /*
  794  * Common routine for chroot and chdir.
  795  */
  796 static int
change_dir(struct nameidata *ndp, struct proc *p)
  798 {
  799         struct vnode *vp;
  800         int error;
  802         if ((error = namei(ndp)) != 0)
  803                 return (error);
vp = ndp->ni_vp;
  805         if (vp->v_type != VDIR)
error = ENOTDIR;
  807         else
error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p);
  809         if (error)
vput(vp);
  811         else
VOP_UNLOCK(vp, 0, p);
  813         return (error);
  814 }
  816 /*
  817  * Check permissions, allocate an open file structure,
  818  * and call the device open routine if any.
  819  */
  820 int
sys_open(struct proc *p, void *v, register_t *retval)
  822 {
  823         struct sys_open_args /* {
  824                 syscallarg(const char *) path;
  825                 syscallarg(int) flags;
  826                 syscallarg(mode_t) mode;
  827         } */ *uap = v;
  828         struct filedesc *fdp = p->p_fd;
  829         struct file *fp;
  830         struct vnode *vp;
  831         struct vattr vattr;
  832         int flags, cmode;
  833         int type, indx, error, localtrunc = 0;
  834         struct flock lf;
  835         struct nameidata nd;
fdplock(fdp);
  839         if ((error = falloc(p, &fp, &indx)) != 0)
  840                 goto out;
flags = FFLAGS(SCARG(uap, flags));
cmode = ((SCARG(uap, mode) &~ fdp->fd_cmask) & ALLPERMS) &~ S_ISTXT;
NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p);
p->p_dupfd = -1;                        /* XXX check for fdopen */
  846         if ((flags & O_TRUNC) && (flags & (O_EXLOCK | O_SHLOCK))) {
localtrunc = 1;
flags &= ~O_TRUNC;      /* Must do truncate ourselves */
  849         }
  850         if ((error = vn_open(&nd, flags, cmode)) != 0) {
  851                 if ((error == ENODEV || error == ENXIO) &&
p->p_dupfd >= 0 &&                  /* XXX from fdopen */
  853                     (error =
dupfdopen(fdp, indx, p->p_dupfd, flags, error)) == 0) {
closef(fp, p);
  856                         *retval = indx;
  857                         goto out;
  858                 }
  859                 if (error == ERESTART)
error = EINTR;
fdremove(fdp, indx);
closef(fp, p);
  863                 goto out;
  864         }
p->p_dupfd = 0;
vp = nd.ni_vp;
fp->f_flag = flags & FMASK;
fp->f_type = DTYPE_VNODE;
fp->f_ops = &vnops;
fp->f_data = vp;
  871         if (flags & (O_EXLOCK | O_SHLOCK)) {
lf.l_whence = SEEK_SET;
lf.l_start = 0;
lf.l_len = 0;
  875                 if (flags & O_EXLOCK)
lf.l_type = F_WRLCK;
  877                 else
lf.l_type = F_RDLCK;
type = F_FLOCK;
  880                 if ((flags & FNONBLOCK) == 0)
type |= F_WAIT;
VOP_UNLOCK(vp, 0, p);
error = VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf, type);
  884                 if (error) {
  885                         /* closef will vn_close the file for us. */
fdremove(fdp, indx);
closef(fp, p);
  888                         goto out;
  889                 }
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
fp->f_flag |= FHASLOCK;
  892         }
  893         if (localtrunc) {
  894                 if ((fp->f_flag & FWRITE) == 0)
error = EACCES;
  896                 else if (vp->v_mount->mnt_flag & MNT_RDONLY)
error = EROFS;
  898                 else if (vp->v_type == VDIR)
error = EISDIR;
  900                 else if ((error = vn_writechk(vp)) == 0) {
VATTR_NULL(&vattr);
vattr.va_size = 0;
error = VOP_SETATTR(vp, &vattr, fp->f_cred, p);
  904                 }
  905                 if (error) {
VOP_UNLOCK(vp, 0, p);
  907                         /* closef will close the file for us. */
fdremove(fdp, indx);
closef(fp, p);
  910                         goto out;
  911                 }
  912         }
VOP_UNLOCK(vp, 0, p);
  914         *retval = indx;
FILE_SET_MATURE(fp);
out:
fdpunlock(fdp);
  918         return (error);
  919 }
  921 /*
  922  * Get file handle system call
  923  */
  924 int
sys_getfh(struct proc *p, void *v, register_t *retval)
  926 {
  927         struct sys_getfh_args /* {
  928                 syscallarg(const char *) fname;
  929                 syscallarg(fhandle_t *) fhp;
  930         } */ *uap = v;
  931         struct vnode *vp;
fhandle_t fh;
  933         int error;
  934         struct nameidata nd;
  936         /*
  937          * Must be super user
  938          */
error = suser(p, 0);
  940         if (error)
  941                 return (error);
NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
SCARG(uap, fname), p);
error = namei(&nd);
  945         if (error)
  946                 return (error);
vp = nd.ni_vp;
bzero(&fh, sizeof(fh));
fh.fh_fsid = vp->v_mount->mnt_stat.f_fsid;
error = VFS_VPTOFH(vp, &fh.fh_fid);
vput(vp);
  952         if (error)
  953                 return (error);
error = copyout(&fh, SCARG(uap, fhp), sizeof(fh));
  955         return (error);
  956 }
  958 /*
  959  * Open a file given a file handle.
  960  *
  961  * Check permissions, allocate an open file structure,
  962  * and call the device open routine if any.
  963  */
  964 int
sys_fhopen(struct proc *p, void *v, register_t *retval)
  966 {
  967         struct sys_fhopen_args /* {
  968                 syscallarg(const fhandle_t *) fhp;
  969                 syscallarg(int) flags;
  970         } */ *uap = v;
  971         struct filedesc *fdp = p->p_fd;
  972         struct file *fp;
  973         struct vnode *vp = NULL;
  974         struct mount *mp;
  975         struct ucred *cred = p->p_ucred;
  976         int flags;
  977         int type, indx, error=0;
  978         struct flock lf;
  979         struct vattr va;
fhandle_t fh;
  982         /*
  983          * Must be super user
  984          */
  985         if ((error = suser(p, 0)))
  986                 return (error);
flags = FFLAGS(SCARG(uap, flags));
  989         if ((flags & (FREAD | FWRITE)) == 0)
  990                 return (EINVAL);
  991         if ((flags & O_CREAT))
  992                 return (EINVAL);
fdplock(fdp);
  995         if ((error = falloc(p, &fp, &indx)) != 0) {
fp = NULL;
  997                 goto bad;
  998         }
 1000         if ((error = copyin(SCARG(uap, fhp), &fh, sizeof(fhandle_t))) != 0)
 1001                 goto bad;
 1003         if ((mp = vfs_getvfs(&fh.fh_fsid)) == NULL) {
error = ESTALE;
 1005                 goto bad;
 1006         }
 1008         if ((error = VFS_FHTOVP(mp, &fh.fh_fid, &vp)) != 0) {
vp = NULL;      /* most likely unnecessary sanity for bad: */
 1010                 goto bad;
 1011         }
 1013         /* Now do an effective vn_open */
 1015         if (vp->v_type == VSOCK) {
error = EOPNOTSUPP;
 1017                 goto bad;
 1018         }
 1019         if (flags & FREAD) {
 1020                 if ((error = VOP_ACCESS(vp, VREAD, cred, p)) != 0)
 1021                         goto bad;
 1022         }
 1023         if (flags & (FWRITE | O_TRUNC)) {
 1024                 if (vp->v_type == VDIR) {
error = EISDIR;
 1026                         goto bad;
 1027                 }
 1028                 if ((error = vn_writechk(vp)) != 0 ||
 1029                     (error = VOP_ACCESS(vp, VWRITE, cred, p)) != 0)
 1030                         goto bad;
 1031         }
 1032         if (flags & O_TRUNC) {
VATTR_NULL(&va);
va.va_size = 0;
 1035                 if ((error = VOP_SETATTR(vp, &va, cred, p)) != 0)
 1036                         goto bad;
 1037         }
 1038         if ((error = VOP_OPEN(vp, flags, cred, p)) != 0)
 1039                 goto bad;
 1040         if (flags & FWRITE)
vp->v_writecount++;
 1043         /* done with modified vn_open, now finish what sys_open does. */
fp->f_flag = flags & FMASK;
fp->f_type = DTYPE_VNODE;
fp->f_ops = &vnops;
fp->f_data = vp;
 1049         if (flags & (O_EXLOCK | O_SHLOCK)) {
lf.l_whence = SEEK_SET;
lf.l_start = 0;
lf.l_len = 0;
 1053                 if (flags & O_EXLOCK)
lf.l_type = F_WRLCK;
 1055                 else
lf.l_type = F_RDLCK;
type = F_FLOCK;
 1058                 if ((flags & FNONBLOCK) == 0)
type |= F_WAIT;
VOP_UNLOCK(vp, 0, p);
error = VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf, type);
 1062                 if (error)
 1063                         goto bad;
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
fp->f_flag |= FHASLOCK;
 1066         }
VOP_UNLOCK(vp, 0, p);
 1068         *retval = indx;
FILE_SET_MATURE(fp);
fdpunlock(fdp);
 1072         return (0);
bad:
 1075         if (fp) {
fdremove(fdp, indx);
closef(fp, p);
 1078                 if (vp != NULL)
vput(vp);
 1080         }
fdpunlock(fdp);
 1082         return (error);
 1083 }
 1085 /* ARGSUSED */
 1086 int
sys_fhstat(struct proc *p, void *v, register_t *retval)
 1088 {
 1089         struct sys_fhstat_args /* {
 1090                 syscallarg(const fhandle_t *) fhp;
 1091                 syscallarg(struct stat *) sb;
 1092         } */ *uap = v;
 1093         struct stat sb;
 1094         int error;
fhandle_t fh;
 1096         struct mount *mp;
 1097         struct vnode *vp;
 1099         /*
 1100          * Must be super user
 1101          */
 1102         if ((error = suser(p, 0)))
 1103                 return (error);
 1105         if ((error = copyin(SCARG(uap, fhp), &fh, sizeof(fhandle_t))) != 0)
 1106                 return (error);
 1108         if ((mp = vfs_getvfs(&fh.fh_fsid)) == NULL)
 1109                 return (ESTALE);
 1110         if ((error = VFS_FHTOVP(mp, &fh.fh_fid, &vp)))
 1111                 return (error);
error = vn_stat(vp, &sb, p);
vput(vp);
 1114         if (error)
 1115                 return (error);
error = copyout(&sb, SCARG(uap, sb), sizeof(sb));
 1117         return (error);
 1118 }
 1120 /* ARGSUSED */
 1121 int
sys_fhstatfs(struct proc *p, void *v, register_t *retval)
 1123 {
 1124         struct sys_fhstatfs_args /*
 1125                 syscallarg(const fhandle_t *) fhp;
 1126                 syscallarg(struct statfs *) buf;
 1127         } */ *uap = v;
 1128         struct statfs *sp;
fhandle_t fh;
 1130         struct mount *mp;
 1131         struct vnode *vp;
 1132         int error;
 1134         /*
 1135          * Must be super user
 1136          */
 1137         if ((error = suser(p, 0)))
 1138                 return (error);
 1140         if ((error = copyin(SCARG(uap, fhp), &fh, sizeof(fhandle_t))) != 0)
 1141                 return (error);
 1143         if ((mp = vfs_getvfs(&fh.fh_fsid)) == NULL)
 1144                 return (ESTALE);
 1145         if ((error = VFS_FHTOVP(mp, &fh.fh_fid, &vp)))
 1146                 return (error);
mp = vp->v_mount;
sp = &mp->mnt_stat;
vput(vp);
 1150         if ((error = VFS_STATFS(mp, sp, p)) != 0)
 1151                 return (error);
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
 1153         return (copyout(sp, SCARG(uap, buf), sizeof(sp)));
 1154 }
 1156 /*
 1157  * Create a special file.
 1158  */
 1159 /* ARGSUSED */
 1160 int
sys_mknod(struct proc *p, void *v, register_t *retval)
 1162 {
 1163         struct sys_mknod_args /* {
 1164                 syscallarg(const char *) path;
 1165                 syscallarg(mode_t) mode;
 1166                 syscallarg(int) dev;
 1167         } */ *uap = v;
 1168         struct vnode *vp;
 1169         struct vattr vattr;
 1170         int error;
 1171         struct nameidata nd;
 1173         if ((error = suser(p, 0)) != 0)
 1174                 return (error);
 1175         if (p->p_fd->fd_rdir)
 1176                 return (EINVAL);
NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, SCARG(uap, path), p);
 1178         if ((error = namei(&nd)) != 0)
 1179                 return (error);
vp = nd.ni_vp;
 1181         if (vp != NULL)
error = EEXIST;
 1183         else {
VATTR_NULL(&vattr);
vattr.va_mode = (SCARG(uap, mode) & ALLPERMS) &~ p->p_fd->fd_cmask;
vattr.va_rdev = SCARG(uap, dev);
 1188                 switch (SCARG(uap, mode) & S_IFMT) {
 1189                 case S_IFMT:    /* used by badsect to flag bad sectors */
vattr.va_type = VBAD;
 1191                         break;
 1192                 case S_IFCHR:
vattr.va_type = VCHR;
 1194                         break;
 1195                 case S_IFBLK:
vattr.va_type = VBLK;
 1197                         break;
 1198                 default:
error = EINVAL;
 1200                         break;
 1201                 }
 1202         }
 1203         if (!error) {
error = VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr);
 1205         } else {
VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
 1207                 if (nd.ni_dvp == vp)
vrele(nd.ni_dvp);
 1209                 else
vput(nd.ni_dvp);
 1211                 if (vp)
vrele(vp);
 1213         }
 1214         return (error);
 1215 }
 1217 /*
 1218  * Create a named pipe.
 1219  */
 1220 /* ARGSUSED */
 1221 int
sys_mkfifo(struct proc *p, void *v, register_t *retval)
 1223 {
 1224 #ifndef FIFO
 1225         return (EOPNOTSUPP);
 1226 #else
 1227         struct sys_mkfifo_args /* {
 1228                 syscallarg(const char *) path;
 1229                 syscallarg(mode_t) mode;
 1230         } */ *uap = v;
 1231         struct vattr vattr;
 1232         int error;
 1233         struct nameidata nd;
NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, SCARG(uap, path), p);
 1236         if ((error = namei(&nd)) != 0)
 1237                 return (error);
 1238         if (nd.ni_vp != NULL) {
VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
 1240                 if (nd.ni_dvp == nd.ni_vp)
vrele(nd.ni_dvp);
 1242                 else
vput(nd.ni_dvp);
vrele(nd.ni_vp);
 1245                 return (EEXIST);
 1246         }
VATTR_NULL(&vattr);
vattr.va_type = VFIFO;
vattr.va_mode = (SCARG(uap, mode) & ALLPERMS) &~ p->p_fd->fd_cmask;
 1250         return (VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr));
 1251 #endif /* FIFO */
 1252 }
 1254 /*
 1255  * Make a hard file link.
 1256  */
 1257 /* ARGSUSED */
 1258 int
sys_link(struct proc *p, void *v, register_t *retval)
 1260 {
 1261         struct sys_link_args /* {
 1262                 syscallarg(const char *) path;
 1263                 syscallarg(const char *) link;
 1264         } */ *uap = v;
 1265         struct vnode *vp;
 1266         struct nameidata nd;
 1267         int error;
 1268         int flags;
NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p);
 1271         if ((error = namei(&nd)) != 0)
 1272                 return (error);
vp = nd.ni_vp;
flags = LOCKPARENT;
 1276         if (vp->v_type == VDIR) {
flags |= STRIPSLASHES;
 1278         }
NDINIT(&nd, CREATE, flags, UIO_USERSPACE, SCARG(uap, link), p);
 1281         if ((error = namei(&nd)) != 0)
 1282                 goto out;
 1283         if (nd.ni_vp) {
VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
 1285                 if (nd.ni_dvp == nd.ni_vp)
vrele(nd.ni_dvp);
 1287                 else
vput(nd.ni_dvp);
vrele(nd.ni_vp);
error = EEXIST;
 1291                 goto out;
 1292         }
error = VOP_LINK(nd.ni_dvp, vp, &nd.ni_cnd);
out:
vrele(vp);
 1296         return (error);
 1297 }
 1299 /*
 1300  * Make a symbolic link.
 1301  */
 1302 /* ARGSUSED */
 1303 int
sys_symlink(struct proc *p, void *v, register_t *retval)
 1305 {
 1306         struct sys_symlink_args /* {
 1307                 syscallarg(const char *) path;
 1308                 syscallarg(const char *) link;
 1309         } */ *uap = v;
 1310         struct vattr vattr;
 1311         char *path;
 1312         int error;
 1313         struct nameidata nd;
path = pool_get(&namei_pool, PR_WAITOK);
error = copyinstr(SCARG(uap, path), path, MAXPATHLEN, NULL);
 1317         if (error)
 1318                 goto out;
NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, SCARG(uap, link), p);
 1320         if ((error = namei(&nd)) != 0)
 1321                 goto out;
 1322         if (nd.ni_vp) {
VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
 1324                 if (nd.ni_dvp == nd.ni_vp)
vrele(nd.ni_dvp);
 1326                 else
vput(nd.ni_dvp);
vrele(nd.ni_vp);
error = EEXIST;
 1330                 goto out;
 1331         }
VATTR_NULL(&vattr);
vattr.va_mode = ACCESSPERMS &~ p->p_fd->fd_cmask;
error = VOP_SYMLINK(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr, path);
out:
pool_put(&namei_pool, path);
 1337         return (error);
 1338 }
 1340 /*
 1341  * Delete a name from the filesystem.
 1342  */
 1343 /* ARGSUSED */
 1344 int
sys_unlink(struct proc *p, void *v, register_t *retval)
 1346 {
 1347         struct sys_unlink_args /* {
 1348                 syscallarg(const char *) path;
 1349         } */ *uap = v;
 1350         struct vnode *vp;
 1351         int error;
 1352         struct nameidata nd;
NDINIT(&nd, DELETE, LOCKPARENT | LOCKLEAF, UIO_USERSPACE,
SCARG(uap, path), p);
 1356         if ((error = namei(&nd)) != 0)
 1357                 return (error);
vp = nd.ni_vp;
 1360         /*
 1361          * The root of a mounted filesystem cannot be deleted.
 1362          */
 1363         if (vp->v_flag & VROOT) {
VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
 1365                 if (nd.ni_dvp == vp)
vrele(nd.ni_dvp);
 1367                 else
vput(nd.ni_dvp);
vput(vp);
error = EBUSY;
 1371                 goto out;
 1372         }
 1374         (void)uvm_vnp_uncache(vp);
error = VOP_REMOVE(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd);
out:
 1378         return (error);
 1379 }
 1381 /*
 1382  * Reposition read/write file offset.
 1383  */
 1384 int
sys_lseek(struct proc *p, void *v, register_t *retval)
 1386 {
 1387         struct sys_lseek_args /* {
 1388                 syscallarg(int) fd;
 1389                 syscallarg(int) pad;
 1390                 syscallarg(off_t) offset;
 1391                 syscallarg(int) whence;
 1392         } */ *uap = v;
 1393         struct ucred *cred = p->p_ucred;
 1394         struct filedesc *fdp = p->p_fd;
 1395         struct file *fp;
 1396         struct vattr vattr;
 1397         struct vnode *vp;
off_t offarg, newoff;
 1399         int error, special;
 1401         if ((fp = fd_getfile(fdp, SCARG(uap, fd))) == NULL)
 1402                 return (EBADF);
 1403         if (fp->f_type != DTYPE_VNODE)
 1404                 return (ESPIPE);
vp = (struct vnode *)fp->f_data;
 1406         if (vp->v_type == VFIFO)
 1407                 return (ESPIPE);
 1408         if (vp->v_type == VCHR)
special = 1;
 1410         else
special = 0;
offarg = SCARG(uap, offset);
 1414         switch (SCARG(uap, whence)) {
 1415         case SEEK_CUR:
newoff = fp->f_offset + offarg;;
 1417                 break;
 1418         case SEEK_END:
error = VOP_GETATTR((struct vnode *)fp->f_data, &vattr,
cred, p);
 1421                 if (error)
 1422                         return (error);
newoff = offarg + (off_t)vattr.va_size;
 1424                 break;
 1425         case SEEK_SET:
newoff = offarg;
 1427                 break;
 1428         default:
 1429                 return (EINVAL);
 1430         }
 1431         if (!special) {
 1432                 if (newoff < 0)
 1433                         return (EINVAL);
 1434         } else {
 1435                 /*
 1436                  * Make sure the user don't seek beyond the end of the
 1437                  * partition.
 1438                  */
 1439                 struct partinfo dpart;
error = vn_ioctl(fp, DIOCGPART, (void *)&dpart, p);
 1441                 if (!error) {
 1442                         if (newoff >= DL_GETPSIZE(dpart.part) *
dpart.disklab->d_secsize)
 1444                                         return (EINVAL);
 1445                 }
 1446         }
 1447         *(off_t *)retval = fp->f_offset = newoff;
fp->f_seek++;
 1449         return (0);
 1450 }
 1452 /*
 1453  * Check access permissions.
 1454  */
 1455 int
sys_access(struct proc *p, void *v, register_t *retval)
 1457 {
 1458         struct sys_access_args /* {
 1459                 syscallarg(const char *) path;
 1460                 syscallarg(int) flags;
 1461         } */ *uap = v;
 1462         struct ucred *cred = p->p_ucred;
 1463         struct vnode *vp;
 1464         int error, flags, t_gid, t_uid;
 1465         struct nameidata nd;
 1467         if (SCARG(uap, flags) & ~(R_OK | W_OK | X_OK))
 1468                 return (EINVAL);
t_uid = cred->cr_uid;
t_gid = cred->cr_gid;
cred->cr_uid = p->p_cred->p_ruid;
cred->cr_gid = p->p_cred->p_rgid;
NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
SCARG(uap, path), p);
 1475         if ((error = namei(&nd)) != 0)
 1476                 goto out1;
vp = nd.ni_vp;
 1479         /* Flags == 0 means only check for existence. */
 1480         if (SCARG(uap, flags)) {
flags = 0;
 1482                 if (SCARG(uap, flags) & R_OK)
flags |= VREAD;
 1484                 if (SCARG(uap, flags) & W_OK)
flags |= VWRITE;
 1486                 if (SCARG(uap, flags) & X_OK)
flags |= VEXEC;
 1488                 if ((flags & VWRITE) == 0 || (error = vn_writechk(vp)) == 0)
error = VOP_ACCESS(vp, flags, cred, p);
 1490         }
vput(vp);
out1:
cred->cr_uid = t_uid;
cred->cr_gid = t_gid;
 1495         return (error);
 1496 }
 1498 /*
 1499  * Get file status; this version follows links.
 1500  */
 1501 /* ARGSUSED */
 1502 int
sys_stat(struct proc *p, void *v, register_t *retval)
 1504 {
 1505         struct sys_stat_args /* {
 1506                 syscallarg(const char *) path;
 1507                 syscallarg(struct stat *) ub;
 1508         } */ *uap = v;
 1509         struct stat sb;
 1510         int error;
 1511         struct nameidata nd;
NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
SCARG(uap, path), p);
 1515         if ((error = namei(&nd)) != 0)
 1516                 return (error);
error = vn_stat(nd.ni_vp, &sb, p);
vput(nd.ni_vp);
 1519         if (error)
 1520                 return (error);
 1521         /* Don't let non-root see generation numbers (for NFS security) */
 1522         if (suser(p, 0))
sb.st_gen = 0;
error = copyout(&sb, SCARG(uap, ub), sizeof(sb));
 1525         return (error);
 1526 }
 1528 /*
 1529  * Get file status; this version does not follow links.
 1530  */
 1531 /* ARGSUSED */
 1532 int
sys_lstat(struct proc *p, void *v, register_t *retval)
 1534 {
 1535         struct sys_lstat_args /* {
 1536                 syscallarg(const char *) path;
 1537                 syscallarg(struct stat *) ub;
 1538         } */ *uap = v;
 1539         struct stat sb;
 1540         int error;
 1541         struct nameidata nd;
NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF, UIO_USERSPACE,
SCARG(uap, path), p);
 1545         if ((error = namei(&nd)) != 0)
 1546                 return (error);
error = vn_stat(nd.ni_vp, &sb, p);
vput(nd.ni_vp);
 1549         if (error)
 1550                 return (error);
 1551         /* Don't let non-root see generation numbers (for NFS security) */
 1552         if (suser(p, 0))
sb.st_gen = 0;
error = copyout(&sb, SCARG(uap, ub), sizeof(sb));
 1555         return (error);
 1556 }
 1558 /*
 1559  * Get configurable pathname variables.
 1560  */
 1561 /* ARGSUSED */
 1562 int
sys_pathconf(struct proc *p, void *v, register_t *retval)
 1564 {
 1565         struct sys_pathconf_args /* {
 1566                 syscallarg(const char *) path;
 1567                 syscallarg(int) name;
 1568         } */ *uap = v;
 1569         int error;
 1570         struct nameidata nd;
NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
SCARG(uap, path), p);
 1574         if ((error = namei(&nd)) != 0)
 1575                 return (error);
error = VOP_PATHCONF(nd.ni_vp, SCARG(uap, name), retval);
vput(nd.ni_vp);
 1578         return (error);
 1579 }
 1581 /*
 1582  * Return target name of a symbolic link.
 1583  */
 1584 /* ARGSUSED */
 1585 int
sys_readlink(struct proc *p, void *v, register_t *retval)
 1587 {
 1588         struct sys_readlink_args /* {
 1589                 syscallarg(const char *) path;
 1590                 syscallarg(char *) buf;
 1591                 syscallarg(size_t) count;
 1592         } */ *uap = v;
 1593         struct vnode *vp;
 1594         struct iovec aiov;
 1595         struct uio auio;
 1596         int error;
 1597         struct nameidata nd;
NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF, UIO_USERSPACE,
SCARG(uap, path), p);
 1601         if ((error = namei(&nd)) != 0)
 1602                 return (error);
vp = nd.ni_vp;
 1604         if (vp->v_type != VLNK)
error = EINVAL;
 1606         else {
aiov.iov_base = SCARG(uap, buf);
aiov.iov_len = SCARG(uap, count);
auio.uio_iov = &aiov;
auio.uio_iovcnt = 1;
auio.uio_offset = 0;
auio.uio_rw = UIO_READ;
auio.uio_segflg = UIO_USERSPACE;
auio.uio_procp = p;
auio.uio_resid = SCARG(uap, count);
error = VOP_READLINK(vp, &auio, p->p_ucred);
 1617         }
vput(vp);
 1619         *retval = SCARG(uap, count) - auio.uio_resid;
 1620         return (error);
 1621 }
 1623 /*
 1624  * Change flags of a file given a path name.
 1625  */
 1626 /* ARGSUSED */
 1627 int
sys_chflags(struct proc *p, void *v, register_t *retval)
 1629 {
 1630         struct sys_chflags_args /* {
 1631                 syscallarg(const char *) path;
 1632                 syscallarg(u_int) flags;
 1633         } */ *uap = v;
 1634         struct vnode *vp;
 1635         struct vattr vattr;
 1636         int error;
 1637         struct nameidata nd;
NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p);
 1640         if ((error = namei(&nd)) != 0)
 1641                 return (error);
vp = nd.ni_vp;
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
 1644         if (vp->v_mount->mnt_flag & MNT_RDONLY)
error = EROFS;
 1646         else if (SCARG(uap, flags) == VNOVAL)
error = EINVAL;
 1648         else {
 1649                 if (suser(p, 0)) {
 1650                         if ((error = VOP_GETATTR(vp, &vattr, p->p_ucred, p)) != 0)
 1651                                 goto out;
 1652                         if (vattr.va_type == VCHR || vattr.va_type == VBLK) {
error = EINVAL;
 1654                                 goto out;
 1655                         }
 1656                 }
VATTR_NULL(&vattr);
vattr.va_flags = SCARG(uap, flags);
error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
 1660         }
out:
vput(vp);
 1663         return (error);
 1664 }
 1666 /*
 1667  * Change flags of a file given a file descriptor.
 1668  */
 1669 /* ARGSUSED */
 1670 int
sys_fchflags(struct proc *p, void *v, register_t *retval)
 1672 {
 1673         struct sys_fchflags_args /* {
 1674                 syscallarg(int) fd;
 1675                 syscallarg(u_int) flags;
 1676         } */ *uap = v;
 1677         struct vattr vattr;
 1678         struct vnode *vp;
 1679         struct file *fp;
 1680         int error;
 1682         if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0)
 1683                 return (error);
vp = (struct vnode *)fp->f_data;
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
 1686         if (vp->v_mount && vp->v_mount->mnt_flag & MNT_RDONLY)
error = EROFS;
 1688         else if (SCARG(uap, flags) == VNOVAL)
error = EINVAL;
 1690         else {
 1691                 if (suser(p, 0)) {
 1692                         if ((error = VOP_GETATTR(vp, &vattr, p->p_ucred, p))
 1693                             != 0)
 1694                                 goto out;
 1695                         if (vattr.va_type == VCHR || vattr.va_type == VBLK) {
error = EINVAL;
 1697                                 goto out;
 1698                         }
 1699                 }
VATTR_NULL(&vattr);
vattr.va_flags = SCARG(uap, flags);
error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
 1703         }
out:
VOP_UNLOCK(vp, 0, p);
FRELE(fp);
 1707         return (error);
 1708 }
 1710 /*
 1711  * Change mode of a file given path name.
 1712  */
 1713 /* ARGSUSED */
 1714 int
sys_chmod(struct proc *p, void *v, register_t *retval)
 1716 {
 1717         struct sys_chmod_args /* {
 1718                 syscallarg(const char *) path;
 1719                 syscallarg(mode_t) mode;
 1720         } */ *uap = v;
 1721         struct vnode *vp;
 1722         struct vattr vattr;
 1723         int error;
 1724         struct nameidata nd;
 1726         if (SCARG(uap, mode) & ~(S_IFMT | ALLPERMS))
 1727                 return (EINVAL);
NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p);
 1730         if ((error = namei(&nd)) != 0)
 1731                 return (error);
vp = nd.ni_vp;
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
 1734         if (vp->v_mount->mnt_flag & MNT_RDONLY)
error = EROFS;
 1736         else {
VATTR_NULL(&vattr);
vattr.va_mode = SCARG(uap, mode) & ALLPERMS;
error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
 1740         }
vput(vp);
 1742         return (error);
 1743 }
 1745 /*
 1746  * Change mode of a file given a file descriptor.
 1747  */
 1748 /* ARGSUSED */
 1749 int
sys_fchmod(struct proc *p, void *v, register_t *retval)
 1751 {
 1752         struct sys_fchmod_args /* {
 1753                 syscallarg(int) fd;
 1754                 syscallarg(mode_t) mode;
 1755         } */ *uap = v;
 1756         struct vattr vattr;
 1757         struct vnode *vp;
 1758         struct file *fp;
 1759         int error;
 1761         if (SCARG(uap, mode) & ~(S_IFMT | ALLPERMS))
 1762                 return (EINVAL);
 1764         if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0)
 1765                 return (error);
vp = (struct vnode *)fp->f_data;
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
 1768         if (vp->v_mount && vp->v_mount->mnt_flag & MNT_RDONLY)
error = EROFS;
 1770         else {
VATTR_NULL(&vattr);
vattr.va_mode = SCARG(uap, mode) & ALLPERMS;
error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
 1774         }
VOP_UNLOCK(vp, 0, p);
FRELE(fp);
 1777         return (error);
 1778 }
 1780 /*
 1781  * Set ownership given a path name.
 1782  */
 1783 /* ARGSUSED */
 1784 int
sys_chown(struct proc *p, void *v, register_t *retval)
 1786 {
 1787         struct sys_chown_args /* {
 1788                 syscallarg(const char *) path;
 1789                 syscallarg(uid_t) uid;
 1790                 syscallarg(gid_t) gid;
 1791         } */ *uap = v;
 1792         struct vnode *vp;
 1793         struct vattr vattr;
 1794         int error;
 1795         struct nameidata nd;
mode_t mode;
NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p);
 1799         if ((error = namei(&nd)) != 0)
 1800                 return (error);
vp = nd.ni_vp;
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
 1803         if (vp->v_mount->mnt_flag & MNT_RDONLY)
error = EROFS;
 1805         else {
 1806                 if ((SCARG(uap, uid) != -1 || SCARG(uap, gid) != -1) &&
 1807                     (suser(p, 0) || suid_clear)) {
error = VOP_GETATTR(vp, &vattr, p->p_ucred, p);
 1809                         if (error)
 1810                                 goto out;
mode = vattr.va_mode & ~(VSUID | VSGID);
 1812                         if (mode == vattr.va_mode)
mode = VNOVAL;
 1814                 }
 1815                 else
mode = VNOVAL;
VATTR_NULL(&vattr);
vattr.va_uid = SCARG(uap, uid);
vattr.va_gid = SCARG(uap, gid);
vattr.va_mode = mode;
error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
 1822         }
out:
vput(vp);
 1825         return (error);
 1826 }
 1828 /*
 1829  * Set ownership given a path name, without following links.
 1830  */
 1831 /* ARGSUSED */
 1832 int
sys_lchown(struct proc *p, void *v, register_t *retval)
 1834 {
 1835         struct sys_lchown_args /* {
 1836                 syscallarg(const char *) path;
 1837                 syscallarg(uid_t) uid;
 1838                 syscallarg(gid_t) gid;
 1839         } */ *uap = v;
 1840         struct vnode *vp;
 1841         struct vattr vattr;
 1842         int error;
 1843         struct nameidata nd;
mode_t mode;
NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, SCARG(uap, path), p);
 1847         if ((error = namei(&nd)) != 0)
 1848                 return (error);
vp = nd.ni_vp;
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
 1851         if (vp->v_mount->mnt_flag & MNT_RDONLY)
error = EROFS;
 1853         else {
 1854                 if ((SCARG(uap, uid) != -1 || SCARG(uap, gid) != -1) &&
 1855                     (suser(p, 0) || suid_clear)) {
error = VOP_GETATTR(vp, &vattr, p->p_ucred, p);
 1857                         if (error)
 1858                                 goto out;
mode = vattr.va_mode & ~(VSUID | VSGID);
 1860                         if (mode == vattr.va_mode)
mode = VNOVAL;
 1862                 }
 1863                 else
mode = VNOVAL;
VATTR_NULL(&vattr);
vattr.va_uid = SCARG(uap, uid);
vattr.va_gid = SCARG(uap, gid);
vattr.va_mode = mode;
error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
 1870         }
out:
vput(vp);
 1873         return (error);
 1874 }
 1876 /*
 1877  * Set ownership given a file descriptor.
 1878  */
 1879 /* ARGSUSED */
 1880 int
sys_fchown(struct proc *p, void *v, register_t *retval)
 1882 {
 1883         struct sys_fchown_args /* {
 1884                 syscallarg(int) fd;
 1885                 syscallarg(uid_t) uid;
 1886                 syscallarg(gid_t) gid;
 1887         } */ *uap = v;
 1888         struct vnode *vp;
 1889         struct vattr vattr;
 1890         int error;
 1891         struct file *fp;
mode_t mode;
 1894         if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0)
 1895                 return (error);
vp = (struct vnode *)fp->f_data;
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
 1898         if (vp->v_mount->mnt_flag & MNT_RDONLY)
error = EROFS;
 1900         else {
 1901                 if ((SCARG(uap, uid) != -1 || SCARG(uap, gid) != -1) &&
 1902                     (suser(p, 0) || suid_clear)) {
error = VOP_GETATTR(vp, &vattr, p->p_ucred, p);
 1904                         if (error)
 1905                                 goto out;
mode = vattr.va_mode & ~(VSUID | VSGID);
 1907                         if (mode == vattr.va_mode)
mode = VNOVAL;
 1909                 } else
mode = VNOVAL;
VATTR_NULL(&vattr);
vattr.va_uid = SCARG(uap, uid);
vattr.va_gid = SCARG(uap, gid);
vattr.va_mode = mode;
error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
 1916         }
out:
VOP_UNLOCK(vp, 0, p);
FRELE(fp);
 1920         return (error);
 1921 }
 1923 /*
 1924  * Set the access and modification times given a path name.
 1925  */
 1926 /* ARGSUSED */
 1927 int
sys_utimes(struct proc *p, void *v, register_t *retval)
 1929 {
 1930         struct sys_utimes_args /* {
 1931                 syscallarg(const char *) path;
 1932                 syscallarg(const struct timeval *) tptr;
 1933         } */ *uap = v;
 1934         struct vnode *vp;
 1935         struct timeval tv[2];
 1936         struct vattr vattr;
 1937         int error;
 1938         struct nameidata nd;
VATTR_NULL(&vattr);
 1941         if (SCARG(uap, tptr) == NULL) {
microtime(&tv[0]);
tv[1] = tv[0];
vattr.va_vaflags |= VA_UTIMES_NULL;
 1945         } else {
error = copyin(SCARG(uap, tptr), tv,
 1947                     sizeof(tv));
 1948                 if (error)
 1949                         return (error);
 1950                 /* XXX workaround timeval matching the VFS constant VNOVAL */
 1951                 if (tv[0].tv_sec == VNOVAL)
tv[0].tv_sec = VNOVAL - 1;
 1953                 if (tv[1].tv_sec == VNOVAL)
tv[1].tv_sec = VNOVAL - 1;
 1955         }
NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p);
 1957         if ((error = namei(&nd)) != 0)
 1958                 return (error);
vp = nd.ni_vp;
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
 1961         if (vp->v_mount->mnt_flag & MNT_RDONLY)
error = EROFS;
 1963         else {
vattr.va_atime.tv_sec = tv[0].tv_sec;
vattr.va_atime.tv_nsec = tv[0].tv_usec * 1000;
vattr.va_mtime.tv_sec = tv[1].tv_sec;
vattr.va_mtime.tv_nsec = tv[1].tv_usec * 1000;
error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
 1969         }
vput(vp);
 1971         return (error);
 1972 }
 1974 /*
 1975  * Set the access and modification times given a file descriptor.
 1976  */
 1977 /* ARGSUSED */
 1978 int
sys_futimes(struct proc *p, void *v, register_t *retval)
 1980 {
 1981         struct sys_futimes_args /* {
 1982                 syscallarg(int) fd;
 1983                 syscallarg(const struct timeval *) tptr;
 1984         } */ *uap = v;
 1985         struct vnode *vp;
 1986         struct timeval tv[2];
 1987         struct vattr vattr;
 1988         int error;
 1989         struct file *fp;
VATTR_NULL(&vattr);
 1992         if (SCARG(uap, tptr) == NULL) {
microtime(&tv[0]);
tv[1] = tv[0];
vattr.va_vaflags |= VA_UTIMES_NULL;
 1996         } else {
error = copyin(SCARG(uap, tptr), tv,
 1998                     sizeof(tv));
 1999                 if (error)
 2000                         return (error);
 2001                 /* XXX workaround timeval matching the VFS constant VNOVAL */
 2002                 if (tv[0].tv_sec == VNOVAL)
tv[0].tv_sec = VNOVAL - 1;
 2004                 if (tv[1].tv_sec == VNOVAL)
tv[1].tv_sec = VNOVAL - 1;
 2006         }
 2007         if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0)
 2008                 return (error);
vp = (struct vnode *)fp->f_data;
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
 2011         if (vp->v_mount && vp->v_mount->mnt_flag & MNT_RDONLY)
error = EROFS;
 2013         else {
vattr.va_atime.tv_sec = tv[0].tv_sec;
vattr.va_atime.tv_nsec = tv[0].tv_usec * 1000;
vattr.va_mtime.tv_sec = tv[1].tv_sec;
vattr.va_mtime.tv_nsec = tv[1].tv_usec * 1000;
error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
 2019         }
VOP_UNLOCK(vp, 0, p);
FRELE(fp);
 2022         return (error);
 2023 }
 2025 /*
 2026  * Truncate a file given its path name.
 2027  */
 2028 /* ARGSUSED */
 2029 int
sys_truncate(struct proc *p, void *v, register_t *retval)
 2031 {
 2032         struct sys_truncate_args /* {
 2033                 syscallarg(const char *) path;
 2034                 syscallarg(int) pad;
 2035                 syscallarg(off_t) length;
 2036         } */ *uap = v;
 2037         struct vnode *vp;
 2038         struct vattr vattr;
 2039         int error;
 2040         struct nameidata nd;
NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p);
 2043         if ((error = namei(&nd)) != 0)
 2044                 return (error);
vp = nd.ni_vp;
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
 2047         if (vp->v_type == VDIR)
error = EISDIR;
 2049         else if ((error = vn_writechk(vp)) == 0 &&
 2050             (error = VOP_ACCESS(vp, VWRITE, p->p_ucred, p)) == 0) {
VATTR_NULL(&vattr);
vattr.va_size = SCARG(uap, length);
error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
 2054         }
vput(vp);
 2056         return (error);
 2057 }
 2059 /*
 2060  * Truncate a file given a file descriptor.
 2061  */
 2062 /* ARGSUSED */
 2063 int
sys_ftruncate(struct proc *p, void *v, register_t *retval)
 2065 {
 2066         struct sys_ftruncate_args /* {
 2067                 syscallarg(int) fd;
 2068                 syscallarg(int) pad;
 2069                 syscallarg(off_t) length;
 2070         } */ *uap = v;
 2071         struct vattr vattr;
 2072         struct vnode *vp;
 2073         struct file *fp;
off_t len;
 2075         int error;
 2077         if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0)
 2078                 return (error);
len = SCARG(uap, length);
 2080         if ((fp->f_flag & FWRITE) == 0 || len < 0) {
error = EINVAL;
 2082                 goto bad;
 2083         }
vp = (struct vnode *)fp->f_data;
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
 2086         if (vp->v_type == VDIR)
error = EISDIR;
 2088         else if ((error = vn_writechk(vp)) == 0) {
VATTR_NULL(&vattr);
vattr.va_size = len;
error = VOP_SETATTR(vp, &vattr, fp->f_cred, p);
 2092         }
VOP_UNLOCK(vp, 0, p);
bad:
FRELE(fp);
 2096         return (error);
 2097 }
 2099 /*
 2100  * Sync an open file.
 2101  */
 2102 /* ARGSUSED */
 2103 int
sys_fsync(struct proc *p, void *v, register_t *retval)
 2105 {
 2106         struct sys_fsync_args /* {
 2107                 syscallarg(int) fd;
 2108         } */ *uap = v;
 2109         struct vnode *vp;
 2110         struct file *fp;
 2111         int error;
 2113         if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0)
 2114                 return (error);
vp = (struct vnode *)fp->f_data;
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
error = VOP_FSYNC(vp, fp->f_cred, MNT_WAIT, p);
 2118 #ifdef FFS_SOFTUPDATES
 2119         if (error == 0 && vp->v_mount && (vp->v_mount->mnt_flag & MNT_SOFTDEP))
error = softdep_fsync(vp);
 2121 #endif
VOP_UNLOCK(vp, 0, p);
FRELE(fp);
 2125         return (error);
 2126 }
 2128 /*
 2129  * Rename files.  Source and destination must either both be directories,
 2130  * or both not be directories.  If target is a directory, it must be empty.
 2131  */
 2132 /* ARGSUSED */
 2133 int
sys_rename(struct proc *p, void *v, register_t *retval)
 2135 {
 2136         struct sys_rename_args /* {
 2137                 syscallarg(const char *) from;
 2138                 syscallarg(const char *) to;
 2139         } */ *uap = v;
 2140         struct vnode *tvp, *fvp, *tdvp;
 2141         struct nameidata fromnd, tond;
 2142         int error;
 2143         int flags;
NDINIT(&fromnd, DELETE, WANTPARENT | SAVESTART, UIO_USERSPACE,
SCARG(uap, from), p);
 2147         if ((error = namei(&fromnd)) != 0)
 2148                 return (error);
fvp = fromnd.ni_vp;
flags = LOCKPARENT | LOCKLEAF | NOCACHE | SAVESTART;
 2152         /*
 2153          * rename("foo/", "bar/");  is  OK
 2154          */
 2155         if (fvp->v_type == VDIR)
flags |= STRIPSLASHES;
NDINIT(&tond, RENAME, flags,
UIO_USERSPACE, SCARG(uap, to), p);
 2160         if ((error = namei(&tond)) != 0) {
VOP_ABORTOP(fromnd.ni_dvp, &fromnd.ni_cnd);
vrele(fromnd.ni_dvp);
vrele(fvp);
 2164                 goto out1;
 2165         }
tdvp = tond.ni_dvp;
tvp = tond.ni_vp;
 2168         if (tvp != NULL) {
 2169                 if (fvp->v_type == VDIR && tvp->v_type != VDIR) {
error = ENOTDIR;
 2171                         goto out;
 2172                 } else if (fvp->v_type != VDIR && tvp->v_type == VDIR) {
error = EISDIR;
 2174                         goto out;
 2175                 }
 2176         }
 2177         if (fvp == tdvp)
error = EINVAL;
 2179         /*
 2180          * If source is the same as the destination (that is the
 2181          * same inode number)
 2182          */
 2183         if (fvp == tvp)
error = -1;
out:
 2186         if (!error) {
 2187                 if (tvp) {
 2188                         (void)uvm_vnp_uncache(tvp);
 2189                 }
error = VOP_RENAME(fromnd.ni_dvp, fromnd.ni_vp, &fromnd.ni_cnd,
tond.ni_dvp, tond.ni_vp, &tond.ni_cnd);
 2192         } else {
VOP_ABORTOP(tond.ni_dvp, &tond.ni_cnd);
 2194                 if (tdvp == tvp)
vrele(tdvp);
 2196                 else
vput(tdvp);
 2198                 if (tvp)
vput(tvp);
VOP_ABORTOP(fromnd.ni_dvp, &fromnd.ni_cnd);
vrele(fromnd.ni_dvp);
vrele(fvp);
 2203         }
vrele(tond.ni_startdir);
pool_put(&namei_pool, tond.ni_cnd.cn_pnbuf);
out1:
 2207         if (fromnd.ni_startdir)
vrele(fromnd.ni_startdir);
pool_put(&namei_pool, fromnd.ni_cnd.cn_pnbuf);
 2210         if (error == -1)
 2211                 return (0);
 2212         return (error);
 2213 }
 2215 /*
 2216  * Make a directory file.
 2217  */
 2218 /* ARGSUSED */
 2219 int
sys_mkdir(struct proc *p, void *v, register_t *retval)
 2221 {
 2222         struct sys_mkdir_args /* {
 2223                 syscallarg(const char *) path;
 2224                 syscallarg(mode_t) mode;
 2225         } */ *uap = v;
 2226         struct vnode *vp;
 2227         struct vattr vattr;
 2228         int error;
 2229         struct nameidata nd;
NDINIT(&nd, CREATE, LOCKPARENT | STRIPSLASHES,
UIO_USERSPACE, SCARG(uap, path), p);
 2233         if ((error = namei(&nd)) != 0)
 2234                 return (error);
vp = nd.ni_vp;
 2236         if (vp != NULL) {
VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
 2238                 if (nd.ni_dvp == vp)
vrele(nd.ni_dvp);
 2240                 else
vput(nd.ni_dvp);
vrele(vp);
 2243                 return (EEXIST);
 2244         }
VATTR_NULL(&vattr);
vattr.va_type = VDIR;
vattr.va_mode = (SCARG(uap, mode) & ACCESSPERMS) &~ p->p_fd->fd_cmask;
error = VOP_MKDIR(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr);
 2249         if (!error)
vput(nd.ni_vp);
 2251         return (error);
 2252 }
 2254 /*
 2255  * Remove a directory file.
 2256  */
 2257 /* ARGSUSED */
 2258 int
sys_rmdir(struct proc *p, void *v, register_t *retval)
 2260 {
 2261         struct sys_rmdir_args /* {
 2262                 syscallarg(const char *) path;
 2263         } */ *uap = v;
 2264         struct vnode *vp;
 2265         int error;
 2266         struct nameidata nd;
NDINIT(&nd, DELETE, LOCKPARENT | LOCKLEAF, UIO_USERSPACE,
SCARG(uap, path), p);
 2270         if ((error = namei(&nd)) != 0)
 2271                 return (error);
vp = nd.ni_vp;
 2273         if (vp->v_type != VDIR) {
error = ENOTDIR;
 2275                 goto out;
 2276         }
 2277         /*
 2278          * No rmdir "." please.
 2279          */
 2280         if (nd.ni_dvp == vp) {
error = EBUSY;
 2282                 goto out;
 2283         }
 2284         /*
 2285          * The root of a mounted filesystem cannot be deleted.
 2286          */
 2287         if (vp->v_flag & VROOT)
error = EBUSY;
out:
 2290         if (!error) {
error = VOP_RMDIR(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd);
 2292         } else {
VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
 2294                 if (nd.ni_dvp == vp)
vrele(nd.ni_dvp);
 2296                 else
vput(nd.ni_dvp);
vput(vp);
 2299         }
 2300         return (error);
 2301 }
 2303 /*
 2304  * Read a block of directory entries in a file system independent format.
 2305  */
 2306 int
sys_getdirentries(struct proc *p, void *v, register_t *retval)
 2308 {
 2309         struct sys_getdirentries_args /* {
 2310                 syscallarg(int) fd;
 2311                 syscallarg(char *) buf;
 2312                 syscallarg(int) count;
 2313                 syscallarg(long *) basep;
 2314         } */ *uap = v;
 2315         struct vnode *vp;
 2316         struct file *fp;
 2317         struct uio auio;
 2318         struct iovec aiov;
 2319         long loff;
 2320         int error, eofflag;
 2322         if (SCARG(uap, count) < 0)
 2323                 return EINVAL;
 2324         if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0)
 2325                 return (error);
 2326         if ((fp->f_flag & FREAD) == 0) {
error = EBADF;
 2328                 goto bad;
 2329         }
vp = (struct vnode *)fp->f_data;
 2331         if (vp->v_type != VDIR) {
error = EINVAL;
 2333                 goto bad;
 2334         }
aiov.iov_base = SCARG(uap, buf);
aiov.iov_len = SCARG(uap, count);
auio.uio_iov = &aiov;
auio.uio_iovcnt = 1;
auio.uio_rw = UIO_READ;
auio.uio_segflg = UIO_USERSPACE;
auio.uio_procp = p;
auio.uio_resid = SCARG(uap, count);
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
loff = auio.uio_offset = fp->f_offset;
error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag, 0, 0);
fp->f_offset = auio.uio_offset;
VOP_UNLOCK(vp, 0, p);
 2348         if (error)
 2349                 goto bad;
error = copyout(&loff, SCARG(uap, basep),
 2351             sizeof(long));
 2352         *retval = SCARG(uap, count) - auio.uio_resid;
bad:
FRELE(fp);
 2355         return (error);
 2356 }
 2358 /*
 2359  * Set the mode mask for creation of filesystem nodes.
 2360  */
 2361 int
sys_umask(struct proc *p, void *v, register_t *retval)
 2363 {
 2364         struct sys_umask_args /* {
 2365                 syscallarg(mode_t) newmask;
 2366         } */ *uap = v;
 2367         struct filedesc *fdp;
fdp = p->p_fd;
 2370         *retval = fdp->fd_cmask;
fdp->fd_cmask = SCARG(uap, newmask) & ACCESSPERMS;
 2372         return (0);
 2373 }
 2375 /*
 2376  * Void all references to file by ripping underlying filesystem
 2377  * away from vnode.
 2378  */
 2379 /* ARGSUSED */
 2380 int
sys_revoke(struct proc *p, void *v, register_t *retval)
 2382 {
 2383         struct sys_revoke_args /* {
 2384                 syscallarg(const char *) path;
 2385         } */ *uap = v;
 2386         struct vnode *vp;
 2387         struct vattr vattr;
 2388         int error;
 2389         struct nameidata nd;
NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p);
 2392         if ((error = namei(&nd)) != 0)
 2393                 return (error);
vp = nd.ni_vp;
 2395         if ((error = VOP_GETATTR(vp, &vattr, p->p_ucred, p)) != 0)
 2396                 goto out;
 2397         if (p->p_ucred->cr_uid != vattr.va_uid &&
 2398             (error = suser(p, 0)))
 2399                 goto out;
 2400         if (vp->v_usecount > 1 || (vp->v_flag & (VALIASED)))
VOP_REVOKE(vp, REVOKEALL);
out:
vrele(vp);
 2404         return (error);
 2405 }
 2407 /*
 2408  * Convert a user file descriptor to a kernel file entry.
 2409  *
 2410  * On return *fpp is FREF:ed.
 2411  */
 2412 int
getvnode(struct filedesc *fdp, int fd, struct file **fpp)
 2414 {
 2415         struct file *fp;
 2416         struct vnode *vp;
 2418         if ((fp = fd_getfile(fdp, fd)) == NULL)
 2419                 return (EBADF);
 2421         if (fp->f_type != DTYPE_VNODE)
 2422                 return (EINVAL);
vp = (struct vnode *)fp->f_data;
 2425         if (vp->v_type == VBAD)
 2426                 return (EBADF);
FREF(fp);
 2429         *fpp = fp;
 2431         return (0);
 2432 }
 2434 /*
 2435  * Positional read system call.
 2436  */
 2437 int
sys_pread(struct proc *p, void *v, register_t *retval)
 2439 {
 2440         struct sys_pread_args /* {
 2441                 syscallarg(int) fd;
 2442                 syscallarg(void *) buf;
 2443                 syscallarg(size_t) nbyte;
 2444                 syscallarg(int) pad;
 2445                 syscallarg(off_t) offset;
 2446         } */ *uap = v;
 2447         struct filedesc *fdp = p->p_fd;
 2448         struct file *fp;
 2449         struct vnode *vp;
off_t offset;
 2451         int fd = SCARG(uap, fd);
 2453         if ((fp = fd_getfile(fdp, fd)) == NULL)
 2454                 return (EBADF);
 2455         if ((fp->f_flag & FREAD) == 0)
 2456                 return (EBADF);
vp = (struct vnode *)fp->f_data;
 2459         if (fp->f_type != DTYPE_VNODE || vp->v_type == VFIFO) {
 2460                 return (ESPIPE);
 2461         }
offset = SCARG(uap, offset);
FREF(fp);
 2467         /* dofileread() will FRELE the descriptor for us */
 2468         return (dofileread(p, fd, fp, SCARG(uap, buf), SCARG(uap, nbyte),
 2469             &offset, retval));
 2470 }
 2472 /*
 2473  * Positional scatter read system call.
 2474  */
 2475 int
sys_preadv(struct proc *p, void *v, register_t *retval)
 2477 {
 2478         struct sys_preadv_args /* {
 2479                 syscallarg(int) fd;
 2480                 syscallarg(const struct iovec *) iovp;
 2481                 syscallarg(int) iovcnt;
 2482                 syscallarg(int) pad;
 2483                 syscallarg(off_t) offset;
 2484         } */ *uap = v;
 2485         struct filedesc *fdp = p->p_fd;
 2486         struct file *fp;
 2487         struct vnode *vp;
off_t offset;
 2489         int fd = SCARG(uap, fd);
 2491         if ((fp = fd_getfile(fdp, fd)) == NULL)
 2492                 return (EBADF);
 2493         if ((fp->f_flag & FREAD) == 0)
 2494                 return (EBADF);
vp = (struct vnode *)fp->f_data;
 2497         if (fp->f_type != DTYPE_VNODE || vp->v_type == VFIFO) {
 2498                 return (ESPIPE);
 2499         }
FREF(fp);
offset = SCARG(uap, offset);
 2505         /* dofilereadv() will FRELE the descriptor for us */
 2506         return (dofilereadv(p, fd, fp, SCARG(uap, iovp), SCARG(uap, iovcnt),
 2507             &offset, retval));
 2508 }
 2510 /*
 2511  * Positional write system call.
 2512  */
 2513 int
sys_pwrite(struct proc *p, void *v, register_t *retval)
 2515 {
 2516         struct sys_pwrite_args /* {
 2517                 syscallarg(int) fd;
 2518                 syscallarg(const void *) buf;
 2519                 syscallarg(size_t) nbyte;
 2520                 syscallarg(int) pad;
 2521                 syscallarg(off_t) offset;
 2522         } */ *uap = v;
 2523         struct filedesc *fdp = p->p_fd;
 2524         struct file *fp;
 2525         struct vnode *vp;
off_t offset;
 2527         int fd = SCARG(uap, fd);
 2529         if ((fp = fd_getfile(fdp, fd)) == NULL)
 2530                 return (EBADF);
 2531         if ((fp->f_flag & FWRITE) == 0)
 2532                 return (EBADF);
vp = (struct vnode *)fp->f_data;
 2535         if (fp->f_type != DTYPE_VNODE || vp->v_type == VFIFO) {
 2536                 return (ESPIPE);
 2537         }
FREF(fp);
offset = SCARG(uap, offset);
 2543         /* dofilewrite() will FRELE the descriptor for us */
 2544         return (dofilewrite(p, fd, fp, SCARG(uap, buf), SCARG(uap, nbyte),
 2545             &offset, retval));
 2546 }
 2548 /*
 2549  * Positional gather write system call.
 2550  */
 2551 int
sys_pwritev(struct proc *p, void *v, register_t *retval)
 2553 {
 2554         struct sys_pwritev_args /* {
 2555                 syscallarg(int) fd;
 2556                 syscallarg(const struct iovec *) iovp;
 2557                 syscallarg(int) iovcnt;
 2558                 syscallarg(int) pad;
 2559                 syscallarg(off_t) offset;
 2560         } */ *uap = v;
 2561         struct filedesc *fdp = p->p_fd;
 2562         struct file *fp;
 2563         struct vnode *vp;
off_t offset;
 2565         int fd = SCARG(uap, fd);
 2567         if ((fp = fd_getfile(fdp, fd)) == NULL)
 2568                 return (EBADF);
 2569         if ((fp->f_flag & FWRITE) == 0)
 2570                 return (EBADF);
vp = (struct vnode *)fp->f_data;
 2573         if (fp->f_type != DTYPE_VNODE || vp->v_type == VFIFO) {
 2574                 return (ESPIPE);
 2575         }
FREF(fp);
offset = SCARG(uap, offset);
 2581         /* dofilewritev() will FRELE the descriptor for us */
 2582         return (dofilewritev(p, fd, fp, SCARG(uap, iovp), SCARG(uap, iovcnt),
 2583             &offset, retval));
 2584 }