Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 71300980 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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
  ...
parents 9cf5c095 be69e1c1

fs/Makefile

+4 −3
Original line number Diff line number Diff line
@@ -63,10 +63,11 @@ obj-$(CONFIG_DLM) += dlm/ 
# Do not add any filesystems before this line

obj-$(CONFIG_FSCACHE)		+= fscache/

obj-$(CONFIG_REISERFS_FS)	+= reiserfs/

obj-$(CONFIG_EXT2_FS)		+= ext2/

# We place ext4 after ext2 so plain ext2 root fs's are mounted using ext2

# unless explicitly requested by rootfstype

obj-$(CONFIG_EXT4_FS)		+= ext4/

# We place ext4 before ext2 so that clean ext3 root fs's do NOT mount using the

# ext2 driver, which doesn't know about journalling!  Explicitly request ext2

# by giving the rootfstype= parameter.

obj-$(CONFIG_EXT2_FS)		+= ext2/

obj-$(CONFIG_JBD2)		+= jbd2/

obj-$(CONFIG_CRAMFS)		+= cramfs/

obj-$(CONFIG_SQUASHFS)		+= squashfs/

fs/ext4/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -8,7 +8,7 @@ ext4-y := balloc.o bitmap.o dir.o file.o fsync.o ialloc.o inode.o page-io.o \ 
		ioctl.o namei.o super.o symlink.o hash.o resize.o extents.o \

		ext4_jbd2.o migrate.o mballoc.o block_validity.o move_extent.o \

		mmp.o indirect.o extents_status.o xattr.o xattr_user.o \

		xattr_trusted.o inline.o readpage.o

		xattr_trusted.o inline.o readpage.o sysfs.o



ext4-$(CONFIG_EXT4_FS_POSIX_ACL)	+= acl.o

ext4-$(CONFIG_EXT4_FS_SECURITY)		+= xattr_security.o

fs/ext4/balloc.c

+49 −43
Original line number Diff line number Diff line
@@ -191,6 +191,7 @@ static int ext4_init_block_bitmap(struct super_block *sb, 
	/* If checksum is bad mark all blocks used to prevent allocation

	 * essentially implementing a per-group read-only flag. */

	if (!ext4_group_desc_csum_verify(sb, block_group, gdp)) {

		ext4_error(sb, "Checksum bad for group %u", block_group);

		grp = ext4_get_group_info(sb, block_group);

		if (!EXT4_MB_GRP_BBITMAP_CORRUPT(grp))

			percpu_counter_sub(&sbi->s_freeclusters_counter,
@@ -203,7 +204,7 @@ static int ext4_init_block_bitmap(struct super_block *sb, 
					   count);

		}

		set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &grp->bb_state);

		return -EIO;

		return -EFSBADCRC;

	}

	memset(bh->b_data, 0, sb->s_blocksize);
