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