f2fs: use err for f2fs_preallocate_blocks (a7de6086) · Commits · e / devices / android_kernel_xiaomi_nabu

fs/f2fs/data.c

+13 −13

Original line number	Original line	Diff line number	Diff line
	@@ -658,11 +658,11 @@ static int __allocate_data_block(struct dnode_of_data *dn)
	return 0;		return 0;
	}		}

	ssize_t f2fs_preallocate_blocks(struct kiocb iocb, struct iov_iter from)		int f2fs_preallocate_blocks(struct kiocb iocb, struct iov_iter from)
	{		{
	struct inode *inode = file_inode(iocb->ki_filp);		struct inode *inode = file_inode(iocb->ki_filp);
	struct f2fs_map_blocks map;		struct f2fs_map_blocks map;
	ssize_t ret = 0;		int err = 0;

	map.m_lblk = F2FS_BLK_ALIGN(iocb->ki_pos);		map.m_lblk = F2FS_BLK_ALIGN(iocb->ki_pos);
	map.m_len = F2FS_BYTES_TO_BLK(iocb->ki_pos + iov_iter_count(from));		map.m_len = F2FS_BYTES_TO_BLK(iocb->ki_pos + iov_iter_count(from));
	@@ -674,19 +674,19 @@ ssize_t f2fs_preallocate_blocks(struct kiocb iocb, struct iov_iter from)
	map.m_next_pgofs = NULL;		map.m_next_pgofs = NULL;

	if (iocb->ki_flags & IOCB_DIRECT) {		if (iocb->ki_flags & IOCB_DIRECT) {
	ret = f2fs_convert_inline_inode(inode);		err = f2fs_convert_inline_inode(inode);
	if (ret)		if (err)
	return ret;		return err;
	return f2fs_map_blocks(inode, &map, 1, F2FS_GET_BLOCK_PRE_DIO);		return f2fs_map_blocks(inode, &map, 1, F2FS_GET_BLOCK_PRE_DIO);
	}		}
	if (iocb->ki_pos + iov_iter_count(from) > MAX_INLINE_DATA) {		if (iocb->ki_pos + iov_iter_count(from) > MAX_INLINE_DATA) {
	ret = f2fs_convert_inline_inode(inode);		err = f2fs_convert_inline_inode(inode);
	if (ret)		if (err)
	return ret;		return err;
	}		}
	if (!f2fs_has_inline_data(inode))		if (!f2fs_has_inline_data(inode))
	return f2fs_map_blocks(inode, &map, 1, F2FS_GET_BLOCK_PRE_AIO);		return f2fs_map_blocks(inode, &map, 1, F2FS_GET_BLOCK_PRE_AIO);
	return ret;		return err;
	}		}

	/*		/*
	@@ -863,19 +863,19 @@ static int __get_data_block(struct inode *inode, sector_t iblock,
	pgoff_t *next_pgofs)		pgoff_t *next_pgofs)
	{		{
	struct f2fs_map_blocks map;		struct f2fs_map_blocks map;
	int ret;		int err;

	map.m_lblk = iblock;		map.m_lblk = iblock;
	map.m_len = bh->b_size >> inode->i_blkbits;		map.m_len = bh->b_size >> inode->i_blkbits;
	map.m_next_pgofs = next_pgofs;		map.m_next_pgofs = next_pgofs;

	ret = f2fs_map_blocks(inode, &map, create, flag);		err = f2fs_map_blocks(inode, &map, create, flag);
	if (!ret) {		if (!err) {
	map_bh(bh, inode->i_sb, map.m_pblk);		map_bh(bh, inode->i_sb, map.m_pblk);
	bh->b_state = (bh->b_state & ~F2FS_MAP_FLAGS) \| map.m_flags;		bh->b_state = (bh->b_state & ~F2FS_MAP_FLAGS) \| map.m_flags;
	bh->b_size = map.m_len << inode->i_blkbits;		bh->b_size = map.m_len << inode->i_blkbits;
	}		}
	return ret;		return err;
	}		}

	static int get_data_block(struct inode *inode, sector_t iblock,		static int get_data_block(struct inode *inode, sector_t iblock,

fs/f2fs/f2fs.h

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -2160,7 +2160,7 @@ void f2fs_update_data_blkaddr(struct dnode_of_data *, block_t);
	int reserve_new_blocks(struct dnode_of_data *, blkcnt_t);		int reserve_new_blocks(struct dnode_of_data *, blkcnt_t);
	int reserve_new_block(struct dnode_of_data *);		int reserve_new_block(struct dnode_of_data *);
	int f2fs_get_block(struct dnode_of_data *, pgoff_t);		int f2fs_get_block(struct dnode_of_data *, pgoff_t);
	ssize_t f2fs_preallocate_blocks(struct kiocb , struct iov_iter );		int f2fs_preallocate_blocks(struct kiocb , struct iov_iter );
	int f2fs_reserve_block(struct dnode_of_data *, pgoff_t);		int f2fs_reserve_block(struct dnode_of_data *, pgoff_t);
	struct page get_read_data_page(struct inode , pgoff_t, int, bool);		struct page get_read_data_page(struct inode , pgoff_t, int, bool);
	struct page find_data_page(struct inode , pgoff_t);		struct page find_data_page(struct inode , pgoff_t);

fs/f2fs/file.c

+19 −16

Original line number	Original line	Diff line number	Diff line
	@@ -1320,15 +1320,15 @@ static int expand_inode_data(struct inode *inode, loff_t offset,
	pgoff_t pg_end;		pgoff_t pg_end;
	loff_t new_size = i_size_read(inode);		loff_t new_size = i_size_read(inode);
	loff_t off_end;		loff_t off_end;
	int ret;		int err;

	ret = inode_newsize_ok(inode, (len + offset));		err = inode_newsize_ok(inode, (len + offset));
	if (ret)		if (err)
	return ret;		return err;

	ret = f2fs_convert_inline_inode(inode);		err = f2fs_convert_inline_inode(inode);
	if (ret)		if (err)
	return ret;		return err;

	f2fs_balance_fs(sbi, true);		f2fs_balance_fs(sbi, true);

	@@ -1340,12 +1340,12 @@ static int expand_inode_data(struct inode *inode, loff_t offset,
	if (off_end)		if (off_end)
	map.m_len++;		map.m_len++;

	ret = f2fs_map_blocks(inode, &map, 1, F2FS_GET_BLOCK_PRE_AIO);		err = f2fs_map_blocks(inode, &map, 1, F2FS_GET_BLOCK_PRE_AIO);
	if (ret) {		if (err) {
	pgoff_t last_off;		pgoff_t last_off;

	if (!map.m_len)		if (!map.m_len)
	return ret;		return err;

	last_off = map.m_lblk + map.m_len - 1;		last_off = map.m_lblk + map.m_len - 1;

	@@ -1359,7 +1359,7 @@ static int expand_inode_data(struct inode *inode, loff_t offset,
	if (!(mode & FALLOC_FL_KEEP_SIZE) && i_size_read(inode) < new_size)		if (!(mode & FALLOC_FL_KEEP_SIZE) && i_size_read(inode) < new_size)
	f2fs_i_size_write(inode, new_size);		f2fs_i_size_write(inode, new_size);

	return ret;		return err;
	}		}

	static long f2fs_fallocate(struct file *file, int mode,		static long f2fs_fallocate(struct file *file, int mode,
	@@ -2263,13 +2263,16 @@ static ssize_t f2fs_file_write_iter(struct kiocb iocb, struct iov_iter from)
	inode_lock(inode);		inode_lock(inode);
	ret = generic_write_checks(iocb, from);		ret = generic_write_checks(iocb, from);
	if (ret > 0) {		if (ret > 0) {
	ret = f2fs_preallocate_blocks(iocb, from);		int err = f2fs_preallocate_blocks(iocb, from);
	if (!ret) {
			if (err) {
			inode_unlock(inode);
			return err;
			}
	blk_start_plug(&plug);		blk_start_plug(&plug);
	ret = __generic_file_write_iter(iocb, from);		ret = __generic_file_write_iter(iocb, from);
	blk_finish_plug(&plug);		blk_finish_plug(&plug);
	}		}
	}
	inode_unlock(inode);		inode_unlock(inode);

	if (ret > 0)		if (ret > 0)