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