sys/kern/vfs_vnops.c

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