aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@linux-foundation.org>2015-11-06 19:23:27 -0500
committerLinus Torvalds <torvalds@linux-foundation.org>2015-11-06 19:23:27 -0500
commit713009809681e5a7871e96e6992692c805b4480b (patch)
tree7f3425f1058175b03b0dde480f982c2a34919838
parent9cf5c095b65da63c08b928a7d0015d5d5dca8a66 (diff)
parentbe69e1c19f0efb091f29521715c380842fa4cd7e (diff)
Merge tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4
Pull ext4 updates from Ted Ts'o: "Add support for the CSUM_SEED feature which will allow future userspace utilities to change the file system's UUID without rewriting all of the file system metadata. A number of miscellaneous fixes, the most significant of which are in the ext4 encryption support. Anyone wishing to use the encryption feature should backport all of the ext4 crypto patches up to 4.4 to get fixes to a memory leak and file system corruption bug. There are also cleanups in ext4's feature test macros and in ext4's sysfs support code" * tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4: (26 commits) fs/ext4: remove unnecessary new_valid_dev check ext4: fix abs() usage in ext4_mb_check_group_pa ext4: do not allow journal_opts for fs w/o journal ext4: explicit mount options parsing cleanup ext4, jbd2: ensure entering into panic after recording an error in superblock [PATCH] fix calculation of meta_bg descriptor backups ext4: fix potential use after free in __ext4_journal_stop jbd2: fix checkpoint list cleanup ext4: fix xfstest generic/269 double revoked buffer bug with bigalloc ext4: make the bitmap read routines return real error codes jbd2: clean up feature test macros with predicate functions ext4: clean up feature test macros with predicate functions ext4: call out CRC and corruption errors with specific error codes ext4: store checksum seed in superblock ext4: reserve code points for the project quota feature ext4: promote ext4 over ext2 in the default probe order jbd2: gate checksum calculations on crc driver presence, not sb flags ext4: use private version of page_zero_new_buffers() for data=journal mode ext4 crypto: fix bugs in ext4_encrypted_zeroout() ext4 crypto: replace some BUG_ON()'s with error checks ...
Diffstat
-rw-r--r--fs/Makefile7
-rw-r--r--fs/ext4/Makefile2
-rw-r--r--fs/ext4/balloc.c92
-rw-r--r--fs/ext4/block_validity.c2
-rw-r--r--fs/ext4/crypto.c52
-rw-r--r--fs/ext4/crypto_fname.c2
-rw-r--r--fs/ext4/crypto_key.c16
-rw-r--r--fs/ext4/crypto_policy.c3
-rw-r--r--fs/ext4/dir.c7
-rw-r--r--fs/ext4/ext4.h177
-rw-r--r--fs/ext4/ext4_jbd2.c6
-rw-r--r--fs/ext4/ext4_jbd2.h10
-rw-r--r--fs/ext4/extents.c82
-rw-r--r--fs/ext4/extents_status.c60
-rw-r--r--fs/ext4/extents_status.h2
-rw-r--r--fs/ext4/ialloc.c113
-rw-r--r--fs/ext4/indirect.c5
-rw-r--r--fs/ext4/inline.c3
-rw-r--r--fs/ext4/inode.c83
-rw-r--r--fs/ext4/ioctl.c15
-rw-r--r--fs/ext4/mballoc.c91
-rw-r--r--fs/ext4/migrate.c9
-rw-r--r--fs/ext4/mmp.c8
-rw-r--r--fs/ext4/namei.c39
-rw-r--r--fs/ext4/page-io.c5
-rw-r--r--fs/ext4/readpage.c2
-rw-r--r--fs/ext4/resize.c34
-rw-r--r--fs/ext4/super.c695
-rw-r--r--fs/ext4/symlink.c2
-rw-r--r--fs/ext4/sysfs.c448
-rw-r--r--fs/ext4/xattr.c32
-rw-r--r--fs/jbd2/checkpoint.c8
-rw-r--r--fs/jbd2/commit.c22
-rw-r--r--fs/jbd2/journal.c27
-rw-r--r--fs/jbd2/recovery.c26
-rw-r--r--fs/jbd2/revoke.c4
-rw-r--r--include/linux/jbd2.h84
-rw-r--r--include/uapi/linux/fs.h1
38 files changed, 1279 insertions, 997 deletions
diff --git a/fs/Makefile b/fs/Makefile
index f79cf4043e60..79f522575cba 100644
--- a/fs/Makefile
+++ b/fs/Makefile
@@ -63,10 +63,11 @@ obj-$(CONFIG_DLM) += dlm/
63# Do not add any filesystems before this line 63# Do not add any filesystems before this line
64obj-$(CONFIG_FSCACHE) += fscache/ 64obj-$(CONFIG_FSCACHE) += fscache/
65obj-$(CONFIG_REISERFS_FS) += reiserfs/ 65obj-$(CONFIG_REISERFS_FS) += reiserfs/
66obj-$(CONFIG_EXT2_FS) += ext2/
67# We place ext4 after ext2 so plain ext2 root fs's are mounted using ext2
68# unless explicitly requested by rootfstype
69obj-$(CONFIG_EXT4_FS) += ext4/ 66obj-$(CONFIG_EXT4_FS) += ext4/
67# We place ext4 before ext2 so that clean ext3 root fs's do NOT mount using the
68# ext2 driver, which doesn't know about journalling! Explicitly request ext2
69# by giving the rootfstype= parameter.
70obj-$(CONFIG_EXT2_FS) += ext2/
70obj-$(CONFIG_JBD2) += jbd2/ 71obj-$(CONFIG_JBD2) += jbd2/
71obj-$(CONFIG_CRAMFS) += cramfs/ 72obj-$(CONFIG_CRAMFS) += cramfs/
72obj-$(CONFIG_SQUASHFS) += squashfs/ 73obj-$(CONFIG_SQUASHFS) += squashfs/
diff --git a/fs/ext4/Makefile b/fs/ext4/Makefile
index 75285ea9aa05..f52cf54f0cbc 100644
--- a/fs/ext4/Makefile
+++ b/fs/ext4/Makefile
@@ -8,7 +8,7 @@ ext4-y := balloc.o bitmap.o dir.o file.o fsync.o ialloc.o inode.o page-io.o \
8 ioctl.o namei.o super.o symlink.o hash.o resize.o extents.o \ 8 ioctl.o namei.o super.o symlink.o hash.o resize.o extents.o \
9 ext4_jbd2.o migrate.o mballoc.o block_validity.o move_extent.o \ 9 ext4_jbd2.o migrate.o mballoc.o block_validity.o move_extent.o \
10 mmp.o indirect.o extents_status.o xattr.o xattr_user.o \ 10 mmp.o indirect.o extents_status.o xattr.o xattr_user.o \
11 xattr_trusted.o inline.o readpage.o 11 xattr_trusted.o inline.o readpage.o sysfs.o
12 12
13ext4-$(CONFIG_EXT4_FS_POSIX_ACL) += acl.o 13ext4-$(CONFIG_EXT4_FS_POSIX_ACL) += acl.o
14ext4-$(CONFIG_EXT4_FS_SECURITY) += xattr_security.o 14ext4-$(CONFIG_EXT4_FS_SECURITY) += xattr_security.o
diff --git a/fs/ext4/balloc.c b/fs/ext4/balloc.c
index cd6ea29be645..ec0668a60678 100644
--- a/fs/ext4/balloc.c
+++ b/fs/ext4/balloc.c
@@ -191,6 +191,7 @@ static int ext4_init_block_bitmap(struct super_block *sb,
191 /* If checksum is bad mark all blocks used to prevent allocation 191 /* If checksum is bad mark all blocks used to prevent allocation
192 * essentially implementing a per-group read-only flag. */ 192 * essentially implementing a per-group read-only flag. */
193 if (!ext4_group_desc_csum_verify(sb, block_group, gdp)) { 193 if (!ext4_group_desc_csum_verify(sb, block_group, gdp)) {
194 ext4_error(sb, "Checksum bad for group %u", block_group);
194 grp = ext4_get_group_info(sb, block_group); 195 grp = ext4_get_group_info(sb, block_group);
195 if (!EXT4_MB_GRP_BBITMAP_CORRUPT(grp)) 196 if (!EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
196 percpu_counter_sub(&sbi->s_freeclusters_counter, 197 percpu_counter_sub(&sbi->s_freeclusters_counter,
@@ -203,7 +204,7 @@ static int ext4_init_block_bitmap(struct super_block *sb,
203 count); 204 count);
204 } 205 }
205 set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &grp->bb_state); 206 set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &grp->bb_state);
206 return -EIO; 207 return -EFSBADCRC;
207 } 208 }
208 memset(bh->b_data, 0, sb->s_blocksize); 209 memset(bh->b_data, 0, sb->s_blocksize);
209 210
@@ -213,7 +214,7 @@ static int ext4_init_block_bitmap(struct super_block *sb,
213 214
214 start = ext4_group_first_block_no(sb, block_group); 215 start = ext4_group_first_block_no(sb, block_group);
215 216
216 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG)) 217 if (ext4_has_feature_flex_bg(sb))
217 flex_bg = 1; 218 flex_bg = 1;
218 219
219 /* Set bits for block and inode bitmaps, and inode table */ 220 /* Set bits for block and inode bitmaps, and inode table */
@@ -322,7 +323,7 @@ static ext4_fsblk_t ext4_valid_block_bitmap(struct super_block *sb,
322 ext4_fsblk_t blk; 323 ext4_fsblk_t blk;
323 ext4_fsblk_t group_first_block; 324 ext4_fsblk_t group_first_block;
324 325
325 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG)) { 326 if (ext4_has_feature_flex_bg(sb)) {
326 /* with FLEX_BG, the inode/block bitmaps and itable 327 /* with FLEX_BG, the inode/block bitmaps and itable
327 * blocks may not be in the group at all 328 * blocks may not be in the group at all
328 * so the bitmap validation will be skipped for those groups 329 * so the bitmap validation will be skipped for those groups
@@ -360,42 +361,45 @@ static ext4_fsblk_t ext4_valid_block_bitmap(struct super_block *sb,
360 return 0; 361 return 0;
361} 362}
362 363
363static void ext4_validate_block_bitmap(struct super_block *sb, 364static int ext4_validate_block_bitmap(struct super_block *sb,
364 struct ext4_group_desc *desc, 365 struct ext4_group_desc *desc,
365 ext4_group_t block_group, 366 ext4_group_t block_group,
366 struct buffer_head *bh) 367 struct buffer_head *bh)
367{ 368{
368 ext4_fsblk_t blk; 369 ext4_fsblk_t blk;
369 struct ext4_group_info *grp = ext4_get_group_info(sb, block_group); 370 struct ext4_group_info *grp = ext4_get_group_info(sb, block_group);
370 struct ext4_sb_info *sbi = EXT4_SB(sb); 371 struct ext4_sb_info *sbi = EXT4_SB(sb);
371 372
372 if (buffer_verified(bh) || EXT4_MB_GRP_BBITMAP_CORRUPT(grp)) 373 if (buffer_verified(bh))
373 return; 374 return 0;
375 if (EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
376 return -EFSCORRUPTED;
374 377
375 ext4_lock_group(sb, block_group); 378 ext4_lock_group(sb, block_group);
376 blk = ext4_valid_block_bitmap(sb, desc, block_group, bh); 379 if (unlikely(!ext4_block_bitmap_csum_verify(sb, block_group,
377 if (unlikely(blk != 0)) { 380 desc, bh))) {
378 ext4_unlock_group(sb, block_group); 381 ext4_unlock_group(sb, block_group);
379 ext4_error(sb, "bg %u: block %llu: invalid block bitmap", 382 ext4_error(sb, "bg %u: bad block bitmap checksum", block_group);
380 block_group, blk);
381 if (!EXT4_MB_GRP_BBITMAP_CORRUPT(grp)) 383 if (!EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
382 percpu_counter_sub(&sbi->s_freeclusters_counter, 384 percpu_counter_sub(&sbi->s_freeclusters_counter,
383 grp->bb_free); 385 grp->bb_free);
384 set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state); 386 set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state);
385 return; 387 return -EFSBADCRC;
386 } 388 }
387 if (unlikely(!ext4_block_bitmap_csum_verify(sb, block_group, 389 blk = ext4_valid_block_bitmap(sb, desc, block_group, bh);
388 desc, bh))) { 390 if (unlikely(blk != 0)) {
389 ext4_unlock_group(sb, block_group); 391 ext4_unlock_group(sb, block_group);
390 ext4_error(sb, "bg %u: bad block bitmap checksum", block_group); 392 ext4_error(sb, "bg %u: block %llu: invalid block bitmap",
393 block_group, blk);
391 if (!EXT4_MB_GRP_BBITMAP_CORRUPT(grp)) 394 if (!EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
392 percpu_counter_sub(&sbi->s_freeclusters_counter, 395 percpu_counter_sub(&sbi->s_freeclusters_counter,
393 grp->bb_free); 396 grp->bb_free);
394 set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state); 397 set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state);
395 return; 398 return -EFSCORRUPTED;
396 } 399 }
397 set_buffer_verified(bh); 400 set_buffer_verified(bh);
398 ext4_unlock_group(sb, block_group); 401 ext4_unlock_group(sb, block_group);
402 return 0;
399} 403}
400 404
401/** 405/**
@@ -414,17 +418,18 @@ ext4_read_block_bitmap_nowait(struct super_block *sb, ext4_group_t block_group)
414 struct ext4_group_desc *desc; 418 struct ext4_group_desc *desc;
415 struct buffer_head *bh; 419 struct buffer_head *bh;
416 ext4_fsblk_t bitmap_blk; 420 ext4_fsblk_t bitmap_blk;
421 int err;
417 422
418 desc = ext4_get_group_desc(sb, block_group, NULL); 423 desc = ext4_get_group_desc(sb, block_group, NULL);
419 if (!desc) 424 if (!desc)
420 return NULL; 425 return ERR_PTR(-EFSCORRUPTED);
421 bitmap_blk = ext4_block_bitmap(sb, desc); 426 bitmap_blk = ext4_block_bitmap(sb, desc);
422 bh = sb_getblk(sb, bitmap_blk); 427 bh = sb_getblk(sb, bitmap_blk);
423 if (unlikely(!bh)) { 428 if (unlikely(!bh)) {
424 ext4_error(sb, "Cannot get buffer for block bitmap - " 429 ext4_error(sb, "Cannot get buffer for block bitmap - "
425 "block_group = %u, block_bitmap = %llu", 430 "block_group = %u, block_bitmap = %llu",
426 block_group, bitmap_blk); 431 block_group, bitmap_blk);
427 return NULL; 432 return ERR_PTR(-ENOMEM);
428 } 433 }
429 434
430 if (bitmap_uptodate(bh)) 435 if (bitmap_uptodate(bh))
@@ -437,7 +442,6 @@ ext4_read_block_bitmap_nowait(struct super_block *sb, ext4_group_t block_group)
437 } 442 }
438 ext4_lock_group(sb, block_group); 443 ext4_lock_group(sb, block_group);
439 if (desc->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) { 444 if (desc->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
440 int err;
441 445
442 err = ext4_init_block_bitmap(sb, bh, block_group, desc); 446 err = ext4_init_block_bitmap(sb, bh, block_group, desc);
443 set_bitmap_uptodate(bh); 447 set_bitmap_uptodate(bh);
@@ -445,7 +449,7 @@ ext4_read_block_bitmap_nowait(struct super_block *sb, ext4_group_t block_group)
445 ext4_unlock_group(sb, block_group); 449 ext4_unlock_group(sb, block_group);
446 unlock_buffer(bh); 450 unlock_buffer(bh);
447 if (err) 451 if (err)
448 ext4_error(sb, "Checksum bad for grp %u", block_group); 452 goto out;
449 goto verify; 453 goto verify;
450 } 454 }
451 ext4_unlock_group(sb, block_group); 455 ext4_unlock_group(sb, block_group);
@@ -468,11 +472,13 @@ ext4_read_block_bitmap_nowait(struct super_block *sb, ext4_group_t block_group)
468 submit_bh(READ | REQ_META | REQ_PRIO, bh); 472 submit_bh(READ | REQ_META | REQ_PRIO, bh);
469 return bh; 473 return bh;
470verify: 474verify:
471 ext4_validate_block_bitmap(sb, desc, block_group, bh); 475 err = ext4_validate_block_bitmap(sb, desc, block_group, bh);
472 if (buffer_verified(bh)) 476 if (err)
473 return bh; 477 goto out;
478 return bh;
479out:
474 put_bh(bh); 480 put_bh(bh);
475 return NULL; 481 return ERR_PTR(err);
476} 482}
477 483
478/* Returns 0 on success, 1 on error */ 484/* Returns 0 on success, 1 on error */
@@ -485,32 +491,32 @@ int ext4_wait_block_bitmap(struct super_block *sb, ext4_group_t block_group,
485 return 0; 491 return 0;
486 desc = ext4_get_group_desc(sb, block_group, NULL); 492 desc = ext4_get_group_desc(sb, block_group, NULL);
487 if (!desc) 493 if (!desc)
488 return 1; 494 return -EFSCORRUPTED;
489 wait_on_buffer(bh); 495 wait_on_buffer(bh);
490 if (!buffer_uptodate(bh)) { 496 if (!buffer_uptodate(bh)) {
491 ext4_error(sb, "Cannot read block bitmap - " 497 ext4_error(sb, "Cannot read block bitmap - "
492 "block_group = %u, block_bitmap = %llu", 498 "block_group = %u, block_bitmap = %llu",
493 block_group, (unsigned long long) bh->b_blocknr); 499 block_group, (unsigned long long) bh->b_blocknr);
494 return 1; 500 return -EIO;
495 } 501 }
496 clear_buffer_new(bh); 502 clear_buffer_new(bh);
497 /* Panic or remount fs read-only if block bitmap is invalid */ 503 /* Panic or remount fs read-only if block bitmap is invalid */
498 ext4_validate_block_bitmap(sb, desc, block_group, bh); 504 return ext4_validate_block_bitmap(sb, desc, block_group, bh);
499 /* ...but check for error just in case errors=continue. */
500 return !buffer_verified(bh);
501} 505}
502 506
503struct buffer_head * 507struct buffer_head *
504ext4_read_block_bitmap(struct super_block *sb, ext4_group_t block_group) 508ext4_read_block_bitmap(struct super_block *sb, ext4_group_t block_group)
505{ 509{
506 struct buffer_head *bh; 510 struct buffer_head *bh;
511 int err;
507 512
508 bh = ext4_read_block_bitmap_nowait(sb, block_group); 513 bh = ext4_read_block_bitmap_nowait(sb, block_group);
509 if (!bh) 514 if (IS_ERR(bh))
510 return NULL; 515 return bh;
511 if (ext4_wait_block_bitmap(sb, block_group, bh)) { 516 err = ext4_wait_block_bitmap(sb, block_group, bh);
517 if (err) {
512 put_bh(bh); 518 put_bh(bh);
513 return NULL; 519 return ERR_PTR(err);
514 } 520 }
515 return bh; 521 return bh;
516} 522}
@@ -681,8 +687,10 @@ ext4_fsblk_t ext4_count_free_clusters(struct super_block *sb)
681 desc_count += ext4_free_group_clusters(sb, gdp); 687 desc_count += ext4_free_group_clusters(sb, gdp);
682 brelse(bitmap_bh); 688 brelse(bitmap_bh);
683 bitmap_bh = ext4_read_block_bitmap(sb, i); 689 bitmap_bh = ext4_read_block_bitmap(sb, i);
684 if (bitmap_bh == NULL) 690 if (IS_ERR(bitmap_bh)) {
691 bitmap_bh = NULL;
685 continue; 692 continue;
693 }
686 694
687 x = ext4_count_free(bitmap_bh->b_data, 695 x = ext4_count_free(bitmap_bh->b_data,
688 EXT4_CLUSTERS_PER_GROUP(sb) / 8); 696 EXT4_CLUSTERS_PER_GROUP(sb) / 8);
@@ -740,14 +748,13 @@ int ext4_bg_has_super(struct super_block *sb, ext4_group_t group)
740 748
741 if (group == 0) 749 if (group == 0)
742 return 1; 750 return 1;
743 if (EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_SPARSE_SUPER2)) { 751 if (ext4_has_feature_sparse_super2(sb)) {
744 if (group == le32_to_cpu(es->s_backup_bgs[0]) || 752 if (group == le32_to_cpu(es->s_backup_bgs[0]) ||
745 group == le32_to_cpu(es->s_backup_bgs[1])) 753 group == le32_to_cpu(es->s_backup_bgs[1]))
746 return 1; 754 return 1;
747 return 0; 755 return 0;
748 } 756 }
749 if ((group <= 1) || !EXT4_HAS_RO_COMPAT_FEATURE(sb, 757 if ((group <= 1) || !ext4_has_feature_sparse_super(sb))
750 EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER))
751 return 1; 758 return 1;
752 if (!(group & 1)) 759 if (!(group & 1))
753 return 0; 760 return 0;
@@ -776,7 +783,7 @@ static unsigned long ext4_bg_num_gdb_nometa(struct super_block *sb,
776 if (!ext4_bg_has_super(sb, group)) 783 if (!ext4_bg_has_super(sb, group))
777 return 0; 784 return 0;
778 785
779 if (EXT4_HAS_INCOMPAT_FEATURE(sb,EXT4_FEATURE_INCOMPAT_META_BG)) 786 if (ext4_has_feature_meta_bg(sb))
780 return le32_to_cpu(EXT4_SB(sb)->s_es->s_first_meta_bg); 787 return le32_to_cpu(EXT4_SB(sb)->s_es->s_first_meta_bg);
781 else 788 else
782 return EXT4_SB(sb)->s_gdb_count; 789 return EXT4_SB(sb)->s_gdb_count;
@@ -797,8 +804,7 @@ unsigned long ext4_bg_num_gdb(struct super_block *sb, ext4_group_t group)
797 le32_to_cpu(EXT4_SB(sb)->s_es->s_first_meta_bg); 804 le32_to_cpu(EXT4_SB(sb)->s_es->s_first_meta_bg);
798 unsigned long metagroup = group / EXT4_DESC_PER_BLOCK(sb); 805 unsigned long metagroup = group / EXT4_DESC_PER_BLOCK(sb);
799 806
800 if (!EXT4_HAS_INCOMPAT_FEATURE(sb,EXT4_FEATURE_INCOMPAT_META_BG) || 807 if (!ext4_has_feature_meta_bg(sb) || metagroup < first_meta_bg)
801 metagroup < first_meta_bg)
802 return ext4_bg_num_gdb_nometa(sb, group); 808 return ext4_bg_num_gdb_nometa(sb, group);
803 809
804 return ext4_bg_num_gdb_meta(sb,group); 810 return ext4_bg_num_gdb_meta(sb,group);
@@ -818,7 +824,7 @@ static unsigned ext4_num_base_meta_clusters(struct super_block *sb,
818 /* Check for superblock and gdt backups in this group */ 824 /* Check for superblock and gdt backups in this group */
819 num = ext4_bg_has_super(sb, block_group); 825 num = ext4_bg_has_super(sb, block_group);
820 826
821 if (!EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_META_BG) || 827 if (!ext4_has_feature_meta_bg(sb) ||
822 block_group < le32_to_cpu(sbi->s_es->s_first_meta_bg) * 828 block_group < le32_to_cpu(sbi->s_es->s_first_meta_bg) *
823 sbi->s_desc_per_block) { 829 sbi->s_desc_per_block) {
824 if (num) { 830 if (num) {
diff --git a/fs/ext4/block_validity.c b/fs/ext4/block_validity.c
index 3522340c7a99..02ddec6d8a7d 100644
--- a/fs/ext4/block_validity.c
+++ b/fs/ext4/block_validity.c
@@ -234,7 +234,7 @@ int ext4_check_blockref(const char *function, unsigned int line,
234 es->s_last_error_block = cpu_to_le64(blk); 234 es->s_last_error_block = cpu_to_le64(blk);
235 ext4_error_inode(inode, function, line, blk, 235 ext4_error_inode(inode, function, line, blk,
236 "invalid block"); 236 "invalid block");
237 return -EIO; 237 return -EFSCORRUPTED;
238 } 238 }
239 } 239 }
240 return 0; 240 return 0;
diff --git a/fs/ext4/crypto.c b/fs/ext4/crypto.c
index 45731558138c..af06830bfc00 100644
--- a/fs/ext4/crypto.c
+++ b/fs/ext4/crypto.c
@@ -253,8 +253,7 @@ typedef enum {
253 EXT4_ENCRYPT, 253 EXT4_ENCRYPT,
254} ext4_direction_t; 254} ext4_direction_t;
255 255
256static int ext4_page_crypto(struct ext4_crypto_ctx *ctx, 256static int ext4_page_crypto(struct inode *inode,
257 struct inode *inode,
258 ext4_direction_t rw, 257 ext4_direction_t rw,
259 pgoff_t index, 258 pgoff_t index,
260 struct page *src_page, 259 struct page *src_page,
@@ -296,7 +295,6 @@ static int ext4_page_crypto(struct ext4_crypto_ctx *ctx,
296 else 295 else
297 res = crypto_ablkcipher_encrypt(req); 296 res = crypto_ablkcipher_encrypt(req);
298 if (res == -EINPROGRESS || res == -EBUSY) { 297 if (res == -EINPROGRESS || res == -EBUSY) {
299 BUG_ON(req->base.data != &ecr);
300 wait_for_completion(&ecr.completion); 298 wait_for_completion(&ecr.completion);
301 res = ecr.res; 299 res = ecr.res;
302 } 300 }
@@ -353,7 +351,7 @@ struct page *ext4_encrypt(struct inode *inode,
353 if (IS_ERR(ciphertext_page)) 351 if (IS_ERR(ciphertext_page))
354 goto errout; 352 goto errout;
355 ctx->w.control_page = plaintext_page; 353 ctx->w.control_page = plaintext_page;
356 err = ext4_page_crypto(ctx, inode, EXT4_ENCRYPT, plaintext_page->index, 354 err = ext4_page_crypto(inode, EXT4_ENCRYPT, plaintext_page->index,
357 plaintext_page, ciphertext_page); 355 plaintext_page, ciphertext_page);
358 if (err) { 356 if (err) {
359 ciphertext_page = ERR_PTR(err); 357 ciphertext_page = ERR_PTR(err);
@@ -378,31 +376,14 @@ struct page *ext4_encrypt(struct inode *inode,
378 * 376 *
379 * Return: Zero on success, non-zero otherwise. 377 * Return: Zero on success, non-zero otherwise.
380 */ 378 */
381int ext4_decrypt(struct ext4_crypto_ctx *ctx, struct page *page) 379int ext4_decrypt(struct page *page)
382{ 380{
383 BUG_ON(!PageLocked(page)); 381 BUG_ON(!PageLocked(page));
384 382
385 return ext4_page_crypto(ctx, page->mapping->host, 383 return ext4_page_crypto(page->mapping->host,
386 EXT4_DECRYPT, page->index, page, page); 384 EXT4_DECRYPT, page->index, page, page);
387} 385}
388 386
389/*
390 * Convenience function which takes care of allocating and
391 * deallocating the encryption context
392 */
393int ext4_decrypt_one(struct inode *inode, struct page *page)
394{
395 int ret;
396
397 struct ext4_crypto_ctx *ctx = ext4_get_crypto_ctx(inode);
398
399 if (IS_ERR(ctx))
400 return PTR_ERR(ctx);
401 ret = ext4_decrypt(ctx, page);
402 ext4_release_crypto_ctx(ctx);
403 return ret;
404}
405
406int ext4_encrypted_zeroout(struct inode *inode, struct ext4_extent *ex) 387int ext4_encrypted_zeroout(struct inode *inode, struct ext4_extent *ex)
407{ 388{
408 struct ext4_crypto_ctx *ctx; 389 struct ext4_crypto_ctx *ctx;
@@ -411,7 +392,13 @@ int ext4_encrypted_zeroout(struct inode *inode, struct ext4_extent *ex)
411 ext4_lblk_t lblk = ex->ee_block; 392 ext4_lblk_t lblk = ex->ee_block;
412 ext4_fsblk_t pblk = ext4_ext_pblock(ex); 393 ext4_fsblk_t pblk = ext4_ext_pblock(ex);
413 unsigned int len = ext4_ext_get_actual_len(ex); 394 unsigned int len = ext4_ext_get_actual_len(ex);
414 int err = 0; 395 int ret, err = 0;
396
397#if 0
398 ext4_msg(inode->i_sb, KERN_CRIT,
399 "ext4_encrypted_zeroout ino %lu lblk %u len %u",
400 (unsigned long) inode->i_ino, lblk, len);
401#endif
415 402
416 BUG_ON(inode->i_sb->s_blocksize != PAGE_CACHE_SIZE); 403 BUG_ON(inode->i_sb->s_blocksize != PAGE_CACHE_SIZE);
417 404
@@ -426,7 +413,7 @@ int ext4_encrypted_zeroout(struct inode *inode, struct ext4_extent *ex)
426 } 413 }
427 414
428 while (len--) { 415 while (len--) {
429 err = ext4_page_crypto(ctx, inode, EXT4_ENCRYPT, lblk, 416 err = ext4_page_crypto(inode, EXT4_ENCRYPT, lblk,
430 ZERO_PAGE(0), ciphertext_page); 417 ZERO_PAGE(0), ciphertext_page);
431 if (err) 418 if (err)
432 goto errout; 419 goto errout;
@@ -437,17 +424,26 @@ int ext4_encrypted_zeroout(struct inode *inode, struct ext4_extent *ex)
437 goto errout; 424 goto errout;
438 } 425 }
439 bio->bi_bdev = inode->i_sb->s_bdev; 426 bio->bi_bdev = inode->i_sb->s_bdev;
440 bio->bi_iter.bi_sector = pblk; 427 bio->bi_iter.bi_sector =
441 err = bio_add_page(bio, ciphertext_page, 428 pblk << (inode->i_sb->s_blocksize_bits - 9);
429 ret = bio_add_page(bio, ciphertext_page,
442 inode->i_sb->s_blocksize, 0); 430 inode->i_sb->s_blocksize, 0);
443 if (err) { 431 if (ret != inode->i_sb->s_blocksize) {
432 /* should never happen! */
433 ext4_msg(inode->i_sb, KERN_ERR,
434 "bio_add_page failed: %d", ret);
435 WARN_ON(1);
444 bio_put(bio); 436 bio_put(bio);
437 err = -EIO;
445 goto errout; 438 goto errout;
446 } 439 }
447 err = submit_bio_wait(WRITE, bio); 440 err = submit_bio_wait(WRITE, bio);
441 if ((err == 0) && bio->bi_error)
442 err = -EIO;
448 bio_put(bio); 443 bio_put(bio);
449 if (err) 444 if (err)
450 goto errout; 445 goto errout;
446 lblk++; pblk++;
451 } 447 }
452 err = 0; 448 err = 0;
453errout: 449errout:
diff --git a/fs/ext4/crypto_fname.c b/fs/ext4/crypto_fname.c
index 847f919c84d9..2fbef8a14760 100644
--- a/fs/ext4/crypto_fname.c
+++ b/fs/ext4/crypto_fname.c
@@ -120,7 +120,6 @@ static int ext4_fname_encrypt(struct inode *inode,
120 ablkcipher_request_set_crypt(req, &src_sg, &dst_sg, ciphertext_len, iv); 120 ablkcipher_request_set_crypt(req, &src_sg, &dst_sg, ciphertext_len, iv);
121 res = crypto_ablkcipher_encrypt(req); 121 res = crypto_ablkcipher_encrypt(req);
122 if (res == -EINPROGRESS || res == -EBUSY) { 122 if (res == -EINPROGRESS || res == -EBUSY) {
123 BUG_ON(req->base.data != &ecr);
124 wait_for_completion(&ecr.completion); 123 wait_for_completion(&ecr.completion);
125 res = ecr.res; 124 res = ecr.res;
126 } 125 }
@@ -182,7 +181,6 @@ static int ext4_fname_decrypt(struct inode *inode,
182 ablkcipher_request_set_crypt(req, &src_sg, &dst_sg, iname->len, iv); 181 ablkcipher_request_set_crypt(req, &src_sg, &dst_sg, iname->len, iv);
183 res = crypto_ablkcipher_decrypt(req); 182 res = crypto_ablkcipher_decrypt(req);
184 if (res == -EINPROGRESS || res == -EBUSY) { 183 if (res == -EINPROGRESS || res == -EBUSY) {
185 BUG_ON(req->base.data != &ecr);
186 wait_for_completion(&ecr.completion); 184 wait_for_completion(&ecr.completion);
187 res = ecr.res; 185 res = ecr.res;
188 } 186 }
diff --git a/fs/ext4/crypto_key.c b/fs/ext4/crypto_key.c
index 5c52c79dea46..c5882b36e558 100644
--- a/fs/ext4/crypto_key.c
+++ b/fs/ext4/crypto_key.c
@@ -71,7 +71,6 @@ static int ext4_derive_key_aes(char deriving_key[EXT4_AES_128_ECB_KEY_SIZE],
71 EXT4_AES_256_XTS_KEY_SIZE, NULL); 71 EXT4_AES_256_XTS_KEY_SIZE, NULL);
72 res = crypto_ablkcipher_encrypt(req); 72 res = crypto_ablkcipher_encrypt(req);
73 if (res == -EINPROGRESS || res == -EBUSY) { 73 if (res == -EINPROGRESS || res == -EBUSY) {
74 BUG_ON(req->base.data != &ecr);
75 wait_for_completion(&ecr.completion); 74 wait_for_completion(&ecr.completion);
76 res = ecr.res; 75 res = ecr.res;
77 } 76 }
@@ -208,7 +207,12 @@ retry:
208 goto out; 207 goto out;
209 } 208 }
210 crypt_info->ci_keyring_key = keyring_key; 209 crypt_info->ci_keyring_key = keyring_key;
211 BUG_ON(keyring_key->type != &key_type_logon); 210 if (keyring_key->type != &key_type_logon) {
211 printk_once(KERN_WARNING
212 "ext4: key type must be logon\n");
213 res = -ENOKEY;
214 goto out;
215 }
212 ukp = user_key_payload(keyring_key); 216 ukp = user_key_payload(keyring_key);
213 if (ukp->datalen != sizeof(struct ext4_encryption_key)) { 217 if (ukp->datalen != sizeof(struct ext4_encryption_key)) {
214 res = -EINVAL; 218 res = -EINVAL;
@@ -217,7 +221,13 @@ retry:
217 master_key = (struct ext4_encryption_key *)ukp->data; 221 master_key = (struct ext4_encryption_key *)ukp->data;
218 BUILD_BUG_ON(EXT4_AES_128_ECB_KEY_SIZE != 222 BUILD_BUG_ON(EXT4_AES_128_ECB_KEY_SIZE !=
219 EXT4_KEY_DERIVATION_NONCE_SIZE); 223 EXT4_KEY_DERIVATION_NONCE_SIZE);
220 BUG_ON(master_key->size != EXT4_AES_256_XTS_KEY_SIZE); 224 if (master_key->size != EXT4_AES_256_XTS_KEY_SIZE) {
225 printk_once(KERN_WARNING
226 "ext4: key size incorrect: %d\n",
227 master_key->size);
228 res = -ENOKEY;
229 goto out;
230 }
221 res = ext4_derive_key_aes(ctx.nonce, master_key->raw, 231 res = ext4_derive_key_aes(ctx.nonce, master_key->raw,
222 raw_key); 232 raw_key);
223 if (res) 233 if (res)
diff --git a/fs/ext4/crypto_policy.c b/fs/ext4/crypto_policy.c
index a640ec2c4b13..ad050698143f 100644
--- a/fs/ext4/crypto_policy.c
+++ b/fs/ext4/crypto_policy.c
@@ -150,7 +150,8 @@ int ext4_is_child_context_consistent_with_parent(struct inode *parent,
150 150
151 if ((parent == NULL) || (child == NULL)) { 151 if ((parent == NULL) || (child == NULL)) {
152 pr_err("parent %p child %p\n", parent, child); 152 pr_err("parent %p child %p\n", parent, child);
153 BUG_ON(1); 153 WARN_ON(1); /* Should never happen */
154 return 0;
154 } 155 }
155 /* no restrictions if the parent directory is not encrypted */ 156 /* no restrictions if the parent directory is not encrypted */
156 if (!ext4_encrypted_inode(parent)) 157 if (!ext4_encrypted_inode(parent))
diff --git a/fs/ext4/dir.c b/fs/ext4/dir.c
index f9e14911918c..1d1bca74f844 100644
--- a/fs/ext4/dir.c
+++ b/fs/ext4/dir.c
@@ -40,8 +40,7 @@ static int is_dx_dir(struct inode *inode)
40{ 40{
41 struct super_block *sb = inode->i_sb; 41 struct super_block *sb = inode->i_sb;
42 42
43 if (EXT4_HAS_COMPAT_FEATURE(inode->i_sb, 43 if (ext4_has_feature_dir_index(inode->i_sb) &&
44 EXT4_FEATURE_COMPAT_DIR_INDEX) &&
45 ((ext4_test_inode_flag(inode, EXT4_INODE_INDEX)) || 44 ((ext4_test_inode_flag(inode, EXT4_INODE_INDEX)) ||
46 ((inode->i_size >> sb->s_blocksize_bits) == 1) || 45 ((inode->i_size >> sb->s_blocksize_bits) == 1) ||
47 ext4_has_inline_data(inode))) 46 ext4_has_inline_data(inode)))
@@ -621,14 +620,14 @@ int ext4_check_all_de(struct inode *dir, struct buffer_head *bh, void *buf,
621 while ((char *) de < top) { 620 while ((char *) de < top) {
622 if (ext4_check_dir_entry(dir, NULL, de, bh, 621 if (ext4_check_dir_entry(dir, NULL, de, bh,
623 buf, buf_size, offset)) 622 buf, buf_size, offset))
624 return -EIO; 623 return -EFSCORRUPTED;
625 nlen = EXT4_DIR_REC_LEN(de->name_len); 624 nlen = EXT4_DIR_REC_LEN(de->name_len);
626 rlen = ext4_rec_len_from_disk(de->rec_len, buf_size); 625 rlen = ext4_rec_len_from_disk(de->rec_len, buf_size);
627 de = (struct ext4_dir_entry_2 *)((char *)de + rlen); 626 de = (struct ext4_dir_entry_2 *)((char *)de + rlen);
628 offset += rlen; 627 offset += rlen;
629 } 628 }
630 if ((char *) de > top) 629 if ((char *) de > top)
631 return -EIO; 630 return -EFSCORRUPTED;
632 631
633 return 0; 632 return 0;
634} 633}
diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index fd1f28be5296..750063f7a50c 100644
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -374,6 +374,7 @@ struct flex_groups {
374#define EXT4_EA_INODE_FL 0x00200000 /* Inode used for large EA */ 374#define EXT4_EA_INODE_FL 0x00200000 /* Inode used for large EA */
375#define EXT4_EOFBLOCKS_FL 0x00400000 /* Blocks allocated beyond EOF */ 375#define EXT4_EOFBLOCKS_FL 0x00400000 /* Blocks allocated beyond EOF */
376#define EXT4_INLINE_DATA_FL 0x10000000 /* Inode has inline data. */ 376#define EXT4_INLINE_DATA_FL 0x10000000 /* Inode has inline data. */
377#define EXT4_PROJINHERIT_FL 0x20000000 /* Create with parents projid */
377#define EXT4_RESERVED_FL 0x80000000 /* reserved for ext4 lib */ 378#define EXT4_RESERVED_FL 0x80000000 /* reserved for ext4 lib */
378 379
379#define EXT4_FL_USER_VISIBLE 0x004BDFFF /* User visible flags */ 380#define EXT4_FL_USER_VISIBLE 0x004BDFFF /* User visible flags */
@@ -431,6 +432,7 @@ enum {
431 EXT4_INODE_EA_INODE = 21, /* Inode used for large EA */ 432 EXT4_INODE_EA_INODE = 21, /* Inode used for large EA */
432 EXT4_INODE_EOFBLOCKS = 22, /* Blocks allocated beyond EOF */ 433 EXT4_INODE_EOFBLOCKS = 22, /* Blocks allocated beyond EOF */
433 EXT4_INODE_INLINE_DATA = 28, /* Data in inode. */ 434 EXT4_INODE_INLINE_DATA = 28, /* Data in inode. */
435 EXT4_INODE_PROJINHERIT = 29, /* Create with parents projid */
434 EXT4_INODE_RESERVED = 31, /* reserved for ext4 lib */ 436 EXT4_INODE_RESERVED = 31, /* reserved for ext4 lib */
435}; 437};
436 438
@@ -475,6 +477,7 @@ static inline void ext4_check_flag_values(void)
475 CHECK_FLAG_VALUE(EA_INODE); 477 CHECK_FLAG_VALUE(EA_INODE);
476 CHECK_FLAG_VALUE(EOFBLOCKS); 478 CHECK_FLAG_VALUE(EOFBLOCKS);
477 CHECK_FLAG_VALUE(INLINE_DATA); 479 CHECK_FLAG_VALUE(INLINE_DATA);
480 CHECK_FLAG_VALUE(PROJINHERIT);
478 CHECK_FLAG_VALUE(RESERVED); 481 CHECK_FLAG_VALUE(RESERVED);
479} 482}
480 483
@@ -692,6 +695,7 @@ struct ext4_inode {
692 __le32 i_crtime; /* File Creation time */ 695 __le32 i_crtime; /* File Creation time */
693 __le32 i_crtime_extra; /* extra FileCreationtime (nsec << 2 | epoch) */ 696 __le32 i_crtime_extra; /* extra FileCreationtime (nsec << 2 | epoch) */
694 __le32 i_version_hi; /* high 32 bits for 64-bit version */ 697 __le32 i_version_hi; /* high 32 bits for 64-bit version */
698 __le32 i_projid; /* Project ID */
695}; 699};
696 700
697struct move_extent { 701struct move_extent {
@@ -1019,6 +1023,9 @@ struct ext4_inode_info {
1019#define EXT4_MOUNT2_HURD_COMPAT 0x00000004 /* Support HURD-castrated 1023#define EXT4_MOUNT2_HURD_COMPAT 0x00000004 /* Support HURD-castrated
1020 file systems */ 1024 file systems */
1021 1025
1026#define EXT4_MOUNT2_EXPLICIT_JOURNAL_CHECKSUM 0x00000008 /* User explicitly
1027 specified journal checksum */
1028
1022#define clear_opt(sb, opt) EXT4_SB(sb)->s_mount_opt &= \ 1029#define clear_opt(sb, opt) EXT4_SB(sb)->s_mount_opt &= \
1023 ~EXT4_MOUNT_##opt 1030 ~EXT4_MOUNT_##opt
1024#define set_opt(sb, opt) EXT4_SB(sb)->s_mount_opt |= \ 1031#define set_opt(sb, opt) EXT4_SB(sb)->s_mount_opt |= \
@@ -1179,7 +1186,9 @@ struct ext4_super_block {
1179 __u8 s_encrypt_algos[4]; /* Encryption algorithms in use */ 1186 __u8 s_encrypt_algos[4]; /* Encryption algorithms in use */
1180 __u8 s_encrypt_pw_salt[16]; /* Salt used for string2key algorithm */ 1187 __u8 s_encrypt_pw_salt[16]; /* Salt used for string2key algorithm */
1181 __le32 s_lpf_ino; /* Location of the lost+found inode */ 1188 __le32 s_lpf_ino; /* Location of the lost+found inode */
1182 __le32 s_reserved[100]; /* Padding to the end of the block */ 1189 __le32 s_prj_quota_inum; /* inode for tracking project quota */
1190 __le32 s_checksum_seed; /* crc32c(uuid) if csum_seed set */
1191 __le32 s_reserved[98]; /* Padding to the end of the block */
1183 __le32 s_checksum; /* crc32c(superblock) */ 1192 __le32 s_checksum; /* crc32c(superblock) */
1184}; 1193};
1185 1194
@@ -1522,6 +1531,7 @@ static inline int ext4_encrypted_inode(struct inode *inode)
1522 * Feature set definitions 1531 * Feature set definitions
1523 */ 1532 */
1524 1533
1534/* Use the ext4_{has,set,clear}_feature_* helpers; these will be removed */
1525#define EXT4_HAS_COMPAT_FEATURE(sb,mask) \ 1535#define EXT4_HAS_COMPAT_FEATURE(sb,mask) \
1526 ((EXT4_SB(sb)->s_es->s_feature_compat & cpu_to_le32(mask)) != 0) 1536 ((EXT4_SB(sb)->s_es->s_feature_compat & cpu_to_le32(mask)) != 0)
1527#define EXT4_HAS_RO_COMPAT_FEATURE(sb,mask) \ 1537#define EXT4_HAS_RO_COMPAT_FEATURE(sb,mask) \
@@ -1566,6 +1576,7 @@ static inline int ext4_encrypted_inode(struct inode *inode)
1566 */ 1576 */
1567#define EXT4_FEATURE_RO_COMPAT_METADATA_CSUM 0x0400 1577#define EXT4_FEATURE_RO_COMPAT_METADATA_CSUM 0x0400
1568#define EXT4_FEATURE_RO_COMPAT_READONLY 0x1000 1578#define EXT4_FEATURE_RO_COMPAT_READONLY 0x1000
1579#define EXT4_FEATURE_RO_COMPAT_PROJECT 0x2000
1569 1580
1570#define EXT4_FEATURE_INCOMPAT_COMPRESSION 0x0001 1581#define EXT4_FEATURE_INCOMPAT_COMPRESSION 0x0001
1571#define EXT4_FEATURE_INCOMPAT_FILETYPE 0x0002 1582#define EXT4_FEATURE_INCOMPAT_FILETYPE 0x0002
@@ -1578,11 +1589,99 @@ static inline int ext4_encrypted_inode(struct inode *inode)
1578#define EXT4_FEATURE_INCOMPAT_FLEX_BG 0x0200 1589#define EXT4_FEATURE_INCOMPAT_FLEX_BG 0x0200
1579#define EXT4_FEATURE_INCOMPAT_EA_INODE 0x0400 /* EA in inode */ 1590#define EXT4_FEATURE_INCOMPAT_EA_INODE 0x0400 /* EA in inode */
1580#define EXT4_FEATURE_INCOMPAT_DIRDATA 0x1000 /* data in dirent */ 1591#define EXT4_FEATURE_INCOMPAT_DIRDATA 0x1000 /* data in dirent */
1581#define EXT4_FEATURE_INCOMPAT_BG_USE_META_CSUM 0x2000 /* use crc32c for bg */ 1592#define EXT4_FEATURE_INCOMPAT_CSUM_SEED 0x2000
1582#define EXT4_FEATURE_INCOMPAT_LARGEDIR 0x4000 /* >2GB or 3-lvl htree */ 1593#define EXT4_FEATURE_INCOMPAT_LARGEDIR 0x4000 /* >2GB or 3-lvl htree */
1583#define EXT4_FEATURE_INCOMPAT_INLINE_DATA 0x8000 /* data in inode */ 1594#define EXT4_FEATURE_INCOMPAT_INLINE_DATA 0x8000 /* data in inode */
1584#define EXT4_FEATURE_INCOMPAT_ENCRYPT 0x10000 1595#define EXT4_FEATURE_INCOMPAT_ENCRYPT 0x10000
1585 1596
1597#define EXT4_FEATURE_COMPAT_FUNCS(name, flagname) \
1598static inline bool ext4_has_feature_##name(struct super_block *sb) \
1599{ \
1600 return ((EXT4_SB(sb)->s_es->s_feature_compat & \
1601 cpu_to_le32(EXT4_FEATURE_COMPAT_##flagname)) != 0); \
1602} \
1603static inline void ext4_set_feature_##name(struct super_block *sb) \
1604{ \
1605 EXT4_SB(sb)->s_es->s_feature_compat |= \
1606 cpu_to_le32(EXT4_FEATURE_COMPAT_##flagname); \
1607} \
1608static inline void ext4_clear_feature_##name(struct super_block *sb) \
1609{ \
1610 EXT4_SB(sb)->s_es->s_feature_compat &= \
1611 ~cpu_to_le32(EXT4_FEATURE_COMPAT_##flagname); \
1612}
1613
1614#define EXT4_FEATURE_RO_COMPAT_FUNCS(name, flagname) \
1615static inline bool ext4_has_feature_##name(struct super_block *sb) \
1616{ \
1617 return ((EXT4_SB(sb)->s_es->s_feature_ro_compat & \
1618 cpu_to_le32(EXT4_FEATURE_RO_COMPAT_##flagname)) != 0); \
1619} \
1620static inline void ext4_set_feature_##name(struct super_block *sb) \
1621{ \
1622 EXT4_SB(sb)->s_es->s_feature_ro_compat |= \
1623 cpu_to_le32(EXT4_FEATURE_RO_COMPAT_##flagname); \
1624} \
1625static inline void ext4_clear_feature_##name(struct super_block *sb) \
1626{ \
1627 EXT4_SB(sb)->s_es->s_feature_ro_compat &= \
1628 ~cpu_to_le32(EXT4_FEATURE_RO_COMPAT_##flagname); \
1629}
1630
1631#define EXT4_FEATURE_INCOMPAT_FUNCS(name, flagname) \
1632static inline bool ext4_has_feature_##name(struct super_block *sb) \
1633{ \
1634 return ((EXT4_SB(sb)->s_es->s_feature_incompat & \
1635 cpu_to_le32(EXT4_FEATURE_INCOMPAT_##flagname)) != 0); \
1636} \
1637static inline void ext4_set_feature_##name(struct super_block *sb) \
1638{ \
1639 EXT4_SB(sb)->s_es->s_feature_incompat |= \
1640 cpu_to_le32(EXT4_FEATURE_INCOMPAT_##flagname); \
1641} \
1642static inline void ext4_clear_feature_##name(struct super_block *sb) \
1643{ \
1644 EXT4_SB(sb)->s_es->s_feature_incompat &= \
1645 ~cpu_to_le32(EXT4_FEATURE_INCOMPAT_##flagname); \
1646}
1647
1648EXT4_FEATURE_COMPAT_FUNCS(dir_prealloc, DIR_PREALLOC)
1649EXT4_FEATURE_COMPAT_FUNCS(imagic_inodes, IMAGIC_INODES)
1650EXT4_FEATURE_COMPAT_FUNCS(journal, HAS_JOURNAL)
1651EXT4_FEATURE_COMPAT_FUNCS(xattr, EXT_ATTR)
1652EXT4_FEATURE_COMPAT_FUNCS(resize_inode, RESIZE_INODE)
1653EXT4_FEATURE_COMPAT_FUNCS(dir_index, DIR_INDEX)
1654EXT4_FEATURE_COMPAT_FUNCS(sparse_super2, SPARSE_SUPER2)
1655
1656EXT4_FEATURE_RO_COMPAT_FUNCS(sparse_super, SPARSE_SUPER)
1657EXT4_FEATURE_RO_COMPAT_FUNCS(large_file, LARGE_FILE)
1658EXT4_FEATURE_RO_COMPAT_FUNCS(btree_dir, BTREE_DIR)
1659EXT4_FEATURE_RO_COMPAT_FUNCS(huge_file, HUGE_FILE)
1660EXT4_FEATURE_RO_COMPAT_FUNCS(gdt_csum, GDT_CSUM)
1661EXT4_FEATURE_RO_COMPAT_FUNCS(dir_nlink, DIR_NLINK)
1662EXT4_FEATURE_RO_COMPAT_FUNCS(extra_isize, EXTRA_ISIZE)
1663EXT4_FEATURE_RO_COMPAT_FUNCS(quota, QUOTA)
1664EXT4_FEATURE_RO_COMPAT_FUNCS(bigalloc, BIGALLOC)
1665EXT4_FEATURE_RO_COMPAT_FUNCS(metadata_csum, METADATA_CSUM)
1666EXT4_FEATURE_RO_COMPAT_FUNCS(readonly, READONLY)
1667EXT4_FEATURE_RO_COMPAT_FUNCS(project, PROJECT)
1668
1669EXT4_FEATURE_INCOMPAT_FUNCS(compression, COMPRESSION)
1670EXT4_FEATURE_INCOMPAT_FUNCS(filetype, FILETYPE)
1671EXT4_FEATURE_INCOMPAT_FUNCS(journal_needs_recovery, RECOVER)
1672EXT4_FEATURE_INCOMPAT_FUNCS(journal_dev, JOURNAL_DEV)
1673EXT4_FEATURE_INCOMPAT_FUNCS(meta_bg, META_BG)
1674EXT4_FEATURE_INCOMPAT_FUNCS(extents, EXTENTS)
1675EXT4_FEATURE_INCOMPAT_FUNCS(64bit, 64BIT)
1676EXT4_FEATURE_INCOMPAT_FUNCS(mmp, MMP)
1677EXT4_FEATURE_INCOMPAT_FUNCS(flex_bg, FLEX_BG)
1678EXT4_FEATURE_INCOMPAT_FUNCS(ea_inode, EA_INODE)
1679EXT4_FEATURE_INCOMPAT_FUNCS(dirdata, DIRDATA)
1680EXT4_FEATURE_INCOMPAT_FUNCS(csum_seed, CSUM_SEED)
1681EXT4_FEATURE_INCOMPAT_FUNCS(largedir, LARGEDIR)
1682EXT4_FEATURE_INCOMPAT_FUNCS(inline_data, INLINE_DATA)
1683EXT4_FEATURE_INCOMPAT_FUNCS(encrypt, ENCRYPT)
1684
1586#define EXT2_FEATURE_COMPAT_SUPP EXT4_FEATURE_COMPAT_EXT_ATTR 1685#define EXT2_FEATURE_COMPAT_SUPP EXT4_FEATURE_COMPAT_EXT_ATTR
1587#define EXT2_FEATURE_INCOMPAT_SUPP (EXT4_FEATURE_INCOMPAT_FILETYPE| \ 1686#define EXT2_FEATURE_INCOMPAT_SUPP (EXT4_FEATURE_INCOMPAT_FILETYPE| \
1588 EXT4_FEATURE_INCOMPAT_META_BG) 1687 EXT4_FEATURE_INCOMPAT_META_BG)
@@ -1598,7 +1697,7 @@ static inline int ext4_encrypted_inode(struct inode *inode)
1598 EXT4_FEATURE_RO_COMPAT_LARGE_FILE| \ 1697 EXT4_FEATURE_RO_COMPAT_LARGE_FILE| \
1599 EXT4_FEATURE_RO_COMPAT_BTREE_DIR) 1698 EXT4_FEATURE_RO_COMPAT_BTREE_DIR)
1600 1699
1601#define EXT4_FEATURE_COMPAT_SUPP EXT2_FEATURE_COMPAT_EXT_ATTR 1700#define EXT4_FEATURE_COMPAT_SUPP EXT4_FEATURE_COMPAT_EXT_ATTR
1602#define EXT4_FEATURE_INCOMPAT_SUPP (EXT4_FEATURE_INCOMPAT_FILETYPE| \ 1701#define EXT4_FEATURE_INCOMPAT_SUPP (EXT4_FEATURE_INCOMPAT_FILETYPE| \
1603 EXT4_FEATURE_INCOMPAT_RECOVER| \ 1702 EXT4_FEATURE_INCOMPAT_RECOVER| \
1604 EXT4_FEATURE_INCOMPAT_META_BG| \ 1703 EXT4_FEATURE_INCOMPAT_META_BG| \
@@ -1607,7 +1706,8 @@ static inline int ext4_encrypted_inode(struct inode *inode)
1607 EXT4_FEATURE_INCOMPAT_FLEX_BG| \ 1706 EXT4_FEATURE_INCOMPAT_FLEX_BG| \
1608 EXT4_FEATURE_INCOMPAT_MMP | \ 1707 EXT4_FEATURE_INCOMPAT_MMP | \
1609 EXT4_FEATURE_INCOMPAT_INLINE_DATA | \ 1708 EXT4_FEATURE_INCOMPAT_INLINE_DATA | \
1610 EXT4_FEATURE_INCOMPAT_ENCRYPT) 1709 EXT4_FEATURE_INCOMPAT_ENCRYPT | \
1710 EXT4_FEATURE_INCOMPAT_CSUM_SEED)
1611#define EXT4_FEATURE_RO_COMPAT_SUPP (EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER| \ 1711#define EXT4_FEATURE_RO_COMPAT_SUPP (EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER| \
1612 EXT4_FEATURE_RO_COMPAT_LARGE_FILE| \ 1712 EXT4_FEATURE_RO_COMPAT_LARGE_FILE| \
1613 EXT4_FEATURE_RO_COMPAT_GDT_CSUM| \ 1713 EXT4_FEATURE_RO_COMPAT_GDT_CSUM| \
@@ -1619,6 +1719,40 @@ static inline int ext4_encrypted_inode(struct inode *inode)
1619 EXT4_FEATURE_RO_COMPAT_METADATA_CSUM|\ 1719 EXT4_FEATURE_RO_COMPAT_METADATA_CSUM|\
1620 EXT4_FEATURE_RO_COMPAT_QUOTA) 1720 EXT4_FEATURE_RO_COMPAT_QUOTA)
1621 1721
1722#define EXTN_FEATURE_FUNCS(ver) \
1723static inline bool ext4_has_unknown_ext##ver##_compat_features(struct super_block *sb) \
1724{ \
1725 return ((EXT4_SB(sb)->s_es->s_feature_compat & \
1726 cpu_to_le32(~EXT##ver##_FEATURE_COMPAT_SUPP)) != 0); \
1727} \
1728static inline bool ext4_has_unknown_ext##ver##_ro_compat_features(struct super_block *sb) \
1729{ \
1730 return ((EXT4_SB(sb)->s_es->s_feature_ro_compat & \
1731 cpu_to_le32(~EXT##ver##_FEATURE_RO_COMPAT_SUPP)) != 0); \
1732} \
1733static inline bool ext4_has_unknown_ext##ver##_incompat_features(struct super_block *sb) \
1734{ \
1735 return ((EXT4_SB(sb)->s_es->s_feature_incompat & \
1736 cpu_to_le32(~EXT##ver##_FEATURE_INCOMPAT_SUPP)) != 0); \
1737}
1738
1739EXTN_FEATURE_FUNCS(2)
1740EXTN_FEATURE_FUNCS(3)
1741EXTN_FEATURE_FUNCS(4)
1742
1743static inline bool ext4_has_compat_features(struct super_block *sb)
1744{
1745 return (EXT4_SB(sb)->s_es->s_feature_compat != 0);
1746}
1747static inline bool ext4_has_ro_compat_features(struct super_block *sb)
1748{
1749 return (EXT4_SB(sb)->s_es->s_feature_ro_compat != 0);
1750}
1751static inline bool ext4_has_incompat_features(struct super_block *sb)
1752{
1753 return (EXT4_SB(sb)->s_es->s_feature_incompat != 0);
1754}
1755
1622/* 1756/*
1623 * Default values for user and/or group using reserved blocks 1757 * Default values for user and/or group using reserved blocks
1624 */ 1758 */
@@ -1769,8 +1903,7 @@ static inline __le16 ext4_rec_len_to_disk(unsigned len, unsigned blocksize)
1769 * (c) Daniel Phillips, 2001 1903 * (c) Daniel Phillips, 2001
1770 */ 1904 */
1771 1905
1772#define is_dx(dir) (EXT4_HAS_COMPAT_FEATURE(dir->i_sb, \ 1906#define is_dx(dir) (ext4_has_feature_dir_index((dir)->i_sb) && \
1773 EXT4_FEATURE_COMPAT_DIR_INDEX) && \
1774 ext4_test_inode_flag((dir), EXT4_INODE_INDEX)) 1907 ext4_test_inode_flag((dir), EXT4_INODE_INDEX))
1775#define EXT4_DIR_LINK_MAX(dir) (!is_dx(dir) && (dir)->i_nlink >= EXT4_LINK_MAX) 1908#define EXT4_DIR_LINK_MAX(dir) (!is_dx(dir) && (dir)->i_nlink >= EXT4_LINK_MAX)
1776#define EXT4_DIR_LINK_EMPTY(dir) ((dir)->i_nlink == 2 || (dir)->i_nlink == 1) 1909#define EXT4_DIR_LINK_EMPTY(dir) ((dir)->i_nlink == 2 || (dir)->i_nlink == 1)
@@ -2063,8 +2196,7 @@ void ext4_release_crypto_ctx(struct ext4_crypto_ctx *ctx);
2063void ext4_restore_control_page(struct page *data_page); 2196void ext4_restore_control_page(struct page *data_page);
2064struct page *ext4_encrypt(struct inode *inode, 2197struct page *ext4_encrypt(struct inode *inode,
2065 struct page *plaintext_page); 2198 struct page *plaintext_page);
2066int ext4_decrypt(struct ext4_crypto_ctx *ctx, struct page *page); 2199int ext4_decrypt(struct page *page);
2067int ext4_decrypt_one(struct inode *inode, struct page *page);
2068int ext4_encrypted_zeroout(struct inode *inode, struct ext4_extent *ex); 2200int ext4_encrypted_zeroout(struct inode *inode, struct ext4_extent *ex);
2069 2201
2070#ifdef CONFIG_EXT4_FS_ENCRYPTION 2202#ifdef CONFIG_EXT4_FS_ENCRYPTION
@@ -2072,7 +2204,7 @@ int ext4_init_crypto(void);
2072void ext4_exit_crypto(void); 2204void ext4_exit_crypto(void);
2073static inline int ext4_sb_has_crypto(struct super_block *sb) 2205static inline int ext4_sb_has_crypto(struct super_block *sb)
2074{ 2206{
2075 return EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_ENCRYPT); 2207 return ext4_has_feature_encrypt(sb);
2076} 2208}
2077#else 2209#else
2078static inline int ext4_init_crypto(void) { return 0; } 2210static inline int ext4_init_crypto(void) { return 0; }
@@ -2193,8 +2325,7 @@ int ext4_insert_dentry(struct inode *dir,
2193 struct ext4_filename *fname); 2325 struct ext4_filename *fname);
2194static inline void ext4_update_dx_flag(struct inode *inode) 2326static inline void ext4_update_dx_flag(struct inode *inode)
2195{ 2327{
2196 if (!EXT4_HAS_COMPAT_FEATURE(inode->i_sb, 2328 if (!ext4_has_feature_dir_index(inode->i_sb))
2197 EXT4_FEATURE_COMPAT_DIR_INDEX))
2198 ext4_clear_inode_flag(inode, EXT4_INODE_INDEX); 2329 ext4_clear_inode_flag(inode, EXT4_INODE_INDEX);
2199} 2330}
2200static unsigned char ext4_filetype_table[] = { 2331static unsigned char ext4_filetype_table[] = {
@@ -2203,8 +2334,7 @@ static unsigned char ext4_filetype_table[] = {
2203 2334
2204static inline unsigned char get_dtype(struct super_block *sb, int filetype) 2335static inline unsigned char get_dtype(struct super_block *sb, int filetype)
2205{ 2336{
2206 if (!EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FILETYPE) || 2337 if (!ext4_has_feature_filetype(sb) || filetype >= EXT4_FT_MAX)
2207 (filetype >= EXT4_FT_MAX))
2208 return DT_UNKNOWN; 2338 return DT_UNKNOWN;
2209 2339
2210 return ext4_filetype_table[filetype]; 2340 return ext4_filetype_table[filetype];
@@ -2245,6 +2375,7 @@ extern int ext4_init_inode_table(struct super_block *sb,
2245extern void ext4_end_bitmap_read(struct buffer_head *bh, int uptodate); 2375extern void ext4_end_bitmap_read(struct buffer_head *bh, int uptodate);
2246 2376
2247/* mballoc.c */ 2377/* mballoc.c */
2378extern const struct file_operations ext4_seq_mb_groups_fops;
2248extern long ext4_mb_stats; 2379extern long ext4_mb_stats;
2249extern long ext4_mb_max_to_scan; 2380extern long ext4_mb_max_to_scan;
2250extern int ext4_mb_init(struct super_block *); 2381extern int ext4_mb_init(struct super_block *);
@@ -2372,6 +2503,7 @@ extern int ext4_group_extend(struct super_block *sb,
2372extern int ext4_resize_fs(struct super_block *sb, ext4_fsblk_t n_blocks_count); 2503extern int ext4_resize_fs(struct super_block *sb, ext4_fsblk_t n_blocks_count);
2373 2504
2374/* super.c */ 2505/* super.c */
2506extern int ext4_seq_options_show(struct seq_file *seq, void *offset);
2375extern int ext4_calculate_overhead(struct super_block *sb); 2507extern int ext4_calculate_overhead(struct super_block *sb);
2376extern void ext4_superblock_csum_set(struct super_block *sb); 2508extern void ext4_superblock_csum_set(struct super_block *sb);
2377extern void *ext4_kvmalloc(size_t size, gfp_t flags); 2509extern void *ext4_kvmalloc(size_t size, gfp_t flags);
@@ -2534,15 +2666,13 @@ extern int ext4_register_li_request(struct super_block *sb,
2534 2666
2535static inline int ext4_has_group_desc_csum(struct super_block *sb) 2667static inline int ext4_has_group_desc_csum(struct super_block *sb)
2536{ 2668{
2537 return EXT4_HAS_RO_COMPAT_FEATURE(sb, 2669 return ext4_has_feature_gdt_csum(sb) ||
2538 EXT4_FEATURE_RO_COMPAT_GDT_CSUM) || 2670 EXT4_SB(sb)->s_chksum_driver != NULL;
2539 (EXT4_SB(sb)->s_chksum_driver != NULL);
2540} 2671}
2541 2672
2542static inline int ext4_has_metadata_csum(struct super_block *sb) 2673static inline int ext4_has_metadata_csum(struct super_block *sb)
2543{ 2674{
2544 WARN_ON_ONCE(EXT4_HAS_RO_COMPAT_FEATURE(sb, 2675 WARN_ON_ONCE(ext4_has_feature_metadata_csum(sb) &&
2545 EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) &&
2546 !EXT4_SB(sb)->s_chksum_driver); 2676 !EXT4_SB(sb)->s_chksum_driver);
2547 2677
2548 return (EXT4_SB(sb)->s_chksum_driver != NULL); 2678 return (EXT4_SB(sb)->s_chksum_driver != NULL);
@@ -2889,7 +3019,7 @@ static unsigned char ext4_type_by_mode[S_IFMT >> S_SHIFT] = {
2889static inline void ext4_set_de_type(struct super_block *sb, 3019static inline void ext4_set_de_type(struct super_block *sb,
2890 struct ext4_dir_entry_2 *de, 3020 struct ext4_dir_entry_2 *de,
2891 umode_t mode) { 3021 umode_t mode) {
2892 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FILETYPE)) 3022 if (ext4_has_feature_filetype(sb))
2893 de->file_type = ext4_type_by_mode[(mode & S_IFMT)>>S_SHIFT]; 3023 de->file_type = ext4_type_by_mode[(mode & S_IFMT)>>S_SHIFT];
2894} 3024}
2895 3025
@@ -2903,6 +3033,12 @@ extern const struct inode_operations ext4_encrypted_symlink_inode_operations;
2903extern const struct inode_operations ext4_symlink_inode_operations; 3033extern const struct inode_operations ext4_symlink_inode_operations;
2904extern const struct inode_operations ext4_fast_symlink_inode_operations; 3034extern const struct inode_operations ext4_fast_symlink_inode_operations;
2905 3035
3036/* sysfs.c */
3037extern int ext4_register_sysfs(struct super_block *sb);
3038extern void ext4_unregister_sysfs(struct super_block *sb);
3039extern int __init ext4_init_sysfs(void);
3040extern void ext4_exit_sysfs(void);
3041
2906/* block_validity */ 3042/* block_validity */
2907extern void ext4_release_system_zone(struct super_block *sb); 3043extern void ext4_release_system_zone(struct super_block *sb);
2908extern int ext4_setup_system_zone(struct super_block *sb); 3044extern int ext4_setup_system_zone(struct super_block *sb);
@@ -3049,4 +3185,7 @@ extern void ext4_resize_end(struct super_block *sb);
3049 3185
3050#endif /* __KERNEL__ */ 3186#endif /* __KERNEL__ */
3051 3187
3188#define EFSBADCRC EBADMSG /* Bad CRC detected */
3189#define EFSCORRUPTED EUCLEAN /* Filesystem is corrupted */
3190
3052#endif /* _EXT4_H */ 3191#endif /* _EXT4_H */
diff --git a/fs/ext4/ext4_jbd2.c b/fs/ext4/ext4_jbd2.c
index d41843181818..e770c1ee4613 100644
--- a/fs/ext4/ext4_jbd2.c
+++ b/fs/ext4/ext4_jbd2.c
@@ -88,13 +88,13 @@ int __ext4_journal_stop(const char *where, unsigned int line, handle_t *handle)
88 return 0; 88 return 0;
89 } 89 }
90 90
91 err = handle->h_err;
91 if (!handle->h_transaction) { 92 if (!handle->h_transaction) {
92 err = jbd2_journal_stop(handle); 93 rc = jbd2_journal_stop(handle);
93 return handle->h_err ? handle->h_err : err; 94 return err ? err : rc;
94 } 95 }
95 96
96 sb = handle->h_transaction->t_journal->j_private; 97 sb = handle->h_transaction->t_journal->j_private;
97 err = handle->h_err;
98 rc = jbd2_journal_stop(handle); 98 rc = jbd2_journal_stop(handle);
99 99
100 if (!err) 100 if (!err)
diff --git a/fs/ext4/ext4_jbd2.h b/fs/ext4/ext4_jbd2.h
index 9c5b49fb281e..5f5846211095 100644
--- a/fs/ext4/ext4_jbd2.h
+++ b/fs/ext4/ext4_jbd2.h
@@ -34,8 +34,7 @@
34 */ 34 */
35 35
36#define EXT4_SINGLEDATA_TRANS_BLOCKS(sb) \ 36#define EXT4_SINGLEDATA_TRANS_BLOCKS(sb) \
37 (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_EXTENTS) \ 37 (ext4_has_feature_extents(sb) ? 20U : 8U)
38 ? 20U : 8U)
39 38
40/* Extended attribute operations touch at most two data buffers, 39/* Extended attribute operations touch at most two data buffers,
41 * two bitmap buffers, and two group summaries, in addition to the inode 40 * two bitmap buffers, and two group summaries, in addition to the inode
@@ -84,17 +83,16 @@
84/* Amount of blocks needed for quota update - we know that the structure was 83/* Amount of blocks needed for quota update - we know that the structure was
85 * allocated so we need to update only data block */ 84 * allocated so we need to update only data block */
86#define EXT4_QUOTA_TRANS_BLOCKS(sb) ((test_opt(sb, QUOTA) ||\ 85#define EXT4_QUOTA_TRANS_BLOCKS(sb) ((test_opt(sb, QUOTA) ||\
87 EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_QUOTA)) ?\ 86 ext4_has_feature_quota(sb)) ? 1 : 0)
88 1 : 0)
89/* Amount of blocks needed for quota insert/delete - we do some block writes 87/* Amount of blocks needed for quota insert/delete - we do some block writes
90 * but inode, sb and group updates are done only once */ 88 * but inode, sb and group updates are done only once */
91#define EXT4_QUOTA_INIT_BLOCKS(sb) ((test_opt(sb, QUOTA) ||\ 89#define EXT4_QUOTA_INIT_BLOCKS(sb) ((test_opt(sb, QUOTA) ||\
92 EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_QUOTA)) ?\ 90 ext4_has_feature_quota(sb)) ?\
93 (DQUOT_INIT_ALLOC*(EXT4_SINGLEDATA_TRANS_BLOCKS(sb)-3)\ 91 (DQUOT_INIT_ALLOC*(EXT4_SINGLEDATA_TRANS_BLOCKS(sb)-3)\
94 +3+DQUOT_INIT_REWRITE) : 0) 92 +3+DQUOT_INIT_REWRITE) : 0)
95 93
96#define EXT4_QUOTA_DEL_BLOCKS(sb) ((test_opt(sb, QUOTA) ||\ 94#define EXT4_QUOTA_DEL_BLOCKS(sb) ((test_opt(sb, QUOTA) ||\
97 EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_QUOTA)) ?\ 95 ext4_has_feature_quota(sb)) ?\
98 (DQUOT_DEL_ALLOC*(EXT4_SINGLEDATA_TRANS_BLOCKS(sb)-3)\ 96 (DQUOT_DEL_ALLOC*(EXT4_SINGLEDATA_TRANS_BLOCKS(sb)-3)\
99 +3+DQUOT_DEL_REWRITE) : 0) 97 +3+DQUOT_DEL_REWRITE) : 0)
100#else 98#else
diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index 2553aa8b608d..3a6197a2e270 100644
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -442,7 +442,7 @@ static int __ext4_ext_check(const char *function, unsigned int line,
442 int depth, ext4_fsblk_t pblk) 442 int depth, ext4_fsblk_t pblk)
443{ 443{
444 const char *error_msg; 444 const char *error_msg;
445 int max = 0; 445 int max = 0, err = -EFSCORRUPTED;
446 446
447 if (unlikely(eh->eh_magic != EXT4_EXT_MAGIC)) { 447 if (unlikely(eh->eh_magic != EXT4_EXT_MAGIC)) {
448 error_msg = "invalid magic"; 448 error_msg = "invalid magic";
@@ -473,6 +473,7 @@ static int __ext4_ext_check(const char *function, unsigned int line,
473 if (ext_depth(inode) != depth && 473 if (ext_depth(inode) != depth &&
474 !ext4_extent_block_csum_verify(inode, eh)) { 474 !ext4_extent_block_csum_verify(inode, eh)) {
475 error_msg = "extent tree corrupted"; 475 error_msg = "extent tree corrupted";
476 err = -EFSBADCRC;
476 goto corrupted; 477 goto corrupted;
477 } 478 }
478 return 0; 479 return 0;
@@ -485,7 +486,7 @@ corrupted:
485 le16_to_cpu(eh->eh_magic), 486 le16_to_cpu(eh->eh_magic),
486 le16_to_cpu(eh->eh_entries), le16_to_cpu(eh->eh_max), 487 le16_to_cpu(eh->eh_entries), le16_to_cpu(eh->eh_max),
487 max, le16_to_cpu(eh->eh_depth), depth); 488 max, le16_to_cpu(eh->eh_depth), depth);
488 return -EIO; 489 return err;
489} 490}
490 491
491#define ext4_ext_check(inode, eh, depth, pblk) \ 492#define ext4_ext_check(inode, eh, depth, pblk) \
@@ -910,7 +911,7 @@ ext4_find_extent(struct inode *inode, ext4_lblk_t block,
910 put_bh(bh); 911 put_bh(bh);
911 EXT4_ERROR_INODE(inode, 912 EXT4_ERROR_INODE(inode,
912 "ppos %d > depth %d", ppos, depth); 913 "ppos %d > depth %d", ppos, depth);
913 ret = -EIO; 914 ret = -EFSCORRUPTED;
914 goto err; 915 goto err;
915 } 916 }
916 path[ppos].p_bh = bh; 917 path[ppos].p_bh = bh;
@@ -959,7 +960,7 @@ static int ext4_ext_insert_index(handle_t *handle, struct inode *inode,
959 EXT4_ERROR_INODE(inode, 960 EXT4_ERROR_INODE(inode,
960 "logical %d == ei_block %d!", 961 "logical %d == ei_block %d!",
961 logical, le32_to_cpu(curp->p_idx->ei_block)); 962 logical, le32_to_cpu(curp->p_idx->ei_block));
962 return -EIO; 963 return -EFSCORRUPTED;
963 } 964 }
964 965
965 if (unlikely(le16_to_cpu(curp->p_hdr->eh_entries) 966 if (unlikely(le16_to_cpu(curp->p_hdr->eh_entries)
@@ -968,7 +969,7 @@ static int ext4_ext_insert_index(handle_t *handle, struct inode *inode,
968 "eh_entries %d >= eh_max %d!", 969 "eh_entries %d >= eh_max %d!",
969 le16_to_cpu(curp->p_hdr->eh_entries), 970 le16_to_cpu(curp->p_hdr->eh_entries),
970 le16_to_cpu(curp->p_hdr->eh_max)); 971 le16_to_cpu(curp->p_hdr->eh_max));
971 return -EIO; 972 return -EFSCORRUPTED;
972 } 973 }
973 974
974 if (logical > le32_to_cpu(curp->p_idx->ei_block)) { 975 if (logical > le32_to_cpu(curp->p_idx->ei_block)) {
@@ -992,7 +993,7 @@ static int ext4_ext_insert_index(handle_t *handle, struct inode *inode,
992 993
993 if (unlikely(ix > EXT_MAX_INDEX(curp->p_hdr))) { 994 if (unlikely(ix > EXT_MAX_INDEX(curp->p_hdr))) {
994 EXT4_ERROR_INODE(inode, "ix > EXT_MAX_INDEX!"); 995 EXT4_ERROR_INODE(inode, "ix > EXT_MAX_INDEX!");
995 return -EIO; 996 return -EFSCORRUPTED;
996 } 997 }
997 998
998 ix->ei_block = cpu_to_le32(logical); 999 ix->ei_block = cpu_to_le32(logical);
@@ -1001,7 +1002,7 @@ static int ext4_ext_insert_index(handle_t *handle, struct inode *inode,
1001 1002
1002 if (unlikely(ix > EXT_LAST_INDEX(curp->p_hdr))) { 1003 if (unlikely(ix > EXT_LAST_INDEX(curp->p_hdr))) {
1003 EXT4_ERROR_INODE(inode, "ix > EXT_LAST_INDEX!"); 1004 EXT4_ERROR_INODE(inode, "ix > EXT_LAST_INDEX!");
1004 return -EIO; 1005 return -EFSCORRUPTED;
1005 } 1006 }
1006 1007
1007 err = ext4_ext_dirty(handle, inode, curp); 1008 err = ext4_ext_dirty(handle, inode, curp);
@@ -1042,7 +1043,7 @@ static int ext4_ext_split(handle_t *handle, struct inode *inode,
1042 * border from split point */ 1043 * border from split point */
1043 if (unlikely(path[depth].p_ext > EXT_MAX_EXTENT(path[depth].p_hdr))) { 1044 if (unlikely(path[depth].p_ext > EXT_MAX_EXTENT(path[depth].p_hdr))) {
1044 EXT4_ERROR_INODE(inode, "p_ext > EXT_MAX_EXTENT!"); 1045 EXT4_ERROR_INODE(inode, "p_ext > EXT_MAX_EXTENT!");
1045 return -EIO; 1046 return -EFSCORRUPTED;
1046 } 1047 }
1047 if (path[depth].p_ext != EXT_MAX_EXTENT(path[depth].p_hdr)) { 1048 if (path[depth].p_ext != EXT_MAX_EXTENT(path[depth].p_hdr)) {
1048 border = path[depth].p_ext[1].ee_block; 1049 border = path[depth].p_ext[1].ee_block;
@@ -1086,7 +1087,7 @@ static int ext4_ext_split(handle_t *handle, struct inode *inode,
1086 newblock = ablocks[--a]; 1087 newblock = ablocks[--a];
1087 if (unlikely(newblock == 0)) { 1088 if (unlikely(newblock == 0)) {
1088 EXT4_ERROR_INODE(inode, "newblock == 0!"); 1089 EXT4_ERROR_INODE(inode, "newblock == 0!");
1089 err = -EIO; 1090 err = -EFSCORRUPTED;
1090 goto cleanup; 1091 goto cleanup;
1091 } 1092 }
1092 bh = sb_getblk_gfp(inode->i_sb, newblock, __GFP_MOVABLE | GFP_NOFS); 1093 bh = sb_getblk_gfp(inode->i_sb, newblock, __GFP_MOVABLE | GFP_NOFS);
@@ -1112,7 +1113,7 @@ static int ext4_ext_split(handle_t *handle, struct inode *inode,
1112 EXT4_ERROR_INODE(inode, "eh_entries %d != eh_max %d!", 1113 EXT4_ERROR_INODE(inode, "eh_entries %d != eh_max %d!",
1113 path[depth].p_hdr->eh_entries, 1114 path[depth].p_hdr->eh_entries,
1114 path[depth].p_hdr->eh_max); 1115 path[depth].p_hdr->eh_max);
1115 err = -EIO; 1116 err = -EFSCORRUPTED;
1116 goto cleanup; 1117 goto cleanup;
1117 } 1118 }
1118 /* start copy from next extent */ 1119 /* start copy from next extent */
@@ -1151,7 +1152,7 @@ static int ext4_ext_split(handle_t *handle, struct inode *inode,
1151 k = depth - at - 1; 1152 k = depth - at - 1;
1152 if (unlikely(k < 0)) { 1153 if (unlikely(k < 0)) {
1153 EXT4_ERROR_INODE(inode, "k %d < 0!", k); 1154 EXT4_ERROR_INODE(inode, "k %d < 0!", k);
1154 err = -EIO; 1155 err = -EFSCORRUPTED;
1155 goto cleanup; 1156 goto cleanup;
1156 } 1157 }
1157 if (k) 1158 if (k)
@@ -1191,7 +1192,7 @@ static int ext4_ext_split(handle_t *handle, struct inode *inode,
1191 EXT4_ERROR_INODE(inode, 1192 EXT4_ERROR_INODE(inode,
1192 "EXT_MAX_INDEX != EXT_LAST_INDEX ee_block %d!", 1193 "EXT_MAX_INDEX != EXT_LAST_INDEX ee_block %d!",
1193 le32_to_cpu(path[i].p_ext->ee_block)); 1194 le32_to_cpu(path[i].p_ext->ee_block));
1194 err = -EIO; 1195 err = -EFSCORRUPTED;
1195 goto cleanup; 1196 goto cleanup;
1196 } 1197 }
1197 /* start copy indexes */ 1198 /* start copy indexes */
@@ -1425,7 +1426,7 @@ static int ext4_ext_search_left(struct inode *inode,
1425 1426
1426 if (unlikely(path == NULL)) { 1427 if (unlikely(path == NULL)) {
1427 EXT4_ERROR_INODE(inode, "path == NULL *logical %d!", *logical); 1428 EXT4_ERROR_INODE(inode, "path == NULL *logical %d!", *logical);
1428 return -EIO; 1429 return -EFSCORRUPTED;
1429 } 1430 }
1430 depth = path->p_depth; 1431 depth = path->p_depth;
1431 *phys = 0; 1432 *phys = 0;
@@ -1444,7 +1445,7 @@ static int ext4_ext_search_left(struct inode *inode,
1444 EXT4_ERROR_INODE(inode, 1445 EXT4_ERROR_INODE(inode,
1445 "EXT_FIRST_EXTENT != ex *logical %d ee_block %d!", 1446 "EXT_FIRST_EXTENT != ex *logical %d ee_block %d!",
1446 *logical, le32_to_cpu(ex->ee_block)); 1447 *logical, le32_to_cpu(ex->ee_block));
1447 return -EIO; 1448 return -EFSCORRUPTED;
1448 } 1449 }
1449 while (--depth >= 0) { 1450 while (--depth >= 0) {
1450 ix = path[depth].p_idx; 1451 ix = path[depth].p_idx;
@@ -1455,7 +1456,7 @@ static int ext4_ext_search_left(struct inode *inode,
1455 EXT_FIRST_INDEX(path[depth].p_hdr) != NULL ? 1456 EXT_FIRST_INDEX(path[depth].p_hdr) != NULL ?
1456 le32_to_cpu(EXT_FIRST_INDEX(path[depth].p_hdr)->ei_block) : 0, 1457 le32_to_cpu(EXT_FIRST_INDEX(path[depth].p_hdr)->ei_block) : 0,
1457 depth); 1458 depth);
1458 return -EIO; 1459 return -EFSCORRUPTED;
1459 } 1460 }
1460 } 1461 }
1461 return 0; 1462 return 0;
@@ -1465,7 +1466,7 @@ static int ext4_ext_search_left(struct inode *inode,
1465 EXT4_ERROR_INODE(inode, 1466 EXT4_ERROR_INODE(inode,
1466 "logical %d < ee_block %d + ee_len %d!", 1467 "logical %d < ee_block %d + ee_len %d!",
1467 *logical, le32_to_cpu(ex->ee_block), ee_len); 1468 *logical, le32_to_cpu(ex->ee_block), ee_len);
1468 return -EIO; 1469 return -EFSCORRUPTED;
1469 } 1470 }
1470 1471
1471 *logical = le32_to_cpu(ex->ee_block) + ee_len - 1; 1472 *logical = le32_to_cpu(ex->ee_block) + ee_len - 1;
@@ -1495,7 +1496,7 @@ static int ext4_ext_search_right(struct inode *inode,
1495 1496
1496 if (unlikely(path == NULL)) { 1497 if (unlikely(path == NULL)) {
1497 EXT4_ERROR_INODE(inode, "path == NULL *logical %d!", *logical); 1498 EXT4_ERROR_INODE(inode, "path == NULL *logical %d!", *logical);
1498 return -EIO; 1499 return -EFSCORRUPTED;
1499 } 1500 }
1500 depth = path->p_depth; 1501 depth = path->p_depth;
1501 *phys = 0; 1502 *phys = 0;
@@ -1514,7 +1515,7 @@ static int ext4_ext_search_right(struct inode *inode,
1514 EXT4_ERROR_INODE(inode, 1515 EXT4_ERROR_INODE(inode,
1515 "first_extent(path[%d].p_hdr) != ex", 1516 "first_extent(path[%d].p_hdr) != ex",
1516 depth); 1517 depth);
1517 return -EIO; 1518 return -EFSCORRUPTED;
1518 } 1519 }
1519 while (--depth >= 0) { 1520 while (--depth >= 0) {
1520 ix = path[depth].p_idx; 1521 ix = path[depth].p_idx;
@@ -1522,7 +1523,7 @@ static int ext4_ext_search_right(struct inode *inode,
1522 EXT4_ERROR_INODE(inode, 1523 EXT4_ERROR_INODE(inode,
1523 "ix != EXT_FIRST_INDEX *logical %d!", 1524 "ix != EXT_FIRST_INDEX *logical %d!",
1524 *logical); 1525 *logical);
1525 return -EIO; 1526 return -EFSCORRUPTED;
1526 } 1527 }
1527 } 1528 }
1528 goto found_extent; 1529 goto found_extent;
@@ -1532,7 +1533,7 @@ static int ext4_ext_search_right(struct inode *inode,
1532 EXT4_ERROR_INODE(inode, 1533 EXT4_ERROR_INODE(inode,
1533 "logical %d < ee_block %d + ee_len %d!", 1534 "logical %d < ee_block %d + ee_len %d!",
1534 *logical, le32_to_cpu(ex->ee_block), ee_len); 1535 *logical, le32_to_cpu(ex->ee_block), ee_len);
1535 return -EIO; 1536 return -EFSCORRUPTED;
1536 } 1537 }
1537 1538
1538 if (ex != EXT_LAST_EXTENT(path[depth].p_hdr)) { 1539 if (ex != EXT_LAST_EXTENT(path[depth].p_hdr)) {
@@ -1670,7 +1671,7 @@ static int ext4_ext_correct_indexes(handle_t *handle, struct inode *inode,
1670 if (unlikely(ex == NULL || eh == NULL)) { 1671 if (unlikely(ex == NULL || eh == NULL)) {
1671 EXT4_ERROR_INODE(inode, 1672 EXT4_ERROR_INODE(inode,
1672 "ex %p == NULL or eh %p == NULL", ex, eh); 1673 "ex %p == NULL or eh %p == NULL", ex, eh);
1673 return -EIO; 1674 return -EFSCORRUPTED;
1674 } 1675 }
1675 1676
1676 if (depth == 0) { 1677 if (depth == 0) {
@@ -1938,14 +1939,14 @@ int ext4_ext_insert_extent(handle_t *handle, struct inode *inode,
1938 mb_flags |= EXT4_MB_DELALLOC_RESERVED; 1939 mb_flags |= EXT4_MB_DELALLOC_RESERVED;
1939 if (unlikely(ext4_ext_get_actual_len(newext) == 0)) { 1940 if (unlikely(ext4_ext_get_actual_len(newext) == 0)) {
1940 EXT4_ERROR_INODE(inode, "ext4_ext_get_actual_len(newext) == 0"); 1941 EXT4_ERROR_INODE(inode, "ext4_ext_get_actual_len(newext) == 0");
1941 return -EIO; 1942 return -EFSCORRUPTED;
1942 } 1943 }
1943 depth = ext_depth(inode); 1944 depth = ext_depth(inode);
1944 ex = path[depth].p_ext; 1945 ex = path[depth].p_ext;
1945 eh = path[depth].p_hdr; 1946 eh = path[depth].p_hdr;
1946 if (unlikely(path[depth].p_hdr == NULL)) { 1947 if (unlikely(path[depth].p_hdr == NULL)) {
1947 EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth); 1948 EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth);
1948 return -EIO; 1949 return -EFSCORRUPTED;
1949 } 1950 }
1950 1951
1951 /* try to insert block into found extent and return */ 1952 /* try to insert block into found extent and return */
@@ -2172,7 +2173,7 @@ static int ext4_fill_fiemap_extents(struct inode *inode,
2172 if (unlikely(path[depth].p_hdr == NULL)) { 2173 if (unlikely(path[depth].p_hdr == NULL)) {
2173 up_read(&EXT4_I(inode)->i_data_sem); 2174 up_read(&EXT4_I(inode)->i_data_sem);
2174 EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth); 2175 EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth);
2175 err = -EIO; 2176 err = -EFSCORRUPTED;
2176 break; 2177 break;
2177 } 2178 }
2178 ex = path[depth].p_ext; 2179 ex = path[depth].p_ext;
@@ -2241,7 +2242,7 @@ static int ext4_fill_fiemap_extents(struct inode *inode,
2241 2242
2242 if (unlikely(es.es_len == 0)) { 2243 if (unlikely(es.es_len == 0)) {
2243 EXT4_ERROR_INODE(inode, "es.es_len == 0"); 2244 EXT4_ERROR_INODE(inode, "es.es_len == 0");
2244 err = -EIO; 2245 err = -EFSCORRUPTED;
2245 break; 2246 break;
2246 } 2247 }
2247 2248
@@ -2264,7 +2265,7 @@ static int ext4_fill_fiemap_extents(struct inode *inode,
2264 "next extent == %u, next " 2265 "next extent == %u, next "
2265 "delalloc extent = %u", 2266 "delalloc extent = %u",
2266 next, next_del); 2267 next, next_del);
2267 err = -EIO; 2268 err = -EFSCORRUPTED;
2268 break; 2269 break;
2269 } 2270 }
2270 } 2271 }
@@ -2363,7 +2364,7 @@ static int ext4_ext_rm_idx(handle_t *handle, struct inode *inode,
2363 leaf = ext4_idx_pblock(path->p_idx); 2364 leaf = ext4_idx_pblock(path->p_idx);
2364 if (unlikely(path->p_hdr->eh_entries == 0)) { 2365 if (unlikely(path->p_hdr->eh_entries == 0)) {
2365 EXT4_ERROR_INODE(inode, "path->p_hdr->eh_entries == 0"); 2366 EXT4_ERROR_INODE(inode, "path->p_hdr->eh_entries == 0");
2366 return -EIO; 2367 return -EFSCORRUPTED;
2367 } 2368 }
2368 err = ext4_ext_get_access(handle, inode, path); 2369 err = ext4_ext_get_access(handle, inode, path);
2369 if (err) 2370 if (err)
@@ -2612,7 +2613,7 @@ ext4_ext_rm_leaf(handle_t *handle, struct inode *inode,
2612 eh = path[depth].p_hdr; 2613 eh = path[depth].p_hdr;
2613 if (unlikely(path[depth].p_hdr == NULL)) { 2614 if (unlikely(path[depth].p_hdr == NULL)) {
2614 EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth); 2615 EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth);
2615 return -EIO; 2616 return -EFSCORRUPTED;
2616 } 2617 }
2617 /* find where to start removing */ 2618 /* find where to start removing */
2618 ex = path[depth].p_ext; 2619 ex = path[depth].p_ext;
@@ -2666,7 +2667,7 @@ ext4_ext_rm_leaf(handle_t *handle, struct inode *inode,
2666 "on extent %u:%u", 2667 "on extent %u:%u",
2667 start, end, ex_ee_block, 2668 start, end, ex_ee_block,
2668 ex_ee_block + ex_ee_len - 1); 2669 ex_ee_block + ex_ee_len - 1);
2669 err = -EIO; 2670 err = -EFSCORRUPTED;
2670 goto out; 2671 goto out;
2671 } else if (a != ex_ee_block) { 2672 } else if (a != ex_ee_block) {
2672 /* remove tail of the extent */ 2673 /* remove tail of the extent */
@@ -2841,7 +2842,7 @@ again:
2841 EXT4_ERROR_INODE(inode, 2842 EXT4_ERROR_INODE(inode,
2842 "path[%d].p_hdr == NULL", 2843 "path[%d].p_hdr == NULL",
2843 depth); 2844 depth);
2844 err = -EIO; 2845 err = -EFSCORRUPTED;
2845 } 2846 }
2846 goto out; 2847 goto out;
2847 } 2848 }
@@ -2920,7 +2921,7 @@ again:
2920 i = 0; 2921 i = 0;
2921 2922
2922 if (ext4_ext_check(inode, path[0].p_hdr, depth, 0)) { 2923 if (ext4_ext_check(inode, path[0].p_hdr, depth, 0)) {
2923 err = -EIO; 2924 err = -EFSCORRUPTED;
2924 goto out; 2925 goto out;
2925 } 2926 }
2926 } 2927 }
@@ -2978,7 +2979,7 @@ again:
2978 * Should be a no-op if we did IO above. */ 2979 * Should be a no-op if we did IO above. */
2979 cond_resched(); 2980 cond_resched();
2980 if (WARN_ON(i + 1 > depth)) { 2981 if (WARN_ON(i + 1 > depth)) {
2981 err = -EIO; 2982 err = -EFSCORRUPTED;
2982 break; 2983 break;
2983 } 2984 }
2984 path[i + 1].p_bh = bh; 2985 path[i + 1].p_bh = bh;
@@ -3054,7 +3055,7 @@ void ext4_ext_init(struct super_block *sb)
3054 * possible initialization would be here 3055 * possible initialization would be here
3055 */ 3056 */
3056 3057
3057 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_EXTENTS)) { 3058 if (ext4_has_feature_extents(sb)) {
3058#if defined(AGGRESSIVE_TEST) || defined(CHECK_BINSEARCH) || defined(EXTENTS_STATS) 3059#if defined(AGGRESSIVE_TEST) || defined(CHECK_BINSEARCH) || defined(EXTENTS_STATS)
3059 printk(KERN_INFO "EXT4-fs: file extents enabled" 3060 printk(KERN_INFO "EXT4-fs: file extents enabled"
3060#ifdef AGGRESSIVE_TEST 3061#ifdef AGGRESSIVE_TEST
@@ -3081,7 +3082,7 @@ void ext4_ext_init(struct super_block *sb)
3081 */ 3082 */
3082void ext4_ext_release(struct super_block *sb) 3083void ext4_ext_release(struct super_block *sb)
3083{ 3084{
3084 if (!EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_EXTENTS)) 3085 if (!ext4_has_feature_extents(sb))
3085 return; 3086 return;
3086 3087
3087#ifdef EXTENTS_STATS 3088#ifdef EXTENTS_STATS
@@ -3345,7 +3346,7 @@ static int ext4_split_extent(handle_t *handle,
3345 if (!ex) { 3346 if (!ex) {
3346 EXT4_ERROR_INODE(inode, "unexpected hole at %lu", 3347 EXT4_ERROR_INODE(inode, "unexpected hole at %lu",
3347 (unsigned long) map->m_lblk); 3348 (unsigned long) map->m_lblk);
3348 return -EIO; 3349 return -EFSCORRUPTED;
3349 } 3350 }
3350 unwritten = ext4_ext_is_unwritten(ex); 3351 unwritten = ext4_ext_is_unwritten(ex);
3351 split_flag1 = 0; 3352 split_flag1 = 0;
@@ -3558,6 +3559,9 @@ static int ext4_ext_convert_to_initialized(handle_t *handle,
3558 max_zeroout = sbi->s_extent_max_zeroout_kb >> 3559 max_zeroout = sbi->s_extent_max_zeroout_kb >>
3559 (inode->i_sb->s_blocksize_bits - 10); 3560 (inode->i_sb->s_blocksize_bits - 10);
3560 3561
3562 if (ext4_encrypted_inode(inode))
3563 max_zeroout = 0;
3564
3561 /* If extent is less than s_max_zeroout_kb, zeroout directly */ 3565 /* If extent is less than s_max_zeroout_kb, zeroout directly */
3562 if (max_zeroout && (ee_len <= max_zeroout)) { 3566 if (max_zeroout && (ee_len <= max_zeroout)) {
3563 err = ext4_ext_zeroout(inode, ex); 3567 err = ext4_ext_zeroout(inode, ex);
@@ -3970,7 +3974,7 @@ convert_initialized_extent(handle_t *handle, struct inode *inode,
3970 if (!ex) { 3974 if (!ex) {
3971 EXT4_ERROR_INODE(inode, "unexpected hole at %lu", 3975 EXT4_ERROR_INODE(inode, "unexpected hole at %lu",
3972 (unsigned long) map->m_lblk); 3976 (unsigned long) map->m_lblk);
3973 return -EIO; 3977 return -EFSCORRUPTED;
3974 } 3978 }
3975 } 3979 }
3976 3980
@@ -4308,7 +4312,7 @@ int ext4_ext_map_blocks(handle_t *handle, struct inode *inode,
4308 "lblock: %lu, depth: %d pblock %lld", 4312 "lblock: %lu, depth: %d pblock %lld",
4309 (unsigned long) map->m_lblk, depth, 4313 (unsigned long) map->m_lblk, depth,
4310 path[depth].p_block); 4314 path[depth].p_block);
4311 err = -EIO; 4315 err = -EFSCORRUPTED;
4312 goto out2; 4316 goto out2;
4313 } 4317 }
4314 4318
@@ -5271,7 +5275,7 @@ ext4_ext_shift_path_extents(struct ext4_ext_path *path, ext4_lblk_t shift,
5271 if (depth == path->p_depth) { 5275 if (depth == path->p_depth) {
5272 ex_start = path[depth].p_ext; 5276 ex_start = path[depth].p_ext;
5273 if (!ex_start) 5277 if (!ex_start)
5274 return -EIO; 5278 return -EFSCORRUPTED;
5275 5279
5276 ex_last = EXT_LAST_EXTENT(path[depth].p_hdr); 5280 ex_last = EXT_LAST_EXTENT(path[depth].p_hdr);
5277 5281
@@ -5411,7 +5415,7 @@ ext4_ext_shift_extents(struct inode *inode, handle_t *handle,
5411 if (!extent) { 5415 if (!extent) {
5412 EXT4_ERROR_INODE(inode, "unexpected hole at %lu", 5416 EXT4_ERROR_INODE(inode, "unexpected hole at %lu",
5413 (unsigned long) *iterator); 5417 (unsigned long) *iterator);
5414 return -EIO; 5418 return -EFSCORRUPTED;
5415 } 5419 }
5416 if (SHIFT == SHIFT_LEFT && *iterator > 5420 if (SHIFT == SHIFT_LEFT && *iterator >
5417 le32_to_cpu(extent->ee_block)) { 5421 le32_to_cpu(extent->ee_block)) {
diff --git a/fs/ext4/extents_status.c b/fs/ext4/extents_status.c
index 26724aeece73..ac748b3af1c1 100644
--- a/fs/ext4/extents_status.c
+++ b/fs/ext4/extents_status.c
@@ -1089,20 +1089,9 @@ static unsigned long ext4_es_scan(struct shrinker *shrink,
1089 return nr_shrunk; 1089 return nr_shrunk;
1090} 1090}
1091 1091
1092static void *ext4_es_seq_shrinker_info_start(struct seq_file *seq, loff_t *pos) 1092int ext4_seq_es_shrinker_info_show(struct seq_file *seq, void *v)
1093{ 1093{
1094 return *pos ? NULL : SEQ_START_TOKEN; 1094 struct ext4_sb_info *sbi = EXT4_SB((struct super_block *) seq->private);
1095}
1096
1097static void *
1098ext4_es_seq_shrinker_info_next(struct seq_file *seq, void *v, loff_t *pos)
1099{
1100 return NULL;
1101}
1102
1103static int ext4_es_seq_shrinker_info_show(struct seq_file *seq, void *v)
1104{
1105 struct ext4_sb_info *sbi = seq->private;
1106 struct ext4_es_stats *es_stats = &sbi->s_es_stats; 1095 struct ext4_es_stats *es_stats = &sbi->s_es_stats;
1107 struct ext4_inode_info *ei, *max = NULL; 1096 struct ext4_inode_info *ei, *max = NULL;
1108 unsigned int inode_cnt = 0; 1097 unsigned int inode_cnt = 0;
@@ -1143,45 +1132,6 @@ static int ext4_es_seq_shrinker_info_show(struct seq_file *seq, void *v)
1143 return 0; 1132 return 0;
1144} 1133}
1145 1134
1146static void ext4_es_seq_shrinker_info_stop(struct seq_file *seq, void *v)
1147{
1148}
1149
1150static const struct seq_operations ext4_es_seq_shrinker_info_ops = {
1151 .start = ext4_es_seq_shrinker_info_start,
1152 .next = ext4_es_seq_shrinker_info_next,
1153 .stop = ext4_es_seq_shrinker_info_stop,
1154 .show = ext4_es_seq_shrinker_info_show,
1155};
1156
1157static int
1158ext4_es_seq_shrinker_info_open(struct inode *inode, struct file *file)
1159{
1160 int ret;
1161
1162 ret = seq_open(file, &ext4_es_seq_shrinker_info_ops);
1163 if (!ret) {
1164 struct seq_file *m = file->private_data;
1165 m->private = PDE_DATA(inode);
1166 }
1167
1168 return ret;
1169}
1170
1171static int
1172ext4_es_seq_shrinker_info_release(struct inode *inode, struct file *file)
1173{
1174 return seq_release(inode, file);
1175}
1176
1177static const struct file_operations ext4_es_seq_shrinker_info_fops = {
1178 .owner = THIS_MODULE,
1179 .open = ext4_es_seq_shrinker_info_open,
1180 .read = seq_read,
1181 .llseek = seq_lseek,
1182 .release = ext4_es_seq_shrinker_info_release,
1183};
1184
1185int ext4_es_register_shrinker(struct ext4_sb_info *sbi) 1135int ext4_es_register_shrinker(struct ext4_sb_info *sbi)
1186{ 1136{
1187 int err; 1137 int err;
@@ -1210,10 +1160,6 @@ int ext4_es_register_shrinker(struct ext4_sb_info *sbi)
1210 if (err) 1160 if (err)
1211 goto err2; 1161 goto err2;
1212 1162
1213 if (sbi->s_proc)
1214 proc_create_data("es_shrinker_info", S_IRUGO, sbi->s_proc,
1215 &ext4_es_seq_shrinker_info_fops, sbi);
1216
1217 return 0; 1163 return 0;
1218 1164
1219err2: 1165err2:
@@ -1225,8 +1171,6 @@ err1:
1225 1171
1226void ext4_es_unregister_shrinker(struct ext4_sb_info *sbi) 1172void ext4_es_unregister_shrinker(struct ext4_sb_info *sbi)
1227{ 1173{
1228 if (sbi->s_proc)
1229 remove_proc_entry("es_shrinker_info", sbi->s_proc);
1230 percpu_counter_destroy(&sbi->s_es_stats.es_stats_all_cnt); 1174 percpu_counter_destroy(&sbi->s_es_stats.es_stats_all_cnt);
1231 percpu_counter_destroy(&sbi->s_es_stats.es_stats_shk_cnt); 1175 percpu_counter_destroy(&sbi->s_es_stats.es_stats_shk_cnt);
1232 unregister_shrinker(&sbi->s_es_shrinker); 1176 unregister_shrinker(&sbi->s_es_shrinker);
diff --git a/fs/ext4/extents_status.h b/fs/ext4/extents_status.h
index 691b52613ce4..f7aa24f4642d 100644
--- a/fs/ext4/extents_status.h
+++ b/fs/ext4/extents_status.h
@@ -172,4 +172,6 @@ static inline void ext4_es_store_pblock_status(struct extent_status *es,
172extern int ext4_es_register_shrinker(struct ext4_sb_info *sbi); 172extern int ext4_es_register_shrinker(struct ext4_sb_info *sbi);
173extern void ext4_es_unregister_shrinker(struct ext4_sb_info *sbi); 173extern void ext4_es_unregister_shrinker(struct ext4_sb_info *sbi);
174 174
175extern int ext4_seq_es_shrinker_info_show(struct seq_file *seq, void *v);
176
175#endif /* _EXT4_EXTENTS_STATUS_H */ 177#endif /* _EXT4_EXTENTS_STATUS_H */
diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c
index 619bfc1fda8c..1b8024d26f65 100644
--- a/fs/ext4/ialloc.c
+++ b/fs/ext4/ialloc.c
@@ -64,7 +64,7 @@ void ext4_mark_bitmap_end(int start_bit, int end_bit, char *bitmap)
64} 64}
65 65
66/* Initializes an uninitialized inode bitmap */ 66/* Initializes an uninitialized inode bitmap */
67static unsigned ext4_init_inode_bitmap(struct super_block *sb, 67static int ext4_init_inode_bitmap(struct super_block *sb,
68 struct buffer_head *bh, 68 struct buffer_head *bh,
69 ext4_group_t block_group, 69 ext4_group_t block_group,
70 struct ext4_group_desc *gdp) 70 struct ext4_group_desc *gdp)
@@ -89,7 +89,7 @@ static unsigned ext4_init_inode_bitmap(struct super_block *sb,
89 count); 89 count);
90 } 90 }
91 set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &grp->bb_state); 91 set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &grp->bb_state);
92 return 0; 92 return -EFSBADCRC;
93 } 93 }
94 94
95 memset(bh->b_data, 0, (EXT4_INODES_PER_GROUP(sb) + 7) / 8); 95 memset(bh->b_data, 0, (EXT4_INODES_PER_GROUP(sb) + 7) / 8);
@@ -99,7 +99,7 @@ static unsigned ext4_init_inode_bitmap(struct super_block *sb,
99 EXT4_INODES_PER_GROUP(sb) / 8); 99 EXT4_INODES_PER_GROUP(sb) / 8);
100 ext4_group_desc_csum_set(sb, block_group, gdp); 100 ext4_group_desc_csum_set(sb, block_group, gdp);
101 101
102 return EXT4_INODES_PER_GROUP(sb); 102 return 0;
103} 103}
104 104
105void ext4_end_bitmap_read(struct buffer_head *bh, int uptodate) 105void ext4_end_bitmap_read(struct buffer_head *bh, int uptodate)
@@ -112,6 +112,42 @@ void ext4_end_bitmap_read(struct buffer_head *bh, int uptodate)
112 put_bh(bh); 112 put_bh(bh);
113} 113}
114 114
115static int ext4_validate_inode_bitmap(struct super_block *sb,
116 struct ext4_group_desc *desc,
117 ext4_group_t block_group,
118 struct buffer_head *bh)
119{
120 ext4_fsblk_t blk;
121 struct ext4_group_info *grp = ext4_get_group_info(sb, block_group);
122 struct ext4_sb_info *sbi = EXT4_SB(sb);
123
124 if (buffer_verified(bh))
125 return 0;
126 if (EXT4_MB_GRP_IBITMAP_CORRUPT(grp))
127 return -EFSCORRUPTED;
128
129 ext4_lock_group(sb, block_group);
130 blk = ext4_inode_bitmap(sb, desc);
131 if (!ext4_inode_bitmap_csum_verify(sb, block_group, desc, bh,
132 EXT4_INODES_PER_GROUP(sb) / 8)) {
133 ext4_unlock_group(sb, block_group);
134 ext4_error(sb, "Corrupt inode bitmap - block_group = %u, "
135 "inode_bitmap = %llu", block_group, blk);
136 grp = ext4_get_group_info(sb, block_group);
137 if (!EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) {
138 int count;
139 count = ext4_free_inodes_count(sb, desc);
140 percpu_counter_sub(&sbi->s_freeinodes_counter,
141 count);
142 }
143 set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &grp->bb_state);
144 return -EFSBADCRC;
145 }
146 set_buffer_verified(bh);
147 ext4_unlock_group(sb, block_group);
148 return 0;
149}
150
115/* 151/*
116 * Read the inode allocation bitmap for a given block_group, reading 152 * Read the inode allocation bitmap for a given block_group, reading
117 * into the specified slot in the superblock's bitmap cache. 153 * into the specified slot in the superblock's bitmap cache.
@@ -124,12 +160,11 @@ ext4_read_inode_bitmap(struct super_block *sb, ext4_group_t block_group)
124 struct ext4_group_desc *desc; 160 struct ext4_group_desc *desc;
125 struct buffer_head *bh = NULL; 161 struct buffer_head *bh = NULL;
126 ext4_fsblk_t bitmap_blk; 162 ext4_fsblk_t bitmap_blk;
127 struct ext4_group_info *grp; 163 int err;
128 struct ext4_sb_info *sbi = EXT4_SB(sb);
129 164
130 desc = ext4_get_group_desc(sb, block_group, NULL); 165 desc = ext4_get_group_desc(sb, block_group, NULL);
131 if (!desc) 166 if (!desc)
132 return NULL; 167 return ERR_PTR(-EFSCORRUPTED);
133 168
134 bitmap_blk = ext4_inode_bitmap(sb, desc); 169 bitmap_blk = ext4_inode_bitmap(sb, desc);
135 bh = sb_getblk(sb, bitmap_blk); 170 bh = sb_getblk(sb, bitmap_blk);
@@ -137,7 +172,7 @@ ext4_read_inode_bitmap(struct super_block *sb, ext4_group_t block_group)
137 ext4_error(sb, "Cannot read inode bitmap - " 172 ext4_error(sb, "Cannot read inode bitmap - "
138 "block_group = %u, inode_bitmap = %llu", 173 "block_group = %u, inode_bitmap = %llu",
139 block_group, bitmap_blk); 174 block_group, bitmap_blk);
140 return NULL; 175 return ERR_PTR(-EIO);
141 } 176 }
142 if (bitmap_uptodate(bh)) 177 if (bitmap_uptodate(bh))
143 goto verify; 178 goto verify;
@@ -150,12 +185,14 @@ ext4_read_inode_bitmap(struct super_block *sb, ext4_group_t block_group)
150 185
151 ext4_lock_group(sb, block_group); 186 ext4_lock_group(sb, block_group);
152 if (desc->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT)) { 187 if (desc->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT)) {
153 ext4_init_inode_bitmap(sb, bh, block_group, desc); 188 err = ext4_init_inode_bitmap(sb, bh, block_group, desc);
154 set_bitmap_uptodate(bh); 189 set_bitmap_uptodate(bh);
155 set_buffer_uptodate(bh); 190 set_buffer_uptodate(bh);
156 set_buffer_verified(bh); 191 set_buffer_verified(bh);
157 ext4_unlock_group(sb, block_group); 192 ext4_unlock_group(sb, block_group);
158 unlock_buffer(bh); 193 unlock_buffer(bh);
194 if (err)
195 goto out;
159 return bh; 196 return bh;
160 } 197 }
161 ext4_unlock_group(sb, block_group); 198 ext4_unlock_group(sb, block_group);
@@ -182,31 +219,17 @@ ext4_read_inode_bitmap(struct super_block *sb, ext4_group_t block_group)
182 ext4_error(sb, "Cannot read inode bitmap - " 219 ext4_error(sb, "Cannot read inode bitmap - "
183 "block_group = %u, inode_bitmap = %llu", 220 "block_group = %u, inode_bitmap = %llu",
184 block_group, bitmap_blk); 221 block_group, bitmap_blk);
185 return NULL; 222 return ERR_PTR(-EIO);
186 } 223 }
187 224
188verify: 225verify:
189 ext4_lock_group(sb, block_group); 226 err = ext4_validate_inode_bitmap(sb, desc, block_group, bh);
190 if (!buffer_verified(bh) && 227 if (err)
191 !ext4_inode_bitmap_csum_verify(sb, block_group, desc, bh, 228 goto out;
192 EXT4_INODES_PER_GROUP(sb) / 8)) {
193 ext4_unlock_group(sb, block_group);
194 put_bh(bh);
195 ext4_error(sb, "Corrupt inode bitmap - block_group = %u, "
196 "inode_bitmap = %llu", block_group, bitmap_blk);
197 grp = ext4_get_group_info(sb, block_group);
198 if (!EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) {
199 int count;
200 count = ext4_free_inodes_count(sb, desc);
201 percpu_counter_sub(&sbi->s_freeinodes_counter,
202 count);
203 }
204 set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &grp->bb_state);
205 return NULL;
206 }
207 ext4_unlock_group(sb, block_group);
208 set_buffer_verified(bh);
209 return bh; 229 return bh;
230out:
231 put_bh(bh);
232 return ERR_PTR(err);
210} 233}
211 234
212/* 235/*
@@ -286,8 +309,15 @@ void ext4_free_inode(handle_t *handle, struct inode *inode)
286 bitmap_bh = ext4_read_inode_bitmap(sb, block_group); 309 bitmap_bh = ext4_read_inode_bitmap(sb, block_group);
287 /* Don't bother if the inode bitmap is corrupt. */ 310 /* Don't bother if the inode bitmap is corrupt. */
288 grp = ext4_get_group_info(sb, block_group); 311 grp = ext4_get_group_info(sb, block_group);
289 if (unlikely(EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) || !bitmap_bh) 312 if (IS_ERR(bitmap_bh)) {
313 fatal = PTR_ERR(bitmap_bh);
314 bitmap_bh = NULL;
315 goto error_return;
316 }
317 if (unlikely(EXT4_MB_GRP_IBITMAP_CORRUPT(grp))) {
318 fatal = -EFSCORRUPTED;
290 goto error_return; 319 goto error_return;
320 }
291 321
292 BUFFER_TRACE(bitmap_bh, "get_write_access"); 322 BUFFER_TRACE(bitmap_bh, "get_write_access");
293 fatal = ext4_journal_get_write_access(handle, bitmap_bh); 323 fatal = ext4_journal_get_write_access(handle, bitmap_bh);
@@ -826,7 +856,9 @@ got_group:
826 brelse(inode_bitmap_bh); 856 brelse(inode_bitmap_bh);
827 inode_bitmap_bh = ext4_read_inode_bitmap(sb, group); 857 inode_bitmap_bh = ext4_read_inode_bitmap(sb, group);
828 /* Skip groups with suspicious inode tables */ 858 /* Skip groups with suspicious inode tables */
829 if (EXT4_MB_GRP_IBITMAP_CORRUPT(grp) || !inode_bitmap_bh) { 859 if (EXT4_MB_GRP_IBITMAP_CORRUPT(grp) ||
860 IS_ERR(inode_bitmap_bh)) {
861 inode_bitmap_bh = NULL;
830 if (++group == ngroups) 862 if (++group == ngroups)
831 group = 0; 863 group = 0;
832 continue; 864 continue;
@@ -902,8 +934,8 @@ got:
902 struct buffer_head *block_bitmap_bh; 934 struct buffer_head *block_bitmap_bh;
903 935
904 block_bitmap_bh = ext4_read_block_bitmap(sb, group); 936 block_bitmap_bh = ext4_read_block_bitmap(sb, group);
905 if (!block_bitmap_bh) { 937 if (IS_ERR(block_bitmap_bh)) {
906 err = -EIO; 938 err = PTR_ERR(block_bitmap_bh);
907 goto out; 939 goto out;
908 } 940 }
909 BUFFER_TRACE(block_bitmap_bh, "get block bitmap access"); 941 BUFFER_TRACE(block_bitmap_bh, "get block bitmap access");
@@ -1045,7 +1077,7 @@ got:
1045 1077
1046 ei->i_extra_isize = EXT4_SB(sb)->s_want_extra_isize; 1078 ei->i_extra_isize = EXT4_SB(sb)->s_want_extra_isize;
1047 ei->i_inline_off = 0; 1079 ei->i_inline_off = 0;
1048 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_INLINE_DATA)) 1080 if (ext4_has_feature_inline_data(sb))
1049 ext4_set_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA); 1081 ext4_set_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
1050 ret = inode; 1082 ret = inode;
1051 err = dquot_alloc_inode(inode); 1083 err = dquot_alloc_inode(inode);
@@ -1060,7 +1092,7 @@ got:
1060 if (err) 1092 if (err)
1061 goto fail_free_drop; 1093 goto fail_free_drop;
1062 1094
1063 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_EXTENTS)) { 1095 if (ext4_has_feature_extents(sb)) {
1064 /* set extent flag only for directory, file and normal symlink*/ 1096 /* set extent flag only for directory, file and normal symlink*/
1065 if (S_ISDIR(mode) || S_ISREG(mode) || S_ISLNK(mode)) { 1097 if (S_ISDIR(mode) || S_ISREG(mode) || S_ISLNK(mode)) {
1066 ext4_set_inode_flag(inode, EXT4_INODE_EXTENTS); 1098 ext4_set_inode_flag(inode, EXT4_INODE_EXTENTS);
@@ -1116,14 +1148,17 @@ struct inode *ext4_orphan_get(struct super_block *sb, unsigned long ino)
1116 /* Error cases - e2fsck has already cleaned up for us */ 1148 /* Error cases - e2fsck has already cleaned up for us */
1117 if (ino > max_ino) { 1149 if (ino > max_ino) {
1118 ext4_warning(sb, "bad orphan ino %lu! e2fsck was run?", ino); 1150 ext4_warning(sb, "bad orphan ino %lu! e2fsck was run?", ino);
1151 err = -EFSCORRUPTED;
1119 goto error; 1152 goto error;
1120 } 1153 }
1121 1154
1122 block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb); 1155 block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb);
1123 bit = (ino - 1) % EXT4_INODES_PER_GROUP(sb); 1156 bit = (ino - 1) % EXT4_INODES_PER_GROUP(sb);
1124 bitmap_bh = ext4_read_inode_bitmap(sb, block_group); 1157 bitmap_bh = ext4_read_inode_bitmap(sb, block_group);
1125 if (!bitmap_bh) { 1158 if (IS_ERR(bitmap_bh)) {
1126 ext4_warning(sb, "inode bitmap error for orphan %lu", ino); 1159 err = PTR_ERR(bitmap_bh);
1160 ext4_warning(sb, "inode bitmap error %ld for orphan %lu",
1161 ino, err);
1127 goto error; 1162 goto error;
1128 } 1163 }
1129 1164
@@ -1198,8 +1233,10 @@ unsigned long ext4_count_free_inodes(struct super_block *sb)
1198 desc_count += ext4_free_inodes_count(sb, gdp); 1233 desc_count += ext4_free_inodes_count(sb, gdp);
1199 brelse(bitmap_bh); 1234 brelse(bitmap_bh);
1200 bitmap_bh = ext4_read_inode_bitmap(sb, i); 1235 bitmap_bh = ext4_read_inode_bitmap(sb, i);
1201 if (!bitmap_bh) 1236 if (IS_ERR(bitmap_bh)) {
1237 bitmap_bh = NULL;
1202 continue; 1238 continue;
1239 }
1203 1240
1204 x = ext4_count_free(bitmap_bh->b_data, 1241 x = ext4_count_free(bitmap_bh->b_data,
1205 EXT4_INODES_PER_GROUP(sb) / 8); 1242 EXT4_INODES_PER_GROUP(sb) / 8);
diff --git a/fs/ext4/indirect.c b/fs/ext4/indirect.c
index 2468261748b2..355ef9c36c87 100644
--- a/fs/ext4/indirect.c
+++ b/fs/ext4/indirect.c
@@ -562,11 +562,10 @@ int ext4_ind_map_blocks(handle_t *handle, struct inode *inode,
562 /* 562 /*
563 * Okay, we need to do block allocation. 563 * Okay, we need to do block allocation.
564 */ 564 */
565 if (EXT4_HAS_RO_COMPAT_FEATURE(inode->i_sb, 565 if (ext4_has_feature_bigalloc(inode->i_sb)) {
566 EXT4_FEATURE_RO_COMPAT_BIGALLOC)) {
567 EXT4_ERROR_INODE(inode, "Can't allocate blocks for " 566 EXT4_ERROR_INODE(inode, "Can't allocate blocks for "
568 "non-extent mapped inodes with bigalloc"); 567 "non-extent mapped inodes with bigalloc");
569 return -EUCLEAN; 568 return -EFSCORRUPTED;
570 } 569 }
571 570
572 /* Set up for the direct block allocation */ 571 /* Set up for the direct block allocation */
diff --git a/fs/ext4/inline.c b/fs/ext4/inline.c
index cd944a7a99cd..d884989cc83d 100644
--- a/fs/ext4/inline.c
+++ b/fs/ext4/inline.c
@@ -434,8 +434,7 @@ static int ext4_destroy_inline_data_nolock(handle_t *handle,
434 memset((void *)ext4_raw_inode(&is.iloc)->i_block, 434 memset((void *)ext4_raw_inode(&is.iloc)->i_block,
435 0, EXT4_MIN_INLINE_DATA_SIZE); 435 0, EXT4_MIN_INLINE_DATA_SIZE);
436 436
437 if (EXT4_HAS_INCOMPAT_FEATURE(inode->i_sb, 437 if (ext4_has_feature_extents(inode->i_sb)) {
438 EXT4_FEATURE_INCOMPAT_EXTENTS)) {
439 if (S_ISDIR(inode->i_mode) || 438 if (S_ISDIR(inode->i_mode) ||
440 S_ISREG(inode->i_mode) || S_ISLNK(inode->i_mode)) { 439 S_ISREG(inode->i_mode) || S_ISLNK(inode->i_mode)) {
441 ext4_set_inode_flag(inode, EXT4_INODE_EXTENTS); 440 ext4_set_inode_flag(inode, EXT4_INODE_EXTENTS);
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 612fbcf76b5c..e8d620a484f6 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -378,7 +378,7 @@ static int __check_block_validity(struct inode *inode, const char *func,
378 "lblock %lu mapped to illegal pblock " 378 "lblock %lu mapped to illegal pblock "
379 "(length %d)", (unsigned long) map->m_lblk, 379 "(length %d)", (unsigned long) map->m_lblk,
380 map->m_len); 380 map->m_len);
381 return -EIO; 381 return -EFSCORRUPTED;
382 } 382 }
383 return 0; 383 return 0;
384} 384}
@@ -480,7 +480,7 @@ int ext4_map_blocks(handle_t *handle, struct inode *inode,
480 480
481 /* We can handle the block number less than EXT_MAX_BLOCKS */ 481 /* We can handle the block number less than EXT_MAX_BLOCKS */
482 if (unlikely(map->m_lblk >= EXT_MAX_BLOCKS)) 482 if (unlikely(map->m_lblk >= EXT_MAX_BLOCKS))
483 return -EIO; 483 return -EFSCORRUPTED;
484 484
485 /* Lookup extent status tree firstly */ 485 /* Lookup extent status tree firstly */
486 if (ext4_es_lookup_extent(inode, map->m_lblk, &es)) { 486 if (ext4_es_lookup_extent(inode, map->m_lblk, &es)) {
@@ -965,7 +965,7 @@ static int ext4_block_write_begin(struct page *page, loff_t pos, unsigned len,
965 if (unlikely(err)) 965 if (unlikely(err))
966 page_zero_new_buffers(page, from, to); 966 page_zero_new_buffers(page, from, to);
967 else if (decrypt) 967 else if (decrypt)
968 err = ext4_decrypt_one(inode, page); 968 err = ext4_decrypt(page);
969 return err; 969 return err;
970} 970}
971#endif 971#endif
@@ -1181,6 +1181,38 @@ errout:
1181 return ret ? ret : copied; 1181 return ret ? ret : copied;
1182} 1182}
1183 1183
1184/*
1185 * This is a private version of page_zero_new_buffers() which doesn't
1186 * set the buffer to be dirty, since in data=journalled mode we need
1187 * to call ext4_handle_dirty_metadata() instead.
1188 */
1189static void zero_new_buffers(struct page *page, unsigned from, unsigned to)
1190{
1191 unsigned int block_start = 0, block_end;
1192 struct buffer_head *head, *bh;
1193
1194 bh = head = page_buffers(page);
1195 do {
1196 block_end = block_start + bh->b_size;
1197 if (buffer_new(bh)) {
1198 if (block_end > from && block_start < to) {
1199 if (!PageUptodate(page)) {
1200 unsigned start, size;
1201
1202 start = max(from, block_start);
1203 size = min(to, block_end) - start;
1204
1205 zero_user(page, start, size);
1206 set_buffer_uptodate(bh);
1207 }
1208 clear_buffer_new(bh);
1209 }
1210 }
1211 block_start = block_end;
1212 bh = bh->b_this_page;
1213 } while (bh != head);
1214}
1215
1184static int ext4_journalled_write_end(struct file *file, 1216static int ext4_journalled_write_end(struct file *file,
1185 struct address_space *mapping, 1217 struct address_space *mapping,
1186 loff_t pos, unsigned len, unsigned copied, 1218 loff_t pos, unsigned len, unsigned copied,
@@ -1207,7 +1239,7 @@ static int ext4_journalled_write_end(struct file *file,
1207 if (copied < len) { 1239 if (copied < len) {
1208 if (!PageUptodate(page)) 1240 if (!PageUptodate(page))
1209 copied = 0; 1241 copied = 0;
1210 page_zero_new_buffers(page, from+copied, to); 1242 zero_new_buffers(page, from+copied, to);
1211 } 1243 }
1212 1244
1213 ret = ext4_walk_page_buffers(handle, page_buffers(page), from, 1245 ret = ext4_walk_page_buffers(handle, page_buffers(page), from,
@@ -1815,11 +1847,22 @@ static int ext4_writepage(struct page *page,
1815 * the page. But we may reach here when we do a journal commit via 1847 * the page. But we may reach here when we do a journal commit via
1816 * journal_submit_inode_data_buffers() and in that case we must write 1848 * journal_submit_inode_data_buffers() and in that case we must write
1817 * allocated buffers to achieve data=ordered mode guarantees. 1849 * allocated buffers to achieve data=ordered mode guarantees.
1850 *
1851 * Also, if there is only one buffer per page (the fs block
1852 * size == the page size), if one buffer needs block
1853 * allocation or needs to modify the extent tree to clear the
1854 * unwritten flag, we know that the page can't be written at
1855 * all, so we might as well refuse the write immediately.
1856 * Unfortunately if the block size != page size, we can't as
1857 * easily detect this case using ext4_walk_page_buffers(), but
1858 * for the extremely common case, this is an optimization that
1859 * skips a useless round trip through ext4_bio_write_page().
1818 */ 1860 */
1819 if (ext4_walk_page_buffers(NULL, page_bufs, 0, len, NULL, 1861 if (ext4_walk_page_buffers(NULL, page_bufs, 0, len, NULL,
1820 ext4_bh_delay_or_unwritten)) { 1862 ext4_bh_delay_or_unwritten)) {
1821 redirty_page_for_writepage(wbc, page); 1863 redirty_page_for_writepage(wbc, page);
1822 if (current->flags & PF_MEMALLOC) { 1864 if ((current->flags & PF_MEMALLOC) ||
1865 (inode->i_sb->s_blocksize == PAGE_CACHE_SIZE)) {
1823 /* 1866 /*
1824 * For memory cleaning there's no point in writing only 1867 * For memory cleaning there's no point in writing only
1825 * some buffers. So just bail out. Warn if we came here 1868 * some buffers. So just bail out. Warn if we came here
@@ -2599,8 +2642,7 @@ static int ext4_nonda_switch(struct super_block *sb)
2599/* We always reserve for an inode update; the superblock could be there too */ 2642/* We always reserve for an inode update; the superblock could be there too */
2600static int ext4_da_write_credits(struct inode *inode, loff_t pos, unsigned len) 2643static int ext4_da_write_credits(struct inode *inode, loff_t pos, unsigned len)
2601{ 2644{
2602 if (likely(EXT4_HAS_RO_COMPAT_FEATURE(inode->i_sb, 2645 if (likely(ext4_has_feature_large_file(inode->i_sb)))
2603 EXT4_FEATURE_RO_COMPAT_LARGE_FILE)))
2604 return 1; 2646 return 1;
2605 2647
2606 if (pos + len <= 0x7fffffffULL) 2648 if (pos + len <= 0x7fffffffULL)
@@ -3393,7 +3435,7 @@ static int __ext4_block_zero_page_range(handle_t *handle,
3393 /* We expect the key to be set. */ 3435 /* We expect the key to be set. */
3394 BUG_ON(!ext4_has_encryption_key(inode)); 3436 BUG_ON(!ext4_has_encryption_key(inode));
3395 BUG_ON(blocksize != PAGE_CACHE_SIZE); 3437 BUG_ON(blocksize != PAGE_CACHE_SIZE);
3396 WARN_ON_ONCE(ext4_decrypt_one(inode, page)); 3438 WARN_ON_ONCE(ext4_decrypt(page));
3397 } 3439 }
3398 } 3440 }
3399 if (ext4_should_journal_data(inode)) { 3441 if (ext4_should_journal_data(inode)) {
@@ -3820,7 +3862,7 @@ static int __ext4_get_inode_loc(struct inode *inode,
3820 3862
3821 iloc->bh = NULL; 3863 iloc->bh = NULL;
3822 if (!ext4_valid_inum(sb, inode->i_ino)) 3864 if (!ext4_valid_inum(sb, inode->i_ino))
3823 return -EIO; 3865 return -EFSCORRUPTED;
3824 3866
3825 iloc->block_group = (inode->i_ino - 1) / EXT4_INODES_PER_GROUP(sb); 3867 iloc->block_group = (inode->i_ino - 1) / EXT4_INODES_PER_GROUP(sb);
3826 gdp = ext4_get_group_desc(sb, iloc->block_group, NULL); 3868 gdp = ext4_get_group_desc(sb, iloc->block_group, NULL);
@@ -4006,8 +4048,7 @@ static blkcnt_t ext4_inode_blocks(struct ext4_inode *raw_inode,
4006 struct inode *inode = &(ei->vfs_inode); 4048 struct inode *inode = &(ei->vfs_inode);
4007 struct super_block *sb = inode->i_sb; 4049 struct super_block *sb = inode->i_sb;
4008 4050
4009 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, 4051 if (ext4_has_feature_huge_file(sb)) {
4010 EXT4_FEATURE_RO_COMPAT_HUGE_FILE)) {
4011 /* we are using combined 48 bit field */ 4052 /* we are using combined 48 bit field */
4012 i_blocks = ((u64)le16_to_cpu(raw_inode->i_blocks_high)) << 32 | 4053 i_blocks = ((u64)le16_to_cpu(raw_inode->i_blocks_high)) << 32 |
4013 le32_to_cpu(raw_inode->i_blocks_lo); 4054 le32_to_cpu(raw_inode->i_blocks_lo);
@@ -4068,7 +4109,7 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
4068 EXT4_ERROR_INODE(inode, "bad extra_isize (%u != %u)", 4109 EXT4_ERROR_INODE(inode, "bad extra_isize (%u != %u)",
4069 EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize, 4110 EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize,
4070 EXT4_INODE_SIZE(inode->i_sb)); 4111 EXT4_INODE_SIZE(inode->i_sb));
4071 ret = -EIO; 4112 ret = -EFSCORRUPTED;
4072 goto bad_inode; 4113 goto bad_inode;
4073 } 4114 }
4074 } else 4115 } else
@@ -4088,7 +4129,7 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
4088 4129
4089 if (!ext4_inode_csum_verify(inode, raw_inode, ei)) { 4130 if (!ext4_inode_csum_verify(inode, raw_inode, ei)) {
4090 EXT4_ERROR_INODE(inode, "checksum invalid"); 4131 EXT4_ERROR_INODE(inode, "checksum invalid");
4091 ret = -EIO; 4132 ret = -EFSBADCRC;
4092 goto bad_inode; 4133 goto bad_inode;
4093 } 4134 }
4094 4135
@@ -4130,7 +4171,7 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
4130 ei->i_flags = le32_to_cpu(raw_inode->i_flags); 4171 ei->i_flags = le32_to_cpu(raw_inode->i_flags);
4131 inode->i_blocks = ext4_inode_blocks(raw_inode, ei); 4172 inode->i_blocks = ext4_inode_blocks(raw_inode, ei);
4132 ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl_lo); 4173 ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl_lo);
4133 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_64BIT)) 4174 if (ext4_has_feature_64bit(sb))
4134 ei->i_file_acl |= 4175 ei->i_file_acl |=
4135 ((__u64)le16_to_cpu(raw_inode->i_file_acl_high)) << 32; 4176 ((__u64)le16_to_cpu(raw_inode->i_file_acl_high)) << 32;
4136 inode->i_size = ext4_isize(raw_inode); 4177 inode->i_size = ext4_isize(raw_inode);
@@ -4203,7 +4244,7 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
4203 !ext4_data_block_valid(EXT4_SB(sb), ei->i_file_acl, 1)) { 4244 !ext4_data_block_valid(EXT4_SB(sb), ei->i_file_acl, 1)) {
4204 EXT4_ERROR_INODE(inode, "bad extended attribute block %llu", 4245 EXT4_ERROR_INODE(inode, "bad extended attribute block %llu",
4205 ei->i_file_acl); 4246 ei->i_file_acl);
4206 ret = -EIO; 4247 ret = -EFSCORRUPTED;
4207 goto bad_inode; 4248 goto bad_inode;
4208 } else if (!ext4_has_inline_data(inode)) { 4249 } else if (!ext4_has_inline_data(inode)) {
4209 if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) { 4250 if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
@@ -4254,7 +4295,7 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
4254 } else if (ino == EXT4_BOOT_LOADER_INO) { 4295 } else if (ino == EXT4_BOOT_LOADER_INO) {
4255 make_bad_inode(inode); 4296 make_bad_inode(inode);
4256 } else { 4297 } else {
4257 ret = -EIO; 4298 ret = -EFSCORRUPTED;
4258 EXT4_ERROR_INODE(inode, "bogus i_mode (%o)", inode->i_mode); 4299 EXT4_ERROR_INODE(inode, "bogus i_mode (%o)", inode->i_mode);
4259 goto bad_inode; 4300 goto bad_inode;
4260 } 4301 }
@@ -4272,7 +4313,7 @@ bad_inode:
4272struct inode *ext4_iget_normal(struct super_block *sb, unsigned long ino) 4313struct inode *ext4_iget_normal(struct super_block *sb, unsigned long ino)
4273{ 4314{
4274 if (ino < EXT4_FIRST_INO(sb) && ino != EXT4_ROOT_INO) 4315 if (ino < EXT4_FIRST_INO(sb) && ino != EXT4_ROOT_INO)
4275 return ERR_PTR(-EIO); 4316 return ERR_PTR(-EFSCORRUPTED);
4276 return ext4_iget(sb, ino); 4317 return ext4_iget(sb, ino);
4277} 4318}
4278 4319
@@ -4294,7 +4335,7 @@ static int ext4_inode_blocks_set(handle_t *handle,
4294 ext4_clear_inode_flag(inode, EXT4_INODE_HUGE_FILE); 4335 ext4_clear_inode_flag(inode, EXT4_INODE_HUGE_FILE);
4295 return 0; 4336 return 0;
4296 } 4337 }
4297 if (!EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_HUGE_FILE)) 4338 if (!ext4_has_feature_huge_file(sb))
4298 return -EFBIG; 4339 return -EFBIG;
4299 4340
4300 if (i_blocks <= 0xffffffffffffULL) { 4341 if (i_blocks <= 0xffffffffffffULL) {
@@ -4455,8 +4496,7 @@ static int ext4_do_update_inode(handle_t *handle,
4455 need_datasync = 1; 4496 need_datasync = 1;
4456 } 4497 }
4457 if (ei->i_disksize > 0x7fffffffULL) { 4498 if (ei->i_disksize > 0x7fffffffULL) {
4458 if (!EXT4_HAS_RO_COMPAT_FEATURE(sb, 4499 if (!ext4_has_feature_large_file(sb) ||
4459 EXT4_FEATURE_RO_COMPAT_LARGE_FILE) ||
4460 EXT4_SB(sb)->s_es->s_rev_level == 4500 EXT4_SB(sb)->s_es->s_rev_level ==
4461 cpu_to_le32(EXT4_GOOD_OLD_REV)) 4501 cpu_to_le32(EXT4_GOOD_OLD_REV))
4462 set_large_file = 1; 4502 set_large_file = 1;
@@ -4505,8 +4545,7 @@ static int ext4_do_update_inode(handle_t *handle,
4505 if (err) 4545 if (err)
4506 goto out_brelse; 4546 goto out_brelse;
4507 ext4_update_dynamic_rev(sb); 4547 ext4_update_dynamic_rev(sb);
4508 EXT4_SET_RO_COMPAT_FEATURE(sb, 4548 ext4_set_feature_large_file(sb);
4509 EXT4_FEATURE_RO_COMPAT_LARGE_FILE);
4510 ext4_handle_sync(handle); 4549 ext4_handle_sync(handle);
4511 err = ext4_handle_dirty_super(handle, sb); 4550 err = ext4_handle_dirty_super(handle, sb);
4512 } 4551 }
diff --git a/fs/ext4/ioctl.c b/fs/ext4/ioctl.c
index 1346cfa355d0..5e872fd40e5e 100644
--- a/fs/ext4/ioctl.c
+++ b/fs/ext4/ioctl.c
@@ -145,8 +145,7 @@ static long swap_inode_boot_loader(struct super_block *sb,
145 inode_bl->i_version = 1; 145 inode_bl->i_version = 1;
146 i_size_write(inode_bl, 0); 146 i_size_write(inode_bl, 0);
147 inode_bl->i_mode = S_IFREG; 147 inode_bl->i_mode = S_IFREG;
148 if (EXT4_HAS_INCOMPAT_FEATURE(sb, 148 if (ext4_has_feature_extents(sb)) {
149 EXT4_FEATURE_INCOMPAT_EXTENTS)) {
150 ext4_set_inode_flag(inode_bl, EXT4_INODE_EXTENTS); 149 ext4_set_inode_flag(inode_bl, EXT4_INODE_EXTENTS);
151 ext4_ext_tree_init(handle, inode_bl); 150 ext4_ext_tree_init(handle, inode_bl);
152 } else 151 } else
@@ -383,8 +382,7 @@ setversion_out:
383 goto group_extend_out; 382 goto group_extend_out;
384 } 383 }
385 384
386 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, 385 if (ext4_has_feature_bigalloc(sb)) {
387 EXT4_FEATURE_RO_COMPAT_BIGALLOC)) {
388 ext4_msg(sb, KERN_ERR, 386 ext4_msg(sb, KERN_ERR,
389 "Online resizing not supported with bigalloc"); 387 "Online resizing not supported with bigalloc");
390 err = -EOPNOTSUPP; 388 err = -EOPNOTSUPP;
@@ -432,8 +430,7 @@ group_extend_out:
432 goto mext_out; 430 goto mext_out;
433 } 431 }
434 432
435 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, 433 if (ext4_has_feature_bigalloc(sb)) {
436 EXT4_FEATURE_RO_COMPAT_BIGALLOC)) {
437 ext4_msg(sb, KERN_ERR, 434 ext4_msg(sb, KERN_ERR,
438 "Online defrag not supported with bigalloc"); 435 "Online defrag not supported with bigalloc");
439 err = -EOPNOTSUPP; 436 err = -EOPNOTSUPP;
@@ -470,8 +467,7 @@ mext_out:
470 goto group_add_out; 467 goto group_add_out;
471 } 468 }
472 469
473 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, 470 if (ext4_has_feature_bigalloc(sb)) {
474 EXT4_FEATURE_RO_COMPAT_BIGALLOC)) {
475 ext4_msg(sb, KERN_ERR, 471 ext4_msg(sb, KERN_ERR,
476 "Online resizing not supported with bigalloc"); 472 "Online resizing not supported with bigalloc");
477 err = -EOPNOTSUPP; 473 err = -EOPNOTSUPP;
@@ -553,8 +549,7 @@ group_add_out:
553 int err = 0, err2 = 0; 549 int err = 0, err2 = 0;
554 ext4_group_t o_group = EXT4_SB(sb)->s_groups_count; 550 ext4_group_t o_group = EXT4_SB(sb)->s_groups_count;
555 551
556 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, 552 if (ext4_has_feature_bigalloc(sb)) {
557 EXT4_FEATURE_RO_COMPAT_BIGALLOC)) {
558 ext4_msg(sb, KERN_ERR, 553 ext4_msg(sb, KERN_ERR,
559 "Online resizing not (yet) supported with bigalloc"); 554 "Online resizing not (yet) supported with bigalloc");
560 return -EOPNOTSUPP; 555 return -EOPNOTSUPP;
diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
index 34b610ea5030..b4b3c1f91814 100644
--- a/fs/ext4/mballoc.c
+++ b/fs/ext4/mballoc.c
@@ -874,8 +874,10 @@ static int ext4_mb_init_cache(struct page *page, char *incore)
874 bh[i] = NULL; 874 bh[i] = NULL;
875 continue; 875 continue;
876 } 876 }
877 if (!(bh[i] = ext4_read_block_bitmap_nowait(sb, group))) { 877 bh[i] = ext4_read_block_bitmap_nowait(sb, group);
878 err = -ENOMEM; 878 if (IS_ERR(bh[i])) {
879 err = PTR_ERR(bh[i]);
880 bh[i] = NULL;
879 goto out; 881 goto out;
880 } 882 }
881 mb_debug(1, "read bitmap for group %u\n", group); 883 mb_debug(1, "read bitmap for group %u\n", group);
@@ -883,8 +885,13 @@ static int ext4_mb_init_cache(struct page *page, char *incore)
883 885
884 /* wait for I/O completion */ 886 /* wait for I/O completion */
885 for (i = 0, group = first_group; i < groups_per_page; i++, group++) { 887 for (i = 0, group = first_group; i < groups_per_page; i++, group++) {
886 if (bh[i] && ext4_wait_block_bitmap(sb, group, bh[i])) 888 int err2;
887 err = -EIO; 889
890 if (!bh[i])
891 continue;
892 err2 = ext4_wait_block_bitmap(sb, group, bh[i]);
893 if (!err)
894 err = err2;
888 } 895 }
889 896
890 first_block = page->index * blocks_per_page; 897 first_block = page->index * blocks_per_page;
@@ -2333,7 +2340,7 @@ static int ext4_mb_seq_groups_open(struct inode *inode, struct file *file)
2333 2340
2334} 2341}
2335 2342
2336static const struct file_operations ext4_mb_seq_groups_fops = { 2343const struct file_operations ext4_seq_mb_groups_fops = {
2337 .owner = THIS_MODULE, 2344 .owner = THIS_MODULE,
2338 .open = ext4_mb_seq_groups_open, 2345 .open = ext4_mb_seq_groups_open,
2339 .read = seq_read, 2346 .read = seq_read,
@@ -2447,7 +2454,7 @@ int ext4_mb_add_groupinfo(struct super_block *sb, ext4_group_t group,
2447 kmalloc(sb->s_blocksize, GFP_NOFS); 2454 kmalloc(sb->s_blocksize, GFP_NOFS);
2448 BUG_ON(meta_group_info[i]->bb_bitmap == NULL); 2455 BUG_ON(meta_group_info[i]->bb_bitmap == NULL);
2449 bh = ext4_read_block_bitmap(sb, group); 2456 bh = ext4_read_block_bitmap(sb, group);
2450 BUG_ON(bh == NULL); 2457 BUG_ON(IS_ERR_OR_NULL(bh));
2451 memcpy(meta_group_info[i]->bb_bitmap, bh->b_data, 2458 memcpy(meta_group_info[i]->bb_bitmap, bh->b_data,
2452 sb->s_blocksize); 2459 sb->s_blocksize);
2453 put_bh(bh); 2460 put_bh(bh);
@@ -2661,10 +2668,6 @@ int ext4_mb_init(struct super_block *sb)
2661 if (ret != 0) 2668 if (ret != 0)
2662 goto out_free_locality_groups; 2669 goto out_free_locality_groups;
2663 2670
2664 if (sbi->s_proc)
2665 proc_create_data("mb_groups", S_IRUGO, sbi->s_proc,
2666 &ext4_mb_seq_groups_fops, sb);
2667
2668 return 0; 2671 return 0;
2669 2672
2670out_free_locality_groups: 2673out_free_locality_groups:
@@ -2705,9 +2708,6 @@ int ext4_mb_release(struct super_block *sb)
2705 struct ext4_sb_info *sbi = EXT4_SB(sb); 2708 struct ext4_sb_info *sbi = EXT4_SB(sb);
2706 struct kmem_cache *cachep = get_groupinfo_cache(sb->s_blocksize_bits); 2709 struct kmem_cache *cachep = get_groupinfo_cache(sb->s_blocksize_bits);
2707 2710
2708 if (sbi->s_proc)
2709 remove_proc_entry("mb_groups", sbi->s_proc);
2710
2711 if (sbi->s_group_info) { 2711 if (sbi->s_group_info) {
2712 for (i = 0; i < ngroups; i++) { 2712 for (i = 0; i < ngroups; i++) {
2713 grinfo = ext4_get_group_info(sb, i); 2713 grinfo = ext4_get_group_info(sb, i);
@@ -2896,10 +2896,12 @@ ext4_mb_mark_diskspace_used(struct ext4_allocation_context *ac,
2896 sb = ac->ac_sb; 2896 sb = ac->ac_sb;
2897 sbi = EXT4_SB(sb); 2897 sbi = EXT4_SB(sb);
2898 2898
2899 err = -EIO;
2900 bitmap_bh = ext4_read_block_bitmap(sb, ac->ac_b_ex.fe_group); 2899 bitmap_bh = ext4_read_block_bitmap(sb, ac->ac_b_ex.fe_group);
2901 if (!bitmap_bh) 2900 if (IS_ERR(bitmap_bh)) {
2901 err = PTR_ERR(bitmap_bh);
2902 bitmap_bh = NULL;
2902 goto out_err; 2903 goto out_err;
2904 }
2903 2905
2904 BUFFER_TRACE(bitmap_bh, "getting write access"); 2906 BUFFER_TRACE(bitmap_bh, "getting write access");
2905 err = ext4_journal_get_write_access(handle, bitmap_bh); 2907 err = ext4_journal_get_write_access(handle, bitmap_bh);
@@ -3331,8 +3333,8 @@ ext4_mb_check_group_pa(ext4_fsblk_t goal_block,
3331 atomic_inc(&pa->pa_count); 3333 atomic_inc(&pa->pa_count);
3332 return pa; 3334 return pa;
3333 } 3335 }
3334 cur_distance = abs(goal_block - cpa->pa_pstart); 3336 cur_distance = abs64(goal_block - cpa->pa_pstart);
3335 new_distance = abs(goal_block - pa->pa_pstart); 3337 new_distance = abs64(goal_block - pa->pa_pstart);
3336 3338
3337 if (cur_distance <= new_distance) 3339 if (cur_distance <= new_distance)
3338 return cpa; 3340 return cpa;
@@ -3843,8 +3845,10 @@ ext4_mb_discard_group_preallocations(struct super_block *sb,
3843 return 0; 3845 return 0;
3844 3846
3845 bitmap_bh = ext4_read_block_bitmap(sb, group); 3847 bitmap_bh = ext4_read_block_bitmap(sb, group);
3846 if (bitmap_bh == NULL) { 3848 if (IS_ERR(bitmap_bh)) {
3847 ext4_error(sb, "Error reading block bitmap for %u", group); 3849 err = PTR_ERR(bitmap_bh);
3850 ext4_error(sb, "Error %d reading block bitmap for %u",
3851 err, group);
3848 return 0; 3852 return 0;
3849 } 3853 }
3850 3854
@@ -4015,9 +4019,10 @@ repeat:
4015 } 4019 }
4016 4020
4017 bitmap_bh = ext4_read_block_bitmap(sb, group); 4021 bitmap_bh = ext4_read_block_bitmap(sb, group);
4018 if (bitmap_bh == NULL) { 4022 if (IS_ERR(bitmap_bh)) {
4019 ext4_error(sb, "Error reading block bitmap for %u", 4023 err = PTR_ERR(bitmap_bh);
4020 group); 4024 ext4_error(sb, "Error %d reading block bitmap for %u",
4025 err, group);
4021 ext4_mb_unload_buddy(&e4b); 4026 ext4_mb_unload_buddy(&e4b);
4022 continue; 4027 continue;
4023 } 4028 }
@@ -4682,22 +4687,11 @@ void ext4_free_blocks(handle_t *handle, struct inode *inode,
4682 ext4_debug("freeing block %llu\n", block); 4687 ext4_debug("freeing block %llu\n", block);
4683 trace_ext4_free_blocks(inode, block, count, flags); 4688 trace_ext4_free_blocks(inode, block, count, flags);
4684 4689
4685 if (flags & EXT4_FREE_BLOCKS_FORGET) { 4690 if (bh && (flags & EXT4_FREE_BLOCKS_FORGET)) {
4686 struct buffer_head *tbh = bh; 4691 BUG_ON(count > 1);
4687 int i;
4688
4689 BUG_ON(bh && (count > 1));
4690 4692
4691 for (i = 0; i < count; i++) { 4693 ext4_forget(handle, flags & EXT4_FREE_BLOCKS_METADATA,
4692 cond_resched(); 4694 inode, bh, block);
4693 if (!bh)
4694 tbh = sb_find_get_block(inode->i_sb,
4695 block + i);
4696 if (!tbh)
4697 continue;
4698 ext4_forget(handle, flags & EXT4_FREE_BLOCKS_METADATA,
4699 inode, tbh, block + i);
4700 }
4701 } 4695 }
4702 4696
4703 /* 4697 /*
@@ -4742,6 +4736,19 @@ void ext4_free_blocks(handle_t *handle, struct inode *inode,
4742 count += sbi->s_cluster_ratio - overflow; 4736 count += sbi->s_cluster_ratio - overflow;
4743 } 4737 }
4744 4738
4739 if (!bh && (flags & EXT4_FREE_BLOCKS_FORGET)) {
4740 int i;
4741
4742 for (i = 0; i < count; i++) {
4743 cond_resched();
4744 bh = sb_find_get_block(inode->i_sb, block + i);
4745 if (!bh)
4746 continue;
4747 ext4_forget(handle, flags & EXT4_FREE_BLOCKS_METADATA,
4748 inode, bh, block + i);
4749 }
4750 }
4751
4745do_more: 4752do_more:
4746 overflow = 0; 4753 overflow = 0;
4747 ext4_get_group_no_and_offset(sb, block, &block_group, &bit); 4754 ext4_get_group_no_and_offset(sb, block, &block_group, &bit);
@@ -4761,8 +4768,9 @@ do_more:
4761 } 4768 }
4762 count_clusters = EXT4_NUM_B2C(sbi, count); 4769 count_clusters = EXT4_NUM_B2C(sbi, count);
4763 bitmap_bh = ext4_read_block_bitmap(sb, block_group); 4770 bitmap_bh = ext4_read_block_bitmap(sb, block_group);
4764 if (!bitmap_bh) { 4771 if (IS_ERR(bitmap_bh)) {
4765 err = -EIO; 4772 err = PTR_ERR(bitmap_bh);
4773 bitmap_bh = NULL;
4766 goto error_return; 4774 goto error_return;
4767 } 4775 }
4768 gdp = ext4_get_group_desc(sb, block_group, &gd_bh); 4776 gdp = ext4_get_group_desc(sb, block_group, &gd_bh);
@@ -4931,8 +4939,9 @@ int ext4_group_add_blocks(handle_t *handle, struct super_block *sb,
4931 } 4939 }
4932 4940
4933 bitmap_bh = ext4_read_block_bitmap(sb, block_group); 4941 bitmap_bh = ext4_read_block_bitmap(sb, block_group);
4934 if (!bitmap_bh) { 4942 if (IS_ERR(bitmap_bh)) {
4935 err = -EIO; 4943 err = PTR_ERR(bitmap_bh);
4944 bitmap_bh = NULL;
4936 goto error_return; 4945 goto error_return;
4937 } 4946 }
4938 4947
diff --git a/fs/ext4/migrate.c b/fs/ext4/migrate.c
index 6163ad21cb0e..a4651894cc33 100644
--- a/fs/ext4/migrate.c
+++ b/fs/ext4/migrate.c
@@ -448,8 +448,7 @@ int ext4_ext_migrate(struct inode *inode)
448 * If the filesystem does not support extents, or the inode 448 * If the filesystem does not support extents, or the inode
449 * already is extent-based, error out. 449 * already is extent-based, error out.
450 */ 450 */
451 if (!EXT4_HAS_INCOMPAT_FEATURE(inode->i_sb, 451 if (!ext4_has_feature_extents(inode->i_sb) ||
452 EXT4_FEATURE_INCOMPAT_EXTENTS) ||
453 (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) 452 (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
454 return -EINVAL; 453 return -EINVAL;
455 454
@@ -625,13 +624,11 @@ int ext4_ind_migrate(struct inode *inode)
625 handle_t *handle; 624 handle_t *handle;
626 int ret; 625 int ret;
627 626
628 if (!EXT4_HAS_INCOMPAT_FEATURE(inode->i_sb, 627 if (!ext4_has_feature_extents(inode->i_sb) ||
629 EXT4_FEATURE_INCOMPAT_EXTENTS) ||
630 (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) 628 (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
631 return -EINVAL; 629 return -EINVAL;
632 630
633 if (EXT4_HAS_RO_COMPAT_FEATURE(inode->i_sb, 631 if (ext4_has_feature_bigalloc(inode->i_sb))
634 EXT4_FEATURE_RO_COMPAT_BIGALLOC))
635 return -EOPNOTSUPP; 632 return -EOPNOTSUPP;
636 633
637 /* 634 /*
diff --git a/fs/ext4/mmp.c b/fs/ext4/mmp.c
index 6eb1a619890c..0a512aa81bf7 100644
--- a/fs/ext4/mmp.c
+++ b/fs/ext4/mmp.c
@@ -98,10 +98,12 @@ static int read_mmp_block(struct super_block *sb, struct buffer_head **bh,
98 } 98 }
99 99
100 mmp = (struct mmp_struct *)((*bh)->b_data); 100 mmp = (struct mmp_struct *)((*bh)->b_data);
101 if (le32_to_cpu(mmp->mmp_magic) == EXT4_MMP_MAGIC && 101 if (le32_to_cpu(mmp->mmp_magic) != EXT4_MMP_MAGIC)
102 ext4_mmp_csum_verify(sb, mmp)) 102 ret = -EFSCORRUPTED;
103 else if (!ext4_mmp_csum_verify(sb, mmp))
104 ret = -EFSBADCRC;
105 else
103 return 0; 106 return 0;
104 ret = -EINVAL;
105 107
106warn_exit: 108warn_exit:
107 ext4_warning(sb, "Error %d while reading MMP block %llu", 109 ext4_warning(sb, "Error %d while reading MMP block %llu",
diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
index 9f61e7679a6d..19ce34525a59 100644
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -109,7 +109,7 @@ static struct buffer_head *__ext4_read_dirblock(struct inode *inode,
109 if (!bh) { 109 if (!bh) {
110 ext4_error_inode(inode, func, line, block, 110 ext4_error_inode(inode, func, line, block,
111 "Directory hole found"); 111 "Directory hole found");
112 return ERR_PTR(-EIO); 112 return ERR_PTR(-EFSCORRUPTED);
113 } 113 }
114 dirent = (struct ext4_dir_entry *) bh->b_data; 114 dirent = (struct ext4_dir_entry *) bh->b_data;
115 /* Determine whether or not we have an index block */ 115 /* Determine whether or not we have an index block */
@@ -124,7 +124,7 @@ static struct buffer_head *__ext4_read_dirblock(struct inode *inode,
124 if (!is_dx_block && type == INDEX) { 124 if (!is_dx_block && type == INDEX) {
125 ext4_error_inode(inode, func, line, block, 125 ext4_error_inode(inode, func, line, block,
126 "directory leaf block found instead of index block"); 126 "directory leaf block found instead of index block");
127 return ERR_PTR(-EIO); 127 return ERR_PTR(-EFSCORRUPTED);
128 } 128 }
129 if (!ext4_has_metadata_csum(inode->i_sb) || 129 if (!ext4_has_metadata_csum(inode->i_sb) ||
130 buffer_verified(bh)) 130 buffer_verified(bh))
@@ -142,7 +142,7 @@ static struct buffer_head *__ext4_read_dirblock(struct inode *inode,
142 ext4_error_inode(inode, func, line, block, 142 ext4_error_inode(inode, func, line, block,
143 "Directory index failed checksum"); 143 "Directory index failed checksum");
144 brelse(bh); 144 brelse(bh);
145 return ERR_PTR(-EIO); 145 return ERR_PTR(-EFSBADCRC);
146 } 146 }
147 } 147 }
148 if (!is_dx_block) { 148 if (!is_dx_block) {
@@ -152,7 +152,7 @@ static struct buffer_head *__ext4_read_dirblock(struct inode *inode,
152 ext4_error_inode(inode, func, line, block, 152 ext4_error_inode(inode, func, line, block,
153 "Directory block failed checksum"); 153 "Directory block failed checksum");
154 brelse(bh); 154 brelse(bh);
155 return ERR_PTR(-EIO); 155 return ERR_PTR(-EFSBADCRC);
156 } 156 }
157 } 157 }
158 return bh; 158 return bh;
@@ -1570,19 +1570,19 @@ static struct dentry *ext4_lookup(struct inode *dir, struct dentry *dentry, unsi
1570 brelse(bh); 1570 brelse(bh);
1571 if (!ext4_valid_inum(dir->i_sb, ino)) { 1571 if (!ext4_valid_inum(dir->i_sb, ino)) {
1572 EXT4_ERROR_INODE(dir, "bad inode number: %u", ino); 1572 EXT4_ERROR_INODE(dir, "bad inode number: %u", ino);
1573 return ERR_PTR(-EIO); 1573 return ERR_PTR(-EFSCORRUPTED);
1574 } 1574 }
1575 if (unlikely(ino == dir->i_ino)) { 1575 if (unlikely(ino == dir->i_ino)) {
1576 EXT4_ERROR_INODE(dir, "'%pd' linked to parent dir", 1576 EXT4_ERROR_INODE(dir, "'%pd' linked to parent dir",
1577 dentry); 1577 dentry);
1578 return ERR_PTR(-EIO); 1578 return ERR_PTR(-EFSCORRUPTED);
1579 } 1579 }
1580 inode = ext4_iget_normal(dir->i_sb, ino); 1580 inode = ext4_iget_normal(dir->i_sb, ino);
1581 if (inode == ERR_PTR(-ESTALE)) { 1581 if (inode == ERR_PTR(-ESTALE)) {
1582 EXT4_ERROR_INODE(dir, 1582 EXT4_ERROR_INODE(dir,
1583 "deleted inode referenced: %u", 1583 "deleted inode referenced: %u",
1584 ino); 1584 ino);
1585 return ERR_PTR(-EIO); 1585 return ERR_PTR(-EFSCORRUPTED);
1586 } 1586 }
1587 if (!IS_ERR(inode) && ext4_encrypted_inode(dir) && 1587 if (!IS_ERR(inode) && ext4_encrypted_inode(dir) &&
1588 (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) || 1588 (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
@@ -1619,7 +1619,7 @@ struct dentry *ext4_get_parent(struct dentry *child)
1619 if (!ext4_valid_inum(d_inode(child)->i_sb, ino)) { 1619 if (!ext4_valid_inum(d_inode(child)->i_sb, ino)) {
1620 EXT4_ERROR_INODE(d_inode(child), 1620 EXT4_ERROR_INODE(d_inode(child),
1621 "bad parent inode number: %u", ino); 1621 "bad parent inode number: %u", ino);
1622 return ERR_PTR(-EIO); 1622 return ERR_PTR(-EFSCORRUPTED);
1623 } 1623 }
1624 1624
1625 return d_obtain_alias(ext4_iget_normal(d_inode(child)->i_sb, ino)); 1625 return d_obtain_alias(ext4_iget_normal(d_inode(child)->i_sb, ino));
@@ -1807,7 +1807,7 @@ int ext4_find_dest_de(struct inode *dir, struct inode *inode,
1807 while ((char *) de <= top) { 1807 while ((char *) de <= top) {
1808 if (ext4_check_dir_entry(dir, NULL, de, bh, 1808 if (ext4_check_dir_entry(dir, NULL, de, bh,
1809 buf, buf_size, offset)) { 1809 buf, buf_size, offset)) {
1810 res = -EIO; 1810 res = -EFSCORRUPTED;
1811 goto return_result; 1811 goto return_result;
1812 } 1812 }
1813 /* Provide crypto context and crypto buffer to ext4 match */ 1813 /* Provide crypto context and crypto buffer to ext4 match */
@@ -1967,7 +1967,7 @@ static int make_indexed_dir(handle_t *handle, struct ext4_filename *fname,
1967 if ((char *) de >= (((char *) root) + blocksize)) { 1967 if ((char *) de >= (((char *) root) + blocksize)) {
1968 EXT4_ERROR_INODE(dir, "invalid rec_len for '..'"); 1968 EXT4_ERROR_INODE(dir, "invalid rec_len for '..'");
1969 brelse(bh); 1969 brelse(bh);
1970 return -EIO; 1970 return -EFSCORRUPTED;
1971 } 1971 }
1972 len = ((char *) root) + (blocksize - csum_size) - (char *) de; 1972 len = ((char *) root) + (blocksize - csum_size) - (char *) de;
1973 1973
@@ -2118,7 +2118,7 @@ static int ext4_add_entry(handle_t *handle, struct dentry *dentry,
2118 goto out; 2118 goto out;
2119 2119
2120 if (blocks == 1 && !dx_fallback && 2120 if (blocks == 1 && !dx_fallback &&
2121 EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_DIR_INDEX)) { 2121 ext4_has_feature_dir_index(sb)) {
2122 retval = make_indexed_dir(handle, &fname, dentry, 2122 retval = make_indexed_dir(handle, &fname, dentry,
2123 inode, bh); 2123 inode, bh);
2124 bh = NULL; /* make_indexed_dir releases bh */ 2124 bh = NULL; /* make_indexed_dir releases bh */
@@ -2315,7 +2315,7 @@ int ext4_generic_delete_entry(handle_t *handle,
2315 while (i < buf_size - csum_size) { 2315 while (i < buf_size - csum_size) {
2316 if (ext4_check_dir_entry(dir, NULL, de, bh, 2316 if (ext4_check_dir_entry(dir, NULL, de, bh,
2317 bh->b_data, bh->b_size, i)) 2317 bh->b_data, bh->b_size, i))
2318 return -EIO; 2318 return -EFSCORRUPTED;
2319 if (de == de_del) { 2319 if (de == de_del) {
2320 if (pde) 2320 if (pde)
2321 pde->rec_len = ext4_rec_len_to_disk( 2321 pde->rec_len = ext4_rec_len_to_disk(
@@ -2388,8 +2388,7 @@ static void ext4_inc_count(handle_t *handle, struct inode *inode)
2388 /* limit is 16-bit i_links_count */ 2388 /* limit is 16-bit i_links_count */
2389 if (inode->i_nlink >= EXT4_LINK_MAX || inode->i_nlink == 2) { 2389 if (inode->i_nlink >= EXT4_LINK_MAX || inode->i_nlink == 2) {
2390 set_nlink(inode, 1); 2390 set_nlink(inode, 1);
2391 EXT4_SET_RO_COMPAT_FEATURE(inode->i_sb, 2391 ext4_set_feature_dir_nlink(inode->i_sb);
2392 EXT4_FEATURE_RO_COMPAT_DIR_NLINK);
2393 } 2392 }
2394 } 2393 }
2395} 2394}
@@ -2469,9 +2468,6 @@ static int ext4_mknod(struct inode *dir, struct dentry *dentry,
2469 struct inode *inode; 2468 struct inode *inode;
2470 int err, credits, retries = 0; 2469 int err, credits, retries = 0;
2471 2470
2472 if (!new_valid_dev(rdev))
2473 return -EINVAL;
2474
2475 err = dquot_initialize(dir); 2471 err = dquot_initialize(dir);
2476 if (err) 2472 if (err)
2477 return err; 2473 return err;
@@ -2934,7 +2930,7 @@ static int ext4_rmdir(struct inode *dir, struct dentry *dentry)
2934 2930
2935 inode = d_inode(dentry); 2931 inode = d_inode(dentry);
2936 2932
2937 retval = -EIO; 2933 retval = -EFSCORRUPTED;
2938 if (le32_to_cpu(de->inode) != inode->i_ino) 2934 if (le32_to_cpu(de->inode) != inode->i_ino)
2939 goto end_rmdir; 2935 goto end_rmdir;
2940 2936
@@ -3008,7 +3004,7 @@ static int ext4_unlink(struct inode *dir, struct dentry *dentry)
3008 3004
3009 inode = d_inode(dentry); 3005 inode = d_inode(dentry);
3010 3006
3011 retval = -EIO; 3007 retval = -EFSCORRUPTED;
3012 if (le32_to_cpu(de->inode) != inode->i_ino) 3008 if (le32_to_cpu(de->inode) != inode->i_ino)
3013 goto end_unlink; 3009 goto end_unlink;
3014 3010
@@ -3310,7 +3306,7 @@ static int ext4_rename_dir_prepare(handle_t *handle, struct ext4_renament *ent)
3310 if (!ent->dir_bh) 3306 if (!ent->dir_bh)
3311 return retval; 3307 return retval;
3312 if (le32_to_cpu(ent->parent_de->inode) != ent->dir->i_ino) 3308 if (le32_to_cpu(ent->parent_de->inode) != ent->dir->i_ino)
3313 return -EIO; 3309 return -EFSCORRUPTED;
3314 BUFFER_TRACE(ent->dir_bh, "get_write_access"); 3310 BUFFER_TRACE(ent->dir_bh, "get_write_access");
3315 return ext4_journal_get_write_access(handle, ent->dir_bh); 3311 return ext4_journal_get_write_access(handle, ent->dir_bh);
3316} 3312}
@@ -3352,8 +3348,7 @@ static int ext4_setent(handle_t *handle, struct ext4_renament *ent,
3352 if (retval) 3348 if (retval)
3353 return retval; 3349 return retval;
3354 ent->de->inode = cpu_to_le32(ino); 3350 ent->de->inode = cpu_to_le32(ino);
3355 if (EXT4_HAS_INCOMPAT_FEATURE(ent->dir->i_sb, 3351 if (ext4_has_feature_filetype(ent->dir->i_sb))
3356 EXT4_FEATURE_INCOMPAT_FILETYPE))
3357 ent->de->file_type = file_type; 3352 ent->de->file_type = file_type;
3358 ent->dir->i_version++; 3353 ent->dir->i_version++;
3359 ent->dir->i_ctime = ent->dir->i_mtime = 3354 ent->dir->i_ctime = ent->dir->i_mtime =
diff --git a/fs/ext4/page-io.c b/fs/ext4/page-io.c
index 84ba4d2b3a35..17fbe3882b8e 100644
--- a/fs/ext4/page-io.c
+++ b/fs/ext4/page-io.c
@@ -425,6 +425,7 @@ int ext4_bio_write_page(struct ext4_io_submit *io,
425 struct buffer_head *bh, *head; 425 struct buffer_head *bh, *head;
426 int ret = 0; 426 int ret = 0;
427 int nr_submitted = 0; 427 int nr_submitted = 0;
428 int nr_to_submit = 0;
428 429
429 blocksize = 1 << inode->i_blkbits; 430 blocksize = 1 << inode->i_blkbits;
430 431
@@ -477,11 +478,13 @@ int ext4_bio_write_page(struct ext4_io_submit *io,
477 unmap_underlying_metadata(bh->b_bdev, bh->b_blocknr); 478 unmap_underlying_metadata(bh->b_bdev, bh->b_blocknr);
478 } 479 }
479 set_buffer_async_write(bh); 480 set_buffer_async_write(bh);
481 nr_to_submit++;
480 } while ((bh = bh->b_this_page) != head); 482 } while ((bh = bh->b_this_page) != head);
481 483
482 bh = head = page_buffers(page); 484 bh = head = page_buffers(page);
483 485
484 if (ext4_encrypted_inode(inode) && S_ISREG(inode->i_mode)) { 486 if (ext4_encrypted_inode(inode) && S_ISREG(inode->i_mode) &&
487 nr_to_submit) {
485 data_page = ext4_encrypt(inode, page); 488 data_page = ext4_encrypt(inode, page);
486 if (IS_ERR(data_page)) { 489 if (IS_ERR(data_page)) {
487 ret = PTR_ERR(data_page); 490 ret = PTR_ERR(data_page);
diff --git a/fs/ext4/readpage.c b/fs/ext4/readpage.c
index 560af0437704..d94af71a4e7f 100644
--- a/fs/ext4/readpage.c
+++ b/fs/ext4/readpage.c
@@ -62,7 +62,7 @@ static void completion_pages(struct work_struct *work)
62 bio_for_each_segment_all(bv, bio, i) { 62 bio_for_each_segment_all(bv, bio, i) {
63 struct page *page = bv->bv_page; 63 struct page *page = bv->bv_page;
64 64
65 int ret = ext4_decrypt(ctx, page); 65 int ret = ext4_decrypt(page);
66 if (ret) { 66 if (ret) {
67 WARN_ON_ONCE(1); 67 WARN_ON_ONCE(1);
68 SetPageError(page); 68 SetPageError(page);
diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index cf0c472047e3..ad62d7acc315 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -490,7 +490,7 @@ static int setup_new_flex_group_blocks(struct super_block *sb,
490 group_data[0].group != sbi->s_groups_count); 490 group_data[0].group != sbi->s_groups_count);
491 491
492 reserved_gdb = le16_to_cpu(es->s_reserved_gdt_blocks); 492 reserved_gdb = le16_to_cpu(es->s_reserved_gdt_blocks);
493 meta_bg = EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_META_BG); 493 meta_bg = ext4_has_feature_meta_bg(sb);
494 494
495 /* This transaction may be extended/restarted along the way */ 495 /* This transaction may be extended/restarted along the way */
496 handle = ext4_journal_start_sb(sb, EXT4_HT_RESIZE, EXT4_MAX_TRANS_DATA); 496 handle = ext4_journal_start_sb(sb, EXT4_HT_RESIZE, EXT4_MAX_TRANS_DATA);
@@ -680,8 +680,7 @@ static unsigned ext4_list_backups(struct super_block *sb, unsigned *three,
680 int mult = 3; 680 int mult = 3;
681 unsigned ret; 681 unsigned ret;
682 682
683 if (!EXT4_HAS_RO_COMPAT_FEATURE(sb, 683 if (!ext4_has_feature_sparse_super(sb)) {
684 EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER)) {
685 ret = *min; 684 ret = *min;
686 *min += 1; 685 *min += 1;
687 return ret; 686 return ret;
@@ -1040,7 +1039,7 @@ exit_free:
1040 * do not copy the full number of backups at this time. The resize 1039 * do not copy the full number of backups at this time. The resize
1041 * which changed s_groups_count will backup again. 1040 * which changed s_groups_count will backup again.
1042 */ 1041 */
1043static void update_backups(struct super_block *sb, int blk_off, char *data, 1042static void update_backups(struct super_block *sb, sector_t blk_off, char *data,
1044 int size, int meta_bg) 1043 int size, int meta_bg)
1045{ 1044{
1046 struct ext4_sb_info *sbi = EXT4_SB(sb); 1045 struct ext4_sb_info *sbi = EXT4_SB(sb);
@@ -1065,7 +1064,7 @@ static void update_backups(struct super_block *sb, int blk_off, char *data,
1065 group = ext4_list_backups(sb, &three, &five, &seven); 1064 group = ext4_list_backups(sb, &three, &five, &seven);
1066 last = sbi->s_groups_count; 1065 last = sbi->s_groups_count;
1067 } else { 1066 } else {
1068 group = ext4_meta_bg_first_group(sb, group) + 1; 1067 group = ext4_get_group_number(sb, blk_off) + 1;
1069 last = (ext4_group_t)(group + EXT4_DESC_PER_BLOCK(sb) - 2); 1068 last = (ext4_group_t)(group + EXT4_DESC_PER_BLOCK(sb) - 2);
1070 } 1069 }
1071 1070
@@ -1158,7 +1157,7 @@ static int ext4_add_new_descs(handle_t *handle, struct super_block *sb,
1158 int i, gdb_off, gdb_num, err = 0; 1157 int i, gdb_off, gdb_num, err = 0;
1159 int meta_bg; 1158 int meta_bg;
1160 1159
1161 meta_bg = EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_META_BG); 1160 meta_bg = ext4_has_feature_meta_bg(sb);
1162 for (i = 0; i < count; i++, group++) { 1161 for (i = 0; i < count; i++, group++) {
1163 int reserved_gdb = ext4_bg_has_super(sb, group) ? 1162 int reserved_gdb = ext4_bg_has_super(sb, group) ?
1164 le16_to_cpu(es->s_reserved_gdt_blocks) : 0; 1163 le16_to_cpu(es->s_reserved_gdt_blocks) : 0;
@@ -1381,9 +1380,7 @@ static void ext4_update_super(struct super_block *sb,
1381 1380
1382 ext4_debug("free blocks count %llu", 1381 ext4_debug("free blocks count %llu",
1383 percpu_counter_read(&sbi->s_freeclusters_counter)); 1382 percpu_counter_read(&sbi->s_freeclusters_counter));
1384 if (EXT4_HAS_INCOMPAT_FEATURE(sb, 1383 if (ext4_has_feature_flex_bg(sb) && sbi->s_log_groups_per_flex) {
1385 EXT4_FEATURE_INCOMPAT_FLEX_BG) &&
1386 sbi->s_log_groups_per_flex) {
1387 ext4_group_t flex_group; 1384 ext4_group_t flex_group;
1388 flex_group = ext4_flex_group(sbi, group_data[0].group); 1385 flex_group = ext4_flex_group(sbi, group_data[0].group);
1389 atomic64_add(EXT4_NUM_B2C(sbi, free_blocks), 1386 atomic64_add(EXT4_NUM_B2C(sbi, free_blocks),
@@ -1476,8 +1473,7 @@ exit_journal:
1476 int gdb_num = group / EXT4_DESC_PER_BLOCK(sb); 1473 int gdb_num = group / EXT4_DESC_PER_BLOCK(sb);
1477 int gdb_num_end = ((group + flex_gd->count - 1) / 1474 int gdb_num_end = ((group + flex_gd->count - 1) /
1478 EXT4_DESC_PER_BLOCK(sb)); 1475 EXT4_DESC_PER_BLOCK(sb));
1479 int meta_bg = EXT4_HAS_INCOMPAT_FEATURE(sb, 1476 int meta_bg = ext4_has_feature_meta_bg(sb);
1480 EXT4_FEATURE_INCOMPAT_META_BG);
1481 sector_t old_gdb = 0; 1477 sector_t old_gdb = 0;
1482 1478
1483 update_backups(sb, sbi->s_sbh->b_blocknr, (char *)es, 1479 update_backups(sb, sbi->s_sbh->b_blocknr, (char *)es,
@@ -1585,8 +1581,7 @@ int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input)
1585 1581
1586 gdb_off = input->group % EXT4_DESC_PER_BLOCK(sb); 1582 gdb_off = input->group % EXT4_DESC_PER_BLOCK(sb);
1587 1583
1588 if (gdb_off == 0 && !EXT4_HAS_RO_COMPAT_FEATURE(sb, 1584 if (gdb_off == 0 && !ext4_has_feature_sparse_super(sb)) {
1589 EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER)) {
1590 ext4_warning(sb, "Can't resize non-sparse filesystem further"); 1585 ext4_warning(sb, "Can't resize non-sparse filesystem further");
1591 return -EPERM; 1586 return -EPERM;
1592 } 1587 }
@@ -1604,9 +1599,8 @@ int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input)
1604 } 1599 }
1605 1600
1606 if (reserved_gdb || gdb_off == 0) { 1601 if (reserved_gdb || gdb_off == 0) {
1607 if (!EXT4_HAS_COMPAT_FEATURE(sb, 1602 if (ext4_has_feature_resize_inode(sb) ||
1608 EXT4_FEATURE_COMPAT_RESIZE_INODE) 1603 !le16_to_cpu(es->s_reserved_gdt_blocks)) {
1609 || !le16_to_cpu(es->s_reserved_gdt_blocks)) {
1610 ext4_warning(sb, 1604 ext4_warning(sb,
1611 "No reserved GDT blocks, can't resize"); 1605 "No reserved GDT blocks, can't resize");
1612 return -EPERM; 1606 return -EPERM;
@@ -1825,8 +1819,8 @@ static int ext4_convert_meta_bg(struct super_block *sb, struct inode *inode)
1825 if (err) 1819 if (err)
1826 goto errout; 1820 goto errout;
1827 1821
1828 EXT4_CLEAR_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_RESIZE_INODE); 1822 ext4_clear_feature_resize_inode(sb);
1829 EXT4_SET_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_META_BG); 1823 ext4_set_feature_meta_bg(sb);
1830 sbi->s_es->s_first_meta_bg = 1824 sbi->s_es->s_first_meta_bg =
1831 cpu_to_le32(num_desc_blocks(sb, sbi->s_groups_count)); 1825 cpu_to_le32(num_desc_blocks(sb, sbi->s_groups_count));
1832 1826
@@ -1918,9 +1912,9 @@ retry:
1918 n_desc_blocks = num_desc_blocks(sb, n_group + 1); 1912 n_desc_blocks = num_desc_blocks(sb, n_group + 1);
1919 o_desc_blocks = num_desc_blocks(sb, sbi->s_groups_count); 1913 o_desc_blocks = num_desc_blocks(sb, sbi->s_groups_count);
1920 1914
1921 meta_bg = EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_META_BG); 1915 meta_bg = ext4_has_feature_meta_bg(sb);
1922 1916
1923 if (EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_RESIZE_INODE)) { 1917 if (ext4_has_feature_resize_inode(sb)) {
1924 if (meta_bg) { 1918 if (meta_bg) {
1925 ext4_error(sb, "resize_inode and meta_bg enabled " 1919 ext4_error(sb, "resize_inode and meta_bg enabled "
1926 "simultaneously"); 1920 "simultaneously");
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index a63c7b0a10cf..04d0f1b33409 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -34,7 +34,6 @@
34#include <linux/namei.h> 34#include <linux/namei.h>
35#include <linux/quotaops.h> 35#include <linux/quotaops.h>
36#include <linux/seq_file.h> 36#include <linux/seq_file.h>
37#include <linux/proc_fs.h>
38#include <linux/ctype.h> 37#include <linux/ctype.h>
39#include <linux/log2.h> 38#include <linux/log2.h>
40#include <linux/crc16.h> 39#include <linux/crc16.h>
@@ -54,11 +53,8 @@
54#define CREATE_TRACE_POINTS 53#define CREATE_TRACE_POINTS
55#include <trace/events/ext4.h> 54#include <trace/events/ext4.h>
56 55
57static struct proc_dir_entry *ext4_proc_root;
58static struct kset *ext4_kset;
59static struct ext4_lazy_init *ext4_li_info; 56static struct ext4_lazy_init *ext4_li_info;
60static struct mutex ext4_li_mtx; 57static struct mutex ext4_li_mtx;
61static struct ext4_features *ext4_feat;
62static int ext4_mballoc_ready; 58static int ext4_mballoc_ready;
63static struct ratelimit_state ext4_mount_msg_ratelimit; 59static struct ratelimit_state ext4_mount_msg_ratelimit;
64 60
@@ -83,7 +79,6 @@ static int ext4_feature_set_ok(struct super_block *sb, int readonly);
83static void ext4_destroy_lazyinit_thread(void); 79static void ext4_destroy_lazyinit_thread(void);
84static void ext4_unregister_li_request(struct super_block *sb); 80static void ext4_unregister_li_request(struct super_block *sb);
85static void ext4_clear_request_list(void); 81static void ext4_clear_request_list(void);
86static int ext4_reserve_clusters(struct ext4_sb_info *, ext4_fsblk_t);
87 82
88#if !defined(CONFIG_EXT2_FS) && !defined(CONFIG_EXT2_FS_MODULE) && defined(CONFIG_EXT4_USE_FOR_EXT2) 83#if !defined(CONFIG_EXT2_FS) && !defined(CONFIG_EXT2_FS_MODULE) && defined(CONFIG_EXT4_USE_FOR_EXT2)
89static struct file_system_type ext2_fs_type = { 84static struct file_system_type ext2_fs_type = {
@@ -115,8 +110,7 @@ MODULE_ALIAS("ext3");
115static int ext4_verify_csum_type(struct super_block *sb, 110static int ext4_verify_csum_type(struct super_block *sb,
116 struct ext4_super_block *es) 111 struct ext4_super_block *es)
117{ 112{
118 if (!EXT4_HAS_RO_COMPAT_FEATURE(sb, 113 if (!ext4_has_feature_metadata_csum(sb))
119 EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
120 return 1; 114 return 1;
121 115
122 return es->s_checksum_type == EXT4_CRC32C_CHKSUM; 116 return es->s_checksum_type == EXT4_CRC32C_CHKSUM;
@@ -394,9 +388,13 @@ static void ext4_handle_error(struct super_block *sb)
394 smp_wmb(); 388 smp_wmb();
395 sb->s_flags |= MS_RDONLY; 389 sb->s_flags |= MS_RDONLY;
396 } 390 }
397 if (test_opt(sb, ERRORS_PANIC)) 391 if (test_opt(sb, ERRORS_PANIC)) {
392 if (EXT4_SB(sb)->s_journal &&
393 !(EXT4_SB(sb)->s_journal->j_flags & JBD2_REC_ERR))
394 return;
398 panic("EXT4-fs (device %s): panic forced after error\n", 395 panic("EXT4-fs (device %s): panic forced after error\n",
399 sb->s_id); 396 sb->s_id);
397 }
400} 398}
401 399
402#define ext4_error_ratelimit(sb) \ 400#define ext4_error_ratelimit(sb) \
@@ -495,6 +493,12 @@ const char *ext4_decode_error(struct super_block *sb, int errno,
495 char *errstr = NULL; 493 char *errstr = NULL;
496 494
497 switch (errno) { 495 switch (errno) {
496 case -EFSCORRUPTED:
497 errstr = "Corrupt filesystem";
498 break;
499 case -EFSBADCRC:
500 errstr = "Filesystem failed CRC";
501 break;
498 case -EIO: 502 case -EIO:
499 errstr = "IO failure"; 503 errstr = "IO failure";
500 break; 504 break;
@@ -585,8 +589,12 @@ void __ext4_abort(struct super_block *sb, const char *function,
585 jbd2_journal_abort(EXT4_SB(sb)->s_journal, -EIO); 589 jbd2_journal_abort(EXT4_SB(sb)->s_journal, -EIO);
586 save_error_info(sb, function, line); 590 save_error_info(sb, function, line);
587 } 591 }
588 if (test_opt(sb, ERRORS_PANIC)) 592 if (test_opt(sb, ERRORS_PANIC)) {
593 if (EXT4_SB(sb)->s_journal &&
594 !(EXT4_SB(sb)->s_journal->j_flags & JBD2_REC_ERR))
595 return;
589 panic("EXT4-fs panic from previous error\n"); 596 panic("EXT4-fs panic from previous error\n");
597 }
590} 598}
591 599
592void __ext4_msg(struct super_block *sb, 600void __ext4_msg(struct super_block *sb,
@@ -800,6 +808,7 @@ static void ext4_put_super(struct super_block *sb)
800 ext4_abort(sb, "Couldn't clean up the journal"); 808 ext4_abort(sb, "Couldn't clean up the journal");
801 } 809 }
802 810
811 ext4_unregister_sysfs(sb);
803 ext4_es_unregister_shrinker(sbi); 812 ext4_es_unregister_shrinker(sbi);
804 del_timer_sync(&sbi->s_err_report); 813 del_timer_sync(&sbi->s_err_report);
805 ext4_release_system_zone(sb); 814 ext4_release_system_zone(sb);
@@ -808,18 +817,12 @@ static void ext4_put_super(struct super_block *sb)
808 ext4_xattr_put_super(sb); 817 ext4_xattr_put_super(sb);
809 818
810 if (!(sb->s_flags & MS_RDONLY)) { 819 if (!(sb->s_flags & MS_RDONLY)) {
811 EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER); 820 ext4_clear_feature_journal_needs_recovery(sb);
812 es->s_state = cpu_to_le16(sbi->s_mount_state); 821 es->s_state = cpu_to_le16(sbi->s_mount_state);
813 } 822 }
814 if (!(sb->s_flags & MS_RDONLY)) 823 if (!(sb->s_flags & MS_RDONLY))
815 ext4_commit_super(sb, 1); 824 ext4_commit_super(sb, 1);
816 825
817 if (sbi->s_proc) {
818 remove_proc_entry("options", sbi->s_proc);
819 remove_proc_entry(sb->s_id, ext4_proc_root);
820 }
821 kobject_del(&sbi->s_kobj);
822
823 for (i = 0; i < sbi->s_gdb_count; i++) 826 for (i = 0; i < sbi->s_gdb_count; i++)
824 brelse(sbi->s_group_desc[i]); 827 brelse(sbi->s_group_desc[i]);
825 kvfree(sbi->s_group_desc); 828 kvfree(sbi->s_group_desc);
@@ -1288,7 +1291,7 @@ static int set_qf_name(struct super_block *sb, int qtype, substring_t *args)
1288 "quota options when quota turned on"); 1291 "quota options when quota turned on");
1289 return -1; 1292 return -1;
1290 } 1293 }
1291 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_QUOTA)) { 1294 if (ext4_has_feature_quota(sb)) {
1292 ext4_msg(sb, KERN_ERR, "Cannot set journaled quota options " 1295 ext4_msg(sb, KERN_ERR, "Cannot set journaled quota options "
1293 "when QUOTA feature is enabled"); 1296 "when QUOTA feature is enabled");
1294 return -1; 1297 return -1;
@@ -1381,10 +1384,10 @@ static const struct mount_opts {
1381 {Opt_nojournal_checksum, EXT4_MOUNT_JOURNAL_CHECKSUM, 1384 {Opt_nojournal_checksum, EXT4_MOUNT_JOURNAL_CHECKSUM,
1382 MOPT_EXT4_ONLY | MOPT_CLEAR}, 1385 MOPT_EXT4_ONLY | MOPT_CLEAR},
1383 {Opt_journal_checksum, EXT4_MOUNT_JOURNAL_CHECKSUM, 1386 {Opt_journal_checksum, EXT4_MOUNT_JOURNAL_CHECKSUM,
1384 MOPT_EXT4_ONLY | MOPT_SET}, 1387 MOPT_EXT4_ONLY | MOPT_SET | MOPT_EXPLICIT},
1385 {Opt_journal_async_commit, (EXT4_MOUNT_JOURNAL_ASYNC_COMMIT | 1388 {Opt_journal_async_commit, (EXT4_MOUNT_JOURNAL_ASYNC_COMMIT |
1386 EXT4_MOUNT_JOURNAL_CHECKSUM), 1389 EXT4_MOUNT_JOURNAL_CHECKSUM),
1387 MOPT_EXT4_ONLY | MOPT_SET}, 1390 MOPT_EXT4_ONLY | MOPT_SET | MOPT_EXPLICIT},
1388 {Opt_noload, EXT4_MOUNT_NOLOAD, MOPT_NO_EXT2 | MOPT_SET}, 1391 {Opt_noload, EXT4_MOUNT_NOLOAD, MOPT_NO_EXT2 | MOPT_SET},
1389 {Opt_err_panic, EXT4_MOUNT_ERRORS_PANIC, MOPT_SET | MOPT_CLEAR_ERR}, 1392 {Opt_err_panic, EXT4_MOUNT_ERRORS_PANIC, MOPT_SET | MOPT_CLEAR_ERR},
1390 {Opt_err_ro, EXT4_MOUNT_ERRORS_RO, MOPT_SET | MOPT_CLEAR_ERR}, 1393 {Opt_err_ro, EXT4_MOUNT_ERRORS_RO, MOPT_SET | MOPT_CLEAR_ERR},
@@ -1513,8 +1516,14 @@ static int handle_mount_opt(struct super_block *sb, char *opt, int token,
1513 return -1; 1516 return -1;
1514 if (args->from && (m->flags & MOPT_GTE0) && (arg < 0)) 1517 if (args->from && (m->flags & MOPT_GTE0) && (arg < 0))
1515 return -1; 1518 return -1;
1516 if (m->flags & MOPT_EXPLICIT) 1519 if (m->flags & MOPT_EXPLICIT) {
1517 set_opt2(sb, EXPLICIT_DELALLOC); 1520 if (m->mount_opt & EXT4_MOUNT_DELALLOC) {
1521 set_opt2(sb, EXPLICIT_DELALLOC);
1522 } else if (m->mount_opt & EXT4_MOUNT_JOURNAL_CHECKSUM) {
1523 set_opt2(sb, EXPLICIT_JOURNAL_CHECKSUM);
1524 } else
1525 return -1;
1526 }
1518 if (m->flags & MOPT_CLEAR_ERR) 1527 if (m->flags & MOPT_CLEAR_ERR)
1519 clear_opt(sb, ERRORS_MASK); 1528 clear_opt(sb, ERRORS_MASK);
1520 if (token == Opt_noquota && sb_any_quota_loaded(sb)) { 1529 if (token == Opt_noquota && sb_any_quota_loaded(sb)) {
@@ -1647,8 +1656,7 @@ static int handle_mount_opt(struct super_block *sb, char *opt, int token,
1647 "quota options when quota turned on"); 1656 "quota options when quota turned on");
1648 return -1; 1657 return -1;
1649 } 1658 }
1650 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, 1659 if (ext4_has_feature_quota(sb)) {
1651 EXT4_FEATURE_RO_COMPAT_QUOTA)) {
1652 ext4_msg(sb, KERN_ERR, 1660 ext4_msg(sb, KERN_ERR,
1653 "Cannot set journaled quota options " 1661 "Cannot set journaled quota options "
1654 "when QUOTA feature is enabled"); 1662 "when QUOTA feature is enabled");
@@ -1707,7 +1715,7 @@ static int parse_options(char *options, struct super_block *sb,
1707 return 0; 1715 return 0;
1708 } 1716 }
1709#ifdef CONFIG_QUOTA 1717#ifdef CONFIG_QUOTA
1710 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_QUOTA) && 1718 if (ext4_has_feature_quota(sb) &&
1711 (test_opt(sb, USRQUOTA) || test_opt(sb, GRPQUOTA))) { 1719 (test_opt(sb, USRQUOTA) || test_opt(sb, GRPQUOTA))) {
1712 ext4_msg(sb, KERN_ERR, "Cannot set quota options when QUOTA " 1720 ext4_msg(sb, KERN_ERR, "Cannot set quota options when QUOTA "
1713 "feature is enabled"); 1721 "feature is enabled");
@@ -1880,7 +1888,7 @@ static int ext4_show_options(struct seq_file *seq, struct dentry *root)
1880 return _ext4_show_options(seq, root->d_sb, 0); 1888 return _ext4_show_options(seq, root->d_sb, 0);
1881} 1889}
1882 1890
1883static int options_seq_show(struct seq_file *seq, void *offset) 1891int ext4_seq_options_show(struct seq_file *seq, void *offset)
1884{ 1892{
1885 struct super_block *sb = seq->private; 1893 struct super_block *sb = seq->private;
1886 int rc; 1894 int rc;
@@ -1891,19 +1899,6 @@ static int options_seq_show(struct seq_file *seq, void *offset)
1891 return rc; 1899 return rc;
1892} 1900}
1893 1901
1894static int options_open_fs(struct inode *inode, struct file *file)
1895{
1896 return single_open(file, options_seq_show, PDE_DATA(inode));
1897}
1898
1899static const struct file_operations ext4_seq_options_fops = {
1900 .owner = THIS_MODULE,
1901 .open = options_open_fs,
1902 .read = seq_read,
1903 .llseek = seq_lseek,
1904 .release = single_release,
1905};
1906
1907static int ext4_setup_super(struct super_block *sb, struct ext4_super_block *es, 1902static int ext4_setup_super(struct super_block *sb, struct ext4_super_block *es,
1908 int read_only) 1903 int read_only)
1909{ 1904{
@@ -1944,7 +1939,7 @@ static int ext4_setup_super(struct super_block *sb, struct ext4_super_block *es,
1944 es->s_mtime = cpu_to_le32(get_seconds()); 1939 es->s_mtime = cpu_to_le32(get_seconds());
1945 ext4_update_dynamic_rev(sb); 1940 ext4_update_dynamic_rev(sb);
1946 if (sbi->s_journal) 1941 if (sbi->s_journal)
1947 EXT4_SET_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER); 1942 ext4_set_feature_journal_needs_recovery(sb);
1948 1943
1949 ext4_commit_super(sb, 1); 1944 ext4_commit_super(sb, 1);
1950done: 1945done:
@@ -2027,12 +2022,13 @@ failed:
2027 return 0; 2022 return 0;
2028} 2023}
2029 2024
2030static __le16 ext4_group_desc_csum(struct ext4_sb_info *sbi, __u32 block_group, 2025static __le16 ext4_group_desc_csum(struct super_block *sb, __u32 block_group,
2031 struct ext4_group_desc *gdp) 2026 struct ext4_group_desc *gdp)
2032{ 2027{
2033 int offset; 2028 int offset;
2034 __u16 crc = 0; 2029 __u16 crc = 0;
2035 __le32 le_group = cpu_to_le32(block_group); 2030 __le32 le_group = cpu_to_le32(block_group);
2031 struct ext4_sb_info *sbi = EXT4_SB(sb);
2036 2032
2037 if (ext4_has_metadata_csum(sbi->s_sb)) { 2033 if (ext4_has_metadata_csum(sbi->s_sb)) {
2038 /* Use new metadata_csum algorithm */ 2034 /* Use new metadata_csum algorithm */
@@ -2052,8 +2048,7 @@ static __le16 ext4_group_desc_csum(struct ext4_sb_info *sbi, __u32 block_group,
2052 } 2048 }
2053 2049
2054 /* old crc16 code */ 2050 /* old crc16 code */
2055 if (!(sbi->s_es->s_feature_ro_compat & 2051 if (!ext4_has_feature_gdt_csum(sb))
2056 cpu_to_le32(EXT4_FEATURE_RO_COMPAT_GDT_CSUM)))
2057 return 0; 2052 return 0;
2058 2053
2059 offset = offsetof(struct ext4_group_desc, bg_checksum); 2054 offset = offsetof(struct ext4_group_desc, bg_checksum);
@@ -2063,8 +2058,7 @@ static __le16 ext4_group_desc_csum(struct ext4_sb_info *sbi, __u32 block_group,
2063 crc = crc16(crc, (__u8 *)gdp, offset); 2058 crc = crc16(crc, (__u8 *)gdp, offset);
2064 offset += sizeof(gdp->bg_checksum); /* skip checksum */ 2059 offset += sizeof(gdp->bg_checksum); /* skip checksum */
2065 /* for checksum of struct ext4_group_desc do the rest...*/ 2060 /* for checksum of struct ext4_group_desc do the rest...*/
2066 if ((sbi->s_es->s_feature_incompat & 2061 if (ext4_has_feature_64bit(sb) &&
2067 cpu_to_le32(EXT4_FEATURE_INCOMPAT_64BIT)) &&
2068 offset < le16_to_cpu(sbi->s_es->s_desc_size)) 2062 offset < le16_to_cpu(sbi->s_es->s_desc_size))
2069 crc = crc16(crc, (__u8 *)gdp + offset, 2063 crc = crc16(crc, (__u8 *)gdp + offset,
2070 le16_to_cpu(sbi->s_es->s_desc_size) - 2064 le16_to_cpu(sbi->s_es->s_desc_size) -
@@ -2078,8 +2072,7 @@ int ext4_group_desc_csum_verify(struct super_block *sb, __u32 block_group,
2078 struct ext4_group_desc *gdp) 2072 struct ext4_group_desc *gdp)
2079{ 2073{
2080 if (ext4_has_group_desc_csum(sb) && 2074 if (ext4_has_group_desc_csum(sb) &&
2081 (gdp->bg_checksum != ext4_group_desc_csum(EXT4_SB(sb), 2075 (gdp->bg_checksum != ext4_group_desc_csum(sb, block_group, gdp)))
2082 block_group, gdp)))
2083 return 0; 2076 return 0;
2084 2077
2085 return 1; 2078 return 1;
@@ -2090,7 +2083,7 @@ void ext4_group_desc_csum_set(struct super_block *sb, __u32 block_group,
2090{ 2083{
2091 if (!ext4_has_group_desc_csum(sb)) 2084 if (!ext4_has_group_desc_csum(sb))
2092 return; 2085 return;
2093 gdp->bg_checksum = ext4_group_desc_csum(EXT4_SB(sb), block_group, gdp); 2086 gdp->bg_checksum = ext4_group_desc_csum(sb, block_group, gdp);
2094} 2087}
2095 2088
2096/* Called at mount-time, super-block is locked */ 2089/* Called at mount-time, super-block is locked */
@@ -2106,7 +2099,7 @@ static int ext4_check_descriptors(struct super_block *sb,
2106 int flexbg_flag = 0; 2099 int flexbg_flag = 0;
2107 ext4_group_t i, grp = sbi->s_groups_count; 2100 ext4_group_t i, grp = sbi->s_groups_count;
2108 2101
2109 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG)) 2102 if (ext4_has_feature_flex_bg(sb))
2110 flexbg_flag = 1; 2103 flexbg_flag = 1;
2111 2104
2112 ext4_debug("Checking group descriptors"); 2105 ext4_debug("Checking group descriptors");
@@ -2150,7 +2143,7 @@ static int ext4_check_descriptors(struct super_block *sb,
2150 if (!ext4_group_desc_csum_verify(sb, i, gdp)) { 2143 if (!ext4_group_desc_csum_verify(sb, i, gdp)) {
2151 ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: " 2144 ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
2152 "Checksum for group %u failed (%u!=%u)", 2145 "Checksum for group %u failed (%u!=%u)",
2153 i, le16_to_cpu(ext4_group_desc_csum(sbi, i, 2146 i, le16_to_cpu(ext4_group_desc_csum(sb, i,
2154 gdp)), le16_to_cpu(gdp->bg_checksum)); 2147 gdp)), le16_to_cpu(gdp->bg_checksum));
2155 if (!(sb->s_flags & MS_RDONLY)) { 2148 if (!(sb->s_flags & MS_RDONLY)) {
2156 ext4_unlock_group(sb, i); 2149 ext4_unlock_group(sb, i);
@@ -2413,8 +2406,7 @@ static ext4_fsblk_t descriptor_loc(struct super_block *sb,
2413 2406
2414 first_meta_bg = le32_to_cpu(sbi->s_es->s_first_meta_bg); 2407 first_meta_bg = le32_to_cpu(sbi->s_es->s_first_meta_bg);
2415 2408
2416 if (!EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_META_BG) || 2409 if (!ext4_has_feature_meta_bg(sb) || nr < first_meta_bg)
2417 nr < first_meta_bg)
2418 return logical_sb_block + nr + 1; 2410 return logical_sb_block + nr + 1;
2419 bg = sbi->s_desc_per_block * nr; 2411 bg = sbi->s_desc_per_block * nr;
2420 if (ext4_bg_has_super(sb, bg)) 2412 if (ext4_bg_has_super(sb, bg))
@@ -2470,335 +2462,6 @@ static unsigned long ext4_get_stripe_size(struct ext4_sb_info *sbi)
2470 return ret; 2462 return ret;
2471} 2463}
2472 2464
2473/* sysfs supprt */
2474
2475struct ext4_attr {
2476 struct attribute attr;
2477 ssize_t (*show)(struct ext4_attr *, struct ext4_sb_info *, char *);
2478 ssize_t (*store)(struct ext4_attr *, struct ext4_sb_info *,
2479 const char *, size_t);
2480 union {
2481 int offset;
2482 int deprecated_val;
2483 } u;
2484};
2485
2486static int parse_strtoull(const char *buf,
2487 unsigned long long max, unsigned long long *value)
2488{
2489 int ret;
2490
2491 ret = kstrtoull(skip_spaces(buf), 0, value);
2492 if (!ret && *value > max)
2493 ret = -EINVAL;
2494 return ret;
2495}
2496
2497static ssize_t delayed_allocation_blocks_show(struct ext4_attr *a,
2498 struct ext4_sb_info *sbi,
2499 char *buf)
2500{
2501 return snprintf(buf, PAGE_SIZE, "%llu\n",
2502 (s64) EXT4_C2B(sbi,
2503 percpu_counter_sum(&sbi->s_dirtyclusters_counter)));
2504}
2505
2506static ssize_t session_write_kbytes_show(struct ext4_attr *a,
2507 struct ext4_sb_info *sbi, char *buf)
2508{
2509 struct super_block *sb = sbi->s_buddy_cache->i_sb;
2510
2511 if (!sb->s_bdev->bd_part)
2512 return snprintf(buf, PAGE_SIZE, "0\n");
2513 return snprintf(buf, PAGE_SIZE, "%lu\n",
2514 (part_stat_read(sb->s_bdev->bd_part, sectors[1]) -
2515 sbi->s_sectors_written_start) >> 1);
2516}
2517
2518static ssize_t lifetime_write_kbytes_show(struct ext4_attr *a,
2519 struct ext4_sb_info *sbi, char *buf)
2520{
2521 struct super_block *sb = sbi->s_buddy_cache->i_sb;
2522
2523 if (!sb->s_bdev->bd_part)
2524 return snprintf(buf, PAGE_SIZE, "0\n");
2525 return snprintf(buf, PAGE_SIZE, "%llu\n",
2526 (unsigned long long)(sbi->s_kbytes_written +
2527 ((part_stat_read(sb->s_bdev->bd_part, sectors[1]) -
2528 EXT4_SB(sb)->s_sectors_written_start) >> 1)));
2529}
2530
2531static ssize_t inode_readahead_blks_store(struct ext4_attr *a,
2532 struct ext4_sb_info *sbi,
2533 const char *buf, size_t count)
2534{
2535 unsigned long t;
2536 int ret;
2537
2538 ret = kstrtoul(skip_spaces(buf), 0, &t);
2539 if (ret)
2540 return ret;
2541
2542 if (t && (!is_power_of_2(t) || t > 0x40000000))
2543 return -EINVAL;
2544
2545 sbi->s_inode_readahead_blks = t;
2546 return count;
2547}
2548
2549static ssize_t sbi_ui_show(struct ext4_attr *a,
2550 struct ext4_sb_info *sbi, char *buf)
2551{
2552 unsigned int *ui = (unsigned int *) (((char *) sbi) + a->u.offset);
2553
2554 return snprintf(buf, PAGE_SIZE, "%u\n", *ui);
2555}
2556
2557static ssize_t sbi_ui_store(struct ext4_attr *a,
2558 struct ext4_sb_info *sbi,
2559 const char *buf, size_t count)
2560{
2561 unsigned int *ui = (unsigned int *) (((char *) sbi) + a->u.offset);
2562 unsigned long t;
2563 int ret;
2564
2565 ret = kstrtoul(skip_spaces(buf), 0, &t);
2566 if (ret)
2567 return ret;
2568 *ui = t;
2569 return count;
2570}
2571
2572static ssize_t es_ui_show(struct ext4_attr *a,
2573 struct ext4_sb_info *sbi, char *buf)
2574{
2575
2576 unsigned int *ui = (unsigned int *) (((char *) sbi->s_es) +
2577 a->u.offset);
2578
2579 return snprintf(buf, PAGE_SIZE, "%u\n", *ui);
2580}
2581
2582static ssize_t reserved_clusters_show(struct ext4_attr *a,
2583 struct ext4_sb_info *sbi, char *buf)
2584{
2585 return snprintf(buf, PAGE_SIZE, "%llu\n",
2586 (unsigned long long) atomic64_read(&sbi->s_resv_clusters));
2587}
2588
2589static ssize_t reserved_clusters_store(struct ext4_attr *a,
2590 struct ext4_sb_info *sbi,
2591 const char *buf, size_t count)
2592{
2593 unsigned long long val;
2594 int ret;
2595
2596 if (parse_strtoull(buf, -1ULL, &val))
2597 return -EINVAL;
2598 ret = ext4_reserve_clusters(sbi, val);
2599
2600 return ret ? ret : count;
2601}
2602
2603static ssize_t trigger_test_error(struct ext4_attr *a,
2604 struct ext4_sb_info *sbi,
2605 const char *buf, size_t count)
2606{
2607 int len = count;
2608
2609 if (!capable(CAP_SYS_ADMIN))
2610 return -EPERM;
2611
2612 if (len && buf[len-1] == '\n')
2613 len--;
2614
2615 if (len)
2616 ext4_error(sbi->s_sb, "%.*s", len, buf);
2617 return count;
2618}
2619
2620static ssize_t sbi_deprecated_show(struct ext4_attr *a,
2621 struct ext4_sb_info *sbi, char *buf)
2622{
2623 return snprintf(buf, PAGE_SIZE, "%d\n", a->u.deprecated_val);
2624}
2625
2626#define EXT4_ATTR_OFFSET(_name,_mode,_show,_store,_elname) \
2627static struct ext4_attr ext4_attr_##_name = { \
2628 .attr = {.name = __stringify(_name), .mode = _mode }, \
2629 .show = _show, \
2630 .store = _store, \
2631 .u = { \
2632 .offset = offsetof(struct ext4_sb_info, _elname),\
2633 }, \
2634}
2635
2636#define EXT4_ATTR_OFFSET_ES(_name,_mode,_show,_store,_elname) \
2637static struct ext4_attr ext4_attr_##_name = { \
2638 .attr = {.name = __stringify(_name), .mode = _mode }, \
2639 .show = _show, \
2640 .store = _store, \
2641 .u = { \
2642 .offset = offsetof(struct ext4_super_block, _elname), \
2643 }, \
2644}
2645
2646#define EXT4_ATTR(name, mode, show, store) \
2647static struct ext4_attr ext4_attr_##name = __ATTR(name, mode, show, store)
2648
2649#define EXT4_INFO_ATTR(name) EXT4_ATTR(name, 0444, NULL, NULL)
2650#define EXT4_RO_ATTR(name) EXT4_ATTR(name, 0444, name##_show, NULL)
2651#define EXT4_RW_ATTR(name) EXT4_ATTR(name, 0644, name##_show, name##_store)
2652
2653#define EXT4_RO_ATTR_ES_UI(name, elname) \
2654 EXT4_ATTR_OFFSET_ES(name, 0444, es_ui_show, NULL, elname)
2655#define EXT4_RW_ATTR_SBI_UI(name, elname) \
2656 EXT4_ATTR_OFFSET(name, 0644, sbi_ui_show, sbi_ui_store, elname)
2657
2658#define ATTR_LIST(name) &ext4_attr_##name.attr
2659#define EXT4_DEPRECATED_ATTR(_name, _val) \
2660static struct ext4_attr ext4_attr_##_name = { \
2661 .attr = {.name = __stringify(_name), .mode = 0444 }, \
2662 .show = sbi_deprecated_show, \
2663 .u = { \
2664 .deprecated_val = _val, \
2665 }, \
2666}
2667
2668EXT4_RO_ATTR(delayed_allocation_blocks);
2669EXT4_RO_ATTR(session_write_kbytes);
2670EXT4_RO_ATTR(lifetime_write_kbytes);
2671EXT4_RW_ATTR(reserved_clusters);
2672EXT4_ATTR_OFFSET(inode_readahead_blks, 0644, sbi_ui_show,
2673 inode_readahead_blks_store, s_inode_readahead_blks);
2674EXT4_RW_ATTR_SBI_UI(inode_goal, s_inode_goal);
2675EXT4_RW_ATTR_SBI_UI(mb_stats, s_mb_stats);
2676EXT4_RW_ATTR_SBI_UI(mb_max_to_scan, s_mb_max_to_scan);
2677EXT4_RW_ATTR_SBI_UI(mb_min_to_scan, s_mb_min_to_scan);
2678EXT4_RW_ATTR_SBI_UI(mb_order2_req, s_mb_order2_reqs);
2679EXT4_RW_ATTR_SBI_UI(mb_stream_req, s_mb_stream_request);
2680EXT4_RW_ATTR_SBI_UI(mb_group_prealloc, s_mb_group_prealloc);
2681EXT4_DEPRECATED_ATTR(max_writeback_mb_bump, 128);
2682EXT4_RW_ATTR_SBI_UI(extent_max_zeroout_kb, s_extent_max_zeroout_kb);
2683EXT4_ATTR(trigger_fs_error, 0200, NULL, trigger_test_error);
2684EXT4_RW_ATTR_SBI_UI(err_ratelimit_interval_ms, s_err_ratelimit_state.interval);
2685EXT4_RW_ATTR_SBI_UI(err_ratelimit_burst, s_err_ratelimit_state.burst);
2686EXT4_RW_ATTR_SBI_UI(warning_ratelimit_interval_ms, s_warning_ratelimit_state.interval);
2687EXT4_RW_ATTR_SBI_UI(warning_ratelimit_burst, s_warning_ratelimit_state.burst);
2688EXT4_RW_ATTR_SBI_UI(msg_ratelimit_interval_ms, s_msg_ratelimit_state.interval);
2689EXT4_RW_ATTR_SBI_UI(msg_ratelimit_burst, s_msg_ratelimit_state.burst);
2690EXT4_RO_ATTR_ES_UI(errors_count, s_error_count);
2691EXT4_RO_ATTR_ES_UI(first_error_time, s_first_error_time);
2692EXT4_RO_ATTR_ES_UI(last_error_time, s_last_error_time);
2693
2694static struct attribute *ext4_attrs[] = {
2695 ATTR_LIST(delayed_allocation_blocks),
2696 ATTR_LIST(session_write_kbytes),
2697 ATTR_LIST(lifetime_write_kbytes),
2698 ATTR_LIST(reserved_clusters),
2699 ATTR_LIST(inode_readahead_blks),
2700 ATTR_LIST(inode_goal),
2701 ATTR_LIST(mb_stats),
2702 ATTR_LIST(mb_max_to_scan),
2703 ATTR_LIST(mb_min_to_scan),
2704 ATTR_LIST(mb_order2_req),
2705 ATTR_LIST(mb_stream_req),
2706 ATTR_LIST(mb_group_prealloc),
2707 ATTR_LIST(max_writeback_mb_bump),
2708 ATTR_LIST(extent_max_zeroout_kb),
2709 ATTR_LIST(trigger_fs_error),
2710 ATTR_LIST(err_ratelimit_interval_ms),
2711 ATTR_LIST(err_ratelimit_burst),
2712 ATTR_LIST(warning_ratelimit_interval_ms),
2713 ATTR_LIST(warning_ratelimit_burst),
2714 ATTR_LIST(msg_ratelimit_interval_ms),
2715 ATTR_LIST(msg_ratelimit_burst),
2716 ATTR_LIST(errors_count),
2717 ATTR_LIST(first_error_time),
2718 ATTR_LIST(last_error_time),
2719 NULL,
2720};
2721
2722/* Features this copy of ext4 supports */
2723EXT4_INFO_ATTR(lazy_itable_init);
2724EXT4_INFO_ATTR(batched_discard);
2725EXT4_INFO_ATTR(meta_bg_resize);
2726EXT4_INFO_ATTR(encryption);
2727
2728static struct attribute *ext4_feat_attrs[] = {
2729 ATTR_LIST(lazy_itable_init),
2730 ATTR_LIST(batched_discard),
2731 ATTR_LIST(meta_bg_resize),
2732 ATTR_LIST(encryption),
2733 NULL,
2734};
2735
2736static ssize_t ext4_attr_show(struct kobject *kobj,
2737 struct attribute *attr, char *buf)
2738{
2739 struct ext4_sb_info *sbi = container_of(kobj, struct ext4_sb_info,
2740 s_kobj);
2741 struct ext4_attr *a = container_of(attr, struct ext4_attr, attr);
2742
2743 return a->show ? a->show(a, sbi, buf) : 0;
2744}
2745
2746static ssize_t ext4_attr_store(struct kobject *kobj,
2747 struct attribute *attr,
2748 const char *buf, size_t len)
2749{
2750 struct ext4_sb_info *sbi = container_of(kobj, struct ext4_sb_info,
2751 s_kobj);
2752 struct ext4_attr *a = container_of(attr, struct ext4_attr, attr);
2753
2754 return a->store ? a->store(a, sbi, buf, len) : 0;
2755}
2756
2757static void ext4_sb_release(struct kobject *kobj)
2758{
2759 struct ext4_sb_info *sbi = container_of(kobj, struct ext4_sb_info,
2760 s_kobj);
2761 complete(&sbi->s_kobj_unregister);
2762}
2763
2764static const struct sysfs_ops ext4_attr_ops = {
2765 .show = ext4_attr_show,
2766 .store = ext4_attr_store,
2767};
2768
2769static struct kobj_type ext4_ktype = {
2770 .default_attrs = ext4_attrs,
2771 .sysfs_ops = &ext4_attr_ops,
2772 .release = ext4_sb_release,
2773};
2774
2775static void ext4_feat_release(struct kobject *kobj)
2776{
2777 complete(&ext4_feat->f_kobj_unregister);
2778}
2779
2780static ssize_t ext4_feat_show(struct kobject *kobj,
2781 struct attribute *attr, char *buf)
2782{
2783 return snprintf(buf, PAGE_SIZE, "supported\n");
2784}
2785
2786/*
2787 * We can not use ext4_attr_show/store because it relies on the kobject
2788 * being embedded in the ext4_sb_info structure which is definitely not
2789 * true in this case.
2790 */
2791static const struct sysfs_ops ext4_feat_ops = {
2792 .show = ext4_feat_show,
2793 .store = NULL,
2794};
2795
2796static struct kobj_type ext4_feat_ktype = {
2797 .default_attrs = ext4_feat_attrs,
2798 .sysfs_ops = &ext4_feat_ops,
2799 .release = ext4_feat_release,
2800};
2801
2802/* 2465/*
2803 * Check whether this filesystem can be mounted based on 2466 * Check whether this filesystem can be mounted based on
2804 * the features present and the RDONLY/RDWR mount requested. 2467 * the features present and the RDONLY/RDWR mount requested.
@@ -2807,7 +2470,7 @@ static struct kobj_type ext4_feat_ktype = {
2807 */ 2470 */
2808static int ext4_feature_set_ok(struct super_block *sb, int readonly) 2471static int ext4_feature_set_ok(struct super_block *sb, int readonly)
2809{ 2472{
2810 if (EXT4_HAS_INCOMPAT_FEATURE(sb, ~EXT4_FEATURE_INCOMPAT_SUPP)) { 2473 if (ext4_has_unknown_ext4_incompat_features(sb)) {
2811 ext4_msg(sb, KERN_ERR, 2474 ext4_msg(sb, KERN_ERR,
2812 "Couldn't mount because of " 2475 "Couldn't mount because of "
2813 "unsupported optional features (%x)", 2476 "unsupported optional features (%x)",
@@ -2819,14 +2482,14 @@ static int ext4_feature_set_ok(struct super_block *sb, int readonly)
2819 if (readonly) 2482 if (readonly)
2820 return 1; 2483 return 1;
2821 2484
2822 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_READONLY)) { 2485 if (ext4_has_feature_readonly(sb)) {
2823 ext4_msg(sb, KERN_INFO, "filesystem is read-only"); 2486 ext4_msg(sb, KERN_INFO, "filesystem is read-only");
2824 sb->s_flags |= MS_RDONLY; 2487 sb->s_flags |= MS_RDONLY;
2825 return 1; 2488 return 1;
2826 } 2489 }
2827 2490
2828 /* Check that feature set is OK for a read-write mount */ 2491 /* Check that feature set is OK for a read-write mount */
2829 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, ~EXT4_FEATURE_RO_COMPAT_SUPP)) { 2492 if (ext4_has_unknown_ext4_ro_compat_features(sb)) {
2830 ext4_msg(sb, KERN_ERR, "couldn't mount RDWR because of " 2493 ext4_msg(sb, KERN_ERR, "couldn't mount RDWR because of "
2831 "unsupported optional features (%x)", 2494 "unsupported optional features (%x)",
2832 (le32_to_cpu(EXT4_SB(sb)->s_es->s_feature_ro_compat) & 2495 (le32_to_cpu(EXT4_SB(sb)->s_es->s_feature_ro_compat) &
@@ -2837,7 +2500,7 @@ static int ext4_feature_set_ok(struct super_block *sb, int readonly)
2837 * Large file size enabled file system can only be mounted 2500 * Large file size enabled file system can only be mounted
2838 * read-write on 32-bit systems if kernel is built with CONFIG_LBDAF 2501 * read-write on 32-bit systems if kernel is built with CONFIG_LBDAF
2839 */ 2502 */
2840 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_HUGE_FILE)) { 2503 if (ext4_has_feature_huge_file(sb)) {
2841 if (sizeof(blkcnt_t) < sizeof(u64)) { 2504 if (sizeof(blkcnt_t) < sizeof(u64)) {
2842 ext4_msg(sb, KERN_ERR, "Filesystem with huge files " 2505 ext4_msg(sb, KERN_ERR, "Filesystem with huge files "
2843 "cannot be mounted RDWR without " 2506 "cannot be mounted RDWR without "
@@ -2845,8 +2508,7 @@ static int ext4_feature_set_ok(struct super_block *sb, int readonly)
2845 return 0; 2508 return 0;
2846 } 2509 }
2847 } 2510 }
2848 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_BIGALLOC) && 2511 if (ext4_has_feature_bigalloc(sb) && !ext4_has_feature_extents(sb)) {
2849 !EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_EXTENTS)) {
2850 ext4_msg(sb, KERN_ERR, 2512 ext4_msg(sb, KERN_ERR,
2851 "Can't support bigalloc feature without " 2513 "Can't support bigalloc feature without "
2852 "extents feature\n"); 2514 "extents feature\n");
@@ -2854,8 +2516,7 @@ static int ext4_feature_set_ok(struct super_block *sb, int readonly)
2854 } 2516 }
2855 2517
2856#ifndef CONFIG_QUOTA 2518#ifndef CONFIG_QUOTA
2857 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_QUOTA) && 2519 if (ext4_has_feature_quota(sb) && !readonly) {
2858 !readonly) {
2859 ext4_msg(sb, KERN_ERR, 2520 ext4_msg(sb, KERN_ERR,
2860 "Filesystem with quota feature cannot be mounted RDWR " 2521 "Filesystem with quota feature cannot be mounted RDWR "
2861 "without CONFIG_QUOTA"); 2522 "without CONFIG_QUOTA");
@@ -3312,7 +2973,7 @@ static int count_overhead(struct super_block *sb, ext4_group_t grp,
3312 ext4_group_t i, ngroups = ext4_get_groups_count(sb); 2973 ext4_group_t i, ngroups = ext4_get_groups_count(sb);
3313 int s, j, count = 0; 2974 int s, j, count = 0;
3314 2975
3315 if (!EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_BIGALLOC)) 2976 if (!ext4_has_feature_bigalloc(sb))
3316 return (ext4_bg_has_super(sb, grp) + ext4_bg_num_gdb(sb, grp) + 2977 return (ext4_bg_has_super(sb, grp) + ext4_bg_num_gdb(sb, grp) +
3317 sbi->s_itb_per_group + 2); 2978 sbi->s_itb_per_group + 2);
3318 2979
@@ -3403,10 +3064,10 @@ int ext4_calculate_overhead(struct super_block *sb)
3403 return 0; 3064 return 0;
3404} 3065}
3405 3066
3406 3067static void ext4_set_resv_clusters(struct super_block *sb)
3407static ext4_fsblk_t ext4_calculate_resv_clusters(struct super_block *sb)
3408{ 3068{
3409 ext4_fsblk_t resv_clusters; 3069 ext4_fsblk_t resv_clusters;
3070 struct ext4_sb_info *sbi = EXT4_SB(sb);
3410 3071
3411 /* 3072 /*
3412 * There's no need to reserve anything when we aren't using extents. 3073 * There's no need to reserve anything when we aren't using extents.
@@ -3414,8 +3075,8 @@ static ext4_fsblk_t ext4_calculate_resv_clusters(struct super_block *sb)
3414 * hole punching doesn't need new metadata... This is needed especially 3075 * hole punching doesn't need new metadata... This is needed especially
3415 * to keep ext2/3 backward compatibility. 3076 * to keep ext2/3 backward compatibility.
3416 */ 3077 */
3417 if (!EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_EXTENTS)) 3078 if (!ext4_has_feature_extents(sb))
3418 return 0; 3079 return;
3419 /* 3080 /*
3420 * By default we reserve 2% or 4096 clusters, whichever is smaller. 3081 * By default we reserve 2% or 4096 clusters, whichever is smaller.
3421 * This should cover the situations where we can not afford to run 3082 * This should cover the situations where we can not afford to run
@@ -3424,26 +3085,13 @@ static ext4_fsblk_t ext4_calculate_resv_clusters(struct super_block *sb)
3424 * allocation would require 1, or 2 blocks, higher numbers are 3085 * allocation would require 1, or 2 blocks, higher numbers are
3425 * very rare. 3086 * very rare.
3426 */ 3087 */
3427 resv_clusters = ext4_blocks_count(EXT4_SB(sb)->s_es) >> 3088 resv_clusters = (ext4_blocks_count(sbi->s_es) >>
3428 EXT4_SB(sb)->s_cluster_bits; 3089 sbi->s_cluster_bits);
3429 3090
3430 do_div(resv_clusters, 50); 3091 do_div(resv_clusters, 50);
3431 resv_clusters = min_t(ext4_fsblk_t, resv_clusters, 4096); 3092 resv_clusters = min_t(ext4_fsblk_t, resv_clusters, 4096);
3432 3093
3433 return resv_clusters; 3094 atomic64_set(&sbi->s_resv_clusters, resv_clusters);
3434}
3435
3436
3437static int ext4_reserve_clusters(struct ext4_sb_info *sbi, ext4_fsblk_t count)
3438{
3439 ext4_fsblk_t clusters = ext4_blocks_count(sbi->s_es) >>
3440 sbi->s_cluster_bits;
3441
3442 if (count >= clusters)
3443 return -EINVAL;
3444
3445 atomic64_set(&sbi->s_resv_clusters, count);
3446 return 0;
3447} 3095}
3448 3096
3449static int ext4_fill_super(struct super_block *sb, void *data, int silent) 3097static int ext4_fill_super(struct super_block *sb, void *data, int silent)
@@ -3526,9 +3174,8 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
3526 sbi->s_kbytes_written = le64_to_cpu(es->s_kbytes_written); 3174 sbi->s_kbytes_written = le64_to_cpu(es->s_kbytes_written);
3527 3175
3528 /* Warn if metadata_csum and gdt_csum are both set. */ 3176 /* Warn if metadata_csum and gdt_csum are both set. */
3529 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, 3177 if (ext4_has_feature_metadata_csum(sb) &&
3530 EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) && 3178 ext4_has_feature_gdt_csum(sb))
3531 EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_GDT_CSUM))
3532 ext4_warning(sb, "metadata_csum and uninit_bg are " 3179 ext4_warning(sb, "metadata_csum and uninit_bg are "
3533 "redundant flags; please run fsck."); 3180 "redundant flags; please run fsck.");
3534 3181
@@ -3541,8 +3188,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
3541 } 3188 }
3542 3189
3543 /* Load the checksum driver */ 3190 /* Load the checksum driver */
3544 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, 3191 if (ext4_has_feature_metadata_csum(sb)) {
3545 EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) {
3546 sbi->s_chksum_driver = crypto_alloc_shash("crc32c", 0, 0); 3192 sbi->s_chksum_driver = crypto_alloc_shash("crc32c", 0, 0);
3547 if (IS_ERR(sbi->s_chksum_driver)) { 3193 if (IS_ERR(sbi->s_chksum_driver)) {
3548 ext4_msg(sb, KERN_ERR, "Cannot load crc32c driver."); 3194 ext4_msg(sb, KERN_ERR, "Cannot load crc32c driver.");
@@ -3557,11 +3203,14 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
3557 ext4_msg(sb, KERN_ERR, "VFS: Found ext4 filesystem with " 3203 ext4_msg(sb, KERN_ERR, "VFS: Found ext4 filesystem with "
3558 "invalid superblock checksum. Run e2fsck?"); 3204 "invalid superblock checksum. Run e2fsck?");
3559 silent = 1; 3205 silent = 1;
3206 ret = -EFSBADCRC;
3560 goto cantfind_ext4; 3207 goto cantfind_ext4;
3561 } 3208 }
3562 3209
3563 /* Precompute checksum seed for all metadata */ 3210 /* Precompute checksum seed for all metadata */
3564 if (ext4_has_metadata_csum(sb)) 3211 if (ext4_has_feature_csum_seed(sb))
3212 sbi->s_csum_seed = le32_to_cpu(es->s_checksum_seed);
3213 else if (ext4_has_metadata_csum(sb))
3565 sbi->s_csum_seed = ext4_chksum(sbi, ~0, es->s_uuid, 3214 sbi->s_csum_seed = ext4_chksum(sbi, ~0, es->s_uuid,
3566 sizeof(es->s_uuid)); 3215 sizeof(es->s_uuid));
3567 3216
@@ -3664,17 +3313,16 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
3664 (test_opt(sb, POSIX_ACL) ? MS_POSIXACL : 0); 3313 (test_opt(sb, POSIX_ACL) ? MS_POSIXACL : 0);
3665 3314
3666 if (le32_to_cpu(es->s_rev_level) == EXT4_GOOD_OLD_REV && 3315 if (le32_to_cpu(es->s_rev_level) == EXT4_GOOD_OLD_REV &&
3667 (EXT4_HAS_COMPAT_FEATURE(sb, ~0U) || 3316 (ext4_has_compat_features(sb) ||
3668 EXT4_HAS_RO_COMPAT_FEATURE(sb, ~0U) || 3317 ext4_has_ro_compat_features(sb) ||
3669 EXT4_HAS_INCOMPAT_FEATURE(sb, ~0U))) 3318 ext4_has_incompat_features(sb)))
3670 ext4_msg(sb, KERN_WARNING, 3319 ext4_msg(sb, KERN_WARNING,
3671 "feature flags set on rev 0 fs, " 3320 "feature flags set on rev 0 fs, "
3672 "running e2fsck is recommended"); 3321 "running e2fsck is recommended");
3673 3322
3674 if (es->s_creator_os == cpu_to_le32(EXT4_OS_HURD)) { 3323 if (es->s_creator_os == cpu_to_le32(EXT4_OS_HURD)) {
3675 set_opt2(sb, HURD_COMPAT); 3324 set_opt2(sb, HURD_COMPAT);
3676 if (EXT4_HAS_INCOMPAT_FEATURE(sb, 3325 if (ext4_has_feature_64bit(sb)) {
3677 EXT4_FEATURE_INCOMPAT_64BIT)) {
3678 ext4_msg(sb, KERN_ERR, 3326 ext4_msg(sb, KERN_ERR,
3679 "The Hurd can't support 64-bit file systems"); 3327 "The Hurd can't support 64-bit file systems");
3680 goto failed_mount; 3328 goto failed_mount;
@@ -3732,8 +3380,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
3732 } 3380 }
3733 } 3381 }
3734 3382
3735 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_ENCRYPT) && 3383 if (ext4_has_feature_encrypt(sb) && es->s_encryption_level) {
3736 es->s_encryption_level) {
3737 ext4_msg(sb, KERN_ERR, "Unsupported encryption level %d", 3384 ext4_msg(sb, KERN_ERR, "Unsupported encryption level %d",
3738 es->s_encryption_level); 3385 es->s_encryption_level);
3739 goto failed_mount; 3386 goto failed_mount;
@@ -3765,8 +3412,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
3765 } 3412 }
3766 } 3413 }
3767 3414
3768 has_huge_files = EXT4_HAS_RO_COMPAT_FEATURE(sb, 3415 has_huge_files = ext4_has_feature_huge_file(sb);
3769 EXT4_FEATURE_RO_COMPAT_HUGE_FILE);
3770 sbi->s_bitmap_maxbytes = ext4_max_bitmap_size(sb->s_blocksize_bits, 3416 sbi->s_bitmap_maxbytes = ext4_max_bitmap_size(sb->s_blocksize_bits,
3771 has_huge_files); 3417 has_huge_files);
3772 sb->s_maxbytes = ext4_max_size(sb->s_blocksize_bits, has_huge_files); 3418 sb->s_maxbytes = ext4_max_size(sb->s_blocksize_bits, has_huge_files);
@@ -3790,7 +3436,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
3790 } 3436 }
3791 3437
3792 sbi->s_desc_size = le16_to_cpu(es->s_desc_size); 3438 sbi->s_desc_size = le16_to_cpu(es->s_desc_size);
3793 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_64BIT)) { 3439 if (ext4_has_feature_64bit(sb)) {
3794 if (sbi->s_desc_size < EXT4_MIN_DESC_SIZE_64BIT || 3440 if (sbi->s_desc_size < EXT4_MIN_DESC_SIZE_64BIT ||
3795 sbi->s_desc_size > EXT4_MAX_DESC_SIZE || 3441 sbi->s_desc_size > EXT4_MAX_DESC_SIZE ||
3796 !is_power_of_2(sbi->s_desc_size)) { 3442 !is_power_of_2(sbi->s_desc_size)) {
@@ -3821,7 +3467,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
3821 for (i = 0; i < 4; i++) 3467 for (i = 0; i < 4; i++)
3822 sbi->s_hash_seed[i] = le32_to_cpu(es->s_hash_seed[i]); 3468 sbi->s_hash_seed[i] = le32_to_cpu(es->s_hash_seed[i]);
3823 sbi->s_def_hash_version = es->s_def_hash_version; 3469 sbi->s_def_hash_version = es->s_def_hash_version;
3824 if (EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_DIR_INDEX)) { 3470 if (ext4_has_feature_dir_index(sb)) {
3825 i = le32_to_cpu(es->s_flags); 3471 i = le32_to_cpu(es->s_flags);
3826 if (i & EXT2_FLAGS_UNSIGNED_HASH) 3472 if (i & EXT2_FLAGS_UNSIGNED_HASH)
3827 sbi->s_hash_unsigned = 3; 3473 sbi->s_hash_unsigned = 3;
@@ -3841,8 +3487,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
3841 3487
3842 /* Handle clustersize */ 3488 /* Handle clustersize */
3843 clustersize = BLOCK_SIZE << le32_to_cpu(es->s_log_cluster_size); 3489 clustersize = BLOCK_SIZE << le32_to_cpu(es->s_log_cluster_size);
3844 has_bigalloc = EXT4_HAS_RO_COMPAT_FEATURE(sb, 3490 has_bigalloc = ext4_has_feature_bigalloc(sb);
3845 EXT4_FEATURE_RO_COMPAT_BIGALLOC);
3846 if (has_bigalloc) { 3491 if (has_bigalloc) {
3847 if (clustersize < blocksize) { 3492 if (clustersize < blocksize) {
3848 ext4_msg(sb, KERN_ERR, 3493 ext4_msg(sb, KERN_ERR,
@@ -3961,13 +3606,6 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
3961 goto failed_mount; 3606 goto failed_mount;
3962 } 3607 }
3963 3608
3964 if (ext4_proc_root)
3965 sbi->s_proc = proc_mkdir(sb->s_id, ext4_proc_root);
3966
3967 if (sbi->s_proc)
3968 proc_create_data("options", S_IRUGO, sbi->s_proc,
3969 &ext4_seq_options_fops, sb);
3970
3971 bgl_lock_init(sbi->s_blockgroup_lock); 3609 bgl_lock_init(sbi->s_blockgroup_lock);
3972 3610
3973 for (i = 0; i < db_count; i++) { 3611 for (i = 0; i < db_count; i++) {
@@ -3982,6 +3620,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
3982 } 3620 }
3983 if (!ext4_check_descriptors(sb, &first_not_zeroed)) { 3621 if (!ext4_check_descriptors(sb, &first_not_zeroed)) {
3984 ext4_msg(sb, KERN_ERR, "group descriptors corrupted!"); 3622 ext4_msg(sb, KERN_ERR, "group descriptors corrupted!");
3623 ret = -EFSCORRUPTED;
3985 goto failed_mount2; 3624 goto failed_mount2;
3986 } 3625 }
3987 3626
@@ -4007,7 +3646,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
4007 sb->s_xattr = ext4_xattr_handlers; 3646 sb->s_xattr = ext4_xattr_handlers;
4008#ifdef CONFIG_QUOTA 3647#ifdef CONFIG_QUOTA
4009 sb->dq_op = &ext4_quota_operations; 3648 sb->dq_op = &ext4_quota_operations;
4010 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_QUOTA)) 3649 if (ext4_has_feature_quota(sb))
4011 sb->s_qcop = &dquot_quotactl_sysfile_ops; 3650 sb->s_qcop = &dquot_quotactl_sysfile_ops;
4012 else 3651 else
4013 sb->s_qcop = &ext4_qctl_operations; 3652 sb->s_qcop = &ext4_qctl_operations;
@@ -4021,11 +3660,9 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
4021 sb->s_root = NULL; 3660 sb->s_root = NULL;
4022 3661
4023 needs_recovery = (es->s_last_orphan != 0 || 3662 needs_recovery = (es->s_last_orphan != 0 ||
4024 EXT4_HAS_INCOMPAT_FEATURE(sb, 3663 ext4_has_feature_journal_needs_recovery(sb));
4025 EXT4_FEATURE_INCOMPAT_RECOVER));
4026 3664
4027 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_MMP) && 3665 if (ext4_has_feature_mmp(sb) && !(sb->s_flags & MS_RDONLY))
4028 !(sb->s_flags & MS_RDONLY))
4029 if (ext4_multi_mount_protect(sb, le64_to_cpu(es->s_mmp_block))) 3666 if (ext4_multi_mount_protect(sb, le64_to_cpu(es->s_mmp_block)))
4030 goto failed_mount3a; 3667 goto failed_mount3a;
4031 3668
@@ -4033,23 +3670,47 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
4033 * The first inode we look at is the journal inode. Don't try 3670 * The first inode we look at is the journal inode. Don't try
4034 * root first: it may be modified in the journal! 3671 * root first: it may be modified in the journal!
4035 */ 3672 */
4036 if (!test_opt(sb, NOLOAD) && 3673 if (!test_opt(sb, NOLOAD) && ext4_has_feature_journal(sb)) {
4037 EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_HAS_JOURNAL)) {
4038 if (ext4_load_journal(sb, es, journal_devnum)) 3674 if (ext4_load_journal(sb, es, journal_devnum))
4039 goto failed_mount3a; 3675 goto failed_mount3a;
4040 } else if (test_opt(sb, NOLOAD) && !(sb->s_flags & MS_RDONLY) && 3676 } else if (test_opt(sb, NOLOAD) && !(sb->s_flags & MS_RDONLY) &&
4041 EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER)) { 3677 ext4_has_feature_journal_needs_recovery(sb)) {
4042 ext4_msg(sb, KERN_ERR, "required journal recovery " 3678 ext4_msg(sb, KERN_ERR, "required journal recovery "
4043 "suppressed and not mounted read-only"); 3679 "suppressed and not mounted read-only");
4044 goto failed_mount_wq; 3680 goto failed_mount_wq;
4045 } else { 3681 } else {
3682 /* Nojournal mode, all journal mount options are illegal */
3683 if (test_opt2(sb, EXPLICIT_JOURNAL_CHECKSUM)) {
3684 ext4_msg(sb, KERN_ERR, "can't mount with "
3685 "journal_checksum, fs mounted w/o journal");
3686 goto failed_mount_wq;
3687 }
3688 if (test_opt(sb, JOURNAL_ASYNC_COMMIT)) {
3689 ext4_msg(sb, KERN_ERR, "can't mount with "
3690 "journal_async_commit, fs mounted w/o journal");
3691 goto failed_mount_wq;
3692 }
3693 if (sbi->s_commit_interval != JBD2_DEFAULT_MAX_COMMIT_AGE*HZ) {
3694 ext4_msg(sb, KERN_ERR, "can't mount with "
3695 "commit=%lu, fs mounted w/o journal",
3696 sbi->s_commit_interval / HZ);
3697 goto failed_mount_wq;
3698 }
3699 if (EXT4_MOUNT_DATA_FLAGS &
3700 (sbi->s_mount_opt ^ sbi->s_def_mount_opt)) {
3701 ext4_msg(sb, KERN_ERR, "can't mount with "
3702 "data=, fs mounted w/o journal");
3703 goto failed_mount_wq;
3704 }
3705 sbi->s_def_mount_opt &= EXT4_MOUNT_JOURNAL_CHECKSUM;
3706 clear_opt(sb, JOURNAL_CHECKSUM);
4046 clear_opt(sb, DATA_FLAGS); 3707 clear_opt(sb, DATA_FLAGS);
4047 sbi->s_journal = NULL; 3708 sbi->s_journal = NULL;
4048 needs_recovery = 0; 3709 needs_recovery = 0;
4049 goto no_journal; 3710 goto no_journal;
4050 } 3711 }
4051 3712
4052 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_64BIT) && 3713 if (ext4_has_feature_64bit(sb) &&
4053 !jbd2_journal_set_features(EXT4_SB(sb)->s_journal, 0, 0, 3714 !jbd2_journal_set_features(EXT4_SB(sb)->s_journal, 0, 0,
4054 JBD2_FEATURE_INCOMPAT_64BIT)) { 3715 JBD2_FEATURE_INCOMPAT_64BIT)) {
4055 ext4_msg(sb, KERN_ERR, "Failed to set 64-bit journal feature"); 3716 ext4_msg(sb, KERN_ERR, "Failed to set 64-bit journal feature");
@@ -4101,18 +3762,16 @@ no_journal:
4101 } 3762 }
4102 } 3763 }
4103 3764
4104 if ((DUMMY_ENCRYPTION_ENABLED(sbi) || 3765 if ((DUMMY_ENCRYPTION_ENABLED(sbi) || ext4_has_feature_encrypt(sb)) &&
4105 EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_ENCRYPT)) &&
4106 (blocksize != PAGE_CACHE_SIZE)) { 3766 (blocksize != PAGE_CACHE_SIZE)) {
4107 ext4_msg(sb, KERN_ERR, 3767 ext4_msg(sb, KERN_ERR,
4108 "Unsupported blocksize for fs encryption"); 3768 "Unsupported blocksize for fs encryption");
4109 goto failed_mount_wq; 3769 goto failed_mount_wq;
4110 } 3770 }
4111 3771
4112 if (DUMMY_ENCRYPTION_ENABLED(sbi) && 3772 if (DUMMY_ENCRYPTION_ENABLED(sbi) && !(sb->s_flags & MS_RDONLY) &&
4113 !(sb->s_flags & MS_RDONLY) && 3773 !ext4_has_feature_encrypt(sb)) {
4114 !EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_ENCRYPT)) { 3774 ext4_set_feature_encrypt(sb);
4115 EXT4_SET_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_ENCRYPT);
4116 ext4_commit_super(sb, 1); 3775 ext4_commit_super(sb, 1);
4117 } 3776 }
4118 3777
@@ -4171,8 +3830,7 @@ no_journal:
4171 if (sbi->s_inode_size > EXT4_GOOD_OLD_INODE_SIZE) { 3830 if (sbi->s_inode_size > EXT4_GOOD_OLD_INODE_SIZE) {
4172 sbi->s_want_extra_isize = sizeof(struct ext4_inode) - 3831 sbi->s_want_extra_isize = sizeof(struct ext4_inode) -
4173 EXT4_GOOD_OLD_INODE_SIZE; 3832 EXT4_GOOD_OLD_INODE_SIZE;
4174 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, 3833 if (ext4_has_feature_extra_isize(sb)) {
4175 EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE)) {
4176 if (sbi->s_want_extra_isize < 3834 if (sbi->s_want_extra_isize <
4177 le16_to_cpu(es->s_want_extra_isize)) 3835 le16_to_cpu(es->s_want_extra_isize))
4178 sbi->s_want_extra_isize = 3836 sbi->s_want_extra_isize =
@@ -4192,12 +3850,7 @@ no_journal:
4192 "available"); 3850 "available");
4193 } 3851 }
4194 3852
4195 err = ext4_reserve_clusters(sbi, ext4_calculate_resv_clusters(sb)); 3853 ext4_set_resv_clusters(sb);
4196 if (err) {
4197 ext4_msg(sb, KERN_ERR, "failed to reserve %llu clusters for "
4198 "reserved pool", ext4_calculate_resv_clusters(sb));
4199 goto failed_mount4a;
4200 }
4201 3854
4202 err = ext4_setup_system_zone(sb); 3855 err = ext4_setup_system_zone(sb);
4203 if (err) { 3856 if (err) {
@@ -4236,7 +3889,7 @@ no_journal:
4236 goto failed_mount6; 3889 goto failed_mount6;
4237 } 3890 }
4238 3891
4239 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG)) 3892 if (ext4_has_feature_flex_bg(sb))
4240 if (!ext4_fill_flex_info(sb)) { 3893 if (!ext4_fill_flex_info(sb)) {
4241 ext4_msg(sb, KERN_ERR, 3894 ext4_msg(sb, KERN_ERR,
4242 "unable to initialize " 3895 "unable to initialize "
@@ -4248,17 +3901,13 @@ no_journal:
4248 if (err) 3901 if (err)
4249 goto failed_mount6; 3902 goto failed_mount6;
4250 3903
4251 sbi->s_kobj.kset = ext4_kset; 3904 err = ext4_register_sysfs(sb);
4252 init_completion(&sbi->s_kobj_unregister);
4253 err = kobject_init_and_add(&sbi->s_kobj, &ext4_ktype, NULL,
4254 "%s", sb->s_id);
4255 if (err) 3905 if (err)
4256 goto failed_mount7; 3906 goto failed_mount7;
4257 3907
4258#ifdef CONFIG_QUOTA 3908#ifdef CONFIG_QUOTA
4259 /* Enable quota usage during mount. */ 3909 /* Enable quota usage during mount. */
4260 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_QUOTA) && 3910 if (ext4_has_feature_quota(sb) && !(sb->s_flags & MS_RDONLY)) {
4261 !(sb->s_flags & MS_RDONLY)) {
4262 err = ext4_enable_quotas(sb); 3911 err = ext4_enable_quotas(sb);
4263 if (err) 3912 if (err)
4264 goto failed_mount8; 3913 goto failed_mount8;
@@ -4313,7 +3962,7 @@ cantfind_ext4:
4313 3962
4314#ifdef CONFIG_QUOTA 3963#ifdef CONFIG_QUOTA
4315failed_mount8: 3964failed_mount8:
4316 kobject_del(&sbi->s_kobj); 3965 ext4_unregister_sysfs(sb);
4317#endif 3966#endif
4318failed_mount7: 3967failed_mount7:
4319 ext4_unregister_li_request(sb); 3968 ext4_unregister_li_request(sb);
@@ -4353,10 +4002,6 @@ failed_mount2:
4353failed_mount: 4002failed_mount:
4354 if (sbi->s_chksum_driver) 4003 if (sbi->s_chksum_driver)
4355 crypto_free_shash(sbi->s_chksum_driver); 4004 crypto_free_shash(sbi->s_chksum_driver);
4356 if (sbi->s_proc) {
4357 remove_proc_entry("options", sbi->s_proc);
4358 remove_proc_entry(sb->s_id, ext4_proc_root);
4359 }
4360#ifdef CONFIG_QUOTA 4005#ifdef CONFIG_QUOTA
4361 for (i = 0; i < EXT4_MAXQUOTAS; i++) 4006 for (i = 0; i < EXT4_MAXQUOTAS; i++)
4362 kfree(sbi->s_qf_names[i]); 4007 kfree(sbi->s_qf_names[i]);
@@ -4403,7 +4048,7 @@ static journal_t *ext4_get_journal(struct super_block *sb,
4403 struct inode *journal_inode; 4048 struct inode *journal_inode;
4404 journal_t *journal; 4049 journal_t *journal;
4405 4050
4406 BUG_ON(!EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_HAS_JOURNAL)); 4051 BUG_ON(!ext4_has_feature_journal(sb));
4407 4052
4408 /* First, test for the existence of a valid inode on disk. Bad 4053 /* First, test for the existence of a valid inode on disk. Bad
4409 * things happen if we iget() an unused inode, as the subsequent 4054 * things happen if we iget() an unused inode, as the subsequent
@@ -4453,7 +4098,7 @@ static journal_t *ext4_get_dev_journal(struct super_block *sb,
4453 struct ext4_super_block *es; 4098 struct ext4_super_block *es;
4454 struct block_device *bdev; 4099 struct block_device *bdev;
4455 4100
4456 BUG_ON(!EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_HAS_JOURNAL)); 4101 BUG_ON(!ext4_has_feature_journal(sb));
4457 4102
4458 bdev = ext4_blkdev_get(j_dev, sb); 4103 bdev = ext4_blkdev_get(j_dev, sb);
4459 if (bdev == NULL) 4104 if (bdev == NULL)
@@ -4545,7 +4190,7 @@ static int ext4_load_journal(struct super_block *sb,
4545 int err = 0; 4190 int err = 0;
4546 int really_read_only; 4191 int really_read_only;
4547 4192
4548 BUG_ON(!EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_HAS_JOURNAL)); 4193 BUG_ON(!ext4_has_feature_journal(sb));
4549 4194
4550 if (journal_devnum && 4195 if (journal_devnum &&
4551 journal_devnum != le32_to_cpu(es->s_journal_dev)) { 4196 journal_devnum != le32_to_cpu(es->s_journal_dev)) {
@@ -4562,7 +4207,7 @@ static int ext4_load_journal(struct super_block *sb,
4562 * crash? For recovery, we need to check in advance whether we 4207 * crash? For recovery, we need to check in advance whether we
4563 * can get read-write access to the device. 4208 * can get read-write access to the device.
4564 */ 4209 */
4565 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER)) { 4210 if (ext4_has_feature_journal_needs_recovery(sb)) {
4566 if (sb->s_flags & MS_RDONLY) { 4211 if (sb->s_flags & MS_RDONLY) {
4567 ext4_msg(sb, KERN_INFO, "INFO: recovery " 4212 ext4_msg(sb, KERN_INFO, "INFO: recovery "
4568 "required on readonly filesystem"); 4213 "required on readonly filesystem");
@@ -4593,7 +4238,7 @@ static int ext4_load_journal(struct super_block *sb,
4593 if (!(journal->j_flags & JBD2_BARRIER)) 4238 if (!(journal->j_flags & JBD2_BARRIER))
4594 ext4_msg(sb, KERN_INFO, "barriers disabled"); 4239 ext4_msg(sb, KERN_INFO, "barriers disabled");
4595 4240
4596 if (!EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER)) 4241 if (!ext4_has_feature_journal_needs_recovery(sb))
4597 err = jbd2_journal_wipe(journal, !really_read_only); 4242 err = jbd2_journal_wipe(journal, !really_read_only);
4598 if (!err) { 4243 if (!err) {
4599 char *save = kmalloc(EXT4_S_ERR_LEN, GFP_KERNEL); 4244 char *save = kmalloc(EXT4_S_ERR_LEN, GFP_KERNEL);
@@ -4707,7 +4352,7 @@ static void ext4_mark_recovery_complete(struct super_block *sb,
4707{ 4352{
4708 journal_t *journal = EXT4_SB(sb)->s_journal; 4353 journal_t *journal = EXT4_SB(sb)->s_journal;
4709 4354
4710 if (!EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_HAS_JOURNAL)) { 4355 if (!ext4_has_feature_journal(sb)) {
4711 BUG_ON(journal != NULL); 4356 BUG_ON(journal != NULL);
4712 return; 4357 return;
4713 } 4358 }
@@ -4715,9 +4360,9 @@ static void ext4_mark_recovery_complete(struct super_block *sb,
4715 if (jbd2_journal_flush(journal) < 0) 4360 if (jbd2_journal_flush(journal) < 0)
4716 goto out; 4361 goto out;
4717 4362
4718 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER) && 4363 if (ext4_has_feature_journal_needs_recovery(sb) &&
4719 sb->s_flags & MS_RDONLY) { 4364 sb->s_flags & MS_RDONLY) {
4720 EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER); 4365 ext4_clear_feature_journal_needs_recovery(sb);
4721 ext4_commit_super(sb, 1); 4366 ext4_commit_super(sb, 1);
4722 } 4367 }
4723 4368
@@ -4737,7 +4382,7 @@ static void ext4_clear_journal_err(struct super_block *sb,
4737 int j_errno; 4382 int j_errno;
4738 const char *errstr; 4383 const char *errstr;
4739 4384
4740 BUG_ON(!EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_HAS_JOURNAL)); 4385 BUG_ON(!ext4_has_feature_journal(sb));
4741 4386
4742 journal = EXT4_SB(sb)->s_journal; 4387 journal = EXT4_SB(sb)->s_journal;
4743 4388
@@ -4852,7 +4497,7 @@ static int ext4_freeze(struct super_block *sb)
4852 goto out; 4497 goto out;
4853 4498
4854 /* Journal blocked and flushed, clear needs_recovery flag. */ 4499 /* Journal blocked and flushed, clear needs_recovery flag. */
4855 EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER); 4500 ext4_clear_feature_journal_needs_recovery(sb);
4856 } 4501 }
4857 4502
4858 error = ext4_commit_super(sb, 1); 4503 error = ext4_commit_super(sb, 1);
@@ -4874,7 +4519,7 @@ static int ext4_unfreeze(struct super_block *sb)
4874 4519
4875 if (EXT4_SB(sb)->s_journal) { 4520 if (EXT4_SB(sb)->s_journal) {
4876 /* Reset the needs_recovery flag before the fs is unlocked. */ 4521 /* Reset the needs_recovery flag before the fs is unlocked. */
4877 EXT4_SET_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER); 4522 ext4_set_feature_journal_needs_recovery(sb);
4878 } 4523 }
4879 4524
4880 ext4_commit_super(sb, 1); 4525 ext4_commit_super(sb, 1);
@@ -5027,8 +4672,7 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data)
5027 ext4_mark_recovery_complete(sb, es); 4672 ext4_mark_recovery_complete(sb, es);
5028 } else { 4673 } else {
5029 /* Make sure we can mount this feature set readwrite */ 4674 /* Make sure we can mount this feature set readwrite */
5030 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, 4675 if (ext4_has_feature_readonly(sb) ||
5031 EXT4_FEATURE_RO_COMPAT_READONLY) ||
5032 !ext4_feature_set_ok(sb, 0)) { 4676 !ext4_feature_set_ok(sb, 0)) {
5033 err = -EROFS; 4677 err = -EROFS;
5034 goto restore_opts; 4678 goto restore_opts;
@@ -5044,9 +4688,9 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data)
5044 if (!ext4_group_desc_csum_verify(sb, g, gdp)) { 4688 if (!ext4_group_desc_csum_verify(sb, g, gdp)) {
5045 ext4_msg(sb, KERN_ERR, 4689 ext4_msg(sb, KERN_ERR,
5046 "ext4_remount: Checksum for group %u failed (%u!=%u)", 4690 "ext4_remount: Checksum for group %u failed (%u!=%u)",
5047 g, le16_to_cpu(ext4_group_desc_csum(sbi, g, gdp)), 4691 g, le16_to_cpu(ext4_group_desc_csum(sb, g, gdp)),
5048 le16_to_cpu(gdp->bg_checksum)); 4692 le16_to_cpu(gdp->bg_checksum));
5049 err = -EINVAL; 4693 err = -EFSBADCRC;
5050 goto restore_opts; 4694 goto restore_opts;
5051 } 4695 }
5052 } 4696 }
@@ -5076,8 +4720,7 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data)
5076 sbi->s_mount_state = le16_to_cpu(es->s_state); 4720 sbi->s_mount_state = le16_to_cpu(es->s_state);
5077 if (!ext4_setup_super(sb, es, 0)) 4721 if (!ext4_setup_super(sb, es, 0))
5078 sb->s_flags &= ~MS_RDONLY; 4722 sb->s_flags &= ~MS_RDONLY;
5079 if (EXT4_HAS_INCOMPAT_FEATURE(sb, 4723 if (ext4_has_feature_mmp(sb))
5080 EXT4_FEATURE_INCOMPAT_MMP))
5081 if (ext4_multi_mount_protect(sb, 4724 if (ext4_multi_mount_protect(sb,
5082 le64_to_cpu(es->s_mmp_block))) { 4725 le64_to_cpu(es->s_mmp_block))) {
5083 err = -EROFS; 4726 err = -EROFS;
@@ -5110,8 +4753,7 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data)
5110 if (enable_quota) { 4753 if (enable_quota) {
5111 if (sb_any_quota_suspended(sb)) 4754 if (sb_any_quota_suspended(sb))
5112 dquot_resume(sb, -1); 4755 dquot_resume(sb, -1);
5113 else if (EXT4_HAS_RO_COMPAT_FEATURE(sb, 4756 else if (ext4_has_feature_quota(sb)) {
5114 EXT4_FEATURE_RO_COMPAT_QUOTA)) {
5115 err = ext4_enable_quotas(sb); 4757 err = ext4_enable_quotas(sb);
5116 if (err) 4758 if (err)
5117 goto restore_opts; 4759 goto restore_opts;
@@ -5255,7 +4897,7 @@ static int ext4_mark_dquot_dirty(struct dquot *dquot)
5255 struct ext4_sb_info *sbi = EXT4_SB(sb); 4897 struct ext4_sb_info *sbi = EXT4_SB(sb);
5256 4898
5257 /* Are we journaling quotas? */ 4899 /* Are we journaling quotas? */
5258 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_QUOTA) || 4900 if (ext4_has_feature_quota(sb) ||
5259 sbi->s_qf_names[USRQUOTA] || sbi->s_qf_names[GRPQUOTA]) { 4901 sbi->s_qf_names[USRQUOTA] || sbi->s_qf_names[GRPQUOTA]) {
5260 dquot_mark_dquot_dirty(dquot); 4902 dquot_mark_dquot_dirty(dquot);
5261 return ext4_write_dquot(dquot); 4903 return ext4_write_dquot(dquot);
@@ -5343,7 +4985,7 @@ static int ext4_quota_enable(struct super_block *sb, int type, int format_id,
5343 le32_to_cpu(EXT4_SB(sb)->s_es->s_grp_quota_inum) 4985 le32_to_cpu(EXT4_SB(sb)->s_es->s_grp_quota_inum)
5344 }; 4986 };
5345 4987
5346 BUG_ON(!EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_QUOTA)); 4988 BUG_ON(!ext4_has_feature_quota(sb));
5347 4989
5348 if (!qf_inums[type]) 4990 if (!qf_inums[type])
5349 return -EPERM; 4991 return -EPERM;
@@ -5537,11 +5179,11 @@ static inline void unregister_as_ext2(void)
5537 5179
5538static inline int ext2_feature_set_ok(struct super_block *sb) 5180static inline int ext2_feature_set_ok(struct super_block *sb)
5539{ 5181{
5540 if (EXT4_HAS_INCOMPAT_FEATURE(sb, ~EXT2_FEATURE_INCOMPAT_SUPP)) 5182 if (ext4_has_unknown_ext2_incompat_features(sb))
5541 return 0; 5183 return 0;
5542 if (sb->s_flags & MS_RDONLY) 5184 if (sb->s_flags & MS_RDONLY)
5543 return 1; 5185 return 1;
5544 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, ~EXT2_FEATURE_RO_COMPAT_SUPP)) 5186 if (ext4_has_unknown_ext2_ro_compat_features(sb))
5545 return 0; 5187 return 0;
5546 return 1; 5188 return 1;
5547} 5189}
@@ -5566,13 +5208,13 @@ static inline void unregister_as_ext3(void)
5566 5208
5567static inline int ext3_feature_set_ok(struct super_block *sb) 5209static inline int ext3_feature_set_ok(struct super_block *sb)
5568{ 5210{
5569 if (EXT4_HAS_INCOMPAT_FEATURE(sb, ~EXT3_FEATURE_INCOMPAT_SUPP)) 5211 if (ext4_has_unknown_ext3_incompat_features(sb))
5570 return 0; 5212 return 0;
5571 if (!EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_HAS_JOURNAL)) 5213 if (!ext4_has_feature_journal(sb))
5572 return 0; 5214 return 0;
5573 if (sb->s_flags & MS_RDONLY) 5215 if (sb->s_flags & MS_RDONLY)
5574 return 1; 5216 return 1;
5575 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, ~EXT3_FEATURE_RO_COMPAT_SUPP)) 5217 if (ext4_has_unknown_ext3_ro_compat_features(sb))
5576 return 0; 5218 return 0;
5577 return 1; 5219 return 1;
5578} 5220}
@@ -5586,37 +5228,6 @@ static struct file_system_type ext4_fs_type = {
5586}; 5228};
5587MODULE_ALIAS_FS("ext4"); 5229MODULE_ALIAS_FS("ext4");
5588 5230
5589static int __init ext4_init_feat_adverts(void)
5590{
5591 struct ext4_features *ef;
5592 int ret = -ENOMEM;
5593
5594 ef = kzalloc(sizeof(struct ext4_features), GFP_KERNEL);
5595 if (!ef)
5596 goto out;
5597
5598 ef->f_kobj.kset = ext4_kset;
5599 init_completion(&ef->f_kobj_unregister);
5600 ret = kobject_init_and_add(&ef->f_kobj, &ext4_feat_ktype, NULL,
5601 "features");
5602 if (ret) {
5603 kfree(ef);
5604 goto out;
5605 }
5606
5607 ext4_feat = ef;
5608 ret = 0;
5609out:
5610 return ret;
5611}
5612
5613static void ext4_exit_feat_adverts(void)
5614{
5615 kobject_put(&ext4_feat->f_kobj);
5616 wait_for_completion(&ext4_feat->f_kobj_unregister);
5617 kfree(ext4_feat);
5618}
5619
5620/* Shared across all ext4 file systems */ 5231/* Shared across all ext4 file systems */
5621wait_queue_head_t ext4__ioend_wq[EXT4_WQ_HASH_SZ]; 5232wait_queue_head_t ext4__ioend_wq[EXT4_WQ_HASH_SZ];
5622struct mutex ext4__aio_mutex[EXT4_WQ_HASH_SZ]; 5233struct mutex ext4__aio_mutex[EXT4_WQ_HASH_SZ];
@@ -5643,21 +5254,15 @@ static int __init ext4_init_fs(void)
5643 5254
5644 err = ext4_init_pageio(); 5255 err = ext4_init_pageio();
5645 if (err) 5256 if (err)
5646 goto out7; 5257 goto out5;
5647 5258
5648 err = ext4_init_system_zone(); 5259 err = ext4_init_system_zone();
5649 if (err) 5260 if (err)
5650 goto out6; 5261 goto out4;
5651 ext4_kset = kset_create_and_add("ext4", NULL, fs_kobj);
5652 if (!ext4_kset) {
5653 err = -ENOMEM;
5654 goto out5;
5655 }
5656 ext4_proc_root = proc_mkdir("fs/ext4", NULL);
5657 5262
5658 err = ext4_init_feat_adverts(); 5263 err = ext4_init_sysfs();
5659 if (err) 5264 if (err)
5660 goto out4; 5265 goto out3;
5661 5266
5662 err = ext4_init_mballoc(); 5267 err = ext4_init_mballoc();
5663 if (err) 5268 if (err)
@@ -5682,16 +5287,12 @@ out1:
5682 ext4_mballoc_ready = 0; 5287 ext4_mballoc_ready = 0;
5683 ext4_exit_mballoc(); 5288 ext4_exit_mballoc();
5684out2: 5289out2:
5685 ext4_exit_feat_adverts(); 5290 ext4_exit_sysfs();
5686out4: 5291out3:
5687 if (ext4_proc_root)
5688 remove_proc_entry("fs/ext4", NULL);
5689 kset_unregister(ext4_kset);
5690out5:
5691 ext4_exit_system_zone(); 5292 ext4_exit_system_zone();
5692out6: 5293out4:
5693 ext4_exit_pageio(); 5294 ext4_exit_pageio();
5694out7: 5295out5:
5695 ext4_exit_es(); 5296 ext4_exit_es();
5696 5297
5697 return err; 5298 return err;
@@ -5706,9 +5307,7 @@ static void __exit ext4_exit_fs(void)
5706 unregister_filesystem(&ext4_fs_type); 5307 unregister_filesystem(&ext4_fs_type);
5707 destroy_inodecache(); 5308 destroy_inodecache();
5708 ext4_exit_mballoc(); 5309 ext4_exit_mballoc();
5709 ext4_exit_feat_adverts(); 5310 ext4_exit_sysfs();
5710 remove_proc_entry("fs/ext4", NULL);
5711 kset_unregister(ext4_kset);
5712 ext4_exit_system_zone(); 5311 ext4_exit_system_zone();
5713 ext4_exit_pageio(); 5312 ext4_exit_pageio();
5714 ext4_exit_es(); 5313 ext4_exit_es();
diff --git a/fs/ext4/symlink.c b/fs/ext4/symlink.c
index c677f2c1044b..abe2401ce405 100644
--- a/fs/ext4/symlink.c
+++ b/fs/ext4/symlink.c
@@ -57,7 +57,7 @@ static const char *ext4_encrypted_follow_link(struct dentry *dentry, void **cook
57 sizeof(struct ext4_encrypted_symlink_data) - 1) > 57 sizeof(struct ext4_encrypted_symlink_data) - 1) >
58 max_size) { 58 max_size) {
59 /* Symlink data on the disk is corrupted */ 59 /* Symlink data on the disk is corrupted */
60 res = -EIO; 60 res = -EFSCORRUPTED;
61 goto errout; 61 goto errout;
62 } 62 }
63 plen = (cstr.len < EXT4_FNAME_CRYPTO_DIGEST_SIZE*2) ? 63 plen = (cstr.len < EXT4_FNAME_CRYPTO_DIGEST_SIZE*2) ?
diff --git a/fs/ext4/sysfs.c b/fs/ext4/sysfs.c
new file mode 100644
index 000000000000..1b57c72f4a00
--- /dev/null
+++ b/fs/ext4/sysfs.c
@@ -0,0 +1,448 @@
1/*
2 * linux/fs/ext4/sysfs.c
3 *
4 * Copyright (C) 1992, 1993, 1994, 1995
5 * Remy Card (card@masi.ibp.fr)
6 * Theodore Ts'o (tytso@mit.edu)
7 *
8 */
9
10#include <linux/time.h>
11#include <linux/fs.h>
12#include <linux/seq_file.h>
13#include <linux/proc_fs.h>
14
15#include "ext4.h"
16#include "ext4_jbd2.h"
17
18typedef enum {
19 attr_noop,
20 attr_delayed_allocation_blocks,
21 attr_session_write_kbytes,
22 attr_lifetime_write_kbytes,
23 attr_reserved_clusters,
24 attr_inode_readahead,
25 attr_trigger_test_error,
26 attr_feature,
27 attr_pointer_ui,
28 attr_pointer_atomic,
29} attr_id_t;
30
31typedef enum {
32 ptr_explicit,
33 ptr_ext4_sb_info_offset,
34 ptr_ext4_super_block_offset,
35} attr_ptr_t;
36
37static const char *proc_dirname = "fs/ext4";
38static struct proc_dir_entry *ext4_proc_root;
39
40struct ext4_attr {
41 struct attribute attr;
42 short attr_id;
43 short attr_ptr;
44 union {
45 int offset;
46 void *explicit_ptr;
47 } u;
48};
49
50static ssize_t session_write_kbytes_show(struct ext4_attr *a,
51 struct ext4_sb_info *sbi, char *buf)
52{
53 struct super_block *sb = sbi->s_buddy_cache->i_sb;
54
55 if (!sb->s_bdev->bd_part)
56 return snprintf(buf, PAGE_SIZE, "0\n");
57 return snprintf(buf, PAGE_SIZE, "%lu\n",
58 (part_stat_read(sb->s_bdev->bd_part, sectors[1]) -
59 sbi->s_sectors_written_start) >> 1);
60}
61
62static ssize_t lifetime_write_kbytes_show(struct ext4_attr *a,
63 struct ext4_sb_info *sbi, char *buf)
64{
65 struct super_block *sb = sbi->s_buddy_cache->i_sb;
66
67 if (!sb->s_bdev->bd_part)
68 return snprintf(buf, PAGE_SIZE, "0\n");
69 return snprintf(buf, PAGE_SIZE, "%llu\n",
70 (unsigned long long)(sbi->s_kbytes_written +
71 ((part_stat_read(sb->s_bdev->bd_part, sectors[1]) -
72 EXT4_SB(sb)->s_sectors_written_start) >> 1)));
73}
74
75static ssize_t inode_readahead_blks_store(struct ext4_attr *a,
76 struct ext4_sb_info *sbi,
77 const char *buf, size_t count)
78{
79 unsigned long t;
80 int ret;
81
82 ret = kstrtoul(skip_spaces(buf), 0, &t);
83 if (ret)
84 return ret;
85
86 if (t && (!is_power_of_2(t) || t > 0x40000000))
87 return -EINVAL;
88
89 sbi->s_inode_readahead_blks = t;
90 return count;
91}
92
93static ssize_t reserved_clusters_store(struct ext4_attr *a,
94 struct ext4_sb_info *sbi,
95 const char *buf, size_t count)
96{
97 unsigned long long val;
98 ext4_fsblk_t clusters = (ext4_blocks_count(sbi->s_es) >>
99 sbi->s_cluster_bits);
100 int ret;
101
102 ret = kstrtoull(skip_spaces(buf), 0, &val);
103 if (!ret || val >= clusters)
104 return -EINVAL;
105
106 atomic64_set(&sbi->s_resv_clusters, val);
107 return count;
108}
109
110static ssize_t trigger_test_error(struct ext4_attr *a,
111 struct ext4_sb_info *sbi,
112 const char *buf, size_t count)
113{
114 int len = count;
115
116 if (!capable(CAP_SYS_ADMIN))
117 return -EPERM;
118
119 if (len && buf[len-1] == '\n')
120 len--;
121
122 if (len)
123 ext4_error(sbi->s_sb, "%.*s", len, buf);
124 return count;
125}
126
127#define EXT4_ATTR(_name,_mode,_id) \
128static struct ext4_attr ext4_attr_##_name = { \
129 .attr = {.name = __stringify(_name), .mode = _mode }, \
130 .attr_id = attr_##_id, \
131}
132
133#define EXT4_ATTR_FUNC(_name,_mode) EXT4_ATTR(_name,_mode,_name)
134
135#define EXT4_ATTR_FEATURE(_name) EXT4_ATTR(_name, 0444, feature)
136
137#define EXT4_ATTR_OFFSET(_name,_mode,_id,_struct,_elname) \
138static struct ext4_attr ext4_attr_##_name = { \
139 .attr = {.name = __stringify(_name), .mode = _mode }, \
140 .attr_id = attr_##_id, \
141 .attr_ptr = ptr_##_struct##_offset, \
142 .u = { \
143 .offset = offsetof(struct _struct, _elname),\
144 }, \
145}
146
147#define EXT4_RO_ATTR_ES_UI(_name,_elname) \
148 EXT4_ATTR_OFFSET(_name, 0444, pointer_ui, ext4_super_block, _elname)
149
150#define EXT4_RW_ATTR_SBI_UI(_name,_elname) \
151 EXT4_ATTR_OFFSET(_name, 0644, pointer_ui, ext4_sb_info, _elname)
152
153#define EXT4_ATTR_PTR(_name,_mode,_id,_ptr) \
154static struct ext4_attr ext4_attr_##_name = { \
155 .attr = {.name = __stringify(_name), .mode = _mode }, \
156 .attr_id = attr_##_id, \
157 .attr_ptr = ptr_explicit, \
158 .u = { \
159 .explicit_ptr = _ptr, \
160 }, \
161}
162
163#define ATTR_LIST(name) &ext4_attr_##name.attr
164
165EXT4_ATTR_FUNC(delayed_allocation_blocks, 0444);
166EXT4_ATTR_FUNC(session_write_kbytes, 0444);
167EXT4_ATTR_FUNC(lifetime_write_kbytes, 0444);
168EXT4_ATTR_FUNC(reserved_clusters, 0644);
169
170EXT4_ATTR_OFFSET(inode_readahead_blks, 0644, inode_readahead,
171 ext4_sb_info, s_inode_readahead_blks);
172EXT4_RW_ATTR_SBI_UI(inode_goal, s_inode_goal);
173EXT4_RW_ATTR_SBI_UI(mb_stats, s_mb_stats);
174EXT4_RW_ATTR_SBI_UI(mb_max_to_scan, s_mb_max_to_scan);
175EXT4_RW_ATTR_SBI_UI(mb_min_to_scan, s_mb_min_to_scan);
176EXT4_RW_ATTR_SBI_UI(mb_order2_req, s_mb_order2_reqs);
177EXT4_RW_ATTR_SBI_UI(mb_stream_req, s_mb_stream_request);
178EXT4_RW_ATTR_SBI_UI(mb_group_prealloc, s_mb_group_prealloc);
179EXT4_RW_ATTR_SBI_UI(extent_max_zeroout_kb, s_extent_max_zeroout_kb);
180EXT4_ATTR(trigger_fs_error, 0200, trigger_test_error);
181EXT4_RW_ATTR_SBI_UI(err_ratelimit_interval_ms, s_err_ratelimit_state.interval);
182EXT4_RW_ATTR_SBI_UI(err_ratelimit_burst, s_err_ratelimit_state.burst);
183EXT4_RW_ATTR_SBI_UI(warning_ratelimit_interval_ms, s_warning_ratelimit_state.interval);
184EXT4_RW_ATTR_SBI_UI(warning_ratelimit_burst, s_warning_ratelimit_state.burst);
185EXT4_RW_ATTR_SBI_UI(msg_ratelimit_interval_ms, s_msg_ratelimit_state.interval);
186EXT4_RW_ATTR_SBI_UI(msg_ratelimit_burst, s_msg_ratelimit_state.burst);
187EXT4_RO_ATTR_ES_UI(errors_count, s_error_count);
188EXT4_RO_ATTR_ES_UI(first_error_time, s_first_error_time);
189EXT4_RO_ATTR_ES_UI(last_error_time, s_last_error_time);
190
191static unsigned int old_bump_val = 128;
192EXT4_ATTR_PTR(max_writeback_mb_bump, 0444, pointer_ui, &old_bump_val);
193
194static struct attribute *ext4_attrs[] = {
195 ATTR_LIST(delayed_allocation_blocks),
196 ATTR_LIST(session_write_kbytes),
197 ATTR_LIST(lifetime_write_kbytes),
198 ATTR_LIST(reserved_clusters),
199 ATTR_LIST(inode_readahead_blks),
200 ATTR_LIST(inode_goal),
201 ATTR_LIST(mb_stats),
202 ATTR_LIST(mb_max_to_scan),
203 ATTR_LIST(mb_min_to_scan),
204 ATTR_LIST(mb_order2_req),
205 ATTR_LIST(mb_stream_req),
206 ATTR_LIST(mb_group_prealloc),
207 ATTR_LIST(max_writeback_mb_bump),
208 ATTR_LIST(extent_max_zeroout_kb),
209 ATTR_LIST(trigger_fs_error),
210 ATTR_LIST(err_ratelimit_interval_ms),
211 ATTR_LIST(err_ratelimit_burst),
212 ATTR_LIST(warning_ratelimit_interval_ms),
213 ATTR_LIST(warning_ratelimit_burst),
214 ATTR_LIST(msg_ratelimit_interval_ms),
215 ATTR_LIST(msg_ratelimit_burst),
216 ATTR_LIST(errors_count),
217 ATTR_LIST(first_error_time),
218 ATTR_LIST(last_error_time),
219 NULL,
220};
221
222/* Features this copy of ext4 supports */
223EXT4_ATTR_FEATURE(lazy_itable_init);
224EXT4_ATTR_FEATURE(batched_discard);
225EXT4_ATTR_FEATURE(meta_bg_resize);
226EXT4_ATTR_FEATURE(encryption);
227EXT4_ATTR_FEATURE(metadata_csum_seed);
228
229static struct attribute *ext4_feat_attrs[] = {
230 ATTR_LIST(lazy_itable_init),
231 ATTR_LIST(batched_discard),
232 ATTR_LIST(meta_bg_resize),
233 ATTR_LIST(encryption),
234 ATTR_LIST(metadata_csum_seed),
235 NULL,
236};
237
238static void *calc_ptr(struct ext4_attr *a, struct ext4_sb_info *sbi)
239{
240 switch (a->attr_ptr) {
241 case ptr_explicit:
242 return a->u.explicit_ptr;
243 case ptr_ext4_sb_info_offset:
244 return (void *) (((char *) sbi) + a->u.offset);
245 case ptr_ext4_super_block_offset:
246 return (void *) (((char *) sbi->s_es) + a->u.offset);
247 }
248 return NULL;
249}
250
251static ssize_t ext4_attr_show(struct kobject *kobj,
252 struct attribute *attr, char *buf)
253{
254 struct ext4_sb_info *sbi = container_of(kobj, struct ext4_sb_info,
255 s_kobj);
256 struct ext4_attr *a = container_of(attr, struct ext4_attr, attr);
257 void *ptr = calc_ptr(a, sbi);
258
259 switch (a->attr_id) {
260 case attr_delayed_allocation_blocks:
261 return snprintf(buf, PAGE_SIZE, "%llu\n",
262 (s64) EXT4_C2B(sbi,
263 percpu_counter_sum(&sbi->s_dirtyclusters_counter)));
264 case attr_session_write_kbytes:
265 return session_write_kbytes_show(a, sbi, buf);
266 case attr_lifetime_write_kbytes:
267 return lifetime_write_kbytes_show(a, sbi, buf);
268 case attr_reserved_clusters:
269 return snprintf(buf, PAGE_SIZE, "%llu\n",
270 (unsigned long long)
271 atomic64_read(&sbi->s_resv_clusters));
272 case attr_inode_readahead:
273 case attr_pointer_ui:
274 if (!ptr)
275 return 0;
276 return snprintf(buf, PAGE_SIZE, "%u\n",
277 *((unsigned int *) ptr));
278 case attr_pointer_atomic:
279 if (!ptr)
280 return 0;
281 return snprintf(buf, PAGE_SIZE, "%d\n",
282 atomic_read((atomic_t *) ptr));
283 case attr_feature:
284 return snprintf(buf, PAGE_SIZE, "supported\n");
285 }
286
287 return 0;
288}
289
290static ssize_t ext4_attr_store(struct kobject *kobj,
291 struct attribute *attr,
292 const char *buf, size_t len)
293{
294 struct ext4_sb_info *sbi = container_of(kobj, struct ext4_sb_info,
295 s_kobj);
296 struct ext4_attr *a = container_of(attr, struct ext4_attr, attr);
297 void *ptr = calc_ptr(a, sbi);
298 unsigned long t;
299 int ret;
300
301 switch (a->attr_id) {
302 case attr_reserved_clusters:
303 return reserved_clusters_store(a, sbi, buf, len);
304 case attr_pointer_ui:
305 if (!ptr)
306 return 0;
307 ret = kstrtoul(skip_spaces(buf), 0, &t);
308 if (ret)
309 return ret;
310 *((unsigned int *) ptr) = t;
311 return len;
312 case attr_inode_readahead:
313 return inode_readahead_blks_store(a, sbi, buf, len);
314 case attr_trigger_test_error:
315 return trigger_test_error(a, sbi, buf, len);
316 }
317 return 0;
318}
319
320static void ext4_sb_release(struct kobject *kobj)
321{
322 struct ext4_sb_info *sbi = container_of(kobj, struct ext4_sb_info,
323 s_kobj);
324 complete(&sbi->s_kobj_unregister);
325}
326
327static const struct sysfs_ops ext4_attr_ops = {
328 .show = ext4_attr_show,
329 .store = ext4_attr_store,
330};
331
332static struct kobj_type ext4_sb_ktype = {
333 .default_attrs = ext4_attrs,
334 .sysfs_ops = &ext4_attr_ops,
335 .release = ext4_sb_release,
336};
337
338static struct kobj_type ext4_ktype = {
339 .sysfs_ops = &ext4_attr_ops,
340};
341
342static struct kset ext4_kset = {
343 .kobj = {.ktype = &ext4_ktype},
344};
345
346static struct kobj_type ext4_feat_ktype = {
347 .default_attrs = ext4_feat_attrs,
348 .sysfs_ops = &ext4_attr_ops,
349};
350
351static struct kobject ext4_feat = {
352 .kset = &ext4_kset,
353};
354
355#define PROC_FILE_SHOW_DEFN(name) \
356static int name##_open(struct inode *inode, struct file *file) \
357{ \
358 return single_open(file, ext4_seq_##name##_show, PDE_DATA(inode)); \
359} \
360\
361const struct file_operations ext4_seq_##name##_fops = { \
362 .owner = THIS_MODULE, \
363 .open = name##_open, \
364 .read = seq_read, \
365 .llseek = seq_lseek, \
366 .release = single_release, \
367}
368
369#define PROC_FILE_LIST(name) \
370 { __stringify(name), &ext4_seq_##name##_fops }
371
372PROC_FILE_SHOW_DEFN(es_shrinker_info);
373PROC_FILE_SHOW_DEFN(options);
374
375static struct ext4_proc_files {
376 const char *name;
377 const struct file_operations *fops;
378} proc_files[] = {
379 PROC_FILE_LIST(options),
380 PROC_FILE_LIST(es_shrinker_info),
381 PROC_FILE_LIST(mb_groups),
382 { NULL, NULL },
383};
384
385int ext4_register_sysfs(struct super_block *sb)
386{
387 struct ext4_sb_info *sbi = EXT4_SB(sb);
388 struct ext4_proc_files *p;
389 int err;
390
391 sbi->s_kobj.kset = &ext4_kset;
392 init_completion(&sbi->s_kobj_unregister);
393 err = kobject_init_and_add(&sbi->s_kobj, &ext4_sb_ktype, NULL,
394 "%s", sb->s_id);
395 if (err)
396 return err;
397
398 if (ext4_proc_root)
399 sbi->s_proc = proc_mkdir(sb->s_id, ext4_proc_root);
400
401 if (sbi->s_proc) {
402 for (p = proc_files; p->name; p++)
403 proc_create_data(p->name, S_IRUGO, sbi->s_proc,
404 p->fops, sb);
405 }
406 return 0;
407}
408
409void ext4_unregister_sysfs(struct super_block *sb)
410{
411 struct ext4_sb_info *sbi = EXT4_SB(sb);
412 struct ext4_proc_files *p;
413
414 if (sbi->s_proc) {
415 for (p = proc_files; p->name; p++)
416 remove_proc_entry(p->name, sbi->s_proc);
417 remove_proc_entry(sb->s_id, ext4_proc_root);
418 }
419 kobject_del(&sbi->s_kobj);
420}
421
422int __init ext4_init_sysfs(void)
423{
424 int ret;
425
426 kobject_set_name(&ext4_kset.kobj, "ext4");
427 ext4_kset.kobj.parent = fs_kobj;
428 ret = kset_register(&ext4_kset);
429 if (ret)
430 return ret;
431
432 ret = kobject_init_and_add(&ext4_feat, &ext4_feat_ktype,
433 NULL, "features");
434 if (ret)
435 kset_unregister(&ext4_kset);
436 else
437 ext4_proc_root = proc_mkdir(proc_dirname, NULL);
438 return ret;
439}
440
441void ext4_exit_sysfs(void)
442{
443 kobject_put(&ext4_feat);
444 kset_unregister(&ext4_kset);
445 remove_proc_entry(proc_dirname, NULL);
446 ext4_proc_root = NULL;
447}
448
diff --git a/fs/ext4/xattr.c b/fs/ext4/xattr.c
index 16e28c08d1e8..984448c6f5f0 100644
--- a/fs/ext4/xattr.c
+++ b/fs/ext4/xattr.c
@@ -195,7 +195,7 @@ ext4_xattr_check_names(struct ext4_xattr_entry *entry, void *end,
195 while (!IS_LAST_ENTRY(e)) { 195 while (!IS_LAST_ENTRY(e)) {
196 struct ext4_xattr_entry *next = EXT4_XATTR_NEXT(e); 196 struct ext4_xattr_entry *next = EXT4_XATTR_NEXT(e);
197 if ((void *)next >= end) 197 if ((void *)next >= end)
198 return -EIO; 198 return -EFSCORRUPTED;
199 e = next; 199 e = next;
200 } 200 }
201 201
@@ -205,7 +205,7 @@ ext4_xattr_check_names(struct ext4_xattr_entry *entry, void *end,
205 (void *)e + sizeof(__u32) || 205 (void *)e + sizeof(__u32) ||
206 value_start + le16_to_cpu(entry->e_value_offs) + 206 value_start + le16_to_cpu(entry->e_value_offs) +
207 le32_to_cpu(entry->e_value_size) > end)) 207 le32_to_cpu(entry->e_value_size) > end))
208 return -EIO; 208 return -EFSCORRUPTED;
209 entry = EXT4_XATTR_NEXT(entry); 209 entry = EXT4_XATTR_NEXT(entry);
210 } 210 }
211 211
@@ -222,9 +222,9 @@ ext4_xattr_check_block(struct inode *inode, struct buffer_head *bh)
222 222
223 if (BHDR(bh)->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC) || 223 if (BHDR(bh)->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC) ||
224 BHDR(bh)->h_blocks != cpu_to_le32(1)) 224 BHDR(bh)->h_blocks != cpu_to_le32(1))
225 return -EIO; 225 return -EFSCORRUPTED;
226 if (!ext4_xattr_block_csum_verify(inode, bh->b_blocknr, BHDR(bh))) 226 if (!ext4_xattr_block_csum_verify(inode, bh->b_blocknr, BHDR(bh)))
227 return -EIO; 227 return -EFSBADCRC;
228 error = ext4_xattr_check_names(BFIRST(bh), bh->b_data + bh->b_size, 228 error = ext4_xattr_check_names(BFIRST(bh), bh->b_data + bh->b_size,
229 bh->b_data); 229 bh->b_data);
230 if (!error) 230 if (!error)
@@ -239,7 +239,7 @@ ext4_xattr_check_entry(struct ext4_xattr_entry *entry, size_t size)
239 239
240 if (entry->e_value_block != 0 || value_size > size || 240 if (entry->e_value_block != 0 || value_size > size ||
241 le16_to_cpu(entry->e_value_offs) + value_size > size) 241 le16_to_cpu(entry->e_value_offs) + value_size > size)
242 return -EIO; 242 return -EFSCORRUPTED;
243 return 0; 243 return 0;
244} 244}
245 245
@@ -266,7 +266,7 @@ ext4_xattr_find_entry(struct ext4_xattr_entry **pentry, int name_index,
266 } 266 }
267 *pentry = entry; 267 *pentry = entry;
268 if (!cmp && ext4_xattr_check_entry(entry, size)) 268 if (!cmp && ext4_xattr_check_entry(entry, size))
269 return -EIO; 269 return -EFSCORRUPTED;
270 return cmp ? -ENODATA : 0; 270 return cmp ? -ENODATA : 0;
271} 271}
272 272
@@ -297,13 +297,13 @@ ext4_xattr_block_get(struct inode *inode, int name_index, const char *name,
297bad_block: 297bad_block:
298 EXT4_ERROR_INODE(inode, "bad block %llu", 298 EXT4_ERROR_INODE(inode, "bad block %llu",
299 EXT4_I(inode)->i_file_acl); 299 EXT4_I(inode)->i_file_acl);
300 error = -EIO; 300 error = -EFSCORRUPTED;
301 goto cleanup; 301 goto cleanup;
302 } 302 }
303 ext4_xattr_cache_insert(ext4_mb_cache, bh); 303 ext4_xattr_cache_insert(ext4_mb_cache, bh);
304 entry = BFIRST(bh); 304 entry = BFIRST(bh);
305 error = ext4_xattr_find_entry(&entry, name_index, name, bh->b_size, 1); 305 error = ext4_xattr_find_entry(&entry, name_index, name, bh->b_size, 1);
306 if (error == -EIO) 306 if (error == -EFSCORRUPTED)
307 goto bad_block; 307 goto bad_block;
308 if (error) 308 if (error)
309 goto cleanup; 309 goto cleanup;
@@ -445,7 +445,7 @@ ext4_xattr_block_list(struct dentry *dentry, char *buffer, size_t buffer_size)
445 if (ext4_xattr_check_block(inode, bh)) { 445 if (ext4_xattr_check_block(inode, bh)) {
446 EXT4_ERROR_INODE(inode, "bad block %llu", 446 EXT4_ERROR_INODE(inode, "bad block %llu",
447 EXT4_I(inode)->i_file_acl); 447 EXT4_I(inode)->i_file_acl);
448 error = -EIO; 448 error = -EFSCORRUPTED;
449 goto cleanup; 449 goto cleanup;
450 } 450 }
451 ext4_xattr_cache_insert(ext4_mb_cache, bh); 451 ext4_xattr_cache_insert(ext4_mb_cache, bh);
@@ -525,12 +525,12 @@ errout:
525static void ext4_xattr_update_super_block(handle_t *handle, 525static void ext4_xattr_update_super_block(handle_t *handle,
526 struct super_block *sb) 526 struct super_block *sb)
527{ 527{
528 if (EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_EXT_ATTR)) 528 if (ext4_has_feature_xattr(sb))
529 return; 529 return;
530 530
531 BUFFER_TRACE(EXT4_SB(sb)->s_sbh, "get_write_access"); 531 BUFFER_TRACE(EXT4_SB(sb)->s_sbh, "get_write_access");
532 if (ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh) == 0) { 532 if (ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh) == 0) {
533 EXT4_SET_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_EXT_ATTR); 533 ext4_set_feature_xattr(sb);
534 ext4_handle_dirty_super(handle, sb); 534 ext4_handle_dirty_super(handle, sb);
535 } 535 }
536} 536}
@@ -751,7 +751,7 @@ ext4_xattr_block_find(struct inode *inode, struct ext4_xattr_info *i,
751 if (ext4_xattr_check_block(inode, bs->bh)) { 751 if (ext4_xattr_check_block(inode, bs->bh)) {
752 EXT4_ERROR_INODE(inode, "bad block %llu", 752 EXT4_ERROR_INODE(inode, "bad block %llu",
753 EXT4_I(inode)->i_file_acl); 753 EXT4_I(inode)->i_file_acl);
754 error = -EIO; 754 error = -EFSCORRUPTED;
755 goto cleanup; 755 goto cleanup;
756 } 756 }
757 /* Find the named attribute. */ 757 /* Find the named attribute. */
@@ -811,7 +811,7 @@ ext4_xattr_block_set(handle_t *handle, struct inode *inode,
811 bs->bh); 811 bs->bh);
812 } 812 }
813 unlock_buffer(bs->bh); 813 unlock_buffer(bs->bh);
814 if (error == -EIO) 814 if (error == -EFSCORRUPTED)
815 goto bad_block; 815 goto bad_block;
816 if (!error) 816 if (!error)
817 error = ext4_handle_dirty_xattr_block(handle, 817 error = ext4_handle_dirty_xattr_block(handle,
@@ -855,7 +855,7 @@ ext4_xattr_block_set(handle_t *handle, struct inode *inode,
855 } 855 }
856 856
857 error = ext4_xattr_set_entry(i, s); 857 error = ext4_xattr_set_entry(i, s);
858 if (error == -EIO) 858 if (error == -EFSCORRUPTED)
859 goto bad_block; 859 goto bad_block;
860 if (error) 860 if (error)
861 goto cleanup; 861 goto cleanup;
@@ -1314,7 +1314,7 @@ retry:
1314 if (ext4_xattr_check_block(inode, bh)) { 1314 if (ext4_xattr_check_block(inode, bh)) {
1315 EXT4_ERROR_INODE(inode, "bad block %llu", 1315 EXT4_ERROR_INODE(inode, "bad block %llu",
1316 EXT4_I(inode)->i_file_acl); 1316 EXT4_I(inode)->i_file_acl);
1317 error = -EIO; 1317 error = -EFSCORRUPTED;
1318 goto cleanup; 1318 goto cleanup;
1319 } 1319 }
1320 base = BHDR(bh); 1320 base = BHDR(bh);
@@ -1579,7 +1579,7 @@ ext4_xattr_cmp(struct ext4_xattr_header *header1,
1579 memcmp(entry1->e_name, entry2->e_name, entry1->e_name_len)) 1579 memcmp(entry1->e_name, entry2->e_name, entry1->e_name_len))
1580 return 1; 1580 return 1;
1581 if (entry1->e_value_block != 0 || entry2->e_value_block != 0) 1581 if (entry1->e_value_block != 0 || entry2->e_value_block != 0)
1582 return -EIO; 1582 return -EFSCORRUPTED;
1583 if (memcmp((char *)header1 + le16_to_cpu(entry1->e_value_offs), 1583 if (memcmp((char *)header1 + le16_to_cpu(entry1->e_value_offs),
1584 (char *)header2 + le16_to_cpu(entry2->e_value_offs), 1584 (char *)header2 + le16_to_cpu(entry2->e_value_offs),
1585 le32_to_cpu(entry1->e_value_size))) 1585 le32_to_cpu(entry1->e_value_size)))
diff --git a/fs/jbd2/checkpoint.c b/fs/jbd2/checkpoint.c
index 8c44654ce274..684996c8a3a4 100644
--- a/fs/jbd2/checkpoint.c
+++ b/fs/jbd2/checkpoint.c
@@ -427,7 +427,6 @@ static int journal_clean_one_cp_list(struct journal_head *jh, bool destroy)
427 struct journal_head *last_jh; 427 struct journal_head *last_jh;
428 struct journal_head *next_jh = jh; 428 struct journal_head *next_jh = jh;
429 int ret; 429 int ret;
430 int freed = 0;
431 430
432 if (!jh) 431 if (!jh)
433 return 0; 432 return 0;
@@ -441,10 +440,9 @@ static int journal_clean_one_cp_list(struct journal_head *jh, bool destroy)
441 else 440 else
442 ret = __jbd2_journal_remove_checkpoint(jh) + 1; 441 ret = __jbd2_journal_remove_checkpoint(jh) + 1;
443 if (!ret) 442 if (!ret)
444 return freed; 443 return 0;
445 if (ret == 2) 444 if (ret == 2)
446 return 1; 445 return 1;
447 freed = 1;
448 /* 446 /*
449 * This function only frees up some memory 447 * This function only frees up some memory
450 * if possible so we dont have an obligation 448 * if possible so we dont have an obligation
@@ -452,10 +450,10 @@ static int journal_clean_one_cp_list(struct journal_head *jh, bool destroy)
452 * requested: 450 * requested:
453 */ 451 */
454 if (need_resched()) 452 if (need_resched())
455 return freed; 453 return 0;
456 } while (jh != last_jh); 454 } while (jh != last_jh);
457 455
458 return freed; 456 return 0;
459} 457}
460 458
461/* 459/*
diff --git a/fs/jbd2/commit.c b/fs/jbd2/commit.c
index 362e5f614450..36345fefa3ff 100644
--- a/fs/jbd2/commit.c
+++ b/fs/jbd2/commit.c
@@ -142,8 +142,7 @@ static int journal_submit_commit_record(journal_t *journal,
142 tmp->h_commit_sec = cpu_to_be64(now.tv_sec); 142 tmp->h_commit_sec = cpu_to_be64(now.tv_sec);
143 tmp->h_commit_nsec = cpu_to_be32(now.tv_nsec); 143 tmp->h_commit_nsec = cpu_to_be32(now.tv_nsec);
144 144
145 if (JBD2_HAS_COMPAT_FEATURE(journal, 145 if (jbd2_has_feature_checksum(journal)) {
146 JBD2_FEATURE_COMPAT_CHECKSUM)) {
147 tmp->h_chksum_type = JBD2_CRC32_CHKSUM; 146 tmp->h_chksum_type = JBD2_CRC32_CHKSUM;
148 tmp->h_chksum_size = JBD2_CRC32_CHKSUM_SIZE; 147 tmp->h_chksum_size = JBD2_CRC32_CHKSUM_SIZE;
149 tmp->h_chksum[0] = cpu_to_be32(crc32_sum); 148 tmp->h_chksum[0] = cpu_to_be32(crc32_sum);
@@ -157,8 +156,7 @@ static int journal_submit_commit_record(journal_t *journal,
157 bh->b_end_io = journal_end_buffer_io_sync; 156 bh->b_end_io = journal_end_buffer_io_sync;
158 157
159 if (journal->j_flags & JBD2_BARRIER && 158 if (journal->j_flags & JBD2_BARRIER &&
160 !JBD2_HAS_INCOMPAT_FEATURE(journal, 159 !jbd2_has_feature_async_commit(journal))
161 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT))
162 ret = submit_bh(WRITE_SYNC | WRITE_FLUSH_FUA, bh); 160 ret = submit_bh(WRITE_SYNC | WRITE_FLUSH_FUA, bh);
163 else 161 else
164 ret = submit_bh(WRITE_SYNC, bh); 162 ret = submit_bh(WRITE_SYNC, bh);
@@ -317,7 +315,7 @@ static void write_tag_block(journal_t *j, journal_block_tag_t *tag,
317 unsigned long long block) 315 unsigned long long block)
318{ 316{
319 tag->t_blocknr = cpu_to_be32(block & (u32)~0); 317 tag->t_blocknr = cpu_to_be32(block & (u32)~0);
320 if (JBD2_HAS_INCOMPAT_FEATURE(j, JBD2_FEATURE_INCOMPAT_64BIT)) 318 if (jbd2_has_feature_64bit(j))
321 tag->t_blocknr_high = cpu_to_be32((block >> 31) >> 1); 319 tag->t_blocknr_high = cpu_to_be32((block >> 31) >> 1);
322} 320}
323 321
@@ -356,7 +354,7 @@ static void jbd2_block_tag_csum_set(journal_t *j, journal_block_tag_t *tag,
356 bh->b_size); 354 bh->b_size);
357 kunmap_atomic(addr); 355 kunmap_atomic(addr);
358 356
359 if (JBD2_HAS_INCOMPAT_FEATURE(j, JBD2_FEATURE_INCOMPAT_CSUM_V3)) 357 if (jbd2_has_feature_csum3(j))
360 tag3->t_checksum = cpu_to_be32(csum32); 358 tag3->t_checksum = cpu_to_be32(csum32);
361 else 359 else
362 tag->t_checksum = cpu_to_be16(csum32); 360 tag->t_checksum = cpu_to_be16(csum32);
@@ -730,8 +728,7 @@ start_journal_io:
730 /* 728 /*
731 * Compute checksum. 729 * Compute checksum.
732 */ 730 */
733 if (JBD2_HAS_COMPAT_FEATURE(journal, 731 if (jbd2_has_feature_checksum(journal)) {
734 JBD2_FEATURE_COMPAT_CHECKSUM)) {
735 crc32_sum = 732 crc32_sum =
736 jbd2_checksum_data(crc32_sum, bh); 733 jbd2_checksum_data(crc32_sum, bh);
737 } 734 }
@@ -797,8 +794,7 @@ start_journal_io:
797 blkdev_issue_flush(journal->j_fs_dev, GFP_NOFS, NULL); 794 blkdev_issue_flush(journal->j_fs_dev, GFP_NOFS, NULL);
798 795
799 /* Done it all: now write the commit record asynchronously. */ 796 /* Done it all: now write the commit record asynchronously. */
800 if (JBD2_HAS_INCOMPAT_FEATURE(journal, 797 if (jbd2_has_feature_async_commit(journal)) {
801 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) {
802 err = journal_submit_commit_record(journal, commit_transaction, 798 err = journal_submit_commit_record(journal, commit_transaction,
803 &cbh, crc32_sum); 799 &cbh, crc32_sum);
804 if (err) 800 if (err)
@@ -889,8 +885,7 @@ start_journal_io:
889 commit_transaction->t_state = T_COMMIT_JFLUSH; 885 commit_transaction->t_state = T_COMMIT_JFLUSH;
890 write_unlock(&journal->j_state_lock); 886 write_unlock(&journal->j_state_lock);
891 887
892 if (!JBD2_HAS_INCOMPAT_FEATURE(journal, 888 if (!jbd2_has_feature_async_commit(journal)) {
893 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) {
894 err = journal_submit_commit_record(journal, commit_transaction, 889 err = journal_submit_commit_record(journal, commit_transaction,
895 &cbh, crc32_sum); 890 &cbh, crc32_sum);
896 if (err) 891 if (err)
@@ -898,8 +893,7 @@ start_journal_io:
898 } 893 }
899 if (cbh) 894 if (cbh)
900 err = journal_wait_on_commit_record(journal, cbh); 895 err = journal_wait_on_commit_record(journal, cbh);
901 if (JBD2_HAS_INCOMPAT_FEATURE(journal, 896 if (jbd2_has_feature_async_commit(journal) &&
902 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT) &&
903 journal->j_flags & JBD2_BARRIER) { 897 journal->j_flags & JBD2_BARRIER) {
904 blkdev_issue_flush(journal->j_dev, GFP_NOFS, NULL); 898 blkdev_issue_flush(journal->j_dev, GFP_NOFS, NULL);
905 } 899 }
diff --git a/fs/jbd2/journal.c b/fs/jbd2/journal.c
index 8270fe9e3641..81e622681c82 100644
--- a/fs/jbd2/journal.c
+++ b/fs/jbd2/journal.c
@@ -124,7 +124,7 @@ EXPORT_SYMBOL(__jbd2_debug);
124/* Checksumming functions */ 124/* Checksumming functions */
125static int jbd2_verify_csum_type(journal_t *j, journal_superblock_t *sb) 125static int jbd2_verify_csum_type(journal_t *j, journal_superblock_t *sb)
126{ 126{
127 if (!jbd2_journal_has_csum_v2or3(j)) 127 if (!jbd2_journal_has_csum_v2or3_feature(j))
128 return 1; 128 return 1;
129 129
130 return sb->s_checksum_type == JBD2_CRC32C_CHKSUM; 130 return sb->s_checksum_type == JBD2_CRC32C_CHKSUM;
@@ -1523,16 +1523,16 @@ static int journal_get_superblock(journal_t *journal)
1523 goto out; 1523 goto out;
1524 } 1524 }
1525 1525
1526 if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_CSUM_V2) && 1526 if (jbd2_has_feature_csum2(journal) &&
1527 JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_CSUM_V3)) { 1527 jbd2_has_feature_csum3(journal)) {
1528 /* Can't have checksum v2 and v3 at the same time! */ 1528 /* Can't have checksum v2 and v3 at the same time! */
1529 printk(KERN_ERR "JBD2: Can't enable checksumming v2 and v3 " 1529 printk(KERN_ERR "JBD2: Can't enable checksumming v2 and v3 "
1530 "at the same time!\n"); 1530 "at the same time!\n");
1531 goto out; 1531 goto out;
1532 } 1532 }
1533 1533
1534 if (jbd2_journal_has_csum_v2or3(journal) && 1534 if (jbd2_journal_has_csum_v2or3_feature(journal) &&
1535 JBD2_HAS_COMPAT_FEATURE(journal, JBD2_FEATURE_COMPAT_CHECKSUM)) { 1535 jbd2_has_feature_checksum(journal)) {
1536 /* Can't have checksum v1 and v2 on at the same time! */ 1536 /* Can't have checksum v1 and v2 on at the same time! */
1537 printk(KERN_ERR "JBD2: Can't enable checksumming v1 and v2/3 " 1537 printk(KERN_ERR "JBD2: Can't enable checksumming v1 and v2/3 "
1538 "at the same time!\n"); 1538 "at the same time!\n");
@@ -1545,7 +1545,7 @@ static int journal_get_superblock(journal_t *journal)
1545 } 1545 }
1546 1546
1547 /* Load the checksum driver */ 1547 /* Load the checksum driver */
1548 if (jbd2_journal_has_csum_v2or3(journal)) { 1548 if (jbd2_journal_has_csum_v2or3_feature(journal)) {
1549 journal->j_chksum_driver = crypto_alloc_shash("crc32c", 0, 0); 1549 journal->j_chksum_driver = crypto_alloc_shash("crc32c", 0, 0);
1550 if (IS_ERR(journal->j_chksum_driver)) { 1550 if (IS_ERR(journal->j_chksum_driver)) {
1551 printk(KERN_ERR "JBD2: Cannot load crc32c driver.\n"); 1551 printk(KERN_ERR "JBD2: Cannot load crc32c driver.\n");
@@ -1558,6 +1558,7 @@ static int journal_get_superblock(journal_t *journal)
1558 /* Check superblock checksum */ 1558 /* Check superblock checksum */
1559 if (!jbd2_superblock_csum_verify(journal, sb)) { 1559 if (!jbd2_superblock_csum_verify(journal, sb)) {
1560 printk(KERN_ERR "JBD2: journal checksum error\n"); 1560 printk(KERN_ERR "JBD2: journal checksum error\n");
1561 err = -EFSBADCRC;
1561 goto out; 1562 goto out;
1562 } 1563 }
1563 1564
@@ -1649,7 +1650,7 @@ int jbd2_journal_load(journal_t *journal)
1649 printk(KERN_ERR "JBD2: journal transaction %u on %s " 1650 printk(KERN_ERR "JBD2: journal transaction %u on %s "
1650 "is corrupt.\n", journal->j_failed_commit, 1651 "is corrupt.\n", journal->j_failed_commit,
1651 journal->j_devname); 1652 journal->j_devname);
1652 return -EIO; 1653 return -EFSCORRUPTED;
1653 } 1654 }
1654 1655
1655 /* OK, we've finished with the dynamic journal bits: 1656 /* OK, we've finished with the dynamic journal bits:
@@ -2071,8 +2072,12 @@ static void __journal_abort_soft (journal_t *journal, int errno)
2071 2072
2072 __jbd2_journal_abort_hard(journal); 2073 __jbd2_journal_abort_hard(journal);
2073 2074
2074 if (errno) 2075 if (errno) {
2075 jbd2_journal_update_sb_errno(journal); 2076 jbd2_journal_update_sb_errno(journal);
2077 write_lock(&journal->j_state_lock);
2078 journal->j_flags |= JBD2_REC_ERR;
2079 write_unlock(&journal->j_state_lock);
2080 }
2076} 2081}
2077 2082
2078/** 2083/**
@@ -2197,15 +2202,15 @@ size_t journal_tag_bytes(journal_t *journal)
2197{ 2202{
2198 size_t sz; 2203 size_t sz;
2199 2204
2200 if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_CSUM_V3)) 2205 if (jbd2_has_feature_csum3(journal))
2201 return sizeof(journal_block_tag3_t); 2206 return sizeof(journal_block_tag3_t);
2202 2207
2203 sz = sizeof(journal_block_tag_t); 2208 sz = sizeof(journal_block_tag_t);
2204 2209
2205 if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_CSUM_V2)) 2210 if (jbd2_has_feature_csum2(journal))
2206 sz += sizeof(__u16); 2211 sz += sizeof(__u16);
2207 2212
2208 if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_64BIT)) 2213 if (jbd2_has_feature_64bit(journal))
2209 return sz; 2214 return sz;
2210 else 2215 else
2211 return sz - sizeof(__u32); 2216 return sz - sizeof(__u32);
diff --git a/fs/jbd2/recovery.c b/fs/jbd2/recovery.c
index a9079d035ae5..7f277e49fe88 100644
--- a/fs/jbd2/recovery.c
+++ b/fs/jbd2/recovery.c
@@ -140,7 +140,7 @@ static int jread(struct buffer_head **bhp, journal_t *journal,
140 140
141 if (offset >= journal->j_maxlen) { 141 if (offset >= journal->j_maxlen) {
142 printk(KERN_ERR "JBD2: corrupted journal superblock\n"); 142 printk(KERN_ERR "JBD2: corrupted journal superblock\n");
143 return -EIO; 143 return -EFSCORRUPTED;
144 } 144 }
145 145
146 err = jbd2_journal_bmap(journal, offset, &blocknr); 146 err = jbd2_journal_bmap(journal, offset, &blocknr);
@@ -342,7 +342,7 @@ static inline unsigned long long read_tag_block(journal_t *journal,
342 journal_block_tag_t *tag) 342 journal_block_tag_t *tag)
343{ 343{
344 unsigned long long block = be32_to_cpu(tag->t_blocknr); 344 unsigned long long block = be32_to_cpu(tag->t_blocknr);
345 if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_64BIT)) 345 if (jbd2_has_feature_64bit(journal))
346 block |= (u64)be32_to_cpu(tag->t_blocknr_high) << 32; 346 block |= (u64)be32_to_cpu(tag->t_blocknr_high) << 32;
347 return block; 347 return block;
348} 348}
@@ -411,7 +411,7 @@ static int jbd2_block_tag_csum_verify(journal_t *j, journal_block_tag_t *tag,
411 csum32 = jbd2_chksum(j, j->j_csum_seed, (__u8 *)&seq, sizeof(seq)); 411 csum32 = jbd2_chksum(j, j->j_csum_seed, (__u8 *)&seq, sizeof(seq));
412 csum32 = jbd2_chksum(j, csum32, buf, j->j_blocksize); 412 csum32 = jbd2_chksum(j, csum32, buf, j->j_blocksize);
413 413
414 if (JBD2_HAS_INCOMPAT_FEATURE(j, JBD2_FEATURE_INCOMPAT_CSUM_V3)) 414 if (jbd2_has_feature_csum3(j))
415 return tag3->t_checksum == cpu_to_be32(csum32); 415 return tag3->t_checksum == cpu_to_be32(csum32);
416 else 416 else
417 return tag->t_checksum == cpu_to_be16(csum32); 417 return tag->t_checksum == cpu_to_be16(csum32);
@@ -527,7 +527,7 @@ static int do_one_pass(journal_t *journal,
527 printk(KERN_ERR "JBD2: Invalid checksum " 527 printk(KERN_ERR "JBD2: Invalid checksum "
528 "recovering block %lu in log\n", 528 "recovering block %lu in log\n",
529 next_log_block); 529 next_log_block);
530 err = -EIO; 530 err = -EFSBADCRC;
531 brelse(bh); 531 brelse(bh);
532 goto failed; 532 goto failed;
533 } 533 }
@@ -538,8 +538,7 @@ static int do_one_pass(journal_t *journal,
538 * just skip over the blocks it describes. */ 538 * just skip over the blocks it describes. */
539 if (pass != PASS_REPLAY) { 539 if (pass != PASS_REPLAY) {
540 if (pass == PASS_SCAN && 540 if (pass == PASS_SCAN &&
541 JBD2_HAS_COMPAT_FEATURE(journal, 541 jbd2_has_feature_checksum(journal) &&
542 JBD2_FEATURE_COMPAT_CHECKSUM) &&
543 !info->end_transaction) { 542 !info->end_transaction) {
544 if (calc_chksums(journal, bh, 543 if (calc_chksums(journal, bh,
545 &next_log_block, 544 &next_log_block,
@@ -602,7 +601,7 @@ static int do_one_pass(journal_t *journal,
602 journal, tag, obh->b_data, 601 journal, tag, obh->b_data,
603 be32_to_cpu(tmp->h_sequence))) { 602 be32_to_cpu(tmp->h_sequence))) {
604 brelse(obh); 603 brelse(obh);
605 success = -EIO; 604 success = -EFSBADCRC;
606 printk(KERN_ERR "JBD2: Invalid " 605 printk(KERN_ERR "JBD2: Invalid "
607 "checksum recovering " 606 "checksum recovering "
608 "block %llu in log\n", 607 "block %llu in log\n",
@@ -694,8 +693,7 @@ static int do_one_pass(journal_t *journal,
694 * much to do other than move on to the next sequence 693 * much to do other than move on to the next sequence
695 * number. */ 694 * number. */
696 if (pass == PASS_SCAN && 695 if (pass == PASS_SCAN &&
697 JBD2_HAS_COMPAT_FEATURE(journal, 696 jbd2_has_feature_checksum(journal)) {
698 JBD2_FEATURE_COMPAT_CHECKSUM)) {
699 int chksum_err, chksum_seen; 697 int chksum_err, chksum_seen;
700 struct commit_header *cbh = 698 struct commit_header *cbh =
701 (struct commit_header *)bh->b_data; 699 (struct commit_header *)bh->b_data;
@@ -735,8 +733,7 @@ static int do_one_pass(journal_t *journal,
735 if (chksum_err) { 733 if (chksum_err) {
736 info->end_transaction = next_commit_ID; 734 info->end_transaction = next_commit_ID;
737 735
738 if (!JBD2_HAS_INCOMPAT_FEATURE(journal, 736 if (!jbd2_has_feature_async_commit(journal)) {
739 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)){
740 journal->j_failed_commit = 737 journal->j_failed_commit =
741 next_commit_ID; 738 next_commit_ID;
742 brelse(bh); 739 brelse(bh);
@@ -750,8 +747,7 @@ static int do_one_pass(journal_t *journal,
750 bh->b_data)) { 747 bh->b_data)) {
751 info->end_transaction = next_commit_ID; 748 info->end_transaction = next_commit_ID;
752 749
753 if (!JBD2_HAS_INCOMPAT_FEATURE(journal, 750 if (!jbd2_has_feature_async_commit(journal)) {
754 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)) {
755 journal->j_failed_commit = 751 journal->j_failed_commit =
756 next_commit_ID; 752 next_commit_ID;
757 brelse(bh); 753 brelse(bh);
@@ -851,7 +847,7 @@ static int scan_revoke_records(journal_t *journal, struct buffer_head *bh,
851 rcount = be32_to_cpu(header->r_count); 847 rcount = be32_to_cpu(header->r_count);
852 848
853 if (!jbd2_revoke_block_csum_verify(journal, header)) 849 if (!jbd2_revoke_block_csum_verify(journal, header))
854 return -EINVAL; 850 return -EFSBADCRC;
855 851
856 if (jbd2_journal_has_csum_v2or3(journal)) 852 if (jbd2_journal_has_csum_v2or3(journal))
857 csum_size = sizeof(struct jbd2_journal_revoke_tail); 853 csum_size = sizeof(struct jbd2_journal_revoke_tail);
@@ -859,7 +855,7 @@ static int scan_revoke_records(journal_t *journal, struct buffer_head *bh,
859 return -EINVAL; 855 return -EINVAL;
860 max = rcount; 856 max = rcount;
861 857
862 if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_64BIT)) 858 if (jbd2_has_feature_64bit(journal))
863 record_len = 8; 859 record_len = 8;
864 860
865 while (offset + record_len <= max) { 861 while (offset + record_len <= max) {
diff --git a/fs/jbd2/revoke.c b/fs/jbd2/revoke.c
index 0abf2e7f725b..705ae577882b 100644
--- a/fs/jbd2/revoke.c
+++ b/fs/jbd2/revoke.c
@@ -589,7 +589,7 @@ static void write_one_revoke_record(journal_t *journal,
589 if (jbd2_journal_has_csum_v2or3(journal)) 589 if (jbd2_journal_has_csum_v2or3(journal))
590 csum_size = sizeof(struct jbd2_journal_revoke_tail); 590 csum_size = sizeof(struct jbd2_journal_revoke_tail);
591 591
592 if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_64BIT)) 592 if (jbd2_has_feature_64bit(journal))
593 sz = 8; 593 sz = 8;
594 else 594 else
595 sz = 4; 595 sz = 4;
@@ -619,7 +619,7 @@ static void write_one_revoke_record(journal_t *journal,
619 *descriptorp = descriptor; 619 *descriptorp = descriptor;
620 } 620 }
621 621
622 if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_64BIT)) 622 if (jbd2_has_feature_64bit(journal))
623 * ((__be64 *)(&descriptor->b_data[offset])) = 623 * ((__be64 *)(&descriptor->b_data[offset])) =
624 cpu_to_be64(record->blocknr); 624 cpu_to_be64(record->blocknr);
625 else 625 else
diff --git a/include/linux/jbd2.h b/include/linux/jbd2.h
index df07e78487d5..65407f6c9120 100644
--- a/include/linux/jbd2.h
+++ b/include/linux/jbd2.h
@@ -278,6 +278,7 @@ typedef struct journal_superblock_s
278/* 0x0400 */ 278/* 0x0400 */
279} journal_superblock_t; 279} journal_superblock_t;
280 280
281/* Use the jbd2_{has,set,clear}_feature_* helpers; these will be removed */
281#define JBD2_HAS_COMPAT_FEATURE(j,mask) \ 282#define JBD2_HAS_COMPAT_FEATURE(j,mask) \
282 ((j)->j_format_version >= 2 && \ 283 ((j)->j_format_version >= 2 && \
283 ((j)->j_superblock->s_feature_compat & cpu_to_be32((mask)))) 284 ((j)->j_superblock->s_feature_compat & cpu_to_be32((mask))))
@@ -288,7 +289,7 @@ typedef struct journal_superblock_s
288 ((j)->j_format_version >= 2 && \ 289 ((j)->j_format_version >= 2 && \
289 ((j)->j_superblock->s_feature_incompat & cpu_to_be32((mask)))) 290 ((j)->j_superblock->s_feature_incompat & cpu_to_be32((mask))))
290 291
291#define JBD2_FEATURE_COMPAT_CHECKSUM 0x00000001 292#define JBD2_FEATURE_COMPAT_CHECKSUM 0x00000001
292 293
293#define JBD2_FEATURE_INCOMPAT_REVOKE 0x00000001 294#define JBD2_FEATURE_INCOMPAT_REVOKE 0x00000001
294#define JBD2_FEATURE_INCOMPAT_64BIT 0x00000002 295#define JBD2_FEATURE_INCOMPAT_64BIT 0x00000002
@@ -296,6 +297,8 @@ typedef struct journal_superblock_s
296#define JBD2_FEATURE_INCOMPAT_CSUM_V2 0x00000008 297#define JBD2_FEATURE_INCOMPAT_CSUM_V2 0x00000008
297#define JBD2_FEATURE_INCOMPAT_CSUM_V3 0x00000010 298#define JBD2_FEATURE_INCOMPAT_CSUM_V3 0x00000010
298 299
300/* See "journal feature predicate functions" below */
301
299/* Features known to this kernel version: */ 302/* Features known to this kernel version: */
300#define JBD2_KNOWN_COMPAT_FEATURES JBD2_FEATURE_COMPAT_CHECKSUM 303#define JBD2_KNOWN_COMPAT_FEATURES JBD2_FEATURE_COMPAT_CHECKSUM
301#define JBD2_KNOWN_ROCOMPAT_FEATURES 0 304#define JBD2_KNOWN_ROCOMPAT_FEATURES 0
@@ -1034,6 +1037,69 @@ struct journal_s
1034 __u32 j_csum_seed; 1037 __u32 j_csum_seed;
1035}; 1038};
1036 1039
1040/* journal feature predicate functions */
1041#define JBD2_FEATURE_COMPAT_FUNCS(name, flagname) \
1042static inline bool jbd2_has_feature_##name(journal_t *j) \
1043{ \
1044 return ((j)->j_format_version >= 2 && \
1045 ((j)->j_superblock->s_feature_compat & \
1046 cpu_to_be32(JBD2_FEATURE_COMPAT_##flagname)) != 0); \
1047} \
1048static inline void jbd2_set_feature_##name(journal_t *j) \
1049{ \
1050 (j)->j_superblock->s_feature_compat |= \
1051 cpu_to_be32(JBD2_FEATURE_COMPAT_##flagname); \
1052} \
1053static inline void jbd2_clear_feature_##name(journal_t *j) \
1054{ \
1055 (j)->j_superblock->s_feature_compat &= \
1056 ~cpu_to_be32(JBD2_FEATURE_COMPAT_##flagname); \
1057}
1058
1059#define JBD2_FEATURE_RO_COMPAT_FUNCS(name, flagname) \
1060static inline bool jbd2_has_feature_##name(journal_t *j) \
1061{ \
1062 return ((j)->j_format_version >= 2 && \
1063 ((j)->j_superblock->s_feature_ro_compat & \
1064 cpu_to_be32(JBD2_FEATURE_RO_COMPAT_##flagname)) != 0); \
1065} \
1066static inline void jbd2_set_feature_##name(journal_t *j) \
1067{ \
1068 (j)->j_superblock->s_feature_ro_compat |= \
1069 cpu_to_be32(JBD2_FEATURE_RO_COMPAT_##flagname); \
1070} \
1071static inline void jbd2_clear_feature_##name(journal_t *j) \
1072{ \
1073 (j)->j_superblock->s_feature_ro_compat &= \
1074 ~cpu_to_be32(JBD2_FEATURE_RO_COMPAT_##flagname); \
1075}
1076
1077#define JBD2_FEATURE_INCOMPAT_FUNCS(name, flagname) \
1078static inline bool jbd2_has_feature_##name(journal_t *j) \
1079{ \
1080 return ((j)->j_format_version >= 2 && \
1081 ((j)->j_superblock->s_feature_incompat & \
1082 cpu_to_be32(JBD2_FEATURE_INCOMPAT_##flagname)) != 0); \
1083} \
1084static inline void jbd2_set_feature_##name(journal_t *j) \
1085{ \
1086 (j)->j_superblock->s_feature_incompat |= \
1087 cpu_to_be32(JBD2_FEATURE_INCOMPAT_##flagname); \
1088} \
1089static inline void jbd2_clear_feature_##name(journal_t *j) \
1090{ \
1091 (j)->j_superblock->s_feature_incompat &= \
1092 ~cpu_to_be32(JBD2_FEATURE_INCOMPAT_##flagname); \
1093}
1094
1095JBD2_FEATURE_COMPAT_FUNCS(checksum, CHECKSUM)
1096
1097JBD2_FEATURE_INCOMPAT_FUNCS(revoke, REVOKE)
1098JBD2_FEATURE_INCOMPAT_FUNCS(64bit, 64BIT)
1099JBD2_FEATURE_INCOMPAT_FUNCS(async_commit, ASYNC_COMMIT)
1100JBD2_FEATURE_INCOMPAT_FUNCS(csum2, CSUM_V2)
1101JBD2_FEATURE_INCOMPAT_FUNCS(csum3, CSUM_V3)
1102
1037/* 1103/*
1038 * Journal flag definitions 1104 * Journal flag definitions
1039 */ 1105 */
@@ -1046,6 +1112,7 @@ struct journal_s
1046#define JBD2_ABORT_ON_SYNCDATA_ERR 0x040 /* Abort the journal on file 1112#define JBD2_ABORT_ON_SYNCDATA_ERR 0x040 /* Abort the journal on file
1047 * data write error in ordered 1113 * data write error in ordered
1048 * mode */ 1114 * mode */
1115#define JBD2_REC_ERR 0x080 /* The errno in the sb has been recorded */
1049 1116
1050/* 1117/*
1051 * Function declarations for the journaling transaction and buffer 1118 * Function declarations for the journaling transaction and buffer
@@ -1338,13 +1405,17 @@ static inline int tid_geq(tid_t x, tid_t y)
1338extern int jbd2_journal_blocks_per_page(struct inode *inode); 1405extern int jbd2_journal_blocks_per_page(struct inode *inode);
1339extern size_t journal_tag_bytes(journal_t *journal); 1406extern size_t journal_tag_bytes(journal_t *journal);
1340 1407
1408static inline bool jbd2_journal_has_csum_v2or3_feature(journal_t *j)
1409{
1410 return jbd2_has_feature_csum2(j) || jbd2_has_feature_csum3(j);
1411}
1412
1341static inline int jbd2_journal_has_csum_v2or3(journal_t *journal) 1413static inline int jbd2_journal_has_csum_v2or3(journal_t *journal)
1342{ 1414{
1343 if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_CSUM_V2) || 1415 WARN_ON_ONCE(jbd2_journal_has_csum_v2or3_feature(journal) &&
1344 JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_CSUM_V3)) 1416 journal->j_chksum_driver == NULL);
1345 return 1;
1346 1417
1347 return 0; 1418 return journal->j_chksum_driver != NULL;
1348} 1419}
1349 1420
1350/* 1421/*
@@ -1444,4 +1515,7 @@ static inline tid_t jbd2_get_latest_transaction(journal_t *journal)
1444 1515
1445#endif /* __KERNEL__ */ 1516#endif /* __KERNEL__ */
1446 1517
1518#define EFSBADCRC EBADMSG /* Bad CRC detected */
1519#define EFSCORRUPTED EUCLEAN /* Filesystem is corrupted */
1520
1447#endif /* _LINUX_JBD2_H */ 1521#endif /* _LINUX_JBD2_H */
diff --git a/include/uapi/linux/fs.h b/include/uapi/linux/fs.h
index 9b964a5920af..f15d980249b5 100644
--- a/include/uapi/linux/fs.h
+++ b/include/uapi/linux/fs.h
@@ -197,6 +197,7 @@ struct inodes_stat_t {
197#define FS_EXTENT_FL 0x00080000 /* Extents */ 197#define FS_EXTENT_FL 0x00080000 /* Extents */
198#define FS_DIRECTIO_FL 0x00100000 /* Use direct i/o */ 198#define FS_DIRECTIO_FL 0x00100000 /* Use direct i/o */
199#define FS_NOCOW_FL 0x00800000 /* Do not cow file */ 199#define FS_NOCOW_FL 0x00800000 /* Do not cow file */
200#define FS_PROJINHERIT_FL 0x20000000 /* Create with parents projid */
200#define FS_RESERVED_FL 0x80000000 /* reserved for ext2 lib */ 201#define FS_RESERVED_FL 0x80000000 /* reserved for ext2 lib */
201 202
202#define FS_FL_USER_VISIBLE 0x0003DFFF /* User visible flags */ 203#define FS_FL_USER_VISIBLE 0x0003DFFF /* User visible flags */
generated by cgit v1.2.2 (git 2.25.0) at 2025-08-27 07:05:48 -0400