On Mon, 23 Nov 2020, Hugh Dickins wrote: > On Mon, 23 Nov 2020, Linus Torvalds wrote: > > > > IOW, why couldn't we just make the __test_set_page_writeback() > > increment the page count if the writeback flag wasn't already set, and > > then make the end_page_writeback() do a put_page() after it all? > > Right, that should be a lot simpler, and will not require any of the > cleanup (much as I liked that). If you're reasonably confident that > adding the extra get_page+put_page to every writeback (instead of > just to the waited case, which I presume significantly less common) > will get lost in the noise - I was not confident of that, nor > confident of devising realistic tests to decide it. > > What I did look into before sending, was whether in the filesystems > there was a pattern of doing a put_page() after *set_page_writeback(), > when it would just be a matter of deleting that put_page() and doing > it instead at the end of end_page_writeback(). But no: there were a > few cases like that, but in general no such pattern. > > Though, what I think I'll try is not quite what you suggest there, > but instead do both get_page() and put_page() in end_page_writeback(). > The reason being, there are a number of places (in mm at least) where > we judge what to do by the expected refcount: places that know to add > 1 on when PagePrivate is set (for buffers), but do not expect to add > 1 on when PageWriteback is set. Now, all of those places probably > have to have their own wait_on_page_writeback() too, but I'd rather > narrow the window when the refcount is raised, than work through > what if any change would be needed in those places. This ran fine overnight on several machines - just to check I hadn't screwed it up. Vanishingly unlikely to have hit either condition, nor would I have noticed any difference in performance. [PATCH] mm: fix VM_BUG_ON(PageTail) and BUG_ON(PageWriteback) Twice now, when exercising ext4 looped on shmem huge pages, I have crashed on the PF_ONLY_HEAD check inside PageWaiters(): ext4_finish_bio() calling end_page_writeback() calling wake_up_page() on tail of a shmem huge page, no longer an ext4 page at all. The problem is that PageWriteback is not accompanied by a page reference (as the NOTE at the end of test_clear_page_writeback() acknowledges): as soon as TestClearPageWriteback has been done, that page could be removed from page cache, freed, and reused for something else by the time that wake_up_page() is reached. https://lore.kernel.org/linux-mm/20200827122019.GC14765@xxxxxxxxxxxxxxxxxxxx/ Matthew Wilcox suggested avoiding or weakening the PageWaiters() tail check; but I'm paranoid about even looking at an unreferenced struct page, lest its memory might itself have already been reused or hotremoved (and wake_up_page_bit() may modify that memory with its ClearPageWaiters()). Then on crashing a second time, realized there's a stronger reason against that approach. If my testing just occasionally crashes on that check, when the page is reused for part of a compound page, wouldn't it be much more common for the page to get reused as an order-0 page before reaching wake_up_page()? And on rare occasions, might that reused page already be marked PageWriteback by its new user, and already be waited upon? What would that look like? It would look like BUG_ON(PageWriteback) after wait_on_page_writeback() in write_cache_pages() (though I have never seen that crash myself). And prior to 2a9127fcf229 ("mm: rewrite wait_on_page_bit_common() logic") this would have been much less likely: before that, wake_page_function()'s non-exclusive case would stop walking and not wake if it found Writeback already set again; whereas now the non-exclusive case proceeds to wake. I have not thought of a fix that does not add a little overhead: the simplest fix is for end_page_writeback() to get_page() before calling test_clear_page_writeback(), then put_page() after wake_up_page(). Was there a chance of missed wakeups before, since a page freed before reaching wake_up_page() would have PageWaiters cleared? I think not, because each waiter does hold a reference on the page. This bug comes when the old use of the page, the one we do TestClearPageWriteback on, had *no* waiters, so no additional page reference beyond the page cache (and whoever racily freed it). The reuse of the page has a waiter holding a reference, and its own PageWriteback set; but the belated wake_up_page() has woken the reuse to hit that BUG_ON(PageWriteback). Reported-by: syzbot+3622cea378100f45d59f@xxxxxxxxxxxxxxxxxxxxxxxxx Reported-by: Qian Cai <cai@xxxxxx> Fixes: 2a9127fcf229 ("mm: rewrite wait_on_page_bit_common() logic") Signed-off-by: Hugh Dickins <hughd@xxxxxxxxxx> Cc: stable@xxxxxxxxxxxxxxx # v5.8+ --- mm/filemap.c | 8 ++++++++ mm/page-writeback.c | 6 ------ 2 files changed, 8 insertions(+), 6 deletions(-) --- 5.10-rc5/mm/filemap.c 2020-11-22 17:43:01.637279974 -0800 +++ linux/mm/filemap.c 2020-11-23 23:08:20.141851113 -0800 @@ -1484,11 +1484,19 @@ void end_page_writeback(struct page *pag rotate_reclaimable_page(page); } + /* + * Writeback does not hold a page reference of its own, relying + * on truncation to wait for the clearing of PG_writeback. + * But here we must make sure that the page is not freed and + * reused before the wake_up_page(). + */ + get_page(page); if (!test_clear_page_writeback(page)) BUG(); smp_mb__after_atomic(); wake_up_page(page, PG_writeback); + put_page(page); } EXPORT_SYMBOL(end_page_writeback); --- 5.10-rc5/mm/page-writeback.c 2020-10-25 16:45:47.977843485 -0700 +++ linux/mm/page-writeback.c 2020-11-23 23:08:20.141851113 -0800 @@ -2754,12 +2754,6 @@ int test_clear_page_writeback(struct pag } else { ret = TestClearPageWriteback(page); } - /* - * NOTE: Page might be free now! Writeback doesn't hold a page - * reference on its own, it relies on truncation to wait for - * the clearing of PG_writeback. The below can only access - * page state that is static across allocation cycles. - */ if (ret) { dec_lruvec_state(lruvec, NR_WRITEBACK); dec_zone_page_state(page, NR_ZONE_WRITE_PENDING);
