On Tue, Nov 16, 2021, Joerg Roedel wrote: > On Mon, Nov 15, 2021 at 06:26:16PM +0000, Sean Christopherson wrote: > > No, because as Andy pointed out, host userspace must already guard against a bad > > GPA, i.e. this is just a variant of the guest telling the host to DMA to a GPA > > that is completely bogus. The shared vs. private behavior just means that when > > host userspace is doing a GPA=>HVA lookup, it needs to incorporate the "shared" > > state of the GPA. If the host goes and DMAs into the completely wrong HVA=>PFN, > > then that is a host bug; that the bug happened to be exploited by a buggy/malicious > > guest doesn't change the fact that the host messed up. > > The thing is that the usual checking mechanisms can't be applied to > guest-private pages. For user-space the GPA is valid if it fits into the > guest memory layout user-space set up before. But whether a page is > shared or private is the guests business. And that's where we fundamentally disagree. Whether a page is shared or private is very much the host's business. The guest can _ask_ to convert a page, but the host ultimately owns the state of a page. Even in this proposed auto-convert approach, the host has final say over the state of the page. The main difference between auto-converting in the #PF handler and an unmapping approach is that, as you note below, the latter requires an explicit action from host userspace. But again, the host kernel has final say over the state of any given page. > And without an expensive reporting/query mechanism user-space doesn't have the > information to do the check. The cost of exiting to userspace isn't all that expensive relative to the cost of the RMP update itself, e.g. IIRC updating the RMP is several thousand cycles. TDX will have a similar cost to modify S-EPT entries. Actually updating the backing store (see below) might be relatively expensive, but I highly doubt it will be orders of magnitude slower than updating the RMP, or that it will have a meaningful impact on guest performance. > A mechanism to lock pages to shared is also needed, and that creates the > next problems: The most recent proposal for unmapping guest private memory doesn't require new locking at the page level. The high level idea is to treat shared and private variations of GPAs as two unrelated addresses from a host memory management perspective. They are only a "single" address in the context of KVM's MMU, i.e. the NPT for SNP. For shared pages, no new locking is required as the PFN associated with a VMA will not be freed until all mappings go away. Any access after all mappings/references have been dropped is a nothing more than a use-after-free bug, and the guilty party is punished accordingly. For private pages, the proposed idea is to require that all guest private memory be backed by an elightened backing store, e.g. the initial RFC enhances memfd and shmem to support sealing the file as guest-only: : The new seal is only allowed if there's no pre-existing pages in the fd : and there's no existing mapping of the file. After the seal is set, no : read/write/mmap from userspace is allowed. It is KVM's responsibility to ensure it doesn't map a shared PFN into a private GPA and vice versa, and that TDP entries are unmapped appropriately, e.g. when userspace punches a hole in the backing store, but that can all be done using existing locks, e.g. KVM's mmu_lock. No new locking mechanisms are required. > * Who can release the lock, only the process which created it or > anyone who has the memory mapped? > > * What happens when a process has locked guest regions and then > dies with SIGSEGV, will its locks on guest memory be released > stay around forever? > And this is only what comes to mind immediatly, I sure there are more > problematic details in such an interface. Please read through this proposal/RFC, more eyeballs would certainly be welcome. https://lkml.kernel.org/r/20211111141352.26311-1-chao.p.peng@xxxxxxxxxxxxxxx
