40 */ 41 42#include <sys/param.h> 43#include <sys/systm.h> 44#include <sys/fcntl.h> 45#include <sys/file.h> 46#include <sys/stat.h> 47#include <sys/proc.h> 48#include <sys/lock.h> 49#include <sys/mount.h> 50#include <sys/mutex.h> 51#include <sys/namei.h> 52#include <sys/vnode.h> 53#include <sys/bio.h> 54#include <sys/buf.h> 55#include <sys/filio.h> 56#include <sys/sx.h> 57#include <sys/ttycom.h> 58#include <sys/conf.h> 59#include <sys/syslog.h> 60 61#include <machine/limits.h> 62 63static int vn_closefile(struct file *fp, struct thread *td); 64static int vn_ioctl(struct file *fp, u_long com, void *data, 65 struct thread *td); 66static int vn_read(struct file *fp, struct uio *uio, 67 struct ucred *cred, int flags, struct thread *td); 68static int vn_poll(struct file *fp, int events, struct ucred *cred, 69 struct thread *td); 70static int vn_kqfilter(struct file *fp, struct knote *kn); 71static int vn_statfile(struct file *fp, struct stat *sb, struct thread *td); 72static int vn_write(struct file *fp, struct uio *uio, 73 struct ucred *cred, int flags, struct thread *td); 74 75struct fileops vnops = { 76 vn_read, vn_write, vn_ioctl, vn_poll, vn_kqfilter, 77 vn_statfile, vn_closefile 78}; 79 80int 81vn_open(ndp, flagp, cmode) 82 register struct nameidata *ndp; 83 int *flagp, cmode; 84{ 85 struct thread *td = ndp->ni_cnd.cn_thread; 86 87 return (vn_open_cred(ndp, flagp, cmode, td->td_ucred)); 88} 89 90/* 91 * Common code for vnode open operations. 92 * Check permissions, and call the VOP_OPEN or VOP_CREATE routine. 93 * 94 * Note that this does NOT free nameidata for the successful case, 95 * due to the NDINIT being done elsewhere. 96 */ 97int 98vn_open_cred(ndp, flagp, cmode, cred) 99 register struct nameidata *ndp; 100 int *flagp, cmode; 101 struct ucred *cred; 102{ 103 struct vnode *vp; 104 struct mount *mp; 105 struct thread *td = ndp->ni_cnd.cn_thread; 106 struct vattr vat; 107 struct vattr *vap = &vat; 108 int mode, fmode, error; 109#ifdef LOOKUP_SHARED 110 int exclusive; /* The current intended lock state */ 111 112 exclusive = 0; 113#endif 114 115restart: 116 fmode = *flagp; 117 if (fmode & O_CREAT) { 118 ndp->ni_cnd.cn_nameiop = CREATE; 119 ndp->ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF; 120 if ((fmode & O_EXCL) == 0 && (fmode & O_NOFOLLOW) == 0) 121 ndp->ni_cnd.cn_flags |= FOLLOW; 122 bwillwrite(); 123 if ((error = namei(ndp)) != 0) 124 return (error); 125 if (ndp->ni_vp == NULL) { 126 VATTR_NULL(vap); 127 vap->va_type = VREG; 128 vap->va_mode = cmode; 129 if (fmode & O_EXCL) 130 vap->va_vaflags |= VA_EXCLUSIVE; 131 if (vn_start_write(ndp->ni_dvp, &mp, V_NOWAIT) != 0) { 132 NDFREE(ndp, NDF_ONLY_PNBUF); 133 vput(ndp->ni_dvp); 134 if ((error = vn_start_write(NULL, &mp, 135 V_XSLEEP | PCATCH)) != 0) 136 return (error); 137 goto restart; 138 } 139 VOP_LEASE(ndp->ni_dvp, td, cred, LEASE_WRITE); 140 error = VOP_CREATE(ndp->ni_dvp, &ndp->ni_vp, 141 &ndp->ni_cnd, vap); 142 vput(ndp->ni_dvp); 143 vn_finished_write(mp); 144 if (error) { 145 NDFREE(ndp, NDF_ONLY_PNBUF); 146 return (error); 147 } 148 ASSERT_VOP_UNLOCKED(ndp->ni_dvp, "create"); 149 ASSERT_VOP_LOCKED(ndp->ni_vp, "create"); 150 fmode &= ~O_TRUNC; 151 vp = ndp->ni_vp; 152#ifdef LOOKUP_SHARED 153 exclusive = 1; 154#endif 155 } else { 156 if (ndp->ni_dvp == ndp->ni_vp) 157 vrele(ndp->ni_dvp); 158 else 159 vput(ndp->ni_dvp); 160 ndp->ni_dvp = NULL; 161 vp = ndp->ni_vp; 162 if (fmode & O_EXCL) { 163 error = EEXIST; 164 goto bad; 165 } 166 fmode &= ~O_CREAT; 167 } 168 } else { 169 ndp->ni_cnd.cn_nameiop = LOOKUP; 170#ifdef LOOKUP_SHARED 171 ndp->ni_cnd.cn_flags = 172 ((fmode & O_NOFOLLOW) ? NOFOLLOW : FOLLOW) | 173 LOCKSHARED | LOCKLEAF; 174#else 175 ndp->ni_cnd.cn_flags = 176 ((fmode & O_NOFOLLOW) ? NOFOLLOW : FOLLOW) | LOCKLEAF; 177#endif 178 if ((error = namei(ndp)) != 0) 179 return (error); 180 vp = ndp->ni_vp; 181 } 182 if (vp->v_type == VLNK) { 183 error = EMLINK; 184 goto bad; 185 } 186 if (vp->v_type == VSOCK) { 187 error = EOPNOTSUPP; 188 goto bad; 189 } 190 if ((fmode & O_CREAT) == 0) { 191 mode = 0; 192 if (fmode & (FWRITE | O_TRUNC)) { 193 if (vp->v_type == VDIR) { 194 error = EISDIR; 195 goto bad; 196 } 197 error = vn_writechk(vp); 198 if (error) 199 goto bad; 200 mode |= VWRITE; 201 } 202 if (fmode & FREAD) 203 mode |= VREAD; 204 if (mode) { 205 error = VOP_ACCESS(vp, mode, cred, td); 206 if (error) 207 goto bad; 208 } 209 } 210 if ((error = VOP_OPEN(vp, fmode, cred, td)) != 0) 211 goto bad; 212 /* 213 * Make sure that a VM object is created for VMIO support. 214 */ 215 if (vn_canvmio(vp) == TRUE) { 216#ifdef LOOKUP_SHARED 217 int flock; 218 219 if (!exclusive && VOP_GETVOBJECT(vp, NULL) != 0) 220 VOP_LOCK(vp, LK_UPGRADE, td); 221 /* 222 * In cases where the object is marked as dead object_create 223 * will unlock and relock exclusive. It is safe to call in 224 * here with a shared lock because we only examine fields that 225 * the shared lock guarantees will be stable. In the UPGRADE 226 * case it is not likely that anyone has used this vnode yet 227 * so there will be no contention. The logic after this call 228 * restores the requested locking state. 229 */ 230#endif 231 if ((error = vfs_object_create(vp, td, cred)) != 0) { 232 VOP_UNLOCK(vp, 0, td); 233 VOP_CLOSE(vp, fmode, cred, td); 234 NDFREE(ndp, NDF_ONLY_PNBUF); 235 vrele(vp); 236 *flagp = fmode; 237 return (error); 238 } 239#ifdef LOOKUP_SHARED 240 flock = VOP_ISLOCKED(vp, td); 241 if (!exclusive && flock == LK_EXCLUSIVE) 242 VOP_LOCK(vp, LK_DOWNGRADE, td); 243#endif 244 } 245 246 if (fmode & FWRITE) 247 vp->v_writecount++; 248 *flagp = fmode; 249 return (0); 250bad: 251 NDFREE(ndp, NDF_ONLY_PNBUF); 252 vput(vp); 253 *flagp = fmode; 254 return (error); 255} 256 257/* 258 * Check for write permissions on the specified vnode. 259 * Prototype text segments cannot be written. 260 */ 261int 262vn_writechk(vp) 263 register struct vnode *vp; 264{ 265 266 /* 267 * If there's shared text associated with 268 * the vnode, try to free it up once. If 269 * we fail, we can't allow writing. 270 */ 271 if (vp->v_flag & VTEXT) 272 return (ETXTBSY); 273 return (0); 274} 275 276/* 277 * Vnode close call 278 */ 279int 280vn_close(vp, flags, cred, td) 281 register struct vnode *vp; 282 int flags; 283 struct ucred *cred; 284 struct thread *td; 285{ 286 int error; 287 288 if (flags & FWRITE) 289 vp->v_writecount--; 290 error = VOP_CLOSE(vp, flags, cred, td); 291 /* 292 * XXX - In certain instances VOP_CLOSE has to do the vrele 293 * itself. If the vrele has been done, it will return EAGAIN 294 * to indicate that the vrele should not be done again. When 295 * this happens, we just return success. The correct thing to 296 * do would be to have all VOP_CLOSE instances do the vrele. 297 */ 298 if (error == EAGAIN) 299 return (0); 300 vrele(vp); 301 return (error); 302} 303 304/* 305 * Sequential heuristic - detect sequential operation 306 */ 307static __inline 308int 309sequential_heuristic(struct uio *uio, struct file *fp) 310{ 311 312 if ((uio->uio_offset == 0 && fp->f_seqcount > 0) || 313 uio->uio_offset == fp->f_nextoff) { 314 /* 315 * XXX we assume that the filesystem block size is 316 * the default. Not true, but still gives us a pretty 317 * good indicator of how sequential the read operations 318 * are. 319 */ 320 fp->f_seqcount += (uio->uio_resid + BKVASIZE - 1) / BKVASIZE; 321 if (fp->f_seqcount >= 127) 322 fp->f_seqcount = 127; 323 return(fp->f_seqcount << 16); 324 } 325 326 /* 327 * Not sequential, quick draw-down of seqcount 328 */ 329 if (fp->f_seqcount > 1) 330 fp->f_seqcount = 1; 331 else 332 fp->f_seqcount = 0; 333 return(0); 334} 335 336/* 337 * Package up an I/O request on a vnode into a uio and do it. 338 */ 339int 340vn_rdwr(rw, vp, base, len, offset, segflg, ioflg, cred, aresid, td) 341 enum uio_rw rw; 342 struct vnode *vp; 343 caddr_t base; 344 int len; 345 off_t offset; 346 enum uio_seg segflg; 347 int ioflg; 348 struct ucred *cred; 349 int *aresid; 350 struct thread *td; 351{ 352 struct uio auio; 353 struct iovec aiov; 354 struct mount *mp; 355 int error; 356 357 if ((ioflg & IO_NODELOCKED) == 0) { 358 mp = NULL; 359 if (rw == UIO_WRITE) { 360 if (vp->v_type != VCHR && 361 (error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) 362 != 0) 363 return (error); 364 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); 365 } else { 366 vn_lock(vp, LK_SHARED | LK_RETRY, td); 367 } 368 369 } 370 auio.uio_iov = &aiov; 371 auio.uio_iovcnt = 1; 372 aiov.iov_base = base; 373 aiov.iov_len = len; 374 auio.uio_resid = len; 375 auio.uio_offset = offset; 376 auio.uio_segflg = segflg; 377 auio.uio_rw = rw; 378 auio.uio_td = td; 379 if (rw == UIO_READ) { 380 error = VOP_READ(vp, &auio, ioflg, cred); 381 } else { 382 error = VOP_WRITE(vp, &auio, ioflg, cred); 383 } 384 if (aresid) 385 *aresid = auio.uio_resid; 386 else 387 if (auio.uio_resid && error == 0) 388 error = EIO; 389 if ((ioflg & IO_NODELOCKED) == 0) { 390 if (rw == UIO_WRITE) 391 vn_finished_write(mp); 392 VOP_UNLOCK(vp, 0, td); 393 } 394 return (error); 395} 396 397/* 398 * Package up an I/O request on a vnode into a uio and do it. The I/O 399 * request is split up into smaller chunks and we try to avoid saturating 400 * the buffer cache while potentially holding a vnode locked, so we 401 * check bwillwrite() before calling vn_rdwr(). We also call uio_yield() 402 * to give other processes a chance to lock the vnode (either other processes 403 * core'ing the same binary, or unrelated processes scanning the directory). 404 */ 405int 406vn_rdwr_inchunks(rw, vp, base, len, offset, segflg, ioflg, cred, aresid, td) 407 enum uio_rw rw; 408 struct vnode *vp; 409 caddr_t base; 410 int len; 411 off_t offset; 412 enum uio_seg segflg; 413 int ioflg; 414 struct ucred *cred; 415 int *aresid; 416 struct thread *td; 417{ 418 int error = 0; 419 420 do { 421 int chunk = (len > MAXBSIZE) ? MAXBSIZE : len; 422 423 if (rw != UIO_READ && vp->v_type == VREG) 424 bwillwrite(); 425 error = vn_rdwr(rw, vp, base, chunk, offset, segflg, 426 ioflg, cred, aresid, td); 427 len -= chunk; /* aresid calc already includes length */ 428 if (error) 429 break; 430 offset += chunk; 431 base += chunk; 432 uio_yield(); 433 } while (len); 434 if (aresid) 435 *aresid += len; 436 return (error); 437} 438 439/* 440 * File table vnode read routine. 441 */ 442static int 443vn_read(fp, uio, cred, flags, td) 444 struct file *fp; 445 struct uio *uio; 446 struct ucred *cred; 447 struct thread *td; 448 int flags; 449{ 450 struct vnode *vp; 451 int error, ioflag; 452 453 mtx_lock(&Giant); 454 KASSERT(uio->uio_td == td, ("uio_td %p is not td %p", 455 uio->uio_td, td)); 456 vp = (struct vnode *)fp->f_data; 457 ioflag = 0; 458 if (fp->f_flag & FNONBLOCK) 459 ioflag |= IO_NDELAY; 460 if (fp->f_flag & O_DIRECT) 461 ioflag |= IO_DIRECT; 462 VOP_LEASE(vp, td, cred, LEASE_READ); 463 vn_lock(vp, LK_SHARED | LK_NOPAUSE | LK_RETRY, td); 464 if ((flags & FOF_OFFSET) == 0) 465 uio->uio_offset = fp->f_offset; 466 467 ioflag |= sequential_heuristic(uio, fp); 468 469 error = VOP_READ(vp, uio, ioflag, cred); 470 if ((flags & FOF_OFFSET) == 0) 471 fp->f_offset = uio->uio_offset; 472 fp->f_nextoff = uio->uio_offset; 473 VOP_UNLOCK(vp, 0, td); 474 mtx_unlock(&Giant); 475 return (error); 476} 477 478/* 479 * File table vnode write routine. 480 */ 481static int 482vn_write(fp, uio, cred, flags, td) 483 struct file *fp; 484 struct uio *uio; 485 struct ucred *cred; 486 struct thread *td; 487 int flags; 488{ 489 struct vnode *vp; 490 struct mount *mp; 491 int error, ioflag; 492 493 mtx_lock(&Giant); 494 KASSERT(uio->uio_td == td, ("uio_td %p is not td %p", 495 uio->uio_td, td)); 496 vp = (struct vnode *)fp->f_data; 497 if (vp->v_type == VREG) 498 bwillwrite(); 499 ioflag = IO_UNIT; 500 if (vp->v_type == VREG && (fp->f_flag & O_APPEND)) 501 ioflag |= IO_APPEND; 502 if (fp->f_flag & FNONBLOCK) 503 ioflag |= IO_NDELAY; 504 if (fp->f_flag & O_DIRECT) 505 ioflag |= IO_DIRECT; 506 if ((fp->f_flag & O_FSYNC) || 507 (vp->v_mount && (vp->v_mount->mnt_flag & MNT_SYNCHRONOUS))) 508 ioflag |= IO_SYNC; 509 mp = NULL; 510 if (vp->v_type != VCHR && 511 (error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) { 512 mtx_unlock(&Giant); 513 return (error); 514 } 515 VOP_LEASE(vp, td, cred, LEASE_WRITE); 516 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); 517 if ((flags & FOF_OFFSET) == 0) 518 uio->uio_offset = fp->f_offset; 519 ioflag |= sequential_heuristic(uio, fp); 520 error = VOP_WRITE(vp, uio, ioflag, cred); 521 if ((flags & FOF_OFFSET) == 0) 522 fp->f_offset = uio->uio_offset; 523 fp->f_nextoff = uio->uio_offset; 524 VOP_UNLOCK(vp, 0, td); 525 vn_finished_write(mp); 526 mtx_unlock(&Giant); 527 return (error); 528} 529 530/* 531 * File table vnode stat routine. 532 */ 533static int 534vn_statfile(fp, sb, td) 535 struct file *fp; 536 struct stat *sb; 537 struct thread *td; 538{ 539 struct vnode *vp = (struct vnode *)fp->f_data; 540 int error; 541 542 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); 543 error = vn_stat(vp, sb, td); 544 VOP_UNLOCK(vp, 0, td); 545 546 return (error); 547} 548 549/* 550 * Stat a vnode; implementation for the stat syscall 551 */ 552int 553vn_stat(vp, sb, td) 554 struct vnode *vp; 555 register struct stat *sb; 556 struct thread *td; 557{ 558 struct vattr vattr; 559 register struct vattr *vap; 560 int error; 561 u_short mode; 562 563 vap = &vattr; 564 error = VOP_GETATTR(vp, vap, td->td_ucred, td); 565 if (error) 566 return (error); 567 568 /* 569 * Zero the spare stat fields 570 */ 571 bzero(sb, sizeof *sb); 572 573 /* 574 * Copy from vattr table 575 */ 576 if (vap->va_fsid != VNOVAL) 577 sb->st_dev = vap->va_fsid; 578 else 579 sb->st_dev = vp->v_mount->mnt_stat.f_fsid.val[0]; 580 sb->st_ino = vap->va_fileid; 581 mode = vap->va_mode; 582 switch (vap->va_type) { 583 case VREG: 584 mode |= S_IFREG; 585 break; 586 case VDIR: 587 mode |= S_IFDIR; 588 break; 589 case VBLK: 590 mode |= S_IFBLK; 591 break; 592 case VCHR: 593 mode |= S_IFCHR; 594 break; 595 case VLNK: 596 mode |= S_IFLNK; 597 /* This is a cosmetic change, symlinks do not have a mode. */ 598 if (vp->v_mount->mnt_flag & MNT_NOSYMFOLLOW) 599 sb->st_mode &= ~ACCESSPERMS; /* 0000 */ 600 else 601 sb->st_mode |= ACCESSPERMS; /* 0777 */ 602 break; 603 case VSOCK: 604 mode |= S_IFSOCK; 605 break; 606 case VFIFO: 607 mode |= S_IFIFO; 608 break; 609 default: 610 return (EBADF); 611 }; 612 sb->st_mode = mode; 613 sb->st_nlink = vap->va_nlink; 614 sb->st_uid = vap->va_uid; 615 sb->st_gid = vap->va_gid; 616 sb->st_rdev = vap->va_rdev; 617 if (vap->va_size > OFF_MAX) 618 return (EOVERFLOW); 619 sb->st_size = vap->va_size; 620 sb->st_atimespec = vap->va_atime; 621 sb->st_mtimespec = vap->va_mtime; 622 sb->st_ctimespec = vap->va_ctime;
|
624 625 /* 626 * According to www.opengroup.org, the meaning of st_blksize is 627 * "a filesystem-specific preferred I/O block size for this 628 * object. In some filesystem types, this may vary from file 629 * to file" 630 * Default to PAGE_SIZE after much discussion. 631 */ 632 633 if (vap->va_type == VREG) { 634 sb->st_blksize = vap->va_blocksize; 635 } else if (vn_isdisk(vp, NULL)) { 636 sb->st_blksize = vp->v_rdev->si_bsize_best; 637 if (sb->st_blksize < vp->v_rdev->si_bsize_phys) 638 sb->st_blksize = vp->v_rdev->si_bsize_phys; 639 if (sb->st_blksize < BLKDEV_IOSIZE) 640 sb->st_blksize = BLKDEV_IOSIZE; 641 } else { 642 sb->st_blksize = PAGE_SIZE; 643 } 644 645 sb->st_flags = vap->va_flags; 646 if (suser(td)) 647 sb->st_gen = 0; 648 else 649 sb->st_gen = vap->va_gen; 650 651#if (S_BLKSIZE == 512) 652 /* Optimize this case */ 653 sb->st_blocks = vap->va_bytes >> 9; 654#else 655 sb->st_blocks = vap->va_bytes / S_BLKSIZE; 656#endif 657 return (0); 658} 659 660/* 661 * File table vnode ioctl routine. 662 */ 663static int 664vn_ioctl(fp, com, data, td) 665 struct file *fp; 666 u_long com; 667 void *data; 668 struct thread *td; 669{ 670 register struct vnode *vp = ((struct vnode *)fp->f_data); 671 struct vnode *vpold; 672 struct vattr vattr; 673 int error; 674 675 switch (vp->v_type) { 676 677 case VREG: 678 case VDIR: 679 if (com == FIONREAD) { 680 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); 681 error = VOP_GETATTR(vp, &vattr, td->td_ucred, td); 682 VOP_UNLOCK(vp, 0, td); 683 if (error) 684 return (error); 685 *(int *)data = vattr.va_size - fp->f_offset; 686 return (0); 687 } 688 if (com == FIONBIO || com == FIOASYNC) /* XXX */ 689 return (0); /* XXX */ 690 /* fall into ... */ 691 692 default: 693#if 0 694 return (ENOTTY); 695#endif 696 case VFIFO: 697 case VCHR: 698 case VBLK: 699 if (com == FIODTYPE) { 700 if (vp->v_type != VCHR && vp->v_type != VBLK) 701 return (ENOTTY); 702 *(int *)data = devsw(vp->v_rdev)->d_flags & D_TYPEMASK; 703 return (0); 704 } 705 error = VOP_IOCTL(vp, com, data, fp->f_flag, td->td_ucred, td); 706 if (error == 0 && com == TIOCSCTTY) { 707 708 /* Do nothing if reassigning same control tty */ 709 sx_slock(&proctree_lock); 710 if (td->td_proc->p_session->s_ttyvp == vp) { 711 sx_sunlock(&proctree_lock); 712 return (0); 713 } 714 715 vpold = td->td_proc->p_session->s_ttyvp; 716 VREF(vp); 717 SESS_LOCK(td->td_proc->p_session); 718 td->td_proc->p_session->s_ttyvp = vp; 719 SESS_UNLOCK(td->td_proc->p_session); 720 721 sx_sunlock(&proctree_lock); 722 723 /* Get rid of reference to old control tty */ 724 if (vpold) 725 vrele(vpold); 726 } 727 return (error); 728 } 729} 730 731/* 732 * File table vnode poll routine. 733 */ 734static int 735vn_poll(fp, events, cred, td) 736 struct file *fp; 737 int events; 738 struct ucred *cred; 739 struct thread *td; 740{ 741 742 return (VOP_POLL(((struct vnode *)fp->f_data), events, cred, td)); 743} 744 745/* 746 * Check that the vnode is still valid, and if so 747 * acquire requested lock. 748 */ 749int 750#ifndef DEBUG_LOCKS 751vn_lock(vp, flags, td) 752#else 753debug_vn_lock(vp, flags, td, filename, line) 754#endif 755 struct vnode *vp; 756 int flags; 757 struct thread *td; 758#ifdef DEBUG_LOCKS 759 const char *filename; 760 int line; 761#endif 762{ 763 int error; 764 765 do { 766 if ((flags & LK_INTERLOCK) == 0) 767 mtx_lock(&vp->v_interlock); 768 if ((vp->v_flag & VXLOCK) && vp->v_vxproc != curthread) { 769 vp->v_flag |= VXWANT; 770 msleep(vp, &vp->v_interlock, PINOD | PDROP, 771 "vn_lock", 0); 772 error = ENOENT; 773 } else { 774#if 0 775 /* this can now occur in normal operation */ 776 if (vp->v_vxproc != NULL) 777 log(LOG_INFO, "VXLOCK interlock avoided in vn_lock\n"); 778#endif 779#ifdef DEBUG_LOCKS 780 vp->filename = filename; 781 vp->line = line; 782#endif 783 error = VOP_LOCK(vp, 784 flags | LK_NOPAUSE | LK_INTERLOCK, td); 785 if (error == 0) 786 return (error); 787 } 788 flags &= ~LK_INTERLOCK; 789 } while (flags & LK_RETRY); 790 return (error); 791} 792 793/* 794 * File table vnode close routine. 795 */ 796static int 797vn_closefile(fp, td) 798 struct file *fp; 799 struct thread *td; 800{ 801 802 fp->f_ops = &badfileops; 803 return (vn_close(((struct vnode *)fp->f_data), fp->f_flag, 804 fp->f_cred, td)); 805} 806 807/* 808 * Preparing to start a filesystem write operation. If the operation is 809 * permitted, then we bump the count of operations in progress and 810 * proceed. If a suspend request is in progress, we wait until the 811 * suspension is over, and then proceed. 812 */ 813int 814vn_start_write(vp, mpp, flags) 815 struct vnode *vp; 816 struct mount **mpp; 817 int flags; 818{ 819 struct mount *mp; 820 int error; 821 822 /* 823 * If a vnode is provided, get and return the mount point that 824 * to which it will write. 825 */ 826 if (vp != NULL) { 827 if ((error = VOP_GETWRITEMOUNT(vp, mpp)) != 0) { 828 *mpp = NULL; 829 if (error != EOPNOTSUPP) 830 return (error); 831 return (0); 832 } 833 } 834 if ((mp = *mpp) == NULL) 835 return (0); 836 /* 837 * Check on status of suspension. 838 */ 839 while ((mp->mnt_kern_flag & MNTK_SUSPEND) != 0) { 840 if (flags & V_NOWAIT) 841 return (EWOULDBLOCK); 842 error = tsleep(&mp->mnt_flag, (PUSER - 1) | (flags & PCATCH), 843 "suspfs", 0); 844 if (error) 845 return (error); 846 } 847 if (flags & V_XSLEEP) 848 return (0); 849 mp->mnt_writeopcount++; 850 return (0); 851} 852 853/* 854 * Secondary suspension. Used by operations such as vop_inactive 855 * routines that are needed by the higher level functions. These 856 * are allowed to proceed until all the higher level functions have 857 * completed (indicated by mnt_writeopcount dropping to zero). At that 858 * time, these operations are halted until the suspension is over. 859 */ 860int 861vn_write_suspend_wait(vp, mp, flags) 862 struct vnode *vp; 863 struct mount *mp; 864 int flags; 865{ 866 int error; 867 868 if (vp != NULL) { 869 if ((error = VOP_GETWRITEMOUNT(vp, &mp)) != 0) { 870 if (error != EOPNOTSUPP) 871 return (error); 872 return (0); 873 } 874 } 875 /* 876 * If we are not suspended or have not yet reached suspended 877 * mode, then let the operation proceed. 878 */ 879 if (mp == NULL || (mp->mnt_kern_flag & MNTK_SUSPENDED) == 0) 880 return (0); 881 if (flags & V_NOWAIT) 882 return (EWOULDBLOCK); 883 /* 884 * Wait for the suspension to finish. 885 */ 886 return (tsleep(&mp->mnt_flag, (PUSER - 1) | (flags & PCATCH), 887 "suspfs", 0)); 888} 889 890/* 891 * Filesystem write operation has completed. If we are suspending and this 892 * operation is the last one, notify the suspender that the suspension is 893 * now in effect. 894 */ 895void 896vn_finished_write(mp) 897 struct mount *mp; 898{ 899 900 if (mp == NULL) 901 return; 902 mp->mnt_writeopcount--; 903 if (mp->mnt_writeopcount < 0) 904 panic("vn_finished_write: neg cnt"); 905 if ((mp->mnt_kern_flag & MNTK_SUSPEND) != 0 && 906 mp->mnt_writeopcount <= 0) 907 wakeup(&mp->mnt_writeopcount); 908} 909 910/* 911 * Request a filesystem to suspend write operations. 912 */ 913void 914vfs_write_suspend(mp) 915 struct mount *mp; 916{ 917 struct thread *td = curthread; 918 919 if (mp->mnt_kern_flag & MNTK_SUSPEND) 920 return; 921 mp->mnt_kern_flag |= MNTK_SUSPEND; 922 if (mp->mnt_writeopcount > 0) 923 (void) tsleep(&mp->mnt_writeopcount, PUSER - 1, "suspwt", 0); 924 VFS_SYNC(mp, MNT_WAIT, td->td_ucred, td); 925 mp->mnt_kern_flag |= MNTK_SUSPENDED; 926} 927 928/* 929 * Request a filesystem to resume write operations. 930 */ 931void 932vfs_write_resume(mp) 933 struct mount *mp; 934{ 935 936 if ((mp->mnt_kern_flag & MNTK_SUSPEND) == 0) 937 return; 938 mp->mnt_kern_flag &= ~(MNTK_SUSPEND | MNTK_SUSPENDED); 939 wakeup(&mp->mnt_writeopcount); 940 wakeup(&mp->mnt_flag); 941} 942 943/* 944 * Implement kqueues for files by translating it to vnode operation. 945 */ 946static int 947vn_kqfilter(struct file *fp, struct knote *kn) 948{ 949 950 return (VOP_KQFILTER(((struct vnode *)fp->f_data), kn)); 951} 952 953/* 954 * Simplified in-kernel wrapper calls for extended attribute access. 955 * Both calls pass in a NULL credential, authorizing as "kernel" access. 956 * Set IO_NODELOCKED in ioflg if the vnode is already locked. 957 */ 958int 959vn_extattr_get(struct vnode *vp, int ioflg, int attrnamespace, 960 const char *attrname, int *buflen, char *buf, struct thread *td) 961{ 962 struct uio auio; 963 struct iovec iov; 964 int error; 965 966 iov.iov_len = *buflen; 967 iov.iov_base = buf; 968 969 auio.uio_iov = &iov; 970 auio.uio_iovcnt = 1; 971 auio.uio_rw = UIO_READ; 972 auio.uio_segflg = UIO_SYSSPACE; 973 auio.uio_td = td; 974 auio.uio_offset = 0; 975 auio.uio_resid = *buflen; 976 977 if ((ioflg & IO_NODELOCKED) == 0) 978 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); 979 980 /* authorize attribute retrieval as kernel */ 981 error = VOP_GETEXTATTR(vp, attrnamespace, attrname, &auio, NULL, NULL, 982 td); 983 984 if ((ioflg & IO_NODELOCKED) == 0) 985 VOP_UNLOCK(vp, 0, td); 986 987 if (error == 0) { 988 *buflen = *buflen - auio.uio_resid; 989 } 990 991 return (error); 992} 993 994/* 995 * XXX failure mode if partially written? 996 */ 997int 998vn_extattr_set(struct vnode *vp, int ioflg, int attrnamespace, 999 const char *attrname, int buflen, char *buf, struct thread *td) 1000{ 1001 struct uio auio; 1002 struct iovec iov; 1003 struct mount *mp; 1004 int error; 1005 1006 iov.iov_len = buflen; 1007 iov.iov_base = buf; 1008 1009 auio.uio_iov = &iov; 1010 auio.uio_iovcnt = 1; 1011 auio.uio_rw = UIO_WRITE; 1012 auio.uio_segflg = UIO_SYSSPACE; 1013 auio.uio_td = td; 1014 auio.uio_offset = 0; 1015 auio.uio_resid = buflen; 1016 1017 if ((ioflg & IO_NODELOCKED) == 0) { 1018 if ((error = vn_start_write(vp, &mp, V_WAIT)) != 0) 1019 return (error); 1020 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); 1021 } 1022 1023 /* authorize attribute setting as kernel */ 1024 error = VOP_SETEXTATTR(vp, attrnamespace, attrname, &auio, NULL, td); 1025 1026 if ((ioflg & IO_NODELOCKED) == 0) { 1027 vn_finished_write(mp); 1028 VOP_UNLOCK(vp, 0, td); 1029 } 1030 1031 return (error); 1032} 1033 1034int 1035vn_extattr_rm(struct vnode *vp, int ioflg, int attrnamespace, 1036 const char *attrname, struct thread *td) 1037{ 1038 struct mount *mp; 1039 int error; 1040 1041 if ((ioflg & IO_NODELOCKED) == 0) { 1042 if ((error = vn_start_write(vp, &mp, V_WAIT)) != 0) 1043 return (error); 1044 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); 1045 } 1046 1047 /* authorize attribute removal as kernel */ 1048 error = VOP_SETEXTATTR(vp, attrnamespace, attrname, NULL, NULL, td); 1049 1050 if ((ioflg & IO_NODELOCKED) == 0) { 1051 vn_finished_write(mp); 1052 VOP_UNLOCK(vp, 0, td); 1053 } 1054 1055 return (error); 1056}
|