PyNVMe3 Test Suites

Last Modified: November 21, 2025

Conformance
Benchmark
Management
Production
Placement

Suite: scripts/conformance

folder: scripts/conformance/01_admin

file: scripts/conformance/01_admin/abort_test

function: scripts/conformance/01_admin/abort_test.py::test_dut_firmware_and_model_name

Log controller identity information by reading the Identify Controller data and invoking a namespace format to ensure readiness.

Reference

NVM Express Revision 1.4a, Figure 249.

Steps

Log controller model number retrieved from Identify data
Log controller firmware revision for traceability
Report additional controller and namespace properties
Format the namespace to ensure subsequent tests start from a clean state

function: scripts/conformance/01_admin/abort_test.py::test_abort_specific_aer_command

Validate abort handling by issuing an AER command, aborting it via CID, and confirming the AER completion reports the aborted status.

Reference

NVM Express Revision 1.4a, Section 5.1.

Steps

Track asynchronous event request abort status for verification
Define an AER callback that records the abort status from the completion entry
Submit an AER command and record the issued command identifier
Issue the abort targeting the AER command and expect an aborted completion status
Confirm that the callback observed the aborted AER command identifier

function: scripts/conformance/01_admin/abort_test.py::test_abort_abort_command

Verify nested abort handling by issuing abort commands against other abort commands and AERs to ensure each completes successfully or reports 00/07 as expected.

Reference

NVM Express Revision 1.4a, Section 5.1.

Steps

Skip the test if the controller supports fewer than two outstanding abort commands
Issue an abort command and abort it with a second abort, expecting clean completions
Repeat the sequence using an invalid CID to ensure abort handling stays consistent
Abort an AER with two nested abort commands and expect the AER to report an aborted completion

function: scripts/conformance/01_admin/abort_test.py::test_abort_io_burst

Stress bursty abort behavior by posting many writes plus a flush, delaying briefly, and aborting the flush via SQID and CID.

Reference

NVM Express Revision 1.4a, Section 5.1.

Steps

Create dedicated submission and completion queues for the burst test
Post 100 writes and a flush before ringing the doorbell once
Wait for the configured delay before issuing the abort
Abort the flush command using its CID and queue identifier
Reap all completions to ensure none remain outstanding
Delete the queues now that verification has completed

file: scripts/conformance/01_admin/aer_test

function: scripts/conformance/01_admin/aer_test.py::test_aer_limit_exceeded

Validate the controller enforces the Identify AER limit by submitting one more request than allowed.

Reference

Specification: NVM Express Revision 1.4a.

Steps

Read the AER limit from the Identify Controller data.
Issue the maximum number of AER commands allowed by the controller.
Submit one additional AER command to verify the limit is enforced.
Abort each outstanding AER command and expect a successful completion.

function: scripts/conformance/01_admin/aer_test.py::test_aer_no_timeout

Confirm an AER command stays outstanding without timeout before being aborted by the host.

Reference

Specification: NVM Express Revision 1.4a.

Steps

Submit one AER command without waiting for completion.
Observe the command for 15 seconds without expecting completion or timeout.
Abort the outstanding AER command and confirm the abort succeeds.

function: scripts/conformance/01_admin/aer_test.py::test_aer_sanitize

Verify sanitize completion events trigger AER by issuing sanitize commands while monitoring notifications.

Reference

Specification: NVM Express Revision 1.4a.

Steps

Skip test execution if sanitize is not supported.
Log the sanitize capabilities so the test report shows controller support.
Post one AER command to capture the sanitize completion notice.
Issue a sanitize command to trigger the sanitize operation.
Poll the sanitize log until completion while watching for the AER notification.
Confirm the sanitize log reports a completed state.
Run a sanitize flow once to ensure the completion triggers an AER.
Repeat the sanitize flow to ensure consistent AER behavior across runs.

function: scripts/conformance/01_admin/aer_test.py::test_aer_mask_event

Ensure masking SMART health events suppresses the AER notification even when a thermal event is forced.

Reference

Specification: NVM Express Revision 1.4a.

Steps

Post an AER command to capture any future asynchronous notifications.
Mask the SMART/Health AER source so temperature changes should not raise notices.
Read the SMART log to capture the current composite temperature.
Program the temperature threshold below the current value to force a warning condition.
Read SMART logs while confirming no AER notification is triggered.
Ensure the SMART critical warning bit reflects the triggered temperature alarm.
Restore the original temperature threshold and AER mask configuration.

function: scripts/conformance/01_admin/aer_test.py::test_aer_fw_activation_starting

Validate Firmware Activation Starting notices raise AERs by enabling the notice and activating firmware.

Reference

Specification: NVM Express Revision 1.4a.

Steps

Skip the test when firmware management commands are unsupported.
Skip when Optional Asynchronous Event Support does not advertise firmware notices.
Configure the controller to unmask Firmware Activation Starting notices.
Skip if the controller rejected the configuration change.
Arm an AER command with a callback to validate the Firmware Activation Starting notice.
Activate an existing firmware slot to trigger the notice.
Read the firmware log page to clear the notice.
Restore the original AER configuration.

function: scripts/conformance/01_admin/aer_test.py::test_aer_event_no_aer

Ensure no notifications occur when no AER command is outstanding even if a thermal threshold is crossed.

Reference

Specification: NVM Express Revision 1.4a.

Steps

Initialize the controller without posting any AER commands while enabling all notices.
Confirm that temperature events are supported before forcing thresholds.
Get the current temperature from the SMART log without generating any notices.
Drop the temperature threshold below the current reading to trigger a warning condition.
Wait briefly and confirm no AER notification is triggered without an outstanding command.
Verify the SMART critical warning bit reflects the condition despite the lack of an AER.
Restore the original temperature threshold.

function: scripts/conformance/01_admin/aer_test.py::test_aer_abort_all_aer_commands

Exercise abort behavior by filling all AER slots plus one and aborting every outstanding command.

Reference

Specification: NVM Express Revision 1.4a.

Steps

Disable all asynchronous event notifications to control the test flow.
Determine the maximum number of concurrently outstanding AER commands.
Define a callback template for verifying completion status if hook support is available.
Fill every available AER slot with outstanding commands.
Submit one more command to ensure the controller flags the exceeded limit.
Abort every command and expect the controller to complete the aborts successfully.
Write to an invalid doorbell register and confirm that no new AER notification appears.

function: scripts/conformance/01_admin/aer_test.py::test_aer_temperature

Confirm both over- and under-temperature thresholds raise AERs by moving the limits around the current reading.

Reference

Specification: NVM Express Revision 1.4a.

Steps

Post an AER command to receive temperature-related notices.
Capture the original over- and under-temperature thresholds for later restoration.
Enable every asynchronous event type so temperature notices can be delivered.
Allocate a SMART log buffer that will hold the composite temperature data.
Sample the current composite temperature from the SMART log.
Force an over-temperature condition by lowering the high threshold below the reading.
Read the SMART log to acknowledge and clear the over-temperature event.
Restore the original high threshold and verify no further AERs occur.
Force an under-temperature condition by raising the low threshold above the reading.
Read the SMART log again to acknowledge the under-temperature event.
Ensure the SMART critical warning still signals the temperature event.
Restore the original low temperature threshold configuration.

function: scripts/conformance/01_admin/aer_test.py::test_aer_doorbell_invalid_register

Check invalid doorbell register writes raise an AER by deleting a queue and writing to its tail doorbell.

Reference

Specification: NVM Express Revision 1.4a.

Steps

Post an AER command so the controller can raise notices.
Create an I/O completion queue and a paired submission queue.
Delete the submission queue to make its doorbell invalid.
Write the deleted SQ doorbell to trigger the invalid doorbell register event.
Read the error information log page to clear the event.
Delete the completion queue to clean up resources.

function: scripts/conformance/01_admin/aer_test.py::test_aer_doorbell_out_of_range

Trigger the invalid doorbell value AER by writing out-of-range SQ tail values after creating admin I/O queues.

Reference

Specification: NVM Express Revision 1.4a.

Steps

Post an AER command so the controller can report invalid doorbell writes.
Create an I/O queue pair sized to expose tail pointer bounds.
Write an out-of-range SQ tail value to force the invalid doorbell value status.
Read the error information log page to clear the notice.
Delete the SQ and CQ to free resources.

file: scripts/conformance/01_admin/dst_test

function: scripts/conformance/01_admin/dst_test.py::test_dst_short_valid_namespace

Validate a short device self-test against a valid namespace and inspect the Device Self-test log for progress.

Reference

NVM Express Revision 1.4a.

Steps

Issue a short device self-test for the requested namespace
Read the Device Self-test log to confirm the short test is reported as in progress

function: scripts/conformance/01_admin/dst_test.py::test_dst_extended_processing

Exercise an extended device self-test on a valid namespace and verify the log reports the extended run.

Reference

NVM Express Revision 1.4a.

Steps

Issue an extended device self-test for the namespace
Read the log page to ensure the extended test is reported as in progress

function: scripts/conformance/01_admin/dst_test.py::test_dst_short_time

Measure a short device self-test duration to ensure completion occurs within the mandated two-minute limit.

Reference

NVM Express Revision 1.4a.

Steps

Launch a short device self-test on all namespaces and record the start time
Poll the Device Self-test log until the operation completes or a timeout is hit
Assert the elapsed wall clock time does not exceed two minutes

function: scripts/conformance/01_admin/dst_test.py::test_dst_invalid_namespace

Send a device self-test to invalid namespace identifiers and confirm the controller reports Invalid Namespace or Format.

Reference

NVM Express Revision 1.4a.

Steps

Attempt the device self-test with the invalid namespace and expect an abort status

function: scripts/conformance/01_admin/dst_test.py::test_dst_invalid_stc

Issue device self-tests with unsupported STC values and ensure the controller fails them with Invalid Field in Command.

Reference

NVM Express Revision 1.4a.

Steps

Attempt the DST with invalid STC values and expect ERROR status from the controller

function: scripts/conformance/01_admin/dst_test.py::test_dst_in_progress

Run concurrent device self-tests to confirm later commands fail with Device Self-test in Progress while the first test runs.

Reference

NVM Express Revision 1.4a.

Steps

Launch the first DST operation and wait for it to start
Reissue the DST and expect Device Self-test in Progress status
Attempt another DST to ensure the busy status persists
Retry once more to confirm every new command fails while the first test is active

function: scripts/conformance/01_admin/dst_test.py::test_dst_in_progress_abort_dst

Abort an in-progress device self-test using STC Fh and verify the log indicates the cancelled operation.

Reference

NVM Express Revision 1.4a.

Steps

Start the first DST command and read the Device Self-test log
Issue the abort DST command to cancel the running test
Read the Device Self-test log page to confirm the previous run was aborted

function: scripts/conformance/01_admin/dst_test.py::test_dst_short_abort_by_controller_reset

Trigger a controller-level reset during a short device self-test and verify the log records an abort due to reset.

Reference

NVM Express Revision 1.4a.

Steps

Confirm no device self-test is running before starting the scenario
Start a short DST and ensure it is reported as running
Issue a controller reset to abort the running short DST
Verify the controller reports no device self-test in progress
Validate the newest result indicates a reset-induced abort
Confirm the log shows no active DST before issuing a cleanup sequence
Start another short DST to clean up and abort it explicitly

function: scripts/conformance/01_admin/dst_test.py::test_dst_abort_by_format

Start a device self-test and then run Format NVM to confirm the self-test log shows the abort due to formatting.

Reference

NVM Express Revision 1.4a.

Steps

Issue a device self-test for the namespace and verify it remains active when short
Format the namespace to force the device self-test to abort
Read the Device Self-test log to confirm the format aborted the run

function: scripts/conformance/01_admin/dst_test.py::test_dst_abort_by_format_fna_0

Validate that Format NVM aborts any running device self-test when FNA is cleared and runs across nsid combinations.

Reference

NVM Express Revision 1.4a.

Steps

Skip the scenario when the controller implements a spec version earlier than 1.4
Read the current LBA format identifier for later format commands
Skip when the FNA bit is not 0 so the scenario remains applicable
Issue a short DST on namespace 1 to begin the first scenario
Format namespace 1 while the DST is active and wait briefly
Confirm the log reports the format-induced abort
Run another short DST on namespace 1 to validate formatting all namespaces
Format the entire subsystem to abort the short DST
Check that the abort result matches the previous case
Issue a short DST against all namespaces for cross-checking
Format the entire subsystem while the DST is running
Ensure the abort reason reflects the format action
Run another short DST on all namespaces to test formatting a single namespace
Format namespace 1 while the global DST is active
Verify the device self-test log captures the mixed-namespace abort

function: scripts/conformance/01_admin/dst_test.py::test_dst_abort_by_format_fna_1

Validate the Format NVM abort behavior for both specific and global namespaces when FNA is set.

Reference

NVM Express Revision 1.4a.

Steps

Skip the scenario when the controller advertises an NVMe revision earlier than 1.4
Skip when the controller reports FNA is clear
Cache the current LBA format identifier for the format command
Issue a short DST using the parametrized namespace ID
Format the specified namespace to abort the running DST
Inspect the Device Self-test log to confirm the abort reason

function: scripts/conformance/01_admin/dst_test.py::test_dst_abort_by_sanitize

Start a sanitize operation while a device self-test is running and ensure the log records the sanitize-induced abort.

Reference

NVM Express Revision 1.4a.

Steps

Skip when the NVMe spec version is below 1.4
Skip when sanitize operations are not supported by the controller
Define a helper callback to highlight sanitize notification events
Issue a DST command so the sanitize can abort it
Check the Device Self-test log to confirm the DST is active
Issue the sanitize command to force the DST to abort
Wait until the sanitize operation completes while tracking notifications
Clear the sanitize event by reading the log page
Verify the Device Self-test log indicates a sanitize-induced abort

function: scripts/conformance/01_admin/dst_test.py::test_dst_after_sanitize

Attempt to start a device self-test during an in-progress sanitize command and expect Device Self-test in Progress errors.

Reference

NVM Express Revision 1.4a.

Steps

Skip the scenario when sanitize is not supported
Start a sanitize operation to occupy the controller
Skip when the sanitize operation already finished before issuing DST
Issue a DST command that should be aborted by the in-progress sanitize
Monitor the sanitize status and capture the associated AER
Clear the sanitize event by reading the log page

function: scripts/conformance/01_admin/dst_test.py::test_dst_abort_by_command

Start a short device self-test, issue the abort opcode, and confirm the log reflects the abort result.

Reference

NVM Express Revision 1.4a.

Steps

Issue a short DST and confirm it is running
Send the abort DST opcode and allow background update
Refresh the Device Self-test log after the abort
Check that the newest result shows an abort while the current status is idle

function: scripts/conformance/01_admin/dst_test.py::test_dst_extended_time_limit

Measure an extended device self-test to ensure it completes within the Extended Device Self-test Time from Identify Controller.

Reference

NVM Express Revision 1.4a.

Steps

Retrieve and validate the Extended Device Self-test Time from Identify Controller
Force PS0 and disable APST to keep timing deterministic
Verify no device self-test is running prior to issuing the extended test
Issue the extended DST and note the start time
Poll the Device Self-test log until the extended DST finishes
Monitor progress while enforcing a guard timeout
Ensure the elapsed time is under the advertised EDSTT figure
Check that the log records a successful extended DST completion

function: scripts/conformance/01_admin/dst_test.py::test_dst_with_ioworker

Run a short device self-test while applying varying IO workloads to ensure completion occurs under two minutes.

Reference

NVM Express Revision 1.4a.

Steps

Start the IO stress workload and keep track of the total elapsed time
Issue the short DST while IO traffic is running
Poll the Device Self-test log until the DST finishes or times out
Reset the controller once the DST completes to clear the environment
Warn when the overall runtime exceeds the short DST two-minute requirement

function: scripts/conformance/01_admin/dst_test.py::test_dst_extended_not_abort_by_flr_reset

Perform an FLR during an extended device self-test and ensure the test either continues or finishes normally.

Reference

NVM Express Revision 1.4a.

Steps

Check the PCIe capability to ensure FLR is supported
Confirm there is no in-progress DST before the test begins
Start an extended DST operation and allow it to progress
Read the log to ensure the extended DST is still running
Perform the FLR and reset to recover the controller
Confirm the extended DST is either ongoing or reported as a normal completion

function: scripts/conformance/01_admin/dst_test.py::test_dst_extended_not_abort_by_controller_level_reset

Reset the controller while an extended device self-test runs and verify the operation persists across the reset.

Reference

NVM Express Revision 1.4a.

Steps

Start an extended DST operation and allow it to progress
Check the Device Self-test log to verify the DST is running
Reset the controller via CC.EN to introduce a controller-level reset
Confirm the Device Self-test log still reports the DST in progress

function: scripts/conformance/01_admin/dst_test.py::test_dst_short_abort_by_flr_reset

Issue an FLR during a short device self-test and confirm the test is aborted with the correct status.

Reference

NVM Express Revision 1.4a.

Steps

Check FLR capability support before running the scenario
Ensure there is no device self-test in progress beforehand
Start a short DST and confirm it is running
Poll the log once more prior to issuing FLR
Perform an FLR and reset the controller to apply the effect
Verify the short DST is aborted with the appropriate status code

file: scripts/conformance/01_admin/features_test

function: scripts/conformance/01_admin/features_test.py::test_features_fid_0

Validate Feature Identifier 0 rejects Set Features through an expected error status.

Reference

Source: NVM Express Revision 1.4a.

Steps

Issue Set Features for Feature Identifier 0 and expect an Invalid Field status

function: scripts/conformance/01_admin/features_test.py::test_features_sel_00

Confirm Select value 0 returns the current attribute by issuing Get/Set Features.

Reference

Source: NVM Express Revision 1.4a.

Steps

Write and read Feature Identifier 4 with Select 0 to capture the current value
Validate the change took effect and restore the original configuration

function: scripts/conformance/01_admin/features_test.py::test_features_sel_01

Verify Select values 1 and 2 report default and saved attributes and reset restores defaults.

Reference

Source: NVM Express Revision 1.4c.

Steps

Confirm Temperature Threshold Current Setting is not persistent across power events
check if the feature is saveable
check the current operating attribute shall be the same as the default
a Get Features command to read the saved value returns the default value.
setfeature to change the current operating attribute
verify if the current operating attribute is set correctly
verify the default attribute value is not changed
the default value is used after a Controller Level Reset
restore the current operating attribute to original value

function: scripts/conformance/01_admin/features_test.py::test_features_sel_01_reserved_bit

Verify reserved bits in Feature Identifier 4 writes are ignored by the controller.

Reference

Source: NVM Express Revision 1.4a.

Steps

Check the current operating attribute before injecting invalid data
Attempt to program Feature 4 with the reserved bit set in cdw11
Confirm the reserved bit is ignored when reading the current operating attribute
restore the current operating attribute to original value

function: scripts/conformance/01_admin/features_test.py::test_features_sel_11

Check Select value 3 reports feature capabilities when Save is supported.

Reference

Source: NVM Express Revision 1.4a.

Steps

skip if feature Save is not supported
Issue Get Features commands with Select 3 to report capability data
Expect each command to complete successfully

function: scripts/conformance/01_admin/features_test.py::test_features_invalid_sel

Ensure Get Features commands with invalid Select values return errors.

Reference

Source: NVM Express Revision 1.4a.

Steps

Issue Get Features commands with invalid Select values
The commands shall complete with Invalid Field errors

function: scripts/conformance/01_admin/features_test.py::test_features_set_volatile_write_cache

Measure write latency impact when toggling the Volatile Write Cache.

Reference

Source: NVM Express Revision 1.4a.

Steps

Collect the SMART temperature for additional telemetry
skip if volatile cache is not present
get the original write cache setting
enable the write cache and verify the feature is set correctly
Prime the queue pair with several writes to obtain a stable latency reading
Measure the write latency with the write cache enabled for comparison
disable the cache and verify the feature
Measure the write latency with the write cache disabled
recover original write cache setting
Compare the two latency values and confirm caching improves performance

function: scripts/conformance/01_admin/features_test.py::test_features_set_invalid_ncqr

Confirm invalid queue counts in Feature Identifier 7 raise Invalid Field errors.

Reference

Source: NVM Express Revision 1.4a.

Steps

set feature Number of Queues to 0xffff, the command shall complete with error
set feature Number of Queues to 0xffff0000, the command shall complete with error
set feature Number of Queues to 0xffffffff, the command shall complete with error

function: scripts/conformance/01_admin/features_test.py::test_features_num_of_queues

Verify a controller limited to two queues rejects a third I/O queue creation.

Reference

Source: NVM Express Revision 1.4a.

Steps

Define a custom initialization routine that limits the controller to two queues
Disable cc.en and wait for csts.rdy to clear
Configure the admin queue registers
Program the CC register with desired queue entries
Enable the controller by setting cc.en
Wait for csts.rdy to assert
Identify the controller and namespaces
Set and query the number of queues via Feature 7
Create a controller instance constrained to two queues
Check the reported number of queues and skip if the limit differs
Create two I/O queue pairs within the configured limit
Ensure creating an additional queue fails
Delete the created qpairs to release resources

function: scripts/conformance/01_admin/features_test.py::test_features_apst_buffer_length

Validate the APST data structure occupies 256 bytes when retrieved by Get Features.

Reference

Source: NVM Express Revision 1.4a.

Steps

create 4k buffer, pvalue is all-one data
check apst is enabled, the data structure is 256 bytes
check the buffer 256 byte should be original value all-one data
create 4k buffer, pvalue is all-zero data
check apst is enabled, the data structure is 256 bytes
check the buffer 256 byte should be original value all-zero data

function: scripts/conformance/01_admin/features_test.py::test_features_timestamp

Exercise the Timestamp feature across resets and programmed values to ensure expected behavior.

Reference

Source: NVM Express Revision 1.4a.
Source: NVM Express Revision 2.0.

Steps

check ONCS
verify the length of the data buffer
get current timestamp
get the timestamp again after 1 second
get original timestamp status
reset and check status
set timestamp and check status again
get current timestamp
get the timestamp again after 1 second
set a max value: 0xffff_ffff_ffff
set a min value: 0
reset and check timestamp and status according to the Timestamp Origin

file: scripts/conformance/01_admin/format_test

function: scripts/conformance/01_admin/format_test.py::test_format_function

Verify namespace and controller-wide Format NVM success by issuing commands with nsid 0xffffffff and nsid 1.

Reference

Source: NVM Express Revision 1.4a.

Steps

Issue a Format NVM command targeting all namespaces (nsid 0xffffffff) and expect completion
Issue a Format NVM command targeting namespace 1 and expect completion

function: scripts/conformance/01_admin/format_test.py::test_format_secure_erase_function

Validate secure erase settings by issuing Format NVM with SES 1 and SES 2 for both broadcast and namespace-specific scopes.

Reference

Source: NVM Express Revision 1.4a.

Steps

Issue a Format NVM command with SES 1 for all namespaces and expect completion
Issue a Format NVM command with SES 1 for namespace 1 and expect completion
Issue a cryptographic erase when supported and expect the commands to complete successfully

function: scripts/conformance/01_admin/format_test.py::test_format_with_ioworker

Exercise Format NVM under IO load by running an ioworker during the format and validating completion status.

Reference

Source: NVM Express Revision 1.4a.

Steps

Prepare a completion callback that records the Format NVM result status
define a callback function for format command
Run ioworker traffic while issuing a Format NVM command to namespace 1
Check the completion status returned by the Format NVM command

function: scripts/conformance/01_admin/format_test.py::test_format_and_read

Validate read behavior during Format NVM by overlapping a read command with an in-flight format.

Reference

Source: NVM Express Revision 1.4a.

Steps

Issue a Format NVM command and intentionally leave it outstanding
Issue a read command while the format is outstanding and validate completion status
Wait until the outstanding Format NVM command completes

function: scripts/conformance/01_admin/format_test.py::test_format_invalid_ses

Confirm the controller rejects unsupported secure erase settings by issuing Format NVM with invalid SES values.

Reference

Source: NVM Express Revision 1.4a.

Steps

Issue Format NVM commands with SES values 3 through 7 and expect an error status

function: scripts/conformance/01_admin/format_test.py::test_format_not_support_crypto_erase

Verify cryptographic erase is rejected when unsupported by attempting Format NVM with SES 2 on such controllers.

Reference

Source: NVM Express Revision 1.4a.

Steps

Skip the test when the controller advertises cryptographic erase capability
Issue a Format NVM command requesting cryptographic erase and expect an error response

function: scripts/conformance/01_admin/format_test.py::test_format_invalid_lbaf

Check LBA format validation by issuing Format NVM with invalid LBAF values derived from the Identify data.

Reference

Source: NVM Express Revision 1.4a.

Steps

Identify the namespace to determine the highest supported LBA format
Issue Format NVM commands with unsupported LBAF values and expect Invalid Format errors
Restore the namespace to the original LBAF and expect success

function: scripts/conformance/01_admin/format_test.py::test_format_invalid_nsid

Exercise Format NVM namespace validation by issuing commands to valid and invalid nsid values.

Reference

Source: NVM Express Revision 1.4a.

Steps

Issue baseline Format NVM commands with valid nsid parameters
Issue Format NVM commands with nsid zero and expect Invalid Namespace or Format errors
Issue Format NVM commands with nsid 0xfffffffb and expect Invalid Namespace or Format errors
Issue Format NVM commands with nsid 0xff and expect Invalid Namespace or Format errors

function: scripts/conformance/01_admin/format_test.py::test_format_verify_data

Confirm that Format NVM erases user data by writing, reading, formatting, and re-reading specific LBAs.

Reference

Source: NVM Express Revision 1.4a.

Steps

Prepare read and write buffers and initialize data patterns
Write the pattern to LBA 0 and verify it by reading back
Issue a Format NVM command and read the LBA to ensure the pattern is cleared
The data in specified LBA is expected to be erased after the format
Repeat write, verify, format, and validation cycles with SES 1
Perform the same validation for cryptographic erase when supported

file: scripts/conformance/01_admin/fw_download_test

function: scripts/conformance/01_admin/fw_download_test.py::test_fw_download_out_of_order

Validate firmware download accepts reversed ranges by submitting the second chunk before the first.

Reference

NVM Express Revision 1.4a.

Steps

Allocate firmware download buffer that spans two chunks
Issue firmware download requests out of order to confirm reversed ranges complete

function: scripts/conformance/01_admin/fw_download_test.py::test_fw_download_overlap

Check overlapping firmware downloads by repeating an already transferred range.

Reference

NVM Express Revision 1.4a.

Steps

Download adjacent firmware chunks in order as a control
Reissue a previously downloaded chunk to validate overlap handling

function: scripts/conformance/01_admin/fw_download_test.py::test_fw_download_reset

Verify download progress is discarded after a controller reset by resending the final chunk post reset.

Reference

NVM Express Revision 1.4a.

Steps

Download sequential firmware chunks prior to triggering a controller reset
Reset controller and resend the final chunk to ensure the transfer restarts cleanly

function: scripts/conformance/01_admin/fw_download_test.py::test_fw_download_prp

Exercise firmware download PRP offset handling by issuing transfers with valid and invalid offsets.

Reference

NVM Express Revision 1.4a.

Steps

Allocate a buffer large enough for valid and invalid PRP offset tests
Program a valid PRP offset covering exactly one image chunk and download it
Program an invalid PRP offset near a page boundary and repeat the download

file: scripts/conformance/01_admin/identify_test

function: scripts/conformance/01_admin/identify_test.py::test_identify_all_nsid

Verifies Identify rejects invalid namespace IDs by issuing requests to both valid and invalid NSIDs.

Reference

Reference: NVM Express Revision 1.4a

Steps

Send Identify commands with valid namespace IDs to confirm baseline behavior.
Send Identify commands with invalid namespace IDs and expect Invalid Namespace or Format warnings.

function: scripts/conformance/01_admin/identify_test.py::test_identify_namespace_data_structure

Validates the Identify namespace data and the active namespace list by reading and checking key fields.

Reference

Reference: NVM Express Revision 1.4a

Steps

Retrieve the active namespace ID list with an Identify command.
Confirm that the controller reports exactly one namespace.
Read the Identify Namespace data structure for namespace 1.
Verify the returned buffer contains data.
Check that NSZE equals NCAP as required for single namespace controllers.

function: scripts/conformance/01_admin/identify_test.py::test_identify_reserved_cns

Ensures Identify commands issued with reserved CNS values are aborted with Invalid Field in Command status.

Reference

Reference: NVM Express Revision 1.4a

Steps

Issue Identify commands using reserved CNS values and expect Invalid Field warnings.

function: scripts/conformance/01_admin/identify_test.py::test_identify_nsze_ncap_nuse

Checks the NSZE, NCAP, and NUSE fields from Identify Namespace data to ensure they follow the mandated ordering.

Reference

Reference: NVM Express Revision 1.4a

Steps

Read NSZE, NCAP, and NUSE values from namespace 1.
Check that Namespace Size >= Namespace Capacity >= Namespace Utilization.
Force NUSE to be zero when ANA indicates inaccessible or persistent loss conditions.

function: scripts/conformance/01_admin/identify_test.py::test_identify_controller_with_nsid

Validates Identify Controller behavior when the nsid field is supplied by issuing commands with allowed and disallowed NSIDs.

Reference

Reference: NVM Express Revision 1.4c
Reference: NVM Express Revision 2.0

Steps

Read Identify Controller data with nsid set to zero.
Issue Identify Controller commands with invalid NSIDs and expect possible Invalid Field status.

function: scripts/conformance/01_admin/identify_test.py::test_identify_new_cns

Confirms Identify supports the CNS values introduced for command-set-specific namespace and controller data.

Reference

Reference: NVM Express Revision 2.0a

Steps

Skip the test when the controller advertises an NVMe spec revision earlier than 2.0.
Read the I/O Command Set specific Identify Namespace data structure.
Read the I/O Command Set specific Identify Controller data structure.
Read the active namespace ID list associated with the specified I/O Command Set.

file: scripts/conformance/01_admin/logpage_test

function: scripts/conformance/01_admin/logpage_test.py::test_getlogpage_page_id

Validate log page identifier handling by issuing Get Log Page commands with valid and invalid IDs.

Reference

NVM Express Revision 1.4a

Steps

send get log page command with valid Log Page Identifier, and commands shall complete successfully
send get log page command with invalid Log Page Identifier, and commands shall complete with error

function: scripts/conformance/01_admin/logpage_test.py::test_getlogpage_lid_0

Confirm Log Identifier 00h handling by enumerating supported IDs and reading mandatory log pages.

Reference

NVM Express Revision 2.0a

Steps

skip if NVMe spec version is below 2.0
Read Log Identifier 00h to confirm controllers expose the reserved entry.
lid 0,1,2,3,12h are mandatory
if LPA Bit_5 = 1, check lid 13h

function: scripts/conformance/01_admin/logpage_test.py::test_getlogpage_different_size

Check partial Get Log Page transfers by reading SMART information with varying lengths.

Reference

NVM Express Revision 1.4a

Steps

get the full smart log page
read partial smart log page, and check data
read data beyond smart log page, and check data

function: scripts/conformance/01_admin/logpage_test.py::test_getlogpage_data_unit_read

Verify SMART Data Units Read increments by issuing read, compare, and verify workloads.

Reference

NVM Express Revision 1.4a

Steps

skip if compare command is not supported
Prepare SMART log buffer and capture namespace geometry for unit conversions.
get original Data Units Read
send 1000 read commands
check the Data Units Read has increased
send 1000 compare commands
check the Data Units Read has increased
if the controller supports verify command, send 1000 verify commands
the Data Units Read shall be increased

function: scripts/conformance/01_admin/logpage_test.py::test_getlogpage_data_unit_write

Verify SMART Data Units Written increments using write workloads and write-uncorrectable commands.

Reference

NVM Express Revision 1.4a

Steps

check if the controller supports Write Uncorrectable command
Prepare SMART log buffer and derive namespace geometry for the increments.
get original Data Units Written
send 1000 write commands
check the Data Units Written has increased
send 1000 Write Uncorrectable commands
check the Data Units Written has not changed
check if the controller supports Write Zeroes command
send a Write Zeroes commands
check the Data Units Written has not changed
write the lba

function: scripts/conformance/01_admin/logpage_test.py::test_getlogpage_namespace

Validate SMART log namespace scoping by issuing Get Log Page commands with several NSIDs.

Reference

NVM Express Revision 1.4a

Steps

skip if NVMe spec version is below 1.4
Fetch the SMART log with the broadcast NSID to capture controller-wide measurements.
the command completes successfully and the composite temperature is not 0
send get log page command with nsid=1: log page on a per namespace basis
the command completes successfully and the composite temperature is not 0
send get log page commands with invalid namespace
check the get log page command complete with error

function: scripts/conformance/01_admin/logpage_test.py::test_getlogpage_offset

Verify log page offsets by comparing overlapping SMART data and triggering offset errors.

Reference

NVM Express Revision 1.4c

Steps

read smart data
read smart data with log page offset
compare smart data with different offset, shall be different
offset is greater than the logpage size

function: scripts/conformance/01_admin/logpage_test.py::test_getlogpage_smart_composite_temperature

Exercise composite temperature thresholds by manipulating features and reading SMART logs.

Reference

NVM Express Revision 1.4a

Steps

get the current composite temperature
set feature enable all asynchronous events
set the composite temperature threshold lower than current temperature
check AER notification is triggered
send a getlogpage command to get the SMART data
check if Critical Warning bit 1 in SMART data was set
over composite temperature threshold
clear event by read log page
set the composite temperature threshold higher than current temperature
revert to default

function: scripts/conformance/01_admin/logpage_test.py::test_getlogpage_after_error

Validate error information log updates by injecting admin command failures.

Reference

NVM Express Revision 1.4a

Steps

Record the Log Page Attributes for later conditional checks.
Track the command completion M bit used to increment the error count.
Capture the M bit from command completions via a callback hook.
send admin command with opcode=0x6, cdw10=0xFF
send get error log cmd and record nerror1
send admin command with opcode=0x6, cdw10=0xFF
send get error log cmd and record nerror2
verify error count value and number of Error Information Log Entries

function: scripts/conformance/01_admin/logpage_test.py::test_getlogpage_retain_asynchronous_event

Confirm retained asynchronous temperature events remain latched when RAE is set in Get Log Page.

Reference

NVM Express Revision 1.4a

Steps

get the current composite temperature
set feature enable all asynchronous events
set the composite temperature threshold lower than current temperature
check AER notification is triggered
send a getlogpage command to get the SMART data
check if Critical Warning bit 1 in SMART data was set
over composite temperature threshold
get log page with retain asynchronous event.
clear over Temperature Threshold event
trigger under Temperature Threshold event, but the event type is masked

function: scripts/conformance/01_admin/logpage_test.py::test_getlogpage_not_retain_asynchronous_event

Verify temperature asynchronous events clear when Get Log Page does not set the RAE bit.

Reference

NVM Express Revision 1.4a

Steps

get the current composite temperature
set feature enable all asynchronous events
get current temperature
set the composite temperature threshold lower than current temperature
check AER notification is triggered
send a getlogpage command to get the SMART data
check if Critical Warning bit 1 in SMART data was set
over composite temperature threshold
send get log page command to clear an Asynchronous Event.
clear over Temperature Threshold event
send get log page command to clear an Asynchronous Event.
trigger under Temperature Threshold event, the event type is masked
send get log page command to clear an Asynchronous Event.
clear Over Temperature Threshold event
power cycle the drive

function: scripts/conformance/01_admin/logpage_test.py::test_getlogpage_persistent_event_log

Generate persistent event log activity and verify format records before and after formatting.

Reference

NVM Express Revision 2.0

Steps

Parse the returned PEL buffer into a list of event IDs for validation.
check PEL size
fresh events in the logpage
check events: no format event left
format start and complete: 07/08
check events of format, and reset is still there

function: scripts/conformance/01_admin/logpage_test.py::test_getlogpage_exceed_mdts

Validate MDTS enforcement by issuing Get Log Page commands exceeding the controller transfer size.

Reference

NVM Express Revision 1.4a

Steps

check mdts value
Read a small SMART log page as a control transfer.
Read another log page below MDTS for reference.
logpage size is larger than MDTS, error expected

function: scripts/conformance/01_admin/logpage_test.py::test_getlogpage_host_initiated_telemetry

Exercise host initiated telemetry log capture and walk through all advertised data areas.

Reference

NVM Express Revision 2.0a

Steps

Allocate a telemetry buffer for subsequent log transfers.
Skip execution if the controller does not advertise telemetry support.
check if telemetry is supported
capture host initiated telemetry log
get Telemetry Host-Initiated Data Generation Number
capture host initiated telemetry log
check if Telemetry Host-Initiated Data Generation Number is incremented each time
get telemetry header info
Record the last block value for telemetry data area 1.
Record the last block value for telemetry data area 2.
Record the last block value for telemetry data area 3.
Bit 6 of the Log Page Attributes field is set to ‘1’ in the Identify Controller Data Structure
Extended Telemetry Data Area 4 Supported (ETDAS) field is set to 1h in the Host Behavior Support feature
get area 4 last block
Validate that successive data area last block values are monotonic.
Record the host-initiated generation number after the header read.
print header data
get all data block: [1, last]
read last block twice and compare data
get telemetry data beyond last block, error expected
with pytest.warns(UserWarning, match=”ERROR status: 00/02″):
nvme0.getlogpage(7, buf, offset=512*(last+1)).waitdone()
check the generate number again
invalid offset, error expected

function: scripts/conformance/01_admin/logpage_test.py::test_getlogpage_controller_initiated_telemetry

Exercise controller initiated telemetry retrieval across all populated data areas.

Reference

NVM Express Revision 2.0a

Steps

Allocate a telemetry buffer to read controller-initiated data.
Skip execution when telemetry log pages are not supported.
check if telemetry is supported
get telemetry header
check telemetry header data
Record the last block value for telemetry data area 1.
Record the last block value for telemetry data area 2.
Record the last block value for telemetry data area 3.
Ensure the successive telemetry data areas remain monotonic.
Record the last block value for telemetry data area 4 when present.
print header data
get all data block: [1, last]
read last block twice and compare data
check the generate number again
invalid offset, error expected

function: scripts/conformance/01_admin/logpage_test.py::test_getlogpage_telemetry_offset_not_512

Check telemetry offset alignment by issuing misaligned Get Log Page commands.

Reference

NVM Express Revision 2.0a

Steps

define non-512-aligned offset
Skip when telemetry logs are not advertised by the controller.
Test for Telemetry Host-Initiated Log Page (ID = 7)
Expecting error due to misaligned offset
Test for Telemetry Controller-Initiated Log Page (ID = 8)
Expecting error due to misaligned offset

function: scripts/conformance/01_admin/logpage_test.py::test_getlogpage_telemetry_length_not_512

Ensure telemetry transfers require 512-byte multiples by issuing misaligned lengths.

Reference

NVM Express Revision 2.0a

Steps

using buffers of non-512-aligned lengths
Skip when telemetry logs are not advertised by the controller.
Test for Telemetry Host-Initiated Log Page (LID = 07h)
Expecting error due to misaligned length
Test for Telemetry Controller-Initiated Log Page (LID = 08h)
Expecting error due to misaligned length

function: scripts/conformance/01_admin/logpage_test.py::test_getlogpage_host_initiated_telemetry_data_change

Verify host initiated telemetry data updates only after issuing a regeneration command.

Reference

NVM Express Revision 2.0a

Steps

check if telemetry is supported
Skip when telemetry logs are not advertised by the controller.
Trigger telemetry regeneration to capture fresh host data.
get the data area 1 size
get host initiated telemetry data
capture new host initiated telemetry data
get new data area 1 size
get another copy of telemetry data

function: scripts/conformance/01_admin/logpage_test.py::test_getlogpage_nsid_0

Validate SMART log behavior when NSID is set to 0h by monitoring Data Units Written increments.

Reference

NVM Express Revision 2.0a

Steps

skip if NVMe spec version is below 2.0
get original Data Units Written
send 1000 write commands
check the Data Units Written has increased

function: scripts/conformance/01_admin/logpage_test.py::test_getlogpage_error_info_cid_ffff

Verify error log entries report FFFFh for SQID/CID when events are not tied to a specific command.

Reference

NVM Express Revision 2.0a

Steps

issue a flush command with cid 0xffff
issue an AER command
create CQ and SQ
delete SQ first
write doorbell of the deleted SQ to cause the event Invalid Doorbell Register
read log page to clear the event
issue a error info log page
check sqid and cid value in log page, expect 0xffff
delete cq

function: scripts/conformance/01_admin/logpage_test.py::test_getlogpage_eye_opening_measurement

Collect Rx Eye Opening Measurement data by driving EOM log commands and parsing the results.

Reference

TP4119a Rx Phy Eye Opening Measurement (EOM)

Steps

Allocate a large buffer for EOM log transfers and cache the controller ID.
read log data, No measurement has been started
skip if EOM is not supported
Verify the initial measurement header reports the idle state.
start measurement and read log data
check status after estimated time
get the lane descriptor
Retrieve the lane descriptor and eye data for the requested measurement.
abort measurement and clear log
read log data
start measurement and read log data
reset to initilize the EOM log
reserved action

file: scripts/conformance/01_admin/queue_test

function: scripts/conformance/01_admin/queue_test.py::test_queue_create_cq_basic_operation

Validate IO queue creation by issuing write and read traffic and confirming completions are serviced.

Reference

Specification: NVM Express Revision 1.4a

Steps

Issue a baseline write followed by repeated read commands on the created queue.
Wait for every outstanding read command to complete without errors.

function: scripts/conformance/01_admin/queue_test.py::test_queue_create_cq_with_invalid_id

Verify IO CQ creation rejects invalid queue identifiers by issuing Create IO CQ commands with unsupported IDs.

Reference

Specification: NVM Express Revision 1.4a

Steps

Create a CQ with ID 5 to confirm the nominal creation path succeeds.
Attempt to create a CQ with ID 0 and expect Invalid Queue Identifier.
Attempt to create a CQ with ID 0xffff and expect Invalid Queue Identifier.
Attempt to create CQs whose IDs exceed the supported count and expect Invalid Queue Identifier.
Attempt to create a CQ with a duplicate ID and expect Invalid Queue Identifier.
Delete the baseline CQ to clean up the resources.

function: scripts/conformance/01_admin/queue_test.py::test_queue_create_sq_with_invalid_id

Ensure IO SQ creation rejects invalid queue identifiers by issuing Create IO SQ commands with unsupported IDs.

Reference

Specification: NVM Express Revision 1.4a

Steps

Create a CQ with ID 1 to serve as the target for SQ creation.
Create a baseline SQ with ID 5 to confirm successful creation.
Attempt to create an SQ with ID 0 and expect Invalid Queue Identifier.
Attempt to create an SQ with ID 0xffff and expect Invalid Queue Identifier.
Attempt to create SQs with IDs that exceed the supported number and expect Invalid Queue Identifier.
Attempt to create a duplicate SQ ID and expect Invalid Queue Identifier.
Delete the SQ and CQ to release resources.

function: scripts/conformance/01_admin/queue_test.py::test_queue_delete_cq_with_invalid_id

Confirm Delete IO CQ commands fail when issued with invalid queue identifiers by targeting unsupported IDs.

Reference

Specification: NVM Express Revision 1.4a

Steps

Delete a CQ with ID 5 to confirm the baseline path succeeds.
Attempt to delete CQ ID 0 and expect Invalid Queue Identifier.
Attempt to delete CQ ID 0xffff and expect Invalid Queue Identifier.
Attempt to delete CQ IDs bigger than the supported maximum and expect Invalid Queue Identifier.
Attempt to delete a non-existent CQ ID and expect Invalid Queue Identifier.

function: scripts/conformance/01_admin/queue_test.py::test_queue_delete_sq_with_invalid_id

Ensure Delete IO SQ commands return Invalid Queue Identifier when targeting unsupported IDs.

Reference

Specification: NVM Express Revision 1.4a

Steps

Create a CQ and SQ pair and confirm the baseline delete succeeds.
Attempt to delete SQ ID 0 and expect Invalid Queue Identifier.
Attempt to delete SQ ID 0xffff and expect Invalid Queue Identifier.
Attempt to delete SQ IDs beyond the supported count and expect Invalid Queue Identifier.
Attempt to delete a non-existent SQ ID and expect Invalid Queue Identifier.

function: scripts/conformance/01_admin/queue_test.py::test_queue_create_cq_with_invalid_queue_size

Validate Create IO CQ rejects invalid queue sizes by exercising legal and illegal QSIZE values.

Reference

Specification: NVM Express Revision 1.4a

Steps

Create CQs with supported sizes to confirm the reference behavior.
Skip the overflow size checks on hardware that already advertises the maximum MQES.
Attempt to create CQs at oversized values such as 0xffff and expect Invalid Queue Size.
Attempt to create a CQ with size 0x10000 and expect Invalid Queue Size.
Attempt to create a CQ with size 1 and expect Invalid Queue Size.
Attempt to create CQs that exceed the reported MQES and expect Invalid Queue Size.
Attempt to create a CQ with size 0 and expect a failed assertion.
Create a CQ with a supported size as a final sanity check.

function: scripts/conformance/01_admin/queue_test.py::test_queue_create_sq_with_invalid_queue_size

Confirm Create IO SQ enforces queue size limits by issuing commands with supported and unsupported QSIZE values.

Reference

Specification: NVM Express Revision 1.4a

Steps

Create a CQ that the SQs can target.
Create SQs with supported sizes to prove successful operation.
Attempt to create an SQ with size 1 and expect Invalid Queue Size.
Delete the remaining SQ and CQ to clean up.

function: scripts/conformance/01_admin/queue_test.py::test_queue_create_sq_with_invalid_queue_size_mqes

Stress Create IO SQ queue-size validation near MQES limits by issuing oversized QSIZE requests.

Reference

Specification: NVM Express Revision 1.4a

Steps

Skip the extended tests if the controller already advertises the largest MQES.
Create a CQ that will be referenced by the SQs under test.
Attempt to create an SQ with size 0xffff and expect Invalid Queue Size.
Attempt to create an SQ with size 0x10000 and expect Invalid Queue Size.
Attempt to create SQs larger than MQES and expect Invalid Queue Size.
Attempt to create an SQ with size 0 and expect a failed assertion.
Create a supported SQ to verify cleanup and then delete the CQ.

function: scripts/conformance/01_admin/queue_test.py::test_queue_create_sq_physically_contiguous

Verify Create IO SQ enforces physical contiguity when CAP.CQR requires PC=1 by toggling PC and PRP offsets.

Reference

Specification: NVM Express Revision 1.4a

Steps

Skip the test if the controller does not require physically contiguous queues.
Attempt to create an SQ with PC cleared and expect Invalid Queue Deletion.
Create an SQ with PC asserted to confirm normal completion.
Set a non-zero PRP offset and expect PRP Offset Invalid.

function: scripts/conformance/01_admin/queue_test.py::test_queue_create_sq_non_physically_contiguous

Validate Create IO SQ behavior when CAP.CQR allows PRP lists by toggling PC and PRP offsets.

Reference

Specification: NVM Express Revision 1.4a

Steps

Skip the test if the controller mandates physically contiguous queues.
Create SQs with PC asserted and cleared to confirm normal completion with valid PRPs.
Provide a PRP with a non-zero offset and expect PRP Offset Invalid.

function: scripts/conformance/01_admin/queue_test.py::test_queue_create_cq_non_physically_contiguous

Validate Create IO CQ behavior when CAP.CQR allows PRP lists and ensure non-zero offsets fault.

Reference

Specification: NVM Express Revision 1.4a

Steps

Skip the test if the controller enforces physically contiguous queues.
Create CQs with PC asserted and cleared to establish the reference behavior.
Program a PRP with a non-zero offset and expect PRP Offset Invalid.

function: scripts/conformance/01_admin/queue_test.py::test_queue_create_cq_invalid_interrupt_vector

Ensure Create IO CQ validates MSI/MSI-X interrupt vectors by issuing commands with vectors beyond hardware limits.

Reference

Specification: NVM Express Revision 1.4a

Steps

Initialize the invalid interrupt vector placeholder.
Query the MSI capability to derive an out-of-range vector number.
Query the MSI-X capability to identify another invalid interrupt vector.
Skip the test if no invalid interrupt vector can be identified.
Create IO CQs with invalid interrupt vectors and expect Invalid Interrupt Vector errors.

function: scripts/conformance/01_admin/queue_test.py::test_queue_delete_cq_before_sq

Verify Delete IO CQ fails with Invalid Queue Deletion when outstanding SQs still reference the CQ.

Reference

Specification: NVM Express Revision 1.4a

Steps

Create one CQ with multiple associated SQs to prepare the dependency graph.
Attempt to delete the CQ while SQs exist and expect Invalid Queue Deletion.
Delete one SQ to reduce the reference count.
Attempt to delete the CQ again and still expect Invalid Queue Deletion.
Delete the remaining SQs to remove all dependencies.
Delete the CQ after all SQs are removed and expect success.

function: scripts/conformance/01_admin/queue_test.py::test_queue_delete_full_sq

Validate Delete IO SQ behavior when outstanding commands fill every queue and dependencies exist.

Reference

Specification: NVM Express Revision 1.4a

Steps

Create the maximum number of SQs associated with a single CQ.
Fill every SQ with outstanding commands to block CQ deletion.
Attempt to delete the CQ while SQs have outstanding commands and expect Invalid Queue Deletion.
Delete a subset of SQs to reduce the outstanding load.
Attempt to delete the CQ again and expect Invalid Queue Deletion.
Delete more SQs but still leave outstanding queues.
Attempt to delete the CQ once more and expect Invalid Queue Deletion.
Delete the final SQ so the CQ has no dependencies.
Delete the CQ and expect a successful completion.

function: scripts/conformance/01_admin/queue_test.py::test_queue_create_sq_queue_priority

Verify Create IO SQ accepts each supported queue priority by creating SQs with varying QPRIO values.

Reference

Specification: NVM Express Revision 1.4a

Steps

Create SQs with different QPRIO values and confirm that each completes successfully.

function: scripts/conformance/01_admin/queue_test.py::test_queue_set_after_create_queues

Ensure Set Features Number of Queues returns Command Sequence Error once IO queues have been created.

Reference

Specification: NVM Express Revision 1.4a

Steps

Skip the test if the controller does not advertise NVMe 1.4 or later.
Create a CQ and SQ so that IO queues already exist.
Issue Set Features Number of Queues and expect Command Sequence Error.
Delete the SQ and CQ to clean up resources.

function: scripts/conformance/01_admin/queue_test.py::test_queue_create_qpair_exceed_limit

Verify the controller rejects queue creation once the reported Number of Queues limit is exceeded.

Reference

Specification: NVM Express Revision 1.4a

Steps

Create queue pairs up to the controller-reported maximum.
Attempt to create one more queue pair and expect Invalid Queue Identifier.
Delete all queue pairs to free resources.

function: scripts/conformance/01_admin/queue_test.py::test_queue_setfeature_different_cq_sq_number

Verify Set Features Number of Queues supports different CQ and SQ counts and enforces the advertised limits.

Reference

Specification: NVM Express Revision 1.4a

Steps

Initialize the controller without programming the Number of Queues feature.
Disable CC.EN and wait for CSTS.RDY to clear.
Initialize the admin queue registers.
Program the controller configuration register without enabling the controller.
Enable CC.EN.
Wait for CSTS.RDY to assert.
Identify the controller and namespaces.
Initialize the controller before programming the Number of Queues feature.
Program different CQ and SQ counts and verify the controller accepts them.
Create every allowed CQ and SQ to reach the configured limits.
Attempt to create an additional CQ and expect failure.
Attempt to create an additional SQ and expect failure.
Delete the created SQs and CQs to clean up resources.

function: scripts/conformance/01_admin/queue_test.py::test_queue_invalid_prp_offset

Verify Create IO CQ requires zero PRP offsets by issuing commands with various misaligned PRP entries.

Reference

Specification: NVM Express Revision 1.4a

Steps

Initialize a PRP entry with zero offset as the passing reference case.
Figure 149 requires the PRP entry offset to be zero in all cases.
Send PRPs with various invalid offsets and expect PRP Offset Invalid.

function: scripts/conformance/01_admin/queue_test.py::test_queue_cq_sqhd

Verify SQ Head values in admin CQ entries advance correctly across commands and asynchronous events.

Reference

Specification: NVM Express Revision 1.4a

Steps

Initialize the controller without enabling AER handling.
Disable CC.EN and wait for CSTS.RDY to clear.
Program the admin queue registers.
Program the controller configuration register without enabling the controller.
Enable CC.EN.
Wait for CSTS.RDY to assert.
Identify the controller and namespaces.
Configure the number of queues used for admin traffic.
Issue a Get Log Page command and capture the reported SQ head value.
Issue another command and ensure SQ head increments by one.
Issue a command after posting an AER and verify its SQ head advances by two.

function: scripts/conformance/01_admin/queue_test.py::test_queue_sq_fuse_reserved_value

Ensure SQEs that set reserved FUSE field values return Invalid Field in Command or are aborted.

Reference

Specification: NVM Express Revision 1.4a

Steps

Create a minimal IO queue pair that can host the fuse experiments.
Set the SQE FUSE field to the reserved value 0x3 and submit one entry.
Poll the CQE and expect Invalid Field in Command to be reported.

function: scripts/conformance/01_admin/queue_test.py::test_queue_enabled_msix_interrupt_all

Validate MSI-X interrupts assert for a qpair by issuing IO on the highest supported SQID.

Reference

Specification: NVM Express Revision 1.4a

Steps

Create a qpair at the highest supported SQID to exercise the MSI-X wiring.
Clear any existing MSI-X state to start with a clean baseline.
Issue an IO to trigger MSI-X and verify the interrupt fires.
Attempt to create a qpair with an unsupported SQID and expect creation to fail.

file: scripts/conformance/01_admin/sanitize_test

function: scripts/conformance/01_admin/sanitize_test.py::test_sanitize_operations_basic

Verify the controller sanitization log updates by issuing block erase sanitize and polling the log page.

Reference

NVM Express Revision 1.4a.

Steps

Write sample data into the namespace
Verify data before the sanitize operation
Issue block erase sanitize and monitor sanitize progress via log page and AER
Ensure sanitize completion bit indicates the last sanitize completed successfully
Ensure the most recent sanitize completed successfully flag is set
Confirm SCDW10 reflects the Cdw10 value from the sanitize command
Verify data is altered after sanitize completes

function: scripts/conformance/01_admin/sanitize_test.py::test_sanitize_crypto_erase_progress

Verify Crypto Erase sanitize updates the log and removes user data by issuing crypto erase and reading the namespace.

Reference

NVM Express Revision 1.4a.

Steps

Check if controller supports Crypto Erase capability
Write sample user data and verify it prior to sanitize
Issue a Crypto Erase sanitize command
Monitor sanitize progress via log page polling and AER notifications
Confirm data is erased after the Crypto Erase operation
Ensure sanitize completion bit indicates success after Crypto Erase
Ensure sanitize success flag is set after Crypto Erase
Confirm SCDW10 records the Crypto Erase command Dword 10 value

function: scripts/conformance/01_admin/sanitize_test.py::test_sanitize_abort_non_allowed_command

Ensure sanitize in progress aborts disallowed commands by issuing block erase sanitize and running each blocked command expecting 00/1d.

Reference

NVM Express Revision 1.4a.

Steps

Issue block erase sanitize to enter sanitize in progress state
Skip test if sanitize already completed before running disallowed commands
Attempt another Sanitize command and expect sanitize-in-progress abort
Attempt Device Self-test command and expect sanitize-in-progress abort
Attempt firmware download and expect sanitize-in-progress abort
Attempt firmware commit during sanitize and expect sanitize-in-progress abort
Use action=2 for the firmware commit request
Attempt Format NVM command and expect sanitize-in-progress abort
Attempt Flush command during sanitize and handle cache configuration
Attempt Write command and expect sanitize-in-progress abort
Attempt Read command and expect sanitize-in-progress abort
Prepare a read buffer for the command
Monitor sanitize progress until it completes and verify the log page contents
Ensure sanitize completion bit indicates the last sanitize finished successfully
Ensure sanitize success flag indicates the last sanitize completed successfully
Confirm SCDW10 reflects the sanitize command Dword 10 value

function: scripts/conformance/01_admin/sanitize_test.py::test_sanitize_not_abort_allowed_command

Ensure allowed commands complete during sanitize by issuing block erase sanitize and running permitted admin commands.

Reference

NVM Express Revision 1.4a.

Steps

Issue block erase sanitize to enter sanitize in progress state
Skip test if sanitize already completed before issuing allowed commands
Create IO CQ and IO SQ while sanitize is running
Delete the temporary IO queues while sanitize is running
Issue Set Features command and expect it to complete successfully
Issue Get Features command and expect it to complete successfully
Issue Identify command and expect it to complete successfully
Monitor sanitize progress until completion and verify the log contents
Ensure sanitize completion bit indicates success for the most recent operation
Ensure sanitize success flag is set for the most recent operation
Confirm SCDW10 captures the sanitize command Dword 10 value

function: scripts/conformance/01_admin/sanitize_test.py::test_sanitize_not_successful_completion

Ensure reserved sanitize action leaves log and user data unchanged by issuing invalid sanitize and comparing before and after.

Reference

NVM Express Revision 1.4a.

Steps

Write sample data and verify it before issuing an invalid sanitize
Read sanitize status log before issuing the invalid sanitize command
Issue a sanitize command with a reserved action and expect invalid field status
Confirm data remains unchanged after the invalid sanitize operation
Confirm sanitize status log has not been updated after the invalid command

function: scripts/conformance/01_admin/sanitize_test.py::test_sanitize_nvme_reset

Verify sanitize continues across controller reset by running block erase sanitize, resetting, and monitoring log page.

Reference

NVM Express Revision 1.4a.

Steps

Skip the test if sanitize completes too quickly to evaluate reset behavior
Issue a block erase sanitize command to create a long operation
Reset the controller while sanitize is still running
Monitor sanitize progress after reset and verify the log contents
Ensure sanitize completion bit indicates the most recent sanitize succeeded
Ensure sanitize success flag is set for the most recent sanitize operation
Confirm SCDW10 records the sanitize command Dword 10 value

function: scripts/conformance/01_admin/sanitize_test.py::test_sanitize_not_support_type

Ensure unsupported sanitize actions return Invalid Field by checking capabilities and issuing unsupported options.

Reference

NVM Express Revision 1.4a.

Steps

Read sanitize capabilities from Identify data
Try Crypto Erase when unsupported and expect invalid field status
Try Block Erase when unsupported and expect invalid field status
Try Overwrite when unsupported and expect invalid field status
Issue reserved sanitize actions and expect invalid field status

function: scripts/conformance/01_admin/sanitize_test.py::test_sanitize_abort_by_fw_activation

Validate pending firmware activation with reset aborts sanitize by committing firmware and issuing sanitize while activation is pending.

Reference

NVM Express Revision 1.4a.

Steps

Issue firmware commit that triggers activation with reset
Issue sanitize command while firmware activation with reset is pending
Handle firmware activation asynchronous events and complete reset sequence

function: scripts/conformance/01_admin/sanitize_test.py::test_sanitize_no_deallocate

Verify sanitize deallocates logical blocks when No Deallocate After Sanitize allows it by configuring features and issuing block erase.

Reference

NVM Express Revision 1.4a.

Steps

Skip test if controller specification version is below 1.4
Ensure Block Erase sanitize capability is supported
Ensure the No-Deallocate Inhibited bit capability is supported
Configure Sanitize Config feature to set No-Deallocate behavior
Write sample data and verify it prior to running sanitize
Issue sanitize with No Deallocate After Sanitize field set and monitor log/AER
Confirm data is deallocated after sanitize completes
Check sanitize status to ensure completion or proper inhibited state
Clear Sanitize Config setting and ensure command fails when unsupported

function: scripts/conformance/01_admin/sanitize_test.py::test_sanitize_exit_failure_mode

Confirm exit failure mode action succeeds after a good sanitize by issuing block erase and then action 001b.

Reference

NVM Express Revision 2.0a.

Steps

Ensure block erase sanitize capability is available
Issue block erase sanitize and monitor sanitize status through log and AER
Ensure sanitize completion bit indicates success for the last sanitize
Ensure sanitize success flag indicates the most recent sanitize succeeded
Confirm SCDW10 captured the block erase sanitize Cdw10 value
Verify data after sanitize to confirm overwrite behavior
Issue an Exit Failure Mode sanitize command to clear failure state
Verify sanitize log remains unchanged after Exit Failure Mode

function: scripts/conformance/01_admin/sanitize_test.py::test_sanitize_and_flush

Ensure flush commands may succeed during sanitize by disabling cache, issuing sanitize, and running flush while monitoring log.

Reference

NVM Express Revision 2.0a.

Steps

Require a controller with a volatile write cache for this scenario
Record the original write cache setting
Disable the write cache and verify the feature is set correctly
Issue block erase sanitize to create a sanitize-in-progress window
Skip the test if sanitize has already completed before flush can be issued
Issue Flush command during sanitize and expect either success or sanitize-in-progress abort
Complete the sanitize cycle and verify the log contents
Ensure sanitize completion bit indicates the sanitize completed successfully
Ensure sanitize success flag indicates the most recent sanitize succeeded
Confirm SCDW10 captures the sanitize command Dword 10 value

folder: scripts/conformance/02_nvm

file: scripts/conformance/02_nvm/compare_test

function: scripts/conformance/02_nvm/compare_test.py::test_compare_lba_0

Validate Compare command boundary behavior by issuing combinations of legal and illegal LBAs and NLBs.

Reference

NVM Express Revision 1.4a.

Steps

Ensure the namespace advertises Compare support before running the sequence.
Read namespace capacity to establish the maximum valid LBA.
Initialize media content and the comparison buffer to create a passing baseline.
Issue Compare commands against mismatched LBAs and expect miscompare status codes.
Modify the buffer to force data miscompares and ensure the controller reports errors.
Restore the comparison buffer so subsequent tests start from known data.
Vary the NLB field to observe expected errors when the range length does not match.
Send Compare commands that reference invalid LBAs and confirm proper range errors.

function: scripts/conformance/02_nvm/compare_test.py::test_compare_invalid_nsid

Verify Compare commands reject invalid NSIDs by submitting crafted SQEs to the admin queues.

Reference

NVM Express Revision 1.4a.

Steps

Ensure the controller supports the Compare opcode before injecting invalid NSIDs.
Submit a Compare command targeting each invalid NSID and capture completion status.
Verify the completions signal the invalid or nonexistent namespace condition.

function: scripts/conformance/02_nvm/compare_test.py::test_compare_fused_operations

Check Compare-and-Write fused semantics by mixing legal and illegal fuse values and validating the resulting CQ status codes.

Reference

NVM Express Revision 1.4c.

Steps

Abort the test if the controller does not report Compare-and-Write fused capability.
Collect status codes from every CQE produced by the specified number of commands.
Ring the submission queue doorbell to submit queued commands.
Wait for the completion queue to return the requested number of entries.
Record the status code for each completion.
Advance the completion queue head to release consumed entries.
Return a scalar when a single status is captured, otherwise return the list.
Issue standalone write commands to seed data for future comparisons.
Corrupt the buffer so a standalone compare produces a miscompare status.
Restore the data to prove the compare path works when inputs match.
Apply invalid fuse settings to individual commands and expect generic errors.
Combine commands that use illegal fuse combinations and confirm both fail.
Execute a valid Compare-and-Write pair and expect success for both commands.
Introduce a data mismatch within a fused pair to ensure the write aborts.
Reissue the fused pair with correct data to confirm the happy path.
Target different LBAs inside the fused pair to observe range errors.
Change the write buffer to refresh the comparison baseline for later tests.
Confirm the fused pair succeeds when using the updated buffer.
Run a standalone compare to verify the freshly written data persisted.
Mix a fused pair with a standard compare to ensure the queue handles interleaving.
Interleave a fused pair with a conflicting CID to confirm the controller rejects it.
Launch two legal fused pairs simultaneously to verify both pass.
Combine one passing fused pair with one illegal pair to see split completions.

function: scripts/conformance/02_nvm/compare_test.py::test_compare_write_mixed

Exercise Compare and Write operations, including ioworker mixes, to validate token-sensitive behavior and error reporting.

Reference

NVM Express Revision 1.4c.

Steps

Skip the test if the namespace lacks Compare command support.
Format the namespace to clear previous data and metadata.
Expect compare failures when issuing commands without valid prepared data.
Disable write tokens and validate the basic write-then-compare pass sequence.
Stress the namespace with ioworker mixes that lack token enforcement.
Force miscompare warnings by running ioworker with an unexpected data pattern.
Re-enable write tokens and ensure ioworker traffic reports the expected errors.

file: scripts/conformance/02_nvm/copy_test

function: scripts/conformance/02_nvm/copy_test.py::test_copy_basic

Verify the copy command can duplicate chained source ranges and that every destination matches.

Reference

Spec Reference: NVM Command Set Specification 1.0b

Steps

Initialize LBA 0-32 with a deterministic pattern for comparison.
Issue a copy command that duplicates LBA 0-32 into destination LBA 32-64.
Chain two source ranges to populate higher destination LBAs.
Prepare read buffers and confirm their initial contents differ from the source.
Read back LBA 0-32 to capture the original data.
Read back LBA 32-64 to verify the first copy.
Read back LBA 64-96 to verify the chained copy result.
Read back LBA 96-128 to complete the verification set.
Confirm that every copied region exactly matches the source data.

function: scripts/conformance/02_nvm/copy_test.py::test_copy_smart

Ensure copy commands alter SMART host read/write counters without changing data unit counts.

Reference

Spec Reference: NVM Command Set Specification 1.0b

Steps

Capture the baseline SMART accounting values before issuing copy commands.
Issue repeated copy commands so SMART host command counters should increment.
Retrieve SMART data again to confirm only host command counters increased.

function: scripts/conformance/02_nvm/copy_test.py::test_copy_format_1

Exercise Copy descriptor format 1 handling by mixing matching and mismatched format selections.

Reference

Spec Reference: NVM Command Set Specification 1.0b

Steps

Query the controller to confirm Copy Format 1h is supported.
Send a baseline copy using format 0 for both descriptor and command.
Repeat the copy with format 1 for both descriptor and command.
Mix descriptor format 0 with a format 1 command and expect an error.
Mix descriptor format 1 with a format 0 command and expect an error.

function: scripts/conformance/02_nvm/copy_test.py::test_copy_invalid_lba

Validate boundary handling by issuing copy commands that hit or exceed namespace capacity.

Reference

Spec Reference: NVM Command Set Specification 1.0b

Steps

Read the namespace capacity from Identify data.
Copy a minimal range that ends exactly at the namespace boundary.
Issue the boundary copy with SLBA equal to NCAP-1.
Attempt several out-of-range copies and confirm the controller returns errors.
Submit a Copy whose source starts beyond NCAP and expect LBA Out of Range.
Push destination parameters just over NCAP to confirm additional error handling.

function: scripts/conformance/02_nvm/copy_test.py::test_copy_max_namespace_size

Confirm LBA out-of-range handling when Copy destinations exceed namespace size.

Reference

Spec Reference: NVM Command Set Specification 1.0b

Steps

Retrieve NSZE and NCAP and confirm they match.
Attempt destination LBAs beyond NSZE to ensure LBA out-of-range errors are reported.

function: scripts/conformance/02_nvm/copy_test.py::test_copy_fua

Ensure copy commands succeed when the Force Unit Access bit is asserted.

Reference

Spec Reference: NVM Command Set Specification 1.0b

Steps

Send a copy with FUA enabled and require it to complete successfully.

function: scripts/conformance/02_nvm/copy_test.py::test_copy_invalid_nsid

Inject an invalid NSID via manual SQE programming and expect an aborted Copy command.

Reference

Spec Reference: NVM Command Set Specification 1.0b

Steps

Build a simple Copy range buffer used by the crafted SQE.
Manually submit a Copy command with an invalid namespace identifier.
Read the completion entry and confirm a nonzero error status.

function: scripts/conformance/02_nvm/copy_test.py::test_copy_invalid_nsid_lba

Craft a Copy command that combines an invalid NSID with an out-of-range SLBA.

Reference

Spec Reference: NVM Command Set Specification 1.0b

Steps

Inspect MDTS and NCAP; skip when maximum transfer size already covers the scenario.
Allocate a Copy range buffer used by the malformed SQE.
Issue a Copy command with both an invalid namespace and SLBA beyond NCAP.
Check the completion status for the expected error code family.

function: scripts/conformance/02_nvm/copy_test.py::test_copy_max_nr

Exercise the upper NR limit by issuing a Copy command that uses all MSRC entries.

Reference

Spec Reference: NVM Command Set Specification 1.0b

Steps

Read the MSRC capability to understand how many descriptors are allowed.
Populate descriptors up to the allowed MSRC value.
Issue the Copy command using the maximum supported NR.

function: scripts/conformance/02_nvm/copy_test.py::test_copy_invalid_nr

Verify controllers reject Copy commands whose NR exceeds the MSRC capability.

Reference

Spec Reference: NVM Command Set Specification 1.0b

Steps

Use MSRC+1 descriptors to intentionally exceed the supported NR.
Skip if MSRC already advertises the maximum descriptor limit.
Populate one more descriptor than the controller supports.
Submit the Copy command and expect Command Size Limit Exceeded.

function: scripts/conformance/02_nvm/copy_test.py::test_copy_mssrl

Confirm controllers enforce MSSRL by rejecting source ranges that exceed the per-entry length.

Reference

Spec Reference: NVM Command Set Specification 1.0b

Steps

Read MSSRL from Identify to know the maximum blocks per entry.
Run a Copy that uses the maximum allowed blocks per entry and expect success.
Exceed MSSRL by one block and expect a Command Size Limit Exceeded status.

function: scripts/conformance/02_nvm/copy_test.py::test_copy_mcl

Validate enforcement of the MCL cumulative length limit across all Copy descriptors.

Reference

Spec Reference: NVM Command Set Specification 1.0b

Steps

Read MSSRL and MCL to determine how many descriptors can be aggregated.
Fill descriptors that exactly sum to MCL and ensure the Copy succeeds.
Define an additional descriptor so the total exceeds MCL.
Submit the oversized Copy and expect Command Size Limit Exceeded.

function: scripts/conformance/02_nvm/copy_test.py::test_copy_multi_source

Validate multi-source Copy behavior by merging four regions into a contiguous destination.

Reference

Spec Reference: NVM Command Set Specification 1.0b

Steps

Ensure the MSRC capability supports the number of requested ranges.
Ensure the MCL capability can accommodate the combined range lengths.
Ensure no single range exceeds the MSSRL limit.
Log the source offsets and lengths for easier troubleshooting.
Write unique patterns to each region and issue a multi-range Copy.
Read the destination region back in four segments.
Compare each segment against its originating buffer.

function: scripts/conformance/02_nvm/copy_test.py::test_copy_write_uncorrectable

Ensure Copy reports unrecoverable read errors when targeting write-uncorrectable LBAs.

Reference

Spec Reference: NVM Command Set Specification 1.0b

Steps

Skip when the Write Uncorrectable feature is unsupported.
Prepare patterned data that will later be rewritten.
Mark the target LBA range as write uncorrectable.
Attempt a Copy from the uncorrectable range and expect an unrecovered read error.
Rewrite data into the range so subsequent accesses succeed.
Copy the recovered range again to ensure success after rewriting.
Read back each logical block and validate the pattern.

function: scripts/conformance/02_nvm/copy_test.py::test_copy_ioworker

Stress copy operations within a mixed workload generated by ioworker.

Reference

Spec Reference: NVM Command Set Specification 1.0b

Steps

Run ioworker with mixed operations, including Copy commands, across the namespace.

file: scripts/conformance/02_nvm/deallocate_test

function: scripts/conformance/02_nvm/deallocate_test.py::test_deallocate_and_write

Validate deterministic post-deallocation reads by trimming LBAs, writing a pattern, and confirming data transitions.

Reference

NVM Express Revision 1.4a.

Steps

Initialize the DSM buffer and data pattern for the upcoming operations
Deallocate the target LBA range with the Dataset Management command
Write patterned data to the trimmed LBAs and confirm the reads match
Compute the starting LBA for the trim verification
Issue DSM again on the calculated range
Read the trimmed LBAs to ensure the pattern no longer matches

function: scripts/conformance/02_nvm/deallocate_test.py::test_deallocate_out_of_range

Ensure Dataset Management aborts cleanly when LBA ranges exceed the namespace.

Reference

NVM Express Revision 1.4a.

Steps

Retrieve the namespace capacity from the Identify data structure
Deallocate the last valid logical block to confirm a passing completion
Attempt to deallocate LBA ranges beyond capacity and expect an error completion

function: scripts/conformance/02_nvm/deallocate_test.py::test_deallocate_nr_maximum

Exercise the DSM range entry limit by issuing maximum and overflowed range counts.

Reference

NVM Express Revision 1.4a.

Steps

Populate 256 DSM ranges, the architectural maximum, and execute the command
Attempt to exceed 256 ranges and expect helper-side and controller-side failures

function: scripts/conformance/02_nvm/deallocate_test.py::test_deallocate_correct_range

Verify DSM only affects the specified LBA range by trimming the middle block of three writes.

Reference

NVM Express Revision 1.4a.

Steps

Write three consecutive logical blocks to seed deterministic content
Deallocate the middle logical block with a DSM command
Read each logical block to ensure only the trimmed block changed state

function: scripts/conformance/02_nvm/deallocate_test.py::test_deallocate_multiple_range

Validate trimming multiple DSM ranges and verify data integrity on affected and unaffected LBAs.

Reference

NVM Express Revision 1.4a.

Steps

Write four logical blocks to establish baseline data patterns
Program the DSM buffer with several overlapping and contiguous ranges
Read back the LBAs to confirm trimmed ranges return default data and untouched ones remain intact
Rewrite and reread the previously trimmed LBAs to ensure normal IO resumes

function: scripts/conformance/02_nvm/deallocate_test.py::test_deallocate_mixed

Stress DSM operations mixed with other IO types using the ioworker generator.

Reference

NVM Express Revision 1.4a.

Steps

Launch a mixed workload blending trims with random reads and writes

file: scripts/conformance/02_nvm/flush_test

function: scripts/conformance/02_nvm/flush_test.py::test_flush_with_read_write

Validate that flushing after a write persists cached data by issuing a write, flushing, and reading back.

Reference

NVM Express Revision 1.4a

Steps

Prepare read and write buffers and prime the queue pair for IO validation.
Issue a write request to place the pattern in the controller cache.
Issue a Flush command to force the cached data to non-volatile media.
Read back the data to ensure the flushed content matches expectations.

function: scripts/conformance/02_nvm/flush_test.py::test_flush_vwc_check

Check the VWC capability bits by evaluating controller version logic and issuing a namespace broadcast flush.

Reference

NVM Express Revision 1.4a

Steps

Skip the validation if the controller implements a pre-1.4 specification.
Read the Volatile Write Cache (VWC) field from the Identify Controller data structure.
Assert that VWC bits 2:1 are not 00b for controllers compliant with revision 1.4 or later.
Verify that a Flush with NSID 0xffffffff is rejected when namespace broadcast semantics are unsupported.

file: scripts/conformance/02_nvm/read_test

function: scripts/conformance/02_nvm/read_test.py::test_read_large_lba

Validate boundary LBAs by issuing reads at and beyond the namespace capacity.

Reference

NVM Express Revision 1.4a

Steps

Read namespace capacity from Identify data for boundary calculations.
Issue a single-block read at the last valid LBA and expect it to succeed.
Exercise reads beyond the capacity and require LBA Out of Range responses.

function: scripts/conformance/02_nvm/read_test.py::test_read_max_namespace_size

Confirm reads fail when the starting LBA exceeds nsze by issuing varied offsets.

Reference

NVM Express Revision 1.4a

Steps

Read nsze and ncap from Identify data and ensure they match.
Attempt reads beyond nsze with multiple offsets and expect LBA Out of Range.

function: scripts/conformance/02_nvm/read_test.py::test_read_fua

Exercise Force Unit Access by issuing repeated FUA-enabled reads and observing completion.

Reference

NVM Express Revision 1.4a

Steps

Send repeated reads with the FUA bit set and require successful completion.

function: scripts/conformance/02_nvm/read_test.py::test_read_bad_number_blocks

Ensure transfers larger than MDTS are rejected while valid sizes succeed.

Reference

NVM Express Revision 1.4a

Steps

Read MDTS, size the buffer, and skip if the limit is already above 2 MB.
Issue reads with lengths within MDTS to verify the baseline behavior.
Attempt transfers larger than MDTS and expect Invalid Field in Command errors.
Sweep valid NLB values within MDTS and ensure each read completes.

function: scripts/conformance/02_nvm/read_test.py::test_read_valid

Verify data consistency by chaining write and read operations with varied IO flags.

Reference

NVM Express Revision 1.4a

Steps

Initialize I/O buffers and place a distinguishable payload in the write buffer.
Issue the write and trigger the corresponding read from the callback.
Wait for both commands to complete and check that the payload matches.

function: scripts/conformance/02_nvm/read_test.py::test_read_invalid_nsid

Ensure reads targeting an invalid namespace ID return Invalid Namespace or Format.

Reference

NVM Express Revision 1.4a

Steps

Build a read SQE that intentionally references an invalid namespace ID.
Submit the SQE to hardware and allow time for completion.
Verify the CQE status reports Invalid Namespace or Format.

function: scripts/conformance/02_nvm/read_test.py::test_read_invalid_nlb

Ensure reads with transfer lengths beyond MDTS trigger Invalid Field in Command.

Reference

NVM Express Revision 1.4a

Steps

Skip the scenario when MDTS is already large enough to mask the overflow.
Program a read SQE whose NLB equals MDTS so the controller must fault it.
Confirm completion reports Invalid Field in Command.

function: scripts/conformance/02_nvm/read_test.py::test_read_invalid_nsid_lba

Check controller behavior when both NSID and SLBA are invalid in the same command.

Reference

NVM Express Revision 1.4a

Steps

Gather namespace capacity (and MDTS for skip logic) before crafting the command.
Populate a read SQE with invalid NSID and SLBA values and submit it.
Inspect the completion status and accept any documented error for bad NSID/SLBA.

function: scripts/conformance/02_nvm/read_test.py::test_read_ioworker_consistency

Measure random read IOPS by running an io worker that records per-second throughput.

Reference

NVM Express Revision 1.4a

Steps

Launch the io worker with random reads and collect the reported IOPS timeline.

function: scripts/conformance/02_nvm/read_test.py::test_read_ioworker_trim_mixed

Exercise mixed read and deallocate workloads by driving io worker operations.

Reference

NVM Express Revision 1.4a

Steps

Run the io worker with an even mix of read and trim operations for the duration.

function: scripts/conformance/02_nvm/read_test.py::test_read_different_io_size_and_count

Validate reads across multiple IO sizes and queue depths using buffered transfers.

Reference

NVM Express Revision 1.4a

Steps

Allocate per-command DMA buffers sized to the requested LBA count.
Issue the reads for each buffer and wait for all completions.

file: scripts/conformance/02_nvm/verify_test

function: scripts/conformance/02_nvm/verify_test.py::test_verify_large_lba

Validate Verify rejects out-of-range accesses by issuing commands across the namespace boundary.

Reference

NVM Express Revision 1.4a.

Steps

Read the namespace capacity to determine the maximum valid LBA.
Issue Verify at the last valid LBA to confirm the happy-path behavior.
Issue Verify starting exactly at namespace capacity and expect an error.
Issue Verify starting past the namespace capacity and expect an error.
Issue Verify covering the capacity boundary through NLB and expect an error.
Issue Verify using an obviously out-of-range SLBA and expect an error.

function: scripts/conformance/02_nvm/verify_test.py::test_verify_valid

Confirm Verify handles supported IO flags by executing callback-driven IO around the command.

Reference

NVM Express Revision 1.4a.

Steps

Prepare IO buffers that contain a known data pattern.
Program one LBA with the known pattern and confirm it reads back correctly.
Define a Verify completion callback that re-reads the data.
Issue Verify with the requested IO flag and callback.
Wait for outstanding commands and confirm data remained unchanged.

function: scripts/conformance/02_nvm/verify_test.py::test_verify_invalid_nsid

Ensure Verify with an invalid NSID returns Invalid Namespace or Format by submitting a raw SQE.

Reference

NVM Express Revision 1.4a.

Steps

Build a Verify SQE targeting namespace 0xff, which is unsupported.
Inspect the completion status and ensure it reports namespace errors.

function: scripts/conformance/02_nvm/verify_test.py::test_verify_nlb

Demonstrate Verify ignores MDTS by sweeping NLB around the MDTS-derived limit.

Reference

NVM Express Revision 1.4a.

Steps

Read controller MDTS to establish the comparison baseline.
Build a Verify SQE for namespace 1.
Set NLB relative to the MDTS limit using the provided delta.
Submit the command to the queue and ring the doorbell.
Confirm completion reports success regardless of NLB selection.

function: scripts/conformance/02_nvm/verify_test.py::test_verify_invalid_nsid_lba

Check Verify rejects invalid NSID and SLBA combinations by hand-crafting the SQE and PRP list.

Reference

NVM Express Revision 1.4a.

Steps

Read capacity and MDTS to build an out-of-range request.
Build a Verify SQE that targets namespace 0xff and SLBA = capacity.
Ring the doorbell to submit the crafted command.
Validate the completion status reports an appropriate error.

function: scripts/conformance/02_nvm/verify_test.py::test_verify_uncorrectable_lba

Validate Write Uncorrectable handling by forcing errors on Verify and Read until data is rewritten.

Reference

NVM Express Revision 1.4a.

Steps

Check controller capabilities and skip if Write Uncorrectable is unsupported.
Issue Write Uncorrectable on the selected LBA range.
Send read commands on the marked range.
Expect Unrecovered Read Error warnings from both Read and Verify.
Overwrite the range to clear the uncorrectable condition.
Re-issue Verify to confirm the range now passes without errors.

file: scripts/conformance/02_nvm/write_test

function: scripts/conformance/02_nvm/write_test.py::test_write_large_lba

Verify boundary handling by writing at, below, and beyond the namespace limit.

Reference

NVM Express Revision 1.4a.

Steps

Read NCAP from identify data
Issue a valid write at the last logical block
Drive explicit writes beyond NCAP and expect LBA out-of-range warnings

function: scripts/conformance/02_nvm/write_test.py::test_write_max_namespace_size

Confirm namespace size enforcement by issuing writes at and beyond NSZE.

Reference

NVM Express Revision 1.4a.

Steps

Read NSZE and NCAP and confirm they match
Attempt writes beyond NSZE and verify LBA out-of-range aborts

function: scripts/conformance/02_nvm/write_test.py::test_write_fua

Validate force unit access writes by repeatedly issuing commands with FUA set.

Reference

NVM Express Revision 1.4a.

Steps

Issue many FUA writes and require each command to complete successfully

function: scripts/conformance/02_nvm/write_test.py::test_write_bad_number_blocks

Exercise MDTS limits by issuing writes up to and beyond the advertised limit.

Reference

NVM Express Revision 1.4a.

Steps

Check MDTS and allocate a buffer that exceeds the transfer size
Submit writes whose nlb is equal to or below MDTS and expect success
Attempt larger writes and ensure the controller reports invalid field
Sweep smaller nlbs to confirm the remaining range continues to pass

function: scripts/conformance/02_nvm/write_test.py::test_write_valid

Check data consistency by writing then reading back blocks across IO flag modes.

Reference

NVM Express Revision 1.4a.

Steps

Prepare dedicated read and write buffers
Issue a write followed by read to capture the completion callbacks
Wait for both commands to finish and verify the payload matches

function: scripts/conformance/02_nvm/write_test.py::test_write_invalid_nsid

Confirm invalid namespace handling by submitting a write with a bogus NSID.

Reference

NVM Express Revision 1.4a.

Steps

Build a write SQE targeting an invalid namespace identifier
Ring the submission queue doorbell
Check completion status for Invalid Namespace or Format

function: scripts/conformance/02_nvm/write_test.py::test_write_invalid_nlb

Trigger invalid field errors by advertising an NLB larger than MDTS allows.

Reference

NVM Express Revision 1.4a.

Steps

Abort early if MDTS is too large for this negative test
Program a write command whose NLB equals MDTS sectors
Submit the SQE to hardware
Inspect completion status for Invalid Field in Command

function: scripts/conformance/02_nvm/write_test.py::test_write_invalid_nsid_lba

Stress combined namespace and LBA validation by issuing writes far past NCAP.

Reference

NVM Express Revision 1.4a.

Steps

Guard on MDTS and gather NCAP for the overrun
Issue the out-of-range write on an invalid namespace identifier
Post the SQE to the submission queue
Read the completion status and require an error consistent with the violation

function: scripts/conformance/02_nvm/write_test.py::test_write_ioworker_different_op_mixed

Validate mixed I/O capability by running ioworker with read, write, flush, and trim.

Reference

NVM Express Revision 1.4a.

Steps

Execute an ioworker mix of read/write/flush/trim commands

function: scripts/conformance/02_nvm/write_test.py::test_write_ioworker_consistency

Measure write consistency by recording per-second IOPS during a write-only run.

Reference

NVM Express Revision 1.4a.

Steps

Run a write-only ioworker and capture the reported per-second IOPS

function: scripts/conformance/02_nvm/write_test.py::test_write_followed_by_read

Validate write-read pairing by cycling writes followed by reads to many LBAs.

Reference

NVM Express Revision 1.4a.

Steps

Write data to one LBA before each subsequent read
Read data from the same LBA immediately after each write
Repeat the write-read sequence across thousands of LBAs

function: scripts/conformance/02_nvm/write_test.py::test_write_fua_unaligned

Ensure unaligned FUA writes succeed by issuing IOs that misalign the starting LBA.

Reference

NVM Express Revision 1.4a.

Steps

Perform unaligned FUA writes across the test region
Verify the data region with larger aligned read operations

function: scripts/conformance/02_nvm/write_test.py::test_write_cache_disable

Assess data persistence by disabling write cache and inducing power events.

Reference

NVM Express Revision 1.4a.

Steps

Fill the drive with background writes to prepare the media
Disable volatile write cache and confirm the feature setting
Run sequential writes totaling less than 32KiB * 999 commands
Simulate an unsafe shutdown by removing and restoring power
Reset the controller and verify post-shutdown readback
Run sequential writes exceeding 32KiB * 1010 commands
Trigger a controlled shutdown and power-cycle the subsystem
Reinitialize the controller after power restoration
Validate there are no miscompares and verify data integrity

file: scripts/conformance/02_nvm/write_uncorrectable_test

function: scripts/conformance/02_nvm/write_uncorrectable_test.py::test_write_uncorrectable_large_lba

Verify Write Uncorrectable results at the namespace boundary by issuing commands across the final SLBAs.

Reference

Reference: NVM Express Revision 1.4a.

Steps

Retrieve namespace capacity to identify the last accessible LBA.
Issue Write Uncorrectable at the last valid LBA to confirm proper completion.
Push Write Uncorrectable beyond namespace end and expect LBA Out of Range errors.

function: scripts/conformance/02_nvm/write_uncorrectable_test.py::test_write_uncorrectable_deallocate

Confirm that deallocate commands succeed immediately after Write Uncorrectable and allow normal writes.

Reference

Reference: NVM Express Revision 1.4a.

Steps

Verify the controller advertises the deallocate capability before testing.
Prepare deterministic write data used after the uncorrectable/deallocate sequence.
Mark the target range as uncorrectable before any reclaim operations.
Deallocate the same range and require successful completion.
Rewrite the previously uncorrectable range to confirm media usability.

function: scripts/conformance/02_nvm/write_uncorrectable_test.py::test_write_uncorrectable_after_deallocate

Ensure Write Uncorrectable behaves normally when issued after explicit deallocate operations.

Reference

Reference: NVM Express Revision 1.4a.

Steps

Confirm the controller can execute deallocate commands ahead of the test.
Create deterministic IO data and queue resources for follow-on writes.
Deallocate the range so Write Uncorrectable follows an empty logical space.
Issue Write Uncorrectable on the deallocated space and expect success.
Perform a standard write afterward to verify the namespace continues working.

function: scripts/conformance/02_nvm/write_uncorrectable_test.py::test_write_uncorrectable_read

Validate that reads targeting Write Uncorrectable LBAs return Unrecovered Read Error until rewritten.

Reference

Reference: NVM Express Revision 1.4a.

Steps

Allocate IO buffers and deterministic write data for the LBA range.
Tag the LBAs as uncorrectable ahead of the read validation.
Read the uncorrectable range and expect an Unrecovered Read Error from the controller.
Rewrite the same LBAs so subsequent reads can succeed.
Read the recovered range and confirm the expected pattern is returned.

file: scripts/conformance/02_nvm/write_zeroes_test

function: scripts/conformance/02_nvm/write_zeroes_test.py::test_write_zeroes_large_lba

Ensure Write Zeroes rejects ranges exceeding namespace capacity by issuing commands at and beyond the boundary.

Reference

NVM Express Revision 1.4a

Steps

Read namespace capacity to determine command boundaries.
Issue Write Zeroes at the last logical block to confirm valid completion.
Issue Write Zeroes starting exactly at namespace capacity and expect a range error.
Issue Write Zeroes starting beyond namespace capacity and expect a range error.
Issue Write Zeroes that overruns the namespace end and expect a range error.
Issue Write Zeroes using an invalid high SLBA to ensure the controller reports a range error.

function: scripts/conformance/02_nvm/write_zeroes_test.py::test_write_zeroes_valid

Validate Write Zeroes with different IO flags by writing data, zeroing it, and reading back asynchronously.

Reference

NVM Express Revision 1.4a

Steps

Prepare data buffers and populate the IO queue context.
Write patterned data and confirm the media contains the payload.
Define a completion callback that issues a read after Write Zeroes.
Submit the Write Zeroes command with the requested IO flags.
Wait for completion and confirm the logical block was zeroed.

function: scripts/conformance/02_nvm/write_zeroes_test.py::test_write_zeroes_invalid_nsid

Confirm Write Zeroes returns Invalid Namespace when an out-of-range NSID is used.

Reference

NVM Express Revision 1.4a

Steps

Submit a raw SQE targeting invalid namespace 0xff.
Verify the completion status reports Invalid Namespace or Format.

function: scripts/conformance/02_nvm/write_zeroes_test.py::test_write_zeroes_nlb

Validate the Write Zeroes maximum transfer by issuing a request sized to the controller MDTS limit.

Reference

NVM Express Revision 1.4a

Steps

Read the controller MDTS to determine the allowed maximum blocks.
Calculate the Write Zeroes Size Limit when the controller exposes it.
Program a Write Zeroes SQE sized to the MDTS limit.
Confirm the completion status indicates success for the MDTS-sized request.

function: scripts/conformance/02_nvm/write_zeroes_test.py::test_write_zeroes_invalid_nsid_lba

Ensure Write Zeroes reports errors for invalid namespace and SLBA combinations exceeding capacity.

Reference

NVM Express Revision 1.4a

Steps

Read the namespace capacity and controller MDTS for boundary calculations.
Submit Write Zeroes targeting an invalid namespace and out-of-range SLBA.
Validate the completion status returns an appropriate error code.

function: scripts/conformance/02_nvm/write_zeroes_test.py::test_write_zeroes_data_unit_write

Verify the SMART Data Units Written field remains unchanged when issuing Write Zeroes commands.

Reference

NVM Express Revision 1.4a

Steps

Skip this validation on controllers implementing specs earlier than 1.4.
Establish the baseline Data Units Written counter from the SMART log.
Issue a burst of Write Zeroes commands across the namespace.
Re-read the SMART log to confirm the Data Units Written value is unchanged.

folder: scripts/conformance/03_features/hmb

file: scripts/conformance/03_features/hmb/1_basic_test

function: scripts/conformance/03_features/hmb/1_basic_test.py::test_hmb_buffer_alloc_huge

Validate HMB allocations scale cleanly by instantiating progressively larger buffers.

Reference

NVM Express Revision 1.4a.

Steps

Ramp buffer allocation sizes exponentially to observe allocator limits
Allocate a large contiguous buffer to check high watermark handling
Create multiple medium buffers to confirm repeated allocations succeed

function: scripts/conformance/03_features/hmb/1_basic_test.py::test_hmb_write_read

Verify HMB IO paths by issuing sequential, read-only, and mixed workloads across sizes.

Reference

NVM Express Revision 1.4a.

Steps

Enable the host memory buffer before issuing IO
Iterate through IO patterns for multiple passes while HMB remains active
Issue a write-only workload to populate the host memory buffer
Issue a read-only workload to verify data retrieval through HMB
Issue a mixed workload to confirm balanced read and write handling

file: scripts/conformance/03_features/hmb/2_protocol_test

function: scripts/conformance/03_features/hmb/2_protocol_test.py::test_hmb_support

Verify the Host Memory Buffer preferred size is greater than or equal to the minimum by parsing Identify data.

Reference

Spec: NVM Express Revision 1.4a

Steps

Read the HMB preferred and minimum sizes from Identify data.
Validate HMPRE is at least HMMIN and log relevant Identify fields.
Warn if HMPRE exceeds 64 MiB of host memory.

function: scripts/conformance/03_features/hmb/2_protocol_test.py::test_hmb_command_sequence

Ensure enabling HMB while it is already active triggers a Command Sequence Error via the Set Features command.

Reference

Spec: NVM Express Revision 1.4a

Steps

Enable the Host Memory Buffer feature as the baseline state.
Attempt to re-enable HMB with EHM=1 and expect a Command Sequence Error.
Disable the Host Memory Buffer feature to clear the state.
Issue a subsequent disable to confirm it succeeds when already disabled.

function: scripts/conformance/03_features/hmb/2_protocol_test.py::test_hmb_size_invalid

Validate that HMB Set Features rejects invalid buffer sizes before accepting valid parameters.

Reference

Spec: NVM Express Revision 1.4a

Steps

Gather HMB capability data and skip when unsupported.
Allocate host memory buffers and descriptor table for hmb validation.
Allocate the next chunk buffer and track remaining size.
Populate the descriptor entry for this chunk.
Record the physical address of the descriptor list for subsequent commands.
Attempt to enable HMB with zero buffer size and expect an Invalid Field in Command status.
Enable HMB with valid size parameters to confirm normal behavior.
Query the HMB feature to confirm the controller adopted the configuration.
Disable the HMB feature to clean up the test state.

function: scripts/conformance/03_features/hmb/2_protocol_test.py::test_hmb_entry_count_invalid

Validate that HMB Set Features rejects a zero descriptor count while accepting valid configurations.

Reference

Spec: NVM Express Revision 1.4a

Steps

Gather HMB capability data and skip when unsupported.
Allocate host memory buffers and descriptor table for entry-count validation.
Allocate the next chunk buffer and account for bytes remaining.
Populate the descriptor entry for this chunk.
Record the physical address of the descriptor list for subsequent commands.
Attempt to enable HMB with zero descriptor entries and expect Invalid Field in Command.
Enable HMB with the valid descriptor count to confirm success.
Query the HMB feature to verify descriptor list information.
Disable the HMB feature and return the controller to default configuration.

function: scripts/conformance/03_features/hmb/2_protocol_test.py::test_hmb_format_sanitize

Confirm that format and sanitize operations succeed while HMB traffic continues to run.

Reference

Spec: NVM Express Revision 1.4a

Steps

Enable the HMB feature before issuing IO and maintenance commands.
Run ioworker traffic to exercise the data path while HMB is active.
Record the current LBA format ID from Identify data.
Issue a format command while HMB remains enabled.
Run ioworker traffic again to verify IO remains healthy post-format.
Skip the sanitize portion when the controller reports no support.
Launch a block erase sanitize and monitor progress via the sanitize log page.
Run ioworker traffic a final time to validate HMB functionality.

function: scripts/conformance/03_features/hmb/2_protocol_test.py::test_hmb_enable_disable_with_ioworker

Stress enable and disable transitions for HMB while an IO workload runs continuously.

Reference

Spec: NVM Express Revision 1.4a

Steps

Cycle HMB enable and disable while random IO runs to expose timing issues.

function: scripts/conformance/03_features/hmb/2_protocol_test.py::test_hmb_data_consistency

Verify data consistency across HMB enable and disable transitions by comparing read buffers.

Reference

Spec: NVM Express Revision 1.4a

Steps

Enable the HMB feature prior to capturing baseline IO data.
Run IO workload to seed media content before comparisons.
Read baseline data into reference buffers while HMB is enabled.
Disable HMB to compare behavior without host memory buffering.
Read data without HMB and confirm that it matches the HMB-enabled baseline.
Run IO workload again between enable and disable phases.
Capture another data snapshot with HMB disabled for later comparison.
Re-enable HMB prior to the final comparison read.
Read data with HMB enabled once more and ensure it matches the disabled snapshot.

file: scripts/conformance/03_features/hmb/3_size_test

function: scripts/conformance/03_features/hmb/3_size_test.py::test_hmb_single_buffer

Validate HMB single-buffer behavior by enabling the entire allocation and running IO traffic.

Reference

Specification: NVM Express Revision 1.4a.

Steps

Configure HMB as a single contiguous chunk covering the full allocation
Issue IO workloads to exercise the configured HMB

function: scripts/conformance/03_features/hmb/3_size_test.py::test_hmb_buffer_size_large

Validate large HMB chunk sizes by programming multiple megabyte chunks and running IO.

Reference

Specification: NVM Express Revision 1.4a.

Steps

Configure HMB using the requested multi-megabyte chunk size
Issue IO workloads to exercise the configured HMB

function: scripts/conformance/03_features/hmb/3_size_test.py::test_hmb_buffer_size_small

Stress small HMB chunk sizes by ensuring descriptor limits are sufficient before exercising IO.

Reference

Specification: NVM Express Revision 1.4a.

Steps

Skip test if the host cannot describe enough chunks for the selected configuration
Configure HMB using the requested small chunk size
Issue IO workloads to exercise the configured HMB

function: scripts/conformance/03_features/hmb/3_size_test.py::test_hmb_buffer_size_tiny

Validate extremely small HMB chunk sizes by checking descriptor capacity prior to executing IO.

Reference

Specification: NVM Express Revision 1.4a.

Steps

Skip test if the host cannot describe enough chunks for the selected configuration
Configure HMB using the requested tiny chunk size
Issue IO workloads to exercise the configured HMB

file: scripts/conformance/03_features/hmb/4_mr_test

function: scripts/conformance/03_features/hmb/4_mr_test.py::test_hmb_mr_reset

Validates MR bit persistence by reenabling HMB after resets and D3 transitions using the previously recorded buffer.

Reference

Specification: NVM Express Revision 1.4a

Steps

Enable HMB and verify baseline IO workload
Disable HMB while leaving MR metadata intact before reset
Skip reset operations when no event is requested
Trigger a controller reset when requested by the parameter
Perform subsystem reset followed by controller reset when requested
Cycle through D3hot to D0 and reset the controller after power transition
Reenable HMB with the same MR buffer parameters
Run IO workload again to ensure buffer reuse works after transitions

function: scripts/conformance/03_features/hmb/4_mr_test.py::test_hmb_mr_d3_without_disable

Confirms IO continues successfully after D3 transitions even when HMB is not reenabled until later depending on the disable flag.

Reference

Specification: NVM Express Revision 1.4a

Steps

Enable HMB and execute a baseline IO workload
Disable HMB with MR state saved prior to power change
Enter D3hot and return to D0 before resetting the controller
Optionally clear the HMB state completely when disable flag is set
Issue IO workload to detect failures when HMB stays disabled
Reenable HMB using the retained MR settings
Exercise IO workload again after HMB reenable

function: scripts/conformance/03_features/hmb/4_mr_test.py::test_hmb_mr_with_wrong_buffer

Ensures controller rejects MR enable attempts with zeroed buffer fields after D3 transitions by expecting an invalid field warning.

Reference

Specification: NVM Express Revision 1.4a

Steps

Enable HMB to capture valid buffer parameters
Run IO workload to confirm baseline behavior
Disable HMB while keeping MR metadata prior to power cycle
Transition through D3hot and reset the controller
Attempt to enable HMB with zeroed buffer values expecting invalid field warning
Run IO workload again to confirm the controller remains operational

function: scripts/conformance/03_features/hmb/4_mr_test.py::test_hmb_mr_with_different_buffer

Checks that mismatched MR buffer parameters are rejected after D3 transitions by issuing a set features command with altered values.

Reference

Specification: NVM Express Revision 1.4a

Steps

Enable HMB and confirm IO worker activity
Disable HMB while preserving MR metadata before power cycle
Move to D3hot, return to D0, and reset controller to simulate sleep
Attempt to enable HMB using modified buffer address and size to force rejection
Run IO workload afterward to ensure controller remains responsive

file: scripts/conformance/03_features/hmb/5_memory_test

function: scripts/conformance/03_features/hmb/5_memory_test.py::test_hmb_address_non_align

Verify HMB enabling succeeds even with a misaligned Host Memory Descriptor List address by issuing IO afterwards.

Reference

NVM Express Revision 1.4a

Steps

Enable HMB using a descriptor pointer that is intentionally misaligned.
Issue IO workload to confirm the controller operates normally.

function: scripts/conformance/03_features/hmb/5_memory_test.py::test_hmb_memory

Ensure preexisting host buffers retain data by allocating memory before and after enabling HMB and performing IO.

Reference

NVM Express Revision 1.4a

Steps

Allocate the first host buffer before enabling HMB and fill it with a fixed pattern.
Enable HMB to consume host memory for controller-managed caching.
Allocate a second host buffer after HMB enable with another pattern.
Run an IO workload while HMB is in use.
Confirm neither buffer content changed.

function: scripts/conformance/03_features/hmb/5_memory_test.py::test_hmb_not_equal

Validate the controller accepts HMB lists where entry sizes differ by enabling HMB with uneven descriptors.

Reference

NVM Express Revision 1.4a

Steps

Enable HMB with buffers configured to have unequal sizes per entry.
Run IO traffic to ensure normal behavior continues.

function: scripts/conformance/03_features/hmb/5_memory_test.py::test_hmb_out_of_order

Check that HMB remains operational when descriptor entries are intentionally out of order.

Reference

NVM Express Revision 1.4a

Steps

Enable HMB while permuting the entry order to mimic improper sorting.
Execute IO to verify HMB accesses despite the shuffled list.

function: scripts/conformance/03_features/hmb/5_memory_test.py::test_hmb_bit_flip_in_buffer_list

Introduce bit flips inside the Host Memory Descriptor List to ensure the controller tolerates descriptor corruption.

Reference

NVM Express Revision 1.4a

Steps

Enable HMB using a valid descriptor table.
Run IO to populate and exercise HMB.
Corrupt the descriptor list by flipping a bit in the HMB list buffer.
Run IO again to confirm the device handles the corrupted descriptor.

function: scripts/conformance/03_features/hmb/5_memory_test.py::test_hmb_bit_flip_data_consistency

Flip random bits inside HMB data buffers and verify read workloads continue to succeed.

Reference

NVM Express Revision 1.4a

Steps

Enable HMB before running any IO workload.
Run sequential writes to populate HMB with deterministic data.
Randomly flip bits in the HMB data buffers according to the parameterized count.
Re-run random read IO to ensure data path tolerates the corrupt cache lines.

function: scripts/conformance/03_features/hmb/5_memory_test.py::test_hmb_change_all_buffer_dword

Stress the controller by corrupting one byte in every 32-bit word of the HMB buffers before validation IO.

Reference

NVM Express Revision 1.4a

Steps

Enable HMB so the controller can start referencing host memory buffers.
Run sequential writes to populate the namespace and exercise HMB.
Walk each HMB buffer and flip a random bit within every dword.
Perform mixed random reads to observe behavior with widespread corruption.

function: scripts/conformance/03_features/hmb/5_memory_test.py::test_hmb_change_all_buffer_bytes

Corrupt every byte stored in HMB before executing a mixed read-write workload.

Reference

NVM Express Revision 1.4a

Steps

Enable HMB for the target namespace.
Run sequential writes to populate the namespace with predictable data.
Flip a random bit in every byte across all HMB buffers.
Execute mixed random IO to validate error handling after full corruption.

function: scripts/conformance/03_features/hmb/5_memory_test.py::test_hmb_change_all_buffer_interval

Inject periodic corruption into varied buffer intervals before running a mixed IO workload.

Reference

NVM Express Revision 1.4a

Steps

Enable HMB with standard descriptors.
Run sequential writes to preload the namespace and fill HMB.
Inject random bit flips within each selected interval across every HMB buffer.
Launch mixed random IO traffic to validate behavior after interval corruption.

folder: scripts/conformance/03_features

file: scripts/conformance/03_features/boot_partition_test

function: scripts/conformance/03_features/boot_partition_test.py::test_boot_partition_write

Validate boot partition programming by streaming Firmware Download chunks and completing with Firmware Commit.

Reference

NVM Express Revision 2.0

Steps

Compute boot image geometry based on the Boot Partition size field.
Prepare deterministic buffer chunks for the image payload.
Transfer each chunk sequentially with the Firmware Download command.
Commit the staged image to the specified boot partition.

function: scripts/conformance/03_features/boot_partition_test.py::test_boot_partition_load

Ensure boot partition data can be read through the MMIO load registers and matches the expected pattern.

Reference

NVM Express Revision 2.0

Steps

Calculate chunk geometry that aligns with the Boot Partition capacity.
Program the MMIO registers, fetch each chunk, and verify the pattern.
Report the effective boot partition read throughput.

function: scripts/conformance/03_features/boot_partition_test.py::test_boot_partition_load_beyond_end

Confirm the controller reports BPINFO.BRS errors when MMIO loads request data beyond the boot partition boundary.

Reference

NVM Express Revision 2.0

Steps

Allocate a transfer buffer and derive the total number of register-sized chunks.
Program the MMIO registers to read beyond the partition end.
Wait for completion and expect an error BRS status.
Retry with a valid offset and confirm successful completion.

function: scripts/conformance/03_features/boot_partition_test.py::test_boot_partition_verify

Verify the boot partition image via Boot Partition Log Page reads and compare the payload to the programmed pattern.

Reference

NVM Express Revision 2.0

Steps

Skip controllers whose reported specification version predates revision 2.0.
Confirm the Boot Partition log page is supported before accessing it.
Validate the reported Boot Partition size within the log page.
Calculate the total image size based on the Boot Partition descriptor.
Retrieve each chunk via Log Page offset reads and verify the buffer contents.
Report the sustained log page read throughput.

function: scripts/conformance/03_features/boot_partition_test.py::test_boot_partition_load_power_cycle

Ensure MMIO boot partition loads recover correctly when a dirty power cycle interrupts the transfer.

Reference

NVM Express Revision 2.0

Steps

Launch a boot partition load and verify the returned data pattern.
Start another load transaction without waiting for completion.
Force a dirty power cycle while the boot image transfer is active.
Reload the image after power is restored and confirm integrity.

function: scripts/conformance/03_features/boot_partition_test.py::test_boot_partition_load_change_address

Validate that reprogramming the MMIO address register mid-transfer routes the boot image to the updated buffer.

Reference

NVM Express Revision 2.0

Steps

Initiate a boot image load into the first buffer.
Reprogram the DMA address after the transfer has started.
Wait for completion and ensure the image appears in only one buffer.

function: scripts/conformance/03_features/boot_partition_test.py::test_boot_partition_load_write_dword

Ensure MMIO boot partition loads succeed when the DMA address registers are programmed with dword writes.

Reference

NVM Express Revision 2.0

Steps

Program the DMA address via dword writes and start the load.
Wait for completion and validate the buffer contents.

function: scripts/conformance/03_features/boot_partition_test.py::test_boot_partition_load_offset

Verify the boot partition can be loaded into a buffer starting at non-4K aligned offsets without data corruption.

Reference

NVM Express Revision 2.0

Steps

Initiate a boot image load into a buffer with the specified offset.
Validate that the resulting buffer matches the expected image pattern.

function: scripts/conformance/03_features/boot_partition_test.py::test_boot_partition_power_cycle

Validate that Firmware Commit to a boot partition remains atomic when a dirty power cycle interrupts the download or commit flow.

Reference

NVM Express Revision 2.0

Steps

Program a known baseline image into boot partition 0 using the helper routine.
Recompute the total image size and chunking parameters used for downloads.
Stage a replacement image by issuing Firmware Download for each chunk.
Commit the newly downloaded image to the boot partition.
Force a dirty power cycle while the commit is in progress.
Load the boot partition through the MMIO registers after power recovery.
Verify whether each chunk matches the old or new pattern.
Firmware Commit with Commit Action 110b or 111b shall guarantee atomic operation.

file: scripts/conformance/03_features/power_management_test

function: scripts/conformance/03_features/power_management_test.py::test_power_state_transition

Exercise read I/O while forcing manual power state transitions between two targets.

Reference

NVM Express Revision 1.4a.

Steps

Disable APST so the test can manually drive every transition.
Seed the target LBA with known data for later verification.
Sweep multiple transition delays and confirm read correctness.
logging.info(delay)
Force the initial power state before the delay window.
Request the target state and pause for the active delay.
Re-read the seeded LBA and verify data integrity.
Consume the completion from the asynchronous Set Features call.

function: scripts/conformance/03_features/power_management_test.py::test_power_state_ps3_simple

Confirm the controller exits PS3 when new work arrives by issuing admin and I/O commands.

Reference

NVM Express Revision 1.4a.

Steps

Disable APST so the controller holds the requested state.
Place the controller in PS0 and allow it to settle.
Move to PS3 and remain idle long enough for the state to stabilize.
Issue admin identify and read IOs to ensure the device wakes correctly.

function: scripts/conformance/03_features/power_management_test.py::test_power_state_async_with_io

Stress background reads while repeatedly forcing asynchronous transitions into PS3 and PS4.

Reference

NVM Express Revision 1.4a.

Steps

Disable APST so manual transitions remain in effect.
Prime the controller in the provided operational state before testing.
Fill the namespace so that later reads return meaningful data.
Run a read workload while toggling between non-operational states.
Alternate between PS3 and PS4 while the workload is active.
Gather the results once the worker completes.

function: scripts/conformance/03_features/power_management_test.py::test_power_state_operational_async_with_io

Cycle through operational power states while a read workload runs to confirm stability.

Reference

NVM Express Revision 1.4a.

Steps

Disable APST so the test can directly select every operational state.
Begin the test from PS0 to establish a reference point.
Precondition the namespace with deterministic data.
Keep issuing reads while hopping among operational states.
Randomize the next operational state every iteration.

function: scripts/conformance/03_features/power_management_test.py::test_power_state_npss

Confirm every advertised power state can be selected and invalid states fail cleanly.

Reference

NVM Express Revision 1.4a.

Steps

Query the number of supported power states from Identify data.
Disable APST if the controller supports it to maintain manual control.
Set each valid power state and confirm the same value is reported back.
Ensure the Set Features command succeeded.
Try invalid power states and expect the controller to return an error.

function: scripts/conformance/03_features/power_management_test.py::test_power_state_maximum_power

Verify the maximum power consumption monotonically decreases across power states.

Reference

NVM Express Revision 1.4a.

Steps

Read the number of supported power states and stage storage.
Collect the scaled maximum power value for each state.
Confirm power decreases across operational states.
Confirm power decreases across non-operational states and between groups.

function: scripts/conformance/03_features/power_management_test.py::test_power_state_operational_ps_with_ioworker

Run ioworker workloads in every operational power state to ensure IO completes cleanly.

Reference

NVM Express Revision 1.4a.

Steps

Enable APST when supported so the controller may downshift as needed.
Iterate each operational state and run a brief workload.

function: scripts/conformance/03_features/power_management_test.py::test_power_state_nonoperational_ps_with_io

Issue IO of a single opcode from each non-operational state and confirm the controller resumes the prior operational state.

Reference

NVM Express Revision 1.4a.

Steps

Disable APST so manual power selections are honored during setup.
Walk through every operational/non-operational pairing and send IOs.
Confirm Set Features landed on the requested non-operational state.
Validate the controller resumes the prior operational power state.

function: scripts/conformance/03_features/power_management_test.py::test_power_state_nonoperational_ps_with_mixio

Issue mixed IO workloads in non-operational states to confirm the controller resumes the previous operational state.

Reference

NVM Express Revision 1.4a.

Steps

Disable APST so the test can hold each power state pair precisely.
For each pairing, run a mixed workload and see if APST reverts to the operational state.
Validate the request placed the controller into the non-operational state.
Ensure the controller transitions back to the latest operational state.

function: scripts/conformance/03_features/power_management_test.py::test_power_state_with_admin_cmd

Issue admin commands in every power state and ensure the state does not drift.

Reference

NVM Express Revision 1.4a.

Steps

Disable APST when present so manual state selection sticks.
Loop through every state, send admin log reads, and verify the state is unchanged.

function: scripts/conformance/03_features/power_management_test.py::test_power_state_temperature_aer

Drive temperature thresholds in every power state and verify AERs trigger without altering the state.

Reference

NVM Express Revision 1.4a.

Steps

Capture the current temperature configuration for restoration later.
Enable the temperature threshold asynchronous event.
Skip when the device cannot report temperature via AER.
Disable APST if present so the current power state remains fixed.
Allocate a SMART log buffer for repeated temperature sampling.
Iterate through each power state, trigger the warning, and confirm the state does not change.
Raise an over-temperature event.
Restore the threshold and confirm the warning clears without power-state movement.

function: scripts/conformance/03_features/power_management_test.py::test_power_state_nonoperational_ps_with_dst

Run device self-tests from non-operational states to ensure power states remain latched.

Reference

NVM Express Revision 1.4a.

Steps

Skip the test when device self-test is unsupported.
Enable Non-Operational Power State Permissive Mode to allow DST work.
Disable APST so the controller stays in the requested power state.
Launch DST from each non-operational state and confirm the state remains unchanged.
Verify permissive mode holds the controller in the test state.

function: scripts/conformance/03_features/power_management_test.py::test_power_state_short_dst_duration

Hammer Set Features commands during a short DST and confirm it still finishes within spec.

Reference

NVM Express Revision 1.4a.

Steps

Skip if the controller lacks device self-test support.
Start a short DST and capture the baseline timestamp.
Flood Set Features requests across power states until DST completes.
Abort the DST if needed and ensure it completed within the two-minute limit.

function: scripts/conformance/03_features/power_management_test.py::test_power_state_different_ps_with_write_register

Write NVMe registers in every power state to ensure MMIO does not disturb the current state.

Reference

NVM Express Revision 1.4a.

Steps

Disable APST to guarantee Set Features stays applied.
Touch registers repeatedly across all power states and verify they remain fixed.
Ensure the MMIO accesses did not trigger a power transition.

function: scripts/conformance/03_features/power_management_test.py::test_power_state_different_ps_with_write_pcie_register

Write PCIe configuration registers across power states to ensure the NVMe state is maintained.

Reference

NVM Express Revision 1.4a.

Steps

Disable APST when supported to keep the state fixed.
Perform repeated PCIe writes for each state and verify the state stays locked.
Confirm MMIO/configuration access did not change the power state.

function: scripts/conformance/03_features/power_management_test.py::test_power_state_autonomous_ps_transitions

Verify APST drives the controller into non-operational states after extended idle time.

Reference

NVM Express Revision 1.4a.

Steps

Ensure Non-Operational Power State Permissive Mode is off when possible.
Enable APST so the controller autonomously transitions after idle.
Idle in each operational state for long enough to trigger APST.
Confirm the controller entered one of the non-operational states.

function: scripts/conformance/03_features/power_management_test.py::test_power_state_invalid_transition

Verify the controller rejects APST entries that specify operational target states.

Reference

NVM Express Revision 1.4a.

Steps

Skip when the device reports an NVMe version earlier than 1.4.
Skip when APST is not implemented.
Enable APST so the host can program entries for validation.
Determine how many power states to exercise in the APST table.
Program APST entries that incorrectly target operational states and expect errors.

function: scripts/conformance/03_features/power_management_test.py::test_power_state_max_power_pcie

Compare PS0 maximum power against the PCIe slot limit to ensure compliance.

Reference

NVM Express Revision 1.4a.

Steps

Derive the PCIe slot power limit from the capability registers.
Calculate PS0 maximum power from the Identify descriptor.
Compare the two numbers to ensure the slot can supply PS0.

function: scripts/conformance/03_features/power_management_test.py::test_power_state_operational_performance

Measure sequential read performance in each operational power state for comparison.

Reference

NVM Express Revision 1.4a.

Steps

Disable APST if needed and reformat to get consistent workload data.
Capture read IOPS for every operational power state.
for ps in range(len(ops_list)-1):
if iops[ps] > iops[ps+1]:

   warnings.warn("performance is not degraded at lower power state")

function: scripts/conformance/03_features/power_management_test.py::test_power_state_thermal_throttle_performance

Check read performance while varying host-controlled thermal throttle thresholds.

Reference

NVM Express Revision 1.4a.

Steps

Reformat the namespace so the ensuing workload has a clean baseline.
skip this test if the feature is not supported by the device
fix on PS0, and disable autonomous power state transitions
get current temperature from SMART data
Helper to fetch the SMART temperature and validate input ranges.
Helper to measure IO performance with the current throttle configuration.
skip the test if current temperature is out of scope host can control
get the performance in normal case, no thermal throttle
idle to cool down, and get current temperature
make current temperature higher than TMT1 for the light throttle
light throttle performance should be lower than usual performance
idle to cool down, and get current temperature
make current temperature higher than TMT2 for the heavy throttle
heavy throttle performance should be lower than light throttle performance
idle to cool down, and get current temperature
make current temperature higher than TMT1 and lower than TMT2, but the heavy throttle continues
light throttle performance should be higher than heavy throttle performance
restore the TMT setting

function: scripts/conformance/03_features/power_management_test.py::test_power_state_with_hot_reset

Force hot resets immediately after power-state selections and ensure the controller recovers to PS0.

Reference

NVM Express Revision 1.4a.

Steps

Drive each power state just before initiating a hot reset.
After every reset confirm the controller comes back in PS0.
Disable APST when available to keep the target state fixed.

function: scripts/conformance/03_features/power_management_test.py::test_power_state_with_function_level_reset

Issue PCIe FLR operations after selecting various power states and ensure recovery to PS0.

Reference

NVM Express Revision 1.4a.

Steps

Walk through all power states before triggering FLR cycles.
Validate that each FLR returns the controller to PS0.
Disable APST for deterministic state transitions.

function: scripts/conformance/03_features/power_management_test.py::test_power_state_idle_transition_ps

Program APST idle timers and verify transitions occur when the idle window elapses.

Reference

NVM Express Revision 1.4a.

Steps

Enable APST and back up the table for later restoration.
Program a three-second idle timeout and probe behavior above/below the threshold.
Program a five-second timeout and repeat the same checks at different delays.

function: scripts/conformance/03_features/power_management_test.py::test_power_state_disable_special_ps_apst

Disable APST for selected power states and confirm they no longer transition automatically.

Reference

NVM Express Revision 1.4a.

Steps

Enable APST and keep a backup copy of the programmed table.
Helper function that zeroes the APST entry for a specific state.
Clear the APST entry for the targeted power state.
Read the NPSS value so we can iterate through every state.
Disable APST per state and confirm the controller remains in that state while idle.

function: scripts/conformance/03_features/power_management_test.py::test_power_state_break_transition

Verify that issuing IO during APST idle windows resets the transition timer.

Reference

NVM Express Revision 1.4a.

Steps

Enable APST and keep a backup of the original table.
Inject IO before the idle window expires and confirm APST restarts the timer.

function: scripts/conformance/03_features/power_management_test.py::test_power_state_change_idle_time

Modify APST idle timers on the fly and verify the new delay takes effect.

Reference

NVM Express Revision 1.4a.

Steps

Enable APST and snapshot the table for restoration.
Update the idle time before it expires and verify the state does not change prematurely.

function: scripts/conformance/03_features/power_management_test.py::test_power_state_host_power

Map host power-state policies onto NVMe power states and validate the resulting behavior under load.

Reference

NVM Express Revision 1.4a.
Microsoft Power Management for Storage Hardware Devices (NVMe).

Steps

Define representative host policies with idle and change times.
key: [idle_time/ms, change_time/ms]
Derive the device latency numbers from Identify data.
Fill the namespace so later reads validate data already present.
Helper that runs a read workload and then forces a specific NVMe power state.
Randomly select host states and map them to controller states for multiple cycles.
Create a comparison rule that favors states meeting the host latency allowance.
Rank the controller states by the comparison rule.
Default to PS0 if no device latency satisfies the host target.
Otherwise select the mapped power state, handling Modern Standby specially.

function: scripts/conformance/03_features/power_management_test.py::test_power_state_latency

Measure transition latency between every state pair and compare with the advertised limits.

Reference

NVM Express Revision 1.4a.

Steps

Disable APST when present to keep power states under manual control.
Walk through each source/target combination and validate the reported latency.

function: scripts/conformance/03_features/power_management_test.py::test_power_state_apst_saveable

Validate that APST settings persist across resets when marked as saveable.

Reference

NVM Express Revision 1.4a.

Steps

Skip the test entirely when APST is unsupported.
Ensure the controller advertises a saveable/ changeable APST capability.
Keep the original APST table beside a copy of the effective state.
Program APST with sv=1 and disable transitions.
Reset the controller to check whether the setting persists.
Confirm APST remains disabled after reset via all select options.
Restore the original APST programming.

function: scripts/conformance/03_features/power_management_test.py::test_power_state_idle_with_low_speed

Exercise APST behavior while stepping through multiple PCIe link speeds.

Reference

NVM Express Revision 1.4a.

Steps

Skip test execution entirely when APST is unsupported.
Enable APST so the controller can autonomously downshift while links slow down.
Ensure the requested link speed is within device capability.
Force the PCIe link to the requested speed and confirm the hardware honors it.
check acutal link speed
check apst is enabled
Enable ASPM L1.2 to push the link into the lowest possible idle state.
Fix the controller on PS0 before starting IO.
Write and flush a known block so later reads have context.
Issue reads with increasing idle gaps to observe APST and ASPM combined behavior.
Restore the original link speed before exiting the test.

function: scripts/conformance/03_features/power_management_test.py::test_power_state_format

Issue Format commands from every power state and confirm the controller stays in that state.

Reference

NVM Express Revision 1.4a.

Steps

Loop through each state, run standard and secure format, and confirm the state persists.

file: scripts/conformance/03_features/reset_test

function: scripts/conformance/03_features/reset_test.py::test_reset_queue_level_reset

Validate queue-level reset while IO remains outstanding by deleting and recreating the queues mid traffic.

Reference

NVM Express Revision 1.4a, Section 7.3.3.

Steps

Format the namespace so data verification starts from a known zero baseline.
Create IO submission and completion queues for manual operations.
Submit patterned write commands to seed data before the reset.
Trigger a queue-level reset while the write commands remain outstanding.
Recreate the queues and issue read commands to validate data.
Verify each completion returns the expected pattern or permissible all-zero data.
Tear down the IO queues used in this test.

function: scripts/conformance/03_features/reset_test.py::test_reset_controller_reset_nvme_registers

Ensure controller reset restores CC and AQA registers after deliberate modifications.

Reference

NVM Express Revision 1.4a, Section 7.3.2.

Steps

Capture the original CC register value for later comparison.
Modify CC so that a reset-induced change can be detected.
Issue a controller-level reset.
Confirm the CC register returns to its original value.
Clear CC.EN to permit updates to admin queue registers.
Adjust the AQA register to a known offset.
Re-enable CC.EN so the controller latches the changed registers.
Ensure the AQA modification is visible before reset.
Verify AQA returns to its saved value after reset.

function: scripts/conformance/03_features/reset_test.py::test_reset_controller_reset_d3hot

Confirm controller reset succeeds after exiting D3hot and returning to D0.

Reference

NVM Express Revision 1.4a, Section 7.3.2.

Steps

Drive the device into D3hot and wait for the power state to stabilize.
Return the device to D0 before resetting.
Issue a controller-level reset.
Confirm the controller reports ready status after reset.

function: scripts/conformance/03_features/reset_test.py::test_reset_controller_reset_aspm

Verify controller reset behavior while toggling ASPM states before issuing the reset.

Reference

NVM Express Revision 1.4a, Section 7.3.2.

Steps

Force ASPM disabled and wait briefly for the link to settle.
Enable ASPM L1 and wait briefly before issuing the reset.
Issue a controller-level reset.
Confirm the controller reports ready status after reset.

function: scripts/conformance/03_features/reset_test.py::test_reset_controller_reset_with_outstanding_io

Validate controller reset during outstanding IO by resubmitting reads and checking data patterns.

Reference

NVM Express Revision 1.4a, Section 7.3.2.

Steps

Format the namespace so data verification starts from a known zero baseline.
Submit a burst of write commands to keep the queue busy.
Reset the controller while IOs remain active.
Recreate the queues and issue read commands to validate data.
Verify each completion returns the expected pattern or permissible all-zero data.

function: scripts/conformance/03_features/reset_test.py::test_reset_controller_reset_ioworker

Check controller reset resiliency while background IO workers generate traffic.

Reference

NVM Express Revision 1.4a, Section 7.3.2.

Steps

Reset the controller while an IO worker continues running.
Confirm the controller reports ready status after reset.

function: scripts/conformance/03_features/reset_test.py::test_reset_controller_with_existed_adminq

Ensure controller reset can reuse existing admin queue register state without reinitialization.

Reference

NVM Express Revision 1.4a.

Steps

Record the current admin queue register values.
Reset the controller using the preserved admin queue settings.
Issue thousands of admin commands to validate the reused queue.
Verify the admin queue registers match the saved values after reset.

function: scripts/conformance/03_features/reset_test.py::test_reset_flr_d3hot

Confirm function level reset behaves correctly after the device exits D3hot.

Reference

NVM Express Revision 1.4a, Section 7.3.2.

Steps

Drive the device into D3hot and wait for the power state to stabilize.
Issue a PCIe function level reset.
Confirm the controller reports ready status after reset.

function: scripts/conformance/03_features/reset_test.py::test_reset_flr_aspm

Verify function level reset while the link is held in ASPM L1.

Reference

NVM Express Revision 1.4a, Section 7.3.2.

Steps

Enter ASPM L1 and hold the state before the reset.
Issue a PCIe function level reset.
Confirm the controller reports ready status after reset.

function: scripts/conformance/03_features/reset_test.py::test_reset_flr_with_ioworker

Validate function level reset during IO worker activity to ensure recovery.

Reference

NVM Express Revision 1.4a.

Steps

Run an IO worker and trigger FLR mid workload.

function: scripts/conformance/03_features/reset_test.py::test_reset_flr_with_outstanding_io

Ensure function level reset during outstanding IO preserves data integrity afterward.

Reference

NVM Express Revision 1.4a, Section 7.3.2.

Steps

Format the namespace so data verification starts from a known zero baseline.
Create IO submission and completion queues for manual operations.
Post a burst of commands so IO remains outstanding.
Trigger FLR while writes are still in flight.
Recreate queues after reset and issue reads to verify data.
Validate that completion data patterns meet expectations.

function: scripts/conformance/03_features/reset_test.py::test_reset_pci_hot_reset_d3hot

Check PCIe hot reset behavior immediately after exiting D3hot.

Reference

NVM Express Revision 1.4a, Section 7.3.2.

Steps

Drive the device into D3hot and wait for the power state to stabilize.
Issue a PCIe hot reset followed by a controller reset.
Confirm the controller reports ready status after reset.

function: scripts/conformance/03_features/reset_test.py::test_reset_pci_hot_reset_aspm

Verify PCIe hot reset while toggling ASPM states before the reset.

Reference

NVM Express Revision 1.4a, Section 7.3.2.

Steps

Force ASPM disabled and wait briefly for the link to settle.
Enable ASPM L1 and wait briefly before issuing the reset.
Issue a PCIe hot reset followed by a controller reset.
Confirm the controller reports ready status after reset.

function: scripts/conformance/03_features/reset_test.py::test_reset_pci_hot_reset_with_ioworker

Ensure PCIe hot reset works while IO workers issue commands.

Reference

NVM Express Revision 1.4a, Section 7.3.2.

Steps

Run an IO worker and trigger a PCIe hot reset mid workload.
Confirm the controller reports ready status after reset.

function: scripts/conformance/03_features/reset_test.py::test_reset_pci_hot_reset_with_outstanding_io

Validate PCIe hot reset with outstanding IO by checking post-reset reads.

Reference

NVM Express Revision 1.4a, Section 7.3.2.

Steps

Format the namespace so data verification starts from a known zero baseline.
Create IO submission and completion queues for manual operations.
Issue a burst of write commands to create outstanding IO.
Initiate the selected reset while IO remains pending.
Recreate queues after reset and issue reads to verify data.
Validate that completion data patterns meet expectations.

function: scripts/conformance/03_features/reset_test.py::test_reset_subsystem_reset_aspm

Verify subsystem reset while toggling ASPM L1 state.

Reference

NVM Express Revision 1.4a, Section 7.3.4.

Steps

Force ASPM disabled and wait briefly for the link to settle.
Enable ASPM L1 and wait briefly before issuing the reset.
Verify the drive reports ready status after reset.

function: scripts/conformance/03_features/reset_test.py::test_reset_subsystem_reset_with_ioworker

Check subsystem reset resilience while IO workers run.

Reference

NVM Express Revision 1.4a, Section 7.3.4.

Steps

Run an IO worker and trigger the subsystem reset mid workload.
Verify the drive reports ready status after reset.

function: scripts/conformance/03_features/reset_test.py::test_reset_subsystem_reset_with_outstanding_io

Ensure subsystem reset with outstanding IO maintains acceptable data patterns afterward.

Reference

NVM Express Revision 1.4a, Section 7.3.4.

Steps

Format the namespace so data verification starts from a known zero baseline.
Create IO submission and completion queues for manual operations.
Issue a burst of write commands to create outstanding IO.
Initiate the selected reset while IO remains pending.
Recreate queues after reset and issue reads to verify data.
Validate that completion data patterns meet expectations.

function: scripts/conformance/03_features/reset_test.py::test_reset_timing

Measure NVMe initialization timing from CC.EN enable through first admin and IO completions.

Reference

NVM Express Revision 1.4a.

Steps

Define a custom NVMe initialization routine.
Disable CC.EN and wait for CSTS.RDY to clear.
Program the admin queue registers.
Program the CC register fields.
Enable CC.EN and capture the timestamp.
Instantiate the controller with the custom init function.
Wait for CSTS.RDY to assert.
Issue the first Identify command and capture latency.
Initialize each namespace and create IO queues.
Issue the first IO read and record its latency.
Release allocated queues and namespace handles.

file: scripts/conformance/03_features/write_protect_test

function: scripts/conformance/03_features/write_protect_test.py::test_write_protect

Validate that namespace write protection is supported before executing the feature test.

Reference

Specification: NVM Express Revision 1.4c

Steps

Check the Identify Namespace data to confirm write protection support.

folder: scripts/conformance/04_registers

file: scripts/conformance/04_registers/controller_test

function: scripts/conformance/04_registers/controller_test.py::test_controller_cap

Validate CAP/CC expose correct page size limits and NVM command set support.

Reference

NVM Express Revision 1.4a.

Steps

Retrieve Controller Capabilities register to parse limits
Derive MPSMIN and MPSMAX to compute supported page sizes
Verify MPSMAX is not smaller than MPSMIN
Read Controller Configuration Memory Page Size
Ensure configured MPS is within advertised range
Confirm CAP indicates NVM command set support

function: scripts/conformance/04_registers/controller_test.py::test_controller_crto

Verify CRTO/CRMS timeouts are reported correctly and registers remain read-only.

Reference

NVM Express Revision 2.0c.

Steps

Skip if NVMe spec version is below 2.0
Capture CRTO-related fields from CAP and CRTO
Attempt to modify read-only CRTO register and verify no change
Validate CRWMT value and emit warning when too small
Check the relationship between CRIMT and CRWMT
Validate CRIMT range when supported

function: scripts/conformance/04_registers/controller_test.py::test_controller_version

Confirm the Version register reports a supported NVMe major revision.

Reference

NVM Express Revision 1.4a.

Steps

Read Version register value
Validate supported major version field

function: scripts/conformance/04_registers/controller_test.py::test_controller_cc

Inspect CC to ensure CQ/SQ entry sizes match NVMe requirements.

Reference

NVM Express Revision 1.4a.

Steps

Read Controller Configuration
Verify IOCQES/IOSQES encode 16B CQ and 64B SQ entries

function: scripts/conformance/04_registers/controller_test.py::test_controller_register_reserved

Ensure reserved controller registers remain zero after write attempts.

Reference

NVM Express Revision 1.4a.

Steps

Confirm reserved field starts at zero
Attempt to write to reserved field
Re-read reserved field to ensure it stayed zero

function: scripts/conformance/04_registers/controller_test.py::test_controller_csts

Read CSTS to confirm CSTS.RDY indicates controller is ready.

Reference

NVM Express Revision 1.4a.

Steps

Read Controller Status register
Check csts.rdy is 1

function: scripts/conformance/04_registers/controller_test.py::test_controller_cap_to

Toggle CC.EN and measure CSTS.RDY transitions against CAP.TO limits.

Reference

NVM Express Revision 1.4a.

Steps

Read Controller Capabilities Timeout value
Disable cc.en to start timing deassertion
Wait for CSTS.RDY to clear and verify timing
Restore cc.en to re-enable controller
Wait for CSTS.RDY to assert and verify timing

function: scripts/conformance/04_registers/controller_test.py::test_controller_cap_mqes

Attempt to create IO queues larger than MQES to confirm enforcement of the advertised limit.

Reference

NVM Express Revision 1.4a.

Steps

Read Maximum Queue Entries Supported
Verify minimum queue depth support and skip if maximum already reached
Expect IO CQ creation to fail when queue size exceeds MQES
Expect IO SQ creation to fail when queue size exceeds MQES

function: scripts/conformance/04_registers/controller_test.py::test_controller_ams

Confirm CAP/CC reflect supported and selected arbitration mechanisms.

Reference

NVM Express Revision 1.4a.

Steps

Read Arbitration Mechanism Supported
Read Arbitration Mechanism Selected

function: scripts/conformance/04_registers/controller_test.py::test_controller_intms_and_intmc

Validate INTMS/INTMC mask registers remain unchanged after writes.

Reference

NVM Express Revision 1.4a.

Steps

Read Interrupt Mask Set and Interrupt Mask Clear
Write zeros to INTMS to test immutability
Write zeros to INTMC to test immutability
Ensure INTMS and INTMC retained their original values

function: scripts/conformance/04_registers/controller_test.py::test_controller_cc_iocqes

Compare CC.IOCQES with Identify CQES limits to validate completion entry size.

Reference

NVM Express Revision 1.4a.

Steps

Read I/O Completion Queue Entry Size from CC
Read Identify Completion Queue Entry Size limits
Validate identify Completion Queue Entry Size bounds
Ensure CC.IOCQES falls within Identify CQES limits

function: scripts/conformance/04_registers/controller_test.py::test_controller_cc_iosqes

Compare CC.IOSQES with Identify SQES limits to validate submission entry size.

Reference

NVM Express Revision 1.4a.

Steps

Read I/O Submission Queue Entry Size from CC
Read Identify Submission Queue Entry Size limits
Validate identify Submission Queue Entry Size bounds
Ensure CC.IOSQES falls within Identify SQES limits

function: scripts/conformance/04_registers/controller_test.py::test_controller_cc_en

Toggle CC.EN while running simple I/O to verify shutdown and reinitialization succeed.

Reference

NVM Express Revision 1.4a.

Steps

Capture current CC.EN state before exercising transitions
Ensure controller is fully ready
Issue a simple read command through a small IO queue pair
Confirm read completed successfully
Disable cc.en to shut down controller
Wait for CSTS.RDY to deassert
Reinitialize admin queue while controller is disabled
Re-enable cc.en using original configuration
Wait for CSTS.RDY to assert and confirm CC restored

function: scripts/conformance/04_registers/controller_test.py::test_controller_cc_css

Read CSS within CC to ensure the controller reports the expected I/O command set.

Reference

NVM Express Revision 1.4a.

Steps

Read Controller Configuration I/O Command Set Selected

function: scripts/conformance/04_registers/controller_test.py::test_controller_mdts

Exercise I/O sizes around Identify MDTS to confirm errors occur when limits are exceeded.

Reference

NVM Express Revision 1.4a.

Steps

Skip the test if controller already advertises 2MB MDTS
Get Memory Page Size Minimum
Get Maximum Data Transfer Size
Create Submission/Completion Queue
Prepare long data buffer chain for the write command
Issue a write command with maximum valid number of pages
Expect the write command to complete successfully
Issue a write command exceeding MDTS limit
Expect the write command to complete with an error status
Issue a read command exceeding MDTS limit
Expect the read command to complete with an error status
Issue a read command within MDTS limit
Expect the read command to complete successfully
Delete Submission/Completion Queue

function: scripts/conformance/04_registers/controller_test.py::test_controller_doorbell_invalid

Write an invalid doorbell value to confirm the controller raises an asynchronous event.

Reference

NVM Express Revision 1.4a.

Steps

Issue one AER command to monitor asynchronous errors
Retrieve supported queue counts from Number of Queues feature
Access invalid doorbell register and expect async error

function: scripts/conformance/04_registers/controller_test.py::test_controller_cc_shn

Send a shutdown notification and observe CC/CSTS fields to ensure shutdown flow follows specification.

Reference

NVM Express Revision 1.4a.

Steps

Read Controller Configuration before triggering shutdown
Observe current SHN bits and CSTS state
Send shutdown notify to DUT and reset afterward

function: scripts/conformance/04_registers/controller_test.py::test_controller_shn_before_commands

Issue admin and I/O commands before shutdown notify to confirm controller recovers cleanly.

Reference

NVM Express Revision 1.4a.

Steps

Send read IO commands and admin commands prior to shutdown
Send shutdown notify and measure response time
Reset controller without power cycle
Send read IO commands and admin commands after reset

function: scripts/conformance/04_registers/controller_test.py::test_controller_cc_memory_page_size_8k

Reinitialize the controller with an 8K memory page size and verify 4K I/O still succeeds.

Reference

NVM Express Revision 1.4a.

Steps

Define a helper that reinitializes the controller with an 8K page size
Disable cc.en and wait for CSTS.RDY to deassert
Initialize admin queue registers
Program CC with the desired 8K memory page size
Enable cc.en using the 8K configuration
Wait until CSTS.RDY indicates the controller is ready
Identify the controller and enumerate namespaces
Configure the number of queues via set/get features
Check if MPS supports 8K page size
Prepare 4K read/write buffer
Send write and read command
Wait for commands to complete and verify data integrity

function: scripts/conformance/04_registers/controller_test.py::test_controller_asq

Configure the controller with different ASQ offsets to ensure admin queue processing is unaffected.

Reference

NVM Express Revision 1.4a.

Steps

Define a helper that reinitializes the controller with a shifted ASQ
Disable cc.en and wait for CSTS.RDY to deassert
Program admin queue registers with the requested ASQ offset
Configure CC before enabling the controller
Enable cc.en to bring the controller online
Wait until CSTS.RDY indicates readiness
Identify the controller and its namespaces
Reset controller with different locations of admin SQ
Test with many admin commands to fill-up admin SQ

file: scripts/conformance/04_registers/pcie_test

function: scripts/conformance/04_registers/pcie_test.py::test_pcie_identifiers

Check the PCI Identifiers fields by reading configuration space registers.

Reference

NVM Express Revision 1.4a.

Steps

Read Identifiers register from configuration space.
Read Class Code register to capture the device class tuple.
Read Subsystem Identifiers to confirm board specific IDs.

function: scripts/conformance/04_registers/pcie_test.py::test_pcie_command

Verify the PCI Command register contents by issuing configuration reads.

Reference

NVM Express Revision 1.4a.

Steps

Read the Command register snapshot for diagnostics.
Confirm the Memory Space Enable bit is set before exercising BAR access.
Confirm reserved bits remain clear to detect malformed configuration.

function: scripts/conformance/04_registers/pcie_test.py::test_pcie_revision_id

Capture the PCI Revision ID so later tests know which silicon is present.

Reference

NVM Express Revision 1.4a.

Steps

Read Revision ID register for logging.

function: scripts/conformance/04_registers/pcie_test.py::test_pcie_class_code

Validate the PCI Class Code matches a Non-Volatile memory controller.

Reference

NVM Express Revision 1.4a.

Steps

Read Class Code register to capture device type fields.
Check the class tuple matches the NVMe controller class code.

function: scripts/conformance/04_registers/pcie_test.py::test_pcie_bist

Read the PCI Built-In Self Test register to make sure no faults latched.

Reference

NVM Express Revision 1.4a.

Steps

Read Built-In Self Test register value from config space.
Verify completion code fields are zero or indicate test in progress.

function: scripts/conformance/04_registers/pcie_test.py::test_pcie_pmcr

Read PCI Power Management Capabilities to understand supported states.

Reference

NVM Express Revision 1.4a.

Steps

Locate the PCI Power Management capability offset.
Dump the capability register contents for version and AUX data.

function: scripts/conformance/04_registers/pcie_test.py::test_pcie_pmcsr

Read PCI Power Management Control and Status to track power state.

Reference

NVM Express Revision 1.4a.

Steps

Locate the PMCSR offset derived from the capability pointer.
Capture PMCSR fields such as current state and software reset bits.
Decode the optional Power Data reporting if the scale indicates support.

function: scripts/conformance/04_registers/pcie_test.py::test_pcie_pcie_cap

Interrogate PCIe capability, device, and status registers over config space.

Reference

NVM Express Revision 1.4a.

Steps

Locate the PCI Express capability structure.
Read the PCIe capability header for version, type, and slot info.
Read Device Capabilities to learn payload size support.
Read Device Control settings for payload, read request, and ordering.
Read and clear Device Status bits to monitor correctable errors.
Clear the correctable error detected bit to confirm write ability.

function: scripts/conformance/04_registers/pcie_test.py::test_pcie_link_capabilities_and_status

Read PCIe link capability, control, and status registers for link metrics.

Reference

NVM Express Revision 1.4a.

Steps

Gather link capability settings for speed, width, and ASPM support.
Read link control settings before making any ASPM modifications.
Read link status bits for negotiated speed, width, and training state.

function: scripts/conformance/04_registers/pcie_test.py::test_pcie_format

Issue a Format NVM command and confirm the controller completes it.

Reference

NVM Express Revision 1.4a.

Steps

Submit a format command and wait for completion.

function: scripts/conformance/04_registers/pcie_test.py::test_pcie_write_bandwidth

Measure write bandwidth by running a short sequential workload.

Reference

NVM Express Revision 1.4a.

Steps

Configure IO worker for sequential write workload.
Calculate throughput based on IO size and operation count.

function: scripts/conformance/04_registers/pcie_test.py::test_pcie_link_control_aspm

Toggle ASPM policies and issue repeated reads to observe behavior.

Reference

NVM Express Revision 1.4a.

Steps

Read current Link Control settings before modification.
Program the ASPM control bits to the requested setting.
Create IO submission and completion queues for read traffic.
Loop on 100 blocking reads to stress link power transitions.
Delay slightly between IOs to allow ASPM entry.
Restore ASPM configuration back to L0.

function: scripts/conformance/04_registers/pcie_test.py::test_pcie_mps_256

Confirm Max Payload Size is at least 256 bytes via the PCIe capability.

Reference

NVM Express Revision 1.4a.

Steps

Read the Device Control register to check negotiated MPS.

function: scripts/conformance/04_registers/pcie_test.py::test_pcie_read_write

Perform a write then read on the same LBA to validate data path.

Reference

NVM Express Revision 1.4a.

Steps

Issue a write to the target namespace and wait for completion.
Issue a read to confirm payload access still works.

function: scripts/conformance/04_registers/pcie_test.py::test_pcie_max_read_request_size

Sweep the Max Read Request Size register and measure IO bandwidth.

Reference

NVM Express Revision 1.4a.

Steps

Capture the current Device Control register settings.
Program a new Max Read Request Size value.
Re-read Device Control to confirm the update was accepted.
Run the bandwidth workload to gauge the effect.

function: scripts/conformance/04_registers/pcie_test.py::test_pcie_read_write_post

Repeat the write/read workload after changing payload settings.

Reference

NVM Express Revision 1.4a.

Steps

Write test data to confirm the namespace is available.
Read test data to ensure integrity after configuration changes.

function: scripts/conformance/04_registers/pcie_test.py::test_pcie_reset

Reset the PCIe link and controller to restore payload defaults.

Reference

NVM Express Revision 1.4a.

Steps

Reset the PCIe hierarchy before touching the controller.
Reset the controller to reinitialize admin state.

function: scripts/conformance/04_registers/pcie_test.py::test_pcie_read_write_after_reset

Verify read and write commands succeed after the PCIe reset.

Reference

NVM Express Revision 1.4a.

Steps

Run a write to ensure queues operate post-reset.
Run a read to confirm data-path functionality remains intact.

file: scripts/conformance/04_registers/power_test

function: scripts/conformance/04_registers/power_test.py::test_power_pcie_pmcsr_d3hot

Verify PMCSR-directed D3hot entry and exit while checking admin command behavior across transitions.

Reference

Specification: NVM Express Revision 1.4a

Steps

Read the PCI Power Management capability offset and control register.
Force the controller into D3hot via the PMCSR.
Return the controller to D0 and confirm admin command success.
Re-enter D3hot before sending an admin command.
Expect admin command timeouts in D3hot to confirm loss of service.
Restore the controller to D0 and verify it responds again.

function: scripts/conformance/04_registers/power_test.py::test_power_pcie_capability_d3hot

Validate D3hot transitions through PCIe capabilities while ensuring IO workloads continue to succeed in D0.

Reference

Specification: NVM Express Revision 1.4a

Steps

Read the PCIe power management registers for the initial state.
Confirm the controller starts in D0.
Drive the controller into D3hot and hold the state briefly.
Bring the controller back to D0 from D3hot.
Run an IO workload to verify D0 services requests.
Explicitly request D0 to ensure the state is stable.
Run another IO workload to confirm continued service.
Verify the power state remains D0 after the workload.

function: scripts/conformance/04_registers/power_test.py::test_power_pcie_aspm_L1

Ensure ASPM transitions between L1 and L0 still allow admin commands to complete successfully.

Reference

Specification: NVM Express Revision 1.4a

Steps

Drive the link into ASPM L1 state.
Send admin commands while in ASPM L1 and allow the state to settle.
Return to ASPM L0 and log controller information.

function: scripts/conformance/04_registers/power_test.py::test_power_pcie_aspm_l1_and_d3hot

Validate combined ASPM and D3hot transitions by toggling both mechanisms and running IO workloads.

Reference

Specification: NVM Express Revision 1.4a

Steps

Enable ASPM L1 to reduce link power.
Transition to D3hot while ASPM is active and pause briefly.
Bring the controller back to D0 and reset ASPM to L0.
Confirm ASPM reports L0 and run IO to verify functionality.
Enter D3hot again to validate repeated transitions.
Request ASPM L1 while in D3hot and wait briefly.
Return ASPM to L0 to prepare for D0 operation.
Bring the controller back to D0 after ASPM adjustments.
Run IO while in D0 and ASPM L0 to confirm serviceability.
Verify ASPM remains in L0 after the IO workload.
Transition back to D3hot for an additional cycle and pause briefly.
Exit D3hot to D0 to finish the sequence.
Run IO in D0 one final time to ensure stability.

function: scripts/conformance/04_registers/power_test.py::test_power_pcie_ioworker_aspm

Check ASPM toggling during mixed IO workloads to ensure data consistency.

Reference

Specification: NVM Express Revision 1.4a

Steps

Start a mixed read and write IO workload.
Toggle ASPM between L1 and L0 during the workload.
Reset the controller to clear any lingering ASPM effects.

folder: scripts/conformance/05_controller

file: scripts/conformance/05_controller/arbitration_test

function: scripts/conformance/05_controller/arbitration_test.py::test_arbitration_weighted_round_robin

Exercise urgent-class Weighted Round Robin by flooding queues with flush commands and verifying urgent completions arrive first.

Reference

NVM Express Revision 1.4a.

Steps

Confirm controller supports Weighted Round Robin arbitration
Reformat the namespace to remove prior workload artifacts
Program HPW:MPW:LPW ratios of 8:4:2 and an eight-command burst
Measure admin command latency while the device is idle
Create a completion queue and two SQs per priority class
Instantiate eight IO submission queues that cover all priorities
Fill each submission queue with 50 flush commands
Ring submission queue doorbells starting from the lowest priority
Measure admin command latency while IO queues are busy
Sample completion entries to capture submission queue IDs
Confirm urgent queues complete their work before the others
Delete the IO queues to restore the controller state

function: scripts/conformance/05_controller/arbitration_test.py::test_arbitration_weighted_round_robin_ioworker

Validate Weighted Round Robin proportional control by running IO workers at different priorities and comparing their throughput share.

Reference

NVM Express Revision 1.4a.

Steps

Confirm controller supports Weighted Round Robin arbitration
Reformat the namespace to ensure deterministic IO ranges
Pre-fill the working region with writes to remove read-modify penalties
Program HPW:MPW:LPW ratios of 8:4:2 and an eight-command burst
Configure one IO worker per priority level with identical transfer parameters
Start the IO workers and store their running handles
Close each worker to collect IO statistics and throughput
Assert that higher priority queues consume more IO bandwidth

function: scripts/conformance/05_controller/arbitration_test.py::test_arbitration_default_round_robin

Verify default round robin arbitration by flooding the controller with flush commands and checking that completions cover all queues evenly.

Reference

NVM Express Revision 1.4a.

Steps

Verify the controller offers a CQ depth large enough for the test
Ensure there are enough IO queue pairs to exercise round robin scheduling
Set the arbitration burst size to two commands
Create a completion queue and eight IO submission queues
Populate each submission queue with 50 flush commands
Ring the submission queue doorbells in numerical order
Measure admin command latency while IO queues are busy
Inspect completion entries to review submission queue IDs
Assert that round robin arbitration keeps completions evenly distributed
Delete created queues to restore the controller configuration

file: scripts/conformance/05_controller/interrupt_test

function: scripts/conformance/05_controller/interrupt_test.py::test_interrupt_aggregation_time_threshold

Verify interrupt aggregation time and threshold using Get Features commands.

Reference

Spec: NVM Express Revision 1.4a

Steps

Retrieve the default interrupt aggregation time and threshold settings

function: scripts/conformance/05_controller/interrupt_test.py::test_interrupt_qpair_msix_mask

Validate MSIx mask behavior by toggling the mask bits while issuing IO on a queue pair.

Reference

Spec: NVM Express Revision 1.4a

Steps

Initialize the queue pair and clear any pending MSIx interrupt
Issue a read command to trigger a notification
Confirm the MSIx interrupt asserts for the pending IO
Clear the MSIx pending bit
Issue another read command to confirm the interrupt flow
Confirm the MSIx interrupt asserts for the pending IO
Clear the pending interrupt and set the MSIx mask bits
Issue a read command while the interrupt remains masked
Confirm the MSIx interrupt stays deasserted while masked
Unmask the MSIx interrupt to release the pending completion
Verify the delayed interrupt is finally reported

function: scripts/conformance/05_controller/interrupt_test.py::test_interrupt_multiple_qpair_msix

Confirm MSIx interrupts are delivered per queue pair by issuing IOs on two vectors.

Reference

Spec: NVM Express Revision 1.4a

Steps

Create two queue pairs with interrupts enabled on separate vectors
Issue IO on the first queue pair
Confirm the first queue pair asserts its interrupt
Confirm the second queue pair does not receive an interrupt
Drain the completion before deleting the queues
Delete both queue pairs to clean up resources

function: scripts/conformance/05_controller/interrupt_test.py::test_interrupt_qpair_msix_coalescing

Measure MSIx interrupt coalescing by comparing latency before and after enabling aggregation time.

Reference

Spec: NVM Express Revision 1.4a

Steps

Clear existing interrupts before measuring latency
Enable interrupt vector coalescing to allow aggregation
Measure baseline interrupt latency for a single IO
Program aggregation time to 20ms and threshold to 6 completions
Issue two IOs to trigger coalescing behavior
Measure the coalesced interrupt latency for multiple IOs
Log a warning if latency does not reflect aggregation
Disable coalescing to restore immediate interrupts
Issue another IO to confirm latency returns to normal
Measure the interrupt latency with coalescing disabled
Warn if the latency remains unexpectedly high

function: scripts/conformance/05_controller/interrupt_test.py::test_interrupt_coalescing

Ensure disabling interrupt coalescing per vector bypasses the controller aggregation settings.

Reference

Spec: NVM Express Revision 1.4a

Steps

Enable coalescing on interrupt vector 1 as a baseline
Clear pending interrupts before measuring latency
Capture baseline interrupt latency to compare against aggregated runs
Issue preliminary reads to warm up the queue pair if required
Disable coalescing on the interrupt vector under test
Program the controller aggregation time and threshold
Submit IOs that would be aggregated if coalescing were enabled
Measure latency with vector-level coalescing disabled
Confirm latency stays below the aggregation window
Re-enable coalescing for interrupt vector 1
Submit IOs that should now aggregate
Measure latency with coalescing restored
Warn if interrupts still arrive immediately despite coalescing

function: scripts/conformance/05_controller/interrupt_test.py::test_interrupt_different_coalescing

Validate that queue pairs can independently enable or disable interrupt coalescing.

Reference

Spec: NVM Express Revision 1.4a

Steps

Instantiate two queue pairs to compare coalescing behaviors
Enable coalescing on both interrupt vectors initially
Measure baseline latency on the first queue pair
Disable coalescing for the second queue pair
Program shared aggregation time and threshold values
Issue IO on qpair1 to exercise aggregated behavior
Measure latency on qpair1 while aggregation is expected
Warn if the first queue pair does not show aggregation delay
Issue IO on qpair2 where coalescing has been disabled
Measure latency on qpair2 and ensure it stays short
Assert qpair2 latency remains below the aggregation window

function: scripts/conformance/05_controller/interrupt_test.py::test_interrupt_vector_discontiguous

Ensure queue pairs bound to discontiguous interrupt vectors signal on their assigned vector.

Reference

Spec: NVM Express Revision 1.4a

Steps

Create queue pairs pinned to interrupt vectors 2 and 4
Clear qpair1 interrupt state before issuing IO
Issue IO on qpair1 tied to vector 2
Verify qpair1 raises its own interrupt
Clear qpair2 interrupt state before the next IO
Issue IO on qpair2 tied to vector 4
Verify qpair2 raises its own interrupt
Delete the queue pairs after verification

function: scripts/conformance/05_controller/interrupt_test.py::test_interrupt_specific_interrupt_vector_coalescing

Demonstrate mixed interrupt vector coalescing states by measuring latency per vector.

Reference

Spec: NVM Express Revision 1.4a

Steps

Create queue pairs on distinct vectors with coalescing initially disabled
Read different LBAs to avoid LBA lock contention
Drain the expected completions and clear MSIx state
Enable coalescing only on qpair2
Configure aggregation time and threshold values
Measure qpair2 latency to verify aggregation is active
Measure qpair1 latency where coalescing remains disabled
Ensure qpair1 latency stays below the aggregation expectation

function: scripts/conformance/05_controller/interrupt_test.py::test_interrupt_create_cq_disable

Verify that a Completion Queue with interrupts disabled does not signal MSIx events.

Reference

Spec: NVM Express Revision 1.4a

Steps

Prepare IO buffers and queue pairs with interrupts enabled and disabled
Clear qpair1 interrupt state before issuing IO
Issue a write on qpair1 to trigger an interrupt
Verify qpair1 reports the interrupt and completion
Clear qpair2 interrupt state even though it is disabled
Issue a read on qpair2 where interrupts are disabled
Confirm qpair2 completes without asserting MSIx
Validate that the transferred data matches expectations
Delete both queue pairs after verification

function: scripts/conformance/05_controller/interrupt_test.py::test_interrupt_qpair_msix_coalescing_numb

Validate the interrupt aggregation threshold by issuing varying numbers of IOs.

Reference

Spec: NVM Express Revision 1.4a

Steps

Clear pending interrupts before measuring latency
Disable controller and per-vector coalescing to force immediate interrupts
Issue a few IOs to capture the immediate interrupt latency
Continually issue IO bursts to confirm latency stays low without aggregation
Ensure latency remains below the aggregation threshold when coalescing is disabled
Enable coalescing and configure aggregation time and threshold
Issue bursts below the threshold to observe time-based aggregation
Warn if latency does not show aggregation when threshold is not met
Issue bursts that meet the threshold to confirm aggregation occurs
Assert aggregated latency remains within the expected bounds

function: scripts/conformance/05_controller/interrupt_test.py::test_interrupt_ioworker_qpair

Observe interrupt behavior while an ioworker exercises a queue pair.

Reference

Spec: NVM Express Revision 1.4a

Steps

Create a queue pair with interrupts enabled or disabled per parameter
Start an ioworker that continuously issues reads on the queue pair
Repeatedly sample the interrupt status while the worker is running
Delete the queue pair after the worker completes

file: scripts/conformance/05_controller/prp_test

function: scripts/conformance/05_controller/prp_test.py::test_prp_format

Ensure the namespace is formatted before executing subsequent PRP tests.

Reference

NVM Express Revision 1.4a.

Steps

Issue a namespace format to guarantee a clean state for follow-on tests

function: scripts/conformance/05_controller/prp_test.py::test_prp_write_mdts

Validate PRP write handling across varying data lengths around MDTS limits.

Reference

NVM Express Revision 1.4a.

Steps

Gather the controller-reported minimum memory page size for later comparison
Retrieve the advertised Maximum Data Transfer Size so we can detect boundary behavior
Create a temporary IO queue pair dedicated to this data length sweep
Build a PRP list chain large enough to describe the requested transfer length
Iterate through the required page count and link additional PRP lists as needed
Submit the write command sized to the target NLBA value
Verify the completion entry reflects either success or MDTS violation as expected
Tear down the temporary IO queue pair created for this test

function: scripts/conformance/05_controller/prp_test.py::test_prp_page_offset

Read data using PRPs with different offsets and confirm the correct LBA data is returned.

Reference

NVM Express Revision 1.4a.

Steps

Program a known data pattern to the target namespace for later verification
Read the data with varying offsets distributed across two memory pages
Verify each resulting buffer still begins with the known signature

function: scripts/conformance/05_controller/prp_test.py::test_prp_admin_page_offset

Issue Identify commands using PRP buffers aligned at different valid offsets.

Reference

NVM Express Revision 1.4a.

Steps

Prepare an Identify buffer that starts at the requested valid offset
Issue the Identify command using the offset buffer
Confirm the controller returned valid identify data

function: scripts/conformance/05_controller/prp_test.py::test_prp_admin_page_offset_invalid

Send Identify commands with misaligned PRP offsets and observe controller handling.

Reference

NVM Express Revision 1.4a.

Steps

Prepare an Identify buffer that intentionally violates dword alignment
Send an Identify command with the invalid offset while tracking completion status
Capture the completion status through a callback for later verification
Check identify data from offset 0 when no error was reported

function: scripts/conformance/05_controller/prp_test.py::test_prp_valid_offset_in_prplist

Issue a read command with valid PRP1 and PRP list offsets to confirm acceptance.

Reference

NVM Express Revision 1.4a.

Steps

Configure PRP1 with a non-zero offset to emulate partial-page buffers
Build the first PRP list segment with a non-zero offset and constrained size
Allocate a chained PRP list to cover the remaining regions
Fill the PRP list entries before linking to the chained list
Populate the chained PRP list entries that continue the transfer
Issue a read command that consumes both PRP1 and the PRP list
Reap the command and wait for the CQ phase bit flip

function: scripts/conformance/05_controller/prp_test.py::test_prp_invalid_offset_in_prplist

Fill PRP list entries with invalid offsets and expect a PRP Offset Invalid status.

Reference

NVM Express Revision 1.4a.

Steps

Configure PRP1 with a non-zero offset to exercise validation logic
Create a PRP list whose base also starts at a non-zero offset
Fill each PRP entry with the same invalid offset to ensure the controller detects it
Submit the command that references the invalid PRP list
Wait for completion and expect the PRP Offset Invalid status

function: scripts/conformance/05_controller/prp_test.py::test_prp_invalid_buffer_offset

Issue an IO command with a PRP entry that has a non-zero offset and observe controller behavior.

Reference

NVM Express Revision 1.4a.

Steps

Prepare a write command that intentionally supplies a PRP entry with offset 1
Post the command to the submission queue and capture the resulting status
If no error is reported, read the LBA back to confirm the controller ignored the offset

function: scripts/conformance/05_controller/prp_test.py::test_prp_invalid_one_qpair

Inject invalid PRP commands through a single queue pair to verify error handling.

Reference

NVM Express Revision 1.4a.

Steps

Create a dedicated queue pair for the invalid PRP injections
Repeatedly inject commands with invalid PRPs until phase bits wrap
Tear down the temporary queue pair to release resources

function: scripts/conformance/05_controller/prp_test.py::test_prp_invalid_one_qpair_normal_command

Mix invalid and valid commands on one queue pair to confirm recovery after errors.

Reference

NVM Express Revision 1.4a.

Steps

Inject an invalid PRP command through the shared queue pair
Issue a normal write followed by a normal read to verify the queue still operates

function: scripts/conformance/05_controller/prp_test.py::test_prp_invalid_multi_qpair_normal_command

Exercise invalid and valid PRP commands across two queue pairs to check isolation.

Reference

NVM Express Revision 1.4a.

Steps

Create a second queue pair for concurrent validation
Inject invalid PRP commands into both queue pairs
Issue normal write and read commands on both queue pairs to confirm recovery
Delete the additional queue pair that was allocated for this test

function: scripts/conformance/05_controller/prp_test.py::test_prp_multi_invalid_and_multi_normal_command

Stress one queue pair with many invalid and valid commands to ensure stable completion handling.

Reference

NVM Express Revision 1.4a.

Steps

Provision an IO queue pair sized to the controller capabilities
Initialize the starting command identifier and completion phase bit
Loop over the requested amount of invalid PRP commands
Follow up with the requested amount of valid write commands
Tear down the queue pair after completing the stress mix

function: scripts/conformance/05_controller/prp_test.py::test_prp_invalid_before_ioworker

Submit an invalid PRP command before launching ioworker traffic to verify stability.

Reference

NVM Express Revision 1.4a.

Steps

Inject an invalid PRP command through the shared queue pair before background IO
Run an IO worker workload after the invalid command is injected

function: scripts/conformance/05_controller/prp_test.py::test_prp_invalid_multiple

Repeat invalid PRP injections many times to confirm consistent error responses.

Reference

NVM Express Revision 1.4a.

Steps

Iterate over many cycles to repeatedly exercise the invalid PRP path

function: scripts/conformance/05_controller/prp_test.py::test_prp_invalid_with_ioworker

Inject invalid PRP commands while an IO worker issues background traffic.

Reference

NVM Express Revision 1.4a.

Steps

Run an IO worker workload while continuously injecting invalid PRP commands

function: scripts/conformance/05_controller/prp_test.py::test_prp_invalid_offset_create_sq

Attempt to create IO submission queues with invalid PRP offsets and expect failures.

Reference

NVM Express Revision 1.4a.

Steps

Provision a valid completion queue that future SQs can target
Create a submission queue using a properly aligned PRP pointer as a baseline
Exercise invalid PRP offsets when creating submission queues and expect failures
Attempt to create a queue with PRP offset 2048 and expect PRP Offset Invalid
Attempt the same sequence with a slightly different misalignment
Cover the extreme case where the pointer is almost at the end of the page
Try another sub-page offset to ensure all cases are rejected

function: scripts/conformance/05_controller/prp_test.py::test_prp_page_offset_invalid

Read using buffers that have invalid offsets and expect either errors or ignored offsets.

Reference

NVM Express Revision 1.4a.

Steps

Program the namespace with a recognizable pattern at the target LBA
Prepare a read buffer whose offset varies across the invalid values
Capture the completion status through a callback to detect PRP offset errors
Check whether we receive the expected error or the data with ignored offset

function: scripts/conformance/05_controller/prp_test.py::test_prp_identify_prp2

Issue Identify commands with PRP2 that is not contiguous with PRP1 and verify data stitching.

Reference

NVM Express Revision 1.4a.

Steps

Issue a baseline Identify command with a contiguous buffer
Issue another Identify command that spans PRP1 and PRP2
Check data returned by the two Identify commands to ensure it aligns correctly
Dump the last commands for debug context if verification fails later

file: scripts/conformance/05_controller/sgl_test

function: scripts/conformance/05_controller/sgl_test.py::test_sgl_format

Formats the namespace to confirm the controller accepts SGL-capable format commands.

Reference

Reference: NVM Express Revision 1.4a

Steps

Issue a namespace format with a 4 KiB data size

function: scripts/conformance/05_controller/sgl_test.py::test_sgl_buffer

Exercises buffer backed SGL reads and writes while toggling offsets and descriptor usage.

Reference

Reference: NVM Express Revision 1.4a

Steps

Ensure the verification helper is available before running IO checks
Write baseline data then read it back to confirm normal PRP operations
Disable SGL usage to validate PRP fallback
Re-enable SGL and ensure basic reads still succeed
Read within a single sector window by adjusting the buffer offset and size
Consume two sectors using a larger offset span
Reset offsets and capture the buffer contents for debugging

function: scripts/conformance/05_controller/sgl_test.py::test_sgl_ioworker

Runs IO workers with varying SGL usage ratios to ensure both PRP and SGL paths succeed.

Reference

Reference: NVM Express Revision 1.4a

Steps

Reformat the namespace to place metadata in a known state
Run an IO worker that uses only PRP transfers
Run an IO worker that uses SGL transfers exclusively
Mix PRP and SGL transactions in a longer run

function: scripts/conformance/05_controller/sgl_test.py::test_sgl_send_cmd_and_waitdone

Submits manual SGL read commands and validates completions when mixing PRP and SGL descriptors.

Reference

Reference: NVM Express Revision 1.4a

Steps

Establish IO submission/completion queues for explicit command posting
Define completion callbacks that check phase tags and status fields
Issue short SGL reads to verify normal completions
Send additional commands to exercise invalid CID handling and PRP fallback
Confirm the queue pointers advanced as expected
Tear down the test submission and completion queues

function: scripts/conformance/05_controller/sgl_test.py::test_sgl_send_cmd_size_offset

Validates SGL descriptors honor explicit sizes and offsets across varying read lengths.

Reference

Reference: NVM Express Revision 1.4a

Steps

Create IO queues for directly issued read commands
Define a callback that ensures completions return success
Submit a default SGL read using a descriptor sized to one sector
Move the SGL window by one sector and read again
Expand the descriptor to cover two logical blocks starting mid-buffer
Ring the submission queue doorbell and wait for completions
Release the temporary queues

function: scripts/conformance/05_controller/sgl_test.py::test_sgl_offset_in_segment

Builds nested SGL segments to confirm offset handling inside a last segment descriptor.

Reference

Reference: NVM Express Revision 1.4a

Steps

Allocate the top-level last segment descriptor used for chaining entries
Configure the first data block so it trims to a single sector
Configure a second data block that contributes zero bytes
Keep a final data block with default offsets to complete the segment
Populate the segment entries with the prepared data blocks

function: scripts/conformance/05_controller/sgl_test.py::test_sgl_send_cmd_and_waitdone_read_segment_example

Scopes a multi-level SGL segment during read/write IO and verifies each section of data.

Reference

Reference: NVM Express Revision 1.4a

Steps

Prepare the namespace with known data before issuing segmented reads
Write random data to LBA 100-125 for later comparisons
Set up dedicated IO queues for manually posted read/write commands
Enforce successful completions for each segmented transfer
Build nested segments that mix data, bit-bucket, and last segment entries
Submit the segmented read and wait for completion
Check segmented buffers and the zero-filled hole
Reuse the same segment topology for a write command
Remove the temporary IO queues

function: scripts/conformance/05_controller/sgl_test.py::test_sgl_send_cmd_and_waitdone_read_segment_error

Attempts a recursive SGL segment submission to validate controller error handling.

Reference

Reference: NVM Express Revision 1.4a

Steps

Create IO queues that will host the invalid segmented command
Callback expects an error status signaled via the completion queue
Build a malformed segment list that references itself
Issue the read expected to fail and wait for completion
Clean up the queues after capturing the error

function: scripts/conformance/05_controller/sgl_test.py::test_sgl_invalid_phys_addr

Submits descriptors with bogus physical addresses to confirm hardware detects the faults.

Reference

Reference: NVM Express Revision 1.4a

Steps

Open IO queues to host commands that point to invalid addresses
Capture completion statuses for the invalid address tests
Submit reads using SGL and PRP descriptors with fake physical addresses
Ring the queue doorbells and drain all completions
Delete the queues to finish the test

function: scripts/conformance/05_controller/sgl_test.py::test_sgl_invalid_address_and_length

Combines invalid length and address values to ensure the controller rejects malformed SGLs.

Reference

Reference: NVM Express Revision 1.4a

Steps

Initialize IO queues for submitting intentionally invalid descriptors
Build and submit a descriptor with the requested invalid tuple
Wait for the command log to capture the failing write
Dump the merged command log entries for inspection
Release the queues before exiting the test

function: scripts/conformance/05_controller/sgl_test.py::test_sgl_invalid_type

Sweeps through reserved SGL descriptor types to verify proper error reporting.

Reference

Reference: NVM Express Revision 1.4a

Steps

Allocate queues used to host writes with unsupported SGL descriptor types
Show how the controller reported the invalid type request
Destroy the queues after the invalid type sweep

function: scripts/conformance/05_controller/sgl_test.py::test_sgl_last_segment_unaligned_size

Verifies that Last Segment descriptors enforce 16-byte alignment by varying lengths.

Reference

Reference: NVM Express Revision 1.4a

Steps

Build a last segment descriptor that intentionally violates the size requirement
Configure the first data block for a one-sector transfer
Configure the second data block to contribute zero length
Keep a standard data block as the final entry
Load the segment vector and log it for debugging
Create queues and post a write using the malformed segment
Dump the command log for the failing transfer
Delete the queues at the end of the iteration

function: scripts/conformance/05_controller/sgl_test.py::test_sgl_invalid_subtype

Sweeps SGL subtype combinations to ensure the controller flags invalid encodings.

Reference

Reference: NVM Express Revision 1.4a

Steps

Allocate queues shared by the subtype iterations
Capture the controller response for each unsupported subtype
Clean up queues at the end of the sweep

function: scripts/conformance/05_controller/sgl_test.py::test_sgl_all_zero

Checks controller behavior when the SGL descriptor and size fields are all zeros.

Reference

Reference: NVM Express Revision 1.4a

Steps

Allocate queues for issuing the zeroed descriptor command
Submit a write whose descriptor and size are forced to zero
Print the resulting command log for debugging
Remove the queues after collecting the log

function: scripts/conformance/05_controller/sgl_test.py::test_trim_with_sgl

Triggers a Dataset Management trim using SGL metadata and checks the affected data blocks.

Reference

Reference: NVM Express Revision 1.4a

Steps

Prepare data buffers and IO queue resources
Send write and read commands to populate reference data
Wait for the commands to finish and verify data integrity
Trim LBA 0 using an SGL descriptor in meta mode
Check data after issuing the trim

file: scripts/conformance/05_controller/sq_cq_test

function: scripts/conformance/05_controller/sq_cq_test.py::test_sq_cq_around

Validate that a three-entry CQ wraps correctly by issuing four commands and observing phase behavior.

Reference

NVM Express Revision 1.4a, Data Structures.

Steps

Create a CQ with three entries and an SQ with five entries mapped to that CQ
Issue three SQEs with descending CIDs to approach the wrap condition
Allow the controller to post the completions
Verify the first CQE reports CID 4
Verify the second CQE reports CID 3
Confirm the third CQE is still empty before wraparound
Advance the CQ head to consume the first entry
Verify the first CQE is still CID 4 after re-reading with old phase
Confirm the third CQE now reports CID 2 as the queue wraps
Issue a fourth SQE to force the phase bit toggle
Move the CQ head further to toggle the phase bit
Confirm CQ entry 3 keeps CID 2 with the proper phase
Confirm CQ entry 2 keeps CID 3 with the proper phase
Ensure the wrapped CQ entry now reports CID 1

function: scripts/conformance/05_controller/sq_cq_test.py::test_sq_overflow

Check that a two-entry SQ wraps safely by issuing two commands and validating CQ contents.

Reference

NVM Express Revision 1.4a, Data Structures.

Steps

Create a CQ with five entries and an SQ with two entries bound to the CQ
Issue the first SQE with CID 4 and ring the tail doorbell
Issue the second SQE with CID 3 and wrap the tail pointer
Verify the first CQE reports CID 4
Verify the second CQE reports CID 3
Confirm no other CQEs become valid after wraparound

function: scripts/conformance/05_controller/sq_cq_test.py::test_sq_delete_after_cq

Ensure the controller rejects deleting an IO CQ while an associated SQ still exists.

Reference

NVM Express Revision 1.4a, Section 5.4.

Steps

Create a linked IO CQ/SQ pair
Attempt to delete the CQ first and expect Invalid Queue Deletion

function: scripts/conformance/05_controller/sq_cq_test.py::test_sq_doorbell

Validate that writing an SQ tail doorbell without SQEs leaves the CQ idle.

Reference

NVM Express Revision 1.4a, Data Structures.

Steps

Create a linked IO CQ/SQ pair
Ring the SQ tail doorbell and ensure the controller accepts it

function: scripts/conformance/05_controller/sq_cq_test.py::test_sq_admin_smaller_cq

Verify that an oversized admin SQ paired with a smaller CQ still produces coherent completions.

Reference

NVM Express Revision 1.4a, Data Structures.

Steps

Helper to write SQEs into the admin SQ buffer
Disable the controller before programming admin queue registers
Program the admin queue registers with SQ size 100 and CQ size 10
Re-enable the controller so the new queue settings take effect
Build an Identify Namespace admin command template
Issue a series of commands that use distinct CIDs to stress the small CQ
Inspect the CQ buffer before any manual doorbell moves
Advance the CQ doorbell once and recheck completion data
Advance the CQ doorbell again and verify the entries remain consistent
Advance the CQ doorbell twice to force a phase change and inspect the CQ

function: scripts/conformance/05_controller/sq_cq_test.py::test_sq_admin_invalid_doorbell

Verify an invalid admin SQ doorbell write triggers the expected asynchronous error.

Reference

NVM Express Revision 1.4a, Figure 146.

Steps

Program an invalid admin SQ tail value and wait for the associated AER

function: scripts/conformance/05_controller/sq_cq_test.py::test_sq_doorbell_invalid

Confirm an invalid IO SQ doorbell value raises the Invalid Doorbell asynchronous event.

Reference

NVM Express Revision 1.4a, Figure 146.

Steps

Clear existing asynchronous event records
Create a paired IO CQ/SQ for the test
Program an invalid SQ tail doorbell value and expect an AER

function: scripts/conformance/05_controller/sq_cq_test.py::test_sq_cq_another_sq

Validate two IO SQs can target the same CQ without corrupting completion order.

Reference

NVM Express Revision 1.4a, Submission Queue Entry Format.

Steps

Create a CQ and the first SQ, each with three entries
Post commands with CID 4 and 3 to the first SQ
Ring the SQ doorbell twice to submit both commands
Create the second IO SQ that also targets the same CQ
Post a command with CID 2 on the second SQ and ring its doorbell
Verify the first CQE reports CID 4
Verify the second CQE reports CID 3
Confirm the third CQE is still empty
Advance the CQ head to release the first entry
Ensure the third CQE now reports CID 2 coming from SQ2
Confirm the first CQE still shows CID 4 with the old phase
Post a command with CID 1 using SQ2 and ring its doorbell
Advance the CQ head again to consume two entries
Verify the CQ wraps and now reports CID 1 at entry 0

function: scripts/conformance/05_controller/sq_cq_test.py::test_sq_create_invalid_cqid

Ensure Create IO SQ fails gracefully when referencing invalid CQIDs from the spec-defined categories.

Reference

NVM Express Revision 1.4a, Section 5.3.

Steps

Query ncqa through Get Features to know the supported CQ range
Create a CQ with CQID 1 for later references
Create a valid SQ bound to the CQ above as control
Expect SQ creation to fail when targeting CQID 0 (the admin CQ)
Expect failure if CQID 0xffff is used
Expect failure when CQID exceeds the supported ncqa range by one
Expect failure when CQID exceeds the supported range by a large offset
Expect failure when CQIDs 2 or 4 do not correspond to created CQs
Delete the valid SQ and CQ used for baseline coverage

function: scripts/conformance/05_controller/sq_cq_test.py::test_sq_read_write_burst

Burst IO submissions to ensure the CQ handles near-full conditions without overflowing.

Reference

NVM Express Revision 1.4a, Section 5.3.

Steps

Create paired IO CQ/SQ buffers sized near the queue limit
Define a helper that seeds SQEs with unique PRPs and CIDs
Post 127 write SQEs that use their LBA as data and ring the doorbell once
Wait for all but the last completion and advance the head
Submit one additional write to verify wraparound behavior
Confirm no CQ overflow occurs after consuming the entries
Tear down the write queues
Create fresh CQ/SQ pairs to repeat the burst with reads
Post 127 read SQEs that check the written LBAs
Wait for all read completions to be posted
Validate each buffer contains the expected pattern (cid == data)
Delete the read queues after validation

function: scripts/conformance/05_controller/sq_cq_test.py::test_cq_doorbell_valid

Confirm a standalone CQ can be created and deleted without an associated SQ.

Reference

NVM Express Revision 1.4a, Section 5.3.

Steps

Create the CQ only and wait briefly for it to become ready
Delete the CQ cleanly without touching any SQ

function: scripts/conformance/05_controller/sq_cq_test.py::test_cq_create_physically_contiguous

Ensure controllers requiring physically contiguous CQs reject queues created without PC set.

Reference

NVM Express Revision 1.4a, Section 5.3.

Steps

Check CAP.CQR and skip the test if PC enforcement is not required
Create an IO CQ with the PC flag to prove the valid path succeeds
Attempt to create the CQ without PC and expect the controller to reject it

function: scripts/conformance/05_controller/sq_cq_test.py::test_cq_sq_diff_id

Confirm SQs may be paired to a CQ even when their queue identifiers differ.

Reference

NVM Express Revision 2.0.

Steps

Create an IO CQ using QID 1
Create an SQ parameterized by sqid that targets the CQ
Post a simple command and ring the SQ doorbell
Wait for the completion and verify it succeeded
Tear down the SQ and CQ

file: scripts/conformance/05_controller/sqe_cqe_test

function: scripts/conformance/05_controller/sqe_cqe_test.py::test_sqe_cqe_sqhd

Validate SQ head pointer reporting by reusing SQ entries and observing CQ updates.

Reference

NVM Express Revision 1.4a.

Steps

Create IOCQ depth 3 and IOSQ depth 2 to control the observed head/tail behavior.
Issue the first IO command and advance the SQ tail pointer.
Verify only the first CQ entry reports the SQHD, SQID, and phase bit update.
Issue the second IO command and roll the SQ tail.
Confirm the second CQ entry reports the new command while the third remains untouched.
Issue the third IO command without advancing CQ head.
Ensure the last CQ entry does not update while the CQ head is unchanged.
Move the CQ head to release an entry and allow the pending completion to post.
Submit another command and release an additional CQ entry.
Confirm the next round of CQ entries advances SQHD and toggles the phase bit.
Delete the queues to clean up the environment.

function: scripts/conformance/05_controller/sqe_cqe_test.py::test_sqe_cqe_p_tag_invert_after_cq_full

Confirm phase tag inversion when the CQ wraps by repeatedly filling and draining a small queue pair.

Reference

NVM Express Revision 1.4a.

Steps

Create IOCQ depth 2 and IOSQ depth 10 to force CQ wrap quickly.
Build and post the first write command.
Post the second write command and advance the tail.
Verify the first completion reports the expected identifiers and SQ head.
Verify the second completion reports the expected identifiers and SQ head.
Confirm both CQ entries still report a phase of 1 before wrap.
Post the third write command to trigger wrap conditions.
Post the fourth write command.
Ensure the third completion reports the expected metadata with inverted phase.
Confirm the fourth completion appears after freeing a CQ slot.
Confirm both CQ entries now report the cleared phase bit.
Delete the queue pair used for the wraparound test.

function: scripts/conformance/05_controller/sqe_cqe_test.py::test_sqe_cqe_discontinuous_cid

Verify completion handling by submitting commands with discontinuous CIDs.

Reference

NVM Express Revision 1.4a.

Steps

Create IOCQ and IOSQ with three entries to observe CID order.
Issue commands using non-sequential CIDs and advance the tail.
Verify CQ entries return the discontinuous CIDs as submitted.
Delete the queues once CID handling is verified.

function: scripts/conformance/05_controller/sqe_cqe_test.py::test_sqe_cqe_max_cid

Exercise completion reporting by issuing commands that use minimum and maximum allowed CIDs.

Reference

NVM Express Revision 1.4a.

Steps

Determine the valid CID range for the detected controller.
Create IOCQ and IOSQ with three entries to capture the completions.
Submit commands using maximum and zero CIDs.
Ensure the CQ reports the CIDs without modification.
Delete the queues to conclude the CID range test.

function: scripts/conformance/05_controller/sqe_cqe_test.py::test_sqe_cqe_cid_conflict

Verify controller behavior by submitting duplicate CIDs simultaneously.

Reference

NVM Express Revision 1.4a.

Steps

Create IOCQ and IOSQ with twenty entries to host large transfers.
Prepare the PRP buffer chain sized to the controller MDTS limit.
Post identical commands with the same CID into the queue.
Wait for completions and ensure status indicates success or CID conflict.
Delete the queues once duplicate CID handling is verified.

function: scripts/conformance/05_controller/sqe_cqe_test.py::test_sqe_cqe_reserved

Check controller handling by issuing commands whose reserved SQE fields are non-zero.

Reference

NVM Express Revision 1.4a.

Steps

Create IOCQ and IOSQ supporting three entries for the reserved field check.
Issue a command with a non-zero reserved field.
Verify the controller completes successfully despite the reserved bits.
Delete the queues after the reserved field validation.

function: scripts/conformance/05_controller/sqe_cqe_test.py::test_sqe_cqe_fuse_is_zero

Verify the controller accepts commands by issuing IOs with the FUSE field cleared.

Reference

NVM Express Revision 1.4a.

Steps

Create IOCQ and IOSQ with three entries dedicated to fuse validation.
Issue a command with the fuse bits cleared.
Confirm successful completion status for the zero fuse field.
Delete the queues after verifying fuse handling.

function: scripts/conformance/05_controller/sqe_cqe_test.py::test_sqe_cqe_opc_invalid_admin_cmd

Validate that invalid admin opcodes are rejected by issuing admin commands with unsupported opcodes.

Reference

NVM Express Revision 1.4a.

Steps

Send the invalid admin command and expect an error completion.

function: scripts/conformance/05_controller/sqe_cqe_test.py::test_sqe_cqe_opc_invalid_nvm_cmd

Confirm the controller flags invalid NVM command opcodes by sending IOSQ entries with unsupported opcodes.

Reference

NVM Express Revision 1.4a.

Steps

Create IOCQ and IOSQ with three entries to capture the invalid opcode response.
Issue a command using the invalid opcode under test.
Check that the status field indicates Invalid Command Opcode.
Delete the queues after capturing the invalid opcode completion.

function: scripts/conformance/05_controller/sqe_cqe_test.py::test_sqe_cqe_ns_invalid

Verify invalid namespace identifiers are rejected by targeting unsupported namespace IDs.

Reference

NVM Express Revision 1.4a.

Steps

Create IOCQ and IOSQ with three entries to record the namespace failures.
Issue a command against an invalid namespace value.
Confirm the completion status reports Invalid Namespace or Format.
Delete the queues once the invalid namespace handling is validated.

function: scripts/conformance/05_controller/sqe_cqe_test.py::test_sqe_cqe_ns_broadcast

Ensure broadcast namespace ID handling matches expectations by issuing IOs to NSID 0xffffffff.

Reference

NVM Express Revision 1.4a.

Steps

Create IOCQ and IOSQ with three entries to monitor broadcast namespace behavior.
Issue a command targeting the broadcast namespace identifier.
Confirm status indicates Invalid Namespace or Format or Namespace Not Ready.
Delete the queues once the broadcast namespace behavior is confirmed.

folder: scripts/conformance/06_tcg

file: scripts/conformance/06_tcg/01_use_case_test

function: scripts/conformance/06_tcg/01_use_case_test.py::test_uct01_level0_discovery

Verify Level 0 Discovery by power cycling the controller and issuing discovery commands.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Power cycle the subsystem to force the TCG stack into a known state
Issue the Level 0 Discovery command and verify the COMID count
check Number of ComIDs >= 1
Log the Level 0 discovery feature list for traceability
Validate Admin4 authority access when supported

function: scripts/conformance/06_tcg/01_use_case_test.py::test_uct02_properties

Validate Properties negotiation using defined host limits and confirming device acceptance.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Send the Properties command with the mandated host limits
Read the Properties response to confirm each reported value

function: scripts/conformance/06_tcg/01_use_case_test.py::test_uct03_take_ownership

Take ownership by retrieving the MSID PIN, replacing the SID credential, and validating revert-to-default.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Start an Admin SP session as Anybody to read the MSID PIN
Retrieve MSID PIN from the C_PIN table
Close the Anybody session
Start an Admin SP session authenticated as SID using the MSID PIN
Program the new SID password to complete ownership
Close the SID-authenticated session
Start an Admin SP session with the newly set SID password
Issue RevertTPer to confirm the credential operates correctly

function: scripts/conformance/06_tcg/01_use_case_test.py::test_uct04_activate_locking_sp

Activate the Locking SP from Manufactured-Inactive by setting SID and issuing Activate.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Start an Admin SP Anybody session and fetch the MSID PIN
Replace the SID credential using the retrieved MSID PIN
Authenticate as SID and issue Activate on the Locking SP object
CLOSE_SESSION
Start a Locking SP Admin1 session to verify the lifecycle state
Close the locksp session after verification

function: scripts/conformance/06_tcg/01_use_case_test.py::test_uct05_configuring_authorities

Configure required authorities by enabling admins and users and validating session logon.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Query the Level 0 discovery data to determine the LAST_REQUIRED_USER value
Start a Locking SP Admin1 session to configure account access
Enable User1 and provision a password for it
Enable Admin4 if Opal 2.0 capabilities are advertised
Enable User1 in the Locking SP and set its password
Enable the LAST_REQUIRED_USER authority and set its password
Close the Locking SP admin session after provisioning users
Open a Locking SP Admin1 session using the newly provisioned credentials
Close the session after confirming access
Open a Locking SP Admin4 session to validate optional administrator access
Close the Admin4 validation session
Authenticate as User1 on the Locking SP to confirm user access
Close the User1 session to end the test
Start a Locking SP session as the LAST_REQUIRED_USER to verify final authority
Close the LAST_REQUIRED_USER session cleanly

function: scripts/conformance/06_tcg/01_use_case_test.py::test_uct06_configuring_locking_objects

Configure locking ranges by programming range metadata and verifying host access.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Read Level 0 discovery data to obtain the LAST_REQUIRED_RANGE identifier
Start a Locking SP Admin1 session to configure locking range attributes
Program the LAST_REQUIRED_RANGE boundaries and initial access state
Close the configuration session to persist the locking metadata
Write data through the namespace and verify it can be read back

function: scripts/conformance/06_tcg/01_use_case_test.py::test_uct06_configuring_locking_objects_powercycle

Verify locking range configuration across a power cycle by attempting I/O afterward.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Determine the LAST_REQUIRED_RANGE identifier from Level 0 discovery
Open a Locking SP Admin1 session to set up the range prior to power cycling
Configure the range boundaries and lock both read and write access
Close the configuration session to persist the range state
Power cycle the subsystem and reset the controller
Attempt read and write I/O and expect Data Protection errors

function: scripts/conformance/06_tcg/01_use_case_test.py::test_uct07_unlocking_range

Verify that a configured locking range can be unlocked for a user through the defined methods.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Start a Locking SP Admin1 session and provision User1 credentials
Query LAST_REQUIRED_RANGE and size it for the test
Configure the locking range boundaries for the unlock test
Close the admin session to proceed with range controls
Start another Locking SP Admin1 session to configure lock state
Grant User1 read and write access to the configured range
Close the admin session after assigning user permissions
Start a User1 session to request unlocking of the assigned range
Clear the ReadLocked and WriteLocked bits within the range
Close the user session cleanly before issuing I/O
Issue write and read traffic to validate the unlocked range

function: scripts/conformance/06_tcg/01_use_case_test.py::test_uct08_erasing_range

Validate range erasure by deriving a new key and verifying data is destroyed.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Skip the test on Pyrite devices that do not support erasing ranges
Identify the LAST_REQUIRED_RANGE to target for the erase procedure
Read the AlignmentGranularity so the range sizing honors controller constraints
Establish the locking range boundaries using the calculated size
Write a known pattern and unlock the range before erasure
Verify the pattern prior to erasing the range
Start a session to derive a new wrapping key for the range
Read the range to confirm the data no longer matches the original pattern

function: scripts/conformance/06_tcg/01_use_case_test.py::test_uct09_using_datastore

Validate DataStore table read/write permissions via Admin and User sessions.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Enable User1 and program its password through a Locking SP admin session
Start a Locking SP Admin1 session to grant DataStore privileges
Allow User1 to perform DataStore Set operations
Allow User1 to perform DataStore Get operations
Close the admin session so the user can consume the privileges
Start a User1 session to write data into the DataStore
Write the magic pattern into the DataStore table
Close the session after writing
Start another User1 session to read back the stored data
Read and verify the DataStore payload matches what was written

function: scripts/conformance/06_tcg/01_use_case_test.py::test_uct10_enable_mbr_shadow

Exercise the MBR shadowing enable-to-done workflow and confirm locking range visibility.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Skip devices that lack Opal 2.0 because MBR shadowing is not supported there
Invoke Properties method
read AlignmentGranularity
start locking sp admin1 session
Invoke the Set method on the BooleanExpr column of the ACE_MBRCONTROL_SET_DONE ACE object to include the UIDs of the User1 and LAST_REQUIRED_USER Authority objects
invoke Get method on the Rows column of the MBR Table Descriptor Object
Determine the namespace geometry to size the MBR range correctly
invoke the Set method to change the RangeLength column of the LAST_REQUIRED_RANGE to SIZE_OF_MBR_TABLE_DESCRIPTOR_IN_LOGICAL_BLOCKS + 10 LBAs
write 1s over the entire LAST_REQUIRED_RANGE
call Get method on the MBR object in the Table table to retrieve the MandatoryWriteGranularity column value
invoke Set method to write the MBR table with the MAGIC_PATTERN
Write any remaining tail bytes that do not fill an entire chunk
invoke Set method on the Enable column of the MBRControl table with a value of TRUE
close session
powercycle
write the MAGIC_PATTERN over the entire LAST_REQUIRED_RANGE
read from LBA 0 to the size of the MBR Table
Read the trailing portion beyond the MBR table and confirm it remains erased
test_uct11_mbr_done
read LAST_REQUIRED_USER
enable user1 and set passwd for it
enable last_required_user and set passwd for it
Grant the LAST_REQUIRED_USER authority read and write access to the range
close session
Start a LAST_REQUIRED_USER session to clear the lock bits and set MBR done
Call the Set method on the ReadLocked and WriteLocked columns of the LAST_REQUIRED_RANGE Locking object with a value of FALSE
Set the MBRDone flag to release the range to hosts
close session
read the entire LAST_REQUIRED_RANGE
Read the remaining portion and compare it to the expected filler pattern

function: scripts/conformance/06_tcg/01_use_case_test.py::test_uct12_revert_locking_sp

Validate Locking SP revert in Manufactured state and confirm access behavior afterward.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Write a known pattern over 64 logical blocks at LBA 0
Call StartSession method with SPID = Admin SP UID
Call Revert method on Locking SP object
Call StartSession method with SPID = Locking SP
For Pyrite 1.00, do nothing for this step

function: scripts/conformance/06_tcg/01_use_case_test.py::test_uct13_revert_admin_sp_lockingsp_inactive

Revert the Admin SP while the Locking SP remains ManufacturedInactive and ensure SID handling.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Determine which SSC feature the DUT advertises
take ownership
Replace the SID credential to prepare for the revert operation
write data over 64 logical blocks beginning at LBA 0
Call StartSession method with SPID = Admin SP UID
Call Revert method on Admin SP object
read Behavior of C_PIN_SID Pin upon TPer Revert value in level0 discovery
Reprogram the SID credential if the revert reset it
start session with SID
Call StartSession method with SPID = Locking SP
Read 64 logical blocks beginning at LBA 0

function: scripts/conformance/06_tcg/01_use_case_test.py::test_uct14_revert_admin_sp_locking_sp_active

Revert the Admin SP while Locking SP is active and confirm SID recovery behavior.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Determine the supported SSC feature set
Start an Anybody Admin SP session to capture the MSID PIN
Call StartSession method with SPID = Admin SP UID
Call Get method on UID 00 00 00 06 00 00 02 02 to determine support
close session
write data over 64 logical blocks beginning at LBA 0
Call StartSession method with SPID = Admin SP UID D and HostSigningAuthority = SID authority UID
Call Revert method on Admin SP object
read Behavior of C_PIN_SID Pin upon TPer Revert value in level0 discovery
start session with SID
Call StartSession method with SPID = Locking SP
For Pyrite 1.00, do nothing for this step

function: scripts/conformance/06_tcg/01_use_case_test.py::test_uct15_revert_admin_sp_locking_sp_active

Revert the Admin SP using Admin1 credentials while the Locking SP is in Manufactured state.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Determine the supported SSC capability before executing Admin1 flows
check whether admin1 is supported
Enable admin1
write data over 64 logical blocks beginning at LBA 0
Call StartSession method with SPID = Admin SP UID and HostSigningAuthority = Admin1 authority
Call Revert method on Admin SP object
read Behavior of C_PIN_SID Pin upon TPer Revert value in level0 discovery
start session with SID
Call StartSession method with SPID = Locking SP
For Pyrite 1.00, do nothing for this step

function: scripts/conformance/06_tcg/01_use_case_test.py::test_uct16_psid_revert

Perform a PSID revert to return the device to factory defaults.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Provide the correct PSID credential for the device under test
Power cycle the device to ensure the PSID path is available
Start a PSID session and issue RevertTPer to factory reset the device

file: scripts/conformance/06_tcg/02_specific_functionality_test

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_spf01_transaction

Exercise SPF-01 transaction flow by issuing sequential sessions that wrap writes in start and end transaction tokens and verifying datastore persistence.

Reference

TCG Storage Opal Family Test Cases Specification Revision 1.00

Steps

start locking sp admin1 session
write zero to datastore table
close session
start a new session to test transactional write sequencing
send a subpacket that contains a startTransaction token with a status code of 0x00
write magic_pattern to datastore table
send a subpacket that contains an end transaction token with a status code of 0x00
open a verification session to read back committed data
read data from datastore table and check it
start locking sp admin1 session to clear the data under transaction
send a subpacket that contains a startTransaction token with a status code of 0x00
write zero to datastore table
open the final session to confirm the erase operation succeeded
read data from datastore table and check it

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_spf02_if_recv_behavior_tests_case1

Verify IF-RECV case 1 by issuing IF-RECV and confirming the ComPacket header indicates no further data.

Reference

TCG Storage Opal Family Test Cases Specification Revision 1.00

Steps

Issue an IF-RECV command
check a ComPacket header value of “All Response(s) returned – no further data”

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_spf02_if_recv_behavior_tests_case2

Validate IF-RECV case 2 by forcing a large datastore read and observing segmented IF-RECV responses.

Reference

TCG Storage Opal Family Test Cases Specification Revision 1.00

Steps

start locking sp admin1 session
read data from datastore table
IF-Recv transfer length = 0x100
read the returned compacket header to determine outstanding data and minimum transfer
close the session before checking header fields
validate outstanding data and transfer length indicators

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_spf03_trylimit_case_sid

Exercise SPF-03 SID TryLimit by exhausting failed SID authentications, observing lockout, and validating recovery after a power cycle.

Reference

TCG Storage Opal Family Test Cases Specification Revision 1.00

Steps

Attempt SID login with an invalid PIN until TryLimit attempts are consumed when TryLimit > 0.
Skip the TryLimit exercise when the implementation exposes no limit.
Confirm SID authentication is locked out by expecting AUTHORITY_LOCKED_OUT when opening the Admin SP.
Power cycle the subsystem and reset the controller to clear the SID lockout.
Re-activate the locking SP lifecycle to restore the baseline after the power cycle.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_spf03_trylimit_case_admin1

Exercise SPF-03 Admin1 TryLimit by exhausting incorrect authentications and confirming lockout behavior.

Reference

TCG Storage Opal Family Test Cases Specification Revision 1.00

Steps

Attempt Admin1 login with an invalid PIN until the reported TryLimit is met.
Verify Admin1 authentication is locked out by expecting AUTHORITY_LOCKED_OUT.
Power cycle the subsystem and reset the controller for subsequent tests.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_spf03_trylimit_case_user1

Exercise SPF-03 User1 TryLimit by exhausting failed user authentications and confirming lockout.

Reference

TCG Storage Opal Family Test Cases Specification Revision 1.00

Steps

Attempt User1 login with an invalid PIN until the reported TryLimit is consumed.
Confirm User1 access is locked out by expecting AUTHORITY_LOCKED_OUT on session start.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_spf04_tryreset_case_sid

Validate SPF-04 SID tries reset by exhausting failed SID attempts and verifying the tries counter clears.

Reference

TCG Storage Opal Family Test Cases Specification Revision 1.00

Steps

Exhaust SID authentication attempts to reach TryLimit – 1 when the device advertises a TryLimit.
Skip the reset validation entirely when TryLimit support is absent.
Start an Admin SP session with SID authority to evaluate the tries counter.
Read the SID tries counter after exercising the TryLimit threshold.
Ensure the SID tries counter cleared to zero.
Close the SID session after verification.
Re-enable the locking SP lifecycle for the next test sequence.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_spf04_tryreset_case_admin1

Validate SPF-04 Admin1 tries reset by consuming TryLimit – 1 failures and confirming the counter clears.

Reference

TCG Storage Opal Family Test Cases Specification Revision 1.00

Steps

Drive Admin1 authentication failures until the tries counter reaches TryLimit – 1 when supported.
Start a locking SP session with Admin1 authority to inspect tries.
Read the Admin1 tries counter following the attempted resets.
Close the Admin1 session after verification.
Ensure the Admin1 tries counter cleared to zero.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_spf04_tryreset_case_user1

Validate SPF-04 User1 tries reset by driving failures and confirming the user counter clears.

Reference

TCG Storage Opal Family Test Cases Specification Revision 1.00

Steps

Drive User1 authentication failures until the tries counter reaches TryLimit – 1 when available.
Start a locking SP session with User1 authority to clear tries.
Close the User1 session after the reset.
Start a locking SP session with Admin1 authority to read the User1 tries counter.
Read the User1 tries counter to confirm it reset.
Close the Admin1 session after gathering the result.
Ensure the User1 tries counter cleared to zero.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_spf05_tries_reset_on_power_cycle_sid

Verify SPF-05 SID tries reset across a power cycle by exhausting failures, power cycling, and confirming the counter clears.

Reference

TCG Storage Opal Family Test Cases Specification Revision 1.00

Steps

Drive SID authentication failures through the reported TryLimit when supported; skip when no limit is published.
Verify SID remains locked out prior to the power cycle.
Power cycle the subsystem and reset the controller.
Start an Admin SP SID session after power cycle and read the TryLimit/Try counters.
Call Get method on SID’s C_PIN Object to retrieve the TryLimit Column’s value
Close the SID session after sampling the counters.
Ensure the SID tries counter cleared after the power cycle.
Re-activate the locking SP lifecycle for subsequent tests.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_spf05_tries_reset_on_power_cycle_admin1

Verify SPF-05 Admin1 tries reset across a power cycle by exhausting failures and confirming the counter clears afterward.

Reference

TCG Storage Opal Family Test Cases Specification Revision 1.00

Steps

Drive Admin1 authentication failures through the reported TryLimit when available; skip when unsupported.
Verify Admin1 is locked out before issuing the power cycle.
Power cycle the subsystem and reset the controller.
Open a locking SP Admin session to sample Admin1 TryLimit/Try counters.
Call Get method on Admin1’s C_PIN Object to retrieve the TryLimit Column’s value
Close the locking SP session and ensure the tries counter cleared.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_spf05_tries_reset_on_power_cycle_user1

Verify SPF-05 User1 tries reset across a power cycle by exhausting failures and confirming the counter clears afterward.

Reference

TCG Storage Opal Family Test Cases Specification Revision 1.00

Steps

Drive User1 authentication failures through the reported TryLimit when available; skip when unsupported.
power cycle
Call Get method on User1’s C_PIN Object to retrieve the TryLimit Column’s value
Close the locking SP session and ensure the User1 tries counter cleared.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_spf06_next_case1

Validate SPF-06 Next command Case 1 by iterating locking table entries and confirming returned UID ordering.

Reference

TCG Storage Opal Family Test Cases Specification Revision 1.00

Steps

Skip the test when the controller does not advertise Opal capability.
Start a locking SP session with Admin1 authority.
Read the MaxRanges field from the LockingInfo table.
Issue Next without a WHERE filter to obtain the initial UID list.
Issue Next starting from the first UID to retrieve one subsequent entry.
Close the session after collecting the iteration data.
Ensure the number of returned UIDs equals MaxRanges + 1 (9 in this test vector).
Verify the UID prefix of each returned entry and confirm the second query overlaps the first list.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_spf06_next_case2

Validate SPF-06 Next command Case 2 by iterating Pyrite locking entries and confirming constraints.

Reference

TCG Storage Opal Family Test Cases Specification Revision 1.00

Steps

Skip the test when the controller does not advertise Pyrite capability.
Start a locking SP session with Admin1 authority.
Issue Next on the MethodID table without a WHERE filter to collect the initial UID list.
Issue Next starting from the first UID to retrieve a single subsequent entry.
Close the session after collecting the iteration data.
Ensure at least seven entries are reported by the first query.
Verify each returned UID has the expected prefix and the second query overlaps the first list.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_spf07_host_session_number

Verify SPF-07 host session number handling by forcing an arbitrary HSN and ensuring it persists across commands.

Reference

TCG Storage Opal Family Test Cases Specification Revision 1.00

Steps

Start an Admin SP session with an arbitrary host session number to confirm the controller echoes it.
Read the MSID PIN to ensure the host session number is preserved in the response header.
Close the Admin SP session.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_spf08_revert_sp_case1

Validate SPF-08 RevertSP Case 1 by writing a known pattern, issuing RevertSP without KeepData, and confirming access is blocked with data wiped.

Reference

TCG Storage Opal Family Test Cases Specification Revision 1.00

Steps

Write a known pattern across the first 64 logical blocks.
Start a Locking SP session with Admin1 authority to drive RevertSP.
Invoke RevertSP without KeepData so user data and keys are erased.
Attempt to reopen the Locking SP session and expect a TCG error.
For non-Pyrite controllers, verify the previously written pattern was removed.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_spf08_revert_sp_case2

Validate SPF-08 RevertSP Case 2 by running RevertSP with KeepData cleared and confirming data removal.

Reference

TCG Storage Opal Family Test Cases Specification Revision 1.00

Steps

Skip devices that only support Pyrite 1.00, which does not exercise this flow.
Write a known pattern across the first 64 logical blocks.
Start a Locking SP session with Admin1 authority to drive RevertSP.
Invoke RevertSP with KeepGlobalRangeKey/KeepData explicitly set to FALSE.
Attempt to reopen the Locking SP session and expect a TCG error.
Read back the first 64 logical blocks to confirm the pattern was erased.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_spf08_revert_sp_case3

Validate SPF-08 RevertSP Case 3 by running RevertSP with KeepData set and confirming user data persists.

Reference

TCG Storage Opal Family Test Cases Specification Revision 1.00

Steps

Skip devices that only support Pyrite 1.00, which does not exercise this flow.
Write a known pattern across the first 64 logical blocks.
Start a Locking SP session with Admin1 authority to drive RevertSP.
Invoke RevertSP with KeepGlobalRangeKey/KeepData set to TRUE.
Attempt to reopen the Locking SP session and expect a TCG error.
Read back the first 64 logical blocks to confirm the pattern persists.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_spf09_range_alignment_verification

Verify SPF-09 locking range alignment by reading alignment parameters and configuring a compliant range.

Reference

TCG Storage Opal Family Test Cases Specification Revision 1.00

Steps

Start a Locking SP session with Admin1 authority to query alignment requirements.
Exit early when the feature or AlignmentRequired flag is not enabled for this device.
Read block size, alignment granularity, and lowest aligned LBA to determine constraints.
Configure a locking range using the aligned LBA constraint.
Close the session after the configuration command completes.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_spf10_byte_table_access_granularity

Validate SPF-10 byte table access granularity by enforcing MandatoryWriteGranularity on datastore writes and reads.

Reference

TCG Storage Opal Family Test Cases Specification Revision 1.00

Steps

Start a Locking SP session with Admin1 authority to query the datastore granularity.
Read the MandatoryWriteGranularity field from the datastore table.
Skip the test when the granularity requirement is trivial.
Write a payload whose length is exactly one granularity unit.
Close the session after writing the datastore.
Start a new session to read back the datastore contents.
Read the datastore entry and confirm the stored pattern matches the original write.
Ensure the granularity is non-zero and the stored value is correct.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_spf11_stack_reset

Exercise SPF-11 stack reset by enabling a user, issuing STACK_RESET, and ensuring the enable state clears.

Reference

TCG Storage Opal Family Test Cases Specification Revision 1.00

Steps

Start an Admin1 session to modify User1 state within a transaction.
Begin a transaction for the user enable operation.
Enable User1 to establish state that should be reset later.
Issue STACK_RESET and confirm the command succeeds.
Start another Admin1 session to inspect the User1 enable state.
Retrieve the User1 enabled column value after the reset.
Close the Admin1 session.
Confirm the user enable state cleared.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_spf12_tper_reset_case1

Validate SPF-12 TPer reset by enabling programmatic reset, configuring locking ranges, and confirming DNR behavior after TPER_RESET.

Reference

TCG Storage Opal Family Test Cases Specification Revision 1.00

Steps

Enable ProgrammaticReset to allow the TPer reset to clear locks.
Open an Admin1 session to configure locking ranges prior to the reset.
Configure the optional global range for Opal 2.0+ devices.
Lock and enable LockOnReset for the primary global range.
Program the LockOnReset column to include Programmatic.
Start a Locking SP session to issue the TPER_RESET.
Issue the TPER_RESET command
Reopen the Locking SP session to verify range state.
Read the Locking_GlobalRange columns to confirm locks reasserted.
Close the session and ensure both read/write locks are set.
Attempt a write while expecting DNR due to locked range.
Attempt a read under the same conditions and ensure DNR remains asserted.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_spf13_authenticate

Validate SPF-13 authentication by retrieving MSID credentials, authenticating as SID, and verifying the returned UID.

Reference

TCG Storage Opal Family Test Cases Specification Revision 1.00

Steps

Read the MSID PIN to obtain the default SID credential.
Start an Admin SP session to perform the Authenticate method.
Authenticate using the SID authority and the MSID credential.
Read the SID C_PIN UID column for confirmation.
Close the session.
Ensure the returned UID matches the SID C_PIN object identifier.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_spf15_random

Validate SPF-15 Random by requesting multiple 32-byte random blocks and ensuring the data is not all zeros or ones.

Reference

TCG Storage Opal Family Test Cases Specification Revision 1.00

Steps

Start a Locking SP session to access the Random method.
Request 32-byte random data twice to confirm the interface functions consistently.
Ensure each response demonstrates entropy and is not comprised solely of ones or zeros.
Close the locking SP session.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_spf16_common_name

Validate SPF-16 CommonName by programming Admin1 and locking range CommonName fields and verifying the stored values.

Reference

TCG Storage Opal Family Test Cases Specification Revision 1.00

Steps

Skip devices that do not advertise Opal 2.x or Ruby CommonName support.
Start an Admin1 session to modify CommonName columns.
Program the Admin1 CommonName using the MAGIC_PATTERN string.
Program the Locking_GlobalRange CommonName fields using the MAGIC_PATTERN.
Read the Admin1 CommonName value back for verification.
Read the Locking_GlobalRange CommonName value.
Close the Admin1 session.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_spf17_additional_dataStore_tables_case1

Validate SPF-17 additional datastore tables Case 1 by activating the maximum number of tables and confirming reported sizes.

Reference

TCG Storage Opal Family Test Cases Specification Revision 1.00

Steps

Skip when the controller does not advertise the Additional DataStore Table feature.
Parse the maximum number of DataStore tables from discovery data.
Parse the total DataStore size from discovery data.
Parse the DataStore table alignment requirement.
Take ownership to obtain the default SID password.
Program the SID PIN to the provided test password.
Activate the Locking SP with aligned DataStore table sizes.
Call Activate with the computed table count and per-table size.
Close the Admin SP session.
Start an Admin1 session to query the resulting DataStore table metadata.
Read the DataStore table Rows column to verify the allocated size.
Close the Admin1 session.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_spf17_additional_dataStore_tables_case2

Validate SPF-17 additional datastore tables Case 2 by activating aligned per-table sizes and confirming each table reports the expected rows.

Reference

TCG Storage Opal Family Test Cases Specification Revision 1.00

Steps

Skip when the controller does not advertise the Additional DataStore Table feature.
Parse the maximum number of DataStore tables from discovery data.
Parse the DataStore table alignment requirement.
Take ownership to obtain the default SID password.
Program the SID PIN to the provided test password.
Activate the Locking SP using the minimum aligned table size.
Call Activate with the per-table alignment value.
Close the Admin SP session.
Start an Admin1 session to query each DataStore table.
Read each table’s Rows column and ensure the reported size equals the alignment granularity.
Close the Admin1 session.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_spf18_range_crossing_behavior

Validate SPF-18 range crossing behavior by configuring aligned ranges and issuing I/O that spans or stays within the boundaries.

Reference

TCG Storage Opal Family Test Cases Specification Revision 1.00

Steps

Determine range crossing capability from Level 0 discovery and skip unsupported devices.
Record the MDTS value to size the test I/O.
Read the alignment granularity from the LockingInfo structure.
Start an Admin1 session to configure the test ranges.
Configure and unlock the Locking_GlobalRange and Locking_Range instances.
Close the Admin1 session.
Issue range-crossing writes and reads and check whether DNR is asserted.
Perform range-crossing I/O and confirm the controller allows it without errors.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_spf19_block_sid_authentication

Verify SPF-19 block SID authentication by toggling the hardware reset requirement and observing SID session availability.

Reference

TCG Storage Opal Family Test Cases Specification Revision 1.00

Steps

Skip when the subsystem reset capability is unavailable.
Skip when the Block SID Authentication feature is absent.
Retrieve the MSID PIN for subsequent SID authentication attempts.
Assert the hardware reset block via IF-SEND.
Confirm SID authentication is rejected while the block is asserted.
Check the feature descriptor to ensure the hardware reset status bit is set.
Perform a subsystem reset to satisfy the hardware reset requirement.
Verify SID authentication succeeds once the hardware reset is satisfied.
Clear the hardware reset condition again using IF-SEND.
Confirm SID authentication is blocked until the condition clears.
Verify the hardware reset status bit is now cleared.
Power cycle the subsystem and ensure SID authentication continues to succeed.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_spf20_data_removal_mechanism

Validate SPF-20 data removal mechanisms by iterating supported mechanisms and confirming the active value updates accordingly.

Reference

TCG Storage Opal Family Test Cases Specification Revision 1.00

Steps

Skip devices that do not advertise the Data Removal Mechanism feature.
Parse the Supported Data Removal Mechanisms descriptor.
Read the currently active data removal mechanism via an Admin SP SID session.
Query the ActiveDataRemovalMechanism column and ensure it is supported.
Set the ActiveDataRemovalMechanism column to one of the supported modes.
Close the SID session to commit the change.
Open an Anybody Admin SP session to read the public view of the active mechanism.
Query the ActiveDataRemovalMechanism column again and ensure it reflects the requested value.
Close the Anybody session and validate the mechanism selection.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_read_datastore

Verify datastore reads by writing a known pattern with MandatoryWriteGranularity enforcement and retrieving nine rows.

Reference

TCG Storage Security Subsystem Class: Opal Specification Version 2.01

Steps

Start a Locking SP Admin1 session to query MandatoryWriteGranularity.
Read nine rows from the datastore table for verification.
Close the session and verify the amount of data returned.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_getacl

Verify getacl by opening an Admin SP session and retrieving the ACL for a known object.

Reference

TCG Storage Security Subsystem Class: Opal Specification Version 2.01

Steps

Start an Admin SP session with SID authority.
Invoke getacl for the specified UID and log the returned ACL entries.
Close the Admin SP session.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_set_lock_on_reset

Validate LockOnReset behavior by programming the global range to powercycle mode and verifying it persists through a reset.

Reference

TCG Storage Security Subsystem Class: Opal Specification Version 2.01

Steps

Start a Locking SP session to program the LockOnReset column.
Set LockOnReset to powercycle and read back the programmed value.
close session
Power cycle the subsystem to ensure the setting persists.
Reopen a session to read back the LockOnReset field.
Retrieve the LockOnReset value and ensure it remains unchanged.
Close the session and validate the value.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_write_longdata_to_datastore

Verify datastore writes with large payloads by honoring MandatoryWriteGranularity and host communication limits.

Reference

TCG Storage Security Subsystem Class: Opal Specification Version 2.01

Steps

Start a Locking SP Admin1 session to ensure MandatoryWriteGranularity permits the test.
write 1k bytes to datastore table
Read back the data written with the default host limits.
Close the session and confirm the last write persisted.
Advertise host communication limits large enough to test 4K writes.
Start a new session to perform a 4K write under the updated limits.
Write a 4K payload to the datastore and ensure the transfer succeeds.
Read back the 4K payload using the same buffer size.
Close the session and verify the read data matches the pattern.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_mbr_table

Validate MBR table functionality by writing known patterns, power cycling, and ensuring expected persistence.

Reference

TCG Storage Security Subsystem Class: Opal Specification Version 2.01

Steps

Start an Admin1 session to confirm MandatoryWriteGranularity supports the test.
Initialize the MBR table with zeros.
Close the session before the next write.
Start another session to write the MAGIC_PATTERN into the MBR table.
Write the MAGIC_PATTERN into the MBR table.
Power cycle and format the namespace to ensure MBR persistence is evaluated cleanly.
Format the namespace to clear any residual data.
Read the MBR table to ensure the MAGIC_PATTERN persisted.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_mbr_and_revert

Validate MBR persistence across a RevertTPR sequence by writing data, reverting, and confirming the table clears.

Reference

TCG Storage Security Subsystem Class: Opal Specification Version 2.01

Steps

Start an Admin1 session to confirm MandatoryWriteGranularity supports the test.
Write the MAGIC_PATTERN into the MBR table.
Verify the written data before issuing RevertTPer.
Revert the TPer to factory state.
Reacquire ownership using the MSID credential.
Activate the Locking SP to restore normal operation.
Ensure the MBR table content was cleared by the revert.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_done_on_reset

Validate MBR DoneOnReset behavior by programming powercycle mode and confirming it persists across a reset.

Reference

TCG Storage Security Subsystem Class: Opal Specification Version 2.01

Steps

Start a session to program the DoneOnReset column.
Set DoneOnReset to powercycle and read back the value.
Power cycle the device to ensure the value persists.
Verify the DoneOnReset column after the reset.

function: scripts/conformance/06_tcg/02_specific_functionality_test.py::test_write_maxdata_to_datastore

Validate datastore transfers at maximum token sizes by negotiating host properties and performing a boundary-length write and read.

Reference

TCG Storage Security Subsystem Class: Opal Specification Version 2.01

Steps

Announce host properties to learn the device’s maximum communication sizes.
Swap host/device limits to match the device’s maximum capabilities.
Start an Admin1 session to confirm MandatoryWriteGranularity supports the test.
Compute the maximum atom payload based on the negotiated limits.
Write the maximum supported payload to the datastore.
Read the payload back to confirm integrity.
Close the session and ensure the stored data matches the write buffer.
Verify the read data matches the written pattern.

file: scripts/conformance/06_tcg/03_error_test_cases_test

function: scripts/conformance/06_tcg/03_error_test_cases_test.py::test_etc_01_native_protocol_rw_locked_error_responses

Validate that NVMe read/write commands report DNR when Admin1 locks the GlobalRange via the Locking SP.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Establish a Locking SP Admin1 session to manage the global range.
Enable read/write locking on the global range and set both locks to True.
Track the DNR state reported by the NVMe completion callbacks.
Issue a write to the locked range and verify the DNR bit is set.
Issue a read to the locked range and verify the DNR bit is set.

function: scripts/conformance/06_tcg/03_error_test_cases_test.py::test_etc_02_general_if_send_if_recv_synchronous_protocol

Ensure synchronous IF-SEND/IF-RECV exchanges return protocol errors when Properties is requested immediately after session start.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Issue an IF-SEND to open an anybody Admin SP session.
Request Properties over the same ComID to trigger the synchronous protocol fault.

function: scripts/conformance/06_tcg/03_error_test_cases_test.py::test_etc_03_invalid_if_send_transfer_length

Validate that IF-SEND commands exceedings MaxComPacketSize are rejected after discovering the device limit.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Query Properties to learn the device MaxComPacketSize.
Prepare a Properties request whose ComPacket header length matches the payload size.
Send the IF-SEND with a Transfer Length greater than MaxComPacketSize to trigger an error.

function: scripts/conformance/06_tcg/03_error_test_cases_test.py::test_etc_04_invalid_sessionid_regular_session

Confirm that using an invalid SessionID within a regular session triggers the expected zeroed outstanding/min-transfer response.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Take ownership by opening an anybody Admin SP session.
Start a new Admin SP session using the retrieved password.
Issue a Get against the MSID credential using a mismatched Packet SessionID.
Close the session and verify outstanding data and minimum transfer values remain zero.

function: scripts/conformance/06_tcg/03_error_test_cases_test.py::test_etc_05_unexpected_token_outside_of_method_regular_session

Verify the Locking SP handles injected EndList tokens outside the method body while maintaining User1 state.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Initialize a Locking SP session as Admin1 and enable User1 prior to error injection.
Reopen the Admin1 session and inject an EndList token before the CALL while disabling User1.
Capture the response when EndList is forced before the CALL token.
Evaluate the outstanding data and minimum transfer fields returned in the header.
Retry the injected call if the device reports pending data.
Close the session after handling the injected command.
Repeat the Set method attempt with another injected EndList token ordering under a new session.
Query the Enabled column to confirm User1 remains enabled after the error injection.
Close the session and ensure the User1 state is still enabled.

function: scripts/conformance/06_tcg/03_error_test_cases_test.py::test_etc_06_unexpected_token_in_method_regular_session

Validate that injecting EndList immediately after the CALL token causes the Set method to fail as expected.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Open a Locking SP session as Admin1 to prepare for the token injection test.
Disable User1 while injecting an EndList token immediately after the CALL token.
Close the session after validating the injected command failed.

function: scripts/conformance/06_tcg/03_error_test_cases_test.py::test_etc_07_unexpected_token_outside_of_method_control_session

Ensure control sessions reject StartSession requests when an EndList token is injected before the CALL token.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Attempt to start a Locking SP session with an EndList token inserted ahead of the CALL token.
Start a clean Locking SP session to confirm the device remains in a good state.
Verify the outstanding data and minimum transfer fields remained zero.

function: scripts/conformance/06_tcg/03_error_test_cases_test.py::test_etc_08_unexpected_token_in_method_control_session

Validate that duplicate StartList tokens in a control session parameter list trigger the appropriate error response.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Issue a Properties command while injecting a StartList token immediately after another StartList.
Confirm that the returned header fields indicate zero outstanding data and minimum transfer bytes.

function: scripts/conformance/06_tcg/03_error_test_cases_test.py::test_etc_10_invalid_invoking_id_get_case1

Verify the controller rejects Get requests from Admin1 when the InvokingID is not defined in the table.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Open a Locking SP session as Admin1 to issue an invalid Get request.
Attempt to Get from InvokingID 00 00 08 01 AA BB CC DD and expect an error status.
Close the session after completing the invalid Get request.

function: scripts/conformance/06_tcg/03_error_test_cases_test.py::test_etc_10_invalid_invoking_id_get_case2

Validate that Anybody sessions cannot Get from undefined InvokingIDs such as the DataStore table.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Start a Locking SP session using the Anybody authority to issue the invalid Get.
Attempt to Get from InvokingID 00 00 10 01 00 00 00 00 (DataStore table) and expect an error.
Close the session after observing the invalid InvokingID response.

function: scripts/conformance/06_tcg/03_error_test_cases_test.py::test_etc_10_invalid_invoking_id_get_case3

Confirm that valid Admin1 Get requests against C_PIN_Admin1 return data while the PIN value remains hidden.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Start a Locking SP session as Admin1 to read from the C_PIN_Admin1 object.
Request multiple columns from InvokingID 00 00 00 0B 00 01 00 01 (C_PIN_Admin1).
Retrieve the remaining single-column values to ensure each response contains one item.
Close the session and confirm that the PIN value array is empty.

function: scripts/conformance/06_tcg/03_error_test_cases_test.py::test_etc_10_invalid_invoking_id_get_case4

Ensure Anybody sessions cannot Get from the ThisSP object when the InvokingID is invalid for the caller.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Open a Locking SP session with Anybody authority to access the ThisSP object.
Attempt to Get from InvokingID 00 00 00 00 00 00 00 01 (ThisSP) and expect an error.
Close the session after confirming the invalid InvokingID response.

function: scripts/conformance/06_tcg/03_error_test_cases_test.py::test_etc_11_invalid_invoking_id_non_get

Demonstrate that Set operations targeting invalid InvokingIDs fail during a Locking SP session.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Start a Locking SP session to attempt a Set against an invalid object.
Attempt to Set InvokingID 00 00 08 01 00 00 00 05 and expect the command to fail.
Close the session after receiving the invalid InvokingID error.

function: scripts/conformance/06_tcg/03_error_test_cases_test.py::test_etc_12_authorization

Ensure unauthorized attempts to enable User1 during a Locking SP session raise the expected error.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Start a Locking SP session using Anybody authority to simulate an unauthorized caller.
Attempt to enable User1 without sufficient rights and expect an authorization error.
Close the session after verifying the unauthorized Set was rejected.

function: scripts/conformance/06_tcg/03_error_test_cases_test.py::test_etc_13_malformed_comPacket_header_regular_session

Verify malformed ComPacket headers are rejected during regular sessions while keeping Admin1 tries unchanged.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Query Properties to learn the device MaxComPacketSize limit.
Start a Locking SP session as Admin1 to perform the malformed write.
Write to the datastore with a ComPacket header larger than MaxComPacketSize while keeping Transfer Length within limits.
Issue IF-RECV to capture the response to the malformed command.
Determine whether the malformed header caused a session abort.
Reauthenticate as Admin1 to inspect the Tries column if the session was aborted.
Read the Tries column of Admin1’s C_PIN object to ensure no retries were consumed.
Confirm admin1_tries remains zero after the malformed command.
Close the session if the malformed header was handled without aborting.

function: scripts/conformance/06_tcg/03_error_test_cases_test.py::test_etc_16_overlapping_locking_ranges

Ensure overlapping locking ranges generate errors when configured through the Locking SP.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Skip this test if the device lacks Opal 1.0/2.0 locking range support.
Start a Locking SP session as Admin1 to configure locking ranges.
Configure Locking_Range1 to reserve LBAs 0-63.
Attempt to configure Locking_Range2 with an overlapping definition and expect an error.
Close the session once the overlapping range failure is observed.

function: scripts/conformance/06_tcg/03_error_test_cases_test.py::test_etc_17_invalid_type

Verify that invalid data types written to User1’s Enabled column are rejected.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Open a Locking SP session as Admin1 to modify User1 state.
Attempt to write a 0xAAAA value into the Enabled column to trigger a type error.
Close the session after verifying the invalid type was rejected.

function: scripts/conformance/06_tcg/03_error_test_cases_test.py::test_etc_18_revertsp_globalrange_locked

Validate that RevertSP fails when the global locking range remains locked.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Open a Locking SP session as Admin1 to manipulate the global range.
Lock the GlobalRange by setting both ReadLocked and WriteLocked attributes.
Attempt to RevertSP while keeping the global range key/data and expect an error.
Close the session after observing the RevertSP failure.

function: scripts/conformance/06_tcg/03_error_test_cases_test.py::test_etc_19_ata_security_interaction

Validate ATA security interactions by attempting Locking SP activation after resetting SID credentials.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Retrieve the MSID credential via an anybody Admin SP session to take ownership.
Update SID credentials using the retrieved MSID value.
Attempt to activate the Locking SP and expect the ATA security interaction to trigger error 63.
Close the session after validating the activation failure response.

function: scripts/conformance/06_tcg/03_error_test_cases_test.py::test_etc_20_startSession_on_inactive_locking_sp

Verify StartSession fails when issued against an inactive Locking SP.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Attempt to start a Locking SP session even though the SP remains inactive.

function: scripts/conformance/06_tcg/03_error_test_cases_test.py::test_etc_21_startsession_with_incorrect_hostChallenge

Ensure StartSession rejects Admin1 attempts when the HostChallenge does not match the stored PIN.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Attempt to start a Locking SP session as Admin1 using an incorrect HostChallenge value.

function: scripts/conformance/06_tcg/03_error_test_cases_test.py::test_etc_22_multiple_sessions_case1

Validate the controller enforces the MaxSessions limit when multiple Locking SP sessions are requested.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Query Properties to determine the TPer’s MaxSessions capability.
Start a Locking SP session with write access using Admin1 credentials.
Attempt to open another Locking SP session and expect an error based on MaxSessions.
Close the original session before power cycling the subsystem.
Power cycle the subsystem to return the controller to a known state.
Reset the controller handle after the subsystem power cycle completes.

function: scripts/conformance/06_tcg/03_error_test_cases_test.py::test_etc_23_data_removal_mechanism_set_unsupported_value

Ensure unsupported Data Removal Mechanism values are rejected when written via the Admin SP.

Reference

TCG Storage Opal Family Test Cases Specification, Revision 1.00

Steps

Skip the test if the device does not advertise the Data Removal Mechanism feature.
Extract the Supported Data Removal Mechanisms descriptor from Level 0 Discovery.
Start an Admin SP session as SID to query the current Active mechanism.
Read the ActiveDataRemovalMechanism column to capture the baseline value.
Iterate through all mechanisms and try to set those not advertised as supported.
Attempt to set ActiveDataRemovalMechanism to an unsupported value and expect an error.
Close the Admin SP session before verifying the current mechanism value.
Read back the ActiveDataRemovalMechanism via Anybody authority to confirm it was not updated.

function: scripts/conformance/06_tcg/03_error_test_cases_test.py::test_data_over_maxcompacketsize

Confirm datastore reads larger than MaxComPacketSize produce an error after provisioning the Locking SP.

Reference

TCG Storage Security Subsystem Class: Opal Specification Version 2.01

Steps

Determine the device’s MaxComPacketSize limit before programming the SP.
Take ownership by retrieving the MSID credential through the Admin SP.
Program the SID credential with a known password for the remainder of the test.
Activate the Locking SP using the newly provisioned SID credentials.
Perform an in-bounds read from the datastore table as a control case.
Attempt to read beyond MaxComPacketSize and expect an error response.

function: scripts/conformance/06_tcg/03_error_test_cases_test.py::test_start_session_with_wrong_sp

Ensure StartSession fails when the command references an incorrect SP identifier list.

Reference

TCG Storage Security Subsystem Class: Opal Specification Version 2.01

Steps

Attempt to start a Locking SP session while providing an incorrect LOCKINGSP parameter.

file: scripts/conformance/06_tcg/04_appendix_test

function: scripts/conformance/06_tcg/04_appendix_test.py::test_active_user_powercycle

Validate locked user data remains protected across dirty power cycle by reactivating TCG sessions.

Reference

TCG Storage Security Subsystem Class: Opal Specification Version 2.01

Steps

Call StartSession method with SPID = Locking SP UID and HostSigningAuthority = Admin1 authority UID
Provision user1 and grant range access
Close admin session after provisioning
Write pattern to namespace with unlocked state
Flush written data to media
Power cycle subsystem to emulate dirty shutdown
Attempt read without user credential and expect lock enforcement
Reactivate locking SP and unlock range with admin credential
Read data with user credential to confirm integrity

function: scripts/conformance/06_tcg/04_appendix_test.py::test_mbr_read_write

Verify MBR table write and read operations through Opal admin session.

Reference

TCG Storage Security Subsystem Class: Opal Specification Version 2.01

Steps

Verify device supports Opal 2.0 before running MBR test
Invoke Properties method to negotiate host limits
Start locking SP admin1 session
Retrieve MBR table size from descriptor
Query mandatory write granularity for MBR object
Write MBR table with test pattern
Read back the MBR content for verification
close session

function: scripts/conformance/06_tcg/04_appendix_test.py::test_datastore_read_write

Validate datastore table write and read via locking SP session.

Reference

TCG Storage Security Subsystem Class: Opal Specification Version 2.01

Steps

Start locking SP admin1 session
Query datastore mandatory write granularity
Define datastore offsets and payload
invoke Set method to write the datastore table with the MAGIC_PATTERN
Read datastore content for verification
close session

function: scripts/conformance/06_tcg/04_appendix_test.py::test_blocksid_and_lock_range

Assess Block SID authentication survives power events while locking ranges are enforced.

Reference

NVM Express Revision 1.4a

Steps

L2 platform: Tributo MTL meteor lake 0.1.37
Discover TCG capabilities and ensure Block SID is supported
Power cycle the SD to clear existing Block SID state
BlockSID enabling
Set feature PS3
PCIe reset
Power cycle the SD
Start SID session and set new Admin SP password
Call StartSession method with SPID = Admin SP UID and HostSigningAuthority = SID authority UID
Activate locking SP and move lifecycle to enabled state
Call Activate method on Locking SP object
Enable ProgrammaticReset to allow TPER reset
Open locking SP session and enforce lock on global range
Issue TPER reset to clear locking state
Call StartSession method with SPID = Locking SP UID and HostSigningAuthority = Admin1 authority UID
Unlock global range after TPER reset
Call StartSession method with SPID = Locking SP UID and HostSigningAuthority = Admin1 authority UID
Perform IO to confirm access restored without errors

file: scripts/conformance/06_tcg/05_core_spec_test

function: scripts/conformance/06_tcg/05_core_spec_test.py::test_trylimit

Verify SID try limit equals 10 by reading Admin SP session properties.

Reference

Datacenter NVMe SSD Specification, Revision 2.5

Steps

Start Admin SP session using SID authority credential
Read SID C_PIN TryLimit column
Read SID C_PIN Tries column
Read SID C_PIN persistence attribute
Close session to release resources

function: scripts/conformance/06_tcg/05_core_spec_test.py::test_datastore_size

Verify datastore capacity equals 10 MB using Admin SP session query.

Reference

Datacenter NVMe SSD Specification, Revision 2.5

Steps

Open Admin SP session
Get datastore size
Keep optional datastore size threshold check for reference
if data_store_rows < (1010241024):
warnings.warn(“DataStore size: %dKB, less than 10MB” % (data_store_rows//1024))
Close session

function: scripts/conformance/06_tcg/05_core_spec_test.py::test_single_user_mode

Confirm Single User Mode support via Level 0 discovery feature list.

Reference

Datacenter NVMe SSD Specification, Revision 2.5

Steps

Run Level 0 discovery and check Single User Mode feature flag

function: scripts/conformance/06_tcg/05_core_spec_test.py::test_configurable_namespace_locking

Confirm Configurable Namespace Locking support via Level 0 discovery.

Reference

Datacenter NVMe SSD Specification, Revision 2.5

Steps

Run Level 0 discovery and check Configurable Namespace Locking feature flag

function: scripts/conformance/06_tcg/05_core_spec_test.py::test_properties_info

Collect and log TPer property limits using the Properties method.

Reference

Datacenter NVMe SSD Specification, Revision 2.5

Steps

Invoke Properties method with host-defined property hints
Get MaxComIDTime value
Get DefSessionTimeout value
Get MaxSessionTimeout value
Get MinSessionTimeout value
Get MaxTransactionLimit value
Get MaxSessions value
Get MaxReadSessions value
If a host includes property parameters to the Properties method invocation that the TPer does not support, the TPer SHALL ignore those parameters, and SHALL NOT return them in its response.

function: scripts/conformance/06_tcg/05_core_spec_test.py::test_authentication_time

Measure authentication time for C_PIN start session handshake.

Reference

Datacenter NVMe SSD Specification, Revision 2.5

Steps

Start authentication session and capture latency
Optional check: authentication of a C_PIN should be at least 100 ms
if authentication_time < 0.1:
warnings.warn(“authentication time: %.02fms, less than 100ms” % (authentication_time*1000))

function: scripts/conformance/06_tcg/05_core_spec_test.py::test_get_comid

Verify GET_COMID returns expected ComID via security receive command.

Reference

TCG Storage Architecture Core Specification, Revision 2.01

Steps

Prepare buffer for GET_COMID readback
Issue GET_COMID
Parse feature data to determine number of ComIDs

function: scripts/conformance/06_tcg/05_core_spec_test.py::test_verify_comid_valid

Check VERIFY_COMID_VALID status through security send/receive sequence.

Reference

TCG Storage Architecture Core Specification, Revision 2.01

Steps

Check security command capability before issuing TCG command
Retrieve Level 0 discovery data to confirm TCG availability
Issue GET_COMID to obtain active ComID
Issue VERIFY_COMID_VALID to report ComID status

function: scripts/conformance/06_tcg/05_core_spec_test.py::test_comid_and_session

Verify ComID state transitions before, during, and after sessions.

Reference

TCG Storage Architecture Core Specification, Revision 2.01

Steps

Power cycle the device to clear ComID state
Retrieve ComID via GET_COMID and validate availability
Fetch ComID status through VERIFY_COMID_VALID
Open Admin SP session to associate ComID
Verify ComID status reflects association
Close session and confirm status assertion
Re-query ComID status after closing session
Power cycle device again to ensure status persistence

function: scripts/conformance/06_tcg/05_core_spec_test.py::test_invalid_comid

Ensure invalid ComID session attempt raises expected warning.

Reference

TCG Storage Architecture Core Specification, Revision 2.01

Steps

Attempt session creation with invalid ComID and expect warning

function: scripts/conformance/06_tcg/05_core_spec_test.py::test_syncsession

Validate SyncSession command keeps session active without errors.

Reference

TCG Storage Architecture Core Specification, Revision 2.01

Steps

Start anybody session on Admin SP
Issue SyncSession method to maintain session
close session

function: scripts/conformance/06_tcg/05_core_spec_test.py::test_data_store_transaction_success

Verify successful datastore transaction commit preserves written data.

Reference

TCG Storage Architecture Core Specification, Revision 2.01

Steps

Start locking SP admin1 session and read mandatory write granularity
Write zeros to datastore to set baseline content
Close session after baseline write
Begin transaction before modifying datastore content
Write magic_pattern to datastore table
Commit transaction with success status
Read datastore to confirm committed pattern persists

function: scripts/conformance/06_tcg/05_core_spec_test.py::test_data_store_abort_transaction

Confirm endTransaction failure status discards uncommitted datastore data.

Reference

TCG Storage Architecture Core Specification, Revision 2.01

Steps

Start locking SP admin1 session
Begin transaction before writing data
Write magic_pattern to datastore table
End transaction with failure status to discard changes
Close session after transaction failure
Read data to ensure failed transaction did not persist writes

function: scripts/conformance/06_tcg/05_core_spec_test.py::test_transaction_trylimit_case

Exercise transaction flow to verify Admin1 try limit enforcement.

Reference

TCG Storage Architecture Core Specification, Revision 2.01

Steps

Drive Admin1 authentication retries up to TryLimit using wrong password
Attempt User1 session and expect AUTHORITY_LOCKED_OUT
Power cycle to reset Admin1 Tries counter
Confirm retries cleared after power cycle
Start transaction before authentication attempts
Authenticate with wrong password to increment tries
End transaction with success status
Check Admin1 tries incremented once
Start a second transaction
Authenticate again with wrong password
End transaction with failure status to finalize second try
Check Admin1 tries incremented twice

function: scripts/conformance/06_tcg/05_core_spec_test.py::test_level0_discovery

Send Level 0 Discovery at multiple phases to observe ComID consistency.

Reference

TCG Storage Architecture Core Specification, Revision 2.01

Steps

Issue Level 0 discovery before opening any session
Start Admin SP session for subsequent discovery checks
Issue Level 0 discovery while session active
Issue Level 0 discovery after MSID retrieval
Issue Level 0 discovery after closing Admin SP session
Start SID session with MSID password to update credential
Issue Level 0 discovery after SID start-session send
Issue Level 0 discovery after SID close-session send

function: scripts/conformance/06_tcg/05_core_spec_test.py::test_send_twice_start_session

Verify duplicate start session security sends fail as expected.

Reference

TCG Storage Architecture Core Specification, Revision 2.01

Steps

Retrieve baseline ComID from Level 0 discovery
Send start session security send twice
Check the second start-session send fails
Retrieve MSID C_PIN after successful session start

function: scripts/conformance/06_tcg/05_core_spec_test.py::test_send_twice_end_session

Verify duplicate end session commands return expected error status.

Reference

TCG Storage Architecture Core Specification, Revision 2.01

Steps

Retrieve baseline ComID from Level 0 discovery
Open Admin SP session prior to duplicate close attempts
Retrieve MSID C_PIN after successful session start
Send close session security send twice
Check the second end-session send fails

function: scripts/conformance/06_tcg/05_core_spec_test.py::test_outstandingdata

Validate outstanding_data handling by limiting datastore receive length.

Reference

TCG Storage Architecture Core Specification, Revision 2.01

Steps

Start locking SP admin1 session
Query mandatory write granularity before datastore access
Read 512 rows from the datastore table
Retrieve partial response to capture outstanding data size
Receive remaining outstanding data to complete transfer
Close session

function: scripts/conformance/06_tcg/05_core_spec_test.py::test_max_compacket_size

Check MaxComPacketSize enforcement when reading large datastore ranges.

Reference

TCG Storage Architecture Core Specification, Revision 2.01

Steps

Invoke Properties method to identify MaxComPacketSize limits
Start locking SP admin1 session
Query mandatory write granularity prior to large read
Read MaxComPacketSize rows from the datastore to exceed response limit
Close session

function: scripts/conformance/06_tcg/05_core_spec_test.py::test_multi_users_and_ranges

Verify eight users own unique locked ranges and can read/write after unlock.

Reference

TCG Storage Architecture Core Specification, Revision 2.01

Steps

Check Opal 2.0 capability and skip if unsupported
Open locking SP admin session
Enable eight users with default passwords
Assign locked ranges to each user with distinct offsets
Close admin session after range setup
Verify locked ranges reject host I/O
Open eight user sessions and unlock assigned ranges
Issue host write/read to confirm unlocked access per range

Suite: scripts/benchmark

folder: scripts/benchmark

file: scripts.benchmark.basic_cdm

CrystalDiskMark-style benchmark that replays a fixed set of sequential and random workloads to sanity-check SSD bandwidth and IOPS under typical client settings.

The suite preconditions the drive and then sweeps through large-block sequential transfers plus 4K random mixes so engineers can compare numbers across firmware revisions with minimal tuning.

file: scripts.benchmark.idle_stress

Exercises drives in 24×7 standby scenarios with sporadic IO bursts to mimic office-style PCs, ensuring the SSD survives repeated transitions into/out of deep power states without latency spikes.

It measures entry/exit latency into PS3/PS4, watches power draw through a PAM, and validates data with background readbacks so firmware engineers can spot low-power bugs quickly.

file: scripts.benchmark.interval_read_disturb

Stresses fixed LBAs for long periods to expose read-disturb related errors while leaving idle gaps that mimic fleet workloads; JEDEC enterprise patterns are replayed to prepare the media before targeted reads.

SMART, temperature, and UECC counters are captured before/after each sweep, and a full-drive verify pass ensures retention issues surface early.

file: scripts.benchmark.ioworker_stress

Runs a long-haul randomized workload that mixes IO workers with admin commands to validate SSD stability, performance, and error recovery under shifting conditions.

Workloads are repeatedly started/stopped while telemetry (SMART, voltage, error codes) is monitored, and the entire drive is verified at the end to guarantee data integrity.

file: scripts.benchmark.link_speed_stress

Assesses NVMe stability when PCIe link speeds hop between generations under a continuous read workload, capturing transition delays and timeouts.

By scripting repeated speed thrashing while IOps remain high, the benchmark reveals LTSSM bugs, PHY margin issues, or firmware throttling triggered by link changes.

file: scripts.benchmark.llm_loading

Simulates LLM-style dataset loading by repeatedly filling regions with mixed IO patterns and then streaming multi-GB “image” chunks to measure read and write latency consistency.

Parameter sweeps change image sizes and loop counts so teams can size caches, validate QoS under bursty ingestion, and ensure data stays intact after each heavy pass.

file: scripts.benchmark.longtime_readwrite

Consumes defined percentages of PE cycles via sustained sequential writes and then checks how read/write performance drifts over time.

file: scripts.benchmark.performance

Evaluates client SSD performance across sequential/random workloads while tracking latency consistency, thermal behavior, and power envelopes.

It automates fill phases, JEDEC traces, cache reclaim studies, restricted IOPS cases, and power-state characterizations so validation teams can build a single report covering QoS, efficiency, and recovery.

file: scripts.benchmark.por_sudden

Automates dirty power-cycle (SPOR) validation by logging controller readiness after abruptly removing power during active workloads. Requires a Quarch PAM for precise control and telemetry.

SPOR emulates unexpected power loss with no shutdown hint so firmware handling of inflight IO, command logs, and rescan latency can be measured repeatably.

Power-on timing checkpoints:

BAR Access Time: write BAR registers successfully
Admin Ready Time: admin queue commands accepted
First IO Completion Time: first read completes

file: scripts.benchmark.por_typical

Automates clean power-cycle (POR) testing with Quarch PAM control to track when the SSD exposes BAR registers, accepts admin commands, and completes first IOs.

POR simulates shutting down power after the host has notified the device, so it focuses on firmware readiness, cache flush completeness, and command-log scan times.

Power-on timing checkpoints:

BAR Access Time: control registers writable
Admin Ready Time: admin queue ready
First IO Completion Time: first read finishes

file: scripts.benchmark.read_retention

Fills the entire drive, stores CRCs for every LBA, and later compares them after long power-off intervals (e.g., multi-month retention studies).

Recommended workflow:

Create /home/crc with root if missing.
Run make test TESTS=...::test_prepare to fill & log CRC.
Run test_verify once to archive initial logs.
Collect artifacts from results.
Power off DUT and store at room temperature for ~2 months.
Reinsert DUT into same SUT.
Re-run test_verify to compare CRC/SMART.
Collect updated logs/diagrams.

file: scripts.benchmark.replay_trace

Provides helpers to parse CSV trace descriptions (SLBA, NLB, opcode, timestamp) and replay them against an NVMe namespace at different capacity scales.

test_replay_trace writes/trim operations, performs a clean subsystem power cycle, re-enables HMB if present, and finally replays the read-only phase so power-cycle sensitivity can be evaluated deterministically.

file: scripts.benchmark.reset_double

Inject resets during NVMe initialization to ensure the controller/driver stack recovers cleanly from mid-boot interruptions.

file: scripts.benchmark.saw_diagram

Stresses APST/APSM-driven transitions into PS3/PS4 by injecting IOs at varying idle delays and charting the resulting latency spikes (saw-tooth diagram).

file: scripts.benchmark.wear_leveling

Evaluates static and dynamic wear leveling by writing hot/cold regions with sequential and random IOs, then graphing IOPS trends and verifying data.

Hot sequential vs. hot random phases expose GC aggressiveness, while final power cycle + verify stages confirm that endurance algorithms did not corrupt data.

file: scripts.benchmark.write_latency

Measures long-tail latency while streaming sequential 128KB writes (QD=1) and plots throughput, per-IO latency, and temperature evolution.

Preparation helpers handle formatting, optional sanitization/prefill, HMB/FUA selection, and workload sizing so repeated runs stay consistent.

Pass criteria enforce <1% of IOs exceeding 8ms and 99th percentile latency below 8ms; diagrams and CSV logs assist regression tracking.

Suite: scripts/management

folder: scripts/management

file: scripts/management/01_mi_inband_test

function: scripts/management/01_mi_inband_test.py::test_mi_vpd_write_and_read

Validate MI VPD write/read using mixed in-band and out-of-band access.

Reference

Based on NVM Express Management Interface Revision 1.2c.

Steps

Allocate buffers for in-band VPD write and readback
Attempt VPD write and fall back to copying existing VPD if write not supported
Read VPD in-band for baseline comparison
Verify written data matches read data
Read VPD via out-of-band path and compare contents
Mix in-band and out-of-band reads to cross-check consistency
Repeat out-of-band reads across size variants

function: scripts/management/01_mi_inband_test.py::test_mi_large_message_inband

Validate MI VPD read padding across varying payload lengths in-band.

Reference

Based on NVM Express Management Interface Revision 1.2c.

Steps

Issue MI VPD read using zeroed pattern to confirm completion status across sizes
Repeat MI VPD read using ones pattern to confirm unused bytes remain unchanged

function: scripts/management/01_mi_inband_test.py::test_mi_inband_header

Validate in-band receive header handling for CIAP, IC, and NVMe context rules.

Reference

Based on NVM Express Management Interface Revision 1.2c.

Steps

Initialize completion status tracking for MI receive path validation
Capture completion status and error location from MI receive completions
Validate invalid command opcode handling in in-band command message
Confirm invalid opcode handling for alternate opcode value
Exercise CIAP=0 flow in an in-band command message
Ensure CIAP=1 in an in-band command triggers error reporting
Ensure IC=1 in an in-band command triggers error reporting
Validate error handling in NVMe context during MI receive
Issue VPD read with non-dword size to confirm padding behavior
Issue VPD read from slot 1 for comparison
Pad buffer tail to dword granularity before comparison

function: scripts/management/01_mi_inband_test.py::test_mi_inband_header_send

Exercise MI send header handling for CIAP, IC, and opcode validation.

Reference

Based on NVM Express Management Interface Revision 1.2c.

Steps

Initialize completion status tracking for MI send path validation
Capture completion status and error location from MI send completions
Issue baseline MI send to confirm successful completion
Validate invalid command opcode handling in in-band command message
Confirm invalid opcode handling for alternate opcode value
Exercise CIAP=0 flow in an in-band command message
Ensure CIAP=1 in an in-band command triggers error reporting
Ensure IC=1 in an in-band command triggers error reporting
Validate error handling in NVMe context during MI send
Read original VPD data for later restoration
Write VPD with non-dword aligned data pattern
Read VPD from slot 0 after partial write
Read VPD from slot 1 for comparison
Restore original VPD contents
Verify VPD data matches padded write data across slots

function: scripts/management/01_mi_inband_test.py::test_mi_inband_control_primitives_prohibited

Ensure in-band tunneling rejects Management Control Primitive opcodes.

Reference

Based on NVM Express Management Interface Revision 1.2c.

Steps

Track completion status returned by the MI tunneling transport
Capture completion status and error location during tunneled operations
Issue receive/send commands for Control Primitive opcodes 0-4 to confirm rejection

function: scripts/management/01_mi_inband_test.py::test_mi_reset

Validate MI reset command using subsystem power cycle callbacks.

Reference

Based on NVM Express Management Interface Revision 1.1b.

Steps

Define MI reset callback that triggers inline MI reset through PCIe transport
Define placeholder completion callback required by the subsystem wrapper
Skip if MI commands are not supported
Create subsystem wrapper using MI callbacks
Issue MI reset sequence and restore controller readiness

function: scripts/management/01_mi_inband_test.py::test_mi_invalid_operation

Verify MI send path reports invalid opcode errors for unsupported commands.

Reference

Based on NVM Express Management Interface Revision 1.1b.

Steps

Send MI command with an invalid opcode and confirm status field is 0x3
send MI with an invalid command opcode

function: scripts/management/01_mi_inband_test.py::test_mi_configuration_get_health_status_change

Retrieve Health Status Change configuration via MI tunneling.

Reference

Based on NVM Express Management Interface Revision 1.1b.

Steps

Issue MI receive with CFG_ID 0x02 to fetch Health Status Change configuration
MI command to get configuratrion of Health Status Change

function: scripts/management/01_mi_inband_test.py::test_mi_configuration_set_health_status_change

Update Health Status Change configuration via MI tunneling.

Reference

Based on NVM Express Management Interface Revision 1.1b.

Steps

Send MI configuration set for CFG_ID 0x02 and expect successful completion
MI command to set configuration of Health Status Change, it shall complete successfully

function: scripts/management/01_mi_inband_test.py::test_mi_read_nvme_mi_data_structure_nvm_subsystem_information

Read MI data structure for NVM subsystem information via receive path.

Reference

Based on NVM Express Management Interface Revision 1.1b.

Steps

Fetch NVM subsystem information and dump the first few dwords

function: scripts/management/01_mi_inband_test.py::test_mi_read_nvme_mi_data_structure_nvm_subsystem_information_wrong_command

Confirm MI data structure read fails when issued through mi_send.

Reference

Based on NVM Express Management Interface Revision 1.1b.

Steps

Attempt MI send for subsystem information and log resulting status

function: scripts/management/01_mi_inband_test.py::test_mi_read_nvme_mi_data_structure_port_information

Read MI data structure for port information via receive path.

Reference

Based on NVM Express Management Interface Revision 1.1b.

Steps

Query port information structure for port 0 and log contents

function: scripts/management/01_mi_inband_test.py::test_mi_read_nvme_mi_data_structure_port_information_wrong_port

Confirm MI port information read fails for unsupported port identifiers.

Reference

Based on NVM Express Management Interface Revision 1.1b.

Steps

Attempt port information read against invalid port value and observe status

function: scripts/management/01_mi_inband_test.py::test_mi_ep_buf_prohibited

Verify Management Endpoint Buffer commands are prohibited in MI tunneling.

Reference

Based on NVM Express Management Interface Revision 1.1b.

Steps

Allocate scratch buffer used for Management Endpoint buffer read/write commands
Test Management Endpoint Buffer Read (0x0A)
Test Management Endpoint Buffer Write (0x0A)
Test Management Endpoint Buffer Read (0x0B)
Test Management Endpoint Buffer Write (0x0B)

function: scripts/management/01_mi_inband_test.py::test_mi_configuration_prohibited

Validate prohibited configuration identifiers return expected tunneled status.

Reference

Based on NVM Express Management Interface Revision 1.2c.

Steps

Exercise Configuration Get/Set commands for prohibited CFG_ID=1
Exercise Configuration Get/Set commands for prohibited CFG_ID=3
Exercise Configuration Get/Set commands for valid CFG_ID=2

file: scripts/management/02_basic_mgmt_cmd_test

function: scripts/management/02_basic_mgmt_cmd_test.py::test_mi_spec_appendix_a_read_drive_status

Verify drive status, SMART warnings, and temperature via SMBus block read with PEC validation.

Reference

Based on Management Interface Specification Revision 1.2c Appendix A.

Steps

Read drive status page from offset 0 over SMBus into an 8 byte buffer
Calculate PEC over the address and payload to validate integrity
Log the retrieved status payload for traceability

function: scripts/management/02_basic_mgmt_cmd_test.py::test_mi_spec_appendix_a_read_drive_static_data

Retrieve drive VID and serial number through an I2C static data block read for identification.

Reference

Based on Management Interface Specification Revision 1.2c Appendix A.

Steps

Capture 32 bytes of static identification data through an I2C block read
Log the retrieved static payload for debugging

function: scripts/management/02_basic_mgmt_cmd_test.py::test_mi_spec_appendix_a_reset_arbitration_bit

Reset the arbitration condition by issuing a single byte I2C write to the management endpoint.

Reference

Based on Management Interface Specification Revision 1.2c Appendix A.

Steps

Send byte 0xff to clear the arbitration bit on the management endpoint

function: scripts/management/02_basic_mgmt_cmd_test.py::test_mi_spec_appendix_a_read_drive_status_across_i2c_block_boundaries

Sweep I2C bitrates to confirm block reads cross boundaries while preserving status payload integrity.

Reference

Based on Management Interface Specification Revision 1.2c Appendix A.

Steps

Log the drive serial number for comparison against I2C payloads
Sweep the I2C bitrate and read 100 bytes to ensure seamless access across block boundaries
Validate that the serial number prefix is returned intact

file: scripts/management/03_mi_cmd_set_test

function: scripts/management/03_mi_cmd_set_test.py::test_mi_no_unsolicited_response

Verify that the Management Endpoint never sends unsolicited responses by calling receive() without issuing a command first.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Receive a response without sending a prior command request

function: scripts/management/03_mi_cmd_set_test.py::test_mi_ep_buf_different_length

Exercise Management Endpoint buffer read and write paths at varied data lengths to confirm data integrity.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Read the SMBus port data structure to check for buffer support and size
Write random data into the Management Endpoint buffer
Read back the buffer and verify data integrity

function: scripts/management/03_mi_cmd_set_test.py::test_mi_read_mi_data_structure

Validate MI data structure reads by querying subsystem, port, and parameter records through out-of-band access.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Read the NVM Subsystem Information structure (DTYP=00h)
Read the SMBus port information structure (DTYP=01h) to examine parameters
Enumerate and log the port data for each reported port
Validate Maximum MCTP Transmission Unit Size
Validate Management Endpoint Buffer Size
Validate VPD Address and Maximum Frequency
Validate MI Endpoint Address and Maximum Frequency

function: scripts/management/03_mi_cmd_set_test.py::test_mi_pcie_port_specific_data

Correlate MI-reported PCIe port data against PCIe configuration space registers to confirm accuracy.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Create a helper to locate the requested PCIe port entry within the MI data structures
Locate a PCIe port entry in the MI data structures
Ensure the capability exists on the PCIe side
Parse MI-reported PCIe port fields
Compare Maximum Payload Size (encoded per PCIe Device Control register bits [7:5])
Supported link speed vector
Derive from Link Capabilities max speed if Link Capabilities 2 is not populated
Current link speed from Link Status register bits [3:0]
Maximum link width from Link Capabilities bits [9:4]
Negotiated link width from Link Status bits [9:4]

function: scripts/management/03_mi_cmd_set_test.py::test_mi_read_mi_data_structure_lockdown

Verify the lockdown feature blocks MI data structure reads when commanded via admin lockdown operations.

Reference

NVMe Base Specification Revision 2.2

Steps

Issue a baseline MI data structure read to confirm access prior to lockdown
Prohibit the command via the lockdown admin command
Confirm the MI data structure read is blocked while lockdown is active
Allow the command again through the lockdown admin interface
Prohibit the command through the admin queue controlling different scope
Reissue the MI data structure read out of band and confirm access still works
Restore the default lockdown settings to reenable the command fully

function: scripts/management/03_mi_cmd_set_test.py::test_mi_read_mi_data_structure_controller

Cross-check controller list and controller information MI data structures with identify controller data.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Read the controller list and compare the CID with the Identify data
Read the controller information structure and confirm the PCI vendor/device IDs

function: scripts/management/03_mi_cmd_set_test.py::test_mi_read_mi_data_structure_command_support

Inspect the command support data structures to list NVMe-MI command opcodes per message type.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Read the target data structure and skip tests when unsupported
Enumerate the reported commands and log their opcodes

function: scripts/management/03_mi_cmd_set_test.py::test_mi_nvm_subsystem_health_status_poll

Exercise the NVM Subsystem Health Status Poll command to confirm field values fall within expected limits.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Send a baseline health status poll with Clear Status cleared
Check the NVM Subsystem Status (NSS) flags for a healthy state
Record the smart warning field for traceability
Confirm the composite temperature stays below the safety threshold
Confirm the percentage drive life used is within the expected range
Log the composite controller status value for reference

function: scripts/management/03_mi_cmd_set_test.py::test_mi_nvm_subsystem_health_status_poll_check

Compare MI health status poll information with the NVMe SMART log to cross-validate telemetry.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Send a health status poll and capture the MI-reported composite temperature
Retrieve the SMART log from the NVMe controller for temperature comparison
Validate that the temperature readings do not diverge beyond the tolerance
Compare the percentage used values reported through MI and SMART

function: scripts/management/03_mi_cmd_set_test.py::test_mi_nvm_subsystem_health_status_poll_clear

Verify that Clear Status operates independently from subsystem resets and reflects in MI polling.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Check the Identify Controller data to ensure subsystem reset is supported
Clear the health status and confirm CCS is zero
Issue an NVMe subsystem reset and allow the transition to complete
Poll the health status without clearing after the reset to capture the event bit
Validate that the “NVM Subsystem Reset Occurred” bit becomes set
Clear the status again to remove the latched bit
Re-poll the health status to confirm the reset bit cleared
Validate that the “NVM Subsystem Reset Occurred” bit is now cleared

function: scripts/management/03_mi_cmd_set_test.py::test_mi_configuration_set_health_status_independent

Confirm that MI health status tracking for in-band and out-of-band paths operates independently.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Skip the test when MI send/receive commands are not available
Retrieve the subsystem health status over the in-band path to prime buffers
Read CCS via the in-band path and ensure it reports a non-zero value
Capture CCS via out-of-band access for comparison
Clear the “ready” bit via Configuration Set and re-read CCS
Verify that the in-band CCS view remains unchanged after the OOB clear
Clear the status via the out-of-band interface only
Re-read CCS in-band to ensure it has not yet been cleared
Confirm the out-of-band CCS view cleared as expected
Trigger an in-band reset and ensure CCS ultimately clears

function: scripts/management/03_mi_cmd_set_test.py::test_mi_configuration_set_health_status_change

Drive configuration set operations that alter health status bits and observe CC/CSTS reflections.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Clear the CC register through PCIe config space and confirm it takes effect
Clear the health status and validate CSTS and CCS report ready=0
Set CC.EN and verify CSTS register indicates ready
Set shutdown and verify CSTS register and CCS
Clear “ready” in CCS and verify
Validate final CCS state is cleared

function: scripts/management/03_mi_cmd_set_test.py::test_mi_nvm_subsystem_health_status_poll_temperature

Validate that the composite temperature reported via MI tracks workload-induced heating.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Capture the idle composite temperature using the health status poll
Stress the namespace with an IO worker to elevate device temperature
Read the composite temperature again to confirm it increases
Verify the post-workload temperature is not lower than the idle value

function: scripts/management/03_mi_cmd_set_test.py::test_mi_controller_health_status_poll

Exercise controller health status polling for various filters and selectors to confirm responses.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Report only changed health status without selecting a specific controller
Report changed health status for a specific controller selection field
Report all health statuses across all controllers
Report changed health status for a multi-controller selection
Report only a specific error condition by programming error_select
Report all health statuses (all=1), regardless of changes.
Validate critical response data fields.

function: scripts/management/03_mi_cmd_set_test.py::test_mi_controller_health_status_poll_with_nvme

Correlate MI controller health status poll data with NVMe Identify and SMART log fields for consistency.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Perform a general health status poll with ALL=1
Validate response data structure
Extract and validate the Controller ID reported in the MI payload
Compare the MI health status data with the NVMe SMART log page
Perform a health status poll targeting the specific controller selection
Validate that controller selection fields still apply when ALL=1
Use error selection filtering to ensure consistent error reporting
Limit the number of returned entries by setting MAXRENT to one
Specifying 256 entries is interpreted as an Invalid Parameter.
The maximum number of entries is 255
Report only controller status changes (error_select=1).
Generate temperature change by running IO workload

function: scripts/management/03_mi_cmd_set_test.py::test_mi_controller_health_status_poll_clear

Validate Clear Changed Flags behavior and compare OOB results to in-band tunneling.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Perform a health status poll with ALL=1 (report all health data)
Poll again with Clear Changed Flags set to clear the change bits
Perform a subsequent poll with ALL=1 to confirm the cleared flag state persists
Report only controller status changes to ensure no entries are returned
Retrieve the health status via in-band tunneling to demonstrate independent operation

function: scripts/management/03_mi_cmd_set_test.py::test_mi_controller_health_status_poll_filter

Trigger controller health status change flags via temperature events and validate filtered polling.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Clear the controller health status changed flags to start from a clean slate
Poll the controller health status using a filter to confirm no entries are reported initially
assert res[7] == 0, f”Unexpected Response Entries error: {res[7]}”
Capture the original temperature threshold configuration
Ensure asynchronous temperature events are enabled
Retrieve the current temperature from the SMART log to use as the trigger point
Drop the over temperature threshold below the current temperature to force an event
Restore the original threshold configuration after the event triggers
Poll the controller health status after triggering the event
Clear the controller health status changed flags again to clean up

function: scripts/management/03_mi_cmd_set_test.py::test_mi_ses_prohibited

Confirm SES receive/send opcodes are rejected with Invalid Command Opcode status.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Attempt to send an SES Receive command (0x08) and expect Invalid Command Opcode
Attempt to send an SES Send command (0x09) and expect Invalid Command Opcode

function: scripts/management/03_mi_cmd_set_test.py::test_mi_configuration_get

Exercise the Configuration Get command to confirm default values across identifiers.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Get Health Status Change configuration
Get current SMBus/I2C Frequency configuration
Get MCTP TU size configuration

function: scripts/management/03_mi_cmd_set_test.py::test_mi_configuration_set

Program several configuration identifiers and observe both valid updates and reserved field errors.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Verify a reserved configuration identifier raises an invalid parameter response
Set Health Status Change masks with increasing coverage
Set SMBus/I2C Frequency to 400 KHz
Read the SMBus/I2C Frequency configuration
Set SMBus/I2C Frequency back to 100 KHz
Confirm the SMBus/I2C Frequency returned to 100 KHz

function: scripts/management/03_mi_cmd_set_test.py::test_mi_configuration_set_frequency_outstanding

Attempt to change SMBus/I2C Frequency while other MI command messages are outstanding.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Attempt to set SMBus/I2C Frequency (CFG_ID = 1) while slot is idle
Issue a VPD read command on slot 1 and receive response
Issue another VPD read command on slot 1 but not wait for receiving
Attempt to set SMBus/I2C Frequency again and verify response
recover the default freqency

function: scripts/management/03_mi_cmd_set_test.py::test_mi_configuration_set_frequency_invalid

Drive Configuration Set for SMBus/I2C Frequency with unsupported values to confirm error handling.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Unsupported SMBus/I2C frequency (e.g., 0x05 which is not defined)
Invalid Port Identifier (port not an SMBus/I2C port)
Attempt to set a reserved frequency (e.g., 0x0 which is not valid)
Attempt to set a frequency that exceeds defined limits (e.g., 0x10 which is reserved)
Recover the default frequency to ensure no residual impact

function: scripts/management/03_mi_cmd_set_test.py::test_mi_configuration_set_frequency

Cycle through each supported SMBus/I2C frequency and verify it applies cleanly.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Capture the current SMBus/I2C Frequency
Configure the requested frequency value
Verify the Configuration Set succeeded
Exercise the bus by issuing a VPD read
Restore the original SMBus/I2C frequency

function: scripts/management/03_mi_cmd_set_test.py::test_mi_configuration_set_tu_size

Configure various MCTP Transmission Unit sizes and confirm they remain within supported limits.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Read the device-supported maximum TU size
Skip the test if the requested TU exceeds the maximum supported size
Set the MCTP Transmission Unit size
Verify that the TU size was set correctly
Read VPD data to validate device response

function: scripts/management/03_mi_cmd_set_test.py::test_mi_configuration_set_tu_size_outstanding

Modify the TU size while other commands are pending to ensure MI command sequencing is honored.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Set TU size to 100 bytes
Issue a VPD read command on slot 1 and receive the response
Issue another VPD read command on slot 1 but do not wait for response
Attempt to set TU size to 128 bytes while VPD read is outstanding
Receive the VPD response
Recover the default TU size (64 bytes)

function: scripts/management/03_mi_cmd_set_test.py::test_mi_configuration_set_tu_size_invalid

Feed unsupported TU sizes to Configuration Set to confirm invalid parameter handling.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Set an unsupported TU size (e.g., 20 bytes, below the valid range)
Set an unsupported TU size (e.g., 300 bytes, above the valid range)
Set a reserved TU size (e.g., 0 bytes, which is invalid)
Recover the default TU size (64 bytes) after invalid cases

function: scripts/management/03_mi_cmd_set_test.py::test_mi_configuration_set_invalid_port_id

Ensure Configuration Set rejects invalid or reserved port identifiers with the proper error code.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Use a Port Identifier that is not valid (e.g., a non-existent port)
Use a reserved Port Identifier (e.g., 0xFF which is not allowed for valid configurations)
Recover with a valid Port Identifier and TU size

function: scripts/management/03_mi_cmd_set_test.py::test_mi_message_header

Inspect NVMe-MI message headers for length, message type, and slot-specific bits.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Read the VPD (Vital Product Data) from the MI interface in the specified slot
Check the message length
Verify Message Type is 0x4
Verify Integrity Check (IC) bit is set to 1
Verify ROR (Response/Request) bit is set correctly
Verify NVMe-MI Message Type indicates an NVMe-MI Command
Verify the Command Slot Identifier

function: scripts/management/03_mi_cmd_set_test.py::test_mi_message_header_send_meb

Verify commands that do not support the MEB bit return an invalid parameter when it is set.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Read SMBus Port Information to determine if Management Endpoint Buffer is supported
read ep buffer shall not support MEB bit
read ep buffer without MEB bit
read ep buffer with MEB bit
Management Endpoint shall respond with an Invalid Parameter Error Response with the PEL field indicating the MEB bit.

function: scripts/management/03_mi_cmd_set_test.py::test_mi_vpd_read

Sweep VPD read lengths up to the TU limit to validate response sizing and integrity.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Read the SMBus port data structure to determine the TU limit before issuing reads
send vpd read command with different length

function: scripts/management/03_mi_cmd_set_test.py::test_mi_vpd_read_length

Probe VPD read offsets and lengths that cross the VPD boundary to confirm error handling.

Reference

NVMe-MI Specification Revision 1.2c

Steps

A VPD Read command with length 0 and no data is valid
Valid VPD read request within size limits
VPD read request with Data Length exceeding VPD size (invalid)
VPD read request with Data Offset + Data Length exceeding VPD size (invalid)

function: scripts/management/03_mi_cmd_set_test.py::test_mi_ep_buf_invalid_length

Submit Management Endpoint Buffer writes with mismatched data lengths to observe error returns.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Read SMBus Port Information to determine if Management Endpoint Buffer is supported
Initialize buffer with specified length
Test: Write buffer with length + 1 (mismatch with Data Length)
Test: Write buffer with length – 1 (mismatch with Data Length)
Test: Write buffer with correct length

function: scripts/management/03_mi_cmd_set_test.py::test_mi_ep_buf_offset

Exercise Management Endpoint Buffer writes across different offsets to ensure address handling is correct.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Read SMBus Port Information to determine if Management Endpoint Buffer is supported
Initialize buffer with specified length
Test valid buffer writes at various offsets

function: scripts/management/03_mi_cmd_set_test.py::test_mi_ep_buf_write_read

Verify data integrity across Management Endpoint Buffer write and read sequences at large transfer sizes.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Read SMBus Port Information to determine if Management Endpoint Buffer is supported
Write data to Management Endpoint Buffer
Read back the data from Management Endpoint Buffer
Validate the written data matches the read data
Test invalid buffer length > 4224 bytes
Read back the data from Management Endpoint Buffer

function: scripts/management/03_mi_cmd_set_test.py::test_mi_ep_buf_read_after_sanitize

Confirm sanitize operations clear the Management Endpoint Buffer and trigger appropriate MI status values.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Read SMBus Port Information to determine if Management Endpoint Buffer is supported
Write data to Management Endpoint Buffer
Read back the data from Management Endpoint Buffer
Validate the written data matches the read data
sanitize
check sanitize status in log page
responds with a Response Message Status of Management Endpoint Buffer Cleared Due to Sanitize

function: scripts/management/03_mi_cmd_set_test.py::test_mi_ep_buf_invalid_offset

Check Management Endpoint Buffer reads and writes at invalid offsets and length combinations.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Retrieve Management Endpoint Buffer size
Valid offset tests
Invalid offset tests
Invalid DOFST + DLEN combination tests

function: scripts/management/03_mi_cmd_set_test.py::test_mi_command_servicing_across_controller_reset

Ensure controller-level resets do not interrupt outstanding NVMe-MI command servicing.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Skip the test if the baseline VPD read command is not supported by the endpoint
Issue another MI command and reset the controller before fetching the response.

function: scripts/management/03_mi_cmd_set_test.py::test_mi_reset

Trigger an MI reset and confirm configuration registers and VPD access return to defaults.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Change SMBus/I2C Frequency to 3 and MCTP TU size to 100 bytes
Verify updated SMBus/I2C Frequency and MCTP TU size
Perform a VPD Read and save the response
Define a reset function and initialize the subsystem
reset mi only
Verify SMBus/I2C Frequency and MCTP TU size are reset to defaults
Verify VPD Read is functional after reset
Admin Command Set is still available even though the NVMe Controller may be disabled or held in reset
Perform NVMe reset and verify VPD Read
Send admin command and MI command at the same time
Ensure VPD response before and after NVMe reset are identical

function: scripts/management/03_mi_cmd_set_test.py::test_mi_shutdown_command

Exercise normal and abrupt MI shutdown types and verify subsystem behavior.

Reference

NVMe-MI Specification Revision 1.2c

Steps

shutdown controller with different type
Test Reserved Shutdown Type
Define a reset function and initialize the subsystem
A Management Controller should shutdown all NVMe Controllers in an NVM Subsystem prior to resetting the NVM Subsystem.
get identify again after reset

function: scripts/management/03_mi_cmd_set_test.py::test_mi_shutdown_abrupt_completion

Verify abrupt shutdown drives CSTS bits and increments dirty shutdown counter.

Reference

Management Interface Specification, Revision 1.2c.

Steps

Define helper accessors used to observe CSTS and the dirty shutdown counter
Ensure controller is ready and capture baseline dirty shutdown counter
Issue abrupt shutdown via MI (shutdown_type=0x01)
Wait until SHST10b and ST1 (shutdown complete per spec)
Recover controller to ready state for subsequent tests

function: scripts/management/03_mi_cmd_set_test.py::test_mi_vpd_read_offset_len

Read overlapping VPD ranges at different offsets to confirm data consistency.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Read 100 bytes from VPD at offset 0 and validate
read 51 bytes to VPD starting at offset 22
validate data buffer

function: scripts/management/03_mi_cmd_set_test.py::test_mi_vpd_read_while_sanitize

Demonstrate that VPD reads continue to operate while sanitize is in progress.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Skip when the device does not advertise sanitize capabilities
start sanitize operation
vpd read is allowed during a sanitize operation
check sanitize status in log page

function: scripts/management/03_mi_cmd_set_test.py::test_mi_vpd_read_while_format

Confirm VPD reads remain functional while a Format NVM command executes.

Reference

NVMe-MI Specification Revision 1.2c

Steps

Capture baseline VPD data prior to issuing the Format command
start the format command
VPD read is allowed during a format command
wait format command done

file: scripts/management/04_mi_admin_cmd_test

function: scripts/management/04_mi_admin_cmd_test.py::test_mi_admin_prohibited

Ensure the MI endpoint flags prohibited NVMe Admin opcodes with an Invalid Command warning.

Reference

NVM Express Management Interface Specification Revision 1.2c.

Steps

Issue an MI Admin command with a forbidden opcode and expect an Invalid Command warning.

function: scripts/management/04_mi_admin_cmd_test.py::test_mi_admin_get_log_page

Compare SMART log retrieval through MI Get Log Page against NVMe Admin results.

Reference

NVM Express Management Interface Specification Revision 1.2c.

Steps

Retrieve the SMART log through the MI transport.
Retrieve the SMART log via the NVMe Admin Get Log Page command.
Compare temperatures and buffers returned by both transports.

function: scripts/management/04_mi_admin_cmd_test.py::test_inband_admin_tunneling_prohibited

Verify that NVMe Admin commands cannot be tunneled through the in-band MI mechanism.

Reference

NVM Express Management Interface Specification Revision 1.2c.

Steps

Skip the test if the platform lacks MI Send or Receive in-band tunneling support.
Use MI out-of-band transport to capture a SMART log slice for comparison.
Prepare the MI message metadata used for tunneling NVMe Get Log Page.
Track the tunneled completion status provided by the callback.
Capture the MI completion status and error location from the callback path.
Attempt to issue an Admin command via in-band MI tunneling, which is prohibited.
MI message type 2 indicates NVMe Admin Command tunneling.
Validate that the MI transport rejected the tunneled Admin command.

function: scripts/management/04_mi_admin_cmd_test.py::test_mi_admin_get_log_page_without_controller

Confirm MI Get Log Page behavior without controller state and when applying offsets.

Reference

NVM Express Management Interface Specification Revision 1.2c.

Steps

Execute MI Get Log Page without a controller context to capture baseline data.
Fetch the same log with an explicit offset applied at the MI layer.
Compare the buffered data between offset and non-offset reads.
Request the log page with an invalid offset to confirm error handling.
Validate equivalent responses when combining SQE offset and MI request offset fields.

function: scripts/management/04_mi_admin_cmd_test.py::test_mi_admin_get_log_page_error_status

Exercise MI Get Log Page success paths and invalid parameter handling versus NVMe Admin.

Reference

NVM Express Management Interface Specification Revision 1.2c.

Steps

Define baseline log page IDs and windowing parameters for validation.
Compare MI and NVMe Admin responses for each mandatory log page.
Verify MI error reporting for invalid size and offset combinations.
Confirm payload size for a valid log page ID with regenerated data.
Request an unsupported log page ID to validate NVMe status reporting.

function: scripts/management/04_mi_admin_cmd_test.py::test_mi_admin_get_log_page_requires_rae

Demonstrate that tunneling Get Log Page with RAE cleared produces an Invalid Field status.

Reference

NVM Express Management Interface Specification Revision 1.2c.

Steps

Issue a tunneled Get Log Page with RAE cleared to zero.
Check that the NVMe completion status reports Invalid Field in Command.
Ensure aborted Get Log Page operations return no payload data.

function: scripts/management/04_mi_admin_cmd_test.py::test_mi_admin_aer_temperature

Validate MI-observed temperature events generated via NVMe Asynchronous Event Requests.

Reference

NVM Express Management Interface Specification Revision 1.2c.

Steps

Issue an Asynchronous Event Request (AER) command
Save original Over and Under Temperature Threshold settings
Enable all asynchronous events
Allocate buffer for SMART log and get the current temperature
Set Over Temperature Threshold to trigger AER
Send MI Get Log Page command to verify the event
Restore original Over Temperature Threshold
Set Under Temperature Threshold to trigger AER
Read SMART log to validate the critical warning
Restore original Under Temperature Threshold

function: scripts/management/04_mi_admin_cmd_test.py::test_mi_admin_identify

Confirm MI Identify responses match NVMe Admin Identify data for partial and full reads.

Reference

NVM Express Management Interface Specification Revision 1.2c.

Steps

Retrieve partial Identify data through MI.
Fetch the same Identify structure via NVMe Admin for comparison.
Retrieve the full Identify data through MI.
Compare entire Identify buffers between MI and NVMe Admin transports.

function: scripts/management/04_mi_admin_cmd_test.py::test_mi_admin_ep_buf_identify

Verify MI Identify functionality when routed through the Management Endpoint Buffer.

Reference

NVM Express Management Interface Specification Revision 1.2c.

Steps

if 0x0206 not in mi.ep_buf_commands:
pytest.skip(“identify not support EP buffer”)
Read the Management Endpoint Buffer size from the MI data structure.
Retrieve partial Identify data via MI without using the endpoint buffer.
Compare the MI data against a direct NVMe Admin Identify command.
Exercise endpoint buffer write and read primitives.
Send MI Identify while directing data into the endpoint buffer.
Read back the endpoint buffer contents.
Send an NVMe Identify command in-band for comparison.
Compare the endpoint buffer contents against the NVMe Identify data.

function: scripts/management/04_mi_admin_cmd_test.py::test_mi_admin_timestamp

Use MI Set Features to program the timestamp and poll it while changing power states.

Reference

NVM Express Management Interface Specification Revision 1.2c.

Steps

Program the controller timestamp via MI while entering the target power state.
Drive the controller into the requested power state and verify support.
Poll the timestamp through MI and ensure monotonic growth at the expected rate.
Restore the controller to power state 0 after polling completes.

function: scripts/management/04_mi_admin_cmd_test.py::test_mi_admin_command_servicing_across_controller_reset

Ensure MI-tunneled Admin commands continue to execute across controller-level resets.

Reference

NVM Express Management Interface Specification Revision 1.2c.

Steps

Capture a baseline MI Get Log Page response prior to reset.
Disable the controller to force a controller-level reset.
Issue the same MI Get Log Page request following the reset.
Verify the post-reset data matches the baseline response.

function: scripts/management/04_mi_admin_cmd_test.py::test_mi_admin_identify_diff_slot

Confirm MI Identify responses are consistent across slots and match NVMe Admin data.

Reference

NVM Express Management Interface Specification Revision 1.2c.

Steps

Send an NVMe Admin Identify command and capture the complete data structure.
Send an MI Identify command using slot 0 and compare against the Admin data.
Repeat the MI Identify command using slot 1 and compare the buffer again.

function: scripts/management/04_mi_admin_cmd_test.py::test_mi_admin_invalid_input_data_size

Check MI rejects Admin requests whose payload exceeds the declared data length.

Reference

NVM Express Management Interface Specification Revision 1.2c.

Steps

Build a payload that is larger than the advertised data transfer size.
Attempt the transfer and expect the MI Invalid Input Data Size warning.

function: scripts/management/04_mi_admin_cmd_test.py::test_mi_fw_download

Transfer firmware chunks through MI Download commands while sweeping link frequency.

Reference

NVM Express Management Interface Specification Revision 1.2c.

Steps

Configure the requested link frequency for the MI port.
Read back the configuration to ensure the new frequency is active.
Slice the firmware image into chunks that match the MI transfer unit.
Stream each chunk via MI NVMe Firmware Download and retry on transient errors.
Record the total transfer time and ensure no retries were needed.

function: scripts/management/04_mi_admin_cmd_test.py::test_mi_logpage_lockdown

Read the MI lockdown log page and verify the payload is accessible via Get Log Page.

Reference

NVM Express Management Interface Specification Revision 1.2c.

Steps

Fetch the lockdown log page and log the raw payload for review.

function: scripts/management/04_mi_admin_cmd_test.py::test_namespace_delete_all

Remove every namespace on the controller via the MI Delete Namespace command.

Reference

NVM Express Management Interface Specification Revision 1.2c.

Steps

Issue the MI Delete Namespace command targeting all namespaces.

function: scripts/management/04_mi_admin_cmd_test.py::test_create_single_ns

Provision a single 4 KiB namespace for subsequent tests via NVMe Admin commands.

Reference

NVM Express Base Specification Revision 1.4b.

Steps

Invoke the shared helper to create one namespace with a 4 KiB LBA format.

file: scripts/management/05_mi_control_primitive_test

function: scripts/management/05_mi_control_primitive_test.py::test_mi_slot_pause_flag

Verify dual-slot states stay independent and Pause flag behaves globally.

Reference

Management Interface Specification, Revision 1.2c.

Steps

verify both slots start idle
send only the first admin-packet on slot0 so it stays in Receive
verify slot0 active and slot1 idle
send a complete MI command on slot1
verify slot0 still receiving and slot1 processing
pause command servicing and verify global pause flag
resume command servicing and verify pause flag cleared
verify pause flag cleared on both slots

function: scripts/management/05_mi_control_primitive_test.py::test_mi_cmnics_on_new_cmd_when_non_idle

Verify CMNICS is set when a new Command Message starts on a non-Idle slot.

Reference

Management Interface Specification, Revision 1.2c.

Steps

make slot0 non-idle by sending only the first packet of a firmware download
start another command on the same non-idle slot0 (new SOM while not Idle)
verify CMNICS is set in Get State (Figure 43 error/state flags)
assert (s.data(7, 6) & 0x0008) != 0 # CMNICS == 1
verify slot remains active servicing (either old continues or new accepted)
send remaining packets and collect the response

function: scripts/management/05_mi_control_primitive_test.py::test_mi_idle_receive_and_replay_transmit

Verify Idle→Receive on first packet and Replay→Transmit when response available.

Reference

Management Interface Specification, Revision 1.2c.

Steps

attempt to replay with no prior response available
issue a short-response command to generate a single-packet response
replay the last response and drain it to avoid mixing packets
verify slot returns to idle after replay completes

function: scripts/management/05_mi_control_primitive_test.py::test_mi_receive_state_transitions

Verify Receive→Idle and Receive→Process transitions.

Reference

Management Interface Specification, Revision 1.2c.

Steps

enter Receive by only sending the first packet
abort while receiving → Idle
trigger assembly error by skipping the first packet
trigger MIC error by injecting bad CRC32
check BMICE flag (bit4 indicates integrity error)
try receiving to confirm the bad message was silently discarded

function: scripts/management/05_mi_control_primitive_test.py::test_mi_process_state_transitions

Verify Process transitions: completion→Transmit (even when paused) and Abort→Idle.

Reference

Management Interface Specification, Revision 1.2c.

Steps

assemble a short command and pause before completion
verify completion drives Transmit regardless of Pause
abort during processing → Idle (if abortable)

function: scripts/management/05_mi_control_primitive_test.py::test_mi_transmit_state_transitions

Verify Transmit→Idle after full response or Abort, and Transmit→Process for MPR.

Reference

Management Interface Specification, Revision 1.2c.

Steps

transmit→idle after full response
transmit→idle after abort

function: scripts/management/05_mi_control_primitive_test.py::test_mi_pause_behavior

Verify Pause behavior: global flag, idempotent, CPSR bits, and response suspension.

Reference

Management Interface Specification, Revision 1.2c.

Steps

pause in idle has no effect
pause in receive and verify global pause flag
pause again and verify global pause flag remains set (idempotent)
verify CSI must be 0: pause with CSI=1 should return Invalid Parameter with PEL (CSI bit)
issue a command while paused; command responses are suspended while CP responses are not
resume and drain the pending response; pause flag clears and slot returns to idle

function: scripts/management/05_mi_control_primitive_test.py::test_mi_abort_behavior

Verify Abort behavior: Idle transition, CPAS/CPSR, pause clear, resume other-slot transmit, and discard replay.

Reference

Management Interface Specification, Revision 1.2c.

Steps

abort in idle state has no effect
make slot0 busy (Receive) to be a valid abort target
abort slot0 and check CPSR/CPAS and pause clearing (Abort response is success)
set state to pause state
abort in pause state

function: scripts/management/05_mi_control_primitive_test.py::test_mi_abort_cpas_by_state

Verify Abort CPAS mapping by servicing state (Idle/Receive/Process/Transmit).

Reference

Management Interface Specification, Revision 1.2c.

Steps

idle → CPAS=00b
receive → CPAS=01b
verify slot0 active and slot1 idle
abort while receiving
process → CPAS=01b or 10b（before/after affecting subsystem）

function: scripts/management/05_mi_control_primitive_test.py::test_mi_umep_flags

Verify UMEP (Unexpected Middle or End of Packet) flags.

Reference

Management Interface Specification, Revision 1.2c.

Steps

inject unexpected middle/end of packet to trigger UMEP

function: scripts/management/05_mi_control_primitive_test.py::test_mi_reset_flag

Verify NSSRO (NVM Subsystem Reset Occurred) flag reporting with mi reset

Reference

Management Interface Specification, Revision 1.2c.

Steps

issue several commands while toggling pause; NSSRO should not be set by normal traffic
Define a reset function and initialize the subsystem
reset mi only
check reset flag

function: scripts/management/05_mi_control_primitive_test.py::test_mi_control_primitives_survive_controller_reset

Controller Level Reset shall not disrupt MI control primitive servicing.

Reference

NVM Express Base Specification, Controller Level Reset behavior.

Steps

Issue Get State with a known tag and trigger controller level reset before reading it.
Control primitives remain available after the reset.

function: scripts/management/05_mi_control_primitive_test.py::test_mi_replay_basic_behavior

Verify Replay clears Pause flag and retransmits the last command response.

Reference

Management Interface Specification, Revision 1.2c.

Steps

generate a replayable response
pause endpoint to simulate suspended transmissions
replay both slots

function: scripts/management/05_mi_control_primitive_test.py::test_mi_replay_with_rro

Verify Replay with Response Replay Offset (RRO) and RR bit in CPSR.

Reference

Management Interface Specification, Revision 1.2

Steps

generate a replayable response
replay with RRO = 0 → full replay expected, RR=1
replay with RRO within valid range
the response message without first packet is invalid
replay again from the beginning
replay after abort and RR shall be cleared to 0
nothing to replay after abort

function: scripts/management/05_mi_control_primitive_test.py::test_mi_nssro_flag

Verify NSSRO (NVM Subsystem Reset Occurred) flag reporting and clearing.

Reference

Management Interface Specification, Revision 1.2c.

Steps

issue several commands while toggling pause; NSSRO should not be set by normal traffic
verify NSSRO is not command-slot specific (read with slot parameter should match)

function: scripts/management/05_mi_control_primitive_test.py::test_mi_replay_idle_no_response

Verify Replay in Idle with no cached response → RR=0.

Reference

Management Interface Specification, Revision 2.1.

Steps

ensure no cached response
replay when nothing to retransmit → RR=0

function: scripts/management/05_mi_control_primitive_test.py::test_mi_servicing_model_dual_slot

Validate independent operation of dual command slots in MI.

Reference

Management Interface Specification, Revision 1.2c.

Steps

skip test if VPD Read command not supported
read VPD with complete packets using slot 0 and 1
send a request only packet 0 in slot 0
read again on slot 1 while slot 0 is receiving
try to read on slot 0 while it is still receiving
complete the command on slot 0
read VPD again on both slots to verify normal operation

function: scripts/management/05_mi_control_primitive_test.py::test_mi_control_primitive_tag

Verifies that the Response Message contains the same value in the Tag field as the corresponding Request Message.

Reference

Management Interface Specification, Revision 1.2c.

Steps

Send a Get State command with the specified tag and receive the response
Verify that the response message has the same tag as the request
send many command with different tags
check all responsed tags, only the response associated with the last Control Primitive are guaranteed

file: scripts/management/06_mi_pcie_cmd_test

function: scripts/management/06_mi_pcie_cmd_test.py::test_mi_pcie_cfg_read

PCIe Configuration Read

Reference

Management Interface Specification, Revision 1.2c.
7.1 PCIe Configuration Read

Steps

Send PCIe Configuration Read command
check PCIe Configuration Read data

function: scripts/management/06_mi_pcie_cmd_test.py::test_mi_pcie_cfg_read_bar_access

A Management Endpoint that supports PCIe commands must service BAR accesses.

Reference

Management Interface Specification, Revision 1.2c.

Steps

check if PCIe Config Read is supported
BAR0/1 registers sit at offsets 0x10-0x17; spec requires they return data, not Access Denied.
compare BAR content with direct PCIe view

function: scripts/management/06_mi_pcie_cmd_test.py::test_mi_pcie_cfg_read_offset_overflow

NVMe-MI PCIe Config Read should fail when offset+length exceed config space.

Reference

Management Interface Specification, Revision 1.2c.

Steps

check if PCIe Config Read is supported
Boundary checks: these requests stay fully within the 4KB PCIe config space.
Offset+length exceeds 4KB boundary, expect Invalid Parameter (PEL -> Offset field).
Length = 1 at the last byte is valid.
Reading 2 bytes from 0xfff straddles the boundary, should fault.

function: scripts/management/06_mi_pcie_cmd_test.py::test_mi_pcie_cfg_read_d3hot

PCIe command either succeeds or returns PCIe Inaccessible while controller in non-D0 state.

Reference

Management Interface Specification, Revision 1.2c.

Steps

Confirm baseline behaviour in D0.
Enter D3hot (non-D0 state) and attempt a PCIe command.
Exit D3hot and verify PCIe commands succeed again.

function: scripts/management/06_mi_pcie_cmd_test.py::test_mi_pcie_command_status_during_controller_reset

PCIe command responses are either serviced or return PCIe Inaccessible.

Reference
N/A

Steps

Confirm baseline behaviour prior to reset.
Start another PCIe command and reset controller before collecting the response.
PCIe port remained accessible, so data must match the config space.
If affected, spec mandates PCIe Inaccessible completion status.
PCIe command servicing resumes after reset.

file: scripts/management/07_mi_feature_test

function: scripts/management/07_mi_feature_test.py::test_mi_feature_configuration_set_and_reset

Set Mi configuration and mi reset

Reference

Management Interface Specification, Revision 1.2c.
8.3.1 NVM Subsystem Reset

Steps

get default MCTP Transmission Unit Size
set MCTP Transmission Unit Size=128byte
get current MCTP Transmission Unit Size
issue mi reset
get current MCTP Transmission Unit Size

function: scripts/management/07_mi_feature_test.py::test_mi_feature_set_mctp_tu_size

Test for setting and verifying MCTP Transmission Unit (TU) Size and performing VPD reads.

Reference

NVM Express® Management Interface Specification, Revision 1.2c

Steps

Set MCTP Transmission Unit Size to 64 bytes
Retrieve current MCTP Transmission Unit Size to verify it has been set to 64 bytes
Perform initial VPD read of 100 bytes
Set MCTP Transmission Unit Size to 128 bytes
Confirm new MCTP Transmission Unit Size of 128 bytes
Perform VPD read again and ensure consistency
Compare the two VPD read buffers to ensure data integrity
Reset MCTP Transmission Unit Size back to 64 bytes for cleanup
Confirm the reset to 64 bytes

function: scripts/management/07_mi_feature_test.py::test_mi_feature_ep_buf_full

Full Management Endpoint Buffer and verify

Reference

Management Interface Specification, Revision 1.2c.
5.5 Management Endpoint Buffer Write

Steps

read Management Endpoint Buffer Size
full check Management Endpoint Buffer

function: scripts/management/07_mi_feature_test.py::test_mi_feature_ep_buf_reset

Reset Management Endpoint Buffer

Reference

Management Interface Specification, Revision 1.2c.
5.5 Management Endpoint Buffer Write

Steps

read Management Endpoint Buffer Size
Management Endpoint Buffer Write special data and check
read Management Endpoint Buffer after controller reset
issue MI Reset
read Management Endpoint Buffer after MI reset

function: scripts/management/07_mi_feature_test.py::test_mi_feature_ep_buf_sanitize

Validate that the Management Endpoint Buffer is cleared to 0h during a sanitize operation.

Reference

Management Interface Specification, Revision 1.2c.

Steps

Read Management Endpoint Buffer Size
Check if sanitize operation is supported
Full Management Endpoint Buffer
Sanitize operation
check error status of Management Endpoint Buffer Cleared Due to Sanitize. Thi

function: scripts/management/07_mi_feature_test.py::test_mi_feature_disable_ccen

disable nvme and send mi command

Reference

Management Interface Specification, Revision 1.2c.
6 NVM Express Admin Command Set

Steps

send nvme identify command
set nvme cc.en=0
send mi identify command
check identify data
check the controller is disabled

function: scripts/management/07_mi_feature_test.py::test_mi_feature_d3hot

enter pcie d3hot and send mi command

Reference

Management Interface Specification, Revision 1.2c.
6 NVM Express Admin Command Set

Steps

send nvme identify command
enter pcie d3hot
send mi identify command
enter pcie d0
check identify data

function: scripts/management/07_mi_feature_test.py::test_mi_feature_command_latency

test mi command latency with io

Reference

Management Interface Specification, Revision 1.2c.
5.11 VPD Read

Steps

get current SMBus/I2C Frequency
vpd read 256 bytes 100 cycles
vpd read 256 bytes 100 cycles with ioworker running
compare the time

function: scripts/management/07_mi_feature_test.py::test_mi_feature_io_with_periodic_oob_reset

Run random-read IO for 60 seconds while issuing MI resets every second.

Reference
N/A

Steps

start read IO workload
issue MI resets periodically during IO
log results

function: scripts/management/07_mi_feature_test.py::test_mi_duplicated_slot

Verifies that the Management Controller should not send a new command to a slot until the previous command’s response is received.

Reference

NVM Express® Management Interface Specification, Revision 1.2c

Steps

Read VPD data in different slots to confirm slots 0 and 1 are operational
send two commands in both slots without waiting for previous responses
send another two commands in both slots without waiting for previous responses

function: scripts/management/07_mi_feature_test.py::test_mi_dual_slot_concurrent

Validate VPD read consistency across dual slots (slot 0 and slot 1).

Reference

NVMe Management Interface Specification, Revision 1.2c

Steps

skip if VPD read command is not supported
Perform initial VPD read from slot 0
Perform consecutive VPD reads from both slots
Verify data consistency in both slots across reads

function: scripts/management/07_mi_feature_test.py::test_mi_nvm_subsystem_report

Validate the NVM Subsystem Report (NVMSR) field to verify NVMe Storage Device status.

Reference

NVMe Management Interface Specification, Revision 1.2c

Steps

skip if NVMe spec version is below 2.0
Retrieve NVMSR field from the Identify Controller data structure
Verify that the NVMSR field is set to 1 for an NVMe Storage Device
print FGUID

file: scripts/management/08_mi_error_inject_test

function: scripts/management/08_mi_error_inject_test.py::test_mi_unexpected_eom

Validate unexpected EOM handling and confirm UMEP reporting behavior.

Reference

Based on NVM Express Management Interface Specification 1.2c.

Steps

Reset MI error state to start clean
Send two partial commands to create a Receive → Process transition.
Inject an unexpected EOM (missing SOM) and confirm UMEP is reported.

function: scripts/management/08_mi_error_inject_test.py::test_mi_invalid_som_and_eom

Verify SOM/EOM error handling during MI VPD and Identify commands.

Reference

Based on NVM Express Management Interface Specification 1.2c.

Steps

Check VPD read support before exercising error cases
Reset MI error state to isolate injected errors
Send a baseline VPD read command with valid headers
Send a VPD read with correct SOM/EOM values to confirm clean completion
Send a VPD read with SOM only while clearing EOM
Send a VPD read with EOM only while clearing SOM
Send a VPD read with both SOM and EOM cleared
Send a normal MI Identify command to ensure baseline success
Send MI Identify command split with intentionally incorrect EOM marker
The error command shall be discarded
Clear all error state flags after validation

function: scripts/management/08_mi_error_inject_test.py::test_mi_bad_mctp_version

Send MI command with bad MCTP version to ensure BHVS flag is asserted.

Reference

Based on NVM Express Management Interface Specification 1.2c.

Steps

Start from a clean state so only the injected error affects the flags
Force an invalid MCTP version value in the first packet header
Issue a standard Identify command; the corrupted header should be rejected
Check MI state for BHVS flag after processing the invalid header
Attempt to receive response and confirm it is silently discarded, triggering warning

function: scripts/management/08_mi_error_inject_test.py::test_mi_invalid_integrity_check

Check invalid integrity check handling in NVMe-MI admin commands.

Reference

Based on NVM Express Management Interface Specification 1.2c.

Steps

Reset MI error state before injecting IC fault
Send a valid NVMe Admin command and ensure response without errors
Verify the state is in Idle
Inject an invalid integrity check (IC) and send the command again
Send the same admin command with invalid integrity check
Attempt to receive response and confirm it is silently discarded, triggering warning

function: scripts/management/08_mi_error_inject_test.py::test_mi_invalid_mic_crc32

Inject CRC32 corruption into MI command and verify BMICE reporting.

Reference

Based on NVM Express Management Interface Specification 1.2c.

Steps

Reset MI error state before CRC injection
Inject an error into the CRC32 value of the MCTP header and send an identify command
Wait briefly to allow the error to be processed
Check the state control field for the BMICE flag (bit 4 should be set to ‘1’ to indicate an integrity error)
Attempt to receive the response and confirm it is silently discarded, triggering a warning
Verify again that the MI has returned to the Idle state after handling the error
Clear error state flag after confirming BMICE behavior
Ensure the error flag is cleared following cleanup

function: scripts/management/08_mi_error_inject_test.py::test_mi_invalid_offset

Issue MI NVMe Admin commands with invalid offsets and expect errors.

Reference

Based on NVM Express Management Interface Specification 1.2c.

Steps

Send MI Identify command with misaligned offset
Validate the reported parameter error location
Send MI Identify command with offset beyond completion data size

function: scripts/management/08_mi_error_inject_test.py::test_mi_invalid_length

Issue MI NVMe Admin commands with invalid lengths and expect errors.

Reference

Based on NVM Express Management Interface Specification 1.2c.

Steps

Send MI Identify command with length shorter than expected
Send MI Identify command with length beyond completion data size

function: scripts/management/08_mi_error_inject_test.py::test_mi_invalid_opcode

Validate MI error reporting for unsupported NVMe Admin and MI opcodes.

Reference

Based on NVM Express Management Interface Specification 1.2c.

Steps

Send MI NVMe Admin command with unsupported opcode
Send MI command with invalid opcode

function: scripts/management/08_mi_error_inject_test.py::test_mi_invalid_nvme_command

Verify MI surfaces NVMe internal error status for bad Identify command.

Reference

Based on NVM Express Management Interface Specification 1.2c.

Steps

Send MI NVMe Admin Identify command expected to trigger internal error
Check NVMe completion status field is non-zero to reflect error

file: scripts/management/09_mi_stress_test

function: scripts/management/09_mi_stress_test.py::test_mi_stress_mix_nvme_cmd

test mi command mix io command

Reference

Management Interface Specification, Revision 1.2c.
6 NVM Express Admin Command Set

Steps

send different mi command
random read, get io latency
mixing io and mi commands
check if the mi command is correct
check for io latency changes

function: scripts/management/09_mi_stress_test.py::test_mi_stress_cmd_ctrl_mix

Control Primitives Mix

Reference

Management Interface Specification, Revision 1.2c.
4.2.1 Control Primitives

Steps

mix send different mi command

function: scripts/management/09_mi_stress_test.py::test_mi_stress_io_with_mi_reset

IO and mi reset

Reference

Management Interface Specification, Revision 1.2c.
5.8 Reset

Steps

issue mi reset
mi reset during io

function: scripts/management/09_mi_stress_test.py::test_mi_stress_control_primitives_survive_controller_reset

Repeated controller resets shall not disrupt Control Primitive servicing.

Reference

Management Interface Specification, Revision 1.2c.

Steps

Send multiple Get State commands with unique tags, resetting the controller

function: scripts/management/09_mi_stress_test.py::test_mi_stress_command_servicing_across_controller_reset

MI command servicing must stay alive through repeated controller resets.

Reference

Management Interface Specification, Revision 1.2c.

Steps

Skip test if VPD Read command is not supported
Get baseline VPD data
Repeatedly issue VPD Read commands with controller resets in between

function: scripts/management/09_mi_stress_test.py::test_mi_stress_admin_command_servicing_across_controller_reset

Admin commands tunneled via MI must survive repeated resets.

Reference

Management Interface Specification, Revision 1.2c.

Steps

Get baseline Log Page data
Repeatedly issue Get Log Page commands with controller resets in between

function: scripts/management/09_mi_stress_test.py::test_mi_stress_pcie_command_status_during_controller_reset

PCIe Config commands should either complete or return PCIe Inaccessible.

Reference
N/A

Steps

Skip test if PCIe Config Read command is not supported
Prepare expected data
Repeatedly issue PCIe Config Read commands with controller resets in between

function: scripts/management/09_mi_stress_test.py::test_mi_stress_diff_slot

Send mi commands with different slots

Reference

Management Interface Specification, Revision 1.2c.
4 Message Servicing Model

Steps

get response of different mi command in slot 0
send different mi command in slot 0 and slot 1

function: scripts/management/09_mi_stress_test.py::test_mi_stress_basic_management_mix

mi command and basic management mixed

Reference

Management Interface Specification, Revision 1.2c.
4 Message Servicing Model

Steps

mix send mi command and basic management command
mi configuration get command
smbus block read of the drive’s status
mi read mi data structure command
smbus block read of the drive’s static data
mi vpd read
i2c.i2c_master_write(i2c.ENDPOINT, [0xff], flags=pyaardvark.I2C_NO_STOP)
mi identify command

function: scripts/management/09_mi_stress_test.py::test_mi_stress_inband_oob_cmd_mix

mi command and out of band command mixed

Reference

Management Interface Specification, Revision 1.2c.

Steps

skip if mi command is not supported
mix send mi command and basic management command
mi configuration get command
send mi command to get configuratrion of Health Status Change
mi read mi data structure command
send mi command to set configuration of Health Status Change
mi vpd read
mi identify command

function: scripts/management/09_mi_stress_test.py::test_mi_large_message

mi command with different length of packets

Reference

Management Interface Specification, Revision 1.2c.

Steps

send vpd read command with different length
send read mi data structure command with different length

function: scripts/management/09_mi_stress_test.py::test_mi_dual_slot_thread_commands

send commands in both slots

Reference

Management Interface Specification, Revision 1.2c.

Steps

get response of cmd1 in slot0
get response of cmd2 in slot1
define first thread for cmd1
define second thread for cmd2
start both threads
get and verify all responses in main thread
wait both threads complete

function: scripts/management/09_mi_stress_test.py::test_mi_stress_longtime

keep nvme and mi mixed operations for long time

Reference

Management Interface Specification, Revision 1.2c.

Steps

format the namespace first
Collect all ioworkers
Start all ioworkers
Mix mi commands and i2c basic management commands
Close all ioworkers

file: scripts/management/10_mi_ocp_test

function: scripts/management/10_mi_ocp_test.py::test_ocp_update_data_byte_write

Check Firmware Update Flags field

Reference

Datacenter NVMe SSD Specification, Revision 2.6

Steps

Read current data from the device
Calculate and update PEC before writing back
Read data again for verification
Revert to original value without pec
Read data again for verification
Validate that the data remains unchanged after the update

function: scripts/management/10_mi_ocp_test.py::test_ocp_read_firmware_update_flags

Check Firmware Update Flags field

Reference

Datacenter NVMe SSD Specification, Revision 2.6. SMBUS-4

Steps

send NVMe Basic Management Command opcode 90
check Firmware Update Flags field (byte 91) in the SMBus Data structure shall be set to FFh

function: scripts/management/10_mi_ocp_test.py::test_ocp_read_secure_boot_failure_reporting

Check Firmware Update Flags field

Reference

Datacenter NVMe SSD Specification, Revision 2.6. SMBUS-5

Steps

send NVMe Basic Management Command opcode 242
The Secure Boot Failure Feature Reporting Supported bit at offset 243 shall be supported and set to 1b.

function: scripts/management/10_mi_ocp_test.py::test_ocp_read_basic_mgmt_delay

Check NVMe Basic Management Command time

Reference

Datacenter NVMe SSD Specification, Revision 2.6. SMBUS-7

Steps

read Controller Capabilities Timeout value
get NVMe Basic Management Command time
The device shall take no longer than the CAP.TO timeout value to produce stable SMBus output through the NVMe Basic Management Command

function: scripts/management/10_mi_ocp_test.py::test_ocp_update_data_block_write

Test NVMe-MI data update via I2C.

Reference

Datacenter NVMe SSD Specification, Revision 2.6. SMBUS-10

Steps

Read current data from the device
Calculate and update PEC before writing back
The device shall check the PEC value sent when the host issues a Block Write and only process the message if the PEC value matches the SMBus data format
Read data again for verification
revert to original value
Read data again for verification
Validate that the data remains unchanged after the update

function: scripts/management/10_mi_ocp_test.py::test_mi_level0_discovery

send tcg level0 discovery over smbus

Reference

Datacenter NVMe SSD Specification, Revision 2.5
11.3 NVMe-MI Requirements

Steps

send tcg level0 discovery over smbus

function: scripts/management/10_mi_ocp_test.py::test_mi_device_self_test

send device self test command over smbus

Reference

Datacenter NVMe SSD Specification, Revision 2.5
11.3 NVMe-MI Requirements

Steps

send device self test command over smbus

function: scripts/management/10_mi_ocp_test.py::test_mi_log_page_device_self_test

Validate device self-test log page (page ID 0x6) over SMBus.

Reference

Datacenter NVMe SSD Specification, Revision 2.5.
Section 11.3: NVMe-MI Requirements.

Steps

Start a short Device Self-Test (DST) and record start time
Retrieve the device self-test log through MI
Issue a format command to abort the DST
Retrieve the device self-test log through MI again

function: scripts/management/10_mi_ocp_test.py::test_mi_log_page_sanitize

Validate sanitize log page (page ID 0x81) over SMBus.

Reference

Datacenter NVMe SSD Specification, Revision 2.5.
Section 11.3: NVMe-MI Requirements.

Steps

Send sanitize command over smbus
Issue another Block Erase sanitize command
Monitor sanitize status via MI log page
Retrieve sanitize log page through MI
Extract status and progress from the log data
Validate sanitize completion

function: scripts/management/10_mi_ocp_test.py::test_mi_log_page_extended_smart_log

Validate extended SMART/Health log page (page ID 0xC0) over SMBus.

Reference

Datacenter NVMe SSD Specification, Revision 2.5.
Section 11.3: NVMe-MI Requirements.

Steps

Retrieve the extended SMART/Health log through MI
Retrieve the same extended SMART/Health log through NVMe Admin
Compare the data retrieved through MI and NVMe Admin

function: scripts/management/10_mi_ocp_test.py::test_mi_log_page_persistent_event_log

Validate persistent event log page (page ID 0xD) over SMBus.

Reference

Datacenter NVMe SSD Specification, Revision 2.5.
Section 11.3: NVMe-MI Requirements.

Steps

Reset the NVMe controller
Retrieve persistent event log (LSP = 1) through MI
Retrieve persistent event log (LSP = 0) through MI

function: scripts/management/10_mi_ocp_test.py::test_mi_log_page_telemetry_host_initiated_log

send get log page pageid(0xd) command over smbus

Reference

Datacenter NVMe SSD Specification, Revision 2.5
11.3 NVMe-MI Requirements

Steps

get persistent event log log through mi

function: scripts/management/10_mi_ocp_test.py::test_mi_log_page_telemetry_controller_initiated_log

send get log page pageid(0x8) command over smbus

Reference

Datacenter NVMe SSD Specification, Revision 2.5
11.3 NVMe-MI Requirements

Steps

get persistent event log log through mi

function: scripts/management/10_mi_ocp_test.py::test_mi_feature_temperature_threshold

Validate temperature threshold feature using MI commands.

Reference

Datacenter NVMe SSD Specification, Revision 2.5.
Section 11.3: NVMe-MI Requirements.

Steps

Retrieve original temperature threshold configuration
Set a new temperature threshold using MI
Verify the new configuration through NVMe Admin command
Restore the original temperature threshold configuration

function: scripts/management/10_mi_ocp_test.py::test_mi_diff_host_smbus_frequency

Validate MI command functionality under different SMBus host frequencies.

Reference

Datacenter NVMe SSD Specification, Revision 2.5.
Section 11.3: NVMe-MI Requirements.

Steps

Initialize host with different SMBus frequencies
Prepare a buffer for the NVMe firmware download command
Send an NVMe firmware download command via MI

function: scripts/management/10_mi_ocp_test.py::test_smbus_prepare_to_arp

Test for sending the Prepare to ARP command using SMBus protocol.

Reference

System Management Bus (SMBus) Specification Version 3.2, 6.6.3.2 Prepare to ARP

Steps

Send ARP address with command
Send the SMBus command with PEC
send command with wrong PEC

function: scripts/management/10_mi_ocp_test.py::test_smbus_get_udid

get UDID of an SMBus device.

Reference

Datacenter NVMe SSD Specification, Revision 2.6. NVMe-MI-6

Steps

send get udid SMBus command
send another get udid SMBus command
verify the data, assume no random number
fetch the UDID from the packet
check UDID fields

function: scripts/management/10_mi_ocp_test.py::test_spdm_get_version

Get SPDM Version

Reference

Security Protocol and Data Model (SPDM) Specification, Version: 1.0.2
4.9.1.1 GET_VERSION request message and VERSION response message

Steps

send get SPDM version command over smbus

file: scripts/management/11_spdm_test

function: scripts/management/11_spdm_test.py::test_spdm_get_version

Validate SPDM VERSION response (VersionNumberEntry count and entries) for a GET_VERSION request.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Transmit GET_VERSION and receive the corresponding VERSION response.
Check SPDM message header fields in the VERSION response.
Parse VersionNumberEntry count from the payload.
Iterate over VersionNumberEntry array and log each advertised version.

function: scripts/management/11_spdm_test.py::test_spdm_get_version_invalid_version

Validate GET_VERSION with invalid Version encodings returns an ERROR response.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Send GET_VERSION using invalid Version encodings and expect an ERROR response.

function: scripts/management/11_spdm_test.py::test_spdm_get_version_multiple

After receiving GET_VERSION, the Responder cancels any previous outstanding requests from the same Requester.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Interleave GET_VERSION and GET_CAPABILITIES, then issue GET_VERSION again.
Send GET_VERSION twice; only the latest request should be serviced.
Validate the captured VERSION response header.

function: scripts/management/11_spdm_test.py::test_spdm_get_version_latency

Measure GET_VERSION request latency and verify it is within the expected threshold.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Issue GET_VERSION request.
Start timing prior to receiving the VERSION response.
Receive the VERSION response.
Compute elapsed time in seconds.
Log latency in microseconds.
Threshold check: latency must be < 100 ms.

function: scripts/management/11_spdm_test.py::test_spdm_get_capabilities

GET_CAPABILITIES and verify CAPABILITIES response fields and flags.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Perform version discovery then request CAPABILITIES.
Repeat capability discovery after a fresh GET_VERSION.
Verify CAPABILITIES response header fields per SPDM.
CTExponent → cryptographic timeout (ms).
CAPABILITIES Flags.
Selected capability bits per SPDM flags layout.
Reserved bits example check (kept disabled as in the original).
assert flags & 0xFFFC0000 == 0, “reserved bits shall be zero”
DataTransferSize and MaxSPDMmsgSize.
PSK_CAP must not use the reserved value 0b11.

function: scripts/management/11_spdm_test.py::test_spdm_get_capabilities_invalid_flag

GET_CAPABILITIES with an invalid Flags value and verify ERROR handling.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Issue GET_VERSION then GET_CAPABILITIES with an invalid Flags encoding.
Verify Header.Version in the captured response.

function: scripts/management/11_spdm_test.py::test_spdm_get_capabilities_multiple

Multiple GET_CAPABILITIES requests and verification of expected responses.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

GET_VERSION then GET_CAPABILITIES.
GET_CAPABILITIES before GET_VERSION → expect ERROR 0x04.
Refresh connection discovery then request CAPABILITIES again.

function: scripts/management/11_spdm_test.py::test_spdm_get_capabilities_invalid_version

Test GET_CAPABILITIES with invalid SPDM versions and expect an ERROR response.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Discover supported VersionNumberEntry values.
Candidate invalid Version encodings.
For versions not advertised by the Responder, expect ERROR on GET_CAPABILITIES.

function: scripts/management/11_spdm_test.py::test_spdm_get_capabilities_invalid_flags

Send GET_CAPABILITIES with invalid parameter encodings and expect ERROR; verify header fields in the response.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

perform VERSION discovery before capability disclosure
request CAPABILITIES with an invalid Flags bitmap and expect ERROR
request CAPABILITIES with an invalid DataTransferSize and expect ERROR
request CAPABILITIES with invalid MaxSPDMmsgSize relative to DataTransferSize and expect ERROR
verify Header.Version in the captured response

function: scripts/management/11_spdm_test.py::test_spdm_get_capabilities_check_resp_flags

Check CAPABILITIES response flags and cross-field constraints.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

perform VERSION discovery then request CAPABILITIES with a specific Flags mask
if ENCRYPT_CAP == 1 then KEY_EX_CAP == 1 or PSK_CAP in {1,2}
if MEAS_CAP == 1 then KEY_EX_CAP == 1 or PSK_CAP in {1,2}
if KEY_EX_CAP == 1 then ENCRYPT_CAP == 1 or MAC_CAP == 1
PSK_CAP must not be 3
if PSK_CAP != 0 then ENCRYPT_CAP == 1 or MAC_CAP == 1
if MUT_AUTH_CAP == 1 then ENCAP_CAP == 1
if HANDSHAKE_IN_THE_CLEAR_CAP == 1 then KEY_EX_CAP == 1
if PUB_KEY_ID_CAP == 1 then CERT_CAP == 0
DataTransferSize must be >= minimum; MaxSPDMmsgSize must be >= DataTransferSize
if CHAL_CAP == 1 or MEAS_CAP == 1 or KEY_EX_CAP == 1 then CERT_CAP == 1 or PUB_KEY_ID_CAP == 1

function: scripts/management/11_spdm_test.py::test_spdm_get_capabilities_invalid_param

Send GET_CAPABILITIES with invalid parameters and expect ERROR responses.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

send GET_VERSION to establish negotiated Version
send GET_CAPABILITIES with Param2=0 as baseline success
send GET_CAPABILITIES with Param2=1 expect ERROR
send GET_CAPABILITIES with CTExponent incremented expect ERROR
send GET_CAPABILITIES with DataTransferSize+1 and MaxSPDMmsgSize+1 expect ERROR

function: scripts/management/11_spdm_test.py::test_spdm_negotiate_algorithms

Send NEGOTIATE_ALGORITHMS and validate ALGORITHMS response fields.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Prerequisite discovery: VERSION, then CAPABILITIES.
NEGOTIATE_ALGORITHMS → ALGORITHMS.
Length check for ALGORITHMS payload.
Header: Version, ResponseCode=ALGORITHMS, reserved/length fields.
MeasurementHashAlgo: exactly one bit set.
BaseAsymSel / BaseHashSel: exactly one bit set each.
Reserved region and extended counts.
RespAlgStruct list: Type/Count/Selected; fixed 2-byte bitmap; no extended; exactly one bit selected.

function: scripts/management/11_spdm_test.py::test_spdm_negotiate_algorithms_invalid_sequence

NEGOTIATE_ALGORITHMS in invalid request orders should return ERROR; only the canonical sequence succeeds.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

NEGOTIATE_ALGORITHMS before GET_VERSION → expect ERROR 0x04
GET_VERSION only (no GET_CAPABILITIES) then NEGOTIATE_ALGORITHMS → expect ERROR 0x04
Canonical order: GET_VERSION → GET_CAPABILITIES → NEGOTIATE_ALGORITHMS → expect ALGORITHMS
Re-issuing NEGOTIATE_ALGORITHMS after negotiation → expect ERROR 0x04
GET_CAPABILITIES after NEGOTIATE_ALGORITHMS (invalid order) → expect ERROR 0x04
NEGOTIATE_ALGORITHMS after the above invalid order → expect ERROR 0x04
Restart from GET_VERSION to allow the canonical sequence again

function: scripts/management/11_spdm_test.py::test_spdm_negotiate_algorithms_invalid_version

NEGOTIATE_ALGORITHMS with unsupported Version encodings should return ERROR.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

perform VERSION discovery and collect supported VersionNumberEntry values
candidate invalid Version encodings
for versions not advertised by the responder expect ERROR on NEGOTIATE_ALGORITHMS

function: scripts/management/11_spdm_test.py::test_spdm_negotiate_algorithms_invalid_params

NEGOTIATE_ALGORITHMS with invalid parameters should return ERROR

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

send GET_VERSION to establish the negotiated Version
send GET_CAPABILITIES to disclose CTExponent and Flags before algorithm negotiation
send NEGOTIATE_ALGORITHMS with total Length below minimum, expect ERROR
send NEGOTIATE_ALGORITHMS with ExtAsymSelCount exceeding allowed range, expect ERROR
send NEGOTIATE_ALGORITHMS with ExtHashSelCount exceeding allowed range, expect ERROR
send NEGOTIATE_ALGORITHMS with FixedAlgStruct count too small, expect ERROR
send NEGOTIATE_ALGORITHMS with unsupported FixedAlgStruct count value, expect ERROR

function: scripts/management/11_spdm_test.py::test_spdm_negotiate_algorithms_multiple_times

Send NEGOTIATE_ALGORITHMS more than once and expect only the first negotiation to succeed.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

send GET_VERSION to establish negotiated Version
send GET_CAPABILITIES to disclose CTExponent and Flags prior to negotiation
send first NEGOTIATE_ALGORITHMS and expect ALGORITHMS
send another NEGOTIATE_ALGORITHMS with Param2=1 and expect ERROR

function: scripts/management/11_spdm_test.py::test_spdm_negotiate_algorithms_skip_get_capabilities

Send NEGOTIATE_ALGORITHMS without GET_CAPABILITIES and expect ERROR.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

perform VERSION discovery
attempt NEGOTIATE_ALGORITHMS while skipping GET_CAPABILITIES and expect ERROR 0x04

function: scripts/management/11_spdm_test.py::test_spdm_diff_capabilities_algorithms

Exercise CAPABILITIES and ALGORITHMS with differing selections and expect ERROR on invalid overrides.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

VERSION → CAPABILITIES to establish baseline
CAPABILITIES with DataTransferSize override should return ERROR
VERSION → CAPABILITIES → NEGOTIATE_ALGORITHMS to establish baseline
NEGOTIATE_ALGORITHMS with invalid BaseHashAlgo bitmap should return ERROR

function: scripts/management/11_spdm_test.py::test_spdm_get_digest

Send GET_DIGESTS and validate DIGESTS response fields and cert chain digests.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Issue GET_VERSION, GET_CAPABILITIES, and NEGOTIATE_ALGORITHMS to construct VCA
GET_DIGESTS → DIGESTS
Header: Version and ResponseCode=DIGESTS; Param1 reserved
Param2 slot mask → digest count (number of set bits)
Digest array length = digest_count * digest_length
Log per-slot CertChainHash

function: scripts/management/11_spdm_test.py::test_spdm_get_digests_with_different_hash_algorithms

Verify GET_DIGESTS response across negotiated BaseHashAlgo variants.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Establish connection discovery then capability disclosure.
Negotiate algorithms by proposing a single candidate BaseHashAlgo derived from the parameter,
then observe the Responder’s BaseHashSel selection in the ALGORITHMS response.
If the Responder does not select any BaseHashAlgo, skip this variant.
Determine HashSize for the selected BaseHashAlgo to interpret DIGESTS payload.
Request DIGESTS and record the response for this negotiated BaseHashAlgo.
Extract the first CertChainHash from the DIGESTS payload for observation/logging.
Reissue GET_DIGESTS for idempotence; responses should be identical for the same negotiated state.

function: scripts/management/11_spdm_test.py::test_spdm_get_digests_invalid_requests

Send GET_DIGESTS in invalid connection states; verify ERROR handling and success after proper initialization.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

GET_VERSION then GET_DIGESTS before CAPABILITIES → expect ERROR
After CAPABILITIES, GET_DIGESTS before NEGOTIATE_ALGORITHMS → expect ERROR
Correct order completed; GET_DIGESTS should succeed
Unsupported Version in GET_DIGESTS → expect ERROR
Reissuing CAPABILITIES after negotiation → expect ERROR
Reissuing NEGOTIATE_ALGORITHMS after negotiation → expect ERROR
CAPABILITIES again after prior failures → still expect ERROR
GET_DIGESTS remains valid after correct initialization

function: scripts/management/11_spdm_test.py::test_spdm_get_digests_invalid_version

GET_DIGESTS with unsupported Version encodings should return ERROR.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

perform VERSION discovery and collect supported VersionNumberEntry values
candidate invalid Version encodings
for versions not advertised by the responder expect ERROR on GET_DIGESTS
establish connection state before issuing the request under test

function: scripts/management/11_spdm_test.py::test_spdm_get_certificate

Retrieve the full certificate chain via GET_CERTIFICATE and validate against the DIGESTS CertChainHash.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Issue GET_VERSION, GET_CAPABILITIES, and NEGOTIATE_ALGORITHMS to construct VCA
Obtain DIGESTS to anchor the expected CertChainHash.
Retrieve the complete certificate chain in portions until RemainderLength becomes zero.
Verify the certificate chain hash matches the DIGESTS value.
Parse the DER-encoded certificate chain into X.509 objects.
Verify the chain from root to leaf using the issuer’s public key on the subject’s tbsCertificate.

function: scripts/management/11_spdm_test.py::test_spdm_get_cert_from_diff_slots

Send GET_CERTIFICATE for each slot indicated in the DIGESTS slot mask and verify per-slot chain via precomputed CertChainHash.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Issue GET_VERSION, GET_CAPABILITIES, and NEGOTIATE_ALGORITHMS to construct VCA
request DIGESTS and parse the slot mask and per-slot CertChainHash array
header checks for DIGESTS
derive slot count from Param2 bitmap and slice the digest blob
for each set bit in the slot mask, pull the CERTIFICATE chain and validate against the corresponding CertChainHash

function: scripts/management/11_spdm_test.py::test_spdm_get_leaf_certificate

Retrieve the leaf certificate from the CERTIFICATE chain and log essential fields.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

send GET_VERSION to establish negotiated Version
send GET_CAPABILITIES to disclose CTExponent and Flags
send NEGOTIATE_ALGORITHMS to select MeasurementHashAlgo/BaseAsymSel/BaseHashSel
retrieve the complete CERTIFICATE chain in portions
parse DER certificates into X.509 objects
select the leaf certificate and log subject/issuer/serial/validity

function: scripts/management/11_spdm_test.py::test_spdm_get_certificate_invalid_version

GET_CERTIFICATE with unsupported Version encodings should return ERROR.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

perform VERSION discovery and collect supported VersionNumberEntry values
prepare candidate invalid Version encodings
for versions not advertised by the responder expect ERROR on GET_CERTIFICATE
enter negotiated state then issue the request under test

function: scripts/management/11_spdm_test.py::test_spdm_get_cert_with_invalid_slots

GET_CERTIFICATE with an unset slot number should return ERROR.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

obtain DIGESTS to discover the slot mask
issue GET_CERTIFICATE for each slot not set in the mask and expect ERROR

function: scripts/management/11_spdm_test.py::test_spdm_get_challenge

Send CHALLENGE and validate CHALLENGE_AUTH signature against the responder certificate chain.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Issue GET_VERSION, GET_CAPABILITIES, and NEGOTIATE_ALGORITHMS to construct VCA
Retrieve the complete certificate chain to obtain the ResponderPublicKey from the last certificate.
Send CHALLENGE and capture CHALLENGE_AUTH.
Verify CertChainHash equals the hash of the retrieved certificate chain.
Build the signed message: ResponderChallengeAuthSigningContext followed by Hash of the transcript for CHALLENGE.
Extract the signature and verify using the ResponderPublicKey from the leaf certificate.

function: scripts/management/11_spdm_test.py::test_spdm_challenge_with_invalid_version

CHALLENGE with unsupported Version encodings should return ERROR.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

perform VERSION discovery and collect supported VersionNumberEntry values
candidate invalid Version encodings
for versions not advertised by the responder expect ERROR on CHALLENGE

function: scripts/management/11_spdm_test.py::test_spdm_challenge_with_invalid_params

CHALLENGE with invalid parameters should return ERROR.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Issue GET_VERSION, GET_CAPABILITIES, and NEGOTIATE_ALGORITHMS to construct VCA
obtain DIGESTS to learn the slot mask used for CHALLENGE
issue CHALLENGE for each slot not set in the mask and expect ERROR
param2 out of allowed range should return ERROR
param2 near upper reserved boundary should return ERROR

function: scripts/management/11_spdm_test.py::test_spdm_challenge_check_nonce

Check CHALLENGE Nonce quality across repeated exchanges using a chi-square uniformity test.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

collect responder nonces from multiple CHALLENGE flows
evaluate nonce byte distribution for near-uniformity

function: scripts/management/11_spdm_test.py::test_spdm_challenge_a1_b1_c1

Run CHALLENGE flow A1_B1_C1 with full VCA and certificate retrieval prior to CHALLENGE.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Issue GET_VERSION, GET_CAPABILITIES, and NEGOTIATE_ALGORITHMS to construct VCA
GET_DIGESTS to obtain CertChainHash
GET_CERTIFICATE to obtain leaf certificate
Send CHALLENGE and verify response

function: scripts/management/11_spdm_test.py::test_spdm_challenge_a1_b3_c1

Run CHALLENGE flow A1_B3_C1 with DIGESTS after retrieving the certificate, then CHALLENGE.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Issue GET_VERSION, GET_CAPABILITIES, and NEGOTIATE_ALGORITHMS to construct VCA
GET_CERTIFICATE to obtain leaf certificate
Re-enter VERSION CAPABILITIES ALGORITHMS before CHALLENGE
GET_DIGESTS to obtain CertChainHash
Send CHALLENGE and verify response

function: scripts/management/11_spdm_test.py::test_spdm_challenge_a1_b4_c1

Run CHALLENGE flow A1_B4_C1 with certificate retrieval after VCA, then CHALLENGE.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Issue GET_VERSION, GET_CAPABILITIES, and NEGOTIATE_ALGORITHMS to construct VCA
GET_DIGESTS to obtain CertChainHash
Re-enter VERSION CAPABILITIES ALGORITHMS before CHALLENGE
GET_CERTIFICATE to obtain leaf certificate
Send CHALLENGE and verify response

function: scripts/management/11_spdm_test.py::test_spdm_challenge_a1_b2_c1

Run CHALLENGE flow A1_B2_C1 with CHALLENGE directly after VCA steps.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Issue GET_VERSION, GET_CAPABILITIES, and NEGOTIATE_ALGORITHMS to construct VCA
GET_DIGESTS to obtain CertChainHash
GET_CERTIFICATE to obtain leaf certificate
Re-enter VERSION CAPABILITIES ALGORITHMS before CHALLENGE
Send CHALLENGE and verify response

function: scripts/management/11_spdm_test.py::test_spdm_challenge_a2_b1_c1

Run CHALLENGE flow A2_B1_C1 under CACHE_CAP with DIGESTS and certificate before CHALLENGE.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Check if CACHE CAP is supported
Send CHALLENGE, M1 and M2 shall be set to null
GET_DIGESTS to obtain CertChainHash
GET_CERTIFICATE to obtain leaf certificate
Send CHALLENGE and verify response

function: scripts/management/11_spdm_test.py::test_spdm_challenge_a2_b3_c1

Run CHALLENGE flow A2_B3_C1 under CACHE_CAP with DIGESTS then CHALLENGE using a retrieved certificate.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Check if CACHE CAP is supported
GET_CERTIFICATE to obtain leaf certificate
Send CHALLENGE, M1 and M2 shall be set to null
GET_DIGESTS to obtain CertChainHash
Send CHALLENGE and verify response

function: scripts/management/11_spdm_test.py::test_spdm_challenge_a2_b4_c1

Run CHALLENGE flow A2_B4_C1 under CACHE_CAP with certificate retrieval then CHALLENGE.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Check if CACHE CAP is supported
GET_DIGESTS to obtain CertChainHash
Send CHALLENGE, M1 and M2 shall be set to null
GET_CERTIFICATE to obtain leaf certificate
Send CHALLENGE and verify response

function: scripts/management/11_spdm_test.py::test_spdm_challenge_a2_b2_c1

Run CHALLENGE flow A2_B2_C1 under CACHE_CAP with transcript handling then CHALLENGE only.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Check if CACHE CAP is supported
GET_DIGESTS to obtain CertChainHash
GET_CERTIFICATE to obtain leaf certificate
Send CHALLENGE, M1 and M2 shall be set to null
Send CHALLENGE and verify response

function: scripts/management/11_spdm_test.py::test_spdm_get_measurements_with_invalid_version

Probe GET_MEASUREMENTS with unsupported VersionNumber and expect ERROR.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Issue GET_VERSION, GET_CAPABILITIES, and NEGOTIATE_ALGORITHMS to construct VCA
GET_DIGESTS to obtain CertChainHash
GET_CERTIFICATE to obtain leaf certificate
CHALLENGE to bind CertChainHash and responder nonce
GET_MEASUREMENTS all measurements as baseline
GET_VERSION to enumerate supported versions
GET_CAPABILITIES negotiation baseline
NEGOTIATE_ALGORITHMS negotiate base parameters
GET_MEASUREMENTS with VersionNumber set to each unsupported value expect ERROR

function: scripts/management/11_spdm_test.py::test_spdm_get_measurements_invalid_order

Send GET_MEASUREMENTS before NEGOTIATE_ALGORITHMS and expect ERROR.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

GET_VERSION discovery
GET_CAPABILITIES discovery
GET_MEASUREMENTS before NEGOTIATE_ALGORITHMS expect ERROR

function: scripts/management/11_spdm_test.py::test_spdm_get_measurements_invalid_params

Validate GET_MEASUREMENTS parameter handling for index and slot id.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Issue GET_VERSION, GET_CAPABILITIES, and NEGOTIATE_ALGORITHMS to construct VCA
GET_DIGESTS to obtain CertChainHash
GET_CERTIFICATE to obtain leaf certificate
CHALLENGE to bind CertChainHash
GET_MEASUREMENTS param1=1 param2=0xFF request all measurements
GET_MEASUREMENTS param1=1 param2=0x02 request by valid index
GET_MEASUREMENTS param1=1 param2=num_blocks+1 out of range index expect ERROR
GET_DIGESTS to read slot bitmap
GET_MEASUREMENTS with slot_id not provisioned expect ERROR

function: scripts/management/11_spdm_test.py::test_spdm_get_measurements_check_response

Validate MEASUREMENTS structure length blocks and value types for GET_MEASUREMENTS.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

GET_VERSION discovery
GET_CAPABILITIES discovery
NEGOTIATE_ALGORITHMS select MeasurementHashAlgo
GET_DIGESTS to obtain CertChainHash
GET_CERTIFICATE to obtain leaf certificate
CHALLENGE to bind CertChainHash
GET_MEASUREMENTS param1=1 param2=0xFF request all measurements
Parse MeasurementRecord into MeasurementBlock[]
Check MeasurementSpecification and DMTF value type semantics

function: scripts/management/11_spdm_test.py::test_spdm_get_measurements_check_signature

Verify MEASUREMENTS signature for multiple GET_MEASUREMENTS operations.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Issue GET_VERSION, GET_CAPABILITIES, and NEGOTIATE_ALGORITHMS to construct VCA
GET_DIGESTS to obtain CertChainHash
GET_CERTIFICATE to obtain leaf certificate
CHALLENGE to bind CertChainHash
GET_MEASUREMENTS operation = 0x00 request current measurement

function: scripts/management/11_spdm_test.py::test_spdm_get_measurements_check_signature_in_session

Verify MEASUREMENTS signature for GET_MEASUREMENTS inside an established session.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Start a session
GET_MEASUREMENTS operation = 0x00 within session
Verify MEASUREMENTS signature

function: scripts/management/11_spdm_test.py::test_spdm_get_measurements_out_of_session

Verify MEASUREMENTS signature for GET_MEASUREMENTS without using a session.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Start a session
Operate without using the secure session
GET_MEASUREMENTS operation = 0xFF request all measurements
Verify MEASUREMENTS signature

function: scripts/management/11_spdm_test.py::test_spdm_key_exchange_with_invalid_version

Probe KEY_EXCHANGE with unsupported VersionNumber and expect ERROR.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

GET_VERSION to enumerate supported versions
GET_CAPABILITIES then NEGOTIATE_ALGORITHMS as baseline
Prepare KEY_EXCHANGE exchange_data
KEY_EXCHANGE with each unsupported VersionNumber expect ERROR

function: scripts/management/11_spdm_test.py::test_spdm_key_exchange_with_invalid_order

Send KEY_EXCHANGE before NEGOTIATE_ALGORITHMS and expect ERROR.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

GET_VERSION then GET_CAPABILITIES
KEY_EXCHANGE attempted before NEGOTIATE_ALGORITHMS expect ERROR

function: scripts/management/11_spdm_test.py::test_spdm_key_exchange_in_session

Send KEY_EXCHANGE within an established session and expect ERROR.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Operate within an established secure session
Update application key schedule before sending application-level requests
KEY_EXCHANGE in-session must be rejected

function: scripts/management/11_spdm_test.py::test_spdm_key_exchange_open_two_sessions

Issue KEY_EXCHANGE to create a new session and ensure SessionID differs from existing.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Start a session
Update application key schedule before sending application-level requests
KEY_EXCHANGE to establish a new session

function: scripts/management/11_spdm_test.py::test_spdm_key_exchange_invalid_params

Validate KEY_EXCHANGE parameter handling for slot and measurement selection.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

GET_DIGESTS to read slot bitmap
Prepare KEY_EXCHANGE exchange_data
KEY_EXCHANGE with an unprovisioned slot expect ERROR
KEY_EXCHANGE with Param1 beyond TcbMeasurements expect ERROR
KEY_EXCHANGE with Param1 below AllMeasurements expect ERROR

function: scripts/management/11_spdm_test.py::test_spdm_handshake_in_the_clear

Exercise KEY_EXCHANGE with HANDSHAKE_IN_THE_CLEAR_CAP = 1 and verify responder signature.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

GET_VERSION for discovery
GET_CAPABILITIES with HANDSHAKE_IN_THE_CLEAR_CAP requested then check negotiated flags
NEGOTIATE_ALGORITHMS to select base parameters
Include CertChainHash into transcript
Prepare ephemeral key for KEY_EXCHANGE exchange_data
KEY_EXCHANGE with different Param1 and session_policy = 1

function: scripts/management/11_spdm_test.py::test_spdm_finish_with_invalid_version

Send FINISH with an unsupported VersionNumber and expect ERROR.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Issue GET_VERSION, GET_CAPABILITIES, and NEGOTIATE_ALGORITHMS to construct VCA
Add CertChainHash to transcript
KEY_EXCHANGE to establish session context
Derive handshake secrets
FINISH with invalid VersionNumber expect ERROR

function: scripts/management/11_spdm_test.py::test_spdm_finish_with_invalid_order

Send FINISH without prior KEY_EXCHANGE and expect ERROR.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

GET_VERSION for discovery
GET_CAPABILITIES for discovery
FINISH without session establishment expect ERROR

function: scripts/management/11_spdm_test.py::test_spdm_finish_in_session

Complete FINISH after KEY_EXCHANGE then attempt another FINISH within the session and expect ERROR.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Issue GET_VERSION, GET_CAPABILITIES, and NEGOTIATE_ALGORITHMS to construct VCA
Add CertChainHash to transcript
KEY_EXCHANGE to establish session context
Derive handshake secrets
FINISH to transition to application keys
FINISH again within the established session expect ERROR

function: scripts/management/11_spdm_test.py::test_spdm_finish_with_invalid_params

Send FINISH with invalid parameters and expect ERROR.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Issue GET_VERSION, GET_CAPABILITIES, and NEGOTIATE_ALGORITHMS to construct VCA
Add CertChainHash to transcript
KEY_EXCHANGE to establish session context
Derive handshake secrets
FINISH with invalid VersionNumber expect ERROR
End session

function: scripts/management/11_spdm_test.py::test_spdm_finish_handshake_in_the_clear

Complete FINISH when HANDSHAKE_IN_THE_CLEAR_CAP = 1.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

VERSION CAPABILITIES with HANDSHAKE_IN_THE_CLEAR_CAP then ALGORITHMS
Add CertChainHash to transcript
KEY_EXCHANGE to establish session context
Derive handshake secrets
FINISH in clear per negotiated capability
Send END_SESSIONEND_SESSION request and receive response

function: scripts/management/11_spdm_test.py::test_spdm_finish_outside_session

Send FINISH without a session and expect ERROR 0x0B.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

FINISH without KEY_EXCHANGE or session establishment expect ERROR

function: scripts/management/11_spdm_test.py::test_spdm_heartbeat_with_invalid_version

Send HEARTBEAT with an unsupported VersionNumber and expect ERROR.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Start a session
HEARTBEAT with VersionNumber = 0xFF should return ERROR

function: scripts/management/11_spdm_test.py::test_heartbeat_in_handshake

Attempt HEARTBEAT during handshake phase and expect ERROR.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Issue GET_VERSION, GET_CAPABILITIES, and NEGOTIATE_ALGORITHMS to construct VCA
incorporate CertChainHash into transcript to begin handshake
KEY_EXCHANGE to start session establishment
derive handshake keys prior to FINISH
HEARTBEAT during handshake should return ERROR
End session

function: scripts/management/11_spdm_test.py::test_key_update_with_invalid_params

Send KEY_UPDATE with an unsupported VersionNumber and expect ERROR.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Start a session
HEARTBEAT to confirm liveness of the session
KEY_UPDATE with VersionNumber = 0xFF should return ERROR

function: scripts/management/11_spdm_test.py::test_end_session_with_invalid_params

Send END_SESSION with an unsupported VersionNumber and expect ERROR.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Issue GET_VERSION, GET_CAPABILITIES, and NEGOTIATE_ALGORITHMS to construct VCA
incorporate CertChainHash into transcript then establish a session
KEY_EXCHANGE to begin session setup
derive handshake keys and complete FINISH
END_SESSION with VersionNumber = 0xFF should return ERROR
End session

function: scripts/management/11_spdm_test.py::test_end_session_before_finish

Send END_SESSION before FINISH.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Issue GET_VERSION, GET_CAPABILITIES, and NEGOTIATE_ALGORITHMS to construct VCA
incorporate CertChainHash into transcript then establish a session
KEY_EXCHANGE to begin session setup
derive handshake keys and complete FINISH
END_SESSION before FINISH
End session

function: scripts/management/11_spdm_test.py::test_spdm_end_session_outside_session

Send END_SESSION without a session and expect ERROR.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

END_SESSION outside any session should return ERROR 0x0B

function: scripts/management/11_spdm_test.py::test_spdm_get_chunk

Retrieve a complete DIGESTS payload using CHUNK_GET and validate it matches the baseline DIGESTS.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Issue GET_VERSION, GET_CAPABILITIES, and NEGOTIATE_ALGORITHMS to construct VCA
Establish a baseline DIGESTS for later comparison.
Negotiate a small DataTransferSize to trigger chunked transfer.
Request DIGESTS expecting LARGE_RESPONSE that mandates CHUNK_GET.
Use CHUNK_GET to fetch the full DIGESTS payload in sequence and reassemble it.
Verify the reassembled payload equals the baseline DIGESTS.

function: scripts/management/11_spdm_test.py::test_spdm_heartbeat_requires_session

Send HEARTBEAT without an established session and expect ERROR.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Issue GET_VERSION, GET_CAPABILITIES, and NEGOTIATE_ALGORITHMS to construct VCA
Exercise sending HEARTBEAT before creating a session and assert the harness reports an ERROR response

function: scripts/management/11_spdm_test.py::test_spdm_heartbeat_multiple_with_seq

Send repeated HEARTBEAT to validate liveness on the SessionId and expect HEARTBEAT_ACK.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Start a session
send HEARTBEAT and expect HEARTBEAT_ACK
send another HEARTBEAT and expect HEARTBEAT_ACK
send a third HEARTBEAT and expect HEARTBEAT_ACK

function: scripts/management/11_spdm_test.py::test_spdm_key_update_flow

Verify KEY_UPDATE basic functionality over an established session.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Start a session
liveness check before updates
update all keys → expect KEY_UPDATE_ACK
verify new keys → expect KEY_UPDATE_ACK
liveness check after update
update single direction → expect KEY_UPDATE_ACK
verify again → expect KEY_UPDATE_ACK
final liveness check

function: scripts/management/11_spdm_test.py::test_spdm_cmds_in_session_invalid

Send GET_CAPABILITIES and NEGOTIATE_ALGORITHMS inside a session and expect ERROR.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Start a session
GET_CAPABILITIES is a connection-state command and must not be accepted in session
NEGOTIATE_ALGORITHMS is a connection-state command and must not be accepted in session

function: scripts/management/11_spdm_test.py::test_spdm_get_measurements_with_io

Continuously issue GET_MEASUREMENTS during host I/O and verify MEASUREMENTS signature in-session.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

Start a session
drive mixed read/write I/O while repeatedly validating GET_MEASUREMENTS signature over the same session

function: scripts/management/11_spdm_test.py::test_spdm_get_chunk_out_of_order

Request CHUNK_GET out of order and expect ERROR until chunkseq_no starts at 0.

Reference

SPDM Specification Revision 1.2.3 (DMTF DSP0274 v1.2.3).

Steps

GET_DIGESTS twice to capture baseline size and decide if chunking is needed
VERSION → CAPABILITIES(DataTransferSize=0x40) → NEGOTIATE_ALGORITHMS to enable chunk transfer path
GET_DIGESTS should return ERROR 0x0F indicating chunked transfer required
CHUNK_GET with out-of-order chunkseq_no should return ERROR
CHUNK_GET with chunkseq_no=0 should be accepted to start the transfer

file: scripts/management/12_vdm_test

function: scripts/management/12_vdm_test.py::test_mi_admin_identify_vdm_smbus_concurrent

Exercise MI Identify via VDM and SMBus concurrently and compare with NVMe Admin.

Reference

Based on NVM Express Management Interface Revision 1.2c.

Steps

Send Identify command via MI (partial data retrieval)
Send Identify command via NVMe Admin and compare partial data
Retrieve full Identify data through VDM
Retrieve full Identify data through SMBus
Retrieve full Identify data through VDM and SMBus concurrently

function: scripts/management/12_vdm_test.py::test_mi_ep_buf_differnt_length

Validate Management Endpoint Buffer read/write across varying transfer lengths.

Reference

Based on NVM Express Management Interface Revision 1.2c.

Steps

Read SMBus Port Information to determine if Management Endpoint Buffer is supported
Write Management Endpoint Buffer with deterministic pattern
Read Management Endpoint Buffer and verify payload

function: scripts/management/12_vdm_test.py::test_mi_read_mi_data_structure

Verify NVMe-MI data structure reads for subsystem and port discovery.

Reference

Based on NVM Express Management Interface Revision 1.2c.

Steps

Read NVM Subsystem Information (DTYP = 00h)
Read Port Information (DTYP = 01h) for SMBus port
Log port information for each available port
Validate Maximum MCTP Transmission Unit Size
Validate Management Endpoint Buffer Size

function: scripts/management/12_vdm_test.py::test_mi_vpd_read_length

Confirm VPD read handling when requested length and offset exceed available data.

Reference

Based on NVM Express Management Interface Revision 1.2c.

Steps

A VPD Read command with length 0 and no data is valid
Valid VPD read request within size limits
VPD read request with Data Length exceeding VPD size (invalid)
VPD read request with Data Offset + Data Length exceeding VPD size (invalid)

function: scripts/management/12_vdm_test.py::test_mi_admin_timestamp

Validate MI timestamp set/get consistency across power states.

Reference

Based on NVM Express Management Interface Revision 1.2c.

Steps

Set timestamp via MI command while targeting the requested power state
Set the requested power state and confirm support
Repeat timestamp retrieval and validate monotonicity via MI
Restore controller to PS0

function: scripts/management/12_vdm_test.py::test_mi_admin_identify

Compare MI Identify data against NVMe Admin Identify results.

Reference

Based on NVM Express Management Interface Revision 1.2c.

Steps

Send Identify command via MI (partial data retrieval)
Send Identify command via NVMe Admin and compare partial data
Retrieve the entire Identify data through MI
Compare the entire Identify data from MI and NVMe Admin

function: scripts/management/12_vdm_test.py::test_spdm_get_version

Validate SPDM GET_VERSION response handling.

Reference

Based on SPDM Specification Revision 1.0.2.

Steps

Send GET_VERSION request and receive response

file: scripts/management/13_fru_test

function: scripts/management/13_fru_test.py::test_fru_read

Validate FRU common header integrity via direct SMBus reads.

Reference

Based on NVM Express Management Interface Specification Revision 1.2c.

Steps

Read the FRU common header over SMBus
Verify the version and checksum in the FRU header
Read the entire FRU content for baseline comparison
Read the FRU content in two segments to confirm offset reset

function: scripts/management/13_fru_test.py::test_fru_read_vpd

Validate that MI VPD reads match SMBus FRU reads for the same offsets.

Reference

Based on NVM Express Management Interface Specification Revision 1.2c.

Steps

Prepare buffer placeholder for VPD comparison
Read VPD content via the MI VPD Read command
Read the same VPD region directly over SMBus
Compare MI VPD read data to direct SMBus read
Verify that invalid FRU slave address is rejected

function: scripts/management/13_fru_test.py::test_fru_read_power_cycle

Confirm FRU offset resets after a full power cycle using SMBus reads.

Reference

Based on NVM Express Management Interface Specification Revision 1.2c.

Steps

Capture FRU content with initial power applied
Perform a full power cycle of the drive
Read FRU content again to ensure offset reset to zero
The internal offset shall be cleared to 0h following a power cycle of the FRU Information Device

function: scripts/management/13_fru_test.py::test_fru_product_info_area_fields

Inspect Product Info Area fields for completeness and checksum validity over SMBus.

Reference

Based on NVM Express Management Interface Specification Revision 1.2c.

Steps

Define expected Product Info labels and required entries
Read the FRU common header to locate Product Info Area
Read the full FRU image for field extraction
Validate Product Info Area checksum and format
Iterate through TLV entries and verify content
padding or explicitly empty field

function: scripts/management/13_fru_test.py::test_fru_nvme_multirecord_area

Decode NVMe and PCIe MultiRecord entries from the FRU over SMBus.

Reference

Based on NVM Express Management Interface Specification Revision 1.2c.

Steps

Read FRU header to determine MultiRecord offset
Read the full FRU image to access MultiRecord data
Parse each MultiRecord entry and validate checksums
Log NVMe-specific MultiRecord details when present
Log PCIe port MultiRecord details when present

function: scripts/management/13_fru_test.py::test_fru_i2c_write

Ensure VPD writes over SMBus are blocked when MI VPD Write is supported.

Reference

Based on NVM Express Management Interface Specification Revision 1.2c.

Steps

Check whether the MI VPD Write command is supported
Prepare data for a negative VPD write attempt
Confirm SMBus VPD write is rejected when MI write capability exists

function: scripts/management/13_fru_test.py::test_fru_read_with_aux_power_only

Validate FRU SMBus readability when only auxiliary power is supplied.

Reference

Based on NVM Express Management Interface Specification Revision 1.2c.

Steps

Skip if auxiliary power rail cannot be controlled
Skip if platform does not provide U.2 style auxiliary rail
Transition into auxiliary-power-only state
Attempt SMBus static-data read while only aux power is applied
Restore main power and wait before resuming access
Verify auxiliary-only data matches after restoring main power
Final sanity check after another SMBus read with full power.

Suite: scripts/production

folder: scripts/production

file: scripts.production.01_normal_io_test

This file contains long-duration IO tests aimed at evaluating the reliability, endurance, and performance of NVMe SSDs under sustained workloads. The tests cover various read/write patterns, including random and sequential operations with different block sizes and ratios, running for extended periods from 30 minutes to several days. These tests are designed to ensure that the NVMe SSDs can handle continuous stress, identify potential issues, and verify that the devices meet required performance and stability standards over their expected lifespan.

file: scripts.production.02_mix_io_test

This file contains a series of mixed IO tests aimed at evaluating the performance and reliability of NVMe SSDs under various conditions, including different block sizes, read/write ratios, and IO patterns over extended durations. The tests simulate real-world workloads by varying parameters such as queue depth and block size, switching between random and sequential operations, and collecting performance data. These tests are designed to stress the SSD and ensure it can handle diverse and intensive usage scenarios.

file: scripts.production.03_data_model_test

This file contains a series of data model tests designed to simulate real-world workloads on NVMe SSDs. Each test emulates different application scenarios, such as cloud computing, SQL databases, and content delivery networks, by varying parameters like block size, read/write ratio, and randomness. The purpose of these tests is to assess the SSD’s performance, endurance, and reliability under conditions that mimic actual usage patterns in diverse environments.

file: scripts.production.04_trim_format_test

This file includes a series of tests focused on assessing NVMe SSD performance under various conditions, particularly during and after trim operations. The tests simulate workloads that involve sequential and random writes, followed by trim operations and subsequent performance evaluations. These scenarios help determine how effectively the SSD maintains performance when managing trimmed data and handling mixed IO patterns over extended periods.

file: scripts.production.05_small_range_test

This file contains a set of tests designed to evaluate the performance and reliability of NVMe SSDs by executing various read and write operations on specific LBA ranges and random regions within the drive. The tests focus on stressing the SSD with different workloads, such as repeated reads and writes on the same or multiple LBAs, and small range operations. These scenarios are intended to simulate real-world usage patterns and assess how the SSD manages data across its storage space over extended durations.

file: scripts.production.06_jesd_workload_test

This file includes a test case designed to evaluate NVMe SSD performance and endurance under a JEDEC JESD 219 workload, which simulates a typical client workload for solid-state drives. The test involves a sequence of operations: a full drive sequential write with 128KB block sizes, followed by 4KB random writes, and concluding with a workload distribution that mimics real-world usage scenarios. The purpose is to assess how well the SSD handles sustained writes, mixed workloads, and different IO patterns over an extended period.

file: scripts.production.07_power_cycle_test

This script automates power cycling tests on NVMe SSDs to assess their response times and reliability under different power loss conditions. It focuses on simulating both sudden (dirty) and typical (clean) power cycles. These tests help evaluate the SSD’s resilience and ability to maintain data integrity across 1000 cycles, ensuring the device meets stringent durability standards.

file: scripts.production.08_wl_stress_test

This script conducts a wear leveling test on NVMe SSDs to evaluate their endurance and efficiency in managing data distribution across the memory cells. The test involves sequential and random write operations to different regions of the drive, simulating hot and cold data scenarios, and triggers wear leveling and garbage collection processes. The test measures IOPS (Input/Output Operations Per Second) throughout the operations and generates performance diagrams to assess the effectiveness of wear leveling. The script also includes power cycling and full-drive verification steps to ensure data integrity post-testing.

file: scripts.production.09_io_stress_test

This script conducts a comprehensive stress test on NVMe SSDs to validate their stability, performance, and error handling capabilities under prolonged and varied workloads. The test involves running multiple randomized I/O operations on different namespaces concurrently with NVMe Admin commands, MI commands, and events (e.g. power cycle, and reset). This approach helps assess the SSD’s resilience and readiness for deployment in demanding environments.

Suite: scripts/placement

folder: scripts/placement

file: scripts/placement/01_basic_test

function: scripts/placement/01_basic_test.py::test_config_configure_fdp_parameters

Ensure that FDP parameters like the Flexible Data Placement feature are correctly applied when configured.

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement

Steps

delete all namespaces
Enable FDP with default configuration index 0
Verify FDP is enabled
Check Identify Controller for FDP support
Disable FDP
Verify FDP is disabled
create an namespace

function: scripts/placement/01_basic_test.py::test_config_enable_fdp_with_namespace_created

Confirm that a Set Features command specifying the FDP feature is aborted with “Command Sequence Error” if it enables FDP when a namespace is created.

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement

Steps

Delete all namespaces
Create a namespace in the Endurance Group
Attempt to set FDP with an existing namespace
Expect a Command Sequence Error
Delete the namespace
nvme0.ns_delete()

file: scripts/placement/02_logpage_test

function: scripts/placement/02_logpage_test.py::test_config_endurance_group_identifier

Validate the Endurance Group Identifier field to ensure it correctly specifies the Endurance Group.

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement – Section 5.16.1

Steps

Allocate a buffer for the log page data (16 bytes for header)
Issue a Get Log Page command to retrieve the FDP Configurations log page (Log Page Identifier 0x20)
Assert that the Version field (Byte 02) in the log page header is cleared to 0h, as required by the spec.
Issue another Get Log Page command with an invalid Log Specific Identifier (0 instead of 1).
Expect a warning with “ERROR status: 00/02” indicating an Invalid Field in the Command status code.

function: scripts/placement/02_logpage_test.py::test_config_validate_fdp_configuration_descriptors

Verify the validity of FDP Configuration Descriptors, specifically the FDP Configuration Valid bit and associated fields in the FDP Configuration Descriptor.

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement – Section 5.16.1

Steps

Retrieve the FDP Configurations log page header (first 16 bytes)
Extract the total size of the log page and the number of FDP configurations
Initialize the offset to start reading FDP Configuration Descriptors
Iterate through each FDP Configuration Descriptor
Retrieve the first 16 bytes of the current configuration descriptor
Extract the size of the descriptor to prepare for full retrieval
Retrieve the full configuration descriptor based on its size
Reclaim Group Identifier Format (RGIF): normally only single one RG
Check the FDP Configuration Valid bit (Bit 7 in Byte 02)
Ensure that the required fields have non-zero values
Extract the number of Reclaim Unit Handles (NRUH)
Verify that each Reclaim Unit Handle type is either 1 (Host Specified) or 2 (Controller Specified)

function: scripts/placement/02_logpage_test.py::test_handle_usage_fdp_disabled

Verify that the controller aborts the Get Log Page command with FDP Disabled error

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement – Section 5.16.1

Steps

Allocate buffer for log page retrieval
Issue Get Log Page command for Reclaim Unit Handle Usage (Log Page Identifier 21h)
Expect an error with status 00/29 if FDP is disabled

function: scripts/placement/02_logpage_test.py::test_handle_usage_fdp_enabled

Verify that the Get Log Page command retrieves the Reclaim Unit Handle Usage page

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement – Section 5.16.1

Steps

Allocate buffer for log page retrieval
NSID field is reserved
NSID field is reserved if FDP is enabled
Issue Get Log Page command with NSID reserved (should succeed)
Number of Reclaim Unit Handles (NRUH): This field identifies the number of Reclaim Unit Handle Usage Descriptors in the Reclaim Unit Handle Usage Descriptor List. This field shall be a non-zero value.

function: scripts/placement/02_logpage_test.py::test_handle_usage_descriptor

Verify that Reclaim Unit Handle Usage descriptors are correctly retrieved and processed,

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement – Section 5.16.1

Steps

Retrieve the Reclaim Unit Handle Usage log page header (first 8 bytes)
Extract the number of Reclaim Unit Handles (NRUH)
Initialize offset for retrieving descriptors and a counter for Controller Specified entries
Iterate through all Reclaim Unit Handles and validate the attributes
Allocate buffer for the descriptor (8 bytes per descriptor)
Retrieve each Reclaim Unit Handle Usage descriptor
Extract the attributes from the descriptor
Check that the attribute is “not used by a namespace” (0h)
Count the entries marked as “Controller Specified” (2h)

function: scripts/placement/02_logpage_test.py::test_handle_usage_descriptor_with_ns

Verify that Reclaim Unit Handle Usage descriptors are correctly retrieved for a namespace,

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement – Section 5.16.1

Steps

Retrieve the Reclaim Unit Handle Usage log page header (first 8 bytes)
Extract the number of Reclaim Unit Handles (NRUH)
Initialize offset for retrieving descriptors and a counter for Controller Specified entries
Iterate through all Reclaim Unit Handles and validate the attributes
Allocate buffer for the descriptor (8 bytes per descriptor)
Retrieve each Reclaim Unit Handle Usage descriptor
Extract the attributes from the descriptor
Check that the attribute is “Host Specified” (1h) when associated with a namespace

function: scripts/placement/02_logpage_test.py::test_statistics_fdp_disabled

Verify that when FDP is disabled, the controller aborts the Get Log Page command

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement – Section 5.16.1

Steps

When FDP is disabled, expect an error with FDP Disabled status (00/29)

function: scripts/placement/02_logpage_test.py::test_statistics_written_counter

Verify the FDP Statistics Log Page (Log Page Identifier 22h) for correct reporting of

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement – Section 5.16.1

Steps

Wait for counter updates (SSD stats update interval)
Extract Host Bytes with Metadata Written (HBMW) and Media Bytes with Metadata Written (MBMW)
Ensure the counters are reset to 0 after the FDP feature is modified via Set Features command
Write data to generate Host and Media bytes
Calculate the expected bytes written (based on LBA and sector size)
Retrieve the counters again after the I/O operation
Validate that the Host Bytes and Media Bytes are updated as expected

function: scripts/placement/02_logpage_test.py::test_statistics_nsid_reserved

Verify that NSID is reserved in the FDP Statistics Log Page (Log Page Identifier 22h) when FDP is enabled.

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement – Section 5.16.1

Steps

Allocate buffer for log page retrieval
Retrieve the log page with NSID set to reserved value (0)
Invalid NSID values should trigger an error

function: scripts/placement/02_logpage_test.py::test_statistics_after_sanitize

Confirm that a Reclaim Unit Handle is modified to reference a different Reclaim Unit as part of performing a sanitize operation.

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement

Steps

Write data to all Placement Identifiers (PIDs) before the sanitize operation
Capture statistics before performing sanitize operation
Perform sanitize operation
Capture statistics after performing sanitize operation
Verify that the Reclaim Unit Handle has been modified
Assert that after sanitize, all Reclaim Unit Handles have the same remaining LBA and time

file: scripts/placement/03_features_test

function: scripts/placement/03_features_test.py::test_setting_default_value

Verify that the default value of the Flexible Data Placement (FDP) feature is 0h.

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement – Section 5.27.1

Steps

Retrieve the current FDP feature value
Retrieve the default FDP feature value

function: scripts/placement/03_features_test.py::test_setting_default_value_fdp_enabled

Verify that the default value of the Flexible Data Placement (FDP) feature is 0h.

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement – Section 5.27.1

Steps

Retrieve the current FDP feature value
Retrieve the default FDP feature value

function: scripts/placement/03_features_test.py::test_setting_saveable_bit

Verify that the FDP feature can only be modified when the SV bit is set to 1 in the Set Features command.

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement – Section 5.27.1

Steps

Check if ONCS bit 4 is set (FDP support)
Try to set FDP feature without SV bit (expecting failure)
Set FDP feature with SV bit set to 1 (should succeed)
Verify FDP feature was updated
Reset FDP feature to default (0h)

function: scripts/placement/03_features_test.py::test_setting_enable_fdp_with_namespace

Verify that a namespace can be created properly, but attempting to modify the FDP feature after namespace creation results in a “Command Sequence Error”.

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement – Section 8.TBD.1

Steps

Create a single namespace using the provided utility function
Attempt to modify the FDP feature (set it to ‘1’)
Expecting a “Command Sequence Error” (ERROR status: 00/0c)
Attempt to disable the FDP feature (set it to ‘0’)
Delete the namespace to clean up

function: scripts/placement/03_features_test.py::test_setting_double_associated

Verify that a specific Reclaim Unit Handle cannot be associated with more than one Placement Handle per namespace.

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement

Steps

Attempt to create a namespace with the same RUH (0) associated with multiple PHs
Attempt to create a namespace where RUH 1 is associated with PH 1 and PH 2
Attempt to create a namespace with multiple RUHs, some being duplicated
Create a valid namespace with unique RUH associations

function: scripts/placement/03_features_test.py::test_setting_resume_controller_reset

Verify that following a controller level reset, Flexible Data Placement (FDP) is properly resumed for an Endurance Group.

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement

Steps

Retrieve and store the current FDP feature value and configuration index
Retrieve and store the current Reclaim Unit Handle (RUH) Status data
Perform a controller level reset
Check if FDP feature is properly resumed by verifying the FDP configuration index and status
Verify that the RUH status matches the previous state for each namespace in the Endurance Group

file: scripts/placement/04_io_test

function: scripts/placement/04_io_test.py::test_reclaim_update_on_full_capacity

Verify that when a Reclaim Unit is written to capacity, the controller updates

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement

Steps

Retrieve initial Reclaim Unit Handle mapping and total LBA count
Define I/O parameters for filling the Reclaim Unit
Perform continuous write operations to fill the Reclaim Unit using ioworker
After ioworker completes, get the remaining LBA count
Perform additional writes for 5 seconds to trigger RUH update
Get the updated LBA count after the short write
Verify that the remaining LBA count has increased, indicating RUH update

function: scripts/placement/04_io_test.py::test_management_receive_numd

Verify the behavior of the Number of Dwords (NUMD) field for the I/O Management Receive command (Opcode 0x12).

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement – Section 7.TBDIOMR

Steps

Retrieve the full 128 bytes data structure
Retrieve only 32 bytes (8 DWORDs)
Retrieve with a larger NUMD, expecting full data structure (128 bytes)

function: scripts/placement/04_io_test.py::test_management_invalid_operation

Verify the behavior of the Number of Dwords (NUMD) field for the I/O Management Receive command (Opcode 0x12).

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement – Section 7.TBDIOMR

Steps

Valid operation: No action (MO=00h)
Valid operation: Reclaim Unit Handle Status (MO=01h)
Invalid operation: MO=02h (reserved)

function: scripts/placement/04_io_test.py::test_management_fdp_disabled

Verify that if FDP is disabled in the Endurance Group, the I/O Management Receive command is aborted with “FDP Disabled” status.

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement – Section 7.TBDIOMR

Steps

Use Namespace ID 1 for this test, assuming FDP is disabled for this namespace
Expect the command to be aborted with a status indicating FDP Disabled (00/29h)
Expect the command to be aborted with a status indicating FDP Disabled (00/29h)
Close the namespace after the test

function: scripts/placement/04_io_test.py::test_management_nsid_invalid

Verify that the I/O Management Receive command is aborted with “Invalid Namespace or Format” when NSID is invalid (0h or FFFFFFFFh).

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement – Section 7.TBDIOMR

Steps

Case 1: NSID = 0h, expect the command to be aborted with Invalid Namespace or Format (00/02h)
Case 2: NSID = FFFFFFFFh, expect the command to be aborted with Invalid Namespace or Format (00/02h)
Case 3: Test with an NSID that doesn’t exist (e.g., nsid + 1)

function: scripts/placement/04_io_test.py::test_management_receive_numd_large

Verify that if the host reads beyond the size of the Reclaim Unit Handle Status data structure, zeroes are returned.

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement – Section 7.TBDIOMR

Steps

Retrieve the head of the buffer
Get the number of Reclaim Unit Handle Status Descriptors (NRUHSD)
Convert expected size to DWORDs for cdw11 (1 DWORD = 4 bytes)
Request data beyond the actual structure size
Extract data beyond the expected structure size
Verify data beyond the structure size is zero-filled

function: scripts/placement/04_io_test.py::test_management_update_without_buf

Verify that issuing an I/O Management Send command without a valid buffer or with invalid arguments results in an error.

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement

Steps

Send command with MO set to 0 (No action) – this should pass
Issue command with invalid MO (e.g., MO=2, which is reserved) – should trigger error
Issue command with MO=1 (Reclaim Unit Handle Update) but without valid buffer – should trigger error

function: scripts/placement/04_io_test.py::test_management_send_mo_invalid

Verify that I/O Management Send command with MO set to ’00h’ (No action) doesn’t perform any updates.

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement

Steps

write some data to RU 0 and 1
Retrieve the initial Reclaim Unit Handle status
Send I/O Management Send command with MO=00h (No action)
Retrieve the Reclaim Unit Handle status after the command
Assert that the Reclaim Unit Handle remains unchanged
invalid MO = 2

function: scripts/placement/04_io_test.py::test_management_update_ruh

Verify that I/O Management Send command performs the Reclaim Unit Handle Update operation correctly with MO set to ’01h’.

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement

Steps

write some data to RU 0 and 1
Prepare valid Placement Identifier list (PIU) in the buffer
Retrieve initial Reclaim Unit Handle status
Issue I/O Management Send command to update Reclaim Unit Handles (MO=01h)
Retrieve Reclaim Unit Handle status after the update
Verify Reclaim Unit Handles have been updated as expected
RU2 is empty, so no need to update
RU3 is not updated here

function: scripts/placement/04_io_test.py::test_management_update_ruh_with_io

Verify that I/O Management Send command performs the Reclaim Unit Handle Update operation correctly with MO set to ’01h’.

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement

Steps

Prepare valid Placement Identifier list (PIU) in the buffer
write some data to RU 0 and 1
Issue I/O Management Send command to update Reclaim Unit Handles (MO=01h)

function: scripts/placement/04_io_test.py::test_management_update_invalid_placement_id

Summary not provided.

Reference
N/A

Steps

Find the count of placement in the namespace
fill an invalid placement id to the buffer
Issue I/O Management Send command with invalid place id
the controller shall abort the command with a status code of Invalid Field in Command

function: scripts/placement/04_io_test.py::test_management_update_invalid_npid

Summary not provided.

Reference
N/A

Steps

Find the count of placement in the namespace
Issue I/O Management Send command with invalid npid
the controller shall abort the command with a status code of Invalid Field in Command

function: scripts/placement/04_io_test.py::test_write_invalid_pid

Confirm the behavior when a write command specifies an invalid Placement Identifier (PID).

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement

Steps

Retrieve the number of valid Placement Identifiers (PIDs)
Capture statistics before the write operation
Issue a write command with an invalid PID
Capture statistics after the write operation
Verify that statistics have changed even with the write using an invalid Placement Identifier

function: scripts/placement/04_io_test.py::test_write_without_directive

Confirm the behavior when a write command specifies a Placement Identifier (PID), but no Data Placement Directive is provided. The data should be placed using Placement Handle value 0h.

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement

Steps

Capture statistics before the write operation
Issue a write command with a PID (e.g., 1), but without the Data Placement Directive (no io_flags for FDP)
Capture statistics after the write operation
Verify that the write was done using Placement Handle 0, despite specifying PID 1

function: scripts/placement/04_io_test.py::test_write_data_placement_without_directive

Confirm the behavior when a write command does not specify the Data Placement Directive, defaulting to Placement Handle value 0h.

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement

Steps

Capture statistics before the write operation
Issue a write command without specifying the Data Placement Directive (no io_flags for FDP)
We write 8 sectors with 10,000 IOPS over a 10-second period
Capture statistics after the write operation
Log the before and after statistics for debugging
Validate that only Placement Handle 0 is affected
The Placement Handle 0 should reflect the changes in its usage (Bytes Written), while other handles remain unchanged.
Validate that all other Placement Handles were unaffected
Ensures that only PH 0 was affected by the write operation

function: scripts/placement/04_io_test.py::test_write_different_operations

Verify that I/O Management Send command performs the Reclaim Unit Handle Update operation correctly with MO set to ’01h’.

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement

Steps

Perform write operations without Data Placement Directive
Perform write operations with Data Placement Directive
Perform write operations with Data Placement Directive

function: scripts/placement/04_io_test.py::test_write_read_different_pli

Test FDP by writing data to one Placement Identifier (PLI) and reading it from another PLI

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement

Steps

write phase use PLI 1
read phase use PLI 2

file: scripts/placement/05_directive_test

function: scripts/placement/05_directive_test.py::test_identify_return_parameters

Confirm that the Identify Directive bit is always cleared to ‘0’, ensuring that the host cannot change its state.

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement

Steps

Issue a Directive Receive command for Identify Directive (dtype=0)

function: scripts/placement/05_directive_test.py::test_identify_directive_immutable

Confirm that the Identify Directive bit is always cleared to ‘0’, ensuring that the host cannot change its state.

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement

Steps

Issue a Directive Receive command for Identify Directive (dtype=0)
Extract ‘support’, ‘enabled’, and ‘persistent’ bit fields from the buffer
Check that Directive type 0 (Identify) and type 2 (FDP) are supported and enabled
Check that the Identify Directive is not persistent across controller resets (Identify must remain cleared)

function: scripts/placement/05_directive_test.py::test_directive_enable_invalid_nsid

If the Directive is the Data Placement Directive and an NSID value of FFFFFFFFh is specified,

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement

Steps

First, enable the directive with a valid NSID (ensure it works correctly)
Now, attempt to enable the directive with an invalid NSID (FFFFFFFFh)
Expecting failure with status code indicating Invalid Namespace or Format

function: scripts/placement/05_directive_test.py::test_directive_data_placement

Verify that any Directive Receive or Directive Send command specifying a Data Placement Directive Type

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement

Steps

Attempt to issue a Directive Send command with Data Placement Directive Type (dtype = 2)
Expect the command to fail with Invalid Field in Command status
Attempt to issue a Directive Receive command with Data Placement Directive Type (dtype = 2)
Expect the command to fail with Invalid Field in Command status

file: scripts/placement/06_namespace_test

function: scripts/placement/06_namespace_test.py::test_shared_reclaim_unit_handle_invalid_format

Verify that the command is aborted with a status code of Invalid Format if the Reclaim Unit Handle is shared by other namespaces and the Format Index does not match.

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement

Steps

Create a namespace with a specific format
create another namespace with a different format, but using a common RU handle
create another namespace with the same format
Attempt to format the first namespace with a different block size (512), expect failure due to shared Reclaim Unit Handle with incompatible format
Perform some I/O operations on the valid namespace with correct format
Clean up and close namespace

file: scripts/placement/07_event_test

file: scripts/placement/08_performance_test

function: scripts/placement/08_performance_test.py::test_fdp_performance_compare

Evaluate FDP performance using large block write operations with and without FDP directive.

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement

Steps

Calculate I/O size in sectors
Perform the first I/O workload with FDP directive enabled
Perform the second I/O workload without FDP directive
Compare the performance between FDP-enabled and without FDP
Assert that the performance difference is within acceptable range (less than 1%)

function: scripts/placement/08_performance_test.py::test_fdp_latency_compare

Assess FDP performance under a high IOPS workload and compare latency with and without FDP directive enabled.

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement

Steps

I/O size in sectors (4KB)
Perform high IOPS workload with FDP directive enabled
Perform high IOPS workload without FDP directive
Compare latencies and log the difference
Assert that the latency difference is within acceptable range (e.g., less than 5% difference)

function: scripts/placement/08_performance_test.py::test_fdp_mixed_io_compare

Compare FDP performance under mixed read/write IO workloads with different read percentages (10%, 50%, 90%).

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement

Steps

I/O size in sectors (4KB)
Perform mixed read/write workload with FDP directive enabled
Perform mixed read/write workload without FDP directive
Compare read and write IO counts between FDP enabled and disabled runs
Assert the performance difference is within acceptable range (e.g., less than 5%)

function: scripts/placement/08_performance_test.py::test_fdp_multi_ns_performance

Measure the performance of multiple namespaces with FDP enabled under high I/O load.

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement

Steps

I/O size in sectors (4KB)
create another one ns with 1 RUH
use different RUH
Compare performance: ns2 (with all RUHs) should perform better than ns1 (with 1 RUH)
use same RUH
Compare performance: ns2 (with 4 RUHs) should perform better than ns1 (with 1 RUH)
clean up

file: scripts/placement/09_stress_test

function: scripts/placement/09_stress_test.py::test_fdp_enable_disable

Perform a stress test on the FDP feature by repeatedly enabling and disabling it under high load.

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement

Steps

Ensure FDP is enabled

function: scripts/placement/09_stress_test.py::test_fdp_io_stress

Perform an intensive I/O workload with FDP enabled to assess system stability and performance.

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement

Steps

Iterate through different configurations of I/O sizes and read percentages
Perform I/O with varying io_size, read percentage, and placement identifier (cdw13)
Log the I/O worker result

function: scripts/placement/09_stress_test.py::test_fdp_io_stress_async

Perform an intensive asynchronous I/O workload with FDP enabled to assess system stability and performance.

Reference

NVM Express® Technical Proposal 4146 Flexible Data Placement

Steps

Iterate through different configurations of I/O sizes and read percentages
Perform asynchronous I/O with varying io_size, read percentage, and placement identifier (cdw13)
Wait for all I/O workers to complete and collect the results