blob: 42ad067097731296c59d89d36888323771ff9ecd [file]
// Licensed under the Apache-2.0 license
// SPDX-License-Identifier: Apache-2.0
//! End-to-end host test for PLDM firmware-update inventory commands.
//!
//! The Update Agent queries a Firmware Device over in-memory MCTP and verifies
//! the type 5 device identifiers and firmware parameters supplied by `FdOps`.
use core::cell::RefCell;
use mctp::Eid;
use openprot_mctp_server::Server;
use openprot_pldm_service::firmware_device::FirmwareDevice;
use openprot_pldm_service::MctpPldmTransport;
use pldm_common::codec::PldmCodec;
use pldm_common::message::firmware_update::apply_complete::ApplyResult;
use pldm_common::message::firmware_update::get_fw_params::{
FirmwareParameters, GetFirmwareParametersRequest, GetFirmwareParametersResponse,
};
use pldm_common::message::firmware_update::get_status::ProgressPercent;
use pldm_common::message::firmware_update::query_devid::{
QueryDeviceIdentifiersRequest, QueryDeviceIdentifiersResponse,
};
use pldm_common::message::firmware_update::transfer_complete::TransferResult;
use pldm_common::message::firmware_update::verify_complete::VerifyResult;
use pldm_common::protocol::base::{PldmBaseCompletionCode, PldmMsgType};
use pldm_common::protocol::firmware_update::{
ComponentActivationMethods, ComponentClassification, ComponentParameterEntry,
ComponentResponseCode, Descriptor, DescriptorType, FirmwareDeviceCapability,
PldmFirmwareString, PldmFirmwareVersion,
};
use pldm_common::util::fw_component::FirmwareComponent;
use pldm_interface::firmware_device::fd_ops::{ComponentOperation, FdOps, FdOpsError};
mod common;
use common::{run_fd_step, transfer, BufferSender, DirectClientWithPump, FD_EID, UA_EID};
struct InventoryFdOps {
descriptors: [Descriptor; 2],
firmware_parameters: FirmwareParameters,
}
impl FdOps for InventoryFdOps {
fn get_device_identifiers(
&self,
device_identifiers: &mut [Descriptor],
) -> Result<usize, FdOpsError> {
let destination = device_identifiers
.get_mut(..self.descriptors.len())
.ok_or(FdOpsError::DeviceIdentifiersError)?;
destination.copy_from_slice(&self.descriptors);
Ok(self.descriptors.len())
}
fn get_firmware_parms(
&self,
firmware_params: &mut FirmwareParameters,
) -> Result<(), FdOpsError> {
*firmware_params = self.firmware_parameters.clone();
Ok(())
}
fn get_xfer_size(&self, _ua_transfer_size: usize) -> Result<usize, FdOpsError> {
Err(FdOpsError::TransferSizeError)
}
fn handle_component(
&self,
_component: &FirmwareComponent,
_fw_params: &FirmwareParameters,
_op: ComponentOperation,
) -> Result<ComponentResponseCode, FdOpsError> {
Err(FdOpsError::ComponentError)
}
fn query_download_offset_and_length(
&self,
_component: &FirmwareComponent,
) -> Result<(usize, usize), FdOpsError> {
Err(FdOpsError::FwDownloadError)
}
fn download_fw_data(
&self,
_offset: usize,
_data: &[u8],
_component: &FirmwareComponent,
) -> Result<TransferResult, FdOpsError> {
Err(FdOpsError::FwDownloadError)
}
fn is_download_complete(&self, _component: &FirmwareComponent) -> bool {
false
}
fn query_download_progress(
&self,
_component: &FirmwareComponent,
_progress_percent: &mut ProgressPercent,
) -> Result<(), FdOpsError> {
Err(FdOpsError::FwDownloadError)
}
fn verify(
&self,
_component: &FirmwareComponent,
_progress_percent: &mut ProgressPercent,
) -> Result<VerifyResult, FdOpsError> {
Err(FdOpsError::VerifyError)
}
fn apply(
&self,
_component: &FirmwareComponent,
_progress_percent: &mut ProgressPercent,
) -> Result<ApplyResult, FdOpsError> {
Err(FdOpsError::ApplyError)
}
fn activate(
&self,
_self_contained_activation: u8,
_estimated_time: &mut u16,
) -> Result<u8, FdOpsError> {
Err(FdOpsError::ActivateError)
}
fn cancel_update_component(&self, _component: &FirmwareComponent) -> Result<(), FdOpsError> {
Err(FdOpsError::CancelUpdateError)
}
}
fn firmware_string(value: &str) -> PldmFirmwareString {
match PldmFirmwareString::new("ASCII", value) {
Ok(value) => value,
Err(error) => panic!("invalid firmware string {value}: {error:?}"),
}
}
#[test]
fn firmware_update_inventory_commands_return_fd_data() {
let pci_vendor_id = match Descriptor::new(DescriptorType::PciVendorId, &[0x34, 0x12]) {
Ok(descriptor) => descriptor,
Err(error) => panic!("invalid PCI vendor descriptor: {error:?}"),
};
let uuid = match Descriptor::new(
DescriptorType::Uuid,
&[
0x10, 0x32, 0x54, 0x76, 0x98, 0xba, 0xdc, 0xfe, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab,
0xcd, 0xef,
],
) {
Ok(descriptor) => descriptor,
Err(error) => panic!("invalid UUID descriptor: {error:?}"),
};
let descriptors = [pci_vendor_id, uuid];
let active_image_set_version = firmware_string("platform-2.4.0");
let pending_image_set_version = firmware_string("platform-2.5.0");
let active_component_version = firmware_string("controller-2.4.0");
let pending_component_version = firmware_string("controller-2.5.0");
let active_version =
PldmFirmwareVersion::new(0x0002_0400, &active_component_version, Some("20260801"));
let pending_version =
PldmFirmwareVersion::new(0x0002_0500, &pending_component_version, Some("20260901"));
let component = ComponentParameterEntry::new(
ComponentClassification::Firmware,
0x1001,
0,
&active_version,
&pending_version,
ComponentActivationMethods(0x0009),
FirmwareDeviceCapability(0x0000_0003),
);
let firmware_parameters = FirmwareParameters::new(
FirmwareDeviceCapability(0x0000_0003),
1,
&active_image_set_version,
&pending_image_set_version,
&[component],
);
let fd_ops = InventoryFdOps {
descriptors,
firmware_parameters: firmware_parameters.clone(),
};
let ua_to_fd_packets = RefCell::new(Vec::new());
let ua_sender = BufferSender {
packets: &ua_to_fd_packets,
};
let ua_server: RefCell<Server<_, 16>> = RefCell::new(Server::new(Eid(UA_EID), 0, ua_sender));
let fd_to_ua_packets = RefCell::new(Vec::new());
let fd_sender = BufferSender {
packets: &fd_to_ua_packets,
};
let fd_server: RefCell<Server<_, 16>> = RefCell::new(Server::new(Eid(FD_EID), 0, fd_sender));
// Create the DirectClientWithPump for the responder role, which handles requests from the UA to the FD.
let responder_client = DirectClientWithPump::new(&fd_server, || {
transfer(&ua_to_fd_packets, &mut fd_server.borrow_mut());
ua_to_fd_packets.borrow_mut().clear();
});
// Inventory Commands do not invoke the FW FSM and do not invoke FD as an initiator. Therefore the closure is empty.
let requester_client = DirectClientWithPump::new(&fd_server, || {});
let mut fd = FirmwareDevice::init(
&fd_ops,
&pldm_interface::config::PLDM_PROTOCOL_CAPABILITIES,
MctpPldmTransport::new(responder_client),
MctpPldmTransport::new(requester_client),
);
let mut fd_buf = [0u8; 1024];
let mut transact = |request: &[u8]| -> Vec<u8> {
let handle = ua_server
.borrow_mut()
.req(FD_EID)
.expect("allocate UA request handle");
ua_server
.borrow_mut()
.send(Some(handle), 0x01, None, None, false, request)
.expect("send inventory request");
run_fd_step(&mut fd, UA_EID, &mut fd_buf, &mut ());
transfer(&fd_to_ua_packets, &mut ua_server.borrow_mut());
fd_to_ua_packets.borrow_mut().clear();
let mut response = [0u8; 1024];
let metadata = ua_server
.borrow_mut()
.try_recv(handle, &mut response)
.expect("inventory response should be available");
let payload = response
.get(..metadata.payload_size)
.expect("response payload should fit the receive buffer")
.to_vec();
let _ = ua_server.borrow_mut().unbind(handle);
payload
};
let mut request_buf = [0u8; 64];
let mut instance_id = 0u8;
let query_device_identifiers =
QueryDeviceIdentifiersRequest::new(instance_id, PldmMsgType::Request);
let request_len = query_device_identifiers
.encode(&mut request_buf)
.expect("encode QueryDeviceIdentifiers");
let response = transact(
request_buf
.get(..request_len)
.expect("encoded request should fit the request buffer"),
);
let response = QueryDeviceIdentifiersResponse::decode(&response)
.expect("decode QueryDeviceIdentifiers response");
assert_eq!(
response.completion_code,
PldmBaseCompletionCode::Success as u8
);
assert_eq!(response.descriptor_count, 2);
let [expected_initial, expected_additional] = descriptors;
assert_eq!(response.initial_descriptor, expected_initial);
let additional = response
.additional_descriptors
.as_ref()
.expect("UUID descriptor should be present");
let [actual_additional, ..] = additional;
assert_eq!(*actual_additional, expected_additional);
assert_eq!(
response.device_identifiers_len as usize,
descriptors
.iter()
.map(Descriptor::codec_size_in_bytes)
.sum()
);
instance_id += 1;
let get_firmware_parameters =
GetFirmwareParametersRequest::new(instance_id, PldmMsgType::Request);
let request_len = get_firmware_parameters
.encode(&mut request_buf)
.expect("encode GetFirmwareParameters");
let response = transact(
request_buf
.get(..request_len)
.expect("encoded request should fit the request buffer"),
);
let response = GetFirmwareParametersResponse::decode(&response)
.expect("decode GetFirmwareParameters response");
assert_eq!(
response.completion_code,
PldmBaseCompletionCode::Success as u8
);
assert_eq!(response.parms, firmware_parameters);
}