@@ -213,7 +214,7 @@ static int ext4_init_block_bitmap(struct super_block *sb, 


	start = ext4_group_first_block_no(sb, block_group);



	if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG))

	if (ext4_has_feature_flex_bg(sb))

		flex_bg = 1;



	/* 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, 
	ext4_fsblk_t blk;

	ext4_fsblk_t group_first_block;



	if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG)) {

	if (ext4_has_feature_flex_bg(sb)) {

		/* with FLEX_BG, the inode/block bitmaps and itable

		 * blocks may not be in the group at all

		 * so the bitmap validation will be skipped for those groups
@@ -360,7 +361,7 @@ static ext4_fsblk_t ext4_valid_block_bitmap(struct super_block *sb, 
	return 0;

}



static void ext4_validate_block_bitmap(struct super_block *sb,

static int ext4_validate_block_bitmap(struct super_block *sb,

				      struct ext4_group_desc *desc,

				      ext4_group_t block_group,

				      struct buffer_head *bh)
@@ -369,33 +370,36 @@ static void ext4_validate_block_bitmap(struct super_block *sb, 
	struct ext4_group_info *grp = ext4_get_group_info(sb, block_group);

	struct ext4_sb_info *sbi = EXT4_SB(sb);



	if (buffer_verified(bh) || EXT4_MB_GRP_BBITMAP_CORRUPT(grp))

		return;

	if (buffer_verified(bh))

		return 0;

	if (EXT4_MB_GRP_BBITMAP_CORRUPT(grp))

		return -EFSCORRUPTED;



	ext4_lock_group(sb, block_group);

	blk = ext4_valid_block_bitmap(sb, desc, block_group, bh);

	if (unlikely(blk != 0)) {

	if (unlikely(!ext4_block_bitmap_csum_verify(sb, block_group,

			desc, bh))) {

		ext4_unlock_group(sb, block_group);

		ext4_error(sb, "bg %u: block %llu: invalid block bitmap",

			   block_group, blk);

		ext4_error(sb, "bg %u: bad block bitmap checksum", block_group);

		if (!EXT4_MB_GRP_BBITMAP_CORRUPT(grp))

			percpu_counter_sub(&sbi->s_freeclusters_counter,

					   grp->bb_free);

		set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state);

		return;

		return -EFSBADCRC;

	}

	if (unlikely(!ext4_block_bitmap_csum_verify(sb, block_group,

			desc, bh))) {

	blk = ext4_valid_block_bitmap(sb, desc, block_group, bh);

	if (unlikely(blk != 0)) {

		ext4_unlock_group(sb, block_group);

		ext4_error(sb, "bg %u: bad block bitmap checksum", block_group);

		ext4_error(sb, "bg %u: block %llu: invalid block bitmap",

			   block_group, blk);

		if (!EXT4_MB_GRP_BBITMAP_CORRUPT(grp))

			percpu_counter_sub(&sbi->s_freeclusters_counter,

					   grp->bb_free);

		set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state);

		return;

		return -EFSCORRUPTED;

	}

	set_buffer_verified(bh);

	ext4_unlock_group(sb, block_group);

	return 0;

}



/**
@@ -414,17 +418,18 @@ ext4_read_block_bitmap_nowait(struct super_block *sb, ext4_group_t block_group) 
	struct ext4_group_desc *desc;

	struct buffer_head *bh;

	ext4_fsblk_t bitmap_blk;

	int err;



	desc = ext4_get_group_desc(sb, block_group, NULL);

	if (!desc)

		return NULL;

		return ERR_PTR(-EFSCORRUPTED);

	bitmap_blk = ext4_block_bitmap(sb, desc);

	bh = sb_getblk(sb, bitmap_blk);

	if (unlikely(!bh)) {

		ext4_error(sb, "Cannot get buffer for block bitmap - "

			   "block_group = %u, block_bitmap = %llu",

			   block_group, bitmap_blk);

		return NULL;

		return ERR_PTR(-ENOMEM);

	}



	if (bitmap_uptodate(bh))
@@ -437,7 +442,6 @@ ext4_read_block_bitmap_nowait(struct super_block *sb, ext4_group_t block_group) 
	}

	ext4_lock_group(sb, block_group);

	if (desc->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {

		int err;



		err = ext4_init_block_bitmap(sb, bh, block_group, desc);

		set_bitmap_uptodate(bh);
@@ -445,7 +449,7 @@ ext4_read_block_bitmap_nowait(struct super_block *sb, ext4_group_t block_group) 
		ext4_unlock_group(sb, block_group);

		unlock_buffer(bh);

		if (err)

			ext4_error(sb, "Checksum bad for grp %u", block_group);

			goto out;

		goto verify;

	}

	ext4_unlock_group(sb, block_group);
@@ -468,11 +472,13 @@ ext4_read_block_bitmap_nowait(struct super_block *sb, ext4_group_t block_group) 
	submit_bh(READ | REQ_META | REQ_PRIO, bh);

	return bh;

verify:

	ext4_validate_block_bitmap(sb, desc, block_group, bh);

	if (buffer_verified(bh))

	err = ext4_validate_block_bitmap(sb, desc, block_group, bh);

	if (err)

		goto out;

	return bh;

out:

	put_bh(bh);

	return NULL;

	return ERR_PTR(err);

}



/* 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, 
		return 0;

	desc = ext4_get_group_desc(sb, block_group, NULL);

	if (!desc)

		return 1;

		return -EFSCORRUPTED;

	wait_on_buffer(bh);

	if (!buffer_uptodate(bh)) {

		ext4_error(sb, "Cannot read block bitmap - "

			   "block_group = %u, block_bitmap = %llu",

			   block_group, (unsigned long long) bh->b_blocknr);

		return 1;

		return -EIO;

	}

	clear_buffer_new(bh);

	/* Panic or remount fs read-only if block bitmap is invalid */

	ext4_validate_block_bitmap(sb, desc, block_group, bh);

	/* ...but check for error just in case errors=continue. */

	return !buffer_verified(bh);

	return ext4_validate_block_bitmap(sb, desc, block_group, bh);

}



