On Wed, 7 Jun 2023 20:35:05 -0700 (PDT) Hugh Dickins <hughd@xxxxxxxxxx> wrote: > On Tue, 6 Jun 2023, Gerald Schaefer wrote: > > On Mon, 5 Jun 2023 22:11:52 -0700 (PDT) > > Hugh Dickins <hughd@xxxxxxxxxx> wrote: > > > On Thu, 1 Jun 2023 15:57:51 +0200 > > > Gerald Schaefer <gerald.schaefer@xxxxxxxxxxxxx> wrote: > > > > > > > > Yes, we have 2 pagetables in one 4K page, which could result in same > > > > rcu_head reuse. It might be possible to use the cleverness from our > > > > page_table_free() function, e.g. to only do the call_rcu() once, for > > > > the case where both 2K pagetable fragments become unused, similar to > > > > how we decide when to actually call __free_page(). > > > > > > > > However, it might be much worse, and page->rcu_head from a pagetable > > > > page cannot be used at all for s390, because we also use page->lru > > > > to keep our list of free 2K pagetable fragments. I always get confused > > > > by struct page unions, so not completely sure, but it seems to me that > > > > page->rcu_head would overlay with page->lru, right? > > > > > > Sigh, yes, page->rcu_head overlays page->lru. But (please correct me if > > > I'm wrong) I think that s390 could use exactly the same technique for > > > its list of free 2K pagetable fragments as it uses for its list of THP > > > "deposited" pagetable fragments, over in arch/s390/mm/pgtable.c: use > > > the first two longs of the page table itself for threading the list. > > > > Nice idea, I think that could actually work, since we only need the empty > > 2K halves on the list. So it should be possible to store the list_head > > inside those. > > Jason quickly pointed out the flaw in my thinking there. Yes, while I had the right concerns about "the to-be-freed pagetables would still be accessible, but not really valid, if we added them back to the list, with list_heads inside them", when suggesting the approach w/o passing over the mm, I missed that we would have the very same issue already with the existing page_table_free_rcu(). Thankfully Jason was watching out! > > > > > > > > > And while it could use third and fourth longs instead, I don't see any > > > need for that: a deposited pagetable has been allocated, so would not > > > be on the list of free fragments. > > > > Correct, that should not interfere. > > > > > > > > Below is one of the grossest patches I've ever posted: gross because > > > it's a rushed attempt to see whether that is viable, while it would take > > > me longer to understand all the s390 cleverness there (even though the > > > PP AA commentary above page_table_alloc() is excellent). > > > > Sounds fair, this is also one of the grossest code we have, which is also > > why Alexander added the comment. I guess we could need even more comments > > inside the code, as it still confuses me more than it should. > > > > Considering that, you did remarkably well. Your patch seems to work fine, > > at least it survived some LTP mm tests. I will also add it to our CI runs, > > to give it some more testing. Will report tomorrow when it broke something. > > See also below for some patch comments. > > Many thanks for your effort on this patch. I don't expect the testing > of it to catch Jason's point, that I'm corrupting the page table while > it's on its way through RCU to being freed, but he's right nonetheless. Right, tests ran fine, but we would have introduced subtle issues with racing gup_fast, I guess. > > I'll integrate your fixes below into what I have here, but probably > just archive it as something to refer to later in case it might play > a part; but probably it will not - sorry for wasting your time. No worries, looking at that s390 code can never be amiss. It seems I need regular refresh, at least I'm sure I already understood it better in the past. And who knows, with Jasons recent thoughts, that "list_head inside pagetable" idea might not be dead yet. > > > > > > > > > I'm hoping the use of page->lru in arch/s390/mm/gmap.c is disjoint. > > > And cmma_init_nodat()? Ah, that's __init so I guess disjoint. > > > > cmma_init_nodat() should be disjoint, not only because it is __init, > > but also because it explicitly skips pagetable pages, so it should > > never touch page->lru of those. > > > > Not very familiar with the gmap code, it does look disjoint, and we should > > also use complete 4K pages for pagetables instead of 2K fragments there, > > but Christian or Claudio should also have a look. > > > > > > > > Gerald, s390 folk: would it be possible for you to give this > > > a try, suggest corrections and improvements, and then I can make it > > > a separate patch of the series; and work on avoiding concurrent use > > > of the rcu_head by pagetable fragment buddies (ideally fit in with > > > the scheme already there, maybe DD bits to go along with the PP AA). > > > > It feels like it could be possible to not only avoid the double > > rcu_head, but also avoid passing over the mm via page->pt_mm. > > I.e. have pte_free_defer(), which has the mm, do all the checks and > > list updates that page_table_free() does, for which we need the mm. > > Then just skip the pgtable_pte_page_dtor() + __free_page() at the end, > > and do call_rcu(pte_free_now) instead. The pte_free_now() could then > > just do _dtor/__free_page similar to the generic version. > > I'm not sure: I missed your suggestion there when I first skimmed > through, and today have spent more time getting deeper into how it's > done at present. I am now feeling more confident of a way forward, > a nicely integrated way forward, than I was yesterday. > Though getting it right may not be so easy. I think my "feeling" was a déjà vu of the existing logic that we use for page_table_free_rcu() -> __tlb_remove_table(), where we also have no mm any more at the end, and use the PP bits magic to find out if the page can be freed, or if we still have fragments left. Of course, in that case, we also would not need the mm any more for list handling, as the to-be-freed fragments were already put back on the list, but with PP bits set, to prevent re-use. And clearing those would then make the fragment usable from the list again. I guess that would also be the major difference here, i.e. your RCU call-back would need to be able to add fragments back to the list, after having them removed before to make room for page->rcu_head, but with Jasons thoughts that does not seem so impossible after all. I do not yet understand if the list_head would then compulsorily need to be inside the pagetable, because page->rcu_head/lru still cannot be used (again). But you already have a patch for that, so either way might be possible. > > When Jason pointed out the existing RCU, I initially hoped that it might > already provide the necessary framework: but sadly not, because the > unbatched case (used when additional memory is not available) does not > use RCU at all, but instead the tlb_remove_table_sync_one() IRQ hack. > If I used that, it would cripple the s390 implementation unacceptably. > > > > > I must admit that I still have no good overview of the "big picture" > > here, and especially if this approach would still fit in. Probably not, > > as the to-be-freed pagetables would still be accessible, but not really > > valid, if we added them back to the list, with list_heads inside them. > > So maybe call_rcu() has to be done always, and not only for the case > > where the whole 4K page becomes free, then we probably cannot do w/o > > passing over the mm for proper list handling. > > My current thinking (but may be proved wrong) is along the lines of: > why does something on its way to being freed need to be on any list > than the rcu_head list? I expect the current answer is, that the > other half is allocated, so the page won't be freed; but I hope that > we can put it back on that list once we're through with the rcu_head. Yes, that looks promising. Such a fragment would not necessarily need to be on the list, because while it is on its way, i.e. before the RCU call-back finished, it cannot be re-used anyway. page_table_alloc() could currently find such a fragment on the list, but only to see the PP bits set, so it will not use it. Only after __tlb_remove_table() in the RCU call-back resets the bits, it would be usable again. In your case, that could correspond to adding it back to the list. That could even be an improvement, because page_table_alloc() would not be bothered by such unusable fragments. [...] > > Is it too early to wish you a happy reverse Xmas? Nice idea, we should make June 24th the reverse Xmas Remembrance Day :-)
