dummy/linux-stable-mirror
1
0
Fork 1
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/ synced 2025-04-19 20:58:31 +09:00
Code Issues Packages Projects Releases Wiki Activity

squashfs; convert squashfs_copy_cache() to take a folio

Browse Source 
Remove accesses to page->index and page->mapping.  Also use folio
APIs where available.  This code still assumes order 0 folios.

[dan.carpenter@linaro.org: fix a NULL vs IS_ERR() bug]
  Link: https://lkml.kernel.org/r/7b7f44d6-9153-4d7c-b65b-2d78febe6c7a@stanley.mountain
Link: https://lkml.kernel.org/r/20241220224634.723899-4-willy@infradead.org
Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Signed-off-by: Dan Carpenter <dan.carpenter@linaro.org>
Cc: Phillip Lougher <phillip@squashfs.org.uk>
Cc: Dan Carpenter <dan.carpenter@linaro.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
This commit is contained in:
Matthew Wilcox (Oracle) 2024-12-20 22:46:27 +00:00 committed by Andrew Morton
parent 2a7aea59cf
commit 5641371fd0
3 changed files with 28 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
fs/squashfs/file.c
View File

@ -378,13 +378,15 @@ void squashfs_fill_page(struct page *page, struct squashfs_cache_entry *buffer,
}
/* Copy data into page cache */
void squashfs_copy_cache(struct page *page, struct squashfs_cache_entry *buffer,
int bytes, int offset)
void squashfs_copy_cache(struct folio *folio,
struct squashfs_cache_entry *buffer, size_t bytes,
size_t offset)
{
struct inode *inode = page->mapping->host;
struct address_space *mapping = folio->mapping;
struct inode *inode = mapping->host;
struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
int i, mask = (1 << (msblk->block_log - PAGE_SHIFT)) - 1;
int start_index = page->index & ~mask, end_index = start_index | mask;
int start_index = folio->index & ~mask, end_index = start_index | mask;
/*
* Loop copying datablock into pages. As the datablock likely covers
@ -394,25 +396,27 @@ void squashfs_copy_cache(struct page *page, struct squashfs_cache_entry *buffer,
*/
for (i = start_index; i <= end_index && bytes > 0; i++,
bytes -= PAGE_SIZE, offset += PAGE_SIZE) {
struct page *push_page;
int avail = buffer ? min_t(int, bytes, PAGE_SIZE) : 0;
struct folio *push_folio;
size_t avail = buffer ? min(bytes, PAGE_SIZE) : 0;
TRACE("bytes %d, i %d, available_bytes %d\n", bytes, i, avail);
TRACE("bytes %zu, i %d, available_bytes %zu\n", bytes, i, avail);
push_page = (i == page->index) ? page :
grab_cache_page_nowait(page->mapping, i);
push_folio = (i == folio->index) ? folio :
__filemap_get_folio(mapping, i,
FGP_LOCK|FGP_CREAT|FGP_NOFS|FGP_NOWAIT,
mapping_gfp_mask(mapping));
if (!push_page)
if (IS_ERR(push_folio))
continue;
if (PageUptodate(push_page))
goto skip_page;
if (folio_test_uptodate(push_folio))
goto skip_folio;
squashfs_fill_page(push_page, buffer, offset, avail);
skip_page:
unlock_page(push_page);
if (i != page->index)
put_page(push_page);
squashfs_fill_page(&push_folio->page, buffer, offset, avail);
skip_folio:
folio_unlock(push_folio);
if (i != folio->index)
folio_put(push_folio);
}
}
@ -430,16 +434,16 @@ static int squashfs_readpage_fragment(struct folio *folio, int expected)
squashfs_i(inode)->fragment_block,
squashfs_i(inode)->fragment_size);
else
squashfs_copy_cache(&folio->page, buffer, expected,
squashfs_copy_cache(folio, buffer, expected,
squashfs_i(inode)->fragment_offset);
squashfs_cache_put(buffer);
return res;
}
static int squashfs_readpage_sparse(struct page *page, int expected)
static int squashfs_readpage_sparse(struct folio *folio, int expected)
{
squashfs_copy_cache(page, NULL, expected, 0);
squashfs_copy_cache(folio, NULL, expected, 0);
return 0;
}
@ -470,7 +474,7 @@ static int squashfs_read_folio(struct file *file, struct folio *folio)
goto out;
if (res == 0)
res = squashfs_readpage_sparse(&folio->page, expected);
res = squashfs_readpage_sparse(folio, expected);
else
res = squashfs_readpage_block(folio, block, res, expected);
} else

2
fs/squashfs/file_cache.c
View File

@ -29,7 +29,7 @@ int squashfs_readpage_block(struct folio *folio, u64 block, int bsize, int expec
ERROR("Unable to read page, block %llx, size %x\n", block,
bsize);
else
squashfs_copy_cache(&folio->page, buffer, expected, 0);
squashfs_copy_cache(folio, buffer, expected, 0);
squashfs_cache_put(buffer);
return res;

4
fs/squashfs/squashfs.h
View File

@ -74,8 +74,8 @@ extern __le64 *squashfs_read_fragment_index_table(struct super_block *,
/* file.c */
void squashfs_fill_page(struct page *, struct squashfs_cache_entry *, int, int);
void squashfs_copy_cache(struct page *, struct squashfs_cache_entry *, int,
int);
void squashfs_copy_cache(struct folio *, struct squashfs_cache_entry *,
size_t bytes, size_t offset);
/* file_xxx.c */
int squashfs_readpage_block(struct folio *, u64 block, int bsize, int expected);