Commit 12e61ce2 authored by Chao Yu's avatar Chao Yu Committed by Jaegeuk Kim
Browse files

f2fs: convert f2fs_write_begin() to use folio 

Convert to use folio, so that we can get rid of 'page->index' to
prepare for removal of 'index' field in structure page [1].

[1] https://lore.kernel.org/all/Zp8fgUSIBGQ1TN0D@casper.infradead.org/



Cc: Matthew Wilcox <willy@infradead.org>
Signed-off-by: default avatarChao Yu <chao@kernel.org>
Reviewed-by: default avatarLi Zetao <lizetao1@huawei.com>
Signed-off-by: default avatarJaegeuk Kim <jaegeuk@kernel.org>
parent 1e5df24c

fs/f2fs/data.c

+23 −21
Original line number Diff line number Diff line
@@ -3378,11 +3378,11 @@ void f2fs_write_failed(struct inode *inode, loff_t to) 
}



static int prepare_write_begin(struct f2fs_sb_info *sbi,

			struct page *page, loff_t pos, unsigned len,

			struct folio *folio, loff_t pos, unsigned int len,

			block_t *blk_addr, bool *node_changed)

{

	struct inode *inode = page->mapping->host;

	pgoff_t index = page->index;

	struct inode *inode = folio->mapping->host;

	pgoff_t index = folio->index;

	struct dnode_of_data dn;

	struct page *ipage;

	bool locked = false;
@@ -3419,13 +3419,13 @@ static int prepare_write_begin(struct f2fs_sb_info *sbi, 


	if (f2fs_has_inline_data(inode)) {

		if (pos + len <= MAX_INLINE_DATA(inode)) {

			f2fs_do_read_inline_data(page_folio(page), ipage);

			f2fs_do_read_inline_data(folio, ipage);

			set_inode_flag(inode, FI_DATA_EXIST);

			if (inode->i_nlink)

				set_page_private_inline(ipage);

			goto out;

		}

		err = f2fs_convert_inline_page(&dn, page);

		err = f2fs_convert_inline_page(&dn, folio_page(folio, 0));

		if (err || dn.data_blkaddr != NULL_ADDR)

			goto out;

	}
@@ -3518,12 +3518,12 @@ static int __reserve_data_block(struct inode *inode, pgoff_t index, 
}



static int prepare_atomic_write_begin(struct f2fs_sb_info *sbi,

			struct page *page, loff_t pos, unsigned int len,

			struct folio *folio, loff_t pos, unsigned int len,

			block_t *blk_addr, bool *node_changed, bool *use_cow)

{

	struct inode *inode = page->mapping->host;

	struct inode *inode = folio->mapping->host;

	struct inode *cow_inode = F2FS_I(inode)->cow_inode;

	pgoff_t index = page->index;

	pgoff_t index = folio->index;

	int err = 0;

	block_t ori_blk_addr = NULL_ADDR;
@@ -3566,6 +3566,7 @@ static int f2fs_write_begin(struct file *file, struct address_space *mapping, 
	struct inode *inode = mapping->host;

	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);

	struct page *page = NULL;

	struct folio *folio;

	pgoff_t index = ((unsigned long long) pos) >> PAGE_SHIFT;

	bool need_balance = false;

	bool use_cow = false;
@@ -3625,22 +3626,23 @@ static int f2fs_write_begin(struct file *file, struct address_space *mapping, 
	/* TODO: cluster can be compressed due to race with .writepage */



	*pagep = page;

	folio = page_folio(page);



	if (f2fs_is_atomic_file(inode))

		err = prepare_atomic_write_begin(sbi, page, pos, len,

		err = prepare_atomic_write_begin(sbi, folio, pos, len,

					&blkaddr, &need_balance, &use_cow);

	else

		err = prepare_write_begin(sbi, page, pos, len,

		err = prepare_write_begin(sbi, folio, pos, len,

					&blkaddr, &need_balance);

	if (err)

		goto fail;



	if (need_balance && !IS_NOQUOTA(inode) &&

			has_not_enough_free_secs(sbi, 0, 0)) {

		unlock_page(page);

		folio_unlock(folio);

		f2fs_balance_fs(sbi, true);

		lock_page(page);

		if (page->mapping != mapping) {

		folio_lock(folio);

		if (folio->mapping != mapping) {

			/* The page got truncated from under us */

			f2fs_put_page(page, 1);

			goto repeat;
@@ -3649,18 +3651,18 @@ static int f2fs_write_begin(struct file *file, struct address_space *mapping, 


	f2fs_wait_on_page_writeback(page, DATA, false, true);



	if (len == PAGE_SIZE || PageUptodate(page))

	if (len == PAGE_SIZE || folio_test_uptodate(folio))

		return 0;



	if (!(pos & (PAGE_SIZE - 1)) && (pos + len) >= i_size_read(inode) &&

	    !f2fs_verity_in_progress(inode)) {

		zero_user_segment(page, len, PAGE_SIZE);

		folio_zero_segment(folio, len, folio_size(folio));

		return 0;

	}



	if (blkaddr == NEW_ADDR) {

		zero_user_segment(page, 0, PAGE_SIZE);

		SetPageUptodate(page);

		folio_zero_segment(folio, 0, folio_size(folio));

		folio_mark_uptodate(folio);

	} else {

		if (!f2fs_is_valid_blkaddr(sbi, blkaddr,

				DATA_GENERIC_ENHANCE_READ)) {
@@ -3669,16 +3671,16 @@ static int f2fs_write_begin(struct file *file, struct address_space *mapping, 
		}

		err = f2fs_submit_page_read(use_cow ?

				F2FS_I(inode)->cow_inode : inode,

				page_folio(page), blkaddr, 0, true);

				folio, blkaddr, 0, true);

		if (err)

			goto fail;



		lock_page(page);

		if (unlikely(page->mapping != mapping)) {

		folio_lock(folio);

		if (unlikely(folio->mapping != mapping)) {

			f2fs_put_page(page, 1);

			goto repeat;

		}

		if (unlikely(!PageUptodate(page))) {

		if (unlikely(!folio_test_uptodate(folio))) {

			err = -EIO;

			goto fail;

		}