ext4: pass context information to jbd2__journal_start()

So we can better understand what bits of ext4 are responsible for
long-running jbd2 handles, use jbd2__journal_start() so we can pass
context information for logging purposes.

The recommended way for finding the longer-running handles is:

   T=/sys/kernel/debug/tracing
   EVENT=$T/events/jbd2/jbd2_handle_stats
   echo "interval > 5" > $EVENT/filter
   echo 1 > $EVENT/enable

   ./run-my-fs-benchmark

   cat $T/trace > /tmp/problem-handles

This will list handles that were active for longer than 20ms.  Having
longer-running handles is bad, because a commit started at the wrong
time could stall for those 20+ milliseconds, which could delay an
fsync() or an O_SYNC operation.  Here is an example line from the
trace file describing a handle which lived on for 311 jiffies, or over
1.2 seconds:

postmark-2917  [000] ....   196.435786: jbd2_handle_stats: dev 254,32 
   tid 570 type 2 line_no 2541 interval 311 sync 0 requested_blocks 1
   dirtied_blocks 0

Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>

16 files changed, 111 insertions, 69 deletions

diff --git a/fs/ext4/acl.c b/fs/ext4/acl.c
index e6e0d988439b..406cf8bb12d5 100644
--- a/fs/ext4/acl.c
+++ b/fs/ext4/acl.c
@@ -324,7 +324,7 @@ ext4_acl_chmod(struct inode *inode)
         if (error)
                 return error;
 retry:
