Re: [PATCH v5 09/13] KVM: Handle page fault for private memory

[Chao Peng]

On Tue, Mar 29, 2022 at 01:07:18AM +0000, Sean Christopherson wrote:
> On Thu, Mar 10, 2022, Chao Peng wrote:
> > @@ -3890,7 +3893,59 @@ static bool kvm_arch_setup_async_pf(struct kvm_vcpu 
> > *vcpu, gpa_t cr2_or_gpa,
> >                               kvm_vcpu_gfn_to_hva(vcpu, gfn), &arch);
> >  }
> >  
> > -static bool kvm_faultin_pfn(struct kvm_vcpu *vcpu, struct kvm_page_fault 
> > *fault, int *r)
> > +static bool kvm_vcpu_is_private_gfn(struct kvm_vcpu *vcpu, gfn_t gfn)
> > +{
> > +   /*
> > +    * At this time private gfn has not been supported yet. Other patch
> > +    * that enables it should change this.
> > +    */
> > +   return false;
> > +}
> > +
> > +static bool kvm_faultin_pfn_private(struct kvm_vcpu *vcpu,
> > +                               struct kvm_page_fault *fault,
> > +                               bool *is_private_pfn, int *r)
> 
> @is_private_pfn should be a field in @fault, not a separate parameter, and it
> should be a const property set by the original caller.  I would also name it
> "is_private", because if KVM proceeds past this point, it will be a property 
> of
> the fault/access _and_ the pfn
> 
> I say it's a property of the fault because the below kvm_vcpu_is_private_gfn()
> should instead be:
> 
>       if (fault->is_private)
> 
> The kvm_vcpu_is_private_gfn() check is TDX centric.  For SNP, private vs. 
> shared
> is communicated via error code.  For software-only (I'm being optimistic ;-) 
> ),
> we'd probably need to track private vs. shared internally in KVM, I don't 
> think
> we'd want to force it to be a property of the gfn.

Make sense.

