| Message ID | 1531944882.10738.1.camel@intel.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
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@intel.com> > --- > 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; }
On Wed, 2018-07-18 at 14:45 -0700, Dave Hansen wrote: > 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@intel.com> > > --- > > 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. Here, we only figure out (1) if the page is pointed by a writable PTE; or (2) if the page is pointed by a RO PTE (data or SHSTK) and it has been copied and it still exists. We are not trying to determine if the SHSTK PTE is writable (we know it is not). We look for the dirty bit to be sure the COW'ed page is still there. The difference for the shadow stack case is that we look for the *hardware* dirty bit. Perhaps we can create another macro, pte_ro_dirty_hw(), which is equivalent to is_shstk_pte(). > > 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. True, the processor can always write to a page through a shadow stack PTE, but it must do that with a CALL instruction. Can we define a write operation as: MOV r1, *(r2). Then we don't have any doubt on pte_write() any more. > > > > > + 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; > } Ok, I will change it. Yu-cheng
>>> -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. > > Here, we only figure out (1) if the page is pointed by a writable PTE; or > (2) if the page is pointed by a RO PTE (data or SHSTK) and it has been > copied and it still exists. We are not trying to > determine if the > SHSTK PTE is writable (we know it is not). Please think about the big picture. I'm not just talking about this patch, but about every use of pte_write() in the kernel. >> 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. > > True, the processor can always write to a page through a shadow stack > PTE, but it must do that with a CALL instruction. Can we define a > write operation as: MOV r1, *(r2). Then we don't have any doubt on > pte_write() any more. No, we can't just move the target. :) You can define it this way, but then you also need to go to every spot in the kernel that calls pte_write() (and _PAGE_RW in fact) and audit it to ensure it means "mov ..." and not push.
On Wed, 2018-07-18 at 17:06 -0700, Dave Hansen wrote: > > > > > > > > > > > > > -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. > > Here, we only figure out (1) if the page is pointed by a writable > > PTE; or > > (2) if the page is pointed by a RO PTE (data or SHSTK) and it has > > been > > copied and it still exists. We are not trying to > > determine if the > > SHSTK PTE is writable (we know it is not). > Please think about the big picture. I'm not just talking about this > patch, but about every use of pte_write() in the kernel. > > > > > > > > > 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. > > True, the processor can always write to a page through a shadow > > stack > > PTE, but it must do that with a CALL instruction. Can we define > > a > > write operation as: MOV r1, *(r2). Then we don't have any doubt > > on > > pte_write() any more. > No, we can't just move the target. :) > > You can define it this way, but then you also need to go to every > spot > in the kernel that calls pte_write() (and _PAGE_RW in fact) and > audit it > to ensure it means "mov ..." and not push. Which pte_write() do you think is right? bool is_shstk_pte(pte) { return (_PAGE_RW not set) && (_PAGE_DIRTY_HW set); } int pte_write_1(pte) { return (_PAGE_RW set) && !is_shstk_pte(pte); } int pte_write_2(pte) { return (_PAGE_RW set) || is_shstk_pte(pte); } Yu-cheng
On 07/19/2018 10:06 AM, Yu-cheng Yu wrote:
> Which pte_write() do you think is right?
There isn't one that's right.
The problem is that the behavior right now is ambiguous. Some callers
of pte_write() need to know about _PAGE_RW alone and others want to know
if (_PAGE_RW || is_shstk()).
The point is that you need both, plus a big audit of all the pte_write()
users to ensure they use the right one.
For instance, see spurious_fault_check(). We can get a shadowstack
fault that also has X86_PF_WRITE, but pte_write()==0. That might make a
shadowstack write fault falsely appear spurious.
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). */ -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; + return ((flags & FOLL_FORCE) && (flags & FOLL_COW) && + pte_dirty(pte)); + } else { + return ((flags & FOLL_FORCE) && (flags & FOLL_COW) && + is_shstk_pte(pte)); + } } static struct page *follow_page_pte(struct vm_area_struct *vma, @@ -105,7 +135,7 @@ static struct page *follow_page_pte(struct vm_area_struct *vma, } if ((flags & FOLL_NUMA) && pte_protnone(pte)) goto no_page; - if ((flags & FOLL_WRITE) && !can_follow_write_pte(pte, flags)) { + if ((flags & FOLL_WRITE) && !can_follow_write(pte, flags, vma)) { pte_unmap_unlock(ptep, ptl); return NULL; } diff --git a/mm/huge_memory.c b/mm/huge_memory.c index 7f3e11d3b64a..822a563678b5 100644 --- a/mm/huge_memory.c +++ b/mm/huge_memory.c @@ -1388,11 +1388,20 @@ int do_huge_pmd_wp_page(struct vm_fault *vmf, pmd_t orig_pmd) /* * FOLL_FORCE can write to even unwritable pmd's, but only * after we've gone through a COW cycle and they are dirty. + * See comments in mm/gup.c, can_follow_write(). */ -static inline bool can_follow_write_pmd(pmd_t pmd, unsigned int flags) -{ - return pmd_write(pmd) || - ((flags & FOLL_FORCE) && (flags & FOLL_COW) && pmd_dirty(pmd)); +static inline bool can_follow_write(pmd_t pmd, unsigned int flags, + struct vm_area_struct *vma) +{ + if (!is_shstk_mapping(vma->vm_flags)) { + if (pmd_write(pmd)) + return true; + return ((flags & FOLL_FORCE) && (flags & FOLL_COW) && + pmd_dirty(pmd)); + } else { + return ((flags & FOLL_FORCE) && (flags & FOLL_COW) && + is_shstk_pmd(pmd)); + } } struct page *follow_trans_huge_pmd(struct vm_area_struct *vma, @@ -1405,7 +1414,7 @@ struct page *follow_trans_huge_pmd(struct vm_area_struct *vma, assert_spin_locked(pmd_lockptr(mm, pmd)); - if (flags & FOLL_WRITE && !can_follow_write_pmd(*pmd, flags)) + if (flags & FOLL_WRITE && !can_follow_write(*pmd, flags, vma)) goto out; /* Avoid dumping huge zero page */