vm_memory: Add from_desciptor() in MemoryMappingBuilder

MemoryMappingBuilder had `from_file()` and `from_shared_memory`, which
are almost the same. So, this commit adds `from_descriptor()` to replace
both of the two.

BUG=b:194137301
TEST=build

Change-Id: Ia13f5e8e0f95a5c32e47dc9b3be13b7a7fa510bf
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/crosvm/+/3159881
Tested-by: kokoro <noreply+kokoro@google.com>
Commit-Queue: Keiichi Watanabe <keiichiw@chromium.org>
Reviewed-by: Chirantan Ekbote <chirantan@chromium.org>

arch/src/pstore.rs

@@ -55,7 +55,7 @@ pub fn create_memory_region(
         .map_err(Error::ResourcesError)?;
 
     let memory_mapping = MemoryMappingBuilder::new(pstore.size as usize)
-        .from_file(&file)
+        .from_descriptor(&file)
         .build()
         .map_err(Error::MmapError)?;
 

base/src/mmap.rs

@@ -2,10 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-use crate::{wrap_descriptor, AsRawDescriptor, MappedRegion, MmapError, Protection, SharedMemory};
+use crate::{wrap_descriptor, AsRawDescriptor, MappedRegion, MmapError, Protection};
 use data_model::volatile_memory::*;
 use data_model::DataInit;
-use std::fs::File;
 use sys_util::MemoryMapping as SysUtilMmap;
 
 pub type Result<T> = std::result::Result<T, MmapError>;
@@ -110,23 +109,11 @@ impl<'a> MemoryMappingBuilder<'a> {
         }
     }
 
-    /// Build the memory mapping given the specified File to mapped memory
+    /// Build the memory mapping given the specified descriptor to mapped memory
     ///
     /// Default: Create a new memory mapping.
