sys/ufs/ffs/ffs_vnops.c

   1 /*-
   2  * SPDX-License-Identifier: (BSD-2-Clause-FreeBSD AND BSD-3-Clause)
   3  *
   4  * Copyright (c) 2002, 2003 Networks Associates Technology, Inc.
   5  * All rights reserved.
   6  *
   7  * This software was developed for the FreeBSD Project by Marshall
   8  * Kirk McKusick and Network Associates Laboratories, the Security
   9  * Research Division of Network Associates, Inc. under DARPA/SPAWAR
  10  * contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA CHATS
  11  * research program
  12  *
  13  * Redistribution and use in source and binary forms, with or without
  14  * modification, are permitted provided that the following conditions
  15  * are met:
  16  * 1. Redistributions of source code must retain the above copyright
  17  *    notice, this list of conditions and the following disclaimer.
  18  * 2. Redistributions in binary form must reproduce the above copyright
  19  *    notice, this list of conditions and the following disclaimer in the
  20  *    documentation and/or other materials provided with the distribution.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  * Copyright (c) 1982, 1986, 1989, 1993
  35  *      The Regents of the University of California.  All rights reserved.
  36  *
  37  * Redistribution and use in source and binary forms, with or without
  38  * modification, are permitted provided that the following conditions
  39  * are met:
  40  * 1. Redistributions of source code must retain the above copyright
  41  *    notice, this list of conditions and the following disclaimer.
  42  * 2. Redistributions in binary form must reproduce the above copyright
  43  *    notice, this list of conditions and the following disclaimer in the
  44  *    documentation and/or other materials provided with the distribution.
  45  * 3. Neither the name of the University nor the names of its contributors
  46  *    may be used to endorse or promote products derived from this software
  47  *    without specific prior written permission.
  48  *
  49  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  50  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  51  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  52  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  53  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  54  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  55  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  56  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  57  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  58  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  59  * SUCH DAMAGE.
  60  *
  61  *      from: @(#)ufs_readwrite.c       8.11 (Berkeley) 5/8/95
  62  * from: $FreeBSD: .../ufs/ufs_readwrite.c,v 1.96 2002/08/12 09:22:11 phk ...
  63  *      @(#)ffs_vnops.c 8.15 (Berkeley) 5/14/95
  64  */
  65
  66 #include <sys/cdefs.h>
  67 __FBSDID("$FreeBSD$");
  68
  69 #include "opt_directio.h"
  70 #include "opt_ffs.h"
  71 #include "opt_ufs.h"
  72
  73 #include <sys/param.h>
  74 #include <sys/bio.h>
  75 #include <sys/systm.h>
  76 #include <sys/buf.h>
  77 #include <sys/conf.h>
  78 #include <sys/extattr.h>
  79 #include <sys/kernel.h>
  80 #include <sys/limits.h>
  81 #include <sys/malloc.h>
  82 #include <sys/mount.h>
  83 #include <sys/priv.h>
  84 #include <sys/rwlock.h>
  85 #include <sys/stat.h>
  86 #include <sys/sysctl.h>
  87 #include <sys/vmmeter.h>
  88 #include <sys/vnode.h>
  89
  90 #include <vm/vm.h>
  91 #include <vm/vm_param.h>
  92 #include <vm/vm_extern.h>
  93 #include <vm/vm_object.h>
  94 #include <vm/vm_page.h>
  95 #include <vm/vm_pager.h>
  96 #include <vm/vnode_pager.h>
  97
  98 #include <ufs/ufs/extattr.h>
  99 #include <ufs/ufs/quota.h>
 100 #include <ufs/ufs/inode.h>
 101 #include <ufs/ufs/ufs_extern.h>
 102 #include <ufs/ufs/ufsmount.h>
 103 #include <ufs/ufs/dir.h>
 104 #ifdef UFS_DIRHASH
 105 #include <ufs/ufs/dirhash.h>
 106 #endif
 107
 108 #include <ufs/ffs/fs.h>
 109 #include <ufs/ffs/ffs_extern.h>
 110
 111 #define ALIGNED_TO(ptr, s)      \
 112         (((uintptr_t)(ptr) & (_Alignof(s) - 1)) == 0)
 113
 114 #ifdef DIRECTIO
 115 extern int      ffs_rawread(struct vnode *vp, struct uio *uio, int *workdone);
 116 #endif
 117 static vop_fdatasync_t  ffs_fdatasync;
 118 static vop_fsync_t      ffs_fsync;
 119 static vop_getpages_t   ffs_getpages;
 120 static vop_getpages_async_t     ffs_getpages_async;
 121 static vop_lock1_t      ffs_lock;
 122 #ifdef INVARIANTS
 123 static vop_unlock_t     ffs_unlock_debug;
 124 #endif
 125 static vop_read_t       ffs_read;
 126 static vop_write_t      ffs_write;
 127 static int      ffs_extread(struct vnode *vp, struct uio *uio, int ioflag);
 128 static int      ffs_extwrite(struct vnode *vp, struct uio *uio, int ioflag,
 129                     struct ucred *cred);
 130 static vop_strategy_t   ffsext_strategy;
 131 static vop_closeextattr_t       ffs_closeextattr;
 132 static vop_deleteextattr_t      ffs_deleteextattr;
 133 static vop_getextattr_t ffs_getextattr;
 134 static vop_listextattr_t        ffs_listextattr;
 135 static vop_openextattr_t        ffs_openextattr;
 136 static vop_setextattr_t ffs_setextattr;
 137 static vop_vptofh_t     ffs_vptofh;
 138 static vop_vput_pair_t  ffs_vput_pair;
 139
 140 /* Global vfs data structures for ufs. */
 141 struct vop_vector ffs_vnodeops1 = {
 142         .vop_default =          &ufs_vnodeops,
 143         .vop_fsync =            ffs_fsync,
 144         .vop_fdatasync =        ffs_fdatasync,
 145         .vop_getpages =         ffs_getpages,
 146         .vop_getpages_async =   ffs_getpages_async,
 147         .vop_lock1 =            ffs_lock,
 148 #ifdef INVARIANTS
 149         .vop_unlock =           ffs_unlock_debug,
 150 #endif
 151         .vop_read =             ffs_read,
 152         .vop_reallocblks =      ffs_reallocblks,
 153         .vop_write =            ffs_write,
 154         .vop_vptofh =           ffs_vptofh,
 155         .vop_vput_pair =        ffs_vput_pair,
 156 };
 157 VFS_VOP_VECTOR_REGISTER(ffs_vnodeops1);
 158
 159 struct vop_vector ffs_fifoops1 = {
 160         .vop_default =          &ufs_fifoops,
 161         .vop_fsync =            ffs_fsync,
 162         .vop_fdatasync =        ffs_fdatasync,
 163         .vop_lock1 =            ffs_lock,
 164 #ifdef INVARIANTS
 165         .vop_unlock =           ffs_unlock_debug,
 166 #endif
 167         .vop_vptofh =           ffs_vptofh,
 168 };
 169 VFS_VOP_VECTOR_REGISTER(ffs_fifoops1);
 170
 171 /* Global vfs data structures for ufs. */
 172 struct vop_vector ffs_vnodeops2 = {
 173         .vop_default =          &ufs_vnodeops,
 174         .vop_fsync =            ffs_fsync,
 175         .vop_fdatasync =        ffs_fdatasync,
 176         .vop_getpages =         ffs_getpages,
 177         .vop_getpages_async =   ffs_getpages_async,
 178         .vop_lock1 =            ffs_lock,
 179 #ifdef INVARIANTS
 180         .vop_unlock =           ffs_unlock_debug,
 181 #endif
 182         .vop_read =             ffs_read,
 183         .vop_reallocblks =      ffs_reallocblks,
 184         .vop_write =            ffs_write,
 185         .vop_closeextattr =     ffs_closeextattr,
 186         .vop_deleteextattr =    ffs_deleteextattr,
 187         .vop_getextattr =       ffs_getextattr,
 188         .vop_listextattr =      ffs_listextattr,
 189         .vop_openextattr =      ffs_openextattr,
 190         .vop_setextattr =       ffs_setextattr,
 191         .vop_vptofh =           ffs_vptofh,
 192         .vop_vput_pair =        ffs_vput_pair,
 193 };
 194 VFS_VOP_VECTOR_REGISTER(ffs_vnodeops2);
 195
 196 struct vop_vector ffs_fifoops2 = {
 197         .vop_default =          &ufs_fifoops,
 198         .vop_fsync =            ffs_fsync,
 199         .vop_fdatasync =        ffs_fdatasync,
 200         .vop_lock1 =            ffs_lock,
 201 #ifdef INVARIANTS
 202         .vop_unlock =           ffs_unlock_debug,
 203 #endif
 204         .vop_reallocblks =      ffs_reallocblks,
 205         .vop_strategy =         ffsext_strategy,
 206         .vop_closeextattr =     ffs_closeextattr,
 207         .vop_deleteextattr =    ffs_deleteextattr,
 208         .vop_getextattr =       ffs_getextattr,
 209         .vop_listextattr =      ffs_listextattr,
 210         .vop_openextattr =      ffs_openextattr,
 211         .vop_setextattr =       ffs_setextattr,
 212         .vop_vptofh =           ffs_vptofh,
 213 };
 214 VFS_VOP_VECTOR_REGISTER(ffs_fifoops2);
 215
 216 /*
 217  * Synch an open file.
 218  */
 219 /* ARGSUSED */
 220 static int
 221 ffs_fsync(struct vop_fsync_args *ap)
 222 {
 223         struct vnode *vp;
 224         struct bufobj *bo;
 225         int error;
 226
 227         vp = ap->a_vp;
 228         bo = &vp->v_bufobj;
 229 retry:
 230         error = ffs_syncvnode(vp, ap->a_waitfor, 0);
 231         if (error)
 232                 return (error);
 233         if (ap->a_waitfor == MNT_WAIT && DOINGSOFTDEP(vp)) {
 234                 error = softdep_fsync(vp);
 235                 if (error)
 236                         return (error);
 237
 238                 /*
 239                  * The softdep_fsync() function may drop vp lock,
 240                  * allowing for dirty buffers to reappear on the
 241                  * bo_dirty list. Recheck and resync as needed.
 242                  */
 243                 BO_LOCK(bo);
 244                 if ((vp->v_type == VREG || vp->v_type == VDIR) &&
 245                     (bo->bo_numoutput > 0 || bo->bo_dirty.bv_cnt > 0)) {
 246                         BO_UNLOCK(bo);
 247                         goto retry;
 248                 }
 249                 BO_UNLOCK(bo);
 250         }
 251         if (ffs_fsfail_cleanup(VFSTOUFS(vp->v_mount), 0))
 252                 return (ENXIO);
 253         return (0);
 254 }
 255
 256 int
 257 ffs_syncvnode(struct vnode *vp, int waitfor, int flags)
 258 {
 259         struct inode *ip;
 260         struct bufobj *bo;
 261         struct ufsmount *ump;
 262         struct buf *bp, *nbp;
 263         ufs_lbn_t lbn;
 264         int error, passes;
 265         bool still_dirty, unlocked, wait;
 266
 267         ip = VTOI(vp);
 268         bo = &vp->v_bufobj;
 269         ump = VFSTOUFS(vp->v_mount);
 270
 271         /*
 272          * When doing MNT_WAIT we must first flush all dependencies
 273          * on the inode.
 274          */
 275         if (DOINGSOFTDEP(vp) && waitfor == MNT_WAIT &&
 276             (error = softdep_sync_metadata(vp)) != 0) {
 277                 if (ffs_fsfail_cleanup(ump, error))
 278                         error = 0;
 279                 return (error);
 280         }
 281
 282         /*
 283          * Flush all dirty buffers associated with a vnode.
 284          */
 285         error = 0;
 286         passes = 0;
 287         wait = false;   /* Always do an async pass first. */
 288         unlocked = false;
 289         lbn = lblkno(ITOFS(ip), (ip->i_size + ITOFS(ip)->fs_bsize - 1));
 290         BO_LOCK(bo);
 291 loop:
 292         TAILQ_FOREACH(bp, &bo->bo_dirty.bv_hd, b_bobufs)
 293                 bp->b_vflags &= ~BV_SCANNED;
 294         TAILQ_FOREACH_SAFE(bp, &bo->bo_dirty.bv_hd, b_bobufs, nbp) {
 295                 /*
 296                  * Reasons to skip this buffer: it has already been considered
 297                  * on this pass, the buffer has dependencies that will cause
 298                  * it to be redirtied and it has not already been deferred,
 299                  * or it is already being written.
 300                  */
 301                 if ((bp->b_vflags & BV_SCANNED) != 0)
 302                         continue;
 303                 bp->b_vflags |= BV_SCANNED;
 304                 /*
 305                  * Flush indirects in order, if requested.
 306                  *
 307                  * Note that if only datasync is requested, we can
 308                  * skip indirect blocks when softupdates are not
 309                  * active.  Otherwise we must flush them with data,
 310                  * since dependencies prevent data block writes.
 311                  */
 312                 if (waitfor == MNT_WAIT && bp->b_lblkno <= -UFS_NDADDR &&
 313                     (lbn_level(bp->b_lblkno) >= passes ||
 314                     ((flags & DATA_ONLY) != 0 && !DOINGSOFTDEP(vp))))
 315                         continue;
 316                 if (bp->b_lblkno > lbn)
 317                         panic("ffs_syncvnode: syncing truncated data.");
 318                 if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT, NULL) == 0) {
 319                         BO_UNLOCK(bo);
 320                 } else if (wait) {
 321                         if (BUF_LOCK(bp,
 322                             LK_EXCLUSIVE | LK_SLEEPFAIL | LK_INTERLOCK,
 323                             BO_LOCKPTR(bo)) != 0) {
 324                                 bp->b_vflags &= ~BV_SCANNED;
 325                                 goto next;
 326                         }
 327                 } else
 328                         continue;
 329                 if ((bp->b_flags & B_DELWRI) == 0)
 330                         panic("ffs_fsync: not dirty");
 331                 /*
 332                  * Check for dependencies and potentially complete them.
 333                  */
 334                 if (!LIST_EMPTY(&bp->b_dep) &&
 335                     (error = softdep_sync_buf(vp, bp,
 336                     wait ? MNT_WAIT : MNT_NOWAIT)) != 0) {
 337                         /*
 338                          * Lock order conflict, buffer was already unlocked,
 339                          * and vnode possibly unlocked.
 340                          */
 341                         if (error == ERELOOKUP) {
 342                                 if (vp->v_data == NULL)
 343                                         return (EBADF);
 344                                 unlocked = true;
 345                                 if (DOINGSOFTDEP(vp) && waitfor == MNT_WAIT &&
 346                                     (error = softdep_sync_metadata(vp)) != 0) {
 347                                         if (ffs_fsfail_cleanup(ump, error))
 348                                                 error = 0;
 349                                         return (unlocked && error == 0 ?
 350                                             ERELOOKUP : error);
 351                                 }
 352                                 /* Re-evaluate inode size */
 353                                 lbn = lblkno(ITOFS(ip), (ip->i_size +
 354                                     ITOFS(ip)->fs_bsize - 1));
 355                                 goto next;
 356                         }
 357                         /* I/O error. */
 358                         if (error != EBUSY) {
 359                                 BUF_UNLOCK(bp);
 360                                 return (error);
 361                         }
 362                         /* If we deferred once, don't defer again. */
 363                         if ((bp->b_flags & B_DEFERRED) == 0) {
 364                                 bp->b_flags |= B_DEFERRED;
 365                                 BUF_UNLOCK(bp);
 366                                 goto next;
 367                         }
 368                 }
 369                 if (wait) {
 370                         bremfree(bp);
 371                         error = bwrite(bp);
 372                         if (ffs_fsfail_cleanup(ump, error))
 373                                 error = 0;
 374                         if (error != 0)
 375                                 return (error);
 376                 } else if ((bp->b_flags & B_CLUSTEROK)) {
 377                         (void) vfs_bio_awrite(bp);
 378                 } else {
 379                         bremfree(bp);
 380                         (void) bawrite(bp);
 381                 }
 382 next:
 383                 /*
 384                  * Since we may have slept during the I/O, we need
 385                  * to start from a known point.
 386                  */
 387                 BO_LOCK(bo);
 388                 nbp = TAILQ_FIRST(&bo->bo_dirty.bv_hd);
 389         }
 390         if (waitfor != MNT_WAIT) {
 391                 BO_UNLOCK(bo);
 392                 if ((flags & NO_INO_UPDT) != 0)
 393                         return (unlocked ? ERELOOKUP : 0);
 394                 error = ffs_update(vp, 0);
 395                 if (error == 0 && unlocked)
 396                         error = ERELOOKUP;
 397                 return (error);
 398         }
 399         /* Drain IO to see if we're done. */
 400         bufobj_wwait(bo, 0, 0);
 401         /*
 402          * Block devices associated with filesystems may have new I/O
 403          * requests posted for them even if the vnode is locked, so no
 404          * amount of trying will get them clean.  We make several passes
 405          * as a best effort.
 406          *
 407          * Regular files may need multiple passes to flush all dependency
 408          * work as it is possible that we must write once per indirect
 409          * level, once for the leaf, and once for the inode and each of
 410          * these will be done with one sync and one async pass.
 411          */
 412         if (bo->bo_dirty.bv_cnt > 0) {
 413                 if ((flags & DATA_ONLY) == 0) {
 414                         still_dirty = true;
 415                 } else {
 416                         /*
 417                          * For data-only sync, dirty indirect buffers
 418                          * are ignored.
 419                          */
 420                         still_dirty = false;
 421                         TAILQ_FOREACH(bp, &bo->bo_dirty.bv_hd, b_bobufs) {
 422                                 if (bp->b_lblkno > -UFS_NDADDR) {
 423                                         still_dirty = true;
 424                                         break;
 425                                 }
 426                         }
 427                 }
 428
 429                 if (still_dirty) {
 430                         /* Write the inode after sync passes to flush deps. */
 431                         if (wait && DOINGSOFTDEP(vp) &&
 432                             (flags & NO_INO_UPDT) == 0) {
 433                                 BO_UNLOCK(bo);
 434                                 ffs_update(vp, 1);
 435                                 BO_LOCK(bo);
 436                         }
 437                         /* switch between sync/async. */
 438                         wait = !wait;
 439                         if (wait || ++passes < UFS_NIADDR + 2)
 440                                 goto loop;
 441                 }
 442         }
 443         BO_UNLOCK(bo);
 444         error = 0;
 445         if ((flags & DATA_ONLY) == 0) {
 446                 if ((flags & NO_INO_UPDT) == 0)
 447                         error = ffs_update(vp, 1);
 448                 if (DOINGSUJ(vp))
 449                         softdep_journal_fsync(VTOI(vp));
 450         } else if ((ip->i_flags & (IN_SIZEMOD | IN_IBLKDATA)) != 0) {
 451                 error = ffs_update(vp, 1);
 452         }
 453         if (error == 0 && unlocked)
 454                 error = ERELOOKUP;
 455         if (error == 0)
 456                 ip->i_flag &= ~IN_NEEDSYNC;
 457         return (error);
 458 }
 459
 460 static int
 461 ffs_fdatasync(struct vop_fdatasync_args *ap)
 462 {
 463
 464         return (ffs_syncvnode(ap->a_vp, MNT_WAIT, DATA_ONLY));
 465 }
 466
 467 static int
 468 ffs_lock(ap)
 469         struct vop_lock1_args /* {
 470                 struct vnode *a_vp;
 471                 int a_flags;
 472                 char *file;
 473                 int line;
 474         } */ *ap;
 475 {
 476 #if !defined(NO_FFS_SNAPSHOT) || defined(DIAGNOSTIC)
 477         struct vnode *vp = ap->a_vp;
 478 #endif  /* !NO_FFS_SNAPSHOT || DIAGNOSTIC */
 479 #ifdef DIAGNOSTIC
 480         struct inode *ip;
 481 #endif  /* DIAGNOSTIC */
 482         int result;
 483 #ifndef NO_FFS_SNAPSHOT
 484         int flags;
 485         struct lock *lkp;
 486
 487         /*
 488          * Adaptive spinning mixed with SU leads to trouble. use a giant hammer
 489          * and only use it when LK_NODDLKTREAT is set. Currently this means it
 490          * is only used during path lookup.
 491          */
 492         if ((ap->a_flags & LK_NODDLKTREAT) != 0)
 493                 ap->a_flags |= LK_ADAPTIVE;
 494         switch (ap->a_flags & LK_TYPE_MASK) {
 495         case LK_SHARED:
 496         case LK_UPGRADE:
 497         case LK_EXCLUSIVE:
 498                 flags = ap->a_flags;
 499                 for (;;) {
 500 #ifdef DEBUG_VFS_LOCKS
 501                         VNPASS(vp->v_holdcnt != 0, vp);
 502 #endif  /* DEBUG_VFS_LOCKS */
 503                         lkp = vp->v_vnlock;
 504                         result = lockmgr_lock_flags(lkp, flags,
 505                             &VI_MTX(vp)->lock_object, ap->a_file, ap->a_line);
 506                         if (lkp == vp->v_vnlock || result != 0)
 507                                 break;
 508                         /*
 509                          * Apparent success, except that the vnode
 510                          * mutated between snapshot file vnode and
 511                          * regular file vnode while this process
 512                          * slept.  The lock currently held is not the
 513                          * right lock.  Release it, and try to get the
 514                          * new lock.
 515                          */
 516                         lockmgr_unlock(lkp);
 517                         if ((flags & (LK_INTERLOCK | LK_NOWAIT)) ==
 518                             (LK_INTERLOCK | LK_NOWAIT))
 519                                 return (EBUSY);
 520                         if ((flags & LK_TYPE_MASK) == LK_UPGRADE)
 521                                 flags = (flags & ~LK_TYPE_MASK) | LK_EXCLUSIVE;
 522                         flags &= ~LK_INTERLOCK;
 523                 }
 524 #ifdef DIAGNOSTIC
 525                 switch (ap->a_flags & LK_TYPE_MASK) {
 526                 case LK_UPGRADE:
 527                 case LK_EXCLUSIVE:
 528                         if (result == 0 && vp->v_vnlock->lk_recurse == 0) {
 529                                 ip = VTOI(vp);
 530                                 if (ip != NULL)
 531                                         ip->i_lock_gen++;
 532                         }
 533                 }
 534 #endif  /* DIAGNOSTIC */
 535                 break;
 536         default:
 537 #ifdef DIAGNOSTIC
 538                 if ((ap->a_flags & LK_TYPE_MASK) == LK_DOWNGRADE) {
 539                         ip = VTOI(vp);
 540                         if (ip != NULL)
 541                                 ufs_unlock_tracker(ip);
 542                 }
 543 #endif  /* DIAGNOSTIC */
 544                 result = VOP_LOCK1_APV(&ufs_vnodeops, ap);
 545                 break;
 546         }
 547 #else   /* NO_FFS_SNAPSHOT */
 548         /*
 549          * See above for an explanation.
 550          */
 551         if ((ap->a_flags & LK_NODDLKTREAT) != 0)
 552                 ap->a_flags |= LK_ADAPTIVE;
 553 #ifdef DIAGNOSTIC
 554         if ((ap->a_flags & LK_TYPE_MASK) == LK_DOWNGRADE) {
 555                 ip = VTOI(vp);
 556                 if (ip != NULL)
 557                         ufs_unlock_tracker(ip);
 558         }
 559 #endif  /* DIAGNOSTIC */
 560         result =  VOP_LOCK1_APV(&ufs_vnodeops, ap);
 561 #endif  /* NO_FFS_SNAPSHOT */
 562 #ifdef DIAGNOSTIC
 563         switch (ap->a_flags & LK_TYPE_MASK) {
 564         case LK_UPGRADE:
 565         case LK_EXCLUSIVE:
 566                 if (result == 0 && vp->v_vnlock->lk_recurse == 0) {
 567                         ip = VTOI(vp);
 568                         if (ip != NULL)
 569                                 ip->i_lock_gen++;
 570                 }
 571         }
 572 #endif  /* DIAGNOSTIC */
 573         return (result);
 574 }
 575
 576 #ifdef INVARIANTS
 577 static int
 578 ffs_unlock_debug(struct vop_unlock_args *ap)
 579 {
 580         struct vnode *vp;
 581         struct inode *ip;
 582
 583         vp = ap->a_vp;
 584         ip = VTOI(vp);
 585         if (ip->i_flag & UFS_INODE_FLAG_LAZY_MASK_ASSERTABLE) {
 586                 if ((vp->v_mflag & VMP_LAZYLIST) == 0) {
 587                         VI_LOCK(vp);
 588                         VNASSERT((vp->v_mflag & VMP_LAZYLIST), vp,
 589                             ("%s: modified vnode (%x) not on lazy list",
 590                             __func__, ip->i_flag));
 591                         VI_UNLOCK(vp);
 592                 }
 593         }
 594         KASSERT(vp->v_type != VDIR || vp->v_vnlock->lk_recurse != 0 ||
 595             (ip->i_flag & IN_ENDOFF) == 0,
 596             ("ufs dir vp %p ip %p flags %#x", vp, ip, ip->i_flag));
 597 #ifdef DIAGNOSTIC
 598         if (VOP_ISLOCKED(vp) == LK_EXCLUSIVE && ip != NULL &&
 599             vp->v_vnlock->lk_recurse == 0)
 600                 ufs_unlock_tracker(ip);
 601 #endif
 602         return (VOP_UNLOCK_APV(&ufs_vnodeops, ap));
 603 }
 604 #endif
 605
 606 static int
 607 ffs_read_hole(struct uio *uio, long xfersize, long *size)
 608 {
 609         ssize_t saved_resid, tlen;
 610         int error;
 611
 612         while (xfersize > 0) {
 613                 tlen = min(xfersize, ZERO_REGION_SIZE);
 614                 saved_resid = uio->uio_resid;
 615                 error = vn_io_fault_uiomove(__DECONST(void *, zero_region),
 616                     tlen, uio);
 617                 if (error != 0)
 618                         return (error);
 619                 tlen = saved_resid - uio->uio_resid;
 620                 xfersize -= tlen;
 621                 *size -= tlen;
 622         }
 623         return (0);
 624 }
 625
 626 /*
 627  * Vnode op for reading.
 628  */
 629 static int
 630 ffs_read(ap)
 631         struct vop_read_args /* {
 632                 struct vnode *a_vp;
 633                 struct uio *a_uio;
 634                 int a_ioflag;
 635                 struct ucred *a_cred;
 636         } */ *ap;
 637 {
 638         struct vnode *vp;
 639         struct inode *ip;
 640         struct uio *uio;
 641         struct fs *fs;
 642         struct buf *bp;
 643         ufs_lbn_t lbn, nextlbn;
 644         off_t bytesinfile;
 645         long size, xfersize, blkoffset;
 646         ssize_t orig_resid;
 647         int bflag, error, ioflag, seqcount;
 648
 649         vp = ap->a_vp;
 650         uio = ap->a_uio;
 651         ioflag = ap->a_ioflag;
 652         if (ap->a_ioflag & IO_EXT)
 653 #ifdef notyet
 654                 return (ffs_extread(vp, uio, ioflag));
 655 #else
 656                 panic("ffs_read+IO_EXT");
 657 #endif
 658 #ifdef DIRECTIO
 659         if ((ioflag & IO_DIRECT) != 0) {
 660                 int workdone;
 661
 662                 error = ffs_rawread(vp, uio, &workdone);
 663                 if (error != 0 || workdone != 0)
 664                         return error;
 665         }
 666 #endif
 667
 668         seqcount = ap->a_ioflag >> IO_SEQSHIFT;
 669         ip = VTOI(vp);
 670
 671 #ifdef INVARIANTS
 672         if (uio->uio_rw != UIO_READ)
 673                 panic("ffs_read: mode");
 674
 675         if (vp->v_type == VLNK) {
 676                 if ((int)ip->i_size < vp->v_mount->mnt_maxsymlinklen)
 677                         panic("ffs_read: short symlink");
 678         } else if (vp->v_type != VREG && vp->v_type != VDIR)
 679                 panic("ffs_read: type %d",  vp->v_type);
 680 #endif
 681         orig_resid = uio->uio_resid;
 682         KASSERT(orig_resid >= 0, ("ffs_read: uio->uio_resid < 0"));
 683         if (orig_resid == 0)
 684                 return (0);
 685         KASSERT(uio->uio_offset >= 0, ("ffs_read: uio->uio_offset < 0"));
 686         fs = ITOFS(ip);
 687         if (uio->uio_offset < ip->i_size &&
 688             uio->uio_offset >= fs->fs_maxfilesize)
 689                 return (EOVERFLOW);
 690
 691         bflag = GB_UNMAPPED | (uio->uio_segflg == UIO_NOCOPY ? 0 : GB_NOSPARSE);
 692         for (error = 0, bp = NULL; uio->uio_resid > 0; bp = NULL) {
 693                 if ((bytesinfile = ip->i_size - uio->uio_offset) <= 0)
 694                         break;
 695                 lbn = lblkno(fs, uio->uio_offset);
 696                 nextlbn = lbn + 1;
 697
 698                 /*
 699                  * size of buffer.  The buffer representing the
 700                  * end of the file is rounded up to the size of
 701                  * the block type ( fragment or full block,
 702                  * depending ).
 703                  */
 704                 size = blksize(fs, ip, lbn);
 705                 blkoffset = blkoff(fs, uio->uio_offset);
 706
 707                 /*
 708                  * The amount we want to transfer in this iteration is
 709                  * one FS block less the amount of the data before
 710                  * our startpoint (duh!)
 711                  */
 712                 xfersize = fs->fs_bsize - blkoffset;
 713
 714                 /*
 715                  * But if we actually want less than the block,
 716                  * or the file doesn't have a whole block more of data,
 717                  * then use the lesser number.
 718                  */
 719                 if (uio->uio_resid < xfersize)
 720                         xfersize = uio->uio_resid;
 721                 if (bytesinfile < xfersize)
 722                         xfersize = bytesinfile;
 723
 724                 if (lblktosize(fs, nextlbn) >= ip->i_size) {
 725                         /*
 726                          * Don't do readahead if this is the end of the file.
 727                          */
 728                         error = bread_gb(vp, lbn, size, NOCRED, bflag, &bp);
 729                 } else if ((vp->v_mount->mnt_flag & MNT_NOCLUSTERR) == 0) {
 730                         /*
 731                          * Otherwise if we are allowed to cluster,
 732                          * grab as much as we can.
 733                          *
 734                          * XXX  This may not be a win if we are not
 735                          * doing sequential access.
 736                          */
 737                         error = cluster_read(vp, ip->i_size, lbn,
 738                             size, NOCRED, blkoffset + uio->uio_resid,
 739                             seqcount, bflag, &bp);
 740                 } else if (seqcount > 1) {
 741                         /*
 742                          * If we are NOT allowed to cluster, then
 743                          * if we appear to be acting sequentially,
 744                          * fire off a request for a readahead
 745                          * as well as a read. Note that the 4th and 5th
 746                          * arguments point to arrays of the size specified in
 747                          * the 6th argument.
 748                          */
 749                         u_int nextsize = blksize(fs, ip, nextlbn);
 750                         error = breadn_flags(vp, lbn, lbn, size, &nextlbn,
 751                             &nextsize, 1, NOCRED, bflag, NULL, &bp);
 752                 } else {
 753                         /*
 754                          * Failing all of the above, just read what the
 755                          * user asked for. Interestingly, the same as
 756                          * the first option above.
 757                          */
 758                         error = bread_gb(vp, lbn, size, NOCRED, bflag, &bp);
 759                 }
 760                 if (error == EJUSTRETURN) {
 761                         error = ffs_read_hole(uio, xfersize, &size);
 762                         if (error == 0)
 763                                 continue;
 764                 }
 765                 if (error != 0) {
 766                         brelse(bp);
 767                         bp = NULL;
 768                         break;
 769                 }
 770
 771                 /*
 772                  * We should only get non-zero b_resid when an I/O error
 773                  * has occurred, which should cause us to break above.
 774                  * However, if the short read did not cause an error,
 775                  * then we want to ensure that we do not uiomove bad
 776                  * or uninitialized data.
 777                  */
 778                 size -= bp->b_resid;
 779                 if (size < xfersize) {
 780                         if (size == 0)
 781                                 break;
 782                         xfersize = size;
 783                 }
 784
 785                 if (buf_mapped(bp)) {
 786                         error = vn_io_fault_uiomove((char *)bp->b_data +
 787                             blkoffset, (int)xfersize, uio);
 788                 } else {
 789                         error = vn_io_fault_pgmove(bp->b_pages, blkoffset,
 790                             (int)xfersize, uio);
 791                 }
 792                 if (error)
 793                         break;
 794
 795                 vfs_bio_brelse(bp, ioflag);
 796         }
 797
 798         /*
 799          * This can only happen in the case of an error
 800          * because the loop above resets bp to NULL on each iteration
 801          * and on normal completion has not set a new value into it.
 802          * so it must have come from a 'break' statement
 803          */
 804         if (bp != NULL)
 805                 vfs_bio_brelse(bp, ioflag);
 806
 807         if ((error == 0 || uio->uio_resid != orig_resid) &&
 808             (vp->v_mount->mnt_flag & (MNT_NOATIME | MNT_RDONLY)) == 0)
 809                 UFS_INODE_SET_FLAG_SHARED(ip, IN_ACCESS);
 810         return (error);
 811 }
 812
 813 /*
 814  * Vnode op for writing.
 815  */
 816 static int
 817 ffs_write(ap)
 818         struct vop_write_args /* {
 819                 struct vnode *a_vp;
 820                 struct uio *a_uio;
 821                 int a_ioflag;
 822                 struct ucred *a_cred;
 823         } */ *ap;
 824 {
 825         struct vnode *vp;
 826         struct uio *uio;
 827         struct inode *ip;
 828         struct fs *fs;
 829         struct buf *bp;
 830         ufs_lbn_t lbn;
 831         off_t osize;
 832         ssize_t resid;
 833         int seqcount;
 834         int blkoffset, error, flags, ioflag, size, xfersize;
 835
 836         vp = ap->a_vp;
 837         if (DOINGSUJ(vp))
 838                 softdep_prealloc(vp, MNT_WAIT);
 839         if (vp->v_data == NULL)
 840                 return (EBADF);
 841
 842         uio = ap->a_uio;
 843         ioflag = ap->a_ioflag;
 844         if (ap->a_ioflag & IO_EXT)
 845 #ifdef notyet
 846                 return (ffs_extwrite(vp, uio, ioflag, ap->a_cred));
 847 #else
 848                 panic("ffs_write+IO_EXT");
 849 #endif
 850
 851         seqcount = ap->a_ioflag >> IO_SEQSHIFT;
 852         ip = VTOI(vp);
 853
 854 #ifdef INVARIANTS
 855         if (uio->uio_rw != UIO_WRITE)
 856                 panic("ffs_write: mode");
 857 #endif
 858
 859         switch (vp->v_type) {
 860         case VREG:
 861                 if (ioflag & IO_APPEND)
 862                         uio->uio_offset = ip->i_size;
 863                 if ((ip->i_flags & APPEND) && uio->uio_offset != ip->i_size)
 864                         return (EPERM);
 865                 /* FALLTHROUGH */
 866         case VLNK:
 867                 break;
 868         case VDIR:
 869                 panic("ffs_write: dir write");
 870                 break;
 871         default:
 872                 panic("ffs_write: type %p %d (%d,%d)", vp, (int)vp->v_type,
 873                         (int)uio->uio_offset,
 874                         (int)uio->uio_resid
 875                 );
 876         }
 877
 878         KASSERT(uio->uio_resid >= 0, ("ffs_write: uio->uio_resid < 0"));
 879         KASSERT(uio->uio_offset >= 0, ("ffs_write: uio->uio_offset < 0"));
 880         fs = ITOFS(ip);
 881         if ((uoff_t)uio->uio_offset + uio->uio_resid > fs->fs_maxfilesize)
 882                 return (EFBIG);
 883         /*
 884          * Maybe this should be above the vnode op call, but so long as
 885          * file servers have no limits, I don't think it matters.
 886          */
 887         if (vn_rlimit_fsize(vp, uio, uio->uio_td))
 888                 return (EFBIG);
 889
 890         resid = uio->uio_resid;
 891         osize = ip->i_size;
 892         if (seqcount > BA_SEQMAX)
 893                 flags = BA_SEQMAX << BA_SEQSHIFT;
 894         else
 895                 flags = seqcount << BA_SEQSHIFT;
 896         if (ioflag & IO_SYNC)
 897                 flags |= IO_SYNC;
 898         flags |= BA_UNMAPPED;
 899
 900         for (error = 0; uio->uio_resid > 0;) {
 901                 lbn = lblkno(fs, uio->uio_offset);
 902                 blkoffset = blkoff(fs, uio->uio_offset);
 903                 xfersize = fs->fs_bsize - blkoffset;
 904                 if (uio->uio_resid < xfersize)
 905                         xfersize = uio->uio_resid;
 906                 if (uio->uio_offset + xfersize > ip->i_size)
 907                         vnode_pager_setsize(vp, uio->uio_offset + xfersize);
 908
 909                 /*
 910                  * We must perform a read-before-write if the transfer size
 911                  * does not cover the entire buffer.
 912                  */
 913                 if (fs->fs_bsize > xfersize)
 914                         flags |= BA_CLRBUF;
 915                 else
 916                         flags &= ~BA_CLRBUF;
 917 /* XXX is uio->uio_offset the right thing here? */
 918                 error = UFS_BALLOC(vp, uio->uio_offset, xfersize,
 919                     ap->a_cred, flags, &bp);
 920                 if (error != 0) {
 921                         vnode_pager_setsize(vp, ip->i_size);
 922                         break;
 923                 }
 924                 if ((ioflag & (IO_SYNC|IO_INVAL)) == (IO_SYNC|IO_INVAL))
 925                         bp->b_flags |= B_NOCACHE;
 926
 927                 if (uio->uio_offset + xfersize > ip->i_size) {
 928                         ip->i_size = uio->uio_offset + xfersize;
 929                         DIP_SET(ip, i_size, ip->i_size);
 930                         UFS_INODE_SET_FLAG(ip, IN_SIZEMOD | IN_CHANGE);
 931                 }
 932
 933                 size = blksize(fs, ip, lbn) - bp->b_resid;
 934                 if (size < xfersize)
 935                         xfersize = size;
 936
 937                 if (buf_mapped(bp)) {
 938                         error = vn_io_fault_uiomove((char *)bp->b_data +
 939                             blkoffset, (int)xfersize, uio);
 940                 } else {
 941                         error = vn_io_fault_pgmove(bp->b_pages, blkoffset,
 942                             (int)xfersize, uio);
 943                 }
 944                 /*
 945                  * If the buffer is not already filled and we encounter an
 946                  * error while trying to fill it, we have to clear out any
 947                  * garbage data from the pages instantiated for the buffer.
 948                  * If we do not, a failed uiomove() during a write can leave
 949                  * the prior contents of the pages exposed to a userland mmap.
 950                  *
 951                  * Note that we need only clear buffers with a transfer size
 952                  * equal to the block size because buffers with a shorter
 953                  * transfer size were cleared above by the call to UFS_BALLOC()
 954                  * with the BA_CLRBUF flag set.
 955                  *
 956                  * If the source region for uiomove identically mmaps the
 957                  * buffer, uiomove() performed the NOP copy, and the buffer
 958                  * content remains valid because the page fault handler
 959                  * validated the pages.
 960                  */
 961                 if (error != 0 && (bp->b_flags & B_CACHE) == 0 &&
 962                     fs->fs_bsize == xfersize)
 963                         vfs_bio_clrbuf(bp);
 964
 965                 vfs_bio_set_flags(bp, ioflag);
 966
 967                 /*
 968                  * If IO_SYNC each buffer is written synchronously.  Otherwise
 969                  * if we have a severe page deficiency write the buffer
 970                  * asynchronously.  Otherwise try to cluster, and if that
 971                  * doesn't do it then either do an async write (if O_DIRECT),
 972                  * or a delayed write (if not).
 973                  */
 974                 if (ioflag & IO_SYNC) {
 975                         (void)bwrite(bp);
 976                 } else if (vm_page_count_severe() ||
 977                             buf_dirty_count_severe() ||
 978                             (ioflag & IO_ASYNC)) {
 979                         bp->b_flags |= B_CLUSTEROK;
 980                         bawrite(bp);
 981                 } else if (xfersize + blkoffset == fs->fs_bsize) {
 982                         if ((vp->v_mount->mnt_flag & MNT_NOCLUSTERW) == 0) {
 983                                 bp->b_flags |= B_CLUSTEROK;
 984                                 cluster_write(vp, &ip->i_clusterw, bp,
 985                                     ip->i_size, seqcount, GB_UNMAPPED);
 986                         } else {
 987                                 bawrite(bp);
 988                         }
 989                 } else if (ioflag & IO_DIRECT) {
 990                         bp->b_flags |= B_CLUSTEROK;
 991                         bawrite(bp);
 992                 } else {
 993                         bp->b_flags |= B_CLUSTEROK;
 994                         bdwrite(bp);
 995                 }
 996                 if (error || xfersize == 0)
 997                         break;
 998                 UFS_INODE_SET_FLAG(ip, IN_CHANGE | IN_UPDATE);
 999         }
1000         /*
1001          * If we successfully wrote any data, and we are not the superuser
1002          * we clear the setuid and setgid bits as a precaution against
1003          * tampering.
1004          */
1005         if ((ip->i_mode & (ISUID | ISGID)) && resid > uio->uio_resid &&
1006             ap->a_cred) {
1007                 if (priv_check_cred(ap->a_cred, PRIV_VFS_RETAINSUGID)) {
1008                         vn_seqc_write_begin(vp);
1009                         UFS_INODE_SET_MODE(ip, ip->i_mode & ~(ISUID | ISGID));
1010                         DIP_SET(ip, i_mode, ip->i_mode);
1011                         vn_seqc_write_end(vp);
1012                 }
1013         }
1014         if (error) {
1015                 if (ioflag & IO_UNIT) {
1016                         (void)ffs_truncate(vp, osize,
1017                             IO_NORMAL | (ioflag & IO_SYNC), ap->a_cred);
1018                         uio->uio_offset -= resid - uio->uio_resid;
1019                         uio->uio_resid = resid;
1020                 }
1021         } else if (resid > uio->uio_resid && (ioflag & IO_SYNC)) {
1022                 if (!(ioflag & IO_DATASYNC) ||
1023                     (ip->i_flags & (IN_SIZEMOD | IN_IBLKDATA)))
1024                         error = ffs_update(vp, 1);
1025                 if (ffs_fsfail_cleanup(VFSTOUFS(vp->v_mount), error))
1026                         error = ENXIO;
1027         }
1028         return (error);
1029 }
1030
1031 /*
1032  * Extended attribute area reading.
1033  */
1034 static int
1035 ffs_extread(struct vnode *vp, struct uio *uio, int ioflag)
1036 {
1037         struct inode *ip;
1038         struct ufs2_dinode *dp;
1039         struct fs *fs;
1040         struct buf *bp;
1041         ufs_lbn_t lbn, nextlbn;
1042         off_t bytesinfile;
1043         long size, xfersize, blkoffset;
1044         ssize_t orig_resid;
1045         int error;
1046
1047         ip = VTOI(vp);
1048         fs = ITOFS(ip);
1049         dp = ip->i_din2;
1050
1051 #ifdef INVARIANTS
1052         if (uio->uio_rw != UIO_READ || fs->fs_magic != FS_UFS2_MAGIC)
1053                 panic("ffs_extread: mode");
1054
1055 #endif
1056         orig_resid = uio->uio_resid;
1057         KASSERT(orig_resid >= 0, ("ffs_extread: uio->uio_resid < 0"));
1058         if (orig_resid == 0)
1059                 return (0);
1060         KASSERT(uio->uio_offset >= 0, ("ffs_extread: uio->uio_offset < 0"));
1061
1062         for (error = 0, bp = NULL; uio->uio_resid > 0; bp = NULL) {
1063                 if ((bytesinfile = dp->di_extsize - uio->uio_offset) <= 0)
1064                         break;
1065                 lbn = lblkno(fs, uio->uio_offset);
1066                 nextlbn = lbn + 1;
1067
1068                 /*
1069                  * size of buffer.  The buffer representing the
1070                  * end of the file is rounded up to the size of
1071                  * the block type ( fragment or full block,
1072                  * depending ).
1073                  */
1074                 size = sblksize(fs, dp->di_extsize, lbn);
1075                 blkoffset = blkoff(fs, uio->uio_offset);
1076
1077                 /*
1078                  * The amount we want to transfer in this iteration is
1079                  * one FS block less the amount of the data before
1080                  * our startpoint (duh!)
1081                  */
1082                 xfersize = fs->fs_bsize - blkoffset;
1083
1084                 /*
1085                  * But if we actually want less than the block,
1086                  * or the file doesn't have a whole block more of data,
1087                  * then use the lesser number.
1088                  */
1089                 if (uio->uio_resid < xfersize)
1090                         xfersize = uio->uio_resid;
1091                 if (bytesinfile < xfersize)
1092                         xfersize = bytesinfile;
1093
1094                 if (lblktosize(fs, nextlbn) >= dp->di_extsize) {
1095                         /*
1096                          * Don't do readahead if this is the end of the info.
1097                          */
1098                         error = bread(vp, -1 - lbn, size, NOCRED, &bp);
1099                 } else {
1100                         /*
1101                          * If we have a second block, then
1102                          * fire off a request for a readahead
1103                          * as well as a read. Note that the 4th and 5th
1104                          * arguments point to arrays of the size specified in
1105                          * the 6th argument.
1106                          */
1107                         u_int nextsize = sblksize(fs, dp->di_extsize, nextlbn);
1108
1109                         nextlbn = -1 - nextlbn;
1110                         error = breadn(vp, -1 - lbn,
1111                             size, &nextlbn, &nextsize, 1, NOCRED, &bp);
1112                 }
1113                 if (error) {
1114                         brelse(bp);
1115                         bp = NULL;
1116                         break;
1117                 }
1118
1119                 /*
1120                  * We should only get non-zero b_resid when an I/O error
1121                  * has occurred, which should cause us to break above.
1122                  * However, if the short read did not cause an error,
1123                  * then we want to ensure that we do not uiomove bad
1124                  * or uninitialized data.
1125                  */
1126                 size -= bp->b_resid;
1127                 if (size < xfersize) {
1128                         if (size == 0)
1129                                 break;
1130                         xfersize = size;
1131                 }
1132
1133                 error = uiomove((char *)bp->b_data + blkoffset,
1134                                         (int)xfersize, uio);
1135                 if (error)
1136                         break;
1137                 vfs_bio_brelse(bp, ioflag);
1138         }
1139
1140         /*
1141          * This can only happen in the case of an error
1142          * because the loop above resets bp to NULL on each iteration
1143          * and on normal completion has not set a new value into it.
1144          * so it must have come from a 'break' statement
1145          */
1146         if (bp != NULL)
1147                 vfs_bio_brelse(bp, ioflag);
1148         return (error);
1149 }
1150
1151 /*
1152  * Extended attribute area writing.
1153  */
1154 static int
1155 ffs_extwrite(struct vnode *vp, struct uio *uio, int ioflag, struct ucred *ucred)
1156 {
1157         struct inode *ip;
1158         struct ufs2_dinode *dp;
1159         struct fs *fs;
1160         struct buf *bp;
1161         ufs_lbn_t lbn;
1162         off_t osize;
1163         ssize_t resid;
1164         int blkoffset, error, flags, size, xfersize;
1165
1166         ip = VTOI(vp);
1167         fs = ITOFS(ip);
1168         dp = ip->i_din2;
1169
1170 #ifdef INVARIANTS
1171         if (uio->uio_rw != UIO_WRITE || fs->fs_magic != FS_UFS2_MAGIC)
1172                 panic("ffs_extwrite: mode");
1173 #endif
1174
1175         if (ioflag & IO_APPEND)
1176                 uio->uio_offset = dp->di_extsize;
1177         KASSERT(uio->uio_offset >= 0, ("ffs_extwrite: uio->uio_offset < 0"));
1178         KASSERT(uio->uio_resid >= 0, ("ffs_extwrite: uio->uio_resid < 0"));
1179         if ((uoff_t)uio->uio_offset + uio->uio_resid >
1180             UFS_NXADDR * fs->fs_bsize)
1181                 return (EFBIG);
1182
1183         resid = uio->uio_resid;
1184         osize = dp->di_extsize;
1185         flags = IO_EXT;
1186         if (ioflag & IO_SYNC)
1187                 flags |= IO_SYNC;
1188
1189         for (error = 0; uio->uio_resid > 0;) {
1190                 lbn = lblkno(fs, uio->uio_offset);
1191                 blkoffset = blkoff(fs, uio->uio_offset);
1192                 xfersize = fs->fs_bsize - blkoffset;
1193                 if (uio->uio_resid < xfersize)
1194                         xfersize = uio->uio_resid;
1195
1196                 /*
1197                  * We must perform a read-before-write if the transfer size
1198                  * does not cover the entire buffer.
1199                  */
1200                 if (fs->fs_bsize > xfersize)
1201                         flags |= BA_CLRBUF;
1202                 else
1203                         flags &= ~BA_CLRBUF;
1204                 error = UFS_BALLOC(vp, uio->uio_offset, xfersize,
1205                     ucred, flags, &bp);
1206                 if (error != 0)
1207                         break;
1208                 /*
1209                  * If the buffer is not valid we have to clear out any
1210                  * garbage data from the pages instantiated for the buffer.
1211                  * If we do not, a failed uiomove() during a write can leave
1212                  * the prior contents of the pages exposed to a userland
1213                  * mmap().  XXX deal with uiomove() errors a better way.
1214                  */
1215                 if ((bp->b_flags & B_CACHE) == 0 && fs->fs_bsize <= xfersize)
1216                         vfs_bio_clrbuf(bp);
1217
1218                 if (uio->uio_offset + xfersize > dp->di_extsize) {
1219                         dp->di_extsize = uio->uio_offset + xfersize;
1220                         UFS_INODE_SET_FLAG(ip, IN_SIZEMOD | IN_CHANGE);
1221                 }
1222
1223                 size = sblksize(fs, dp->di_extsize, lbn) - bp->b_resid;
1224                 if (size < xfersize)
1225                         xfersize = size;
1226
1227                 error =
1228                     uiomove((char *)bp->b_data + blkoffset, (int)xfersize, uio);
1229
1230                 vfs_bio_set_flags(bp, ioflag);
1231
1232                 /*
1233                  * If IO_SYNC each buffer is written synchronously.  Otherwise
1234                  * if we have a severe page deficiency write the buffer
1235                  * asynchronously.  Otherwise try to cluster, and if that
1236                  * doesn't do it then either do an async write (if O_DIRECT),
1237                  * or a delayed write (if not).
1238                  */
1239                 if (ioflag & IO_SYNC) {
1240                         (void)bwrite(bp);
1241                 } else if (vm_page_count_severe() ||
1242                             buf_dirty_count_severe() ||
1243                             xfersize + blkoffset == fs->fs_bsize ||
1244                             (ioflag & (IO_ASYNC | IO_DIRECT)))
1245                         bawrite(bp);
1246                 else
1247                         bdwrite(bp);
1248                 if (error || xfersize == 0)
1249                         break;
1250                 UFS_INODE_SET_FLAG(ip, IN_CHANGE);
1251         }
1252         /*
1253          * If we successfully wrote any data, and we are not the superuser
1254          * we clear the setuid and setgid bits as a precaution against
1255          * tampering.
1256          */
1257         if ((ip->i_mode & (ISUID | ISGID)) && resid > uio->uio_resid && ucred) {
1258                 if (priv_check_cred(ucred, PRIV_VFS_RETAINSUGID)) {
1259                         vn_seqc_write_begin(vp);
1260                         UFS_INODE_SET_MODE(ip, ip->i_mode & ~(ISUID | ISGID));
1261                         dp->di_mode = ip->i_mode;
1262                         vn_seqc_write_end(vp);
1263                 }
1264         }
1265         if (error) {
1266                 if (ioflag & IO_UNIT) {
1267                         (void)ffs_truncate(vp, osize,
1268                             IO_EXT | (ioflag&IO_SYNC), ucred);
1269                         uio->uio_offset -= resid - uio->uio_resid;
1270                         uio->uio_resid = resid;
1271                 }
1272         } else if (resid > uio->uio_resid && (ioflag & IO_SYNC))
1273                 error = ffs_update(vp, 1);
1274         return (error);
1275 }
1276
1277 /*
1278  * Vnode operating to retrieve a named extended attribute.
1279  *
1280  * Locate a particular EA (nspace:name) in the area (ptr:length), and return
1281  * the length of the EA, and possibly the pointer to the entry and to the data.
1282  */
1283 static int
1284 ffs_findextattr(u_char *ptr, u_int length, int nspace, const char *name,
1285     struct extattr **eapp, u_char **eac)
1286 {
1287         struct extattr *eap, *eaend;
1288         size_t nlen;
1289
1290         nlen = strlen(name);
1291         KASSERT(ALIGNED_TO(ptr, struct extattr), ("unaligned"));
1292         eap = (struct extattr *)ptr;
1293         eaend = (struct extattr *)(ptr + length);
1294         for (; eap < eaend; eap = EXTATTR_NEXT(eap)) {
1295                 KASSERT(EXTATTR_NEXT(eap) <= eaend,
1296                     ("extattr next %p beyond %p", EXTATTR_NEXT(eap), eaend));
1297                 if (eap->ea_namespace != nspace || eap->ea_namelength != nlen
1298                     || memcmp(eap->ea_name, name, nlen) != 0)
1299                         continue;
1300                 if (eapp != NULL)
1301                         *eapp = eap;
1302                 if (eac != NULL)
1303                         *eac = EXTATTR_CONTENT(eap);
1304                 return (EXTATTR_CONTENT_SIZE(eap));
1305         }
1306         return (-1);
1307 }
1308
1309 static int
1310 ffs_rdextattr(u_char **p, struct vnode *vp, struct thread *td)
1311 {
1312         const struct extattr *eap, *eaend, *eapnext;
1313         struct inode *ip;
1314         struct ufs2_dinode *dp;
1315         struct fs *fs;
1316         struct uio luio;
1317         struct iovec liovec;
1318         u_int easize;
1319         int error;
1320         u_char *eae;
1321
1322         ip = VTOI(vp);
1323         fs = ITOFS(ip);
1324         dp = ip->i_din2;
1325         easize = dp->di_extsize;
1326         if ((uoff_t)easize > UFS_NXADDR * fs->fs_bsize)
1327                 return (EFBIG);
1328
1329         eae = malloc(easize, M_TEMP, M_WAITOK);
1330
1331         liovec.iov_base = eae;
1332         liovec.iov_len = easize;
1333         luio.uio_iov = &liovec;
1334         luio.uio_iovcnt = 1;
1335         luio.uio_offset = 0;
1336         luio.uio_resid = easize;
1337         luio.uio_segflg = UIO_SYSSPACE;
1338         luio.uio_rw = UIO_READ;
1339         luio.uio_td = td;
1340
1341         error = ffs_extread(vp, &luio, IO_EXT | IO_SYNC);
1342         if (error) {
1343                 free(eae, M_TEMP);
1344                 return (error);
1345         }
1346         /* Validate disk xattrfile contents. */
1347         for (eap = (void *)eae, eaend = (void *)(eae + easize); eap < eaend;
1348             eap = eapnext) {
1349                 eapnext = EXTATTR_NEXT(eap);
1350                 /* Bogusly short entry or bogusly long entry. */
1351                 if (eap->ea_length < sizeof(*eap) || eapnext > eaend) {
1352                         free(eae, M_TEMP);
1353                         return (EINTEGRITY);
1354                 }
1355         }
1356         *p = eae;
1357         return (0);
1358 }
1359
1360 static void
1361 ffs_lock_ea(struct vnode *vp)
1362 {
1363         struct inode *ip;
1364
1365         ip = VTOI(vp);
1366         VI_LOCK(vp);
1367         while (ip->i_flag & IN_EA_LOCKED) {
1368                 UFS_INODE_SET_FLAG(ip, IN_EA_LOCKWAIT);
1369                 msleep(&ip->i_ea_refs, &vp->v_interlock, PINOD + 2, "ufs_ea",
1370                     0);
1371         }
1372         UFS_INODE_SET_FLAG(ip, IN_EA_LOCKED);
1373         VI_UNLOCK(vp);
1374 }
1375
1376 static void
1377 ffs_unlock_ea(struct vnode *vp)
1378 {
1379         struct inode *ip;
1380
1381         ip = VTOI(vp);
1382         VI_LOCK(vp);
1383         if (ip->i_flag & IN_EA_LOCKWAIT)
1384                 wakeup(&ip->i_ea_refs);
1385         ip->i_flag &= ~(IN_EA_LOCKED | IN_EA_LOCKWAIT);
1386         VI_UNLOCK(vp);
1387 }
1388
1389 static int
1390 ffs_open_ea(struct vnode *vp, struct ucred *cred, struct thread *td)
1391 {
1392         struct inode *ip;
1393         struct ufs2_dinode *dp;
1394         int error;
1395
1396         ip = VTOI(vp);
1397
1398         ffs_lock_ea(vp);
1399         if (ip->i_ea_area != NULL) {
1400                 ip->i_ea_refs++;
1401                 ffs_unlock_ea(vp);
1402                 return (0);
1403         }
1404         dp = ip->i_din2;
1405         error = ffs_rdextattr(&ip->i_ea_area, vp, td);
1406         if (error) {
1407                 ffs_unlock_ea(vp);
1408                 return (error);
1409         }
1410         ip->i_ea_len = dp->di_extsize;
1411         ip->i_ea_error = 0;
1412         ip->i_ea_refs++;
1413         ffs_unlock_ea(vp);
1414         return (0);
1415 }
1416
1417 /*
1418  * Vnode extattr transaction commit/abort
1419  */
1420 static int
1421 ffs_close_ea(struct vnode *vp, int commit, struct ucred *cred, struct thread *td)
1422 {
1423         struct inode *ip;
1424         struct uio luio;
1425         struct iovec *liovec;
1426         struct ufs2_dinode *dp;
1427         size_t ea_len, tlen;
1428         int error, i, lcnt;
1429
1430         ip = VTOI(vp);
1431
1432         ffs_lock_ea(vp);
1433         if (ip->i_ea_area == NULL) {
1434                 ffs_unlock_ea(vp);
1435                 return (EINVAL);
1436         }
1437         dp = ip->i_din2;
1438         error = ip->i_ea_error;
1439         if (commit && error == 0) {
1440                 ASSERT_VOP_ELOCKED(vp, "ffs_close_ea commit");
1441                 if (cred == NOCRED)
1442                         cred =  vp->v_mount->mnt_cred;
1443
1444                 ea_len = MAX(ip->i_ea_len, dp->di_extsize);
1445                 for (lcnt = 1, tlen = ea_len - ip->i_ea_len; tlen > 0;) {
1446                         tlen -= MIN(ZERO_REGION_SIZE, tlen);
1447                         lcnt++;
1448                 }
1449
1450                 liovec = __builtin_alloca(lcnt * sizeof(struct iovec));
1451                 luio.uio_iovcnt = lcnt;
1452
1453                 liovec[0].iov_base = ip->i_ea_area;
1454                 liovec[0].iov_len = ip->i_ea_len;
1455                 for (i = 1, tlen = ea_len; i < lcnt; i++) {
1456                         liovec[i].iov_base = __DECONST(void *, zero_region);
1457                         liovec[i].iov_len = MIN(ZERO_REGION_SIZE, tlen);
1458                         tlen -= liovec[i].iov_len;
1459                 }
1460                 MPASS(tlen == ip->i_ea_len);
1461
1462                 luio.uio_iov = liovec;
1463                 luio.uio_offset = 0;
1464                 luio.uio_resid = ea_len;
1465                 luio.uio_segflg = UIO_SYSSPACE;
1466                 luio.uio_rw = UIO_WRITE;
1467                 luio.uio_td = td;
1468                 error = ffs_extwrite(vp, &luio, IO_EXT | IO_SYNC, cred);
1469         }
1470         if (--ip->i_ea_refs == 0) {
1471                 free(ip->i_ea_area, M_TEMP);
1472                 ip->i_ea_area = NULL;
1473                 ip->i_ea_len = 0;
1474                 ip->i_ea_error = 0;
1475         }
1476         ffs_unlock_ea(vp);
1477
1478         if (commit && error == 0 && ip->i_ea_len == 0)
1479                 ffs_truncate(vp, 0, IO_EXT, cred);
1480         return (error);
1481 }
1482
1483 /*
1484  * Vnode extattr strategy routine for fifos.
1485  *
1486  * We need to check for a read or write of the external attributes.
1487  * Otherwise we just fall through and do the usual thing.
1488  */
1489 static int
1490 ffsext_strategy(struct vop_strategy_args *ap)
1491 /*
1492 struct vop_strategy_args {
1493         struct vnodeop_desc *a_desc;
1494         struct vnode *a_vp;
1495         struct buf *a_bp;
1496 };
1497 */
1498 {
1499         struct vnode *vp;
1500         daddr_t lbn;
1501
1502         vp = ap->a_vp;
1503         lbn = ap->a_bp->b_lblkno;
1504         if (I_IS_UFS2(VTOI(vp)) && lbn < 0 && lbn >= -UFS_NXADDR)
1505                 return (VOP_STRATEGY_APV(&ufs_vnodeops, ap));
1506         if (vp->v_type == VFIFO)
1507                 return (VOP_STRATEGY_APV(&ufs_fifoops, ap));
1508         panic("spec nodes went here");
1509 }
1510
1511 /*
1512  * Vnode extattr transaction commit/abort
1513  */
1514 static int
1515 ffs_openextattr(struct vop_openextattr_args *ap)
1516 /*
1517 struct vop_openextattr_args {
1518         struct vnodeop_desc *a_desc;
1519         struct vnode *a_vp;
1520         IN struct ucred *a_cred;
1521         IN struct thread *a_td;
1522 };
1523 */
1524 {
1525
1526         if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK)
1527                 return (EOPNOTSUPP);
1528
1529         return (ffs_open_ea(ap->a_vp, ap->a_cred, ap->a_td));
1530 }
1531
1532 /*
1533  * Vnode extattr transaction commit/abort
1534  */
1535 static int
1536 ffs_closeextattr(struct vop_closeextattr_args *ap)
1537 /*
1538 struct vop_closeextattr_args {
1539         struct vnodeop_desc *a_desc;
1540         struct vnode *a_vp;
1541         int a_commit;
1542         IN struct ucred *a_cred;
1543         IN struct thread *a_td;
1544 };
1545 */
1546 {
1547         struct vnode *vp;
1548
1549         vp = ap->a_vp;
1550         if (vp->v_type == VCHR || vp->v_type == VBLK)
1551                 return (EOPNOTSUPP);
1552         if (ap->a_commit && (vp->v_mount->mnt_flag & MNT_RDONLY) != 0)
1553                 return (EROFS);
1554
1555         return (ffs_close_ea(vp, ap->a_commit, ap->a_cred, ap->a_td));
1556 }
1557
1558 /*
1559  * Vnode operation to remove a named attribute.
1560  */
1561 static int
1562 ffs_deleteextattr(struct vop_deleteextattr_args *ap)
1563 /*
1564 vop_deleteextattr {
1565         IN struct vnode *a_vp;
1566         IN int a_attrnamespace;
1567         IN const char *a_name;
1568         IN struct ucred *a_cred;
1569         IN struct thread *a_td;
1570 };
1571 */
1572 {
1573         struct vnode *vp;
1574         struct inode *ip;
1575         struct extattr *eap;
1576         uint32_t ul;
1577         int olen, error, i, easize;
1578         u_char *eae;
1579         void *tmp;
1580
1581         vp = ap->a_vp;
1582         ip = VTOI(vp);
1583
1584         if (vp->v_type == VCHR || vp->v_type == VBLK)
1585                 return (EOPNOTSUPP);
1586         if (strlen(ap->a_name) == 0)
1587                 return (EINVAL);
1588         if (vp->v_mount->mnt_flag & MNT_RDONLY)
1589                 return (EROFS);
1590
1591         error = extattr_check_cred(vp, ap->a_attrnamespace,
1592             ap->a_cred, ap->a_td, VWRITE);
1593         if (error) {
1594                 /*
1595                  * ffs_lock_ea is not needed there, because the vnode
1596                  * must be exclusively locked.
1597                  */
1598                 if (ip->i_ea_area != NULL && ip->i_ea_error == 0)
1599                         ip->i_ea_error = error;
1600                 return (error);
1601         }
1602
1603         error = ffs_open_ea(vp, ap->a_cred, ap->a_td);
1604         if (error)
1605                 return (error);
1606
1607         /* CEM: delete could be done in-place instead */
1608         eae = malloc(ip->i_ea_len, M_TEMP, M_WAITOK);
1609         bcopy(ip->i_ea_area, eae, ip->i_ea_len);
1610         easize = ip->i_ea_len;
1611
1612         olen = ffs_findextattr(eae, easize, ap->a_attrnamespace, ap->a_name,
1613             &eap, NULL);
1614         if (olen == -1) {
1615                 /* delete but nonexistent */
1616                 free(eae, M_TEMP);
1617                 ffs_close_ea(vp, 0, ap->a_cred, ap->a_td);
1618                 return (ENOATTR);
1619         }
1620         ul = eap->ea_length;
1621         i = (u_char *)EXTATTR_NEXT(eap) - eae;
1622         bcopy(EXTATTR_NEXT(eap), eap, easize - i);
1623         easize -= ul;
1624
1625         tmp = ip->i_ea_area;
1626         ip->i_ea_area = eae;
1627         ip->i_ea_len = easize;
1628         free(tmp, M_TEMP);
1629         error = ffs_close_ea(vp, 1, ap->a_cred, ap->a_td);
1630         return (error);
1631 }
1632
1633 /*
1634  * Vnode operation to retrieve a named extended attribute.
1635  */
1636 static int
1637 ffs_getextattr(struct vop_getextattr_args *ap)
1638 /*
1639 vop_getextattr {
1640         IN struct vnode *a_vp;
1641         IN int a_attrnamespace;
1642         IN const char *a_name;
1643         INOUT struct uio *a_uio;
1644         OUT size_t *a_size;
1645         IN struct ucred *a_cred;
1646         IN struct thread *a_td;
1647 };
1648 */
1649 {
1650         struct inode *ip;
1651         u_char *eae, *p;
1652         unsigned easize;
1653         int error, ealen;
1654
1655         ip = VTOI(ap->a_vp);
1656
1657         if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK)
1658                 return (EOPNOTSUPP);
1659
1660         error = extattr_check_cred(ap->a_vp, ap->a_attrnamespace,
1661             ap->a_cred, ap->a_td, VREAD);
1662         if (error)
1663                 return (error);
1664
1665         error = ffs_open_ea(ap->a_vp, ap->a_cred, ap->a_td);
1666         if (error)
1667                 return (error);
1668
1669         eae = ip->i_ea_area;
1670         easize = ip->i_ea_len;
1671
1672         ealen = ffs_findextattr(eae, easize, ap->a_attrnamespace, ap->a_name,
1673             NULL, &p);
1674         if (ealen >= 0) {
1675                 error = 0;
1676                 if (ap->a_size != NULL)
1677                         *ap->a_size = ealen;
1678                 else if (ap->a_uio != NULL)
1679                         error = uiomove(p, ealen, ap->a_uio);
1680         } else
1681                 error = ENOATTR;
1682
1683         ffs_close_ea(ap->a_vp, 0, ap->a_cred, ap->a_td);
1684         return (error);
1685 }
1686
1687 /*
1688  * Vnode operation to retrieve extended attributes on a vnode.
1689  */
1690 static int
1691 ffs_listextattr(struct vop_listextattr_args *ap)
1692 /*
1693 vop_listextattr {
1694         IN struct vnode *a_vp;
1695         IN int a_attrnamespace;
1696         INOUT struct uio *a_uio;
1697         OUT size_t *a_size;
1698         IN struct ucred *a_cred;
1699         IN struct thread *a_td;
1700 };
1701 */
1702 {
1703         struct inode *ip;
1704         struct extattr *eap, *eaend;
1705         int error, ealen;
1706
1707         ip = VTOI(ap->a_vp);
1708
1709         if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK)
1710                 return (EOPNOTSUPP);
1711
1712         error = extattr_check_cred(ap->a_vp, ap->a_attrnamespace,
1713             ap->a_cred, ap->a_td, VREAD);
1714         if (error)
1715                 return (error);
1716
1717         error = ffs_open_ea(ap->a_vp, ap->a_cred, ap->a_td);
1718         if (error)
1719                 return (error);
1720
1721         error = 0;
1722         if (ap->a_size != NULL)
1723                 *ap->a_size = 0;
1724
1725         KASSERT(ALIGNED_TO(ip->i_ea_area, struct extattr), ("unaligned"));
1726         eap = (struct extattr *)ip->i_ea_area;
1727         eaend = (struct extattr *)(ip->i_ea_area + ip->i_ea_len);
1728         for (; error == 0 && eap < eaend; eap = EXTATTR_NEXT(eap)) {
1729                 KASSERT(EXTATTR_NEXT(eap) <= eaend,
1730                     ("extattr next %p beyond %p", EXTATTR_NEXT(eap), eaend));
1731                 if (eap->ea_namespace != ap->a_attrnamespace)
1732                         continue;
1733
1734                 ealen = eap->ea_namelength;
1735                 if (ap->a_size != NULL)
1736                         *ap->a_size += ealen + 1;
1737                 else if (ap->a_uio != NULL)
1738                         error = uiomove(&eap->ea_namelength, ealen + 1,
1739                             ap->a_uio);
1740         }
1741
1742         ffs_close_ea(ap->a_vp, 0, ap->a_cred, ap->a_td);
1743         return (error);
1744 }
1745
1746 /*
1747  * Vnode operation to set a named attribute.
1748  */
1749 static int
1750 ffs_setextattr(struct vop_setextattr_args *ap)
1751 /*
1752 vop_setextattr {
1753         IN struct vnode *a_vp;
1754         IN int a_attrnamespace;
1755         IN const char *a_name;
1756         INOUT struct uio *a_uio;
1757         IN struct ucred *a_cred;
1758         IN struct thread *a_td;
1759 };
1760 */
1761 {
1762         struct vnode *vp;
1763         struct inode *ip;
1764         struct fs *fs;
1765         struct extattr *eap;
1766         uint32_t ealength, ul;
1767         ssize_t ealen;
1768         int olen, eapad1, eapad2, error, i, easize;
1769         u_char *eae;
1770         void *tmp;
1771
1772         vp = ap->a_vp;
1773         ip = VTOI(vp);
1774         fs = ITOFS(ip);
1775
1776         if (vp->v_type == VCHR || vp->v_type == VBLK)
1777                 return (EOPNOTSUPP);
1778         if (strlen(ap->a_name) == 0)
1779                 return (EINVAL);
1780
1781         /* XXX Now unsupported API to delete EAs using NULL uio. */
1782         if (ap->a_uio == NULL)
1783                 return (EOPNOTSUPP);
1784
1785         if (vp->v_mount->mnt_flag & MNT_RDONLY)
1786                 return (EROFS);
1787
1788         ealen = ap->a_uio->uio_resid;
1789         if (ealen < 0 || ealen > lblktosize(fs, UFS_NXADDR))
1790                 return (EINVAL);
1791
1792         error = extattr_check_cred(vp, ap->a_attrnamespace,
1793             ap->a_cred, ap->a_td, VWRITE);
1794         if (error) {
1795                 /*
1796                  * ffs_lock_ea is not needed there, because the vnode
1797                  * must be exclusively locked.
1798                  */
1799                 if (ip->i_ea_area != NULL && ip->i_ea_error == 0)
1800                         ip->i_ea_error = error;
1801                 return (error);
1802         }
1803
1804         error = ffs_open_ea(vp, ap->a_cred, ap->a_td);
1805         if (error)
1806                 return (error);
1807
1808         ealength = sizeof(uint32_t) + 3 + strlen(ap->a_name);
1809         eapad1 = roundup2(ealength, 8) - ealength;
1810         eapad2 = roundup2(ealen, 8) - ealen;
1811         ealength += eapad1 + ealen + eapad2;
1812
1813         /*
1814          * CEM: rewrites of the same size or smaller could be done in-place
1815          * instead.  (We don't acquire any fine-grained locks in here either,
1816          * so we could also do bigger writes in-place.)
1817          */
1818         eae = malloc(ip->i_ea_len + ealength, M_TEMP, M_WAITOK);
1819         bcopy(ip->i_ea_area, eae, ip->i_ea_len);
1820         easize = ip->i_ea_len;
1821
1822         olen = ffs_findextattr(eae, easize, ap->a_attrnamespace, ap->a_name,
1823             &eap, NULL);
1824         if (olen == -1) {
1825                 /* new, append at end */
1826                 KASSERT(ALIGNED_TO(eae + easize, struct extattr),
1827                     ("unaligned"));
1828                 eap = (struct extattr *)(eae + easize);
1829                 easize += ealength;
1830         } else {
1831                 ul = eap->ea_length;
1832                 i = (u_char *)EXTATTR_NEXT(eap) - eae;
1833                 if (ul != ealength) {
1834                         bcopy(EXTATTR_NEXT(eap), (u_char *)eap + ealength,
1835                             easize - i);
1836                         easize += (ealength - ul);
1837                 }
1838         }
1839         if (easize > lblktosize(fs, UFS_NXADDR)) {
1840                 free(eae, M_TEMP);
1841                 ffs_close_ea(vp, 0, ap->a_cred, ap->a_td);
1842                 if (ip->i_ea_area != NULL && ip->i_ea_error == 0)
1843                         ip->i_ea_error = ENOSPC;
1844                 return (ENOSPC);
1845         }
1846         eap->ea_length = ealength;
1847         eap->ea_namespace = ap->a_attrnamespace;
1848         eap->ea_contentpadlen = eapad2;
1849         eap->ea_namelength = strlen(ap->a_name);
1850         memcpy(eap->ea_name, ap->a_name, strlen(ap->a_name));
1851         bzero(&eap->ea_name[strlen(ap->a_name)], eapad1);
1852         error = uiomove(EXTATTR_CONTENT(eap), ealen, ap->a_uio);
1853         if (error) {
1854                 free(eae, M_TEMP);
1855                 ffs_close_ea(vp, 0, ap->a_cred, ap->a_td);
1856                 if (ip->i_ea_area != NULL && ip->i_ea_error == 0)
1857                         ip->i_ea_error = error;
1858                 return (error);
1859         }
1860         bzero((u_char *)EXTATTR_CONTENT(eap) + ealen, eapad2);
1861
1862         tmp = ip->i_ea_area;
1863         ip->i_ea_area = eae;
1864         ip->i_ea_len = easize;
1865         free(tmp, M_TEMP);
1866         error = ffs_close_ea(vp, 1, ap->a_cred, ap->a_td);
1867         return (error);
1868 }
1869
1870 /*
1871  * Vnode pointer to File handle
1872  */
1873 static int
1874 ffs_vptofh(struct vop_vptofh_args *ap)
1875 /*
1876 vop_vptofh {
1877         IN struct vnode *a_vp;
1878         IN struct fid *a_fhp;
1879 };
1880 */
1881 {
1882         struct inode *ip;
1883         struct ufid *ufhp;
1884
1885         ip = VTOI(ap->a_vp);
1886         ufhp = (struct ufid *)ap->a_fhp;
1887         ufhp->ufid_len = sizeof(struct ufid);
1888         ufhp->ufid_ino = ip->i_number;
1889         ufhp->ufid_gen = ip->i_gen;
1890         return (0);
1891 }
1892
1893 SYSCTL_DECL(_vfs_ffs);
1894 static int use_buf_pager = 1;
1895 SYSCTL_INT(_vfs_ffs, OID_AUTO, use_buf_pager, CTLFLAG_RWTUN, &use_buf_pager, 0,
1896     "Always use buffer pager instead of bmap");
1897
1898 static daddr_t
1899 ffs_gbp_getblkno(struct vnode *vp, vm_ooffset_t off)
1900 {
1901
1902         return (lblkno(VFSTOUFS(vp->v_mount)->um_fs, off));
1903 }
1904
1905 static int
1906 ffs_gbp_getblksz(struct vnode *vp, daddr_t lbn)
1907 {
1908
1909         return (blksize(VFSTOUFS(vp->v_mount)->um_fs, VTOI(vp), lbn));
1910 }
1911
1912 static int
1913 ffs_getpages(struct vop_getpages_args *ap)
1914 {
1915         struct vnode *vp;
1916         struct ufsmount *um;
1917
1918         vp = ap->a_vp;
1919         um = VFSTOUFS(vp->v_mount);
1920
1921         if (!use_buf_pager && um->um_devvp->v_bufobj.bo_bsize <= PAGE_SIZE)
1922                 return (vnode_pager_generic_getpages(vp, ap->a_m, ap->a_count,
1923                     ap->a_rbehind, ap->a_rahead, NULL, NULL));
1924         return (vfs_bio_getpages(vp, ap->a_m, ap->a_count, ap->a_rbehind,
1925             ap->a_rahead, ffs_gbp_getblkno, ffs_gbp_getblksz));
1926 }
1927
1928 static int
1929 ffs_getpages_async(struct vop_getpages_async_args *ap)
1930 {
1931         struct vnode *vp;
1932         struct ufsmount *um;
1933         bool do_iodone;
1934         int error;
1935
1936         vp = ap->a_vp;
1937         um = VFSTOUFS(vp->v_mount);
1938         do_iodone = true;
1939
1940         if (um->um_devvp->v_bufobj.bo_bsize <= PAGE_SIZE) {
1941                 error = vnode_pager_generic_getpages(vp, ap->a_m, ap->a_count,
1942                     ap->a_rbehind, ap->a_rahead, ap->a_iodone, ap->a_arg);
1943                 if (error == 0)
1944                         do_iodone = false;
1945         } else {
1946                 error = vfs_bio_getpages(vp, ap->a_m, ap->a_count,
1947                     ap->a_rbehind, ap->a_rahead, ffs_gbp_getblkno,
1948                     ffs_gbp_getblksz);
1949         }
1950         if (do_iodone && ap->a_iodone != NULL)
1951                 ap->a_iodone(ap->a_arg, ap->a_m, ap->a_count, error);
1952
1953         return (error);
1954 }
1955
1956 static int
1957 ffs_vput_pair(struct vop_vput_pair_args *ap)
1958 {
1959         struct mount *mp;
1960         struct vnode *dvp, *vp, *vp1, **vpp;
1961         struct inode *dp, *ip;
1962         ino_t ip_ino;
1963         u_int64_t ip_gen;
1964         off_t old_size;
1965         int error, vp_locked;
1966
1967         dvp = ap->a_dvp;
1968         dp = VTOI(dvp);
1969         vpp = ap->a_vpp;
1970         vp = vpp != NULL ? *vpp : NULL;
1971
1972         if ((dp->i_flag & (IN_NEEDSYNC | IN_ENDOFF)) == 0) {
1973                 vput(dvp);
1974                 if (vp != NULL && ap->a_unlock_vp)
1975                         vput(vp);
1976                 return (0);
1977         }
1978
1979         mp = dvp->v_mount;
1980         if (vp != NULL) {
1981                 if (ap->a_unlock_vp) {
1982                         vput(vp);
1983                 } else {
1984                         MPASS(vp->v_type != VNON);
1985                         vp_locked = VOP_ISLOCKED(vp);
1986                         ip = VTOI(vp);
1987                         ip_ino = ip->i_number;
1988                         ip_gen = ip->i_gen;
1989                         VOP_UNLOCK(vp);
1990                 }
1991         }
1992
1993         /*
1994          * If compaction or fsync was requested do it in ffs_vput_pair()
1995          * now that other locks are no longer held.
1996          */
1997         if ((dp->i_flag & IN_ENDOFF) != 0) {
1998                 VNASSERT(I_ENDOFF(dp) != 0 && I_ENDOFF(dp) < dp->i_size, dvp,
1999                     ("IN_ENDOFF set but I_ENDOFF() is not"));
2000                 dp->i_flag &= ~IN_ENDOFF;
2001                 old_size = dp->i_size;
2002                 error = UFS_TRUNCATE(dvp, (off_t)I_ENDOFF(dp), IO_NORMAL |
2003                     (DOINGASYNC(dvp) ? 0 : IO_SYNC), curthread->td_ucred);
2004                 if (error != 0 && error != ERELOOKUP) {
2005                         if (!ffs_fsfail_cleanup(VFSTOUFS(mp), error)) {
2006                                 vn_printf(dvp,
2007                                     "IN_ENDOFF: failed to truncate, "
2008                                     "error %d\n", error);
2009                         }
2010 #ifdef UFS_DIRHASH
2011                         ufsdirhash_free(dp);
2012 #endif
2013                 }
2014                 SET_I_ENDOFF(dp, 0);
2015         }
2016         if ((dp->i_flag & IN_NEEDSYNC) != 0) {
2017                 do {
2018                         error = ffs_syncvnode(dvp, MNT_WAIT, 0);
2019                 } while (error == ERELOOKUP);
2020         }
2021
2022         vput(dvp);
2023
2024         if (vp == NULL || ap->a_unlock_vp)
2025                 return (0);
2026         MPASS(mp != NULL);
2027
2028         /*
2029          * It is possible that vp is reclaimed at this point. Only
2030          * routines that call us with a_unlock_vp == false can find
2031          * that their vp has been reclaimed. There are three areas
2032          * that are affected:
2033          * 1) vn_open_cred() - later VOPs could fail, but
2034          *    dead_open() returns 0 to simulate successful open.
2035          * 2) ffs_snapshot() - creation of snapshot fails with EBADF.
2036          * 3) NFS server (several places) - code is prepared to detect
2037          *    and respond to dead vnodes by returning ESTALE.
2038          */
2039         VOP_LOCK(vp, vp_locked | LK_RETRY);
2040         if (!VN_IS_DOOMED(vp))
2041                 return (0);
2042
2043         /*
2044          * Try harder to recover from reclaimed vp if reclaim was not
2045          * because underlying inode was cleared.  We saved inode
2046          * number and inode generation, so we can try to reinstantiate
2047          * exactly same version of inode.  If this fails, return
2048          * original doomed vnode and let caller to handle
2049          * consequences.
2050          *
2051          * Note that callers must keep write started around
2052          * VOP_VPUT_PAIR() calls, so it is safe to use mp without
2053          * busying it.
2054          */
2055         VOP_UNLOCK(vp);
2056         error = ffs_inotovp(mp, ip_ino, ip_gen, LK_EXCLUSIVE, &vp1,
2057             FFSV_REPLACE_DOOMED);
2058         if (error != 0) {
2059                 VOP_LOCK(vp, vp_locked | LK_RETRY);
2060         } else {
2061                 vrele(vp);
2062                 *vpp = vp1;
2063         }
2064         return (error);
2065 }