sys/fs/ext2fs/ext2_vfsops.c

   1 /*-
   2  *  modified for EXT2FS support in Lites 1.1
   3  *
   4  *  Aug 1995, Godmar Back (gback@cs.utah.edu)
   5  *  University of Utah, Department of Computer Science
   6  */
   7 /*-
   8  * SPDX-License-Identifier: BSD-3-Clause
   9  *
  10  * Copyright (c) 1989, 1991, 1993, 1994
  11  *      The Regents of the University of California.  All rights reserved.
  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  * 3. Neither the name of the University nor the names of its contributors
  22  *    may be used to endorse or promote products derived from this software
  23  *    without specific prior written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  35  * SUCH DAMAGE.
  36  *
  37  *      @(#)ffs_vfsops.c        8.8 (Berkeley) 4/18/94
  38  * $FreeBSD$
  39  */
  40
  41 #include <sys/param.h>
  42 #include <sys/systm.h>
  43 #include <sys/namei.h>
  44 #include <sys/priv.h>
  45 #include <sys/proc.h>
  46 #include <sys/kernel.h>
  47 #include <sys/vnode.h>
  48 #include <sys/mount.h>
  49 #include <sys/bio.h>
  50 #include <sys/buf.h>
  51 #include <sys/conf.h>
  52 #include <sys/endian.h>
  53 #include <sys/fcntl.h>
  54 #include <sys/malloc.h>
  55 #include <sys/stat.h>
  56 #include <sys/mutex.h>
  57
  58 #include <geom/geom.h>
  59 #include <geom/geom_vfs.h>
  60
  61 #include <fs/ext2fs/ext2_mount.h>
  62 #include <fs/ext2fs/inode.h>
  63
  64 #include <fs/ext2fs/fs.h>
  65 #include <fs/ext2fs/ext2fs.h>
  66 #include <fs/ext2fs/ext2_dinode.h>
  67 #include <fs/ext2fs/ext2_extern.h>
  68
  69 static int      ext2_flushfiles(struct mount *mp, int flags, struct thread *td);
  70 static int      ext2_mountfs(struct vnode *, struct mount *);
  71 static int      ext2_reload(struct mount *mp, struct thread *td);
  72 static int      ext2_sbupdate(struct ext2mount *, int);
  73 static int      ext2_cgupdate(struct ext2mount *, int);
  74 static vfs_unmount_t            ext2_unmount;
  75 static vfs_root_t               ext2_root;
  76 static vfs_statfs_t             ext2_statfs;
  77 static vfs_sync_t               ext2_sync;
  78 static vfs_vget_t               ext2_vget;
  79 static vfs_fhtovp_t             ext2_fhtovp;
  80 static vfs_mount_t              ext2_mount;
  81
  82 MALLOC_DEFINE(M_EXT2NODE, "ext2_node", "EXT2 vnode private part");
  83 static MALLOC_DEFINE(M_EXT2MNT, "ext2_mount", "EXT2 mount structure");
  84
  85 static struct vfsops ext2fs_vfsops = {
  86         .vfs_fhtovp =           ext2_fhtovp,
  87         .vfs_mount =            ext2_mount,
  88         .vfs_root =             ext2_root,      /* root inode via vget */
  89         .vfs_statfs =           ext2_statfs,
  90         .vfs_sync =             ext2_sync,
  91         .vfs_unmount =          ext2_unmount,
  92         .vfs_vget =             ext2_vget,
  93 };
  94
  95 VFS_SET(ext2fs_vfsops, ext2fs, 0);
  96
  97 static int      ext2_check_sb_compat(struct ext2fs *es, struct cdev *dev,
  98                     int ronly);
  99 static int      compute_sb_data(struct vnode * devvp,
 100                     struct ext2fs * es, struct m_ext2fs * fs);
 101
 102 static const char *ext2_opts[] = { "acls", "async", "noatime", "noclusterr",
 103     "noclusterw", "noexec", "export", "force", "from", "multilabel",
 104     "suiddir", "nosymfollow", "sync", "union", NULL };
 105
 106 /*
 107  * VFS Operations.
 108  *
 109  * mount system call
 110  */
 111 static int
 112 ext2_mount(struct mount *mp)
 113 {
 114         struct vfsoptlist *opts;
 115         struct vnode *devvp;
 116         struct thread *td;
 117         struct ext2mount *ump = NULL;
 118         struct m_ext2fs *fs;
 119         struct nameidata nd, *ndp = &nd;
 120         accmode_t accmode;
 121         char *path, *fspec;
 122         int error, flags, len;
 123
 124         td = curthread;
 125         opts = mp->mnt_optnew;
 126
 127         if (vfs_filteropt(opts, ext2_opts))
 128                 return (EINVAL);
 129
 130         vfs_getopt(opts, "fspath", (void **)&path, NULL);
 131         /* Double-check the length of path.. */
 132         if (strlen(path) >= MAXMNTLEN)
 133                 return (ENAMETOOLONG);
 134
 135         fspec = NULL;
 136         error = vfs_getopt(opts, "from", (void **)&fspec, &len);
 137         if (!error && fspec[len - 1] != '\0')
 138                 return (EINVAL);
 139
 140         /*
 141          * If updating, check whether changing from read-only to
 142          * read/write; if there is no device name, that's all we do.
 143          */
 144         if (mp->mnt_flag & MNT_UPDATE) {
 145                 ump = VFSTOEXT2(mp);
 146                 fs = ump->um_e2fs;
 147                 error = 0;
 148                 if (fs->e2fs_ronly == 0 &&
 149                     vfs_flagopt(opts, "ro", NULL, 0)) {
 150                         error = VFS_SYNC(mp, MNT_WAIT);
 151                         if (error)
 152                                 return (error);
 153                         flags = WRITECLOSE;
 154                         if (mp->mnt_flag & MNT_FORCE)
 155                                 flags |= FORCECLOSE;
 156                         error = ext2_flushfiles(mp, flags, td);
 157                         if (error == 0 && fs->e2fs_wasvalid && ext2_cgupdate(ump, MNT_WAIT) == 0) {
 158                                 fs->e2fs->e2fs_state |= E2FS_ISCLEAN;
 159                                 ext2_sbupdate(ump, MNT_WAIT);
 160                         }
 161                         fs->e2fs_ronly = 1;
 162                         vfs_flagopt(opts, "ro", &mp->mnt_flag, MNT_RDONLY);
 163                         g_topology_lock();
 164                         g_access(ump->um_cp, 0, -1, 0);
 165                         g_topology_unlock();
 166                 }
 167                 if (!error && (mp->mnt_flag & MNT_RELOAD))
 168                         error = ext2_reload(mp, td);
 169                 if (error)
 170                         return (error);
 171                 devvp = ump->um_devvp;
 172                 if (fs->e2fs_ronly && !vfs_flagopt(opts, "ro", NULL, 0)) {
 173                         if (ext2_check_sb_compat(fs->e2fs, devvp->v_rdev, 0))
 174                                 return (EPERM);
 175
 176                         /*
 177                          * If upgrade to read-write by non-root, then verify
 178                          * that user has necessary permissions on the device.
 179                          */
 180                         vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
 181                         error = VOP_ACCESS(devvp, VREAD | VWRITE,
 182                             td->td_ucred, td);
 183                         if (error)
 184                                 error = priv_check(td, PRIV_VFS_MOUNT_PERM);
 185                         if (error) {
 186                                 VOP_UNLOCK(devvp, 0);
 187                                 return (error);
 188                         }
 189                         VOP_UNLOCK(devvp, 0);
 190                         g_topology_lock();
 191                         error = g_access(ump->um_cp, 0, 1, 0);
 192                         g_topology_unlock();
 193                         if (error)
 194                                 return (error);
 195
 196                         if ((fs->e2fs->e2fs_state & E2FS_ISCLEAN) == 0 ||
 197                             (fs->e2fs->e2fs_state & E2FS_ERRORS)) {
 198                                 if (mp->mnt_flag & MNT_FORCE) {
 199                                         printf(
 200 "WARNING: %s was not properly dismounted\n", fs->e2fs_fsmnt);
 201                                 } else {
 202                                         printf(
 203 "WARNING: R/W mount of %s denied.  Filesystem is not clean - run fsck\n",
 204                                             fs->e2fs_fsmnt);
 205                                         return (EPERM);
 206                                 }
 207                         }
 208                         fs->e2fs->e2fs_state &= ~E2FS_ISCLEAN;
 209                         (void)ext2_cgupdate(ump, MNT_WAIT);
 210                         fs->e2fs_ronly = 0;
 211                         MNT_ILOCK(mp);
 212                         mp->mnt_flag &= ~MNT_RDONLY;
 213                         MNT_IUNLOCK(mp);
 214                 }
 215                 if (vfs_flagopt(opts, "export", NULL, 0)) {
 216                         /* Process export requests in vfs_mount.c. */
 217                         return (error);
 218                 }
 219         }
 220
 221         /*
 222          * Not an update, or updating the name: look up the name
 223          * and verify that it refers to a sensible disk device.
 224          */
 225         if (fspec == NULL)
 226                 return (EINVAL);
 227         NDINIT(ndp, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, fspec, td);
 228         if ((error = namei(ndp)) != 0)
 229                 return (error);
 230         NDFREE(ndp, NDF_ONLY_PNBUF);
 231         devvp = ndp->ni_vp;
 232
 233         if (!vn_isdisk(devvp, &error)) {
 234                 vput(devvp);
 235                 return (error);
 236         }
 237
 238         /*
 239          * If mount by non-root, then verify that user has necessary
 240          * permissions on the device.
 241          *
 242          * XXXRW: VOP_ACCESS() enough?
 243          */
 244         accmode = VREAD;
 245         if ((mp->mnt_flag & MNT_RDONLY) == 0)
 246                 accmode |= VWRITE;
 247         error = VOP_ACCESS(devvp, accmode, td->td_ucred, td);
 248         if (error)
 249                 error = priv_check(td, PRIV_VFS_MOUNT_PERM);
 250         if (error) {
 251                 vput(devvp);
 252                 return (error);
 253         }
 254
 255         if ((mp->mnt_flag & MNT_UPDATE) == 0) {
 256                 error = ext2_mountfs(devvp, mp);
 257         } else {
 258                 if (devvp != ump->um_devvp) {
 259                         vput(devvp);
 260                         return (EINVAL);        /* needs translation */
 261                 } else
 262                         vput(devvp);
 263         }
 264         if (error) {
 265                 vrele(devvp);
 266                 return (error);
 267         }
 268         ump = VFSTOEXT2(mp);
 269         fs = ump->um_e2fs;
 270
 271         /*
 272          * Note that this strncpy() is ok because of a check at the start
 273          * of ext2_mount().
 274          */
 275         strncpy(fs->e2fs_fsmnt, path, MAXMNTLEN);
 276         fs->e2fs_fsmnt[MAXMNTLEN - 1] = '\0';
 277         vfs_mountedfrom(mp, fspec);
 278         return (0);
 279 }
 280
 281 static int
 282 ext2_check_sb_compat(struct ext2fs *es, struct cdev *dev, int ronly)
 283 {
 284         uint32_t i, mask;
 285
 286         if (es->e2fs_magic != E2FS_MAGIC) {
 287                 printf("ext2fs: %s: wrong magic number %#x (expected %#x)\n",
 288                     devtoname(dev), es->e2fs_magic, E2FS_MAGIC);
 289                 return (1);
 290         }
 291         if (es->e2fs_rev > E2FS_REV0) {
 292                 mask = es->e2fs_features_incompat & ~(EXT2F_INCOMPAT_SUPP |
 293                     EXT4F_RO_INCOMPAT_SUPP);
 294                 if (mask) {
 295                         printf("WARNING: mount of %s denied due to "
 296                             "unsupported optional features:\n", devtoname(dev));
 297                         for (i = 0;
 298                             i < sizeof(incompat)/sizeof(struct ext2_feature);
 299                             i++)
 300                                 if (mask & incompat[i].mask)
 301                                         printf("%s ", incompat[i].name);
 302                         printf("\n");
 303                         return (1);
 304                 }
 305                 mask = es->e2fs_features_rocompat & ~EXT2F_ROCOMPAT_SUPP;
 306                 if (!ronly && mask) {
 307                         printf("WARNING: R/W mount of %s denied due to "
 308                             "unsupported optional features:\n", devtoname(dev));
 309                         for (i = 0;
 310                             i < sizeof(ro_compat)/sizeof(struct ext2_feature);
 311                             i++)
 312                                 if (mask & ro_compat[i].mask)
 313                                         printf("%s ", ro_compat[i].name);
 314                         printf("\n");
 315                         return (1);
 316                 }
 317         }
 318         return (0);
 319 }
 320
 321 /*
 322  * This computes the fields of the m_ext2fs structure from the
 323  * data in the ext2fs structure read in.
 324  */
 325 static int
 326 compute_sb_data(struct vnode *devvp, struct ext2fs *es,
 327     struct m_ext2fs *fs)
 328 {
 329         int g_count = 0, error;
 330         int i, j;
 331         int logic_sb_block = 1; /* XXX for now */
 332         struct buf *bp;
 333         uint32_t e2fs_descpb, e2fs_gdbcount_alloc;
 334
 335         fs->e2fs_bcount = es->e2fs_bcount;
 336         fs->e2fs_rbcount = es->e2fs_rbcount;
 337         fs->e2fs_fbcount = es->e2fs_fbcount;
 338         if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT)) {
 339                 fs->e2fs_bcount |= (uint64_t)(es->e4fs_bcount_hi) << 32;
 340                 fs->e2fs_rbcount |= (uint64_t)(es->e4fs_rbcount_hi) << 32;
 341                 fs->e2fs_fbcount |= (uint64_t)(es->e4fs_fbcount_hi) << 32;
 342         }
 343         fs->e2fs_bshift = EXT2_MIN_BLOCK_LOG_SIZE + es->e2fs_log_bsize;
 344         fs->e2fs_bsize = 1U << fs->e2fs_bshift;
 345         fs->e2fs_fsbtodb = es->e2fs_log_bsize + 1;
 346         fs->e2fs_qbmask = fs->e2fs_bsize - 1;
 347         fs->e2fs_fsize = EXT2_MIN_FRAG_SIZE << es->e2fs_log_fsize;
 348         if (fs->e2fs_fsize)
 349                 fs->e2fs_fpb = fs->e2fs_bsize / fs->e2fs_fsize;
 350         fs->e2fs_bpg = es->e2fs_bpg;
 351         fs->e2fs_fpg = es->e2fs_fpg;
 352         fs->e2fs_ipg = es->e2fs_ipg;
 353         if (es->e2fs_rev == E2FS_REV0) {
 354                 fs->e2fs_isize = E2FS_REV0_INODE_SIZE;
 355         } else {
 356                 fs->e2fs_isize = es->e2fs_inode_size;
 357
 358                 /*
 359                  * Simple sanity check for superblock inode size value.
 360                  */
 361                 if (EXT2_INODE_SIZE(fs) < E2FS_REV0_INODE_SIZE ||
 362                     EXT2_INODE_SIZE(fs) > fs->e2fs_bsize ||
 363                     (fs->e2fs_isize & (fs->e2fs_isize - 1)) != 0) {
 364                         printf("ext2fs: invalid inode size %d\n",
 365                             fs->e2fs_isize);
 366                         return (EIO);
 367                 }
 368         }
 369         /* Check for extra isize in big inodes. */
 370         if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_EXTRA_ISIZE) &&
 371             EXT2_INODE_SIZE(fs) < sizeof(struct ext2fs_dinode)) {
 372                 printf("ext2fs: no space for extra inode timestamps\n");
 373                 return (EINVAL);
 374         }
 375         /* Check checksum features */
 376         if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM) &&
 377             EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) {
 378                 printf("ext2fs: incorrect checksum features combination\n");
 379                 return (EINVAL);
 380         }
 381         /* Check for group descriptor size */
 382         if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT) &&
 383             (es->e3fs_desc_size != sizeof(struct ext2_gd))) {
 384                 printf("ext2fs: group descriptor size unsupported %d\n",
 385                     es->e3fs_desc_size);
 386                 return (EINVAL);
 387         }
 388
 389         fs->e2fs_ipb = fs->e2fs_bsize / EXT2_INODE_SIZE(fs);
 390         fs->e2fs_itpg = fs->e2fs_ipg / fs->e2fs_ipb;
 391         /* s_resuid / s_resgid ? */
 392         fs->e2fs_gcount = howmany(fs->e2fs_bcount - es->e2fs_first_dblock,
 393             EXT2_BLOCKS_PER_GROUP(fs));
 394         if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT)) {
 395                 e2fs_descpb = fs->e2fs_bsize / sizeof(struct ext2_gd);
 396                 e2fs_gdbcount_alloc = howmany(fs->e2fs_gcount, e2fs_descpb);
 397         } else {
 398                 e2fs_descpb = fs->e2fs_bsize / E2FS_REV0_GD_SIZE;
 399                 e2fs_gdbcount_alloc = howmany(fs->e2fs_gcount,
 400                     fs->e2fs_bsize / sizeof(struct ext2_gd));
 401         }
 402         fs->e2fs_gdbcount = howmany(fs->e2fs_gcount, e2fs_descpb);
 403         fs->e2fs_gd = mallocarray(e2fs_gdbcount_alloc, fs->e2fs_bsize,
 404             M_EXT2MNT, M_WAITOK | M_ZERO);
 405         fs->e2fs_contigdirs = mallocarray(fs->e2fs_gcount,
 406             sizeof(*fs->e2fs_contigdirs), M_EXT2MNT, M_WAITOK | M_ZERO);
 407
 408         /*
 409          * Adjust logic_sb_block.
 410          * Godmar thinks: if the blocksize is greater than 1024, then
 411          * the superblock is logically part of block zero.
 412          */
 413         if (fs->e2fs_bsize > SBSIZE)
 414                 logic_sb_block = 0;
 415         for (i = 0; i < fs->e2fs_gdbcount; i++) {
 416                 error = bread(devvp,
 417                     fsbtodb(fs, logic_sb_block + i + 1),
 418                     fs->e2fs_bsize, NOCRED, &bp);
 419                 if (error) {
 420                         free(fs->e2fs_contigdirs, M_EXT2MNT);
 421                         free(fs->e2fs_gd, M_EXT2MNT);
 422                         brelse(bp);
 423                         return (error);
 424                 }
 425                 if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT)) {
 426                         memcpy(&fs->e2fs_gd[
 427                             i * fs->e2fs_bsize / sizeof(struct ext2_gd)],
 428                             bp->b_data, fs->e2fs_bsize);
 429                 } else {
 430                         for (j = 0; j < e2fs_descpb &&
 431                             g_count < fs->e2fs_gcount; j++, g_count++)
 432                                 memcpy(&fs->e2fs_gd[g_count],
 433                                     bp->b_data + j * E2FS_REV0_GD_SIZE,
 434                                     E2FS_REV0_GD_SIZE);
 435                 }
 436                 brelse(bp);
 437                 bp = NULL;
 438         }
 439         /* Precompute checksum seed for all metadata */
 440         ext2_sb_csum_set_seed(fs);
 441         /* Verfy cg csum */
 442         if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM) ||
 443             EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) {
 444                 error = ext2_gd_csum_verify(fs, devvp->v_rdev);
 445                 if (error)
 446                         return (error);
 447         }
 448         /* Initialization for the ext2 Orlov allocator variant. */
 449         fs->e2fs_total_dir = 0;
 450         for (i = 0; i < fs->e2fs_gcount; i++)
 451                 fs->e2fs_total_dir += e2fs_gd_get_ndirs(&fs->e2fs_gd[i]);
 452
 453         if (es->e2fs_rev == E2FS_REV0 ||
 454             !EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_LARGEFILE))
 455                 fs->e2fs_maxfilesize = 0x7fffffff;
 456         else {
 457                 fs->e2fs_maxfilesize = 0xffffffffffff;
 458                 if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_HUGE_FILE))
 459                         fs->e2fs_maxfilesize = 0x7fffffffffffffff;
 460         }
 461         if (es->e4fs_flags & E2FS_UNSIGNED_HASH) {
 462                 fs->e2fs_uhash = 3;
 463         } else if ((es->e4fs_flags & E2FS_SIGNED_HASH) == 0) {
 464 #ifdef __CHAR_UNSIGNED__
 465                 es->e4fs_flags |= E2FS_UNSIGNED_HASH;
 466                 fs->e2fs_uhash = 3;
 467 #else
 468                 es->e4fs_flags |= E2FS_SIGNED_HASH;
 469 #endif
 470         }
 471         if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))
 472                 error = ext2_sb_csum_verify(fs);
 473
 474         return (error);
 475 }
 476
 477 /*
 478  * Reload all incore data for a filesystem (used after running fsck on
 479  * the root filesystem and finding things to fix). The filesystem must
 480  * be mounted read-only.
 481  *
 482  * Things to do to update the mount:
 483  *      1) invalidate all cached meta-data.
 484  *      2) re-read superblock from disk.
 485  *      3) invalidate all cluster summary information.
 486  *      4) invalidate all inactive vnodes.
 487  *      5) invalidate all cached file data.
 488  *      6) re-read inode data for all active vnodes.
 489  * XXX we are missing some steps, in particular # 3, this has to be reviewed.
 490  */
 491 static int
 492 ext2_reload(struct mount *mp, struct thread *td)
 493 {
 494         struct vnode *vp, *mvp, *devvp;
 495         struct inode *ip;
 496         struct buf *bp;
 497         struct ext2fs *es;
 498         struct m_ext2fs *fs;
 499         struct csum *sump;
 500         int error, i;
 501         int32_t *lp;
 502
 503         if ((mp->mnt_flag & MNT_RDONLY) == 0)
 504                 return (EINVAL);
 505         /*
 506          * Step 1: invalidate all cached meta-data.
 507          */
 508         devvp = VFSTOEXT2(mp)->um_devvp;
 509         vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
 510         if (vinvalbuf(devvp, 0, 0, 0) != 0)
 511                 panic("ext2_reload: dirty1");
 512         VOP_UNLOCK(devvp, 0);
 513
 514         /*
 515          * Step 2: re-read superblock from disk.
 516          * constants have been adjusted for ext2
 517          */
 518         if ((error = bread(devvp, SBLOCK, SBSIZE, NOCRED, &bp)) != 0)
 519                 return (error);
 520         es = (struct ext2fs *)bp->b_data;
 521         if (ext2_check_sb_compat(es, devvp->v_rdev, 0) != 0) {
 522                 brelse(bp);
 523                 return (EIO);           /* XXX needs translation */
 524         }
 525         fs = VFSTOEXT2(mp)->um_e2fs;
 526         bcopy(bp->b_data, fs->e2fs, sizeof(struct ext2fs));
 527
 528         if ((error = compute_sb_data(devvp, es, fs)) != 0) {
 529                 brelse(bp);
 530                 return (error);
 531         }
 532 #ifdef UNKLAR
 533         if (fs->fs_sbsize < SBSIZE)
 534                 bp->b_flags |= B_INVAL;
 535 #endif
 536         brelse(bp);
 537
 538         /*
 539          * Step 3: invalidate all cluster summary information.
 540          */
 541         if (fs->e2fs_contigsumsize > 0) {
 542                 lp = fs->e2fs_maxcluster;
 543                 sump = fs->e2fs_clustersum;
 544                 for (i = 0; i < fs->e2fs_gcount; i++, sump++) {
 545                         *lp++ = fs->e2fs_contigsumsize;
 546                         sump->cs_init = 0;
 547                         bzero(sump->cs_sum, fs->e2fs_contigsumsize + 1);
 548                 }
 549         }
 550
 551 loop:
 552         MNT_VNODE_FOREACH_ALL(vp, mp, mvp) {
 553                 /*
 554                  * Step 4: invalidate all cached file data.
 555                  */
 556                 if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) {
 557                         MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);
 558                         goto loop;
 559                 }
 560                 if (vinvalbuf(vp, 0, 0, 0))
 561                         panic("ext2_reload: dirty2");
 562
 563                 /*
 564                  * Step 5: re-read inode data for all active vnodes.
 565                  */
 566                 ip = VTOI(vp);
 567                 error = bread(devvp, fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
 568                     (int)fs->e2fs_bsize, NOCRED, &bp);
 569                 if (error) {
 570                         VOP_UNLOCK(vp, 0);
 571                         vrele(vp);
 572                         MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);
 573                         return (error);
 574                 }
 575                 ext2_ei2i((struct ext2fs_dinode *)((char *)bp->b_data +
 576                     EXT2_INODE_SIZE(fs) * ino_to_fsbo(fs, ip->i_number)), ip);
 577                 brelse(bp);
 578                 VOP_UNLOCK(vp, 0);
 579                 vrele(vp);
 580         }
 581         return (0);
 582 }
 583
 584 /*
 585  * Common code for mount and mountroot.
 586  */
 587 static int
 588 ext2_mountfs(struct vnode *devvp, struct mount *mp)
 589 {
 590         struct ext2mount *ump;
 591         struct buf *bp;
 592         struct m_ext2fs *fs;
 593         struct ext2fs *es;
 594         struct cdev *dev = devvp->v_rdev;
 595         struct g_consumer *cp;
 596         struct bufobj *bo;
 597         struct csum *sump;
 598         int error;
 599         int ronly;
 600         int i;
 601         u_long size;
 602         int32_t *lp;
 603         int32_t e2fs_maxcontig;
 604
 605         ronly = vfs_flagopt(mp->mnt_optnew, "ro", NULL, 0);
 606         /* XXX: use VOP_ACESS to check FS perms */
 607         g_topology_lock();
 608         error = g_vfs_open(devvp, &cp, "ext2fs", ronly ? 0 : 1);
 609         g_topology_unlock();
 610         VOP_UNLOCK(devvp, 0);
 611         if (error)
 612                 return (error);
 613
 614         /* XXX: should we check for some sectorsize or 512 instead? */
 615         if (((SBSIZE % cp->provider->sectorsize) != 0) ||
 616             (SBSIZE < cp->provider->sectorsize)) {
 617                 g_topology_lock();
 618                 g_vfs_close(cp);
 619                 g_topology_unlock();
 620                 return (EINVAL);
 621         }
 622
 623         bo = &devvp->v_bufobj;
 624         bo->bo_private = cp;
 625         bo->bo_ops = g_vfs_bufops;
 626         if (devvp->v_rdev->si_iosize_max != 0)
 627                 mp->mnt_iosize_max = devvp->v_rdev->si_iosize_max;
 628         if (mp->mnt_iosize_max > MAXPHYS)
 629                 mp->mnt_iosize_max = MAXPHYS;
 630
 631         bp = NULL;
 632         ump = NULL;
 633         if ((error = bread(devvp, SBLOCK, SBSIZE, NOCRED, &bp)) != 0)
 634                 goto out;
 635         es = (struct ext2fs *)bp->b_data;
 636         if (ext2_check_sb_compat(es, dev, ronly) != 0) {
 637                 error = EINVAL;         /* XXX needs translation */
 638                 goto out;
 639         }
 640         if ((es->e2fs_state & E2FS_ISCLEAN) == 0 ||
 641             (es->e2fs_state & E2FS_ERRORS)) {
 642                 if (ronly || (mp->mnt_flag & MNT_FORCE)) {
 643                         printf(
 644 "WARNING: Filesystem was not properly dismounted\n");
 645                 } else {
 646                         printf(
 647 "WARNING: R/W mount denied.  Filesystem is not clean - run fsck\n");
 648                         error = EPERM;
 649                         goto out;
 650                 }
 651         }
 652         ump = malloc(sizeof(*ump), M_EXT2MNT, M_WAITOK | M_ZERO);
 653
 654         /*
 655          * I don't know whether this is the right strategy. Note that
 656          * we dynamically allocate both an m_ext2fs and an ext2fs
 657          * while Linux keeps the super block in a locked buffer.
 658          */
 659         ump->um_e2fs = malloc(sizeof(struct m_ext2fs),
 660             M_EXT2MNT, M_WAITOK | M_ZERO);
 661         ump->um_e2fs->e2fs = malloc(sizeof(struct ext2fs),
 662             M_EXT2MNT, M_WAITOK);
 663         mtx_init(EXT2_MTX(ump), "EXT2FS", "EXT2FS Lock", MTX_DEF);
 664         bcopy(es, ump->um_e2fs->e2fs, (u_int)sizeof(struct ext2fs));
 665         if ((error = compute_sb_data(devvp, ump->um_e2fs->e2fs, ump->um_e2fs)))
 666                 goto out;
 667
 668         /*
 669          * Calculate the maximum contiguous blocks and size of cluster summary
 670          * array.  In FFS this is done by newfs; however, the superblock
 671          * in ext2fs doesn't have these variables, so we can calculate
 672          * them here.
 673          */
 674         e2fs_maxcontig = MAX(1, MAXPHYS / ump->um_e2fs->e2fs_bsize);
 675         ump->um_e2fs->e2fs_contigsumsize = MIN(e2fs_maxcontig, EXT2_MAXCONTIG);
 676         if (ump->um_e2fs->e2fs_contigsumsize > 0) {
 677                 size = ump->um_e2fs->e2fs_gcount * sizeof(int32_t);
 678                 ump->um_e2fs->e2fs_maxcluster = malloc(size, M_EXT2MNT, M_WAITOK);
 679                 size = ump->um_e2fs->e2fs_gcount * sizeof(struct csum);
 680                 ump->um_e2fs->e2fs_clustersum = malloc(size, M_EXT2MNT, M_WAITOK);
 681                 lp = ump->um_e2fs->e2fs_maxcluster;
 682                 sump = ump->um_e2fs->e2fs_clustersum;
 683                 for (i = 0; i < ump->um_e2fs->e2fs_gcount; i++, sump++) {
 684                         *lp++ = ump->um_e2fs->e2fs_contigsumsize;
 685                         sump->cs_init = 0;
 686                         sump->cs_sum = mallocarray(
 687                             ump->um_e2fs->e2fs_contigsumsize + 1,
 688                             sizeof(int32_t), M_EXT2MNT, M_WAITOK | M_ZERO);
 689                 }
 690         }
 691
 692         brelse(bp);
 693         bp = NULL;
 694         fs = ump->um_e2fs;
 695         fs->e2fs_ronly = ronly; /* ronly is set according to mnt_flags */
 696
 697         /*
 698          * If the fs is not mounted read-only, make sure the super block is
 699          * always written back on a sync().
 700          */
 701         fs->e2fs_wasvalid = fs->e2fs->e2fs_state & E2FS_ISCLEAN ? 1 : 0;
 702         if (ronly == 0) {
 703                 fs->e2fs_fmod = 1;      /* mark it modified */
 704                 fs->e2fs->e2fs_state &= ~E2FS_ISCLEAN;  /* set fs invalid */
 705         }
 706         mp->mnt_data = ump;
 707         mp->mnt_stat.f_fsid.val[0] = dev2udev(dev);
 708         mp->mnt_stat.f_fsid.val[1] = mp->mnt_vfc->vfc_typenum;
 709         mp->mnt_maxsymlinklen = EXT2_MAXSYMLINKLEN;
 710         MNT_ILOCK(mp);
 711         mp->mnt_flag |= MNT_LOCAL;
 712         MNT_IUNLOCK(mp);
 713         ump->um_mountp = mp;
 714         ump->um_dev = dev;
 715         ump->um_devvp = devvp;
 716         ump->um_bo = &devvp->v_bufobj;
 717         ump->um_cp = cp;
 718
 719         /*
 720          * Setting those two parameters allowed us to use
 721          * ufs_bmap w/o changse!
 722          */
 723         ump->um_nindir = EXT2_ADDR_PER_BLOCK(fs);
 724         ump->um_bptrtodb = fs->e2fs->e2fs_log_bsize + 1;
 725         ump->um_seqinc = EXT2_FRAGS_PER_BLOCK(fs);
 726         if (ronly == 0)
 727                 ext2_sbupdate(ump, MNT_WAIT);
 728         /*
 729          * Initialize filesystem stat information in mount struct.
 730          */
 731         MNT_ILOCK(mp);
 732         mp->mnt_kern_flag |= MNTK_LOOKUP_SHARED | MNTK_EXTENDED_SHARED |
 733             MNTK_USES_BCACHE;
 734         MNT_IUNLOCK(mp);
 735         return (0);
 736 out:
 737         if (bp)
 738                 brelse(bp);
 739         if (cp != NULL) {
 740                 g_topology_lock();
 741                 g_vfs_close(cp);
 742                 g_topology_unlock();
 743         }
 744         if (ump) {
 745                 mtx_destroy(EXT2_MTX(ump));
 746                 free(ump->um_e2fs->e2fs_gd, M_EXT2MNT);
 747                 free(ump->um_e2fs->e2fs_contigdirs, M_EXT2MNT);
 748                 free(ump->um_e2fs->e2fs, M_EXT2MNT);
 749                 free(ump->um_e2fs, M_EXT2MNT);
 750                 free(ump, M_EXT2MNT);
 751                 mp->mnt_data = NULL;
 752         }
 753         return (error);
 754 }
 755
 756 /*
 757  * Unmount system call.
 758  */
 759 static int
 760 ext2_unmount(struct mount *mp, int mntflags)
 761 {
 762         struct ext2mount *ump;
 763         struct m_ext2fs *fs;
 764         struct csum *sump;
 765         int error, flags, i, ronly;
 766
 767         flags = 0;
 768         if (mntflags & MNT_FORCE) {
 769                 if (mp->mnt_flag & MNT_ROOTFS)
 770                         return (EINVAL);
 771                 flags |= FORCECLOSE;
 772         }
 773         if ((error = ext2_flushfiles(mp, flags, curthread)) != 0)
 774                 return (error);
 775         ump = VFSTOEXT2(mp);
 776         fs = ump->um_e2fs;
 777         ronly = fs->e2fs_ronly;
 778         if (ronly == 0 && ext2_cgupdate(ump, MNT_WAIT) == 0) {
 779                 if (fs->e2fs_wasvalid)
 780                         fs->e2fs->e2fs_state |= E2FS_ISCLEAN;
 781                 ext2_sbupdate(ump, MNT_WAIT);
 782         }
 783
 784         g_topology_lock();
 785         g_vfs_close(ump->um_cp);
 786         g_topology_unlock();
 787         vrele(ump->um_devvp);
 788         sump = fs->e2fs_clustersum;
 789         for (i = 0; i < fs->e2fs_gcount; i++, sump++)
 790                 free(sump->cs_sum, M_EXT2MNT);
 791         free(fs->e2fs_clustersum, M_EXT2MNT);
 792         free(fs->e2fs_maxcluster, M_EXT2MNT);
 793         free(fs->e2fs_gd, M_EXT2MNT);
 794         free(fs->e2fs_contigdirs, M_EXT2MNT);
 795         free(fs->e2fs, M_EXT2MNT);
 796         free(fs, M_EXT2MNT);
 797         free(ump, M_EXT2MNT);
 798         mp->mnt_data = NULL;
 799         MNT_ILOCK(mp);
 800         mp->mnt_flag &= ~MNT_LOCAL;
 801         MNT_IUNLOCK(mp);
 802         return (error);
 803 }
 804
 805 /*
 806  * Flush out all the files in a filesystem.
 807  */
 808 static int
 809 ext2_flushfiles(struct mount *mp, int flags, struct thread *td)
 810 {
 811         int error;
 812
 813         error = vflush(mp, 0, flags, td);
 814         return (error);
 815 }
 816
 817 /*
 818  * Get filesystem statistics.
 819  */
 820 int
 821 ext2_statfs(struct mount *mp, struct statfs *sbp)
 822 {
 823         struct ext2mount *ump;
 824         struct m_ext2fs *fs;
 825         uint32_t overhead, overhead_per_group, ngdb;
 826         int i, ngroups;
 827
 828         ump = VFSTOEXT2(mp);
 829         fs = ump->um_e2fs;
 830         if (fs->e2fs->e2fs_magic != E2FS_MAGIC)
 831                 panic("ext2_statfs");
 832
 833         /*
 834          * Compute the overhead (FS structures)
 835          */
 836         overhead_per_group =
 837             1 /* block bitmap */ +
 838             1 /* inode bitmap */ +
 839             fs->e2fs_itpg;
 840         overhead = fs->e2fs->e2fs_first_dblock +
 841             fs->e2fs_gcount * overhead_per_group;
 842         if (fs->e2fs->e2fs_rev > E2FS_REV0 &&
 843             fs->e2fs->e2fs_features_rocompat & EXT2F_ROCOMPAT_SPARSESUPER) {
 844                 for (i = 0, ngroups = 0; i < fs->e2fs_gcount; i++) {
 845                         if (ext2_cg_has_sb(fs, i))
 846                                 ngroups++;
 847                 }
 848         } else {
 849                 ngroups = fs->e2fs_gcount;
 850         }
 851         ngdb = fs->e2fs_gdbcount;
 852         if (fs->e2fs->e2fs_rev > E2FS_REV0 &&
 853             fs->e2fs->e2fs_features_compat & EXT2F_COMPAT_RESIZE)
 854                 ngdb += fs->e2fs->e2fs_reserved_ngdb;
 855         overhead += ngroups * (1 /* superblock */ + ngdb);
 856
 857         sbp->f_bsize = EXT2_FRAG_SIZE(fs);
 858         sbp->f_iosize = EXT2_BLOCK_SIZE(fs);
 859         sbp->f_blocks = fs->e2fs_bcount - overhead;
 860         sbp->f_bfree = fs->e2fs_fbcount;
 861         sbp->f_bavail = sbp->f_bfree - fs->e2fs_rbcount;
 862         sbp->f_files = fs->e2fs->e2fs_icount;
 863         sbp->f_ffree = fs->e2fs->e2fs_ficount;
 864         return (0);
 865 }
 866
 867 /*
 868  * Go through the disk queues to initiate sandbagged IO;
 869  * go through the inodes to write those that have been modified;
 870  * initiate the writing of the super block if it has been modified.
 871  *
 872  * Note: we are always called with the filesystem marked `MPBUSY'.
 873  */
 874 static int
 875 ext2_sync(struct mount *mp, int waitfor)
 876 {
 877         struct vnode *mvp, *vp;
 878         struct thread *td;
 879         struct inode *ip;
 880         struct ext2mount *ump = VFSTOEXT2(mp);
 881         struct m_ext2fs *fs;
 882         int error, allerror = 0;
 883
 884         td = curthread;
 885         fs = ump->um_e2fs;
 886         if (fs->e2fs_fmod != 0 && fs->e2fs_ronly != 0) {                /* XXX */
 887                 printf("fs = %s\n", fs->e2fs_fsmnt);
 888                 panic("ext2_sync: rofs mod");
 889         }
 890
 891         /*
 892          * Write back each (modified) inode.
 893          */
 894 loop:
 895         MNT_VNODE_FOREACH_ALL(vp, mp, mvp) {
 896                 if (vp->v_type == VNON) {
 897                         VI_UNLOCK(vp);
 898                         continue;
 899                 }
 900                 ip = VTOI(vp);
 901                 if ((ip->i_flag &
 902                     (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) == 0 &&
 903                     (vp->v_bufobj.bo_dirty.bv_cnt == 0 ||
 904                     waitfor == MNT_LAZY)) {
 905                         VI_UNLOCK(vp);
 906                         continue;
 907                 }
 908                 error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK, td);
 909                 if (error) {
 910                         if (error == ENOENT) {
 911                                 MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);
 912                                 goto loop;
 913                         }
 914                         continue;
 915                 }
 916                 if ((error = VOP_FSYNC(vp, waitfor, td)) != 0)
 917                         allerror = error;
 918                 VOP_UNLOCK(vp, 0);
 919                 vrele(vp);
 920         }
 921
 922         /*
 923          * Force stale filesystem control information to be flushed.
 924          */
 925         if (waitfor != MNT_LAZY) {
 926                 vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
 927                 if ((error = VOP_FSYNC(ump->um_devvp, waitfor, td)) != 0)
 928                         allerror = error;
 929                 VOP_UNLOCK(ump->um_devvp, 0);
 930         }
 931
 932         /*
 933          * Write back modified superblock.
 934          */
 935         if (fs->e2fs_fmod != 0) {
 936                 fs->e2fs_fmod = 0;
 937                 fs->e2fs->e2fs_wtime = time_second;
 938                 if ((error = ext2_cgupdate(ump, waitfor)) != 0)
 939                         allerror = error;
 940         }
 941         return (allerror);
 942 }
 943
 944 /*
 945  * Look up an EXT2FS dinode number to find its incore vnode, otherwise read it
 946  * in from disk.  If it is in core, wait for the lock bit to clear, then
 947  * return the inode locked.  Detection and handling of mount points must be
 948  * done by the calling routine.
 949  */
 950 static int
 951 ext2_vget(struct mount *mp, ino_t ino, int flags, struct vnode **vpp)
 952 {
 953         struct m_ext2fs *fs;
 954         struct inode *ip;
 955         struct ext2mount *ump;
 956         struct buf *bp;
 957         struct vnode *vp;
 958         struct thread *td;
 959         int i, error;
 960         int used_blocks;
 961
 962         td = curthread;
 963         error = vfs_hash_get(mp, ino, flags, td, vpp, NULL, NULL);
 964         if (error || *vpp != NULL)
 965                 return (error);
 966
 967         ump = VFSTOEXT2(mp);
 968         ip = malloc(sizeof(struct inode), M_EXT2NODE, M_WAITOK | M_ZERO);
 969
 970         /* Allocate a new vnode/inode. */
 971         if ((error = getnewvnode("ext2fs", mp, &ext2_vnodeops, &vp)) != 0) {
 972                 *vpp = NULL;
 973                 free(ip, M_EXT2NODE);
 974                 return (error);
 975         }
 976         vp->v_data = ip;
 977         ip->i_vnode = vp;
 978         ip->i_e2fs = fs = ump->um_e2fs;
 979         ip->i_ump = ump;
 980         ip->i_number = ino;
 981
 982         lockmgr(vp->v_vnlock, LK_EXCLUSIVE, NULL);
 983         error = insmntque(vp, mp);
 984         if (error != 0) {
 985                 free(ip, M_EXT2NODE);
 986                 *vpp = NULL;
 987                 return (error);
 988         }
 989         error = vfs_hash_insert(vp, ino, flags, td, vpp, NULL, NULL);
 990         if (error || *vpp != NULL)
 991                 return (error);
 992
 993         /* Read in the disk contents for the inode, copy into the inode. */
 994         if ((error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ino)),
 995             (int)fs->e2fs_bsize, NOCRED, &bp)) != 0) {
 996                 /*
 997                  * The inode does not contain anything useful, so it would
 998                  * be misleading to leave it on its hash chain. With mode
 999                  * still zero, it will be unlinked and returned to the free
1000                  * list by vput().
1001                  */
1002                 brelse(bp);
1003                 vput(vp);
1004                 *vpp = NULL;
1005                 return (error);
1006         }
1007         /* convert ext2 inode to dinode */
1008         error = ext2_ei2i((struct ext2fs_dinode *)((char *)bp->b_data +
1009             EXT2_INODE_SIZE(fs) * ino_to_fsbo(fs, ino)), ip);
1010         if (error) {
1011                 printf("ext2fs: Bad inode %lu csum - run fsck\n",
1012                     (unsigned long)ino);
1013                 brelse(bp);
1014                 vput(vp);
1015                 *vpp = NULL;
1016                 return (error);
1017         }
1018         ip->i_block_group = ino_to_cg(fs, ino);
1019         ip->i_next_alloc_block = 0;
1020         ip->i_next_alloc_goal = 0;
1021
1022         /*
1023          * Now we want to make sure that block pointers for unused
1024          * blocks are zeroed out - ext2_balloc depends on this
1025          * although for regular files and directories only
1026          *
1027          * If IN_E4EXTENTS is enabled, unused blocks are not zeroed
1028          * out because we could corrupt the extent tree.
1029          */
1030         if (!(ip->i_flag & IN_E4EXTENTS) &&
1031             (S_ISDIR(ip->i_mode) || S_ISREG(ip->i_mode))) {
1032                 used_blocks = howmany(ip->i_size, fs->e2fs_bsize);
1033                 for (i = used_blocks; i < EXT2_NDIR_BLOCKS; i++)
1034                         ip->i_db[i] = 0;
1035         }
1036 #ifdef EXT2FS_DEBUG
1037         ext2_print_inode(ip);
1038         ext4_ext_print_extent_tree_status(ip);
1039 #endif
1040         bqrelse(bp);
1041
1042         /*
1043          * Initialize the vnode from the inode, check for aliases.
1044          * Note that the underlying vnode may have changed.
1045          */
1046         if ((error = ext2_vinit(mp, &ext2_fifoops, &vp)) != 0) {
1047                 vput(vp);
1048                 *vpp = NULL;
1049                 return (error);
1050         }
1051
1052         /*
1053          * Finish inode initialization.
1054          */
1055
1056         *vpp = vp;
1057         return (0);
1058 }
1059
1060 /*
1061  * File handle to vnode
1062  *
1063  * Have to be really careful about stale file handles:
1064  * - check that the inode number is valid
1065  * - call ext2_vget() to get the locked inode
1066  * - check for an unallocated inode (i_mode == 0)
1067  * - check that the given client host has export rights and return
1068  *   those rights via. exflagsp and credanonp
1069  */
1070 static int
1071 ext2_fhtovp(struct mount *mp, struct fid *fhp, int flags, struct vnode **vpp)
1072 {
1073         struct inode *ip;
1074         struct ufid *ufhp;
1075         struct vnode *nvp;
1076         struct m_ext2fs *fs;
1077         int error;
1078
1079         ufhp = (struct ufid *)fhp;
1080         fs = VFSTOEXT2(mp)->um_e2fs;
1081         if (ufhp->ufid_ino < EXT2_ROOTINO ||
1082             ufhp->ufid_ino > fs->e2fs_gcount * fs->e2fs->e2fs_ipg)
1083                 return (ESTALE);
1084
1085         error = VFS_VGET(mp, ufhp->ufid_ino, LK_EXCLUSIVE, &nvp);
1086         if (error) {
1087                 *vpp = NULLVP;
1088                 return (error);
1089         }
1090         ip = VTOI(nvp);
1091         if (ip->i_mode == 0 ||
1092             ip->i_gen != ufhp->ufid_gen || ip->i_nlink <= 0) {
1093                 vput(nvp);
1094                 *vpp = NULLVP;
1095                 return (ESTALE);
1096         }
1097         *vpp = nvp;
1098         vnode_create_vobject(*vpp, 0, curthread);
1099         return (0);
1100 }
1101
1102 /*
1103  * Write a superblock and associated information back to disk.
1104  */
1105 static int
1106 ext2_sbupdate(struct ext2mount *mp, int waitfor)
1107 {
1108         struct m_ext2fs *fs = mp->um_e2fs;
1109         struct ext2fs *es = fs->e2fs;
1110         struct buf *bp;
1111         int error = 0;
1112
1113         es->e2fs_bcount = fs->e2fs_bcount & 0xffffffff;
1114         es->e2fs_rbcount = fs->e2fs_rbcount & 0xffffffff;
1115         es->e2fs_fbcount = fs->e2fs_fbcount & 0xffffffff;
1116         if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT)) {
1117                 es->e4fs_bcount_hi = fs->e2fs_bcount >> 32;
1118                 es->e4fs_rbcount_hi = fs->e2fs_rbcount >> 32;
1119                 es->e4fs_fbcount_hi = fs->e2fs_fbcount >> 32;
1120         }
1121
1122         if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))
1123                 ext2_sb_csum_set(fs);
1124
1125         bp = getblk(mp->um_devvp, SBLOCK, SBSIZE, 0, 0, 0);
1126         bcopy((caddr_t)es, bp->b_data, (u_int)sizeof(struct ext2fs));
1127         if (waitfor == MNT_WAIT)
1128                 error = bwrite(bp);
1129         else
1130                 bawrite(bp);
1131
1132         /*
1133          * The buffers for group descriptors, inode bitmaps and block bitmaps
1134          * are not busy at this point and are (hopefully) written by the
1135          * usual sync mechanism. No need to write them here.
1136          */
1137         return (error);
1138 }
1139 int
1140 ext2_cgupdate(struct ext2mount *mp, int waitfor)
1141 {
1142         struct m_ext2fs *fs = mp->um_e2fs;
1143         struct buf *bp;
1144         int i, j, g_count = 0, error = 0, allerror = 0;
1145
1146         allerror = ext2_sbupdate(mp, waitfor);
1147
1148         /* Update gd csums */
1149         if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM) ||
1150             EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))
1151                 ext2_gd_csum_set(fs);
1152
1153         for (i = 0; i < fs->e2fs_gdbcount; i++) {
1154                 bp = getblk(mp->um_devvp, fsbtodb(fs,
1155                     fs->e2fs->e2fs_first_dblock +
1156                     1 /* superblock */ + i), fs->e2fs_bsize, 0, 0, 0);
1157                 if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT)) {
1158                         memcpy(bp->b_data, &fs->e2fs_gd[
1159                             i * fs->e2fs_bsize / sizeof(struct ext2_gd)],
1160                             fs->e2fs_bsize);
1161                 } else {
1162                         for (j = 0; j < fs->e2fs_bsize / E2FS_REV0_GD_SIZE &&
1163                             g_count < fs->e2fs_gcount; j++, g_count++)
1164                                 memcpy(bp->b_data + j * E2FS_REV0_GD_SIZE,
1165                                     &fs->e2fs_gd[g_count], E2FS_REV0_GD_SIZE);
1166                 }
1167                 if (waitfor == MNT_WAIT)
1168                         error = bwrite(bp);
1169                 else
1170                         bawrite(bp);
1171         }
1172
1173         if (!allerror && error)
1174                 allerror = error;
1175         return (allerror);
1176 }
1177
1178 /*
1179  * Return the root of a filesystem.
1180  */
1181 static int
1182 ext2_root(struct mount *mp, int flags, struct vnode **vpp)
1183 {
1184         struct vnode *nvp;
1185         int error;
1186
1187         error = VFS_VGET(mp, EXT2_ROOTINO, LK_EXCLUSIVE, &nvp);
1188         if (error)
1189                 return (error);
1190         *vpp = nvp;
1191         return (0);
1192 }