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
  43 #include <sys/cdefs.h>
  44 #include "opt_hwpmc_hooks.h"
  45
  46 #include <sys/param.h>
  47 #include <sys/systm.h>
  48 #include <sys/disk.h>
  49 #include <sys/fail.h>
  50 #include <sys/fcntl.h>
  51 #include <sys/file.h>
  52 #include <sys/kdb.h>
  53 #include <sys/ktr.h>
  54 #include <sys/stat.h>
  55 #include <sys/priv.h>
  56 #include <sys/proc.h>
  57 #include <sys/limits.h>
  58 #include <sys/lock.h>
  59 #include <sys/mman.h>
  60 #include <sys/mount.h>
  61 #include <sys/mutex.h>
  62 #include <sys/namei.h>
  63 #include <sys/vnode.h>
  64 #include <sys/dirent.h>
  65 #include <sys/bio.h>
  66 #include <sys/buf.h>
  67 #include <sys/filio.h>
  68 #include <sys/resourcevar.h>
  69 #include <sys/rwlock.h>
  70 #include <sys/prng.h>
  71 #include <sys/sx.h>
  72 #include <sys/sleepqueue.h>
  73 #include <sys/sysctl.h>
  74 #include <sys/ttycom.h>
  75 #include <sys/conf.h>
  76 #include <sys/syslog.h>
  77 #include <sys/unistd.h>
  78 #include <sys/user.h>
  79 #include <sys/ktrace.h>
  80
  81 #include <security/audit/audit.h>
  82 #include <security/mac/mac_framework.h>
  83
  84 #include <vm/vm.h>
  85 #include <vm/vm_extern.h>
  86 #include <vm/pmap.h>
  87 #include <vm/vm_map.h>
  88 #include <vm/vm_object.h>
  89 #include <vm/vm_page.h>
  90 #include <vm/vm_pager.h>
  91 #include <vm/vnode_pager.h>
  92
  93 #ifdef HWPMC_HOOKS
  94 #include <sys/pmckern.h>
  95 #endif
  96
  97 static fo_rdwr_t        vn_read;
  98 static fo_rdwr_t        vn_write;
  99 static fo_rdwr_t        vn_io_fault;
 100 static fo_truncate_t    vn_truncate;
 101 static fo_ioctl_t       vn_ioctl;
 102 static fo_poll_t        vn_poll;
 103 static fo_kqfilter_t    vn_kqfilter;
 104 static fo_close_t       vn_closefile;
 105 static fo_mmap_t        vn_mmap;
 106 static fo_fallocate_t   vn_fallocate;
 107 static fo_fspacectl_t   vn_fspacectl;
 108
 109 struct  fileops vnops = {
 110         .fo_read = vn_io_fault,
 111         .fo_write = vn_io_fault,
 112         .fo_truncate = vn_truncate,
 113         .fo_ioctl = vn_ioctl,
 114         .fo_poll = vn_poll,
 115         .fo_kqfilter = vn_kqfilter,
 116         .fo_stat = vn_statfile,
 117         .fo_close = vn_closefile,
 118         .fo_chmod = vn_chmod,
 119         .fo_chown = vn_chown,
 120         .fo_sendfile = vn_sendfile,
 121         .fo_seek = vn_seek,
 122         .fo_fill_kinfo = vn_fill_kinfo,
 123         .fo_mmap = vn_mmap,
 124         .fo_fallocate = vn_fallocate,
 125         .fo_fspacectl = vn_fspacectl,
 126         .fo_cmp = vn_cmp,
 127         .fo_flags = DFLAG_PASSABLE | DFLAG_SEEKABLE
 128 };
 129
 130 const u_int io_hold_cnt = 16;
 131 static int vn_io_fault_enable = 1;
 132 SYSCTL_INT(_debug, OID_AUTO, vn_io_fault_enable, CTLFLAG_RWTUN,
 133     &vn_io_fault_enable, 0, "Enable vn_io_fault lock avoidance");
 134 static int vn_io_fault_prefault = 0;
 135 SYSCTL_INT(_debug, OID_AUTO, vn_io_fault_prefault, CTLFLAG_RWTUN,
 136     &vn_io_fault_prefault, 0, "Enable vn_io_fault prefaulting");
 137 static int vn_io_pgcache_read_enable = 1;
 138 SYSCTL_INT(_debug, OID_AUTO, vn_io_pgcache_read_enable, CTLFLAG_RWTUN,
 139     &vn_io_pgcache_read_enable, 0,
 140     "Enable copying from page cache for reads, avoiding fs");
 141 static u_long vn_io_faults_cnt;
 142 SYSCTL_ULONG(_debug, OID_AUTO, vn_io_faults, CTLFLAG_RD,
 143     &vn_io_faults_cnt, 0, "Count of vn_io_fault lock avoidance triggers");
 144
 145 static int vfs_allow_read_dir = 0;
 146 SYSCTL_INT(_security_bsd, OID_AUTO, allow_read_dir, CTLFLAG_RW,
 147     &vfs_allow_read_dir, 0,
 148     "Enable read(2) of directory by root for filesystems that support it");
 149
 150 /*
 151  * Returns true if vn_io_fault mode of handling the i/o request should
 152  * be used.
 153  */
 154 static bool
 155 do_vn_io_fault(struct vnode *vp, struct uio *uio)
 156 {
 157         struct mount *mp;
 158
 159         return (uio->uio_segflg == UIO_USERSPACE && vp->v_type == VREG &&
 160             (mp = vp->v_mount) != NULL &&
 161             (mp->mnt_kern_flag & MNTK_NO_IOPF) != 0 && vn_io_fault_enable);
 162 }
 163
 164 /*
 165  * Structure used to pass arguments to vn_io_fault1(), to do either
 166  * file- or vnode-based I/O calls.
 167  */
 168 struct vn_io_fault_args {
 169         enum {
 170                 VN_IO_FAULT_FOP,
 171                 VN_IO_FAULT_VOP
 172         } kind;
 173         struct ucred *cred;
 174         int flags;
 175         union {
 176                 struct fop_args_tag {
 177                         struct file *fp;
 178                         fo_rdwr_t *doio;
 179                 } fop_args;
 180                 struct vop_args_tag {
 181                         struct vnode *vp;
 182                 } vop_args;
 183         } args;
 184 };
 185
 186 static int vn_io_fault1(struct vnode *vp, struct uio *uio,
 187     struct vn_io_fault_args *args, struct thread *td);
 188
 189 int
 190 vn_open(struct nameidata *ndp, int *flagp, int cmode, struct file *fp)
 191 {
 192         struct thread *td = curthread;
 193
 194         return (vn_open_cred(ndp, flagp, cmode, 0, td->td_ucred, fp));
 195 }
 196
 197 static uint64_t
 198 open2nameif(int fmode, u_int vn_open_flags)
 199 {
 200         uint64_t res;
 201
 202         res = ISOPEN | LOCKLEAF;
 203         if ((fmode & O_RESOLVE_BENEATH) != 0)
 204                 res |= RBENEATH;
 205         if ((fmode & O_EMPTY_PATH) != 0)
 206                 res |= EMPTYPATH;
 207         if ((fmode & FREAD) != 0)
 208                 res |= OPENREAD;
 209         if ((fmode & FWRITE) != 0)
 210                 res |= OPENWRITE;
 211         if ((vn_open_flags & VN_OPEN_NOAUDIT) == 0)
 212                 res |= AUDITVNODE1;
 213         if ((vn_open_flags & VN_OPEN_NOCAPCHECK) != 0)
 214                 res |= NOCAPCHECK;
 215         if ((vn_open_flags & VN_OPEN_WANTIOCTLCAPS) != 0)
 216                 res |= WANTIOCTLCAPS;
 217         return (res);
 218 }
 219
 220 /*
 221  * Common code for vnode open operations via a name lookup.
 222  * Lookup the vnode and invoke VOP_CREATE if needed.
 223  * Check permissions, and call the VOP_OPEN or VOP_CREATE routine.
 224  *
 225  * Note that this does NOT free nameidata for the successful case,
 226  * due to the NDINIT being done elsewhere.
 227  */
 228 int
 229 vn_open_cred(struct nameidata *ndp, int *flagp, int cmode, u_int vn_open_flags,
 230     struct ucred *cred, struct file *fp)
 231 {
 232         struct vnode *vp;
 233         struct mount *mp;
 234         struct vattr vat;
 235         struct vattr *vap = &vat;
 236         int fmode, error;
 237         bool first_open;
 238
 239 restart:
 240         first_open = false;
 241         fmode = *flagp;
 242         if ((fmode & (O_CREAT | O_EXCL | O_DIRECTORY)) == (O_CREAT |
 243             O_EXCL | O_DIRECTORY) ||
 244             (fmode & (O_CREAT | O_EMPTY_PATH)) == (O_CREAT | O_EMPTY_PATH))
 245                 return (EINVAL);
 246         else if ((fmode & (O_CREAT | O_DIRECTORY)) == O_CREAT) {
 247                 ndp->ni_cnd.cn_nameiop = CREATE;
 248                 ndp->ni_cnd.cn_flags = open2nameif(fmode, vn_open_flags);
 249                 /*
 250                  * Set NOCACHE to avoid flushing the cache when
 251                  * rolling in many files at once.
 252                  *
 253                  * Set NC_KEEPPOSENTRY to keep positive entries if they already
 254                  * exist despite NOCACHE.
 255                  */
 256                 ndp->ni_cnd.cn_flags |= LOCKPARENT | NOCACHE | NC_KEEPPOSENTRY;
 257                 if ((fmode & O_EXCL) == 0 && (fmode & O_NOFOLLOW) == 0)
 258                         ndp->ni_cnd.cn_flags |= FOLLOW;
 259                 if ((vn_open_flags & VN_OPEN_INVFS) == 0)
 260                         bwillwrite();
 261                 if ((error = namei(ndp)) != 0)
 262                         return (error);
 263                 if (ndp->ni_vp == NULL) {
 264                         VATTR_NULL(vap);
 265                         vap->va_type = VREG;
 266                         vap->va_mode = cmode;
 267                         if (fmode & O_EXCL)
 268                                 vap->va_vaflags |= VA_EXCLUSIVE;
 269                         if (vn_start_write(ndp->ni_dvp, &mp, V_NOWAIT) != 0) {
 270                                 NDFREE_PNBUF(ndp);
 271                                 vput(ndp->ni_dvp);
 272                                 if ((error = vn_start_write(NULL, &mp,
 273                                     V_XSLEEP | V_PCATCH)) != 0)
 274                                         return (error);
 275                                 NDREINIT(ndp);
 276                                 goto restart;
 277                         }
 278                         if ((vn_open_flags & VN_OPEN_NAMECACHE) != 0)
 279                                 ndp->ni_cnd.cn_flags |= MAKEENTRY;
 280 #ifdef MAC
 281                         error = mac_vnode_check_create(cred, ndp->ni_dvp,
 282                             &ndp->ni_cnd, vap);
 283                         if (error == 0)
 284 #endif
 285                                 error = VOP_CREATE(ndp->ni_dvp, &ndp->ni_vp,
 286                                     &ndp->ni_cnd, vap);
 287                         vp = ndp->ni_vp;
 288                         if (error == 0 && (fmode & O_EXCL) != 0 &&
 289                             (fmode & (O_EXLOCK | O_SHLOCK)) != 0) {
 290                                 VI_LOCK(vp);
 291                                 vp->v_iflag |= VI_FOPENING;
 292                                 VI_UNLOCK(vp);
 293                                 first_open = true;
 294                         }
 295                         VOP_VPUT_PAIR(ndp->ni_dvp, error == 0 ? &vp : NULL,
 296                             false);
 297                         vn_finished_write(mp);
 298                         if (error) {
 299                                 NDFREE_PNBUF(ndp);
 300                                 if (error == ERELOOKUP) {
 301                                         NDREINIT(ndp);
 302                                         goto restart;
 303                                 }
 304                                 return (error);
 305                         }
 306                         fmode &= ~O_TRUNC;
 307                 } else {
 308                         if (ndp->ni_dvp == ndp->ni_vp)
 309                                 vrele(ndp->ni_dvp);
 310                         else
 311                                 vput(ndp->ni_dvp);
 312                         ndp->ni_dvp = NULL;
 313                         vp = ndp->ni_vp;
 314                         if (fmode & O_EXCL) {
 315                                 error = EEXIST;
 316                                 goto bad;
 317                         }
 318                         if (vp->v_type == VDIR) {
 319                                 error = EISDIR;
 320                                 goto bad;
 321                         }
 322                         fmode &= ~O_CREAT;
 323                 }
 324         } else {
 325                 ndp->ni_cnd.cn_nameiop = LOOKUP;
 326                 ndp->ni_cnd.cn_flags = open2nameif(fmode, vn_open_flags);
 327                 ndp->ni_cnd.cn_flags |= (fmode & O_NOFOLLOW) != 0 ? NOFOLLOW :
 328                     FOLLOW;
 329                 if ((fmode & FWRITE) == 0)
 330                         ndp->ni_cnd.cn_flags |= LOCKSHARED;
 331                 if ((error = namei(ndp)) != 0)
 332                         return (error);
 333                 vp = ndp->ni_vp;
 334         }
 335         error = vn_open_vnode(vp, fmode, cred, curthread, fp);
 336         if (first_open) {
 337                 VI_LOCK(vp);
 338                 vp->v_iflag &= ~VI_FOPENING;
 339                 wakeup(vp);
 340                 VI_UNLOCK(vp);
 341         }
 342         if (error)
 343                 goto bad;
 344         *flagp = fmode;
 345         return (0);
 346 bad:
 347         NDFREE_PNBUF(ndp);
 348         vput(vp);
 349         *flagp = fmode;
 350         ndp->ni_vp = NULL;
 351         return (error);
 352 }
 353
 354 static int
 355 vn_open_vnode_advlock(struct vnode *vp, int fmode, struct file *fp)
 356 {
 357         struct flock lf;
 358         int error, lock_flags, type;
 359
 360         ASSERT_VOP_LOCKED(vp, "vn_open_vnode_advlock");
 361         if ((fmode & (O_EXLOCK | O_SHLOCK)) == 0)
 362                 return (0);
 363         KASSERT(fp != NULL, ("open with flock requires fp"));
 364         if (fp->f_type != DTYPE_NONE && fp->f_type != DTYPE_VNODE)
 365                 return (EOPNOTSUPP);
 366
 367         lock_flags = VOP_ISLOCKED(vp);
 368         VOP_UNLOCK(vp);
 369
 370         lf.l_whence = SEEK_SET;
 371         lf.l_start = 0;
 372         lf.l_len = 0;
 373         lf.l_type = (fmode & O_EXLOCK) != 0 ? F_WRLCK : F_RDLCK;
 374         type = F_FLOCK;
 375         if ((fmode & FNONBLOCK) == 0)
 376                 type |= F_WAIT;
 377         if ((fmode & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
 378                 type |= F_FIRSTOPEN;
 379         error = VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf, type);
 380         if (error == 0)
 381                 fp->f_flag |= FHASLOCK;
 382
 383         vn_lock(vp, lock_flags | LK_RETRY);
 384         return (error);
 385 }
 386
 387 /*
 388  * Common code for vnode open operations once a vnode is located.
 389  * Check permissions, and call the VOP_OPEN routine.
 390  */
 391 int
 392 vn_open_vnode(struct vnode *vp, int fmode, struct ucred *cred,
 393     struct thread *td, struct file *fp)
 394 {
 395         accmode_t accmode;
 396         int error;
 397
 398         if (vp->v_type == VLNK) {
 399                 if ((fmode & O_PATH) == 0 || (fmode & FEXEC) != 0)
 400                         return (EMLINK);
 401         }
 402         if (vp->v_type != VDIR && fmode & O_DIRECTORY)
 403                 return (ENOTDIR);
 404
 405         accmode = 0;
 406         if ((fmode & O_PATH) == 0) {
 407                 if (vp->v_type == VSOCK)
 408                         return (EOPNOTSUPP);
 409                 if ((fmode & (FWRITE | O_TRUNC)) != 0) {
 410                         if (vp->v_type == VDIR)
 411                                 return (EISDIR);
 412                         accmode |= VWRITE;
 413                 }
 414                 if ((fmode & FREAD) != 0)
 415                         accmode |= VREAD;
 416                 if ((fmode & O_APPEND) && (fmode & FWRITE))
 417                         accmode |= VAPPEND;
 418 #ifdef MAC
 419                 if ((fmode & O_CREAT) != 0)
 420                         accmode |= VCREAT;
 421 #endif
 422         }
 423         if ((fmode & FEXEC) != 0)
 424                 accmode |= VEXEC;
 425 #ifdef MAC
 426         if ((fmode & O_VERIFY) != 0)
 427                 accmode |= VVERIFY;
 428         error = mac_vnode_check_open(cred, vp, accmode);
 429         if (error != 0)
 430                 return (error);
 431
 432         accmode &= ~(VCREAT | VVERIFY);
 433 #endif
 434         if ((fmode & O_CREAT) == 0 && accmode != 0) {
 435                 error = VOP_ACCESS(vp, accmode, cred, td);
 436                 if (error != 0)
 437                         return (error);
 438         }
 439         if ((fmode & O_PATH) != 0) {
 440                 if (vp->v_type != VFIFO && vp->v_type != VSOCK &&
 441                     VOP_ACCESS(vp, VREAD, cred, td) == 0)
 442                         fp->f_flag |= FKQALLOWED;
 443                 return (0);
 444         }
 445
 446         if (vp->v_type == VFIFO && VOP_ISLOCKED(vp) != LK_EXCLUSIVE)
 447                 vn_lock(vp, LK_UPGRADE | LK_RETRY);
 448         error = VOP_OPEN(vp, fmode, cred, td, fp);
 449         if (error != 0)
 450                 return (error);
 451
 452         error = vn_open_vnode_advlock(vp, fmode, fp);
 453         if (error == 0 && (fmode & FWRITE) != 0) {
 454                 error = VOP_ADD_WRITECOUNT(vp, 1);
 455                 if (error == 0) {
 456                         CTR3(KTR_VFS, "%s: vp %p v_writecount increased to %d",
 457                              __func__, vp, vp->v_writecount);
 458                 }
 459         }
 460
 461         /*
 462          * Error from advlock or VOP_ADD_WRITECOUNT() still requires
 463          * calling VOP_CLOSE() to pair with earlier VOP_OPEN().
 464          */
 465         if (error != 0) {
 466                 if (fp != NULL) {
 467                         /*
 468                          * Arrange the call by having fdrop() to use
 469                          * vn_closefile().  This is to satisfy
 470                          * filesystems like devfs or tmpfs, which
 471                          * override fo_close().
 472                          */
 473                         fp->f_flag |= FOPENFAILED;
 474                         fp->f_vnode = vp;
 475                         if (fp->f_ops == &badfileops) {
 476                                 fp->f_type = DTYPE_VNODE;
 477                                 fp->f_ops = &vnops;
 478                         }
 479                         vref(vp);
 480                 } else {
 481                         /*
 482                          * If there is no fp, due to kernel-mode open,
 483                          * we can call VOP_CLOSE() now.
 484                          */
 485                         if ((vp->v_type == VFIFO ||
 486                             !MNT_EXTENDED_SHARED(vp->v_mount)) &&
 487                             VOP_ISLOCKED(vp) != LK_EXCLUSIVE)
 488                                 vn_lock(vp, LK_UPGRADE | LK_RETRY);
 489                         (void)VOP_CLOSE(vp, fmode & (FREAD | FWRITE | FEXEC),
 490                             cred, td);
 491                 }
 492         }
 493
 494         ASSERT_VOP_LOCKED(vp, "vn_open_vnode");
 495         return (error);
 496
 497 }
 498
 499 /*
 500  * Check for write permissions on the specified vnode.
 501  * Prototype text segments cannot be written.
 502  * It is racy.
 503  */
 504 int
 505 vn_writechk(struct vnode *vp)
 506 {
 507
 508         ASSERT_VOP_LOCKED(vp, "vn_writechk");
 509         /*
 510          * If there's shared text associated with
 511          * the vnode, try to free it up once.  If
 512          * we fail, we can't allow writing.
 513          */
 514         if (VOP_IS_TEXT(vp))
 515                 return (ETXTBSY);
 516
 517         return (0);
 518 }
 519
 520 /*
 521  * Vnode close call
 522  */
 523 static int
 524 vn_close1(struct vnode *vp, int flags, struct ucred *file_cred,
 525     struct thread *td, bool keep_ref)
 526 {
 527         struct mount *mp;
 528         int error, lock_flags;
 529
 530         lock_flags = vp->v_type != VFIFO && MNT_EXTENDED_SHARED(vp->v_mount) ?
 531             LK_SHARED : 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 | V_PCATCH))
 654                             != 0)
 655                                 goto out;
 656                         lock_flags = vn_lktype_write(mp, vp);
 657                 } else
 658                         lock_flags = LK_SHARED;
 659                 vn_lock(vp, lock_flags | LK_RETRY);
 660         } else
 661                 rl_cookie = NULL;
 662
 663         ASSERT_VOP_LOCKED(vp, "IO_NODELOCKED with no vp lock held");
 664 #ifdef MAC
 665         if ((ioflg & IO_NOMACCHECK) == 0) {
 666                 if (rw == UIO_READ)
 667                         error = mac_vnode_check_read(active_cred, file_cred,
 668                             vp);
 669                 else
 670                         error = mac_vnode_check_write(active_cred, file_cred,
 671                             vp);
 672         }
 673 #endif
 674         if (error == 0) {
 675                 if (file_cred != NULL)
 676                         cred = file_cred;
 677                 else
 678                         cred = active_cred;
 679                 if (do_vn_io_fault(vp, &auio)) {
 680                         args.kind = VN_IO_FAULT_VOP;
 681                         args.cred = cred;
 682                         args.flags = ioflg;
 683                         args.args.vop_args.vp = vp;
 684                         error = vn_io_fault1(vp, &auio, &args, td);
 685                 } else if (rw == UIO_READ) {
 686                         error = VOP_READ(vp, &auio, ioflg, cred);
 687                 } else /* if (rw == UIO_WRITE) */ {
 688                         error = VOP_WRITE(vp, &auio, ioflg, cred);
 689                 }
 690         }
 691         if (aresid)
 692                 *aresid = auio.uio_resid;
 693         else
 694                 if (auio.uio_resid && error == 0)
 695                         error = EIO;
 696         if ((ioflg & IO_NODELOCKED) == 0) {
 697                 VOP_UNLOCK(vp);
 698                 if (mp != NULL)
 699                         vn_finished_write(mp);
 700         }
 701  out:
 702         if (rl_cookie != NULL)
 703                 vn_rangelock_unlock(vp, rl_cookie);
 704         return (error);
 705 }
 706
 707 /*
 708  * Package up an I/O request on a vnode into a uio and do it.  The I/O
 709  * request is split up into smaller chunks and we try to avoid saturating
 710  * the buffer cache while potentially holding a vnode locked, so we
 711  * check bwillwrite() before calling vn_rdwr().  We also call kern_yield()
 712  * to give other processes a chance to lock the vnode (either other processes
 713  * core'ing the same binary, or unrelated processes scanning the directory).
 714  */
 715 int
 716 vn_rdwr_inchunks(enum uio_rw rw, struct vnode *vp, void *base, size_t len,
 717     off_t offset, enum uio_seg segflg, int ioflg, struct ucred *active_cred,
 718     struct ucred *file_cred, size_t *aresid, struct thread *td)
 719 {
 720         int error = 0;
 721         ssize_t iaresid;
 722
 723         do {
 724                 int chunk;
 725
 726                 /*
 727                  * Force `offset' to a multiple of MAXBSIZE except possibly
 728                  * for the first chunk, so that filesystems only need to
 729                  * write full blocks except possibly for the first and last
 730                  * chunks.
 731                  */
 732                 chunk = MAXBSIZE - (uoff_t)offset % MAXBSIZE;
 733
 734                 if (chunk > len)
 735                         chunk = len;
 736                 if (rw != UIO_READ && vp->v_type == VREG)
 737                         bwillwrite();
 738                 iaresid = 0;
 739                 error = vn_rdwr(rw, vp, base, chunk, offset, segflg,
 740                     ioflg, active_cred, file_cred, &iaresid, td);
 741                 len -= chunk;   /* aresid calc already includes length */
 742                 if (error)
 743                         break;
 744                 offset += chunk;
 745                 base = (char *)base + chunk;
 746                 kern_yield(PRI_USER);
 747         } while (len);
 748         if (aresid)
 749                 *aresid = len + iaresid;
 750         return (error);
 751 }
 752
 753 #if OFF_MAX <= LONG_MAX
 754 off_t
 755 foffset_lock(struct file *fp, int flags)
 756 {
 757         volatile short *flagsp;
 758         off_t res;
 759         short state;
 760
 761         KASSERT((flags & FOF_OFFSET) == 0, ("FOF_OFFSET passed"));
 762
 763         if ((flags & FOF_NOLOCK) != 0)
 764                 return (atomic_load_long(&fp->f_offset));
 765
 766         /*
 767          * According to McKusick the vn lock was protecting f_offset here.
 768          * It is now protected by the FOFFSET_LOCKED flag.
 769          */
 770         flagsp = &fp->f_vnread_flags;
 771         if (atomic_cmpset_acq_16(flagsp, 0, FOFFSET_LOCKED))
 772                 return (atomic_load_long(&fp->f_offset));
 773
 774         sleepq_lock(&fp->f_vnread_flags);
 775         state = atomic_load_16(flagsp);
 776         for (;;) {
 777                 if ((state & FOFFSET_LOCKED) == 0) {
 778                         if (!atomic_fcmpset_acq_16(flagsp, &state,
 779                             FOFFSET_LOCKED))
 780                                 continue;
 781                         break;
 782                 }
 783                 if ((state & FOFFSET_LOCK_WAITING) == 0) {
 784                         if (!atomic_fcmpset_acq_16(flagsp, &state,
 785                             state | FOFFSET_LOCK_WAITING))
 786                                 continue;
 787                 }
 788                 DROP_GIANT();
 789                 sleepq_add(&fp->f_vnread_flags, NULL, "vofflock", 0, 0);
 790                 sleepq_wait(&fp->f_vnread_flags, PUSER -1);
 791                 PICKUP_GIANT();
 792                 sleepq_lock(&fp->f_vnread_flags);
 793                 state = atomic_load_16(flagsp);
 794         }
 795         res = atomic_load_long(&fp->f_offset);
 796         sleepq_release(&fp->f_vnread_flags);
 797         return (res);
 798 }
 799
 800 void
 801 foffset_unlock(struct file *fp, off_t val, int flags)
 802 {
 803         volatile short *flagsp;
 804         short state;
 805
 806         KASSERT((flags & FOF_OFFSET) == 0, ("FOF_OFFSET passed"));
 807
 808         if ((flags & FOF_NOUPDATE) == 0)
 809                 atomic_store_long(&fp->f_offset, val);
 810         if ((flags & FOF_NEXTOFF_R) != 0)
 811                 fp->f_nextoff[UIO_READ] = val;
 812         if ((flags & FOF_NEXTOFF_W) != 0)
 813                 fp->f_nextoff[UIO_WRITE] = val;
 814
 815         if ((flags & FOF_NOLOCK) != 0)
 816                 return;
 817
 818         flagsp = &fp->f_vnread_flags;
 819         state = atomic_load_16(flagsp);
 820         if ((state & FOFFSET_LOCK_WAITING) == 0 &&
 821             atomic_cmpset_rel_16(flagsp, state, 0))
 822                 return;
 823
 824         sleepq_lock(&fp->f_vnread_flags);
 825         MPASS((fp->f_vnread_flags & FOFFSET_LOCKED) != 0);
 826         MPASS((fp->f_vnread_flags & FOFFSET_LOCK_WAITING) != 0);
 827         fp->f_vnread_flags = 0;
 828         sleepq_broadcast(&fp->f_vnread_flags, SLEEPQ_SLEEP, 0, 0);
 829         sleepq_release(&fp->f_vnread_flags);
 830 }
 831
 832 static off_t
 833 foffset_read(struct file *fp)
 834 {
 835
 836         return (atomic_load_long(&fp->f_offset));
 837 }
 838 #else
 839 off_t
 840 foffset_lock(struct file *fp, int flags)
 841 {
 842         struct mtx *mtxp;
 843         off_t res;
 844
 845         KASSERT((flags & FOF_OFFSET) == 0, ("FOF_OFFSET passed"));
 846
 847         mtxp = mtx_pool_find(mtxpool_sleep, fp);
 848         mtx_lock(mtxp);
 849         if ((flags & FOF_NOLOCK) == 0) {
 850                 while (fp->f_vnread_flags & FOFFSET_LOCKED) {
 851                         fp->f_vnread_flags |= FOFFSET_LOCK_WAITING;
 852                         msleep(&fp->f_vnread_flags, mtxp, PUSER -1,
 853                             "vofflock", 0);
 854                 }
 855                 fp->f_vnread_flags |= FOFFSET_LOCKED;
 856         }
 857         res = fp->f_offset;
 858         mtx_unlock(mtxp);
 859         return (res);
 860 }
 861
 862 void
 863 foffset_unlock(struct file *fp, off_t val, int flags)
 864 {
 865         struct mtx *mtxp;
 866
 867         KASSERT((flags & FOF_OFFSET) == 0, ("FOF_OFFSET passed"));
 868
 869         mtxp = mtx_pool_find(mtxpool_sleep, fp);
 870         mtx_lock(mtxp);
 871         if ((flags & FOF_NOUPDATE) == 0)
 872                 fp->f_offset = val;
 873         if ((flags & FOF_NEXTOFF_R) != 0)
 874                 fp->f_nextoff[UIO_READ] = val;
 875         if ((flags & FOF_NEXTOFF_W) != 0)
 876                 fp->f_nextoff[UIO_WRITE] = val;
 877         if ((flags & FOF_NOLOCK) == 0) {
 878                 KASSERT((fp->f_vnread_flags & FOFFSET_LOCKED) != 0,
 879                     ("Lost FOFFSET_LOCKED"));
 880                 if (fp->f_vnread_flags & FOFFSET_LOCK_WAITING)
 881                         wakeup(&fp->f_vnread_flags);
 882                 fp->f_vnread_flags = 0;
 883         }
 884         mtx_unlock(mtxp);
 885 }
 886
 887 static off_t
 888 foffset_read(struct file *fp)
 889 {
 890
 891         return (foffset_lock(fp, FOF_NOLOCK));
 892 }
 893 #endif
 894
 895 void
 896 foffset_lock_uio(struct file *fp, struct uio *uio, int flags)
 897 {
 898
 899         if ((flags & FOF_OFFSET) == 0)
 900                 uio->uio_offset = foffset_lock(fp, flags);
 901 }
 902
 903 void
 904 foffset_unlock_uio(struct file *fp, struct uio *uio, int flags)
 905 {
 906
 907         if ((flags & FOF_OFFSET) == 0)
 908                 foffset_unlock(fp, uio->uio_offset, flags);
 909 }
 910
 911 static int
 912 get_advice(struct file *fp, struct uio *uio)
 913 {
 914         struct mtx *mtxp;
 915         int ret;
 916
 917         ret = POSIX_FADV_NORMAL;
 918         if (fp->f_advice == NULL || fp->f_vnode->v_type != VREG)
 919                 return (ret);
 920
 921         mtxp = mtx_pool_find(mtxpool_sleep, fp);
 922         mtx_lock(mtxp);
 923         if (fp->f_advice != NULL &&
 924             uio->uio_offset >= fp->f_advice->fa_start &&
 925             uio->uio_offset + uio->uio_resid <= fp->f_advice->fa_end)
 926                 ret = fp->f_advice->fa_advice;
 927         mtx_unlock(mtxp);
 928         return (ret);
 929 }
 930
 931 static int
 932 get_write_ioflag(struct file *fp)
 933 {
 934         int ioflag;
 935         struct mount *mp;
 936         struct vnode *vp;
 937
 938         ioflag = 0;
 939         vp = fp->f_vnode;
 940         mp = atomic_load_ptr(&vp->v_mount);
 941
 942         if ((fp->f_flag & O_DIRECT) != 0)
 943                 ioflag |= IO_DIRECT;
 944
 945         if ((fp->f_flag & O_FSYNC) != 0 ||
 946             (mp != NULL && (mp->mnt_flag & MNT_SYNCHRONOUS) != 0))
 947                 ioflag |= IO_SYNC;
 948
 949         /*
 950          * For O_DSYNC we set both IO_SYNC and IO_DATASYNC, so that VOP_WRITE()
 951          * or VOP_DEALLOCATE() implementations that don't understand IO_DATASYNC
 952          * fall back to full O_SYNC behavior.
 953          */
 954         if ((fp->f_flag & O_DSYNC) != 0)
 955                 ioflag |= IO_SYNC | IO_DATASYNC;
 956
 957         return (ioflag);
 958 }
 959
 960 int
 961 vn_read_from_obj(struct vnode *vp, struct uio *uio)
 962 {
 963         vm_object_t obj;
 964         vm_page_t ma[io_hold_cnt + 2];
 965         off_t off, vsz;
 966         ssize_t resid;
 967         int error, i, j;
 968
 969         MPASS(uio->uio_resid <= ptoa(io_hold_cnt + 2));
 970         obj = atomic_load_ptr(&vp->v_object);
 971         if (obj == NULL)
 972                 return (EJUSTRETURN);
 973
 974         /*
 975          * Depends on type stability of vm_objects.
 976          */
 977         vm_object_pip_add(obj, 1);
 978         if ((obj->flags & OBJ_DEAD) != 0) {
 979                 /*
 980                  * Note that object might be already reused from the
 981                  * vnode, and the OBJ_DEAD flag cleared.  This is fine,
 982                  * we recheck for DOOMED vnode state after all pages
 983                  * are busied, and retract then.
 984                  *
 985                  * But we check for OBJ_DEAD to ensure that we do not
 986                  * busy pages while vm_object_terminate_pages()
 987                  * processes the queue.
 988                  */
 989                 error = EJUSTRETURN;
 990                 goto out_pip;
 991         }
 992
 993         resid = uio->uio_resid;
 994         off = uio->uio_offset;
 995         for (i = 0; resid > 0; i++) {
 996                 MPASS(i < io_hold_cnt + 2);
 997                 ma[i] = vm_page_grab_unlocked(obj, atop(off),
 998                     VM_ALLOC_NOCREAT | VM_ALLOC_SBUSY | VM_ALLOC_IGN_SBUSY |
 999                     VM_ALLOC_NOWAIT);
1000                 if (ma[i] == NULL)
1001                         break;
1002
1003                 /*
1004                  * Skip invalid pages.  Valid mask can be partial only
1005                  * at EOF, and we clip later.
1006                  */
1007                 if (vm_page_none_valid(ma[i])) {
1008                         vm_page_sunbusy(ma[i]);
1009                         break;
1010                 }
1011
1012                 resid -= PAGE_SIZE;
1013                 off += PAGE_SIZE;
1014         }
1015         if (i == 0) {
1016                 error = EJUSTRETURN;
1017                 goto out_pip;
1018         }
1019
1020         /*
1021          * Check VIRF_DOOMED after we busied our pages.  Since
1022          * vgonel() terminates the vnode' vm_object, it cannot
1023          * process past pages busied by us.
1024          */
1025         if (VN_IS_DOOMED(vp)) {
1026                 error = EJUSTRETURN;
1027                 goto out;
1028         }
1029
1030         resid = PAGE_SIZE - (uio->uio_offset & PAGE_MASK) + ptoa(i - 1);
1031         if (resid > uio->uio_resid)
1032                 resid = uio->uio_resid;
1033
1034         /*
1035          * Unlocked read of vnp_size is safe because truncation cannot
1036          * pass busied page.  But we load vnp_size into a local
1037          * variable so that possible concurrent extension does not
1038          * break calculation.
1039          */
1040 #if defined(__powerpc__) && !defined(__powerpc64__)
1041         vsz = obj->un_pager.vnp.vnp_size;
1042 #else
1043         vsz = atomic_load_64(&obj->un_pager.vnp.vnp_size);
1044 #endif
1045         if (uio->uio_offset >= vsz) {
1046                 error = EJUSTRETURN;
1047                 goto out;
1048         }
1049         if (uio->uio_offset + resid > vsz)
1050                 resid = vsz - uio->uio_offset;
1051
1052         error = vn_io_fault_pgmove(ma, uio->uio_offset & PAGE_MASK, resid, uio);
1053
1054 out:
1055         for (j = 0; j < i; j++) {
1056                 if (error == 0)
1057                         vm_page_reference(ma[j]);
1058                 vm_page_sunbusy(ma[j]);
1059         }
1060 out_pip:
1061         vm_object_pip_wakeup(obj);
1062         if (error != 0)
1063                 return (error);
1064         return (uio->uio_resid == 0 ? 0 : EJUSTRETURN);
1065 }
1066
1067 /*
1068  * File table vnode read routine.
1069  */
1070 static int
1071 vn_read(struct file *fp, struct uio *uio, struct ucred *active_cred, int flags,
1072     struct thread *td)
1073 {
1074         struct vnode *vp;
1075         off_t orig_offset;
1076         int error, ioflag;
1077         int advice;
1078
1079         KASSERT(uio->uio_td == td, ("uio_td %p is not td %p",
1080             uio->uio_td, td));
1081         KASSERT(flags & FOF_OFFSET, ("No FOF_OFFSET"));
1082         vp = fp->f_vnode;
1083         ioflag = 0;
1084         if (fp->f_flag & FNONBLOCK)
1085                 ioflag |= IO_NDELAY;
1086         if (fp->f_flag & O_DIRECT)
1087                 ioflag |= IO_DIRECT;
1088
1089         /*
1090          * Try to read from page cache.  VIRF_DOOMED check is racy but
1091          * allows us to avoid unneeded work outright.
1092          */
1093         if (vn_io_pgcache_read_enable && !mac_vnode_check_read_enabled() &&
1094             (vn_irflag_read(vp) & (VIRF_DOOMED | VIRF_PGREAD)) == VIRF_PGREAD) {
1095                 error = VOP_READ_PGCACHE(vp, uio, ioflag, fp->f_cred);
1096                 if (error == 0) {
1097                         fp->f_nextoff[UIO_READ] = uio->uio_offset;
1098                         return (0);
1099                 }
1100                 if (error != EJUSTRETURN)
1101                         return (error);
1102         }
1103
1104         advice = get_advice(fp, uio);
1105         vn_lock(vp, LK_SHARED | LK_RETRY);
1106
1107         switch (advice) {
1108         case POSIX_FADV_NORMAL:
1109         case POSIX_FADV_SEQUENTIAL:
1110         case POSIX_FADV_NOREUSE:
1111                 ioflag |= sequential_heuristic(uio, fp);
1112                 break;
1113         case POSIX_FADV_RANDOM:
1114                 /* Disable read-ahead for random I/O. */
1115                 break;
1116         }
1117         orig_offset = uio->uio_offset;
1118
1119 #ifdef MAC
1120         error = mac_vnode_check_read(active_cred, fp->f_cred, vp);
1121         if (error == 0)
1122 #endif
1123                 error = VOP_READ(vp, uio, ioflag, fp->f_cred);
1124         fp->f_nextoff[UIO_READ] = uio->uio_offset;
1125         VOP_UNLOCK(vp);
1126         if (error == 0 && advice == POSIX_FADV_NOREUSE &&
1127             orig_offset != uio->uio_offset)
1128                 /*
1129                  * Use POSIX_FADV_DONTNEED to flush pages and buffers
1130                  * for the backing file after a POSIX_FADV_NOREUSE
1131                  * read(2).
1132                  */
1133                 error = VOP_ADVISE(vp, orig_offset, uio->uio_offset - 1,
1134                     POSIX_FADV_DONTNEED);
1135         return (error);
1136 }
1137
1138 /*
1139  * File table vnode write routine.
1140  */
1141 static int
1142 vn_write(struct file *fp, struct uio *uio, struct ucred *active_cred, int flags,
1143     struct thread *td)
1144 {
1145         struct vnode *vp;
1146         struct mount *mp;
1147         off_t orig_offset;
1148         int error, ioflag;
1149         int advice;
1150         bool need_finished_write;
1151
1152         KASSERT(uio->uio_td == td, ("uio_td %p is not td %p",
1153             uio->uio_td, td));
1154         KASSERT(flags & FOF_OFFSET, ("No FOF_OFFSET"));
1155         vp = fp->f_vnode;
1156         if (vp->v_type == VREG)
1157                 bwillwrite();
1158         ioflag = IO_UNIT;
1159         if (vp->v_type == VREG && (fp->f_flag & O_APPEND) != 0)
1160                 ioflag |= IO_APPEND;
1161         if ((fp->f_flag & FNONBLOCK) != 0)
1162                 ioflag |= IO_NDELAY;
1163         ioflag |= get_write_ioflag(fp);
1164
1165         mp = NULL;
1166         need_finished_write = false;
1167         if (vp->v_type != VCHR) {
1168                 error = vn_start_write(vp, &mp, V_WAIT | V_PCATCH);
1169                 if (error != 0)
1170                         goto unlock;
1171                 need_finished_write = true;
1172         }
1173
1174         advice = get_advice(fp, uio);
1175
1176         vn_lock(vp, vn_lktype_write(mp, vp) | LK_RETRY);
1177         switch (advice) {
1178         case POSIX_FADV_NORMAL:
1179         case POSIX_FADV_SEQUENTIAL:
1180         case POSIX_FADV_NOREUSE:
1181                 ioflag |= sequential_heuristic(uio, fp);
1182                 break;
1183         case POSIX_FADV_RANDOM:
1184                 /* XXX: Is this correct? */
1185                 break;
1186         }
1187         orig_offset = uio->uio_offset;
1188
1189 #ifdef MAC
1190         error = mac_vnode_check_write(active_cred, fp->f_cred, vp);
1191         if (error == 0)
1192 #endif
1193                 error = VOP_WRITE(vp, uio, ioflag, fp->f_cred);
1194         fp->f_nextoff[UIO_WRITE] = uio->uio_offset;
1195         VOP_UNLOCK(vp);
1196         if (need_finished_write)
1197                 vn_finished_write(mp);
1198         if (error == 0 && advice == POSIX_FADV_NOREUSE &&
1199             orig_offset != uio->uio_offset)
1200                 /*
1201                  * Use POSIX_FADV_DONTNEED to flush pages and buffers
1202                  * for the backing file after a POSIX_FADV_NOREUSE
1203                  * write(2).
1204                  */
1205                 error = VOP_ADVISE(vp, orig_offset, uio->uio_offset - 1,
1206                     POSIX_FADV_DONTNEED);
1207 unlock:
1208         return (error);
1209 }
1210
1211 /*
1212  * The vn_io_fault() is a wrapper around vn_read() and vn_write() to
1213  * prevent the following deadlock:
1214  *
1215  * Assume that the thread A reads from the vnode vp1 into userspace
1216  * buffer buf1 backed by the pages of vnode vp2.  If a page in buf1 is
1217  * currently not resident, then system ends up with the call chain
1218  *   vn_read() -> VOP_READ(vp1) -> uiomove() -> [Page Fault] ->
1219  *     vm_fault(buf1) -> vnode_pager_getpages(vp2) -> VOP_GETPAGES(vp2)
1220  * which establishes lock order vp1->vn_lock, then vp2->vn_lock.
1221  * If, at the same time, thread B reads from vnode vp2 into buffer buf2
1222  * backed by the pages of vnode vp1, and some page in buf2 is not
1223  * resident, we get a reversed order vp2->vn_lock, then vp1->vn_lock.
1224  *
1225  * To prevent the lock order reversal and deadlock, vn_io_fault() does
1226  * not allow page faults to happen during VOP_READ() or VOP_WRITE().
1227  * Instead, it first tries to do the whole range i/o with pagefaults
1228  * disabled. If all pages in the i/o buffer are resident and mapped,
1229  * VOP will succeed (ignoring the genuine filesystem errors).
1230  * Otherwise, we get back EFAULT, and vn_io_fault() falls back to do
1231  * i/o in chunks, with all pages in the chunk prefaulted and held
1232  * using vm_fault_quick_hold_pages().
1233  *
1234  * Filesystems using this deadlock avoidance scheme should use the
1235  * array of the held pages from uio, saved in the curthread->td_ma,
1236  * instead of doing uiomove().  A helper function
1237  * vn_io_fault_uiomove() converts uiomove request into
1238  * uiomove_fromphys() over td_ma array.
1239  *
1240  * Since vnode locks do not cover the whole i/o anymore, rangelocks
1241  * make the current i/o request atomic with respect to other i/os and
1242  * truncations.
1243  */
1244
1245 /*
1246  * Decode vn_io_fault_args and perform the corresponding i/o.
1247  */
1248 static int
1249 vn_io_fault_doio(struct vn_io_fault_args *args, struct uio *uio,
1250     struct thread *td)
1251 {
1252         int error, save;
1253
1254         error = 0;
1255         save = vm_fault_disable_pagefaults();
1256         switch (args->kind) {
1257         case VN_IO_FAULT_FOP:
1258                 error = (args->args.fop_args.doio)(args->args.fop_args.fp,
1259                     uio, args->cred, args->flags, td);
1260                 break;
1261         case VN_IO_FAULT_VOP:
1262                 if (uio->uio_rw == UIO_READ) {
1263                         error = VOP_READ(args->args.vop_args.vp, uio,
1264                             args->flags, args->cred);
1265                 } else if (uio->uio_rw == UIO_WRITE) {
1266                         error = VOP_WRITE(args->args.vop_args.vp, uio,
1267                             args->flags, args->cred);
1268                 }
1269                 break;
1270         default:
1271                 panic("vn_io_fault_doio: unknown kind of io %d %d",
1272                     args->kind, uio->uio_rw);
1273         }
1274         vm_fault_enable_pagefaults(save);
1275         return (error);
1276 }
1277
1278 static int
1279 vn_io_fault_touch(char *base, const struct uio *uio)
1280 {
1281         int r;
1282
1283         r = fubyte(base);
1284         if (r == -1 || (uio->uio_rw == UIO_READ && subyte(base, r) == -1))
1285                 return (EFAULT);
1286         return (0);
1287 }
1288
1289 static int
1290 vn_io_fault_prefault_user(const struct uio *uio)
1291 {
1292         char *base;
1293         const struct iovec *iov;
1294         size_t len;
1295         ssize_t resid;
1296         int error, i;
1297
1298         KASSERT(uio->uio_segflg == UIO_USERSPACE,
1299             ("vn_io_fault_prefault userspace"));
1300
1301         error = i = 0;
1302         iov = uio->uio_iov;
1303         resid = uio->uio_resid;
1304         base = iov->iov_base;
1305         len = iov->iov_len;
1306         while (resid > 0) {
1307                 error = vn_io_fault_touch(base, uio);
1308                 if (error != 0)
1309                         break;
1310                 if (len < PAGE_SIZE) {
1311                         if (len != 0) {
1312                                 error = vn_io_fault_touch(base + len - 1, uio);
1313                                 if (error != 0)
1314                                         break;
1315                                 resid -= len;
1316                         }
1317                         if (++i >= uio->uio_iovcnt)
1318                                 break;
1319                         iov = uio->uio_iov + i;
1320                         base = iov->iov_base;
1321                         len = iov->iov_len;
1322                 } else {
1323                         len -= PAGE_SIZE;
1324                         base += PAGE_SIZE;
1325                         resid -= PAGE_SIZE;
1326                 }
1327         }
1328         return (error);
1329 }
1330
1331 /*
1332  * Common code for vn_io_fault(), agnostic to the kind of i/o request.
1333  * Uses vn_io_fault_doio() to make the call to an actual i/o function.
1334  * Used from vn_rdwr() and vn_io_fault(), which encode the i/o request
1335  * into args and call vn_io_fault1() to handle faults during the user
1336  * mode buffer accesses.
1337  */
1338 static int
1339 vn_io_fault1(struct vnode *vp, struct uio *uio, struct vn_io_fault_args *args,
1340     struct thread *td)
1341 {
1342         vm_page_t ma[io_hold_cnt + 2];
1343         struct uio *uio_clone, short_uio;
1344         struct iovec short_iovec[1];
1345         vm_page_t *prev_td_ma;
1346         vm_prot_t prot;
1347         vm_offset_t addr, end;
1348         size_t len, resid;
1349         ssize_t adv;
1350         int error, cnt, saveheld, prev_td_ma_cnt;
1351
1352         if (vn_io_fault_prefault) {
1353                 error = vn_io_fault_prefault_user(uio);
1354                 if (error != 0)
1355                         return (error); /* Or ignore ? */
1356         }
1357
1358         prot = uio->uio_rw == UIO_READ ? VM_PROT_WRITE : VM_PROT_READ;
1359
1360         /*
1361          * The UFS follows IO_UNIT directive and replays back both
1362          * uio_offset and uio_resid if an error is encountered during the
1363          * operation.  But, since the iovec may be already advanced,
1364          * uio is still in an inconsistent state.
1365          *
1366          * Cache a copy of the original uio, which is advanced to the redo
1367          * point using UIO_NOCOPY below.
1368          */
1369         uio_clone = cloneuio(uio);
1370         resid = uio->uio_resid;
1371
1372         short_uio.uio_segflg = UIO_USERSPACE;
1373         short_uio.uio_rw = uio->uio_rw;
1374         short_uio.uio_td = uio->uio_td;
1375
1376         error = vn_io_fault_doio(args, uio, td);
1377         if (error != EFAULT)
1378                 goto out;
1379
1380         atomic_add_long(&vn_io_faults_cnt, 1);
1381         uio_clone->uio_segflg = UIO_NOCOPY;
1382         uiomove(NULL, resid - uio->uio_resid, uio_clone);
1383         uio_clone->uio_segflg = uio->uio_segflg;
1384
1385         saveheld = curthread_pflags_set(TDP_UIOHELD);
1386         prev_td_ma = td->td_ma;
1387         prev_td_ma_cnt = td->td_ma_cnt;
1388
1389         while (uio_clone->uio_resid != 0) {
1390                 len = uio_clone->uio_iov->iov_len;
1391                 if (len == 0) {
1392                         KASSERT(uio_clone->uio_iovcnt >= 1,
1393                             ("iovcnt underflow"));
1394                         uio_clone->uio_iov++;
1395                         uio_clone->uio_iovcnt--;
1396                         continue;
1397                 }
1398                 if (len > ptoa(io_hold_cnt))
1399                         len = ptoa(io_hold_cnt);
1400                 addr = (uintptr_t)uio_clone->uio_iov->iov_base;
1401                 end = round_page(addr + len);
1402                 if (end < addr) {
1403                         error = EFAULT;
1404                         break;
1405                 }
1406                 /*
1407                  * A perfectly misaligned address and length could cause
1408                  * both the start and the end of the chunk to use partial
1409                  * page.  +2 accounts for such a situation.
1410                  */
1411                 cnt = vm_fault_quick_hold_pages(&td->td_proc->p_vmspace->vm_map,
1412                     addr, len, prot, ma, io_hold_cnt + 2);
1413                 if (cnt == -1) {
1414                         error = EFAULT;
1415                         break;
1416                 }
1417                 short_uio.uio_iov = &short_iovec[0];
1418                 short_iovec[0].iov_base = (void *)addr;
1419                 short_uio.uio_iovcnt = 1;
1420                 short_uio.uio_resid = short_iovec[0].iov_len = len;
1421                 short_uio.uio_offset = uio_clone->uio_offset;
1422                 td->td_ma = ma;
1423                 td->td_ma_cnt = cnt;
1424
1425                 error = vn_io_fault_doio(args, &short_uio, td);
1426                 vm_page_unhold_pages(ma, cnt);
1427                 adv = len - short_uio.uio_resid;
1428
1429                 uio_clone->uio_iov->iov_base =
1430                     (char *)uio_clone->uio_iov->iov_base + adv;
1431                 uio_clone->uio_iov->iov_len -= adv;
1432                 uio_clone->uio_resid -= adv;
1433                 uio_clone->uio_offset += adv;
1434
1435                 uio->uio_resid -= adv;
1436                 uio->uio_offset += adv;
1437
1438                 if (error != 0 || adv == 0)
1439                         break;
1440         }
1441         td->td_ma = prev_td_ma;
1442         td->td_ma_cnt = prev_td_ma_cnt;
1443         curthread_pflags_restore(saveheld);
1444 out:
1445         freeuio(uio_clone);
1446         return (error);
1447 }
1448
1449 static int
1450 vn_io_fault(struct file *fp, struct uio *uio, struct ucred *active_cred,
1451     int flags, struct thread *td)
1452 {
1453         fo_rdwr_t *doio;
1454         struct vnode *vp;
1455         void *rl_cookie;
1456         struct vn_io_fault_args args;
1457         int error;
1458         bool do_io_fault, do_rangelock;
1459
1460         doio = uio->uio_rw == UIO_READ ? vn_read : vn_write;
1461         vp = fp->f_vnode;
1462
1463         /*
1464          * The ability to read(2) on a directory has historically been
1465          * allowed for all users, but this can and has been the source of
1466          * at least one security issue in the past.  As such, it is now hidden
1467          * away behind a sysctl for those that actually need it to use it, and
1468          * restricted to root when it's turned on to make it relatively safe to
1469          * leave on for longer sessions of need.
1470          */
1471         if (vp->v_type == VDIR) {
1472                 KASSERT(uio->uio_rw == UIO_READ,
1473                     ("illegal write attempted on a directory"));
1474                 if (!vfs_allow_read_dir)
1475                         return (EISDIR);
1476                 if ((error = priv_check(td, PRIV_VFS_READ_DIR)) != 0)
1477                         return (EISDIR);
1478         }
1479
1480         do_io_fault = do_vn_io_fault(vp, uio);
1481         do_rangelock = do_io_fault || (vn_irflag_read(vp) & VIRF_PGREAD) != 0;
1482         foffset_lock_uio(fp, uio, flags);
1483         if (do_rangelock) {
1484                 if (uio->uio_rw == UIO_READ) {
1485                         rl_cookie = vn_rangelock_rlock(vp, uio->uio_offset,
1486                             uio->uio_offset + uio->uio_resid);
1487                 } else if ((fp->f_flag & O_APPEND) != 0 ||
1488                     (flags & FOF_OFFSET) == 0) {
1489                         /* For appenders, punt and lock the whole range. */
1490                         rl_cookie = vn_rangelock_wlock(vp, 0, OFF_MAX);
1491                 } else {
1492                         rl_cookie = vn_rangelock_wlock(vp, uio->uio_offset,
1493                             uio->uio_offset + uio->uio_resid);
1494                 }
1495         }
1496         if (do_io_fault) {
1497                 args.kind = VN_IO_FAULT_FOP;
1498                 args.args.fop_args.fp = fp;
1499                 args.args.fop_args.doio = doio;
1500                 args.cred = active_cred;
1501                 args.flags = flags | FOF_OFFSET;
1502                 error = vn_io_fault1(vp, uio, &args, td);
1503         } else {
1504                 error = doio(fp, uio, active_cred, flags | FOF_OFFSET, td);
1505         }
1506         if (do_rangelock)
1507                 vn_rangelock_unlock(vp, rl_cookie);
1508         foffset_unlock_uio(fp, uio, flags);
1509         return (error);
1510 }
1511
1512 /*
1513  * Helper function to perform the requested uiomove operation using
1514  * the held pages for io->uio_iov[0].iov_base buffer instead of
1515  * copyin/copyout.  Access to the pages with uiomove_fromphys()
1516  * instead of iov_base prevents page faults that could occur due to
1517  * pmap_collect() invalidating the mapping created by
1518  * vm_fault_quick_hold_pages(), or pageout daemon, page laundry or
1519  * object cleanup revoking the write access from page mappings.
1520  *
1521  * Filesystems specified MNTK_NO_IOPF shall use vn_io_fault_uiomove()
1522  * instead of plain uiomove().
1523  */
1524 int
1525 vn_io_fault_uiomove(char *data, int xfersize, struct uio *uio)
1526 {
1527         struct uio transp_uio;
1528         struct iovec transp_iov[1];
1529         struct thread *td;
1530         size_t adv;
1531         int error, pgadv;
1532
1533         td = curthread;
1534         if ((td->td_pflags & TDP_UIOHELD) == 0 ||
1535             uio->uio_segflg != UIO_USERSPACE)
1536                 return (uiomove(data, xfersize, uio));
1537
1538         KASSERT(uio->uio_iovcnt == 1, ("uio_iovcnt %d", uio->uio_iovcnt));
1539         transp_iov[0].iov_base = data;
1540         transp_uio.uio_iov = &transp_iov[0];
1541         transp_uio.uio_iovcnt = 1;
1542         if (xfersize > uio->uio_resid)
1543                 xfersize = uio->uio_resid;
1544         transp_uio.uio_resid = transp_iov[0].iov_len = xfersize;
1545         transp_uio.uio_offset = 0;
1546         transp_uio.uio_segflg = UIO_SYSSPACE;
1547         /*
1548          * Since transp_iov points to data, and td_ma page array
1549          * corresponds to original uio->uio_iov, we need to invert the
1550          * direction of the i/o operation as passed to
1551          * uiomove_fromphys().
1552          */
1553         switch (uio->uio_rw) {
1554         case UIO_WRITE:
1555                 transp_uio.uio_rw = UIO_READ;
1556                 break;
1557         case UIO_READ:
1558                 transp_uio.uio_rw = UIO_WRITE;
1559                 break;
1560         }
1561         transp_uio.uio_td = uio->uio_td;
1562         error = uiomove_fromphys(td->td_ma,
1563             ((vm_offset_t)uio->uio_iov->iov_base) & PAGE_MASK,
1564             xfersize, &transp_uio);
1565         adv = xfersize - transp_uio.uio_resid;
1566         pgadv =
1567             (((vm_offset_t)uio->uio_iov->iov_base + adv) >> PAGE_SHIFT) -
1568             (((vm_offset_t)uio->uio_iov->iov_base) >> PAGE_SHIFT);
1569         td->td_ma += pgadv;
1570         KASSERT(td->td_ma_cnt >= pgadv, ("consumed pages %d %d", td->td_ma_cnt,
1571             pgadv));
1572         td->td_ma_cnt -= pgadv;
1573         uio->uio_iov->iov_base = (char *)uio->uio_iov->iov_base + adv;
1574         uio->uio_iov->iov_len -= adv;
1575         uio->uio_resid -= adv;
1576         uio->uio_offset += adv;
1577         return (error);
1578 }
1579
1580 int
1581 vn_io_fault_pgmove(vm_page_t ma[], vm_offset_t offset, int xfersize,
1582     struct uio *uio)
1583 {
1584         struct thread *td;
1585         vm_offset_t iov_base;
1586         int cnt, pgadv;
1587
1588         td = curthread;
1589         if ((td->td_pflags & TDP_UIOHELD) == 0 ||
1590             uio->uio_segflg != UIO_USERSPACE)
1591                 return (uiomove_fromphys(ma, offset, xfersize, uio));
1592
1593         KASSERT(uio->uio_iovcnt == 1, ("uio_iovcnt %d", uio->uio_iovcnt));
1594         cnt = xfersize > uio->uio_resid ? uio->uio_resid : xfersize;
1595         iov_base = (vm_offset_t)uio->uio_iov->iov_base;
1596         switch (uio->uio_rw) {
1597         case UIO_WRITE:
1598                 pmap_copy_pages(td->td_ma, iov_base & PAGE_MASK, ma,
1599                     offset, cnt);
1600                 break;
1601         case UIO_READ:
1602                 pmap_copy_pages(ma, offset, td->td_ma, iov_base & PAGE_MASK,
1603                     cnt);
1604                 break;
1605         }
1606         pgadv = ((iov_base + cnt) >> PAGE_SHIFT) - (iov_base >> PAGE_SHIFT);
1607         td->td_ma += pgadv;
1608         KASSERT(td->td_ma_cnt >= pgadv, ("consumed pages %d %d", td->td_ma_cnt,
1609             pgadv));
1610         td->td_ma_cnt -= pgadv;
1611         uio->uio_iov->iov_base = (char *)(iov_base + cnt);
1612         uio->uio_iov->iov_len -= cnt;
1613         uio->uio_resid -= cnt;
1614         uio->uio_offset += cnt;
1615         return (0);
1616 }
1617
1618 /*
1619  * File table truncate routine.
1620  */
1621 static int
1622 vn_truncate(struct file *fp, off_t length, struct ucred *active_cred,
1623     struct thread *td)
1624 {
1625         struct mount *mp;
1626         struct vnode *vp;
1627         void *rl_cookie;
1628         int error;
1629
1630         vp = fp->f_vnode;
1631
1632 retry:
1633         /*
1634          * Lock the whole range for truncation.  Otherwise split i/o
1635          * might happen partly before and partly after the truncation.
1636          */
1637         rl_cookie = vn_rangelock_wlock(vp, 0, OFF_MAX);
1638         error = vn_start_write(vp, &mp, V_WAIT | V_PCATCH);
1639         if (error)
1640                 goto out1;
1641         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
1642         AUDIT_ARG_VNODE1(vp);
1643         if (vp->v_type == VDIR) {
1644                 error = EISDIR;
1645                 goto out;
1646         }
1647 #ifdef MAC
1648         error = mac_vnode_check_write(active_cred, fp->f_cred, vp);
1649         if (error)
1650                 goto out;
1651 #endif
1652         error = vn_truncate_locked(vp, length, (fp->f_flag & O_FSYNC) != 0,
1653             fp->f_cred);
1654 out:
1655         VOP_UNLOCK(vp);
1656         vn_finished_write(mp);
1657 out1:
1658         vn_rangelock_unlock(vp, rl_cookie);
1659         if (error == ERELOOKUP)
1660                 goto retry;
1661         return (error);
1662 }
1663
1664 /*
1665  * Truncate a file that is already locked.
1666  */
1667 int
1668 vn_truncate_locked(struct vnode *vp, off_t length, bool sync,
1669     struct ucred *cred)
1670 {
1671         struct vattr vattr;
1672         int error;
1673
1674         error = VOP_ADD_WRITECOUNT(vp, 1);
1675         if (error == 0) {
1676                 VATTR_NULL(&vattr);
1677                 vattr.va_size = length;
1678                 if (sync)
1679                         vattr.va_vaflags |= VA_SYNC;
1680                 error = VOP_SETATTR(vp, &vattr, cred);
1681                 VOP_ADD_WRITECOUNT_CHECKED(vp, -1);
1682         }
1683         return (error);
1684 }
1685
1686 /*
1687  * File table vnode stat routine.
1688  */
1689 int
1690 vn_statfile(struct file *fp, struct stat *sb, struct ucred *active_cred)
1691 {
1692         struct vnode *vp = fp->f_vnode;
1693         int error;
1694
1695         vn_lock(vp, LK_SHARED | LK_RETRY);
1696         error = VOP_STAT(vp, sb, active_cred, fp->f_cred);
1697         VOP_UNLOCK(vp);
1698
1699         return (error);
1700 }
1701
1702 /*
1703  * File table vnode ioctl routine.
1704  */
1705 static int
1706 vn_ioctl(struct file *fp, u_long com, void *data, struct ucred *active_cred,
1707     struct thread *td)
1708 {
1709         struct vnode *vp;
1710         struct fiobmap2_arg *bmarg;
1711         off_t size;
1712         int error;
1713
1714         vp = fp->f_vnode;
1715         switch (vp->v_type) {
1716         case VDIR:
1717         case VREG:
1718                 switch (com) {
1719                 case FIONREAD:
1720                         error = vn_getsize(vp, &size, active_cred);
1721                         if (error == 0)
1722                                 *(int *)data = size - fp->f_offset;
1723                         return (error);
1724                 case FIOBMAP2:
1725                         bmarg = (struct fiobmap2_arg *)data;
1726                         vn_lock(vp, LK_SHARED | LK_RETRY);
1727 #ifdef MAC
1728                         error = mac_vnode_check_read(active_cred, fp->f_cred,
1729                             vp);
1730                         if (error == 0)
1731 #endif
1732                                 error = VOP_BMAP(vp, bmarg->bn, NULL,
1733                                     &bmarg->bn, &bmarg->runp, &bmarg->runb);
1734                         VOP_UNLOCK(vp);
1735                         return (error);
1736                 case FIONBIO:
1737                 case FIOASYNC:
1738                         return (0);
1739                 default:
1740                         return (VOP_IOCTL(vp, com, data, fp->f_flag,
1741                             active_cred, td));
1742                 }
1743                 break;
1744         case VCHR:
1745                 return (VOP_IOCTL(vp, com, data, fp->f_flag,
1746                     active_cred, td));
1747         default:
1748                 return (ENOTTY);
1749         }
1750 }
1751
1752 /*
1753  * File table vnode poll routine.
1754  */
1755 static int
1756 vn_poll(struct file *fp, int events, struct ucred *active_cred,
1757     struct thread *td)
1758 {
1759         struct vnode *vp;
1760         int error;
1761
1762         vp = fp->f_vnode;
1763 #if defined(MAC) || defined(AUDIT)
1764         if (AUDITING_TD(td) || mac_vnode_check_poll_enabled()) {
1765                 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
1766                 AUDIT_ARG_VNODE1(vp);
1767                 error = mac_vnode_check_poll(active_cred, fp->f_cred, vp);
1768                 VOP_UNLOCK(vp);
1769                 if (error != 0)
1770                         return (error);
1771         }
1772 #endif
1773         error = VOP_POLL(vp, events, fp->f_cred, td);
1774         return (error);
1775 }
1776
1777 /*
1778  * Acquire the requested lock and then check for validity.  LK_RETRY
1779  * permits vn_lock to return doomed vnodes.
1780  */
1781 static int __noinline
1782 _vn_lock_fallback(struct vnode *vp, int flags, const char *file, int line,
1783     int error)
1784 {
1785
1786         KASSERT((flags & LK_RETRY) == 0 || error == 0,
1787             ("vn_lock: error %d incompatible with flags %#x", error, flags));
1788
1789         if (error == 0)
1790                 VNASSERT(VN_IS_DOOMED(vp), vp, ("vnode not doomed"));
1791
1792         if ((flags & LK_RETRY) == 0) {
1793                 if (error == 0) {
1794                         VOP_UNLOCK(vp);
1795                         error = ENOENT;
1796                 }
1797                 return (error);
1798         }
1799
1800         /*
1801          * LK_RETRY case.
1802          *
1803          * Nothing to do if we got the lock.
1804          */
1805         if (error == 0)
1806                 return (0);
1807
1808         /*
1809          * Interlock was dropped by the call in _vn_lock.
1810          */
1811         flags &= ~LK_INTERLOCK;
1812         do {
1813                 error = VOP_LOCK1(vp, flags, file, line);
1814         } while (error != 0);
1815         return (0);
1816 }
1817
1818 int
1819 _vn_lock(struct vnode *vp, int flags, const char *file, int line)
1820 {
1821         int error;
1822
1823         VNASSERT((flags & LK_TYPE_MASK) != 0, vp,
1824             ("vn_lock: no locktype (%d passed)", flags));
1825         VNPASS(vp->v_holdcnt > 0, vp);
1826         error = VOP_LOCK1(vp, flags, file, line);
1827         if (__predict_false(error != 0 || VN_IS_DOOMED(vp)))
1828                 return (_vn_lock_fallback(vp, flags, file, line, error));
1829         return (0);
1830 }
1831
1832 /*
1833  * File table vnode close routine.
1834  */
1835 static int
1836 vn_closefile(struct file *fp, struct thread *td)
1837 {
1838         struct vnode *vp;
1839         struct flock lf;
1840         int error;
1841         bool ref;
1842
1843         vp = fp->f_vnode;
1844         fp->f_ops = &badfileops;
1845         ref = (fp->f_flag & FHASLOCK) != 0;
1846
1847         error = vn_close1(vp, fp->f_flag, fp->f_cred, td, ref);
1848
1849         if (__predict_false(ref)) {
1850                 lf.l_whence = SEEK_SET;
1851                 lf.l_start = 0;
1852                 lf.l_len = 0;
1853                 lf.l_type = F_UNLCK;
1854                 (void) VOP_ADVLOCK(vp, fp, F_UNLCK, &lf, F_FLOCK);
1855                 vrele(vp);
1856         }
1857         return (error);
1858 }
1859
1860 /*
1861  * Preparing to start a filesystem write operation. If the operation is
1862  * permitted, then we bump the count of operations in progress and
1863  * proceed. If a suspend request is in progress, we wait until the
1864  * suspension is over, and then proceed.
1865  */
1866 static int
1867 vn_start_write_refed(struct mount *mp, int flags, bool mplocked)
1868 {
1869         struct mount_pcpu *mpcpu;
1870         int error, mflags;
1871
1872         if (__predict_true(!mplocked) && (flags & V_XSLEEP) == 0 &&
1873             vfs_op_thread_enter(mp, mpcpu)) {
1874                 MPASS((mp->mnt_kern_flag & MNTK_SUSPEND) == 0);
1875                 vfs_mp_count_add_pcpu(mpcpu, writeopcount, 1);
1876                 vfs_op_thread_exit(mp, mpcpu);
1877                 return (0);
1878         }
1879
1880         if (mplocked)
1881                 mtx_assert(MNT_MTX(mp), MA_OWNED);
1882         else
1883                 MNT_ILOCK(mp);
1884
1885         error = 0;
1886
1887         /*
1888          * Check on status of suspension.
1889          */
1890         if ((curthread->td_pflags & TDP_IGNSUSP) == 0 ||
1891             mp->mnt_susp_owner != curthread) {
1892                 mflags = 0;
1893                 if ((mp->mnt_vfc->vfc_flags & VFCF_SBDRY) != 0) {
1894                         if (flags & V_PCATCH)
1895                                 mflags |= PCATCH;
1896                 }
1897                 mflags |= (PUSER - 1);
1898                 while ((mp->mnt_kern_flag & MNTK_SUSPEND) != 0) {
1899                         if ((flags & V_NOWAIT) != 0) {
1900                                 error = EWOULDBLOCK;
1901                                 goto unlock;
1902                         }
1903                         error = msleep(&mp->mnt_flag, MNT_MTX(mp), mflags,
1904                             "suspfs", 0);
1905                         if (error != 0)
1906                                 goto unlock;
1907                 }
1908         }
1909         if ((flags & V_XSLEEP) != 0)
1910                 goto unlock;
1911         mp->mnt_writeopcount++;
1912 unlock:
1913         if (error != 0 || (flags & V_XSLEEP) != 0)
1914                 MNT_REL(mp);
1915         MNT_IUNLOCK(mp);
1916         return (error);
1917 }
1918
1919 int
1920 vn_start_write(struct vnode *vp, struct mount **mpp, int flags)
1921 {
1922         struct mount *mp;
1923         int error;
1924
1925         KASSERT((flags & ~V_VALID_FLAGS) == 0,
1926             ("%s: invalid flags passed %d\n", __func__, flags));
1927
1928         error = 0;
1929         /*
1930          * If a vnode is provided, get and return the mount point that
1931          * to which it will write.
1932          */
1933         if (vp != NULL) {
1934                 if ((error = VOP_GETWRITEMOUNT(vp, mpp)) != 0) {
1935                         *mpp = NULL;
1936                         if (error != EOPNOTSUPP)
1937                                 return (error);
1938                         return (0);
1939                 }
1940         }
1941         if ((mp = *mpp) == NULL)
1942                 return (0);
1943
1944         /*
1945          * VOP_GETWRITEMOUNT() returns with the mp refcount held through
1946          * a vfs_ref().
1947          * As long as a vnode is not provided we need to acquire a
1948          * refcount for the provided mountpoint too, in order to
1949          * emulate a vfs_ref().
1950          */
1951         if (vp == NULL)
1952                 vfs_ref(mp);
1953
1954         error = vn_start_write_refed(mp, flags, false);
1955         if (error != 0 && (flags & V_NOWAIT) == 0)
1956                 *mpp = NULL;
1957         return (error);
1958 }
1959
1960 /*
1961  * Secondary suspension. Used by operations such as vop_inactive
1962  * routines that are needed by the higher level functions. These
1963  * are allowed to proceed until all the higher level functions have
1964  * completed (indicated by mnt_writeopcount dropping to zero). At that
1965  * time, these operations are halted until the suspension is over.
1966  */
1967 int
1968 vn_start_secondary_write(struct vnode *vp, struct mount **mpp, int flags)
1969 {
1970         struct mount *mp;
1971         int error, mflags;
1972
1973         KASSERT((flags & (~V_VALID_FLAGS | V_XSLEEP)) == 0,
1974             ("%s: invalid flags passed %d\n", __func__, flags));
1975
1976  retry:
1977         if (vp != NULL) {
1978                 if ((error = VOP_GETWRITEMOUNT(vp, mpp)) != 0) {
1979                         *mpp = NULL;
1980                         if (error != EOPNOTSUPP)
1981                                 return (error);
1982                         return (0);
1983                 }
1984         }
1985         /*
1986          * If we are not suspended or have not yet reached suspended
1987          * mode, then let the operation proceed.
1988          */
1989         if ((mp = *mpp) == NULL)
1990                 return (0);
1991
1992         /*
1993          * VOP_GETWRITEMOUNT() returns with the mp refcount held through
1994          * a vfs_ref().
1995          * As long as a vnode is not provided we need to acquire a
1996          * refcount for the provided mountpoint too, in order to
1997          * emulate a vfs_ref().
1998          */
1999         MNT_ILOCK(mp);
2000         if (vp == NULL)
2001                 MNT_REF(mp);
2002         if ((mp->mnt_kern_flag & (MNTK_SUSPENDED | MNTK_SUSPEND2)) == 0) {
2003                 mp->mnt_secondary_writes++;
2004                 mp->mnt_secondary_accwrites++;
2005                 MNT_IUNLOCK(mp);
2006                 return (0);
2007         }
2008         if ((flags & V_NOWAIT) != 0) {
2009                 MNT_REL(mp);
2010                 MNT_IUNLOCK(mp);
2011                 *mpp = NULL;
2012                 return (EWOULDBLOCK);
2013         }
2014         /*
2015          * Wait for the suspension to finish.
2016          */
2017         mflags = 0;
2018         if ((mp->mnt_vfc->vfc_flags & VFCF_SBDRY) != 0) {
2019                 if ((flags & V_PCATCH) != 0)
2020                         mflags |= PCATCH;
2021         }
2022         mflags |= (PUSER - 1) | PDROP;
2023         error = msleep(&mp->mnt_flag, MNT_MTX(mp), mflags, "suspfs", 0);
2024         vfs_rel(mp);
2025         if (error == 0)
2026                 goto retry;
2027         *mpp = NULL;
2028         return (error);
2029 }
2030
2031 /*
2032  * Filesystem write operation has completed. If we are suspending and this
2033  * operation is the last one, notify the suspender that the suspension is
2034  * now in effect.
2035  */
2036 void
2037 vn_finished_write(struct mount *mp)
2038 {
2039         struct mount_pcpu *mpcpu;
2040         int c;
2041
2042         if (mp == NULL)
2043                 return;
2044
2045         if (vfs_op_thread_enter(mp, mpcpu)) {
2046                 vfs_mp_count_sub_pcpu(mpcpu, writeopcount, 1);
2047                 vfs_mp_count_sub_pcpu(mpcpu, ref, 1);
2048                 vfs_op_thread_exit(mp, mpcpu);
2049                 return;
2050         }
2051
2052         MNT_ILOCK(mp);
2053         vfs_assert_mount_counters(mp);
2054         MNT_REL(mp);
2055         c = --mp->mnt_writeopcount;
2056         if (mp->mnt_vfs_ops == 0) {
2057                 MPASS((mp->mnt_kern_flag & MNTK_SUSPEND) == 0);
2058                 MNT_IUNLOCK(mp);
2059                 return;
2060         }
2061         if (c < 0)
2062                 vfs_dump_mount_counters(mp);
2063         if ((mp->mnt_kern_flag & MNTK_SUSPEND) != 0 && c == 0)
2064                 wakeup(&mp->mnt_writeopcount);
2065         MNT_IUNLOCK(mp);
2066 }
2067
2068 /*
2069  * Filesystem secondary write operation has completed. If we are
2070  * suspending and this operation is the last one, notify the suspender
2071  * that the suspension is now in effect.
2072  */
2073 void
2074 vn_finished_secondary_write(struct mount *mp)
2075 {
2076         if (mp == NULL)
2077                 return;
2078         MNT_ILOCK(mp);
2079         MNT_REL(mp);
2080         mp->mnt_secondary_writes--;
2081         if (mp->mnt_secondary_writes < 0)
2082                 panic("vn_finished_secondary_write: neg cnt");
2083         if ((mp->mnt_kern_flag & MNTK_SUSPEND) != 0 &&
2084             mp->mnt_secondary_writes <= 0)
2085                 wakeup(&mp->mnt_secondary_writes);
2086         MNT_IUNLOCK(mp);
2087 }
2088
2089 /*
2090  * Request a filesystem to suspend write operations.
2091  */
2092 int
2093 vfs_write_suspend(struct mount *mp, int flags)
2094 {
2095         int error;
2096
2097         vfs_op_enter(mp);
2098
2099         MNT_ILOCK(mp);
2100         vfs_assert_mount_counters(mp);
2101         if (mp->mnt_susp_owner == curthread) {
2102                 vfs_op_exit_locked(mp);
2103                 MNT_IUNLOCK(mp);
2104                 return (EALREADY);
2105         }
2106         while (mp->mnt_kern_flag & MNTK_SUSPEND)
2107                 msleep(&mp->mnt_flag, MNT_MTX(mp), PUSER - 1, "wsuspfs", 0);
2108
2109         /*
2110          * Unmount holds a write reference on the mount point.  If we
2111          * own busy reference and drain for writers, we deadlock with
2112          * the reference draining in the unmount path.  Callers of
2113          * vfs_write_suspend() must specify VS_SKIP_UNMOUNT if
2114          * vfs_busy() reference is owned and caller is not in the
2115          * unmount context.
2116          */
2117         if ((flags & VS_SKIP_UNMOUNT) != 0 &&
2118             (mp->mnt_kern_flag & MNTK_UNMOUNT) != 0) {
2119                 vfs_op_exit_locked(mp);
2120                 MNT_IUNLOCK(mp);
2121                 return (EBUSY);
2122         }
2123
2124         mp->mnt_kern_flag |= MNTK_SUSPEND;
2125         mp->mnt_susp_owner = curthread;
2126         if (mp->mnt_writeopcount > 0)
2127                 (void) msleep(&mp->mnt_writeopcount,
2128                     MNT_MTX(mp), (PUSER - 1)|PDROP, "suspwt", 0);
2129         else
2130                 MNT_IUNLOCK(mp);
2131         if ((error = VFS_SYNC(mp, MNT_SUSPEND)) != 0) {
2132                 vfs_write_resume(mp, 0);
2133                 /* vfs_write_resume does vfs_op_exit() for us */
2134         }
2135         return (error);
2136 }
2137
2138 /*
2139  * Request a filesystem to resume write operations.
2140  */
2141 void
2142 vfs_write_resume(struct mount *mp, int flags)
2143 {
2144
2145         MNT_ILOCK(mp);
2146         if ((mp->mnt_kern_flag & MNTK_SUSPEND) != 0) {
2147                 KASSERT(mp->mnt_susp_owner == curthread, ("mnt_susp_owner"));
2148                 mp->mnt_kern_flag &= ~(MNTK_SUSPEND | MNTK_SUSPEND2 |
2149                                        MNTK_SUSPENDED);
2150                 mp->mnt_susp_owner = NULL;
2151                 wakeup(&mp->mnt_writeopcount);
2152                 wakeup(&mp->mnt_flag);
2153                 curthread->td_pflags &= ~TDP_IGNSUSP;
2154                 if ((flags & VR_START_WRITE) != 0) {
2155                         MNT_REF(mp);
2156                         mp->mnt_writeopcount++;
2157                 }
2158                 MNT_IUNLOCK(mp);
2159                 if ((flags & VR_NO_SUSPCLR) == 0)
2160                         VFS_SUSP_CLEAN(mp);
2161                 vfs_op_exit(mp);
2162         } else if ((flags & VR_START_WRITE) != 0) {
2163                 MNT_REF(mp);
2164                 vn_start_write_refed(mp, 0, true);
2165         } else {
2166                 MNT_IUNLOCK(mp);
2167         }
2168 }
2169
2170 /*
2171  * Helper loop around vfs_write_suspend() for filesystem unmount VFS
2172  * methods.
2173  */
2174 int
2175 vfs_write_suspend_umnt(struct mount *mp)
2176 {
2177         int error;
2178
2179         KASSERT((curthread->td_pflags & TDP_IGNSUSP) == 0,
2180             ("vfs_write_suspend_umnt: recursed"));
2181
2182         /* dounmount() already called vn_start_write(). */
2183         for (;;) {
2184                 vn_finished_write(mp);
2185                 error = vfs_write_suspend(mp, 0);
2186                 if (error != 0) {
2187                         vn_start_write(NULL, &mp, V_WAIT);
2188                         return (error);
2189                 }
2190                 MNT_ILOCK(mp);
2191                 if ((mp->mnt_kern_flag & MNTK_SUSPENDED) != 0)
2192                         break;
2193                 MNT_IUNLOCK(mp);
2194                 vn_start_write(NULL, &mp, V_WAIT);
2195         }
2196         mp->mnt_kern_flag &= ~(MNTK_SUSPENDED | MNTK_SUSPEND2);
2197         wakeup(&mp->mnt_flag);
2198         MNT_IUNLOCK(mp);
2199         curthread->td_pflags |= TDP_IGNSUSP;
2200         return (0);
2201 }
2202
2203 /*
2204  * Implement kqueues for files by translating it to vnode operation.
2205  */
2206 static int
2207 vn_kqfilter(struct file *fp, struct knote *kn)
2208 {
2209
2210         return (VOP_KQFILTER(fp->f_vnode, kn));
2211 }
2212
2213 int
2214 vn_kqfilter_opath(struct file *fp, struct knote *kn)
2215 {
2216         if ((fp->f_flag & FKQALLOWED) == 0)
2217                 return (EBADF);
2218         return (vn_kqfilter(fp, kn));
2219 }
2220
2221 /*
2222  * Simplified in-kernel wrapper calls for extended attribute access.
2223  * Both calls pass in a NULL credential, authorizing as "kernel" access.
2224  * Set IO_NODELOCKED in ioflg if the vnode is already locked.
2225  */
2226 int
2227 vn_extattr_get(struct vnode *vp, int ioflg, int attrnamespace,
2228     const char *attrname, int *buflen, char *buf, struct thread *td)
2229 {
2230         struct uio      auio;
2231         struct iovec    iov;
2232         int     error;
2233
2234         iov.iov_len = *buflen;
2235         iov.iov_base = buf;
2236
2237         auio.uio_iov = &iov;
2238         auio.uio_iovcnt = 1;
2239         auio.uio_rw = UIO_READ;
2240         auio.uio_segflg = UIO_SYSSPACE;
2241         auio.uio_td = td;
2242         auio.uio_offset = 0;
2243         auio.uio_resid = *buflen;
2244
2245         if ((ioflg & IO_NODELOCKED) == 0)
2246                 vn_lock(vp, LK_SHARED | LK_RETRY);
2247
2248         ASSERT_VOP_LOCKED(vp, "IO_NODELOCKED with no vp lock held");
2249
2250         /* authorize attribute retrieval as kernel */
2251         error = VOP_GETEXTATTR(vp, attrnamespace, attrname, &auio, NULL, NULL,
2252             td);
2253
2254         if ((ioflg & IO_NODELOCKED) == 0)
2255                 VOP_UNLOCK(vp);
2256
2257         if (error == 0) {
2258                 *buflen = *buflen - auio.uio_resid;
2259         }
2260
2261         return (error);
2262 }
2263
2264 /*
2265  * XXX failure mode if partially written?
2266  */
2267 int
2268 vn_extattr_set(struct vnode *vp, int ioflg, int attrnamespace,
2269     const char *attrname, int buflen, char *buf, struct thread *td)
2270 {
2271         struct uio      auio;
2272         struct iovec    iov;
2273         struct mount    *mp;
2274         int     error;
2275
2276         iov.iov_len = buflen;
2277         iov.iov_base = buf;
2278
2279         auio.uio_iov = &iov;
2280         auio.uio_iovcnt = 1;
2281         auio.uio_rw = UIO_WRITE;
2282         auio.uio_segflg = UIO_SYSSPACE;
2283         auio.uio_td = td;
2284         auio.uio_offset = 0;
2285         auio.uio_resid = buflen;
2286
2287         if ((ioflg & IO_NODELOCKED) == 0) {
2288                 if ((error = vn_start_write(vp, &mp, V_WAIT)) != 0)
2289                         return (error);
2290                 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
2291         }
2292
2293         ASSERT_VOP_LOCKED(vp, "IO_NODELOCKED with no vp lock held");
2294
2295         /* authorize attribute setting as kernel */
2296         error = VOP_SETEXTATTR(vp, attrnamespace, attrname, &auio, NULL, td);
2297
2298         if ((ioflg & IO_NODELOCKED) == 0) {
2299                 vn_finished_write(mp);
2300                 VOP_UNLOCK(vp);
2301         }
2302
2303         return (error);
2304 }
2305
2306 int
2307 vn_extattr_rm(struct vnode *vp, int ioflg, int attrnamespace,
2308     const char *attrname, struct thread *td)
2309 {
2310         struct mount    *mp;
2311         int     error;
2312
2313         if ((ioflg & IO_NODELOCKED) == 0) {
2314                 if ((error = vn_start_write(vp, &mp, V_WAIT)) != 0)
2315                         return (error);
2316                 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
2317         }
2318
2319         ASSERT_VOP_LOCKED(vp, "IO_NODELOCKED with no vp lock held");
2320
2321         /* authorize attribute removal as kernel */
2322         error = VOP_DELETEEXTATTR(vp, attrnamespace, attrname, NULL, td);
2323         if (error == EOPNOTSUPP)
2324                 error = VOP_SETEXTATTR(vp, attrnamespace, attrname, NULL,
2325                     NULL, td);
2326
2327         if ((ioflg & IO_NODELOCKED) == 0) {
2328                 vn_finished_write(mp);
2329                 VOP_UNLOCK(vp);
2330         }
2331
2332         return (error);
2333 }
2334
2335 static int
2336 vn_get_ino_alloc_vget(struct mount *mp, void *arg, int lkflags,
2337     struct vnode **rvp)
2338 {
2339
2340         return (VFS_VGET(mp, *(ino_t *)arg, lkflags, rvp));
2341 }
2342
2343 int
2344 vn_vget_ino(struct vnode *vp, ino_t ino, int lkflags, struct vnode **rvp)
2345 {
2346
2347         return (vn_vget_ino_gen(vp, vn_get_ino_alloc_vget, &ino,
2348             lkflags, rvp));
2349 }
2350
2351 int
2352 vn_vget_ino_gen(struct vnode *vp, vn_get_ino_t alloc, void *alloc_arg,
2353     int lkflags, struct vnode **rvp)
2354 {
2355         struct mount *mp;
2356         int ltype, error;
2357
2358         ASSERT_VOP_LOCKED(vp, "vn_vget_ino_get");
2359         mp = vp->v_mount;
2360         ltype = VOP_ISLOCKED(vp);
2361         KASSERT(ltype == LK_EXCLUSIVE || ltype == LK_SHARED,
2362             ("vn_vget_ino: vp not locked"));
2363         error = vfs_busy(mp, MBF_NOWAIT);
2364         if (error != 0) {
2365                 vfs_ref(mp);
2366                 VOP_UNLOCK(vp);
2367                 error = vfs_busy(mp, 0);
2368                 vn_lock(vp, ltype | LK_RETRY);
2369                 vfs_rel(mp);
2370                 if (error != 0)
2371                         return (ENOENT);
2372                 if (VN_IS_DOOMED(vp)) {
2373                         vfs_unbusy(mp);
2374                         return (ENOENT);
2375                 }
2376         }
2377         VOP_UNLOCK(vp);
2378         error = alloc(mp, alloc_arg, lkflags, rvp);
2379         vfs_unbusy(mp);
2380         if (error != 0 || *rvp != vp)
2381                 vn_lock(vp, ltype | LK_RETRY);
2382         if (VN_IS_DOOMED(vp)) {
2383                 if (error == 0) {
2384                         if (*rvp == vp)
2385                                 vunref(vp);
2386                         else
2387                                 vput(*rvp);
2388                 }
2389                 error = ENOENT;
2390         }
2391         return (error);
2392 }
2393
2394 static void
2395 vn_send_sigxfsz(struct proc *p)
2396 {
2397         PROC_LOCK(p);
2398         kern_psignal(p, SIGXFSZ);
2399         PROC_UNLOCK(p);
2400 }
2401
2402 int
2403 vn_rlimit_trunc(u_quad_t size, struct thread *td)
2404 {
2405         if (size <= lim_cur(td, RLIMIT_FSIZE))
2406                 return (0);
2407         vn_send_sigxfsz(td->td_proc);
2408         return (EFBIG);
2409 }
2410
2411 static int
2412 vn_rlimit_fsizex1(const struct vnode *vp, struct uio *uio, off_t maxfsz,
2413     bool adj, struct thread *td)
2414 {
2415         off_t lim;
2416         bool ktr_write;
2417
2418         if (vp->v_type != VREG)
2419                 return (0);
2420
2421         /*
2422          * Handle file system maximum file size.
2423          */
2424         if (maxfsz != 0 && uio->uio_offset + uio->uio_resid > maxfsz) {
2425                 if (!adj || uio->uio_offset >= maxfsz)
2426                         return (EFBIG);
2427                 uio->uio_resid = maxfsz - uio->uio_offset;
2428         }
2429
2430         /*
2431          * This is kernel write (e.g. vnode_pager) or accounting
2432          * write, ignore limit.
2433          */
2434         if (td == NULL || (td->td_pflags2 & TDP2_ACCT) != 0)
2435                 return (0);
2436
2437         /*
2438          * Calculate file size limit.
2439          */
2440         ktr_write = (td->td_pflags & TDP_INKTRACE) != 0;
2441         lim = __predict_false(ktr_write) ? td->td_ktr_io_lim :
2442             lim_cur(td, RLIMIT_FSIZE);
2443
2444         /*
2445          * Is the limit reached?
2446          */
2447         if (__predict_true((uoff_t)uio->uio_offset + uio->uio_resid <= lim))
2448                 return (0);
2449
2450         /*
2451          * Prepared filesystems can handle writes truncated to the
2452          * file size limit.
2453          */
2454         if (adj && (uoff_t)uio->uio_offset < lim) {
2455                 uio->uio_resid = lim - (uoff_t)uio->uio_offset;
2456                 return (0);
2457         }
2458
2459         if (!ktr_write || ktr_filesize_limit_signal)
2460                 vn_send_sigxfsz(td->td_proc);
2461         return (EFBIG);
2462 }
2463
2464 /*
2465  * Helper for VOP_WRITE() implementations, the common code to
2466  * handle maximum supported file size on the filesystem, and
2467  * RLIMIT_FSIZE, except for special writes from accounting subsystem
2468  * and ktrace.
2469  *
2470  * For maximum file size (maxfsz argument):
2471  * - return EFBIG if uio_offset is beyond it
2472  * - otherwise, clamp uio_resid if write would extend file beyond maxfsz.
2473  *
2474  * For RLIMIT_FSIZE:
2475  * - return EFBIG and send SIGXFSZ if uio_offset is beyond the limit
2476  * - otherwise, clamp uio_resid if write would extend file beyond limit.
2477  *
2478  * If clamping occured, the adjustment for uio_resid is stored in
2479  * *resid_adj, to be re-applied by vn_rlimit_fsizex_res() on return
2480  * from the VOP.
2481  */
2482 int
2483 vn_rlimit_fsizex(const struct vnode *vp, struct uio *uio, off_t maxfsz,
2484     ssize_t *resid_adj, struct thread *td)
2485 {
2486         ssize_t resid_orig;
2487         int error;
2488         bool adj;
2489
2490         resid_orig = uio->uio_resid;
2491         adj = resid_adj != NULL;
2492         error = vn_rlimit_fsizex1(vp, uio, maxfsz, adj, td);
2493         if (adj)
2494                 *resid_adj = resid_orig - uio->uio_resid;
2495         return (error);
2496 }
2497
2498 void
2499 vn_rlimit_fsizex_res(struct uio *uio, ssize_t resid_adj)
2500 {
2501         uio->uio_resid += resid_adj;
2502 }
2503
2504 int
2505 vn_rlimit_fsize(const struct vnode *vp, const struct uio *uio,
2506     struct thread *td)
2507 {
2508         return (vn_rlimit_fsizex(vp, __DECONST(struct uio *, uio), 0, NULL,
2509             td));
2510 }
2511
2512 int
2513 vn_chmod(struct file *fp, mode_t mode, struct ucred *active_cred,
2514     struct thread *td)
2515 {
2516         struct vnode *vp;
2517
2518         vp = fp->f_vnode;
2519 #ifdef AUDIT
2520         vn_lock(vp, LK_SHARED | LK_RETRY);
2521         AUDIT_ARG_VNODE1(vp);
2522         VOP_UNLOCK(vp);
2523 #endif
2524         return (setfmode(td, active_cred, vp, mode));
2525 }
2526
2527 int
2528 vn_chown(struct file *fp, uid_t uid, gid_t gid, struct ucred *active_cred,
2529     struct thread *td)
2530 {
2531         struct vnode *vp;
2532
2533         vp = fp->f_vnode;
2534 #ifdef AUDIT
2535         vn_lock(vp, LK_SHARED | LK_RETRY);
2536         AUDIT_ARG_VNODE1(vp);
2537         VOP_UNLOCK(vp);
2538 #endif
2539         return (setfown(td, active_cred, vp, uid, gid));
2540 }
2541
2542 /*
2543  * Remove pages in the range ["start", "end") from the vnode's VM object.  If
2544  * "end" is 0, then the range extends to the end of the object.
2545  */
2546 void
2547 vn_pages_remove(struct vnode *vp, vm_pindex_t start, vm_pindex_t end)
2548 {
2549         vm_object_t object;
2550
2551         if ((object = vp->v_object) == NULL)
2552                 return;
2553         VM_OBJECT_WLOCK(object);
2554         vm_object_page_remove(object, start, end, 0);
2555         VM_OBJECT_WUNLOCK(object);
2556 }
2557
2558 /*
2559  * Like vn_pages_remove(), but skips invalid pages, which by definition are not
2560  * mapped into any process' address space.  Filesystems may use this in
2561  * preference to vn_pages_remove() to avoid blocking on pages busied in
2562  * preparation for a VOP_GETPAGES.
2563  */
2564 void
2565 vn_pages_remove_valid(struct vnode *vp, vm_pindex_t start, vm_pindex_t end)
2566 {
2567         vm_object_t object;
2568
2569         if ((object = vp->v_object) == NULL)
2570                 return;
2571         VM_OBJECT_WLOCK(object);
2572         vm_object_page_remove(object, start, end, OBJPR_VALIDONLY);
2573         VM_OBJECT_WUNLOCK(object);
2574 }
2575
2576 int
2577 vn_bmap_seekhole_locked(struct vnode *vp, u_long cmd, off_t *off,
2578     struct ucred *cred)
2579 {
2580         off_t size;
2581         daddr_t bn, bnp;
2582         uint64_t bsize;
2583         off_t noff;
2584         int error;
2585
2586         KASSERT(cmd == FIOSEEKHOLE || cmd == FIOSEEKDATA,
2587             ("%s: Wrong command %lu", __func__, cmd));
2588         ASSERT_VOP_ELOCKED(vp, "vn_bmap_seekhole_locked");
2589
2590         if (vp->v_type != VREG) {
2591                 error = ENOTTY;
2592                 goto out;
2593         }
2594         error = vn_getsize_locked(vp, &size, cred);
2595         if (error != 0)
2596                 goto out;
2597         noff = *off;
2598         if (noff < 0 || noff >= size) {
2599                 error = ENXIO;
2600                 goto out;
2601         }
2602
2603         /* See the comment in ufs_bmap_seekdata(). */
2604         vnode_pager_clean_sync(vp);
2605
2606         bsize = vp->v_mount->mnt_stat.f_iosize;
2607         for (bn = noff / bsize; noff < size; bn++, noff += bsize -
2608             noff % bsize) {
2609                 error = VOP_BMAP(vp, bn, NULL, &bnp, NULL, NULL);
2610                 if (error == EOPNOTSUPP) {
2611                         error = ENOTTY;
2612                         goto out;
2613                 }
2614                 if ((bnp == -1 && cmd == FIOSEEKHOLE) ||
2615                     (bnp != -1 && cmd == FIOSEEKDATA)) {
2616                         noff = bn * bsize;
2617                         if (noff < *off)
2618                                 noff = *off;
2619                         goto out;
2620                 }
2621         }
2622         if (noff > size)
2623                 noff = size;
2624         /* noff == size. There is an implicit hole at the end of file. */
2625         if (cmd == FIOSEEKDATA)
2626                 error = ENXIO;
2627 out:
2628         if (error == 0)
2629                 *off = noff;
2630         return (error);
2631 }
2632
2633 int
2634 vn_bmap_seekhole(struct vnode *vp, u_long cmd, off_t *off, struct ucred *cred)
2635 {
2636         int error;
2637
2638         KASSERT(cmd == FIOSEEKHOLE || cmd == FIOSEEKDATA,
2639             ("%s: Wrong command %lu", __func__, cmd));
2640
2641         if (vn_lock(vp, LK_EXCLUSIVE) != 0)
2642                 return (EBADF);
2643         error = vn_bmap_seekhole_locked(vp, cmd, off, cred);
2644         VOP_UNLOCK(vp);
2645         return (error);
2646 }
2647
2648 int
2649 vn_seek(struct file *fp, off_t offset, int whence, struct thread *td)
2650 {
2651         struct ucred *cred;
2652         struct vnode *vp;
2653         off_t foffset, fsize, size;
2654         int error, noneg;
2655
2656         cred = td->td_ucred;
2657         vp = fp->f_vnode;
2658         noneg = (vp->v_type != VCHR);
2659         /*
2660          * Try to dodge locking for common case of querying the offset.
2661          */
2662         if (whence == L_INCR && offset == 0) {
2663                 foffset = foffset_read(fp);
2664                 if (__predict_false(foffset < 0 && noneg)) {
2665                         return (EOVERFLOW);
2666                 }
2667                 td->td_uretoff.tdu_off = foffset;
2668                 return (0);
2669         }
2670         foffset = foffset_lock(fp, 0);
2671         error = 0;
2672         switch (whence) {
2673         case L_INCR:
2674                 if (noneg &&
2675                     (foffset < 0 ||
2676                     (offset > 0 && foffset > OFF_MAX - offset))) {
2677                         error = EOVERFLOW;
2678                         break;
2679                 }
2680                 offset += foffset;
2681                 break;
2682         case L_XTND:
2683                 error = vn_getsize(vp, &fsize, cred);
2684                 if (error != 0)
2685                         break;
2686
2687                 /*
2688                  * If the file references a disk device, then fetch
2689                  * the media size and use that to determine the ending
2690                  * offset.
2691                  */
2692                 if (fsize == 0 && vp->v_type == VCHR &&
2693                     fo_ioctl(fp, DIOCGMEDIASIZE, &size, cred, td) == 0)
2694                         fsize = size;
2695                 if (noneg && offset > 0 && fsize > OFF_MAX - offset) {
2696                         error = EOVERFLOW;
2697                         break;
2698                 }
2699                 offset += fsize;
2700                 break;
2701         case L_SET:
2702                 break;
2703         case SEEK_DATA:
2704                 error = fo_ioctl(fp, FIOSEEKDATA, &offset, cred, td);
2705                 if (error == ENOTTY)
2706                         error = EINVAL;
2707                 break;
2708         case SEEK_HOLE:
2709                 error = fo_ioctl(fp, FIOSEEKHOLE, &offset, cred, td);
2710                 if (error == ENOTTY)
2711                         error = EINVAL;
2712                 break;
2713         default:
2714                 error = EINVAL;
2715         }
2716         if (error == 0 && noneg && offset < 0)
2717                 error = EINVAL;
2718         if (error != 0)
2719                 goto drop;
2720         VFS_KNOTE_UNLOCKED(vp, 0);
2721         td->td_uretoff.tdu_off = offset;
2722 drop:
2723         foffset_unlock(fp, offset, error != 0 ? FOF_NOUPDATE : 0);
2724         return (error);
2725 }
2726
2727 int
2728 vn_utimes_perm(struct vnode *vp, struct vattr *vap, struct ucred *cred,
2729     struct thread *td)
2730 {
2731         int error;
2732
2733         /*
2734          * Grant permission if the caller is the owner of the file, or
2735          * the super-user, or has ACL_WRITE_ATTRIBUTES permission on
2736          * on the file.  If the time pointer is null, then write
2737          * permission on the file is also sufficient.
2738          *
2739          * From NFSv4.1, draft 21, 6.2.1.3.1, Discussion of Mask Attributes:
2740          * A user having ACL_WRITE_DATA or ACL_WRITE_ATTRIBUTES
2741          * will be allowed to set the times [..] to the current
2742          * server time.
2743          */
2744         error = VOP_ACCESSX(vp, VWRITE_ATTRIBUTES, cred, td);
2745         if (error != 0 && (vap->va_vaflags & VA_UTIMES_NULL) != 0)
2746                 error = VOP_ACCESS(vp, VWRITE, cred, td);
2747         return (error);
2748 }
2749
2750 int
2751 vn_fill_kinfo(struct file *fp, struct kinfo_file *kif, struct filedesc *fdp)
2752 {
2753         struct vnode *vp;
2754         int error;
2755
2756         if (fp->f_type == DTYPE_FIFO)
2757                 kif->kf_type = KF_TYPE_FIFO;
2758         else
2759                 kif->kf_type = KF_TYPE_VNODE;
2760         vp = fp->f_vnode;
2761         vref(vp);
2762         FILEDESC_SUNLOCK(fdp);
2763         error = vn_fill_kinfo_vnode(vp, kif);
2764         vrele(vp);
2765         FILEDESC_SLOCK(fdp);
2766         return (error);
2767 }
2768
2769 static inline void
2770 vn_fill_junk(struct kinfo_file *kif)
2771 {
2772         size_t len, olen;
2773
2774         /*
2775          * Simulate vn_fullpath returning changing values for a given
2776          * vp during e.g. coredump.
2777          */
2778         len = (arc4random() % (sizeof(kif->kf_path) - 2)) + 1;
2779         olen = strlen(kif->kf_path);
2780         if (len < olen)
2781                 strcpy(&kif->kf_path[len - 1], "$");
2782         else
2783                 for (; olen < len; olen++)
2784                         strcpy(&kif->kf_path[olen], "A");
2785 }
2786
2787 int
2788 vn_fill_kinfo_vnode(struct vnode *vp, struct kinfo_file *kif)
2789 {
2790         struct vattr va;
2791         char *fullpath, *freepath;
2792         int error;
2793
2794         kif->kf_un.kf_file.kf_file_type = vntype_to_kinfo(vp->v_type);
2795         freepath = NULL;
2796         fullpath = "-";
2797         error = vn_fullpath(vp, &fullpath, &freepath);
2798         if (error == 0) {
2799                 strlcpy(kif->kf_path, fullpath, sizeof(kif->kf_path));
2800         }
2801         if (freepath != NULL)
2802                 free(freepath, M_TEMP);
2803
2804         KFAIL_POINT_CODE(DEBUG_FP, fill_kinfo_vnode__random_path,
2805                 vn_fill_junk(kif);
2806         );
2807
2808         /*
2809          * Retrieve vnode attributes.
2810          */
2811         va.va_fsid = VNOVAL;
2812         va.va_rdev = NODEV;
2813         vn_lock(vp, LK_SHARED | LK_RETRY);
2814         error = VOP_GETATTR(vp, &va, curthread->td_ucred);
2815         VOP_UNLOCK(vp);
2816         if (error != 0)
2817                 return (error);
2818         if (va.va_fsid != VNOVAL)
2819                 kif->kf_un.kf_file.kf_file_fsid = va.va_fsid;
2820         else
2821                 kif->kf_un.kf_file.kf_file_fsid =
2822                     vp->v_mount->mnt_stat.f_fsid.val[0];
2823         kif->kf_un.kf_file.kf_file_fsid_freebsd11 =
2824             kif->kf_un.kf_file.kf_file_fsid; /* truncate */
2825         kif->kf_un.kf_file.kf_file_fileid = va.va_fileid;
2826         kif->kf_un.kf_file.kf_file_mode = MAKEIMODE(va.va_type, va.va_mode);
2827         kif->kf_un.kf_file.kf_file_size = va.va_size;
2828         kif->kf_un.kf_file.kf_file_rdev = va.va_rdev;
2829         kif->kf_un.kf_file.kf_file_rdev_freebsd11 =
2830             kif->kf_un.kf_file.kf_file_rdev; /* truncate */
2831         kif->kf_un.kf_file.kf_file_nlink = va.va_nlink;
2832         return (0);
2833 }
2834
2835 int
2836 vn_mmap(struct file *fp, vm_map_t map, vm_offset_t *addr, vm_size_t size,
2837     vm_prot_t prot, vm_prot_t cap_maxprot, int flags, vm_ooffset_t foff,
2838     struct thread *td)
2839 {
2840 #ifdef HWPMC_HOOKS
2841         struct pmckern_map_in pkm;
2842 #endif
2843         struct mount *mp;
2844         struct vnode *vp;
2845         vm_object_t object;
2846         vm_prot_t maxprot;
2847         boolean_t writecounted;
2848         int error;
2849
2850 #if defined(COMPAT_FREEBSD7) || defined(COMPAT_FREEBSD6) || \
2851     defined(COMPAT_FREEBSD5) || defined(COMPAT_FREEBSD4)
2852         /*
2853          * POSIX shared-memory objects are defined to have
2854          * kernel persistence, and are not defined to support
2855          * read(2)/write(2) -- or even open(2).  Thus, we can
2856          * use MAP_ASYNC to trade on-disk coherence for speed.
2857          * The shm_open(3) library routine turns on the FPOSIXSHM
2858          * flag to request this behavior.
2859          */
2860         if ((fp->f_flag & FPOSIXSHM) != 0)
2861                 flags |= MAP_NOSYNC;
2862 #endif
2863         vp = fp->f_vnode;
2864
2865         /*
2866          * Ensure that file and memory protections are
2867          * compatible.  Note that we only worry about
2868          * writability if mapping is shared; in this case,
2869          * current and max prot are dictated by the open file.
2870          * XXX use the vnode instead?  Problem is: what
2871          * credentials do we use for determination? What if
2872          * proc does a setuid?
2873          */
2874         mp = vp->v_mount;
2875         if (mp != NULL && (mp->mnt_flag & MNT_NOEXEC) != 0) {
2876                 maxprot = VM_PROT_NONE;
2877                 if ((prot & VM_PROT_EXECUTE) != 0)
2878                         return (EACCES);
2879         } else
2880                 maxprot = VM_PROT_EXECUTE;
2881         if ((fp->f_flag & FREAD) != 0)
2882                 maxprot |= VM_PROT_READ;
2883         else if ((prot & VM_PROT_READ) != 0)
2884                 return (EACCES);
2885
2886         /*
2887          * If we are sharing potential changes via MAP_SHARED and we
2888          * are trying to get write permission although we opened it
2889          * without asking for it, bail out.
2890          */
2891         if ((flags & MAP_SHARED) != 0) {
2892                 if ((fp->f_flag & FWRITE) != 0)
2893                         maxprot |= VM_PROT_WRITE;
2894                 else if ((prot & VM_PROT_WRITE) != 0)
2895                         return (EACCES);
2896         } else {
2897                 maxprot |= VM_PROT_WRITE;
2898                 cap_maxprot |= VM_PROT_WRITE;
2899         }
2900         maxprot &= cap_maxprot;
2901
2902         /*
2903          * For regular files and shared memory, POSIX requires that
2904          * the value of foff be a legitimate offset within the data
2905          * object.  In particular, negative offsets are invalid.
2906          * Blocking negative offsets and overflows here avoids
2907          * possible wraparound or user-level access into reserved
2908          * ranges of the data object later.  In contrast, POSIX does
2909          * not dictate how offsets are used by device drivers, so in
2910          * the case of a device mapping a negative offset is passed
2911          * on.
2912          */
2913         if (
2914 #ifdef _LP64
2915             size > OFF_MAX ||
2916 #endif
2917             foff > OFF_MAX - size)
2918                 return (EINVAL);
2919
2920         writecounted = FALSE;
2921         error = vm_mmap_vnode(td, size, prot, &maxprot, &flags, vp,
2922             &foff, &object, &writecounted);
2923         if (error != 0)
2924                 return (error);
2925         error = vm_mmap_object(map, addr, size, prot, maxprot, flags, object,
2926             foff, writecounted, td);
2927         if (error != 0) {
2928                 /*
2929                  * If this mapping was accounted for in the vnode's
2930                  * writecount, then undo that now.
2931                  */
2932                 if (writecounted)
2933                         vm_pager_release_writecount(object, 0, size);
2934                 vm_object_deallocate(object);
2935         }
2936 #ifdef HWPMC_HOOKS
2937         /* Inform hwpmc(4) if an executable is being mapped. */
2938         if (PMC_HOOK_INSTALLED(PMC_FN_MMAP)) {
2939                 if ((prot & VM_PROT_EXECUTE) != 0 && error == 0) {
2940                         pkm.pm_file = vp;
2941                         pkm.pm_address = (uintptr_t) *addr;
2942                         PMC_CALL_HOOK_UNLOCKED(td, PMC_FN_MMAP, (void *) &pkm);
2943                 }
2944         }
2945 #endif
2946         return (error);
2947 }
2948
2949 void
2950 vn_fsid(struct vnode *vp, struct vattr *va)
2951 {
2952         fsid_t *f;
2953
2954         f = &vp->v_mount->mnt_stat.f_fsid;
2955         va->va_fsid = (uint32_t)f->val[1];
2956         va->va_fsid <<= sizeof(f->val[1]) * NBBY;
2957         va->va_fsid += (uint32_t)f->val[0];
2958 }
2959
2960 int
2961 vn_fsync_buf(struct vnode *vp, int waitfor)
2962 {
2963         struct buf *bp, *nbp;
2964         struct bufobj *bo;
2965         struct mount *mp;
2966         int error, maxretry;
2967
2968         error = 0;
2969         maxretry = 10000;     /* large, arbitrarily chosen */
2970         mp = NULL;
2971         if (vp->v_type == VCHR) {
2972                 VI_LOCK(vp);
2973                 mp = vp->v_rdev->si_mountpt;
2974                 VI_UNLOCK(vp);
2975         }
2976         bo = &vp->v_bufobj;
2977         BO_LOCK(bo);
2978 loop1:
2979         /*
2980          * MARK/SCAN initialization to avoid infinite loops.
2981          */
2982         TAILQ_FOREACH(bp, &bo->bo_dirty.bv_hd, b_bobufs) {
2983                 bp->b_vflags &= ~BV_SCANNED;
2984                 bp->b_error = 0;
2985         }
2986
2987         /*
2988          * Flush all dirty buffers associated with a vnode.
2989          */
2990 loop2:
2991         TAILQ_FOREACH_SAFE(bp, &bo->bo_dirty.bv_hd, b_bobufs, nbp) {
2992                 if ((bp->b_vflags & BV_SCANNED) != 0)
2993                         continue;
2994                 bp->b_vflags |= BV_SCANNED;
2995                 if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT, NULL)) {
2996                         if (waitfor != MNT_WAIT)
2997                                 continue;
2998                         if (BUF_LOCK(bp,
2999                             LK_EXCLUSIVE | LK_INTERLOCK | LK_SLEEPFAIL,
3000                             BO_LOCKPTR(bo)) != 0) {
3001                                 BO_LOCK(bo);
3002                                 goto loop1;
3003                         }
3004                         BO_LOCK(bo);
3005                 }
3006                 BO_UNLOCK(bo);
3007                 KASSERT(bp->b_bufobj == bo,
3008                     ("bp %p wrong b_bufobj %p should be %p",
3009                     bp, bp->b_bufobj, bo));
3010                 if ((bp->b_flags & B_DELWRI) == 0)
3011                         panic("fsync: not dirty");
3012                 if ((vp->v_object != NULL) && (bp->b_flags & B_CLUSTEROK)) {
3013                         vfs_bio_awrite(bp);
3014                 } else {
3015                         bremfree(bp);
3016                         bawrite(bp);
3017                 }
3018                 if (maxretry < 1000)
3019                         pause("dirty", hz < 1000 ? 1 : hz / 1000);
3020                 BO_LOCK(bo);
3021                 goto loop2;
3022         }
3023
3024         /*
3025          * If synchronous the caller expects us to completely resolve all
3026          * dirty buffers in the system.  Wait for in-progress I/O to
3027          * complete (which could include background bitmap writes), then
3028          * retry if dirty blocks still exist.
3029          */
3030         if (waitfor == MNT_WAIT) {
3031                 bufobj_wwait(bo, 0, 0);
3032                 if (bo->bo_dirty.bv_cnt > 0) {
3033                         /*
3034                          * If we are unable to write any of these buffers
3035                          * then we fail now rather than trying endlessly
3036                          * to write them out.
3037                          */
3038                         TAILQ_FOREACH(bp, &bo->bo_dirty.bv_hd, b_bobufs)
3039                                 if ((error = bp->b_error) != 0)
3040                                         break;
3041                         if ((mp != NULL && mp->mnt_secondary_writes > 0) ||
3042                             (error == 0 && --maxretry >= 0))
3043                                 goto loop1;
3044                         if (error == 0)
3045                                 error = EAGAIN;
3046                 }
3047         }
3048         BO_UNLOCK(bo);
3049         if (error != 0)
3050                 vn_printf(vp, "fsync: giving up on dirty (error = %d) ", error);
3051
3052         return (error);
3053 }
3054
3055 /*
3056  * Copies a byte range from invp to outvp.  Calls VOP_COPY_FILE_RANGE()
3057  * or vn_generic_copy_file_range() after rangelocking the byte ranges,
3058  * to do the actual copy.
3059  * vn_generic_copy_file_range() is factored out, so it can be called
3060  * from a VOP_COPY_FILE_RANGE() call as well, but handles vnodes from
3061  * different file systems.
3062  */
3063 int
3064 vn_copy_file_range(struct vnode *invp, off_t *inoffp, struct vnode *outvp,
3065     off_t *outoffp, size_t *lenp, unsigned int flags, struct ucred *incred,
3066     struct ucred *outcred, struct thread *fsize_td)
3067 {
3068         struct mount *inmp, *outmp;
3069         struct vnode *invpl, *outvpl;
3070         int error;
3071         size_t len;
3072         uint64_t uval;
3073
3074         invpl = outvpl = NULL;
3075         len = *lenp;
3076         *lenp = 0;              /* For error returns. */
3077         error = 0;
3078
3079         /* Do some sanity checks on the arguments. */
3080         if (invp->v_type == VDIR || outvp->v_type == VDIR)
3081                 error = EISDIR;
3082         else if (*inoffp < 0 || *outoffp < 0 ||
3083             invp->v_type != VREG || outvp->v_type != VREG)
3084                 error = EINVAL;
3085         if (error != 0)
3086                 goto out;
3087
3088         /* Ensure offset + len does not wrap around. */
3089         uval = *inoffp;
3090         uval += len;
3091         if (uval > INT64_MAX)
3092                 len = INT64_MAX - *inoffp;
3093         uval = *outoffp;
3094         uval += len;
3095         if (uval > INT64_MAX)
3096                 len = INT64_MAX - *outoffp;
3097         if (len == 0)
3098                 goto out;
3099
3100         error = VOP_GETLOWVNODE(invp, &invpl, FREAD);
3101         if (error != 0)
3102                 goto out;
3103         error = VOP_GETLOWVNODE(outvp, &outvpl, FWRITE);
3104         if (error != 0)
3105                 goto out1;
3106
3107         inmp = invpl->v_mount;
3108         outmp = outvpl->v_mount;
3109         if (inmp == NULL || outmp == NULL)
3110                 goto out2;
3111
3112         for (;;) {
3113                 error = vfs_busy(inmp, 0);
3114                 if (error != 0)
3115                         goto out2;
3116                 if (inmp == outmp)
3117                         break;
3118                 error = vfs_busy(outmp, MBF_NOWAIT);
3119                 if (error != 0) {
3120                         vfs_unbusy(inmp);
3121                         error = vfs_busy(outmp, 0);
3122                         if (error == 0) {
3123                                 vfs_unbusy(outmp);
3124                                 continue;
3125                         }
3126                         goto out2;
3127                 }
3128                 break;
3129         }
3130
3131         /*
3132          * If the two vnodes are for the same file system type, call
3133          * VOP_COPY_FILE_RANGE(), otherwise call vn_generic_copy_file_range()
3134          * which can handle copies across multiple file system types.
3135          */
3136         *lenp = len;
3137         if (inmp == outmp || inmp->mnt_vfc == outmp->mnt_vfc)
3138                 error = VOP_COPY_FILE_RANGE(invpl, inoffp, outvpl, outoffp,
3139                     lenp, flags, incred, outcred, fsize_td);
3140         else
3141                 error = ENOSYS;
3142         if (error == ENOSYS)
3143                 error = vn_generic_copy_file_range(invpl, inoffp, outvpl,
3144                     outoffp, lenp, flags, incred, outcred, fsize_td);
3145         vfs_unbusy(outmp);
3146         if (inmp != outmp)
3147                 vfs_unbusy(inmp);
3148 out2:
3149         if (outvpl != NULL)
3150                 vrele(outvpl);
3151 out1:
3152         if (invpl != NULL)
3153                 vrele(invpl);
3154 out:
3155         return (error);
3156 }
3157
3158 /*
3159  * Test len bytes of data starting at dat for all bytes == 0.
3160  * Return true if all bytes are zero, false otherwise.
3161  * Expects dat to be well aligned.
3162  */
3163 static bool
3164 mem_iszero(void *dat, int len)
3165 {
3166         int i;
3167         const u_int *p;
3168         const char *cp;
3169
3170         for (p = dat; len > 0; len -= sizeof(*p), p++) {
3171                 if (len >= sizeof(*p)) {
3172                         if (*p != 0)
3173                                 return (false);
3174                 } else {
3175                         cp = (const char *)p;
3176                         for (i = 0; i < len; i++, cp++)
3177                                 if (*cp != '\0')
3178                                         return (false);
3179                 }
3180         }
3181         return (true);
3182 }
3183
3184 /*
3185  * Look for a hole in the output file and, if found, adjust *outoffp
3186  * and *xferp to skip past the hole.
3187  * *xferp is the entire hole length to be written and xfer2 is how many bytes
3188  * to be written as 0's upon return.
3189  */
3190 static off_t
3191 vn_skip_hole(struct vnode *outvp, off_t xfer2, off_t *outoffp, off_t *xferp,
3192     off_t *dataoffp, off_t *holeoffp, struct ucred *cred)
3193 {
3194         int error;
3195         off_t delta;
3196
3197         if (*holeoffp == 0 || *holeoffp <= *outoffp) {
3198                 *dataoffp = *outoffp;
3199                 error = VOP_IOCTL(outvp, FIOSEEKDATA, dataoffp, 0, cred,
3200                     curthread);
3201                 if (error == 0) {
3202                         *holeoffp = *dataoffp;
3203                         error = VOP_IOCTL(outvp, FIOSEEKHOLE, holeoffp, 0, cred,
3204                             curthread);
3205                 }
3206                 if (error != 0 || *holeoffp == *dataoffp) {
3207                         /*
3208                          * Since outvp is unlocked, it may be possible for
3209                          * another thread to do a truncate(), lseek(), write()
3210                          * creating a hole at startoff between the above
3211                          * VOP_IOCTL() calls, if the other thread does not do
3212                          * rangelocking.
3213                          * If that happens, *holeoffp == *dataoffp and finding
3214                          * the hole has failed, so disable vn_skip_hole().
3215                          */
3216                         *holeoffp = -1; /* Disable use of vn_skip_hole(). */
3217                         return (xfer2);
3218                 }
3219                 KASSERT(*dataoffp >= *outoffp,
3220                     ("vn_skip_hole: dataoff=%jd < outoff=%jd",
3221                     (intmax_t)*dataoffp, (intmax_t)*outoffp));
3222                 KASSERT(*holeoffp > *dataoffp,
3223                     ("vn_skip_hole: holeoff=%jd <= dataoff=%jd",
3224                     (intmax_t)*holeoffp, (intmax_t)*dataoffp));
3225         }
3226
3227         /*
3228          * If there is a hole before the data starts, advance *outoffp and
3229          * *xferp past the hole.
3230          */
3231         if (*dataoffp > *outoffp) {
3232                 delta = *dataoffp - *outoffp;
3233                 if (delta >= *xferp) {
3234                         /* Entire *xferp is a hole. */
3235                         *outoffp += *xferp;
3236                         *xferp = 0;
3237                         return (0);
3238                 }
3239                 *xferp -= delta;
3240                 *outoffp += delta;
3241                 xfer2 = MIN(xfer2, *xferp);
3242         }
3243
3244         /*
3245          * If a hole starts before the end of this xfer2, reduce this xfer2 so
3246          * that the write ends at the start of the hole.
3247          * *holeoffp should always be greater than *outoffp, but for the
3248          * non-INVARIANTS case, check this to make sure xfer2 remains a sane
3249          * value.
3250          */
3251         if (*holeoffp > *outoffp && *holeoffp < *outoffp + xfer2)
3252                 xfer2 = *holeoffp - *outoffp;
3253         return (xfer2);
3254 }
3255
3256 /*
3257  * Write an xfer sized chunk to outvp in blksize blocks from dat.
3258  * dat is a maximum of blksize in length and can be written repeatedly in
3259  * the chunk.
3260  * If growfile == true, just grow the file via vn_truncate_locked() instead
3261  * of doing actual writes.
3262  * If checkhole == true, a hole is being punched, so skip over any hole
3263  * already in the output file.
3264  */
3265 static int
3266 vn_write_outvp(struct vnode *outvp, char *dat, off_t outoff, off_t xfer,
3267     u_long blksize, bool growfile, bool checkhole, struct ucred *cred)
3268 {
3269         struct mount *mp;
3270         off_t dataoff, holeoff, xfer2;
3271         int error;
3272
3273         /*
3274          * Loop around doing writes of blksize until write has been completed.
3275          * Lock/unlock on each loop iteration so that a bwillwrite() can be
3276          * done for each iteration, since the xfer argument can be very
3277          * large if there is a large hole to punch in the output file.
3278          */
3279         error = 0;
3280         holeoff = 0;
3281         do {
3282                 xfer2 = MIN(xfer, blksize);
3283                 if (checkhole) {
3284                         /*
3285                          * Punching a hole.  Skip writing if there is
3286                          * already a hole in the output file.
3287                          */
3288                         xfer2 = vn_skip_hole(outvp, xfer2, &outoff, &xfer,
3289                             &dataoff, &holeoff, cred);
3290                         if (xfer == 0)
3291                                 break;
3292                         if (holeoff < 0)
3293                                 checkhole = false;
3294                         KASSERT(xfer2 > 0, ("vn_write_outvp: xfer2=%jd",
3295                             (intmax_t)xfer2));
3296                 }
3297                 bwillwrite();
3298                 mp = NULL;
3299                 error = vn_start_write(outvp, &mp, V_WAIT);
3300                 if (error != 0)
3301                         break;
3302                 if (growfile) {
3303                         error = vn_lock(outvp, LK_EXCLUSIVE);
3304                         if (error == 0) {
3305                                 error = vn_truncate_locked(outvp, outoff + xfer,
3306                                     false, cred);
3307                                 VOP_UNLOCK(outvp);
3308                         }
3309                 } else {
3310                         error = vn_lock(outvp, vn_lktype_write(mp, outvp));
3311                         if (error == 0) {
3312                                 error = vn_rdwr(UIO_WRITE, outvp, dat, xfer2,
3313                                     outoff, UIO_SYSSPACE, IO_NODELOCKED,
3314                                     curthread->td_ucred, cred, NULL, curthread);
3315                                 outoff += xfer2;
3316                                 xfer -= xfer2;
3317                                 VOP_UNLOCK(outvp);
3318                         }
3319                 }
3320                 if (mp != NULL)
3321                         vn_finished_write(mp);
3322         } while (!growfile && xfer > 0 && error == 0);
3323         return (error);
3324 }
3325
3326 /*
3327  * Copy a byte range of one file to another.  This function can handle the
3328  * case where invp and outvp are on different file systems.
3329  * It can also be called by a VOP_COPY_FILE_RANGE() to do the work, if there
3330  * is no better file system specific way to do it.
3331  */
3332 int
3333 vn_generic_copy_file_range(struct vnode *invp, off_t *inoffp,
3334     struct vnode *outvp, off_t *outoffp, size_t *lenp, unsigned int flags,
3335     struct ucred *incred, struct ucred *outcred, struct thread *fsize_td)
3336 {
3337         struct vattr inva;
3338         struct mount *mp;
3339         off_t startoff, endoff, xfer, xfer2;
3340         u_long blksize;
3341         int error, interrupted;
3342         bool cantseek, readzeros, eof, first, lastblock, holetoeof, sparse;
3343         ssize_t aresid, r = 0;
3344         size_t copylen, len, savlen;
3345         off_t outsize;
3346         char *dat;
3347         long holein, holeout;
3348         struct timespec curts, endts;
3349
3350         holein = holeout = 0;
3351         savlen = len = *lenp;
3352         error = 0;
3353         interrupted = 0;
3354         dat = NULL;
3355
3356         error = vn_lock(invp, LK_SHARED);
3357         if (error != 0)
3358                 goto out;
3359         if (VOP_PATHCONF(invp, _PC_MIN_HOLE_SIZE, &holein) != 0)
3360                 holein = 0;
3361         error = VOP_GETATTR(invp, &inva, incred);
3362         if (error == 0 && inva.va_size > OFF_MAX)
3363                 error = EFBIG;
3364         VOP_UNLOCK(invp);
3365         if (error != 0)
3366                 goto out;
3367
3368         /*
3369          * Use va_bytes >= va_size as a hint that the file does not have
3370          * sufficient holes to justify the overhead of doing FIOSEEKHOLE.
3371          * This hint does not work well for file systems doing compression
3372          * and may fail when allocations for extended attributes increases
3373          * the value of va_bytes to >= va_size.
3374          */
3375         sparse = true;
3376         if (holein != 0 && inva.va_bytes >= inva.va_size) {
3377                 holein = 0;
3378                 sparse = false;
3379         }
3380
3381         mp = NULL;
3382         error = vn_start_write(outvp, &mp, V_WAIT);
3383         if (error == 0)
3384                 error = vn_lock(outvp, LK_EXCLUSIVE);
3385         if (error == 0) {
3386                 /*
3387                  * If fsize_td != NULL, do a vn_rlimit_fsizex() call,
3388                  * now that outvp is locked.
3389                  */
3390                 if (fsize_td != NULL) {
3391                         struct uio io;
3392
3393                         io.uio_offset = *outoffp;
3394                         io.uio_resid = len;
3395                         error = vn_rlimit_fsizex(outvp, &io, 0, &r, fsize_td);
3396                         len = savlen = io.uio_resid;
3397                         /*
3398                          * No need to call vn_rlimit_fsizex_res before return,
3399                          * since the uio is local.
3400                          */
3401                 }
3402                 if (VOP_PATHCONF(outvp, _PC_MIN_HOLE_SIZE, &holeout) != 0)
3403                         holeout = 0;
3404                 /*
3405                  * Holes that are past EOF do not need to be written as a block
3406                  * of zero bytes.  So, truncate the output file as far as
3407                  * possible and then use size to decide if writing 0
3408                  * bytes is necessary in the loop below.
3409                  */
3410                 if (error == 0)
3411                         error = vn_getsize_locked(outvp, &outsize, outcred);
3412                 if (error == 0 && outsize > *outoffp &&
3413                     *outoffp <= OFF_MAX - len && outsize <= *outoffp + len &&
3414                     *inoffp < inva.va_size &&
3415                     *outoffp <= OFF_MAX - (inva.va_size - *inoffp) &&
3416                     outsize <= *outoffp + (inva.va_size - *inoffp)) {
3417 #ifdef MAC
3418                         error = mac_vnode_check_write(curthread->td_ucred,
3419                             outcred, outvp);
3420                         if (error == 0)
3421 #endif
3422                                 error = vn_truncate_locked(outvp, *outoffp,
3423                                     false, outcred);
3424                         if (error == 0)
3425                                 outsize = *outoffp;
3426                 }
3427                 VOP_UNLOCK(outvp);
3428         }
3429         if (mp != NULL)
3430                 vn_finished_write(mp);
3431         if (error != 0)
3432                 goto out;
3433
3434         if (sparse && holein == 0 && holeout > 0) {
3435                 /*
3436                  * For this special case, the input data will be scanned
3437                  * for blocks of all 0 bytes.  For these blocks, the
3438                  * write can be skipped for the output file to create
3439                  * an unallocated region.
3440                  * Therefore, use the appropriate size for the output file.
3441                  */
3442                 blksize = holeout;
3443                 if (blksize <= 512) {
3444                         /*
3445                          * Use f_iosize, since ZFS reports a _PC_MIN_HOLE_SIZE
3446                          * of 512, although it actually only creates
3447                          * unallocated regions for blocks >= f_iosize.
3448                          */
3449                         blksize = outvp->v_mount->mnt_stat.f_iosize;
3450                 }
3451         } else {
3452                 /*
3453                  * Use the larger of the two f_iosize values.  If they are
3454                  * not the same size, one will normally be an exact multiple of
3455                  * the other, since they are both likely to be a power of 2.
3456                  */
3457                 blksize = MAX(invp->v_mount->mnt_stat.f_iosize,
3458                     outvp->v_mount->mnt_stat.f_iosize);
3459         }
3460
3461         /* Clip to sane limits. */
3462         if (blksize < 4096)
3463                 blksize = 4096;
3464         else if (blksize > maxphys)
3465                 blksize = maxphys;
3466         dat = malloc(blksize, M_TEMP, M_WAITOK);
3467
3468         /*
3469          * If VOP_IOCTL(FIOSEEKHOLE) works for invp, use it and FIOSEEKDATA
3470          * to find holes.  Otherwise, just scan the read block for all 0s
3471          * in the inner loop where the data copying is done.
3472          * Note that some file systems such as NFSv3, NFSv4.0 and NFSv4.1 may
3473          * support holes on the server, but do not support FIOSEEKHOLE.
3474          * The kernel flag COPY_FILE_RANGE_TIMEO1SEC is used to indicate
3475          * that this function should return after 1second with a partial
3476          * completion.
3477          */
3478         if ((flags & COPY_FILE_RANGE_TIMEO1SEC) != 0) {
3479                 getnanouptime(&endts);
3480                 endts.tv_sec++;
3481         } else
3482                 timespecclear(&endts);
3483         first = true;
3484         holetoeof = eof = false;
3485         while (len > 0 && error == 0 && !eof && interrupted == 0) {
3486                 endoff = 0;                     /* To shut up compilers. */
3487                 cantseek = true;
3488                 startoff = *inoffp;
3489                 copylen = len;
3490
3491                 /*
3492                  * Find the next data area.  If there is just a hole to EOF,
3493                  * FIOSEEKDATA should fail with ENXIO.
3494                  * (I do not know if any file system will report a hole to
3495                  *  EOF via FIOSEEKHOLE, but I am pretty sure FIOSEEKDATA
3496                  *  will fail for those file systems.)
3497                  *
3498                  * For input files that don't support FIOSEEKDATA/FIOSEEKHOLE,
3499                  * the code just falls through to the inner copy loop.
3500                  */
3501                 error = EINVAL;
3502                 if (holein > 0) {
3503                         error = VOP_IOCTL(invp, FIOSEEKDATA, &startoff, 0,
3504                             incred, curthread);
3505                         if (error == ENXIO) {
3506                                 startoff = endoff = inva.va_size;
3507                                 eof = holetoeof = true;
3508                                 error = 0;
3509                         }
3510                 }
3511                 if (error == 0 && !holetoeof) {
3512                         endoff = startoff;
3513                         error = VOP_IOCTL(invp, FIOSEEKHOLE, &endoff, 0,
3514                             incred, curthread);
3515                         /*
3516                          * Since invp is unlocked, it may be possible for
3517                          * another thread to do a truncate(), lseek(), write()
3518                          * creating a hole at startoff between the above
3519                          * VOP_IOCTL() calls, if the other thread does not do
3520                          * rangelocking.
3521                          * If that happens, startoff == endoff and finding
3522                          * the hole has failed, so set an error.
3523                          */
3524                         if (error == 0 && startoff == endoff)
3525                                 error = EINVAL; /* Any error. Reset to 0. */
3526                 }
3527                 if (error == 0) {
3528                         if (startoff > *inoffp) {
3529                                 /* Found hole before data block. */
3530                                 xfer = MIN(startoff - *inoffp, len);
3531                                 if (*outoffp < outsize) {
3532                                         /* Must write 0s to punch hole. */
3533                                         xfer2 = MIN(outsize - *outoffp,
3534                                             xfer);
3535                                         memset(dat, 0, MIN(xfer2, blksize));
3536                                         error = vn_write_outvp(outvp, dat,
3537                                             *outoffp, xfer2, blksize, false,
3538                                             holeout > 0, outcred);
3539                                 }
3540
3541                                 if (error == 0 && *outoffp + xfer >
3542                                     outsize && (xfer == len || holetoeof)) {
3543                                         /* Grow output file (hole at end). */
3544                                         error = vn_write_outvp(outvp, dat,
3545                                             *outoffp, xfer, blksize, true,
3546                                             false, outcred);
3547                                 }
3548                                 if (error == 0) {
3549                                         *inoffp += xfer;
3550                                         *outoffp += xfer;
3551                                         len -= xfer;
3552                                         if (len < savlen) {
3553                                                 interrupted = sig_intr();
3554                                                 if (timespecisset(&endts) &&
3555                                                     interrupted == 0) {
3556                                                         getnanouptime(&curts);
3557                                                         if (timespeccmp(&curts,
3558                                                             &endts, >=))
3559                                                                 interrupted =
3560                                                                     EINTR;
3561                                                 }
3562                                         }
3563                                 }
3564                         }
3565                         copylen = MIN(len, endoff - startoff);
3566                         cantseek = false;
3567                 } else {
3568                         cantseek = true;
3569                         if (!sparse)
3570                                 cantseek = false;
3571                         startoff = *inoffp;
3572                         copylen = len;
3573                         error = 0;
3574                 }
3575
3576                 xfer = blksize;
3577                 if (cantseek) {
3578                         /*
3579                          * Set first xfer to end at a block boundary, so that
3580                          * holes are more likely detected in the loop below via
3581                          * the for all bytes 0 method.
3582                          */
3583                         xfer -= (*inoffp % blksize);
3584                 }
3585
3586                 /*
3587                  * Loop copying the data block.  If this was our first attempt
3588                  * to copy anything, allow a zero-length block so that the VOPs
3589                  * get a chance to update metadata, specifically the atime.
3590                  */
3591                 while (error == 0 && ((copylen > 0 && !eof) || first) &&
3592                     interrupted == 0) {
3593                         if (copylen < xfer)
3594                                 xfer = copylen;
3595                         first = false;
3596                         error = vn_lock(invp, LK_SHARED);
3597                         if (error != 0)
3598                                 goto out;
3599                         error = vn_rdwr(UIO_READ, invp, dat, xfer,
3600                             startoff, UIO_SYSSPACE, IO_NODELOCKED,
3601                             curthread->td_ucred, incred, &aresid,
3602                             curthread);
3603                         VOP_UNLOCK(invp);
3604                         lastblock = false;
3605                         if (error == 0 && (xfer == 0 || aresid > 0)) {
3606                                 /* Stop the copy at EOF on the input file. */
3607                                 xfer -= aresid;
3608                                 eof = true;
3609                                 lastblock = true;
3610                         }
3611                         if (error == 0) {
3612                                 /*
3613                                  * Skip the write for holes past the initial EOF
3614                                  * of the output file, unless this is the last
3615                                  * write of the output file at EOF.
3616                                  */
3617                                 readzeros = cantseek ? mem_iszero(dat, xfer) :
3618                                     false;
3619                                 if (xfer == len)
3620                                         lastblock = true;
3621                                 if (!cantseek || *outoffp < outsize ||
3622                                     lastblock || !readzeros)
3623                                         error = vn_write_outvp(outvp, dat,
3624                                             *outoffp, xfer, blksize,
3625                                             readzeros && lastblock &&
3626                                             *outoffp >= outsize, false,
3627                                             outcred);
3628                                 if (error == 0) {
3629                                         *inoffp += xfer;
3630                                         startoff += xfer;
3631                                         *outoffp += xfer;
3632                                         copylen -= xfer;
3633                                         len -= xfer;
3634                                         if (len < savlen) {
3635                                                 interrupted = sig_intr();
3636                                                 if (timespecisset(&endts) &&
3637                                                     interrupted == 0) {
3638                                                         getnanouptime(&curts);
3639                                                         if (timespeccmp(&curts,
3640                                                             &endts, >=))
3641                                                                 interrupted =
3642                                                                     EINTR;
3643                                                 }
3644                                         }
3645                                 }
3646                         }
3647                         xfer = blksize;
3648                 }
3649         }
3650 out:
3651         *lenp = savlen - len;
3652         free(dat, M_TEMP);
3653         return (error);
3654 }
3655
3656 static int
3657 vn_fallocate(struct file *fp, off_t offset, off_t len, struct thread *td)
3658 {
3659         struct mount *mp;
3660         struct vnode *vp;
3661         off_t olen, ooffset;
3662         int error;
3663 #ifdef AUDIT
3664         int audited_vnode1 = 0;
3665 #endif
3666
3667         vp = fp->f_vnode;
3668         if (vp->v_type != VREG)
3669                 return (ENODEV);
3670
3671         /* Allocating blocks may take a long time, so iterate. */
3672         for (;;) {
3673                 olen = len;
3674                 ooffset = offset;
3675
3676                 bwillwrite();
3677                 mp = NULL;
3678                 error = vn_start_write(vp, &mp, V_WAIT | V_PCATCH);
3679                 if (error != 0)
3680                         break;
3681                 error = vn_lock(vp, LK_EXCLUSIVE);
3682                 if (error != 0) {
3683                         vn_finished_write(mp);
3684                         break;
3685                 }
3686 #ifdef AUDIT
3687                 if (!audited_vnode1) {
3688                         AUDIT_ARG_VNODE1(vp);
3689                         audited_vnode1 = 1;
3690                 }
3691 #endif
3692 #ifdef MAC
3693                 error = mac_vnode_check_write(td->td_ucred, fp->f_cred, vp);
3694                 if (error == 0)
3695 #endif
3696                         error = VOP_ALLOCATE(vp, &offset, &len, 0,
3697                             td->td_ucred);
3698                 VOP_UNLOCK(vp);
3699                 vn_finished_write(mp);
3700
3701                 if (olen + ooffset != offset + len) {
3702                         panic("offset + len changed from %jx/%jx to %jx/%jx",
3703                             ooffset, olen, offset, len);
3704                 }
3705                 if (error != 0 || len == 0)
3706                         break;
3707                 KASSERT(olen > len, ("Iteration did not make progress?"));
3708                 maybe_yield();
3709         }
3710
3711         return (error);
3712 }
3713
3714 static int
3715 vn_deallocate_impl(struct vnode *vp, off_t *offset, off_t *length, int flags,
3716     int ioflag, struct ucred *cred, struct ucred *active_cred,
3717     struct ucred *file_cred)
3718 {
3719         struct mount *mp;
3720         void *rl_cookie;
3721         off_t off, len;
3722         int error;
3723 #ifdef AUDIT
3724         bool audited_vnode1 = false;
3725 #endif
3726
3727         rl_cookie = NULL;
3728         error = 0;
3729         mp = NULL;
3730         off = *offset;
3731         len = *length;
3732
3733         if ((ioflag & (IO_NODELOCKED | IO_RANGELOCKED)) == 0)
3734                 rl_cookie = vn_rangelock_wlock(vp, off, off + len);
3735         while (len > 0 && error == 0) {
3736                 /*
3737                  * Try to deallocate the longest range in one pass.
3738                  * In case a pass takes too long to be executed, it returns
3739                  * partial result. The residue will be proceeded in the next
3740                  * pass.
3741                  */
3742
3743                 if ((ioflag & IO_NODELOCKED) == 0) {
3744                         bwillwrite();
3745                         if ((error = vn_start_write(vp, &mp,
3746                             V_WAIT | V_PCATCH)) != 0)
3747                                 goto out;
3748                         vn_lock(vp, vn_lktype_write(mp, vp) | LK_RETRY);
3749                 }
3750 #ifdef AUDIT
3751                 if (!audited_vnode1) {
3752                         AUDIT_ARG_VNODE1(vp);
3753                         audited_vnode1 = true;
3754                 }
3755 #endif
3756
3757 #ifdef MAC
3758                 if ((ioflag & IO_NOMACCHECK) == 0)
3759                         error = mac_vnode_check_write(active_cred, file_cred,
3760                             vp);
3761 #endif
3762                 if (error == 0)
3763                         error = VOP_DEALLOCATE(vp, &off, &len, flags, ioflag,
3764                             cred);
3765
3766                 if ((ioflag & IO_NODELOCKED) == 0) {
3767                         VOP_UNLOCK(vp);
3768                         if (mp != NULL) {
3769                                 vn_finished_write(mp);
3770                                 mp = NULL;
3771                         }
3772                 }
3773                 if (error == 0 && len != 0)
3774                         maybe_yield();
3775         }
3776 out:
3777         if (rl_cookie != NULL)
3778                 vn_rangelock_unlock(vp, rl_cookie);
3779         *offset = off;
3780         *length = len;
3781         return (error);
3782 }
3783
3784 /*
3785  * This function is supposed to be used in the situations where the deallocation
3786  * is not triggered by a user request.
3787  */
3788 int
3789 vn_deallocate(struct vnode *vp, off_t *offset, off_t *length, int flags,
3790     int ioflag, struct ucred *active_cred, struct ucred *file_cred)
3791 {
3792         struct ucred *cred;
3793
3794         if (*offset < 0 || *length <= 0 || *length > OFF_MAX - *offset ||
3795             flags != 0)
3796                 return (EINVAL);
3797         if (vp->v_type != VREG)
3798                 return (ENODEV);
3799
3800         cred = file_cred != NOCRED ? file_cred : active_cred;
3801         return (vn_deallocate_impl(vp, offset, length, flags, ioflag, cred,
3802             active_cred, file_cred));
3803 }
3804
3805 static int
3806 vn_fspacectl(struct file *fp, int cmd, off_t *offset, off_t *length, int flags,
3807     struct ucred *active_cred, struct thread *td)
3808 {
3809         int error;
3810         struct vnode *vp;
3811         int ioflag;
3812
3813         KASSERT(cmd == SPACECTL_DEALLOC, ("vn_fspacectl: Invalid cmd"));
3814         KASSERT((flags & ~SPACECTL_F_SUPPORTED) == 0,
3815             ("vn_fspacectl: non-zero flags"));
3816         KASSERT(*offset >= 0 && *length > 0 && *length <= OFF_MAX - *offset,
3817             ("vn_fspacectl: offset/length overflow or underflow"));
3818         vp = fp->f_vnode;
3819
3820         if (vp->v_type != VREG)
3821                 return (ENODEV);
3822
3823         ioflag = get_write_ioflag(fp);
3824
3825         switch (cmd) {
3826         case SPACECTL_DEALLOC:
3827                 error = vn_deallocate_impl(vp, offset, length, flags, ioflag,
3828                     active_cred, active_cred, fp->f_cred);
3829                 break;
3830         default:
3831                 panic("vn_fspacectl: unknown cmd %d", cmd);
3832         }
3833
3834         return (error);
3835 }
3836
3837 /*
3838  * Keep this assert as long as sizeof(struct dirent) is used as the maximum
3839  * entry size.
3840  */
3841 _Static_assert(_GENERIC_MAXDIRSIZ == sizeof(struct dirent),
3842     "'struct dirent' size must be a multiple of its alignment "
3843     "(see _GENERIC_DIRLEN())");
3844
3845 /*
3846  * Returns successive directory entries through some caller's provided buffer.
3847  *
3848  * This function automatically refills the provided buffer with calls to
3849  * VOP_READDIR() (after MAC permission checks).
3850  *
3851  * 'td' is used for credentials and passed to uiomove().  'dirbuf' is the
3852  * caller's buffer to fill and 'dirbuflen' its allocated size.  'dirbuf' must
3853  * be properly aligned to access 'struct dirent' structures and 'dirbuflen'
3854  * must be greater than GENERIC_MAXDIRSIZ to avoid VOP_READDIR() returning
3855  * EINVAL (the latter is not a strong guarantee (yet); but EINVAL will always
3856  * be returned if this requirement is not verified).  '*dpp' points to the
3857  * current directory entry in the buffer and '*len' contains the remaining
3858  * valid bytes in 'dirbuf' after 'dpp' (including the pointed entry).
3859  *
3860  * At first call (or when restarting the read), '*len' must have been set to 0,
3861  * '*off' to 0 (or any valid start offset) and '*eofflag' to 0.  There are no
3862  * more entries as soon as '*len' is 0 after a call that returned 0.  Calling
3863  * again this function after such a condition is considered an error and EINVAL
3864  * will be returned.  Other possible error codes are those of VOP_READDIR(),
3865  * EINTEGRITY if the returned entries do not pass coherency tests, or EINVAL
3866  * (bad call).  All errors are unrecoverable, i.e., the state ('*len', '*off'
3867  * and '*eofflag') must be re-initialized before a subsequent call.  On error
3868  * or at end of directory, '*dpp' is reset to NULL.
3869  *
3870  * '*len', '*off' and '*eofflag' are internal state the caller should not
3871  * tamper with except as explained above.  '*off' is the next directory offset
3872  * to read from to refill the buffer.  '*eofflag' is set to 0 or 1 by the last
3873  * internal call to VOP_READDIR() that returned without error, indicating
3874  * whether it reached the end of the directory, and to 2 by this function after
3875  * all entries have been read.
3876  */
3877 int
3878 vn_dir_next_dirent(struct vnode *vp, struct thread *td,
3879     char *dirbuf, size_t dirbuflen,
3880     struct dirent **dpp, size_t *len, off_t *off, int *eofflag)
3881 {
3882         struct dirent *dp = NULL;
3883         int reclen;
3884         int error;
3885         struct uio uio;
3886         struct iovec iov;
3887
3888         ASSERT_VOP_LOCKED(vp, "vnode not locked");
3889         VNASSERT(vp->v_type == VDIR, vp, ("vnode is not a directory"));
3890         MPASS2((uintptr_t)dirbuf < (uintptr_t)dirbuf + dirbuflen,
3891             "Address space overflow");
3892
3893         if (__predict_false(dirbuflen < GENERIC_MAXDIRSIZ)) {
3894                 /* Don't take any chances in this case */
3895                 error = EINVAL;
3896                 goto out;
3897         }
3898
3899         if (*len != 0) {
3900                 dp = *dpp;
3901
3902                 /*
3903                  * The caller continued to call us after an error (we set dp to
3904                  * NULL in a previous iteration).  Bail out right now.
3905                  */
3906                 if (__predict_false(dp == NULL))
3907                         return (EINVAL);
3908
3909                 MPASS(*len <= dirbuflen);
3910                 MPASS2((uintptr_t)dirbuf <= (uintptr_t)dp &&
3911                     (uintptr_t)dp + *len <= (uintptr_t)dirbuf + dirbuflen,
3912                     "Filled range not inside buffer");
3913
3914                 reclen = dp->d_reclen;
3915                 if (reclen >= *len) {
3916                         /* End of buffer reached */
3917                         *len = 0;
3918                 } else {
3919                         dp = (struct dirent *)((char *)dp + reclen);
3920                         *len -= reclen;
3921                 }
3922         }
3923
3924         if (*len == 0) {
3925                 dp = NULL;
3926
3927                 /* Have to refill. */
3928                 switch (*eofflag) {
3929                 case 0:
3930                         break;
3931
3932                 case 1:
3933                         /* Nothing more to read. */
3934                         *eofflag = 2; /* Remember the caller reached EOF. */
3935                         goto success;
3936
3937                 default:
3938                         /* The caller didn't test for EOF. */
3939                         error = EINVAL;
3940                         goto out;
3941                 }
3942
3943                 iov.iov_base = dirbuf;
3944                 iov.iov_len = dirbuflen;
3945
3946                 uio.uio_iov = &iov;
3947                 uio.uio_iovcnt = 1;
3948                 uio.uio_offset = *off;
3949                 uio.uio_resid = dirbuflen;
3950                 uio.uio_segflg = UIO_SYSSPACE;
3951                 uio.uio_rw = UIO_READ;
3952                 uio.uio_td = td;
3953
3954 #ifdef MAC
3955                 error = mac_vnode_check_readdir(td->td_ucred, vp);
3956                 if (error == 0)
3957 #endif
3958                         error = VOP_READDIR(vp, &uio, td->td_ucred, eofflag,
3959                             NULL, NULL);
3960                 if (error != 0)
3961                         goto out;
3962
3963                 *len = dirbuflen - uio.uio_resid;
3964                 *off = uio.uio_offset;
3965
3966                 if (*len == 0) {
3967                         /* Sanity check on INVARIANTS. */
3968                         MPASS(*eofflag != 0);
3969                         *eofflag = 1;
3970                         goto success;
3971                 }
3972
3973                 /*
3974                  * Normalize the flag returned by VOP_READDIR(), since we use 2
3975                  * as a sentinel value.
3976                  */
3977                 if (*eofflag != 0)
3978                         *eofflag = 1;
3979
3980                 dp = (struct dirent *)dirbuf;
3981         }
3982
3983         if (__predict_false(*len < GENERIC_MINDIRSIZ ||
3984             dp->d_reclen < GENERIC_MINDIRSIZ)) {
3985                 error = EINTEGRITY;
3986                 dp = NULL;
3987                 goto out;
3988         }
3989
3990 success:
3991         error = 0;
3992 out:
3993         *dpp = dp;
3994         return (error);
3995 }
3996
3997 /*
3998  * Checks whether a directory is empty or not.
3999  *
4000  * If the directory is empty, returns 0, and if it is not, ENOTEMPTY.  Other
4001  * values are genuine errors preventing the check.
4002  */
4003 int
4004 vn_dir_check_empty(struct vnode *vp)
4005 {
4006         struct thread *const td = curthread;
4007         char *dirbuf;
4008         size_t dirbuflen, len;
4009         off_t off;
4010         int eofflag, error;
4011         struct dirent *dp;
4012         struct vattr va;
4013
4014         ASSERT_VOP_LOCKED(vp, "vfs_emptydir");
4015         VNPASS(vp->v_type == VDIR, vp);
4016
4017         error = VOP_GETATTR(vp, &va, td->td_ucred);
4018         if (error != 0)
4019                 return (error);
4020
4021         dirbuflen = max(DEV_BSIZE, GENERIC_MAXDIRSIZ);
4022         if (dirbuflen < va.va_blocksize)
4023                 dirbuflen = va.va_blocksize;
4024         dirbuf = malloc(dirbuflen, M_TEMP, M_WAITOK);
4025
4026         len = 0;
4027         off = 0;
4028         eofflag = 0;
4029
4030         for (;;) {
4031                 error = vn_dir_next_dirent(vp, td, dirbuf, dirbuflen,
4032                     &dp, &len, &off, &eofflag);
4033                 if (error != 0)
4034                         goto end;
4035
4036                 if (len == 0) {
4037                         /* EOF */
4038                         error = 0;
4039                         goto end;
4040                 }
4041
4042                 /*
4043                  * Skip whiteouts.  Unionfs operates on filesystems only and
4044                  * not on hierarchies, so these whiteouts would be shadowed on
4045                  * the system hierarchy but not for a union using the
4046                  * filesystem of their directories as the upper layer.
4047                  * Additionally, unionfs currently transparently exposes
4048                  * union-specific metadata of its upper layer, meaning that
4049                  * whiteouts can be seen through the union view in empty
4050                  * directories.  Taking into account these whiteouts would then
4051                  * prevent mounting another filesystem on such effectively
4052                  * empty directories.
4053                  */
4054                 if (dp->d_type == DT_WHT)
4055                         continue;
4056
4057                 /*
4058                  * Any file in the directory which is not '.' or '..' indicates
4059                  * the directory is not empty.
4060                  */
4061                 switch (dp->d_namlen) {
4062                 case 2:
4063                         if (dp->d_name[1] != '.') {
4064                                 /* Can't be '..' (nor '.') */
4065                                 error = ENOTEMPTY;
4066                                 goto end;
4067                         }
4068                         /* FALLTHROUGH */
4069                 case 1:
4070                         if (dp->d_name[0] != '.') {
4071                                 /* Can't be '..' nor '.' */
4072                                 error = ENOTEMPTY;
4073                                 goto end;
4074                         }
4075                         break;
4076
4077                 default:
4078                         error = ENOTEMPTY;
4079                         goto end;
4080                 }
4081         }
4082
4083 end:
4084         free(dirbuf, M_TEMP);
4085         return (error);
4086 }
4087
4088
4089 static u_long vn_lock_pair_pause_cnt;
4090 SYSCTL_ULONG(_debug, OID_AUTO, vn_lock_pair_pause, CTLFLAG_RD,
4091     &vn_lock_pair_pause_cnt, 0,
4092     "Count of vn_lock_pair deadlocks");
4093
4094 u_int vn_lock_pair_pause_max;
4095 SYSCTL_UINT(_debug, OID_AUTO, vn_lock_pair_pause_max, CTLFLAG_RW,
4096     &vn_lock_pair_pause_max, 0,
4097     "Max ticks for vn_lock_pair deadlock avoidance sleep");
4098
4099 static void
4100 vn_lock_pair_pause(const char *wmesg)
4101 {
4102         atomic_add_long(&vn_lock_pair_pause_cnt, 1);
4103         pause(wmesg, prng32_bounded(vn_lock_pair_pause_max));
4104 }
4105
4106 /*
4107  * Lock pair of (possibly same) vnodes vp1, vp2, avoiding lock order
4108  * reversal.  vp1_locked indicates whether vp1 is locked; if not, vp1
4109  * must be unlocked.  Same for vp2 and vp2_locked.  One of the vnodes
4110  * can be NULL.
4111  *
4112  * The function returns with both vnodes exclusively or shared locked,
4113  * according to corresponding lkflags, and guarantees that it does not
4114  * create lock order reversal with other threads during its execution.
4115  * Both vnodes could be unlocked temporary (and reclaimed).
4116  *
4117  * If requesting shared locking, locked vnode lock must not be recursed.
4118  *
4119  * Only one of LK_SHARED and LK_EXCLUSIVE must be specified.
4120  * LK_NODDLKTREAT can be optionally passed.
4121  *
4122  * If vp1 == vp2, only one, most exclusive, lock is obtained on it.
4123  */
4124 void
4125 vn_lock_pair(struct vnode *vp1, bool vp1_locked, int lkflags1,
4126     struct vnode *vp2, bool vp2_locked, int lkflags2)
4127 {
4128         int error, locked1;
4129
4130         MPASS((((lkflags1 & LK_SHARED) != 0) ^ ((lkflags1 & LK_EXCLUSIVE) != 0)) ||
4131             (vp1 == NULL && lkflags1 == 0));
4132         MPASS((lkflags1 & ~(LK_SHARED | LK_EXCLUSIVE | LK_NODDLKTREAT)) == 0);
4133         MPASS((((lkflags2 & LK_SHARED) != 0) ^ ((lkflags2 & LK_EXCLUSIVE) != 0)) ||
4134             (vp2 == NULL && lkflags2 == 0));
4135         MPASS((lkflags2 & ~(LK_SHARED | LK_EXCLUSIVE | LK_NODDLKTREAT)) == 0);
4136
4137         if (vp1 == NULL && vp2 == NULL)
4138                 return;
4139
4140         if (vp1 == vp2) {
4141                 MPASS(vp1_locked == vp2_locked);
4142
4143                 /* Select the most exclusive mode for lock. */
4144                 if ((lkflags1 & LK_TYPE_MASK) != (lkflags2 & LK_TYPE_MASK))
4145                         lkflags1 = (lkflags1 & ~LK_SHARED) | LK_EXCLUSIVE;
4146
4147                 if (vp1_locked) {
4148                         ASSERT_VOP_LOCKED(vp1, "vp1");
4149
4150                         /* No need to relock if any lock is exclusive. */
4151                         if ((vp1->v_vnlock->lock_object.lo_flags &
4152                             LK_NOSHARE) != 0)
4153                                 return;
4154
4155                         locked1 = VOP_ISLOCKED(vp1);
4156                         if (((lkflags1 & LK_SHARED) != 0 &&
4157                             locked1 != LK_EXCLUSIVE) ||
4158                             ((lkflags1 & LK_EXCLUSIVE) != 0 &&
4159                             locked1 == LK_EXCLUSIVE))
4160                                 return;
4161                         VOP_UNLOCK(vp1);
4162                 }
4163
4164                 ASSERT_VOP_UNLOCKED(vp1, "vp1");
4165                 vn_lock(vp1, lkflags1 | LK_RETRY);
4166                 return;
4167         }
4168
4169         if (vp1 != NULL) {
4170                 if ((lkflags1 & LK_SHARED) != 0 &&
4171                     (vp1->v_vnlock->lock_object.lo_flags & LK_NOSHARE) != 0)
4172                         lkflags1 = (lkflags1 & ~LK_SHARED) | LK_EXCLUSIVE;
4173                 if (vp1_locked && VOP_ISLOCKED(vp1) != LK_EXCLUSIVE) {
4174                         ASSERT_VOP_LOCKED(vp1, "vp1");
4175                         if ((lkflags1 & LK_EXCLUSIVE) != 0) {
4176                                 VOP_UNLOCK(vp1);
4177                                 ASSERT_VOP_UNLOCKED(vp1,
4178                                     "vp1 shared recursed");
4179                                 vp1_locked = false;
4180                         }
4181                 } else if (!vp1_locked)
4182                         ASSERT_VOP_UNLOCKED(vp1, "vp1");
4183         } else {
4184                 vp1_locked = true;
4185         }
4186
4187         if (vp2 != NULL) {
4188                 if ((lkflags2 & LK_SHARED) != 0 &&
4189                     (vp2->v_vnlock->lock_object.lo_flags & LK_NOSHARE) != 0)
4190                         lkflags2 = (lkflags2 & ~LK_SHARED) | LK_EXCLUSIVE;
4191                 if (vp2_locked && VOP_ISLOCKED(vp2) != LK_EXCLUSIVE) {
4192                         ASSERT_VOP_LOCKED(vp2, "vp2");
4193                         if ((lkflags2 & LK_EXCLUSIVE) != 0) {
4194                                 VOP_UNLOCK(vp2);
4195                                 ASSERT_VOP_UNLOCKED(vp2,
4196                                     "vp2 shared recursed");
4197                                 vp2_locked = false;
4198                         }
4199                 } else if (!vp2_locked)
4200                         ASSERT_VOP_UNLOCKED(vp2, "vp2");
4201         } else {
4202                 vp2_locked = true;
4203         }
4204
4205         if (!vp1_locked && !vp2_locked) {
4206                 vn_lock(vp1, lkflags1 | LK_RETRY);
4207                 vp1_locked = true;
4208         }
4209
4210         while (!vp1_locked || !vp2_locked) {
4211                 if (vp1_locked && vp2 != NULL) {
4212                         if (vp1 != NULL) {
4213                                 error = VOP_LOCK1(vp2, lkflags2 | LK_NOWAIT,
4214                                     __FILE__, __LINE__);
4215                                 if (error == 0)
4216                                         break;
4217                                 VOP_UNLOCK(vp1);
4218                                 vp1_locked = false;
4219                                 vn_lock_pair_pause("vlp1");
4220                         }
4221                         vn_lock(vp2, lkflags2 | LK_RETRY);
4222                         vp2_locked = true;
4223                 }
4224                 if (vp2_locked && vp1 != NULL) {
4225                         if (vp2 != NULL) {
4226                                 error = VOP_LOCK1(vp1, lkflags1 | LK_NOWAIT,
4227                                     __FILE__, __LINE__);
4228                                 if (error == 0)
4229                                         break;
4230                                 VOP_UNLOCK(vp2);
4231                                 vp2_locked = false;
4232                                 vn_lock_pair_pause("vlp2");
4233                         }
4234                         vn_lock(vp1, lkflags1 | LK_RETRY);
4235                         vp1_locked = true;
4236                 }
4237         }
4238         if (vp1 != NULL) {
4239                 if (lkflags1 == LK_EXCLUSIVE)
4240                         ASSERT_VOP_ELOCKED(vp1, "vp1 ret");
4241                 else
4242                         ASSERT_VOP_LOCKED(vp1, "vp1 ret");
4243         }
4244         if (vp2 != NULL) {
4245                 if (lkflags2 == LK_EXCLUSIVE)
4246                         ASSERT_VOP_ELOCKED(vp2, "vp2 ret");
4247                 else
4248                         ASSERT_VOP_LOCKED(vp2, "vp2 ret");
4249         }
4250 }
4251
4252 int
4253 vn_lktype_write(struct mount *mp, struct vnode *vp)
4254 {
4255         if (MNT_SHARED_WRITES(mp) ||
4256             (mp == NULL && MNT_SHARED_WRITES(vp->v_mount)))
4257                 return (LK_SHARED);
4258         return (LK_EXCLUSIVE);
4259 }
4260
4261 int
4262 vn_cmp(struct file *fp1, struct file *fp2, struct thread *td)
4263 {
4264         if (fp2->f_type != DTYPE_VNODE)
4265                 return (3);
4266         return (kcmp_cmp((uintptr_t)fp1->f_vnode, (uintptr_t)fp2->f_vnode));
4267 }