> 
> Then you can also move the fault->is_private waiver into 
> is_page_fault_stale(),
> and drop the local is_private_pfn in direct_page_fault().
> 
> > +{
> > +   int order;
> > +   unsigned int flags = 0;
> > +   struct kvm_memory_slot *slot = fault->slot;
> > +   long pfn = kvm_memfile_get_pfn(slot, fault->gfn, &order);
> 
> If get_lock_pfn() and thus kvm_memfile_get_pfn() returns a pure error code 
> instead
> of multiplexing the pfn, then this can be:
> 
>       bool is_private_pfn;
> 
>       is_private_pfn = !!kvm_memfile_get_pfn(slot, fault->gfn, &fault->pfn, 
> &order);
> 
> That self-documents the "pfn < 0" == shared logic.

Yes, agreed.

> 
> > +
> > +   if (kvm_vcpu_is_private_gfn(vcpu, fault->addr >> PAGE_SHIFT)) {
> > +           if (pfn < 0)
> > +                   flags |= KVM_MEMORY_EXIT_FLAG_PRIVATE;
> > +           else {
> > +                   fault->pfn = pfn;
> > +                   if (slot->flags & KVM_MEM_READONLY)
> > +                           fault->map_writable = false;
> > +                   else
> > +                           fault->map_writable = true;
> > +
> > +                   if (order == 0)
> > +                           fault->max_level = PG_LEVEL_4K;
> 
> This doesn't correctly handle order > 0, but less than the next page size, in 
> which
> case max_level needs to be PG_LEVEL_4k.  It also doesn't handle the case where
> max_level > PG_LEVEL_2M.
> 
> That said, I think the proper fix is to have the get_lock_pfn() API return 
> the max
> mapping level, not the order.  KVM, and presumably any other secondary MMU 
> that might
> use these APIs, doesn't care about the order of the struct page, KVM cares 
> about the
> max size/level of page it can map into the guest.  And similar to the 
> previous patch,
> "order" is specific to struct page, which we are trying to avoid.

I remembered I suggested return max mapping level instead of order but
Kirill reminded me that PG_LEVEL_* is x86 specific, then changed back
to 'order'. It's just a matter of backing store or KVM to convert
'order' to mapping level.

> 
> > +                   *is_private_pfn = true;
> 
> This is where KVM guarantees that is_private_pfn == fault->is_private.
> 
> > +                   *r = RET_PF_FIXED;
> > +                   return true;
> 
> Ewww.  This is super confusing.  Ditto for the "*r = -1" magic number.  I 
> totally
> understand why you took this approach, it's just hard to follow because it 
> kinda
> follows the kvm_faultin_pfn() semantics, but then inverts true and false in 
> this
> one case.
> 
> I think the least awful option is to forego the helper and open code 
> everything.
> If we ever refactor kvm_faultin_pfn() to be less weird then we can maybe move 
> this
> to a helper.
> 
> Open coding isn't too bad if you reorganize things so that the 
> exit-to-userspace
> path is a dedicated, early check.  IMO, it's a lot easier to read this way, 
> open
> coded or not.

Yes the existing way of handling this is really awful, including the handling 
for 'r'
that will be finally return to KVM_RUN as part of the uAPI. Let me try your 
above
suggestion.

> 
> I think this is correct?  "is_private_pfn" and "level" are locals, everything 
> else
> is in @fault.
> 
>       if (kvm_slot_is_private(slot)) {
>               is_private_pfn = !!kvm_memfile_get_pfn(slot, fault->gfn,
>                                                      &fault->pfn, &level);
> 
>               if (fault->is_private != is_private_pfn) {
>                       if (is_private_pfn)
>                               kvm_memfile_put_pfn(slot, fault->pfn);
> 
>                       vcpu->run->exit_reason = KVM_EXIT_MEMORY_ERROR;
>                       if (fault->is_private)
>                               vcpu->run->memory.flags = 
> KVM_MEMORY_EXIT_FLAG_PRIVATE;
>                       else
>                               vcpu->run->memory.flags = 0;
>                       vcpu->run->memory.padding = 0;
>                       vcpu->run->memory.gpa = fault->gfn << PAGE_SHIFT;
>                       vcpu->run->memory.size = PAGE_SIZE;
>                       *r = 0;
>                       return true;
>               }
> 
>               /*
>                * fault->pfn is all set if the fault is for a private pfn, just
>                * need to update other metadata.
>                */
>               if (fault->is_private) {
>                       fault->max_level = min(fault->max_level, level);
>                       fault->map_writable = !(slot->flags & KVM_MEM_READONLY);
>                       return false;
>               }
> 
>               /* Fault is shared, fallthrough to the standard path. */
>       }
> 
>       async = false;
> 
> > @@ -4016,7 +4076,7 @@ static int direct_page_fault(struct kvm_vcpu *vcpu, 
> > struct kvm_page_fault *fault
> >     else
> >             write_lock(&vcpu->kvm->mmu_lock);
> >  
> > -   if (is_page_fault_stale(vcpu, fault, mmu_seq))
> > +   if (!is_private_pfn && is_page_fault_stale(vcpu, fault, mmu_seq))
> 
> As above, I'd prefer this check go in is_page_fault_stale().  It means shadow 
> MMUs
> will suffer a pointless check, but I don't think that's a big issue.  Oooh, 
> unless
> we support software-only, which would play nice with nested and probably even 
> legacy
> shadow paging.  Fun :-)

Sounds good.

> 
> >             goto out_unlock;
> >  
> >     r = make_mmu_pages_available(vcpu);
> > @@ -4033,7 +4093,12 @@ static int direct_page_fault(struct kvm_vcpu *vcpu, 
> > struct kvm_page_fault *fault
> >             read_unlock(&vcpu->kvm->mmu_lock);
> >     else
> >             write_unlock(&vcpu->kvm->mmu_lock);
> > -   kvm_release_pfn_clean(fault->pfn);
> > +
> > +   if (is_private_pfn)
> 
> And this can be
> 
>       if (fault->is_private)
> 
> Same feedback for paging_tmpl.h.

Agreed.

Thanks,
Chao