Whamcloud - gitweb
LU-12477 ldiskfs: remove obsolete ext4 patches 52/37352/14
authorJames Simmons <jsimmons@infradead.org>
Fri, 6 Mar 2020 01:40:47 +0000 (20:40 -0500)
committerOleg Drokin <green@whamcloud.com>
Tue, 24 Mar 2020 05:17:24 +0000 (05:17 +0000)
Drop support for ldiskfs kernels earlier than RHEL7.6.

Test-Parameters: trivial

Change-Id: I30450904c508ec8aa5388cbfd9bd967028f88b28
Signed-off-by: James Simmons <jsimmons@infradead.org>
Reviewed-on: https://review.whamcloud.com/37352
Reviewed-by: Andreas Dilger <adilger@whamcloud.com>
Reviewed-by: Alex Zhuravlev <bzzz@whamcloud.com>
Tested-by: jenkins <devops@whamcloud.com>
Tested-by: Maloo <maloo@whamcloud.com>
Reviewed-by: Oleg Drokin <green@whamcloud.com>
129 files changed:
config/lustre-build-ldiskfs.m4
ldiskfs/kernel_patches/patches/rhel6.3/ext4-export-64bit-name-hash.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel6.3/ext4-hash-indexed-dir-dotdot-update.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel6.3/ext4-inode-version.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel6.3/ext4-journal-path-opt.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel6.3/ext4-max-dir-size.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel6.3/ext4-nlink-2.6.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel6.3/ext4-nocmtime-2.6.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel6.3/ext4-not-discard-preallocation-umount.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel6.3/ext4-osd-iam-exports.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel6.3/ext4-pdir-fix.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel6.3/ext4-pdirop.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel6.3/ext4-remove-cond_resched-calls.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel6.5/ext4-fix-journal-quota.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel6.5/ext4-give-warning-with-dir-htree-growing.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel7.2/ext4-dont-check-before-replay.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel7.2/ext4-dont-check-in-ro.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel7.2/ext4-large-eas.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel7.2/ext4-pdirop.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel7.2/ext4-release-bh-in-makeinxdir.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel7.2/ext4-remove-i_data_sem-from-xattr.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel7.3/ext4-corrupted-inode-block-bitmaps-handling-patches.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel7.4/ext4-dont-check-before-replay.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel7.4/ext4-remove-i_data_sem-from-xattr.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-attach-jinode-in-writepages.patch [moved from ldiskfs/kernel_patches/patches/rhel7.4/ext4-attach-jinode-in-writepages.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-cleanup-goto-next-group.patch [moved from ldiskfs/kernel_patches/patches/rhel7/ext4-cleanup-goto-next-group.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-data-in-dirent.patch [moved from ldiskfs/kernel_patches/patches/rhel7.3/ext4-data-in-dirent.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-disable-mb-cache.patch [moved from ldiskfs/kernel_patches/patches/rhel7.3/ext4-disable-mb-cache.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-dont-check-in-ro.patch [moved from ldiskfs/kernel_patches/patches/rhel6.3/ext4-dont-check-in-ro.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-export-mb-stream-allocator-variables.patch [moved from ldiskfs/kernel_patches/patches/rhel7.2/ext4-export-mb-stream-allocator-variables.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-export-orphan-add.patch [moved from ldiskfs/kernel_patches/patches/rhel7/ext4-export-orphan-add.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-fix-xattr-shifting-when-expanding-inodes.patch [moved from ldiskfs/kernel_patches/patches/rhel7.4/ext4-fix-xattr-shifting-when-expanding-inodes.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-give-warning-with-dir-htree-growing.patch [moved from ldiskfs/kernel_patches/patches/rhel7/ext4-give-warning-with-dir-htree-growing.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-hash-indexed-dir-dotdot-update.patch [moved from ldiskfs/kernel_patches/patches/rhel7/ext4-hash-indexed-dir-dotdot-update.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-include-terminating-u32-in-size-of-xattr-entries-when-expanding-inodes.patch [moved from ldiskfs/kernel_patches/patches/rhel7/ext4-include-terminating-u32-in-size-of-xattr-entries-when-expanding-inodes.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-inode-version.patch [moved from ldiskfs/kernel_patches/patches/rhel7/ext4-inode-version.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-jcb-optimization.patch [moved from ldiskfs/kernel_patches/patches/rhel7/ext4-jcb-optimization.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-kill-dx-root.patch [moved from ldiskfs/kernel_patches/patches/rhel7/ext4-kill-dx-root.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-large-dir.patch [moved from ldiskfs/kernel_patches/patches/rhel7.4/ext4-large-dir.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-lookup-dotdot.patch [moved from ldiskfs/kernel_patches/patches/rhel7/ext4-lookup-dotdot.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-max-dir-size.patch [moved from ldiskfs/kernel_patches/patches/rhel7/ext4-max-dir-size.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-mballoc-extra-checks.patch [moved from ldiskfs/kernel_patches/patches/rhel7/ext4-mballoc-extra-checks.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-mballoc-pa-free-mismatch.patch [moved from ldiskfs/kernel_patches/patches/rhel7/ext4-mballoc-pa-free-mismatch.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-mballoc-prefetch.patch [new file with mode: 0644]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-mballoc-skip-uninit-groups-cr0.patch [moved from ldiskfs/kernel_patches/patches/rhel7/ext4-mballoc-skip-uninit-groups-cr0.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-misc.patch [moved from ldiskfs/kernel_patches/patches/rhel7/ext4-misc.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-mmp-brelse.patch [moved from ldiskfs/kernel_patches/patches/rhel7/ext4-mmp-brelse.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-mmp-dont-mark-bh-dirty.patch [moved from ldiskfs/kernel_patches/patches/rhel7/ext4-mmp-dont-mark-bh-dirty.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-nocmtime.patch [moved from ldiskfs/kernel_patches/patches/rhel7/ext4-nocmtime.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-optimize-ext4_find_delalloc_range-in-nodelalloc.patch [moved from ldiskfs/kernel_patches/patches/rhel7/ext4-optimize-ext4_find_delalloc_range-in-nodelalloc.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-pdirop.patch [moved from ldiskfs/kernel_patches/patches/rhel7.4/ext4-pdirop.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-prealloc.patch [moved from ldiskfs/kernel_patches/patches/rhel7.4/ext4-prealloc.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-preread-gd.patch [moved from ldiskfs/kernel_patches/patches/rhel7.2/ext4-preread-gd.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-print-inum-in-htree-warning.patch [moved from ldiskfs/kernel_patches/patches/rhel6.3/ext4-print-inum-in-htree-warning.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-projid-feature-support.patch [moved from ldiskfs/kernel_patches/patches/rhel7/ext4-projid-feature-support.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-projid-ignore-maxquotas.patch [moved from ldiskfs/kernel_patches/patches/rhel7/ext4-projid-ignore-maxquotas.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-projid-quotas.patch [moved from ldiskfs/kernel_patches/patches/rhel7/ext4-projid-quotas.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-projid-xfs-ioctls.patch [moved from ldiskfs/kernel_patches/patches/rhel7.5/ext4-projid-xfs-ioctls.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-reduce-lock-contention-in-__ext4_new_inode.patch [moved from ldiskfs/kernel_patches/patches/rhel7/ext4-reduce-lock-contention-in-__ext4_new_inode.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-simple-blockalloc.patch [moved from ldiskfs/kernel_patches/patches/rhel7.2/ext4-simple-blockalloc.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4-use-GFP_NOFS-in-ext4_inode_attach_jinode.patch [moved from ldiskfs/kernel_patches/patches/rhel7/ext4-use-GFP_NOFS-in-ext4_inode_attach_jinode.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7.6/ext4_s_max_ext_tree_depth.patch [moved from ldiskfs/kernel_patches/patches/rhel7/ext4_s_max_ext_tree_depth.patch with 100% similarity]
ldiskfs/kernel_patches/patches/rhel7/ext4-corrupted-inode-block-bitmaps-handling-patches.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel7/ext4-data-in-dirent.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel7/ext4-disable-mb-cache.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel7/ext4-fix-xattr-shifting-when-expanding-inodes.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel7/ext4-large-dir.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel7/ext4-large-eas.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel7/ext4-pdirop.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel7/ext4-prealloc.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel7/ext4-projid-xfs-ioctls.patch [deleted file]
ldiskfs/kernel_patches/patches/rhel7/ext4-remove-i_data_sem-from-xattr.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp1/ext4-notalloc_under_idatasem.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp2/export-ext4-3.0.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp2/ext4-corrupted-inode-block-bitmaps-handling-patches.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp2/ext4-data-in-dirent.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp2/ext4-disable-mb-cache.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp2/ext4-ext_generation.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp2/ext4-handle-cleanup-after-quota-failure.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp2/ext4-introduce-ext4_kvmalloc-ext4_kzalloc-and-ext4_kvfree.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp2/ext4-journal-callback.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp2/ext4-kill-dx_root.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp2/ext4-large-dir.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp2/ext4-large-eas.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp2/ext4-lookup-dotdot.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp2/ext4-make-quota-as-first-class-supported-feature.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp2/ext4-map_inode_page-3.0.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp2/ext4-max-dir-size-options.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp2/ext4-mballoc-extra-checks.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp2/ext4-mballoc-pa_free-mismatch.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp2/ext4-misc.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp2/ext4-mmp-dont-mark-bh-dirty.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp2/ext4-osd-iop-common.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp2/ext4-prealloc.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp2/ext4-speed-up-fitrim-by-recording-flags-in-ext4_group_info.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp2/ext4-store-tree-generation-at-find.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp2/ext4-use-ext4_kvzalloc-ext4_kvmalloc-for-s_group_desc-and-s_group_info.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp2/ext4-use-ext4_msg-instead-of-printk-in-mballoc.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp2/restore-path-in-walk_extent_callback.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp2/revert-ext4-avoid-uninitialized-memory-references-in-ext3_htree_next_block.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp3/ext4-dont-check-before-replay.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp3/ext4-mmp-brelse.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp3/ext4_s_max_ext_tree_depth.patch [deleted file]
ldiskfs/kernel_patches/patches/sles11sp4/ext4-large-dir.patch [deleted file]
ldiskfs/kernel_patches/patches/sles12/ext4-osd-iop-common.patch [moved from ldiskfs/kernel_patches/patches/rhel7/ext4-osd-iop-common.patch with 100% similarity]
ldiskfs/kernel_patches/series/ldiskfs-3.0-sles11.series [deleted file]
ldiskfs/kernel_patches/series/ldiskfs-3.0-sles11sp3.series [deleted file]
ldiskfs/kernel_patches/series/ldiskfs-3.0-sles11sp4.series [deleted file]
ldiskfs/kernel_patches/series/ldiskfs-3.10-rhel7.2.series
ldiskfs/kernel_patches/series/ldiskfs-3.10-rhel7.3.series
ldiskfs/kernel_patches/series/ldiskfs-3.10-rhel7.4.series
ldiskfs/kernel_patches/series/ldiskfs-3.10-rhel7.5.series
ldiskfs/kernel_patches/series/ldiskfs-3.10-rhel7.6.series
ldiskfs/kernel_patches/series/ldiskfs-3.10-rhel7.7.series
ldiskfs/kernel_patches/series/ldiskfs-3.10-rhel7.series
ldiskfs/kernel_patches/series/ldiskfs-3.12-sles12.series
ldiskfs/kernel_patches/series/ldiskfs-3.12-sles12sp1.series
ldiskfs/kernel_patches/series/ldiskfs-4.15.0-20-ubuntu18.series
ldiskfs/kernel_patches/series/ldiskfs-4.15.0-24-ubuntu18.series
ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.1.series
ldiskfs/kernel_patches/series/ldiskfs-4.18-rhel8.series
ldiskfs/kernel_patches/series/ldiskfs-4.4-sles12sp2.series
ldiskfs/kernel_patches/series/ldiskfs-4.4-sles12sp3.series
ldiskfs/kernel_patches/series/ldiskfs-4.4.0-45-ubuntu14+16.series
ldiskfs/kernel_patches/series/ldiskfs-4.4.0-49-ubuntu14+16.series
ldiskfs/kernel_patches/series/ldiskfs-4.4.0-62-ubuntu14+16.series
ldiskfs/kernel_patches/series/ldiskfs-4.4.0-73-ubuntu14+16.series
ldiskfs/kernel_patches/series/ldiskfs-5.0.0-13-ubuntu19.series
ldiskfs/kernel_patches/series/ldiskfs-5.4.0-ml.series

index 1f4a1e7..f205890 100644 (file)
@@ -17,38 +17,13 @@ AS_IF([test x$RHEL_KERNEL = xyes], [
        80)     LDISKFS_SERIES="4.18-rhel8.series"      ;;
        77)     LDISKFS_SERIES="3.10-rhel7.7.series"    ;;
        76)     LDISKFS_SERIES="3.10-rhel7.6.series"    ;;
-       75)     LDISKFS_SERIES="3.10-rhel7.5.series"    ;;
-       74)     LDISKFS_SERIES="3.10-rhel7.4.series"    ;;
-       73)     LDISKFS_SERIES="3.10-rhel7.3.series"    ;;
-       72)     LDISKFS_SERIES="3.10-rhel7.2.series"    ;;
-       71)     LDISKFS_SERIES="3.10-rhel7.series"      ;;
-       69)     LDISKFS_SERIES="2.6-rhel6.9.series"     ;;
-       68)     LDISKFS_SERIES="2.6-rhel6.8.series"     ;;
-       67)     LDISKFS_SERIES="2.6-rhel6.7.series"     ;;
-       66)     LDISKFS_SERIES="2.6-rhel6.6.series"     ;;
-       65)     LDISKFS_SERIES="2.6-rhel6.5.series"     ;;
-       64)     LDISKFS_SERIES="2.6-rhel6.4.series"     ;;
-       6[0-3]) LDISKFS_SERIES="2.6-rhel6.series"       ;;
        esac
 ], [test x$SUSE_KERNEL = xyes], [
        AS_VERSION_COMPARE([$LINUXRELEASE],[4.12.14],[
        AS_VERSION_COMPARE([$LINUXRELEASE],[4.4.82],[
        AS_VERSION_COMPARE([$LINUXRELEASE],[4.4.0],[
-       AS_VERSION_COMPARE([$LINUXRELEASE],[3.12.0],[
-       AS_VERSION_COMPARE([$LINUXRELEASE],[3.0.0],[
-       AS_VERSION_COMPARE([$LINUXRELEASE],[2.6.32], [],
-       [LDISKFS_SERIES="2.6-sles11.series"],[LDISKFS_SERIES="2.6-sles11.series"])],
-       [LDISKFS_SERIES="3.0-sles11.series"],[
-               PLEV=$(grep PATCHLEVEL /etc/SuSE-release | sed -e 's/.*= *//')
-               case $PLEV in
-               2) LDISKFS_SERIES="3.0-sles11.series"
-                       ;;
-               3) LDISKFS_SERIES="3.0-sles11sp3.series"
-                       ;;
-               4) LDISKFS_SERIES="3.0-sles11sp4.series"
-                       ;;
-               esac
-       ])],[LDISKFS_SERIES="3.12-sles12.series"],[
+       AS_VERSION_COMPARE([$LINUXRELEASE],[3.12.0],[],
+       [LDISKFS_SERIES="3.12-sles12.series"],[
                PLEV=$(grep PATCHLEVEL /etc/SuSE-release | sed -e 's/.*= *//')
                case $PLEV in
                1) LDISKFS_SERIES="3.12-sles12sp1.series"
diff --git a/ldiskfs/kernel_patches/patches/rhel6.3/ext4-export-64bit-name-hash.patch b/ldiskfs/kernel_patches/patches/rhel6.3/ext4-export-64bit-name-hash.patch
deleted file mode 100644 (file)
index f3982bd..0000000
+++ /dev/null
@@ -1,189 +0,0 @@
-diff -urp linux-stage.orig/fs/ext4/dir.c linux-stage/fs/ext4/dir.c
---- linux-stage.orig/fs/ext4/dir.c     2012-06-21 10:26:23.000000000 -0400
-+++ linux-stage/fs/ext4/dir.c  2012-06-21 10:37:39.000000000 -0400
-@@ -247,20 +247,52 @@ out:
-
- /*
-  * These functions convert from the major/minor hash to an f_pos
-- * value.
-+ * value for dx directories.
-  *
-- * 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.
-+ * Upper layer (for example NFS) should specify FMODE_32BITHASH or
-+ * FMODE_64BITHASH explicitly. On the other hand, we allow ext4 to be mounted
-+ * directly on both 32-bit and 64-bit nodes, under such case, neither
-+ * FMODE_32BITHASH nor FMODE_64BITHASH is specified.
-+ */
-+static inline loff_t hash2pos(struct file *filp, __u32 major, __u32 minor)
-+{
-+      if ((filp->f_mode & FMODE_32BITHASH) ||
-+          (!(filp->f_mode & FMODE_64BITHASH) && is_compat_task()))
-+              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_mode & FMODE_32BITHASH) ||
-+          (!(filp->f_mode & FMODE_64BITHASH) && is_compat_task()))
-+              return (pos << 1) & 0xffffffff;
-+      else
-+              return ((pos >> 32) << 1) & 0xffffffff;
-+}
-+
-+static inline __u32 pos2min_hash(struct file *filp, loff_t pos)
-+{
-+      if ((filp->f_mode & FMODE_32BITHASH) ||
-+          (!(filp->f_mode & FMODE_64BITHASH) && is_compat_task()))
-+              return 0;
-+      else
-+              return pos & 0xffffffff;
-+}
-+
-+/*
-+ * Return 32- or 64-bit end-of-file for dx directories
-  */
--#define hash2pos(major, minor)        (major >> 1)
--#define pos2maj_hash(pos)     ((pos << 1) & 0xffffffff)
--#define pos2min_hash(pos)     (0)
-+static inline loff_t ext4_get_htree_eof(struct file *filp)
-+{
-+      if ((filp->f_mode & FMODE_32BITHASH) ||
-+          (!(filp->f_mode & FMODE_64BITHASH) && is_compat_task()))
-+              return EXT4_HTREE_EOF_32BIT;
-+      else
-+              return EXT4_HTREE_EOF_64BIT;
-+}
-+
- /*
-  * This structure holds the nodes of the red-black tree used to store
-@@ -323,15 +364,16 @@ static void free_rb_tree_fname(struct rb
- }
--static struct dir_private_info *ext4_htree_create_dir_info(loff_t pos)
-+static struct dir_private_info *
-+ext4_htree_create_dir_info(struct file *filp, loff_t pos)
- {
-       struct dir_private_info *p;
-       p = kzalloc(sizeof(struct dir_private_info), GFP_KERNEL);
-       if (!p)
-               return NULL;
--      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);
-       return p;
- }
-@@ -427,7 +469,7 @@ static int call_filldir(struct file *fil
-                      "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,
-@@ -452,13 +494,13 @@ static int ext4_dx_readdir(struct file *
-       int     ret;
-       if (!info) {
--              info = ext4_htree_create_dir_info(filp->f_pos);
-+              info = ext4_htree_create_dir_info(filp, filp->f_pos);
-               if (!info)
-                       return -ENOMEM;
-               filp->private_data = info;
-       }
-
--      if (filp->f_pos == EXT4_HTREE_EOF)
-+      if (filp->f_pos == ext4_get_htree_eof(filp))
-               return 0;       /* EOF */
-
-       /* Some one has messed with f_pos; reset the world */
-@@ -466,8 +508,8 @@ static int ext4_dx_readdir(struct file *
-               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);
-       }
-       /*
-@@ -499,7 +541,7 @@ static int ext4_dx_readdir(struct file *
-                       if (ret < 0)
-                               return ret;
-                       if (ret == 0) {
--                              filp->f_pos = EXT4_HTREE_EOF;
-+                              filp->f_pos = ext4_get_htree_eof(filp);
-                               break;
-                       }
-                       info->curr_node = rb_first(&info->root);
-@@ -519,7 +561,7 @@ static int ext4_dx_readdir(struct file *
-                       info->curr_minor_hash = fname->minor_hash;
-               } else {
-                       if (info->next_hash == ~0) {
--                              filp->f_pos = EXT4_HTREE_EOF;
-+                              filp->f_pos = ext4_get_htree_eof(filp);
-                               break;
-                       }
-                       info->curr_hash = info->next_hash;
-diff -urp linux-stage.orig/fs/ext4/ext4.h linux-stage/fs/ext4/ext4.h
---- linux-stage.orig/fs/ext4/ext4.h    2012-06-21 10:26:23.000000000 -0400
-+++ linux-stage/fs/ext4/ext4.h 2012-06-21 10:39:43.000000000 -0400
-@@ -816,6 +816,16 @@ struct ext4_inode_info {
-       __u64 i_fs_version;
- };
-+#ifndef FMODE_32BITHASH
-+/* 32bit hashes as llseek() offset (for directories) */
-+#define FMODE_32BITHASH         ((__force fmode_t)0x200)
-+#endif
-+
-+#ifndef FMODE_64BITHASH
-+/* 64bit hashes as llseek() offset (for directories) */
-+#define FMODE_64BITHASH         ((__force fmode_t)0x400)
-+#endif
-+
- #define HAVE_DISK_INODE_VERSION
- /*
-@@ -1450,7 +1460,11 @@ struct dx_hash_info
-       u32             *seed;
- };
-
--#define EXT4_HTREE_EOF        0x7fffffff
-+
-+/* 32 and 64 bit signed EOF for dx directories */
-+#define EXT4_HTREE_EOF_32BIT   ((1UL  << (32 - 1)) - 1)
-+#define EXT4_HTREE_EOF_64BIT   ((1ULL << (64 - 1)) - 1)
-+
-
- /*
-  * Control parameters used by ext4_htree_next_block
-diff -urp linux-stage.orig/fs/ext4/hash.c linux-stage/fs/ext4/hash.c
---- linux-stage.orig/fs/ext4/hash.c    2012-06-21 10:26:23.000000000 -0400
-+++ linux-stage/fs/ext4/hash.c 2012-06-21 10:29:02.000000000 -0400
-@@ -201,8 +201,8 @@ int ext4fs_dirhash(const char *name, int
-               return -1;
-       }
-       hash = hash & ~1;
--      if (hash == (EXT4_HTREE_EOF << 1))
--              hash = (EXT4_HTREE_EOF-1) << 1;
-+      if (hash == (EXT4_HTREE_EOF_32BIT << 1))
-+              hash = (EXT4_HTREE_EOF_32BIT - 1) << 1;
-       hinfo->hash = hash;
-       hinfo->minor_hash = minor_hash;
-       return 0;
diff --git a/ldiskfs/kernel_patches/patches/rhel6.3/ext4-hash-indexed-dir-dotdot-update.patch b/ldiskfs/kernel_patches/patches/rhel6.3/ext4-hash-indexed-dir-dotdot-update.patch
deleted file mode 100644 (file)
index 76416c7..0000000
+++ /dev/null
@@ -1,87 +0,0 @@
-Index: linux-stage/fs/ext4/namei.c
-===================================================================
---- linux-stage.orig/fs/ext4/namei.c   2009-08-10 22:44:33.000000000 +0800
-+++ linux-stage/fs/ext4/namei.c        2009-08-10 22:48:22.000000000 +0800
-@@ -1493,6 +1493,72 @@
-       return add_dirent_to_buf(handle, dentry, inode, de, bh);
- }
-+/* update ".." for hash-indexed directory, split the item "." if necessary */
-+static int ext4_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 ext4_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 = ext4_bread(handle, dir, 0, 0, &err);
-+      if (!dir_block)
-+              goto out;
-+
-+      de = (struct ext4_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 >= EXT4_DIR_REC_LEN(1));
-+      if (len > EXT4_DIR_REC_LEN(1)) {
-+              BUFFER_TRACE(dir_block, "get_write_access");
-+              err = ext4_journal_get_write_access(handle, dir_block);
-+              if (err)
-+                      goto out_journal;
-+
-+              journal = 1;
-+              de->rec_len = cpu_to_le16(EXT4_DIR_REC_LEN(1));
-+      }
-+
-+      len -= EXT4_DIR_REC_LEN(1);
-+      assert(len == 0 || len >= EXT4_DIR_REC_LEN(2));
-+      de = (struct ext4_dir_entry_2 *)
-+                      ((char *) de + le16_to_cpu(de->rec_len));
-+      if (!journal) {
-+              BUFFER_TRACE(dir_block, "get_write_access");
-+              err = ext4_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) >= EXT4_DIR_REC_LEN(2));
-+      de->name_len = 2;
-+      strcpy (de->name, "..");
-+      ext4_set_de_type(dir->i_sb, de, S_IFDIR);
-+
-+out_journal:
-+      if (journal) {
-+              BUFFER_TRACE(dir_block, "call ext4_handle_dirty_metadata");
-+              err = ext4_handle_dirty_metadata(handle, dir, dir_block);
-+              ext4_mark_inode_dirty(handle, dir);
-+      }
-+      brelse (dir_block);
-+
-+out:
-+      return err;
-+}
-+
- /*
-  *    ext4_add_entry()
-  *
-@@ -1521,6 +1587,9 @@
-       if (!dentry->d_name.len)
-               return -EINVAL;
-       if (is_dx(dir)) {
-+              if (dentry->d_name.len == 2 &&
-+                  memcmp(dentry->d_name.name, "..", 2) == 0)
-+                      return ext4_update_dotdot(handle, dentry, inode);
-               retval = ext4_dx_add_entry(handle, dentry, inode);
-               if (!retval || (retval != ERR_BAD_DX_DIR))
-                       return retval;
diff --git a/ldiskfs/kernel_patches/patches/rhel6.3/ext4-inode-version.patch b/ldiskfs/kernel_patches/patches/rhel6.3/ext4-inode-version.patch
deleted file mode 100644 (file)
index a104bed..0000000
+++ /dev/null
@@ -1,63 +0,0 @@
-Index: linux-2.6.32-el6-beta/fs/ext4/inode.c
-===================================================================
---- linux-2.6.32-el6-beta.orig/fs/ext4/inode.c
-+++ linux-2.6.32-el6-beta/fs/ext4/inode.c
-@@ -4920,11 +4920,11 @@ struct inode *ext4_iget(struct super_blo
-       EXT4_INODE_GET_XTIME(i_atime, inode, raw_inode);
-       EXT4_EINODE_GET_XTIME(i_crtime, ei, raw_inode);
--      inode->i_version = le32_to_cpu(raw_inode->i_disk_version);
-+      ei->i_fs_version = le32_to_cpu(raw_inode->i_disk_version);
-       if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) {
-               if (EXT4_FITS_IN_INODE(raw_inode, ei, i_version_hi))
--                      inode->i_version |=
--                      (__u64)(le32_to_cpu(raw_inode->i_version_hi)) << 32;
-+                      ei->i_fs_version |= (__u64)(le32_to_cpu(raw_inode->i_version_hi))
-+                                                                       << 32;
-       }
-       ret = 0;
-@@ -5134,11 +5134,11 @@ static int ext4_do_update_inode(handle_t
-               for (block = 0; block < EXT4_N_BLOCKS; block++)
-                       raw_inode->i_block[block] = ei->i_data[block];
--      raw_inode->i_disk_version = cpu_to_le32(inode->i_version);
-+      raw_inode->i_disk_version = cpu_to_le32(ei->i_fs_version);
-       if (ei->i_extra_isize) {
-               if (EXT4_FITS_IN_INODE(raw_inode, ei, i_version_hi))
--                      raw_inode->i_version_hi =
--                      cpu_to_le32(inode->i_version >> 32);
-+                      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);
-       }
-Index: linux-2.6.32-el6-beta/fs/ext4/ialloc.c
-===================================================================
---- linux-2.6.32-el6-beta.orig/fs/ext4/ialloc.c
-+++ linux-2.6.32-el6-beta/fs/ext4/ialloc.c
-@@ -1018,6 +1018,7 @@ got:
-       ei->i_dtime = 0;
-       ei->i_block_group = group;
-       ei->i_last_alloc_group = ~0;
-+      ei->i_fs_version = 0;
-       ext4_set_inode_flags(inode);
-       if (IS_DIRSYNC(inode))
-Index: linux-2.6.32-el6-beta/fs/ext4/ext4.h
-===================================================================
---- linux-2.6.32-el6-beta.orig/fs/ext4/ext4.h
-+++ linux-2.6.32-el6-beta/fs/ext4/ext4.h
-@@ -714,8 +714,12 @@ struct ext4_inode_info {
-        */
-       tid_t i_sync_tid;
-       tid_t i_datasync_tid;
-+
-+      __u64 i_fs_version;
- };
-+#define HAVE_DISK_INODE_VERSION
-+
- /*
-  * File system states
-  */
diff --git a/ldiskfs/kernel_patches/patches/rhel6.3/ext4-journal-path-opt.patch b/ldiskfs/kernel_patches/patches/rhel6.3/ext4-journal-path-opt.patch
deleted file mode 100644 (file)
index 73d7839..0000000
+++ /dev/null
@@ -1,67 +0,0 @@
-diff -ur linux-stage.orig/fs/ext4/super.c linux-stage/fs/ext4/super.c
---- linux-stage.orig/fs/ext4/super.c   2013-09-26 11:25:51.970361560 -0400
-+++ linux-stage/fs/ext4/super.c        2013-09-26 11:46:25.078236831 -0400
-@@ -1274,7 +1274,7 @@
-       Opt_user_xattr, Opt_nouser_xattr, Opt_acl, Opt_noacl,
-       Opt_auto_da_alloc, Opt_noauto_da_alloc, Opt_noload, Opt_nobh, Opt_bh,
-       Opt_commit, Opt_min_batch_time, Opt_max_batch_time,
--      Opt_journal_update, Opt_journal_dev,
-+      Opt_journal_update, Opt_journal_dev, Opt_journal_path,
-       Opt_journal_checksum, Opt_journal_async_commit,
-       Opt_abort, Opt_data_journal, Opt_data_ordered, Opt_data_writeback,
-       Opt_data_err_abort, Opt_data_err_ignore,
-@@ -1323,6 +1323,7 @@
-       {Opt_max_batch_time, "max_batch_time=%u"},
-       {Opt_journal_update, "journal=update"},
-       {Opt_journal_dev, "journal_dev=%u"},
-+      {Opt_journal_path, "journal_path=%s"},
-       {Opt_journal_checksum, "journal_checksum"},
-       {Opt_journal_async_commit, "journal_async_commit"},
-       {Opt_abort, "abort"},
-@@ -1533,6 +1534,46 @@
-                               return 0;
-                       *journal_devnum = option;
-                       break;
-+              case Opt_journal_path: {
-+                      char *journal_path;
-+                      struct inode *journal_inode;
-+                      struct path path;
-+                      int error;
-+
-+                      if (is_remount) {
-+                              ext4_msg(sb, KERN_ERR,
-+                                      "Cannot specify journal on remount");
-+                              return -1;
-+                      }
-+                      journal_path = match_strdup(&args[0]);
-+                      if (!journal_path) {
-+                              ext4_msg(sb, KERN_ERR, "error: could not dup "
-+                                      "journal device string");
-+                              return -1;
-+                      }
-+
-+                      error = kern_path(journal_path, LOOKUP_FOLLOW, &path);
-+                      if (error) {
-+                              ext4_msg(sb, KERN_ERR, "error: could not find "
-+                                      "journal device path: error %d", error);
-+                                      kfree(journal_path);
-+                              return -1;
-+                      }
-+
-+                      journal_inode = path.dentry->d_inode;
-+                      if (!S_ISBLK(journal_inode->i_mode)) {
-+                              ext4_msg(sb, KERN_ERR, "error: journal path %s "
-+                                      "is not a block device", journal_path);
-+                              path_put(&path);
-+                              kfree(journal_path);
-+                              return -1;
-+                      }
-+
-+                      *journal_devnum = new_encode_dev(journal_inode->i_rdev);
-+                      path_put(&path);
-+                      kfree(journal_path);
-+                      break;
-+              }
-               case Opt_journal_checksum:
-                       set_opt(sbi->s_mount_opt, JOURNAL_CHECKSUM);
-                       break;
diff --git a/ldiskfs/kernel_patches/patches/rhel6.3/ext4-max-dir-size.patch b/ldiskfs/kernel_patches/patches/rhel6.3/ext4-max-dir-size.patch
deleted file mode 100644 (file)
index 1820d69..0000000
+++ /dev/null
@@ -1,70 +0,0 @@
-Index: linux-stage/fs/ext4/namei.c
-===================================================================
---- linux-stage.orig/fs/ext4/namei.c
-+++ linux-stage/fs/ext4/namei.c
-@@ -60,6 +60,15 @@ struct buffer_head *ext4_append(handle_t
-       * have to be serialized -bzzz */
-       down(&ei->i_append_sem);
-+      if (unlikely(S_ISDIR(inode->i_mode) &&
-+                   EXT4_SB(inode->i_sb)->s_max_dir_size &&
-+                   (inode->i_size >=
-+                   EXT4_SB(inode->i_sb)->s_max_dir_size))) {
-+              *err = -ENOSPC;
-+              up(&ei->i_append_sem);
-+              return NULL;
-+      }
-+
-       *block = inode->i_size >> inode->i_sb->s_blocksize_bits;
-       bh = ext4_bread(handle, inode, *block, 1, err);
-Index: linux-2.6.32-el6-beta/fs/ext4/super.c
-===================================================================
---- linux-2.6.32-el6-beta.orig/fs/ext4/super.c
-+++ linux-2.6.32-el6-beta/fs/ext4/super.c
-@@ -999,6 +999,9 @@ static int ext4_show_options(struct seq_
-               seq_printf(seq, ",init_itable=%u",
-                          (unsigned) sbi->s_li_wait_mult);
-+      if (sbi->s_max_dir_size)
-+              seq_printf(seq, "max_dir_size=%lu", sbi->s_max_dir_size);
-+
-       ext4_show_quota_options(seq, sb);
-       return 0;
-@@ -2373,6 +2384,7 @@ EXT4_RO_ATTR(lifetime_write_kbytes);
- EXT4_ATTR_OFFSET(inode_readahead_blks, 0644, sbi_ui_show,
-                inode_readahead_blks_store, s_inode_readahead_blks);
- EXT4_RW_ATTR_SBI_UI(inode_goal, s_inode_goal);
-+EXT4_RW_ATTR_SBI_UI(max_dir_size, s_max_dir_size);
- EXT4_RW_ATTR_SBI_UI(mb_stats, s_mb_stats);
- EXT4_RW_ATTR_SBI_UI(mb_max_to_scan, s_mb_max_to_scan);
- EXT4_RW_ATTR_SBI_UI(mb_min_to_scan, s_mb_min_to_scan);
-@@ -2388,6 +2400,7 @@ static struct attribute *ext4_attrs[] = 
-       ATTR_LIST(lifetime_write_kbytes),
-       ATTR_LIST(inode_readahead_blks),
-       ATTR_LIST(inode_goal),
-+      ATTR_LIST(max_dir_size),
-       ATTR_LIST(mb_stats),
-       ATTR_LIST(mb_max_to_scan),
-       ATTR_LIST(mb_min_to_scan),
-@@ -2877,6 +2890,7 @@ static int ext4_fill_super(struct super_
-       }
-       sb->s_fs_info = sbi;
-       sbi->s_mount_opt = 0;
-+      sbi->s_max_dir_size = 0;
-       sbi->s_resuid = EXT4_DEF_RESUID;
-       sbi->s_resgid = EXT4_DEF_RESGID;
-       sbi->s_inode_readahead_blks = EXT4_DEF_INODE_READAHEAD_BLKS;
-Index: linux-2.6.32-el6-beta/fs/ext4/ext4.h
-===================================================================
---- linux-2.6.32-el6-beta.orig/fs/ext4/ext4.h
-+++ linux-2.6.32-el6-beta/fs/ext4/ext4.h
-@@ -1113,6 +1113,7 @@ struct ext4_sb_info {
-       unsigned long s_mb_prealloc_table_size;
-       unsigned int s_mb_group_prealloc;
-       unsigned int s_max_writeback_mb_bump;
-+      unsigned long s_max_dir_size;
-       /* where last allocation was done - for stream allocation */
-       unsigned long s_mb_last_group;
-       unsigned long s_mb_last_start;
diff --git a/ldiskfs/kernel_patches/patches/rhel6.3/ext4-nlink-2.6.patch b/ldiskfs/kernel_patches/patches/rhel6.3/ext4-nlink-2.6.patch
deleted file mode 100644 (file)
index dcf3f33..0000000
+++ /dev/null
@@ -1,36 +0,0 @@
-Index: linux-stage/fs/ext4/namei.c
-===================================================================
---- linux-stage.orig/fs/ext4/namei.c
-+++ linux-stage/fs/ext4/namei.c
-@@ -1609,7 +1709,7 @@ static void ext4_inc_count(handle_t *han
-  * DIR_NLINK feature is set if 1) nlinks > EXT4_LINK_MAX or 2) nlinks == 2,
-  * since this indicates that nlinks count was previously 1.
-  */
--static void ext4_inc_count(handle_t *handle, struct inode *inode)
-+void ext4_inc_count(handle_t *handle, struct inode *inode)
- {
-       inc_nlink(inode);
-       if (is_dx(inode) && inode->i_nlink > 1) {
-@@ -1709,17 +1709,18 @@ static void ext4_inc_count(handle_t *han
-               }
-       }
- }
-+EXPORT_SYMBOL(ext4_inc_count);
- /*
-  * If a directory had nlink == 1, then we should let it be 1. This indicates
-  * directory has >EXT4_LINK_MAX subdirs.
-  */
--static void ext4_dec_count(handle_t *handle, struct inode *inode)
-+void ext4_dec_count(handle_t *handle, struct inode *inode)
- {
--      drop_nlink(inode);
--      if (S_ISDIR(inode->i_mode) && inode->i_nlink == 0)
--              inc_nlink(inode);
-+      if (!S_ISDIR(inode->i_mode) || inode->i_nlink > 2)
-+              drop_nlink(inode);
- }
-+EXPORT_SYMBOL(ext4_dec_count);
- static int ext4_add_nondir(handle_t *handle,
diff --git a/ldiskfs/kernel_patches/patches/rhel6.3/ext4-nocmtime-2.6.patch b/ldiskfs/kernel_patches/patches/rhel6.3/ext4-nocmtime-2.6.patch
deleted file mode 100644 (file)
index bbc8853..0000000
+++ /dev/null
@@ -1,14 +0,0 @@
-Index: linux-stage/fs/ext4/ext4.h
-===================================================================
---- linux-stage.orig/fs/ext4/ext4.h
-+++ linux-stage/fs/ext4/ext4.h
-@@ -1213,6 +1213,9 @@ static inline struct ext4_inode_info *EX
- static inline struct timespec ext4_current_time(struct inode *inode)
- {
-+      if (IS_NOCMTIME(inode))
-+              return inode->i_ctime;
-+
-       return (inode->i_sb->s_time_gran < NSEC_PER_SEC) ?
-               current_fs_time(inode->i_sb) : CURRENT_TIME_SEC;
- }
diff --git a/ldiskfs/kernel_patches/patches/rhel6.3/ext4-not-discard-preallocation-umount.patch b/ldiskfs/kernel_patches/patches/rhel6.3/ext4-not-discard-preallocation-umount.patch
deleted file mode 100644 (file)
index a52d91f..0000000
+++ /dev/null
@@ -1,14 +0,0 @@
-Index: linux-stage/fs/ext4/mballoc.c
-===================================================================
---- linux-stage.orig/fs/ext4/mballoc.c
-+++ linux-stage/fs/ext4/mballoc.c
-@@ -3781,7 +3781,8 @@ ext4_mb_release_inode_pa(struct ext4_bud
-                * from the bitmap and continue.
-                */
-       }
--      BUG_ON(pa->pa_free != free);
-+      /* do not verify if the file system is being umounted */
-+      BUG_ON(atomic_read(&sb->s_active) > 0 && pa->pa_free != free);
-       atomic_add(free, &sbi->s_mb_discarded);
-       return err;
diff --git a/ldiskfs/kernel_patches/patches/rhel6.3/ext4-osd-iam-exports.patch b/ldiskfs/kernel_patches/patches/rhel6.3/ext4-osd-iam-exports.patch
deleted file mode 100644 (file)
index 3bae32f..0000000
+++ /dev/null
@@ -1,64 +0,0 @@
-diff -rupN 2.6.27.21_2/fs/ext4/ext4.h 2.6.27.21_3/fs/ext4/ext4.h
---- 2.6.27.21_2/fs/ext4/ext4.h 2009-07-17 12:19:59.000000000 +0530
-+++ 2.6.27.21_3/fs/ext4/ext4.h 2009-07-17 12:38:59.000000000 +0530
-@@ -1181,6 +1181,9 @@ extern int ext4_orphan_add(handle_t *, s
- #define ll_ext4_find_entry(inode, dentry, res_dir) ext4_find_entry(inode, &(dentry)->d_name, res_dir)
- extern int ext4_add_dot_dotdot(handle_t *handle, struct inode *dir,
-                              struct inode *inode);
-+extern struct buffer_head *ext4_append(handle_t *handle,
-+                                     struct inode *inode,
-+                                     ext4_lblk_t *block, int *err);
- /* resize.c */
- extern int ext4_group_add(struct super_block *sb,
-diff -rupN 2.6.27.21_2/fs/ext4/hash.c 2.6.27.21_3/fs/ext4/hash.c
---- 2.6.27.21_2/fs/ext4/hash.c 2009-07-17 12:12:56.000000000 +0530
-+++ 2.6.27.21_3/fs/ext4/hash.c 2009-07-17 12:40:22.000000000 +0530
-@@ -9,6 +9,7 @@
-  * License.
-  */
-+#include <linux/module.h>
- #include <linux/fs.h>
- #include <linux/jbd2.h>
- #include <linux/cryptohash.h>
-@@ -206,3 +207,4 @@ int ext4fs_dirhash(const char *name, int
-       hinfo->minor_hash = minor_hash;
-       return 0;
- }
-+EXPORT_SYMBOL(ext4fs_dirhash);
-diff -rupN 2.6.27.21_2/fs/ext4/namei.c 2.6.27.21_3/fs/ext4/namei.c
---- 2.6.27.21_2/fs/ext4/namei.c        2009-07-17 12:23:51.000000000 +0530
-+++ 2.6.27.21_3/fs/ext4/namei.c        2009-07-17 12:37:59.000000000 +0530
-@@ -51,9 +51,9 @@
- #define NAMEI_RA_SIZE      (NAMEI_RA_CHUNKS * NAMEI_RA_BLOCKS)
- #define NAMEI_RA_INDEX(c,b)  (((c) * NAMEI_RA_BLOCKS) + (b))
--static struct buffer_head *ext4_append(handle_t *handle,
--                                      struct inode *inode,
--                                      ext4_lblk_t *block, int *err)
-+struct buffer_head *ext4_append(handle_t *handle,
-+                              struct inode *inode,
-+                              ext4_lblk_t *block, int *err)
- {
-       struct buffer_head *bh;
-       struct ext4_inode_info *ei = EXT4_I(inode);
-@@ -72,6 +72,7 @@ static struct buffer_head *ext4_append(h
-       up(&ei->i_append_sem);
-       return bh;
- }
-+EXPORT_SYMBOL(ext4_append);
- #ifndef assert
- #define assert(test) J_ASSERT(test)
-diff -rupN 2.6.27.21_2/fs/ext4/super.c 2.6.27.21_3/fs/ext4/super.c
---- 2.6.27.21_2/fs/ext4/super.c        2009-07-17 12:12:57.000000000 +0530
-+++ 2.6.27.21_3/fs/ext4/super.c        2009-07-17 12:40:52.000000000 +0530
-@@ -377,6 +377,7 @@ void __ext4_std_error(struct super_block
-       ext4_handle_error(sb);
- }
-+EXPORT_SYMBOL(__ext4_std_error);
- /*
-  * ext4_abort is a much stronger failure handler than ext4_error.  The
diff --git a/ldiskfs/kernel_patches/patches/rhel6.3/ext4-pdir-fix.patch b/ldiskfs/kernel_patches/patches/rhel6.3/ext4-pdir-fix.patch
deleted file mode 100644 (file)
index 0f261d1..0000000
+++ /dev/null
@@ -1,52 +0,0 @@
-Index: linux-stage/fs/ext4/ext4.h
-===================================================================
---- linux-stage.orig/fs/ext4/ext4.h    2012-08-07 11:52:38.994200699 -0700
-+++ linux-stage/fs/ext4/ext4.h 2012-08-07 12:28:19.497442862 -0700
-@@ -706,6 +707,9 @@
-       __u32   i_dtime;
-       ext4_fsblk_t    i_file_acl;
-+      /* following fields for parallel directory operations -bzzz */
-+      struct semaphore i_append_sem;
-+
-       /*
-        * i_block_group is the number of the block group which contains
-        * this file's inode.  Constant across the lifetime of the inode,
-Index: linux-stage/fs/ext4/namei.c
-===================================================================
---- linux-stage.orig/fs/ext4/namei.c   2012-08-07 11:52:38.992199430 -0700
-+++ linux-stage/fs/ext4/namei.c        2012-08-07 12:27:24.845281099 -0700
-@@ -53,6 +53,11 @@
-                                       ext4_lblk_t *block, int *err)
- {
-       struct buffer_head *bh;
-+      struct ext4_inode_info *ei = EXT4_I(inode);
-+
-+      /* with parallel dir operations all appends
-+      * have to be serialized -bzzz */
-+      down(&ei->i_append_sem);
-       *block = inode->i_size >> inode->i_sb->s_blocksize_bits;
-@@ -65,7 +70,9 @@
-                       brelse(bh);
-                       bh = NULL;
-               }
-+              ei->i_disksize = inode->i_size;
-       }
-+      up(&ei->i_append_sem);
-       return bh;
- }
-Index: linux-stage/fs/ext4/super.c
-===================================================================
---- linux-stage.orig/fs/ext4/super.c   2012-08-07 11:52:39.009197356 -0700
-+++ linux-stage/fs/ext4/super.c        2012-08-07 12:28:29.499112997 -0700
-@@ -749,6 +749,7 @@
-       ei->vfs_inode.i_version = 1;
-       ei->vfs_inode.i_data.writeback_index = 0;
-+      sema_init(&ei->i_append_sem, 1);
-       memset(&ei->i_cached_extent, 0, sizeof(struct ext4_ext_cache));
-       INIT_LIST_HEAD(&ei->i_prealloc_list);
-       spin_lock_init(&ei->i_prealloc_lock);
diff --git a/ldiskfs/kernel_patches/patches/rhel6.3/ext4-pdirop.patch b/ldiskfs/kernel_patches/patches/rhel6.3/ext4-pdirop.patch
deleted file mode 100644 (file)
index 0bbed17..0000000
+++ /dev/null
@@ -1,1872 +0,0 @@
-Index: linux-2.6.32-504.3.3.el6.x86_64/include/linux/htree_lock.h
-===================================================================
---- /dev/null
-+++ linux-2.6.32-504.3.3.el6.x86_64/include/linux/htree_lock.h
-@@ -0,0 +1,187 @@
-+/*
-+ * include/linux/htree_lock.h
-+ *
-+ * Copyright (c) 2011, 2012, Intel Corporation.
-+ *
-+ * Author: Liang Zhen <liang@whamcloud.com>
-+ */
-+
-+/*
-+ * htree lock
-+ *
-+ * htree_lock is an advanced lock, it can support five lock modes (concept is
-+ * taken from DLM) and it's a sleeping lock.
-+ *
-+ * most common use case is:
-+ * - create a htree_lock_head for data
-+ * - each thread (contender) creates it's own htree_lock
-+ * - contender needs to call htree_lock(lock_node, mode) to protect data and
-+ *   call htree_unlock to release lock
-+ *
-+ * Also, there is advanced use-case which is more complex, user can have
-+ * PW/PR lock on particular key, it's mostly used while user holding shared
-+ * lock on the htree (CW, CR)
-+ *
-+ * htree_lock(lock_node, HTREE_LOCK_CR); lock the htree with CR
-+ * htree_node_lock(lock_node, HTREE_LOCK_PR, key...); lock @key with PR
-+ * ...
-+ * htree_node_unlock(lock_node);; unlock the key
-+ *
-+ * Another tip is, we can have N-levels of this kind of keys, all we need to
-+ * do is specifying N-levels while creating htree_lock_head, then we can
-+ * lock/unlock a specific level by:
-+ * htree_node_lock(lock_node, mode1, key1, level1...);
-+ * do something;
-+ * htree_node_lock(lock_node, mode1, key2, level2...);
-+ * do something;
-+ * htree_node_unlock(lock_node, level2);
-+ * htree_node_unlock(lock_node, level1);
-+ *
-+ * NB: for multi-level, should be careful about locking order to avoid deadlock
-+ */
-+
-+#ifndef _LINUX_HTREE_LOCK_H
-+#define _LINUX_HTREE_LOCK_H
-+
-+#include <linux/list.h>
-+#include <linux/spinlock.h>
-+#include <linux/sched.h>
-+
-+/*
-+ * Lock Modes
-+ * more details can be found here:
-+ * http://en.wikipedia.org/wiki/Distributed_lock_manager
-+ */
-+typedef enum {
-+      HTREE_LOCK_EX   = 0, /* exclusive lock: incompatible with all others */
-+      HTREE_LOCK_PW,       /* protected write: allows only CR users */
-+      HTREE_LOCK_PR,       /* protected read: allow PR, CR users */
-+      HTREE_LOCK_CW,       /* concurrent write: allow CR, CW users */
-+      HTREE_LOCK_CR,       /* concurrent read: allow all but EX users */
-+      HTREE_LOCK_MAX,      /* number of lock modes */
-+} htree_lock_mode_t;
-+
-+#define HTREE_LOCK_NL         HTREE_LOCK_MAX
-+#define HTREE_LOCK_INVAL      0xdead10c
-+
-+enum {
-+      HTREE_HBITS_MIN         = 2,
-+      HTREE_HBITS_DEF         = 14,
-+      HTREE_HBITS_MAX         = 32,
-+};
-+
-+enum {
-+      HTREE_EVENT_DISABLE     = (0),
-+      HTREE_EVENT_RD          = (1 << HTREE_LOCK_PR),
-+      HTREE_EVENT_WR          = (1 << HTREE_LOCK_PW),
-+      HTREE_EVENT_RDWR        = (HTREE_EVENT_RD | HTREE_EVENT_WR),
-+};
-+
-+struct htree_lock;
-+
-+typedef void (*htree_event_cb_t)(void *target, void *event);
-+
-+struct htree_lock_child {
-+      struct list_head        lc_list;        /* granted list */
-+      htree_event_cb_t        lc_callback;    /* event callback */
-+      unsigned                lc_events;      /* event types */
-+};
-+
-+struct htree_lock_head {
-+      unsigned long           lh_lock;        /* bits lock */
-+      /* blocked lock list (htree_lock) */
-+      struct list_head        lh_blocked_list;
-+      /* # key levels */
-+      u16                     lh_depth;
-+      /* hash bits for key and limit number of locks */
-+      u16                     lh_hbits;
-+      /* counters for blocked locks */
-+      u16                     lh_nblocked[HTREE_LOCK_MAX];
-+      /* counters for granted locks */
-+      u16                     lh_ngranted[HTREE_LOCK_MAX];
-+      /* private data */
-+      void                    *lh_private;
-+      /* array of children locks */
-+      struct htree_lock_child lh_children[0];
-+};
-+
-+/* htree_lock_node_t is child-lock for a specific key (ln_value) */
-+struct htree_lock_node {
-+      htree_lock_mode_t       ln_mode;
-+      /* major hash key */
-+      u16                     ln_major_key;
-+      /* minor hash key */
-+      u16                     ln_minor_key;
-+      struct list_head        ln_major_list;
-+      struct list_head        ln_minor_list;
-+      /* alive list, all locks (granted, blocked, listening) are on it */
-+      struct list_head        ln_alive_list;
-+      /* blocked list */
-+      struct list_head        ln_blocked_list;
-+      /* granted list */
-+      struct list_head        ln_granted_list;
-+      void                    *ln_ev_target;
-+};
-+
-+struct htree_lock {
-+      struct task_struct      *lk_task;
-+      struct htree_lock_head  *lk_head;
-+      void                    *lk_private;
-+      unsigned                lk_depth;
-+      htree_lock_mode_t       lk_mode;
-+      struct list_head        lk_blocked_list;
-+      struct htree_lock_node  lk_nodes[0];
-+};
-+
-+/* create a lock head, which stands for a resource */
-+struct htree_lock_head *htree_lock_head_alloc(unsigned depth,
-+                                            unsigned hbits, unsigned priv);
-+/* free a lock head */
-+void htree_lock_head_free(struct htree_lock_head *lhead);
-+/* register event callback for child lock at level @depth */
-+void htree_lock_event_attach(struct htree_lock_head *lhead, unsigned depth,
-+                           unsigned events, htree_event_cb_t callback);
-+/* create a lock handle, which stands for a thread */
-+struct htree_lock *htree_lock_alloc(unsigned depth, unsigned pbytes);
-+/* free a lock handle */
-+void htree_lock_free(struct htree_lock *lck);
-+/* lock htree, when @wait is true, 0 is returned if the lock can't
-+ * be granted immediately */
-+int htree_lock_try(struct htree_lock *lck, struct htree_lock_head *lhead,
-+                 htree_lock_mode_t mode, int wait);
-+/* unlock htree */
-+void htree_unlock(struct htree_lock *lck);
-+/* unlock and relock htree with @new_mode */
-+int htree_change_lock_try(struct htree_lock *lck,
-+                        htree_lock_mode_t new_mode, int wait);
-+void htree_change_mode(struct htree_lock *lck, htree_lock_mode_t mode);
-+/* require child lock (key) of htree at level @dep, @event will be sent to all
-+ * listeners on this @key while lock being granted */
-+int htree_node_lock_try(struct htree_lock *lck, htree_lock_mode_t mode,
-+                      u32 key, unsigned dep, int wait, void *event);
-+/* release child lock at level @dep, this lock will listen on it's key
-+ * if @event isn't NULL, event_cb will be called against @lck while granting
-+ * any other lock at level @dep with the same key */
-+void htree_node_unlock(struct htree_lock *lck, unsigned dep, void *event);
-+/* stop listening on child lock at level @dep */
-+void htree_node_stop_listen(struct htree_lock *lck, unsigned dep);
-+/* for debug */
-+void htree_lock_stat_print(int depth);
-+void htree_lock_stat_reset(void);
-+
-+#define htree_lock(lck, lh, mode)     htree_lock_try(lck, lh, mode, 1)
-+#define htree_change_lock(lck, mode)  htree_change_lock_try(lck, mode, 1)
-+
-+#define htree_lock_mode(lck)          ((lck)->lk_mode)
-+
-+#define htree_node_lock(lck, mode, key, dep)  \
-+      htree_node_lock_try(lck, mode, key, dep, 1, NULL)
-+/* this is only safe in thread context of lock owner */
-+#define htree_node_is_granted(lck, dep)               \
-+      ((lck)->lk_nodes[dep].ln_mode != HTREE_LOCK_INVAL && \
-+       (lck)->lk_nodes[dep].ln_mode != HTREE_LOCK_NL)
-+/* this is only safe in thread context of lock owner */
-+#define htree_node_is_listening(lck, dep)     \
-+      ((lck)->lk_nodes[dep].ln_mode == HTREE_LOCK_NL)
-+
-+#endif
-Index: linux-2.6.32-504.3.3.el6.x86_64/fs/ext4/htree_lock.c
-===================================================================
---- /dev/null
-+++ linux-2.6.32-504.3.3.el6.x86_64/fs/ext4/htree_lock.c
-@@ -0,0 +1,880 @@
-+/*
-+ * fs/ext4/htree_lock.c
-+ *
-+ * Copyright (c) 2011, 2012, Intel Corporation.
-+ *
-+ * Author: Liang Zhen <liang@whamcloud.com>
-+ */
-+#include <linux/jbd2.h>
-+#include <linux/hash.h>
-+#include <linux/module.h>
-+#include <linux/htree_lock.h>
-+
-+enum {
-+      HTREE_LOCK_BIT_EX       = (1 << HTREE_LOCK_EX),
-+      HTREE_LOCK_BIT_PW       = (1 << HTREE_LOCK_PW),
-+      HTREE_LOCK_BIT_PR       = (1 << HTREE_LOCK_PR),
-+      HTREE_LOCK_BIT_CW       = (1 << HTREE_LOCK_CW),
-+      HTREE_LOCK_BIT_CR       = (1 << HTREE_LOCK_CR),
-+};
-+
-+enum {
-+      HTREE_LOCK_COMPAT_EX    = 0,
-+      HTREE_LOCK_COMPAT_PW    = HTREE_LOCK_COMPAT_EX | HTREE_LOCK_BIT_CR,
-+      HTREE_LOCK_COMPAT_PR    = HTREE_LOCK_COMPAT_PW | HTREE_LOCK_BIT_PR,
-+      HTREE_LOCK_COMPAT_CW    = HTREE_LOCK_COMPAT_PW | HTREE_LOCK_BIT_CW,
-+      HTREE_LOCK_COMPAT_CR    = HTREE_LOCK_COMPAT_CW | HTREE_LOCK_BIT_PR |
-+                                HTREE_LOCK_BIT_PW,
-+};
-+
-+static int htree_lock_compat[] = {
-+      [HTREE_LOCK_EX]         HTREE_LOCK_COMPAT_EX,
-+      [HTREE_LOCK_PW]         HTREE_LOCK_COMPAT_PW,
-+      [HTREE_LOCK_PR]         HTREE_LOCK_COMPAT_PR,
-+      [HTREE_LOCK_CW]         HTREE_LOCK_COMPAT_CW,
-+      [HTREE_LOCK_CR]         HTREE_LOCK_COMPAT_CR,
-+};
-+
-+/* max allowed htree-lock depth.
-+ * We only need depth=3 for ext4 although user can have higher value. */
-+#define HTREE_LOCK_DEP_MAX    16
-+
-+#ifdef HTREE_LOCK_DEBUG
-+
-+static char *hl_name[] = {
-+      [HTREE_LOCK_EX]         "EX",
-+      [HTREE_LOCK_PW]         "PW",
-+      [HTREE_LOCK_PR]         "PR",
-+      [HTREE_LOCK_CW]         "CW",
-+      [HTREE_LOCK_CR]         "CR",
-+};
-+
-+/* lock stats */
-+struct htree_lock_node_stats {
-+      unsigned long long      blocked[HTREE_LOCK_MAX];
-+      unsigned long long      granted[HTREE_LOCK_MAX];
-+      unsigned long long      retried[HTREE_LOCK_MAX];
-+      unsigned long long      events;
-+};
-+
-+struct htree_lock_stats {
-+      struct htree_lock_node_stats    nodes[HTREE_LOCK_DEP_MAX];
-+      unsigned long long      granted[HTREE_LOCK_MAX];
-+      unsigned long long      blocked[HTREE_LOCK_MAX];
-+};
-+
-+static struct htree_lock_stats hl_stats;
-+
-+void htree_lock_stat_reset(void)
-+{
-+      memset(&hl_stats, 0, sizeof(hl_stats));
-+}
-+
-+void htree_lock_stat_print(int depth)
-+{
-+      int     i;
-+      int     j;
-+
-+      printk(KERN_DEBUG "HTREE LOCK STATS:\n");
-+      for (i = 0; i < HTREE_LOCK_MAX; i++) {
-+              printk(KERN_DEBUG "[%s]: G [%10llu], B [%10llu]\n",
-+                     hl_name[i], hl_stats.granted[i], hl_stats.blocked[i]);
-+      }
-+      for (i = 0; i < depth; i++) {
-+              printk(KERN_DEBUG "HTREE CHILD [%d] STATS:\n", i);
-+              for (j = 0; j < HTREE_LOCK_MAX; j++) {
-+                      printk(KERN_DEBUG
-+                              "[%s]: G [%10llu], B [%10llu], R [%10llu]\n",
-+                              hl_name[j], hl_stats.nodes[i].granted[j],
-+                              hl_stats.nodes[i].blocked[j],
-+                              hl_stats.nodes[i].retried[j]);
-+              }
-+      }
-+}
-+
-+#define lk_grant_inc(m)       do { hl_stats.granted[m]++; } while (0)
-+#define lk_block_inc(m)       do { hl_stats.blocked[m]++; } while (0)
-+#define ln_grant_inc(d, m)    do { hl_stats.nodes[d].granted[m]++; } while (0)
-+#define ln_block_inc(d, m)    do { hl_stats.nodes[d].blocked[m]++; } while (0)
-+#define ln_retry_inc(d, m)    do { hl_stats.nodes[d].retried[m]++; } while (0)
-+#define ln_event_inc(d)       do { hl_stats.nodes[d].events++; } while (0)
-+
-+#else /* !DEBUG */
-+
-+void htree_lock_stat_reset(void) {}
-+void htree_lock_stat_print(int depth) {}
-+
-+#define lk_grant_inc(m)             do {} while (0)
-+#define lk_block_inc(m)             do {} while (0)
-+#define ln_grant_inc(d, m)    do {} while (0)
-+#define ln_block_inc(d, m)    do {} while (0)
-+#define ln_retry_inc(d, m)    do {} while (0)
-+#define ln_event_inc(d)             do {} while (0)
-+
-+#endif /* DEBUG */
-+
-+EXPORT_SYMBOL(htree_lock_stat_reset);
-+EXPORT_SYMBOL(htree_lock_stat_print);
-+
-+#define HTREE_DEP_ROOT                  (-1)
-+
-+#define htree_spin_lock(lhead, dep)                           \
-+      bit_spin_lock((dep) + 1, &(lhead)->lh_lock)
-+#define htree_spin_unlock(lhead, dep)                         \
-+      bit_spin_unlock((dep) + 1, &(lhead)->lh_lock)
-+
-+#define htree_key_event_ignore(child, ln)                     \
-+      (!((child)->lc_events & (1 << (ln)->ln_mode)))
-+
-+static int
-+htree_key_list_empty(struct htree_lock_node *ln)
-+{
-+      return list_empty(&ln->ln_major_list) && list_empty(&ln->ln_minor_list);
-+}
-+
-+static void
-+htree_key_list_del_init(struct htree_lock_node *ln)
-+{
-+      struct htree_lock_node *tmp = NULL;
-+
-+      if (!list_empty(&ln->ln_minor_list)) {
-+              tmp = list_entry(ln->ln_minor_list.next,
-+                               struct htree_lock_node, ln_minor_list);
-+              list_del_init(&ln->ln_minor_list);
-+      }
-+
-+      if (list_empty(&ln->ln_major_list))
-+              return;
-+
-+      if (tmp == NULL) { /* not on minor key list */
-+              list_del_init(&ln->ln_major_list);
-+      } else {
-+              BUG_ON(!list_empty(&tmp->ln_major_list));
-+              list_replace_init(&ln->ln_major_list, &tmp->ln_major_list);
-+      }
-+}
-+
-+static void
-+htree_key_list_replace_init(struct htree_lock_node *old,
-+                          struct htree_lock_node *new)
-+{
-+      if (!list_empty(&old->ln_major_list))
-+              list_replace_init(&old->ln_major_list, &new->ln_major_list);
-+
-+      if (!list_empty(&old->ln_minor_list))
-+              list_replace_init(&old->ln_minor_list, &new->ln_minor_list);
-+}
-+
-+static void
-+htree_key_event_enqueue(struct htree_lock_child *child,
-+                      struct htree_lock_node *ln, int dep, void *event)
-+{
-+      struct htree_lock_node *tmp;
-+
-+      /* NB: ALWAYS called holding lhead::lh_lock(dep) */
-+      BUG_ON(ln->ln_mode == HTREE_LOCK_NL);
-+      if (event == NULL || htree_key_event_ignore(child, ln))
-+              return;
-+
-+      /* shouldn't be a very long list */
-+      list_for_each_entry(tmp, &ln->ln_alive_list, ln_alive_list) {
-+              if (tmp->ln_mode == HTREE_LOCK_NL) {
-+                      ln_event_inc(dep);
-+                      if (child->lc_callback != NULL)
-+                              child->lc_callback(tmp->ln_ev_target, event);
-+              }
-+      }
-+}
-+
-+static int
-+htree_node_lock_enqueue(struct htree_lock *newlk, struct htree_lock *curlk,
-+                      unsigned dep, int wait, void *event)
-+{
-+      struct htree_lock_child *child = &newlk->lk_head->lh_children[dep];
-+      struct htree_lock_node *newln = &newlk->lk_nodes[dep];
-+      struct htree_lock_node *curln = &curlk->lk_nodes[dep];
-+
-+      /* NB: ALWAYS called holding lhead::lh_lock(dep) */
-+      /* NB: we only expect PR/PW lock mode at here, only these two modes are
-+       * allowed for htree_node_lock(asserted in htree_node_lock_internal),
-+       * NL is only used for listener, user can't directly require NL mode */
-+      if ((curln->ln_mode == HTREE_LOCK_NL) ||
-+          (curln->ln_mode != HTREE_LOCK_PW &&
-+           newln->ln_mode != HTREE_LOCK_PW)) {
-+              /* no conflict, attach it on granted list of @curlk */
-+              if (curln->ln_mode != HTREE_LOCK_NL) {
-+                      list_add(&newln->ln_granted_list,
-+                               &curln->ln_granted_list);
-+              } else {
-+                      /* replace key owner */
-+                      htree_key_list_replace_init(curln, newln);
-+              }
-+
-+              list_add(&newln->ln_alive_list, &curln->ln_alive_list);
-+              htree_key_event_enqueue(child, newln, dep, event);
-+              ln_grant_inc(dep, newln->ln_mode);
-+              return 1; /* still hold lh_lock */
-+      }
-+
-+      if (!wait) { /* can't grant and don't want to wait */
-+              ln_retry_inc(dep, newln->ln_mode);
-+              newln->ln_mode = HTREE_LOCK_INVAL;
-+              return -1; /* don't wait and just return -1 */
-+      }
-+
-+      newlk->lk_task = current;
-+      set_current_state(TASK_UNINTERRUPTIBLE);
-+      /* conflict, attach it on blocked list of curlk */
-+      list_add_tail(&newln->ln_blocked_list, &curln->ln_blocked_list);
-+      list_add(&newln->ln_alive_list, &curln->ln_alive_list);
-+      ln_block_inc(dep, newln->ln_mode);
-+
-+      htree_spin_unlock(newlk->lk_head, dep);
-+      /* wait to be given the lock */
-+      if (newlk->lk_task != NULL)
-+              schedule();
-+      /* granted, no doubt, wake up will set me RUNNING */
-+      if (event == NULL || htree_key_event_ignore(child, newln))
-+              return 0; /* granted without lh_lock */
-+
-+      htree_spin_lock(newlk->lk_head, dep);
-+      htree_key_event_enqueue(child, newln, dep, event);
-+      return 1; /* still hold lh_lock */
-+}
-+
-+/*
-+ * get PR/PW access to particular tree-node according to @dep and @key,
-+ * it will return -1 if @wait is false and can't immediately grant this lock.
-+ * All listeners(HTREE_LOCK_NL) on @dep and with the same @key will get
-+ * @event if it's not NULL.
-+ * NB: ALWAYS called holding lhead::lh_lock
-+ */
-+static int
-+htree_node_lock_internal(struct htree_lock_head *lhead, struct htree_lock *lck,
-+                       htree_lock_mode_t mode, u32 key, unsigned dep,
-+                       int wait, void *event)
-+{
-+      LIST_HEAD               (list);
-+      struct htree_lock       *tmp;
-+      struct htree_lock       *tmp2;
-+      u16                     major;
-+      u16                     minor;
-+      u8                      reverse;
-+      u8                      ma_bits;
-+      u8                      mi_bits;
-+
-+      BUG_ON(mode != HTREE_LOCK_PW && mode != HTREE_LOCK_PR);
-+      BUG_ON(htree_node_is_granted(lck, dep));
-+
-+      key = hash_long(key, lhead->lh_hbits);
-+
-+      mi_bits = lhead->lh_hbits >> 1;
-+      ma_bits = lhead->lh_hbits - mi_bits;
-+
-+      lck->lk_nodes[dep].ln_major_key = major = key & ((1U << ma_bits) - 1);
-+      lck->lk_nodes[dep].ln_minor_key = minor = key >> ma_bits;
-+      lck->lk_nodes[dep].ln_mode = mode;
-+
-+      /*
-+       * The major key list is an ordered list, so searches are started
-+       * at the end of the list that is numerically closer to major_key,
-+       * so at most half of the list will be walked (for well-distributed
-+       * keys). The list traversal aborts early if the expected key
-+       * location is passed.
-+       */
-+      reverse = (major >= (1 << (ma_bits - 1)));
-+
-+      if (reverse) {
-+              list_for_each_entry_reverse(tmp,
-+                                      &lhead->lh_children[dep].lc_list,
-+                                      lk_nodes[dep].ln_major_list) {
-+                      if (tmp->lk_nodes[dep].ln_major_key == major) {
-+                              goto search_minor;
-+
-+                      } else if (tmp->lk_nodes[dep].ln_major_key < major) {
-+                              /* attach _after_ @tmp */
-+                              list_add(&lck->lk_nodes[dep].ln_major_list,
-+                                       &tmp->lk_nodes[dep].ln_major_list);
-+                              goto out_grant_major;
-+                      }
-+              }
-+
-+              list_add(&lck->lk_nodes[dep].ln_major_list,
-+                       &lhead->lh_children[dep].lc_list);
-+              goto out_grant_major;
-+
-+      } else {
-+              list_for_each_entry(tmp, &lhead->lh_children[dep].lc_list,
-+                                  lk_nodes[dep].ln_major_list) {
-+                      if (tmp->lk_nodes[dep].ln_major_key == major) {
-+                              goto search_minor;
-+
-+                      } else if (tmp->lk_nodes[dep].ln_major_key > major) {
-+                              /* insert _before_ @tmp */
-+                              list_add_tail(&lck->lk_nodes[dep].ln_major_list,
-+                                      &tmp->lk_nodes[dep].ln_major_list);
-+                              goto out_grant_major;
-+                      }
-+              }
-+
-+              list_add_tail(&lck->lk_nodes[dep].ln_major_list,
-+                            &lhead->lh_children[dep].lc_list);
-+              goto out_grant_major;
-+      }
-+
-+ search_minor:
-+      /*
-+       * NB: minor_key list doesn't have a "head", @list is just a
-+       * temporary stub for helping list searching, make sure it's removed
-+       * after searching.
-+       * minor_key list is an ordered list too.
-+       */
-+      list_add_tail(&list, &tmp->lk_nodes[dep].ln_minor_list);
-+
-+      reverse = (minor >= (1 << (mi_bits - 1)));
-+
-+      if (reverse) {
-+              list_for_each_entry_reverse(tmp2, &list,
-+                                          lk_nodes[dep].ln_minor_list) {
-+                      if (tmp2->lk_nodes[dep].ln_minor_key == minor) {
-+                              goto out_enqueue;
-+
-+                      } else if (tmp2->lk_nodes[dep].ln_minor_key < minor) {
-+                              /* attach _after_ @tmp2 */
-+                              list_add(&lck->lk_nodes[dep].ln_minor_list,
-+                                       &tmp2->lk_nodes[dep].ln_minor_list);
-+                              goto out_grant_minor;
-+                      }
-+              }
-+
-+              list_add(&lck->lk_nodes[dep].ln_minor_list, &list);
-+
-+      } else {
-+              list_for_each_entry(tmp2, &list,
-+                                  lk_nodes[dep].ln_minor_list) {
-+                      if (tmp2->lk_nodes[dep].ln_minor_key == minor) {
-+                              goto out_enqueue;
-+
-+                      } else if (tmp2->lk_nodes[dep].ln_minor_key > minor) {
-+                              /* insert _before_ @tmp2 */
-+                              list_add_tail(&lck->lk_nodes[dep].ln_minor_list,
-+                                      &tmp2->lk_nodes[dep].ln_minor_list);
-+                              goto out_grant_minor;
-+                      }
-+              }
-+
-+              list_add_tail(&lck->lk_nodes[dep].ln_minor_list, &list);
-+      }
-+
-+ out_grant_minor:
-+      if (list.next == &lck->lk_nodes[dep].ln_minor_list) {
-+              /* new lock @lck is the first one on minor_key list, which
-+               * means it has the smallest minor_key and it should
-+               * replace @tmp as minor_key owner */
-+              list_replace_init(&tmp->lk_nodes[dep].ln_major_list,
-+                                &lck->lk_nodes[dep].ln_major_list);
-+      }
-+      /* remove the temporary head */
-+      list_del(&list);
-+
-+ out_grant_major:
-+      ln_grant_inc(dep, lck->lk_nodes[dep].ln_mode);
-+      return 1; /* granted with holding lh_lock */
-+
-+ out_enqueue:
-+      list_del(&list); /* remove temprary head */
-+      return htree_node_lock_enqueue(lck, tmp2, dep, wait, event);
-+}
-+
-+/*
-+ * release the key of @lck at level @dep, and grant any blocked locks.
-+ * caller will still listen on @key if @event is not NULL, which means
-+ * caller can see a event (by event_cb) while granting any lock with
-+ * the same key at level @dep.
-+ * NB: ALWAYS called holding lhead::lh_lock
-+ * NB: listener will not block anyone because listening mode is HTREE_LOCK_NL
-+ */
-+static void
-+htree_node_unlock_internal(struct htree_lock_head *lhead,
-+                         struct htree_lock *curlk, unsigned dep, void *event)
-+{
-+      struct htree_lock_node  *curln = &curlk->lk_nodes[dep];
-+      struct htree_lock       *grtlk = NULL;
-+      struct htree_lock_node  *grtln;
-+      struct htree_lock       *poslk;
-+      struct htree_lock       *tmplk;
-+
-+      if (!htree_node_is_granted(curlk, dep))
-+              return;
-+
-+      if (!list_empty(&curln->ln_granted_list)) {
-+              /* there is another granted lock */
-+              grtlk = list_entry(curln->ln_granted_list.next,
-+                                 struct htree_lock,
-+                                 lk_nodes[dep].ln_granted_list);
-+              list_del_init(&curln->ln_granted_list);
-+      }
-+
-+      if (grtlk == NULL && !list_empty(&curln->ln_blocked_list)) {
-+              /*
-+               * @curlk is the only granted lock, so we confirmed:
-+               * a) curln is key owner (attached on major/minor_list),
-+               *    so if there is any blocked lock, it should be attached
-+               *    on curln->ln_blocked_list
-+               * b) we always can grant the first blocked lock
-+               */
-+              grtlk = list_entry(curln->ln_blocked_list.next,
-+                                 struct htree_lock,
-+                                 lk_nodes[dep].ln_blocked_list);
-+              BUG_ON(grtlk->lk_task == NULL);
-+              wake_up_process(grtlk->lk_task);
-+      }
-+
-+      if (event != NULL &&
-+          lhead->lh_children[dep].lc_events != HTREE_EVENT_DISABLE) {
-+              curln->ln_ev_target = event;
-+              curln->ln_mode = HTREE_LOCK_NL; /* listen! */
-+      } else {
-+              curln->ln_mode = HTREE_LOCK_INVAL;
-+      }
-+
-+      if (grtlk == NULL) { /* I must be the only one locking this key */
-+              struct htree_lock_node *tmpln;
-+
-+              BUG_ON(htree_key_list_empty(curln));
-+
-+              if (curln->ln_mode == HTREE_LOCK_NL) /* listening */
-+                      return;
-+
-+              /* not listening */
-+              if (list_empty(&curln->ln_alive_list)) { /* no more listener */
-+                      htree_key_list_del_init(curln);
-+                      return;
-+              }
-+
-+              tmpln = list_entry(curln->ln_alive_list.next,
-+                                 struct htree_lock_node, ln_alive_list);
-+
-+              BUG_ON(tmpln->ln_mode != HTREE_LOCK_NL);
-+
-+              htree_key_list_replace_init(curln, tmpln);
-+              list_del_init(&curln->ln_alive_list);
-+
-+              return;
-+      }
-+
-+      /* have a granted lock */
-+      grtln = &grtlk->lk_nodes[dep];
-+      if (!list_empty(&curln->ln_blocked_list)) {
-+              /* only key owner can be on both lists */
-+              BUG_ON(htree_key_list_empty(curln));
-+
-+              if (list_empty(&grtln->ln_blocked_list)) {
-+                      list_add(&grtln->ln_blocked_list,
-+                               &curln->ln_blocked_list);
-+              }
-+              list_del_init(&curln->ln_blocked_list);
-+      }
-+      /*
-+       * NB: this is the tricky part:
-+       * We have only two modes for child-lock (PR and PW), also,
-+       * only owner of the key (attached on major/minor_list) can be on
-+       * both blocked_list and granted_list, so @grtlk must be one
-+       * of these two cases:
-+       *
-+       * a) @grtlk is taken from granted_list, which means we've granted
-+       *    more than one lock so @grtlk has to be PR, the first blocked
-+       *    lock must be PW and we can't grant it at all.
-+       *    So even @grtlk is not owner of the key (empty blocked_list),
-+       *    we don't care because we can't grant any lock.
-+       * b) we just grant a new lock which is taken from head of blocked
-+       *    list, and it should be the first granted lock, and it should
-+       *    be the first one linked on blocked_list.
-+       *
-+       * Either way, we can get correct result by iterating blocked_list
-+       * of @grtlk, and don't have to bother on how to find out
-+       * owner of current key.
-+       */
-+      list_for_each_entry_safe(poslk, tmplk, &grtln->ln_blocked_list,
-+                               lk_nodes[dep].ln_blocked_list) {
-+              if (grtlk->lk_nodes[dep].ln_mode == HTREE_LOCK_PW ||
-+                  poslk->lk_nodes[dep].ln_mode == HTREE_LOCK_PW)
-+                      break;
-+              /* grant all readers */
-+              list_del_init(&poslk->lk_nodes[dep].ln_blocked_list);
-+              list_add(&poslk->lk_nodes[dep].ln_granted_list,
-+                       &grtln->ln_granted_list);
-+
-+              BUG_ON(poslk->lk_task == NULL);
-+              wake_up_process(poslk->lk_task);
-+      }
-+
-+      /* if @curln is the owner of this key, replace it with @grtln */
-+      if (!htree_key_list_empty(curln))
-+              htree_key_list_replace_init(curln, grtln);
-+
-+      if (curln->ln_mode == HTREE_LOCK_INVAL)
-+              list_del_init(&curln->ln_alive_list);
-+}
-+
-+/*
-+ * it's just wrapper of htree_node_lock_internal, it returns 1 on granted
-+ * and 0 only if @wait is false and can't grant it immediately
-+ */
-+int
-+htree_node_lock_try(struct htree_lock *lck, htree_lock_mode_t mode,
-+                  u32 key, unsigned dep, int wait, void *event)
-+{
-+      struct htree_lock_head *lhead = lck->lk_head;
-+      int rc;
-+
-+      BUG_ON(dep >= lck->lk_depth);
-+      BUG_ON(lck->lk_mode == HTREE_LOCK_INVAL);
-+
-+      htree_spin_lock(lhead, dep);
-+      rc = htree_node_lock_internal(lhead, lck, mode, key, dep, wait, event);
-+      if (rc != 0)
-+              htree_spin_unlock(lhead, dep);
-+      return rc >= 0;
-+}
-+EXPORT_SYMBOL(htree_node_lock_try);
-+
-+/* it's wrapper of htree_node_unlock_internal */
-+void
-+htree_node_unlock(struct htree_lock *lck, unsigned dep, void *event)
-+{
-+      struct htree_lock_head *lhead = lck->lk_head;
-+
-+      BUG_ON(dep >= lck->lk_depth);
-+      BUG_ON(lck->lk_mode == HTREE_LOCK_INVAL);
-+
-+      htree_spin_lock(lhead, dep);
-+      htree_node_unlock_internal(lhead, lck, dep, event);
-+      htree_spin_unlock(lhead, dep);
-+}
-+EXPORT_SYMBOL(htree_node_unlock);
-+
-+/* stop listening on child-lock level @dep */
-+void
-+htree_node_stop_listen(struct htree_lock *lck, unsigned dep)
-+{
-+      struct htree_lock_node *ln = &lck->lk_nodes[dep];
-+      struct htree_lock_node *tmp;
-+
-+      BUG_ON(htree_node_is_granted(lck, dep));
-+      BUG_ON(!list_empty(&ln->ln_blocked_list));
-+      BUG_ON(!list_empty(&ln->ln_granted_list));
-+
-+      if (!htree_node_is_listening(lck, dep))
-+              return;
-+
-+      htree_spin_lock(lck->lk_head, dep);
-+      ln->ln_mode = HTREE_LOCK_INVAL;
-+      ln->ln_ev_target = NULL;
-+
-+      if (htree_key_list_empty(ln)) { /* not owner */
-+              list_del_init(&ln->ln_alive_list);
-+              goto out;
-+      }
-+
-+      /* I'm the owner... */
-+      if (list_empty(&ln->ln_alive_list)) { /* no more listener */
-+              htree_key_list_del_init(ln);
-+              goto out;
-+      }
-+
-+      tmp = list_entry(ln->ln_alive_list.next,
-+                       struct htree_lock_node, ln_alive_list);
-+
-+      BUG_ON(tmp->ln_mode != HTREE_LOCK_NL);
-+      htree_key_list_replace_init(ln, tmp);
-+      list_del_init(&ln->ln_alive_list);
-+ out:
-+      htree_spin_unlock(lck->lk_head, dep);
-+}
-+EXPORT_SYMBOL(htree_node_stop_listen);
-+
-+/* release all child-locks if we have any */
-+static void
-+htree_node_release_all(struct htree_lock *lck)
-+{
-+      int     i;
-+
-+      for (i = 0; i < lck->lk_depth; i++) {
-+              if (htree_node_is_granted(lck, i))
-+                      htree_node_unlock(lck, i, NULL);
-+              else if (htree_node_is_listening(lck, i))
-+                      htree_node_stop_listen(lck, i);
-+      }
-+}
-+
-+/*
-+ * obtain htree lock, it could be blocked inside if there's conflict
-+ * with any granted or blocked lock and @wait is true.
-+ * NB: ALWAYS called holding lhead::lh_lock
-+ */
-+static int
-+htree_lock_internal(struct htree_lock *lck, int wait)
-+{
-+      struct htree_lock_head *lhead = lck->lk_head;
-+      int     granted = 0;
-+      int     blocked = 0;
-+      int     i;
-+
-+      for (i = 0; i < HTREE_LOCK_MAX; i++) {
-+              if (lhead->lh_ngranted[i] != 0)
-+                      granted |= 1 << i;
-+              if (lhead->lh_nblocked[i] != 0)
-+                      blocked |= 1 << i;
-+      }
-+      if ((htree_lock_compat[lck->lk_mode] & granted) != granted ||
-+          (htree_lock_compat[lck->lk_mode] & blocked) != blocked) {
-+              /* will block current lock even it just conflicts with any
-+               * other blocked lock, so lock like EX wouldn't starve */
-+              if (!wait)
-+                      return -1;
-+              lhead->lh_nblocked[lck->lk_mode]++;
-+              lk_block_inc(lck->lk_mode);
-+
-+              lck->lk_task = current;
-+              list_add_tail(&lck->lk_blocked_list, &lhead->lh_blocked_list);
-+
-+              set_current_state(TASK_UNINTERRUPTIBLE);
-+              htree_spin_unlock(lhead, HTREE_DEP_ROOT);
-+              /* wait to be given the lock */
-+              if (lck->lk_task != NULL)
-+                      schedule();
-+              /* granted, no doubt. wake up will set me RUNNING */
-+              return 0; /* without lh_lock */
-+      }
-+      lhead->lh_ngranted[lck->lk_mode]++;
-+      lk_grant_inc(lck->lk_mode);
-+      return 1;
-+}
-+
-+/* release htree lock. NB: ALWAYS called holding lhead::lh_lock */
-+static void
-+htree_unlock_internal(struct htree_lock *lck)
-+{
-+      struct htree_lock_head *lhead = lck->lk_head;
-+      struct htree_lock *tmp;
-+      struct htree_lock *tmp2;
-+      int granted = 0;
-+      int i;
-+
-+      BUG_ON(lhead->lh_ngranted[lck->lk_mode] == 0);
-+
-+      lhead->lh_ngranted[lck->lk_mode]--;
-+      lck->lk_mode = HTREE_LOCK_INVAL;
-+
-+      for (i = 0; i < HTREE_LOCK_MAX; i++) {
-+              if (lhead->lh_ngranted[i] != 0)
-+                      granted |= 1 << i;
-+      }
-+      list_for_each_entry_safe(tmp, tmp2,
-+                               &lhead->lh_blocked_list, lk_blocked_list) {
-+              /* conflict with any granted lock? */
-+              if ((htree_lock_compat[tmp->lk_mode] & granted) != granted)
-+                      break;
-+
-+              list_del_init(&tmp->lk_blocked_list);
-+
-+              BUG_ON(lhead->lh_nblocked[tmp->lk_mode] == 0);
-+
-+              lhead->lh_nblocked[tmp->lk_mode]--;
-+              lhead->lh_ngranted[tmp->lk_mode]++;
-+              granted |= 1 << tmp->lk_mode;
-+
-+              BUG_ON(tmp->lk_task == NULL);
-+              wake_up_process(tmp->lk_task);
-+      }
-+}
-+
-+/* it's wrapper of htree_lock_internal and exported interface.
-+ * It always return 1 with granted lock if @wait is true, it can return 0
-+ * if @wait is false and locking request can't be granted immediately */
-+int
-+htree_lock_try(struct htree_lock *lck, struct htree_lock_head *lhead,
-+             htree_lock_mode_t mode, int wait)
-+{
-+      int     rc;
-+
-+      BUG_ON(lck->lk_depth > lhead->lh_depth);
-+      BUG_ON(lck->lk_head != NULL);
-+      BUG_ON(lck->lk_task != NULL);
-+
-+      lck->lk_head = lhead;
-+      lck->lk_mode = mode;
-+
-+      htree_spin_lock(lhead, HTREE_DEP_ROOT);
-+      rc = htree_lock_internal(lck, wait);
-+      if (rc != 0)
-+              htree_spin_unlock(lhead, HTREE_DEP_ROOT);
-+      return rc >= 0;
-+}
-+EXPORT_SYMBOL(htree_lock_try);
-+
-+/* it's wrapper of htree_unlock_internal and exported interface.
-+ * It will release all htree_node_locks and htree_lock */
-+void
-+htree_unlock(struct htree_lock *lck)
-+{
-+      BUG_ON(lck->lk_head == NULL);
-+      BUG_ON(lck->lk_mode == HTREE_LOCK_INVAL);
-+
-+      htree_node_release_all(lck);
-+
-+      htree_spin_lock(lck->lk_head, HTREE_DEP_ROOT);
-+      htree_unlock_internal(lck);
-+      htree_spin_unlock(lck->lk_head, HTREE_DEP_ROOT);
-+      lck->lk_head = NULL;
-+      lck->lk_task = NULL;
-+}
-+EXPORT_SYMBOL(htree_unlock);
-+
-+/* change lock mode */
-+void
-+htree_change_mode(struct htree_lock *lck, htree_lock_mode_t mode)
-+{
-+      BUG_ON(lck->lk_mode == HTREE_LOCK_INVAL);
-+      lck->lk_mode = mode;
-+}
-+EXPORT_SYMBOL(htree_change_mode);
-+
-+/* release htree lock, and lock it again with new mode.
-+ * This function will first release all htree_node_locks and htree_lock,
-+ * then try to gain htree_lock with new @mode.
-+ * It always return 1 with granted lock if @wait is true, it can return 0
-+ * if @wait is false and locking request can't be granted immediately */
-+int
-+htree_change_lock_try(struct htree_lock *lck, htree_lock_mode_t mode, int wait)
-+{
-+      struct htree_lock_head *lhead = lck->lk_head;
-+      int rc;
-+
-+      BUG_ON(lhead == NULL);
-+      BUG_ON(lck->lk_mode == mode);
-+      BUG_ON(lck->lk_mode == HTREE_LOCK_INVAL || mode == HTREE_LOCK_INVAL);
-+
-+      htree_node_release_all(lck);
-+
-+      htree_spin_lock(lhead, HTREE_DEP_ROOT);
-+      htree_unlock_internal(lck);
-+      lck->lk_mode = mode;
-+      rc = htree_lock_internal(lck, wait);
-+      if (rc != 0)
-+              htree_spin_unlock(lhead, HTREE_DEP_ROOT);
-+      return rc >= 0;
-+}
-+EXPORT_SYMBOL(htree_change_lock_try);
-+
-+/* create a htree_lock head with @depth levels (number of child-locks),
-+ * it is a per resoruce structure */
-+struct htree_lock_head *
-+htree_lock_head_alloc(unsigned depth, unsigned hbits, unsigned priv)
-+{
-+      struct htree_lock_head *lhead;
-+      int  i;
-+
-+      if (depth > HTREE_LOCK_DEP_MAX) {
-+              printk(KERN_ERR "%d is larger than max htree_lock depth %d\n",
-+                      depth, HTREE_LOCK_DEP_MAX);
-+              return NULL;
-+      }
-+
-+      lhead = kzalloc(offsetof(struct htree_lock_head,
-+                               lh_children[depth]) + priv, GFP_NOFS);
-+      if (lhead == NULL)
-+              return NULL;
-+
-+      if (hbits < HTREE_HBITS_MIN)
-+              lhead->lh_hbits = HTREE_HBITS_MIN;
-+      else if (hbits > HTREE_HBITS_MAX)
-+              lhead->lh_hbits = HTREE_HBITS_MAX;
-+
-+      lhead->lh_lock = 0;
-+      lhead->lh_depth = depth;
-+      INIT_LIST_HEAD(&lhead->lh_blocked_list);
-+      if (priv > 0) {
-+              lhead->lh_private = (void *)lhead +
-+                      offsetof(struct htree_lock_head, lh_children[depth]);
-+      }
-+
-+      for (i = 0; i < depth; i++) {
-+              INIT_LIST_HEAD(&lhead->lh_children[i].lc_list);
-+              lhead->lh_children[i].lc_events = HTREE_EVENT_DISABLE;
-+      }
-+      return lhead;
-+}
-+EXPORT_SYMBOL(htree_lock_head_alloc);
-+
-+/* free the htree_lock head */
-+void
-+htree_lock_head_free(struct htree_lock_head *lhead)
-+{
-+      int     i;
-+
-+      BUG_ON(!list_empty(&lhead->lh_blocked_list));
-+      for (i = 0; i < lhead->lh_depth; i++)
-+              BUG_ON(!list_empty(&lhead->lh_children[i].lc_list));
-+      kfree(lhead);
-+}
-+EXPORT_SYMBOL(htree_lock_head_free);
-+
-+/* register event callback for @events of child-lock at level @dep */
-+void
-+htree_lock_event_attach(struct htree_lock_head *lhead, unsigned dep,
-+                      unsigned events, htree_event_cb_t callback)
-+{
-+      BUG_ON(lhead->lh_depth <= dep);
-+      lhead->lh_children[dep].lc_events = events;
-+      lhead->lh_children[dep].lc_callback = callback;
-+}
-+EXPORT_SYMBOL(htree_lock_event_attach);
-+
-+/* allocate a htree_lock, which is per-thread structure, @pbytes is some
-+ * extra-bytes as private data for caller */
-+struct htree_lock *
-+htree_lock_alloc(unsigned depth, unsigned pbytes)
-+{
-+      struct htree_lock *lck;
-+      int i = offsetof(struct htree_lock, lk_nodes[depth]);
-+
-+      if (depth > HTREE_LOCK_DEP_MAX) {
-+              printk(KERN_ERR "%d is larger than max htree_lock depth %d\n",
-+                      depth, HTREE_LOCK_DEP_MAX);
-+              return NULL;
-+      }
-+      lck = kzalloc(i + pbytes, GFP_NOFS);
-+      if (lck == NULL)
-+              return NULL;
-+
-+      if (pbytes != 0)
-+              lck->lk_private = (void *)lck + i;
-+      lck->lk_mode = HTREE_LOCK_INVAL;
-+      lck->lk_depth = depth;
-+      INIT_LIST_HEAD(&lck->lk_blocked_list);
-+
-+      for (i = 0; i < depth; i++) {
-+              struct htree_lock_node *node = &lck->lk_nodes[i];
-+
-+              node->ln_mode = HTREE_LOCK_INVAL;
-+              INIT_LIST_HEAD(&node->ln_major_list);
-+              INIT_LIST_HEAD(&node->ln_minor_list);
-+              INIT_LIST_HEAD(&node->ln_alive_list);
-+              INIT_LIST_HEAD(&node->ln_blocked_list);
-+              INIT_LIST_HEAD(&node->ln_granted_list);
-+      }
-+
-+      return lck;
-+}
-+EXPORT_SYMBOL(htree_lock_alloc);
-+
-+/* free htree_lock node */
-+void
-+htree_lock_free(struct htree_lock *lck)
-+{
-+      BUG_ON(lck->lk_mode != HTREE_LOCK_INVAL);
-+      kfree(lck);
-+}
-+EXPORT_SYMBOL(htree_lock_free);
-Index: linux-2.6.32-504.3.3.el6.x86_64/fs/ext4/ext4.h
-===================================================================
---- linux-2.6.32-504.3.3.el6.x86_64.orig/fs/ext4/ext4.h
-+++ linux-2.6.32-504.3.3.el6.x86_64/fs/ext4/ext4.h
-@@ -27,6 +27,7 @@
- #include <linux/mutex.h>
- #include <linux/timer.h>
- #include <linux/wait.h>
-+#include <linux/htree_lock.h>
- #include <linux/blockgroup_lock.h>
- #include <linux/percpu_counter.h>
- #ifdef __KERNEL__
-@@ -1625,6 +1626,71 @@ ext4_dir_htree_level(struct super_block
-               EXT4_HTREE_LEVEL : EXT4_HTREE_LEVEL_COMPAT;
- }
-+/* assume name-hash is protected by upper layer */
-+#define EXT4_HTREE_LOCK_HASH  0
-+
-+enum ext4_pdo_lk_types {
-+#if EXT4_HTREE_LOCK_HASH
-+      EXT4_LK_HASH,
-+#endif
-+      EXT4_LK_DX,             /* index block */
-+      EXT4_LK_DE,             /* directory entry block */
-+      EXT4_LK_SPIN,           /* spinlock */
-+      EXT4_LK_MAX,
-+};
-+
-+/* read-only bit */
-+#define EXT4_LB_RO(b)         (1 << (b))
-+/* read + write, high bits for writer */
-+#define EXT4_LB_RW(b)         ((1 << (b)) | (1 << (EXT4_LK_MAX + (b))))
-+
-+enum ext4_pdo_lock_bits {
-+      /* DX lock bits */
-+      EXT4_LB_DX_RO           = EXT4_LB_RO(EXT4_LK_DX),
-+      EXT4_LB_DX              = EXT4_LB_RW(EXT4_LK_DX),
-+      /* DE lock bits */
-+      EXT4_LB_DE_RO           = EXT4_LB_RO(EXT4_LK_DE),
-+      EXT4_LB_DE              = EXT4_LB_RW(EXT4_LK_DE),
-+      /* DX spinlock bits */
-+      EXT4_LB_SPIN_RO         = EXT4_LB_RO(EXT4_LK_SPIN),
-+      EXT4_LB_SPIN            = EXT4_LB_RW(EXT4_LK_SPIN),
-+      /* accurate searching */
-+      EXT4_LB_EXACT           = EXT4_LB_RO(EXT4_LK_MAX << 1),
-+};
-+
-+enum ext4_pdo_lock_opc {
-+      /* external */
-+      EXT4_HLOCK_READDIR      = (EXT4_LB_DE_RO | EXT4_LB_DX_RO),
-+      EXT4_HLOCK_LOOKUP       = (EXT4_LB_DE_RO | EXT4_LB_SPIN_RO |
-+                                 EXT4_LB_EXACT),
-+      EXT4_HLOCK_DEL          = (EXT4_LB_DE | EXT4_LB_SPIN_RO |
-+                                 EXT4_LB_EXACT),
-+      EXT4_HLOCK_ADD          = (EXT4_LB_DE | EXT4_LB_SPIN_RO),
-+
-+      /* internal */
-+      EXT4_HLOCK_LOOKUP_SAFE  = (EXT4_LB_DE_RO | EXT4_LB_DX_RO |
-+                                 EXT4_LB_EXACT),
-+      EXT4_HLOCK_DEL_SAFE     = (EXT4_LB_DE | EXT4_LB_DX_RO | EXT4_LB_EXACT),
-+      EXT4_HLOCK_SPLIT        = (EXT4_LB_DE | EXT4_LB_DX | EXT4_LB_SPIN),
-+};
-+
-+extern struct htree_lock_head *ext4_htree_lock_head_alloc(unsigned hbits);
-+#define ext4_htree_lock_head_free(lhead)      htree_lock_head_free(lhead)
-+
-+extern struct htree_lock *ext4_htree_lock_alloc(void);
-+#define ext4_htree_lock_free(lck)             htree_lock_free(lck)
-+
-+extern void ext4_htree_lock(struct htree_lock *lck,
-+                          struct htree_lock_head *lhead,
-+                          struct inode *dir, unsigned flags);
-+#define ext4_htree_unlock(lck)                  htree_unlock(lck)
-+
-+extern struct buffer_head * __ext4_find_entry(struct inode *dir,
-+                                      const struct qstr *d_name,
-+                                      struct ext4_dir_entry_2 **res_dir,
-+                                      struct htree_lock *lck);
-+extern int __ext4_add_entry(handle_t *handle, struct dentry *dentry,
-+                    struct inode *inode, struct htree_lock *lck);
- void ext4_get_group_no_and_offset(struct super_block *sb, ext4_fsblk_t blocknr,
-                       ext4_group_t *blockgrpp, ext4_grpblk_t *offsetp);
-Index: linux-2.6.32-504.3.3.el6.x86_64/fs/ext4/namei.c
-===================================================================
---- linux-2.6.32-504.3.3.el6.x86_64.orig/fs/ext4/namei.c
-+++ linux-2.6.32-504.3.3.el6.x86_64/fs/ext4/namei.c
-@@ -176,7 +176,7 @@ static struct dx_frame *dx_probe(const s
-                                struct inode *dir,
-                                struct dx_hash_info *hinfo,
-                                struct dx_frame *frame,
--                               int *err);
-+                               struct htree_lock *lck, int *err);
- static void dx_release(struct dx_frame *frames);
- static int dx_make_map(struct ext4_dir_entry_2 *de, unsigned blocksize,
-                      struct dx_hash_info *hinfo, struct dx_map_entry map[]);
-@@ -189,13 +189,13 @@ static void dx_insert_block(struct dx_fr
- static int ext4_htree_next_block(struct inode *dir, __u32 hash,
-                                struct dx_frame *frame,
-                                struct dx_frame *frames,
--                               __u32 *start_hash);
-+                               __u32 *start_hash, struct htree_lock *lck);
- static struct buffer_head * ext4_dx_find_entry(struct inode *dir,
-               const struct qstr *d_name,
-               struct ext4_dir_entry_2 **res_dir,
--              int *err);
-+              struct htree_lock *lck, int *err);
- static int ext4_dx_add_entry(handle_t *handle, struct dentry *dentry,
--                           struct inode *inode);
-+                           struct inode *inode, struct htree_lock *lck);
- /*
-  * p is at least 6 bytes before the end of page
-@@ -368,6 +368,225 @@ struct stats dx_show_entries(struct dx_h
- }
- #endif /* DX_DEBUG */
-+/* private data for htree_lock */
-+struct ext4_dir_lock_data {
-+      unsigned                ld_flags;  /* bits-map for lock types */
-+      unsigned                ld_count;  /* # entries of the last DX block */
-+      struct dx_entry         ld_at_entry; /* copy of leaf dx_entry */
-+      struct dx_entry         *ld_at;    /* position of leaf dx_entry */
-+};
-+
-+#define ext4_htree_lock_data(l) ((struct ext4_dir_lock_data *)(l)->lk_private)
-+#define ext4_find_entry(dir, name, dirent) __ext4_find_entry(dir, name, dirent, NULL)
-+#define ext4_add_entry(handle, dentry, inode) __ext4_add_entry(handle, dentry, inode, NULL)
-+
-+/* NB: ext4_lblk_t is 32 bits so we use high bits to identify invalid blk */
-+#define EXT4_HTREE_NODE_CHANGED       (0xcafeULL << 32)
-+
-+static void ext4_htree_event_cb(void *target, void *event)
-+{
-+      u64 *block = (u64 *)target;
-+
-+      if (*block == dx_get_block((struct dx_entry *)event))
-+              *block = EXT4_HTREE_NODE_CHANGED;
-+}
-+
-+struct htree_lock_head *ext4_htree_lock_head_alloc(unsigned hbits)
-+{
-+      struct htree_lock_head *lhead;
-+
-+      lhead = htree_lock_head_alloc(EXT4_LK_MAX, hbits, 0);
-+      if (lhead != NULL) {
-+              htree_lock_event_attach(lhead, EXT4_LK_SPIN, HTREE_EVENT_WR,
-+                                      ext4_htree_event_cb);
-+      }
-+      return lhead;
-+}
-+EXPORT_SYMBOL(ext4_htree_lock_head_alloc);
-+
-+struct htree_lock *ext4_htree_lock_alloc(void)
-+{
-+      return htree_lock_alloc(EXT4_LK_MAX,
-+                              sizeof(struct ext4_dir_lock_data));
-+}
-+EXPORT_SYMBOL(ext4_htree_lock_alloc);
-+
-+static htree_lock_mode_t ext4_htree_mode(unsigned flags)
-+{
-+      switch (flags) {
-+      default: /* 0 or unknown flags require EX lock */
-+              return HTREE_LOCK_EX;
-+      case EXT4_HLOCK_READDIR:
-+              return HTREE_LOCK_PR;
-+      case EXT4_HLOCK_LOOKUP:
-+              return HTREE_LOCK_CR;
-+      case EXT4_HLOCK_DEL:
-+      case EXT4_HLOCK_ADD:
-+              return HTREE_LOCK_CW;
-+      }
-+}
-+
-+/* return PR for read-only operations, otherwise return EX */
-+static inline htree_lock_mode_t ext4_htree_safe_mode(unsigned flags)
-+{
-+      int writer = (flags & EXT4_LB_DE) == EXT4_LB_DE;
-+
-+      /* 0 requires EX lock */
-+      return (flags == 0 || writer) ? HTREE_LOCK_EX : HTREE_LOCK_PR;
-+}
-+
-+static int ext4_htree_safe_locked(struct htree_lock *lck)
-+{
-+      int writer;
-+
-+      if (lck == NULL || lck->lk_mode == HTREE_LOCK_EX)
-+              return 1;
-+
-+      writer = (ext4_htree_lock_data(lck)->ld_flags & EXT4_LB_DE) ==
-+               EXT4_LB_DE;
-+      if (writer) /* all readers & writers are excluded? */
-+              return lck->lk_mode == HTREE_LOCK_EX;
-+
-+      /* all writers are excluded? */
-+      return lck->lk_mode == HTREE_LOCK_PR ||
-+             lck->lk_mode == HTREE_LOCK_PW ||
-+             lck->lk_mode == HTREE_LOCK_EX;
-+}
-+
-+/* relock htree_lock with EX mode if it's change operation, otherwise
-+ * relock it with PR mode. It's noop if PDO is disabled. */
-+static void ext4_htree_safe_relock(struct htree_lock *lck)
-+{
-+      if (!ext4_htree_safe_locked(lck)) {
-+              unsigned flags = ext4_htree_lock_data(lck)->ld_flags;
-+
-+              htree_change_lock(lck, ext4_htree_safe_mode(flags));
-+      }
-+}
-+
-+void ext4_htree_lock(struct htree_lock *lck, struct htree_lock_head *lhead,
-+                   struct inode *dir, unsigned flags)
-+{
-+      htree_lock_mode_t mode = is_dx(dir) ? ext4_htree_mode(flags) :
-+                                            ext4_htree_safe_mode(flags);
-+
-+      ext4_htree_lock_data(lck)->ld_flags = flags;
-+      htree_lock(lck, lhead, mode);
-+      if (!is_dx(dir))
-+              ext4_htree_safe_relock(lck); /* make sure it's safe locked */
-+}
-+EXPORT_SYMBOL(ext4_htree_lock);
-+
-+static int ext4_htree_node_lock(struct htree_lock *lck, struct dx_entry *at,
-+                              unsigned lmask, int wait, void *ev)
-+{
-+      u32     key = (at == NULL) ? 0 : dx_get_block(at);
-+      u32     mode;
-+
-+      /* NOOP if htree is well protected or caller doesn't require the lock */
-+      if (ext4_htree_safe_locked(lck) ||
-+         !(ext4_htree_lock_data(lck)->ld_flags & lmask))
-+              return 1;
-+
-+      mode = (ext4_htree_lock_data(lck)->ld_flags & lmask) == lmask ?
-+              HTREE_LOCK_PW : HTREE_LOCK_PR;
-+      while (1) {
-+              if (htree_node_lock_try(lck, mode, key, ffz(~lmask), wait, ev))
-+                      return 1;
-+              if (!(lmask & EXT4_LB_SPIN)) /* not a spinlock */
-+                      return 0;
-+              cpu_relax(); /* spin until granted */
-+      }
-+}
-+
-+static int ext4_htree_node_locked(struct htree_lock *lck, unsigned lmask)
-+{
-+      return ext4_htree_safe_locked(lck) ||
-+             htree_node_is_granted(lck, ffz(~lmask));
-+}
-+
-+static void ext4_htree_node_unlock(struct htree_lock *lck,
-+                                 unsigned lmask, void *buf)
-+{
-+      /* NB: it's safe to call mutiple times or even it's not locked */
-+      if (!ext4_htree_safe_locked(lck) &&
-+           htree_node_is_granted(lck, ffz(~lmask)))
-+              htree_node_unlock(lck, ffz(~lmask), buf);
-+}
-+
-+#define ext4_htree_dx_lock(lck, key)          \
-+      ext4_htree_node_lock(lck, key, EXT4_LB_DX, 1, NULL)
-+#define ext4_htree_dx_lock_try(lck, key)      \
-+      ext4_htree_node_lock(lck, key, EXT4_LB_DX, 0, NULL)
-+#define ext4_htree_dx_unlock(lck)             \
-+      ext4_htree_node_unlock(lck, EXT4_LB_DX, NULL)
-+#define ext4_htree_dx_locked(lck)             \
-+      ext4_htree_node_locked(lck, EXT4_LB_DX)
-+
-+static void ext4_htree_dx_need_lock(struct htree_lock *lck)
-+{
-+      struct ext4_dir_lock_data *ld;
-+
-+      if (ext4_htree_safe_locked(lck))
-+              return;
-+
-+      ld = ext4_htree_lock_data(lck);
-+      switch (ld->ld_flags) {
-+      default:
-+              return;
-+      case EXT4_HLOCK_LOOKUP:
-+              ld->ld_flags = EXT4_HLOCK_LOOKUP_SAFE;
-+              return;
-+      case EXT4_HLOCK_DEL:
-+              ld->ld_flags = EXT4_HLOCK_DEL_SAFE;
-+              return;
-+      case EXT4_HLOCK_ADD:
-+              ld->ld_flags = EXT4_HLOCK_SPLIT;
-+              return;
-+      }
-+}
-+
-+#define ext4_htree_de_lock(lck, key)          \
-+      ext4_htree_node_lock(lck, key, EXT4_LB_DE, 1, NULL)
-+#define ext4_htree_de_unlock(lck)             \
-+      ext4_htree_node_unlock(lck, EXT4_LB_DE, NULL)
-+
-+#define ext4_htree_spin_lock(lck, key, event) \
-+      ext4_htree_node_lock(lck, key, EXT4_LB_SPIN, 0, event)
-+#define ext4_htree_spin_unlock(lck)           \
-+      ext4_htree_node_unlock(lck, EXT4_LB_SPIN, NULL)
-+#define ext4_htree_spin_unlock_listen(lck, p) \
-+      ext4_htree_node_unlock(lck, EXT4_LB_SPIN, p)
-+
-+static void ext4_htree_spin_stop_listen(struct htree_lock *lck)
-+{
-+      if (!ext4_htree_safe_locked(lck) &&
-+          htree_node_is_listening(lck, ffz(~EXT4_LB_SPIN)))
-+              htree_node_stop_listen(lck, ffz(~EXT4_LB_SPIN));
-+}
-+
-+enum {
-+      DX_HASH_COL_IGNORE,     /* ignore collision while probing frames */
-+      DX_HASH_COL_YES,        /* there is collision and it does matter */
-+      DX_HASH_COL_NO,         /* there is no collision */
-+};
-+
-+static int dx_probe_hash_collision(struct htree_lock *lck,
-+                                 struct dx_entry *entries,
-+                                 struct dx_entry *at, u32 hash)
-+{
-+      if (!(lck && ext4_htree_lock_data(lck)->ld_flags & EXT4_LB_EXACT)) {
-+              return DX_HASH_COL_IGNORE; /* don't care about collision */
-+
-+      } else if (at == entries + dx_get_count(entries) - 1) {
-+              return DX_HASH_COL_IGNORE; /* not in any leaf of this DX */
-+
-+      } else { /* hash collision? */
-+              return ((dx_get_hash(at + 1) & ~1) == hash) ?
-+                      DX_HASH_COL_YES : DX_HASH_COL_NO;
-+      }
-+}
-+
- /*
-  * Probe for a directory leaf block to search.
-  *
-@@ -379,10 +598,11 @@ struct stats dx_show_entries(struct dx_h
-  */
- static struct dx_frame *
- dx_probe(const struct qstr *d_name, struct inode *dir,
--       struct dx_hash_info *hinfo, struct dx_frame *frame_in, int *err)
-+       struct dx_hash_info *hinfo, struct dx_frame *frame_in,
-+       struct htree_lock *lck, int *err)
- {
-       unsigned count, indirect;
--      struct dx_entry *at, *entries, *p, *q, *m;
-+      struct dx_entry *at, *entries, *p, *q, *m, *dx = NULL;
-       struct dx_root_info * info;
-       struct buffer_head *bh;
-       struct dx_frame *frame = frame_in;
-@@ -447,8 +667,15 @@ dx_probe(const struct qstr *d_name, stru
-       dxtrace(printk("Look up %x", hash));
-       while (1)
-       {
-+              if (indirect == 0) { /* the last index level */
-+                      /* NB: ext4_htree_dx_lock() could be noop if
-+                       * DX-lock flag is not set for current operation */
-+                      ext4_htree_dx_lock(lck, dx);
-+                      ext4_htree_spin_lock(lck, dx, NULL);
-+              }
-               count = dx_get_count(entries);
--              if (!count || count > dx_get_limit(entries)) {
-+              if (count == 0 || count > dx_get_limit(entries)) {
-+                      ext4_htree_spin_unlock(lck); /* release spin */
-                       ext4_warning(dir->i_sb,
-                                    "dx entry: no count or count > limit");
-                       brelse(bh);
-@@ -489,9 +716,73 @@ dx_probe(const struct qstr *d_name, stru
-               frame->bh = bh;
-               frame->entries = entries;
-               frame->at = at;
--              if (!indirect--) return frame;
-+
-+              if (indirect == 0) { /* the last index level */
-+                      struct ext4_dir_lock_data *ld;
-+                      u64 myblock;
-+
-+                      /* By default we only lock DE-block, however, we will
-+                       * also lock the last level DX-block if:
-+                       * a) there is hash collision
-+                       *    we will set DX-lock flag (a few lines below)
-+                       *    and redo to lock DX-block
-+                       *    see detail in dx_probe_hash_collision()
-+                       * b) it's a retry from splitting
-+                       *    we need to lock the last level DX-block so nobody
-+                       *    else can split any leaf blocks under the same
-+                       *    DX-block, see detail in ext4_dx_add_entry()
-+                       */
-+                      if (ext4_htree_dx_locked(lck)) {
-+                              /* DX-block is locked, just lock DE-block
-+                               * and return */
-+                              ext4_htree_spin_unlock(lck);
-+                              if (!ext4_htree_safe_locked(lck))
-+                                      ext4_htree_de_lock(lck, frame->at);
-+                              return frame;
-+                      }
-+                      /* it's pdirop and no DX lock */
-+                      if (dx_probe_hash_collision(lck, entries, at, hash) ==
-+                          DX_HASH_COL_YES) {
-+                              /* found hash collision, set DX-lock flag
-+                               * and retry to abtain DX-lock */
-+                              ext4_htree_spin_unlock(lck);
-+                              ext4_htree_dx_need_lock(lck);
-+                              continue;
-+                      }
-+                      ld = ext4_htree_lock_data(lck);
-+                      /* because I don't lock DX, so @at can't be trusted
-+                       * after I release spinlock so I have to save it */
-+                      ld->ld_at = at;
-+                      ld->ld_at_entry = *at;
-+                      ld->ld_count = dx_get_count(entries);
-+
-+                      frame->at = &ld->ld_at_entry;
-+                      myblock = dx_get_block(at);
-+
-+                      /* NB: ordering locking */
-+                      ext4_htree_spin_unlock_listen(lck, &myblock);
-+                      /* other thread can split this DE-block because:
-+                       * a) I don't have lock for the DE-block yet
-+                       * b) I released spinlock on DX-block
-+                       * if it happened I can detect it by listening
-+                       * splitting event on this DE-block */
-+                      ext4_htree_de_lock(lck, frame->at);
-+                      ext4_htree_spin_stop_listen(lck);
-+
-+                      if (myblock == EXT4_HTREE_NODE_CHANGED) {
-+                              /* someone split this DE-block before
-+                               * I locked it, I need to retry and lock
-+                               * valid DE-block */
-+                              ext4_htree_de_unlock(lck);
-+                              continue;
-+                      }
-+                      return frame;
-+              }
-+              dx = at;
-+              indirect--;
-               if (!(bh = ext4_bread (NULL,dir, dx_get_block(at), 0, err)))
-                       goto fail2;
-+
-               at = entries = ((struct dx_node *) bh->b_data)->entries;
-               if (dx_get_limit(entries) != dx_node_limit (dir)) {
-                       ext4_warning(dir->i_sb,
-@@ -553,7 +844,7 @@ static void dx_release (struct dx_frame
- static int ext4_htree_next_block(struct inode *dir, __u32 hash,
-                                struct dx_frame *frame,
-                                struct dx_frame *frames,
--                               __u32 *start_hash)
-+                               __u32 *start_hash, struct htree_lock *lck)
- {
-       struct dx_frame *p;
-       struct buffer_head *bh;
-@@ -568,12 +859,22 @@ static int ext4_htree_next_block(struct
-        * this loop, num_frames indicates the number of interior
-        * nodes need to be read.
-        */
-+      ext4_htree_de_unlock(lck);
-       while (1) {
--              if (++(p->at) < p->entries + dx_get_count(p->entries))
--                      break;
-+              if (num_frames > 0 || ext4_htree_dx_locked(lck)) {
-+                      /* num_frames > 0 :
-+                       *   DX block
-+                       * ext4_htree_dx_locked:
-+                       *   frame->at is reliable pointer returned by dx_probe,
-+                       *   otherwise dx_probe already knew no collision */
-+                      if (++(p->at) < p->entries + dx_get_count(p->entries))
-+                              break;
-+              }
-               if (p == frames)
-                       return 0;
-               num_frames++;
-+              if (num_frames == 1)
-+                      ext4_htree_dx_unlock(lck);
-               p--;
-       }
-@@ -596,6 +897,13 @@ static int ext4_htree_next_block(struct
-        * block so no check is necessary
-        */
-       while (num_frames--) {
-+              if (num_frames == 0) {
-+                      /* it's not always necessary, we just don't want to
-+                       * detect hash collision again */
-+                      ext4_htree_dx_need_lock(lck);
-+                      ext4_htree_dx_lock(lck, p->at);
-+              }
-+
-               if (!(bh = ext4_bread(NULL, dir, dx_get_block(p->at),
-                                     0, &err)))
-                       return err; /* Failure */
-@@ -604,6 +912,7 @@ static int ext4_htree_next_block(struct
-               p->bh = bh;
-               p->at = p->entries = ((struct dx_node *) bh->b_data)->entries;
-       }
-+      ext4_htree_de_lock(lck, p->at);
-       return 1;
- }
-@@ -696,10 +1005,10 @@ int ext4_htree_fill_tree(struct file *di
-       }
-       hinfo.hash = start_hash;
-       hinfo.minor_hash = 0;
--      frame = dx_probe(NULL, dir, &hinfo, frames, &err);
-+      /* assume it's PR locked */
-+      frame = dx_probe(NULL, dir, &hinfo, frames, NULL, &err);
-       if (!frame)
-               return err;
--
-       /* Add '.' and '..' from the htree header */
-       if (!start_hash && !start_minor_hash) {
-               de = (struct ext4_dir_entry_2 *) frames[0].bh->b_data;
-@@ -726,7 +1035,7 @@ int ext4_htree_fill_tree(struct file *di
-               count += ret;
-               hashval = ~0;
-               ret = ext4_htree_next_block(dir, HASH_NB_ALWAYS,
--                                          frame, frames, &hashval);
-+                                          frame, frames, &hashval, NULL);
-               *next_hash = hashval;
-               if (ret < 0) {
-                       err = ret;
-@@ -826,9 +1135,17 @@ static void dx_insert_block(struct dx_fr
- static void ext4_update_dx_flag(struct inode *inode)
- {
-+      /* Disable it for ldiskfs, because going from a DX directory to
-+       * a non-DX directory while it is in use will completely break
-+       * the htree-locking.
-+       * If we really want to support this operation in the future,
-+       * we need to exclusively lock the directory at here which will
-+       * increase complexity of code */
-+#if 0
-       if (!EXT4_HAS_COMPAT_FEATURE(inode->i_sb,
-                                    EXT4_FEATURE_COMPAT_DIR_INDEX))
-               ext4_clear_inode_flag(inode, EXT4_INODE_INDEX);
-+#endif
- }
- /*
-@@ -900,9 +1217,10 @@ static inline int search_dirblock(struct
-  * The returned buffer_head has ->b_count elevated.  The caller is expected
-  * to brelse() it when appropriate.
-  */
--static struct buffer_head * ext4_find_entry (struct inode *dir,
-+struct buffer_head * __ext4_find_entry(struct inode *dir,
-                                       const struct qstr *d_name,
--                                      struct ext4_dir_entry_2 ** res_dir)
-+                                      struct ext4_dir_entry_2 **res_dir,
-+                                      struct htree_lock *lck)
- {
-       struct super_block *sb;
-       struct buffer_head *bh_use[NAMEI_RA_SIZE];
-@@ -923,7 +1241,7 @@ static struct buffer_head * ext4_find_en
-       if (namelen > EXT4_NAME_LEN)
-               return NULL;
-       if (is_dx(dir)) {
--              bh = ext4_dx_find_entry(dir, d_name, res_dir, &err);
-+              bh = ext4_dx_find_entry(dir, d_name, res_dir, lck, &err);
-               /*
-                * On success, or if the error was file not found,
-                * return.  Otherwise, fall back to doing a search the
-@@ -933,6 +1251,7 @@ static struct buffer_head * ext4_find_en
-                       return bh;
-               dxtrace(printk(KERN_DEBUG "ext4_find_entry: dx failed, "
-                              "falling back\n"));
-+              ext4_htree_safe_relock(lck);
-       }
-       nblocks = dir->i_size >> EXT4_BLOCK_SIZE_BITS(sb);
-       start = EXT4_I(dir)->i_dir_start_lookup;
-@@ -1008,9 +1327,12 @@ cleanup_and_exit:
-               brelse(bh_use[ra_ptr]);
-       return ret;
- }
-+EXPORT_SYMBOL(__ext4_find_entry);
--static struct buffer_head * ext4_dx_find_entry(struct inode *dir, const struct qstr *d_name,
--                     struct ext4_dir_entry_2 **res_dir, int *err)
-+static struct buffer_head * ext4_dx_find_entry(struct inode *dir,
-+                              const struct qstr *d_name,
-+                              struct ext4_dir_entry_2 **res_dir,
-+                              struct htree_lock *lck, int *err)
- {
-       struct super_block * sb;
-       struct dx_hash_info     hinfo;
-@@ -1026,13 +1348,16 @@ static struct buffer_head * ext4_dx_find
-       sb = dir->i_sb;
-       /* NFS may look up ".." - look at dx_root directory block */
-       if (namelen > 2 || name[0] != '.'||(name[1] != '.' && name[1] != '\0')){
--              if (!(frame = dx_probe(d_name, dir, &hinfo, frames, err)))
-+              if (!(frame = dx_probe(d_name, dir, &hinfo, frames, lck, err)))
-                       return NULL;
-       } else {
-               frame = frames;
-               frame->bh = NULL;                       /* for dx_release() */
-               frame->at = (struct dx_entry *)frames;  /* hack for zero entry*/
-               dx_set_block(frame->at, 0);             /* dx_root block is 0 */
-+              /* "." and ".." are stored in root DX lock */
-+              ext4_htree_dx_need_lock(lck);
-+              ext4_htree_dx_lock(lck, NULL);
-       }
-       hash = hinfo.hash;
-       do {
-@@ -1061,7 +1386,7 @@ static struct buffer_head * ext4_dx_find
-               brelse(bh);
-               /* Check to see if we should continue to search */
-               retval = ext4_htree_next_block(dir, hash, frame,
--                                             frames, NULL);
-+                                             frames, NULL, lck);
-               if (retval < 0) {
-                       ext4_warning(sb,
-                            "error reading index page in directory #%lu",
-@@ -1244,8 +1569,9 @@ static struct ext4_dir_entry_2* dx_pack_
-  * Returns pointer to de in block into which the new entry will be inserted.
-  */
- static struct ext4_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
--                      struct buffer_head **bh,struct dx_frame *frame,
--                      struct dx_hash_info *hinfo, int *error)
-+                      struct buffer_head **bh, struct dx_frame *frames,
-+                      struct dx_frame *frame, struct dx_hash_info *hinfo,
-+                      struct htree_lock *lck, int *error)
- {
-       unsigned blocksize = dir->i_sb->s_blocksize;
-       unsigned count, continued;
-@@ -1302,7 +1628,14 @@ static struct ext4_dir_entry_2 *do_split
-                                       hash2, split, count-split));
-       /* Fancy dance to stay within two buffers */
--      de2 = dx_move_dirents(data1, data2, map + split, count - split, blocksize);
-+      if (hinfo->hash < hash2) {
-+              de2 = dx_move_dirents(data1, data2, map + split,
-+                                    count - split, blocksize);
-+      } else {
-+              /* make sure we will add entry to the same block which
-+               * we have already locked */
-+              de2 = dx_move_dirents(data1, data2, map, split, blocksize);
-+      }
-       de = dx_pack_dirents(data1, blocksize);
-       de->rec_len = ext4_rec_len_to_disk(data1 + blocksize - (char *) de,
-                                          blocksize);
-@@ -1311,13 +1644,21 @@ static struct ext4_dir_entry_2 *do_split
-       dxtrace(dx_show_leaf (hinfo, (struct ext4_dir_entry_2 *) data1, blocksize, 1));
-       dxtrace(dx_show_leaf (hinfo, (struct ext4_dir_entry_2 *) data2, blocksize, 1));
--      /* Which block gets the new entry? */
--      if (hinfo->hash >= hash2)
--      {
--              swap(*bh, bh2);
--              de = de2;
-+      ext4_htree_spin_lock(lck, frame > frames ? (frame - 1)->at : NULL,
-+                           frame->at); /* notify block is being split */
-+      if (hinfo->hash < hash2) {
-+              dx_insert_block(frame, hash2 + continued, newblock);
-+
-+      } else {
-+              /* switch block number */
-+              dx_insert_block(frame, hash2 + continued,
-+                              dx_get_block(frame->at));
-+              dx_set_block(frame->at, newblock);
-+              (frame->at)++;
-       }
--      dx_insert_block(frame, hash2 + continued, newblock);
-+      ext4_htree_spin_unlock(lck);
-+      ext4_htree_dx_unlock(lck);
-+
-       err = ext4_handle_dirty_metadata(handle, dir, bh2);
-       if (err)
-               goto journal_error;
-@@ -1558,7 +1899,7 @@ static int make_indexed_dir(handle_t *ha
-       ext4_handle_dirty_metadata(handle, dir, frame->bh);
-       ext4_handle_dirty_metadata(handle, dir, bh);
--      de = do_split(handle,dir, &bh, frame, &hinfo, &retval);
-+      de = do_split(handle,dir, &bh, frames, frame, &hinfo, NULL, &retval);
-       if (!de) {
-               /*
-                * Even if the block split failed, we have to properly write
-@@ -1664,8 +2005,8 @@ out:
-  * may not sleep between calling this and putting something into
-  * the entry, as someone else might have used it while you slept.
-  */
--static int ext4_add_entry(handle_t *handle, struct dentry *dentry,
--                        struct inode *inode)
-+int __ext4_add_entry(handle_t *handle, struct dentry *dentry,
-+                    struct inode *inode, struct htree_lock *lck)
- {
-       struct inode *dir = dentry->d_parent->d_inode;
-       struct buffer_head *bh;
-@@ -1684,9 +2025,10 @@ static int ext4_add_entry(handle_t *hand
-               if (dentry->d_name.len == 2 &&
-                   memcmp(dentry->d_name.name, "..", 2) == 0)
-                       return ext4_update_dotdot(handle, dentry, inode);
--              retval = ext4_dx_add_entry(handle, dentry, inode);
-+              retval = ext4_dx_add_entry(handle, dentry, inode, lck);
-               if (!retval || (retval != ERR_BAD_DX_DIR))
-                       return retval;
-+              ext4_htree_safe_relock(lck);
-               ext4_clear_inode_flag(dir, EXT4_INODE_INDEX);
-               dx_fallback++;
-               ext4_mark_inode_dirty(handle, dir);
-@@ -1717,12 +2059,13 @@ static int ext4_add_entry(handle_t *hand
-       brelse(bh);
-       return retval;
- }
-+EXPORT_SYMBOL(__ext4_add_entry);
- /*
-  * Returns 0 for success, or a negative error value
-  */
- static int ext4_dx_add_entry(handle_t *handle, struct dentry *dentry,
--                           struct inode *inode)
-+                           struct inode *inode, struct htree_lock *lck)
- {
-       struct dx_frame frames[EXT4_HTREE_LEVEL], *frame;
-       struct dx_entry *entries, *at;
-@@ -1736,7 +2079,7 @@ static int ext4_dx_add_entry(handle_t *h
- again:
-       restart = 0;
--      frame = dx_probe(&dentry->d_name, dir, &hinfo, frames, &err);
-+      frame = dx_probe(&dentry->d_name, dir, &hinfo, frames, lck, &err);
-       if (!frame)
-               return err;
-       entries = frame->entries;
-@@ -1763,6 +2106,11 @@ again:
-               struct dx_node *node2;
-               struct buffer_head *bh2;
-+              if (!ext4_htree_safe_locked(lck)) { /* retry with EX lock */
-+                      ext4_htree_safe_relock(lck);
-+                      restart = 1;
-+                      goto cleanup;
-+              }
-               while (frame > frames) {
-                       if (dx_get_count((frame - 1)->entries) <
-                           dx_get_limit((frame - 1)->entries)) {
-@@ -1860,16 +2208,43 @@ again:
-                       restart = 1;
-                       goto cleanup;
-               }
-+      } else if (!ext4_htree_dx_locked(lck)) {
-+              struct ext4_dir_lock_data *ld = ext4_htree_lock_data(lck);
-+
-+              /* not well protected, require DX lock */
-+              ext4_htree_dx_need_lock(lck);
-+              at = frame > frames ? (frame - 1)->at : NULL;
-+
-+              /* NB: no risk of deadlock because it's just a try.
-+               *
-+               * NB: we check ld_count for twice, the first time before
-+               * having DX lock, the second time after holding DX lock.
-+               *
-+               * NB: We never free blocks for directory so far, which
-+               * means value returned by dx_get_count() should equal to
-+               * ld->ld_count if nobody split any DE-block under @at,
-+               * and ld->ld_at still points to valid dx_entry. */
-+              if ((ld->ld_count != dx_get_count(entries)) ||
-+                  !ext4_htree_dx_lock_try(lck, at) ||
-+                  (ld->ld_count != dx_get_count(entries))) {
-+                      restart = 1;
-+                      goto cleanup;
-+              }
-+              /* OK, I've got DX lock and nothing changed */
-+              frame->at = ld->ld_at;
-       }
--      de = do_split(handle, dir, &bh, frame, &hinfo, &err);
-+      de = do_split(handle, dir, &bh, frames, frame, &hinfo, lck, &err);
-       if (!de)
-               goto cleanup;
-+
-       err = add_dirent_to_buf(handle, dentry, inode, de, bh);
-       goto cleanup;
- journal_error:
-       ext4_std_error(dir->i_sb, err);
- cleanup:
-+      ext4_htree_dx_unlock(lck);
-+      ext4_htree_de_unlock(lck);
-       if (bh)
-               brelse(bh);
-       dx_release(frames);
-Index: linux-2.6.32-504.3.3.el6.x86_64/fs/ext4/Makefile
-===================================================================
---- linux-2.6.32-504.3.3.el6.x86_64.orig/fs/ext4/Makefile
-+++ linux-2.6.32-504.3.3.el6.x86_64/fs/ext4/Makefile
-@@ -6,6 +6,7 @@ obj-$(CONFIG_EXT4_FS) += ext4.o
- ext4-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 \
-+              htree_lock.o \
-               ext4_jbd2.o migrate.o mballoc.o block_validity.o move_extent.o \
-               mmp.o
diff --git a/ldiskfs/kernel_patches/patches/rhel6.3/ext4-remove-cond_resched-calls.patch b/ldiskfs/kernel_patches/patches/rhel6.3/ext4-remove-cond_resched-calls.patch
deleted file mode 100644 (file)
index b854280..0000000
+++ /dev/null
@@ -1,29 +0,0 @@
-Index: linux-2.6.18.i386/fs/ext4/ialloc.c
-===================================================================
---- linux-2.6.18.i386.orig/fs/ext4/ialloc.c
-+++ linux-2.6.18.i386/fs/ext4/ialloc.c
-@@ -1057,7 +1057,6 @@ unsigned long ext4_count_free_inodes (st
-               if (!gdp)
-                       continue;
-               desc_count += ext4_free_inodes_count(sb, gdp);
--              cond_resched();
-       }
-       return desc_count;
- #endif
-Index: linux-2.6.18.i386/fs/ext4/super.c
-===================================================================
---- linux-2.6.18.i386.orig/fs/ext4/super.c
-+++ linux-2.6.18.i386/fs/ext4/super.c
-@@ -3100,11 +3100,9 @@ static int ext4_statfs(struct dentry *de
-                * block group descriptors.  If the sparse superblocks
-                * feature is turned on, then not all groups have this.
-                */
--              for (i = 0; i < ngroups; i++) {
-+              for (i = 0; i < ngroups; i++)
-                       overhead += ext4_bg_has_super(sb, i) +
-                               ext4_bg_num_gdb(sb, i);
--                      cond_resched();
--              }
-               /*
-                * Every block group has an inode bitmap, a block
diff --git a/ldiskfs/kernel_patches/patches/rhel6.5/ext4-fix-journal-quota.patch b/ldiskfs/kernel_patches/patches/rhel6.5/ext4-fix-journal-quota.patch
deleted file mode 100644 (file)
index 220de39..0000000
+++ /dev/null
@@ -1,15 +0,0 @@
-diff --git a/fs/ext4/super.c b/fs/ext4/super.c
-index 1ed737f..77e2fb3 100644
---- a/fs/ext4/super.c
-+++ b/fs/ext4/super.c
-@@ -4672,7 +4672,9 @@ static int ext4_release_dquot(struct dquot *dquot)
- static int ext4_mark_dquot_dirty(struct dquot *dquot)
- {
-       /* Are we journaling quotas? */
--      if (EXT4_SB(dquot->dq_sb)->s_qf_names[USRQUOTA] ||
-+      if (EXT4_HAS_RO_COMPAT_FEATURE(dquot->dq_sb,
-+                      EXT4_FEATURE_RO_COMPAT_QUOTA) ||
-+          EXT4_SB(dquot->dq_sb)->s_qf_names[USRQUOTA] ||
-           EXT4_SB(dquot->dq_sb)->s_qf_names[GRPQUOTA]) {
-               dquot_mark_dquot_dirty(dquot);
-               return ext4_write_dquot(dquot);
diff --git a/ldiskfs/kernel_patches/patches/rhel6.5/ext4-give-warning-with-dir-htree-growing.patch b/ldiskfs/kernel_patches/patches/rhel6.5/ext4-give-warning-with-dir-htree-growing.patch
deleted file mode 100644 (file)
index 7cdebaa..0000000
+++ /dev/null
@@ -1,168 +0,0 @@
-diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
-index 938487a..47313fd 100644
---- a/fs/ext4/ext4.h
-+++ b/fs/ext4/ext4.h
-@@ -1178,6 +1178,7 @@ struct ext4_sb_info {
-       unsigned int s_mb_group_prealloc;
-       unsigned int s_max_writeback_mb_bump;
-       unsigned long s_max_dir_size;
-+      unsigned long s_warning_dir_size;
-       /* where last allocation was done - for stream allocation */
-       unsigned long s_mb_last_group;
-       unsigned long s_mb_last_start;
-diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
-index 992dc58..57ff920 100644
---- a/fs/ext4/namei.c
-+++ b/fs/ext4/namei.c
-@@ -370,11 +370,19 @@ struct ext4_dir_lock_data {
- #define ext4_htree_lock_data(l) ((struct ext4_dir_lock_data *)(l)->lk_private)
- #define ext4_find_entry(dir, name, dirent) __ext4_find_entry(dir, name, dirent, NULL)
--#define ext4_add_entry(handle, dentry, inode) __ext4_add_entry(handle, dentry, inode, NULL)
--
- /* NB: ext4_lblk_t is 32 bits so we use high bits to identify invalid blk */
- #define EXT4_HTREE_NODE_CHANGED       (0xcafeULL << 32)
-+inline int ext4_add_entry(handle_t *handle, struct dentry *dentry,
-+                          struct inode *inode)
-+{
-+      int ret = __ext4_add_entry(handle, dentry, inode, NULL);
-+
-+      if (ret == -ENOBUFS)
-+              ret = 0;
-+      return ret;
-+}
-+
- static void ext4_htree_event_cb(void *target, void *event)
- {
-       u64 *block = (u64 *)target;
-@@ -2053,6 +2061,54 @@ int __ext4_add_entry(handle_t *handle, struct dentry *dentry,
- }
- EXPORT_SYMBOL(__ext4_add_entry);
-+static unsigned long __ext4_max_dir_size(struct dx_frame *frames,
-+                             struct dx_frame *frame, struct inode *dir)
-+{
-+      unsigned long max_dir_size;
-+
-+      if (EXT4_SB(dir->i_sb)->s_max_dir_size) {
-+              max_dir_size = EXT4_SB(dir->i_sb)->s_max_dir_size;
-+      } else {
-+              max_dir_size = EXT4_BLOCK_SIZE(dir->i_sb);
-+              while (frame >= frames) {
-+                      max_dir_size *= dx_get_limit(frame->entries);
-+                      if (frame == frames)
-+                              break;
-+                      frame--;
-+              }
-+              /* use 75% of max dir size in average */
-+              max_dir_size = max_dir_size / 4 * 3;
-+      }
-+      return max_dir_size;
-+}
-+
-+/*
-+ * With hash tree growing, it is easy to hit ENOSPC, but it is hard
-+ * to predict when it will happen. let's give administrators warning
-+ * when reaching 5/8 and 11/16 of limit
-+ */
-+static inline bool dir_size_in_warning_range(struct dx_frame *frames,
-+                                           struct dx_frame *frame,
-+                                           struct inode *dir)
-+{
-+      unsigned long size1, size2;
-+      struct super_block *sb = dir->i_sb;
-+
-+      if (unlikely(!EXT4_SB(sb)->s_warning_dir_size))
-+              EXT4_SB(sb)->s_warning_dir_size =
-+                      __ext4_max_dir_size(frames, frame, dir);
-+
-+      size1 = EXT4_SB(sb)->s_warning_dir_size / 16 * 10;
-+      size1 = size1 & ~(EXT4_BLOCK_SIZE(sb) - 1);
-+      size2 = EXT4_SB(sb)->s_warning_dir_size / 16 * 11;
-+      size2 = size2 & ~(EXT4_BLOCK_SIZE(sb) - 1);
-+      if (in_range(dir->i_size, size1, EXT4_BLOCK_SIZE(sb)) ||
-+          in_range(dir->i_size, size2, EXT4_BLOCK_SIZE(sb)))
-+              return true;
-+
-+      return false;
-+}
-+
- /*
-  * Returns 0 for success, or a negative error value
-  */
-@@ -2068,6 +2124,7 @@ static int ext4_dx_add_entry(handle_t *handle, struct dentry *dentry,
-       struct ext4_dir_entry_2 *de;
-       int restart;
-       int err;
-+      bool ret_warn = false;
- again:
-       restart = 0;
-@@ -2088,6 +2145,11 @@ again:
-       /* Block full, should compress but for now just split */
-       dxtrace(printk(KERN_DEBUG "using %u of %u node entries\n",
-                      dx_get_count(entries), dx_get_limit(entries)));
-+
-+      if (frame - frames + 1 >= ext4_dir_htree_level(sb) ||
-+          EXT4_SB(dir->i_sb)->s_max_dir_size)
-+              ret_warn = dir_size_in_warning_range(frames, frame, dir);
-+
-       /* Need to split index? */
-       if (dx_get_count(entries) == dx_get_limit(entries)) {
-               ext4_lblk_t newblock;
-@@ -2119,7 +2181,7 @@ again:
-                                        "reach max htree level :%d",
-                                        dir->i_ino, levels);
-                       if (ext4_dir_htree_level(sb) < EXT4_HTREE_LEVEL) {
--                              ext4_warning(sb, "Large directory feature is"
-+                              ext4_warning(sb, "Large directory feature is "
-                                                "not enabled on this "
-                                                "filesystem");
-                       }
-@@ -2248,6 +2310,8 @@ cleanup:
-        * repeat dx_probe() to find out valid htree-path */
-       if (restart && err == 0)
-               goto again;
-+      if (err == 0 && ret_warn)
-+              err = -ENOBUFS;
-       return err;
- }
-diff --git a/fs/ext4/super.c b/fs/ext4/super.c
-index f02a632..b8ed072 100644
---- a/fs/ext4/super.c
-+++ b/fs/ext4/super.c
-@@ -1813,6 +1813,8 @@ set_qf_format:
-                       if (option < 0)
-                               return 0;
-                       sbi->s_max_dir_size = option * 1024;
-+                      /* reset s_warning_dir_size and make it re-calculated */
-+                      sbi->s_warning_dir_size = 0;
-                       break;
-               case Opt_stripe:
-                       if (match_int(&args[0], &option))
-@@ -2577,6 +2579,7 @@ EXT4_ATTR_OFFSET(inode_readahead_blks, 0644, sbi_ui_show,
-                inode_readahead_blks_store, s_inode_readahead_blks);
- EXT4_RW_ATTR_SBI_UI(inode_goal, s_inode_goal);
- EXT4_RW_ATTR_SBI_UI(max_dir_size, s_max_dir_size);
-+EXT4_RW_ATTR_SBI_UI(warning_dir_size, s_warning_dir_size);
- EXT4_RW_ATTR_SBI_UI(mb_stats, s_mb_stats);
- EXT4_RW_ATTR_SBI_UI(mb_max_to_scan, s_mb_max_to_scan);
- EXT4_RW_ATTR_SBI_UI(mb_min_to_scan, s_mb_min_to_scan);
-@@ -2594,6 +2597,7 @@ static struct attribute *ext4_attrs[] = {
-       ATTR_LIST(inode_readahead_blks),
-       ATTR_LIST(inode_goal),
-       ATTR_LIST(max_dir_size),
-+      ATTR_LIST(warning_dir_size),
-       ATTR_LIST(mb_stats),
-       ATTR_LIST(mb_max_to_scan),
-       ATTR_LIST(mb_min_to_scan),
-@@ -3119,6 +3123,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
-       sb->s_fs_info = sbi;
-       sbi->s_mount_opt = 0;
-       sbi->s_max_dir_size = 0;
-+      sbi->s_warning_dir_size = 0;
-       sbi->s_resuid = EXT4_DEF_RESUID;
-       sbi->s_resgid = EXT4_DEF_RESGID;
-       sbi->s_inode_readahead_blks = EXT4_DEF_INODE_READAHEAD_BLKS;
diff --git a/ldiskfs/kernel_patches/patches/rhel7.2/ext4-dont-check-before-replay.patch b/ldiskfs/kernel_patches/patches/rhel7.2/ext4-dont-check-before-replay.patch
deleted file mode 100644 (file)
index de1b7f6..0000000
+++ /dev/null
@@ -1,33 +0,0 @@
-Index: linux-stage/fs/ext4/super.c
-When ldiskfs run in failover mode whith read-only disk.
-Part of allocation updates are lost and ldiskfs may fail
-while mounting this is due to inconsistent state of
-group-descriptor. Group-descriptor check is added after
-journal replay.
-===================================================================
---- linux-stage/fs/ext4/super.c        2016-11-06 15:15:30.892386878 +0530
-+++ linux-stage.orig.1/fs/ext4/super.c 2016-11-08 10:56:45.579892189 +0530
-@@ -3980,10 +3980,6 @@
-                       goto failed_mount2;
-               }
-       }
--      if (!ext4_check_descriptors(sb, &first_not_zeroed)) {
--              ext4_msg(sb, KERN_ERR, "group descriptors corrupted!");
--              goto failed_mount2;
--      }
-
-       sbi->s_gdb_count = db_count;
-       get_random_bytes(&sbi->s_next_generation, sizeof(u32));
-@@ -4104,6 +4100,12 @@
-       sbi->s_journal->j_commit_callback = ext4_journal_commit_callback;
-
- no_journal:
-+
-+      if (!ext4_check_descriptors(sb, &first_not_zeroed)) {
-+              ext4_msg(sb, KERN_ERR, "group descriptors corrupted!");
-+              goto failed_mount_wq;
-+      }
-+
-       /*
-        * Get the # of file system overhead blocks from the
-        * superblock if present.
diff --git a/ldiskfs/kernel_patches/patches/rhel7.2/ext4-dont-check-in-ro.patch b/ldiskfs/kernel_patches/patches/rhel7.2/ext4-dont-check-in-ro.patch
deleted file mode 100644 (file)
index 9fa9194..0000000
+++ /dev/null
@@ -1,29 +0,0 @@
---- linux-stage/fs/ext4/mballoc.c      2016-11-25 04:15:25.824396109 +0530
-+++ linux-stage.orig/fs/ext4/mballoc.c 2016-11-25 02:59:13.505151246 +0530
-@@ -3594,6 +3594,11 @@
-       unsigned short max = EXT4_CLUSTERS_PER_GROUP(sb);
-       unsigned short i, first, free = 0;
-+#ifdef HAVE_CLEAR_RDONLY_ON_PUT
-+      /* be quiet if readonly device */
-+      if (dev_check_rdonly(sb->s_bdev))
-+              return 0;
-+#endif
-       i = mb_find_next_zero_bit(bitmap, max, 0);
-       while (i < max) {
-@@ -3969,6 +3974,14 @@
-               bit = next + 1;
-       }
-+
-+#ifdef HAVE_CLEAR_RDONLY_ON_PUT
-+      /* be quiet if readonly device */
-+      if (dev_check_rdonly(sb->s_bdev)) {
-+              atomic_add(free, &sbi->s_mb_discarded);
-+              return err;
-+      }
-+#endif
-       /* "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)) {
diff --git a/ldiskfs/kernel_patches/patches/rhel7.2/ext4-large-eas.patch b/ldiskfs/kernel_patches/patches/rhel7.2/ext4-large-eas.patch
deleted file mode 100644 (file)
index 35ca4d5..0000000
+++ /dev/null
@@ -1,1093 +0,0 @@
-This patch implements the large EA support in ext4. If the size of
-an EA value is larger than the blocksize, then the EA value would
-not be saved in the external EA block, instead it would be saved
-in an external EA inode. So, the patch also helps support a larger
-number of EAs.
-
-Index: linux-stage/fs/ext4/ext4.h
-===================================================================
---- linux-stage.orig/fs/ext4/ext4.h
-+++ linux-stage/fs/ext4/ext4.h
-@@ -1579,6 +1579,7 @@ static inline void ext4_clear_state_flag
-                                        EXT4_FEATURE_INCOMPAT_EXTENTS| \
-                                        EXT4_FEATURE_INCOMPAT_64BIT| \
-                                        EXT4_FEATURE_INCOMPAT_FLEX_BG| \
-+                                       EXT4_FEATURE_INCOMPAT_EA_INODE| \
-                                        EXT4_FEATURE_INCOMPAT_MMP |    \
-                                        EXT4_FEATURE_INCOMPAT_DIRDATA| \
-                                        EXT4_FEATURE_INCOMPAT_INLINE_DATA)
-@@ -1990,6 +1997,10 @@ struct mmpd_data {
- # define ATTRIB_NORET __attribute__((noreturn))
- # define NORET_AND    noreturn,
-+struct ext4_xattr_ino_array {
-+      unsigned int xia_count;         /* # of used item in the array */
-+      unsigned int xia_inodes[0];
-+};
- /* bitmap.c */
- extern unsigned int ext4_count_free(char *bitmap, unsigned numchars);
- void ext4_inode_bitmap_csum_set(struct super_block *sb, ext4_group_t group,
-@@ -2194,6 +2205,7 @@ extern void ext4_set_inode_flags(struct
- extern void ext4_get_inode_flags(struct ext4_inode_info *);
- extern int ext4_alloc_da_blocks(struct inode *inode);
- extern void ext4_set_aops(struct inode *inode);
-+extern int ext4_meta_trans_blocks(struct inode *, int nrblocks, int chunk);
- extern int ext4_writepage_trans_blocks(struct inode *);
- extern int ext4_chunk_trans_blocks(struct inode *, int nrblocks);
- extern int ext4_zero_partial_blocks(handle_t *handle, struct inode *inode,
-Index: linux-stage/fs/ext4/inode.c
-===================================================================
---- linux-stage.orig/fs/ext4/inode.c
-+++ linux-stage/fs/ext4/inode.c
-@@ -134,8 +134,6 @@ static void ext4_invalidatepage(struct p
-                               unsigned int length);
- static int __ext4_journalled_writepage(struct page *page, unsigned int len);
- static int ext4_bh_delay_or_unwritten(handle_t *handle, struct buffer_head *bh);
--static int ext4_meta_trans_blocks(struct inode *inode, int lblocks,
--                                int pextents);
- /*
-  * Test whether an inode is a fast symlink.
-@@ -184,6 +182,8 @@ void ext4_evict_inode(struct inode *inod
- {
-       handle_t *handle;
-       int err;
-+      int extra_credits = 3;
-+      struct ext4_xattr_ino_array *lea_ino_array = NULL;
-       trace_ext4_evict_inode(inode);
-@@ -236,8 +236,8 @@ void ext4_evict_inode(struct inode *inod
-        * protection against it
-        */
-       sb_start_intwrite(inode->i_sb);
--      handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE,
--                                  ext4_blocks_for_truncate(inode)+3);
-+
-+      handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, extra_credits);
-       if (IS_ERR(handle)) {
-               ext4_std_error(inode->i_sb, PTR_ERR(handle));
-               /*
-@@ -252,6 +252,32 @@ void ext4_evict_inode(struct inode *inod
-       if (IS_SYNC(inode))
-               ext4_handle_sync(handle);
-+
-+      /* Delete xattr inode before deleting the main inode. */
-+      err = ext4_xattr_delete_inode(handle, inode, &lea_ino_array);
-+      if (err) {
-+              ext4_warning(inode->i_sb,
-+                           "couldn't delete inode's xattr (err %d)", err);
-+              goto stop_handle;
-+      }
-+
-+      if (!IS_NOQUOTA(inode))
-+              extra_credits += 2 * EXT4_QUOTA_DEL_BLOCKS(inode->i_sb);
-+
-+      if (!ext4_handle_has_enough_credits(handle,
-+                      ext4_blocks_for_truncate(inode) + extra_credits)) {
-+              err = ext4_journal_extend(handle,
-+                      ext4_blocks_for_truncate(inode) + extra_credits);
-+              if (err > 0)
-+                      err = ext4_journal_restart(handle,
-+                      ext4_blocks_for_truncate(inode) + extra_credits);
-+              if (err != 0) {
-+                      ext4_warning(inode->i_sb,
-+                                   "couldn't extend journal (err %d)", err);
-+                      goto stop_handle;
-+              }
-+      }
-+
-       inode->i_size = 0;
-       err = ext4_mark_inode_dirty(handle, inode);
-       if (err) {
-@@ -269,10 +296,10 @@ void ext4_evict_inode(struct inode *inod
-        * enough credits left in the handle to remove the inode from
-        * the orphan list and set the dtime field.
-        */
--      if (!ext4_handle_has_enough_credits(handle, 3)) {
--              err = ext4_journal_extend(handle, 3);
-+      if (!ext4_handle_has_enough_credits(handle, extra_credits)) {
-+              err = ext4_journal_extend(handle, extra_credits);
-               if (err > 0)
--                      err = ext4_journal_restart(handle, 3);
-+                      err = ext4_journal_restart(handle, extra_credits);
-               if (err != 0) {
-                       ext4_warning(inode->i_sb,
-                                    "couldn't extend journal (err %d)", err);
-@@ -308,6 +335,9 @@ void ext4_evict_inode(struct inode *inod
-               ext4_free_inode(handle, inode);
-       ext4_journal_stop(handle);
-       sb_end_intwrite(inode->i_sb);
-+
-+      if (lea_ino_array != NULL)
-+              ext4_xattr_inode_array_free(inode, lea_ino_array);
-       return;
- no_delete:
-       ext4_clear_inode(inode);        /* We must guarantee clearing of inode... */
-@@ -4681,7 +4711,7 @@ static int ext4_index_trans_blocks(struc
-  *
-  * Also account for superblock, inode, quota and xattr blocks
-  */
--static int ext4_meta_trans_blocks(struct inode *inode, int lblocks,
-+int ext4_meta_trans_blocks(struct inode *inode, int lblocks,
-                                 int pextents)
- {
-       ext4_group_t groups, ngroups = ext4_get_groups_count(inode->i_sb);
-Index: linux-stage/fs/ext4/xattr.c
-===================================================================
---- linux-stage.orig/fs/ext4/xattr.c
-+++ linux-stage/fs/ext4/xattr.c
-@@ -201,6 +201,7 @@ ext4_xattr_check_names(struct ext4_xattr
-       while (!IS_LAST_ENTRY(entry)) {
-               if (entry->e_value_size != 0 &&
-+                  entry->e_value_inum == 0 &&
-                   (value_start + le16_to_cpu(entry->e_value_offs) <
-                    (void *)e + sizeof(__u32) ||
-                    value_start + le16_to_cpu(entry->e_value_offs) +
-@@ -233,19 +234,26 @@ ext4_xattr_check_block(struct inode *ino
- }
- static inline int
--ext4_xattr_check_entry(struct ext4_xattr_entry *entry, size_t size)
-+ext4_xattr_check_entry(struct ext4_xattr_entry *entry, size_t size,
-+                     struct inode *inode)
- {
-       size_t value_size = le32_to_cpu(entry->e_value_size);
--      if (entry->e_value_block != 0 || value_size > size ||
-+      if (!entry->e_value_inum &&
-           le16_to_cpu(entry->e_value_offs) + value_size > size)
-+              return -EIO;
-+      if (entry->e_value_inum &&
-+          (le32_to_cpu(entry->e_value_inum) < EXT4_FIRST_INO(inode->i_sb) ||
-+           le32_to_cpu(entry->e_value_inum) >
-+           le32_to_cpu(EXT4_SB(inode->i_sb)->s_es->s_inodes_count)))
-               return -EIO;
-       return 0;
- }
- static int
- ext4_xattr_find_entry(struct ext4_xattr_entry **pentry, int name_index,
--                    const char *name, size_t size, int sorted)
-+                    const char *name, size_t size, int sorted,
-+                    struct inode *inode)
- {
-       struct ext4_xattr_entry *entry;
-       size_t name_len;
-@@ -265,11 +273,109 @@ ext4_xattr_find_entry(struct ext4_xattr_
-                       break;
-       }
-       *pentry = entry;
--      if (!cmp && ext4_xattr_check_entry(entry, size))
-+      if (!cmp && ext4_xattr_check_entry(entry, size, inode))
-                       return -EIO;
-       return cmp ? -ENODATA : 0;
- }
-+/*
-+ * Read the EA value from an inode.
-+ */
-+static int ext4_xattr_inode_read(struct inode *ea_inode, void *buf, size_t *size)
-+{
-+      unsigned long block = 0;
-+      struct buffer_head *bh = NULL;
-+      int err, blocksize;
-+      size_t csize, ret_size = 0;
-+
-+      if (*size == 0)
-+              return 0;
-+
-+      blocksize = ea_inode->i_sb->s_blocksize;
-+
-+      while (ret_size < *size) {
-+              csize = (*size - ret_size) > blocksize ? blocksize :
-+                                                      *size - ret_size;
-+              bh = ext4_bread(NULL, ea_inode, block, 0, &err);
-+              if (!bh) {
-+                      *size = ret_size;
-+                      return err;
-+              }
-+              memcpy(buf, bh->b_data, csize);
-+              brelse(bh);
-+
-+              buf += csize;
-+              block += 1;
-+              ret_size += csize;
-+      }
-+
-+      *size = ret_size;
-+
-+      return err;
-+}
-+
-+/*
-+ * Fetch the xattr inode from disk.
-+ *
-+ * The xattr inode stores the parent inode number and generation so that
-+ * the kernel and e2fsck can verify the xattr inode is valid upon access.
-+ */
-+struct inode *ext4_xattr_inode_iget(struct inode *parent,
-+                                  unsigned long ea_ino, int *err)
-+{
-+      struct inode *ea_inode = NULL;
-+
-+      ea_inode = ext4_iget(parent->i_sb, ea_ino);
-+      if (IS_ERR(ea_inode) || is_bad_inode(ea_inode)) {
-+              int rc = IS_ERR(ea_inode) ? PTR_ERR(ea_inode) : 0;
-+              ext4_error(parent->i_sb, "error while reading EA inode %lu "
-+                         "/ %d %d", ea_ino, rc, is_bad_inode(ea_inode));
-+              *err = rc != 0 ? rc : -EIO;
-+              return NULL;
-+      }
-+
-+      if (EXT4_XATTR_INODE_GET_PARENT(ea_inode) != parent->i_ino ||
-+          ea_inode->i_generation != parent->i_generation) {
-+              ext4_error(parent->i_sb, "Backpointer from EA inode %lu "
-+                         "to parent invalid.", ea_ino);
-+              *err = -EINVAL;
-+              goto error;
-+      }
-+
-+      if (!(EXT4_I(ea_inode)->i_flags & EXT4_EA_INODE_FL)) {
-+              ext4_error(parent->i_sb, "EA inode %lu does not have "
-+                         "EXT4_EA_INODE_FL flag set.\n", ea_ino);
-+              *err = -EINVAL;
-+              goto error;
-+      }
-+
-+      *err = 0;
-+      return ea_inode;
-+
-+error:
-+      iput(ea_inode);
-+      return NULL;
-+}
-+
-+/*
-+ * Read the value from the EA inode.
-+ */
-+static int ext4_xattr_inode_get(struct inode *inode, unsigned long ea_ino,
-+                              void *buffer, size_t *size)
-+{
-+      struct inode *ea_inode = NULL;
-+      int err;
-+
-+      ea_inode = ext4_xattr_inode_iget(inode, ea_ino, &err);
-+      if (err)
-+              return err;
-+
-+      err = ext4_xattr_inode_read(ea_inode, buffer, size);
-+      iput(ea_inode);
-+
-+      return err;
-+}
-+
- static int
- ext4_xattr_block_get(struct inode *inode, int name_index, const char *name,
-                    void *buffer, size_t buffer_size)
-@@ -301,7 +401,8 @@ bad_block:
-       }
-       ext4_xattr_cache_insert(bh);
-       entry = BFIRST(bh);
--      error = ext4_xattr_find_entry(&entry, name_index, name, bh->b_size, 1);
-+      error = ext4_xattr_find_entry(&entry, name_index, name, bh->b_size, 1,
-+                                    inode);
-       if (error == -EIO)
-               goto bad_block;
-       if (error)
-@@ -311,8 +412,16 @@ bad_block:
-               error = -ERANGE;
-               if (size > buffer_size)
-                       goto cleanup;
--              memcpy(buffer, bh->b_data + le16_to_cpu(entry->e_value_offs),
--                     size);
-+              if (entry->e_value_inum) {
-+                      error = ext4_xattr_inode_get(inode,
-+                                           le32_to_cpu(entry->e_value_inum),
-+                                           buffer, &size);
-+                      if (error)
-+                              goto cleanup;
-+              } else {
-+                      memcpy(buffer, bh->b_data +
-+                             le16_to_cpu(entry->e_value_offs), size);
-+              }
-       }
-       error = size;
-@@ -346,7 +455,7 @@ ext4_xattr_ibody_get(struct inode *inode
-       if (error)
-               goto cleanup;
-       error = ext4_xattr_find_entry(&entry, name_index, name,
--                                    end - (void *)entry, 0);
-+                                    end - (void *)entry, 0, inode);
-       if (error)
-               goto cleanup;
-       size = le32_to_cpu(entry->e_value_size);
-@@ -354,8 +463,16 @@ ext4_xattr_ibody_get(struct inode *inode
-               error = -ERANGE;
-               if (size > buffer_size)
-                       goto cleanup;
--              memcpy(buffer, (void *)IFIRST(header) +
--                     le16_to_cpu(entry->e_value_offs), size);
-+              if (entry->e_value_inum) {
-+                      error = ext4_xattr_inode_get(inode,
-+                                           le32_to_cpu(entry->e_value_inum),
-+                                           buffer, &size);
-+                      if (error)
-+                              goto cleanup;
-+              } else {
-+                      memcpy(buffer, (void *)IFIRST(header) +
-+                             le16_to_cpu(entry->e_value_offs), size);
-+              }
-       }
-       error = size;
-@@ -600,7 +717,7 @@ static size_t ext4_xattr_free_space(stru
-                                   size_t *min_offs, void *base, int *total)
- {
-       for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
--              if (!last->e_value_block && last->e_value_size) {
-+              if (!last->e_value_inum && last->e_value_size) {
-                       size_t offs = le16_to_cpu(last->e_value_offs);
-                       if (offs < *min_offs)
-                               *min_offs = offs;
-@@ -611,16 +728,198 @@ static size_t ext4_xattr_free_space(stru
-       return (*min_offs - ((void *)last - base) - sizeof(__u32));
- }
-+/*
-+ * Write the value of the EA in an inode.
-+ */
- static int
--ext4_xattr_set_entry(struct ext4_xattr_info *i, struct ext4_xattr_search *s)
-+ext4_xattr_inode_write(handle_t *handle, struct inode *ea_inode,
-+                     const void *buf, int bufsize)
-+{
-+      struct buffer_head *bh = NULL;
-+      unsigned long block = 0;
-+      unsigned blocksize = ea_inode->i_sb->s_blocksize;
-+      unsigned max_blocks = (bufsize + blocksize - 1) >> ea_inode->i_blkbits;
-+      int csize, wsize = 0;
-+      int ret = 0;
-+      int retries = 0;
-+
-+retry:
-+      while (ret >= 0 && ret < max_blocks) {
-+              struct ext4_map_blocks map;
-+              map.m_lblk = block += ret;
-+              map.m_len = max_blocks -= ret;
-+
-+              ret = ext4_map_blocks(handle, ea_inode, &map,
-+                                    EXT4_GET_BLOCKS_CREATE);
-+              if (ret <= 0) {
-+                      ext4_mark_inode_dirty(handle, ea_inode);
-+                      if (ret == -ENOSPC &&
-+                          ext4_should_retry_alloc(ea_inode->i_sb, &retries)) {
-+                              ret = 0;
-+                              goto retry;
-+                      }
-+                      break;
-+              }
-+      }
-+
-+      if (ret < 0)
-+              return ret;
-+
-+      block = 0;
-+      while (wsize < bufsize) {
-+              if (bh != NULL)
-+                      brelse(bh);
-+              csize = (bufsize - wsize) > blocksize ? blocksize :
-+                                                              bufsize - wsize;
-+              bh = ext4_getblk(handle, ea_inode, block, 0, &ret);
-+              if (!bh)
-+                      goto out;
-+              ret = ext4_journal_get_write_access(handle, bh);
-+              if (ret)
-+                      goto out;
-+
-+              memcpy(bh->b_data, buf, csize);
-+              set_buffer_uptodate(bh);
-+              ext4_handle_dirty_metadata(handle, ea_inode, bh);
-+
-+              buf += csize;
-+              wsize += csize;
-+              block += 1;
-+      }
-+
-+      mutex_lock(&ea_inode->i_mutex);
-+      i_size_write(ea_inode, wsize);
-+      ext4_update_i_disksize(ea_inode, wsize);
-+      mutex_unlock(&ea_inode->i_mutex);
-+
-+      ext4_mark_inode_dirty(handle, ea_inode);
-+
-+out:
-+      brelse(bh);
-+
-+      return ret;
-+}
-+
-+static void ext4_xattr_inode_set_ref(struct inode *ea_inode, __u64 ref_count)
-+{
-+       ea_inode->i_ctime.tv_sec = (__u32)(ref_count >> 32);
-+       ea_inode->i_version = (__u32)ref_count;
-+}
-+
-+static void ext4_xattr_inode_set_hash(struct inode *ea_inode, __u32 hash)
-+{
-+       ea_inode->i_atime.tv_sec = hash;
-+}
-+
-+/*
-+ * Create an inode to store the value of a large EA.
-+ */
-+static struct inode *
-+ext4_xattr_inode_create(handle_t *handle, struct inode *inode, __u32 hash)
-+{
-+      struct inode *ea_inode = NULL;
-+
-+      /*
-+       * Let the next inode be the goal, so we try and allocate the EA inode
-+       * in the same group, or nearby one.
-+       */
-+      ea_inode = ext4_new_inode(handle, inode->i_sb->s_root->d_inode,
-+                                S_IFREG|0600, NULL, inode->i_ino + 1, NULL);
-+
-+      if (!IS_ERR(ea_inode)) {
-+              ea_inode->i_op = &ext4_file_inode_operations;
-+              ea_inode->i_fop = &ext4_file_operations;
-+              ext4_set_aops(ea_inode);
-+              ea_inode->i_generation = inode->i_generation;
-+              EXT4_I(ea_inode)->i_flags |= EXT4_EA_INODE_FL;
-+
-+              /*
-+               * A back-pointer from EA inode to parent inode will be useful
-+               * for e2fsck.
-+               */
-+              EXT4_XATTR_INODE_SET_PARENT(ea_inode, inode->i_ino);
-+              unlock_new_inode(ea_inode);
-+
-+               ext4_xattr_inode_set_ref(ea_inode, 1);
-+               ext4_xattr_inode_set_hash(ea_inode, hash);
-+      }
-+
-+      return ea_inode;
-+}
-+
-+/*
-+ * Unlink the inode storing the value of the EA.
-+ */
-+int
-+ext4_xattr_inode_unlink(struct inode *inode, unsigned long ea_ino)
-+{
-+      struct inode *ea_inode = NULL;
-+      int err;
-+
-+      ea_inode = ext4_xattr_inode_iget(inode, ea_ino, &err);
-+      if (err)
-+              return err;
-+
-+      clear_nlink(ea_inode);
-+      iput(ea_inode);
-+
-+      return 0;
-+}
-+
-+static __u32
-+ext4_xattr_inode_hash(struct ext4_sb_info *sbi, const void *buffer, size_t size)
-+{
-+      if (ext4_has_metadata_csum(sbi->s_sb))
-+              return ext4_chksum(sbi, sbi->s_csum_seed, buffer, size);
-+      return 0;
-+}
-+
-+/*
-+ * Add value of the EA in an inode.
-+ */
-+static int
-+ext4_xattr_inode_set(handle_t *handle, struct inode *inode, unsigned long *ea_ino,
-+                   const void *value, size_t value_len)
-+{
-+      struct inode *ea_inode = NULL;
-+      __u32 hash;
-+      int err;
-+
-+      /* Create an inode for the EA value */
-+      hash = ext4_xattr_inode_hash(EXT4_SB(inode->i_sb), value, value_len);
-+      ea_inode = ext4_xattr_inode_create(handle, inode, hash);
-+      if (IS_ERR(ea_inode))
-+              return -1;
-+
-+      err = ext4_xattr_inode_write(handle, ea_inode, value, value_len);
-+      if (err)
-+              clear_nlink(ea_inode);
-+      else
-+              *ea_ino = ea_inode->i_ino;
-+
-+      iput(ea_inode);
-+
-+      return err;
-+}
-+
-+static int
-+ext4_xattr_set_entry(struct ext4_xattr_info *i, struct ext4_xattr_search *s,
-+                   handle_t *handle, struct inode *inode)
- {
-       struct ext4_xattr_entry *last;
-       size_t free, min_offs = s->end - s->base, name_len = strlen(i->name);
-+      int in_inode = i->in_inode;
-+
-+      if (EXT4_HAS_INCOMPAT_FEATURE(inode->i_sb,
-+               EXT4_FEATURE_INCOMPAT_EA_INODE) &&
-+          (EXT4_XATTR_SIZE(i->value_len) >
-+           EXT4_XATTR_MIN_LARGE_EA_SIZE(inode->i_sb->s_blocksize)))
-+              in_inode = 1;
-       /* Compute min_offs and last. */
-       last = s->first;
-       for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
--              if (!last->e_value_block && last->e_value_size) {
-+              if (!last->e_value_inum && last->e_value_size) {
-                       size_t offs = le16_to_cpu(last->e_value_offs);
-                       if (offs < min_offs)
-                               min_offs = offs;
-@@ -628,15 +927,21 @@ ext4_xattr_set_entry(struct ext4_xattr_i
-       }
-       free = min_offs - ((void *)last - s->base) - sizeof(__u32);
-       if (!s->not_found) {
--              if (!s->here->e_value_block && s->here->e_value_size) {
-+              if (!in_inode &&
-+                  !s->here->e_value_inum && s->here->e_value_size) {
-                       size_t size = le32_to_cpu(s->here->e_value_size);
-                       free += EXT4_XATTR_SIZE(size);
-               }
-               free += EXT4_XATTR_LEN(name_len);
-       }
-       if (i->value) {
--              if (free < EXT4_XATTR_LEN(name_len) +
--                         EXT4_XATTR_SIZE(i->value_len))
-+              size_t value_len = EXT4_XATTR_SIZE(i->value_len);
-+
-+              if (in_inode)
-+                      value_len = 0;
-+
-+              if (free < value_len ||
-+                  free < EXT4_XATTR_LEN(name_len) + value_len)
-                       return -ENOSPC;
-       }
-@@ -651,7 +955,8 @@ ext4_xattr_set_entry(struct ext4_xattr_i
-               s->here->e_name_len = name_len;
-               memcpy(s->here->e_name, i->name, name_len);
-       } else {
--              if (!s->here->e_value_block && s->here->e_value_size) {
-+              if (!s->here->e_value_inum && s->here->e_value_size &&
-+                  s->here->e_value_offs > 0) {
-                       void *first_val = s->base + min_offs;
-                       size_t offs = le16_to_cpu(s->here->e_value_offs);
-                       void *val = s->base + offs;
-@@ -685,13 +990,18 @@ ext4_xattr_set_entry(struct ext4_xattr_i
-                       last = s->first;
-                       while (!IS_LAST_ENTRY(last)) {
-                               size_t o = le16_to_cpu(last->e_value_offs);
--                              if (!last->e_value_block &&
-+                              if (!last->e_value_inum &&
-                                   last->e_value_size && o < offs)
-                                       last->e_value_offs =
-                                               cpu_to_le16(o + size);
-                               last = EXT4_XATTR_NEXT(last);
-                       }
-               }
-+              if (s->here->e_value_inum) {
-+                      ext4_xattr_inode_unlink(inode,
-+                                      le32_to_cpu(s->here->e_value_inum));
-+                      s->here->e_value_inum = 0;
-+              }
-               if (!i->value) {
-                       /* Remove the old name. */
-                       size_t size = EXT4_XATTR_LEN(name_len);
-@@ -705,10 +1014,17 @@ ext4_xattr_set_entry(struct ext4_xattr_i
-       if (i->value) {
-               /* Insert the new value. */
-               s->here->e_value_size = cpu_to_le32(i->value_len);
--              if (i->value_len) {
-+              if (in_inode) {
-+                      unsigned long ea_ino = le32_to_cpu(s->here->e_value_inum);
-+                      ext4_xattr_inode_set(handle, inode, &ea_ino, i->value,
-+                                           i->value_len);
-+                      s->here->e_value_inum = cpu_to_le32(ea_ino);
-+                      s->here->e_value_offs = 0;
-+              } else if (i->value_len) {
-                       size_t size = EXT4_XATTR_SIZE(i->value_len);
-                       void *val = s->base + min_offs - size;
-                       s->here->e_value_offs = cpu_to_le16(min_offs - size);
-+                      s->here->e_value_inum = 0;
-                       if (i->value == EXT4_ZERO_XATTR_VALUE) {
-                               memset(val, 0, size);
-                       } else {
-@@ -758,7 +1074,7 @@ ext4_xattr_block_find(struct inode *inod
-               bs->s.end = bs->bh->b_data + bs->bh->b_size;
-               bs->s.here = bs->s.first;
-               error = ext4_xattr_find_entry(&bs->s.here, i->name_index,
--                                            i->name, bs->bh->b_size, 1);
-+                                            i->name, bs->bh->b_size, 1, inode);
-               if (error && error != -ENODATA)
-                       goto cleanup;
-               bs->s.not_found = error;
-@@ -782,8 +1098,6 @@ ext4_xattr_block_set(handle_t *handle, s
- #define header(x) ((struct ext4_xattr_header *)(x))
--      if (i->value && i->value_len > sb->s_blocksize)
--              return -ENOSPC;
-       if (s->base) {
-               ce = mb_cache_entry_get(ext4_xattr_cache, bs->bh->b_bdev,
-                                       bs->bh->b_blocknr);
-@@ -799,7 +1113,7 @@ ext4_xattr_block_set(handle_t *handle, s
-                               ce = NULL;
-                       }
-                       ea_bdebug(bs->bh, "modifying in-place");
--                      error = ext4_xattr_set_entry(i, s);
-+                      error = ext4_xattr_set_entry(i, s, handle, inode);
-                       if (!error) {
-                               if (!IS_LAST_ENTRY(s->first))
-                                       ext4_xattr_rehash(header(s->base),
-@@ -850,7 +1164,7 @@ ext4_xattr_block_set(handle_t *handle, s
-               s->end = s->base + sb->s_blocksize;
-       }
--      error = ext4_xattr_set_entry(i, s);
-+      error = ext4_xattr_set_entry(i, s, handle, inode);
-       if (error == -EIO)
-               goto bad_block;
-       if (error)
-@@ -1000,7 +1314,7 @@ int ext4_xattr_ibody_find(struct inode *
-               /* Find the named attribute. */
-               error = ext4_xattr_find_entry(&is->s.here, i->name_index,
-                                             i->name, is->s.end -
--                                            (void *)is->s.base, 0);
-+                                            (void *)is->s.base, 0, inode);
-               if (error && error != -ENODATA)
-                       return error;
-               is->s.not_found = error;
-@@ -1018,7 +1332,7 @@ int ext4_xattr_ibody_inline_set(handle_t
-       if (EXT4_I(inode)->i_extra_isize == 0)
-               return -ENOSPC;
--      error = ext4_xattr_set_entry(i, s);
-+      error = ext4_xattr_set_entry(i, s, handle, inode);
-       if (error) {
-               if (error == -ENOSPC &&
-                   ext4_has_inline_data(inode)) {
-@@ -1030,7 +1344,7 @@ int ext4_xattr_ibody_inline_set(handle_t
-                       error = ext4_xattr_ibody_find(inode, i, is);
-                       if (error)
-                               return error;
--                      error = ext4_xattr_set_entry(i, s);
-+                      error = ext4_xattr_set_entry(i, s, handle, inode);
-               }
-               if (error)
-                       return error;
-@@ -1056,7 +1370,7 @@ static int ext4_xattr_ibody_set(handle_t
-       if (EXT4_I(inode)->i_extra_isize == 0)
-               return -ENOSPC;
--      error = ext4_xattr_set_entry(i, s);
-+      error = ext4_xattr_set_entry(i, s, handle, inode);
-       if (error)
-               return error;
-       header = IHDR(inode, ext4_raw_inode(&is->iloc));
-@@ -1092,7 +1406,7 @@ ext4_xattr_set_handle(handle_t *handle,
-               .name = name,
-               .value = value,
-               .value_len = value_len,
--
-+              .in_inode = 0,
-       };
-       struct ext4_xattr_ibody_find is = {
-               .s = { .not_found = -ENODATA, },
-@@ -1157,6 +1471,15 @@ ext4_xattr_set_handle(handle_t *handle,
-                                       goto cleanup;
-                       }
-                       error = ext4_xattr_block_set(handle, inode, &i, &bs);
-+                      if (EXT4_HAS_INCOMPAT_FEATURE(inode->i_sb,
-+                                      EXT4_FEATURE_INCOMPAT_EA_INODE) &&
-+                          error == -ENOSPC) {
-+                              /* xattr not fit to block, store at external
-+                               * inode */
-+                              i.in_inode = 1;
-+                              error = ext4_xattr_ibody_set(handle, inode,
-+                                                           &i, &is);
-+                      }
-                       if (error)
-                               goto cleanup;
-                       if (!is.s.not_found) {
-@@ -1203,9 +1526,22 @@ ext4_xattr_set(struct inode *inode, int
-              const void *value, size_t value_len, int flags)
- {
-       handle_t *handle;
-+      struct super_block *sb = inode->i_sb;
-       int error, retries = 0;
-       int credits = ext4_jbd2_credits_xattr(inode);
-+      if ((value_len >= EXT4_XATTR_MIN_LARGE_EA_SIZE(sb->s_blocksize)) &&
-+          EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_EA_INODE)) {
-+              int nrblocks = (value_len + sb->s_blocksize - 1) >>
-+                                      sb->s_blocksize_bits;
-+
-+              /* For new inode */
-+              credits += EXT4_SINGLEDATA_TRANS_BLOCKS(sb) + 3;
-+
-+              /* For data blocks of EA inode */
-+              credits += ext4_meta_trans_blocks(inode, nrblocks, 0);
-+      }
-+
- retry:
-       handle = ext4_journal_start(inode, EXT4_HT_XATTR, credits);
-       if (IS_ERR(handle)) {
-@@ -1217,7 +1553,7 @@ retry:
-                                             value, value_len, flags);
-               error2 = ext4_journal_stop(handle);
-               if (error == -ENOSPC &&
--                  ext4_should_retry_alloc(inode->i_sb, &retries))
-+                  ext4_should_retry_alloc(sb, &retries))
-                       goto retry;
-               if (error == 0)
-                       error = error2;
-@@ -1239,7 +1575,7 @@ static void ext4_xattr_shift_entries(str
-       /* Adjust the value offsets of the entries */
-       for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
--              if (!last->e_value_block && last->e_value_size) {
-+              if (!last->e_value_inum && 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)
-@@ -1477,21 +1813,135 @@ cleanup:
- }
-+#define EIA_INCR 16 /* must be 2^n */
-+#define EIA_MASK (EIA_INCR - 1)
-+/* Add the large xattr @ino into @lea_ino_array for later deletion.
-+ * If @lea_ino_array is new or full it will be grown and the old
-+ * contents copied over.
-+ */
-+static int
-+ext4_expand_ino_array(struct ext4_xattr_ino_array **lea_ino_array, __u32 ino)
-+{
-+      if (*lea_ino_array == NULL) {
-+              /*
-+               * Start with 15 inodes, so it fits into a power-of-two size.
-+               * If *lea_ino_array is NULL, this is essentially offsetof()
-+               */
-+              (*lea_ino_array) =
-+                      kmalloc(offsetof(struct ext4_xattr_ino_array,
-+                                       xia_inodes[EIA_MASK]),
-+                              GFP_NOFS);
-+              if (*lea_ino_array == NULL)
-+                      return -ENOMEM;
-+              (*lea_ino_array)->xia_count = 0;
-+      } else if (((*lea_ino_array)->xia_count & EIA_MASK) == EIA_MASK) {
-+              /* expand the array once all 15 + n * 16 slots are full */
-+              struct ext4_xattr_ino_array *new_array = NULL;
-+              int count = (*lea_ino_array)->xia_count;
-+
-+              /* if new_array is NULL, this is essentially offsetof() */
-+              new_array = kmalloc(
-+                              offsetof(struct ext4_xattr_ino_array,
-+                                       xia_inodes[count + EIA_INCR]),
-+                              GFP_NOFS);
-+              if (new_array == NULL)
-+                      return -ENOMEM;
-+              memcpy(new_array, *lea_ino_array,
-+                     offsetof(struct ext4_xattr_ino_array,
-+                              xia_inodes[count]));
-+              kfree(*lea_ino_array);
-+              *lea_ino_array = new_array;
-+      }
-+      (*lea_ino_array)->xia_inodes[(*lea_ino_array)->xia_count++] = ino;
-+      return 0;
-+}
-+
-+/**
-+ * Add xattr inode to orphan list
-+ */
-+static int
-+ext4_xattr_inode_orphan_add(handle_t *handle, struct inode *inode,
-+                      int credits, struct ext4_xattr_ino_array *lea_ino_array)
-+{
-+      struct inode *ea_inode = NULL;
-+      int idx = 0, error = 0;
-+
-+      if (lea_ino_array == NULL)
-+              return 0;
-+
-+      for (; idx < lea_ino_array->xia_count; ++idx) {
-+              if (!ext4_handle_has_enough_credits(handle, credits)) {
-+                      error = ext4_journal_extend(handle, credits);
-+                      if (error > 0)
-+                              error = ext4_journal_restart(handle, credits);
-+
-+                      if (error != 0) {
-+                              ext4_warning(inode->i_sb,
-+                                      "couldn't extend journal "
-+                                      "(err %d)", error);
-+                              return error;
-+                      }
-+              }
-+              ea_inode = ext4_xattr_inode_iget(inode,
-+                              lea_ino_array->xia_inodes[idx], &error);
-+              if (error)
-+                      continue;
-+              ext4_orphan_add(handle, ea_inode);
-+              /* the inode's i_count will be released by caller */
-+      }
-+
-+      return 0;
-+}
- /*
-  * ext4_xattr_delete_inode()
-  *
-- * Free extended attribute resources associated with this inode. This
-+ * Free extended attribute resources associated with this inode. Traverse
-+ * all entries and unlink any xattr inodes associated with this inode. This
-  * is called immediately before an inode is freed. We have exclusive
-- * access to the inode.
-+ * access to the inode. If an orphan inode is deleted it will also delete any
-+ * xattr block and all xattr inodes. They are checked by ext4_xattr_inode_iget()
-+ * to ensure they belong to the parent inode and were not deleted already.
-  */
--void
--ext4_xattr_delete_inode(handle_t *handle, struct inode *inode)
-+int
-+ext4_xattr_delete_inode(handle_t *handle, struct inode *inode,
-+                      struct ext4_xattr_ino_array **lea_ino_array)
- {
-       struct buffer_head *bh = NULL;
-+      struct ext4_xattr_ibody_header *header;
-+      struct ext4_inode *raw_inode;
-+      struct ext4_iloc iloc;
-+      struct ext4_xattr_entry *entry;
-+      int credits = 3, error = 0;
--      if (!EXT4_I(inode)->i_file_acl)
-+      if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR))
-+              goto delete_external_ea;
-+
-+      error = ext4_get_inode_loc(inode, &iloc);
-+      if (error)
-               goto cleanup;
-+      raw_inode = ext4_raw_inode(&iloc);
-+      header = IHDR(inode, raw_inode);
-+      for (entry = IFIRST(header); !IS_LAST_ENTRY(entry);
-+           entry = EXT4_XATTR_NEXT(entry)) {
-+              if (!entry->e_value_inum)
-+                      continue;
-+              if (ext4_expand_ino_array(lea_ino_array,
-+                                        entry->e_value_inum) != 0) {
-+                      brelse(iloc.bh);
-+                      goto cleanup;
-+              }
-+              entry->e_value_inum = 0;
-+      }
-+      brelse(iloc.bh);
-+
-+delete_external_ea:
-+      if (!EXT4_I(inode)->i_file_acl) {
-+              /* add xattr inode to orphan list */
-+              ext4_xattr_inode_orphan_add(handle, inode, credits,
-+                                              *lea_ino_array);
-+              goto cleanup;
-+      }
-       bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
-       if (!bh) {
-               EXT4_ERROR_INODE(inode, "block %llu read error",
-@@ -1504,11 +1954,69 @@ ext4_xattr_delete_inode(handle_t *handle
-                                EXT4_I(inode)->i_file_acl);
-               goto cleanup;
-       }
-+
-+      for (entry = BFIRST(bh); !IS_LAST_ENTRY(entry);
-+           entry = EXT4_XATTR_NEXT(entry)) {
-+              if (!entry->e_value_inum)
-+                      continue;
-+              if (ext4_expand_ino_array(lea_ino_array,
-+                                        entry->e_value_inum) != 0)
-+                      goto cleanup;
-+              entry->e_value_inum = 0;
-+      }
-+
-+      /* add xattr inode to orphan list */
-+      error = ext4_xattr_inode_orphan_add(handle, inode, credits,
-+                                      *lea_ino_array);
-+      if (error != 0)
-+              goto cleanup;
-+
-+      if (!IS_NOQUOTA(inode))
-+              credits += 2 * EXT4_QUOTA_DEL_BLOCKS(inode->i_sb);
-+
-+      if (!ext4_handle_has_enough_credits(handle, credits)) {
-+              error = ext4_journal_extend(handle, credits);
-+              if (error > 0)
-+                      error = ext4_journal_restart(handle, credits);
-+              if (error != 0) {
-+                      ext4_warning(inode->i_sb,
-+                              "couldn't extend journal (err %d)", error);
-+                      goto cleanup;
-+              }
-+      }
-+
-       ext4_xattr_release_block(handle, inode, bh);
-       EXT4_I(inode)->i_file_acl = 0;
- cleanup:
-       brelse(bh);
-+
-+      return error;
-+}
-+
-+void
-+ext4_xattr_inode_array_free(struct inode *inode,
-+                          struct ext4_xattr_ino_array *lea_ino_array)
-+{
-+      struct inode    *ea_inode = NULL;
-+      int             idx = 0;
-+      int             err;
-+
-+      if (lea_ino_array == NULL)
-+              return;
-+
-+      for (; idx < lea_ino_array->xia_count; ++idx) {
-+              ea_inode = ext4_xattr_inode_iget(inode,
-+                              lea_ino_array->xia_inodes[idx], &err);
-+              if (err)
-+                      continue;
-+              /* for inode's i_count get from ext4_xattr_delete_inode */
-+              if (!list_empty(&EXT4_I(ea_inode)->i_orphan))
-+                      iput(ea_inode);
-+              clear_nlink(ea_inode);
-+              iput(ea_inode);
-+      }
-+      kfree(lea_ino_array);
- }
- /*
-@@ -1578,10 +2086,9 @@ ext4_xattr_cmp(struct ext4_xattr_header
-                   entry1->e_name_index != entry2->e_name_index ||
-                   entry1->e_name_len != entry2->e_name_len ||
-                   entry1->e_value_size != entry2->e_value_size ||
-+                  entry1->e_value_inum != entry2->e_value_inum ||
-                   memcmp(entry1->e_name, entry2->e_name, entry1->e_name_len))
-                       return 1;
--              if (entry1->e_value_block != 0 || entry2->e_value_block != 0)
--                      return -EIO;
-               if (memcmp((char *)header1 + le16_to_cpu(entry1->e_value_offs),
-                          (char *)header2 + le16_to_cpu(entry2->e_value_offs),
-                          le32_to_cpu(entry1->e_value_size)))
-@@ -1665,7 +2172,7 @@ static inline void ext4_xattr_hash_entry
-                      *name++;
-       }
--      if (entry->e_value_block == 0 && entry->e_value_size != 0) {
-+      if (!entry->e_value_inum && entry->e_value_size) {
-               __le32 *value = (__le32 *)((char *)header +
-                       le16_to_cpu(entry->e_value_offs));
-               for (n = (le32_to_cpu(entry->e_value_size) +
-Index: linux-stage/fs/ext4/xattr.h
-===================================================================
---- linux-stage.orig/fs/ext4/xattr.h
-+++ linux-stage/fs/ext4/xattr.h
-@@ -42,7 +42,7 @@ struct ext4_xattr_entry {
-       __u8    e_name_len;     /* length of name */
-       __u8    e_name_index;   /* attribute name index */
-       __le16  e_value_offs;   /* offset in disk block of value */
--      __le32  e_value_block;  /* disk block attribute is stored on (n/i) */
-+      __le32  e_value_inum;   /* inode in which the value is stored */
-       __le32  e_value_size;   /* size of attribute value */
-       __le32  e_hash;         /* hash value of name and value */
-       char    e_name[0];      /* attribute name */
-@@ -67,6 +67,26 @@ struct ext4_xattr_entry {
-               EXT4_I(inode)->i_extra_isize))
- #define IFIRST(hdr) ((struct ext4_xattr_entry *)((hdr)+1))
-+/*
-+ * Link EA inode back to parent one using i_mtime field.
-+ * Extra integer type conversion added to ignore higher
-+ * bits in i_mtime.tv_sec which might be set by ext4_get()
-+ */
-+#define EXT4_XATTR_INODE_SET_PARENT(inode, inum)      \
-+do {                                                  \
-+      (inode)->i_mtime.tv_sec = inum;                 \
-+} while(0)
-+
-+#define EXT4_XATTR_INODE_GET_PARENT(inode)            \
-+      ((__u32)(inode)->i_mtime.tv_sec)
-+
-+/*
-+ * The minimum size of EA value when you start storing it in an external inode
-+ * size of block - size of header - size of 1 entry - 4 null bytes
-+*/
-+#define EXT4_XATTR_MIN_LARGE_EA_SIZE(b)                                       \
-+      ((b) - EXT4_XATTR_LEN(3) - sizeof(struct ext4_xattr_header) - 4)
-+
- #define BHDR(bh) ((struct ext4_xattr_header *)((bh)->b_data))
- #define ENTRY(ptr) ((struct ext4_xattr_entry *)(ptr))
- #define BFIRST(bh) ENTRY(BHDR(bh)+1)
-@@ -75,10 +84,11 @@ struct ext4_xattr_entry {
- #define EXT4_ZERO_XATTR_VALUE ((void *)-1)
- struct ext4_xattr_info {
--      int name_index;
-       const char *name;
-       const void *value;
-       size_t value_len;
-+      int name_index;
-+      int in_inode;
- };
- struct ext4_xattr_search {
-@@ -106,7 +116,13 @@ extern int ext4_xattr_get(struct inode *
- extern int ext4_xattr_set(struct inode *, int, const char *, const void *, size_t, int);
- extern int ext4_xattr_set_handle(handle_t *, struct inode *, int, const char *, const void *, size_t, int);
--extern void ext4_xattr_delete_inode(handle_t *, struct inode *);
-+extern struct inode *ext4_xattr_inode_iget(struct inode *parent, unsigned long ea_ino,
-+                                         int *err);
-+extern int ext4_xattr_inode_unlink(struct inode *inode, unsigned long ea_ino);
-+extern int ext4_xattr_delete_inode(handle_t *handle, struct inode *inode,
-+                                 struct ext4_xattr_ino_array **array);
-+extern void ext4_xattr_inode_array_free(struct inode *inode,
-+                                      struct ext4_xattr_ino_array *array);
- extern void ext4_xattr_put_super(struct super_block *);
- extern int ext4_expand_extra_isize_ea(struct inode *inode, int new_extra_isize,
-Index: linux-stage/fs/ext4/ialloc.c
-===================================================================
---- linux-stage.orig/fs/ext4/ialloc.c
-+++ linux-stage/fs/ext4/ialloc.c
-@@ -269,7 +269,6 @@ void ext4_free_inode(handle_t *handle, s
-        * as writing the quota to disk may need the lock as well.
-        */
-       dquot_initialize(inode);
--      ext4_xattr_delete_inode(handle, inode);
-       dquot_free_inode(inode);
-       dquot_drop(inode);
-Index: linux-stage/fs/ext4/inline.c
-===================================================================
---- linux-stage.orig/fs/ext4/inline.c
-+++ linux-stage/fs/ext4/inline.c
-@@ -59,7 +59,7 @@ static int get_max_inline_xattr_value_si
-       /* Compute min_offs. */
-       for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
--              if (!entry->e_value_block && entry->e_value_size) {
-+              if (!entry->e_value_inum && entry->e_value_size) {
-                       size_t offs = le16_to_cpu(entry->e_value_offs);
-                       if (offs < min_offs)
-                               min_offs = offs;
diff --git a/ldiskfs/kernel_patches/patches/rhel7.2/ext4-pdirop.patch b/ldiskfs/kernel_patches/patches/rhel7.2/ext4-pdirop.patch
deleted file mode 100644 (file)
index 2064fd2..0000000
+++ /dev/null
@@ -1,1932 +0,0 @@
-Single directory performance is a critical for HPC workloads. In a
-typical use case an application creates a separate output file for
-each node and task in a job. As nodes and tasks increase, hundreds
-of thousands of files may be created in a single directory within
-a short window of time.
-Today, both filename lookup and file system modifying operations
-(such as create and unlink) are protected with a single lock for
-an entire ldiskfs directory. PDO project will remove this
-bottleneck by introducing a parallel locking mechanism for entire
-ldiskfs directories. This work will enable multiple application
-threads to simultaneously lookup, create and unlink in parallel.
-    
-This patch contains:
- - pdirops support for ldiskfs
- - integrate with osd-ldiskfs
-
-Index: linux-3.10.0-229.1.2.fc21.x86_64/include/linux/htree_lock.h
-===================================================================
---- /dev/null
-+++ linux-3.10.0-229.1.2.fc21.x86_64/include/linux/htree_lock.h
-@@ -0,0 +1,187 @@
-+/*
-+ * include/linux/htree_lock.h
-+ *
-+ * Copyright (c) 2011, 2012, Intel Corporation.
-+ *
-+ * Author: Liang Zhen <liang@whamcloud.com>
-+ */
-+
-+/*
-+ * htree lock
-+ *
-+ * htree_lock is an advanced lock, it can support five lock modes (concept is
-+ * taken from DLM) and it's a sleeping lock.
-+ *
-+ * most common use case is:
-+ * - create a htree_lock_head for data
-+ * - each thread (contender) creates it's own htree_lock
-+ * - contender needs to call htree_lock(lock_node, mode) to protect data and
-+ *   call htree_unlock to release lock
-+ *
-+ * Also, there is advanced use-case which is more complex, user can have
-+ * PW/PR lock on particular key, it's mostly used while user holding shared
-+ * lock on the htree (CW, CR)
-+ *
-+ * htree_lock(lock_node, HTREE_LOCK_CR); lock the htree with CR
-+ * htree_node_lock(lock_node, HTREE_LOCK_PR, key...); lock @key with PR
-+ * ...
-+ * htree_node_unlock(lock_node);; unlock the key
-+ *
-+ * Another tip is, we can have N-levels of this kind of keys, all we need to
-+ * do is specifying N-levels while creating htree_lock_head, then we can
-+ * lock/unlock a specific level by:
-+ * htree_node_lock(lock_node, mode1, key1, level1...);
-+ * do something;
-+ * htree_node_lock(lock_node, mode1, key2, level2...);
-+ * do something;
-+ * htree_node_unlock(lock_node, level2);
-+ * htree_node_unlock(lock_node, level1);
-+ *
-+ * NB: for multi-level, should be careful about locking order to avoid deadlock
-+ */
-+
-+#ifndef _LINUX_HTREE_LOCK_H
-+#define _LINUX_HTREE_LOCK_H
-+
-+#include <linux/list.h>
-+#include <linux/spinlock.h>
-+#include <linux/sched.h>
-+
-+/*
-+ * Lock Modes
-+ * more details can be found here:
-+ * http://en.wikipedia.org/wiki/Distributed_lock_manager
-+ */
-+typedef enum {
-+      HTREE_LOCK_EX   = 0, /* exclusive lock: incompatible with all others */
-+      HTREE_LOCK_PW,       /* protected write: allows only CR users */
-+      HTREE_LOCK_PR,       /* protected read: allow PR, CR users */
-+      HTREE_LOCK_CW,       /* concurrent write: allow CR, CW users */
-+      HTREE_LOCK_CR,       /* concurrent read: allow all but EX users */
-+      HTREE_LOCK_MAX,      /* number of lock modes */
-+} htree_lock_mode_t;
-+
-+#define HTREE_LOCK_NL         HTREE_LOCK_MAX
-+#define HTREE_LOCK_INVAL      0xdead10c
-+
-+enum {
-+      HTREE_HBITS_MIN         = 2,
-+      HTREE_HBITS_DEF         = 14,
-+      HTREE_HBITS_MAX         = 32,
-+};
-+
-+enum {
-+      HTREE_EVENT_DISABLE     = (0),
-+      HTREE_EVENT_RD          = (1 << HTREE_LOCK_PR),
-+      HTREE_EVENT_WR          = (1 << HTREE_LOCK_PW),
-+      HTREE_EVENT_RDWR        = (HTREE_EVENT_RD | HTREE_EVENT_WR),
-+};
-+
-+struct htree_lock;
-+
-+typedef void (*htree_event_cb_t)(void *target, void *event);
-+
-+struct htree_lock_child {
-+      struct list_head        lc_list;        /* granted list */
-+      htree_event_cb_t        lc_callback;    /* event callback */
-+      unsigned                lc_events;      /* event types */
-+};
-+
-+struct htree_lock_head {
-+      unsigned long           lh_lock;        /* bits lock */
-+      /* blocked lock list (htree_lock) */
-+      struct list_head        lh_blocked_list;
-+      /* # key levels */
-+      u16                     lh_depth;
-+      /* hash bits for key and limit number of locks */
-+      u16                     lh_hbits;
-+      /* counters for blocked locks */
-+      u16                     lh_nblocked[HTREE_LOCK_MAX];
-+      /* counters for granted locks */
-+      u16                     lh_ngranted[HTREE_LOCK_MAX];
-+      /* private data */
-+      void                    *lh_private;
-+      /* array of children locks */
-+      struct htree_lock_child lh_children[0];
-+};
-+
-+/* htree_lock_node_t is child-lock for a specific key (ln_value) */
-+struct htree_lock_node {
-+      htree_lock_mode_t       ln_mode;
-+      /* major hash key */
-+      u16                     ln_major_key;
-+      /* minor hash key */
-+      u16                     ln_minor_key;
-+      struct list_head        ln_major_list;
-+      struct list_head        ln_minor_list;
-+      /* alive list, all locks (granted, blocked, listening) are on it */
-+      struct list_head        ln_alive_list;
-+      /* blocked list */
-+      struct list_head        ln_blocked_list;
-+      /* granted list */
-+      struct list_head        ln_granted_list;
-+      void                    *ln_ev_target;
-+};
-+
-+struct htree_lock {
-+      struct task_struct      *lk_task;
-+      struct htree_lock_head  *lk_head;
-+      void                    *lk_private;
-+      unsigned                lk_depth;
-+      htree_lock_mode_t       lk_mode;
-+      struct list_head        lk_blocked_list;
-+      struct htree_lock_node  lk_nodes[0];
-+};
-+
-+/* create a lock head, which stands for a resource */
-+struct htree_lock_head *htree_lock_head_alloc(unsigned depth,
-+                                            unsigned hbits, unsigned priv);
-+/* free a lock head */
-+void htree_lock_head_free(struct htree_lock_head *lhead);
-+/* register event callback for child lock at level @depth */
-+void htree_lock_event_attach(struct htree_lock_head *lhead, unsigned depth,
-+                           unsigned events, htree_event_cb_t callback);
-+/* create a lock handle, which stands for a thread */
-+struct htree_lock *htree_lock_alloc(unsigned depth, unsigned pbytes);
-+/* free a lock handle */
-+void htree_lock_free(struct htree_lock *lck);
-+/* lock htree, when @wait is true, 0 is returned if the lock can't
-+ * be granted immediately */
-+int htree_lock_try(struct htree_lock *lck, struct htree_lock_head *lhead,
-+                 htree_lock_mode_t mode, int wait);
-+/* unlock htree */
-+void htree_unlock(struct htree_lock *lck);
-+/* unlock and relock htree with @new_mode */
-+int htree_change_lock_try(struct htree_lock *lck,
-+                        htree_lock_mode_t new_mode, int wait);
-+void htree_change_mode(struct htree_lock *lck, htree_lock_mode_t mode);
-+/* require child lock (key) of htree at level @dep, @event will be sent to all
-+ * listeners on this @key while lock being granted */
-+int htree_node_lock_try(struct htree_lock *lck, htree_lock_mode_t mode,
-+                      u32 key, unsigned dep, int wait, void *event);
-+/* release child lock at level @dep, this lock will listen on it's key
-+ * if @event isn't NULL, event_cb will be called against @lck while granting
-+ * any other lock at level @dep with the same key */
-+void htree_node_unlock(struct htree_lock *lck, unsigned dep, void *event);
-+/* stop listening on child lock at level @dep */
-+void htree_node_stop_listen(struct htree_lock *lck, unsigned dep);
-+/* for debug */
-+void htree_lock_stat_print(int depth);
-+void htree_lock_stat_reset(void);
-+
-+#define htree_lock(lck, lh, mode)     htree_lock_try(lck, lh, mode, 1)
-+#define htree_change_lock(lck, mode)  htree_change_lock_try(lck, mode, 1)
-+
-+#define htree_lock_mode(lck)          ((lck)->lk_mode)
-+
-+#define htree_node_lock(lck, mode, key, dep)  \
-+      htree_node_lock_try(lck, mode, key, dep, 1, NULL)
-+/* this is only safe in thread context of lock owner */
-+#define htree_node_is_granted(lck, dep)               \
-+      ((lck)->lk_nodes[dep].ln_mode != HTREE_LOCK_INVAL && \
-+       (lck)->lk_nodes[dep].ln_mode != HTREE_LOCK_NL)
-+/* this is only safe in thread context of lock owner */
-+#define htree_node_is_listening(lck, dep)     \
-+      ((lck)->lk_nodes[dep].ln_mode == HTREE_LOCK_NL)
-+
-+#endif
-Index: linux-3.10.0-229.1.2.fc21.x86_64/fs/ext4/htree_lock.c
-===================================================================
---- /dev/null
-+++ linux-3.10.0-229.1.2.fc21.x86_64/fs/ext4/htree_lock.c
-@@ -0,0 +1,880 @@
-+/*
-+ * fs/ext4/htree_lock.c
-+ *
-+ * Copyright (c) 2011, 2012, Intel Corporation.
-+ *
-+ * Author: Liang Zhen <liang@whamcloud.com>
-+ */
-+#include <linux/jbd2.h>
-+#include <linux/hash.h>
-+#include <linux/module.h>
-+#include <linux/htree_lock.h>
-+
-+enum {
-+      HTREE_LOCK_BIT_EX       = (1 << HTREE_LOCK_EX),
-+      HTREE_LOCK_BIT_PW       = (1 << HTREE_LOCK_PW),
-+      HTREE_LOCK_BIT_PR       = (1 << HTREE_LOCK_PR),
-+      HTREE_LOCK_BIT_CW       = (1 << HTREE_LOCK_CW),
-+      HTREE_LOCK_BIT_CR       = (1 << HTREE_LOCK_CR),
-+};
-+
-+enum {
-+      HTREE_LOCK_COMPAT_EX    = 0,
-+      HTREE_LOCK_COMPAT_PW    = HTREE_LOCK_COMPAT_EX | HTREE_LOCK_BIT_CR,
-+      HTREE_LOCK_COMPAT_PR    = HTREE_LOCK_COMPAT_PW | HTREE_LOCK_BIT_PR,
-+      HTREE_LOCK_COMPAT_CW    = HTREE_LOCK_COMPAT_PW | HTREE_LOCK_BIT_CW,
-+      HTREE_LOCK_COMPAT_CR    = HTREE_LOCK_COMPAT_CW | HTREE_LOCK_BIT_PR |
-+                                HTREE_LOCK_BIT_PW,
-+};
-+
-+static int htree_lock_compat[] = {
-+      [HTREE_LOCK_EX]         HTREE_LOCK_COMPAT_EX,
-+      [HTREE_LOCK_PW]         HTREE_LOCK_COMPAT_PW,
-+      [HTREE_LOCK_PR]         HTREE_LOCK_COMPAT_PR,
-+      [HTREE_LOCK_CW]         HTREE_LOCK_COMPAT_CW,
-+      [HTREE_LOCK_CR]         HTREE_LOCK_COMPAT_CR,
-+};
-+
-+/* max allowed htree-lock depth.
-+ * We only need depth=3 for ext4 although user can have higher value. */
-+#define HTREE_LOCK_DEP_MAX    16
-+
-+#ifdef HTREE_LOCK_DEBUG
-+
-+static char *hl_name[] = {
-+      [HTREE_LOCK_EX]         "EX",
-+      [HTREE_LOCK_PW]         "PW",
-+      [HTREE_LOCK_PR]         "PR",
-+      [HTREE_LOCK_CW]         "CW",
-+      [HTREE_LOCK_CR]         "CR",
-+};
-+
-+/* lock stats */
-+struct htree_lock_node_stats {
-+      unsigned long long      blocked[HTREE_LOCK_MAX];
-+      unsigned long long      granted[HTREE_LOCK_MAX];
-+      unsigned long long      retried[HTREE_LOCK_MAX];
-+      unsigned long long      events;
-+};
-+
-+struct htree_lock_stats {
-+      struct htree_lock_node_stats    nodes[HTREE_LOCK_DEP_MAX];
-+      unsigned long long      granted[HTREE_LOCK_MAX];
-+      unsigned long long      blocked[HTREE_LOCK_MAX];
-+};
-+
-+static struct htree_lock_stats hl_stats;
-+
-+void htree_lock_stat_reset(void)
-+{
-+      memset(&hl_stats, 0, sizeof(hl_stats));
-+}
-+
-+void htree_lock_stat_print(int depth)
-+{
-+      int     i;
-+      int     j;
-+
-+      printk(KERN_DEBUG "HTREE LOCK STATS:\n");
-+      for (i = 0; i < HTREE_LOCK_MAX; i++) {
-+              printk(KERN_DEBUG "[%s]: G [%10llu], B [%10llu]\n",
-+                     hl_name[i], hl_stats.granted[i], hl_stats.blocked[i]);
-+      }
-+      for (i = 0; i < depth; i++) {
-+              printk(KERN_DEBUG "HTREE CHILD [%d] STATS:\n", i);
-+              for (j = 0; j < HTREE_LOCK_MAX; j++) {
-+                      printk(KERN_DEBUG
-+                              "[%s]: G [%10llu], B [%10llu], R [%10llu]\n",
-+                              hl_name[j], hl_stats.nodes[i].granted[j],
-+                              hl_stats.nodes[i].blocked[j],
-+                              hl_stats.nodes[i].retried[j]);
-+              }
-+      }
-+}
-+
-+#define lk_grant_inc(m)       do { hl_stats.granted[m]++; } while (0)
-+#define lk_block_inc(m)       do { hl_stats.blocked[m]++; } while (0)
-+#define ln_grant_inc(d, m)    do { hl_stats.nodes[d].granted[m]++; } while (0)
-+#define ln_block_inc(d, m)    do { hl_stats.nodes[d].blocked[m]++; } while (0)
-+#define ln_retry_inc(d, m)    do { hl_stats.nodes[d].retried[m]++; } while (0)
-+#define ln_event_inc(d)       do { hl_stats.nodes[d].events++; } while (0)
-+
-+#else /* !DEBUG */
-+
-+void htree_lock_stat_reset(void) {}
-+void htree_lock_stat_print(int depth) {}
-+
-+#define lk_grant_inc(m)             do {} while (0)
-+#define lk_block_inc(m)             do {} while (0)
-+#define ln_grant_inc(d, m)    do {} while (0)
-+#define ln_block_inc(d, m)    do {} while (0)
-+#define ln_retry_inc(d, m)    do {} while (0)
-+#define ln_event_inc(d)             do {} while (0)
-+
-+#endif /* DEBUG */
-+
-+EXPORT_SYMBOL(htree_lock_stat_reset);
-+EXPORT_SYMBOL(htree_lock_stat_print);
-+
-+#define HTREE_DEP_ROOT                  (-1)
-+
-+#define htree_spin_lock(lhead, dep)                           \
-+      bit_spin_lock((dep) + 1, &(lhead)->lh_lock)
-+#define htree_spin_unlock(lhead, dep)                         \
-+      bit_spin_unlock((dep) + 1, &(lhead)->lh_lock)
-+
-+#define htree_key_event_ignore(child, ln)                     \
-+      (!((child)->lc_events & (1 << (ln)->ln_mode)))
-+
-+static int
-+htree_key_list_empty(struct htree_lock_node *ln)
-+{
-+      return list_empty(&ln->ln_major_list) && list_empty(&ln->ln_minor_list);
-+}
-+
-+static void
-+htree_key_list_del_init(struct htree_lock_node *ln)
-+{
-+      struct htree_lock_node *tmp = NULL;
-+
-+      if (!list_empty(&ln->ln_minor_list)) {
-+              tmp = list_entry(ln->ln_minor_list.next,
-+                               struct htree_lock_node, ln_minor_list);
-+              list_del_init(&ln->ln_minor_list);
-+      }
-+
-+      if (list_empty(&ln->ln_major_list))
-+              return;
-+
-+      if (tmp == NULL) { /* not on minor key list */
-+              list_del_init(&ln->ln_major_list);
-+      } else {
-+              BUG_ON(!list_empty(&tmp->ln_major_list));
-+              list_replace_init(&ln->ln_major_list, &tmp->ln_major_list);
-+      }
-+}
-+
-+static void
-+htree_key_list_replace_init(struct htree_lock_node *old,
-+                          struct htree_lock_node *new)
-+{
-+      if (!list_empty(&old->ln_major_list))
-+              list_replace_init(&old->ln_major_list, &new->ln_major_list);
-+
-+      if (!list_empty(&old->ln_minor_list))
-+              list_replace_init(&old->ln_minor_list, &new->ln_minor_list);
-+}
-+
-+static void
-+htree_key_event_enqueue(struct htree_lock_child *child,
-+                      struct htree_lock_node *ln, int dep, void *event)
-+{
-+      struct htree_lock_node *tmp;
-+
-+      /* NB: ALWAYS called holding lhead::lh_lock(dep) */
-+      BUG_ON(ln->ln_mode == HTREE_LOCK_NL);
-+      if (event == NULL || htree_key_event_ignore(child, ln))
-+              return;
-+
-+      /* shouldn't be a very long list */
-+      list_for_each_entry(tmp, &ln->ln_alive_list, ln_alive_list) {
-+              if (tmp->ln_mode == HTREE_LOCK_NL) {
-+                      ln_event_inc(dep);
-+                      if (child->lc_callback != NULL)
-+                              child->lc_callback(tmp->ln_ev_target, event);
-+              }
-+      }
-+}
-+
-+static int
-+htree_node_lock_enqueue(struct htree_lock *newlk, struct htree_lock *curlk,
-+                      unsigned dep, int wait, void *event)
-+{
-+      struct htree_lock_child *child = &newlk->lk_head->lh_children[dep];
-+      struct htree_lock_node *newln = &newlk->lk_nodes[dep];
-+      struct htree_lock_node *curln = &curlk->lk_nodes[dep];
-+
-+      /* NB: ALWAYS called holding lhead::lh_lock(dep) */
-+      /* NB: we only expect PR/PW lock mode at here, only these two modes are
-+       * allowed for htree_node_lock(asserted in htree_node_lock_internal),
-+       * NL is only used for listener, user can't directly require NL mode */
-+      if ((curln->ln_mode == HTREE_LOCK_NL) ||
-+          (curln->ln_mode != HTREE_LOCK_PW &&
-+           newln->ln_mode != HTREE_LOCK_PW)) {
-+              /* no conflict, attach it on granted list of @curlk */
-+              if (curln->ln_mode != HTREE_LOCK_NL) {
-+                      list_add(&newln->ln_granted_list,
-+                               &curln->ln_granted_list);
-+              } else {
-+                      /* replace key owner */
-+                      htree_key_list_replace_init(curln, newln);
-+              }
-+
-+              list_add(&newln->ln_alive_list, &curln->ln_alive_list);
-+              htree_key_event_enqueue(child, newln, dep, event);
-+              ln_grant_inc(dep, newln->ln_mode);
-+              return 1; /* still hold lh_lock */
-+      }
-+
-+      if (!wait) { /* can't grant and don't want to wait */
-+              ln_retry_inc(dep, newln->ln_mode);
-+              newln->ln_mode = HTREE_LOCK_INVAL;
-+              return -1; /* don't wait and just return -1 */
-+      }
-+
-+      newlk->lk_task = current;
-+      set_current_state(TASK_UNINTERRUPTIBLE);
-+      /* conflict, attach it on blocked list of curlk */
-+      list_add_tail(&newln->ln_blocked_list, &curln->ln_blocked_list);
-+      list_add(&newln->ln_alive_list, &curln->ln_alive_list);
-+      ln_block_inc(dep, newln->ln_mode);
-+
-+      htree_spin_unlock(newlk->lk_head, dep);
-+      /* wait to be given the lock */
-+      if (newlk->lk_task != NULL)
-+              schedule();
-+      /* granted, no doubt, wake up will set me RUNNING */
-+      if (event == NULL || htree_key_event_ignore(child, newln))
-+              return 0; /* granted without lh_lock */
-+
-+      htree_spin_lock(newlk->lk_head, dep);
-+      htree_key_event_enqueue(child, newln, dep, event);
-+      return 1; /* still hold lh_lock */
-+}
-+
-+/*
-+ * get PR/PW access to particular tree-node according to @dep and @key,
-+ * it will return -1 if @wait is false and can't immediately grant this lock.
-+ * All listeners(HTREE_LOCK_NL) on @dep and with the same @key will get
-+ * @event if it's not NULL.
-+ * NB: ALWAYS called holding lhead::lh_lock
-+ */
-+static int
-+htree_node_lock_internal(struct htree_lock_head *lhead, struct htree_lock *lck,
-+                       htree_lock_mode_t mode, u32 key, unsigned dep,
-+                       int wait, void *event)
-+{
-+      LIST_HEAD(list);
-+      struct htree_lock       *tmp;
-+      struct htree_lock       *tmp2;
-+      u16                     major;
-+      u16                     minor;
-+      u8                      reverse;
-+      u8                      ma_bits;
-+      u8                      mi_bits;
-+
-+      BUG_ON(mode != HTREE_LOCK_PW && mode != HTREE_LOCK_PR);
-+      BUG_ON(htree_node_is_granted(lck, dep));
-+
-+      key = hash_long(key, lhead->lh_hbits);
-+
-+      mi_bits = lhead->lh_hbits >> 1;
-+      ma_bits = lhead->lh_hbits - mi_bits;
-+
-+      lck->lk_nodes[dep].ln_major_key = major = key & ((1U << ma_bits) - 1);
-+      lck->lk_nodes[dep].ln_minor_key = minor = key >> ma_bits;
-+      lck->lk_nodes[dep].ln_mode = mode;
-+
-+      /*
-+       * The major key list is an ordered list, so searches are started
-+       * at the end of the list that is numerically closer to major_key,
-+       * so at most half of the list will be walked (for well-distributed
-+       * keys). The list traversal aborts early if the expected key
-+       * location is passed.
-+       */
-+      reverse = (major >= (1 << (ma_bits - 1)));
-+
-+      if (reverse) {
-+              list_for_each_entry_reverse(tmp,
-+                                      &lhead->lh_children[dep].lc_list,
-+                                      lk_nodes[dep].ln_major_list) {
-+                      if (tmp->lk_nodes[dep].ln_major_key == major) {
-+                              goto search_minor;
-+
-+                      } else if (tmp->lk_nodes[dep].ln_major_key < major) {
-+                              /* attach _after_ @tmp */
-+                              list_add(&lck->lk_nodes[dep].ln_major_list,
-+                                       &tmp->lk_nodes[dep].ln_major_list);
-+                              goto out_grant_major;
-+                      }
-+              }
-+
-+              list_add(&lck->lk_nodes[dep].ln_major_list,
-+                       &lhead->lh_children[dep].lc_list);
-+              goto out_grant_major;
-+
-+      } else {
-+              list_for_each_entry(tmp, &lhead->lh_children[dep].lc_list,
-+                                  lk_nodes[dep].ln_major_list) {
-+                      if (tmp->lk_nodes[dep].ln_major_key == major) {
-+                              goto search_minor;
-+
-+                      } else if (tmp->lk_nodes[dep].ln_major_key > major) {
-+                              /* insert _before_ @tmp */
-+                              list_add_tail(&lck->lk_nodes[dep].ln_major_list,
-+                                      &tmp->lk_nodes[dep].ln_major_list);
-+                              goto out_grant_major;
-+                      }
-+              }
-+
-+              list_add_tail(&lck->lk_nodes[dep].ln_major_list,
-+                            &lhead->lh_children[dep].lc_list);
-+              goto out_grant_major;
-+      }
-+
-+ search_minor:
-+      /*
-+       * NB: minor_key list doesn't have a "head", @list is just a
-+       * temporary stub for helping list searching, make sure it's removed
-+       * after searching.
-+       * minor_key list is an ordered list too.
-+       */
-+      list_add_tail(&list, &tmp->lk_nodes[dep].ln_minor_list);
-+
-+      reverse = (minor >= (1 << (mi_bits - 1)));
-+
-+      if (reverse) {
-+              list_for_each_entry_reverse(tmp2, &list,
-+                                          lk_nodes[dep].ln_minor_list) {
-+                      if (tmp2->lk_nodes[dep].ln_minor_key == minor) {
-+                              goto out_enqueue;
-+
-+                      } else if (tmp2->lk_nodes[dep].ln_minor_key < minor) {
-+                              /* attach _after_ @tmp2 */
-+                              list_add(&lck->lk_nodes[dep].ln_minor_list,
-+                                       &tmp2->lk_nodes[dep].ln_minor_list);
-+                              goto out_grant_minor;
-+                      }
-+              }
-+
-+              list_add(&lck->lk_nodes[dep].ln_minor_list, &list);
-+
-+      } else {
-+              list_for_each_entry(tmp2, &list,
-+                                  lk_nodes[dep].ln_minor_list) {
-+                      if (tmp2->lk_nodes[dep].ln_minor_key == minor) {
-+                              goto out_enqueue;
-+
-+                      } else if (tmp2->lk_nodes[dep].ln_minor_key > minor) {
-+                              /* insert _before_ @tmp2 */
-+                              list_add_tail(&lck->lk_nodes[dep].ln_minor_list,
-+                                      &tmp2->lk_nodes[dep].ln_minor_list);
-+                              goto out_grant_minor;
-+                      }
-+              }
-+
-+              list_add_tail(&lck->lk_nodes[dep].ln_minor_list, &list);
-+      }
-+
-+ out_grant_minor:
-+      if (list.next == &lck->lk_nodes[dep].ln_minor_list) {
-+              /* new lock @lck is the first one on minor_key list, which
-+               * means it has the smallest minor_key and it should
-+               * replace @tmp as minor_key owner */
-+              list_replace_init(&tmp->lk_nodes[dep].ln_major_list,
-+                                &lck->lk_nodes[dep].ln_major_list);
-+      }
-+      /* remove the temporary head */
-+      list_del(&list);
-+
-+ out_grant_major:
-+      ln_grant_inc(dep, lck->lk_nodes[dep].ln_mode);
-+      return 1; /* granted with holding lh_lock */
-+
-+ out_enqueue:
-+      list_del(&list); /* remove temprary head */
-+      return htree_node_lock_enqueue(lck, tmp2, dep, wait, event);
-+}
-+
-+/*
-+ * release the key of @lck at level @dep, and grant any blocked locks.
-+ * caller will still listen on @key if @event is not NULL, which means
-+ * caller can see a event (by event_cb) while granting any lock with
-+ * the same key at level @dep.
-+ * NB: ALWAYS called holding lhead::lh_lock
-+ * NB: listener will not block anyone because listening mode is HTREE_LOCK_NL
-+ */
-+static void
-+htree_node_unlock_internal(struct htree_lock_head *lhead,
-+                         struct htree_lock *curlk, unsigned dep, void *event)
-+{
-+      struct htree_lock_node  *curln = &curlk->lk_nodes[dep];
-+      struct htree_lock       *grtlk = NULL;
-+      struct htree_lock_node  *grtln;
-+      struct htree_lock       *poslk;
-+      struct htree_lock       *tmplk;
-+
-+      if (!htree_node_is_granted(curlk, dep))
-+              return;
-+
-+      if (!list_empty(&curln->ln_granted_list)) {
-+              /* there is another granted lock */
-+              grtlk = list_entry(curln->ln_granted_list.next,
-+                                 struct htree_lock,
-+                                 lk_nodes[dep].ln_granted_list);
-+              list_del_init(&curln->ln_granted_list);
-+      }
-+
-+      if (grtlk == NULL && !list_empty(&curln->ln_blocked_list)) {
-+              /*
-+               * @curlk is the only granted lock, so we confirmed:
-+               * a) curln is key owner (attached on major/minor_list),
-+               *    so if there is any blocked lock, it should be attached
-+               *    on curln->ln_blocked_list
-+               * b) we always can grant the first blocked lock
-+               */
-+              grtlk = list_entry(curln->ln_blocked_list.next,
-+                                 struct htree_lock,
-+                                 lk_nodes[dep].ln_blocked_list);
-+              BUG_ON(grtlk->lk_task == NULL);
-+              wake_up_process(grtlk->lk_task);
-+      }
-+
-+      if (event != NULL &&
-+          lhead->lh_children[dep].lc_events != HTREE_EVENT_DISABLE) {
-+              curln->ln_ev_target = event;
-+              curln->ln_mode = HTREE_LOCK_NL; /* listen! */
-+      } else {
-+              curln->ln_mode = HTREE_LOCK_INVAL;
-+      }
-+
-+      if (grtlk == NULL) { /* I must be the only one locking this key */
-+              struct htree_lock_node *tmpln;
-+
-+              BUG_ON(htree_key_list_empty(curln));
-+
-+              if (curln->ln_mode == HTREE_LOCK_NL) /* listening */
-+                      return;
-+
-+              /* not listening */
-+              if (list_empty(&curln->ln_alive_list)) { /* no more listener */
-+                      htree_key_list_del_init(curln);
-+                      return;
-+              }
-+
-+              tmpln = list_entry(curln->ln_alive_list.next,
-+                                 struct htree_lock_node, ln_alive_list);
-+
-+              BUG_ON(tmpln->ln_mode != HTREE_LOCK_NL);
-+
-+              htree_key_list_replace_init(curln, tmpln);
-+              list_del_init(&curln->ln_alive_list);
-+
-+              return;
-+      }
-+
-+      /* have a granted lock */
-+      grtln = &grtlk->lk_nodes[dep];
-+      if (!list_empty(&curln->ln_blocked_list)) {
-+              /* only key owner can be on both lists */
-+              BUG_ON(htree_key_list_empty(curln));
-+
-+              if (list_empty(&grtln->ln_blocked_list)) {
-+                      list_add(&grtln->ln_blocked_list,
-+                               &curln->ln_blocked_list);
-+              }
-+              list_del_init(&curln->ln_blocked_list);
-+      }
-+      /*
-+       * NB: this is the tricky part:
-+       * We have only two modes for child-lock (PR and PW), also,
-+       * only owner of the key (attached on major/minor_list) can be on
-+       * both blocked_list and granted_list, so @grtlk must be one
-+       * of these two cases:
-+       *
-+       * a) @grtlk is taken from granted_list, which means we've granted
-+       *    more than one lock so @grtlk has to be PR, the first blocked
-+       *    lock must be PW and we can't grant it at all.
-+       *    So even @grtlk is not owner of the key (empty blocked_list),
-+       *    we don't care because we can't grant any lock.
-+       * b) we just grant a new lock which is taken from head of blocked
-+       *    list, and it should be the first granted lock, and it should
-+       *    be the first one linked on blocked_list.
-+       *
-+       * Either way, we can get correct result by iterating blocked_list
-+       * of @grtlk, and don't have to bother on how to find out
-+       * owner of current key.
-+       */
-+      list_for_each_entry_safe(poslk, tmplk, &grtln->ln_blocked_list,
-+                               lk_nodes[dep].ln_blocked_list) {
-+              if (grtlk->lk_nodes[dep].ln_mode == HTREE_LOCK_PW ||
-+                  poslk->lk_nodes[dep].ln_mode == HTREE_LOCK_PW)
-+                      break;
-+              /* grant all readers */
-+              list_del_init(&poslk->lk_nodes[dep].ln_blocked_list);
-+              list_add(&poslk->lk_nodes[dep].ln_granted_list,
-+                       &grtln->ln_granted_list);
-+
-+              BUG_ON(poslk->lk_task == NULL);
-+              wake_up_process(poslk->lk_task);
-+      }
-+
-+      /* if @curln is the owner of this key, replace it with @grtln */
-+      if (!htree_key_list_empty(curln))
-+              htree_key_list_replace_init(curln, grtln);
-+
-+      if (curln->ln_mode == HTREE_LOCK_INVAL)
-+              list_del_init(&curln->ln_alive_list);
-+}
-+
-+/*
-+ * it's just wrapper of htree_node_lock_internal, it returns 1 on granted
-+ * and 0 only if @wait is false and can't grant it immediately
-+ */
-+int
-+htree_node_lock_try(struct htree_lock *lck, htree_lock_mode_t mode,
-+                  u32 key, unsigned dep, int wait, void *event)
-+{
-+      struct htree_lock_head *lhead = lck->lk_head;
-+      int rc;
-+
-+      BUG_ON(dep >= lck->lk_depth);
-+      BUG_ON(lck->lk_mode == HTREE_LOCK_INVAL);
-+
-+      htree_spin_lock(lhead, dep);
-+      rc = htree_node_lock_internal(lhead, lck, mode, key, dep, wait, event);
-+      if (rc != 0)
-+              htree_spin_unlock(lhead, dep);
-+      return rc >= 0;
-+}
-+EXPORT_SYMBOL(htree_node_lock_try);
-+
-+/* it's wrapper of htree_node_unlock_internal */
-+void
-+htree_node_unlock(struct htree_lock *lck, unsigned dep, void *event)
-+{
-+      struct htree_lock_head *lhead = lck->lk_head;
-+
-+      BUG_ON(dep >= lck->lk_depth);
-+      BUG_ON(lck->lk_mode == HTREE_LOCK_INVAL);
-+
-+      htree_spin_lock(lhead, dep);
-+      htree_node_unlock_internal(lhead, lck, dep, event);
-+      htree_spin_unlock(lhead, dep);
-+}
-+EXPORT_SYMBOL(htree_node_unlock);
-+
-+/* stop listening on child-lock level @dep */
-+void
-+htree_node_stop_listen(struct htree_lock *lck, unsigned dep)
-+{
-+      struct htree_lock_node *ln = &lck->lk_nodes[dep];
-+      struct htree_lock_node *tmp;
-+
-+      BUG_ON(htree_node_is_granted(lck, dep));
-+      BUG_ON(!list_empty(&ln->ln_blocked_list));
-+      BUG_ON(!list_empty(&ln->ln_granted_list));
-+
-+      if (!htree_node_is_listening(lck, dep))
-+              return;
-+
-+      htree_spin_lock(lck->lk_head, dep);
-+      ln->ln_mode = HTREE_LOCK_INVAL;
-+      ln->ln_ev_target = NULL;
-+
-+      if (htree_key_list_empty(ln)) { /* not owner */
-+              list_del_init(&ln->ln_alive_list);
-+              goto out;
-+      }
-+
-+      /* I'm the owner... */
-+      if (list_empty(&ln->ln_alive_list)) { /* no more listener */
-+              htree_key_list_del_init(ln);
-+              goto out;
-+      }
-+
-+      tmp = list_entry(ln->ln_alive_list.next,
-+                       struct htree_lock_node, ln_alive_list);
-+
-+      BUG_ON(tmp->ln_mode != HTREE_LOCK_NL);
-+      htree_key_list_replace_init(ln, tmp);
-+      list_del_init(&ln->ln_alive_list);
-+ out:
-+      htree_spin_unlock(lck->lk_head, dep);
-+}
-+EXPORT_SYMBOL(htree_node_stop_listen);
-+
-+/* release all child-locks if we have any */
-+static void
-+htree_node_release_all(struct htree_lock *lck)
-+{
-+      int     i;
-+
-+      for (i = 0; i < lck->lk_depth; i++) {
-+              if (htree_node_is_granted(lck, i))
-+                      htree_node_unlock(lck, i, NULL);
-+              else if (htree_node_is_listening(lck, i))
-+                      htree_node_stop_listen(lck, i);
-+      }
-+}
-+
-+/*
-+ * obtain htree lock, it could be blocked inside if there's conflict
-+ * with any granted or blocked lock and @wait is true.
-+ * NB: ALWAYS called holding lhead::lh_lock
-+ */
-+static int
-+htree_lock_internal(struct htree_lock *lck, int wait)
-+{
-+      struct htree_lock_head *lhead = lck->lk_head;
-+      int     granted = 0;
-+      int     blocked = 0;
-+      int     i;
-+
-+      for (i = 0; i < HTREE_LOCK_MAX; i++) {
-+              if (lhead->lh_ngranted[i] != 0)
-+                      granted |= 1 << i;
-+              if (lhead->lh_nblocked[i] != 0)
-+                      blocked |= 1 << i;
-+      }
-+      if ((htree_lock_compat[lck->lk_mode] & granted) != granted ||
-+          (htree_lock_compat[lck->lk_mode] & blocked) != blocked) {
-+              /* will block current lock even it just conflicts with any
-+               * other blocked lock, so lock like EX wouldn't starve */
-+              if (!wait)
-+                      return -1;
-+              lhead->lh_nblocked[lck->lk_mode]++;
-+              lk_block_inc(lck->lk_mode);
-+
-+              lck->lk_task = current;
-+              list_add_tail(&lck->lk_blocked_list, &lhead->lh_blocked_list);
-+
-+              set_current_state(TASK_UNINTERRUPTIBLE);
-+              htree_spin_unlock(lhead, HTREE_DEP_ROOT);
-+              /* wait to be given the lock */
-+              if (lck->lk_task != NULL)
-+                      schedule();
-+              /* granted, no doubt. wake up will set me RUNNING */
-+              return 0; /* without lh_lock */
-+      }
-+      lhead->lh_ngranted[lck->lk_mode]++;
-+      lk_grant_inc(lck->lk_mode);
-+      return 1;
-+}
-+
-+/* release htree lock. NB: ALWAYS called holding lhead::lh_lock */
-+static void
-+htree_unlock_internal(struct htree_lock *lck)
-+{
-+      struct htree_lock_head *lhead = lck->lk_head;
-+      struct htree_lock *tmp;
-+      struct htree_lock *tmp2;
-+      int granted = 0;
-+      int i;
-+
-+      BUG_ON(lhead->lh_ngranted[lck->lk_mode] == 0);
-+
-+      lhead->lh_ngranted[lck->lk_mode]--;
-+      lck->lk_mode = HTREE_LOCK_INVAL;
-+
-+      for (i = 0; i < HTREE_LOCK_MAX; i++) {
-+              if (lhead->lh_ngranted[i] != 0)
-+                      granted |= 1 << i;
-+      }
-+      list_for_each_entry_safe(tmp, tmp2,
-+                               &lhead->lh_blocked_list, lk_blocked_list) {
-+              /* conflict with any granted lock? */
-+              if ((htree_lock_compat[tmp->lk_mode] & granted) != granted)
-+                      break;
-+
-+              list_del_init(&tmp->lk_blocked_list);
-+
-+              BUG_ON(lhead->lh_nblocked[tmp->lk_mode] == 0);
-+
-+              lhead->lh_nblocked[tmp->lk_mode]--;
-+              lhead->lh_ngranted[tmp->lk_mode]++;
-+              granted |= 1 << tmp->lk_mode;
-+
-+              BUG_ON(tmp->lk_task == NULL);
-+              wake_up_process(tmp->lk_task);
-+      }
-+}
-+
-+/* it's wrapper of htree_lock_internal and exported interface.
-+ * It always return 1 with granted lock if @wait is true, it can return 0
-+ * if @wait is false and locking request can't be granted immediately */
-+int
-+htree_lock_try(struct htree_lock *lck, struct htree_lock_head *lhead,
-+             htree_lock_mode_t mode, int wait)
-+{
-+      int     rc;
-+
-+      BUG_ON(lck->lk_depth > lhead->lh_depth);
-+      BUG_ON(lck->lk_head != NULL);
-+      BUG_ON(lck->lk_task != NULL);
-+
-+      lck->lk_head = lhead;
-+      lck->lk_mode = mode;
-+
-+      htree_spin_lock(lhead, HTREE_DEP_ROOT);
-+      rc = htree_lock_internal(lck, wait);
-+      if (rc != 0)
-+              htree_spin_unlock(lhead, HTREE_DEP_ROOT);
-+      return rc >= 0;
-+}
-+EXPORT_SYMBOL(htree_lock_try);
-+
-+/* it's wrapper of htree_unlock_internal and exported interface.
-+ * It will release all htree_node_locks and htree_lock */
-+void
-+htree_unlock(struct htree_lock *lck)
-+{
-+      BUG_ON(lck->lk_head == NULL);
-+      BUG_ON(lck->lk_mode == HTREE_LOCK_INVAL);
-+
-+      htree_node_release_all(lck);
-+
-+      htree_spin_lock(lck->lk_head, HTREE_DEP_ROOT);
-+      htree_unlock_internal(lck);
-+      htree_spin_unlock(lck->lk_head, HTREE_DEP_ROOT);
-+      lck->lk_head = NULL;
-+      lck->lk_task = NULL;
-+}
-+EXPORT_SYMBOL(htree_unlock);
-+
-+/* change lock mode */
-+void
-+htree_change_mode(struct htree_lock *lck, htree_lock_mode_t mode)
-+{
-+      BUG_ON(lck->lk_mode == HTREE_LOCK_INVAL);
-+      lck->lk_mode = mode;
-+}
-+EXPORT_SYMBOL(htree_change_mode);
-+
-+/* release htree lock, and lock it again with new mode.
-+ * This function will first release all htree_node_locks and htree_lock,
-+ * then try to gain htree_lock with new @mode.
-+ * It always return 1 with granted lock if @wait is true, it can return 0
-+ * if @wait is false and locking request can't be granted immediately */
-+int
-+htree_change_lock_try(struct htree_lock *lck, htree_lock_mode_t mode, int wait)
-+{
-+      struct htree_lock_head *lhead = lck->lk_head;
-+      int rc;
-+
-+      BUG_ON(lhead == NULL);
-+      BUG_ON(lck->lk_mode == mode);
-+      BUG_ON(lck->lk_mode == HTREE_LOCK_INVAL || mode == HTREE_LOCK_INVAL);
-+
-+      htree_node_release_all(lck);
-+
-+      htree_spin_lock(lhead, HTREE_DEP_ROOT);
-+      htree_unlock_internal(lck);
-+      lck->lk_mode = mode;
-+      rc = htree_lock_internal(lck, wait);
-+      if (rc != 0)
-+              htree_spin_unlock(lhead, HTREE_DEP_ROOT);
-+      return rc >= 0;
-+}
-+EXPORT_SYMBOL(htree_change_lock_try);
-+
-+/* create a htree_lock head with @depth levels (number of child-locks),
-+ * it is a per resoruce structure */
-+struct htree_lock_head *
-+htree_lock_head_alloc(unsigned depth, unsigned hbits, unsigned priv)
-+{
-+      struct htree_lock_head *lhead;
-+      int  i;
-+
-+      if (depth > HTREE_LOCK_DEP_MAX) {
-+              printk(KERN_ERR "%d is larger than max htree_lock depth %d\n",
-+                      depth, HTREE_LOCK_DEP_MAX);
-+              return NULL;
-+      }
-+
-+      lhead = kzalloc(offsetof(struct htree_lock_head,
-+                               lh_children[depth]) + priv, GFP_NOFS);
-+      if (lhead == NULL)
-+              return NULL;
-+
-+      if (hbits < HTREE_HBITS_MIN)
-+              lhead->lh_hbits = HTREE_HBITS_MIN;
-+      else if (hbits > HTREE_HBITS_MAX)
-+              lhead->lh_hbits = HTREE_HBITS_MAX;
-+
-+      lhead->lh_lock = 0;
-+      lhead->lh_depth = depth;
-+      INIT_LIST_HEAD(&lhead->lh_blocked_list);
-+      if (priv > 0) {
-+              lhead->lh_private = (void *)lhead +
-+                      offsetof(struct htree_lock_head, lh_children[depth]);
-+      }
-+
-+      for (i = 0; i < depth; i++) {
-+              INIT_LIST_HEAD(&lhead->lh_children[i].lc_list);
-+              lhead->lh_children[i].lc_events = HTREE_EVENT_DISABLE;
-+      }
-+      return lhead;
-+}
-+EXPORT_SYMBOL(htree_lock_head_alloc);
-+
-+/* free the htree_lock head */
-+void
-+htree_lock_head_free(struct htree_lock_head *lhead)
-+{
-+      int     i;
-+
-+      BUG_ON(!list_empty(&lhead->lh_blocked_list));
-+      for (i = 0; i < lhead->lh_depth; i++)
-+              BUG_ON(!list_empty(&lhead->lh_children[i].lc_list));
-+      kfree(lhead);
-+}
-+EXPORT_SYMBOL(htree_lock_head_free);
-+
-+/* register event callback for @events of child-lock at level @dep */
-+void
-+htree_lock_event_attach(struct htree_lock_head *lhead, unsigned dep,
-+                      unsigned events, htree_event_cb_t callback)
-+{
-+      BUG_ON(lhead->lh_depth <= dep);
-+      lhead->lh_children[dep].lc_events = events;
-+      lhead->lh_children[dep].lc_callback = callback;
-+}
-+EXPORT_SYMBOL(htree_lock_event_attach);
-+
-+/* allocate a htree_lock, which is per-thread structure, @pbytes is some
-+ * extra-bytes as private data for caller */
-+struct htree_lock *
-+htree_lock_alloc(unsigned depth, unsigned pbytes)
-+{
-+      struct htree_lock *lck;
-+      int i = offsetof(struct htree_lock, lk_nodes[depth]);
-+
-+      if (depth > HTREE_LOCK_DEP_MAX) {
-+              printk(KERN_ERR "%d is larger than max htree_lock depth %d\n",
-+                      depth, HTREE_LOCK_DEP_MAX);
-+              return NULL;
-+      }
-+      lck = kzalloc(i + pbytes, GFP_NOFS);
-+      if (lck == NULL)
-+              return NULL;
-+
-+      if (pbytes != 0)
-+              lck->lk_private = (void *)lck + i;
-+      lck->lk_mode = HTREE_LOCK_INVAL;
-+      lck->lk_depth = depth;
-+      INIT_LIST_HEAD(&lck->lk_blocked_list);
-+
-+      for (i = 0; i < depth; i++) {
-+              struct htree_lock_node *node = &lck->lk_nodes[i];
-+
-+              node->ln_mode = HTREE_LOCK_INVAL;
-+              INIT_LIST_HEAD(&node->ln_major_list);
-+              INIT_LIST_HEAD(&node->ln_minor_list);
-+              INIT_LIST_HEAD(&node->ln_alive_list);
-+              INIT_LIST_HEAD(&node->ln_blocked_list);
-+              INIT_LIST_HEAD(&node->ln_granted_list);
-+      }
-+
-+      return lck;
-+}
-+EXPORT_SYMBOL(htree_lock_alloc);
-+
-+/* free htree_lock node */
-+void
-+htree_lock_free(struct htree_lock *lck)
-+{
-+      BUG_ON(lck->lk_mode != HTREE_LOCK_INVAL);
-+      kfree(lck);
-+}
-+EXPORT_SYMBOL(htree_lock_free);
-Index: linux-3.10.0-229.1.2.fc21.x86_64/fs/ext4/Makefile
-===================================================================
---- linux-3.10.0-229.1.2.fc21.x86_64.orig/fs/ext4/Makefile
-+++ linux-3.10.0-229.1.2.fc21.x86_64/fs/ext4/Makefile
-@@ -6,6 +6,7 @@ obj-$(CONFIG_EXT4_FS) += ext4.o
- ext4-y        := balloc.o bitmap.o dir.o file.o fsync.o ialloc.o inode.o page-io.o \
-               ioctl.o namei.o super.o symlink.o hash.o resize.o extents.o \
-+              htree_lock.o \
-               ext4_jbd2.o migrate.o mballoc.o block_validity.o move_extent.o \
-               mmp.o indirect.o extents_status.o xattr.o xattr_user.o \
-               xattr_trusted.o inline.o
-Index: linux-3.10.0-229.1.2.fc21.x86_64/fs/ext4/ext4.h
-===================================================================
---- linux-3.10.0-229.1.2.fc21.x86_64.orig/fs/ext4/ext4.h
-+++ linux-3.10.0-229.1.2.fc21.x86_64/fs/ext4/ext4.h
-@@ -27,6 +27,7 @@
- #include <linux/mutex.h>
- #include <linux/timer.h>
- #include <linux/wait.h>
-+#include <linux/htree_lock.h>
- #include <linux/blockgroup_lock.h>
- #include <linux/percpu_counter.h>
- #include <linux/ratelimit.h>
-@@ -821,6 +822,9 @@ struct ext4_inode_info {
-       __u32   i_dtime;
-       ext4_fsblk_t    i_file_acl;
-+      /* following fields for parallel directory operations -bzzz */
-+      struct semaphore i_append_sem;
-+
-       /*
-        * i_block_group is the number of the block group which contains
-        * this file's inode.  Constant across the lifetime of the inode,
-@@ -1846,6 +1850,71 @@ struct dx_hash_info
-  */
- #define HASH_NB_ALWAYS                1
-+/* assume name-hash is protected by upper layer */
-+#define EXT4_HTREE_LOCK_HASH  0
-+
-+enum ext4_pdo_lk_types {
-+#if EXT4_HTREE_LOCK_HASH
-+      EXT4_LK_HASH,
-+#endif
-+      EXT4_LK_DX,             /* index block */
-+      EXT4_LK_DE,             /* directory entry block */
-+      EXT4_LK_SPIN,           /* spinlock */
-+      EXT4_LK_MAX,
-+};
-+
-+/* read-only bit */
-+#define EXT4_LB_RO(b)         (1 << (b))
-+/* read + write, high bits for writer */
-+#define EXT4_LB_RW(b)         ((1 << (b)) | (1 << (EXT4_LK_MAX + (b))))
-+
-+enum ext4_pdo_lock_bits {
-+      /* DX lock bits */
-+      EXT4_LB_DX_RO           = EXT4_LB_RO(EXT4_LK_DX),
-+      EXT4_LB_DX              = EXT4_LB_RW(EXT4_LK_DX),
-+      /* DE lock bits */
-+      EXT4_LB_DE_RO           = EXT4_LB_RO(EXT4_LK_DE),
-+      EXT4_LB_DE              = EXT4_LB_RW(EXT4_LK_DE),
-+      /* DX spinlock bits */
-+      EXT4_LB_SPIN_RO         = EXT4_LB_RO(EXT4_LK_SPIN),
-+      EXT4_LB_SPIN            = EXT4_LB_RW(EXT4_LK_SPIN),
-+      /* accurate searching */
-+      EXT4_LB_EXACT           = EXT4_LB_RO(EXT4_LK_MAX << 1),
-+};
-+
-+enum ext4_pdo_lock_opc {
-+      /* external */
-+      EXT4_HLOCK_READDIR      = (EXT4_LB_DE_RO | EXT4_LB_DX_RO),
-+      EXT4_HLOCK_LOOKUP       = (EXT4_LB_DE_RO | EXT4_LB_SPIN_RO |
-+                                 EXT4_LB_EXACT),
-+      EXT4_HLOCK_DEL          = (EXT4_LB_DE | EXT4_LB_SPIN_RO |
-+                                 EXT4_LB_EXACT),
-+      EXT4_HLOCK_ADD          = (EXT4_LB_DE | EXT4_LB_SPIN_RO),
-+
-+      /* internal */
-+      EXT4_HLOCK_LOOKUP_SAFE  = (EXT4_LB_DE_RO | EXT4_LB_DX_RO |
-+                                 EXT4_LB_EXACT),
-+      EXT4_HLOCK_DEL_SAFE     = (EXT4_LB_DE | EXT4_LB_DX_RO | EXT4_LB_EXACT),
-+      EXT4_HLOCK_SPLIT        = (EXT4_LB_DE | EXT4_LB_DX | EXT4_LB_SPIN),
-+};
-+
-+extern struct htree_lock_head *ext4_htree_lock_head_alloc(unsigned hbits);
-+#define ext4_htree_lock_head_free(lhead)      htree_lock_head_free(lhead)
-+
-+extern struct htree_lock *ext4_htree_lock_alloc(void);
-+#define ext4_htree_lock_free(lck)             htree_lock_free(lck)
-+
-+extern void ext4_htree_lock(struct htree_lock *lck,
-+                          struct htree_lock_head *lhead,
-+                          struct inode *dir, unsigned flags);
-+#define ext4_htree_unlock(lck)                  htree_unlock(lck)
-+
-+extern struct buffer_head *__ext4_find_entry(struct inode *dir,
-+                                      const struct qstr *d_name,
-+                                      struct ext4_dir_entry_2 **res_dir,
-+                                      int *inlined, struct htree_lock *lck);
-+extern int __ext4_add_entry(handle_t *handle, struct dentry *dentry,
-+                    struct inode *inode, struct htree_lock *lck);
- /*
-  * Describe an inode's exact location on disk and in memory
-@@ -2088,9 +2157,17 @@ void ext4_insert_dentry(struct inode *in
-                       const char *name, int namelen, void *data);
- static inline void ext4_update_dx_flag(struct inode *inode)
- {
-+      /* Disable it for ldiskfs, because going from a DX directory to
-+       * a non-DX directory while it is in use will completely break
-+       * the htree-locking.
-+       * If we really want to support this operation in the future,
-+       * we need to exclusively lock the directory at here which will
-+       * increase complexity of code */
-+#if 0
-       if (!EXT4_HAS_COMPAT_FEATURE(inode->i_sb,
-                                    EXT4_FEATURE_COMPAT_DIR_INDEX))
-               ext4_clear_inode_flag(inode, EXT4_INODE_INDEX);
-+#endif
- }
- static unsigned char ext4_filetype_table[] = {
-       DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK
-Index: linux-3.10.0-229.1.2.fc21.x86_64/fs/ext4/namei.c
-===================================================================
---- linux-3.10.0-229.1.2.fc21.x86_64.orig/fs/ext4/namei.c
-+++ linux-3.10.0-229.1.2.fc21.x86_64/fs/ext4/namei.c
-@@ -53,6 +53,7 @@ struct buffer_head *ext4_append(handle_t
-                                       ext4_lblk_t *block)
- {
-       struct buffer_head *bh;
-+      struct ext4_inode_info *ei = EXT4_I(inode);
-       int err = 0;
-       if (unlikely(EXT4_SB(inode->i_sb)->s_max_dir_size_kb &&
-@@ -60,15 +61,22 @@ struct buffer_head *ext4_append(handle_t
-                     EXT4_SB(inode->i_sb)->s_max_dir_size_kb)))
-               return ERR_PTR(-ENOSPC);
-+      /* with parallel dir operations all appends
-+      * have to be serialized -bzzz */
-+      down(&ei->i_append_sem);
-+
-       *block = inode->i_size >> inode->i_sb->s_blocksize_bits;
-       bh = ext4_bread(handle, inode, *block, 1, &err);
--      if (!bh)
-+      if (!bh) {
-+              up(&ei->i_append_sem);
-               return ERR_PTR(err);
-+      }
-       inode->i_size += inode->i_sb->s_blocksize;
-       EXT4_I(inode)->i_disksize = inode->i_size;
-       BUFFER_TRACE(bh, "get_write_access");
-       err = ext4_journal_get_write_access(handle, bh);
-+      up(&ei->i_append_sem);
-       if (err) {
-               brelse(bh);
-               ext4_std_error(inode->i_sb, err);
-@@ -246,7 +254,7 @@ static struct dx_frame *dx_probe(const s
-                                struct inode *dir,
-                                struct dx_hash_info *hinfo,
-                                struct dx_frame *frame,
--                               int *err);
-+                               struct htree_lock *lck, int *err);
- static void dx_release(struct dx_frame *frames);
- static int dx_make_map(struct ext4_dir_entry_2 *de, unsigned blocksize,
-                      struct dx_hash_info *hinfo, struct dx_map_entry map[]);
-@@ -259,13 +267,13 @@ static void dx_insert_block(struct dx_fr
- static int ext4_htree_next_block(struct inode *dir, __u32 hash,
-                                struct dx_frame *frame,
-                                struct dx_frame *frames,
--                               __u32 *start_hash);
-+                               __u32 *start_hash, struct htree_lock *lck);
- static struct buffer_head * ext4_dx_find_entry(struct inode *dir,
-               const struct qstr *d_name,
-               struct ext4_dir_entry_2 **res_dir,
--              int *err);
-+              struct htree_lock *lck, int *err);
- static int ext4_dx_add_entry(handle_t *handle, struct dentry *dentry,
--                           struct inode *inode);
-+                           struct inode *inode, struct htree_lock *lck);
- /* checksumming functions */
- void initialize_dirent_tail(struct ext4_dir_entry_tail *t,
-@@ -668,6 +676,227 @@ struct stats dx_show_entries(struct dx_h
- }
- #endif /* DX_DEBUG */
-+/* private data for htree_lock */
-+struct ext4_dir_lock_data {
-+      unsigned                ld_flags;  /* bits-map for lock types */
-+      unsigned                ld_count;  /* # entries of the last DX block */
-+      struct dx_entry         ld_at_entry; /* copy of leaf dx_entry */
-+      struct dx_entry         *ld_at;    /* position of leaf dx_entry */
-+};
-+
-+#define ext4_htree_lock_data(l)       ((struct ext4_dir_lock_data *)(l)->lk_private)
-+#define ext4_find_entry(dir, name, dirent, inline) \
-+                      __ext4_find_entry(dir, name, dirent, inline, NULL)
-+#define ext4_add_entry(handle, dentry, inode) \
-+                      __ext4_add_entry(handle, dentry, inode, NULL)
-+
-+/* NB: ext4_lblk_t is 32 bits so we use high bits to identify invalid blk */
-+#define EXT4_HTREE_NODE_CHANGED       (0xcafeULL << 32)
-+
-+static void ext4_htree_event_cb(void *target, void *event)
-+{
-+      u64 *block = (u64 *)target;
-+
-+      if (*block == dx_get_block((struct dx_entry *)event))
-+              *block = EXT4_HTREE_NODE_CHANGED;
-+}
-+
-+struct htree_lock_head *ext4_htree_lock_head_alloc(unsigned hbits)
-+{
-+      struct htree_lock_head *lhead;
-+
-+      lhead = htree_lock_head_alloc(EXT4_LK_MAX, hbits, 0);
-+      if (lhead != NULL) {
-+              htree_lock_event_attach(lhead, EXT4_LK_SPIN, HTREE_EVENT_WR,
-+                                      ext4_htree_event_cb);
-+      }
-+      return lhead;
-+}
-+EXPORT_SYMBOL(ext4_htree_lock_head_alloc);
-+
-+struct htree_lock *ext4_htree_lock_alloc(void)
-+{
-+      return htree_lock_alloc(EXT4_LK_MAX,
-+                              sizeof(struct ext4_dir_lock_data));
-+}
-+EXPORT_SYMBOL(ext4_htree_lock_alloc);
-+
-+static htree_lock_mode_t ext4_htree_mode(unsigned flags)
-+{
-+      switch (flags) {
-+      default: /* 0 or unknown flags require EX lock */
-+              return HTREE_LOCK_EX;
-+      case EXT4_HLOCK_READDIR:
-+              return HTREE_LOCK_PR;
-+      case EXT4_HLOCK_LOOKUP:
-+              return HTREE_LOCK_CR;
-+      case EXT4_HLOCK_DEL:
-+      case EXT4_HLOCK_ADD:
-+              return HTREE_LOCK_CW;
-+      }
-+}
-+
-+/* return PR for read-only operations, otherwise return EX */
-+static inline htree_lock_mode_t ext4_htree_safe_mode(unsigned flags)
-+{
-+      int writer = (flags & EXT4_LB_DE) == EXT4_LB_DE;
-+
-+      /* 0 requires EX lock */
-+      return (flags == 0 || writer) ? HTREE_LOCK_EX : HTREE_LOCK_PR;
-+}
-+
-+static int ext4_htree_safe_locked(struct htree_lock *lck)
-+{
-+      int writer;
-+
-+      if (lck == NULL || lck->lk_mode == HTREE_LOCK_EX)
-+              return 1;
-+
-+      writer = (ext4_htree_lock_data(lck)->ld_flags & EXT4_LB_DE) ==
-+               EXT4_LB_DE;
-+      if (writer) /* all readers & writers are excluded? */
-+              return lck->lk_mode == HTREE_LOCK_EX;
-+
-+      /* all writers are excluded? */
-+      return lck->lk_mode == HTREE_LOCK_PR ||
-+             lck->lk_mode == HTREE_LOCK_PW ||
-+             lck->lk_mode == HTREE_LOCK_EX;
-+}
-+
-+/* relock htree_lock with EX mode if it's change operation, otherwise
-+ * relock it with PR mode. It's noop if PDO is disabled. */
-+static void ext4_htree_safe_relock(struct htree_lock *lck)
-+{
-+      if (!ext4_htree_safe_locked(lck)) {
-+              unsigned flags = ext4_htree_lock_data(lck)->ld_flags;
-+
-+              htree_change_lock(lck, ext4_htree_safe_mode(flags));
-+      }
-+}
-+
-+void ext4_htree_lock(struct htree_lock *lck, struct htree_lock_head *lhead,
-+                   struct inode *dir, unsigned flags)
-+{
-+      htree_lock_mode_t mode = is_dx(dir) ? ext4_htree_mode(flags) :
-+                                            ext4_htree_safe_mode(flags);
-+
-+      ext4_htree_lock_data(lck)->ld_flags = flags;
-+      htree_lock(lck, lhead, mode);
-+      if (!is_dx(dir))
-+              ext4_htree_safe_relock(lck); /* make sure it's safe locked */
-+}
-+EXPORT_SYMBOL(ext4_htree_lock);
-+
-+static int ext4_htree_node_lock(struct htree_lock *lck, struct dx_entry *at,
-+                              unsigned lmask, int wait, void *ev)
-+{
-+      u32     key = (at == NULL) ? 0 : dx_get_block(at);
-+      u32     mode;
-+
-+      /* NOOP if htree is well protected or caller doesn't require the lock */
-+      if (ext4_htree_safe_locked(lck) ||
-+         !(ext4_htree_lock_data(lck)->ld_flags & lmask))
-+              return 1;
-+
-+      mode = (ext4_htree_lock_data(lck)->ld_flags & lmask) == lmask ?
-+              HTREE_LOCK_PW : HTREE_LOCK_PR;
-+      while (1) {
-+              if (htree_node_lock_try(lck, mode, key, ffz(~lmask), wait, ev))
-+                      return 1;
-+              if (!(lmask & EXT4_LB_SPIN)) /* not a spinlock */
-+                      return 0;
-+              cpu_relax(); /* spin until granted */
-+      }
-+}
-+
-+static int ext4_htree_node_locked(struct htree_lock *lck, unsigned lmask)
-+{
-+      return ext4_htree_safe_locked(lck) ||
-+             htree_node_is_granted(lck, ffz(~lmask));
-+}
-+
-+static void ext4_htree_node_unlock(struct htree_lock *lck,
-+                                 unsigned lmask, void *buf)
-+{
-+      /* NB: it's safe to call mutiple times or even it's not locked */
-+      if (!ext4_htree_safe_locked(lck) &&
-+           htree_node_is_granted(lck, ffz(~lmask)))
-+              htree_node_unlock(lck, ffz(~lmask), buf);
-+}
-+
-+#define ext4_htree_dx_lock(lck, key)          \
-+      ext4_htree_node_lock(lck, key, EXT4_LB_DX, 1, NULL)
-+#define ext4_htree_dx_lock_try(lck, key)      \
-+      ext4_htree_node_lock(lck, key, EXT4_LB_DX, 0, NULL)
-+#define ext4_htree_dx_unlock(lck)             \
-+      ext4_htree_node_unlock(lck, EXT4_LB_DX, NULL)
-+#define ext4_htree_dx_locked(lck)             \
-+      ext4_htree_node_locked(lck, EXT4_LB_DX)
-+
-+static void ext4_htree_dx_need_lock(struct htree_lock *lck)
-+{
-+      struct ext4_dir_lock_data *ld;
-+
-+      if (ext4_htree_safe_locked(lck))
-+              return;
-+
-+      ld = ext4_htree_lock_data(lck);
-+      switch (ld->ld_flags) {
-+      default:
-+              return;
-+      case EXT4_HLOCK_LOOKUP:
-+              ld->ld_flags = EXT4_HLOCK_LOOKUP_SAFE;
-+              return;
-+      case EXT4_HLOCK_DEL:
-+              ld->ld_flags = EXT4_HLOCK_DEL_SAFE;
-+              return;
-+      case EXT4_HLOCK_ADD:
-+              ld->ld_flags = EXT4_HLOCK_SPLIT;
-+              return;
-+      }
-+}
-+
-+#define ext4_htree_de_lock(lck, key)          \
-+      ext4_htree_node_lock(lck, key, EXT4_LB_DE, 1, NULL)
-+#define ext4_htree_de_unlock(lck)             \
-+      ext4_htree_node_unlock(lck, EXT4_LB_DE, NULL)
-+
-+#define ext4_htree_spin_lock(lck, key, event) \
-+      ext4_htree_node_lock(lck, key, EXT4_LB_SPIN, 0, event)
-+#define ext4_htree_spin_unlock(lck)           \
-+      ext4_htree_node_unlock(lck, EXT4_LB_SPIN, NULL)
-+#define ext4_htree_spin_unlock_listen(lck, p) \
-+      ext4_htree_node_unlock(lck, EXT4_LB_SPIN, p)
-+
-+static void ext4_htree_spin_stop_listen(struct htree_lock *lck)
-+{
-+      if (!ext4_htree_safe_locked(lck) &&
-+          htree_node_is_listening(lck, ffz(~EXT4_LB_SPIN)))
-+              htree_node_stop_listen(lck, ffz(~EXT4_LB_SPIN));
-+}
-+
-+enum {
-+      DX_HASH_COL_IGNORE,     /* ignore collision while probing frames */
-+      DX_HASH_COL_YES,        /* there is collision and it does matter */
-+      DX_HASH_COL_NO,         /* there is no collision */
-+};
-+
-+static int dx_probe_hash_collision(struct htree_lock *lck,
-+                                 struct dx_entry *entries,
-+                                 struct dx_entry *at, u32 hash)
-+{
-+      if (!(ext4_htree_lock_data(lck)->ld_flags & EXT4_LB_EXACT)) {
-+              return DX_HASH_COL_IGNORE; /* don't care about collision */
-+
-+      } else if (at == entries + dx_get_count(entries) - 1) {
-+              return DX_HASH_COL_IGNORE; /* not in any leaf of this DX */
-+
-+      } else { /* hash collision? */
-+              return ((dx_get_hash(at + 1) & ~1) == hash) ?
-+                      DX_HASH_COL_YES : DX_HASH_COL_NO;
-+      }
-+}
-+
- /*
-  * Probe for a directory leaf block to search.
-  *
-@@ -679,10 +908,11 @@ struct stats dx_show_entries(struct dx_h
-  */
- static struct dx_frame *
- dx_probe(const struct qstr *d_name, struct inode *dir,
--       struct dx_hash_info *hinfo, struct dx_frame *frame_in, int *err)
-+       struct dx_hash_info *hinfo, struct dx_frame *frame_in,
-+       struct htree_lock *lck, int *err)
- {
-       unsigned count, indirect;
--      struct dx_entry *at, *entries, *p, *q, *m;
-+      struct dx_entry *at, *entries, *p, *q, *m, *dx = NULL;
-       struct dx_root_info *info;
-       struct buffer_head *bh;
-       struct dx_frame *frame = frame_in;
-@@ -750,8 +980,15 @@ dx_probe(const struct qstr *d_name, stru
-       dxtrace(printk("Look up %x", hash));
-       while (1)
-       {
-+              if (indirect == 0) { /* the last index level */
-+                      /* NB: ext4_htree_dx_lock() could be noop if
-+                       * DX-lock flag is not set for current operation */
-+                      ext4_htree_dx_lock(lck, dx);
-+                      ext4_htree_spin_lock(lck, dx, NULL);
-+              }
-               count = dx_get_count(entries);
--              if (!count || count > dx_get_limit(entries)) {
-+              if (count == 0 || count > dx_get_limit(entries)) {
-+                      ext4_htree_spin_unlock(lck); /* release spin */
-                       ext4_warning(dir->i_sb,
-                                    "dx entry: no count or count > limit");
-                       brelse(bh);
-@@ -792,7 +1029,70 @@ dx_probe(const struct qstr *d_name, stru
-               frame->bh = bh;
-               frame->entries = entries;
-               frame->at = at;
--              if (!indirect--) return frame;
-+
-+              if (indirect == 0) { /* the last index level */
-+                      struct ext4_dir_lock_data *ld;
-+                      u64 myblock;
-+
-+                      /* By default we only lock DE-block, however, we will
-+                       * also lock the last level DX-block if:
-+                       * a) there is hash collision
-+                       *    we will set DX-lock flag (a few lines below)
-+                       *    and redo to lock DX-block
-+                       *    see detail in dx_probe_hash_collision()
-+                       * b) it's a retry from splitting
-+                       *    we need to lock the last level DX-block so nobody
-+                       *    else can split any leaf blocks under the same
-+                       *    DX-block, see detail in ext4_dx_add_entry()
-+                       */
-+                      if (ext4_htree_dx_locked(lck)) {
-+                              /* DX-block is locked, just lock DE-block
-+                               * and return */
-+                              ext4_htree_spin_unlock(lck);
-+                              if (!ext4_htree_safe_locked(lck))
-+                                      ext4_htree_de_lock(lck, frame->at);
-+                              return frame;
-+                      }
-+                      /* it's pdirop and no DX lock */
-+                      if (dx_probe_hash_collision(lck, entries, at, hash) ==
-+                          DX_HASH_COL_YES) {
-+                              /* found hash collision, set DX-lock flag
-+                               * and retry to abtain DX-lock */
-+                              ext4_htree_spin_unlock(lck);
-+                              ext4_htree_dx_need_lock(lck);
-+                              continue;
-+                      }
-+                      ld = ext4_htree_lock_data(lck);
-+                      /* because I don't lock DX, so @at can't be trusted
-+                       * after I release spinlock so I have to save it */
-+                      ld->ld_at = at;
-+                      ld->ld_at_entry = *at;
-+                      ld->ld_count = dx_get_count(entries);
-+
-+                      frame->at = &ld->ld_at_entry;
-+                      myblock = dx_get_block(at);
-+
-+                      /* NB: ordering locking */
-+                      ext4_htree_spin_unlock_listen(lck, &myblock);
-+                      /* other thread can split this DE-block because:
-+                       * a) I don't have lock for the DE-block yet
-+                       * b) I released spinlock on DX-block
-+                       * if it happened I can detect it by listening
-+                       * splitting event on this DE-block */
-+                      ext4_htree_de_lock(lck, frame->at);
-+                      ext4_htree_spin_stop_listen(lck);
-+
-+                      if (myblock == EXT4_HTREE_NODE_CHANGED) {
-+                              /* someone split this DE-block before
-+                               * I locked it, I need to retry and lock
-+                               * valid DE-block */
-+                              ext4_htree_de_unlock(lck);
-+                              continue;
-+                      }
-+                      return frame;
-+              }
-+              dx = at;
-+              indirect--;
-               bh = ext4_read_dirblock(dir, dx_get_block(at), INDEX);
-               if (IS_ERR(bh)) {
-                       *err = PTR_ERR(bh);
-@@ -860,7 +1160,7 @@ static void dx_release (struct dx_frame
- static int ext4_htree_next_block(struct inode *dir, __u32 hash,
-                                struct dx_frame *frame,
-                                struct dx_frame *frames,
--                               __u32 *start_hash)
-+                               __u32 *start_hash, struct htree_lock *lck)
- {
-       struct dx_frame *p;
-       struct buffer_head *bh;
-@@ -875,12 +1175,22 @@ static int ext4_htree_next_block(struct
-        * this loop, num_frames indicates the number of interior
-        * nodes need to be read.
-        */
-+      ext4_htree_de_unlock(lck);
-       while (1) {
--              if (++(p->at) < p->entries + dx_get_count(p->entries))
--                      break;
-+              if (num_frames > 0 || ext4_htree_dx_locked(lck)) {
-+                      /* num_frames > 0 :
-+                       *   DX block
-+                       * ext4_htree_dx_locked:
-+                       *   frame->at is reliable pointer returned by dx_probe,
-+                       *   otherwise dx_probe already knew no collision */
-+                      if (++(p->at) < p->entries + dx_get_count(p->entries))
-+                              break;
-+              }
-               if (p == frames)
-                       return 0;
-               num_frames++;
-+              if (num_frames == 1)
-+                      ext4_htree_dx_unlock(lck);
-               p--;
-       }
-@@ -903,6 +1213,13 @@ static int ext4_htree_next_block(struct
-        * block so no check is necessary
-        */
-       while (num_frames--) {
-+              if (num_frames == 0) {
-+                      /* it's not always necessary, we just don't want to
-+                       * detect hash collision again */
-+                      ext4_htree_dx_need_lock(lck);
-+                      ext4_htree_dx_lock(lck, p->at);
-+              }
-+
-               bh = ext4_read_dirblock(dir, dx_get_block(p->at), INDEX);
-               if (IS_ERR(bh))
-                       return PTR_ERR(bh);
-@@ -911,6 +1228,7 @@ static int ext4_htree_next_block(struct
-               p->bh = bh;
-               p->at = p->entries = ((struct dx_node *) bh->b_data)->entries;
-       }
-+      ext4_htree_de_lock(lck, p->at);
-       return 1;
- }
-@@ -1013,10 +1331,10 @@ int ext4_htree_fill_tree(struct file *di
-       }
-       hinfo.hash = start_hash;
-       hinfo.minor_hash = 0;
--      frame = dx_probe(NULL, dir, &hinfo, frames, &err);
-+      /* assume it's PR locked */
-+      frame = dx_probe(NULL, dir, &hinfo, frames, NULL, &err);
-       if (!frame)
-               return err;
--
-       /* Add '.' and '..' from the htree header */
-       if (!start_hash && !start_minor_hash) {
-               de = (struct ext4_dir_entry_2 *) frames[0].bh->b_data;
-@@ -1043,7 +1361,7 @@ int ext4_htree_fill_tree(struct file *di
-               count += ret;
-               hashval = ~0;
-               ret = ext4_htree_next_block(dir, HASH_NB_ALWAYS,
--                                          frame, frames, &hashval);
-+                                          frame, frames, &hashval, NULL);
-               *next_hash = hashval;
-               if (ret < 0) {
-                       err = ret;
-@@ -1236,10 +1554,10 @@ static int is_dx_internal_node(struct in
-  * The returned buffer_head has ->b_count elevated.  The caller is expected
-  * to brelse() it when appropriate.
-  */
--static struct buffer_head * ext4_find_entry (struct inode *dir,
-+struct buffer_head *__ext4_find_entry(struct inode *dir,
-                                       const struct qstr *d_name,
-                                       struct ext4_dir_entry_2 **res_dir,
--                                      int *inlined)
-+                                      int *inlined, struct htree_lock *lck)
- {
-       struct super_block *sb;
-       struct buffer_head *bh_use[NAMEI_RA_SIZE];
-@@ -1283,7 +1601,7 @@ static struct buffer_head * ext4_find_en
-               goto restart;
-       }
-       if (is_dx(dir)) {
--              bh = ext4_dx_find_entry(dir, d_name, res_dir, &err);
-+              bh = ext4_dx_find_entry(dir, d_name, res_dir, lck, &err);
-               /*
-                * On success, or if the error was file not found,
-                * return.  Otherwise, fall back to doing a search the
-@@ -1297,6 +1615,7 @@ static struct buffer_head * ext4_find_en
-                       return bh;
-               dxtrace(printk(KERN_DEBUG "ext4_find_entry: dx failed, "
-                              "falling back\n"));
-+              ext4_htree_safe_relock(lck);
-       }
-       nblocks = dir->i_size >> EXT4_BLOCK_SIZE_BITS(sb);
-       start = EXT4_I(dir)->i_dir_start_lookup;
-@@ -1389,9 +1708,12 @@ cleanup_and_exit:
-               brelse(bh_use[ra_ptr]);
-       return ret;
- }
-+EXPORT_SYMBOL(__ext4_find_entry);
--static struct buffer_head * ext4_dx_find_entry(struct inode *dir, const struct qstr *d_name,
--                     struct ext4_dir_entry_2 **res_dir, int *err)
-+static struct buffer_head *ext4_dx_find_entry(struct inode *dir,
-+                              const struct qstr *d_name,
-+                              struct ext4_dir_entry_2 **res_dir,
-+                              struct htree_lock *lck, int *err)
- {
-       struct super_block * sb = dir->i_sb;
-       struct dx_hash_info     hinfo;
-@@ -1400,7 +1722,7 @@ static struct buffer_head * ext4_dx_find
-       ext4_lblk_t block;
-       int retval;
--      if (!(frame = dx_probe(d_name, dir, &hinfo, frames, err)))
-+      if (!(frame = dx_probe(d_name, dir, &hinfo, frames, lck, err)))
-               return NULL;
-       do {
-               block = dx_get_block(frame->at);
-@@ -1424,7 +1746,7 @@ static struct buffer_head * ext4_dx_find
-               /* Check to see if we should continue to search */
-               retval = ext4_htree_next_block(dir, hinfo.hash, frame,
--                                             frames, NULL);
-+                                             frames, NULL, lck);
-               if (retval < 0) {
-                       ext4_warning(sb,
-                            "error reading index page in directory #%lu",
-@@ -1583,8 +1905,9 @@ static struct ext4_dir_entry_2* dx_pack_
-  * Returns pointer to de in block into which the new entry will be inserted.
-  */
- static struct ext4_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
--                      struct buffer_head **bh,struct dx_frame *frame,
--                      struct dx_hash_info *hinfo, int *error)
-+                      struct buffer_head **bh, struct dx_frame *frames,
-+                      struct dx_frame *frame, struct dx_hash_info *hinfo,
-+                      struct htree_lock *lck, int *error)
- {
-       unsigned blocksize = dir->i_sb->s_blocksize;
-       unsigned count, continued;
-@@ -1647,7 +1970,14 @@ static struct ext4_dir_entry_2 *do_split
-                                       hash2, split, count-split));
-       /* Fancy dance to stay within two buffers */
--      de2 = dx_move_dirents(data1, data2, map + split, count - split, blocksize);
-+      if (hinfo->hash < hash2) {
-+              de2 = dx_move_dirents(data1, data2, map + split,
-+                                    count - split, blocksize);
-+      } else {
-+              /* make sure we will add entry to the same block which
-+               * we have already locked */
-+              de2 = dx_move_dirents(data1, data2, map, split, blocksize);
-+      }
-       de = dx_pack_dirents(data1, blocksize);
-       de->rec_len = ext4_rec_len_to_disk(data1 + (blocksize - csum_size) -
-                                          (char *) de,
-@@ -1666,13 +1996,21 @@ static struct ext4_dir_entry_2 *do_split
-       dxtrace(dx_show_leaf (hinfo, (struct ext4_dir_entry_2 *) data1, blocksize, 1));
-       dxtrace(dx_show_leaf (hinfo, (struct ext4_dir_entry_2 *) data2, blocksize, 1));
--      /* Which block gets the new entry? */
--      if (hinfo->hash >= hash2)
--      {
--              swap(*bh, bh2);
--              de = de2;
-+      ext4_htree_spin_lock(lck, frame > frames ? (frame - 1)->at : NULL,
-+                           frame->at); /* notify block is being split */
-+      if (hinfo->hash < hash2) {
-+              dx_insert_block(frame, hash2 + continued, newblock);
-+
-+      } else {
-+              /* switch block number */
-+              dx_insert_block(frame, hash2 + continued,
-+                              dx_get_block(frame->at));
-+              dx_set_block(frame->at, newblock);
-+              (frame->at)++;
-       }
--      dx_insert_block(frame, hash2 + continued, newblock);
-+      ext4_htree_spin_unlock(lck);
-+      ext4_htree_dx_unlock(lck);
-+
-       err = ext4_handle_dirty_dirent_node(handle, dir, bh2);
-       if (err)
-               goto journal_error;
-@@ -1945,7 +2283,7 @@ static int make_indexed_dir(handle_t *ha
-       ext4_handle_dirty_dx_node(handle, dir, frame->bh);
-       ext4_handle_dirty_dirent_node(handle, dir, bh);
--      de = do_split(handle,dir, &bh, frame, &hinfo, &retval);
-+      de = do_split(handle, dir, &bh, frames, frame, &hinfo, NULL, &retval);
-       if (!de) {
-               /*
-                * Even if the block split failed, we have to properly write
-@@ -2051,8 +2389,8 @@ out:
-  * may not sleep between calling this and putting something into
-  * the entry, as someone else might have used it while you slept.
-  */
--static int ext4_add_entry(handle_t *handle, struct dentry *dentry,
--                        struct inode *inode)
-+int __ext4_add_entry(handle_t *handle, struct dentry *dentry,
-+                    struct inode *inode, struct htree_lock *lck)
- {
-       struct inode *dir = dentry->d_parent->d_inode;
-       struct buffer_head *bh = NULL;
-@@ -2087,9 +2425,10 @@ static int ext4_add_entry(handle_t *hand
-               if (dentry->d_name.len == 2 &&
-                   memcmp(dentry->d_name.name, "..", 2) == 0)
-                       return ext4_update_dotdot(handle, dentry, inode);
--              retval = ext4_dx_add_entry(handle, dentry, inode);
-+              retval = ext4_dx_add_entry(handle, dentry, inode, lck);
-               if (!retval || (retval != ERR_BAD_DX_DIR))
-                       goto out;
-+              ext4_htree_safe_relock(lck);
-               ext4_clear_inode_flag(dir, EXT4_INODE_INDEX);
-               dx_fallback++;
-               ext4_mark_inode_dirty(handle, dir);
-@@ -2129,12 +2468,13 @@ static int ext4_add_entry(handle_t *hand
-               ext4_set_inode_state(inode, EXT4_STATE_NEWENTRY);
-       return retval;
- }
-+EXPORT_SYMBOL(__ext4_add_entry);
- /*
-  * Returns 0 for success, or a negative error value
-  */
- static int ext4_dx_add_entry(handle_t *handle, struct dentry *dentry,
--                           struct inode *inode)
-+                           struct inode *inode, struct htree_lock *lck)
- {
-       struct dx_frame frames[EXT4_HTREE_LEVEL], *frame;
-       struct dx_entry *entries, *at;
-@@ -2148,7 +2488,7 @@ static int ext4_dx_add_entry(handle_t *h
- again:
-       restart = 0;
--      frame = dx_probe(&dentry->d_name, dir, &hinfo, frames, &err);
-+      frame = dx_probe(&dentry->d_name, dir, &hinfo, frames, lck, &err);
-       if (!frame)
-               return err;
-       entries = frame->entries;
-@@ -2178,6 +2518,11 @@ again:
-               struct dx_node *node2;
-               struct buffer_head *bh2;
-+              if (!ext4_htree_safe_locked(lck)) { /* retry with EX lock */
-+                      ext4_htree_safe_relock(lck);
-+                      restart = 1;
-+                      goto cleanup;
-+              }
-               while (frame > frames) {
-                       if (dx_get_count((frame - 1)->entries) <
-                           dx_get_limit((frame - 1)->entries)) {
-@@ -2277,16 +2622,43 @@ again:
-                       restart = 1;
-                       goto journal_error;
-               }
-+      } else if (!ext4_htree_dx_locked(lck)) {
-+              struct ext4_dir_lock_data *ld = ext4_htree_lock_data(lck);
-+
-+              /* not well protected, require DX lock */
-+              ext4_htree_dx_need_lock(lck);
-+              at = frame > frames ? (frame - 1)->at : NULL;
-+
-+              /* NB: no risk of deadlock because it's just a try.
-+               *
-+               * NB: we check ld_count for twice, the first time before
-+               * having DX lock, the second time after holding DX lock.
-+               *
-+               * NB: We never free blocks for directory so far, which
-+               * means value returned by dx_get_count() should equal to
-+               * ld->ld_count if nobody split any DE-block under @at,
-+               * and ld->ld_at still points to valid dx_entry. */
-+              if ((ld->ld_count != dx_get_count(entries)) ||
-+                  !ext4_htree_dx_lock_try(lck, at) ||
-+                  (ld->ld_count != dx_get_count(entries))) {
-+                      restart = 1;
-+                      goto cleanup;
-+              }
-+              /* OK, I've got DX lock and nothing changed */
-+              frame->at = ld->ld_at;
-       }
--      de = do_split(handle, dir, &bh, frame, &hinfo, &err);
-+      de = do_split(handle, dir, &bh, frames, frame, &hinfo, lck, &err);
-       if (!de)
-               goto cleanup;
-+
-       err = add_dirent_to_buf(handle, dentry, inode, de, bh);
-       goto cleanup;
- journal_error:
-       ext4_std_error(dir->i_sb, err); /* this is a no-op if err == 0 */
- cleanup:
-+      ext4_htree_dx_unlock(lck);
-+      ext4_htree_de_unlock(lck);
-       brelse(bh);
-       dx_release(frames);
-       /* @restart is true means htree-path has been changed, we need to
-Index: linux-3.10.0-229.1.2.fc21.x86_64/fs/ext4/super.c
-===================================================================
---- linux-3.10.0-229.1.2.fc21.x86_64.orig/fs/ext4/super.c
-+++ linux-3.10.0-229.1.2.fc21.x86_64/fs/ext4/super.c
-@@ -875,6 +875,7 @@ static struct inode *ext4_alloc_inode(st
-       ei->vfs_inode.i_version = 1;
-       spin_lock_init(&ei->i_raw_lock);
-+      sema_init(&ei->i_append_sem, 1);
-       INIT_LIST_HEAD(&ei->i_prealloc_list);
-       spin_lock_init(&ei->i_prealloc_lock);
-       ext4_es_init_tree(&ei->i_es_tree);
diff --git a/ldiskfs/kernel_patches/patches/rhel7.2/ext4-release-bh-in-makeinxdir.patch b/ldiskfs/kernel_patches/patches/rhel7.2/ext4-release-bh-in-makeinxdir.patch
deleted file mode 100644 (file)
index ef4d54a..0000000
+++ /dev/null
@@ -1,10 +0,0 @@
---- linux-1/fs/ext4/namei.c    2016-09-27 02:16:31.020890438 +0800
-+++ linux-2/fs/ext4/namei.c    2016-09-27 02:17:14.246620470 +0800
-@@ -1874,6 +1874,7 @@ out_frames:
-        */
-       ext4_mark_inode_dirty(handle, dir);
-       dx_release(frames);
-+      brelse(bh);
-       return retval;
- }
diff --git a/ldiskfs/kernel_patches/patches/rhel7.2/ext4-remove-i_data_sem-from-xattr.patch b/ldiskfs/kernel_patches/patches/rhel7.2/ext4-remove-i_data_sem-from-xattr.patch
deleted file mode 100644 (file)
index fa5ace5..0000000
+++ /dev/null
@@ -1,475 +0,0 @@
-From a521100231f816f8cdd9c8e77da14ff1e42c2b17 Mon Sep 17 00:00:00 2001
-From: Theodore Ts'o <tytso@mit.edu>
-Date: Thu, 4 Sep 2014 18:06:25 -0400
-Subject: [PATCH] ext4: pass allocation_request struct to
- ext4_(alloc,splice)_branch
-
-Instead of initializing the allocation_request structure in
-ext4_alloc_branch(), set it up in ext4_ind_map_blocks(), and then pass
-it to ext4_alloc_branch() and ext4_splice_branch().
-
-This allows ext4_ind_map_blocks to pass flags in the allocation
-request structure without having to add Yet Another argument to
-ext4_alloc_branch().
-
-Signed-off-by: Theodore Ts'o <tytso@mit.edu>
-Reviewed-by: Jan Kara <jack@suse.cz>
----
- fs/ext4/indirect.c | 82 +++++++++++++++++++++++++-----------------------------
- 1 file changed, 38 insertions(+), 44 deletions(-)
-
-diff --git a/fs/ext4/indirect.c b/fs/ext4/indirect.c
-index e75f840..69af0cd 100644
---- a/fs/ext4/indirect.c
-+++ b/fs/ext4/indirect.c
-@@ -318,34 +318,22 @@ static int ext4_blks_to_allocate(Indirect *branch, int k, unsigned int blks,
-  *    ext4_alloc_block() (normally -ENOSPC). Otherwise we set the chain
-  *    as described above and return 0.
-  */
--static int ext4_alloc_branch(handle_t *handle, struct inode *inode,
--                           ext4_lblk_t iblock, int indirect_blks,
--                           int *blks, ext4_fsblk_t goal,
--                           ext4_lblk_t *offsets, Indirect *branch)
-+static int ext4_alloc_branch(handle_t *handle,
-+                           struct ext4_allocation_request *ar,
-+                           int indirect_blks, ext4_lblk_t *offsets,
-+                           Indirect *branch)
- {
--      struct ext4_allocation_request  ar;
-       struct buffer_head *            bh;
-       ext4_fsblk_t                    b, new_blocks[4];
-       __le32                          *p;
-       int                             i, j, err, len = 1;
--      /*
--       * Set up for the direct block allocation
--       */
--      memset(&ar, 0, sizeof(ar));
--      ar.inode = inode;
--      ar.len = *blks;
--      ar.logical = iblock;
--      if (S_ISREG(inode->i_mode))
--              ar.flags = EXT4_MB_HINT_DATA;
--
-       for (i = 0; i <= indirect_blks; i++) {
-               if (i == indirect_blks) {
--                      ar.goal = goal;
--                      new_blocks[i] = ext4_mb_new_blocks(handle, &ar, &err);
-+                      new_blocks[i] = ext4_mb_new_blocks(handle, ar, &err);
-               } else
--                      goal = new_blocks[i] = ext4_new_meta_blocks(handle, inode,
--                                                      goal, 0, NULL, &err);
-+                      ar->goal = new_blocks[i] = ext4_new_meta_blocks(handle,
-+                                  ar->inode, ar->goal, 0, NULL, &err);
-               if (err) {
-                       i--;
-                       goto failed;
-@@ -354,7 +342,7 @@ static int ext4_alloc_branch(handle_t *handle, struct inode *inode,
-               if (i == 0)
-                       continue;
--              bh = branch[i].bh = sb_getblk(inode->i_sb, new_blocks[i-1]);
-+              bh = branch[i].bh = sb_getblk(ar->inode->i_sb, new_blocks[i-1]);
-               if (unlikely(!bh)) {
-                       err = -ENOMEM;
-                       goto failed;
-@@ -372,7 +360,7 @@ static int ext4_alloc_branch(handle_t *handle, struct inode *inode,
-               b = new_blocks[i];
-               if (i == indirect_blks)
--                      len = ar.len;
-+                      len = ar->len;
-               for (j = 0; j < len; j++)
-                       *p++ = cpu_to_le32(b++);
-@@ -381,11 +369,10 @@ static int ext4_alloc_branch(handle_t *handle, struct inode *inode,
-               unlock_buffer(bh);
-               BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
--              err = ext4_handle_dirty_metadata(handle, inode, bh);
-+              err = ext4_handle_dirty_metadata(handle, ar->inode, bh);
-               if (err)
-                       goto failed;
-       }
--      *blks = ar.len;
-       return 0;
- failed:
-       for (; i >= 0; i--) {
-@@ -396,10 +383,10 @@ static int ext4_alloc_branch(handle_t *handle, struct inode *inode,
-                * existing before ext4_alloc_branch() was called.
-                */
-               if (i > 0 && i != indirect_blks && branch[i].bh)
--                      ext4_forget(handle, 1, inode, branch[i].bh,
-+                      ext4_forget(handle, 1, ar->inode, branch[i].bh,
-                                   branch[i].bh->b_blocknr);
--              ext4_free_blocks(handle, inode, NULL, new_blocks[i],
--                               (i == indirect_blks) ? ar.len : 1, 0);
-+              ext4_free_blocks(handle, ar->inode, NULL, new_blocks[i],
-+                               (i == indirect_blks) ? ar->len : 1, 0);
-       }
-       return err;
- }
-@@ -419,9 +406,9 @@ static int ext4_alloc_branch(handle_t *handle, struct inode *inode,
-  * inode (->i_blocks, etc.). In case of success we end up with the full
-  * chain to new block and return 0.
-  */
--static int ext4_splice_branch(handle_t *handle, struct inode *inode,
--                            ext4_lblk_t block, Indirect *where, int num,
--                            int blks)
-+static int ext4_splice_branch(handle_t *handle,
-+                            struct ext4_allocation_request *ar,
-+                            Indirect *where, int num)
- {
-       int i;
-       int err = 0;
-@@ -446,9 +433,9 @@ static int ext4_splice_branch(handle_t *handle, struct inode *inode,
-        * Update the host buffer_head or inode to point to more just allocated
-        * direct blocks blocks
-        */
--      if (num == 0 && blks > 1) {
-+      if (num == 0 && ar->len > 1) {
-               current_block = le32_to_cpu(where->key) + 1;
--              for (i = 1; i < blks; i++)
-+              for (i = 1; i < ar->len; i++)
-                       *(where->p + i) = cpu_to_le32(current_block++);
-       }
-@@ -465,14 +452,14 @@ static int ext4_splice_branch(handle_t *handle, struct inode *inode,
-                */
-               jbd_debug(5, "splicing indirect only\n");
-               BUFFER_TRACE(where->bh, "call ext4_handle_dirty_metadata");
--              err = ext4_handle_dirty_metadata(handle, inode, where->bh);
-+              err = ext4_handle_dirty_metadata(handle, ar->inode, where->bh);
-               if (err)
-                       goto err_out;
-       } else {
-               /*
-                * OK, we spliced it into the inode itself on a direct block.
-                */
--              ext4_mark_inode_dirty(handle, inode);
-+              ext4_mark_inode_dirty(handle, ar->inode);
-               jbd_debug(5, "splicing direct\n");
-       }
-       return err;
-@@ -484,11 +471,11 @@ static int ext4_splice_branch(handle_t *handle, struct inode *inode,
-                * need to revoke the block, which is why we don't
-                * need to set EXT4_FREE_BLOCKS_METADATA.
-                */
--              ext4_free_blocks(handle, inode, where[i].bh, 0, 1,
-+              ext4_free_blocks(handle, ar->inode, where[i].bh, 0, 1,
-                                EXT4_FREE_BLOCKS_FORGET);
-       }
--      ext4_free_blocks(handle, inode, NULL, le32_to_cpu(where[num].key),
--                       blks, 0);
-+      ext4_free_blocks(handle, ar->inode, NULL, le32_to_cpu(where[num].key),
-+                       ar->len, 0);
-       return err;
- }
-@@ -525,11 +512,11 @@ int ext4_ind_map_blocks(handle_t *handle, struct inode *inode,
-                       struct ext4_map_blocks *map,
-                       int flags)
- {
-+      struct ext4_allocation_request ar;
-       int err = -EIO;
-       ext4_lblk_t offsets[4];
-       Indirect chain[4];
-       Indirect *partial;
--      ext4_fsblk_t goal;
-       int indirect_blks;
-       int blocks_to_boundary = 0;
-       int depth;
-@@ -579,7 +566,14 @@ int ext4_ind_map_blocks(handle_t *handle, struct inode *inode,
-               return -ENOSPC;
-       }
--      goal = ext4_find_goal(inode, map->m_lblk, partial);
-+      /* Set up for the direct block allocation */
-+      memset(&ar, 0, sizeof(ar));
-+      ar.inode = inode;
-+      ar.logical = map->m_lblk;
-+      if (S_ISREG(inode->i_mode))
-+              ar.flags = EXT4_MB_HINT_DATA;
-+
-+      ar.goal = ext4_find_goal(inode, map->m_lblk, partial);
-       /* the number of blocks need to allocate for [d,t]indirect blocks */
-       indirect_blks = (chain + depth) - partial - 1;
-@@ -588,13 +582,13 @@ int ext4_ind_map_blocks(handle_t *handle, struct inode *inode,
-        * Next look up the indirect map to count the totoal number of
-        * direct blocks to allocate for this branch.
-        */
--      count = ext4_blks_to_allocate(partial, indirect_blks,
--                                    map->m_len, blocks_to_boundary);
-+      ar.len = ext4_blks_to_allocate(partial, indirect_blks,
-+                                     map->m_len, blocks_to_boundary);
-+
-       /*
-        * Block out ext4_truncate while we alter the tree
-        */
--      err = ext4_alloc_branch(handle, inode, map->m_lblk, indirect_blks,
--                              &count, goal,
-+      err = ext4_alloc_branch(handle, &ar, indirect_blks,
-                               offsets + (partial - chain), partial);
-       /*
-@@ -605,14 +599,14 @@ int ext4_ind_map_blocks(handle_t *handle, struct inode *inode,
-        * may need to return -EAGAIN upwards in the worst case.  --sct
-        */
-       if (!err)
--              err = ext4_splice_branch(handle, inode, map->m_lblk,
--                                       partial, indirect_blks, count);
-+              err = ext4_splice_branch(handle, &ar, partial, indirect_blks);
-       if (err)
-               goto cleanup;
-       map->m_flags |= EXT4_MAP_NEW;
-       ext4_update_inode_fsync_trans(handle, inode, 1);
-+      count = ar.len;
- got_it:
-       map->m_flags |= EXT4_MAP_MAPPED;
-       map->m_pblk = le32_to_cpu(chain[depth-1].key);
--- 
-2.7.4
-
-From e3cf5d5d9a86df1c5e413bdd3725c25a16ff854c Mon Sep 17 00:00:00 2001
-From: Theodore Ts'o <tytso@mit.edu>
-Date: Thu, 4 Sep 2014 18:07:25 -0400
-Subject: [PATCH] ext4: prepare to drop EXT4_STATE_DELALLOC_RESERVED
-
-The EXT4_STATE_DELALLOC_RESERVED flag was originally implemented
-because it was too hard to make sure the mballoc and get_block flags
-could be reliably passed down through all of the codepaths that end up
-calling ext4_mb_new_blocks().
-
-Since then, we have mb_flags passed down through most of the code
-paths, so getting rid of EXT4_STATE_DELALLOC_RESERVED isn't as tricky
-as it used to.
-
-This commit plumbs in the last of what is required, and then adds a
-WARN_ON check to make sure we haven't missed anything.  If this passes
-a full regression test run, we can then drop
-EXT4_STATE_DELALLOC_RESERVED.
-
-Signed-off-by: Theodore Ts'o <tytso@mit.edu>
-Reviewed-by: Jan Kara <jack@suse.cz>
----
- fs/ext4/balloc.c   |  3 +--
- fs/ext4/extents.c  |  6 +++++-
- fs/ext4/indirect.c |  6 +++++-
- fs/ext4/mballoc.c  | 10 ++++++----
- fs/ext4/xattr.c    |  6 ------
- 5 files changed, 17 insertions(+), 14 deletions(-)
-
-diff --git a/fs/ext4/balloc.c b/fs/ext4/balloc.c
-index 581ef40..d70f154 100644
---- a/fs/ext4/balloc.c
-+++ b/fs/ext4/balloc.c
-@@ -636,8 +636,7 @@ ext4_fsblk_t ext4_new_meta_blocks(handle_t *handle, struct inode *inode,
-        * Account for the allocated meta blocks.  We will never
-        * fail EDQUOT for metdata, but we do account for it.
-        */
--      if (!(*errp) &&
--          ext4_test_inode_state(inode, EXT4_STATE_DELALLOC_RESERVED)) {
-+      if (!(*errp) && (flags & EXT4_MB_DELALLOC_RESERVED)) {
-               dquot_alloc_block_nofail(inode,
-                               EXT4_C2B(EXT4_SB(inode->i_sb), ar.len));
-       }
-diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
-index 3ac1686..8170b32 100644
---- a/fs/ext4/extents.c
-+++ b/fs/ext4/extents.c
-@@ -1933,6 +1933,8 @@ int ext4_ext_insert_extent(handle_t *handle, struct inode *inode,
-       ext4_lblk_t next;
-       int mb_flags = 0, unwritten;
-+      if (gb_flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE)
-+              mb_flags |= EXT4_MB_DELALLOC_RESERVED;
-       if (unlikely(ext4_ext_get_actual_len(newext) == 0)) {
-               EXT4_ERROR_INODE(inode, "ext4_ext_get_actual_len(newext) == 0");
-               return -EIO;
-@@ -2054,7 +2056,7 @@ int ext4_ext_insert_extent(handle_t *handle, struct inode *inode,
-        * We're gonna add a new leaf in the tree.
-        */
-       if (gb_flags & EXT4_GET_BLOCKS_METADATA_NOFAIL)
--              mb_flags = EXT4_MB_USE_RESERVED;
-+              mb_flags |= EXT4_MB_USE_RESERVED;
-       err = ext4_ext_create_new_leaf(handle, inode, mb_flags, gb_flags,
-                                      ppath, newext);
-       if (err)
-@@ -4438,6 +4440,8 @@ int ext4_ext_map_blocks(handle_t *handle, struct inode *inode,
-               ar.flags = 0;
-       if (flags & EXT4_GET_BLOCKS_NO_NORMALIZE)
-               ar.flags |= EXT4_MB_HINT_NOPREALLOC;
-+      if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE)
-+              ar.flags |= EXT4_MB_DELALLOC_RESERVED;
-       newblock = ext4_mb_new_blocks(handle, &ar, &err);
-       if (!newblock)
-               goto out2;
-diff --git a/fs/ext4/indirect.c b/fs/ext4/indirect.c
-index 69af0cd..36b3696 100644
---- a/fs/ext4/indirect.c
-+++ b/fs/ext4/indirect.c
-@@ -333,7 +333,9 @@ static int ext4_alloc_branch(handle_t *handle,
-                       new_blocks[i] = ext4_mb_new_blocks(handle, ar, &err);
-               } else
-                       ar->goal = new_blocks[i] = ext4_new_meta_blocks(handle,
--                                  ar->inode, ar->goal, 0, NULL, &err);
-+                                      ar->inode, ar->goal,
-+                                      ar->flags & EXT4_MB_DELALLOC_RESERVED,
-+                                      NULL, &err);
-               if (err) {
-                       i--;
-                       goto failed;
-@@ -572,6 +574,8 @@ int ext4_ind_map_blocks(handle_t *handle, struct inode *inode,
-       ar.logical = map->m_lblk;
-       if (S_ISREG(inode->i_mode))
-               ar.flags = EXT4_MB_HINT_DATA;
-+      if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE)
-+              ar.flags |= EXT4_MB_DELALLOC_RESERVED;
-       ar.goal = ext4_find_goal(inode, map->m_lblk, partial);
-diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
-index 8b0f9ef..15dffda 100644
---- a/fs/ext4/mballoc.c
-+++ b/fs/ext4/mballoc.c
-@@ -4415,9 +4415,12 @@ ext4_fsblk_t ext4_mb_new_blocks(handle_t *handle,
-        * EDQUOT check, as blocks and quotas have been already
-        * reserved when data being copied into pagecache.
-        */
--      if (ext4_test_inode_state(ar->inode, EXT4_STATE_DELALLOC_RESERVED))
-+      if (ext4_test_inode_state(ar->inode, EXT4_STATE_DELALLOC_RESERVED)) {
-+              WARN_ON((ar->flags & EXT4_MB_DELALLOC_RESERVED) == 0);
-               ar->flags |= EXT4_MB_DELALLOC_RESERVED;
--      else {
-+      }
-+
-+      if ((ar->flags & EXT4_MB_DELALLOC_RESERVED) == 0) {
-               /* Without delayed allocation we need to verify
-                * there is enough free blocks to do block allocation
-                * and verify allocation doesn't exceed the quota limits.
-@@ -4528,8 +4531,7 @@ ext4_fsblk_t ext4_mb_new_blocks(handle_t *handle,
-       if (inquota && ar->len < inquota)
-               dquot_free_block(ar->inode, EXT4_C2B(sbi, inquota - ar->len));
-       if (!ar->len) {
--              if (!ext4_test_inode_state(ar->inode,
--                                         EXT4_STATE_DELALLOC_RESERVED))
-+              if ((ar->flags & EXT4_MB_DELALLOC_RESERVED) == 0)
-                       /* release all the reserved blocks if non delalloc */
-                       percpu_counter_sub(&sbi->s_dirtyclusters_counter,
-                                               reserv_clstrs);
-diff --git a/fs/ext4/xattr.c b/fs/ext4/xattr.c
-index e738733..da4df70 100644
---- a/fs/ext4/xattr.c
-+++ b/fs/ext4/xattr.c
-@@ -899,14 +899,8 @@ ext4_xattr_block_set(handle_t *handle, struct inode *inode,
-                       if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
-                               goal = goal & EXT4_MAX_BLOCK_FILE_PHYS;
--                      /*
--                       * take i_data_sem because we will test
--                       * i_delalloc_reserved_flag in ext4_mb_new_blocks
--                       */
--                      down_read(&EXT4_I(inode)->i_data_sem);
-                       block = ext4_new_meta_blocks(handle, inode, goal, 0,
-                                                    NULL, &error);
--                      up_read((&EXT4_I(inode)->i_data_sem));
-                       if (error)
-                               goto cleanup;
--- 
-2.7.4
-
-From 2e81a4eeedcaa66e35f58b81e0755b87057ce392 Mon Sep 17 00:00:00 2001
-From: Jan Kara <jack@suse.cz>
-Date: Thu, 11 Aug 2016 12:38:55 -0400
-Subject: [PATCH] ext4: avoid deadlock when expanding inode size
-
-When we need to move xattrs into external xattr block, we call
-ext4_xattr_block_set() from ext4_expand_extra_isize_ea(). That may end
-up calling ext4_mark_inode_dirty() again which will recurse back into
-the inode expansion code leading to deadlocks.
-
-Protect from recursion using EXT4_STATE_NO_EXPAND inode flag and move
-its management into ext4_expand_extra_isize_ea() since its manipulation
-is safe there (due to xattr_sem) from possible races with
-ext4_xattr_set_handle() which plays with it as well.
-
-CC: stable@vger.kernel.org   # 4.4.x
-Signed-off-by: Jan Kara <jack@suse.cz>
-Signed-off-by: Theodore Ts'o <tytso@mit.edu>
----
- fs/ext4/inode.c |  2 --
- fs/ext4/xattr.c | 19 +++++++++++++------
- 2 files changed, 13 insertions(+), 8 deletions(-)
-
-diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
-index 5a6277d..13c95b2 100644
---- a/fs/ext4/inode.c
-+++ b/fs/ext4/inode.c
-@@ -5466,8 +5466,6 @@ int ext4_mark_inode_dirty(handle_t *handle, struct inode *inode)
-                                                     sbi->s_want_extra_isize,
-                                                     iloc, handle);
-                       if (ret) {
--                              ext4_set_inode_state(inode,
--                                                   EXT4_STATE_NO_EXPAND);
-                               if (mnt_count !=
-                                       le16_to_cpu(sbi->s_es->s_mnt_count)) {
-                                       ext4_warning(inode->i_sb,
-diff --git a/fs/ext4/xattr.c b/fs/ext4/xattr.c
-index c893f00..2eb935c 100644
---- a/fs/ext4/xattr.c
-+++ b/fs/ext4/xattr.c
-@@ -1358,11 +1358,13 @@ int ext4_expand_extra_isize_ea(struct inode *inode, int new_extra_isize,
-       int isize_diff; /* How much do we need to grow i_extra_isize */
-       down_write(&EXT4_I(inode)->xattr_sem);
-+      /*
-+       * Set EXT4_STATE_NO_EXPAND to avoid recursion when marking inode dirty
-+       */
-+      ext4_set_inode_state(inode, EXT4_STATE_NO_EXPAND);
- retry:
--      if (EXT4_I(inode)->i_extra_isize >= new_extra_isize) {
--              up_write(&EXT4_I(inode)->xattr_sem);
--              return 0;
--      }
-+      if (EXT4_I(inode)->i_extra_isize >= new_extra_isize)
-+              goto out;
-       header = IHDR(inode, raw_inode);
-       entry = IFIRST(header);
-@@ -1392,8 +1394,7 @@ int ext4_expand_extra_isize_ea(struct inode *inode, int new_extra_isize,
-                               (void *)header, total_ino,
-                               inode->i_sb->s_blocksize);
-               EXT4_I(inode)->i_extra_isize = new_extra_isize;
--              error = 0;
--              goto cleanup;
-+              goto out;
-       }
-       /*
-@@ -1553,6 +1554,8 @@ int ext4_expand_extra_isize_ea(struct inode *inode, int new_extra_isize,
-               kfree(bs);
-       }
-       brelse(bh);
-+out:
-+      ext4_clear_inode_state(inode, EXT4_STATE_NO_EXPAND);
-       up_write(&EXT4_I(inode)->xattr_sem);
-       return 0;
-@@ -1564,6 +1567,10 @@ int ext4_expand_extra_isize_ea(struct inode *inode, int new_extra_isize,
-       kfree(is);
-       kfree(bs);
-       brelse(bh);
-+      /*
-+       * We deliberately leave EXT4_STATE_NO_EXPAND set here since inode
-+       * size expansion failed.
-+       */
-       up_write(&EXT4_I(inode)->xattr_sem);
-       return error;
- }
--- 
-2.7.4
-
diff --git a/ldiskfs/kernel_patches/patches/rhel7.3/ext4-corrupted-inode-block-bitmaps-handling-patches.patch b/ldiskfs/kernel_patches/patches/rhel7.3/ext4-corrupted-inode-block-bitmaps-handling-patches.patch
deleted file mode 100644 (file)
index 60f63c5..0000000
+++ /dev/null
@@ -1,464 +0,0 @@
-Since we could skip corrupt block groups, this patch
-use ext4_warning() intead of ext4_error() to make FS not
-emount RO in default, also fix a leftover from upstream
-commit 163a203ddb36c36d4a1c942
----
-Index: linux-stage/fs/ext4/balloc.c
-===================================================================
---- linux-stage.orig/fs/ext4/balloc.c
-+++ linux-stage/fs/ext4/balloc.c
-@@ -185,25 +185,17 @@ static int ext4_init_block_bitmap(struct
-       struct ext4_sb_info *sbi = EXT4_SB(sb);
-       ext4_fsblk_t start, tmp;
-       int flex_bg = 0;
--      struct ext4_group_info *grp;
-       J_ASSERT_BH(bh, buffer_locked(bh));
-       /* If checksum is bad mark all blocks used to prevent allocation
-        * essentially implementing a per-group read-only flag. */
-       if (!ext4_group_desc_csum_verify(sb, block_group, gdp)) {
--              grp = ext4_get_group_info(sb, block_group);
--              if (!EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
--                      percpu_counter_sub(&sbi->s_freeclusters_counter,
--                                         grp->bb_free);
--              set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state);
--              if (!EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) {
--                      int count;
--                      count = ext4_free_inodes_count(sb, gdp);
--                      percpu_counter_sub(&sbi->s_freeinodes_counter,
--                                         count);
--              }
--              set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &grp->bb_state);
-+              ext4_corrupted_block_group(sb, block_group,
-+                              EXT4_GROUP_INFO_BBITMAP_CORRUPT |
-+                              EXT4_GROUP_INFO_IBITMAP_CORRUPT,
-+                              "Checksum bad for group %u",
-+                              block_group);
-               return -EIO;
-       }
-       memset(bh->b_data, 0, sb->s_blocksize);
-@@ -368,7 +360,6 @@ static void ext4_validate_block_bitmap(s
- {
-       ext4_fsblk_t    blk;
-       struct ext4_group_info *grp = ext4_get_group_info(sb, block_group);
--      struct ext4_sb_info *sbi = EXT4_SB(sb);
-       if (buffer_verified(bh) || EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
-               return;
-@@ -377,22 +368,19 @@ static void ext4_validate_block_bitmap(s
-       blk = ext4_valid_block_bitmap(sb, desc, block_group, bh);
-       if (unlikely(blk != 0)) {
-               ext4_unlock_group(sb, block_group);
--              ext4_error(sb, "bg %u: block %llu: invalid block bitmap",
--                         block_group, blk);
--              if (!EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
--                      percpu_counter_sub(&sbi->s_freeclusters_counter,
--                                         grp->bb_free);
--              set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state);
-+              ext4_corrupted_block_group(sb, block_group,
-+                              EXT4_GROUP_INFO_BBITMAP_CORRUPT,
-+                              "bg %u: block %llu: invalid block bitmap",
-+                              block_group, blk);
-               return;
-       }
-       if (unlikely(!ext4_block_bitmap_csum_verify(sb, block_group,
-                       desc, bh))) {
-               ext4_unlock_group(sb, block_group);
--              ext4_error(sb, "bg %u: bad block bitmap checksum", block_group);
--              if (!EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
--                      percpu_counter_sub(&sbi->s_freeclusters_counter,
--                                         grp->bb_free);
--              set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state);
-+              ext4_corrupted_block_group(sb, block_group,
-+                              EXT4_GROUP_INFO_BBITMAP_CORRUPT,
-+                              "bg %u: bad block bitmap checksum",
-+                              block_group);
-               return;
-       }
-       set_buffer_verified(bh);
-@@ -445,8 +433,6 @@ ext4_read_block_bitmap_nowait(struct sup
-               set_buffer_uptodate(bh);
-               ext4_unlock_group(sb, block_group);
-               unlock_buffer(bh);
--              if (err)
--                      ext4_error(sb, "Checksum bad for grp %u", block_group);
-               goto verify;
-       }
-       ext4_unlock_group(sb, block_group);
-Index: linux-stage/fs/ext4/ext4.h
-===================================================================
---- linux-stage.orig/fs/ext4/ext4.h
-+++ linux-stage/fs/ext4/ext4.h
-@@ -91,6 +91,17 @@ typedef __u32 ext4_lblk_t;
- /* data type for block group number */
- typedef unsigned int ext4_group_t;
-+void __ext4_corrupted_block_group(struct super_block *sb,
-+                                ext4_group_t group, unsigned int flags,
-+                                const char *function, unsigned int line);
-+
-+#define ext4_corrupted_block_group(sb, group, flags, fmt, ...)                \
-+      do {                                                            \
-+              __ext4_warning(sb, __func__, __LINE__, fmt,             \
-+                              ##__VA_ARGS__);                         \
-+              __ext4_corrupted_block_group(sb, group, flags,          \
-+                                      __func__, __LINE__);            \
-+      } while (0)
- /*
-  * Flags used in mballoc's allocation_context flags field.
-  *
-@@ -2676,7 +2687,11 @@ struct ext4_group_info {
- #define EXT4_GROUP_INFO_NEED_INIT_BIT         0
- #define EXT4_GROUP_INFO_WAS_TRIMMED_BIT               1
- #define EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT   2
-+#define EXT4_GROUP_INFO_BBITMAP_CORRUPT               \
-+      (1 << EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT)
- #define EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT   3
-+#define EXT4_GROUP_INFO_IBITMAP_CORRUPT               \
-+      (1 << EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT)
- #define EXT4_MB_GRP_NEED_INIT(grp)    \
-       (test_bit(EXT4_GROUP_INFO_NEED_INIT_BIT, &((grp)->bb_state)))
-Index: linux-stage/fs/ext4/ialloc.c
-===================================================================
---- linux-stage.orig/fs/ext4/ialloc.c
-+++ linux-stage/fs/ext4/ialloc.c
-@@ -70,26 +70,15 @@ static unsigned ext4_init_inode_bitmap(s
-                                      ext4_group_t block_group,
-                                      struct ext4_group_desc *gdp)
- {
--      struct ext4_group_info *grp;
--      struct ext4_sb_info *sbi = EXT4_SB(sb);
-       J_ASSERT_BH(bh, buffer_locked(bh));
-       /* If checksum is bad mark all blocks and inodes use to prevent
-        * allocation, essentially implementing a per-group read-only flag. */
-       if (!ext4_group_desc_csum_verify(sb, block_group, gdp)) {
--              ext4_error(sb, "Checksum bad for group %u", block_group);
--              grp = ext4_get_group_info(sb, block_group);
--              if (!EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
--                      percpu_counter_sub(&sbi->s_freeclusters_counter,
--                                         grp->bb_free);
--              set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state);
--              if (!EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) {
--                      int count;
--                      count = ext4_free_inodes_count(sb, gdp);
--                      percpu_counter_sub(&sbi->s_freeinodes_counter,
--                                         count);
--              }
--              set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &grp->bb_state);
-+              ext4_corrupted_block_group(sb, block_group,
-+                              EXT4_GROUP_INFO_BBITMAP_CORRUPT |
-+                              EXT4_GROUP_INFO_IBITMAP_CORRUPT,
-+                              "Checksum bad for group %u", block_group);
-               return 0;
-       }
-@@ -125,8 +114,6 @@ ext4_read_inode_bitmap(struct super_bloc
-       struct ext4_group_desc *desc;
-       struct buffer_head *bh = NULL;
-       ext4_fsblk_t bitmap_blk;
--      struct ext4_group_info *grp;
--      struct ext4_sb_info *sbi = EXT4_SB(sb);
-       desc = ext4_get_group_desc(sb, block_group, NULL);
-       if (!desc)
-@@ -193,16 +180,10 @@ verify:
-                                          EXT4_INODES_PER_GROUP(sb) / 8)) {
-               ext4_unlock_group(sb, block_group);
-               put_bh(bh);
--              ext4_error(sb, "Corrupt inode bitmap - block_group = %u, "
--                         "inode_bitmap = %llu", block_group, bitmap_blk);
--              grp = ext4_get_group_info(sb, block_group);
--              if (!EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) {
--                      int count;
--                      count = ext4_free_inodes_count(sb, desc);
--                      percpu_counter_sub(&sbi->s_freeinodes_counter,
--                                         count);
--              }
--              set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &grp->bb_state);
-+              ext4_corrupted_block_group(sb, block_group,
-+                              EXT4_GROUP_INFO_IBITMAP_CORRUPT,
-+                              "Corrupt inode bitmap - block_group = %u, inode_bitmap = %llu",
-+                              block_group, bitmap_blk);
-               return NULL;
-       }
-       ext4_unlock_group(sb, block_group);
-@@ -337,14 +318,9 @@ out:
-               if (!fatal)
-                       fatal = err;
-       } else {
--              ext4_error(sb, "bit already cleared for inode %lu", ino);
--              if (gdp && !EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) {
--                      int count;
--                      count = ext4_free_inodes_count(sb, gdp);
--                      percpu_counter_sub(&sbi->s_freeinodes_counter,
--                                         count);
--              }
--              set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &grp->bb_state);
-+              ext4_corrupted_block_group(sb, block_group,
-+                              EXT4_GROUP_INFO_IBITMAP_CORRUPT,
-+                              "bit already cleared for inode %lu", ino);
-       }
- error_return:
-Index: linux-stage/fs/ext4/mballoc.c
-===================================================================
---- linux-stage.orig/fs/ext4/mballoc.c
-+++ linux-stage/fs/ext4/mballoc.c
-@@ -752,10 +752,18 @@ int ext4_mb_generate_buddy(struct super_
-       if (free != grp->bb_free) {
-               struct ext4_group_desc *gdp;
-               gdp = ext4_get_group_desc(sb, group, NULL);
--              ext4_error(sb, "group %lu: %u blocks in bitmap, %u in bb, "
--                      "%u in gd, %lu pa's\n", (long unsigned int)group,
--                      free, grp->bb_free, ext4_free_group_clusters(sb, gdp),
--                      grp->bb_prealloc_nr);
-+
-+              ext4_corrupted_block_group(sb, group,
-+                              EXT4_GROUP_INFO_BBITMAP_CORRUPT,
-+                              "group %lu: %u blocks in bitmap, %u in bb, %u in gd, %lu pa's block bitmap corrupt",
-+                              (unsigned long int)group, free, grp->bb_free,
-+                              ext4_free_group_clusters(sb, gdp),
-+                              grp->bb_prealloc_nr);
-+              /*
-+               * If we intend to continue, we consider group descriptor
-+               * corrupt and update bb_free using bitmap value
-+               */
-+              grp->bb_free = free;
-               return -EIO;
-       }
-       mb_set_largest_free_order(sb, grp);
-@@ -1101,7 +1109,7 @@ ext4_mb_load_buddy(struct super_block *s
-       int block;
-       int pnum;
-       int poff;
--      struct page *page;
-+      struct page *page = NULL;
-       int ret;
-       struct ext4_group_info *grp;
-       struct ext4_sb_info *sbi = EXT4_SB(sb);
-@@ -1127,7 +1135,7 @@ ext4_mb_load_buddy(struct super_block *s
-                */
-               ret = ext4_mb_init_group(sb, group);
-               if (ret)
--                      return ret;
-+                      goto err;
-       }
-       /*
-@@ -1227,6 +1235,7 @@ err:
-               page_cache_release(e4b->bd_buddy_page);
-       e4b->bd_buddy = NULL;
-       e4b->bd_bitmap = NULL;
-+      ext4_warning(sb, "Error loading buddy information for %u", group);
-       return ret;
- }
-@@ -3598,9 +3607,11 @@ int ext4_mb_check_ondisk_bitmap(struct s
-       }
-       if (free != free_in_gdp) {
--              ext4_error(sb, "on-disk bitmap for group %d"
--                      "corrupted: %u blocks free in bitmap, %u - in gd\n",
--                      group, free, free_in_gdp);
-+              ext4_corrupted_block_group(sb, group,
-+                              EXT4_GROUP_INFO_BBITMAP_CORRUPT,
-+                              "on-disk bitmap for group %d corrupted: %u blocks free in bitmap, %u - in gd\n",
-+                              group, free,
-+                              free_in_gdp);
-               return -EIO;
-       }
-       return 0;
-@@ -3961,16 +3972,8 @@ ext4_mb_release_inode_pa(struct ext4_bud
-       /* "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)) {
--              ext4_error(sb, "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);
-               ext4_grp_locked_error(sb, group, 0, 0, "free %u, pa_free %u",
--                                      free, pa->pa_free);
-+                                    free, pa->pa_free);
-               /*
-                * pa is already deleted so we use the value obtained
-                * from the bitmap and continue.
-@@ -4030,14 +4033,11 @@ ext4_mb_discard_group_preallocations(str
-               return 0;
-       bitmap_bh = ext4_read_block_bitmap(sb, group);
--      if (bitmap_bh == NULL) {
--              ext4_error(sb, "Error reading block bitmap for %u", group);
-+      if (bitmap_bh == NULL)
-               return 0;
--      }
-       err = ext4_mb_load_buddy(sb, group, &e4b);
-       if (err) {
--              ext4_error(sb, "Error loading buddy information for %u", group);
-               put_bh(bitmap_bh);
-               return 0;
-       }
-@@ -4197,16 +4197,11 @@ repeat:
-               group = ext4_get_group_number(sb, pa->pa_pstart);
-               err = ext4_mb_load_buddy(sb, group, &e4b);
--              if (err) {
--                      ext4_error(sb, "Error loading buddy information for %u",
--                                      group);
-+              if (err)
-                       return;
--              }
-               bitmap_bh = ext4_read_block_bitmap(sb, group);
-               if (bitmap_bh == NULL) {
--                      ext4_error(sb, "Error reading block bitmap for %u",
--                                      group);
-                       ext4_mb_unload_buddy(&e4b);
-                       continue;
-               }
-@@ -4466,11 +4461,8 @@ ext4_mb_discard_lg_preallocations(struct
-       list_for_each_entry_safe(pa, tmp, &discard_list, u.pa_tmp_list) {
-               group = ext4_get_group_number(sb, pa->pa_pstart);
--              if (ext4_mb_load_buddy(sb, group, &e4b)) {
--                      ext4_error(sb, "Error loading buddy information for %u",
--                                      group);
-+              if (ext4_mb_load_buddy(sb, group, &e4b))
-                       continue;
--              }
-               ext4_lock_group(sb, group);
-               list_del(&pa->pa_group_list);
-               ext4_get_group_info(sb, group)->bb_prealloc_nr--;
-@@ -4741,17 +4733,18 @@ errout:
-                        * been updated or not when fail case. So can
-                        * not revert pa_free back, just mark pa_error*/
-                       pa->pa_error++;
--                      ext4_error(sb,
--                              "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);
-+                      ext4_corrupted_block_group(sb, 0, 0,
-+                                      "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);
-               }
-       }
-       ext4_mb_release_context(ac);
-@@ -5036,7 +5029,7 @@ do_more:
-       err = ext4_mb_load_buddy(sb, block_group, &e4b);
-       if (err)
--              goto error_return;
-+              goto error_brelse;
-       if ((flags & EXT4_FREE_BLOCKS_METADATA) && ext4_handle_valid(handle)) {
-               struct ext4_free_data *new_entry;
-@@ -5118,8 +5111,9 @@ do_more:
-               goto do_more;
-       }
- error_return:
--      brelse(bitmap_bh);
-       ext4_std_error(sb, err);
-+error_brelse:
-+      brelse(bitmap_bh);
-       return;
- }
-@@ -5215,7 +5209,7 @@ int ext4_group_add_blocks(handle_t *hand
-       err = ext4_mb_load_buddy(sb, block_group, &e4b);
-       if (err)
--              goto error_return;
-+              goto error_brelse;
-       /*
-        * need to update group_info->bb_free and bitmap
-@@ -5252,8 +5246,9 @@ int ext4_group_add_blocks(handle_t *hand
-               err = ret;
- error_return:
--      brelse(bitmap_bh);
-       ext4_std_error(sb, err);
-+error_brelse:
-+      brelse(bitmap_bh);
-       return err;
- }
-@@ -5328,11 +5323,9 @@ ext4_trim_all_free(struct super_block *s
-       trace_ext4_trim_all_free(sb, group, start, max);
-       ret = ext4_mb_load_buddy(sb, group, &e4b);
--      if (ret) {
--              ext4_error(sb, "Error in loading buddy "
--                              "information for %u", group);
-+      if (ret)
-               return ret;
--      }
-+
-       bitmap = e4b.bd_bitmap;
-       ext4_lock_group(sb, group);
-Index: linux-stage/fs/ext4/super.c
-===================================================================
---- linux-stage.orig/fs/ext4/super.c
-+++ linux-stage/fs/ext4/super.c
-@@ -633,6 +633,37 @@ void __ext4_warning(struct super_block *
-       va_end(args);
- }
-+void __ext4_corrupted_block_group(struct super_block *sb, ext4_group_t group,
-+                                unsigned int flags, const char *function,
-+                                unsigned int line)
-+{
-+      struct ext4_sb_info *sbi = EXT4_SB(sb);
-+      struct ext4_group_info *grp = ext4_get_group_info(sb, group);
-+      struct ext4_group_desc *gdp = ext4_get_group_desc(sb, group, NULL);
-+
-+      if (flags & EXT4_GROUP_INFO_BBITMAP_CORRUPT &&
-+          !EXT4_MB_GRP_BBITMAP_CORRUPT(grp)) {
-+              percpu_counter_sub(&sbi->s_freeclusters_counter,
-+                                      grp->bb_free);
-+              set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT,
-+                      &grp->bb_state);
-+      }
-+
-+      if (flags & EXT4_GROUP_INFO_IBITMAP_CORRUPT &&
-+          !EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) {
-+              if (gdp) {
-+                      int count;
-+
-+                      count = ext4_free_inodes_count(sb, gdp);
-+                      percpu_counter_sub(&sbi->s_freeinodes_counter,
-+                                         count);
-+              }
-+              set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT,
-+                      &grp->bb_state);
-+      }
-+      save_error_info(sb, function, line);
-+}
-+
- void __ext4_grp_locked_error(const char *function, unsigned int line,
-                            struct super_block *sb, ext4_group_t grp,
-                            unsigned long ino, ext4_fsblk_t block,
diff --git a/ldiskfs/kernel_patches/patches/rhel7.4/ext4-dont-check-before-replay.patch b/ldiskfs/kernel_patches/patches/rhel7.4/ext4-dont-check-before-replay.patch
deleted file mode 100644 (file)
index e1d41d7..0000000
+++ /dev/null
@@ -1,33 +0,0 @@
-Index: linux-stage/fs/ext4/super.c
-When ldiskfs run in failover mode whith read-only disk.
-Part of allocation updates are lost and ldiskfs may fail
-while mounting this is due to inconsistent state of
-group-descriptor. Group-descriptor check is added after
-journal replay.
-===================================================================
---- linux-stage/fs/ext4/super.c        2016-11-06 15:15:30.892386878 +0530
-+++ linux-stage.orig.1/fs/ext4/super.c 2016-11-08 10:56:45.579892189 +0530
-@@ -3980,10 +3980,6 @@
-                       goto failed_mount2;
-               }
-       }
--      if (!ext4_check_descriptors(sb, logical_sb_block, &first_not_zeroed)) {
--              ext4_msg(sb, KERN_ERR, "group descriptors corrupted!");
--              goto failed_mount2;
--      }