1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Copyright (c) 1989, 1993
|
|
|
|
* The Regents of the University of California. All rights reserved.
|
|
|
|
* (c) UNIX System Laboratories, Inc.
|
|
|
|
* All or some portions of this file are derived from material licensed
|
|
|
|
* to the University of California by American Telephone and Telegraph
|
|
|
|
* Co. or Unix System Laboratories, Inc. and are reproduced herein with
|
|
|
|
* the permission of UNIX System Laboratories, Inc.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
|
|
* must display the following acknowledgement:
|
|
|
|
* This product includes software developed by the University of
|
|
|
|
* California, Berkeley and its contributors.
|
|
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*
|
|
|
|
* @(#)vfs_syscalls.c 8.13 (Berkeley) 4/15/94
|
1997-09-28 06:37:02 +00:00
|
|
|
* $Id: vfs_syscalls.c,v 1.74 1997/09/27 13:39:06 kato Exp $
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
|
1996-01-05 17:46:14 +00:00
|
|
|
/*
|
|
|
|
* XXX - The following is required because of some magic done
|
|
|
|
* in getdirentries() below which is only done if the translucent
|
|
|
|
* filesystem `UNION' is compiled into the kernel. This is broken,
|
|
|
|
* but I don't have time to study the code deeply enough to understand
|
|
|
|
* what's going on and determine an appropriate fix. -GAW
|
|
|
|
*/
|
1996-05-11 04:39:53 +00:00
|
|
|
#include "opt_union.h"
|
1996-01-05 17:46:14 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/systm.h>
|
1997-02-10 02:22:35 +00:00
|
|
|
#include <sys/sysent.h>
|
1995-11-12 06:43:28 +00:00
|
|
|
#include <sys/sysproto.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/namei.h>
|
|
|
|
#include <sys/filedesc.h>
|
|
|
|
#include <sys/kernel.h>
|
1997-03-23 03:37:54 +00:00
|
|
|
#include <sys/fcntl.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/file.h>
|
|
|
|
#include <sys/stat.h>
|
1996-09-03 14:25:27 +00:00
|
|
|
#include <sys/unistd.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/vnode.h>
|
|
|
|
#include <sys/mount.h>
|
|
|
|
#include <sys/proc.h>
|
|
|
|
#include <sys/malloc.h>
|
|
|
|
#include <sys/dirent.h>
|
|
|
|
|
1995-03-16 18:17:34 +00:00
|
|
|
#ifdef UNION
|
|
|
|
#include <miscfs/union/union.h>
|
|
|
|
#endif
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <vm/vm.h>
|
1995-12-07 12:48:31 +00:00
|
|
|
#include <vm/vm_object.h>
|
|
|
|
#include <vm/vm_extern.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/sysctl.h>
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
static int change_dir __P((struct nameidata *ndp, struct proc *p));
|
|
|
|
static void checkdirs __P((struct vnode *olddp));
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Virtual File System System Calls
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Mount a file system.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct mount_args {
|
1997-02-10 02:22:35 +00:00
|
|
|
char *type;
|
1994-05-24 10:09:53 +00:00
|
|
|
char *path;
|
|
|
|
int flags;
|
|
|
|
caddr_t data;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
mount(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct mount_args /* {
|
|
|
|
syscallarg(char *) type;
|
|
|
|
syscallarg(char *) path;
|
|
|
|
syscallarg(int) flags;
|
|
|
|
syscallarg(caddr_t) data;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1997-02-10 02:22:35 +00:00
|
|
|
struct vnode *vp;
|
|
|
|
struct mount *mp;
|
|
|
|
struct vfsconf *vfsp;
|
1994-05-25 09:21:21 +00:00
|
|
|
int error, flag = 0;
|
1997-02-10 02:22:35 +00:00
|
|
|
struct vattr va;
|
|
|
|
u_long fstypenum;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct nameidata nd;
|
1997-02-10 02:22:35 +00:00
|
|
|
char fstypename[MFSNAMELEN];
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Get vnode to be covered
|
|
|
|
*/
|
1997-02-10 02:22:35 +00:00
|
|
|
NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
|
|
|
|
SCARG(uap, path), p);
|
|
|
|
if (error = namei(&nd))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
vp = nd.ni_vp;
|
1997-02-10 02:22:35 +00:00
|
|
|
if (SCARG(uap, flags) & MNT_UPDATE) {
|
1994-05-24 10:09:53 +00:00
|
|
|
if ((vp->v_flag & VROOT) == 0) {
|
|
|
|
vput(vp);
|
|
|
|
return (EINVAL);
|
|
|
|
}
|
|
|
|
mp = vp->v_mount;
|
|
|
|
flag = mp->mnt_flag;
|
|
|
|
/*
|
|
|
|
* We only allow the filesystem to be reloaded if it
|
|
|
|
* is currently mounted read-only.
|
|
|
|
*/
|
1997-02-10 02:22:35 +00:00
|
|
|
if ((SCARG(uap, flags) & MNT_RELOAD) &&
|
1994-05-24 10:09:53 +00:00
|
|
|
((mp->mnt_flag & MNT_RDONLY) == 0)) {
|
|
|
|
vput(vp);
|
|
|
|
return (EOPNOTSUPP); /* Needs translation */
|
|
|
|
}
|
|
|
|
mp->mnt_flag |=
|
1997-02-10 02:22:35 +00:00
|
|
|
SCARG(uap, flags) & (MNT_RELOAD | MNT_FORCE | MNT_UPDATE);
|
|
|
|
/*
|
|
|
|
* Only root, or the user that did the original mount is
|
|
|
|
* permitted to update it.
|
|
|
|
*/
|
|
|
|
if (mp->mnt_stat.f_owner != p->p_ucred->cr_uid &&
|
|
|
|
(error = suser(p->p_ucred, &p->p_acflag))) {
|
|
|
|
vput(vp);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Do not allow NFS export by non-root users. Silently
|
|
|
|
* enforce MNT_NOSUID and MNT_NODEV for non-root users.
|
|
|
|
*/
|
|
|
|
if (p->p_ucred->cr_uid != 0) {
|
|
|
|
if (SCARG(uap, flags) & MNT_EXPORTED) {
|
|
|
|
vput(vp);
|
|
|
|
return (EPERM);
|
|
|
|
}
|
|
|
|
SCARG(uap, flags) |= MNT_NOSUID | MNT_NODEV;
|
|
|
|
}
|
|
|
|
if (vfs_busy(mp, LK_NOWAIT, 0, p)) {
|
|
|
|
vput(vp);
|
|
|
|
return (EBUSY);
|
|
|
|
}
|
|
|
|
VOP_UNLOCK(vp, 0, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
goto update;
|
|
|
|
}
|
1997-02-10 02:22:35 +00:00
|
|
|
/*
|
|
|
|
* If the user is not root, ensure that they own the directory
|
|
|
|
* onto which we are attempting to mount.
|
|
|
|
*/
|
|
|
|
if ((error = VOP_GETATTR(vp, &va, p->p_ucred, p)) ||
|
|
|
|
(va.va_uid != p->p_ucred->cr_uid &&
|
|
|
|
(error = suser(p->p_ucred, &p->p_acflag)))) {
|
|
|
|
vput(vp);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Do not allow NFS export by non-root users. Silently
|
|
|
|
* enforce MNT_NOSUID and MNT_NODEV for non-root users.
|
|
|
|
*/
|
|
|
|
if (p->p_ucred->cr_uid != 0) {
|
|
|
|
if (SCARG(uap, flags) & MNT_EXPORTED) {
|
|
|
|
vput(vp);
|
|
|
|
return (EPERM);
|
|
|
|
}
|
|
|
|
SCARG(uap, flags) |= MNT_NOSUID | MNT_NODEV;
|
|
|
|
}
|
|
|
|
if (error = vinvalbuf(vp, V_SAVE, p->p_ucred, p, 0, 0))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
if (vp->v_type != VDIR) {
|
|
|
|
vput(vp);
|
|
|
|
return (ENOTDIR);
|
|
|
|
}
|
1997-02-10 02:22:35 +00:00
|
|
|
#ifdef COMPAT_43
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
1997-02-10 02:22:35 +00:00
|
|
|
* Historically filesystem types were identified by number. If we
|
|
|
|
* get an integer for the filesystem type instead of a string, we
|
|
|
|
* check to see if it matches one of the historic filesystem types.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1997-02-10 02:22:35 +00:00
|
|
|
fstypenum = (u_long)SCARG(uap, type);
|
|
|
|
if (fstypenum < maxvfsconf) {
|
|
|
|
for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next)
|
|
|
|
if (vfsp->vfc_typenum == fstypenum)
|
|
|
|
break;
|
|
|
|
if (vfsp == NULL) {
|
|
|
|
vput(vp);
|
|
|
|
return (ENODEV);
|
|
|
|
}
|
|
|
|
strncpy(fstypename, vfsp->vfc_name, MFSNAMELEN);
|
|
|
|
} else
|
|
|
|
#endif /* COMPAT_43 */
|
|
|
|
if (error = copyinstr(SCARG(uap, type), fstypename, MFSNAMELEN, NULL)) {
|
1994-05-24 10:09:53 +00:00
|
|
|
vput(vp);
|
|
|
|
return (error);
|
|
|
|
}
|
1997-02-10 02:22:35 +00:00
|
|
|
for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next)
|
|
|
|
if (!strcmp(vfsp->vfc_name, fstypename))
|
|
|
|
break;
|
|
|
|
if (vfsp == NULL) {
|
|
|
|
vput(vp);
|
|
|
|
return (ENODEV);
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
if (vp->v_mountedhere != NULL) {
|
|
|
|
vput(vp);
|
|
|
|
return (EBUSY);
|
|
|
|
}
|
1997-02-10 02:22:35 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate and initialize the filesystem.
|
|
|
|
*/
|
|
|
|
mp = (struct mount *)malloc((u_long)sizeof(struct mount),
|
|
|
|
M_MOUNT, M_WAITOK);
|
|
|
|
bzero((char *)mp, (u_long)sizeof(struct mount));
|
|
|
|
lockinit(&mp->mnt_lock, PVFS, "vfslock", 0, 0);
|
|
|
|
(void)vfs_busy(mp, LK_NOWAIT, 0, p);
|
|
|
|
mp->mnt_op = vfsp->vfc_vfsops;
|
|
|
|
mp->mnt_vfc = vfsp;
|
|
|
|
vfsp->vfc_refcount++;
|
|
|
|
mp->mnt_stat.f_type = vfsp->vfc_typenum;
|
|
|
|
mp->mnt_flag |= vfsp->vfc_flags & MNT_VISFLAGMASK;
|
|
|
|
strncpy(mp->mnt_stat.f_fstypename, vfsp->vfc_name, MFSNAMELEN);
|
1994-05-24 10:09:53 +00:00
|
|
|
vp->v_mountedhere = mp;
|
|
|
|
mp->mnt_vnodecovered = vp;
|
1997-02-10 02:22:35 +00:00
|
|
|
mp->mnt_stat.f_owner = p->p_ucred->cr_uid;
|
1994-05-24 10:09:53 +00:00
|
|
|
update:
|
|
|
|
/*
|
|
|
|
* Set the mount level flags.
|
|
|
|
*/
|
1997-02-10 02:22:35 +00:00
|
|
|
if (SCARG(uap, flags) & MNT_RDONLY)
|
1994-05-24 10:09:53 +00:00
|
|
|
mp->mnt_flag |= MNT_RDONLY;
|
|
|
|
else if (mp->mnt_flag & MNT_RDONLY)
|
|
|
|
mp->mnt_flag |= MNT_WANTRDWR;
|
|
|
|
mp->mnt_flag &=~ (MNT_NOSUID | MNT_NOEXEC | MNT_NODEV |
|
1997-09-27 13:40:20 +00:00
|
|
|
MNT_SYNCHRONOUS | MNT_UNION | MNT_ASYNC | MNT_NOATIME |
|
|
|
|
MNT_NOCLUSTERR | MNT_NOCLUSTERW);
|
1997-02-10 02:22:35 +00:00
|
|
|
mp->mnt_flag |= SCARG(uap, flags) & (MNT_NOSUID | MNT_NOEXEC |
|
|
|
|
MNT_NODEV | MNT_SYNCHRONOUS | MNT_UNION | MNT_ASYNC | MNT_FORCE |
|
1997-09-27 13:40:20 +00:00
|
|
|
MNT_NOATIME | MNT_NOCLUSTERR | MNT_NOCLUSTERW);
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Mount the filesystem.
|
|
|
|
*/
|
1997-02-10 02:22:35 +00:00
|
|
|
error = VFS_MOUNT(mp, SCARG(uap, path), SCARG(uap, data), &nd, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (mp->mnt_flag & MNT_UPDATE) {
|
|
|
|
vrele(vp);
|
|
|
|
if (mp->mnt_flag & MNT_WANTRDWR)
|
|
|
|
mp->mnt_flag &= ~MNT_RDONLY;
|
|
|
|
mp->mnt_flag &=~
|
|
|
|
(MNT_UPDATE | MNT_RELOAD | MNT_FORCE | MNT_WANTRDWR);
|
|
|
|
if (error)
|
|
|
|
mp->mnt_flag = flag;
|
1997-02-10 02:22:35 +00:00
|
|
|
vfs_unbusy(mp, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Put the new filesystem on the mount list after root.
|
|
|
|
*/
|
|
|
|
cache_purge(vp);
|
|
|
|
if (!error) {
|
1997-02-10 02:22:35 +00:00
|
|
|
simple_lock(&mountlist_slock);
|
1995-08-11 11:31:18 +00:00
|
|
|
CIRCLEQ_INSERT_TAIL(&mountlist, mp, mnt_list);
|
1997-02-10 02:22:35 +00:00
|
|
|
simple_unlock(&mountlist_slock);
|
|
|
|
checkdirs(vp);
|
|
|
|
VOP_UNLOCK(vp, 0, p);
|
|
|
|
vfs_unbusy(mp, p);
|
|
|
|
if (error = VFS_START(mp, 0, p))
|
1995-08-11 11:31:18 +00:00
|
|
|
vrele(vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
} else {
|
|
|
|
mp->mnt_vnodecovered->v_mountedhere = (struct mount *)0;
|
1997-02-10 02:22:35 +00:00
|
|
|
mp->mnt_vfc->vfc_refcount--;
|
|
|
|
vfs_unbusy(mp, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
free((caddr_t)mp, M_MOUNT);
|
|
|
|
vput(vp);
|
|
|
|
}
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
/*
|
|
|
|
* Scan all active processes to see if any of them have a current
|
|
|
|
* or root directory onto which the new filesystem has just been
|
|
|
|
* mounted. If so, replace them with the new mount point.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
checkdirs(olddp)
|
|
|
|
struct vnode *olddp;
|
|
|
|
{
|
|
|
|
struct filedesc *fdp;
|
|
|
|
struct vnode *newdp;
|
|
|
|
struct proc *p;
|
|
|
|
|
|
|
|
if (olddp->v_usecount == 1)
|
|
|
|
return;
|
|
|
|
if (VFS_ROOT(olddp->v_mountedhere, &newdp))
|
|
|
|
panic("mount: lost mount");
|
|
|
|
for (p = allproc.lh_first; p != 0; p = p->p_list.le_next) {
|
|
|
|
fdp = p->p_fd;
|
|
|
|
if (fdp->fd_cdir == olddp) {
|
|
|
|
vrele(fdp->fd_cdir);
|
|
|
|
VREF(newdp);
|
|
|
|
fdp->fd_cdir = newdp;
|
|
|
|
}
|
|
|
|
if (fdp->fd_rdir == olddp) {
|
|
|
|
vrele(fdp->fd_rdir);
|
|
|
|
VREF(newdp);
|
|
|
|
fdp->fd_rdir = newdp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (rootvnode == olddp) {
|
|
|
|
vrele(rootvnode);
|
|
|
|
VREF(newdp);
|
|
|
|
rootvnode = newdp;
|
|
|
|
}
|
|
|
|
vput(newdp);
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Unmount a file system.
|
|
|
|
*
|
|
|
|
* Note: unmount takes a path to the vnode mounted on as argument,
|
|
|
|
* not special file (as before).
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct unmount_args {
|
|
|
|
char *path;
|
|
|
|
int flags;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
unmount(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct unmount_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
syscallarg(int) flags;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register struct vnode *vp;
|
|
|
|
struct mount *mp;
|
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
|
|
|
|
SCARG(uap, path), p);
|
|
|
|
if (error = namei(&nd))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
vp = nd.ni_vp;
|
1997-02-10 02:22:35 +00:00
|
|
|
mp = vp->v_mount;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
1997-02-10 02:22:35 +00:00
|
|
|
* Only root, or the user that did the original mount is
|
|
|
|
* permitted to unmount this filesystem.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1997-02-10 02:22:35 +00:00
|
|
|
if ((mp->mnt_stat.f_owner != p->p_ucred->cr_uid) &&
|
1994-05-24 10:09:53 +00:00
|
|
|
(error = suser(p->p_ucred, &p->p_acflag))) {
|
|
|
|
vput(vp);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-02-10 02:22:35 +00:00
|
|
|
* Don't allow unmounting the root file system.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1997-02-10 02:22:35 +00:00
|
|
|
if (mp->mnt_flag & MNT_ROOTFS) {
|
1994-05-24 10:09:53 +00:00
|
|
|
vput(vp);
|
|
|
|
return (EINVAL);
|
|
|
|
}
|
1994-08-20 16:03:26 +00:00
|
|
|
|
|
|
|
/*
|
1997-02-10 02:22:35 +00:00
|
|
|
* Must be the root of the filesystem
|
1994-08-20 16:03:26 +00:00
|
|
|
*/
|
1997-02-10 02:22:35 +00:00
|
|
|
if ((vp->v_flag & VROOT) == 0) {
|
|
|
|
vput(vp);
|
1994-08-20 16:03:26 +00:00
|
|
|
return (EINVAL);
|
1997-02-10 02:22:35 +00:00
|
|
|
}
|
|
|
|
vput(vp);
|
|
|
|
return (dounmount(mp, SCARG(uap, flags), p));
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Do the actual file system unmount.
|
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
dounmount(mp, flags, p)
|
|
|
|
register struct mount *mp;
|
|
|
|
int flags;
|
|
|
|
struct proc *p;
|
|
|
|
{
|
|
|
|
struct vnode *coveredvp;
|
|
|
|
int error;
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
simple_lock(&mountlist_slock);
|
1994-05-24 10:09:53 +00:00
|
|
|
mp->mnt_flag |= MNT_UNMOUNT;
|
1997-02-10 02:22:35 +00:00
|
|
|
lockmgr(&mp->mnt_lock, LK_DRAIN | LK_INTERLOCK, &mountlist_slock, p);
|
1997-07-17 07:17:33 +00:00
|
|
|
|
|
|
|
if (mp->mnt_flag & MNT_EXPUBLIC)
|
|
|
|
vfs_setpublicfs(NULL, NULL, NULL);
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
mp->mnt_flag &=~ MNT_ASYNC;
|
1995-05-21 21:39:31 +00:00
|
|
|
vfs_msync(mp, MNT_NOWAIT);
|
1994-05-24 10:09:53 +00:00
|
|
|
vnode_pager_umount(mp); /* release cached vnodes */
|
|
|
|
cache_purgevfs(mp); /* remove cache entries for this file sys */
|
1997-02-10 02:22:35 +00:00
|
|
|
if (((mp->mnt_flag & MNT_RDONLY) ||
|
|
|
|
(error = VFS_SYNC(mp, MNT_WAIT, p->p_ucred, p)) == 0) ||
|
1994-05-24 10:09:53 +00:00
|
|
|
(flags & MNT_FORCE))
|
|
|
|
error = VFS_UNMOUNT(mp, flags, p);
|
1997-02-10 02:22:35 +00:00
|
|
|
simple_lock(&mountlist_slock);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (error) {
|
1997-02-10 02:22:35 +00:00
|
|
|
mp->mnt_flag &= ~MNT_UNMOUNT;
|
|
|
|
lockmgr(&mp->mnt_lock, LK_RELEASE | LK_INTERLOCK | LK_REENABLE,
|
|
|
|
&mountlist_slock, p);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
CIRCLEQ_REMOVE(&mountlist, mp, mnt_list);
|
|
|
|
if ((coveredvp = mp->mnt_vnodecovered) != NULLVP) {
|
|
|
|
coveredvp->v_mountedhere = (struct mount *)0;
|
1994-05-24 10:09:53 +00:00
|
|
|
vrele(coveredvp);
|
|
|
|
}
|
1997-02-10 02:22:35 +00:00
|
|
|
mp->mnt_vfc->vfc_refcount--;
|
|
|
|
if (mp->mnt_vnodelist.lh_first != NULL)
|
|
|
|
panic("unmount: dangling vnode");
|
|
|
|
lockmgr(&mp->mnt_lock, LK_RELEASE | LK_INTERLOCK, &mountlist_slock, p);
|
|
|
|
if (mp->mnt_flag & MNT_MWAIT)
|
|
|
|
wakeup((caddr_t)mp);
|
|
|
|
free((caddr_t)mp, M_MOUNT);
|
|
|
|
return (0);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Sync each mounted filesystem.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1995-10-08 00:06:22 +00:00
|
|
|
struct sync_args {
|
|
|
|
int dummy;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1995-10-08 00:06:22 +00:00
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
#ifdef DEBUG
|
|
|
|
int syncprt = 0;
|
|
|
|
SYSCTL_INT(_debug, 0, syncprt, CTLFLAG_RW, &syncprt, 0, "");
|
|
|
|
#endif
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
sync(p, uap, retval)
|
|
|
|
struct proc *p;
|
|
|
|
struct sync_args *uap;
|
1997-02-10 02:22:35 +00:00
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct mount *mp, *nmp;
|
1994-05-24 10:09:53 +00:00
|
|
|
int asyncflag;
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
simple_lock(&mountlist_slock);
|
|
|
|
for (mp = mountlist.cqh_first; mp != (void *)&mountlist; mp = nmp) {
|
|
|
|
if (vfs_busy(mp, LK_NOWAIT, &mountlist_slock, p)) {
|
|
|
|
nmp = mp->mnt_list.cqe_next;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if ((mp->mnt_flag & MNT_RDONLY) == 0) {
|
1994-05-24 10:09:53 +00:00
|
|
|
asyncflag = mp->mnt_flag & MNT_ASYNC;
|
|
|
|
mp->mnt_flag &= ~MNT_ASYNC;
|
1995-05-21 21:39:31 +00:00
|
|
|
vfs_msync(mp, MNT_NOWAIT);
|
1995-02-13 13:45:04 +00:00
|
|
|
VFS_SYNC(mp, MNT_NOWAIT, p != NULL ? p->p_ucred : NOCRED, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (asyncflag)
|
|
|
|
mp->mnt_flag |= MNT_ASYNC;
|
|
|
|
}
|
1997-02-10 02:22:35 +00:00
|
|
|
simple_lock(&mountlist_slock);
|
|
|
|
nmp = mp->mnt_list.cqe_next;
|
|
|
|
vfs_unbusy(mp, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1997-02-10 02:22:35 +00:00
|
|
|
simple_unlock(&mountlist_slock);
|
1997-02-12 06:46:11 +00:00
|
|
|
#if 0
|
|
|
|
/*
|
|
|
|
* XXX don't call vfs_bufstats() yet because that routine
|
|
|
|
* was not imported in the Lite2 merge.
|
|
|
|
*/
|
1997-02-10 02:22:35 +00:00
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
if (syncprt)
|
|
|
|
vfs_bufstats();
|
|
|
|
#endif /* DIAGNOSTIC */
|
1997-02-12 06:46:11 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Change filesystem quotas.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct quotactl_args {
|
|
|
|
char *path;
|
|
|
|
int cmd;
|
|
|
|
int uid;
|
|
|
|
caddr_t arg;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
quotactl(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct quotactl_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
syscallarg(int) cmd;
|
|
|
|
syscallarg(int) uid;
|
|
|
|
syscallarg(caddr_t) arg;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register struct mount *mp;
|
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p);
|
|
|
|
if (error = namei(&nd))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
mp = nd.ni_vp->v_mount;
|
|
|
|
vrele(nd.ni_vp);
|
1997-02-10 02:22:35 +00:00
|
|
|
return (VFS_QUOTACTL(mp, SCARG(uap, cmd), SCARG(uap, uid),
|
|
|
|
SCARG(uap, arg), p));
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get filesystem statistics.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct statfs_args {
|
|
|
|
char *path;
|
|
|
|
struct statfs *buf;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
statfs(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct statfs_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
syscallarg(struct statfs *) buf;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register struct mount *mp;
|
|
|
|
register struct statfs *sp;
|
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
1997-03-23 20:08:22 +00:00
|
|
|
struct statfs sb;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p);
|
|
|
|
if (error = namei(&nd))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
mp = nd.ni_vp->v_mount;
|
|
|
|
sp = &mp->mnt_stat;
|
|
|
|
vrele(nd.ni_vp);
|
1994-10-02 17:35:40 +00:00
|
|
|
error = VFS_STATFS(mp, sp, p);
|
|
|
|
if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
|
1997-03-23 20:08:22 +00:00
|
|
|
if (p->p_ucred->cr_uid != 0) {
|
|
|
|
bcopy((caddr_t)sp, (caddr_t)&sb, sizeof(sb));
|
|
|
|
sb.f_fsid.val[0] = sb.f_fsid.val[1] = 0;
|
|
|
|
sp = &sb;
|
|
|
|
}
|
1997-02-10 02:22:35 +00:00
|
|
|
return (copyout((caddr_t)sp, (caddr_t)SCARG(uap, buf), sizeof(*sp)));
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get filesystem statistics.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct fstatfs_args {
|
|
|
|
int fd;
|
|
|
|
struct statfs *buf;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
fstatfs(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct fstatfs_args /* {
|
|
|
|
syscallarg(int) fd;
|
|
|
|
syscallarg(struct statfs *) buf;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
struct file *fp;
|
|
|
|
struct mount *mp;
|
|
|
|
register struct statfs *sp;
|
|
|
|
int error;
|
1997-03-23 20:08:22 +00:00
|
|
|
struct statfs sb;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
if (error = getvnode(p->p_fd, SCARG(uap, fd), &fp))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
mp = ((struct vnode *)fp->f_data)->v_mount;
|
|
|
|
sp = &mp->mnt_stat;
|
1994-10-02 17:35:40 +00:00
|
|
|
error = VFS_STATFS(mp, sp, p);
|
|
|
|
if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
|
1997-03-23 20:08:22 +00:00
|
|
|
if (p->p_ucred->cr_uid != 0) {
|
|
|
|
bcopy((caddr_t)sp, (caddr_t)&sb, sizeof(sb));
|
|
|
|
sb.f_fsid.val[0] = sb.f_fsid.val[1] = 0;
|
|
|
|
sp = &sb;
|
|
|
|
}
|
1997-02-10 02:22:35 +00:00
|
|
|
return (copyout((caddr_t)sp, (caddr_t)SCARG(uap, buf), sizeof(*sp)));
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get statistics on all filesystems.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct getfsstat_args {
|
|
|
|
struct statfs *buf;
|
|
|
|
long bufsize;
|
|
|
|
int flags;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
getfsstat(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct getfsstat_args /* {
|
|
|
|
syscallarg(struct statfs *) buf;
|
|
|
|
syscallarg(long) bufsize;
|
|
|
|
syscallarg(int) flags;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register struct mount *mp, *nmp;
|
|
|
|
register struct statfs *sp;
|
|
|
|
caddr_t sfsp;
|
|
|
|
long count, maxcount, error;
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
maxcount = SCARG(uap, bufsize) / sizeof(struct statfs);
|
|
|
|
sfsp = (caddr_t)SCARG(uap, buf);
|
1995-08-11 11:31:18 +00:00
|
|
|
count = 0;
|
1997-02-10 02:22:35 +00:00
|
|
|
simple_lock(&mountlist_slock);
|
1995-08-11 11:31:18 +00:00
|
|
|
for (mp = mountlist.cqh_first; mp != (void *)&mountlist; mp = nmp) {
|
1997-02-10 02:22:35 +00:00
|
|
|
if (vfs_busy(mp, LK_NOWAIT, &mountlist_slock, p)) {
|
1996-01-16 13:07:14 +00:00
|
|
|
nmp = mp->mnt_list.cqe_next;
|
|
|
|
continue;
|
|
|
|
}
|
1997-02-10 02:22:35 +00:00
|
|
|
if (sfsp && count < maxcount) {
|
1994-05-24 10:09:53 +00:00
|
|
|
sp = &mp->mnt_stat;
|
|
|
|
/*
|
|
|
|
* If MNT_NOWAIT is specified, do not refresh the
|
|
|
|
* fsstat cache. MNT_WAIT overrides MNT_NOWAIT.
|
|
|
|
*/
|
1997-02-10 02:22:35 +00:00
|
|
|
if (((SCARG(uap, flags) & MNT_NOWAIT) == 0 ||
|
|
|
|
(SCARG(uap, flags) & MNT_WAIT)) &&
|
1996-01-16 13:07:14 +00:00
|
|
|
(error = VFS_STATFS(mp, sp, p))) {
|
1997-02-10 02:22:35 +00:00
|
|
|
simple_lock(&mountlist_slock);
|
1996-01-16 13:07:14 +00:00
|
|
|
nmp = mp->mnt_list.cqe_next;
|
1997-02-10 02:22:35 +00:00
|
|
|
vfs_unbusy(mp, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
continue;
|
1996-01-16 13:07:14 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
|
1994-10-08 22:33:43 +00:00
|
|
|
error = copyout((caddr_t)sp, sfsp, sizeof(*sp));
|
1996-01-16 13:07:14 +00:00
|
|
|
if (error) {
|
1997-02-10 02:22:35 +00:00
|
|
|
vfs_unbusy(mp, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
1996-01-16 13:07:14 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
sfsp += sizeof(*sp);
|
|
|
|
}
|
|
|
|
count++;
|
1997-02-10 02:22:35 +00:00
|
|
|
simple_lock(&mountlist_slock);
|
1996-01-16 13:07:14 +00:00
|
|
|
nmp = mp->mnt_list.cqe_next;
|
1997-02-10 02:22:35 +00:00
|
|
|
vfs_unbusy(mp, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1997-02-10 02:22:35 +00:00
|
|
|
simple_unlock(&mountlist_slock);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (sfsp && count > maxcount)
|
|
|
|
*retval = maxcount;
|
|
|
|
else
|
|
|
|
*retval = count;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Change current working directory to a given file descriptor.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct fchdir_args {
|
|
|
|
int fd;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
fchdir(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
struct fchdir_args /* {
|
|
|
|
syscallarg(int) fd;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register struct filedesc *fdp = p->p_fd;
|
1997-02-10 02:22:35 +00:00
|
|
|
struct vnode *vp, *tdp;
|
|
|
|
struct mount *mp;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct file *fp;
|
|
|
|
int error;
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
if (error = getvnode(fdp, SCARG(uap, fd), &fp))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
vp = (struct vnode *)fp->f_data;
|
1997-02-10 02:22:35 +00:00
|
|
|
VREF(vp);
|
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (vp->v_type != VDIR)
|
|
|
|
error = ENOTDIR;
|
|
|
|
else
|
|
|
|
error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p);
|
1997-02-10 02:22:35 +00:00
|
|
|
while (!error && (mp = vp->v_mountedhere) != NULL) {
|
|
|
|
if (vfs_busy(mp, 0, 0, p))
|
|
|
|
continue;
|
|
|
|
error = VFS_ROOT(mp, &tdp);
|
|
|
|
vfs_unbusy(mp, p);
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
vput(vp);
|
|
|
|
vp = tdp;
|
|
|
|
}
|
|
|
|
if (error) {
|
|
|
|
vput(vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
1997-02-10 02:22:35 +00:00
|
|
|
}
|
|
|
|
VOP_UNLOCK(vp, 0, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
vrele(fdp->fd_cdir);
|
|
|
|
fdp->fd_cdir = vp;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Change current working directory (``.'').
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct chdir_args {
|
|
|
|
char *path;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
chdir(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
struct chdir_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register struct filedesc *fdp = p->p_fd;
|
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
|
|
|
|
SCARG(uap, path), p);
|
|
|
|
if (error = change_dir(&nd, p))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
vrele(fdp->fd_cdir);
|
|
|
|
fdp->fd_cdir = nd.ni_vp;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Change notion of root (``/'') directory.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct chroot_args {
|
|
|
|
char *path;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
chroot(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
struct chroot_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register struct filedesc *fdp = p->p_fd;
|
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
|
|
|
|
1994-10-02 17:35:40 +00:00
|
|
|
error = suser(p->p_ucred, &p->p_acflag);
|
|
|
|
if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
1997-02-10 02:22:35 +00:00
|
|
|
NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
|
|
|
|
SCARG(uap, path), p);
|
|
|
|
if (error = change_dir(&nd, p))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
if (fdp->fd_rdir != NULL)
|
|
|
|
vrele(fdp->fd_rdir);
|
|
|
|
fdp->fd_rdir = nd.ni_vp;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Common routine for chroot and chdir.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
change_dir(ndp, p)
|
|
|
|
register struct nameidata *ndp;
|
|
|
|
struct proc *p;
|
|
|
|
{
|
|
|
|
struct vnode *vp;
|
|
|
|
int error;
|
|
|
|
|
1994-10-02 17:35:40 +00:00
|
|
|
error = namei(ndp);
|
|
|
|
if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
vp = ndp->ni_vp;
|
|
|
|
if (vp->v_type != VDIR)
|
|
|
|
error = ENOTDIR;
|
|
|
|
else
|
|
|
|
error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p);
|
|
|
|
if (error)
|
1997-02-10 02:22:35 +00:00
|
|
|
vput(vp);
|
|
|
|
else
|
|
|
|
VOP_UNLOCK(vp, 0, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check permissions, allocate an open file structure,
|
|
|
|
* and call the device open routine if any.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct open_args {
|
|
|
|
char *path;
|
|
|
|
int flags;
|
|
|
|
int mode;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
open(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct open_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
syscallarg(int) flags;
|
|
|
|
syscallarg(int) mode;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register struct filedesc *fdp = p->p_fd;
|
|
|
|
register struct file *fp;
|
|
|
|
register struct vnode *vp;
|
|
|
|
int flags, cmode;
|
|
|
|
struct file *nfp;
|
|
|
|
int type, indx, error;
|
|
|
|
struct flock lf;
|
|
|
|
struct nameidata nd;
|
|
|
|
|
1994-10-02 17:35:40 +00:00
|
|
|
error = falloc(p, &nfp, &indx);
|
|
|
|
if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
fp = nfp;
|
1997-02-10 02:22:35 +00:00
|
|
|
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);
|
1994-05-24 10:09:53 +00:00
|
|
|
p->p_dupfd = -indx - 1; /* XXX check for fdopen */
|
1994-10-02 17:35:40 +00:00
|
|
|
error = vn_open(&nd, flags, cmode);
|
|
|
|
if (error) {
|
1994-05-24 10:09:53 +00:00
|
|
|
ffree(fp);
|
|
|
|
if ((error == ENODEV || error == ENXIO) &&
|
1997-02-10 02:22:35 +00:00
|
|
|
p->p_dupfd >= 0 && /* XXX from fdopen */
|
1994-05-24 10:09:53 +00:00
|
|
|
(error =
|
1997-02-10 02:22:35 +00:00
|
|
|
dupfdopen(fdp, indx, p->p_dupfd, flags, error)) == 0) {
|
1994-05-24 10:09:53 +00:00
|
|
|
*retval = indx;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
if (error == ERESTART)
|
|
|
|
error = EINTR;
|
|
|
|
fdp->fd_ofiles[indx] = NULL;
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
p->p_dupfd = 0;
|
|
|
|
vp = nd.ni_vp;
|
1996-12-19 19:42:37 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
fp->f_flag = flags & FMASK;
|
1996-12-19 19:42:37 +00:00
|
|
|
fp->f_type = (vp->v_type == VFIFO ? DTYPE_FIFO : DTYPE_VNODE);
|
1994-05-24 10:09:53 +00:00
|
|
|
fp->f_ops = &vnops;
|
|
|
|
fp->f_data = (caddr_t)vp;
|
|
|
|
if (flags & (O_EXLOCK | O_SHLOCK)) {
|
|
|
|
lf.l_whence = SEEK_SET;
|
|
|
|
lf.l_start = 0;
|
|
|
|
lf.l_len = 0;
|
|
|
|
if (flags & O_EXLOCK)
|
|
|
|
lf.l_type = F_WRLCK;
|
|
|
|
else
|
|
|
|
lf.l_type = F_RDLCK;
|
|
|
|
type = F_FLOCK;
|
|
|
|
if ((flags & FNONBLOCK) == 0)
|
|
|
|
type |= F_WAIT;
|
1997-02-10 02:22:35 +00:00
|
|
|
VOP_UNLOCK(vp, 0, p);
|
|
|
|
if (error = VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf, type)) {
|
1994-05-24 10:09:53 +00:00
|
|
|
(void) vn_close(vp, fp->f_flag, fp->f_cred, p);
|
|
|
|
ffree(fp);
|
|
|
|
fdp->fd_ofiles[indx] = NULL;
|
|
|
|
return (error);
|
|
|
|
}
|
1997-02-10 02:22:35 +00:00
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
fp->f_flag |= FHASLOCK;
|
|
|
|
}
|
1997-02-10 02:22:35 +00:00
|
|
|
VOP_UNLOCK(vp, 0, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
*retval = indx;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef COMPAT_43
|
|
|
|
/*
|
|
|
|
* Create a file.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct ocreat_args {
|
|
|
|
char *path;
|
|
|
|
int mode;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
ocreat(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct ocreat_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
syscallarg(int) mode;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1997-02-10 02:22:35 +00:00
|
|
|
struct open_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
syscallarg(int) flags;
|
|
|
|
syscallarg(int) mode;
|
|
|
|
} */ nuap;
|
|
|
|
|
|
|
|
SCARG(&nuap, path) = SCARG(uap, path);
|
|
|
|
SCARG(&nuap, mode) = SCARG(uap, mode);
|
|
|
|
SCARG(&nuap, flags) = O_WRONLY | O_CREAT | O_TRUNC;
|
|
|
|
return (open(p, &nuap, retval));
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
#endif /* COMPAT_43 */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create a special file.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct mknod_args {
|
|
|
|
char *path;
|
|
|
|
int mode;
|
|
|
|
int dev;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
mknod(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct mknod_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
syscallarg(int) mode;
|
|
|
|
syscallarg(int) dev;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register struct vnode *vp;
|
|
|
|
struct vattr vattr;
|
|
|
|
int error;
|
1997-02-10 02:22:35 +00:00
|
|
|
int whiteout;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct nameidata nd;
|
|
|
|
|
1994-10-02 17:35:40 +00:00
|
|
|
error = suser(p->p_ucred, &p->p_acflag);
|
|
|
|
if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
1997-02-10 02:22:35 +00:00
|
|
|
NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, SCARG(uap, path), p);
|
|
|
|
if (error = namei(&nd))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
vp = nd.ni_vp;
|
|
|
|
if (vp != NULL)
|
|
|
|
error = EEXIST;
|
|
|
|
else {
|
|
|
|
VATTR_NULL(&vattr);
|
1997-02-10 02:22:35 +00:00
|
|
|
vattr.va_mode = (SCARG(uap, mode) & ALLPERMS) &~ p->p_fd->fd_cmask;
|
|
|
|
vattr.va_rdev = SCARG(uap, dev);
|
|
|
|
whiteout = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
switch (SCARG(uap, mode) & S_IFMT) {
|
1994-05-24 10:09:53 +00:00
|
|
|
case S_IFMT: /* used by badsect to flag bad sectors */
|
|
|
|
vattr.va_type = VBAD;
|
|
|
|
break;
|
|
|
|
case S_IFCHR:
|
|
|
|
vattr.va_type = VCHR;
|
|
|
|
break;
|
|
|
|
case S_IFBLK:
|
|
|
|
vattr.va_type = VBLK;
|
|
|
|
break;
|
1997-02-10 02:22:35 +00:00
|
|
|
case S_IFWHT:
|
|
|
|
whiteout = 1;
|
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
default:
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!error) {
|
1997-02-10 02:22:35 +00:00
|
|
|
VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
|
|
|
|
if (whiteout) {
|
|
|
|
error = VOP_WHITEOUT(nd.ni_dvp, &nd.ni_cnd, CREATE);
|
|
|
|
if (error)
|
|
|
|
VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
|
|
|
|
vput(nd.ni_dvp);
|
|
|
|
} else {
|
|
|
|
error = VOP_MKNOD(nd.ni_dvp, &nd.ni_vp,
|
|
|
|
&nd.ni_cnd, &vattr);
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
} else {
|
|
|
|
VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
|
|
|
|
if (nd.ni_dvp == vp)
|
|
|
|
vrele(nd.ni_dvp);
|
|
|
|
else
|
|
|
|
vput(nd.ni_dvp);
|
|
|
|
if (vp)
|
|
|
|
vrele(vp);
|
|
|
|
}
|
1997-04-04 17:46:21 +00:00
|
|
|
ASSERT_VOP_UNLOCKED(nd.ni_dvp, "mknod");
|
|
|
|
ASSERT_VOP_UNLOCKED(nd.ni_vp, "mknod");
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-02-10 02:22:35 +00:00
|
|
|
* Create a named pipe.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct mkfifo_args {
|
|
|
|
char *path;
|
|
|
|
int mode;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
mkfifo(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct mkfifo_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
syscallarg(int) mode;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
struct vattr vattr;
|
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, SCARG(uap, path), p);
|
|
|
|
if (error = namei(&nd))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
if (nd.ni_vp != NULL) {
|
|
|
|
VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
|
|
|
|
if (nd.ni_dvp == nd.ni_vp)
|
|
|
|
vrele(nd.ni_dvp);
|
|
|
|
else
|
|
|
|
vput(nd.ni_dvp);
|
|
|
|
vrele(nd.ni_vp);
|
|
|
|
return (EEXIST);
|
|
|
|
}
|
|
|
|
VATTR_NULL(&vattr);
|
|
|
|
vattr.va_type = VFIFO;
|
1997-02-10 02:22:35 +00:00
|
|
|
vattr.va_mode = (SCARG(uap, mode) & ALLPERMS) &~ p->p_fd->fd_cmask;
|
|
|
|
VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Make a hard file link.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct link_args {
|
|
|
|
char *path;
|
|
|
|
char *link;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
link(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct link_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
syscallarg(char *) link;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register struct vnode *vp;
|
|
|
|
struct nameidata nd;
|
|
|
|
int error;
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p);
|
|
|
|
if (error = namei(&nd))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
vp = nd.ni_vp;
|
1996-05-24 16:19:23 +00:00
|
|
|
if (vp->v_type == VDIR)
|
|
|
|
error = EPERM; /* POSIX */
|
|
|
|
else {
|
1997-02-10 02:22:35 +00:00
|
|
|
NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, SCARG(uap, link), p);
|
1994-10-02 17:35:40 +00:00
|
|
|
error = namei(&nd);
|
|
|
|
if (!error) {
|
1995-08-01 18:51:02 +00:00
|
|
|
if (nd.ni_vp != NULL) {
|
1994-05-24 10:09:53 +00:00
|
|
|
VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
|
|
|
|
if (nd.ni_dvp == nd.ni_vp)
|
|
|
|
vrele(nd.ni_dvp);
|
|
|
|
else
|
|
|
|
vput(nd.ni_dvp);
|
|
|
|
if (nd.ni_vp)
|
|
|
|
vrele(nd.ni_vp);
|
1995-08-01 18:51:02 +00:00
|
|
|
error = EEXIST;
|
|
|
|
} else {
|
1997-02-10 02:22:35 +00:00
|
|
|
VOP_LEASE(nd.ni_dvp, p, p->p_ucred,
|
|
|
|
LEASE_WRITE);
|
|
|
|
VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE);
|
1995-08-01 18:51:02 +00:00
|
|
|
error = VOP_LINK(nd.ni_dvp, vp, &nd.ni_cnd);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
vrele(vp);
|
1997-04-04 17:46:21 +00:00
|
|
|
ASSERT_VOP_UNLOCKED(nd.ni_dvp, "link");
|
|
|
|
ASSERT_VOP_UNLOCKED(nd.ni_vp, "link");
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Make a symbolic link.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct symlink_args {
|
|
|
|
char *path;
|
|
|
|
char *link;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
symlink(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct symlink_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
syscallarg(char *) link;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
struct vattr vattr;
|
|
|
|
char *path;
|
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
|
|
|
|
1997-09-21 04:24:27 +00:00
|
|
|
path = zalloc(namei_zone);
|
1997-02-10 02:22:35 +00:00
|
|
|
if (error = copyinstr(SCARG(uap, path), path, MAXPATHLEN, NULL))
|
1994-05-24 10:09:53 +00:00
|
|
|
goto out;
|
1997-02-10 02:22:35 +00:00
|
|
|
NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, SCARG(uap, link), p);
|
|
|
|
if (error = namei(&nd))
|
1994-05-24 10:09:53 +00:00
|
|
|
goto out;
|
|
|
|
if (nd.ni_vp) {
|
|
|
|
VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
|
|
|
|
if (nd.ni_dvp == nd.ni_vp)
|
|
|
|
vrele(nd.ni_dvp);
|
|
|
|
else
|
|
|
|
vput(nd.ni_dvp);
|
|
|
|
vrele(nd.ni_vp);
|
|
|
|
error = EEXIST;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
VATTR_NULL(&vattr);
|
|
|
|
vattr.va_mode = ACCESSPERMS &~ p->p_fd->fd_cmask;
|
1997-02-10 02:22:35 +00:00
|
|
|
VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
|
1994-05-24 10:09:53 +00:00
|
|
|
error = VOP_SYMLINK(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr, path);
|
1997-04-04 17:46:21 +00:00
|
|
|
ASSERT_VOP_UNLOCKED(nd.ni_dvp, "symlink");
|
|
|
|
ASSERT_VOP_UNLOCKED(nd.ni_vp, "symlink");
|
1994-05-24 10:09:53 +00:00
|
|
|
out:
|
1997-09-21 04:24:27 +00:00
|
|
|
zfree(namei_zone, path);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
/*
|
|
|
|
* Delete a whiteout from the filesystem.
|
|
|
|
*/
|
|
|
|
/* ARGSUSED */
|
|
|
|
int
|
|
|
|
undelete(p, uap, retval)
|
|
|
|
struct proc *p;
|
|
|
|
register struct undelete_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
|
|
|
|
|
|
|
NDINIT(&nd, DELETE, LOCKPARENT|DOWHITEOUT, UIO_USERSPACE,
|
|
|
|
SCARG(uap, path), p);
|
|
|
|
error = namei(&nd);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
|
|
|
|
if (nd.ni_vp != NULLVP || !(nd.ni_cnd.cn_flags & ISWHITEOUT)) {
|
|
|
|
VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
|
|
|
|
if (nd.ni_dvp == nd.ni_vp)
|
|
|
|
vrele(nd.ni_dvp);
|
|
|
|
else
|
|
|
|
vput(nd.ni_dvp);
|
|
|
|
if (nd.ni_vp)
|
|
|
|
vrele(nd.ni_vp);
|
|
|
|
return (EEXIST);
|
|
|
|
}
|
|
|
|
|
|
|
|
VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
|
|
|
|
if (error = VOP_WHITEOUT(nd.ni_dvp, &nd.ni_cnd, DELETE))
|
|
|
|
VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
|
|
|
|
vput(nd.ni_dvp);
|
1997-04-04 17:46:21 +00:00
|
|
|
ASSERT_VOP_UNLOCKED(nd.ni_dvp, "undelete");
|
|
|
|
ASSERT_VOP_UNLOCKED(nd.ni_vp, "undelete");
|
1997-02-10 02:22:35 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Delete a name from the filesystem.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct unlink_args {
|
|
|
|
char *path;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
unlink(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
struct unlink_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register struct vnode *vp;
|
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
NDINIT(&nd, DELETE, LOCKPARENT, UIO_USERSPACE, SCARG(uap, path), p);
|
|
|
|
if (error = namei(&nd))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
vp = nd.ni_vp;
|
1997-02-10 02:22:35 +00:00
|
|
|
VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE);
|
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1996-05-24 16:19:23 +00:00
|
|
|
if (vp->v_type == VDIR)
|
|
|
|
error = EPERM; /* POSIX */
|
|
|
|
else {
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* The root of a mounted filesystem cannot be deleted.
|
1996-05-24 16:19:23 +00:00
|
|
|
*
|
|
|
|
* XXX: can this only be a VDIR case?
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
if (vp->v_flag & VROOT)
|
|
|
|
error = EBUSY;
|
|
|
|
else
|
1997-02-10 02:22:35 +00:00
|
|
|
(void) vnode_pager_uncache(vp, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!error) {
|
1997-02-10 02:22:35 +00:00
|
|
|
VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
|
1994-05-24 10:09:53 +00:00
|
|
|
error = VOP_REMOVE(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd);
|
|
|
|
} else {
|
|
|
|
VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
|
|
|
|
if (nd.ni_dvp == vp)
|
|
|
|
vrele(nd.ni_dvp);
|
|
|
|
else
|
|
|
|
vput(nd.ni_dvp);
|
1997-02-10 02:22:35 +00:00
|
|
|
if (vp != NULLVP)
|
|
|
|
vput(vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1997-04-04 17:46:21 +00:00
|
|
|
ASSERT_VOP_UNLOCKED(nd.ni_dvp, "unlink");
|
|
|
|
ASSERT_VOP_UNLOCKED(nd.ni_vp, "unlink");
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Reposition read/write file offset.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct lseek_args {
|
|
|
|
int fd;
|
|
|
|
int pad;
|
|
|
|
off_t offset;
|
|
|
|
int whence;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
lseek(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct lseek_args /* {
|
|
|
|
syscallarg(int) fd;
|
|
|
|
syscallarg(int) pad;
|
|
|
|
syscallarg(off_t) offset;
|
|
|
|
syscallarg(int) whence;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval; /* XXX */
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
struct ucred *cred = p->p_ucred;
|
|
|
|
register struct filedesc *fdp = p->p_fd;
|
|
|
|
register struct file *fp;
|
|
|
|
struct vattr vattr;
|
|
|
|
int error;
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
if ((u_int)SCARG(uap, fd) >= fdp->fd_nfiles ||
|
|
|
|
(fp = fdp->fd_ofiles[SCARG(uap, fd)]) == NULL)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (EBADF);
|
|
|
|
if (fp->f_type != DTYPE_VNODE)
|
|
|
|
return (ESPIPE);
|
1997-02-10 02:22:35 +00:00
|
|
|
switch (SCARG(uap, whence)) {
|
1994-05-24 10:09:53 +00:00
|
|
|
case L_INCR:
|
1997-02-10 02:22:35 +00:00
|
|
|
fp->f_offset += SCARG(uap, offset);
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
case L_XTND:
|
1994-10-02 17:35:40 +00:00
|
|
|
error=VOP_GETATTR((struct vnode *)fp->f_data, &vattr, cred, p);
|
|
|
|
if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
1997-02-10 02:22:35 +00:00
|
|
|
fp->f_offset = SCARG(uap, offset) + vattr.va_size;
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
case L_SET:
|
1997-02-10 02:22:35 +00:00
|
|
|
fp->f_offset = SCARG(uap, offset);
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return (EINVAL);
|
|
|
|
}
|
|
|
|
*(off_t *)retval = fp->f_offset;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
#if defined(COMPAT_43) || defined(COMPAT_SUNOS)
|
|
|
|
/*
|
|
|
|
* Reposition read/write file offset.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct olseek_args {
|
|
|
|
int fd;
|
|
|
|
long offset;
|
|
|
|
int whence;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
olseek(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct olseek_args /* {
|
|
|
|
syscallarg(int) fd;
|
|
|
|
syscallarg(long) offset;
|
|
|
|
syscallarg(int) whence;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1997-02-10 02:22:35 +00:00
|
|
|
struct lseek_args /* {
|
|
|
|
syscallarg(int) fd;
|
|
|
|
syscallarg(int) pad;
|
|
|
|
syscallarg(off_t) offset;
|
|
|
|
syscallarg(int) whence;
|
|
|
|
} */ nuap;
|
1994-05-24 10:09:53 +00:00
|
|
|
off_t qret;
|
|
|
|
int error;
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
SCARG(&nuap, fd) = SCARG(uap, fd);
|
|
|
|
SCARG(&nuap, offset) = SCARG(uap, offset);
|
|
|
|
SCARG(&nuap, whence) = SCARG(uap, whence);
|
|
|
|
error = lseek(p, &nuap, (register_t *) &qret);
|
1994-05-24 10:09:53 +00:00
|
|
|
*(long *)retval = qret;
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
#endif /* COMPAT_43 */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check access permissions.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct access_args {
|
|
|
|
char *path;
|
|
|
|
int flags;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
access(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct access_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
syscallarg(int) flags;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register struct ucred *cred = p->p_ucred;
|
|
|
|
register struct vnode *vp;
|
|
|
|
int error, flags, t_gid, t_uid;
|
|
|
|
struct nameidata nd;
|
|
|
|
|
|
|
|
t_uid = cred->cr_uid;
|
|
|
|
t_gid = cred->cr_groups[0];
|
|
|
|
cred->cr_uid = p->p_cred->p_ruid;
|
|
|
|
cred->cr_groups[0] = p->p_cred->p_rgid;
|
1997-02-10 02:22:35 +00:00
|
|
|
NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
|
|
|
|
SCARG(uap, path), p);
|
|
|
|
if (error = namei(&nd))
|
1994-05-24 10:09:53 +00:00
|
|
|
goto out1;
|
|
|
|
vp = nd.ni_vp;
|
|
|
|
|
|
|
|
/* Flags == 0 means only check for existence. */
|
1997-02-10 02:22:35 +00:00
|
|
|
if (SCARG(uap, flags)) {
|
1994-05-24 10:09:53 +00:00
|
|
|
flags = 0;
|
1997-02-10 02:22:35 +00:00
|
|
|
if (SCARG(uap, flags) & R_OK)
|
1994-05-24 10:09:53 +00:00
|
|
|
flags |= VREAD;
|
1997-02-10 02:22:35 +00:00
|
|
|
if (SCARG(uap, flags) & W_OK)
|
1994-05-24 10:09:53 +00:00
|
|
|
flags |= VWRITE;
|
1997-02-10 02:22:35 +00:00
|
|
|
if (SCARG(uap, flags) & X_OK)
|
1994-05-24 10:09:53 +00:00
|
|
|
flags |= VEXEC;
|
|
|
|
if ((flags & VWRITE) == 0 || (error = vn_writechk(vp)) == 0)
|
|
|
|
error = VOP_ACCESS(vp, flags, cred, p);
|
|
|
|
}
|
|
|
|
vput(vp);
|
|
|
|
out1:
|
|
|
|
cred->cr_uid = t_uid;
|
|
|
|
cred->cr_groups[0] = t_gid;
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
#if defined(COMPAT_43) || defined(COMPAT_SUNOS)
|
|
|
|
/*
|
|
|
|
* Get file status; this version follows links.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct ostat_args {
|
|
|
|
char *path;
|
|
|
|
struct ostat *ub;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
ostat(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct ostat_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
syscallarg(struct ostat *) ub;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
struct stat sb;
|
|
|
|
struct ostat osb;
|
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
|
|
|
|
SCARG(uap, path), p);
|
|
|
|
if (error = namei(&nd))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
error = vn_stat(nd.ni_vp, &sb, p);
|
|
|
|
vput(nd.ni_vp);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
cvtstat(&sb, &osb);
|
1997-02-10 02:22:35 +00:00
|
|
|
error = copyout((caddr_t)&osb, (caddr_t)SCARG(uap, ub), sizeof (osb));
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get file status; this version does not follow links.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct olstat_args {
|
|
|
|
char *path;
|
|
|
|
struct ostat *ub;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
olstat(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct olstat_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
syscallarg(struct ostat *) ub;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1997-03-31 12:02:53 +00:00
|
|
|
struct vnode *vp;
|
|
|
|
struct stat sb;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct ostat osb;
|
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
|
|
|
|
1997-03-31 12:02:53 +00:00
|
|
|
NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF, UIO_USERSPACE,
|
1997-02-10 02:22:35 +00:00
|
|
|
SCARG(uap, path), p);
|
|
|
|
if (error = namei(&nd))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
1994-09-02 04:14:44 +00:00
|
|
|
vp = nd.ni_vp;
|
1997-03-31 12:02:53 +00:00
|
|
|
error = vn_stat(vp, &sb, p);
|
|
|
|
if (vp->v_type == VLNK)
|
|
|
|
sb.st_mode |= S_IFLNK | ACCESSPERMS; /* 0777 */
|
|
|
|
vput(vp);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
1994-05-24 10:09:53 +00:00
|
|
|
cvtstat(&sb, &osb);
|
1997-02-10 02:22:35 +00:00
|
|
|
error = copyout((caddr_t)&osb, (caddr_t)SCARG(uap, ub), sizeof (osb));
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Convert from an old to a new stat structure.
|
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
void
|
1994-05-24 10:09:53 +00:00
|
|
|
cvtstat(st, ost)
|
|
|
|
struct stat *st;
|
|
|
|
struct ostat *ost;
|
|
|
|
{
|
|
|
|
|
|
|
|
ost->st_dev = st->st_dev;
|
|
|
|
ost->st_ino = st->st_ino;
|
|
|
|
ost->st_mode = st->st_mode;
|
|
|
|
ost->st_nlink = st->st_nlink;
|
|
|
|
ost->st_uid = st->st_uid;
|
|
|
|
ost->st_gid = st->st_gid;
|
|
|
|
ost->st_rdev = st->st_rdev;
|
|
|
|
if (st->st_size < (quad_t)1 << 32)
|
|
|
|
ost->st_size = st->st_size;
|
|
|
|
else
|
|
|
|
ost->st_size = -2;
|
|
|
|
ost->st_atime = st->st_atime;
|
|
|
|
ost->st_mtime = st->st_mtime;
|
|
|
|
ost->st_ctime = st->st_ctime;
|
|
|
|
ost->st_blksize = st->st_blksize;
|
|
|
|
ost->st_blocks = st->st_blocks;
|
|
|
|
ost->st_flags = st->st_flags;
|
|
|
|
ost->st_gen = st->st_gen;
|
|
|
|
}
|
|
|
|
#endif /* COMPAT_43 || COMPAT_SUNOS */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get file status; this version follows links.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct stat_args {
|
|
|
|
char *path;
|
|
|
|
struct stat *ub;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
stat(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct stat_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
syscallarg(struct stat *) ub;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
struct stat sb;
|
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
|
|
|
|
SCARG(uap, path), p);
|
|
|
|
if (error = namei(&nd))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
error = vn_stat(nd.ni_vp, &sb, p);
|
|
|
|
vput(nd.ni_vp);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
1997-02-10 02:22:35 +00:00
|
|
|
error = copyout((caddr_t)&sb, (caddr_t)SCARG(uap, ub), sizeof (sb));
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get file status; this version does not follow links.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct lstat_args {
|
|
|
|
char *path;
|
|
|
|
struct stat *ub;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
lstat(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct lstat_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
syscallarg(struct stat *) ub;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
int error;
|
1997-03-31 12:02:53 +00:00
|
|
|
struct vnode *vp;
|
|
|
|
struct stat sb;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct nameidata nd;
|
|
|
|
|
1997-03-31 12:02:53 +00:00
|
|
|
NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF, UIO_USERSPACE,
|
1997-02-10 02:22:35 +00:00
|
|
|
SCARG(uap, path), p);
|
|
|
|
if (error = namei(&nd))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
vp = nd.ni_vp;
|
1997-03-31 12:02:53 +00:00
|
|
|
error = vn_stat(vp, &sb, p);
|
|
|
|
if (vp->v_type == VLNK)
|
|
|
|
sb.st_mode |= S_IFLNK | ACCESSPERMS; /* 0777 */
|
|
|
|
vput(vp);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
1997-02-10 02:22:35 +00:00
|
|
|
error = copyout((caddr_t)&sb, (caddr_t)SCARG(uap, ub), sizeof (sb));
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get configurable pathname variables.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct pathconf_args {
|
|
|
|
char *path;
|
|
|
|
int name;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
pathconf(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct pathconf_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
syscallarg(int) name;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
|
|
|
|
SCARG(uap, path), p);
|
|
|
|
if (error = namei(&nd))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
1997-02-10 02:22:35 +00:00
|
|
|
error = VOP_PATHCONF(nd.ni_vp, SCARG(uap, name), retval);
|
1994-05-24 10:09:53 +00:00
|
|
|
vput(nd.ni_vp);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return target name of a symbolic link.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct readlink_args {
|
|
|
|
char *path;
|
|
|
|
char *buf;
|
|
|
|
int count;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
readlink(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct readlink_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
syscallarg(char *) buf;
|
|
|
|
syscallarg(int) count;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register struct vnode *vp;
|
|
|
|
struct iovec aiov;
|
|
|
|
struct uio auio;
|
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF, UIO_USERSPACE,
|
|
|
|
SCARG(uap, path), p);
|
|
|
|
if (error = namei(&nd))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
vp = nd.ni_vp;
|
|
|
|
if (vp->v_type != VLNK)
|
|
|
|
error = EINVAL;
|
|
|
|
else {
|
1997-02-10 02:22:35 +00:00
|
|
|
aiov.iov_base = SCARG(uap, buf);
|
|
|
|
aiov.iov_len = SCARG(uap, count);
|
1994-05-24 10:09:53 +00:00
|
|
|
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;
|
1997-02-10 02:22:35 +00:00
|
|
|
auio.uio_resid = SCARG(uap, count);
|
1994-05-24 10:09:53 +00:00
|
|
|
error = VOP_READLINK(vp, &auio, p->p_ucred);
|
|
|
|
}
|
|
|
|
vput(vp);
|
1997-02-10 02:22:35 +00:00
|
|
|
*retval = SCARG(uap, count) - auio.uio_resid;
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Change flags of a file given a path name.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct chflags_args {
|
|
|
|
char *path;
|
|
|
|
int flags;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
chflags(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct chflags_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
syscallarg(int) flags;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register struct vnode *vp;
|
|
|
|
struct vattr vattr;
|
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p);
|
|
|
|
if (error = namei(&nd))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
vp = nd.ni_vp;
|
1997-02-10 02:22:35 +00:00
|
|
|
VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE);
|
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
|
1995-10-22 09:32:48 +00:00
|
|
|
VATTR_NULL(&vattr);
|
1997-02-10 02:22:35 +00:00
|
|
|
vattr.va_flags = SCARG(uap, flags);
|
1995-10-22 09:32:48 +00:00
|
|
|
error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
vput(vp);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Change flags of a file given a file descriptor.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct fchflags_args {
|
|
|
|
int fd;
|
|
|
|
int flags;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
fchflags(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct fchflags_args /* {
|
|
|
|
syscallarg(int) fd;
|
|
|
|
syscallarg(int) flags;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
struct vattr vattr;
|
|
|
|
struct vnode *vp;
|
|
|
|
struct file *fp;
|
|
|
|
int error;
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
if (error = getvnode(p->p_fd, SCARG(uap, fd), &fp))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
vp = (struct vnode *)fp->f_data;
|
1997-02-10 02:22:35 +00:00
|
|
|
VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE);
|
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
|
1995-10-22 09:32:48 +00:00
|
|
|
VATTR_NULL(&vattr);
|
1997-02-10 02:22:35 +00:00
|
|
|
vattr.va_flags = SCARG(uap, flags);
|
1995-10-22 09:32:48 +00:00
|
|
|
error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
|
1997-02-10 02:22:35 +00:00
|
|
|
VOP_UNLOCK(vp, 0, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Change mode of a file given path name.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct chmod_args {
|
|
|
|
char *path;
|
|
|
|
int mode;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
chmod(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct chmod_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
syscallarg(int) mode;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register struct vnode *vp;
|
|
|
|
struct vattr vattr;
|
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p);
|
|
|
|
if (error = namei(&nd))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
vp = nd.ni_vp;
|
1997-02-10 02:22:35 +00:00
|
|
|
VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE);
|
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
|
1995-10-22 09:32:48 +00:00
|
|
|
VATTR_NULL(&vattr);
|
1997-02-10 02:22:35 +00:00
|
|
|
vattr.va_mode = SCARG(uap, mode) & ALLPERMS;
|
1995-10-22 09:32:48 +00:00
|
|
|
error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
vput(vp);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Change mode of a file given a file descriptor.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct fchmod_args {
|
|
|
|
int fd;
|
|
|
|
int mode;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
fchmod(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct fchmod_args /* {
|
|
|
|
syscallarg(int) fd;
|
|
|
|
syscallarg(int) mode;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
struct vattr vattr;
|
|
|
|
struct vnode *vp;
|
|
|
|
struct file *fp;
|
|
|
|
int error;
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
if (error = getvnode(p->p_fd, SCARG(uap, fd), &fp))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
vp = (struct vnode *)fp->f_data;
|
1997-02-10 02:22:35 +00:00
|
|
|
VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE);
|
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
|
1995-10-22 09:32:48 +00:00
|
|
|
VATTR_NULL(&vattr);
|
1997-02-10 02:22:35 +00:00
|
|
|
vattr.va_mode = SCARG(uap, mode) & ALLPERMS;
|
1995-10-22 09:32:48 +00:00
|
|
|
error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
|
1997-02-10 02:22:35 +00:00
|
|
|
VOP_UNLOCK(vp, 0, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set ownership given a path name.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct chown_args {
|
|
|
|
char *path;
|
|
|
|
int uid;
|
|
|
|
int gid;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
chown(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct chown_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
syscallarg(int) uid;
|
|
|
|
syscallarg(int) gid;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register struct vnode *vp;
|
|
|
|
struct vattr vattr;
|
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p);
|
|
|
|
if (error = namei(&nd))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
vp = nd.ni_vp;
|
1997-02-10 02:22:35 +00:00
|
|
|
VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE);
|
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
|
1995-10-22 09:32:48 +00:00
|
|
|
VATTR_NULL(&vattr);
|
1997-02-10 02:22:35 +00:00
|
|
|
vattr.va_uid = SCARG(uap, uid);
|
|
|
|
vattr.va_gid = SCARG(uap, gid);
|
1995-10-22 09:32:48 +00:00
|
|
|
error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
vput(vp);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
1997-03-31 12:21:37 +00:00
|
|
|
/*
|
|
|
|
* Set ownership given a path name, do not cross symlinks.
|
|
|
|
*/
|
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct lchown_args {
|
|
|
|
char *path;
|
|
|
|
int uid;
|
|
|
|
int gid;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
/* ARGSUSED */
|
|
|
|
int
|
|
|
|
lchown(p, uap, retval)
|
|
|
|
struct proc *p;
|
|
|
|
register struct lchown_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
syscallarg(int) uid;
|
|
|
|
syscallarg(int) gid;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
|
|
|
{
|
|
|
|
register struct vnode *vp;
|
|
|
|
struct vattr vattr;
|
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
|
|
|
|
|
|
|
NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, SCARG(uap, path), p);
|
|
|
|
if (error = namei(&nd))
|
|
|
|
return (error);
|
|
|
|
vp = nd.ni_vp;
|
|
|
|
VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE);
|
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
|
|
|
|
VATTR_NULL(&vattr);
|
|
|
|
vattr.va_uid = SCARG(uap, uid);
|
|
|
|
vattr.va_gid = SCARG(uap, gid);
|
|
|
|
error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
|
|
|
|
vput(vp);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Set ownership given a file descriptor.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct fchown_args {
|
|
|
|
int fd;
|
|
|
|
int uid;
|
|
|
|
int gid;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
fchown(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct fchown_args /* {
|
|
|
|
syscallarg(int) fd;
|
|
|
|
syscallarg(int) uid;
|
|
|
|
syscallarg(int) gid;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
struct vattr vattr;
|
|
|
|
struct vnode *vp;
|
|
|
|
struct file *fp;
|
|
|
|
int error;
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
if (error = getvnode(p->p_fd, SCARG(uap, fd), &fp))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
vp = (struct vnode *)fp->f_data;
|
1997-02-10 02:22:35 +00:00
|
|
|
VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE);
|
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
|
1995-10-22 09:32:48 +00:00
|
|
|
VATTR_NULL(&vattr);
|
1997-02-10 02:22:35 +00:00
|
|
|
vattr.va_uid = SCARG(uap, uid);
|
|
|
|
vattr.va_gid = SCARG(uap, gid);
|
1995-10-22 09:32:48 +00:00
|
|
|
error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
|
1997-02-10 02:22:35 +00:00
|
|
|
VOP_UNLOCK(vp, 0, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set the access and modification times of a file.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct utimes_args {
|
|
|
|
char *path;
|
|
|
|
struct timeval *tptr;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
utimes(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct utimes_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
syscallarg(struct timeval *) tptr;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register struct vnode *vp;
|
|
|
|
struct timeval tv[2];
|
|
|
|
struct vattr vattr;
|
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
|
|
|
|
|
|
|
VATTR_NULL(&vattr);
|
1997-02-10 02:22:35 +00:00
|
|
|
if (SCARG(uap, tptr) == NULL) {
|
1994-05-24 10:09:53 +00:00
|
|
|
microtime(&tv[0]);
|
|
|
|
tv[1] = tv[0];
|
|
|
|
vattr.va_vaflags |= VA_UTIMES_NULL;
|
1997-02-10 02:22:35 +00:00
|
|
|
} else if (error = copyin((caddr_t)SCARG(uap, tptr), (caddr_t)tv,
|
|
|
|
sizeof (tv)))
|
|
|
|
return (error);
|
|
|
|
NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p);
|
|
|
|
if (error = namei(&nd))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
vp = nd.ni_vp;
|
1997-02-10 02:22:35 +00:00
|
|
|
VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE);
|
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
|
1996-09-19 18:21:32 +00:00
|
|
|
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;
|
1995-10-22 09:32:48 +00:00
|
|
|
error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
vput(vp);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Truncate a file given its path name.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct truncate_args {
|
|
|
|
char *path;
|
|
|
|
int pad;
|
|
|
|
off_t length;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
truncate(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct truncate_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
syscallarg(int) pad;
|
|
|
|
syscallarg(off_t) length;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register struct vnode *vp;
|
|
|
|
struct vattr vattr;
|
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
|
|
|
|
1994-09-02 10:23:43 +00:00
|
|
|
if (uap->length < 0)
|
|
|
|
return(EINVAL);
|
1997-02-10 02:22:35 +00:00
|
|
|
NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p);
|
|
|
|
if (error = namei(&nd))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
vp = nd.ni_vp;
|
1997-02-10 02:22:35 +00:00
|
|
|
VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE);
|
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (vp->v_type == VDIR)
|
|
|
|
error = EISDIR;
|
|
|
|
else if ((error = vn_writechk(vp)) == 0 &&
|
|
|
|
(error = VOP_ACCESS(vp, VWRITE, p->p_ucred, p)) == 0) {
|
|
|
|
VATTR_NULL(&vattr);
|
1997-02-10 02:22:35 +00:00
|
|
|
vattr.va_size = SCARG(uap, length);
|
1994-05-24 10:09:53 +00:00
|
|
|
error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
|
|
|
|
}
|
|
|
|
vput(vp);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Truncate a file given a file descriptor.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct ftruncate_args {
|
|
|
|
int fd;
|
|
|
|
int pad;
|
|
|
|
off_t length;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
ftruncate(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct ftruncate_args /* {
|
|
|
|
syscallarg(int) fd;
|
|
|
|
syscallarg(int) pad;
|
|
|
|
syscallarg(off_t) length;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
struct vattr vattr;
|
|
|
|
struct vnode *vp;
|
|
|
|
struct file *fp;
|
|
|
|
int error;
|
|
|
|
|
1994-09-02 10:23:43 +00:00
|
|
|
if (uap->length < 0)
|
|
|
|
return(EINVAL);
|
1997-02-10 02:22:35 +00:00
|
|
|
if (error = getvnode(p->p_fd, SCARG(uap, fd), &fp))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
if ((fp->f_flag & FWRITE) == 0)
|
|
|
|
return (EINVAL);
|
|
|
|
vp = (struct vnode *)fp->f_data;
|
1997-02-10 02:22:35 +00:00
|
|
|
VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE);
|
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (vp->v_type == VDIR)
|
|
|
|
error = EISDIR;
|
|
|
|
else if ((error = vn_writechk(vp)) == 0) {
|
|
|
|
VATTR_NULL(&vattr);
|
1997-02-10 02:22:35 +00:00
|
|
|
vattr.va_size = SCARG(uap, length);
|
1994-05-24 10:09:53 +00:00
|
|
|
error = VOP_SETATTR(vp, &vattr, fp->f_cred, p);
|
|
|
|
}
|
1997-02-10 02:22:35 +00:00
|
|
|
VOP_UNLOCK(vp, 0, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
#if defined(COMPAT_43) || defined(COMPAT_SUNOS)
|
|
|
|
/*
|
|
|
|
* Truncate a file given its path name.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct otruncate_args {
|
|
|
|
char *path;
|
|
|
|
long length;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
otruncate(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct otruncate_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
syscallarg(long) length;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1997-02-10 02:22:35 +00:00
|
|
|
struct truncate_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
syscallarg(int) pad;
|
|
|
|
syscallarg(off_t) length;
|
|
|
|
} */ nuap;
|
|
|
|
|
|
|
|
SCARG(&nuap, path) = SCARG(uap, path);
|
|
|
|
SCARG(&nuap, length) = SCARG(uap, length);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (truncate(p, &nuap, retval));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Truncate a file given a file descriptor.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct oftruncate_args {
|
|
|
|
int fd;
|
|
|
|
long length;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
oftruncate(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct oftruncate_args /* {
|
|
|
|
syscallarg(int) fd;
|
|
|
|
syscallarg(long) length;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1997-02-10 02:22:35 +00:00
|
|
|
struct ftruncate_args /* {
|
|
|
|
syscallarg(int) fd;
|
|
|
|
syscallarg(int) pad;
|
|
|
|
syscallarg(off_t) length;
|
|
|
|
} */ nuap;
|
|
|
|
|
|
|
|
SCARG(&nuap, fd) = SCARG(uap, fd);
|
|
|
|
SCARG(&nuap, length) = SCARG(uap, length);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (ftruncate(p, &nuap, retval));
|
|
|
|
}
|
|
|
|
#endif /* COMPAT_43 || COMPAT_SUNOS */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Sync an open file.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct fsync_args {
|
|
|
|
int fd;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
fsync(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
struct fsync_args /* {
|
|
|
|
syscallarg(int) fd;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register struct vnode *vp;
|
|
|
|
struct file *fp;
|
|
|
|
int error;
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
if (error = getvnode(p->p_fd, SCARG(uap, fd), &fp))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
vp = (struct vnode *)fp->f_data;
|
1997-02-10 02:22:35 +00:00
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
|
1995-06-28 12:01:13 +00:00
|
|
|
if (vp->v_object) {
|
NOTE: libkvm, w, ps, 'top', and any other utility which depends on struct
proc or any VM system structure will have to be rebuilt!!!
Much needed overhaul of the VM system. Included in this first round of
changes:
1) Improved pager interfaces: init, alloc, dealloc, getpages, putpages,
haspage, and sync operations are supported. The haspage interface now
provides information about clusterability. All pager routines now take
struct vm_object's instead of "pagers".
2) Improved data structures. In the previous paradigm, there is constant
confusion caused by pagers being both a data structure ("allocate a
pager") and a collection of routines. The idea of a pager structure has
escentially been eliminated. Objects now have types, and this type is
used to index the appropriate pager. In most cases, items in the pager
structure were duplicated in the object data structure and thus were
unnecessary. In the few cases that remained, a un_pager structure union
was created in the object to contain these items.
3) Because of the cleanup of #1 & #2, a lot of unnecessary layering can now
be removed. For instance, vm_object_enter(), vm_object_lookup(),
vm_object_remove(), and the associated object hash list were some of the
things that were removed.
4) simple_lock's removed. Discussion with several people reveals that the
SMP locking primitives used in the VM system aren't likely the mechanism
that we'll be adopting. Even if it were, the locking that was in the code
was very inadequate and would have to be mostly re-done anyway. The
locking in a uni-processor kernel was a no-op but went a long way toward
making the code difficult to read and debug.
5) Places that attempted to kludge-up the fact that we don't have kernel
thread support have been fixed to reflect the reality that we are really
dealing with processes, not threads. The VM system didn't have complete
thread support, so the comments and mis-named routines were just wrong.
We now use tsleep and wakeup directly in the lock routines, for instance.
6) Where appropriate, the pagers have been improved, especially in the
pager_alloc routines. Most of the pager_allocs have been rewritten and
are now faster and easier to maintain.
7) The pagedaemon pageout clustering algorithm has been rewritten and
now tries harder to output an even number of pages before and after
the requested page. This is sort of the reverse of the ideal pagein
algorithm and should provide better overall performance.
8) Unnecessary (incorrect) casts to caddr_t in calls to tsleep & wakeup
have been removed. Some other unnecessary casts have also been removed.
9) Some almost useless debugging code removed.
10) Terminology of shadow objects vs. backing objects straightened out.
The fact that the vm_object data structure escentially had this
backwards really confused things. The use of "shadow" and "backing
object" throughout the code is now internally consistent and correct
in the Mach terminology.
11) Several minor bug fixes, including one in the vm daemon that caused
0 RSS objects to not get purged as intended.
12) A "default pager" has now been created which cleans up the transition
of objects to the "swap" type. The previous checks throughout the code
for swp->pg_data != NULL were really ugly. This change also provides
the rudiments for future backing of "anonymous" memory by something
other than the swap pager (via the vnode pager, for example), and it
allows the decision about which of these pagers to use to be made
dynamically (although will need some additional decision code to do
this, of course).
13) (dyson) MAP_COPY has been deprecated and the corresponding "copy
object" code has been removed. MAP_COPY was undocumented and non-
standard. It was furthermore broken in several ways which caused its
behavior to degrade to MAP_PRIVATE. Binaries that use MAP_COPY will
continue to work correctly, but via the slightly different semantics
of MAP_PRIVATE.
14) (dyson) Sharing maps have been removed. It's marginal usefulness in a
threads design can be worked around in other ways. Both #12 and #13
were done to simplify the code and improve readability and maintain-
ability. (As were most all of these changes)
TODO:
1) Rewrite most of the vnode pager to use VOP_GETPAGES/PUTPAGES. Doing
this will reduce the vnode pager to a mere fraction of its current size.
2) Rewrite vm_fault and the swap/vnode pagers to use the clustering
information provided by the new haspage pager interface. This will
substantially reduce the overhead by eliminating a large number of
VOP_BMAP() calls. The VOP_BMAP() filesystem interface should be
improved to provide both a "behind" and "ahead" indication of
contiguousness.
3) Implement the extended features of pager_haspage in swap_pager_haspage().
It currently just says 0 pages ahead/behind.
4) Re-implement the swap device (swstrategy) in a more elegant way, perhaps
via a much more general mechanism that could also be used for disk
striping of regular filesystems.
5) Do something to improve the architecture of vm_object_collapse(). The
fact that it makes calls into the swap pager and knows too much about
how the swap pager operates really bothers me. It also doesn't allow
for collapsing of non-swap pager objects ("unnamed" objects backed by
other pagers).
1995-07-13 08:48:48 +00:00
|
|
|
vm_object_page_clean(vp->v_object, 0, 0 ,0, FALSE);
|
1995-05-21 21:39:31 +00:00
|
|
|
}
|
1995-11-05 21:01:15 +00:00
|
|
|
error = VOP_FSYNC(vp, fp->f_cred,
|
1997-03-05 01:42:14 +00:00
|
|
|
(vp->v_mount && (vp->v_mount->mnt_flag & MNT_ASYNC)) ?
|
|
|
|
MNT_NOWAIT : MNT_WAIT, p);
|
1997-02-10 02:22:35 +00:00
|
|
|
VOP_UNLOCK(vp, 0, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Rename files. Source and destination must either both be directories,
|
|
|
|
* or both not be directories. If target is a directory, it must be empty.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct rename_args {
|
|
|
|
char *from;
|
|
|
|
char *to;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
rename(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct rename_args /* {
|
|
|
|
syscallarg(char *) from;
|
|
|
|
syscallarg(char *) to;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register struct vnode *tvp, *fvp, *tdvp;
|
|
|
|
struct nameidata fromnd, tond;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
NDINIT(&fromnd, DELETE, WANTPARENT | SAVESTART, UIO_USERSPACE,
|
1997-02-10 02:22:35 +00:00
|
|
|
SCARG(uap, from), p);
|
|
|
|
if (error = namei(&fromnd))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
fvp = fromnd.ni_vp;
|
|
|
|
NDINIT(&tond, RENAME, LOCKPARENT | LOCKLEAF | NOCACHE | SAVESTART,
|
1997-02-10 02:22:35 +00:00
|
|
|
UIO_USERSPACE, SCARG(uap, to), p);
|
1995-07-31 00:35:58 +00:00
|
|
|
if (fromnd.ni_vp->v_type == VDIR)
|
|
|
|
tond.ni_cnd.cn_flags |= WILLBEDIR;
|
1997-02-10 02:22:35 +00:00
|
|
|
if (error = namei(&tond)) {
|
1995-11-18 11:35:05 +00:00
|
|
|
/* Translate error code for rename("dir1", "dir2/."). */
|
|
|
|
if (error == EISDIR && fvp->v_type == VDIR)
|
|
|
|
error = EINVAL;
|
1994-05-24 10:09:53 +00:00
|
|
|
VOP_ABORTOP(fromnd.ni_dvp, &fromnd.ni_cnd);
|
|
|
|
vrele(fromnd.ni_dvp);
|
|
|
|
vrele(fvp);
|
|
|
|
goto out1;
|
|
|
|
}
|
|
|
|
tdvp = tond.ni_dvp;
|
|
|
|
tvp = tond.ni_vp;
|
|
|
|
if (tvp != NULL) {
|
|
|
|
if (fvp->v_type == VDIR && tvp->v_type != VDIR) {
|
|
|
|
error = ENOTDIR;
|
|
|
|
goto out;
|
|
|
|
} else if (fvp->v_type != VDIR && tvp->v_type == VDIR) {
|
|
|
|
error = EISDIR;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (fvp == tdvp)
|
|
|
|
error = EINVAL;
|
|
|
|
/*
|
|
|
|
* If source is the same as the destination (that is the
|
|
|
|
* same inode number with the same name in the same directory),
|
|
|
|
* then there is nothing to do.
|
|
|
|
*/
|
|
|
|
if (fvp == tvp && fromnd.ni_dvp == tdvp &&
|
|
|
|
fromnd.ni_cnd.cn_namelen == tond.ni_cnd.cn_namelen &&
|
|
|
|
!bcmp(fromnd.ni_cnd.cn_nameptr, tond.ni_cnd.cn_nameptr,
|
|
|
|
fromnd.ni_cnd.cn_namelen))
|
|
|
|
error = -1;
|
|
|
|
out:
|
|
|
|
if (!error) {
|
1997-02-10 02:22:35 +00:00
|
|
|
VOP_LEASE(tdvp, p, p->p_ucred, LEASE_WRITE);
|
|
|
|
if (fromnd.ni_dvp != tdvp)
|
|
|
|
VOP_LEASE(fromnd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
|
1995-03-19 11:16:58 +00:00
|
|
|
if (tvp) {
|
1997-02-10 02:22:35 +00:00
|
|
|
VOP_LEASE(tvp, p, p->p_ucred, LEASE_WRITE);
|
|
|
|
(void) vnode_pager_uncache(tvp, p);
|
1995-03-19 11:16:58 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
error = VOP_RENAME(fromnd.ni_dvp, fromnd.ni_vp, &fromnd.ni_cnd,
|
|
|
|
tond.ni_dvp, tond.ni_vp, &tond.ni_cnd);
|
|
|
|
} else {
|
|
|
|
VOP_ABORTOP(tond.ni_dvp, &tond.ni_cnd);
|
|
|
|
if (tdvp == tvp)
|
|
|
|
vrele(tdvp);
|
|
|
|
else
|
|
|
|
vput(tdvp);
|
|
|
|
if (tvp)
|
|
|
|
vput(tvp);
|
|
|
|
VOP_ABORTOP(fromnd.ni_dvp, &fromnd.ni_cnd);
|
|
|
|
vrele(fromnd.ni_dvp);
|
|
|
|
vrele(fvp);
|
|
|
|
}
|
|
|
|
vrele(tond.ni_startdir);
|
1997-04-04 17:46:21 +00:00
|
|
|
ASSERT_VOP_UNLOCKED(fromnd.ni_dvp, "rename");
|
|
|
|
ASSERT_VOP_UNLOCKED(fromnd.ni_vp, "rename");
|
|
|
|
ASSERT_VOP_UNLOCKED(tond.ni_dvp, "rename");
|
|
|
|
ASSERT_VOP_UNLOCKED(tond.ni_vp, "rename");
|
1997-09-21 04:24:27 +00:00
|
|
|
zfree(namei_zone, tond.ni_cnd.cn_pnbuf);
|
1994-05-24 10:09:53 +00:00
|
|
|
out1:
|
|
|
|
if (fromnd.ni_startdir)
|
|
|
|
vrele(fromnd.ni_startdir);
|
1997-09-21 04:24:27 +00:00
|
|
|
zfree(namei_zone, fromnd.ni_cnd.cn_pnbuf);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (error == -1)
|
|
|
|
return (0);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Make a directory file.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct mkdir_args {
|
|
|
|
char *path;
|
|
|
|
int mode;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
mkdir(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct mkdir_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
syscallarg(int) mode;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register struct vnode *vp;
|
|
|
|
struct vattr vattr;
|
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, SCARG(uap, path), p);
|
1995-07-31 00:35:58 +00:00
|
|
|
nd.ni_cnd.cn_flags |= WILLBEDIR;
|
1997-02-10 02:22:35 +00:00
|
|
|
if (error = namei(&nd))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
vp = nd.ni_vp;
|
|
|
|
if (vp != NULL) {
|
|
|
|
VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
|
|
|
|
if (nd.ni_dvp == vp)
|
|
|
|
vrele(nd.ni_dvp);
|
|
|
|
else
|
|
|
|
vput(nd.ni_dvp);
|
|
|
|
vrele(vp);
|
|
|
|
return (EEXIST);
|
|
|
|
}
|
|
|
|
VATTR_NULL(&vattr);
|
|
|
|
vattr.va_type = VDIR;
|
1997-02-10 02:22:35 +00:00
|
|
|
vattr.va_mode = (SCARG(uap, mode) & ACCESSPERMS) &~ p->p_fd->fd_cmask;
|
|
|
|
VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
|
1994-05-24 10:09:53 +00:00
|
|
|
error = VOP_MKDIR(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr);
|
|
|
|
if (!error)
|
|
|
|
vput(nd.ni_vp);
|
1997-04-04 17:46:21 +00:00
|
|
|
ASSERT_VOP_UNLOCKED(nd.ni_dvp, "mkdir");
|
|
|
|
ASSERT_VOP_UNLOCKED(nd.ni_vp, "mkdir");
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Remove a directory file.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct rmdir_args {
|
|
|
|
char *path;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
rmdir(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
struct rmdir_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register struct vnode *vp;
|
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
NDINIT(&nd, DELETE, LOCKPARENT | LOCKLEAF, UIO_USERSPACE,
|
|
|
|
SCARG(uap, path), p);
|
|
|
|
if (error = namei(&nd))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
vp = nd.ni_vp;
|
|
|
|
if (vp->v_type != VDIR) {
|
|
|
|
error = ENOTDIR;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* No rmdir "." please.
|
|
|
|
*/
|
|
|
|
if (nd.ni_dvp == vp) {
|
|
|
|
error = EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* The root of a mounted filesystem cannot be deleted.
|
|
|
|
*/
|
|
|
|
if (vp->v_flag & VROOT)
|
|
|
|
error = EBUSY;
|
|
|
|
out:
|
|
|
|
if (!error) {
|
1997-02-10 02:22:35 +00:00
|
|
|
VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
|
|
|
|
VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE);
|
1994-05-24 10:09:53 +00:00
|
|
|
error = VOP_RMDIR(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd);
|
|
|
|
} else {
|
|
|
|
VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
|
|
|
|
if (nd.ni_dvp == vp)
|
|
|
|
vrele(nd.ni_dvp);
|
|
|
|
else
|
|
|
|
vput(nd.ni_dvp);
|
|
|
|
vput(vp);
|
|
|
|
}
|
1997-04-04 17:46:21 +00:00
|
|
|
ASSERT_VOP_UNLOCKED(nd.ni_dvp, "rmdir");
|
|
|
|
ASSERT_VOP_UNLOCKED(nd.ni_vp, "rmdir");
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef COMPAT_43
|
|
|
|
/*
|
|
|
|
* Read a block of directory entries in a file system independent format.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct ogetdirentries_args {
|
|
|
|
int fd;
|
|
|
|
char *buf;
|
|
|
|
u_int count;
|
|
|
|
long *basep;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
ogetdirentries(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct ogetdirentries_args /* {
|
|
|
|
syscallarg(int) fd;
|
|
|
|
syscallarg(char *) buf;
|
|
|
|
syscallarg(u_int) count;
|
|
|
|
syscallarg(long *) basep;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register struct vnode *vp;
|
|
|
|
struct file *fp;
|
|
|
|
struct uio auio, kuio;
|
|
|
|
struct iovec aiov, kiov;
|
|
|
|
struct dirent *dp, *edp;
|
|
|
|
caddr_t dirbuf;
|
1997-02-10 02:22:35 +00:00
|
|
|
int error, eofflag, readcnt;
|
1994-05-24 10:09:53 +00:00
|
|
|
long loff;
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
if (error = getvnode(p->p_fd, SCARG(uap, fd), &fp))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
if ((fp->f_flag & FREAD) == 0)
|
|
|
|
return (EBADF);
|
|
|
|
vp = (struct vnode *)fp->f_data;
|
1997-02-10 02:22:35 +00:00
|
|
|
unionread:
|
1994-05-24 10:09:53 +00:00
|
|
|
if (vp->v_type != VDIR)
|
|
|
|
return (EINVAL);
|
1997-02-10 02:22:35 +00:00
|
|
|
aiov.iov_base = SCARG(uap, buf);
|
|
|
|
aiov.iov_len = SCARG(uap, count);
|
1994-05-24 10:09:53 +00:00
|
|
|
auio.uio_iov = &aiov;
|
|
|
|
auio.uio_iovcnt = 1;
|
|
|
|
auio.uio_rw = UIO_READ;
|
|
|
|
auio.uio_segflg = UIO_USERSPACE;
|
|
|
|
auio.uio_procp = p;
|
1997-02-10 02:22:35 +00:00
|
|
|
auio.uio_resid = SCARG(uap, count);
|
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
loff = auio.uio_offset = fp->f_offset;
|
|
|
|
# if (BYTE_ORDER != LITTLE_ENDIAN)
|
|
|
|
if (vp->v_mount->mnt_maxsymlinklen <= 0) {
|
1997-02-10 02:22:35 +00:00
|
|
|
error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag,
|
|
|
|
NULL, NULL);
|
1994-05-24 10:09:53 +00:00
|
|
|
fp->f_offset = auio.uio_offset;
|
|
|
|
} else
|
|
|
|
# endif
|
|
|
|
{
|
|
|
|
kuio = auio;
|
|
|
|
kuio.uio_iov = &kiov;
|
|
|
|
kuio.uio_segflg = UIO_SYSSPACE;
|
1997-02-10 02:22:35 +00:00
|
|
|
kiov.iov_len = SCARG(uap, count);
|
|
|
|
MALLOC(dirbuf, caddr_t, SCARG(uap, count), M_TEMP, M_WAITOK);
|
1994-05-24 10:09:53 +00:00
|
|
|
kiov.iov_base = dirbuf;
|
1997-02-10 02:22:35 +00:00
|
|
|
error = VOP_READDIR(vp, &kuio, fp->f_cred, &eofflag,
|
|
|
|
NULL, NULL);
|
1994-05-24 10:09:53 +00:00
|
|
|
fp->f_offset = kuio.uio_offset;
|
|
|
|
if (error == 0) {
|
1997-02-10 02:22:35 +00:00
|
|
|
readcnt = SCARG(uap, count) - kuio.uio_resid;
|
1994-05-24 10:09:53 +00:00
|
|
|
edp = (struct dirent *)&dirbuf[readcnt];
|
|
|
|
for (dp = (struct dirent *)dirbuf; dp < edp; ) {
|
|
|
|
# if (BYTE_ORDER == LITTLE_ENDIAN)
|
|
|
|
/*
|
|
|
|
* The expected low byte of
|
|
|
|
* dp->d_namlen is our dp->d_type.
|
|
|
|
* The high MBZ byte of dp->d_namlen
|
|
|
|
* is our dp->d_namlen.
|
|
|
|
*/
|
|
|
|
dp->d_type = dp->d_namlen;
|
|
|
|
dp->d_namlen = 0;
|
|
|
|
# else
|
|
|
|
/*
|
|
|
|
* The dp->d_type is the high byte
|
|
|
|
* of the expected dp->d_namlen,
|
|
|
|
* so must be zero'ed.
|
|
|
|
*/
|
|
|
|
dp->d_type = 0;
|
|
|
|
# endif
|
|
|
|
if (dp->d_reclen > 0) {
|
|
|
|
dp = (struct dirent *)
|
|
|
|
((char *)dp + dp->d_reclen);
|
|
|
|
} else {
|
|
|
|
error = EIO;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (dp >= edp)
|
|
|
|
error = uiomove(dirbuf, readcnt, &auio);
|
|
|
|
}
|
|
|
|
FREE(dirbuf, M_TEMP);
|
|
|
|
}
|
1997-02-10 02:22:35 +00:00
|
|
|
VOP_UNLOCK(vp, 0, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
1997-02-10 02:22:35 +00:00
|
|
|
|
|
|
|
#ifdef UNION
|
|
|
|
{
|
|
|
|
if ((SCARG(uap, count) == auio.uio_resid) &&
|
|
|
|
(vp->v_op == union_vnodeop_p)) {
|
|
|
|
struct vnode *lvp;
|
|
|
|
|
|
|
|
lvp = union_dircache(vp, p);
|
|
|
|
if (lvp != NULLVP) {
|
|
|
|
struct vattr va;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the directory is opaque,
|
|
|
|
* then don't show lower entries
|
|
|
|
*/
|
|
|
|
error = VOP_GETATTR(vp, &va, fp->f_cred, p);
|
|
|
|
if (va.va_flags & OPAQUE) {
|
|
|
|
vput(lvp);
|
|
|
|
lvp = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (lvp != NULLVP) {
|
|
|
|
error = VOP_OPEN(lvp, FREAD, fp->f_cred, p);
|
|
|
|
if (error) {
|
|
|
|
vput(lvp);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
VOP_UNLOCK(lvp, 0, p);
|
|
|
|
fp->f_data = (caddr_t) lvp;
|
|
|
|
fp->f_offset = 0;
|
|
|
|
error = vn_close(vp, FREAD, fp->f_cred, p);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
vp = lvp;
|
|
|
|
goto unionread;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* UNION */
|
|
|
|
|
|
|
|
if ((SCARG(uap, count) == auio.uio_resid) &&
|
|
|
|
(vp->v_flag & VROOT) &&
|
|
|
|
(vp->v_mount->mnt_flag & MNT_UNION)) {
|
|
|
|
struct vnode *tvp = vp;
|
|
|
|
vp = vp->v_mount->mnt_vnodecovered;
|
|
|
|
VREF(vp);
|
|
|
|
fp->f_data = (caddr_t) vp;
|
|
|
|
fp->f_offset = 0;
|
|
|
|
vrele(tvp);
|
|
|
|
goto unionread;
|
|
|
|
}
|
|
|
|
error = copyout((caddr_t)&loff, (caddr_t)SCARG(uap, basep),
|
|
|
|
sizeof(long));
|
|
|
|
*retval = SCARG(uap, count) - auio.uio_resid;
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
1997-02-10 02:22:35 +00:00
|
|
|
#endif /* COMPAT_43 */
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Read a block of directory entries in a file system independent format.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct getdirentries_args {
|
|
|
|
int fd;
|
|
|
|
char *buf;
|
|
|
|
u_int count;
|
|
|
|
long *basep;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
getdirentries(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct getdirentries_args /* {
|
|
|
|
syscallarg(int) fd;
|
|
|
|
syscallarg(char *) buf;
|
|
|
|
syscallarg(u_int) count;
|
|
|
|
syscallarg(long *) basep;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register struct vnode *vp;
|
|
|
|
struct file *fp;
|
|
|
|
struct uio auio;
|
|
|
|
struct iovec aiov;
|
|
|
|
long loff;
|
1997-02-10 02:22:35 +00:00
|
|
|
int error, eofflag;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
if (error = getvnode(p->p_fd, SCARG(uap, fd), &fp))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
if ((fp->f_flag & FREAD) == 0)
|
|
|
|
return (EBADF);
|
|
|
|
vp = (struct vnode *)fp->f_data;
|
|
|
|
unionread:
|
|
|
|
if (vp->v_type != VDIR)
|
|
|
|
return (EINVAL);
|
1997-02-10 02:22:35 +00:00
|
|
|
aiov.iov_base = SCARG(uap, buf);
|
|
|
|
aiov.iov_len = SCARG(uap, count);
|
1994-05-24 10:09:53 +00:00
|
|
|
auio.uio_iov = &aiov;
|
|
|
|
auio.uio_iovcnt = 1;
|
|
|
|
auio.uio_rw = UIO_READ;
|
|
|
|
auio.uio_segflg = UIO_USERSPACE;
|
|
|
|
auio.uio_procp = p;
|
1997-02-10 02:22:35 +00:00
|
|
|
auio.uio_resid = SCARG(uap, count);
|
1997-09-21 04:24:27 +00:00
|
|
|
/* vn_lock(vp, LK_SHARED | LK_RETRY, p); */
|
1997-02-10 02:22:35 +00:00
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
loff = auio.uio_offset = fp->f_offset;
|
1997-02-10 02:22:35 +00:00
|
|
|
error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag, NULL, NULL);
|
1994-05-24 10:09:53 +00:00
|
|
|
fp->f_offset = auio.uio_offset;
|
1997-02-10 02:22:35 +00:00
|
|
|
VOP_UNLOCK(vp, 0, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
|
|
|
|
#ifdef UNION
|
|
|
|
{
|
1997-02-10 02:22:35 +00:00
|
|
|
if ((SCARG(uap, count) == auio.uio_resid) &&
|
1994-05-24 10:09:53 +00:00
|
|
|
(vp->v_op == union_vnodeop_p)) {
|
1997-02-10 02:22:35 +00:00
|
|
|
struct vnode *lvp;
|
|
|
|
|
|
|
|
lvp = union_dircache(vp, p);
|
|
|
|
if (lvp != NULLVP) {
|
|
|
|
struct vattr va;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
/*
|
|
|
|
* If the directory is opaque,
|
|
|
|
* then don't show lower entries
|
|
|
|
*/
|
|
|
|
error = VOP_GETATTR(vp, &va, fp->f_cred, p);
|
|
|
|
if (va.va_flags & OPAQUE) {
|
|
|
|
vput(lvp);
|
|
|
|
lvp = NULL;
|
|
|
|
}
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
if (lvp != NULLVP) {
|
|
|
|
error = VOP_OPEN(lvp, FREAD, fp->f_cred, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (error) {
|
1997-02-10 02:22:35 +00:00
|
|
|
vput(lvp);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
1997-02-10 02:22:35 +00:00
|
|
|
VOP_UNLOCK(lvp, 0, p);
|
|
|
|
fp->f_data = (caddr_t) lvp;
|
1994-05-24 10:09:53 +00:00
|
|
|
fp->f_offset = 0;
|
1997-02-10 02:22:35 +00:00
|
|
|
error = vn_close(vp, FREAD, fp->f_cred, p);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
1997-02-10 02:22:35 +00:00
|
|
|
vp = lvp;
|
1994-05-24 10:09:53 +00:00
|
|
|
goto unionread;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1997-02-10 02:22:35 +00:00
|
|
|
#endif /* UNION */
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
if ((SCARG(uap, count) == auio.uio_resid) &&
|
1994-05-24 10:09:53 +00:00
|
|
|
(vp->v_flag & VROOT) &&
|
|
|
|
(vp->v_mount->mnt_flag & MNT_UNION)) {
|
|
|
|
struct vnode *tvp = vp;
|
|
|
|
vp = vp->v_mount->mnt_vnodecovered;
|
|
|
|
VREF(vp);
|
|
|
|
fp->f_data = (caddr_t) vp;
|
|
|
|
fp->f_offset = 0;
|
|
|
|
vrele(tvp);
|
|
|
|
goto unionread;
|
|
|
|
}
|
1997-02-10 02:22:35 +00:00
|
|
|
error = copyout((caddr_t)&loff, (caddr_t)SCARG(uap, basep),
|
|
|
|
sizeof(long));
|
|
|
|
*retval = SCARG(uap, count) - auio.uio_resid;
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set the mode mask for creation of filesystem nodes.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct umask_args {
|
|
|
|
int newmask;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1997-02-10 02:22:35 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
umask(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
struct umask_args /* {
|
|
|
|
syscallarg(int) newmask;
|
|
|
|
} */ *uap;
|
|
|
|
int *retval; /* XXX */
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register struct filedesc *fdp;
|
|
|
|
|
|
|
|
fdp = p->p_fd;
|
|
|
|
*retval = fdp->fd_cmask;
|
1997-02-10 02:22:35 +00:00
|
|
|
fdp->fd_cmask = SCARG(uap, newmask) & ALLPERMS;
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Void all references to file by ripping underlying filesystem
|
|
|
|
* away from vnode.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct revoke_args {
|
|
|
|
char *path;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
revoke(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct revoke_args /* {
|
|
|
|
syscallarg(char *) path;
|
|
|
|
} */ *uap;
|
|
|
|
register_t *retval;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register struct vnode *vp;
|
|
|
|
struct vattr vattr;
|
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p);
|
|
|
|
if (error = namei(&nd))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
vp = nd.ni_vp;
|
1997-02-10 02:22:35 +00:00
|
|
|
if (error = VOP_GETATTR(vp, &vattr, p->p_ucred, p))
|
1994-05-24 10:09:53 +00:00
|
|
|
goto out;
|
|
|
|
if (p->p_ucred->cr_uid != vattr.va_uid &&
|
|
|
|
(error = suser(p->p_ucred, &p->p_acflag)))
|
|
|
|
goto out;
|
|
|
|
if (vp->v_usecount > 1 || (vp->v_flag & VALIASED))
|
1997-02-10 02:22:35 +00:00
|
|
|
VOP_REVOKE(vp, REVOKEALL);
|
1994-05-24 10:09:53 +00:00
|
|
|
out:
|
|
|
|
vrele(vp);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Convert a user file descriptor to a kernel file entry.
|
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
getvnode(fdp, fd, fpp)
|
|
|
|
struct filedesc *fdp;
|
|
|
|
int fd;
|
1995-11-13 08:22:21 +00:00
|
|
|
struct file **fpp;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
struct file *fp;
|
|
|
|
|
|
|
|
if ((u_int)fd >= fdp->fd_nfiles ||
|
|
|
|
(fp = fdp->fd_ofiles[fd]) == NULL)
|
|
|
|
return (EBADF);
|
1996-12-19 19:42:37 +00:00
|
|
|
if (fp->f_type != DTYPE_VNODE && fp->f_type != DTYPE_FIFO)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (EINVAL);
|
|
|
|
*fpp = fp;
|
|
|
|
return (0);
|
|
|
|
}
|
1997-09-14 16:51:31 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct __getcwd_args {
|
1997-09-15 19:11:07 +00:00
|
|
|
u_char *buf;
|
|
|
|
u_int buflen;
|
1997-09-14 16:51:31 +00:00
|
|
|
};
|
|
|
|
#endif
|
1997-09-24 07:46:54 +00:00
|
|
|
#define STATNODE(mode, name, var) \
|
|
|
|
SYSCTL_INT(_vfs_cache, OID_AUTO, name, mode, var, 0, "");
|
|
|
|
|
|
|
|
static int disablecwd;
|
|
|
|
SYSCTL_INT(_debug, OID_AUTO, disablecwd, CTLFLAG_RW, &disablecwd, 0, "");
|
|
|
|
|
|
|
|
static u_long numcwdcalls; STATNODE(CTLFLAG_RD, numcwdcalls, &numcwdcalls);
|
|
|
|
static u_long numcwdfail1; STATNODE(CTLFLAG_RD, numcwdfail1, &numcwdfail1);
|
|
|
|
static u_long numcwdfail2; STATNODE(CTLFLAG_RD, numcwdfail2, &numcwdfail2);
|
|
|
|
static u_long numcwdfail3; STATNODE(CTLFLAG_RD, numcwdfail3, &numcwdfail3);
|
|
|
|
static u_long numcwdfail4; STATNODE(CTLFLAG_RD, numcwdfail4, &numcwdfail4);
|
|
|
|
static u_long numcwdfound; STATNODE(CTLFLAG_RD, numcwdfound, &numcwdfound);
|
1997-09-14 16:51:31 +00:00
|
|
|
int
|
|
|
|
__getcwd(p, uap, retval)
|
|
|
|
struct proc *p;
|
1997-09-15 19:11:07 +00:00
|
|
|
struct __getcwd_args *uap;
|
1997-09-14 16:51:31 +00:00
|
|
|
register_t *retval;
|
|
|
|
{
|
1997-09-15 19:11:07 +00:00
|
|
|
struct filedesc *fdp;
|
1997-09-14 16:51:31 +00:00
|
|
|
struct vnode *vp;
|
|
|
|
struct namecache *ncp;
|
1997-09-15 19:11:07 +00:00
|
|
|
char *buf, *bp;
|
1997-09-16 08:05:09 +00:00
|
|
|
int i, j, error;
|
1997-09-14 16:51:31 +00:00
|
|
|
|
1997-09-24 07:46:54 +00:00
|
|
|
if (disablecwd)
|
|
|
|
return (ENODEV);
|
1997-09-15 19:11:07 +00:00
|
|
|
fdp = p->p_fd;
|
1997-09-16 08:05:09 +00:00
|
|
|
j = 0;
|
|
|
|
error = 0;
|
|
|
|
if (uap->buflen < 2)
|
|
|
|
return (EINVAL);
|
|
|
|
if (uap->buflen > MAXPATHLEN)
|
|
|
|
uap->buflen = MAXPATHLEN;
|
|
|
|
buf = bp = malloc(uap->buflen, M_TEMP, M_WAITOK);
|
1997-09-15 19:11:07 +00:00
|
|
|
bp += uap->buflen - 1;
|
|
|
|
*bp = '\0';
|
1997-09-24 07:46:54 +00:00
|
|
|
numcwdcalls++;
|
1997-09-14 16:51:31 +00:00
|
|
|
for (vp = fdp->fd_cdir; vp != fdp->fd_rdir && vp != rootvnode;) {
|
1997-09-28 06:37:02 +00:00
|
|
|
if (vp->v_flag & VROOT) {
|
|
|
|
vp = vp->v_mount->mnt_vnodecovered;
|
|
|
|
continue;
|
|
|
|
}
|
1997-09-16 08:05:09 +00:00
|
|
|
if (vp->v_dd->v_id != vp->v_ddid) {
|
1997-09-24 07:46:54 +00:00
|
|
|
numcwdfail1++;
|
1997-09-16 08:05:09 +00:00
|
|
|
free(buf, M_TEMP);
|
1997-09-15 19:11:07 +00:00
|
|
|
return (ENOTDIR);
|
1997-09-16 08:05:09 +00:00
|
|
|
}
|
1997-09-14 16:51:31 +00:00
|
|
|
ncp = TAILQ_FIRST(&vp->v_cache_dst);
|
1997-09-16 08:05:09 +00:00
|
|
|
if (!ncp) {
|
1997-09-24 07:46:54 +00:00
|
|
|
numcwdfail2++;
|
1997-09-16 08:05:09 +00:00
|
|
|
free(buf, M_TEMP);
|
1997-09-15 19:11:07 +00:00
|
|
|
return (ENOENT);
|
1997-09-16 08:05:09 +00:00
|
|
|
}
|
|
|
|
if (ncp->nc_dvp != vp->v_dd) {
|
1997-09-24 07:46:54 +00:00
|
|
|
numcwdfail3++;
|
1997-09-16 08:05:09 +00:00
|
|
|
free(buf, M_TEMP);
|
1997-09-15 19:11:07 +00:00
|
|
|
return (EBADF);
|
1997-09-16 08:05:09 +00:00
|
|
|
}
|
1997-09-15 19:11:07 +00:00
|
|
|
for (i=ncp->nc_nlen - 1; i >= 0; i--) {
|
1997-09-16 08:05:09 +00:00
|
|
|
if (bp == buf) {
|
1997-09-24 07:46:54 +00:00
|
|
|
numcwdfail4++;
|
1997-09-16 08:05:09 +00:00
|
|
|
free(buf, M_TEMP);
|
1997-09-15 19:11:07 +00:00
|
|
|
return (ENOMEM);
|
1997-09-16 08:05:09 +00:00
|
|
|
}
|
1997-09-15 19:11:07 +00:00
|
|
|
*--bp = ncp->nc_name[i];
|
1997-09-14 16:51:31 +00:00
|
|
|
}
|
1997-09-16 08:05:09 +00:00
|
|
|
if (bp == buf) {
|
1997-09-24 07:46:54 +00:00
|
|
|
numcwdfail4++;
|
1997-09-16 08:05:09 +00:00
|
|
|
free(buf, M_TEMP);
|
1997-09-15 19:11:07 +00:00
|
|
|
return (ENOMEM);
|
1997-09-16 08:05:09 +00:00
|
|
|
}
|
1997-09-15 19:11:07 +00:00
|
|
|
*--bp = '/';
|
1997-09-14 16:51:31 +00:00
|
|
|
j++;
|
|
|
|
vp = vp->v_dd;
|
|
|
|
}
|
|
|
|
if (!j) {
|
1997-09-16 08:05:09 +00:00
|
|
|
if (bp == buf) {
|
1997-09-24 07:46:54 +00:00
|
|
|
numcwdfail4++;
|
1997-09-16 08:05:09 +00:00
|
|
|
free(buf, M_TEMP);
|
1997-09-15 19:11:07 +00:00
|
|
|
return (ENOMEM);
|
1997-09-16 08:05:09 +00:00
|
|
|
}
|
1997-09-15 19:11:07 +00:00
|
|
|
*--bp = '/';
|
1997-09-14 16:51:31 +00:00
|
|
|
}
|
1997-09-24 07:46:54 +00:00
|
|
|
numcwdfound++;
|
1997-09-15 19:11:07 +00:00
|
|
|
error = copyout(bp, uap->buf, strlen(bp) + 1);
|
|
|
|
free(buf, M_TEMP);
|
|
|
|
return (error);
|
1997-09-14 16:51:31 +00:00
|
|
|
}
|