sys/ufs/ext2fs/ext2fs_vfsops.c

   1 /*      $NetBSD: ext2fs_vfsops.c,v 1.152 2009/10/21 17:37:21 pooka Exp $        */
   2
   3 /*
   4  * Copyright (c) 1989, 1991, 1993, 1994
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the University nor the names of its contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  *
  31  *      @(#)ffs_vfsops.c        8.14 (Berkeley) 11/28/94
  32  * Modified for ext2fs by Manuel Bouyer.
  33  */
  34
  35 /*
  36  * Copyright (c) 1997 Manuel Bouyer.
  37  *
  38  * Redistribution and use in source and binary forms, with or without
  39  * modification, are permitted provided that the following conditions
  40  * are met:
  41  * 1. Redistributions of source code must retain the above copyright
  42  *    notice, this list of conditions and the following disclaimer.
  43  * 2. Redistributions in binary form must reproduce the above copyright
  44  *    notice, this list of conditions and the following disclaimer in the
  45  *    documentation and/or other materials provided with the distribution.
  46  *
  47  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  48  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  49  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  50  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  51  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  52  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  53  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  54  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  55  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  56  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  57  *
  58  *      @(#)ffs_vfsops.c        8.14 (Berkeley) 11/28/94
  59  * Modified for ext2fs by Manuel Bouyer.
  60  */
  61
  62 #include <sys/cdefs.h>
  63 __KERNEL_RCSID(0, "$NetBSD: ext2fs_vfsops.c,v 1.152 2009/10/21 17:37:21 pooka Exp $");
  64
  65 #if defined(_KERNEL_OPT)
  66 #include "opt_compat_netbsd.h"
  67 #endif
  68
  69 #include <sys/param.h>
  70 #include <sys/systm.h>
  71 #include <sys/sysctl.h>
  72 #include <sys/namei.h>
  73 #include <sys/proc.h>
  74 #include <sys/kernel.h>
  75 #include <sys/vnode.h>
  76 #include <sys/socket.h>
  77 #include <sys/mount.h>
  78 #include <sys/buf.h>
  79 #include <sys/device.h>
  80 #include <sys/mbuf.h>
  81 #include <sys/file.h>
  82 #include <sys/disklabel.h>
  83 #include <sys/ioctl.h>
  84 #include <sys/errno.h>
  85 #include <sys/malloc.h>
  86 #include <sys/pool.h>
  87 #include <sys/lock.h>
  88 #include <sys/conf.h>
  89 #include <sys/kauth.h>
  90 #include <sys/module.h>
  91
  92 #include <miscfs/genfs/genfs.h>
  93 #include <miscfs/specfs/specdev.h>
  94
  95 #include <ufs/ufs/quota.h>
  96 #include <ufs/ufs/ufsmount.h>
  97 #include <ufs/ufs/inode.h>
  98 #include <ufs/ufs/dir.h>
  99 #include <ufs/ufs/ufs_extern.h>
 100
 101 #include <ufs/ext2fs/ext2fs.h>
 102 #include <ufs/ext2fs/ext2fs_dir.h>
 103 #include <ufs/ext2fs/ext2fs_extern.h>
 104
 105 MODULE(MODULE_CLASS_VFS, ext2fs, "ffs");
 106
 107 int ext2fs_sbupdate(struct ufsmount *, int);
 108 static int ext2fs_checksb(struct ext2fs *, int);
 109
 110 static struct sysctllog *ext2fs_sysctl_log;
 111
 112 extern const struct vnodeopv_desc ext2fs_vnodeop_opv_desc;
 113 extern const struct vnodeopv_desc ext2fs_specop_opv_desc;
 114 extern const struct vnodeopv_desc ext2fs_fifoop_opv_desc;
 115
 116 const struct vnodeopv_desc * const ext2fs_vnodeopv_descs[] = {
 117         &ext2fs_vnodeop_opv_desc,
 118         &ext2fs_specop_opv_desc,
 119         &ext2fs_fifoop_opv_desc,
 120         NULL,
 121 };
 122
 123 struct vfsops ext2fs_vfsops = {
 124         MOUNT_EXT2FS,
 125         sizeof (struct ufs_args),
 126         ext2fs_mount,
 127         ufs_start,
 128         ext2fs_unmount,
 129         ufs_root,
 130         ufs_quotactl,
 131         ext2fs_statvfs,
 132         ext2fs_sync,
 133         ext2fs_vget,
 134         ext2fs_fhtovp,
 135         ext2fs_vptofh,
 136         ext2fs_init,
 137         ext2fs_reinit,
 138         ext2fs_done,
 139         ext2fs_mountroot,
 140         (int (*)(struct mount *, struct vnode *, struct timespec *)) eopnotsupp,
 141         vfs_stdextattrctl,
 142         (void *)eopnotsupp,     /* vfs_suspendctl */
 143         genfs_renamelock_enter,
 144         genfs_renamelock_exit,
 145         (void *)eopnotsupp,
 146         ext2fs_vnodeopv_descs,
 147         0,
 148         { NULL, NULL },
 149 };
 150
 151 static const struct genfs_ops ext2fs_genfsops = {
 152         .gop_size = genfs_size,
 153         .gop_alloc = ext2fs_gop_alloc,
 154         .gop_write = genfs_gop_write,
 155         .gop_markupdate = ufs_gop_markupdate,
 156 };
 157
 158 static const struct ufs_ops ext2fs_ufsops = {
 159         .uo_itimes = ext2fs_itimes,
 160         .uo_update = ext2fs_update,
 161         .uo_vfree = ext2fs_vfree,
 162         .uo_unmark_vnode = (void (*)(vnode_t *))nullop,
 163 };
 164
 165 /* Fill in the inode uid/gid from ext2 halves.  */
 166 void
 167 ext2fs_set_inode_guid(struct inode *ip)
 168 {
 169
 170         ip->i_gid = ip->i_e2fs_gid;
 171         ip->i_uid = ip->i_e2fs_uid;
 172         if (ip->i_e2fs->e2fs.e2fs_rev > E2FS_REV0) {
 173                 ip->i_gid |= ip->i_e2fs_gid_high << 16;
 174                 ip->i_uid |= ip->i_e2fs_uid_high << 16;
 175         }
 176 }
 177
 178 static int
 179 ext2fs_modcmd(modcmd_t cmd, void *arg)
 180 {
 181         int error;
 182
 183         switch (cmd) {
 184         case MODULE_CMD_INIT:
 185                 error = vfs_attach(&ext2fs_vfsops);
 186                 if (error != 0)
 187                         break;
 188                 sysctl_createv(&ext2fs_sysctl_log, 0, NULL, NULL,
 189                                CTLFLAG_PERMANENT,
 190                                CTLTYPE_NODE, "vfs", NULL,
 191                                NULL, 0, NULL, 0,
 192                                CTL_VFS, CTL_EOL);
 193                 sysctl_createv(&ext2fs_sysctl_log, 0, NULL, NULL,
 194                                CTLFLAG_PERMANENT,
 195                                CTLTYPE_NODE, "ext2fs",
 196                                SYSCTL_DESCR("Linux EXT2FS file system"),
 197                                NULL, 0, NULL, 0,
 198                                CTL_VFS, 17, CTL_EOL);
 199                 /*
 200                  * XXX the "17" above could be dynamic, thereby eliminating
 201                  * one more instance of the "number to vfs" mapping problem,
 202                  * but "17" is the order as taken from sys/mount.h
 203                  */
 204                 break;
 205         case MODULE_CMD_FINI:
 206                 error = vfs_detach(&ext2fs_vfsops);
 207                 if (error != 0)
 208                         break;
 209                 sysctl_teardown(&ext2fs_sysctl_log);
 210                 break;
 211         default:
 212                 error = ENOTTY;
 213                 break;
 214         }
 215
 216         return (error);
 217 }
 218
 219 /*
 220  * XXX Same structure as FFS inodes?  Should we share a common pool?
 221  */
 222 struct pool ext2fs_inode_pool;
 223 struct pool ext2fs_dinode_pool;
 224
 225 extern u_long ext2gennumber;
 226
 227 void
 228 ext2fs_init(void)
 229 {
 230
 231         pool_init(&ext2fs_inode_pool, sizeof(struct inode), 0, 0, 0,
 232             "ext2fsinopl", &pool_allocator_nointr, IPL_NONE);
 233         pool_init(&ext2fs_dinode_pool, sizeof(struct ext2fs_dinode), 0, 0, 0,
 234             "ext2dinopl", &pool_allocator_nointr, IPL_NONE);
 235         ufs_init();
 236 }
 237
 238 void
 239 ext2fs_reinit(void)
 240 {
 241         ufs_reinit();
 242 }
 243
 244 void
 245 ext2fs_done(void)
 246 {
 247
 248         ufs_done();
 249         pool_destroy(&ext2fs_inode_pool);
 250         pool_destroy(&ext2fs_dinode_pool);
 251 }
 252
 253 /*
 254  * Called by main() when ext2fs is going to be mounted as root.
 255  *
 256  * Name is updated by mount(8) after booting.
 257  */
 258 #define ROOTNAME        "root_device"
 259
 260 int
 261 ext2fs_mountroot(void)
 262 {
 263         extern struct vnode *rootvp;
 264         struct m_ext2fs *fs;
 265         struct mount *mp;
 266         struct ufsmount *ump;
 267         int error;
 268
 269         if (device_class(root_device) != DV_DISK)
 270                 return (ENODEV);
 271
 272         if ((error = vfs_rootmountalloc(MOUNT_EXT2FS, "root_device", &mp))) {
 273                 vrele(rootvp);
 274                 return (error);
 275         }
 276
 277         if ((error = ext2fs_mountfs(rootvp, mp)) != 0) {
 278                 vfs_unbusy(mp, false, NULL);
 279                 vfs_destroy(mp);
 280                 return (error);
 281         }
 282         mutex_enter(&mountlist_lock);
 283         CIRCLEQ_INSERT_TAIL(&mountlist, mp, mnt_list);
 284         mutex_exit(&mountlist_lock);
 285         ump = VFSTOUFS(mp);
 286         fs = ump->um_e2fs;
 287         memset(fs->e2fs_fsmnt, 0, sizeof(fs->e2fs_fsmnt));
 288         (void) copystr(mp->mnt_stat.f_mntonname, fs->e2fs_fsmnt,
 289             sizeof(fs->e2fs_fsmnt) - 1, 0);
 290         if (fs->e2fs.e2fs_rev > E2FS_REV0) {
 291                 memset(fs->e2fs.e2fs_fsmnt, 0, sizeof(fs->e2fs.e2fs_fsmnt));
 292                 (void) copystr(mp->mnt_stat.f_mntonname, fs->e2fs.e2fs_fsmnt,
 293                     sizeof(fs->e2fs.e2fs_fsmnt) - 1, 0);
 294         }
 295         (void)ext2fs_statvfs(mp, &mp->mnt_stat);
 296         vfs_unbusy(mp, false, NULL);
 297         setrootfstime((time_t)fs->e2fs.e2fs_wtime);
 298         return (0);
 299 }
 300
 301 /*
 302  * VFS Operations.
 303  *
 304  * mount system call
 305  */
 306 int
 307 ext2fs_mount(struct mount *mp, const char *path, void *data, size_t *data_len)
 308 {
 309         struct lwp *l = curlwp;
 310         struct vnode *devvp;
 311         struct ufs_args *args = data;
 312         struct ufsmount *ump = NULL;
 313         struct m_ext2fs *fs;
 314         size_t size;
 315         int error = 0, flags, update;
 316         mode_t accessmode;
 317
 318         if (*data_len < sizeof *args)
 319                 return EINVAL;
 320
 321         if (mp->mnt_flag & MNT_GETARGS) {
 322                 ump = VFSTOUFS(mp);
 323                 if (ump == NULL)
 324                         return EIO;
 325                 memset(args, 0, sizeof *args);
 326                 args->fspec = NULL;
 327                 *data_len = sizeof *args;
 328                 return 0;
 329         }
 330
 331         update = mp->mnt_flag & MNT_UPDATE;
 332
 333         /* Check arguments */
 334         if (args->fspec != NULL) {
 335                 /*
 336                  * Look up the name and verify that it's sane.
 337                  */
 338                 error = namei_simple_user(args->fspec,
 339                                         NSM_FOLLOW_NOEMULROOT, &devvp);
 340                 if (error != 0)
 341                         return (error);
 342
 343                 if (!update) {
 344                         /*
 345                          * Be sure this is a valid block device
 346                          */
 347                         if (devvp->v_type != VBLK)
 348                                 error = ENOTBLK;
 349                         else if (bdevsw_lookup(devvp->v_rdev) == NULL)
 350                                 error = ENXIO;
 351                 } else {
 352                         /*
 353                          * Be sure we're still naming the same device
 354                          * used for our initial mount
 355                          */
 356                         ump = VFSTOUFS(mp);
 357                         if (devvp != ump->um_devvp) {
 358                                 if (devvp->v_rdev != ump->um_devvp->v_rdev)
 359                                         error = EINVAL;
 360                                 else {
 361                                         vrele(devvp);
 362                                         devvp = ump->um_devvp;
 363                                         vref(devvp);
 364                                 }
 365                         }
 366                 }
 367         } else {
 368                 if (!update) {
 369                         /* New mounts must have a filename for the device */
 370                         return (EINVAL);
 371                 } else {
 372                         ump = VFSTOUFS(mp);
 373                         devvp = ump->um_devvp;
 374                         vref(devvp);
 375                 }
 376         }
 377
 378         /*
 379          * If mount by non-root, then verify that user has necessary
 380          * permissions on the device.
 381          *
 382          * Permission to update a mount is checked higher, so here we presume
 383          * updating the mount is okay (for example, as far as securelevel goes)
 384          * which leaves us with the normal check.
 385          */
 386         if (error == 0) {
 387                 accessmode = VREAD;
 388                 if (update ?
 389                     (mp->mnt_iflag & IMNT_WANTRDWR) != 0 :
 390                     (mp->mnt_flag & MNT_RDONLY) == 0)
 391                         accessmode |= VWRITE;
 392                 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
 393                 error = genfs_can_mount(devvp, accessmode, l->l_cred);
 394                 VOP_UNLOCK(devvp, 0);
 395         }
 396
 397         if (error) {
 398                 vrele(devvp);
 399                 return (error);
 400         }
 401
 402         if (!update) {
 403                 int xflags;
 404
 405                 if (mp->mnt_flag & MNT_RDONLY)
 406                         xflags = FREAD;
 407                 else
 408                         xflags = FREAD|FWRITE;
 409                 error = VOP_OPEN(devvp, xflags, FSCRED);
 410                 if (error)
 411                         goto fail;
 412                 error = ext2fs_mountfs(devvp, mp);
 413                 if (error) {
 414                         vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
 415                         (void)VOP_CLOSE(devvp, xflags, NOCRED);
 416                         VOP_UNLOCK(devvp, 0);
 417                         goto fail;
 418                 }
 419
 420                 ump = VFSTOUFS(mp);
 421                 fs = ump->um_e2fs;
 422         } else {
 423                 /*
 424                  * Update the mount.
 425                  */
 426
 427                 /*
 428                  * The initial mount got a reference on this
 429                  * device, so drop the one obtained via
 430                  * namei(), above.
 431                  */
 432                 vrele(devvp);
 433
 434                 ump = VFSTOUFS(mp);
 435                 fs = ump->um_e2fs;
 436                 if (fs->e2fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
 437                         /*
 438                          * Changing from r/w to r/o
 439                          */
 440                         flags = WRITECLOSE;
 441                         if (mp->mnt_flag & MNT_FORCE)
 442                                 flags |= FORCECLOSE;
 443                         error = ext2fs_flushfiles(mp, flags);
 444                         if (error == 0 &&
 445                             ext2fs_cgupdate(ump, MNT_WAIT) == 0 &&
 446                             (fs->e2fs.e2fs_state & E2FS_ERRORS) == 0) {
 447                                 fs->e2fs.e2fs_state = E2FS_ISCLEAN;
 448                                 (void) ext2fs_sbupdate(ump, MNT_WAIT);
 449                         }
 450                         if (error)
 451                                 return (error);
 452                         fs->e2fs_ronly = 1;
 453                 }
 454
 455                 if (mp->mnt_flag & MNT_RELOAD) {
 456                         error = ext2fs_reload(mp, l->l_cred, l);
 457                         if (error)
 458                                 return (error);
 459                 }
 460
 461                 if (fs->e2fs_ronly && (mp->mnt_iflag & IMNT_WANTRDWR)) {
 462                         /*
 463                          * Changing from read-only to read/write
 464                          */
 465                         fs->e2fs_ronly = 0;
 466                         if (fs->e2fs.e2fs_state == E2FS_ISCLEAN)
 467                                 fs->e2fs.e2fs_state = 0;
 468                         else
 469                                 fs->e2fs.e2fs_state = E2FS_ERRORS;
 470                         fs->e2fs_fmod = 1;
 471                 }
 472                 if (args->fspec == NULL)
 473                         return 0;
 474         }
 475
 476         error = set_statvfs_info(path, UIO_USERSPACE, args->fspec,
 477             UIO_USERSPACE, mp->mnt_op->vfs_name, mp, l);
 478         (void) copystr(mp->mnt_stat.f_mntonname, fs->e2fs_fsmnt,
 479             sizeof(fs->e2fs_fsmnt) - 1, &size);
 480         memset(fs->e2fs_fsmnt + size, 0, sizeof(fs->e2fs_fsmnt) - size);
 481         if (fs->e2fs.e2fs_rev > E2FS_REV0) {
 482                 (void) copystr(mp->mnt_stat.f_mntonname, fs->e2fs.e2fs_fsmnt,
 483                     sizeof(fs->e2fs.e2fs_fsmnt) - 1, &size);
 484                 memset(fs->e2fs.e2fs_fsmnt, 0,
 485                     sizeof(fs->e2fs.e2fs_fsmnt) - size);
 486         }
 487         if (fs->e2fs_fmod != 0) {       /* XXX */
 488                 fs->e2fs_fmod = 0;
 489                 if (fs->e2fs.e2fs_state == 0)
 490                         fs->e2fs.e2fs_wtime = time_second;
 491                 else
 492                         printf("%s: file system not clean; please fsck(8)\n",
 493                                 mp->mnt_stat.f_mntfromname);
 494                 (void) ext2fs_cgupdate(ump, MNT_WAIT);
 495         }
 496         return (error);
 497
 498 fail:
 499         vrele(devvp);
 500         return (error);
 501 }
 502
 503 /*
 504  * Reload all incore data for a filesystem (used after running fsck on
 505  * the root filesystem and finding things to fix). The filesystem must
 506  * be mounted read-only.
 507  *
 508  * Things to do to update the mount:
 509  *      1) invalidate all cached meta-data.
 510  *      2) re-read superblock from disk.
 511  *      3) re-read summary information from disk.
 512  *      4) invalidate all inactive vnodes.
 513  *      5) invalidate all cached file data.
 514  *      6) re-read inode data for all active vnodes.
 515  */
 516 int
 517 ext2fs_reload(struct mount *mp, kauth_cred_t cred, struct lwp *l)
 518 {
 519         struct vnode *vp, *mvp, *devvp;
 520         struct inode *ip;
 521         struct buf *bp;
 522         struct m_ext2fs *fs;
 523         struct ext2fs *newfs;
 524         struct partinfo dpart;
 525         int i, size, error;
 526         void *cp;
 527         struct ufsmount *ump;
 528
 529         if ((mp->mnt_flag & MNT_RDONLY) == 0)
 530                 return (EINVAL);
 531
 532         ump = VFSTOUFS(mp);
 533         /*
 534          * Step 1: invalidate all cached meta-data.
 535          */
 536         devvp = ump->um_devvp;
 537         vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
 538         error = vinvalbuf(devvp, 0, cred, l, 0, 0);
 539         VOP_UNLOCK(devvp, 0);
 540         if (error)
 541                 panic("ext2fs_reload: dirty1");
 542         /*
 543          * Step 2: re-read superblock from disk.
 544          */
 545         if (VOP_IOCTL(devvp, DIOCGPART, &dpart, FREAD, NOCRED) != 0)
 546                 size = DEV_BSIZE;
 547         else
 548                 size = dpart.disklab->d_secsize;
 549         error = bread(devvp, (daddr_t)(SBOFF / size), SBSIZE, NOCRED, 0, &bp);
 550         if (error) {
 551                 brelse(bp, 0);
 552                 return (error);
 553         }
 554         newfs = (struct ext2fs *)bp->b_data;
 555         error = ext2fs_checksb(newfs, (mp->mnt_flag & MNT_RDONLY) != 0);
 556         if (error) {
 557                 brelse(bp, 0);
 558                 return (error);
 559         }
 560
 561         fs = ump->um_e2fs;
 562         /*
 563          * copy in new superblock, and compute in-memory values
 564          */
 565         e2fs_sbload(newfs, &fs->e2fs);
 566         fs->e2fs_ncg =
 567             howmany(fs->e2fs.e2fs_bcount - fs->e2fs.e2fs_first_dblock,
 568             fs->e2fs.e2fs_bpg);
 569         /* XXX assume hw bsize = 512 */
 570         fs->e2fs_fsbtodb = fs->e2fs.e2fs_log_bsize + 1;
 571         fs->e2fs_bsize = MINBSIZE << fs->e2fs.e2fs_log_bsize;
 572         fs->e2fs_bshift = LOG_MINBSIZE + fs->e2fs.e2fs_log_bsize;
 573         fs->e2fs_qbmask = fs->e2fs_bsize - 1;
 574         fs->e2fs_bmask = ~fs->e2fs_qbmask;
 575         fs->e2fs_ngdb =
 576             howmany(fs->e2fs_ncg, fs->e2fs_bsize / sizeof(struct ext2_gd));
 577         fs->e2fs_ipb = fs->e2fs_bsize / EXT2_DINODE_SIZE(fs);
 578         fs->e2fs_itpg = fs->e2fs.e2fs_ipg / fs->e2fs_ipb;
 579         brelse(bp, 0);
 580
 581         /*
 582          * Step 3: re-read summary information from disk.
 583          */
 584
 585         for (i = 0; i < fs->e2fs_ngdb; i++) {
 586                 error = bread(devvp ,
 587                     fsbtodb(fs, fs->e2fs.e2fs_first_dblock +
 588                     1 /* superblock */ + i),
 589                     fs->e2fs_bsize, NOCRED, 0, &bp);
 590                 if (error) {
 591                         brelse(bp, 0);
 592                         return (error);
 593                 }
 594                 e2fs_cgload((struct ext2_gd *)bp->b_data,
 595                     &fs->e2fs_gd[i * fs->e2fs_bsize / sizeof(struct ext2_gd)],
 596                     fs->e2fs_bsize);
 597                 brelse(bp, 0);
 598         }
 599
 600         /* Allocate a marker vnode. */
 601         if ((mvp = vnalloc(mp)) == NULL)
 602                 return ENOMEM;
 603         /*
 604          * NOTE: not using the TAILQ_FOREACH here since in this loop vgone()
 605          * and vclean() can be called indirectly
 606          */
 607         mutex_enter(&mntvnode_lock);
 608 loop:
 609         for (vp = TAILQ_FIRST(&mp->mnt_vnodelist); vp; vp = vunmark(mvp)) {
 610                 vmark(mvp, vp);
 611                 if (vp->v_mount != mp || vismarker(vp))
 612                         continue;
 613                 /*
 614                  * Step 4: invalidate all inactive vnodes.
 615                  */
 616                 if (vrecycle(vp, &mntvnode_lock, l)) {
 617                         mutex_enter(&mntvnode_lock);
 618                         (void)vunmark(mvp);
 619                         goto loop;
 620                 }
 621                 /*
 622                  * Step 5: invalidate all cached file data.
 623                  */
 624                 mutex_enter(&vp->v_interlock);
 625                 mutex_exit(&mntvnode_lock);
 626                 if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK)) {
 627                         mutex_enter(&mntvnode_lock);
 628                         (void)vunmark(mvp);
 629                         goto loop;
 630                 }
 631                 if (vinvalbuf(vp, 0, cred, l, 0, 0))
 632                         panic("ext2fs_reload: dirty2");
 633                 /*
 634                  * Step 6: re-read inode data for all active vnodes.
 635                  */
 636                 ip = VTOI(vp);
 637                 error = bread(devvp, fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
 638                     (int)fs->e2fs_bsize, NOCRED, 0, &bp);
 639                 if (error) {
 640                         vput(vp);
 641                         mutex_enter(&mntvnode_lock);
 642                         (void)vunmark(mvp);
 643                         break;
 644                 }
 645                 cp = (char *)bp->b_data +
 646                     (ino_to_fsbo(fs, ip->i_number) * EXT2_DINODE_SIZE(fs));
 647                 e2fs_iload((struct ext2fs_dinode *)cp, ip->i_din.e2fs_din);
 648                 ext2fs_set_inode_guid(ip);
 649                 brelse(bp, 0);
 650                 vput(vp);
 651                 mutex_enter(&mntvnode_lock);
 652         }
 653         mutex_exit(&mntvnode_lock);
 654         vnfree(mvp);
 655         return (error);
 656 }
 657
 658 /*
 659  * Common code for mount and mountroot
 660  */
 661 int
 662 ext2fs_mountfs(struct vnode *devvp, struct mount *mp)
 663 {
 664         struct lwp *l = curlwp;
 665         struct ufsmount *ump;
 666         struct buf *bp;
 667         struct ext2fs *fs;
 668         struct m_ext2fs *m_fs;
 669         dev_t dev;
 670         struct partinfo dpart;
 671         int error, i, size, ronly;
 672         kauth_cred_t cred;
 673         struct proc *p;
 674
 675         dev = devvp->v_rdev;
 676         p = l ? l->l_proc : NULL;
 677         cred = l ? l->l_cred : NOCRED;
 678
 679         /* Flush out any old buffers remaining from a previous use. */
 680         vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
 681         error = vinvalbuf(devvp, V_SAVE, cred, l, 0, 0);
 682         VOP_UNLOCK(devvp, 0);
 683         if (error)
 684                 return (error);
 685
 686         ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
 687         if (VOP_IOCTL(devvp, DIOCGPART, &dpart, FREAD, cred) != 0)
 688                 size = DEV_BSIZE;
 689         else
 690                 size = dpart.disklab->d_secsize;
 691
 692         bp = NULL;
 693         ump = NULL;
 694
 695 #ifdef DEBUG_EXT2
 696         printf("ext2 sb size: %d\n", sizeof(struct ext2fs));
 697 #endif
 698         error = bread(devvp, (SBOFF / size), SBSIZE, cred, 0, &bp);
 699         if (error)
 700                 goto out;
 701         fs = (struct ext2fs *)bp->b_data;
 702         error = ext2fs_checksb(fs, ronly);
 703         if (error)
 704                 goto out;
 705         ump = malloc(sizeof(*ump), M_UFSMNT, M_WAITOK);
 706         memset(ump, 0, sizeof(*ump));
 707         ump->um_fstype = UFS1;
 708         ump->um_ops = &ext2fs_ufsops;
 709         ump->um_e2fs = malloc(sizeof(struct m_ext2fs), M_UFSMNT, M_WAITOK);
 710         memset(ump->um_e2fs, 0, sizeof(struct m_ext2fs));
 711         e2fs_sbload((struct ext2fs *)bp->b_data, &ump->um_e2fs->e2fs);
 712         brelse(bp, 0);
 713         bp = NULL;
 714         m_fs = ump->um_e2fs;
 715         m_fs->e2fs_ronly = ronly;
 716
 717 #ifdef DEBUG_EXT2
 718         printf("ext2 ino size %d\n", EXT2_DINODE_SIZE(m_fs));
 719 #endif
 720         if (ronly == 0) {
 721                 if (m_fs->e2fs.e2fs_state == E2FS_ISCLEAN)
 722                         m_fs->e2fs.e2fs_state = 0;
 723                 else
 724                         m_fs->e2fs.e2fs_state = E2FS_ERRORS;
 725                 m_fs->e2fs_fmod = 1;
 726         }
 727
 728         /* compute dynamic sb infos */
 729         m_fs->e2fs_ncg =
 730             howmany(m_fs->e2fs.e2fs_bcount - m_fs->e2fs.e2fs_first_dblock,
 731             m_fs->e2fs.e2fs_bpg);
 732         /* XXX assume hw bsize = 512 */
 733         m_fs->e2fs_fsbtodb = m_fs->e2fs.e2fs_log_bsize + 1;
 734         m_fs->e2fs_bsize = MINBSIZE << m_fs->e2fs.e2fs_log_bsize;
 735         m_fs->e2fs_bshift = LOG_MINBSIZE + m_fs->e2fs.e2fs_log_bsize;
 736         m_fs->e2fs_qbmask = m_fs->e2fs_bsize - 1;
 737         m_fs->e2fs_bmask = ~m_fs->e2fs_qbmask;
 738         m_fs->e2fs_ngdb =
 739             howmany(m_fs->e2fs_ncg, m_fs->e2fs_bsize / sizeof(struct ext2_gd));
 740         m_fs->e2fs_ipb = m_fs->e2fs_bsize / EXT2_DINODE_SIZE(m_fs);
 741         m_fs->e2fs_itpg = m_fs->e2fs.e2fs_ipg / m_fs->e2fs_ipb;
 742
 743         m_fs->e2fs_gd = malloc(m_fs->e2fs_ngdb * m_fs->e2fs_bsize,
 744             M_UFSMNT, M_WAITOK);
 745         for (i = 0; i < m_fs->e2fs_ngdb; i++) {
 746                 error = bread(devvp ,
 747                     fsbtodb(m_fs, m_fs->e2fs.e2fs_first_dblock +
 748                     1 /* superblock */ + i),
 749                     m_fs->e2fs_bsize, NOCRED, 0, &bp);
 750                 if (error) {
 751                         free(m_fs->e2fs_gd, M_UFSMNT);
 752                         goto out;
 753                 }
 754                 e2fs_cgload((struct ext2_gd *)bp->b_data,
 755                     &m_fs->e2fs_gd[
 756                         i * m_fs->e2fs_bsize / sizeof(struct ext2_gd)],
 757                     m_fs->e2fs_bsize);
 758                 brelse(bp, 0);
 759                 bp = NULL;
 760         }
 761
 762         mp->mnt_data = ump;
 763         mp->mnt_stat.f_fsidx.__fsid_val[0] = (long)dev;
 764         mp->mnt_stat.f_fsidx.__fsid_val[1] = makefstype(MOUNT_EXT2FS);
 765         mp->mnt_stat.f_fsid = mp->mnt_stat.f_fsidx.__fsid_val[0];
 766         mp->mnt_stat.f_namemax = EXT2FS_MAXNAMLEN;
 767         mp->mnt_flag |= MNT_LOCAL;
 768         mp->mnt_dev_bshift = DEV_BSHIFT;        /* XXX */
 769         mp->mnt_fs_bshift = m_fs->e2fs_bshift;
 770         mp->mnt_iflag |= IMNT_DTYPE;
 771         ump->um_flags = 0;
 772         ump->um_mountp = mp;
 773         ump->um_dev = dev;
 774         ump->um_devvp = devvp;
 775         ump->um_nindir = NINDIR(m_fs);
 776         ump->um_lognindir = ffs(NINDIR(m_fs)) - 1;
 777         ump->um_bptrtodb = m_fs->e2fs_fsbtodb;
 778         ump->um_seqinc = 1; /* no frags */
 779         ump->um_maxsymlinklen = EXT2_MAXSYMLINKLEN;
 780         ump->um_dirblksiz = m_fs->e2fs_bsize;
 781         ump->um_maxfilesize = ((uint64_t)0x80000000 * m_fs->e2fs_bsize - 1);
 782         devvp->v_specmountpoint = mp;
 783         return (0);
 784
 785 out:
 786         KASSERT(bp != NULL);
 787         brelse(bp, 0);
 788         if (ump) {
 789                 free(ump->um_e2fs, M_UFSMNT);
 790                 free(ump, M_UFSMNT);
 791                 mp->mnt_data = NULL;
 792         }
 793         return (error);
 794 }
 795
 796 /*
 797  * unmount system call
 798  */
 799 int
 800 ext2fs_unmount(struct mount *mp, int mntflags)
 801 {
 802         struct ufsmount *ump;
 803         struct m_ext2fs *fs;
 804         int error, flags;
 805
 806         flags = 0;
 807         if (mntflags & MNT_FORCE)
 808                 flags |= FORCECLOSE;
 809         if ((error = ext2fs_flushfiles(mp, flags)) != 0)
 810                 return (error);
 811         ump = VFSTOUFS(mp);
 812         fs = ump->um_e2fs;
 813         if (fs->e2fs_ronly == 0 &&
 814                 ext2fs_cgupdate(ump, MNT_WAIT) == 0 &&
 815                 (fs->e2fs.e2fs_state & E2FS_ERRORS) == 0) {
 816                 fs->e2fs.e2fs_state = E2FS_ISCLEAN;
 817                 (void) ext2fs_sbupdate(ump, MNT_WAIT);
 818         }
 819         if (ump->um_devvp->v_type != VBAD)
 820                 ump->um_devvp->v_specmountpoint = NULL;
 821         vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
 822         error = VOP_CLOSE(ump->um_devvp, fs->e2fs_ronly ? FREAD : FREAD|FWRITE,
 823             NOCRED);
 824         vput(ump->um_devvp);
 825         free(fs->e2fs_gd, M_UFSMNT);
 826         free(fs, M_UFSMNT);
 827         free(ump, M_UFSMNT);
 828         mp->mnt_data = NULL;
 829         mp->mnt_flag &= ~MNT_LOCAL;
 830         return (error);
 831 }
 832
 833 /*
 834  * Flush out all the files in a filesystem.
 835  */
 836 int
 837 ext2fs_flushfiles(struct mount *mp, int flags)
 838 {
 839         extern int doforce;
 840         int error;
 841
 842         if (!doforce)
 843                 flags &= ~FORCECLOSE;
 844         error = vflush(mp, NULLVP, flags);
 845         return (error);
 846 }
 847
 848 /*
 849  * Get file system statistics.
 850  */
 851 int
 852 ext2fs_statvfs(struct mount *mp, struct statvfs *sbp)
 853 {
 854         struct ufsmount *ump;
 855         struct m_ext2fs *fs;
 856         uint32_t overhead, overhead_per_group, ngdb;
 857         int i, ngroups;
 858
 859         ump = VFSTOUFS(mp);
 860         fs = ump->um_e2fs;
 861         if (fs->e2fs.e2fs_magic != E2FS_MAGIC)
 862                 panic("ext2fs_statvfs");
 863
 864         /*
 865          * Compute the overhead (FS structures)
 866          */
 867         overhead_per_group =
 868             1 /* block bitmap */ +
 869             1 /* inode bitmap */ +
 870             fs->e2fs_itpg;
 871         overhead = fs->e2fs.e2fs_first_dblock +
 872             fs->e2fs_ncg * overhead_per_group;
 873         if (fs->e2fs.e2fs_rev > E2FS_REV0 &&
 874             fs->e2fs.e2fs_features_rocompat & EXT2F_ROCOMPAT_SPARSESUPER) {
 875                 for (i = 0, ngroups = 0; i < fs->e2fs_ncg; i++) {
 876                         if (cg_has_sb(i))
 877                                 ngroups++;
 878                 }
 879         } else {
 880                 ngroups = fs->e2fs_ncg;
 881         }
 882         ngdb = fs->e2fs_ngdb;
 883         if (fs->e2fs.e2fs_rev > E2FS_REV0 &&
 884             fs->e2fs.e2fs_features_compat & EXT2F_COMPAT_RESIZE)
 885                 ngdb += fs->e2fs.e2fs_reserved_ngdb;
 886         overhead += ngroups * (1 /* superblock */ + ngdb);
 887
 888         sbp->f_bsize = fs->e2fs_bsize;
 889         sbp->f_frsize = MINBSIZE << fs->e2fs.e2fs_fsize;
 890         sbp->f_iosize = fs->e2fs_bsize;
 891         sbp->f_blocks = fs->e2fs.e2fs_bcount - overhead;
 892         sbp->f_bfree = fs->e2fs.e2fs_fbcount;
 893         sbp->f_bresvd = fs->e2fs.e2fs_rbcount;
 894         if (sbp->f_bfree > sbp->f_bresvd)
 895                 sbp->f_bavail = sbp->f_bfree - sbp->f_bresvd;
 896         else
 897                 sbp->f_bavail = 0;
 898         sbp->f_files =  fs->e2fs.e2fs_icount;
 899         sbp->f_ffree = fs->e2fs.e2fs_ficount;
 900         sbp->f_favail = fs->e2fs.e2fs_ficount;
 901         sbp->f_fresvd = 0;
 902         copy_statvfs_info(sbp, mp);
 903         return (0);
 904 }
 905
 906 /*
 907  * Go through the disk queues to initiate sandbagged IO;
 908  * go through the inodes to write those that have been modified;
 909  * initiate the writing of the super block if it has been modified.
 910  *
 911  * Note: we are always called with the filesystem marked `MPBUSY'.
 912  */
 913 int
 914 ext2fs_sync(struct mount *mp, int waitfor, kauth_cred_t cred)
 915 {
 916         struct vnode *vp, *mvp;
 917         struct inode *ip;
 918         struct ufsmount *ump = VFSTOUFS(mp);
 919         struct m_ext2fs *fs;
 920         int error, allerror = 0;
 921
 922         fs = ump->um_e2fs;
 923         if (fs->e2fs_fmod != 0 && fs->e2fs_ronly != 0) {        /* XXX */
 924                 printf("fs = %s\n", fs->e2fs_fsmnt);
 925                 panic("update: rofs mod");
 926         }
 927
 928         /* Allocate a marker vnode. */
 929         if ((mvp = vnalloc(mp)) == NULL)
 930                 return (ENOMEM);
 931
 932         /*
 933          * Write back each (modified) inode.
 934          */
 935         mutex_enter(&mntvnode_lock);
 936 loop:
 937         /*
 938          * NOTE: not using the TAILQ_FOREACH here since in this loop vgone()
 939          * and vclean() can be called indirectly
 940          */
 941         for (vp = TAILQ_FIRST(&mp->mnt_vnodelist); vp; vp = vunmark(mvp)) {
 942                 vmark(mvp, vp);
 943                 if (vp->v_mount != mp || vismarker(vp))
 944                         continue;
 945                 mutex_enter(&vp->v_interlock);
 946                 ip = VTOI(vp);
 947                 if (ip == NULL || (vp->v_iflag & (VI_XLOCK|VI_CLEAN)) != 0 ||
 948                     vp->v_type == VNON ||
 949                     ((ip->i_flag &
 950                       (IN_CHANGE | IN_UPDATE | IN_MODIFIED)) == 0 &&
 951                      LIST_EMPTY(&vp->v_dirtyblkhd) &&
 952                      UVM_OBJ_IS_CLEAN(&vp->v_uobj)))
 953                 {
 954                         mutex_exit(&vp->v_interlock);
 955                         continue;
 956                 }
 957                 mutex_exit(&mntvnode_lock);
 958                 error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK);
 959                 if (error) {
 960                         mutex_enter(&mntvnode_lock);
 961                         if (error == ENOENT) {
 962                                 mutex_enter(&mntvnode_lock);
 963                                 (void)vunmark(mvp);
 964                                 goto loop;
 965                         }
 966                         continue;
 967                 }
 968                 if (vp->v_type == VREG && waitfor == MNT_LAZY)
 969                         error = ext2fs_update(vp, NULL, NULL, 0);
 970                 else
 971                         error = VOP_FSYNC(vp, cred,
 972                             waitfor == MNT_WAIT ? FSYNC_WAIT : 0, 0, 0);
 973                 if (error)
 974                         allerror = error;
 975                 vput(vp);
 976                 mutex_enter(&mntvnode_lock);
 977         }
 978         mutex_exit(&mntvnode_lock);
 979         vnfree(mvp);
 980         /*
 981          * Force stale file system control information to be flushed.
 982          */
 983         if (waitfor != MNT_LAZY) {
 984                 vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
 985                 if ((error = VOP_FSYNC(ump->um_devvp, cred,
 986                     waitfor == MNT_WAIT ? FSYNC_WAIT : 0, 0, 0)) != 0)
 987                         allerror = error;
 988                 VOP_UNLOCK(ump->um_devvp, 0);
 989         }
 990         /*
 991          * Write back modified superblock.
 992          */
 993         if (fs->e2fs_fmod != 0) {
 994                 fs->e2fs_fmod = 0;
 995                 fs->e2fs.e2fs_wtime = time_second;
 996                 if ((error = ext2fs_cgupdate(ump, waitfor)))
 997                         allerror = error;
 998         }
 999         return (allerror);
