Merge tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4

+10

fs/ext4/ext4.h

··· 268 268 /* Translate # of blks to # of clusters */ 269 269 #define EXT4_NUM_B2C(sbi, blks) (((blks) + (sbi)->s_cluster_ratio - 1) >> \ 270 270 (sbi)->s_cluster_bits) 271 + /* Mask out the low bits to get the starting block of the cluster */ 272 + #define EXT4_PBLK_CMASK(s, pblk) ((pblk) & \ 273 + ~((ext4_fsblk_t) (s)->s_cluster_ratio - 1)) 274 + #define EXT4_LBLK_CMASK(s, lblk) ((lblk) & \ 275 + ~((ext4_lblk_t) (s)->s_cluster_ratio - 1)) 276 + /* Get the cluster offset */ 277 + #define EXT4_PBLK_COFF(s, pblk) ((pblk) & \ 278 + ((ext4_fsblk_t) (s)->s_cluster_ratio - 1)) 279 + #define EXT4_LBLK_COFF(s, lblk) ((lblk) & \ 280 + ((ext4_lblk_t) (s)->s_cluster_ratio - 1)) 271 281 272 282 /* 273 283 * Structure of a blocks group descriptor

+9

fs/ext4/ext4_jbd2.c

··· 259 259 if (WARN_ON_ONCE(err)) { 260 260 ext4_journal_abort_handle(where, line, __func__, bh, 261 261 handle, err); 262 + ext4_error_inode(inode, where, line, 263 + bh->b_blocknr, 264 + "journal_dirty_metadata failed: " 265 + "handle type %u started at line %u, " 266 + "credits %u/%u, errcode %d", 267 + handle->h_type, 268 + handle->h_line_no, 269 + handle->h_requested_credits, 270 + handle->h_buffer_credits, err); 262 271 } 263 272 } else { 264 273 if (inode)

+30 -15

fs/ext4/extents.c

··· 360 360 { 361 361 ext4_fsblk_t block = ext4_ext_pblock(ext); 362 362 int len = ext4_ext_get_actual_len(ext); 363 + ext4_lblk_t lblock = le32_to_cpu(ext->ee_block); 364 + ext4_lblk_t last = lblock + len - 1; 363 365 364 - if (len == 0) 366 + if (lblock > last) 365 367 return 0; 366 368 return ext4_data_block_valid(EXT4_SB(inode->i_sb), block, len); 367 369 } ··· 389 387 if (depth == 0) { 390 388 /* leaf entries */ 391 389 struct ext4_extent *ext = EXT_FIRST_EXTENT(eh); 390 + struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es; 391 + ext4_fsblk_t pblock = 0; 392 + ext4_lblk_t lblock = 0; 393 + ext4_lblk_t prev = 0; 394 + int len = 0; 392 395 while (entries) { 393 396 if (!ext4_valid_extent(inode, ext)) 394 397 return 0; 398 + 399 + /* Check for overlapping extents */ 400 + lblock = le32_to_cpu(ext->ee_block); 401 + len = ext4_ext_get_actual_len(ext); 402 + if ((lblock <= prev) && prev) { 403 + pblock = ext4_ext_pblock(ext); 404 + es->s_last_error_block = cpu_to_le64(pblock); 405 + return 0; 406 + } 395 407 ext++; 396 408 entries--; 409 + prev = lblock + len - 1; 397 410 } 398 411 } else { 399 412 struct ext4_extent_idx *ext_idx = EXT_FIRST_INDEX(eh); ··· 1851 1834 depth = ext_depth(inode); 1852 1835 if (!path[depth].p_ext) 1853 1836 goto out; 1854 - b2 = le32_to_cpu(path[depth].p_ext->ee_block); 1855 - b2 &= ~(sbi->s_cluster_ratio - 1); 1837 + b2 = EXT4_LBLK_CMASK(sbi, le32_to_cpu(path[depth].p_ext->ee_block)); 1856 1838 1857 1839 /* 1858 1840 * get the next allocated block if the extent in the path ··· 1861 1845 b2 = ext4_ext_next_allocated_block(path); 1862 1846 if (b2 == EXT_MAX_BLOCKS) 1863 1847 goto out; 1864 - b2 &= ~(sbi->s_cluster_ratio - 1); 1848 + b2 = EXT4_LBLK_CMASK(sbi, b2); 1865 1849 } 1866 1850 1867 1851 /* check for wrap through zero on extent logical start block*/ ··· 2520 2504 * extent, we have to mark the cluster as used (store negative 2521 2505 * cluster number in partial_cluster). 2522 2506 */ 2523 - unaligned = pblk & (sbi->s_cluster_ratio - 1); 2507 + unaligned = EXT4_PBLK_COFF(sbi, pblk); 2524 2508 if (unaligned && (ee_len == num) && 2525 2509 (*partial_cluster != -((long long)EXT4_B2C(sbi, pblk)))) 2526 2510 *partial_cluster = EXT4_B2C(sbi, pblk); ··· 2614 2598 * accidentally freeing it later on 2615 2599 */ 2616 2600 pblk = ext4_ext_pblock(ex); 2617 - if (pblk & (sbi->s_cluster_ratio - 1)) 2601 + if (EXT4_PBLK_COFF(sbi, pblk)) 2618 2602 *partial_cluster = 2619 2603 -((long long)EXT4_B2C(sbi, pblk)); 2620 2604 ex--; ··· 3769 3753 { 3770 3754 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 3771 3755 ext4_lblk_t lblk_start, lblk_end; 3772 - lblk_start = lblk & (~(sbi->s_cluster_ratio - 1)); 3756 + lblk_start = EXT4_LBLK_CMASK(sbi, lblk); 3773 3757 lblk_end = lblk_start + sbi->s_cluster_ratio - 1; 3774 3758 3775 3759 return ext4_find_delalloc_range(inode, lblk_start, lblk_end); ··· 3828 3812 trace_ext4_get_reserved_cluster_alloc(inode, lblk_start, num_blks); 3829 3813 3830 3814 /* Check towards left side */ 3831 - c_offset = lblk_start & (sbi->s_cluster_ratio - 1); 3815 + c_offset = EXT4_LBLK_COFF(sbi, lblk_start); 3832 3816 if (c_offset) { 3833 - lblk_from = lblk_start & (~(sbi->s_cluster_ratio - 1)); 3817 + lblk_from = EXT4_LBLK_CMASK(sbi, lblk_start); 3834 3818 lblk_to = lblk_from + c_offset - 1; 3835 3819 3836 3820 if (ext4_find_delalloc_range(inode, lblk_from, lblk_to)) ··· 3838 3822 } 3839 3823 3840 3824 /* Now check towards right. */ 3841 - c_offset = (lblk_start + num_blks) & (sbi->s_cluster_ratio - 1); 3825 + c_offset = EXT4_LBLK_COFF(sbi, lblk_start + num_blks); 3842 3826 if (allocated_clusters && c_offset) { 3843 3827 lblk_from = lblk_start + num_blks; 3844 3828 lblk_to = lblk_from + (sbi->s_cluster_ratio - c_offset) - 1; ··· 4046 4030 struct ext4_ext_path *path) 4047 4031 { 4048 4032 struct ext4_sb_info *sbi = EXT4_SB(sb); 4049 - ext4_lblk_t c_offset = map->m_lblk & (sbi->s_cluster_ratio-1); 4033 + ext4_lblk_t c_offset = EXT4_LBLK_COFF(sbi, map->m_lblk); 4050 4034 ext4_lblk_t ex_cluster_start, ex_cluster_end; 4051 4035 ext4_lblk_t rr_cluster_start; 4052 4036 ext4_lblk_t ee_block = le32_to_cpu(ex->ee_block); ··· 4064 4048 (rr_cluster_start == ex_cluster_start)) { 4065 4049 if (rr_cluster_start == ex_cluster_end) 4066 4050 ee_start += ee_len - 1; 4067 - map->m_pblk = (ee_start & ~(sbi->s_cluster_ratio - 1)) + 4068 - c_offset; 4051 + map->m_pblk = EXT4_PBLK_CMASK(sbi, ee_start) + c_offset; 4069 4052 map->m_len = min(map->m_len, 4070 4053 (unsigned) sbi->s_cluster_ratio - c_offset); 4071 4054 /* ··· 4218 4203 */ 4219 4204 map->m_flags &= ~EXT4_MAP_FROM_CLUSTER; 4220 4205 newex.ee_block = cpu_to_le32(map->m_lblk); 4221 - cluster_offset = map->m_lblk & (sbi->s_cluster_ratio-1); 4206 + cluster_offset = EXT4_LBLK_CMASK(sbi, map->m_lblk); 4222 4207 4223 4208 /* 4224 4209 * If we are doing bigalloc, check to see if the extent returned ··· 4286 4271 * needed so that future calls to get_implied_cluster_alloc() 4287 4272 * work correctly. 4288 4273 */ 4289 - offset = map->m_lblk & (sbi->s_cluster_ratio - 1); 4274 + offset = EXT4_LBLK_COFF(sbi, map->m_lblk); 4290 4275 ar.len = EXT4_NUM_B2C(sbi, offset+allocated); 4291 4276 ar.goal -= offset; 4292 4277 ar.logical -= offset;

-12

fs/ext4/inode.c

··· 1206 1206 */ 1207 1207 static int ext4_da_reserve_metadata(struct inode *inode, ext4_lblk_t lblock) 1208 1208 { 1209 - int retries = 0; 1210 1209 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 1211 1210 struct ext4_inode_info *ei = EXT4_I(inode); 1212 1211 unsigned int md_needed; ··· 1217 1218 * in order to allocate nrblocks 1218 1219 * worse case is one extent per block 1219 1220 */ 1220 - repeat: 1221 1221 spin_lock(&ei->i_block_reservation_lock); 1222 1222 /* 1223 1223 * ext4_calc_metadata_amount() has side effects, which we have ··· 1236 1238 ei->i_da_metadata_calc_len = save_len; 1237 1239 ei->i_da_metadata_calc_last_lblock = save_last_lblock; 1238 1240 spin_unlock(&ei->i_block_reservation_lock); 1239 - if (ext4_should_retry_alloc(inode->i_sb, &retries)) { 1240 - cond_resched(); 1241 - goto repeat; 1242 - } 1243 1241 return -ENOSPC; 1244 1242 } 1245 1243 ei->i_reserved_meta_blocks += md_needed; ··· 1249 1255 */ 1250 1256 static int ext4_da_reserve_space(struct inode *inode, ext4_lblk_t lblock) 1251 1257 { 1252 - int retries = 0; 1253 1258 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 1254 1259 struct ext4_inode_info *ei = EXT4_I(inode); 1255 1260 unsigned int md_needed; ··· 1270 1277 * in order to allocate nrblocks 1271 1278 * worse case is one extent per block 1272 1279 */ 1273 - repeat: 1274 1280 spin_lock(&ei->i_block_reservation_lock); 1275 1281 /* 1276 1282 * ext4_calc_metadata_amount() has side effects, which we have ··· 1289 1297 ei->i_da_metadata_calc_len = save_len; 1290 1298 ei->i_da_metadata_calc_last_lblock = save_last_lblock; 1291 1299 spin_unlock(&ei->i_block_reservation_lock); 1292 - if (ext4_should_retry_alloc(inode->i_sb, &retries)) { 1293 - cond_resched(); 1294 - goto repeat; 1295 - } 1296 1300 dquot_release_reservation_block(inode, EXT4_C2B(sbi, 1)); 1297 1301 return -ENOSPC; 1298 1302 }

+11 -6

fs/ext4/mballoc.c

··· 3442 3442 { 3443 3443 struct ext4_prealloc_space *pa; 3444 3444 pa = container_of(head, struct ext4_prealloc_space, u.pa_rcu); 3445 + 3446 + BUG_ON(atomic_read(&pa->pa_count)); 3447 + BUG_ON(pa->pa_deleted == 0); 3445 3448 kmem_cache_free(ext4_pspace_cachep, pa); 3446 3449 } 3447 3450 ··· 3458 3455 ext4_group_t grp; 3459 3456 ext4_fsblk_t grp_blk; 3460 3457 3461 - if (!atomic_dec_and_test(&pa->pa_count) || pa->pa_free != 0) 3462 - return; 3463 - 3464 3458 /* in this short window concurrent discard can set pa_deleted */ 3465 3459 spin_lock(&pa->pa_lock); 3460 + if (!atomic_dec_and_test(&pa->pa_count) || pa->pa_free != 0) { 3461 + spin_unlock(&pa->pa_lock); 3462 + return; 3463 + } 3464 + 3466 3465 if (pa->pa_deleted == 1) { 3467 3466 spin_unlock(&pa->pa_lock); 3468 3467 return; ··· 4126 4121 ext4_get_group_no_and_offset(sb, goal, &group, &block); 4127 4122 4128 4123 /* set up allocation goals */ 4129 - ac->ac_b_ex.fe_logical = ar->logical & ~(sbi->s_cluster_ratio - 1); 4124 + ac->ac_b_ex.fe_logical = EXT4_LBLK_CMASK(sbi, ar->logical); 4130 4125 ac->ac_status = AC_STATUS_CONTINUE; 4131 4126 ac->ac_sb = sb; 4132 4127 ac->ac_inode = ar->inode; ··· 4668 4663 * blocks at the beginning or the end unless we are explicitly 4669 4664 * requested to avoid doing so. 4670 4665 */ 4671 - overflow = block & (sbi->s_cluster_ratio - 1); 4666 + overflow = EXT4_PBLK_COFF(sbi, block); 4672 4667 if (overflow) { 4673 4668 if (flags & EXT4_FREE_BLOCKS_NOFREE_FIRST_CLUSTER) { 4674 4669 overflow = sbi->s_cluster_ratio - overflow; ··· 4682 4677 count += overflow; 4683 4678 } 4684 4679 } 4685 - overflow = count & (sbi->s_cluster_ratio - 1); 4680 + overflow = EXT4_LBLK_COFF(sbi, count); 4686 4681 if (overflow) { 4687 4682 if (flags & EXT4_FREE_BLOCKS_NOFREE_LAST_CLUSTER) { 4688 4683 if (count > overflow)

+15 -6

fs/ext4/super.c

··· 792 792 } 793 793 794 794 ext4_es_unregister_shrinker(sbi); 795 - del_timer(&sbi->s_err_report); 795 + del_timer_sync(&sbi->s_err_report); 796 796 ext4_release_system_zone(sb); 797 797 ext4_mb_release(sb); 798 798 ext4_ext_release(sb); ··· 3316 3316 } 3317 3317 3318 3318 3319 - static ext4_fsblk_t ext4_calculate_resv_clusters(struct ext4_sb_info *sbi) 3319 + static ext4_fsblk_t ext4_calculate_resv_clusters(struct super_block *sb) 3320 3320 { 3321 3321 ext4_fsblk_t resv_clusters; 3322 3322 3323 + /* 3324 + * There's no need to reserve anything when we aren't using extents. 3325 + * The space estimates are exact, there are no unwritten extents, 3326 + * hole punching doesn't need new metadata... This is needed especially 3327 + * to keep ext2/3 backward compatibility. 3328 + */ 3329 + if (!EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_EXTENTS)) 3330 + return 0; 3323 3331 /* 3324 3332 * By default we reserve 2% or 4096 clusters, whichever is smaller. 3325 3333 * This should cover the situations where we can not afford to run ··· 3336 3328 * allocation would require 1, or 2 blocks, higher numbers are 3337 3329 * very rare. 3338 3330 */ 3339 - resv_clusters = ext4_blocks_count(sbi->s_es) >> sbi->s_cluster_bits; 3331 + resv_clusters = ext4_blocks_count(EXT4_SB(sb)->s_es) >> 3332 + EXT4_SB(sb)->s_cluster_bits; 3340 3333 3341 3334 do_div(resv_clusters, 50); 3342 3335 resv_clusters = min_t(ext4_fsblk_t, resv_clusters, 4096); ··· 4080 4071 "available"); 4081 4072 } 4082 4073 4083 - err = ext4_reserve_clusters(sbi, ext4_calculate_resv_clusters(sbi)); 4074 + err = ext4_reserve_clusters(sbi, ext4_calculate_resv_clusters(sb)); 4084 4075 if (err) { 4085 4076 ext4_msg(sb, KERN_ERR, "failed to reserve %llu clusters for " 4086 - "reserved pool", ext4_calculate_resv_clusters(sbi)); 4077 + "reserved pool", ext4_calculate_resv_clusters(sb)); 4087 4078 goto failed_mount4a; 4088 4079 } 4089 4080 ··· 4193 4184 } 4194 4185 failed_mount3: 4195 4186 ext4_es_unregister_shrinker(sbi); 4196 - del_timer(&sbi->s_err_report); 4187 + del_timer_sync(&sbi->s_err_report); 4197 4188 if (sbi->s_flex_groups) 4198 4189 ext4_kvfree(sbi->s_flex_groups); 4199 4190 percpu_counter_destroy(&sbi->s_freeclusters_counter);

+8 -10

fs/jbd2/journal.c

··· 702 702 read_lock(&journal->j_state_lock); 703 703 #ifdef CONFIG_JBD2_DEBUG 704 704 if (!tid_geq(journal->j_commit_request, tid)) { 705 - printk(KERN_EMERG 705 + printk(KERN_ERR 706 706 "%s: error: j_commit_request=%d, tid=%d\n", 707 707 __func__, journal->j_commit_request, tid); 708 708 } ··· 718 718 } 719 719 read_unlock(&journal->j_state_lock); 720 720 721 - if (unlikely(is_journal_aborted(journal))) { 722 - printk(KERN_EMERG "journal commit I/O error\n"); 721 + if (unlikely(is_journal_aborted(journal))) 723 722 err = -EIO; 724 - } 725 723 return err; 726 724 } 727 725 ··· 1525 1527 if (JBD2_HAS_COMPAT_FEATURE(journal, JBD2_FEATURE_COMPAT_CHECKSUM) && 1526 1528 JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_CSUM_V2)) { 1527 1529 /* Can't have checksum v1 and v2 on at the same time! */ 1528 - printk(KERN_ERR "JBD: Can't enable checksumming v1 and v2 " 1530 + printk(KERN_ERR "JBD2: Can't enable checksumming v1 and v2 " 1529 1531 "at the same time!\n"); 1530 1532 goto out; 1531 1533 } 1532 1534 1533 1535 if (!jbd2_verify_csum_type(journal, sb)) { 1534 - printk(KERN_ERR "JBD: Unknown checksum type\n"); 1536 + printk(KERN_ERR "JBD2: Unknown checksum type\n"); 1535 1537 goto out; 1536 1538 } 1537 1539 ··· 1539 1541 if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_CSUM_V2)) { 1540 1542 journal->j_chksum_driver = crypto_alloc_shash("crc32c", 0, 0); 1541 1543 if (IS_ERR(journal->j_chksum_driver)) { 1542 - printk(KERN_ERR "JBD: Cannot load crc32c driver.\n"); 1544 + printk(KERN_ERR "JBD2: Cannot load crc32c driver.\n"); 1543 1545 err = PTR_ERR(journal->j_chksum_driver); 1544 1546 journal->j_chksum_driver = NULL; 1545 1547 goto out; ··· 1548 1550 1549 1551 /* Check superblock checksum */ 1550 1552 if (!jbd2_superblock_csum_verify(journal, sb)) { 1551 - printk(KERN_ERR "JBD: journal checksum error\n"); 1553 + printk(KERN_ERR "JBD2: journal checksum error\n"); 1552 1554 goto out; 1553 1555 } 1554 1556 ··· 1834 1836 journal->j_chksum_driver = crypto_alloc_shash("crc32c", 1835 1837 0, 0); 1836 1838 if (IS_ERR(journal->j_chksum_driver)) { 1837 - printk(KERN_ERR "JBD: Cannot load crc32c " 1839 + printk(KERN_ERR "JBD2: Cannot load crc32c " 1838 1840 "driver.\n"); 1839 1841 journal->j_chksum_driver = NULL; 1840 1842 return 0; ··· 2643 2645 #ifdef CONFIG_JBD2_DEBUG 2644 2646 int n = atomic_read(&nr_journal_heads); 2645 2647 if (n) 2646 - printk(KERN_EMERG "JBD2: leaked %d journal_heads!\n", n); 2648 + printk(KERN_ERR "JBD2: leaked %d journal_heads!\n", n); 2647 2649 #endif 2648 2650 jbd2_remove_jbd_stats_proc_entry(); 2649 2651 jbd2_journal_destroy_caches();

+1 -1

fs/jbd2/recovery.c

··· 594 594 be32_to_cpu(tmp->h_sequence))) { 595 595 brelse(obh); 596 596 success = -EIO; 597 - printk(KERN_ERR "JBD: Invalid " 597 + printk(KERN_ERR "JBD2: Invalid " 598 598 "checksum recovering " 599 599 "block %llu in log\n", 600 600 blocknr);

+9 -7

fs/jbd2/transaction.c

··· 932 932 jbd2_alloc(jh2bh(jh)->b_size, 933 933 GFP_NOFS); 934 934 if (!frozen_buffer) { 935 - printk(KERN_EMERG 935 + printk(KERN_ERR 936 936 "%s: OOM for frozen_buffer\n", 937 937 __func__); 938 938 JBUFFER_TRACE(jh, "oom!"); ··· 1166 1166 if (!jh->b_committed_data) { 1167 1167 committed_data = jbd2_alloc(jh2bh(jh)->b_size, GFP_NOFS); 1168 1168 if (!committed_data) { 1169 - printk(KERN_EMERG "%s: No memory for committed data\n", 1169 + printk(KERN_ERR "%s: No memory for committed data\n", 1170 1170 __func__); 1171 1171 err = -ENOMEM; 1172 1172 goto out; ··· 1290 1290 * once a transaction -bzzz 1291 1291 */ 1292 1292 jh->b_modified = 1; 1293 - J_ASSERT_JH(jh, handle->h_buffer_credits > 0); 1293 + if (handle->h_buffer_credits <= 0) { 1294 + ret = -ENOSPC; 1295 + goto out_unlock_bh; 1296 + } 1294 1297 handle->h_buffer_credits--; 1295 1298 } 1296 1299 ··· 1308 1305 JBUFFER_TRACE(jh, "fastpath"); 1309 1306 if (unlikely(jh->b_transaction != 1310 1307 journal->j_running_transaction)) { 1311 - printk(KERN_EMERG "JBD: %s: " 1308 + printk(KERN_ERR "JBD2: %s: " 1312 1309 "jh->b_transaction (%llu, %p, %u) != " 1313 1310 "journal->j_running_transaction (%p, %u)", 1314 1311 journal->j_devname, ··· 1335 1332 JBUFFER_TRACE(jh, "already on other transaction"); 1336 1333 if (unlikely(jh->b_transaction != 1337 1334 journal->j_committing_transaction)) { 1338 - printk(KERN_EMERG "JBD: %s: " 1335 + printk(KERN_ERR "JBD2: %s: " 1339 1336 "jh->b_transaction (%llu, %p, %u) != " 1340 1337 "journal->j_committing_transaction (%p, %u)", 1341 1338 journal->j_devname, ··· 1348 1345 ret = -EINVAL; 1349 1346 } 1350 1347 if (unlikely(jh->b_next_transaction != transaction)) { 1351 - printk(KERN_EMERG "JBD: %s: " 1348 + printk(KERN_ERR "JBD2: %s: " 1352 1349 "jh->b_next_transaction (%llu, %p, %u) != " 1353 1350 "transaction (%p, %u)", 1354 1351 journal->j_devname, ··· 1376 1373 jbd2_journal_put_journal_head(jh); 1377 1374 out: 1378 1375 JBUFFER_TRACE(jh, "exit"); 1379 - WARN_ON(ret); /* All errors are bugs, so dump the stack */ 1380 1376 return ret; 1381 1377 } 1382 1378

Configure Feed

Configure Feed