ldiskfs/kernel_patches/patches/ext3-uninit-2.6.18.patch

   1 Add support for the uninit_groups feature to the kernel.
   2
   3 Keep a high water mark of used inodes for each group to improve e2fsck time.
   4 Block and inode bitmaps can be uninitialized on disk via a flag in the
   5 group descriptor to avoid reading or scanning them at e2fsck time.
   6 A checksum of each group descriptor is used to ensure that corruption in
   7 the group descriptor's bit flags does not cause incorrect operation.
   8
   9 Index: linux-2.6.18-53.1.14/include/linux/ext3_fs.h
  10 ===================================================================
  11 --- linux-2.6.18-53.1.14.orig/include/linux/ext3_fs.h
  12 +++ linux-2.6.18-53.1.14/include/linux/ext3_fs.h
  13 @@ -150,16 +150,22 @@ struct ext3_allocation_request {
  14   */
  15  struct ext3_group_desc
  16  {
  17 -       __le32  bg_block_bitmap;                /* Blocks bitmap block */
  18 -       __le32  bg_inode_bitmap;                /* Inodes bitmap block */
  19 +       __le32  bg_block_bitmap;        /* Blocks bitmap block */
  20 +       __le32  bg_inode_bitmap;        /* Inodes bitmap block */
  21         __le32  bg_inode_table;         /* Inodes table block */
  22         __le16  bg_free_blocks_count;   /* Free blocks count */
  23         __le16  bg_free_inodes_count;   /* Free inodes count */
  24         __le16  bg_used_dirs_count;     /* Directories count */
  25 -       __u16   bg_pad;
  26 -       __le32  bg_reserved[3];
  27 +       __le16  bg_flags;               /* EXT3_BG_flags (UNINIT, etc) */
  28 +       __le32  bg_reserved[2];         /* Likely block/inode bitmap checksum */
  29 +       __le16  bg_itable_unused;       /* Unused inodes count */
  30 +       __le16  bg_checksum;            /* crc16(sb_uuid+group+desc) */
  31  };
  32
  33 +#define EXT3_BG_INODE_UNINIT   0x0001 /* Inode table/bitmap not in use */
  34 +#define EXT3_BG_BLOCK_UNINIT   0x0002 /* Block bitmap not in use */
  35 +#define EXT3_BG_INODE_ZEROED   0x0004 /* On-disk itable initialized to zero */
  36 +
  37  /*
  38   * Macro-instructions used to manage group descriptors
  39   */
  40 @@ -603,6 +609,7 @@ static inline int ext3_valid_inum(struct
  41  #define EXT3_FEATURE_RO_COMPAT_SPARSE_SUPER    0x0001
  42  #define EXT3_FEATURE_RO_COMPAT_LARGE_FILE      0x0002
  43  #define EXT3_FEATURE_RO_COMPAT_BTREE_DIR       0x0004
  44 +#define EXT4_FEATURE_RO_COMPAT_GDT_CSUM                0x0010
  45  #define EXT4_FEATURE_RO_COMPAT_DIR_NLINK       0x0020
  46
  47  #define EXT3_FEATURE_INCOMPAT_COMPRESSION      0x0001
  48 @@ -619,6 +626,7 @@ static inline int ext3_valid_inum(struct
  49                                          EXT3_FEATURE_INCOMPAT_EXTENTS)
  50  #define EXT3_FEATURE_RO_COMPAT_SUPP    (EXT3_FEATURE_RO_COMPAT_SPARSE_SUPER| \
  51                                          EXT3_FEATURE_RO_COMPAT_LARGE_FILE| \
  52 +                                        EXT4_FEATURE_RO_COMPAT_GDT_CSUM| \
  53                                          EXT4_FEATURE_RO_COMPAT_DIR_NLINK| \
  54                                          EXT3_FEATURE_RO_COMPAT_BTREE_DIR)
  55
  56 Index: linux-2.6.18-53.1.14/fs/ext3/resize.c
  57 ===================================================================
  58 --- linux-2.6.18-53.1.14.orig/fs/ext3/resize.c
  59 +++ linux-2.6.18-53.1.14/fs/ext3/resize.c
  60 @@ -18,6 +18,7 @@
  61  #include <linux/errno.h>
  62  #include <linux/slab.h>
  63
  64 +#include "group.h"
  65
  66  #define outside(b, first, last)        ((b) < (first) || (b) >= (last))
  67  #define inside(b, first, last) ((b) >= (first) && (b) < (last))
  68 @@ -137,25 +138,6 @@ static struct buffer_head *bclean(handle
  69  }
  70
  71  /*
  72 - * To avoid calling the atomic setbit hundreds or thousands of times, we only
  73 - * need to use it within a single byte (to ensure we get endianness right).
  74 - * We can use memset for the rest of the bitmap as there are no other users.
  75 - */
  76 -static void mark_bitmap_end(int start_bit, int end_bit, char *bitmap)
  77 -{
  78 -       int i;
  79 -
  80 -       if (start_bit >= end_bit)
  81 -               return;
  82 -
  83 -       ext3_debug("mark end bits +%d through +%d used\n", start_bit, end_bit);
  84 -       for (i = start_bit; i < ((start_bit + 7) & ~7UL); i++)
  85 -               ext3_set_bit(i, bitmap);
  86 -       if (i < end_bit)
  87 -               memset(bitmap + (i >> 3), 0xff, (end_bit - i) >> 3);
  88 -}
  89 -
  90 -/*
  91   * If we have fewer than thresh credits, extend by EXT3_MAX_TRANS_DATA.
  92   * If that fails, restart the transaction & regain write access for the
  93   * buffer head which is used for block_bitmap modifications.
  94 @@ -834,6 +816,7 @@ int ext3_group_add(struct super_block *s
  95         gdp->bg_inode_table = cpu_to_le32(input->inode_table);
  96         gdp->bg_free_blocks_count = cpu_to_le16(input->free_blocks_count);
  97         gdp->bg_free_inodes_count = cpu_to_le16(EXT3_INODES_PER_GROUP(sb));
  98 +       gdp->bg_checksum = ext3_group_desc_csum(sbi, input->group, gdp);
  99
 100         /*
 101          * Make the new blocks and inodes valid next.  We do this before
 102 Index: linux-2.6.18-53.1.14/fs/ext3/super.c
 103 ===================================================================
 104 --- linux-2.6.18-53.1.14.orig/fs/ext3/super.c
 105 +++ linux-2.6.18-53.1.14/fs/ext3/super.c
 106 @@ -41,6 +41,7 @@
 107  #include "xattr.h"
 108  #include "acl.h"
 109  #include "namei.h"
 110 +#include "group.h"
 111
 112  static int ext3_load_journal(struct super_block *, struct ext3_super_block *,
 113                              unsigned long journal_devnum);
 114 @@ -1227,6 +1228,91 @@ static int ext3_setup_super(struct super
 115         return res;
 116  }
 117
 118 +#if !defined(CONFIG_CRC16) && !defined(CONFIG_CRC16_MODULE)
 119 +/** CRC table for the CRC-16. The poly is 0x8005 (x^16 + x^15 + x^2 + 1) */
 120 +__u16 const crc16_table[256] = {
 121 +       0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241,
 122 +       0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440,
 123 +       0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40,
 124 +       0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841,
 125 +       0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40,
 126 +       0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41,
 127 +       0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641,
 128 +       0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040,
 129 +       0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240,
 130 +       0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441,
 131 +       0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41,
 132 +       0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840,
 133 +       0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41,
 134 +       0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40,
 135 +       0xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640,
 136 +       0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041,
 137 +       0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240,
 138 +       0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441,
 139 +       0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41,
 140 +       0xAA01, 0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840,
 141 +       0x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41,
 142 +       0xBE01, 0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40,
 143 +       0xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1, 0xB681, 0x7640,
 144 +       0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041,
 145 +       0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241,
 146 +       0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440,
 147 +       0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40,
 148 +       0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841,
 149 +       0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40,
 150 +       0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41,
 151 +       0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641,
 152 +       0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040
 153 +};
 154 +
 155 +static inline __u16 crc16_byte(__u16 crc, const __u8 data)
 156 +{
 157 +       return (crc >> 8) ^ crc16_table[(crc ^ data) & 0xff];
 158 +}
 159 +
 160 +__u16 crc16(__u16 crc, __u8 const *buffer, size_t len)
 161 +{
 162 +       while (len--)
 163 +               crc = crc16_byte(crc, *buffer++);
 164 +       return crc;
 165 +}
 166 +#endif
 167 +
 168 +__le16 ext3_group_desc_csum(struct ext3_sb_info *sbi, __u32 block_group,
 169 +                           struct ext3_group_desc *gdp)
 170 +{
 171 +       __u16 crc = 0;
 172 +
 173 +       if (sbi->s_es->s_feature_ro_compat &
 174 +           cpu_to_le32(EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) {
 175 +               int offset = offsetof(struct ext3_group_desc, bg_checksum);
 176 +               __le32 le_group = cpu_to_le32(block_group);
 177 +
 178 +               crc = crc16(~0, sbi->s_es->s_uuid, sizeof(sbi->s_es->s_uuid));
 179 +               crc = crc16(crc, (__u8 *)&le_group, sizeof(le_group));
 180 +               crc = crc16(crc, (__u8 *)gdp, offset);
 181 +               offset += sizeof(gdp->bg_checksum); /* skip checksum */
 182 +               BUG_ON(offset != sizeof(*gdp)); /* XXX handle s_desc_size */
 183 +               /* for checksum of struct ext4_group_desc do the rest...
 184 +               if ((sbi->s_es->s_feature_incompat &
 185 +                    cpu_to_le32(EXT4_FEATURE_INCOMPAT_64BIT)) &&
 186 +                    offset < le16_to_cpu(sbi->s_es->s_desc_size)) {
 187 +                       crc = crc16(crc, (__u8 *)gdp + offset,
 188 +                                   le16_to_cpu(sbi->s_es->s_desc_size) -
 189 +                                   offset);
 190 +               */
 191 +       }
 192 +
 193 +       return cpu_to_le16(crc);
 194 +}
 195 +
 196 +int ext3_group_desc_csum_verify(struct ext3_sb_info *sbi, __u32 block_group,
 197 +                               struct ext3_group_desc *gdp)
 198 +{
 199 +       return (gdp->bg_checksum ==
 200 +                       ext3_group_desc_csum(sbi, block_group, gdp));
 201 +}
 202 +
 203  /* Called at mount-time, super-block is locked */
 204  static int ext3_check_descriptors (struct super_block * sb)
 205  {
 206 @@ -1281,6 +1367,13 @@ static int ext3_check_descriptors (struc
 207                                         le32_to_cpu(gdp->bg_inode_table));
 208                         return 0;
 209                 }
 210 +               if (!ext3_group_desc_csum_verify(sbi, i, gdp)) {
 211 +                       ext3_error(sb, __FUNCTION__,
 212 +                                  "Checksum for group %d failed (%u!=%u)\n", i,
 213 +                                  le16_to_cpu(ext3_group_desc_csum(sbi,i,gdp)),
 214 +                                  le16_to_cpu(gdp->bg_checksum));
 215 +                       return 0;
 216 +               }
 217                 first_block += EXT3_BLOCKS_PER_GROUP(sb);
 218                 gdp++;
 219         }
 220 Index: linux-2.6.18-53.1.14/fs/ext3/group.h
 221 ===================================================================
 222 --- /dev/null
 223 +++ linux-2.6.18-53.1.14/fs/ext3/group.h
 224 @@ -0,0 +1,30 @@
 225 +/*
 226 + *  linux/fs/ext3/group.h
 227 + *
 228 + * Copyright 2008 Sun Microsystems, Inc.
 229 + *
 230 + * Author: Andreas Dilger <adilger@clusterfs.com>
 231 + */
 232 +
 233 +#ifndef _LINUX_EXT3_GROUP_H
 234 +#define _LINUX_EXT3_GROUP_H
 235 +#if defined(CONFIG_CRC16) || defined(CONFIG_CRC16_MODULE)
 236 +#include <linux/crc16.h>
 237 +#endif
 238 +
 239 +extern __le16 ext3_group_desc_csum(struct ext3_sb_info *sbi, __u32 group,
 240 +                                  struct ext3_group_desc *gdp);
 241 +extern int ext3_group_desc_csum_verify(struct ext3_sb_info *sbi, __u32 group,
 242 +                                      struct ext3_group_desc *gdp);
 243 +struct buffer_head *read_block_bitmap(struct super_block *sb,
 244 +                                     unsigned int block_group);
 245 +extern unsigned ext3_init_block_bitmap(struct super_block *sb,
 246 +                                      struct buffer_head *bh, int group,
 247 +                                      struct ext3_group_desc *desc);
 248 +#define ext3_free_blocks_after_init(sb, group, desc)                   \
 249 +               ext3_init_block_bitmap(sb, NULL, group, desc)
 250 +extern unsigned ext3_init_inode_bitmap(struct super_block *sb,
 251 +                                      struct buffer_head *bh, int group,
 252 +                                      struct ext3_group_desc *desc);
 253 +extern void mark_bitmap_end(int start_bit, int end_bit, char *bitmap);
 254 +#endif /* _LINUX_EXT3_GROUP_H */
 255 Index: linux-2.6.18-53.1.14/fs/ext3/ialloc.c
 256 ===================================================================
 257 --- linux-2.6.18-53.1.14.orig/fs/ext3/ialloc.c
 258 +++ linux-2.6.18-53.1.14/fs/ext3/ialloc.c
 259 @@ -28,6 +28,7 @@
 260
 261  #include "xattr.h"
 262  #include "acl.h"
 263 +#include "group.h"
 264
 265  /*
 266   * ialloc.c contains the inodes allocation and deallocation routines
 267 @@ -43,6 +44,52 @@
 268   * the free blocks count in the block.
 269   */
 270
 271 +/*
 272 + * To avoid calling the atomic setbit hundreds or thousands of times, we only
 273 + * need to use it within a single byte (to ensure we get endianness right).
 274 + * We can use memset for the rest of the bitmap as there are no other users.
 275 + */
 276 +void mark_bitmap_end(int start_bit, int end_bit, char *bitmap)
 277 +{
 278 +       int i;
 279 +
 280 +       if (start_bit >= end_bit)
 281 +               return;
 282 +
 283 +       ext3_debug("mark end bits +%d through +%d used\n", start_bit, end_bit);
 284 +       for (i = start_bit; i < ((start_bit + 7) & ~7UL); i++)
 285 +               ext3_set_bit(i, bitmap);
 286 +       if (i < end_bit)
 287 +               memset(bitmap + (i >> 3), 0xff, (end_bit - i) >> 3);
 288 +}
 289 +
 290 +/* Initializes an uninitialized inode bitmap */
 291 +unsigned ext3_init_inode_bitmap(struct super_block *sb,
 292 +                               struct buffer_head *bh, int block_group,
 293 +                               struct ext3_group_desc *gdp)
 294 +{
 295 +       struct ext3_sb_info *sbi = EXT3_SB(sb);
 296 +
 297 +       J_ASSERT_BH(bh, buffer_locked(bh));
 298 +
 299 +       /* If checksum is bad mark all blocks and inodes used to prevent
 300 +        * allocation, essentially implementing a per-group read-only flag. */
 301 +       if (!ext3_group_desc_csum_verify(sbi, block_group, gdp)) {
 302 +               ext3_error(sb, __FUNCTION__, "Checksum bad for group %u\n",
 303 +                          block_group);
 304 +               gdp->bg_free_blocks_count = 0;
 305 +               gdp->bg_free_inodes_count = 0;
 306 +               gdp->bg_itable_unused = 0;
 307 +               memset(bh->b_data, 0xff, sb->s_blocksize);
 308 +               return 0;
 309 +       }
 310 +
 311 +       memset(bh->b_data, 0, (EXT3_INODES_PER_GROUP(sb) + 7) / 8);
 312 +       mark_bitmap_end(EXT3_INODES_PER_GROUP(sb), EXT3_BLOCKS_PER_GROUP(sb),
 313 +                       bh->b_data);
 314 +
 315 +       return EXT3_INODES_PER_GROUP(sb);
 316 +}
 317
 318  /*
 319   * Read the inode allocation bitmap for a given block_group, reading
 320 @@ -59,8 +106,19 @@ read_inode_bitmap(struct super_block * s
 321         desc = ext3_get_group_desc(sb, block_group, NULL);
 322         if (!desc)
 323                 goto error_out;
 324 -
 325 -       bh = sb_bread(sb, le32_to_cpu(desc->bg_inode_bitmap));
 326 +       if (desc->bg_flags & cpu_to_le16(EXT3_BG_INODE_UNINIT)) {
 327 +               bh = sb_getblk(sb, le32_to_cpu(desc->bg_inode_bitmap));
 328 +               if (!buffer_uptodate(bh)) {
 329 +                       lock_buffer(bh);
 330 +                       if (!buffer_uptodate(bh)) {
 331 +                               ext3_init_inode_bitmap(sb, bh,block_group,desc);
 332 +                               set_buffer_uptodate(bh);
 333 +                       }
 334 +                       unlock_buffer(bh);
 335 +               }
 336 +       } else {
 337 +               bh = sb_bread(sb, le32_to_cpu(desc->bg_inode_bitmap));
 338 +       }
 339         if (!bh)
 340                 ext3_error(sb, "read_inode_bitmap",
 341                             "Cannot read inode bitmap - "
 342 @@ -169,6 +227,8 @@ void ext3_free_inode (handle_t *handle,
 343                         if (is_directory)
 344                                 gdp->bg_used_dirs_count = cpu_to_le16(
 345                                   le16_to_cpu(gdp->bg_used_dirs_count) - 1);
 346 +                       gdp->bg_checksum = ext3_group_desc_csum(sbi,block_group,
 347 +                                                               gdp);
 348                         spin_unlock(sb_bgl_lock(sbi, block_group));
 349                         percpu_counter_inc(&sbi->s_freeinodes_counter);
 350                         if (is_directory)
 351 @@ -454,7 +514,7 @@ struct inode *ext3_new_inode(handle_t *h
 352         struct ext3_sb_info *sbi;
 353         int err = 0;
 354         struct inode *ret;
 355 -       int i;
 356 +       int i, free = 0;
 357
 358         /* Cannot create files in a deleted directory */
 359         if (!dir || !dir->i_nlink)
 360 @@ -571,11 +631,13 @@ repeat_in_this_group:
 361         goto out;
 362
 363  got:
 364 -       ino += group * EXT3_INODES_PER_GROUP(sb) + 1;
 365 -       if (ino < EXT3_FIRST_INO(sb) || ino > le32_to_cpu(es->s_inodes_count)) {
 366 -               ext3_error (sb, "ext3_new_inode",
 367 -                           "reserved inode or inode > inodes count - "
 368 -                           "block_group = %d, inode=%lu", group, ino);
 369 +       ino++;
 370 +       if ((group == 0 && ino < EXT3_FIRST_INO(sb)) ||
 371 +           ino > EXT3_INODES_PER_GROUP(sb)) {
 372 +               ext3_error(sb, __FUNCTION__,
 373 +                          "reserved inode or inode > inodes count - "
 374 +                          "block_group = %d, inode=%lu", group,
 375 +                          ino + group * EXT3_INODES_PER_GROUP(sb));
 376                 err = -EIO;
 377                 goto fail;
 378         }
 379 @@ -583,13 +645,64 @@ got:
 380         BUFFER_TRACE(bh2, "get_write_access");
 381         err = ext3_journal_get_write_access(handle, bh2);
 382         if (err) goto fail;
 383 +
 384 +       /* We may have to initialize the block bitmap if it isn't already */
 385 +       if (EXT3_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_GDT_CSUM) &&
 386 +           gdp->bg_flags & cpu_to_le16(EXT3_BG_BLOCK_UNINIT)) {
 387 +               struct buffer_head *block_bh = read_block_bitmap(sb, group);
 388 +
 389 +               BUFFER_TRACE(block_bh, "get block bitmap access");
 390 +               err = ext3_journal_get_write_access(handle, block_bh);
 391 +               if (err) {
 392 +                       brelse(block_bh);
 393 +                       goto fail;
 394 +               }
 395 +
 396 +               free = 0;
 397 +               spin_lock(sb_bgl_lock(sbi, group));
 398 +               /* recheck and clear flag under lock if we still need to */
 399 +               if (gdp->bg_flags & cpu_to_le16(EXT3_BG_BLOCK_UNINIT)) {
 400 +                       gdp->bg_flags &= cpu_to_le16(~EXT3_BG_BLOCK_UNINIT);
 401 +                       free = ext3_free_blocks_after_init(sb, group, gdp);
 402 +                       gdp->bg_free_blocks_count = cpu_to_le16(free);
 403 +               }
 404 +               spin_unlock(sb_bgl_lock(sbi, group));
 405 +
 406 +               /* Don't need to dirty bitmap block if we didn't change it */
 407 +               if (free) {
 408 +                       BUFFER_TRACE(block_bh, "dirty block bitmap");
 409 +                       err = ext3_journal_dirty_metadata(handle, block_bh);
 410 +               }
 411 +
 412 +               brelse(block_bh);
 413 +               if (err)
 414 +                       goto fail;
 415 +       }
 416 +
 417         spin_lock(sb_bgl_lock(sbi, group));
 418 +       /* If we didn't allocate from within the initialized part of the inode
 419 +        * table then we need to initialize up to this inode. */
 420 +       if (EXT3_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) {
 421 +               if (gdp->bg_flags & cpu_to_le16(EXT3_BG_INODE_UNINIT)) {
 422 +                       gdp->bg_flags &= cpu_to_le16(~EXT3_BG_INODE_UNINIT);
 423 +                       free = 0;
 424 +               } else {
 425 +                       free = EXT3_INODES_PER_GROUP(sb) -
 426 +                               le16_to_cpu(gdp->bg_itable_unused);
 427 +               }
 428 +
 429 +               if (ino > free)
 430 +                       gdp->bg_itable_unused =
 431 +                               cpu_to_le16(EXT3_INODES_PER_GROUP(sb) - ino);
 432 +       }
 433 +
 434         gdp->bg_free_inodes_count =
 435                 cpu_to_le16(le16_to_cpu(gdp->bg_free_inodes_count) - 1);
 436         if (S_ISDIR(mode)) {
 437                 gdp->bg_used_dirs_count =
 438                         cpu_to_le16(le16_to_cpu(gdp->bg_used_dirs_count) + 1);
 439         }
 440 +       gdp->bg_checksum = ext3_group_desc_csum(sbi, group, gdp);
 441         spin_unlock(sb_bgl_lock(sbi, group));
 442         BUFFER_TRACE(bh2, "call ext3_journal_dirty_metadata");
 443         err = ext3_journal_dirty_metadata(handle, bh2);
 444 @@ -611,7 +724,7 @@ got:
 445                 inode->i_gid = current->fsgid;
 446         inode->i_mode = mode;
 447
 448 -       inode->i_ino = ino;
 449 +       inode->i_ino = ino + group * EXT3_INODES_PER_GROUP(sb);
 450         /* This is the optimal IO size (for stat), not the fs block size */
 451         inode->i_blocks = 0;
 452         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
 453 Index: linux-2.6.18-53.1.14/fs/ext3/mballoc.c
 454 ===================================================================
 455 --- linux-2.6.18-53.1.14.orig/fs/ext3/mballoc.c
 456 +++ linux-2.6.18-53.1.14/fs/ext3/mballoc.c
 457 @@ -36,6 +36,8 @@
 458  #include <linux/seq_file.h>
 459  #include <linux/version.h>
 460
 461 +#include "group.h"
 462 +
 463  /*
 464   * MUSTDO:
 465   *   - test ext3_ext_search_left() and ext3_ext_search_right()
 466 @@ -323,6 +325,7 @@ struct ext3_group_info {
 467         unsigned long   bb_state;
 468         unsigned long   bb_tid;
 469         struct ext3_free_metadata *bb_md_cur;
 470 +       struct ext3_group_desc *bb_gdp;
 471         unsigned short  bb_first_free;
 472         unsigned short  bb_free;
 473         unsigned short  bb_fragments;
 474 @@ -941,10 +944,7 @@ static int ext3_mb_init_cache(struct pag
 475                 if (first_group + i >= EXT3_SB(sb)->s_groups_count)
 476                         break;
 477
 478 -               err = -EIO;
 479 -               desc = ext3_get_group_desc(sb, first_group + i, NULL);
 480 -               if (desc == NULL)
 481 -                       goto out;
 482 +               desc = EXT3_GROUP_INFO(sb, first_group + i)->bb_gdp;
 483
 484                 err = -ENOMEM;
 485                 bh[i] = sb_getblk(sb, le32_to_cpu(desc->bg_block_bitmap));
 486 @@ -959,7 +959,12 @@ static int ext3_mb_init_cache(struct pag
 487                         unlock_buffer(bh[i]);
 488                         continue;
 489                 }
 490 -
 491 +               if (desc->bg_flags & cpu_to_le16(EXT3_BG_BLOCK_UNINIT)) {
 492 +                       ext3_init_block_bitmap(sb, bh[i], first_group + i,desc);
 493 +                       set_buffer_uptodate(bh[i]);
 494 +                       unlock_buffer(bh[i]);
 495 +                       continue;
 496 +               }
 497                 get_bh(bh[i]);
 498                 bh[i]->b_end_io = end_buffer_read_sync;
 499                 submit_bh(READ, bh[i]);
 500 @@ -1731,6 +1736,10 @@ static int ext3_mb_good_group(struct ext
 501         switch (cr) {
 502                 case 0:
 503                         BUG_ON(ac->ac_2order == 0);
 504 +                       /* If this group is uninitialized, skip it initially */
 505 +                       if (grp->bb_gdp->bg_flags &
 506 +                           cpu_to_le16(EXT3_BG_BLOCK_UNINIT))
 507 +                               return 0;
 508                         bits = ac->ac_sb->s_blocksize_bits + 1;
 509                         for (i = ac->ac_2order; i <= bits; i++)
 510                                 if (grp->bb_counters[i] > 0)
 511 @@ -1824,7 +1833,9 @@ repeat:
 512                         }
 513
 514                         ac->ac_groups_scanned++;
 515 -                       if (cr == 0)
 516 +                       if (cr == 0 || (e3b.bd_info->bb_gdp->bg_flags &
 517 +                                       cpu_to_le16(EXT3_BG_BLOCK_UNINIT) &&
 518 +                                       ac->ac_2order != 0))
 519                                 ext3_mb_simple_scan_group(ac, &e3b);
 520                         else if (cr == 1 && ac->ac_g_ex.fe_len == sbi->s_stripe)
 521                                 ext3_mb_scan_aligned(ac, &e3b);
 522 @@ -2304,12 +2315,13 @@ int ext3_mb_init_backend(struct super_bl
 523                         i--;
 524                         goto err_freebuddy;
 525                 }
 526 +               memset(meta_group_info[j], 0, len);
 527                 desc = ext3_get_group_desc(sb, i, NULL);
 528 +               meta_group_info[j]->bb_gdp = desc;
 529                 if (desc == NULL) {
 530                         printk(KERN_ERR"EXT3-fs: can't read descriptor %u\n",i);
 531                         goto err_freebuddy;
 532                 }
 533 -               memset(meta_group_info[j], 0, len);
 534                 set_bit(EXT3_GROUP_INFO_NEED_INIT_BIT,
 535                         &meta_group_info[j]->bb_state);
 536
 537 @@ -2943,9 +2955,17 @@ int ext3_mb_mark_diskspace_used(struct e
 538                     ac->ac_b_ex.fe_start, ac->ac_b_ex.fe_len);
 539
 540         spin_lock(sb_bgl_lock(sbi, ac->ac_b_ex.fe_group));
 541 +       if (gdp->bg_flags & cpu_to_le16(EXT3_BG_BLOCK_UNINIT)) {
 542 +               gdp->bg_flags &= cpu_to_le16(~EXT3_BG_BLOCK_UNINIT);
 543 +               gdp->bg_free_blocks_count =
 544 +                       cpu_to_le16(ext3_free_blocks_after_init(sb,
 545 +                                                           ac->ac_b_ex.fe_group,
 546 +                                                           gdp));
 547 +       }
 548         gdp->bg_free_blocks_count =
 549                 cpu_to_le16(le16_to_cpu(gdp->bg_free_blocks_count)
 550                                 - ac->ac_b_ex.fe_len);
 551 +       gdp->bg_checksum = ext3_group_desc_csum(sbi, ac->ac_b_ex.fe_group, gdp);
 552         spin_unlock(sb_bgl_lock(sbi, ac->ac_b_ex.fe_group));
 553         percpu_counter_mod(&sbi->s_freeblocks_counter, - ac->ac_b_ex.fe_len);
 554
 555 @@ -4355,6 +4375,7 @@ do_more:
 556         spin_lock(sb_bgl_lock(sbi, block_group));
 557         gdp->bg_free_blocks_count =
 558                 cpu_to_le16(le16_to_cpu(gdp->bg_free_blocks_count) + count);
 559 +       gdp->bg_checksum = ext3_group_desc_csum(sbi, block_group, gdp);
 560         spin_unlock(sb_bgl_lock(sbi, block_group));
 561         percpu_counter_mod(&sbi->s_freeblocks_counter, count);
 562
 563 Index: linux-2.6.18-53.1.14/fs/ext3/balloc.c
 564 ===================================================================
 565 --- linux-2.6.18-53.1.14.orig/fs/ext3/balloc.c
 566 +++ linux-2.6.18-53.1.14/fs/ext3/balloc.c
 567 @@ -20,6 +20,7 @@
 568  #include <linux/quotaops.h>
 569  #include <linux/buffer_head.h>
 570
 571 +#include "group.h"
 572  /*
 573   * balloc.c contains the blocks allocation and deallocation routines
 574   */
 575 @@ -73,6 +74,83 @@ struct ext3_group_desc * ext3_get_group_
 576         return desc + offset;
 577  }
 578
 579 +/* Initializes an uninitialized block bitmap if given, and returns the
 580 + * number of blocks free in the group. */
 581 +unsigned ext3_init_block_bitmap(struct super_block *sb, struct buffer_head *bh,
 582 +                               int block_group, struct ext3_group_desc *gdp)
 583 +{
 584 +       unsigned long start;
 585 +       int bit, bit_max;
 586 +       unsigned free_blocks;
 587 +       struct ext3_sb_info *sbi = EXT3_SB(sb);
 588 +
 589 +       if (bh) {
 590 +               J_ASSERT_BH(bh, buffer_locked(bh));
 591 +
 592 +               /* If checksum is bad mark all blocks use to prevent allocation,
 593 +                * essentially implementing a per-group read-only flag. */
 594 +               if (!ext3_group_desc_csum_verify(sbi, block_group, gdp)) {
 595 +                       ext3_error(sb, __FUNCTION__,
 596 +                                  "Checksum bad for group %u\n", block_group);
 597 +                       gdp->bg_free_blocks_count = 0;
 598 +                       gdp->bg_free_inodes_count = 0;
 599 +                       gdp->bg_itable_unused = 0;
 600 +                       memset(bh->b_data, 0xff, sb->s_blocksize);
 601 +                       return 0;
 602 +               }
 603 +               memset(bh->b_data, 0, sb->s_blocksize);
 604 +       }
 605 +
 606 +       /* Check for superblock and gdt backups in this group */
 607 +       bit_max = ext3_bg_has_super(sb, block_group);
 608 +
 609 +       if (!EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_META_BG) ||
 610 +           block_group < le32_to_cpu(sbi->s_es->s_first_meta_bg) *
 611 +                         sbi->s_desc_per_block) {
 612 +               if (bit_max) {
 613 +                       bit_max += ext3_bg_num_gdb(sb, block_group);
 614 +                       bit_max +=le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks);
 615 +               }
 616 +       } else { /* For META_BG_BLOCK_GROUPS */
 617 +               int group_rel = (block_group -
 618 +                                le32_to_cpu(sbi->s_es->s_first_meta_bg)) %
 619 +                               EXT3_DESC_PER_BLOCK(sb);
 620 +               if (group_rel == 0 || group_rel == 1 ||
 621 +                   (group_rel == EXT3_DESC_PER_BLOCK(sb) - 1))
 622 +                       bit_max += 1;
 623 +       }
 624 +
 625 +       /* Last and first groups are always initialized */
 626 +       free_blocks = EXT3_BLOCKS_PER_GROUP(sb) - bit_max;
 627 +
 628 +       if (bh) {
 629 +               for (bit = 0; bit < bit_max; bit++)
 630 +                       ext3_set_bit(bit, bh->b_data);
 631 +
 632 +               start = block_group * EXT3_BLOCKS_PER_GROUP(sb) +
 633 +                       le32_to_cpu(sbi->s_es->s_first_data_block);
 634 +
 635 +               /* Set bits for block and inode bitmaps, and inode table */
 636 +               ext3_set_bit(le32_to_cpu(gdp->bg_block_bitmap) - start,
 637 +                            bh->b_data);
 638 +               ext3_set_bit(le32_to_cpu(gdp->bg_inode_bitmap) - start,
 639 +                            bh->b_data);
 640 +               for (bit = le32_to_cpu(gdp->bg_inode_table) - start,
 641 +                    bit_max = bit + sbi->s_itb_per_group; bit < bit_max; bit++)
 642 +                       ext3_set_bit(bit, bh->b_data);
 643 +
 644 +               /*
 645 +                * Also if the number of blocks within the group is
 646 +                * less than the blocksize * 8 ( which is the size
 647 +                * of bitmap ), set rest of the block bitmap to 1
 648 +                */
 649 +               mark_bitmap_end(EXT3_BLOCKS_PER_GROUP(sb), sb->s_blocksize * 8,
 650 +                               bh->b_data);
 651 +       }
 652 +
 653 +       return free_blocks - sbi->s_itb_per_group - 2;
 654 +}
 655 +
 656  /*
 657   * Read the bitmap for a given block_group, reading into the specified
 658   * slot in the superblock's bitmap cache.
 659 @@ -88,7 +166,19 @@ read_block_bitmap(struct super_block *sb
 660         desc = ext3_get_group_desc (sb, block_group, NULL);
 661         if (!desc)
 662                 goto error_out;
 663 -       bh = sb_bread(sb, le32_to_cpu(desc->bg_block_bitmap));
 664 +       if (desc->bg_flags & cpu_to_le16(EXT3_BG_BLOCK_UNINIT)) {
 665 +               bh = sb_getblk(sb, le32_to_cpu(desc->bg_block_bitmap));
 666 +               if (!buffer_uptodate(bh)) {
 667 +                       lock_buffer(bh);
 668 +                       if (!buffer_uptodate(bh)) {
 669 +                               ext3_init_block_bitmap(sb, bh,block_group,desc);
 670 +                               set_buffer_uptodate(bh);
 671 +                       }
 672 +                       unlock_buffer(bh);
 673 +               }
 674 +       } else {
 675 +               bh = sb_bread(sb, le32_to_cpu(desc->bg_block_bitmap));
 676 +       }
 677         if (!bh)
 678                 ext3_error (sb, "read_block_bitmap",
 679                             "Cannot read block bitmap - "
 680 @@ -467,6 +557,7 @@ do_more:
 681         desc->bg_free_blocks_count =
 682                 cpu_to_le16(le16_to_cpu(desc->bg_free_blocks_count) +
 683                         group_freed);
 684 +       desc->bg_checksum = ext3_group_desc_csum(sbi, block_group, desc);
 685         spin_unlock(sb_bgl_lock(sbi, block_group));
 686         percpu_counter_mod(&sbi->s_freeblocks_counter, count);
 687
 688 @@ -1434,8 +1525,11 @@ allocated:
 689                         ret_block, goal_hits, goal_attempts);
 690
 691         spin_lock(sb_bgl_lock(sbi, group_no));
 692 +       if (gdp->bg_flags & cpu_to_le16(EXT3_BG_BLOCK_UNINIT))
 693 +               gdp->bg_flags &= cpu_to_le16(~EXT3_BG_BLOCK_UNINIT);
 694         gdp->bg_free_blocks_count =
 695                         cpu_to_le16(le16_to_cpu(gdp->bg_free_blocks_count) - num);
 696 +       gdp->bg_checksum = ext3_group_desc_csum(sbi, group_no, gdp);
 697         spin_unlock(sb_bgl_lock(sbi, group_no));
 698         percpu_counter_mod(&sbi->s_freeblocks_counter, -num);
 699