RFE: Skeleton for DMA layer #306
Conversation
| } | ||
| } | ||
|
|
||
| pub fn map_dma_ranges( |
There was a problem hiding this comment.
I understand this is a draft ... could you add a doc comment so that folks know the intended contract and usage here?
| } | ||
|
|
||
| /// Adds a new client to the list and stores its pinning threshold | ||
| fn register_client(&self, client: &Arc<DmaClient>, threshold: usize) { |
There was a problem hiding this comment.
Is there a need to have per-client bounce buffers?
| } | ||
|
|
||
| // Trait for the DMA interface | ||
| pub trait DmaInterface { |
There was a problem hiding this comment.
Do you envision that this would replace other uses of bounce buffering? (for example, copying from private memory into shared memory for isolated VMs, or when the block disk bounces for arm64 guests)?
There was a problem hiding this comment.
yes, i do envision that.
Policy on GlobalDmaManager can be control the behavior system wide.
There was a problem hiding this comment.
Got it. How do you envision handling the case:
- Have a VTL0 VM where sometimes memory needs to be pinned.
- This particular transaction's memory must be placed in a bounce buffer, even if pinning would otherwise succeed?
(I'm thinking about the block device driver here, where it would never want to pin memory - the kernel doesn't know about the VTL0 addresses.)
There was a problem hiding this comment.
We discussed this offline. map_dma_ranges will take additional per-transaction parameters. For example, some clients may want all transactions to be placed into the bounce buffer.
| static GLOBAL_DMA_MANAGER: OnceCell<Arc<GlobalDmaManager>> = OnceCell::new(); | ||
|
|
||
| /// Global DMA Manager to handle resources and manage clients | ||
| pub struct GlobalDmaManager { |
There was a problem hiding this comment.
What settings will this manager have? Which of those do you expect to expose in Vtl2Settings?
| let mut dma_transactions = Vec::new(); | ||
| let force_bounce_buffer = options.map_or(false, |opts| opts.force_bounce_buffer); | ||
|
|
||
| let threshold = manager.get_client_threshold(self).ok_or(DmaError::InitializationFailed)?; |
There was a problem hiding this comment.
This line can be moved before defining dma_transactions to fail earlier.
|
|
||
| for range in ranges { | ||
| let use_bounce_buffer = force_bounce_buffer || range_size > threshold || !self.can_pin(range); | ||
|
|
|
|
||
| for transaction in dma_transactions { | ||
| if transaction.is_bounce_buffer { | ||
| // Code to release bounce buffer |
There was a problem hiding this comment.
Do we need copy out from bounce buffer here?
There was a problem hiding this comment.
The caller may not know if it's bounce buffer or not, so I think we need handle it here. And need pass the Memory range to copy data out. Actually, I think we need know the IO direction to decide which copy is needed (including the one in map_dma_ranges).
|
|
||
| /// Allocates a bounce buffer if available, otherwise returns an error | ||
| pub fn allocate_bounce_buffer(&self, size: usize) -> Result<usize, DmaError> { | ||
| Err(DmaError::BounceBufferFailed) // Placeholder |
There was a problem hiding this comment.
Do we need ensure the bounce buffer is page aligned?
There was a problem hiding this comment.
I envision that bounce buffer management will be aligned.
There was a problem hiding this comment.
And also note it: our current bounce buffer allocation function has infinite loop issue which we want to avoid it in the new implementation.
| let result = self.issue_raw(command).await; | ||
|
|
||
| dma_client | ||
| .unmap_dma_ranges(&dma_transactions.transactions) |
There was a problem hiding this comment.
So we need handle the same functionality as copy_to_guest_memory in unmap_dma_ranges if opcode.transfer_controller_to_host()
| let result = self.issue_raw(command).await; | ||
|
|
||
| dma_client | ||
| .unmap_dma_ranges(&dma_transactions.transactions) |
There was a problem hiding this comment.
To simplify usage, can we just pass dma_transactions to unmap_dma_ranges? So caller needn't know details of DmaTransactionHandler?
| pub original_addr: usize, | ||
| pub dma_addr: usize, | ||
| pub size: usize, | ||
| pub is_pinned: bool, |
There was a problem hiding this comment.
Can we have comments explaining these fields? like is_pinned and is_bounce_buffer cannot be both true, why do we need keep both?
| let threshold = manager.get_client_threshold(self).ok_or(DmaError::InitializationFailed)?; | ||
|
|
||
| for range in ranges { | ||
| let use_bounce_buffer = force_bounce_buffer || range_size > threshold || !self.can_pin(range); |
There was a problem hiding this comment.
If can_pin returns true, would it grantee the later pin_memory succeed?
I guess not. Then what's the strategy to handle pin/bounce buffer failures?
I mean, should we fallback to bounce buffer if pin failed?
Should we try pin if bounce buffer allocation failed?
No description provided.