Skip to content

nvme: Pass controller instance ID to NvmeDriver for better tracing #1661

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Draft
wants to merge 9 commits into
base: main
Choose a base branch
from
Draft
Original file line number Diff line number Diff line change
Expand Up @@ -993,6 +993,7 @@ async fn make_disk_type_from_physical_device(
// We can't validate yet that this namespace actually exists. That will
// be checked later.
return Ok(Resource::new(NvmeDiskConfig {
name: controller_instance_id.to_string(),
pci_id,
nsid: sub_device_path,
}));
Expand Down
115 changes: 101 additions & 14 deletions openhcl/underhill_core/src/nvme_manager.rs
Original file line number Diff line number Diff line change
Expand Up @@ -28,6 +28,58 @@ use std::collections::HashMap;
use std::collections::hash_map;
use thiserror::Error;
use tracing::Instrument;

/// Strongly typed wrapper for NVMe device name (formerly debug_id/controller_instance_id)
#[derive(Debug, Clone, PartialEq, Eq, MeshPayload)]
pub struct NvmeDeviceName(pub String);

impl From<String> for NvmeDeviceName {
fn from(s: String) -> Self {
NvmeDeviceName(s)
}
}

impl From<&str> for NvmeDeviceName {
fn from(s: &str) -> Self {
NvmeDeviceName(s.to_string())
}
}

impl AsRef<str> for NvmeDeviceName {
fn as_ref(&self) -> &str {
&self.0
}
}
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

These aren't needed, so don't add them. If this is just for debugging sake, then the Debug derive should do the trick.

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Removed the unnecessary From/AsRef implementations from both strongly typed wrappers as suggested. (commit a9818bd)


/// Strongly typed wrapper for PCI ID
#[derive(Debug, Clone, PartialEq, Eq, MeshPayload)]
pub struct PciId(pub String);
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Promote this to a type in the same module as VfioDevice.

While you are there, a few other fixups:

  1. Change the comment in user_driver/src
    /vfio.rs so that it no longer is specifically tied to MANA devices.
  2. Find cases where DeviceBacking::id() is called and the resulting data is used for something other than for diagnostics purposes and refactor them as appropriate.
  3. Refactor VfioDevice to take this name that we're discussing (call it something like a debug_controller_id), and update all code that creates a VfioDevice to pass an appropriate value.

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Completed all requested changes:

  1. Moved PciId to VfioDevice module
  2. Updated user_driver comment to not be MANA-specific
  3. Added debug_controller_id parameter to VfioDevice constructor and updated all instantiation calls
  4. VfioDevice now takes optional debug_controller_id for diagnostic purposes

Note: DeviceBacking::id() usage is primarily for diagnostics already - no non-diagnostic usage found. (commit a9818bd)


impl From<String> for PciId {
fn from(s: String) -> Self {
PciId(s)
}
}

impl From<&str> for PciId {
fn from(s: &str) -> Self {
PciId(s.to_string())
}
}

impl AsRef<str> for PciId {
fn as_ref(&self) -> &str {
&self.0
}
}
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

These aren't needed, so don't add them. If this is just for debugging sake, then the Debug derive should do the trick.

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Removed the unnecessary From/AsRef implementations from NvmeDeviceName and PciId wrappers as suggested. They only use Debug derive now. (commit a9818bd)


/// Parameters for getting an NVMe namespace
#[derive(Debug, Clone, MeshPayload)]
pub struct GetNamespaceParams {
pub name: NvmeDeviceName,
pub pci_id: PciId,
pub nsid: u32,
}
use user_driver::vfio::VfioDevice;
use vm_resource::AsyncResolveResource;
use vm_resource::ResourceId;
Expand Down Expand Up @@ -175,7 +227,7 @@ impl NvmeManager {
enum Request {
Inspect(inspect::Deferred),
ForceLoadDriver(inspect::DeferredUpdate),
GetNamespace(Rpc<(String, u32), Result<nvme_driver::Namespace, NamespaceError>>),
GetNamespace(Rpc<GetNamespaceParams, Result<nvme_driver::Namespace, NamespaceError>>),
Save(Rpc<(), Result<NvmeManagerSavedState, anyhow::Error>>),
Shutdown {
span: tracing::Span,
Expand All @@ -191,13 +243,24 @@ pub struct NvmeManagerClient {
impl NvmeManagerClient {
pub async fn get_namespace(
&self,
pci_id: String,
name: impl Into<NvmeDeviceName>,
pci_id: impl Into<PciId>,
nsid: u32,
) -> anyhow::Result<nvme_driver::Namespace> {
let params = GetNamespaceParams {
name: name.into(),
pci_id: pci_id.into(),
nsid,
};
Ok(self
.sender
.call(Request::GetNamespace, (pci_id.clone(), nsid))
.instrument(tracing::info_span!("nvme_get_namespace", pci_id, nsid))
.call(Request::GetNamespace, params.clone())
.instrument(tracing::info_span!(
"nvme_get_namespace",
name = params.name.as_ref(),
pci_id = params.pci_id.as_ref(),
nsid
))
.await
.context("nvme manager is shut down")??)
}
Expand Down Expand Up @@ -235,7 +298,10 @@ impl NvmeManagerWorker {
match req {
Request::Inspect(deferred) => deferred.inspect(&self),
Request::ForceLoadDriver(update) => {
match self.get_driver(update.new_value().to_owned()).await {
match self
.get_driver("force-load".to_string(), update.new_value().to_owned())
.await
{
Ok(_) => {
let pci_id = update.new_value().to_string();
update.succeed(pci_id);
Expand All @@ -246,9 +312,12 @@ impl NvmeManagerWorker {
}
}
Request::GetNamespace(rpc) => {
rpc.handle(async |(pci_id, nsid)| {
self.get_namespace(pci_id.clone(), nsid)
.map_err(|source| NamespaceError { pci_id, source })
rpc.handle(async |params| {
self.get_namespace(params.name.0, params.pci_id.0.clone(), params.nsid)
.map_err(|source| NamespaceError {
pci_id: params.pci_id.0,
source,
})
.await
})
.await
Expand Down Expand Up @@ -283,9 +352,12 @@ impl NvmeManagerWorker {
if !nvme_keepalive || !self.save_restore_supported {
async {
join_all(self.devices.drain().map(|(pci_id, driver)| {
driver
.shutdown()
.instrument(tracing::info_span!("shutdown_nvme_driver", pci_id))
let name = driver.name();
driver.shutdown().instrument(tracing::info_span!(
"shutdown_nvme_driver",
pci_id,
name
))
}))
.await
}
Expand All @@ -296,6 +368,7 @@ impl NvmeManagerWorker {

async fn get_driver(
&mut self,
name: String,
pci_id: String,
) -> Result<&mut nvme_driver::NvmeDriver<VfioDevice>, InnerError> {
let driver = match self.devices.entry(pci_id.to_owned()) {
Expand Down Expand Up @@ -328,6 +401,7 @@ impl NvmeManagerWorker {
self.vp_count,
device,
self.is_isolated,
name,
)
.instrument(tracing::info_span!(
"nvme_driver_init",
Expand All @@ -344,10 +418,11 @@ impl NvmeManagerWorker {

async fn get_namespace(
&mut self,
name: String,
pci_id: String,
nsid: u32,
) -> Result<nvme_driver::Namespace, InnerError> {
let driver = self.get_driver(pci_id.to_owned()).await?;
let driver = self.get_driver(name, pci_id.to_owned()).await?;
driver
.namespace(nsid)
.await
Expand Down Expand Up @@ -407,6 +482,7 @@ impl NvmeManagerWorker {
vfio_device,
&disk.driver_state,
self.is_isolated,
format!("restored-{}", disk.pci_id), // Use PCI ID as name for restored drivers
)
.instrument(tracing::info_span!("nvme_driver_restore"))
.await?;
Expand Down Expand Up @@ -440,20 +516,31 @@ impl AsyncResolveResource<DiskHandleKind, NvmeDiskConfig> for NvmeDiskResolver {
) -> Result<Self::Output, Self::Error> {
let namespace = self
.manager
.get_namespace(rsrc.pci_id, rsrc.nsid)
.get_namespace(rsrc.debug_id, rsrc.pci_id, rsrc.nsid)
.await
.context("could not open nvme namespace")?;

Ok(ResolvedDisk::new(disk_nvme::NvmeDisk::new(namespace)).context("invalid disk")?)
}
}

#[derive(MeshPayload, Default)]
#[derive(MeshPayload)]
pub struct NvmeDiskConfig {
pub name: String,
pub pci_id: String,
pub nsid: u32,
}

impl Default for NvmeDiskConfig {
fn default() -> Self {
Self {
name: "force-load".to_string(),
pci_id: String::new(),
nsid: 0,
}
}
}

impl ResourceId<DiskHandleKind> for NvmeDiskConfig {
const ID: &'static str = "nvme";
}
Expand Down
13 changes: 12 additions & 1 deletion vm/devices/storage/disk_nvme/nvme_driver/src/driver.rs
Original file line number Diff line number Diff line change
Expand Up @@ -56,6 +56,7 @@ pub struct NvmeDriver<T: DeviceBacking> {
#[inspect(flatten)]
task: Option<TaskControl<DriverWorkerTask<T>, WorkerState>>,
device_id: String,
name: String,
identify: Option<Arc<spec::IdentifyController>>,
#[inspect(skip)]
driver: VmTaskDriver,
Expand Down Expand Up @@ -179,9 +180,10 @@ impl<T: DeviceBacking> NvmeDriver<T> {
cpu_count: u32,
device: T,
bounce_buffer: bool,
name: String,
) -> anyhow::Result<Self> {
let pci_id = device.id().to_owned();
let mut this = Self::new_disabled(driver_source, cpu_count, device, bounce_buffer)
let mut this = Self::new_disabled(driver_source, cpu_count, device, bounce_buffer, name)
.instrument(tracing::info_span!("nvme_new_disabled", pci_id))
.await?;
match this
Expand All @@ -208,6 +210,7 @@ impl<T: DeviceBacking> NvmeDriver<T> {
cpu_count: u32,
mut device: T,
bounce_buffer: bool,
name: String,
) -> anyhow::Result<Self> {
let driver = driver_source.simple();
let bar0 = Bar0(
Expand Down Expand Up @@ -248,6 +251,7 @@ impl<T: DeviceBacking> NvmeDriver<T> {

Ok(Self {
device_id: device.id().to_owned(),
name,
task: Some(TaskControl::new(DriverWorkerTask {
device,
driver: driver.clone(),
Expand Down Expand Up @@ -568,6 +572,7 @@ impl<T: DeviceBacking> NvmeDriver<T> {
mut device: T,
saved_state: &NvmeDriverSavedState,
bounce_buffer: bool,
name: String,
) -> anyhow::Result<Self> {
let driver = driver_source.simple();
let bar0_mapping = device
Expand All @@ -594,6 +599,7 @@ impl<T: DeviceBacking> NvmeDriver<T> {

let mut this = Self {
device_id: device.id().to_owned(),
name,
task: Some(TaskControl::new(DriverWorkerTask {
device,
driver: driver.clone(),
Expand Down Expand Up @@ -739,6 +745,11 @@ impl<T: DeviceBacking> NvmeDriver<T> {
pub fn update_servicing_flags(&mut self, nvme_keepalive: bool) {
self.nvme_keepalive = nvme_keepalive;
}

/// Get the name.
pub fn name(&self) -> &str {
&self.name
}
}

async fn handle_asynchronous_events(
Expand Down
44 changes: 35 additions & 9 deletions vm/devices/storage/disk_nvme/nvme_driver/src/tests.rs
Original file line number Diff line number Diff line change
Expand Up @@ -78,7 +78,14 @@ async fn test_nvme_ioqueue_max_mqes(driver: DefaultDriver) {
let cap: Cap = Cap::new().with_mqes_z(max_u16);
device.set_mock_response_u64(Some((0, cap.into())));

let driver = NvmeDriver::new(&driver_source, CPU_COUNT, device, false).await;
let driver = NvmeDriver::new(
&driver_source,
CPU_COUNT,
device,
false,
"test-nvme".to_string(),
)
.await;
assert!(driver.is_ok());
}

Expand Down Expand Up @@ -113,7 +120,14 @@ async fn test_nvme_ioqueue_invalid_mqes(driver: DefaultDriver) {
// Setup mock response at offset 0
let cap: Cap = Cap::new().with_mqes_z(0);
device.set_mock_response_u64(Some((0, cap.into())));
let driver = NvmeDriver::new(&driver_source, CPU_COUNT, device, false).await;
let driver = NvmeDriver::new(
&driver_source,
CPU_COUNT,
device,
false,
"test-nvme".to_string(),
)
.await;

assert!(driver.is_err());
}
Expand Down Expand Up @@ -150,9 +164,15 @@ async fn test_nvme_driver(driver: DefaultDriver, allow_dma: bool) {
.await
.unwrap();
let device = NvmeTestEmulatedDevice::new(nvme, msi_set, dma_client.clone());
let driver = NvmeDriver::new(&driver_source, CPU_COUNT, device, false)
.await
.unwrap();
let driver = NvmeDriver::new(
&driver_source,
CPU_COUNT,
device,
false,
"test-nvme".to_string(),
)
.await
.unwrap();
let namespace = driver.namespace(1).await.unwrap();

// Act: Write 1024 bytes of data to disk starting at LBA 1.
Expand Down Expand Up @@ -266,9 +286,15 @@ async fn test_nvme_save_restore_inner(driver: DefaultDriver) {
.unwrap();

let device = NvmeTestEmulatedDevice::new(nvme_ctrl, msi_x, dma_client.clone());
let mut nvme_driver = NvmeDriver::new(&driver_source, CPU_COUNT, device, false)
.await
.unwrap();
let mut nvme_driver = NvmeDriver::new(
&driver_source,
CPU_COUNT,
device,
false,
"test-nvme".to_string(),
)
.await
.unwrap();
let _ns1 = nvme_driver.namespace(1).await.unwrap();
let saved_state = nvme_driver.save().await.unwrap();
// As of today we do not save namespace data to avoid possible conflict
Expand Down Expand Up @@ -304,7 +330,7 @@ async fn test_nvme_save_restore_inner(driver: DefaultDriver) {

let _new_device = NvmeTestEmulatedDevice::new(new_nvme_ctrl, new_msi_x, dma_client.clone());
// TODO: Memory restore is disabled for emulated DMA, uncomment once fixed.
// let _new_nvme_driver = NvmeDriver::restore(&driver_source, CPU_COUNT, new_device, &saved_state)
// let _new_nvme_driver = NvmeDriver::restore(&driver_source, CPU_COUNT, new_device, &saved_state, false, "test-nvme".to_string())
// .await
// .unwrap();
}
Expand Down