2005-01-06 23:35:40 +00:00
|
|
|
/*-
|
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.
|
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
|
2003-06-11 00:56:59 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
1997-12-16 17:40:42 +00:00
|
|
|
#include "opt_compat.h"
|
2008-02-23 01:01:49 +00:00
|
|
|
#include "opt_ktrace.h"
|
2002-07-31 01:27:33 +00:00
|
|
|
#include "opt_mac.h"
|
1997-12-16 17:40:42 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/systm.h>
|
2000-05-05 09:59:14 +00:00
|
|
|
#include <sys/bio.h>
|
1999-02-25 15:54:06 +00:00
|
|
|
#include <sys/buf.h>
|
1997-02-10 02:22:35 +00:00
|
|
|
#include <sys/sysent.h>
|
2002-08-01 17:47:56 +00:00
|
|
|
#include <sys/malloc.h>
|
1999-09-11 00:46:08 +00:00
|
|
|
#include <sys/mount.h>
|
2000-10-20 07:58:15 +00:00
|
|
|
#include <sys/mutex.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>
|
2007-04-05 21:10:53 +00:00
|
|
|
#include <sys/filio.h>
|
2003-04-29 13:36:06 +00:00
|
|
|
#include <sys/limits.h>
|
1998-11-03 14:29:09 +00:00
|
|
|
#include <sys/linker.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/stat.h>
|
2001-03-28 11:52:56 +00:00
|
|
|
#include <sys/sx.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>
|
2006-11-06 13:42:10 +00:00
|
|
|
#include <sys/priv.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/proc.h>
|
|
|
|
#include <sys/dirent.h>
|
2001-02-21 06:39:57 +00:00
|
|
|
#include <sys/jail.h>
|
2002-09-01 20:37:28 +00:00
|
|
|
#include <sys/syscallsubr.h>
|
2001-08-23 13:51:17 +00:00
|
|
|
#include <sys/sysctl.h>
|
2008-02-23 01:01:49 +00:00
|
|
|
#ifdef KTRACE
|
|
|
|
#include <sys/ktrace.h>
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2002-03-26 15:33:44 +00:00
|
|
|
#include <machine/stdarg.h>
|
2001-08-23 13:51:17 +00:00
|
|
|
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
#include <security/audit/audit.h>
|
2006-10-22 11:52:19 +00:00
|
|
|
#include <security/mac/mac_framework.h>
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
|
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>
|
2000-11-18 21:01:04 +00:00
|
|
|
#include <vm/vm_page.h>
|
2002-03-20 04:09:59 +00:00
|
|
|
#include <vm/uma.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2002-03-19 21:25:46 +00:00
|
|
|
static int chroot_refuse_vdir_fds(struct filedesc *fdp);
|
2002-09-01 20:37:28 +00:00
|
|
|
static int getutimes(const struct timeval *, enum uio_seg, struct timespec *);
|
2002-03-19 21:25:46 +00:00
|
|
|
static int setfown(struct thread *td, struct vnode *, uid_t, gid_t);
|
|
|
|
static int setfmode(struct thread *td, struct vnode *, int);
|
|
|
|
static int setfflags(struct thread *td, struct vnode *, int);
|
|
|
|
static int setutimes(struct thread *td, struct vnode *,
|
2002-07-17 02:03:19 +00:00
|
|
|
const struct timespec *, int, int);
|
2002-03-19 21:25:46 +00:00
|
|
|
static int vn_access(struct vnode *vp, int user_flags, struct ucred *cred,
|
|
|
|
struct thread *td);
|
1997-10-23 09:29:09 +00:00
|
|
|
|
2002-10-27 18:07:41 +00:00
|
|
|
/*
|
|
|
|
* The module initialization routine for POSIX asynchronous I/O will
|
|
|
|
* set this to the version of AIO that it implements. (Zero means
|
|
|
|
* that it is not implemented.) This value is used here by pathconf()
|
|
|
|
* and in kern_descrip.c by fpathconf().
|
|
|
|
*/
|
|
|
|
int async_io_version;
|
|
|
|
|
2007-03-05 13:10:58 +00:00
|
|
|
#ifdef DEBUG
|
|
|
|
static int syncprt = 0;
|
|
|
|
SYSCTL_INT(_debug, OID_AUTO, syncprt, CTLFLAG_RW, &syncprt, 0, "");
|
|
|
|
#endif
|
|
|
|
|
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 {
|
2004-01-11 19:52:10 +00:00
|
|
|
int dummy;
|
1995-10-08 00:06:22 +00:00
|
|
|
};
|
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
|
2001-09-12 08:38:13 +00:00
|
|
|
sync(td, uap)
|
|
|
|
struct thread *td;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct sync_args *uap;
|
|
|
|
{
|
2000-07-11 22:07:57 +00:00
|
|
|
struct mount *mp, *nmp;
|
2006-03-21 23:58:37 +00:00
|
|
|
int vfslocked;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock(&mountlist_mtx);
|
1999-11-20 10:00:46 +00:00
|
|
|
for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) {
|
2008-08-31 14:26:08 +00:00
|
|
|
if (vfs_busy(mp, LK_NOWAIT, &mountlist_mtx)) {
|
1999-11-20 10:00:46 +00:00
|
|
|
nmp = TAILQ_NEXT(mp, mnt_list);
|
1997-02-10 02:22:35 +00:00
|
|
|
continue;
|
|
|
|
}
|
2006-03-21 23:58:37 +00:00
|
|
|
vfslocked = VFS_LOCK_GIANT(mp);
|
2000-07-11 22:07:57 +00:00
|
|
|
if ((mp->mnt_flag & MNT_RDONLY) == 0 &&
|
|
|
|
vn_start_write(NULL, &mp, V_NOWAIT) == 0) {
|
2006-09-26 04:12:49 +00:00
|
|
|
MNT_ILOCK(mp);
|
2006-09-26 04:15:59 +00:00
|
|
|
mp->mnt_noasync++;
|
|
|
|
mp->mnt_kern_flag &= ~MNTK_ASYNC;
|
2006-09-26 04:12:49 +00:00
|
|
|
MNT_IUNLOCK(mp);
|
1995-05-21 21:39:31 +00:00
|
|
|
vfs_msync(mp, MNT_NOWAIT);
|
2005-01-11 07:36:22 +00:00
|
|
|
VFS_SYNC(mp, MNT_NOWAIT, td);
|
2006-09-26 04:12:49 +00:00
|
|
|
MNT_ILOCK(mp);
|
2006-09-26 04:15:59 +00:00
|
|
|
mp->mnt_noasync--;
|
|
|
|
if ((mp->mnt_flag & MNT_ASYNC) != 0 &&
|
|
|
|
mp->mnt_noasync == 0)
|
|
|
|
mp->mnt_kern_flag |= MNTK_ASYNC;
|
2006-09-26 04:12:49 +00:00
|
|
|
MNT_IUNLOCK(mp);
|
2000-07-11 22:07:57 +00:00
|
|
|
vn_finished_write(mp);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2006-03-21 23:58:37 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock(&mountlist_mtx);
|
1999-11-20 10:00:46 +00:00
|
|
|
nmp = TAILQ_NEXT(mp, mnt_list);
|
2008-08-31 14:26:08 +00:00
|
|
|
vfs_unbusy(mp);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock(&mountlist_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
This Implements the mumbled about "Jail" feature.
This is a seriously beefed up chroot kind of thing. The process
is jailed along the same lines as a chroot does it, but with
additional tough restrictions imposed on what the superuser can do.
For all I know, it is safe to hand over the root bit inside a
prison to the customer living in that prison, this is what
it was developed for in fact: "real virtual servers".
Each prison has an ip number associated with it, which all IP
communications will be coerced to use and each prison has its own
hostname.
Needless to say, you need more RAM this way, but the advantage is
that each customer can run their own particular version of apache
and not stomp on the toes of their neighbors.
It generally does what one would expect, but setting up a jail
still takes a little knowledge.
A few notes:
I have no scripts for setting up a jail, don't ask me for them.
The IP number should be an alias on one of the interfaces.
mount a /proc in each jail, it will make ps more useable.
/proc/<pid>/status tells the hostname of the prison for
jailed processes.
Quotas are only sensible if you have a mountpoint per prison.
There are no privisions for stopping resource-hogging.
Some "#ifdef INET" and similar may be missing (send patches!)
If somebody wants to take it from here and develop it into
more of a "virtual machine" they should be most welcome!
Tools, comments, patches & documentation most welcome.
Have fun...
Sponsored by: http://www.rndassociates.com/
Run for almost a year by: http://www.servetheweb.com/
1999-04-28 11:38:52 +00:00
|
|
|
/* XXX PRISON: could be per prison flag */
|
|
|
|
static int prison_quotas;
|
|
|
|
#if 0
|
|
|
|
SYSCTL_INT(_kern_prison, OID_AUTO, quotas, CTLFLAG_RW, &prison_quotas, 0, "");
|
|
|
|
#endif
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* 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-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
quotactl(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct quotactl_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
|
|
|
int cmd;
|
|
|
|
int uid;
|
|
|
|
caddr_t arg;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2007-03-14 08:45:55 +00:00
|
|
|
struct mount *mp;
|
2006-03-21 23:58:37 +00:00
|
|
|
int vfslocked;
|
1994-05-24 10:09:53 +00:00
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
|
|
|
|
2006-06-05 13:34:23 +00:00
|
|
|
AUDIT_ARG(cmd, uap->cmd);
|
|
|
|
AUDIT_ARG(uid, uap->uid);
|
2002-02-27 18:32:23 +00:00
|
|
|
if (jailed(td->td_ucred) && !prison_quotas)
|
This Implements the mumbled about "Jail" feature.
This is a seriously beefed up chroot kind of thing. The process
is jailed along the same lines as a chroot does it, but with
additional tough restrictions imposed on what the superuser can do.
For all I know, it is safe to hand over the root bit inside a
prison to the customer living in that prison, this is what
it was developed for in fact: "real virtual servers".
Each prison has an ip number associated with it, which all IP
communications will be coerced to use and each prison has its own
hostname.
Needless to say, you need more RAM this way, but the advantage is
that each customer can run their own particular version of apache
and not stomp on the toes of their neighbors.
It generally does what one would expect, but setting up a jail
still takes a little knowledge.
A few notes:
I have no scripts for setting up a jail, don't ask me for them.
The IP number should be an alias on one of the interfaces.
mount a /proc in each jail, it will make ps more useable.
/proc/<pid>/status tells the hostname of the prison for
jailed processes.
Quotas are only sensible if you have a mountpoint per prison.
There are no privisions for stopping resource-hogging.
Some "#ifdef INET" and similar may be missing (send patches!)
If somebody wants to take it from here and develop it into
more of a "virtual machine" they should be most welcome!
Tools, comments, patches & documentation most welcome.
Have fun...
Sponsored by: http://www.rndassociates.com/
Run for almost a year by: http://www.servetheweb.com/
1999-04-28 11:38:52 +00:00
|
|
|
return (EPERM);
|
2006-03-21 23:58:37 +00:00
|
|
|
NDINIT(&nd, LOOKUP, FOLLOW | MPSAFE | AUDITVNODE1,
|
|
|
|
UIO_USERSPACE, uap->path, td);
|
|
|
|
if ((error = namei(&nd)) != 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2006-03-21 23:58:37 +00:00
|
|
|
vfslocked = NDHASGIANT(&nd);
|
1999-12-15 23:02:35 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
2004-04-26 15:44:42 +00:00
|
|
|
mp = nd.ni_vp->v_mount;
|
2008-08-31 14:26:08 +00:00
|
|
|
if ((error = vfs_busy(mp, 0, NULL))) {
|
2007-03-14 08:45:55 +00:00
|
|
|
vrele(nd.ni_vp);
|
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
|
|
|
return (error);
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
vrele(nd.ni_vp);
|
2002-12-14 08:18:06 +00:00
|
|
|
error = VFS_QUOTACTL(mp, uap->cmd, uap->uid, uap->arg, td);
|
2008-08-31 14:26:08 +00:00
|
|
|
vfs_unbusy(mp);
|
2006-03-21 23:58:37 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2000-07-11 22:07:57 +00:00
|
|
|
return (error);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
2007-08-28 20:28:12 +00:00
|
|
|
/*
|
|
|
|
* Used by statfs conversion routines to scale the block size up if
|
|
|
|
* necessary so that all of the block counts are <= 'max_size'. Note
|
|
|
|
* that 'max_size' should be a bitmask, i.e. 2^n - 1 for some non-zero
|
|
|
|
* value of 'n'.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
statfs_scale_blocks(struct statfs *sf, long max_size)
|
|
|
|
{
|
|
|
|
uint64_t count;
|
|
|
|
int shift;
|
|
|
|
|
|
|
|
KASSERT(powerof2(max_size + 1), ("%s: invalid max_size", __func__));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Attempt to scale the block counts to give a more accurate
|
|
|
|
* overview to userland of the ratio of free space to used
|
|
|
|
* space. To do this, find the largest block count and compute
|
|
|
|
* a divisor that lets it fit into a signed integer <= max_size.
|
|
|
|
*/
|
|
|
|
if (sf->f_bavail < 0)
|
|
|
|
count = -sf->f_bavail;
|
|
|
|
else
|
|
|
|
count = sf->f_bavail;
|
|
|
|
count = MAX(sf->f_blocks, MAX(sf->f_bfree, count));
|
|
|
|
if (count <= max_size)
|
|
|
|
return;
|
|
|
|
|
|
|
|
count >>= flsl(max_size);
|
|
|
|
shift = 0;
|
|
|
|
while (count > 0) {
|
|
|
|
shift++;
|
|
|
|
count >>=1;
|
|
|
|
}
|
|
|
|
|
|
|
|
sf->f_bsize <<= shift;
|
|
|
|
sf->f_blocks >>= shift;
|
|
|
|
sf->f_bfree >>= shift;
|
|
|
|
sf->f_bavail >>= shift;
|
|
|
|
}
|
|
|
|
|
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-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
statfs(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct statfs_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
|
|
|
struct statfs *buf;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
2005-02-07 18:44:55 +00:00
|
|
|
{
|
|
|
|
struct statfs sf;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = kern_statfs(td, uap->path, UIO_USERSPACE, &sf);
|
|
|
|
if (error == 0)
|
|
|
|
error = copyout(&sf, uap->buf, sizeof(sf));
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_statfs(struct thread *td, char *path, enum uio_seg pathseg,
|
|
|
|
struct statfs *buf)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2003-11-12 08:01:40 +00:00
|
|
|
struct mount *mp;
|
|
|
|
struct statfs *sp, sb;
|
2006-03-21 23:58:37 +00:00
|
|
|
int vfslocked;
|
1994-05-24 10:09:53 +00:00
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
|
|
|
|
2006-03-21 23:58:37 +00:00
|
|
|
NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | MPSAFE | AUDITVNODE1,
|
|
|
|
pathseg, path, td);
|
2005-05-27 19:15:46 +00:00
|
|
|
error = namei(&nd);
|
2006-03-21 23:58:37 +00:00
|
|
|
if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2006-03-21 23:58:37 +00:00
|
|
|
vfslocked = NDHASGIANT(&nd);
|
1994-05-24 10:09:53 +00:00
|
|
|
mp = nd.ni_vp->v_mount;
|
2006-02-23 05:18:07 +00:00
|
|
|
vfs_ref(mp);
|
1999-12-15 23:02:35 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
2006-02-23 05:18:07 +00:00
|
|
|
vput(nd.ni_vp);
|
2002-07-31 01:27:33 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_mount_check_stat(td->td_ucred, mp);
|
2006-08-02 15:27:48 +00:00
|
|
|
if (error)
|
2006-03-21 23:58:37 +00:00
|
|
|
goto out;
|
2002-07-31 01:27:33 +00:00
|
|
|
#endif
|
2003-11-12 08:01:40 +00:00
|
|
|
/*
|
|
|
|
* Set these in case the underlying filesystem fails to do so.
|
|
|
|
*/
|
2006-02-23 05:18:07 +00:00
|
|
|
sp = &mp->mnt_stat;
|
2003-11-12 08:01:40 +00:00
|
|
|
sp->f_version = STATFS_VERSION;
|
|
|
|
sp->f_namemax = NAME_MAX;
|
|
|
|
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
|
2001-09-12 08:38:13 +00:00
|
|
|
error = VFS_STATFS(mp, sp, td);
|
2006-03-21 23:58:37 +00:00
|
|
|
if (error)
|
|
|
|
goto out;
|
2006-11-06 13:42:10 +00:00
|
|
|
if (priv_check(td, PRIV_VFS_GENERATION)) {
|
2002-06-28 23:02:38 +00:00
|
|
|
bcopy(sp, &sb, sizeof(sb));
|
1997-03-23 20:08:22 +00:00
|
|
|
sb.f_fsid.val[0] = sb.f_fsid.val[1] = 0;
|
2005-06-09 18:49:19 +00:00
|
|
|
prison_enforce_statfs(td->td_ucred, mp, &sb);
|
1997-03-23 20:08:22 +00:00
|
|
|
sp = &sb;
|
|
|
|
}
|
2005-02-07 18:44:55 +00:00
|
|
|
*buf = *sp;
|
2006-03-21 23:58:37 +00:00
|
|
|
out:
|
2006-07-27 20:00:27 +00:00
|
|
|
vfs_rel(mp);
|
2006-03-21 23:58:37 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2006-03-31 03:54:20 +00:00
|
|
|
if (mtx_owned(&Giant))
|
|
|
|
printf("statfs(%d): %s: %d\n", vfslocked, path, error);
|
2006-03-21 23:58:37 +00:00
|
|
|
return (error);
|
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-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
fstatfs(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct fstatfs_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
int fd;
|
|
|
|
struct statfs *buf;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
2005-02-07 18:44:55 +00:00
|
|
|
{
|
|
|
|
struct statfs sf;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = kern_fstatfs(td, uap->fd, &sf);
|
|
|
|
if (error == 0)
|
|
|
|
error = copyout(&sf, uap->buf, sizeof(sf));
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_fstatfs(struct thread *td, int fd, struct statfs *buf)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
struct file *fp;
|
|
|
|
struct mount *mp;
|
2003-11-12 08:01:40 +00:00
|
|
|
struct statfs *sp, sb;
|
2006-03-21 23:58:37 +00:00
|
|
|
int vfslocked;
|
2006-02-06 10:15:27 +00:00
|
|
|
struct vnode *vp;
|
1994-05-24 10:09:53 +00:00
|
|
|
int error;
|
|
|
|
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
AUDIT_ARG(fd, fd);
|
2005-05-27 19:15:46 +00:00
|
|
|
error = getvnode(td->td_proc->p_fd, fd, &fp);
|
|
|
|
if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2006-02-06 10:15:27 +00:00
|
|
|
vp = fp->f_vnode;
|
2006-03-21 23:58:37 +00:00
|
|
|
vfslocked = VFS_LOCK_GIANT(vp->v_mount);
|
2008-01-10 01:10:58 +00:00
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
|
2006-02-23 05:18:07 +00:00
|
|
|
#ifdef AUDIT
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
AUDIT_ARG(vnode, vp, ARG_VNODE1);
|
|
|
|
#endif
|
2006-02-22 09:52:25 +00:00
|
|
|
mp = vp->v_mount;
|
2006-02-23 05:18:07 +00:00
|
|
|
if (mp)
|
|
|
|
vfs_ref(mp);
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(vp, 0);
|
2002-01-13 11:58:06 +00:00
|
|
|
fdrop(fp, td);
|
2006-02-23 05:18:07 +00:00
|
|
|
if (vp->v_iflag & VI_DOOMED) {
|
2006-03-21 23:58:37 +00:00
|
|
|
error = EBADF;
|
|
|
|
goto out;
|
2006-02-23 05:18:07 +00:00
|
|
|
}
|
2002-07-31 01:27:33 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_mount_check_stat(td->td_ucred, mp);
|
2006-08-02 15:27:48 +00:00
|
|
|
if (error)
|
2006-03-21 23:58:37 +00:00
|
|
|
goto out;
|
2002-07-31 01:27:33 +00:00
|
|
|
#endif
|
2003-11-12 08:01:40 +00:00
|
|
|
/*
|
|
|
|
* Set these in case the underlying filesystem fails to do so.
|
|
|
|
*/
|
2006-02-23 05:18:07 +00:00
|
|
|
sp = &mp->mnt_stat;
|
2003-11-12 08:01:40 +00:00
|
|
|
sp->f_version = STATFS_VERSION;
|
|
|
|
sp->f_namemax = NAME_MAX;
|
|
|
|
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
|
2001-09-12 08:38:13 +00:00
|
|
|
error = VFS_STATFS(mp, sp, td);
|
2006-03-21 23:58:37 +00:00
|
|
|
if (error)
|
|
|
|
goto out;
|
2006-11-06 13:42:10 +00:00
|
|
|
if (priv_check(td, PRIV_VFS_GENERATION)) {
|
2002-06-28 23:02:38 +00:00
|
|
|
bcopy(sp, &sb, sizeof(sb));
|
1997-03-23 20:08:22 +00:00
|
|
|
sb.f_fsid.val[0] = sb.f_fsid.val[1] = 0;
|
2005-06-09 18:49:19 +00:00
|
|
|
prison_enforce_statfs(td->td_ucred, mp, &sb);
|
1997-03-23 20:08:22 +00:00
|
|
|
sp = &sb;
|
|
|
|
}
|
2005-02-07 18:44:55 +00:00
|
|
|
*buf = *sp;
|
2006-03-21 23:58:37 +00:00
|
|
|
out:
|
2006-08-02 15:27:48 +00:00
|
|
|
if (mp)
|
|
|
|
vfs_rel(mp);
|
2006-03-21 23:58:37 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
|
|
|
return (error);
|
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
|
2001-09-12 08:38:13 +00:00
|
|
|
getfsstat(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct getfsstat_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
struct statfs *buf;
|
|
|
|
long bufsize;
|
|
|
|
int flags;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2005-06-09 17:44:46 +00:00
|
|
|
|
2005-06-11 14:58:20 +00:00
|
|
|
return (kern_getfsstat(td, &uap->buf, uap->bufsize, UIO_USERSPACE,
|
2005-06-09 17:44:46 +00:00
|
|
|
uap->flags));
|
|
|
|
}
|
|
|
|
|
2005-06-11 14:58:20 +00:00
|
|
|
/*
|
|
|
|
* If (bufsize > 0 && bufseg == UIO_SYSSPACE)
|
|
|
|
* The caller is responsible for freeing memory which will be allocated
|
|
|
|
* in '*buf'.
|
|
|
|
*/
|
2005-06-09 17:44:46 +00:00
|
|
|
int
|
2005-06-11 14:58:20 +00:00
|
|
|
kern_getfsstat(struct thread *td, struct statfs **buf, size_t bufsize,
|
2005-06-09 17:44:46 +00:00
|
|
|
enum uio_seg bufseg, int flags)
|
|
|
|
{
|
2003-11-12 08:01:40 +00:00
|
|
|
struct mount *mp, *nmp;
|
2005-06-09 17:44:46 +00:00
|
|
|
struct statfs *sfsp, *sp, sb;
|
|
|
|
size_t count, maxcount;
|
2006-03-21 23:58:37 +00:00
|
|
|
int vfslocked;
|
2005-06-09 17:44:46 +00:00
|
|
|
int error;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2005-06-09 17:44:46 +00:00
|
|
|
maxcount = bufsize / sizeof(struct statfs);
|
2005-06-11 14:58:20 +00:00
|
|
|
if (bufsize == 0)
|
|
|
|
sfsp = NULL;
|
|
|
|
else if (bufseg == UIO_USERSPACE)
|
|
|
|
sfsp = *buf;
|
|
|
|
else /* if (bufseg == UIO_SYSSPACE) */ {
|
|
|
|
count = 0;
|
2005-06-12 07:03:23 +00:00
|
|
|
mtx_lock(&mountlist_mtx);
|
2005-06-11 14:58:20 +00:00
|
|
|
TAILQ_FOREACH(mp, &mountlist, mnt_list) {
|
|
|
|
count++;
|
|
|
|
}
|
2005-06-12 07:03:23 +00:00
|
|
|
mtx_unlock(&mountlist_mtx);
|
2005-06-11 14:58:20 +00:00
|
|
|
if (maxcount > count)
|
|
|
|
maxcount = count;
|
|
|
|
sfsp = *buf = malloc(maxcount * sizeof(struct statfs), M_TEMP,
|
|
|
|
M_WAITOK);
|
|
|
|
}
|
|
|
|
count = 0;
|
2005-06-12 07:03:23 +00:00
|
|
|
mtx_lock(&mountlist_mtx);
|
1999-11-20 10:00:46 +00:00
|
|
|
for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) {
|
2005-06-09 18:49:19 +00:00
|
|
|
if (prison_canseemount(td->td_ucred, mp) != 0) {
|
2004-02-14 18:31:11 +00:00
|
|
|
nmp = TAILQ_NEXT(mp, mnt_list);
|
|
|
|
continue;
|
|
|
|
}
|
2002-07-31 01:27:33 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
if (mac_mount_check_stat(td->td_ucred, mp) != 0) {
|
2002-07-31 01:27:33 +00:00
|
|
|
nmp = TAILQ_NEXT(mp, mnt_list);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
#endif
|
2008-08-31 14:26:08 +00:00
|
|
|
if (vfs_busy(mp, LK_NOWAIT, &mountlist_mtx)) {
|
1999-11-20 10:00:46 +00:00
|
|
|
nmp = TAILQ_NEXT(mp, mnt_list);
|
1996-01-16 13:07:14 +00:00
|
|
|
continue;
|
|
|
|
}
|
2006-03-21 23:58:37 +00:00
|
|
|
vfslocked = VFS_LOCK_GIANT(mp);
|
1997-02-10 02:22:35 +00:00
|
|
|
if (sfsp && count < maxcount) {
|
1994-05-24 10:09:53 +00:00
|
|
|
sp = &mp->mnt_stat;
|
2003-11-12 08:01:40 +00:00
|
|
|
/*
|
|
|
|
* Set these in case the underlying filesystem
|
|
|
|
* fails to do so.
|
|
|
|
*/
|
|
|
|
sp->f_version = STATFS_VERSION;
|
|
|
|
sp->f_namemax = NAME_MAX;
|
|
|
|
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
1998-03-08 09:59:44 +00:00
|
|
|
* If MNT_NOWAIT or MNT_LAZY is specified, do not
|
|
|
|
* refresh the fsstat cache. MNT_NOWAIT or MNT_LAZY
|
|
|
|
* overrides MNT_WAIT.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2005-06-09 17:44:46 +00:00
|
|
|
if (((flags & (MNT_LAZY|MNT_NOWAIT)) == 0 ||
|
|
|
|
(flags & MNT_WAIT)) &&
|
2001-09-12 08:38:13 +00:00
|
|
|
(error = VFS_STATFS(mp, sp, td))) {
|
2006-03-21 23:58:37 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock(&mountlist_mtx);
|
1999-11-20 10:00:46 +00:00
|
|
|
nmp = TAILQ_NEXT(mp, mnt_list);
|
2008-08-31 14:26:08 +00:00
|
|
|
vfs_unbusy(mp);
|
1994-05-24 10:09:53 +00:00
|
|
|
continue;
|
1996-01-16 13:07:14 +00:00
|
|
|
}
|
2006-11-06 13:42:10 +00:00
|
|
|
if (priv_check(td, PRIV_VFS_GENERATION)) {
|
2003-11-12 08:01:40 +00:00
|
|
|
bcopy(sp, &sb, sizeof(sb));
|
|
|
|
sb.f_fsid.val[0] = sb.f_fsid.val[1] = 0;
|
2005-06-09 18:49:19 +00:00
|
|
|
prison_enforce_statfs(td->td_ucred, mp, &sb);
|
2003-11-12 08:01:40 +00:00
|
|
|
sp = &sb;
|
|
|
|
}
|
2005-06-11 14:58:20 +00:00
|
|
|
if (bufseg == UIO_SYSSPACE)
|
|
|
|
bcopy(sp, sfsp, sizeof(*sp));
|
|
|
|
else /* if (bufseg == UIO_USERSPACE) */ {
|
2005-06-09 17:44:46 +00:00
|
|
|
error = copyout(sp, sfsp, sizeof(*sp));
|
|
|
|
if (error) {
|
2008-08-31 14:26:08 +00:00
|
|
|
vfs_unbusy(mp);
|
2006-03-21 23:58:37 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2005-06-09 17:44:46 +00:00
|
|
|
return (error);
|
|
|
|
}
|
2005-06-11 14:58:20 +00:00
|
|
|
}
|
2005-06-09 17:44:46 +00:00
|
|
|
sfsp++;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2006-03-21 23:58:37 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
1994-05-24 10:09:53 +00:00
|
|
|
count++;
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock(&mountlist_mtx);
|
1999-11-20 10:00:46 +00:00
|
|
|
nmp = TAILQ_NEXT(mp, mnt_list);
|
2008-08-31 14:26:08 +00:00
|
|
|
vfs_unbusy(mp);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock(&mountlist_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (sfsp && count > maxcount)
|
2001-09-12 08:38:13 +00:00
|
|
|
td->td_retval[0] = maxcount;
|
1994-05-24 10:09:53 +00:00
|
|
|
else
|
2001-09-12 08:38:13 +00:00
|
|
|
td->td_retval[0] = count;
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2003-11-12 08:01:40 +00:00
|
|
|
#ifdef COMPAT_FREEBSD4
|
|
|
|
/*
|
|
|
|
* Get old format filesystem statistics.
|
|
|
|
*/
|
2005-05-27 19:23:48 +00:00
|
|
|
static void cvtstatfs(struct statfs *, struct ostatfs *);
|
2003-11-12 08:01:40 +00:00
|
|
|
|
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct freebsd4_statfs_args {
|
|
|
|
char *path;
|
|
|
|
struct ostatfs *buf;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
int
|
|
|
|
freebsd4_statfs(td, uap)
|
|
|
|
struct thread *td;
|
|
|
|
struct freebsd4_statfs_args /* {
|
|
|
|
char *path;
|
|
|
|
struct ostatfs *buf;
|
|
|
|
} */ *uap;
|
|
|
|
{
|
|
|
|
struct ostatfs osb;
|
2005-02-07 18:44:55 +00:00
|
|
|
struct statfs sf;
|
2003-11-12 08:01:40 +00:00
|
|
|
int error;
|
|
|
|
|
2005-02-07 18:44:55 +00:00
|
|
|
error = kern_statfs(td, uap->path, UIO_USERSPACE, &sf);
|
2003-11-12 08:01:40 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
2005-05-27 19:23:48 +00:00
|
|
|
cvtstatfs(&sf, &osb);
|
2003-11-12 08:01:40 +00:00
|
|
|
return (copyout(&osb, uap->buf, sizeof(osb)));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get filesystem statistics.
|
|
|
|
*/
|
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct freebsd4_fstatfs_args {
|
|
|
|
int fd;
|
|
|
|
struct ostatfs *buf;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
int
|
|
|
|
freebsd4_fstatfs(td, uap)
|
|
|
|
struct thread *td;
|
|
|
|
struct freebsd4_fstatfs_args /* {
|
|
|
|
int fd;
|
|
|
|
struct ostatfs *buf;
|
|
|
|
} */ *uap;
|
|
|
|
{
|
|
|
|
struct ostatfs osb;
|
2005-02-07 18:44:55 +00:00
|
|
|
struct statfs sf;
|
2003-11-12 08:01:40 +00:00
|
|
|
int error;
|
|
|
|
|
2005-02-07 18:44:55 +00:00
|
|
|
error = kern_fstatfs(td, uap->fd, &sf);
|
2003-11-12 08:01:40 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
2005-05-27 19:23:48 +00:00
|
|
|
cvtstatfs(&sf, &osb);
|
2003-11-12 08:01:40 +00:00
|
|
|
return (copyout(&osb, uap->buf, sizeof(osb)));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get statistics on all filesystems.
|
|
|
|
*/
|
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct freebsd4_getfsstat_args {
|
|
|
|
struct ostatfs *buf;
|
|
|
|
long bufsize;
|
|
|
|
int flags;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
int
|
|
|
|
freebsd4_getfsstat(td, uap)
|
|
|
|
struct thread *td;
|
|
|
|
register struct freebsd4_getfsstat_args /* {
|
|
|
|
struct ostatfs *buf;
|
|
|
|
long bufsize;
|
|
|
|
int flags;
|
|
|
|
} */ *uap;
|
|
|
|
{
|
2005-06-09 17:44:46 +00:00
|
|
|
struct statfs *buf, *sp;
|
2003-11-12 08:01:40 +00:00
|
|
|
struct ostatfs osb;
|
2005-06-09 17:44:46 +00:00
|
|
|
size_t count, size;
|
|
|
|
int error;
|
2003-11-12 08:01:40 +00:00
|
|
|
|
2005-06-09 17:44:46 +00:00
|
|
|
count = uap->bufsize / sizeof(struct ostatfs);
|
|
|
|
size = count * sizeof(struct statfs);
|
2005-06-11 14:58:20 +00:00
|
|
|
error = kern_getfsstat(td, &buf, size, UIO_SYSSPACE, uap->flags);
|
|
|
|
if (size > 0) {
|
2005-06-09 17:44:46 +00:00
|
|
|
count = td->td_retval[0];
|
|
|
|
sp = buf;
|
|
|
|
while (count > 0 && error == 0) {
|
2005-05-27 19:23:48 +00:00
|
|
|
cvtstatfs(sp, &osb);
|
2005-06-09 17:44:46 +00:00
|
|
|
error = copyout(&osb, uap->buf, sizeof(osb));
|
|
|
|
sp++;
|
|
|
|
uap->buf++;
|
|
|
|
count--;
|
2003-11-12 08:01:40 +00:00
|
|
|
}
|
2005-06-09 17:44:46 +00:00
|
|
|
free(buf, M_TEMP);
|
2003-11-12 08:01:40 +00:00
|
|
|
}
|
2005-06-09 17:44:46 +00:00
|
|
|
return (error);
|
2003-11-12 08:01:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Implement fstatfs() for (NFS) file handles.
|
|
|
|
*/
|
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct freebsd4_fhstatfs_args {
|
|
|
|
struct fhandle *u_fhp;
|
|
|
|
struct ostatfs *buf;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
int
|
|
|
|
freebsd4_fhstatfs(td, uap)
|
|
|
|
struct thread *td;
|
|
|
|
struct freebsd4_fhstatfs_args /* {
|
|
|
|
struct fhandle *u_fhp;
|
|
|
|
struct ostatfs *buf;
|
|
|
|
} */ *uap;
|
|
|
|
{
|
|
|
|
struct ostatfs osb;
|
2005-02-07 18:44:55 +00:00
|
|
|
struct statfs sf;
|
2003-11-12 08:01:40 +00:00
|
|
|
fhandle_t fh;
|
|
|
|
int error;
|
|
|
|
|
2005-05-27 19:15:46 +00:00
|
|
|
error = copyin(uap->u_fhp, &fh, sizeof(fhandle_t));
|
|
|
|
if (error)
|
2003-11-12 08:01:40 +00:00
|
|
|
return (error);
|
2005-02-07 18:44:55 +00:00
|
|
|
error = kern_fhstatfs(td, fh, &sf);
|
2003-11-12 08:01:40 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
2005-05-27 19:23:48 +00:00
|
|
|
cvtstatfs(&sf, &osb);
|
2003-11-12 08:01:40 +00:00
|
|
|
return (copyout(&osb, uap->buf, sizeof(osb)));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Convert a new format statfs structure to an old format statfs structure.
|
|
|
|
*/
|
|
|
|
static void
|
2005-05-27 19:23:48 +00:00
|
|
|
cvtstatfs(nsp, osp)
|
2003-11-12 08:01:40 +00:00
|
|
|
struct statfs *nsp;
|
|
|
|
struct ostatfs *osp;
|
|
|
|
{
|
|
|
|
|
2007-08-28 20:28:12 +00:00
|
|
|
statfs_scale_blocks(nsp, LONG_MAX);
|
2003-11-12 08:01:40 +00:00
|
|
|
bzero(osp, sizeof(*osp));
|
2007-08-28 20:28:12 +00:00
|
|
|
osp->f_bsize = nsp->f_bsize;
|
2003-11-12 08:01:40 +00:00
|
|
|
osp->f_iosize = MIN(nsp->f_iosize, LONG_MAX);
|
2007-08-28 20:28:12 +00:00
|
|
|
osp->f_blocks = nsp->f_blocks;
|
|
|
|
osp->f_bfree = nsp->f_bfree;
|
|
|
|
osp->f_bavail = nsp->f_bavail;
|
2003-11-12 08:01:40 +00:00
|
|
|
osp->f_files = MIN(nsp->f_files, LONG_MAX);
|
|
|
|
osp->f_ffree = MIN(nsp->f_ffree, LONG_MAX);
|
|
|
|
osp->f_owner = nsp->f_owner;
|
|
|
|
osp->f_type = nsp->f_type;
|
|
|
|
osp->f_flags = nsp->f_flags;
|
|
|
|
osp->f_syncwrites = MIN(nsp->f_syncwrites, LONG_MAX);
|
|
|
|
osp->f_asyncwrites = MIN(nsp->f_asyncwrites, LONG_MAX);
|
|
|
|
osp->f_syncreads = MIN(nsp->f_syncreads, LONG_MAX);
|
|
|
|
osp->f_asyncreads = MIN(nsp->f_asyncreads, LONG_MAX);
|
2006-03-04 00:09:09 +00:00
|
|
|
strlcpy(osp->f_fstypename, nsp->f_fstypename,
|
|
|
|
MIN(MFSNAMELEN, OMFSNAMELEN));
|
|
|
|
strlcpy(osp->f_mntonname, nsp->f_mntonname,
|
2006-03-03 07:20:54 +00:00
|
|
|
MIN(MNAMELEN, OMNAMELEN));
|
2006-03-04 00:09:09 +00:00
|
|
|
strlcpy(osp->f_mntfromname, nsp->f_mntfromname,
|
2006-03-03 07:20:54 +00:00
|
|
|
MIN(MNAMELEN, OMNAMELEN));
|
2005-05-22 21:52:30 +00:00
|
|
|
osp->f_fsid = nsp->f_fsid;
|
2003-11-12 08:01:40 +00:00
|
|
|
}
|
|
|
|
#endif /* COMPAT_FREEBSD4 */
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* 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-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
fchdir(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
struct fchdir_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
int fd;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-12 08:38:13 +00:00
|
|
|
register struct filedesc *fdp = td->td_proc->p_fd;
|
2002-01-13 11:58:06 +00:00
|
|
|
struct vnode *vp, *tdp, *vpold;
|
1997-02-10 02:22:35 +00:00
|
|
|
struct mount *mp;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct file *fp;
|
2005-01-24 10:25:44 +00:00
|
|
|
int vfslocked;
|
1994-05-24 10:09:53 +00:00
|
|
|
int error;
|
|
|
|
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
AUDIT_ARG(fd, uap->fd);
|
2002-12-14 01:56:26 +00:00
|
|
|
if ((error = getvnode(fdp, uap->fd, &fp)) != 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2003-06-22 08:41:43 +00:00
|
|
|
vp = fp->f_vnode;
|
1997-02-10 02:22:35 +00:00
|
|
|
VREF(vp);
|
2002-01-13 11:58:06 +00:00
|
|
|
fdrop(fp, td);
|
2005-12-20 00:49:59 +00:00
|
|
|
vfslocked = VFS_LOCK_GIANT(vp->v_mount);
|
2008-01-10 01:10:58 +00:00
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
AUDIT_ARG(vnode, vp, ARG_VNODE1);
|
2006-07-19 18:30:33 +00:00
|
|
|
error = change_dir(vp, td);
|
1997-02-10 02:22:35 +00:00
|
|
|
while (!error && (mp = vp->v_mountedhere) != NULL) {
|
2005-01-24 10:25:44 +00:00
|
|
|
int tvfslocked;
|
2008-08-31 14:26:08 +00:00
|
|
|
if (vfs_busy(mp, 0, 0))
|
1997-02-10 02:22:35 +00:00
|
|
|
continue;
|
2005-01-24 10:25:44 +00:00
|
|
|
tvfslocked = VFS_LOCK_GIANT(mp);
|
2005-03-24 07:31:38 +00:00
|
|
|
error = VFS_ROOT(mp, LK_EXCLUSIVE, &tdp, td);
|
2008-08-31 14:26:08 +00:00
|
|
|
vfs_unbusy(mp);
|
2005-01-24 10:25:44 +00:00
|
|
|
if (error) {
|
|
|
|
VFS_UNLOCK_GIANT(tvfslocked);
|
1997-02-10 02:22:35 +00:00
|
|
|
break;
|
2005-01-24 10:25:44 +00:00
|
|
|
}
|
1997-02-10 02:22:35 +00:00
|
|
|
vput(vp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
1997-02-10 02:22:35 +00:00
|
|
|
vp = tdp;
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = tvfslocked;
|
1997-02-10 02:22:35 +00:00
|
|
|
}
|
|
|
|
if (error) {
|
|
|
|
vput(vp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
1997-02-10 02:22:35 +00:00
|
|
|
}
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(vp, 0);
|
2006-02-03 15:42:16 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XLOCK(fdp);
|
2002-01-13 11:58:06 +00:00
|
|
|
vpold = fdp->fd_cdir;
|
1994-05-24 10:09:53 +00:00
|
|
|
fdp->fd_cdir = vp;
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(fdp);
|
2006-02-03 15:42:16 +00:00
|
|
|
vfslocked = VFS_LOCK_GIANT(vpold->v_mount);
|
2002-01-13 11:58:06 +00:00
|
|
|
vrele(vpold);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
1994-05-24 10:09:53 +00:00
|
|
|
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-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
chdir(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
struct chdir_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
2002-09-01 20:37:28 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
return (kern_chdir(td, uap->path, UIO_USERSPACE));
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_chdir(struct thread *td, char *path, enum uio_seg pathseg)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-12 08:38:13 +00:00
|
|
|
register struct filedesc *fdp = td->td_proc->p_fd;
|
1994-05-24 10:09:53 +00:00
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
2002-01-13 11:58:06 +00:00
|
|
|
struct vnode *vp;
|
2005-01-24 10:25:44 +00:00
|
|
|
int vfslocked;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | AUDITVNODE1 | MPSAFE,
|
|
|
|
pathseg, path, td);
|
2003-04-09 02:55:18 +00:00
|
|
|
if ((error = namei(&nd)) != 0)
|
|
|
|
return (error);
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = NDHASGIANT(&nd);
|
2003-04-09 02:55:18 +00:00
|
|
|
if ((error = change_dir(nd.ni_vp, td)) != 0) {
|
|
|
|
vput(nd.ni_vp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2003-04-09 02:55:18 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2003-04-09 02:55:18 +00:00
|
|
|
}
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(nd.ni_vp, 0);
|
2006-02-01 09:30:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
1999-12-15 23:02:35 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XLOCK(fdp);
|
2002-01-13 11:58:06 +00:00
|
|
|
vp = fdp->fd_cdir;
|
1994-05-24 10:09:53 +00:00
|
|
|
fdp->fd_cdir = nd.ni_vp;
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(fdp);
|
2006-02-01 09:30:44 +00:00
|
|
|
vfslocked = VFS_LOCK_GIANT(vp->v_mount);
|
2002-01-13 11:58:06 +00:00
|
|
|
vrele(vp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
1999-03-23 14:26:40 +00:00
|
|
|
/*
|
|
|
|
* Helper function for raised chroot(2) security function: Refuse if
|
|
|
|
* any filedescriptors are open directories.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
chroot_refuse_vdir_fds(fdp)
|
|
|
|
struct filedesc *fdp;
|
|
|
|
{
|
|
|
|
struct vnode *vp;
|
|
|
|
struct file *fp;
|
|
|
|
int fd;
|
|
|
|
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_LOCK_ASSERT(fdp);
|
|
|
|
|
1999-03-23 14:26:40 +00:00
|
|
|
for (fd = 0; fd < fdp->fd_nfiles ; fd++) {
|
2002-02-01 18:27:16 +00:00
|
|
|
fp = fget_locked(fdp, fd);
|
|
|
|
if (fp == NULL)
|
1999-03-23 14:26:40 +00:00
|
|
|
continue;
|
2002-02-01 18:27:16 +00:00
|
|
|
if (fp->f_type == DTYPE_VNODE) {
|
2003-06-22 08:41:43 +00:00
|
|
|
vp = fp->f_vnode;
|
2002-07-13 04:07:12 +00:00
|
|
|
if (vp->v_type == VDIR)
|
2002-02-01 18:27:16 +00:00
|
|
|
return (EPERM);
|
|
|
|
}
|
1999-03-23 14:26:40 +00:00
|
|
|
}
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This sysctl determines if we will allow a process to chroot(2) if it
|
|
|
|
* has a directory open:
|
|
|
|
* 0: disallowed for all processes.
|
|
|
|
* 1: allowed for processes that were not already chroot(2)'ed.
|
|
|
|
* 2: allowed for all processes.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int chroot_allow_open_directories = 1;
|
|
|
|
|
|
|
|
SYSCTL_INT(_kern, OID_AUTO, chroot_allow_open_directories, CTLFLAG_RW,
|
|
|
|
&chroot_allow_open_directories, 0, "");
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* 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-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
chroot(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
struct chroot_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
2005-01-24 10:25:44 +00:00
|
|
|
int vfslocked;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2007-06-12 00:12:01 +00:00
|
|
|
error = priv_check(td, PRIV_VFS_CHROOT);
|
1994-10-02 17:35:40 +00:00
|
|
|
if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | MPSAFE | AUDITVNODE1,
|
2005-01-24 10:25:44 +00:00
|
|
|
UIO_USERSPACE, uap->path, td);
|
2003-04-09 02:55:18 +00:00
|
|
|
error = namei(&nd);
|
|
|
|
if (error)
|
2002-07-13 04:07:12 +00:00
|
|
|
goto error;
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = NDHASGIANT(&nd);
|
2003-04-09 02:55:18 +00:00
|
|
|
if ((error = change_dir(nd.ni_vp, td)) != 0)
|
|
|
|
goto e_vunlock;
|
2002-08-01 03:50:08 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
if ((error = mac_vnode_check_chroot(td->td_ucred, nd.ni_vp)))
|
2003-04-09 02:55:18 +00:00
|
|
|
goto e_vunlock;
|
2002-08-01 03:50:08 +00:00
|
|
|
#endif
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(nd.ni_vp, 0);
|
2003-04-09 02:55:18 +00:00
|
|
|
error = change_root(nd.ni_vp, td);
|
|
|
|
vrele(nd.ni_vp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2002-07-13 04:07:12 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
2003-04-09 02:55:18 +00:00
|
|
|
return (error);
|
|
|
|
e_vunlock:
|
|
|
|
vput(nd.ni_vp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2002-07-13 04:07:12 +00:00
|
|
|
error:
|
2003-01-31 18:57:04 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
2002-07-13 04:07:12 +00:00
|
|
|
return (error);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2003-04-09 02:55:18 +00:00
|
|
|
* Common routine for chroot and chdir. Callers must provide a locked vnode
|
|
|
|
* instance.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2003-04-09 02:55:18 +00:00
|
|
|
int
|
|
|
|
change_dir(vp, td)
|
|
|
|
struct vnode *vp;
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
2003-04-09 02:55:18 +00:00
|
|
|
ASSERT_VOP_LOCKED(vp, "change_dir(): vp not locked");
|
1994-05-24 10:09:53 +00:00
|
|
|
if (vp->v_type != VDIR)
|
2003-04-09 02:55:18 +00:00
|
|
|
return (ENOTDIR);
|
2002-08-01 03:50:08 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_vnode_check_chdir(td->td_ucred, vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (error)
|
2003-04-09 02:55:18 +00:00
|
|
|
return (error);
|
|
|
|
#endif
|
|
|
|
error = VOP_ACCESS(vp, VEXEC, td->td_ucred, td);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2003-04-09 02:55:18 +00:00
|
|
|
/*
|
|
|
|
* Common routine for kern_chroot() and jail_attach(). The caller is
|
2007-10-24 19:04:04 +00:00
|
|
|
* responsible for invoking priv_check() and mac_vnode_check_chroot() to
|
|
|
|
* authorize this operation.
|
2003-04-09 02:55:18 +00:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
change_root(vp, td)
|
|
|
|
struct vnode *vp;
|
|
|
|
struct thread *td;
|
|
|
|
{
|
|
|
|
struct filedesc *fdp;
|
|
|
|
struct vnode *oldvp;
|
2006-02-01 09:30:44 +00:00
|
|
|
int vfslocked;
|
2003-04-09 02:55:18 +00:00
|
|
|
int error;
|
|
|
|
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_ASSERT_GIANT(vp->v_mount);
|
2003-04-09 02:55:18 +00:00
|
|
|
fdp = td->td_proc->p_fd;
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XLOCK(fdp);
|
2003-04-09 02:55:18 +00:00
|
|
|
if (chroot_allow_open_directories == 0 ||
|
|
|
|
(chroot_allow_open_directories == 1 && fdp->fd_rdir != rootvnode)) {
|
|
|
|
error = chroot_refuse_vdir_fds(fdp);
|
|
|
|
if (error) {
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(fdp);
|
2003-04-09 02:55:18 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
oldvp = fdp->fd_rdir;
|
|
|
|
fdp->fd_rdir = vp;
|
|
|
|
VREF(fdp->fd_rdir);
|
|
|
|
if (!fdp->fd_jdir) {
|
|
|
|
fdp->fd_jdir = vp;
|
|
|
|
VREF(fdp->fd_jdir);
|
|
|
|
}
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(fdp);
|
2006-02-01 09:30:44 +00:00
|
|
|
vfslocked = VFS_LOCK_GIANT(oldvp->v_mount);
|
2003-04-09 02:55:18 +00:00
|
|
|
vrele(oldvp);
|
2006-02-01 09:30:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2003-04-09 02:55:18 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
2007-03-05 13:10:58 +00:00
|
|
|
* Check permissions, allocate an open file structure, and call the device
|
|
|
|
* open routine if any.
|
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 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
|
2001-09-12 08:38:13 +00:00
|
|
|
open(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct open_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
|
|
|
int flags;
|
|
|
|
int mode;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2002-09-01 20:37:28 +00:00
|
|
|
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
return (kern_open(td, uap->path, UIO_USERSPACE, uap->flags, uap->mode));
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct openat_args {
|
|
|
|
int fd;
|
|
|
|
char *path;
|
|
|
|
int flag;
|
|
|
|
int mode;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
int
|
|
|
|
openat(struct thread *td, struct openat_args *uap)
|
|
|
|
{
|
|
|
|
|
|
|
|
return (kern_openat(td, uap->fd, uap->path, UIO_USERSPACE, uap->flag,
|
|
|
|
uap->mode));
|
2002-09-01 20:37:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_open(struct thread *td, char *path, enum uio_seg pathseg, int flags,
|
|
|
|
int mode)
|
|
|
|
{
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
|
|
|
|
return (kern_openat(td, AT_FDCWD, path, pathseg, flags, mode));
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_openat(struct thread *td, int fd, char *path, enum uio_seg pathseg,
|
|
|
|
int flags, int mode)
|
|
|
|
{
|
2001-09-12 08:38:13 +00:00
|
|
|
struct proc *p = td->td_proc;
|
2000-07-04 03:34:11 +00:00
|
|
|
struct filedesc *fdp = p->p_fd;
|
|
|
|
struct file *fp;
|
|
|
|
struct vnode *vp;
|
|
|
|
struct vattr vat;
|
2000-07-11 22:07:57 +00:00
|
|
|
struct mount *mp;
|
2003-05-31 20:29:34 +00:00
|
|
|
int cmode;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct file *nfp;
|
|
|
|
int type, indx, error;
|
|
|
|
struct flock lf;
|
|
|
|
struct nameidata nd;
|
2005-01-24 10:25:44 +00:00
|
|
|
int vfslocked;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
AUDIT_ARG(fflags, flags);
|
|
|
|
AUDIT_ARG(mode, mode);
|
2008-03-31 11:57:18 +00:00
|
|
|
/* XXX: audit dirfd */
|
|
|
|
/*
|
|
|
|
* Only one of the O_EXEC, O_RDONLY, O_WRONLY and O_RDWR may
|
|
|
|
* be specified.
|
|
|
|
*/
|
|
|
|
if (flags & O_EXEC) {
|
|
|
|
if (flags & O_ACCMODE)
|
|
|
|
return (EINVAL);
|
|
|
|
} else if ((flags & O_ACCMODE) == O_ACCMODE)
|
1997-10-22 07:28:51 +00:00
|
|
|
return (EINVAL);
|
2008-03-31 11:57:18 +00:00
|
|
|
else
|
|
|
|
flags = FFLAGS(flags);
|
|
|
|
|
2001-09-12 08:38:13 +00:00
|
|
|
error = falloc(td, &nfp, &indx);
|
1994-10-02 17:35:40 +00:00
|
|
|
if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2003-10-19 20:41:07 +00:00
|
|
|
/* An extra reference on `nfp' has been held for us by falloc(). */
|
1994-05-24 10:09:53 +00:00
|
|
|
fp = nfp;
|
2007-12-30 01:42:15 +00:00
|
|
|
/* Set the flags early so the finit in devfs can pick them up. */
|
|
|
|
fp->f_flag = flags & FMASK;
|
2002-09-01 20:37:28 +00:00
|
|
|
cmode = ((mode &~ fdp->fd_cmask) & ALLPERMS) &~ S_ISTXT;
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
NDINIT_AT(&nd, LOOKUP, FOLLOW | AUDITVNODE1 | MPSAFE, pathseg, path, fd,
|
|
|
|
td);
|
2003-08-07 17:08:26 +00:00
|
|
|
td->td_dupfd = -1; /* XXX check for fdopen */
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
error = vn_open(&nd, &flags, cmode, fp);
|
1994-10-02 17:35:40 +00:00
|
|
|
if (error) {
|
2003-07-27 20:09:13 +00:00
|
|
|
/*
|
|
|
|
* If the vn_open replaced the method vector, something
|
|
|
|
* wonderous happened deep below and we just pass it up
|
|
|
|
* pretending we know what we do.
|
|
|
|
*/
|
|
|
|
if (error == ENXIO && fp->f_ops != &badfileops) {
|
|
|
|
fdrop(fp, td);
|
|
|
|
td->td_retval[0] = indx;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2000-11-18 21:01:04 +00:00
|
|
|
/*
|
|
|
|
* handle special fdopen() case. bleh. dupfdopen() is
|
|
|
|
* responsible for dropping the old contents of ofiles[indx]
|
|
|
|
* if it succeeds.
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
if ((error == ENODEV || error == ENXIO) &&
|
2001-09-12 08:38:13 +00:00
|
|
|
td->td_dupfd >= 0 && /* XXX from fdopen */
|
1994-05-24 10:09:53 +00:00
|
|
|
(error =
|
2001-09-12 08:38:13 +00:00
|
|
|
dupfdopen(td, fdp, indx, td->td_dupfd, flags, error)) == 0) {
|
|
|
|
td->td_retval[0] = indx;
|
2007-03-21 19:32:08 +00:00
|
|
|
fdrop(fp, td);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
}
|
2000-11-18 21:01:04 +00:00
|
|
|
/*
|
|
|
|
* Clean up the descriptor, but only if another thread hadn't
|
|
|
|
* replaced or closed it.
|
|
|
|
*/
|
2004-11-07 22:16:07 +00:00
|
|
|
fdclose(fdp, fp, indx, td);
|
2007-03-21 19:32:08 +00:00
|
|
|
fdrop(fp, td);
|
2000-11-18 21:01:04 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
if (error == ERESTART)
|
|
|
|
error = EINTR;
|
|
|
|
return (error);
|
|
|
|
}
|
2001-09-12 08:38:13 +00:00
|
|
|
td->td_dupfd = 0;
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = NDHASGIANT(&nd);
|
1999-12-15 23:02:35 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
1994-05-24 10:09:53 +00:00
|
|
|
vp = nd.ni_vp;
|
1996-12-19 19:42:37 +00:00
|
|
|
|
2007-12-30 01:42:15 +00:00
|
|
|
fp->f_vnode = vp; /* XXX Does devfs need this? */
|
|
|
|
/*
|
|
|
|
* If the file wasn't claimed by devfs bind it to the normal
|
|
|
|
* vnode operations here.
|
|
|
|
*/
|
|
|
|
if (fp->f_ops == &badfileops) {
|
|
|
|
KASSERT(vp->v_type != VFIFO, ("Unexpected fifo."));
|
|
|
|
fp->f_seqcount = 1;
|
|
|
|
finit(fp, flags & FMASK, DTYPE_VNODE, vp, &vnops);
|
|
|
|
}
|
2003-06-19 04:10:56 +00:00
|
|
|
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(vp, 0);
|
1994-05-24 10:09:53 +00:00
|
|
|
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;
|
2002-06-28 23:02:38 +00:00
|
|
|
if ((error = VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf,
|
|
|
|
type)) != 0)
|
2000-07-04 03:34:11 +00:00
|
|
|
goto bad;
|
2007-12-30 01:42:15 +00:00
|
|
|
atomic_set_int(&fp->f_flag, FHASLOCK);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2000-07-04 03:34:11 +00:00
|
|
|
if (flags & O_TRUNC) {
|
2000-07-11 22:07:57 +00:00
|
|
|
if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0)
|
|
|
|
goto bad;
|
2002-02-27 18:32:23 +00:00
|
|
|
VOP_LEASE(vp, td, td->td_ucred, LEASE_WRITE);
|
2000-07-04 03:34:11 +00:00
|
|
|
VATTR_NULL(&vat);
|
|
|
|
vat.va_size = 0;
|
2008-01-10 01:10:58 +00:00
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
|
Introduce support for Mandatory Access Control and extensible
kernel access control.
Invoke appropriate MAC entry points to authorize the following
operations:
truncate on open() (write)
access() (access)
readlink() (readlink)
chflags(), lchflags(), fchflags() (setflag)
chmod(), fchmod(), lchmod() (setmode)
chown(), fchown(), lchown() (setowner)
utimes(), lutimes(), futimes() (setutimes)
truncate(), ftrunfcate() (write)
revoke() (revoke)
fhopen() (open)
truncate on fhopen() (write)
extattr_set_fd, extattr_set_file() (setextattr)
extattr_get_fd, extattr_get_file() (getextattr)
extattr_delete_fd(), extattr_delete_file() (setextattr)
These entry points permit MAC policies to enforce a variety of
protections on vnodes. More vnode checks to come, especially in
non-native ABIs.
Obtained from: TrustedBSD Project
Sponsored by: DARPA, NAI Labs
2002-08-01 15:37:12 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_vnode_check_write(td->td_ucred, fp->f_cred, vp);
|
Introduce support for Mandatory Access Control and extensible
kernel access control.
Invoke appropriate MAC entry points to authorize the following
operations:
truncate on open() (write)
access() (access)
readlink() (readlink)
chflags(), lchflags(), fchflags() (setflag)
chmod(), fchmod(), lchmod() (setmode)
chown(), fchown(), lchown() (setowner)
utimes(), lutimes(), futimes() (setutimes)
truncate(), ftrunfcate() (write)
revoke() (revoke)
fhopen() (open)
truncate on fhopen() (write)
extattr_set_fd, extattr_set_file() (setextattr)
extattr_get_fd, extattr_get_file() (getextattr)
extattr_delete_fd(), extattr_delete_file() (setextattr)
These entry points permit MAC policies to enforce a variety of
protections on vnodes. More vnode checks to come, especially in
non-native ABIs.
Obtained from: TrustedBSD Project
Sponsored by: DARPA, NAI Labs
2002-08-01 15:37:12 +00:00
|
|
|
if (error == 0)
|
|
|
|
#endif
|
2008-08-28 15:23:18 +00:00
|
|
|
error = VOP_SETATTR(vp, &vat, td->td_ucred);
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(vp, 0);
|
2000-07-11 22:07:57 +00:00
|
|
|
vn_finished_write(mp);
|
2000-07-04 03:34:11 +00:00
|
|
|
if (error)
|
|
|
|
goto bad;
|
|
|
|
}
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2000-11-18 21:01:04 +00:00
|
|
|
/*
|
|
|
|
* Release our private reference, leaving the one associated with
|
|
|
|
* the descriptor table intact.
|
|
|
|
*/
|
2001-09-12 08:38:13 +00:00
|
|
|
fdrop(fp, td);
|
|
|
|
td->td_retval[0] = indx;
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
2000-07-04 03:34:11 +00:00
|
|
|
bad:
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2004-11-07 22:16:07 +00:00
|
|
|
fdclose(fdp, fp, indx, td);
|
2002-10-07 20:49:22 +00:00
|
|
|
fdrop(fp, td);
|
2000-07-04 03:34:11 +00:00
|
|
|
return (error);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#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
|
2001-09-12 08:38:13 +00:00
|
|
|
ocreat(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct ocreat_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
|
|
|
int mode;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1997-02-10 02:22:35 +00:00
|
|
|
|
2004-03-16 10:46:42 +00:00
|
|
|
return (kern_open(td, uap->path, UIO_USERSPACE,
|
|
|
|
O_WRONLY | O_CREAT | O_TRUNC, uap->mode));
|
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-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
mknod(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct mknod_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
|
|
|
int mode;
|
|
|
|
int dev;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2002-09-01 20:37:28 +00:00
|
|
|
|
|
|
|
return (kern_mknod(td, uap->path, UIO_USERSPACE, uap->mode, uap->dev));
|
|
|
|
}
|
|
|
|
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct mknodat_args {
|
|
|
|
int fd;
|
|
|
|
char *path;
|
|
|
|
mode_t mode;
|
|
|
|
dev_t dev;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
int
|
|
|
|
mknodat(struct thread *td, struct mknodat_args *uap)
|
|
|
|
{
|
|
|
|
|
|
|
|
return (kern_mknodat(td, uap->fd, uap->path, UIO_USERSPACE, uap->mode,
|
|
|
|
uap->dev));
|
|
|
|
}
|
|
|
|
|
2002-09-01 20:37:28 +00:00
|
|
|
int
|
|
|
|
kern_mknod(struct thread *td, char *path, enum uio_seg pathseg, int mode,
|
|
|
|
int dev)
|
|
|
|
{
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
|
|
|
|
return (kern_mknodat(td, AT_FDCWD, path, pathseg, mode, dev));
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_mknodat(struct thread *td, int fd, char *path, enum uio_seg pathseg,
|
|
|
|
int mode, int dev)
|
|
|
|
{
|
2000-07-11 22:07:57 +00:00
|
|
|
struct vnode *vp;
|
|
|
|
struct mount *mp;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct vattr vattr;
|
|
|
|
int error;
|
1998-06-07 17:13:14 +00:00
|
|
|
int whiteout = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct nameidata nd;
|
2005-01-24 10:25:44 +00:00
|
|
|
int vfslocked;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
AUDIT_ARG(mode, mode);
|
|
|
|
AUDIT_ARG(dev, dev);
|
2002-09-01 20:37:28 +00:00
|
|
|
switch (mode & S_IFMT) {
|
This Implements the mumbled about "Jail" feature.
This is a seriously beefed up chroot kind of thing. The process
is jailed along the same lines as a chroot does it, but with
additional tough restrictions imposed on what the superuser can do.
For all I know, it is safe to hand over the root bit inside a
prison to the customer living in that prison, this is what
it was developed for in fact: "real virtual servers".
Each prison has an ip number associated with it, which all IP
communications will be coerced to use and each prison has its own
hostname.
Needless to say, you need more RAM this way, but the advantage is
that each customer can run their own particular version of apache
and not stomp on the toes of their neighbors.
It generally does what one would expect, but setting up a jail
still takes a little knowledge.
A few notes:
I have no scripts for setting up a jail, don't ask me for them.
The IP number should be an alias on one of the interfaces.
mount a /proc in each jail, it will make ps more useable.
/proc/<pid>/status tells the hostname of the prison for
jailed processes.
Quotas are only sensible if you have a mountpoint per prison.
There are no privisions for stopping resource-hogging.
Some "#ifdef INET" and similar may be missing (send patches!)
If somebody wants to take it from here and develop it into
more of a "virtual machine" they should be most welcome!
Tools, comments, patches & documentation most welcome.
Have fun...
Sponsored by: http://www.rndassociates.com/
Run for almost a year by: http://www.servetheweb.com/
1999-04-28 11:38:52 +00:00
|
|
|
case S_IFCHR:
|
|
|
|
case S_IFBLK:
|
2006-11-06 13:42:10 +00:00
|
|
|
error = priv_check(td, PRIV_VFS_MKNOD_DEV);
|
|
|
|
break;
|
|
|
|
case S_IFMT:
|
|
|
|
error = priv_check(td, PRIV_VFS_MKNOD_BAD);
|
|
|
|
break;
|
|
|
|
case S_IFWHT:
|
|
|
|
error = priv_check(td, PRIV_VFS_MKNOD_WHT);
|
This Implements the mumbled about "Jail" feature.
This is a seriously beefed up chroot kind of thing. The process
is jailed along the same lines as a chroot does it, but with
additional tough restrictions imposed on what the superuser can do.
For all I know, it is safe to hand over the root bit inside a
prison to the customer living in that prison, this is what
it was developed for in fact: "real virtual servers".
Each prison has an ip number associated with it, which all IP
communications will be coerced to use and each prison has its own
hostname.
Needless to say, you need more RAM this way, but the advantage is
that each customer can run their own particular version of apache
and not stomp on the toes of their neighbors.
It generally does what one would expect, but setting up a jail
still takes a little knowledge.
A few notes:
I have no scripts for setting up a jail, don't ask me for them.
The IP number should be an alias on one of the interfaces.
mount a /proc in each jail, it will make ps more useable.
/proc/<pid>/status tells the hostname of the prison for
jailed processes.
Quotas are only sensible if you have a mountpoint per prison.
There are no privisions for stopping resource-hogging.
Some "#ifdef INET" and similar may be missing (send patches!)
If somebody wants to take it from here and develop it into
more of a "virtual machine" they should be most welcome!
Tools, comments, patches & documentation most welcome.
Have fun...
Sponsored by: http://www.rndassociates.com/
Run for almost a year by: http://www.servetheweb.com/
1999-04-28 11:38:52 +00:00
|
|
|
break;
|
2008-06-22 21:51:32 +00:00
|
|
|
case S_IFIFO:
|
|
|
|
if (dev == 0)
|
|
|
|
return (kern_mkfifoat(td, fd, path, pathseg, mode));
|
|
|
|
/* FALLTHROUGH */
|
This Implements the mumbled about "Jail" feature.
This is a seriously beefed up chroot kind of thing. The process
is jailed along the same lines as a chroot does it, but with
additional tough restrictions imposed on what the superuser can do.
For all I know, it is safe to hand over the root bit inside a
prison to the customer living in that prison, this is what
it was developed for in fact: "real virtual servers".
Each prison has an ip number associated with it, which all IP
communications will be coerced to use and each prison has its own
hostname.
Needless to say, you need more RAM this way, but the advantage is
that each customer can run their own particular version of apache
and not stomp on the toes of their neighbors.
It generally does what one would expect, but setting up a jail
still takes a little knowledge.
A few notes:
I have no scripts for setting up a jail, don't ask me for them.
The IP number should be an alias on one of the interfaces.
mount a /proc in each jail, it will make ps more useable.
/proc/<pid>/status tells the hostname of the prison for
jailed processes.
Quotas are only sensible if you have a mountpoint per prison.
There are no privisions for stopping resource-hogging.
Some "#ifdef INET" and similar may be missing (send patches!)
If somebody wants to take it from here and develop it into
more of a "virtual machine" they should be most welcome!
Tools, comments, patches & documentation most welcome.
Have fun...
Sponsored by: http://www.rndassociates.com/
Run for almost a year by: http://www.servetheweb.com/
1999-04-28 11:38:52 +00:00
|
|
|
default:
|
2006-11-06 13:42:10 +00:00
|
|
|
error = EINVAL;
|
This Implements the mumbled about "Jail" feature.
This is a seriously beefed up chroot kind of thing. The process
is jailed along the same lines as a chroot does it, but with
additional tough restrictions imposed on what the superuser can do.
For all I know, it is safe to hand over the root bit inside a
prison to the customer living in that prison, this is what
it was developed for in fact: "real virtual servers".
Each prison has an ip number associated with it, which all IP
communications will be coerced to use and each prison has its own
hostname.
Needless to say, you need more RAM this way, but the advantage is
that each customer can run their own particular version of apache
and not stomp on the toes of their neighbors.
It generally does what one would expect, but setting up a jail
still takes a little knowledge.
A few notes:
I have no scripts for setting up a jail, don't ask me for them.
The IP number should be an alias on one of the interfaces.
mount a /proc in each jail, it will make ps more useable.
/proc/<pid>/status tells the hostname of the prison for
jailed processes.
Quotas are only sensible if you have a mountpoint per prison.
There are no privisions for stopping resource-hogging.
Some "#ifdef INET" and similar may be missing (send patches!)
If somebody wants to take it from here and develop it into
more of a "virtual machine" they should be most welcome!
Tools, comments, patches & documentation most welcome.
Have fun...
Sponsored by: http://www.rndassociates.com/
Run for almost a year by: http://www.servetheweb.com/
1999-04-28 11:38:52 +00:00
|
|
|
break;
|
|
|
|
}
|
1994-10-02 17:35:40 +00:00
|
|
|
if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2000-07-11 22:07:57 +00:00
|
|
|
restart:
|
2000-01-10 00:08:53 +00:00
|
|
|
bwillwrite();
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
NDINIT_AT(&nd, CREATE, LOCKPARENT | SAVENAME | MPSAFE | AUDITVNODE1,
|
|
|
|
pathseg, path, fd, td);
|
1999-01-27 21:50:00 +00:00
|
|
|
if ((error = namei(&nd)) != 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = NDHASGIANT(&nd);
|
1994-05-24 10:09:53 +00:00
|
|
|
vp = nd.ni_vp;
|
2000-07-11 22:07:57 +00:00
|
|
|
if (vp != NULL) {
|
2003-08-05 00:26:51 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
|
|
|
if (vp == nd.ni_dvp)
|
|
|
|
vrele(nd.ni_dvp);
|
|
|
|
else
|
|
|
|
vput(nd.ni_dvp);
|
2006-02-01 00:25:26 +00:00
|
|
|
vrele(vp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2003-08-05 00:26:51 +00:00
|
|
|
return (EEXIST);
|
2000-07-11 22:07:57 +00:00
|
|
|
} else {
|
1994-05-24 10:09:53 +00:00
|
|
|
VATTR_NULL(&vattr);
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_SLOCK(td->td_proc->p_fd);
|
2002-09-01 20:37:28 +00:00
|
|
|
vattr.va_mode = (mode & ALLPERMS) &
|
|
|
|
~td->td_proc->p_fd->fd_cmask;
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_SUNLOCK(td->td_proc->p_fd);
|
2002-09-01 20:37:28 +00:00
|
|
|
vattr.va_rdev = dev;
|
1997-02-10 02:22:35 +00:00
|
|
|
whiteout = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2002-09-01 20:37:28 +00:00
|
|
|
switch (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:
|
2006-11-06 13:42:10 +00:00
|
|
|
panic("kern_mknod: invalid mode");
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|
2000-07-11 22:07:57 +00:00
|
|
|
if (vn_start_write(nd.ni_dvp, &mp, V_NOWAIT) != 0) {
|
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
|
|
|
vput(nd.ni_dvp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2000-07-11 22:07:57 +00:00
|
|
|
if ((error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH)) != 0)
|
|
|
|
return (error);
|
|
|
|
goto restart;
|
|
|
|
}
|
2002-10-19 20:25:57 +00:00
|
|
|
#ifdef MAC
|
|
|
|
if (error == 0 && !whiteout)
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_vnode_check_create(td->td_ucred, nd.ni_dvp,
|
2002-10-19 20:25:57 +00:00
|
|
|
&nd.ni_cnd, &vattr);
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
if (!error) {
|
2002-02-27 18:32:23 +00:00
|
|
|
VOP_LEASE(nd.ni_dvp, td, td->td_ucred, LEASE_WRITE);
|
1999-12-15 23:02:35 +00:00
|
|
|
if (whiteout)
|
1997-02-10 02:22:35 +00:00
|
|
|
error = VOP_WHITEOUT(nd.ni_dvp, &nd.ni_cnd, CREATE);
|
1999-12-15 23:02:35 +00:00
|
|
|
else {
|
1997-02-10 02:22:35 +00:00
|
|
|
error = VOP_MKNOD(nd.ni_dvp, &nd.ni_vp,
|
|
|
|
&nd.ni_cnd, &vattr);
|
1999-11-13 14:35:50 +00:00
|
|
|
if (error == 0)
|
|
|
|
vput(nd.ni_vp);
|
1997-02-10 02:22:35 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2000-07-11 22:07:57 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
|
|
|
vput(nd.ni_dvp);
|
|
|
|
vn_finished_write(mp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
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-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
mkfifo(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct mkfifo_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
|
|
|
int mode;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
2002-09-01 20:37:28 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
return (kern_mkfifo(td, uap->path, UIO_USERSPACE, uap->mode));
|
|
|
|
}
|
|
|
|
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct mkfifoat_args {
|
|
|
|
int fd;
|
|
|
|
char *path;
|
|
|
|
mode_t mode;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
int
|
|
|
|
mkfifoat(struct thread *td, struct mkfifoat_args *uap)
|
|
|
|
{
|
|
|
|
|
|
|
|
return (kern_mkfifoat(td, uap->fd, uap->path, UIO_USERSPACE,
|
|
|
|
uap->mode));
|
|
|
|
}
|
|
|
|
|
2002-09-01 20:37:28 +00:00
|
|
|
int
|
|
|
|
kern_mkfifo(struct thread *td, char *path, enum uio_seg pathseg, int mode)
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
return (kern_mkfifoat(td, AT_FDCWD, path, pathseg, mode));
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_mkfifoat(struct thread *td, int fd, char *path, enum uio_seg pathseg,
|
|
|
|
int mode)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2000-07-11 22:07:57 +00:00
|
|
|
struct mount *mp;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct vattr vattr;
|
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
2005-01-24 10:25:44 +00:00
|
|
|
int vfslocked;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2006-06-05 13:34:23 +00:00
|
|
|
AUDIT_ARG(mode, mode);
|
2000-07-11 22:07:57 +00:00
|
|
|
restart:
|
2000-01-10 00:08:53 +00:00
|
|
|
bwillwrite();
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
NDINIT_AT(&nd, CREATE, LOCKPARENT | SAVENAME | MPSAFE | AUDITVNODE1,
|
|
|
|
pathseg, path, fd, td);
|
1999-01-27 21:50:00 +00:00
|
|
|
if ((error = namei(&nd)) != 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = NDHASGIANT(&nd);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (nd.ni_vp != NULL) {
|
1999-12-15 23:02:35 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
2003-08-05 00:26:51 +00:00
|
|
|
if (nd.ni_vp == nd.ni_dvp)
|
|
|
|
vrele(nd.ni_dvp);
|
|
|
|
else
|
|
|
|
vput(nd.ni_dvp);
|
2006-02-01 00:25:26 +00:00
|
|
|
vrele(nd.ni_vp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (EEXIST);
|
|
|
|
}
|
2000-07-11 22:07:57 +00:00
|
|
|
if (vn_start_write(nd.ni_dvp, &mp, V_NOWAIT) != 0) {
|
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
|
|
|
vput(nd.ni_dvp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2000-07-11 22:07:57 +00:00
|
|
|
if ((error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH)) != 0)
|
|
|
|
return (error);
|
|
|
|
goto restart;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
VATTR_NULL(&vattr);
|
|
|
|
vattr.va_type = VFIFO;
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_SLOCK(td->td_proc->p_fd);
|
2002-09-01 20:37:28 +00:00
|
|
|
vattr.va_mode = (mode & ALLPERMS) & ~td->td_proc->p_fd->fd_cmask;
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_SUNLOCK(td->td_proc->p_fd);
|
2002-10-19 20:25:57 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_vnode_check_create(td->td_ucred, nd.ni_dvp, &nd.ni_cnd,
|
2002-10-19 20:25:57 +00:00
|
|
|
&vattr);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
#endif
|
2002-02-27 18:32:23 +00:00
|
|
|
VOP_LEASE(nd.ni_dvp, td, td->td_ucred, LEASE_WRITE);
|
1998-05-07 04:58:58 +00:00
|
|
|
error = VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr);
|
1999-11-13 14:35:50 +00:00
|
|
|
if (error == 0)
|
|
|
|
vput(nd.ni_vp);
|
2002-10-19 20:25:57 +00:00
|
|
|
#ifdef MAC
|
|
|
|
out:
|
|
|
|
#endif
|
1998-05-07 04:58:58 +00:00
|
|
|
vput(nd.ni_dvp);
|
2000-07-11 22:07:57 +00:00
|
|
|
vn_finished_write(mp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
1998-05-07 04:58:58 +00:00
|
|
|
return (error);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
link(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct link_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
|
|
|
char *link;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
2002-09-01 20:37:28 +00:00
|
|
|
{
|
|
|
|
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
return (kern_link(td, uap->path, uap->link, UIO_USERSPACE));
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct linkat_args {
|
|
|
|
int fd1;
|
|
|
|
char *path1;
|
|
|
|
int fd2;
|
|
|
|
char *path2;
|
|
|
|
int flag;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
int
|
|
|
|
linkat(struct thread *td, struct linkat_args *uap)
|
|
|
|
{
|
|
|
|
int flag;
|
|
|
|
|
|
|
|
flag = uap->flag;
|
|
|
|
if (flag & ~AT_SYMLINK_FOLLOW)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
return (kern_linkat(td, uap->fd1, uap->fd2, uap->path1, uap->path2,
|
|
|
|
UIO_USERSPACE, (flag & AT_SYMLINK_FOLLOW) ? FOLLOW : NOFOLLOW));
|
2002-09-01 20:37:28 +00:00
|
|
|
}
|
|
|
|
|
2004-03-08 20:37:25 +00:00
|
|
|
static int hardlink_check_uid = 0;
|
|
|
|
SYSCTL_INT(_security_bsd, OID_AUTO, hardlink_check_uid, CTLFLAG_RW,
|
|
|
|
&hardlink_check_uid, 0,
|
|
|
|
"Unprivileged processes cannot create hard links to files owned by other "
|
|
|
|
"users");
|
|
|
|
static int hardlink_check_gid = 0;
|
|
|
|
SYSCTL_INT(_security_bsd, OID_AUTO, hardlink_check_gid, CTLFLAG_RW,
|
|
|
|
&hardlink_check_gid, 0,
|
|
|
|
"Unprivileged processes cannot create hard links to files owned by other "
|
|
|
|
"groups");
|
|
|
|
|
|
|
|
static int
|
2008-08-28 15:23:18 +00:00
|
|
|
can_hardlink(struct vnode *vp, struct ucred *cred)
|
2004-03-08 20:37:25 +00:00
|
|
|
{
|
|
|
|
struct vattr va;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if (!hardlink_check_uid && !hardlink_check_gid)
|
|
|
|
return (0);
|
|
|
|
|
2008-08-28 15:23:18 +00:00
|
|
|
error = VOP_GETATTR(vp, &va, cred);
|
2004-03-08 20:37:25 +00:00
|
|
|
if (error != 0)
|
|
|
|
return (error);
|
|
|
|
|
2006-11-06 13:42:10 +00:00
|
|
|
if (hardlink_check_uid && cred->cr_uid != va.va_uid) {
|
2007-06-12 00:12:01 +00:00
|
|
|
error = priv_check_cred(cred, PRIV_VFS_LINK, 0);
|
2006-11-06 13:42:10 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
2004-03-08 20:37:25 +00:00
|
|
|
}
|
|
|
|
|
2006-11-06 13:42:10 +00:00
|
|
|
if (hardlink_check_gid && !groupmember(va.va_gid, cred)) {
|
2007-06-12 00:12:01 +00:00
|
|
|
error = priv_check_cred(cred, PRIV_VFS_LINK, 0);
|
2006-11-06 13:42:10 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
2004-03-08 20:37:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2002-09-01 20:37:28 +00:00
|
|
|
int
|
|
|
|
kern_link(struct thread *td, char *path, char *link, enum uio_seg segflg)
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
return (kern_linkat(td, AT_FDCWD, AT_FDCWD, path,link, segflg, FOLLOW));
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_linkat(struct thread *td, int fd1, int fd2, char *path1, char *path2,
|
|
|
|
enum uio_seg segflg, int follow)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2000-07-11 22:07:57 +00:00
|
|
|
struct vnode *vp;
|
|
|
|
struct mount *mp;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct nameidata nd;
|
2005-01-24 10:25:44 +00:00
|
|
|
int vfslocked;
|
|
|
|
int lvfslocked;
|
1994-05-24 10:09:53 +00:00
|
|
|
int error;
|
|
|
|
|
2000-01-10 00:08:53 +00:00
|
|
|
bwillwrite();
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
NDINIT_AT(&nd, LOOKUP, follow | MPSAFE | AUDITVNODE1, segflg, path1,
|
|
|
|
fd1, td);
|
|
|
|
|
1999-01-27 21:50:00 +00:00
|
|
|
if ((error = namei(&nd)) != 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = NDHASGIANT(&nd);
|
1999-12-15 23:02:35 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
1994-05-24 10:09:53 +00:00
|
|
|
vp = nd.ni_vp;
|
2000-07-11 22:07:57 +00:00
|
|
|
if (vp->v_type == VDIR) {
|
|
|
|
vrele(vp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2000-07-11 22:07:57 +00:00
|
|
|
return (EPERM); /* POSIX */
|
|
|
|
}
|
|
|
|
if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) {
|
|
|
|
vrele(vp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2000-07-11 22:07:57 +00:00
|
|
|
return (error);
|
|
|
|
}
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
NDINIT_AT(&nd, CREATE, LOCKPARENT | SAVENAME | MPSAFE | AUDITVNODE1,
|
|
|
|
segflg, path2, fd2, td);
|
2000-07-11 22:07:57 +00:00
|
|
|
if ((error = namei(&nd)) == 0) {
|
2005-01-24 10:25:44 +00:00
|
|
|
lvfslocked = NDHASGIANT(&nd);
|
2000-07-11 22:07:57 +00:00
|
|
|
if (nd.ni_vp != NULL) {
|
2003-08-05 00:26:51 +00:00
|
|
|
if (nd.ni_dvp == nd.ni_vp)
|
|
|
|
vrele(nd.ni_dvp);
|
|
|
|
else
|
|
|
|
vput(nd.ni_dvp);
|
2006-02-01 00:25:26 +00:00
|
|
|
vrele(nd.ni_vp);
|
2000-07-11 22:07:57 +00:00
|
|
|
error = EEXIST;
|
2008-01-10 01:10:58 +00:00
|
|
|
} else if ((error = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY))
|
2002-09-19 13:32:45 +00:00
|
|
|
== 0) {
|
2002-02-27 18:32:23 +00:00
|
|
|
VOP_LEASE(nd.ni_dvp, td, td->td_ucred, LEASE_WRITE);
|
|
|
|
VOP_LEASE(vp, td, td->td_ucred, LEASE_WRITE);
|
2008-08-28 15:23:18 +00:00
|
|
|
error = can_hardlink(vp, td->td_ucred);
|
2004-03-08 20:37:25 +00:00
|
|
|
if (error == 0)
|
2002-10-05 18:11:36 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_vnode_check_link(td->td_ucred,
|
2004-03-08 20:37:25 +00:00
|
|
|
nd.ni_dvp, vp, &nd.ni_cnd);
|
2002-10-05 18:11:36 +00:00
|
|
|
if (error == 0)
|
|
|
|
#endif
|
|
|
|
error = VOP_LINK(nd.ni_dvp, vp, &nd.ni_cnd);
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(vp, 0);
|
2003-08-05 00:26:51 +00:00
|
|
|
vput(nd.ni_dvp);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2000-07-11 22:07:57 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(lvfslocked);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
vrele(vp);
|
2000-07-11 22:07:57 +00:00
|
|
|
vn_finished_write(mp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
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-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
symlink(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct symlink_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
|
|
|
char *link;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
2002-09-01 20:37:28 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
return (kern_symlink(td, uap->path, uap->link, UIO_USERSPACE));
|
|
|
|
}
|
|
|
|
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct symlinkat_args {
|
|
|
|
char *path;
|
|
|
|
int fd;
|
|
|
|
char *path2;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
int
|
|
|
|
symlinkat(struct thread *td, struct symlinkat_args *uap)
|
|
|
|
{
|
|
|
|
|
|
|
|
return (kern_symlinkat(td, uap->path1, uap->fd, uap->path2,
|
|
|
|
UIO_USERSPACE));
|
|
|
|
}
|
|
|
|
|
2002-09-01 20:37:28 +00:00
|
|
|
int
|
|
|
|
kern_symlink(struct thread *td, char *path, char *link, enum uio_seg segflg)
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
return (kern_symlinkat(td, path, AT_FDCWD, link, segflg));
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_symlinkat(struct thread *td, char *path1, int fd, char *path2,
|
|
|
|
enum uio_seg segflg)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2000-07-11 22:07:57 +00:00
|
|
|
struct mount *mp;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct vattr vattr;
|
2002-09-01 20:37:28 +00:00
|
|
|
char *syspath;
|
1994-05-24 10:09:53 +00:00
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
2005-01-24 10:25:44 +00:00
|
|
|
int vfslocked;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2002-09-01 20:37:28 +00:00
|
|
|
if (segflg == UIO_SYSSPACE) {
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
syspath = path1;
|
2002-09-01 20:37:28 +00:00
|
|
|
} else {
|
2003-02-19 05:47:46 +00:00
|
|
|
syspath = uma_zalloc(namei_zone, M_WAITOK);
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
if ((error = copyinstr(path1, syspath, MAXPATHLEN, NULL)) != 0)
|
2002-09-01 20:37:28 +00:00
|
|
|
goto out;
|
|
|
|
}
|
2006-06-05 13:34:23 +00:00
|
|
|
AUDIT_ARG(text, syspath);
|
2000-07-11 22:07:57 +00:00
|
|
|
restart:
|
2000-01-10 00:08:53 +00:00
|
|
|
bwillwrite();
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
NDINIT_AT(&nd, CREATE, LOCKPARENT | SAVENAME | MPSAFE | AUDITVNODE1,
|
|
|
|
segflg, path2, fd, td);
|
1999-01-27 21:50:00 +00:00
|
|
|
if ((error = namei(&nd)) != 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
goto out;
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = NDHASGIANT(&nd);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (nd.ni_vp) {
|
1999-12-15 23:02:35 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
2003-08-05 00:26:51 +00:00
|
|
|
if (nd.ni_vp == nd.ni_dvp)
|
|
|
|
vrele(nd.ni_dvp);
|
|
|
|
else
|
|
|
|
vput(nd.ni_dvp);
|
2006-02-01 00:25:26 +00:00
|
|
|
vrele(nd.ni_vp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
1994-05-24 10:09:53 +00:00
|
|
|
error = EEXIST;
|
|
|
|
goto out;
|
|
|
|
}
|
2000-07-11 22:07:57 +00:00
|
|
|
if (vn_start_write(nd.ni_dvp, &mp, V_NOWAIT) != 0) {
|
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
|
|
|
vput(nd.ni_dvp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2000-07-11 22:07:57 +00:00
|
|
|
if ((error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH)) != 0)
|
2004-05-11 10:42:02 +00:00
|
|
|
goto out;
|
2000-07-11 22:07:57 +00:00
|
|
|
goto restart;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
VATTR_NULL(&vattr);
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_SLOCK(td->td_proc->p_fd);
|
2001-09-12 08:38:13 +00:00
|
|
|
vattr.va_mode = ACCESSPERMS &~ td->td_proc->p_fd->fd_cmask;
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_SUNLOCK(td->td_proc->p_fd);
|
2002-10-19 20:25:57 +00:00
|
|
|
#ifdef MAC
|
|
|
|
vattr.va_type = VLNK;
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_vnode_check_create(td->td_ucred, nd.ni_dvp, &nd.ni_cnd,
|
2002-10-19 20:25:57 +00:00
|
|
|
&vattr);
|
|
|
|
if (error)
|
|
|
|
goto out2;
|
|
|
|
#endif
|
2002-02-27 18:32:23 +00:00
|
|
|
VOP_LEASE(nd.ni_dvp, td, td->td_ucred, LEASE_WRITE);
|
2002-09-01 20:37:28 +00:00
|
|
|
error = VOP_SYMLINK(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr, syspath);
|
1999-11-13 20:58:17 +00:00
|
|
|
if (error == 0)
|
|
|
|
vput(nd.ni_vp);
|
2002-10-19 20:25:57 +00:00
|
|
|
#ifdef MAC
|
|
|
|
out2:
|
|
|
|
#endif
|
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
1998-05-07 04:58:58 +00:00
|
|
|
vput(nd.ni_dvp);
|
2000-07-11 22:07:57 +00:00
|
|
|
vn_finished_write(mp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
1994-05-24 10:09:53 +00:00
|
|
|
out:
|
2002-09-01 20:37:28 +00:00
|
|
|
if (segflg != UIO_SYSSPACE)
|
|
|
|
uma_zfree(namei_zone, syspath);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
1997-02-10 02:22:35 +00:00
|
|
|
/*
|
|
|
|
* Delete a whiteout from the filesystem.
|
|
|
|
*/
|
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
undelete(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct undelete_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
|
|
|
{
|
|
|
|
int error;
|
2000-07-11 22:07:57 +00:00
|
|
|
struct mount *mp;
|
1997-02-10 02:22:35 +00:00
|
|
|
struct nameidata nd;
|
2005-01-24 10:25:44 +00:00
|
|
|
int vfslocked;
|
1997-02-10 02:22:35 +00:00
|
|
|
|
2000-07-11 22:07:57 +00:00
|
|
|
restart:
|
2000-01-10 00:08:53 +00:00
|
|
|
bwillwrite();
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
NDINIT(&nd, DELETE, LOCKPARENT | DOWHITEOUT | MPSAFE | AUDITVNODE1,
|
|
|
|
UIO_USERSPACE, uap->path, td);
|
1997-02-10 02:22:35 +00:00
|
|
|
error = namei(&nd);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = NDHASGIANT(&nd);
|
1997-02-10 02:22:35 +00:00
|
|
|
|
|
|
|
if (nd.ni_vp != NULLVP || !(nd.ni_cnd.cn_flags & ISWHITEOUT)) {
|
1999-12-15 23:02:35 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
2003-08-05 00:26:51 +00:00
|
|
|
if (nd.ni_vp == nd.ni_dvp)
|
|
|
|
vrele(nd.ni_dvp);
|
|
|
|
else
|
|
|
|
vput(nd.ni_dvp);
|
2006-02-01 00:25:26 +00:00
|
|
|
if (nd.ni_vp)
|
|
|
|
vrele(nd.ni_vp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
1997-02-10 02:22:35 +00:00
|
|
|
return (EEXIST);
|
|
|
|
}
|
2000-07-11 22:07:57 +00:00
|
|
|
if (vn_start_write(nd.ni_dvp, &mp, V_NOWAIT) != 0) {
|
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
|
|
|
vput(nd.ni_dvp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2000-07-11 22:07:57 +00:00
|
|
|
if ((error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH)) != 0)
|
|
|
|
return (error);
|
|
|
|
goto restart;
|
|
|
|
}
|
2002-02-27 18:32:23 +00:00
|
|
|
VOP_LEASE(nd.ni_dvp, td, td->td_ucred, LEASE_WRITE);
|
1999-12-15 23:02:35 +00:00
|
|
|
error = VOP_WHITEOUT(nd.ni_dvp, &nd.ni_cnd, DELETE);
|
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
1997-02-10 02:22:35 +00:00
|
|
|
vput(nd.ni_dvp);
|
2000-07-11 22:07:57 +00:00
|
|
|
vn_finished_write(mp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
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-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
unlink(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
struct unlink_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
2002-09-01 20:37:28 +00:00
|
|
|
{
|
|
|
|
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
return (kern_unlink(td, uap->path, UIO_USERSPACE));
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct unlinkat_args {
|
|
|
|
int fd;
|
|
|
|
char *path;
|
|
|
|
int flag;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
int
|
|
|
|
unlinkat(struct thread *td, struct unlinkat_args *uap)
|
|
|
|
{
|
|
|
|
int flag = uap->flag;
|
|
|
|
int fd = uap->fd;
|
|
|
|
char *path = uap->path;
|
|
|
|
|
|
|
|
if (flag & ~AT_REMOVEDIR)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
if (flag & AT_REMOVEDIR)
|
|
|
|
return (kern_rmdirat(td, fd, path, UIO_USERSPACE));
|
|
|
|
else
|
|
|
|
return (kern_unlinkat(td, fd, path, UIO_USERSPACE));
|
2002-09-01 20:37:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_unlink(struct thread *td, char *path, enum uio_seg pathseg)
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
return (kern_unlinkat(td, AT_FDCWD, path, pathseg));
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_unlinkat(struct thread *td, int fd, char *path, enum uio_seg pathseg)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2000-07-11 22:07:57 +00:00
|
|
|
struct mount *mp;
|
|
|
|
struct vnode *vp;
|
1994-05-24 10:09:53 +00:00
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
2005-01-24 10:25:44 +00:00
|
|
|
int vfslocked;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2000-07-11 22:07:57 +00:00
|
|
|
restart:
|
2000-01-10 00:08:53 +00:00
|
|
|
bwillwrite();
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
NDINIT_AT(&nd, DELETE, LOCKPARENT | LOCKLEAF | MPSAFE | AUDITVNODE1,
|
|
|
|
pathseg, path, fd, td);
|
1999-01-27 21:50:00 +00:00
|
|
|
if ((error = namei(&nd)) != 0)
|
2006-01-22 19:37:02 +00:00
|
|
|
return (error == EINVAL ? EPERM : error);
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = NDHASGIANT(&nd);
|
1994-05-24 10:09:53 +00:00
|
|
|
vp = nd.ni_vp;
|
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
|
|
|
*/
|
2002-08-04 10:29:36 +00:00
|
|
|
if (vp->v_vflag & VV_ROOT)
|
1994-05-24 10:09:53 +00:00
|
|
|
error = EBUSY;
|
|
|
|
}
|
2002-08-21 03:55:35 +00:00
|
|
|
if (error == 0) {
|
|
|
|
if (vn_start_write(nd.ni_dvp, &mp, V_NOWAIT) != 0) {
|
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
2006-02-01 00:25:26 +00:00
|
|
|
vput(nd.ni_dvp);
|
2002-08-21 03:55:35 +00:00
|
|
|
if (vp == nd.ni_dvp)
|
|
|
|
vrele(vp);
|
|
|
|
else
|
|
|
|
vput(vp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2002-08-21 03:55:35 +00:00
|
|
|
if ((error = vn_start_write(NULL, &mp,
|
|
|
|
V_XSLEEP | PCATCH)) != 0)
|
|
|
|
return (error);
|
|
|
|
goto restart;
|
|
|
|
}
|
2002-10-19 20:25:57 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_vnode_check_unlink(td->td_ucred, nd.ni_dvp, vp,
|
2002-10-19 20:25:57 +00:00
|
|
|
&nd.ni_cnd);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
#endif
|
2002-02-27 18:32:23 +00:00
|
|
|
VOP_LEASE(nd.ni_dvp, td, td->td_ucred, LEASE_WRITE);
|
Make our v_usecount vnode reference count work identically to the
original BSD code. The association between the vnode and the vm_object
no longer includes reference counts. The major difference is that
vm_object's are no longer freed gratuitiously from the vnode, and so
once an object is created for the vnode, it will last as long as the
vnode does.
When a vnode object reference count is incremented, then the underlying
vnode reference count is incremented also. The two "objects" are now
more intimately related, and so the interactions are now much less
complex.
When vnodes are now normally placed onto the free queue with an object still
attached. The rundown of the object happens at vnode rundown time, and
happens with exactly the same filesystem semantics of the original VFS
code. There is absolutely no need for vnode_pager_uncache and other
travesties like that anymore.
A side-effect of these changes is that SMP locking should be much simpler,
the I/O copyin/copyout optimizations work, NFS should be more ponderable,
and further work on layered filesystems should be less frustrating, because
of the totally coherent management of the vnode objects and vnodes.
Please be careful with your system while running this code, but I would
greatly appreciate feedback as soon a reasonably possible.
1998-01-06 05:26:17 +00:00
|
|
|
error = VOP_REMOVE(nd.ni_dvp, vp, &nd.ni_cnd);
|
2002-10-19 20:25:57 +00:00
|
|
|
#ifdef MAC
|
|
|
|
out:
|
|
|
|
#endif
|
2002-08-21 03:55:35 +00:00
|
|
|
vn_finished_write(mp);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1999-12-15 23:02:35 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
2006-02-01 00:25:26 +00:00
|
|
|
vput(nd.ni_dvp);
|
2002-08-21 03:55:35 +00:00
|
|
|
if (vp == nd.ni_dvp)
|
|
|
|
vrele(vp);
|
|
|
|
else
|
|
|
|
vput(vp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
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
|
2001-09-12 08:38:13 +00:00
|
|
|
lseek(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct lseek_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
int fd;
|
|
|
|
int pad;
|
|
|
|
off_t offset;
|
|
|
|
int whence;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2002-02-27 18:32:23 +00:00
|
|
|
struct ucred *cred = td->td_ucred;
|
2002-01-14 00:13:45 +00:00
|
|
|
struct file *fp;
|
2001-08-21 21:20:42 +00:00
|
|
|
struct vnode *vp;
|
2002-01-13 11:58:06 +00:00
|
|
|
struct vattr vattr;
|
2001-08-21 21:20:42 +00:00
|
|
|
off_t offset;
|
|
|
|
int error, noneg;
|
2005-01-24 10:25:44 +00:00
|
|
|
int vfslocked;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2002-01-14 00:13:45 +00:00
|
|
|
if ((error = fget(td, uap->fd, &fp)) != 0)
|
|
|
|
return (error);
|
2003-06-18 19:53:59 +00:00
|
|
|
if (!(fp->f_ops->fo_flags & DFLAG_SEEKABLE)) {
|
2002-01-13 11:58:06 +00:00
|
|
|
fdrop(fp, td);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (ESPIPE);
|
2002-01-13 11:58:06 +00:00
|
|
|
}
|
2003-06-22 08:41:43 +00:00
|
|
|
vp = fp->f_vnode;
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = VFS_LOCK_GIANT(vp->v_mount);
|
2001-08-21 21:20:42 +00:00
|
|
|
noneg = (vp->v_type != VCHR);
|
2002-12-14 01:56:26 +00:00
|
|
|
offset = uap->offset;
|
|
|
|
switch (uap->whence) {
|
1994-05-24 10:09:53 +00:00
|
|
|
case L_INCR:
|
2001-08-21 21:20:42 +00:00
|
|
|
if (noneg &&
|
2001-08-29 18:35:53 +00:00
|
|
|
(fp->f_offset < 0 ||
|
2003-01-06 13:19:05 +00:00
|
|
|
(offset > 0 && fp->f_offset > OFF_MAX - offset))) {
|
|
|
|
error = EOVERFLOW;
|
|
|
|
break;
|
|
|
|
}
|
2001-08-21 21:20:42 +00:00
|
|
|
offset += fp->f_offset;
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
case L_XTND:
|
2008-01-10 01:10:58 +00:00
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
|
2008-08-28 15:23:18 +00:00
|
|
|
error = VOP_GETATTR(vp, &vattr, cred);
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(vp, 0);
|
1994-10-02 17:35:40 +00:00
|
|
|
if (error)
|
2003-01-06 13:19:05 +00:00
|
|
|
break;
|
2001-08-21 21:20:42 +00:00
|
|
|
if (noneg &&
|
2001-08-29 18:35:53 +00:00
|
|
|
(vattr.va_size > OFF_MAX ||
|
2003-01-06 13:19:05 +00:00
|
|
|
(offset > 0 && vattr.va_size > OFF_MAX - offset))) {
|
|
|
|
error = EOVERFLOW;
|
|
|
|
break;
|
|
|
|
}
|
2001-08-21 21:20:42 +00:00
|
|
|
offset += vattr.va_size;
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
case L_SET:
|
|
|
|
break;
|
2007-04-05 21:10:53 +00:00
|
|
|
case SEEK_DATA:
|
|
|
|
error = fo_ioctl(fp, FIOSEEKDATA, &offset, cred, td);
|
|
|
|
break;
|
|
|
|
case SEEK_HOLE:
|
|
|
|
error = fo_ioctl(fp, FIOSEEKHOLE, &offset, cred, td);
|
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
default:
|
2003-01-06 13:19:05 +00:00
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
if (error == 0 && noneg && offset < 0)
|
|
|
|
error = EINVAL;
|
2005-01-24 10:25:44 +00:00
|
|
|
if (error != 0)
|
|
|
|
goto drop;
|
2001-08-21 21:20:42 +00:00
|
|
|
fp->f_offset = offset;
|
2001-09-12 08:38:13 +00:00
|
|
|
*(off_t *)(td->td_retval) = fp->f_offset;
|
2005-01-24 10:25:44 +00:00
|
|
|
drop:
|
2002-01-13 11:58:06 +00:00
|
|
|
fdrop(fp, td);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
|
|
|
return (error);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
2004-06-11 11:16:26 +00:00
|
|
|
#if defined(COMPAT_43)
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* 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
|
2001-09-12 08:38:13 +00:00
|
|
|
olseek(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct olseek_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
int fd;
|
|
|
|
long offset;
|
|
|
|
int whence;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1997-02-10 02:22:35 +00:00
|
|
|
struct lseek_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
int fd;
|
|
|
|
int pad;
|
|
|
|
off_t offset;
|
|
|
|
int whence;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ nuap;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2002-12-14 01:56:26 +00:00
|
|
|
nuap.fd = uap->fd;
|
|
|
|
nuap.offset = uap->offset;
|
|
|
|
nuap.whence = uap->whence;
|
2007-07-04 22:57:21 +00:00
|
|
|
return (lseek(td, &nuap));
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
#endif /* COMPAT_43 */
|
|
|
|
|
2007-07-04 22:57:21 +00:00
|
|
|
/* Version with the 'pad' argument */
|
|
|
|
int
|
|
|
|
freebsd6_lseek(td, uap)
|
|
|
|
struct thread *td;
|
|
|
|
register struct freebsd6_lseek_args *uap;
|
|
|
|
{
|
|
|
|
struct lseek_args ouap;
|
|
|
|
|
|
|
|
ouap.fd = uap->fd;
|
|
|
|
ouap.offset = uap->offset;
|
|
|
|
ouap.whence = uap->whence;
|
|
|
|
return (lseek(td, &ouap));
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
2001-09-21 21:33:22 +00:00
|
|
|
* Check access permissions using passed credentials.
|
|
|
|
*/
|
|
|
|
static int
|
2001-09-22 03:07:41 +00:00
|
|
|
vn_access(vp, user_flags, cred, td)
|
2001-09-21 21:33:22 +00:00
|
|
|
struct vnode *vp;
|
|
|
|
int user_flags;
|
|
|
|
struct ucred *cred;
|
|
|
|
struct thread *td;
|
|
|
|
{
|
|
|
|
int error, flags;
|
|
|
|
|
|
|
|
/* Flags == 0 means only check for existence. */
|
|
|
|
error = 0;
|
|
|
|
if (user_flags) {
|
|
|
|
flags = 0;
|
|
|
|
if (user_flags & R_OK)
|
|
|
|
flags |= VREAD;
|
|
|
|
if (user_flags & W_OK)
|
|
|
|
flags |= VWRITE;
|
|
|
|
if (user_flags & X_OK)
|
|
|
|
flags |= VEXEC;
|
Introduce support for Mandatory Access Control and extensible
kernel access control.
Invoke appropriate MAC entry points to authorize the following
operations:
truncate on open() (write)
access() (access)
readlink() (readlink)
chflags(), lchflags(), fchflags() (setflag)
chmod(), fchmod(), lchmod() (setmode)
chown(), fchown(), lchown() (setowner)
utimes(), lutimes(), futimes() (setutimes)
truncate(), ftrunfcate() (write)
revoke() (revoke)
fhopen() (open)
truncate on fhopen() (write)
extattr_set_fd, extattr_set_file() (setextattr)
extattr_get_fd, extattr_get_file() (getextattr)
extattr_delete_fd(), extattr_delete_file() (setextattr)
These entry points permit MAC policies to enforce a variety of
protections on vnodes. More vnode checks to come, especially in
non-native ABIs.
Obtained from: TrustedBSD Project
Sponsored by: DARPA, NAI Labs
2002-08-01 15:37:12 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_vnode_check_access(cred, vp, flags);
|
Introduce support for Mandatory Access Control and extensible
kernel access control.
Invoke appropriate MAC entry points to authorize the following
operations:
truncate on open() (write)
access() (access)
readlink() (readlink)
chflags(), lchflags(), fchflags() (setflag)
chmod(), fchmod(), lchmod() (setmode)
chown(), fchown(), lchown() (setowner)
utimes(), lutimes(), futimes() (setutimes)
truncate(), ftrunfcate() (write)
revoke() (revoke)
fhopen() (open)
truncate on fhopen() (write)
extattr_set_fd, extattr_set_file() (setextattr)
extattr_get_fd, extattr_get_file() (getextattr)
extattr_delete_fd(), extattr_delete_file() (setextattr)
These entry points permit MAC policies to enforce a variety of
protections on vnodes. More vnode checks to come, especially in
non-native ABIs.
Obtained from: TrustedBSD Project
Sponsored by: DARPA, NAI Labs
2002-08-01 15:37:12 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
#endif
|
2001-09-21 21:33:22 +00:00
|
|
|
if ((flags & VWRITE) == 0 || (error = vn_writechk(vp)) == 0)
|
|
|
|
error = VOP_ACCESS(vp, flags, cred, td);
|
|
|
|
}
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check access permissions using "real" credentials.
|
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 access_args {
|
|
|
|
char *path;
|
|
|
|
int flags;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
access(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct access_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
|
|
|
int flags;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
2002-09-01 20:37:28 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
return (kern_access(td, uap->path, UIO_USERSPACE, uap->flags));
|
|
|
|
}
|
|
|
|
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct faccessat_args {
|
|
|
|
int dirfd;
|
|
|
|
char *path;
|
|
|
|
int mode;
|
|
|
|
int flag;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
int faccessat(struct thread *td, struct faccessat_args *uap)
|
|
|
|
{
|
|
|
|
|
|
|
|
if (uap->flag & ~AT_EACCESS)
|
|
|
|
return (EINVAL);
|
|
|
|
return (kern_accessat(td, uap->fd, uap->path, UIO_USERSPACE, uap->flag,
|
|
|
|
uap->mode));
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_access(struct thread *td, char *path, enum uio_seg pathseg, int mode)
|
|
|
|
{
|
|
|
|
|
|
|
|
return (kern_accessat(td, AT_FDCWD, path, pathseg, 0, mode));
|
|
|
|
}
|
|
|
|
|
2002-09-01 20:37:28 +00:00
|
|
|
int
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
kern_accessat(struct thread *td, int fd, char *path, enum uio_seg pathseg,
|
|
|
|
int flags, int mode)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2000-09-02 12:31:55 +00:00
|
|
|
struct ucred *cred, *tmpcred;
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
struct vnode *vp;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct nameidata nd;
|
2005-01-24 10:25:44 +00:00
|
|
|
int vfslocked;
|
|
|
|
int error;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2000-09-02 12:31:55 +00:00
|
|
|
/*
|
|
|
|
* Create and modify a temporary credential instead of one that
|
|
|
|
* is potentially shared. This could also mess up socket
|
|
|
|
* buffer accounting which can run in an interrupt context.
|
|
|
|
*/
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
if (!(flags & AT_EACCESS)) {
|
|
|
|
cred = td->td_ucred;
|
|
|
|
tmpcred = crdup(cred);
|
|
|
|
tmpcred->cr_uid = cred->cr_ruid;
|
|
|
|
tmpcred->cr_groups[0] = cred->cr_rgid;
|
|
|
|
td->td_ucred = tmpcred;
|
|
|
|
} else
|
|
|
|
cred = tmpcred = td->td_ucred;
|
|
|
|
NDINIT_AT(&nd, LOOKUP, FOLLOW | LOCKLEAF | MPSAFE | AUDITVNODE1,
|
|
|
|
pathseg, path, fd, td);
|
1999-01-27 21:50:00 +00:00
|
|
|
if ((error = namei(&nd)) != 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
goto out1;
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = NDHASGIANT(&nd);
|
1994-05-24 10:09:53 +00:00
|
|
|
vp = nd.ni_vp;
|
|
|
|
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
error = vn_access(vp, mode, tmpcred, td);
|
1999-12-15 23:02:35 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
1994-05-24 10:09:53 +00:00
|
|
|
vput(vp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
1994-05-24 10:09:53 +00:00
|
|
|
out1:
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
if (!(flags & AT_EACCESS)) {
|
|
|
|
td->td_ucred = cred;
|
|
|
|
crfree(tmpcred);
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2001-09-21 21:33:22 +00:00
|
|
|
/*
|
|
|
|
* Check access permissions using "effective" credentials.
|
|
|
|
*/
|
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct eaccess_args {
|
|
|
|
char *path;
|
|
|
|
int flags;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
int
|
|
|
|
eaccess(td, uap)
|
|
|
|
struct thread *td;
|
|
|
|
register struct eaccess_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
|
|
|
int flags;
|
2001-09-21 21:33:22 +00:00
|
|
|
} */ *uap;
|
2006-02-06 22:00:53 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
return (kern_eaccess(td, uap->path, UIO_USERSPACE, uap->flags));
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_eaccess(struct thread *td, char *path, enum uio_seg pathseg, int flags)
|
2001-09-21 21:33:22 +00:00
|
|
|
{
|
|
|
|
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
return (kern_accessat(td, AT_FDCWD, path, pathseg, AT_EACCESS, flags));
|
2001-09-21 21:33:22 +00:00
|
|
|
}
|
|
|
|
|
2004-06-11 11:16:26 +00:00
|
|
|
#if defined(COMPAT_43)
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* 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-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
ostat(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct ostat_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
|
|
|
struct ostat *ub;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
struct stat sb;
|
|
|
|
struct ostat osb;
|
|
|
|
int error;
|
|
|
|
|
2005-02-07 18:44:55 +00:00
|
|
|
error = kern_stat(td, uap->path, UIO_USERSPACE, &sb);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
cvtstat(&sb, &osb);
|
2002-12-14 01:56:26 +00:00
|
|
|
error = copyout(&osb, 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-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
olstat(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct olstat_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
|
|
|
struct ostat *ub;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1997-03-31 12:02:53 +00:00
|
|
|
struct stat sb;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct ostat osb;
|
|
|
|
int error;
|
|
|
|
|
2005-02-07 18:44:55 +00:00
|
|
|
error = kern_lstat(td, uap->path, UIO_USERSPACE, &sb);
|
1997-03-31 12:02:53 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
1994-05-24 10:09:53 +00:00
|
|
|
cvtstat(&sb, &osb);
|
2002-12-14 01:56:26 +00:00
|
|
|
error = copyout(&osb, 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;
|
|
|
|
}
|
2004-06-11 11:16:26 +00:00
|
|
|
#endif /* COMPAT_43 */
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
stat(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct stat_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
|
|
|
struct stat *ub;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
struct stat sb;
|
|
|
|
int error;
|
2005-02-07 18:44:55 +00:00
|
|
|
|
|
|
|
error = kern_stat(td, uap->path, UIO_USERSPACE, &sb);
|
|
|
|
if (error == 0)
|
|
|
|
error = copyout(&sb, uap->ub, sizeof (sb));
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct fstatat_args {
|
|
|
|
int fd;
|
|
|
|
char *path;
|
|
|
|
struct stat *buf;
|
|
|
|
int flag;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
int
|
|
|
|
fstatat(struct thread *td, struct fstatat_args *uap)
|
|
|
|
{
|
|
|
|
struct stat sb;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = kern_statat(td, uap->flag, uap->fd, uap->path,
|
|
|
|
UIO_USERSPACE, &sb);
|
|
|
|
if (error == 0)
|
|
|
|
error = copyout(&sb, uap->buf, sizeof (sb));
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2005-02-07 18:44:55 +00:00
|
|
|
int
|
|
|
|
kern_stat(struct thread *td, char *path, enum uio_seg pathseg, struct stat *sbp)
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
return (kern_statat(td, 0, AT_FDCWD, path, pathseg, sbp));
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_statat(struct thread *td, int flag, int fd, char *path,
|
|
|
|
enum uio_seg pathseg, struct stat *sbp)
|
2005-02-07 18:44:55 +00:00
|
|
|
{
|
1994-05-24 10:09:53 +00:00
|
|
|
struct nameidata nd;
|
2005-02-07 18:44:55 +00:00
|
|
|
struct stat sb;
|
|
|
|
int error, vfslocked;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
if (flag & ~AT_SYMLINK_NOFOLLOW)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
NDINIT_AT(&nd, LOOKUP, ((flag & AT_SYMLINK_NOFOLLOW) ? NOFOLLOW :
|
|
|
|
FOLLOW) | LOCKSHARED | LOCKLEAF | AUDITVNODE1 | MPSAFE, pathseg,
|
|
|
|
path, fd, td);
|
|
|
|
|
1999-01-27 21:50:00 +00:00
|
|
|
if ((error = namei(&nd)) != 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = NDHASGIANT(&nd);
|
Make similar changes to fo_stat() and fo_poll() as made earlier to
fo_read() and fo_write(): explicitly use the cred argument to fo_poll()
as "active_cred" using the passed file descriptor's f_cred reference
to provide access to the file credential. Add an active_cred
argument to fo_stat() so that implementers have access to the active
credential as well as the file credential. Generally modify callers
of fo_stat() to pass in td->td_ucred rather than fp->f_cred, which
was redundantly provided via the fp argument. This set of modifications
also permits threads to perform these operations on behalf of another
thread without modifying their credential.
Trickle this change down into fo_stat/poll() implementations:
- badfo_poll(), badfo_stat(): modify/add arguments.
- kqueue_poll(), kqueue_stat(): modify arguments.
- pipe_poll(), pipe_stat(): modify/add arguments, pass active_cred to
MAC checks rather than td->td_ucred.
- soo_poll(), soo_stat(): modify/add arguments, pass fp->f_cred rather
than cred to pru_sopoll() to maintain current semantics.
- sopoll(): moidfy arguments.
- vn_poll(), vn_statfile(): modify/add arguments, pass new arguments
to vn_stat(). Pass active_cred to MAC and fp->f_cred to VOP_POLL()
to maintian current semantics.
- vn_close(): rename cred to file_cred to reflect reality while I'm here.
- vn_stat(): Add active_cred and file_cred arguments to vn_stat()
and consumers so that this distinction is maintained at the VFS
as well as 'struct file' layer. Pass active_cred instead of
td->td_ucred to MAC and to VOP_GETATTR() to maintain current semantics.
- fifofs: modify the creation of a "filetemp" so that the file
credential is properly initialized and can be used in the socket
code if desired. Pass ap->a_td->td_ucred as the active
credential to soo_poll(). If we teach the vnop interface about
the distinction between file and active credentials, we would use
the active credential here.
Note that current inconsistent passing of active_cred vs. file_cred to
VOP's is maintained. It's not clear why GETATTR would be authorized
using active_cred while POLL would be authorized using file_cred at
the file system level.
Obtained from: TrustedBSD Project
Sponsored by: DARPA, NAI Labs
2002-08-16 12:52:03 +00:00
|
|
|
error = vn_stat(nd.ni_vp, &sb, td->td_ucred, NOCRED, td);
|
1999-12-15 23:02:35 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
1994-05-24 10:09:53 +00:00
|
|
|
vput(nd.ni_vp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2006-03-31 03:54:20 +00:00
|
|
|
if (mtx_owned(&Giant))
|
|
|
|
printf("stat(%d): %s\n", vfslocked, path);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
2005-02-07 18:44:55 +00:00
|
|
|
*sbp = sb;
|
2008-02-23 01:01:49 +00:00
|
|
|
#ifdef KTRACE
|
|
|
|
if (KTRPOINT(td, KTR_STRUCT))
|
|
|
|
ktrstat(&sb);
|
|
|
|
#endif
|
2005-02-07 18:44:55 +00:00
|
|
|
return (0);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
lstat(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct lstat_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
|
|
|
struct stat *ub;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2005-02-07 18:44:55 +00:00
|
|
|
struct stat sb;
|
1994-05-24 10:09:53 +00:00
|
|
|
int error;
|
2005-02-07 18:44:55 +00:00
|
|
|
|
|
|
|
error = kern_lstat(td, uap->path, UIO_USERSPACE, &sb);
|
|
|
|
if (error == 0)
|
|
|
|
error = copyout(&sb, uap->ub, sizeof (sb));
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_lstat(struct thread *td, char *path, enum uio_seg pathseg, struct stat *sbp)
|
|
|
|
{
|
1994-05-24 10:09:53 +00:00
|
|
|
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
return (kern_statat(td, AT_SYMLINK_NOFOLLOW, AT_FDCWD, path, pathseg,
|
|
|
|
sbp));
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
2000-09-14 19:13:59 +00:00
|
|
|
/*
|
2005-02-07 18:44:55 +00:00
|
|
|
* Implementation of the NetBSD [l]stat() functions.
|
2000-09-14 19:13:59 +00:00
|
|
|
*/
|
1998-05-11 03:55:28 +00:00
|
|
|
void
|
|
|
|
cvtnstat(sb, nsb)
|
|
|
|
struct stat *sb;
|
|
|
|
struct nstat *nsb;
|
|
|
|
{
|
2002-06-24 07:14:44 +00:00
|
|
|
bzero(nsb, sizeof *nsb);
|
1998-05-11 03:55:28 +00:00
|
|
|
nsb->st_dev = sb->st_dev;
|
|
|
|
nsb->st_ino = sb->st_ino;
|
|
|
|
nsb->st_mode = sb->st_mode;
|
|
|
|
nsb->st_nlink = sb->st_nlink;
|
|
|
|
nsb->st_uid = sb->st_uid;
|
|
|
|
nsb->st_gid = sb->st_gid;
|
|
|
|
nsb->st_rdev = sb->st_rdev;
|
|
|
|
nsb->st_atimespec = sb->st_atimespec;
|
|
|
|
nsb->st_mtimespec = sb->st_mtimespec;
|
|
|
|
nsb->st_ctimespec = sb->st_ctimespec;
|
|
|
|
nsb->st_size = sb->st_size;
|
|
|
|
nsb->st_blocks = sb->st_blocks;
|
|
|
|
nsb->st_blksize = sb->st_blksize;
|
|
|
|
nsb->st_flags = sb->st_flags;
|
|
|
|
nsb->st_gen = sb->st_gen;
|
2002-07-16 22:36:00 +00:00
|
|
|
nsb->st_birthtimespec = sb->st_birthtimespec;
|
1998-05-11 03:55:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct nstat_args {
|
|
|
|
char *path;
|
|
|
|
struct nstat *ub;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
nstat(td, uap)
|
|
|
|
struct thread *td;
|
1998-05-11 03:55:28 +00:00
|
|
|
register struct nstat_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
|
|
|
struct nstat *ub;
|
1998-05-11 03:55:28 +00:00
|
|
|
} */ *uap;
|
|
|
|
{
|
|
|
|
struct stat sb;
|
|
|
|
struct nstat nsb;
|
|
|
|
int error;
|
|
|
|
|
2005-02-07 18:44:55 +00:00
|
|
|
error = kern_stat(td, uap->path, UIO_USERSPACE, &sb);
|
1998-05-11 03:55:28 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
cvtnstat(&sb, &nsb);
|
2002-12-14 01:56:26 +00:00
|
|
|
error = copyout(&nsb, uap->ub, sizeof (nsb));
|
1998-05-11 03:55:28 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2000-09-14 19:13:59 +00:00
|
|
|
* NetBSD lstat. Get file status; this version does not follow links.
|
1998-05-11 03:55:28 +00:00
|
|
|
*/
|
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct lstat_args {
|
|
|
|
char *path;
|
|
|
|
struct stat *ub;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
nlstat(td, uap)
|
|
|
|
struct thread *td;
|
1998-05-11 03:55:28 +00:00
|
|
|
register struct nlstat_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
|
|
|
struct nstat *ub;
|
1998-05-11 03:55:28 +00:00
|
|
|
} */ *uap;
|
|
|
|
{
|
|
|
|
struct stat sb;
|
|
|
|
struct nstat nsb;
|
2005-02-07 18:44:55 +00:00
|
|
|
int error;
|
1998-05-11 03:55:28 +00:00
|
|
|
|
2005-02-07 18:44:55 +00:00
|
|
|
error = kern_lstat(td, uap->path, UIO_USERSPACE, &sb);
|
1998-05-11 03:55:28 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
cvtnstat(&sb, &nsb);
|
2002-12-14 01:56:26 +00:00
|
|
|
error = copyout(&nsb, uap->ub, sizeof (nsb));
|
1998-05-11 03:55:28 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* 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-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
pathconf(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct pathconf_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
|
|
|
int name;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2005-02-07 21:46:43 +00:00
|
|
|
|
|
|
|
return (kern_pathconf(td, uap->path, UIO_USERSPACE, uap->name));
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_pathconf(struct thread *td, char *path, enum uio_seg pathseg, int name)
|
|
|
|
{
|
1994-05-24 10:09:53 +00:00
|
|
|
struct nameidata nd;
|
2005-02-07 21:46:43 +00:00
|
|
|
int error, vfslocked;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | MPSAFE | AUDITVNODE1,
|
|
|
|
pathseg, path, td);
|
1999-01-27 21:50:00 +00:00
|
|
|
if ((error = namei(&nd)) != 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = NDHASGIANT(&nd);
|
1999-12-15 23:02:35 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
2002-10-27 18:07:41 +00:00
|
|
|
|
|
|
|
/* If asynchronous I/O is available, it works for all files. */
|
2005-02-07 21:46:43 +00:00
|
|
|
if (name == _PC_ASYNC_IO)
|
2002-10-27 18:07:41 +00:00
|
|
|
td->td_retval[0] = async_io_version;
|
|
|
|
else
|
2005-02-07 21:46:43 +00:00
|
|
|
error = VOP_PATHCONF(nd.ni_vp, name, td->td_retval);
|
1994-05-24 10:09:53 +00:00
|
|
|
vput(nd.ni_vp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
1994-05-24 10:09:53 +00:00
|
|
|
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;
|
2008-02-12 20:09:04 +00:00
|
|
|
size_t count;
|
1994-05-24 10:09:53 +00:00
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
readlink(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct readlink_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
|
|
|
char *buf;
|
2008-02-12 20:09:04 +00:00
|
|
|
size_t count;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2002-09-01 20:37:28 +00:00
|
|
|
|
|
|
|
return (kern_readlink(td, uap->path, UIO_USERSPACE, uap->buf,
|
|
|
|
UIO_USERSPACE, uap->count));
|
|
|
|
}
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct readlinkat_args {
|
|
|
|
int fd;
|
|
|
|
char *path;
|
|
|
|
char *buf;
|
|
|
|
size_t bufsize;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
int
|
|
|
|
readlinkat(struct thread *td, struct readlinkat_args *uap)
|
|
|
|
{
|
|
|
|
|
|
|
|
return (kern_readlinkat(td, uap->fd, uap->path, UIO_USERSPACE,
|
|
|
|
uap->buf, UIO_USERSPACE, uap->bufsize));
|
|
|
|
}
|
2002-09-01 20:37:28 +00:00
|
|
|
|
|
|
|
int
|
|
|
|
kern_readlink(struct thread *td, char *path, enum uio_seg pathseg, char *buf,
|
2008-02-12 20:09:04 +00:00
|
|
|
enum uio_seg bufseg, size_t count)
|
2002-09-01 20:37:28 +00:00
|
|
|
{
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
|
|
|
|
return (kern_readlinkat(td, AT_FDCWD, path, pathseg, buf, bufseg,
|
|
|
|
count));
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_readlinkat(struct thread *td, int fd, char *path, enum uio_seg pathseg,
|
|
|
|
char *buf, enum uio_seg bufseg, size_t count)
|
|
|
|
{
|
|
|
|
struct vnode *vp;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct iovec aiov;
|
|
|
|
struct uio auio;
|
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
2005-01-24 10:25:44 +00:00
|
|
|
int vfslocked;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
NDINIT_AT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | MPSAFE | AUDITVNODE1,
|
|
|
|
pathseg, path, fd, td);
|
|
|
|
|
1999-01-27 21:50:00 +00:00
|
|
|
if ((error = namei(&nd)) != 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
1999-12-15 23:02:35 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = NDHASGIANT(&nd);
|
1994-05-24 10:09:53 +00:00
|
|
|
vp = nd.ni_vp;
|
Introduce support for Mandatory Access Control and extensible
kernel access control.
Invoke appropriate MAC entry points to authorize the following
operations:
truncate on open() (write)
access() (access)
readlink() (readlink)
chflags(), lchflags(), fchflags() (setflag)
chmod(), fchmod(), lchmod() (setmode)
chown(), fchown(), lchown() (setowner)
utimes(), lutimes(), futimes() (setutimes)
truncate(), ftrunfcate() (write)
revoke() (revoke)
fhopen() (open)
truncate on fhopen() (write)
extattr_set_fd, extattr_set_file() (setextattr)
extattr_get_fd, extattr_get_file() (getextattr)
extattr_delete_fd(), extattr_delete_file() (setextattr)
These entry points permit MAC policies to enforce a variety of
protections on vnodes. More vnode checks to come, especially in
non-native ABIs.
Obtained from: TrustedBSD Project
Sponsored by: DARPA, NAI Labs
2002-08-01 15:37:12 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_vnode_check_readlink(td->td_ucred, vp);
|
Introduce support for Mandatory Access Control and extensible
kernel access control.
Invoke appropriate MAC entry points to authorize the following
operations:
truncate on open() (write)
access() (access)
readlink() (readlink)
chflags(), lchflags(), fchflags() (setflag)
chmod(), fchmod(), lchmod() (setmode)
chown(), fchown(), lchown() (setowner)
utimes(), lutimes(), futimes() (setutimes)
truncate(), ftrunfcate() (write)
revoke() (revoke)
fhopen() (open)
truncate on fhopen() (write)
extattr_set_fd, extattr_set_file() (setextattr)
extattr_get_fd, extattr_get_file() (getextattr)
extattr_delete_fd(), extattr_delete_file() (setextattr)
These entry points permit MAC policies to enforce a variety of
protections on vnodes. More vnode checks to come, especially in
non-native ABIs.
Obtained from: TrustedBSD Project
Sponsored by: DARPA, NAI Labs
2002-08-01 15:37:12 +00:00
|
|
|
if (error) {
|
|
|
|
vput(vp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
Introduce support for Mandatory Access Control and extensible
kernel access control.
Invoke appropriate MAC entry points to authorize the following
operations:
truncate on open() (write)
access() (access)
readlink() (readlink)
chflags(), lchflags(), fchflags() (setflag)
chmod(), fchmod(), lchmod() (setmode)
chown(), fchown(), lchown() (setowner)
utimes(), lutimes(), futimes() (setutimes)
truncate(), ftrunfcate() (write)
revoke() (revoke)
fhopen() (open)
truncate on fhopen() (write)
extattr_set_fd, extattr_set_file() (setextattr)
extattr_get_fd, extattr_get_file() (getextattr)
extattr_delete_fd(), extattr_delete_file() (setextattr)
These entry points permit MAC policies to enforce a variety of
protections on vnodes. More vnode checks to come, especially in
non-native ABIs.
Obtained from: TrustedBSD Project
Sponsored by: DARPA, NAI Labs
2002-08-01 15:37:12 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
if (vp->v_type != VLNK)
|
|
|
|
error = EINVAL;
|
|
|
|
else {
|
2002-09-01 20:37:28 +00:00
|
|
|
aiov.iov_base = buf;
|
|
|
|
aiov.iov_len = 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;
|
2002-09-01 20:37:28 +00:00
|
|
|
auio.uio_segflg = bufseg;
|
2001-09-12 08:38:13 +00:00
|
|
|
auio.uio_td = td;
|
2002-09-01 20:37:28 +00:00
|
|
|
auio.uio_resid = count;
|
2002-02-27 18:32:23 +00:00
|
|
|
error = VOP_READLINK(vp, &auio, td->td_ucred);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
vput(vp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2002-09-01 20:37:28 +00:00
|
|
|
td->td_retval[0] = count - auio.uio_resid;
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2000-09-14 19:13:59 +00:00
|
|
|
/*
|
|
|
|
* Common implementation code for chflags() and fchflags().
|
|
|
|
*/
|
1998-05-11 03:55:28 +00:00
|
|
|
static int
|
2001-09-12 08:38:13 +00:00
|
|
|
setfflags(td, vp, flags)
|
|
|
|
struct thread *td;
|
1998-05-11 03:55:28 +00:00
|
|
|
struct vnode *vp;
|
|
|
|
int flags;
|
|
|
|
{
|
|
|
|
int error;
|
2000-07-11 22:07:57 +00:00
|
|
|
struct mount *mp;
|
1998-05-11 03:55:28 +00:00
|
|
|
struct vattr vattr;
|
|
|
|
|
1999-08-02 21:34:46 +00:00
|
|
|
/*
|
1999-08-04 04:52:18 +00:00
|
|
|
* Prevent non-root users from setting flags on devices. When
|
|
|
|
* a device is reused, users can retain ownership of the device
|
|
|
|
* if they are allowed to set flags and programs assume that
|
|
|
|
* chown can't fail when done as root.
|
1999-08-02 21:34:46 +00:00
|
|
|
*/
|
2001-10-01 20:01:07 +00:00
|
|
|
if (vp->v_type == VCHR || vp->v_type == VBLK) {
|
2007-06-12 00:12:01 +00:00
|
|
|
error = priv_check(td, PRIV_VFS_CHFLAGS_DEV);
|
2001-10-01 20:01:07 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
}
|
1999-08-03 17:07:04 +00:00
|
|
|
|
2000-07-11 22:07:57 +00:00
|
|
|
if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0)
|
|
|
|
return (error);
|
2002-02-27 18:32:23 +00:00
|
|
|
VOP_LEASE(vp, td, td->td_ucred, LEASE_WRITE);
|
2008-01-10 01:10:58 +00:00
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
|
2003-03-05 23:15:23 +00:00
|
|
|
VATTR_NULL(&vattr);
|
|
|
|
vattr.va_flags = flags;
|
Introduce support for Mandatory Access Control and extensible
kernel access control.
Invoke appropriate MAC entry points to authorize the following
operations:
truncate on open() (write)
access() (access)
readlink() (readlink)
chflags(), lchflags(), fchflags() (setflag)
chmod(), fchmod(), lchmod() (setmode)
chown(), fchown(), lchown() (setowner)
utimes(), lutimes(), futimes() (setutimes)
truncate(), ftrunfcate() (write)
revoke() (revoke)
fhopen() (open)
truncate on fhopen() (write)
extattr_set_fd, extattr_set_file() (setextattr)
extattr_get_fd, extattr_get_file() (getextattr)
extattr_delete_fd(), extattr_delete_file() (setextattr)
These entry points permit MAC policies to enforce a variety of
protections on vnodes. More vnode checks to come, especially in
non-native ABIs.
Obtained from: TrustedBSD Project
Sponsored by: DARPA, NAI Labs
2002-08-01 15:37:12 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_vnode_check_setflags(td->td_ucred, vp, vattr.va_flags);
|
2003-03-05 23:15:23 +00:00
|
|
|
if (error == 0)
|
Introduce support for Mandatory Access Control and extensible
kernel access control.
Invoke appropriate MAC entry points to authorize the following
operations:
truncate on open() (write)
access() (access)
readlink() (readlink)
chflags(), lchflags(), fchflags() (setflag)
chmod(), fchmod(), lchmod() (setmode)
chown(), fchown(), lchown() (setowner)
utimes(), lutimes(), futimes() (setutimes)
truncate(), ftrunfcate() (write)
revoke() (revoke)
fhopen() (open)
truncate on fhopen() (write)
extattr_set_fd, extattr_set_file() (setextattr)
extattr_get_fd, extattr_get_file() (getextattr)
extattr_delete_fd(), extattr_delete_file() (setextattr)
These entry points permit MAC policies to enforce a variety of
protections on vnodes. More vnode checks to come, especially in
non-native ABIs.
Obtained from: TrustedBSD Project
Sponsored by: DARPA, NAI Labs
2002-08-01 15:37:12 +00:00
|
|
|
#endif
|
2008-08-28 15:23:18 +00:00
|
|
|
error = VOP_SETATTR(vp, &vattr, td->td_ucred);
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(vp, 0);
|
2000-07-11 22:07:57 +00:00
|
|
|
vn_finished_write(mp);
|
1999-08-04 04:52:18 +00:00
|
|
|
return (error);
|
1998-05-11 03:55:28 +00:00
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* 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-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
chflags(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct chflags_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
|
|
|
int flags;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
2005-01-24 10:25:44 +00:00
|
|
|
int vfslocked;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
AUDIT_ARG(fflags, uap->flags);
|
|
|
|
NDINIT(&nd, LOOKUP, FOLLOW | MPSAFE | AUDITVNODE1, UIO_USERSPACE,
|
|
|
|
uap->path, td);
|
1999-01-27 21:50:00 +00:00
|
|
|
if ((error = namei(&nd)) != 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
1999-12-15 23:02:35 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = NDHASGIANT(&nd);
|
2002-12-14 01:56:26 +00:00
|
|
|
error = setfflags(td, nd.ni_vp, uap->flags);
|
1998-05-11 03:55:28 +00:00
|
|
|
vrele(nd.ni_vp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2004-01-11 19:52:10 +00:00
|
|
|
return (error);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
2002-05-05 23:47:41 +00:00
|
|
|
/*
|
|
|
|
* Same as chflags() but doesn't follow symlinks.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
lchflags(td, uap)
|
|
|
|
struct thread *td;
|
|
|
|
register struct lchflags_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
|
|
|
int flags;
|
2002-05-05 23:47:41 +00:00
|
|
|
} */ *uap;
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
2005-01-24 10:25:44 +00:00
|
|
|
int vfslocked;
|
2002-05-05 23:47:41 +00:00
|
|
|
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
AUDIT_ARG(fflags, uap->flags);
|
|
|
|
NDINIT(&nd, LOOKUP, NOFOLLOW | MPSAFE | AUDITVNODE1, UIO_USERSPACE,
|
|
|
|
uap->path, td);
|
2002-05-05 23:47:41 +00:00
|
|
|
if ((error = namei(&nd)) != 0)
|
|
|
|
return (error);
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = NDHASGIANT(&nd);
|
2002-05-05 23:47:41 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
2002-12-14 01:56:26 +00:00
|
|
|
error = setfflags(td, nd.ni_vp, uap->flags);
|
2002-05-05 23:47:41 +00:00
|
|
|
vrele(nd.ni_vp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2004-01-11 19:52:10 +00:00
|
|
|
return (error);
|
2002-05-05 23:47:41 +00:00
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* 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-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
fchflags(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct fchflags_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
int fd;
|
|
|
|
int flags;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
struct file *fp;
|
2005-01-24 10:25:44 +00:00
|
|
|
int vfslocked;
|
1994-05-24 10:09:53 +00:00
|
|
|
int error;
|
|
|
|
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
AUDIT_ARG(fd, uap->fd);
|
|
|
|
AUDIT_ARG(fflags, uap->flags);
|
2002-12-14 01:56:26 +00:00
|
|
|
if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = VFS_LOCK_GIANT(fp->f_vnode->v_mount);
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
#ifdef AUDIT
|
2008-01-10 01:10:58 +00:00
|
|
|
vn_lock(fp->f_vnode, LK_EXCLUSIVE | LK_RETRY);
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
AUDIT_ARG(vnode, fp->f_vnode, ARG_VNODE1);
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(fp->f_vnode, 0);
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
#endif
|
2003-06-22 08:41:43 +00:00
|
|
|
error = setfflags(td, fp->f_vnode, uap->flags);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2005-12-20 00:49:59 +00:00
|
|
|
fdrop(fp, td);
|
2002-01-13 11:58:06 +00:00
|
|
|
return (error);
|
1998-05-11 03:55:28 +00:00
|
|
|
}
|
|
|
|
|
2000-09-14 19:13:59 +00:00
|
|
|
/*
|
|
|
|
* Common implementation code for chmod(), lchmod() and fchmod().
|
|
|
|
*/
|
1998-05-11 03:55:28 +00:00
|
|
|
static int
|
2001-09-12 08:38:13 +00:00
|
|
|
setfmode(td, vp, mode)
|
|
|
|
struct thread *td;
|
1998-05-11 03:55:28 +00:00
|
|
|
struct vnode *vp;
|
|
|
|
int mode;
|
|
|
|
{
|
|
|
|
int error;
|
2000-07-11 22:07:57 +00:00
|
|
|
struct mount *mp;
|
1998-05-11 03:55:28 +00:00
|
|
|
struct vattr vattr;
|
|
|
|
|
2000-07-11 22:07:57 +00:00
|
|
|
if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0)
|
|
|
|
return (error);
|
2002-02-27 18:32:23 +00:00
|
|
|
VOP_LEASE(vp, td, td->td_ucred, LEASE_WRITE);
|
2008-01-10 01:10:58 +00:00
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
|
1995-10-22 09:32:48 +00:00
|
|
|
VATTR_NULL(&vattr);
|
1998-05-11 03:55:28 +00:00
|
|
|
vattr.va_mode = mode & ALLPERMS;
|
Introduce support for Mandatory Access Control and extensible
kernel access control.
Invoke appropriate MAC entry points to authorize the following
operations:
truncate on open() (write)
access() (access)
readlink() (readlink)
chflags(), lchflags(), fchflags() (setflag)
chmod(), fchmod(), lchmod() (setmode)
chown(), fchown(), lchown() (setowner)
utimes(), lutimes(), futimes() (setutimes)
truncate(), ftrunfcate() (write)
revoke() (revoke)
fhopen() (open)
truncate on fhopen() (write)
extattr_set_fd, extattr_set_file() (setextattr)
extattr_get_fd, extattr_get_file() (getextattr)
extattr_delete_fd(), extattr_delete_file() (setextattr)
These entry points permit MAC policies to enforce a variety of
protections on vnodes. More vnode checks to come, especially in
non-native ABIs.
Obtained from: TrustedBSD Project
Sponsored by: DARPA, NAI Labs
2002-08-01 15:37:12 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_vnode_check_setmode(td->td_ucred, vp, vattr.va_mode);
|
Introduce support for Mandatory Access Control and extensible
kernel access control.
Invoke appropriate MAC entry points to authorize the following
operations:
truncate on open() (write)
access() (access)
readlink() (readlink)
chflags(), lchflags(), fchflags() (setflag)
chmod(), fchmod(), lchmod() (setmode)
chown(), fchown(), lchown() (setowner)
utimes(), lutimes(), futimes() (setutimes)
truncate(), ftrunfcate() (write)
revoke() (revoke)
fhopen() (open)
truncate on fhopen() (write)
extattr_set_fd, extattr_set_file() (setextattr)
extattr_get_fd, extattr_get_file() (getextattr)
extattr_delete_fd(), extattr_delete_file() (setextattr)
These entry points permit MAC policies to enforce a variety of
protections on vnodes. More vnode checks to come, especially in
non-native ABIs.
Obtained from: TrustedBSD Project
Sponsored by: DARPA, NAI Labs
2002-08-01 15:37:12 +00:00
|
|
|
if (error == 0)
|
|
|
|
#endif
|
2008-08-28 15:23:18 +00:00
|
|
|
error = VOP_SETATTR(vp, &vattr, td->td_ucred);
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(vp, 0);
|
2000-07-11 22:07:57 +00:00
|
|
|
vn_finished_write(mp);
|
2004-01-11 19:52:10 +00:00
|
|
|
return (error);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
chmod(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct chmod_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
|
|
|
int mode;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
2002-09-01 20:37:28 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
return (kern_chmod(td, uap->path, UIO_USERSPACE, uap->mode));
|
|
|
|
}
|
|
|
|
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct fchmodat_args {
|
|
|
|
int dirfd;
|
|
|
|
char *path;
|
|
|
|
mode_t mode;
|
|
|
|
int flag;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
int
|
|
|
|
fchmodat(struct thread *td, struct fchmodat_args *uap)
|
|
|
|
{
|
|
|
|
int flag = uap->flag;
|
|
|
|
int fd = uap->fd;
|
|
|
|
char *path = uap->path;
|
|
|
|
mode_t mode = uap->mode;
|
|
|
|
|
|
|
|
if (flag & ~AT_SYMLINK_NOFOLLOW)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
return (kern_fchmodat(td, fd, path, UIO_USERSPACE, mode, flag));
|
|
|
|
}
|
|
|
|
|
2002-09-01 20:37:28 +00:00
|
|
|
int
|
|
|
|
kern_chmod(struct thread *td, char *path, enum uio_seg pathseg, int mode)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
return (kern_fchmodat(td, AT_FDCWD, path, pathseg, mode, 0));
|
1998-05-11 03:55:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Change mode of a file given path name (don't follow links.)
|
|
|
|
*/
|
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct lchmod_args {
|
|
|
|
char *path;
|
|
|
|
int mode;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
lchmod(td, uap)
|
|
|
|
struct thread *td;
|
1998-05-11 03:55:28 +00:00
|
|
|
register struct lchmod_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
|
|
|
int mode;
|
1998-05-11 03:55:28 +00:00
|
|
|
} */ *uap;
|
|
|
|
{
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
|
|
|
|
return (kern_fchmodat(td, AT_FDCWD, uap->path, UIO_USERSPACE,
|
|
|
|
uap->mode, AT_SYMLINK_NOFOLLOW));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_fchmodat(struct thread *td, int fd, char *path, enum uio_seg pathseg,
|
|
|
|
mode_t mode, int flag)
|
|
|
|
{
|
1998-05-11 03:55:28 +00:00
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
2005-01-24 10:25:44 +00:00
|
|
|
int vfslocked;
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
int follow;
|
1998-05-11 03:55:28 +00:00
|
|
|
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
AUDIT_ARG(mode, mode);
|
|
|
|
follow = (flag & AT_SYMLINK_NOFOLLOW) ? NOFOLLOW : FOLLOW;
|
|
|
|
NDINIT_AT(&nd, LOOKUP, follow | MPSAFE | AUDITVNODE1, pathseg, path,
|
|
|
|
fd, td);
|
1999-01-27 21:50:00 +00:00
|
|
|
if ((error = namei(&nd)) != 0)
|
1998-05-11 03:55:28 +00:00
|
|
|
return (error);
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = NDHASGIANT(&nd);
|
1999-12-15 23:02:35 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
error = setfmode(td, nd.ni_vp, mode);
|
1998-05-11 03:55:28 +00:00
|
|
|
vrele(nd.ni_vp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2004-01-11 19:52:10 +00:00
|
|
|
return (error);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
fchmod(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct fchmod_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
int fd;
|
|
|
|
int mode;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
struct file *fp;
|
2005-01-24 10:25:44 +00:00
|
|
|
int vfslocked;
|
1994-05-24 10:09:53 +00:00
|
|
|
int error;
|
|
|
|
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
AUDIT_ARG(fd, uap->fd);
|
|
|
|
AUDIT_ARG(mode, uap->mode);
|
2002-12-14 01:56:26 +00:00
|
|
|
if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = VFS_LOCK_GIANT(fp->f_vnode->v_mount);
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
#ifdef AUDIT
|
2008-01-10 01:10:58 +00:00
|
|
|
vn_lock(fp->f_vnode, LK_EXCLUSIVE | LK_RETRY);
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
AUDIT_ARG(vnode, fp->f_vnode, ARG_VNODE1);
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(fp->f_vnode, 0);
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
#endif
|
2003-06-22 08:41:43 +00:00
|
|
|
error = setfmode(td, fp->f_vnode, uap->mode);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2005-12-20 00:49:59 +00:00
|
|
|
fdrop(fp, td);
|
2002-01-13 11:58:06 +00:00
|
|
|
return (error);
|
1998-05-11 03:55:28 +00:00
|
|
|
}
|
|
|
|
|
2000-09-14 19:13:59 +00:00
|
|
|
/*
|
|
|
|
* Common implementation for chown(), lchown(), and fchown()
|
|
|
|
*/
|
1998-05-11 03:55:28 +00:00
|
|
|
static int
|
2001-09-12 08:38:13 +00:00
|
|
|
setfown(td, vp, uid, gid)
|
|
|
|
struct thread *td;
|
1998-05-11 03:55:28 +00:00
|
|
|
struct vnode *vp;
|
|
|
|
uid_t uid;
|
|
|
|
gid_t gid;
|
|
|
|
{
|
|
|
|
int error;
|
2000-07-11 22:07:57 +00:00
|
|
|
struct mount *mp;
|
1998-05-11 03:55:28 +00:00
|
|
|
struct vattr vattr;
|
|
|
|
|
2000-07-11 22:07:57 +00:00
|
|
|
if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0)
|
|
|
|
return (error);
|
2002-02-27 18:32:23 +00:00
|
|
|
VOP_LEASE(vp, td, td->td_ucred, LEASE_WRITE);
|
2008-01-10 01:10:58 +00:00
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
|
1995-10-22 09:32:48 +00:00
|
|
|
VATTR_NULL(&vattr);
|
1998-05-11 03:55:28 +00:00
|
|
|
vattr.va_uid = uid;
|
|
|
|
vattr.va_gid = gid;
|
Introduce support for Mandatory Access Control and extensible
kernel access control.
Invoke appropriate MAC entry points to authorize the following
operations:
truncate on open() (write)
access() (access)
readlink() (readlink)
chflags(), lchflags(), fchflags() (setflag)
chmod(), fchmod(), lchmod() (setmode)
chown(), fchown(), lchown() (setowner)
utimes(), lutimes(), futimes() (setutimes)
truncate(), ftrunfcate() (write)
revoke() (revoke)
fhopen() (open)
truncate on fhopen() (write)
extattr_set_fd, extattr_set_file() (setextattr)
extattr_get_fd, extattr_get_file() (getextattr)
extattr_delete_fd(), extattr_delete_file() (setextattr)
These entry points permit MAC policies to enforce a variety of
protections on vnodes. More vnode checks to come, especially in
non-native ABIs.
Obtained from: TrustedBSD Project
Sponsored by: DARPA, NAI Labs
2002-08-01 15:37:12 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_vnode_check_setowner(td->td_ucred, vp, vattr.va_uid,
|
Introduce support for Mandatory Access Control and extensible
kernel access control.
Invoke appropriate MAC entry points to authorize the following
operations:
truncate on open() (write)
access() (access)
readlink() (readlink)
chflags(), lchflags(), fchflags() (setflag)
chmod(), fchmod(), lchmod() (setmode)
chown(), fchown(), lchown() (setowner)
utimes(), lutimes(), futimes() (setutimes)
truncate(), ftrunfcate() (write)
revoke() (revoke)
fhopen() (open)
truncate on fhopen() (write)
extattr_set_fd, extattr_set_file() (setextattr)
extattr_get_fd, extattr_get_file() (getextattr)
extattr_delete_fd(), extattr_delete_file() (setextattr)
These entry points permit MAC policies to enforce a variety of
protections on vnodes. More vnode checks to come, especially in
non-native ABIs.
Obtained from: TrustedBSD Project
Sponsored by: DARPA, NAI Labs
2002-08-01 15:37:12 +00:00
|
|
|
vattr.va_gid);
|
|
|
|
if (error == 0)
|
|
|
|
#endif
|
2008-08-28 15:23:18 +00:00
|
|
|
error = VOP_SETATTR(vp, &vattr, td->td_ucred);
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(vp, 0);
|
2000-07-11 22:07:57 +00:00
|
|
|
vn_finished_write(mp);
|
2004-01-11 19:52:10 +00:00
|
|
|
return (error);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
chown(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct chown_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
|
|
|
int uid;
|
|
|
|
int gid;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2002-09-01 20:37:28 +00:00
|
|
|
|
|
|
|
return (kern_chown(td, uap->path, UIO_USERSPACE, uap->uid, uap->gid));
|
|
|
|
}
|
|
|
|
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct fchownat_args {
|
|
|
|
int fd;
|
|
|
|
const char * path;
|
|
|
|
uid_t uid;
|
|
|
|
gid_t gid;
|
|
|
|
int flag;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
int
|
|
|
|
fchownat(struct thread *td, struct fchownat_args *uap)
|
|
|
|
{
|
|
|
|
int flag;
|
|
|
|
|
|
|
|
flag = uap->flag;
|
|
|
|
if (flag & ~AT_SYMLINK_NOFOLLOW)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
return (kern_fchownat(td, uap->fd, uap->path, UIO_USERSPACE, uap->uid,
|
|
|
|
uap->gid, uap->flag));
|
|
|
|
}
|
|
|
|
|
2002-09-01 20:37:28 +00:00
|
|
|
int
|
|
|
|
kern_chown(struct thread *td, char *path, enum uio_seg pathseg, int uid,
|
|
|
|
int gid)
|
|
|
|
{
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
|
|
|
|
return (kern_fchownat(td, AT_FDCWD, path, pathseg, uid, gid, 0));
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_fchownat(struct thread *td, int fd, char *path, enum uio_seg pathseg,
|
|
|
|
int uid, int gid, int flag)
|
|
|
|
{
|
1994-05-24 10:09:53 +00:00
|
|
|
struct nameidata nd;
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
int error, vfslocked, follow;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
AUDIT_ARG(owner, uid, gid);
|
2008-04-07 00:29:32 +00:00
|
|
|
follow = (flag & AT_SYMLINK_NOFOLLOW) ? NOFOLLOW : FOLLOW;
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
NDINIT_AT(&nd, LOOKUP, follow | MPSAFE | AUDITVNODE1, pathseg, path,
|
|
|
|
fd, td);
|
|
|
|
|
1999-01-27 21:50:00 +00:00
|
|
|
if ((error = namei(&nd)) != 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = NDHASGIANT(&nd);
|
1999-12-15 23:02:35 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
2002-09-01 20:37:28 +00:00
|
|
|
error = setfown(td, nd.ni_vp, uid, gid);
|
1998-05-11 03:55:28 +00:00
|
|
|
vrele(nd.ni_vp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
1994-05-24 10:09:53 +00:00
|
|
|
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
|
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
lchown(td, uap)
|
|
|
|
struct thread *td;
|
1997-03-31 12:21:37 +00:00
|
|
|
register struct lchown_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
|
|
|
int uid;
|
|
|
|
int gid;
|
1997-03-31 12:21:37 +00:00
|
|
|
} */ *uap;
|
|
|
|
{
|
2002-09-01 20:37:28 +00:00
|
|
|
|
|
|
|
return (kern_lchown(td, uap->path, UIO_USERSPACE, uap->uid, uap->gid));
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_lchown(struct thread *td, char *path, enum uio_seg pathseg, int uid,
|
|
|
|
int gid)
|
|
|
|
{
|
1997-03-31 12:21:37 +00:00
|
|
|
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
return (kern_fchownat(td, AT_FDCWD, path, pathseg, uid, gid,
|
|
|
|
AT_SYMLINK_NOFOLLOW));
|
1997-03-31 12:21:37 +00:00
|
|
|
}
|
|
|
|
|
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-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
fchown(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct fchown_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
int fd;
|
|
|
|
int uid;
|
|
|
|
int gid;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
struct file *fp;
|
2005-01-24 10:25:44 +00:00
|
|
|
int vfslocked;
|
1994-05-24 10:09:53 +00:00
|
|
|
int error;
|
|
|
|
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
AUDIT_ARG(fd, uap->fd);
|
|
|
|
AUDIT_ARG(owner, uap->uid, uap->gid);
|
2002-12-14 01:56:26 +00:00
|
|
|
if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = VFS_LOCK_GIANT(fp->f_vnode->v_mount);
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
#ifdef AUDIT
|
2008-01-10 01:10:58 +00:00
|
|
|
vn_lock(fp->f_vnode, LK_EXCLUSIVE | LK_RETRY);
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
AUDIT_ARG(vnode, fp->f_vnode, ARG_VNODE1);
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(fp->f_vnode, 0);
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
#endif
|
2003-06-22 08:41:43 +00:00
|
|
|
error = setfown(td, fp->f_vnode, uap->uid, uap->gid);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2005-12-20 00:49:59 +00:00
|
|
|
fdrop(fp, td);
|
2002-01-13 11:58:06 +00:00
|
|
|
return (error);
|
1998-05-11 03:55:28 +00:00
|
|
|
}
|
|
|
|
|
2000-09-14 19:13:59 +00:00
|
|
|
/*
|
|
|
|
* Common implementation code for utimes(), lutimes(), and futimes().
|
|
|
|
*/
|
1998-05-11 03:55:28 +00:00
|
|
|
static int
|
2002-09-01 20:37:28 +00:00
|
|
|
getutimes(usrtvp, tvpseg, tsp)
|
1999-08-22 01:46:57 +00:00
|
|
|
const struct timeval *usrtvp;
|
2002-09-01 20:37:28 +00:00
|
|
|
enum uio_seg tvpseg;
|
1999-08-22 01:46:57 +00:00
|
|
|
struct timespec *tsp;
|
|
|
|
{
|
2006-01-04 00:47:13 +00:00
|
|
|
struct timeval tv[2];
|
2002-09-01 20:37:28 +00:00
|
|
|
const struct timeval *tvp;
|
1999-08-22 01:46:57 +00:00
|
|
|
int error;
|
|
|
|
|
|
|
|
if (usrtvp == NULL) {
|
1999-08-22 16:50:30 +00:00
|
|
|
microtime(&tv[0]);
|
|
|
|
TIMEVAL_TO_TIMESPEC(&tv[0], &tsp[0]);
|
1999-08-22 01:46:57 +00:00
|
|
|
tsp[1] = tsp[0];
|
|
|
|
} else {
|
2002-09-01 20:37:28 +00:00
|
|
|
if (tvpseg == UIO_SYSSPACE) {
|
|
|
|
tvp = usrtvp;
|
|
|
|
} else {
|
|
|
|
if ((error = copyin(usrtvp, tv, sizeof(tv))) != 0)
|
|
|
|
return (error);
|
|
|
|
tvp = tv;
|
|
|
|
}
|
|
|
|
|
2006-01-04 07:50:54 +00:00
|
|
|
if (tvp[0].tv_usec < 0 || tvp[0].tv_usec >= 1000000 ||
|
|
|
|
tvp[1].tv_usec < 0 || tvp[1].tv_usec >= 1000000)
|
2006-01-04 00:47:13 +00:00
|
|
|
return (EINVAL);
|
|
|
|
TIMEVAL_TO_TIMESPEC(&tvp[0], &tsp[0]);
|
|
|
|
TIMEVAL_TO_TIMESPEC(&tvp[1], &tsp[1]);
|
1999-08-22 01:46:57 +00:00
|
|
|
}
|
2004-01-11 19:52:10 +00:00
|
|
|
return (0);
|
1999-08-22 01:46:57 +00:00
|
|
|
}
|
|
|
|
|
2000-09-14 19:13:59 +00:00
|
|
|
/*
|
|
|
|
* Common implementation code for utimes(), lutimes(), and futimes().
|
|
|
|
*/
|
1999-08-22 01:46:57 +00:00
|
|
|
static int
|
2002-07-17 02:03:19 +00:00
|
|
|
setutimes(td, vp, ts, numtimes, nullflag)
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td;
|
1998-05-11 03:55:28 +00:00
|
|
|
struct vnode *vp;
|
1999-08-22 01:46:57 +00:00
|
|
|
const struct timespec *ts;
|
2002-07-17 02:03:19 +00:00
|
|
|
int numtimes;
|
1998-05-11 03:55:28 +00:00
|
|
|
int nullflag;
|
|
|
|
{
|
2002-07-17 02:03:19 +00:00
|
|
|
int error, setbirthtime;
|
2000-07-11 22:07:57 +00:00
|
|
|
struct mount *mp;
|
1998-05-11 03:55:28 +00:00
|
|
|
struct vattr vattr;
|
|
|
|
|
2000-07-11 22:07:57 +00:00
|
|
|
if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0)
|
|
|
|
return (error);
|
2002-02-27 18:32:23 +00:00
|
|
|
VOP_LEASE(vp, td, td->td_ucred, LEASE_WRITE);
|
2008-01-10 01:10:58 +00:00
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
|
2002-07-17 02:03:19 +00:00
|
|
|
setbirthtime = 0;
|
2008-08-28 15:23:18 +00:00
|
|
|
if (numtimes < 3 && !VOP_GETATTR(vp, &vattr, td->td_ucred) &&
|
2002-07-17 02:03:19 +00:00
|
|
|
timespeccmp(&ts[1], &vattr.va_birthtime, < ))
|
|
|
|
setbirthtime = 1;
|
1995-10-22 09:32:48 +00:00
|
|
|
VATTR_NULL(&vattr);
|
1999-08-22 01:46:57 +00:00
|
|
|
vattr.va_atime = ts[0];
|
|
|
|
vattr.va_mtime = ts[1];
|
2002-07-17 02:03:19 +00:00
|
|
|
if (setbirthtime)
|
|
|
|
vattr.va_birthtime = ts[1];
|
|
|
|
if (numtimes > 2)
|
|
|
|
vattr.va_birthtime = ts[2];
|
1998-05-11 03:55:28 +00:00
|
|
|
if (nullflag)
|
|
|
|
vattr.va_vaflags |= VA_UTIMES_NULL;
|
Introduce support for Mandatory Access Control and extensible
kernel access control.
Invoke appropriate MAC entry points to authorize the following
operations:
truncate on open() (write)
access() (access)
readlink() (readlink)
chflags(), lchflags(), fchflags() (setflag)
chmod(), fchmod(), lchmod() (setmode)
chown(), fchown(), lchown() (setowner)
utimes(), lutimes(), futimes() (setutimes)
truncate(), ftrunfcate() (write)
revoke() (revoke)
fhopen() (open)
truncate on fhopen() (write)
extattr_set_fd, extattr_set_file() (setextattr)
extattr_get_fd, extattr_get_file() (getextattr)
extattr_delete_fd(), extattr_delete_file() (setextattr)
These entry points permit MAC policies to enforce a variety of
protections on vnodes. More vnode checks to come, especially in
non-native ABIs.
Obtained from: TrustedBSD Project
Sponsored by: DARPA, NAI Labs
2002-08-01 15:37:12 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_vnode_check_setutimes(td->td_ucred, vp, vattr.va_atime,
|
Introduce support for Mandatory Access Control and extensible
kernel access control.
Invoke appropriate MAC entry points to authorize the following
operations:
truncate on open() (write)
access() (access)
readlink() (readlink)
chflags(), lchflags(), fchflags() (setflag)
chmod(), fchmod(), lchmod() (setmode)
chown(), fchown(), lchown() (setowner)
utimes(), lutimes(), futimes() (setutimes)
truncate(), ftrunfcate() (write)
revoke() (revoke)
fhopen() (open)
truncate on fhopen() (write)
extattr_set_fd, extattr_set_file() (setextattr)
extattr_get_fd, extattr_get_file() (getextattr)
extattr_delete_fd(), extattr_delete_file() (setextattr)
These entry points permit MAC policies to enforce a variety of
protections on vnodes. More vnode checks to come, especially in
non-native ABIs.
Obtained from: TrustedBSD Project
Sponsored by: DARPA, NAI Labs
2002-08-01 15:37:12 +00:00
|
|
|
vattr.va_mtime);
|
|
|
|
#endif
|
2002-10-02 09:09:25 +00:00
|
|
|
if (error == 0)
|
2008-08-28 15:23:18 +00:00
|
|
|
error = VOP_SETATTR(vp, &vattr, td->td_ucred);
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(vp, 0);
|
2000-07-11 22:07:57 +00:00
|
|
|
vn_finished_write(mp);
|
2004-01-11 19:52:10 +00:00
|
|
|
return (error);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
utimes(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct utimes_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
|
|
|
struct timeval *tptr;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2002-09-01 20:37:28 +00:00
|
|
|
|
|
|
|
return (kern_utimes(td, uap->path, UIO_USERSPACE, uap->tptr,
|
|
|
|
UIO_USERSPACE));
|
|
|
|
}
|
|
|
|
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct futimesat_args {
|
|
|
|
int fd;
|
|
|
|
const char * path;
|
|
|
|
const struct timeval * times;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
int
|
|
|
|
futimesat(struct thread *td, struct futimesat_args *uap)
|
|
|
|
{
|
|
|
|
|
|
|
|
return (kern_utimesat(td, uap->fd, uap->path, UIO_USERSPACE,
|
|
|
|
uap->times, UIO_USERSPACE));
|
|
|
|
}
|
|
|
|
|
2002-09-01 20:37:28 +00:00
|
|
|
int
|
|
|
|
kern_utimes(struct thread *td, char *path, enum uio_seg pathseg,
|
|
|
|
struct timeval *tptr, enum uio_seg tptrseg)
|
|
|
|
{
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
|
|
|
|
return (kern_utimesat(td, AT_FDCWD, path, pathseg, tptr, tptrseg));
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_utimesat(struct thread *td, int fd, char *path, enum uio_seg pathseg,
|
|
|
|
struct timeval *tptr, enum uio_seg tptrseg)
|
|
|
|
{
|
1994-05-24 10:09:53 +00:00
|
|
|
struct nameidata nd;
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
struct timespec ts[2];
|
|
|
|
int error, vfslocked;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2002-09-01 20:37:28 +00:00
|
|
|
if ((error = getutimes(tptr, tptrseg, ts)) != 0)
|
1999-08-22 01:46:57 +00:00
|
|
|
return (error);
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
NDINIT_AT(&nd, LOOKUP, FOLLOW | MPSAFE | AUDITVNODE1, pathseg, path,
|
|
|
|
fd, td);
|
|
|
|
|
1999-01-27 21:50:00 +00:00
|
|
|
if ((error = namei(&nd)) != 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = NDHASGIANT(&nd);
|
1999-12-15 23:02:35 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
2002-09-01 20:37:28 +00:00
|
|
|
error = setutimes(td, nd.ni_vp, ts, 2, tptr == NULL);
|
1998-05-11 03:55:28 +00:00
|
|
|
vrele(nd.ni_vp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
1998-05-11 03:55:28 +00:00
|
|
|
/*
|
|
|
|
* Set the access and modification times of a file.
|
|
|
|
*/
|
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct lutimes_args {
|
|
|
|
char *path;
|
|
|
|
struct timeval *tptr;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
lutimes(td, uap)
|
|
|
|
struct thread *td;
|
1998-05-11 03:55:28 +00:00
|
|
|
register struct lutimes_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
|
|
|
struct timeval *tptr;
|
1998-05-11 03:55:28 +00:00
|
|
|
} */ *uap;
|
|
|
|
{
|
2002-09-01 20:37:28 +00:00
|
|
|
|
|
|
|
return (kern_lutimes(td, uap->path, UIO_USERSPACE, uap->tptr,
|
|
|
|
UIO_USERSPACE));
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_lutimes(struct thread *td, char *path, enum uio_seg pathseg,
|
|
|
|
struct timeval *tptr, enum uio_seg tptrseg)
|
|
|
|
{
|
1999-08-22 01:46:57 +00:00
|
|
|
struct timespec ts[2];
|
1998-05-11 03:55:28 +00:00
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
2005-01-24 10:25:44 +00:00
|
|
|
int vfslocked;
|
1998-05-11 03:55:28 +00:00
|
|
|
|
2002-09-01 20:37:28 +00:00
|
|
|
if ((error = getutimes(tptr, tptrseg, ts)) != 0)
|
1999-08-22 01:46:57 +00:00
|
|
|
return (error);
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
NDINIT(&nd, LOOKUP, NOFOLLOW | MPSAFE | AUDITVNODE1, pathseg, path, td);
|
1999-01-27 21:50:00 +00:00
|
|
|
if ((error = namei(&nd)) != 0)
|
1998-05-11 03:55:28 +00:00
|
|
|
return (error);
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = NDHASGIANT(&nd);
|
1999-12-15 23:02:35 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
2002-09-01 20:37:28 +00:00
|
|
|
error = setutimes(td, nd.ni_vp, ts, 2, tptr == NULL);
|
1998-05-11 03:55:28 +00:00
|
|
|
vrele(nd.ni_vp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
1998-05-11 03:55:28 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set the access and modification times of a file.
|
|
|
|
*/
|
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct futimes_args {
|
|
|
|
int fd;
|
|
|
|
struct timeval *tptr;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
futimes(td, uap)
|
|
|
|
struct thread *td;
|
1998-05-11 03:55:28 +00:00
|
|
|
register struct futimes_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
int fd;
|
|
|
|
struct timeval *tptr;
|
1998-05-11 03:55:28 +00:00
|
|
|
} */ *uap;
|
|
|
|
{
|
2002-09-01 20:37:28 +00:00
|
|
|
|
|
|
|
return (kern_futimes(td, uap->fd, uap->tptr, UIO_USERSPACE));
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_futimes(struct thread *td, int fd, struct timeval *tptr,
|
|
|
|
enum uio_seg tptrseg)
|
|
|
|
{
|
1999-08-22 01:46:57 +00:00
|
|
|
struct timespec ts[2];
|
1998-05-11 03:55:28 +00:00
|
|
|
struct file *fp;
|
2005-01-24 10:25:44 +00:00
|
|
|
int vfslocked;
|
1998-05-11 03:55:28 +00:00
|
|
|
int error;
|
|
|
|
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
AUDIT_ARG(fd, fd);
|
2002-09-01 20:37:28 +00:00
|
|
|
if ((error = getutimes(tptr, tptrseg, ts)) != 0)
|
1999-08-22 01:46:57 +00:00
|
|
|
return (error);
|
2002-09-01 20:37:28 +00:00
|
|
|
if ((error = getvnode(td->td_proc->p_fd, fd, &fp)) != 0)
|
1998-05-11 03:55:28 +00:00
|
|
|
return (error);
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = VFS_LOCK_GIANT(fp->f_vnode->v_mount);
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
#ifdef AUDIT
|
2008-01-10 01:10:58 +00:00
|
|
|
vn_lock(fp->f_vnode, LK_EXCLUSIVE | LK_RETRY);
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
AUDIT_ARG(vnode, fp->f_vnode, ARG_VNODE1);
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(fp->f_vnode, 0);
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
#endif
|
2003-06-22 08:41:43 +00:00
|
|
|
error = setutimes(td, fp->f_vnode, ts, 2, tptr == NULL);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2005-12-20 00:49:59 +00:00
|
|
|
fdrop(fp, td);
|
2002-01-13 11:58:06 +00:00
|
|
|
return (error);
|
1998-05-11 03:55:28 +00:00
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* 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-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
truncate(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct truncate_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
|
|
|
int pad;
|
|
|
|
off_t length;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
2002-09-01 20:37:28 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
return (kern_truncate(td, uap->path, UIO_USERSPACE, uap->length));
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_truncate(struct thread *td, char *path, enum uio_seg pathseg, off_t length)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2000-07-11 22:07:57 +00:00
|
|
|
struct mount *mp;
|
|
|
|
struct vnode *vp;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct vattr vattr;
|
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
2005-01-24 10:25:44 +00:00
|
|
|
int vfslocked;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2002-09-01 20:37:28 +00:00
|
|
|
if (length < 0)
|
1994-09-02 10:23:43 +00:00
|
|
|
return(EINVAL);
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
NDINIT(&nd, LOOKUP, FOLLOW | MPSAFE | AUDITVNODE1, pathseg, path, td);
|
1999-01-27 21:50:00 +00:00
|
|
|
if ((error = namei(&nd)) != 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = NDHASGIANT(&nd);
|
1994-05-24 10:09:53 +00:00
|
|
|
vp = nd.ni_vp;
|
2000-07-11 22:07:57 +00:00
|
|
|
if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) {
|
|
|
|
vrele(vp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2000-07-11 22:07:57 +00:00
|
|
|
return (error);
|
|
|
|
}
|
1999-12-15 23:02:35 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
2002-02-27 18:32:23 +00:00
|
|
|
VOP_LEASE(vp, td, td->td_ucred, LEASE_WRITE);
|
2008-01-10 01:10:58 +00:00
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (vp->v_type == VDIR)
|
|
|
|
error = EISDIR;
|
Introduce support for Mandatory Access Control and extensible
kernel access control.
Invoke appropriate MAC entry points to authorize the following
operations:
truncate on open() (write)
access() (access)
readlink() (readlink)
chflags(), lchflags(), fchflags() (setflag)
chmod(), fchmod(), lchmod() (setmode)
chown(), fchown(), lchown() (setowner)
utimes(), lutimes(), futimes() (setutimes)
truncate(), ftrunfcate() (write)
revoke() (revoke)
fhopen() (open)
truncate on fhopen() (write)
extattr_set_fd, extattr_set_file() (setextattr)
extattr_get_fd, extattr_get_file() (getextattr)
extattr_delete_fd(), extattr_delete_file() (setextattr)
These entry points permit MAC policies to enforce a variety of
protections on vnodes. More vnode checks to come, especially in
non-native ABIs.
Obtained from: TrustedBSD Project
Sponsored by: DARPA, NAI Labs
2002-08-01 15:37:12 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
else if ((error = mac_vnode_check_write(td->td_ucred, NOCRED, vp))) {
|
2002-08-19 19:04:53 +00:00
|
|
|
}
|
Introduce support for Mandatory Access Control and extensible
kernel access control.
Invoke appropriate MAC entry points to authorize the following
operations:
truncate on open() (write)
access() (access)
readlink() (readlink)
chflags(), lchflags(), fchflags() (setflag)
chmod(), fchmod(), lchmod() (setmode)
chown(), fchown(), lchown() (setowner)
utimes(), lutimes(), futimes() (setutimes)
truncate(), ftrunfcate() (write)
revoke() (revoke)
fhopen() (open)
truncate on fhopen() (write)
extattr_set_fd, extattr_set_file() (setextattr)
extattr_get_fd, extattr_get_file() (getextattr)
extattr_delete_fd(), extattr_delete_file() (setextattr)
These entry points permit MAC policies to enforce a variety of
protections on vnodes. More vnode checks to come, especially in
non-native ABIs.
Obtained from: TrustedBSD Project
Sponsored by: DARPA, NAI Labs
2002-08-01 15:37:12 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
else if ((error = vn_writechk(vp)) == 0 &&
|
2002-02-27 18:32:23 +00:00
|
|
|
(error = VOP_ACCESS(vp, VWRITE, td->td_ucred, td)) == 0) {
|
1994-05-24 10:09:53 +00:00
|
|
|
VATTR_NULL(&vattr);
|
2002-09-01 20:37:28 +00:00
|
|
|
vattr.va_size = length;
|
2008-08-28 15:23:18 +00:00
|
|
|
error = VOP_SETATTR(vp, &vattr, td->td_ucred);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
vput(vp);
|
2000-07-11 22:07:57 +00:00
|
|
|
vn_finished_write(mp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2004-06-11 11:16:26 +00:00
|
|
|
#if defined(COMPAT_43)
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* 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-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
otruncate(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct otruncate_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
|
|
|
long length;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1997-02-10 02:22:35 +00:00
|
|
|
struct truncate_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
|
|
|
int pad;
|
|
|
|
off_t length;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ nuap;
|
|
|
|
|
2002-12-14 01:56:26 +00:00
|
|
|
nuap.path = uap->path;
|
|
|
|
nuap.length = uap->length;
|
2001-09-12 08:38:13 +00:00
|
|
|
return (truncate(td, &nuap));
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2004-06-11 11:16:26 +00:00
|
|
|
#endif /* COMPAT_43 */
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2007-07-04 22:57:21 +00:00
|
|
|
/* Versions with the pad argument */
|
|
|
|
int
|
|
|
|
freebsd6_truncate(struct thread *td, struct freebsd6_truncate_args *uap)
|
|
|
|
{
|
|
|
|
struct truncate_args ouap;
|
|
|
|
|
|
|
|
ouap.path = uap->path;
|
|
|
|
ouap.length = uap->length;
|
|
|
|
return (truncate(td, &ouap));
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
freebsd6_ftruncate(struct thread *td, struct freebsd6_ftruncate_args *uap)
|
|
|
|
{
|
|
|
|
struct ftruncate_args ouap;
|
|
|
|
|
|
|
|
ouap.fd = uap->fd;
|
|
|
|
ouap.length = uap->length;
|
|
|
|
return (ftruncate(td, &ouap));
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* 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-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
fsync(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
struct fsync_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
int fd;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2000-07-11 22:07:57 +00:00
|
|
|
struct vnode *vp;
|
|
|
|
struct mount *mp;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct file *fp;
|
2005-01-24 10:25:44 +00:00
|
|
|
int vfslocked;
|
1994-05-24 10:09:53 +00:00
|
|
|
int error;
|
|
|
|
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
AUDIT_ARG(fd, uap->fd);
|
2002-12-14 01:56:26 +00:00
|
|
|
if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2003-06-22 08:41:43 +00:00
|
|
|
vp = fp->f_vnode;
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = VFS_LOCK_GIANT(vp->v_mount);
|
|
|
|
if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0)
|
|
|
|
goto drop;
|
2008-01-10 01:10:58 +00:00
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
AUDIT_ARG(vnode, vp, ARG_VNODE1);
|
2005-01-25 00:40:01 +00:00
|
|
|
if (vp->v_object != NULL) {
|
|
|
|
VM_OBJECT_LOCK(vp->v_object);
|
|
|
|
vm_object_page_clean(vp->v_object, 0, 0, 0);
|
|
|
|
VM_OBJECT_UNLOCK(vp->v_object);
|
2001-05-19 01:28:09 +00:00
|
|
|
}
|
2005-01-11 07:36:22 +00:00
|
|
|
error = VOP_FSYNC(vp, MNT_WAIT, td);
|
2000-06-16 14:32:13 +00:00
|
|
|
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(vp, 0);
|
2000-07-11 22:07:57 +00:00
|
|
|
vn_finished_write(mp);
|
2005-01-24 10:25:44 +00:00
|
|
|
drop:
|
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2002-01-13 11:58:06 +00:00
|
|
|
fdrop(fp, td);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2007-03-05 13:10:58 +00:00
|
|
|
* Rename files. Source and destination must either both be directories, or
|
|
|
|
* both not be directories. If target is a directory, it must be empty.
|
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 rename_args {
|
|
|
|
char *from;
|
|
|
|
char *to;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
rename(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct rename_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *from;
|
|
|
|
char *to;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
2002-09-01 20:37:28 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
return (kern_rename(td, uap->from, uap->to, UIO_USERSPACE));
|
|
|
|
}
|
|
|
|
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct renameat_args {
|
|
|
|
int oldfd;
|
|
|
|
char *old;
|
|
|
|
int newfd;
|
|
|
|
char *new;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
int
|
|
|
|
renameat(struct thread *td, struct renameat_args *uap)
|
|
|
|
{
|
|
|
|
|
|
|
|
return (kern_renameat(td, uap->oldfd, uap->old, uap->newfd, uap->new,
|
|
|
|
UIO_USERSPACE));
|
|
|
|
}
|
|
|
|
|
2002-09-01 20:37:28 +00:00
|
|
|
int
|
|
|
|
kern_rename(struct thread *td, char *from, char *to, enum uio_seg pathseg)
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
return (kern_renameat(td, AT_FDCWD, from, AT_FDCWD, to, pathseg));
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_renameat(struct thread *td, int oldfd, char *old, int newfd, char *new,
|
|
|
|
enum uio_seg pathseg)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2002-10-27 23:23:51 +00:00
|
|
|
struct mount *mp = NULL;
|
2000-07-11 22:07:57 +00:00
|
|
|
struct vnode *tvp, *fvp, *tdvp;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct nameidata fromnd, tond;
|
2005-01-24 10:25:44 +00:00
|
|
|
int tvfslocked;
|
|
|
|
int fvfslocked;
|
1994-05-24 10:09:53 +00:00
|
|
|
int error;
|
|
|
|
|
2000-01-10 00:08:53 +00:00
|
|
|
bwillwrite();
|
2002-10-19 20:25:57 +00:00
|
|
|
#ifdef MAC
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
NDINIT_AT(&fromnd, DELETE, LOCKPARENT | LOCKLEAF | SAVESTART | MPSAFE |
|
|
|
|
AUDITVNODE1, pathseg, old, oldfd, td);
|
2002-10-19 20:25:57 +00:00
|
|
|
#else
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
NDINIT_AT(&fromnd, DELETE, WANTPARENT | SAVESTART | MPSAFE |
|
|
|
|
AUDITVNODE1, pathseg, old, oldfd, td);
|
2002-10-19 20:25:57 +00:00
|
|
|
#endif
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
|
1999-01-27 21:50:00 +00:00
|
|
|
if ((error = namei(&fromnd)) != 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2005-01-24 10:25:44 +00:00
|
|
|
fvfslocked = NDHASGIANT(&fromnd);
|
|
|
|
tvfslocked = 0;
|
2002-10-19 20:25:57 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_vnode_check_rename_from(td->td_ucred, fromnd.ni_dvp,
|
2002-10-19 20:25:57 +00:00
|
|
|
fromnd.ni_vp, &fromnd.ni_cnd);
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(fromnd.ni_dvp, 0);
|
2006-10-26 13:20:28 +00:00
|
|
|
if (fromnd.ni_dvp != fromnd.ni_vp)
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(fromnd.ni_vp, 0);
|
2002-10-19 20:25:57 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
fvp = fromnd.ni_vp;
|
2002-10-19 20:25:57 +00:00
|
|
|
if (error == 0)
|
|
|
|
error = vn_start_write(fvp, &mp, V_WAIT | PCATCH);
|
|
|
|
if (error != 0) {
|
2000-07-11 22:07:57 +00:00
|
|
|
NDFREE(&fromnd, NDF_ONLY_PNBUF);
|
|
|
|
vrele(fromnd.ni_dvp);
|
|
|
|
vrele(fvp);
|
|
|
|
goto out1;
|
|
|
|
}
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
NDINIT_AT(&tond, RENAME, LOCKPARENT | LOCKLEAF | NOCACHE | SAVESTART |
|
|
|
|
MPSAFE | AUDITVNODE2, pathseg, new, newfd, td);
|
1995-07-31 00:35:58 +00:00
|
|
|
if (fromnd.ni_vp->v_type == VDIR)
|
|
|
|
tond.ni_cnd.cn_flags |= WILLBEDIR;
|
1999-01-27 21:50:00 +00:00
|
|
|
if ((error = namei(&tond)) != 0) {
|
1995-11-18 11:35:05 +00:00
|
|
|
/* Translate error code for rename("dir1", "dir2/."). */
|
|
|
|
if (error == EISDIR && fvp->v_type == VDIR)
|
|
|
|
error = EINVAL;
|
1999-12-15 23:02:35 +00:00
|
|
|
NDFREE(&fromnd, NDF_ONLY_PNBUF);
|
1994-05-24 10:09:53 +00:00
|
|
|
vrele(fromnd.ni_dvp);
|
|
|
|
vrele(fvp);
|
2005-09-01 21:46:33 +00:00
|
|
|
vn_finished_write(mp);
|
1994-05-24 10:09:53 +00:00
|
|
|
goto out1;
|
|
|
|
}
|
2005-02-02 17:17:15 +00:00
|
|
|
tvfslocked = NDHASGIANT(&tond);
|
1994-05-24 10:09:53 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
2008-09-01 10:11:39 +00:00
|
|
|
if (fvp == tdvp) {
|
1994-05-24 10:09:53 +00:00
|
|
|
error = EINVAL;
|
2008-09-01 10:11:39 +00:00
|
|
|
goto out;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
2002-09-10 11:09:13 +00:00
|
|
|
* If the source is the same as the destination (that is, if they
|
|
|
|
* are links to the same vnode), then there is nothing to do.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2002-09-10 11:09:13 +00:00
|
|
|
if (fvp == tvp)
|
1994-05-24 10:09:53 +00:00
|
|
|
error = -1;
|
2002-10-19 20:25:57 +00:00
|
|
|
#ifdef MAC
|
|
|
|
else
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_vnode_check_rename_to(td->td_ucred, tdvp,
|
2002-10-19 20:25:57 +00:00
|
|
|
tond.ni_vp, fromnd.ni_dvp == tdvp, &tond.ni_cnd);
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
out:
|
|
|
|
if (!error) {
|
2002-02-27 18:32:23 +00:00
|
|
|
VOP_LEASE(tdvp, td, td->td_ucred, LEASE_WRITE);
|
Make our v_usecount vnode reference count work identically to the
original BSD code. The association between the vnode and the vm_object
no longer includes reference counts. The major difference is that
vm_object's are no longer freed gratuitiously from the vnode, and so
once an object is created for the vnode, it will last as long as the
vnode does.
When a vnode object reference count is incremented, then the underlying
vnode reference count is incremented also. The two "objects" are now
more intimately related, and so the interactions are now much less
complex.
When vnodes are now normally placed onto the free queue with an object still
attached. The rundown of the object happens at vnode rundown time, and
happens with exactly the same filesystem semantics of the original VFS
code. There is absolutely no need for vnode_pager_uncache and other
travesties like that anymore.
A side-effect of these changes is that SMP locking should be much simpler,
the I/O copyin/copyout optimizations work, NFS should be more ponderable,
and further work on layered filesystems should be less frustrating, because
of the totally coherent management of the vnode objects and vnodes.
Please be careful with your system while running this code, but I would
greatly appreciate feedback as soon a reasonably possible.
1998-01-06 05:26:17 +00:00
|
|
|
if (fromnd.ni_dvp != tdvp) {
|
2002-02-27 18:32:23 +00:00
|
|
|
VOP_LEASE(fromnd.ni_dvp, td, td->td_ucred, LEASE_WRITE);
|
Make our v_usecount vnode reference count work identically to the
original BSD code. The association between the vnode and the vm_object
no longer includes reference counts. The major difference is that
vm_object's are no longer freed gratuitiously from the vnode, and so
once an object is created for the vnode, it will last as long as the
vnode does.
When a vnode object reference count is incremented, then the underlying
vnode reference count is incremented also. The two "objects" are now
more intimately related, and so the interactions are now much less
complex.
When vnodes are now normally placed onto the free queue with an object still
attached. The rundown of the object happens at vnode rundown time, and
happens with exactly the same filesystem semantics of the original VFS
code. There is absolutely no need for vnode_pager_uncache and other
travesties like that anymore.
A side-effect of these changes is that SMP locking should be much simpler,
the I/O copyin/copyout optimizations work, NFS should be more ponderable,
and further work on layered filesystems should be less frustrating, because
of the totally coherent management of the vnode objects and vnodes.
Please be careful with your system while running this code, but I would
greatly appreciate feedback as soon a reasonably possible.
1998-01-06 05:26:17 +00:00
|
|
|
}
|
1995-03-19 11:16:58 +00:00
|
|
|
if (tvp) {
|
2002-02-27 18:32:23 +00:00
|
|
|
VOP_LEASE(tvp, td, td->td_ucred, LEASE_WRITE);
|
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);
|
1999-12-15 23:02:35 +00:00
|
|
|
NDFREE(&fromnd, NDF_ONLY_PNBUF);
|
|
|
|
NDFREE(&tond, NDF_ONLY_PNBUF);
|
1994-05-24 10:09:53 +00:00
|
|
|
} else {
|
1999-12-15 23:02:35 +00:00
|
|
|
NDFREE(&fromnd, NDF_ONLY_PNBUF);
|
|
|
|
NDFREE(&tond, NDF_ONLY_PNBUF);
|
2005-04-11 09:19:08 +00:00
|
|
|
if (tvp)
|
|
|
|
vput(tvp);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (tdvp == tvp)
|
|
|
|
vrele(tdvp);
|
|
|
|
else
|
|
|
|
vput(tdvp);
|
|
|
|
vrele(fromnd.ni_dvp);
|
|
|
|
vrele(fvp);
|
|
|
|
}
|
|
|
|
vrele(tond.ni_startdir);
|
2002-10-27 23:23:51 +00:00
|
|
|
vn_finished_write(mp);
|
2005-09-01 21:46:33 +00:00
|
|
|
out1:
|
1994-05-24 10:09:53 +00:00
|
|
|
if (fromnd.ni_startdir)
|
|
|
|
vrele(fromnd.ni_startdir);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(fvfslocked);
|
|
|
|
VFS_UNLOCK_GIANT(tvfslocked);
|
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-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
mkdir(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct mkdir_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
|
|
|
int mode;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-12 08:38:13 +00:00
|
|
|
|
2002-09-01 20:37:28 +00:00
|
|
|
return (kern_mkdir(td, uap->path, UIO_USERSPACE, uap->mode));
|
2001-09-12 08:38:13 +00:00
|
|
|
}
|
|
|
|
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct mkdirat_args {
|
|
|
|
int fd;
|
|
|
|
char *path;
|
|
|
|
mode_t mode;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
int
|
|
|
|
mkdirat(struct thread *td, struct mkdirat_args *uap)
|
|
|
|
{
|
|
|
|
|
|
|
|
return (kern_mkdirat(td, uap->fd, uap->path, UIO_USERSPACE, uap->mode));
|
|
|
|
}
|
|
|
|
|
2001-09-12 08:38:13 +00:00
|
|
|
int
|
2002-09-01 20:37:28 +00:00
|
|
|
kern_mkdir(struct thread *td, char *path, enum uio_seg segflg, int mode)
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
return (kern_mkdirat(td, AT_FDCWD, path, segflg, mode));
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_mkdirat(struct thread *td, int fd, char *path, enum uio_seg segflg,
|
|
|
|
int mode)
|
2001-09-12 08:38:13 +00:00
|
|
|
{
|
2000-07-11 22:07:57 +00:00
|
|
|
struct mount *mp;
|
|
|
|
struct vnode *vp;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct vattr vattr;
|
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
2005-01-24 10:25:44 +00:00
|
|
|
int vfslocked;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
AUDIT_ARG(mode, mode);
|
2000-07-11 22:07:57 +00:00
|
|
|
restart:
|
2000-01-10 00:08:53 +00:00
|
|
|
bwillwrite();
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
NDINIT_AT(&nd, CREATE, LOCKPARENT | SAVENAME | MPSAFE | AUDITVNODE1,
|
|
|
|
segflg, path, fd, td);
|
1995-07-31 00:35:58 +00:00
|
|
|
nd.ni_cnd.cn_flags |= WILLBEDIR;
|
1999-01-27 21:50:00 +00:00
|
|
|
if ((error = namei(&nd)) != 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = NDHASGIANT(&nd);
|
1994-05-24 10:09:53 +00:00
|
|
|
vp = nd.ni_vp;
|
|
|
|
if (vp != NULL) {
|
1999-12-15 23:02:35 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
2002-06-28 20:06:47 +00:00
|
|
|
/*
|
|
|
|
* XXX namei called with LOCKPARENT but not LOCKLEAF has
|
|
|
|
* the strange behaviour of leaving the vnode unlocked
|
|
|
|
* if the target is the same vnode as the parent.
|
|
|
|
*/
|
|
|
|
if (vp == nd.ni_dvp)
|
|
|
|
vrele(nd.ni_dvp);
|
|
|
|
else
|
|
|
|
vput(nd.ni_dvp);
|
2006-02-01 00:25:26 +00:00
|
|
|
vrele(vp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (EEXIST);
|
|
|
|
}
|
2000-07-11 22:07:57 +00:00
|
|
|
if (vn_start_write(nd.ni_dvp, &mp, V_NOWAIT) != 0) {
|
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
|
|
|
vput(nd.ni_dvp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2000-07-11 22:07:57 +00:00
|
|
|
if ((error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH)) != 0)
|
|
|
|
return (error);
|
|
|
|
goto restart;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
VATTR_NULL(&vattr);
|
|
|
|
vattr.va_type = VDIR;
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_SLOCK(td->td_proc->p_fd);
|
2001-09-12 08:38:13 +00:00
|
|
|
vattr.va_mode = (mode & ACCESSPERMS) &~ td->td_proc->p_fd->fd_cmask;
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_SUNLOCK(td->td_proc->p_fd);
|
2002-10-19 20:25:57 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_vnode_check_create(td->td_ucred, nd.ni_dvp, &nd.ni_cnd,
|
2002-10-19 20:25:57 +00:00
|
|
|
&vattr);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
#endif
|
2002-02-27 18:32:23 +00:00
|
|
|
VOP_LEASE(nd.ni_dvp, td, td->td_ucred, LEASE_WRITE);
|
1994-05-24 10:09:53 +00:00
|
|
|
error = VOP_MKDIR(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr);
|
2002-10-19 20:25:57 +00:00
|
|
|
#ifdef MAC
|
|
|
|
out:
|
|
|
|
#endif
|
1999-12-15 23:02:35 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
1998-05-07 04:58:58 +00:00
|
|
|
vput(nd.ni_dvp);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (!error)
|
|
|
|
vput(nd.ni_vp);
|
2000-07-11 22:07:57 +00:00
|
|
|
vn_finished_write(mp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
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-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
rmdir(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
struct rmdir_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
2002-09-01 20:37:28 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
return (kern_rmdir(td, uap->path, UIO_USERSPACE));
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_rmdir(struct thread *td, char *path, enum uio_seg pathseg)
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
return (kern_rmdirat(td, AT_FDCWD, path, pathseg));
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_rmdirat(struct thread *td, int fd, char *path, enum uio_seg pathseg)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2000-07-11 22:07:57 +00:00
|
|
|
struct mount *mp;
|
|
|
|
struct vnode *vp;
|
1994-05-24 10:09:53 +00:00
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
2005-01-24 10:25:44 +00:00
|
|
|
int vfslocked;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2000-07-11 22:07:57 +00:00
|
|
|
restart:
|
2000-01-10 00:08:53 +00:00
|
|
|
bwillwrite();
|
Implement the
openat(2), faccessat(2), fchmodat(2), fchownat(2), fstatat(2),
futimesat(2), linkat(2), mkdirat(2), mkfifoat(2), mknodat(2),
readlinkat(2), renameat(2), symlinkat(2)
syscalls.
Based on the submission by rdivacky,
sponsored by Google Summer of Code 2007
Reviewed by: rwatson, rdivacky
Tested by: pho
2008-03-31 12:04:20 +00:00
|
|
|
NDINIT_AT(&nd, DELETE, LOCKPARENT | LOCKLEAF | MPSAFE | AUDITVNODE1,
|
|
|
|
pathseg, path, fd, td);
|
1999-01-27 21:50:00 +00:00
|
|
|
if ((error = namei(&nd)) != 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = NDHASGIANT(&nd);
|
1994-05-24 10:09:53 +00:00
|
|
|
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.
|
|
|
|
*/
|
2002-08-04 10:29:36 +00:00
|
|
|
if (vp->v_vflag & VV_ROOT) {
|
1994-05-24 10:09:53 +00:00
|
|
|
error = EBUSY;
|
2000-07-11 22:07:57 +00:00
|
|
|
goto out;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2002-10-19 20:25:57 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_vnode_check_unlink(td->td_ucred, nd.ni_dvp, vp,
|
2002-10-19 20:25:57 +00:00
|
|
|
&nd.ni_cnd);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
#endif
|
2000-07-11 22:07:57 +00:00
|
|
|
if (vn_start_write(nd.ni_dvp, &mp, V_NOWAIT) != 0) {
|
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
2006-02-01 00:25:26 +00:00
|
|
|
vput(vp);
|
2000-07-11 22:07:57 +00:00
|
|
|
if (nd.ni_dvp == vp)
|
|
|
|
vrele(nd.ni_dvp);
|
|
|
|
else
|
|
|
|
vput(nd.ni_dvp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2000-07-11 22:07:57 +00:00
|
|
|
if ((error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH)) != 0)
|
|
|
|
return (error);
|
|
|
|
goto restart;
|
|
|
|
}
|
2002-02-27 18:32:23 +00:00
|
|
|
VOP_LEASE(nd.ni_dvp, td, td->td_ucred, LEASE_WRITE);
|
|
|
|
VOP_LEASE(vp, td, td->td_ucred, LEASE_WRITE);
|
2000-07-11 22:07:57 +00:00
|
|
|
error = VOP_RMDIR(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd);
|
|
|
|
vn_finished_write(mp);
|
1999-12-15 23:02:35 +00:00
|
|
|
out:
|
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
2006-02-01 00:25:26 +00:00
|
|
|
vput(vp);
|
1998-05-07 04:58:58 +00:00
|
|
|
if (nd.ni_dvp == vp)
|
|
|
|
vrele(nd.ni_dvp);
|
|
|
|
else
|
|
|
|
vput(nd.ni_dvp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef COMPAT_43
|
|
|
|
/*
|
2002-05-16 21:28:32 +00:00
|
|
|
* Read a block of directory entries in a filesystem independent format.
|
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 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
|
2001-09-12 08:38:13 +00:00
|
|
|
ogetdirentries(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct ogetdirentries_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
int fd;
|
|
|
|
char *buf;
|
|
|
|
u_int count;
|
|
|
|
long *basep;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1998-11-03 08:01:48 +00:00
|
|
|
struct vnode *vp;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct file *fp;
|
|
|
|
struct uio auio, kuio;
|
|
|
|
struct iovec aiov, kiov;
|
|
|
|
struct dirent *dp, *edp;
|
|
|
|
caddr_t dirbuf;
|
- Add conditional VFS Giant locking to getdents_common() (linux ABIs),
ibcs2_getdents(), ibcs2_read(), ogetdirentries(), svr4_sys_getdents(),
and svr4_sys_getdents64() similar to that in getdirentries().
- Mark ibcs2_getdents(), ibcs2_read(), linux_getdents(), linux_getdents64(),
linux_readdir(), ogetdirentries(), svr4_sys_getdents(), and
svr4_sys_getdents64() MPSAFE.
2006-07-11 20:52:08 +00:00
|
|
|
int error, eofflag, readcnt, vfslocked;
|
1994-05-24 10:09:53 +00:00
|
|
|
long loff;
|
|
|
|
|
2001-08-10 22:14:18 +00:00
|
|
|
/* XXX arbitrary sanity limit on `count'. */
|
2002-12-14 01:56:26 +00:00
|
|
|
if (uap->count > 64 * 1024)
|
2001-08-10 22:14:18 +00:00
|
|
|
return (EINVAL);
|
2002-12-14 01:56:26 +00:00
|
|
|
if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2002-01-13 11:58:06 +00:00
|
|
|
if ((fp->f_flag & FREAD) == 0) {
|
|
|
|
fdrop(fp, td);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (EBADF);
|
2002-01-13 11:58:06 +00:00
|
|
|
}
|
2003-06-22 08:41:43 +00:00
|
|
|
vp = fp->f_vnode;
|
1997-02-10 02:22:35 +00:00
|
|
|
unionread:
|
- Add conditional VFS Giant locking to getdents_common() (linux ABIs),
ibcs2_getdents(), ibcs2_read(), ogetdirentries(), svr4_sys_getdents(),
and svr4_sys_getdents64() similar to that in getdirentries().
- Mark ibcs2_getdents(), ibcs2_read(), linux_getdents(), linux_getdents64(),
linux_readdir(), ogetdirentries(), svr4_sys_getdents(), and
svr4_sys_getdents64() MPSAFE.
2006-07-11 20:52:08 +00:00
|
|
|
vfslocked = VFS_LOCK_GIANT(vp->v_mount);
|
2002-01-13 11:58:06 +00:00
|
|
|
if (vp->v_type != VDIR) {
|
- Add conditional VFS Giant locking to getdents_common() (linux ABIs),
ibcs2_getdents(), ibcs2_read(), ogetdirentries(), svr4_sys_getdents(),
and svr4_sys_getdents64() similar to that in getdirentries().
- Mark ibcs2_getdents(), ibcs2_read(), linux_getdents(), linux_getdents64(),
linux_readdir(), ogetdirentries(), svr4_sys_getdents(), and
svr4_sys_getdents64() MPSAFE.
2006-07-11 20:52:08 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2002-01-13 11:58:06 +00:00
|
|
|
fdrop(fp, td);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (EINVAL);
|
2002-01-13 11:58:06 +00:00
|
|
|
}
|
2002-12-14 01:56:26 +00:00
|
|
|
aiov.iov_base = uap->buf;
|
|
|
|
aiov.iov_len = 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;
|
2001-09-12 08:38:13 +00:00
|
|
|
auio.uio_td = td;
|
2002-12-14 01:56:26 +00:00
|
|
|
auio.uio_resid = uap->count;
|
2008-01-10 01:10:58 +00:00
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
|
1994-05-24 10:09:53 +00:00
|
|
|
loff = auio.uio_offset = fp->f_offset;
|
2002-08-01 20:44:52 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_vnode_check_readdir(td->td_ucred, vp);
|
2002-08-01 20:44:52 +00:00
|
|
|
if (error) {
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(vp, 0);
|
- Add conditional VFS Giant locking to getdents_common() (linux ABIs),
ibcs2_getdents(), ibcs2_read(), ogetdirentries(), svr4_sys_getdents(),
and svr4_sys_getdents64() similar to that in getdirentries().
- Mark ibcs2_getdents(), ibcs2_read(), linux_getdents(), linux_getdents64(),
linux_readdir(), ogetdirentries(), svr4_sys_getdents(), and
svr4_sys_getdents64() MPSAFE.
2006-07-11 20:52:08 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2002-08-01 20:44:52 +00:00
|
|
|
fdrop(fp, td);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
# 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;
|
2002-12-14 01:56:26 +00:00
|
|
|
kiov.iov_len = uap->count;
|
2003-02-19 05:47:46 +00:00
|
|
|
MALLOC(dirbuf, caddr_t, 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) {
|
2002-12-14 01:56:26 +00:00
|
|
|
readcnt = 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);
|
|
|
|
}
|
2002-01-13 11:58:06 +00:00
|
|
|
if (error) {
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(vp, 0);
|
- Add conditional VFS Giant locking to getdents_common() (linux ABIs),
ibcs2_getdents(), ibcs2_read(), ogetdirentries(), svr4_sys_getdents(),
and svr4_sys_getdents64() similar to that in getdirentries().
- Mark ibcs2_getdents(), ibcs2_read(), linux_getdents(), linux_getdents64(),
linux_readdir(), ogetdirentries(), svr4_sys_getdents(), and
svr4_sys_getdents64() MPSAFE.
2006-07-11 20:52:08 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2002-01-13 11:58:06 +00:00
|
|
|
fdrop(fp, td);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2002-01-13 11:58:06 +00:00
|
|
|
}
|
2007-02-19 10:56:09 +00:00
|
|
|
if (uap->count == auio.uio_resid &&
|
|
|
|
(vp->v_vflag & VV_ROOT) &&
|
|
|
|
(vp->v_mount->mnt_flag & MNT_UNION)) {
|
|
|
|
struct vnode *tvp = vp;
|
|
|
|
vp = vp->v_mount->mnt_vnodecovered;
|
|
|
|
VREF(vp);
|
|
|
|
fp->f_vnode = vp;
|
|
|
|
fp->f_data = vp;
|
|
|
|
fp->f_offset = 0;
|
|
|
|
vput(tvp);
|
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
|
|
|
goto unionread;
|
1999-02-27 07:06:05 +00:00
|
|
|
}
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(vp, 0);
|
- Add conditional VFS Giant locking to getdents_common() (linux ABIs),
ibcs2_getdents(), ibcs2_read(), ogetdirentries(), svr4_sys_getdents(),
and svr4_sys_getdents64() similar to that in getdirentries().
- Mark ibcs2_getdents(), ibcs2_read(), linux_getdents(), linux_getdents64(),
linux_readdir(), ogetdirentries(), svr4_sys_getdents(), and
svr4_sys_getdents64() MPSAFE.
2006-07-11 20:52:08 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2002-12-14 01:56:26 +00:00
|
|
|
error = copyout(&loff, uap->basep, sizeof(long));
|
2002-01-13 11:58:06 +00:00
|
|
|
fdrop(fp, td);
|
2002-12-14 01:56:26 +00:00
|
|
|
td->td_retval[0] = 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
|
|
|
|
|
|
|
/*
|
2002-05-16 21:28:32 +00:00
|
|
|
* Read a block of directory entries in a filesystem independent format.
|
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 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
|
2001-09-12 08:38:13 +00:00
|
|
|
getdirentries(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct getdirentries_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
int fd;
|
|
|
|
char *buf;
|
|
|
|
u_int count;
|
|
|
|
long *basep;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1998-11-03 08:01:48 +00:00
|
|
|
struct vnode *vp;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct file *fp;
|
|
|
|
struct uio auio;
|
|
|
|
struct iovec aiov;
|
2005-01-24 10:25:44 +00:00
|
|
|
int vfslocked;
|
1994-05-24 10:09:53 +00:00
|
|
|
long loff;
|
1997-02-10 02:22:35 +00:00
|
|
|
int error, eofflag;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
AUDIT_ARG(fd, uap->fd);
|
2002-12-14 01:56:26 +00:00
|
|
|
if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2002-01-13 11:58:06 +00:00
|
|
|
if ((fp->f_flag & FREAD) == 0) {
|
|
|
|
fdrop(fp, td);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (EBADF);
|
2002-01-13 11:58:06 +00:00
|
|
|
}
|
2003-06-22 08:41:43 +00:00
|
|
|
vp = fp->f_vnode;
|
1994-05-24 10:09:53 +00:00
|
|
|
unionread:
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = VFS_LOCK_GIANT(vp->v_mount);
|
2002-01-13 11:58:06 +00:00
|
|
|
if (vp->v_type != VDIR) {
|
2007-02-19 10:56:09 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2005-01-24 10:25:44 +00:00
|
|
|
error = EINVAL;
|
|
|
|
goto fail;
|
2002-01-13 11:58:06 +00:00
|
|
|
}
|
2002-12-14 01:56:26 +00:00
|
|
|
aiov.iov_base = uap->buf;
|
|
|
|
aiov.iov_len = 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;
|
2001-09-12 08:38:13 +00:00
|
|
|
auio.uio_td = td;
|
2002-12-14 01:56:26 +00:00
|
|
|
auio.uio_resid = uap->count;
|
2008-01-10 01:10:58 +00:00
|
|
|
/* vn_lock(vp, LK_SHARED | LK_RETRY); */
|
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
AUDIT_ARG(vnode, vp, ARG_VNODE1);
|
1994-05-24 10:09:53 +00:00
|
|
|
loff = auio.uio_offset = fp->f_offset;
|
2002-08-01 20:44:52 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_vnode_check_readdir(td->td_ucred, vp);
|
2002-08-01 20:44:52 +00:00
|
|
|
if (error == 0)
|
|
|
|
#endif
|
|
|
|
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;
|
2007-02-19 10:56:09 +00:00
|
|
|
if (error) {
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(vp, 0);
|
2007-02-19 10:56:09 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
if (uap->count == auio.uio_resid &&
|
|
|
|
(vp->v_vflag & VV_ROOT) &&
|
|
|
|
(vp->v_mount->mnt_flag & MNT_UNION)) {
|
|
|
|
struct vnode *tvp = vp;
|
|
|
|
vp = vp->v_mount->mnt_vnodecovered;
|
|
|
|
VREF(vp);
|
|
|
|
fp->f_vnode = vp;
|
|
|
|
fp->f_data = vp;
|
|
|
|
fp->f_offset = 0;
|
|
|
|
vput(tvp);
|
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
|
|
|
goto unionread;
|
1999-02-27 07:06:05 +00:00
|
|
|
}
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(vp, 0);
|
2007-02-19 10:56:09 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2002-12-14 01:56:26 +00:00
|
|
|
if (uap->basep != NULL) {
|
|
|
|
error = copyout(&loff, uap->basep, sizeof(long));
|
1998-05-11 03:55:28 +00:00
|
|
|
}
|
2002-12-14 01:56:26 +00:00
|
|
|
td->td_retval[0] = uap->count - auio.uio_resid;
|
2005-01-24 10:25:44 +00:00
|
|
|
fail:
|
2002-01-13 11:58:06 +00:00
|
|
|
fdrop(fp, td);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
2007-03-05 13:10:58 +00:00
|
|
|
|
1998-05-11 03:55:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct getdents_args {
|
|
|
|
int fd;
|
|
|
|
char *buf;
|
|
|
|
size_t count;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
getdents(td, uap)
|
|
|
|
struct thread *td;
|
1998-05-11 03:55:28 +00:00
|
|
|
register struct getdents_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
int fd;
|
|
|
|
char *buf;
|
|
|
|
u_int count;
|
1998-05-11 03:55:28 +00:00
|
|
|
} */ *uap;
|
|
|
|
{
|
|
|
|
struct getdirentries_args ap;
|
|
|
|
ap.fd = uap->fd;
|
|
|
|
ap.buf = uap->buf;
|
|
|
|
ap.count = uap->count;
|
|
|
|
ap.basep = NULL;
|
2004-01-11 19:52:10 +00:00
|
|
|
return (getdirentries(td, &ap));
|
1998-05-11 03:55:28 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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
|
2001-09-12 08:38:13 +00:00
|
|
|
umask(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
struct umask_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
int newmask;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register struct filedesc *fdp;
|
|
|
|
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XLOCK(td->td_proc->p_fd);
|
2001-09-12 08:38:13 +00:00
|
|
|
fdp = td->td_proc->p_fd;
|
|
|
|
td->td_retval[0] = fdp->fd_cmask;
|
2002-12-14 01:56:26 +00:00
|
|
|
fdp->fd_cmask = uap->newmask & ALLPERMS;
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(td->td_proc->p_fd);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2007-03-05 13:10:58 +00:00
|
|
|
* Void all references to file by ripping underlying filesystem away from
|
|
|
|
* vnode.
|
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 revoke_args {
|
|
|
|
char *path;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
revoke(td, uap)
|
|
|
|
struct thread *td;
|
1997-02-10 02:22:35 +00:00
|
|
|
register struct revoke_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
char *path;
|
1997-02-10 02:22:35 +00:00
|
|
|
} */ *uap;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2000-07-11 22:07:57 +00:00
|
|
|
struct vnode *vp;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct vattr vattr;
|
|
|
|
int error;
|
|
|
|
struct nameidata nd;
|
2005-01-24 10:25:44 +00:00
|
|
|
int vfslocked;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | MPSAFE | AUDITVNODE1,
|
|
|
|
UIO_USERSPACE, uap->path, td);
|
1999-01-27 21:50:00 +00:00
|
|
|
if ((error = namei(&nd)) != 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = NDHASGIANT(&nd);
|
1994-05-24 10:09:53 +00:00
|
|
|
vp = nd.ni_vp;
|
1999-12-15 23:02:35 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
2000-11-02 21:14:13 +00:00
|
|
|
if (vp->v_type != VCHR) {
|
2005-01-24 10:25:44 +00:00
|
|
|
error = EINVAL;
|
2005-03-13 11:45:51 +00:00
|
|
|
goto out;
|
1999-01-24 06:28:37 +00:00
|
|
|
}
|
Introduce support for Mandatory Access Control and extensible
kernel access control.
Invoke appropriate MAC entry points to authorize the following
operations:
truncate on open() (write)
access() (access)
readlink() (readlink)
chflags(), lchflags(), fchflags() (setflag)
chmod(), fchmod(), lchmod() (setmode)
chown(), fchown(), lchown() (setowner)
utimes(), lutimes(), futimes() (setutimes)
truncate(), ftrunfcate() (write)
revoke() (revoke)
fhopen() (open)
truncate on fhopen() (write)
extattr_set_fd, extattr_set_file() (setextattr)
extattr_get_fd, extattr_get_file() (getextattr)
extattr_delete_fd(), extattr_delete_file() (setextattr)
These entry points permit MAC policies to enforce a variety of
protections on vnodes. More vnode checks to come, especially in
non-native ABIs.
Obtained from: TrustedBSD Project
Sponsored by: DARPA, NAI Labs
2002-08-01 15:37:12 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_vnode_check_revoke(td->td_ucred, vp);
|
2005-01-24 10:25:44 +00:00
|
|
|
if (error)
|
2005-03-13 11:45:51 +00:00
|
|
|
goto out;
|
Introduce support for Mandatory Access Control and extensible
kernel access control.
Invoke appropriate MAC entry points to authorize the following
operations:
truncate on open() (write)
access() (access)
readlink() (readlink)
chflags(), lchflags(), fchflags() (setflag)
chmod(), fchmod(), lchmod() (setmode)
chown(), fchown(), lchown() (setowner)
utimes(), lutimes(), futimes() (setutimes)
truncate(), ftrunfcate() (write)
revoke() (revoke)
fhopen() (open)
truncate on fhopen() (write)
extattr_set_fd, extattr_set_file() (setextattr)
extattr_get_fd, extattr_get_file() (getextattr)
extattr_delete_fd(), extattr_delete_file() (setextattr)
These entry points permit MAC policies to enforce a variety of
protections on vnodes. More vnode checks to come, especially in
non-native ABIs.
Obtained from: TrustedBSD Project
Sponsored by: DARPA, NAI Labs
2002-08-01 15:37:12 +00:00
|
|
|
#endif
|
2008-08-28 15:23:18 +00:00
|
|
|
error = VOP_GETATTR(vp, &vattr, td->td_ucred);
|
2005-01-24 10:25:44 +00:00
|
|
|
if (error)
|
2005-03-13 11:45:51 +00:00
|
|
|
goto out;
|
2002-02-27 18:32:23 +00:00
|
|
|
if (td->td_ucred->cr_uid != vattr.va_uid) {
|
2007-06-12 00:12:01 +00:00
|
|
|
error = priv_check(td, PRIV_VFS_ADMIN);
|
2005-01-24 10:25:44 +00:00
|
|
|
if (error)
|
2005-03-13 11:45:51 +00:00
|
|
|
goto out;
|
2001-10-01 20:01:07 +00:00
|
|
|
}
|
1999-08-26 14:53:31 +00:00
|
|
|
if (vcount(vp) > 1)
|
1997-02-10 02:22:35 +00:00
|
|
|
VOP_REVOKE(vp, REVOKEALL);
|
2005-03-13 11:45:51 +00:00
|
|
|
out:
|
2005-01-24 10:25:44 +00:00
|
|
|
vput(vp);
|
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Convert a user file descriptor to a kernel file entry.
|
2004-02-17 12:30:32 +00:00
|
|
|
* A reference on the file entry is held upon returning.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
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
|
|
|
{
|
2002-01-13 11:58:06 +00:00
|
|
|
int error;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct file *fp;
|
|
|
|
|
2002-01-13 11:58:06 +00:00
|
|
|
fp = NULL;
|
|
|
|
if (fdp == NULL)
|
|
|
|
error = EBADF;
|
|
|
|
else {
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_SLOCK(fdp);
|
2002-01-13 11:58:06 +00:00
|
|
|
if ((u_int)fd >= fdp->fd_nfiles ||
|
|
|
|
(fp = fdp->fd_ofiles[fd]) == NULL)
|
|
|
|
error = EBADF;
|
2003-07-04 12:20:27 +00:00
|
|
|
else if (fp->f_vnode == NULL) {
|
2002-01-13 11:58:06 +00:00
|
|
|
fp = NULL;
|
|
|
|
error = EINVAL;
|
|
|
|
} else {
|
|
|
|
fhold(fp);
|
|
|
|
error = 0;
|
|
|
|
}
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_SUNLOCK(fdp);
|
2002-01-13 11:58:06 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
*fpp = fp;
|
2002-01-13 11:58:06 +00:00
|
|
|
return (error);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2003-07-04 12:20:27 +00:00
|
|
|
|
1999-09-11 00:46:08 +00:00
|
|
|
/*
|
2007-03-05 13:10:58 +00:00
|
|
|
* Get an (NFS) file handle.
|
1999-09-11 00:46:08 +00:00
|
|
|
*/
|
2004-04-05 10:15:53 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct lgetfh_args {
|
|
|
|
char *fname;
|
|
|
|
fhandle_t *fhp;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
int
|
|
|
|
lgetfh(td, uap)
|
|
|
|
struct thread *td;
|
|
|
|
register struct lgetfh_args *uap;
|
|
|
|
{
|
|
|
|
struct nameidata nd;
|
|
|
|
fhandle_t fh;
|
|
|
|
register struct vnode *vp;
|
2005-01-24 10:25:44 +00:00
|
|
|
int vfslocked;
|
2004-04-05 10:15:53 +00:00
|
|
|
int error;
|
|
|
|
|
2006-11-06 13:42:10 +00:00
|
|
|
error = priv_check(td, PRIV_VFS_GETFH);
|
2004-04-05 10:15:53 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | MPSAFE | AUDITVNODE1,
|
2005-01-24 10:25:44 +00:00
|
|
|
UIO_USERSPACE, uap->fname, td);
|
2004-04-05 10:15:53 +00:00
|
|
|
error = namei(&nd);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = NDHASGIANT(&nd);
|
2004-04-05 10:15:53 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
|
|
|
vp = nd.ni_vp;
|
|
|
|
bzero(&fh, sizeof(fh));
|
|
|
|
fh.fh_fsid = vp->v_mount->mnt_stat.f_fsid;
|
2007-02-15 22:08:35 +00:00
|
|
|
error = VOP_VPTOFH(vp, &fh.fh_fid);
|
2004-04-05 10:15:53 +00:00
|
|
|
vput(vp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2004-04-05 10:15:53 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
error = copyout(&fh, uap->fhp, sizeof (fh));
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
1999-09-11 00:46:08 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct getfh_args {
|
|
|
|
char *fname;
|
|
|
|
fhandle_t *fhp;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
getfh(td, uap)
|
|
|
|
struct thread *td;
|
1999-09-11 00:46:08 +00:00
|
|
|
register struct getfh_args *uap;
|
|
|
|
{
|
|
|
|
struct nameidata nd;
|
|
|
|
fhandle_t fh;
|
|
|
|
register struct vnode *vp;
|
2005-01-24 10:25:44 +00:00
|
|
|
int vfslocked;
|
1999-09-11 00:46:08 +00:00
|
|
|
int error;
|
|
|
|
|
2006-11-06 13:42:10 +00:00
|
|
|
error = priv_check(td, PRIV_VFS_GETFH);
|
1999-09-11 00:46:08 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
Add pathname and/or vnode argument auditing for the following system calls:
quotactl, statfs, fstatfs, fchdir, chdir, chroot, open, mknod, mkfifo,
link, symlink, undelete, unlink, access, eaccess, stat, lstat, pathconf,
readlink, chflags, lchflags, fchflags, chmod, lchmod, fchmod, chown,
lchown, fchown, utimes, lutimes, futimes, truncate, ftruncate, fsync,
rename, mkdir, rmdir, getdirentries, revoke, lgetfh, getfh, extattrctl,
extattr_set_file, extattr_set_link, extattr_get_file, extattr_get_link,
extattr_delete_file, extattr_delete_link, extattr_list_file, extattr_list_link.
In many cases the pathname and vnode auditing is done within namei lookup
instead of directly in the system call.
Audit the remaining arguments to these system calls:
fstatfs, fchdir, open, mknod, chflags, lchflags, fchflags, chmod, lchmod,
fchmod, chown, lchown, fchown, futimes, ftruncate, fsync, mkdir,
getdirentries.
2006-02-22 16:04:20 +00:00
|
|
|
NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | MPSAFE | AUDITVNODE1,
|
2005-01-24 10:25:44 +00:00
|
|
|
UIO_USERSPACE, uap->fname, td);
|
1999-09-11 00:46:08 +00:00
|
|
|
error = namei(&nd);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
2005-01-24 10:25:44 +00:00
|
|
|
vfslocked = NDHASGIANT(&nd);
|
1999-12-15 23:02:35 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
1999-09-11 00:46:08 +00:00
|
|
|
vp = nd.ni_vp;
|
|
|
|
bzero(&fh, sizeof(fh));
|
|
|
|
fh.fh_fsid = vp->v_mount->mnt_stat.f_fsid;
|
2007-02-15 22:08:35 +00:00
|
|
|
error = VOP_VPTOFH(vp, &fh.fh_fid);
|
1999-09-11 00:46:08 +00:00
|
|
|
vput(vp);
|
2005-01-24 10:25:44 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
1999-09-11 00:46:08 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
error = copyout(&fh, uap->fhp, sizeof (fh));
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2006-11-06 13:42:10 +00:00
|
|
|
* syscall for the rpc.lockd to use to translate a NFS file handle into an
|
|
|
|
* open descriptor.
|
1999-09-11 00:46:08 +00:00
|
|
|
*
|
2006-11-06 13:42:10 +00:00
|
|
|
* warning: do not remove the priv_check() call or this becomes one giant
|
1999-09-11 00:46:08 +00:00
|
|
|
* security hole.
|
|
|
|
*/
|
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct fhopen_args {
|
|
|
|
const struct fhandle *u_fhp;
|
|
|
|
int flags;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
fhopen(td, uap)
|
|
|
|
struct thread *td;
|
1999-09-11 00:46:08 +00:00
|
|
|
struct fhopen_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
const struct fhandle *u_fhp;
|
|
|
|
int flags;
|
1999-09-11 00:46:08 +00:00
|
|
|
} */ *uap;
|
|
|
|
{
|
2001-09-12 08:38:13 +00:00
|
|
|
struct proc *p = td->td_proc;
|
1999-09-11 00:46:08 +00:00
|
|
|
struct mount *mp;
|
|
|
|
struct vnode *vp;
|
|
|
|
struct fhandle fhp;
|
|
|
|
struct vattr vat;
|
|
|
|
struct vattr *vap = &vat;
|
|
|
|
struct flock lf;
|
|
|
|
struct file *fp;
|
|
|
|
register struct filedesc *fdp = p->p_fd;
|
|
|
|
int fmode, mode, error, type;
|
2004-01-11 19:52:10 +00:00
|
|
|
struct file *nfp;
|
2006-03-21 23:58:37 +00:00
|
|
|
int vfslocked;
|
1999-09-11 00:46:08 +00:00
|
|
|
int indx;
|
|
|
|
|
2006-11-06 13:42:10 +00:00
|
|
|
error = priv_check(td, PRIV_VFS_FHOPEN);
|
1999-09-11 00:46:08 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
2002-12-14 01:56:26 +00:00
|
|
|
fmode = FFLAGS(uap->flags);
|
1999-09-11 00:46:08 +00:00
|
|
|
/* why not allow a non-read/write open for our lockd? */
|
|
|
|
if (((fmode & (FREAD | FWRITE)) == 0) || (fmode & O_CREAT))
|
|
|
|
return (EINVAL);
|
2002-12-14 01:56:26 +00:00
|
|
|
error = copyin(uap->u_fhp, &fhp, sizeof(fhp));
|
1999-09-11 00:46:08 +00:00
|
|
|
if (error)
|
|
|
|
return(error);
|
|
|
|
/* find the mount point */
|
|
|
|
mp = vfs_getvfs(&fhp.fh_fsid);
|
2006-03-31 03:54:20 +00:00
|
|
|
if (mp == NULL)
|
|
|
|
return (ESTALE);
|
2006-03-21 23:58:37 +00:00
|
|
|
vfslocked = VFS_LOCK_GIANT(mp);
|
1999-09-11 00:46:08 +00:00
|
|
|
/* now give me my vnode, it gets returned to me locked */
|
|
|
|
error = VFS_FHTOVP(mp, &fhp.fh_fid, &vp);
|
|
|
|
if (error)
|
2005-05-28 12:58:54 +00:00
|
|
|
goto out;
|
2004-01-11 19:52:10 +00:00
|
|
|
/*
|
1999-09-11 00:46:08 +00:00
|
|
|
* from now on we have to make sure not
|
|
|
|
* to forget about the vnode
|
2004-01-11 19:52:10 +00:00
|
|
|
* any error that causes an abort must vput(vp)
|
1999-09-11 00:46:08 +00:00
|
|
|
* just set error = err and 'goto bad;'.
|
|
|
|
*/
|
|
|
|
|
2004-01-11 19:52:10 +00:00
|
|
|
/*
|
|
|
|
* from vn_open
|
1999-09-11 00:46:08 +00:00
|
|
|
*/
|
|
|
|
if (vp->v_type == VLNK) {
|
|
|
|
error = EMLINK;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
if (vp->v_type == VSOCK) {
|
|
|
|
error = EOPNOTSUPP;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
mode = 0;
|
|
|
|
if (fmode & (FWRITE | O_TRUNC)) {
|
|
|
|
if (vp->v_type == VDIR) {
|
|
|
|
error = EISDIR;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
error = vn_writechk(vp);
|
|
|
|
if (error)
|
|
|
|
goto bad;
|
|
|
|
mode |= VWRITE;
|
|
|
|
}
|
|
|
|
if (fmode & FREAD)
|
|
|
|
mode |= VREAD;
|
2002-07-22 12:51:06 +00:00
|
|
|
if (fmode & O_APPEND)
|
|
|
|
mode |= VAPPEND;
|
Introduce support for Mandatory Access Control and extensible
kernel access control.
Invoke appropriate MAC entry points to authorize the following
operations:
truncate on open() (write)
access() (access)
readlink() (readlink)
chflags(), lchflags(), fchflags() (setflag)
chmod(), fchmod(), lchmod() (setmode)
chown(), fchown(), lchown() (setowner)
utimes(), lutimes(), futimes() (setutimes)
truncate(), ftrunfcate() (write)
revoke() (revoke)
fhopen() (open)
truncate on fhopen() (write)
extattr_set_fd, extattr_set_file() (setextattr)
extattr_get_fd, extattr_get_file() (getextattr)
extattr_delete_fd(), extattr_delete_file() (setextattr)
These entry points permit MAC policies to enforce a variety of
protections on vnodes. More vnode checks to come, especially in
non-native ABIs.
Obtained from: TrustedBSD Project
Sponsored by: DARPA, NAI Labs
2002-08-01 15:37:12 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_vnode_check_open(td->td_ucred, vp, mode);
|
Introduce support for Mandatory Access Control and extensible
kernel access control.
Invoke appropriate MAC entry points to authorize the following
operations:
truncate on open() (write)
access() (access)
readlink() (readlink)
chflags(), lchflags(), fchflags() (setflag)
chmod(), fchmod(), lchmod() (setmode)
chown(), fchown(), lchown() (setowner)
utimes(), lutimes(), futimes() (setutimes)
truncate(), ftrunfcate() (write)
revoke() (revoke)
fhopen() (open)
truncate on fhopen() (write)
extattr_set_fd, extattr_set_file() (setextattr)
extattr_get_fd, extattr_get_file() (getextattr)
extattr_delete_fd(), extattr_delete_file() (setextattr)
These entry points permit MAC policies to enforce a variety of
protections on vnodes. More vnode checks to come, especially in
non-native ABIs.
Obtained from: TrustedBSD Project
Sponsored by: DARPA, NAI Labs
2002-08-01 15:37:12 +00:00
|
|
|
if (error)
|
|
|
|
goto bad;
|
|
|
|
#endif
|
1999-09-11 00:46:08 +00:00
|
|
|
if (mode) {
|
2002-02-27 18:32:23 +00:00
|
|
|
error = VOP_ACCESS(vp, mode, td->td_ucred, td);
|
1999-09-11 00:46:08 +00:00
|
|
|
if (error)
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
if (fmode & O_TRUNC) {
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(vp, 0); /* XXX */
|
2000-07-11 22:07:57 +00:00
|
|
|
if ((error = vn_start_write(NULL, &mp, V_WAIT | PCATCH)) != 0) {
|
|
|
|
vrele(vp);
|
2005-05-28 12:58:54 +00:00
|
|
|
goto out;
|
2000-07-11 22:07:57 +00:00
|
|
|
}
|
2002-02-27 18:32:23 +00:00
|
|
|
VOP_LEASE(vp, td, td->td_ucred, LEASE_WRITE);
|
2008-01-10 01:10:58 +00:00
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); /* XXX */
|
Introduce support for Mandatory Access Control and extensible
kernel access control.
Invoke appropriate MAC entry points to authorize the following
operations:
truncate on open() (write)
access() (access)
readlink() (readlink)
chflags(), lchflags(), fchflags() (setflag)
chmod(), fchmod(), lchmod() (setmode)
chown(), fchown(), lchown() (setowner)
utimes(), lutimes(), futimes() (setutimes)
truncate(), ftrunfcate() (write)
revoke() (revoke)
fhopen() (open)
truncate on fhopen() (write)
extattr_set_fd, extattr_set_file() (setextattr)
extattr_get_fd, extattr_get_file() (getextattr)
extattr_delete_fd(), extattr_delete_file() (setextattr)
These entry points permit MAC policies to enforce a variety of
protections on vnodes. More vnode checks to come, especially in
non-native ABIs.
Obtained from: TrustedBSD Project
Sponsored by: DARPA, NAI Labs
2002-08-01 15:37:12 +00:00
|
|
|
#ifdef MAC
|
2002-08-19 19:04:53 +00:00
|
|
|
/*
|
|
|
|
* We don't yet have fp->f_cred, so use td->td_ucred, which
|
|
|
|
* should be right.
|
|
|
|
*/
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_vnode_check_write(td->td_ucred, td->td_ucred, vp);
|
Introduce support for Mandatory Access Control and extensible
kernel access control.
Invoke appropriate MAC entry points to authorize the following
operations:
truncate on open() (write)
access() (access)
readlink() (readlink)
chflags(), lchflags(), fchflags() (setflag)
chmod(), fchmod(), lchmod() (setmode)
chown(), fchown(), lchown() (setowner)
utimes(), lutimes(), futimes() (setutimes)
truncate(), ftrunfcate() (write)
revoke() (revoke)
fhopen() (open)
truncate on fhopen() (write)
extattr_set_fd, extattr_set_file() (setextattr)
extattr_get_fd, extattr_get_file() (getextattr)
extattr_delete_fd(), extattr_delete_file() (setextattr)
These entry points permit MAC policies to enforce a variety of
protections on vnodes. More vnode checks to come, especially in
non-native ABIs.
Obtained from: TrustedBSD Project
Sponsored by: DARPA, NAI Labs
2002-08-01 15:37:12 +00:00
|
|
|
if (error == 0) {
|
|
|
|
#endif
|
|
|
|
VATTR_NULL(vap);
|
|
|
|
vap->va_size = 0;
|
2008-08-28 15:23:18 +00:00
|
|
|
error = VOP_SETATTR(vp, vap, td->td_ucred);
|
Introduce support for Mandatory Access Control and extensible
kernel access control.
Invoke appropriate MAC entry points to authorize the following
operations:
truncate on open() (write)
access() (access)
readlink() (readlink)
chflags(), lchflags(), fchflags() (setflag)
chmod(), fchmod(), lchmod() (setmode)
chown(), fchown(), lchown() (setowner)
utimes(), lutimes(), futimes() (setutimes)
truncate(), ftrunfcate() (write)
revoke() (revoke)
fhopen() (open)
truncate on fhopen() (write)
extattr_set_fd, extattr_set_file() (setextattr)
extattr_get_fd, extattr_get_file() (getextattr)
extattr_delete_fd(), extattr_delete_file() (setextattr)
These entry points permit MAC policies to enforce a variety of
protections on vnodes. More vnode checks to come, especially in
non-native ABIs.
Obtained from: TrustedBSD Project
Sponsored by: DARPA, NAI Labs
2002-08-01 15:37:12 +00:00
|
|
|
#ifdef MAC
|
|
|
|
}
|
|
|
|
#endif
|
2000-07-11 22:07:57 +00:00
|
|
|
vn_finished_write(mp);
|
1999-09-11 00:46:08 +00:00
|
|
|
if (error)
|
|
|
|
goto bad;
|
|
|
|
}
|
2007-05-31 11:51:53 +00:00
|
|
|
error = VOP_OPEN(vp, fmode, td->td_ucred, td, NULL);
|
1999-09-11 00:46:08 +00:00
|
|
|
if (error)
|
|
|
|
goto bad;
|
2005-01-24 23:53:54 +00:00
|
|
|
|
1999-09-11 00:46:08 +00:00
|
|
|
if (fmode & FWRITE)
|
|
|
|
vp->v_writecount++;
|
|
|
|
|
|
|
|
/*
|
2004-01-11 19:52:10 +00:00
|
|
|
* end of vn_open code
|
1999-09-11 00:46:08 +00:00
|
|
|
*/
|
|
|
|
|
2001-10-24 18:32:17 +00:00
|
|
|
if ((error = falloc(td, &nfp, &indx)) != 0) {
|
|
|
|
if (fmode & FWRITE)
|
|
|
|
vp->v_writecount--;
|
1999-09-11 00:46:08 +00:00
|
|
|
goto bad;
|
2001-10-24 18:32:17 +00:00
|
|
|
}
|
2003-10-19 20:41:07 +00:00
|
|
|
/* An extra reference on `nfp' has been held for us by falloc(). */
|
2004-01-11 19:52:10 +00:00
|
|
|
fp = nfp;
|
2003-06-22 08:41:43 +00:00
|
|
|
nfp->f_vnode = vp;
|
2007-12-30 01:42:15 +00:00
|
|
|
finit(nfp, fmode & FMASK, DTYPE_VNODE, vp, &vnops);
|
1999-09-11 00:46:08 +00:00
|
|
|
if (fmode & (O_EXLOCK | O_SHLOCK)) {
|
|
|
|
lf.l_whence = SEEK_SET;
|
|
|
|
lf.l_start = 0;
|
|
|
|
lf.l_len = 0;
|
|
|
|
if (fmode & O_EXLOCK)
|
|
|
|
lf.l_type = F_WRLCK;
|
|
|
|
else
|
|
|
|
lf.l_type = F_RDLCK;
|
|
|
|
type = F_FLOCK;
|
|
|
|
if ((fmode & FNONBLOCK) == 0)
|
|
|
|
type |= F_WAIT;
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(vp, 0);
|
2002-06-28 23:02:38 +00:00
|
|
|
if ((error = VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf,
|
|
|
|
type)) != 0) {
|
2000-11-18 21:01:04 +00:00
|
|
|
/*
|
|
|
|
* The lock request failed. Normally close the
|
|
|
|
* descriptor but handle the case where someone might
|
|
|
|
* have dup()d or close()d it when we weren't looking.
|
|
|
|
*/
|
2004-11-07 22:16:07 +00:00
|
|
|
fdclose(fdp, fp, indx, td);
|
|
|
|
|
2000-11-18 21:01:04 +00:00
|
|
|
/*
|
|
|
|
* release our private reference
|
|
|
|
*/
|
2001-09-12 08:38:13 +00:00
|
|
|
fdrop(fp, td);
|
2005-05-28 12:58:54 +00:00
|
|
|
goto out;
|
1999-09-11 00:46:08 +00:00
|
|
|
}
|
2008-01-10 01:10:58 +00:00
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
|
2007-12-30 01:42:15 +00:00
|
|
|
atomic_set_int(&fp->f_flag, FHASLOCK);
|
1999-09-11 00:46:08 +00:00
|
|
|
}
|
|
|
|
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(vp, 0);
|
2001-09-12 08:38:13 +00:00
|
|
|
fdrop(fp, td);
|
2006-03-31 03:54:20 +00:00
|
|
|
vfs_rel(mp);
|
2006-03-21 23:58:37 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2001-09-12 08:38:13 +00:00
|
|
|
td->td_retval[0] = indx;
|
1999-09-11 00:46:08 +00:00
|
|
|
return (0);
|
|
|
|
|
|
|
|
bad:
|
|
|
|
vput(vp);
|
2005-05-28 12:58:54 +00:00
|
|
|
out:
|
2006-03-31 03:54:20 +00:00
|
|
|
vfs_rel(mp);
|
2006-03-21 23:58:37 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
1999-09-11 00:46:08 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2000-09-14 19:13:59 +00:00
|
|
|
/*
|
|
|
|
* Stat an (NFS) file handle.
|
|
|
|
*/
|
1999-09-11 00:46:08 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct fhstat_args {
|
|
|
|
struct fhandle *u_fhp;
|
|
|
|
struct stat *sb;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
fhstat(td, uap)
|
|
|
|
struct thread *td;
|
1999-09-11 00:46:08 +00:00
|
|
|
register struct fhstat_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
struct fhandle *u_fhp;
|
|
|
|
struct stat *sb;
|
1999-09-11 00:46:08 +00:00
|
|
|
} */ *uap;
|
|
|
|
{
|
|
|
|
struct stat sb;
|
|
|
|
fhandle_t fh;
|
|
|
|
struct mount *mp;
|
|
|
|
struct vnode *vp;
|
2006-03-21 23:58:37 +00:00
|
|
|
int vfslocked;
|
1999-09-11 00:46:08 +00:00
|
|
|
int error;
|
|
|
|
|
2006-11-06 13:42:10 +00:00
|
|
|
error = priv_check(td, PRIV_VFS_FHSTAT);
|
1999-09-11 00:46:08 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
2002-12-14 01:56:26 +00:00
|
|
|
error = copyin(uap->u_fhp, &fh, sizeof(fhandle_t));
|
1999-09-11 00:46:08 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
2006-03-21 23:58:37 +00:00
|
|
|
if ((mp = vfs_getvfs(&fh.fh_fsid)) == NULL)
|
1999-09-11 00:46:08 +00:00
|
|
|
return (ESTALE);
|
2006-03-21 23:58:37 +00:00
|
|
|
vfslocked = VFS_LOCK_GIANT(mp);
|
2005-05-28 12:58:54 +00:00
|
|
|
if ((error = VFS_FHTOVP(mp, &fh.fh_fid, &vp))) {
|
2006-03-31 03:54:20 +00:00
|
|
|
vfs_rel(mp);
|
2006-03-21 23:58:37 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
1999-09-11 00:46:08 +00:00
|
|
|
return (error);
|
2005-05-28 12:58:54 +00:00
|
|
|
}
|
Make similar changes to fo_stat() and fo_poll() as made earlier to
fo_read() and fo_write(): explicitly use the cred argument to fo_poll()
as "active_cred" using the passed file descriptor's f_cred reference
to provide access to the file credential. Add an active_cred
argument to fo_stat() so that implementers have access to the active
credential as well as the file credential. Generally modify callers
of fo_stat() to pass in td->td_ucred rather than fp->f_cred, which
was redundantly provided via the fp argument. This set of modifications
also permits threads to perform these operations on behalf of another
thread without modifying their credential.
Trickle this change down into fo_stat/poll() implementations:
- badfo_poll(), badfo_stat(): modify/add arguments.
- kqueue_poll(), kqueue_stat(): modify arguments.
- pipe_poll(), pipe_stat(): modify/add arguments, pass active_cred to
MAC checks rather than td->td_ucred.
- soo_poll(), soo_stat(): modify/add arguments, pass fp->f_cred rather
than cred to pru_sopoll() to maintain current semantics.
- sopoll(): moidfy arguments.
- vn_poll(), vn_statfile(): modify/add arguments, pass new arguments
to vn_stat(). Pass active_cred to MAC and fp->f_cred to VOP_POLL()
to maintian current semantics.
- vn_close(): rename cred to file_cred to reflect reality while I'm here.
- vn_stat(): Add active_cred and file_cred arguments to vn_stat()
and consumers so that this distinction is maintained at the VFS
as well as 'struct file' layer. Pass active_cred instead of
td->td_ucred to MAC and to VOP_GETATTR() to maintain current semantics.
- fifofs: modify the creation of a "filetemp" so that the file
credential is properly initialized and can be used in the socket
code if desired. Pass ap->a_td->td_ucred as the active
credential to soo_poll(). If we teach the vnop interface about
the distinction between file and active credentials, we would use
the active credential here.
Note that current inconsistent passing of active_cred vs. file_cred to
VOP's is maintained. It's not clear why GETATTR would be authorized
using active_cred while POLL would be authorized using file_cred at
the file system level.
Obtained from: TrustedBSD Project
Sponsored by: DARPA, NAI Labs
2002-08-16 12:52:03 +00:00
|
|
|
error = vn_stat(vp, &sb, td->td_ucred, NOCRED, td);
|
1999-09-11 00:46:08 +00:00
|
|
|
vput(vp);
|
2006-03-31 03:54:20 +00:00
|
|
|
vfs_rel(mp);
|
2006-03-21 23:58:37 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
1999-09-11 00:46:08 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
2002-12-14 01:56:26 +00:00
|
|
|
error = copyout(&sb, uap->sb, sizeof(sb));
|
1999-09-11 00:46:08 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2000-09-14 19:13:59 +00:00
|
|
|
/*
|
|
|
|
* Implement fstatfs() for (NFS) file handles.
|
|
|
|
*/
|
1999-09-11 00:46:08 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct fhstatfs_args {
|
|
|
|
struct fhandle *u_fhp;
|
|
|
|
struct statfs *buf;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
fhstatfs(td, uap)
|
|
|
|
struct thread *td;
|
1999-09-11 00:46:08 +00:00
|
|
|
struct fhstatfs_args /* {
|
2002-12-14 02:07:32 +00:00
|
|
|
struct fhandle *u_fhp;
|
|
|
|
struct statfs *buf;
|
1999-09-11 00:46:08 +00:00
|
|
|
} */ *uap;
|
2005-02-07 18:44:55 +00:00
|
|
|
{
|
|
|
|
struct statfs sf;
|
|
|
|
fhandle_t fh;
|
|
|
|
int error;
|
|
|
|
|
2005-05-27 19:15:46 +00:00
|
|
|
error = copyin(uap->u_fhp, &fh, sizeof(fhandle_t));
|
|
|
|
if (error)
|
2005-02-07 18:44:55 +00:00
|
|
|
return (error);
|
|
|
|
error = kern_fhstatfs(td, fh, &sf);
|
2005-05-27 19:15:46 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
return (copyout(&sf, uap->buf, sizeof(sf)));
|
2005-02-07 18:44:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_fhstatfs(struct thread *td, fhandle_t fh, struct statfs *buf)
|
1999-09-11 00:46:08 +00:00
|
|
|
{
|
2004-06-07 12:19:55 +00:00
|
|
|
struct statfs *sp;
|
1999-09-11 00:46:08 +00:00
|
|
|
struct mount *mp;
|
|
|
|
struct vnode *vp;
|
2006-03-21 23:58:37 +00:00
|
|
|
int vfslocked;
|
1999-09-11 00:46:08 +00:00
|
|
|
int error;
|
|
|
|
|
2006-11-06 13:42:10 +00:00
|
|
|
error = priv_check(td, PRIV_VFS_FHSTATFS);
|
2001-10-01 20:01:07 +00:00
|
|
|
if (error)
|
1999-09-11 00:46:08 +00:00
|
|
|
return (error);
|
2006-03-21 23:58:37 +00:00
|
|
|
if ((mp = vfs_getvfs(&fh.fh_fsid)) == NULL)
|
1999-09-11 00:46:08 +00:00
|
|
|
return (ESTALE);
|
2006-03-21 23:58:37 +00:00
|
|
|
vfslocked = VFS_LOCK_GIANT(mp);
|
2005-05-27 19:15:46 +00:00
|
|
|
error = VFS_FHTOVP(mp, &fh.fh_fid, &vp);
|
2005-05-28 12:58:54 +00:00
|
|
|
if (error) {
|
2006-03-21 23:58:37 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2006-03-31 03:54:20 +00:00
|
|
|
vfs_rel(mp);
|
1999-09-11 00:46:08 +00:00
|
|
|
return (error);
|
2005-05-28 12:58:54 +00:00
|
|
|
}
|
2006-02-22 09:52:25 +00:00
|
|
|
vput(vp);
|
2006-03-21 23:58:37 +00:00
|
|
|
error = prison_canseemount(td->td_ucred, mp);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
2002-07-31 01:27:33 +00:00
|
|
|
#ifdef MAC
|
2007-10-24 19:04:04 +00:00
|
|
|
error = mac_mount_check_stat(td->td_ucred, mp);
|
2006-03-21 23:58:37 +00:00
|
|
|
if (error)
|
|
|
|
goto out;
|
2002-07-31 01:27:33 +00:00
|
|
|
#endif
|
2003-11-12 08:01:40 +00:00
|
|
|
/*
|
|
|
|
* Set these in case the underlying filesystem fails to do so.
|
|
|
|
*/
|
2006-02-23 05:18:07 +00:00
|
|
|
sp = &mp->mnt_stat;
|
2003-11-12 08:01:40 +00:00
|
|
|
sp->f_version = STATFS_VERSION;
|
|
|
|
sp->f_namemax = NAME_MAX;
|
|
|
|
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
|
2005-05-27 19:15:46 +00:00
|
|
|
error = VFS_STATFS(mp, sp, td);
|
2006-09-20 00:32:07 +00:00
|
|
|
if (error == 0)
|
|
|
|
*buf = *sp;
|
2006-03-21 23:58:37 +00:00
|
|
|
out:
|
2006-02-23 05:18:07 +00:00
|
|
|
vfs_rel(mp);
|
2006-03-21 23:58:37 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
|
|
|
return (error);
|
1999-09-11 00:46:08 +00:00
|
|
|
}
|