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

Commit 0572d766 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'f2fs-for-5.4-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs 

Pull f2fs fixes from Jaegeuk Kim:
 "This set of patches adjust to follow recent setflags changes and fix
  two regressions"

* tag 'f2fs-for-5.4-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs:
  f2fs: use EINVAL for superblock with invalid magic
  f2fs: fix to read source block before invalidating it
  f2fs: remove redundant check from f2fs_setflags_common()
  f2fs: use generic checking function for FS_IOC_FSSETXATTR
  f2fs: use generic checking and prep function for FS_IOC_SETFLAGS
parents 2f6f0a99 38fb6d0e

fs/f2fs/file.c

+23 −40
Original line number Diff line number Diff line
@@ -1653,19 +1653,12 @@ static int f2fs_file_flush(struct file *file, fl_owner_t id) 
static int f2fs_setflags_common(struct inode *inode, u32 iflags, u32 mask)

{

	struct f2fs_inode_info *fi = F2FS_I(inode);

	u32 oldflags;



	/* Is it quota file? Do not allow user to mess with it */

	if (IS_NOQUOTA(inode))

		return -EPERM;



	oldflags = fi->i_flags;



	if ((iflags ^ oldflags) & (F2FS_APPEND_FL | F2FS_IMMUTABLE_FL))

		if (!capable(CAP_LINUX_IMMUTABLE))

			return -EPERM;



	fi->i_flags = iflags | (oldflags & ~mask);

	fi->i_flags = iflags | (fi->i_flags & ~mask);



	if (fi->i_flags & F2FS_PROJINHERIT_FL)

		set_inode_flag(inode, FI_PROJ_INHERIT);
@@ -1770,7 +1763,8 @@ static int f2fs_ioc_getflags(struct file *filp, unsigned long arg) 
static int f2fs_ioc_setflags(struct file *filp, unsigned long arg)

{

	struct inode *inode = file_inode(filp);

	u32 fsflags;

	struct f2fs_inode_info *fi = F2FS_I(inode);

	u32 fsflags, old_fsflags;

	u32 iflags;

	int ret;
@@ -1794,8 +1788,14 @@ static int f2fs_ioc_setflags(struct file *filp, unsigned long arg) 


	inode_lock(inode);



	old_fsflags = f2fs_iflags_to_fsflags(fi->i_flags);

	ret = vfs_ioc_setflags_prepare(inode, old_fsflags, fsflags);

	if (ret)

		goto out;



	ret = f2fs_setflags_common(inode, iflags,

			f2fs_fsflags_to_iflags(F2FS_SETTABLE_FS_FL));

out:

	inode_unlock(inode);

	mnt_drop_write_file(filp);

	return ret;
@@ -2855,52 +2855,32 @@ static inline u32 f2fs_xflags_to_iflags(u32 xflags) 
	return iflags;

}



static int f2fs_ioc_fsgetxattr(struct file *filp, unsigned long arg)

static void f2fs_fill_fsxattr(struct inode *inode, struct fsxattr *fa)

{

	struct inode *inode = file_inode(filp);

	struct f2fs_inode_info *fi = F2FS_I(inode);

	struct fsxattr fa;



	memset(&fa, 0, sizeof(struct fsxattr));

	fa.fsx_xflags = f2fs_iflags_to_xflags(fi->i_flags);

	simple_fill_fsxattr(fa, f2fs_iflags_to_xflags(fi->i_flags));



	if (f2fs_sb_has_project_quota(F2FS_I_SB(inode)))

		fa.fsx_projid = (__u32)from_kprojid(&init_user_ns,

							fi->i_projid);



	if (copy_to_user((struct fsxattr __user *)arg, &fa, sizeof(fa)))

		return -EFAULT;

	return 0;

		fa->fsx_projid = from_kprojid(&init_user_ns, fi->i_projid);

}



static int f2fs_ioctl_check_project(struct inode *inode, struct fsxattr *fa)

static int f2fs_ioc_fsgetxattr(struct file *filp, unsigned long arg)

{

	/*

	 * Project Quota ID state is only allowed to change from within the init

	 * namespace. Enforce that restriction only if we are trying to change

	 * the quota ID state. Everything else is allowed in user namespaces.

	 */

	if (current_user_ns() == &init_user_ns)

		return 0;



	if (__kprojid_val(F2FS_I(inode)->i_projid) != fa->fsx_projid)

		return -EINVAL;

	struct inode *inode = file_inode(filp);

	struct fsxattr fa;



	if (F2FS_I(inode)->i_flags & F2FS_PROJINHERIT_FL) {

		if (!(fa->fsx_xflags & FS_XFLAG_PROJINHERIT))

			return -EINVAL;

	} else {

		if (fa->fsx_xflags & FS_XFLAG_PROJINHERIT)

			return -EINVAL;

	}

	f2fs_fill_fsxattr(inode, &fa);



	if (copy_to_user((struct fsxattr __user *)arg, &fa, sizeof(fa)))

		return -EFAULT;

	return 0;

}



static int f2fs_ioc_fssetxattr(struct file *filp, unsigned long arg)

{

	struct inode *inode = file_inode(filp);

	struct fsxattr fa;

	struct fsxattr fa, old_fa;

	u32 iflags;

	int err;
@@ -2923,9 +2903,12 @@ static int f2fs_ioc_fssetxattr(struct file *filp, unsigned long arg) 
		return err;



	inode_lock(inode);

	err = f2fs_ioctl_check_project(inode, &fa);



	f2fs_fill_fsxattr(inode, &old_fa);

	err = vfs_ioc_fssetxattr_check(inode, &old_fa, &fa);

	if (err)

		goto out;



	err = f2fs_setflags_common(inode, iflags,

			f2fs_xflags_to_iflags(F2FS_SUPPORTED_XFLAGS));

	if (err)

fs/f2fs/gc.c

+34 −36
Original line number Diff line number Diff line
@@ -796,6 +796,29 @@ static int move_data_block(struct inode *inode, block_t bidx, 
	if (lfs_mode)

		down_write(&fio.sbi->io_order_lock);



	mpage = f2fs_grab_cache_page(META_MAPPING(fio.sbi),

					fio.old_blkaddr, false);

	if (!mpage)

		goto up_out;



	fio.encrypted_page = mpage;



	/* read source block in mpage */

	if (!PageUptodate(mpage)) {

		err = f2fs_submit_page_bio(&fio);

		if (err) {

			f2fs_put_page(mpage, 1);

			goto up_out;

		}

		lock_page(mpage);

		if (unlikely(mpage->mapping != META_MAPPING(fio.sbi) ||

						!PageUptodate(mpage))) {

			err = -EIO;

			f2fs_put_page(mpage, 1);

			goto up_out;

		}

	}



	f2fs_allocate_data_block(fio.sbi, NULL, fio.old_blkaddr, &newaddr,

					&sum, CURSEG_COLD_DATA, NULL, false);
@@ -803,44 +826,18 @@ static int move_data_block(struct inode *inode, block_t bidx, 
				newaddr, FGP_LOCK | FGP_CREAT, GFP_NOFS);

	if (!fio.encrypted_page) {

		err = -ENOMEM;

		f2fs_put_page(mpage, 1);

		goto recover_block;

	}



	mpage = f2fs_pagecache_get_page(META_MAPPING(fio.sbi),

					fio.old_blkaddr, FGP_LOCK, GFP_NOFS);

	if (mpage) {

		bool updated = false;



		if (PageUptodate(mpage)) {

	/* write target block */

	f2fs_wait_on_page_writeback(fio.encrypted_page, DATA, true, true);

	memcpy(page_address(fio.encrypted_page),

				page_address(mpage), PAGE_SIZE);

			updated = true;

		}

	f2fs_put_page(mpage, 1);

	invalidate_mapping_pages(META_MAPPING(fio.sbi),

				fio.old_blkaddr, fio.old_blkaddr);

		if (updated)

			goto write_page;

	}



	err = f2fs_submit_page_bio(&fio);

	if (err)

		goto put_page_out;



	/* write page */

	lock_page(fio.encrypted_page);



	if (unlikely(fio.encrypted_page->mapping != META_MAPPING(fio.sbi))) {

		err = -EIO;

		goto put_page_out;

	}

	if (unlikely(!PageUptodate(fio.encrypted_page))) {

		err = -EIO;

		goto put_page_out;

	}



write_page:

	f2fs_wait_on_page_writeback(fio.encrypted_page, DATA, true, true);

	set_page_dirty(fio.encrypted_page);

	if (clear_page_dirty_for_io(fio.encrypted_page))

		dec_page_count(fio.sbi, F2FS_DIRTY_META);
@@ -871,11 +868,12 @@ static int move_data_block(struct inode *inode, block_t bidx, 
put_page_out:

	f2fs_put_page(fio.encrypted_page, 1);

recover_block:

	if (lfs_mode)

		up_write(&fio.sbi->io_order_lock);

	if (err)

		f2fs_do_replace_block(fio.sbi, &sum, newaddr, fio.old_blkaddr,

								true, true);

up_out:

	if (lfs_mode)

		up_write(&fio.sbi->io_order_lock);

put_out:

	f2fs_put_dnode(&dn);

out:

fs/f2fs/super.c

+24 −24
Original line number Diff line number Diff line
@@ -2422,6 +2422,12 @@ static int sanity_check_raw_super(struct f2fs_sb_info *sbi, 
	size_t crc_offset = 0;

	__u32 crc = 0;



	if (le32_to_cpu(raw_super->magic) != F2FS_SUPER_MAGIC) {

		f2fs_info(sbi, "Magic Mismatch, valid(0x%x) - read(0x%x)",

			  F2FS_SUPER_MAGIC, le32_to_cpu(raw_super->magic));

		return -EINVAL;

	}



	/* Check checksum_offset and crc in superblock */

	if (__F2FS_HAS_FEATURE(raw_super, F2FS_FEATURE_SB_CHKSUM)) {

		crc_offset = le32_to_cpu(raw_super->checksum_offset);
@@ -2429,26 +2435,20 @@ static int sanity_check_raw_super(struct f2fs_sb_info *sbi, 
			offsetof(struct f2fs_super_block, crc)) {

			f2fs_info(sbi, "Invalid SB checksum offset: %zu",

				  crc_offset);

			return 1;

			return -EFSCORRUPTED;

		}

		crc = le32_to_cpu(raw_super->crc);

		if (!f2fs_crc_valid(sbi, crc, raw_super, crc_offset)) {

			f2fs_info(sbi, "Invalid SB checksum value: %u", crc);

			return 1;

			return -EFSCORRUPTED;

		}

	}



	if (F2FS_SUPER_MAGIC != le32_to_cpu(raw_super->magic)) {

		f2fs_info(sbi, "Magic Mismatch, valid(0x%x) - read(0x%x)",

			  F2FS_SUPER_MAGIC, le32_to_cpu(raw_super->magic));

		return 1;

	}



	/* Currently, support only 4KB page cache size */

	if (F2FS_BLKSIZE != PAGE_SIZE) {

		f2fs_info(sbi, "Invalid page_cache_size (%lu), supports only 4KB",

			  PAGE_SIZE);

		return 1;

		return -EFSCORRUPTED;

	}



	/* Currently, support only 4KB block size */
@@ -2456,14 +2456,14 @@ static int sanity_check_raw_super(struct f2fs_sb_info *sbi, 
	if (blocksize != F2FS_BLKSIZE) {

		f2fs_info(sbi, "Invalid blocksize (%u), supports only 4KB",

			  blocksize);

		return 1;

		return -EFSCORRUPTED;

	}



	/* check log blocks per segment */

	if (le32_to_cpu(raw_super->log_blocks_per_seg) != 9) {

		f2fs_info(sbi, "Invalid log blocks per segment (%u)",

			  le32_to_cpu(raw_super->log_blocks_per_seg));

		return 1;

		return -EFSCORRUPTED;

	}



	/* Currently, support 512/1024/2048/4096 bytes sector size */
@@ -2473,7 +2473,7 @@ static int sanity_check_raw_super(struct f2fs_sb_info *sbi, 
				F2FS_MIN_LOG_SECTOR_SIZE) {

		f2fs_info(sbi, "Invalid log sectorsize (%u)",

			  le32_to_cpu(raw_super->log_sectorsize));

		return 1;

		return -EFSCORRUPTED;

	}

	if (le32_to_cpu(raw_super->log_sectors_per_block) +

		le32_to_cpu(raw_super->log_sectorsize) !=
@@ -2481,7 +2481,7 @@ static int sanity_check_raw_super(struct f2fs_sb_info *sbi, 
		f2fs_info(sbi, "Invalid log sectors per block(%u) log sectorsize(%u)",

			  le32_to_cpu(raw_super->log_sectors_per_block),

			  le32_to_cpu(raw_super->log_sectorsize));

		return 1;

		return -EFSCORRUPTED;

	}



	segment_count = le32_to_cpu(raw_super->segment_count);
@@ -2495,7 +2495,7 @@ static int sanity_check_raw_super(struct f2fs_sb_info *sbi, 
	if (segment_count > F2FS_MAX_SEGMENT ||

				segment_count < F2FS_MIN_SEGMENTS) {

		f2fs_info(sbi, "Invalid segment count (%u)", segment_count);

		return 1;

		return -EFSCORRUPTED;

	}



	if (total_sections > segment_count ||
@@ -2503,25 +2503,25 @@ static int sanity_check_raw_super(struct f2fs_sb_info *sbi, 
			segs_per_sec > segment_count || !segs_per_sec) {

		f2fs_info(sbi, "Invalid segment/section count (%u, %u x %u)",

			  segment_count, total_sections, segs_per_sec);

		return 1;

		return -EFSCORRUPTED;

	}



	if ((segment_count / segs_per_sec) < total_sections) {

		f2fs_info(sbi, "Small segment_count (%u < %u * %u)",

			  segment_count, segs_per_sec, total_sections);

		return 1;

		return -EFSCORRUPTED;

	}



	if (segment_count > (le64_to_cpu(raw_super->block_count) >> 9)) {

		f2fs_info(sbi, "Wrong segment_count / block_count (%u > %llu)",

			  segment_count, le64_to_cpu(raw_super->block_count));

		return 1;

		return -EFSCORRUPTED;

	}



	if (secs_per_zone > total_sections || !secs_per_zone) {

		f2fs_info(sbi, "Wrong secs_per_zone / total_sections (%u, %u)",

			  secs_per_zone, total_sections);

		return 1;

		return -EFSCORRUPTED;

	}

	if (le32_to_cpu(raw_super->extension_count) > F2FS_MAX_EXTENSION ||

			raw_super->hot_ext_count > F2FS_MAX_EXTENSION ||
@@ -2531,7 +2531,7 @@ static int sanity_check_raw_super(struct f2fs_sb_info *sbi, 
			  le32_to_cpu(raw_super->extension_count),

			  raw_super->hot_ext_count,

			  F2FS_MAX_EXTENSION);

		return 1;

		return -EFSCORRUPTED;

	}



	if (le32_to_cpu(raw_super->cp_payload) >
@@ -2539,7 +2539,7 @@ static int sanity_check_raw_super(struct f2fs_sb_info *sbi, 
		f2fs_info(sbi, "Insane cp_payload (%u > %u)",

			  le32_to_cpu(raw_super->cp_payload),

			  blocks_per_seg - F2FS_CP_PACKS);

		return 1;

		return -EFSCORRUPTED;

	}



	/* check reserved ino info */
@@ -2550,12 +2550,12 @@ static int sanity_check_raw_super(struct f2fs_sb_info *sbi, 
			  le32_to_cpu(raw_super->node_ino),

			  le32_to_cpu(raw_super->meta_ino),

			  le32_to_cpu(raw_super->root_ino));

		return 1;

		return -EFSCORRUPTED;

	}



	/* check CP/SIT/NAT/SSA/MAIN_AREA area boundary */

	if (sanity_check_area_boundary(sbi, bh))

		return 1;

		return -EFSCORRUPTED;



	return 0;

}
@@ -2870,10 +2870,10 @@ static int read_raw_super_block(struct f2fs_sb_info *sbi, 
		}



		/* sanity checking of raw super */

		if (sanity_check_raw_super(sbi, bh)) {

		err = sanity_check_raw_super(sbi, bh);

		if (err) {

			f2fs_err(sbi, "Can't find valid F2FS filesystem in %dth superblock",

				 block + 1);

			err = -EFSCORRUPTED;

			brelse(bh);

			continue;

		}