-    ///
-    /// Note: this is a forward looking interface to accomodate platforms that
-    /// require special handling for file backed mappings.
-    #[allow(clippy::wrong_self_convention, unused_mut)]
-    pub fn from_file(mut self, file: &'a File) -> MemoryMappingBuilder {
-        self.descriptor = Some(file as &dyn AsRawDescriptor);
-        self
-    }
-
-    /// Build the memory mapping given the specified SharedMemory to mapped memory
-    ///
-    /// Default: Create a new memory mapping.
-    pub fn from_shared_memory(mut self, shm: &'a SharedMemory) -> MemoryMappingBuilder {
-        self.descriptor = Some(shm as &dyn AsRawDescriptor);
+    pub fn from_descriptor(mut self, d: &'a dyn AsRawDescriptor) -> MemoryMappingBuilder {
+        self.descriptor = Some(d);
         self
     }
 

devices/src/pci/vfio_pci.rs

@@ -838,7 +838,7 @@ impl VfioPciDevice {
                         // device process doesn't has this mapping, but vfio_dma_map() need it
                         // in device process, so here map it again.
                         let mmap = match MemoryMappingBuilder::new(mmap_size as usize)
-                            .from_file(self.device.device_file())
+                            .from_descriptor(self.device.device_file())
                             .offset(offset)
                             .build()
                         {

devices/src/virtio/snd/vios_backend/shm_streams.rs

@@ -361,7 +361,7 @@ fn mmap_buffer(
 
     let mmap = MemoryMappingBuilder::new(extended_size)
         .offset(aligned_offset as u64)
-        .from_shared_memory(src)
+        .from_descriptor(src)
         .build()
         .map_err(Error::GuestMmapError)?;
 

devices/src/virtio/snd/vios_backend/shm_vios.rs

@@ -702,7 +702,7 @@ impl IoBufferQueue {
         let size = file.seek(SeekFrom::End(0)).map_err(Error::FileSizeError)? as usize;
 
         let mmap = MemoryMappingBuilder::new(size)
-            .from_file(&file)
+            .from_descriptor(&file)
             .build()
             .map_err(Error::ServerMmapError)?;
 

gpu_display/src/gpu_display_wl.rs

@@ -315,7 +315,7 @@ impl DisplayT for DisplayWl {
         let buffer_size = round_up_to_page_size(fb_size as usize * BUFFER_COUNT);
         let buffer_shm = SharedMemory::named("GpuDisplaySurface", buffer_size as u64)?;
         let buffer_mem = MemoryMappingBuilder::new(buffer_size)
-            .from_shared_memory(&buffer_shm)
+            .from_descriptor(&buffer_shm)
             .build()
             .unwrap();
 

hypervisor/src/kvm/mod.rs

@@ -32,8 +32,8 @@ use libc::{
 use base::{
     block_signal, errno_result, error, ioctl, ioctl_with_mut_ref, ioctl_with_ref, ioctl_with_val,
     pagesize, signal, unblock_signal, AsRawDescriptor, Error, Event, FromRawDescriptor,
-    MappedRegion, MemoryMapping, MemoryMappingBuilder, MemoryMappingBuilderUnix, MmapError,
-    Protection, RawDescriptor, Result, SafeDescriptor,
+    MappedRegion, MemoryMapping, MemoryMappingBuilder, MmapError, Protection, RawDescriptor,
+    Result, SafeDescriptor,
 };
 use data_model::vec_with_array_field;
 use kvm_sys::*;

kvm/src/lib.rs

@@ -969,7 +969,7 @@ impl Vcpu {
         let vcpu = unsafe { File::from_raw_descriptor(vcpu_fd) };
 
         let run_mmap = MemoryMappingBuilder::new(run_mmap_size)
-            .from_file(&vcpu)
+            .from_descriptor(&vcpu)
             .build()
             .map_err(|_| Error::new(ENOSPC))?;
 

kvm/tests/dirty_log.rs

@@ -21,7 +21,7 @@ fn test_run() {
     let guest_mem = GuestMemory::new(&[]).unwrap();
     let mem = SharedMemory::anon(mem_size).expect("failed to create shared memory");
     let mmap = MemoryMappingBuilder::new(mem_size as usize)
-        .from_shared_memory(&mem)
+        .from_descriptor(&mem)
         .build()
         .expect("failed to create memory mapping");
 
@@ -48,7 +48,7 @@ fn test_run() {
             GuestAddress(0),
             Box::new(
                 MemoryMappingBuilder::new(mem_size as usize)
-                    .from_shared_memory(&mem)
+                    .from_descriptor(&mem)
                     .build()
                     .expect("failed to create memory mapping"),
             ),

kvm/tests/read_only_memory.rs

@@ -23,7 +23,7 @@ fn test_run() {
     let guest_mem = GuestMemory::new(&[]).unwrap();
     let mem = SharedMemory::anon(mem_size).expect("failed to create shared memory");
     let mmap = MemoryMappingBuilder::new(mem_size as usize)
-        .from_shared_memory(&mem)
+        .from_descriptor(&mem)
         .build()
         .expect("failed to create memory mapping");
 
@@ -50,7 +50,7 @@ fn test_run() {
         GuestAddress(0),
         Box::new(
             MemoryMappingBuilder::new(mem_size as usize)
-                .from_shared_memory(&mem)
+                .from_descriptor(&mem)
                 .build()
                 .expect("failed to create memory mapping"),
         ),
@@ -63,7 +63,7 @@ fn test_run() {
     // from it.
     let mem_ro = SharedMemory::anon(0x1000).expect("failed to create shared memory");
     let mmap_ro = MemoryMappingBuilder::new(0x1000)
-        .from_shared_memory(&mem_ro)
+        .from_descriptor(&mem_ro)
         .build()
         .expect("failed to create memory mapping");
     mmap_ro
@@ -73,7 +73,7 @@ fn test_run() {
         GuestAddress(vcpu_sregs.es.base),
         Box::new(
             MemoryMappingBuilder::new(0x1000)
-                .from_shared_memory(&mem_ro)
+                .from_descriptor(&mem_ro)
                 .build()
                 .expect("failed to create memory mapping"),
         ),

src/plugin/process.rs

@@ -365,7 +365,7 @@ impl Process {
             _ => {}
         }
         let mem = MemoryMappingBuilder::new(length as usize)
-            .from_shared_memory(&shm)
+            .from_descriptor(&shm)
             .offset(offset)
             .build()
             .map_err(mmap_to_sys_err)?;

vm_control/src/lib.rs

@@ -30,8 +30,8 @@ use serde::{Deserialize, Serialize};
 use base::{
     error, with_as_descriptor, AsRawDescriptor, Error as SysError, Event, ExternalMapping, Fd,
     FromRawDescriptor, IntoRawDescriptor, Killable, MappedRegion, MemoryMappingArena,
-    MemoryMappingBuilder, MemoryMappingBuilderUnix, MmapError, Protection, Result, SafeDescriptor,
-    SharedMemory, Tube, SIGRTMIN,
+    MemoryMappingBuilder, MmapError, Protection, Result, SafeDescriptor, SharedMemory, Tube,
+    SIGRTMIN,
 };
 use hypervisor::{IrqRoute, IrqSource, Vm};
 use resources::{Alloc, MmioType, SystemAllocator};

vm_memory/src/guest_memory.rs

@@ -14,8 +14,8 @@ use std::sync::Arc;
 use base::{pagesize, Error as SysError};
 use base::{
     AsRawDescriptor, AsRawDescriptors, MappedRegion, MemfdSeals, MemoryMapping,
-    MemoryMappingBuilder, MemoryMappingBuilderUnix, MemoryMappingUnix, MmapError, RawDescriptor,
-    SharedMemory, SharedMemoryUnix,
+    MemoryMappingBuilder, MemoryMappingUnix, MmapError, RawDescriptor, SharedMemory,
+    SharedMemoryUnix,
 };
 use bitflags::bitflags;
 use cros_async::{mem, BackingMemory};
@@ -202,7 +202,7 @@ impl GuestMemory {
             let size = usize::try_from(range.1)
                 .map_err(|_| Error::MemoryRegionTooLarge(range.1 as u128))?;
             let mapping = MemoryMappingBuilder::new(size)
-                .from_shared_memory(shm.as_ref())
+                .from_descriptor(shm.as_ref())
                 .offset(offset)
                 .build()
                 .map_err(Error::MemoryMappingFailed)?;
@@ -1011,7 +1011,7 @@ mod tests {
 
         let _ = gm.with_regions::<_, ()>(|index, _, size, _, shm, shm_offset| {
             let mmap = MemoryMappingBuilder::new(size)
-                .from_shared_memory(shm)
+                .from_descriptor(shm)
                 .offset(shm_offset)
                 .build()
                 .unwrap();