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