Commit 34113026 authored by Matthew Wilcox (Oracle)'s avatar Matthew Wilcox (Oracle) Committed by Andrew Morton
Browse files

affs: convert data read and write to use folios 

We still need to convert to/from folios in write_begin & write_end to fit
the API, but this removes a lot of calls to old page-based functions,
removing many hidden calls to compound_head().

Link: https://lkml.kernel.org/r/20230713035512.4139457-4-willy@infradead.org


Signed-off-by: default avatarMatthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: default avatarPankaj Raghav <p.raghav@samsung.com>
Acked-by: default avatarDavid Sterba <dsterba@suse.com>
Cc: Alexander Viro <viro@zeniv.linux.org.uk>
Cc: Christian Brauner <brauner@kernel.org>
Cc: Jan Kara <jack@suse.com>
Cc: Konstantin Komarov <almaz.alexandrovich@paragon-software.com>
Cc: Nathan Chancellor <nathan@kernel.org>
Cc: Nick Desaulniers <ndesaulniers@google.com>
Cc: "Theodore Ts'o" <tytso@mit.edu>
Cc: Tom Rix <trix@redhat.com>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
parent 41a638a1

fs/affs/file.c

+38 −39
Original line number Diff line number Diff line
@@ -520,21 +520,20 @@ affs_getemptyblk_ino(struct inode *inode, int block) 
	return ERR_PTR(err);

}



static int

affs_do_readpage_ofs(struct page *page, unsigned to, int create)

static int affs_do_read_folio_ofs(struct folio *folio, size_t to, int create)

{

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

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

	struct super_block *sb = inode->i_sb;

	struct buffer_head *bh;

	unsigned pos = 0;

	u32 bidx, boff, bsize;

	size_t pos = 0;

	size_t bidx, boff, bsize;

	u32 tmp;



	pr_debug("%s(%lu, %ld, 0, %d)\n", __func__, inode->i_ino,

		 page->index, to);

	BUG_ON(to > PAGE_SIZE);

	pr_debug("%s(%lu, %ld, 0, %zu)\n", __func__, inode->i_ino,

		 folio->index, to);

	BUG_ON(to > folio_size(folio));

	bsize = AFFS_SB(sb)->s_data_blksize;

	tmp = page->index << PAGE_SHIFT;

	tmp = folio_pos(folio);

	bidx = tmp / bsize;

	boff = tmp % bsize;
@@ -544,7 +543,7 @@ affs_do_readpage_ofs(struct page *page, unsigned to, int create) 
			return PTR_ERR(bh);

		tmp = min(bsize - boff, to - pos);

		BUG_ON(pos + tmp > to || tmp > bsize);

		memcpy_to_page(page, pos, AFFS_DATA(bh) + boff, tmp);

		memcpy_to_folio(folio, pos, AFFS_DATA(bh) + boff, tmp);

		affs_brelse(bh);

		bidx++;

		pos += tmp;
@@ -624,25 +623,23 @@ affs_extent_file_ofs(struct inode *inode, u32 newsize) 
	return PTR_ERR(bh);

}



static int

affs_read_folio_ofs(struct file *file, struct folio *folio)

static int affs_read_folio_ofs(struct file *file, struct folio *folio)

{

	struct page *page = &folio->page;

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

	u32 to;

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

	size_t to;

	int err;



	pr_debug("%s(%lu, %ld)\n", __func__, inode->i_ino, page->index);

	to = PAGE_SIZE;

	if (((page->index + 1) << PAGE_SHIFT) > inode->i_size) {

		to = inode->i_size & ~PAGE_MASK;

		memset(page_address(page) + to, 0, PAGE_SIZE - to);

	pr_debug("%s(%lu, %ld)\n", __func__, inode->i_ino, folio->index);

	to = folio_size(folio);

	if (folio_pos(folio) + to > inode->i_size) {

		to = inode->i_size - folio_pos(folio);

		folio_zero_segment(folio, to, folio_size(folio));

	}



	err = affs_do_readpage_ofs(page, to, 0);

	err = affs_do_read_folio_ofs(folio, to, 0);

	if (!err)

		SetPageUptodate(page);

	unlock_page(page);

		folio_mark_uptodate(folio);

	folio_unlock(folio);

	return err;

}
@@ -651,7 +648,7 @@ static int affs_write_begin_ofs(struct file *file, struct address_space *mapping 
				struct page **pagep, void **fsdata)

{

	struct inode *inode = mapping->host;

	struct page *page;

	struct folio *folio;

	pgoff_t index;

	int err = 0;
@@ -667,19 +664,20 @@ static int affs_write_begin_ofs(struct file *file, struct address_space *mapping 
	}



	index = pos >> PAGE_SHIFT;

	page = grab_cache_page_write_begin(mapping, index);

	if (!page)

		return -ENOMEM;

	*pagep = page;

	folio = __filemap_get_folio(mapping, index, FGP_WRITEBEGIN,

			mapping_gfp_mask(mapping));

	if (IS_ERR(folio))

		return PTR_ERR(folio);

	*pagep = &folio->page;



	if (PageUptodate(page))

	if (folio_test_uptodate(folio))

		return 0;



	/* XXX: inefficient but safe in the face of short writes */

	err = affs_do_readpage_ofs(page, PAGE_SIZE, 1);

	err = affs_do_read_folio_ofs(folio, folio_size(folio), 1);

	if (err) {

		unlock_page(page);

		put_page(page);

		folio_unlock(folio);

		folio_put(folio);

	}

	return err;

}
@@ -688,6 +686,7 @@ static int affs_write_end_ofs(struct file *file, struct address_space *mapping, 
				loff_t pos, unsigned len, unsigned copied,

				struct page *page, void *fsdata)

{

	struct folio *folio = page_folio(page);

	struct inode *inode = mapping->host;

	struct super_block *sb = inode->i_sb;

	struct buffer_head *bh, *prev_bh;
@@ -701,18 +700,18 @@ static int affs_write_end_ofs(struct file *file, struct address_space *mapping, 
	to = from + len;

	/*

	 * XXX: not sure if this can handle short copies (len < copied), but

	 * we don't have to, because the page should always be uptodate here,

	 * we don't have to, because the folio should always be uptodate here,

	 * due to write_begin.

	 */



	pr_debug("%s(%lu, %llu, %llu)\n", __func__, inode->i_ino, pos,

		 pos + len);

	bsize = AFFS_SB(sb)->s_data_blksize;

	data = page_address(page);

	data = folio_address(folio);



	bh = NULL;

	written = 0;

	tmp = (page->index << PAGE_SHIFT) + from;

	tmp = (folio->index << PAGE_SHIFT) + from;

	bidx = tmp / bsize;

	boff = tmp % bsize;

	if (boff) {
@@ -804,11 +803,11 @@ static int affs_write_end_ofs(struct file *file, struct address_space *mapping, 
		from += tmp;

		bidx++;

	}

	SetPageUptodate(page);

	folio_mark_uptodate(folio);



done:

	affs_brelse(bh);

	tmp = (page->index << PAGE_SHIFT) + from;

	tmp = (folio->index << PAGE_SHIFT) + from;

	if (tmp > inode->i_size)

		inode->i_size = AFFS_I(inode)->mmu_private = tmp;
@@ -819,8 +818,8 @@ static int affs_write_end_ofs(struct file *file, struct address_space *mapping, 
	}



err_first_bh:

	unlock_page(page);

	put_page(page);

	folio_unlock(folio);

	folio_put(folio);



	return written;