The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/fs/ext2fs/ext2_vfsops.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    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/sdt.h>
   56 #include <sys/stat.h>
   57 #include <sys/mutex.h>
   58 
   59 #include <geom/geom.h>
   60 #include <geom/geom_vfs.h>
   61 
   62 #include <fs/ext2fs/fs.h>
   63 #include <fs/ext2fs/ext2_mount.h>
   64 #include <fs/ext2fs/inode.h>
   65 
   66 #include <fs/ext2fs/ext2fs.h>
   67 #include <fs/ext2fs/ext2_dinode.h>
   68 #include <fs/ext2fs/ext2_extern.h>
   69 #include <fs/ext2fs/ext2_extents.h>
   70 
   71 SDT_PROVIDER_DECLARE(ext2fs);
   72 /*
   73  * ext2fs trace probe:
   74  * arg0: verbosity. Higher numbers give more verbose messages
   75  * arg1: Textual message
   76  */
   77 SDT_PROBE_DEFINE2(ext2fs, , vfsops, trace, "int", "char*");
   78 SDT_PROBE_DEFINE2(ext2fs, , vfsops, ext2_cg_validate_error, "char*", "int");
   79 SDT_PROBE_DEFINE1(ext2fs, , vfsops, ext2_compute_sb_data_error, "char*");
   80 
   81 
   82 static int      ext2_flushfiles(struct mount *mp, int flags, struct thread *td);
   83 static int      ext2_mountfs(struct vnode *, struct mount *);
   84 static int      ext2_reload(struct mount *mp, struct thread *td);
   85 static int      ext2_sbupdate(struct ext2mount *, int);
   86 static int      ext2_cgupdate(struct ext2mount *, int);
   87 static vfs_unmount_t            ext2_unmount;
   88 static vfs_root_t               ext2_root;
   89 static vfs_statfs_t             ext2_statfs;
   90 static vfs_sync_t               ext2_sync;
   91 static vfs_vget_t               ext2_vget;
   92 static vfs_fhtovp_t             ext2_fhtovp;
   93 static vfs_mount_t              ext2_mount;
   94 
   95 MALLOC_DEFINE(M_EXT2NODE, "ext2_node", "EXT2 vnode private part");
   96 static MALLOC_DEFINE(M_EXT2MNT, "ext2_mount", "EXT2 mount structure");
   97 
   98 static struct vfsops ext2fs_vfsops = {
   99         .vfs_fhtovp =           ext2_fhtovp,
  100         .vfs_mount =            ext2_mount,
  101         .vfs_root =             ext2_root,      /* root inode via vget */
  102         .vfs_statfs =           ext2_statfs,
  103         .vfs_sync =             ext2_sync,
  104         .vfs_unmount =          ext2_unmount,
  105         .vfs_vget =             ext2_vget,
  106 };
  107 
  108 VFS_SET(ext2fs_vfsops, ext2fs, 0);
  109 
  110 static int      ext2_check_sb_compat(struct ext2fs *es, struct cdev *dev,
  111                     int ronly);
  112 static int      ext2_compute_sb_data(struct vnode * devvp,
  113                     struct ext2fs * es, struct m_ext2fs * fs);
  114 
  115 static const char *ext2_opts[] = { "acls", "async", "noatime", "noclusterr", 
  116     "noclusterw", "noexec", "export", "force", "from", "multilabel",
  117     "suiddir", "nosymfollow", "sync", "union", NULL };
  118 
  119 /*
  120  * VFS Operations.
  121  *
  122  * mount system call
  123  */
  124 static int
  125 ext2_mount(struct mount *mp)
  126 {
  127         struct vfsoptlist *opts;
  128         struct vnode *devvp;
  129         struct thread *td;
  130         struct ext2mount *ump = NULL;
  131         struct m_ext2fs *fs;
  132         struct nameidata nd, *ndp = &nd;
  133         accmode_t accmode;
  134         char *path, *fspec;
  135         int error, flags, len;
  136 
  137         td = curthread;
  138         opts = mp->mnt_optnew;
  139 
  140         if (vfs_filteropt(opts, ext2_opts))
  141                 return (EINVAL);
  142 
  143         vfs_getopt(opts, "fspath", (void **)&path, NULL);
  144         /* Double-check the length of path.. */
  145         if (strlen(path) >= MAXMNTLEN)
  146                 return (ENAMETOOLONG);
  147 
  148         fspec = NULL;
  149         error = vfs_getopt(opts, "from", (void **)&fspec, &len);
  150         if (!error && fspec[len - 1] != '\0')
  151                 return (EINVAL);
  152 
  153         /*
  154          * If updating, check whether changing from read-only to
  155          * read/write; if there is no device name, that's all we do.
  156          */
  157         if (mp->mnt_flag & MNT_UPDATE) {
  158                 ump = VFSTOEXT2(mp);
  159                 fs = ump->um_e2fs;
  160                 error = 0;
  161                 if (fs->e2fs_ronly == 0 &&
  162                     vfs_flagopt(opts, "ro", NULL, 0)) {
  163                         error = VFS_SYNC(mp, MNT_WAIT);
  164                         if (error)
  165                                 return (error);
  166                         flags = WRITECLOSE;
  167                         if (mp->mnt_flag & MNT_FORCE)
  168                                 flags |= FORCECLOSE;
  169                         error = ext2_flushfiles(mp, flags, td);
  170                         if (error == 0 && fs->e2fs_wasvalid &&
  171                             ext2_cgupdate(ump, MNT_WAIT) == 0) {
  172                                 fs->e2fs->e2fs_state |= E2FS_ISCLEAN;
  173                                 ext2_sbupdate(ump, MNT_WAIT);
  174                         }
  175                         fs->e2fs_ronly = 1;
  176                         vfs_flagopt(opts, "ro", &mp->mnt_flag, MNT_RDONLY);
  177                         g_topology_lock();
  178                         g_access(ump->um_cp, 0, -1, 0);
  179                         g_topology_unlock();
  180                 }
  181                 if (!error && (mp->mnt_flag & MNT_RELOAD))
  182                         error = ext2_reload(mp, td);
  183                 if (error)
  184                         return (error);
  185                 devvp = ump->um_devvp;
  186                 if (fs->e2fs_ronly && !vfs_flagopt(opts, "ro", NULL, 0)) {
  187                         if (ext2_check_sb_compat(fs->e2fs, devvp->v_rdev, 0))
  188                                 return (EPERM);
  189 
  190                         /*
  191                          * If upgrade to read-write by non-root, then verify
  192                          * that user has necessary permissions on the device.
  193                          */
  194                         vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
  195                         error = VOP_ACCESS(devvp, VREAD | VWRITE,
  196                             td->td_ucred, td);
  197                         if (error)
  198                                 error = priv_check(td, PRIV_VFS_MOUNT_PERM);
  199                         if (error) {
  200                                 VOP_UNLOCK(devvp, 0);
  201                                 return (error);
  202                         }
  203                         VOP_UNLOCK(devvp, 0);
  204                         g_topology_lock();
  205                         error = g_access(ump->um_cp, 0, 1, 0);
  206                         g_topology_unlock();
  207                         if (error)
  208                                 return (error);
  209 
  210                         if ((fs->e2fs->e2fs_state & E2FS_ISCLEAN) == 0 ||
  211                             (fs->e2fs->e2fs_state & E2FS_ERRORS)) {
  212                                 if (mp->mnt_flag & MNT_FORCE) {
  213                                         printf(
  214 "WARNING: %s was not properly dismounted\n", fs->e2fs_fsmnt);
  215                                 } else {
  216                                         printf(
  217 "WARNING: R/W mount of %s denied.  Filesystem is not clean - run fsck\n",
  218                                             fs->e2fs_fsmnt);
  219                                         return (EPERM);
  220                                 }
  221                         }
  222                         fs->e2fs->e2fs_state &= ~E2FS_ISCLEAN;
  223                         (void)ext2_cgupdate(ump, MNT_WAIT);
  224                         fs->e2fs_ronly = 0;
  225                         MNT_ILOCK(mp);
  226                         mp->mnt_flag &= ~MNT_RDONLY;
  227                         MNT_IUNLOCK(mp);
  228                 }
  229                 if (vfs_flagopt(opts, "export", NULL, 0)) {
  230                         /* Process export requests in vfs_mount.c. */
  231                         return (error);
  232                 }
  233         }
  234 
  235         /*
  236          * Not an update, or updating the name: look up the name
  237          * and verify that it refers to a sensible disk device.
  238          */
  239         if (fspec == NULL)
  240                 return (EINVAL);
  241         NDINIT(ndp, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, fspec, td);
  242         if ((error = namei(ndp)) != 0)
  243                 return (error);
  244         NDFREE(ndp, NDF_ONLY_PNBUF);
  245         devvp = ndp->ni_vp;
  246 
  247         if (!vn_isdisk(devvp, &error)) {
  248                 vput(devvp);
  249                 return (error);
  250         }
  251 
  252         /*
  253          * If mount by non-root, then verify that user has necessary
  254          * permissions on the device.
  255          *
  256          * XXXRW: VOP_ACCESS() enough?
  257          */
  258         accmode = VREAD;
  259         if ((mp->mnt_flag & MNT_RDONLY) == 0)
  260                 accmode |= VWRITE;
  261         error = VOP_ACCESS(devvp, accmode, td->td_ucred, td);
  262         if (error)
  263                 error = priv_check(td, PRIV_VFS_MOUNT_PERM);
  264         if (error) {
  265                 vput(devvp);
  266                 return (error);
  267         }
  268 
  269         if ((mp->mnt_flag & MNT_UPDATE) == 0) {
  270                 error = ext2_mountfs(devvp, mp);
  271         } else {
  272                 if (devvp != ump->um_devvp) {
  273                         vput(devvp);
  274                         return (EINVAL);        /* needs translation */
  275                 } else
  276                         vput(devvp);
  277         }
  278         if (error) {
  279                 vrele(devvp);
  280                 return (error);
  281         }
  282         ump = VFSTOEXT2(mp);
  283         fs = ump->um_e2fs;
  284 
  285         /*
  286          * Note that this strncpy() is ok because of a check at the start
  287          * of ext2_mount().
  288          */
  289         strncpy(fs->e2fs_fsmnt, path, MAXMNTLEN);
  290         fs->e2fs_fsmnt[MAXMNTLEN - 1] = '\0';
  291         vfs_mountedfrom(mp, fspec);
  292         return (0);
  293 }
  294 
  295 static int
  296 ext2_check_sb_compat(struct ext2fs *es, struct cdev *dev, int ronly)
  297 {
  298         uint32_t i, mask;
  299 
  300         if (es->e2fs_magic != E2FS_MAGIC) {
  301                 printf("ext2fs: %s: wrong magic number %#x (expected %#x)\n",
  302                     devtoname(dev), es->e2fs_magic, E2FS_MAGIC);
  303                 return (1);
  304         }
  305         if (es->e2fs_rev > E2FS_REV0) {
  306                 mask = es->e2fs_features_incompat & ~(EXT2F_INCOMPAT_SUPP);
  307                 if (mask) {
  308                         printf("WARNING: mount of %s denied due to "
  309                             "unsupported optional features:\n", devtoname(dev));
  310                         for (i = 0;
  311                             i < sizeof(incompat)/sizeof(struct ext2_feature);
  312                             i++)
  313                                 if (mask & incompat[i].mask)
  314                                         printf("%s ", incompat[i].name);
  315                         printf("\n");
  316                         return (1);
  317                 }
  318                 mask = es->e2fs_features_rocompat & ~EXT2F_ROCOMPAT_SUPP;
  319                 if (!ronly && mask) {
  320                         printf("WARNING: R/W mount of %s denied due to "
  321                             "unsupported optional features:\n", devtoname(dev));
  322                         for (i = 0;
  323                             i < sizeof(ro_compat)/sizeof(struct ext2_feature);
  324                             i++)
  325                                 if (mask & ro_compat[i].mask)
  326                                         printf("%s ", ro_compat[i].name);
  327                         printf("\n");
  328                         return (1);
  329                 }
  330         }
  331         return (0);
  332 }
  333 
  334 static e4fs_daddr_t
  335 ext2_cg_location(struct m_ext2fs *fs, int number)
  336 {
  337         int cg, descpb, logical_sb, has_super = 0;
  338 
  339         /*
  340          * Adjust logical superblock block number.
  341          * Godmar thinks: if the blocksize is greater than 1024, then
  342          * the superblock is logically part of block zero.
  343          */
  344         logical_sb = fs->e2fs_bsize > SBSIZE ? 0 : 1;
  345 
  346         if (!EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_META_BG) ||
  347             number < fs->e2fs->e3fs_first_meta_bg)
  348                 return (logical_sb + number + 1);
  349 
  350         if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT))
  351                 descpb = fs->e2fs_bsize / sizeof(struct ext2_gd);
  352         else
  353                 descpb = fs->e2fs_bsize / E2FS_REV0_GD_SIZE;
  354 
  355         cg = descpb * number;
  356 
  357         if (ext2_cg_has_sb(fs, cg))
  358                 has_super = 1;
  359 
  360         return (has_super + cg * (e4fs_daddr_t)EXT2_BLOCKS_PER_GROUP(fs) +
  361             fs->e2fs->e2fs_first_dblock);
  362 }
  363 
  364 static int
  365 ext2_cg_validate(struct m_ext2fs *fs)
  366 {
  367         uint64_t b_bitmap;
  368         uint64_t i_bitmap;
  369         uint64_t i_tables;
  370         uint64_t first_block, last_block, last_cg_block;
  371         struct ext2_gd *gd;
  372         unsigned int i, cg_count;
  373 
  374         first_block = fs->e2fs->e2fs_first_dblock;
  375         last_cg_block = ext2_cg_number_gdb(fs, 0);
  376         cg_count = fs->e2fs_gcount;
  377 
  378         for (i = 0; i < fs->e2fs_gcount; i++) {
  379                 gd = &fs->e2fs_gd[i];
  380 
  381                 if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_FLEX_BG) ||
  382                     i == fs->e2fs_gcount - 1) {
  383                         last_block = fs->e2fs_bcount - 1;
  384                 } else {
  385                         last_block = first_block +
  386                             (EXT2_BLOCKS_PER_GROUP(fs) - 1);
  387                 }
  388 
  389                 if ((cg_count == fs->e2fs_gcount) &&
  390                     !(gd->ext4bgd_flags & EXT2_BG_INODE_ZEROED))
  391                         cg_count = i;
  392 
  393                 b_bitmap = e2fs_gd_get_b_bitmap(gd);
  394                 if (b_bitmap == 0) {
  395                         SDT_PROBE2(ext2fs, , vfsops, ext2_cg_validate_error,
  396                             "block bitmap is zero", i);
  397                         return (EINVAL);
  398 
  399                 }
  400                 if (b_bitmap <= last_cg_block) {
  401                         SDT_PROBE2(ext2fs, , vfsops, ext2_cg_validate_error,
  402                             "block bitmap overlaps gds", i);
  403                         return (EINVAL);
  404                 }
  405                 if (b_bitmap < first_block || b_bitmap > last_block) {
  406                         SDT_PROBE2(ext2fs, , vfsops, ext2_cg_validate_error,
  407                             "block bitmap not in group", i);
  408                         return (EINVAL);
  409                 }
  410 
  411                 i_bitmap = e2fs_gd_get_i_bitmap(gd);
  412                 if (i_bitmap == 0) {
  413                         SDT_PROBE2(ext2fs, , vfsops, ext2_cg_validate_error,
  414                             "inode bitmap is zero", i);
  415                         return (EINVAL);
  416                 }
  417                 if (i_bitmap <= last_cg_block) {
  418                         SDT_PROBE2(ext2fs, , vfsops, ext2_cg_validate_error,
  419                             "inode bitmap overlaps gds", i);
  420                         return (EINVAL);
  421                 }
  422                 if (i_bitmap < first_block || i_bitmap > last_block) {
  423                         SDT_PROBE2(ext2fs, , vfsops, ext2_cg_validate_error,
  424                             "inode bitmap not in group blk", i);
  425                         return (EINVAL);
  426                 }
  427 
  428                 i_tables = e2fs_gd_get_i_tables(gd);
  429                 if (i_tables == 0) {
  430                         SDT_PROBE2(ext2fs, , vfsops, ext2_cg_validate_error,
  431                             "inode table is zero", i);
  432                         return (EINVAL);
  433                 }
  434                 if (i_tables <= last_cg_block) {
  435                         SDT_PROBE2(ext2fs, , vfsops, ext2_cg_validate_error,
  436                             "inode tables overlaps gds", i);
  437                         return (EINVAL);
  438                 }
  439                 if (i_tables < first_block ||
  440                     i_tables + fs->e2fs_itpg - 1 > last_block) {
  441                         SDT_PROBE2(ext2fs, , vfsops, ext2_cg_validate_error,
  442                             "inode tables not in group blk", i);
  443                         return (EINVAL);
  444                 }
  445 
  446                 if (!EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_FLEX_BG))
  447                         first_block += EXT2_BLOCKS_PER_GROUP(fs);
  448         }
  449 
  450         return (0);
  451 }
  452 
  453 /*
  454  * This computes the fields of the m_ext2fs structure from the
  455  * data in the ext2fs structure read in.
  456  */
  457 static int
  458 ext2_compute_sb_data(struct vnode *devvp, struct ext2fs *es,
  459     struct m_ext2fs *fs)
  460 {
  461         struct buf *bp;
  462         uint32_t e2fs_descpb, e2fs_gdbcount_alloc;
  463         int i, j;
  464         int g_count = 0;
  465         int error;
  466 
  467         /* Check checksum features */
  468         if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM) &&
  469             EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) {
  470                 SDT_PROBE1(ext2fs, , vfsops, ext2_compute_sb_data_error,
  471                     "incorrect checksum features combination");
  472                 return (EINVAL);
  473         }
  474 
  475         /* Precompute checksum seed for all metadata */
  476         ext2_sb_csum_set_seed(fs);
  477 
  478         /* Verify sb csum if possible */
  479         if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) {
  480                 error = ext2_sb_csum_verify(fs);
  481                 if (error) {
  482                         return (error);
  483                 }
  484         }
  485 
  486         /* Check for block size = 1K|2K|4K */
  487         if (es->e2fs_log_bsize > 2) {
  488                 SDT_PROBE1(ext2fs, , vfsops, ext2_compute_sb_data_error,
  489                     "bad block size");
  490                 return (EINVAL);
  491         }
  492 
  493         fs->e2fs_bshift = EXT2_MIN_BLOCK_LOG_SIZE + es->e2fs_log_bsize;
  494         fs->e2fs_bsize = 1U << fs->e2fs_bshift;
  495         fs->e2fs_fsbtodb = es->e2fs_log_bsize + 1;
  496         fs->e2fs_qbmask = fs->e2fs_bsize - 1;
  497 
  498         /* Check for fragment size */
  499         if (es->e2fs_log_fsize >
  500             (EXT2_MAX_FRAG_LOG_SIZE - EXT2_MIN_BLOCK_LOG_SIZE)) {
  501                 SDT_PROBE1(ext2fs, , vfsops, ext2_compute_sb_data_error,
  502                     "invalid log cluster size");
  503                 return (EINVAL);
  504         }
  505 
  506         fs->e2fs_fsize = EXT2_MIN_FRAG_SIZE << es->e2fs_log_fsize;
  507         if (fs->e2fs_fsize != fs->e2fs_bsize) {
  508                 SDT_PROBE1(ext2fs, , vfsops, ext2_compute_sb_data_error,
  509                     "fragment size != block size");
  510                 return (EINVAL);
  511         }
  512 
  513         fs->e2fs_fpb = fs->e2fs_bsize / fs->e2fs_fsize;
  514 
  515         /* Check reserved gdt blocks for future filesystem expansion */
  516         if (es->e2fs_reserved_ngdb > (fs->e2fs_bsize / 4)) {
  517                 SDT_PROBE1(ext2fs, , vfsops, ext2_compute_sb_data_error,
  518                     "number of reserved GDT blocks too large");
  519                 return (EINVAL);
  520         }
  521 
  522         if (es->e2fs_rev == E2FS_REV0) {
  523                 fs->e2fs_isize = E2FS_REV0_INODE_SIZE;
  524         } else {
  525                 fs->e2fs_isize = es->e2fs_inode_size;
  526 
  527                 /*
  528                  * Check first ino.
  529                  */
  530                 if (es->e2fs_first_ino < EXT2_FIRSTINO) {
  531                         SDT_PROBE1(ext2fs, , vfsops, ext2_compute_sb_data_error,
  532                             "invalid first ino");
  533                         return (EINVAL);
  534                 }
  535 
  536                 /*
  537                  * Simple sanity check for superblock inode size value.
  538                  */
  539                 if (EXT2_INODE_SIZE(fs) < E2FS_REV0_INODE_SIZE ||
  540                     EXT2_INODE_SIZE(fs) > fs->e2fs_bsize ||
  541                     (fs->e2fs_isize & (fs->e2fs_isize - 1)) != 0) {
  542                         SDT_PROBE1(ext2fs, , vfsops, ext2_compute_sb_data_error,
  543                             "invalid inode size");
  544                         return (EINVAL);
  545                 }
  546         }
  547 
  548         /* Check group descriptors */
  549         if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT) &&
  550             es->e3fs_desc_size != E2FS_64BIT_GD_SIZE) {
  551                 SDT_PROBE1(ext2fs, , vfsops, ext2_compute_sb_data_error,
  552                     "unsupported 64bit descriptor size");
  553                 return (EINVAL);
  554         }
  555 
  556         fs->e2fs_bpg = es->e2fs_bpg;
  557         fs->e2fs_fpg = es->e2fs_fpg;
  558         if (fs->e2fs_bpg == 0 || fs->e2fs_fpg == 0) {
  559                 SDT_PROBE1(ext2fs, , vfsops, ext2_compute_sb_data_error,
  560                     "zero blocks/fragments per group");
  561                 return (EINVAL);
  562         } else if (fs->e2fs_bpg != fs->e2fs_fpg) {
  563                 SDT_PROBE1(ext2fs, , vfsops, ext2_compute_sb_data_error,
  564                     "blocks per group not equal fragments per group");
  565                 return (EINVAL);
  566         }
  567 
  568         if (fs->e2fs_bpg != fs->e2fs_bsize * 8) {
  569                 SDT_PROBE1(ext2fs, , vfsops, ext2_compute_sb_data_error,
  570                     "non-standard group size unsupported");
  571                 return (EINVAL);
  572         }
  573 
  574         fs->e2fs_ipb = fs->e2fs_bsize / EXT2_INODE_SIZE(fs);
  575         if (fs->e2fs_ipb == 0 ||
  576             fs->e2fs_ipb > fs->e2fs_bsize / E2FS_REV0_INODE_SIZE) {
  577                 SDT_PROBE1(ext2fs, , vfsops, ext2_compute_sb_data_error,
  578                     "bad inodes per block size");
  579                 return (EINVAL);
  580         }
  581 
  582         fs->e2fs_ipg = es->e2fs_ipg;
  583         if (fs->e2fs_ipg < fs->e2fs_ipb || fs->e2fs_ipg >  fs->e2fs_bsize * 8) {
  584                 SDT_PROBE1(ext2fs, , vfsops, ext2_compute_sb_data_error,
  585                     "invalid inodes per group");
  586                 return (EINVAL);
  587         }
  588 
  589         fs->e2fs_itpg = fs->e2fs_ipg / fs->e2fs_ipb;
  590 
  591         fs->e2fs_bcount = es->e2fs_bcount;
  592         fs->e2fs_rbcount = es->e2fs_rbcount;
  593         fs->e2fs_fbcount = es->e2fs_fbcount;
  594         if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT)) {
  595                 fs->e2fs_bcount |= (uint64_t)(es->e4fs_bcount_hi) << 32;
  596                 fs->e2fs_rbcount |= (uint64_t)(es->e4fs_rbcount_hi) << 32;
  597                 fs->e2fs_fbcount |= (uint64_t)(es->e4fs_fbcount_hi) << 32;
  598         }
  599         if (fs->e2fs_rbcount > fs->e2fs_bcount ||
  600             fs->e2fs_fbcount > fs->e2fs_bcount) {
  601                 SDT_PROBE1(ext2fs, , vfsops, ext2_compute_sb_data_error,
  602                     "invalid block count");
  603                 return (EINVAL);
  604         }
  605         if (es->e2fs_first_dblock >= fs->e2fs_bcount) {
  606                 SDT_PROBE1(ext2fs, , vfsops, ext2_compute_sb_data_error,
  607                     "first data block out of range");
  608                 return (EINVAL);
  609         }
  610 
  611         fs->e2fs_gcount = howmany(fs->e2fs_bcount - es->e2fs_first_dblock,
  612             EXT2_BLOCKS_PER_GROUP(fs));
  613         if (fs->e2fs_gcount > ((uint64_t)1 << 32) - EXT2_DESCS_PER_BLOCK(fs)) {
  614                 SDT_PROBE1(ext2fs, , vfsops, ext2_compute_sb_data_error,
  615                     "groups count too large");
  616                 return (EINVAL);
  617         }
  618 
  619         /* Check for extra isize in big inodes. */
  620         if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_EXTRA_ISIZE) &&
  621             EXT2_INODE_SIZE(fs) < sizeof(struct ext2fs_dinode)) {
  622                 SDT_PROBE1(ext2fs, , vfsops, ext2_compute_sb_data_error,
  623                     "no space for extra inode timestamps");
  624                 return (EINVAL);
  625         }
  626 
  627         /* s_resuid / s_resgid ? */
  628 
  629         if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT)) {
  630                 e2fs_descpb = fs->e2fs_bsize / E2FS_64BIT_GD_SIZE;
  631                 e2fs_gdbcount_alloc = howmany(fs->e2fs_gcount, e2fs_descpb);
  632         } else {
  633                 e2fs_descpb = fs->e2fs_bsize / E2FS_REV0_GD_SIZE;
  634                 e2fs_gdbcount_alloc = howmany(fs->e2fs_gcount,
  635                     fs->e2fs_bsize / sizeof(struct ext2_gd));
  636         }
  637         fs->e2fs_gdbcount = howmany(fs->e2fs_gcount, e2fs_descpb);
  638         fs->e2fs_gd = malloc(e2fs_gdbcount_alloc * fs->e2fs_bsize,
  639             M_EXT2MNT, M_WAITOK | M_ZERO);
  640         fs->e2fs_contigdirs = malloc(fs->e2fs_gcount *
  641             sizeof(*fs->e2fs_contigdirs), M_EXT2MNT, M_WAITOK | M_ZERO);
  642 
  643         for (i = 0; i < fs->e2fs_gdbcount; i++) {
  644                 error = bread(devvp,
  645                     fsbtodb(fs, ext2_cg_location(fs, i)),
  646                     fs->e2fs_bsize, NOCRED, &bp);
  647                 if (error) {
  648                         /*
  649                          * fs->e2fs_gd and fs->e2fs_contigdirs
  650                          * will be freed later by the caller,
  651                          * because this function could be called from
  652                          * MNT_UPDATE path.
  653                          */
  654                         brelse(bp);
  655                         return (error);
  656                 }
  657                 if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT)) {
  658                         memcpy(&fs->e2fs_gd[
  659                             i * fs->e2fs_bsize / sizeof(struct ext2_gd)],
  660                             bp->b_data, fs->e2fs_bsize);
  661                 } else {
  662                         for (j = 0; j < e2fs_descpb &&
  663                             g_count < fs->e2fs_gcount; j++, g_count++)
  664                                 memcpy(&fs->e2fs_gd[g_count],
  665                                     bp->b_data + j * E2FS_REV0_GD_SIZE,
  666                                     E2FS_REV0_GD_SIZE);
  667                 }
  668                 brelse(bp);
  669                 bp = NULL;
  670         }
  671 
  672         /* Validate cgs consistency */
  673         error = ext2_cg_validate(fs);
  674         if (error)
  675                 return (error);
  676 
  677         /* Verfy cgs csum */
  678         if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM) ||
  679             EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) {
  680                 error = ext2_gd_csum_verify(fs, devvp->v_rdev);
  681                 if (error)
  682                         return (error);
  683         }
  684         /* Initialization for the ext2 Orlov allocator variant. */
  685         fs->e2fs_total_dir = 0;
  686         for (i = 0; i < fs->e2fs_gcount; i++)
  687                 fs->e2fs_total_dir += e2fs_gd_get_ndirs(&fs->e2fs_gd[i]);
  688 
  689         if (es->e2fs_rev == E2FS_REV0 ||
  690             !EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_LARGEFILE))
  691                 fs->e2fs_maxfilesize = 0x7fffffff;
  692         else {
  693                 fs->e2fs_maxfilesize = 0xffffffffffff;
  694                 if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_HUGE_FILE))
  695                         fs->e2fs_maxfilesize = 0x7fffffffffffffff;
  696         }
  697         if (es->e4fs_flags & E2FS_UNSIGNED_HASH) {
  698                 fs->e2fs_uhash = 3;
  699         } else if ((es->e4fs_flags & E2FS_SIGNED_HASH) == 0) {
  700 #ifdef __CHAR_UNSIGNED__
  701                 es->e4fs_flags |= E2FS_UNSIGNED_HASH;
  702                 fs->e2fs_uhash = 3;
  703 #else
  704                 es->e4fs_flags |= E2FS_SIGNED_HASH;
  705 #endif
  706         }
  707         if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))
  708                 error = ext2_sb_csum_verify(fs);
  709 
  710         return (error);
  711 }
  712 
  713 /*
  714  * Reload all incore data for a filesystem (used after running fsck on
  715  * the root filesystem and finding things to fix). The filesystem must
  716  * be mounted read-only.
  717  *
  718  * Things to do to update the mount:
  719  *      1) invalidate all cached meta-data.
  720  *      2) re-read superblock from disk.
  721  *      3) invalidate all cluster summary information.
  722  *      4) invalidate all inactive vnodes.
  723  *      5) invalidate all cached file data.
  724  *      6) re-read inode data for all active vnodes.
  725  * XXX we are missing some steps, in particular # 3, this has to be reviewed.
  726  */
  727 static int
  728 ext2_reload(struct mount *mp, struct thread *td)
  729 {
  730         struct vnode *vp, *mvp, *devvp;
  731         struct inode *ip;
  732         struct buf *bp;
  733         struct ext2fs *es;
  734         struct m_ext2fs *fs;
  735         struct csum *sump;
  736         int error, i;
  737         int32_t *lp;
  738 
  739         if ((mp->mnt_flag & MNT_RDONLY) == 0)
  740                 return (EINVAL);
  741         /*
  742          * Step 1: invalidate all cached meta-data.
  743          */
  744         devvp = VFSTOEXT2(mp)->um_devvp;
  745         vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
  746         if (vinvalbuf(devvp, 0, 0, 0) != 0)
  747                 panic("ext2_reload: dirty1");
  748         VOP_UNLOCK(devvp, 0);
  749 
  750         /*
  751          * Step 2: re-read superblock from disk.
  752          * constants have been adjusted for ext2
  753          */
  754         if ((error = bread(devvp, SBLOCK, SBSIZE, NOCRED, &bp)) != 0)
  755                 return (error);
  756         es = (struct ext2fs *)bp->b_data;
  757         if (ext2_check_sb_compat(es, devvp->v_rdev, 0) != 0) {
  758                 brelse(bp);
  759                 return (EIO);           /* XXX needs translation */
  760         }
  761         fs = VFSTOEXT2(mp)->um_e2fs;
  762         bcopy(bp->b_data, fs->e2fs, sizeof(struct ext2fs));
  763 
  764         if ((error = ext2_compute_sb_data(devvp, es, fs)) != 0) {
  765                 brelse(bp);
  766                 return (error);
  767         }
  768 #ifdef UNKLAR
  769         if (fs->fs_sbsize < SBSIZE)
  770                 bp->b_flags |= B_INVAL;
  771 #endif
  772         brelse(bp);
  773 
  774         /*
  775          * Step 3: invalidate all cluster summary information.
  776          */
  777         if (fs->e2fs_contigsumsize > 0) {
  778                 lp = fs->e2fs_maxcluster;
  779                 sump = fs->e2fs_clustersum;
  780                 for (i = 0; i < fs->e2fs_gcount; i++, sump++) {
  781                         *lp++ = fs->e2fs_contigsumsize;
  782                         sump->cs_init = 0;
  783                         bzero(sump->cs_sum, fs->e2fs_contigsumsize + 1);
  784                 }
  785         }
  786 
  787 loop:
  788         MNT_VNODE_FOREACH_ALL(vp, mp, mvp) {
  789                 /*
  790                  * Step 4: invalidate all cached file data.
  791                  */
  792                 if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) {
  793                         MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);
  794                         goto loop;
  795                 }
  796                 if (vinvalbuf(vp, 0, 0, 0))
  797                         panic("ext2_reload: dirty2");
  798 
  799                 /*
  800                  * Step 5: re-read inode data for all active vnodes.
  801                  */
  802                 ip = VTOI(vp);
  803                 error = bread(devvp, fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
  804                     (int)fs->e2fs_bsize, NOCRED, &bp);
  805                 if (error) {
  806                         VOP_UNLOCK(vp, 0);
  807                         vrele(vp);
  808                         MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);
  809                         return (error);
  810                 }
  811 
  812                 error = ext2_ei2i((struct ext2fs_dinode *)((char *)bp->b_data +
  813                     EXT2_INODE_SIZE(fs) * ino_to_fsbo(fs, ip->i_number)), ip);
  814 
  815                 brelse(bp);
  816                 VOP_UNLOCK(vp, 0);
  817                 vrele(vp);
  818 
  819                 if (error) {
  820                         MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);
  821                         return (error);
  822                 }
  823         }
  824         return (0);
  825 }
  826 
  827 /*
  828  * Common code for mount and mountroot.
  829  */
  830 static int
  831 ext2_mountfs(struct vnode *devvp, struct mount *mp)
  832 {
  833         struct ext2mount *ump;
  834         struct buf *bp;
  835         struct m_ext2fs *fs;
  836         struct ext2fs *es;
  837         struct cdev *dev = devvp->v_rdev;
  838         struct g_consumer *cp;
  839         struct bufobj *bo;
  840         struct csum *sump;
  841         int error;
  842         int ronly;
  843         int i;
  844         u_long size;
  845         int32_t *lp;
  846         int32_t e2fs_maxcontig;
  847 
  848         ronly = vfs_flagopt(mp->mnt_optnew, "ro", NULL, 0);
  849         /* XXX: use VOP_ACESS to check FS perms */
  850         g_topology_lock();
  851         error = g_vfs_open(devvp, &cp, "ext2fs", ronly ? 0 : 1);
  852         g_topology_unlock();
  853         VOP_UNLOCK(devvp, 0);
  854         if (error)
  855                 return (error);
  856 
  857         /* XXX: should we check for some sectorsize or 512 instead? */
  858         if (((SBSIZE % cp->provider->sectorsize) != 0) ||
  859             (SBSIZE < cp->provider->sectorsize)) {
  860                 g_topology_lock();
  861                 g_vfs_close(cp);
  862                 g_topology_unlock();
  863                 return (EINVAL);
  864         }
  865 
  866         bo = &devvp->v_bufobj;
  867         bo->bo_private = cp;
  868         bo->bo_ops = g_vfs_bufops;
  869         if (devvp->v_rdev->si_iosize_max != 0)
  870                 mp->mnt_iosize_max = devvp->v_rdev->si_iosize_max;
  871         if (mp->mnt_iosize_max > MAXPHYS)
  872                 mp->mnt_iosize_max = MAXPHYS;
  873 
  874         bp = NULL;
  875         ump = NULL;
  876         if ((error = bread(devvp, SBLOCK, SBSIZE, NOCRED, &bp)) != 0)
  877                 goto out;
  878         es = (struct ext2fs *)bp->b_data;
  879         if (ext2_check_sb_compat(es, dev, ronly) != 0) {
  880                 error = EINVAL;         /* XXX needs translation */
  881                 goto out;
  882         }
  883         if ((es->e2fs_state & E2FS_ISCLEAN) == 0 ||
  884             (es->e2fs_state & E2FS_ERRORS)) {
  885                 if (ronly || (mp->mnt_flag & MNT_FORCE)) {
  886                         printf(
  887 "WARNING: Filesystem was not properly dismounted\n");
  888                 } else {
  889                         printf(
  890 "WARNING: R/W mount denied.  Filesystem is not clean - run fsck\n");
  891                         error = EPERM;
  892                         goto out;
  893                 }
  894         }
  895         ump = malloc(sizeof(*ump), M_EXT2MNT, M_WAITOK | M_ZERO);
  896 
  897         /*
  898          * I don't know whether this is the right strategy. Note that
  899          * we dynamically allocate both an m_ext2fs and an ext2fs
  900          * while Linux keeps the super block in a locked buffer.
  901          */
  902         ump->um_e2fs = malloc(sizeof(struct m_ext2fs),
  903             M_EXT2MNT, M_WAITOK | M_ZERO);
  904         ump->um_e2fs->e2fs = malloc(sizeof(struct ext2fs),
  905             M_EXT2MNT, M_WAITOK);
  906         mtx_init(EXT2_MTX(ump), "EXT2FS", "EXT2FS Lock", MTX_DEF);
  907         bcopy(es, ump->um_e2fs->e2fs, (u_int)sizeof(struct ext2fs));
  908         if ((error = ext2_compute_sb_data(devvp, ump->um_e2fs->e2fs, ump->um_e2fs)))
  909                 goto out;
  910 
  911         /*
  912          * Calculate the maximum contiguous blocks and size of cluster summary
  913          * array.  In FFS this is done by newfs; however, the superblock
  914          * in ext2fs doesn't have these variables, so we can calculate
  915          * them here.
  916          */
  917         e2fs_maxcontig = MAX(1, MAXPHYS / ump->um_e2fs->e2fs_bsize);
  918         ump->um_e2fs->e2fs_contigsumsize = MIN(e2fs_maxcontig, EXT2_MAXCONTIG);
  919         if (ump->um_e2fs->e2fs_contigsumsize > 0) {
  920                 size = ump->um_e2fs->e2fs_gcount * sizeof(int32_t);
  921                 ump->um_e2fs->e2fs_maxcluster = malloc(size, M_EXT2MNT, M_WAITOK);
  922                 size = ump->um_e2fs->e2fs_gcount * sizeof(struct csum);
  923                 ump->um_e2fs->e2fs_clustersum = malloc(size, M_EXT2MNT, M_WAITOK);
  924                 lp = ump->um_e2fs->e2fs_maxcluster;
  925                 sump = ump->um_e2fs->e2fs_clustersum;
  926                 for (i = 0; i < ump->um_e2fs->e2fs_gcount; i++, sump++) {
  927                         *lp++ = ump->um_e2fs->e2fs_contigsumsize;
  928                         sump->cs_init = 0;
  929                         sump->cs_sum = malloc((ump->um_e2fs->e2fs_contigsumsize + 1) *
  930                             sizeof(int32_t), M_EXT2MNT, M_WAITOK | M_ZERO);
  931                 }
  932         }
  933 
  934         brelse(bp);
  935         bp = NULL;
  936         fs = ump->um_e2fs;
  937         fs->e2fs_ronly = ronly; /* ronly is set according to mnt_flags */
  938 
  939         /*
  940          * If the fs is not mounted read-only, make sure the super block is
  941          * always written back on a sync().
  942          */
  943         fs->e2fs_wasvalid = fs->e2fs->e2fs_state & E2FS_ISCLEAN ? 1 : 0;
  944         if (ronly == 0) {
  945                 fs->e2fs_fmod = 1;      /* mark it modified */
  946                 fs->e2fs->e2fs_state &= ~E2FS_ISCLEAN;  /* set fs invalid */
  947         }
  948         mp->mnt_data = ump;
  949         mp->mnt_stat.f_fsid.val[0] = dev2udev(dev);
  950         mp->mnt_stat.f_fsid.val[1] = mp->mnt_vfc->vfc_typenum;
  951         mp->mnt_maxsymlinklen = EXT2_MAXSYMLINKLEN;
  952         MNT_ILOCK(mp);
  953         mp->mnt_flag |= MNT_LOCAL;
  954         MNT_IUNLOCK(mp);
  955         ump->um_mountp = mp;
  956         ump->um_dev = dev;
  957         ump->um_devvp = devvp;
  958         ump->um_bo = &devvp->v_bufobj;
  959         ump->um_cp = cp;
  960 
  961         /*
  962          * Setting those two parameters allowed us to use
  963          * ufs_bmap w/o changse!
  964          */
  965         ump->um_nindir = EXT2_ADDR_PER_BLOCK(fs);
  966         ump->um_bptrtodb = fs->e2fs->e2fs_log_bsize + 1;
  967         ump->um_seqinc = EXT2_FRAGS_PER_BLOCK(fs);
  968         if (ronly == 0)
  969                 ext2_sbupdate(ump, MNT_WAIT);
  970         /*
  971          * Initialize filesystem stat information in mount struct.
  972          */
  973         MNT_ILOCK(mp);
  974         mp->mnt_kern_flag |= MNTK_LOOKUP_SHARED | MNTK_EXTENDED_SHARED |
  975             MNTK_USES_BCACHE;
  976         MNT_IUNLOCK(mp);
  977         return (0);
  978 out:
  979         if (bp)
  980                 brelse(bp);
  981         if (cp != NULL) {
  982                 g_topology_lock();
  983                 g_vfs_close(cp);
  984                 g_topology_unlock();
  985         }
  986         if (ump) {
  987                 mtx_destroy(EXT2_MTX(ump));
  988                 free(ump->um_e2fs->e2fs_gd, M_EXT2MNT);
  989                 free(ump->um_e2fs->e2fs_contigdirs, M_EXT2MNT);
  990                 free(ump->um_e2fs->e2fs, M_EXT2MNT);
  991                 free(ump->um_e2fs, M_EXT2MNT);
  992                 free(ump, M_EXT2MNT);
  993                 mp->mnt_data = NULL;
  994         }
  995         return (error);
  996 }
  997 
  998 /*
  999  * Unmount system call.
 1000  */
 1001 static int
 1002 ext2_unmount(struct mount *mp, int mntflags)
 1003 {
 1004         struct ext2mount *ump;
 1005         struct m_ext2fs *fs;
 1006         struct csum *sump;
 1007         int error, flags, i, ronly;
 1008 
 1009         flags = 0;
 1010         if (mntflags & MNT_FORCE) {
 1011                 if (mp->mnt_flag & MNT_ROOTFS)
 1012                         return (EINVAL);
 1013                 flags |= FORCECLOSE;
 1014         }
 1015         if ((error = ext2_flushfiles(mp, flags, curthread)) != 0)
 1016                 return (error);
 1017         ump = VFSTOEXT2(mp);
 1018         fs = ump->um_e2fs;
 1019         ronly = fs->e2fs_ronly;
 1020         if (ronly == 0 && ext2_cgupdate(ump, MNT_WAIT) == 0) {
 1021                 if (fs->e2fs_wasvalid)
 1022                         fs->e2fs->e2fs_state |= E2FS_ISCLEAN;
 1023                 ext2_sbupdate(ump, MNT_WAIT);
 1024         }
 1025 
 1026         g_topology_lock();
 1027         g_vfs_close(ump->um_cp);
 1028         g_topology_unlock();
 1029         vrele(ump->um_devvp);
 1030         sump = fs->e2fs_clustersum;
 1031         for (i = 0; i < fs->e2fs_gcount; i++, sump++)
 1032                 free(sump->cs_sum, M_EXT2MNT);
 1033         free(fs->e2fs_clustersum, M_EXT2MNT);
 1034         free(fs->e2fs_maxcluster, M_EXT2MNT);
 1035         free(fs->e2fs_gd, M_EXT2MNT);
 1036         free(fs->e2fs_contigdirs, M_EXT2MNT);
 1037         free(fs->e2fs, M_EXT2MNT);
 1038         free(fs, M_EXT2MNT);
 1039         free(ump, M_EXT2MNT);
 1040         mp->mnt_data = NULL;
 1041         MNT_ILOCK(mp);
 1042         mp->mnt_flag &= ~MNT_LOCAL;
 1043         MNT_IUNLOCK(mp);
 1044         return (error);
 1045 }
 1046 
 1047 /*
 1048  * Flush out all the files in a filesystem.
 1049  */
 1050 static int
 1051 ext2_flushfiles(struct mount *mp, int flags, struct thread *td)
 1052 {
 1053         int error;
 1054 
 1055         error = vflush(mp, 0, flags, td);
 1056         return (error);
 1057 }
 1058 
 1059 /*
 1060  * Get filesystem statistics.
 1061  */
 1062 int
 1063 ext2_statfs(struct mount *mp, struct statfs *sbp)
 1064 {
 1065         struct ext2mount *ump;
 1066         struct m_ext2fs *fs;
 1067         uint32_t overhead, overhead_per_group, ngdb;
 1068         int i, ngroups;
 1069 
 1070         ump = VFSTOEXT2(mp);
 1071         fs = ump->um_e2fs;
 1072         if (fs->e2fs->e2fs_magic != E2FS_MAGIC)
 1073                 panic("ext2_statfs");
 1074 
 1075         /*
 1076          * Compute the overhead (FS structures)
 1077          */
 1078         overhead_per_group =
 1079             1 /* block bitmap */ +
 1080             1 /* inode bitmap */ +
 1081             fs->e2fs_itpg;
 1082         overhead = fs->e2fs->e2fs_first_dblock +
 1083             fs->e2fs_gcount * overhead_per_group;
 1084         if (fs->e2fs->e2fs_rev > E2FS_REV0 &&
 1085             fs->e2fs->e2fs_features_rocompat & EXT2F_ROCOMPAT_SPARSESUPER) {
 1086                 for (i = 0, ngroups = 0; i < fs->e2fs_gcount; i++) {
 1087                         if (ext2_cg_has_sb(fs, i))
 1088                                 ngroups++;
 1089                 }
 1090         } else {
 1091                 ngroups = fs->e2fs_gcount;
 1092         }
 1093         ngdb = fs->e2fs_gdbcount;
 1094         if (fs->e2fs->e2fs_rev > E2FS_REV0 &&
 1095             fs->e2fs->e2fs_features_compat & EXT2F_COMPAT_RESIZE)
 1096                 ngdb += fs->e2fs->e2fs_reserved_ngdb;
 1097         overhead += ngroups * (1 /* superblock */ + ngdb);
 1098 
 1099         sbp->f_bsize = EXT2_FRAG_SIZE(fs);
 1100         sbp->f_iosize = EXT2_BLOCK_SIZE(fs);
 1101         sbp->f_blocks = fs->e2fs_bcount - overhead;
 1102         sbp->f_bfree = fs->e2fs_fbcount;
 1103         sbp->f_bavail = sbp->f_bfree - fs->e2fs_rbcount;
 1104         sbp->f_files = fs->e2fs->e2fs_icount;
 1105         sbp->f_ffree = fs->e2fs->e2fs_ficount;
 1106         return (0);
 1107 }
 1108 
 1109 /*
 1110  * Go through the disk queues to initiate sandbagged IO;
 1111  * go through the inodes to write those that have been modified;
 1112  * initiate the writing of the super block if it has been modified.
 1113  *
 1114  * Note: we are always called with the filesystem marked `MPBUSY'.
 1115  */
 1116 static int
 1117 ext2_sync(struct mount *mp, int waitfor)
 1118 {
 1119         struct vnode *mvp, *vp;
 1120         struct thread *td;
 1121         struct inode *ip;
 1122         struct ext2mount *ump = VFSTOEXT2(mp);
 1123         struct m_ext2fs *fs;
 1124         int error, allerror = 0;
 1125 
 1126         td = curthread;
 1127         fs = ump->um_e2fs;
 1128         if (fs->e2fs_fmod != 0 && fs->e2fs_ronly != 0) {                /* XXX */
 1129                 panic("ext2_sync: rofs mod fs=%s", fs->e2fs_fsmnt);
 1130         }
 1131 
 1132         /*
 1133          * Write back each (modified) inode.
 1134          */
 1135 loop:
 1136         MNT_VNODE_FOREACH_ALL(vp, mp, mvp) {
 1137                 if (vp->v_type == VNON) {
 1138                         VI_UNLOCK(vp);
 1139                         continue;
 1140                 }
 1141                 ip = VTOI(vp);
 1142                 if ((ip->i_flag &
 1143                     (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) == 0 &&
 1144                     (vp->v_bufobj.bo_dirty.bv_cnt == 0 ||
 1145                     waitfor == MNT_LAZY)) {
 1146                         VI_UNLOCK(vp);
 1147                         continue;
 1148                 }
 1149                 error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK, td);
 1150                 if (error) {
 1151                         if (error == ENOENT) {
 1152                                 MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);
 1153                                 goto loop;
 1154                         }
 1155                         continue;
 1156                 }
 1157                 if ((error = VOP_FSYNC(vp, waitfor, td)) != 0)
 1158                         allerror = error;
 1159                 VOP_UNLOCK(vp, 0);
 1160                 vrele(vp);
 1161         }
 1162 
 1163         /*
 1164          * Force stale filesystem control information to be flushed.
 1165          */
 1166         if (waitfor != MNT_LAZY) {
 1167                 vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
 1168                 if ((error = VOP_FSYNC(ump->um_devvp, waitfor, td)) != 0)
 1169                         allerror = error;
 1170                 VOP_UNLOCK(ump->um_devvp, 0);
 1171         }
 1172 
 1173         /*
 1174          * Write back modified superblock.
 1175          */
 1176         if (fs->e2fs_fmod != 0) {
 1177                 fs->e2fs_fmod = 0;
 1178                 fs->e2fs->e2fs_wtime = time_second;
 1179                 if ((error = ext2_cgupdate(ump, waitfor)) != 0)
 1180                         allerror = error;
 1181         }
 1182         return (allerror);
 1183 }
 1184 
 1185 /*
 1186  * Look up an EXT2FS dinode number to find its incore vnode, otherwise read it
 1187  * in from disk.  If it is in core, wait for the lock bit to clear, then
 1188  * return the inode locked.  Detection and handling of mount points must be
 1189  * done by the calling routine.
 1190  */
 1191 static int
 1192 ext2_vget(struct mount *mp, ino_t ino, int flags, struct vnode **vpp)
 1193 {
 1194         struct m_ext2fs *fs;
 1195         struct inode *ip;
 1196         struct ext2mount *ump;
 1197         struct buf *bp;
 1198         struct vnode *vp;
 1199         struct thread *td;
 1200         unsigned int i, used_blocks;
 1201         int error;
 1202 
 1203         td = curthread;
 1204         error = vfs_hash_get(mp, ino, flags, td, vpp, NULL, NULL);
 1205         if (error || *vpp != NULL)
 1206                 return (error);
 1207 
 1208         ump = VFSTOEXT2(mp);
 1209         ip = malloc(sizeof(struct inode), M_EXT2NODE, M_WAITOK | M_ZERO);
 1210 
 1211         /* Allocate a new vnode/inode. */
 1212         if ((error = getnewvnode("ext2fs", mp, &ext2_vnodeops, &vp)) != 0) {
 1213                 *vpp = NULL;
 1214                 free(ip, M_EXT2NODE);
 1215                 return (error);
 1216         }
 1217         vp->v_data = ip;
 1218         ip->i_vnode = vp;
 1219         ip->i_e2fs = fs = ump->um_e2fs;
 1220         ip->i_ump = ump;
 1221         ip->i_number = ino;
 1222 
 1223         lockmgr(vp->v_vnlock, LK_EXCLUSIVE, NULL);
 1224         error = insmntque(vp, mp);
 1225         if (error != 0) {
 1226                 free(ip, M_EXT2NODE);
 1227                 *vpp = NULL;
 1228                 return (error);
 1229         }
 1230         error = vfs_hash_insert(vp, ino, flags, td, vpp, NULL, NULL);
 1231         if (error || *vpp != NULL)
 1232                 return (error);
 1233 
 1234         /* Read in the disk contents for the inode, copy into the inode. */
 1235         if ((error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ino)),
 1236             (int)fs->e2fs_bsize, NOCRED, &bp)) != 0) {
 1237                 /*
 1238                  * The inode does not contain anything useful, so it would
 1239                  * be misleading to leave it on its hash chain. With mode
 1240                  * still zero, it will be unlinked and returned to the free
 1241                  * list by vput().
 1242                  */
 1243                 brelse(bp);
 1244                 vput(vp);
 1245                 *vpp = NULL;
 1246                 return (error);
 1247         }
 1248         /* convert ext2 inode to dinode */
 1249         error = ext2_ei2i((struct ext2fs_dinode *)((char *)bp->b_data +
 1250             EXT2_INODE_SIZE(fs) * ino_to_fsbo(fs, ino)), ip);
 1251         if (error) {
 1252                 brelse(bp);
 1253                 vput(vp);
 1254                 *vpp = NULL;
 1255                 return (error);
 1256         }
 1257         ip->i_block_group = ino_to_cg(fs, ino);
 1258         ip->i_next_alloc_block = 0;
 1259         ip->i_next_alloc_goal = 0;
 1260 
 1261         /*
 1262          * Now we want to make sure that block pointers for unused
 1263          * blocks are zeroed out - ext2_balloc depends on this
 1264          * although for regular files and directories only
 1265          *
 1266          * If IN_E4EXTENTS is enabled, unused blocks are not zeroed
 1267          * out because we could corrupt the extent tree.
 1268          */
 1269         if (!(ip->i_flag & IN_E4EXTENTS) &&
 1270             (S_ISDIR(ip->i_mode) || S_ISREG(ip->i_mode))) {
 1271                 used_blocks = howmany(ip->i_size, fs->e2fs_bsize);
 1272                 for (i = used_blocks; i < EXT2_NDIR_BLOCKS; i++)
 1273                         ip->i_db[i] = 0;
 1274         }
 1275 #ifdef EXT2FS_PRINT_EXTENTS
 1276         ext2_print_inode(ip);
 1277         ext4_ext_print_extent_tree_status(ip);
 1278 #endif
 1279         bqrelse(bp);
 1280 
 1281         /*
 1282          * Initialize the vnode from the inode, check for aliases.
 1283          * Note that the underlying vnode may have changed.
 1284          */
 1285         if ((error = ext2_vinit(mp, &ext2_fifoops, &vp)) != 0) {
 1286                 vput(vp);
 1287                 *vpp = NULL;
 1288                 return (error);
 1289         }
 1290 
 1291         /*
 1292          * Finish inode initialization.
 1293          */
 1294 
 1295         *vpp = vp;
 1296         return (0);
 1297 }
 1298 
 1299 /*
 1300  * File handle to vnode
 1301  *
 1302  * Have to be really careful about stale file handles:
 1303  * - check that the inode number is valid
 1304  * - call ext2_vget() to get the locked inode
 1305  * - check for an unallocated inode (i_mode == 0)
 1306  * - check that the given client host has export rights and return
 1307  *   those rights via. exflagsp and credanonp
 1308  */
 1309 static int
 1310 ext2_fhtovp(struct mount *mp, struct fid *fhp, int flags, struct vnode **vpp)
 1311 {
 1312         struct inode *ip;
 1313         struct ufid *ufhp;
 1314         struct vnode *nvp;
 1315         struct m_ext2fs *fs;
 1316         int error;
 1317 
 1318         ufhp = (struct ufid *)fhp;
 1319         fs = VFSTOEXT2(mp)->um_e2fs;
 1320         if (ufhp->ufid_ino < EXT2_ROOTINO ||
 1321             ufhp->ufid_ino > fs->e2fs_gcount * fs->e2fs->e2fs_ipg)
 1322                 return (ESTALE);
 1323 
 1324         error = VFS_VGET(mp, ufhp->ufid_ino, LK_EXCLUSIVE, &nvp);
 1325         if (error) {
 1326                 *vpp = NULLVP;
 1327                 return (error);
 1328         }
 1329         ip = VTOI(nvp);
 1330         if (ip->i_mode == 0 ||
 1331             ip->i_gen != ufhp->ufid_gen || ip->i_nlink <= 0) {
 1332                 vput(nvp);
 1333                 *vpp = NULLVP;
 1334                 return (ESTALE);
 1335         }
 1336         *vpp = nvp;
 1337         vnode_create_vobject(*vpp, 0, curthread);
 1338         return (0);
 1339 }
 1340 
 1341 /*
 1342  * Write a superblock and associated information back to disk.
 1343  */
 1344 static int
 1345 ext2_sbupdate(struct ext2mount *mp, int waitfor)
 1346 {
 1347         struct m_ext2fs *fs = mp->um_e2fs;
 1348         struct ext2fs *es = fs->e2fs;
 1349         struct buf *bp;
 1350         int error = 0;
 1351 
 1352         es->e2fs_bcount = fs->e2fs_bcount & 0xffffffff;
 1353         es->e2fs_rbcount = fs->e2fs_rbcount & 0xffffffff;
 1354         es->e2fs_fbcount = fs->e2fs_fbcount & 0xffffffff;
 1355         if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT)) {
 1356                 es->e4fs_bcount_hi = fs->e2fs_bcount >> 32;
 1357                 es->e4fs_rbcount_hi = fs->e2fs_rbcount >> 32;
 1358                 es->e4fs_fbcount_hi = fs->e2fs_fbcount >> 32;
 1359         }
 1360 
 1361         if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))
 1362                 ext2_sb_csum_set(fs);
 1363 
 1364         bp = getblk(mp->um_devvp, SBLOCK, SBSIZE, 0, 0, 0);
 1365         bcopy((caddr_t)es, bp->b_data, (u_int)sizeof(struct ext2fs));
 1366         if (waitfor == MNT_WAIT)
 1367                 error = bwrite(bp);
 1368         else
 1369                 bawrite(bp);
 1370 
 1371         /*
 1372          * The buffers for group descriptors, inode bitmaps and block bitmaps
 1373          * are not busy at this point and are (hopefully) written by the
 1374          * usual sync mechanism. No need to write them here.
 1375          */
 1376         return (error);
 1377 }
 1378 int
 1379 ext2_cgupdate(struct ext2mount *mp, int waitfor)
 1380 {
 1381         struct m_ext2fs *fs = mp->um_e2fs;
 1382         struct buf *bp;
 1383         int i, j, g_count = 0, error = 0, allerror = 0;
 1384 
 1385         allerror = ext2_sbupdate(mp, waitfor);
 1386 
 1387         /* Update gd csums */
 1388         if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM) ||
 1389             EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM))
 1390                 ext2_gd_csum_set(fs);
 1391 
 1392         for (i = 0; i < fs->e2fs_gdbcount; i++) {
 1393                 bp = getblk(mp->um_devvp, fsbtodb(fs,
 1394                     ext2_cg_location(fs, i)),
 1395                     fs->e2fs_bsize, 0, 0, 0);
 1396                 if (EXT2_HAS_INCOMPAT_FEATURE(fs, EXT2F_INCOMPAT_64BIT)) {
 1397                         memcpy(bp->b_data, &fs->e2fs_gd[
 1398                             i * fs->e2fs_bsize / sizeof(struct ext2_gd)],
 1399                             fs->e2fs_bsize);
 1400                 } else {
 1401                         for (j = 0; j < fs->e2fs_bsize / E2FS_REV0_GD_SIZE &&
 1402                             g_count < fs->e2fs_gcount; j++, g_count++)
 1403                                 memcpy(bp->b_data + j * E2FS_REV0_GD_SIZE,
 1404                                     &fs->e2fs_gd[g_count], E2FS_REV0_GD_SIZE);
 1405                 }
 1406                 if (waitfor == MNT_WAIT)
 1407                         error = bwrite(bp);
 1408                 else
 1409                         bawrite(bp);
 1410         }
 1411 
 1412         if (!allerror && error)
 1413                 allerror = error;
 1414         return (allerror);
 1415 }
 1416 
 1417 /*
 1418  * Return the root of a filesystem.
 1419  */
 1420 static int
 1421 ext2_root(struct mount *mp, int flags, struct vnode **vpp)
 1422 {
 1423         struct vnode *nvp;
 1424         int error;
 1425 
 1426         error = VFS_VGET(mp, EXT2_ROOTINO, LK_EXCLUSIVE, &nvp);
 1427         if (error)
 1428                 return (error);
 1429         *vpp = nvp;
 1430         return (0);
 1431 }

Cache object: 036be18147c4584692548a0d1d577181


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.