On 07/18/2018 01:14 PM, Yu-cheng Yu wrote:
> On Tue, 2018-07-17 at 16:15 -0700, Dave Hansen wrote:
>> On 07/17/2018 04:03 PM, Yu-cheng Yu wrote:
>>>
>>> We need to find a way to differentiate "someone can write to this PTE"
>>> from "the write bit is set in this PTE".
>> Please think about this:
>>
>> Should pte_write() tell us whether PTE.W=1, or should it tell us
>> that *something* can write to the PTE, which would include
>> PTE.W=0/D=1?
>
>
> Is it better now?
>
>
> Subject: [PATCH] mm: Modify can_follow_write_pte/pmd for shadow stack
>
> can_follow_write_pte/pmd look for the (RO & DIRTY) PTE/PMD to
> verify a non-sharing RO page still exists after a broken COW.
>
> However, a shadow stack PTE is always RO & DIRTY; it can be:
>
> RO & DIRTY_HW - is_shstk_pte(pte) is true; or
> RO & DIRTY_SW - the page is being shared.
>
> Update these functions to check a non-sharing shadow stack page
> still exists after the COW.
>
> Also rename can_follow_write_pte/pmd() to can_follow_write() to
> make their meaning clear; i.e. "Can we write to the page?", not
> "Is the PTE writable?"
>
> Signed-off-by: Yu-cheng Yu <yu-cheng.yu@xxxxxxxxx>
> ---
> mm/gup.c | 38 ++++++++++++++++++++++++++++++++++----
> mm/huge_memory.c | 19 ++++++++++++++-----
> 2 files changed, 48 insertions(+), 9 deletions(-)
>
> diff --git a/mm/gup.c b/mm/gup.c
> index fc5f98069f4e..316967996232 100644
> --- a/mm/gup.c
> +++ b/mm/gup.c
> @@ -63,11 +63,41 @@ static int follow_pfn_pte(struct vm_area_struct *vma, unsigned long address,
> /*
> * FOLL_FORCE can write to even unwritable pte's, but only
> * after we've gone through a COW cycle and they are dirty.
> + *
> + * Background:
> + *
> + * When we force-write to a read-only page, the page fault
> + * handler copies the page and sets the new page's PTE to
> + * RO & DIRTY. This routine tells
> + *
> + * "Can we write to the page?"
> + *
> + * by checking:
> + *
> + * (1) The page has been copied, i.e. FOLL_COW is set;
> + * (2) The copy still exists and its PTE is RO & DIRTY.
> + *
> + * However, a shadow stack PTE is always RO & DIRTY; it can
> + * be:
> + *
> + * RO & DIRTY_HW: when is_shstk_pte(pte) is true; or
> + * RO & DIRTY_SW: when the page is being shared.
> + *
> + * To test a shadow stack's non-sharing page still exists,
> + * we verify that the new page's PTE is_shstk_pte(pte).
The content is getting there, but we need it next to the code, please.
> */
> -static inline bool can_follow_write_pte(pte_t pte, unsigned int flags)
> +static inline bool can_follow_write(pte_t pte, unsigned int flags,
> + struct vm_area_struct *vma)
> {
> - return pte_write(pte) ||
> - ((flags & FOLL_FORCE) && (flags & FOLL_COW) && pte_dirty(pte));
> + if (!is_shstk_mapping(vma->vm_flags)) {
> + if (pte_write(pte))
> + return true;
Let me see if I can say this another way.
The bigger issue is that these patches change the semantics of
pte_write(). Before these patches, it meant that you *MUST* have this
bit set to write to the page controlled by the PTE. Now, it means: you
can write if this bit is set *OR* the shadowstack bit combination is set.
That's the fundamental problem. We need some code in the kernel that
logically represents the concept of "is this PTE a shadowstack PTE or a
PTE with the write bit set", and we will call that pte_write(), or maybe
pte_writable().
You *have* to somehow rectify this situation. We can absolutely no
leave pte_write() in its current, ambiguous state where it has no real
meaning or where it is used to mean _both_ things depending on context.
> + return ((flags & FOLL_FORCE) && (flags & FOLL_COW) &&
> + pte_dirty(pte));
> + } else {
> + return ((flags & FOLL_FORCE) && (flags & FOLL_COW) &&
> + is_shstk_pte(pte));
> + }
> }
Ok, it's rewrite time I guess.
Yu-cheng, you may not know all the history, but this code is actually
the source of the "Dirty COW" security issue. We need to be very, very
careful with it, and super-explicit about all the logic. This is the
time to blow up the comments and walk folks through exactly what we
expect to happen.
Anybody think I'm being too verbose? Is there a reason not to just go
whole-hog on this sucker?
static inline bool can_follow_write(pte_t pte, unsigned int flags,
struct vm_area_struct *vma)
{
/*
* FOLL_FORCE can "write" to hardware read-only PTEs, but
* has to do a COW operation first. Do not allow the
* hardware protection override unless we see FOLL_FORCE
* *and* the COW has been performed by the fault code.
*/
bool gup_cow_ok = (flags & FOLL_FORCE) &&
(flags & FOLL_COW);
/*
* FOLL_COW flags tell us whether the page fault code did a COW
* operation but not whether the PTE we are dealing with here
* was COW'd. It could have been zapped and refaulted since the
* COW operation.
*/
bool pte_cow_ok;
/* We have two COW pte "formats" */
if (!is_shstk_mapping(vma->vm_flags)) {
if (pte_write(pte)) {
/* Any hardware-writable PTE is writable here */
pte_cow_ok = true;
} else {
/* Is the COW-set dirty bit still there? */
pte_cow_ok = pte_dirty(pte));
}
} else {
/* Shadow stack PTEs are always hardware-writable */
/*
* Shadow stack pages do copy-on-access, so any present
* shadow stack page has had a COW-equivalent performed.
*/
pte_cow_ok = is_shstk_pte(pte));
}
return gup_cow_ok && pte_cow_ok;
}
