diff --git a/fs/ext3/resize.c b/fs/ext3/resize.c
index 28cfd0b..d16854f 100644
--- a/fs/ext3/resize.c
+++ b/fs/ext3/resize.c
@@ -579,6 +579,8 @@ static int reserve_backup_gdb(handle_t *handle, struct inode *inode,
 		goto exit_free;
 	}
 
+	printk("gdb_count = %d; mod is %d\n", EXT3_SB(sb)->s_gdb_count,
+	       (EXT3_SB(sb)->s_gdb_count % EXT3_ADDR_PER_BLOCK(sb)));
 	blk = EXT3_SB(sb)->s_sbh->b_blocknr + 1 + EXT3_SB(sb)->s_gdb_count;
 	data = (__le32 *)dind->b_data + EXT3_SB(sb)->s_gdb_count;
 	end = (__le32 *)dind->b_data + EXT3_ADDR_PER_BLOCK(sb);
@@ -599,6 +601,7 @@ static int reserve_backup_gdb(handle_t *handle, struct inode *inode,
 			err = -EIO;
 			goto exit_bh;
 		}
+		printk("Checking primary[%d] block %lu\n", res, blk);
 		if ((gdbackups = verify_reserved_gdb(sb, primary[res])) < 0) {
 			brelse(primary[res]);
 			err = gdbackups;
@@ -767,6 +770,9 @@ int ext3_group_add(struct super_block *sb, struct ext3_new_group_data *input)
 
 	gdb_num = input->group / EXT3_DESC_PER_BLOCK(sb);
 	gdb_off = input->group % EXT3_DESC_PER_BLOCK(sb);
+	printk("ext3 group add %lu (num %d, offset %d has_super %d, reserved_gdb %d)\n", 
+	       input->group, gdb_num, gdb_off, ext3_bg_has_super(sb, input->group),
+		reserved_gdb);
 
 	if (gdb_off == 0 && !EXT3_HAS_RO_COMPAT_FEATURE(sb,
 					EXT3_FEATURE_RO_COMPAT_SPARSE_SUPER)) {
diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
index c9900aa..a413336 100644
--- a/fs/ext4/mballoc.c
+++ b/fs/ext4/mballoc.c
@@ -2444,6 +2444,7 @@ int ext4_mb_release(struct super_block *sb)
 		return 0;
 
 	/* release freed, non-committed blocks */
+	printk("mb_release 10\n");
 	spin_lock(&sbi->s_md_lock);
 	list_splice_init(&sbi->s_closed_transaction,
 			&sbi->s_committed_transaction);
@@ -2452,8 +2453,10 @@ int ext4_mb_release(struct super_block *sb)
 	spin_unlock(&sbi->s_md_lock);
 	ext4_mb_free_committed_blocks(sb);
 
+	printk("mb_release 12\n");
 	if (sbi->s_group_info) {
 		for (i = 0; i < sbi->s_groups_count; i++) {
+			printk("Group %d...\n", i);
 			grinfo = ext4_get_group_info(sb, i);
 #ifdef DOUBLE_CHECK
 			kfree(grinfo->bb_bitmap);
@@ -2463,6 +2466,7 @@ int ext4_mb_release(struct super_block *sb)
 			ext4_unlock_group(sb, i);
 			kfree(grinfo);
 		}
+		printk("mb_release 14\n");
 		num_meta_group_infos = (sbi->s_groups_count +
 				EXT4_DESC_PER_BLOCK(sb) - 1) >>
 			EXT4_DESC_PER_BLOCK_BITS(sb);
@@ -2470,6 +2474,7 @@ int ext4_mb_release(struct super_block *sb)
 			kfree(sbi->s_group_info[i]);
 		kfree(sbi->s_group_info);
 	}
+	printk("mb_release 20\n");
 	kfree(sbi->s_mb_offsets);
 	kfree(sbi->s_mb_maxs);
 	if (sbi->s_buddy_cache)
@@ -2498,10 +2503,12 @@ int ext4_mb_release(struct super_block *sb)
 				atomic_read(&sbi->s_mb_discarded));
 	}
 
+	printk("mb_release 30\n");
 	kfree(sbi->s_locality_groups);
 
 	ext4_mb_history_release(sb);
 	ext4_mb_destroy_per_dev_proc(sb);
+	printk("mb_release 40\n");
 
 	return 0;
 }
diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index 9ecb92f..3b6c496 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -369,11 +369,11 @@ static int verify_reserved_gdb(struct super_block *sb,
 		    grp * EXT4_BLOCKS_PER_GROUP(sb) + blk){
 			ext4_warning(sb, __func__,
 				     "reserved GDT %llu"
-				     " missing grp %d (%llu)",
+				     " missing grp %d (%llu != %lu)",
 				     blk, grp,
 				     grp *
-				     (ext4_fsblk_t)EXT4_BLOCKS_PER_GROUP(sb) +
-				     blk);
+				     (ext4_fsblk_t)EXT4_BLOCKS_PER_GROUP(sb) + blk,
+				     le32_to_cpu(*(p-1)));
 			return -EINVAL;
 		}
 		if (++gdbackups > EXT4_ADDR_PER_BLOCK(sb))