-        handle = ext4_journal_start(inode,
+        handle = ext4_journal_start(inode, EXT4_HT_XATTR,
                         EXT4_DATA_TRANS_BLOCKS(inode->i_sb));
         if (IS_ERR(handle)) {
                 error = PTR_ERR(handle);
@@ -422,7 +422,8 @@ ext4_xattr_set_acl(struct dentry *dentry, const char *name, const void *value,
                 acl = NULL;
 
 retry:
-        handle = ext4_journal_start(inode, EXT4_DATA_TRANS_BLOCKS(inode->i_sb));
+        handle = ext4_journal_start(inode, EXT4_HT_XATTR,
+                                    EXT4_DATA_TRANS_BLOCKS(inode->i_sb));
         if (IS_ERR(handle)) {
                 error = PTR_ERR(handle);
                 goto release_and_out;
diff --git a/fs/ext4/ext4_jbd2.c b/fs/ext4/ext4_jbd2.c
index 6f6114525535..7058975e3a55 100644
--- a/fs/ext4/ext4_jbd2.c
+++ b/fs/ext4/ext4_jbd2.c
@@ -38,7 +38,8 @@ static void ext4_put_nojournal(handle_t *handle)
 /*
  * Wrappers for jbd2_journal_start/end.
  */
-handle_t *ext4_journal_start_sb(struct super_block *sb, int nblocks)
+handle_t *__ext4_journal_start_sb(struct super_block *sb, unsigned int line,
+                                  int type, int nblocks)
 {
         journal_t *journal;
 
@@ -59,7 +60,7 @@ handle_t *ext4_journal_start_sb(struct super_block *sb, int nblocks)
                 ext4_abort(sb, "Detected aborted journal");
                 return ERR_PTR(-EROFS);
         }
-        return jbd2_journal_start(journal, nblocks);
+        return jbd2__journal_start(journal, nblocks, GFP_NOFS, type, line);
 }
 
 int __ext4_journal_stop(const char *where, unsigned int line, handle_t *handle)
diff --git a/fs/ext4/ext4_jbd2.h b/fs/ext4/ext4_jbd2.h
index 7177f9b21cb2..302814b85945 100644
--- a/fs/ext4/ext4_jbd2.h
+++ b/fs/ext4/ext4_jbd2.h
@@ -110,6 +110,22 @@
 #define EXT4_MAXQUOTAS_INIT_BLOCKS(sb) (MAXQUOTAS*EXT4_QUOTA_INIT_BLOCKS(sb))
 #define EXT4_MAXQUOTAS_DEL_BLOCKS(sb) (MAXQUOTAS*EXT4_QUOTA_DEL_BLOCKS(sb))
 
+/*
+ * Ext4 handle operation types -- for logging purposes
+ */
+#define EXT4_HT_MISC             0
+#define EXT4_HT_INODE            1
+#define EXT4_HT_WRITE_PAGE       2
+#define EXT4_HT_MAP_BLOCKS       3
+#define EXT4_HT_DIR              4
+#define EXT4_HT_TRUNCATE         5
+#define EXT4_HT_QUOTA            6
+#define EXT4_HT_RESIZE           7
+#define EXT4_HT_MIGRATE          8
+#define EXT4_HT_MOVE_EXTENTS     9
+#define EXT4_HT_XATTR           10
+#define EXT4_HT_MAX             11
+
 /**
  *   struct ext4_journal_cb_entry - Base structure for callback information.
  *
@@ -234,7 +250,8 @@ int __ext4_handle_dirty_super(const char *where, unsigned int line,
 #define ext4_handle_dirty_super(handle, sb) \
         __ext4_handle_dirty_super(__func__, __LINE__, (handle), (sb))
 
-handle_t *ext4_journal_start_sb(struct super_block *sb, int nblocks);
+handle_t *__ext4_journal_start_sb(struct super_block *sb, unsigned int line,
+                                  int type, int nblocks);
 int __ext4_journal_stop(const char *where, unsigned int line, handle_t *handle);
 
 #define EXT4_NOJOURNAL_MAX_REF_COUNT ((unsigned long) 4096)
@@ -268,9 +285,17 @@ static inline int ext4_handle_has_enough_credits(handle_t *handle, int needed)
         return 1;
 }
 
-static inline handle_t *ext4_journal_start(struct inode *inode, int nblocks)
+#define ext4_journal_start_sb(sb, type, nblocks)                        \
+        __ext4_journal_start_sb((sb), __LINE__, (type), (nblocks))
+
+#define ext4_journal_start(inode, type, nblocks)                        \
+        __ext4_journal_start((inode), __LINE__, (type), (nblocks))
+
+static inline handle_t *__ext4_journal_start(struct inode *inode,
+                                             unsigned int line, int type,
+                                             int nblocks)
 {
-        return ext4_journal_start_sb(inode->i_sb, nblocks);
+        return __ext4_journal_start_sb(inode->i_sb, line, type, nblocks);
 }
 
 #define ext4_journal_stop(handle) \
diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index db55c62e1f01..b6b54d658dc2 100644
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -2656,7 +2656,7 @@ static int ext4_ext_remove_space(struct inode *inode, ext4_lblk_t start,
         ext_debug("truncate since %u to %u\n", start, end);
 
         /* probably first extent we're gonna free will be last in block */
-        handle = ext4_journal_start(inode, depth + 1);
+        handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, depth + 1);
         if (IS_ERR(handle))
                 return PTR_ERR(handle);
 
@@ -4287,7 +4287,7 @@ void ext4_ext_truncate(struct inode *inode)
          * probably first extent we're gonna free will be last in block
          */
         err = ext4_writepage_trans_blocks(inode);
-        handle = ext4_journal_start(inode, err);
+        handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, err);
         if (IS_ERR(handle))
                 return;
 
@@ -4454,7 +4454,8 @@ retry:
         while (ret >= 0 && ret < max_blocks) {
                 map.m_lblk = map.m_lblk + ret;
                 map.m_len = max_blocks = max_blocks - ret;
-                handle = ext4_journal_start(inode, credits);
+                handle = ext4_journal_start(inode, EXT4_HT_MAP_BLOCKS,
+                                            credits);
                 if (IS_ERR(handle)) {
                         ret = PTR_ERR(handle);
                         break;
@@ -4532,7 +4533,7 @@ int ext4_convert_unwritten_extents(struct inode *inode, loff_t offset,
         while (ret >= 0 && ret < max_blocks) {
                 map.m_lblk += ret;
                 map.m_len = (max_blocks -= ret);
-                handle = ext4_journal_start(inode, credits);
+                handle = ext4_journal_start(inode, EXT4_HT_MAP_BLOCKS, credits);
                 if (IS_ERR(handle)) {
                         ret = PTR_ERR(handle);
                         break;
@@ -4710,7 +4711,7 @@ int ext4_ext_punch_hole(struct file *file, loff_t offset, loff_t length)
         inode_dio_wait(inode);
 
         credits = ext4_writepage_trans_blocks(inode);
-        handle = ext4_journal_start(inode, credits);
+        handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, credits);
         if (IS_ERR(handle)) {
                 err = PTR_ERR(handle);
                 goto out_dio;
diff --git a/fs/ext4/file.c b/fs/ext4/file.c
index 405565a62277..2cf8ab810687 100644
--- a/fs/ext4/file.c
+++ b/fs/ext4/file.c
@@ -240,7 +240,7 @@ static int ext4_file_open(struct inode * inode, struct file * filp)
                         handle_t *handle;
                         int err;
 
-                        handle = ext4_journal_start_sb(sb, 1);
+                        handle = ext4_journal_start_sb(sb, EXT4_HT_MISC, 1);
                         if (IS_ERR(handle))
                                 return PTR_ERR(handle);
                         err = ext4_journal_get_write_access(handle, sbi->s_sbh);
diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c
index 3f32c8012447..10bd6fecc9ff 100644
--- a/fs/ext4/ialloc.c
+++ b/fs/ext4/ialloc.c
@@ -1137,7 +1137,7 @@ int ext4_init_inode_table(struct super_block *sb, ext4_group_t group,
         if (gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_ZEROED))
                 goto out;
 
-        handle = ext4_journal_start_sb(sb, 1);
+        handle = ext4_journal_start_sb(sb, EXT4_HT_MISC, 1);
         if (IS_ERR(handle)) {
                 ret = PTR_ERR(handle);
                 goto out;
diff --git a/fs/ext4/indirect.c b/fs/ext4/indirect.c
index 193281098fb6..c541ab8b64dd 100644
--- a/fs/ext4/indirect.c
+++ b/fs/ext4/indirect.c
@@ -791,7 +791,7 @@ ssize_t ext4_ind_direct_IO(int rw, struct kiocb *iocb,
 
                 if (final_size > inode->i_size) {
                         /* Credits for sb + inode write */
-                        handle = ext4_journal_start(inode, 2);
+                        handle = ext4_journal_start(inode, EXT4_HT_INODE, 2);
                         if (IS_ERR(handle)) {
                                 ret = PTR_ERR(handle);
                                 goto out;
@@ -851,7 +851,7 @@ locked:
                 int err;
 
                 /* Credits for sb + inode write */
-                handle = ext4_journal_start(inode, 2);
+                handle = ext4_journal_start(inode, EXT4_HT_INODE, 2);
                 if (IS_ERR(handle)) {
                         /* This is really bad luck. We've written the data
                          * but cannot extend i_size. Bail out and pretend
@@ -950,7 +950,8 @@ static handle_t *start_transaction(struct inode *inode)
 {
         handle_t *result;
 
-        result = ext4_journal_start(inode, ext4_blocks_for_truncate(inode));
+        result = ext4_journal_start(inode, EXT4_HT_TRUNCATE,
+                                    ext4_blocks_for_truncate(inode));
         if (!IS_ERR(result))
                 return result;
 
diff --git a/fs/ext4/inline.c b/fs/ext4/inline.c
index 93a3408fc89b..bc5f871f0893 100644
--- a/fs/ext4/inline.c
+++ b/fs/ext4/inline.c
@@ -545,7 +545,7 @@ static int ext4_convert_inline_data_to_extent(struct address_space *mapping,
                 return ret;
 
 retry:
-        handle = ext4_journal_start(inode, needed_blocks);
+        handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, needed_blocks);
         if (IS_ERR(handle)) {
                 ret = PTR_ERR(handle);
                 handle = NULL;
@@ -657,7 +657,7 @@ int ext4_try_to_write_inline_data(struct address_space *mapping,
          * The possible write could happen in the inode,
          * so try to reserve the space in inode first.
          */
-        handle = ext4_journal_start(inode, 1);
+        handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
         if (IS_ERR(handle)) {
                 ret = PTR_ERR(handle);
                 handle = NULL;
@@ -853,7 +853,7 @@ int ext4_da_write_inline_data_begin(struct address_space *mapping,
         if (ret)
                 return ret;
 
-        handle = ext4_journal_start(inode, 1);
+        handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
         if (IS_ERR(handle)) {
                 ret = PTR_ERR(handle);
                 handle = NULL;
@@ -1770,7 +1770,7 @@ void ext4_inline_data_truncate(struct inode *inode, int *has_inline)
 
 
         needed_blocks = ext4_writepage_trans_blocks(inode);
-        handle = ext4_journal_start(inode, needed_blocks);
+        handle = ext4_journal_start(inode, EXT4_HT_INODE, needed_blocks);
         if (IS_ERR(handle))
                 return;
 
@@ -1862,7 +1862,7 @@ int ext4_convert_inline_data(struct inode *inode)
         if (error)
                 return error;
 
-        handle = ext4_journal_start(inode, needed_blocks);
+        handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, needed_blocks);
         if (IS_ERR(handle)) {
                 error = PTR_ERR(handle);
                 goto out_free;
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 07d9defeaf8c..5042c8773ad7 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -234,7 +234,8 @@ void ext4_evict_inode(struct inode *inode)
          * protection against it
          */
         sb_start_intwrite(inode->i_sb);
-        handle = ext4_journal_start(inode, ext4_blocks_for_truncate(inode)+3);
+        handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE,
+                                    ext4_blocks_for_truncate(inode)+3);
         if (IS_ERR(handle)) {
                 ext4_std_error(inode->i_sb, PTR_ERR(handle));
                 /*
@@ -656,7 +657,8 @@ static int _ext4_get_block(struct inode *inode, sector_t iblock,
                 if (map.m_len > DIO_MAX_BLOCKS)
                         map.m_len = DIO_MAX_BLOCKS;
                 dio_credits = ext4_chunk_trans_blocks(inode, map.m_len);
-                handle = ext4_journal_start(inode, dio_credits);
+                handle = ext4_journal_start(inode, EXT4_HT_MAP_BLOCKS,
+                                            dio_credits);
                 if (IS_ERR(handle)) {
                         ret = PTR_ERR(handle);
                         return ret;
@@ -881,7 +883,7 @@ static int ext4_write_begin(struct file *file, struct address_space *mapping,
         }
 
 retry:
-        handle = ext4_journal_start(inode, needed_blocks);
+        handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, needed_blocks);
         if (IS_ERR(handle)) {
                 ret = PTR_ERR(handle);
                 goto out;
@@ -1881,7 +1883,8 @@ static int __ext4_journalled_writepage(struct page *page,
          * references to buffers so we are safe */
         unlock_page(page);
 
-        handle = ext4_journal_start(inode, ext4_writepage_trans_blocks(inode));
+        handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE,
+                                    ext4_writepage_trans_blocks(inode));
         if (IS_ERR(handle)) {
                 ret = PTR_ERR(handle);
                 goto out;
@@ -2312,7 +2315,8 @@ retry:
                 needed_blocks = ext4_da_writepages_trans_blocks(inode);
 
                 /* start a new transaction*/
-                handle = ext4_journal_start(inode, needed_blocks);
+                handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE,
+                                            needed_blocks);
                 if (IS_ERR(handle)) {
                         ret = PTR_ERR(handle);
                         ext4_msg(inode->i_sb, KERN_CRIT, "%s: jbd2_start: "
@@ -2468,7 +2472,7 @@ retry:
          * to journalling the i_disksize update if writes to the end
          * of file which has an already mapped buffer.
          */
-        handle = ext4_journal_start(inode, 1);
+        handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, 1);
         if (IS_ERR(handle)) {
                 ret = PTR_ERR(handle);
                 goto out;
@@ -4215,8 +4219,9 @@ int ext4_setattr(struct dentry *dentry, struct iattr *attr)
 
                 /* (user+group)*(old+new) structure, inode write (sb,
                  * inode block, ? - but truncate inode update has it) */
-                handle = ext4_journal_start(inode, (EXT4_MAXQUOTAS_INIT_BLOCKS(inode->i_sb)+
-                                        EXT4_MAXQUOTAS_DEL_BLOCKS(inode->i_sb))+3);
+                handle = ext4_journal_start(inode, EXT4_HT_QUOTA,
+                        (EXT4_MAXQUOTAS_INIT_BLOCKS(inode->i_sb) +
+                         EXT4_MAXQUOTAS_DEL_BLOCKS(inode->i_sb)) + 3);
                 if (IS_ERR(handle)) {
                         error = PTR_ERR(handle);
                         goto err_out;
@@ -4251,7 +4256,7 @@ int ext4_setattr(struct dentry *dentry, struct iattr *attr)
             (attr->ia_size < inode->i_size)) {
                 handle_t *handle;
 
-                handle = ext4_journal_start(inode, 3);
+                handle = ext4_journal_start(inode, EXT4_HT_INODE, 3);
                 if (IS_ERR(handle)) {
                         error = PTR_ERR(handle);
                         goto err_out;
@@ -4271,7 +4276,8 @@ int ext4_setattr(struct dentry *dentry, struct iattr *attr)
                                                             attr->ia_size);
                         if (error) {
                                 /* Do as much error cleanup as possible */
-                                handle = ext4_journal_start(inode, 3);
+                                handle = ext4_journal_start(inode,
+                                                            EXT4_HT_INODE, 3);
                                 if (IS_ERR(handle)) {
                                         ext4_orphan_del(NULL, inode);
                                         goto err_out;
@@ -4612,7 +4618,7 @@ void ext4_dirty_inode(struct inode *inode, int flags)
 {
         handle_t *handle;
 
-        handle = ext4_journal_start(inode, 2);
+        handle = ext4_journal_start(inode, EXT4_HT_INODE, 2);
         if (IS_ERR(handle))
                 goto out;
 
@@ -4713,7 +4719,7 @@ int ext4_change_inode_journal_flag(struct inode *inode, int val)
 
         /* Finally we can mark the inode as dirty. */
 
-        handle = ext4_journal_start(inode, 1);
+        handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
         if (IS_ERR(handle))
                 return PTR_ERR(handle);
 
@@ -4791,7 +4797,8 @@ int ext4_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
         else
                 get_block = ext4_get_block;
 retry_alloc:
-        handle = ext4_journal_start(inode, ext4_writepage_trans_blocks(inode));
+        handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE,
+                                    ext4_writepage_trans_blocks(inode));
         if (IS_ERR(handle)) {
                 ret = VM_FAULT_SIGBUS;
                 goto out;
diff --git a/fs/ext4/ioctl.c b/fs/ext4/ioctl.c
index 4784ac244fc6..31f4f56a32d6 100644
--- a/fs/ext4/ioctl.c
+++ b/fs/ext4/ioctl.c
@@ -104,7 +104,7 @@ long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
                 } else if (oldflags & EXT4_EOFBLOCKS_FL)
                         ext4_truncate(inode);
 
-                handle = ext4_journal_start(inode, 1);
+                handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
                 if (IS_ERR(handle)) {
                         err = PTR_ERR(handle);
                         goto flags_out;
@@ -173,7 +173,7 @@ flags_out:
                 }
 
                 mutex_lock(&inode->i_mutex);
-                handle = ext4_journal_start(inode, 1);
+                handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
                 if (IS_ERR(handle)) {
                         err = PTR_ERR(handle);
                         goto unlock_out;
diff --git a/fs/ext4/migrate.c b/fs/ext4/migrate.c
index db8226d595fa..4e4fcfd342f8 100644
--- a/fs/ext4/migrate.c
+++ b/fs/ext4/migrate.c
@@ -456,7 +456,7 @@ int ext4_ext_migrate(struct inode *inode)
                  */
                 return retval;
 
-        handle = ext4_journal_start(inode,
+        handle = ext4_journal_start(inode, EXT4_HT_MIGRATE,
                                         EXT4_DATA_TRANS_BLOCKS(inode->i_sb) +
                                         EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3 +
                                         EXT4_MAXQUOTAS_INIT_BLOCKS(inode->i_sb)
@@ -507,7 +507,7 @@ int ext4_ext_migrate(struct inode *inode)
         ext4_set_inode_state(inode, EXT4_STATE_EXT_MIGRATE);
         up_read((&EXT4_I(inode)->i_data_sem));
 
-        handle = ext4_journal_start(inode, 1);
+        handle = ext4_journal_start(inode, EXT4_HT_MIGRATE, 1);
         if (IS_ERR(handle)) {
                 /*
                  * It is impossible to update on-disk structures without
diff --git a/fs/ext4/move_extent.c b/fs/ext4/move_extent.c
index e4cdb5188f34..0d6734394eac 100644
--- a/fs/ext4/move_extent.c
+++ b/fs/ext4/move_extent.c
@@ -923,7 +923,7 @@ move_extent_per_page(struct file *o_filp, struct inode *donor_inode,
 again:
         *err = 0;
         jblocks = ext4_writepage_trans_blocks(orig_inode) * 2;
-        handle = ext4_journal_start(orig_inode, jblocks);
+        handle = ext4_journal_start(orig_inode, EXT4_HT_MOVE_EXTENTS, jblocks);
         if (IS_ERR(handle)) {
                 *err = PTR_ERR(handle);
                 return 0;
diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
index 34ed624d2c56..51841032ca03 100644
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -2262,9 +2262,10 @@ static int ext4_create(struct inode *dir, struct dentry *dentry, umode_t mode,
         dquot_initialize(dir);
 
 retry:
-        handle = ext4_journal_start(dir, EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
-                                        EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3 +
-                                        EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb));
+        handle = ext4_journal_start(dir, EXT4_HT_DIR,
+                (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
+                 EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3 +
+                 EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb)));
         if (IS_ERR(handle))
                 return PTR_ERR(handle);
 
@@ -2298,9 +2299,10 @@ static int ext4_mknod(struct inode *dir, struct dentry *dentry,
         dquot_initialize(dir);
 
 retry:
-        handle = ext4_journal_start(dir, EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
-                                        EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3 +
-                                        EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb));
+        handle = ext4_journal_start(dir, EXT4_HT_DIR,
+                (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
+                 EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3 +
+                 EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb)));
         if (IS_ERR(handle))
                 return PTR_ERR(handle);
 
@@ -2414,9 +2416,10 @@ static int ext4_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
         dquot_initialize(dir);
 
 retry:
-        handle = ext4_journal_start(dir, EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
-                                        EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3 +
-                                        EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb));
+        handle = ext4_journal_start(dir, EXT4_HT_DIR,
+                (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
+                 EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3 +
+                 EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb)));
         if (IS_ERR(handle))
                 return PTR_ERR(handle);
 
@@ -2729,7 +2732,8 @@ static int ext4_rmdir(struct inode *dir, struct dentry *dentry)
         dquot_initialize(dir);
         dquot_initialize(dentry->d_inode);
 
-        handle = ext4_journal_start(dir, EXT4_DELETE_TRANS_BLOCKS(dir->i_sb));
+        handle = ext4_journal_start(dir, EXT4_HT_DIR,
+                                    EXT4_DELETE_TRANS_BLOCKS(dir->i_sb));
         if (IS_ERR(handle))
                 return PTR_ERR(handle);
 
@@ -2791,7 +2795,8 @@ static int ext4_unlink(struct inode *dir, struct dentry *dentry)
         dquot_initialize(dir);
         dquot_initialize(dentry->d_inode);
 
-        handle = ext4_journal_start(dir, EXT4_DELETE_TRANS_BLOCKS(dir->i_sb));
+        handle = ext4_journal_start(dir, EXT4_HT_DIR,
+                                    EXT4_DELETE_TRANS_BLOCKS(dir->i_sb));
         if (IS_ERR(handle))
                 return PTR_ERR(handle);
 
@@ -2870,7 +2875,7 @@ static int ext4_symlink(struct inode *dir,
                           EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb);
         }
 retry:
-        handle = ext4_journal_start(dir, credits);
+        handle = ext4_journal_start(dir, EXT4_HT_DIR, credits);
         if (IS_ERR(handle))
                 return PTR_ERR(handle);
 
@@ -2908,7 +2913,7 @@ retry:
                  * Now inode is being linked into dir (EXT4_DATA_TRANS_BLOCKS
                  * + EXT4_INDEX_EXTRA_TRANS_BLOCKS), inode is also modified
                  */
-                handle = ext4_journal_start(dir,
+                handle = ext4_journal_start(dir, EXT4_HT_DIR,
                                 EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
                                 EXT4_INDEX_EXTRA_TRANS_BLOCKS + 1);
                 if (IS_ERR(handle)) {
@@ -2955,8 +2960,9 @@ static int ext4_link(struct dentry *old_dentry,
         dquot_initialize(dir);
 
 retry:
-        handle = ext4_journal_start(dir, EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
-                                        EXT4_INDEX_EXTRA_TRANS_BLOCKS);
+        handle = ext4_journal_start(dir, EXT4_HT_DIR,
+                (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
+                 EXT4_INDEX_EXTRA_TRANS_BLOCKS));
         if (IS_ERR(handle))
                 return PTR_ERR(handle);
 
@@ -3039,9 +3045,9 @@ static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
          * in separate transaction */
         if (new_dentry->d_inode)
                 dquot_initialize(new_dentry->d_inode);
-        handle = ext4_journal_start(old_dir, 2 *
-                                        EXT4_DATA_TRANS_BLOCKS(old_dir->i_sb) +
-                                        EXT4_INDEX_EXTRA_TRANS_BLOCKS + 2);
+        handle = ext4_journal_start(old_dir, EXT4_HT_DIR,
+                (2 * EXT4_DATA_TRANS_BLOCKS(old_dir->i_sb) +
+                 EXT4_INDEX_EXTRA_TRANS_BLOCKS + 2));
         if (IS_ERR(handle))
                 return PTR_ERR(handle);
 
diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index 8eefb636beb8..c7f4d7584669 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -466,7 +466,7 @@ static int setup_new_flex_group_blocks(struct super_block *sb,
         meta_bg = EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_META_BG);
 
         /* This transaction may be extended/restarted along the way */
-        handle = ext4_journal_start_sb(sb, EXT4_MAX_TRANS_DATA);
+        handle = ext4_journal_start_sb(sb, EXT4_HT_RESIZE, EXT4_MAX_TRANS_DATA);
         if (IS_ERR(handle))
                 return PTR_ERR(handle);
 
@@ -1031,7 +1031,7 @@ static void update_backups(struct super_block *sb, int blk_off, char *data,
         handle_t *handle;
         int err = 0, err2;
 
-        handle = ext4_journal_start_sb(sb, EXT4_MAX_TRANS_DATA);
+        handle = ext4_journal_start_sb(sb, EXT4_HT_RESIZE, EXT4_MAX_TRANS_DATA);
         if (IS_ERR(handle)) {
                 group = 1;
                 err = PTR_ERR(handle);
@@ -1412,7 +1412,7 @@ static int ext4_flex_group_add(struct super_block *sb,
          * modify each of the reserved GDT dindirect blocks.
          */
         credit = flex_gd->count * 4 + reserved_gdb;
-        handle = ext4_journal_start_sb(sb, credit);
+        handle = ext4_journal_start_sb(sb, EXT4_HT_RESIZE, credit);
         if (IS_ERR(handle)) {
                 err = PTR_ERR(handle);
                 goto exit;
@@ -1624,7 +1624,7 @@ static int ext4_group_extend_no_check(struct super_block *sb,
         /* We will update the superblock, one block bitmap, and
          * one group descriptor via ext4_group_add_blocks().
          */
-        handle = ext4_journal_start_sb(sb, 3);
+        handle = ext4_journal_start_sb(sb, EXT4_HT_RESIZE, 3);
         if (IS_ERR(handle)) {
                 err = PTR_ERR(handle);
                 ext4_warning(sb, "error %d on journal start", err);
@@ -1788,7 +1788,7 @@ static int ext4_convert_meta_bg(struct super_block *sb, struct inode *inode)
                 credits += 3;   /* block bitmap, bg descriptor, resize inode */
         }
 
-        handle = ext4_journal_start_sb(sb, credits);
+        handle = ext4_journal_start_sb(sb, EXT4_HT_RESIZE, credits);
         if (IS_ERR(handle))
                 return PTR_ERR(handle);
 
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index cb9d67fbc8f0..ef6ac59e4961 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -4762,7 +4762,7 @@ static int ext4_write_dquot(struct dquot *dquot)
         struct inode *inode;
 
         inode = dquot_to_inode(dquot);
-        handle = ext4_journal_start(inode,
+        handle = ext4_journal_start(inode, EXT4_HT_QUOTA,
                                     EXT4_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
         if (IS_ERR(handle))
                 return PTR_ERR(handle);
@@ -4778,7 +4778,7 @@ static int ext4_acquire_dquot(struct dquot *dquot)
         int ret, err;
         handle_t *handle;
 
-        handle = ext4_journal_start(dquot_to_inode(dquot),
+        handle = ext4_journal_start(dquot_to_inode(dquot), EXT4_HT_QUOTA,
                                     EXT4_QUOTA_INIT_BLOCKS(dquot->dq_sb));
         if (IS_ERR(handle))
                 return PTR_ERR(handle);
@@ -4794,7 +4794,7 @@ static int ext4_release_dquot(struct dquot *dquot)
         int ret, err;
         handle_t *handle;
 
-        handle = ext4_journal_start(dquot_to_inode(dquot),
+        handle = ext4_journal_start(dquot_to_inode(dquot), EXT4_HT_QUOTA,
                                     EXT4_QUOTA_DEL_BLOCKS(dquot->dq_sb));
         if (IS_ERR(handle)) {
                 /* Release dquot anyway to avoid endless cycle in dqput() */
@@ -4826,7 +4826,7 @@ static int ext4_write_info(struct super_block *sb, int type)
         handle_t *handle;
 
         /* Data block + inode block */
-        handle = ext4_journal_start(sb->s_root->d_inode, 2);
+        handle = ext4_journal_start(sb->s_root->d_inode, EXT4_HT_QUOTA, 2);
         if (IS_ERR(handle))
                 return PTR_ERR(handle);
         ret = dquot_commit_info(sb, type);
@@ -4972,7 +4972,7 @@ static int ext4_quota_off(struct super_block *sb, int type)
 
         /* Update modification times of quota files when userspace can
          * start looking at them */
-        handle = ext4_journal_start(inode, 1);
+        handle = ext4_journal_start(inode, EXT4_HT_QUOTA, 1);
         if (IS_ERR(handle))
                 goto out;
         inode->i_mtime = inode->i_ctime = CURRENT_TIME;
diff --git a/fs/ext4/xattr.c b/fs/ext4/xattr.c
index c68990c392c7..2efc5600b03b 100644
--- a/fs/ext4/xattr.c
+++ b/fs/ext4/xattr.c
@@ -1175,7 +1175,7 @@ retry:
         if (ext4_has_inline_data(inode))
                 credits += ext4_writepage_trans_blocks(inode) + 1;
 
-        handle = ext4_journal_start(inode, credits);
+        handle = ext4_journal_start(inode, EXT4_HT_XATTR, credits);
         if (IS_ERR(handle)) {
                 error = PTR_ERR(handle);
         } else {