struct buffer_head *

ext4_read_block_bitmap(struct super_block *sb, ext4_group_t block_group)

{

	struct buffer_head *bh;

	int err;



	bh = ext4_read_block_bitmap_nowait(sb, block_group);

	if (!bh)

		return NULL;

	if (ext4_wait_block_bitmap(sb, block_group, bh)) {

	if (IS_ERR(bh))

		return bh;

	err = ext4_wait_block_bitmap(sb, block_group, bh);

	if (err) {

		put_bh(bh);

		return NULL;

		return ERR_PTR(err);

	}

	return bh;

}
@@ -681,8 +687,10 @@ ext4_fsblk_t ext4_count_free_clusters(struct super_block *sb) 
			desc_count += ext4_free_group_clusters(sb, gdp);

		brelse(bitmap_bh);

		bitmap_bh = ext4_read_block_bitmap(sb, i);

		if (bitmap_bh == NULL)

		if (IS_ERR(bitmap_bh)) {

			bitmap_bh = NULL;

			continue;

		}



		x = ext4_count_free(bitmap_bh->b_data,

				    EXT4_CLUSTERS_PER_GROUP(sb) / 8);
@@ -740,14 +748,13 @@ int ext4_bg_has_super(struct super_block *sb, ext4_group_t group) 


	if (group == 0)

		return 1;

	if (EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_SPARSE_SUPER2)) {

	if (ext4_has_feature_sparse_super2(sb)) {

		if (group == le32_to_cpu(es->s_backup_bgs[0]) ||

		    group == le32_to_cpu(es->s_backup_bgs[1]))

			return 1;

		return 0;

	}

	if ((group <= 1) || !EXT4_HAS_RO_COMPAT_FEATURE(sb,

					EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER))

	if ((group <= 1) || !ext4_has_feature_sparse_super(sb))

		return 1;

	if (!(group & 1))

		return 0;
@@ -776,7 +783,7 @@ static unsigned long ext4_bg_num_gdb_nometa(struct super_block *sb, 
	if (!ext4_bg_has_super(sb, group))

		return 0;



	if (EXT4_HAS_INCOMPAT_FEATURE(sb,EXT4_FEATURE_INCOMPAT_META_BG))

	if (ext4_has_feature_meta_bg(sb))

		return le32_to_cpu(EXT4_SB(sb)->s_es->s_first_meta_bg);

	else

		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) 
			le32_to_cpu(EXT4_SB(sb)->s_es->s_first_meta_bg);

	unsigned long metagroup = group / EXT4_DESC_PER_BLOCK(sb);



	if (!EXT4_HAS_INCOMPAT_FEATURE(sb,EXT4_FEATURE_INCOMPAT_META_BG) ||

			metagroup < first_meta_bg)

	if (!ext4_has_feature_meta_bg(sb) || metagroup < first_meta_bg)

		return ext4_bg_num_gdb_nometa(sb, group);



	return ext4_bg_num_gdb_meta(sb,group);
@@ -818,7 +824,7 @@ static unsigned ext4_num_base_meta_clusters(struct super_block *sb, 
	/* Check for superblock and gdt backups in this group */

	num = ext4_bg_has_super(sb, block_group);



	if (!EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_META_BG) ||

	if (!ext4_has_feature_meta_bg(sb) ||

	    block_group < le32_to_cpu(sbi->s_es->s_first_meta_bg) *

			  sbi->s_desc_per_block) {

		if (num) {

fs/ext4/block_validity.c

+1 −1
Original line number Diff line number Diff line
@@ -234,7 +234,7 @@ int ext4_check_blockref(const char *function, unsigned int line, 
			es->s_last_error_block = cpu_to_le64(blk);

			ext4_error_inode(inode, function, line, blk,

					 "invalid block");

			return -EIO;

			return -EFSCORRUPTED;

		}

	}

	return 0;

fs/ext4/crypto.c

+24 −28
Original line number Diff line number Diff line
@@ -253,8 +253,7 @@ typedef enum { 
	EXT4_ENCRYPT,

} ext4_direction_t;



static int ext4_page_crypto(struct ext4_crypto_ctx *ctx,

			    struct inode *inode,

static int ext4_page_crypto(struct inode *inode,

			    ext4_direction_t rw,

			    pgoff_t index,

			    struct page *src_page,
@@ -296,7 +295,6 @@ static int ext4_page_crypto(struct ext4_crypto_ctx *ctx, 
	else

		res = crypto_ablkcipher_encrypt(req);

	if (res == -EINPROGRESS || res == -EBUSY) {

		BUG_ON(req->base.data != &ecr);

		wait_for_completion(&ecr.completion);

		res = ecr.res;

	}
@@ -353,7 +351,7 @@ struct page *ext4_encrypt(struct inode *inode, 
	if (IS_ERR(ciphertext_page))

		goto errout;

	ctx->w.control_page = plaintext_page;

	err = ext4_page_crypto(ctx, inode, EXT4_ENCRYPT, plaintext_page->index,

	err = ext4_page_crypto(inode, EXT4_ENCRYPT, plaintext_page->index,

			       plaintext_page, ciphertext_page);

	if (err) {

		ciphertext_page = ERR_PTR(err);
@@ -378,31 +376,14 @@ struct page *ext4_encrypt(struct inode *inode, 
 *

 * Return: Zero on success, non-zero otherwise.

 */

int ext4_decrypt(struct ext4_crypto_ctx *ctx, struct page *page)

int ext4_decrypt(struct page *page)

{

	BUG_ON(!PageLocked(page));



	return ext4_page_crypto(ctx, page->mapping->host,

	return ext4_page_crypto(page->mapping->host,

				EXT4_DECRYPT, page->index, page, page);

}



/*

 * Convenience function which takes care of allocating and

 * deallocating the encryption context

 */

int ext4_decrypt_one(struct inode *inode, struct page *page)

{

	int ret;



	struct ext4_crypto_ctx *ctx = ext4_get_crypto_ctx(inode);



	if (IS_ERR(ctx))

		return PTR_ERR(ctx);

	ret = ext4_decrypt(ctx, page);

	ext4_release_crypto_ctx(ctx);

	return ret;

}



int ext4_encrypted_zeroout(struct inode *inode, struct ext4_extent *ex)

{

	struct ext4_crypto_ctx	*ctx;
@@ -411,7 +392,13 @@ int ext4_encrypted_zeroout(struct inode *inode, struct ext4_extent *ex) 
	ext4_lblk_t		lblk = ex->ee_block;

	ext4_fsblk_t		pblk = ext4_ext_pblock(ex);

	unsigned int		len = ext4_ext_get_actual_len(ex);

	int			err = 0;

	int			ret, err = 0;



#if 0

	ext4_msg(inode->i_sb, KERN_CRIT,

		 "ext4_encrypted_zeroout ino %lu lblk %u len %u",

		 (unsigned long) inode->i_ino, lblk, len);

#endif



	BUG_ON(inode->i_sb->s_blocksize != PAGE_CACHE_SIZE);
@@ -426,7 +413,7 @@ int ext4_encrypted_zeroout(struct inode *inode, struct ext4_extent *ex) 
	}



	while (len--) {

		err = ext4_page_crypto(ctx, inode, EXT4_ENCRYPT, lblk,

		err = ext4_page_crypto(inode, EXT4_ENCRYPT, lblk,

				       ZERO_PAGE(0), ciphertext_page);

		if (err)

			goto errout;
@@ -437,17 +424,26 @@ int ext4_encrypted_zeroout(struct inode *inode, struct ext4_extent *ex) 
			goto errout;

		}

		bio->bi_bdev = inode->i_sb->s_bdev;

		bio->bi_iter.bi_sector = pblk;

		err = bio_add_page(bio, ciphertext_page,

		bio->bi_iter.bi_sector =

			pblk << (inode->i_sb->s_blocksize_bits - 9);

		ret = bio_add_page(bio, ciphertext_page,

				   inode->i_sb->s_blocksize, 0);

		if (err) {

		if (ret != inode->i_sb->s_blocksize) {

			/* should never happen! */

			ext4_msg(inode->i_sb, KERN_ERR,

				 "bio_add_page failed: %d", ret);

			WARN_ON(1);

			bio_put(bio);

			err = -EIO;

			goto errout;

		}

		err = submit_bio_wait(WRITE, bio);

		if ((err == 0) && bio->bi_error)

			err = -EIO;

		bio_put(bio);

		if (err)

			goto errout;

		lblk++; pblk++;

	}

	err = 0;

errout: