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

Commit 9e302393 authored by Chao Yu's avatar Chao Yu Committed by Jaegeuk Kim
Browse files

f2fs: introduce f2fs_read_single_page() for cleanup 



This patch introduces f2fs_read_single_page() to wrap core operations
of reading one page in f2fs_mpage_readpages().

In addition, if we failed in f2fs_mpage_readpages(), propagate error
number to f2fs_read_data_page(), for f2fs_read_data_pages() path,
always return success.

Signed-off-by: default avatarChao Yu <yuchao0@huawei.com>
Signed-off-by: default avatarJaegeuk Kim <jaegeuk@kernel.org>
parent 4b75b0e1

fs/f2fs/data.c

+118 −96
Original line number Diff line number Diff line
@@ -1505,50 +1505,21 @@ int f2fs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, 
	return ret;

}



/*

 * This function was originally taken from fs/mpage.c, and customized for f2fs.

 * Major change was from block_size == page_size in f2fs by default.

 *

 * Note that the aops->readpages() function is ONLY used for read-ahead. If

 * this function ever deviates from doing just read-ahead, it should either

 * use ->readpage() or do the necessary surgery to decouple ->readpages()

 * from read-ahead.

 */

static int f2fs_mpage_readpages(struct address_space *mapping,

			struct list_head *pages, struct page *page,

			unsigned nr_pages, bool is_readahead)

{

	struct bio *bio = NULL;

	sector_t last_block_in_bio = 0;

	struct inode *inode = mapping->host;

static int f2fs_read_single_page(struct inode *inode, struct page *page,

					unsigned nr_pages,

					struct f2fs_map_blocks *map,

					struct bio **bio_ret,

					sector_t *last_block_in_bio,

					bool is_readahead)

{

	struct bio *bio = *bio_ret;

	const unsigned blkbits = inode->i_blkbits;

	const unsigned blocksize = 1 << blkbits;

	sector_t block_in_file;

	sector_t last_block;

	sector_t last_block_in_file;

	sector_t block_nr;

	struct f2fs_map_blocks map;



	map.m_pblk = 0;

	map.m_lblk = 0;

	map.m_len = 0;

	map.m_flags = 0;

	map.m_next_pgofs = NULL;

	map.m_next_extent = NULL;

	map.m_seg_type = NO_CHECK_TYPE;

	map.m_may_create = false;



	for (; nr_pages; nr_pages--) {

		if (pages) {

			page = list_last_entry(pages, struct page, lru);



			prefetchw(&page->flags);

			list_del(&page->lru);

			if (add_to_page_cache_lru(page, mapping,

						  page->index,

						  readahead_gfp_mask(mapping)))

				goto next_page;

		}

	int ret = 0;



	block_in_file = (sector_t)page->index;

	last_block = block_in_file + nr_pages;
@@ -1563,23 +1534,24 @@ static int f2fs_mpage_readpages(struct address_space *mapping, 
	/*

	 * Map blocks using the previous result first.

	 */

		if ((map.m_flags & F2FS_MAP_MAPPED) &&

				block_in_file > map.m_lblk &&

				block_in_file < (map.m_lblk + map.m_len))

	if ((map->m_flags & F2FS_MAP_MAPPED) &&

			block_in_file > map->m_lblk &&

			block_in_file < (map->m_lblk + map->m_len))

		goto got_it;



	/*

	 * Then do more f2fs_map_blocks() calls until we are

	 * done with this page.

	 */

		map.m_lblk = block_in_file;

		map.m_len = last_block - block_in_file;

	map->m_lblk = block_in_file;

	map->m_len = last_block - block_in_file;



		if (f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_DEFAULT))

			goto set_error_page;

	ret = f2fs_map_blocks(inode, map, 0, F2FS_GET_BLOCK_DEFAULT);

	if (ret)

		goto out;

got_it:

		if ((map.m_flags & F2FS_MAP_MAPPED)) {

			block_nr = map.m_pblk + block_in_file - map.m_lblk;

	if ((map->m_flags & F2FS_MAP_MAPPED)) {

		block_nr = map->m_pblk + block_in_file - map->m_lblk;

		SetPageMappedToDisk(page);



		if (!PageUptodate(page) && !cleancache_get_page(page)) {
@@ -1588,22 +1560,24 @@ static int f2fs_mpage_readpages(struct address_space *mapping, 
		}



		if (!f2fs_is_valid_blkaddr(F2FS_I_SB(inode), block_nr,

								DATA_GENERIC))

				goto set_error_page;

							DATA_GENERIC)) {

			ret = -EFAULT;

			goto out;

		}

	} else {

zero_out:

		zero_user_segment(page, 0, PAGE_SIZE);

		if (!PageUptodate(page))

			SetPageUptodate(page);

		unlock_page(page);

			goto next_page;

		goto out;

	}



	/*

	 * This page will go to BIO.  Do we need to send this

	 * BIO off first?

	 */

		if (bio && (last_block_in_bio != block_nr - 1 ||

	if (bio && (*last_block_in_bio != block_nr - 1 ||

		!__same_bdev(F2FS_I_SB(inode), block_nr, bio))) {

submit_and_realloc:

		__submit_bio(F2FS_I_SB(inode), bio, DATA);
@@ -1613,8 +1587,9 @@ static int f2fs_mpage_readpages(struct address_space *mapping, 
		bio = f2fs_grab_read_bio(inode, block_nr, nr_pages,

				is_readahead ? REQ_RAHEAD : 0);

		if (IS_ERR(bio)) {

			ret = PTR_ERR(bio);

			bio = NULL;

				goto set_error_page;

			goto out;

		}

	}
@@ -1629,19 +1604,66 @@ static int f2fs_mpage_readpages(struct address_space *mapping, 


	inc_page_count(F2FS_I_SB(inode), F2FS_RD_DATA);

	ClearPageError(page);

		last_block_in_bio = block_nr;

		goto next_page;

set_error_page:

		SetPageError(page);

		zero_user_segment(page, 0, PAGE_SIZE);

		unlock_page(page);

		goto next_page;

	*last_block_in_bio = block_nr;

	goto out;

confused:

	if (bio) {

		__submit_bio(F2FS_I_SB(inode), bio, DATA);

		bio = NULL;

	}

	unlock_page(page);

out:

	*bio_ret = bio;

	return ret;

}



/*

 * This function was originally taken from fs/mpage.c, and customized for f2fs.

 * Major change was from block_size == page_size in f2fs by default.

 *

 * Note that the aops->readpages() function is ONLY used for read-ahead. If

 * this function ever deviates from doing just read-ahead, it should either

 * use ->readpage() or do the necessary surgery to decouple ->readpages()

 * from read-ahead.

 */

static int f2fs_mpage_readpages(struct address_space *mapping,

			struct list_head *pages, struct page *page,

			unsigned nr_pages, bool is_readahead)

{

	struct bio *bio = NULL;

	sector_t last_block_in_bio = 0;

	struct inode *inode = mapping->host;

	struct f2fs_map_blocks map;

	int ret = 0;



	map.m_pblk = 0;

	map.m_lblk = 0;

	map.m_len = 0;

	map.m_flags = 0;

	map.m_next_pgofs = NULL;

	map.m_next_extent = NULL;

	map.m_seg_type = NO_CHECK_TYPE;

	map.m_may_create = false;



	for (; nr_pages; nr_pages--) {

		if (pages) {

			page = list_last_entry(pages, struct page, lru);



			prefetchw(&page->flags);

			list_del(&page->lru);

			if (add_to_page_cache_lru(page, mapping,

						  page->index,

						  readahead_gfp_mask(mapping)))

				goto next_page;

		}



		ret = f2fs_read_single_page(inode, page, nr_pages, &map, &bio,

					&last_block_in_bio, is_readahead);

		if (ret) {

			SetPageError(page);

			zero_user_segment(page, 0, PAGE_SIZE);

			unlock_page(page);

		}

next_page:

		if (pages)

			put_page(page);
@@ -1649,7 +1671,7 @@ static int f2fs_mpage_readpages(struct address_space *mapping, 
	BUG_ON(pages && !list_empty(pages));

	if (bio)

		__submit_bio(F2FS_I_SB(inode), bio, DATA);

	return 0;

	return pages ? 0 : ret;

}



static int f2fs_read_data_page(struct file *file, struct page *page)