dma_client: remove fallback allocator (#2350)

#2061 added a fallback allocator for situations where the private pool
is available but persistence isn't needed. This had the unintended
effect of MANA devices using the private pool when available even though
its memory won't be persisted or restored. This leads to restoration
failures on servicing because not all memory from the private pool is
restored, and could also lead to scenarios where MANA could exhaust the
private pool even though it doesn't need to use it.

This change removes the fallback allocator so this scenario isn't
possible.

Author: justus-camp-microsoft

Cargo.lock

@@ -5041,7 +5041,6 @@ dependencies = [
  "memory_range",
  "mesh",
  "page_pool_alloc",
- "tracing",
  "user_driver",
  "virt",
  "vmcore",

openhcl/openhcl_dma_manager/Cargo.toml

@@ -21,7 +21,6 @@ virt.workspace = true
 vmcore.workspace = true
 
 anyhow.workspace = true
-tracing.workspace = true
 
 [lints]
 workspace = true

openhcl/openhcl_dma_manager/src/lib.rs

@@ -287,20 +287,12 @@ impl DmaManagerInner {
                     allocation_visibility: AllocationVisibility::Private,
                     persistent_allocations: false,
                     shared_spawner: _,
-                    private_spawner,
+                    private_spawner: _,
                 } => match lower_vtl_policy {
                     LowerVtlPermissionPolicy::Any => {
                         // No persistence needed means the `LockedMemorySpawner`
                         // using normal VTL2 ram is fine.
-                        match private_spawner {
-                            Some(private) => DmaClientBacking::PrivatePoolWithFallback((
-                                private
-                                    .allocator(device_name.into())
-                                    .context("failed to create private allocator")?,
-                                LockedMemorySpawner,
-                            )),
-                            None => DmaClientBacking::LockedMemory(LockedMemorySpawner),
-                        }
+                        DmaClientBacking::LockedMemory(LockedMemorySpawner)
                     }
                     LowerVtlPermissionPolicy::Vtl0 => {
                         // `LockedMemorySpawner` uses private VTL2 ram, so
@@ -425,7 +417,6 @@ enum DmaClientBacking {
     SharedPool(#[inspect(skip)] PagePoolAllocator),
     PrivatePool(#[inspect(skip)] PagePoolAllocator),
     LockedMemory(#[inspect(skip)] LockedMemorySpawner),
-    PrivatePoolWithFallback(#[inspect(skip)] (PagePoolAllocator, LockedMemorySpawner)),
     PrivatePoolLowerVtl(#[inspect(skip)] LowerVtlMemorySpawner<PagePoolAllocator>),
     LockedMemoryLowerVtl(#[inspect(skip)] LowerVtlMemorySpawner<LockedMemorySpawner>),
 }
@@ -439,16 +430,6 @@ impl DmaClientBacking {
             DmaClientBacking::SharedPool(allocator) => allocator.allocate_dma_buffer(total_size),
             DmaClientBacking::PrivatePool(allocator) => allocator.allocate_dma_buffer(total_size),
             DmaClientBacking::LockedMemory(spawner) => spawner.allocate_dma_buffer(total_size),
-            DmaClientBacking::PrivatePoolWithFallback((allocator, spawner)) => {
-                allocator.allocate_dma_buffer(total_size).or_else(|err| {
-                    tracing::warn!(
-                        size = total_size,
-                        error = ?err,
-                        "falling back to locked memory for dma allocation"
-                    );
-                    spawner.allocate_dma_buffer(total_size)
-                })
-            }
             DmaClientBacking::PrivatePoolLowerVtl(spawner) => {
                 spawner.allocate_dma_buffer(total_size)
             }
@@ -462,9 +443,6 @@ impl DmaClientBacking {
         match self {
             DmaClientBacking::SharedPool(allocator) => allocator.attach_pending_buffers(),
             DmaClientBacking::PrivatePool(allocator) => allocator.attach_pending_buffers(),
-            DmaClientBacking::PrivatePoolWithFallback(_) => {
-                anyhow::bail!("cannot attach pending buffers with fallback allocator")
-            }
             DmaClientBacking::LockedMemory(_) => {
                 anyhow::bail!(
                     "attaching pending buffers is not supported with locked memory; \