RE: [PATCH V2 5/6] net: netvsc: Add Isolation VM support for netvsc driver

["Michael Kelley (LINUX)" <mikelley@xxxxxxxxxxxxx>]

From: Tianyu Lan <ltykernel@xxxxxxxxx> Sent: Tuesday, November 23, 2021 6:31 AM
> 
> In Isolation VM, all shared memory with host needs to mark visible
> to host via hvcall. vmbus_establish_gpadl() has already done it for
> netvsc rx/tx ring buffer. The page buffer used by vmbus_sendpacket_
> pagebuffer() stills need to be handled. Use DMA API to map/umap
> these memory during sending/receiving packet and Hyper-V swiotlb
> bounce buffer dma address will be returned. The swiotlb bounce buffer
> has been masked to be visible to host during boot up.
> 
> Allocate rx/tx ring buffer via dma_alloc_noncontiguous() in Isolation
> VM. After calling vmbus_establish_gpadl() which marks these pages visible
> to host, map these pages unencrypted addes space via dma_vmap_noncontiguous().
> 

The big unresolved topic is how best to do the allocation and mapping of the big
netvsc send and receive buffers.  Let me summarize and make a recommendation.

Background
==========
1.  Each Hyper-V synthetic network device requires a large pre-allocated receive
     buffer (defaults to 16 Mbytes) and a similar send buffer (defaults to 1 
Mbyte).
2.  The buffers are allocated in guest memory and shared with the Hyper-V host.
     As such, in the Hyper-V SNP environment, the memory must be unencrypted
     and accessed in the Hyper-V guest with shared_gpa_boundary (i.e., VTOM)
     added to the physical memory address.
3.  The buffers need *not* be contiguous in guest physical memory, but must be
     contiguously mapped in guest kernel virtual space.
4.  Network devices may come and go during the life of the VM, so allocation of
     these buffers and their mappings may be done after Linux has been running 
for
     a long time.
5.  Performance of the allocation and mapping process is not an issue since it 
is
     done only on synthetic network device add/remove.
6.  So the primary goals are an appropriate logical abstraction, code that is
     simple and straightforward, and efficient memory usage.

Approaches
==========
During the development of these patches, four approaches have been
implemented:

1.  Two virtual mappings:  One from vmalloc() to allocate the guest memory, and
     the second from vmap_pfns() after adding the shared_gpa_boundary.   This is
     implemented in Hyper-V or netvsc specific code, with no use of DMA APIs.
     No separate list of physical pages is maintained, so for creating the 
second
     mapping, the PFN list is assembled temporarily by doing virt-to-phys()
     page-by-page on the vmalloc mapping, and then discarded because it is no
     longer needed.  [v4 of the original patch series.]

2.  Two virtual mappings as in (1) above, but implemented via new DMA calls
     dma_map_decrypted() and dma_unmap_encrypted().  [v3 of the original
     patch series.]

3.  Two virtual mappings as in (1) above, but implemented via DMA noncontiguous
      allocation and mapping calls, as enhanced to allow for custom map/unmap
      implementations.  A list of physical pages is maintained in the 
dma_sgt_handle
      as expected by the DMA noncontiguous API.  [New split-off patch series v1 
& v2]

4.   Single virtual mapping from vmap_pfns().  The netvsc driver allocates 
physical
      memory via alloc_pages() with as much contiguity as possible, and 
maintains a
      list of physical pages and ranges.   Single virtual map is setup with 
vmap_pfns()
      after adding shared_gpa_boundary.  [v5 of the original patch series.]

Both implementations using DMA APIs use very little of the existing DMA
machinery.  Both require extensions to the DMA APIs, and custom ops functions.
While in some sense the netvsc send and receive buffers involve DMA, they
do not require any DMA actions on a per-I/O basis.  It seems better to me to
not try to fit these two buffers into the DMA model as a one-off.  Let's just
use Hyper-V specific code to allocate and map them, as is done with the
Hyper-V VMbus channel ring buffers.

That leaves approaches (1) and (4) above.  Between those two, (1) is
simpler even though there are two virtual mappings.  Using alloc_pages() as
in (4) is messy and there's no real benefit to using higher order allocations.
(4) also requires maintaining a separate list of PFNs and ranges, which offsets
some of the benefits to having only one virtual mapping active at any point in
time.

I don't think there's a clear "right" answer, so it's a judgment call.  We've
explored what other approaches would look like, and I'd say let's go with
(1) as the simpler approach.  Thoughts?

Michael