1 /*- 2 * Copyright (c) 1989, 1993 3 * The Regents of the University of California. All rights reserved. 4 * (c) UNIX System Laboratories, Inc. 5 * All or some portions of this file are derived from material licensed 6 * to the University of California by American Telephone and Telegraph 7 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 8 * the permission of UNIX System Laboratories, Inc. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 4. Neither the name of the University nor the names of its contributors 19 * may be used to endorse or promote products derived from this software 20 * without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 * 34 * @(#)vfs_syscalls.c 8.13 (Berkeley) 4/15/94 35 */ 36 37 #include <sys/cdefs.h> 38 __FBSDID("$FreeBSD$"); 39 40 #include "opt_capsicum.h" 41 #include "opt_compat.h" 42 #include "opt_ktrace.h" 43 44 #include <sys/param.h> 45 #include <sys/systm.h> 46 #include <sys/bio.h> 47 #include <sys/buf.h> 48 #include <sys/capsicum.h> 49 #include <sys/disk.h> 50 #include <sys/sysent.h> 51 #include <sys/malloc.h> 52 #include <sys/mount.h> 53 #include <sys/mutex.h> 54 #include <sys/sysproto.h> 55 #include <sys/namei.h> 56 #include <sys/filedesc.h> 57 #include <sys/kernel.h> 58 #include <sys/fcntl.h> 59 #include <sys/file.h> 60 #include <sys/filio.h> 61 #include <sys/limits.h> 62 #include <sys/linker.h> 63 #include <sys/rwlock.h> 64 #include <sys/sdt.h> 65 #include <sys/stat.h> 66 #include <sys/sx.h> 67 #include <sys/unistd.h> 68 #include <sys/vnode.h> 69 #include <sys/priv.h> 70 #include <sys/proc.h> 71 #include <sys/dirent.h> 72 #include <sys/jail.h> 73 #include <sys/syscallsubr.h> 74 #include <sys/sysctl.h> 75 #ifdef KTRACE 76 #include <sys/ktrace.h> 77 #endif 78 79 #include <machine/stdarg.h> 80 81 #include <security/audit/audit.h> 82 #include <security/mac/mac_framework.h> 83 84 #include <vm/vm.h> 85 #include <vm/vm_object.h> 86 #include <vm/vm_page.h> 87 #include <vm/uma.h> 88 89 #include <ufs/ufs/quota.h> 90 91 MALLOC_DEFINE(M_FADVISE, "fadvise", "posix_fadvise(2) information"); 92 93 SDT_PROVIDER_DEFINE(vfs); 94 SDT_PROBE_DEFINE2(vfs, , stat, mode, "char *", "int"); 95 SDT_PROBE_DEFINE2(vfs, , stat, reg, "char *", "int"); 96 97 static int kern_chflagsat(struct thread *td, int fd, const char *path, 98 enum uio_seg pathseg, u_long flags, int atflag); 99 static int setfflags(struct thread *td, struct vnode *, u_long); 100 static int getutimes(const struct timeval *, enum uio_seg, struct timespec *); 101 static int getutimens(const struct timespec *, enum uio_seg, 102 struct timespec *, int *); 103 static int setutimes(struct thread *td, struct vnode *, 104 const struct timespec *, int, int); 105 static int vn_access(struct vnode *vp, int user_flags, struct ucred *cred, 106 struct thread *td); 107 108 /* 109 * The module initialization routine for POSIX asynchronous I/O will 110 * set this to the version of AIO that it implements. (Zero means 111 * that it is not implemented.) This value is used here by pathconf() 112 * and in kern_descrip.c by fpathconf(). 113 */ 114 int async_io_version; 115 116 /* 117 * Sync each mounted filesystem. 118 */ 119 #ifndef _SYS_SYSPROTO_H_ 120 struct sync_args { 121 int dummy; 122 }; 123 #endif 124 /* ARGSUSED */ 125 int 126 sys_sync(td, uap) 127 struct thread *td; 128 struct sync_args *uap; 129 { 130 struct mount *mp, *nmp; 131 int save; 132 133 mtx_lock(&mountlist_mtx); 134 for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) { 135 if (vfs_busy(mp, MBF_NOWAIT | MBF_MNTLSTLOCK)) { 136 nmp = TAILQ_NEXT(mp, mnt_list); 137 continue; 138 } 139 if ((mp->mnt_flag & MNT_RDONLY) == 0 && 140 vn_start_write(NULL, &mp, V_NOWAIT) == 0) { 141 save = curthread_pflags_set(TDP_SYNCIO); 142 vfs_msync(mp, MNT_NOWAIT); 143 VFS_SYNC(mp, MNT_NOWAIT); 144 curthread_pflags_restore(save); 145 vn_finished_write(mp); 146 } 147 mtx_lock(&mountlist_mtx); 148 nmp = TAILQ_NEXT(mp, mnt_list); 149 vfs_unbusy(mp); 150 } 151 mtx_unlock(&mountlist_mtx); 152 return (0); 153 } 154 155 /* 156 * Change filesystem quotas. 157 */ 158 #ifndef _SYS_SYSPROTO_H_ 159 struct quotactl_args { 160 char *path; 161 int cmd; 162 int uid; 163 caddr_t arg; 164 }; 165 #endif 166 int 167 sys_quotactl(td, uap) 168 struct thread *td; 169 register struct quotactl_args /* { 170 char *path; 171 int cmd; 172 int uid; 173 caddr_t arg; 174 } */ *uap; 175 { 176 struct mount *mp; 177 struct nameidata nd; 178 int error; 179 180 AUDIT_ARG_CMD(uap->cmd); 181 AUDIT_ARG_UID(uap->uid); 182 if (!prison_allow(td->td_ucred, PR_ALLOW_QUOTAS)) 183 return (EPERM); 184 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | AUDITVNODE1, UIO_USERSPACE, 185 uap->path, td); 186 if ((error = namei(&nd)) != 0) 187 return (error); 188 NDFREE(&nd, NDF_ONLY_PNBUF); 189 mp = nd.ni_vp->v_mount; 190 vfs_ref(mp); 191 vput(nd.ni_vp); 192 error = vfs_busy(mp, 0); 193 vfs_rel(mp); 194 if (error != 0) 195 return (error); 196 error = VFS_QUOTACTL(mp, uap->cmd, uap->uid, uap->arg); 197 198 /* 199 * Since quota on operation typically needs to open quota 200 * file, the Q_QUOTAON handler needs to unbusy the mount point 201 * before calling into namei. Otherwise, unmount might be 202 * started between two vfs_busy() invocations (first is our, 203 * second is from mount point cross-walk code in lookup()), 204 * causing deadlock. 205 * 206 * Require that Q_QUOTAON handles the vfs_busy() reference on 207 * its own, always returning with ubusied mount point. 208 */ 209 if ((uap->cmd >> SUBCMDSHIFT) != Q_QUOTAON) 210 vfs_unbusy(mp); 211 return (error); 212 } 213 214 /* 215 * Used by statfs conversion routines to scale the block size up if 216 * necessary so that all of the block counts are <= 'max_size'. Note 217 * that 'max_size' should be a bitmask, i.e. 2^n - 1 for some non-zero 218 * value of 'n'. 219 */ 220 void 221 statfs_scale_blocks(struct statfs *sf, long max_size) 222 { 223 uint64_t count; 224 int shift; 225 226 KASSERT(powerof2(max_size + 1), ("%s: invalid max_size", __func__)); 227 228 /* 229 * Attempt to scale the block counts to give a more accurate 230 * overview to userland of the ratio of free space to used 231 * space. To do this, find the largest block count and compute 232 * a divisor that lets it fit into a signed integer <= max_size. 233 */ 234 if (sf->f_bavail < 0) 235 count = -sf->f_bavail; 236 else 237 count = sf->f_bavail; 238 count = MAX(sf->f_blocks, MAX(sf->f_bfree, count)); 239 if (count <= max_size) 240 return; 241 242 count >>= flsl(max_size); 243 shift = 0; 244 while (count > 0) { 245 shift++; 246 count >>=1; 247 } 248 249 sf->f_bsize <<= shift; 250 sf->f_blocks >>= shift; 251 sf->f_bfree >>= shift; 252 sf->f_bavail >>= shift; 253 } 254 255 /* 256 * Get filesystem statistics. 257 */ 258 #ifndef _SYS_SYSPROTO_H_ 259 struct statfs_args { 260 char *path; 261 struct statfs *buf; 262 }; 263 #endif 264 int 265 sys_statfs(td, uap) 266 struct thread *td; 267 register struct statfs_args /* { 268 char *path; 269 struct statfs *buf; 270 } */ *uap; 271 { 272 struct statfs sf; 273 int error; 274 275 error = kern_statfs(td, uap->path, UIO_USERSPACE, &sf); 276 if (error == 0) 277 error = copyout(&sf, uap->buf, sizeof(sf)); 278 return (error); 279 } 280 281 int 282 kern_statfs(struct thread *td, char *path, enum uio_seg pathseg, 283 struct statfs *buf) 284 { 285 struct mount *mp; 286 struct statfs *sp, sb; 287 struct nameidata nd; 288 int error; 289 290 NDINIT(&nd, LOOKUP, FOLLOW | LOCKSHARED | LOCKLEAF | AUDITVNODE1, 291 pathseg, path, td); 292 error = namei(&nd); 293 if (error != 0) 294 return (error); 295 mp = nd.ni_vp->v_mount; 296 vfs_ref(mp); 297 NDFREE(&nd, NDF_ONLY_PNBUF); 298 vput(nd.ni_vp); 299 error = vfs_busy(mp, 0); 300 vfs_rel(mp); 301 if (error != 0) 302 return (error); 303 #ifdef MAC 304 error = mac_mount_check_stat(td->td_ucred, mp); 305 if (error != 0) 306 goto out; 307 #endif 308 /* 309 * Set these in case the underlying filesystem fails to do so. 310 */ 311 sp = &mp->mnt_stat; 312 sp->f_version = STATFS_VERSION; 313 sp->f_namemax = NAME_MAX; 314 sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; 315 error = VFS_STATFS(mp, sp); 316 if (error != 0) 317 goto out; 318 if (priv_check(td, PRIV_VFS_GENERATION)) { 319 bcopy(sp, &sb, sizeof(sb)); 320 sb.f_fsid.val[0] = sb.f_fsid.val[1] = 0; 321 prison_enforce_statfs(td->td_ucred, mp, &sb); 322 sp = &sb; 323 } 324 *buf = *sp; 325 out: 326 vfs_unbusy(mp); 327 return (error); 328 } 329 330 /* 331 * Get filesystem statistics. 332 */ 333 #ifndef _SYS_SYSPROTO_H_ 334 struct fstatfs_args { 335 int fd; 336 struct statfs *buf; 337 }; 338 #endif 339 int 340 sys_fstatfs(td, uap) 341 struct thread *td; 342 register struct fstatfs_args /* { 343 int fd; 344 struct statfs *buf; 345 } */ *uap; 346 { 347 struct statfs sf; 348 int error; 349 350 error = kern_fstatfs(td, uap->fd, &sf); 351 if (error == 0) 352 error = copyout(&sf, uap->buf, sizeof(sf)); 353 return (error); 354 } 355 356 int 357 kern_fstatfs(struct thread *td, int fd, struct statfs *buf) 358 { 359 struct file *fp; 360 struct mount *mp; 361 struct statfs *sp, sb; 362 struct vnode *vp; 363 cap_rights_t rights; 364 int error; 365 366 AUDIT_ARG_FD(fd); 367 error = getvnode(td, fd, cap_rights_init(&rights, CAP_FSTATFS), &fp); 368 if (error != 0) 369 return (error); 370 vp = fp->f_vnode; 371 vn_lock(vp, LK_SHARED | LK_RETRY); 372 #ifdef AUDIT 373 AUDIT_ARG_VNODE1(vp); 374 #endif 375 mp = vp->v_mount; 376 if (mp) 377 vfs_ref(mp); 378 VOP_UNLOCK(vp, 0); 379 fdrop(fp, td); 380 if (mp == NULL) { 381 error = EBADF; 382 goto out; 383 } 384 error = vfs_busy(mp, 0); 385 vfs_rel(mp); 386 if (error != 0) 387 return (error); 388 #ifdef MAC 389 error = mac_mount_check_stat(td->td_ucred, mp); 390 if (error != 0) 391 goto out; 392 #endif 393 /* 394 * Set these in case the underlying filesystem fails to do so. 395 */ 396 sp = &mp->mnt_stat; 397 sp->f_version = STATFS_VERSION; 398 sp->f_namemax = NAME_MAX; 399 sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; 400 error = VFS_STATFS(mp, sp); 401 if (error != 0) 402 goto out; 403 if (priv_check(td, PRIV_VFS_GENERATION)) { 404 bcopy(sp, &sb, sizeof(sb)); 405 sb.f_fsid.val[0] = sb.f_fsid.val[1] = 0; 406 prison_enforce_statfs(td->td_ucred, mp, &sb); 407 sp = &sb; 408 } 409 *buf = *sp; 410 out: 411 if (mp) 412 vfs_unbusy(mp); 413 return (error); 414 } 415 416 /* 417 * Get statistics on all filesystems. 418 */ 419 #ifndef _SYS_SYSPROTO_H_ 420 struct getfsstat_args { 421 struct statfs *buf; 422 long bufsize; 423 int flags; 424 }; 425 #endif 426 int 427 sys_getfsstat(td, uap) 428 struct thread *td; 429 register struct getfsstat_args /* { 430 struct statfs *buf; 431 long bufsize; 432 int flags; 433 } */ *uap; 434 { 435 size_t count; 436 int error; 437 438 error = kern_getfsstat(td, &uap->buf, uap->bufsize, &count, 439 UIO_USERSPACE, uap->flags); 440 if (error == 0) 441 td->td_retval[0] = count; 442 return (error); 443 } 444 445 /* 446 * If (bufsize > 0 && bufseg == UIO_SYSSPACE) 447 * The caller is responsible for freeing memory which will be allocated 448 * in '*buf'. 449 */ 450 int 451 kern_getfsstat(struct thread *td, struct statfs **buf, size_t bufsize, 452 size_t *countp, enum uio_seg bufseg, int flags) 453 { 454 struct mount *mp, *nmp; 455 struct statfs *sfsp, *sp, sb; 456 size_t count, maxcount; 457 int error; 458 459 maxcount = bufsize / sizeof(struct statfs); 460 if (bufsize == 0) 461 sfsp = NULL; 462 else if (bufseg == UIO_USERSPACE) 463 sfsp = *buf; 464 else /* if (bufseg == UIO_SYSSPACE) */ { 465 count = 0; 466 mtx_lock(&mountlist_mtx); 467 TAILQ_FOREACH(mp, &mountlist, mnt_list) { 468 count++; 469 } 470 mtx_unlock(&mountlist_mtx); 471 if (maxcount > count) 472 maxcount = count; 473 sfsp = *buf = malloc(maxcount * sizeof(struct statfs), M_TEMP, 474 M_WAITOK); 475 } 476 count = 0; 477 mtx_lock(&mountlist_mtx); 478 for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) { 479 if (prison_canseemount(td->td_ucred, mp) != 0) { 480 nmp = TAILQ_NEXT(mp, mnt_list); 481 continue; 482 } 483 #ifdef MAC 484 if (mac_mount_check_stat(td->td_ucred, mp) != 0) { 485 nmp = TAILQ_NEXT(mp, mnt_list); 486 continue; 487 } 488 #endif 489 if (vfs_busy(mp, MBF_NOWAIT | MBF_MNTLSTLOCK)) { 490 nmp = TAILQ_NEXT(mp, mnt_list); 491 continue; 492 } 493 if (sfsp && count < maxcount) { 494 sp = &mp->mnt_stat; 495 /* 496 * Set these in case the underlying filesystem 497 * fails to do so. 498 */ 499 sp->f_version = STATFS_VERSION; 500 sp->f_namemax = NAME_MAX; 501 sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; 502 /* 503 * If MNT_NOWAIT or MNT_LAZY is specified, do not 504 * refresh the fsstat cache. MNT_NOWAIT or MNT_LAZY 505 * overrides MNT_WAIT. 506 */ 507 if (((flags & (MNT_LAZY|MNT_NOWAIT)) == 0 || 508 (flags & MNT_WAIT)) && 509 (error = VFS_STATFS(mp, sp))) { 510 mtx_lock(&mountlist_mtx); 511 nmp = TAILQ_NEXT(mp, mnt_list); 512 vfs_unbusy(mp); 513 continue; 514 } 515 if (priv_check(td, PRIV_VFS_GENERATION)) { 516 bcopy(sp, &sb, sizeof(sb)); 517 sb.f_fsid.val[0] = sb.f_fsid.val[1] = 0; 518 prison_enforce_statfs(td->td_ucred, mp, &sb); 519 sp = &sb; 520 } 521 if (bufseg == UIO_SYSSPACE) 522 bcopy(sp, sfsp, sizeof(*sp)); 523 else /* if (bufseg == UIO_USERSPACE) */ { 524 error = copyout(sp, sfsp, sizeof(*sp)); 525 if (error != 0) { 526 vfs_unbusy(mp); 527 return (error); 528 } 529 } 530 sfsp++; 531 } 532 count++; 533 mtx_lock(&mountlist_mtx); 534 nmp = TAILQ_NEXT(mp, mnt_list); 535 vfs_unbusy(mp); 536 } 537 mtx_unlock(&mountlist_mtx); 538 if (sfsp && count > maxcount) 539 *countp = maxcount; 540 else 541 *countp = count; 542 return (0); 543 } 544 545 #ifdef COMPAT_FREEBSD4 546 /* 547 * Get old format filesystem statistics. 548 */ 549 static void cvtstatfs(struct statfs *, struct ostatfs *); 550 551 #ifndef _SYS_SYSPROTO_H_ 552 struct freebsd4_statfs_args { 553 char *path; 554 struct ostatfs *buf; 555 }; 556 #endif 557 int 558 freebsd4_statfs(td, uap) 559 struct thread *td; 560 struct freebsd4_statfs_args /* { 561 char *path; 562 struct ostatfs *buf; 563 } */ *uap; 564 { 565 struct ostatfs osb; 566 struct statfs sf; 567 int error; 568 569 error = kern_statfs(td, uap->path, UIO_USERSPACE, &sf); 570 if (error != 0) 571 return (error); 572 cvtstatfs(&sf, &osb); 573 return (copyout(&osb, uap->buf, sizeof(osb))); 574 } 575 576 /* 577 * Get filesystem statistics. 578 */ 579 #ifndef _SYS_SYSPROTO_H_ 580 struct freebsd4_fstatfs_args { 581 int fd; 582 struct ostatfs *buf; 583 }; 584 #endif 585 int 586 freebsd4_fstatfs(td, uap) 587 struct thread *td; 588 struct freebsd4_fstatfs_args /* { 589 int fd; 590 struct ostatfs *buf; 591 } */ *uap; 592 { 593 struct ostatfs osb; 594 struct statfs sf; 595 int error; 596 597 error = kern_fstatfs(td, uap->fd, &sf); 598 if (error != 0) 599 return (error); 600 cvtstatfs(&sf, &osb); 601 return (copyout(&osb, uap->buf, sizeof(osb))); 602 } 603 604 /* 605 * Get statistics on all filesystems. 606 */ 607 #ifndef _SYS_SYSPROTO_H_ 608 struct freebsd4_getfsstat_args { 609 struct ostatfs *buf; 610 long bufsize; 611 int flags; 612 }; 613 #endif 614 int 615 freebsd4_getfsstat(td, uap) 616 struct thread *td; 617 register struct freebsd4_getfsstat_args /* { 618 struct ostatfs *buf; 619 long bufsize; 620 int flags; 621 } */ *uap; 622 { 623 struct statfs *buf, *sp; 624 struct ostatfs osb; 625 size_t count, size; 626 int error; 627 628 count = uap->bufsize / sizeof(struct ostatfs); 629 size = count * sizeof(struct statfs); 630 error = kern_getfsstat(td, &buf, size, &count, UIO_SYSSPACE, 631 uap->flags); 632 if (size > 0) { 633 sp = buf; 634 while (count > 0 && error == 0) { 635 cvtstatfs(sp, &osb); 636 error = copyout(&osb, uap->buf, sizeof(osb)); 637 sp++; 638 uap->buf++; 639 count--; 640 } 641 free(buf, M_TEMP); 642 } 643 if (error == 0) 644 td->td_retval[0] = count; 645 return (error); 646 } 647 648 /* 649 * Implement fstatfs() for (NFS) file handles. 650 */ 651 #ifndef _SYS_SYSPROTO_H_ 652 struct freebsd4_fhstatfs_args { 653 struct fhandle *u_fhp; 654 struct ostatfs *buf; 655 }; 656 #endif 657 int 658 freebsd4_fhstatfs(td, uap) 659 struct thread *td; 660 struct freebsd4_fhstatfs_args /* { 661 struct fhandle *u_fhp; 662 struct ostatfs *buf; 663 } */ *uap; 664 { 665 struct ostatfs osb; 666 struct statfs sf; 667 fhandle_t fh; 668 int error; 669 670 error = copyin(uap->u_fhp, &fh, sizeof(fhandle_t)); 671 if (error != 0) 672 return (error); 673 error = kern_fhstatfs(td, fh, &sf); 674 if (error != 0) 675 return (error); 676 cvtstatfs(&sf, &osb); 677 return (copyout(&osb, uap->buf, sizeof(osb))); 678 } 679 680 /* 681 * Convert a new format statfs structure to an old format statfs structure. 682 */ 683 static void 684 cvtstatfs(nsp, osp) 685 struct statfs *nsp; 686 struct ostatfs *osp; 687 { 688 689 statfs_scale_blocks(nsp, LONG_MAX); 690 bzero(osp, sizeof(*osp)); 691 osp->f_bsize = nsp->f_bsize; 692 osp->f_iosize = MIN(nsp->f_iosize, LONG_MAX); 693 osp->f_blocks = nsp->f_blocks; 694 osp->f_bfree = nsp->f_bfree; 695 osp->f_bavail = nsp->f_bavail; 696 osp->f_files = MIN(nsp->f_files, LONG_MAX); 697 osp->f_ffree = MIN(nsp->f_ffree, LONG_MAX); 698 osp->f_owner = nsp->f_owner; 699 osp->f_type = nsp->f_type; 700 osp->f_flags = nsp->f_flags; 701 osp->f_syncwrites = MIN(nsp->f_syncwrites, LONG_MAX); 702 osp->f_asyncwrites = MIN(nsp->f_asyncwrites, LONG_MAX); 703 osp->f_syncreads = MIN(nsp->f_syncreads, LONG_MAX); 704 osp->f_asyncreads = MIN(nsp->f_asyncreads, LONG_MAX); 705 strlcpy(osp->f_fstypename, nsp->f_fstypename, 706 MIN(MFSNAMELEN, OMFSNAMELEN)); 707 strlcpy(osp->f_mntonname, nsp->f_mntonname, 708 MIN(MNAMELEN, OMNAMELEN)); 709 strlcpy(osp->f_mntfromname, nsp->f_mntfromname, 710 MIN(MNAMELEN, OMNAMELEN)); 711 osp->f_fsid = nsp->f_fsid; 712 } 713 #endif /* COMPAT_FREEBSD4 */ 714 715 /* 716 * Change current working directory to a given file descriptor. 717 */ 718 #ifndef _SYS_SYSPROTO_H_ 719 struct fchdir_args { 720 int fd; 721 }; 722 #endif 723 int 724 sys_fchdir(td, uap) 725 struct thread *td; 726 struct fchdir_args /* { 727 int fd; 728 } */ *uap; 729 { 730 struct vnode *vp, *tdp; 731 struct mount *mp; 732 struct file *fp; 733 cap_rights_t rights; 734 int error; 735 736 AUDIT_ARG_FD(uap->fd); 737 error = getvnode(td, uap->fd, cap_rights_init(&rights, CAP_FCHDIR), 738 &fp); 739 if (error != 0) 740 return (error); 741 vp = fp->f_vnode; 742 VREF(vp); 743 fdrop(fp, td); 744 vn_lock(vp, LK_SHARED | LK_RETRY); 745 AUDIT_ARG_VNODE1(vp); 746 error = change_dir(vp, td); 747 while (!error && (mp = vp->v_mountedhere) != NULL) { 748 if (vfs_busy(mp, 0)) 749 continue; 750 error = VFS_ROOT(mp, LK_SHARED, &tdp); 751 vfs_unbusy(mp); 752 if (error != 0) 753 break; 754 vput(vp); 755 vp = tdp; 756 } 757 if (error != 0) { 758 vput(vp); 759 return (error); 760 } 761 VOP_UNLOCK(vp, 0); 762 pwd_chdir(td, vp); 763 return (0); 764 } 765 766 /* 767 * Change current working directory (``.''). 768 */ 769 #ifndef _SYS_SYSPROTO_H_ 770 struct chdir_args { 771 char *path; 772 }; 773 #endif 774 int 775 sys_chdir(td, uap) 776 struct thread *td; 777 struct chdir_args /* { 778 char *path; 779 } */ *uap; 780 { 781 782 return (kern_chdir(td, uap->path, UIO_USERSPACE)); 783 } 784 785 int 786 kern_chdir(struct thread *td, char *path, enum uio_seg pathseg) 787 { 788 struct nameidata nd; 789 int error; 790 791 NDINIT(&nd, LOOKUP, FOLLOW | LOCKSHARED | LOCKLEAF | AUDITVNODE1, 792 pathseg, path, td); 793 if ((error = namei(&nd)) != 0) 794 return (error); 795 if ((error = change_dir(nd.ni_vp, td)) != 0) { 796 vput(nd.ni_vp); 797 NDFREE(&nd, NDF_ONLY_PNBUF); 798 return (error); 799 } 800 VOP_UNLOCK(nd.ni_vp, 0); 801 NDFREE(&nd, NDF_ONLY_PNBUF); 802 pwd_chdir(td, nd.ni_vp); 803 return (0); 804 } 805 806 /* 807 * Change notion of root (``/'') directory. 808 */ 809 #ifndef _SYS_SYSPROTO_H_ 810 struct chroot_args { 811 char *path; 812 }; 813 #endif 814 int 815 sys_chroot(td, uap) 816 struct thread *td; 817 struct chroot_args /* { 818 char *path; 819 } */ *uap; 820 { 821 struct nameidata nd; 822 int error; 823 824 error = priv_check(td, PRIV_VFS_CHROOT); 825 if (error != 0) 826 return (error); 827 NDINIT(&nd, LOOKUP, FOLLOW | LOCKSHARED | LOCKLEAF | AUDITVNODE1, 828 UIO_USERSPACE, uap->path, td); 829 error = namei(&nd); 830 if (error != 0) 831 goto error; 832 error = change_dir(nd.ni_vp, td); 833 if (error != 0) 834 goto e_vunlock; 835 #ifdef MAC 836 error = mac_vnode_check_chroot(td->td_ucred, nd.ni_vp); 837 if (error != 0) 838 goto e_vunlock; 839 #endif 840 VOP_UNLOCK(nd.ni_vp, 0); 841 error = pwd_chroot(td, nd.ni_vp); 842 vrele(nd.ni_vp); 843 NDFREE(&nd, NDF_ONLY_PNBUF); 844 return (error); 845 e_vunlock: 846 vput(nd.ni_vp); 847 error: 848 NDFREE(&nd, NDF_ONLY_PNBUF); 849 return (error); 850 } 851 852 /* 853 * Common routine for chroot and chdir. Callers must provide a locked vnode 854 * instance. 855 */ 856 int 857 change_dir(vp, td) 858 struct vnode *vp; 859 struct thread *td; 860 { 861 #ifdef MAC 862 int error; 863 #endif 864 865 ASSERT_VOP_LOCKED(vp, "change_dir(): vp not locked"); 866 if (vp->v_type != VDIR) 867 return (ENOTDIR); 868 #ifdef MAC 869 error = mac_vnode_check_chdir(td->td_ucred, vp); 870 if (error != 0) 871 return (error); 872 #endif 873 return (VOP_ACCESS(vp, VEXEC, td->td_ucred, td)); 874 } 875 876 static __inline void 877 flags_to_rights(int flags, cap_rights_t *rightsp) 878 { 879 880 if (flags & O_EXEC) { 881 cap_rights_set(rightsp, CAP_FEXECVE); 882 } else { 883 switch ((flags & O_ACCMODE)) { 884 case O_RDONLY: 885 cap_rights_set(rightsp, CAP_READ); 886 break; 887 case O_RDWR: 888 cap_rights_set(rightsp, CAP_READ); 889 /* FALLTHROUGH */ 890 case O_WRONLY: 891 cap_rights_set(rightsp, CAP_WRITE); 892 if (!(flags & (O_APPEND | O_TRUNC))) 893 cap_rights_set(rightsp, CAP_SEEK); 894 break; 895 } 896 } 897 898 if (flags & O_CREAT) 899 cap_rights_set(rightsp, CAP_CREATE); 900 901 if (flags & O_TRUNC) 902 cap_rights_set(rightsp, CAP_FTRUNCATE); 903 904 if (flags & (O_SYNC | O_FSYNC)) 905 cap_rights_set(rightsp, CAP_FSYNC); 906 907 if (flags & (O_EXLOCK | O_SHLOCK)) 908 cap_rights_set(rightsp, CAP_FLOCK); 909 } 910 911 /* 912 * Check permissions, allocate an open file structure, and call the device 913 * open routine if any. 914 */ 915 #ifndef _SYS_SYSPROTO_H_ 916 struct open_args { 917 char *path; 918 int flags; 919 int mode; 920 }; 921 #endif 922 int 923 sys_open(td, uap) 924 struct thread *td; 925 register struct open_args /* { 926 char *path; 927 int flags; 928 int mode; 929 } */ *uap; 930 { 931 932 return (kern_openat(td, AT_FDCWD, uap->path, UIO_USERSPACE, 933 uap->flags, uap->mode)); 934 } 935 936 #ifndef _SYS_SYSPROTO_H_ 937 struct openat_args { 938 int fd; 939 char *path; 940 int flag; 941 int mode; 942 }; 943 #endif 944 int 945 sys_openat(struct thread *td, struct openat_args *uap) 946 { 947 948 return (kern_openat(td, uap->fd, uap->path, UIO_USERSPACE, uap->flag, 949 uap->mode)); 950 } 951 952 int 953 kern_openat(struct thread *td, int fd, char *path, enum uio_seg pathseg, 954 int flags, int mode) 955 { 956 struct proc *p = td->td_proc; 957 struct filedesc *fdp = p->p_fd; 958 struct file *fp; 959 struct vnode *vp; 960 struct nameidata nd; 961 cap_rights_t rights; 962 int cmode, error, indx; 963 964 indx = -1; 965 966 AUDIT_ARG_FFLAGS(flags); 967 AUDIT_ARG_MODE(mode); 968 /* XXX: audit dirfd */ 969 cap_rights_init(&rights, CAP_LOOKUP); 970 flags_to_rights(flags, &rights); 971 /* 972 * Only one of the O_EXEC, O_RDONLY, O_WRONLY and O_RDWR flags 973 * may be specified. 974 */ 975 if (flags & O_EXEC) { 976 if (flags & O_ACCMODE) 977 return (EINVAL); 978 } else if ((flags & O_ACCMODE) == O_ACCMODE) { 979 return (EINVAL); 980 } else { 981 flags = FFLAGS(flags); 982 } 983 984 /* 985 * Allocate the file descriptor, but don't install a descriptor yet. 986 */ 987 error = falloc_noinstall(td, &fp); 988 if (error != 0) 989 return (error); 990 /* 991 * An extra reference on `fp' has been held for us by 992 * falloc_noinstall(). 993 */ 994 /* Set the flags early so the finit in devfs can pick them up. */ 995 fp->f_flag = flags & FMASK; 996 cmode = ((mode & ~fdp->fd_cmask) & ALLPERMS) & ~S_ISTXT; 997 NDINIT_ATRIGHTS(&nd, LOOKUP, FOLLOW | AUDITVNODE1, pathseg, path, fd, 998 &rights, td); 999 td->td_dupfd = -1; /* XXX check for fdopen */ 1000 error = vn_open(&nd, &flags, cmode, fp); 1001 if (error != 0) { 1002 /* 1003 * If the vn_open replaced the method vector, something 1004 * wonderous happened deep below and we just pass it up 1005 * pretending we know what we do. 1006 */ 1007 if (error == ENXIO && fp->f_ops != &badfileops) 1008 goto success; 1009 1010 /* 1011 * Handle special fdopen() case. bleh. 1012 * 1013 * Don't do this for relative (capability) lookups; we don't 1014 * understand exactly what would happen, and we don't think 1015 * that it ever should. 1016 */ 1017 if (nd.ni_strictrelative == 0 && 1018 (error == ENODEV || error == ENXIO) && 1019 td->td_dupfd >= 0) { 1020 error = dupfdopen(td, fdp, td->td_dupfd, flags, error, 1021 &indx); 1022 if (error == 0) 1023 goto success; 1024 } 1025 1026 goto bad; 1027 } 1028 td->td_dupfd = 0; 1029 NDFREE(&nd, NDF_ONLY_PNBUF); 1030 vp = nd.ni_vp; 1031 1032 /* 1033 * Store the vnode, for any f_type. Typically, the vnode use 1034 * count is decremented by direct call to vn_closefile() for 1035 * files that switched type in the cdevsw fdopen() method. 1036 */ 1037 fp->f_vnode = vp; 1038 /* 1039 * If the file wasn't claimed by devfs bind it to the normal 1040 * vnode operations here. 1041 */ 1042 if (fp->f_ops == &badfileops) { 1043 KASSERT(vp->v_type != VFIFO, ("Unexpected fifo.")); 1044 fp->f_seqcount = 1; 1045 finit(fp, (flags & FMASK) | (fp->f_flag & FHASLOCK), 1046 DTYPE_VNODE, vp, &vnops); 1047 } 1048 1049 VOP_UNLOCK(vp, 0); 1050 if (flags & O_TRUNC) { 1051 error = fo_truncate(fp, 0, td->td_ucred, td); 1052 if (error != 0) 1053 goto bad; 1054 } 1055 success: 1056 /* 1057 * If we haven't already installed the FD (for dupfdopen), do so now. 1058 */ 1059 if (indx == -1) { 1060 struct filecaps *fcaps; 1061 1062 #ifdef CAPABILITIES 1063 if (nd.ni_strictrelative == 1) 1064 fcaps = &nd.ni_filecaps; 1065 else 1066 #endif 1067 fcaps = NULL; 1068 error = finstall(td, fp, &indx, flags, fcaps); 1069 /* On success finstall() consumes fcaps. */ 1070 if (error != 0) { 1071 filecaps_free(&nd.ni_filecaps); 1072 goto bad; 1073 } 1074 } else { 1075 filecaps_free(&nd.ni_filecaps); 1076 } 1077 1078 /* 1079 * Release our private reference, leaving the one associated with 1080 * the descriptor table intact. 1081 */ 1082 fdrop(fp, td); 1083 td->td_retval[0] = indx; 1084 return (0); 1085 bad: 1086 KASSERT(indx == -1, ("indx=%d, should be -1", indx)); 1087 fdrop(fp, td); 1088 return (error); 1089 } 1090 1091 #ifdef COMPAT_43 1092 /* 1093 * Create a file. 1094 */ 1095 #ifndef _SYS_SYSPROTO_H_ 1096 struct ocreat_args { 1097 char *path; 1098 int mode; 1099 }; 1100 #endif 1101 int 1102 ocreat(td, uap) 1103 struct thread *td; 1104 register struct ocreat_args /* { 1105 char *path; 1106 int mode; 1107 } */ *uap; 1108 { 1109 1110 return (kern_openat(td, AT_FDCWD, uap->path, UIO_USERSPACE, 1111 O_WRONLY | O_CREAT | O_TRUNC, uap->mode)); 1112 } 1113 #endif /* COMPAT_43 */ 1114 1115 /* 1116 * Create a special file. 1117 */ 1118 #ifndef _SYS_SYSPROTO_H_ 1119 struct mknod_args { 1120 char *path; 1121 int mode; 1122 int dev; 1123 }; 1124 #endif 1125 int 1126 sys_mknod(td, uap) 1127 struct thread *td; 1128 register struct mknod_args /* { 1129 char *path; 1130 int mode; 1131 int dev; 1132 } */ *uap; 1133 { 1134 1135 return (kern_mknodat(td, AT_FDCWD, uap->path, UIO_USERSPACE, 1136 uap->mode, uap->dev)); 1137 } 1138 1139 #ifndef _SYS_SYSPROTO_H_ 1140 struct mknodat_args { 1141 int fd; 1142 char *path; 1143 mode_t mode; 1144 dev_t dev; 1145 }; 1146 #endif 1147 int 1148 sys_mknodat(struct thread *td, struct mknodat_args *uap) 1149 { 1150 1151 return (kern_mknodat(td, uap->fd, uap->path, UIO_USERSPACE, uap->mode, 1152 uap->dev)); 1153 } 1154 1155 int 1156 kern_mknodat(struct thread *td, int fd, char *path, enum uio_seg pathseg, 1157 int mode, int dev) 1158 { 1159 struct vnode *vp; 1160 struct mount *mp; 1161 struct vattr vattr; 1162 struct nameidata nd; 1163 cap_rights_t rights; 1164 int error, whiteout = 0; 1165 1166 AUDIT_ARG_MODE(mode); 1167 AUDIT_ARG_DEV(dev); 1168 switch (mode & S_IFMT) { 1169 case S_IFCHR: 1170 case S_IFBLK: 1171 error = priv_check(td, PRIV_VFS_MKNOD_DEV); 1172 break; 1173 case S_IFMT: 1174 error = priv_check(td, PRIV_VFS_MKNOD_BAD); 1175 break; 1176 case S_IFWHT: 1177 error = priv_check(td, PRIV_VFS_MKNOD_WHT); 1178 break; 1179 case S_IFIFO: 1180 if (dev == 0) 1181 return (kern_mkfifoat(td, fd, path, pathseg, mode)); 1182 /* FALLTHROUGH */ 1183 default: 1184 error = EINVAL; 1185 break; 1186 } 1187 if (error != 0) 1188 return (error); 1189 restart: 1190 bwillwrite(); 1191 NDINIT_ATRIGHTS(&nd, CREATE, LOCKPARENT | SAVENAME | AUDITVNODE1 | 1192 NOCACHE, pathseg, path, fd, cap_rights_init(&rights, CAP_MKNODAT), 1193 td); 1194 if ((error = namei(&nd)) != 0) 1195 return (error); 1196 vp = nd.ni_vp; 1197 if (vp != NULL) { 1198 NDFREE(&nd, NDF_ONLY_PNBUF); 1199 if (vp == nd.ni_dvp) 1200 vrele(nd.ni_dvp); 1201 else 1202 vput(nd.ni_dvp); 1203 vrele(vp); 1204 return (EEXIST); 1205 } else { 1206 VATTR_NULL(&vattr); 1207 vattr.va_mode = (mode & ALLPERMS) & 1208 ~td->td_proc->p_fd->fd_cmask; 1209 vattr.va_rdev = dev; 1210 whiteout = 0; 1211 1212 switch (mode & S_IFMT) { 1213 case S_IFMT: /* used by badsect to flag bad sectors */ 1214 vattr.va_type = VBAD; 1215 break; 1216 case S_IFCHR: 1217 vattr.va_type = VCHR; 1218 break; 1219 case S_IFBLK: 1220 vattr.va_type = VBLK; 1221 break; 1222 case S_IFWHT: 1223 whiteout = 1; 1224 break; 1225 default: 1226 panic("kern_mknod: invalid mode"); 1227 } 1228 } 1229 if (vn_start_write(nd.ni_dvp, &mp, V_NOWAIT) != 0) { 1230 NDFREE(&nd, NDF_ONLY_PNBUF); 1231 vput(nd.ni_dvp); 1232 if ((error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH)) != 0) 1233 return (error); 1234 goto restart; 1235 } 1236 #ifdef MAC 1237 if (error == 0 && !whiteout) 1238 error = mac_vnode_check_create(td->td_ucred, nd.ni_dvp, 1239 &nd.ni_cnd, &vattr); 1240 #endif 1241 if (error == 0) { 1242 if (whiteout) 1243 error = VOP_WHITEOUT(nd.ni_dvp, &nd.ni_cnd, CREATE); 1244 else { 1245 error = VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, 1246 &nd.ni_cnd, &vattr); 1247 if (error == 0) 1248 vput(nd.ni_vp); 1249 } 1250 } 1251 NDFREE(&nd, NDF_ONLY_PNBUF); 1252 vput(nd.ni_dvp); 1253 vn_finished_write(mp); 1254 return (error); 1255 } 1256 1257 /* 1258 * Create a named pipe. 1259 */ 1260 #ifndef _SYS_SYSPROTO_H_ 1261 struct mkfifo_args { 1262 char *path; 1263 int mode; 1264 }; 1265 #endif 1266 int 1267 sys_mkfifo(td, uap) 1268 struct thread *td; 1269 register struct mkfifo_args /* { 1270 char *path; 1271 int mode; 1272 } */ *uap; 1273 { 1274 1275 return (kern_mkfifoat(td, AT_FDCWD, uap->path, UIO_USERSPACE, 1276 uap->mode)); 1277 } 1278 1279 #ifndef _SYS_SYSPROTO_H_ 1280 struct mkfifoat_args { 1281 int fd; 1282 char *path; 1283 mode_t mode; 1284 }; 1285 #endif 1286 int 1287 sys_mkfifoat(struct thread *td, struct mkfifoat_args *uap) 1288 { 1289 1290 return (kern_mkfifoat(td, uap->fd, uap->path, UIO_USERSPACE, 1291 uap->mode)); 1292 } 1293 1294 int 1295 kern_mkfifoat(struct thread *td, int fd, char *path, enum uio_seg pathseg, 1296 int mode) 1297 { 1298 struct mount *mp; 1299 struct vattr vattr; 1300 struct nameidata nd; 1301 cap_rights_t rights; 1302 int error; 1303 1304 AUDIT_ARG_MODE(mode); 1305 restart: 1306 bwillwrite(); 1307 NDINIT_ATRIGHTS(&nd, CREATE, LOCKPARENT | SAVENAME | AUDITVNODE1 | 1308 NOCACHE, pathseg, path, fd, cap_rights_init(&rights, CAP_MKFIFOAT), 1309 td); 1310 if ((error = namei(&nd)) != 0) 1311 return (error); 1312 if (nd.ni_vp != NULL) { 1313 NDFREE(&nd, NDF_ONLY_PNBUF); 1314 if (nd.ni_vp == nd.ni_dvp) 1315 vrele(nd.ni_dvp); 1316 else 1317 vput(nd.ni_dvp); 1318 vrele(nd.ni_vp); 1319 return (EEXIST); 1320 } 1321 if (vn_start_write(nd.ni_dvp, &mp, V_NOWAIT) != 0) { 1322 NDFREE(&nd, NDF_ONLY_PNBUF); 1323 vput(nd.ni_dvp); 1324 if ((error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH)) != 0) 1325 return (error); 1326 goto restart; 1327 } 1328 VATTR_NULL(&vattr); 1329 vattr.va_type = VFIFO; 1330 vattr.va_mode = (mode & ALLPERMS) & ~td->td_proc->p_fd->fd_cmask; 1331 #ifdef MAC 1332 error = mac_vnode_check_create(td->td_ucred, nd.ni_dvp, &nd.ni_cnd, 1333 &vattr); 1334 if (error != 0) 1335 goto out; 1336 #endif 1337 error = VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr); 1338 if (error == 0) 1339 vput(nd.ni_vp); 1340 #ifdef MAC 1341 out: 1342 #endif 1343 vput(nd.ni_dvp); 1344 vn_finished_write(mp); 1345 NDFREE(&nd, NDF_ONLY_PNBUF); 1346 return (error); 1347 } 1348 1349 /* 1350 * Make a hard file link. 1351 */ 1352 #ifndef _SYS_SYSPROTO_H_ 1353 struct link_args { 1354 char *path; 1355 char *link; 1356 }; 1357 #endif 1358 int 1359 sys_link(td, uap) 1360 struct thread *td; 1361 register struct link_args /* { 1362 char *path; 1363 char *link; 1364 } */ *uap; 1365 { 1366 1367 return (kern_linkat(td, AT_FDCWD, AT_FDCWD, uap->path, uap->link, 1368 UIO_USERSPACE, FOLLOW)); 1369 } 1370 1371 #ifndef _SYS_SYSPROTO_H_ 1372 struct linkat_args { 1373 int fd1; 1374 char *path1; 1375 int fd2; 1376 char *path2; 1377 int flag; 1378 }; 1379 #endif 1380 int 1381 sys_linkat(struct thread *td, struct linkat_args *uap) 1382 { 1383 int flag; 1384 1385 flag = uap->flag; 1386 if (flag & ~AT_SYMLINK_FOLLOW) 1387 return (EINVAL); 1388 1389 return (kern_linkat(td, uap->fd1, uap->fd2, uap->path1, uap->path2, 1390 UIO_USERSPACE, (flag & AT_SYMLINK_FOLLOW) ? FOLLOW : NOFOLLOW)); 1391 } 1392 1393 int hardlink_check_uid = 0; 1394 SYSCTL_INT(_security_bsd, OID_AUTO, hardlink_check_uid, CTLFLAG_RW, 1395 &hardlink_check_uid, 0, 1396 "Unprivileged processes cannot create hard links to files owned by other " 1397 "users"); 1398 static int hardlink_check_gid = 0; 1399 SYSCTL_INT(_security_bsd, OID_AUTO, hardlink_check_gid, CTLFLAG_RW, 1400 &hardlink_check_gid, 0, 1401 "Unprivileged processes cannot create hard links to files owned by other " 1402 "groups"); 1403 1404 static int 1405 can_hardlink(struct vnode *vp, struct ucred *cred) 1406 { 1407 struct vattr va; 1408 int error; 1409 1410 if (!hardlink_check_uid && !hardlink_check_gid) 1411 return (0); 1412 1413 error = VOP_GETATTR(vp, &va, cred); 1414 if (error != 0) 1415 return (error); 1416 1417 if (hardlink_check_uid && cred->cr_uid != va.va_uid) { 1418 error = priv_check_cred(cred, PRIV_VFS_LINK, 0); 1419 if (error != 0) 1420 return (error); 1421 } 1422 1423 if (hardlink_check_gid && !groupmember(va.va_gid, cred)) { 1424 error = priv_check_cred(cred, PRIV_VFS_LINK, 0); 1425 if (error != 0) 1426 return (error); 1427 } 1428 1429 return (0); 1430 } 1431 1432 int 1433 kern_linkat(struct thread *td, int fd1, int fd2, char *path1, char *path2, 1434 enum uio_seg segflg, int follow) 1435 { 1436 struct vnode *vp; 1437 struct mount *mp; 1438 struct nameidata nd; 1439 cap_rights_t rights; 1440 int error; 1441 1442 again: 1443 bwillwrite(); 1444 NDINIT_ATRIGHTS(&nd, LOOKUP, follow | AUDITVNODE1, segflg, path1, fd1, 1445 cap_rights_init(&rights, CAP_LINKAT_SOURCE), td); 1446 1447 if ((error = namei(&nd)) != 0) 1448 return (error); 1449 NDFREE(&nd, NDF_ONLY_PNBUF); 1450 vp = nd.ni_vp; 1451 if (vp->v_type == VDIR) { 1452 vrele(vp); 1453 return (EPERM); /* POSIX */ 1454 } 1455 NDINIT_ATRIGHTS(&nd, CREATE, 1456 LOCKPARENT | SAVENAME | AUDITVNODE2 | NOCACHE, segflg, path2, fd2, 1457 cap_rights_init(&rights, CAP_LINKAT_TARGET), td); 1458 if ((error = namei(&nd)) == 0) { 1459 if (nd.ni_vp != NULL) { 1460 NDFREE(&nd, NDF_ONLY_PNBUF); 1461 if (nd.ni_dvp == nd.ni_vp) 1462 vrele(nd.ni_dvp); 1463 else 1464 vput(nd.ni_dvp); 1465 vrele(nd.ni_vp); 1466 vrele(vp); 1467 return (EEXIST); 1468 } else if (nd.ni_dvp->v_mount != vp->v_mount) { 1469 /* 1470 * Cross-device link. No need to recheck 1471 * vp->v_type, since it cannot change, except 1472 * to VBAD. 1473 */ 1474 NDFREE(&nd, NDF_ONLY_PNBUF); 1475 vput(nd.ni_dvp); 1476 vrele(vp); 1477 return (EXDEV); 1478 } else if ((error = vn_lock(vp, LK_EXCLUSIVE)) == 0) { 1479 error = can_hardlink(vp, td->td_ucred); 1480 #ifdef MAC 1481 if (error == 0) 1482 error = mac_vnode_check_link(td->td_ucred, 1483 nd.ni_dvp, vp, &nd.ni_cnd); 1484 #endif 1485 if (error != 0) { 1486 vput(vp); 1487 vput(nd.ni_dvp); 1488 NDFREE(&nd, NDF_ONLY_PNBUF); 1489 return (error); 1490 } 1491 error = vn_start_write(vp, &mp, V_NOWAIT); 1492 if (error != 0) { 1493 vput(vp); 1494 vput(nd.ni_dvp); 1495 NDFREE(&nd, NDF_ONLY_PNBUF); 1496 error = vn_start_write(NULL, &mp, 1497 V_XSLEEP | PCATCH); 1498 if (error != 0) 1499 return (error); 1500 goto again; 1501 } 1502 error = VOP_LINK(nd.ni_dvp, vp, &nd.ni_cnd); 1503 VOP_UNLOCK(vp, 0); 1504 vput(nd.ni_dvp); 1505 vn_finished_write(mp); 1506 NDFREE(&nd, NDF_ONLY_PNBUF); 1507 } else { 1508 vput(nd.ni_dvp); 1509 NDFREE(&nd, NDF_ONLY_PNBUF); 1510 vrele(vp); 1511 goto again; 1512 } 1513 } 1514 vrele(vp); 1515 return (error); 1516 } 1517 1518 /* 1519 * Make a symbolic link. 1520 */ 1521 #ifndef _SYS_SYSPROTO_H_ 1522 struct symlink_args { 1523 char *path; 1524 char *link; 1525 }; 1526 #endif 1527 int 1528 sys_symlink(td, uap) 1529 struct thread *td; 1530 register struct symlink_args /* { 1531 char *path; 1532 char *link; 1533 } */ *uap; 1534 { 1535 1536 return (kern_symlinkat(td, uap->path, AT_FDCWD, uap->link, 1537 UIO_USERSPACE)); 1538 } 1539 1540 #ifndef _SYS_SYSPROTO_H_ 1541 struct symlinkat_args { 1542 char *path; 1543 int fd; 1544 char *path2; 1545 }; 1546 #endif 1547 int 1548 sys_symlinkat(struct thread *td, struct symlinkat_args *uap) 1549 { 1550 1551 return (kern_symlinkat(td, uap->path1, uap->fd, uap->path2, 1552 UIO_USERSPACE)); 1553 } 1554 1555 int 1556 kern_symlinkat(struct thread *td, char *path1, int fd, char *path2, 1557 enum uio_seg segflg) 1558 { 1559 struct mount *mp; 1560 struct vattr vattr; 1561 char *syspath; 1562 struct nameidata nd; 1563 int error; 1564 cap_rights_t rights; 1565 1566 if (segflg == UIO_SYSSPACE) { 1567 syspath = path1; 1568 } else { 1569 syspath = uma_zalloc(namei_zone, M_WAITOK); 1570 if ((error = copyinstr(path1, syspath, MAXPATHLEN, NULL)) != 0) 1571 goto out; 1572 } 1573 AUDIT_ARG_TEXT(syspath); 1574 restart: 1575 bwillwrite(); 1576 NDINIT_ATRIGHTS(&nd, CREATE, LOCKPARENT | SAVENAME | AUDITVNODE1 | 1577 NOCACHE, segflg, path2, fd, cap_rights_init(&rights, CAP_SYMLINKAT), 1578 td); 1579 if ((error = namei(&nd)) != 0) 1580 goto out; 1581 if (nd.ni_vp) { 1582 NDFREE(&nd, NDF_ONLY_PNBUF); 1583 if (nd.ni_vp == nd.ni_dvp) 1584 vrele(nd.ni_dvp); 1585 else 1586 vput(nd.ni_dvp); 1587 vrele(nd.ni_vp); 1588 error = EEXIST; 1589 goto out; 1590 } 1591 if (vn_start_write(nd.ni_dvp, &mp, V_NOWAIT) != 0) { 1592 NDFREE(&nd, NDF_ONLY_PNBUF); 1593 vput(nd.ni_dvp); 1594 if ((error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH)) != 0) 1595 goto out; 1596 goto restart; 1597 } 1598 VATTR_NULL(&vattr); 1599 vattr.va_mode = ACCESSPERMS &~ td->td_proc->p_fd->fd_cmask; 1600 #ifdef MAC 1601 vattr.va_type = VLNK; 1602 error = mac_vnode_check_create(td->td_ucred, nd.ni_dvp, &nd.ni_cnd, 1603 &vattr); 1604 if (error != 0) 1605 goto out2; 1606 #endif 1607 error = VOP_SYMLINK(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr, syspath); 1608 if (error == 0) 1609 vput(nd.ni_vp); 1610 #ifdef MAC 1611 out2: 1612 #endif 1613 NDFREE(&nd, NDF_ONLY_PNBUF); 1614 vput(nd.ni_dvp); 1615 vn_finished_write(mp); 1616 out: 1617 if (segflg != UIO_SYSSPACE) 1618 uma_zfree(namei_zone, syspath); 1619 return (error); 1620 } 1621 1622 /* 1623 * Delete a whiteout from the filesystem. 1624 */ 1625 int 1626 sys_undelete(td, uap) 1627 struct thread *td; 1628 register struct undelete_args /* { 1629 char *path; 1630 } */ *uap; 1631 { 1632 struct mount *mp; 1633 struct nameidata nd; 1634 int error; 1635 1636 restart: 1637 bwillwrite(); 1638 NDINIT(&nd, DELETE, LOCKPARENT | DOWHITEOUT | AUDITVNODE1, 1639 UIO_USERSPACE, uap->path, td); 1640 error = namei(&nd); 1641 if (error != 0) 1642 return (error); 1643 1644 if (nd.ni_vp != NULLVP || !(nd.ni_cnd.cn_flags & ISWHITEOUT)) { 1645 NDFREE(&nd, NDF_ONLY_PNBUF); 1646 if (nd.ni_vp == nd.ni_dvp) 1647 vrele(nd.ni_dvp); 1648 else 1649 vput(nd.ni_dvp); 1650 if (nd.ni_vp) 1651 vrele(nd.ni_vp); 1652 return (EEXIST); 1653 } 1654 if (vn_start_write(nd.ni_dvp, &mp, V_NOWAIT) != 0) { 1655 NDFREE(&nd, NDF_ONLY_PNBUF); 1656 vput(nd.ni_dvp); 1657 if ((error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH)) != 0) 1658 return (error); 1659 goto restart; 1660 } 1661 error = VOP_WHITEOUT(nd.ni_dvp, &nd.ni_cnd, DELETE); 1662 NDFREE(&nd, NDF_ONLY_PNBUF); 1663 vput(nd.ni_dvp); 1664 vn_finished_write(mp); 1665 return (error); 1666 } 1667 1668 /* 1669 * Delete a name from the filesystem. 1670 */ 1671 #ifndef _SYS_SYSPROTO_H_ 1672 struct unlink_args { 1673 char *path; 1674 }; 1675 #endif 1676 int 1677 sys_unlink(td, uap) 1678 struct thread *td; 1679 struct unlink_args /* { 1680 char *path; 1681 } */ *uap; 1682 { 1683 1684 return (kern_unlinkat(td, AT_FDCWD, uap->path, UIO_USERSPACE, 0)); 1685 } 1686 1687 #ifndef _SYS_SYSPROTO_H_ 1688 struct unlinkat_args { 1689 int fd; 1690 char *path; 1691 int flag; 1692 }; 1693 #endif 1694 int 1695 sys_unlinkat(struct thread *td, struct unlinkat_args *uap) 1696 { 1697 int flag = uap->flag; 1698 int fd = uap->fd; 1699 char *path = uap->path; 1700 1701 if (flag & ~AT_REMOVEDIR) 1702 return (EINVAL); 1703 1704 if (flag & AT_REMOVEDIR) 1705 return (kern_rmdirat(td, fd, path, UIO_USERSPACE)); 1706 else 1707 return (kern_unlinkat(td, fd, path, UIO_USERSPACE, 0)); 1708 } 1709 1710 int 1711 kern_unlinkat(struct thread *td, int fd, char *path, enum uio_seg pathseg, 1712 ino_t oldinum) 1713 { 1714 struct mount *mp; 1715 struct vnode *vp; 1716 struct nameidata nd; 1717 struct stat sb; 1718 cap_rights_t rights; 1719 int error; 1720 1721 restart: 1722 bwillwrite(); 1723 NDINIT_ATRIGHTS(&nd, DELETE, LOCKPARENT | LOCKLEAF | AUDITVNODE1, 1724 pathseg, path, fd, cap_rights_init(&rights, CAP_UNLINKAT), td); 1725 if ((error = namei(&nd)) != 0) 1726 return (error == EINVAL ? EPERM : error); 1727 vp = nd.ni_vp; 1728 if (vp->v_type == VDIR && oldinum == 0) { 1729 error = EPERM; /* POSIX */ 1730 } else if (oldinum != 0 && 1731 ((error = vn_stat(vp, &sb, td->td_ucred, NOCRED, td)) == 0) && 1732 sb.st_ino != oldinum) { 1733 error = EIDRM; /* Identifier removed */ 1734 } else { 1735 /* 1736 * The root of a mounted filesystem cannot be deleted. 1737 * 1738 * XXX: can this only be a VDIR case? 1739 */ 1740 if (vp->v_vflag & VV_ROOT) 1741 error = EBUSY; 1742 } 1743 if (error == 0) { 1744 if (vn_start_write(nd.ni_dvp, &mp, V_NOWAIT) != 0) { 1745 NDFREE(&nd, NDF_ONLY_PNBUF); 1746 vput(nd.ni_dvp); 1747 if (vp == nd.ni_dvp) 1748 vrele(vp); 1749 else 1750 vput(vp); 1751 if ((error = vn_start_write(NULL, &mp, 1752 V_XSLEEP | PCATCH)) != 0) 1753 return (error); 1754 goto restart; 1755 } 1756 #ifdef MAC 1757 error = mac_vnode_check_unlink(td->td_ucred, nd.ni_dvp, vp, 1758 &nd.ni_cnd); 1759 if (error != 0) 1760 goto out; 1761 #endif 1762 vfs_notify_upper(vp, VFS_NOTIFY_UPPER_UNLINK); 1763 error = VOP_REMOVE(nd.ni_dvp, vp, &nd.ni_cnd); 1764 #ifdef MAC 1765 out: 1766 #endif 1767 vn_finished_write(mp); 1768 } 1769 NDFREE(&nd, NDF_ONLY_PNBUF); 1770 vput(nd.ni_dvp); 1771 if (vp == nd.ni_dvp) 1772 vrele(vp); 1773 else 1774 vput(vp); 1775 return (error); 1776 } 1777 1778 /* 1779 * Reposition read/write file offset. 1780 */ 1781 #ifndef _SYS_SYSPROTO_H_ 1782 struct lseek_args { 1783 int fd; 1784 int pad; 1785 off_t offset; 1786 int whence; 1787 }; 1788 #endif 1789 int 1790 sys_lseek(td, uap) 1791 struct thread *td; 1792 register struct lseek_args /* { 1793 int fd; 1794 int pad; 1795 off_t offset; 1796 int whence; 1797 } */ *uap; 1798 { 1799 struct file *fp; 1800 cap_rights_t rights; 1801 int error; 1802 1803 AUDIT_ARG_FD(uap->fd); 1804 error = fget(td, uap->fd, cap_rights_init(&rights, CAP_SEEK), &fp); 1805 if (error != 0) 1806 return (error); 1807 error = (fp->f_ops->fo_flags & DFLAG_SEEKABLE) != 0 ? 1808 fo_seek(fp, uap->offset, uap->whence, td) : ESPIPE; 1809 fdrop(fp, td); 1810 return (error); 1811 } 1812 1813 #if defined(COMPAT_43) 1814 /* 1815 * Reposition read/write file offset. 1816 */ 1817 #ifndef _SYS_SYSPROTO_H_ 1818 struct olseek_args { 1819 int fd; 1820 long offset; 1821 int whence; 1822 }; 1823 #endif 1824 int 1825 olseek(td, uap) 1826 struct thread *td; 1827 register struct olseek_args /* { 1828 int fd; 1829 long offset; 1830 int whence; 1831 } */ *uap; 1832 { 1833 struct lseek_args /* { 1834 int fd; 1835 int pad; 1836 off_t offset; 1837 int whence; 1838 } */ nuap; 1839 1840 nuap.fd = uap->fd; 1841 nuap.offset = uap->offset; 1842 nuap.whence = uap->whence; 1843 return (sys_lseek(td, &nuap)); 1844 } 1845 #endif /* COMPAT_43 */ 1846 1847 #if defined(COMPAT_FREEBSD6) 1848 /* Version with the 'pad' argument */ 1849 int 1850 freebsd6_lseek(td, uap) 1851 struct thread *td; 1852 register struct freebsd6_lseek_args *uap; 1853 { 1854 struct lseek_args ouap; 1855 1856 ouap.fd = uap->fd; 1857 ouap.offset = uap->offset; 1858 ouap.whence = uap->whence; 1859 return (sys_lseek(td, &ouap)); 1860 } 1861 #endif 1862 1863 /* 1864 * Check access permissions using passed credentials. 1865 */ 1866 static int 1867 vn_access(vp, user_flags, cred, td) 1868 struct vnode *vp; 1869 int user_flags; 1870 struct ucred *cred; 1871 struct thread *td; 1872 { 1873 accmode_t accmode; 1874 int error; 1875 1876 /* Flags == 0 means only check for existence. */ 1877 if (user_flags == 0) 1878 return (0); 1879 1880 accmode = 0; 1881 if (user_flags & R_OK) 1882 accmode |= VREAD; 1883 if (user_flags & W_OK) 1884 accmode |= VWRITE; 1885 if (user_flags & X_OK) 1886 accmode |= VEXEC; 1887 #ifdef MAC 1888 error = mac_vnode_check_access(cred, vp, accmode); 1889 if (error != 0) 1890 return (error); 1891 #endif 1892 if ((accmode & VWRITE) == 0 || (error = vn_writechk(vp)) == 0) 1893 error = VOP_ACCESS(vp, accmode, cred, td); 1894 return (error); 1895 } 1896 1897 /* 1898 * Check access permissions using "real" credentials. 1899 */ 1900 #ifndef _SYS_SYSPROTO_H_ 1901 struct access_args { 1902 char *path; 1903 int amode; 1904 }; 1905 #endif 1906 int 1907 sys_access(td, uap) 1908 struct thread *td; 1909 register struct access_args /* { 1910 char *path; 1911 int amode; 1912 } */ *uap; 1913 { 1914 1915 return (kern_accessat(td, AT_FDCWD, uap->path, UIO_USERSPACE, 1916 0, uap->amode)); 1917 } 1918 1919 #ifndef _SYS_SYSPROTO_H_ 1920 struct faccessat_args { 1921 int dirfd; 1922 char *path; 1923 int amode; 1924 int flag; 1925 } 1926 #endif 1927 int 1928 sys_faccessat(struct thread *td, struct faccessat_args *uap) 1929 { 1930 1931 return (kern_accessat(td, uap->fd, uap->path, UIO_USERSPACE, uap->flag, 1932 uap->amode)); 1933 } 1934 1935 int 1936 kern_accessat(struct thread *td, int fd, char *path, enum uio_seg pathseg, 1937 int flag, int amode) 1938 { 1939 struct ucred *cred, *usecred; 1940 struct vnode *vp; 1941 struct nameidata nd; 1942 cap_rights_t rights; 1943 int error; 1944 1945 if (flag & ~AT_EACCESS) 1946 return (EINVAL); 1947 if (amode != F_OK && (amode & ~(R_OK | W_OK | X_OK)) != 0) 1948 return (EINVAL); 1949 1950 /* 1951 * Create and modify a temporary credential instead of one that 1952 * is potentially shared (if we need one). 1953 */ 1954 cred = td->td_ucred; 1955 if ((flag & AT_EACCESS) == 0 && 1956 ((cred->cr_uid != cred->cr_ruid || 1957 cred->cr_rgid != cred->cr_groups[0]))) { 1958 usecred = crdup(cred); 1959 usecred->cr_uid = cred->cr_ruid; 1960 usecred->cr_groups[0] = cred->cr_rgid; 1961 td->td_ucred = usecred; 1962 } else 1963 usecred = cred; 1964 AUDIT_ARG_VALUE(amode); 1965 NDINIT_ATRIGHTS(&nd, LOOKUP, FOLLOW | LOCKSHARED | LOCKLEAF | 1966 AUDITVNODE1, pathseg, path, fd, cap_rights_init(&rights, CAP_FSTAT), 1967 td); 1968 if ((error = namei(&nd)) != 0) 1969 goto out; 1970 vp = nd.ni_vp; 1971 1972 error = vn_access(vp, amode, usecred, td); 1973 NDFREE(&nd, NDF_ONLY_PNBUF); 1974 vput(vp); 1975 out: 1976 if (usecred != cred) { 1977 td->td_ucred = cred; 1978 crfree(usecred); 1979 } 1980 return (error); 1981 } 1982 1983 /* 1984 * Check access permissions using "effective" credentials. 1985 */ 1986 #ifndef _SYS_SYSPROTO_H_ 1987 struct eaccess_args { 1988 char *path; 1989 int amode; 1990 }; 1991 #endif 1992 int 1993 sys_eaccess(td, uap) 1994 struct thread *td; 1995 register struct eaccess_args /* { 1996 char *path; 1997 int amode; 1998 } */ *uap; 1999 { 2000 2001 return (kern_accessat(td, AT_FDCWD, uap->path, UIO_USERSPACE, 2002 AT_EACCESS, uap->amode)); 2003 } 2004 2005 #if defined(COMPAT_43) 2006 /* 2007 * Get file status; this version follows links. 2008 */ 2009 #ifndef _SYS_SYSPROTO_H_ 2010 struct ostat_args { 2011 char *path; 2012 struct ostat *ub; 2013 }; 2014 #endif 2015 int 2016 ostat(td, uap) 2017 struct thread *td; 2018 register struct ostat_args /* { 2019 char *path; 2020 struct ostat *ub; 2021 } */ *uap; 2022 { 2023 struct stat sb; 2024 struct ostat osb; 2025 int error; 2026 2027 error = kern_statat(td, 0, AT_FDCWD, uap->path, UIO_USERSPACE, 2028 &sb, NULL); 2029 if (error != 0) 2030 return (error); 2031 cvtstat(&sb, &osb); 2032 return (copyout(&osb, uap->ub, sizeof (osb))); 2033 } 2034 2035 /* 2036 * Get file status; this version does not follow links. 2037 */ 2038 #ifndef _SYS_SYSPROTO_H_ 2039 struct olstat_args { 2040 char *path; 2041 struct ostat *ub; 2042 }; 2043 #endif 2044 int 2045 olstat(td, uap) 2046 struct thread *td; 2047 register struct olstat_args /* { 2048 char *path; 2049 struct ostat *ub; 2050 } */ *uap; 2051 { 2052 struct stat sb; 2053 struct ostat osb; 2054 int error; 2055 2056 error = kern_statat(td, AT_SYMLINK_NOFOLLOW, AT_FDCWD, uap->path, 2057 UIO_USERSPACE, &sb, NULL); 2058 if (error != 0) 2059 return (error); 2060 cvtstat(&sb, &osb); 2061 return (copyout(&osb, uap->ub, sizeof (osb))); 2062 } 2063 2064 /* 2065 * Convert from an old to a new stat structure. 2066 */ 2067 void 2068 cvtstat(st, ost) 2069 struct stat *st; 2070 struct ostat *ost; 2071 { 2072 2073 ost->st_dev = st->st_dev; 2074 ost->st_ino = st->st_ino; 2075 ost->st_mode = st->st_mode; 2076 ost->st_nlink = st->st_nlink; 2077 ost->st_uid = st->st_uid; 2078 ost->st_gid = st->st_gid; 2079 ost->st_rdev = st->st_rdev; 2080 if (st->st_size < (quad_t)1 << 32) 2081 ost->st_size = st->st_size; 2082 else 2083 ost->st_size = -2; 2084 ost->st_atim = st->st_atim; 2085 ost->st_mtim = st->st_mtim; 2086 ost->st_ctim = st->st_ctim; 2087 ost->st_blksize = st->st_blksize; 2088 ost->st_blocks = st->st_blocks; 2089 ost->st_flags = st->st_flags; 2090 ost->st_gen = st->st_gen; 2091 } 2092 #endif /* COMPAT_43 */ 2093 2094 /* 2095 * Get file status; this version follows links. 2096 */ 2097 #ifndef _SYS_SYSPROTO_H_ 2098 struct stat_args { 2099 char *path; 2100 struct stat *ub; 2101 }; 2102 #endif 2103 int 2104 sys_stat(td, uap) 2105 struct thread *td; 2106 register struct stat_args /* { 2107 char *path; 2108 struct stat *ub; 2109 } */ *uap; 2110 { 2111 struct stat sb; 2112 int error; 2113 2114 error = kern_statat(td, 0, AT_FDCWD, uap->path, UIO_USERSPACE, 2115 &sb, NULL); 2116 if (error == 0) 2117 error = copyout(&sb, uap->ub, sizeof (sb)); 2118 return (error); 2119 } 2120 2121 #ifndef _SYS_SYSPROTO_H_ 2122 struct fstatat_args { 2123 int fd; 2124 char *path; 2125 struct stat *buf; 2126 int flag; 2127 } 2128 #endif 2129 int 2130 sys_fstatat(struct thread *td, struct fstatat_args *uap) 2131 { 2132 struct stat sb; 2133 int error; 2134 2135 error = kern_statat(td, uap->flag, uap->fd, uap->path, 2136 UIO_USERSPACE, &sb, NULL); 2137 if (error == 0) 2138 error = copyout(&sb, uap->buf, sizeof (sb)); 2139 return (error); 2140 } 2141 2142 int 2143 kern_statat(struct thread *td, int flag, int fd, char *path, 2144 enum uio_seg pathseg, struct stat *sbp, 2145 void (*hook)(struct vnode *vp, struct stat *sbp)) 2146 { 2147 struct nameidata nd; 2148 struct stat sb; 2149 cap_rights_t rights; 2150 int error; 2151 2152 if (flag & ~AT_SYMLINK_NOFOLLOW) 2153 return (EINVAL); 2154 2155 NDINIT_ATRIGHTS(&nd, LOOKUP, ((flag & AT_SYMLINK_NOFOLLOW) ? NOFOLLOW : 2156 FOLLOW) | LOCKSHARED | LOCKLEAF | AUDITVNODE1, pathseg, path, fd, 2157 cap_rights_init(&rights, CAP_FSTAT), td); 2158 2159 if ((error = namei(&nd)) != 0) 2160 return (error); 2161 error = vn_stat(nd.ni_vp, &sb, td->td_ucred, NOCRED, td); 2162 if (error == 0) { 2163 SDT_PROBE2(vfs, , stat, mode, path, sb.st_mode); 2164 if (S_ISREG(sb.st_mode)) 2165 SDT_PROBE2(vfs, , stat, reg, path, pathseg); 2166 if (__predict_false(hook != NULL)) 2167 hook(nd.ni_vp, &sb); 2168 } 2169 NDFREE(&nd, NDF_ONLY_PNBUF); 2170 vput(nd.ni_vp); 2171 if (error != 0) 2172 return (error); 2173 *sbp = sb; 2174 #ifdef KTRACE 2175 if (KTRPOINT(td, KTR_STRUCT)) 2176 ktrstat(&sb); 2177 #endif 2178 return (0); 2179 } 2180 2181 /* 2182 * Get file status; this version does not follow links. 2183 */ 2184 #ifndef _SYS_SYSPROTO_H_ 2185 struct lstat_args { 2186 char *path; 2187 struct stat *ub; 2188 }; 2189 #endif 2190 int 2191 sys_lstat(td, uap) 2192 struct thread *td; 2193 register struct lstat_args /* { 2194 char *path; 2195 struct stat *ub; 2196 } */ *uap; 2197 { 2198 struct stat sb; 2199 int error; 2200 2201 error = kern_statat(td, AT_SYMLINK_NOFOLLOW, AT_FDCWD, uap->path, 2202 UIO_USERSPACE, &sb, NULL); 2203 if (error == 0) 2204 error = copyout(&sb, uap->ub, sizeof (sb)); 2205 return (error); 2206 } 2207 2208 /* 2209 * Implementation of the NetBSD [l]stat() functions. 2210 */ 2211 void 2212 cvtnstat(sb, nsb) 2213 struct stat *sb; 2214 struct nstat *nsb; 2215 { 2216 2217 bzero(nsb, sizeof *nsb); 2218 nsb->st_dev = sb->st_dev; 2219 nsb->st_ino = sb->st_ino; 2220 nsb->st_mode = sb->st_mode; 2221 nsb->st_nlink = sb->st_nlink; 2222 nsb->st_uid = sb->st_uid; 2223 nsb->st_gid = sb->st_gid; 2224 nsb->st_rdev = sb->st_rdev; 2225 nsb->st_atim = sb->st_atim; 2226 nsb->st_mtim = sb->st_mtim; 2227 nsb->st_ctim = sb->st_ctim; 2228 nsb->st_size = sb->st_size; 2229 nsb->st_blocks = sb->st_blocks; 2230 nsb->st_blksize = sb->st_blksize; 2231 nsb->st_flags = sb->st_flags; 2232 nsb->st_gen = sb->st_gen; 2233 nsb->st_birthtim = sb->st_birthtim; 2234 } 2235 2236 #ifndef _SYS_SYSPROTO_H_ 2237 struct nstat_args { 2238 char *path; 2239 struct nstat *ub; 2240 }; 2241 #endif 2242 int 2243 sys_nstat(td, uap) 2244 struct thread *td; 2245 register struct nstat_args /* { 2246 char *path; 2247 struct nstat *ub; 2248 } */ *uap; 2249 { 2250 struct stat sb; 2251 struct nstat nsb; 2252 int error; 2253 2254 error = kern_statat(td, 0, AT_FDCWD, uap->path, UIO_USERSPACE, 2255 &sb, NULL); 2256 if (error != 0) 2257 return (error); 2258 cvtnstat(&sb, &nsb); 2259 return (copyout(&nsb, uap->ub, sizeof (nsb))); 2260 } 2261 2262 /* 2263 * NetBSD lstat. Get file status; this version does not follow links. 2264 */ 2265 #ifndef _SYS_SYSPROTO_H_ 2266 struct lstat_args { 2267 char *path; 2268 struct stat *ub; 2269 }; 2270 #endif 2271 int 2272 sys_nlstat(td, uap) 2273 struct thread *td; 2274 register struct nlstat_args /* { 2275 char *path; 2276 struct nstat *ub; 2277 } */ *uap; 2278 { 2279 struct stat sb; 2280 struct nstat nsb; 2281 int error; 2282 2283 error = kern_statat(td, AT_SYMLINK_NOFOLLOW, AT_FDCWD, uap->path, 2284 UIO_USERSPACE, &sb, NULL); 2285 if (error != 0) 2286 return (error); 2287 cvtnstat(&sb, &nsb); 2288 return (copyout(&nsb, uap->ub, sizeof (nsb))); 2289 } 2290 2291 /* 2292 * Get configurable pathname variables. 2293 */ 2294 #ifndef _SYS_SYSPROTO_H_ 2295 struct pathconf_args { 2296 char *path; 2297 int name; 2298 }; 2299 #endif 2300 int 2301 sys_pathconf(td, uap) 2302 struct thread *td; 2303 register struct pathconf_args /* { 2304 char *path; 2305 int name; 2306 } */ *uap; 2307 { 2308 2309 return (kern_pathconf(td, uap->path, UIO_USERSPACE, uap->name, FOLLOW)); 2310 } 2311 2312 #ifndef _SYS_SYSPROTO_H_ 2313 struct lpathconf_args { 2314 char *path; 2315 int name; 2316 }; 2317 #endif 2318 int 2319 sys_lpathconf(td, uap) 2320 struct thread *td; 2321 register struct lpathconf_args /* { 2322 char *path; 2323 int name; 2324 } */ *uap; 2325 { 2326 2327 return (kern_pathconf(td, uap->path, UIO_USERSPACE, uap->name, 2328 NOFOLLOW)); 2329 } 2330 2331 int 2332 kern_pathconf(struct thread *td, char *path, enum uio_seg pathseg, int name, 2333 u_long flags) 2334 { 2335 struct nameidata nd; 2336 int error; 2337 2338 NDINIT(&nd, LOOKUP, LOCKSHARED | LOCKLEAF | AUDITVNODE1 | flags, 2339 pathseg, path, td); 2340 if ((error = namei(&nd)) != 0) 2341 return (error); 2342 NDFREE(&nd, NDF_ONLY_PNBUF); 2343 2344 /* If asynchronous I/O is available, it works for all files. */ 2345 if (name == _PC_ASYNC_IO) 2346 td->td_retval[0] = async_io_version; 2347 else 2348 error = VOP_PATHCONF(nd.ni_vp, name, td->td_retval); 2349 vput(nd.ni_vp); 2350 return (error); 2351 } 2352 2353 /* 2354 * Return target name of a symbolic link. 2355 */ 2356 #ifndef _SYS_SYSPROTO_H_ 2357 struct readlink_args { 2358 char *path; 2359 char *buf; 2360 size_t count; 2361 }; 2362 #endif 2363 int 2364 sys_readlink(td, uap) 2365 struct thread *td; 2366 register struct readlink_args /* { 2367 char *path; 2368 char *buf; 2369 size_t count; 2370 } */ *uap; 2371 { 2372 2373 return (kern_readlinkat(td, AT_FDCWD, uap->path, UIO_USERSPACE, 2374 uap->buf, UIO_USERSPACE, uap->count)); 2375 } 2376 #ifndef _SYS_SYSPROTO_H_ 2377 struct readlinkat_args { 2378 int fd; 2379 char *path; 2380 char *buf; 2381 size_t bufsize; 2382 }; 2383 #endif 2384 int 2385 sys_readlinkat(struct thread *td, struct readlinkat_args *uap) 2386 { 2387 2388 return (kern_readlinkat(td, uap->fd, uap->path, UIO_USERSPACE, 2389 uap->buf, UIO_USERSPACE, uap->bufsize)); 2390 } 2391 2392 int 2393 kern_readlinkat(struct thread *td, int fd, char *path, enum uio_seg pathseg, 2394 char *buf, enum uio_seg bufseg, size_t count) 2395 { 2396 struct vnode *vp; 2397 struct iovec aiov; 2398 struct uio auio; 2399 struct nameidata nd; 2400 int error; 2401 2402 if (count > IOSIZE_MAX) 2403 return (EINVAL); 2404 2405 NDINIT_AT(&nd, LOOKUP, NOFOLLOW | LOCKSHARED | LOCKLEAF | AUDITVNODE1, 2406 pathseg, path, fd, td); 2407 2408 if ((error = namei(&nd)) != 0) 2409 return (error); 2410 NDFREE(&nd, NDF_ONLY_PNBUF); 2411 vp = nd.ni_vp; 2412 #ifdef MAC 2413 error = mac_vnode_check_readlink(td->td_ucred, vp); 2414 if (error != 0) { 2415 vput(vp); 2416 return (error); 2417 } 2418 #endif 2419 if (vp->v_type != VLNK) 2420 error = EINVAL; 2421 else { 2422 aiov.iov_base = buf; 2423 aiov.iov_len = count; 2424 auio.uio_iov = &aiov; 2425 auio.uio_iovcnt = 1; 2426 auio.uio_offset = 0; 2427 auio.uio_rw = UIO_READ; 2428 auio.uio_segflg = bufseg; 2429 auio.uio_td = td; 2430 auio.uio_resid = count; 2431 error = VOP_READLINK(vp, &auio, td->td_ucred); 2432 td->td_retval[0] = count - auio.uio_resid; 2433 } 2434 vput(vp); 2435 return (error); 2436 } 2437 2438 /* 2439 * Common implementation code for chflags() and fchflags(). 2440 */ 2441 static int 2442 setfflags(td, vp, flags) 2443 struct thread *td; 2444 struct vnode *vp; 2445 u_long flags; 2446 { 2447 struct mount *mp; 2448 struct vattr vattr; 2449 int error; 2450 2451 /* We can't support the value matching VNOVAL. */ 2452 if (flags == VNOVAL) 2453 return (EOPNOTSUPP); 2454 2455 /* 2456 * Prevent non-root users from setting flags on devices. When 2457 * a device is reused, users can retain ownership of the device 2458 * if they are allowed to set flags and programs assume that 2459 * chown can't fail when done as root. 2460 */ 2461 if (vp->v_type == VCHR || vp->v_type == VBLK) { 2462 error = priv_check(td, PRIV_VFS_CHFLAGS_DEV); 2463 if (error != 0) 2464 return (error); 2465 } 2466 2467 if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) 2468 return (error); 2469 VATTR_NULL(&vattr); 2470 vattr.va_flags = flags; 2471 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 2472 #ifdef MAC 2473 error = mac_vnode_check_setflags(td->td_ucred, vp, vattr.va_flags); 2474 if (error == 0) 2475 #endif 2476 error = VOP_SETATTR(vp, &vattr, td->td_ucred); 2477 VOP_UNLOCK(vp, 0); 2478 vn_finished_write(mp); 2479 return (error); 2480 } 2481 2482 /* 2483 * Change flags of a file given a path name. 2484 */ 2485 #ifndef _SYS_SYSPROTO_H_ 2486 struct chflags_args { 2487 const char *path; 2488 u_long flags; 2489 }; 2490 #endif 2491 int 2492 sys_chflags(td, uap) 2493 struct thread *td; 2494 register struct chflags_args /* { 2495 const char *path; 2496 u_long flags; 2497 } */ *uap; 2498 { 2499 2500 return (kern_chflagsat(td, AT_FDCWD, uap->path, UIO_USERSPACE, 2501 uap->flags, 0)); 2502 } 2503 2504 #ifndef _SYS_SYSPROTO_H_ 2505 struct chflagsat_args { 2506 int fd; 2507 const char *path; 2508 u_long flags; 2509 int atflag; 2510 } 2511 #endif 2512 int 2513 sys_chflagsat(struct thread *td, struct chflagsat_args *uap) 2514 { 2515 int fd = uap->fd; 2516 const char *path = uap->path; 2517 u_long flags = uap->flags; 2518 int atflag = uap->atflag; 2519 2520 if (atflag & ~AT_SYMLINK_NOFOLLOW) 2521 return (EINVAL); 2522 2523 return (kern_chflagsat(td, fd, path, UIO_USERSPACE, flags, atflag)); 2524 } 2525 2526 /* 2527 * Same as chflags() but doesn't follow symlinks. 2528 */ 2529 int 2530 sys_lchflags(td, uap) 2531 struct thread *td; 2532 register struct lchflags_args /* { 2533 const char *path; 2534 u_long flags; 2535 } */ *uap; 2536 { 2537 2538 return (kern_chflagsat(td, AT_FDCWD, uap->path, UIO_USERSPACE, 2539 uap->flags, AT_SYMLINK_NOFOLLOW)); 2540 } 2541 2542 static int 2543 kern_chflagsat(struct thread *td, int fd, const char *path, 2544 enum uio_seg pathseg, u_long flags, int atflag) 2545 { 2546 struct nameidata nd; 2547 cap_rights_t rights; 2548 int error, follow; 2549 2550 AUDIT_ARG_FFLAGS(flags); 2551 follow = (atflag & AT_SYMLINK_NOFOLLOW) ? NOFOLLOW : FOLLOW; 2552 NDINIT_ATRIGHTS(&nd, LOOKUP, follow | AUDITVNODE1, pathseg, path, fd, 2553 cap_rights_init(&rights, CAP_FCHFLAGS), td); 2554 if ((error = namei(&nd)) != 0) 2555 return (error); 2556 NDFREE(&nd, NDF_ONLY_PNBUF); 2557 error = setfflags(td, nd.ni_vp, flags); 2558 vrele(nd.ni_vp); 2559 return (error); 2560 } 2561 2562 /* 2563 * Change flags of a file given a file descriptor. 2564 */ 2565 #ifndef _SYS_SYSPROTO_H_ 2566 struct fchflags_args { 2567 int fd; 2568 u_long flags; 2569 }; 2570 #endif 2571 int 2572 sys_fchflags(td, uap) 2573 struct thread *td; 2574 register struct fchflags_args /* { 2575 int fd; 2576 u_long flags; 2577 } */ *uap; 2578 { 2579 struct file *fp; 2580 cap_rights_t rights; 2581 int error; 2582 2583 AUDIT_ARG_FD(uap->fd); 2584 AUDIT_ARG_FFLAGS(uap->flags); 2585 error = getvnode(td, uap->fd, cap_rights_init(&rights, CAP_FCHFLAGS), 2586 &fp); 2587 if (error != 0) 2588 return (error); 2589 #ifdef AUDIT 2590 vn_lock(fp->f_vnode, LK_SHARED | LK_RETRY); 2591 AUDIT_ARG_VNODE1(fp->f_vnode); 2592 VOP_UNLOCK(fp->f_vnode, 0); 2593 #endif 2594 error = setfflags(td, fp->f_vnode, uap->flags); 2595 fdrop(fp, td); 2596 return (error); 2597 } 2598 2599 /* 2600 * Common implementation code for chmod(), lchmod() and fchmod(). 2601 */ 2602 int 2603 setfmode(td, cred, vp, mode) 2604 struct thread *td; 2605 struct ucred *cred; 2606 struct vnode *vp; 2607 int mode; 2608 { 2609 struct mount *mp; 2610 struct vattr vattr; 2611 int error; 2612 2613 if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) 2614 return (error); 2615 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 2616 VATTR_NULL(&vattr); 2617 vattr.va_mode = mode & ALLPERMS; 2618 #ifdef MAC 2619 error = mac_vnode_check_setmode(cred, vp, vattr.va_mode); 2620 if (error == 0) 2621 #endif 2622 error = VOP_SETATTR(vp, &vattr, cred); 2623 VOP_UNLOCK(vp, 0); 2624 vn_finished_write(mp); 2625 return (error); 2626 } 2627 2628 /* 2629 * Change mode of a file given path name. 2630 */ 2631 #ifndef _SYS_SYSPROTO_H_ 2632 struct chmod_args { 2633 char *path; 2634 int mode; 2635 }; 2636 #endif 2637 int 2638 sys_chmod(td, uap) 2639 struct thread *td; 2640 register struct chmod_args /* { 2641 char *path; 2642 int mode; 2643 } */ *uap; 2644 { 2645 2646 return (kern_fchmodat(td, AT_FDCWD, uap->path, UIO_USERSPACE, 2647 uap->mode, 0)); 2648 } 2649 2650 #ifndef _SYS_SYSPROTO_H_ 2651 struct fchmodat_args { 2652 int dirfd; 2653 char *path; 2654 mode_t mode; 2655 int flag; 2656 } 2657 #endif 2658 int 2659 sys_fchmodat(struct thread *td, struct fchmodat_args *uap) 2660 { 2661 int flag = uap->flag; 2662 int fd = uap->fd; 2663 char *path = uap->path; 2664 mode_t mode = uap->mode; 2665 2666 if (flag & ~AT_SYMLINK_NOFOLLOW) 2667 return (EINVAL); 2668 2669 return (kern_fchmodat(td, fd, path, UIO_USERSPACE, mode, flag)); 2670 } 2671 2672 /* 2673 * Change mode of a file given path name (don't follow links.) 2674 */ 2675 #ifndef _SYS_SYSPROTO_H_ 2676 struct lchmod_args { 2677 char *path; 2678 int mode; 2679 }; 2680 #endif 2681 int 2682 sys_lchmod(td, uap) 2683 struct thread *td; 2684 register struct lchmod_args /* { 2685 char *path; 2686 int mode; 2687 } */ *uap; 2688 { 2689 2690 return (kern_fchmodat(td, AT_FDCWD, uap->path, UIO_USERSPACE, 2691 uap->mode, AT_SYMLINK_NOFOLLOW)); 2692 } 2693 2694 int 2695 kern_fchmodat(struct thread *td, int fd, char *path, enum uio_seg pathseg, 2696 mode_t mode, int flag) 2697 { 2698 struct nameidata nd; 2699 cap_rights_t rights; 2700 int error, follow; 2701 2702 AUDIT_ARG_MODE(mode); 2703 follow = (flag & AT_SYMLINK_NOFOLLOW) ? NOFOLLOW : FOLLOW; 2704 NDINIT_ATRIGHTS(&nd, LOOKUP, follow | AUDITVNODE1, pathseg, path, fd, 2705 cap_rights_init(&rights, CAP_FCHMOD), td); 2706 if ((error = namei(&nd)) != 0) 2707 return (error); 2708 NDFREE(&nd, NDF_ONLY_PNBUF); 2709 error = setfmode(td, td->td_ucred, nd.ni_vp, mode); 2710 vrele(nd.ni_vp); 2711 return (error); 2712 } 2713 2714 /* 2715 * Change mode of a file given a file descriptor. 2716 */ 2717 #ifndef _SYS_SYSPROTO_H_ 2718 struct fchmod_args { 2719 int fd; 2720 int mode; 2721 }; 2722 #endif 2723 int 2724 sys_fchmod(struct thread *td, struct fchmod_args *uap) 2725 { 2726 struct file *fp; 2727 cap_rights_t rights; 2728 int error; 2729 2730 AUDIT_ARG_FD(uap->fd); 2731 AUDIT_ARG_MODE(uap->mode); 2732 2733 error = fget(td, uap->fd, cap_rights_init(&rights, CAP_FCHMOD), &fp); 2734 if (error != 0) 2735 return (error); 2736 error = fo_chmod(fp, uap->mode, td->td_ucred, td); 2737 fdrop(fp, td); 2738 return (error); 2739 } 2740 2741 /* 2742 * Common implementation for chown(), lchown(), and fchown() 2743 */ 2744 int 2745 setfown(td, cred, vp, uid, gid) 2746 struct thread *td; 2747 struct ucred *cred; 2748 struct vnode *vp; 2749 uid_t uid; 2750 gid_t gid; 2751 { 2752 struct mount *mp; 2753 struct vattr vattr; 2754 int error; 2755 2756 if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) 2757 return (error); 2758 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 2759 VATTR_NULL(&vattr); 2760 vattr.va_uid = uid; 2761 vattr.va_gid = gid; 2762 #ifdef MAC 2763 error = mac_vnode_check_setowner(cred, vp, vattr.va_uid, 2764 vattr.va_gid); 2765 if (error == 0) 2766 #endif 2767 error = VOP_SETATTR(vp, &vattr, cred); 2768 VOP_UNLOCK(vp, 0); 2769 vn_finished_write(mp); 2770 return (error); 2771 } 2772 2773 /* 2774 * Set ownership given a path name. 2775 */ 2776 #ifndef _SYS_SYSPROTO_H_ 2777 struct chown_args { 2778 char *path; 2779 int uid; 2780 int gid; 2781 }; 2782 #endif 2783 int 2784 sys_chown(td, uap) 2785 struct thread *td; 2786 register struct chown_args /* { 2787 char *path; 2788 int uid; 2789 int gid; 2790 } */ *uap; 2791 { 2792 2793 return (kern_fchownat(td, AT_FDCWD, uap->path, UIO_USERSPACE, uap->uid, 2794 uap->gid, 0)); 2795 } 2796 2797 #ifndef _SYS_SYSPROTO_H_ 2798 struct fchownat_args { 2799 int fd; 2800 const char * path; 2801 uid_t uid; 2802 gid_t gid; 2803 int flag; 2804 }; 2805 #endif 2806 int 2807 sys_fchownat(struct thread *td, struct fchownat_args *uap) 2808 { 2809 int flag; 2810 2811 flag = uap->flag; 2812 if (flag & ~AT_SYMLINK_NOFOLLOW) 2813 return (EINVAL); 2814 2815 return (kern_fchownat(td, uap->fd, uap->path, UIO_USERSPACE, uap->uid, 2816 uap->gid, uap->flag)); 2817 } 2818 2819 int 2820 kern_fchownat(struct thread *td, int fd, char *path, enum uio_seg pathseg, 2821 int uid, int gid, int flag) 2822 { 2823 struct nameidata nd; 2824 cap_rights_t rights; 2825 int error, follow; 2826 2827 AUDIT_ARG_OWNER(uid, gid); 2828 follow = (flag & AT_SYMLINK_NOFOLLOW) ? NOFOLLOW : FOLLOW; 2829 NDINIT_ATRIGHTS(&nd, LOOKUP, follow | AUDITVNODE1, pathseg, path, fd, 2830 cap_rights_init(&rights, CAP_FCHOWN), td); 2831 2832 if ((error = namei(&nd)) != 0) 2833 return (error); 2834 NDFREE(&nd, NDF_ONLY_PNBUF); 2835 error = setfown(td, td->td_ucred, nd.ni_vp, uid, gid); 2836 vrele(nd.ni_vp); 2837 return (error); 2838 } 2839 2840 /* 2841 * Set ownership given a path name, do not cross symlinks. 2842 */ 2843 #ifndef _SYS_SYSPROTO_H_ 2844 struct lchown_args { 2845 char *path; 2846 int uid; 2847 int gid; 2848 }; 2849 #endif 2850 int 2851 sys_lchown(td, uap) 2852 struct thread *td; 2853 register struct lchown_args /* { 2854 char *path; 2855 int uid; 2856 int gid; 2857 } */ *uap; 2858 { 2859 2860 return (kern_fchownat(td, AT_FDCWD, uap->path, UIO_USERSPACE, 2861 uap->uid, uap->gid, AT_SYMLINK_NOFOLLOW)); 2862 } 2863 2864 /* 2865 * Set ownership given a file descriptor. 2866 */ 2867 #ifndef _SYS_SYSPROTO_H_ 2868 struct fchown_args { 2869 int fd; 2870 int uid; 2871 int gid; 2872 }; 2873 #endif 2874 int 2875 sys_fchown(td, uap) 2876 struct thread *td; 2877 register struct fchown_args /* { 2878 int fd; 2879 int uid; 2880 int gid; 2881 } */ *uap; 2882 { 2883 struct file *fp; 2884 cap_rights_t rights; 2885 int error; 2886 2887 AUDIT_ARG_FD(uap->fd); 2888 AUDIT_ARG_OWNER(uap->uid, uap->gid); 2889 error = fget(td, uap->fd, cap_rights_init(&rights, CAP_FCHOWN), &fp); 2890 if (error != 0) 2891 return (error); 2892 error = fo_chown(fp, uap->uid, uap->gid, td->td_ucred, td); 2893 fdrop(fp, td); 2894 return (error); 2895 } 2896 2897 /* 2898 * Common implementation code for utimes(), lutimes(), and futimes(). 2899 */ 2900 static int 2901 getutimes(usrtvp, tvpseg, tsp) 2902 const struct timeval *usrtvp; 2903 enum uio_seg tvpseg; 2904 struct timespec *tsp; 2905 { 2906 struct timeval tv[2]; 2907 const struct timeval *tvp; 2908 int error; 2909 2910 if (usrtvp == NULL) { 2911 vfs_timestamp(&tsp[0]); 2912 tsp[1] = tsp[0]; 2913 } else { 2914 if (tvpseg == UIO_SYSSPACE) { 2915 tvp = usrtvp; 2916 } else { 2917 if ((error = copyin(usrtvp, tv, sizeof(tv))) != 0) 2918 return (error); 2919 tvp = tv; 2920 } 2921 2922 if (tvp[0].tv_usec < 0 || tvp[0].tv_usec >= 1000000 || 2923 tvp[1].tv_usec < 0 || tvp[1].tv_usec >= 1000000) 2924 return (EINVAL); 2925 TIMEVAL_TO_TIMESPEC(&tvp[0], &tsp[0]); 2926 TIMEVAL_TO_TIMESPEC(&tvp[1], &tsp[1]); 2927 } 2928 return (0); 2929 } 2930 2931 /* 2932 * Common implementation code for futimens(), utimensat(). 2933 */ 2934 #define UTIMENS_NULL 0x1 2935 #define UTIMENS_EXIT 0x2 2936 static int 2937 getutimens(const struct timespec *usrtsp, enum uio_seg tspseg, 2938 struct timespec *tsp, int *retflags) 2939 { 2940 struct timespec tsnow; 2941 int error; 2942 2943 vfs_timestamp(&tsnow); 2944 *retflags = 0; 2945 if (usrtsp == NULL) { 2946 tsp[0] = tsnow; 2947 tsp[1] = tsnow; 2948 *retflags |= UTIMENS_NULL; 2949 return (0); 2950 } 2951 if (tspseg == UIO_SYSSPACE) { 2952 tsp[0] = usrtsp[0]; 2953 tsp[1] = usrtsp[1]; 2954 } else if ((error = copyin(usrtsp, tsp, sizeof(*tsp) * 2)) != 0) 2955 return (error); 2956 if (tsp[0].tv_nsec == UTIME_OMIT && tsp[1].tv_nsec == UTIME_OMIT) 2957 *retflags |= UTIMENS_EXIT; 2958 if (tsp[0].tv_nsec == UTIME_NOW && tsp[1].tv_nsec == UTIME_NOW) 2959 *retflags |= UTIMENS_NULL; 2960 if (tsp[0].tv_nsec == UTIME_OMIT) 2961 tsp[0].tv_sec = VNOVAL; 2962 else if (tsp[0].tv_nsec == UTIME_NOW) 2963 tsp[0] = tsnow; 2964 else if (tsp[0].tv_nsec < 0 || tsp[0].tv_nsec >= 1000000000L) 2965 return (EINVAL); 2966 if (tsp[1].tv_nsec == UTIME_OMIT) 2967 tsp[1].tv_sec = VNOVAL; 2968 else if (tsp[1].tv_nsec == UTIME_NOW) 2969 tsp[1] = tsnow; 2970 else if (tsp[1].tv_nsec < 0 || tsp[1].tv_nsec >= 1000000000L) 2971 return (EINVAL); 2972 2973 return (0); 2974 } 2975 2976 /* 2977 * Common implementation code for utimes(), lutimes(), futimes(), futimens(), 2978 * and utimensat(). 2979 */ 2980 static int 2981 setutimes(td, vp, ts, numtimes, nullflag) 2982 struct thread *td; 2983 struct vnode *vp; 2984 const struct timespec *ts; 2985 int numtimes; 2986 int nullflag; 2987 { 2988 struct mount *mp; 2989 struct vattr vattr; 2990 int error, setbirthtime; 2991 2992 if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) 2993 return (error); 2994 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 2995 setbirthtime = 0; 2996 if (numtimes < 3 && !VOP_GETATTR(vp, &vattr, td->td_ucred) && 2997 timespeccmp(&ts[1], &vattr.va_birthtime, < )) 2998 setbirthtime = 1; 2999 VATTR_NULL(&vattr); 3000 vattr.va_atime = ts[0]; 3001 vattr.va_mtime = ts[1]; 3002 if (setbirthtime) 3003 vattr.va_birthtime = ts[1]; 3004 if (numtimes > 2) 3005 vattr.va_birthtime = ts[2]; 3006 if (nullflag) 3007 vattr.va_vaflags |= VA_UTIMES_NULL; 3008 #ifdef MAC 3009 error = mac_vnode_check_setutimes(td->td_ucred, vp, vattr.va_atime, 3010 vattr.va_mtime); 3011 #endif 3012 if (error == 0) 3013 error = VOP_SETATTR(vp, &vattr, td->td_ucred); 3014 VOP_UNLOCK(vp, 0); 3015 vn_finished_write(mp); 3016 return (error); 3017 } 3018 3019 /* 3020 * Set the access and modification times of a file. 3021 */ 3022 #ifndef _SYS_SYSPROTO_H_ 3023 struct utimes_args { 3024 char *path; 3025 struct timeval *tptr; 3026 }; 3027 #endif 3028 int 3029 sys_utimes(td, uap) 3030 struct thread *td; 3031 register struct utimes_args /* { 3032 char *path; 3033 struct timeval *tptr; 3034 } */ *uap; 3035 { 3036 3037 return (kern_utimesat(td, AT_FDCWD, uap->path, UIO_USERSPACE, 3038 uap->tptr, UIO_USERSPACE)); 3039 } 3040 3041 #ifndef _SYS_SYSPROTO_H_ 3042 struct futimesat_args { 3043 int fd; 3044 const char * path; 3045 const struct timeval * times; 3046 }; 3047 #endif 3048 int 3049 sys_futimesat(struct thread *td, struct futimesat_args *uap) 3050 { 3051 3052 return (kern_utimesat(td, uap->fd, uap->path, UIO_USERSPACE, 3053 uap->times, UIO_USERSPACE)); 3054 } 3055 3056 int 3057 kern_utimesat(struct thread *td, int fd, char *path, enum uio_seg pathseg, 3058 struct timeval *tptr, enum uio_seg tptrseg) 3059 { 3060 struct nameidata nd; 3061 struct timespec ts[2]; 3062 cap_rights_t rights; 3063 int error; 3064 3065 if ((error = getutimes(tptr, tptrseg, ts)) != 0) 3066 return (error); 3067 NDINIT_ATRIGHTS(&nd, LOOKUP, FOLLOW | AUDITVNODE1, pathseg, path, fd, 3068 cap_rights_init(&rights, CAP_FUTIMES), td); 3069 3070 if ((error = namei(&nd)) != 0) 3071 return (error); 3072 NDFREE(&nd, NDF_ONLY_PNBUF); 3073 error = setutimes(td, nd.ni_vp, ts, 2, tptr == NULL); 3074 vrele(nd.ni_vp); 3075 return (error); 3076 } 3077 3078 /* 3079 * Set the access and modification times of a file. 3080 */ 3081 #ifndef _SYS_SYSPROTO_H_ 3082 struct lutimes_args { 3083 char *path; 3084 struct timeval *tptr; 3085 }; 3086 #endif 3087 int 3088 sys_lutimes(td, uap) 3089 struct thread *td; 3090 register struct lutimes_args /* { 3091 char *path; 3092 struct timeval *tptr; 3093 } */ *uap; 3094 { 3095 3096 return (kern_lutimes(td, uap->path, UIO_USERSPACE, uap->tptr, 3097 UIO_USERSPACE)); 3098 } 3099 3100 int 3101 kern_lutimes(struct thread *td, char *path, enum uio_seg pathseg, 3102 struct timeval *tptr, enum uio_seg tptrseg) 3103 { 3104 struct timespec ts[2]; 3105 struct nameidata nd; 3106 int error; 3107 3108 if ((error = getutimes(tptr, tptrseg, ts)) != 0) 3109 return (error); 3110 NDINIT(&nd, LOOKUP, NOFOLLOW | AUDITVNODE1, pathseg, path, td); 3111 if ((error = namei(&nd)) != 0) 3112 return (error); 3113 NDFREE(&nd, NDF_ONLY_PNBUF); 3114 error = setutimes(td, nd.ni_vp, ts, 2, tptr == NULL); 3115 vrele(nd.ni_vp); 3116 return (error); 3117 } 3118 3119 /* 3120 * Set the access and modification times of a file. 3121 */ 3122 #ifndef _SYS_SYSPROTO_H_ 3123 struct futimes_args { 3124 int fd; 3125 struct timeval *tptr; 3126 }; 3127 #endif 3128 int 3129 sys_futimes(td, uap) 3130 struct thread *td; 3131 register struct futimes_args /* { 3132 int fd; 3133 struct timeval *tptr; 3134 } */ *uap; 3135 { 3136 3137 return (kern_futimes(td, uap->fd, uap->tptr, UIO_USERSPACE)); 3138 } 3139 3140 int 3141 kern_futimes(struct thread *td, int fd, struct timeval *tptr, 3142 enum uio_seg tptrseg) 3143 { 3144 struct timespec ts[2]; 3145 struct file *fp; 3146 cap_rights_t rights; 3147 int error; 3148 3149 AUDIT_ARG_FD(fd); 3150 error = getutimes(tptr, tptrseg, ts); 3151 if (error != 0) 3152 return (error); 3153 error = getvnode(td, fd, cap_rights_init(&rights, CAP_FUTIMES), &fp); 3154 if (error != 0) 3155 return (error); 3156 #ifdef AUDIT 3157 vn_lock(fp->f_vnode, LK_SHARED | LK_RETRY); 3158 AUDIT_ARG_VNODE1(fp->f_vnode); 3159 VOP_UNLOCK(fp->f_vnode, 0); 3160 #endif 3161 error = setutimes(td, fp->f_vnode, ts, 2, tptr == NULL); 3162 fdrop(fp, td); 3163 return (error); 3164 } 3165 3166 int 3167 sys_futimens(struct thread *td, struct futimens_args *uap) 3168 { 3169 3170 return (kern_futimens(td, uap->fd, uap->times, UIO_USERSPACE)); 3171 } 3172 3173 int 3174 kern_futimens(struct thread *td, int fd, struct timespec *tptr, 3175 enum uio_seg tptrseg) 3176 { 3177 struct timespec ts[2]; 3178 struct file *fp; 3179 cap_rights_t rights; 3180 int error, flags; 3181 3182 AUDIT_ARG_FD(fd); 3183 error = getutimens(tptr, tptrseg, ts, &flags); 3184 if (error != 0) 3185 return (error); 3186 if (flags & UTIMENS_EXIT) 3187 return (0); 3188 error = getvnode(td, fd, cap_rights_init(&rights, CAP_FUTIMES), &fp); 3189 if (error != 0) 3190 return (error); 3191 #ifdef AUDIT 3192 vn_lock(fp->f_vnode, LK_SHARED | LK_RETRY); 3193 AUDIT_ARG_VNODE1(fp->f_vnode); 3194 VOP_UNLOCK(fp->f_vnode, 0); 3195 #endif 3196 error = setutimes(td, fp->f_vnode, ts, 2, flags & UTIMENS_NULL); 3197 fdrop(fp, td); 3198 return (error); 3199 } 3200 3201 int 3202 sys_utimensat(struct thread *td, struct utimensat_args *uap) 3203 { 3204 3205 return (kern_utimensat(td, uap->fd, uap->path, UIO_USERSPACE, 3206 uap->times, UIO_USERSPACE, uap->flag)); 3207 } 3208 3209 int 3210 kern_utimensat(struct thread *td, int fd, char *path, enum uio_seg pathseg, 3211 struct timespec *tptr, enum uio_seg tptrseg, int flag) 3212 { 3213 struct nameidata nd; 3214 struct timespec ts[2]; 3215 cap_rights_t rights; 3216 int error, flags; 3217 3218 if (flag & ~AT_SYMLINK_NOFOLLOW) 3219 return (EINVAL); 3220 3221 if ((error = getutimens(tptr, tptrseg, ts, &flags)) != 0) 3222 return (error); 3223 NDINIT_ATRIGHTS(&nd, LOOKUP, ((flag & AT_SYMLINK_NOFOLLOW) ? NOFOLLOW : 3224 FOLLOW) | AUDITVNODE1, pathseg, path, fd, 3225 cap_rights_init(&rights, CAP_FUTIMES), td); 3226 if ((error = namei(&nd)) != 0) 3227 return (error); 3228 /* 3229 * We are allowed to call namei() regardless of 2xUTIME_OMIT. 3230 * POSIX states: 3231 * "If both tv_nsec fields are UTIME_OMIT... EACCESS may be detected." 3232 * "Search permission is denied by a component of the path prefix." 3233 */ 3234 NDFREE(&nd, NDF_ONLY_PNBUF); 3235 if ((flags & UTIMENS_EXIT) == 0) 3236 error = setutimes(td, nd.ni_vp, ts, 2, flags & UTIMENS_NULL); 3237 vrele(nd.ni_vp); 3238 return (error); 3239 } 3240 3241 /* 3242 * Truncate a file given its path name. 3243 */ 3244 #ifndef _SYS_SYSPROTO_H_ 3245 struct truncate_args { 3246 char *path; 3247 int pad; 3248 off_t length; 3249 }; 3250 #endif 3251 int 3252 sys_truncate(td, uap) 3253 struct thread *td; 3254 register struct truncate_args /* { 3255 char *path; 3256 int pad; 3257 off_t length; 3258 } */ *uap; 3259 { 3260 3261 return (kern_truncate(td, uap->path, UIO_USERSPACE, uap->length)); 3262 } 3263 3264 int 3265 kern_truncate(struct thread *td, char *path, enum uio_seg pathseg, off_t length) 3266 { 3267 struct mount *mp; 3268 struct vnode *vp; 3269 void *rl_cookie; 3270 struct vattr vattr; 3271 struct nameidata nd; 3272 int error; 3273 3274 if (length < 0) 3275 return(EINVAL); 3276 NDINIT(&nd, LOOKUP, FOLLOW | AUDITVNODE1, pathseg, path, td); 3277 if ((error = namei(&nd)) != 0) 3278 return (error); 3279 vp = nd.ni_vp; 3280 rl_cookie = vn_rangelock_wlock(vp, 0, OFF_MAX); 3281 if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) { 3282 vn_rangelock_unlock(vp, rl_cookie); 3283 vrele(vp); 3284 return (error); 3285 } 3286 NDFREE(&nd, NDF_ONLY_PNBUF); 3287 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 3288 if (vp->v_type == VDIR) 3289 error = EISDIR; 3290 #ifdef MAC 3291 else if ((error = mac_vnode_check_write(td->td_ucred, NOCRED, vp))) { 3292 } 3293 #endif 3294 else if ((error = vn_writechk(vp)) == 0 && 3295 (error = VOP_ACCESS(vp, VWRITE, td->td_ucred, td)) == 0) { 3296 VATTR_NULL(&vattr); 3297 vattr.va_size = length; 3298 error = VOP_SETATTR(vp, &vattr, td->td_ucred); 3299 } 3300 VOP_UNLOCK(vp, 0); 3301 vn_finished_write(mp); 3302 vn_rangelock_unlock(vp, rl_cookie); 3303 vrele(vp); 3304 return (error); 3305 } 3306 3307 #if defined(COMPAT_43) 3308 /* 3309 * Truncate a file given its path name. 3310 */ 3311 #ifndef _SYS_SYSPROTO_H_ 3312 struct otruncate_args { 3313 char *path; 3314 long length; 3315 }; 3316 #endif 3317 int 3318 otruncate(td, uap) 3319 struct thread *td; 3320 register struct otruncate_args /* { 3321 char *path; 3322 long length; 3323 } */ *uap; 3324 { 3325 struct truncate_args /* { 3326 char *path; 3327 int pad; 3328 off_t length; 3329 } */ nuap; 3330 3331 nuap.path = uap->path; 3332 nuap.length = uap->length; 3333 return (sys_truncate(td, &nuap)); 3334 } 3335 #endif /* COMPAT_43 */ 3336 3337 #if defined(COMPAT_FREEBSD6) 3338 /* Versions with the pad argument */ 3339 int 3340 freebsd6_truncate(struct thread *td, struct freebsd6_truncate_args *uap) 3341 { 3342 struct truncate_args ouap; 3343 3344 ouap.path = uap->path; 3345 ouap.length = uap->length; 3346 return (sys_truncate(td, &ouap)); 3347 } 3348 3349 int 3350 freebsd6_ftruncate(struct thread *td, struct freebsd6_ftruncate_args *uap) 3351 { 3352 struct ftruncate_args ouap; 3353 3354 ouap.fd = uap->fd; 3355 ouap.length = uap->length; 3356 return (sys_ftruncate(td, &ouap)); 3357 } 3358 #endif 3359 3360 /* 3361 * Sync an open file. 3362 */ 3363 #ifndef _SYS_SYSPROTO_H_ 3364 struct fsync_args { 3365 int fd; 3366 }; 3367 #endif 3368 int 3369 sys_fsync(td, uap) 3370 struct thread *td; 3371 struct fsync_args /* { 3372 int fd; 3373 } */ *uap; 3374 { 3375 struct vnode *vp; 3376 struct mount *mp; 3377 struct file *fp; 3378 cap_rights_t rights; 3379 int error, lock_flags; 3380 3381 AUDIT_ARG_FD(uap->fd); 3382 error = getvnode(td, uap->fd, cap_rights_init(&rights, CAP_FSYNC), &fp); 3383 if (error != 0) 3384 return (error); 3385 vp = fp->f_vnode; 3386 error = vn_start_write(vp, &mp, V_WAIT | PCATCH); 3387 if (error != 0) 3388 goto drop; 3389 if (MNT_SHARED_WRITES(mp) || 3390 ((mp == NULL) && MNT_SHARED_WRITES(vp->v_mount))) { 3391 lock_flags = LK_SHARED; 3392 } else { 3393 lock_flags = LK_EXCLUSIVE; 3394 } 3395 vn_lock(vp, lock_flags | LK_RETRY); 3396 AUDIT_ARG_VNODE1(vp); 3397 if (vp->v_object != NULL) { 3398 VM_OBJECT_WLOCK(vp->v_object); 3399 vm_object_page_clean(vp->v_object, 0, 0, 0); 3400 VM_OBJECT_WUNLOCK(vp->v_object); 3401 } 3402 error = VOP_FSYNC(vp, MNT_WAIT, td); 3403 3404 VOP_UNLOCK(vp, 0); 3405 vn_finished_write(mp); 3406 drop: 3407 fdrop(fp, td); 3408 return (error); 3409 } 3410 3411 /* 3412 * Rename files. Source and destination must either both be directories, or 3413 * both not be directories. If target is a directory, it must be empty. 3414 */ 3415 #ifndef _SYS_SYSPROTO_H_ 3416 struct rename_args { 3417 char *from; 3418 char *to; 3419 }; 3420 #endif 3421 int 3422 sys_rename(td, uap) 3423 struct thread *td; 3424 register struct rename_args /* { 3425 char *from; 3426 char *to; 3427 } */ *uap; 3428 { 3429 3430 return (kern_renameat(td, AT_FDCWD, uap->from, AT_FDCWD, 3431 uap->to, UIO_USERSPACE)); 3432 } 3433 3434 #ifndef _SYS_SYSPROTO_H_ 3435 struct renameat_args { 3436 int oldfd; 3437 char *old; 3438 int newfd; 3439 char *new; 3440 }; 3441 #endif 3442 int 3443 sys_renameat(struct thread *td, struct renameat_args *uap) 3444 { 3445 3446 return (kern_renameat(td, uap->oldfd, uap->old, uap->newfd, uap->new, 3447 UIO_USERSPACE)); 3448 } 3449 3450 int 3451 kern_renameat(struct thread *td, int oldfd, char *old, int newfd, char *new, 3452 enum uio_seg pathseg) 3453 { 3454 struct mount *mp = NULL; 3455 struct vnode *tvp, *fvp, *tdvp; 3456 struct nameidata fromnd, tond; 3457 cap_rights_t rights; 3458 int error; 3459 3460 again: 3461 bwillwrite(); 3462 #ifdef MAC 3463 NDINIT_ATRIGHTS(&fromnd, DELETE, LOCKPARENT | LOCKLEAF | SAVESTART | 3464 AUDITVNODE1, pathseg, old, oldfd, 3465 cap_rights_init(&rights, CAP_RENAMEAT_SOURCE), td); 3466 #else 3467 NDINIT_ATRIGHTS(&fromnd, DELETE, WANTPARENT | SAVESTART | AUDITVNODE1, 3468 pathseg, old, oldfd, 3469 cap_rights_init(&rights, CAP_RENAMEAT_SOURCE), td); 3470 #endif 3471 3472 if ((error = namei(&fromnd)) != 0) 3473 return (error); 3474 #ifdef MAC 3475 error = mac_vnode_check_rename_from(td->td_ucred, fromnd.ni_dvp, 3476 fromnd.ni_vp, &fromnd.ni_cnd); 3477 VOP_UNLOCK(fromnd.ni_dvp, 0); 3478 if (fromnd.ni_dvp != fromnd.ni_vp) 3479 VOP_UNLOCK(fromnd.ni_vp, 0); 3480 #endif 3481 fvp = fromnd.ni_vp; 3482 NDINIT_ATRIGHTS(&tond, RENAME, LOCKPARENT | LOCKLEAF | NOCACHE | 3483 SAVESTART | AUDITVNODE2, pathseg, new, newfd, 3484 cap_rights_init(&rights, CAP_RENAMEAT_TARGET), td); 3485 if (fromnd.ni_vp->v_type == VDIR) 3486 tond.ni_cnd.cn_flags |= WILLBEDIR; 3487 if ((error = namei(&tond)) != 0) { 3488 /* Translate error code for rename("dir1", "dir2/."). */ 3489 if (error == EISDIR && fvp->v_type == VDIR) 3490 error = EINVAL; 3491 NDFREE(&fromnd, NDF_ONLY_PNBUF); 3492 vrele(fromnd.ni_dvp); 3493 vrele(fvp); 3494 goto out1; 3495 } 3496 tdvp = tond.ni_dvp; 3497 tvp = tond.ni_vp; 3498 error = vn_start_write(fvp, &mp, V_NOWAIT); 3499 if (error != 0) { 3500 NDFREE(&fromnd, NDF_ONLY_PNBUF); 3501 NDFREE(&tond, NDF_ONLY_PNBUF); 3502 if (tvp != NULL) 3503 vput(tvp); 3504 if (tdvp == tvp) 3505 vrele(tdvp); 3506 else 3507 vput(tdvp); 3508 vrele(fromnd.ni_dvp); 3509 vrele(fvp); 3510 vrele(tond.ni_startdir); 3511 if (fromnd.ni_startdir != NULL) 3512 vrele(fromnd.ni_startdir); 3513 error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH); 3514 if (error != 0) 3515 return (error); 3516 goto again; 3517 } 3518 if (tvp != NULL) { 3519 if (fvp->v_type == VDIR && tvp->v_type != VDIR) { 3520 error = ENOTDIR; 3521 goto out; 3522 } else if (fvp->v_type != VDIR && tvp->v_type == VDIR) { 3523 error = EISDIR; 3524 goto out; 3525 } 3526 #ifdef CAPABILITIES 3527 if (newfd != AT_FDCWD) { 3528 /* 3529 * If the target already exists we require CAP_UNLINKAT 3530 * from 'newfd'. 3531 */ 3532 error = cap_check(&tond.ni_filecaps.fc_rights, 3533 cap_rights_init(&rights, CAP_UNLINKAT)); 3534 if (error != 0) 3535 goto out; 3536 } 3537 #endif 3538 } 3539 if (fvp == tdvp) { 3540 error = EINVAL; 3541 goto out; 3542 } 3543 /* 3544 * If the source is the same as the destination (that is, if they 3545 * are links to the same vnode), then there is nothing to do. 3546 */ 3547 if (fvp == tvp) 3548 error = -1; 3549 #ifdef MAC 3550 else 3551 error = mac_vnode_check_rename_to(td->td_ucred, tdvp, 3552 tond.ni_vp, fromnd.ni_dvp == tdvp, &tond.ni_cnd); 3553 #endif 3554 out: 3555 if (error == 0) { 3556 error = VOP_RENAME(fromnd.ni_dvp, fromnd.ni_vp, &fromnd.ni_cnd, 3557 tond.ni_dvp, tond.ni_vp, &tond.ni_cnd); 3558 NDFREE(&fromnd, NDF_ONLY_PNBUF); 3559 NDFREE(&tond, NDF_ONLY_PNBUF); 3560 } else { 3561 NDFREE(&fromnd, NDF_ONLY_PNBUF); 3562 NDFREE(&tond, NDF_ONLY_PNBUF); 3563 if (tvp != NULL) 3564 vput(tvp); 3565 if (tdvp == tvp) 3566 vrele(tdvp); 3567 else 3568 vput(tdvp); 3569 vrele(fromnd.ni_dvp); 3570 vrele(fvp); 3571 } 3572 vrele(tond.ni_startdir); 3573 vn_finished_write(mp); 3574 out1: 3575 if (fromnd.ni_startdir) 3576 vrele(fromnd.ni_startdir); 3577 if (error == -1) 3578 return (0); 3579 return (error); 3580 } 3581 3582 /* 3583 * Make a directory file. 3584 */ 3585 #ifndef _SYS_SYSPROTO_H_ 3586 struct mkdir_args { 3587 char *path; 3588 int mode; 3589 }; 3590 #endif 3591 int 3592 sys_mkdir(td, uap) 3593 struct thread *td; 3594 register struct mkdir_args /* { 3595 char *path; 3596 int mode; 3597 } */ *uap; 3598 { 3599 3600 return (kern_mkdirat(td, AT_FDCWD, uap->path, UIO_USERSPACE, 3601 uap->mode)); 3602 } 3603 3604 #ifndef _SYS_SYSPROTO_H_ 3605 struct mkdirat_args { 3606 int fd; 3607 char *path; 3608 mode_t mode; 3609 }; 3610 #endif 3611 int 3612 sys_mkdirat(struct thread *td, struct mkdirat_args *uap) 3613 { 3614 3615 return (kern_mkdirat(td, uap->fd, uap->path, UIO_USERSPACE, uap->mode)); 3616 } 3617 3618 int 3619 kern_mkdirat(struct thread *td, int fd, char *path, enum uio_seg segflg, 3620 int mode) 3621 { 3622 struct mount *mp; 3623 struct vnode *vp; 3624 struct vattr vattr; 3625 struct nameidata nd; 3626 cap_rights_t rights; 3627 int error; 3628 3629 AUDIT_ARG_MODE(mode); 3630 restart: 3631 bwillwrite(); 3632 NDINIT_ATRIGHTS(&nd, CREATE, LOCKPARENT | SAVENAME | AUDITVNODE1 | 3633 NOCACHE, segflg, path, fd, cap_rights_init(&rights, CAP_MKDIRAT), 3634 td); 3635 nd.ni_cnd.cn_flags |= WILLBEDIR; 3636 if ((error = namei(&nd)) != 0) 3637 return (error); 3638 vp = nd.ni_vp; 3639 if (vp != NULL) { 3640 NDFREE(&nd, NDF_ONLY_PNBUF); 3641 /* 3642 * XXX namei called with LOCKPARENT but not LOCKLEAF has 3643 * the strange behaviour of leaving the vnode unlocked 3644 * if the target is the same vnode as the parent. 3645 */ 3646 if (vp == nd.ni_dvp) 3647 vrele(nd.ni_dvp); 3648 else 3649 vput(nd.ni_dvp); 3650 vrele(vp); 3651 return (EEXIST); 3652 } 3653 if (vn_start_write(nd.ni_dvp, &mp, V_NOWAIT) != 0) { 3654 NDFREE(&nd, NDF_ONLY_PNBUF); 3655 vput(nd.ni_dvp); 3656 if ((error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH)) != 0) 3657 return (error); 3658 goto restart; 3659 } 3660 VATTR_NULL(&vattr); 3661 vattr.va_type = VDIR; 3662 vattr.va_mode = (mode & ACCESSPERMS) &~ td->td_proc->p_fd->fd_cmask; 3663 #ifdef MAC 3664 error = mac_vnode_check_create(td->td_ucred, nd.ni_dvp, &nd.ni_cnd, 3665 &vattr); 3666 if (error != 0) 3667 goto out; 3668 #endif 3669 error = VOP_MKDIR(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr); 3670 #ifdef MAC 3671 out: 3672 #endif 3673 NDFREE(&nd, NDF_ONLY_PNBUF); 3674 vput(nd.ni_dvp); 3675 if (error == 0) 3676 vput(nd.ni_vp); 3677 vn_finished_write(mp); 3678 return (error); 3679 } 3680 3681 /* 3682 * Remove a directory file. 3683 */ 3684 #ifndef _SYS_SYSPROTO_H_ 3685 struct rmdir_args { 3686 char *path; 3687 }; 3688 #endif 3689 int 3690 sys_rmdir(td, uap) 3691 struct thread *td; 3692 struct rmdir_args /* { 3693 char *path; 3694 } */ *uap; 3695 { 3696 3697 return (kern_rmdirat(td, AT_FDCWD, uap->path, UIO_USERSPACE)); 3698 } 3699 3700 int 3701 kern_rmdirat(struct thread *td, int fd, char *path, enum uio_seg pathseg) 3702 { 3703 struct mount *mp; 3704 struct vnode *vp; 3705 struct nameidata nd; 3706 cap_rights_t rights; 3707 int error; 3708 3709 restart: 3710 bwillwrite(); 3711 NDINIT_ATRIGHTS(&nd, DELETE, LOCKPARENT | LOCKLEAF | AUDITVNODE1, 3712 pathseg, path, fd, cap_rights_init(&rights, CAP_UNLINKAT), td); 3713 if ((error = namei(&nd)) != 0) 3714 return (error); 3715 vp = nd.ni_vp; 3716 if (vp->v_type != VDIR) { 3717 error = ENOTDIR; 3718 goto out; 3719 } 3720 /* 3721 * No rmdir "." please. 3722 */ 3723 if (nd.ni_dvp == vp) { 3724 error = EINVAL; 3725 goto out; 3726 } 3727 /* 3728 * The root of a mounted filesystem cannot be deleted. 3729 */ 3730 if (vp->v_vflag & VV_ROOT) { 3731 error = EBUSY; 3732 goto out; 3733 } 3734 #ifdef MAC 3735 error = mac_vnode_check_unlink(td->td_ucred, nd.ni_dvp, vp, 3736 &nd.ni_cnd); 3737 if (error != 0) 3738 goto out; 3739 #endif 3740 if (vn_start_write(nd.ni_dvp, &mp, V_NOWAIT) != 0) { 3741 NDFREE(&nd, NDF_ONLY_PNBUF); 3742 vput(vp); 3743 if (nd.ni_dvp == vp) 3744 vrele(nd.ni_dvp); 3745 else 3746 vput(nd.ni_dvp); 3747 if ((error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH)) != 0) 3748 return (error); 3749 goto restart; 3750 } 3751 vfs_notify_upper(vp, VFS_NOTIFY_UPPER_UNLINK); 3752 error = VOP_RMDIR(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd); 3753 vn_finished_write(mp); 3754 out: 3755 NDFREE(&nd, NDF_ONLY_PNBUF); 3756 vput(vp); 3757 if (nd.ni_dvp == vp) 3758 vrele(nd.ni_dvp); 3759 else 3760 vput(nd.ni_dvp); 3761 return (error); 3762 } 3763 3764 #ifdef COMPAT_43 3765 /* 3766 * Read a block of directory entries in a filesystem independent format. 3767 */ 3768 #ifndef _SYS_SYSPROTO_H_ 3769 struct ogetdirentries_args { 3770 int fd; 3771 char *buf; 3772 u_int count; 3773 long *basep; 3774 }; 3775 #endif 3776 int 3777 ogetdirentries(struct thread *td, struct ogetdirentries_args *uap) 3778 { 3779 long loff; 3780 int error; 3781 3782 error = kern_ogetdirentries(td, uap, &loff); 3783 if (error == 0) 3784 error = copyout(&loff, uap->basep, sizeof(long)); 3785 return (error); 3786 } 3787 3788 int 3789 kern_ogetdirentries(struct thread *td, struct ogetdirentries_args *uap, 3790 long *ploff) 3791 { 3792 struct vnode *vp; 3793 struct file *fp; 3794 struct uio auio, kuio; 3795 struct iovec aiov, kiov; 3796 struct dirent *dp, *edp; 3797 cap_rights_t rights; 3798 caddr_t dirbuf; 3799 int error, eofflag, readcnt; 3800 long loff; 3801 off_t foffset; 3802 3803 /* XXX arbitrary sanity limit on `count'. */ 3804 if (uap->count > 64 * 1024) 3805 return (EINVAL); 3806 error = getvnode(td, uap->fd, cap_rights_init(&rights, CAP_READ), &fp); 3807 if (error != 0) 3808 return (error); 3809 if ((fp->f_flag & FREAD) == 0) { 3810 fdrop(fp, td); 3811 return (EBADF); 3812 } 3813 vp = fp->f_vnode; 3814 foffset = foffset_lock(fp, 0); 3815 unionread: 3816 if (vp->v_type != VDIR) { 3817 foffset_unlock(fp, foffset, 0); 3818 fdrop(fp, td); 3819 return (EINVAL); 3820 } 3821 aiov.iov_base = uap->buf; 3822 aiov.iov_len = uap->count; 3823 auio.uio_iov = &aiov; 3824 auio.uio_iovcnt = 1; 3825 auio.uio_rw = UIO_READ; 3826 auio.uio_segflg = UIO_USERSPACE; 3827 auio.uio_td = td; 3828 auio.uio_resid = uap->count; 3829 vn_lock(vp, LK_SHARED | LK_RETRY); 3830 loff = auio.uio_offset = foffset; 3831 #ifdef MAC 3832 error = mac_vnode_check_readdir(td->td_ucred, vp); 3833 if (error != 0) { 3834 VOP_UNLOCK(vp, 0); 3835 foffset_unlock(fp, foffset, FOF_NOUPDATE); 3836 fdrop(fp, td); 3837 return (error); 3838 } 3839 #endif 3840 # if (BYTE_ORDER != LITTLE_ENDIAN) 3841 if (vp->v_mount->mnt_maxsymlinklen <= 0) { 3842 error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag, 3843 NULL, NULL); 3844 foffset = auio.uio_offset; 3845 } else 3846 # endif 3847 { 3848 kuio = auio; 3849 kuio.uio_iov = &kiov; 3850 kuio.uio_segflg = UIO_SYSSPACE; 3851 kiov.iov_len = uap->count; 3852 dirbuf = malloc(uap->count, M_TEMP, M_WAITOK); 3853 kiov.iov_base = dirbuf; 3854 error = VOP_READDIR(vp, &kuio, fp->f_cred, &eofflag, 3855 NULL, NULL); 3856 foffset = kuio.uio_offset; 3857 if (error == 0) { 3858 readcnt = uap->count - kuio.uio_resid; 3859 edp = (struct dirent *)&dirbuf[readcnt]; 3860 for (dp = (struct dirent *)dirbuf; dp < edp; ) { 3861 # if (BYTE_ORDER == LITTLE_ENDIAN) 3862 /* 3863 * The expected low byte of 3864 * dp->d_namlen is our dp->d_type. 3865 * The high MBZ byte of dp->d_namlen 3866 * is our dp->d_namlen. 3867 */ 3868 dp->d_type = dp->d_namlen; 3869 dp->d_namlen = 0; 3870 # else 3871 /* 3872 * The dp->d_type is the high byte 3873 * of the expected dp->d_namlen, 3874 * so must be zero'ed. 3875 */ 3876 dp->d_type = 0; 3877 # endif 3878 if (dp->d_reclen > 0) { 3879 dp = (struct dirent *) 3880 ((char *)dp + dp->d_reclen); 3881 } else { 3882 error = EIO; 3883 break; 3884 } 3885 } 3886 if (dp >= edp) 3887 error = uiomove(dirbuf, readcnt, &auio); 3888 } 3889 free(dirbuf, M_TEMP); 3890 } 3891 if (error != 0) { 3892 VOP_UNLOCK(vp, 0); 3893 foffset_unlock(fp, foffset, 0); 3894 fdrop(fp, td); 3895 return (error); 3896 } 3897 if (uap->count == auio.uio_resid && 3898 (vp->v_vflag & VV_ROOT) && 3899 (vp->v_mount->mnt_flag & MNT_UNION)) { 3900 struct vnode *tvp = vp; 3901 vp = vp->v_mount->mnt_vnodecovered; 3902 VREF(vp); 3903 fp->f_vnode = vp; 3904 fp->f_data = vp; 3905 foffset = 0; 3906 vput(tvp); 3907 goto unionread; 3908 } 3909 VOP_UNLOCK(vp, 0); 3910 foffset_unlock(fp, foffset, 0); 3911 fdrop(fp, td); 3912 td->td_retval[0] = uap->count - auio.uio_resid; 3913 if (error == 0) 3914 *ploff = loff; 3915 return (error); 3916 } 3917 #endif /* COMPAT_43 */ 3918 3919 /* 3920 * Read a block of directory entries in a filesystem independent format. 3921 */ 3922 #ifndef _SYS_SYSPROTO_H_ 3923 struct getdirentries_args { 3924 int fd; 3925 char *buf; 3926 u_int count; 3927 long *basep; 3928 }; 3929 #endif 3930 int 3931 sys_getdirentries(td, uap) 3932 struct thread *td; 3933 register struct getdirentries_args /* { 3934 int fd; 3935 char *buf; 3936 u_int count; 3937 long *basep; 3938 } */ *uap; 3939 { 3940 long base; 3941 int error; 3942 3943 error = kern_getdirentries(td, uap->fd, uap->buf, uap->count, &base, 3944 NULL, UIO_USERSPACE); 3945 if (error != 0) 3946 return (error); 3947 if (uap->basep != NULL) 3948 error = copyout(&base, uap->basep, sizeof(long)); 3949 return (error); 3950 } 3951 3952 int 3953 kern_getdirentries(struct thread *td, int fd, char *buf, u_int count, 3954 long *basep, ssize_t *residp, enum uio_seg bufseg) 3955 { 3956 struct vnode *vp; 3957 struct file *fp; 3958 struct uio auio; 3959 struct iovec aiov; 3960 cap_rights_t rights; 3961 long loff; 3962 int error, eofflag; 3963 off_t foffset; 3964 3965 AUDIT_ARG_FD(fd); 3966 if (count > IOSIZE_MAX) 3967 return (EINVAL); 3968 auio.uio_resid = count; 3969 error = getvnode(td, fd, cap_rights_init(&rights, CAP_READ), &fp); 3970 if (error != 0) 3971 return (error); 3972 if ((fp->f_flag & FREAD) == 0) { 3973 fdrop(fp, td); 3974 return (EBADF); 3975 } 3976 vp = fp->f_vnode; 3977 foffset = foffset_lock(fp, 0); 3978 unionread: 3979 if (vp->v_type != VDIR) { 3980 error = EINVAL; 3981 goto fail; 3982 } 3983 aiov.iov_base = buf; 3984 aiov.iov_len = count; 3985 auio.uio_iov = &aiov; 3986 auio.uio_iovcnt = 1; 3987 auio.uio_rw = UIO_READ; 3988 auio.uio_segflg = bufseg; 3989 auio.uio_td = td; 3990 vn_lock(vp, LK_SHARED | LK_RETRY); 3991 AUDIT_ARG_VNODE1(vp); 3992 loff = auio.uio_offset = foffset; 3993 #ifdef MAC 3994 error = mac_vnode_check_readdir(td->td_ucred, vp); 3995 if (error == 0) 3996 #endif 3997 error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag, NULL, 3998 NULL); 3999 foffset = auio.uio_offset; 4000 if (error != 0) { 4001 VOP_UNLOCK(vp, 0); 4002 goto fail; 4003 } 4004 if (count == auio.uio_resid && 4005 (vp->v_vflag & VV_ROOT) && 4006 (vp->v_mount->mnt_flag & MNT_UNION)) { 4007 struct vnode *tvp = vp; 4008 4009 vp = vp->v_mount->mnt_vnodecovered; 4010 VREF(vp); 4011 fp->f_vnode = vp; 4012 fp->f_data = vp; 4013 foffset = 0; 4014 vput(tvp); 4015 goto unionread; 4016 } 4017 VOP_UNLOCK(vp, 0); 4018 *basep = loff; 4019 if (residp != NULL) 4020 *residp = auio.uio_resid; 4021 td->td_retval[0] = count - auio.uio_resid; 4022 fail: 4023 foffset_unlock(fp, foffset, 0); 4024 fdrop(fp, td); 4025 return (error); 4026 } 4027 4028 #ifndef _SYS_SYSPROTO_H_ 4029 struct getdents_args { 4030 int fd; 4031 char *buf; 4032 size_t count; 4033 }; 4034 #endif 4035 int 4036 sys_getdents(td, uap) 4037 struct thread *td; 4038 register struct getdents_args /* { 4039 int fd; 4040 char *buf; 4041 u_int count; 4042 } */ *uap; 4043 { 4044 struct getdirentries_args ap; 4045 4046 ap.fd = uap->fd; 4047 ap.buf = uap->buf; 4048 ap.count = uap->count; 4049 ap.basep = NULL; 4050 return (sys_getdirentries(td, &ap)); 4051 } 4052 4053 /* 4054 * Set the mode mask for creation of filesystem nodes. 4055 */ 4056 #ifndef _SYS_SYSPROTO_H_ 4057 struct umask_args { 4058 int newmask; 4059 }; 4060 #endif 4061 int 4062 sys_umask(td, uap) 4063 struct thread *td; 4064 struct umask_args /* { 4065 int newmask; 4066 } */ *uap; 4067 { 4068 struct filedesc *fdp; 4069 4070 fdp = td->td_proc->p_fd; 4071 FILEDESC_XLOCK(fdp); 4072 td->td_retval[0] = fdp->fd_cmask; 4073 fdp->fd_cmask = uap->newmask & ALLPERMS; 4074 FILEDESC_XUNLOCK(fdp); 4075 return (0); 4076 } 4077 4078 /* 4079 * Void all references to file by ripping underlying filesystem away from 4080 * vnode. 4081 */ 4082 #ifndef _SYS_SYSPROTO_H_ 4083 struct revoke_args { 4084 char *path; 4085 }; 4086 #endif 4087 int 4088 sys_revoke(td, uap) 4089 struct thread *td; 4090 register struct revoke_args /* { 4091 char *path; 4092 } */ *uap; 4093 { 4094 struct vnode *vp; 4095 struct vattr vattr; 4096 struct nameidata nd; 4097 int error; 4098 4099 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | AUDITVNODE1, UIO_USERSPACE, 4100 uap->path, td); 4101 if ((error = namei(&nd)) != 0) 4102 return (error); 4103 vp = nd.ni_vp; 4104 NDFREE(&nd, NDF_ONLY_PNBUF); 4105 if (vp->v_type != VCHR || vp->v_rdev == NULL) { 4106 error = EINVAL; 4107 goto out; 4108 } 4109 #ifdef MAC 4110 error = mac_vnode_check_revoke(td->td_ucred, vp); 4111 if (error != 0) 4112 goto out; 4113 #endif 4114 error = VOP_GETATTR(vp, &vattr, td->td_ucred); 4115 if (error != 0) 4116 goto out; 4117 if (td->td_ucred->cr_uid != vattr.va_uid) { 4118 error = priv_check(td, PRIV_VFS_ADMIN); 4119 if (error != 0) 4120 goto out; 4121 } 4122 if (vcount(vp) > 1) 4123 VOP_REVOKE(vp, REVOKEALL); 4124 out: 4125 vput(vp); 4126 return (error); 4127 } 4128 4129 /* 4130 * Convert a user file descriptor to a kernel file entry and check that, if it 4131 * is a capability, the correct rights are present. A reference on the file 4132 * entry is held upon returning. 4133 */ 4134 int 4135 getvnode(struct thread *td, int fd, cap_rights_t *rightsp, struct file **fpp) 4136 { 4137 struct file *fp; 4138 int error; 4139 4140 error = fget_unlocked(td->td_proc->p_fd, fd, rightsp, &fp, NULL); 4141 if (error != 0) 4142 return (error); 4143 4144 /* 4145 * The file could be not of the vnode type, or it may be not 4146 * yet fully initialized, in which case the f_vnode pointer 4147 * may be set, but f_ops is still badfileops. E.g., 4148 * devfs_open() transiently create such situation to 4149 * facilitate csw d_fdopen(). 4150 * 4151 * Dupfdopen() handling in kern_openat() installs the 4152 * half-baked file into the process descriptor table, allowing 4153 * other thread to dereference it. Guard against the race by 4154 * checking f_ops. 4155 */ 4156 if (fp->f_vnode == NULL || fp->f_ops == &badfileops) { 4157 fdrop(fp, td); 4158 return (EINVAL); 4159 } 4160 *fpp = fp; 4161 return (0); 4162 } 4163 4164 4165 /* 4166 * Get an (NFS) file handle. 4167 */ 4168 #ifndef _SYS_SYSPROTO_H_ 4169 struct lgetfh_args { 4170 char *fname; 4171 fhandle_t *fhp; 4172 }; 4173 #endif 4174 int 4175 sys_lgetfh(td, uap) 4176 struct thread *td; 4177 register struct lgetfh_args *uap; 4178 { 4179 struct nameidata nd; 4180 fhandle_t fh; 4181 register struct vnode *vp; 4182 int error; 4183 4184 error = priv_check(td, PRIV_VFS_GETFH); 4185 if (error != 0) 4186 return (error); 4187 NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | AUDITVNODE1, UIO_USERSPACE, 4188 uap->fname, td); 4189 error = namei(&nd); 4190 if (error != 0) 4191 return (error); 4192 NDFREE(&nd, NDF_ONLY_PNBUF); 4193 vp = nd.ni_vp; 4194 bzero(&fh, sizeof(fh)); 4195 fh.fh_fsid = vp->v_mount->mnt_stat.f_fsid; 4196 error = VOP_VPTOFH(vp, &fh.fh_fid); 4197 vput(vp); 4198 if (error == 0) 4199 error = copyout(&fh, uap->fhp, sizeof (fh)); 4200 return (error); 4201 } 4202 4203 #ifndef _SYS_SYSPROTO_H_ 4204 struct getfh_args { 4205 char *fname; 4206 fhandle_t *fhp; 4207 }; 4208 #endif 4209 int 4210 sys_getfh(td, uap) 4211 struct thread *td; 4212 register struct getfh_args *uap; 4213 { 4214 struct nameidata nd; 4215 fhandle_t fh; 4216 register struct vnode *vp; 4217 int error; 4218 4219 error = priv_check(td, PRIV_VFS_GETFH); 4220 if (error != 0) 4221 return (error); 4222 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | AUDITVNODE1, UIO_USERSPACE, 4223 uap->fname, td); 4224 error = namei(&nd); 4225 if (error != 0) 4226 return (error); 4227 NDFREE(&nd, NDF_ONLY_PNBUF); 4228 vp = nd.ni_vp; 4229 bzero(&fh, sizeof(fh)); 4230 fh.fh_fsid = vp->v_mount->mnt_stat.f_fsid; 4231 error = VOP_VPTOFH(vp, &fh.fh_fid); 4232 vput(vp); 4233 if (error == 0) 4234 error = copyout(&fh, uap->fhp, sizeof (fh)); 4235 return (error); 4236 } 4237 4238 /* 4239 * syscall for the rpc.lockd to use to translate a NFS file handle into an 4240 * open descriptor. 4241 * 4242 * warning: do not remove the priv_check() call or this becomes one giant 4243 * security hole. 4244 */ 4245 #ifndef _SYS_SYSPROTO_H_ 4246 struct fhopen_args { 4247 const struct fhandle *u_fhp; 4248 int flags; 4249 }; 4250 #endif 4251 int 4252 sys_fhopen(td, uap) 4253 struct thread *td; 4254 struct fhopen_args /* { 4255 const struct fhandle *u_fhp; 4256 int flags; 4257 } */ *uap; 4258 { 4259 struct mount *mp; 4260 struct vnode *vp; 4261 struct fhandle fhp; 4262 struct file *fp; 4263 int fmode, error; 4264 int indx; 4265 4266 error = priv_check(td, PRIV_VFS_FHOPEN); 4267 if (error != 0) 4268 return (error); 4269 indx = -1; 4270 fmode = FFLAGS(uap->flags); 4271 /* why not allow a non-read/write open for our lockd? */ 4272 if (((fmode & (FREAD | FWRITE)) == 0) || (fmode & O_CREAT)) 4273 return (EINVAL); 4274 error = copyin(uap->u_fhp, &fhp, sizeof(fhp)); 4275 if (error != 0) 4276 return(error); 4277 /* find the mount point */ 4278 mp = vfs_busyfs(&fhp.fh_fsid); 4279 if (mp == NULL) 4280 return (ESTALE); 4281 /* now give me my vnode, it gets returned to me locked */ 4282 error = VFS_FHTOVP(mp, &fhp.fh_fid, LK_EXCLUSIVE, &vp); 4283 vfs_unbusy(mp); 4284 if (error != 0) 4285 return (error); 4286 4287 error = falloc_noinstall(td, &fp); 4288 if (error != 0) { 4289 vput(vp); 4290 return (error); 4291 } 4292 /* 4293 * An extra reference on `fp' has been held for us by 4294 * falloc_noinstall(). 4295 */ 4296 4297 #ifdef INVARIANTS 4298 td->td_dupfd = -1; 4299 #endif 4300 error = vn_open_vnode(vp, fmode, td->td_ucred, td, fp); 4301 if (error != 0) { 4302 KASSERT(fp->f_ops == &badfileops, 4303 ("VOP_OPEN in fhopen() set f_ops")); 4304 KASSERT(td->td_dupfd < 0, 4305 ("fhopen() encountered fdopen()")); 4306 4307 vput(vp); 4308 goto bad; 4309 } 4310 #ifdef INVARIANTS 4311 td->td_dupfd = 0; 4312 #endif 4313 fp->f_vnode = vp; 4314 fp->f_seqcount = 1; 4315 finit(fp, (fmode & FMASK) | (fp->f_flag & FHASLOCK), DTYPE_VNODE, vp, 4316 &vnops); 4317 VOP_UNLOCK(vp, 0); 4318 if ((fmode & O_TRUNC) != 0) { 4319 error = fo_truncate(fp, 0, td->td_ucred, td); 4320 if (error != 0) 4321 goto bad; 4322 } 4323 4324 error = finstall(td, fp, &indx, fmode, NULL); 4325 bad: 4326 fdrop(fp, td); 4327 td->td_retval[0] = indx; 4328 return (error); 4329 } 4330 4331 /* 4332 * Stat an (NFS) file handle. 4333 */ 4334 #ifndef _SYS_SYSPROTO_H_ 4335 struct fhstat_args { 4336 struct fhandle *u_fhp; 4337 struct stat *sb; 4338 }; 4339 #endif 4340 int 4341 sys_fhstat(td, uap) 4342 struct thread *td; 4343 register struct fhstat_args /* { 4344 struct fhandle *u_fhp; 4345 struct stat *sb; 4346 } */ *uap; 4347 { 4348 struct stat sb; 4349 struct fhandle fh; 4350 int error; 4351 4352 error = copyin(uap->u_fhp, &fh, sizeof(fh)); 4353 if (error != 0) 4354 return (error); 4355 error = kern_fhstat(td, fh, &sb); 4356 if (error == 0) 4357 error = copyout(&sb, uap->sb, sizeof(sb)); 4358 return (error); 4359 } 4360 4361 int 4362 kern_fhstat(struct thread *td, struct fhandle fh, struct stat *sb) 4363 { 4364 struct mount *mp; 4365 struct vnode *vp; 4366 int error; 4367 4368 error = priv_check(td, PRIV_VFS_FHSTAT); 4369 if (error != 0) 4370 return (error); 4371 if ((mp = vfs_busyfs(&fh.fh_fsid)) == NULL) 4372 return (ESTALE); 4373 error = VFS_FHTOVP(mp, &fh.fh_fid, LK_EXCLUSIVE, &vp); 4374 vfs_unbusy(mp); 4375 if (error != 0) 4376 return (error); 4377 error = vn_stat(vp, sb, td->td_ucred, NOCRED, td); 4378 vput(vp); 4379 return (error); 4380 } 4381 4382 /* 4383 * Implement fstatfs() for (NFS) file handles. 4384 */ 4385 #ifndef _SYS_SYSPROTO_H_ 4386 struct fhstatfs_args { 4387 struct fhandle *u_fhp; 4388 struct statfs *buf; 4389 }; 4390 #endif 4391 int 4392 sys_fhstatfs(td, uap) 4393 struct thread *td; 4394 struct fhstatfs_args /* { 4395 struct fhandle *u_fhp; 4396 struct statfs *buf; 4397 } */ *uap; 4398 { 4399 struct statfs sf; 4400 fhandle_t fh; 4401 int error; 4402 4403 error = copyin(uap->u_fhp, &fh, sizeof(fhandle_t)); 4404 if (error != 0) 4405 return (error); 4406 error = kern_fhstatfs(td, fh, &sf); 4407 if (error != 0) 4408 return (error); 4409 return (copyout(&sf, uap->buf, sizeof(sf))); 4410 } 4411 4412 int 4413 kern_fhstatfs(struct thread *td, fhandle_t fh, struct statfs *buf) 4414 { 4415 struct statfs *sp; 4416 struct mount *mp; 4417 struct vnode *vp; 4418 int error; 4419 4420 error = priv_check(td, PRIV_VFS_FHSTATFS); 4421 if (error != 0) 4422 return (error); 4423 if ((mp = vfs_busyfs(&fh.fh_fsid)) == NULL) 4424 return (ESTALE); 4425 error = VFS_FHTOVP(mp, &fh.fh_fid, LK_EXCLUSIVE, &vp); 4426 if (error != 0) { 4427 vfs_unbusy(mp); 4428 return (error); 4429 } 4430 vput(vp); 4431 error = prison_canseemount(td->td_ucred, mp); 4432 if (error != 0) 4433 goto out; 4434 #ifdef MAC 4435 error = mac_mount_check_stat(td->td_ucred, mp); 4436 if (error != 0) 4437 goto out; 4438 #endif 4439 /* 4440 * Set these in case the underlying filesystem fails to do so. 4441 */ 4442 sp = &mp->mnt_stat; 4443 sp->f_version = STATFS_VERSION; 4444 sp->f_namemax = NAME_MAX; 4445 sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; 4446 error = VFS_STATFS(mp, sp); 4447 if (error == 0) 4448 *buf = *sp; 4449 out: 4450 vfs_unbusy(mp); 4451 return (error); 4452 } 4453 4454 int 4455 kern_posix_fallocate(struct thread *td, int fd, off_t offset, off_t len) 4456 { 4457 struct file *fp; 4458 struct mount *mp; 4459 struct vnode *vp; 4460 cap_rights_t rights; 4461 off_t olen, ooffset; 4462 int error; 4463 4464 if (offset < 0 || len <= 0) 4465 return (EINVAL); 4466 /* Check for wrap. */ 4467 if (offset > OFF_MAX - len) 4468 return (EFBIG); 4469 error = fget(td, fd, cap_rights_init(&rights, CAP_WRITE), &fp); 4470 if (error != 0) 4471 return (error); 4472 if ((fp->f_ops->fo_flags & DFLAG_SEEKABLE) == 0) { 4473 error = ESPIPE; 4474 goto out; 4475 } 4476 if ((fp->f_flag & FWRITE) == 0) { 4477 error = EBADF; 4478 goto out; 4479 } 4480 if (fp->f_type != DTYPE_VNODE) { 4481 error = ENODEV; 4482 goto out; 4483 } 4484 vp = fp->f_vnode; 4485 if (vp->v_type != VREG) { 4486 error = ENODEV; 4487 goto out; 4488 } 4489 4490 /* Allocating blocks may take a long time, so iterate. */ 4491 for (;;) { 4492 olen = len; 4493 ooffset = offset; 4494 4495 bwillwrite(); 4496 mp = NULL; 4497 error = vn_start_write(vp, &mp, V_WAIT | PCATCH); 4498 if (error != 0) 4499 break; 4500 error = vn_lock(vp, LK_EXCLUSIVE); 4501 if (error != 0) { 4502 vn_finished_write(mp); 4503 break; 4504 } 4505 #ifdef MAC 4506 error = mac_vnode_check_write(td->td_ucred, fp->f_cred, vp); 4507 if (error == 0) 4508 #endif 4509 error = VOP_ALLOCATE(vp, &offset, &len); 4510 VOP_UNLOCK(vp, 0); 4511 vn_finished_write(mp); 4512 4513 if (olen + ooffset != offset + len) { 4514 panic("offset + len changed from %jx/%jx to %jx/%jx", 4515 ooffset, olen, offset, len); 4516 } 4517 if (error != 0 || len == 0) 4518 break; 4519 KASSERT(olen > len, ("Iteration did not make progress?")); 4520 maybe_yield(); 4521 } 4522 out: 4523 fdrop(fp, td); 4524 return (error); 4525 } 4526 4527 int 4528 sys_posix_fallocate(struct thread *td, struct posix_fallocate_args *uap) 4529 { 4530 4531 td->td_retval[0] = kern_posix_fallocate(td, uap->fd, uap->offset, 4532 uap->len); 4533 return (0); 4534 } 4535 4536 /* 4537 * Unlike madvise(2), we do not make a best effort to remember every 4538 * possible caching hint. Instead, we remember the last setting with 4539 * the exception that we will allow POSIX_FADV_NORMAL to adjust the 4540 * region of any current setting. 4541 */ 4542 int 4543 kern_posix_fadvise(struct thread *td, int fd, off_t offset, off_t len, 4544 int advice) 4545 { 4546 struct fadvise_info *fa, *new; 4547 struct file *fp; 4548 struct vnode *vp; 4549 cap_rights_t rights; 4550 off_t end; 4551 int error; 4552 4553 if (offset < 0 || len < 0 || offset > OFF_MAX - len) 4554 return (EINVAL); 4555 switch (advice) { 4556 case POSIX_FADV_SEQUENTIAL: 4557 case POSIX_FADV_RANDOM: 4558 case POSIX_FADV_NOREUSE: 4559 new = malloc(sizeof(*fa), M_FADVISE, M_WAITOK); 4560 break; 4561 case POSIX_FADV_NORMAL: 4562 case POSIX_FADV_WILLNEED: 4563 case POSIX_FADV_DONTNEED: 4564 new = NULL; 4565 break; 4566 default: 4567 return (EINVAL); 4568 } 4569 /* XXX: CAP_POSIX_FADVISE? */ 4570 error = fget(td, fd, cap_rights_init(&rights), &fp); 4571 if (error != 0) 4572 goto out; 4573 if ((fp->f_ops->fo_flags & DFLAG_SEEKABLE) == 0) { 4574 error = ESPIPE; 4575 goto out; 4576 } 4577 if (fp->f_type != DTYPE_VNODE) { 4578 error = ENODEV; 4579 goto out; 4580 } 4581 vp = fp->f_vnode; 4582 if (vp->v_type != VREG) { 4583 error = ENODEV; 4584 goto out; 4585 } 4586 if (len == 0) 4587 end = OFF_MAX; 4588 else 4589 end = offset + len - 1; 4590 switch (advice) { 4591 case POSIX_FADV_SEQUENTIAL: 4592 case POSIX_FADV_RANDOM: 4593 case POSIX_FADV_NOREUSE: 4594 /* 4595 * Try to merge any existing non-standard region with 4596 * this new region if possible, otherwise create a new 4597 * non-standard region for this request. 4598 */ 4599 mtx_pool_lock(mtxpool_sleep, fp); 4600 fa = fp->f_advice; 4601 if (fa != NULL && fa->fa_advice == advice && 4602 ((fa->fa_start <= end && fa->fa_end >= offset) || 4603 (end != OFF_MAX && fa->fa_start == end + 1) || 4604 (fa->fa_end != OFF_MAX && fa->fa_end + 1 == offset))) { 4605 if (offset < fa->fa_start) 4606 fa->fa_start = offset; 4607 if (end > fa->fa_end) 4608 fa->fa_end = end; 4609 } else { 4610 new->fa_advice = advice; 4611 new->fa_start = offset; 4612 new->fa_end = end; 4613 fp->f_advice = new; 4614 new = fa; 4615 } 4616 mtx_pool_unlock(mtxpool_sleep, fp); 4617 break; 4618 case POSIX_FADV_NORMAL: 4619 /* 4620 * If a the "normal" region overlaps with an existing 4621 * non-standard region, trim or remove the 4622 * non-standard region. 4623 */ 4624 mtx_pool_lock(mtxpool_sleep, fp); 4625 fa = fp->f_advice; 4626 if (fa != NULL) { 4627 if (offset <= fa->fa_start && end >= fa->fa_end) { 4628 new = fa; 4629 fp->f_advice = NULL; 4630 } else if (offset <= fa->fa_start && 4631 end >= fa->fa_start) 4632 fa->fa_start = end + 1; 4633 else if (offset <= fa->fa_end && end >= fa->fa_end) 4634 fa->fa_end = offset - 1; 4635 else if (offset >= fa->fa_start && end <= fa->fa_end) { 4636 /* 4637 * If the "normal" region is a middle 4638 * portion of the existing 4639 * non-standard region, just remove 4640 * the whole thing rather than picking 4641 * one side or the other to 4642 * preserve. 4643 */ 4644 new = fa; 4645 fp->f_advice = NULL; 4646 } 4647 } 4648 mtx_pool_unlock(mtxpool_sleep, fp); 4649 break; 4650 case POSIX_FADV_WILLNEED: 4651 case POSIX_FADV_DONTNEED: 4652 error = VOP_ADVISE(vp, offset, end, advice); 4653 break; 4654 } 4655 out: 4656 if (fp != NULL) 4657 fdrop(fp, td); 4658 free(new, M_FADVISE); 4659 return (error); 4660 } 4661 4662 int 4663 sys_posix_fadvise(struct thread *td, struct posix_fadvise_args *uap) 4664 { 4665 4666 td->td_retval[0] = kern_posix_fadvise(td, uap->fd, uap->offset, 4667 uap->len, uap->advice); 4668 return (0); 4669 } 4670