tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

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>

Theodore Ts'o 9924a92a 722887dd

+111 -69
+3 -2
fs/ext4/acl.c
··· 324 324 if (error) 325 325 return error; 326 326 retry: 327 - handle = ext4_journal_start(inode, 327 + handle = ext4_journal_start(inode, EXT4_HT_XATTR, 328 328 EXT4_DATA_TRANS_BLOCKS(inode->i_sb)); 329 329 if (IS_ERR(handle)) { 330 330 error = PTR_ERR(handle); ··· 422 422 acl = NULL; 423 423 424 424 retry: 425 - handle = ext4_journal_start(inode, EXT4_DATA_TRANS_BLOCKS(inode->i_sb)); 425 + handle = ext4_journal_start(inode, EXT4_HT_XATTR, 426 + EXT4_DATA_TRANS_BLOCKS(inode->i_sb)); 426 427 if (IS_ERR(handle)) { 427 428 error = PTR_ERR(handle); 428 429 goto release_and_out;
+3 -2
fs/ext4/ext4_jbd2.c
··· 38 38 /* 39 39 * Wrappers for jbd2_journal_start/end. 40 40 */ 41 - handle_t *ext4_journal_start_sb(struct super_block *sb, int nblocks) 41 + handle_t *__ext4_journal_start_sb(struct super_block *sb, unsigned int line, 42 + int type, int nblocks) 42 43 { 43 44 journal_t *journal; 44 45 ··· 60 59 ext4_abort(sb, "Detected aborted journal"); 61 60 return ERR_PTR(-EROFS); 62 61 } 63 - return jbd2_journal_start(journal, nblocks); 62 + return jbd2__journal_start(journal, nblocks, GFP_NOFS, type, line); 64 63 } 65 64 66 65 int __ext4_journal_stop(const char *where, unsigned int line, handle_t *handle)
+28 -3
fs/ext4/ext4_jbd2.h
··· 110 110 #define EXT4_MAXQUOTAS_INIT_BLOCKS(sb) (MAXQUOTAS*EXT4_QUOTA_INIT_BLOCKS(sb)) 111 111 #define EXT4_MAXQUOTAS_DEL_BLOCKS(sb) (MAXQUOTAS*EXT4_QUOTA_DEL_BLOCKS(sb)) 112 112 113 + /* 114 + * Ext4 handle operation types -- for logging purposes 115 + */ 116 + #define EXT4_HT_MISC 0 117 + #define EXT4_HT_INODE 1 118 + #define EXT4_HT_WRITE_PAGE 2 119 + #define EXT4_HT_MAP_BLOCKS 3 120 + #define EXT4_HT_DIR 4 121 + #define EXT4_HT_TRUNCATE 5 122 + #define EXT4_HT_QUOTA 6 123 + #define EXT4_HT_RESIZE 7 124 + #define EXT4_HT_MIGRATE 8 125 + #define EXT4_HT_MOVE_EXTENTS 9 126 + #define EXT4_HT_XATTR 10 127 + #define EXT4_HT_MAX 11 128 + 113 129 /** 114 130 * struct ext4_journal_cb_entry - Base structure for callback information. 115 131 * ··· 250 234 #define ext4_handle_dirty_super(handle, sb) \ 251 235 __ext4_handle_dirty_super(__func__, __LINE__, (handle), (sb)) 252 236 253 - handle_t *ext4_journal_start_sb(struct super_block *sb, int nblocks); 237 + handle_t *__ext4_journal_start_sb(struct super_block *sb, unsigned int line, 238 + int type, int nblocks); 254 239 int __ext4_journal_stop(const char *where, unsigned int line, handle_t *handle); 255 240 256 241 #define EXT4_NOJOURNAL_MAX_REF_COUNT ((unsigned long) 4096) ··· 285 268 return 1; 286 269 } 287 270 288 - static inline handle_t *ext4_journal_start(struct inode *inode, int nblocks) 271 + #define ext4_journal_start_sb(sb, type, nblocks) \ 272 + __ext4_journal_start_sb((sb), __LINE__, (type), (nblocks)) 273 + 274 + #define ext4_journal_start(inode, type, nblocks) \ 275 + __ext4_journal_start((inode), __LINE__, (type), (nblocks)) 276 + 277 + static inline handle_t *__ext4_journal_start(struct inode *inode, 278 + unsigned int line, int type, 279 + int nblocks) 289 280 { 290 - return ext4_journal_start_sb(inode->i_sb, nblocks); 281 + return __ext4_journal_start_sb(inode->i_sb, line, type, nblocks); 291 282 } 292 283 293 284 #define ext4_journal_stop(handle) \
+6 -5
fs/ext4/extents.c
··· 2656 2656 ext_debug("truncate since %u to %u\n", start, end); 2657 2657 2658 2658 /* probably first extent we're gonna free will be last in block */ 2659 - handle = ext4_journal_start(inode, depth + 1); 2659 + handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, depth + 1); 2660 2660 if (IS_ERR(handle)) 2661 2661 return PTR_ERR(handle); 2662 2662 ··· 4287 4287 * probably first extent we're gonna free will be last in block 4288 4288 */ 4289 4289 err = ext4_writepage_trans_blocks(inode); 4290 - handle = ext4_journal_start(inode, err); 4290 + handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, err); 4291 4291 if (IS_ERR(handle)) 4292 4292 return; 4293 4293 ··· 4454 4454 while (ret >= 0 && ret < max_blocks) { 4455 4455 map.m_lblk = map.m_lblk + ret; 4456 4456 map.m_len = max_blocks = max_blocks - ret; 4457 - handle = ext4_journal_start(inode, credits); 4457 + handle = ext4_journal_start(inode, EXT4_HT_MAP_BLOCKS, 4458 + credits); 4458 4459 if (IS_ERR(handle)) { 4459 4460 ret = PTR_ERR(handle); 4460 4461 break; ··· 4533 4532 while (ret >= 0 && ret < max_blocks) { 4534 4533 map.m_lblk += ret; 4535 4534 map.m_len = (max_blocks -= ret); 4536 - handle = ext4_journal_start(inode, credits); 4535 + handle = ext4_journal_start(inode, EXT4_HT_MAP_BLOCKS, credits); 4537 4536 if (IS_ERR(handle)) { 4538 4537 ret = PTR_ERR(handle); 4539 4538 break; ··· 4711 4710 inode_dio_wait(inode); 4712 4711 4713 4712 credits = ext4_writepage_trans_blocks(inode); 4714 - handle = ext4_journal_start(inode, credits); 4713 + handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, credits); 4715 4714 if (IS_ERR(handle)) { 4716 4715 err = PTR_ERR(handle); 4717 4716 goto out_dio;
+1 -1
fs/ext4/file.c
··· 240 240 handle_t *handle; 241 241 int err; 242 242 243 - handle = ext4_journal_start_sb(sb, 1); 243 + handle = ext4_journal_start_sb(sb, EXT4_HT_MISC, 1); 244 244 if (IS_ERR(handle)) 245 245 return PTR_ERR(handle); 246 246 err = ext4_journal_get_write_access(handle, sbi->s_sbh);
+1 -1
fs/ext4/ialloc.c
··· 1137 1137 if (gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_ZEROED)) 1138 1138 goto out; 1139 1139 1140 - handle = ext4_journal_start_sb(sb, 1); 1140 + handle = ext4_journal_start_sb(sb, EXT4_HT_MISC, 1); 1141 1141 if (IS_ERR(handle)) { 1142 1142 ret = PTR_ERR(handle); 1143 1143 goto out;
+4 -3
fs/ext4/indirect.c
··· 791 791 792 792 if (final_size > inode->i_size) { 793 793 /* Credits for sb + inode write */ 794 - handle = ext4_journal_start(inode, 2); 794 + handle = ext4_journal_start(inode, EXT4_HT_INODE, 2); 795 795 if (IS_ERR(handle)) { 796 796 ret = PTR_ERR(handle); 797 797 goto out; ··· 851 851 int err; 852 852 853 853 /* Credits for sb + inode write */ 854 - handle = ext4_journal_start(inode, 2); 854 + handle = ext4_journal_start(inode, EXT4_HT_INODE, 2); 855 855 if (IS_ERR(handle)) { 856 856 /* This is really bad luck. We've written the data 857 857 * but cannot extend i_size. Bail out and pretend ··· 950 950 { 951 951 handle_t *result; 952 952 953 - result = ext4_journal_start(inode, ext4_blocks_for_truncate(inode)); 953 + result = ext4_journal_start(inode, EXT4_HT_TRUNCATE, 954 + ext4_blocks_for_truncate(inode)); 954 955 if (!IS_ERR(result)) 955 956 return result; 956 957
+5 -5
fs/ext4/inline.c
··· 545 545 return ret; 546 546 547 547 retry: 548 - handle = ext4_journal_start(inode, needed_blocks); 548 + handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, needed_blocks); 549 549 if (IS_ERR(handle)) { 550 550 ret = PTR_ERR(handle); 551 551 handle = NULL; ··· 657 657 * The possible write could happen in the inode, 658 658 * so try to reserve the space in inode first. 659 659 */ 660 - handle = ext4_journal_start(inode, 1); 660 + handle = ext4_journal_start(inode, EXT4_HT_INODE, 1); 661 661 if (IS_ERR(handle)) { 662 662 ret = PTR_ERR(handle); 663 663 handle = NULL; ··· 853 853 if (ret) 854 854 return ret; 855 855 856 - handle = ext4_journal_start(inode, 1); 856 + handle = ext4_journal_start(inode, EXT4_HT_INODE, 1); 857 857 if (IS_ERR(handle)) { 858 858 ret = PTR_ERR(handle); 859 859 handle = NULL; ··· 1770 1770 1771 1771 1772 1772 needed_blocks = ext4_writepage_trans_blocks(inode); 1773 - handle = ext4_journal_start(inode, needed_blocks); 1773 + handle = ext4_journal_start(inode, EXT4_HT_INODE, needed_blocks); 1774 1774 if (IS_ERR(handle)) 1775 1775 return; 1776 1776 ··· 1862 1862 if (error) 1863 1863 return error; 1864 1864 1865 - handle = ext4_journal_start(inode, needed_blocks); 1865 + handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, needed_blocks); 1866 1866 if (IS_ERR(handle)) { 1867 1867 error = PTR_ERR(handle); 1868 1868 goto out_free;
+20 -13
fs/ext4/inode.c
··· 234 234 * protection against it 235 235 */ 236 236 sb_start_intwrite(inode->i_sb); 237 - handle = ext4_journal_start(inode, ext4_blocks_for_truncate(inode)+3); 237 + handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, 238 + ext4_blocks_for_truncate(inode)+3); 238 239 if (IS_ERR(handle)) { 239 240 ext4_std_error(inode->i_sb, PTR_ERR(handle)); 240 241 /* ··· 657 656 if (map.m_len > DIO_MAX_BLOCKS) 658 657 map.m_len = DIO_MAX_BLOCKS; 659 658 dio_credits = ext4_chunk_trans_blocks(inode, map.m_len); 660 - handle = ext4_journal_start(inode, dio_credits); 659 + handle = ext4_journal_start(inode, EXT4_HT_MAP_BLOCKS, 660 + dio_credits); 661 661 if (IS_ERR(handle)) { 662 662 ret = PTR_ERR(handle); 663 663 return ret; ··· 883 881 } 884 882 885 883 retry: 886 - handle = ext4_journal_start(inode, needed_blocks); 884 + handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, needed_blocks); 887 885 if (IS_ERR(handle)) { 888 886 ret = PTR_ERR(handle); 889 887 goto out; ··· 1883 1881 * references to buffers so we are safe */ 1884 1882 unlock_page(page); 1885 1883 1886 - handle = ext4_journal_start(inode, ext4_writepage_trans_blocks(inode)); 1884 + handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, 1885 + ext4_writepage_trans_blocks(inode)); 1887 1886 if (IS_ERR(handle)) { 1888 1887 ret = PTR_ERR(handle); 1889 1888 goto out; ··· 2315 2312 needed_blocks = ext4_da_writepages_trans_blocks(inode); 2316 2313 2317 2314 /* start a new transaction*/ 2318 - handle = ext4_journal_start(inode, needed_blocks); 2315 + handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, 2316 + needed_blocks); 2319 2317 if (IS_ERR(handle)) { 2320 2318 ret = PTR_ERR(handle); 2321 2319 ext4_msg(inode->i_sb, KERN_CRIT, "%s: jbd2_start: " ··· 2472 2468 * to journalling the i_disksize update if writes to the end 2473 2469 * of file which has an already mapped buffer. 2474 2470 */ 2475 - handle = ext4_journal_start(inode, 1); 2471 + handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, 1); 2476 2472 if (IS_ERR(handle)) { 2477 2473 ret = PTR_ERR(handle); 2478 2474 goto out; ··· 4219 4215 4220 4216 /* (user+group)*(old+new) structure, inode write (sb, 4221 4217 * inode block, ? - but truncate inode update has it) */ 4222 - handle = ext4_journal_start(inode, (EXT4_MAXQUOTAS_INIT_BLOCKS(inode->i_sb)+ 4223 - EXT4_MAXQUOTAS_DEL_BLOCKS(inode->i_sb))+3); 4218 + handle = ext4_journal_start(inode, EXT4_HT_QUOTA, 4219 + (EXT4_MAXQUOTAS_INIT_BLOCKS(inode->i_sb) + 4220 + EXT4_MAXQUOTAS_DEL_BLOCKS(inode->i_sb)) + 3); 4224 4221 if (IS_ERR(handle)) { 4225 4222 error = PTR_ERR(handle); 4226 4223 goto err_out; ··· 4256 4251 (attr->ia_size < inode->i_size)) { 4257 4252 handle_t *handle; 4258 4253 4259 - handle = ext4_journal_start(inode, 3); 4254 + handle = ext4_journal_start(inode, EXT4_HT_INODE, 3); 4260 4255 if (IS_ERR(handle)) { 4261 4256 error = PTR_ERR(handle); 4262 4257 goto err_out; ··· 4276 4271 attr->ia_size); 4277 4272 if (error) { 4278 4273 /* Do as much error cleanup as possible */ 4279 - handle = ext4_journal_start(inode, 3); 4274 + handle = ext4_journal_start(inode, 4275 + EXT4_HT_INODE, 3); 4280 4276 if (IS_ERR(handle)) { 4281 4277 ext4_orphan_del(NULL, inode); 4282 4278 goto err_out; ··· 4618 4612 { 4619 4613 handle_t *handle; 4620 4614 4621 - handle = ext4_journal_start(inode, 2); 4615 + handle = ext4_journal_start(inode, EXT4_HT_INODE, 2); 4622 4616 if (IS_ERR(handle)) 4623 4617 goto out; 4624 4618 ··· 4719 4713 4720 4714 /* Finally we can mark the inode as dirty. */ 4721 4715 4722 - handle = ext4_journal_start(inode, 1); 4716 + handle = ext4_journal_start(inode, EXT4_HT_INODE, 1); 4723 4717 if (IS_ERR(handle)) 4724 4718 return PTR_ERR(handle); 4725 4719 ··· 4797 4791 else 4798 4792 get_block = ext4_get_block; 4799 4793 retry_alloc: 4800 - handle = ext4_journal_start(inode, ext4_writepage_trans_blocks(inode)); 4794 + handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, 4795 + ext4_writepage_trans_blocks(inode)); 4801 4796 if (IS_ERR(handle)) { 4802 4797 ret = VM_FAULT_SIGBUS; 4803 4798 goto out;
+2 -2
fs/ext4/ioctl.c
··· 104 104 } else if (oldflags & EXT4_EOFBLOCKS_FL) 105 105 ext4_truncate(inode); 106 106 107 - handle = ext4_journal_start(inode, 1); 107 + handle = ext4_journal_start(inode, EXT4_HT_INODE, 1); 108 108 if (IS_ERR(handle)) { 109 109 err = PTR_ERR(handle); 110 110 goto flags_out; ··· 173 173 } 174 174 175 175 mutex_lock(&inode->i_mutex); 176 - handle = ext4_journal_start(inode, 1); 176 + handle = ext4_journal_start(inode, EXT4_HT_INODE, 1); 177 177 if (IS_ERR(handle)) { 178 178 err = PTR_ERR(handle); 179 179 goto unlock_out;
+2 -2
fs/ext4/migrate.c
··· 456 456 */ 457 457 return retval; 458 458 459 - handle = ext4_journal_start(inode, 459 + handle = ext4_journal_start(inode, EXT4_HT_MIGRATE, 460 460 EXT4_DATA_TRANS_BLOCKS(inode->i_sb) + 461 461 EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3 + 462 462 EXT4_MAXQUOTAS_INIT_BLOCKS(inode->i_sb) ··· 507 507 ext4_set_inode_state(inode, EXT4_STATE_EXT_MIGRATE); 508 508 up_read((&EXT4_I(inode)->i_data_sem)); 509 509 510 - handle = ext4_journal_start(inode, 1); 510 + handle = ext4_journal_start(inode, EXT4_HT_MIGRATE, 1); 511 511 if (IS_ERR(handle)) { 512 512 /* 513 513 * It is impossible to update on-disk structures without
+1 -1
fs/ext4/move_extent.c
··· 923 923 again: 924 924 *err = 0; 925 925 jblocks = ext4_writepage_trans_blocks(orig_inode) * 2; 926 - handle = ext4_journal_start(orig_inode, jblocks); 926 + handle = ext4_journal_start(orig_inode, EXT4_HT_MOVE_EXTENTS, jblocks); 927 927 if (IS_ERR(handle)) { 928 928 *err = PTR_ERR(handle); 929 929 return 0;
+24 -18
fs/ext4/namei.c
··· 2262 2262 dquot_initialize(dir); 2263 2263 2264 2264 retry: 2265 - handle = ext4_journal_start(dir, EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + 2266 - EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3 + 2267 - EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb)); 2265 + handle = ext4_journal_start(dir, EXT4_HT_DIR, 2266 + (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + 2267 + EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3 + 2268 + EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb))); 2268 2269 if (IS_ERR(handle)) 2269 2270 return PTR_ERR(handle); 2270 2271 ··· 2299 2298 dquot_initialize(dir); 2300 2299 2301 2300 retry: 2302 - handle = ext4_journal_start(dir, EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + 2303 - EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3 + 2304 - EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb)); 2301 + handle = ext4_journal_start(dir, EXT4_HT_DIR, 2302 + (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + 2303 + EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3 + 2304 + EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb))); 2305 2305 if (IS_ERR(handle)) 2306 2306 return PTR_ERR(handle); 2307 2307 ··· 2416 2414 dquot_initialize(dir); 2417 2415 2418 2416 retry: 2419 - handle = ext4_journal_start(dir, EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + 2420 - EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3 + 2421 - EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb)); 2417 + handle = ext4_journal_start(dir, EXT4_HT_DIR, 2418 + (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + 2419 + EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3 + 2420 + EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb))); 2422 2421 if (IS_ERR(handle)) 2423 2422 return PTR_ERR(handle); 2424 2423 ··· 2732 2729 dquot_initialize(dir); 2733 2730 dquot_initialize(dentry->d_inode); 2734 2731 2735 - handle = ext4_journal_start(dir, EXT4_DELETE_TRANS_BLOCKS(dir->i_sb)); 2732 + handle = ext4_journal_start(dir, EXT4_HT_DIR, 2733 + EXT4_DELETE_TRANS_BLOCKS(dir->i_sb)); 2736 2734 if (IS_ERR(handle)) 2737 2735 return PTR_ERR(handle); 2738 2736 ··· 2795 2791 dquot_initialize(dir); 2796 2792 dquot_initialize(dentry->d_inode); 2797 2793 2798 - handle = ext4_journal_start(dir, EXT4_DELETE_TRANS_BLOCKS(dir->i_sb)); 2794 + handle = ext4_journal_start(dir, EXT4_HT_DIR, 2795 + EXT4_DELETE_TRANS_BLOCKS(dir->i_sb)); 2799 2796 if (IS_ERR(handle)) 2800 2797 return PTR_ERR(handle); 2801 2798 ··· 2875 2870 EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb); 2876 2871 } 2877 2872 retry: 2878 - handle = ext4_journal_start(dir, credits); 2873 + handle = ext4_journal_start(dir, EXT4_HT_DIR, credits); 2879 2874 if (IS_ERR(handle)) 2880 2875 return PTR_ERR(handle); 2881 2876 ··· 2913 2908 * Now inode is being linked into dir (EXT4_DATA_TRANS_BLOCKS 2914 2909 * + EXT4_INDEX_EXTRA_TRANS_BLOCKS), inode is also modified 2915 2910 */ 2916 - handle = ext4_journal_start(dir, 2911 + handle = ext4_journal_start(dir, EXT4_HT_DIR, 2917 2912 EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + 2918 2913 EXT4_INDEX_EXTRA_TRANS_BLOCKS + 1); 2919 2914 if (IS_ERR(handle)) { ··· 2960 2955 dquot_initialize(dir); 2961 2956 2962 2957 retry: 2963 - handle = ext4_journal_start(dir, EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + 2964 - EXT4_INDEX_EXTRA_TRANS_BLOCKS); 2958 + handle = ext4_journal_start(dir, EXT4_HT_DIR, 2959 + (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + 2960 + EXT4_INDEX_EXTRA_TRANS_BLOCKS)); 2965 2961 if (IS_ERR(handle)) 2966 2962 return PTR_ERR(handle); 2967 2963 ··· 3045 3039 * in separate transaction */ 3046 3040 if (new_dentry->d_inode) 3047 3041 dquot_initialize(new_dentry->d_inode); 3048 - handle = ext4_journal_start(old_dir, 2 * 3049 - EXT4_DATA_TRANS_BLOCKS(old_dir->i_sb) + 3050 - EXT4_INDEX_EXTRA_TRANS_BLOCKS + 2); 3042 + handle = ext4_journal_start(old_dir, EXT4_HT_DIR, 3043 + (2 * EXT4_DATA_TRANS_BLOCKS(old_dir->i_sb) + 3044 + EXT4_INDEX_EXTRA_TRANS_BLOCKS + 2)); 3051 3045 if (IS_ERR(handle)) 3052 3046 return PTR_ERR(handle); 3053 3047
+5 -5
fs/ext4/resize.c
··· 466 466 meta_bg = EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_META_BG); 467 467 468 468 /* This transaction may be extended/restarted along the way */ 469 - handle = ext4_journal_start_sb(sb, EXT4_MAX_TRANS_DATA); 469 + handle = ext4_journal_start_sb(sb, EXT4_HT_RESIZE, EXT4_MAX_TRANS_DATA); 470 470 if (IS_ERR(handle)) 471 471 return PTR_ERR(handle); 472 472 ··· 1031 1031 handle_t *handle; 1032 1032 int err = 0, err2; 1033 1033 1034 - handle = ext4_journal_start_sb(sb, EXT4_MAX_TRANS_DATA); 1034 + handle = ext4_journal_start_sb(sb, EXT4_HT_RESIZE, EXT4_MAX_TRANS_DATA); 1035 1035 if (IS_ERR(handle)) { 1036 1036 group = 1; 1037 1037 err = PTR_ERR(handle); ··· 1412 1412 * modify each of the reserved GDT dindirect blocks. 1413 1413 */ 1414 1414 credit = flex_gd->count * 4 + reserved_gdb; 1415 - handle = ext4_journal_start_sb(sb, credit); 1415 + handle = ext4_journal_start_sb(sb, EXT4_HT_RESIZE, credit); 1416 1416 if (IS_ERR(handle)) { 1417 1417 err = PTR_ERR(handle); 1418 1418 goto exit; ··· 1624 1624 /* We will update the superblock, one block bitmap, and 1625 1625 * one group descriptor via ext4_group_add_blocks(). 1626 1626 */ 1627 - handle = ext4_journal_start_sb(sb, 3); 1627 + handle = ext4_journal_start_sb(sb, EXT4_HT_RESIZE, 3); 1628 1628 if (IS_ERR(handle)) { 1629 1629 err = PTR_ERR(handle); 1630 1630 ext4_warning(sb, "error %d on journal start", err); ··· 1788 1788 credits += 3; /* block bitmap, bg descriptor, resize inode */ 1789 1789 } 1790 1790 1791 - handle = ext4_journal_start_sb(sb, credits); 1791 + handle = ext4_journal_start_sb(sb, EXT4_HT_RESIZE, credits); 1792 1792 if (IS_ERR(handle)) 1793 1793 return PTR_ERR(handle); 1794 1794
+5 -5
fs/ext4/super.c
··· 4762 4762 struct inode *inode; 4763 4763 4764 4764 inode = dquot_to_inode(dquot); 4765 - handle = ext4_journal_start(inode, 4765 + handle = ext4_journal_start(inode, EXT4_HT_QUOTA, 4766 4766 EXT4_QUOTA_TRANS_BLOCKS(dquot->dq_sb)); 4767 4767 if (IS_ERR(handle)) 4768 4768 return PTR_ERR(handle); ··· 4778 4778 int ret, err; 4779 4779 handle_t *handle; 4780 4780 4781 - handle = ext4_journal_start(dquot_to_inode(dquot), 4781 + handle = ext4_journal_start(dquot_to_inode(dquot), EXT4_HT_QUOTA, 4782 4782 EXT4_QUOTA_INIT_BLOCKS(dquot->dq_sb)); 4783 4783 if (IS_ERR(handle)) 4784 4784 return PTR_ERR(handle); ··· 4794 4794 int ret, err; 4795 4795 handle_t *handle; 4796 4796 4797 - handle = ext4_journal_start(dquot_to_inode(dquot), 4797 + handle = ext4_journal_start(dquot_to_inode(dquot), EXT4_HT_QUOTA, 4798 4798 EXT4_QUOTA_DEL_BLOCKS(dquot->dq_sb)); 4799 4799 if (IS_ERR(handle)) { 4800 4800 /* Release dquot anyway to avoid endless cycle in dqput() */ ··· 4826 4826 handle_t *handle; 4827 4827 4828 4828 /* Data block + inode block */ 4829 - handle = ext4_journal_start(sb->s_root->d_inode, 2); 4829 + handle = ext4_journal_start(sb->s_root->d_inode, EXT4_HT_QUOTA, 2); 4830 4830 if (IS_ERR(handle)) 4831 4831 return PTR_ERR(handle); 4832 4832 ret = dquot_commit_info(sb, type); ··· 4972 4972 4973 4973 /* Update modification times of quota files when userspace can 4974 4974 * start looking at them */ 4975 - handle = ext4_journal_start(inode, 1); 4975 + handle = ext4_journal_start(inode, EXT4_HT_QUOTA, 1); 4976 4976 if (IS_ERR(handle)) 4977 4977 goto out; 4978 4978 inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+1 -1
fs/ext4/xattr.c
··· 1175 1175 if (ext4_has_inline_data(inode)) 1176 1176 credits += ext4_writepage_trans_blocks(inode) + 1; 1177 1177 1178 - handle = ext4_journal_start(inode, credits); 1178 + handle = ext4_journal_start(inode, EXT4_HT_XATTR, credits); 1179 1179 if (IS_ERR(handle)) { 1180 1180 error = PTR_ERR(handle); 1181 1181 } else {