sys/kern/vfs_vnops.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  *
   4  * Copyright (c) 1982, 1986, 1989, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  * (c) UNIX System Laboratories, Inc.
   7  * All or some portions of this file are derived from material licensed
   8  * to the University of California by American Telephone and Telegraph
   9  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
  10  * the permission of UNIX System Laboratories, Inc.
  11  *
  12  * Copyright (c) 2012 Konstantin Belousov <kib@FreeBSD.org>
  13  * Copyright (c) 2013, 2014 The FreeBSD Foundation
  14  *
  15  * Portions of this software were developed by Konstantin Belousov
  16  * under sponsorship from the FreeBSD Foundation.
  17  *
  18  * Redistribution and use in source and binary forms, with or without
  19  * modification, are permitted provided that the following conditions
  20  * are met:
  21  * 1. Redistributions of source code must retain the above copyright
  22  *    notice, this list of conditions and the following disclaimer.
  23  * 2. Redistributions in binary form must reproduce the above copyright
  24  *    notice, this list of conditions and the following disclaimer in the
  25  *    documentation and/or other materials provided with the distribution.
  26  * 3. Neither the name of the University nor the names of its contributors
  27  *    may be used to endorse or promote products derived from this software
  28  *    without specific prior written permission.
  29  *
  30  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  31  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  32  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  33  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  34  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  35  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  36  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  37  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  38  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  39  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  40  * SUCH DAMAGE.
  41  *
  42  *      @(#)vfs_vnops.c 8.2 (Berkeley) 1/21/94
  43  */
  44
  45 #include <sys/cdefs.h>
  46 __FBSDID("$FreeBSD$");
  47
  48 #include "opt_hwpmc_hooks.h"
  49
  50 #include <sys/param.h>
  51 #include <sys/systm.h>
  52 #include <sys/disk.h>
  53 #include <sys/fail.h>
  54 #include <sys/fcntl.h>
  55 #include <sys/file.h>
  56 #include <sys/kdb.h>
  57 #include <sys/ktr.h>
  58 #include <sys/stat.h>
  59 #include <sys/priv.h>
  60 #include <sys/proc.h>
  61 #include <sys/limits.h>
  62 #include <sys/lock.h>
  63 #include <sys/mman.h>
  64 #include <sys/mount.h>
  65 #include <sys/mutex.h>
  66 #include <sys/namei.h>
  67 #include <sys/vnode.h>
  68 #include <sys/bio.h>
  69 #include <sys/buf.h>
  70 #include <sys/filio.h>
  71 #include <sys/resourcevar.h>
  72 #include <sys/rwlock.h>
  73 #include <sys/prng.h>
  74 #include <sys/sx.h>
  75 #include <sys/sleepqueue.h>
  76 #include <sys/sysctl.h>
  77 #include <sys/ttycom.h>
  78 #include <sys/conf.h>
  79 #include <sys/syslog.h>
  80 #include <sys/unistd.h>
  81 #include <sys/user.h>
  82 #include <sys/ktrace.h>
  83
  84 #include <security/audit/audit.h>
  85 #include <security/mac/mac_framework.h>
  86
  87 #include <vm/vm.h>
  88 #include <vm/vm_extern.h>
  89 #include <vm/pmap.h>
  90 #include <vm/vm_map.h>
  91 #include <vm/vm_object.h>
  92 #include <vm/vm_page.h>
  93 #include <vm/vm_pager.h>
  94
  95 #ifdef HWPMC_HOOKS
  96 #include <sys/pmckern.h>
  97 #endif
  98
  99 static fo_rdwr_t        vn_read;
 100 static fo_rdwr_t        vn_write;
 101 static fo_rdwr_t        vn_io_fault;
 102 static fo_truncate_t    vn_truncate;
 103 static fo_ioctl_t       vn_ioctl;
 104 static fo_poll_t        vn_poll;
 105 static fo_kqfilter_t    vn_kqfilter;
 106 static fo_close_t       vn_closefile;
 107 static fo_mmap_t        vn_mmap;
 108 static fo_fallocate_t   vn_fallocate;
 109
 110 struct  fileops vnops = {
 111         .fo_read = vn_io_fault,
 112         .fo_write = vn_io_fault,
 113         .fo_truncate = vn_truncate,
 114         .fo_ioctl = vn_ioctl,
 115         .fo_poll = vn_poll,
 116         .fo_kqfilter = vn_kqfilter,
 117         .fo_stat = vn_statfile,
 118         .fo_close = vn_closefile,
 119         .fo_chmod = vn_chmod,
 120         .fo_chown = vn_chown,
 121         .fo_sendfile = vn_sendfile,
 122         .fo_seek = vn_seek,
 123         .fo_fill_kinfo = vn_fill_kinfo,
 124         .fo_mmap = vn_mmap,
 125         .fo_fallocate = vn_fallocate,
 126         .fo_flags = DFLAG_PASSABLE | DFLAG_SEEKABLE
 127 };
 128
 129 const u_int io_hold_cnt = 16;
 130 static int vn_io_fault_enable = 1;
 131 SYSCTL_INT(_debug, OID_AUTO, vn_io_fault_enable, CTLFLAG_RWTUN,
 132     &vn_io_fault_enable, 0, "Enable vn_io_fault lock avoidance");
 133 static int vn_io_fault_prefault = 0;
 134 SYSCTL_INT(_debug, OID_AUTO, vn_io_fault_prefault, CTLFLAG_RWTUN,
 135     &vn_io_fault_prefault, 0, "Enable vn_io_fault prefaulting");
 136 static int vn_io_pgcache_read_enable = 1;
 137 SYSCTL_INT(_debug, OID_AUTO, vn_io_pgcache_read_enable, CTLFLAG_RWTUN,
 138     &vn_io_pgcache_read_enable, 0,
 139     "Enable copying from page cache for reads, avoiding fs");
 140 static u_long vn_io_faults_cnt;
 141 SYSCTL_ULONG(_debug, OID_AUTO, vn_io_faults, CTLFLAG_RD,
 142     &vn_io_faults_cnt, 0, "Count of vn_io_fault lock avoidance triggers");
 143
 144 static int vfs_allow_read_dir = 0;
 145 SYSCTL_INT(_security_bsd, OID_AUTO, allow_read_dir, CTLFLAG_RW,
 146     &vfs_allow_read_dir, 0,
 147     "Enable read(2) of directory by root for filesystems that support it");
 148
 149 /*
 150  * Returns true if vn_io_fault mode of handling the i/o request should
 151  * be used.
 152  */
 153 static bool
 154 do_vn_io_fault(struct vnode *vp, struct uio *uio)
 155 {
 156         struct mount *mp;
 157
 158         return (uio->uio_segflg == UIO_USERSPACE && vp->v_type == VREG &&
 159             (mp = vp->v_mount) != NULL &&
 160             (mp->mnt_kern_flag & MNTK_NO_IOPF) != 0 && vn_io_fault_enable);
 161 }
 162
 163 /*
 164  * Structure used to pass arguments to vn_io_fault1(), to do either
 165  * file- or vnode-based I/O calls.
 166  */
 167 struct vn_io_fault_args {
 168         enum {
 169                 VN_IO_FAULT_FOP,
 170                 VN_IO_FAULT_VOP
 171         } kind;
 172         struct ucred *cred;
 173         int flags;
 174         union {
 175                 struct fop_args_tag {
 176                         struct file *fp;
 177                         fo_rdwr_t *doio;
 178                 } fop_args;
 179                 struct vop_args_tag {
 180                         struct vnode *vp;
 181                 } vop_args;
 182         } args;
 183 };
 184
 185 static int vn_io_fault1(struct vnode *vp, struct uio *uio,
 186     struct vn_io_fault_args *args, struct thread *td);
 187
 188 int
 189 vn_open(struct nameidata *ndp, int *flagp, int cmode, struct file *fp)
 190 {
 191         struct thread *td = ndp->ni_cnd.cn_thread;
 192
 193         return (vn_open_cred(ndp, flagp, cmode, 0, td->td_ucred, fp));
 194 }
 195
 196 static uint64_t
 197 open2nameif(int fmode, u_int vn_open_flags)
 198 {
 199         uint64_t res;
 200
 201         res = ISOPEN | LOCKLEAF;
 202         if ((fmode & O_RESOLVE_BENEATH) != 0)
 203                 res |= RBENEATH;
 204         if ((fmode & O_EMPTY_PATH) != 0)
 205                 res |= EMPTYPATH;
 206         if ((vn_open_flags & VN_OPEN_NOAUDIT) == 0)
 207                 res |= AUDITVNODE1;
 208         if ((vn_open_flags & VN_OPEN_NOCAPCHECK) != 0)
 209                 res |= NOCAPCHECK;
 210         return (res);
 211 }
 212
 213 /*
 214  * Common code for vnode open operations via a name lookup.
 215  * Lookup the vnode and invoke VOP_CREATE if needed.
 216  * Check permissions, and call the VOP_OPEN or VOP_CREATE routine.
 217  *
 218  * Note that this does NOT free nameidata for the successful case,
 219  * due to the NDINIT being done elsewhere.
 220  */
 221 int
 222 vn_open_cred(struct nameidata *ndp, int *flagp, int cmode, u_int vn_open_flags,
 223     struct ucred *cred, struct file *fp)
 224 {
 225         struct vnode *vp;
 226         struct mount *mp;
 227         struct thread *td = ndp->ni_cnd.cn_thread;
 228         struct vattr vat;
 229         struct vattr *vap = &vat;
 230         int fmode, error;
 231         bool first_open;
 232
 233 restart:
 234         first_open = false;
 235         fmode = *flagp;
 236         if ((fmode & (O_CREAT | O_EXCL | O_DIRECTORY)) == (O_CREAT |
 237             O_EXCL | O_DIRECTORY) ||
 238             (fmode & (O_CREAT | O_EMPTY_PATH)) == (O_CREAT | O_EMPTY_PATH))
 239                 return (EINVAL);
 240         else if ((fmode & (O_CREAT | O_DIRECTORY)) == O_CREAT) {
 241                 ndp->ni_cnd.cn_nameiop = CREATE;
 242                 ndp->ni_cnd.cn_flags = open2nameif(fmode, vn_open_flags);
 243                 /*
 244                  * Set NOCACHE to avoid flushing the cache when
 245                  * rolling in many files at once.
 246                  *
 247                  * Set NC_KEEPPOSENTRY to keep positive entries if they already
 248                  * exist despite NOCACHE.
 249                  */
 250                 ndp->ni_cnd.cn_flags |= LOCKPARENT | NOCACHE | NC_KEEPPOSENTRY;
 251                 if ((fmode & O_EXCL) == 0 && (fmode & O_NOFOLLOW) == 0)
 252                         ndp->ni_cnd.cn_flags |= FOLLOW;
 253                 if ((vn_open_flags & VN_OPEN_INVFS) == 0)
 254                         bwillwrite();
 255                 if ((error = namei(ndp)) != 0)
 256                         return (error);
 257                 if (ndp->ni_vp == NULL) {
 258                         VATTR_NULL(vap);
 259                         vap->va_type = VREG;
 260                         vap->va_mode = cmode;
 261                         if (fmode & O_EXCL)
 262                                 vap->va_vaflags |= VA_EXCLUSIVE;
 263                         if (vn_start_write(ndp->ni_dvp, &mp, V_NOWAIT) != 0) {
 264                                 NDFREE(ndp, NDF_ONLY_PNBUF);
 265                                 vput(ndp->ni_dvp);
 266                                 if ((error = vn_start_write(NULL, &mp,
 267                                     V_XSLEEP | PCATCH)) != 0)
 268                                         return (error);
 269                                 NDREINIT(ndp);
 270                                 goto restart;
 271                         }
 272                         if ((vn_open_flags & VN_OPEN_NAMECACHE) != 0)
 273                                 ndp->ni_cnd.cn_flags |= MAKEENTRY;
 274 #ifdef MAC
 275                         error = mac_vnode_check_create(cred, ndp->ni_dvp,
 276                             &ndp->ni_cnd, vap);
 277                         if (error == 0)
 278 #endif
 279                                 error = VOP_CREATE(ndp->ni_dvp, &ndp->ni_vp,
 280                                     &ndp->ni_cnd, vap);
 281                         vp = ndp->ni_vp;
 282                         if (error == 0 && (fmode & O_EXCL) != 0 &&
 283                             (fmode & (O_EXLOCK | O_SHLOCK)) != 0) {
 284                                 VI_LOCK(vp);
 285                                 vp->v_iflag |= VI_FOPENING;
 286                                 VI_UNLOCK(vp);
 287                                 first_open = true;
 288                         }
 289                         VOP_VPUT_PAIR(ndp->ni_dvp, error == 0 ? &vp : NULL,
 290                             false);
 291                         vn_finished_write(mp);
 292                         if (error) {
 293                                 NDFREE(ndp, NDF_ONLY_PNBUF);
 294                                 if (error == ERELOOKUP) {
 295                                         NDREINIT(ndp);
 296                                         goto restart;
 297                                 }
 298                                 return (error);
 299                         }
 300                         fmode &= ~O_TRUNC;
 301                 } else {
 302                         if (ndp->ni_dvp == ndp->ni_vp)
 303                                 vrele(ndp->ni_dvp);
 304                         else
 305                                 vput(ndp->ni_dvp);
 306                         ndp->ni_dvp = NULL;
 307                         vp = ndp->ni_vp;
 308                         if (fmode & O_EXCL) {
 309                                 error = EEXIST;
 310                                 goto bad;
 311                         }
 312                         if (vp->v_type == VDIR) {
 313                                 error = EISDIR;
 314                                 goto bad;
 315                         }
 316                         fmode &= ~O_CREAT;
 317                 }
 318         } else {
 319                 ndp->ni_cnd.cn_nameiop = LOOKUP;
 320                 ndp->ni_cnd.cn_flags = open2nameif(fmode, vn_open_flags);
 321                 ndp->ni_cnd.cn_flags |= (fmode & O_NOFOLLOW) != 0 ? NOFOLLOW :
 322                     FOLLOW;
 323                 if ((fmode & FWRITE) == 0)
 324                         ndp->ni_cnd.cn_flags |= LOCKSHARED;
 325                 if ((error = namei(ndp)) != 0)
 326                         return (error);
 327                 vp = ndp->ni_vp;
 328         }
 329         error = vn_open_vnode(vp, fmode, cred, td, fp);
 330         if (first_open) {
 331                 VI_LOCK(vp);
 332                 vp->v_iflag &= ~VI_FOPENING;
 333                 wakeup(vp);
 334                 VI_UNLOCK(vp);
 335         }
 336         if (error)
 337                 goto bad;
 338         *flagp = fmode;
 339         return (0);
 340 bad:
 341         NDFREE(ndp, NDF_ONLY_PNBUF);
 342         vput(vp);
 343         *flagp = fmode;
 344         ndp->ni_vp = NULL;
 345         return (error);
 346 }
 347
 348 static int
 349 vn_open_vnode_advlock(struct vnode *vp, int fmode, struct file *fp)
 350 {
 351         struct flock lf;
 352         int error, lock_flags, type;
 353
 354         ASSERT_VOP_LOCKED(vp, "vn_open_vnode_advlock");
 355         if ((fmode & (O_EXLOCK | O_SHLOCK)) == 0)
 356                 return (0);
 357         KASSERT(fp != NULL, ("open with flock requires fp"));
 358         if (fp->f_type != DTYPE_NONE && fp->f_type != DTYPE_VNODE)
 359                 return (EOPNOTSUPP);
 360
 361         lock_flags = VOP_ISLOCKED(vp);
 362         VOP_UNLOCK(vp);
 363
 364         lf.l_whence = SEEK_SET;
 365         lf.l_start = 0;
 366         lf.l_len = 0;
 367         lf.l_type = (fmode & O_EXLOCK) != 0 ? F_WRLCK : F_RDLCK;
 368         type = F_FLOCK;
 369         if ((fmode & FNONBLOCK) == 0)
 370                 type |= F_WAIT;
 371         if ((fmode & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
 372                 type |= F_FIRSTOPEN;
 373         error = VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf, type);
 374         if (error == 0)
 375                 fp->f_flag |= FHASLOCK;
 376
 377         vn_lock(vp, lock_flags | LK_RETRY);
 378         return (error);
 379 }
 380
 381 /*
 382  * Common code for vnode open operations once a vnode is located.
 383  * Check permissions, and call the VOP_OPEN routine.
 384  */
 385 int
 386 vn_open_vnode(struct vnode *vp, int fmode, struct ucred *cred,
 387     struct thread *td, struct file *fp)
 388 {
 389         accmode_t accmode;
 390         int error;
 391
 392         if (vp->v_type == VLNK) {
 393                 if ((fmode & O_PATH) == 0 || (fmode & FEXEC) != 0)
 394                         return (EMLINK);
 395         }
 396         if (vp->v_type == VSOCK)
 397                 return (EOPNOTSUPP);
 398         if (vp->v_type != VDIR && fmode & O_DIRECTORY)
 399                 return (ENOTDIR);
 400
 401         accmode = 0;
 402         if ((fmode & O_PATH) == 0) {
 403                 if ((fmode & (FWRITE | O_TRUNC)) != 0) {
 404                         if (vp->v_type == VDIR)
 405                                 return (EISDIR);
 406                         accmode |= VWRITE;
 407                 }
 408                 if ((fmode & FREAD) != 0)
 409                         accmode |= VREAD;
 410                 if ((fmode & O_APPEND) && (fmode & FWRITE))
 411                         accmode |= VAPPEND;
 412 #ifdef MAC
 413                 if ((fmode & O_CREAT) != 0)
 414                         accmode |= VCREAT;
 415 #endif
 416         }
 417         if ((fmode & FEXEC) != 0)
 418                 accmode |= VEXEC;
 419 #ifdef MAC
 420         if ((fmode & O_VERIFY) != 0)
 421                 accmode |= VVERIFY;
 422         error = mac_vnode_check_open(cred, vp, accmode);
 423         if (error != 0)
 424                 return (error);
 425
 426         accmode &= ~(VCREAT | VVERIFY);
 427 #endif
 428         if ((fmode & O_CREAT) == 0 && accmode != 0) {
 429                 error = VOP_ACCESS(vp, accmode, cred, td);
 430                 if (error != 0)
 431                         return (error);
 432         }
 433         if ((fmode & O_PATH) != 0) {
 434                 if (vp->v_type == VFIFO)
 435                         error = EPIPE;
 436                 else
 437                         error = VOP_ACCESS(vp, VREAD, cred, td);
 438                 if (error == 0)
 439                         fp->f_flag |= FKQALLOWED;
 440                 return (0);
 441         }
 442
 443         if (vp->v_type == VFIFO && VOP_ISLOCKED(vp) != LK_EXCLUSIVE)
 444                 vn_lock(vp, LK_UPGRADE | LK_RETRY);
 445         error = VOP_OPEN(vp, fmode, cred, td, fp);
 446         if (error != 0)
 447                 return (error);
 448
 449         error = vn_open_vnode_advlock(vp, fmode, fp);
 450         if (error == 0 && (fmode & FWRITE) != 0) {
 451                 error = VOP_ADD_WRITECOUNT(vp, 1);
 452                 if (error == 0) {
 453                         CTR3(KTR_VFS, "%s: vp %p v_writecount increased to %d",
 454                              __func__, vp, vp->v_writecount);
 455                 }
 456         }
 457
 458         /*
 459          * Error from advlock or VOP_ADD_WRITECOUNT() still requires
 460          * calling VOP_CLOSE() to pair with earlier VOP_OPEN().
 461          */
 462         if (error != 0) {
 463                 if (fp != NULL) {
 464                         /*
 465                          * Arrange the call by having fdrop() to use
 466                          * vn_closefile().  This is to satisfy
 467                          * filesystems like devfs or tmpfs, which
 468                          * override fo_close().
 469                          */
 470                         fp->f_flag |= FOPENFAILED;
 471                         fp->f_vnode = vp;
 472                         if (fp->f_ops == &badfileops) {
 473                                 fp->f_type = DTYPE_VNODE;
 474                                 fp->f_ops = &vnops;
 475                         }
 476                         vref(vp);
 477                 } else {
 478                         /*
 479                          * If there is no fp, due to kernel-mode open,
 480                          * we can call VOP_CLOSE() now.
 481                          */
 482                         if (vp->v_type != VFIFO && (fmode & FWRITE) != 0 &&
 483                             !MNT_EXTENDED_SHARED(vp->v_mount) &&
 484                             VOP_ISLOCKED(vp) != LK_EXCLUSIVE)
 485                                 vn_lock(vp, LK_UPGRADE | LK_RETRY);
 486                         (void)VOP_CLOSE(vp, fmode & (FREAD | FWRITE | FEXEC),
 487                             cred, td);
 488                 }
 489         }
 490
 491         ASSERT_VOP_LOCKED(vp, "vn_open_vnode");
 492         return (error);
 493
 494 }
 495
 496 /*
 497  * Check for write permissions on the specified vnode.
 498  * Prototype text segments cannot be written.
 499  * It is racy.
 500  */
 501 int
 502 vn_writechk(struct vnode *vp)
 503 {
 504
 505         ASSERT_VOP_LOCKED(vp, "vn_writechk");
 506         /*
 507          * If there's shared text associated with
 508          * the vnode, try to free it up once.  If
 509          * we fail, we can't allow writing.
 510          */
 511         if (VOP_IS_TEXT(vp))
 512                 return (ETXTBSY);
 513
 514         return (0);
 515 }
 516
 517 /*
 518  * Vnode close call
 519  */
 520 static int
 521 vn_close1(struct vnode *vp, int flags, struct ucred *file_cred,
 522     struct thread *td, bool keep_ref)
 523 {
 524         struct mount *mp;
 525         int error, lock_flags;
 526
 527         if (vp->v_type != VFIFO && (flags & FWRITE) == 0 &&
 528             MNT_EXTENDED_SHARED(vp->v_mount))
 529                 lock_flags = LK_SHARED;
 530         else
 531                 lock_flags = LK_EXCLUSIVE;
 532
 533         vn_start_write(vp, &mp, V_WAIT);
 534         vn_lock(vp, lock_flags | LK_RETRY);
 535         AUDIT_ARG_VNODE1(vp);
 536         if ((flags & (FWRITE | FOPENFAILED)) == FWRITE) {
 537                 VOP_ADD_WRITECOUNT_CHECKED(vp, -1);
 538                 CTR3(KTR_VFS, "%s: vp %p v_writecount decreased to %d",
 539                     __func__, vp, vp->v_writecount);
 540         }
 541         error = VOP_CLOSE(vp, flags, file_cred, td);
 542         if (keep_ref)
 543                 VOP_UNLOCK(vp);
 544         else
 545                 vput(vp);
 546         vn_finished_write(mp);
 547         return (error);
 548 }
 549
 550 int
 551 vn_close(struct vnode *vp, int flags, struct ucred *file_cred,
 552     struct thread *td)
 553 {
 554
 555         return (vn_close1(vp, flags, file_cred, td, false));
 556 }
 557
 558 /*
 559  * Heuristic to detect sequential operation.
 560  */
 561 static int
 562 sequential_heuristic(struct uio *uio, struct file *fp)
 563 {
 564         enum uio_rw rw;
 565
 566         ASSERT_VOP_LOCKED(fp->f_vnode, __func__);
 567
 568         rw = uio->uio_rw;
 569         if (fp->f_flag & FRDAHEAD)
 570                 return (fp->f_seqcount[rw] << IO_SEQSHIFT);
 571
 572         /*
 573          * Offset 0 is handled specially.  open() sets f_seqcount to 1 so
 574          * that the first I/O is normally considered to be slightly
 575          * sequential.  Seeking to offset 0 doesn't change sequentiality
 576          * unless previous seeks have reduced f_seqcount to 0, in which
 577          * case offset 0 is not special.
 578          */
 579         if ((uio->uio_offset == 0 && fp->f_seqcount[rw] > 0) ||
 580             uio->uio_offset == fp->f_nextoff[rw]) {
 581                 /*
 582                  * f_seqcount is in units of fixed-size blocks so that it
 583                  * depends mainly on the amount of sequential I/O and not
 584                  * much on the number of sequential I/O's.  The fixed size
 585                  * of 16384 is hard-coded here since it is (not quite) just
 586                  * a magic size that works well here.  This size is more
 587                  * closely related to the best I/O size for real disks than
 588                  * to any block size used by software.
 589                  */
 590                 if (uio->uio_resid >= IO_SEQMAX * 16384)
 591                         fp->f_seqcount[rw] = IO_SEQMAX;
 592                 else {
 593                         fp->f_seqcount[rw] += howmany(uio->uio_resid, 16384);
 594                         if (fp->f_seqcount[rw] > IO_SEQMAX)
 595                                 fp->f_seqcount[rw] = IO_SEQMAX;
 596                 }
 597                 return (fp->f_seqcount[rw] << IO_SEQSHIFT);
 598         }
 599
 600         /* Not sequential.  Quickly draw-down sequentiality. */
 601         if (fp->f_seqcount[rw] > 1)
 602                 fp->f_seqcount[rw] = 1;
 603         else
 604                 fp->f_seqcount[rw] = 0;
 605         return (0);
 606 }
 607
 608 /*
 609  * Package up an I/O request on a vnode into a uio and do it.
 610  */
 611 int
 612 vn_rdwr(enum uio_rw rw, struct vnode *vp, void *base, int len, off_t offset,
 613     enum uio_seg segflg, int ioflg, struct ucred *active_cred,
 614     struct ucred *file_cred, ssize_t *aresid, struct thread *td)
 615 {
 616         struct uio auio;
 617         struct iovec aiov;
 618         struct mount *mp;
 619         struct ucred *cred;
 620         void *rl_cookie;
 621         struct vn_io_fault_args args;
 622         int error, lock_flags;
 623
 624         if (offset < 0 && vp->v_type != VCHR)
 625                 return (EINVAL);
 626         auio.uio_iov = &aiov;
 627         auio.uio_iovcnt = 1;
 628         aiov.iov_base = base;
 629         aiov.iov_len = len;
 630         auio.uio_resid = len;
 631         auio.uio_offset = offset;
 632         auio.uio_segflg = segflg;
 633         auio.uio_rw = rw;
 634         auio.uio_td = td;
 635         error = 0;
 636
 637         if ((ioflg & IO_NODELOCKED) == 0) {
 638                 if ((ioflg & IO_RANGELOCKED) == 0) {
 639                         if (rw == UIO_READ) {
 640                                 rl_cookie = vn_rangelock_rlock(vp, offset,
 641                                     offset + len);
 642                         } else if ((ioflg & IO_APPEND) != 0) {
 643                                 rl_cookie = vn_rangelock_wlock(vp, 0, OFF_MAX);
 644                         } else {
 645                                 rl_cookie = vn_rangelock_wlock(vp, offset,
 646                                     offset + len);
 647                         }
 648                 } else
 649                         rl_cookie = NULL;
 650                 mp = NULL;
 651                 if (rw == UIO_WRITE) {
 652                         if (vp->v_type != VCHR &&
 653                             (error = vn_start_write(vp, &mp, V_WAIT | PCATCH))
 654                             != 0)
 655                                 goto out;
 656                         if (MNT_SHARED_WRITES(mp) ||
 657                             ((mp == NULL) && MNT_SHARED_WRITES(vp->v_mount)))
 658                                 lock_flags = LK_SHARED;
 659                         else
 660                                 lock_flags = LK_EXCLUSIVE;
 661                 } else
 662                         lock_flags = LK_SHARED;
 663                 vn_lock(vp, lock_flags | LK_RETRY);
 664         } else
 665                 rl_cookie = NULL;
 666
 667         ASSERT_VOP_LOCKED(vp, "IO_NODELOCKED with no vp lock held");
 668 #ifdef MAC
 669         if ((ioflg & IO_NOMACCHECK) == 0) {
 670                 if (rw == UIO_READ)
 671                         error = mac_vnode_check_read(active_cred, file_cred,
 672                             vp);
 673                 else
 674                         error = mac_vnode_check_write(active_cred, file_cred,
 675                             vp);
 676         }
 677 #endif
 678         if (error == 0) {
 679                 if (file_cred != NULL)
 680                         cred = file_cred;
 681                 else
 682                         cred = active_cred;
 683                 if (do_vn_io_fault(vp, &auio)) {
 684                         args.kind = VN_IO_FAULT_VOP;
 685                         args.cred = cred;
 686                         args.flags = ioflg;
 687                         args.args.vop_args.vp = vp;
 688                         error = vn_io_fault1(vp, &auio, &args, td);
 689                 } else if (rw == UIO_READ) {
 690                         error = VOP_READ(vp, &auio, ioflg, cred);
 691                 } else /* if (rw == UIO_WRITE) */ {
 692                         error = VOP_WRITE(vp, &auio, ioflg, cred);
 693                 }
 694         }
 695         if (aresid)
 696                 *aresid = auio.uio_resid;
 697         else
 698                 if (auio.uio_resid && error == 0)
 699                         error = EIO;
 700         if ((ioflg & IO_NODELOCKED) == 0) {
 701                 VOP_UNLOCK(vp);
 702                 if (mp != NULL)
 703                         vn_finished_write(mp);
 704         }
 705  out:
 706         if (rl_cookie != NULL)
 707                 vn_rangelock_unlock(vp, rl_cookie);
 708         return (error);
 709 }
 710
 711 /*
 712  * Package up an I/O request on a vnode into a uio and do it.  The I/O
 713  * request is split up into smaller chunks and we try to avoid saturating
 714  * the buffer cache while potentially holding a vnode locked, so we
 715  * check bwillwrite() before calling vn_rdwr().  We also call kern_yield()
 716  * to give other processes a chance to lock the vnode (either other processes
 717  * core'ing the same binary, or unrelated processes scanning the directory).
 718  */
 719 int
 720 vn_rdwr_inchunks(enum uio_rw rw, struct vnode *vp, void *base, size_t len,
 721     off_t offset, enum uio_seg segflg, int ioflg, struct ucred *active_cred,
 722     struct ucred *file_cred, size_t *aresid, struct thread *td)
 723 {
 724         int error = 0;
 725         ssize_t iaresid;
 726
 727         do {
 728                 int chunk;
 729
 730                 /*
 731                  * Force `offset' to a multiple of MAXBSIZE except possibly
 732                  * for the first chunk, so that filesystems only need to
 733                  * write full blocks except possibly for the first and last
 734                  * chunks.
 735                  */
 736                 chunk = MAXBSIZE - (uoff_t)offset % MAXBSIZE;
 737
 738                 if (chunk > len)
 739                         chunk = len;
 740                 if (rw != UIO_READ && vp->v_type == VREG)
 741                         bwillwrite();
 742                 iaresid = 0;
 743                 error = vn_rdwr(rw, vp, base, chunk, offset, segflg,
 744                     ioflg, active_cred, file_cred, &iaresid, td);
 745                 len -= chunk;   /* aresid calc already includes length */
 746                 if (error)
 747                         break;
 748                 offset += chunk;
 749                 base = (char *)base + chunk;
 750                 kern_yield(PRI_USER);
 751         } while (len);
 752         if (aresid)
 753                 *aresid = len + iaresid;
 754         return (error);
 755 }
 756
 757 #if OFF_MAX <= LONG_MAX
 758 off_t
 759 foffset_lock(struct file *fp, int flags)
 760 {
 761         volatile short *flagsp;
 762         off_t res;
 763         short state;
 764
 765         KASSERT((flags & FOF_OFFSET) == 0, ("FOF_OFFSET passed"));
 766
 767         if ((flags & FOF_NOLOCK) != 0)
 768                 return (atomic_load_long(&fp->f_offset));
 769
 770         /*
 771          * According to McKusick the vn lock was protecting f_offset here.
 772          * It is now protected by the FOFFSET_LOCKED flag.
 773          */
 774         flagsp = &fp->f_vnread_flags;
 775         if (atomic_cmpset_acq_16(flagsp, 0, FOFFSET_LOCKED))
 776                 return (atomic_load_long(&fp->f_offset));
 777
 778         sleepq_lock(&fp->f_vnread_flags);
 779         state = atomic_load_16(flagsp);
 780         for (;;) {
 781                 if ((state & FOFFSET_LOCKED) == 0) {
 782                         if (!atomic_fcmpset_acq_16(flagsp, &state,
 783                             FOFFSET_LOCKED))
 784                                 continue;
 785                         break;
 786                 }
 787                 if ((state & FOFFSET_LOCK_WAITING) == 0) {
 788                         if (!atomic_fcmpset_acq_16(flagsp, &state,
 789                             state | FOFFSET_LOCK_WAITING))
 790                                 continue;
 791                 }
 792                 DROP_GIANT();
 793                 sleepq_add(&fp->f_vnread_flags, NULL, "vofflock", 0, 0);
 794                 sleepq_wait(&fp->f_vnread_flags, PUSER -1);
 795                 PICKUP_GIANT();
 796                 sleepq_lock(&fp->f_vnread_flags);
 797                 state = atomic_load_16(flagsp);
 798         }
 799         res = atomic_load_long(&fp->f_offset);
 800         sleepq_release(&fp->f_vnread_flags);
 801         return (res);
 802 }
 803
 804 void
 805 foffset_unlock(struct file *fp, off_t val, int flags)
 806 {
 807         volatile short *flagsp;
 808         short state;
 809
 810         KASSERT((flags & FOF_OFFSET) == 0, ("FOF_OFFSET passed"));
 811
 812         if ((flags & FOF_NOUPDATE) == 0)
 813                 atomic_store_long(&fp->f_offset, val);
 814         if ((flags & FOF_NEXTOFF_R) != 0)
 815                 fp->f_nextoff[UIO_READ] = val;
 816         if ((flags & FOF_NEXTOFF_W) != 0)
 817                 fp->f_nextoff[UIO_WRITE] = val;
 818
 819         if ((flags & FOF_NOLOCK) != 0)
 820                 return;
 821
 822         flagsp = &fp->f_vnread_flags;
 823         state = atomic_load_16(flagsp);
 824         if ((state & FOFFSET_LOCK_WAITING) == 0 &&
 825             atomic_cmpset_rel_16(flagsp, state, 0))
 826                 return;
 827
 828         sleepq_lock(&fp->f_vnread_flags);
 829         MPASS((fp->f_vnread_flags & FOFFSET_LOCKED) != 0);
 830         MPASS((fp->f_vnread_flags & FOFFSET_LOCK_WAITING) != 0);
 831         fp->f_vnread_flags = 0;
 832         sleepq_broadcast(&fp->f_vnread_flags, SLEEPQ_SLEEP, 0, 0);
 833         sleepq_release(&fp->f_vnread_flags);
 834 }
 835 #else
 836 off_t
 837 foffset_lock(struct file *fp, int flags)
 838 {
 839         struct mtx *mtxp;
 840         off_t res;
 841
 842         KASSERT((flags & FOF_OFFSET) == 0, ("FOF_OFFSET passed"));
 843
 844         mtxp = mtx_pool_find(mtxpool_sleep, fp);
 845         mtx_lock(mtxp);
 846         if ((flags & FOF_NOLOCK) == 0) {
 847                 while (fp->f_vnread_flags & FOFFSET_LOCKED) {
 848                         fp->f_vnread_flags |= FOFFSET_LOCK_WAITING;
 849                         msleep(&fp->f_vnread_flags, mtxp, PUSER -1,
 850                             "vofflock", 0);
 851                 }
 852                 fp->f_vnread_flags |= FOFFSET_LOCKED;
 853         }
 854         res = fp->f_offset;
 855         mtx_unlock(mtxp);
 856         return (res);
 857 }
 858
 859 void
 860 foffset_unlock(struct file *fp, off_t val, int flags)
 861 {
 862         struct mtx *mtxp;
 863
 864         KASSERT((flags & FOF_OFFSET) == 0, ("FOF_OFFSET passed"));
 865
 866         mtxp = mtx_pool_find(mtxpool_sleep, fp);
 867         mtx_lock(mtxp);
 868         if ((flags & FOF_NOUPDATE) == 0)
 869                 fp->f_offset = val;
 870         if ((flags & FOF_NEXTOFF_R) != 0)
 871                 fp->f_nextoff[UIO_READ] = val;
 872         if ((flags & FOF_NEXTOFF_W) != 0)
 873                 fp->f_nextoff[UIO_WRITE] = val;
 874         if ((flags & FOF_NOLOCK) == 0) {
 875                 KASSERT((fp->f_vnread_flags & FOFFSET_LOCKED) != 0,
 876                     ("Lost FOFFSET_LOCKED"));
 877                 if (fp->f_vnread_flags & FOFFSET_LOCK_WAITING)
 878                         wakeup(&fp->f_vnread_flags);
 879                 fp->f_vnread_flags = 0;
 880         }
 881         mtx_unlock(mtxp);
 882 }
 883 #endif
 884
 885 void
 886 foffset_lock_uio(struct file *fp, struct uio *uio, int flags)
 887 {
 888
 889         if ((flags & FOF_OFFSET) == 0)
 890                 uio->uio_offset = foffset_lock(fp, flags);
 891 }
 892
 893 void
 894 foffset_unlock_uio(struct file *fp, struct uio *uio, int flags)
 895 {
 896
 897         if ((flags & FOF_OFFSET) == 0)
 898                 foffset_unlock(fp, uio->uio_offset, flags);
 899 }
 900
 901 static int
 902 get_advice(struct file *fp, struct uio *uio)
 903 {
 904         struct mtx *mtxp;
 905         int ret;
 906
 907         ret = POSIX_FADV_NORMAL;
 908         if (fp->f_advice == NULL || fp->f_vnode->v_type != VREG)
 909                 return (ret);
 910
 911         mtxp = mtx_pool_find(mtxpool_sleep, fp);
 912         mtx_lock(mtxp);
 913         if (fp->f_advice != NULL &&
 914             uio->uio_offset >= fp->f_advice->fa_start &&
 915             uio->uio_offset + uio->uio_resid <= fp->f_advice->fa_end)
 916                 ret = fp->f_advice->fa_advice;
 917         mtx_unlock(mtxp);
 918         return (ret);
 919 }
 920
 921 int
 922 vn_read_from_obj(struct vnode *vp, struct uio *uio)
 923 {
 924         vm_object_t obj;
 925         vm_page_t ma[io_hold_cnt + 2];
 926         off_t off, vsz;
 927         ssize_t resid;
 928         int error, i, j;
 929
 930         MPASS(uio->uio_resid <= ptoa(io_hold_cnt + 2));
 931         obj = atomic_load_ptr(&vp->v_object);
 932         if (obj == NULL)
 933                 return (EJUSTRETURN);
 934
 935         /*
 936          * Depends on type stability of vm_objects.
 937          */
 938         vm_object_pip_add(obj, 1);
 939         if ((obj->flags & OBJ_DEAD) != 0) {
 940                 /*
 941                  * Note that object might be already reused from the
 942                  * vnode, and the OBJ_DEAD flag cleared.  This is fine,
 943                  * we recheck for DOOMED vnode state after all pages
 944                  * are busied, and retract then.
 945                  *
 946                  * But we check for OBJ_DEAD to ensure that we do not
 947                  * busy pages while vm_object_terminate_pages()
 948                  * processes the queue.
 949                  */
 950                 error = EJUSTRETURN;
 951                 goto out_pip;
 952         }
 953
 954         resid = uio->uio_resid;
 955         off = uio->uio_offset;
 956         for (i = 0; resid > 0; i++) {
 957                 MPASS(i < io_hold_cnt + 2);
 958                 ma[i] = vm_page_grab_unlocked(obj, atop(off),
 959                     VM_ALLOC_NOCREAT | VM_ALLOC_SBUSY | VM_ALLOC_IGN_SBUSY |
 960                     VM_ALLOC_NOWAIT);
 961                 if (ma[i] == NULL)
 962                         break;
 963
 964                 /*
 965                  * Skip invalid pages.  Valid mask can be partial only
 966                  * at EOF, and we clip later.
 967                  */
 968                 if (vm_page_none_valid(ma[i])) {
 969                         vm_page_sunbusy(ma[i]);
 970                         break;
 971                 }
 972
 973                 resid -= PAGE_SIZE;
 974                 off += PAGE_SIZE;
 975         }
 976         if (i == 0) {
 977                 error = EJUSTRETURN;
 978                 goto out_pip;
 979         }
 980
 981         /*
 982          * Check VIRF_DOOMED after we busied our pages.  Since
 983          * vgonel() terminates the vnode' vm_object, it cannot
 984          * process past pages busied by us.
 985          */
 986         if (VN_IS_DOOMED(vp)) {
 987                 error = EJUSTRETURN;
 988                 goto out;
 989         }
 990
 991         resid = PAGE_SIZE - (uio->uio_offset & PAGE_MASK) + ptoa(i - 1);
 992         if (resid > uio->uio_resid)
 993                 resid = uio->uio_resid;
 994
 995         /*
 996          * Unlocked read of vnp_size is safe because truncation cannot
 997          * pass busied page.  But we load vnp_size into a local
 998          * variable so that possible concurrent extension does not
 999          * break calculation.
1000          */
1001 #if defined(__powerpc__) && !defined(__powerpc64__)
1002         vsz = obj->un_pager.vnp.vnp_size;
1003 #else
1004         vsz = atomic_load_64(&obj->un_pager.vnp.vnp_size);
1005 #endif
1006         if (uio->uio_offset >= vsz) {
1007                 error = EJUSTRETURN;
1008                 goto out;
1009         }
1010         if (uio->uio_offset + resid > vsz)
1011                 resid = vsz - uio->uio_offset;
1012
1013         error = vn_io_fault_pgmove(ma, uio->uio_offset & PAGE_MASK, resid, uio);
1014
1015 out:
1016         for (j = 0; j < i; j++) {
1017                 if (error == 0)
1018                         vm_page_reference(ma[j]);
1019                 vm_page_sunbusy(ma[j]);
1020         }
1021 out_pip:
1022         vm_object_pip_wakeup(obj);
1023         if (error != 0)
1024                 return (error);
1025         return (uio->uio_resid == 0 ? 0 : EJUSTRETURN);
1026 }
1027
1028 /*
1029  * File table vnode read routine.
1030  */
1031 static int
1032 vn_read(struct file *fp, struct uio *uio, struct ucred *active_cred, int flags,
1033     struct thread *td)
1034 {
1035         struct vnode *vp;
1036         off_t orig_offset;
1037         int error, ioflag;
1038         int advice;
1039
1040         KASSERT(uio->uio_td == td, ("uio_td %p is not td %p",
1041             uio->uio_td, td));
1042         KASSERT(flags & FOF_OFFSET, ("No FOF_OFFSET"));
1043         vp = fp->f_vnode;
1044         ioflag = 0;
1045         if (fp->f_flag & FNONBLOCK)
1046                 ioflag |= IO_NDELAY;
1047         if (fp->f_flag & O_DIRECT)
1048                 ioflag |= IO_DIRECT;
1049
1050         /*
1051          * Try to read from page cache.  VIRF_DOOMED check is racy but
1052          * allows us to avoid unneeded work outright.
1053          */
1054         if (vn_io_pgcache_read_enable && !mac_vnode_check_read_enabled() &&
1055             (vn_irflag_read(vp) & (VIRF_DOOMED | VIRF_PGREAD)) == VIRF_PGREAD) {
1056                 error = VOP_READ_PGCACHE(vp, uio, ioflag, fp->f_cred);
1057                 if (error == 0) {
1058                         fp->f_nextoff[UIO_READ] = uio->uio_offset;
1059                         return (0);
1060                 }
1061                 if (error != EJUSTRETURN)
1062                         return (error);
1063         }
1064
1065         advice = get_advice(fp, uio);
1066         vn_lock(vp, LK_SHARED | LK_RETRY);
1067
1068         switch (advice) {
1069         case POSIX_FADV_NORMAL:
1070         case POSIX_FADV_SEQUENTIAL:
1071         case POSIX_FADV_NOREUSE:
1072                 ioflag |= sequential_heuristic(uio, fp);
1073                 break;
1074         case POSIX_FADV_RANDOM:
1075                 /* Disable read-ahead for random I/O. */
1076                 break;
1077         }
1078         orig_offset = uio->uio_offset;
1079
1080 #ifdef MAC
1081         error = mac_vnode_check_read(active_cred, fp->f_cred, vp);
1082         if (error == 0)
1083 #endif
1084                 error = VOP_READ(vp, uio, ioflag, fp->f_cred);
1085         fp->f_nextoff[UIO_READ] = uio->uio_offset;
1086         VOP_UNLOCK(vp);
1087         if (error == 0 && advice == POSIX_FADV_NOREUSE &&
1088             orig_offset != uio->uio_offset)
1089                 /*
1090                  * Use POSIX_FADV_DONTNEED to flush pages and buffers
1091                  * for the backing file after a POSIX_FADV_NOREUSE
1092                  * read(2).
1093                  */
1094                 error = VOP_ADVISE(vp, orig_offset, uio->uio_offset - 1,
1095                     POSIX_FADV_DONTNEED);
1096         return (error);
1097 }
1098
1099 /*
1100  * File table vnode write routine.
1101  */
1102 static int
1103 vn_write(struct file *fp, struct uio *uio, struct ucred *active_cred, int flags,
1104     struct thread *td)
1105 {
1106         struct vnode *vp;
1107         struct mount *mp;
1108         off_t orig_offset;
1109         int error, ioflag, lock_flags;
1110         int advice;
1111         bool need_finished_write;
1112
1113         KASSERT(uio->uio_td == td, ("uio_td %p is not td %p",
1114             uio->uio_td, td));
1115         KASSERT(flags & FOF_OFFSET, ("No FOF_OFFSET"));
1116         vp = fp->f_vnode;
1117         if (vp->v_type == VREG)
1118                 bwillwrite();
1119         ioflag = IO_UNIT;
1120         if (vp->v_type == VREG && (fp->f_flag & O_APPEND))
1121                 ioflag |= IO_APPEND;
1122         if (fp->f_flag & FNONBLOCK)
1123                 ioflag |= IO_NDELAY;
1124         if (fp->f_flag & O_DIRECT)
1125                 ioflag |= IO_DIRECT;
1126
1127         mp = atomic_load_ptr(&vp->v_mount);
1128         if ((fp->f_flag & O_FSYNC) ||
1129             (mp != NULL && (mp->mnt_flag & MNT_SYNCHRONOUS)))
1130                 ioflag |= IO_SYNC;
1131
1132         /*
1133          * For O_DSYNC we set both IO_SYNC and IO_DATASYNC, so that VOP_WRITE()
1134          * implementations that don't understand IO_DATASYNC fall back to full
1135          * O_SYNC behavior.
1136          */
1137         if (fp->f_flag & O_DSYNC)
1138                 ioflag |= IO_SYNC | IO_DATASYNC;
1139         mp = NULL;
1140         need_finished_write = false;
1141         if (vp->v_type != VCHR) {
1142                 error = vn_start_write(vp, &mp, V_WAIT | PCATCH);
1143                 if (error != 0)
1144                         goto unlock;
1145                 need_finished_write = true;
1146         }
1147
1148         advice = get_advice(fp, uio);
1149
1150         if (MNT_SHARED_WRITES(mp) ||
1151             (mp == NULL && MNT_SHARED_WRITES(vp->v_mount))) {
1152                 lock_flags = LK_SHARED;
1153         } else {
1154                 lock_flags = LK_EXCLUSIVE;
1155         }
1156
1157         vn_lock(vp, lock_flags | LK_RETRY);
1158         switch (advice) {
1159         case POSIX_FADV_NORMAL:
1160         case POSIX_FADV_SEQUENTIAL:
1161         case POSIX_FADV_NOREUSE:
1162                 ioflag |= sequential_heuristic(uio, fp);
1163                 break;
1164         case POSIX_FADV_RANDOM:
1165                 /* XXX: Is this correct? */
1166                 break;
1167         }
1168         orig_offset = uio->uio_offset;
1169
1170 #ifdef MAC
1171         error = mac_vnode_check_write(active_cred, fp->f_cred, vp);
1172         if (error == 0)
1173 #endif
1174                 error = VOP_WRITE(vp, uio, ioflag, fp->f_cred);
1175         fp->f_nextoff[UIO_WRITE] = uio->uio_offset;
1176         VOP_UNLOCK(vp);
1177         if (need_finished_write)
1178                 vn_finished_write(mp);
1179         if (error == 0 && advice == POSIX_FADV_NOREUSE &&
1180             orig_offset != uio->uio_offset)
1181                 /*
1182                  * Use POSIX_FADV_DONTNEED to flush pages and buffers
1183                  * for the backing file after a POSIX_FADV_NOREUSE
1184                  * write(2).
1185                  */
1186                 error = VOP_ADVISE(vp, orig_offset, uio->uio_offset - 1,
1187                     POSIX_FADV_DONTNEED);
1188 unlock:
1189         return (error);
1190 }
1191
1192 /*
1193  * The vn_io_fault() is a wrapper around vn_read() and vn_write() to
1194  * prevent the following deadlock:
1195  *
1196  * Assume that the thread A reads from the vnode vp1 into userspace
1197  * buffer buf1 backed by the pages of vnode vp2.  If a page in buf1 is
1198  * currently not resident, then system ends up with the call chain
1199  *   vn_read() -> VOP_READ(vp1) -> uiomove() -> [Page Fault] ->
1200  *     vm_fault(buf1) -> vnode_pager_getpages(vp2) -> VOP_GETPAGES(vp2)
1201  * which establishes lock order vp1->vn_lock, then vp2->vn_lock.
1202  * If, at the same time, thread B reads from vnode vp2 into buffer buf2
1203  * backed by the pages of vnode vp1, and some page in buf2 is not
1204  * resident, we get a reversed order vp2->vn_lock, then vp1->vn_lock.
1205  *
1206  * To prevent the lock order reversal and deadlock, vn_io_fault() does
1207  * not allow page faults to happen during VOP_READ() or VOP_WRITE().
1208  * Instead, it first tries to do the whole range i/o with pagefaults
1209  * disabled. If all pages in the i/o buffer are resident and mapped,
1210  * VOP will succeed (ignoring the genuine filesystem errors).
1211  * Otherwise, we get back EFAULT, and vn_io_fault() falls back to do
1212  * i/o in chunks, with all pages in the chunk prefaulted and held
1213  * using vm_fault_quick_hold_pages().
1214  *
1215  * Filesystems using this deadlock avoidance scheme should use the
1216  * array of the held pages from uio, saved in the curthread->td_ma,
1217  * instead of doing uiomove().  A helper function
1218  * vn_io_fault_uiomove() converts uiomove request into
1219  * uiomove_fromphys() over td_ma array.
1220  *
1221  * Since vnode locks do not cover the whole i/o anymore, rangelocks
1222  * make the current i/o request atomic with respect to other i/os and
1223  * truncations.
1224  */
1225
1226 /*
1227  * Decode vn_io_fault_args and perform the corresponding i/o.
1228  */
1229 static int
1230 vn_io_fault_doio(struct vn_io_fault_args *args, struct uio *uio,
1231     struct thread *td)
1232 {
1233         int error, save;
1234
1235         error = 0;
1236         save = vm_fault_disable_pagefaults();
1237         switch (args->kind) {
1238         case VN_IO_FAULT_FOP:
1239                 error = (args->args.fop_args.doio)(args->args.fop_args.fp,
1240                     uio, args->cred, args->flags, td);
1241                 break;
1242         case VN_IO_FAULT_VOP:
1243                 if (uio->uio_rw == UIO_READ) {
1244                         error = VOP_READ(args->args.vop_args.vp, uio,
1245                             args->flags, args->cred);
1246                 } else if (uio->uio_rw == UIO_WRITE) {
1247                         error = VOP_WRITE(args->args.vop_args.vp, uio,
1248                             args->flags, args->cred);
1249                 }
1250                 break;
1251         default:
1252                 panic("vn_io_fault_doio: unknown kind of io %d %d",
1253                     args->kind, uio->uio_rw);
1254         }
1255         vm_fault_enable_pagefaults(save);
1256         return (error);
1257 }
1258
1259 static int
1260 vn_io_fault_touch(char *base, const struct uio *uio)
1261 {
1262         int r;
1263
1264         r = fubyte(base);
1265         if (r == -1 || (uio->uio_rw == UIO_READ && subyte(base, r) == -1))
1266                 return (EFAULT);
1267         return (0);
1268 }
1269
1270 static int
1271 vn_io_fault_prefault_user(const struct uio *uio)
1272 {
1273         char *base;
1274         const struct iovec *iov;
1275         size_t len;
1276         ssize_t resid;
1277         int error, i;
1278
1279         KASSERT(uio->uio_segflg == UIO_USERSPACE,
1280             ("vn_io_fault_prefault userspace"));
1281
1282         error = i = 0;
1283         iov = uio->uio_iov;
1284         resid = uio->uio_resid;
1285         base = iov->iov_base;
1286         len = iov->iov_len;
1287         while (resid > 0) {
1288                 error = vn_io_fault_touch(base, uio);
1289                 if (error != 0)
1290                         break;
1291                 if (len < PAGE_SIZE) {
1292                         if (len != 0) {
1293                                 error = vn_io_fault_touch(base + len - 1, uio);
1294                                 if (error != 0)
1295                                         break;
1296                                 resid -= len;
1297                         }
1298                         if (++i >= uio->uio_iovcnt)
1299                                 break;
1300                         iov = uio->uio_iov + i;
1301                         base = iov->iov_base;
1302                         len = iov->iov_len;
1303                 } else {
1304                         len -= PAGE_SIZE;
1305                         base += PAGE_SIZE;
1306                         resid -= PAGE_SIZE;
1307                 }
1308         }
1309         return (error);
1310 }
1311
1312 /*
1313  * Common code for vn_io_fault(), agnostic to the kind of i/o request.
1314  * Uses vn_io_fault_doio() to make the call to an actual i/o function.
1315  * Used from vn_rdwr() and vn_io_fault(), which encode the i/o request
1316  * into args and call vn_io_fault1() to handle faults during the user
1317  * mode buffer accesses.
1318  */
1319 static int
1320 vn_io_fault1(struct vnode *vp, struct uio *uio, struct vn_io_fault_args *args,
1321     struct thread *td)
1322 {
1323         vm_page_t ma[io_hold_cnt + 2];
1324         struct uio *uio_clone, short_uio;
1325         struct iovec short_iovec[1];
1326         vm_page_t *prev_td_ma;
1327         vm_prot_t prot;
1328         vm_offset_t addr, end;
1329         size_t len, resid;
1330         ssize_t adv;
1331         int error, cnt, saveheld, prev_td_ma_cnt;
1332
1333         if (vn_io_fault_prefault) {
1334                 error = vn_io_fault_prefault_user(uio);
1335                 if (error != 0)
1336                         return (error); /* Or ignore ? */
1337         }
1338
1339         prot = uio->uio_rw == UIO_READ ? VM_PROT_WRITE : VM_PROT_READ;
1340
1341         /*
1342          * The UFS follows IO_UNIT directive and replays back both
1343          * uio_offset and uio_resid if an error is encountered during the
1344          * operation.  But, since the iovec may be already advanced,
1345          * uio is still in an inconsistent state.
1346          *
1347          * Cache a copy of the original uio, which is advanced to the redo
1348          * point using UIO_NOCOPY below.
1349          */
1350         uio_clone = cloneuio(uio);
1351         resid = uio->uio_resid;
1352
1353         short_uio.uio_segflg = UIO_USERSPACE;
1354         short_uio.uio_rw = uio->uio_rw;
1355         short_uio.uio_td = uio->uio_td;
1356
1357         error = vn_io_fault_doio(args, uio, td);
1358         if (error != EFAULT)
1359                 goto out;
1360
1361         atomic_add_long(&vn_io_faults_cnt, 1);
1362         uio_clone->uio_segflg = UIO_NOCOPY;
1363         uiomove(NULL, resid - uio->uio_resid, uio_clone);
1364         uio_clone->uio_segflg = uio->uio_segflg;
1365
1366         saveheld = curthread_pflags_set(TDP_UIOHELD);
1367         prev_td_ma = td->td_ma;
1368         prev_td_ma_cnt = td->td_ma_cnt;
1369
1370         while (uio_clone->uio_resid != 0) {
1371                 len = uio_clone->uio_iov->iov_len;
1372                 if (len == 0) {
1373                         KASSERT(uio_clone->uio_iovcnt >= 1,
1374                             ("iovcnt underflow"));
1375                         uio_clone->uio_iov++;
1376                         uio_clone->uio_iovcnt--;
1377                         continue;
1378                 }
1379                 if (len > ptoa(io_hold_cnt))
1380                         len = ptoa(io_hold_cnt);
1381                 addr = (uintptr_t)uio_clone->uio_iov->iov_base;
1382                 end = round_page(addr + len);
1383                 if (end < addr) {
1384                         error = EFAULT;
1385                         break;
1386                 }
1387                 cnt = atop(end - trunc_page(addr));
1388                 /*
1389                  * A perfectly misaligned address and length could cause
1390                  * both the start and the end of the chunk to use partial
1391                  * page.  +2 accounts for such a situation.
1392                  */
1393                 cnt = vm_fault_quick_hold_pages(&td->td_proc->p_vmspace->vm_map,
1394                     addr, len, prot, ma, io_hold_cnt + 2);
1395                 if (cnt == -1) {
1396                         error = EFAULT;
1397                         break;
1398                 }
1399                 short_uio.uio_iov = &short_iovec[0];
1400                 short_iovec[0].iov_base = (void *)addr;
1401                 short_uio.uio_iovcnt = 1;
1402                 short_uio.uio_resid = short_iovec[0].iov_len = len;
1403                 short_uio.uio_offset = uio_clone->uio_offset;
1404                 td->td_ma = ma;
1405                 td->td_ma_cnt = cnt;
1406
1407                 error = vn_io_fault_doio(args, &short_uio, td);
1408                 vm_page_unhold_pages(ma, cnt);
1409                 adv = len - short_uio.uio_resid;
1410
1411                 uio_clone->uio_iov->iov_base =
1412                     (char *)uio_clone->uio_iov->iov_base + adv;
1413                 uio_clone->uio_iov->iov_len -= adv;
1414                 uio_clone->uio_resid -= adv;
1415                 uio_clone->uio_offset += adv;
1416
1417                 uio->uio_resid -= adv;
1418                 uio->uio_offset += adv;
1419
1420                 if (error != 0 || adv == 0)
1421                         break;
1422         }
1423         td->td_ma = prev_td_ma;
1424         td->td_ma_cnt = prev_td_ma_cnt;
1425         curthread_pflags_restore(saveheld);
1426 out:
1427         free(uio_clone, M_IOV);
1428         return (error);
1429 }
1430
1431 static int
1432 vn_io_fault(struct file *fp, struct uio *uio, struct ucred *active_cred,
1433     int flags, struct thread *td)
1434 {
1435         fo_rdwr_t *doio;
1436         struct vnode *vp;
1437         void *rl_cookie;
1438         struct vn_io_fault_args args;
1439         int error;
1440
1441         doio = uio->uio_rw == UIO_READ ? vn_read : vn_write;
1442         vp = fp->f_vnode;
1443
1444         /*
1445          * The ability to read(2) on a directory has historically been
1446          * allowed for all users, but this can and has been the source of
1447          * at least one security issue in the past.  As such, it is now hidden
1448          * away behind a sysctl for those that actually need it to use it, and
1449          * restricted to root when it's turned on to make it relatively safe to
1450          * leave on for longer sessions of need.
1451          */
1452         if (vp->v_type == VDIR) {
1453                 KASSERT(uio->uio_rw == UIO_READ,
1454                     ("illegal write attempted on a directory"));
1455                 if (!vfs_allow_read_dir)
1456                         return (EISDIR);
1457                 if ((error = priv_check(td, PRIV_VFS_READ_DIR)) != 0)
1458                         return (EISDIR);
1459         }
1460
1461         foffset_lock_uio(fp, uio, flags);
1462         if (do_vn_io_fault(vp, uio)) {
1463                 args.kind = VN_IO_FAULT_FOP;
1464                 args.args.fop_args.fp = fp;
1465                 args.args.fop_args.doio = doio;
1466                 args.cred = active_cred;
1467                 args.flags = flags | FOF_OFFSET;
1468                 if (uio->uio_rw == UIO_READ) {
1469                         rl_cookie = vn_rangelock_rlock(vp, uio->uio_offset,
1470                             uio->uio_offset + uio->uio_resid);
1471                 } else if ((fp->f_flag & O_APPEND) != 0 ||
1472                     (flags & FOF_OFFSET) == 0) {
1473                         /* For appenders, punt and lock the whole range. */
1474                         rl_cookie = vn_rangelock_wlock(vp, 0, OFF_MAX);
1475                 } else {
1476                         rl_cookie = vn_rangelock_wlock(vp, uio->uio_offset,
1477                             uio->uio_offset + uio->uio_resid);
1478                 }
1479                 error = vn_io_fault1(vp, uio, &args, td);
1480                 vn_rangelock_unlock(vp, rl_cookie);
1481         } else {
1482                 error = doio(fp, uio, active_cred, flags | FOF_OFFSET, td);
1483         }
1484         foffset_unlock_uio(fp, uio, flags);
1485         return (error);
1486 }
1487
1488 /*
1489  * Helper function to perform the requested uiomove operation using
1490  * the held pages for io->uio_iov[0].iov_base buffer instead of
1491  * copyin/copyout.  Access to the pages with uiomove_fromphys()
1492  * instead of iov_base prevents page faults that could occur due to
1493  * pmap_collect() invalidating the mapping created by
1494  * vm_fault_quick_hold_pages(), or pageout daemon, page laundry or
1495  * object cleanup revoking the write access from page mappings.
1496  *
1497  * Filesystems specified MNTK_NO_IOPF shall use vn_io_fault_uiomove()
1498  * instead of plain uiomove().
1499  */
1500 int
1501 vn_io_fault_uiomove(char *data, int xfersize, struct uio *uio)
1502 {
1503         struct uio transp_uio;
1504         struct iovec transp_iov[1];
1505         struct thread *td;
1506         size_t adv;
1507         int error, pgadv;
1508
1509         td = curthread;
1510         if ((td->td_pflags & TDP_UIOHELD) == 0 ||
1511             uio->uio_segflg != UIO_USERSPACE)
1512                 return (uiomove(data, xfersize, uio));
1513
1514         KASSERT(uio->uio_iovcnt == 1, ("uio_iovcnt %d", uio->uio_iovcnt));
1515         transp_iov[0].iov_base = data;
1516         transp_uio.uio_iov = &transp_iov[0];
1517         transp_uio.uio_iovcnt = 1;
1518         if (xfersize > uio->uio_resid)
1519                 xfersize = uio->uio_resid;
1520         transp_uio.uio_resid = transp_iov[0].iov_len = xfersize;
1521         transp_uio.uio_offset = 0;
1522         transp_uio.uio_segflg = UIO_SYSSPACE;
1523         /*
1524          * Since transp_iov points to data, and td_ma page array
1525          * corresponds to original uio->uio_iov, we need to invert the
1526          * direction of the i/o operation as passed to
1527          * uiomove_fromphys().
1528          */
1529         switch (uio->uio_rw) {
1530         case UIO_WRITE:
1531                 transp_uio.uio_rw = UIO_READ;
1532                 break;
1533         case UIO_READ:
1534                 transp_uio.uio_rw = UIO_WRITE;
1535                 break;
1536         }
1537         transp_uio.uio_td = uio->uio_td;
1538         error = uiomove_fromphys(td->td_ma,
1539             ((vm_offset_t)uio->uio_iov->iov_base) & PAGE_MASK,
1540             xfersize, &transp_uio);
1541         adv = xfersize - transp_uio.uio_resid;
1542         pgadv =
1543             (((vm_offset_t)uio->uio_iov->iov_base + adv) >> PAGE_SHIFT) -
1544             (((vm_offset_t)uio->uio_iov->iov_base) >> PAGE_SHIFT);
1545         td->td_ma += pgadv;
1546         KASSERT(td->td_ma_cnt >= pgadv, ("consumed pages %d %d", td->td_ma_cnt,
1547             pgadv));
1548         td->td_ma_cnt -= pgadv;
1549         uio->uio_iov->iov_base = (char *)uio->uio_iov->iov_base + adv;
1550         uio->uio_iov->iov_len -= adv;
1551         uio->uio_resid -= adv;
1552         uio->uio_offset += adv;
1553         return (error);
1554 }
1555
1556 int
1557 vn_io_fault_pgmove(vm_page_t ma[], vm_offset_t offset, int xfersize,
1558     struct uio *uio)
1559 {
1560         struct thread *td;
1561         vm_offset_t iov_base;
1562         int cnt, pgadv;
1563
1564         td = curthread;
1565         if ((td->td_pflags & TDP_UIOHELD) == 0 ||
1566             uio->uio_segflg != UIO_USERSPACE)
1567                 return (uiomove_fromphys(ma, offset, xfersize, uio));
1568
1569         KASSERT(uio->uio_iovcnt == 1, ("uio_iovcnt %d", uio->uio_iovcnt));
1570         cnt = xfersize > uio->uio_resid ? uio->uio_resid : xfersize;
1571         iov_base = (vm_offset_t)uio->uio_iov->iov_base;
1572         switch (uio->uio_rw) {
1573         case UIO_WRITE:
1574                 pmap_copy_pages(td->td_ma, iov_base & PAGE_MASK, ma,
1575                     offset, cnt);
1576                 break;
1577         case UIO_READ:
1578                 pmap_copy_pages(ma, offset, td->td_ma, iov_base & PAGE_MASK,
1579                     cnt);
1580                 break;
1581         }
1582         pgadv = ((iov_base + cnt) >> PAGE_SHIFT) - (iov_base >> PAGE_SHIFT);
1583         td->td_ma += pgadv;
1584         KASSERT(td->td_ma_cnt >= pgadv, ("consumed pages %d %d", td->td_ma_cnt,
1585             pgadv));
1586         td->td_ma_cnt -= pgadv;
1587         uio->uio_iov->iov_base = (char *)(iov_base + cnt);
1588         uio->uio_iov->iov_len -= cnt;
1589         uio->uio_resid -= cnt;
1590         uio->uio_offset += cnt;
1591         return (0);
1592 }
1593
1594 /*
1595  * File table truncate routine.
1596  */
1597 static int
1598 vn_truncate(struct file *fp, off_t length, struct ucred *active_cred,
1599     struct thread *td)
1600 {
1601         struct mount *mp;
1602         struct vnode *vp;
1603         void *rl_cookie;
1604         int error;
1605
1606         vp = fp->f_vnode;
1607
1608 retry:
1609         /*
1610          * Lock the whole range for truncation.  Otherwise split i/o
1611          * might happen partly before and partly after the truncation.
1612          */
1613         rl_cookie = vn_rangelock_wlock(vp, 0, OFF_MAX);
1614         error = vn_start_write(vp, &mp, V_WAIT | PCATCH);
1615         if (error)
1616                 goto out1;
1617         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
1618         AUDIT_ARG_VNODE1(vp);
1619         if (vp->v_type == VDIR) {
1620                 error = EISDIR;
1621                 goto out;
1622         }
1623 #ifdef MAC
1624         error = mac_vnode_check_write(active_cred, fp->f_cred, vp);
1625         if (error)
1626                 goto out;
1627 #endif
1628         error = vn_truncate_locked(vp, length, (fp->f_flag & O_FSYNC) != 0,
1629             fp->f_cred);
1630 out:
1631         VOP_UNLOCK(vp);
1632         vn_finished_write(mp);
1633 out1:
1634         vn_rangelock_unlock(vp, rl_cookie);
1635         if (error == ERELOOKUP)
1636                 goto retry;
1637         return (error);
1638 }
1639
1640 /*
1641  * Truncate a file that is already locked.
1642  */
1643 int
1644 vn_truncate_locked(struct vnode *vp, off_t length, bool sync,
1645     struct ucred *cred)
1646 {
1647         struct vattr vattr;
1648         int error;
1649
1650         error = VOP_ADD_WRITECOUNT(vp, 1);
1651         if (error == 0) {
1652                 VATTR_NULL(&vattr);
1653                 vattr.va_size = length;
1654                 if (sync)
1655                         vattr.va_vaflags |= VA_SYNC;
1656                 error = VOP_SETATTR(vp, &vattr, cred);
1657                 VOP_ADD_WRITECOUNT_CHECKED(vp, -1);
1658         }
1659         return (error);
1660 }
1661
1662 /*
1663  * File table vnode stat routine.
1664  */
1665 int
1666 vn_statfile(struct file *fp, struct stat *sb, struct ucred *active_cred,
1667     struct thread *td)
1668 {
1669         struct vnode *vp = fp->f_vnode;
1670         int error;
1671
1672         vn_lock(vp, LK_SHARED | LK_RETRY);
1673         error = VOP_STAT(vp, sb, active_cred, fp->f_cred, td);
1674         VOP_UNLOCK(vp);
1675
1676         return (error);
1677 }
1678
1679 /*
1680  * File table vnode ioctl routine.
1681  */
1682 static int
1683 vn_ioctl(struct file *fp, u_long com, void *data, struct ucred *active_cred,
1684     struct thread *td)
1685 {
1686         struct vattr vattr;
1687         struct vnode *vp;
1688         struct fiobmap2_arg *bmarg;
1689         int error;
1690
1691         vp = fp->f_vnode;
1692         switch (vp->v_type) {
1693         case VDIR:
1694         case VREG:
1695                 switch (com) {
1696                 case FIONREAD:
1697                         vn_lock(vp, LK_SHARED | LK_RETRY);
1698                         error = VOP_GETATTR(vp, &vattr, active_cred);
1699                         VOP_UNLOCK(vp);
1700                         if (error == 0)
1701                                 *(int *)data = vattr.va_size - fp->f_offset;
1702                         return (error);
1703                 case FIOBMAP2:
1704                         bmarg = (struct fiobmap2_arg *)data;
1705                         vn_lock(vp, LK_SHARED | LK_RETRY);
1706 #ifdef MAC
1707                         error = mac_vnode_check_read(active_cred, fp->f_cred,
1708                             vp);
1709                         if (error == 0)
1710 #endif
1711                                 error = VOP_BMAP(vp, bmarg->bn, NULL,
1712                                     &bmarg->bn, &bmarg->runp, &bmarg->runb);
1713                         VOP_UNLOCK(vp);
1714                         return (error);
1715                 case FIONBIO:
1716                 case FIOASYNC:
1717                         return (0);
1718                 default:
1719                         return (VOP_IOCTL(vp, com, data, fp->f_flag,
1720                             active_cred, td));
1721                 }
1722                 break;
1723         case VCHR:
1724                 return (VOP_IOCTL(vp, com, data, fp->f_flag,
1725                     active_cred, td));
1726         default:
1727                 return (ENOTTY);
1728         }
1729 }
1730
1731 /*
1732  * File table vnode poll routine.
1733  */
1734 static int
1735 vn_poll(struct file *fp, int events, struct ucred *active_cred,
1736     struct thread *td)
1737 {
1738         struct vnode *vp;
1739         int error;
1740
1741         vp = fp->f_vnode;
1742 #if defined(MAC) || defined(AUDIT)
1743         if (AUDITING_TD(td) || mac_vnode_check_poll_enabled()) {
1744                 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
1745                 AUDIT_ARG_VNODE1(vp);
1746                 error = mac_vnode_check_poll(active_cred, fp->f_cred, vp);
1747                 VOP_UNLOCK(vp);
1748                 if (error != 0)
1749                         return (error);
1750         }
1751 #endif
1752         error = VOP_POLL(vp, events, fp->f_cred, td);
1753         return (error);
1754 }
1755
1756 /*
1757  * Acquire the requested lock and then check for validity.  LK_RETRY
1758  * permits vn_lock to return doomed vnodes.
1759  */
1760 static int __noinline
1761 _vn_lock_fallback(struct vnode *vp, int flags, const char *file, int line,
1762     int error)
1763 {
1764
1765         KASSERT((flags & LK_RETRY) == 0 || error == 0,
1766             ("vn_lock: error %d incompatible with flags %#x", error, flags));
1767
1768         if (error == 0)
1769                 VNASSERT(VN_IS_DOOMED(vp), vp, ("vnode not doomed"));
1770
1771         if ((flags & LK_RETRY) == 0) {
1772                 if (error == 0) {
1773                         VOP_UNLOCK(vp);
1774                         error = ENOENT;
1775                 }
1776                 return (error);
1777         }
1778
1779         /*
1780          * LK_RETRY case.
1781          *
1782          * Nothing to do if we got the lock.
1783          */
1784         if (error == 0)
1785                 return (0);
1786
1787         /*
1788          * Interlock was dropped by the call in _vn_lock.
1789          */
1790         flags &= ~LK_INTERLOCK;
1791         do {
1792                 error = VOP_LOCK1(vp, flags, file, line);
1793         } while (error != 0);
1794         return (0);
1795 }
1796
1797 int
1798 _vn_lock(struct vnode *vp, int flags, const char *file, int line)
1799 {
1800         int error;
1801
1802         VNASSERT((flags & LK_TYPE_MASK) != 0, vp,
1803             ("vn_lock: no locktype (%d passed)", flags));
1804         VNPASS(vp->v_holdcnt > 0, vp);
1805         error = VOP_LOCK1(vp, flags, file, line);
1806         if (__predict_false(error != 0 || VN_IS_DOOMED(vp)))
1807                 return (_vn_lock_fallback(vp, flags, file, line, error));
1808         return (0);
1809 }
1810
1811 /*
1812  * File table vnode close routine.
1813  */
1814 static int
1815 vn_closefile(struct file *fp, struct thread *td)
1816 {
1817         struct vnode *vp;
1818         struct flock lf;
1819         int error;
1820         bool ref;
1821
1822         vp = fp->f_vnode;
1823         fp->f_ops = &badfileops;
1824         ref = (fp->f_flag & FHASLOCK) != 0 && fp->f_type == DTYPE_VNODE;
1825
1826         error = vn_close1(vp, fp->f_flag, fp->f_cred, td, ref);
1827
1828         if (__predict_false(ref)) {
1829                 lf.l_whence = SEEK_SET;
1830                 lf.l_start = 0;
1831                 lf.l_len = 0;
1832                 lf.l_type = F_UNLCK;
1833                 (void) VOP_ADVLOCK(vp, fp, F_UNLCK, &lf, F_FLOCK);
1834                 vrele(vp);
1835         }
1836         return (error);
1837 }
1838
1839 /*
1840  * Preparing to start a filesystem write operation. If the operation is
1841  * permitted, then we bump the count of operations in progress and
1842  * proceed. If a suspend request is in progress, we wait until the
1843  * suspension is over, and then proceed.
1844  */
1845 static int
1846 vn_start_write_refed(struct mount *mp, int flags, bool mplocked)
1847 {
1848         struct mount_pcpu *mpcpu;
1849         int error, mflags;
1850
1851         if (__predict_true(!mplocked) && (flags & V_XSLEEP) == 0 &&
1852             vfs_op_thread_enter(mp, mpcpu)) {
1853                 MPASS((mp->mnt_kern_flag & MNTK_SUSPEND) == 0);
1854                 vfs_mp_count_add_pcpu(mpcpu, writeopcount, 1);
1855                 vfs_op_thread_exit(mp, mpcpu);
1856                 return (0);
1857         }
1858
1859         if (mplocked)
1860                 mtx_assert(MNT_MTX(mp), MA_OWNED);
1861         else
1862                 MNT_ILOCK(mp);
1863
1864         error = 0;
1865
1866         /*
1867          * Check on status of suspension.
1868          */
1869         if ((curthread->td_pflags & TDP_IGNSUSP) == 0 ||
1870             mp->mnt_susp_owner != curthread) {
1871                 mflags = ((mp->mnt_vfc->vfc_flags & VFCF_SBDRY) != 0 ?
1872                     (flags & PCATCH) : 0) | (PUSER - 1);
1873                 while ((mp->mnt_kern_flag & MNTK_SUSPEND) != 0) {
1874                         if (flags & V_NOWAIT) {
1875                                 error = EWOULDBLOCK;
1876                                 goto unlock;
1877                         }
1878                         error = msleep(&mp->mnt_flag, MNT_MTX(mp), mflags,
1879                             "suspfs", 0);
1880                         if (error)
1881                                 goto unlock;
1882                 }
1883         }
1884         if (flags & V_XSLEEP)
1885                 goto unlock;
1886         mp->mnt_writeopcount++;
1887 unlock:
1888         if (error != 0 || (flags & V_XSLEEP) != 0)
1889                 MNT_REL(mp);
1890         MNT_IUNLOCK(mp);
1891         return (error);
1892 }
1893
1894 int
1895 vn_start_write(struct vnode *vp, struct mount **mpp, int flags)
1896 {
1897         struct mount *mp;
1898         int error;
1899
1900         KASSERT((flags & V_MNTREF) == 0 || (*mpp != NULL && vp == NULL),
1901             ("V_MNTREF requires mp"));
1902
1903         error = 0;
1904         /*
1905          * If a vnode is provided, get and return the mount point that
1906          * to which it will write.
1907          */
1908         if (vp != NULL) {
1909                 if ((error = VOP_GETWRITEMOUNT(vp, mpp)) != 0) {
1910                         *mpp = NULL;
1911                         if (error != EOPNOTSUPP)
1912                                 return (error);
1913                         return (0);
1914                 }
1915         }
1916         if ((mp = *mpp) == NULL)
1917                 return (0);
1918
1919         /*
1920          * VOP_GETWRITEMOUNT() returns with the mp refcount held through
1921          * a vfs_ref().
1922          * As long as a vnode is not provided we need to acquire a
1923          * refcount for the provided mountpoint too, in order to
1924          * emulate a vfs_ref().
1925          */
1926         if (vp == NULL && (flags & V_MNTREF) == 0)
1927                 vfs_ref(mp);
1928
1929         return (vn_start_write_refed(mp, flags, false));
1930 }
1931
1932 /*
1933  * Secondary suspension. Used by operations such as vop_inactive
1934  * routines that are needed by the higher level functions. These
1935  * are allowed to proceed until all the higher level functions have
1936  * completed (indicated by mnt_writeopcount dropping to zero). At that
1937  * time, these operations are halted until the suspension is over.
1938  */
1939 int
1940 vn_start_secondary_write(struct vnode *vp, struct mount **mpp, int flags)
1941 {
1942         struct mount *mp;
1943         int error;
1944
1945         KASSERT((flags & V_MNTREF) == 0 || (*mpp != NULL && vp == NULL),
1946             ("V_MNTREF requires mp"));
1947
1948  retry:
1949         if (vp != NULL) {
1950                 if ((error = VOP_GETWRITEMOUNT(vp, mpp)) != 0) {
1951                         *mpp = NULL;
1952                         if (error != EOPNOTSUPP)
1953                                 return (error);
1954                         return (0);
1955                 }
1956         }
1957         /*
1958          * If we are not suspended or have not yet reached suspended
1959          * mode, then let the operation proceed.
1960          */
1961         if ((mp = *mpp) == NULL)
1962                 return (0);
1963
1964         /*
1965          * VOP_GETWRITEMOUNT() returns with the mp refcount held through
1966          * a vfs_ref().
1967          * As long as a vnode is not provided we need to acquire a
1968          * refcount for the provided mountpoint too, in order to
1969          * emulate a vfs_ref().
1970          */
1971         MNT_ILOCK(mp);
1972         if (vp == NULL && (flags & V_MNTREF) == 0)
1973                 MNT_REF(mp);
1974         if ((mp->mnt_kern_flag & (MNTK_SUSPENDED | MNTK_SUSPEND2)) == 0) {
1975                 mp->mnt_secondary_writes++;
1976                 mp->mnt_secondary_accwrites++;
1977                 MNT_IUNLOCK(mp);
1978                 return (0);
1979         }
1980         if (flags & V_NOWAIT) {
1981                 MNT_REL(mp);
1982                 MNT_IUNLOCK(mp);
1983                 return (EWOULDBLOCK);
1984         }
1985         /*
1986          * Wait for the suspension to finish.
1987          */
1988         error = msleep(&mp->mnt_flag, MNT_MTX(mp), (PUSER - 1) | PDROP |
1989             ((mp->mnt_vfc->vfc_flags & VFCF_SBDRY) != 0 ? (flags & PCATCH) : 0),
1990             "suspfs", 0);
1991         vfs_rel(mp);
1992         if (error == 0)
1993                 goto retry;
1994         return (error);
1995 }
1996
1997 /*
1998  * Filesystem write operation has completed. If we are suspending and this
1999  * operation is the last one, notify the suspender that the suspension is
2000  * now in effect.
2001  */
2002 void
2003 vn_finished_write(struct mount *mp)
2004 {
2005         struct mount_pcpu *mpcpu;
2006         int c;
2007
2008         if (mp == NULL)
2009                 return;
2010
2011         if (vfs_op_thread_enter(mp, mpcpu)) {
2012                 vfs_mp_count_sub_pcpu(mpcpu, writeopcount, 1);
2013                 vfs_mp_count_sub_pcpu(mpcpu, ref, 1);
2014                 vfs_op_thread_exit(mp, mpcpu);
2015                 return;
2016         }
2017
2018         MNT_ILOCK(mp);
2019         vfs_assert_mount_counters(mp);
2020         MNT_REL(mp);
2021         c = --mp->mnt_writeopcount;
2022         if (mp->mnt_vfs_ops == 0) {
2023                 MPASS((mp->mnt_kern_flag & MNTK_SUSPEND) == 0);
2024                 MNT_IUNLOCK(mp);
2025                 return;
2026         }
2027         if (c < 0)
2028                 vfs_dump_mount_counters(mp);
2029         if ((mp->mnt_kern_flag & MNTK_SUSPEND) != 0 && c == 0)
2030                 wakeup(&mp->mnt_writeopcount);
2031         MNT_IUNLOCK(mp);
2032 }
2033
2034 /*
2035  * Filesystem secondary write operation has completed. If we are
2036  * suspending and this operation is the last one, notify the suspender
2037  * that the suspension is now in effect.
2038  */
2039 void
2040 vn_finished_secondary_write(struct mount *mp)
2041 {
2042         if (mp == NULL)
2043                 return;
2044         MNT_ILOCK(mp);
2045         MNT_REL(mp);
2046         mp->mnt_secondary_writes--;
2047         if (mp->mnt_secondary_writes < 0)
2048                 panic("vn_finished_secondary_write: neg cnt");
2049         if ((mp->mnt_kern_flag & MNTK_SUSPEND) != 0 &&
2050             mp->mnt_secondary_writes <= 0)
2051                 wakeup(&mp->mnt_secondary_writes);
2052         MNT_IUNLOCK(mp);
2053 }
2054
2055 /*
2056  * Request a filesystem to suspend write operations.
2057  */
2058 int
2059 vfs_write_suspend(struct mount *mp, int flags)
2060 {
2061         int error;
2062
2063         vfs_op_enter(mp);
2064
2065         MNT_ILOCK(mp);
2066         vfs_assert_mount_counters(mp);
2067         if (mp->mnt_susp_owner == curthread) {
2068                 vfs_op_exit_locked(mp);
2069                 MNT_IUNLOCK(mp);
2070                 return (EALREADY);
2071         }
2072         while (mp->mnt_kern_flag & MNTK_SUSPEND)
2073                 msleep(&mp->mnt_flag, MNT_MTX(mp), PUSER - 1, "wsuspfs", 0);
2074
2075         /*
2076          * Unmount holds a write reference on the mount point.  If we
2077          * own busy reference and drain for writers, we deadlock with
2078          * the reference draining in the unmount path.  Callers of
2079          * vfs_write_suspend() must specify VS_SKIP_UNMOUNT if
2080          * vfs_busy() reference is owned and caller is not in the
2081          * unmount context.
2082          */
2083         if ((flags & VS_SKIP_UNMOUNT) != 0 &&
2084             (mp->mnt_kern_flag & MNTK_UNMOUNT) != 0) {
2085                 vfs_op_exit_locked(mp);
2086                 MNT_IUNLOCK(mp);
2087                 return (EBUSY);
2088         }
2089
2090         mp->mnt_kern_flag |= MNTK_SUSPEND;
2091         mp->mnt_susp_owner = curthread;
2092         if (mp->mnt_writeopcount > 0)
2093                 (void) msleep(&mp->mnt_writeopcount,
2094                     MNT_MTX(mp), (PUSER - 1)|PDROP, "suspwt", 0);
2095         else
2096                 MNT_IUNLOCK(mp);
2097         if ((error = VFS_SYNC(mp, MNT_SUSPEND)) != 0) {
2098                 vfs_write_resume(mp, 0);
2099                 /* vfs_write_resume does vfs_op_exit() for us */
2100         }
2101         return (error);
2102 }
2103
2104 /*
2105  * Request a filesystem to resume write operations.
2106  */
2107 void
2108 vfs_write_resume(struct mount *mp, int flags)
2109 {
2110
2111         MNT_ILOCK(mp);
2112         if ((mp->mnt_kern_flag & MNTK_SUSPEND) != 0) {
2113                 KASSERT(mp->mnt_susp_owner == curthread, ("mnt_susp_owner"));
2114                 mp->mnt_kern_flag &= ~(MNTK_SUSPEND | MNTK_SUSPEND2 |
2115                                        MNTK_SUSPENDED);
2116                 mp->mnt_susp_owner = NULL;
2117                 wakeup(&mp->mnt_writeopcount);
2118                 wakeup(&mp->mnt_flag);
2119                 curthread->td_pflags &= ~TDP_IGNSUSP;
2120                 if ((flags & VR_START_WRITE) != 0) {
2121                         MNT_REF(mp);
2122                         mp->mnt_writeopcount++;
2123                 }
2124                 MNT_IUNLOCK(mp);
2125                 if ((flags & VR_NO_SUSPCLR) == 0)
2126                         VFS_SUSP_CLEAN(mp);
2127                 vfs_op_exit(mp);
2128         } else if ((flags & VR_START_WRITE) != 0) {
2129                 MNT_REF(mp);
2130                 vn_start_write_refed(mp, 0, true);
2131         } else {
2132                 MNT_IUNLOCK(mp);
2133         }
2134 }
2135
2136 /*
2137  * Helper loop around vfs_write_suspend() for filesystem unmount VFS
2138  * methods.
2139  */
2140 int
2141 vfs_write_suspend_umnt(struct mount *mp)
2142 {
2143         int error;
2144
2145         KASSERT((curthread->td_pflags & TDP_IGNSUSP) == 0,
2146             ("vfs_write_suspend_umnt: recursed"));
2147
2148         /* dounmount() already called vn_start_write(). */
2149         for (;;) {
2150                 vn_finished_write(mp);
2151                 error = vfs_write_suspend(mp, 0);
2152                 if (error != 0) {
2153                         vn_start_write(NULL, &mp, V_WAIT);
2154                         return (error);
2155                 }
2156                 MNT_ILOCK(mp);
2157                 if ((mp->mnt_kern_flag & MNTK_SUSPENDED) != 0)
2158                         break;
2159                 MNT_IUNLOCK(mp);
2160                 vn_start_write(NULL, &mp, V_WAIT);
2161         }
2162         mp->mnt_kern_flag &= ~(MNTK_SUSPENDED | MNTK_SUSPEND2);
2163         wakeup(&mp->mnt_flag);
2164         MNT_IUNLOCK(mp);
2165         curthread->td_pflags |= TDP_IGNSUSP;
2166         return (0);
2167 }
2168
2169 /*
2170  * Implement kqueues for files by translating it to vnode operation.
2171  */
2172 static int
2173 vn_kqfilter(struct file *fp, struct knote *kn)
2174 {
2175
2176         return (VOP_KQFILTER(fp->f_vnode, kn));
2177 }
2178
2179 int
2180 vn_kqfilter_opath(struct file *fp, struct knote *kn)
2181 {
2182         if ((fp->f_flag & FKQALLOWED) == 0)
2183                 return (EBADF);
2184         return (vn_kqfilter(fp, kn));
2185 }
2186
2187 /*
2188  * Simplified in-kernel wrapper calls for extended attribute access.
2189  * Both calls pass in a NULL credential, authorizing as "kernel" access.
2190  * Set IO_NODELOCKED in ioflg if the vnode is already locked.
2191  */
2192 int
2193 vn_extattr_get(struct vnode *vp, int ioflg, int attrnamespace,
2194     const char *attrname, int *buflen, char *buf, struct thread *td)
2195 {
2196         struct uio      auio;
2197         struct iovec    iov;
2198         int     error;
2199
2200         iov.iov_len = *buflen;
2201         iov.iov_base = buf;
2202
2203         auio.uio_iov = &iov;
2204         auio.uio_iovcnt = 1;
2205         auio.uio_rw = UIO_READ;
2206         auio.uio_segflg = UIO_SYSSPACE;
2207         auio.uio_td = td;
2208         auio.uio_offset = 0;
2209         auio.uio_resid = *buflen;
2210
2211         if ((ioflg & IO_NODELOCKED) == 0)
2212                 vn_lock(vp, LK_SHARED | LK_RETRY);
2213
2214         ASSERT_VOP_LOCKED(vp, "IO_NODELOCKED with no vp lock held");
2215
2216         /* authorize attribute retrieval as kernel */
2217         error = VOP_GETEXTATTR(vp, attrnamespace, attrname, &auio, NULL, NULL,
2218             td);
2219
2220         if ((ioflg & IO_NODELOCKED) == 0)
2221                 VOP_UNLOCK(vp);
2222
2223         if (error == 0) {
2224                 *buflen = *buflen - auio.uio_resid;
2225         }
2226
2227         return (error);
2228 }
2229
2230 /*
2231  * XXX failure mode if partially written?
2232  */
2233 int
2234 vn_extattr_set(struct vnode *vp, int ioflg, int attrnamespace,
2235     const char *attrname, int buflen, char *buf, struct thread *td)
2236 {
2237         struct uio      auio;
2238         struct iovec    iov;
2239         struct mount    *mp;
2240         int     error;
2241
2242         iov.iov_len = buflen;
2243         iov.iov_base = buf;
2244
2245         auio.uio_iov = &iov;
2246         auio.uio_iovcnt = 1;
2247         auio.uio_rw = UIO_WRITE;
2248         auio.uio_segflg = UIO_SYSSPACE;
2249         auio.uio_td = td;
2250         auio.uio_offset = 0;
2251         auio.uio_resid = buflen;
2252
2253         if ((ioflg & IO_NODELOCKED) == 0) {
2254                 if ((error = vn_start_write(vp, &mp, V_WAIT)) != 0)
2255                         return (error);
2256                 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
2257         }
2258
2259         ASSERT_VOP_LOCKED(vp, "IO_NODELOCKED with no vp lock held");
2260
2261         /* authorize attribute setting as kernel */
2262         error = VOP_SETEXTATTR(vp, attrnamespace, attrname, &auio, NULL, td);
2263
2264         if ((ioflg & IO_NODELOCKED) == 0) {
2265                 vn_finished_write(mp);
2266                 VOP_UNLOCK(vp);
2267         }
2268
2269         return (error);
2270 }
2271
2272 int
2273 vn_extattr_rm(struct vnode *vp, int ioflg, int attrnamespace,
2274     const char *attrname, struct thread *td)
2275 {
2276         struct mount    *mp;
2277         int     error;
2278
2279         if ((ioflg & IO_NODELOCKED) == 0) {
2280                 if ((error = vn_start_write(vp, &mp, V_WAIT)) != 0)
2281                         return (error);
2282                 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
2283         }
2284
2285         ASSERT_VOP_LOCKED(vp, "IO_NODELOCKED with no vp lock held");
2286
2287         /* authorize attribute removal as kernel */
2288         error = VOP_DELETEEXTATTR(vp, attrnamespace, attrname, NULL, td);
2289         if (error == EOPNOTSUPP)
2290                 error = VOP_SETEXTATTR(vp, attrnamespace, attrname, NULL,
2291                     NULL, td);
2292
2293         if ((ioflg & IO_NODELOCKED) == 0) {
2294                 vn_finished_write(mp);
2295                 VOP_UNLOCK(vp);
2296         }
2297
2298         return (error);
2299 }
2300
2301 static int
2302 vn_get_ino_alloc_vget(struct mount *mp, void *arg, int lkflags,
2303     struct vnode **rvp)
2304 {
2305
2306         return (VFS_VGET(mp, *(ino_t *)arg, lkflags, rvp));
2307 }
2308
2309 int
2310 vn_vget_ino(struct vnode *vp, ino_t ino, int lkflags, struct vnode **rvp)
2311 {
2312
2313         return (vn_vget_ino_gen(vp, vn_get_ino_alloc_vget, &ino,
2314             lkflags, rvp));
2315 }
2316
2317 int
2318 vn_vget_ino_gen(struct vnode *vp, vn_get_ino_t alloc, void *alloc_arg,
2319     int lkflags, struct vnode **rvp)
2320 {
2321         struct mount *mp;
2322         int ltype, error;
2323
2324         ASSERT_VOP_LOCKED(vp, "vn_vget_ino_get");
2325         mp = vp->v_mount;
2326         ltype = VOP_ISLOCKED(vp);
2327         KASSERT(ltype == LK_EXCLUSIVE || ltype == LK_SHARED,
2328             ("vn_vget_ino: vp not locked"));
2329         error = vfs_busy(mp, MBF_NOWAIT);
2330         if (error != 0) {
2331                 vfs_ref(mp);
2332                 VOP_UNLOCK(vp);
2333                 error = vfs_busy(mp, 0);
2334                 vn_lock(vp, ltype | LK_RETRY);
2335                 vfs_rel(mp);
2336                 if (error != 0)
2337                         return (ENOENT);
2338                 if (VN_IS_DOOMED(vp)) {
2339                         vfs_unbusy(mp);
2340                         return (ENOENT);
2341                 }
2342         }
2343         VOP_UNLOCK(vp);
2344         error = alloc(mp, alloc_arg, lkflags, rvp);
2345         vfs_unbusy(mp);
2346         if (error != 0 || *rvp != vp)
2347                 vn_lock(vp, ltype | LK_RETRY);
2348         if (VN_IS_DOOMED(vp)) {
2349                 if (error == 0) {
2350                         if (*rvp == vp)
2351                                 vunref(vp);
2352                         else
2353                                 vput(*rvp);
2354                 }
2355                 error = ENOENT;
2356         }
2357         return (error);
2358 }
2359
2360 int
2361 vn_rlimit_fsize(const struct vnode *vp, const struct uio *uio,
2362     struct thread *td)
2363 {
2364         off_t lim;
2365         bool ktr_write;
2366
2367         if (td == NULL)
2368                 return (0);
2369
2370         /*
2371          * There are conditions where the limit is to be ignored.
2372          * However, since it is almost never reached, check it first.
2373          */
2374         ktr_write = (td->td_pflags & TDP_INKTRACE) != 0;
2375         lim = lim_cur(td, RLIMIT_FSIZE);
2376         if (__predict_false(ktr_write))
2377                 lim = td->td_ktr_io_lim;
2378         if (__predict_true((uoff_t)uio->uio_offset + uio->uio_resid <= lim))
2379                 return (0);
2380
2381         /*
2382          * The limit is reached.
2383          */
2384         if (vp->v_type != VREG ||
2385             (td->td_pflags2 & TDP2_ACCT) != 0)
2386                 return (0);
2387
2388         if (!ktr_write || ktr_filesize_limit_signal) {
2389                 PROC_LOCK(td->td_proc);
2390                 kern_psignal(td->td_proc, SIGXFSZ);
2391                 PROC_UNLOCK(td->td_proc);
2392         }
2393         return (EFBIG);
2394 }
2395
2396 int
2397 vn_chmod(struct file *fp, mode_t mode, struct ucred *active_cred,
2398     struct thread *td)
2399 {
2400         struct vnode *vp;
2401
2402         vp = fp->f_vnode;
2403 #ifdef AUDIT
2404         vn_lock(vp, LK_SHARED | LK_RETRY);
2405         AUDIT_ARG_VNODE1(vp);
2406         VOP_UNLOCK(vp);
2407 #endif
2408         return (setfmode(td, active_cred, vp, mode));
2409 }
2410
2411 int
2412 vn_chown(struct file *fp, uid_t uid, gid_t gid, struct ucred *active_cred,
2413     struct thread *td)
2414 {
2415         struct vnode *vp;
2416
2417         vp = fp->f_vnode;
2418 #ifdef AUDIT
2419         vn_lock(vp, LK_SHARED | LK_RETRY);
2420         AUDIT_ARG_VNODE1(vp);
2421         VOP_UNLOCK(vp);
2422 #endif
2423         return (setfown(td, active_cred, vp, uid, gid));
2424 }
2425
2426 void
2427 vn_pages_remove(struct vnode *vp, vm_pindex_t start, vm_pindex_t end)
2428 {
2429         vm_object_t object;
2430
2431         if ((object = vp->v_object) == NULL)
2432                 return;
2433         VM_OBJECT_WLOCK(object);
2434         vm_object_page_remove(object, start, end, 0);
2435         VM_OBJECT_WUNLOCK(object);
2436 }
2437
2438 int
2439 vn_bmap_seekhole(struct vnode *vp, u_long cmd, off_t *off, struct ucred *cred)
2440 {
2441         struct vattr va;
2442         daddr_t bn, bnp;
2443         uint64_t bsize;
2444         off_t noff;
2445         int error;
2446
2447         KASSERT(cmd == FIOSEEKHOLE || cmd == FIOSEEKDATA,
2448             ("Wrong command %lu", cmd));
2449
2450         if (vn_lock(vp, LK_SHARED) != 0)
2451                 return (EBADF);
2452         if (vp->v_type != VREG) {
2453                 error = ENOTTY;
2454                 goto unlock;
2455         }
2456         error = VOP_GETATTR(vp, &va, cred);
2457         if (error != 0)
2458                 goto unlock;
2459         noff = *off;
2460         if (noff >= va.va_size) {
2461                 error = ENXIO;
2462                 goto unlock;
2463         }
2464         bsize = vp->v_mount->mnt_stat.f_iosize;
2465         for (bn = noff / bsize; noff < va.va_size; bn++, noff += bsize -
2466             noff % bsize) {
2467                 error = VOP_BMAP(vp, bn, NULL, &bnp, NULL, NULL);
2468                 if (error == EOPNOTSUPP) {
2469                         error = ENOTTY;
2470                         goto unlock;
2471                 }
2472                 if ((bnp == -1 && cmd == FIOSEEKHOLE) ||
2473                     (bnp != -1 && cmd == FIOSEEKDATA)) {
2474                         noff = bn * bsize;
2475                         if (noff < *off)
2476                                 noff = *off;
2477                         goto unlock;
2478                 }
2479         }
2480         if (noff > va.va_size)
2481                 noff = va.va_size;
2482         /* noff == va.va_size. There is an implicit hole at the end of file. */
2483         if (cmd == FIOSEEKDATA)
2484                 error = ENXIO;
2485 unlock:
2486         VOP_UNLOCK(vp);
2487         if (error == 0)
2488                 *off = noff;
2489         return (error);
2490 }
2491
2492 int
2493 vn_seek(struct file *fp, off_t offset, int whence, struct thread *td)
2494 {
2495         struct ucred *cred;
2496         struct vnode *vp;
2497         struct vattr vattr;
2498         off_t foffset, size;
2499         int error, noneg;
2500
2501         cred = td->td_ucred;
2502         vp = fp->f_vnode;
2503         foffset = foffset_lock(fp, 0);
2504         noneg = (vp->v_type != VCHR);
2505         error = 0;
2506         switch (whence) {
2507         case L_INCR:
2508                 if (noneg &&
2509                     (foffset < 0 ||
2510                     (offset > 0 && foffset > OFF_MAX - offset))) {
2511                         error = EOVERFLOW;
2512                         break;
2513                 }
2514                 offset += foffset;
2515                 break;
2516         case L_XTND:
2517                 vn_lock(vp, LK_SHARED | LK_RETRY);
2518                 error = VOP_GETATTR(vp, &vattr, cred);
2519                 VOP_UNLOCK(vp);
2520                 if (error)
2521                         break;
2522
2523                 /*
2524                  * If the file references a disk device, then fetch
2525                  * the media size and use that to determine the ending
2526                  * offset.
2527                  */
2528                 if (vattr.va_size == 0 && vp->v_type == VCHR &&
2529                     fo_ioctl(fp, DIOCGMEDIASIZE, &size, cred, td) == 0)
2530                         vattr.va_size = size;
2531                 if (noneg &&
2532                     (vattr.va_size > OFF_MAX ||
2533                     (offset > 0 && vattr.va_size > OFF_MAX - offset))) {
2534                         error = EOVERFLOW;
2535                         break;
2536                 }
2537                 offset += vattr.va_size;
2538                 break;
2539         case L_SET:
2540                 break;
2541         case SEEK_DATA:
2542                 error = fo_ioctl(fp, FIOSEEKDATA, &offset, cred, td);
2543                 if (error == ENOTTY)
2544                         error = EINVAL;
2545                 break;
2546         case SEEK_HOLE:
2547                 error = fo_ioctl(fp, FIOSEEKHOLE, &offset, cred, td);
2548                 if (error == ENOTTY)
2549                         error = EINVAL;
2550                 break;
2551         default:
2552                 error = EINVAL;
2553         }
2554         if (error == 0 && noneg && offset < 0)
2555                 error = EINVAL;
2556         if (error != 0)
2557                 goto drop;
2558         VFS_KNOTE_UNLOCKED(vp, 0);
2559         td->td_uretoff.tdu_off = offset;
2560 drop:
2561         foffset_unlock(fp, offset, error != 0 ? FOF_NOUPDATE : 0);
2562         return (error);
2563 }
2564
2565 int
2566 vn_utimes_perm(struct vnode *vp, struct vattr *vap, struct ucred *cred,
2567     struct thread *td)
2568 {
2569         int error;
2570
2571         /*
2572          * Grant permission if the caller is the owner of the file, or
2573          * the super-user, or has ACL_WRITE_ATTRIBUTES permission on
2574          * on the file.  If the time pointer is null, then write
2575          * permission on the file is also sufficient.
2576          *
2577          * From NFSv4.1, draft 21, 6.2.1.3.1, Discussion of Mask Attributes:
2578          * A user having ACL_WRITE_DATA or ACL_WRITE_ATTRIBUTES
2579          * will be allowed to set the times [..] to the current
2580          * server time.
2581          */
2582         error = VOP_ACCESSX(vp, VWRITE_ATTRIBUTES, cred, td);
2583         if (error != 0 && (vap->va_vaflags & VA_UTIMES_NULL) != 0)
2584                 error = VOP_ACCESS(vp, VWRITE, cred, td);
2585         return (error);
2586 }
2587
2588 int
2589 vn_fill_kinfo(struct file *fp, struct kinfo_file *kif, struct filedesc *fdp)
2590 {
2591         struct vnode *vp;
2592         int error;
2593
2594         if (fp->f_type == DTYPE_FIFO)
2595                 kif->kf_type = KF_TYPE_FIFO;
2596         else
2597                 kif->kf_type = KF_TYPE_VNODE;
2598         vp = fp->f_vnode;
2599         vref(vp);
2600         FILEDESC_SUNLOCK(fdp);
2601         error = vn_fill_kinfo_vnode(vp, kif);
2602         vrele(vp);
2603         FILEDESC_SLOCK(fdp);
2604         return (error);
2605 }
2606
2607 static inline void
2608 vn_fill_junk(struct kinfo_file *kif)
2609 {
2610         size_t len, olen;
2611
2612         /*
2613          * Simulate vn_fullpath returning changing values for a given
2614          * vp during e.g. coredump.
2615          */
2616         len = (arc4random() % (sizeof(kif->kf_path) - 2)) + 1;
2617         olen = strlen(kif->kf_path);
2618         if (len < olen)
2619                 strcpy(&kif->kf_path[len - 1], "$");
2620         else
2621                 for (; olen < len; olen++)
2622                         strcpy(&kif->kf_path[olen], "A");
2623 }
2624
2625 int
2626 vn_fill_kinfo_vnode(struct vnode *vp, struct kinfo_file *kif)
2627 {
2628         struct vattr va;
2629         char *fullpath, *freepath;
2630         int error;
2631
2632         kif->kf_un.kf_file.kf_file_type = vntype_to_kinfo(vp->v_type);
2633         freepath = NULL;
2634         fullpath = "-";
2635         error = vn_fullpath(vp, &fullpath, &freepath);
2636         if (error == 0) {
2637                 strlcpy(kif->kf_path, fullpath, sizeof(kif->kf_path));
2638         }
2639         if (freepath != NULL)
2640                 free(freepath, M_TEMP);
2641
2642         KFAIL_POINT_CODE(DEBUG_FP, fill_kinfo_vnode__random_path,
2643                 vn_fill_junk(kif);
2644         );
2645
2646         /*
2647          * Retrieve vnode attributes.
2648          */
2649         va.va_fsid = VNOVAL;
2650         va.va_rdev = NODEV;
2651         vn_lock(vp, LK_SHARED | LK_RETRY);
2652         error = VOP_GETATTR(vp, &va, curthread->td_ucred);
2653         VOP_UNLOCK(vp);
2654         if (error != 0)
2655                 return (error);
2656         if (va.va_fsid != VNOVAL)
2657                 kif->kf_un.kf_file.kf_file_fsid = va.va_fsid;
2658         else
2659                 kif->kf_un.kf_file.kf_file_fsid =
2660                     vp->v_mount->mnt_stat.f_fsid.val[0];
2661         kif->kf_un.kf_file.kf_file_fsid_freebsd11 =
2662             kif->kf_un.kf_file.kf_file_fsid; /* truncate */
2663         kif->kf_un.kf_file.kf_file_fileid = va.va_fileid;
2664         kif->kf_un.kf_file.kf_file_mode = MAKEIMODE(va.va_type, va.va_mode);
2665         kif->kf_un.kf_file.kf_file_size = va.va_size;
2666         kif->kf_un.kf_file.kf_file_rdev = va.va_rdev;
2667         kif->kf_un.kf_file.kf_file_rdev_freebsd11 =
2668             kif->kf_un.kf_file.kf_file_rdev; /* truncate */
2669         return (0);
2670 }
2671
2672 int
2673 vn_mmap(struct file *fp, vm_map_t map, vm_offset_t *addr, vm_size_t size,
2674     vm_prot_t prot, vm_prot_t cap_maxprot, int flags, vm_ooffset_t foff,
2675     struct thread *td)
2676 {
2677 #ifdef HWPMC_HOOKS
2678         struct pmckern_map_in pkm;
2679 #endif
2680         struct mount *mp;
2681         struct vnode *vp;
2682         vm_object_t object;
2683         vm_prot_t maxprot;
2684         boolean_t writecounted;
2685         int error;
2686
2687 #if defined(COMPAT_FREEBSD7) || defined(COMPAT_FREEBSD6) || \
2688     defined(COMPAT_FREEBSD5) || defined(COMPAT_FREEBSD4)
2689         /*
2690          * POSIX shared-memory objects are defined to have
2691          * kernel persistence, and are not defined to support
2692          * read(2)/write(2) -- or even open(2).  Thus, we can
2693          * use MAP_ASYNC to trade on-disk coherence for speed.
2694          * The shm_open(3) library routine turns on the FPOSIXSHM
2695          * flag to request this behavior.
2696          */
2697         if ((fp->f_flag & FPOSIXSHM) != 0)
2698                 flags |= MAP_NOSYNC;
2699 #endif
2700         vp = fp->f_vnode;
2701
2702         /*
2703          * Ensure that file and memory protections are
2704          * compatible.  Note that we only worry about
2705          * writability if mapping is shared; in this case,
2706          * current and max prot are dictated by the open file.
2707          * XXX use the vnode instead?  Problem is: what
2708          * credentials do we use for determination? What if
2709          * proc does a setuid?
2710          */
2711         mp = vp->v_mount;
2712         if (mp != NULL && (mp->mnt_flag & MNT_NOEXEC) != 0) {
2713                 maxprot = VM_PROT_NONE;
2714                 if ((prot & VM_PROT_EXECUTE) != 0)
2715                         return (EACCES);
2716         } else
2717                 maxprot = VM_PROT_EXECUTE;
2718         if ((fp->f_flag & FREAD) != 0)
2719                 maxprot |= VM_PROT_READ;
2720         else if ((prot & VM_PROT_READ) != 0)
2721                 return (EACCES);
2722
2723         /*
2724          * If we are sharing potential changes via MAP_SHARED and we
2725          * are trying to get write permission although we opened it
2726          * without asking for it, bail out.
2727          */
2728         if ((flags & MAP_SHARED) != 0) {
2729                 if ((fp->f_flag & FWRITE) != 0)
2730                         maxprot |= VM_PROT_WRITE;
2731                 else if ((prot & VM_PROT_WRITE) != 0)
2732                         return (EACCES);
2733         } else {
2734                 maxprot |= VM_PROT_WRITE;
2735                 cap_maxprot |= VM_PROT_WRITE;
2736         }
2737         maxprot &= cap_maxprot;
2738
2739         /*
2740          * For regular files and shared memory, POSIX requires that
2741          * the value of foff be a legitimate offset within the data
2742          * object.  In particular, negative offsets are invalid.
2743          * Blocking negative offsets and overflows here avoids
2744          * possible wraparound or user-level access into reserved
2745          * ranges of the data object later.  In contrast, POSIX does
2746          * not dictate how offsets are used by device drivers, so in
2747          * the case of a device mapping a negative offset is passed
2748          * on.
2749          */
2750         if (
2751 #ifdef _LP64
2752             size > OFF_MAX ||
2753 #endif
2754             foff > OFF_MAX - size)
2755                 return (EINVAL);
2756
2757         writecounted = FALSE;
2758         error = vm_mmap_vnode(td, size, prot, &maxprot, &flags, vp,
2759             &foff, &object, &writecounted);
2760         if (error != 0)
2761                 return (error);
2762         error = vm_mmap_object(map, addr, size, prot, maxprot, flags, object,
2763             foff, writecounted, td);
2764         if (error != 0) {
2765                 /*
2766                  * If this mapping was accounted for in the vnode's
2767                  * writecount, then undo that now.
2768                  */
2769                 if (writecounted)
2770                         vm_pager_release_writecount(object, 0, size);
2771                 vm_object_deallocate(object);
2772         }
2773 #ifdef HWPMC_HOOKS
2774         /* Inform hwpmc(4) if an executable is being mapped. */
2775         if (PMC_HOOK_INSTALLED(PMC_FN_MMAP)) {
2776                 if ((prot & VM_PROT_EXECUTE) != 0 && error == 0) {
2777                         pkm.pm_file = vp;
2778                         pkm.pm_address = (uintptr_t) *addr;
2779                         PMC_CALL_HOOK_UNLOCKED(td, PMC_FN_MMAP, (void *) &pkm);
2780                 }
2781         }
2782 #endif
2783         return (error);
2784 }
2785
2786 void
2787 vn_fsid(struct vnode *vp, struct vattr *va)
2788 {
2789         fsid_t *f;
2790
2791         f = &vp->v_mount->mnt_stat.f_fsid;
2792         va->va_fsid = (uint32_t)f->val[1];
2793         va->va_fsid <<= sizeof(f->val[1]) * NBBY;
2794         va->va_fsid += (uint32_t)f->val[0];
2795 }
2796
2797 int
2798 vn_fsync_buf(struct vnode *vp, int waitfor)
2799 {
2800         struct buf *bp, *nbp;
2801         struct bufobj *bo;
2802         struct mount *mp;
2803         int error, maxretry;
2804
2805         error = 0;
2806         maxretry = 10000;     /* large, arbitrarily chosen */
2807         mp = NULL;
2808         if (vp->v_type == VCHR) {
2809                 VI_LOCK(vp);
2810                 mp = vp->v_rdev->si_mountpt;
2811                 VI_UNLOCK(vp);
2812         }
2813         bo = &vp->v_bufobj;
2814         BO_LOCK(bo);
2815 loop1:
2816         /*
2817          * MARK/SCAN initialization to avoid infinite loops.
2818          */
2819         TAILQ_FOREACH(bp, &bo->bo_dirty.bv_hd, b_bobufs) {
2820                 bp->b_vflags &= ~BV_SCANNED;
2821                 bp->b_error = 0;
2822         }
2823
2824         /*
2825          * Flush all dirty buffers associated with a vnode.
2826          */
2827 loop2:
2828         TAILQ_FOREACH_SAFE(bp, &bo->bo_dirty.bv_hd, b_bobufs, nbp) {
2829                 if ((bp->b_vflags & BV_SCANNED) != 0)
2830                         continue;
2831                 bp->b_vflags |= BV_SCANNED;
2832                 if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT, NULL)) {
2833                         if (waitfor != MNT_WAIT)
2834                                 continue;
2835                         if (BUF_LOCK(bp,
2836                             LK_EXCLUSIVE | LK_INTERLOCK | LK_SLEEPFAIL,
2837                             BO_LOCKPTR(bo)) != 0) {
2838                                 BO_LOCK(bo);
2839                                 goto loop1;
2840                         }
2841                         BO_LOCK(bo);
2842                 }
2843                 BO_UNLOCK(bo);
2844                 KASSERT(bp->b_bufobj == bo,
2845                     ("bp %p wrong b_bufobj %p should be %p",
2846                     bp, bp->b_bufobj, bo));
2847                 if ((bp->b_flags & B_DELWRI) == 0)
2848                         panic("fsync: not dirty");
2849                 if ((vp->v_object != NULL) && (bp->b_flags & B_CLUSTEROK)) {
2850                         vfs_bio_awrite(bp);
2851                 } else {
2852                         bremfree(bp);
2853                         bawrite(bp);
2854                 }
2855                 if (maxretry < 1000)
2856                         pause("dirty", hz < 1000 ? 1 : hz / 1000);
2857                 BO_LOCK(bo);
2858                 goto loop2;
2859         }
2860
2861         /*
2862          * If synchronous the caller expects us to completely resolve all
2863          * dirty buffers in the system.  Wait for in-progress I/O to
2864          * complete (which could include background bitmap writes), then
2865          * retry if dirty blocks still exist.
2866          */
2867         if (waitfor == MNT_WAIT) {
2868                 bufobj_wwait(bo, 0, 0);
2869                 if (bo->bo_dirty.bv_cnt > 0) {
2870                         /*
2871                          * If we are unable to write any of these buffers
2872                          * then we fail now rather than trying endlessly
2873                          * to write them out.
2874                          */
2875                         TAILQ_FOREACH(bp, &bo->bo_dirty.bv_hd, b_bobufs)
2876                                 if ((error = bp->b_error) != 0)
2877                                         break;
2878                         if ((mp != NULL && mp->mnt_secondary_writes > 0) ||
2879                             (error == 0 && --maxretry >= 0))
2880                                 goto loop1;
2881                         if (error == 0)
2882                                 error = EAGAIN;
2883                 }
2884         }
2885         BO_UNLOCK(bo);
2886         if (error != 0)
2887                 vn_printf(vp, "fsync: giving up on dirty (error = %d) ", error);
2888
2889         return (error);
2890 }
2891
2892 /*
2893  * Copies a byte range from invp to outvp.  Calls VOP_COPY_FILE_RANGE()
2894  * or vn_generic_copy_file_range() after rangelocking the byte ranges,
2895  * to do the actual copy.
2896  * vn_generic_copy_file_range() is factored out, so it can be called
2897  * from a VOP_COPY_FILE_RANGE() call as well, but handles vnodes from
2898  * different file systems.
2899  */
2900 int
2901 vn_copy_file_range(struct vnode *invp, off_t *inoffp, struct vnode *outvp,
2902     off_t *outoffp, size_t *lenp, unsigned int flags, struct ucred *incred,
2903     struct ucred *outcred, struct thread *fsize_td)
2904 {
2905         int error;
2906         size_t len;
2907         uint64_t uval;
2908
2909         len = *lenp;
2910         *lenp = 0;              /* For error returns. */
2911         error = 0;
2912
2913         /* Do some sanity checks on the arguments. */
2914         if (invp->v_type == VDIR || outvp->v_type == VDIR)
2915                 error = EISDIR;
2916         else if (*inoffp < 0 || *outoffp < 0 ||
2917             invp->v_type != VREG || outvp->v_type != VREG)
2918                 error = EINVAL;
2919         if (error != 0)
2920                 goto out;
2921
2922         /* Ensure offset + len does not wrap around. */
2923         uval = *inoffp;
2924         uval += len;
2925         if (uval > INT64_MAX)
2926                 len = INT64_MAX - *inoffp;
2927         uval = *outoffp;
2928         uval += len;
2929         if (uval > INT64_MAX)
2930                 len = INT64_MAX - *outoffp;
2931         if (len == 0)
2932                 goto out;
2933
2934         /*
2935          * If the two vnode are for the same file system, call
2936          * VOP_COPY_FILE_RANGE(), otherwise call vn_generic_copy_file_range()
2937          * which can handle copies across multiple file systems.
2938          */
2939         *lenp = len;
2940         if (invp->v_mount == outvp->v_mount)
2941                 error = VOP_COPY_FILE_RANGE(invp, inoffp, outvp, outoffp,
2942                     lenp, flags, incred, outcred, fsize_td);
2943         else
2944                 error = vn_generic_copy_file_range(invp, inoffp, outvp,
2945                     outoffp, lenp, flags, incred, outcred, fsize_td);
2946 out:
2947         return (error);
2948 }
2949
2950 /*
2951  * Test len bytes of data starting at dat for all bytes == 0.
2952  * Return true if all bytes are zero, false otherwise.
2953  * Expects dat to be well aligned.
2954  */
2955 static bool
2956 mem_iszero(void *dat, int len)
2957 {
2958         int i;
2959         const u_int *p;
2960         const char *cp;
2961
2962         for (p = dat; len > 0; len -= sizeof(*p), p++) {
2963                 if (len >= sizeof(*p)) {
2964                         if (*p != 0)
2965                                 return (false);
2966                 } else {
2967                         cp = (const char *)p;
2968                         for (i = 0; i < len; i++, cp++)
2969                                 if (*cp != '\0')
2970                                         return (false);
2971                 }
2972         }
2973         return (true);
2974 }
2975
2976 /*
2977  * Look for a hole in the output file and, if found, adjust *outoffp
2978  * and *xferp to skip past the hole.
2979  * *xferp is the entire hole length to be written and xfer2 is how many bytes
2980  * to be written as 0's upon return.
2981  */
2982 static off_t
2983 vn_skip_hole(struct vnode *outvp, off_t xfer2, off_t *outoffp, off_t *xferp,
2984     off_t *dataoffp, off_t *holeoffp, struct ucred *cred)
2985 {
2986         int error;
2987         off_t delta;
2988
2989         if (*holeoffp == 0 || *holeoffp <= *outoffp) {
2990                 *dataoffp = *outoffp;
2991                 error = VOP_IOCTL(outvp, FIOSEEKDATA, dataoffp, 0, cred,
2992                     curthread);
2993                 if (error == 0) {
2994                         *holeoffp = *dataoffp;
2995                         error = VOP_IOCTL(outvp, FIOSEEKHOLE, holeoffp, 0, cred,
2996                             curthread);
2997                 }
2998                 if (error != 0 || *holeoffp == *dataoffp) {
2999                         /*
3000                          * Since outvp is unlocked, it may be possible for
3001                          * another thread to do a truncate(), lseek(), write()
3002                          * creating a hole at startoff between the above
3003                          * VOP_IOCTL() calls, if the other thread does not do
3004                          * rangelocking.
3005                          * If that happens, *holeoffp == *dataoffp and finding
3006                          * the hole has failed, so disable vn_skip_hole().
3007                          */
3008                         *holeoffp = -1; /* Disable use of vn_skip_hole(). */
3009                         return (xfer2);
3010                 }
3011                 KASSERT(*dataoffp >= *outoffp,
3012                     ("vn_skip_hole: dataoff=%jd < outoff=%jd",
3013                     (intmax_t)*dataoffp, (intmax_t)*outoffp));
3014                 KASSERT(*holeoffp > *dataoffp,
3015                     ("vn_skip_hole: holeoff=%jd <= dataoff=%jd",
3016                     (intmax_t)*holeoffp, (intmax_t)*dataoffp));
3017         }
3018
3019         /*
3020          * If there is a hole before the data starts, advance *outoffp and
3021          * *xferp past the hole.
3022          */
3023         if (*dataoffp > *outoffp) {
3024                 delta = *dataoffp - *outoffp;
3025                 if (delta >= *xferp) {
3026                         /* Entire *xferp is a hole. */
3027                         *outoffp += *xferp;
3028                         *xferp = 0;
3029                         return (0);
3030                 }
3031                 *xferp -= delta;
3032                 *outoffp += delta;
3033                 xfer2 = MIN(xfer2, *xferp);
3034         }
3035
3036         /*
3037          * If a hole starts before the end of this xfer2, reduce this xfer2 so
3038          * that the write ends at the start of the hole.
3039          * *holeoffp should always be greater than *outoffp, but for the
3040          * non-INVARIANTS case, check this to make sure xfer2 remains a sane
3041          * value.
3042          */
3043         if (*holeoffp > *outoffp && *holeoffp < *outoffp + xfer2)
3044                 xfer2 = *holeoffp - *outoffp;
3045         return (xfer2);
3046 }
3047
3048 /*
3049  * Write an xfer sized chunk to outvp in blksize blocks from dat.
3050  * dat is a maximum of blksize in length and can be written repeatedly in
3051  * the chunk.
3052  * If growfile == true, just grow the file via vn_truncate_locked() instead
3053  * of doing actual writes.
3054  * If checkhole == true, a hole is being punched, so skip over any hole
3055  * already in the output file.
3056  */
3057 static int
3058 vn_write_outvp(struct vnode *outvp, char *dat, off_t outoff, off_t xfer,
3059     u_long blksize, bool growfile, bool checkhole, struct ucred *cred)
3060 {
3061         struct mount *mp;
3062         off_t dataoff, holeoff, xfer2;
3063         int error, lckf;
3064
3065         /*
3066          * Loop around doing writes of blksize until write has been completed.
3067          * Lock/unlock on each loop iteration so that a bwillwrite() can be
3068          * done for each iteration, since the xfer argument can be very
3069          * large if there is a large hole to punch in the output file.
3070          */
3071         error = 0;
3072         holeoff = 0;
3073         do {
3074                 xfer2 = MIN(xfer, blksize);
3075                 if (checkhole) {
3076                         /*
3077                          * Punching a hole.  Skip writing if there is
3078                          * already a hole in the output file.
3079                          */
3080                         xfer2 = vn_skip_hole(outvp, xfer2, &outoff, &xfer,
3081                             &dataoff, &holeoff, cred);
3082                         if (xfer == 0)
3083                                 break;
3084                         if (holeoff < 0)
3085                                 checkhole = false;
3086                         KASSERT(xfer2 > 0, ("vn_write_outvp: xfer2=%jd",
3087                             (intmax_t)xfer2));
3088                 }
3089                 bwillwrite();
3090                 mp = NULL;
3091                 error = vn_start_write(outvp, &mp, V_WAIT);
3092                 if (error != 0)
3093                         break;
3094                 if (growfile) {
3095                         error = vn_lock(outvp, LK_EXCLUSIVE);
3096                         if (error == 0) {
3097                                 error = vn_truncate_locked(outvp, outoff + xfer,
3098                                     false, cred);
3099                                 VOP_UNLOCK(outvp);
3100                         }
3101                 } else {
3102                         if (MNT_SHARED_WRITES(mp))
3103                                 lckf = LK_SHARED;
3104                         else
3105                                 lckf = LK_EXCLUSIVE;
3106                         error = vn_lock(outvp, lckf);
3107                         if (error == 0) {
3108                                 error = vn_rdwr(UIO_WRITE, outvp, dat, xfer2,
3109                                     outoff, UIO_SYSSPACE, IO_NODELOCKED,
3110                                     curthread->td_ucred, cred, NULL, curthread);
3111                                 outoff += xfer2;
3112                                 xfer -= xfer2;
3113                                 VOP_UNLOCK(outvp);
3114                         }
3115                 }
3116                 if (mp != NULL)
3117                         vn_finished_write(mp);
3118         } while (!growfile && xfer > 0 && error == 0);
3119         return (error);
3120 }
3121
3122 /*
3123  * Copy a byte range of one file to another.  This function can handle the
3124  * case where invp and outvp are on different file systems.
3125  * It can also be called by a VOP_COPY_FILE_RANGE() to do the work, if there
3126  * is no better file system specific way to do it.
3127  */
3128 int
3129 vn_generic_copy_file_range(struct vnode *invp, off_t *inoffp,
3130     struct vnode *outvp, off_t *outoffp, size_t *lenp, unsigned int flags,
3131     struct ucred *incred, struct ucred *outcred, struct thread *fsize_td)
3132 {
3133         struct vattr va, inva;
3134         struct mount *mp;
3135         struct uio io;
3136         off_t startoff, endoff, xfer, xfer2;
3137         u_long blksize;
3138         int error, interrupted;
3139         bool cantseek, readzeros, eof, lastblock, holetoeof;
3140         ssize_t aresid;
3141         size_t copylen, len, rem, savlen;
3142         char *dat;
3143         long holein, holeout;
3144
3145         holein = holeout = 0;
3146         savlen = len = *lenp;
3147         error = 0;
3148         interrupted = 0;
3149         dat = NULL;
3150
3151         error = vn_lock(invp, LK_SHARED);
3152         if (error != 0)
3153                 goto out;
3154         if (VOP_PATHCONF(invp, _PC_MIN_HOLE_SIZE, &holein) != 0)
3155                 holein = 0;
3156         if (holein > 0)
3157                 error = VOP_GETATTR(invp, &inva, incred);
3158         VOP_UNLOCK(invp);
3159         if (error != 0)
3160                 goto out;
3161
3162         mp = NULL;
3163         error = vn_start_write(outvp, &mp, V_WAIT);
3164         if (error == 0)
3165                 error = vn_lock(outvp, LK_EXCLUSIVE);
3166         if (error == 0) {
3167                 /*
3168                  * If fsize_td != NULL, do a vn_rlimit_fsize() call,
3169                  * now that outvp is locked.
3170                  */
3171                 if (fsize_td != NULL) {
3172                         io.uio_offset = *outoffp;
3173                         io.uio_resid = len;
3174                         error = vn_rlimit_fsize(outvp, &io, fsize_td);
3175                         if (error != 0)
3176                                 error = EFBIG;
3177                 }
3178                 if (VOP_PATHCONF(outvp, _PC_MIN_HOLE_SIZE, &holeout) != 0)
3179                         holeout = 0;
3180                 /*
3181                  * Holes that are past EOF do not need to be written as a block
3182                  * of zero bytes.  So, truncate the output file as far as
3183                  * possible and then use va.va_size to decide if writing 0
3184                  * bytes is necessary in the loop below.
3185                  */
3186                 if (error == 0)
3187                         error = VOP_GETATTR(outvp, &va, outcred);
3188                 if (error == 0 && va.va_size > *outoffp && va.va_size <=
3189                     *outoffp + len) {
3190 #ifdef MAC
3191                         error = mac_vnode_check_write(curthread->td_ucred,
3192                             outcred, outvp);
3193                         if (error == 0)
3194 #endif
3195                                 error = vn_truncate_locked(outvp, *outoffp,
3196                                     false, outcred);
3197                         if (error == 0)
3198                                 va.va_size = *outoffp;
3199                 }
3200                 VOP_UNLOCK(outvp);
3201         }
3202         if (mp != NULL)
3203                 vn_finished_write(mp);
3204         if (error != 0)
3205                 goto out;
3206
3207         /*
3208          * Set the blksize to the larger of the hole sizes for invp and outvp.
3209          * If hole sizes aren't available, set the blksize to the larger
3210          * f_iosize of invp and outvp.
3211          * This code expects the hole sizes and f_iosizes to be powers of 2.
3212          * This value is clipped at 4Kbytes and 1Mbyte.
3213          */
3214         blksize = MAX(holein, holeout);
3215
3216         /* Clip len to end at an exact multiple of hole size. */
3217         if (blksize > 1) {
3218                 rem = *inoffp % blksize;
3219                 if (rem > 0)
3220                         rem = blksize - rem;
3221                 if (len > rem && len - rem > blksize)
3222                         len = savlen = rounddown(len - rem, blksize) + rem;
3223         }
3224
3225         if (blksize <= 1)
3226                 blksize = MAX(invp->v_mount->mnt_stat.f_iosize,
3227                     outvp->v_mount->mnt_stat.f_iosize);
3228         if (blksize < 4096)
3229                 blksize = 4096;
3230         else if (blksize > 1024 * 1024)
3231                 blksize = 1024 * 1024;
3232         dat = malloc(blksize, M_TEMP, M_WAITOK);
3233
3234         /*
3235          * If VOP_IOCTL(FIOSEEKHOLE) works for invp, use it and FIOSEEKDATA
3236          * to find holes.  Otherwise, just scan the read block for all 0s
3237          * in the inner loop where the data copying is done.
3238          * Note that some file systems such as NFSv3, NFSv4.0 and NFSv4.1 may
3239          * support holes on the server, but do not support FIOSEEKHOLE.
3240          */
3241         holetoeof = eof = false;
3242         while (len > 0 && error == 0 && !eof && interrupted == 0) {
3243                 endoff = 0;                     /* To shut up compilers. */
3244                 cantseek = true;
3245                 startoff = *inoffp;
3246                 copylen = len;
3247
3248                 /*
3249                  * Find the next data area.  If there is just a hole to EOF,
3250                  * FIOSEEKDATA should fail with ENXIO.
3251                  * (I do not know if any file system will report a hole to
3252                  *  EOF via FIOSEEKHOLE, but I am pretty sure FIOSEEKDATA
3253                  *  will fail for those file systems.)
3254                  *
3255                  * For input files that don't support FIOSEEKDATA/FIOSEEKHOLE,
3256                  * the code just falls through to the inner copy loop.
3257                  */
3258                 error = EINVAL;
3259                 if (holein > 0) {
3260                         error = VOP_IOCTL(invp, FIOSEEKDATA, &startoff, 0,
3261                             incred, curthread);
3262                         if (error == ENXIO) {
3263                                 startoff = endoff = inva.va_size;
3264                                 eof = holetoeof = true;
3265                                 error = 0;
3266                         }
3267                 }
3268                 if (error == 0 && !holetoeof) {
3269                         endoff = startoff;
3270                         error = VOP_IOCTL(invp, FIOSEEKHOLE, &endoff, 0,
3271                             incred, curthread);
3272                         /*
3273                          * Since invp is unlocked, it may be possible for
3274                          * another thread to do a truncate(), lseek(), write()
3275                          * creating a hole at startoff between the above
3276                          * VOP_IOCTL() calls, if the other thread does not do
3277                          * rangelocking.
3278                          * If that happens, startoff == endoff and finding
3279                          * the hole has failed, so set an error.
3280                          */
3281                         if (error == 0 && startoff == endoff)
3282                                 error = EINVAL; /* Any error. Reset to 0. */
3283                 }
3284                 if (error == 0) {
3285                         if (startoff > *inoffp) {
3286                                 /* Found hole before data block. */
3287                                 xfer = MIN(startoff - *inoffp, len);
3288                                 if (*outoffp < va.va_size) {
3289                                         /* Must write 0s to punch hole. */
3290                                         xfer2 = MIN(va.va_size - *outoffp,
3291                                             xfer);
3292                                         memset(dat, 0, MIN(xfer2, blksize));
3293                                         error = vn_write_outvp(outvp, dat,
3294                                             *outoffp, xfer2, blksize, false,
3295                                             holeout > 0, outcred);
3296                                 }
3297
3298                                 if (error == 0 && *outoffp + xfer >
3299                                     va.va_size && (xfer == len || holetoeof)) {
3300                                         /* Grow output file (hole at end). */
3301                                         error = vn_write_outvp(outvp, dat,
3302                                             *outoffp, xfer, blksize, true,
3303                                             false, outcred);
3304                                 }
3305                                 if (error == 0) {
3306                                         *inoffp += xfer;
3307                                         *outoffp += xfer;
3308                                         len -= xfer;
3309                                         if (len < savlen)
3310                                                 interrupted = sig_intr();
3311                                 }
3312                         }
3313                         copylen = MIN(len, endoff - startoff);
3314                         cantseek = false;
3315                 } else {
3316                         cantseek = true;
3317                         startoff = *inoffp;
3318                         copylen = len;
3319                         error = 0;
3320                 }
3321
3322                 xfer = blksize;
3323                 if (cantseek) {
3324                         /*
3325                          * Set first xfer to end at a block boundary, so that
3326                          * holes are more likely detected in the loop below via
3327                          * the for all bytes 0 method.
3328                          */
3329                         xfer -= (*inoffp % blksize);
3330                 }
3331                 /* Loop copying the data block. */
3332                 while (copylen > 0 && error == 0 && !eof && interrupted == 0) {
3333                         if (copylen < xfer)
3334                                 xfer = copylen;
3335                         error = vn_lock(invp, LK_SHARED);
3336                         if (error != 0)
3337                                 goto out;
3338                         error = vn_rdwr(UIO_READ, invp, dat, xfer,
3339                             startoff, UIO_SYSSPACE, IO_NODELOCKED,
3340                             curthread->td_ucred, incred, &aresid,
3341                             curthread);
3342                         VOP_UNLOCK(invp);
3343                         lastblock = false;
3344                         if (error == 0 && aresid > 0) {
3345                                 /* Stop the copy at EOF on the input file. */
3346                                 xfer -= aresid;
3347                                 eof = true;
3348                                 lastblock = true;
3349                         }
3350                         if (error == 0) {
3351                                 /*
3352                                  * Skip the write for holes past the initial EOF
3353                                  * of the output file, unless this is the last
3354                                  * write of the output file at EOF.
3355                                  */
3356                                 readzeros = cantseek ? mem_iszero(dat, xfer) :
3357                                     false;
3358                                 if (xfer == len)
3359                                         lastblock = true;
3360                                 if (!cantseek || *outoffp < va.va_size ||
3361                                     lastblock || !readzeros)
3362                                         error = vn_write_outvp(outvp, dat,
3363                                             *outoffp, xfer, blksize,
3364                                             readzeros && lastblock &&
3365                                             *outoffp >= va.va_size, false,
3366                                             outcred);
3367                                 if (error == 0) {
3368                                         *inoffp += xfer;
3369                                         startoff += xfer;
3370                                         *outoffp += xfer;
3371                                         copylen -= xfer;
3372                                         len -= xfer;
3373                                         if (len < savlen)
3374                                                 interrupted = sig_intr();
3375                                 }
3376                         }
3377                         xfer = blksize;
3378                 }
3379         }
3380 out:
3381         *lenp = savlen - len;
3382         free(dat, M_TEMP);
3383         return (error);
3384 }
3385
3386 static int
3387 vn_fallocate(struct file *fp, off_t offset, off_t len, struct thread *td)
3388 {
3389         struct mount *mp;
3390         struct vnode *vp;
3391         off_t olen, ooffset;
3392         int error;
3393 #ifdef AUDIT
3394         int audited_vnode1 = 0;
3395 #endif
3396
3397         vp = fp->f_vnode;
3398         if (vp->v_type != VREG)
3399                 return (ENODEV);
3400
3401         /* Allocating blocks may take a long time, so iterate. */
3402         for (;;) {
3403                 olen = len;
3404                 ooffset = offset;
3405
3406                 bwillwrite();
3407                 mp = NULL;
3408                 error = vn_start_write(vp, &mp, V_WAIT | PCATCH);
3409                 if (error != 0)
3410                         break;
3411                 error = vn_lock(vp, LK_EXCLUSIVE);
3412                 if (error != 0) {
3413                         vn_finished_write(mp);
3414                         break;
3415                 }
3416 #ifdef AUDIT
3417                 if (!audited_vnode1) {
3418                         AUDIT_ARG_VNODE1(vp);
3419                         audited_vnode1 = 1;
3420                 }
3421 #endif
3422 #ifdef MAC
3423                 error = mac_vnode_check_write(td->td_ucred, fp->f_cred, vp);
3424                 if (error == 0)
3425 #endif
3426                         error = VOP_ALLOCATE(vp, &offset, &len);
3427                 VOP_UNLOCK(vp);
3428                 vn_finished_write(mp);
3429
3430                 if (olen + ooffset != offset + len) {
3431                         panic("offset + len changed from %jx/%jx to %jx/%jx",
3432                             ooffset, olen, offset, len);
3433                 }
3434                 if (error != 0 || len == 0)
3435                         break;
3436                 KASSERT(olen > len, ("Iteration did not make progress?"));
3437                 maybe_yield();
3438         }
3439
3440         return (error);
3441 }
3442
3443 static u_long vn_lock_pair_pause_cnt;
3444 SYSCTL_ULONG(_debug, OID_AUTO, vn_lock_pair_pause, CTLFLAG_RD,
3445     &vn_lock_pair_pause_cnt, 0,
3446     "Count of vn_lock_pair deadlocks");
3447
3448 u_int vn_lock_pair_pause_max;
3449 SYSCTL_UINT(_debug, OID_AUTO, vn_lock_pair_pause_max, CTLFLAG_RW,
3450     &vn_lock_pair_pause_max, 0,
3451     "Max ticks for vn_lock_pair deadlock avoidance sleep");
3452
3453 static void
3454 vn_lock_pair_pause(const char *wmesg)
3455 {
3456         atomic_add_long(&vn_lock_pair_pause_cnt, 1);
3457         pause(wmesg, prng32_bounded(vn_lock_pair_pause_max));
3458 }
3459
3460 /*
3461  * Lock pair of vnodes vp1, vp2, avoiding lock order reversal.
3462  * vp1_locked indicates whether vp1 is exclusively locked; if not, vp1
3463  * must be unlocked.  Same for vp2 and vp2_locked.  One of the vnodes
3464  * can be NULL.
3465  *
3466  * The function returns with both vnodes exclusively locked, and
3467  * guarantees that it does not create lock order reversal with other
3468  * threads during its execution.  Both vnodes could be unlocked
3469  * temporary (and reclaimed).
3470  */
3471 void
3472 vn_lock_pair(struct vnode *vp1, bool vp1_locked, struct vnode *vp2,
3473     bool vp2_locked)
3474 {
3475         int error;
3476
3477         if (vp1 == NULL && vp2 == NULL)
3478                 return;
3479         if (vp1 != NULL) {
3480                 if (vp1_locked)
3481                         ASSERT_VOP_ELOCKED(vp1, "vp1");
3482                 else
3483                         ASSERT_VOP_UNLOCKED(vp1, "vp1");
3484         } else {
3485                 vp1_locked = true;
3486         }
3487         if (vp2 != NULL) {
3488                 if (vp2_locked)
3489                         ASSERT_VOP_ELOCKED(vp2, "vp2");
3490                 else
3491                         ASSERT_VOP_UNLOCKED(vp2, "vp2");
3492         } else {
3493                 vp2_locked = true;
3494         }
3495         if (!vp1_locked && !vp2_locked) {
3496                 vn_lock(vp1, LK_EXCLUSIVE | LK_RETRY);
3497                 vp1_locked = true;
3498         }
3499
3500         for (;;) {
3501                 if (vp1_locked && vp2_locked)
3502                         break;
3503                 if (vp1_locked && vp2 != NULL) {
3504                         if (vp1 != NULL) {
3505                                 error = VOP_LOCK1(vp2, LK_EXCLUSIVE | LK_NOWAIT,
3506                                     __FILE__, __LINE__);
3507                                 if (error == 0)
3508                                         break;
3509                                 VOP_UNLOCK(vp1);
3510                                 vp1_locked = false;
3511                                 vn_lock_pair_pause("vlp1");
3512                         }
3513                         vn_lock(vp2, LK_EXCLUSIVE | LK_RETRY);
3514                         vp2_locked = true;
3515                 }
3516                 if (vp2_locked && vp1 != NULL) {
3517                         if (vp2 != NULL) {
3518                                 error = VOP_LOCK1(vp1, LK_EXCLUSIVE | LK_NOWAIT,
3519                                     __FILE__, __LINE__);
3520                                 if (error == 0)
3521                                         break;
3522                                 VOP_UNLOCK(vp2);
3523                                 vp2_locked = false;
3524                                 vn_lock_pair_pause("vlp2");
3525                         }
3526                         vn_lock(vp1, LK_EXCLUSIVE | LK_RETRY);
3527                         vp1_locked = true;
3528                 }
3529         }
3530         if (vp1 != NULL)
3531                 ASSERT_VOP_ELOCKED(vp1, "vp1 ret");
3532         if (vp2 != NULL)
3533                 ASSERT_VOP_ELOCKED(vp2, "vp2 ret");
3534 }