diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index ce5464f92a7e..cd01aec87303 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -48,6 +48,17 @@
 
 #include <trace/events/ext4.h>
 
+#include "ext4_jbd2_dbg.h"
+
+static int ext4_bh_tdbg(handle_t *handle, struct buffer_head *bh)
+{
+	struct super_block *sb = bh->b_page->mapping->host->i_sb;
+	tdbg_ext4(sb, "bh: %px, data offset: %04llx, page: %px, inode: %px\n",
+		  bh, (u64) bh->b_data & ((u64)PAGE_SIZE - 1),
+		  bh->b_page, bh->b_page->mapping->host);
+	return 0;
+}
+
 static __u32 ext4_inode_csum(struct inode *inode, struct ext4_inode *raw,
 			      struct ext4_inode_info *ei)
 {
@@ -1193,6 +1204,7 @@ static int ext4_write_begin(struct file *file, struct address_space *mapping,
 		ret = __block_write_begin(page, pos, len, ext4_get_block);
 #endif
 	if (!ret && ext4_should_journal_data(inode)) {
+		tdbg_ext4(inode->i_sb, "journal started: inode %px, txn %px", inode, handle->h_transaction);
 		ret = ext4_walk_page_buffers(handle, page_buffers(page),
 					     from, to, NULL,
 					     do_journal_get_write_access);
@@ -1446,6 +1458,7 @@ static int ext4_journalled_write_end(struct file *file,
 			ext4_orphan_del(NULL, inode);
 	}
 
+	tdbg_ext4(inode->i_sb, "journal stopped: inode %px", inode);
 	return ret ? ret : copied;
 }
 
@@ -1917,6 +1930,10 @@ static int __ext4_journalled_writepage(struct page *page,
 	err = ext4_jbd2_inode_add_write(handle, inode, 0, len);
 	if (ret == 0)
 		ret = err;
+	{
+		struct super_block *sb = handle->h_transaction->t_journal->j_private;
+		tdbg_ext4(sb, "Added inode to txn list: inode %px, txn = %px, err = %d", inode, handle->h_transaction, err);
+	}
 	EXT4_I(inode)->i_datasync_tid = handle->h_transaction->t_tid;
 	err = ext4_journal_stop(handle);
 	if (!ret)
@@ -2035,6 +2052,7 @@ static int ext4_writepage(struct page *page,
 		keep_towrite = true;
 	}
 
+	tdbg_ext4(inode->i_sb, "called for inode %px by comm %s", inode, current->comm);
 	if (PageChecked(page) && ext4_should_journal_data(inode))
 		/*
 		 * It's mmapped pagecache.  Add buffers and journal it.  There
@@ -5969,6 +5987,8 @@ vm_fault_t ext4_page_mkwrite(struct vm_fault *vmf)
 	get_block_t *get_block;
 	int retries = 0;
 
+	tdbg_ext4(inode->i_sb, "entry for inode %px", inode);
+
 	if (unlikely(IS_IMMUTABLE(inode)))
 		return VM_FAULT_SIGBUS;
 
@@ -6006,6 +6026,9 @@ vm_fault_t ext4_page_mkwrite(struct vm_fault *vmf)
 		len = size & ~PAGE_MASK;
 	else
 		len = PAGE_SIZE;
+
+	ext4_walk_page_buffers(NULL, page_buffers(page), 0, len, NULL, ext4_bh_tdbg);
+
 	/*
 	 * Return if we have all the buffers mapped. This avoids the need to do
 	 * journal_start/journal_stop which can block and take a long time. But
@@ -6018,6 +6041,7 @@ vm_fault_t ext4_page_mkwrite(struct vm_fault *vmf)
 			/* Wait so that we don't change page under IO */
 			wait_for_stable_page(page);
 			ret = VM_FAULT_LOCKED;
+			tdbg_ext4(inode->i_sb, "returning; all buffers mapped for inode %px", inode);
 			goto out;
 		}
 	}
@@ -6036,6 +6060,7 @@ vm_fault_t ext4_page_mkwrite(struct vm_fault *vmf)
 	}
 	err = block_page_mkwrite(vma, vmf, get_block);
 	if (!err && ext4_should_journal_data(inode)) {
+		tdbg_ext4(inode->i_sb, "before djgwa(), for inode %px", inode);
 		if (ext4_walk_page_buffers(handle, page_buffers(page), 0,
 			  PAGE_SIZE, NULL, do_journal_get_write_access)) {
 			unlock_page(page);
@@ -6043,6 +6068,7 @@ vm_fault_t ext4_page_mkwrite(struct vm_fault *vmf)
 			ext4_journal_stop(handle);
 			goto out;
 		}
+		tdbg_ext4(inode->i_sb, "after  djgwa(), for inode %px", inode);
 		ext4_set_inode_state(inode, EXT4_STATE_JDATA);
 		if (ext4_jbd2_inode_add_write(handle, inode, 0, PAGE_SIZE)) {
 			unlock_page(page);
@@ -6050,6 +6076,7 @@ vm_fault_t ext4_page_mkwrite(struct vm_fault *vmf)
 			ext4_journal_stop(handle);
 			goto out;
 		}
+		tdbg_ext4(inode->i_sb, "Added inode to txn list: inode %px, txn = %px, err = 0", inode, handle->h_transaction);
 	}
 	ext4_journal_stop(handle);
 	if (err == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 38aaac6572ea..7167fcf60b5c 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -58,6 +58,8 @@
 #define CREATE_TRACE_POINTS
 #include <trace/events/ext4.h>
 
+#include "ext4_jbd2_dbg.h"
+
 static struct ext4_lazy_init *ext4_li_info;
 static struct mutex ext4_li_mtx;
 static struct ratelimit_state ext4_mount_msg_ratelimit;
@@ -492,14 +494,20 @@ static int ext4_journalled_writepage_callback(struct page *page,
 	transaction_t *transaction = (transaction_t *) data;
 	struct buffer_head *bh, *head;
 	struct journal_head *jh;
+	struct super_block *sb = page->mapping->host->i_sb;
 
 	// XXX: any chance of !bh here?
 	bh = head = page_buffers(page);
+	tdbg_ext4(sb, "entry for bh %px, page %px, inode: %px", bh, page, page->mapping->host);
 	do {
 		jh = bh2jh(bh);
 		if (!jh || jh->b_transaction != transaction ||
 		    jh->b_next_transaction) {
 			redirty_page_for_writepage(wbc, page);
+			tdbg_ext4(sb, "redirty for bh %px, jh, %px, txn %px, next_txn %px",
+				  bh, jh,
+				  jh ? jh->b_transaction : NULL,
+				  jh ? jh->b_next_transaction : NULL);
 			goto out;
 		}
 	} while ((bh = bh->b_this_page) != head);
@@ -522,6 +530,7 @@ static int ext4_journalled_submit_inode_data_buffers(struct jbd2_inode *jinode)
 		.range_end = dirty_end,
         };
 
+	tdbg_ext4(jinode->i_vfs_inode->i_sb, "entry for inode: %px", jinode->i_vfs_inode);
 	return write_cache_pages(mapping, &wbc,
 				 ext4_journalled_writepage_callback,
 				 transaction);
@@ -529,6 +538,7 @@ static int ext4_journalled_submit_inode_data_buffers(struct jbd2_inode *jinode)
 
 static int ext4_journalled_finish_inode_data_buffers(struct jbd2_inode *jinode)
 {
+	tdbg_ext4(jinode->i_vfs_inode->i_sb, "entry for inode: %px", jinode->i_vfs_inode);
 	return 0;
 }
 
diff --git a/fs/jbd2/commit.c b/fs/jbd2/commit.c
index b98d227b50d8..96f0d81eadf9 100644
--- a/fs/jbd2/commit.c
+++ b/fs/jbd2/commit.c
@@ -29,6 +29,8 @@
 #include <linux/printk.h>
 #include <linux/delay.h>
 
+#include "../ext4/ext4_jbd2_dbg.h"
+
 static journal_t *force_panic;
 
 /*
@@ -222,11 +224,14 @@ static int journal_submit_data_buffers(journal_t *journal,
 	int err, ret = 0;
 	struct address_space *mapping;
 
+	tdbg_jbd2(journal, "entry for transaction: 0x%px\n", commit_transaction);
 	spin_lock(&journal->j_list_lock);
 	list_for_each_entry(jinode, &commit_transaction->t_inode_list, i_list) {
 		loff_t dirty_start = jinode->i_dirty_start;
 		loff_t dirty_end = jinode->i_dirty_end;
 
+		tdbg_jbd2(journal, "txn list has inode %px (write data flag: 0x%lx)\n", jinode->i_vfs_inode, (jinode->i_flags & JI_WRITE_DATA));
+
 		if (!(jinode->i_flags & JI_WRITE_DATA))
 			continue;
 		mapping = jinode->i_vfs_inode->i_mapping;
diff --git a/fs/jbd2/journal.c b/fs/jbd2/journal.c
index e4944436e733..b86b871ee823 100644
--- a/fs/jbd2/journal.c
+++ b/fs/jbd2/journal.c
@@ -48,6 +48,8 @@
 #include <linux/uaccess.h>
 #include <asm/page.h>
 
+#include "../ext4/ext4_jbd2_dbg.h"
+
 #ifdef CONFIG_JBD2_DEBUG
 ushort jbd2_journal_enable_debug __read_mostly;
 EXPORT_SYMBOL(jbd2_journal_enable_debug);
@@ -453,6 +455,9 @@ int jbd2_journal_write_metadata_buffer(transaction_t *transaction,
 
 	*bh_out = new_bh;
 
+	tdbg_jbd2(transaction->t_journal, "copy out: done/need %d/%d, bh: %px, offset: %04x, page: %px, inode: %px\n",
+	     done_copy_out, need_copy_out, jh2bh(jh_in), new_offset, new_page, new_page->mapping ? new_page->mapping->host : NULL);
+
 	/*
 	 * The to-be-written buffer needs to get moved to the io queue,
 	 * and the original buffer whose contents we are shadowing or
diff --git a/fs/jbd2/transaction.c b/fs/jbd2/transaction.c
index e91aad3637a2..93a55a228e08 100644
--- a/fs/jbd2/transaction.c
+++ b/fs/jbd2/transaction.c
@@ -30,6 +30,8 @@
 
 #include <trace/events/jbd2.h>
 
+#include "../ext4/ext4_jbd2_dbg.h"
+
 static void __jbd2_journal_temp_unlink_buffer(struct journal_head *jh);
 static void __jbd2_journal_unfile_buffer(struct journal_head *jh);
 
@@ -952,6 +954,8 @@ do_get_write_access(handle_t *handle, struct journal_head *jh,
 repeat:
 	bh = jh2bh(jh);
 
+	tdbg_jbd2(journal, "entry for bh: %px, offset: %04lx, page %px, inode: %px",
+		  bh, offset_in_page(bh->b_data), bh->b_page, bh->b_page->mapping->host);
 	/* @@@ Need to check for errors here at some point. */
 
  	start_lock = jiffies;
