sys/vfs/ufs/ffs_vfsops.c

   1 /*
   2  * Copyright (c) 1989, 1991, 1993, 1994
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by the University of
  16  *      California, Berkeley and its contributors.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  *
  33  *      @(#)ffs_vfsops.c        8.31 (Berkeley) 5/20/95
  34  * $FreeBSD: src/sys/ufs/ffs/ffs_vfsops.c,v 1.117.2.10 2002/06/23 22:34:52 iedowse Exp $
  35  * $DragonFly: src/sys/vfs/ufs/ffs_vfsops.c,v 1.5 2003/07/03 18:35:27 dillon Exp $
  36  */
  37
  38 #include "opt_quota.h"
  39
  40 #include <sys/param.h>
  41 #include <sys/systm.h>
  42 #include <sys/proc.h>
  43 #include <sys/namei.h>
  44 #include <sys/kernel.h>
  45 #include <sys/vnode.h>
  46 #include <sys/mount.h>
  47 #include <sys/buf.h>
  48 #include <sys/conf.h>
  49 #include <sys/fcntl.h>
  50 #include <sys/disklabel.h>
  51 #include <sys/malloc.h>
  52
  53 #include <ufs/ufs/quota.h>
  54 #include <ufs/ufs/ufsmount.h>
  55 #include <ufs/ufs/inode.h>
  56 #include <ufs/ufs/ufs_extern.h>
  57
  58 #include <ufs/ffs/fs.h>
  59 #include <ufs/ffs/ffs_extern.h>
  60
  61 #include <vm/vm.h>
  62 #include <vm/vm_page.h>
  63 #include <vm/vm_zone.h>
  64
  65 static MALLOC_DEFINE(M_FFSNODE, "FFS node", "FFS vnode private part");
  66
  67 static int      ffs_sbupdate __P((struct ufsmount *, int));
  68 static int      ffs_reload __P((struct mount *,struct ucred *,struct thread *));
  69 static int      ffs_oldfscompat __P((struct fs *));
  70 static int      ffs_mount __P((struct mount *, char *, caddr_t,
  71                                 struct nameidata *, struct thread *));
  72 static int      ffs_init __P((struct vfsconf *));
  73
  74 static struct vfsops ufs_vfsops = {
  75         ffs_mount,
  76         ufs_start,
  77         ffs_unmount,
  78         ufs_root,
  79         ufs_quotactl,
  80         ffs_statfs,
  81         ffs_sync,
  82         ffs_vget,
  83         ffs_fhtovp,
  84         ufs_check_export,
  85         ffs_vptofh,
  86         ffs_init,
  87         vfs_stduninit,
  88         vfs_stdextattrctl,
  89 };
  90
  91 VFS_SET(ufs_vfsops, ufs, 0);
  92
  93 /*
  94  * ffs_mount
  95  *
  96  * Called when mounting local physical media
  97  *
  98  * PARAMETERS:
  99  *              mountroot
 100  *                      mp      mount point structure
 101  *                      path    NULL (flag for root mount!!!)
 102  *                      data    <unused>
 103  *                      ndp     <unused>
 104  *                      p       process (user credentials check [statfs])
 105  *
 106  *              mount
 107  *                      mp      mount point structure
 108  *                      path    path to mount point
 109  *                      data    pointer to argument struct in user space
 110  *                      ndp     mount point namei() return (used for
 111  *                              credentials on reload), reused to look
 112  *                              up block device.
 113  *                      p       process (user credentials check)
 114  *
 115  * RETURNS:     0       Success
 116  *              !0      error number (errno.h)
 117  *
 118  * LOCK STATE:
 119  *
 120  *              ENTRY
 121  *                      mount point is locked
 122  *              EXIT
 123  *                      mount point is locked
 124  *
 125  * NOTES:
 126  *              A NULL path can be used for a flag since the mount
 127  *              system call will fail with EFAULT in copyinstr in
 128  *              namei() if it is a genuine NULL from the user.
 129  */
 130 static int
 131 ffs_mount( mp, path, data, ndp, td)
 132         struct mount            *mp;    /* mount struct pointer*/
 133         char                    *path;  /* path to mount point*/
 134         caddr_t                 data;   /* arguments to FS specific mount*/
 135         struct nameidata        *ndp;   /* mount point credentials*/
 136         struct thread           *td;    /* process requesting mount*/
 137 {
 138         size_t          size;
 139         int             err = 0;
 140         struct vnode    *devvp;
 141
 142         struct ufs_args args;
 143         struct ufsmount *ump = 0;
 144         register struct fs *fs;
 145         int error, flags, ronly = 0;
 146         mode_t accessmode;
 147         struct ucred *cred;
 148
 149         KKASSERT(td->td_proc);
 150         cred = td->td_proc->p_ucred;
 151
 152         /*
 153          * Use NULL path to flag a root mount
 154          */
 155         if( path == NULL) {
 156                 /*
 157                  ***
 158                  * Mounting root file system
 159                  ***
 160                  */
 161
 162                 if ((err = bdevvp(rootdev, &rootvp))) {
 163                         printf("ffs_mountroot: can't find rootvp\n");
 164                         return (err);
 165                 }
 166
 167                 if( ( err = ffs_mountfs(rootvp, mp, td, M_FFSNODE)) != 0) {
 168                         /* fs specific cleanup (if any)*/
 169                         goto error_1;
 170                 }
 171
 172                 goto dostatfs;          /* success*/
 173
 174         }
 175
 176         /*
 177          ***
 178          * Mounting non-root file system or updating a file system
 179          ***
 180          */
 181
 182         /* copy in user arguments*/
 183         err = copyin(data, (caddr_t)&args, sizeof (struct ufs_args));
 184         if (err)
 185                 goto error_1;           /* can't get arguments*/
 186
 187         /*
 188          * If updating, check whether changing from read-only to
 189          * read/write; if there is no device name, that's all we do.
 190          */
 191         if (mp->mnt_flag & MNT_UPDATE) {
 192                 ump = VFSTOUFS(mp);
 193                 fs = ump->um_fs;
 194                 devvp = ump->um_devvp;
 195                 err = 0;
 196                 ronly = fs->fs_ronly;   /* MNT_RELOAD might change this */
 197                 if (ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
 198                         /*
 199                          * Flush any dirty data.
 200                          */
 201                         VFS_SYNC(mp, MNT_WAIT, td);
 202                         /*
 203                          * Check for and optionally get rid of files open
 204                          * for writing.
 205                          */
 206                         flags = WRITECLOSE;
 207                         if (mp->mnt_flag & MNT_FORCE)
 208                                 flags |= FORCECLOSE;
 209                         if (mp->mnt_flag & MNT_SOFTDEP) {
 210                                 err = softdep_flushfiles(mp, flags, td);
 211                         } else {
 212                                 err = ffs_flushfiles(mp, flags, td);
 213                         }
 214                         ronly = 1;
 215                 }
 216                 if (!err && (mp->mnt_flag & MNT_RELOAD))
 217                         err = ffs_reload(mp, ndp->ni_cnd.cn_cred, td);
 218                 if (err) {
 219                         goto error_1;
 220                 }
 221                 if (ronly && (mp->mnt_kern_flag & MNTK_WANTRDWR)) {
 222                         /*
 223                          * If upgrade to read-write by non-root, then verify
 224                          * that user has necessary permissions on the device.
 225                          */
 226                         if (cred->cr_uid != 0) {
 227                                 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td);
 228                                 if ((error = VOP_ACCESS(devvp, VREAD | VWRITE,
 229                                     cred, td)) != 0) {
 230                                         VOP_UNLOCK(devvp, 0, td);
 231                                         return (error);
 232                                 }
 233                                 VOP_UNLOCK(devvp, 0, td);
 234                         }
 235
 236                         fs->fs_flags &= ~FS_UNCLEAN;
 237                         if (fs->fs_clean == 0) {
 238                                 fs->fs_flags |= FS_UNCLEAN;
 239                                 if (mp->mnt_flag & MNT_FORCE) {
 240                                         printf(
 241 "WARNING: %s was not properly dismounted\n",
 242                                             fs->fs_fsmnt);
 243                                 } else {
 244                                         printf(
 245 "WARNING: R/W mount of %s denied.  Filesystem is not clean - run fsck\n",
 246                                             fs->fs_fsmnt);
 247                                         err = EPERM;
 248                                         goto error_1;
 249                                 }
 250                         }
 251
 252                         /* check to see if we need to start softdep */
 253                         if (fs->fs_flags & FS_DOSOFTDEP) {
 254                                 err = softdep_mount(devvp, mp, fs);
 255                                 if (err)
 256                                         goto error_1;
 257                         }
 258
 259                         ronly = 0;
 260                 }
 261                 /*
 262                  * Soft updates is incompatible with "async",
 263                  * so if we are doing softupdates stop the user
 264                  * from setting the async flag in an update.
 265                  * Softdep_mount() clears it in an initial mount
 266                  * or ro->rw remount.
 267                  */
 268                 if (mp->mnt_flag & MNT_SOFTDEP) {
 269                         mp->mnt_flag &= ~MNT_ASYNC;
 270                 }
 271                 /* if not updating name...*/
 272                 if (args.fspec == 0) {
 273                         /*
 274                          * Process export requests.  Jumping to "success"
 275                          * will return the vfs_export() error code.
 276                          */
 277                         err = vfs_export(mp, &ump->um_export, &args.export);
 278                         goto success;
 279                 }
 280         }
 281
 282         /*
 283          * Not an update, or updating the name: look up the name
 284          * and verify that it refers to a sensible block device.
 285          */
 286         NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, td);
 287         err = namei(ndp);
 288         if (err) {
 289                 /* can't get devvp!*/
 290                 goto error_1;
 291         }
 292
 293         NDFREE(ndp, NDF_ONLY_PNBUF);
 294         devvp = ndp->ni_vp;
 295
 296         if (!vn_isdisk(devvp, &err))
 297                 goto error_2;
 298
 299         /*
 300          * If mount by non-root, then verify that user has necessary
 301          * permissions on the device.
 302          */
 303         if (cred->cr_uid != 0) {
 304                 accessmode = VREAD;
 305                 if ((mp->mnt_flag & MNT_RDONLY) == 0)
 306                         accessmode |= VWRITE;
 307                 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td);
 308                 if ((error = VOP_ACCESS(devvp, accessmode, cred, td)) != 0) {
 309                         vput(devvp);
 310                         return (error);
 311                 }
 312                 VOP_UNLOCK(devvp, 0, td);
 313         }
 314
 315         if (mp->mnt_flag & MNT_UPDATE) {
 316                 /*
 317                  ********************
 318                  * UPDATE
 319                  * If it's not the same vnode, or at least the same device
 320                  * then it's not correct.
 321                  ********************
 322                  */
 323
 324                 if (devvp != ump->um_devvp) {
 325                         if ( devvp->v_rdev == ump->um_devvp->v_rdev) {
 326                                 vrele(devvp);
 327                         } else {
 328                                 err = EINVAL;   /* needs translation */
 329                         }
 330                 } else
 331                         vrele(devvp);
 332                 /*
 333                  * Update device name only on success
 334                  */
 335                 if( !err) {
 336                         /* Save "mounted from" info for mount point (NULL pad)*/
 337                         copyinstr(      args.fspec,
 338                                         mp->mnt_stat.f_mntfromname,
 339                                         MNAMELEN - 1,
 340                                         &size);
 341                         bzero( mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
 342                 }
 343         } else {
 344                 /*
 345                  ********************
 346                  * NEW MOUNT
 347                  ********************
 348                  */
 349
 350                 /*
 351                  * Since this is a new mount, we want the names for
 352                  * the device and the mount point copied in.  If an
 353                  * error occurs,  the mountpoint is discarded by the
 354                  * upper level code.
 355                  */
 356                 /* Save "last mounted on" info for mount point (NULL pad)*/
 357                 copyinstr(      path,                           /* mount point*/
 358                                 mp->mnt_stat.f_mntonname,       /* save area*/
 359                                 MNAMELEN - 1,                   /* max size*/
 360                                 &size);                         /* real size*/
 361                 bzero( mp->mnt_stat.f_mntonname + size, MNAMELEN - size);
 362
 363                 /* Save "mounted from" info for mount point (NULL pad)*/
 364                 copyinstr(      args.fspec,                     /* device name*/
 365                                 mp->mnt_stat.f_mntfromname,     /* save area*/
 366                                 MNAMELEN - 1,                   /* max size*/
 367                                 &size);                         /* real size*/
 368                 bzero( mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
 369
 370                 err = ffs_mountfs(devvp, mp, td, M_FFSNODE);
 371         }
 372         if (err) {
 373                 goto error_2;
 374         }
 375
 376 dostatfs:
 377         /*
 378          * Initialize FS stat information in mount struct; uses both
 379          * mp->mnt_stat.f_mntonname and mp->mnt_stat.f_mntfromname
 380          *
 381          * This code is common to root and non-root mounts
 382          */
 383         (void)VFS_STATFS(mp, &mp->mnt_stat, td);
 384
 385         goto success;
 386
 387
 388 error_2:        /* error with devvp held*/
 389
 390         /* release devvp before failing*/
 391         vrele(devvp);
 392
 393 error_1:        /* no state to back out*/
 394
 395 success:
 396         if (!err && path && (mp->mnt_flag & MNT_UPDATE)) {
 397                 /* Update clean flag after changing read-onlyness. */
 398                 fs = ump->um_fs;
 399                 if (ronly != fs->fs_ronly) {
 400                         fs->fs_ronly = ronly;
 401                         fs->fs_clean = ronly &&
 402                             (fs->fs_flags & FS_UNCLEAN) == 0 ? 1 : 0;
 403                         ffs_sbupdate(ump, MNT_WAIT);
 404                 }
 405         }
 406         return (err);
 407 }
 408
 409 /*
 410  * Reload all incore data for a filesystem (used after running fsck on
 411  * the root filesystem and finding things to fix). The filesystem must
 412  * be mounted read-only.
 413  *
 414  * Things to do to update the mount:
 415  *      1) invalidate all cached meta-data.
 416  *      2) re-read superblock from disk.
 417  *      3) re-read summary information from disk.
 418  *      4) invalidate all inactive vnodes.
 419  *      5) invalidate all cached file data.
 420  *      6) re-read inode data for all active vnodes.
 421  */
 422 static int
 423 ffs_reload(struct mount *mp, struct ucred *cred, struct thread *td)
 424 {
 425         struct vnode *vp, *nvp, *devvp;
 426         struct inode *ip;
 427         void *space;
 428         struct buf *bp;
 429         struct fs *fs, *newfs;
 430         struct partinfo dpart;
 431         dev_t dev;
 432         int i, blks, size, error;
 433         int32_t *lp;
 434
 435         KKASSERT(td->td_proc && td->td_proc->p_ucred == cred);
 436
 437         if ((mp->mnt_flag & MNT_RDONLY) == 0)
 438                 return (EINVAL);
 439         /*
 440          * Step 1: invalidate all cached meta-data.
 441          */
 442         devvp = VFSTOUFS(mp)->um_devvp;
 443         vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td);
 444         error = vinvalbuf(devvp, 0, td, 0, 0);
 445         VOP_UNLOCK(devvp, 0, td);
 446         if (error)
 447                 panic("ffs_reload: dirty1");
 448
 449         dev = devvp->v_rdev;
 450
 451         /*
 452          * Only VMIO the backing device if the backing device is a real
 453          * block device.  See ffs_mountmfs() for more details.
 454          */
 455         if (devvp->v_tag != VT_MFS && vn_isdisk(devvp, NULL)) {
 456                 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td);
 457                 vfs_object_create(devvp, td);
 458                 simple_lock(&devvp->v_interlock);
 459                 VOP_UNLOCK(devvp, LK_INTERLOCK, td);
 460         }
 461
 462         /*
 463          * Step 2: re-read superblock from disk.
 464          */
 465         if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, NOCRED, td) != 0)
 466                 size = DEV_BSIZE;
 467         else
 468                 size = dpart.disklab->d_secsize;
 469         if ((error = bread(devvp, (ufs_daddr_t)(SBOFF/size), SBSIZE, &bp)) != 0)
 470                 return (error);
 471         newfs = (struct fs *)bp->b_data;
 472         if (newfs->fs_magic != FS_MAGIC || newfs->fs_bsize > MAXBSIZE ||
 473                 newfs->fs_bsize < sizeof(struct fs)) {
 474                         brelse(bp);
 475                         return (EIO);           /* XXX needs translation */
 476         }
 477         fs = VFSTOUFS(mp)->um_fs;
 478         /*
 479          * Copy pointer fields back into superblock before copying in   XXX
 480          * new superblock. These should really be in the ufsmount.      XXX
 481          * Note that important parameters (eg fs_ncg) are unchanged.
 482          */
 483         newfs->fs_csp = fs->fs_csp;
 484         newfs->fs_maxcluster = fs->fs_maxcluster;
 485         newfs->fs_contigdirs = fs->fs_contigdirs;
 486         bcopy(newfs, fs, (u_int)fs->fs_sbsize);
 487         if (fs->fs_sbsize < SBSIZE)
 488                 bp->b_flags |= B_INVAL;
 489         brelse(bp);
 490         mp->mnt_maxsymlinklen = fs->fs_maxsymlinklen;
 491         ffs_oldfscompat(fs);
 492         /* An old fsck may have zeroed these fields, so recheck them. */
 493         if (fs->fs_avgfilesize <= 0)            /* XXX */
 494                 fs->fs_avgfilesize = AVFILESIZ; /* XXX */
 495         if (fs->fs_avgfpdir <= 0)               /* XXX */
 496                 fs->fs_avgfpdir = AFPDIR;       /* XXX */
 497
 498         /*
 499          * Step 3: re-read summary information from disk.
 500          */
 501         blks = howmany(fs->fs_cssize, fs->fs_fsize);
 502         space = fs->fs_csp;
 503         for (i = 0; i < blks; i += fs->fs_frag) {
 504                 size = fs->fs_bsize;
 505                 if (i + fs->fs_frag > blks)
 506                         size = (blks - i) * fs->fs_fsize;
 507                 error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size, &bp);
 508                 if (error)
 509                         return (error);
 510                 bcopy(bp->b_data, space, (u_int)size);
 511                 space = (char *)space + size;
 512                 brelse(bp);
 513         }
 514         /*
 515          * We no longer know anything about clusters per cylinder group.
 516          */
 517         if (fs->fs_contigsumsize > 0) {
 518                 lp = fs->fs_maxcluster;
 519                 for (i = 0; i < fs->fs_ncg; i++)
 520                         *lp++ = fs->fs_contigsumsize;
 521         }
 522
 523 loop:
 524         simple_lock(&mntvnode_slock);
 525         for (vp = TAILQ_FIRST(&mp->mnt_nvnodelist); vp != NULL; vp = nvp) {
 526                 if (vp->v_mount != mp) {
 527                         simple_unlock(&mntvnode_slock);
 528                         goto loop;
 529                 }
 530                 nvp = TAILQ_NEXT(vp, v_nmntvnodes);
 531                 /*
 532                  * Step 4: invalidate all inactive vnodes.
 533                  */
 534                 if (vrecycle(vp, &mntvnode_slock, td))
 535                         goto loop;
 536                 /*
 537                  * Step 5: invalidate all cached file data.
 538                  */
 539                 simple_lock(&vp->v_interlock);
 540                 simple_unlock(&mntvnode_slock);
 541                 if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) {
 542                         goto loop;
 543                 }
 544                 if (vinvalbuf(vp, 0, td, 0, 0))
 545                         panic("ffs_reload: dirty2");
 546                 /*
 547                  * Step 6: re-read inode data for all active vnodes.
 548                  */
 549                 ip = VTOI(vp);
 550                 error =
 551                     bread(devvp, fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
 552                     (int)fs->fs_bsize, &bp);
 553                 if (error) {
 554                         vput(vp);
 555                         return (error);
 556                 }
 557                 ip->i_din = *((struct dinode *)bp->b_data +
 558                     ino_to_fsbo(fs, ip->i_number));
 559                 ip->i_effnlink = ip->i_nlink;
 560                 brelse(bp);
 561                 vput(vp);
 562                 simple_lock(&mntvnode_slock);
 563         }
 564         simple_unlock(&mntvnode_slock);
 565         return (0);
 566 }
 567
 568 /*
 569  * Common code for mount and mountroot
 570  */
 571 int
 572 ffs_mountfs(devvp, mp, td, malloctype)
 573         register struct vnode *devvp;
 574         struct mount *mp;
 575         struct thread *td;
 576         struct malloc_type *malloctype;
 577 {
 578         register struct ufsmount *ump;
 579         struct buf *bp;
 580         register struct fs *fs;
 581         dev_t dev;
 582         struct partinfo dpart;
 583         void *space;
 584         int error, i, blks, size, ronly;
 585         int32_t *lp;
 586         u_int64_t maxfilesize;                                  /* XXX */
 587         size_t strsize;
 588         int ncount;
 589
 590         dev = devvp->v_rdev;
 591         /*
 592          * Disallow multiple mounts of the same device.
 593          * Disallow mounting of a device that is currently in use
 594          * (except for root, which might share swap device for miniroot).
 595          * Flush out any old buffers remaining from a previous use.
 596          */
 597         error = vfs_mountedon(devvp);
 598         if (error)
 599                 return (error);
 600         ncount = vcount(devvp);
 601
 602         if (ncount > 1 && devvp != rootvp)
 603                 return (EBUSY);
 604         vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td);
 605         error = vinvalbuf(devvp, V_SAVE, td, 0, 0);
 606         VOP_UNLOCK(devvp, 0, td);
 607         if (error)
 608                 return (error);
 609
 610         /*
 611          * Only VMIO the backing device if the backing device is a real
 612          * block device.  This excludes the original MFS implementation.
 613          * Note that it is optional that the backing device be VMIOed.  This
 614          * increases the opportunity for metadata caching.
 615          */
 616         if (devvp->v_tag != VT_MFS && vn_isdisk(devvp, NULL)) {
 617                 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td);
 618                 vfs_object_create(devvp, td);
 619                 simple_lock(&devvp->v_interlock);
 620                 VOP_UNLOCK(devvp, LK_INTERLOCK, td);
 621         }
 622
 623         ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
 624         vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td);
 625         error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, td);
 626         VOP_UNLOCK(devvp, 0, td);
 627         if (error)
 628                 return (error);
 629         if (devvp->v_rdev->si_iosize_max != 0)
 630                 mp->mnt_iosize_max = devvp->v_rdev->si_iosize_max;
 631         if (mp->mnt_iosize_max > MAXPHYS)
 632                 mp->mnt_iosize_max = MAXPHYS;
 633
 634         if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, proc0.p_ucred, td) != 0)
 635                 size = DEV_BSIZE;
 636         else
 637                 size = dpart.disklab->d_secsize;
 638
 639         bp = NULL;
 640         ump = NULL;
 641         if ((error = bread(devvp, SBLOCK, SBSIZE, &bp)) != 0)
 642                 goto out;
 643         fs = (struct fs *)bp->b_data;
 644         if (fs->fs_magic != FS_MAGIC || fs->fs_bsize > MAXBSIZE ||
 645             fs->fs_bsize < sizeof(struct fs)) {
 646                 error = EINVAL;         /* XXX needs translation */
 647                 goto out;
 648         }
 649         fs->fs_fmod = 0;
 650         fs->fs_flags &= ~FS_UNCLEAN;
 651         if (fs->fs_clean == 0) {
 652                 fs->fs_flags |= FS_UNCLEAN;
 653                 if (ronly || (mp->mnt_flag & MNT_FORCE)) {
 654                         printf(
 655 "WARNING: %s was not properly dismounted\n",
 656                             fs->fs_fsmnt);
 657                 } else {
 658                         printf(
 659 "WARNING: R/W mount of %s denied.  Filesystem is not clean - run fsck\n",
 660                             fs->fs_fsmnt);
 661                         error = EPERM;
 662                         goto out;
 663                 }
 664         }
 665         /* XXX updating 4.2 FFS superblocks trashes rotational layout tables */
 666         if (fs->fs_postblformat == FS_42POSTBLFMT && !ronly) {
 667                 error = EROFS;          /* needs translation */
 668                 goto out;
 669         }
 670         ump = malloc(sizeof *ump, M_UFSMNT, M_WAITOK);
 671         bzero((caddr_t)ump, sizeof *ump);
 672         ump->um_malloctype = malloctype;
 673         ump->um_i_effnlink_valid = 1;
 674         ump->um_fs = malloc((u_long)fs->fs_sbsize, M_UFSMNT,
 675             M_WAITOK);
 676         ump->um_blkatoff = ffs_blkatoff;
 677         ump->um_truncate = ffs_truncate;
 678         ump->um_update = ffs_update;
 679         ump->um_valloc = ffs_valloc;
 680         ump->um_vfree = ffs_vfree;
 681         bcopy(bp->b_data, ump->um_fs, (u_int)fs->fs_sbsize);
 682         if (fs->fs_sbsize < SBSIZE)
 683                 bp->b_flags |= B_INVAL;
 684         brelse(bp);
 685         bp = NULL;
 686         fs = ump->um_fs;
 687         fs->fs_ronly = ronly;
 688         size = fs->fs_cssize;
 689         blks = howmany(size, fs->fs_fsize);
 690         if (fs->fs_contigsumsize > 0)
 691                 size += fs->fs_ncg * sizeof(int32_t);
 692         size += fs->fs_ncg * sizeof(u_int8_t);
 693         space = malloc((u_long)size, M_UFSMNT, M_WAITOK);
 694         fs->fs_csp = space;
 695         for (i = 0; i < blks; i += fs->fs_frag) {
 696                 size = fs->fs_bsize;
 697                 if (i + fs->fs_frag > blks)
 698                         size = (blks - i) * fs->fs_fsize;
 699                 if ((error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size,
 700                     &bp)) != 0) {
 701                         free(fs->fs_csp, M_UFSMNT);
 702                         goto out;
 703                 }
 704                 bcopy(bp->b_data, space, (u_int)size);
 705                 space = (char *)space + size;
 706                 brelse(bp);
 707                 bp = NULL;
 708         }
 709         if (fs->fs_contigsumsize > 0) {
 710                 fs->fs_maxcluster = lp = space;
 711                 for (i = 0; i < fs->fs_ncg; i++)
 712                         *lp++ = fs->fs_contigsumsize;
 713                 space = lp;
 714         }
 715         size = fs->fs_ncg * sizeof(u_int8_t);
 716         fs->fs_contigdirs = (u_int8_t *)space;
 717         bzero(fs->fs_contigdirs, size);
 718         /* Compatibility for old filesystems       XXX */
 719         if (fs->fs_avgfilesize <= 0)            /* XXX */
 720                 fs->fs_avgfilesize = AVFILESIZ; /* XXX */
 721         if (fs->fs_avgfpdir <= 0)               /* XXX */
 722                 fs->fs_avgfpdir = AFPDIR;       /* XXX */
 723         mp->mnt_data = (qaddr_t)ump;
 724         mp->mnt_stat.f_fsid.val[0] = fs->fs_id[0];
 725         mp->mnt_stat.f_fsid.val[1] = fs->fs_id[1];
 726         if (fs->fs_id[0] == 0 || fs->fs_id[1] == 0 ||
 727             vfs_getvfs(&mp->mnt_stat.f_fsid))
 728                 vfs_getnewfsid(mp);
 729         mp->mnt_maxsymlinklen = fs->fs_maxsymlinklen;
 730         mp->mnt_flag |= MNT_LOCAL;
 731         ump->um_mountp = mp;
 732         ump->um_dev = dev;
 733         ump->um_devvp = devvp;
 734         ump->um_nindir = fs->fs_nindir;
 735         ump->um_bptrtodb = fs->fs_fsbtodb;
 736         ump->um_seqinc = fs->fs_frag;
 737         for (i = 0; i < MAXQUOTAS; i++)
 738                 ump->um_quotas[i] = NULLVP;
 739         devvp->v_specmountpoint = mp;
 740         ffs_oldfscompat(fs);
 741
 742         /*
 743          * Set FS local "last mounted on" information (NULL pad)
 744          */
 745         copystr(        mp->mnt_stat.f_mntonname,       /* mount point*/
 746                         fs->fs_fsmnt,                   /* copy area*/
 747                         sizeof(fs->fs_fsmnt) - 1,       /* max size*/
 748                         &strsize);                      /* real size*/
 749         bzero( fs->fs_fsmnt + strsize, sizeof(fs->fs_fsmnt) - strsize);
 750
 751         if( mp->mnt_flag & MNT_ROOTFS) {
 752                 /*
 753                  * Root mount; update timestamp in mount structure.
 754                  * this will be used by the common root mount code
 755                  * to update the system clock.
 756                  */
 757                 mp->mnt_time = fs->fs_time;
 758         }
 759
 760         ump->um_savedmaxfilesize = fs->fs_maxfilesize;          /* XXX */
 761         maxfilesize = (u_int64_t)0x40000000 * fs->fs_bsize - 1; /* XXX */
 762         /* Enforce limit caused by vm object backing (32 bits vm_pindex_t). */
 763         if (maxfilesize > (u_int64_t)0x80000000u * PAGE_SIZE - 1)
 764                 maxfilesize = (u_int64_t)0x80000000u * PAGE_SIZE - 1;
 765         if (fs->fs_maxfilesize > maxfilesize)                   /* XXX */
 766                 fs->fs_maxfilesize = maxfilesize;               /* XXX */
 767         if (ronly == 0) {
 768                 if ((fs->fs_flags & FS_DOSOFTDEP) &&
 769                     (error = softdep_mount(devvp, mp, fs)) != 0) {
 770                         free(fs->fs_csp, M_UFSMNT);
 771                         goto out;
 772                 }
 773                 fs->fs_fmod = 1;
 774                 fs->fs_clean = 0;
 775                 (void) ffs_sbupdate(ump, MNT_WAIT);
 776         }
 777         return (0);
 778 out:
 779         devvp->v_specmountpoint = NULL;
 780         if (bp)
 781                 brelse(bp);
 782         (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, td);
 783         if (ump) {
 784                 free(ump->um_fs, M_UFSMNT);
 785                 free(ump, M_UFSMNT);
 786                 mp->mnt_data = (qaddr_t)0;
 787         }
 788         return (error);
 789 }
 790
 791 /*
 792  * Sanity checks for old file systems.
 793  *
 794  * XXX - goes away some day.
 795  */
 796 static int
 797 ffs_oldfscompat(fs)
 798         struct fs *fs;
 799 {
 800
 801         fs->fs_npsect = max(fs->fs_npsect, fs->fs_nsect);       /* XXX */
 802         fs->fs_interleave = max(fs->fs_interleave, 1);          /* XXX */
 803         if (fs->fs_postblformat == FS_42POSTBLFMT)              /* XXX */
 804                 fs->fs_nrpos = 8;                               /* XXX */
 805         if (fs->fs_inodefmt < FS_44INODEFMT) {                  /* XXX */
 806 #if 0
 807                 int i;                                          /* XXX */
 808                 u_int64_t sizepb = fs->fs_bsize;                /* XXX */
 809                                                                 /* XXX */
 810                 fs->fs_maxfilesize = fs->fs_bsize * NDADDR - 1; /* XXX */
 811                 for (i = 0; i < NIADDR; i++) {                  /* XXX */
 812                         sizepb *= NINDIR(fs);                   /* XXX */
 813                         fs->fs_maxfilesize += sizepb;           /* XXX */
 814                 }                                               /* XXX */
 815 #endif
 816                 fs->fs_maxfilesize = (u_quad_t) 1LL << 39;
 817                 fs->fs_qbmask = ~fs->fs_bmask;                  /* XXX */
 818                 fs->fs_qfmask = ~fs->fs_fmask;                  /* XXX */
 819         }                                                       /* XXX */
 820         return (0);
 821 }
 822
 823 /*
 824  * unmount system call
 825  */
 826 int
 827 ffs_unmount(struct mount *mp, int mntflags, struct thread *td)
 828 {
 829         register struct ufsmount *ump;
 830         register struct fs *fs;
 831         int error, flags;
 832
 833         flags = 0;
 834         if (mntflags & MNT_FORCE) {
 835                 flags |= FORCECLOSE;
 836         }
 837         if (mp->mnt_flag & MNT_SOFTDEP) {
 838                 if ((error = softdep_flushfiles(mp, flags, td)) != 0)
 839                         return (error);
 840         } else {
 841                 if ((error = ffs_flushfiles(mp, flags, td)) != 0)
 842                         return (error);
 843         }
 844         ump = VFSTOUFS(mp);
 845         fs = ump->um_fs;
 846         if (fs->fs_ronly == 0) {
 847                 fs->fs_clean = fs->fs_flags & FS_UNCLEAN ? 0 : 1;
 848                 error = ffs_sbupdate(ump, MNT_WAIT);
 849                 if (error) {
 850                         fs->fs_clean = 0;
 851                         return (error);
 852                 }
 853         }
 854         ump->um_devvp->v_specmountpoint = NULL;
 855
 856         vinvalbuf(ump->um_devvp, V_SAVE, td, 0, 0);
 857         error = VOP_CLOSE(ump->um_devvp, fs->fs_ronly ? FREAD : FREAD|FWRITE, td);
 858
 859         vrele(ump->um_devvp);
 860
 861         free(fs->fs_csp, M_UFSMNT);
 862         free(fs, M_UFSMNT);
 863         free(ump, M_UFSMNT);
 864         mp->mnt_data = (qaddr_t)0;
 865         mp->mnt_flag &= ~MNT_LOCAL;
 866         return (error);
 867 }
 868
 869 /*
 870  * Flush out all the files in a filesystem.
 871  */
 872 int
 873 ffs_flushfiles(struct mount *mp, int flags, struct thread *td)
 874 {
 875         struct ufsmount *ump;
 876         int error;
 877         struct ucred *cred;
 878
 879         KKASSERT(td->td_proc);
 880         cred = td->td_proc->p_ucred;
 881
 882         ump = VFSTOUFS(mp);
 883 #ifdef QUOTA
 884         if (mp->mnt_flag & MNT_QUOTA) {
 885                 int i;
 886                 error = vflush(mp, 0, SKIPSYSTEM|flags);
 887                 if (error)
 888                         return (error);
 889                 for (i = 0; i < MAXQUOTAS; i++) {
 890                         if (ump->um_quotas[i] == NULLVP)
 891                                 continue;
 892                         quotaoff(td, mp, i);
 893                 }
 894                 /*
 895                  * Here we fall through to vflush again to ensure
 896                  * that we have gotten rid of all the system vnodes.
 897                  */
 898         }
 899 #endif
 900         /*
 901          * Flush all the files.
 902          */
 903         if ((error = vflush(mp, 0, flags)) != 0)
 904                 return (error);
 905         /*
 906          * Flush filesystem metadata.
 907          */
 908         vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY, td);
 909         error = VOP_FSYNC(ump->um_devvp, MNT_WAIT, td);
 910         VOP_UNLOCK(ump->um_devvp, 0, td);
 911         return (error);
 912 }
 913
 914 /*
 915  * Get file system statistics.
 916  */
 917 int
 918 ffs_statfs(struct mount *mp, struct statfs *sbp, struct thread *td)
 919 {
 920         register struct ufsmount *ump;
 921         register struct fs *fs;
 922
 923         ump = VFSTOUFS(mp);
 924         fs = ump->um_fs;
 925         if (fs->fs_magic != FS_MAGIC)
 926                 panic("ffs_statfs");
 927         sbp->f_bsize = fs->fs_fsize;
 928         sbp->f_iosize = fs->fs_bsize;
 929         sbp->f_blocks = fs->fs_dsize;
 930         sbp->f_bfree = fs->fs_cstotal.cs_nbfree * fs->fs_frag +
 931                 fs->fs_cstotal.cs_nffree;
 932         sbp->f_bavail = freespace(fs, fs->fs_minfree);
 933         sbp->f_files =  fs->fs_ncg * fs->fs_ipg - ROOTINO;
 934         sbp->f_ffree = fs->fs_cstotal.cs_nifree;
 935         if (sbp != &mp->mnt_stat) {
 936                 sbp->f_type = mp->mnt_vfc->vfc_typenum;
 937                 bcopy((caddr_t)mp->mnt_stat.f_mntonname,
 938                         (caddr_t)&sbp->f_mntonname[0], MNAMELEN);
 939                 bcopy((caddr_t)mp->mnt_stat.f_mntfromname,
 940                         (caddr_t)&sbp->f_mntfromname[0], MNAMELEN);
 941         }
 942         return (0);
 943 }
 944
 945 /*
 946  * Go through the disk queues to initiate sandbagged IO;
 947  * go through the inodes to write those that have been modified;
 948  * initiate the writing of the super block if it has been modified.
 949  *
 950  * Note: we are always called with the filesystem marked `MPBUSY'.
 951  */
 952 int
 953 ffs_sync(struct mount *mp, int waitfor, struct thread *td)
 954 {
 955         struct vnode *nvp, *vp;
 956         struct inode *ip;
 957         struct ufsmount *ump = VFSTOUFS(mp);
 958         struct fs *fs;
 959         int error, allerror = 0;
 960
 961         fs = ump->um_fs;
 962         if (fs->fs_fmod != 0 && fs->fs_ronly != 0) {            /* XXX */
 963                 printf("fs = %s\n", fs->fs_fsmnt);
 964                 panic("ffs_sync: rofs mod");
 965         }
 966         /*
 967          * Write back each (modified) inode.
 968          */
 969         simple_lock(&mntvnode_slock);
 970 loop:
 971         for (vp = TAILQ_FIRST(&mp->mnt_nvnodelist); vp != NULL; vp = nvp) {
 972                 /*
 973                  * If the vnode that we are about to sync is no longer
 974                  * associated with this mount point, start over.
 975                  */
 976                 if (vp->v_mount != mp)
 977                         goto loop;
 978
 979                 /*
 980                  * Depend on the mntvnode_slock to keep things stable enough
 981                  * for a quick test.  Since there might be hundreds of
 982                  * thousands of vnodes, we cannot afford even a subroutine
 983                  * call unless there's a good chance that we have work to do.
 984                  */
 985                 nvp = TAILQ_NEXT(vp, v_nmntvnodes);
 986                 ip = VTOI(vp);
 987                 if (vp->v_type == VNON || ((ip->i_flag &
 988                      (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) == 0 &&
 989                      TAILQ_EMPTY(&vp->v_dirtyblkhd))) {
 990                         continue;
 991                 }
 992                 if (vp->v_type != VCHR) {
 993                         simple_unlock(&mntvnode_slock);
 994                         error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT, td);
 995                         if (error) {
 996                                 simple_lock(&mntvnode_slock);
 997                                 if (error == ENOENT)
 998                                         goto loop;
 999                         } else {
1000                                 if ((error = VOP_FSYNC(vp, waitfor, td)) != 0)
1001                                         allerror = error;
1002                                 VOP_UNLOCK(vp, 0, td);
1003                                 vrele(vp);
1004                                 simple_lock(&mntvnode_slock);
1005                         }
1006                 } else {
1007                         /*
1008                          * We must reference the vp to prevent it from
1009                          * getting ripped out from under UFS_UPDATE, since
1010                          * we are not holding a vnode lock.  XXX why aren't
1011                          * we holding a vnode lock?
1012                          */
1013                         VREF(vp);
1014                         simple_unlock(&mntvnode_slock);
1015                         /* UFS_UPDATE(vp, waitfor == MNT_WAIT); */
1016                         UFS_UPDATE(vp, 0);
1017                         vrele(vp);
1018                         simple_lock(&mntvnode_slock);
1019                 }
1020                 if (TAILQ_NEXT(vp, v_nmntvnodes) != nvp)
1021                         goto loop;
1022         }
1023         simple_unlock(&mntvnode_slock);
1024         /*
1025          * Force stale file system control information to be flushed.
1026          */
1027         if (waitfor != MNT_LAZY) {
1028                 if (ump->um_mountp->mnt_flag & MNT_SOFTDEP)
1029                         waitfor = MNT_NOWAIT;
1030                 vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY, td);
1031                 if ((error = VOP_FSYNC(ump->um_devvp, waitfor, td)) != 0)
1032                         allerror = error;
1033                 VOP_UNLOCK(ump->um_devvp, 0, td);
1034         }
1035 #ifdef QUOTA
1036         qsync(mp);
1037 #endif
1038         /*
1039          * Write back modified superblock.
1040          */
1041         if (fs->fs_fmod != 0 && (error = ffs_sbupdate(ump, waitfor)) != 0)
1042                 allerror = error;
1043         return (allerror);
1044 }
1045
1046 /*
1047  * Look up a FFS dinode number to find its incore vnode, otherwise read it
1048  * in from disk.  If it is in core, wait for the lock bit to clear, then
1049  * return the inode locked.  Detection and handling of mount points must be
1050  * done by the calling routine.
1051  */
1052 static int ffs_inode_hash_lock;
1053
1054 int
1055 ffs_vget(mp, ino, vpp)
1056         struct mount *mp;
1057         ino_t ino;
1058         struct vnode **vpp;
1059 {
1060         struct fs *fs;
1061         struct inode *ip;
1062         struct ufsmount *ump;
1063         struct buf *bp;
1064         struct vnode *vp;
1065         dev_t dev;
1066         int error;
1067
1068         ump = VFSTOUFS(mp);
1069         dev = ump->um_dev;
1070 restart:
1071         if ((*vpp = ufs_ihashget(dev, ino)) != NULL) {
1072                 return (0);
1073         }
1074
1075         /*
1076          * Lock out the creation of new entries in the FFS hash table in
1077          * case getnewvnode() or MALLOC() blocks, otherwise a duplicate
1078          * may occur!
1079          */
1080         if (ffs_inode_hash_lock) {
1081                 while (ffs_inode_hash_lock) {
1082                         ffs_inode_hash_lock = -1;
1083                         tsleep(&ffs_inode_hash_lock, PVM, "ffsvgt", 0);
1084                 }
1085                 goto restart;
1086         }
1087         ffs_inode_hash_lock = 1;
1088
1089         /*
1090          * If this MALLOC() is performed after the getnewvnode()
1091          * it might block, leaving a vnode with a NULL v_data to be
1092          * found by ffs_sync() if a sync happens to fire right then,
1093          * which will cause a panic because ffs_sync() blindly
1094          * dereferences vp->v_data (as well it should).
1095          */
1096         MALLOC(ip, struct inode *, sizeof(struct inode),
1097             ump->um_malloctype, M_WAITOK);
1098
1099         /* Allocate a new vnode/inode. */
1100         error = getnewvnode(VT_UFS, mp, ffs_vnodeop_p, &vp);
1101         if (error) {
1102                 if (ffs_inode_hash_lock < 0)
1103                         wakeup(&ffs_inode_hash_lock);
1104                 ffs_inode_hash_lock = 0;
1105                 *vpp = NULL;
1106                 FREE(ip, ump->um_malloctype);
1107                 return (error);
1108         }
1109         bzero((caddr_t)ip, sizeof(struct inode));
1110         lockinit(&ip->i_lock, PINOD, "inode", VLKTIMEOUT, LK_CANRECURSE);
1111         vp->v_data = ip;
1112         /*
1113          * FFS supports lock sharing in the stack of vnodes
1114          */
1115         vp->v_vnlock = &ip->i_lock;
1116         ip->i_vnode = vp;
1117         ip->i_fs = fs = ump->um_fs;
1118         ip->i_dev = dev;
1119         ip->i_number = ino;
1120 #ifdef QUOTA
1121         {
1122                 int i;
1123                 for (i = 0; i < MAXQUOTAS; i++)
1124                         ip->i_dquot[i] = NODQUOT;
1125         }
1126 #endif
1127         /*
1128          * Put it onto its hash chain and lock it so that other requests for
1129          * this inode will block if they arrive while we are sleeping waiting
1130          * for old data structures to be purged or for the contents of the
1131          * disk portion of this inode to be read.
1132          */
1133         ufs_ihashins(ip);
1134
1135         if (ffs_inode_hash_lock < 0)
1136                 wakeup(&ffs_inode_hash_lock);
1137         ffs_inode_hash_lock = 0;
1138
1139         /* Read in the disk contents for the inode, copy into the inode. */
1140         error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ino)),
1141             (int)fs->fs_bsize, &bp);
1142         if (error) {
1143                 /*
1144                  * The inode does not contain anything useful, so it would
1145                  * be misleading to leave it on its hash chain. With mode
1146                  * still zero, it will be unlinked and returned to the free
1147                  * list by vput().
1148                  */
1149                 brelse(bp);
1150                 vput(vp);
1151                 *vpp = NULL;
1152                 return (error);
1153         }
1154         ip->i_din = *((struct dinode *)bp->b_data + ino_to_fsbo(fs, ino));
1155         if (DOINGSOFTDEP(vp))
1156                 softdep_load_inodeblock(ip);
1157         else
1158                 ip->i_effnlink = ip->i_nlink;
1159         bqrelse(bp);
1160
1161         /*
1162          * Initialize the vnode from the inode, check for aliases.
1163          * Note that the underlying vnode may have changed.
1164          */
1165         error = ufs_vinit(mp, ffs_specop_p, ffs_fifoop_p, &vp);
1166         if (error) {
1167                 vput(vp);
1168                 *vpp = NULL;
1169                 return (error);
1170         }
1171         /*
1172          * Finish inode initialization now that aliasing has been resolved.
1173          */
1174         ip->i_devvp = ump->um_devvp;
1175         VREF(ip->i_devvp);
1176         /*
1177          * Set up a generation number for this inode if it does not
1178          * already have one. This should only happen on old filesystems.
1179          */
1180         if (ip->i_gen == 0) {
1181                 ip->i_gen = random() / 2 + 1;
1182                 if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0)
1183                         ip->i_flag |= IN_MODIFIED;
1184         }
1185         /*
1186          * Ensure that uid and gid are correct. This is a temporary
1187          * fix until fsck has been changed to do the update.
1188          */
1189         if (fs->fs_inodefmt < FS_44INODEFMT) {          /* XXX */
1190                 ip->i_uid = ip->i_din.di_ouid;          /* XXX */
1191                 ip->i_gid = ip->i_din.di_ogid;          /* XXX */
1192         }                                               /* XXX */
1193
1194         *vpp = vp;
1195         return (0);
1196 }
1197
1198 /*
1199  * File handle to vnode
1200  *
1201  * Have to be really careful about stale file handles:
1202  * - check that the inode number is valid
1203  * - call ffs_vget() to get the locked inode
1204  * - check for an unallocated inode (i_mode == 0)
1205  * - check that the given client host has export rights and return
1206  *   those rights via. exflagsp and credanonp
1207  */
1208 int
1209 ffs_fhtovp(mp, fhp, vpp)
1210         register struct mount *mp;
1211         struct fid *fhp;
1212         struct vnode **vpp;
1213 {
1214         register struct ufid *ufhp;
1215         struct fs *fs;
1216
1217         ufhp = (struct ufid *)fhp;
1218         fs = VFSTOUFS(mp)->um_fs;
1219         if (ufhp->ufid_ino < ROOTINO ||
1220             ufhp->ufid_ino >= fs->fs_ncg * fs->fs_ipg)
1221                 return (ESTALE);
1222         return (ufs_fhtovp(mp, ufhp, vpp));
1223 }
1224
1225 /*
1226  * Vnode pointer to File handle
1227  */
1228 /* ARGSUSED */
1229 int
1230 ffs_vptofh(vp, fhp)
1231         struct vnode *vp;
1232         struct fid *fhp;
1233 {
1234         register struct inode *ip;
1235         register struct ufid *ufhp;
1236
1237         ip = VTOI(vp);
1238         ufhp = (struct ufid *)fhp;
1239         ufhp->ufid_len = sizeof(struct ufid);
1240         ufhp->ufid_ino = ip->i_number;
1241         ufhp->ufid_gen = ip->i_gen;
1242         return (0);
1243 }
1244
1245 /*
1246  * Initialize the filesystem; just use ufs_init.
1247  */
1248 static int
1249 ffs_init(vfsp)
1250         struct vfsconf *vfsp;
1251 {
1252
1253         softdep_initialize();
1254         return (ufs_init(vfsp));
1255 }
1256
1257 /*
1258  * Write a superblock and associated information back to disk.
1259  */
1260 static int
1261 ffs_sbupdate(mp, waitfor)
1262         struct ufsmount *mp;
1263         int waitfor;
1264 {
1265         register struct fs *dfs, *fs = mp->um_fs;
1266         register struct buf *bp;
1267         int blks;
1268         void *space;
1269         int i, size, error, allerror = 0;
1270
1271         /*
1272          * First write back the summary information.
1273          */
1274         blks = howmany(fs->fs_cssize, fs->fs_fsize);
1275         space = fs->fs_csp;
1276         for (i = 0; i < blks; i += fs->fs_frag) {
1277                 size = fs->fs_bsize;
1278                 if (i + fs->fs_frag > blks)
1279                         size = (blks - i) * fs->fs_fsize;
1280                 bp = getblk(mp->um_devvp, fsbtodb(fs, fs->fs_csaddr + i),
1281                     size, 0, 0);
1282                 bcopy(space, bp->b_data, (u_int)size);
1283                 space = (char *)space + size;
1284                 if (waitfor != MNT_WAIT)
1285                         bawrite(bp);
1286                 else if ((error = bwrite(bp)) != 0)
1287                         allerror = error;
1288         }
1289         /*
1290          * Now write back the superblock itself. If any errors occurred
1291          * up to this point, then fail so that the superblock avoids
1292          * being written out as clean.
1293          */
1294         if (allerror)
1295                 return (allerror);
1296         bp = getblk(mp->um_devvp, SBLOCK, (int)fs->fs_sbsize, 0, 0);
1297         fs->fs_fmod = 0;
1298         fs->fs_time = time_second;
1299         bcopy((caddr_t)fs, bp->b_data, (u_int)fs->fs_sbsize);
1300         /* Restore compatibility to old file systems.              XXX */
1301         dfs = (struct fs *)bp->b_data;                          /* XXX */
1302         if (fs->fs_postblformat == FS_42POSTBLFMT)              /* XXX */
1303                 dfs->fs_nrpos = -1;                             /* XXX */
1304         if (fs->fs_inodefmt < FS_44INODEFMT) {                  /* XXX */
1305                 int32_t *lp, tmp;                               /* XXX */
1306                                                                 /* XXX */
1307                 lp = (int32_t *)&dfs->fs_qbmask;                /* XXX */
1308                 tmp = lp[4];                                    /* XXX */
1309                 for (i = 4; i > 0; i--)                         /* XXX */
1310                         lp[i] = lp[i-1];                        /* XXX */
1311                 lp[0] = tmp;                                    /* XXX */
1312         }                                                       /* XXX */
1313         dfs->fs_maxfilesize = mp->um_savedmaxfilesize;          /* XXX */
1314         if (waitfor != MNT_WAIT)
1315                 bawrite(bp);
1316         else if ((error = bwrite(bp)) != 0)
1317                 allerror = error;
1318         return (allerror);
1319 }