Hi Catalin, Thanks for the review! Comments below... On 16/02/2024 12:25, Catalin Marinas wrote: > On Thu, Feb 15, 2024 at 10:31:59AM +0000, Ryan Roberts wrote: >> arch/arm64/mm/contpte.c | 285 +++++++++++++++++++++++++++++++ > > Nitpick: I think most symbols in contpte.c can be EXPORT_SYMBOL_GPL(). > We don't expect them to be used by random out of tree modules. In fact, > do we expect them to end up in modules at all? Most seem to be called > from the core mm code. The problem is that the contpte_* symbols are called from the ptep_* inline functions. So where those inlines are called from modules, we need to make sure the contpte_* symbols are available. John Hubbard originally reported this problem against v1 and I enumerated all the drivers that call into the ptep_* inlines here: https://lore.kernel.org/linux-arm-kernel/b994ff89-1a1f-26ca-9479-b08c77f94be8@xxxxxxx/#t So they definitely need to be exported. Perhaps we can tighten it to EXPORT_SYMBOL_GPL(), but I was being cautious as I didn't want to break anything out-of-tree. I'm not sure what the normal policy is? arm64 seems to use ~equal amounts of both. > >> +#define ptep_get_lockless ptep_get_lockless >> +static inline pte_t ptep_get_lockless(pte_t *ptep) >> +{ >> + pte_t pte = __ptep_get(ptep); >> + >> + if (likely(!pte_valid_cont(pte))) >> + return pte; >> + >> + return contpte_ptep_get_lockless(ptep); >> +} > [...] >> +pte_t contpte_ptep_get_lockless(pte_t *orig_ptep) >> +{ >> + /* >> + * Gather access/dirty bits, which may be populated in any of the ptes >> + * of the contig range. We may not be holding the PTL, so any contiguous >> + * range may be unfolded/modified/refolded under our feet. Therefore we >> + * ensure we read a _consistent_ contpte range by checking that all ptes >> + * in the range are valid and have CONT_PTE set, that all pfns are >> + * contiguous and that all pgprots are the same (ignoring access/dirty). >> + * If we find a pte that is not consistent, then we must be racing with >> + * an update so start again. If the target pte does not have CONT_PTE >> + * set then that is considered consistent on its own because it is not >> + * part of a contpte range. >> +*/ > > I can't get my head around this lockless API. Maybe it works fine (and > may have been discussed already) but we should document what the races > are, why it works, what the memory ordering requirements are. For > example, the generic (well, x86 PAE) ptep_get_lockless() only needs to > ensure that the low/high 32 bits of a pte are consistent and there are > some ordering rules on how these are updated. > > Does the arm64 implementation only need to be correct w.r.t. the > access/dirty bits? Since we can read orig_ptep atomically, I assume the > only other updates from unfolding would set the dirty/access bits. > >> + >> + pgprot_t orig_prot; >> + unsigned long pfn; >> + pte_t orig_pte; >> + pgprot_t prot; >> + pte_t *ptep; >> + pte_t pte; >> + int i; >> + >> +retry: >> + orig_pte = __ptep_get(orig_ptep); >> + >> + if (!pte_valid_cont(orig_pte)) >> + return orig_pte; >> + >> + orig_prot = pte_pgprot(pte_mkold(pte_mkclean(orig_pte))); >> + ptep = contpte_align_down(orig_ptep); >> + pfn = pte_pfn(orig_pte) - (orig_ptep - ptep); >> + >> + for (i = 0; i < CONT_PTES; i++, ptep++, pfn++) { >> + pte = __ptep_get(ptep); >> + prot = pte_pgprot(pte_mkold(pte_mkclean(pte))); > > We don't have any ordering guarantees in how the ptes in this range are > read or written in the contpte_set_ptes() and the fold/unfold functions. > We might not need them given all the other checks below but it's worth > adding a comment. > >> + >> + if (!pte_valid_cont(pte) || >> + pte_pfn(pte) != pfn || >> + pgprot_val(prot) != pgprot_val(orig_prot)) >> + goto retry; > > I think this also needs some comment. I get the !pte_valid_cont() check > to attempt retrying when racing with unfolding. Are the other checks > needed to detect re-folding with different protection or pfn? > >> + >> + if (pte_dirty(pte)) >> + orig_pte = pte_mkdirty(orig_pte); >> + >> + if (pte_young(pte)) >> + orig_pte = pte_mkyoung(orig_pte); >> + } > > After writing the comments above, I think I figured out that the whole > point of this loop is to check that the ptes in the contig range are > still consistent and the only variation allowed is the dirty/young > state to be passed to the orig_pte returned. The original pte may have > been updated by the time this loop finishes but I don't think it > matters, it wouldn't be any different than reading a single pte and > returning it while it is being updated. Correct. The pte can be updated at any time, before after or during the reads. That was always the case. But now we have to cope with a whole contpte block being repainted while we are reading it. So we are just checking to make sure that all the ptes that we read from the contpte block are consistent with eachother and therefore we can trust that the access/dirty bits we gathered are consistent. > > If you can make this easier to parse (in a few years time) with an > additional patch adding some more comments, that would be great. For > this patch: I already have a big block comment at the top, which was trying to explain it. Clearly not well enough though. I'll add more comments as a follow up patch when I get back from holiday. > > Reviewed-by: Catalin Marinas <catalin.marinas@xxxxxxx> Thanks! >
