sys/kern/vfs_vnops.c

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