42#include "opt_capsicum.h"
43#include "opt_ktrace.h"
47#ifdef COMPAT_FREEBSD11
48#include <sys/abi_compat.h>
52#include <sys/capsicum.h>
54#include <sys/sysent.h>
55#include <sys/malloc.h>
58#include <sys/sysproto.h>
60#include <sys/filedesc.h>
61#include <sys/kernel.h>
65#include <sys/limits.h>
66#include <sys/linker.h>
67#include <sys/rwlock.h>
71#include <sys/unistd.h>
75#include <sys/dirent.h>
77#include <sys/syscallsubr.h>
78#include <sys/sysctl.h>
80#include <sys/ktrace.h>
83#include <machine/stdarg.h>
85#include <security/audit/audit.h>
86#include <security/mac/mac_framework.h>
89#include <vm/vm_object.h>
90#include <vm/vm_page.h>
93#include <fs/devfs/devfs.h>
99static int setfflags(
struct thread *td,
struct vnode *, u_long);
100static int getutimes(
const struct timeval *,
enum uio_seg,
struct timespec *);
101static int getutimens(
const struct timespec *,
enum uio_seg,
102 struct timespec *,
int *);
103static int setutimes(
struct thread *td,
struct vnode *,
104 const struct timespec *,
int,
int);
105static int vn_access(
struct vnode *vp,
int user_flags,
struct ucred *cred,
108 enum uio_seg pathseg, fhandle_t *fhp);
110 size_t count,
struct thread *td);
112 const char *
path,
enum uio_seg segflag);
119 MPASS((at_flags & (AT_SYMLINK_FOLLOW | AT_SYMLINK_NOFOLLOW)) !=
120 (AT_SYMLINK_FOLLOW | AT_SYMLINK_NOFOLLOW));
124 if ((at_flags & AT_RESOLVE_BENEATH) != 0)
126 if ((at_flags & AT_SYMLINK_FOLLOW) != 0)
129 if ((
mask & AT_SYMLINK_NOFOLLOW) != 0) {
130 res |= (at_flags & AT_SYMLINK_NOFOLLOW) != 0 ? NOFOLLOW :
133 if ((
mask & AT_EMPTY_PATH) != 0 && (at_flags & AT_EMPTY_PATH) != 0)
141 struct mount *mp, *nmp;
145 for (mp = TAILQ_FIRST(&
mountlist); mp != NULL; mp = nmp) {
146 if (
vfs_busy(mp, MBF_NOWAIT | MBF_MNTLSTLOCK)) {
147 nmp = TAILQ_NEXT(mp, mnt_list);
150 if ((mp->mnt_flag & MNT_RDONLY) == 0 &&
152 save = curthread_pflags_set(TDP_SYNCIO);
154 VFS_SYNC(mp, MNT_NOWAIT);
155 curthread_pflags_restore(save);
159 nmp = TAILQ_NEXT(mp, mnt_list);
169#ifndef _SYS_SYSPROTO_H_
185#ifndef _SYS_SYSPROTO_H_
201 AUDIT_ARG_CMD(uap->
cmd);
202 AUDIT_ARG_UID(uap->
uid);
205 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | AUDITVNODE1, UIO_USERSPACE,
207 if ((error =
namei(&nd)) != 0)
209 NDFREE(&nd, NDF_ONLY_PNBUF);
210 mp = nd.ni_vp->v_mount;
219 error = VFS_QUOTACTL(mp, uap->
cmd, uap->
uid, uap->
arg, &mp_busy);
250 KASSERT(powerof2(max_size + 1), (
"%s: invalid max_size", __func__));
258 if (sf->f_bavail < 0)
259 count = -sf->f_bavail;
261 count = sf->f_bavail;
262 count = MAX(sf->f_blocks, MAX(sf->f_bfree,
count));
263 if (
count <= max_size)
266 count >>= flsl(max_size);
273 sf->f_bsize <<= shift;
274 sf->f_blocks >>= shift;
275 sf->f_bfree >>= shift;
276 sf->f_bavail >>= shift;
291 error = mac_mount_check_stat(td->td_ucred, mp);
295 error = VFS_STATFS(mp,
buf);
299 buf->f_fsid.val[0] =
buf->f_fsid.val[1] = 0;
310#ifndef _SYS_SYSPROTO_H_
322 sfp =
malloc(
sizeof(
struct statfs), M_STATFS, M_WAITOK);
325 error = copyout(sfp, uap->
buf,
sizeof(
struct statfs));
338 NDINIT(&nd, LOOKUP, FOLLOW | AUDITVNODE1, pathseg,
path);
351#ifndef _SYS_SYSPROTO_H_
363 sfp =
malloc(
sizeof(
struct statfs), M_STATFS, M_WAITOK);
366 error = copyout(sfp, uap->
buf,
sizeof(
struct statfs));
385 if (AUDITING_TD(td)) {
386 vn_lock(vp, LK_SHARED | LK_RETRY);
387 AUDIT_ARG_VNODE1(vp);
399#ifndef _SYS_SYSPROTO_H_
415 UIO_USERSPACE, uap->
mode);
417 td->td_retval[0] =
count;
428 size_t *countp,
enum uio_seg bufseg,
int mode)
430 struct mount *mp, *nmp;
431 struct statfs *sfsp, *sp, *sptmp, *tofree;
440 if (bufseg == UIO_SYSSPACE)
445 maxcount = bufsize /
sizeof(
struct statfs);
449 }
else if (bufseg == UIO_USERSPACE) {
455 TAILQ_FOREACH(mp, &
mountlist, mnt_list) {
475 for (mp = TAILQ_FIRST(&
mountlist); mp != NULL; mp = nmp) {
477 nmp = TAILQ_NEXT(mp, mnt_list);
481 if (mac_mount_check_stat(td->td_ucred, mp) != 0) {
482 nmp = TAILQ_NEXT(mp, mnt_list);
487 nmp = TAILQ_NEXT(mp, mnt_list);
505 for (mp = TAILQ_FIRST(&
mountlist); mp != NULL; mp = nmp) {
507 nmp = TAILQ_NEXT(mp, mnt_list);
511 if (mac_mount_check_stat(td->td_ucred, mp) != 0) {
512 nmp = TAILQ_NEXT(mp, mnt_list);
516 if (
mode == MNT_WAIT) {
517 if (
vfs_busy(mp, MBF_MNTLSTLOCK) != 0) {
526 free(tofree, M_STATFS);
530 if (
vfs_busy(mp, MBF_NOWAIT | MBF_MNTLSTLOCK) != 0) {
531 nmp = TAILQ_NEXT(mp, mnt_list);
540 if (
mode != MNT_NOWAIT) {
541 error = VFS_STATFS(mp, sp);
544 nmp = TAILQ_NEXT(mp, mnt_list);
550 sptmp =
malloc(
sizeof(
struct statfs), M_STATFS,
553 sptmp->f_fsid.val[0] = sptmp->f_fsid.val[1] = 0;
558 if (bufseg == UIO_SYSSPACE) {
559 bcopy(sp, sfsp,
sizeof(*sp));
560 free(sptmp, M_STATFS);
562 error = copyout(sp, sfsp,
sizeof(*sp));
563 free(sptmp, M_STATFS);
578 nmp = TAILQ_NEXT(mp, mnt_list);
587#ifdef COMPAT_FREEBSD4
591static void freebsd4_cvtstatfs(
struct statfs *,
struct ostatfs *);
593#ifndef _SYS_SYSPROTO_H_
594struct freebsd4_statfs_args {
600freebsd4_statfs(
struct thread *td,
struct freebsd4_statfs_args *uap)
606 sfp =
malloc(
sizeof(
struct statfs), M_STATFS, M_WAITOK);
607 error =
kern_statfs(td, uap->path, UIO_USERSPACE, sfp);
609 freebsd4_cvtstatfs(sfp, &osb);
610 error = copyout(&osb, uap->buf,
sizeof(osb));
619#ifndef _SYS_SYSPROTO_H_
620struct freebsd4_fstatfs_args {
626freebsd4_fstatfs(
struct thread *td,
struct freebsd4_fstatfs_args *uap)
632 sfp =
malloc(
sizeof(
struct statfs), M_STATFS, M_WAITOK);
635 freebsd4_cvtstatfs(sfp, &osb);
636 error = copyout(&osb, uap->buf,
sizeof(osb));
645#ifndef _SYS_SYSPROTO_H_
646struct freebsd4_getfsstat_args {
653freebsd4_getfsstat(
struct thread *td,
struct freebsd4_getfsstat_args *uap)
655 struct statfs *
buf, *sp;
660 if (uap->bufsize < 0)
662 count = uap->bufsize /
sizeof(
struct ostatfs);
663 if (
count > SIZE_MAX /
sizeof(
struct statfs))
665 size =
count *
sizeof(
struct statfs);
669 td->td_retval[0] =
count;
672 while (
count != 0 && error == 0) {
673 freebsd4_cvtstatfs(sp, &osb);
674 error = copyout(&osb, uap->buf,
sizeof(osb));
687#ifndef _SYS_SYSPROTO_H_
688struct freebsd4_fhstatfs_args {
689 struct fhandle *u_fhp;
694freebsd4_fhstatfs(
struct thread *td,
struct freebsd4_fhstatfs_args *uap)
701 error = copyin(uap->u_fhp, &fh,
sizeof(fhandle_t));
704 sfp =
malloc(
sizeof(
struct statfs), M_STATFS, M_WAITOK);
707 freebsd4_cvtstatfs(sfp, &osb);
708 error = copyout(&osb, uap->buf,
sizeof(osb));
718freebsd4_cvtstatfs(
struct statfs *nsp,
struct ostatfs *osp)
722 bzero(osp,
sizeof(*osp));
723 osp->f_bsize = nsp->f_bsize;
724 osp->f_iosize = MIN(nsp->f_iosize, LONG_MAX);
725 osp->f_blocks = nsp->f_blocks;
726 osp->f_bfree = nsp->f_bfree;
727 osp->f_bavail = nsp->f_bavail;
728 osp->f_files = MIN(nsp->f_files, LONG_MAX);
729 osp->f_ffree = MIN(nsp->f_ffree, LONG_MAX);
730 osp->f_owner = nsp->f_owner;
731 osp->f_type = nsp->f_type;
732 osp->f_flags = nsp->f_flags;
733 osp->f_syncwrites = MIN(nsp->f_syncwrites, LONG_MAX);
734 osp->f_asyncwrites = MIN(nsp->f_asyncwrites, LONG_MAX);
735 osp->f_syncreads = MIN(nsp->f_syncreads, LONG_MAX);
736 osp->f_asyncreads = MIN(nsp->f_asyncreads, LONG_MAX);
737 strlcpy(osp->f_fstypename, nsp->f_fstypename,
738 MIN(MFSNAMELEN, OMFSNAMELEN));
739 strlcpy(osp->f_mntonname, nsp->f_mntonname,
740 MIN(MNAMELEN, OMNAMELEN));
741 strlcpy(osp->f_mntfromname, nsp->f_mntfromname,
742 MIN(MNAMELEN, OMNAMELEN));
743 osp->f_fsid = nsp->f_fsid;
747#if defined(COMPAT_FREEBSD11)
751static void freebsd11_cvtstatfs(
struct statfs *,
struct freebsd11_statfs *);
754freebsd11_statfs(
struct thread *td,
struct freebsd11_statfs_args *uap)
756 struct freebsd11_statfs osb;
760 sfp =
malloc(
sizeof(
struct statfs), M_STATFS, M_WAITOK);
761 error =
kern_statfs(td, uap->path, UIO_USERSPACE, sfp);
763 freebsd11_cvtstatfs(sfp, &osb);
764 error = copyout(&osb, uap->buf,
sizeof(osb));
774freebsd11_fstatfs(
struct thread *td,
struct freebsd11_fstatfs_args *uap)
776 struct freebsd11_statfs osb;
780 sfp =
malloc(
sizeof(
struct statfs), M_STATFS, M_WAITOK);
783 freebsd11_cvtstatfs(sfp, &osb);
784 error = copyout(&osb, uap->buf,
sizeof(osb));
794freebsd11_getfsstat(
struct thread *td,
struct freebsd11_getfsstat_args *uap)
796 return (kern_freebsd11_getfsstat(td, uap->buf, uap->bufsize, uap->mode));
800kern_freebsd11_getfsstat(
struct thread *td,
struct freebsd11_statfs * ubuf,
801 long bufsize,
int mode)
803 struct freebsd11_statfs osb;
804 struct statfs *
buf, *sp;
811 count = bufsize /
sizeof(
struct ostatfs);
812 size =
count *
sizeof(
struct statfs);
815 td->td_retval[0] =
count;
818 while (
count > 0 && error == 0) {
819 freebsd11_cvtstatfs(sp, &osb);
820 error = copyout(&osb, ubuf,
sizeof(osb));
834freebsd11_fhstatfs(
struct thread *td,
struct freebsd11_fhstatfs_args *uap)
836 struct freebsd11_statfs osb;
841 error = copyin(uap->u_fhp, &fh,
sizeof(fhandle_t));
844 sfp =
malloc(
sizeof(
struct statfs), M_STATFS, M_WAITOK);
847 freebsd11_cvtstatfs(sfp, &osb);
848 error = copyout(&osb, uap->buf,
sizeof(osb));
858freebsd11_cvtstatfs(
struct statfs *nsp,
struct freebsd11_statfs *osp)
861 bzero(osp,
sizeof(*osp));
862 osp->f_version = FREEBSD11_STATFS_VERSION;
863 osp->f_type = nsp->f_type;
864 osp->f_flags = nsp->f_flags;
865 osp->f_bsize = nsp->f_bsize;
866 osp->f_iosize = nsp->f_iosize;
867 osp->f_blocks = nsp->f_blocks;
868 osp->f_bfree = nsp->f_bfree;
869 osp->f_bavail = nsp->f_bavail;
870 osp->f_files = nsp->f_files;
871 osp->f_ffree = nsp->f_ffree;
872 osp->f_syncwrites = nsp->f_syncwrites;
873 osp->f_asyncwrites = nsp->f_asyncwrites;
874 osp->f_syncreads = nsp->f_syncreads;
875 osp->f_asyncreads = nsp->f_asyncreads;
876 osp->f_namemax = nsp->f_namemax;
877 osp->f_owner = nsp->f_owner;
878 osp->f_fsid = nsp->f_fsid;
879 strlcpy(osp->f_fstypename, nsp->f_fstypename,
880 MIN(MFSNAMELEN,
sizeof(osp->f_fstypename)));
881 strlcpy(osp->f_mntonname, nsp->f_mntonname,
882 MIN(MNAMELEN,
sizeof(osp->f_mntonname)));
883 strlcpy(osp->f_mntfromname, nsp->f_mntfromname,
884 MIN(MNAMELEN,
sizeof(osp->f_mntfromname)));
891#ifndef _SYS_SYSPROTO_H_
899 struct vnode *vp, *tdp;
904 AUDIT_ARG_FD(uap->
fd);
912 vn_lock(vp, LK_SHARED | LK_RETRY);
913 AUDIT_ARG_VNODE1(vp);
915 while (!error && (mp = vp->v_mountedhere) != NULL) {
918 error = VFS_ROOT(mp, LK_SHARED, &tdp);
937#ifndef _SYS_SYSPROTO_H_
955 NDINIT(&nd, LOOKUP, FOLLOW | LOCKSHARED | LOCKLEAF | AUDITVNODE1,
957 if ((error =
namei(&nd)) != 0)
959 if ((error =
change_dir(nd.ni_vp, td)) != 0) {
964 VOP_UNLOCK(nd.ni_vp);
973 "Unprivileged processes can use chroot(2)");
977#ifndef _SYS_SYSPROTO_H_
994 (p->p_flag2 & P2_NO_NEW_PRIVS) == 0) {
1000 NDINIT(&nd, LOOKUP, FOLLOW | LOCKSHARED | LOCKLEAF | AUDITVNODE1,
1001 UIO_USERSPACE, uap->
path);
1009 error = mac_vnode_check_chroot(td->td_ucred, nd.ni_vp);
1013 VOP_UNLOCK(nd.ni_vp);
1016 NDFREE_NOTHING(&nd);
1021 NDFREE_NOTHING(&nd);
1036 ASSERT_VOP_LOCKED(vp,
"change_dir(): vp not locked");
1037 if (vp->v_type != VDIR)
1040 error = mac_vnode_check_chdir(td->td_ucred, vp);
1044 return (VOP_ACCESS(vp, VEXEC, td->td_ucred, td));
1050 if (
flags & O_EXEC) {
1051 cap_rights_set_one(rightsp, CAP_FEXECVE);
1055 switch ((
flags & O_ACCMODE)) {
1057 cap_rights_set_one(rightsp, CAP_READ);
1060 cap_rights_set_one(rightsp, CAP_READ);
1063 cap_rights_set_one(rightsp, CAP_WRITE);
1064 if (!(
flags & (O_APPEND | O_TRUNC)))
1065 cap_rights_set_one(rightsp, CAP_SEEK);
1070 if (
flags & O_CREAT)
1071 cap_rights_set_one(rightsp, CAP_CREATE);
1073 if (
flags & O_TRUNC)
1074 cap_rights_set_one(rightsp, CAP_FTRUNCATE);
1076 if (
flags & (O_SYNC | O_FSYNC))
1077 cap_rights_set_one(rightsp, CAP_FSYNC);
1079 if (
flags & (O_EXLOCK | O_SHLOCK))
1080 cap_rights_set_one(rightsp, CAP_FLOCK);
1087#ifndef _SYS_SYSPROTO_H_
1102#ifndef _SYS_SYSPROTO_H_
1114 AUDIT_ARG_FD(uap->
fd);
1123 struct proc *p = td->td_proc;
1124 struct filedesc *fdp;
1125 struct pwddesc *pdp;
1128 struct nameidata nd;
1129 cap_rights_t rights;
1130 int cmode, error, indx;
1136 AUDIT_ARG_FFLAGS(
flags);
1137 AUDIT_ARG_MODE(
mode);
1138 cap_rights_init_one(&rights, CAP_LOOKUP);
1146 if ((
flags & O_PATH) != 0) {
1147 flags &= ~(O_CREAT | O_ACCMODE);
1148 }
else if ((
flags & O_EXEC) != 0) {
1149 if (
flags & O_ACCMODE)
1151 }
else if ((
flags & O_ACCMODE) == O_ACCMODE) {
1161 error = falloc_noinstall(td, &fp);
1165 fp->f_flag =
flags & FMASK;
1166 cmode = ((
mode & ~pdp->pd_cmask) & ALLPERMS) & ~S_ISTXT;
1167 NDINIT_ATRIGHTS(&nd, LOOKUP, FOLLOW | AUDITVNODE1, pathseg,
path,
fd,
1177 if (error == ENXIO && fp->f_ops != &
badfileops) {
1178 MPASS((
flags & O_PATH) == 0);
1189 if ((nd.ni_resflags & NIRES_STRICTREL) == 0 &&
1190 (error == ENODEV || error == ENXIO) &&
1191 td->td_dupfd >= 0) {
1201 NDFREE(&nd, NDF_ONLY_PNBUF);
1216 KASSERT(vp->v_type != VFIFO || (
flags & O_PATH) != 0,
1217 (
"Unexpected fifo fp %p vp %p", fp, vp));
1218 if ((
flags & O_PATH) != 0) {
1219 finit(fp, (
flags & FMASK) | (fp->f_flag & FKQALLOWED),
1229 if (
flags & O_TRUNC) {
1230 error = fo_truncate(fp, 0, td->td_ucred, td);
1239 struct filecaps *fcaps;
1242 if ((nd.ni_resflags & NIRES_STRICTREL) != 0)
1243 fcaps = &nd.ni_filecaps;
1258 td->td_retval[0] = indx;
1261 KASSERT(indx == -1, (
"indx=%d, should be -1", indx));
1270#ifndef _SYS_SYSPROTO_H_
1277ocreat(
struct thread *td,
struct ocreat_args *uap)
1280 return (
kern_openat(td, AT_FDCWD, uap->path, UIO_USERSPACE,
1281 O_WRONLY | O_CREAT | O_TRUNC, uap->mode));
1288#ifndef _SYS_SYSPROTO_H_
1304#if defined(COMPAT_FREEBSD11)
1306freebsd11_mknod(
struct thread *td,
1307 struct freebsd11_mknod_args *uap)
1310 return (
kern_mknodat(td, AT_FDCWD, uap->path, UIO_USERSPACE,
1311 uap->mode, uap->dev));
1315freebsd11_mknodat(
struct thread *td,
1316 struct freebsd11_mknodat_args *uap)
1319 return (
kern_mknodat(td, uap->fd, uap->path, UIO_USERSPACE, uap->mode,
1326 int mode, dev_t dev)
1331 struct nameidata nd;
1332 int error, whiteout = 0;
1334 AUDIT_ARG_MODE(
mode);
1336 switch (
mode & S_IFMT) {
1340 if (error == 0 && dev == VNOVAL)
1359 NDINIT_ATRIGHTS(&nd, CREATE, LOCKPARENT | SAVENAME | AUDITVNODE1 |
1361 if ((error =
namei(&nd)) != 0)
1365 NDFREE(&nd, NDF_ONLY_PNBUF);
1366 if (vp == nd.ni_dvp)
1374 vattr.va_mode = (
mode & ALLPERMS) &
1375 ~td->td_proc->p_pd->pd_cmask;
1376 vattr.va_rdev = dev;
1379 switch (
mode & S_IFMT) {
1381 vattr.va_type = VCHR;
1384 vattr.va_type = VBLK;
1390 panic(
"kern_mknod: invalid mode");
1394 NDFREE(&nd, NDF_ONLY_PNBUF);
1401 if (error == 0 && !whiteout)
1402 error = mac_vnode_check_create(td->td_ucred, nd.ni_dvp,
1403 &nd.ni_cnd, &vattr);
1407 error = VOP_WHITEOUT(nd.ni_dvp, &nd.ni_cnd, CREATE);
1409 error = VOP_MKNOD(nd.ni_dvp, &nd.ni_vp,
1410 &nd.ni_cnd, &vattr);
1413 VOP_VPUT_PAIR(nd.ni_dvp, error == 0 && !whiteout ? &nd.ni_vp : NULL,
1416 NDFREE(&nd, NDF_ONLY_PNBUF);
1417 if (error == ERELOOKUP)
1425#ifndef _SYS_SYSPROTO_H_
1439#ifndef _SYS_SYSPROTO_H_
1456 enum uio_seg pathseg,
int mode)
1460 struct nameidata nd;
1463 AUDIT_ARG_MODE(
mode);
1467 NDINIT_ATRIGHTS(&nd, CREATE, LOCKPARENT | SAVENAME | AUDITVNODE1 |
1469 if ((error =
namei(&nd)) != 0)
1471 if (nd.ni_vp != NULL) {
1472 NDFREE(&nd, NDF_ONLY_PNBUF);
1473 if (nd.ni_vp == nd.ni_dvp)
1481 NDFREE(&nd, NDF_ONLY_PNBUF);
1488 vattr.va_type = VFIFO;
1489 vattr.va_mode = (
mode & ALLPERMS) & ~td->td_proc->p_pd->pd_cmask;
1491 error = mac_vnode_check_create(td->td_ucred, nd.ni_dvp, &nd.ni_cnd,
1496 error = VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr);
1500 VOP_VPUT_PAIR(nd.ni_dvp, error == 0 ? &nd.ni_vp : NULL,
true);
1502 NDFREE(&nd, NDF_ONLY_PNBUF);
1503 if (error == ERELOOKUP)
1511#ifndef _SYS_SYSPROTO_H_
1522 UIO_USERSPACE, AT_SYMLINK_FOLLOW));
1525#ifndef _SYS_SYSPROTO_H_
1539 UIO_USERSPACE, uap->
flag));
1545 "Unprivileged processes cannot create hard links to files owned by other "
1550 "Unprivileged processes cannot create hard links to files owned by other "
1562 error = VOP_GETATTR(vp, &va, cred);
1583 const char *path2,
enum uio_seg segflag,
int flag)
1585 struct nameidata nd;
1588 if ((
flag & ~(AT_SYMLINK_FOLLOW | AT_RESOLVE_BENEATH |
1589 AT_EMPTY_PATH)) != 0)
1596 AT_SYMLINK_FOLLOW | AT_RESOLVE_BENEATH | AT_EMPTY_PATH),
1598 if ((error =
namei(&nd)) != 0)
1600 NDFREE(&nd, NDF_ONLY_PNBUF);
1601 if ((nd.ni_resflags & NIRES_EMPTYPATH) != 0) {
1609 }
while (error == EAGAIN || error == ERELOOKUP);
1615 enum uio_seg segflag)
1617 struct nameidata nd;
1621 if (vp->v_type == VDIR) {
1625 NDINIT_ATRIGHTS(&nd, CREATE,
1626 LOCKPARENT | SAVENAME | AUDITVNODE2 | NOCACHE, segflag,
path,
fd,
1628 if ((error =
namei(&nd)) == 0) {
1629 if (nd.ni_vp != NULL) {
1630 NDFREE(&nd, NDF_ONLY_PNBUF);
1631 if (nd.ni_dvp == nd.ni_vp)
1638 }
else if (nd.ni_dvp->v_mount != vp->v_mount) {
1644 NDFREE(&nd, NDF_ONLY_PNBUF);
1648 }
else if ((error = vn_lock(vp, LK_EXCLUSIVE)) == 0) {
1652 error = mac_vnode_check_link(td->td_ucred,
1653 nd.ni_dvp, vp, &nd.ni_cnd);
1658 NDFREE(&nd, NDF_ONLY_PNBUF);
1665 NDFREE(&nd, NDF_ONLY_PNBUF);
1672 error = VOP_LINK(nd.ni_dvp, vp, &nd.ni_cnd);
1673 VOP_VPUT_PAIR(nd.ni_dvp, &vp,
true);
1675 NDFREE(&nd, NDF_ONLY_PNBUF);
1679 NDFREE(&nd, NDF_ONLY_PNBUF);
1692#ifndef _SYS_SYSPROTO_H_
1706#ifndef _SYS_SYSPROTO_H_
1723 enum uio_seg segflg)
1727 const char *syspath;
1729 struct nameidata nd;
1732 if (segflg == UIO_SYSSPACE) {
1736 if ((error = copyinstr(path1, tmppath, MAXPATHLEN, NULL)) != 0)
1740 AUDIT_ARG_TEXT(syspath);
1744 NDINIT_ATRIGHTS(&nd, CREATE, LOCKPARENT | SAVENAME | AUDITVNODE1 |
1746 if ((error =
namei(&nd)) != 0)
1749 NDFREE(&nd, NDF_ONLY_PNBUF);
1750 if (nd.ni_vp == nd.ni_dvp)
1760 NDFREE(&nd, NDF_ONLY_PNBUF);
1767 vattr.va_mode = ACCESSPERMS &~ td->td_proc->p_pd->pd_cmask;
1769 vattr.va_type = VLNK;
1770 error = mac_vnode_check_create(td->td_ucred, nd.ni_dvp, &nd.ni_cnd,
1775 error = VOP_SYMLINK(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr, syspath);
1779 VOP_VPUT_PAIR(nd.ni_dvp, error == 0 ? &nd.ni_vp : NULL,
true);
1781 NDFREE(&nd, NDF_ONLY_PNBUF);
1782 if (error == ERELOOKUP)
1785 if (segflg != UIO_SYSSPACE)
1793#ifndef _SYS_SYSPROTO_H_
1802 struct nameidata nd;
1808 NDINIT(&nd, DELETE, LOCKPARENT | DOWHITEOUT | AUDITVNODE1,
1809 UIO_USERSPACE, uap->
path);
1814 if (nd.ni_vp != NULLVP || !(nd.ni_cnd.cn_flags & ISWHITEOUT)) {
1815 NDFREE(&nd, NDF_ONLY_PNBUF);
1816 if (nd.ni_vp == nd.ni_dvp)
1825 NDFREE(&nd, NDF_ONLY_PNBUF);
1831 error = VOP_WHITEOUT(nd.ni_dvp, &nd.ni_cnd, DELETE);
1832 NDFREE(&nd, NDF_ONLY_PNBUF);
1835 if (error == ERELOOKUP)
1843#ifndef _SYS_SYSPROTO_H_
1858 int flag,
enum uio_seg pathseg, ino_t oldinum)
1861 if ((
flag & ~(AT_REMOVEDIR | AT_RESOLVE_BENEATH)) != 0)
1864 if ((
flag & AT_REMOVEDIR) != 0)
1870#ifndef _SYS_SYSPROTO_H_
1885#ifndef _SYS_SYSPROTO_H_
1903 enum uio_seg pathseg,
int flag, ino_t oldinum)
1908 struct nameidata nd;
1913 if (
fd != FD_NONE) {
1922 NDINIT_ATRIGHTS(&nd, DELETE, LOCKPARENT | LOCKLEAF | AUDITVNODE1 |
1925 if ((error =
namei(&nd)) != 0) {
1926 if (error == EINVAL)
1931 if (vp->v_type == VDIR && oldinum == 0) {
1933 }
else if (oldinum != 0 &&
1934 ((error = VOP_STAT(vp, &sb, td->td_ucred, NOCRED)) == 0) &&
1935 sb.st_ino != oldinum) {
1937 }
else if (fp != NULL && fp->f_vnode != vp) {
1938 if (VN_IS_DOOMED(fp->f_vnode))
1948 if (vp->v_vflag & VV_ROOT)
1953 NDFREE(&nd, NDF_ONLY_PNBUF);
1955 if (vp == nd.ni_dvp)
1960 V_XSLEEP | PCATCH)) != 0) {
1966 error = mac_vnode_check_unlink(td->td_ucred, nd.ni_dvp, vp,
1972 error = VOP_REMOVE(nd.ni_dvp, vp, &nd.ni_cnd);
1978 NDFREE(&nd, NDF_ONLY_PNBUF);
1980 if (vp == nd.ni_dvp)
1984 if (error == ERELOOKUP)
1995#ifndef _SYS_SYSPROTO_H_
2020 error = (fp->f_ops->fo_flags & DFLAG_SEEKABLE) != 0 ?
2021 fo_seek(fp, offset, whence, td) : ESPIPE;
2026#if defined(COMPAT_43)
2030#ifndef _SYS_SYSPROTO_H_
2038olseek(
struct thread *td,
struct olseek_args *uap)
2041 return (
kern_lseek(td, uap->fd, uap->offset, uap->whence));
2045#if defined(COMPAT_FREEBSD6)
2048freebsd6_lseek(
struct thread *td,
struct freebsd6_lseek_args *uap)
2051 return (
kern_lseek(td, uap->fd, uap->offset, uap->whence));
2059vn_access(
struct vnode *vp,
int user_flags,
struct ucred *cred,
2066 if (user_flags == 0)
2070 if (user_flags & R_OK)
2072 if (user_flags & W_OK)
2074 if (user_flags & X_OK)
2077 error = mac_vnode_check_access(cred, vp,
accmode);
2082 error = VOP_ACCESS(vp,
accmode, cred, td);
2089#ifndef _SYS_SYSPROTO_H_
2103#ifndef _SYS_SYSPROTO_H_
2121 enum uio_seg pathseg,
int flag,
int amode)
2123 struct ucred *cred, *usecred;
2125 struct nameidata nd;
2128 if ((
flag & ~(AT_EACCESS | AT_RESOLVE_BENEATH | AT_EMPTY_PATH)) != 0)
2130 if (
amode != F_OK && (
amode & ~(R_OK | W_OK | X_OK)) != 0)
2137 cred = td->td_ucred;
2138 if ((
flag & AT_EACCESS) == 0 &&
2139 ((cred->cr_uid != cred->cr_ruid ||
2140 cred->cr_rgid != cred->cr_groups[0]))) {
2141 usecred =
crdup(cred);
2142 usecred->cr_uid = cred->cr_ruid;
2143 usecred->cr_groups[0] = cred->cr_rgid;
2144 td->td_ucred = usecred;
2147 AUDIT_ARG_VALUE(
amode);
2148 NDINIT_ATRIGHTS(&nd, LOOKUP, FOLLOW | LOCKSHARED | LOCKLEAF |
2151 if ((error =
namei(&nd)) != 0)
2156 NDFREE_NOTHING(&nd);
2159 if (usecred != cred) {
2160 td->td_ucred = cred;
2169#ifndef _SYS_SYSPROTO_H_
2180 AT_EACCESS, uap->
amode));
2183#if defined(COMPAT_43)
2187#ifndef _SYS_SYSPROTO_H_
2194ostat(
struct thread *td,
struct ostat_args *uap)
2200 error =
kern_statat(td, 0, AT_FDCWD, uap->path, UIO_USERSPACE,
2205 return (copyout(&osb, uap->ub, sizeof (osb)));
2211#ifndef _SYS_SYSPROTO_H_
2218olstat(
struct thread *td,
struct olstat_args *uap)
2224 error =
kern_statat(td, AT_SYMLINK_NOFOLLOW, AT_FDCWD, uap->path,
2225 UIO_USERSPACE, &sb, NULL);
2229 return (copyout(&osb, uap->ub, sizeof (osb)));
2237cvtstat(
struct stat *
st,
struct ostat *ost)
2240 bzero(ost,
sizeof(*ost));
2241 ost->st_dev =
st->st_dev;
2242 ost->st_ino =
st->st_ino;
2243 ost->st_mode =
st->st_mode;
2244 ost->st_nlink =
st->st_nlink;
2245 ost->st_uid =
st->st_uid;
2246 ost->st_gid =
st->st_gid;
2247 ost->st_rdev =
st->st_rdev;
2248 ost->st_size = MIN(
st->st_size, INT32_MAX);
2249 ost->st_atim =
st->st_atim;
2250 ost->st_mtim =
st->st_mtim;
2251 ost->st_ctim =
st->st_ctim;
2252 ost->st_blksize =
st->st_blksize;
2253 ost->st_blocks =
st->st_blocks;
2254 ost->st_flags =
st->st_flags;
2255 ost->st_gen =
st->st_gen;
2259#if defined(COMPAT_43) || defined(COMPAT_FREEBSD11)
2260int ino64_trunc_error;
2261SYSCTL_INT(_vfs, OID_AUTO, ino64_trunc_error, CTLFLAG_RW,
2262 &ino64_trunc_error, 0,
2263 "Error on truncation of device, file or inode number, or link count");
2266freebsd11_cvtstat(
struct stat *
st,
struct freebsd11_stat *ost)
2269 ost->st_dev =
st->st_dev;
2270 if (ost->st_dev !=
st->st_dev) {
2271 switch (ino64_trunc_error) {
2282 ost->st_ino =
st->st_ino;
2283 if (ost->st_ino !=
st->st_ino) {
2284 switch (ino64_trunc_error) {
2291 ost->st_ino = UINT32_MAX;
2295 ost->st_mode =
st->st_mode;
2296 ost->st_nlink =
st->st_nlink;
2297 if (ost->st_nlink !=
st->st_nlink) {
2298 switch (ino64_trunc_error) {
2305 ost->st_nlink = UINT16_MAX;
2309 ost->st_uid =
st->st_uid;
2310 ost->st_gid =
st->st_gid;
2311 ost->st_rdev =
st->st_rdev;
2312 if (ost->st_rdev !=
st->st_rdev) {
2313 switch (ino64_trunc_error) {
2320 ost->st_atim =
st->st_atim;
2321 ost->st_mtim =
st->st_mtim;
2322 ost->st_ctim =
st->st_ctim;
2323 ost->st_size =
st->st_size;
2324 ost->st_blocks =
st->st_blocks;
2325 ost->st_blksize =
st->st_blksize;
2326 ost->st_flags =
st->st_flags;
2327 ost->st_gen =
st->st_gen;
2329 ost->st_birthtim =
st->st_birthtim;
2330 bzero((
char *)&ost->st_birthtim +
sizeof(ost->st_birthtim),
2331 sizeof(*ost) - offsetof(
struct freebsd11_stat,
2332 st_birthtim) -
sizeof(ost->st_birthtim));
2337freebsd11_stat(
struct thread *td,
struct freebsd11_stat_args* uap)
2340 struct freebsd11_stat osb;
2343 error =
kern_statat(td, 0, AT_FDCWD, uap->path, UIO_USERSPACE,
2347 error = freebsd11_cvtstat(&sb, &osb);
2349 error = copyout(&osb, uap->ub,
sizeof(osb));
2354freebsd11_lstat(
struct thread *td,
struct freebsd11_lstat_args* uap)
2357 struct freebsd11_stat osb;
2360 error =
kern_statat(td, AT_SYMLINK_NOFOLLOW, AT_FDCWD, uap->path,
2361 UIO_USERSPACE, &sb, NULL);
2364 error = freebsd11_cvtstat(&sb, &osb);
2366 error = copyout(&osb, uap->ub,
sizeof(osb));
2371freebsd11_fhstat(
struct thread *td,
struct freebsd11_fhstat_args* uap)
2375 struct freebsd11_stat osb;
2378 error = copyin(uap->u_fhp, &fh,
sizeof(fhandle_t));
2384 error = freebsd11_cvtstat(&sb, &osb);
2386 error = copyout(&osb, uap->sb,
sizeof(osb));
2391freebsd11_fstatat(
struct thread *td,
struct freebsd11_fstatat_args* uap)
2394 struct freebsd11_stat osb;
2397 error =
kern_statat(td, uap->flag, uap->fd, uap->path,
2398 UIO_USERSPACE, &sb, NULL);
2401 error = freebsd11_cvtstat(&sb, &osb);
2403 error = copyout(&osb, uap->buf,
sizeof(osb));
2411#ifndef _SYS_SYSPROTO_H_
2426 UIO_USERSPACE, &sb, NULL);
2428 error = copyout(&sb, uap->
buf, sizeof (sb));
2434 enum uio_seg pathseg,
struct stat *sbp,
2435 void (*hook)(
struct vnode *vp,
struct stat *sbp))
2437 struct nameidata nd;
2440 if ((
flag & ~(AT_SYMLINK_NOFOLLOW | AT_RESOLVE_BENEATH |
2441 AT_EMPTY_PATH)) != 0)
2445 AT_SYMLINK_NOFOLLOW | AT_EMPTY_PATH) | LOCKSHARED | LOCKLEAF |
2448 if ((error =
namei(&nd)) != 0) {
2449 if (error == ENOTDIR &&
2450 (nd.ni_resflags & NIRES_EMPTYPATH) != 0)
2454 error = VOP_STAT(nd.ni_vp, sbp, td->td_ucred, NOCRED);
2456 if (__predict_false(hook != NULL))
2457 hook(nd.ni_vp, sbp);
2459 NDFREE_NOTHING(&nd);
2461#ifdef __STAT_TIME_T_EXT
2462 sbp->st_atim_ext = 0;
2463 sbp->st_mtim_ext = 0;
2464 sbp->st_ctim_ext = 0;
2465 sbp->st_btim_ext = 0;
2468 if (KTRPOINT(td, KTR_STRUCT))
2469 ktrstat_error(sbp, error);
2474#if defined(COMPAT_FREEBSD11)
2479freebsd11_cvtnstat(
struct stat *sb,
struct nstat *nsb)
2481 struct freebsd11_stat sb11;
2484 error = freebsd11_cvtstat(sb, &sb11);
2488 bzero(nsb,
sizeof(*nsb));
2489 CP(sb11, *nsb, st_dev);
2490 CP(sb11, *nsb, st_ino);
2491 CP(sb11, *nsb, st_mode);
2492 CP(sb11, *nsb, st_nlink);
2493 CP(sb11, *nsb, st_uid);
2494 CP(sb11, *nsb, st_gid);
2495 CP(sb11, *nsb, st_rdev);
2496 CP(sb11, *nsb, st_atim);
2497 CP(sb11, *nsb, st_mtim);
2498 CP(sb11, *nsb, st_ctim);
2499 CP(sb11, *nsb, st_size);
2500 CP(sb11, *nsb, st_blocks);
2501 CP(sb11, *nsb, st_blksize);
2502 CP(sb11, *nsb, st_flags);
2503 CP(sb11, *nsb, st_gen);
2504 CP(sb11, *nsb, st_birthtim);
2508#ifndef _SYS_SYSPROTO_H_
2509struct freebsd11_nstat_args {
2515freebsd11_nstat(
struct thread *td,
struct freebsd11_nstat_args *uap)
2521 error =
kern_statat(td, 0, AT_FDCWD, uap->path, UIO_USERSPACE,
2525 error = freebsd11_cvtnstat(&sb, &nsb);
2527 error = copyout(&nsb, uap->ub, sizeof (nsb));
2534#ifndef _SYS_SYSPROTO_H_
2535struct freebsd11_nlstat_args {
2541freebsd11_nlstat(
struct thread *td,
struct freebsd11_nlstat_args *uap)
2547 error =
kern_statat(td, AT_SYMLINK_NOFOLLOW, AT_FDCWD, uap->path,
2548 UIO_USERSPACE, &sb, NULL);
2551 error = freebsd11_cvtnstat(&sb, &nsb);
2553 error = copyout(&nsb, uap->ub, sizeof (nsb));
2561#ifndef _SYS_SYSPROTO_H_
2576 td->td_retval[0] =
value;
2580#ifndef _SYS_SYSPROTO_H_
2595 td->td_retval[0] =
value;
2603 struct nameidata nd;
2606 NDINIT(&nd, LOOKUP, LOCKSHARED | LOCKLEAF | AUDITVNODE1 |
flags,
2608 if ((error =
namei(&nd)) != 0)
2610 NDFREE_NOTHING(&nd);
2612 error = VOP_PATHCONF(nd.ni_vp,
name, valuep);
2620#ifndef _SYS_SYSPROTO_H_
2632 uap->
buf, UIO_USERSPACE, uap->
count));
2634#ifndef _SYS_SYSPROTO_H_
2652 enum uio_seg pathseg,
char *
buf,
enum uio_seg bufseg,
size_t count)
2655 struct nameidata nd;
2658 if (
count > IOSIZE_MAX)
2661 NDINIT_AT(&nd, LOOKUP, NOFOLLOW | LOCKSHARED | LOCKLEAF | AUDITVNODE1 |
2662 EMPTYPATH, pathseg,
path,
fd);
2664 if ((error =
namei(&nd)) != 0)
2666 NDFREE_NOTHING(&nd);
2686 ASSERT_VOP_LOCKED(vp,
"kern_readlink_vp(): vp not locked");
2688 error = mac_vnode_check_readlink(td->td_ucred, vp);
2692 if (vp->v_type != VLNK && (vp->v_vflag & VV_READLINK) == 0)
2695 aiov.iov_base =
buf;
2696 aiov.iov_len =
count;
2697 auio.uio_iov = &aiov;
2698 auio.uio_iovcnt = 1;
2699 auio.uio_offset = 0;
2700 auio.uio_rw = UIO_READ;
2701 auio.uio_segflg = bufseg;
2703 auio.uio_resid =
count;
2704 error = VOP_READLINK(vp, &auio, td->td_ucred);
2705 td->td_retval[0] =
count - auio.uio_resid;
2720 if (
flags == VNOVAL)
2721 return (EOPNOTSUPP);
2729 if (vp->v_type == VCHR || vp->v_type == VBLK) {
2730 error =
priv_check(td, PRIV_VFS_CHFLAGS_DEV);
2738 vattr.va_flags =
flags;
2739 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
2741 error = mac_vnode_check_setflags(td->td_ucred, vp, vattr.va_flags);
2744 error = VOP_SETATTR(vp, &vattr, td->td_ucred);
2753#ifndef _SYS_SYSPROTO_H_
2767#ifndef _SYS_SYSPROTO_H_
2786#ifndef _SYS_SYSPROTO_H_
2797 uap->
flags, AT_SYMLINK_NOFOLLOW));
2804 struct nameidata nd;
2807 if ((
atflag & ~(AT_SYMLINK_NOFOLLOW | AT_RESOLVE_BENEATH |
2808 AT_EMPTY_PATH)) != 0)
2811 AUDIT_ARG_FFLAGS(
flags);
2813 AT_RESOLVE_BENEATH | AT_EMPTY_PATH) | AUDITVNODE1, pathseg,
path,
2815 if ((error =
namei(&nd)) != 0)
2817 NDFREE_NOTHING(&nd);
2826#ifndef _SYS_SYSPROTO_H_
2838 AUDIT_ARG_FD(uap->
fd);
2839 AUDIT_ARG_FFLAGS(uap->
flags);
2845 if (AUDITING_TD(td)) {
2846 vn_lock(fp->f_vnode, LK_SHARED | LK_RETRY);
2847 AUDIT_ARG_VNODE1(fp->f_vnode);
2848 VOP_UNLOCK(fp->f_vnode);
2868 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
2870 vattr.va_mode =
mode & ALLPERMS;
2872 error = mac_vnode_check_setmode(cred, vp, vattr.va_mode);
2875 error = VOP_SETATTR(vp, &vattr, cred);
2884#ifndef _SYS_SYSPROTO_H_
2898#ifndef _SYS_SYSPROTO_H_
2917#ifndef _SYS_SYSPROTO_H_
2928 uap->
mode, AT_SYMLINK_NOFOLLOW));
2933 enum uio_seg pathseg, mode_t
mode,
int flag)
2935 struct nameidata nd;
2938 if ((
flag & ~(AT_SYMLINK_NOFOLLOW | AT_RESOLVE_BENEATH |
2939 AT_EMPTY_PATH)) != 0)
2942 AUDIT_ARG_MODE(
mode);
2944 AT_RESOLVE_BENEATH | AT_EMPTY_PATH) | AUDITVNODE1, pathseg,
path,
2946 if ((error =
namei(&nd)) != 0)
2948 NDFREE_NOTHING(&nd);
2957#ifndef _SYS_SYSPROTO_H_
2969 AUDIT_ARG_FD(uap->
fd);
2970 AUDIT_ARG_MODE(uap->
mode);
2975 error = fo_chmod(fp, uap->
mode, td->td_ucred, td);
2984setfown(
struct thread *td,
struct ucred *cred,
struct vnode *vp, uid_t uid,
2993 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
2998 error = mac_vnode_check_setowner(cred, vp, vattr.va_uid,
3002 error = VOP_SETATTR(vp, &vattr, cred);
3011#ifndef _SYS_SYSPROTO_H_
3026#ifndef _SYS_SYSPROTO_H_
3045 enum uio_seg pathseg,
int uid,
int gid,
int flag)
3047 struct nameidata nd;
3050 if ((
flag & ~(AT_SYMLINK_NOFOLLOW | AT_RESOLVE_BENEATH |
3051 AT_EMPTY_PATH)) != 0)
3054 AUDIT_ARG_OWNER(uid, gid);
3056 AT_RESOLVE_BENEATH | AT_EMPTY_PATH) | AUDITVNODE1, pathseg,
path,
3059 if ((error =
namei(&nd)) != 0)
3061 NDFREE_NOTHING(&nd);
3062 error =
setfown(td, td->td_ucred, nd.ni_vp, uid, gid);
3070#ifndef _SYS_SYSPROTO_H_
3082 uap->
uid, uap->
gid, AT_SYMLINK_NOFOLLOW));
3088#ifndef _SYS_SYSPROTO_H_
3101 AUDIT_ARG_FD(uap->
fd);
3102 AUDIT_ARG_OWNER(uap->
uid, uap->
gid);
3106 error = fo_chown(fp, uap->
uid, uap->
gid, td->td_ucred, td);
3116 struct timespec *tsp)
3118 struct timeval tv[2];
3119 const struct timeval *tvp;
3122 if (usrtvp == NULL) {
3126 if (tvpseg == UIO_SYSSPACE) {
3129 if ((error = copyin(usrtvp, tv,
sizeof(tv))) != 0)
3134 if (tvp[0].tv_usec < 0 || tvp[0].tv_usec >= 1000000 ||
3135 tvp[1].tv_usec < 0 || tvp[1].tv_usec >= 1000000)
3137 TIMEVAL_TO_TIMESPEC(&tvp[0], &tsp[0]);
3138 TIMEVAL_TO_TIMESPEC(&tvp[1], &tsp[1]);
3146#define UTIMENS_NULL 0x1
3147#define UTIMENS_EXIT 0x2
3150 struct timespec *tsp,
int *retflags)
3152 struct timespec tsnow;
3157 if (usrtsp == NULL) {
3163 if (tspseg == UIO_SYSSPACE) {
3166 }
else if ((error = copyin(usrtsp, tsp,
sizeof(*tsp) * 2)) != 0)
3168 if (tsp[0].tv_nsec == UTIME_OMIT && tsp[1].tv_nsec == UTIME_OMIT)
3170 if (tsp[0].tv_nsec == UTIME_NOW && tsp[1].tv_nsec == UTIME_NOW)
3172 if (tsp[0].tv_nsec == UTIME_OMIT)
3173 tsp[0].tv_sec = VNOVAL;
3174 else if (tsp[0].tv_nsec == UTIME_NOW)
3176 else if (tsp[0].tv_nsec < 0 || tsp[0].tv_nsec >= 1000000000L)
3178 if (tsp[1].tv_nsec == UTIME_OMIT)
3179 tsp[1].tv_sec = VNOVAL;
3180 else if (tsp[1].tv_nsec == UTIME_NOW)
3182 else if (tsp[1].tv_nsec < 0 || tsp[1].tv_nsec >= 1000000000L)
3193setutimes(
struct thread *td,
struct vnode *vp,
const struct timespec *
ts,
3194 int numtimes,
int nullflag)
3201 setbirthtime =
false;
3202 vattr.va_birthtime.tv_sec = VNOVAL;
3203 vattr.va_birthtime.tv_nsec = 0;
3207 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
3208 if (numtimes < 3 && VOP_GETATTR(vp, &vattr, td->td_ucred) == 0 &&
3209 timespeccmp(&
ts[1], &vattr.va_birthtime, < ))
3210 setbirthtime =
true;
3212 vattr.va_atime =
ts[0];
3213 vattr.va_mtime =
ts[1];
3215 vattr.va_birthtime =
ts[1];
3217 vattr.va_birthtime =
ts[2];
3219 vattr.va_vaflags |= VA_UTIMES_NULL;
3221 error = mac_vnode_check_setutimes(td->td_ucred, vp, vattr.va_atime,
3225 error = VOP_SETATTR(vp, &vattr, td->td_ucred);
3234#ifndef _SYS_SYSPROTO_H_
3245 uap->
tptr, UIO_USERSPACE));
3248#ifndef _SYS_SYSPROTO_H_
3260 uap->
times, UIO_USERSPACE));
3265 enum uio_seg pathseg,
const struct timeval *tptr,
enum uio_seg tptrseg)
3267 struct nameidata nd;
3268 struct timespec
ts[2];
3273 NDINIT_ATRIGHTS(&nd, LOOKUP, FOLLOW | AUDITVNODE1, pathseg,
path,
fd,
3276 if ((error =
namei(&nd)) != 0)
3278 NDFREE_NOTHING(&nd);
3279 error =
setutimes(td, nd.ni_vp,
ts, 2, tptr == NULL);
3287#ifndef _SYS_SYSPROTO_H_
3303 const struct timeval *tptr,
enum uio_seg tptrseg)
3305 struct timespec
ts[2];
3306 struct nameidata nd;
3311 NDINIT(&nd, LOOKUP, NOFOLLOW | AUDITVNODE1, pathseg,
path);
3312 if ((error =
namei(&nd)) != 0)
3314 NDFREE_NOTHING(&nd);
3315 error =
setutimes(td, nd.ni_vp,
ts, 2, tptr == NULL);
3323#ifndef _SYS_SYSPROTO_H_
3338 enum uio_seg tptrseg)
3340 struct timespec
ts[2];
3352 if (AUDITING_TD(td)) {
3353 vn_lock(fp->f_vnode, LK_SHARED | LK_RETRY);
3354 AUDIT_ARG_VNODE1(fp->f_vnode);
3355 VOP_UNLOCK(fp->f_vnode);
3358 error =
setutimes(td, fp->f_vnode,
ts, 2, tptr == NULL);
3367 return (
kern_futimens(td, uap->fd, uap->times, UIO_USERSPACE));
3372 enum uio_seg tptrseg)
3374 struct timespec
ts[2];
3388 if (AUDITING_TD(td)) {
3389 vn_lock(fp->f_vnode, LK_SHARED | LK_RETRY);
3390 AUDIT_ARG_VNODE1(fp->f_vnode);
3391 VOP_UNLOCK(fp->f_vnode);
3404 uap->times, UIO_USERSPACE, uap->flag));
3409 enum uio_seg pathseg,
const struct timespec *tptr,
enum uio_seg tptrseg,
3412 struct nameidata nd;
3413 struct timespec
ts[2];
3416 if ((
flag & ~(AT_SYMLINK_NOFOLLOW | AT_RESOLVE_BENEATH |
3417 AT_EMPTY_PATH)) != 0)
3423 AT_RESOLVE_BENEATH | AT_EMPTY_PATH) | AUDITVNODE1,
3425 if ((error =
namei(&nd)) != 0)
3433 NDFREE_NOTHING(&nd);
3443#ifndef _SYS_SYSPROTO_H_
3465 struct nameidata nd;
3472 NDINIT(&nd, LOOKUP, FOLLOW | AUDITVNODE1, pathseg,
path);
3473 if ((error =
namei(&nd)) != 0)
3476 rl_cookie = vn_rangelock_wlock(vp, 0, OFF_MAX);
3478 vn_rangelock_unlock(vp, rl_cookie);
3482 NDFREE(&nd, NDF_ONLY_PNBUF);
3483 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
3484 if (vp->v_type == VDIR)
3487 else if ((error = mac_vnode_check_write(td->td_ucred, NOCRED, vp))) {
3491 (error = VOP_ACCESS(vp, VWRITE, td->td_ucred, td)) == 0) {
3493 vattr.va_size = length;
3494 error = VOP_SETATTR(vp, &vattr, td->td_ucred);
3498 vn_rangelock_unlock(vp, rl_cookie);
3500 if (error == ERELOOKUP)
3505#if defined(COMPAT_43)
3509#ifndef _SYS_SYSPROTO_H_
3510struct otruncate_args {
3516otruncate(
struct thread *td,
struct otruncate_args *uap)
3519 return (
kern_truncate(td, uap->path, UIO_USERSPACE, uap->length));
3523#if defined(COMPAT_FREEBSD6)
3526freebsd6_truncate(
struct thread *td,
struct freebsd6_truncate_args *uap)
3529 return (
kern_truncate(td, uap->path, UIO_USERSPACE, uap->length));
3533freebsd6_ftruncate(
struct thread *td,
struct freebsd6_ftruncate_args *uap)
3562 AUDIT_ARG_VNODE1(vp);
3563 if (vp->v_object != NULL) {
3564 VM_OBJECT_WLOCK(vp->v_object);
3565 vm_object_page_clean(vp->v_object, 0, 0, 0);
3566 VM_OBJECT_WUNLOCK(vp->v_object);
3568 error = fullsync ? VOP_FSYNC(vp, MNT_WAIT, td) : VOP_FDATASYNC(vp, td);
3571 if (error == ERELOOKUP)
3581#ifndef _SYS_SYSPROTO_H_
3604#ifndef _SYS_SYSPROTO_H_
3615 uap->
to, UIO_USERSPACE));
3618#ifndef _SYS_SYSPROTO_H_
3636kern_renameat_mac(
struct thread *td,
int oldfd,
const char *old,
int newfd,
3637 const char *
new,
enum uio_seg pathseg,
struct nameidata *fromnd)
3641 NDINIT_ATRIGHTS(fromnd, DELETE, LOCKPARENT | LOCKLEAF | SAVESTART |
3643 if ((error =
namei(fromnd)) != 0)
3645 error = mac_vnode_check_rename_from(td->td_ucred, fromnd->ni_dvp,
3646 fromnd->ni_vp, &fromnd->ni_cnd);
3647 VOP_UNLOCK(fromnd->ni_dvp);
3648 if (fromnd->ni_dvp != fromnd->ni_vp)
3649 VOP_UNLOCK(fromnd->ni_vp);
3651 NDFREE(fromnd, NDF_ONLY_PNBUF);
3652 vrele(fromnd->ni_dvp);
3653 vrele(fromnd->ni_vp);
3654 if (fromnd->ni_startdir)
3655 vrele(fromnd->ni_startdir);
3663 const char *
new,
enum uio_seg pathseg)
3665 struct mount *mp = NULL;
3666 struct vnode *tvp, *fvp, *tdvp;
3667 struct nameidata fromnd, tond;
3674 if (mac_vnode_check_rename_from_enabled()) {
3675 error = kern_renameat_mac(td, oldfd, old, newfd,
new, pathseg,
3681 NDINIT_ATRIGHTS(&fromnd, DELETE, WANTPARENT | SAVESTART | AUDITVNODE1,
3683 if ((error =
namei(&fromnd)) != 0)
3689 tondflags = LOCKPARENT | LOCKLEAF | NOCACHE | SAVESTART | AUDITVNODE2;
3690 if (fromnd.ni_vp->v_type == VDIR)
3691 tondflags |= WILLBEDIR;
3692 NDINIT_ATRIGHTS(&tond, RENAME, tondflags, pathseg,
new, newfd,
3694 if ((error =
namei(&tond)) != 0) {
3696 if (error == EISDIR && fvp->v_type == VDIR)
3698 NDFREE(&fromnd, NDF_ONLY_PNBUF);
3699 vrele(fromnd.ni_dvp);
3707 NDFREE(&fromnd, NDF_ONLY_PNBUF);
3708 NDFREE(&tond, NDF_ONLY_PNBUF);
3715 vrele(fromnd.ni_dvp);
3717 vrele(tond.ni_startdir);
3718 if (fromnd.ni_startdir != NULL)
3719 vrele(fromnd.ni_startdir);
3726 if (fvp->v_type == VDIR && tvp->v_type != VDIR) {
3729 }
else if (fvp->v_type != VDIR && tvp->v_type == VDIR) {
3734 if (newfd != AT_FDCWD && (tond.ni_resflags & NIRES_ABS) == 0) {
3739 error = cap_check(&tond.ni_filecaps.fc_rights,
3758 error = mac_vnode_check_rename_to(td->td_ucred, tdvp,
3759 tond.ni_vp, fromnd.ni_dvp == tdvp, &tond.ni_cnd);
3763 error = VOP_RENAME(fromnd.ni_dvp, fromnd.ni_vp, &fromnd.ni_cnd,
3764 tond.ni_dvp, tond.ni_vp, &tond.ni_cnd);
3765 NDFREE(&fromnd, NDF_ONLY_PNBUF);
3766 NDFREE(&tond, NDF_ONLY_PNBUF);
3768 NDFREE(&fromnd, NDF_ONLY_PNBUF);
3769 NDFREE(&tond, NDF_ONLY_PNBUF);
3776 vrele(fromnd.ni_dvp);
3779 vrele(tond.ni_startdir);
3782 if (fromnd.ni_startdir)
3783 vrele(fromnd.ni_startdir);
3784 if (error == ERESTART)
3786 if (error == ERELOOKUP)
3794#ifndef _SYS_SYSPROTO_H_
3808#ifndef _SYS_SYSPROTO_H_
3828 struct nameidata nd;
3831 AUDIT_ARG_MODE(
mode);
3835 NDINIT_ATRIGHTS(&nd, CREATE, LOCKPARENT | SAVENAME | AUDITVNODE1 |
3836 NC_NOMAKEENTRY | NC_KEEPPOSENTRY | FAILIFEXISTS | WILLBEDIR,
3838 if ((error =
namei(&nd)) != 0)
3841 NDFREE(&nd, NDF_ONLY_PNBUF);
3848 vattr.va_type = VDIR;
3849 vattr.va_mode = (
mode & ACCESSPERMS) &~ td->td_proc->p_pd->pd_cmask;
3851 error = mac_vnode_check_create(td->td_ucred, nd.ni_dvp, &nd.ni_cnd,
3856 error = VOP_MKDIR(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr);
3860 NDFREE(&nd, NDF_ONLY_PNBUF);
3861 VOP_VPUT_PAIR(nd.ni_dvp, error == 0 ? &nd.ni_vp : NULL,
true);
3863 if (error == ERELOOKUP)
3871#ifndef _SYS_SYSPROTO_H_
3886 enum uio_seg pathseg,
int flag)
3891 struct nameidata nd;
3892 cap_rights_t rights;
3896 if (
fd != FD_NONE) {
3897 error =
getvnode(td,
fd, cap_rights_init_one(&rights,
3906 NDINIT_ATRIGHTS(&nd, DELETE, LOCKPARENT | LOCKLEAF | AUDITVNODE1 |
3909 if ((error =
namei(&nd)) != 0)
3912 if (vp->v_type != VDIR) {
3919 if (nd.ni_dvp == vp) {
3926 if (vp->v_vflag & VV_ROOT) {
3931 if (fp != NULL && fp->f_vnode != vp) {
3932 if (VN_IS_DOOMED(fp->f_vnode))
3940 error = mac_vnode_check_unlink(td->td_ucred, nd.ni_dvp, vp,
3946 NDFREE(&nd, NDF_ONLY_PNBUF);
3948 if (nd.ni_dvp == vp)
3957 error = VOP_RMDIR(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd);
3960 NDFREE(&nd, NDF_ONLY_PNBUF);
3962 if (nd.ni_dvp == vp)
3966 if (error == ERELOOKUP)
3974#if defined(COMPAT_43) || defined(COMPAT_FREEBSD11)
3976freebsd11_kern_getdirentries(
struct thread *td,
int fd,
char *ubuf, u_int
count,
3977 long *basep,
void (*func)(
struct freebsd11_dirent *))
3979 struct freebsd11_dirent dstdp;
3980 struct dirent *dp, *edp;
3983 ssize_t resid, ucount;
3999 for (dp = (
struct dirent *)dirbuf,
4000 edp = (
struct dirent *)&dirbuf[
count - resid];
4001 ucount <
count && dp < edp; ) {
4002 if (dp->d_reclen == 0)
4004 MPASS(dp->d_reclen >= _GENERIC_DIRLEN(0));
4005 if (dp->d_namlen >=
sizeof(dstdp.d_name))
4007 dstdp.d_type = dp->d_type;
4008 dstdp.d_namlen = dp->d_namlen;
4009 dstdp.d_fileno = dp->d_fileno;
4010 if (dstdp.d_fileno != dp->d_fileno) {
4011 switch (ino64_trunc_error) {
4019 dstdp.d_fileno = UINT32_MAX;
4023 dstdp.d_reclen =
sizeof(dstdp) -
sizeof(dstdp.d_name) +
4024 ((dp->d_namlen + 1 + 3) &~ 3);
4025 bcopy(dp->d_name, dstdp.d_name, dstdp.d_namlen);
4026 bzero(dstdp.d_name + dstdp.d_namlen,
4027 dstdp.d_reclen - offsetof(
struct freebsd11_dirent, d_name) -
4029 MPASS(dstdp.d_reclen <= dp->d_reclen);
4030 MPASS(ucount + dstdp.d_reclen <=
count);
4033 error = copyout(&dstdp, ubuf + ucount, dstdp.d_reclen);
4036 dp = (
struct dirent *)((
char *)dp + dp->d_reclen);
4037 ucount += dstdp.d_reclen;
4041 free(dirbuf, M_TEMP);
4043 td->td_retval[0] = ucount;
4050ogetdirentries_cvt(
struct freebsd11_dirent *dp)
4052#if (BYTE_ORDER == LITTLE_ENDIAN)
4057 dp->d_type = dp->d_namlen;
4071#ifndef _SYS_SYSPROTO_H_
4072struct ogetdirentries_args {
4080ogetdirentries(
struct thread *td,
struct ogetdirentries_args *uap)
4085 error = kern_ogetdirentries(td, uap, &loff);
4087 error = copyout(&loff, uap->basep,
sizeof(
long));
4092kern_ogetdirentries(
struct thread *td,
struct ogetdirentries_args *uap,
4099 if (uap->count > 64 * 1024)
4102 error = freebsd11_kern_getdirentries(td, uap->fd, uap->buf, uap->count,
4103 &base, ogetdirentries_cvt);
4105 if (error == 0 && uap->basep != NULL)
4106 error = copyout(&base, uap->basep,
sizeof(
long));
4112#if defined(COMPAT_FREEBSD11)
4113#ifndef _SYS_SYSPROTO_H_
4114struct freebsd11_getdirentries_args {
4122freebsd11_getdirentries(
struct thread *td,
4123 struct freebsd11_getdirentries_args *uap)
4128 error = freebsd11_kern_getdirentries(td, uap->fd, uap->buf, uap->count,
4131 if (error == 0 && uap->basep != NULL)
4132 error = copyout(&base, uap->basep,
sizeof(
long));
4137freebsd11_getdents(
struct thread *td,
struct freebsd11_getdents_args *uap)
4139 struct freebsd11_getdirentries_args ap;
4143 ap.count = uap->count;
4145 return (freebsd11_getdirentries(td, &ap));
4159 NULL, UIO_USERSPACE);
4162 if (uap->basep != NULL)
4163 error = copyout(&base, uap->basep,
sizeof(off_t));
4169 off_t *basep, ssize_t *residp,
enum uio_seg bufseg)
4180 if (
count > IOSIZE_MAX)
4182 auio.uio_resid =
count;
4186 if ((fp->f_flag & FREAD) == 0) {
4193 if (vp->v_type != VDIR) {
4197 aiov.iov_base =
buf;
4198 aiov.iov_len =
count;
4199 auio.uio_iov = &aiov;
4200 auio.uio_iovcnt = 1;
4201 auio.uio_rw = UIO_READ;
4202 auio.uio_segflg = bufseg;
4204 vn_lock(vp, LK_SHARED | LK_RETRY);
4205 AUDIT_ARG_VNODE1(vp);
4206 loff = auio.uio_offset = foffset;
4208 error = mac_vnode_check_readdir(td->td_ucred, vp);
4211 error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag, NULL,
4213 foffset = auio.uio_offset;
4218 if (
count == auio.uio_resid &&
4219 (vp->v_vflag & VV_ROOT) &&
4220 (vp->v_mount->mnt_flag & MNT_UNION)) {
4221 struct vnode *tvp = vp;
4223 vp = vp->v_mount->mnt_vnodecovered;
4233 *residp = auio.uio_resid;
4234 td->td_retval[0] =
count - auio.uio_resid;
4244#ifndef _SYS_SYSPROTO_H_
4252 struct pwddesc *pdp;
4254 pdp = td->td_proc->p_pd;
4256 td->td_retval[0] = pdp->pd_cmask;
4257 pdp->pd_cmask = uap->
newmask & ALLPERMS;
4258 PWDDESC_XUNLOCK(pdp);
4266#ifndef _SYS_SYSPROTO_H_
4276 struct nameidata nd;
4279 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | AUDITVNODE1, UIO_USERSPACE,
4281 if ((error =
namei(&nd)) != 0)
4284 NDFREE_NOTHING(&nd);
4285 if (vp->v_type != VCHR || vp->v_rdev == NULL) {
4290 error = mac_vnode_check_revoke(td->td_ucred, vp);
4294 error = VOP_GETATTR(vp, &vattr, td->td_ucred);
4297 if (td->td_ucred->cr_uid != vattr.va_uid) {
4302 if (devfs_usecount(vp) > 0)
4303 VOP_REVOKE(vp, REVOKEALL);
4337 if (__predict_false(fp->f_vnode == NULL || fp->f_ops == &
badfileops)) {
4353getvnode(
struct thread *td,
int fd, cap_rights_t *rightsp,
struct file **fpp)
4358 if (__predict_false(error != 0))
4377#ifndef _SYS_SYSPROTO_H_
4388 UIO_USERSPACE, uap->
fhp, UIO_USERSPACE));
4391#ifndef _SYS_SYSPROTO_H_
4402 uap->
fhp, UIO_USERSPACE));
4412#ifndef _SYS_SYSPROTO_H_
4425 uap->
fhp, UIO_USERSPACE));
4430 enum uio_seg pathseg, fhandle_t *fhp,
enum uio_seg fhseg)
4432 struct nameidata nd;
4437 if ((
flags & ~(AT_SYMLINK_NOFOLLOW | AT_RESOLVE_BENEATH)) != 0)
4443 AT_RESOLVE_BENEATH) | LOCKLEAF | AUDITVNODE1, pathseg,
path,
4448 NDFREE_NOTHING(&nd);
4450 bzero(&fh,
sizeof(fh));
4451 fh.fh_fsid = vp->v_mount->mnt_stat.f_fsid;
4452 error = VOP_VPTOFH(vp, &fh.fh_fid);
4455 if (fhseg == UIO_USERSPACE)
4456 error = copyout(&fh, fhp,
sizeof (fh));
4458 memcpy(fhp, &fh,
sizeof(fh));
4463#ifndef _SYS_SYSPROTO_H_
4476#ifndef _SYS_SYSPROTO_H_
4492 enum uio_seg pathseg, fhandle_t *fhp)
4502 error = copyin(fhp, &fh,
sizeof(fh));
4509 error = VFS_FHTOVP(mp, &fh.fh_fid, LK_SHARED, &vp);
4515 }
while (error == EAGAIN || error == ERELOOKUP);
4519#ifndef _SYS_SYSPROTO_H_
4537 if (uap->
bufsize > IOSIZE_MAX)
4539 error = copyin(uap->
fhp, &fh,
sizeof(fh));
4544 error = VFS_FHTOVP(mp, &fh.fh_fid, LK_SHARED, &vp);
4560#ifndef _SYS_SYSPROTO_H_
4586 fmode = FFLAGS(
flags);
4588 if (((fmode & (FREAD | FWRITE)) == 0) || (fmode & O_CREAT))
4590 error = copyin(u_fhp, &fhp,
sizeof(fhp));
4598 error = VFS_FHTOVP(mp, &fhp.fh_fid, LK_EXCLUSIVE, &vp);
4603 error = falloc_noinstall(td, &fp);
4619 (
"VOP_OPEN in fhopen() set f_ops"));
4620 KASSERT(td->td_dupfd < 0,
4621 (
"fhopen() encountered fdopen()"));
4632 if ((fmode & O_TRUNC) != 0) {
4633 error = fo_truncate(fp, 0, td->td_ucred, td);
4638 error =
finstall(td, fp, &indx, fmode, NULL);
4641 td->td_retval[0] = indx;
4648#ifndef _SYS_SYSPROTO_H_
4661 error = copyin(uap->
u_fhp, &fh,
sizeof(fh));
4666 error = copyout(&sb, uap->
sb,
sizeof(sb));
4682 error = VFS_FHTOVP(mp, &fh.fh_fid, LK_EXCLUSIVE, &vp);
4686 error = VOP_STAT(vp, sb, td->td_ucred, NOCRED);
4694#ifndef _SYS_SYSPROTO_H_
4707 error = copyin(uap->
u_fhp, &fh,
sizeof(fhandle_t));
4710 sfp =
malloc(
sizeof(
struct statfs), M_STATFS, M_WAITOK);
4713 error = copyout(sfp, uap->
buf,
sizeof(*sfp));
4714 free(sfp, M_STATFS);
4730 error = VFS_FHTOVP(mp, &fh.fh_fid, LK_EXCLUSIVE, &vp);
4740 error = mac_mount_check_stat(td->td_ucred, mp);
4744 error = VFS_STATFS(mp,
buf);
4760 struct fadvise_info *fa, *
new;
4766 if (offset < 0 || len < 0 || offset > OFF_MAX - len)
4768 AUDIT_ARG_VALUE(advice);
4770 case POSIX_FADV_SEQUENTIAL:
4771 case POSIX_FADV_RANDOM:
4772 case POSIX_FADV_NOREUSE:
4773 new =
malloc(
sizeof(*fa), M_FADVISE, M_WAITOK);
4775 case POSIX_FADV_NORMAL:
4776 case POSIX_FADV_WILLNEED:
4777 case POSIX_FADV_DONTNEED:
4788 AUDIT_ARG_FILE(td->td_proc, fp);
4789 if ((fp->f_ops->fo_flags & DFLAG_SEEKABLE) == 0) {
4793 if (fp->f_type != DTYPE_VNODE) {
4798 if (vp->v_type != VREG) {
4805 end = offset + len - 1;
4807 case POSIX_FADV_SEQUENTIAL:
4808 case POSIX_FADV_RANDOM:
4809 case POSIX_FADV_NOREUSE:
4817 if (fa != NULL && fa->fa_advice == advice &&
4818 ((fa->fa_start <= end && fa->fa_end >= offset) ||
4819 (end != OFF_MAX && fa->fa_start == end + 1) ||
4820 (fa->fa_end != OFF_MAX && fa->fa_end + 1 == offset))) {
4821 if (offset < fa->fa_start)
4822 fa->fa_start = offset;
4823 if (end > fa->fa_end)
4826 new->fa_advice = advice;
4827 new->fa_start = offset;
4834 case POSIX_FADV_NORMAL:
4843 if (offset <= fa->fa_start && end >= fa->fa_end) {
4845 fp->f_advice = NULL;
4846 }
else if (offset <= fa->fa_start &&
4847 end >= fa->fa_start)
4848 fa->fa_start = end + 1;
4849 else if (offset <= fa->fa_end && end >= fa->fa_end)
4850 fa->fa_end = offset - 1;
4851 else if (offset >= fa->fa_start && end <= fa->fa_end) {
4861 fp->f_advice = NULL;
4866 case POSIX_FADV_WILLNEED:
4867 case POSIX_FADV_DONTNEED:
4868 error = VOP_ADVISE(vp, offset, end, advice);
4874 free(
new, M_FADVISE);
4890 off_t *outoffp,
size_t len,
unsigned int flags)
4892 struct file *infp, *outfp;
4893 struct vnode *invp, *outvp;
4896 void *rl_rcookie, *rl_wcookie;
4897 off_t savinoff, savoutoff;
4899 infp = outfp = NULL;
4900 rl_rcookie = rl_wcookie = NULL;
4909 if (len > SSIZE_MAX)
4925 if (infp->f_vnode == NULL) {
4936 if (outfp->f_vnode == NULL) {
4943 inoffp = &infp->f_offset;
4944 if (outoffp == NULL)
4945 outoffp = &outfp->f_offset;
4947 savoutoff = *outoffp;
4949 invp = infp->f_vnode;
4950 outvp = outfp->f_vnode;
4952 if ((outfp->f_flag & (FWRITE | FAPPEND)) != FWRITE ||
4953 (infp->f_flag & FREAD) == 0) {
4966 if (invp == outvp && ((savinoff <= savoutoff && savinoff + len >
4967 savoutoff) || (savinoff > savoutoff && savoutoff + len >
4975 rl_wcookie = vn_rangelock_wlock(outvp, *outoffp, *outoffp +
4977 rl_rcookie = vn_rangelock_tryrlock(invp, *inoffp, *inoffp +
4979 if (rl_rcookie != NULL)
4981 vn_rangelock_unlock(outvp, rl_wcookie);
4982 rl_rcookie = vn_rangelock_rlock(invp, *inoffp, *inoffp + len);
4983 vn_rangelock_unlock(invp, rl_rcookie);
4988 flags, infp->f_cred, outfp->f_cred, td);
4990 if (rl_rcookie != NULL)
4991 vn_rangelock_unlock(invp, rl_rcookie);
4992 if (rl_wcookie != NULL)
4993 vn_rangelock_unlock(outvp, rl_wcookie);
4994 if (savinoff != -1 && (error == EINTR || error == ERESTART)) {
4996 *outoffp = savoutoff;
5002 td->td_retval[0] = retlen;
5009 off_t inoff, outoff, *inoffp, *outoffp;
5012 inoffp = outoffp = NULL;
5013 if (uap->inoffp != NULL) {
5014 error = copyin(uap->inoffp, &inoff,
sizeof(off_t));
5019 if (uap->outoffp != NULL) {
5020 error = copyin(uap->outoffp, &outoff,
sizeof(off_t));
5026 outoffp, uap->len, uap->flags);
5027 if (error == 0 && uap->inoffp != NULL)
5028 error = copyout(inoffp, uap->inoffp,
sizeof(off_t));
5029 if (error == 0 && uap->outoffp != NULL)
5030 error = copyout(outoffp, uap->outoffp,
sizeof(off_t));
static struct bt_table st
int finstall(struct thread *td, struct file *fp, int *fd, int flags, struct filecaps *fcaps)
void pwd_chdir(struct thread *td, struct vnode *vp)
int fget_write(struct thread *td, int fd, cap_rights_t *rightsp, struct file **fpp)
void falloc_abort(struct thread *td, struct file *fp)
int pwd_chroot(struct thread *td, struct vnode *vp)
int finstall_refed(struct thread *td, struct file *fp, int *fd, int flags, struct filecaps *fcaps)
void filecaps_free(struct filecaps *fcaps)
int fget(struct thread *td, int fd, cap_rights_t *rightsp, struct file **fpp)
int fget_unlocked(struct thread *td, int fd, cap_rights_t *needrightsp, struct file **fpp)
struct fileops badfileops
int kern_fstat(struct thread *td, int fd, struct stat *sbp)
int dupfdopen(struct thread *td, struct filedesc *fdp, int dfd, int mode, int openerror, int *indxp)
void finit(struct file *fp, u_int flag, short type, void *data, struct fileops *ops)
int fget_read(struct thread *td, int fd, cap_rights_t *rightsp, struct file **fpp)
struct fileops path_fileops
void finit_vnode(struct file *fp, u_int flag, void *data, struct fileops *ops)
int prison_canseemount(struct ucred *cred, struct mount *mp)
void prison_enforce_statfs(struct ucred *cred, struct mount *mp, struct statfs *sp)
int prison_allow(struct ucred *cred, unsigned flag)
void *() malloc(size_t size, struct malloc_type *mtp, int flags)
void free(void *addr, struct malloc_type *mtp)
struct mtx_pool __read_mostly * mtxpool_sleep
int priv_check_cred_vfs_generation(struct ucred *cred)
int priv_check_cred(struct ucred *cred, int priv)
int priv_check(struct thread *td, int priv)
struct ucred * crdup(struct ucred *cr)
int groupmember(gid_t gid, struct ucred *cred)
void crfree(struct ucred *cr)
void panic(const char *fmt,...)
const struct fhandle * u_fhp
const struct timeval * times
__read_mostly cap_rights_t cap_renameat_source_rights
__read_mostly cap_rights_t cap_unlinkat_rights
__read_mostly cap_rights_t cap_linkat_target_rights
__read_mostly cap_rights_t cap_fchown_rights
__read_mostly cap_rights_t cap_fchdir_rights
__read_mostly cap_rights_t cap_mkdirat_rights
__read_mostly cap_rights_t cap_no_rights
__read_mostly cap_rights_t cap_write_rights
__read_mostly cap_rights_t cap_symlinkat_rights
__read_mostly cap_rights_t cap_mknodat_rights
__read_mostly cap_rights_t cap_renameat_target_rights
__read_mostly cap_rights_t cap_mkfifoat_rights
__read_mostly cap_rights_t cap_futimes_rights
__read_mostly cap_rights_t cap_fchflags_rights
__read_mostly cap_rights_t cap_fsync_rights
__read_mostly cap_rights_t cap_fchmod_rights
__read_mostly cap_rights_t cap_fstatfs_rights
__read_mostly cap_rights_t cap_seek_rights
__read_mostly cap_rights_t cap_linkat_source_rights
__read_mostly cap_rights_t cap_fstat_rights
__read_mostly cap_rights_t cap_read_rights
int kern_posix_error(struct thread *td, int error)
int kern_ftruncate(struct thread *td, int fd, off_t length)
void() NDFREE(struct nameidata *ndp, const u_int flags)
int namei(struct nameidata *ndp)
struct mtx_padalign __exclusive_cache_line mountlist_mtx
void vfs_rel(struct mount *mp)
struct mount * vfs_ref_from_vp(struct vnode *vp)
void vfs_ref(struct mount *mp)
void vhold(struct vnode *vp)
void vfs_periodic(struct mount *mp, int flags)
void vref(struct vnode *vp)
void vfs_unbusy(struct mount *mp)
void vrele(struct vnode *vp)
void vfs_timestamp(struct timespec *tsp)
void vput(struct vnode *vp)
int vfs_busy(struct mount *mp, int flags)
void vunref(struct vnode *vp)
struct mount * vfs_busyfs(fsid_t *fsid)
void vfs_notify_upper(struct vnode *vp, enum vfs_notify_upper_type event)
int sys_chown(struct thread *td, struct chown_args *uap)
int sys_fhstatfs(struct thread *td, struct fhstatfs_args *uap)
struct lchflags_args sys_chflagsat
int kern_accessat(struct thread *td, int fd, const char *path, enum uio_seg pathseg, int flag, int amode)
int sys_symlinkat(struct thread *td, struct symlinkat_args *uap)
int setfown(struct thread *td, struct ucred *cred, struct vnode *vp, uid_t uid, gid_t gid)
int sys_getfhat(struct thread *td, struct getfhat_args *uap)
MALLOC_DEFINE(M_FADVISE, "fadvise", "posix_fadvise(2) information")
int kern_truncate(struct thread *td, const char *path, enum uio_seg pathseg, off_t length)
int kern_readlinkat(struct thread *td, int fd, const char *path, enum uio_seg pathseg, char *buf, enum uio_seg bufseg, size_t count)
static uint64_t at2cnpflags(u_int at_flags, u_int mask)
int sys_fhlink(struct thread *td, struct fhlink_args *uap)
static int hardlink_check_gid
int sys_symlink(struct thread *td, struct symlink_args *uap)
int sys_lutimes(struct thread *td, struct lutimes_args *uap)
int getvnode(struct thread *td, int fd, cap_rights_t *rightsp, struct file **fpp)
int sys_mkdirat(struct thread *td, struct mkdirat_args *uap)
int sys_statfs(struct thread *td, struct statfs_args *uap)
int sys_fhopen(struct thread *td, struct fhopen_args *uap)
int kern_chdir(struct thread *td, const char *path, enum uio_seg pathseg)
int sys_rename(struct thread *td, struct rename_args *uap)
int sys_readlinkat(struct thread *td, struct readlinkat_args *uap)
int kern_utimesat(struct thread *td, int fd, const char *path, enum uio_seg pathseg, const struct timeval *tptr, enum uio_seg tptrseg)
int kern_openat(struct thread *td, int fd, const char *path, enum uio_seg pathseg, int flags, int mode)
int sys_fchdir(struct thread *td, struct fchdir_args *uap)
int sys_funlinkat(struct thread *td, struct funlinkat_args *uap)
int kern_getdirentries(struct thread *td, int fd, char *buf, size_t count, off_t *basep, ssize_t *residp, enum uio_seg bufseg)
int kern_linkat(struct thread *td, int fd1, int fd2, const char *path1, const char *path2, enum uio_seg segflag, int flag)
int sys_utimes(struct thread *td, struct utimes_args *uap)
int kern_fstatfs(struct thread *td, int fd, struct statfs *buf)
int sys_access(struct thread *td, struct access_args *uap)
int sys_mkdir(struct thread *td, struct mkdir_args *uap)
int setfmode(struct thread *td, struct ucred *cred, struct vnode *vp, int mode)
int sys_open(struct thread *td, struct open_args *uap)
int sys_chflags(struct thread *td, struct chflags_args *uap)
int sys_revoke(struct thread *td, struct revoke_args *uap)
int sys_renameat(struct thread *td, struct renameat_args *uap)
static __inline void flags_to_rights(int flags, cap_rights_t *rightsp)
static int unprivileged_chroot
static int kern_fhlinkat(struct thread *td, int fd, const char *path, enum uio_seg pathseg, fhandle_t *fhp)
int kern_fhstatfs(struct thread *td, fhandle_t fh, struct statfs *buf)
struct pathconf_args sys_fstatat
int sys_futimes(struct thread *td, struct futimes_args *uap)
int sys_getdirentries(struct thread *td, struct getdirentries_args *uap)
int sys_fchown(struct thread *td, struct fchown_args *uap)
int sys_getfsstat(struct thread *td, struct getfsstat_args *uap)
int kern_mkfifoat(struct thread *td, int fd, const char *path, enum uio_seg pathseg, int mode)
int kern_renameat(struct thread *td, int oldfd, const char *old, int newfd, const char *new, enum uio_seg pathseg)
int sys_sync(struct thread *td, struct sync_args *uap)
static int kern_linkat_vp(struct thread *td, struct vnode *vp, int fd, const char *path, enum uio_seg segflag)
int kern_copy_file_range(struct thread *td, int infd, off_t *inoffp, int outfd, off_t *outoffp, size_t len, unsigned int flags)
int kern_posix_fadvise(struct thread *td, int fd, off_t offset, off_t len, int advice)
int sys_getfh(struct thread *td, struct getfh_args *uap)
static int setutimes(struct thread *td, struct vnode *, const struct timespec *, int, int)
int sys_fhlinkat(struct thread *td, struct fhlinkat_args *uap)
int kern_fsync(struct thread *td, int fd, bool fullsync)
struct eaccess_args sys_faccessat
int sys_utimensat(struct thread *td, struct utimensat_args *uap)
int kern_pathconf(struct thread *td, const char *path, enum uio_seg pathseg, int name, u_long flags, long *valuep)
int sys_rmdir(struct thread *td, struct rmdir_args *uap)
static int can_hardlink(struct vnode *vp, struct ucred *cred)
int sys_fhstat(struct thread *td, struct fhstat_args *uap)
int sys_fstatfs(struct thread *td, struct fstatfs_args *uap)
int sys_openat(struct thread *td, struct openat_args *uap)
int sys_posix_fadvise(struct thread *td, struct posix_fadvise_args *uap)
int sys_lchmod(struct thread *td, struct lchmod_args *uap)
int sys_readlink(struct thread *td, struct readlink_args *uap)
int getvnode_path(struct thread *td, int fd, cap_rights_t *rightsp, struct file **fpp)
int kern_fhstat(struct thread *td, struct fhandle fh, struct stat *sb)
int sys_lseek(struct thread *td, struct lseek_args *uap)
int sys_chroot(struct thread *td, struct chroot_args *uap)
int sys_fhreadlink(struct thread *td, struct fhreadlink_args *uap)
int kern_sync(struct thread *td)
int change_dir(struct vnode *vp, struct thread *td)
static int getutimes(const struct timeval *, enum uio_seg, struct timespec *)
static int kern_chflagsat(struct thread *td, int fd, const char *path, enum uio_seg pathseg, u_long flags, int atflag)
static int kern_readlink_vp(struct vnode *vp, char *buf, enum uio_seg bufseg, size_t count, struct thread *td)
int kern_frmdirat(struct thread *td, int dfd, const char *path, int fd, enum uio_seg pathseg, int flag)
int kern_mkdirat(struct thread *td, int fd, const char *path, enum uio_seg segflg, int mode)
int sys_fchmod(struct thread *td, struct fchmod_args *uap)
int kern_fhopen(struct thread *td, const struct fhandle *u_fhp, int flags)
int kern_fchmodat(struct thread *td, int fd, const char *path, enum uio_seg pathseg, mode_t mode, int flag)
int sys_quotactl(struct thread *td, struct quotactl_args *uap)
static int kern_funlinkat_ex(struct thread *td, int dfd, const char *path, int fd, int flag, enum uio_seg pathseg, ino_t oldinum)
SYSCTL_INT(_security_bsd, OID_AUTO, unprivileged_chroot, CTLFLAG_RW, &unprivileged_chroot, 0, "Unprivileged processes can use chroot(2)")
int sys_chmod(struct thread *td, struct chmod_args *uap)
int sys_pathconf(struct thread *td, struct pathconf_args *uap)
int sys_lchflags(struct thread *td, struct lchflags_args *uap)
int kern_futimes(struct thread *td, int fd, const struct timeval *tptr, enum uio_seg tptrseg)
int sys_truncate(struct thread *td, struct truncate_args *uap)
int kern_getfhat(struct thread *td, int flags, int fd, const char *path, enum uio_seg pathseg, fhandle_t *fhp, enum uio_seg fhseg)
int sys_lgetfh(struct thread *td, struct lgetfh_args *uap)
int sys_fchownat(struct thread *td, struct fchownat_args *uap)
int sys_fchflags(struct thread *td, struct fchflags_args *uap)
int sys_futimesat(struct thread *td, struct futimesat_args *uap)
static int getutimens(const struct timespec *, enum uio_seg, struct timespec *, int *)
int sys_lpathconf(struct thread *td, struct lpathconf_args *uap)
int kern_getfsstat(struct thread *td, struct statfs **buf, size_t bufsize, size_t *countp, enum uio_seg bufseg, int mode)
int kern_funlinkat(struct thread *td, int dfd, const char *path, int fd, enum uio_seg pathseg, int flag, ino_t oldinum)
int sys_unlink(struct thread *td, struct unlink_args *uap)
int sys_eaccess(struct thread *td, struct eaccess_args *uap)
int sys_chdir(struct thread *td, struct chdir_args *uap)
int sys_unlinkat(struct thread *td, struct unlinkat_args *uap)
int sys_lchown(struct thread *td, struct lchown_args *uap)
int kern_statfs(struct thread *td, const char *path, enum uio_seg pathseg, struct statfs *buf)
int sys_undelete(struct thread *td, struct undelete_args *uap)
int sys_umask(struct thread *td, struct umask_args *uap)
int sys_mknodat(struct thread *td, struct mknodat_args *uap)
int kern_utimensat(struct thread *td, int fd, const char *path, enum uio_seg pathseg, const struct timespec *tptr, enum uio_seg tptrseg, int flag)
void statfs_scale_blocks(struct statfs *sf, long max_size)
int kern_statat(struct thread *td, int flag, int fd, const char *path, enum uio_seg pathseg, struct stat *sbp, void(*hook)(struct vnode *vp, struct stat *sbp))
int kern_lseek(struct thread *td, int fd, off_t offset, int whence)
int sys_link(struct thread *td, struct link_args *uap)
struct lchmod_args sys_fchmodat
int sys_linkat(struct thread *td, struct linkat_args *uap)
static int vn_access(struct vnode *vp, int user_flags, struct ucred *cred, struct thread *td)
int sys_fdatasync(struct thread *td, struct fdatasync_args *uap)
int kern_lutimes(struct thread *td, const char *path, enum uio_seg pathseg, const struct timeval *tptr, enum uio_seg tptrseg)
int sys_futimens(struct thread *td, struct futimens_args *uap)
int kern_futimens(struct thread *td, int fd, const struct timespec *tptr, enum uio_seg tptrseg)
int sys_fsync(struct thread *td, struct fsync_args *uap)
int kern_mknodat(struct thread *td, int fd, const char *path, enum uio_seg pathseg, int mode, dev_t dev)
static int setfflags(struct thread *td, struct vnode *, u_long)
int sys_mkfifo(struct thread *td, struct mkfifo_args *uap)
int kern_symlinkat(struct thread *td, const char *path1, int fd, const char *path2, enum uio_seg segflg)
int kern_fchownat(struct thread *td, int fd, const char *path, enum uio_seg pathseg, int uid, int gid, int flag)
int sys_copy_file_range(struct thread *td, struct copy_file_range_args *uap)
static int kern_do_statfs(struct thread *td, struct mount *mp, struct statfs *buf)
int sys_mkfifoat(struct thread *td, struct mkfifoat_args *uap)
int vn_copy_file_range(struct vnode *invp, off_t *inoffp, struct vnode *outvp, off_t *outoffp, size_t *lenp, unsigned int flags, struct ucred *incred, struct ucred *outcred, struct thread *fsize_td)
int vn_start_write(struct vnode *vp, struct mount **mpp, int flags)
int vn_writechk(struct vnode *vp)
int vn_lktype_write(struct mount *mp, struct vnode *vp)
void foffset_unlock(struct file *fp, off_t val, int flags)
int vn_open(struct nameidata *ndp, int *flagp, int cmode, struct file *fp)
void vn_finished_write(struct mount *mp)
int vn_open_vnode(struct vnode *vp, int fmode, struct ucred *cred, struct thread *td, struct file *fp)
off_t foffset_lock(struct file *fp, int flags)