sys/kern/vfs_vnops.c

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