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

Commit 020ecbba authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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

Pull ext4 bugfixes from Ted Ts'o:
 "Miscellaneous ext4 bug fixes for v4.5"

* tag 'ext4_for_linus_stable' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4:
  ext4: fix crashes in dioread_nolock mode
  ext4: fix bh->b_state corruption
  ext4: fix memleak in ext4_readdir()
  ext4: remove unused parameter "newblock" in convert_initialized_extent()
  ext4: don't read blocks from disk after extents being swapped
  ext4: fix potential integer overflow
  ext4: add a line break for proc mb_groups display
  ext4: ioctl: fix erroneous return value
  ext4: fix scheduling in atomic on group checksum failure
  ext4 crypto: move context consistency check to ext4_file_open()
  ext4 crypto: revalidate dentry after adding or removing the key
parents ce6b7143 74dae427

fs/ext4/balloc.c

+4 −3
Original line number Diff line number Diff line
@@ -191,7 +191,6 @@ 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,
@@ -442,14 +441,16 @@ 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)) {



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

		set_bitmap_uptodate(bh);

		set_buffer_uptodate(bh);

		ext4_unlock_group(sb, block_group);

		unlock_buffer(bh);

		if (err)

		if (err) {

			ext4_error(sb, "Failed to init block bitmap for group "

				   "%u: %d", block_group, err);

			goto out;

		}

		goto verify;

	}

	ext4_unlock_group(sb, block_group);

fs/ext4/crypto.c

+56 −0
Original line number Diff line number Diff line
@@ -467,3 +467,59 @@ uint32_t ext4_validate_encryption_key_size(uint32_t mode, uint32_t size) 
		return size;

	return 0;

}



/*

 * Validate dentries for encrypted directories to make sure we aren't

 * potentially caching stale data after a key has been added or

 * removed.

 */

static int ext4_d_revalidate(struct dentry *dentry, unsigned int flags)

{

	struct inode *dir = d_inode(dentry->d_parent);

	struct ext4_crypt_info *ci = EXT4_I(dir)->i_crypt_info;

	int dir_has_key, cached_with_key;



	if (!ext4_encrypted_inode(dir))

		return 0;



	if (ci && ci->ci_keyring_key &&

	    (ci->ci_keyring_key->flags & ((1 << KEY_FLAG_INVALIDATED) |

					  (1 << KEY_FLAG_REVOKED) |

					  (1 << KEY_FLAG_DEAD))))

		ci = NULL;



	/* this should eventually be an flag in d_flags */

	cached_with_key = dentry->d_fsdata != NULL;

	dir_has_key = (ci != NULL);



	/*

	 * If the dentry was cached without the key, and it is a

	 * negative dentry, it might be a valid name.  We can't check

	 * if the key has since been made available due to locking

	 * reasons, so we fail the validation so ext4_lookup() can do

	 * this check.

	 *

	 * We also fail the validation if the dentry was created with

	 * the key present, but we no longer have the key, or vice versa.

	 */

	if ((!cached_with_key && d_is_negative(dentry)) ||

	    (!cached_with_key && dir_has_key) ||

	    (cached_with_key && !dir_has_key)) {

#if 0				/* Revalidation debug */

		char buf[80];

		char *cp = simple_dname(dentry, buf, sizeof(buf));



		if (IS_ERR(cp))

			cp = (char *) "???";

		pr_err("revalidate: %s %p %d %d %d\n", cp, dentry->d_fsdata,

		       cached_with_key, d_is_negative(dentry),

		       dir_has_key);

#endif

		return 0;

	}

	return 1;

}



const struct dentry_operations ext4_encrypted_d_ops = {

	.d_revalidate = ext4_d_revalidate,

};

fs/ext4/dir.c

+11 −2
Original line number Diff line number Diff line
@@ -111,6 +111,12 @@ static int ext4_readdir(struct file *file, struct dir_context *ctx) 
	int dir_has_error = 0;

	struct ext4_str fname_crypto_str = {.name = NULL, .len = 0};



	if (ext4_encrypted_inode(inode)) {

		err = ext4_get_encryption_info(inode);

		if (err && err != -ENOKEY)

			return err;

	}



	if (is_dx_dir(inode)) {

		err = ext4_dx_readdir(file, ctx);

		if (err != ERR_BAD_DX_DIR) {
@@ -157,8 +163,11 @@ static int ext4_readdir(struct file *file, struct dir_context *ctx) 
					index, 1);

			file->f_ra.prev_pos = (loff_t)index << PAGE_CACHE_SHIFT;

			bh = ext4_bread(NULL, inode, map.m_lblk, 0);

			if (IS_ERR(bh))

				return PTR_ERR(bh);

			if (IS_ERR(bh)) {

				err = PTR_ERR(bh);

				bh = NULL;

				goto errout;

			}

		}



		if (!bh) {

fs/ext4/ext4.h

+1 −0
Original line number Diff line number Diff line
@@ -2302,6 +2302,7 @@ struct page *ext4_encrypt(struct inode *inode, 
int ext4_decrypt(struct page *page);

int ext4_encrypted_zeroout(struct inode *inode, ext4_lblk_t lblk,

			   ext4_fsblk_t pblk, ext4_lblk_t len);

extern const struct dentry_operations ext4_encrypted_d_ops;



#ifdef CONFIG_EXT4_FS_ENCRYPTION

int ext4_init_crypto(void);

fs/ext4/extents.c

+2 −2
Original line number Diff line number Diff line
@@ -3928,7 +3928,7 @@ static int 
convert_initialized_extent(handle_t *handle, struct inode *inode,

			   struct ext4_map_blocks *map,

			   struct ext4_ext_path **ppath, int flags,

			   unsigned int allocated, ext4_fsblk_t newblock)

			   unsigned int allocated)

{

	struct ext4_ext_path *path = *ppath;

	struct ext4_extent *ex;
@@ -4347,7 +4347,7 @@ int ext4_ext_map_blocks(handle_t *handle, struct inode *inode, 
			    (flags & EXT4_GET_BLOCKS_CONVERT_UNWRITTEN)) {

				allocated = convert_initialized_extent(

						handle, inode, map, &path,

						flags, allocated, newblock);

						flags, allocated);

				goto out2;

			} else if (!ext4_ext_is_unwritten(ex))

				goto out;