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 <sys/param.h>
  70 #include <sys/bio.h>
  71 #include <sys/systm.h>
  72 #include <sys/buf.h>
  73 #include <sys/conf.h>
  74 #include <sys/extattr.h>
  75 #include <sys/kernel.h>
  76 #include <sys/limits.h>
  77 #include <sys/malloc.h>
  78 #include <sys/mount.h>
  79 #include <sys/priv.h>
  80 #include <sys/rwlock.h>
  81 #include <sys/stat.h>
  82 #include <sys/sysctl.h>
  83 #include <sys/vmmeter.h>
  84 #include <sys/vnode.h>
  85
  86 #include <vm/vm.h>
  87 #include <vm/vm_param.h>
  88 #include <vm/vm_extern.h>
  89 #include <vm/vm_object.h>
  90 #include <vm/vm_page.h>
  91 #include <vm/vm_pager.h>
  92 #include <vm/vnode_pager.h>
  93
  94 #include <ufs/ufs/extattr.h>
  95 #include <ufs/ufs/quota.h>
  96 #include <ufs/ufs/inode.h>
  97 #include <ufs/ufs/ufs_extern.h>
  98 #include <ufs/ufs/ufsmount.h>
  99
 100 #include <ufs/ffs/fs.h>
 101 #include <ufs/ffs/ffs_extern.h>
 102 #include "opt_directio.h"
 103 #include "opt_ffs.h"
 104
 105 #define ALIGNED_TO(ptr, s)      \
 106         (((uintptr_t)(ptr) & (_Alignof(s) - 1)) == 0)
 107
 108 #ifdef DIRECTIO
 109 extern int      ffs_rawread(struct vnode *vp, struct uio *uio, int *workdone);
 110 #endif
 111 static vop_fdatasync_t  ffs_fdatasync;
 112 static vop_fsync_t      ffs_fsync;
 113 static vop_getpages_t   ffs_getpages;
 114 static vop_lock1_t      ffs_lock;
 115 static vop_read_t       ffs_read;
 116 static vop_write_t      ffs_write;
 117 static int      ffs_extread(struct vnode *vp, struct uio *uio, int ioflag);
 118 static int      ffs_extwrite(struct vnode *vp, struct uio *uio, int ioflag,
 119                     struct ucred *cred);
 120 static vop_strategy_t   ffsext_strategy;
 121 static vop_closeextattr_t       ffs_closeextattr;
 122 static vop_deleteextattr_t      ffs_deleteextattr;
 123 static vop_getextattr_t ffs_getextattr;
 124 static vop_listextattr_t        ffs_listextattr;
 125 static vop_openextattr_t        ffs_openextattr;
 126 static vop_setextattr_t ffs_setextattr;
 127 static vop_vptofh_t     ffs_vptofh;
 128
 129 /* Global vfs data structures for ufs. */
 130 struct vop_vector ffs_vnodeops1 = {
 131         .vop_default =          &ufs_vnodeops,
 132         .vop_fsync =            ffs_fsync,
 133         .vop_fdatasync =        ffs_fdatasync,
 134         .vop_getpages =         ffs_getpages,
 135         .vop_getpages_async =   vnode_pager_local_getpages_async,
 136         .vop_lock1 =            ffs_lock,
 137         .vop_read =             ffs_read,
 138         .vop_reallocblks =      ffs_reallocblks,
 139         .vop_write =            ffs_write,
 140         .vop_vptofh =           ffs_vptofh,
 141 };
 142
 143 struct vop_vector ffs_fifoops1 = {
 144         .vop_default =          &ufs_fifoops,
 145         .vop_fsync =            ffs_fsync,
 146         .vop_fdatasync =        ffs_fdatasync,
 147         .vop_reallocblks =      ffs_reallocblks, /* XXX: really ??? */
 148         .vop_vptofh =           ffs_vptofh,
 149 };
 150
 151 /* Global vfs data structures for ufs. */
 152 struct vop_vector ffs_vnodeops2 = {
 153         .vop_default =          &ufs_vnodeops,
 154         .vop_fsync =            ffs_fsync,
 155         .vop_fdatasync =        ffs_fdatasync,
 156         .vop_getpages =         ffs_getpages,
 157         .vop_getpages_async =   vnode_pager_local_getpages_async,
 158         .vop_lock1 =            ffs_lock,
 159         .vop_read =             ffs_read,
 160         .vop_reallocblks =      ffs_reallocblks,
 161         .vop_write =            ffs_write,
 162         .vop_closeextattr =     ffs_closeextattr,
 163         .vop_deleteextattr =    ffs_deleteextattr,
 164         .vop_getextattr =       ffs_getextattr,
 165         .vop_listextattr =      ffs_listextattr,
 166         .vop_openextattr =      ffs_openextattr,
 167         .vop_setextattr =       ffs_setextattr,
 168         .vop_vptofh =           ffs_vptofh,
 169 };
 170
 171 struct vop_vector ffs_fifoops2 = {
 172         .vop_default =          &ufs_fifoops,
 173         .vop_fsync =            ffs_fsync,
 174         .vop_fdatasync =        ffs_fdatasync,
 175         .vop_lock1 =            ffs_lock,
 176         .vop_reallocblks =      ffs_reallocblks,
 177         .vop_strategy =         ffsext_strategy,
 178         .vop_closeextattr =     ffs_closeextattr,
 179         .vop_deleteextattr =    ffs_deleteextattr,
 180         .vop_getextattr =       ffs_getextattr,
 181         .vop_listextattr =      ffs_listextattr,
 182         .vop_openextattr =      ffs_openextattr,
 183         .vop_setextattr =       ffs_setextattr,
 184         .vop_vptofh =           ffs_vptofh,
 185 };
 186
 187 /*
 188  * Synch an open file.
 189  */
 190 /* ARGSUSED */
 191 static int
 192 ffs_fsync(struct vop_fsync_args *ap)
 193 {
 194         struct vnode *vp;
 195         struct bufobj *bo;
 196         int error;
 197
 198         vp = ap->a_vp;
 199         bo = &vp->v_bufobj;
 200 retry:
 201         error = ffs_syncvnode(vp, ap->a_waitfor, 0);
 202         if (error)
 203                 return (error);
 204         if (ap->a_waitfor == MNT_WAIT && DOINGSOFTDEP(vp)) {
 205                 error = softdep_fsync(vp);
 206                 if (error)
 207                         return (error);
 208
 209                 /*
 210                  * The softdep_fsync() function may drop vp lock,
 211                  * allowing for dirty buffers to reappear on the
 212                  * bo_dirty list. Recheck and resync as needed.
 213                  */
 214                 BO_LOCK(bo);
 215                 if ((vp->v_type == VREG || vp->v_type == VDIR) &&
 216                     (bo->bo_numoutput > 0 || bo->bo_dirty.bv_cnt > 0)) {
 217                         BO_UNLOCK(bo);
 218                         goto retry;
 219                 }
 220                 BO_UNLOCK(bo);
 221         }
 222         return (0);
 223 }
 224
 225 int
 226 ffs_syncvnode(struct vnode *vp, int waitfor, int flags)
 227 {
 228         struct inode *ip;
 229         struct bufobj *bo;
 230         struct buf *bp, *nbp;
 231         ufs_lbn_t lbn;
 232         int error, passes;
 233         bool still_dirty, wait;
 234
 235         ip = VTOI(vp);
 236         ip->i_flag &= ~IN_NEEDSYNC;
 237         bo = &vp->v_bufobj;
 238
 239         /*
 240          * When doing MNT_WAIT we must first flush all dependencies
 241          * on the inode.
 242          */
 243         if (DOINGSOFTDEP(vp) && waitfor == MNT_WAIT &&
 244             (error = softdep_sync_metadata(vp)) != 0)
 245                 return (error);
 246
 247         /*
 248          * Flush all dirty buffers associated with a vnode.
 249          */
 250         error = 0;
 251         passes = 0;
 252         wait = false;   /* Always do an async pass first. */
 253         lbn = lblkno(ITOFS(ip), (ip->i_size + ITOFS(ip)->fs_bsize - 1));
 254         BO_LOCK(bo);
 255 loop:
 256         TAILQ_FOREACH(bp, &bo->bo_dirty.bv_hd, b_bobufs)
 257                 bp->b_vflags &= ~BV_SCANNED;
 258         TAILQ_FOREACH_SAFE(bp, &bo->bo_dirty.bv_hd, b_bobufs, nbp) {
 259                 /*
 260                  * Reasons to skip this buffer: it has already been considered
 261                  * on this pass, the buffer has dependencies that will cause
 262                  * it to be redirtied and it has not already been deferred,
 263                  * or it is already being written.
 264                  */
 265                 if ((bp->b_vflags & BV_SCANNED) != 0)
 266                         continue;
 267                 bp->b_vflags |= BV_SCANNED;
 268                 /*
 269                  * Flush indirects in order, if requested.
 270                  *
 271                  * Note that if only datasync is requested, we can
 272                  * skip indirect blocks when softupdates are not
 273                  * active.  Otherwise we must flush them with data,
 274                  * since dependencies prevent data block writes.
 275                  */
 276                 if (waitfor == MNT_WAIT && bp->b_lblkno <= -UFS_NDADDR &&
 277                     (lbn_level(bp->b_lblkno) >= passes ||
 278                     ((flags & DATA_ONLY) != 0 && !DOINGSOFTDEP(vp))))
 279                         continue;
 280                 if (bp->b_lblkno > lbn)
 281                         panic("ffs_syncvnode: syncing truncated data.");
 282                 if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT, NULL) == 0) {
 283                         BO_UNLOCK(bo);
 284                 } else if (wait) {
 285                         if (BUF_LOCK(bp,
 286                             LK_EXCLUSIVE | LK_SLEEPFAIL | LK_INTERLOCK,
 287                             BO_LOCKPTR(bo)) != 0) {
 288                                 bp->b_vflags &= ~BV_SCANNED;
 289                                 goto next;
 290                         }
 291                 } else
 292                         continue;
 293                 if ((bp->b_flags & B_DELWRI) == 0)
 294                         panic("ffs_fsync: not dirty");
 295                 /*
 296                  * Check for dependencies and potentially complete them.
 297                  */
 298                 if (!LIST_EMPTY(&bp->b_dep) &&
 299                     (error = softdep_sync_buf(vp, bp,
 300                     wait ? MNT_WAIT : MNT_NOWAIT)) != 0) {
 301                         /* I/O error. */
 302                         if (error != EBUSY) {
 303                                 BUF_UNLOCK(bp);
 304                                 return (error);
 305                         }
 306                         /* If we deferred once, don't defer again. */
 307                         if ((bp->b_flags & B_DEFERRED) == 0) {
 308                                 bp->b_flags |= B_DEFERRED;
 309                                 BUF_UNLOCK(bp);
 310                                 goto next;
 311                         }
 312                 }
 313                 if (wait) {
 314                         bremfree(bp);
 315                         if ((error = bwrite(bp)) != 0)
 316                                 return (error);
 317                 } else if ((bp->b_flags & B_CLUSTEROK)) {
 318                         (void) vfs_bio_awrite(bp);
 319                 } else {
 320                         bremfree(bp);
 321                         (void) bawrite(bp);
 322                 }
 323 next:
 324                 /*
 325                  * Since we may have slept during the I/O, we need
 326                  * to start from a known point.
 327                  */
 328                 BO_LOCK(bo);
 329                 nbp = TAILQ_FIRST(&bo->bo_dirty.bv_hd);
 330         }
 331         if (waitfor != MNT_WAIT) {
 332                 BO_UNLOCK(bo);
 333                 if ((flags & NO_INO_UPDT) != 0)
 334                         return (0);
 335                 else
 336                         return (ffs_update(vp, 0));
 337         }
 338         /* Drain IO to see if we're done. */
 339         bufobj_wwait(bo, 0, 0);
 340         /*
 341          * Block devices associated with filesystems may have new I/O
 342          * requests posted for them even if the vnode is locked, so no
 343          * amount of trying will get them clean.  We make several passes
 344          * as a best effort.
 345          *
 346          * Regular files may need multiple passes to flush all dependency
 347          * work as it is possible that we must write once per indirect
 348          * level, once for the leaf, and once for the inode and each of
 349          * these will be done with one sync and one async pass.
 350          */
 351         if (bo->bo_dirty.bv_cnt > 0) {
 352                 if ((flags & DATA_ONLY) == 0) {
 353                         still_dirty = true;
 354                 } else {
 355                         /*
 356                          * For data-only sync, dirty indirect buffers
 357                          * are ignored.
 358                          */
 359                         still_dirty = false;
 360                         TAILQ_FOREACH(bp, &bo->bo_dirty.bv_hd, b_bobufs) {
 361                                 if (bp->b_lblkno > -UFS_NDADDR) {
 362                                         still_dirty = true;
 363                                         break;
 364                                 }
 365                         }
 366                 }
 367
 368                 if (still_dirty) {
 369                         /* Write the inode after sync passes to flush deps. */
 370                         if (wait && DOINGSOFTDEP(vp) &&
 371                             (flags & NO_INO_UPDT) == 0) {
 372                                 BO_UNLOCK(bo);
 373                                 ffs_update(vp, 1);
 374                                 BO_LOCK(bo);
 375                         }
 376                         /* switch between sync/async. */
 377                         wait = !wait;
 378                         if (wait || ++passes < UFS_NIADDR + 2)
 379                                 goto loop;
 380                 }
 381         }
 382         BO_UNLOCK(bo);
 383         error = 0;
 384         if ((flags & DATA_ONLY) == 0) {
 385                 if ((flags & NO_INO_UPDT) == 0)
 386                         error = ffs_update(vp, 1);
 387                 if (DOINGSUJ(vp))
 388                         softdep_journal_fsync(VTOI(vp));
 389         }
 390         return (error);
 391 }
 392
 393 static int
 394 ffs_fdatasync(struct vop_fdatasync_args *ap)
 395 {
 396
 397         return (ffs_syncvnode(ap->a_vp, MNT_WAIT, DATA_ONLY));
 398 }
 399
 400 static int
 401 ffs_lock(ap)
 402         struct vop_lock1_args /* {
 403                 struct vnode *a_vp;
 404                 int a_flags;
 405                 struct thread *a_td;
 406                 char *file;
 407                 int line;
 408         } */ *ap;
 409 {
 410 #ifndef NO_FFS_SNAPSHOT
 411         struct vnode *vp;
 412         int flags;
 413         struct lock *lkp;
 414         int result;
 415
 416         switch (ap->a_flags & LK_TYPE_MASK) {
 417         case LK_SHARED:
 418         case LK_UPGRADE:
 419         case LK_EXCLUSIVE:
 420                 vp = ap->a_vp;
 421                 flags = ap->a_flags;
 422                 for (;;) {
 423 #ifdef DEBUG_VFS_LOCKS
 424                         KASSERT(vp->v_holdcnt != 0,
 425                             ("ffs_lock %p: zero hold count", vp));
 426 #endif
 427                         lkp = vp->v_vnlock;
 428                         result = _lockmgr_args(lkp, flags, VI_MTX(vp),
 429                             LK_WMESG_DEFAULT, LK_PRIO_DEFAULT, LK_TIMO_DEFAULT,
 430                             ap->a_file, ap->a_line);
 431                         if (lkp == vp->v_vnlock || result != 0)
 432                                 break;
 433                         /*
 434                          * Apparent success, except that the vnode
 435                          * mutated between snapshot file vnode and
 436                          * regular file vnode while this process
 437                          * slept.  The lock currently held is not the
 438                          * right lock.  Release it, and try to get the
 439                          * new lock.
 440                          */
 441                         (void) _lockmgr_args(lkp, LK_RELEASE, NULL,
 442                             LK_WMESG_DEFAULT, LK_PRIO_DEFAULT, LK_TIMO_DEFAULT,
 443                             ap->a_file, ap->a_line);
 444                         if ((flags & (LK_INTERLOCK | LK_NOWAIT)) ==
 445                             (LK_INTERLOCK | LK_NOWAIT))
 446                                 return (EBUSY);
 447                         if ((flags & LK_TYPE_MASK) == LK_UPGRADE)
 448                                 flags = (flags & ~LK_TYPE_MASK) | LK_EXCLUSIVE;
 449                         flags &= ~LK_INTERLOCK;
 450                 }
 451                 break;
 452         default:
 453                 result = VOP_LOCK1_APV(&ufs_vnodeops, ap);
 454         }
 455         return (result);
 456 #else
 457         return (VOP_LOCK1_APV(&ufs_vnodeops, ap));
 458 #endif
 459 }
 460
 461 static int
 462 ffs_read_hole(struct uio *uio, long xfersize, long *size)
 463 {
 464         ssize_t saved_resid, tlen;
 465         int error;
 466
 467         while (xfersize > 0) {
 468                 tlen = min(xfersize, ZERO_REGION_SIZE);
 469                 saved_resid = uio->uio_resid;
 470                 error = vn_io_fault_uiomove(__DECONST(void *, zero_region),
 471                     tlen, uio);
 472                 if (error != 0)
 473                         return (error);
 474                 tlen = saved_resid - uio->uio_resid;
 475                 xfersize -= tlen;
 476                 *size -= tlen;
 477         }
 478         return (0);
 479 }
 480
 481 /*
 482  * Vnode op for reading.
 483  */
 484 static int
 485 ffs_read(ap)
 486         struct vop_read_args /* {
 487                 struct vnode *a_vp;
 488                 struct uio *a_uio;
 489                 int a_ioflag;
 490                 struct ucred *a_cred;
 491         } */ *ap;
 492 {
 493         struct vnode *vp;
 494         struct inode *ip;
 495         struct uio *uio;
 496         struct fs *fs;
 497         struct buf *bp;
 498         ufs_lbn_t lbn, nextlbn;
 499         off_t bytesinfile;
 500         long size, xfersize, blkoffset;
 501         ssize_t orig_resid;
 502         int bflag, error, ioflag, seqcount;
 503
 504         vp = ap->a_vp;
 505         uio = ap->a_uio;
 506         ioflag = ap->a_ioflag;
 507         if (ap->a_ioflag & IO_EXT)
 508 #ifdef notyet
 509                 return (ffs_extread(vp, uio, ioflag));
 510 #else
 511                 panic("ffs_read+IO_EXT");
 512 #endif
 513 #ifdef DIRECTIO
 514         if ((ioflag & IO_DIRECT) != 0) {
 515                 int workdone;
 516
 517                 error = ffs_rawread(vp, uio, &workdone);
 518                 if (error != 0 || workdone != 0)
 519                         return error;
 520         }
 521 #endif
 522
 523         seqcount = ap->a_ioflag >> IO_SEQSHIFT;
 524         ip = VTOI(vp);
 525
 526 #ifdef INVARIANTS
 527         if (uio->uio_rw != UIO_READ)
 528                 panic("ffs_read: mode");
 529
 530         if (vp->v_type == VLNK) {
 531                 if ((int)ip->i_size < vp->v_mount->mnt_maxsymlinklen)
 532                         panic("ffs_read: short symlink");
 533         } else if (vp->v_type != VREG && vp->v_type != VDIR)
 534                 panic("ffs_read: type %d",  vp->v_type);
 535 #endif
 536         orig_resid = uio->uio_resid;
 537         KASSERT(orig_resid >= 0, ("ffs_read: uio->uio_resid < 0"));
 538         if (orig_resid == 0)
 539                 return (0);
 540         KASSERT(uio->uio_offset >= 0, ("ffs_read: uio->uio_offset < 0"));
 541         fs = ITOFS(ip);
 542         if (uio->uio_offset < ip->i_size &&
 543             uio->uio_offset >= fs->fs_maxfilesize)
 544                 return (EOVERFLOW);
 545
 546         bflag = GB_UNMAPPED | (uio->uio_segflg == UIO_NOCOPY ? 0 : GB_NOSPARSE);
 547         for (error = 0, bp = NULL; uio->uio_resid > 0; bp = NULL) {
 548                 if ((bytesinfile = ip->i_size - uio->uio_offset) <= 0)
 549                         break;
 550                 lbn = lblkno(fs, uio->uio_offset);
 551                 nextlbn = lbn + 1;
 552
 553                 /*
 554                  * size of buffer.  The buffer representing the
 555                  * end of the file is rounded up to the size of
 556                  * the block type ( fragment or full block,
 557                  * depending ).
 558                  */
 559                 size = blksize(fs, ip, lbn);
 560                 blkoffset = blkoff(fs, uio->uio_offset);
 561
 562                 /*
 563                  * The amount we want to transfer in this iteration is
 564                  * one FS block less the amount of the data before
 565                  * our startpoint (duh!)
 566                  */
 567                 xfersize = fs->fs_bsize - blkoffset;
 568
 569                 /*
 570                  * But if we actually want less than the block,
 571                  * or the file doesn't have a whole block more of data,
 572                  * then use the lesser number.
 573                  */
 574                 if (uio->uio_resid < xfersize)
 575                         xfersize = uio->uio_resid;
 576                 if (bytesinfile < xfersize)
 577                         xfersize = bytesinfile;
 578
 579                 if (lblktosize(fs, nextlbn) >= ip->i_size) {
 580                         /*
 581                          * Don't do readahead if this is the end of the file.
 582                          */
 583                         error = bread_gb(vp, lbn, size, NOCRED, bflag, &bp);
 584                 } else if ((vp->v_mount->mnt_flag & MNT_NOCLUSTERR) == 0) {
 585                         /*
 586                          * Otherwise if we are allowed to cluster,
 587                          * grab as much as we can.
 588                          *
 589                          * XXX  This may not be a win if we are not
 590                          * doing sequential access.
 591                          */
 592                         error = cluster_read(vp, ip->i_size, lbn,
 593                             size, NOCRED, blkoffset + uio->uio_resid,
 594                             seqcount, bflag, &bp);
 595                 } else if (seqcount > 1) {
 596                         /*
 597                          * If we are NOT allowed to cluster, then
 598                          * if we appear to be acting sequentially,
 599                          * fire off a request for a readahead
 600                          * as well as a read. Note that the 4th and 5th
 601                          * arguments point to arrays of the size specified in
 602                          * the 6th argument.
 603                          */
 604                         u_int nextsize = blksize(fs, ip, nextlbn);
 605                         error = breadn_flags(vp, lbn, size, &nextlbn,
 606                             &nextsize, 1, NOCRED, bflag, NULL, &bp);
 607                 } else {
 608                         /*
 609                          * Failing all of the above, just read what the
 610                          * user asked for. Interestingly, the same as
 611                          * the first option above.
 612                          */
 613                         error = bread_gb(vp, lbn, size, NOCRED, bflag, &bp);
 614                 }
 615                 if (error == EJUSTRETURN) {
 616                         error = ffs_read_hole(uio, xfersize, &size);
 617                         if (error == 0)
 618                                 continue;
 619                 }
 620                 if (error != 0) {
 621                         brelse(bp);
 622                         bp = NULL;
 623                         break;
 624                 }
 625
 626                 /*
 627                  * We should only get non-zero b_resid when an I/O error
 628                  * has occurred, which should cause us to break above.
 629                  * However, if the short read did not cause an error,
 630                  * then we want to ensure that we do not uiomove bad
 631                  * or uninitialized data.
 632                  */
 633                 size -= bp->b_resid;
 634                 if (size < xfersize) {
 635                         if (size == 0)
 636                                 break;
 637                         xfersize = size;
 638                 }
 639
 640                 if (buf_mapped(bp)) {
 641                         error = vn_io_fault_uiomove((char *)bp->b_data +
 642                             blkoffset, (int)xfersize, uio);
 643                 } else {
 644                         error = vn_io_fault_pgmove(bp->b_pages, blkoffset,
 645                             (int)xfersize, uio);
 646                 }
 647                 if (error)
 648                         break;
 649
 650                 vfs_bio_brelse(bp, ioflag);
 651         }
 652
 653         /*
 654          * This can only happen in the case of an error
 655          * because the loop above resets bp to NULL on each iteration
 656          * and on normal completion has not set a new value into it.
 657          * so it must have come from a 'break' statement
 658          */
 659         if (bp != NULL)
 660                 vfs_bio_brelse(bp, ioflag);
 661
 662         if ((error == 0 || uio->uio_resid != orig_resid) &&
 663             (vp->v_mount->mnt_flag & (MNT_NOATIME | MNT_RDONLY)) == 0 &&
 664             (ip->i_flag & IN_ACCESS) == 0) {
 665                 VI_LOCK(vp);
 666                 ip->i_flag |= IN_ACCESS;
 667                 VI_UNLOCK(vp);
 668         }
 669         return (error);
 670 }
 671
 672 /*
 673  * Vnode op for writing.
 674  */
 675 static int
 676 ffs_write(ap)
 677         struct vop_write_args /* {
 678                 struct vnode *a_vp;
 679                 struct uio *a_uio;
 680                 int a_ioflag;
 681                 struct ucred *a_cred;
 682         } */ *ap;
 683 {
 684         struct vnode *vp;
 685         struct uio *uio;
 686         struct inode *ip;
 687         struct fs *fs;
 688         struct buf *bp;
 689         ufs_lbn_t lbn;
 690         off_t osize;
 691         ssize_t resid;
 692         int seqcount;
 693         int blkoffset, error, flags, ioflag, size, xfersize;
 694
 695         vp = ap->a_vp;
 696         uio = ap->a_uio;
 697         ioflag = ap->a_ioflag;
 698         if (ap->a_ioflag & IO_EXT)
 699 #ifdef notyet
 700                 return (ffs_extwrite(vp, uio, ioflag, ap->a_cred));
 701 #else
 702                 panic("ffs_write+IO_EXT");
 703 #endif
 704
 705         seqcount = ap->a_ioflag >> IO_SEQSHIFT;
 706         ip = VTOI(vp);
 707
 708 #ifdef INVARIANTS
 709         if (uio->uio_rw != UIO_WRITE)
 710                 panic("ffs_write: mode");
 711 #endif
 712
 713         switch (vp->v_type) {
 714         case VREG:
 715                 if (ioflag & IO_APPEND)
 716                         uio->uio_offset = ip->i_size;
 717                 if ((ip->i_flags & APPEND) && uio->uio_offset != ip->i_size)
 718                         return (EPERM);
 719                 /* FALLTHROUGH */
 720         case VLNK:
 721                 break;
 722         case VDIR:
 723                 panic("ffs_write: dir write");
 724                 break;
 725         default:
 726                 panic("ffs_write: type %p %d (%d,%d)", vp, (int)vp->v_type,
 727                         (int)uio->uio_offset,
 728                         (int)uio->uio_resid
 729                 );
 730         }
 731
 732         KASSERT(uio->uio_resid >= 0, ("ffs_write: uio->uio_resid < 0"));
 733         KASSERT(uio->uio_offset >= 0, ("ffs_write: uio->uio_offset < 0"));
 734         fs = ITOFS(ip);
 735         if ((uoff_t)uio->uio_offset + uio->uio_resid > fs->fs_maxfilesize)
 736                 return (EFBIG);
 737         /*
 738          * Maybe this should be above the vnode op call, but so long as
 739          * file servers have no limits, I don't think it matters.
 740          */
 741         if (vn_rlimit_fsize(vp, uio, uio->uio_td))
 742                 return (EFBIG);
 743
 744         resid = uio->uio_resid;
 745         osize = ip->i_size;
 746         if (seqcount > BA_SEQMAX)
 747                 flags = BA_SEQMAX << BA_SEQSHIFT;
 748         else
 749                 flags = seqcount << BA_SEQSHIFT;
 750         if (ioflag & IO_SYNC)
 751                 flags |= IO_SYNC;
 752         flags |= BA_UNMAPPED;
 753
 754         for (error = 0; uio->uio_resid > 0;) {
 755                 lbn = lblkno(fs, uio->uio_offset);
 756                 blkoffset = blkoff(fs, uio->uio_offset);
 757                 xfersize = fs->fs_bsize - blkoffset;
 758                 if (uio->uio_resid < xfersize)
 759                         xfersize = uio->uio_resid;
 760                 if (uio->uio_offset + xfersize > ip->i_size)
 761                         vnode_pager_setsize(vp, uio->uio_offset + xfersize);
 762
 763                 /*
 764                  * We must perform a read-before-write if the transfer size
 765                  * does not cover the entire buffer.
 766                  */
 767                 if (fs->fs_bsize > xfersize)
 768                         flags |= BA_CLRBUF;
 769                 else
 770                         flags &= ~BA_CLRBUF;
 771 /* XXX is uio->uio_offset the right thing here? */
 772                 error = UFS_BALLOC(vp, uio->uio_offset, xfersize,
 773                     ap->a_cred, flags, &bp);
 774                 if (error != 0) {
 775                         vnode_pager_setsize(vp, ip->i_size);
 776                         break;
 777                 }
 778                 if ((ioflag & (IO_SYNC|IO_INVAL)) == (IO_SYNC|IO_INVAL))
 779                         bp->b_flags |= B_NOCACHE;
 780
 781                 if (uio->uio_offset + xfersize > ip->i_size) {
 782                         ip->i_size = uio->uio_offset + xfersize;
 783                         DIP_SET(ip, i_size, ip->i_size);
 784                 }
 785
 786                 size = blksize(fs, ip, lbn) - bp->b_resid;
 787                 if (size < xfersize)
 788                         xfersize = size;
 789
 790                 if (buf_mapped(bp)) {
 791                         error = vn_io_fault_uiomove((char *)bp->b_data +
 792                             blkoffset, (int)xfersize, uio);
 793                 } else {
 794                         error = vn_io_fault_pgmove(bp->b_pages, blkoffset,
 795                             (int)xfersize, uio);
 796                 }
 797                 /*
 798                  * If the buffer is not already filled and we encounter an
 799                  * error while trying to fill it, we have to clear out any
 800                  * garbage data from the pages instantiated for the buffer.
 801                  * If we do not, a failed uiomove() during a write can leave
 802                  * the prior contents of the pages exposed to a userland mmap.
 803                  *
 804                  * Note that we need only clear buffers with a transfer size
 805                  * equal to the block size because buffers with a shorter
 806                  * transfer size were cleared above by the call to UFS_BALLOC()
 807                  * with the BA_CLRBUF flag set.
 808                  *
 809                  * If the source region for uiomove identically mmaps the
 810                  * buffer, uiomove() performed the NOP copy, and the buffer
 811                  * content remains valid because the page fault handler
 812                  * validated the pages.
 813                  */
 814                 if (error != 0 && (bp->b_flags & B_CACHE) == 0 &&
 815                     fs->fs_bsize == xfersize)
 816                         vfs_bio_clrbuf(bp);
 817
 818                 vfs_bio_set_flags(bp, ioflag);
 819
 820                 /*
 821                  * If IO_SYNC each buffer is written synchronously.  Otherwise
 822                  * if we have a severe page deficiency write the buffer
 823                  * asynchronously.  Otherwise try to cluster, and if that
 824                  * doesn't do it then either do an async write (if O_DIRECT),
 825                  * or a delayed write (if not).
 826                  */
 827                 if (ioflag & IO_SYNC) {
 828                         (void)bwrite(bp);
 829                 } else if (vm_page_count_severe() ||
 830                             buf_dirty_count_severe() ||
 831                             (ioflag & IO_ASYNC)) {
 832                         bp->b_flags |= B_CLUSTEROK;
 833                         bawrite(bp);
 834                 } else if (xfersize + blkoffset == fs->fs_bsize) {
 835                         if ((vp->v_mount->mnt_flag & MNT_NOCLUSTERW) == 0) {
 836                                 bp->b_flags |= B_CLUSTEROK;
 837                                 cluster_write(vp, bp, ip->i_size, seqcount,
 838                                     GB_UNMAPPED);
 839                         } else {
 840                                 bawrite(bp);
 841                         }
 842                 } else if (ioflag & IO_DIRECT) {
 843                         bp->b_flags |= B_CLUSTEROK;
 844                         bawrite(bp);
 845                 } else {
 846                         bp->b_flags |= B_CLUSTEROK;
 847                         bdwrite(bp);
 848                 }
 849                 if (error || xfersize == 0)
 850                         break;
 851                 ip->i_flag |= IN_CHANGE | IN_UPDATE;
 852         }
 853         /*
 854          * If we successfully wrote any data, and we are not the superuser
 855          * we clear the setuid and setgid bits as a precaution against
 856          * tampering.
 857          */
 858         if ((ip->i_mode & (ISUID | ISGID)) && resid > uio->uio_resid &&
 859             ap->a_cred) {
 860                 if (priv_check_cred(ap->a_cred, PRIV_VFS_RETAINSUGID, 0)) {
 861                         ip->i_mode &= ~(ISUID | ISGID);
 862                         DIP_SET(ip, i_mode, ip->i_mode);
 863                 }
 864         }
 865         if (error) {
 866                 if (ioflag & IO_UNIT) {
 867                         (void)ffs_truncate(vp, osize,
 868                             IO_NORMAL | (ioflag & IO_SYNC), ap->a_cred);
 869                         uio->uio_offset -= resid - uio->uio_resid;
 870                         uio->uio_resid = resid;
 871                 }
 872         } else if (resid > uio->uio_resid && (ioflag & IO_SYNC))
 873                 error = ffs_update(vp, 1);
 874         return (error);
 875 }
 876
 877 /*
 878  * Extended attribute area reading.
 879  */
 880 static int
 881 ffs_extread(struct vnode *vp, struct uio *uio, int ioflag)
 882 {
 883         struct inode *ip;
 884         struct ufs2_dinode *dp;
 885         struct fs *fs;
 886         struct buf *bp;
 887         ufs_lbn_t lbn, nextlbn;
 888         off_t bytesinfile;
 889         long size, xfersize, blkoffset;
 890         ssize_t orig_resid;
 891         int error;
 892
 893         ip = VTOI(vp);
 894         fs = ITOFS(ip);
 895         dp = ip->i_din2;
 896
 897 #ifdef INVARIANTS
 898         if (uio->uio_rw != UIO_READ || fs->fs_magic != FS_UFS2_MAGIC)
 899                 panic("ffs_extread: mode");
 900
 901 #endif
 902         orig_resid = uio->uio_resid;
 903         KASSERT(orig_resid >= 0, ("ffs_extread: uio->uio_resid < 0"));
 904         if (orig_resid == 0)
 905                 return (0);
 906         KASSERT(uio->uio_offset >= 0, ("ffs_extread: uio->uio_offset < 0"));
 907
 908         for (error = 0, bp = NULL; uio->uio_resid > 0; bp = NULL) {
 909                 if ((bytesinfile = dp->di_extsize - uio->uio_offset) <= 0)
 910                         break;
 911                 lbn = lblkno(fs, uio->uio_offset);
 912                 nextlbn = lbn + 1;
 913
 914                 /*
 915                  * size of buffer.  The buffer representing the
 916                  * end of the file is rounded up to the size of
 917                  * the block type ( fragment or full block,
 918                  * depending ).
 919                  */
 920                 size = sblksize(fs, dp->di_extsize, lbn);
 921                 blkoffset = blkoff(fs, uio->uio_offset);
 922
 923                 /*
 924                  * The amount we want to transfer in this iteration is
 925                  * one FS block less the amount of the data before
 926                  * our startpoint (duh!)
 927                  */
 928                 xfersize = fs->fs_bsize - blkoffset;
 929
 930                 /*
 931                  * But if we actually want less than the block,
 932                  * or the file doesn't have a whole block more of data,
 933                  * then use the lesser number.
 934                  */
 935                 if (uio->uio_resid < xfersize)
 936                         xfersize = uio->uio_resid;
 937                 if (bytesinfile < xfersize)
 938                         xfersize = bytesinfile;
 939
 940                 if (lblktosize(fs, nextlbn) >= dp->di_extsize) {
 941                         /*
 942                          * Don't do readahead if this is the end of the info.
 943                          */
 944                         error = bread(vp, -1 - lbn, size, NOCRED, &bp);
 945                 } else {
 946                         /*
 947                          * If we have a second block, then
 948                          * fire off a request for a readahead
 949                          * as well as a read. Note that the 4th and 5th
 950                          * arguments point to arrays of the size specified in
 951                          * the 6th argument.
 952                          */
 953                         u_int nextsize = sblksize(fs, dp->di_extsize, nextlbn);
 954
 955                         nextlbn = -1 - nextlbn;
 956                         error = breadn(vp, -1 - lbn,
 957                             size, &nextlbn, &nextsize, 1, NOCRED, &bp);
 958                 }
 959                 if (error) {
 960                         brelse(bp);
 961                         bp = NULL;
 962                         break;
 963                 }
 964
 965                 /*
 966                  * We should only get non-zero b_resid when an I/O error
 967                  * has occurred, which should cause us to break above.
 968                  * However, if the short read did not cause an error,
 969                  * then we want to ensure that we do not uiomove bad
 970                  * or uninitialized data.
 971                  */
 972                 size -= bp->b_resid;
 973                 if (size < xfersize) {
 974                         if (size == 0)
 975                                 break;
 976                         xfersize = size;
 977                 }
 978
 979                 error = uiomove((char *)bp->b_data + blkoffset,
 980                                         (int)xfersize, uio);
 981                 if (error)
 982                         break;
 983                 vfs_bio_brelse(bp, ioflag);
 984         }
 985
 986         /*
 987          * This can only happen in the case of an error
 988          * because the loop above resets bp to NULL on each iteration
 989          * and on normal completion has not set a new value into it.
 990          * so it must have come from a 'break' statement
 991          */
 992         if (bp != NULL)
 993                 vfs_bio_brelse(bp, ioflag);
 994         return (error);
 995 }
 996
 997 /*
 998  * Extended attribute area writing.
 999  */
1000 static int
1001 ffs_extwrite(struct vnode *vp, struct uio *uio, int ioflag, struct ucred *ucred)
1002 {
1003         struct inode *ip;
1004         struct ufs2_dinode *dp;
1005         struct fs *fs;
1006         struct buf *bp;
1007         ufs_lbn_t lbn;
1008         off_t osize;
1009         ssize_t resid;
1010         int blkoffset, error, flags, size, xfersize;
1011
1012         ip = VTOI(vp);
1013         fs = ITOFS(ip);
1014         dp = ip->i_din2;
1015
1016 #ifdef INVARIANTS
1017         if (uio->uio_rw != UIO_WRITE || fs->fs_magic != FS_UFS2_MAGIC)
1018                 panic("ffs_extwrite: mode");
1019 #endif
1020
1021         if (ioflag & IO_APPEND)
1022                 uio->uio_offset = dp->di_extsize;
1023         KASSERT(uio->uio_offset >= 0, ("ffs_extwrite: uio->uio_offset < 0"));
1024         KASSERT(uio->uio_resid >= 0, ("ffs_extwrite: uio->uio_resid < 0"));
1025         if ((uoff_t)uio->uio_offset + uio->uio_resid >
1026             UFS_NXADDR * fs->fs_bsize)
1027                 return (EFBIG);
1028
1029         resid = uio->uio_resid;
1030         osize = dp->di_extsize;
1031         flags = IO_EXT;
1032         if (ioflag & IO_SYNC)
1033                 flags |= IO_SYNC;
1034
1035         for (error = 0; uio->uio_resid > 0;) {
1036                 lbn = lblkno(fs, uio->uio_offset);
1037                 blkoffset = blkoff(fs, uio->uio_offset);
1038                 xfersize = fs->fs_bsize - blkoffset;
1039                 if (uio->uio_resid < xfersize)
1040                         xfersize = uio->uio_resid;
1041
1042                 /*
1043                  * We must perform a read-before-write if the transfer size
1044                  * does not cover the entire buffer.
1045                  */
1046                 if (fs->fs_bsize > xfersize)
1047                         flags |= BA_CLRBUF;
1048                 else
1049                         flags &= ~BA_CLRBUF;
1050                 error = UFS_BALLOC(vp, uio->uio_offset, xfersize,
1051                     ucred, flags, &bp);
1052                 if (error != 0)
1053                         break;
1054                 /*
1055                  * If the buffer is not valid we have to clear out any
1056                  * garbage data from the pages instantiated for the buffer.
1057                  * If we do not, a failed uiomove() during a write can leave
1058                  * the prior contents of the pages exposed to a userland
1059                  * mmap().  XXX deal with uiomove() errors a better way.
1060                  */
1061                 if ((bp->b_flags & B_CACHE) == 0 && fs->fs_bsize <= xfersize)
1062                         vfs_bio_clrbuf(bp);
1063
1064                 if (uio->uio_offset + xfersize > dp->di_extsize)
1065                         dp->di_extsize = uio->uio_offset + xfersize;
1066
1067                 size = sblksize(fs, dp->di_extsize, lbn) - bp->b_resid;
1068                 if (size < xfersize)
1069                         xfersize = size;
1070
1071                 error =
1072                     uiomove((char *)bp->b_data + blkoffset, (int)xfersize, uio);
1073
1074                 vfs_bio_set_flags(bp, ioflag);
1075
1076                 /*
1077                  * If IO_SYNC each buffer is written synchronously.  Otherwise
1078                  * if we have a severe page deficiency write the buffer
1079                  * asynchronously.  Otherwise try to cluster, and if that
1080                  * doesn't do it then either do an async write (if O_DIRECT),
1081                  * or a delayed write (if not).
1082                  */
1083                 if (ioflag & IO_SYNC) {
1084                         (void)bwrite(bp);
1085                 } else if (vm_page_count_severe() ||
1086                             buf_dirty_count_severe() ||
1087                             xfersize + blkoffset == fs->fs_bsize ||
1088                             (ioflag & (IO_ASYNC | IO_DIRECT)))
1089                         bawrite(bp);
1090                 else
1091                         bdwrite(bp);
1092                 if (error || xfersize == 0)
1093                         break;
1094                 ip->i_flag |= IN_CHANGE;
1095         }
1096         /*
1097          * If we successfully wrote any data, and we are not the superuser
1098          * we clear the setuid and setgid bits as a precaution against
1099          * tampering.
1100          */
1101         if ((ip->i_mode & (ISUID | ISGID)) && resid > uio->uio_resid && ucred) {
1102                 if (priv_check_cred(ucred, PRIV_VFS_RETAINSUGID, 0)) {
1103                         ip->i_mode &= ~(ISUID | ISGID);
1104                         dp->di_mode = ip->i_mode;
1105                 }
1106         }
1107         if (error) {
1108                 if (ioflag & IO_UNIT) {
1109                         (void)ffs_truncate(vp, osize,
1110                             IO_EXT | (ioflag&IO_SYNC), ucred);
1111                         uio->uio_offset -= resid - uio->uio_resid;
1112                         uio->uio_resid = resid;
1113                 }
1114         } else if (resid > uio->uio_resid && (ioflag & IO_SYNC))
1115                 error = ffs_update(vp, 1);
1116         return (error);
1117 }
1118
1119
1120 /*
1121  * Vnode operating to retrieve a named extended attribute.
1122  *
1123  * Locate a particular EA (nspace:name) in the area (ptr:length), and return
1124  * the length of the EA, and possibly the pointer to the entry and to the data.
1125  */
1126 static int
1127 ffs_findextattr(u_char *ptr, u_int length, int nspace, const char *name,
1128     struct extattr **eapp, u_char **eac)
1129 {
1130         struct extattr *eap, *eaend;
1131         size_t nlen;
1132
1133         nlen = strlen(name);
1134         KASSERT(ALIGNED_TO(ptr, struct extattr), ("unaligned"));
1135         eap = (struct extattr *)ptr;
1136         eaend = (struct extattr *)(ptr + length);
1137         for (; eap < eaend; eap = EXTATTR_NEXT(eap)) {
1138                 /* make sure this entry is complete */
1139                 if (EXTATTR_NEXT(eap) > eaend)
1140                         break;
1141                 if (eap->ea_namespace != nspace || eap->ea_namelength != nlen
1142                     || memcmp(eap->ea_name, name, nlen) != 0)
1143                         continue;
1144                 if (eapp != NULL)
1145                         *eapp = eap;
1146                 if (eac != NULL)
1147                         *eac = EXTATTR_CONTENT(eap);
1148                 return (EXTATTR_CONTENT_SIZE(eap));
1149         }
1150         return (-1);
1151 }
1152
1153 static int
1154 ffs_rdextattr(u_char **p, struct vnode *vp, struct thread *td, int extra)
1155 {
1156         struct inode *ip;
1157         struct ufs2_dinode *dp;
1158         struct fs *fs;
1159         struct uio luio;
1160         struct iovec liovec;
1161         u_int easize;
1162         int error;
1163         u_char *eae;
1164
1165         ip = VTOI(vp);
1166         fs = ITOFS(ip);
1167         dp = ip->i_din2;
1168         easize = dp->di_extsize;
1169         if ((uoff_t)easize + extra > UFS_NXADDR * fs->fs_bsize)
1170                 return (EFBIG);
1171
1172         eae = malloc(easize + extra, M_TEMP, M_WAITOK);
1173
1174         liovec.iov_base = eae;
1175         liovec.iov_len = easize;
1176         luio.uio_iov = &liovec;
1177         luio.uio_iovcnt = 1;
1178         luio.uio_offset = 0;
1179         luio.uio_resid = easize;
1180         luio.uio_segflg = UIO_SYSSPACE;
1181         luio.uio_rw = UIO_READ;
1182         luio.uio_td = td;
1183
1184         error = ffs_extread(vp, &luio, IO_EXT | IO_SYNC);
1185         if (error) {
1186                 free(eae, M_TEMP);
1187                 return(error);
1188         }
1189         *p = eae;
1190         return (0);
1191 }
1192
1193 static void
1194 ffs_lock_ea(struct vnode *vp)
1195 {
1196         struct inode *ip;
1197
1198         ip = VTOI(vp);
1199         VI_LOCK(vp);
1200         while (ip->i_flag & IN_EA_LOCKED) {
1201                 ip->i_flag |= IN_EA_LOCKWAIT;
1202                 msleep(&ip->i_ea_refs, &vp->v_interlock, PINOD + 2, "ufs_ea",
1203                     0);
1204         }
1205         ip->i_flag |= IN_EA_LOCKED;
1206         VI_UNLOCK(vp);
1207 }
1208
1209 static void
1210 ffs_unlock_ea(struct vnode *vp)
1211 {
1212         struct inode *ip;
1213
1214         ip = VTOI(vp);
1215         VI_LOCK(vp);
1216         if (ip->i_flag & IN_EA_LOCKWAIT)
1217                 wakeup(&ip->i_ea_refs);
1218         ip->i_flag &= ~(IN_EA_LOCKED | IN_EA_LOCKWAIT);
1219         VI_UNLOCK(vp);
1220 }
1221
1222 static int
1223 ffs_open_ea(struct vnode *vp, struct ucred *cred, struct thread *td)
1224 {
1225         struct inode *ip;
1226         struct ufs2_dinode *dp;
1227         int error;
1228
1229         ip = VTOI(vp);
1230
1231         ffs_lock_ea(vp);
1232         if (ip->i_ea_area != NULL) {
1233                 ip->i_ea_refs++;
1234                 ffs_unlock_ea(vp);
1235                 return (0);
1236         }
1237         dp = ip->i_din2;
1238         error = ffs_rdextattr(&ip->i_ea_area, vp, td, 0);
1239         if (error) {
1240                 ffs_unlock_ea(vp);
1241                 return (error);
1242         }
1243         ip->i_ea_len = dp->di_extsize;
1244         ip->i_ea_error = 0;
1245         ip->i_ea_refs++;
1246         ffs_unlock_ea(vp);
1247         return (0);
1248 }
1249
1250 /*
1251  * Vnode extattr transaction commit/abort
1252  */
1253 static int
1254 ffs_close_ea(struct vnode *vp, int commit, struct ucred *cred, struct thread *td)
1255 {
1256         struct inode *ip;
1257         struct uio luio;
1258         struct iovec liovec;
1259         int error;
1260         struct ufs2_dinode *dp;
1261
1262         ip = VTOI(vp);
1263
1264         ffs_lock_ea(vp);
1265         if (ip->i_ea_area == NULL) {
1266                 ffs_unlock_ea(vp);
1267                 return (EINVAL);
1268         }
1269         dp = ip->i_din2;
1270         error = ip->i_ea_error;
1271         if (commit && error == 0) {
1272                 ASSERT_VOP_ELOCKED(vp, "ffs_close_ea commit");
1273                 if (cred == NOCRED)
1274                         cred =  vp->v_mount->mnt_cred;
1275                 liovec.iov_base = ip->i_ea_area;
1276                 liovec.iov_len = ip->i_ea_len;
1277                 luio.uio_iov = &liovec;
1278                 luio.uio_iovcnt = 1;
1279                 luio.uio_offset = 0;
1280                 luio.uio_resid = ip->i_ea_len;
1281                 luio.uio_segflg = UIO_SYSSPACE;
1282                 luio.uio_rw = UIO_WRITE;
1283                 luio.uio_td = td;
1284                 /* XXX: I'm not happy about truncating to zero size */
1285                 if (ip->i_ea_len < dp->di_extsize)
1286                         error = ffs_truncate(vp, 0, IO_EXT, cred);
1287                 error = ffs_extwrite(vp, &luio, IO_EXT | IO_SYNC, cred);
1288         }
1289         if (--ip->i_ea_refs == 0) {
1290                 free(ip->i_ea_area, M_TEMP);
1291                 ip->i_ea_area = NULL;
1292                 ip->i_ea_len = 0;
1293                 ip->i_ea_error = 0;
1294         }
1295         ffs_unlock_ea(vp);
1296         return (error);
1297 }
1298
1299 /*
1300  * Vnode extattr strategy routine for fifos.
1301  *
1302  * We need to check for a read or write of the external attributes.
1303  * Otherwise we just fall through and do the usual thing.
1304  */
1305 static int
1306 ffsext_strategy(struct vop_strategy_args *ap)
1307 /*
1308 struct vop_strategy_args {
1309         struct vnodeop_desc *a_desc;
1310         struct vnode *a_vp;
1311         struct buf *a_bp;
1312 };
1313 */
1314 {
1315         struct vnode *vp;
1316         daddr_t lbn;
1317
1318         vp = ap->a_vp;
1319         lbn = ap->a_bp->b_lblkno;
1320         if (I_IS_UFS2(VTOI(vp)) && lbn < 0 && lbn >= -UFS_NXADDR)
1321                 return (VOP_STRATEGY_APV(&ufs_vnodeops, ap));
1322         if (vp->v_type == VFIFO)
1323                 return (VOP_STRATEGY_APV(&ufs_fifoops, ap));
1324         panic("spec nodes went here");
1325 }
1326
1327 /*
1328  * Vnode extattr transaction commit/abort
1329  */
1330 static int
1331 ffs_openextattr(struct vop_openextattr_args *ap)
1332 /*
1333 struct vop_openextattr_args {
1334         struct vnodeop_desc *a_desc;
1335         struct vnode *a_vp;
1336         IN struct ucred *a_cred;
1337         IN struct thread *a_td;
1338 };
1339 */
1340 {
1341
1342         if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK)
1343                 return (EOPNOTSUPP);
1344
1345         return (ffs_open_ea(ap->a_vp, ap->a_cred, ap->a_td));
1346 }
1347
1348
1349 /*
1350  * Vnode extattr transaction commit/abort
1351  */
1352 static int
1353 ffs_closeextattr(struct vop_closeextattr_args *ap)
1354 /*
1355 struct vop_closeextattr_args {
1356         struct vnodeop_desc *a_desc;
1357         struct vnode *a_vp;
1358         int a_commit;
1359         IN struct ucred *a_cred;
1360         IN struct thread *a_td;
1361 };
1362 */
1363 {
1364
1365         if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK)
1366                 return (EOPNOTSUPP);
1367
1368         if (ap->a_commit && (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY))
1369                 return (EROFS);
1370
1371         return (ffs_close_ea(ap->a_vp, ap->a_commit, ap->a_cred, ap->a_td));
1372 }
1373
1374 /*
1375  * Vnode operation to remove a named attribute.
1376  */
1377 static int
1378 ffs_deleteextattr(struct vop_deleteextattr_args *ap)
1379 /*
1380 vop_deleteextattr {
1381         IN struct vnode *a_vp;
1382         IN int a_attrnamespace;
1383         IN const char *a_name;
1384         IN struct ucred *a_cred;
1385         IN struct thread *a_td;
1386 };
1387 */
1388 {
1389         struct inode *ip;
1390         struct extattr *eap;
1391         uint32_t ul;
1392         int olen, error, i, easize;
1393         u_char *eae;
1394         void *tmp;
1395
1396         ip = VTOI(ap->a_vp);
1397
1398         if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK)
1399                 return (EOPNOTSUPP);
1400
1401         if (strlen(ap->a_name) == 0)
1402                 return (EINVAL);
1403
1404         if (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY)
1405                 return (EROFS);
1406
1407         error = extattr_check_cred(ap->a_vp, ap->a_attrnamespace,
1408             ap->a_cred, ap->a_td, VWRITE);
1409         if (error) {
1410
1411                 /*
1412                  * ffs_lock_ea is not needed there, because the vnode
1413                  * must be exclusively locked.
1414                  */
1415                 if (ip->i_ea_area != NULL && ip->i_ea_error == 0)
1416                         ip->i_ea_error = error;
1417                 return (error);
1418         }
1419
1420         error = ffs_open_ea(ap->a_vp, ap->a_cred, ap->a_td);
1421         if (error)
1422                 return (error);
1423
1424         /* CEM: delete could be done in-place instead */
1425         eae = malloc(ip->i_ea_len, M_TEMP, M_WAITOK);
1426         bcopy(ip->i_ea_area, eae, ip->i_ea_len);
1427         easize = ip->i_ea_len;
1428
1429         olen = ffs_findextattr(eae, easize, ap->a_attrnamespace, ap->a_name,
1430             &eap, NULL);
1431         if (olen == -1) {
1432                 /* delete but nonexistent */
1433                 free(eae, M_TEMP);
1434                 ffs_close_ea(ap->a_vp, 0, ap->a_cred, ap->a_td);
1435                 return (ENOATTR);
1436         }
1437         ul = eap->ea_length;
1438         i = (u_char *)EXTATTR_NEXT(eap) - eae;
1439         bcopy(EXTATTR_NEXT(eap), eap, easize - i);
1440         easize -= ul;
1441
1442         tmp = ip->i_ea_area;
1443         ip->i_ea_area = eae;
1444         ip->i_ea_len = easize;
1445         free(tmp, M_TEMP);
1446         error = ffs_close_ea(ap->a_vp, 1, ap->a_cred, ap->a_td);
1447         return (error);
1448 }
1449
1450 /*
1451  * Vnode operation to retrieve a named extended attribute.
1452  */
1453 static int
1454 ffs_getextattr(struct vop_getextattr_args *ap)
1455 /*
1456 vop_getextattr {
1457         IN struct vnode *a_vp;
1458         IN int a_attrnamespace;
1459         IN const char *a_name;
1460         INOUT struct uio *a_uio;
1461         OUT size_t *a_size;
1462         IN struct ucred *a_cred;
1463         IN struct thread *a_td;
1464 };
1465 */
1466 {
1467         struct inode *ip;
1468         u_char *eae, *p;
1469         unsigned easize;
1470         int error, ealen;
1471
1472         ip = VTOI(ap->a_vp);
1473
1474         if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK)
1475                 return (EOPNOTSUPP);
1476
1477         error = extattr_check_cred(ap->a_vp, ap->a_attrnamespace,
1478             ap->a_cred, ap->a_td, VREAD);
1479         if (error)
1480                 return (error);
1481
1482         error = ffs_open_ea(ap->a_vp, ap->a_cred, ap->a_td);
1483         if (error)
1484                 return (error);
1485
1486         eae = ip->i_ea_area;
1487         easize = ip->i_ea_len;
1488
1489         ealen = ffs_findextattr(eae, easize, ap->a_attrnamespace, ap->a_name,
1490             NULL, &p);
1491         if (ealen >= 0) {
1492                 error = 0;
1493                 if (ap->a_size != NULL)
1494                         *ap->a_size = ealen;
1495                 else if (ap->a_uio != NULL)
1496                         error = uiomove(p, ealen, ap->a_uio);
1497         } else
1498                 error = ENOATTR;
1499
1500         ffs_close_ea(ap->a_vp, 0, ap->a_cred, ap->a_td);
1501         return (error);
1502 }
1503
1504 /*
1505  * Vnode operation to retrieve extended attributes on a vnode.
1506  */
1507 static int
1508 ffs_listextattr(struct vop_listextattr_args *ap)
1509 /*
1510 vop_listextattr {
1511         IN struct vnode *a_vp;
1512         IN int a_attrnamespace;
1513         INOUT struct uio *a_uio;
1514         OUT size_t *a_size;
1515         IN struct ucred *a_cred;
1516         IN struct thread *a_td;
1517 };
1518 */
1519 {
1520         struct inode *ip;
1521         struct extattr *eap, *eaend;
1522         int error, ealen;
1523
1524         ip = VTOI(ap->a_vp);
1525
1526         if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK)
1527                 return (EOPNOTSUPP);
1528
1529         error = extattr_check_cred(ap->a_vp, ap->a_attrnamespace,
1530             ap->a_cred, ap->a_td, VREAD);
1531         if (error)
1532                 return (error);
1533
1534         error = ffs_open_ea(ap->a_vp, ap->a_cred, ap->a_td);
1535         if (error)
1536                 return (error);
1537
1538         error = 0;
1539         if (ap->a_size != NULL)
1540                 *ap->a_size = 0;
1541
1542         KASSERT(ALIGNED_TO(ip->i_ea_area, struct extattr), ("unaligned"));
1543         eap = (struct extattr *)ip->i_ea_area;
1544         eaend = (struct extattr *)(ip->i_ea_area + ip->i_ea_len);
1545         for (; error == 0 && eap < eaend; eap = EXTATTR_NEXT(eap)) {
1546                 /* make sure this entry is complete */
1547                 if (EXTATTR_NEXT(eap) > eaend)
1548                         break;
1549                 if (eap->ea_namespace != ap->a_attrnamespace)
1550                         continue;
1551
1552                 ealen = eap->ea_namelength;
1553                 if (ap->a_size != NULL)
1554                         *ap->a_size += ealen + 1;
1555                 else if (ap->a_uio != NULL)
1556                         error = uiomove(&eap->ea_namelength, ealen + 1,
1557                             ap->a_uio);
1558         }
1559
1560         ffs_close_ea(ap->a_vp, 0, ap->a_cred, ap->a_td);
1561         return (error);
1562 }
1563
1564 /*
1565  * Vnode operation to set a named attribute.
1566  */
1567 static int
1568 ffs_setextattr(struct vop_setextattr_args *ap)
1569 /*
1570 vop_setextattr {
1571         IN struct vnode *a_vp;
1572         IN int a_attrnamespace;
1573         IN const char *a_name;
1574         INOUT struct uio *a_uio;
1575         IN struct ucred *a_cred;
1576         IN struct thread *a_td;
1577 };
1578 */
1579 {
1580         struct inode *ip;
1581         struct fs *fs;
1582         struct extattr *eap;
1583         uint32_t ealength, ul;
1584         ssize_t ealen;
1585         int olen, eapad1, eapad2, error, i, easize;
1586         u_char *eae;
1587         void *tmp;
1588
1589         ip = VTOI(ap->a_vp);
1590         fs = ITOFS(ip);
1591
1592         if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK)
1593                 return (EOPNOTSUPP);
1594
1595         if (strlen(ap->a_name) == 0)
1596                 return (EINVAL);
1597
1598         /* XXX Now unsupported API to delete EAs using NULL uio. */
1599         if (ap->a_uio == NULL)
1600                 return (EOPNOTSUPP);
1601
1602         if (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY)
1603                 return (EROFS);
1604
1605         ealen = ap->a_uio->uio_resid;
1606         if (ealen < 0 || ealen > lblktosize(fs, UFS_NXADDR))
1607                 return (EINVAL);
1608
1609         error = extattr_check_cred(ap->a_vp, ap->a_attrnamespace,
1610             ap->a_cred, ap->a_td, VWRITE);
1611         if (error) {
1612
1613                 /*
1614                  * ffs_lock_ea is not needed there, because the vnode
1615                  * must be exclusively locked.
1616                  */
1617                 if (ip->i_ea_area != NULL && ip->i_ea_error == 0)
1618                         ip->i_ea_error = error;
1619                 return (error);
1620         }
1621
1622         error = ffs_open_ea(ap->a_vp, ap->a_cred, ap->a_td);
1623         if (error)
1624                 return (error);
1625
1626         ealength = sizeof(uint32_t) + 3 + strlen(ap->a_name);
1627         eapad1 = roundup2(ealength, 8) - ealength;
1628         eapad2 = roundup2(ealen, 8) - ealen;
1629         ealength += eapad1 + ealen + eapad2;
1630
1631         /*
1632          * CEM: rewrites of the same size or smaller could be done in-place
1633          * instead.  (We don't acquire any fine-grained locks in here either,
1634          * so we could also do bigger writes in-place.)
1635          */
1636         eae = malloc(ip->i_ea_len + ealength, M_TEMP, M_WAITOK);
1637         bcopy(ip->i_ea_area, eae, ip->i_ea_len);
1638         easize = ip->i_ea_len;
1639
1640         olen = ffs_findextattr(eae, easize, ap->a_attrnamespace, ap->a_name,
1641             &eap, NULL);
1642         if (olen == -1) {
1643                 /* new, append at end */
1644                 KASSERT(ALIGNED_TO(eae + easize, struct extattr),
1645                     ("unaligned"));
1646                 eap = (struct extattr *)(eae + easize);
1647                 easize += ealength;
1648         } else {
1649                 ul = eap->ea_length;
1650                 i = (u_char *)EXTATTR_NEXT(eap) - eae;
1651                 if (ul != ealength) {
1652                         bcopy(EXTATTR_NEXT(eap), (u_char *)eap + ealength,
1653                             easize - i);
1654                         easize += (ealength - ul);
1655                 }
1656         }
1657         if (easize > lblktosize(fs, UFS_NXADDR)) {
1658                 free(eae, M_TEMP);
1659                 ffs_close_ea(ap->a_vp, 0, ap->a_cred, ap->a_td);
1660                 if (ip->i_ea_area != NULL && ip->i_ea_error == 0)
1661                         ip->i_ea_error = ENOSPC;
1662                 return (ENOSPC);
1663         }
1664         eap->ea_length = ealength;
1665         eap->ea_namespace = ap->a_attrnamespace;
1666         eap->ea_contentpadlen = eapad2;
1667         eap->ea_namelength = strlen(ap->a_name);
1668         memcpy(eap->ea_name, ap->a_name, strlen(ap->a_name));
1669         bzero(&eap->ea_name[strlen(ap->a_name)], eapad1);
1670         error = uiomove(EXTATTR_CONTENT(eap), ealen, ap->a_uio);
1671         if (error) {
1672                 free(eae, M_TEMP);
1673                 ffs_close_ea(ap->a_vp, 0, ap->a_cred, ap->a_td);
1674                 if (ip->i_ea_area != NULL && ip->i_ea_error == 0)
1675                         ip->i_ea_error = error;
1676                 return (error);
1677         }
1678         bzero((u_char *)EXTATTR_CONTENT(eap) + ealen, eapad2);
1679
1680         tmp = ip->i_ea_area;
1681         ip->i_ea_area = eae;
1682         ip->i_ea_len = easize;
1683         free(tmp, M_TEMP);
1684         error = ffs_close_ea(ap->a_vp, 1, ap->a_cred, ap->a_td);
1685         return (error);
1686 }
1687
1688 /*
1689  * Vnode pointer to File handle
1690  */
1691 static int
1692 ffs_vptofh(struct vop_vptofh_args *ap)
1693 /*
1694 vop_vptofh {
1695         IN struct vnode *a_vp;
1696         IN struct fid *a_fhp;
1697 };
1698 */
1699 {
1700         struct inode *ip;
1701         struct ufid *ufhp;
1702
1703         ip = VTOI(ap->a_vp);
1704         ufhp = (struct ufid *)ap->a_fhp;
1705         ufhp->ufid_len = sizeof(struct ufid);
1706         ufhp->ufid_ino = ip->i_number;
1707         ufhp->ufid_gen = ip->i_gen;
1708         return (0);
1709 }
1710
1711 SYSCTL_DECL(_vfs_ffs);
1712 static int use_buf_pager = 1;
1713 SYSCTL_INT(_vfs_ffs, OID_AUTO, use_buf_pager, CTLFLAG_RWTUN, &use_buf_pager, 0,
1714     "Always use buffer pager instead of bmap");
1715
1716 static daddr_t
1717 ffs_gbp_getblkno(struct vnode *vp, vm_ooffset_t off)
1718 {
1719
1720         return (lblkno(VFSTOUFS(vp->v_mount)->um_fs, off));
1721 }
1722
1723 static int
1724 ffs_gbp_getblksz(struct vnode *vp, daddr_t lbn)
1725 {
1726
1727         return (blksize(VFSTOUFS(vp->v_mount)->um_fs, VTOI(vp), lbn));
1728 }
1729
1730 static int
1731 ffs_getpages(struct vop_getpages_args *ap)
1732 {
1733         struct vnode *vp;
1734         struct ufsmount *um;
1735
1736         vp = ap->a_vp;
1737         um = VFSTOUFS(vp->v_mount);
1738
1739         if (!use_buf_pager && um->um_devvp->v_bufobj.bo_bsize <= PAGE_SIZE)
1740                 return (vnode_pager_generic_getpages(vp, ap->a_m, ap->a_count,
1741                     ap->a_rbehind, ap->a_rahead, NULL, NULL));
1742         return (vfs_bio_getpages(vp, ap->a_m, ap->a_count, ap->a_rbehind,
1743             ap->a_rahead, ffs_gbp_getblkno, ffs_gbp_getblksz));
1744 }