@@ -562,6 +562,8 @@ static int reserve_backup_gdb(handle_t *handle, struct inode *inode,
 		goto exit_free;
 	}
 
+	printk("gdb_count = %d; mod is %d\n", EXT4_SB(sb)->s_gdb_count,
+	       (EXT4_SB(sb)->s_gdb_count % EXT4_ADDR_PER_BLOCK(sb)));
 	blk = EXT4_SB(sb)->s_sbh->b_blocknr + 1 + EXT4_SB(sb)->s_gdb_count;
 	data = (__le32 *)dind->b_data + (EXT4_SB(sb)->s_gdb_count %
 					 EXT4_ADDR_PER_BLOCK(sb));
@@ -583,6 +585,7 @@ static int reserve_backup_gdb(handle_t *handle, struct inode *inode,
 			err = -EIO;
 			goto exit_bh;
 		}
+		printk("Checking primary[%d] block %lu\n", res, blk);
 		if ((gdbackups = verify_reserved_gdb(sb, primary[res])) < 0) {
 			brelse(primary[res]);
 			err = gdbackups;
@@ -751,6 +754,9 @@ int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input)
 
 	gdb_num = input->group / EXT4_DESC_PER_BLOCK(sb);
 	gdb_off = input->group % EXT4_DESC_PER_BLOCK(sb);
+	printk("ext4 group add %lu (num %d, offset %d has_super %d, reserved_gdb %d)\n", 
+	       input->group, gdb_num, gdb_off, ext4_bg_has_super(sb, input->group),
+		reserved_gdb);
 
 	if (gdb_off == 0 && !EXT4_HAS_RO_COMPAT_FEATURE(sb,
 					EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER)) {
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index cb96f12..508ad19 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -502,11 +502,16 @@ static void ext4_put_super (struct super_block * sb)
 	struct ext4_super_block *es = sbi->s_es;
 	int i;
 
+	printk("ext4_put_super: Calling mb_release\n");
 	ext4_mb_release(sb);
+	printk("ext4_put_super: Calling ext_release\n");
 	ext4_ext_release(sb);
+	printk("ext4_put_super: Calling xattr_put_super\n");
 	ext4_xattr_put_super(sb);
+	printk("ext4_put_super: Calling journal_destroy\n");
 	jbd2_journal_destroy(sbi->s_journal);
 	if (!(sb->s_flags & MS_RDONLY)) {
+		printk("Clearing recovery flag\n");
 		EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
 		es->s_state = cpu_to_le16(sbi->s_mount_state);
 		BUFFER_TRACE(sbi->s_sbh, "marking dirty");
@@ -514,9 +519,11 @@ static void ext4_put_super (struct super_block * sb)
 		ext4_commit_super(sb, es, 1);
 	}
 
+	printk("ext4_put_super: Releasing group descriptors\n");
 	for (i = 0; i < sbi->s_gdb_count; i++)
 		brelse(sbi->s_group_desc[i]);
 	kfree(sbi->s_group_desc);
+	printk("ext4_put_super: Releasing per_cpu counters\n");
 	percpu_counter_destroy(&sbi->s_freeblocks_counter);
 	percpu_counter_destroy(&sbi->s_freeinodes_counter);
 	percpu_counter_destroy(&sbi->s_dirs_counter);
@@ -530,10 +537,12 @@ static void ext4_put_super (struct super_block * sb)
 	 * isn't empty.  The on-disk one can be non-empty if we've
 	 * detected an error and taken the fs readonly, but the
 	 * in-memory list had better be clean by this point. */
+	printk("ext4_put_super: Checking in-memory orphan list\n");
 	if (!list_empty(&sbi->s_orphan))
 		dump_orphan_list(sb, sbi);
 	J_ASSERT(list_empty(&sbi->s_orphan));
 
+	printk("ext4_put_super: Invalidating buffers\n");
 	invalidate_bdev(sb->s_bdev);
 	if (sbi->journal_bdev && sbi->journal_bdev != sb->s_bdev) {
 		/*
@@ -545,8 +554,10 @@ static void ext4_put_super (struct super_block * sb)
 		invalidate_bdev(sbi->journal_bdev);
 		ext4_blkdev_remove(sbi);
 	}
+	printk("ext4_put_super: Freeing fs_info\n");
 	sb->s_fs_info = NULL;
 	kfree(sbi);
+	printk("ext4_put_super: Finished!\n");
 	return;
 }