Kernel/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2025-01-01 10:45:49 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

jfs: Convert metapage_writepage to metapage_write_folio

Browse Source 
Implement writepages rather than writepage by using write_cache_pages()
to call metapage_write_folio().  Use bio_add_folio_nofail() as we know
we just allocated the bio.  Replace the call to SetPageError (which
is never checked) with a call to mapping_set_error (which ... might be
checked somewhere?)

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Signed-off-by: Dave Kleikamp <dave.kleikamp@oracle.com>
This commit is contained in:
Matthew Wilcox (Oracle) 2024-04-17 18:56:46 +01:00 committed by Dave Kleikamp
parent 9b4b3f8441
commit 35474d52c6
1 changed files with 41 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

75
fs/jfs/jfs_metapage.c
View File

@ -4,6 +4,7 @@
* Portions Copyright (C) Christoph Hellwig, 2001-2002 * Portions Copyright (C) Christoph Hellwig, 2001-2002
*/ */
#include <linux/blkdev.h>
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/mm.h> #include <linux/mm.h>
#include <linux/module.h> #include <linux/module.h>
@ -321,23 +322,25 @@ static void last_write_complete(struct page *page)
static void metapage_write_end_io(struct bio *bio) static void metapage_write_end_io(struct bio *bio)
{ {
struct page *page = bio->bi_private; struct folio *folio = bio->bi_private;
BUG_ON(!PagePrivate(page)); BUG_ON(!folio->private);
if (bio->bi_status) { if (bio->bi_status) {
int err = blk_status_to_errno(bio->bi_status);
printk(KERN_ERR "metapage_write_end_io: I/O error\n"); printk(KERN_ERR "metapage_write_end_io: I/O error\n");
SetPageError(page); mapping_set_error(folio->mapping, err);
} }
dec_io(page, last_write_complete); dec_io(&folio->page, last_write_complete);
bio_put(bio); bio_put(bio);
} }
static int metapage_writepage(struct page *page, struct writeback_control *wbc) static int metapage_write_folio(struct folio *folio,
struct writeback_control *wbc, void *unused)
{ {
struct bio *bio = NULL; struct bio *bio = NULL;
int block_offset; /* block offset of mp within page */ int block_offset; /* block offset of mp within page */
struct inode *inode = page->mapping->host; struct inode *inode = folio->mapping->host;
int blocks_per_mp = JFS_SBI(inode->i_sb)->nbperpage; int blocks_per_mp = JFS_SBI(inode->i_sb)->nbperpage;
int len; int len;
int xlen; int xlen;
@ -353,14 +356,13 @@ static int metapage_writepage(struct page *page, struct writeback_control *wbc)
int offset; int offset;
int bad_blocks = 0; int bad_blocks = 0;
page_start = (sector_t)page->index << page_start = folio_pos(folio) >> inode->i_blkbits;
(PAGE_SHIFT - inode->i_blkbits); BUG_ON(!folio_test_locked(folio));
BUG_ON(!PageLocked(page)); BUG_ON(folio_test_writeback(folio));
BUG_ON(PageWriteback(page)); folio_start_writeback(folio);
set_page_writeback(page);
for (offset = 0; offset < PAGE_SIZE; offset += PSIZE) { for (offset = 0; offset < PAGE_SIZE; offset += PSIZE) {
mp = page_to_mp(page, offset); mp = page_to_mp(&folio->page, offset);
if (!mp || !test_bit(META_dirty, &mp->flag)) if (!mp || !test_bit(META_dirty, &mp->flag))
continue; continue;
@ -389,22 +391,20 @@ static int metapage_writepage(struct page *page, struct writeback_control *wbc)
continue; continue;
} }
/* Not contiguous */ /* Not contiguous */
if (bio_add_page(bio, page, bio_bytes, bio_offset) < bio_add_folio_nofail(bio, folio, bio_bytes, bio_offset);
bio_bytes)
goto add_failed;
/* /*
* Increment counter before submitting i/o to keep * Increment counter before submitting i/o to keep
* count from hitting zero before we're through * count from hitting zero before we're through
*/ */
inc_io(page); inc_io(&folio->page);
if (!bio->bi_iter.bi_size) if (!bio->bi_iter.bi_size)
goto dump_bio; goto dump_bio;
submit_bio(bio); submit_bio(bio);
nr_underway++; nr_underway++;
bio = NULL; bio = NULL;
} else } else
inc_io(page); inc_io(&folio->page);
xlen = (PAGE_SIZE - offset) >> inode->i_blkbits; xlen = (folio_size(folio) - offset) >> inode->i_blkbits;
pblock = metapage_get_blocks(inode, lblock, &xlen); pblock = metapage_get_blocks(inode, lblock, &xlen);
if (!pblock) { if (!pblock) {
printk(KERN_ERR "JFS: metapage_get_blocks failed\n"); printk(KERN_ERR "JFS: metapage_get_blocks failed\n");
@ -420,7 +420,7 @@ static int metapage_writepage(struct page *page, struct writeback_control *wbc)
bio = bio_alloc(inode->i_sb->s_bdev, 1, REQ_OP_WRITE, GFP_NOFS); bio = bio_alloc(inode->i_sb->s_bdev, 1, REQ_OP_WRITE, GFP_NOFS);
bio->bi_iter.bi_sector = pblock << (inode->i_blkbits - 9); bio->bi_iter.bi_sector = pblock << (inode->i_blkbits - 9);
bio->bi_end_io = metapage_write_end_io; bio->bi_end_io = metapage_write_end_io;
bio->bi_private = page; bio->bi_private = folio;
/* Don't call bio_add_page yet, we may add to this vec */ /* Don't call bio_add_page yet, we may add to this vec */
bio_offset = offset; bio_offset = offset;
@ -430,8 +430,7 @@ static int metapage_writepage(struct page *page, struct writeback_control *wbc)
next_block = lblock + len; next_block = lblock + len;
} }
if (bio) { if (bio) {
if (bio_add_page(bio, page, bio_bytes, bio_offset) < bio_bytes) bio_add_folio_nofail(bio, folio, bio_bytes, bio_offset);
goto add_failed;
if (!bio->bi_iter.bi_size) if (!bio->bi_iter.bi_size)
goto dump_bio; goto dump_bio;
@ -439,34 +438,42 @@ static int metapage_writepage(struct page *page, struct writeback_control *wbc)
nr_underway++; nr_underway++;
} }
if (redirty) if (redirty)
redirty_page_for_writepage(wbc, page); folio_redirty_for_writepage(wbc, folio);
unlock_page(page); folio_unlock(folio);
if (bad_blocks) if (bad_blocks)
goto err_out; goto err_out;
if (nr_underway == 0) if (nr_underway == 0)
end_page_writeback(page); folio_end_writeback(folio);
return 0; return 0;
add_failed:
/* We should never reach here, since we're only adding one vec */
printk(KERN_ERR "JFS: bio_add_page failed unexpectedly\n");
goto skip;
dump_bio: dump_bio:
print_hex_dump(KERN_ERR, "JFS: dump of bio: ", DUMP_PREFIX_ADDRESS, 16, print_hex_dump(KERN_ERR, "JFS: dump of bio: ", DUMP_PREFIX_ADDRESS, 16,
4, bio, sizeof(*bio), 0); 4, bio, sizeof(*bio), 0);
skip:
bio_put(bio); bio_put(bio);
unlock_page(page); folio_unlock(folio);
dec_io(page, last_write_complete); dec_io(&folio->page, last_write_complete);
err_out: err_out:
while (bad_blocks--) while (bad_blocks--)
dec_io(page, last_write_complete); dec_io(&folio->page, last_write_complete);
return -EIO; return -EIO;
} }
static int metapage_writepages(struct address_space *mapping,
struct writeback_control *wbc)
{
struct blk_plug plug;
int err;
blk_start_plug(&plug);
err = write_cache_pages(mapping, wbc, metapage_write_folio, NULL);
blk_finish_plug(&plug);
return err;
}
static int metapage_read_folio(struct file *fp, struct folio *folio) static int metapage_read_folio(struct file *fp, struct folio *folio)
{ {
struct inode *inode = folio->mapping->host; struct inode *inode = folio->mapping->host;
@ -556,7 +563,7 @@ static void metapage_invalidate_folio(struct folio *folio, size_t offset,
const struct address_space_operations jfs_metapage_aops = { const struct address_space_operations jfs_metapage_aops = {
.read_folio = metapage_read_folio, .read_folio = metapage_read_folio,
.writepage = metapage_writepage, .writepages = metapage_writepages,
.release_folio = metapage_release_folio, .release_folio = metapage_release_folio,
.invalidate_folio = metapage_invalidate_folio, .invalidate_folio = metapage_invalidate_folio,
.dirty_folio = filemap_dirty_folio, .dirty_folio = filemap_dirty_folio,
@ -698,7 +705,7 @@ static int metapage_write_one(struct page *page)
if (folio_clear_dirty_for_io(folio)) { if (folio_clear_dirty_for_io(folio)) {
folio_get(folio); folio_get(folio);
ret = metapage_writepage(page, &wbc); ret = metapage_write_folio(folio, &wbc, NULL);
if (ret == 0) if (ret == 0)
folio_wait_writeback(folio); folio_wait_writeback(folio);
folio_put(folio); folio_put(folio);