Preston_PLB
/
kernel-aes67
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

block: Remove special-casing of compound pages 

The special casing was originally added in pre-git history; reproducing
the commit log here:

> commit a318a92567d77
> Author: Andrew Morton <akpm@osdl.org>
> Date:   Sun Sep 21 01:42:22 2003 -0700
>
>     [PATCH] Speed up direct-io hugetlbpage handling
>
>     This patch short-circuits all the direct-io page dirtying logic for
>     higher-order pages.  Without this, we pointlessly bounce BIOs up to
>     keventd all the time.

In the last twenty years, compound pages have become used for more than
just hugetlb.  Rewrite these functions to operate on folios instead
of pages and remove the special case for hugetlbfs; I don't think
it's needed any more (and if it is, we can put it back in as a call
to folio_test_hugetlb()).

This was found by inspection; as far as I can tell, this bug can lead
to pages used as the destination of a direct I/O read not being marked
as dirty.  If those pages are then reclaimed by the MM without being
dirtied for some other reason, they won't be written out.  Then when
they're faulted back in, they will not contain the data they should.
It'll take a pretty unusual setup to produce this problem with several
races all going the wrong way.

This problem predates the folio work; it could for example have been
triggered by mmaping a THP in tmpfs and using that as the target of an
O_DIRECT read.

Fixes: 800d8c63b2 ("shmem: add huge pages support")
Cc:  <stable@vger.kernel.org>
Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
This commit is contained in:
Matthew Wilcox (Oracle) 2023-08-14 15:41:00 +01:00 committed by Jens Axboe
parent 847c5bcdfb
commit 1b151e2435
1 changed files with 24 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
block/bio.c
View File

@ -1145,13 +1145,22 @@ EXPORT_SYMBOL(bio_add_folio);
void __bio_release_pages(struct bio *bio, bool mark_dirty) void __bio_release_pages(struct bio *bio, bool mark_dirty)
{ {
struct bvec_iter_all iter_all; struct folio_iter fi;
struct bio_vec *bvec;
bio_for_each_segment_all(bvec, bio, iter_all) { bio_for_each_folio_all(fi, bio) {
if (mark_dirty && !PageCompound(bvec->bv_page)) struct page *page;
set_page_dirty_lock(bvec->bv_page); size_t done = 0;
bio_release_page(bio, bvec->bv_page);
if (mark_dirty) {
folio_lock(fi.folio);
folio_mark_dirty(fi.folio);
folio_unlock(fi.folio);
}
page = folio_page(fi.folio, fi.offset / PAGE_SIZE);
do {
bio_release_page(bio, page++);
done += PAGE_SIZE;
} while (done < fi.length);
} }
} }
EXPORT_SYMBOL_GPL(__bio_release_pages); EXPORT_SYMBOL_GPL(__bio_release_pages);
@ -1439,18 +1448,12 @@ EXPORT_SYMBOL(bio_free_pages);
* bio_set_pages_dirty() and bio_check_pages_dirty() are support functions * bio_set_pages_dirty() and bio_check_pages_dirty() are support functions
* for performing direct-IO in BIOs. * for performing direct-IO in BIOs.
* *
* The problem is that we cannot run set_page_dirty() from interrupt context * The problem is that we cannot run folio_mark_dirty() from interrupt context
* because the required locks are not interrupt-safe. So what we can do is to * because the required locks are not interrupt-safe. So what we can do is to
* mark the pages dirty _before_ performing IO. And in interrupt context, * mark the pages dirty _before_ performing IO. And in interrupt context,
* check that the pages are still dirty. If so, fine. If not, redirty them * check that the pages are still dirty. If so, fine. If not, redirty them
* in process context. * in process context.
* *
* We special-case compound pages here: normally this means reads into hugetlb
* pages. The logic in here doesn't really work right for compound pages
* because the VM does not uniformly chase down the head page in all cases.
* But dirtiness of compound pages is pretty meaningless anyway: the VM doesn't
* handle them at all. So we skip compound pages here at an early stage.
*
* Note that this code is very hard to test under normal circumstances because * Note that this code is very hard to test under normal circumstances because
* direct-io pins the pages with get_user_pages(). This makes * direct-io pins the pages with get_user_pages(). This makes
* is_page_cache_freeable return false, and the VM will not clean the pages. * is_page_cache_freeable return false, and the VM will not clean the pages.
@ -1466,12 +1469,12 @@ EXPORT_SYMBOL(bio_free_pages);
*/ */
void bio_set_pages_dirty(struct bio *bio) void bio_set_pages_dirty(struct bio *bio)
{ {
struct bio_vec *bvec; struct folio_iter fi;
struct bvec_iter_all iter_all;
bio_for_each_segment_all(bvec, bio, iter_all) { bio_for_each_folio_all(fi, bio) {
if (!PageCompound(bvec->bv_page)) folio_lock(fi.folio);
set_page_dirty_lock(bvec->bv_page); folio_mark_dirty(fi.folio);
folio_unlock(fi.folio);
} }
} }
EXPORT_SYMBOL_GPL(bio_set_pages_dirty); EXPORT_SYMBOL_GPL(bio_set_pages_dirty);
@ -1515,12 +1518,11 @@ static void bio_dirty_fn(struct work_struct *work)
void bio_check_pages_dirty(struct bio *bio) void bio_check_pages_dirty(struct bio *bio)
{ {
struct bio_vec *bvec; struct folio_iter fi;
unsigned long flags; unsigned long flags;
struct bvec_iter_all iter_all;
bio_for_each_segment_all(bvec, bio, iter_all) { bio_for_each_folio_all(fi, bio) {
if (!PageDirty(bvec->bv_page) && !PageCompound(bvec->bv_page)) if (!folio_test_dirty(fi.folio))
goto defer; goto defer;
} }