vfs_vnops.c revision 267816
1/*- 2 * Copyright (c) 1982, 1986, 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 * Copyright (c) 2012 Konstantin Belousov <kib@FreeBSD.org> 11 * Copyright (c) 2013 The FreeBSD Foundation 12 * 13 * Portions of this software were developed by Konstantin Belousov 14 * under sponsorship from the FreeBSD Foundation. 15 * 16 * Redistribution and use in source and binary forms, with or without 17 * modification, are permitted provided that the following conditions 18 * are met: 19 * 1. Redistributions of source code must retain the above copyright 20 * notice, this list of conditions and the following disclaimer. 21 * 2. Redistributions in binary form must reproduce the above copyright 22 * notice, this list of conditions and the following disclaimer in the 23 * documentation and/or other materials provided with the distribution. 24 * 4. Neither the name of the University nor the names of its contributors 25 * may be used to endorse or promote products derived from this software 26 * without specific prior written permission. 27 * 28 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 29 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 30 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 31 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 32 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 33 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 34 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 35 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 36 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 37 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 38 * SUCH DAMAGE. 39 * 40 * @(#)vfs_vnops.c 8.2 (Berkeley) 1/21/94 41 */ 42 43#include <sys/cdefs.h> 44__FBSDID("$FreeBSD: stable/10/sys/kern/vfs_vnops.c 267816 2014-06-24 08:21:43Z kib $"); 45 46#include <sys/param.h> 47#include <sys/systm.h> 48#include <sys/disk.h> 49#include <sys/fcntl.h> 50#include <sys/file.h> 51#include <sys/kdb.h> 52#include <sys/stat.h> 53#include <sys/priv.h> 54#include <sys/proc.h> 55#include <sys/limits.h> 56#include <sys/lock.h> 57#include <sys/mount.h> 58#include <sys/mutex.h> 59#include <sys/namei.h> 60#include <sys/vnode.h> 61#include <sys/bio.h> 62#include <sys/buf.h> 63#include <sys/filio.h> 64#include <sys/resourcevar.h> 65#include <sys/rwlock.h> 66#include <sys/sx.h> 67#include <sys/sysctl.h> 68#include <sys/ttycom.h> 69#include <sys/conf.h> 70#include <sys/syslog.h> 71#include <sys/unistd.h> 72 73#include <security/audit/audit.h> 74#include <security/mac/mac_framework.h> 75 76#include <vm/vm.h> 77#include <vm/vm_extern.h> 78#include <vm/pmap.h> 79#include <vm/vm_map.h> 80#include <vm/vm_object.h> 81#include <vm/vm_page.h> 82 83static fo_rdwr_t vn_read; 84static fo_rdwr_t vn_write; 85static fo_rdwr_t vn_io_fault; 86static fo_truncate_t vn_truncate; 87static fo_ioctl_t vn_ioctl; 88static fo_poll_t vn_poll; 89static fo_kqfilter_t vn_kqfilter; 90static fo_stat_t vn_statfile; 91static fo_close_t vn_closefile; 92 93struct fileops vnops = { 94 .fo_read = vn_io_fault, 95 .fo_write = vn_io_fault, 96 .fo_truncate = vn_truncate, 97 .fo_ioctl = vn_ioctl, 98 .fo_poll = vn_poll, 99 .fo_kqfilter = vn_kqfilter, 100 .fo_stat = vn_statfile, 101 .fo_close = vn_closefile, 102 .fo_chmod = vn_chmod, 103 .fo_chown = vn_chown, 104 .fo_sendfile = vn_sendfile, 105 .fo_seek = vn_seek, 106 .fo_flags = DFLAG_PASSABLE | DFLAG_SEEKABLE 107}; 108 109int 110vn_open(ndp, flagp, cmode, fp) 111 struct nameidata *ndp; 112 int *flagp, cmode; 113 struct file *fp; 114{ 115 struct thread *td = ndp->ni_cnd.cn_thread; 116 117 return (vn_open_cred(ndp, flagp, cmode, 0, td->td_ucred, fp)); 118} 119 120/* 121 * Common code for vnode open operations via a name lookup. 122 * Lookup the vnode and invoke VOP_CREATE if needed. 123 * Check permissions, and call the VOP_OPEN or VOP_CREATE routine. 124 * 125 * Note that this does NOT free nameidata for the successful case, 126 * due to the NDINIT being done elsewhere. 127 */ 128int 129vn_open_cred(struct nameidata *ndp, int *flagp, int cmode, u_int vn_open_flags, 130 struct ucred *cred, struct file *fp) 131{ 132 struct vnode *vp; 133 struct mount *mp; 134 struct thread *td = ndp->ni_cnd.cn_thread; 135 struct vattr vat; 136 struct vattr *vap = &vat; 137 int fmode, error; 138 139restart: 140 fmode = *flagp; 141 if (fmode & O_CREAT) { 142 ndp->ni_cnd.cn_nameiop = CREATE; 143 ndp->ni_cnd.cn_flags = ISOPEN | LOCKPARENT | LOCKLEAF; 144 if ((fmode & O_EXCL) == 0 && (fmode & O_NOFOLLOW) == 0) 145 ndp->ni_cnd.cn_flags |= FOLLOW; 146 if (!(vn_open_flags & VN_OPEN_NOAUDIT)) 147 ndp->ni_cnd.cn_flags |= AUDITVNODE1; 148 if (vn_open_flags & VN_OPEN_NOCAPCHECK) 149 ndp->ni_cnd.cn_flags |= NOCAPCHECK; 150 bwillwrite(); 151 if ((error = namei(ndp)) != 0) 152 return (error); 153 if (ndp->ni_vp == NULL) { 154 VATTR_NULL(vap); 155 vap->va_type = VREG; 156 vap->va_mode = cmode; 157 if (fmode & O_EXCL) 158 vap->va_vaflags |= VA_EXCLUSIVE; 159 if (vn_start_write(ndp->ni_dvp, &mp, V_NOWAIT) != 0) { 160 NDFREE(ndp, NDF_ONLY_PNBUF); 161 vput(ndp->ni_dvp); 162 if ((error = vn_start_write(NULL, &mp, 163 V_XSLEEP | PCATCH)) != 0) 164 return (error); 165 goto restart; 166 } 167#ifdef MAC 168 error = mac_vnode_check_create(cred, ndp->ni_dvp, 169 &ndp->ni_cnd, vap); 170 if (error == 0) 171#endif 172 error = VOP_CREATE(ndp->ni_dvp, &ndp->ni_vp, 173 &ndp->ni_cnd, vap); 174 vput(ndp->ni_dvp); 175 vn_finished_write(mp); 176 if (error) { 177 NDFREE(ndp, NDF_ONLY_PNBUF); 178 return (error); 179 } 180 fmode &= ~O_TRUNC; 181 vp = ndp->ni_vp; 182 } else { 183 if (ndp->ni_dvp == ndp->ni_vp) 184 vrele(ndp->ni_dvp); 185 else 186 vput(ndp->ni_dvp); 187 ndp->ni_dvp = NULL; 188 vp = ndp->ni_vp; 189 if (fmode & O_EXCL) { 190 error = EEXIST; 191 goto bad; 192 } 193 fmode &= ~O_CREAT; 194 } 195 } else { 196 ndp->ni_cnd.cn_nameiop = LOOKUP; 197 ndp->ni_cnd.cn_flags = ISOPEN | 198 ((fmode & O_NOFOLLOW) ? NOFOLLOW : FOLLOW) | LOCKLEAF; 199 if (!(fmode & FWRITE)) 200 ndp->ni_cnd.cn_flags |= LOCKSHARED; 201 if (!(vn_open_flags & VN_OPEN_NOAUDIT)) 202 ndp->ni_cnd.cn_flags |= AUDITVNODE1; 203 if (vn_open_flags & VN_OPEN_NOCAPCHECK) 204 ndp->ni_cnd.cn_flags |= NOCAPCHECK; 205 if ((error = namei(ndp)) != 0) 206 return (error); 207 vp = ndp->ni_vp; 208 } 209 error = vn_open_vnode(vp, fmode, cred, td, fp); 210 if (error) 211 goto bad; 212 *flagp = fmode; 213 return (0); 214bad: 215 NDFREE(ndp, NDF_ONLY_PNBUF); 216 vput(vp); 217 *flagp = fmode; 218 ndp->ni_vp = NULL; 219 return (error); 220} 221 222/* 223 * Common code for vnode open operations once a vnode is located. 224 * Check permissions, and call the VOP_OPEN routine. 225 */ 226int 227vn_open_vnode(struct vnode *vp, int fmode, struct ucred *cred, 228 struct thread *td, struct file *fp) 229{ 230 struct mount *mp; 231 accmode_t accmode; 232 struct flock lf; 233 int error, have_flock, lock_flags, type; 234 235 if (vp->v_type == VLNK) 236 return (EMLINK); 237 if (vp->v_type == VSOCK) 238 return (EOPNOTSUPP); 239 if (vp->v_type != VDIR && fmode & O_DIRECTORY) 240 return (ENOTDIR); 241 accmode = 0; 242 if (fmode & (FWRITE | O_TRUNC)) { 243 if (vp->v_type == VDIR) 244 return (EISDIR); 245 accmode |= VWRITE; 246 } 247 if (fmode & FREAD) 248 accmode |= VREAD; 249 if (fmode & FEXEC) 250 accmode |= VEXEC; 251 if ((fmode & O_APPEND) && (fmode & FWRITE)) 252 accmode |= VAPPEND; 253#ifdef MAC 254 error = mac_vnode_check_open(cred, vp, accmode); 255 if (error) 256 return (error); 257#endif 258 if ((fmode & O_CREAT) == 0) { 259 if (accmode & VWRITE) { 260 error = vn_writechk(vp); 261 if (error) 262 return (error); 263 } 264 if (accmode) { 265 error = VOP_ACCESS(vp, accmode, cred, td); 266 if (error) 267 return (error); 268 } 269 } 270 if (vp->v_type == VFIFO && VOP_ISLOCKED(vp) != LK_EXCLUSIVE) 271 vn_lock(vp, LK_UPGRADE | LK_RETRY); 272 if ((error = VOP_OPEN(vp, fmode, cred, td, fp)) != 0) 273 return (error); 274 275 if (fmode & (O_EXLOCK | O_SHLOCK)) { 276 KASSERT(fp != NULL, ("open with flock requires fp")); 277 lock_flags = VOP_ISLOCKED(vp); 278 VOP_UNLOCK(vp, 0); 279 lf.l_whence = SEEK_SET; 280 lf.l_start = 0; 281 lf.l_len = 0; 282 if (fmode & O_EXLOCK) 283 lf.l_type = F_WRLCK; 284 else 285 lf.l_type = F_RDLCK; 286 type = F_FLOCK; 287 if ((fmode & FNONBLOCK) == 0) 288 type |= F_WAIT; 289 error = VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf, type); 290 have_flock = (error == 0); 291 vn_lock(vp, lock_flags | LK_RETRY); 292 if (error == 0 && vp->v_iflag & VI_DOOMED) 293 error = ENOENT; 294 /* 295 * Another thread might have used this vnode as an 296 * executable while the vnode lock was dropped. 297 * Ensure the vnode is still able to be opened for 298 * writing after the lock has been obtained. 299 */ 300 if (error == 0 && accmode & VWRITE) 301 error = vn_writechk(vp); 302 if (error) { 303 VOP_UNLOCK(vp, 0); 304 if (have_flock) { 305 lf.l_whence = SEEK_SET; 306 lf.l_start = 0; 307 lf.l_len = 0; 308 lf.l_type = F_UNLCK; 309 (void) VOP_ADVLOCK(vp, fp, F_UNLCK, &lf, 310 F_FLOCK); 311 } 312 vn_start_write(vp, &mp, V_WAIT); 313 vn_lock(vp, lock_flags | LK_RETRY); 314 (void)VOP_CLOSE(vp, fmode, cred, td); 315 vn_finished_write(mp); 316 /* Prevent second close from fdrop()->vn_close(). */ 317 if (fp != NULL) 318 fp->f_ops= &badfileops; 319 return (error); 320 } 321 fp->f_flag |= FHASLOCK; 322 } 323 if (fmode & FWRITE) { 324 VOP_ADD_WRITECOUNT(vp, 1); 325 CTR3(KTR_VFS, "%s: vp %p v_writecount increased to %d", 326 __func__, vp, vp->v_writecount); 327 } 328 ASSERT_VOP_LOCKED(vp, "vn_open_vnode"); 329 return (0); 330} 331 332/* 333 * Check for write permissions on the specified vnode. 334 * Prototype text segments cannot be written. 335 */ 336int 337vn_writechk(vp) 338 register struct vnode *vp; 339{ 340 341 ASSERT_VOP_LOCKED(vp, "vn_writechk"); 342 /* 343 * If there's shared text associated with 344 * the vnode, try to free it up once. If 345 * we fail, we can't allow writing. 346 */ 347 if (VOP_IS_TEXT(vp)) 348 return (ETXTBSY); 349 350 return (0); 351} 352 353/* 354 * Vnode close call 355 */ 356int 357vn_close(vp, flags, file_cred, td) 358 register struct vnode *vp; 359 int flags; 360 struct ucred *file_cred; 361 struct thread *td; 362{ 363 struct mount *mp; 364 int error, lock_flags; 365 366 if (vp->v_type != VFIFO && (flags & FWRITE) == 0 && 367 MNT_EXTENDED_SHARED(vp->v_mount)) 368 lock_flags = LK_SHARED; 369 else 370 lock_flags = LK_EXCLUSIVE; 371 372 vn_start_write(vp, &mp, V_WAIT); 373 vn_lock(vp, lock_flags | LK_RETRY); 374 if (flags & FWRITE) { 375 VNASSERT(vp->v_writecount > 0, vp, 376 ("vn_close: negative writecount")); 377 VOP_ADD_WRITECOUNT(vp, -1); 378 CTR3(KTR_VFS, "%s: vp %p v_writecount decreased to %d", 379 __func__, vp, vp->v_writecount); 380 } 381 error = VOP_CLOSE(vp, flags, file_cred, td); 382 vput(vp); 383 vn_finished_write(mp); 384 return (error); 385} 386 387/* 388 * Heuristic to detect sequential operation. 389 */ 390static int 391sequential_heuristic(struct uio *uio, struct file *fp) 392{ 393 394 if (atomic_load_acq_int(&(fp->f_flag)) & FRDAHEAD) 395 return (fp->f_seqcount << IO_SEQSHIFT); 396 397 /* 398 * Offset 0 is handled specially. open() sets f_seqcount to 1 so 399 * that the first I/O is normally considered to be slightly 400 * sequential. Seeking to offset 0 doesn't change sequentiality 401 * unless previous seeks have reduced f_seqcount to 0, in which 402 * case offset 0 is not special. 403 */ 404 if ((uio->uio_offset == 0 && fp->f_seqcount > 0) || 405 uio->uio_offset == fp->f_nextoff) { 406 /* 407 * f_seqcount is in units of fixed-size blocks so that it 408 * depends mainly on the amount of sequential I/O and not 409 * much on the number of sequential I/O's. The fixed size 410 * of 16384 is hard-coded here since it is (not quite) just 411 * a magic size that works well here. This size is more 412 * closely related to the best I/O size for real disks than 413 * to any block size used by software. 414 */ 415 fp->f_seqcount += howmany(uio->uio_resid, 16384); 416 if (fp->f_seqcount > IO_SEQMAX) 417 fp->f_seqcount = IO_SEQMAX; 418 return (fp->f_seqcount << IO_SEQSHIFT); 419 } 420 421 /* Not sequential. Quickly draw-down sequentiality. */ 422 if (fp->f_seqcount > 1) 423 fp->f_seqcount = 1; 424 else 425 fp->f_seqcount = 0; 426 return (0); 427} 428 429/* 430 * Package up an I/O request on a vnode into a uio and do it. 431 */ 432int 433vn_rdwr(enum uio_rw rw, struct vnode *vp, void *base, int len, off_t offset, 434 enum uio_seg segflg, int ioflg, struct ucred *active_cred, 435 struct ucred *file_cred, ssize_t *aresid, struct thread *td) 436{ 437 struct uio auio; 438 struct iovec aiov; 439 struct mount *mp; 440 struct ucred *cred; 441 void *rl_cookie; 442 int error, lock_flags; 443 444 auio.uio_iov = &aiov; 445 auio.uio_iovcnt = 1; 446 aiov.iov_base = base; 447 aiov.iov_len = len; 448 auio.uio_resid = len; 449 auio.uio_offset = offset; 450 auio.uio_segflg = segflg; 451 auio.uio_rw = rw; 452 auio.uio_td = td; 453 error = 0; 454 455 if ((ioflg & IO_NODELOCKED) == 0) { 456 if (rw == UIO_READ) { 457 rl_cookie = vn_rangelock_rlock(vp, offset, 458 offset + len); 459 } else { 460 rl_cookie = vn_rangelock_wlock(vp, offset, 461 offset + len); 462 } 463 mp = NULL; 464 if (rw == UIO_WRITE) { 465 if (vp->v_type != VCHR && 466 (error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) 467 != 0) 468 goto out; 469 if (MNT_SHARED_WRITES(mp) || 470 ((mp == NULL) && MNT_SHARED_WRITES(vp->v_mount))) 471 lock_flags = LK_SHARED; 472 else 473 lock_flags = LK_EXCLUSIVE; 474 } else 475 lock_flags = LK_SHARED; 476 vn_lock(vp, lock_flags | LK_RETRY); 477 } else 478 rl_cookie = NULL; 479 480 ASSERT_VOP_LOCKED(vp, "IO_NODELOCKED with no vp lock held"); 481#ifdef MAC 482 if ((ioflg & IO_NOMACCHECK) == 0) { 483 if (rw == UIO_READ) 484 error = mac_vnode_check_read(active_cred, file_cred, 485 vp); 486 else 487 error = mac_vnode_check_write(active_cred, file_cred, 488 vp); 489 } 490#endif 491 if (error == 0) { 492 if (file_cred != NULL) 493 cred = file_cred; 494 else 495 cred = active_cred; 496 if (rw == UIO_READ) 497 error = VOP_READ(vp, &auio, ioflg, cred); 498 else 499 error = VOP_WRITE(vp, &auio, ioflg, cred); 500 } 501 if (aresid) 502 *aresid = auio.uio_resid; 503 else 504 if (auio.uio_resid && error == 0) 505 error = EIO; 506 if ((ioflg & IO_NODELOCKED) == 0) { 507 VOP_UNLOCK(vp, 0); 508 if (mp != NULL) 509 vn_finished_write(mp); 510 } 511 out: 512 if (rl_cookie != NULL) 513 vn_rangelock_unlock(vp, rl_cookie); 514 return (error); 515} 516 517/* 518 * Package up an I/O request on a vnode into a uio and do it. The I/O 519 * request is split up into smaller chunks and we try to avoid saturating 520 * the buffer cache while potentially holding a vnode locked, so we 521 * check bwillwrite() before calling vn_rdwr(). We also call kern_yield() 522 * to give other processes a chance to lock the vnode (either other processes 523 * core'ing the same binary, or unrelated processes scanning the directory). 524 */ 525int 526vn_rdwr_inchunks(rw, vp, base, len, offset, segflg, ioflg, active_cred, 527 file_cred, aresid, td) 528 enum uio_rw rw; 529 struct vnode *vp; 530 void *base; 531 size_t len; 532 off_t offset; 533 enum uio_seg segflg; 534 int ioflg; 535 struct ucred *active_cred; 536 struct ucred *file_cred; 537 size_t *aresid; 538 struct thread *td; 539{ 540 int error = 0; 541 ssize_t iaresid; 542 543 do { 544 int chunk; 545 546 /* 547 * Force `offset' to a multiple of MAXBSIZE except possibly 548 * for the first chunk, so that filesystems only need to 549 * write full blocks except possibly for the first and last 550 * chunks. 551 */ 552 chunk = MAXBSIZE - (uoff_t)offset % MAXBSIZE; 553 554 if (chunk > len) 555 chunk = len; 556 if (rw != UIO_READ && vp->v_type == VREG) 557 bwillwrite(); 558 iaresid = 0; 559 error = vn_rdwr(rw, vp, base, chunk, offset, segflg, 560 ioflg, active_cred, file_cred, &iaresid, td); 561 len -= chunk; /* aresid calc already includes length */ 562 if (error) 563 break; 564 offset += chunk; 565 base = (char *)base + chunk; 566 kern_yield(PRI_USER); 567 } while (len); 568 if (aresid) 569 *aresid = len + iaresid; 570 return (error); 571} 572 573off_t 574foffset_lock(struct file *fp, int flags) 575{ 576 struct mtx *mtxp; 577 off_t res; 578 579 KASSERT((flags & FOF_OFFSET) == 0, ("FOF_OFFSET passed")); 580 581#if OFF_MAX <= LONG_MAX 582 /* 583 * Caller only wants the current f_offset value. Assume that 584 * the long and shorter integer types reads are atomic. 585 */ 586 if ((flags & FOF_NOLOCK) != 0) 587 return (fp->f_offset); 588#endif 589 590 /* 591 * According to McKusick the vn lock was protecting f_offset here. 592 * It is now protected by the FOFFSET_LOCKED flag. 593 */ 594 mtxp = mtx_pool_find(mtxpool_sleep, fp); 595 mtx_lock(mtxp); 596 if ((flags & FOF_NOLOCK) == 0) { 597 while (fp->f_vnread_flags & FOFFSET_LOCKED) { 598 fp->f_vnread_flags |= FOFFSET_LOCK_WAITING; 599 msleep(&fp->f_vnread_flags, mtxp, PUSER -1, 600 "vofflock", 0); 601 } 602 fp->f_vnread_flags |= FOFFSET_LOCKED; 603 } 604 res = fp->f_offset; 605 mtx_unlock(mtxp); 606 return (res); 607} 608 609void 610foffset_unlock(struct file *fp, off_t val, int flags) 611{ 612 struct mtx *mtxp; 613 614 KASSERT((flags & FOF_OFFSET) == 0, ("FOF_OFFSET passed")); 615 616#if OFF_MAX <= LONG_MAX 617 if ((flags & FOF_NOLOCK) != 0) { 618 if ((flags & FOF_NOUPDATE) == 0) 619 fp->f_offset = val; 620 if ((flags & FOF_NEXTOFF) != 0) 621 fp->f_nextoff = val; 622 return; 623 } 624#endif 625 626 mtxp = mtx_pool_find(mtxpool_sleep, fp); 627 mtx_lock(mtxp); 628 if ((flags & FOF_NOUPDATE) == 0) 629 fp->f_offset = val; 630 if ((flags & FOF_NEXTOFF) != 0) 631 fp->f_nextoff = val; 632 if ((flags & FOF_NOLOCK) == 0) { 633 KASSERT((fp->f_vnread_flags & FOFFSET_LOCKED) != 0, 634 ("Lost FOFFSET_LOCKED")); 635 if (fp->f_vnread_flags & FOFFSET_LOCK_WAITING) 636 wakeup(&fp->f_vnread_flags); 637 fp->f_vnread_flags = 0; 638 } 639 mtx_unlock(mtxp); 640} 641 642void 643foffset_lock_uio(struct file *fp, struct uio *uio, int flags) 644{ 645 646 if ((flags & FOF_OFFSET) == 0) 647 uio->uio_offset = foffset_lock(fp, flags); 648} 649 650void 651foffset_unlock_uio(struct file *fp, struct uio *uio, int flags) 652{ 653 654 if ((flags & FOF_OFFSET) == 0) 655 foffset_unlock(fp, uio->uio_offset, flags); 656} 657 658static int 659get_advice(struct file *fp, struct uio *uio) 660{ 661 struct mtx *mtxp; 662 int ret; 663 664 ret = POSIX_FADV_NORMAL; 665 if (fp->f_advice == NULL) 666 return (ret); 667 668 mtxp = mtx_pool_find(mtxpool_sleep, fp); 669 mtx_lock(mtxp); 670 if (uio->uio_offset >= fp->f_advice->fa_start && 671 uio->uio_offset + uio->uio_resid <= fp->f_advice->fa_end) 672 ret = fp->f_advice->fa_advice; 673 mtx_unlock(mtxp); 674 return (ret); 675} 676 677/* 678 * File table vnode read routine. 679 */ 680static int 681vn_read(fp, uio, active_cred, flags, td) 682 struct file *fp; 683 struct uio *uio; 684 struct ucred *active_cred; 685 int flags; 686 struct thread *td; 687{ 688 struct vnode *vp; 689 struct mtx *mtxp; 690 int error, ioflag; 691 int advice; 692 off_t offset, start, end; 693 694 KASSERT(uio->uio_td == td, ("uio_td %p is not td %p", 695 uio->uio_td, td)); 696 KASSERT(flags & FOF_OFFSET, ("No FOF_OFFSET")); 697 vp = fp->f_vnode; 698 ioflag = 0; 699 if (fp->f_flag & FNONBLOCK) 700 ioflag |= IO_NDELAY; 701 if (fp->f_flag & O_DIRECT) 702 ioflag |= IO_DIRECT; 703 advice = get_advice(fp, uio); 704 vn_lock(vp, LK_SHARED | LK_RETRY); 705 706 switch (advice) { 707 case POSIX_FADV_NORMAL: 708 case POSIX_FADV_SEQUENTIAL: 709 case POSIX_FADV_NOREUSE: 710 ioflag |= sequential_heuristic(uio, fp); 711 break; 712 case POSIX_FADV_RANDOM: 713 /* Disable read-ahead for random I/O. */ 714 break; 715 } 716 offset = uio->uio_offset; 717 718#ifdef MAC 719 error = mac_vnode_check_read(active_cred, fp->f_cred, vp); 720 if (error == 0) 721#endif 722 error = VOP_READ(vp, uio, ioflag, fp->f_cred); 723 fp->f_nextoff = uio->uio_offset; 724 VOP_UNLOCK(vp, 0); 725 if (error == 0 && advice == POSIX_FADV_NOREUSE && 726 offset != uio->uio_offset) { 727 /* 728 * Use POSIX_FADV_DONTNEED to flush clean pages and 729 * buffers for the backing file after a 730 * POSIX_FADV_NOREUSE read(2). To optimize the common 731 * case of using POSIX_FADV_NOREUSE with sequential 732 * access, track the previous implicit DONTNEED 733 * request and grow this request to include the 734 * current read(2) in addition to the previous 735 * DONTNEED. With purely sequential access this will 736 * cause the DONTNEED requests to continously grow to 737 * cover all of the previously read regions of the 738 * file. This allows filesystem blocks that are 739 * accessed by multiple calls to read(2) to be flushed 740 * once the last read(2) finishes. 741 */ 742 start = offset; 743 end = uio->uio_offset - 1; 744 mtxp = mtx_pool_find(mtxpool_sleep, fp); 745 mtx_lock(mtxp); 746 if (fp->f_advice != NULL && 747 fp->f_advice->fa_advice == POSIX_FADV_NOREUSE) { 748 if (start != 0 && fp->f_advice->fa_prevend + 1 == start) 749 start = fp->f_advice->fa_prevstart; 750 else if (fp->f_advice->fa_prevstart != 0 && 751 fp->f_advice->fa_prevstart == end + 1) 752 end = fp->f_advice->fa_prevend; 753 fp->f_advice->fa_prevstart = start; 754 fp->f_advice->fa_prevend = end; 755 } 756 mtx_unlock(mtxp); 757 error = VOP_ADVISE(vp, start, end, POSIX_FADV_DONTNEED); 758 } 759 return (error); 760} 761 762/* 763 * File table vnode write routine. 764 */ 765static int 766vn_write(fp, uio, active_cred, flags, td) 767 struct file *fp; 768 struct uio *uio; 769 struct ucred *active_cred; 770 int flags; 771 struct thread *td; 772{ 773 struct vnode *vp; 774 struct mount *mp; 775 struct mtx *mtxp; 776 int error, ioflag, lock_flags; 777 int advice; 778 off_t offset, start, end; 779 780 KASSERT(uio->uio_td == td, ("uio_td %p is not td %p", 781 uio->uio_td, td)); 782 KASSERT(flags & FOF_OFFSET, ("No FOF_OFFSET")); 783 vp = fp->f_vnode; 784 if (vp->v_type == VREG) 785 bwillwrite(); 786 ioflag = IO_UNIT; 787 if (vp->v_type == VREG && (fp->f_flag & O_APPEND)) 788 ioflag |= IO_APPEND; 789 if (fp->f_flag & FNONBLOCK) 790 ioflag |= IO_NDELAY; 791 if (fp->f_flag & O_DIRECT) 792 ioflag |= IO_DIRECT; 793 if ((fp->f_flag & O_FSYNC) || 794 (vp->v_mount && (vp->v_mount->mnt_flag & MNT_SYNCHRONOUS))) 795 ioflag |= IO_SYNC; 796 mp = NULL; 797 if (vp->v_type != VCHR && 798 (error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) 799 goto unlock; 800 801 advice = get_advice(fp, uio); 802 803 if (MNT_SHARED_WRITES(mp) || 804 (mp == NULL && MNT_SHARED_WRITES(vp->v_mount))) { 805 lock_flags = LK_SHARED; 806 } else { 807 lock_flags = LK_EXCLUSIVE; 808 } 809 810 vn_lock(vp, lock_flags | LK_RETRY); 811 switch (advice) { 812 case POSIX_FADV_NORMAL: 813 case POSIX_FADV_SEQUENTIAL: 814 case POSIX_FADV_NOREUSE: 815 ioflag |= sequential_heuristic(uio, fp); 816 break; 817 case POSIX_FADV_RANDOM: 818 /* XXX: Is this correct? */ 819 break; 820 } 821 offset = uio->uio_offset; 822 823#ifdef MAC 824 error = mac_vnode_check_write(active_cred, fp->f_cred, vp); 825 if (error == 0) 826#endif 827 error = VOP_WRITE(vp, uio, ioflag, fp->f_cred); 828 fp->f_nextoff = uio->uio_offset; 829 VOP_UNLOCK(vp, 0); 830 if (vp->v_type != VCHR) 831 vn_finished_write(mp); 832 if (error == 0 && advice == POSIX_FADV_NOREUSE && 833 offset != uio->uio_offset) { 834 /* 835 * Use POSIX_FADV_DONTNEED to flush clean pages and 836 * buffers for the backing file after a 837 * POSIX_FADV_NOREUSE write(2). To optimize the 838 * common case of using POSIX_FADV_NOREUSE with 839 * sequential access, track the previous implicit 840 * DONTNEED request and grow this request to include 841 * the current write(2) in addition to the previous 842 * DONTNEED. With purely sequential access this will 843 * cause the DONTNEED requests to continously grow to 844 * cover all of the previously written regions of the 845 * file. 846 * 847 * Note that the blocks just written are almost 848 * certainly still dirty, so this only works when 849 * VOP_ADVISE() calls from subsequent writes push out 850 * the data written by this write(2) once the backing 851 * buffers are clean. However, as compared to forcing 852 * IO_DIRECT, this gives much saner behavior. Write 853 * clustering is still allowed, and clean pages are 854 * merely moved to the cache page queue rather than 855 * outright thrown away. This means a subsequent 856 * read(2) can still avoid hitting the disk if the 857 * pages have not been reclaimed. 858 * 859 * This does make POSIX_FADV_NOREUSE largely useless 860 * with non-sequential access. However, sequential 861 * access is the more common use case and the flag is 862 * merely advisory. 863 */ 864 start = offset; 865 end = uio->uio_offset - 1; 866 mtxp = mtx_pool_find(mtxpool_sleep, fp); 867 mtx_lock(mtxp); 868 if (fp->f_advice != NULL && 869 fp->f_advice->fa_advice == POSIX_FADV_NOREUSE) { 870 if (start != 0 && fp->f_advice->fa_prevend + 1 == start) 871 start = fp->f_advice->fa_prevstart; 872 else if (fp->f_advice->fa_prevstart != 0 && 873 fp->f_advice->fa_prevstart == end + 1) 874 end = fp->f_advice->fa_prevend; 875 fp->f_advice->fa_prevstart = start; 876 fp->f_advice->fa_prevend = end; 877 } 878 mtx_unlock(mtxp); 879 error = VOP_ADVISE(vp, start, end, POSIX_FADV_DONTNEED); 880 } 881 882unlock: 883 return (error); 884} 885 886static const int io_hold_cnt = 16; 887static int vn_io_fault_enable = 1; 888SYSCTL_INT(_debug, OID_AUTO, vn_io_fault_enable, CTLFLAG_RW, 889 &vn_io_fault_enable, 0, "Enable vn_io_fault lock avoidance"); 890static u_long vn_io_faults_cnt; 891SYSCTL_ULONG(_debug, OID_AUTO, vn_io_faults, CTLFLAG_RD, 892 &vn_io_faults_cnt, 0, "Count of vn_io_fault lock avoidance triggers"); 893 894/* 895 * The vn_io_fault() is a wrapper around vn_read() and vn_write() to 896 * prevent the following deadlock: 897 * 898 * Assume that the thread A reads from the vnode vp1 into userspace 899 * buffer buf1 backed by the pages of vnode vp2. If a page in buf1 is 900 * currently not resident, then system ends up with the call chain 901 * vn_read() -> VOP_READ(vp1) -> uiomove() -> [Page Fault] -> 902 * vm_fault(buf1) -> vnode_pager_getpages(vp2) -> VOP_GETPAGES(vp2) 903 * which establishes lock order vp1->vn_lock, then vp2->vn_lock. 904 * If, at the same time, thread B reads from vnode vp2 into buffer buf2 905 * backed by the pages of vnode vp1, and some page in buf2 is not 906 * resident, we get a reversed order vp2->vn_lock, then vp1->vn_lock. 907 * 908 * To prevent the lock order reversal and deadlock, vn_io_fault() does 909 * not allow page faults to happen during VOP_READ() or VOP_WRITE(). 910 * Instead, it first tries to do the whole range i/o with pagefaults 911 * disabled. If all pages in the i/o buffer are resident and mapped, 912 * VOP will succeed (ignoring the genuine filesystem errors). 913 * Otherwise, we get back EFAULT, and vn_io_fault() falls back to do 914 * i/o in chunks, with all pages in the chunk prefaulted and held 915 * using vm_fault_quick_hold_pages(). 916 * 917 * Filesystems using this deadlock avoidance scheme should use the 918 * array of the held pages from uio, saved in the curthread->td_ma, 919 * instead of doing uiomove(). A helper function 920 * vn_io_fault_uiomove() converts uiomove request into 921 * uiomove_fromphys() over td_ma array. 922 * 923 * Since vnode locks do not cover the whole i/o anymore, rangelocks 924 * make the current i/o request atomic with respect to other i/os and 925 * truncations. 926 */ 927static int 928vn_io_fault(struct file *fp, struct uio *uio, struct ucred *active_cred, 929 int flags, struct thread *td) 930{ 931 vm_page_t ma[io_hold_cnt + 2]; 932 struct uio *uio_clone, short_uio; 933 struct iovec short_iovec[1]; 934 fo_rdwr_t *doio; 935 struct vnode *vp; 936 void *rl_cookie; 937 struct mount *mp; 938 vm_page_t *prev_td_ma; 939 int error, cnt, save, saveheld, prev_td_ma_cnt; 940 vm_offset_t addr, end; 941 vm_prot_t prot; 942 size_t len, resid; 943 ssize_t adv; 944 945 if (uio->uio_rw == UIO_READ) 946 doio = vn_read; 947 else 948 doio = vn_write; 949 vp = fp->f_vnode; 950 foffset_lock_uio(fp, uio, flags); 951 952 if (uio->uio_segflg != UIO_USERSPACE || vp->v_type != VREG || 953 ((mp = vp->v_mount) != NULL && 954 (mp->mnt_kern_flag & MNTK_NO_IOPF) == 0) || 955 !vn_io_fault_enable) { 956 error = doio(fp, uio, active_cred, flags | FOF_OFFSET, td); 957 goto out_last; 958 } 959 960 /* 961 * The UFS follows IO_UNIT directive and replays back both 962 * uio_offset and uio_resid if an error is encountered during the 963 * operation. But, since the iovec may be already advanced, 964 * uio is still in an inconsistent state. 965 * 966 * Cache a copy of the original uio, which is advanced to the redo 967 * point using UIO_NOCOPY below. 968 */ 969 uio_clone = cloneuio(uio); 970 resid = uio->uio_resid; 971 972 short_uio.uio_segflg = UIO_USERSPACE; 973 short_uio.uio_rw = uio->uio_rw; 974 short_uio.uio_td = uio->uio_td; 975 976 if (uio->uio_rw == UIO_READ) { 977 prot = VM_PROT_WRITE; 978 rl_cookie = vn_rangelock_rlock(vp, uio->uio_offset, 979 uio->uio_offset + uio->uio_resid); 980 } else { 981 prot = VM_PROT_READ; 982 if ((fp->f_flag & O_APPEND) != 0 || (flags & FOF_OFFSET) == 0) 983 /* For appenders, punt and lock the whole range. */ 984 rl_cookie = vn_rangelock_wlock(vp, 0, OFF_MAX); 985 else 986 rl_cookie = vn_rangelock_wlock(vp, uio->uio_offset, 987 uio->uio_offset + uio->uio_resid); 988 } 989 990 save = vm_fault_disable_pagefaults(); 991 error = doio(fp, uio, active_cred, flags | FOF_OFFSET, td); 992 if (error != EFAULT) 993 goto out; 994 995 atomic_add_long(&vn_io_faults_cnt, 1); 996 uio_clone->uio_segflg = UIO_NOCOPY; 997 uiomove(NULL, resid - uio->uio_resid, uio_clone); 998 uio_clone->uio_segflg = uio->uio_segflg; 999 1000 saveheld = curthread_pflags_set(TDP_UIOHELD); 1001 prev_td_ma = td->td_ma; 1002 prev_td_ma_cnt = td->td_ma_cnt; 1003 1004 while (uio_clone->uio_resid != 0) { 1005 len = uio_clone->uio_iov->iov_len; 1006 if (len == 0) { 1007 KASSERT(uio_clone->uio_iovcnt >= 1, 1008 ("iovcnt underflow")); 1009 uio_clone->uio_iov++; 1010 uio_clone->uio_iovcnt--; 1011 continue; 1012 } 1013 if (len > io_hold_cnt * PAGE_SIZE) 1014 len = io_hold_cnt * PAGE_SIZE; 1015 addr = (uintptr_t)uio_clone->uio_iov->iov_base; 1016 end = round_page(addr + len); 1017 if (end < addr) { 1018 error = EFAULT; 1019 break; 1020 } 1021 cnt = atop(end - trunc_page(addr)); 1022 /* 1023 * A perfectly misaligned address and length could cause 1024 * both the start and the end of the chunk to use partial 1025 * page. +2 accounts for such a situation. 1026 */ 1027 cnt = vm_fault_quick_hold_pages(&td->td_proc->p_vmspace->vm_map, 1028 addr, len, prot, ma, io_hold_cnt + 2); 1029 if (cnt == -1) { 1030 error = EFAULT; 1031 break; 1032 } 1033 short_uio.uio_iov = &short_iovec[0]; 1034 short_iovec[0].iov_base = (void *)addr; 1035 short_uio.uio_iovcnt = 1; 1036 short_uio.uio_resid = short_iovec[0].iov_len = len; 1037 short_uio.uio_offset = uio_clone->uio_offset; 1038 td->td_ma = ma; 1039 td->td_ma_cnt = cnt; 1040 1041 error = doio(fp, &short_uio, active_cred, flags | FOF_OFFSET, 1042 td); 1043 vm_page_unhold_pages(ma, cnt); 1044 adv = len - short_uio.uio_resid; 1045 1046 uio_clone->uio_iov->iov_base = 1047 (char *)uio_clone->uio_iov->iov_base + adv; 1048 uio_clone->uio_iov->iov_len -= adv; 1049 uio_clone->uio_resid -= adv; 1050 uio_clone->uio_offset += adv; 1051 1052 uio->uio_resid -= adv; 1053 uio->uio_offset += adv; 1054 1055 if (error != 0 || adv == 0) 1056 break; 1057 } 1058 td->td_ma = prev_td_ma; 1059 td->td_ma_cnt = prev_td_ma_cnt; 1060 curthread_pflags_restore(saveheld); 1061out: 1062 vm_fault_enable_pagefaults(save); 1063 vn_rangelock_unlock(vp, rl_cookie); 1064 free(uio_clone, M_IOV); 1065out_last: 1066 foffset_unlock_uio(fp, uio, flags); 1067 return (error); 1068} 1069 1070/* 1071 * Helper function to perform the requested uiomove operation using 1072 * the held pages for io->uio_iov[0].iov_base buffer instead of 1073 * copyin/copyout. Access to the pages with uiomove_fromphys() 1074 * instead of iov_base prevents page faults that could occur due to 1075 * pmap_collect() invalidating the mapping created by 1076 * vm_fault_quick_hold_pages(), or pageout daemon, page laundry or 1077 * object cleanup revoking the write access from page mappings. 1078 * 1079 * Filesystems specified MNTK_NO_IOPF shall use vn_io_fault_uiomove() 1080 * instead of plain uiomove(). 1081 */ 1082int 1083vn_io_fault_uiomove(char *data, int xfersize, struct uio *uio) 1084{ 1085 struct uio transp_uio; 1086 struct iovec transp_iov[1]; 1087 struct thread *td; 1088 size_t adv; 1089 int error, pgadv; 1090 1091 td = curthread; 1092 if ((td->td_pflags & TDP_UIOHELD) == 0 || 1093 uio->uio_segflg != UIO_USERSPACE) 1094 return (uiomove(data, xfersize, uio)); 1095 1096 KASSERT(uio->uio_iovcnt == 1, ("uio_iovcnt %d", uio->uio_iovcnt)); 1097 transp_iov[0].iov_base = data; 1098 transp_uio.uio_iov = &transp_iov[0]; 1099 transp_uio.uio_iovcnt = 1; 1100 if (xfersize > uio->uio_resid) 1101 xfersize = uio->uio_resid; 1102 transp_uio.uio_resid = transp_iov[0].iov_len = xfersize; 1103 transp_uio.uio_offset = 0; 1104 transp_uio.uio_segflg = UIO_SYSSPACE; 1105 /* 1106 * Since transp_iov points to data, and td_ma page array 1107 * corresponds to original uio->uio_iov, we need to invert the 1108 * direction of the i/o operation as passed to 1109 * uiomove_fromphys(). 1110 */ 1111 switch (uio->uio_rw) { 1112 case UIO_WRITE: 1113 transp_uio.uio_rw = UIO_READ; 1114 break; 1115 case UIO_READ: 1116 transp_uio.uio_rw = UIO_WRITE; 1117 break; 1118 } 1119 transp_uio.uio_td = uio->uio_td; 1120 error = uiomove_fromphys(td->td_ma, 1121 ((vm_offset_t)uio->uio_iov->iov_base) & PAGE_MASK, 1122 xfersize, &transp_uio); 1123 adv = xfersize - transp_uio.uio_resid; 1124 pgadv = 1125 (((vm_offset_t)uio->uio_iov->iov_base + adv) >> PAGE_SHIFT) - 1126 (((vm_offset_t)uio->uio_iov->iov_base) >> PAGE_SHIFT); 1127 td->td_ma += pgadv; 1128 KASSERT(td->td_ma_cnt >= pgadv, ("consumed pages %d %d", td->td_ma_cnt, 1129 pgadv)); 1130 td->td_ma_cnt -= pgadv; 1131 uio->uio_iov->iov_base = (char *)uio->uio_iov->iov_base + adv; 1132 uio->uio_iov->iov_len -= adv; 1133 uio->uio_resid -= adv; 1134 uio->uio_offset += adv; 1135 return (error); 1136} 1137 1138int 1139vn_io_fault_pgmove(vm_page_t ma[], vm_offset_t offset, int xfersize, 1140 struct uio *uio) 1141{ 1142 struct thread *td; 1143 vm_offset_t iov_base; 1144 int cnt, pgadv; 1145 1146 td = curthread; 1147 if ((td->td_pflags & TDP_UIOHELD) == 0 || 1148 uio->uio_segflg != UIO_USERSPACE) 1149 return (uiomove_fromphys(ma, offset, xfersize, uio)); 1150 1151 KASSERT(uio->uio_iovcnt == 1, ("uio_iovcnt %d", uio->uio_iovcnt)); 1152 cnt = xfersize > uio->uio_resid ? uio->uio_resid : xfersize; 1153 iov_base = (vm_offset_t)uio->uio_iov->iov_base; 1154 switch (uio->uio_rw) { 1155 case UIO_WRITE: 1156 pmap_copy_pages(td->td_ma, iov_base & PAGE_MASK, ma, 1157 offset, cnt); 1158 break; 1159 case UIO_READ: 1160 pmap_copy_pages(ma, offset, td->td_ma, iov_base & PAGE_MASK, 1161 cnt); 1162 break; 1163 } 1164 pgadv = ((iov_base + cnt) >> PAGE_SHIFT) - (iov_base >> PAGE_SHIFT); 1165 td->td_ma += pgadv; 1166 KASSERT(td->td_ma_cnt >= pgadv, ("consumed pages %d %d", td->td_ma_cnt, 1167 pgadv)); 1168 td->td_ma_cnt -= pgadv; 1169 uio->uio_iov->iov_base = (char *)(iov_base + cnt); 1170 uio->uio_iov->iov_len -= cnt; 1171 uio->uio_resid -= cnt; 1172 uio->uio_offset += cnt; 1173 return (0); 1174} 1175 1176 1177/* 1178 * File table truncate routine. 1179 */ 1180static int 1181vn_truncate(struct file *fp, off_t length, struct ucred *active_cred, 1182 struct thread *td) 1183{ 1184 struct vattr vattr; 1185 struct mount *mp; 1186 struct vnode *vp; 1187 void *rl_cookie; 1188 int error; 1189 1190 vp = fp->f_vnode; 1191 1192 /* 1193 * Lock the whole range for truncation. Otherwise split i/o 1194 * might happen partly before and partly after the truncation. 1195 */ 1196 rl_cookie = vn_rangelock_wlock(vp, 0, OFF_MAX); 1197 error = vn_start_write(vp, &mp, V_WAIT | PCATCH); 1198 if (error) 1199 goto out1; 1200 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 1201 if (vp->v_type == VDIR) { 1202 error = EISDIR; 1203 goto out; 1204 } 1205#ifdef MAC 1206 error = mac_vnode_check_write(active_cred, fp->f_cred, vp); 1207 if (error) 1208 goto out; 1209#endif 1210 error = vn_writechk(vp); 1211 if (error == 0) { 1212 VATTR_NULL(&vattr); 1213 vattr.va_size = length; 1214 error = VOP_SETATTR(vp, &vattr, fp->f_cred); 1215 } 1216out: 1217 VOP_UNLOCK(vp, 0); 1218 vn_finished_write(mp); 1219out1: 1220 vn_rangelock_unlock(vp, rl_cookie); 1221 return (error); 1222} 1223 1224/* 1225 * File table vnode stat routine. 1226 */ 1227static int 1228vn_statfile(fp, sb, active_cred, td) 1229 struct file *fp; 1230 struct stat *sb; 1231 struct ucred *active_cred; 1232 struct thread *td; 1233{ 1234 struct vnode *vp = fp->f_vnode; 1235 int error; 1236 1237 vn_lock(vp, LK_SHARED | LK_RETRY); 1238 error = vn_stat(vp, sb, active_cred, fp->f_cred, td); 1239 VOP_UNLOCK(vp, 0); 1240 1241 return (error); 1242} 1243 1244/* 1245 * Stat a vnode; implementation for the stat syscall 1246 */ 1247int 1248vn_stat(vp, sb, active_cred, file_cred, td) 1249 struct vnode *vp; 1250 register struct stat *sb; 1251 struct ucred *active_cred; 1252 struct ucred *file_cred; 1253 struct thread *td; 1254{ 1255 struct vattr vattr; 1256 register struct vattr *vap; 1257 int error; 1258 u_short mode; 1259 1260#ifdef MAC 1261 error = mac_vnode_check_stat(active_cred, file_cred, vp); 1262 if (error) 1263 return (error); 1264#endif 1265 1266 vap = &vattr; 1267 1268 /* 1269 * Initialize defaults for new and unusual fields, so that file 1270 * systems which don't support these fields don't need to know 1271 * about them. 1272 */ 1273 vap->va_birthtime.tv_sec = -1; 1274 vap->va_birthtime.tv_nsec = 0; 1275 vap->va_fsid = VNOVAL; 1276 vap->va_rdev = NODEV; 1277 1278 error = VOP_GETATTR(vp, vap, active_cred); 1279 if (error) 1280 return (error); 1281 1282 /* 1283 * Zero the spare stat fields 1284 */ 1285 bzero(sb, sizeof *sb); 1286 1287 /* 1288 * Copy from vattr table 1289 */ 1290 if (vap->va_fsid != VNOVAL) 1291 sb->st_dev = vap->va_fsid; 1292 else 1293 sb->st_dev = vp->v_mount->mnt_stat.f_fsid.val[0]; 1294 sb->st_ino = vap->va_fileid; 1295 mode = vap->va_mode; 1296 switch (vap->va_type) { 1297 case VREG: 1298 mode |= S_IFREG; 1299 break; 1300 case VDIR: 1301 mode |= S_IFDIR; 1302 break; 1303 case VBLK: 1304 mode |= S_IFBLK; 1305 break; 1306 case VCHR: 1307 mode |= S_IFCHR; 1308 break; 1309 case VLNK: 1310 mode |= S_IFLNK; 1311 break; 1312 case VSOCK: 1313 mode |= S_IFSOCK; 1314 break; 1315 case VFIFO: 1316 mode |= S_IFIFO; 1317 break; 1318 default: 1319 return (EBADF); 1320 }; 1321 sb->st_mode = mode; 1322 sb->st_nlink = vap->va_nlink; 1323 sb->st_uid = vap->va_uid; 1324 sb->st_gid = vap->va_gid; 1325 sb->st_rdev = vap->va_rdev; 1326 if (vap->va_size > OFF_MAX) 1327 return (EOVERFLOW); 1328 sb->st_size = vap->va_size; 1329 sb->st_atim = vap->va_atime; 1330 sb->st_mtim = vap->va_mtime; 1331 sb->st_ctim = vap->va_ctime; 1332 sb->st_birthtim = vap->va_birthtime; 1333 1334 /* 1335 * According to www.opengroup.org, the meaning of st_blksize is 1336 * "a filesystem-specific preferred I/O block size for this 1337 * object. In some filesystem types, this may vary from file 1338 * to file" 1339 * Use miminum/default of PAGE_SIZE (e.g. for VCHR). 1340 */ 1341 1342 sb->st_blksize = max(PAGE_SIZE, vap->va_blocksize); 1343 1344 sb->st_flags = vap->va_flags; 1345 if (priv_check(td, PRIV_VFS_GENERATION)) 1346 sb->st_gen = 0; 1347 else 1348 sb->st_gen = vap->va_gen; 1349 1350 sb->st_blocks = vap->va_bytes / S_BLKSIZE; 1351 return (0); 1352} 1353 1354/* 1355 * File table vnode ioctl routine. 1356 */ 1357static int 1358vn_ioctl(fp, com, data, active_cred, td) 1359 struct file *fp; 1360 u_long com; 1361 void *data; 1362 struct ucred *active_cred; 1363 struct thread *td; 1364{ 1365 struct vattr vattr; 1366 struct vnode *vp; 1367 int error; 1368 1369 vp = fp->f_vnode; 1370 switch (vp->v_type) { 1371 case VDIR: 1372 case VREG: 1373 switch (com) { 1374 case FIONREAD: 1375 vn_lock(vp, LK_SHARED | LK_RETRY); 1376 error = VOP_GETATTR(vp, &vattr, active_cred); 1377 VOP_UNLOCK(vp, 0); 1378 if (error == 0) 1379 *(int *)data = vattr.va_size - fp->f_offset; 1380 return (error); 1381 case FIONBIO: 1382 case FIOASYNC: 1383 return (0); 1384 default: 1385 return (VOP_IOCTL(vp, com, data, fp->f_flag, 1386 active_cred, td)); 1387 } 1388 default: 1389 return (ENOTTY); 1390 } 1391} 1392 1393/* 1394 * File table vnode poll routine. 1395 */ 1396static int 1397vn_poll(fp, events, active_cred, td) 1398 struct file *fp; 1399 int events; 1400 struct ucred *active_cred; 1401 struct thread *td; 1402{ 1403 struct vnode *vp; 1404 int error; 1405 1406 vp = fp->f_vnode; 1407#ifdef MAC 1408 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 1409 error = mac_vnode_check_poll(active_cred, fp->f_cred, vp); 1410 VOP_UNLOCK(vp, 0); 1411 if (!error) 1412#endif 1413 1414 error = VOP_POLL(vp, events, fp->f_cred, td); 1415 return (error); 1416} 1417 1418/* 1419 * Acquire the requested lock and then check for validity. LK_RETRY 1420 * permits vn_lock to return doomed vnodes. 1421 */ 1422int 1423_vn_lock(struct vnode *vp, int flags, char *file, int line) 1424{ 1425 int error; 1426 1427 VNASSERT((flags & LK_TYPE_MASK) != 0, vp, 1428 ("vn_lock called with no locktype.")); 1429 do { 1430#ifdef DEBUG_VFS_LOCKS 1431 KASSERT(vp->v_holdcnt != 0, 1432 ("vn_lock %p: zero hold count", vp)); 1433#endif 1434 error = VOP_LOCK1(vp, flags, file, line); 1435 flags &= ~LK_INTERLOCK; /* Interlock is always dropped. */ 1436 KASSERT((flags & LK_RETRY) == 0 || error == 0, 1437 ("LK_RETRY set with incompatible flags (0x%x) or an error occured (%d)", 1438 flags, error)); 1439 /* 1440 * Callers specify LK_RETRY if they wish to get dead vnodes. 1441 * If RETRY is not set, we return ENOENT instead. 1442 */ 1443 if (error == 0 && vp->v_iflag & VI_DOOMED && 1444 (flags & LK_RETRY) == 0) { 1445 VOP_UNLOCK(vp, 0); 1446 error = ENOENT; 1447 break; 1448 } 1449 } while (flags & LK_RETRY && error != 0); 1450 return (error); 1451} 1452 1453/* 1454 * File table vnode close routine. 1455 */ 1456static int 1457vn_closefile(fp, td) 1458 struct file *fp; 1459 struct thread *td; 1460{ 1461 struct vnode *vp; 1462 struct flock lf; 1463 int error; 1464 1465 vp = fp->f_vnode; 1466 fp->f_ops = &badfileops; 1467 1468 if (fp->f_type == DTYPE_VNODE && fp->f_flag & FHASLOCK) 1469 vref(vp); 1470 1471 error = vn_close(vp, fp->f_flag, fp->f_cred, td); 1472 1473 if (fp->f_type == DTYPE_VNODE && fp->f_flag & FHASLOCK) { 1474 lf.l_whence = SEEK_SET; 1475 lf.l_start = 0; 1476 lf.l_len = 0; 1477 lf.l_type = F_UNLCK; 1478 (void) VOP_ADVLOCK(vp, fp, F_UNLCK, &lf, F_FLOCK); 1479 vrele(vp); 1480 } 1481 return (error); 1482} 1483 1484/* 1485 * Preparing to start a filesystem write operation. If the operation is 1486 * permitted, then we bump the count of operations in progress and 1487 * proceed. If a suspend request is in progress, we wait until the 1488 * suspension is over, and then proceed. 1489 */ 1490static int 1491vn_start_write_locked(struct mount *mp, int flags) 1492{ 1493 int error; 1494 1495 mtx_assert(MNT_MTX(mp), MA_OWNED); 1496 error = 0; 1497 1498 /* 1499 * Check on status of suspension. 1500 */ 1501 if ((curthread->td_pflags & TDP_IGNSUSP) == 0 || 1502 mp->mnt_susp_owner != curthread) { 1503 while ((mp->mnt_kern_flag & MNTK_SUSPEND) != 0) { 1504 if (flags & V_NOWAIT) { 1505 error = EWOULDBLOCK; 1506 goto unlock; 1507 } 1508 error = msleep(&mp->mnt_flag, MNT_MTX(mp), 1509 (PUSER - 1) | (flags & PCATCH), "suspfs", 0); 1510 if (error) 1511 goto unlock; 1512 } 1513 } 1514 if (flags & V_XSLEEP) 1515 goto unlock; 1516 mp->mnt_writeopcount++; 1517unlock: 1518 if (error != 0 || (flags & V_XSLEEP) != 0) 1519 MNT_REL(mp); 1520 MNT_IUNLOCK(mp); 1521 return (error); 1522} 1523 1524int 1525vn_start_write(vp, mpp, flags) 1526 struct vnode *vp; 1527 struct mount **mpp; 1528 int flags; 1529{ 1530 struct mount *mp; 1531 int error; 1532 1533 error = 0; 1534 /* 1535 * If a vnode is provided, get and return the mount point that 1536 * to which it will write. 1537 */ 1538 if (vp != NULL) { 1539 if ((error = VOP_GETWRITEMOUNT(vp, mpp)) != 0) { 1540 *mpp = NULL; 1541 if (error != EOPNOTSUPP) 1542 return (error); 1543 return (0); 1544 } 1545 } 1546 if ((mp = *mpp) == NULL) 1547 return (0); 1548 1549 /* 1550 * VOP_GETWRITEMOUNT() returns with the mp refcount held through 1551 * a vfs_ref(). 1552 * As long as a vnode is not provided we need to acquire a 1553 * refcount for the provided mountpoint too, in order to 1554 * emulate a vfs_ref(). 1555 */ 1556 MNT_ILOCK(mp); 1557 if (vp == NULL) 1558 MNT_REF(mp); 1559 1560 return (vn_start_write_locked(mp, flags)); 1561} 1562 1563/* 1564 * Secondary suspension. Used by operations such as vop_inactive 1565 * routines that are needed by the higher level functions. These 1566 * are allowed to proceed until all the higher level functions have 1567 * completed (indicated by mnt_writeopcount dropping to zero). At that 1568 * time, these operations are halted until the suspension is over. 1569 */ 1570int 1571vn_start_secondary_write(vp, mpp, flags) 1572 struct vnode *vp; 1573 struct mount **mpp; 1574 int flags; 1575{ 1576 struct mount *mp; 1577 int error; 1578 1579 retry: 1580 if (vp != NULL) { 1581 if ((error = VOP_GETWRITEMOUNT(vp, mpp)) != 0) { 1582 *mpp = NULL; 1583 if (error != EOPNOTSUPP) 1584 return (error); 1585 return (0); 1586 } 1587 } 1588 /* 1589 * If we are not suspended or have not yet reached suspended 1590 * mode, then let the operation proceed. 1591 */ 1592 if ((mp = *mpp) == NULL) 1593 return (0); 1594 1595 /* 1596 * VOP_GETWRITEMOUNT() returns with the mp refcount held through 1597 * a vfs_ref(). 1598 * As long as a vnode is not provided we need to acquire a 1599 * refcount for the provided mountpoint too, in order to 1600 * emulate a vfs_ref(). 1601 */ 1602 MNT_ILOCK(mp); 1603 if (vp == NULL) 1604 MNT_REF(mp); 1605 if ((mp->mnt_kern_flag & (MNTK_SUSPENDED | MNTK_SUSPEND2)) == 0) { 1606 mp->mnt_secondary_writes++; 1607 mp->mnt_secondary_accwrites++; 1608 MNT_IUNLOCK(mp); 1609 return (0); 1610 } 1611 if (flags & V_NOWAIT) { 1612 MNT_REL(mp); 1613 MNT_IUNLOCK(mp); 1614 return (EWOULDBLOCK); 1615 } 1616 /* 1617 * Wait for the suspension to finish. 1618 */ 1619 error = msleep(&mp->mnt_flag, MNT_MTX(mp), 1620 (PUSER - 1) | (flags & PCATCH) | PDROP, "suspfs", 0); 1621 vfs_rel(mp); 1622 if (error == 0) 1623 goto retry; 1624 return (error); 1625} 1626 1627/* 1628 * Filesystem write operation has completed. If we are suspending and this 1629 * operation is the last one, notify the suspender that the suspension is 1630 * now in effect. 1631 */ 1632void 1633vn_finished_write(mp) 1634 struct mount *mp; 1635{ 1636 if (mp == NULL) 1637 return; 1638 MNT_ILOCK(mp); 1639 MNT_REL(mp); 1640 mp->mnt_writeopcount--; 1641 if (mp->mnt_writeopcount < 0) 1642 panic("vn_finished_write: neg cnt"); 1643 if ((mp->mnt_kern_flag & MNTK_SUSPEND) != 0 && 1644 mp->mnt_writeopcount <= 0) 1645 wakeup(&mp->mnt_writeopcount); 1646 MNT_IUNLOCK(mp); 1647} 1648 1649 1650/* 1651 * Filesystem secondary write operation has completed. If we are 1652 * suspending and this operation is the last one, notify the suspender 1653 * that the suspension is now in effect. 1654 */ 1655void 1656vn_finished_secondary_write(mp) 1657 struct mount *mp; 1658{ 1659 if (mp == NULL) 1660 return; 1661 MNT_ILOCK(mp); 1662 MNT_REL(mp); 1663 mp->mnt_secondary_writes--; 1664 if (mp->mnt_secondary_writes < 0) 1665 panic("vn_finished_secondary_write: neg cnt"); 1666 if ((mp->mnt_kern_flag & MNTK_SUSPEND) != 0 && 1667 mp->mnt_secondary_writes <= 0) 1668 wakeup(&mp->mnt_secondary_writes); 1669 MNT_IUNLOCK(mp); 1670} 1671 1672 1673 1674/* 1675 * Request a filesystem to suspend write operations. 1676 */ 1677int 1678vfs_write_suspend(struct mount *mp, int flags) 1679{ 1680 int error; 1681 1682 MNT_ILOCK(mp); 1683 if (mp->mnt_susp_owner == curthread) { 1684 MNT_IUNLOCK(mp); 1685 return (EALREADY); 1686 } 1687 while (mp->mnt_kern_flag & MNTK_SUSPEND) 1688 msleep(&mp->mnt_flag, MNT_MTX(mp), PUSER - 1, "wsuspfs", 0); 1689 1690 /* 1691 * Unmount holds a write reference on the mount point. If we 1692 * own busy reference and drain for writers, we deadlock with 1693 * the reference draining in the unmount path. Callers of 1694 * vfs_write_suspend() must specify VS_SKIP_UNMOUNT if 1695 * vfs_busy() reference is owned and caller is not in the 1696 * unmount context. 1697 */ 1698 if ((flags & VS_SKIP_UNMOUNT) != 0 && 1699 (mp->mnt_kern_flag & MNTK_UNMOUNT) != 0) { 1700 MNT_IUNLOCK(mp); 1701 return (EBUSY); 1702 } 1703 1704 mp->mnt_kern_flag |= MNTK_SUSPEND; 1705 mp->mnt_susp_owner = curthread; 1706 if (mp->mnt_writeopcount > 0) 1707 (void) msleep(&mp->mnt_writeopcount, 1708 MNT_MTX(mp), (PUSER - 1)|PDROP, "suspwt", 0); 1709 else 1710 MNT_IUNLOCK(mp); 1711 if ((error = VFS_SYNC(mp, MNT_SUSPEND)) != 0) 1712 vfs_write_resume(mp, 0); 1713 return (error); 1714} 1715 1716/* 1717 * Request a filesystem to resume write operations. 1718 */ 1719void 1720vfs_write_resume(struct mount *mp, int flags) 1721{ 1722 1723 MNT_ILOCK(mp); 1724 if ((mp->mnt_kern_flag & MNTK_SUSPEND) != 0) { 1725 KASSERT(mp->mnt_susp_owner == curthread, ("mnt_susp_owner")); 1726 mp->mnt_kern_flag &= ~(MNTK_SUSPEND | MNTK_SUSPEND2 | 1727 MNTK_SUSPENDED); 1728 mp->mnt_susp_owner = NULL; 1729 wakeup(&mp->mnt_writeopcount); 1730 wakeup(&mp->mnt_flag); 1731 curthread->td_pflags &= ~TDP_IGNSUSP; 1732 if ((flags & VR_START_WRITE) != 0) { 1733 MNT_REF(mp); 1734 mp->mnt_writeopcount++; 1735 } 1736 MNT_IUNLOCK(mp); 1737 if ((flags & VR_NO_SUSPCLR) == 0) 1738 VFS_SUSP_CLEAN(mp); 1739 } else if ((flags & VR_START_WRITE) != 0) { 1740 MNT_REF(mp); 1741 vn_start_write_locked(mp, 0); 1742 } else { 1743 MNT_IUNLOCK(mp); 1744 } 1745} 1746 1747/* 1748 * Implement kqueues for files by translating it to vnode operation. 1749 */ 1750static int 1751vn_kqfilter(struct file *fp, struct knote *kn) 1752{ 1753 1754 return (VOP_KQFILTER(fp->f_vnode, kn)); 1755} 1756 1757/* 1758 * Simplified in-kernel wrapper calls for extended attribute access. 1759 * Both calls pass in a NULL credential, authorizing as "kernel" access. 1760 * Set IO_NODELOCKED in ioflg if the vnode is already locked. 1761 */ 1762int 1763vn_extattr_get(struct vnode *vp, int ioflg, int attrnamespace, 1764 const char *attrname, int *buflen, char *buf, struct thread *td) 1765{ 1766 struct uio auio; 1767 struct iovec iov; 1768 int error; 1769 1770 iov.iov_len = *buflen; 1771 iov.iov_base = buf; 1772 1773 auio.uio_iov = &iov; 1774 auio.uio_iovcnt = 1; 1775 auio.uio_rw = UIO_READ; 1776 auio.uio_segflg = UIO_SYSSPACE; 1777 auio.uio_td = td; 1778 auio.uio_offset = 0; 1779 auio.uio_resid = *buflen; 1780 1781 if ((ioflg & IO_NODELOCKED) == 0) 1782 vn_lock(vp, LK_SHARED | LK_RETRY); 1783 1784 ASSERT_VOP_LOCKED(vp, "IO_NODELOCKED with no vp lock held"); 1785 1786 /* authorize attribute retrieval as kernel */ 1787 error = VOP_GETEXTATTR(vp, attrnamespace, attrname, &auio, NULL, NULL, 1788 td); 1789 1790 if ((ioflg & IO_NODELOCKED) == 0) 1791 VOP_UNLOCK(vp, 0); 1792 1793 if (error == 0) { 1794 *buflen = *buflen - auio.uio_resid; 1795 } 1796 1797 return (error); 1798} 1799 1800/* 1801 * XXX failure mode if partially written? 1802 */ 1803int 1804vn_extattr_set(struct vnode *vp, int ioflg, int attrnamespace, 1805 const char *attrname, int buflen, char *buf, struct thread *td) 1806{ 1807 struct uio auio; 1808 struct iovec iov; 1809 struct mount *mp; 1810 int error; 1811 1812 iov.iov_len = buflen; 1813 iov.iov_base = buf; 1814 1815 auio.uio_iov = &iov; 1816 auio.uio_iovcnt = 1; 1817 auio.uio_rw = UIO_WRITE; 1818 auio.uio_segflg = UIO_SYSSPACE; 1819 auio.uio_td = td; 1820 auio.uio_offset = 0; 1821 auio.uio_resid = buflen; 1822 1823 if ((ioflg & IO_NODELOCKED) == 0) { 1824 if ((error = vn_start_write(vp, &mp, V_WAIT)) != 0) 1825 return (error); 1826 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 1827 } 1828 1829 ASSERT_VOP_LOCKED(vp, "IO_NODELOCKED with no vp lock held"); 1830 1831 /* authorize attribute setting as kernel */ 1832 error = VOP_SETEXTATTR(vp, attrnamespace, attrname, &auio, NULL, td); 1833 1834 if ((ioflg & IO_NODELOCKED) == 0) { 1835 vn_finished_write(mp); 1836 VOP_UNLOCK(vp, 0); 1837 } 1838 1839 return (error); 1840} 1841 1842int 1843vn_extattr_rm(struct vnode *vp, int ioflg, int attrnamespace, 1844 const char *attrname, struct thread *td) 1845{ 1846 struct mount *mp; 1847 int error; 1848 1849 if ((ioflg & IO_NODELOCKED) == 0) { 1850 if ((error = vn_start_write(vp, &mp, V_WAIT)) != 0) 1851 return (error); 1852 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 1853 } 1854 1855 ASSERT_VOP_LOCKED(vp, "IO_NODELOCKED with no vp lock held"); 1856 1857 /* authorize attribute removal as kernel */ 1858 error = VOP_DELETEEXTATTR(vp, attrnamespace, attrname, NULL, td); 1859 if (error == EOPNOTSUPP) 1860 error = VOP_SETEXTATTR(vp, attrnamespace, attrname, NULL, 1861 NULL, td); 1862 1863 if ((ioflg & IO_NODELOCKED) == 0) { 1864 vn_finished_write(mp); 1865 VOP_UNLOCK(vp, 0); 1866 } 1867 1868 return (error); 1869} 1870 1871int 1872vn_vget_ino(struct vnode *vp, ino_t ino, int lkflags, struct vnode **rvp) 1873{ 1874 struct mount *mp; 1875 int ltype, error; 1876 1877 mp = vp->v_mount; 1878 ltype = VOP_ISLOCKED(vp); 1879 KASSERT(ltype == LK_EXCLUSIVE || ltype == LK_SHARED, 1880 ("vn_vget_ino: vp not locked")); 1881 error = vfs_busy(mp, MBF_NOWAIT); 1882 if (error != 0) { 1883 vfs_ref(mp); 1884 VOP_UNLOCK(vp, 0); 1885 error = vfs_busy(mp, 0); 1886 vn_lock(vp, ltype | LK_RETRY); 1887 vfs_rel(mp); 1888 if (error != 0) 1889 return (ENOENT); 1890 if (vp->v_iflag & VI_DOOMED) { 1891 vfs_unbusy(mp); 1892 return (ENOENT); 1893 } 1894 } 1895 VOP_UNLOCK(vp, 0); 1896 error = VFS_VGET(mp, ino, lkflags, rvp); 1897 vfs_unbusy(mp); 1898 vn_lock(vp, ltype | LK_RETRY); 1899 if (vp->v_iflag & VI_DOOMED) { 1900 if (error == 0) 1901 vput(*rvp); 1902 error = ENOENT; 1903 } 1904 return (error); 1905} 1906 1907int 1908vn_rlimit_fsize(const struct vnode *vp, const struct uio *uio, 1909 const struct thread *td) 1910{ 1911 1912 if (vp->v_type != VREG || td == NULL) 1913 return (0); 1914 PROC_LOCK(td->td_proc); 1915 if ((uoff_t)uio->uio_offset + uio->uio_resid > 1916 lim_cur(td->td_proc, RLIMIT_FSIZE)) { 1917 kern_psignal(td->td_proc, SIGXFSZ); 1918 PROC_UNLOCK(td->td_proc); 1919 return (EFBIG); 1920 } 1921 PROC_UNLOCK(td->td_proc); 1922 return (0); 1923} 1924 1925int 1926vn_chmod(struct file *fp, mode_t mode, struct ucred *active_cred, 1927 struct thread *td) 1928{ 1929 struct vnode *vp; 1930 1931 vp = fp->f_vnode; 1932#ifdef AUDIT 1933 vn_lock(vp, LK_SHARED | LK_RETRY); 1934 AUDIT_ARG_VNODE1(vp); 1935 VOP_UNLOCK(vp, 0); 1936#endif 1937 return (setfmode(td, active_cred, vp, mode)); 1938} 1939 1940int 1941vn_chown(struct file *fp, uid_t uid, gid_t gid, struct ucred *active_cred, 1942 struct thread *td) 1943{ 1944 struct vnode *vp; 1945 1946 vp = fp->f_vnode; 1947#ifdef AUDIT 1948 vn_lock(vp, LK_SHARED | LK_RETRY); 1949 AUDIT_ARG_VNODE1(vp); 1950 VOP_UNLOCK(vp, 0); 1951#endif 1952 return (setfown(td, active_cred, vp, uid, gid)); 1953} 1954 1955void 1956vn_pages_remove(struct vnode *vp, vm_pindex_t start, vm_pindex_t end) 1957{ 1958 vm_object_t object; 1959 1960 if ((object = vp->v_object) == NULL) 1961 return; 1962 VM_OBJECT_WLOCK(object); 1963 vm_object_page_remove(object, start, end, 0); 1964 VM_OBJECT_WUNLOCK(object); 1965} 1966 1967int 1968vn_bmap_seekhole(struct vnode *vp, u_long cmd, off_t *off, struct ucred *cred) 1969{ 1970 struct vattr va; 1971 daddr_t bn, bnp; 1972 uint64_t bsize; 1973 off_t noff; 1974 int error; 1975 1976 KASSERT(cmd == FIOSEEKHOLE || cmd == FIOSEEKDATA, 1977 ("Wrong command %lu", cmd)); 1978 1979 if (vn_lock(vp, LK_SHARED) != 0) 1980 return (EBADF); 1981 if (vp->v_type != VREG) { 1982 error = ENOTTY; 1983 goto unlock; 1984 } 1985 error = VOP_GETATTR(vp, &va, cred); 1986 if (error != 0) 1987 goto unlock; 1988 noff = *off; 1989 if (noff >= va.va_size) { 1990 error = ENXIO; 1991 goto unlock; 1992 } 1993 bsize = vp->v_mount->mnt_stat.f_iosize; 1994 for (bn = noff / bsize; noff < va.va_size; bn++, noff += bsize) { 1995 error = VOP_BMAP(vp, bn, NULL, &bnp, NULL, NULL); 1996 if (error == EOPNOTSUPP) { 1997 error = ENOTTY; 1998 goto unlock; 1999 } 2000 if ((bnp == -1 && cmd == FIOSEEKHOLE) || 2001 (bnp != -1 && cmd == FIOSEEKDATA)) { 2002 noff = bn * bsize; 2003 if (noff < *off) 2004 noff = *off; 2005 goto unlock; 2006 } 2007 } 2008 if (noff > va.va_size) 2009 noff = va.va_size; 2010 /* noff == va.va_size. There is an implicit hole at the end of file. */ 2011 if (cmd == FIOSEEKDATA) 2012 error = ENXIO; 2013unlock: 2014 VOP_UNLOCK(vp, 0); 2015 if (error == 0) 2016 *off = noff; 2017 return (error); 2018} 2019 2020int 2021vn_seek(struct file *fp, off_t offset, int whence, struct thread *td) 2022{ 2023 struct ucred *cred; 2024 struct vnode *vp; 2025 struct vattr vattr; 2026 off_t foffset, size; 2027 int error, noneg; 2028 2029 cred = td->td_ucred; 2030 vp = fp->f_vnode; 2031 foffset = foffset_lock(fp, 0); 2032 noneg = (vp->v_type != VCHR); 2033 error = 0; 2034 switch (whence) { 2035 case L_INCR: 2036 if (noneg && 2037 (foffset < 0 || 2038 (offset > 0 && foffset > OFF_MAX - offset))) { 2039 error = EOVERFLOW; 2040 break; 2041 } 2042 offset += foffset; 2043 break; 2044 case L_XTND: 2045 vn_lock(vp, LK_SHARED | LK_RETRY); 2046 error = VOP_GETATTR(vp, &vattr, cred); 2047 VOP_UNLOCK(vp, 0); 2048 if (error) 2049 break; 2050 2051 /* 2052 * If the file references a disk device, then fetch 2053 * the media size and use that to determine the ending 2054 * offset. 2055 */ 2056 if (vattr.va_size == 0 && vp->v_type == VCHR && 2057 fo_ioctl(fp, DIOCGMEDIASIZE, &size, cred, td) == 0) 2058 vattr.va_size = size; 2059 if (noneg && 2060 (vattr.va_size > OFF_MAX || 2061 (offset > 0 && vattr.va_size > OFF_MAX - offset))) { 2062 error = EOVERFLOW; 2063 break; 2064 } 2065 offset += vattr.va_size; 2066 break; 2067 case L_SET: 2068 break; 2069 case SEEK_DATA: 2070 error = fo_ioctl(fp, FIOSEEKDATA, &offset, cred, td); 2071 break; 2072 case SEEK_HOLE: 2073 error = fo_ioctl(fp, FIOSEEKHOLE, &offset, cred, td); 2074 break; 2075 default: 2076 error = EINVAL; 2077 } 2078 if (error == 0 && noneg && offset < 0) 2079 error = EINVAL; 2080 if (error != 0) 2081 goto drop; 2082 VFS_KNOTE_UNLOCKED(vp, 0); 2083 *(off_t *)(td->td_retval) = offset; 2084drop: 2085 foffset_unlock(fp, offset, error != 0 ? FOF_NOUPDATE : 0); 2086 return (error); 2087} 2088 2089int 2090vn_utimes_perm(struct vnode *vp, struct vattr *vap, struct ucred *cred, 2091 struct thread *td) 2092{ 2093 int error; 2094 2095 error = VOP_ACCESSX(vp, VWRITE_ATTRIBUTES, cred, td); 2096 2097 /* 2098 * From utimes(2): 2099 * Grant permission if the caller is the owner of the file or 2100 * the super-user. If the time pointer is null, then write 2101 * permission on the file is also sufficient. 2102 * 2103 * From NFSv4.1, draft 21, 6.2.1.3.1, Discussion of Mask Attributes: 2104 * A user having ACL_WRITE_DATA or ACL_WRITE_ATTRIBUTES 2105 * will be allowed to set the times [..] to the current 2106 * server time. 2107 */ 2108 if (error != 0 && (vap->va_vaflags & VA_UTIMES_NULL) != 0) 2109 error = VOP_ACCESS(vp, VWRITE, cred, td); 2110 return (error); 2111} 2112