Whamcloud - gitweb
LU-723 ldiskfs: remove ext3 RHEL5 kernel series
authorAndreas Dilger <adilger@whamcloud.com>
Wed, 26 Oct 2011 07:34:34 +0000 (01:34 -0600)
committerOleg Drokin <green@whamcloud.com>
Thu, 27 Oct 2011 20:02:22 +0000 (16:02 -0400)
Remove the old ext3 RHEL5 kernel patch series.  This has been
deprecated since Lustre 1.8.6 in favour of the ext4 RHEL5 series.

Signed-off-by: Andreas Dilger <adilger@whamcloud.com>
Change-Id: I1e09ff432f2e970446c3b43fb92f0c1a988159ae
Reviewed-on: http://review.whamcloud.com/1603
Tested-by: Hudson
Reviewed-by: Johann Lombardi <johann@whamcloud.com>
Tested-by: Maloo <whamcloud.maloo@gmail.com>
Reviewed-by: Oleg Drokin <green@whamcloud.com>
44 files changed:
build/autoconf/lustre-build-linux.m4
ldiskfs/configure.ac
ldiskfs/kernel_patches/patches/alloc-policy-2.6-rhlel5.diff [deleted file]
ldiskfs/kernel_patches/patches/export-ext3-2.6-rhel4.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-big-endian-check-2.6-rhel5.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-block-bitmap-validation-2.6-rhel5.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-corrupted-orphans-2.6.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-disable-mb-cache.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-dynlocks-2.6-rhel5.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-dynlocks-common.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-ea-expand-lose-block.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-export-64bit-name-hash.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-extents-2.6.18-vanilla.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-fiemap-2.6-rhel5.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-force_over_8tb-rhel5.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-get-raid-stripe-from-sb.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-hash-indexed-dir-dotdot-update.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-include-fixes-2.6-rhel4.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-inode-version-2.6.18-vanilla.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-journal-chksum-2.6.18-vanilla.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-kill-dx_root.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-lookup-dotdot-2.6.9.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-map_inode_page-2.6.18.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-max-dir-size.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-mballoc-pa_free-mismatch.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-mballoc3-2.6.18.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-mballoc3-core.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-mmp-2.6.18-vanilla.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-nanosecond-2.6.18-vanilla.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-nlinks-2.6-rhel5.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-osd-iam-exports.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-osd-iop-common.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-pdir-fix.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-print-inum-in-htree-warning.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-remove-cond_resched-calls-2.6.12.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-statfs-2.6-rhel5.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-uninit-2.6.18.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-version-2.6-rhel5.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-wantedi-2.6-rhel4.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3-xattr-no-update-ctime-2.6.22-vanilla.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3_data_in_dirent.patch [deleted file]
ldiskfs/kernel_patches/patches/ext3_fix_i_flags.patch [deleted file]
ldiskfs/kernel_patches/patches/ext4-convert-group-lock-rhel5.patch [deleted file]
ldiskfs/kernel_patches/series/ldiskfs-2.6-rhel5.series [deleted file]

index deb80fd..0f83400 100644 (file)
@@ -116,7 +116,6 @@ LB_LINUX_TRY_COMPILE([
                #error "not redhat kernel"
                #endif
        ],[
-               RHEL_KENEL="yes"
                RHEL_KERNEL="yes"
                AC_MSG_RESULT([yes])
        ],[
index 2b3d1c5..f92e0f0 100644 (file)
@@ -116,27 +116,16 @@ if test x$enable_dist != xyes; then
        # don't need to do this if only configuring for make dist
 AC_MSG_CHECKING([which ldiskfs series to use])
 case $LINUXRELEASE in
-2.6.5*) LDISKFS_SERIES="2.6-suse.series" ;;
-2.6.9*) LDISKFS_SERIES="2.6-rhel4.series" ;;
-2.6.10-ac*) LDISKFS_SERIES="2.6-fc3.series" ;;
-2.6.10*) LDISKFS_SERIES="2.6-rhel4.series" ;;
-2.6.12*) LDISKFS_SERIES="2.6.12-vanilla.series" ;;
-2.6.15*) LDISKFS_SERIES="2.6-fc5.series";;
-2.6.16*) LDISKFS_SERIES="2.6-sles10.series";;
 2.6.18*)
-       if test x$RHEL_KENEL = xyes; then
-                if test x$enable_ext4 = xyes; then
-                       LDISKFS_SERIES="2.6-rhel5-ext4.series"
-                else
-                       LDISKFS_SERIES="2.6-rhel5.series"
-                fi
-       else
-               LDISKFS_SERIES="2.6.18-vanilla.series"
+       if test x$RHEL_KERNEL = xyes; then
+               LDISKFS_SERIES="2.6-rhel5-ext4.series"
+       fi
+       ;;
+2.6.32*)
+       if test x$RHEL_KERNEL = xyes; then
+                LDISKFS_SERIES="2.6-rhel6.series"
        fi
        ;;
-2.6.22*) LDISKFS_SERIES="2.6.22-vanilla.series";;
-2.6.27*) LDISKFS_SERIES="2.6-sles11.series";;
-2.6.32*) LDISKFS_SERIES="2.6-rhel6.series";;
 *) AC_MSG_WARN([Unknown kernel version $LINUXRELEASE, fix ldiskfs/configure.ac])
 esac
 AC_MSG_RESULT([$LDISKFS_SERIES])
diff --git a/ldiskfs/kernel_patches/patches/alloc-policy-2.6-rhlel5.diff b/ldiskfs/kernel_patches/patches/alloc-policy-2.6-rhlel5.diff
deleted file mode 100644 (file)
index 800574b..0000000
+++ /dev/null
@@ -1,99 +0,0 @@
-diff -Nrpu /tmp/linux-stage/fs/ext3/ialloc.c linux-stage/fs/ext3/ialloc.c
---- /tmp/linux-stage/fs/ext3/ialloc.c  2009-05-09 06:44:02.000000000 +0400
-+++ linux-stage/fs/ext3/ialloc.c       2009-05-09 06:45:33.000000000 +0400
-@@ -822,6 +822,36 @@ fail_drop:
-       return ERR_PTR(err);
- }
-+unsigned long ext3_find_reverse(struct super_block *sb)
-+{
-+      struct ext3_group_desc *desc;
-+      struct buffer_head *bitmap_bh = NULL;
-+      int group;
-+      unsigned long ino, offset;
-+
-+      for (offset = (EXT3_INODES_PER_GROUP(sb) >> 1); offset >= 0;
-+           offset >>= 1) {
-+              for (group = EXT3_SB(sb)->s_groups_count - 1; group >= 0;
-+                   --group) {
-+                      desc = ext3_get_group_desc(sb, group, NULL);
-+                      if (desc->bg_free_inodes_count == 0)
-+                              continue;
-+
-+                      bitmap_bh = read_inode_bitmap(sb, group);
-+                      if (!bitmap_bh)
-+                              continue;
-+
-+                      ino = ext3_find_next_zero_bit((unsigned long *)
-+                                      bitmap_bh->b_data,
-+                                      EXT3_INODES_PER_GROUP(sb), offset);
-+                      if (ino < EXT3_INODES_PER_GROUP(sb))
-+                              return(group * EXT3_INODES_PER_GROUP(sb) +
-+                                     ino + 1);
-+              }
-+      }
-+      return 0;
-+}
-+
- /* Verify that we are loading a valid orphan from disk */
- struct inode *ext3_orphan_get(struct super_block *sb, unsigned long ino)
- {
-diff -Nrpu /tmp/linux-stage/fs/ext3/namei.c linux-stage/fs/ext3/namei.c
---- /tmp/linux-stage/fs/ext3/namei.c   2009-05-09 06:44:02.000000000 +0400
-+++ linux-stage/fs/ext3/namei.c        2009-05-09 06:45:33.000000000 +0400
-@@ -145,14 +145,25 @@ struct dx_map_entry
-       u32 offs;
- };
-+/*
-+ * dentry_param used by ext3_new_inode_wantedi()
-+ */
- #define LVFS_DENTRY_PARAM_MAGIC               20070216UL
- struct lvfs_dentry_params
- {
--      unsigned long   p_inum;
--      void            *p_ptr; 
--      u32             magic;
-+      unsigned long   ldp_inum;
-+      long            ldp_flags;
-+      u32             ldp_magic;
- };
-+/* Only use the least 3 bits of ldp_flags for goal policy */
-+typedef enum {
-+      DP_GOAL_POLICY       = 0,
-+      DP_LASTGROUP_REVERSE = 1,
-+} dp_policy_t;
-+
-+#define LDP_FLAGS_RANGE 0x07
-+
- #ifdef CONFIG_EXT3_INDEX
- static inline unsigned dx_get_block (struct dx_entry *entry);
- static void dx_set_block (struct dx_entry *entry, unsigned value);
-@@ -1718,8 +1727,13 @@ static struct inode * ext3_new_inode_wan
-       if (dentry->d_fsdata != NULL) {
-               struct lvfs_dentry_params *param = dentry->d_fsdata;
--              if (param->magic == LVFS_DENTRY_PARAM_MAGIC)
--                      inum = param->p_inum;
-+              if (param->ldp_magic == LVFS_DENTRY_PARAM_MAGIC) {
-+                      if ((dp_policy_t)(param->ldp_flags & LDP_FLAGS_RANGE) ==
-+                          DP_LASTGROUP_REVERSE)
-+                              inum = ext3_find_reverse(dir->i_sb);
-+                        else /* DP_GOAL_POLICY */
-+                              inum = param->ldp_inum;
-+                }
-       }
-       return ext3_new_inode(handle, dir, mode, inum);
- }
-diff -Nrpu /tmp/linux-stage/include/linux/ext3_fs.h linux-stage/include/linux/ext3_fs.h
---- /tmp/linux-stage/include/linux/ext3_fs.h   2009-05-09 06:44:02.000000000 +0400
-+++ linux-stage/include/linux/ext3_fs.h        2009-05-09 06:45:33.000000000 +0400
-@@ -973,6 +973,7 @@ extern int ext3fs_dirhash(const char *na
- /* ialloc.c */
- extern struct inode * ext3_new_inode (handle_t *, struct inode *, int,
-                                     unsigned long);
-+extern unsigned long ext3_find_reverse(struct super_block *);
- extern void ext3_free_inode (handle_t *, struct inode *);
- extern struct inode * ext3_orphan_get (struct super_block *, unsigned long);
- extern unsigned long ext3_count_free_inodes (struct super_block *);
diff --git a/ldiskfs/kernel_patches/patches/export-ext3-2.6-rhel4.patch b/ldiskfs/kernel_patches/patches/export-ext3-2.6-rhel4.patch
deleted file mode 100644 (file)
index 9f443b4..0000000
+++ /dev/null
@@ -1,35 +0,0 @@
-Index: linux-2.6.9-42.0.10.EL_lustre.1.4.10/fs/ext3/super.c
-===================================================================
---- linux-2.6.9-42.0.10.EL_lustre.1.4.10.orig/fs/ext3/super.c  2007-05-16 08:46:24.000000000 +0200
-+++ linux-2.6.9-42.0.10.EL_lustre.1.4.10/fs/ext3/super.c       2007-05-16 08:48:58.000000000 +0200
-@@ -123,6 +123,8 @@ void ext3_journal_abort_handle(const cha
-       journal_abort_handle(handle);
- }
-+EXPORT_SYMBOL(ext3_journal_abort_handle);
-+
- /* Deal with the reporting of failure conditions on a filesystem such as
-  * inconsistencies detected or read IO failures.
-  *
-@@ -2064,6 +2066,8 @@ int ext3_force_commit(struct super_block
-       return ret;
- }
-+EXPORT_SYMBOL(ext3_force_commit);
-+
- /*
-  * Ext3 always journals updates to the superblock itself, so we don't
-  * have to propagate any other updates to the superblock on disk at this
-@@ -2586,6 +2590,12 @@ int ext3_map_inode_page(struct inode *in
-                         unsigned long *blocks, int *created, int create);
- EXPORT_SYMBOL(ext3_map_inode_page);
-+EXPORT_SYMBOL(ext3_xattr_get);
-+EXPORT_SYMBOL(ext3_xattr_set_handle);
-+EXPORT_SYMBOL(ext3_bread);
-+EXPORT_SYMBOL(ext3_journal_start_sb);
-+EXPORT_SYMBOL(__ext3_journal_stop);
-+
- MODULE_AUTHOR("Remy Card, Stephen Tweedie, Andrew Morton, Andreas Dilger, Theodore Ts'o and others");
- MODULE_DESCRIPTION("Second Extended Filesystem with journaling extensions");
- MODULE_LICENSE("GPL");
diff --git a/ldiskfs/kernel_patches/patches/ext3-big-endian-check-2.6-rhel5.patch b/ldiskfs/kernel_patches/patches/ext3-big-endian-check-2.6-rhel5.patch
deleted file mode 100644 (file)
index 913b02c..0000000
+++ /dev/null
@@ -1,56 +0,0 @@
-Index: linux-2.6.18-92.1.6/fs/ext3/super.c
-===================================================================
---- linux-2.6.18-92.1.6.orig/fs/ext3/super.c
-+++ linux-2.6.18-92.1.6/fs/ext3/super.c
-@@ -71,6 +71,8 @@ static void ext3_unlockfs(struct super_b
- static void ext3_write_super (struct super_block * sb);
- static void ext3_write_super_lockfs(struct super_block *sb);
-+static int bigendian_extents;
-+
- /* 
-  * Wrappers for journal_start/end.
-  *
-@@ -706,7 +708,7 @@ enum {
-       Opt_ignore, Opt_barrier, Opt_err, Opt_resize, Opt_usrquota,
-       Opt_iopen, Opt_noiopen, Opt_iopen_nopriv,
-       Opt_grpquota,
--      Opt_extents, Opt_noextents, Opt_extdebug,
-+      Opt_extents, Opt_noextents, Opt_bigendian_extents, Opt_extdebug,
-       Opt_mballoc, Opt_nomballoc, Opt_stripe, Opt_maxdirsize
- };
-@@ -766,6 +768,7 @@ static match_table_t tokens = {
-       {Opt_barrier, "barrier=%u"},
-       {Opt_extents, "extents"},
-       {Opt_noextents, "noextents"},
-+      {Opt_bigendian_extents, "bigendian_extents"},
-       {Opt_extdebug, "extdebug"},
-       {Opt_mballoc, "mballoc"},
-       {Opt_nomballoc, "nomballoc"},
-@@ -1129,6 +1132,9 @@ clear_qf_name:
-               case Opt_noextents:
-                       clear_opt (sbi->s_mount_opt, EXTENTS);
-                       break;
-+              case Opt_bigendian_extents:
-+                      bigendian_extents = 1;
-+                      break;
-               case Opt_extdebug:
-                       set_opt (sbi->s_mount_opt, EXTDEBUG);
-                       break;
-@@ -2224,6 +2230,15 @@ static int ext3_fill_super (struct super
-               goto failed_mount;
-       }
-+#ifdef __BIG_ENDIAN
-+      if (bigendian_extents == 0) {
-+              printk(KERN_ERR "EXT3-fs: extents feature is not guaranteed to "
-+                     "work on big-endian systems. Use \"bigendian_extents\" "
-+                     "mount option to override.\n");
-+              goto failed_mount;
-+      }
-+#endif
-+
-       bgl_lock_init(&sbi->s_blockgroup_lock);
-       sbi->s_last_alloc_group = -1;
diff --git a/ldiskfs/kernel_patches/patches/ext3-block-bitmap-validation-2.6-rhel5.patch b/ldiskfs/kernel_patches/patches/ext3-block-bitmap-validation-2.6-rhel5.patch
deleted file mode 100644 (file)
index 39cbcc8..0000000
+++ /dev/null
@@ -1,169 +0,0 @@
- fs/ext3/balloc.c |   99 ++++++++++++++++++++++++++++++++++++++++++++----------
- 1 files changed, 81 insertions(+), 18 deletions(-)
-diff --git a/fs/ext3/balloc.c b/fs/ext3/balloc.c
-index ff3428e..a9140ea 100644
-Index: linux-stage/fs/ext3/balloc.c
-===================================================================
---- linux-stage.orig/fs/ext3/balloc.c
-+++ linux-stage/fs/ext3/balloc.c
-@@ -143,9 +143,96 @@ unsigned ext3_init_block_bitmap(struct s
-       return free_blocks - sbi->s_itb_per_group - 2;
- }
--/*
-- * Read the bitmap for a given block_group, reading into the specified 
-- * slot in the superblock's bitmap cache.
-+/**
-+* bh_uptodate_or_lock: Test whether the buffer is uptodate
-+* @bh: struct buffer_head
-+*
-+* Return true if the buffer is up-to-date and false,
-+* with the buffer locked, if not.
-+*/
-+int bh_uptodate_or_lock(struct buffer_head *bh)
-+{
-+      if (!buffer_uptodate(bh)) {
-+              lock_buffer(bh);
-+              if (!buffer_uptodate(bh))
-+                      return 0;
-+              unlock_buffer(bh);
-+      }
-+      return 1;
-+}
-+
-+/**
-+* bh_submit_read: Submit a locked buffer for reading
-+* @bh: struct buffer_head
-+*
-+* Returns a negative error
-+*/
-+int bh_submit_read(struct buffer_head *bh)
-+{
-+      if (!buffer_locked(bh))
-+              lock_buffer(bh);
-+      if (buffer_uptodate(bh))
-+              return 0;
-+      get_bh(bh);
-+      bh->b_end_io = end_buffer_read_sync;
-+      submit_bh(READ, bh);
-+      wait_on_buffer(bh);
-+      if (buffer_uptodate(bh))
-+              return 0;
-+      return -EIO;
-+}
-+
-+static int ext3_valid_block_bitmap(struct super_block *sb,
-+                                 struct ext3_group_desc *desc,
-+                                 unsigned int block_group,
-+                                 struct buffer_head *bh)
-+{
-+      ext3_grpblk_t offset;
-+      ext3_grpblk_t next_zero_bit;
-+      ext3_fsblk_t bitmap_blk;
-+      ext3_fsblk_t group_first_block;
-+
-+      group_first_block = ext3_group_first_block_no(sb, block_group);
-+
-+      /* check whether block bitmap block number is set */
-+      bitmap_blk = le32_to_cpu(desc->bg_block_bitmap);
-+      offset = bitmap_blk - group_first_block;
-+      if (!ext3_test_bit(offset, bh->b_data))
-+              /* bad block bitmap */
-+              goto err_out;
-+
-+      /* check whether the inode bitmap block number is set */
-+      bitmap_blk = le32_to_cpu(desc->bg_inode_bitmap);
-+      offset = bitmap_blk - group_first_block;
-+      if (!ext3_test_bit(offset, bh->b_data))
-+              /* bad block bitmap */
-+              goto err_out;
-+
-+      /* check whether the inode table block number is set */
-+      bitmap_blk = le32_to_cpu(desc->bg_inode_table);
-+      offset = bitmap_blk - group_first_block;
-+      next_zero_bit = ext3_find_next_zero_bit(bh->b_data,
-+                              offset + EXT3_SB(sb)->s_itb_per_group,
-+                              offset);
-+      if (next_zero_bit >= offset + EXT3_SB(sb)->s_itb_per_group)
-+              /* good bitmap for inode tables */
-+              return 1;
-+
-+err_out:
-+      ext3_error(sb, __FUNCTION__,
-+                 "Invalid block bitmap - "
-+                 "block_group = %d, block = %lu",
-+                 (int)block_group, bitmap_blk);
-+      return 0;
-+}
-+
-+/**
-+ * read_block_bitmap()
-+ * @sb:                super block
-+ * @block_group: given block group
-+ *
-+ * Read the bitmap for a given block_group,and validate the
-+ * bits for block/inode/inode tables are set in the bitmaps.
-  *
-  * Return buffer_head on success or NULL in case of failure.
-  */
-@@ -154,29 +241,42 @@ read_block_bitmap(struct super_block *sb
- {
-       struct ext3_group_desc * desc;
-       struct buffer_head * bh = NULL;
-+      ext3_fsblk_t bitmap_blk;
-       desc = ext3_get_group_desc (sb, block_group, NULL);
-       if (!desc)
--              goto error_out;
-+              return NULL;
-+      bitmap_blk = desc->bg_block_bitmap;
-+      bh = sb_getblk(sb, bitmap_blk);
-+      if (unlikely(!bh)) {
-+              ext3_error(sb, __FUNCTION__,
-+                         "Can not read block bitmap - "
-+                         "block group = %d, block_bitmap = %lu",
-+                         (int)block_group, bitmap_blk);
-+              return NULL;
-+      }
-+      if (bh_uptodate_or_lock(bh))
-+              return bh;
-+
-       if (desc->bg_flags & cpu_to_le16(EXT3_BG_BLOCK_UNINIT)) {
--              bh = sb_getblk(sb, le32_to_cpu(desc->bg_block_bitmap));
--              if (!buffer_uptodate(bh)) {
--                      lock_buffer(bh);
--                      if (!buffer_uptodate(bh)) {
--                              ext3_init_block_bitmap(sb, bh,block_group,desc);
--                              set_buffer_uptodate(bh);
--                      }
--                      unlock_buffer(bh);
--              }
--      } else {
--              bh = sb_bread(sb, le32_to_cpu(desc->bg_block_bitmap));
-+              ext3_init_block_bitmap(sb, bh, block_group, desc);
-+              set_buffer_uptodate(bh);
-+              unlock_buffer(bh);
-+              return bh;
-+      }
-+      if (bh_submit_read(bh) < 0) {
-+              brelse(bh);
-+              ext3_error(sb, __FUNCTION__,
-+                         "Cannot read block bitmap - "
-+                         "block group = %d block_bitmap = %lu",
-+                         (int)block_group, bitmap_blk);
-+              return NULL;
-+      }
-+      if (!ext3_valid_block_bitmap(sb, desc, block_group, bh)) {
-+              brelse(bh);
-+              return NULL;
-       }
--      if (!bh)
--              ext3_error (sb, "read_block_bitmap",
--                          "Cannot read block bitmap - "
--                          "block_group = %d, block_bitmap = %u",
--                          block_group, le32_to_cpu(desc->bg_block_bitmap));
--error_out:
-+
-       return bh;
- }
- /*
diff --git a/ldiskfs/kernel_patches/patches/ext3-corrupted-orphans-2.6.patch b/ldiskfs/kernel_patches/patches/ext3-corrupted-orphans-2.6.patch
deleted file mode 100644 (file)
index cff6371..0000000
+++ /dev/null
@@ -1,145 +0,0 @@
---- linux-2.6.18-128.7.1.orig/include/linux/ext3_fs.h  2006-09-19 23:42:06.000000000 -0400
-+++ linux-2.6.18-128.7.1/include/linux/ext3_fs.h       2009-10-12 19:37:54.000000000 -0400
-@@ -809,6 +809,7 @@ extern void ext3_discard_reservation (st
- extern void ext3_dirty_inode(struct inode *);
- extern int ext3_change_inode_journal_flag(struct inode *, int);
- extern int ext3_get_inode_loc(struct inode *, struct ext3_iloc *);
-+extern int ext3_can_truncate(struct inode *inode);
- extern void ext3_truncate (struct inode *);
- extern void ext3_set_inode_flags(struct inode *);
- extern void ext3_set_aops(struct inode *inode);
---- linux-2.6.18-128.7.1.orig/fs/ext3/inode.c  2009-09-15 10:38:31.000000000 -0400
-+++ linux-2.6.18-128.7.1/fs/ext3/inode.c       2009-10-12 18:49:01.000000000 -0400
-@@ -2194,6 +2194,19 @@ static void ext3_free_branches(handle_t 
-       }
- }
-+int ext3_can_truncate(struct inode *inode)
-+{
-+      if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
-+              return 0;
-+      if (S_ISREG(inode->i_mode))
-+              return 1;
-+      if (S_ISDIR(inode->i_mode))
-+              return 1;
-+      if (S_ISLNK(inode->i_mode))
-+              return !ext3_inode_is_fast_symlink(inode);
-+      return 0;
-+}
-+
- /*
-  * ext3_truncate()
-  *
-@@ -2238,12 +2251,7 @@ void ext3_truncate(struct inode *inode)
-       unsigned blocksize = inode->i_sb->s_blocksize;
-       struct page *page;
--      if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
--          S_ISLNK(inode->i_mode)))
--              goto out_notrans;
--      if (ext3_inode_is_fast_symlink(inode))
--              goto out_notrans;
--      if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
-+      if (!ext3_can_truncate(inode))
-               goto out_notrans;
-       /*
---- linux-2.6.18-128.7.1.orig/fs/ext3/ialloc.c 2009-09-15 10:24:17.000000000 -0400
-+++ linux-2.6.18-128.7.1/fs/ext3/ialloc.c      2009-10-14 15:36:27.000000000 -0400
-@@ -645,54 +645,71 @@ struct inode *ext3_orphan_get(struct sup
-       unsigned long max_ino = le32_to_cpu(EXT3_SB(sb)->s_es->s_inodes_count);
-       unsigned long block_group;
-       int bit;
--      struct buffer_head *bitmap_bh = NULL;
-+      struct buffer_head *bitmap_bh;
-       struct inode *inode = NULL;
-       /* Error cases - e2fsck has already cleaned up for us */
-       if (ino > max_ino) {
--              ext3_warning(sb, __FUNCTION__,
-+              ext3_warning(sb, __func__,
-                            "bad orphan ino %lu!  e2fsck was run?", ino);
--              goto out;
-+              goto error;
-       }
-       block_group = (ino - 1) / EXT3_INODES_PER_GROUP(sb);
-       bit = (ino - 1) % EXT3_INODES_PER_GROUP(sb);
-       bitmap_bh = read_inode_bitmap(sb, block_group);
-       if (!bitmap_bh) {
--              ext3_warning(sb, __FUNCTION__,
-+              ext3_warning(sb, __func__,
-                            "inode bitmap error for orphan %lu", ino);
--              goto out;
-+              goto error;
-       }
-       /* Having the inode bit set should be a 100% indicator that this
-        * is a valid orphan (no e2fsck run on fs).  Orphans also include
-        * inodes that were being truncated, so we can't check i_nlink==0.
-        */
--      if (!ext3_test_bit(bit, bitmap_bh->b_data) ||
--                      !(inode = iget(sb, ino)) || is_bad_inode(inode) ||
--                      NEXT_ORPHAN(inode) > max_ino) {
--              ext3_warning(sb, __FUNCTION__,
--                           "bad orphan inode %lu!  e2fsck was run?", ino);
--              printk(KERN_NOTICE "ext3_test_bit(bit=%d, block=%llu) = %d\n",
--                     bit, (unsigned long long)bitmap_bh->b_blocknr,
--                     ext3_test_bit(bit, bitmap_bh->b_data));
--              printk(KERN_NOTICE "inode=%p\n", inode);
--              if (inode) {
--                      printk(KERN_NOTICE "is_bad_inode(inode)=%d\n",
--                             is_bad_inode(inode));
--                      printk(KERN_NOTICE "NEXT_ORPHAN(inode)=%u\n",
--                             NEXT_ORPHAN(inode));
--                      printk(KERN_NOTICE "max_ino=%lu\n", max_ino);
--              }
-+      if (!ext3_test_bit(bit, bitmap_bh->b_data))
-+              goto bad_orphan;
-+
-+      inode = iget(sb, ino);
-+      if ((inode == NULL) || is_bad_inode(inode))
-+              goto bad_orphan;
-+
-+      /*
-+       * If the orphan has i_nlinks > 0 then it should be able to be
-+       * truncated, otherwise it won't be removed from the orphan list
-+       * during processing and an infinite loop will result.
-+       */
-+      if (inode->i_nlink && !ext3_can_truncate(inode))
-+              goto bad_orphan;
-+
-+      if (NEXT_ORPHAN(inode) > max_ino)
-+              goto bad_orphan;
-+      brelse(bitmap_bh);
-+      return inode;
-+
-+bad_orphan:
-+      ext3_warning(sb, __func__,
-+                   "bad orphan inode %lu!  e2fsck was run?", ino);
-+      printk(KERN_NOTICE "ext3_test_bit(bit=%d, block=%llu) = %d\n",
-+             bit, (unsigned long long)bitmap_bh->b_blocknr,
-+             ext3_test_bit(bit, bitmap_bh->b_data));
-+      printk(KERN_NOTICE "inode=%p\n", inode);
-+      if (inode) {
-+              printk(KERN_NOTICE "is_bad_inode(inode)=%d\n",
-+                     is_bad_inode(inode));
-+              printk(KERN_NOTICE "NEXT_ORPHAN(inode)=%u\n",
-+                     NEXT_ORPHAN(inode));
-+              printk(KERN_NOTICE "max_ino=%lu\n", max_ino);
-+              printk(KERN_NOTICE "i_nlink=%u\n", inode->i_nlink);
-               /* Avoid freeing blocks if we got a bad deleted inode */
--              if (inode && inode->i_nlink == 0)
-+              if (inode->i_nlink == 0)
-                       inode->i_blocks = 0;
-               iput(inode);
--              inode = NULL;
-       }
--out:
-       brelse(bitmap_bh);
--      return inode;
-+error:
-+      return NULL;
- }
- unsigned long ext3_count_free_inodes (struct super_block * sb)
diff --git a/ldiskfs/kernel_patches/patches/ext3-disable-mb-cache.patch b/ldiskfs/kernel_patches/patches/ext3-disable-mb-cache.patch
deleted file mode 100644 (file)
index 28b3758..0000000
+++ /dev/null
@@ -1,153 +0,0 @@
-Index: linux-stage/fs/ext3/xattr.c
-===================================================================
---- linux-stage.orig/fs/ext3/xattr.c
-+++ linux-stage/fs/ext3/xattr.c
-@@ -93,7 +93,8 @@
- # define ea_bdebug(f...)
- #endif
--static void ext3_xattr_cache_insert(struct buffer_head *);
-+static void ext3_xattr_cache_insert(struct super_block *,
-+                                  struct buffer_head *);
- static struct buffer_head *ext3_xattr_cache_find(struct inode *,
-                                                struct ext3_xattr_header *,
-                                                struct mb_cache_entry **);
-@@ -238,7 +239,7 @@ bad_block: ext3_error(inode->i_sb, __FUN
-               error = -EIO;
-               goto cleanup;
-       }
--      ext3_xattr_cache_insert(bh);
-+      ext3_xattr_cache_insert(inode->i_sb, bh);
-       entry = BFIRST(bh);
-       error = ext3_xattr_find_entry(&entry, name_index, name, bh->b_size, 1);
-       if (error == -EIO)
-@@ -380,7 +381,7 @@ ext3_xattr_block_list(struct inode *inod
-               error = -EIO;
-               goto cleanup;
-       }
--      ext3_xattr_cache_insert(bh);
-+      ext3_xattr_cache_insert(inode->i_sb, bh);
-       error = ext3_xattr_list_entries(inode, BFIRST(bh), buffer, buffer_size);
- cleanup:
-@@ -479,7 +480,9 @@ ext3_xattr_release_block(handle_t *handl
- {
-       struct mb_cache_entry *ce = NULL;
--      ce = mb_cache_entry_get(ext3_xattr_cache, bh->b_bdev, bh->b_blocknr);
-+      if (!test_opt(inode->i_sb, NO_MBCACHE))
-+              ce = mb_cache_entry_get(ext3_xattr_cache, bh->b_bdev,
-+                                      bh->b_blocknr);
-       if (BHDR(bh)->h_refcount == cpu_to_le32(1)) {
-               ea_bdebug(bh, "refcount now=0; freeing");
-               if (ce)
-@@ -699,8 +702,10 @@ ext3_xattr_block_set(handle_t *handle, s
-       if (i->value && i->value_len > sb->s_blocksize)
-               return -ENOSPC;
-       if (s->base) {
--              ce = mb_cache_entry_get(ext3_xattr_cache, bs->bh->b_bdev,
--                                      bs->bh->b_blocknr);
-+              if (!test_opt(inode->i_sb, NO_MBCACHE))
-+                      ce = mb_cache_entry_get(ext3_xattr_cache,
-+                                              bs->bh->b_bdev,
-+                                              bs->bh->b_blocknr);
-               if (header(s->base)->h_refcount == cpu_to_le32(1)) {
-                       if (ce) {
-                               mb_cache_entry_free(ce);
-@@ -716,7 +721,7 @@ ext3_xattr_block_set(handle_t *handle, s
-                               if (!IS_LAST_ENTRY(s->first))
-                                       ext3_xattr_rehash(header(s->base),
-                                                         s->here);
--                              ext3_xattr_cache_insert(bs->bh);
-+                              ext3_xattr_cache_insert(sb, bs->bh);
-                       }
-                       unlock_buffer(bs->bh);
-                       if (error == -EIO)
-@@ -797,7 +802,8 @@ inserted:
-                               if (error)
-                                       goto cleanup_dquot;
-                       }
--                      mb_cache_entry_release(ce);
-+                      if (ce)
-+                              mb_cache_entry_release(ce);
-                       ce = NULL;
-               } else if (bs->bh && s->base == bs->bh->b_data) {
-                       /* We were modifying this block in-place. */
-@@ -832,7 +838,7 @@ getblk_failed:
-                       memcpy(new_bh->b_data, s->base, new_bh->b_size);
-                       set_buffer_uptodate(new_bh);
-                       unlock_buffer(new_bh);
--                      ext3_xattr_cache_insert(new_bh);
-+                      ext3_xattr_cache_insert(sb, new_bh);
-                       error = ext3_journal_dirty_metadata(handle, new_bh);
-                       if (error)
-                               goto cleanup;
-@@ -1387,12 +1393,15 @@ ext3_xattr_put_super(struct super_block 
-  * Returns 0, or a negative error number on failure.
-  */
- static void
--ext3_xattr_cache_insert(struct buffer_head *bh)
-+ext3_xattr_cache_insert(struct super_block *sb, struct buffer_head *bh)
- {
-       __u32 hash = le32_to_cpu(BHDR(bh)->h_hash);
-       struct mb_cache_entry *ce;
-       int error;
-+      if (test_opt(sb, NO_MBCACHE))
-+              return;
-+
-       ce = mb_cache_entry_alloc(ext3_xattr_cache);
-       if (!ce) {
-               ea_bdebug(bh, "out of memory");
-@@ -1466,6 +1475,8 @@ ext3_xattr_cache_find(struct inode *inod
-       __u32 hash = le32_to_cpu(header->h_hash);
-       struct mb_cache_entry *ce;
-+      if (test_opt(inode->i_sb, NO_MBCACHE))
-+              return NULL;
-       if (!header->h_hash)
-               return NULL;  /* never share */
-       ea_idebug(inode, "looking for cached blocks [%x]", (int)hash);
-Index: linux-stage/fs/ext3/super.c
-===================================================================
---- linux-stage.orig/fs/ext3/super.c
-+++ linux-stage/fs/ext3/super.c
-@@ -722,6 +722,7 @@ enum {
-       Opt_grpquota,
-       Opt_extents, Opt_noextents, Opt_bigendian_extents, Opt_extdebug,
-       Opt_mballoc, Opt_nomballoc, Opt_stripe, Opt_maxdirsize, Opt_force_over_8tb,
-+      Opt_no_mbcache,
- };
- static match_table_t tokens = {
-@@ -788,6 +789,7 @@ static match_table_t tokens = {
-       {Opt_force_over_8tb, "force_over_8tb"},
-       {Opt_resize, "resize"},
-       {Opt_maxdirsize, "maxdirsize=%u"},
-+      {Opt_no_mbcache, "no_mbcache"},
-       {Opt_err, NULL}
- };
-@@ -1175,6 +1177,9 @@ clear_qf_name:
-               case Opt_force_over_8tb:
-                       force_over_8tb = 1;
-                       break;
-+              case Opt_no_mbcache:
-+                      set_opt(sbi->s_mount_opt, NO_MBCACHE);
-+                      break;
-               default:
-                       printk (KERN_ERR
-                               "EXT3-fs: Unrecognized mount option \"%s\" "
-Index: linux-stage/include/linux/ext3_fs.h
-===================================================================
---- linux-stage.orig/include/linux/ext3_fs.h
-+++ linux-stage/include/linux/ext3_fs.h
-@@ -483,6 +483,8 @@ do {                                                                              \
- #define EXT3_MOUNT_JOURNAL_ASYNC_COMMIT 0x20000000 /* Journal Async Commit */
- #endif
-+#define EXT3_MOUNT_NO_MBCACHE           0x40000000 /* Disable mbcache */
-+
- /* Compatibility, for having both ext2_fs.h and ext3_fs.h included at once */
- #ifndef clear_opt
- #define clear_opt(o, opt)             o &= ~EXT3_MOUNT_##opt
diff --git a/ldiskfs/kernel_patches/patches/ext3-dynlocks-2.6-rhel5.patch b/ldiskfs/kernel_patches/patches/ext3-dynlocks-2.6-rhel5.patch
deleted file mode 100644 (file)
index dc973a7..0000000
+++ /dev/null
@@ -1,33 +0,0 @@
-diff -rupN linux-2.6.18-128.1.6_1/fs/ext3/Makefile linux-2.6.18-128.1.6_2/fs/ext3/Makefile
---- linux-2.6.18-128.1.6_1/fs/ext3/Makefile    2009-08-13 19:19:54.000000000 +0530
-+++ linux-2.6.18-128.1.6_2/fs/ext3/Makefile    2009-08-13 19:20:30.000000000 +0530
-@@ -5,7 +5,8 @@
- obj-$(CONFIG_EXT3_FS) += ext3.o
- ext3-y        := balloc.o bitmap.o dir.o file.o fsync.o ialloc.o inode.o \
--         ioctl.o namei.o super.o symlink.o hash.o resize.o extents.o mballoc.o
-+         ioctl.o namei.o super.o symlink.o hash.o resize.o extents.o \
-+         mballoc.o dynlocks.o
- ext3-$(CONFIG_EXT3_FS_XATTR)   += xattr.o xattr_user.o xattr_trusted.o
- ext3-$(CONFIG_EXT3_FS_POSIX_ACL) += acl.o
-diff -rupN linux-2.6.18-128.1.6_1/fs/ext3/super.c linux-2.6.18-128.1.6_2/fs/ext3/super.c
---- linux-2.6.18-128.1.6_1/fs/ext3/super.c     2009-08-13 19:19:54.000000000 +0530
-+++ linux-2.6.18-128.1.6_2/fs/ext3/super.c     2009-08-13 19:23:23.000000000 +0530
-@@ -3529,6 +3530,7 @@ static int __init init_ext3_fs(void)
-       err = init_inodecache();
-       if (err)
-               goto out1;
-+      dynlock_cache_init();
-         err = register_filesystem(&ext3_fs_type);
-       if (err)
-               goto out;
-@@ -3546,6 +3548,7 @@ out1:
- static void __exit exit_ext3_fs(void)
- {
-       unregister_filesystem(&ext3_fs_type);
-+      dynlock_cache_exit();
-       destroy_inodecache();
-       exit_ext3_xattr();
-       exit_ext3_proc();
-
diff --git a/ldiskfs/kernel_patches/patches/ext3-dynlocks-common.patch b/ldiskfs/kernel_patches/patches/ext3-dynlocks-common.patch
deleted file mode 100644 (file)
index 73b0c87..0000000
+++ /dev/null
@@ -1,278 +0,0 @@
-diff -rupN linux-2.6.18-128.1.6_1/fs/ext3/dynlocks.c linux-2.6.18-128.1.6_2/fs/ext3/dynlocks.c
---- linux-2.6.18-128.1.6_1/fs/ext3/dynlocks.c  1970-01-01 05:30:00.000000000 +0530
-+++ linux-2.6.18-128.1.6_2/fs/ext3/dynlocks.c  2009-08-13 20:42:59.000000000 +0530
-@@ -0,0 +1,236 @@
-+/*
-+ * Dynamic Locks
-+ *
-+ * struct dynlock is lockspace
-+ * one may request lock (exclusive or shared) for some value
-+ * in that lockspace
-+ *
-+ */
-+
-+#include <linux/dynlocks.h>
-+#include <linux/module.h>
-+#include <linux/slab.h>
-+#include <linux/sched.h>
-+
-+#define DYNLOCK_HANDLE_MAGIC  0xd19a10c
-+#define DYNLOCK_HANDLE_DEAD   0xd1956ee
-+#define DYNLOCK_LIST_MAGIC    0x11ee91e6
-+
-+static kmem_cache_t * dynlock_cachep = NULL;
-+
-+struct dynlock_handle {
-+      unsigned                dh_magic;
-+      struct list_head        dh_list;
-+      unsigned long           dh_value;       /* lock value */
-+      int                     dh_refcount;    /* number of users */
-+      int                     dh_readers;
-+      int                     dh_writers;
-+      int                     dh_pid;         /* holder of the lock */
-+      wait_queue_head_t       dh_wait;
-+};
-+
-+int __init dynlock_cache_init(void)
-+{
-+      int rc = 0;
-+
-+      printk(KERN_INFO "init dynlocks cache\n");
-+      dynlock_cachep = kmem_cache_create("dynlock_cache",
-+                                       sizeof(struct dynlock_handle),
-+                                       0,
-+                                       SLAB_HWCACHE_ALIGN,
-+                                       NULL, NULL);
-+      if (dynlock_cachep == NULL) {
-+              printk(KERN_ERR "Not able to create dynlock cache");
-+              rc = -ENOMEM;
-+      }
-+      return rc;
-+}
-+
-+void __exit dynlock_cache_exit(void)
-+{
-+      printk(KERN_INFO "exit dynlocks cache\n");
-+      kmem_cache_destroy(dynlock_cachep);
-+}
-+
-+/*
-+ * dynlock_init
-+ *
-+ * initialize lockspace
-+ *
-+ */
-+void dynlock_init(struct dynlock *dl)
-+{
-+      spin_lock_init(&dl->dl_list_lock);
-+      INIT_LIST_HEAD(&dl->dl_list);
-+      dl->dl_magic = DYNLOCK_LIST_MAGIC;
-+}
-+EXPORT_SYMBOL(dynlock_init);
-+
-+/*
-+ * dynlock_lock
-+ *
-+ * acquires lock (exclusive or shared) in specified lockspace
-+ * each lock in lockspace is allocated separately, so user have
-+ * to specify GFP flags.
-+ * routine returns pointer to lock. this pointer is intended to
-+ * be passed to dynlock_unlock
-+ *
-+ */
-+struct dynlock_handle *dynlock_lock(struct dynlock *dl, unsigned long value,
-+                                  enum dynlock_type lt, gfp_t gfp)
-+{
-+      struct dynlock_handle *nhl = NULL;
-+      struct dynlock_handle *hl;
-+
-+      BUG_ON(dl == NULL);
-+      BUG_ON(dl->dl_magic != DYNLOCK_LIST_MAGIC);
-+
-+repeat:
-+      /* find requested lock in lockspace */
-+      spin_lock(&dl->dl_list_lock);
-+      BUG_ON(dl->dl_list.next == NULL);
-+      BUG_ON(dl->dl_list.prev == NULL);
-+      list_for_each_entry(hl, &dl->dl_list, dh_list) {
-+              BUG_ON(hl->dh_list.next == NULL);
-+              BUG_ON(hl->dh_list.prev == NULL);
-+              BUG_ON(hl->dh_magic != DYNLOCK_HANDLE_MAGIC);
-+              if (hl->dh_value == value) {
-+                      /* lock is found */
-+                      if (nhl) {
-+                              /* someone else just allocated
-+                               * lock we didn't find and just created
-+                               * so, we drop our lock
-+                               */
-+                              kmem_cache_free(dynlock_cachep, nhl);
-+                              nhl = NULL;
-+                      }
-+                      hl->dh_refcount++;
-+                      goto found;
-+              }
-+      }
-+      /* lock not found */
-+      if (nhl) {
-+              /* we already have allocated lock. use it */
-+              hl = nhl;
-+              nhl = NULL;
-+              list_add(&hl->dh_list, &dl->dl_list);
-+              goto found;
-+      }
-+      spin_unlock(&dl->dl_list_lock);
-+      
-+      /* lock not found and we haven't allocated lock yet. allocate it */
-+      nhl = kmem_cache_alloc(dynlock_cachep, gfp);
-+      if (nhl == NULL)
-+              return NULL;
-+      nhl->dh_refcount = 1;
-+      nhl->dh_value = value;
-+      nhl->dh_readers = 0;
-+      nhl->dh_writers = 0;
-+      nhl->dh_magic = DYNLOCK_HANDLE_MAGIC;
-+      init_waitqueue_head(&nhl->dh_wait);
-+
-+      /* while lock is being allocated, someone else may allocate it
-+       * and put onto to list. check this situation
-+       */
-+      goto repeat;
-+
-+found:
-+      if (lt == DLT_WRITE) {
-+              /* exclusive lock: user don't want to share lock at all
-+               * NOTE: one process may take the same lock several times
-+               * this functionaly is useful for rename operations */
-+              while ((hl->dh_writers && hl->dh_pid != current->pid) ||
-+                              hl->dh_readers) {
-+                      spin_unlock(&dl->dl_list_lock);
-+                      wait_event(hl->dh_wait,
-+                              hl->dh_writers == 0 && hl->dh_readers == 0);
-+                      spin_lock(&dl->dl_list_lock);
-+              }
-+              hl->dh_writers++;
-+      } else {
-+              /* shared lock: user do not want to share lock with writer */
-+              while (hl->dh_writers) {
-+                      spin_unlock(&dl->dl_list_lock);
-+                      wait_event(hl->dh_wait, hl->dh_writers == 0);
-+                      spin_lock(&dl->dl_list_lock);
-+              }
-+              hl->dh_readers++;
-+      }
-+      hl->dh_pid = current->pid;
-+      spin_unlock(&dl->dl_list_lock);
-+
-+      return hl;
-+}
-+EXPORT_SYMBOL(dynlock_lock);
-+
-+
-+/*
-+ * dynlock_unlock
-+ *
-+ * user have to specify lockspace (dl) and pointer to lock structure
-+ * returned by dynlock_lock()
-+ *
-+ */
-+void dynlock_unlock(struct dynlock *dl, struct dynlock_handle *hl)
-+{
-+      int wakeup = 0;
-+      
-+      BUG_ON(dl == NULL);
-+      BUG_ON(hl == NULL);
-+      BUG_ON(dl->dl_magic != DYNLOCK_LIST_MAGIC);
-+
-+      if (hl->dh_magic != DYNLOCK_HANDLE_MAGIC)
-+              printk(KERN_EMERG "wrong lock magic: %#x\n", hl->dh_magic);
-+
-+      BUG_ON(hl->dh_magic != DYNLOCK_HANDLE_MAGIC);
-+      BUG_ON(hl->dh_writers != 0 && current->pid != hl->dh_pid);
-+
-+      spin_lock(&dl->dl_list_lock);
-+      if (hl->dh_writers) {
-+              BUG_ON(hl->dh_readers != 0);
-+              hl->dh_writers--;
-+              if (hl->dh_writers == 0)
-+                      wakeup = 1;
-+      } else if (hl->dh_readers) {
-+              hl->dh_readers--;
-+              if (hl->dh_readers == 0)
-+                      wakeup = 1;
-+      } else {
-+              BUG();
-+      }
-+      if (wakeup) {
-+              hl->dh_pid = 0;
-+              wake_up(&hl->dh_wait);
-+      }
-+      if (--(hl->dh_refcount) == 0) {
-+              hl->dh_magic = DYNLOCK_HANDLE_DEAD;
-+              list_del(&hl->dh_list);
-+              kmem_cache_free(dynlock_cachep, hl);
-+      }
-+      spin_unlock(&dl->dl_list_lock);
-+}
-+EXPORT_SYMBOL(dynlock_unlock);
-+
-+int dynlock_is_locked(struct dynlock *dl, unsigned long value)
-+{
-+      struct dynlock_handle *hl;
-+      int result = 0;
-+
-+      /* find requested lock in lockspace */
-+      spin_lock(&dl->dl_list_lock);
-+      BUG_ON(dl->dl_list.next == NULL);
-+      BUG_ON(dl->dl_list.prev == NULL);
-+      list_for_each_entry(hl, &dl->dl_list, dh_list) {
-+              BUG_ON(hl->dh_list.next == NULL);
-+              BUG_ON(hl->dh_list.prev == NULL);
-+              BUG_ON(hl->dh_magic != DYNLOCK_HANDLE_MAGIC);
-+              if (hl->dh_value == value && hl->dh_pid == current->pid) {
-+                      /* lock is found */
-+                      result = 1;
-+                      break;
-+              }
-+      }
-+      spin_unlock(&dl->dl_list_lock);
-+      return result;
-+}
-+EXPORT_SYMBOL(dynlock_is_locked);
-diff -rupN linux-2.6.18-128.1.6_1/include/linux/dynlocks.h linux-2.6.18-128.1.6_2/include/linux/dynlocks.h
---- linux-2.6.18-128.1.6_1/include/linux/dynlocks.h    1970-01-01 05:30:00.000000000 +0530
-+++ linux-2.6.18-128.1.6_2/include/linux/dynlocks.h    2009-08-13 20:43:18.000000000 +0530
-@@ -0,0 +1,34 @@
-+#ifndef _LINUX_DYNLOCKS_H
-+#define _LINUX_DYNLOCKS_H
-+
-+#include <linux/list.h>
-+#include <linux/wait.h>
-+
-+struct dynlock_handle;
-+
-+/*
-+ * lock's namespace:
-+ *   - list of locks
-+ *   - lock to protect this list
-+ */
-+struct dynlock {
-+      unsigned                dl_magic;
-+      struct list_head        dl_list;
-+      spinlock_t              dl_list_lock;
-+};
-+
-+enum dynlock_type {
-+      DLT_WRITE,
-+      DLT_READ
-+};
-+
-+int dynlock_cache_init(void);
-+void dynlock_cache_exit(void);
-+void dynlock_init(struct dynlock *dl);
-+struct dynlock_handle *dynlock_lock(struct dynlock *dl, unsigned long value,
-+                                  enum dynlock_type lt, gfp_t gfp);
-+void dynlock_unlock(struct dynlock *dl, struct dynlock_handle *lock);
-+int dynlock_is_locked(struct dynlock *dl, unsigned long value);
-+
-+#endif
-+
diff --git a/ldiskfs/kernel_patches/patches/ext3-ea-expand-lose-block.patch b/ldiskfs/kernel_patches/patches/ext3-ea-expand-lose-block.patch
deleted file mode 100644 (file)
index d40b40d..0000000
+++ /dev/null
@@ -1,27 +0,0 @@
-Date: Mon, 12 May 2008 11:24:40 +0800
-From: Tiger Yang <tiger.yang@oracle.com>
-Subject: [PATCH] ext3/4: fix uninitialized bs in ext3/4_xattr_set_handle()
-To: linux-ext4@vger.kernel.org
-Cc: linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org
-
-This fix the uninitialized bs when we try to replace a xattr entry in ibody
-with the new value which require more than free space.
-
-Signed-off-by: Tiger Yang <tiger.yang@oracle.com>
-
-
-diff --git a/fs/ext3/xattr.c b/fs/ext3/xattr.c
---- a/fs/ext3/xattr.c
-+++ b/fs/ext3/xattr.c
-@@ -1000,6 +1000,11 @@ ext3_xattr_set_handle(handle_t *handle, struct inode *inode, int name_index,
-                       i.value = NULL;
-                       error = ext3_xattr_block_set(handle, inode, &i, &bs);
-               } else if (error == -ENOSPC) {
-+                      if (EXT3_I(inode)->i_file_acl && !bs.s.base) {
-+                              error = ext3_xattr_block_find(inode, &i, &bs);
-+                              if (error)
-+                                      goto cleanup;
-+                      }
-                       error = ext3_xattr_block_set(handle, inode, &i, &bs);
-                       if (error)
-                               goto cleanup;
diff --git a/ldiskfs/kernel_patches/patches/ext3-export-64bit-name-hash.patch b/ldiskfs/kernel_patches/patches/ext3-export-64bit-name-hash.patch
deleted file mode 100644 (file)
index 9cc7294..0000000
+++ /dev/null
@@ -1,135 +0,0 @@
-Index: linux-stage/fs/ext3/dir.c
-===================================================================
---- linux-stage.orig/fs/ext3/dir.c     2011-04-19 01:39:47.000000000 +0800
-+++ linux-stage/fs/ext3/dir.c  2011-04-19 01:44:19.000000000 +0800
-@@ -237,22 +237,50 @@
- }
-
- #ifdef CONFIG_EXT3_INDEX
-+static inline int is_32bit_api(void)
-+{
-+#ifdef HAVE_IS_COMPAT_TASK
-+        return is_compat_task();
-+#else
-+        return (BITS_PER_LONG == 32);
-+#endif
-+}
-+
- /*
-  * These functions convert from the major/minor hash to an f_pos
-  * value.
-- * 
-- * Currently we only use major hash numer.  This is unfortunate, but
-- * on 32-bit machines, the same VFS interface is used for lseek and
-- * llseek, so if we use the 64 bit offset, then the 32-bit versions of
-- * lseek/telldir/seekdir will blow out spectacularly, and from within
-- * the ext2 low-level routine, we don't know if we're being called by
-- * a 64-bit version of the system call or the 32-bit version of the
-- * system call.  Worse yet, NFSv2 only allows for a 32-bit readdir
-- * cookie.  Sigh.
-+ *
-+ * Up layer (OSD) should specify O_32BITHASH or O_64BITHASH explicitly.
-+ * On the other hand, we allow ldiskfs to be mounted directly on both 32-bit
-+ * and 64-bit nodes, under such case, neither O_32BITHASH nor O_64BITHASH is
-+ * specified.
-  */
--#define hash2pos(major, minor)        (major >> 1)
--#define pos2maj_hash(pos)     ((pos << 1) & 0xffffffff)
--#define pos2min_hash(pos)     (0)
-+static inline loff_t hash2pos(struct file *filp, __u32 major, __u32 minor)
-+{
-+      if ((filp->f_flags & O_32BITHASH) ||
-+          (!(filp->f_flags & O_64BITHASH) && is_32bit_api()))
-+              return (major >> 1);
-+      else
-+              return (((__u64)(major >> 1) << 32) | (__u64)minor);
-+}
-+
-+static inline __u32 pos2maj_hash(struct file *filp, loff_t pos)
-+{
-+      if ((filp->f_flags & O_32BITHASH) ||
-+          (!(filp->f_flags & O_64BITHASH) && is_32bit_api()))
-+              return ((pos << 1) & 0xffffffff);
-+      else
-+              return (((pos >> 32) << 1) & 0xffffffff);
-+}
-+
-+static inline __u32 pos2min_hash(struct file *filp, loff_t pos)
-+{
-+      if ((filp->f_flags & O_32BITHASH) ||
-+          (!(filp->f_flags & O_64BITHASH) && is_32bit_api()))
-+              return (0);
-+      else
-+              return (pos & 0xffffffff);
-+}
- /*
-  * This structure holds the nodes of the red-black tree used to store
-@@ -314,7 +342,7 @@
- }
--static struct dir_private_info *create_dir_info(loff_t pos)
-+static struct dir_private_info *create_dir_info(struct file* filp, loff_t pos)
- {
-       struct dir_private_info *p;
-@@ -325,8 +353,8 @@
-       p->curr_node = NULL;
-       p->extra_fname = NULL;
-       p->last_pos = 0;
--      p->curr_hash = pos2maj_hash(pos);
--      p->curr_minor_hash = pos2min_hash(pos);
-+      p->curr_hash = pos2maj_hash(filp, pos);
-+      p->curr_minor_hash = pos2min_hash(filp, pos);
-       p->next_hash = 0;
-       return p;
- }
-@@ -422,7 +450,7 @@
-               printk("call_filldir: called with null fname?!?\n");
-               return 0;
-       }
--      curr_pos = hash2pos(fname->hash, fname->minor_hash);
-+      curr_pos = hash2pos(filp, fname->hash, fname->minor_hash);
-       while (fname) {
-               error = filldir(dirent, fname->name,
-                               fname->name_len, curr_pos, 
-@@ -447,7 +475,7 @@
-       int     ret;
-       if (!info) {
--              info = create_dir_info(filp->f_pos);
-+              info = create_dir_info(filp, filp->f_pos);
-               if (!info)
-                       return -ENOMEM;
-               filp->private_data = info;
-@@ -461,8 +489,8 @@
-               free_rb_tree_fname(&info->root);
-               info->curr_node = NULL;
-               info->extra_fname = NULL;
--              info->curr_hash = pos2maj_hash(filp->f_pos);
--              info->curr_minor_hash = pos2min_hash(filp->f_pos);
-+              info->curr_hash = pos2maj_hash(filp, filp->f_pos);
-+              info->curr_minor_hash = pos2min_hash(filp, filp->f_pos);
-       }
-       /*
-Index: linux-stage/include/linux/ext3_fs.h
-===================================================================
---- linux-stage.orig/include/linux/ext3_fs.h   2011-04-19 01:39:47.000000000 +0800
-+++ linux-stage/include/linux/ext3_fs.h        2011-04-19 01:45:21.000000000 +0800
-@@ -54,6 +54,14 @@
- #define ext3_debug(f, a...)   do {} while (0)
- #endif
-+#ifndef O_32BITHASH
-+# define O_32BITHASH    0x10000000
-+#endif
-+
-+#ifndef O_64BITHASH
-+# define O_64BITHASH    0x20000000
-+#endif
-+
- #define EXT3_MULTIBLOCK_ALLOCATOR     1
-
- #define EXT3_MB_HINT_MERGE            1       /* prefer goal again. length */
diff --git a/ldiskfs/kernel_patches/patches/ext3-extents-2.6.18-vanilla.patch b/ldiskfs/kernel_patches/patches/ext3-extents-2.6.18-vanilla.patch
deleted file mode 100644 (file)
index 0b5d110..0000000
+++ /dev/null
@@ -1,2903 +0,0 @@
-Index: linux-2.6.18.8/fs/ext3/dir.c
-===================================================================
---- linux-2.6.18.8.orig/fs/ext3/dir.c  2007-02-24 00:52:30.000000000 +0100
-+++ linux-2.6.18.8/fs/ext3/dir.c       2007-07-17 09:18:14.000000000 +0200
-@@ -131,8 +131,7 @@ static int ext3_readdir(struct file * fi
-               struct buffer_head *bh = NULL;
-               map_bh.b_state = 0;
--              err = ext3_get_blocks_handle(NULL, inode, blk, 1,
--                                              &map_bh, 0, 0);
-+              err = ext3_get_blocks_wrap(NULL, inode, blk, 1, &map_bh, 0, 0);
-               if (err > 0) {
-                       page_cache_readahead(sb->s_bdev->bd_inode->i_mapping,
-                               &filp->f_ra,
-Index: linux-2.6.18.8/fs/ext3/extents.c
-===================================================================
---- /dev/null  1970-01-01 00:00:00.000000000 +0000
-+++ linux-2.6.18.8/fs/ext3/extents.c   2007-07-17 11:08:59.000000000 +0200
-@@ -0,0 +1,2276 @@
-+/*
-+ * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
-+ * Written by Alex Tomas <alex@clusterfs.com>
-+ *
-+ * Architecture independence:
-+ *   Copyright (c) 2005, Bull S.A.
-+ *   Written by Pierre Peiffer <pierre.peiffer@bull.net>
-+ *
-+ * This program is free software; you can redistribute it and/or modify
-+ * it under the terms of the GNU General Public License version 2 as
-+ * published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-+ * GNU General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public Licens
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-
-+ */
-+
-+/*
-+ * Extents support for EXT3
-+ *
-+ * TODO:
-+ *   - ext3*_error() should be used in some situations
-+ *   - analyze all BUG()/BUG_ON(), use -EIO where appropriate
-+ *   - smart tree reduction
-+ */
-+
-+#include <linux/module.h>
-+#include <linux/fs.h>
-+#include <linux/time.h>
-+#include <linux/ext3_jbd.h>
-+#include <linux/jbd.h>
-+#include <linux/smp_lock.h>
-+#include <linux/highuid.h>
-+#include <linux/pagemap.h>
-+#include <linux/quotaops.h>
-+#include <linux/string.h>
-+#include <linux/slab.h>
-+#include <linux/ext3_extents.h>
-+#include <asm/uaccess.h>
-+
-+
-+static handle_t *ext3_ext_journal_restart(handle_t *handle, int needed)
-+{
-+      int err;
-+
-+      if (handle->h_buffer_credits > needed)
-+              return handle;
-+      if (!ext3_journal_extend(handle, needed))
-+              return handle;
-+      err = ext3_journal_restart(handle, needed);
-+
-+      return handle;
-+}
-+
-+/*
-+ * could return:
-+ *  - EROFS
-+ *  - ENOMEM
-+ */
-+static int ext3_ext_get_access(handle_t *handle, struct inode *inode,
-+                              struct ext3_ext_path *path)
-+{
-+      if (path->p_bh) {
-+              /* path points to block */
-+              return ext3_journal_get_write_access(handle, path->p_bh);
-+      }
-+      /* path points to leaf/index in inode body */
-+      /* we use in-core data, no need to protect them */
-+      return 0;
-+}
-+
-+/*
-+ * could return:
-+ *  - EROFS
-+ *  - ENOMEM
-+ *  - EIO
-+ */
-+static int ext3_ext_dirty(handle_t *handle, struct inode *inode,
-+                              struct ext3_ext_path *path)
-+{
-+      int err;
-+      if (path->p_bh) {
-+              /* path points to block */
-+              err = ext3_journal_dirty_metadata(handle, path->p_bh);
-+      } else {
-+              /* path points to leaf/index in inode body */
-+              err = ext3_mark_inode_dirty(handle, inode);
-+      }
-+      return err;
-+}
-+
-+static int ext3_ext_find_goal(struct inode *inode,
-+                            struct ext3_ext_path *path,
-+                            unsigned long block)
-+{
-+      struct ext3_inode_info *ei = EXT3_I(inode);
-+      unsigned long bg_start;
-+      unsigned long colour;
-+      int depth;
-+
-+      if (path) {
-+              struct ext3_extent *ex;
-+              depth = path->p_depth;
-+
-+              /* try to predict block placement */
-+              if ((ex = path[depth].p_ext))
-+                      return le32_to_cpu(ex->ee_start)
-+                                      + (block - le32_to_cpu(ex->ee_block));
-+
-+              /* it looks index is empty
-+               * try to find starting from index itself */
-+              if (path[depth].p_bh)
-+                      return path[depth].p_bh->b_blocknr;
-+      }
-+
-+      /* OK. use inode's group */
-+      bg_start = (ei->i_block_group * EXT3_BLOCKS_PER_GROUP(inode->i_sb)) +
-+              le32_to_cpu(EXT3_SB(inode->i_sb)->s_es->s_first_data_block);
-+      colour = (current->pid % 16) *
-+                      (EXT3_BLOCKS_PER_GROUP(inode->i_sb) / 16);
-+      return bg_start + colour + block;
-+}
-+
-+static int
-+ext3_ext_new_block(handle_t *handle, struct inode *inode,
-+                      struct ext3_ext_path *path,
-+                      struct ext3_extent *ex, int *err)
-+{
-+      int goal, newblock;
-+
-+      goal = ext3_ext_find_goal(inode, path, le32_to_cpu(ex->ee_block));
-+      newblock = ext3_new_block(handle, inode, goal, err);
-+      return newblock;
-+}
-+
-+static inline int ext3_ext_space_block(struct inode *inode)
-+{
-+      int size;
-+
-+      size = (inode->i_sb->s_blocksize - sizeof(struct ext3_extent_header))
-+                      / sizeof(struct ext3_extent);
-+#ifdef AGRESSIVE_TEST
-+      if (size > 6)
-+              size = 6;
-+#endif
-+      return size;
-+}
-+
-+static inline int ext3_ext_space_block_idx(struct inode *inode)
-+{
-+      int size;
-+
-+      size = (inode->i_sb->s_blocksize - sizeof(struct ext3_extent_header))
-+                      / sizeof(struct ext3_extent_idx);
-+#ifdef AGRESSIVE_TEST
-+      if (size > 5)
-+              size = 5;
-+#endif
-+      return size;
-+}
-+
-+static inline int ext3_ext_space_root(struct inode *inode)
-+{
-+      int size;
-+
-+      size = sizeof(EXT3_I(inode)->i_data);
-+      size -= sizeof(struct ext3_extent_header);
-+      size /= sizeof(struct ext3_extent);
-+#ifdef AGRESSIVE_TEST
-+      if (size > 3)
-+              size = 3;
-+#endif
-+      return size;
-+}
-+
-+static inline int ext3_ext_space_root_idx(struct inode *inode)
-+{
-+      int size;
-+
-+      size = sizeof(EXT3_I(inode)->i_data);
-+      size -= sizeof(struct ext3_extent_header);
-+      size /= sizeof(struct ext3_extent_idx);
-+#ifdef AGRESSIVE_TEST
-+      if (size > 4)
-+              size = 4;
-+#endif
-+      return size;
-+}
-+
-+static inline int
-+ext3_ext_max_entries(struct inode *inode, int depth)
-+{
-+      int max;
-+
-+      if (depth == ext_depth(inode)) {
-+              if (depth == 0)
-+                      max = ext3_ext_space_root(inode);
-+              else
-+                      max = ext3_ext_space_root_idx(inode);
-+      } else {
-+              if (depth == 0)
-+                      max = ext3_ext_space_block(inode);
-+              else
-+                      max = ext3_ext_space_block_idx(inode);
-+      }
-+
-+      return max;
-+}
-+
-+static int __ext3_ext_check_header(const char *function, int line, struct inode *inode,
-+                                      struct ext3_extent_header *eh,
-+                                      int depth)
-+{
-+      const char *error_msg = NULL;
-+      int max = 0;
-+
-+      if (unlikely(eh->eh_magic != cpu_to_le16(EXT3_EXT_MAGIC))) {
-+              error_msg = "invalid magic";
-+              goto corrupted;
-+      }
-+      if (unlikely(le16_to_cpu(eh->eh_depth) != depth)) {
-+              error_msg = "unexpected eh_depth";
-+              goto corrupted;
-+      }
-+      if (unlikely(eh->eh_max == 0)) {
-+              error_msg = "invalid eh_max";
-+              goto corrupted;
-+      }
-+      max = ext3_ext_max_entries(inode, depth);
-+#ifdef AGRESSIVE_TEST
-+      if (eh->eh_max > 3) {
-+              /* inode probably got extent without defining AGRESSIVE_TEST */
-+              max = eh->eh_max;
-+      }
-+#endif
-+      if (unlikely(le16_to_cpu(eh->eh_max) > max)) {
-+              error_msg = "too large eh_max";
-+              goto corrupted;
-+      }
-+      if (unlikely(le16_to_cpu(eh->eh_entries) > le16_to_cpu(eh->eh_max))) {
-+              error_msg = "invalid eh_entries";
-+              goto corrupted;
-+      }
-+      if (unlikely((eh->eh_entries == 0) && (eh->eh_depth != 0))) {
-+              error_msg = "invalid index, eh_entries=0 && eh_depth != 0";
-+              goto corrupted;
-+      }
-+      return 0;
-+
-+corrupted:
-+      ext3_error(inode->i_sb, function,
-+                      ":%d: bad header in inode #%lu: %s - magic %x, "
-+                      "entries %u, max %u(%u), depth %u(%u)", line,
-+                      inode->i_ino, error_msg, le16_to_cpu(eh->eh_magic),
-+                      le16_to_cpu(eh->eh_entries), le16_to_cpu(eh->eh_max),
-+                      max, le16_to_cpu(eh->eh_depth), depth);
-+
-+      return -EIO;
-+}
-+
-+#define ext3_ext_check_header(inode,eh,depth) \
-+      __ext3_ext_check_header(__FUNCTION__,__LINE__,inode,eh,depth)
-+
-+#ifdef EXT_DEBUG
-+static void ext3_ext_show_path(struct inode *inode, struct ext3_ext_path *path)
-+{
-+      int k, l = path->p_depth;
-+
-+      ext_debug(inode, "path:");
-+      for (k = 0; k <= l; k++, path++) {
-+              if (path->p_idx) {
-+                ext_debug(inode, "  %d->%d", le32_to_cpu(path->p_idx->ei_block),
-+                          le32_to_cpu(path->p_idx->ei_leaf));
-+              } else if (path->p_ext) {
-+                      ext_debug(inode, "  %d:%d:%d",
-+                                le32_to_cpu(path->p_ext->ee_block),
-+                                le16_to_cpu(path->p_ext->ee_len),
-+                                le32_to_cpu(path->p_ext->ee_start));
-+              } else
-+                      ext_debug(inode, "  []");
-+      }
-+      ext_debug(inode, "\n");
-+}
-+
-+static void ext3_ext_show_leaf(struct inode *inode, struct ext3_ext_path *path)
-+{
-+      int depth = ext_depth(inode);
-+      struct ext3_extent_header *eh;
-+      struct ext3_extent *ex;
-+      int i;
-+
-+      if (!path)
-+              return;
-+
-+      eh = path[depth].p_hdr;
-+      ex = EXT_FIRST_EXTENT(eh);
-+
-+      for (i = 0; i < le16_to_cpu(eh->eh_entries); i++, ex++) {
-+              ext_debug(inode, "%d:%d:%d ", le32_to_cpu(ex->ee_block),
-+                        le16_to_cpu(ex->ee_len),
-+                        le32_to_cpu(ex->ee_start));
-+      }
-+      ext_debug(inode, "\n");
-+}
-+#else
-+#define ext3_ext_show_path(inode,path)
-+#define ext3_ext_show_leaf(inode,path)
-+#endif
-+
-+static void ext3_ext_drop_refs(struct ext3_ext_path *path)
-+{
-+      int depth = path->p_depth;
-+      int i;
-+
-+      for (i = 0; i <= depth; i++, path++)
-+              if (path->p_bh) {
-+                      brelse(path->p_bh);
-+                      path->p_bh = NULL;
-+              }
-+}
-+
-+/*
-+ * binary search for closest index by given block
-+ * the header must be checked before calling this
-+ */
-+static void
-+ext3_ext_binsearch_idx(struct inode *inode, struct ext3_ext_path *path, int block)
-+{
-+      struct ext3_extent_header *eh = path->p_hdr;
-+      struct ext3_extent_idx *r, *l, *m;
-+
-+      ext_debug(inode, "binsearch for %d(idx):  ", block);
-+
-+      l = EXT_FIRST_INDEX(eh) + 1;
-+      r = EXT_FIRST_INDEX(eh) + le16_to_cpu(eh->eh_entries) - 1;
-+      while (l <= r) {
-+              m = l + (r - l) / 2;
-+              if (block < le32_to_cpu(m->ei_block))
-+                      r = m - 1;
-+              else
-+                      l = m + 1;
-+              ext_debug(inode, "%p(%u):%p(%u):%p(%u) ", l, l->ei_block,
-+                              m, m->ei_block, r, r->ei_block);
-+      }
-+
-+      path->p_idx = l - 1;
-+      ext_debug(inode, "  -> %d->%d ", le32_to_cpu(path->p_idx->ei_block),
-+                le32_to_cpu(path->p_idx->ei_leaf));
-+
-+#ifdef CHECK_BINSEARCH
-+      {
-+              struct ext3_extent_idx *chix, *ix;
-+              int k;
-+
-+              chix = ix = EXT_FIRST_INDEX(eh);
-+              for (k = 0; k < le16_to_cpu(eh->eh_entries); k++, ix++) {
-+                if (k != 0 &&
-+                    le32_to_cpu(ix->ei_block) <= le32_to_cpu(ix[-1].ei_block)) {
-+                              printk("k=%d, ix=0x%p, first=0x%p\n", k,
-+                                      ix, EXT_FIRST_INDEX(eh));
-+                              printk("%u <= %u\n",
-+                                     le32_to_cpu(ix->ei_block),
-+                                     le32_to_cpu(ix[-1].ei_block));
-+                      }
-+                      BUG_ON(k && le32_to_cpu(ix->ei_block)
-+                                         <= le32_to_cpu(ix[-1].ei_block));
-+                      if (block < le32_to_cpu(ix->ei_block))
-+                              break;
-+                      chix = ix;
-+              }
-+              BUG_ON(chix != path->p_idx);
-+      }
-+#endif
-+
-+}
-+
-+/*
-+ * binary search for closest extent by given block
-+ * the header must be checked before calling this
-+ */
-+static void
-+ext3_ext_binsearch(struct inode *inode, struct ext3_ext_path *path, int block)
-+{
-+      struct ext3_extent_header *eh = path->p_hdr;
-+      struct ext3_extent *r, *l, *m;
-+
-+      if (eh->eh_entries == 0) {
-+              /*
-+               * this leaf is empty yet:
-+               *  we get such a leaf in split/add case
-+               */
-+              return;
-+      }
-+
-+      ext_debug(inode, "binsearch for %d:  ", block);
-+
-+      l = EXT_FIRST_EXTENT(eh) + 1;
-+      r = EXT_FIRST_EXTENT(eh) + le16_to_cpu(eh->eh_entries) - 1;
-+
-+      while (l <= r) {
-+              m = l + (r - l) / 2;
-+              if (block < le32_to_cpu(m->ee_block))
-+                      r = m - 1;
-+              else
-+                      l = m + 1;
-+              ext_debug(inode, "%p(%u):%p(%u):%p(%u) ", l, l->ee_block,
-+                              m, m->ee_block, r, r->ee_block);
-+      }
-+
-+      path->p_ext = l - 1;
-+      ext_debug(inode, "  -> %d:%d:%d ",
-+                      le32_to_cpu(path->p_ext->ee_block),
-+                      le32_to_cpu(path->p_ext->ee_start),
-+                      le16_to_cpu(path->p_ext->ee_len));
-+
-+#ifdef CHECK_BINSEARCH
-+      {
-+              struct ext3_extent *chex, *ex;
-+              int k;
-+
-+              chex = ex = EXT_FIRST_EXTENT(eh);
-+              for (k = 0; k < le16_to_cpu(eh->eh_entries); k++, ex++) {
-+                      BUG_ON(k && le32_to_cpu(ex->ee_block)
-+                                        <= le32_to_cpu(ex[-1].ee_block));
-+                      if (block < le32_to_cpu(ex->ee_block))
-+                              break;
-+                      chex = ex;
-+              }
-+              BUG_ON(chex != path->p_ext);
-+      }
-+#endif
-+
-+}
-+
-+int ext3_ext_tree_init(handle_t *handle, struct inode *inode)
-+{
-+      struct ext3_extent_header *eh;
-+
-+      eh = ext_inode_hdr(inode);
-+      eh->eh_depth = 0;
-+      eh->eh_entries = 0;
-+      eh->eh_magic = cpu_to_le16(EXT3_EXT_MAGIC);
-+      eh->eh_max = cpu_to_le16(ext3_ext_space_root(inode));
-+      ext3_mark_inode_dirty(handle, inode);
-+      ext3_ext_invalidate_cache(inode);
-+      return 0;
-+}
-+
-+struct ext3_ext_path *
-+ext3_ext_find_extent(struct inode *inode, int block, struct ext3_ext_path *path)
-+{
-+      struct ext3_extent_header *eh;
-+      struct buffer_head *bh;
-+      short int depth, i, ppos = 0, alloc = 0;
-+
-+      eh = ext_inode_hdr(inode);
-+      i = depth = ext_depth(inode);
-+      if (ext3_ext_check_header(inode, eh, depth))
-+              return ERR_PTR(-EIO);
-+
-+      /* account possible depth increase */
-+      if (!path) {
-+              path = kmalloc(sizeof(struct ext3_ext_path) * (depth + 2),
-+                              GFP_NOFS);
-+              if (!path)
-+                      return ERR_PTR(-ENOMEM);
-+              alloc = 1;
-+      }
-+      memset(path, 0, sizeof(struct ext3_ext_path) * (depth + 1));
-+      path[0].p_hdr = eh;
-+
-+      /* walk through the tree */
-+      while (i) {
-+              ext_debug(inode, "depth %d: num %d, max %d\n",
-+                        ppos, le16_to_cpu(eh->eh_entries), le16_to_cpu(eh->eh_max));
-+
-+              ext3_ext_binsearch_idx(inode, path + ppos, block);
-+              path[ppos].p_block = le32_to_cpu(path[ppos].p_idx->ei_leaf);
-+              path[ppos].p_depth = i;
-+              path[ppos].p_ext = NULL;
-+
-+              bh = sb_bread(inode->i_sb, path[ppos].p_block);
-+              if (!bh)
-+                      goto err;
-+
-+              eh = ext_block_hdr(bh);
-+              ppos++;
-+              BUG_ON(ppos > depth);
-+              path[ppos].p_bh = bh;
-+              path[ppos].p_hdr = eh;
-+              i--;
-+
-+              if (ext3_ext_check_header(inode, eh, i))
-+                      goto err;
-+      }
-+
-+      path[ppos].p_depth = i;
-+      path[ppos].p_hdr = eh;
-+      path[ppos].p_ext = NULL;
-+      path[ppos].p_idx = NULL;
-+
-+      /* find extent */
-+      ext3_ext_binsearch(inode, path + ppos, block);
-+
-+      ext3_ext_show_path(inode, path);
-+
-+      return path;
-+
-+err:
-+      ext3_ext_drop_refs(path);
-+      if (alloc)
-+              kfree(path);
-+      return ERR_PTR(-EIO);
-+}
-+
-+/*
-+ * insert new index [logical;ptr] into the block at cupr
-+ * it check where to insert: before curp or after curp
-+ */
-+static int ext3_ext_insert_index(handle_t *handle, struct inode *inode,
-+                              struct ext3_ext_path *curp,
-+                              int logical, int ptr)
-+{
-+      struct ext3_extent_idx *ix;
-+      int len, err;
-+
-+      if ((err = ext3_ext_get_access(handle, inode, curp)))
-+              return err;
-+
-+      BUG_ON(logical == le32_to_cpu(curp->p_idx->ei_block));
-+      len = EXT_MAX_INDEX(curp->p_hdr) - curp->p_idx;
-+      if (logical > le32_to_cpu(curp->p_idx->ei_block)) {
-+              /* insert after */
-+              if (curp->p_idx != EXT_LAST_INDEX(curp->p_hdr)) {
-+                      len = (len - 1) * sizeof(struct ext3_extent_idx);
-+                      len = len < 0 ? 0 : len;
-+                      ext_debug(inode, "insert new index %d after: %d. "
-+                                      "move %d from 0x%p to 0x%p\n",
-+                                      logical, ptr, len,
-+                                      (curp->p_idx + 1), (curp->p_idx + 2));
-+                      memmove(curp->p_idx + 2, curp->p_idx + 1, len);
-+              }
-+              ix = curp->p_idx + 1;
-+      } else {
-+              /* insert before */
-+              len = len * sizeof(struct ext3_extent_idx);
-+              len = len < 0 ? 0 : len;
-+              ext_debug(inode, "insert new index %d before: %d. "
-+                              "move %d from 0x%p to 0x%p\n",
-+                              logical, ptr, len,
-+                              curp->p_idx, (curp->p_idx + 1));
-+              memmove(curp->p_idx + 1, curp->p_idx, len);
-+              ix = curp->p_idx;
-+      }
-+
-+      ix->ei_block = cpu_to_le32(logical);
-+      ix->ei_leaf = cpu_to_le32(ptr);
-+      ix->ei_leaf_hi = ix->ei_unused = 0;
-+      curp->p_hdr->eh_entries = cpu_to_le16(le16_to_cpu(curp->p_hdr->eh_entries)+1);
-+
-+      BUG_ON(le16_to_cpu(curp->p_hdr->eh_entries)
-+                           > le16_to_cpu(curp->p_hdr->eh_max));
-+      BUG_ON(ix > EXT_LAST_INDEX(curp->p_hdr));
-+
-+      err = ext3_ext_dirty(handle, inode, curp);
-+      ext3_std_error(inode->i_sb, err);
-+
-+      return err;
-+}
-+
-+/*
-+ * routine inserts new subtree into the path, using free index entry
-+ * at depth 'at:
-+ *  - allocates all needed blocks (new leaf and all intermediate index blocks)
-+ *  - makes decision where to split
-+ *  - moves remaining extens and index entries (right to the split point)
-+ *    into the newly allocated blocks
-+ *  - initialize subtree
-+ */
-+static int ext3_ext_split(handle_t *handle, struct inode *inode,
-+                              struct ext3_ext_path *path,
-+                              struct ext3_extent *newext, int at)
-+{
-+      struct buffer_head *bh = NULL;
-+      int depth = ext_depth(inode);
-+      struct ext3_extent_header *neh;
-+      struct ext3_extent_idx *fidx;
-+      struct ext3_extent *ex;
-+      int i = at, k, m, a;
-+      unsigned long newblock, oldblock;
-+      __le32 border;
-+      int *ablocks = NULL; /* array of allocated blocks */
-+      int err = 0;
-+
-+      /* make decision: where to split? */
-+      /* FIXME: now desicion is simplest: at current extent */
-+
-+      /* if current leaf will be splitted, then we should use
-+       * border from split point */
-+      BUG_ON(path[depth].p_ext > EXT_MAX_EXTENT(path[depth].p_hdr));
-+      if (path[depth].p_ext != EXT_MAX_EXTENT(path[depth].p_hdr)) {
-+              border = path[depth].p_ext[1].ee_block;
-+              ext_debug(inode, "leaf will be splitted."
-+                              " next leaf starts at %d\n",
-+                                le32_to_cpu(border));
-+      } else {
-+              border = newext->ee_block;
-+              ext_debug(inode, "leaf will be added."
-+                              " next leaf starts at %d\n",
-+                              le32_to_cpu(border));
-+      }
-+
-+      /*
-+       * if error occurs, then we break processing
-+       * and turn filesystem read-only. so, index won't
-+       * be inserted and tree will be in consistent
-+       * state. next mount will repair buffers too
-+       */
-+
-+      /*
-+       * get array to track all allocated blocks
-+       * we need this to handle errors and free blocks
-+       * upon them
-+       */
-+      ablocks = kmalloc(sizeof(unsigned long) * depth, GFP_NOFS);
-+      if (!ablocks)
-+              return -ENOMEM;
-+      memset(ablocks, 0, sizeof(unsigned long) * depth);
-+
-+      /* allocate all needed blocks */
-+      ext_debug(inode, "allocate %d blocks for indexes/leaf\n", depth - at);
-+      for (a = 0; a < depth - at; a++) {
-+              newblock = ext3_ext_new_block(handle, inode, path, newext, &err);
-+              if (newblock == 0)
-+                      goto cleanup;
-+              ablocks[a] = newblock;
-+      }
-+
-+      /* initialize new leaf */
-+      newblock = ablocks[--a];
-+      BUG_ON(newblock == 0);
-+      bh = sb_getblk(inode->i_sb, newblock);
-+      if (!bh) {
-+              err = -EIO;
-+              goto cleanup;
-+      }
-+      lock_buffer(bh);
-+
-+      if ((err = ext3_journal_get_create_access(handle, bh)))
-+              goto cleanup;
-+
-+      neh = ext_block_hdr(bh);
-+      neh->eh_entries = 0;
-+      neh->eh_max = cpu_to_le16(ext3_ext_space_block(inode));
-+      neh->eh_magic = cpu_to_le16(EXT3_EXT_MAGIC);
-+      neh->eh_depth = 0;
-+      ex = EXT_FIRST_EXTENT(neh);
-+
-+      /* move remain of path[depth] to the new leaf */
-+      BUG_ON(path[depth].p_hdr->eh_entries != path[depth].p_hdr->eh_max);
-+      /* start copy from next extent */
-+      /* TODO: we could do it by single memmove */
-+      m = 0;
-+      path[depth].p_ext++;
-+      while (path[depth].p_ext <=
-+                      EXT_MAX_EXTENT(path[depth].p_hdr)) {
-+              ext_debug(inode, "move %d:%d:%d in new leaf %lu\n",
-+                              le32_to_cpu(path[depth].p_ext->ee_block),
-+                              le32_to_cpu(path[depth].p_ext->ee_start),
-+                              le16_to_cpu(path[depth].p_ext->ee_len),
-+                              newblock);
-+              /*memmove(ex++, path[depth].p_ext++,
-+                              sizeof(struct ext3_extent));
-+              neh->eh_entries++;*/
-+              path[depth].p_ext++;
-+              m++;
-+      }
-+      if (m) {
-+              memmove(ex, path[depth].p_ext-m, sizeof(struct ext3_extent)*m);
-+              neh->eh_entries = cpu_to_le16(le16_to_cpu(neh->eh_entries)+m);
-+      }
-+
-+      set_buffer_uptodate(bh);
-+      unlock_buffer(bh);
-+
-+      if ((err = ext3_journal_dirty_metadata(handle, bh)))
-+              goto cleanup;
-+      brelse(bh);
-+      bh = NULL;
-+
-+      /* correct old leaf */
-+      if (m) {
-+              if ((err = ext3_ext_get_access(handle, inode, path + depth)))
-+                      goto cleanup;
-+              path[depth].p_hdr->eh_entries =
-+                   cpu_to_le16(le16_to_cpu(path[depth].p_hdr->eh_entries)-m);
-+              if ((err = ext3_ext_dirty(handle, inode, path + depth)))
-+                      goto cleanup;
-+
-+      }
-+
-+      /* create intermediate indexes */
-+      k = depth - at - 1;
-+      BUG_ON(k < 0);
-+      if (k)
-+              ext_debug(inode, "create %d intermediate indices\n", k);
-+      /* insert new index into current index block */
-+      /* current depth stored in i var */
-+      i = depth - 1;
-+      while (k--) {
-+              oldblock = newblock;
-+              newblock = ablocks[--a];
-+              bh = sb_getblk(inode->i_sb, newblock);
-+              if (!bh) {
-+                      err = -EIO;
-+                      goto cleanup;
-+              }
-+              lock_buffer(bh);
-+
-+              if ((err = ext3_journal_get_create_access(handle, bh)))
-+                      goto cleanup;
-+
-+              neh = ext_block_hdr(bh);
-+              neh->eh_entries = cpu_to_le16(1);
-+              neh->eh_magic = cpu_to_le16(EXT3_EXT_MAGIC);
-+              neh->eh_max = cpu_to_le16(ext3_ext_space_block_idx(inode));
-+              neh->eh_depth = cpu_to_le16(depth - i);
-+              fidx = EXT_FIRST_INDEX(neh);
-+              fidx->ei_block = border;
-+              fidx->ei_leaf = cpu_to_le32(oldblock);
-+              fidx->ei_leaf_hi = fidx->ei_unused = 0;
-+
-+              ext_debug(inode, "int.index at %d (block %lu): %lu -> %lu\n", i,
-+                              newblock, (unsigned long) le32_to_cpu(border),
-+                              oldblock);
-+              /* copy indexes */
-+              m = 0;
-+              path[i].p_idx++;
-+
-+              ext_debug(inode, "cur 0x%p, last 0x%p\n", path[i].p_idx,
-+                              EXT_MAX_INDEX(path[i].p_hdr));
-+              BUG_ON(EXT_MAX_INDEX(path[i].p_hdr) !=
-+                              EXT_LAST_INDEX(path[i].p_hdr));
-+              while (path[i].p_idx <= EXT_MAX_INDEX(path[i].p_hdr)) {
-+                      ext_debug(inode, "%d: move %d:%d in new index %lu\n", i,
-+                                      le32_to_cpu(path[i].p_idx->ei_block),
-+                                      le32_to_cpu(path[i].p_idx->ei_leaf),
-+                                      newblock);
-+                      /*memmove(++fidx, path[i].p_idx++,
-+                                      sizeof(struct ext3_extent_idx));
-+                      neh->eh_entries++;
-+                      BUG_ON(neh->eh_entries > neh->eh_max);*/
-+                      path[i].p_idx++;
-+                      m++;
-+              }
-+              if (m) {
-+                      memmove(++fidx, path[i].p_idx - m,
-+                              sizeof(struct ext3_extent_idx) * m);
-+                      neh->eh_entries =
-+                              cpu_to_le16(le16_to_cpu(neh->eh_entries) + m);
-+              }
-+              set_buffer_uptodate(bh);
-+              unlock_buffer(bh);
-+
-+              if ((err = ext3_journal_dirty_metadata(handle, bh)))
-+                      goto cleanup;
-+              brelse(bh);
-+              bh = NULL;
-+
-+              /* correct old index */
-+              if (m) {
-+                      err = ext3_ext_get_access(handle, inode, path + i);
-+                      if (err)
-+                              goto cleanup;
-+                      path[i].p_hdr->eh_entries = cpu_to_le16(le16_to_cpu(path[i].p_hdr->eh_entries)-m);
-+                      err = ext3_ext_dirty(handle, inode, path + i);
-+                      if (err)
-+                              goto cleanup;
-+              }
-+
-+              i--;
-+      }
-+
-+      /* insert new index */
-+      if (err)
-+              goto cleanup;
-+
-+      err = ext3_ext_insert_index(handle, inode, path + at,
-+                                  le32_to_cpu(border), newblock);
-+
-+cleanup:
-+      if (bh) {
-+              if (buffer_locked(bh))
-+                      unlock_buffer(bh);
-+              brelse(bh);
-+      }
-+
-+      if (err) {
-+              /* free all allocated blocks in error case */
-+              for (i = 0; i < depth; i++) {
-+                      if (!ablocks[i])
-+                              continue;
-+                      ext3_free_blocks(handle, inode, ablocks[i], 1);
-+              }
-+      }
-+      kfree(ablocks);
-+
-+      return err;
-+}
-+
-+/*
-+ * routine implements tree growing procedure:
-+ *  - allocates new block
-+ *  - moves top-level data (index block or leaf) into the new block
-+ *  - initialize new top-level, creating index that points to the
-+ *    just created block
-+ */
-+static int ext3_ext_grow_indepth(handle_t *handle, struct inode *inode,
-+                                      struct ext3_ext_path *path,
-+                                      struct ext3_extent *newext)
-+{
-+      struct ext3_ext_path *curp = path;
-+      struct ext3_extent_header *neh;
-+      struct ext3_extent_idx *fidx;
-+      struct buffer_head *bh;
-+      unsigned long newblock;
-+      int err = 0;
-+
-+      newblock = ext3_ext_new_block(handle, inode, path, newext, &err);
-+      if (newblock == 0)
-+              return err;
-+
-+      bh = sb_getblk(inode->i_sb, newblock);
-+      if (!bh) {
-+              err = -EIO;
-+              ext3_std_error(inode->i_sb, err);
-+              return err;
-+      }
-+      lock_buffer(bh);
-+
-+      if ((err = ext3_journal_get_create_access(handle, bh))) {
-+              unlock_buffer(bh);
-+              goto out;
-+      }
-+
-+      /* move top-level index/leaf into new block */
-+      memmove(bh->b_data, curp->p_hdr, sizeof(EXT3_I(inode)->i_data));
-+
-+      /* set size of new block */
-+      neh = ext_block_hdr(bh);
-+      /* old root could have indexes or leaves
-+       * so calculate e_max right way */
-+      if (ext_depth(inode))
-+        neh->eh_max = cpu_to_le16(ext3_ext_space_block_idx(inode));
-+      else
-+        neh->eh_max = cpu_to_le16(ext3_ext_space_block(inode));
-+      neh->eh_magic = cpu_to_le16(EXT3_EXT_MAGIC);
-+      set_buffer_uptodate(bh);
-+      unlock_buffer(bh);
-+
-+      if ((err = ext3_journal_dirty_metadata(handle, bh)))
-+              goto out;
-+
-+      /* create index in new top-level index: num,max,pointer */
-+      if ((err = ext3_ext_get_access(handle, inode, curp)))
-+              goto out;
-+
-+      curp->p_hdr->eh_magic = cpu_to_le16(EXT3_EXT_MAGIC);
-+      curp->p_hdr->eh_max = cpu_to_le16(ext3_ext_space_root_idx(inode));
-+      curp->p_hdr->eh_entries = cpu_to_le16(1);
-+      curp->p_idx = EXT_FIRST_INDEX(curp->p_hdr);
-+      /* FIXME: it works, but actually path[0] can be index */
-+      curp->p_idx->ei_block = EXT_FIRST_EXTENT(path[0].p_hdr)->ee_block;
-+      curp->p_idx->ei_leaf = cpu_to_le32(newblock);
-+      curp->p_idx->ei_leaf_hi = curp->p_idx->ei_unused = 0;
-+
-+      neh = ext_inode_hdr(inode);
-+      fidx = EXT_FIRST_INDEX(neh);
-+      ext_debug(inode, "new root: num %d(%d), lblock %d, ptr %d\n",
-+                le16_to_cpu(neh->eh_entries), le16_to_cpu(neh->eh_max),
-+                le32_to_cpu(fidx->ei_block), le32_to_cpu(fidx->ei_leaf));
-+
-+      neh->eh_depth = cpu_to_le16(path->p_depth + 1);
-+      err = ext3_ext_dirty(handle, inode, curp);
-+out:
-+      brelse(bh);
-+
-+      return err;
-+}
-+
-+/*
-+ * routine finds empty index and adds new leaf. if no free index found
-+ * then it requests in-depth growing
-+ */
-+static int ext3_ext_create_new_leaf(handle_t *handle, struct inode *inode,
-+                                      struct ext3_ext_path *path,
-+                                      struct ext3_extent *newext)
-+{
-+      struct ext3_ext_path *curp;
-+      int depth, i, err = 0;
-+
-+repeat:
-+      i = depth = ext_depth(inode);
-+
-+      /* walk up to the tree and look for free index entry */
-+      curp = path + depth;
-+      while (i > 0 && !EXT_HAS_FREE_INDEX(curp)) {
-+              i--;
-+              curp--;
-+      }
-+
-+      /* we use already allocated block for index block
-+       * so, subsequent data blocks should be contigoues */
-+      if (EXT_HAS_FREE_INDEX(curp)) {
-+              /* if we found index with free entry, then use that
-+               * entry: create all needed subtree and add new leaf */
-+              err = ext3_ext_split(handle, inode, path, newext, i);
-+              if (err)
-+                      goto out;
-+
-+              /* refill path */
-+              ext3_ext_drop_refs(path);
-+              path = ext3_ext_find_extent(inode,
-+                                          le32_to_cpu(newext->ee_block),
-+                                          path);
-+              if (IS_ERR(path))
-+                      err = PTR_ERR(path);
-+      } else {
-+              /* tree is full, time to grow in depth */
-+              err = ext3_ext_grow_indepth(handle, inode, path, newext);
-+              if (err)
-+                      goto out;
-+
-+              /* refill path */
-+              ext3_ext_drop_refs(path);
-+              path = ext3_ext_find_extent(inode,
-+                                          le32_to_cpu(newext->ee_block),
-+                                          path);
-+              if (IS_ERR(path)) {
-+                      err = PTR_ERR(path);
-+                      goto out;
-+              }
-+
-+              /*
-+               * only first (depth 0 -> 1) produces free space
-+               * in all other cases we have to split growed tree
-+               */
-+              depth = ext_depth(inode);
-+              if (path[depth].p_hdr->eh_entries == path[depth].p_hdr->eh_max) {
-+                      /* now we need split */
-+                      goto repeat;
-+              }
-+      }
-+
-+out:
-+      return err;
-+}
-+
-+/*
-+ * search the closest allocated block to the left for *logical
-+ * and returns it at @logical + it's physical address at @phys
-+ * if *logical is the smallest allocated block, the function
-+ * returns 0 at @phys
-+ * return value contains 0 (success) or error code
-+ */
-+int
-+ext3_ext_search_left(struct inode *inode, struct ext3_ext_path *path,
-+                      unsigned long *logical, unsigned long *phys)
-+{
-+      struct ext3_extent_idx *ix;
-+      struct ext3_extent *ex;
-+      int depth;
-+
-+      BUG_ON(path == NULL);
-+      depth = path->p_depth;
-+      *phys = 0;
-+
-+      if (depth == 0 && path->p_ext == NULL)
-+              return 0;
-+
-+      /* usually extent in the path covers blocks smaller
-+       * then *logical, but it can be that extent is the
-+       * first one in the file */
-+
-+      ex = path[depth].p_ext;
-+      if (*logical < le32_to_cpu(ex->ee_block)) {
-+              BUG_ON(EXT_FIRST_EXTENT(path[depth].p_hdr) != ex);
-+              while (--depth >= 0) {
-+                      ix = path[depth].p_idx;
-+                      BUG_ON(ix != EXT_FIRST_INDEX(path[depth].p_hdr));
-+              }
-+              return 0;
-+      }
-+
-+      BUG_ON(*logical < le32_to_cpu(ex->ee_block) + le16_to_cpu(ex->ee_len));
-+
-+      *logical = le32_to_cpu(ex->ee_block) + le16_to_cpu(ex->ee_len) - 1;
-+      *phys = le32_to_cpu(ex->ee_start) + le16_to_cpu(ex->ee_len) - 1;
-+      return 0;
-+}
-+EXPORT_SYMBOL(ext3_ext_search_left);
-+
-+/*
-+ * search the closest allocated block to the right for *logical
-+ * and returns it at @logical + it's physical address at @phys
-+ * if *logical is the smallest allocated block, the function
-+ * returns 0 at @phys
-+ * return value contains 0 (success) or error code
-+ */
-+int
-+ext3_ext_search_right(struct inode *inode, struct ext3_ext_path *path,
-+                      unsigned long *logical, unsigned long *phys)
-+{
-+      struct buffer_head *bh = NULL;
-+      struct ext3_extent_header *eh;
-+      struct ext3_extent_idx *ix = NULL;
-+      struct ext3_extent *ex;
-+      unsigned long block;
-+      int depth;
-+
-+      BUG_ON(path == NULL);
-+      depth = path->p_depth;
-+      *phys = 0;
-+
-+      if (depth == 0 && path->p_ext == NULL)
-+              return 0;
-+
-+      /* usually extent in the path covers blocks smaller
-+       * then *logical, but it can be that extent is the
-+       * first one in the file */
-+
-+      ex = path[depth].p_ext;
-+      if (*logical < le32_to_cpu(ex->ee_block)) {
-+              BUG_ON(EXT_FIRST_EXTENT(path[depth].p_hdr) != ex);
-+              while (--depth >= 0) {
-+                      ix = path[depth].p_idx;
-+                      BUG_ON(ix != EXT_FIRST_INDEX(path[depth].p_hdr));
-+              }
-+              *logical = le32_to_cpu(ex->ee_block);
-+              *phys = le32_to_cpu(ex->ee_start);
-+              return 0;
-+      }
-+
-+      BUG_ON(*logical < le32_to_cpu(ex->ee_block) + le16_to_cpu(ex->ee_len));
-+
-+      if (ex != EXT_LAST_EXTENT(path[depth].p_hdr)) {
-+              /* next allocated block in this leaf */
-+              ex++;
-+              *logical = le32_to_cpu(ex->ee_block);
-+              *phys = le32_to_cpu(ex->ee_start);
-+              return 0;
-+      }
-+
-+      /* go up and search for index to the right */
-+      while (--depth >= 0) {
-+              ix = path[depth].p_idx;
-+              if (ix != EXT_LAST_INDEX(path[depth].p_hdr))
-+                      break;
-+      }
-+
-+      if (depth < 0) {
-+              /* we've gone up to the root and
-+               * found no index to the right */
-+              return 0;
-+      }
-+
-+      /* we've found index to the right, let's
-+       * follow it and find the closest allocated
-+       * block to the right */
-+      ix++;
-+      block = le32_to_cpu(ix->ei_leaf);
-+      while (++depth < path->p_depth) {
-+              bh = sb_bread(inode->i_sb, block);
-+              if (bh == NULL)
-+                      return -EIO;
-+              eh = ext_block_hdr(bh);
-+              if (ext3_ext_check_header(inode, eh, path->p_depth - depth)) {
-+                      brelse(bh);
-+                      return -EIO;
-+              }
-+              ix = EXT_FIRST_INDEX(eh);
-+              block = le32_to_cpu(ix->ei_leaf);
-+              brelse(bh);
-+      }
-+
-+      bh = sb_bread(inode->i_sb, block);
-+      if (bh == NULL)
-+              return -EIO;
-+      eh = ext_block_hdr(bh);
-+      if (ext3_ext_check_header(inode, eh, 0)) {
-+              brelse(bh);
-+              return -EIO;
-+      }
-+      ex = EXT_FIRST_EXTENT(eh);
-+      *logical = le32_to_cpu(ex->ee_block);
-+      *phys = le32_to_cpu(ex->ee_start);
-+      brelse(bh);
-+      return 0;
-+
-+}
-+EXPORT_SYMBOL(ext3_ext_search_right);
-+
-+
-+
-+/*
-+ * returns allocated block in subsequent extent or EXT_MAX_BLOCK
-+ * NOTE: it consider block number from index entry as
-+ * allocated block. thus, index entries have to be consistent
-+ * with leafs
-+ */
-+static unsigned long
-+ext3_ext_next_allocated_block(struct ext3_ext_path *path)
-+{
-+      int depth;
-+
-+      BUG_ON(path == NULL);
-+      depth = path->p_depth;
-+
-+      if (depth == 0 && path->p_ext == NULL)
-+              return EXT_MAX_BLOCK;
-+
-+      while (depth >= 0) {
-+              if (depth == path->p_depth) {
-+                      /* leaf */
-+                      if (path[depth].p_ext !=
-+                                      EXT_LAST_EXTENT(path[depth].p_hdr))
-+                        return le32_to_cpu(path[depth].p_ext[1].ee_block);
-+              } else {
-+                      /* index */
-+                      if (path[depth].p_idx !=
-+                                      EXT_LAST_INDEX(path[depth].p_hdr))
-+                        return le32_to_cpu(path[depth].p_idx[1].ei_block);
-+              }
-+              depth--;
-+      }
-+
-+      return EXT_MAX_BLOCK;
-+}
-+
-+/*
-+ * returns first allocated block from next leaf or EXT_UNSET_BLOCK
-+ */
-+static unsigned ext3_ext_next_leaf_block(struct inode *inode,
-+                                       struct ext3_ext_path *path)
-+{
-+      int depth;
-+
-+      BUG_ON(path == NULL);
-+      depth = path->p_depth;
-+
-+      /* zero-tree has no leaf blocks at all */
-+      if (depth == 0)
-+              return EXT_UNSET_BLOCK;
-+
-+      /* go to index block */
-+      depth--;
-+
-+      while (depth >= 0) {
-+              if (path[depth].p_idx !=
-+                              EXT_LAST_INDEX(path[depth].p_hdr))
-+                return le32_to_cpu(path[depth].p_idx[1].ei_block);
-+              depth--;
-+      }
-+
-+      return EXT_UNSET_BLOCK;
-+}
-+
-+/*
-+ * if leaf gets modified and modified extent is first in the leaf
-+ * then we have to correct all indexes above
-+ * TODO: do we need to correct tree in all cases?
-+ */
-+int ext3_ext_correct_indexes(handle_t *handle, struct inode *inode,
-+                              struct ext3_ext_path *path)
-+{
-+      struct ext3_extent_header *eh;
-+      int depth = ext_depth(inode);
-+      struct ext3_extent *ex;
-+      __le32 border;
-+      int k, err = 0;
-+
-+      eh = path[depth].p_hdr;
-+      ex = path[depth].p_ext;
-+      BUG_ON(ex == NULL);
-+      BUG_ON(eh == NULL);
-+
-+      if (depth == 0) {
-+              /* there is no tree at all */
-+              return 0;
-+      }
-+
-+      if (ex != EXT_FIRST_EXTENT(eh)) {
-+              /* we correct tree if first leaf got modified only */
-+              return 0;
-+      }
-+
-+      /*
-+       * TODO: we need correction if border is smaller then current one
-+       */
-+      k = depth - 1;
-+      border = path[depth].p_ext->ee_block;
-+      if ((err = ext3_ext_get_access(handle, inode, path + k)))
-+              return err;
-+      path[k].p_idx->ei_block = border;
-+      if ((err = ext3_ext_dirty(handle, inode, path + k)))
-+              return err;
-+
-+      while (k--) {
-+              /* change all left-side indexes */
-+              if (path[k+1].p_idx != EXT_FIRST_INDEX(path[k+1].p_hdr))
-+                      break;
-+              if ((err = ext3_ext_get_access(handle, inode, path + k)))
-+                      break;
-+              path[k].p_idx->ei_block = border;
-+              if ((err = ext3_ext_dirty(handle, inode, path + k)))
-+                      break;
-+      }
-+
-+      return err;
-+}
-+
-+static int inline
-+ext3_can_extents_be_merged(struct inode *inode, struct ext3_extent *ex1,
-+                              struct ext3_extent *ex2)
-+{
-+      /* FIXME: 48bit support */
-+      if (le32_to_cpu(ex1->ee_block) + le16_to_cpu(ex1->ee_len) !=
-+          le32_to_cpu(ex2->ee_block))
-+              return 0;
-+
-+#ifdef AGRESSIVE_TEST
-+      if (le16_to_cpu(ex1->ee_len) >= 4)
-+              return 0;
-+#endif
-+
-+      if (le32_to_cpu(ex1->ee_start) + le16_to_cpu(ex1->ee_len) ==
-+          le32_to_cpu(ex2->ee_start))
-+              return 1;
-+      return 0;
-+}
-+
-+/*
-+ * this routine tries to merge requsted extent into the existing
-+ * extent or inserts requested extent as new one into the tree,
-+ * creating new leaf in no-space case
-+ */
-+int ext3_ext_insert_extent(handle_t *handle, struct inode *inode,
-+                              struct ext3_ext_path *path,
-+                              struct ext3_extent *newext)
-+{
-+      struct ext3_extent_header * eh;
-+      struct ext3_extent *ex, *fex;
-+      struct ext3_extent *nearex; /* nearest extent */
-+      struct ext3_ext_path *npath = NULL;
-+      int depth, len, err, next;
-+
-+      BUG_ON(newext->ee_len == 0);
-+      depth = ext_depth(inode);
-+      ex = path[depth].p_ext;
-+      BUG_ON(path[depth].p_hdr == NULL);
-+
-+      /* try to insert block into found extent and return */
-+      if (ex && ext3_can_extents_be_merged(inode, ex, newext)) {
-+              ext_debug(inode, "append %d block to %d:%d (from %d)\n",
-+                              le16_to_cpu(newext->ee_len),
-+                              le32_to_cpu(ex->ee_block),
-+                              le16_to_cpu(ex->ee_len),
-+                              le32_to_cpu(ex->ee_start));
-+              if ((err = ext3_ext_get_access(handle, inode, path + depth)))
-+                      return err;
-+              ex->ee_len = cpu_to_le16(le16_to_cpu(ex->ee_len)
-+                                       + le16_to_cpu(newext->ee_len));
-+              eh = path[depth].p_hdr;
-+              nearex = ex;
-+              goto merge;
-+      }
-+
-+repeat:
-+      depth = ext_depth(inode);
-+      eh = path[depth].p_hdr;
-+      if (le16_to_cpu(eh->eh_entries) < le16_to_cpu(eh->eh_max))
-+              goto has_space;
-+
-+      /* probably next leaf has space for us? */
-+      fex = EXT_LAST_EXTENT(eh);
-+      next = ext3_ext_next_leaf_block(inode, path);
-+      if (le32_to_cpu(newext->ee_block) > le32_to_cpu(fex->ee_block)
-+          && next != EXT_UNSET_BLOCK) {
-+              ext_debug(inode, "next leaf block - %d\n", next);
-+              BUG_ON(npath != NULL);
-+              npath = ext3_ext_find_extent(inode, next, NULL);
-+              if (IS_ERR(npath))
-+                      return PTR_ERR(npath);
-+              BUG_ON(npath->p_depth != path->p_depth);
-+              eh = npath[depth].p_hdr;
-+              if (le16_to_cpu(eh->eh_entries) < le16_to_cpu(eh->eh_max)) {
-+                      ext_debug(inode, "next leaf isnt full(%d)\n",
-+                                le16_to_cpu(eh->eh_entries));
-+                      path = npath;
-+                      goto repeat;
-+              }
-+              ext_debug(inode, "next leaf has no free space(%d,%d)\n",
-+                        le16_to_cpu(eh->eh_entries), le16_to_cpu(eh->eh_max));
-+      }
-+
-+      /*
-+       * there is no free space in found leaf
-+       * we're gonna add new leaf in the tree
-+       */
-+      err = ext3_ext_create_new_leaf(handle, inode, path, newext);
-+      if (err)
-+              goto cleanup;
-+      depth = ext_depth(inode);
-+      eh = path[depth].p_hdr;
-+
-+has_space:
-+      nearex = path[depth].p_ext;
-+
-+      if ((err = ext3_ext_get_access(handle, inode, path + depth)))
-+              goto cleanup;
-+
-+      if (!nearex) {
-+              /* there is no extent in this leaf, create first one */
-+              ext_debug(inode, "first extent in the leaf: %d:%d:%d\n",
-+                              le32_to_cpu(newext->ee_block),
-+                              le32_to_cpu(newext->ee_start),
-+                              le16_to_cpu(newext->ee_len));
-+              path[depth].p_ext = EXT_FIRST_EXTENT(eh);
-+      } else if (le32_to_cpu(newext->ee_block)
-+                         > le32_to_cpu(nearex->ee_block)) {
-+              /* BUG_ON(newext->ee_block == nearex->ee_block); */
-+              if (nearex != EXT_LAST_EXTENT(eh)) {
-+                      len = EXT_MAX_EXTENT(eh) - nearex;
-+                      len = (len - 1) * sizeof(struct ext3_extent);
-+                      len = len < 0 ? 0 : len;
-+                      ext_debug(inode, "insert %d:%d:%d after: nearest 0x%p, "
-+                                      "move %d from 0x%p to 0x%p\n",
-+                                      le32_to_cpu(newext->ee_block),
-+                                      le32_to_cpu(newext->ee_start),
-+                                      le16_to_cpu(newext->ee_len),
-+                                      nearex, len, nearex + 1, nearex + 2);
-+                      memmove(nearex + 2, nearex + 1, len);
-+              }
-+              path[depth].p_ext = nearex + 1;
-+      } else {
-+              BUG_ON(newext->ee_block == nearex->ee_block);
-+              len = (EXT_MAX_EXTENT(eh) - nearex) * sizeof(struct ext3_extent);
-+              len = len < 0 ? 0 : len;
-+              ext_debug(inode, "insert %d:%d:%d before: nearest 0x%p, "
-+                              "move %d from 0x%p to 0x%p\n",
-+                              le32_to_cpu(newext->ee_block),
-+                              le32_to_cpu(newext->ee_start),
-+                              le16_to_cpu(newext->ee_len),
-+                              nearex, len, nearex + 1, nearex + 2);
-+              memmove(nearex + 1, nearex, len);
-+              path[depth].p_ext = nearex;
-+      }
-+
-+      eh->eh_entries = cpu_to_le16(le16_to_cpu(eh->eh_entries)+1);
-+      nearex = path[depth].p_ext;
-+      nearex->ee_block = newext->ee_block;
-+      nearex->ee_start = newext->ee_start;
-+      nearex->ee_len = newext->ee_len;
-+      /* FIXME: support for large fs */
-+      nearex->ee_start_hi = 0;
-+
-+merge:
-+      /* try to merge extents to the right */
-+      while (nearex < EXT_LAST_EXTENT(eh)) {
-+              if (!ext3_can_extents_be_merged(inode, nearex, nearex + 1))
-+                      break;
-+              /* merge with next extent! */
-+              nearex->ee_len = cpu_to_le16(le16_to_cpu(nearex->ee_len)
-+                                           + le16_to_cpu(nearex[1].ee_len));
-+              if (nearex + 1 < EXT_LAST_EXTENT(eh)) {
-+                      len = (EXT_LAST_EXTENT(eh) - nearex - 1)
-+                                      * sizeof(struct ext3_extent);
-+                      memmove(nearex + 1, nearex + 2, len);
-+              }
-+              eh->eh_entries = cpu_to_le16(le16_to_cpu(eh->eh_entries)-1);
-+              BUG_ON(eh->eh_entries == 0);
-+      }
-+
-+      /* try to merge extents to the left */
-+
-+      /* time to correct all indexes above */
-+      err = ext3_ext_correct_indexes(handle, inode, path);
-+      if (err)
-+              goto cleanup;
-+
-+      err = ext3_ext_dirty(handle, inode, path + depth);
-+
-+cleanup:
-+      if (npath) {
-+              ext3_ext_drop_refs(npath);
-+              kfree(npath);
-+      }
-+      ext3_ext_tree_changed(inode);
-+      ext3_ext_invalidate_cache(inode);
-+      return err;
-+}
-+
-+int ext3_ext_walk_space(struct inode *inode, unsigned long block,
-+                      unsigned long num, ext_prepare_callback func,
-+                      void *cbdata)
-+{
-+      struct ext3_ext_path *path = NULL;
-+      struct ext3_ext_cache cbex;
-+      struct ext3_extent *ex;
-+      unsigned long next, start = 0, end = 0;
-+      unsigned long last = block + num;
-+      int depth, exists, err = 0;
-+
-+      BUG_ON(func == NULL);
-+      BUG_ON(inode == NULL);
-+
-+      while (block < last && block != EXT_MAX_BLOCK) {
-+              num = last - block;
-+              /* find extent for this block */
-+              path = ext3_ext_find_extent(inode, block, path);
-+              if (IS_ERR(path)) {
-+                      err = PTR_ERR(path);
-+                      path = NULL;
-+                      break;
-+              }
-+
-+              depth = ext_depth(inode);
-+              BUG_ON(path[depth].p_hdr == NULL);
-+              ex = path[depth].p_ext;
-+              next = ext3_ext_next_allocated_block(path);
-+
-+              exists = 0;
-+              if (!ex) {
-+                      /* there is no extent yet, so try to allocate
-+                       * all requested space */
-+                      start = block;
-+                      end = block + num;
-+              } else if (le32_to_cpu(ex->ee_block) > block) {
-+                      /* need to allocate space before found extent */
-+                      start = block;
-+                      end = le32_to_cpu(ex->ee_block);
-+                      if (block + num < end)
-+                              end = block + num;
-+              } else if (block >=
-+                           le32_to_cpu(ex->ee_block) + le16_to_cpu(ex->ee_len)) {
-+                      /* need to allocate space after found extent */
-+                      start = block;
-+                      end = block + num;
-+                      if (end >= next)
-+                              end = next;
-+              } else if (block >= le32_to_cpu(ex->ee_block)) {
-+                      /*
-+                       * some part of requested space is covered
-+                       * by found extent
-+                       */
-+                      start = block;
-+                      end = le32_to_cpu(ex->ee_block) + le16_to_cpu(ex->ee_len);
-+                      if (block + num < end)
-+                              end = block + num;
-+                      exists = 1;
-+              } else {
-+                      BUG();
-+              }
-+              BUG_ON(end <= start);
-+
-+              if (!exists) {
-+                      cbex.ec_block = start;
-+                      cbex.ec_len = end - start;
-+                      cbex.ec_start = 0;
-+                      cbex.ec_type = EXT3_EXT_CACHE_GAP;
-+              } else {
-+                      cbex.ec_block = le32_to_cpu(ex->ee_block);
-+                      cbex.ec_len = le16_to_cpu(ex->ee_len);
-+                      cbex.ec_start = le32_to_cpu(ex->ee_start);
-+                      cbex.ec_type = EXT3_EXT_CACHE_EXTENT;
-+              }
-+
-+              BUG_ON(cbex.ec_len == 0);
-+              err = func(inode, path, &cbex, cbdata);
-+              ext3_ext_drop_refs(path);
-+
-+              if (err < 0)
-+                      break;
-+              if (err == EXT_REPEAT)
-+                      continue;
-+              else if (err == EXT_BREAK) {
-+                      err = 0;
-+                      break;
-+              }
-+
-+              if (ext_depth(inode) != depth) {
-+                      /* depth was changed. we have to realloc path */
-+                      kfree(path);
-+                      path = NULL;
-+              }
-+
-+              block = cbex.ec_block + cbex.ec_len;
-+      }
-+
-+      if (path) {
-+              ext3_ext_drop_refs(path);
-+              kfree(path);
-+      }
-+
-+      return err;
-+}
-+
-+static inline void
-+ext3_ext_put_in_cache(struct inode *inode, __u32 block,
-+                      __u32 len, __u32 start, int type)
-+{
-+      struct ext3_ext_cache *cex;
-+      BUG_ON(len == 0);
-+      cex = &EXT3_I(inode)->i_cached_extent;
-+      cex->ec_type = type;
-+      cex->ec_block = block;
-+      cex->ec_len = len;
-+      cex->ec_start = start;
-+}
-+
-+/*
-+ * this routine calculate boundaries of the gap requested block fits into
-+ * and cache this gap
-+ */
-+static inline void
-+ext3_ext_put_gap_in_cache(struct inode *inode, struct ext3_ext_path *path,
-+                              unsigned long block)
-+{
-+      int depth = ext_depth(inode);
-+      unsigned long lblock, len;
-+      struct ext3_extent *ex;
-+
-+      ex = path[depth].p_ext;
-+      if (ex == NULL) {
-+              /* there is no extent yet, so gap is [0;-] */
-+              lblock = 0;
-+              len = EXT_MAX_BLOCK;
-+              ext_debug(inode, "cache gap(whole file):");
-+      } else if (block < le32_to_cpu(ex->ee_block)) {
-+              lblock = block;
-+              len = le32_to_cpu(ex->ee_block) - block;
-+              ext_debug(inode, "cache gap(before): %lu [%lu:%lu]",
-+                              (unsigned long) block,
-+                              (unsigned long) le32_to_cpu(ex->ee_block),
-+                              (unsigned long) le16_to_cpu(ex->ee_len));
-+      } else if (block >= le32_to_cpu(ex->ee_block)
-+                          + le16_to_cpu(ex->ee_len)) {
-+              lblock = le32_to_cpu(ex->ee_block)
-+                       + le16_to_cpu(ex->ee_len);
-+              len = ext3_ext_next_allocated_block(path);
-+              ext_debug(inode, "cache gap(after): [%lu:%lu] %lu",
-+                              (unsigned long) le32_to_cpu(ex->ee_block),
-+                              (unsigned long) le16_to_cpu(ex->ee_len),
-+                              (unsigned long) block);
-+              BUG_ON(len == lblock);
-+              len = len - lblock;
-+      } else {
-+              lblock = len = 0;
-+              BUG();
-+      }
-+
-+      ext_debug(inode, " -> %lu:%lu\n", (unsigned long) lblock, len);
-+      ext3_ext_put_in_cache(inode, lblock, len, 0, EXT3_EXT_CACHE_GAP);
-+}
-+
-+static inline int
-+ext3_ext_in_cache(struct inode *inode, unsigned long block,
-+                      struct ext3_extent *ex)
-+{
-+      struct ext3_ext_cache *cex;
-+
-+      cex = &EXT3_I(inode)->i_cached_extent;
-+
-+      /* has cache valid data? */
-+      if (cex->ec_type == EXT3_EXT_CACHE_NO)
-+              return EXT3_EXT_CACHE_NO;
-+
-+      BUG_ON(cex->ec_type != EXT3_EXT_CACHE_GAP &&
-+                      cex->ec_type != EXT3_EXT_CACHE_EXTENT);
-+      if (block >= cex->ec_block && block < cex->ec_block + cex->ec_len) {
-+              ex->ee_block = cpu_to_le32(cex->ec_block);
-+              ex->ee_start = cpu_to_le32(cex->ec_start);
-+              ex->ee_start_hi = 0;
-+              ex->ee_len = cpu_to_le16(cex->ec_len);
-+              ext_debug(inode, "%lu cached by %lu:%lu:%lu\n",
-+                              (unsigned long) block,
-+                              (unsigned long) cex->ec_block,
-+                              (unsigned long) cex->ec_len,
-+                              (unsigned long) cex->ec_start);
-+              return cex->ec_type;
-+      }
-+
-+      /* not in cache */
-+      return EXT3_EXT_CACHE_NO;
-+}
-+
-+/*
-+ * routine removes index from the index block
-+ * it's used in truncate case only. thus all requests are for
-+ * last index in the block only
-+ */
-+int ext3_ext_rm_idx(handle_t *handle, struct inode *inode,
-+                      struct ext3_ext_path *path)
-+{
-+      struct buffer_head *bh;
-+      int err;
-+      unsigned long leaf;
-+
-+      /* free index block */
-+      path--;
-+      leaf = le32_to_cpu(path->p_idx->ei_leaf);
-+      BUG_ON(path->p_hdr->eh_entries == 0);
-+      if ((err = ext3_ext_get_access(handle, inode, path)))
-+              return err;
-+      path->p_hdr->eh_entries = cpu_to_le16(le16_to_cpu(path->p_hdr->eh_entries)-1);
-+      if ((err = ext3_ext_dirty(handle, inode, path)))
-+              return err;
-+      ext_debug(inode, "index is empty, remove it, free block %lu\n", leaf);
-+      bh = sb_find_get_block(inode->i_sb, leaf);
-+      ext3_forget(handle, 1, inode, bh, leaf);
-+      ext3_free_blocks(handle, inode, leaf, 1);
-+      return err;
-+}
-+
-+/*
-+ * This routine returns max. credits extent tree can consume.
-+ * It should be OK for low-performance paths like ->writepage()
-+ * To allow many writing process to fit a single transaction,
-+ * caller should calculate credits under truncate_mutex and
-+ * pass actual path.
-+ */
-+int inline ext3_ext_calc_credits_for_insert(struct inode *inode,
-+                                              struct ext3_ext_path *path)
-+{
-+      int depth, needed;
-+
-+      if (path) {
-+              /* probably there is space in leaf? */
-+              depth = ext_depth(inode);
-+              if (le16_to_cpu(path[depth].p_hdr->eh_entries)
-+                              < le16_to_cpu(path[depth].p_hdr->eh_max))
-+                      return 1;
-+      }
-+
-+      /*
-+       * given 32bit logical block (4294967296 blocks), max. tree
-+       * can be 4 levels in depth -- 4 * 340^4 == 53453440000.
-+       * let's also add one more level for imbalance.
-+       */
-+      depth = 5;
-+
-+      /* allocation of new data block(s) */
-+      needed = 2;
-+
-+      /*
-+       * tree can be full, so it'd need to grow in depth:
-+       * we need one credit to modify old root, credits for
-+       * new root will be added in split accounting
-+       */
-+      needed += 1;
-+
-+      /*
-+       * Index split can happen, we'd need:
-+       *    allocate intermediate indexes (bitmap + group)
-+       *  + change two blocks at each level, but root (already included)
-+       */
-+      needed += (depth * 2) + (depth * 2);
-+
-+      /* any allocation modifies superblock */
-+      needed += 1;
-+
-+      return needed;
-+}
-+
-+static int ext3_remove_blocks(handle_t *handle, struct inode *inode,
-+                              struct ext3_extent *ex,
-+                              unsigned long from, unsigned long to)
-+{
-+      struct buffer_head *bh;
-+      int i;
-+
-+#ifdef EXTENTS_STATS
-+      {
-+              struct ext3_sb_info *sbi = EXT3_SB(inode->i_sb);
-+              unsigned short ee_len =  le16_to_cpu(ex->ee_len);
-+              spin_lock(&sbi->s_ext_stats_lock);
-+              sbi->s_ext_blocks += ee_len;
-+              sbi->s_ext_extents++;
-+              if (ee_len < sbi->s_ext_min)
-+                      sbi->s_ext_min = ee_len;
-+              if (ee_len > sbi->s_ext_max)
-+                      sbi->s_ext_max = ee_len;
-+              if (ext_depth(inode) > sbi->s_depth_max)
-+                      sbi->s_depth_max = ext_depth(inode);
-+              spin_unlock(&sbi->s_ext_stats_lock);
-+      }
-+#endif
-+      if (from >= le32_to_cpu(ex->ee_block)
-+          && to == le32_to_cpu(ex->ee_block) + le16_to_cpu(ex->ee_len) - 1) {
-+              /* tail removal */
-+              unsigned long num, start;
-+              num = le32_to_cpu(ex->ee_block) + le16_to_cpu(ex->ee_len) - from;
-+              start = le32_to_cpu(ex->ee_start) + le16_to_cpu(ex->ee_len) - num;
-+              ext_debug(inode, "free last %lu blocks starting %lu\n", num, start);
-+              for (i = 0; i < num; i++) {
-+                      bh = sb_find_get_block(inode->i_sb, start + i);
-+                      ext3_forget(handle, 0, inode, bh, start + i);
-+              }
-+              ext3_free_blocks(handle, inode, start, num);
-+      } else if (from == le32_to_cpu(ex->ee_block)
-+                 && to <= le32_to_cpu(ex->ee_block) + le16_to_cpu(ex->ee_len) - 1) {
-+              printk("strange request: removal %lu-%lu from %u:%u\n",
-+                     from, to, le32_to_cpu(ex->ee_block), le16_to_cpu(ex->ee_len));
-+      } else {
-+              printk("strange request: removal(2) %lu-%lu from %u:%u\n",
-+                     from, to, le32_to_cpu(ex->ee_block), le16_to_cpu(ex->ee_len));
-+      }
-+      return 0;
-+}
-+
-+static int
-+ext3_ext_rm_leaf(handle_t *handle, struct inode *inode,
-+              struct ext3_ext_path *path, unsigned long start)
-+{
-+      int err = 0, correct_index = 0;
-+      int depth = ext_depth(inode), credits;
-+      struct ext3_extent_header *eh;
-+      unsigned a, b, block, num;
-+      unsigned long ex_ee_block;
-+      unsigned short ex_ee_len;
-+      struct ext3_extent *ex;
-+
-+      /* the header must be checked already in ext3_ext_remove_space() */
-+      ext_debug(inode, "truncate since %lu in leaf\n", start);
-+      if (!path[depth].p_hdr)
-+              path[depth].p_hdr = ext_block_hdr(path[depth].p_bh);
-+      eh = path[depth].p_hdr;
-+      BUG_ON(eh == NULL);
-+
-+      /* find where to start removing */
-+      ex = EXT_LAST_EXTENT(eh);
-+
-+      ex_ee_block = le32_to_cpu(ex->ee_block);
-+      ex_ee_len = le16_to_cpu(ex->ee_len);
-+
-+      while (ex >= EXT_FIRST_EXTENT(eh) &&
-+                      ex_ee_block + ex_ee_len > start) {
-+              ext_debug(inode, "remove ext %lu:%u\n", ex_ee_block, ex_ee_len);
-+              path[depth].p_ext = ex;
-+
-+              a = ex_ee_block > start ? ex_ee_block : start;
-+              b = (unsigned long long)ex_ee_block + ex_ee_len - 1 < 
-+                   EXT_MAX_BLOCK ? ex_ee_block + ex_ee_len - 1 : EXT_MAX_BLOCK;
-+
-+              ext_debug(inode, "  border %u:%u\n", a, b);
-+
-+              if (a != ex_ee_block && b != ex_ee_block + ex_ee_len - 1) {
-+                      block = 0;
-+                      num = 0;
-+                      BUG();
-+              } else if (a != ex_ee_block) {
-+                      /* remove tail of the extent */
-+                      block = ex_ee_block;
-+                      num = a - block;
-+              } else if (b != ex_ee_block + ex_ee_len - 1) {
-+                      /* remove head of the extent */
-+                      block = a;
-+                      num = b - a;
-+                      /* there is no "make a hole" API yet */
-+                      BUG();
-+              } else {
-+                      /* remove whole extent: excellent! */
-+                      block = ex_ee_block;
-+                      num = 0;
-+                      BUG_ON(a != ex_ee_block);
-+                      BUG_ON(b != ex_ee_block + ex_ee_len - 1);
-+              }
-+
-+              /* at present, extent can't cross block group */
-+              /* leaf + bitmap + group desc + sb + inode */
-+              credits = 5;
-+              if (ex == EXT_FIRST_EXTENT(eh)) {
-+                      correct_index = 1;
-+                      credits += (ext_depth(inode)) + 1;
-+              }
-+#ifdef CONFIG_QUOTA
-+              credits += 2 * EXT3_QUOTA_TRANS_BLOCKS(inode->i_sb);
-+#endif
-+
-+              handle = ext3_ext_journal_restart(handle, credits);
-+              if (IS_ERR(handle)) {
-+                      err = PTR_ERR(handle);
-+                      goto out;
-+              }
-+
-+              err = ext3_ext_get_access(handle, inode, path + depth);
-+              if (err)
-+                      goto out;
-+
-+              err = ext3_remove_blocks(handle, inode, ex, a, b);
-+              if (err)
-+                      goto out;
-+
-+              if (num == 0) {
-+                      /* this extent is removed entirely mark slot unused */
-+                      ex->ee_start = ex->ee_start_hi = 0;
-+                      eh->eh_entries = cpu_to_le16(le16_to_cpu(eh->eh_entries)-1);
-+              }
-+
-+              ex->ee_block = cpu_to_le32(block);
-+              ex->ee_len = cpu_to_le16(num);
-+
-+              err = ext3_ext_dirty(handle, inode, path + depth);
-+              if (err)
-+                      goto out;
-+
-+              ext_debug(inode, "new extent: %u:%u:%u\n", block, num,
-+                              le32_to_cpu(ex->ee_start));
-+              ex--;
-+              ex_ee_block = le32_to_cpu(ex->ee_block);
-+              ex_ee_len = le16_to_cpu(ex->ee_len);
-+      }
-+
-+      if (correct_index && eh->eh_entries)
-+              err = ext3_ext_correct_indexes(handle, inode, path);
-+
-+      /* if this leaf is free, then we should
-+       * remove it from index block above */
-+      if (err == 0 && eh->eh_entries == 0 && path[depth].p_bh != NULL)
-+              err = ext3_ext_rm_idx(handle, inode, path + depth);
-+
-+out:
-+      return err;
-+}
-+
-+/*
-+ * returns 1 if current index have to be freed (even partial)
-+ */
-+static int inline
-+ext3_ext_more_to_rm(struct ext3_ext_path *path)
-+{
-+      BUG_ON(path->p_idx == NULL);
-+
-+      if (path->p_idx < EXT_FIRST_INDEX(path->p_hdr))
-+              return 0;
-+
-+      /*
-+       * if truncate on deeper level happened it it wasn't partial
-+       * so we have to consider current index for truncation
-+       */
-+      if (le16_to_cpu(path->p_hdr->eh_entries) == path->p_block)
-+              return 0;
-+      return 1;
-+}
-+
-+int ext3_ext_remove_space(struct inode *inode, unsigned long start)
-+{
-+      struct super_block *sb = inode->i_sb;
-+      int depth = ext_depth(inode);
-+      struct ext3_ext_path *path;
-+      handle_t *handle;
-+      int i = 0, err = 0;
-+
-+      ext_debug(inode, "truncate since %lu\n", start);
-+
-+      /* probably first extent we're gonna free will be last in block */
-+      handle = ext3_journal_start(inode, depth + 1);
-+      if (IS_ERR(handle))
-+              return PTR_ERR(handle);
-+
-+      ext3_ext_invalidate_cache(inode);
-+
-+      /*
-+       * we start scanning from right side freeing all the blocks
-+       * after i_size and walking into the deep
-+       */
-+      path = kmalloc(sizeof(struct ext3_ext_path) * (depth + 1), GFP_KERNEL);
-+      if (path == NULL) {
-+              ext3_journal_stop(handle);
-+              return -ENOMEM;
-+      }
-+      memset(path, 0, sizeof(struct ext3_ext_path) * (depth + 1));
-+      path[0].p_hdr = ext_inode_hdr(inode);
-+      if (ext3_ext_check_header(inode, path[0].p_hdr, depth)) {
-+              err = -EIO;
-+              goto out;
-+      }
-+      path[0].p_depth = depth;
-+
-+      while (i >= 0 && err == 0) {
-+              if (i == depth) {
-+                      /* this is leaf block */
-+                      err = ext3_ext_rm_leaf(handle, inode, path, start);
-+                      /* root level have p_bh == NULL, brelse() eats this */
-+                      brelse(path[i].p_bh);
-+                      path[i].p_bh = NULL;
-+                      i--;
-+                      continue;
-+              }
-+
-+              /* this is index block */
-+              if (!path[i].p_hdr) {
-+                      ext_debug(inode, "initialize header\n");
-+                      path[i].p_hdr = ext_block_hdr(path[i].p_bh);
-+              }
-+
-+              if (!path[i].p_idx) {
-+                      /* this level hasn't touched yet */
-+                      path[i].p_idx = EXT_LAST_INDEX(path[i].p_hdr);
-+                      path[i].p_block = le16_to_cpu(path[i].p_hdr->eh_entries)+1;
-+                      ext_debug(inode, "init index ptr: hdr 0x%p, num %d\n",
-+                                path[i].p_hdr,
-+                                le16_to_cpu(path[i].p_hdr->eh_entries));
-+              } else {
-+                      /* we've already was here, see at next index */
-+                      path[i].p_idx--;
-+              }
-+
-+              ext_debug(inode, "level %d - index, first 0x%p, cur 0x%p\n",
-+                              i, EXT_FIRST_INDEX(path[i].p_hdr),
-+                              path[i].p_idx);
-+              if (ext3_ext_more_to_rm(path + i)) {
-+                      struct buffer_head *bh;
-+                      /* go to the next level */
-+                      ext_debug(inode, "move to level %d (block %d)\n",
-+                                i + 1, le32_to_cpu(path[i].p_idx->ei_leaf));
-+                      memset(path + i + 1, 0, sizeof(*path));
-+                      bh = sb_bread(sb, le32_to_cpu(path[i].p_idx->ei_leaf));
-+                      if (!bh) {
-+                              /* should we reset i_size? */
-+                              err = -EIO;
-+                              break;
-+                      }
-+                      BUG_ON(i + 1 > depth);
-+                      if (ext3_ext_check_header(inode, ext_block_hdr(bh),
-+                                                      depth - i - 1)) {
-+                              err = -EIO;
-+                              break;
-+                      }
-+                      path[i+1].p_bh = bh;
-+
-+                      /* put actual number of indexes to know is this
-+                       * number got changed at the next iteration */
-+                      path[i].p_block = le16_to_cpu(path[i].p_hdr->eh_entries);
-+                      i++;
-+              } else {
-+                      /* we finish processing this index, go up */
-+                      if (path[i].p_hdr->eh_entries == 0 && i > 0) {
-+                              /* index is empty, remove it
-+                               * handle must be already prepared by the
-+                               * truncatei_leaf() */
-+                              err = ext3_ext_rm_idx(handle, inode, path + i);
-+                      }
-+                      /* root level have p_bh == NULL, brelse() eats this */
-+                      brelse(path[i].p_bh);
-+                      path[i].p_bh = NULL;
-+                      i--;
-+                      ext_debug(inode, "return to level %d\n", i);
-+              }
-+      }
-+
-+      /* TODO: flexible tree reduction should be here */
-+      if (path->p_hdr->eh_entries == 0) {
-+              /*
-+               * truncate to zero freed all the tree
-+               * so, we need to correct eh_depth
-+               */
-+              err = ext3_ext_get_access(handle, inode, path);
-+              if (err == 0) {
-+                      ext_inode_hdr(inode)->eh_depth = 0;
-+                      ext_inode_hdr(inode)->eh_max =
-+                              cpu_to_le16(ext3_ext_space_root(inode));
-+                      err = ext3_ext_dirty(handle, inode, path);
-+              }
-+      }
-+out:
-+      ext3_ext_tree_changed(inode);
-+      ext3_ext_drop_refs(path);
-+      kfree(path);
-+      ext3_journal_stop(handle);
-+
-+      return err;
-+}
-+
-+/*
-+ * called at mount time
-+ */
-+void ext3_ext_init(struct super_block *sb)
-+{
-+      /*
-+       * possible initialization would be here
-+       */
-+
-+      if (test_opt(sb, EXTENTS)) {
-+              printk("EXT3-fs: file extents enabled");
-+#ifdef AGRESSIVE_TEST
-+              printk(", agressive tests");
-+#endif
-+#ifdef CHECK_BINSEARCH
-+              printk(", check binsearch");
-+#endif
-+#ifdef EXTENTS_STATS
-+              printk(", stats");
-+#endif
-+              printk("\n");
-+#ifdef EXTENTS_STATS
-+              spin_lock_init(&EXT3_SB(sb)->s_ext_stats_lock);
-+              EXT3_SB(sb)->s_ext_min = 1 << 30;
-+              EXT3_SB(sb)->s_ext_max = 0;
-+#endif
-+      }
-+}
-+
-+/*
-+ * called at umount time
-+ */
-+void ext3_ext_release(struct super_block *sb)
-+{
-+      if (!test_opt(sb, EXTENTS))
-+              return;
-+
-+#ifdef EXTENTS_STATS
-+      if (EXT3_SB(sb)->s_ext_blocks && EXT3_SB(sb)->s_ext_extents) {
-+              struct ext3_sb_info *sbi = EXT3_SB(sb);
-+              printk(KERN_ERR "EXT3-fs: %lu blocks in %lu extents (%lu ave)\n",
-+                      sbi->s_ext_blocks, sbi->s_ext_extents,
-+                      sbi->s_ext_blocks / sbi->s_ext_extents);
-+              printk(KERN_ERR "EXT3-fs: extents: %lu min, %lu max, max depth %lu\n",
-+                      sbi->s_ext_min, sbi->s_ext_max, sbi->s_depth_max);
-+      }
-+#endif
-+}
-+
-+int ext3_ext_get_blocks(handle_t *handle, struct inode *inode, sector_t iblock,
-+                      unsigned long max_blocks, struct buffer_head *bh_result,
-+                      int create, int extend_disksize)
-+{
-+      struct ext3_ext_path *path = NULL;
-+      struct ext3_extent newex, *ex;
-+      int goal, newblock, err = 0, depth;
-+      unsigned long allocated = 0;
-+      unsigned long next;
-+
-+      __clear_bit(BH_New, &bh_result->b_state);
-+      ext_debug(inode, "blocks %d/%lu requested for inode %u\n", (int) iblock,
-+                      max_blocks, (unsigned) inode->i_ino);
-+      mutex_lock(&EXT3_I(inode)->truncate_mutex);
-+
-+      /* check in cache */
-+      if ((goal = ext3_ext_in_cache(inode, iblock, &newex))) {
-+              if (goal == EXT3_EXT_CACHE_GAP) {
-+                      if (!create) {
-+                              /* block isn't allocated yet and
-+                               * user don't want to allocate it */
-+                              goto out2;
-+                      }
-+                      /* we should allocate requested block */
-+              } else if (goal == EXT3_EXT_CACHE_EXTENT) {
-+                      /* block is already allocated */
-+                      newblock = iblock
-+                                 - le32_to_cpu(newex.ee_block)
-+                                 + le32_to_cpu(newex.ee_start);
-+                      /* number of remain blocks in the extent */
-+                      BUG_ON(iblock < le32_to_cpu(newex.ee_block));
-+                      allocated = le16_to_cpu(newex.ee_len) -
-+                                      (iblock - le32_to_cpu(newex.ee_block));
-+                      goto out;
-+              } else {
-+                      BUG();
-+              }
-+      }
-+
-+      /* find extent for this block */
-+      path = ext3_ext_find_extent(inode, iblock, NULL);
-+      if (IS_ERR(path)) {
-+              err = PTR_ERR(path);
-+              path = NULL;
-+              goto out2;
-+      }
-+
-+      depth = ext_depth(inode);
-+
-+      /*
-+       * consistent leaf must not be empty
-+       * this situations is possible, though, _during_ tree modification
-+       * this is why assert can't be put in ext3_ext_find_extent()
-+       */
-+      BUG_ON(path[depth].p_ext == NULL && depth != 0);
-+
-+      if ((ex = path[depth].p_ext)) {
-+              unsigned long ee_block = le32_to_cpu(ex->ee_block);
-+              unsigned long ee_start = le32_to_cpu(ex->ee_start);
-+              unsigned short ee_len  = le16_to_cpu(ex->ee_len);
-+              /* if found exent covers block, simple return it */
-+              if (iblock >= ee_block && iblock < ee_block + ee_len) {
-+                      newblock = iblock - ee_block + ee_start;
-+                      /* number of remain blocks in the extent */
-+                      allocated = ee_len - (iblock - ee_block);
-+                      ext_debug(inode, "%d fit into %lu:%d -> %d\n", (int) iblock,
-+                                      ee_block, ee_len, newblock);
-+                      ext3_ext_put_in_cache(inode, ee_block, ee_len,
-+                                              ee_start, EXT3_EXT_CACHE_EXTENT);
-+                      goto out;
-+              }
-+      }
-+
-+      /*
-+       * requested block isn't allocated yet
-+       * we couldn't try to create block if create flag is zero
-+       */
-+      if (!create) {
-+              /* put just found gap into cache to speedup subsequest reqs */
-+              ext3_ext_put_gap_in_cache(inode, path, iblock);
-+              goto out2;
-+      }
-+
-+      /*
-+       * Okay, we need to do block allocation.  Lazily initialize the block
-+       * allocation info here if necessary
-+       */
-+      if (S_ISREG(inode->i_mode) && (!EXT3_I(inode)->i_block_alloc_info))
-+              ext3_init_block_alloc_info(inode);
-+
-+      /* find next allocated block so that we know how many
-+       * blocks we can allocate without ovelapping next extent */
-+      BUG_ON(iblock < le32_to_cpu(ex->ee_block) + le16_to_cpu(ex->ee_len));
-+      next = ext3_ext_next_allocated_block(path);
-+      BUG_ON(next <= iblock);
-+      allocated = next - iblock;
-+      if (allocated > max_blocks)
-+              allocated = max_blocks;
-+
-+      /* allocate new block */
-+      goal = ext3_ext_find_goal(inode, path, iblock);
-+      newblock = ext3_new_blocks(handle, inode, goal, &allocated, &err);
-+      if (!newblock)
-+              goto out2;
-+      ext_debug(inode, "allocate new block: goal %d, found %d/%lu\n",
-+                      goal, newblock, allocated);
-+
-+      /* try to insert new extent into found leaf and return */
-+      newex.ee_block = cpu_to_le32(iblock);
-+      newex.ee_start = cpu_to_le32(newblock);
-+      newex.ee_start_hi = 0;
-+      newex.ee_len = cpu_to_le16(allocated);
-+      err = ext3_ext_insert_extent(handle, inode, path, &newex);
-+      if (err) {
-+              /* free data blocks we just allocated */
-+              ext3_free_blocks(handle, inode, le32_to_cpu(newex.ee_start),
-+                              le16_to_cpu(newex.ee_len));
-+              goto out2;
-+      }
-+
-+      if (extend_disksize && inode->i_size > EXT3_I(inode)->i_disksize)
-+              EXT3_I(inode)->i_disksize = inode->i_size;
-+
-+      /* previous routine could use block we allocated */
-+      newblock = le32_to_cpu(newex.ee_start);
-+      __set_bit(BH_New, &bh_result->b_state);
-+
-+      ext3_ext_put_in_cache(inode, iblock, allocated, newblock,
-+                              EXT3_EXT_CACHE_EXTENT);
-+out:
-+      if (allocated > max_blocks)
-+              allocated = max_blocks;
-+      ext3_ext_show_leaf(inode, path);
-+      __set_bit(BH_Mapped, &bh_result->b_state);
-+      bh_result->b_bdev = inode->i_sb->s_bdev;
-+      bh_result->b_blocknr = newblock;
-+      bh_result->b_size = (allocated << inode->i_blkbits);
-+out2:
-+      if (path) {
-+              ext3_ext_drop_refs(path);
-+              kfree(path);
-+      }
-+      mutex_unlock(&EXT3_I(inode)->truncate_mutex);
-+
-+      return err ? err : allocated;
-+}
-+
-+void ext3_ext_truncate(struct inode * inode, struct page *page)
-+{
-+      struct address_space *mapping = inode->i_mapping;
-+      struct super_block *sb = inode->i_sb;
-+      unsigned long last_block;
-+      handle_t *handle;
-+      int err = 0;
-+
-+      /*
-+       * probably first extent we're gonna free will be last in block
-+       */
-+      err = ext3_writepage_trans_blocks(inode) + 3;
-+      handle = ext3_journal_start(inode, err);
-+      if (IS_ERR(handle)) {
-+              if (page) {
-+                      clear_highpage(page);
-+                      flush_dcache_page(page);
-+                      unlock_page(page);
-+                      page_cache_release(page);
-+              }
-+              return;
-+      }
-+
-+      if (page)
-+              ext3_block_truncate_page(handle, page, mapping, inode->i_size);
-+
-+      mutex_lock(&EXT3_I(inode)->truncate_mutex);
-+      ext3_ext_invalidate_cache(inode);
-+
-+      /*
-+       * TODO: optimization is possible here
-+       * probably we need not scaning at all,
-+       * because page truncation is enough
-+       */
-+      if (ext3_orphan_add(handle, inode))
-+              goto out_stop;
-+
-+      /* we have to know where to truncate from in crash case */
-+      EXT3_I(inode)->i_disksize = inode->i_size;
-+      ext3_mark_inode_dirty(handle, inode);
-+
-+      last_block = (inode->i_size + sb->s_blocksize - 1)
-+                      >> EXT3_BLOCK_SIZE_BITS(sb);
-+      err = ext3_ext_remove_space(inode, last_block);
-+
-+      /* In a multi-transaction truncate, we only make the final
-+       * transaction synchronous */
-+      if (IS_SYNC(inode))
-+              handle->h_sync = 1;
-+
-+out_stop:
-+      /*
-+       * If this was a simple ftruncate(), and the file will remain alive
-+       * then we need to clear up the orphan record which we created above.
-+       * However, if this was a real unlink then we were called by
-+       * ext3_delete_inode(), and we allow that function to clean up the
-+       * orphan info for us.
-+       */
-+      if (inode->i_nlink)
-+              ext3_orphan_del(handle, inode);
-+
-+      mutex_unlock(&EXT3_I(inode)->truncate_mutex);
-+      ext3_journal_stop(handle);
-+}
-+
-+/*
-+ * this routine calculate max number of blocks we could modify
-+ * in order to allocate new block for an inode
-+ */
-+int ext3_ext_writepage_trans_blocks(struct inode *inode, int num)
-+{
-+      int needed;
-+
-+      needed = ext3_ext_calc_credits_for_insert(inode, NULL);
-+
-+      /* caller want to allocate num blocks, but note it includes sb */
-+      needed = needed * num - (num - 1);
-+
-+#ifdef CONFIG_QUOTA
-+      needed += 2 * EXT3_QUOTA_TRANS_BLOCKS(inode->i_sb);
-+#endif
-+
-+      return needed;
-+}
-+
-+EXPORT_SYMBOL(ext3_mark_inode_dirty);
-+EXPORT_SYMBOL(ext3_ext_invalidate_cache);
-+EXPORT_SYMBOL(ext3_ext_insert_extent);
-+EXPORT_SYMBOL(ext3_ext_walk_space);
-+EXPORT_SYMBOL(ext3_ext_find_goal);
-+EXPORT_SYMBOL(ext3_ext_calc_credits_for_insert);
-Index: linux-2.6.18.8/fs/ext3/ialloc.c
-===================================================================
---- linux-2.6.18.8.orig/fs/ext3/ialloc.c       2007-07-17 09:18:09.000000000 +0200
-+++ linux-2.6.18.8/fs/ext3/ialloc.c    2007-07-17 11:08:09.000000000 +0200
-@@ -652,6 +652,17 @@ got:
-               ext3_std_error(sb, err);
-               goto fail_free_drop;
-       }
-+      if (test_opt(sb, EXTENTS) && S_ISREG(inode->i_mode)) {
-+              EXT3_I(inode)->i_flags |= EXT3_EXTENTS_FL;
-+              ext3_ext_tree_init(handle, inode);
-+              if (!EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_EXTENTS)) {
-+                      err = ext3_journal_get_write_access(handle, EXT3_SB(sb)->s_sbh);
-+                      if (err) goto fail;
-+                      EXT3_SET_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_EXTENTS);
-+                      BUFFER_TRACE(EXT3_SB(sb)->s_sbh, "call ext3_journal_dirty_metadata");
-+                      err = ext3_journal_dirty_metadata(handle, EXT3_SB(sb)->s_sbh);
-+              }
-+      }
-       ext3_debug("allocating inode %lu\n", inode->i_ino);
-       goto really_out;
-Index: linux-2.6.18.8/fs/ext3/inode.c
-===================================================================
---- linux-2.6.18.8.orig/fs/ext3/inode.c        2007-07-17 09:18:12.000000000 +0200
-+++ linux-2.6.18.8/fs/ext3/inode.c     2007-07-17 11:08:11.000000000 +0200
-@@ -40,8 +40,6 @@
- #include "xattr.h"
- #include "acl.h"
--static int ext3_writepage_trans_blocks(struct inode *inode);
--
- /*
-  * Test whether an inode is a fast symlink.
-  */
-@@ -804,6 +802,7 @@ int ext3_get_blocks_handle(handle_t *han
-       ext3_fsblk_t first_block = 0;
-+      J_ASSERT(!(EXT3_I(inode)->i_flags & EXT3_EXTENTS_FL));
-       J_ASSERT(handle != NULL || create == 0);
-       depth = ext3_block_to_path(inode,iblock,offsets,&blocks_to_boundary);
-@@ -984,12 +983,10 @@ static int ext3_get_block(struct inode *
-               started = 1;
-       }
--      ret = ext3_get_blocks_handle(handle, inode, iblock,
-+      ret = ext3_get_blocks_wrap(handle, inode, iblock,
-                                       max_blocks, bh_result, create, 0);
--      if (ret > 0) {
--              bh_result->b_size = (ret << inode->i_blkbits);
-+      if (ret > 0)
-               ret = 0;
--      }
-       if (started)
-               ext3_journal_stop(handle);
- out:
-@@ -1008,7 +1005,7 @@ struct buffer_head *ext3_getblk(handle_t
-       dummy.b_state = 0;
-       dummy.b_blocknr = -1000;
-       buffer_trace_init(&dummy.b_history);
--      err = ext3_get_blocks_handle(handle, inode, block, 1,
-+      err = ext3_get_blocks_wrap(handle, inode, block, 1,
-                                       &dummy, create, 1);
-       /*
-        * ext3_get_blocks_handle() returns number of blocks
-@@ -1759,7 +1756,7 @@ void ext3_set_aops(struct inode *inode)
-  * This required during truncate. We need to physically zero the tail end
-  * of that block so it doesn't yield old data if the file is later grown.
-  */
--static int ext3_block_truncate_page(handle_t *handle, struct page *page,
-+int ext3_block_truncate_page(handle_t *handle, struct page *page,
-               struct address_space *mapping, loff_t from)
- {
-       ext3_fsblk_t index = from >> PAGE_CACHE_SHIFT;
-@@ -2263,6 +2260,9 @@ void ext3_truncate(struct inode *inode)
-                       return;
-       }
-+      if (EXT3_I(inode)->i_flags & EXT3_EXTENTS_FL)
-+              return ext3_ext_truncate(inode, page);
-+
-       handle = start_transaction(inode);
-       if (IS_ERR(handle)) {
-               if (page) {
-@@ -3008,12 +3008,15 @@ err_out:
-  * block and work out the exact number of indirects which are touched.  Pah.
-  */
--static int ext3_writepage_trans_blocks(struct inode *inode)
-+int ext3_writepage_trans_blocks(struct inode *inode)
- {
-       int bpp = ext3_journal_blocks_per_page(inode);
-       int indirects = (EXT3_NDIR_BLOCKS % bpp) ? 5 : 3;
-       int ret;
-+      if (EXT3_I(inode)->i_flags & EXT3_EXTENTS_FL)
-+              return ext3_ext_writepage_trans_blocks(inode, bpp);
-+
-       if (ext3_should_journal_data(inode))
-               ret = 3 * (bpp + indirects) + 2;
-       else
-@@ -3260,7 +3263,7 @@ int ext3_map_inode_page(struct inode *in
-               if (blocks[i] != 0)
-                       continue;
--              rc = ext3_get_blocks_handle(handle, inode, iblock, 1, &dummy, 1, 1);
-+              rc = ext3_get_blocks_wrap(handle, inode, iblock, 1, &dummy, 1, 1);
-               if (rc < 0) {
-                       printk(KERN_INFO "ext3_map_inode_page: error reading "
-                                       "block %ld\n", iblock);
-Index: linux-2.6.18.8/fs/ext3/Makefile
-===================================================================
---- linux-2.6.18.8.orig/fs/ext3/Makefile       2007-07-17 09:18:11.000000000 +0200
-+++ linux-2.6.18.8/fs/ext3/Makefile    2007-07-17 11:08:11.000000000 +0200
-@@ -5,7 +5,7 @@
- obj-$(CONFIG_EXT3_FS) += ext3.o
- ext3-y        := balloc.o bitmap.o dir.o file.o fsync.o ialloc.o inode.o \
--         ioctl.o namei.o super.o symlink.o hash.o resize.o
-+         ioctl.o namei.o super.o symlink.o hash.o resize.o extents.o
- ext3-$(CONFIG_EXT3_FS_XATTR)   += xattr.o xattr_user.o xattr_trusted.o
- ext3-$(CONFIG_EXT3_FS_POSIX_ACL) += acl.o
-Index: linux-2.6.18.8/fs/ext3/super.c
-===================================================================
---- linux-2.6.18.8.orig/fs/ext3/super.c        2007-07-17 09:18:12.000000000 +0200
-+++ linux-2.6.18.8/fs/ext3/super.c     2007-07-17 11:08:12.000000000 +0200
-@@ -391,6 +391,7 @@ static void ext3_put_super (struct super
-       struct ext3_super_block *es = sbi->s_es;
-       int i;
-+      ext3_ext_release(sb);
-       ext3_xattr_put_super(sb);
-       journal_destroy(sbi->s_journal);
-       if (!(sb->s_flags & MS_RDONLY)) {
-@@ -455,6 +456,8 @@ static struct inode *ext3_alloc_inode(st
- #endif
-       ei->i_block_alloc_info = NULL;
-       ei->vfs_inode.i_version = 1;
-+
-+      memset(&ei->i_cached_extent, 0, sizeof(ei->i_cached_extent));
-       return &ei->vfs_inode;
- }
-@@ -680,7 +683,8 @@ enum {
-       Opt_jqfmt_vfsold, Opt_jqfmt_vfsv0, Opt_quota, Opt_noquota,
-       Opt_ignore, Opt_barrier, Opt_err, Opt_resize, Opt_usrquota,
-       Opt_iopen, Opt_noiopen, Opt_iopen_nopriv,
--      Opt_grpquota
-+      Opt_grpquota,
-+      Opt_extents, Opt_noextents, Opt_extdebug,
- };
- static match_table_t tokens = {
-@@ -733,6 +737,9 @@ static match_table_t tokens = {
-       {Opt_noiopen, "noiopen"},
-       {Opt_iopen_nopriv, "iopen_nopriv"},
-       {Opt_barrier, "barrier=%u"},
-+      {Opt_extents, "extents"},
-+      {Opt_noextents, "noextents"},
-+      {Opt_extdebug, "extdebug"},
-       {Opt_err, NULL},
-       {Opt_resize, "resize"},
- };
-@@ -1077,6 +1084,15 @@ clear_qf_name:
-               case Opt_bh:
-                       clear_opt(sbi->s_mount_opt, NOBH);
-                       break;
-+              case Opt_extents:
-+                      set_opt (sbi->s_mount_opt, EXTENTS);
-+                      break;
-+              case Opt_noextents:
-+                      clear_opt (sbi->s_mount_opt, EXTENTS);
-+                      break;
-+              case Opt_extdebug:
-+                      set_opt (sbi->s_mount_opt, EXTDEBUG);
-+                      break;
-               default:
-                       printk (KERN_ERR
-                               "EXT3-fs: Unrecognized mount option \"%s\" "
-@@ -1806,6 +1822,8 @@ static int ext3_fill_super (struct super
-               test_opt(sb,DATA_FLAGS) == EXT3_MOUNT_ORDERED_DATA ? "ordered":
-               "writeback");
-+      ext3_ext_init(sb);
-+
-       lock_kernel();
-       return 0;
-Index: linux-2.6.18.8/include/linux/ext3_extents.h
-===================================================================
---- /dev/null  1970-01-01 00:00:00.000000000 +0000
-+++ linux-2.6.18.8/include/linux/ext3_extents.h        2007-07-17 09:18:14.000000000 +0200
-@@ -0,0 +1,232 @@
-+/*
-+ * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
-+ * Written by Alex Tomas <alex@clusterfs.com>
-+ *
-+ * This program is free software; you can redistribute it and/or modify
-+ * it under the terms of the GNU General Public License version 2 as
-+ * published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-+ * GNU General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public Licens
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-
-+ */
-+
-+#ifndef _LINUX_EXT3_EXTENTS
-+#define _LINUX_EXT3_EXTENTS
-+
-+#include <linux/ext3_fs.h>
-+
-+/*
-+ * with AGRESSIVE_TEST defined capacity of index/leaf blocks
-+ * become very little, so index split, in-depth growing and
-+ * other hard changes happens much more often
-+ * this is for debug purposes only
-+ */
-+#define AGRESSIVE_TEST_
-+
-+/*
-+ * with EXTENTS_STATS defined number of blocks and extents
-+ * are collected in truncate path. they'll be showed at
-+ * umount time
-+ */
-+#define EXTENTS_STATS__
-+
-+/*
-+ * if CHECK_BINSEARCH defined, then results of binary search
-+ * will be checked by linear search
-+ */
-+#define CHECK_BINSEARCH__
-+
-+/*
-+ * if EXT_DEBUG is defined you can use 'extdebug' mount option
-+ * to get lots of info what's going on
-+ */
-+#define EXT_DEBUG_
-+#ifdef EXT_DEBUG
-+#define ext_debug(inode,fmt,a...)                       \
-+do {                                                    \
-+      if (test_opt(inode->i_sb, EXTDEBUG))             \
-+              printk(fmt, ##a);                        \
-+} while (0)
-+#else
-+#define ext_debug(inode,fmt,a...)
-+#endif
-+
-+
-+/*
-+ * if EXT_STATS is defined then stats numbers are collected
-+ * these number will be displayed at umount time
-+ */
-+#define EXT_STATS_
-+
-+/*
-+ * define EXT3_ALLOC_NEEDED to 0 since block bitmap, group desc. and sb
-+ * are now accounted in ext3_ext_calc_credits_for_insert()
-+ */
-+#define EXT3_ALLOC_NEEDED 0
-+
-+/*
-+ * ext3_inode has i_block array (60 bytes total)
-+ * first 12 bytes store ext3_extent_header
-+ * the remain stores array of ext3_extent
-+ */
-+
-+/*
-+ * this is extent on-disk structure
-+ * it's used at the bottom of the tree
-+ */
-+struct ext3_extent {
-+      __le32  ee_block;       /* first logical block extent covers */
-+      __le16  ee_len;         /* number of blocks covered by extent */
-+      __le16  ee_start_hi;    /* high 16 bits of physical block */
-+      __le32  ee_start;       /* low 32 bigs of physical block */
-+};
-+
-+/*
-+ * this is index on-disk structure
-+ * it's used at all the levels, but the bottom
-+ */
-+struct ext3_extent_idx {
-+      __le32  ei_block;       /* index covers logical blocks from 'block' */
-+      __le32  ei_leaf;        /* pointer to the physical block of the next *
-+                               * level. leaf or next index could bet here */
-+      __le16  ei_leaf_hi;     /* high 16 bits of physical block */
-+      __u16   ei_unused;
-+};
-+
-+/*
-+ * each block (leaves and indexes), even inode-stored has header
-+ */
-+struct ext3_extent_header {
-+      __le16  eh_magic;       /* probably will support different formats */
-+      __le16  eh_entries;     /* number of valid entries */
-+      __le16  eh_max;         /* capacity of store in entries */
-+      __le16  eh_depth;       /* has tree real underlaying blocks? */
-+      __le32  eh_generation;  /* flags(8 bits) | generation of the tree */
-+};
-+
-+#define EXT3_EXT_MAGIC                0xf30a
-+
-+/*
-+ * array of ext3_ext_path contains path to some extent
-+ * creation/lookup routines use it for traversal/splitting/etc
-+ * truncate uses it to simulate recursive walking
-+ */
-+struct ext3_ext_path {
-+      __u32                           p_block;
-+      __u16                           p_depth;
-+      struct ext3_extent              *p_ext;
-+      struct ext3_extent_idx          *p_idx;
-+      struct ext3_extent_header       *p_hdr;
-+      struct buffer_head              *p_bh;
-+};
-+
-+/*
-+ * structure for external API
-+ */
-+
-+#define EXT3_EXT_CACHE_NO     0
-+#define EXT3_EXT_CACHE_GAP    1
-+#define EXT3_EXT_CACHE_EXTENT 2
-+#define EXT3_EXT_HAS_NO_TREE  /* ext3_extents_tree struct is not used*/
-+
-+/*
-+ * to be called by ext3_ext_walk_space()
-+ * negative retcode - error
-+ * positive retcode - signal for ext3_ext_walk_space(), see below
-+ * callback must return valid extent (passed or newly created)
-+ */
-+typedef int (*ext_prepare_callback)(struct inode *, struct ext3_ext_path *,
-+                                      struct ext3_ext_cache *,
-+                                      void *);
-+
-+#define EXT_CONTINUE  0
-+#define EXT_BREAK     1
-+#define EXT_REPEAT    2
-+
-+
-+#define EXT_MAX_BLOCK 0xffffffff
-+#define EXT_UNSET_BLOCK 1
-+
-+#define EXT_FLAGS_CLR_UNKNOWN 0x7  /* Flags cleared on modification */
-+#define EXT_HDR_GEN_BITS      24
-+#define EXT_HDR_GEN_MASK      ((1 << EXT_HDR_GEN_BITS) - 1)
-+
-+#define EXT_FIRST_EXTENT(__hdr__) \
-+      ((struct ext3_extent *) (((char *) (__hdr__)) +         \
-+                               sizeof(struct ext3_extent_header)))
-+#define EXT_FIRST_INDEX(__hdr__) \
-+      ((struct ext3_extent_idx *) (((char *) (__hdr__)) +     \
-+                                   sizeof(struct ext3_extent_header)))
-+#define EXT_HAS_FREE_INDEX(__path__) \
-+      (le16_to_cpu((__path__)->p_hdr->eh_entries) < \
-+                                   le16_to_cpu((__path__)->p_hdr->eh_max))
-+#define EXT_LAST_EXTENT(__hdr__) \
-+      (EXT_FIRST_EXTENT((__hdr__)) + le16_to_cpu((__hdr__)->eh_entries) - 1)
-+#define EXT_LAST_INDEX(__hdr__) \
-+      (EXT_FIRST_INDEX((__hdr__)) + le16_to_cpu((__hdr__)->eh_entries) - 1)
-+#define EXT_MAX_EXTENT(__hdr__) \
-+      (EXT_FIRST_EXTENT((__hdr__)) + le16_to_cpu((__hdr__)->eh_max) - 1)
-+#define EXT_MAX_INDEX(__hdr__) \
-+      (EXT_FIRST_INDEX((__hdr__)) + le16_to_cpu((__hdr__)->eh_max) - 1)
-+
-+
-+static inline struct ext3_extent_header *ext_inode_hdr(struct inode *inode)
-+{
-+      return (struct ext3_extent_header *) EXT3_I(inode)->i_data;
-+}
-+
-+static inline struct ext3_extent_header *ext_block_hdr(struct buffer_head *bh)
-+{
-+      return (struct ext3_extent_header *) bh->b_data;
-+}
-+
-+static inline unsigned short ext_depth(struct inode *inode)
-+{
-+      return le16_to_cpu(ext_inode_hdr(inode)->eh_depth);
-+}
-+
-+static inline unsigned short ext_flags(struct ext3_extent_header *neh)
-+{
-+      return le16_to_cpu(neh->eh_generation) >> EXT_HDR_GEN_BITS;
-+}
-+
-+static inline unsigned short ext_hdr_gen(struct ext3_extent_header *neh)
-+{
-+      return le16_to_cpu(neh->eh_generation) & EXT_HDR_GEN_MASK;
-+}
-+
-+static inline unsigned short ext_generation(struct inode *inode)
-+{
-+      return ext_hdr_gen(ext_inode_hdr(inode));
-+}
-+
-+static inline void ext3_ext_tree_changed(struct inode *inode)
-+{
-+      struct ext3_extent_header *neh = ext_inode_hdr(inode);
-+      neh->eh_generation = cpu_to_le32(
-+              ((ext_flags(neh) & ~EXT_FLAGS_CLR_UNKNOWN) << EXT_HDR_GEN_BITS)
-+                  | ((ext_hdr_gen(neh) + 1) & EXT_HDR_GEN_MASK));
-+}
-+
-+static inline void
-+ext3_ext_invalidate_cache(struct inode *inode)
-+{
-+      EXT3_I(inode)->i_cached_extent.ec_type = EXT3_EXT_CACHE_NO;
-+}
-+
-+extern int ext3_ext_search_left(struct inode *, struct ext3_ext_path *, unsigned long *, unsigned long *);
-+extern int ext3_ext_search_right(struct inode *, struct ext3_ext_path *, unsigned long *, unsigned long *);
-+extern int ext3_extent_tree_init(handle_t *, struct inode *);
-+extern int ext3_ext_calc_credits_for_insert(struct inode *, struct ext3_ext_path *);
-+extern int ext3_ext_insert_extent(handle_t *, struct inode *, struct ext3_ext_path *, struct ext3_extent *);
-+extern int ext3_ext_walk_space(struct inode *, unsigned long, unsigned long, ext_prepare_callback, void *);
-+extern struct ext3_ext_path * ext3_ext_find_extent(struct inode *, int, struct ext3_ext_path *);
-+
-+#endif /* _LINUX_EXT3_EXTENTS */
-+
-Index: linux-2.6.18.8/include/linux/ext3_fs.h
-===================================================================
---- linux-2.6.18.8.orig/include/linux/ext3_fs.h        2007-07-17 09:18:13.000000000 +0200
-+++ linux-2.6.18.8/include/linux/ext3_fs.h     2007-07-17 11:08:12.000000000 +0200
-@@ -182,8 +182,9 @@ struct ext3_group_desc
- #define EXT3_DIRSYNC_FL                       0x00010000 /* dirsync behaviour (directories only) */
- #define EXT3_TOPDIR_FL                        0x00020000 /* Top of directory hierarchies*/
- #define EXT3_RESERVED_FL              0x80000000 /* reserved for ext3 lib */
-+#define EXT3_EXTENTS_FL                       0x00080000 /* Inode uses extents */
--#define EXT3_FL_USER_VISIBLE          0x0003DFFF /* User visible flags */
-+#define EXT3_FL_USER_VISIBLE          0x000BDFFF /* User visible flags */
- #define EXT3_FL_USER_MODIFIABLE               0x000380FF /* User modifiable flags */
- /*
-@@ -373,6 +374,8 @@ struct ext3_inode {
- #define EXT3_MOUNT_QUOTA              0x80000 /* Some quota option set */
- #define EXT3_MOUNT_USRQUOTA           0x100000 /* "old" user quota */
- #define EXT3_MOUNT_GRPQUOTA           0x200000 /* "old" group quota */
-+#define EXT3_MOUNT_EXTENTS            0x2000000/* Extents support */
-+#define EXT3_MOUNT_EXTDEBUG             0x4000000/* Extents debug */
- /* Compatibility, for having both ext2_fs.h and ext3_fs.h included at once */
- #ifndef clear_opt
-@@ -572,11 +575,13 @@ static inline int ext3_valid_inum(struct
- #define EXT3_FEATURE_INCOMPAT_RECOVER         0x0004 /* Needs recovery */
- #define EXT3_FEATURE_INCOMPAT_JOURNAL_DEV     0x0008 /* Journal device */
- #define EXT3_FEATURE_INCOMPAT_META_BG         0x0010
-+#define EXT3_FEATURE_INCOMPAT_EXTENTS         0x0040 /* extents support */
- #define EXT3_FEATURE_COMPAT_SUPP      EXT2_FEATURE_COMPAT_EXT_ATTR
- #define EXT3_FEATURE_INCOMPAT_SUPP    (EXT3_FEATURE_INCOMPAT_FILETYPE| \
-                                        EXT3_FEATURE_INCOMPAT_RECOVER| \
--                                       EXT3_FEATURE_INCOMPAT_META_BG)
-+                                       EXT3_FEATURE_INCOMPAT_META_BG| \
-+                                       EXT3_FEATURE_INCOMPAT_EXTENTS)
- #define EXT3_FEATURE_RO_COMPAT_SUPP   (EXT3_FEATURE_RO_COMPAT_SPARSE_SUPER| \
-                                        EXT3_FEATURE_RO_COMPAT_LARGE_FILE| \
-                                        EXT3_FEATURE_RO_COMPAT_BTREE_DIR)
-@@ -816,6 +821,9 @@ extern int ext3_get_inode_loc(struct ino
- extern void ext3_set_aops(struct inode *inode);
- extern int ext3_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
-                      u64 start, u64 len);
-+extern int ext3_writepage_trans_blocks(struct inode *);
-+extern int ext3_block_truncate_page(handle_t *handle, struct page *page,
-+              struct address_space *mapping, loff_t from);
- /* ioctl.c */
- extern int ext3_ioctl (struct inode *, struct file *, unsigned int,
-@@ -869,6 +877,30 @@ extern struct inode_operations ext3_spec
- extern struct inode_operations ext3_symlink_inode_operations;
- extern struct inode_operations ext3_fast_symlink_inode_operations;
-+/* extents.c */
-+extern int ext3_ext_tree_init(handle_t *handle, struct inode *);
-+extern int ext3_ext_writepage_trans_blocks(struct inode *, int);
-+extern int ext3_ext_get_blocks(handle_t *, struct inode *, sector_t,
-+                              unsigned long, struct buffer_head *, int, int);
-+extern void ext3_ext_truncate(struct inode *, struct page *);
-+extern void ext3_ext_init(struct super_block *);
-+extern void ext3_ext_release(struct super_block *);
-+static inline int
-+ext3_get_blocks_wrap(handle_t *handle, struct inode *inode, sector_t block,
-+                      unsigned long max_blocks, struct buffer_head *bh,
-+                      int create, int extend_disksize)
-+{
-+      int ret;
-+      if (EXT3_I(inode)->i_flags & EXT3_EXTENTS_FL)
-+              return ext3_ext_get_blocks(handle, inode, block, max_blocks,
-+                                      bh, create, extend_disksize);
-+      ret = ext3_get_blocks_handle(handle, inode, block, max_blocks, bh, create,
-+                                   extend_disksize);
-+      if (ret > 0)
-+              bh->b_size = (ret << inode->i_blkbits);
-+      return ret;
-+}
-+
- #endif        /* __KERNEL__ */
-Index: linux-2.6.18.8/include/linux/ext3_fs_i.h
-===================================================================
---- linux-2.6.18.8.orig/include/linux/ext3_fs_i.h      2007-02-24 00:52:30.000000000 +0100
-+++ linux-2.6.18.8/include/linux/ext3_fs_i.h   2007-07-17 11:08:11.000000000 +0200
-@@ -65,6 +65,16 @@ struct ext3_block_alloc_info {
- #define rsv_end rsv_window._rsv_end
- /*
-+ * storage for cached extent
-+ */
-+struct ext3_ext_cache {
-+      __u32   ec_start;
-+      __u32   ec_block;
-+      __u32   ec_len; /* must be 32bit to return holes */
-+      __u32   ec_type;
-+};
-+
-+/*
-  * third extended file system inode data in memory
-  */
- struct ext3_inode_info {
-@@ -142,6 +152,8 @@ struct ext3_inode_info {
-        */
-       struct mutex truncate_mutex;
-       struct inode vfs_inode;
-+
-+      struct ext3_ext_cache i_cached_extent;
- };
- #endif        /* _LINUX_EXT3_FS_I */
-Index: linux-2.6.18.8/include/linux/ext3_fs_sb.h
-===================================================================
---- linux-2.6.18.8.orig/include/linux/ext3_fs_sb.h     2007-02-24 00:52:30.000000000 +0100
-+++ linux-2.6.18.8/include/linux/ext3_fs_sb.h  2007-07-17 11:08:12.000000000 +0200
-@@ -78,6 +78,16 @@ struct ext3_sb_info {
-       char *s_qf_names[MAXQUOTAS];            /* Names of quota files with journalled quota */
-       int s_jquota_fmt;                       /* Format of quota to use */
- #endif
-+
-+#ifdef EXTENTS_STATS
-+      /* ext3 extents stats */
-+      unsigned long s_ext_min;
-+      unsigned long s_ext_max;
-+      unsigned long s_depth_max;
-+      spinlock_t s_ext_stats_lock;
-+      unsigned long s_ext_blocks;
-+      unsigned long s_ext_extents;
-+#endif
- };
- #endif        /* _LINUX_EXT3_FS_SB */
-Index: linux-2.6.18.8/include/linux/ext3_jbd.h
-===================================================================
---- linux-2.6.18.8.orig/include/linux/ext3_jbd.h       2007-02-24 00:52:30.000000000 +0100
-+++ linux-2.6.18.8/include/linux/ext3_jbd.h    2007-07-17 09:18:14.000000000 +0200
-@@ -23,12 +23,20 @@
- /* Define the number of blocks we need to account to a transaction to
-  * modify one block of data.
-- * 
-+ *
-  * We may have to touch one inode, one bitmap buffer, up to three
-  * indirection blocks, the group and superblock summaries, and the data
-- * block to complete the transaction.  */
-+ * block to complete the transaction.
-+ *
-+ * For extents-enabled fs we may have to allocate and modify upto
-+ * 5 levels of tree + root which is stored in inode. */
-+
-+#define EXT3_SINGLEDATA_TRANS_BLOCKS(sb)                              \
-+      (EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_EXTENTS)   \
-+              || test_opt(sb, EXTENTS) ? 27U : 8U)
--#define EXT3_SINGLEDATA_TRANS_BLOCKS  8U
-+/* Indicate that EXT3_SINGLEDATA_TRANS_BLOCKS takes the sb as argument */
-+#define EXT3_SINGLEDATA_TRANS_BLOCKS_HAS_SB
- /* Extended attribute operations touch at most two data buffers,
-  * two bitmap buffers, and two group summaries, in addition to the inode
-@@ -42,7 +50,7 @@
-  * superblock only gets updated once, of course, so don't bother
-  * counting that again for the quota updates. */
--#define EXT3_DATA_TRANS_BLOCKS(sb)    (EXT3_SINGLEDATA_TRANS_BLOCKS + \
-+#define EXT3_DATA_TRANS_BLOCKS(sb)    (EXT3_SINGLEDATA_TRANS_BLOCKS(sb) + \
-                                        EXT3_XATTR_TRANS_BLOCKS - 2 + \
-                                        2*EXT3_QUOTA_TRANS_BLOCKS(sb))
-@@ -78,9 +86,9 @@
- /* Amount of blocks needed for quota insert/delete - we do some block writes
-  * but inode, sb and group updates are done only once */
- #define EXT3_QUOTA_INIT_BLOCKS(sb) (test_opt(sb, QUOTA) ? (DQUOT_INIT_ALLOC*\
--              (EXT3_SINGLEDATA_TRANS_BLOCKS-3)+3+DQUOT_INIT_REWRITE) : 0)
-+              (EXT3_SINGLEDATA_TRANS_BLOCKS(sb)-3)+3+DQUOT_INIT_REWRITE) : 0)
- #define EXT3_QUOTA_DEL_BLOCKS(sb) (test_opt(sb, QUOTA) ? (DQUOT_DEL_ALLOC*\
--              (EXT3_SINGLEDATA_TRANS_BLOCKS-3)+3+DQUOT_DEL_REWRITE) : 0)
-+              (EXT3_SINGLEDATA_TRANS_BLOCKS(sb)-3)+3+DQUOT_DEL_REWRITE) : 0)
- #else
- #define EXT3_QUOTA_TRANS_BLOCKS(sb) 0
- #define EXT3_QUOTA_INIT_BLOCKS(sb) 0
diff --git a/ldiskfs/kernel_patches/patches/ext3-fiemap-2.6-rhel5.patch b/ldiskfs/kernel_patches/patches/ext3-fiemap-2.6-rhel5.patch
deleted file mode 100644 (file)
index f76beb6..0000000
+++ /dev/null
@@ -1,96 +0,0 @@
-diff -rupN linux-2.6.18-164.6.1_1/fs/ext3/ioctl.c linux-2.6.18-164.6.1_2/fs/ext3/ioctl.c
---- linux-2.6.18-164.6.1_1/fs/ext3/ioctl.c     2009-12-22 12:37:55.000000000 +0530
-+++ linux-2.6.18-164.6.1_2/fs/ext3/ioctl.c     2009-12-22 12:40:44.000000000 +0530
-@@ -16,6 +16,70 @@
- #include <asm/uaccess.h>
- #include <linux/namei.h>
-+/* So that the fiemap access checks can't overflow on 32 bit machines. */
-+#define FIEMAP_MAX_EXTENTS     (UINT_MAX / sizeof(struct fiemap_extent))
-+
-+static int fiemap_check_ranges(struct super_block *sb,
-+                             u64 start, u64 len, u64 *new_len)
-+{
-+      *new_len = len;
-+
-+      if (len == 0)
-+              return -EINVAL;
-+
-+      if (start > sb->s_maxbytes)
-+              return -EFBIG;
-+
-+      /*
-+       * Shrink request scope to what the fs can actually handle.
-+       */
-+      if ((len > sb->s_maxbytes) ||
-+          (sb->s_maxbytes - len) < start)
-+              *new_len = sb->s_maxbytes - start;
-+
-+      return 0;
-+}
-+
-+int ioctl_fiemap(struct inode *inode, struct file *filp, unsigned long arg)
-+{
-+      struct fiemap fiemap;
-+      u64 len;
-+      struct fiemap_extent_info fieinfo = {0, };
-+      struct super_block *sb = inode->i_sb;
-+      int error = 0;
-+
-+      if (copy_from_user(&fiemap, (struct fiemap __user *) arg,
-+                         sizeof(struct fiemap)))
-+               return -EFAULT;
-+
-+      if (fiemap.fm_extent_count > FIEMAP_MAX_EXTENTS)
-+              return -EINVAL;
-+
-+      error = fiemap_check_ranges(sb, fiemap.fm_start, fiemap.fm_length,
-+                                  &len);
-+      if (error)
-+              return error;
-+
-+      fieinfo.fi_flags = fiemap.fm_flags;
-+      fieinfo.fi_extents_max = fiemap.fm_extent_count;
-+      fieinfo.fi_extents_start = (struct fiemap_extent *)(arg + sizeof(fiemap));
-+
-+      if (fiemap.fm_extent_count != 0 &&
-+          !access_ok(VERIFY_WRITE, (void *)arg,
-+                     offsetof(typeof(fiemap), fm_extents[fiemap.fm_extent_count])))
-+              return -EFAULT;
-+
-+      if (fieinfo.fi_flags & FIEMAP_FLAG_SYNC)
-+              filemap_write_and_wait(inode->i_mapping);
-+
-+      error = ext3_fiemap(inode, &fieinfo, fiemap.fm_start, len);
-+      fiemap.fm_flags = fieinfo.fi_flags;
-+      fiemap.fm_mapped_extents = fieinfo.fi_extents_mapped;
-+      if (copy_to_user((char *)arg, &fiemap, sizeof(fiemap)))
-+              error = -EFAULT;
-+
-+      return error;
-+}
- int ext3_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
-               unsigned long arg)
-@@ -276,7 +340,9 @@ flags_err:
-               return err;
-       }
--
-+      case EXT3_IOC_FIEMAP: {
-+              return ioctl_fiemap(inode, filp, arg);
-+      }
-       default:
-               return -ENOTTY;
-diff -rupN linux-2.6.18-164.6.1_1/include/linux/ext3_fs.h linux-2.6.18-164.6.1_2/include/linux/ext3_fs.h
---- linux-2.6.18-164.6.1_1/include/linux/ext3_fs.h     2009-12-22 12:37:55.000000000 +0530
-+++ linux-2.6.18-164.6.1_2/include/linux/ext3_fs.h     2009-12-22 12:43:02.000000000 +0530
-@@ -260,6 +260,7 @@ struct ext3_new_group_data {
- #define       EXT3_IOC_SETVERSION             _IOW('f', 4, long)
- #define EXT3_IOC_GROUP_EXTEND         _IOW('f', 7, unsigned long)
- #define EXT3_IOC_GROUP_ADD            _IOW('f', 8,struct ext3_new_group_input)
-+#define EXT3_IOC_FIEMAP               _IOWR('f', 11, struct fiemap)
- #define       EXT3_IOC_GETVERSION_OLD         _IOR('v', 1, long)
- #define       EXT3_IOC_SETVERSION_OLD         _IOW('v', 2, long)
- #ifdef CONFIG_JBD_DEBUG
diff --git a/ldiskfs/kernel_patches/patches/ext3-force_over_8tb-rhel5.patch b/ldiskfs/kernel_patches/patches/ext3-force_over_8tb-rhel5.patch
deleted file mode 100644 (file)
index 1e1ac08..0000000
+++ /dev/null
@@ -1,57 +0,0 @@
-Index: linux-2.6.18-128.1.6/fs/ext3/super.c
-===================================================================
---- linux-2.6.18-128.1.6.orig/fs/ext3/super.c
-+++ linux-2.6.18-128.1.6/fs/ext3/super.c
-@@ -51,6 +51,8 @@
- #define EXT3_DEFAULT_MAX_DIR_SIZE             0
- #define EXT3_MAX_DIR_SIZE_NAME                "max_dir_size"
-+static int force_over_8tb;
-+
- static int ext3_load_journal(struct super_block *, struct ext3_super_block *,
-                            unsigned long journal_devnum);
- static int ext3_create_journal(struct super_block *, struct ext3_super_block *,
-@@ -715,7 +717,7 @@ enum {
-       Opt_iopen, Opt_noiopen, Opt_iopen_nopriv,
-       Opt_grpquota,
-       Opt_extents, Opt_noextents, Opt_bigendian_extents, Opt_extdebug,
--      Opt_mballoc, Opt_nomballoc, Opt_stripe, Opt_maxdirsize
-+      Opt_mballoc, Opt_nomballoc, Opt_stripe, Opt_maxdirsize, Opt_force_over_8tb,
- };
- static match_table_t tokens = {
-@@ -779,5 +781,6 @@ static match_table_t tokens = {
-       {Opt_mballoc, "mballoc"},
-       {Opt_nomballoc, "nomballoc"},
-       {Opt_stripe, "stripe=%u"},
-+      {Opt_force_over_8tb, "force_over_8tb"},
-       {Opt_resize, "resize"},
- };
-@@ -1157,6 +1160,9 @@ clear_qf_name:
-                               return 0;
-                       sbi->s_max_dir_size = option;
-                       break;
-+              case Opt_force_over_8tb:
-+                      force_over_8tb = 1;
-+                      break;
-               default:
-                       printk (KERN_ERR
-                               "EXT3-fs: Unrecognized mount option \"%s\" "
-@@ -2248,6 +2254,17 @@ static int ext3_fill_super (struct super
-               goto failed_mount;
-       }
-+      if (le32_to_cpu(es->s_blocks_count) >
-+          ((0x80000000000ULL >> sb->s_blocksize_bits) - 1)) {
-+              if (force_over_8tb == 0) {
-+                      printk(KERN_ERR "EXT3-fs does not support filesystems "
-+                             "greater than 8TB and can cause data corruption."
-+                             "Use \"force_over_8tb\" mount option to override."
-+                             "\n");
-+                      goto failed_mount;
-+              }
-+      }
-+
-       if (EXT3_BLOCKS_PER_GROUP(sb) == 0)
-               goto cantfind_ext3;
-       sbi->s_groups_count = ((le32_to_cpu(es->s_blocks_count) -
diff --git a/ldiskfs/kernel_patches/patches/ext3-get-raid-stripe-from-sb.patch b/ldiskfs/kernel_patches/patches/ext3-get-raid-stripe-from-sb.patch
deleted file mode 100644 (file)
index 07f251d..0000000
+++ /dev/null
@@ -1,49 +0,0 @@
-Index: linux-2.6.18-53.1.14/fs/ext3/super.c
-===================================================================
---- linux-2.6.18-53.1.14.orig/fs/ext3/super.c
-+++ linux-2.6.18-53.1.14/fs/ext3/super.c
-@@ -1900,6 +1900,34 @@ static int ext3_max_dir_size_write(struc
-       return count;
- }
-+/*
-+ * ext3_get_stripe_size: Get the stripe size.
-+ * @sbi: In memory super block info
-+ *
-+ * If we have specified it via mount option, then
-+ * use the mount option value. If the value specified at mount time is
-+ * greater than the blocks per group use the super block value.
-+ * If the super block value is greater than blocks per group return 0.
-+ * Allocator needs it be less than blocks per group.
-+ */
-+static unsigned long ext3_get_stripe_size(struct ext3_sb_info *sbi)
-+{
-+      unsigned long stride = le16_to_cpu(sbi->s_es->s_raid_stride);
-+      unsigned long stripe_width =
-+                      le32_to_cpu(sbi->s_es->s_raid_stripe_width);
-+
-+      if (sbi->s_stripe && sbi->s_stripe <= sbi->s_blocks_per_group)
-+              return sbi->s_stripe;
-+
-+      if (stripe_width <= sbi->s_blocks_per_group)
-+              return stripe_width;
-+
-+      if (stride <= sbi->s_blocks_per_group)
-+              return stride;
-+
-+      return 0;
-+}
-+
- static int ext3_fill_super (struct super_block *sb, void *data, int silent)
- {
-       struct buffer_head * bh;
-@@ -2221,6 +2249,8 @@ static int ext3_fill_super (struct super
-       sbi->s_rsv_window_head.rsv_goal_size = 0;
-       ext3_rsv_window_add(sb, &sbi->s_rsv_window_head);
-+        sbi->s_stripe = ext3_get_stripe_size(sbi);
-+
-       /*
-        * set up enough so that it can read an inode
-        */
-
diff --git a/ldiskfs/kernel_patches/patches/ext3-hash-indexed-dir-dotdot-update.patch b/ldiskfs/kernel_patches/patches/ext3-hash-indexed-dir-dotdot-update.patch
deleted file mode 100644 (file)
index a817045..0000000
+++ /dev/null
@@ -1,87 +0,0 @@
-Index: linux-stage/fs/ext3/namei.c
-===================================================================
---- linux-stage.orig/fs/ext3/namei.c   2009-08-10 22:31:03.000000000 +0800
-+++ linux-stage/fs/ext3/namei.c        2009-08-10 22:33:38.000000000 +0800
-@@ -1471,6 +1471,72 @@
- }
- #endif
-+/* update ".." for hash-indexed directory, split the item "." if necessary */
-+static int ext3_update_dotdot(handle_t *handle, struct dentry *dentry,
-+                               struct inode *inode)
-+{
-+      struct inode * dir = dentry->d_parent->d_inode;
-+      struct buffer_head * dir_block;
-+      struct ext3_dir_entry_2 * de;
-+      int len, journal = 0, err = 0;
-+
-+      if (IS_ERR(handle))
-+              return PTR_ERR(handle);
-+
-+      if (IS_DIRSYNC(dir))
-+              handle->h_sync = 1;
-+
-+      dir_block = ext3_bread(handle, dir, 0, 0, &err);
-+      if (!dir_block)
-+              goto out;
-+
-+      de = (struct ext3_dir_entry_2 *)dir_block->b_data;
-+      /* the first item must be "." */
-+      assert(de->name_len == 1 && de->name[0] == '.');
-+      len = le16_to_cpu(de->rec_len);
-+      assert(len >= EXT3_DIR_REC_LEN(1));
-+      if (len > EXT3_DIR_REC_LEN(1)) {
-+              BUFFER_TRACE(dir_block, "get_write_access");
-+              err = ext3_journal_get_write_access(handle, dir_block);
-+              if (err)
-+                      goto out_journal;
-+
-+              journal = 1;
-+              de->rec_len = cpu_to_le16(EXT3_DIR_REC_LEN(1));
-+      }
-+
-+      len -= EXT3_DIR_REC_LEN(1);
-+      assert(len == 0 || len >= EXT3_DIR_REC_LEN(2));
-+      de = (struct ext3_dir_entry_2 *)
-+                      ((char *) de + le16_to_cpu(de->rec_len));
-+      if (!journal) {
-+              BUFFER_TRACE(dir_block, "get_write_access");
-+              err = ext3_journal_get_write_access(handle, dir_block);
-+              if (err)
-+                      goto out_journal;
-+      }
-+
-+      de->inode = cpu_to_le32(inode->i_ino);
-+      if (len > 0)
-+              de->rec_len = cpu_to_le16(len);
-+      else
-+              assert(le16_to_cpu(de->rec_len) >= EXT3_DIR_REC_LEN(2));
-+      de->name_len = 2;
-+      strcpy (de->name, "..");
-+      ext3_set_de_type(dir->i_sb, de, S_IFDIR);
-+
-+out_journal:
-+      if (journal) {
-+              BUFFER_TRACE(dir_block, "call ext3_journal_dirty_metadata");
-+              err = ext3_journal_dirty_metadata(handle, dir_block);
-+              ext3_mark_inode_dirty(handle, dir);
-+      }
-+      brelse (dir_block);
-+
-+out:
-+      return err;
-+}
-+
- /*
-  *    ext3_add_entry()
-  *
-@@ -1502,6 +1568,9 @@
-               return -EINVAL;
- #ifdef CONFIG_EXT3_INDEX
-       if (is_dx(dir)) {
-+              if (dentry->d_name.len == 2 &&
-+                  memcmp(dentry->d_name.name, "..", 2) == 0)
-+                      return ext3_update_dotdot(handle, dentry, inode);
-               retval = ext3_dx_add_entry(handle, dentry, inode);
-               if (!retval || (retval != ERR_BAD_DX_DIR))
-                       return retval;
diff --git a/ldiskfs/kernel_patches/patches/ext3-include-fixes-2.6-rhel4.patch b/ldiskfs/kernel_patches/patches/ext3-include-fixes-2.6-rhel4.patch
deleted file mode 100644 (file)
index 9937044..0000000
+++ /dev/null
@@ -1,53 +0,0 @@
-Index: linux-stage/include/linux/ext3_fs.h
-===================================================================
---- linux-stage.orig/include/linux/ext3_fs.h   2005-02-25 14:53:56.424908168 +0200
-+++ linux-stage/include/linux/ext3_fs.h        2005-02-25 14:53:59.376459464 +0200
-@@ -361,12 +361,13 @@
- #define EXT3_MOUNT_IOPEN_NOPRIV               0x100000/* Make iopen world-readable */
- /* Compatibility, for having both ext2_fs.h and ext3_fs.h included at once */
--#ifndef _LINUX_EXT2_FS_H
-+#ifndef clear_opt
- #define clear_opt(o, opt)             o &= ~EXT3_MOUNT_##opt
- #define set_opt(o, opt)                       o |= EXT3_MOUNT_##opt
- #define test_opt(sb, opt)             (EXT3_SB(sb)->s_mount_opt & \
-                                        EXT3_MOUNT_##opt)
--#else
-+#endif
-+#ifndef EXT2_MOUNT_NOLOAD
- #define EXT2_MOUNT_NOLOAD             EXT3_MOUNT_NOLOAD
- #define EXT2_MOUNT_ABORT              EXT3_MOUNT_ABORT
- #define EXT2_MOUNT_DATA_FLAGS         EXT3_MOUNT_DATA_FLAGS
-Index: linux-2.6.18-53.1.21/fs/ext3/super.c
-===================================================================
---- linux-2.6.18-53.1.21.orig/fs/ext3/super.c
-+++ linux-2.6.18-53.1.21/fs/ext3/super.c
-@@ -677,6 +677,7 @@ enum {
-       Opt_usrjquota, Opt_grpjquota, Opt_offusrjquota, Opt_offgrpjquota,
-       Opt_jqfmt_vfsold, Opt_jqfmt_vfsv0, Opt_quota, Opt_noquota,
-       Opt_ignore, Opt_barrier, Opt_err, Opt_resize, Opt_usrquota,
-+      Opt_iopen, Opt_noiopen, Opt_iopen_nopriv,
-       Opt_grpquota
- };
-@@ -726,6 +727,9 @@ static match_table_t tokens = {
-       {Opt_noquota, "noquota"},
-       {Opt_quota, "quota"},
-       {Opt_usrquota, "usrquota"},
-+      {Opt_iopen, "iopen"},
-+      {Opt_noiopen, "noiopen"},
-+      {Opt_iopen_nopriv, "iopen_nopriv"},
-       {Opt_barrier, "barrier=%u"},
-       {Opt_err, NULL},
-       {Opt_resize, "resize"},
-@@ -1041,6 +1045,10 @@ clear_qf_name:
-                       else
-                               clear_opt(sbi->s_mount_opt, BARRIER);
-                       break;
-+              case Opt_iopen:
-+              case Opt_noiopen:
-+              case Opt_iopen_nopriv:
-+                      break;
-               case Opt_ignore:
-                       break;
-               case Opt_resize:
diff --git a/ldiskfs/kernel_patches/patches/ext3-inode-version-2.6.18-vanilla.patch b/ldiskfs/kernel_patches/patches/ext3-inode-version-2.6.18-vanilla.patch
deleted file mode 100644 (file)
index 4bc112d..0000000
+++ /dev/null
@@ -1,466 +0,0 @@
-Index: linux-2.6.18/fs/ext3/inode.c
-===================================================================
---- linux-2.6.18.orig/fs/ext3/inode.c
-+++ linux-2.6.18/fs/ext3/inode.c
-@@ -2690,6 +2690,13 @@ void ext3_read_inode(struct inode * inod
-       EXT3_INODE_GET_XTIME(i_atime, inode, raw_inode);
-       EXT3_EINODE_GET_XTIME(i_crtime, ei, raw_inode);
-+      ei->i_fs_version = le32_to_cpu(raw_inode->i_disk_version);
-+      if (EXT3_INODE_SIZE(inode->i_sb) > EXT3_GOOD_OLD_INODE_SIZE) {
-+              if (EXT3_FITS_IN_INODE(raw_inode, ei, i_version_hi))
-+                      ei->i_fs_version |= (__u64)(le32_to_cpu(raw_inode->i_version_hi))
-+                                                                       << 32;
-+      }
-+
-       if (S_ISREG(inode->i_mode)) {
-               inode->i_op = &ext3_file_inode_operations;
-               inode->i_fop = &ext3_file_operations;
-@@ -2828,8 +2835,14 @@ static int ext3_do_update_inode(handle_t
-       } else for (block = 0; block < EXT3_N_BLOCKS; block++)
-               raw_inode->i_block[block] = ei->i_data[block];
--      if (ei->i_extra_isize)
-+      raw_inode->i_disk_version = cpu_to_le32(ei->i_fs_version);
-+      if (ei->i_extra_isize) {
-+              if (EXT3_FITS_IN_INODE(raw_inode, ei, i_version_hi)) {
-+                      raw_inode->i_version_hi = cpu_to_le32(ei->i_fs_version
-+                                                                      >> 32);
-+              }
-               raw_inode->i_extra_isize = cpu_to_le16(ei->i_extra_isize);
-+      }
-       BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
-       rc = ext3_journal_dirty_metadata(handle, bh);
-@@ -3103,10 +3116,32 @@ ext3_reserve_inode_write(handle_t *handl
- int ext3_mark_inode_dirty(handle_t *handle, struct inode *inode)
- {
-       struct ext3_iloc iloc;
--      int err;
-+      int err, ret;
-+      static int expand_message;
-       might_sleep();
-       err = ext3_reserve_inode_write(handle, inode, &iloc);
-+      if (EXT3_I(inode)->i_extra_isize <
-+          EXT3_SB(inode->i_sb)->s_want_extra_isize &&
-+          !(EXT3_I(inode)->i_state & EXT3_STATE_NO_EXPAND)) {
-+              /* We need extra buffer credits since we may write into EA block
-+               * with this same handle */
-+              if ((ext3_journal_extend(handle,
-+                           EXT3_DATA_TRANS_BLOCKS(inode->i_sb))) == 0) {
-+                      ret = ext3_expand_extra_isize(inode,
-+                                      EXT3_SB(inode->i_sb)->s_want_extra_isize,
-+                                      iloc, handle);
-+                      if (ret) {
-+                              EXT3_I(inode)->i_state |= EXT3_STATE_NO_EXPAND;
-+                              if (!expand_message) {
-+                                      ext3_warning(inode->i_sb, __FUNCTION__,
-+                                      "Unable to expand inode %lu. Delete some"
-+                                      " EAs or run e2fsck.", inode->i_ino);
-+                                      expand_message = 1;
-+                              }
-+                      }
-+              }
-+      }
-       if (!err)
-               err = ext3_mark_iloc_dirty(handle, inode, &iloc);
-       return err;
-Index: linux-2.6.18/include/linux/ext3_fs.h
-===================================================================
---- linux-2.6.18.orig/include/linux/ext3_fs.h
-+++ linux-2.6.18/include/linux/ext3_fs.h
-@@ -224,6 +224,7 @@ struct ext3_group_desc
- #define EXT3_STATE_JDATA              0x00000001 /* journaled data exists */
- #define EXT3_STATE_NEW                        0x00000002 /* inode is newly created */
- #define EXT3_STATE_XATTR              0x00000004 /* has in-inode xattrs */
-+#define EXT3_STATE_NO_EXPAND          0x00000008 /* No space for expansion */
- /* Used to pass group descriptor data when online resize is done */
- struct ext3_new_group_input {
-@@ -297,7 +298,7 @@ struct ext3_inode {
-       __le32  i_flags;        /* File flags */
-       union {
-               struct {
--                      __u32  l_i_reserved1;
-+                      __u32  l_i_version;
-               } linux1;
-               struct {
-                       __u32  h_i_translator;
-@@ -342,6 +343,7 @@ struct ext3_inode {
-       __le32  i_atime_extra;  /* extra Access time      (nsec << 2 | epoch) */
-       __le32  i_crtime;       /* File Creation time */
-       __le32  i_crtime_extra; /* extra File Creation time (nsec << 2 | epoch) */
-+      __le32  i_version_hi;   /* high 32 bits for 64-bit version */
- };
- #define i_size_high   i_dir_acl
-@@ -404,6 +406,8 @@ do {                                                                              \
-                                      raw_inode->xtime ## _extra);            \
- } while (0)
-+#define i_disk_version osd1.linux1.l_i_version
-+
- #if defined(__KERNEL__) || defined(__linux__)
- #define i_reserved1   osd1.linux1.l_i_reserved1
- #define i_frag                osd2.linux2.l_i_frag
-Index: linux-2.6.18/include/linux/ext3_fs_i.h
-===================================================================
---- linux-2.6.18.orig/include/linux/ext3_fs_i.h
-+++ linux-2.6.18/include/linux/ext3_fs_i.h
-@@ -21,6 +21,8 @@
- #include <linux/seqlock.h>
- #include <linux/mutex.h>
-+#define HAVE_DISK_INODE_VERSION
-+
- /* data type for block offset of block group */
- typedef int ext3_grpblk_t;
-@@ -162,6 +164,8 @@ struct ext3_inode_info {
-       /* mballoc */
-       struct list_head i_prealloc_list;
-       spinlock_t i_prealloc_lock;
-+
-+      __u64 i_fs_version;
- };
- #endif        /* _LINUX_EXT3_FS_I */
-Index: linux-2.6.18/fs/ext3/xattr.c
-===================================================================
---- linux-2.6.18.orig/fs/ext3/xattr.c
-+++ linux-2.6.18/fs/ext3/xattr.c
-@@ -505,6 +505,20 @@ ext3_xattr_release_block(handle_t *handl
-       }
- }
-+static inline size_t ext3_xattr_free_space(struct ext3_xattr_entry *last,
-+                                  size_t *min_offs, void *base, int *total)
-+{
-+      for (; !IS_LAST_ENTRY(last); last = EXT3_XATTR_NEXT(last)) {
-+              *total += EXT3_XATTR_LEN(last->e_name_len);
-+              if (!last->e_value_block && last->e_value_size) {
-+                      size_t offs = le16_to_cpu(last->e_value_offs);
-+                      if (offs < *min_offs)
-+                              *min_offs = offs;
-+              }
-+      }
-+      return (*min_offs - ((void *)last - base) - sizeof(__u32));
-+}
-+
- struct ext3_xattr_info {
-       int name_index;
-       const char *name;
-@@ -945,13 +959,18 @@ ext3_xattr_set_handle(handle_t *handle, 
-       struct ext3_xattr_block_find bs = {
-               .s = { .not_found = -ENODATA, },
-       };
-+      unsigned long no_expand;
-       int error;
-       if (!name)
-               return -EINVAL;
-       if (strlen(name) > 255)
-               return -ERANGE;
-+
-       down_write(&EXT3_I(inode)->xattr_sem);
-+      no_expand = EXT3_I(inode)->i_state & EXT3_STATE_NO_EXPAND;
-+      EXT3_I(inode)->i_state |= EXT3_STATE_NO_EXPAND;
-+
-       error = ext3_get_inode_loc(inode, &is.iloc);
-       if (error)
-               goto cleanup;
-@@ -1009,6 +1028,8 @@ ext3_xattr_set_handle(handle_t *handle, 
-               ext3_xattr_update_super_block(handle, inode->i_sb);
-               inode->i_ctime = ext3_current_time(inode);
-               error = ext3_mark_iloc_dirty(handle, inode, &is.iloc);
-+              if (!value)
-+                      EXT3_I(inode)->i_state &= ~EXT3_STATE_NO_EXPAND;
-               /*
-                * The bh is consumed by ext3_mark_iloc_dirty, even with
-                * error != 0.
-@@ -1021,6 +1042,8 @@ ext3_xattr_set_handle(handle_t *handle, 
- cleanup:
-       brelse(is.iloc.bh);
-       brelse(bs.bh);
-+      if (no_expand == 0)
-+              EXT3_I(inode)->i_state &= ~EXT3_STATE_NO_EXPAND;
-       up_write(&EXT3_I(inode)->xattr_sem);
-       return error;
- }
-@@ -1060,6 +1083,249 @@ retry:
-       return error;
- }
-+static void ext3_xattr_shift_entries(struct ext3_xattr_entry *entry,
-+                                   int value_offs_shift, void *to,
-+                                   void *from, size_t n, int blocksize)
-+{
-+      struct ext3_xattr_entry *last = entry;
-+      int new_offs;
-+
-+      /* Adjust the value offsets of the entries */
-+      for (; !IS_LAST_ENTRY(last); last = EXT3_XATTR_NEXT(last)) {
-+              if (!last->e_value_block && last->e_value_size) {
-+                      new_offs = le16_to_cpu(last->e_value_offs) +
-+                                                      value_offs_shift;
-+                      BUG_ON(new_offs + le32_to_cpu(last->e_value_size) >
-+                             blocksize);
-+                      last->e_value_offs = cpu_to_le16(new_offs);
-+              }
-+      }
-+      /* Shift the entries by n bytes */
-+      memmove(to, from, n);
-+}
-+
-+/* Expand an inode by new_extra_isize bytes.
-+ * Returns 0 on success or negative error number on failure.
-+ */
-+int ext3_expand_extra_isize(struct inode *inode, int new_extra_isize,
-+                          struct ext3_iloc iloc, handle_t *handle)
-+{
-+      struct ext3_inode *raw_inode;
-+      struct ext3_xattr_ibody_header *header;
-+      struct ext3_xattr_entry *entry, *last, *first;
-+      struct buffer_head *bh = NULL;
-+      struct ext3_xattr_ibody_find *is = NULL;
-+      struct ext3_xattr_block_find *bs = NULL;
-+      char *buffer = NULL, *b_entry_name = NULL;
-+      size_t min_offs, free;
-+      int total_ino, total_blk;
-+      void *base, *start, *end;
-+      int extra_isize = 0, error = 0, tried_min_extra_isize = 0;
-+      int s_min_extra_isize = EXT3_SB(inode->i_sb)->s_es->s_min_extra_isize;
-+
-+      down_write(&EXT3_I(inode)->xattr_sem);
-+
-+retry:
-+      if (EXT3_I(inode)->i_extra_isize >= new_extra_isize) {
-+              up_write(&EXT3_I(inode)->xattr_sem);
-+              return 0;
-+      }
-+
-+      raw_inode = ext3_raw_inode(&iloc);
-+
-+      header = IHDR(inode, raw_inode);
-+      entry = IFIRST(header);
-+
-+      /* No extended attributes present */
-+      if (!(EXT3_I(inode)->i_state & EXT3_STATE_XATTR) ||
-+          header->h_magic != cpu_to_le32(EXT3_XATTR_MAGIC)) {
-+              memset((void *)raw_inode + EXT3_GOOD_OLD_INODE_SIZE, 0,
-+                     new_extra_isize);
-+              EXT3_I(inode)->i_extra_isize = new_extra_isize;
-+              goto cleanup;
-+      }
-+
-+      /*
-+       * Check if enough free space is available in the inode to shift the
-+       * entries ahead by new_extra_isize.
-+       */
-+
-+      base = start = entry;
-+      end = (void *)raw_inode + EXT3_SB(inode->i_sb)->s_inode_size;
-+      min_offs = end - base;
-+      last = entry;
-+      total_ino = sizeof(struct ext3_xattr_ibody_header);
-+
-+      free = ext3_xattr_free_space(last, &min_offs, base, &total_ino);
-+      if (free >= new_extra_isize) {
-+              entry = IFIRST(header);
-+              ext3_xattr_shift_entries(entry, EXT3_I(inode)->i_extra_isize -
-+                              new_extra_isize, (void *)raw_inode +
-+                              EXT3_GOOD_OLD_INODE_SIZE + new_extra_isize,
-+                              (void *)header, total_ino,
-+                              inode->i_sb->s_blocksize);
-+              EXT3_I(inode)->i_extra_isize = new_extra_isize;
-+              error = 0;
-+              goto cleanup;
-+      }
-+
-+      /*
-+       * Enough free space isn't available in the inode, check if
-+       * EA block can hold new_extra_isize bytes.
-+       */
-+      if (EXT3_I(inode)->i_file_acl) {
-+              bh = sb_bread(inode->i_sb, EXT3_I(inode)->i_file_acl);
-+              error = -EIO;
-+              if (!bh)
-+                      goto cleanup;
-+              if (ext3_xattr_check_block(bh)) {
-+                      ext3_error(inode->i_sb, __FUNCTION__,
-+                              "inode %lu: bad block "E3FSBLK, inode->i_ino,
-+                              EXT3_I(inode)->i_file_acl);
-+                      error = -EIO;
-+                      goto cleanup;
-+              }
-+              base = BHDR(bh);
-+              first = BFIRST(bh);
-+              end = bh->b_data + bh->b_size;
-+              min_offs = end - base;
-+              free = ext3_xattr_free_space(first, &min_offs, base,
-+                                           &total_blk);
-+              if (free < new_extra_isize) {
-+                      if (!tried_min_extra_isize && s_min_extra_isize) {
-+                              tried_min_extra_isize++;
-+                              new_extra_isize = s_min_extra_isize;
-+                              goto retry;
-+                      }
-+                      error = -1;
-+                      goto cleanup;
-+              }
-+      } else {
-+              free = inode->i_sb->s_blocksize;
-+      }
-+
-+      while (new_extra_isize > 0) {
-+              size_t offs, size, entry_size;
-+              struct ext3_xattr_entry *small_entry = NULL;
-+              struct ext3_xattr_info i = {
-+                      .value = NULL,
-+                      .value_len = 0,
-+              };
-+              unsigned int total_size, shift_bytes, temp = ~0U;
-+
-+              is = (struct ext3_xattr_ibody_find *) kmalloc(sizeof(struct
-+                                       ext3_xattr_ibody_find), GFP_KERNEL);
-+              bs = (struct ext3_xattr_block_find *) kmalloc(sizeof(struct
-+                                       ext3_xattr_block_find), GFP_KERNEL);
-+              memset((void *)is, 0, sizeof(struct ext3_xattr_ibody_find));
-+              memset((void *)bs, 0, sizeof(struct ext3_xattr_block_find));
-+
-+              is->s.not_found = bs->s.not_found = -ENODATA;
-+              is->iloc.bh = NULL;
-+              bs->bh = NULL;
-+
-+              last = IFIRST(header);
-+              /* Find the entry best suited to be pushed into EA block */
-+              entry = NULL;
-+              for (; !IS_LAST_ENTRY(last); last = EXT3_XATTR_NEXT(last)) {
-+                      total_size = EXT3_XATTR_SIZE(le32_to_cpu(last->e_value_size)) +
-+                                      EXT3_XATTR_LEN(last->e_name_len);
-+                      if (total_size <= free && total_size < temp) {
-+                              if (total_size < new_extra_isize) {
-+                                      small_entry = last;
-+                              } else {
-+                                      entry = last;
-+                                      temp = total_size;
-+                              }
-+                      }
-+              }
-+
-+              if (entry == NULL) {
-+                      if (small_entry) {
-+                              entry = small_entry;
-+                      } else {
-+                              if (!tried_min_extra_isize &&
-+                                  s_min_extra_isize) {
-+                                      tried_min_extra_isize++;
-+                                      new_extra_isize = s_min_extra_isize;
-+                                      goto retry;
-+                              }
-+                              error = -1;
-+                              goto cleanup;
-+                      }
-+              }
-+              offs = le16_to_cpu(entry->e_value_offs);
-+              size = le32_to_cpu(entry->e_value_size);
-+              entry_size = EXT3_XATTR_LEN(entry->e_name_len);
-+              i.name_index = entry->e_name_index,
-+              buffer = kmalloc(EXT3_XATTR_SIZE(size), GFP_KERNEL);
-+              b_entry_name = kmalloc(entry->e_name_len + 1, GFP_KERNEL);
-+              /* Save the entry name and the entry value */
-+              memcpy((void *)buffer, (void *)IFIRST(header) + offs,
-+                     EXT3_XATTR_SIZE(size));
-+              memcpy((void *)b_entry_name, (void *)entry->e_name,
-+                     entry->e_name_len);
-+              b_entry_name[entry->e_name_len] = '\0';
-+              i.name = b_entry_name;
-+
-+              error = ext3_get_inode_loc(inode, &is->iloc);
-+              if (error)
-+                      goto cleanup;
-+
-+              error = ext3_xattr_ibody_find(inode, &i, is);
-+              if (error)
-+                      goto cleanup;
-+
-+              /* Remove the chosen entry from the inode */
-+              error = ext3_xattr_ibody_set(handle, inode, &i, is);
-+
-+              entry = IFIRST(header);
-+              if (entry_size + EXT3_XATTR_SIZE(size) >= new_extra_isize)
-+                      shift_bytes = new_extra_isize;
-+              else
-+                      shift_bytes = entry_size + size;
-+              /* Adjust the offsets and shift the remaining entries ahead */
-+              ext3_xattr_shift_entries(entry, EXT3_I(inode)->i_extra_isize -
-+                      shift_bytes, (void *)raw_inode +
-+                      EXT3_GOOD_OLD_INODE_SIZE + extra_isize + shift_bytes,
-+                      (void *)header, total_ino - entry_size,
-+                      inode->i_sb->s_blocksize);
-+
-+              extra_isize += shift_bytes;
-+              new_extra_isize -= shift_bytes;
-+              EXT3_I(inode)->i_extra_isize = extra_isize;
-+
-+              i.name = b_entry_name;
-+              i.value = buffer;
-+              i.value_len = cpu_to_le32(size);
-+              error = ext3_xattr_block_find(inode, &i, bs);
-+              if (error)
-+                      goto cleanup;
-+
-+              /* Add entry which was removed from the inode into the block */
-+              error = ext3_xattr_block_set(handle, inode, &i, bs);
-+              if (error)
-+                      goto cleanup;
-+      }
-+
-+cleanup:
-+      if (b_entry_name)
-+              kfree(b_entry_name);
-+      if (buffer)
-+              kfree(buffer);
-+      if (is) {
-+              brelse(is->iloc.bh);
-+              kfree(is);
-+      }
-+      if (bs)
-+              kfree(bs);
-+      brelse(bh);
-+      up_write(&EXT3_I(inode)->xattr_sem);
-+      return error;
-+}
-+
-+
-+
- /*
-  * ext3_xattr_delete_inode()
-  *
-Index: linux-2.6.18/fs/ext3/xattr.h
-===================================================================
---- linux-2.6.18.orig/fs/ext3/xattr.h
-+++ linux-2.6.18/fs/ext3/xattr.h
-@@ -74,6 +74,9 @@ extern int ext3_xattr_set_handle(handle_
- extern void ext3_xattr_delete_inode(handle_t *, struct inode *);
- extern void ext3_xattr_put_super(struct super_block *);
-+int ext3_expand_extra_isize(struct inode *inode, int new_extra_isize,
-+                          struct ext3_iloc iloc, handle_t *handle);
-+
- extern int init_ext3_xattr(void);
- extern void exit_ext3_xattr(void);
-Index: linux-2.6.18/fs/ext3/ialloc.c
-===================================================================
---- linux-2.6.18.orig/fs/ext3/ialloc.c
-+++ linux-2.6.18/fs/ext3/ialloc.c
-@@ -751,6 +751,7 @@ got:
-       ei->i_dtime = 0;
-       ei->i_block_alloc_info = NULL;
-       ei->i_block_group = group;
-+      ei->i_fs_version = 0;
-       ext3_set_inode_flags(inode);
-       if (IS_DIRSYNC(inode))
diff --git a/ldiskfs/kernel_patches/patches/ext3-journal-chksum-2.6.18-vanilla.patch b/ldiskfs/kernel_patches/patches/ext3-journal-chksum-2.6.18-vanilla.patch
deleted file mode 100644 (file)
index 1d8f299..0000000
+++ /dev/null
@@ -1,81 +0,0 @@
-Index: linux-2.6.18/fs/ext3/super.c
-===================================================================
---- linux-2.6.18.orig/fs/ext3/super.c
-+++ linux-2.6.18/fs/ext3/super.c
-@@ -688,6 +688,9 @@ enum {
-       Opt_user_xattr, Opt_nouser_xattr, Opt_acl, Opt_noacl,
-       Opt_reservation, Opt_noreservation, Opt_noload, Opt_nobh, Opt_bh,
-       Opt_commit, Opt_journal_update, Opt_journal_inum, Opt_journal_dev,
-+#ifdef JFS_FEATURE_COMPAT_CHECKSUM
-+      Opt_journal_checksum, Opt_journal_async_commit,
-+#endif
-       Opt_abort, Opt_data_journal, Opt_data_ordered, Opt_data_writeback,
-       Opt_usrjquota, Opt_grpjquota, Opt_offusrjquota, Opt_offgrpjquota,
-       Opt_jqfmt_vfsold, Opt_jqfmt_vfsv0, Opt_quota, Opt_noquota,
-@@ -730,6 +733,10 @@ static match_table_t tokens = {
-       {Opt_journal_update, "journal=update"},
-       {Opt_journal_inum, "journal=%u"},
-       {Opt_journal_dev, "journal_dev=%u"},
-+#ifdef JFS_FEATURE_COMPAT_CHECKSUM
-+      {Opt_journal_checksum, "journal_checksum"},
-+      {Opt_journal_async_commit, "journal_async_commit"},
-+#endif
-       {Opt_abort, "abort"},
-       {Opt_data_journal, "data=journal"},
-       {Opt_data_ordered, "data=ordered"},
-@@ -924,6 +931,15 @@ static int parse_options (char *options,
-                               return 0;
-                       *journal_devnum = option;
-                       break;
-+#ifdef JFS_FEATURE_COMPAT_CHECKSUM
-+              case Opt_journal_checksum:
-+                      set_opt (sbi->s_mount_opt, JOURNAL_CHECKSUM);
-+                      break;
-+              case Opt_journal_async_commit:
-+                      set_opt (sbi->s_mount_opt, JOURNAL_ASYNC_COMMIT);
-+                      set_opt (sbi->s_mount_opt, JOURNAL_CHECKSUM);
-+                      break;
-+#endif
-               case Opt_noload:
-                       set_opt (sbi->s_mount_opt, NOLOAD);
-                       break;
-@@ -2180,6 +2196,23 @@ static int ext3_fill_super (struct super
-               goto failed_mount3;
-       }
-+#ifdef JFS_FEATURE_COMPAT_CHECKSUM
-+      if (test_opt(sb, JOURNAL_ASYNC_COMMIT)) {
-+              journal_set_features(sbi->s_journal,
-+                              JFS_FEATURE_COMPAT_CHECKSUM, 0,
-+                              JFS_FEATURE_INCOMPAT_ASYNC_COMMIT);
-+      } else if (test_opt(sb, JOURNAL_CHECKSUM)) {
-+              journal_set_features(sbi->s_journal,
-+                              JFS_FEATURE_COMPAT_CHECKSUM, 0, 0);
-+              journal_clear_features(sbi->s_journal, 0, 0,
-+                              JFS_FEATURE_INCOMPAT_ASYNC_COMMIT);
-+      } else {
-+              journal_clear_features(sbi->s_journal,
-+                              JFS_FEATURE_COMPAT_CHECKSUM, 0,
-+                              JFS_FEATURE_INCOMPAT_ASYNC_COMMIT);
-+      }
-+#endif
-+
-       /* We have now updated the journal if required, so we can
-        * validate the data journaling mode. */
-       switch (test_opt(sb, DATA_FLAGS)) {
-Index: linux-2.6.18/include/linux/ext3_fs.h
-===================================================================
---- linux-2.6.18.orig/include/linux/ext3_fs.h
-+++ linux-2.6.18/include/linux/ext3_fs.h
-@@ -476,6 +476,11 @@ do {                                                                             \
- #define EXT3_MOUNT_EXTDEBUG             0x4000000/* Extents debug */
- #define EXT3_MOUNT_MBALLOC            0x8000000/* Buddy allocation support */
-+#ifdef JFS_FEATURE_COMPAT_CHECKSUM
-+#define EXT3_MOUNT_JOURNAL_CHECKSUM     0x10000000 /* Journal checksums */
-+#define EXT3_MOUNT_JOURNAL_ASYNC_COMMIT 0x20000000 /* Journal Async Commit */
-+#endif
-+
- /* Compatibility, for having both ext2_fs.h and ext3_fs.h included at once */
- #ifndef clear_opt
- #define clear_opt(o, opt)             o &= ~EXT3_MOUNT_##opt
diff --git a/ldiskfs/kernel_patches/patches/ext3-kill-dx_root.patch b/ldiskfs/kernel_patches/patches/ext3-kill-dx_root.patch
deleted file mode 100644 (file)
index 1161d6d..0000000
+++ /dev/null
@@ -1,232 +0,0 @@
-Index: b/fs/ext3/namei.c
-===================================================================
---- a/fs/ext3/namei.c
-+++ b/fs/ext3/namei.c
-@@ -115,22 +115,13 @@ struct dx_entry
-  * hash version mod 4 should never be 0.  Sincerely, the paranoia department.
-  */
--struct dx_root
-+struct dx_root_info
- {
--      struct fake_dirent dot;
--      char dot_name[4];
--      struct fake_dirent dotdot;
--      char dotdot_name[4];
--      struct dx_root_info
--      {
--              __le32 reserved_zero;
--              u8 hash_version;
--              u8 info_length; /* 8 */
--              u8 indirect_levels;
--              u8 unused_flags;
--      }
--      info;
--      struct dx_entry entries[0];
-+      __le32 reserved_zero;
-+      u8 hash_version;
-+      u8 info_length; /* 8 */
-+      u8 indirect_levels;
-+      u8 unused_flags;
- };
- struct dx_node
-@@ -174,6 +165,7 @@ typedef enum {
- #define LDP_FLAGS_RANGE 0x07
- #ifdef CONFIG_EXT3_INDEX
-+struct dx_root_info * dx_get_dx_info(struct ext3_dir_entry_2 *de);
- static inline unsigned dx_get_block (struct dx_entry *entry);
- static void dx_set_block (struct dx_entry *entry, unsigned value);
- static inline unsigned dx_get_hash (struct dx_entry *entry);
-@@ -210,6 +202,16 @@ static int ext3_dx_add_entry(handle_t *h
-  * Future: use high four bits of block for coalesce-on-delete flags
-  * Mask them off for now.
-  */
-+struct dx_root_info * dx_get_dx_info(struct ext3_dir_entry_2 *de)
-+{
-+      /* get dotdot first */
-+      de = (struct ext3_dir_entry_2 *)((char *)de + le16_to_cpu(de->rec_len));
-+
-+      /* dx root info is after dotdot entry */
-+      de = (struct ext3_dir_entry_2 *)((char *)de + EXT3_DIR_REC_LEN(2));
-+
-+      return (struct dx_root_info *) de;
-+}
- static inline unsigned dx_get_block (struct dx_entry *entry)
- {
-@@ -362,7 +364,7 @@ dx_probe(struct dentry *dentry, struct i
- {
-       unsigned count, indirect;
-       struct dx_entry *at, *entries, *p, *q, *m;
--      struct dx_root *root;
-+      struct dx_root_info * info;
-       struct buffer_head *bh;
-       struct dx_frame *frame = frame_in;
-       u32 hash;
-@@ -372,46 +374,45 @@ dx_probe(struct dentry *dentry, struct i
-               dir = dentry->d_parent->d_inode;
-       if (!(bh = ext3_bread (NULL,dir, 0, 0, err)))
-               goto fail;
--      root = (struct dx_root *) bh->b_data;
--      if (root->info.hash_version != DX_HASH_TEA &&
--          root->info.hash_version != DX_HASH_HALF_MD4 &&
--          root->info.hash_version != DX_HASH_LEGACY) {
-+
-+      info = dx_get_dx_info((struct ext3_dir_entry_2*)bh->b_data);
-+      if (info->hash_version != DX_HASH_TEA &&
-+          info->hash_version != DX_HASH_HALF_MD4 &&
-+          info->hash_version != DX_HASH_LEGACY) {
-               ext3_warning(dir->i_sb, __FUNCTION__,
-                            "Unrecognised inode hash code %d for directory "
--                           "#%lu", root->info.hash_version, dir->i_ino);
-+                           "#%lu", info->hash_version, dir->i_ino);
-               brelse(bh);
-               *err = ERR_BAD_DX_DIR;
-               goto fail;
-       }
--      hinfo->hash_version = root->info.hash_version;
-+      hinfo->hash_version = info->hash_version;
-       hinfo->seed = EXT3_SB(dir->i_sb)->s_hash_seed;
-       if (dentry)
-               ext3fs_dirhash(dentry->d_name.name, dentry->d_name.len, hinfo);
-       hash = hinfo->hash;
--      if (root->info.unused_flags & 1) {
-+      if (info->unused_flags & 1) {
-               ext3_warning(dir->i_sb, __FUNCTION__,
-                            "Unimplemented inode hash flags: %#06x",
--                           root->info.unused_flags);
-+                           info->unused_flags);
-               brelse(bh);
-               *err = ERR_BAD_DX_DIR;
-               goto fail;
-       }
--      if ((indirect = root->info.indirect_levels) > 1) {
-+      if ((indirect = info->indirect_levels) > 1) {
-               ext3_warning(dir->i_sb, __FUNCTION__,
-                            "Unimplemented inode hash depth: %#06x",
--                           root->info.indirect_levels);
-+                           info->indirect_levels);
-               brelse(bh);
-               *err = ERR_BAD_DX_DIR;
-               goto fail;
-       }
--      entries = (struct dx_entry *) (((char *)&root->info) +
--                                     root->info.info_length);
-+      entries = (struct dx_entry *) (((char *)info) + info->info_length);
--      if (dx_get_limit(entries) != dx_root_limit(dir,
--                                                 root->info.info_length)) {
-+      if (dx_get_limit(entries) != dx_root_limit(dir, info->info_length)) {
-               ext3_warning(dir->i_sb, __FUNCTION__,
-                            "dx entry: limit != root limit");
-               brelse(bh);
-@@ -467,10 +469,12 @@ fail:
- static void dx_release (struct dx_frame *frames)
- {
-+      struct dx_root_info *info;
-+
-       if (frames[0].bh == NULL)
-               return;
--
--      if (((struct dx_root *) frames[0].bh->b_data)->info.indirect_levels)
-+      info = dx_get_dx_info((struct ext3_dir_entry_2*)frames[0].bh->b_data);
-+      if (info->indirect_levels)
-               brelse(frames[1].bh);
-       brelse(frames[0].bh);
- }
-@@ -1419,17 +1423,16 @@ static int make_indexed_dir(handle_t *ha
-       const char      *name = dentry->d_name.name;
-       int             namelen = dentry->d_name.len;
-       struct buffer_head *bh2;
--      struct dx_root  *root;
-       struct dx_frame frames[2], *frame;
-       struct dx_entry *entries;
--      struct ext3_dir_entry_2 *de, *de2;
-+      struct ext3_dir_entry_2 *de, *de2, *dot_de, *dotdot_de;
-       char            *data1, *top;
-       unsigned        len;
-       int             retval;
-       unsigned        blocksize;
-       struct dx_hash_info hinfo;
-       u32             block;
--      struct fake_dirent *fde;
-+      struct dx_root_info *dx_info;
-       blocksize =  dir->i_sb->s_blocksize;
-       dxtrace(printk("Creating index\n"));
-@@ -1439,7 +1442,7 @@ static int make_indexed_dir(handle_t *ha
-               brelse(bh);
-               return retval;
-       }
--      root = (struct dx_root *) bh->b_data;
-+      dot_de = (struct ext3_dir_entry_2 *) bh->b_data;
-       bh2 = ext3_append (handle, dir, &block, &retval);
-       if (!(bh2)) {
-@@ -1450,9 +1453,9 @@ static int make_indexed_dir(handle_t *ha
-       data1 = bh2->b_data;
-       /* The 0th block becomes the root, move the dirents out */
--      fde = &root->dotdot;
--      de = (struct ext3_dir_entry_2 *)((char *)fde + le16_to_cpu(fde->rec_len));
--      len = ((char *) root) + blocksize - (char *) de;
-+      dotdot_de = (struct ext3_dir_entry_2 *)((char *)dot_de + le16_to_cpu(dot_de->rec_len));
-+      de = (struct ext3_dir_entry_2 *)((char *)dotdot_de + le16_to_cpu(dotdot_de->rec_len));
-+      len = ((char *) dot_de) + blocksize - (char *) de;
-       memcpy (data1, de, len);
-       de = (struct ext3_dir_entry_2 *) data1;
-       top = data1 + len;
-@@ -1460,18 +1463,21 @@ static int make_indexed_dir(handle_t *ha
-               de = de2;
-       de->rec_len = cpu_to_le16(data1 + blocksize - (char *) de);
-       /* Initialize the root; the dot dirents already exist */
--      de = (struct ext3_dir_entry_2 *) (&root->dotdot);
--      de->rec_len = cpu_to_le16(blocksize - EXT3_DIR_REC_LEN(2));
--      memset (&root->info, 0, sizeof(root->info));
--      root->info.info_length = sizeof(root->info);
--      root->info.hash_version = EXT3_SB(dir->i_sb)->s_def_hash_version;
--      entries = root->entries;
-+      dotdot_de->rec_len = cpu_to_le16(blocksize - le16_to_cpu(dot_de->rec_len));
-+
-+      /* initialize hashing info */
-+      dx_info = dx_get_dx_info(dot_de);
-+      memset (dx_info, 0, sizeof(*dx_info));
-+      dx_info->info_length = sizeof(*dx_info);
-+      dx_info->hash_version = EXT3_SB(dir->i_sb)->s_def_hash_version;
-+
-+      entries = (void *)dx_info + sizeof(*dx_info);
-       dx_set_block (entries, 1);
-       dx_set_count (entries, 1);
--      dx_set_limit (entries, dx_root_limit(dir, sizeof(root->info)));
-+      dx_set_limit (entries, dx_root_limit(dir, sizeof(*dx_info)));
-       /* Initialize as for dx_probe */
--      hinfo.hash_version = root->info.hash_version;
-+      hinfo.hash_version = dx_info->hash_version;
-       hinfo.seed = EXT3_SB(dir->i_sb)->s_hash_seed;
-       ext3fs_dirhash(name, namelen, &hinfo);
-       frame = frames;
-@@ -1720,6 +1726,7 @@ static int ext3_dx_add_entry(handle_t *h
-                               goto journal_error;
-                       brelse (bh2);
-               } else {
-+                      struct dx_root_info *info;
-                       dxtrace(printk("Creating second level index...\n"));
-                       memcpy((char *) entries2, (char *) entries,
-                              icount * sizeof(struct dx_entry));
-@@ -1728,7 +1735,8 @@ static int ext3_dx_add_entry(handle_t *h
-                       /* Set up root */
-                       dx_set_count(entries, 1);
-                       dx_set_block(entries + 0, newblock);
--                      ((struct dx_root *) frames[0].bh->b_data)->info.indirect_levels = 1;
-+                      info = dx_get_dx_info((struct ext3_dir_entry_2*)frames[0].bh->b_data);
-+                      info->indirect_levels = 1;
-                       /* Add new access path frame */
-                       frame = frames + 1;
diff --git a/ldiskfs/kernel_patches/patches/ext3-lookup-dotdot-2.6.9.patch b/ldiskfs/kernel_patches/patches/ext3-lookup-dotdot-2.6.9.patch
deleted file mode 100644 (file)
index c5c1942..0000000
+++ /dev/null
@@ -1,43 +0,0 @@
-Index: linux-2.6.9-full/fs/ext3/namei.c
-===================================================================
---- linux-2.6.9-full.orig/fs/ext3/namei.c      2006-05-06 01:21:10.000000000 +0400
-+++ linux-2.6.9-full/fs/ext3/namei.c   2006-05-06 01:29:30.000000000 +0400
-@@ -1003,6 +1003,38 @@ static struct dentry *ext3_lookup(struct
-                       return ERR_PTR(-EACCES);
-       }
-+      /* ".." shouldn't go into dcache to preserve dcache hierarchy
-+       * otherwise we'll get parent being a child of actual child.
-+       * see bug 10458 for details -bzzz */
-+      if (inode && (dentry->d_name.name[0] == '.' && (dentry->d_name.len == 1 ||
-+              (dentry->d_name.len == 2 && dentry->d_name.name[1] == '.')))) {
-+              struct dentry *tmp, *goal = NULL;
-+              struct list_head *lp;
-+
-+              /* first, look for an existing dentry - any one is good */
-+              spin_lock(&dcache_lock);
-+              list_for_each(lp, &inode->i_dentry) {
-+                      tmp = list_entry(lp, struct dentry, d_alias);
-+                      goal = tmp;
-+                      dget_locked(goal);
-+                      break;
-+              }
-+              if (goal == NULL) {
-+                      /* there is no alias, we need to make current dentry:
-+                       *  a) inaccessible for __d_lookup()
-+                       *  b) inaccessible for iopen */
-+                      J_ASSERT(list_empty(&dentry->d_alias));
-+                      dentry->d_flags |= DCACHE_NFSFS_RENAMED;
-+                      /* this is d_instantiate() ... */
-+                      list_add(&dentry->d_alias, &inode->i_dentry);
-+                      dentry->d_inode = inode;
-+              }
-+              spin_unlock(&dcache_lock);
-+              if (goal)
-+                      iput(inode);
-+              return goal;
-+      }
-+
-       return d_splice_alias(inode, dentry);
- }
diff --git a/ldiskfs/kernel_patches/patches/ext3-map_inode_page-2.6.18.patch b/ldiskfs/kernel_patches/patches/ext3-map_inode_page-2.6.18.patch
deleted file mode 100644 (file)
index 4bde41b..0000000
+++ /dev/null
@@ -1,86 +0,0 @@
-Index: linux-2.6.18.8/fs/ext3/inode.c
-===================================================================
---- linux-2.6.18.8.orig/fs/ext3/inode.c        2007-06-20 18:10:33.000000000 +0200
-+++ linux-2.6.18.8/fs/ext3/inode.c     2007-06-20 18:53:48.000000000 +0200
-@@ -3222,3 +3222,66 @@ int ext3_change_inode_journal_flag(struc
-       return err;
- }
-+
-+int ext3_map_inode_page(struct inode *inode, struct page *page,
-+                      unsigned long *blocks, int *created, int create)
-+{
-+      unsigned int blocksize, blocks_per_page;
-+      unsigned long iblock;
-+      struct buffer_head dummy;
-+      void *handle;
-+      int i, rc = 0, failed = 0, needed_blocks;
-+
-+      blocksize = inode->i_sb->s_blocksize;
-+      blocks_per_page = PAGE_SIZE >> inode->i_sb->s_blocksize_bits;
-+      iblock = page->index * blocks_per_page;
-+
-+      for (i = 0; i < blocks_per_page; i++, iblock++) {
-+              blocks[i] = ext3_bmap(inode->i_mapping, iblock);
-+              if (blocks[i] == 0) {
-+                      failed++;
-+                      if (created)
-+                              created[i] = -1;
-+              } else if (created) {
-+                      created[i] = 0;
-+              }
-+      }
-+
-+      if (failed == 0 || create == 0)
-+              return 0;
-+
-+      needed_blocks = ext3_writepage_trans_blocks(inode);
-+      handle = ext3_journal_start(inode, needed_blocks);
-+      if (IS_ERR(handle))
-+              return PTR_ERR(handle);
-+
-+      iblock = page->index * blocks_per_page;
-+      for (i = 0; i < blocks_per_page; i++, iblock++) {
-+              if (blocks[i] != 0)
-+                      continue;
-+
-+              rc = ext3_get_blocks_handle(handle, inode, iblock, 1, &dummy, 1, 1);
-+              if (rc < 0) {
-+                      printk(KERN_INFO "ext3_map_inode_page: error reading "
-+                                      "block %ld\n", iblock);
-+                      goto out;
-+              } else {
-+                      if (rc > 1)
-+                              WARN_ON(1);
-+                      rc = 0;
-+              }
-+              /* Unmap any metadata buffers from the block mapping, to avoid
-+               * data corruption due to direct-write from Lustre being
-+               * clobbered by a later flush of the blockdev metadata buffer.*/
-+              if (buffer_new(&dummy))
-+                      unmap_underlying_metadata(dummy.b_bdev,
-+                                      dummy.b_blocknr);
-+              blocks[i] = dummy.b_blocknr;
-+              if (created)
-+                      created[i] = 1;
-+      }
-+
-+out:
-+      ext3_journal_stop(handle);
-+      return rc;
-+}
-Index: linux-2.6.18.8/fs/ext3/super.c
-===================================================================
---- linux-2.6.18.8.orig/fs/ext3/super.c        2007-06-20 18:10:33.000000000 +0200
-+++ linux-2.6.18.8/fs/ext3/super.c     2007-06-20 18:51:12.000000000 +0200
-@@ -2765,6 +2765,10 @@ static void __exit exit_ext3_fs(void)
-       exit_ext3_xattr();
- }
-+int ext3_map_inode_page(struct inode *inode, struct page *page,
-+                      unsigned long *blocks, int *created, int create);
-+EXPORT_SYMBOL(ext3_map_inode_page);
-+
- MODULE_AUTHOR("Remy Card, Stephen Tweedie, Andrew Morton, Andreas Dilger, Theodore Ts'o and others");
- MODULE_DESCRIPTION("Second Extended Filesystem with journaling extensions");
- MODULE_LICENSE("GPL");
diff --git a/ldiskfs/kernel_patches/patches/ext3-max-dir-size.patch b/ldiskfs/kernel_patches/patches/ext3-max-dir-size.patch
deleted file mode 100644 (file)
index 3d901eb..0000000
+++ /dev/null
@@ -1,179 +0,0 @@
-Index: linux-stage/fs/ext3/ialloc.c
-===================================================================
---- linux-stage.orig/fs/ext3/ialloc.c
-+++ linux-stage/fs/ext3/ialloc.c
-@@ -521,12 +521,15 @@ struct inode *ext3_new_inode(handle_t
-               return ERR_PTR(-EPERM);
-       sb = dir->i_sb;
-+      sbi = EXT3_SB(sb);
-+      if (sbi->s_max_dir_size > 0 && i_size_read(dir) >= sbi->s_max_dir_size)
-+              return ERR_PTR(-EFBIG);
-+
-       inode = new_inode(sb);
-       if (!inode)
-               return ERR_PTR(-ENOMEM);
-       ei = EXT3_I(inode);
--      sbi = EXT3_SB(sb);
-       es = sbi->s_es;
-       if (goal) {
-               group = (goal - 1) / EXT3_INODES_PER_GROUP(sb);
-Index: linux-stage/fs/ext3/super.c
-===================================================================
---- linux-stage.orig/fs/ext3/super.c
-+++ linux-stage/fs/ext3/super.c
-@@ -45,6 +45,12 @@
- #include "namei.h"
- #include "group.h"
-+/*
-+ * max directory size tunable
-+ */
-+#define EXT3_DEFAULT_MAX_DIR_SIZE             0
-+#define EXT3_MAX_DIR_SIZE_NAME                "max_dir_size"
-+
- static int ext3_load_journal(struct super_block *, struct ext3_super_block *,
-                            unsigned long journal_devnum);
- static int ext3_create_journal(struct super_block *, struct ext3_super_block *,
-@@ -444,6 +450,7 @@ static void ext3_put_super (struct su
-       }
-       if (sbi->s_mmp_tsk)
-               kthread_stop(sbi->s_mmp_tsk);
-+      remove_proc_entry(EXT3_MAX_DIR_SIZE_NAME, sbi->s_dev_proc);
-       if (sbi->s_dev_proc) {
-               remove_proc_entry(sbi->s_dev_proc->name, proc_root_ext3);
-               sbi->s_dev_proc = NULL;
-@@ -703,7 +710,7 @@ enum {
-       Opt_iopen, Opt_noiopen, Opt_iopen_nopriv,
-       Opt_grpquota,
-       Opt_extents, Opt_noextents, Opt_extdebug,
--      Opt_mballoc, Opt_nomballoc, Opt_stripe,
-+      Opt_mballoc, Opt_nomballoc, Opt_stripe, Opt_maxdirsize
- };
- static match_table_t tokens = {
-@@ -762,8 +769,9 @@ static match_table_t tokens = {
-       {Opt_mballoc, "mballoc"},
-       {Opt_nomballoc, "nomballoc"},
-       {Opt_stripe, "stripe=%u"},
--      {Opt_err, NULL},
-       {Opt_resize, "resize"},
-+      {Opt_maxdirsize, "maxdirsize=%u"},
-+      {Opt_err, NULL}
- };
- static ext3_fsblk_t get_sb_block(void **data)
-@@ -1128,6 +1136,13 @@ clear_qf_name:
-                               return 0;
-                       sbi->s_stripe = option;
-                       break;
-+              case Opt_maxdirsize:
-+                      if (match_int(&args[0], &option))
-+                              return 0;
-+                      if (option <= 0)
-+                              return 0;
-+                      sbi->s_max_dir_size = option;
-+                      break;
-               default:
-                       printk (KERN_ERR
-                               "EXT3-fs: Unrecognized mount option \"%s\" "
-@@ -1875,6 +1890,45 @@ failed:
-       return 1;
- }
-+static int ext3_max_dir_size_read(char *page, char **start, off_t off,
-+                                  int count, int *eof, void *data)
-+{
-+      struct ext3_sb_info *sbi = data;
-+      int len;
-+
-+      *eof = 1;
-+      if (off != 0)
-+              return 0;
-+
-+      len = sprintf(page, "%lu\n", sbi->s_max_dir_size);
-+      *start = page;
-+      return len;
-+}
-+
-+static int ext3_max_dir_size_write(struct file *file, const char *buffer,
-+                                   unsigned long count, void *data)
-+{
-+      struct ext3_sb_info *sbi = data;
-+      char str[32];
-+      unsigned long value;
-+      char *end;
-+
-+      if (count >= sizeof(str)) {
-+              printk(KERN_ERR "EXT3-fs: %s string too long, max %u bytes\n",
-+                     EXT3_MAX_DIR_SIZE_NAME, (int)sizeof(str));
-+              return -EOVERFLOW;
-+      }
-+
-+      if (copy_from_user(str, buffer, count))
-+              return -EFAULT;
-+
-+      value = simple_strtol(str, &end, 0);
-+      if (value < 0)
-+              return -ERANGE;
-+
-+      sbi->s_max_dir_size = value;
-+      return count;
-+}
- static int ext3_fill_super (struct super_block *sb, void *data, int silent)
- {
-@@ -1896,6 +1950,7 @@ static int ext3_fill_super (struct su
-       int i;
-       int needs_recovery;
-       __le32 features;
-+      struct proc_dir_entry *proc;
-       sbi = kmalloc(sizeof(*sbi), GFP_KERNEL);
-       if (!sbi)
-@@ -1924,6 +1979,23 @@ static int ext3_fill_super (struct su
-       unlock_kernel();
-+      sbi->s_max_dir_size = EXT3_DEFAULT_MAX_DIR_SIZE;
-+      proc = create_proc_entry(EXT3_MAX_DIR_SIZE_NAME,
-+                               S_IFREG | S_IRUGO | S_IWUSR, sbi->s_dev_proc);
-+      if (proc == NULL) {
-+              printk(KERN_ERR "EXT3-fs: unable to create %s\n",
-+                     EXT3_MAX_DIR_SIZE_NAME);
-+              remove_proc_entry(EXT3_MAX_DIR_SIZE_NAME, sbi->s_dev_proc);
-+              remove_proc_entry(sb->s_id, proc_root_ext3);
-+              sbi->s_dev_proc = NULL;
-+              sb->s_fs_info = NULL;
-+              kfree(sbi);
-+              return -ENOMEM;
-+      }
-+      proc->data = sbi;
-+      proc->read_proc = ext3_max_dir_size_read;
-+      proc->write_proc = ext3_max_dir_size_write;
-+
-       blocksize = sb_min_blocksize(sb, EXT3_MIN_BLOCK_SIZE);
-       if (!blocksize) {
-               printk(KERN_ERR "EXT3-fs: unable to set blocksize\n");
-@@ -2361,6 +2433,7 @@ failed_mount:
-       ext3_blkdev_remove(sbi);
-       brelse(bh);
- out_fail:
-+      remove_proc_entry(EXT3_MAX_DIR_SIZE_NAME, sbi->s_dev_proc);
-       if (sbi->s_dev_proc) {
-               remove_proc_entry(sbi->s_dev_proc->name, proc_root_ext3);
-               sbi->s_dev_proc = NULL;
-Index: linux-stage/include/linux/ext3_fs_sb.h
-===================================================================
---- linux-stage.orig/include/linux/ext3_fs_sb.h
-+++ linux-stage/include/linux/ext3_fs_sb.h
-@@ -132,6 +132,8 @@ struct ext3_sb_info {
-       unsigned long s_mb_last_group;
-       unsigned long s_mb_last_start;
-+      unsigned long s_max_dir_size;
-+
-       /* history to debug policy */
-       struct ext3_mb_history *s_mb_history;
-       int s_mb_history_cur;
diff --git a/ldiskfs/kernel_patches/patches/ext3-mballoc-pa_free-mismatch.patch b/ldiskfs/kernel_patches/patches/ext3-mballoc-pa_free-mismatch.patch
deleted file mode 100644 (file)
index 311f120..0000000
+++ /dev/null
@@ -1,150 +0,0 @@
-Index: linux-stage/fs/ext3/mballoc.c
-===================================================================
---- linux-stage.orig/fs/ext3/mballoc.c 2010-01-26 23:36:25.000000000 +0800
-+++ linux-stage/fs/ext3/mballoc.c      2010-01-26 23:42:57.000000000 +0800
-@@ -35,6 +35,7 @@
- #include <linux/pagemap.h>
- #include <linux/seq_file.h>
- #include <linux/version.h>
-+#include <linux/genhd.h>
- #include "group.h"
-@@ -360,6 +361,7 @@
-       unsigned short          pa_free;        /* how many blocks are free */
-       unsigned short          pa_linear;      /* consumed in one direction
-                                                * strictly, for group prealloc */
-+      unsigned short          pa_error;
-       spinlock_t              *pa_obj_lock;
-       struct inode            *pa_inode;      /* hack, for history only */
- };
-@@ -3558,6 +3560,7 @@
-       spin_lock_init(&pa->pa_lock);
-       pa->pa_deleted = 0;
-       pa->pa_linear = 0;
-+      pa->pa_error = 0;
-       mb_debug("new inode pa %p: %lu/%lu for %lu\n", pa,
-                       pa->pa_pstart, pa->pa_len, pa->pa_lstart);
-@@ -3615,6 +3618,7 @@
-       spin_lock_init(&pa->pa_lock);
-       pa->pa_deleted = 0;
-       pa->pa_linear = 1;
-+      pa->pa_error = 0;
-       mb_debug("new group pa %p: %lu/%lu for %lu\n", pa,
-                       pa->pa_pstart, pa->pa_len, pa->pa_lstart);
-@@ -3671,7 +3675,10 @@
-       sector_t start;
-       int err = 0, free = 0;
-+      BUG_ON(!ext3_is_group_locked(sb, e3b->bd_group));
-       BUG_ON(pa->pa_deleted == 0);
-+      BUG_ON(pa->pa_linear != 0);
-+      BUG_ON(pa->pa_inode == NULL);
-       ext3_get_group_no_and_offset(sb, pa->pa_pstart, &group, &bit);
-       BUG_ON(group != e3b->bd_group && pa->pa_len != 0);
-       end = bit + pa->pa_len;
-@@ -3704,14 +3711,19 @@
-               mb_free_blocks(pa->pa_inode, e3b, bit, next - bit);
-               bit = next + 1;
-       }
--      if (free != pa->pa_free) {
--              printk("pa %p: logic %lu, phys. %lu, len %lu\n",
--                      pa, (unsigned long) pa->pa_lstart,
--                      (unsigned long) pa->pa_pstart,
--                      (unsigned long) pa->pa_len);
--              printk("free %u, pa_free %u\n", free, pa->pa_free);
--      }
--      BUG_ON(free != pa->pa_free);
-+
-+      /* "free < pa->pa_free" means we maybe double alloc the same blocks,
-+       * otherwise maybe leave some free blocks unavailable, no need to BUG.*/
-+      if ((free > pa->pa_free && !pa->pa_error) || (free < pa->pa_free))
-+              ext3_error(sb, __FUNCTION__, "pa free mismatch: [pa %p] "
-+                            "[phy %lu] [logic %lu] [len %u] [free %u] "
-+                            "[error %u] [inode %lu] [freed %u]", pa,
-+                            (unsigned long)pa->pa_pstart,
-+                            (unsigned long)pa->pa_lstart,
-+                            (unsigned)pa->pa_len, (unsigned)pa->pa_free,
-+                            (unsigned)pa->pa_error, pa->pa_inode->i_ino,
-+                            free);
-+      BUG_ON(pa->pa_free != free);
-       atomic_add(free, &sbi->s_mb_discarded);
-       return err;
-@@ -4189,6 +4201,19 @@
-               *errp = -EDQUOT;
-               return 0;
-       }
-+
-+      if (dev_check_rdonly(sb->s_bdev)) {
-+              struct block_device *bdev = sb->s_bdev;
-+
-+              printk(KERN_WARNING "Alloc from readonly device %s (%#x): "
-+                     "[inode %lu] [logic %lu] [goal %lu] [ll %lu] [pl %lu] "
-+                     "[lr %lu] [pr %lu] [len %lu] [flags %lu]\n",
-+                     bdev->bd_disk ? bdev->bd_disk->disk_name : "",
-+                     bdev->bd_dev, ar->inode->i_ino, ar->logical, ar->goal,
-+                     ar->lleft, ar->pleft, ar->lright, ar->pright, ar->len,
-+                     ar->flags);
-+      }
-+
-       inquota = ar->len;
-       ext3_mb_poll_new_transaction(sb, handle);
-@@ -4217,10 +4242,34 @@
-       }
-       if (likely(ac.ac_status == AC_STATUS_FOUND)) {
--              ext3_mb_mark_diskspace_used(&ac, handle);
--              *errp = 0;
--              block = ext3_grp_offs_to_block(sb, &ac.ac_b_ex);
--              ar->len = ac.ac_b_ex.fe_len;
-+              *errp = ext3_mb_mark_diskspace_used(&ac, handle);
-+              if (!*errp) {
-+                      block = ext3_grp_offs_to_block(sb, &ac.ac_b_ex);
-+                      ar->len = ac.ac_b_ex.fe_len;
-+              } else {
-+                        ac.ac_b_ex.fe_len = 0;
-+                        ar->len = 0;
-+                        ext3_mb_show_ac(&ac);
-+                        if (ac.ac_pa) {
-+                                struct ext3_prealloc_space *pa = ac.ac_pa;
-+
-+                              /* We can not make sure whether the bitmap has
-+                               * been updated or not when fail case. So can
-+                               * not revert pa_free back, just mark pa_error*/
-+                              pa->pa_error++;
-+                                ext3_error(sb, __FUNCTION__,
-+                                            "Updating bitmap error: [err %d] "
-+                                            "[pa %p] [phy %lu] [logic %lu] "
-+                                            "[len %u] [free %u] [error %u] "
-+                                            "[inode %lu]", *errp, pa,
-+                                            (unsigned long)pa->pa_pstart,
-+                                            (unsigned long)pa->pa_lstart,
-+                                            (unsigned)pa->pa_len,
-+                                            (unsigned)pa->pa_free,
-+                                            (unsigned)pa->pa_error,
-+                                      pa->pa_inode ? pa->pa_inode->i_ino : 0);
-+                        }
-+              }
-       } else {
-               freed  = ext3_mb_discard_preallocations(sb, ac.ac_o_ex.fe_len);
-               if (freed)
-@@ -4388,6 +4437,15 @@
-               goto error_return;
-       }
-+      if (dev_check_rdonly(sb->s_bdev)) {
-+              struct block_device *bdev = sb->s_bdev;
-+
-+              printk(KERN_WARNING "Release to readonly device %s (%#x): "
-+                     "[inode %lu] [block %lu] [count %lu] [is_meta %d]\n",
-+                     bdev->bd_disk ? bdev->bd_disk->disk_name : "",
-+                     bdev->bd_dev, inode->i_ino, block, count, metadata);
-+      }
-+
-       ext3_debug("freeing block %lu\n", block);
-       ac.ac_op = EXT3_MB_HISTORY_FREE;
diff --git a/ldiskfs/kernel_patches/patches/ext3-mballoc3-2.6.18.patch b/ldiskfs/kernel_patches/patches/ext3-mballoc3-2.6.18.patch
deleted file mode 100644 (file)
index 4af464c..0000000
+++ /dev/null
@@ -1,608 +0,0 @@
-Index: linux-2.6.18.8/include/linux/ext3_fs_i.h
-===================================================================
---- linux-2.6.18.8.orig/include/linux/ext3_fs_i.h
-+++ linux-2.6.18.8/include/linux/ext3_fs_i.h
-@@ -154,6 +154,10 @@ struct ext3_inode_info {
-       struct inode vfs_inode;
-       struct ext3_ext_cache i_cached_extent;
-+
-+      /* mballoc */
-+      struct list_head i_prealloc_list;
-+      spinlock_t i_prealloc_lock;
- };
- #endif        /* _LINUX_EXT3_FS_I */
-Index: linux-2.6.18.8/include/linux/ext3_fs_sb.h
-===================================================================
---- linux-2.6.18.8.orig/include/linux/ext3_fs_sb.h
-+++ linux-2.6.18.8/include/linux/ext3_fs_sb.h
-@@ -21,8 +21,15 @@
- #include <linux/wait.h>
- #include <linux/blockgroup_lock.h>
- #include <linux/percpu_counter.h>
-+#include <linux/list.h>
- #endif
- #include <linux/rbtree.h>
-+#include <linux/proc_fs.h>
-+
-+struct ext3_buddy_group_blocks;
-+struct ext3_locality_group;
-+struct ext3_mb_history;
-+#define EXT3_BB_MAX_BLOCKS
- /*
-  * third extended-fs super-block data in memory
-Index: linux-2.6.18.8/include/linux/ext3_fs.h
-===================================================================
---- linux-2.6.18.8.orig/include/linux/ext3_fs.h
-+++ linux-2.6.18.8/include/linux/ext3_fs.h
-@@ -17,6 +17,7 @@
- #define _LINUX_EXT3_FS_H
- #include <linux/types.h>
-+#include <linux/ext3_fs_i.h>
- /*
-  * The second extended filesystem constants/structures
-@@ -67,12 +68,12 @@
- struct ext3_allocation_request {
-       struct inode *inode;    /* target inode for block we're allocating */
--      unsigned long logical;  /* logical block in target inode */
--      unsigned long goal;     /* phys. target (a hint) */
--      unsigned long lleft;    /* the closest logical allocated block to the left */
--      unsigned long pleft;    /* phys. block for ^^^ */
--      unsigned long lright;   /* the closest logical allocated block to the right */
--      unsigned long pright;   /* phys. block for ^^^ */
-+      ext3_fsblk_t logical;   /* logical block in target inode */
-+      ext3_fsblk_t goal;      /* phys. target (a hint) */
-+      ext3_fsblk_t lleft;     /* the closest logical allocated block to the left */
-+      ext3_fsblk_t pleft;     /* phys. block for ^^^ */
-+      ext3_fsblk_t lright;    /* the closest logical allocated block to the right */
-+      ext3_fsblk_t pright;    /* phys. block for ^^^ */
-       unsigned long len;      /* how many blocks we want to allocate */
-       unsigned long flags;    /* flags. see above EXT3_MB_HINT_* */
- };
-@@ -400,6 +401,7 @@ struct ext3_inode {
- #define EXT3_MOUNT_IOPEN_NOPRIV               0x800000/* Make iopen world-readable */
- #define EXT3_MOUNT_EXTENTS            0x2000000/* Extents support */
- #define EXT3_MOUNT_EXTDEBUG             0x4000000/* Extents debug */
-+#define EXT3_MOUNT_MBALLOC            0x8000000/* Buddy allocation support */
- /* Compatibility, for having both ext2_fs.h and ext3_fs.h included at once */
- #ifndef clear_opt
-@@ -787,12 +789,12 @@ ext3_group_first_block_no(struct super_b
- /* balloc.c */
- extern int ext3_bg_has_super(struct super_block *sb, int group);
- extern unsigned long ext3_bg_num_gdb(struct super_block *sb, int group);
--extern ext3_fsblk_t ext3_new_block (handle_t *handle, struct inode *inode,
-+extern ext3_fsblk_t ext3_new_block_old (handle_t *handle, struct inode *inode,
-                       ext3_fsblk_t goal, int *errp);
--extern ext3_fsblk_t ext3_new_blocks (handle_t *handle, struct inode *inode,
-+extern ext3_fsblk_t ext3_new_blocks_old (handle_t *handle, struct inode *inode,
-                       ext3_fsblk_t goal, unsigned long *count, int *errp);
- extern void ext3_free_blocks (handle_t *handle, struct inode *inode,
--                      ext3_fsblk_t block, unsigned long count);
-+                      ext3_fsblk_t block, unsigned long count, int metadata);
- extern void ext3_free_blocks_sb (handle_t *handle, struct super_block *sb,
-                                ext3_fsblk_t block, unsigned long count,
-                               unsigned long *pdquot_freed_blocks);
-@@ -836,15 +838,45 @@ extern long ext3_mb_stats;
- extern long ext3_mb_max_to_scan;
- extern int ext3_mb_init(struct super_block *, int);
- extern int ext3_mb_release(struct super_block *);
--extern unsigned long ext3_mb_new_blocks(handle_t *, struct ext3_allocation_request *, int *);
-+extern ext3_fsblk_t ext3_new_block(handle_t *handle, struct inode *inode,
-+                                 ext3_fsblk_t goal, int *errp);
-+extern ext3_fsblk_t ext3_mb_new_blocks(handle_t *,
-+                              struct ext3_allocation_request *, int *);
- extern int ext3_mb_reserve_blocks(struct super_block *, int);
- extern void ext3_mb_release_blocks(struct super_block *, int);
- extern void ext3_mb_release_blocks(struct super_block *, int);
- extern void ext3_mb_discard_inode_preallocations(struct inode *);
- extern int __init init_ext3_mb_proc(void);
- extern void exit_ext3_mb_proc(void);
--extern void ext3_mb_free_blocks(handle_t *, struct inode *, unsigned long, unsigned long, int, int *);
-+extern void ext3_mb_free_blocks(handle_t *, struct inode *, unsigned long,
-+                              unsigned long, int, unsigned long *);
-+
-+static inline ext3_fsblk_t ext3_new_blocks(handle_t *handle,
-+                                         struct inode *inode,
-+                                         ext3_fsblk_t goal,
-+                                         unsigned long *count, int *errp)
-+{
-+      struct ext3_allocation_request ar;
-+      ext3_fsblk_t ret;
-+      if (!test_opt(inode->i_sb, MBALLOC)) {
-+              ret = ext3_new_blocks_old(handle, inode, goal, count, errp);
-+              return ret;
-+      }
-+
-+      ar.inode = inode;
-+      ar.goal = goal;
-+      ar.len = *count;
-+      ar.logical = 0;
-+      ar.lleft = 0;
-+      ar.pleft = 0;
-+      ar.lright = 0;
-+      ar.pright = 0;
-+      ar.flags = 0;
-+      ret = ext3_mb_new_blocks(handle, &ar, errp);
-+      *count = ar.len;
-+      return ret;
-+}
- /* inode.c */
- int ext3_forget(handle_t *handle, int is_metadata, struct inode *inode,
-Index: linux-2.6.18.8/fs/ext3/super.c
-===================================================================
---- linux-2.6.18.8.orig/fs/ext3/super.c
-+++ linux-2.6.18.8/fs/ext3/super.c
-@@ -688,6 +688,7 @@ enum {
-       Opt_iopen, Opt_noiopen, Opt_iopen_nopriv,
-       Opt_grpquota,
-       Opt_extents, Opt_noextents, Opt_extdebug,
-+      Opt_mballoc, Opt_nomballoc, Opt_stripe,
- };
- static match_table_t tokens = {
-@@ -743,6 +744,9 @@ static match_table_t tokens = {
-       {Opt_extents, "extents"},
-       {Opt_noextents, "noextents"},
-       {Opt_extdebug, "extdebug"},
-+      {Opt_mballoc, "mballoc"},
-+      {Opt_nomballoc, "nomballoc"},
-+      {Opt_stripe, "stripe=%u"},
-       {Opt_err, NULL},
-       {Opt_resize, "resize"},
- };
-@@ -1096,6 +1100,19 @@ clear_qf_name:
-               case Opt_extdebug:
-                       set_opt (sbi->s_mount_opt, EXTDEBUG);
-                       break;
-+              case Opt_mballoc:
-+                      set_opt(sbi->s_mount_opt, MBALLOC);
-+                      break;
-+              case Opt_nomballoc:
-+                      clear_opt(sbi->s_mount_opt, MBALLOC);
-+                      break;
-+              case Opt_stripe:
-+                      if (match_int(&args[0], &option))
-+                              return 0;
-+                      if (option < 0)
-+                              return 0;
-+                      sbi->s_stripe = option;
-+                      break;
-               default:
-                       printk (KERN_ERR
-                               "EXT3-fs: Unrecognized mount option \"%s\" "
-@@ -1826,6 +1843,7 @@ static int ext3_fill_super (struct super
-               "writeback");
-       ext3_ext_init(sb);
-+      ext3_mb_init(sb, needs_recovery);
-       lock_kernel();
-       return 0;
-Index: linux-2.6.18.8/fs/ext3/extents.c
-===================================================================
---- linux-2.6.18.8.orig/fs/ext3/extents.c
-+++ linux-2.6.18.8/fs/ext3/extents.c
-@@ -801,7 +801,7 @@ cleanup:
-               for (i = 0; i < depth; i++) {
-                       if (!ablocks[i])
-                               continue;
--                      ext3_free_blocks(handle, inode, ablocks[i], 1);
-+                      ext3_free_blocks(handle, inode, ablocks[i], 1, 1);
-               }
-       }
-       kfree(ablocks);
-@@ -1619,7 +1619,7 @@ int ext3_ext_rm_idx(handle_t *handle, st
-       ext_debug(inode, "index is empty, remove it, free block %lu\n", leaf);
-       bh = sb_find_get_block(inode->i_sb, leaf);
-       ext3_forget(handle, 1, inode, bh, leaf);
--      ext3_free_blocks(handle, inode, leaf, 1);
-+      ext3_free_blocks(handle, inode, leaf, 1, 1);
-       return err;
- }
-@@ -1678,7 +1678,7 @@ static int ext3_remove_blocks(handle_t *
-                               unsigned long from, unsigned long to)
- {
-       struct buffer_head *bh;
--      int i;
-+      int i, metadata = 0;
- #ifdef EXTENTS_STATS
-       {
-@@ -1696,6 +1696,8 @@ static int ext3_remove_blocks(handle_t *
-               spin_unlock(&sbi->s_ext_stats_lock);
-       }
- #endif
-+      if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode))
-+              metadata = 1;
-       if (from >= le32_to_cpu(ex->ee_block)
-           && to == le32_to_cpu(ex->ee_block) + le16_to_cpu(ex->ee_len) - 1) {
-               /* tail removal */
-@@ -1707,7 +1709,7 @@ static int ext3_remove_blocks(handle_t *
-                       bh = sb_find_get_block(inode->i_sb, start + i);
-                       ext3_forget(handle, 0, inode, bh, start + i);
-               }
--              ext3_free_blocks(handle, inode, start, num);
-+              ext3_free_blocks(handle, inode, start, num, metadata);
-       } else if (from == le32_to_cpu(ex->ee_block)
-                  && to <= le32_to_cpu(ex->ee_block) + le16_to_cpu(ex->ee_len) - 1) {
-               printk("strange request: removal %lu-%lu from %u:%u\n",
-@@ -2040,7 +2042,7 @@ int ext3_ext_get_blocks(handle_t *handle
-       struct ext3_extent newex, *ex;
-       int goal, newblock, err = 0, depth;
-       unsigned long allocated = 0;
--      unsigned long next;
-+      struct ext3_allocation_request ar;
-       __clear_bit(BH_New, &bh_result->b_state);
-       ext_debug(inode, "blocks %d/%lu requested for inode %u\n", (int) iblock,
-@@ -2122,18 +2124,36 @@ int ext3_ext_get_blocks(handle_t *handle
-       if (S_ISREG(inode->i_mode) && (!EXT3_I(inode)->i_block_alloc_info))
-               ext3_init_block_alloc_info(inode);
-+      /* find neighbour allocated blocks */
-+      ar.lleft = iblock;
-+      err = ext3_ext_search_left(inode, path, &ar.lleft, &ar.pleft);
-+      if (err)
-+              goto out2;
-+      ar.lright = iblock;
-+      err = ext3_ext_search_right(inode, path, &ar.lright, &ar.pright);
-+      if (err)
-+              goto out2;
-+
-       /* find next allocated block so that we know how many
-        * blocks we can allocate without ovelapping next extent */
--      BUG_ON(iblock < le32_to_cpu(ex->ee_block) + le16_to_cpu(ex->ee_len));
--      next = ext3_ext_next_allocated_block(path);
--      BUG_ON(next <= iblock);
--      allocated = next - iblock;
-+      BUG_ON(ar.pright != 0 && ar.lright <= iblock);
-+      if (ar.pright == 0)
-+              allocated = EXT_MAX_BLOCK - iblock;
-+      else
-+              allocated = ar.lright - iblock;
-       if (allocated > max_blocks)
-               allocated = max_blocks;
-       /* allocate new block */
--      goal = ext3_ext_find_goal(inode, path, iblock);
--      newblock = ext3_new_blocks(handle, inode, goal, &allocated, &err);
-+      ar.inode = inode;
-+      ar.goal = ext3_ext_find_goal(inode, path, iblock);
-+      ar.logical = iblock;
-+      ar.len = allocated;
-+      if (S_ISREG(inode->i_mode))
-+              ar.flags = EXT3_MB_HINT_DATA;
-+      else
-+              ar.flags = 0;
-+      newblock = ext3_mb_new_blocks(handle, &ar, &err);
-       if (!newblock)
-               goto out2;
-       ext_debug(inode, "allocate new block: goal %d, found %d/%lu\n",
-@@ -2143,12 +2163,16 @@ int ext3_ext_get_blocks(handle_t *handle
-       newex.ee_block = cpu_to_le32(iblock);
-       newex.ee_start = cpu_to_le32(newblock);
-       newex.ee_start_hi = 0;
--      newex.ee_len = cpu_to_le16(allocated);
-+      newex.ee_len = cpu_to_le16(ar.len);
-       err = ext3_ext_insert_extent(handle, inode, path, &newex);
-       if (err) {
-               /* free data blocks we just allocated */
--              ext3_free_blocks(handle, inode, le32_to_cpu(newex.ee_start),
--                              le16_to_cpu(newex.ee_len));
-+              /* not a good idea to call discard here directly,
-+               * but otherwise we'd need to call it every free() */
-+              ext3_mb_discard_inode_preallocations(inode);
-+              ext3_free_blocks(handle, inode, newex.ee_start,
-+                               newex.ee_len, 0);
-+
-               goto out2;
-       }
-@@ -2157,6 +2181,7 @@ int ext3_ext_get_blocks(handle_t *handle
-       /* previous routine could use block we allocated */
-       newblock = le32_to_cpu(newex.ee_start);
-+      allocated = le16_to_cpu(newex.ee_len);
-       __set_bit(BH_New, &bh_result->b_state);
-       ext3_ext_put_in_cache(inode, iblock, allocated, newblock,
-@@ -2208,6 +2233,9 @@ void ext3_ext_truncate(struct inode * in
-       mutex_lock(&EXT3_I(inode)->truncate_mutex);
-       ext3_ext_invalidate_cache(inode);
-+      /* it's important to discard preallocations under truncate_mutex */
-+      ext3_mb_discard_inode_preallocations(inode);
-+
-       /*
-        * TODO: optimization is possible here
-        * probably we need not scaning at all,
-Index: linux-2.6.18.8/fs/ext3/Makefile
-===================================================================
---- linux-2.6.18.8.orig/fs/ext3/Makefile
-+++ linux-2.6.18.8/fs/ext3/Makefile
-@@ -5,7 +5,7 @@
- obj-$(CONFIG_EXT3_FS) += ext3.o
- ext3-y        := balloc.o bitmap.o dir.o file.o fsync.o ialloc.o inode.o \
--         ioctl.o namei.o super.o symlink.o hash.o resize.o extents.o
-+         ioctl.o namei.o super.o symlink.o hash.o resize.o extents.o mballoc.o
- ext3-$(CONFIG_EXT3_FS_XATTR)   += xattr.o xattr_user.o xattr_trusted.o
- ext3-$(CONFIG_EXT3_FS_POSIX_ACL) += acl.o
-Index: linux-2.6.18.8/fs/ext3/xattr.c
-===================================================================
---- linux-2.6.18.8.orig/fs/ext3/xattr.c
-+++ linux-2.6.18.8/fs/ext3/xattr.c
-@@ -484,7 +484,7 @@ ext3_xattr_release_block(handle_t *handl
-               ea_bdebug(bh, "refcount now=0; freeing");
-               if (ce)
-                       mb_cache_entry_free(ce);
--              ext3_free_blocks(handle, inode, bh->b_blocknr, 1);
-+              ext3_free_blocks(handle, inode, bh->b_blocknr, 1, 1);
-               get_bh(bh);
-               ext3_forget(handle, 1, inode, bh, bh->b_blocknr);
-       } else {
-@@ -805,7 +805,7 @@ inserted:
-                       new_bh = sb_getblk(sb, block);
-                       if (!new_bh) {
- getblk_failed:
--                              ext3_free_blocks(handle, inode, block, 1);
-+                              ext3_free_blocks(handle, inode, block, 1, 1);
-                               error = -EIO;
-                               goto cleanup;
-                       }
-Index: linux-2.6.18.8/fs/ext3/balloc.c
-===================================================================
---- linux-2.6.18.8.orig/fs/ext3/balloc.c
-+++ linux-2.6.18.8/fs/ext3/balloc.c
-@@ -79,7 +79,7 @@ struct ext3_group_desc * ext3_get_group_
-  *
-  * Return buffer_head on success or NULL in case of failure.
-  */
--static struct buffer_head *
-+struct buffer_head *
- read_block_bitmap(struct super_block *sb, unsigned int block_group)
- {
-       struct ext3_group_desc * desc;
-@@ -294,6 +294,8 @@ void ext3_discard_reservation(struct ino
-       struct ext3_reserve_window_node *rsv;
-       spinlock_t *rsv_lock = &EXT3_SB(inode->i_sb)->s_rsv_window_lock;
-+      ext3_mb_discard_inode_preallocations(inode);
-+
-       if (!block_i)
-               return;
-@@ -490,21 +492,25 @@ error_return:
-       return;
- }
--/* Free given blocks, update quota and i_blocks field */
- void ext3_free_blocks(handle_t *handle, struct inode *inode,
--                      ext3_fsblk_t block, unsigned long count)
-+                      ext3_fsblk_t block, unsigned long count, int metadata)
- {
--      struct super_block * sb;
--      unsigned long dquot_freed_blocks;
-+      struct super_block *sb;
-+      unsigned long freed;
-+
-+      /* this isn't the right place to decide whether block is metadata
-+       * inode.c/extents.c knows better, but for safety ... */
-+      if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode) ||
-+                      ext3_should_journal_data(inode))
-+              metadata = 1;
-       sb = inode->i_sb;
--      if (!sb) {
--              printk ("ext3_free_blocks: nonexistent device");
--              return;
--      }
--      ext3_free_blocks_sb(handle, sb, block, count, &dquot_freed_blocks);
--      if (dquot_freed_blocks)
--              DQUOT_FREE_BLOCK(inode, dquot_freed_blocks);
-+      if (!test_opt(sb, MBALLOC) || !EXT3_SB(sb)->s_group_info)
-+              ext3_free_blocks_sb(handle, sb, block, count, &freed);
-+      else
-+              ext3_mb_free_blocks(handle, inode, block, count, metadata, &freed);
-+      if (freed)
-+              DQUOT_FREE_BLOCK(inode, freed);
-       return;
- }
-@@ -1199,7 +1205,7 @@ int ext3_should_retry_alloc(struct super
-  * bitmap, and then for any free bit if that fails.
-  * This function also updates quota and i_blocks field.
-  */
--ext3_fsblk_t ext3_new_blocks(handle_t *handle, struct inode *inode,
-+ext3_fsblk_t ext3_new_blocks_old(handle_t *handle, struct inode *inode,
-                       ext3_fsblk_t goal, unsigned long *count, int *errp)
- {
-       struct buffer_head *bitmap_bh = NULL;
-@@ -1463,7 +1469,7 @@ out:
-       return 0;
- }
--ext3_fsblk_t ext3_new_block(handle_t *handle, struct inode *inode,
-+ext3_fsblk_t ext3_new_block_old(handle_t *handle, struct inode *inode,
-                       ext3_fsblk_t goal, int *errp)
- {
-       unsigned long count = 1;
-Index: linux-2.6.18.8/fs/ext3/inode.c
-===================================================================
---- linux-2.6.18.8.orig/fs/ext3/inode.c
-+++ linux-2.6.18.8/fs/ext3/inode.c
-@@ -560,7 +560,7 @@ static int ext3_alloc_blocks(handle_t *h
-       return ret;
- failed_out:
-       for (i = 0; i <index; i++)
--              ext3_free_blocks(handle, inode, new_blocks[i], 1);
-+              ext3_free_blocks(handle, inode, new_blocks[i], 1, 0);
-       return ret;
- }
-@@ -659,9 +659,9 @@ failed:
-               ext3_journal_forget(handle, branch[i].bh);
-       }
-       for (i = 0; i <indirect_blks; i++)
--              ext3_free_blocks(handle, inode, new_blocks[i], 1);
-+              ext3_free_blocks(handle, inode, new_blocks[i], 1, 0);
--      ext3_free_blocks(handle, inode, new_blocks[i], num);
-+      ext3_free_blocks(handle, inode, new_blocks[i], num, 0);
-       return err;
- }
-@@ -758,9 +758,10 @@ err_out:
-       for (i = 1; i <= num; i++) {
-               BUFFER_TRACE(where[i].bh, "call journal_forget");
-               ext3_journal_forget(handle, where[i].bh);
--              ext3_free_blocks(handle,inode,le32_to_cpu(where[i-1].key),1);
-+              ext3_free_blocks(handle,inode,le32_to_cpu(where[i-1].key), 1,
-+                               0);
-       }
--      ext3_free_blocks(handle, inode, le32_to_cpu(where[num].key), blks);
-+      ext3_free_blocks(handle, inode, le32_to_cpu(where[num].key), blks, 0);
-       return err;
- }
-@@ -1996,7 +1997,7 @@ static void ext3_clear_blocks(handle_t *
-               }
-       }
--      ext3_free_blocks(handle, inode, block_to_free, count);
-+      ext3_free_blocks(handle, inode, block_to_free, count, 0);
- }
- /**
-@@ -2169,7 +2170,7 @@ static void ext3_free_branches(handle_t 
-                               ext3_journal_test_restart(handle, inode);
-                       }
--                      ext3_free_blocks(handle, inode, nr, 1);
-+                      ext3_free_blocks(handle, inode, nr, 1, 1);
-                       if (parent_bh) {
-                               /*
-Index: linux-2.6.18.8/fs/ext3/mballoc.c
-===================================================================
---- linux-2.6.18.8.orig/fs/ext3/mballoc.c
-+++ linux-2.6.18.8/fs/ext3/mballoc.c
-@@ -350,8 +350,8 @@ struct ext3_prealloc_space {
-       spinlock_t              pa_lock;
-       atomic_t                pa_count;
-       unsigned                pa_deleted;
--      unsigned long           pa_pstart;      /* phys. block */
--      unsigned long           pa_lstart;      /* log. block */
-+      ext3_fsblk_t            pa_pstart;      /* phys. block */
-+      ext3_fsblk_t            pa_lstart;      /* log. block */
-       unsigned short          pa_len;         /* len of preallocated chunk */
-       unsigned short          pa_free;        /* how many blocks are free */
-       unsigned short          pa_linear;      /* consumed in one direction
-@@ -460,8 +460,8 @@ static struct proc_dir_entry *proc_root_
- int ext3_create (struct inode *, struct dentry *, int, struct nameidata *);
- struct buffer_head * read_block_bitmap(struct super_block *, unsigned int);
--unsigned long ext3_new_blocks_old(handle_t *handle, struct inode *inode,
--                      unsigned long goal, unsigned long *count, int *errp);
-+ext3_fsblk_t ext3_new_blocks_old(handle_t *handle, struct inode *inode,
-+                      ext3_fsblk_t goal, unsigned long *count, int *errp);
- void ext3_mb_release_blocks(struct super_block *, int);
- void ext3_mb_poll_new_transaction(struct super_block *, handle_t *);
- void ext3_mb_free_committed_blocks(struct super_block *);
-@@ -479,7 +479,7 @@ int ext3_mb_destroy_per_dev_proc(struct 
-  * Calculate the block group number and offset, given a block number
-  */
- static void ext3_get_group_no_and_offset(struct super_block *sb,
--                                      unsigned long blocknr,
-+                                      ext3_fsblk_t blocknr,
-                                       unsigned long *blockgrpp,
-                                       unsigned long *offsetp)
- {
-@@ -517,12 +517,12 @@ ext3_is_group_locked(struct super_block 
-                                       &EXT3_GROUP_INFO(sb, group)->bb_state);
- }
--unsigned long ext3_grp_offs_to_block(struct super_block *sb,
-+ext3_fsblk_t ext3_grp_offs_to_block(struct super_block *sb,
-                                       struct ext3_free_extent *fex)
- {
--      unsigned long block;
-+      ext3_fsblk_t block;
--      block = (unsigned long) fex->fe_group * EXT3_BLOCKS_PER_GROUP(sb)
-+      block = (ext3_fsblk_t) fex->fe_group * EXT3_BLOCKS_PER_GROUP(sb)
-                       + fex->fe_start
-                       + le32_to_cpu(EXT3_SB(sb)->s_es->s_first_data_block);
-       return block;
-@@ -3202,7 +3202,7 @@ void ext3_mb_collect_stats(struct ext3_a
- void ext3_mb_use_inode_pa(struct ext3_allocation_context *ac,
-                               struct ext3_prealloc_space *pa)
- {
--      unsigned long start, len;
-+      ext3_fsblk_t start, len;
-       /* found preallocated blocks, use them */
-       start = pa->pa_pstart + (ac->ac_o_ex.fe_logical - pa->pa_lstart);
-@@ -4053,13 +4053,13 @@ int ext3_mb_discard_preallocations(struc
-  * it tries to use preallocation first, then falls back
-  * to usual allocation
-  */
--unsigned long ext3_mb_new_blocks(handle_t *handle,
-+ext3_fsblk_t ext3_mb_new_blocks(handle_t *handle,
-                                struct ext3_allocation_request *ar, int *errp)
- {
-       struct ext3_allocation_context ac;
-       struct ext3_sb_info *sbi;
-       struct super_block *sb;
--      unsigned long block = 0;
-+      ext3_fsblk_t block = 0;
-       int freed, inquota;
-       sb = ar->inode->i_sb;
-@@ -4070,8 +4070,8 @@ unsigned long ext3_mb_new_blocks(handle_
-               if (ext3_mballoc_warning++ == 0)
-                       printk(KERN_ERR "EXT3-fs: multiblock request with "
-                                       "mballoc disabled!\n");
--              ar->len = 1;
--              block = ext3_new_block_old(handle, ar->inode, ar->goal, errp);
-+              block = ext3_new_blocks_old(handle, ar->inode, ar->goal,
-+                                          &ar->len, errp);
-               return block;
-       }
-@@ -4135,11 +4135,11 @@ out:
- }
- EXPORT_SYMBOL(ext3_mb_new_blocks);
--int ext3_new_block(handle_t *handle, struct inode *inode,
--                 unsigned long goal, int *errp)
-+ext3_fsblk_t ext3_new_block(handle_t *handle, struct inode *inode,
-+                 ext3_fsblk_t goal, int *errp)
- {
-       struct ext3_allocation_request ar;
--      unsigned long ret;
-+      ext3_fsblk_t ret;
-       if (!test_opt(inode->i_sb, MBALLOC)) {
-               ret = ext3_new_block_old(handle, inode, goal, errp);
-@@ -4254,8 +4254,8 @@ int ext3_mb_free_metadata(handle_t *hand
-  * Main entry point into mballoc to free blocks
-  */
- void ext3_mb_free_blocks(handle_t *handle, struct inode *inode,
--                      unsigned long block, unsigned long count,
--                      int metadata, int *freed)
-+                      ext3_fsblk_t block, unsigned long count,
-+                      int metadata, unsigned long *freed)
- {
-       struct buffer_head *bitmap_bh = NULL;
-       struct super_block *sb = inode->i_sb;
diff --git a/ldiskfs/kernel_patches/patches/ext3-mballoc3-core.patch b/ldiskfs/kernel_patches/patches/ext3-mballoc3-core.patch
deleted file mode 100644 (file)
index 678d878..0000000
+++ /dev/null
@@ -1,4777 +0,0 @@
-Index: linux-stage/include/linux/ext3_fs.h
-===================================================================
---- linux-stage.orig/include/linux/ext3_fs.h
-+++ linux-stage/include/linux/ext3_fs.h
-@@ -53,6 +53,31 @@
- #define ext3_debug(f, a...)   do {} while (0)
- #endif
-+#define EXT3_MULTIBLOCK_ALLOCATOR     1
-+
-+#define EXT3_MB_HINT_MERGE            1       /* prefer goal again. length */
-+#define EXT3_MB_HINT_RESERVED         2       /* blocks already reserved */
-+#define EXT3_MB_HINT_METADATA         4       /* metadata is being allocated */
-+#define EXT3_MB_HINT_FIRST            8       /* first blocks in the file */
-+#define EXT3_MB_HINT_BEST             16      /* search for the best chunk */
-+#define EXT3_MB_HINT_DATA             32      /* data is being allocated */
-+#define EXT3_MB_HINT_NOPREALLOC               64      /* don't preallocate (for tails) */
-+#define EXT3_MB_HINT_GROUP_ALLOC      128     /* allocate for locality group */
-+#define EXT3_MB_HINT_GOAL_ONLY                256     /* allocate goal blocks or none */
-+#define EXT3_MB_HINT_TRY_GOAL         512     /* goal is meaningful */
-+
-+struct ext3_allocation_request {
-+      struct inode *inode;    /* target inode for block we're allocating */
-+      unsigned long logical;  /* logical block in target inode */
-+      unsigned long goal;     /* phys. target (a hint) */
-+      unsigned long lleft;    /* the closest logical allocated block to the left */
-+      unsigned long pleft;    /* phys. block for ^^^ */
-+      unsigned long lright;   /* the closest logical allocated block to the right */
-+      unsigned long pright;   /* phys. block for ^^^ */
-+      unsigned long len;      /* how many blocks we want to allocate */
-+      unsigned long flags;    /* flags. see above EXT3_MB_HINT_* */
-+};
-+
- /*
-  * Special inodes numbers
-  */
-@@ -398,6 +423,14 @@ struct ext3_inode {
- #define ext3_find_first_zero_bit      ext2_find_first_zero_bit
- #define ext3_find_next_zero_bit               ext2_find_next_zero_bit
-+#ifndef ext2_find_next_le_bit
-+#ifdef __LITTLE_ENDIAN
-+#define ext2_find_next_le_bit(addr, size, off) find_next_bit((addr), (size), (off))
-+#else
-+#error "mballoc needs a patch for big-endian systems - CFS bug 10634"
-+#endif        /* __LITTLE_ENDIAN */
-+#endif        /* !ext2_find_next_le_bit */
-+
- /*
-  * Maximal mount counts between two filesystem checks
-  */
-@@ -799,6 +832,20 @@ extern unsigned long ext3_count_dirs (st
- extern void ext3_check_inodes_bitmap (struct super_block *);
- extern unsigned long ext3_count_free (struct buffer_head *, unsigned);
-+/* mballoc.c */
-+extern long ext3_mb_stats;
-+extern long ext3_mb_max_to_scan;
-+extern int ext3_mb_init(struct super_block *, int);
-+extern int ext3_mb_release(struct super_block *);
-+extern unsigned long ext3_mb_new_blocks(handle_t *, struct ext3_allocation_request *, int *);
-+extern int ext3_mb_reserve_blocks(struct super_block *, int);
-+extern void ext3_mb_release_blocks(struct super_block *, int);
-+extern void ext3_mb_release_blocks(struct super_block *, int);
-+extern void ext3_mb_discard_inode_preallocations(struct inode *);
-+extern int __init init_ext3_mb_proc(void);
-+extern void exit_ext3_mb_proc(void);
-+extern void ext3_mb_free_blocks(handle_t *, struct inode *, unsigned long, unsigned long, int, int *);
-+
- /* inode.c */
- int ext3_forget(handle_t *handle, int is_metadata, struct inode *inode,
-@@ -845,6 +892,10 @@ extern int ext3_group_extend(struct supe
-                               ext3_fsblk_t n_blocks_count);
- /* super.c */
-+extern struct proc_dir_entry *proc_root_ext3;
-+extern int __init init_ext3_proc(void);
-+extern void exit_ext3_proc(void);
-+
- extern void ext3_error (struct super_block *, const char *, const char *, ...)
-       __attribute__ ((format (printf, 3, 4)));
- extern void __ext3_std_error (struct super_block *, const char *, int);
-Index: linux-stage/include/linux/ext3_fs_sb.h
-===================================================================
---- linux-stage.orig/include/linux/ext3_fs_sb.h
-+++ linux-stage/include/linux/ext3_fs_sb.h
-@@ -89,6 +89,68 @@ struct ext3_sb_info {
-       unsigned long s_ext_blocks;
-       unsigned long s_ext_extents;
- #endif
-+
-+      /* for buddy allocator */
-+      struct ext3_group_info ***s_group_info;
-+      struct inode *s_buddy_cache;
-+      long s_blocks_reserved;
-+      spinlock_t s_reserve_lock;
-+      struct list_head s_active_transaction;
-+      struct list_head s_closed_transaction;
-+      struct list_head s_committed_transaction;
-+      spinlock_t s_md_lock;
-+      tid_t s_last_transaction;
-+      unsigned short *s_mb_offsets, *s_mb_maxs;
-+
-+      /* tunables */
-+      unsigned long s_mb_factor;
-+      unsigned long s_stripe;
-+      unsigned long s_mb_small_req;
-+      unsigned long s_mb_large_req;
-+      unsigned long s_mb_max_to_scan;
-+      unsigned long s_mb_min_to_scan;
-+      unsigned long s_mb_max_groups_to_scan;
-+      unsigned long s_mb_stats;
-+      unsigned long s_mb_order2_reqs;
-+      unsigned long *s_mb_prealloc_table;
-+      unsigned long s_mb_prealloc_table_size;
-+      unsigned long s_mb_group_prealloc;
-+      /* where last allocation was done - for stream allocation */
-+      unsigned long s_mb_last_group;
-+      unsigned long s_mb_last_start;
-+
-+      /* history to debug policy */
-+      struct ext3_mb_history *s_mb_history;
-+      int s_mb_history_cur;
-+      int s_mb_history_max;
-+      int s_mb_history_num;
-+      struct proc_dir_entry *s_dev_proc;
-+      spinlock_t s_mb_history_lock;
-+      int s_mb_history_filter;
-+
-+      /* stats for buddy allocator */
-+      spinlock_t s_mb_pa_lock;
-+      atomic_t s_bal_reqs;    /* number of reqs with len > 1 */
-+      atomic_t s_bal_success; /* we found long enough chunks */
-+      atomic_t s_bal_allocated;       /* in blocks */
-+      atomic_t s_bal_ex_scanned;      /* total extents scanned */
-+      atomic_t s_bal_goals;   /* goal hits */
-+      atomic_t s_bal_breaks;  /* too long searches */
-+      atomic_t s_bal_2orders; /* 2^order hits */
-+      spinlock_t s_bal_lock;
-+      unsigned long s_mb_buddies_generated;
-+      unsigned long long s_mb_generation_time;
-+      atomic_t s_mb_lost_chunks;
-+      atomic_t s_mb_preallocated;
-+      atomic_t s_mb_discarded;
-+
-+      /* locality groups */
-+      struct ext3_locality_group *s_locality_groups;
-+
- };
-+#define EXT3_GROUP_INFO(sb, group)                                       \
-+      EXT3_SB(sb)->s_group_info[(group) >> EXT3_DESC_PER_BLOCK_BITS(sb)] \
-+                               [(group) & (EXT3_DESC_PER_BLOCK(sb) - 1)]
-+
- #endif        /* _LINUX_EXT3_FS_SB */
-Index: linux-stage/fs/ext3/super.c
-===================================================================
---- linux-stage.orig/fs/ext3/super.c
-+++ linux-stage/fs/ext3/super.c
-@@ -392,6 +392,7 @@ static void ext3_put_super (struct super
-       struct ext3_super_block *es = sbi->s_es;
-       int i, err;
-+      ext3_mb_release(sb);
-       ext3_ext_release(sb);
-       ext3_xattr_put_super(sb);
-       err = journal_destroy(sbi->s_journal);
-@@ -438,6 +439,10 @@ static void ext3_put_super (struct super
-               invalidate_bdev(sbi->journal_bdev, 0);
-               ext3_blkdev_remove(sbi);
-       }
-+      if (sbi->s_dev_proc) {
-+              remove_proc_entry(sbi->s_dev_proc->name, proc_root_ext3);
-+              sbi->s_dev_proc = NULL;
-+      }
-       sb->s_fs_info = NULL;
-       kfree(sbi);
-       return;
-@@ -463,6 +468,8 @@ static struct inode *ext3_alloc_inode(st
-       ei->vfs_inode.i_version = 1;
-       memset(&ei->i_cached_extent, 0, sizeof(ei->i_cached_extent));
-+      INIT_LIST_HEAD(&ei->i_prealloc_list);
-+      spin_lock_init(&ei->i_prealloc_lock);
-       return &ei->vfs_inode;
- }
-@@ -1465,6 +1472,7 @@ static int ext3_fill_super (struct super
-       unsigned long journal_devnum = 0;
-       unsigned long def_mount_opts;
-       struct inode *root;
-+      char *devname;
-       int blocksize;
-       int hblock;
-       int db_count;
-@@ -1480,6 +1488,22 @@ static int ext3_fill_super (struct super
-       sbi->s_mount_opt = 0;
-       sbi->s_resuid = EXT3_DEF_RESUID;
-       sbi->s_resgid = EXT3_DEF_RESGID;
-+      devname = kstrdup(sb->s_id, GFP_KERNEL);
-+      if (devname) {
-+              char *p = devname;
-+              while ((p = strchr(p, '/')))
-+                      *p = '!';
-+              sbi->s_dev_proc = proc_mkdir(devname, proc_root_ext3);
-+              if (sbi->s_dev_proc == NULL)
-+                      printk(KERN_WARNING "EXT3-fs warning: unable to create "
-+                                          "procfs entry for %s(%s)\n",
-+                                          sb->s_id, devname);
-+              kfree(devname);
-+      } else {
-+              printk(KERN_WARNING "EXT3-fs warning: cannot allocate memory "
-+                                  "to create procfs entry for %s\n",
-+                                  sb->s_id);
-+      }
-       unlock_kernel();
-@@ -1885,6 +1909,10 @@ failed_mount:
-       ext3_blkdev_remove(sbi);
-       brelse(bh);
- out_fail:
-+      if (sbi->s_dev_proc) {
-+              remove_proc_entry(sbi->s_dev_proc->name, proc_root_ext3);
-+              sbi->s_dev_proc = NULL;
-+      }
-       sb->s_fs_info = NULL;
-       kfree(sbi);
-       lock_kernel();
-@@ -2850,9 +2878,46 @@ static struct file_system_type ext3_fs_t
-                        |FS_HAS_TRYTOFREE,
- };
-+#define EXT3_ROOT "ext3"
-+struct proc_dir_entry *proc_root_ext3;
-+
-+int __init init_ext3_proc(void)
-+{
-+      int ret;
-+
-+      if ((ret = init_ext3_mb_proc()))
-+              goto out;
-+
-+      proc_root_ext3 = proc_mkdir(EXT3_ROOT, proc_root_fs);
-+      if (proc_root_ext3 == NULL) {
-+              printk(KERN_ERR "EXT3-fs: Unable to create %s\n", EXT3_ROOT);
-+              ret = -ENOMEM;
-+              goto out_mb_proc;
-+      }
-+
-+      return 0;
-+
-+out_mb_proc:
-+      exit_ext3_mb_proc();
-+out:
-+      return ret;
-+}
-+
-+void exit_ext3_proc(void)
-+{
-+      exit_ext3_mb_proc();
-+      remove_proc_entry(EXT3_ROOT, proc_root_fs);
-+}
-+
- static int __init init_ext3_fs(void)
- {
--      int err = init_ext3_xattr();
-+      int err;
-+
-+      err = init_ext3_proc();
-+      if (err)
-+              return err;
-+
-+      err = init_ext3_xattr();
-       if (err)
-               return err;
-       err = init_inodecache();
-@@ -2877,6 +2942,7 @@ static void __exit exit_ext3_fs(void)
-       unregister_filesystem(&ext3_fs_type);
-       destroy_inodecache();
-       exit_ext3_xattr();
-+      exit_ext3_proc();
- }
- int ext3_map_inode_page(struct inode *inode, struct page *page,
-Index: linux-stage/fs/ext3/mballoc.c
-===================================================================
---- /dev/null
-+++ linux-stage/fs/ext3/mballoc.c
-@@ -0,0 +1,4486 @@
-+/*
-+ * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
-+ * Written by Alex Zhuravlev <alex.zhuravlev@sun.com>
-+ *
-+ * This program is free software; you can redistribute it and/or modify
-+ * it under the terms of the GNU General Public License version 2 as
-+ * published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-+ * GNU General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public Licens
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-
-+ */
-+
-+
-+/*
-+ * mballoc.c contains the multiblocks allocation routines
-+ */
-+
-+#include <linux/time.h>
-+#include <linux/fs.h>
-+#include <linux/namei.h>
-+#include <linux/ext3_jbd.h>
-+#include <linux/jbd.h>
-+#include <linux/ext3_fs.h>
-+#include <linux/quotaops.h>
-+#include <linux/buffer_head.h>
-+#include <linux/module.h>
-+#include <linux/swap.h>
-+#include <linux/proc_fs.h>
-+#include <linux/pagemap.h>
-+#include <linux/seq_file.h>
-+#include <linux/version.h>
-+
-+/*
-+ * MUSTDO:
-+ *   - test ext3_ext_search_left() and ext3_ext_search_right()
-+ *   - search for metadata in few groups
-+ *
-+ * TODO v4:
-+ *   - normalization should take into account whether file is still open
-+ *   - discard preallocations if no free space left (policy?)
-+ *   - don't normalize tails
-+ *   - quota
-+ *   - reservation for superuser
-+ *
-+ * TODO v3:
-+ *   - bitmap read-ahead (proposed by Oleg Drokin aka green)
-+ *   - track min/max extents in each group for better group selection
-+ *   - mb_mark_used() may allocate chunk right after splitting buddy
-+ *   - tree of groups sorted by number of free blocks
-+ *   - error handling
-+ */
-+
-+/*
-+ * mballoc operates on the following data:
-+ *  - on-disk bitmap
-+ *  - in-core buddy (actually includes buddy and bitmap)
-+ *  - preallocation descriptors (PAs)
-+ *
-+ * there are two types of preallocations:
-+ *  - inode
-+ *    assiged to specific inode and can be used for this inode only.
-+ *    it describes part of inode's space preallocated to specific
-+ *    physical blocks. any block from that preallocated can be used
-+ *    independent. the descriptor just tracks number of blocks left
-+ *    unused. so, before taking some block from descriptor, one must
-+ *    make sure corresponded logical block isn't allocated yet. this
-+ *    also means that freeing any block within descriptor's range
-+ *    must discard all preallocated blocks.
-+ *  - locality group
-+ *    assigned to specific locality group which does not translate to
-+ *    permanent set of inodes: inode can join and leave group. space
-+ *    from this type of preallocation can be used for any inode. thus
-+ *    it's consumed from the beginning to the end.
-+ *
-+ * relation between them can be expressed as:
-+ *    in-core buddy = on-disk bitmap + preallocation descriptors
-+ *
-+ * this mean blocks mballoc considers used are:
-+ *  - allocated blocks (persistent)
-+ *  - preallocated blocks (non-persistent)
-+ *
-+ * consistency in mballoc world means that at any time a block is either
-+ * free or used in ALL structures. notice: "any time" should not be read
-+ * literally -- time is discrete and delimited by locks.
-+ *
-+ *  to keep it simple, we don't use block numbers, instead we count number of
-+ *  blocks: how many blocks marked used/free in on-disk bitmap, buddy and PA.
-+ *
-+ * all operations can be expressed as:
-+ *  - init buddy:                     buddy = on-disk + PAs
-+ *  - new PA:                         buddy += N; PA = N
-+ *  - use inode PA:                   on-disk += N; PA -= N
-+ *  - discard inode PA                        buddy -= on-disk - PA; PA = 0
-+ *  - use locality group PA           on-disk += N; PA -= N
-+ *  - discard locality group PA               buddy -= PA; PA = 0
-+ *  note: 'buddy -= on-disk - PA' is used to show that on-disk bitmap
-+ *        is used in real operation because we can't know actual used
-+ *        bits from PA, only from on-disk bitmap
-+ *
-+ * if we follow this strict logic, then all operations above should be atomic.
-+ * given some of them can block, we'd have to use something like semaphores
-+ * killing performance on high-end SMP hardware. let's try to relax it using
-+ * the following knowledge:
-+ *  1) if buddy is referenced, it's already initialized
-+ *  2) while block is used in buddy and the buddy is referenced,
-+ *     nobody can re-allocate that block
-+ *  3) we work on bitmaps and '+' actually means 'set bits'. if on-disk has
-+ *     bit set and PA claims same block, it's OK. IOW, one can set bit in
-+ *     on-disk bitmap if buddy has same bit set or/and PA covers corresponded
-+ *     block
-+ *
-+ * so, now we're building a concurrency table:
-+ *  - init buddy vs.
-+ *    - new PA
-+ *      blocks for PA are allocated in the buddy, buddy must be referenced
-+ *      until PA is linked to allocation group to avoid concurrent buddy init
-+ *    - use inode PA
-+ *      we need to make sure that either on-disk bitmap or PA has uptodate data
-+ *      given (3) we care that PA-=N operation doesn't interfere with init
-+ *    - discard inode PA
-+ *      the simplest way would be to have buddy initialized by the discard
-+ *    - use locality group PA
-+ *      again PA-=N must be serialized with init
-+ *    - discard locality group PA
-+ *      the simplest way would be to have buddy initialized by the discard
-+ *  - new PA vs.
-+ *    - use inode PA
-+ *      i_truncate_mutex serializes them
-+ *    - discard inode PA
-+ *      discard process must wait until PA isn't used by another process
-+ *    - use locality group PA
-+ *      some mutex should serialize them
-+ *    - discard locality group PA
-+ *      discard process must wait until PA isn't used by another process
-+ *  - use inode PA
-+ *    - use inode PA
-+ *      i_truncate_mutex or another mutex should serializes them
-+ *    - discard inode PA
-+ *      discard process must wait until PA isn't used by another process
-+ *    - use locality group PA
-+ *      nothing wrong here -- they're different PAs covering different blocks
-+ *    - discard locality group PA
-+ *      discard process must wait until PA isn't used by another process
-+ *
-+ * now we're ready to make few consequences:
-+ *  - PA is referenced and while it is no discard is possible
-+ *  - PA is referenced until block isn't marked in on-disk bitmap
-+ *  - PA changes only after on-disk bitmap
-+ *  - discard must not compete with init. either init is done before
-+ *    any discard or they're serialized somehow
-+ *  - buddy init as sum of on-disk bitmap and PAs is done atomically
-+ *
-+ * a special case when we've used PA to emptiness. no need to modify buddy
-+ * in this case, but we should care about concurrent init
-+ *
-+ */
-+
-+ /*
-+ * Logic in few words:
-+ *
-+ *  - allocation:
-+ *    load group
-+ *    find blocks
-+ *    mark bits in on-disk bitmap
-+ *    release group
-+ *
-+ *  - use preallocation:
-+ *    find proper PA (per-inode or group)
-+ *    load group
-+ *    mark bits in on-disk bitmap
-+ *    release group
-+ *    release PA
-+ *
-+ *  - free:
-+ *    load group
-+ *    mark bits in on-disk bitmap
-+ *    release group
-+ *
-+ *  - discard preallocations in group:
-+ *    mark PAs deleted
-+ *    move them onto local list
-+ *    load on-disk bitmap
-+ *    load group
-+ *    remove PA from object (inode or locality group)
-+ *    mark free blocks in-core
-+ *
-+ *  - discard inode's preallocations:
-+ */
-+
-+/*
-+ * Locking rules
-+ *
-+ * Locks:
-+ *  - bitlock on a group      (group)
-+ *  - object (inode/locality) (object)
-+ *  - per-pa lock             (pa)
-+ *
-+ * Paths:
-+ *  - new pa
-+ *    object
-+ *    group
-+ *
-+ *  - find and use pa:
-+ *    pa
-+ *
-+ *  - release consumed pa:
-+ *    pa
-+ *    group
-+ *    object
-+ *
-+ *  - generate in-core bitmap:
-+ *    group
-+ *        pa
-+ *
-+ *  - discard all for given object (inode, locality group):
-+ *    object
-+ *        pa
-+ *    group
-+ *
-+ *  - discard all for given group:
-+ *    group
-+ *        pa
-+ *    group
-+ *        object
-+ *
-+ */
-+
-+/*
-+ * with AGGRESSIVE_CHECK allocator runs consistency checks over
-+ * structures. these checks slow things down a lot
-+ */
-+#define AGGRESSIVE_CHECK__
-+
-+/*
-+ * with DOUBLE_CHECK defined mballoc creates persistent in-core
-+ * bitmaps, maintains and uses them to check for double allocations
-+ */
-+#define DOUBLE_CHECK__
-+
-+/*
-+ */
-+#define MB_DEBUG__
-+#ifdef MB_DEBUG
-+#define mb_debug(fmt,a...)    printk(fmt, ##a)
-+#else
-+#define mb_debug(fmt,a...)
-+#endif
-+
-+/*
-+ * with EXT3_MB_HISTORY mballoc stores last N allocations in memory
-+ * and you can monitor it in /proc/fs/ext3/<dev>/mb_history
-+ */
-+#define EXT3_MB_HISTORY
-+#define EXT3_MB_HISTORY_ALLOC         1       /* allocation */
-+#define EXT3_MB_HISTORY_PREALLOC      2       /* preallocated blocks used */
-+#define EXT3_MB_HISTORY_DISCARD               4       /* preallocation discarded */
-+#define EXT3_MB_HISTORY_FREE          8       /* free */
-+
-+#define EXT3_MB_HISTORY_DEFAULT               (EXT3_MB_HISTORY_ALLOC | \
-+                                       EXT3_MB_HISTORY_PREALLOC | \
-+                                       EXT3_MB_HISTORY_DISCARD | \
-+                                       EXT3_MB_HISTORY_FREE)
-+
-+/*
-+ * How long mballoc can look for a best extent (in found extents)
-+ */
-+#define MB_DEFAULT_MAX_TO_SCAN                200
-+
-+/*
-+ * How long mballoc must look for a best extent
-+ */
-+#define MB_DEFAULT_MIN_TO_SCAN                10
-+
-+/*
-+ * How many groups mballoc will scan looking for the best chunk
-+ */
-+#define MB_DEFAULT_MAX_GROUPS_TO_SCAN 5
-+
-+/*
-+ * with 'ext3_mb_stats' allocator will collect stats that will be
-+ * shown at umount. The collecting costs though!
-+ */
-+#define MB_DEFAULT_STATS              1
-+
-+/*
-+ * files smaller than MB_DEFAULT_STREAM_THRESHOLD are served
-+ * by the stream allocator, which purpose is to pack requests
-+ * as close each to other as possible to produce smooth I/O traffic
-+ */
-+#define MB_DEFAULT_STREAM_THRESHOLD   16      /* 64K */
-+
-+/*
-+ * for which requests use 2^N search using buddies
-+ */
-+#define MB_DEFAULT_ORDER2_REQS                8
-+
-+/*
-+ * default stripe size = 1MB
-+ */
-+#define MB_DEFAULT_STRIPE             256
-+
-+static kmem_cache_t *ext3_pspace_cachep = NULL;
-+
-+#ifdef EXT3_BB_MAX_BLOCKS
-+#undef EXT3_BB_MAX_BLOCKS
-+#endif
-+#define EXT3_BB_MAX_BLOCKS    30
-+
-+struct ext3_free_metadata {
-+      unsigned group;
-+      unsigned short num;
-+      unsigned short blocks[EXT3_BB_MAX_BLOCKS];
-+      struct list_head list;
-+};
-+
-+struct ext3_group_info {
-+      unsigned long   bb_state;
-+      unsigned long   bb_tid;
-+      struct ext3_free_metadata *bb_md_cur;
-+      unsigned short  bb_first_free;
-+      unsigned short  bb_free;
-+      unsigned short  bb_fragments;
-+      struct          list_head bb_prealloc_list;
-+      unsigned long   bb_prealloc_nr;
-+#ifdef DOUBLE_CHECK
-+      void            *bb_bitmap;
-+#endif
-+      unsigned short  bb_counters[];
-+};
-+
-+#define EXT3_GROUP_INFO_NEED_INIT_BIT 0
-+#define EXT3_GROUP_INFO_LOCKED_BIT    1
-+
-+#define EXT3_MB_GRP_NEED_INIT(grp)    \
-+      (test_bit(EXT3_GROUP_INFO_NEED_INIT_BIT, &(grp)->bb_state))
-+
-+
-+struct ext3_prealloc_space {
-+      struct list_head        pa_inode_list;
-+      struct list_head        pa_group_list;
-+      union {
-+              struct list_head pa_tmp_list;
-+              struct rcu_head pa_rcu;
-+      } u;
-+      spinlock_t              pa_lock;
-+      atomic_t                pa_count;
-+      unsigned                pa_deleted;
-+      unsigned long           pa_pstart;      /* phys. block */
-+      unsigned long           pa_lstart;      /* log. block */
-+      unsigned short          pa_len;         /* len of preallocated chunk */
-+      unsigned short          pa_free;        /* how many blocks are free */
-+      unsigned short          pa_linear;      /* consumed in one direction
-+                                               * strictly, for group prealloc */
-+      spinlock_t              *pa_obj_lock;
-+      struct inode            *pa_inode;      /* hack, for history only */
-+};
-+
-+
-+struct ext3_free_extent {
-+      unsigned long fe_logical;
-+      unsigned long fe_start;
-+      unsigned long fe_group;
-+      unsigned long fe_len;
-+};
-+
-+/*
-+ * Locality group:
-+ *   we try to group all related changes together
-+ *   so that writeback can flush/allocate them together as well
-+ */
-+struct ext3_locality_group {
-+      /* for allocator */
-+      struct semaphore        lg_sem;         /* to serialize allocates */
-+      struct list_head        lg_prealloc_list;/* list of preallocations */
-+      spinlock_t              lg_prealloc_lock;
-+};
-+
-+struct ext3_allocation_context {
-+      struct inode *ac_inode;
-+      struct super_block *ac_sb;
-+
-+      /* original request */
-+      struct ext3_free_extent ac_o_ex;
-+
-+      /* goal request (after normalization) */
-+      struct ext3_free_extent ac_g_ex;
-+
-+      /* the best found extent */
-+      struct ext3_free_extent ac_b_ex;
-+
-+      /* copy of the bext found extent taken before preallocation efforts */
-+      struct ext3_free_extent ac_f_ex;
-+
-+      /* number of iterations done. we have to track to limit searching */
-+      unsigned long ac_ex_scanned;
-+      __u16 ac_groups_scanned;
-+      __u16 ac_found;
-+      __u16 ac_tail;
-+      __u16 ac_buddy;
-+      __u16 ac_flags;         /* allocation hints */
-+      __u8 ac_status;
-+      __u8 ac_criteria;
-+      __u8 ac_repeats;
-+      __u8 ac_2order;         /* if request is to allocate 2^N blocks and
-+                               * N > 0, the field stores N, otherwise 0 */
-+      __u8 ac_op;             /* operation, for history only */
-+      struct page *ac_bitmap_page;
-+      struct page *ac_buddy_page;
-+      struct ext3_prealloc_space *ac_pa;
-+      struct ext3_locality_group *ac_lg;
-+};
-+
-+#define AC_STATUS_CONTINUE    1
-+#define AC_STATUS_FOUND               2
-+#define AC_STATUS_BREAK               3
-+
-+struct ext3_mb_history {
-+      struct ext3_free_extent orig;   /* orig allocation */
-+      struct ext3_free_extent goal;   /* goal allocation */
-+      struct ext3_free_extent result; /* result allocation */
-+      unsigned pid;
-+      unsigned ino;
-+      __u16 found;    /* how many extents have been found */
-+      __u16 groups;   /* how many groups have been scanned */
-+      __u16 tail;     /* what tail broke some buddy */
-+      __u16 buddy;    /* buddy the tail ^^^ broke */
-+      __u16 flags;
-+      __u8 cr:8;      /* which phase the result extent was found at */
-+      __u8 op:4;
-+      __u8 merged:1;
-+};
-+
-+struct ext3_buddy {
-+      struct page *bd_buddy_page;
-+      void *bd_buddy;
-+      struct page *bd_bitmap_page;
-+      void *bd_bitmap;
-+      struct ext3_group_info *bd_info;
-+      struct super_block *bd_sb;
-+      unsigned bd_group;
-+      unsigned bd_blkbits;
-+};
-+#define EXT3_MB_BITMAP(e3b)   ((e3b)->bd_bitmap)
-+#define EXT3_MB_BUDDY(e3b)    ((e3b)->bd_buddy)
-+
-+#ifndef EXT3_MB_HISTORY
-+#define ext3_mb_store_history(ac)
-+#else
-+static void ext3_mb_store_history(struct ext3_allocation_context *ac);
-+#endif
-+
-+#define in_range(b, first, len)       ((b) >= (first) && (b) <= (first) + (len) - 1)
-+
-+int ext3_create (struct inode *, struct dentry *, int, struct nameidata *);
-+struct buffer_head * read_block_bitmap(struct super_block *, unsigned int);
-+unsigned long ext3_new_blocks_old(handle_t *handle, struct inode *inode,
-+                      unsigned long goal, unsigned long *count, int *errp);
-+void ext3_mb_release_blocks(struct super_block *, int);
-+void ext3_mb_poll_new_transaction(struct super_block *, handle_t *);
-+void ext3_mb_free_committed_blocks(struct super_block *);
-+int ext3_mb_generate_from_pa(struct super_block *sb, void *bitmap, int group);
-+void ext3_mb_free_consumed_preallocations(struct ext3_allocation_context *ac);
-+void ext3_mb_return_to_preallocation(struct inode *inode, struct ext3_buddy *e3b,
-+                                      sector_t block, int count);
-+void ext3_mb_show_ac(struct ext3_allocation_context *ac);
-+void ext3_mb_check_with_pa(struct ext3_buddy *e3b, int first, int count);
-+void ext3_mb_put_pa(struct ext3_allocation_context *, struct super_block *, struct ext3_prealloc_space *pa);
-+int ext3_mb_init_per_dev_proc(struct super_block *sb);
-+int ext3_mb_destroy_per_dev_proc(struct super_block *sb);
-+
-+/*
-+ * Calculate the block group number and offset, given a block number
-+ */
-+static void ext3_get_group_no_and_offset(struct super_block *sb,
-+                                      unsigned long blocknr,
-+                                      unsigned long *blockgrpp,
-+                                      unsigned long *offsetp)
-+{
-+      struct ext3_super_block *es = EXT3_SB(sb)->s_es;
-+      unsigned long offset;
-+
-+      blocknr = blocknr - le32_to_cpu(es->s_first_data_block);
-+      offset = blocknr % EXT3_BLOCKS_PER_GROUP(sb);
-+      blocknr = blocknr / EXT3_BLOCKS_PER_GROUP(sb);
-+      if (offsetp)
-+              *offsetp = offset;
-+      if (blockgrpp)
-+              *blockgrpp = blocknr;
-+
-+}
-+
-+static inline void
-+ext3_lock_group(struct super_block *sb, int group)
-+{
-+      bit_spin_lock(EXT3_GROUP_INFO_LOCKED_BIT,
-+                    &EXT3_GROUP_INFO(sb, group)->bb_state);
-+}
-+
-+static inline void
-+ext3_unlock_group(struct super_block *sb, int group)
-+{
-+      bit_spin_unlock(EXT3_GROUP_INFO_LOCKED_BIT,
-+                      &EXT3_GROUP_INFO(sb, group)->bb_state);
-+}
-+
-+static inline int
-+ext3_is_group_locked(struct super_block *sb, int group)
-+{
-+      return bit_spin_is_locked(EXT3_GROUP_INFO_LOCKED_BIT,
-+                                      &EXT3_GROUP_INFO(sb, group)->bb_state);
-+}
-+
-+unsigned long ext3_grp_offs_to_block(struct super_block *sb,
-+                                      struct ext3_free_extent *fex)
-+{
-+      unsigned long block;
-+
-+      block = (unsigned long) fex->fe_group * EXT3_BLOCKS_PER_GROUP(sb)
-+                      + fex->fe_start
-+                      + le32_to_cpu(EXT3_SB(sb)->s_es->s_first_data_block);
-+      return block;
-+}
-+
-+#if BITS_PER_LONG == 64
-+#define mb_correct_addr_and_bit(bit,addr)             \
-+{                                                     \
-+      bit += ((unsigned long) addr & 7UL) << 3;       \
-+      addr = (void *) ((unsigned long) addr & ~7UL);  \
-+}
-+#elif BITS_PER_LONG == 32
-+#define mb_correct_addr_and_bit(bit,addr)             \
-+{                                                     \
-+      bit += ((unsigned long) addr & 3UL) << 3;       \
-+      addr = (void *) ((unsigned long) addr & ~3UL);  \
-+}
-+#else
-+#error "how many bits you are?!"
-+#endif
-+
-+static inline int mb_test_bit(int bit, void *addr)
-+{
-+      mb_correct_addr_and_bit(bit,addr);
-+      return ext2_test_bit(bit, addr);
-+}
-+
-+static inline void mb_set_bit(int bit, void *addr)
-+{
-+      mb_correct_addr_and_bit(bit,addr);
-+      ext2_set_bit(bit, addr);
-+}
-+
-+static inline void mb_set_bit_atomic(spinlock_t *lock, int bit, void *addr)
-+{
-+      mb_correct_addr_and_bit(bit,addr);
-+      ext2_set_bit_atomic(lock, bit, addr);
-+}
-+
-+static inline void mb_clear_bit(int bit, void *addr)
-+{
-+      mb_correct_addr_and_bit(bit,addr);
-+      ext2_clear_bit(bit, addr);
-+}
-+
-+static inline void mb_clear_bit_atomic(spinlock_t *lock, int bit, void *addr)
-+{
-+      mb_correct_addr_and_bit(bit,addr);
-+      ext2_clear_bit_atomic(lock, bit, addr);
-+}
-+
-+static inline int mb_find_next_zero_bit(void *addr, int max, int start)
-+{
-+      int fix;
-+#if BITS_PER_LONG == 64
-+      fix = ((unsigned long) addr & 7UL) << 3;
-+      addr = (void *) ((unsigned long) addr & ~7UL);
-+#elif BITS_PER_LONG == 32
-+      fix = ((unsigned long) addr & 3UL) << 3;
-+      addr = (void *) ((unsigned long) addr & ~3UL);
-+#else
-+#error "how many bits you are?!"
-+#endif
-+      max += fix;
-+      start += fix;
-+      return ext2_find_next_zero_bit(addr, max, start) - fix;
-+}
-+
-+static inline int mb_find_next_bit(void *addr, int max, int start)
-+{
-+      int fix;
-+#if BITS_PER_LONG == 64
-+      fix = ((unsigned long) addr & 7UL) << 3;
-+      addr = (void *) ((unsigned long) addr & ~7UL);
-+#elif BITS_PER_LONG == 32
-+      fix = ((unsigned long) addr & 3UL) << 3;
-+      addr = (void *) ((unsigned long) addr & ~3UL);
-+#else
-+#error "how many bits you are?!"
-+#endif
-+      max += fix;
-+      start += fix;
-+
-+#ifdef __BIG_ENDIAN
-+#else
-+      return find_next_bit(addr, max, start) - fix;
-+#endif
-+}
-+
-+static inline void *mb_find_buddy(struct ext3_buddy *e3b, int order, int *max)
-+{
-+      char *bb;
-+
-+      BUG_ON(EXT3_MB_BITMAP(e3b) == EXT3_MB_BUDDY(e3b));
-+      BUG_ON(max == NULL);
-+
-+      if (order > e3b->bd_blkbits + 1) {
-+              *max = 0;
-+              return NULL;
-+      }
-+
-+      /* at order 0 we see each particular block */
-+      *max = 1 << (e3b->bd_blkbits + 3);
-+      if (order == 0)
-+              return EXT3_MB_BITMAP(e3b);
-+
-+      bb = EXT3_MB_BUDDY(e3b) + EXT3_SB(e3b->bd_sb)->s_mb_offsets[order];
-+      *max = EXT3_SB(e3b->bd_sb)->s_mb_maxs[order];
-+
-+      return bb;
-+}
-+
-+#ifdef DOUBLE_CHECK
-+void mb_free_blocks_double(struct inode *inode, struct ext3_buddy *e3b,
-+                         int first, int count)
-+{
-+      int i;
-+      struct super_block *sb = e3b->bd_sb;
-+
-+      if (unlikely(e3b->bd_info->bb_bitmap == NULL))
-+              return;
-+      BUG_ON(!ext3_is_group_locked(sb, e3b->bd_group));
-+      for (i = 0; i < count; i++) {
-+              if (!mb_test_bit(first + i, e3b->bd_info->bb_bitmap)) {
-+                      unsigned long blocknr;
-+                      blocknr = e3b->bd_group * EXT3_BLOCKS_PER_GROUP(sb);
-+                      blocknr += first + i;
-+                      blocknr +=
-+                          le32_to_cpu(EXT3_SB(sb)->s_es->s_first_data_block);
-+
-+                      ext3_error(sb, __FUNCTION__, "double-free of inode"
-+                                 " %lu's block %lu(bit %u in group %u)\n",
-+                                 inode ? inode->i_ino : 0, blocknr,
-+                                 first + i, e3b->bd_group);
-+              }
-+              mb_clear_bit(first + i, e3b->bd_info->bb_bitmap);
-+      }
-+}
-+
-+void mb_mark_used_double(struct ext3_buddy *e3b, int first, int count)
-+{
-+      int i;
-+      if (unlikely(e3b->bd_info->bb_bitmap == NULL))
-+              return;
-+      BUG_ON(!ext3_is_group_locked(e3b->bd_sb, e3b->bd_group));
-+      for (i = 0; i < count; i++) {
-+              BUG_ON(mb_test_bit(first + i, e3b->bd_info->bb_bitmap));
-+              mb_set_bit(first + i, e3b->bd_info->bb_bitmap);
-+      }
-+}
-+
-+void mb_cmp_bitmaps(struct ext3_buddy *e3b, void *bitmap)
-+{
-+      if (memcmp(e3b->bd_info->bb_bitmap, bitmap, e3b->bd_sb->s_blocksize)) {
-+              unsigned char *b1, *b2;
-+              int i;
-+              b1 = (unsigned char *) e3b->bd_info->bb_bitmap;
-+              b2 = (unsigned char *) bitmap;
-+              for (i = 0; i < e3b->bd_sb->s_blocksize; i++) {
-+                      if (b1[i] != b2[i]) {
-+                              printk("corruption in group %u at byte %u(%u): "
-+                                     "%x in copy != %x on disk/prealloc\n",
-+                                      e3b->bd_group, i, i * 8, b1[i], b2[i]);
-+                              BUG();
-+                      }
-+              }
-+      }
-+}
-+
-+#else
-+#define mb_free_blocks_double(a,b,c,d)
-+#define mb_mark_used_double(a,b,c)
-+#define mb_cmp_bitmaps(a,b)
-+#endif
-+
-+#ifdef AGGRESSIVE_CHECK
-+
-+#define MB_CHECK_ASSERT(assert)                                               \
-+do {                                                                  \
-+      if (!(assert)) {                                                \
-+              printk (KERN_EMERG                                      \
-+                      "Assertion failure in %s() at %s:%d: \"%s\"\n", \
-+                      function, file, line, # assert);                \
-+              BUG();                                                  \
-+      }                                                               \
-+} while (0)
-+
-+static int __mb_check_buddy(struct ext3_buddy *e3b, char *file,
-+                              const char *function, int line)
-+{
-+      struct super_block *sb = e3b->bd_sb;
-+      int order = e3b->bd_blkbits + 1;
-+      int max, max2, i, j, k, count;
-+      struct ext3_group_info *grp;
-+      int fragments = 0, fstart;
-+      struct list_head *cur;
-+      void *buddy, *buddy2;
-+
-+      if (!test_opt(sb, MBALLOC))
-+              return 0;
-+
-+      {
-+              static int mb_check_counter = 0;
-+              if (mb_check_counter++ % 100 != 0)
-+                      return 0;
-+      }
-+
-+      while (order > 1) {
-+              buddy = mb_find_buddy(e3b, order, &max);
-+              MB_CHECK_ASSERT(buddy);
-+              buddy2 = mb_find_buddy(e3b, order - 1, &max2);
-+              MB_CHECK_ASSERT(buddy2);
-+              MB_CHECK_ASSERT(buddy != buddy2);
-+              MB_CHECK_ASSERT(max * 2 == max2);
-+
-+              count = 0;
-+              for (i = 0; i < max; i++) {
-+
-+                      if (mb_test_bit(i, buddy)) {
-+                              /* only single bit in buddy2 may be 1 */
-+                              if (!mb_test_bit(i << 1, buddy2))
-+                                      MB_CHECK_ASSERT(mb_test_bit((i<<1)+1, buddy2));
-+                              else if (!mb_test_bit((i << 1) + 1, buddy2))
-+                                      MB_CHECK_ASSERT(mb_test_bit(i << 1, buddy2));
-+                              continue;
-+                      }
-+
-+                      /* both bits in buddy2 must be 0 */
-+                      MB_CHECK_ASSERT(mb_test_bit(i << 1, buddy2));
-+                      MB_CHECK_ASSERT(mb_test_bit((i << 1) + 1, buddy2));
-+
-+                      for (j = 0; j < (1 << order); j++) {
-+                              k = (i * (1 << order)) + j;
-+                              MB_CHECK_ASSERT(!mb_test_bit(k, EXT3_MB_BITMAP(e3b)));
-+                      }
-+                      count++;
-+              }
-+              MB_CHECK_ASSERT(e3b->bd_info->bb_counters[order] == count);
-+              order--;
-+      }
-+
-+      fstart = -1;
-+      buddy = mb_find_buddy(e3b, 0, &max);
-+      for (i = 0; i < max; i++) {
-+              if (!mb_test_bit(i, buddy)) {
-+                      MB_CHECK_ASSERT(i >= e3b->bd_info->bb_first_free);
-+                      if (fstart == -1) {
-+                              fragments++;
-+                              fstart = i;
-+                      }
-+                      continue;
-+              }
-+              fstart = -1;
-+              /* check used bits only */
-+              for (j = 0; j < e3b->bd_blkbits + 1; j++) {
-+                      buddy2 = mb_find_buddy(e3b, j, &max2);
-+                      k = i >> j;
-+                      MB_CHECK_ASSERT(k < max2);
-+                      MB_CHECK_ASSERT(mb_test_bit(k, buddy2));
-+              }
-+      }
-+      MB_CHECK_ASSERT(!EXT3_MB_GRP_NEED_INIT(e3b->bd_info));
-+      MB_CHECK_ASSERT(e3b->bd_info->bb_fragments == fragments);
-+
-+      grp = EXT3_GROUP_INFO(sb, e3b->bd_group);
-+      buddy = mb_find_buddy(e3b, 0, &max);
-+      list_for_each(cur, &grp->bb_prealloc_list) {
-+              unsigned long groupnr;
-+              struct ext3_prealloc_space *pa;
-+              pa = list_entry(cur, struct ext3_prealloc_space, group_list);
-+              ext3_get_group_no_and_offset(sb, pa->pstart, &groupnr, &k);
-+              MB_CHECK_ASSERT(groupnr == e3b->bd_group);
-+              for (i = 0; i < pa->len; i++)
-+                      MB_CHECK_ASSERT(mb_test_bit(k + i, buddy));
-+      }
-+      return 0;
-+}
-+#undef MB_CHECK_ASSERT
-+#define mb_check_buddy(e3b) __mb_check_buddy(e3b,__FILE__,__FUNCTION__,__LINE__)
-+#else
-+#define mb_check_buddy(e3b)
-+#endif
-+
-+/* find most significant bit */
-+static int inline fmsb(unsigned short word)
-+{
-+      int order;
-+
-+      if (word > 255) {
-+              order = 7;
-+              word >>= 8;
-+      } else {
-+              order = -1;
-+      }
-+
-+      do {
-+              order++;
-+              word >>= 1;
-+      } while (word != 0);
-+
-+      return order;
-+}
-+
-+static void inline
-+ext3_mb_mark_free_simple(struct super_block *sb, void *buddy, unsigned first,
-+                              int len, struct ext3_group_info *grp)
-+{
-+      struct ext3_sb_info *sbi = EXT3_SB(sb);
-+      unsigned short min, max, chunk, border;
-+
-+      BUG_ON(len >= EXT3_BLOCKS_PER_GROUP(sb));
-+
-+      border = 2 << sb->s_blocksize_bits;
-+
-+      while (len > 0) {
-+              /* find how many blocks can be covered since this position */
-+              max = ffs(first | border) - 1;
-+
-+              /* find how many blocks of power 2 we need to mark */
-+              min = fmsb(len);
-+
-+              if (max < min)
-+                      min = max;
-+              chunk = 1 << min;
-+
-+              /* mark multiblock chunks only */
-+              grp->bb_counters[min]++;
-+              if (min > 0)
-+                      mb_clear_bit(first >> min, buddy + sbi->s_mb_offsets[min]);
-+
-+              len -= chunk;
-+              first += chunk;
-+      }
-+}
-+
-+static int
-+ext3_mb_generate_buddy(struct super_block *sb, void *buddy, void *bitmap,
-+                      int group)
-+{
-+      struct ext3_group_info *grp = EXT3_GROUP_INFO(sb, group);
-+      unsigned short max = EXT3_BLOCKS_PER_GROUP(sb);
-+      unsigned short i = 0, first, len;
-+      unsigned free = 0, fragments = 0;
-+      unsigned long long period = get_cycles();
-+
-+      /* initialize buddy from bitmap which is aggregation
-+       * of on-disk bitmap and preallocations */
-+      i = mb_find_next_zero_bit(bitmap, max, 0);
-+      grp->bb_first_free = i;
-+      while (i < max) {
-+              fragments++;
-+              first = i;
-+              i = ext2_find_next_le_bit(bitmap, max, i);
-+              if (i > max)
-+                      i = max;
-+              len = i - first;
-+              free += len;
-+              if (len > 1)
-+                      ext3_mb_mark_free_simple(sb, buddy, first, len, grp);
-+              else
-+                      grp->bb_counters[0]++;
-+              if (i < max)
-+                      i = mb_find_next_zero_bit(bitmap, max, i);
-+      }
-+      grp->bb_fragments = fragments;
-+
-+      if (free != grp->bb_free) {
-+              struct ext3_group_desc *gdp;
-+              gdp = ext3_get_group_desc (sb, group, NULL);
-+              ext3_error(sb, __FUNCTION__,
-+                      "group %u: %u blocks in bitmap, %u in bb, "
-+                      "%u in gd, %lu pa's\n", group, free, grp->bb_free,
-+                      le16_to_cpu(gdp->bg_free_blocks_count),
-+                      grp->bb_prealloc_nr);
-+              return -EIO;
-+      }
-+
-+      clear_bit(EXT3_GROUP_INFO_NEED_INIT_BIT, &grp->bb_state);
-+
-+      period = get_cycles() - period;
-+      spin_lock(&EXT3_SB(sb)->s_bal_lock);
-+      EXT3_SB(sb)->s_mb_buddies_generated++;
-+      EXT3_SB(sb)->s_mb_generation_time += period;
-+      spin_unlock(&EXT3_SB(sb)->s_bal_lock);
-+
-+      return 0;
-+}
-+
-+static int ext3_mb_init_cache(struct page *page, char *incore)
-+{
-+      int blocksize, blocks_per_page, groups_per_page;
-+      int err = 0, i, first_group, first_block;
-+      struct super_block *sb;
-+      struct buffer_head *bhs;
-+      struct buffer_head **bh;
-+      struct inode *inode;
-+      char *data, *bitmap;
-+
-+      mb_debug("init page %lu\n", page->index);
-+
-+      inode = page->mapping->host;
-+      sb = inode->i_sb;
-+      blocksize = 1 << inode->i_blkbits;
-+      blocks_per_page = PAGE_CACHE_SIZE / blocksize;
-+
-+      groups_per_page = blocks_per_page >> 1;
-+      if (groups_per_page == 0)
-+              groups_per_page = 1;
-+
-+      /* allocate buffer_heads to read bitmaps */
-+      if (groups_per_page > 1) {
-+              err = -ENOMEM;
-+              i = sizeof(struct buffer_head *) * groups_per_page;
-+              bh = kmalloc(i, GFP_NOFS);
-+              if (bh == NULL)
-+                      goto out;
-+              memset(bh, 0, i);
-+      } else
-+              bh = &bhs;
-+
-+      first_group = page->index * blocks_per_page / 2;
-+
-+      /* read all groups the page covers into the cache */
-+      for (i = 0; i < groups_per_page; i++) {
-+              struct ext3_group_desc * desc;
-+
-+              if (first_group + i >= EXT3_SB(sb)->s_groups_count)
-+                      break;
-+
-+              err = -EIO;
-+              desc = ext3_get_group_desc(sb, first_group + i, NULL);
-+              if (desc == NULL)
-+                      goto out;
-+
-+              err = -ENOMEM;
-+              bh[i] = sb_getblk(sb, le32_to_cpu(desc->bg_block_bitmap));
-+              if (bh[i] == NULL)
-+                      goto out;
-+
-+              if (buffer_uptodate(bh[i]))
-+                      continue;
-+
-+              lock_buffer(bh[i]);
-+              if (buffer_uptodate(bh[i])) {
-+                      unlock_buffer(bh[i]);
-+                      continue;
-+              }
-+
-+              get_bh(bh[i]);
-+              bh[i]->b_end_io = end_buffer_read_sync;
-+              submit_bh(READ, bh[i]);
-+              mb_debug("read bitmap for group %u\n", first_group + i);
-+      }
-+
-+      /* wait for I/O completion */
-+      for (i = 0; i < groups_per_page && bh[i]; i++)
-+              wait_on_buffer(bh[i]);
-+
-+      err = -EIO;
-+      for (i = 0; i < groups_per_page && bh[i]; i++)
-+              if (!buffer_uptodate(bh[i]))
-+                      goto out;
-+
-+      err = 0;
-+      first_block = page->index * blocks_per_page;
-+      for (i = 0; i < blocks_per_page && err == 0; i++) {
-+              int group;
-+
-+              group = (first_block + i) >> 1;
-+              if (group >= EXT3_SB(sb)->s_groups_count)
-+                      break;
-+
-+              data = page_address(page) + (i * blocksize);
-+              bitmap = bh[group - first_group]->b_data;
-+
-+              if ((first_block + i) & 1) {
-+                      /* this is block of buddy */
-+                      BUG_ON(incore == NULL);
-+                      mb_debug("put buddy for group %u in page %lu/%x\n",
-+                              group, page->index, i * blocksize);
-+                      memset(data, 0xff, blocksize);
-+                      EXT3_GROUP_INFO(sb, group)->bb_fragments = 0;
-+                      memset(EXT3_GROUP_INFO(sb, group)->bb_counters, 0,
-+                             sizeof(unsigned short)*(sb->s_blocksize_bits+2));
-+                      err = ext3_mb_generate_buddy(sb, data, incore, group);
-+                      incore = NULL;
-+              } else {
-+                      /* this is block of bitmap */
-+                      BUG_ON(incore != NULL);
-+                      mb_debug("put bitmap for group %u in page %lu/%x\n",
-+                              group, page->index, i * blocksize);
-+
-+                      /* see comments in ext3_mb_put_pa() */
-+                      ext3_lock_group(sb, group);
-+                      memcpy(data, bitmap, blocksize);
-+
-+                      /* mark all preallocated blocks used in in-core bitmap */
-+                      err = ext3_mb_generate_from_pa(sb, data, group);
-+                      ext3_unlock_group(sb, group);
-+
-+                      incore = data;
-+              }
-+      }
-+      if (likely(err == 0))
-+              SetPageUptodate(page);
-+
-+out:
-+      if (bh) {
-+              for (i = 0; i < groups_per_page && bh[i]; i++)
-+                      brelse(bh[i]);
-+              if (bh != &bhs)
-+                      kfree(bh);
-+      }
-+      return err;
-+}
-+
-+static int ext3_mb_load_buddy(struct super_block *sb, int group,
-+              struct ext3_buddy *e3b)
-+{
-+      struct ext3_sb_info *sbi = EXT3_SB(sb);
-+      struct inode *inode = sbi->s_buddy_cache;
-+      int blocks_per_page, block, pnum, poff;
-+      struct page *page;
-+
-+      mb_debug("load group %u\n", group);
-+
-+      blocks_per_page = PAGE_CACHE_SIZE / sb->s_blocksize;
-+
-+      e3b->bd_blkbits = sb->s_blocksize_bits;
-+      e3b->bd_info = EXT3_GROUP_INFO(sb, group);
-+      e3b->bd_sb = sb;
-+      e3b->bd_group = group;
-+      e3b->bd_buddy_page = NULL;
-+      e3b->bd_bitmap_page = NULL;
-+
-+      block = group * 2;
-+      pnum = block / blocks_per_page;
-+      poff = block % blocks_per_page;
-+
-+      /* we could use find_or_create_page(), but it locks page
-+       * what we'd like to avoid in fast path ... */
-+      page = find_get_page(inode->i_mapping, pnum);
-+      if (page == NULL || !PageUptodate(page)) {
-+              if (page)
-+                      page_cache_release(page);
-+              page = find_or_create_page(inode->i_mapping, pnum, GFP_NOFS);
-+              if (page) {
-+                      BUG_ON(page->mapping != inode->i_mapping);
-+                      if (!PageUptodate(page)) {
-+                              ext3_mb_init_cache(page, NULL);
-+                              mb_cmp_bitmaps(e3b, page_address(page) +
-+                                             (poff * sb->s_blocksize));
-+                      }
-+                      unlock_page(page);
-+              }
-+      }
-+      e3b->bd_bitmap_page = page;
-+      if (page == NULL || !PageUptodate(page))
-+              goto err;
-+      e3b->bd_bitmap = page_address(page) + (poff * sb->s_blocksize);
-+      mark_page_accessed(page);
-+
-+      block++;
-+      pnum = block / blocks_per_page;
-+      poff = block % blocks_per_page;
-+
-+      page = find_get_page(inode->i_mapping, pnum);
-+      if (page == NULL || !PageUptodate(page)) {
-+              if (page)
-+                      page_cache_release(page);
-+              page = find_or_create_page(inode->i_mapping, pnum, GFP_NOFS);
-+              if (page) {
-+                      BUG_ON(page->mapping != inode->i_mapping);
-+                      if (!PageUptodate(page))
-+                              ext3_mb_init_cache(page, e3b->bd_bitmap);
-+
-+                      unlock_page(page);
-+              }
-+      }
-+      e3b->bd_buddy_page = page;
-+      if (page == NULL || !PageUptodate(page))
-+              goto err;
-+      e3b->bd_buddy = page_address(page) + (poff * sb->s_blocksize);
-+      mark_page_accessed(page);
-+
-+      BUG_ON(e3b->bd_bitmap_page == NULL);
-+      BUG_ON(e3b->bd_buddy_page == NULL);
-+
-+      return 0;
-+
-+err:
-+      if (e3b->bd_bitmap_page)
-+              page_cache_release(e3b->bd_bitmap_page);
-+      if (e3b->bd_buddy_page)
-+              page_cache_release(e3b->bd_buddy_page);
-+      e3b->bd_buddy = NULL;
-+      e3b->bd_bitmap = NULL;
-+      return -EIO;
-+}
-+
-+static void ext3_mb_release_desc(struct ext3_buddy *e3b)
-+{
-+      if (e3b->bd_bitmap_page)
-+              page_cache_release(e3b->bd_bitmap_page);
-+      if (e3b->bd_buddy_page)
-+              page_cache_release(e3b->bd_buddy_page);
-+}
-+
-+
-+static int mb_find_order_for_block(struct ext3_buddy *e3b, int block)
-+{
-+      int order = 1;
-+      void *bb;
-+
-+      BUG_ON(EXT3_MB_BITMAP(e3b) == EXT3_MB_BUDDY(e3b));
-+      BUG_ON(block >= (1 << (e3b->bd_blkbits + 3)));
-+
-+      bb = EXT3_MB_BUDDY(e3b);
-+      while (order <= e3b->bd_blkbits + 1) {
-+              block = block >> 1;
-+              if (!mb_test_bit(block, bb)) {
-+                      /* this block is part of buddy of order 'order' */
-+                      return order;
-+              }
-+              bb += 1 << (e3b->bd_blkbits - order);
-+              order++;
-+      }
-+      return 0;
-+}
-+
-+static inline void mb_clear_bits(spinlock_t *lock, void *bm, int cur, int len)
-+{
-+      __u32 *addr;
-+
-+      len = cur + len;
-+      while (cur < len) {
-+              if ((cur & 31) == 0 && (len - cur) >= 32) {
-+                      /* fast path: clear whole word at once */
-+                      addr = bm + (cur >> 3);
-+                      *addr = 0;
-+                      cur += 32;
-+                      continue;
-+              }
-+              if (lock)
-+                      mb_clear_bit_atomic(lock, cur, bm);
-+              else
-+                      mb_clear_bit(cur, bm);
-+              cur++;
-+      }
-+}
-+
-+static inline void mb_set_bits(spinlock_t *lock, void *bm, int cur, int len)
-+{
-+      __u32 *addr;
-+
-+      len = cur + len;
-+      while (cur < len) {
-+              if ((cur & 31) == 0 && (len - cur) >= 32) {
-+                      /* fast path: clear whole word at once */
-+                      addr = bm + (cur >> 3);
-+                      *addr = 0xffffffff;
-+                      cur += 32;
-+                      continue;
-+              }
-+              if (lock)
-+                      mb_set_bit_atomic(lock, cur, bm);
-+              else
-+                      mb_set_bit(cur, bm);
-+              cur++;
-+      }
-+}
-+
-+static int mb_free_blocks(struct inode *inode, struct ext3_buddy *e3b,
-+                        int first, int count)
-+{
-+      int block = 0, max = 0, order;
-+      void *buddy, *buddy2;
-+      struct super_block *sb = e3b->bd_sb;
-+
-+      BUG_ON(first + count > (sb->s_blocksize << 3));
-+      BUG_ON(!ext3_is_group_locked(sb, e3b->bd_group));
-+      mb_check_buddy(e3b);
-+      mb_free_blocks_double(inode, e3b, first, count);
-+
-+      e3b->bd_info->bb_free += count;
-+      if (first < e3b->bd_info->bb_first_free)
-+              e3b->bd_info->bb_first_free = first;
-+
-+      /* let's maintain fragments counter */
-+      if (first != 0)
-+              block = !mb_test_bit(first - 1, EXT3_MB_BITMAP(e3b));
-+      if (first + count < EXT3_SB(sb)->s_mb_maxs[0])
-+              max = !mb_test_bit(first + count, EXT3_MB_BITMAP(e3b));
-+      if (block && max)
-+              e3b->bd_info->bb_fragments--;
-+      else if (!block && !max)
-+              e3b->bd_info->bb_fragments++;
-+
-+      /* let's maintain buddy itself */
-+      while (count-- > 0) {
-+              block = first++;
-+              order = 0;
-+
-+              if (!mb_test_bit(block, EXT3_MB_BITMAP(e3b))) {
-+                      unsigned long blocknr;
-+                      blocknr = e3b->bd_group * EXT3_BLOCKS_PER_GROUP(sb);
-+                      blocknr += block;
-+                      blocknr +=
-+                          le32_to_cpu(EXT3_SB(sb)->s_es->s_first_data_block);
-+
-+                      ext3_error(sb, __FUNCTION__, "double-free of inode"
-+                                 " %lu's block %lu(bit %u in group %u)\n",
-+                                 inode ? inode->i_ino : 0, blocknr, block,
-+                                 e3b->bd_group);
-+              }
-+              mb_clear_bit(block, EXT3_MB_BITMAP(e3b));
-+              e3b->bd_info->bb_counters[order]++;
-+
-+              /* start of the buddy */
-+              buddy = mb_find_buddy(e3b, order, &max);
-+
-+              do {
-+                      block &= ~1UL;
-+                      if (mb_test_bit(block, buddy) ||
-+                                      mb_test_bit(block + 1, buddy))
-+                              break;
-+
-+                      /* both the buddies are free, try to coalesce them */
-+                      buddy2 = mb_find_buddy(e3b, order + 1, &max);
-+
-+                      if (!buddy2)
-+                              break;
-+
-+                      if (order > 0) {
-+                              /* for special purposes, we don't set
-+                               * free bits in bitmap */
-+                              mb_set_bit(block, buddy);
-+                              mb_set_bit(block + 1, buddy);
-+                      }
-+                      e3b->bd_info->bb_counters[order]--;
-+                      e3b->bd_info->bb_counters[order]--;
-+
-+                      block = block >> 1;
-+                      order++;
-+                      e3b->bd_info->bb_counters[order]++;
-+
-+                      mb_clear_bit(block, buddy2);
-+                      buddy = buddy2;
-+              } while (1);
-+      }
-+      mb_check_buddy(e3b);
-+
-+      return 0;
-+}
-+
-+static int mb_find_extent(struct ext3_buddy *e3b, int order, int block,
-+                              int needed, struct ext3_free_extent *ex)
-+{
-+      int next = block, max, ord;
-+      void *buddy;
-+
-+      BUG_ON(!ext3_is_group_locked(e3b->bd_sb, e3b->bd_group));
-+      BUG_ON(ex == NULL);
-+
-+      buddy = mb_find_buddy(e3b, order, &max);
-+      BUG_ON(buddy == NULL);
-+      BUG_ON(block >= max);
-+      if (mb_test_bit(block, buddy)) {
-+              ex->fe_len = 0;
-+              ex->fe_start = 0;
-+              ex->fe_group = 0;
-+              return 0;
-+      }
-+
-+      if (likely(order == 0)) {
-+              /* find actual order */
-+              order = mb_find_order_for_block(e3b, block);
-+              block = block >> order;
-+      }
-+
-+      ex->fe_len = 1 << order;
-+      ex->fe_start = block << order;
-+      ex->fe_group = e3b->bd_group;
-+
-+      /* calc difference from given start */
-+      next = next - ex->fe_start;
-+      ex->fe_len -= next;
-+      ex->fe_start += next;
-+
-+      while (needed > ex->fe_len && (buddy = mb_find_buddy(e3b, order, &max))) {
-+
-+              if (block + 1 >= max)
-+                      break;
-+
-+              next = (block + 1) * (1 << order);
-+              if (mb_test_bit(next, EXT3_MB_BITMAP(e3b)))
-+                      break;
-+
-+              ord = mb_find_order_for_block(e3b, next);
-+
-+              order = ord;
-+              block = next >> order;
-+              ex->fe_len += 1 << order;
-+      }
-+
-+      BUG_ON(ex->fe_start + ex->fe_len > (1 << (e3b->bd_blkbits + 3)));
-+      return ex->fe_len;
-+}
-+
-+static int mb_mark_used(struct ext3_buddy *e3b, struct ext3_free_extent *ex)
-+{
-+      int ord, mlen = 0, max = 0, cur;
-+      int start = ex->fe_start;
-+      int len = ex->fe_len;
-+      unsigned ret = 0;
-+      int len0 = len;
-+      void *buddy;
-+
-+      BUG_ON(start + len > (e3b->bd_sb->s_blocksize << 3));
-+      BUG_ON(e3b->bd_group != ex->fe_group);
-+      BUG_ON(!ext3_is_group_locked(e3b->bd_sb, e3b->bd_group));
-+      spin_lock(sb_bgl_lock(EXT3_SB(e3b->bd_sb), ex->fe_group));
-+      mb_check_buddy(e3b);
-+      mb_mark_used_double(e3b, start, len);
-+
-+      e3b->bd_info->bb_free -= len;
-+   &nb