1000 }
1001
1002 /*
1003  * Look up a EXT2FS dinode number to find its incore vnode, otherwise read it
1004  * in from disk.  If it is in core, wait for the lock bit to clear, then
1005  * return the inode locked.  Detection and handling of mount points must be
1006  * done by the calling routine.
1007  */
1008 int
1009 ext2fs_vget(struct mount *mp, ino_t ino, struct vnode **vpp)
1010 {
1011         struct m_ext2fs *fs;
1012         struct inode *ip;
1013         struct ufsmount *ump;
1014         struct buf *bp;
1015         struct vnode *vp;
1016         dev_t dev;
1017         int error;
1018         void *cp;
1019
1020         ump = VFSTOUFS(mp);
1021         dev = ump->um_dev;
1022 retry:
1023         if ((*vpp = ufs_ihashget(dev, ino, LK_EXCLUSIVE)) != NULL)
1024                 return (0);
1025
1026         /* Allocate a new vnode/inode. */
1027         if ((error = getnewvnode(VT_EXT2FS, mp, ext2fs_vnodeop_p, &vp)) != 0) {
1028                 *vpp = NULL;
1029                 return (error);
1030         }
1031         ip = pool_get(&ext2fs_inode_pool, PR_WAITOK);
1032
1033         mutex_enter(&ufs_hashlock);
1034         if ((*vpp = ufs_ihashget(dev, ino, 0)) != NULL) {
1035                 mutex_exit(&ufs_hashlock);
1036                 ungetnewvnode(vp);
1037                 pool_put(&ext2fs_inode_pool, ip);
1038                 goto retry;
1039         }
1040
1041         vp->v_vflag |= VV_LOCKSWORK;
1042
1043         memset(ip, 0, sizeof(struct inode));
1044         vp->v_data = ip;
1045         ip->i_vnode = vp;
1046         ip->i_ump = ump;
1047         ip->i_e2fs = fs = ump->um_e2fs;
1048         ip->i_dev = dev;
1049         ip->i_number = ino;
1050         ip->i_e2fs_last_lblk = 0;
1051         ip->i_e2fs_last_blk = 0;
1052         genfs_node_init(vp, &ext2fs_genfsops);
1053
1054         /*
1055          * Put it onto its hash chain and lock it so that other requests for
1056          * this inode will block if they arrive while we are sleeping waiting
1057          * for old data structures to be purged or for the contents of the
1058          * disk portion of this inode to be read.
1059          */
1060
1061         ufs_ihashins(ip);
1062         mutex_exit(&ufs_hashlock);
1063
1064         /* Read in the disk contents for the inode, copy into the inode. */
1065         error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ino)),
1066             (int)fs->e2fs_bsize, NOCRED, 0, &bp);
1067         if (error) {
1068
1069                 /*
1070                  * The inode does not contain anything useful, so it would
1071                  * be misleading to leave it on its hash chain. With mode
1072                  * still zero, it will be unlinked and returned to the free
1073                  * list by vput().
1074                  */
1075
1076                 vput(vp);
1077                 brelse(bp, 0);
1078                 *vpp = NULL;
1079                 return (error);
1080         }
1081         cp = (char *)bp->b_data + (ino_to_fsbo(fs, ino) * EXT2_DINODE_SIZE(fs));
1082         ip->i_din.e2fs_din = pool_get(&ext2fs_dinode_pool, PR_WAITOK);
1083         e2fs_iload((struct ext2fs_dinode *)cp, ip->i_din.e2fs_din);
1084         ext2fs_set_inode_guid(ip);
1085         brelse(bp, 0);
1086
1087         /* If the inode was deleted, reset all fields */
1088         if (ip->i_e2fs_dtime != 0) {
1089                 ip->i_e2fs_mode = ip->i_e2fs_nblock = 0;
1090                 (void)ext2fs_setsize(ip, 0);
1091                 memset(ip->i_e2fs_blocks, 0, sizeof(ip->i_e2fs_blocks));
1092         }
1093
1094         /*
1095          * Initialize the vnode from the inode, check for aliases.
1096          */
1097
1098         error = ext2fs_vinit(mp, ext2fs_specop_p, ext2fs_fifoop_p, &vp);
1099         if (error) {
1100                 vput(vp);
1101                 *vpp = NULL;
1102                 return (error);
1103         }
1104         /*
1105          * Finish inode initialization now that aliasing has been resolved.
1106          */
1107
1108         ip->i_devvp = ump->um_devvp;
1109         vref(ip->i_devvp);
1110
1111         /*
1112          * Set up a generation number for this inode if it does not
1113          * already have one. This should only happen on old filesystems.
1114          */
1115
1116         if (ip->i_e2fs_gen == 0) {
1117                 if (++ext2gennumber < (u_long)time_second)
1118                         ext2gennumber = time_second;
1119                 ip->i_e2fs_gen = ext2gennumber;
1120                 if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0)
1121                         ip->i_flag |= IN_MODIFIED;
1122         }
1123         uvm_vnp_setsize(vp, ext2fs_size(ip));
1124         *vpp = vp;
1125         return (0);
1126 }
1127
1128 /*
1129  * File handle to vnode
1130  *
1131  * Have to be really careful about stale file handles:
1132  * - check that the inode number is valid
1133  * - call ext2fs_vget() to get the locked inode
1134  * - check for an unallocated inode (i_mode == 0)
1135  */
1136 int
1137 ext2fs_fhtovp(struct mount *mp, struct fid *fhp, struct vnode **vpp)
1138 {
1139         struct inode *ip;
1140         struct vnode *nvp;
1141         int error;
1142         struct ufid ufh;
1143         struct m_ext2fs *fs;
1144
1145         if (fhp->fid_len != sizeof(struct ufid))
1146                 return EINVAL;
1147
1148         memcpy(&ufh, fhp, sizeof(struct ufid));
1149         fs = VFSTOUFS(mp)->um_e2fs;
1150         if ((ufh.ufid_ino < EXT2_FIRSTINO && ufh.ufid_ino != EXT2_ROOTINO) ||
1151                 ufh.ufid_ino >= fs->e2fs_ncg * fs->e2fs.e2fs_ipg)
1152                 return (ESTALE);
1153
1154         if ((error = VFS_VGET(mp, ufh.ufid_ino, &nvp)) != 0) {
1155                 *vpp = NULLVP;
1156                 return (error);
1157         }
1158         ip = VTOI(nvp);
1159         if (ip->i_e2fs_mode == 0 || ip->i_e2fs_dtime != 0 ||
1160                 ip->i_e2fs_gen != ufh.ufid_gen) {
1161                 vput(nvp);
1162                 *vpp = NULLVP;
1163                 return (ESTALE);
1164         }
1165         *vpp = nvp;
1166         return (0);
1167 }
1168
1169 /*
1170  * Vnode pointer to File handle
1171  */
1172 /* ARGSUSED */
1173 int
1174 ext2fs_vptofh(struct vnode *vp, struct fid *fhp, size_t *fh_size)
1175 {
1176         struct inode *ip;
1177         struct ufid ufh;
1178
1179         if (*fh_size < sizeof(struct ufid)) {
1180                 *fh_size = sizeof(struct ufid);
1181                 return E2BIG;
1182         }
1183         *fh_size = sizeof(struct ufid);
1184
1185         ip = VTOI(vp);
1186         memset(&ufh, 0, sizeof(ufh));
1187         ufh.ufid_len = sizeof(struct ufid);
1188         ufh.ufid_ino = ip->i_number;
1189         ufh.ufid_gen = ip->i_e2fs_gen;
1190         memcpy(fhp, &ufh, sizeof(ufh));
1191         return (0);
1192 }
1193
1194 /*
1195  * Write a superblock and associated information back to disk.
1196  */
1197 int
1198 ext2fs_sbupdate(struct ufsmount *mp, int waitfor)
1199 {
1200         struct m_ext2fs *fs = mp->um_e2fs;
1201         struct buf *bp;
1202         int error = 0;
1203
1204         bp = getblk(mp->um_devvp, SBLOCK, SBSIZE, 0, 0);
1205         e2fs_sbsave(&fs->e2fs, (struct ext2fs*)bp->b_data);
1206         if (waitfor == MNT_WAIT)
1207                 error = bwrite(bp);
1208         else
1209                 bawrite(bp);
1210         return (error);
1211 }
1212
1213 int
1214 ext2fs_cgupdate(struct ufsmount *mp, int waitfor)
1215 {
1216         struct m_ext2fs *fs = mp->um_e2fs;
1217         struct buf *bp;
1218         int i, error = 0, allerror = 0;
1219
1220         allerror = ext2fs_sbupdate(mp, waitfor);
1221         for (i = 0; i < fs->e2fs_ngdb; i++) {
1222                 bp = getblk(mp->um_devvp, fsbtodb(fs,
1223                     fs->e2fs.e2fs_first_dblock +
1224                     1 /* superblock */ + i), fs->e2fs_bsize, 0, 0);
1225                 e2fs_cgsave(&fs->e2fs_gd[
1226                     i * fs->e2fs_bsize / sizeof(struct ext2_gd)],
1227                     (struct ext2_gd *)bp->b_data, fs->e2fs_bsize);
1228                 if (waitfor == MNT_WAIT)
1229                         error = bwrite(bp);
1230                 else
1231                         bawrite(bp);
1232         }
1233
1234         if (!allerror && error)
1235                 allerror = error;
1236         return (allerror);
1237 }
1238
1239 static int
1240 ext2fs_checksb(struct ext2fs *fs, int ronly)
1241 {
1242
1243         if (fs2h16(fs->e2fs_magic) != E2FS_MAGIC) {
1244                 return (EINVAL);                /* XXX needs translation */
1245         }
1246         if (fs2h32(fs->e2fs_rev) > E2FS_REV1) {
1247 #ifdef DIAGNOSTIC
1248                 printf("Ext2 fs: unsupported revision number: %x\n",
1249                     fs2h32(fs->e2fs_rev));
1250 #endif
1251                 return (EINVAL);                /* XXX needs translation */
1252         }
1253         if (fs2h32(fs->e2fs_log_bsize) > 2) { /* block size = 1024|2048|4096 */
1254 #ifdef DIAGNOSTIC
1255                 printf("Ext2 fs: bad block size: %d "
1256                     "(expected <= 2 for ext2 fs)\n",
1257                     fs2h32(fs->e2fs_log_bsize));
1258 #endif
1259                 return (EINVAL);           /* XXX needs translation */
1260         }
1261         if (fs2h32(fs->e2fs_rev) > E2FS_REV0) {
1262                 if (fs2h32(fs->e2fs_first_ino) != EXT2_FIRSTINO) {
1263                         printf("Ext2 fs: unsupported first inode position\n");
1264                         return (EINVAL);      /* XXX needs translation */
1265                 }
1266                 if (fs2h32(fs->e2fs_features_incompat) &
1267                     ~EXT2F_INCOMPAT_SUPP) {
1268                         printf("Ext2 fs: unsupported optional feature\n");
1269                         return (EINVAL);      /* XXX needs translation */
1270                 }
1271                 if (!ronly && fs2h32(fs->e2fs_features_rocompat) &
1272                     ~EXT2F_ROCOMPAT_SUPP) {
1273                         return (EROFS);      /* XXX needs translation */
1274                 }
1275         }
1276         return (0);
1277 }