OCP_2_5_Group_2

DSSD_25_Admin_Command_Execution_Time_Verification_Test_Case.py

Admin Command Execution Time Verification Test Case:

For Standard Duration Admin Commands, the CTO test objectives are to verify that each validly formatted admin command completed successfully within 10 seconds under the following scenarios:

Admin commands issued sequentially,

Admin commands issued in the presence of a stressing background I/O workload.

DSSD_25_Arbitration_Test_Case.py

This script will run the following tests:

Verify that the device’s default arbitration is Round-Robin by reading CC.AMS.
Verify that the device supports Weighted round robin with urgent class priority by reading CAP.AMS.
Verify that the arbitration can be changed to Weighted Round Robin by changing CC.AMS field.

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

NVMe-CFG-1

clear_bit(value, bit)

Clears a bit to 0

Parameters:

value (int) – value to be modified
bit (int) – index to be modified

Return type:

int

set_cc_ams(dut, ams)

Sets CC.AMS value

Parameters:

dut (XML_API) – Device object under test
ams (int) – Arbitration Mechanism Selected for setting

Return type:

None

verify_bit(value, bit, on=True)

Verifies if a bit is set to 1 or cleared to 0

Parameters:

value (int) – value to be checked
bit (int) – index to be checked
on (bool) – If checking against 1, true, if 0, false

Return type:

bool

verify_cc_ams(dut, expected_ams)

Verifies arbitration mechanism selected is set as expected

Parameters:

value (int) – Controller Configuration return bits
expected_ams (int) – expected arbitration mechanism selected

Return type:

None

verify_cc_en(dut, on, timeout)

Verifies CC.EN is set to a particular value

Parameters:

dut (XML_API) – Device object under test
on (bool) – If CC.EN should be 1 or 0
timeout (int) – Expected timeout in seconds

Returns:

end_time – time that CSTS.RDY is expected to transition by

Return type:

int

wait_csts_rdy(dut, end_time, rdy_bit)

Waits timeout / 2 seconds for CSTS.RDY bit to transition after changing CC.EN

Parameters:

dut (XML_API) – Device object under test
end_time (int) – Expected timeout limit (timeout + time.time())
rdy_bit (int) – Expected value for CSTS.RDY to transition to

Return type:

None

DSSD_25_Basic_Command_And_Data_Verification_Test_Case.py

This script will run the following tests:

Do GetLogPage for LID 2h with different NSIDs
Check various field values
Do controller reset and repeat steps 1-2
Do FLR and repeat steps 1-2
Do NSSR and repeat steps 1-2

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.0 requirements referenced by this script:

STD-LOG-2/3/18/23, SLOG-1/3/4/5/11

DSSD_25_Basic_Data_Persistence_Test_Case.py

Basic Data Persistence Test Case

The purpose of this test case is to verify the following:

That the SMART/Health Information Extended Log (C0h) log page is returned, and the command completes with status success,

That all static attribute values in the C0h Log page persist across power cycles, resets, Sanitize, FormatNVM and TCG GenKey/RevertSP, and Revert operations, (Need to add error modes with EI),

That the limited subset of the dynamically updated attribute values that are highly unlikely to change in the absence of specific HW events persist across power cycles, resets, Sanitize, Format NVM and TCG GenKey/RevertSP, and Revert operations, (Need to add error modes with EI),

That the thermal throttling status is 0 reflecting not throttled.

That the capacitor health is greater than 1, and less than 0xFFFF.

That the value in all the reserved fields is 0.

That the NVMe Command Set Errata Version and Lowest Permitted Firmware Revision match the values in Adaptation data.

steps_1_to_11(dut): Perform repeated steps for Test Steps 1-11

DSSD_25_Basic_Namespace_Data_Verification_Test_Case.py

This script will run the following tests:

Verify that new drives come from the factory configured with exactly one active namespace sized to the maximum capacity of the device.
Verify that the FLBAS for this namespace corresponds to the default set at the factory and as specified per the device profile contained in the Adaptation data.
Verify that for a valid namespace, the namespace data returned from the Identify command exactly matches the namespace data as provided in the Adaptation data for the drive.
Verify that the values of NN and MNAN reported in the Identify Controller Dataset are set correctly per the device profile setting in the Adaptation data.
Verify that support for the NSWG field is indicated in the NSFEAT field in adaptation data.
Verify that the NSWG field in Namespace data is populated and, that the value matches the indirection unit value in Adaptation data.

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

NSM-4/5/6, NVMe-OPT-7, SECTOR-3

DSSD_25_Basic_Verification_Of_Asynchronous_Event_Requests_Test_Case.py

The objectives for the Basic Verification of Asynchronous Event Requests Test Case are as follows:

a.) Verify that the value of bit-3 in the LPA field is set to 1b, indicating the support for sending
Telemetry Log Notices.

b.) Verify that the value of bit-8 in the OAES field shall be set to 1b, indicating the support for
Namespace Attribute Notices event and the associated Changed Namespace List log page.

c.) Verify that the value of bit-9 in the OAES field shall be set to 1b, indicating the support for the
Firmware Activation Notices event.

d.) Verify that when attempting to an NVMe Asynchronous Event Request command when there are
already AERL+1 Asynchronous Event Request commands pending, the latest Asynchronous Event Request command shall fail because the number of outstanding Asynchronous Event Request commands has been exceeded.

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

NVMe-OPT-8/9/10/11, NVMe-AD-24/25

DSSD_25_Boot_Requirements_Test_Case.py

This script will run the following tests:

Verify that the Expansion ROM Base Address contains a value of 0 indicating that an Option ROM is not included

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

BOOT-2

DSSD_25_Clear_FW_Update_History_Test_Case.py

This script will run the following tests:

Determine the current and alternate firmware slots
Clear the FW Update History log and verify it was cleared
Download the previous firmware image
Alternate committing the previous and current firmware images multiple times
Verify Valid Firmware Activation History Entries count is correct
Clear the FW Update History log and verify it was cleared

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

CFUH-1 to CFUH-15, GETF-2

DSSD_25_Clear_PCIe_Correctable_Error_Counters_Test_Case.py

This script will run the following tests:

Issue Set Features to clear PCIe correctable error count
Do GetLogPage for LID C0h and verify PCIe Correctable Error Count is zero
Power cycle the drive
Delay 20 seconds
Do GetLogPage for LID C0h and verify PCIe Correctable Error Count is zero
Issue Set Features with SV = 1
Verify the command aborts with status code 0Dh Feature Identifier Not Savable.

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

CPCIE-1-15, GETF-2

DSSD_25_Commands_Received_During_Device_Self_Test_Operation_Test_Case.py

This script will run the following tests:

While the Device Self-test command is in progress, the device properly terminates the new extended device self-test command with a status code of “Device Self-test in Progress.
If a new device self-test command with STC = Fh be sent while the Extend Device Self-Test command is in progress, the device properly terminates the ongoing device self-test operation.
If a new device self-test command with STC = Fh be sent while the Short Device Self-Test command is in progress, the device properly terminates the ongoing device self-test operation.
That the device self-test command with STC = Fh completes successfully.
While the Short Device Self-test Operation is in progress, the device properly terminates the ongoing device self-test command once a Controller Level reset is triggered.
While the Short Device Self-test Operation is in progress, the device properly terminates the ongoing device self-test command once a Format NVM command is received.
While the Short Device Self-test Operation is in progress, the device properly terminates the ongoing device self-test command once a Sanitize Command is received.
While the Extend Device Self-test Operation is in progress, the device properly terminates the ongoing device self-test command once a Format NVM command is received.
While the Extend Device Self-test Operation is in progress, the device properly terminates the ongoing device self-test command once a Sanitize Command is received.

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

NVMe v2.0d Section 5.9/5.16.1.7/8.6

exit_sanitize_failure(dut)

Performs the necessary steps to exit sanitize failure mode

Parameters:: dut (XML_API) – Device object under test
Return type:: None

find_postcondition_wait(dut)

Finds the estimated time to wait for a Sanitize operation to complete

Parameters:: dut (XML_API) – Device object under test
Returns:: wait – Time to wait for Sanitize to complete
Return type:: int

postcondition(dut, wait=7200)

Performs the necessary postcondition steps to restore DUT back to original state

Parameters:

dut (XML_API) – Device object under test
wait (int) – Estimated time to wait for Sanitize Operation if Get Log Page with LID=81h fails

Return type:

None

DSSD_25_Commands_Supported_And_Effects_Log_Page_Test_Case.py

This script will run the following tests:

Read the Controller Capabilities register and check values of bits 37 and 44
Do GetLogPage for LID 5h
Verify the log page contains an entry for each admin command shown as supported in Table 4 in the testplan
Verify the log page contains an entry for each I/O command shown as supported in Table 5 in the testplan
Check the effects bits in Table 5 in the testplan for I/O commands

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

STD-LOG-6

LogPageCheckBitValue(cmd_dict, tag, bit_fieldname, exp_value)

Check value of a particular bit

Parameters:

cmd_dict (dict) – Command dictionary to use
tag (str) – Bit field name
bit_fieldname (str) – Bit field abbreviation
exp_value (int) – Expected bit value

Return type:

None

DSSD_25_Compare_Test_Case.py

This script will run the following tests:

Confirm support and determine maximum I/O size to use
Determine and validate the maximum LBA transfer size
Test individual non-fused commands
Test valid fused operation
Test valid fused operation scenario with incorrect compare pattern
Test fused operation using nonmatching values for NLBs and verify no update performed
Test fused operation using FUSE=1 for both commands and verify no update performed
Test fused operation where first command has FUSE=2 and second command has FUSE=1 and verify no update performed
Test fused operation where second command has FUSE=0

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

NVMe-IO-1/3/4/5/6/7/8/9/10/11/12/13/14, GETF-2

check_cmd_status(cmd_result, exp_sct, exp_sc, fail_type='error')

Extract SCT and SC fields from command result and verify if the values are correct or not

Parameters:

cmd_result (dict) – command output
exp_sct (str) – Expected status code type in the form (Xh)
exp_sc (str) – Expected status code in the form (Xh)
fail_type (str) – Result status for the step (default is ‘error’)

Return type:

None

check_fused_cmd_status(command, expected_type=0, expected_status=0, any_fail=False)

Check status of the fused command

Parameters:

command (str) – command to execute (calls fused_compare_and_write() with appropriate parameter values)
expected_type (int) – Error response type in SCT field
expected_status (int) – Error response status code in SCT field
any_fail (bool) – Whether the type of failure matters, only use for checking failures

Return type:

None

execute_command(command, result_queue)

Execute a command and get the results

Parameters:

command (str) – command to execute
result_queue (list) – Response and status code

Return type:

None

fused_compare_and_write(dut, compare_slba=0, compare_nlba=1, compare_data='5a', compare_fuse=1, write_slba=0, write_nlba=1, write_data='5a', write_fuse=2)

Execute a fused compare and write command and get the results

Parameters:

dut (XML_API) – Device object under test
compare_slba (int) – Starting LBA for compare command
compare_nlba (int) – Number of LBAs for compare command
compare_data (str) – Pattern to use for compare command
compare_fuse (int) – Value of FUSE field in Dword 0 for compare command
write_slba (int) – Starting LBA for write command
write_nlba (int) – Number of LBAs for write command
write_data (str) – Pattern to use for write command
write_fuse (int) – Value of FUSE field in Dword 0 for write command

Return type:

A list containing status code and response for the compare and write commands

verify_data_buffer(dut, data_pattern, nlb=1, slba=0)

Check status of the fused command

Parameters:

dut (XML_API) – Device object under test
data_pattern (str) – Pattern to use in the I/O test
nlb (int) – Number of LBAs
slba (int) – Starting LBA

Returns:

True or False

Return type:

bool

DSSD_25_Controller_Memory_Buffer_Test_Case.py

This script will run the following tests:

Verify that if the value of CMBMSC.CRE is 0b, both values of CMBLOC and CMBSZ are cleared to 00h.
Verify that if the value of CMBMSC.CRE is NOT 0b, either CMBMSC.CMSE or CMBSTS.CBAI has 0b value

Pass/Fail: Script passes if all model number characters are ASCII

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

NVMe-CFG-11

DSSD_25_Controller_Reset_Test_Case.py

This script will run the following tests:

Execute controller reset
Verify AQA, ASQ, ACQ, CMBMSC and PMRMSC registers didn’t change

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

NVMeR-2

DSSD_25_Controller_Status_Ready_Test_Case.py

This script will run the following tests:

Reset the controller by clearing CC.EN field to zero.
Enable the controller, CC.EN=1.
Device will set CSTS.RDY to 1 when it is ready.
Device should service ADMIN commands as soon as CSTS.RDY = 1.

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

TTR-3/4

DSSD_25_Data_Persistence_Across_Format_NVM_Operations_Test_Case.py

The objective for the Data Persistence Across Format NVM Operations test case is to verify that the data in the SMART / Health Information Log Page (LID 02h) persists across Format NVM operations by performing the following checks:

Verify that all reserved and unsupported fields are cleared to 0 and do not change.

Verify that all statically defined fields remain unchanged.

Verify that all dynamically updated counter attribute values that are highly unlikely to change in the absence of specific HW events persist across the Format NVM Commands are either unchanged or have increased in value. The notable exception to this would be fields such as the Available Spares attribute that should persist through the Format NVM Commands but may decrease in value due to the nature of what is being reported.

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

STD-LOG-2/3/18/23, SLOG-1/3/4/5/11

DSSD_25_Data_Persistence_Across_Sanitize_Operations_Test_Case.py

The objective for the Data Persistence Across Sanitize Operations test case is to verify that the data in the SMART / Health Information Log Page (LID 02h) persists across Sanitize Operations by performing the following checks:

Verify that all reserved and unsupported fields are cleared to 0 and do not change.

Verify that all statically defined fields remain unchanged.

Verify that all dynamically updated counter attribute values that are highly unlikely to change in the absence of specific HW events persist across the sanitize process are either unchanged or have increased in value. The notable exception to this would be fields such as the Available Spares attribute that should persist through Sanitize Commands but may decrease in value due to the nature of what is being reported.

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

STD-LOG-2/3/18/23, SLOG-1/3/4/5/11

postcondition(dut)

Data Persistence Across Sanitize Operations Test Case - Postcondition

DUT should be restored to its starting condition. If the Sanitize command should fail at any point the steps to exit Sanitize Failure Mode must be performed. If the test case itself should fail at some step while the Sanitize Operation is in progress the Sanitize Operation must be allowed to complete prior to exiting the failed test case. In all test case outcomes namespace recreation steps shall be performed before exiting the test case.

DSSD_25_Data_Persistence_Across_TCG_Operations_Test_Case.py

Data Persistence Across TCG Operations Test Case: The objective for the Data Persistence Across TCG Operations test case is to verify that the data in the SMART / Health Information Log Page (LID 02h) persists across the required TCG operations by performing the following checks:

Verify that all reserved and unsupported fields are cleared to 0 and do not change.

Verify that all statically defined fields remain unchanged.

Verify that all dynamically updated counter attribute values that are highly unlikely to change in the absence of specific HW events persist across the TCG purge related operations are either unchanged or have increased in value. The notable exception to this would be fields such as the Available Spares attribute that should persist through the TCG purge related operations but may decrease in value due to the nature of what is being reported.

DSSD_25_Dataset_Management_Command_Verification_Test_Case.py

The objectives of this test case are as follows:

Verify support for the Dataset Management command by checking bit-2 of the ONCS field in the Identify Controller dataset.
Verify the use of the Dataset Management command with Attribute = AD for deallocate.
Verify that data blocks that have been deallocated read back as 0.
Verify that after an unsafe power cycle, data blocks that have been deallocated continue to read back as 0.

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

OCP-NVMe-IO-2, OCP-TRIM-1/2/8

DSSD_25_Destructiveness_For_Device_Self_Test_Operation_Test_Case.py

This script will run the following tests:

Verify that user data pattern created during preconditioning is unchanged after a self-test operation.

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SELFTST-11

DSSD_25_Device_Capabilities_Log_Page_Test_Case.py

This script will run the following tests:

NVMe Get Log Page Command with LID=C4h
NVMe Identify Command with CNS=01h
Verify number of physical PCIe ports matches the corresponding field in adaptation parameters
Verify bytes 1:0 of OOB Management Support field are correct
Verify bytes 1:0 of Write Zeroes Command Support field are correct
Verify bytes 1:0 of Sanitize Command Support field are correct
Verify bytes 1:0 of Dataset Management Command Support field are correct
Verify bytes 1:0 of Write Uncorrectable Command Support field are correct
Verify bytes 1:0 of Fused Operation Support field are correct
Verify various values for DSSD Power States

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

DCLP-1 to DCLP-12

DSSD_25_Drive_Behavior_In_Case_Of_PLP_Failure_Test_Case.py

This script will run the following tests:

Perform sequential write/read for five minutes
Inject PLP error
Record EOL-PLP setting
Perform sequential writes for one minute and verify pass/fail based on EOL-PLP setting
Recover the device from the error injection
Check drive performance after it recovers

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

PLP-9

DSSD_25_Drive_State_After_Firmware_Activation_Without_Reset_Test_Case.py

The objectives of this test case are to verify the following:

That firmware activation without reset does not change the contents of the features listed in the Feature Table

That firmware activation without reset does not change the contents of the log pages listed in the Log Page Table.

That firmware activation without reset does not change the PCIe Link Status.

That firmware activation without reset does not change the IO SQ/CQ queue settings.

That firmware activation without reset does not change the LBA format.

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

FWUP-11

compare_dict(log_a, log_b, resv, static, dyn)

Compares corresponding values in two dictionaries

Parameters:

log_a (dict) – First dictionary of objects to be compared
log_b (dict) – Second dictionary of objects to be compared
resv (list) – List of reserved fields
static (list) – List of static fields
dyn (list) – List of dynamic fields

Return type:

None

enable_fw_update(dut)

Enables FW Update in SMBus command code 90 (byte 91)

Parameters:: dut (XML_API) – Device object under test
Return type:: None

get_feature_state(dut)

Does Get Features on a FID

Parameters:: dut (XML_API) – Device object under test
Return type:: Feature data

get_identify_state(dut)

Executes steps 25-30

Parameters:: dut (XML_API) – Device object under test
Return type:: Identify data for CNS 0h and 1h

get_io_state(dut)

Executes steps 20-23

Parameters:: dut (XML_API) – Device object under test
Return type:: None

get_log_page_state(dut, endgid)

Does Get Log Page on a LID

Parameters:

dut (XML_API) – Device object under test
endgid (int) – ENDGID value for LID 9h

Return type:

Log page data

get_pcie_link_status(dut)

Get the PCIe link status

Parameters:: dut (XML_API) – Device object under test
Return type:: PCIe link status

issue_io(dut, seektype, io_profile, threads, blocks, iosperpass=0, io_runtime=-1, io_pattern=0, extra_config=None)

Executes an IO Test

Parameters:

dut (XML_API) – Device object under test
seektype (str) – Either ‘Sequential’ | ‘Random’
io_profile (str) – IO Profile to be executed
threads (int | str) – Threads (QD) to execute IO on
blocks (int | str) – Number of Logical Blocks
iosperpass (int | str) – Param to determine what the IO does on the drive ‘0’: unlimited, ‘-1’: Iterate once over drive, ‘-2’: Iterate twice over drive
io_runtime (int) – Time in seconds for IO to execute
io_pattern (int) – Pattern for io to be executed
extra_config (dict | None) – Optional parameter for running IO test with additional configurations

Return type:

dict

verify_ios(io_tests)

Checks if I/O tests passed or failed

Parameters:: io_tests (list) – list of I/O test dicts
Returns:: io_failed – Returns failed if any I/O test failed
Return type:: bool

DSSD_25_E1L_PCIe_Speed_And_Lane_Width_Test_Case.py

This script will run the following tests:

Verify PCI Express Link Capabilities register (0Ch) lane width and speed
Verify PCI Express Link Status register (12h) lane width and speed

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

FFE1L-2

DSSD_25_E1L_PWRDIS_Test_Case.py

This script will run the following tests:

Assert PWRDIS and wait for device to shutdown
De-assert PWRDIS and wait for device to come up
Start sequential write I/O test and assert PWRDIS and wait for device to shutdown
De-assert PWRDIS and wait for device to come up
Run sequential read I/O test for 5 minutes and verify there are no miscompares
Run sequential write I/O test for 5 minutes
Run sequential read I/O test for 5 minutes
Verify performance is within 5% of performance numbers supplied in adaptation parameters

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.0 requirements referenced by this script:

FFE1L-9

wait_assert(dut)

Wait for PWRDIS signal to be asserted

Parameters:: dut (XML_API) – Device object under test
Return type:: None

wait_deassert(dut)

Wait for PWRDIS signal to be de-asserted

Parameters:: dut (XML_API) – Device object under test
Return type:: None

DSSD_25_E1S_PCIe_Speed_And_Lane_Width_Test_Case.py

This script will run the following tests:

Verify PCI Express Link Capabilities register (0Ch) lane width and speed
Verify PCI Express Link Status register (12h) lane width and speed

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

FFE1S-2

DSSD_25_E1S_PWRDIS_Test_Case.py

This script will run the following tests:

Assert PWRDIS and wait for device to shutdown
De-assert PWRDIS and wait for device to come up
Start sequential write I/O test and assert PWRDIS and wait for device to shutdown
De-assert PWRDIS and wait for device to come up
Run sequential read I/O test for 5 minutes and verify there are no miscompares
Run sequential write I/O test for 5 minutes
Run sequential read I/O test for 5 minutes
Verify performance is within 5% of performance numbers supplied in adaptation parameters

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.0 requirements referenced by this script:

FFE1S-9

wait_assert(dut)

Wait for PWRDIS signal to be asserted

Parameters:: dut (XML_API) – Device object under test
Return type:: None

wait_deassert(dut)

Wait for PWRDIS signal to be de-asserted

Parameters:: dut (XML_API) – Device object under test
Return type:: None

DSSD_25_EUI64_And_NGUID_Test_Case.py

This script will run the following tests:

Verify that if the device comes from the factory, the namespace has a nonzero value for EIU64.
Verify that for all subsequent namespace creations after the first created namespace, the EUI64 field is 0.
Verify that for all namespace creations, the NGUID field is nonzero and contains a value that is different from the default and from all other NGUID values. Also verify UIDREUSE bit is set to 1.

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

NVMe-CFG-7/8

DSSD_25_Endianness_Verification_Test_Case.py

This script will run the following tests:

Do GetLogPage for LID C0h
Check that byte 0 of Security Version Number and Log Page Version fields is correct
Verify Log Page GUID is correct

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SLOG-1/3/4/10, STD-LOG-23, SMART-1/2/12-28/30-33

DSSD_25_Endurance_Estimate_Test_Case.py

This script will run the following tests:

Do GetLogPage for LID C0h and get Endurance Estimate field value
If endurance groups are supported, do GetLogPage for LID 9h and get Endurance Estimate field value
Verify both values are the same

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SLOG-1/3/4/10, STD-LOG-23, SMART-1/2/12-28/30-33

DSSD_25_Endurance_Group_Information_Log_Page_09h_Test_Case.py

This script will run the following tests:

Verify support for endurance groups
Read the endurance group information log page and sanity check fields
Compare endurance estimate values
Sanity check remaining fields

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.0 requirements referenced by this script:

STD-LOG-17

compare_values(field_name, output_lid_02, output_lid_09)

Compare field values from two log pages and verify they match

Parameters:

field_name (str) – Field name to compare
output_lid_02 (dict) – Output of LID 2h
output_lid_09 (dict) – Output of LID 9h

Return type:

None

DSSD_25_Error_Information_Log_Page_Test_Case.py

This script will run the following tests:

Get ELPE field
Do GetLogPage for LID 1h to get error count for each entry
Reset controller
Do IdentifyController
Do GetLogPage for LID 1h to get error count for each entry

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

STD-LOG-1

DSSD_25_Error_Recovery_Log_Page_Test_Case.py

This script will run the following tests:

Read Error Information log page to get recovery settings
Verify reserved fields and static fields and make sure device is in error free state
Record performance logs and set AEN before drive goes into error state
Inject error and recover the drive based on reset and recovery actions
Check drive performance after it recovers

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

EREC-AEN-1, EREC-1 to EREC-15

DSSD_25_Execution_Time_Device_Self_Test_Operation_Test_Case.py

This script will run the following tests:

That the device properly indicates support for the Device Self-Test operation in Identify Controller data.
That the device properly defines the Extended Device Self-test Time in Identify Controller data.
After the minimum number of required LBAs, which is available in the Adaptation Data, have been written, the extended device self-test operation is enabled.
That the Device Self-Test Log Page correctly reports the Device Self-Test Operation status.
A short device self-test operation shall be completed in less than or equal to 2 minutes.
An extended device self-test operation shall be completed in less than or equal to 30 minutes.
A vendor-specific self-test operation shall be completed in less than or equal to 2 seconds.
During the extended device self-test operation, the device properly reads all allocated LBAs and increases the value of Physical Media Units Read field in the SMART Cloud Health log page.
Even though the device self-test operation and host I/O activities are running concurrently, the device self-test operation is still completed within the OCP required time.

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

NVMe-AD-12, STD-LOG-13, SELFTST-2/3/4/5/6/9

DSSD_25_Factory_Default_Settings_Verification_Test_Case.py

This script will run the following tests:

All supported firmware slots shall contain the most recent production firmware revision.
All logical blocks shall be deallocated.
The following SMART / Health Information log page fields shall be cleared to 0h: Critical Warning, Endurance Group Critical Warning Summary, Data Units Read, Data Units Written, Host Read Commands, Host Write Commands, Controller Busy Time, Power Cycles, Power On Hours, Unsafe Shutdowns, Media and Data Integrity Errors, Percentage Used, Number of Error Information Log Entries.
The Available Spare field in the SMART / Health Information log page shall be set to a value of 100.
The Total Number of Events field in the Persistent Event log page shall be cleared to 0h.
The Sanitize Status field in the Sanitize Status log page cleared to 0 indicating the NVM subsystem has never been sanitized and the Global Data Erased bit in the Sanitize Status field set to 1b.

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

FDEF-1/2/3/4/5, NVMe-AD-22

DSSD_25_Failed_Sanitize_Operations_Test_Case.py

This script will run the following tests:

Verify support for sanitize block erase command
Verify initial sanitize state
Delete and recreate smaller fixed size namespace
Precondition namespace for sanitize
If namespace write protection is supported, verify sanitize command fails if sent while namespace is write-protected
Verify sanitize command fails while firmware update is pending

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

NVMe v2.0d 5.16.1.25/5.27.1.19/5.24/8.21

exit_sanitize_failure(dut)

Performs the necessary steps to exit sanitize failure mode

Parameters:: dut (XML_API) – Device object under test
Return type:: None

postcondition(dut, wait=7200, fail=True)

Performs the necessary postcondition steps to restore DUT back to original state

Parameters:

dut (XML_API) – Device object under test
wait (int) – Estimated time to wait for Sanitize Operation if Get Log Page with LID=81h fails
fail (bool) – If True, print ERROR message and exit the script; if False, print DETAIL message

Return type:

None

verify_data_buffer(dut, params, config)

Start an IO test, wait for it to finish, check test status

Parameters:

dut (XML_API) – Device object under test
params (dict) – Parameters for IO test
config (dict) – Configuration for IO test

Return type:

None

DSSD_25_Fatal_Status_Test_Case.py

This script will run the following tests:

Obtain CSTS.CFS and verify it’s set to zero

Pass/Fail: Script passes if register value is set to zero

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

NVMe-CFG-3

DSSD_25_Firmware_Activation_Notice_AE_Test_Case.py

The objectives for the Firmware Activation Notice AE Test Case are as follows:

a.) Verify that if an event occurs for which reporting is enabled and there are no Asynchronous Event
Request commands pending, the device retains the event information for that Asynchronous Event Type and reports it once an Asynchronous Event Request command is submitted.

b.) Verify that if duplicate events are queued while no Asynchronous Event Request commands are
pending, the duplicate events are reported as a single response to a future Asynchronous Event Request command.

c.) Verify that, if an AER is pending, after sending the NVMe Firmware Commit command with CA=3
and slot = 0, an AEN is sent to the host with the following information:

Event Type: Notice

Asynchronous Event Information: Firmware Activation Starting

Log Page Identifier: Firmware Slot Information log (03h)

d.) Verify that, if an AER is pending, after sending the NVMe Firmware Commit command with CA=3
and firmware slot specified, an AEN is sent to the host with the following information:

Event Type: Notice

Asynchronous Event Information: Firmware Activation Star

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

NVMe-OPT-8/9/10/11, NVMe-AD-24/25

verify_aer_completion(aer)

Verify that the AEN configuration is as follows: a. Event Type = ‘Notice’ b. Asynchronous Event Information = ‘Firmware Activation Starting’ c. Log Page Identifier = ‘Firmware Slot Information (03h)’

Parameters:: aer (str) – Asynchronous Event to examine
Return type:: None

DSSD_25_Firmware_Slot_Information_Log_Page_Test_Case.py

This script will run the following tests:

Get firmware slot info from LID 3h
Get FRMW from Identify Controller
Download and commit the previous firmware image to the starting firmware slot
Verify FRS field for appropriate slot in LID 3h matches the previous firmware image
Verify current and next active firmware slots in LID 3h
Do controller reset
Verify current firmware slot in LID 3h
Repeat steps 3-7 for all supported firmware slots
Commit the current firmware image to the current firmware slot

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

STD-LOG-5, MS-CONF-6

verify_slot(dut, start_fw_slot, PARAMS, prev_fw_fn)

Performs steps 10-22 of the Firmware Slot Information Log Page test plan

Parameters:

dut (XML_API) – Device object under test
start_fw_slot (int) – Initial FW slot being tested
PARAMS (dict) – Adaptation Parameters
prev_fw_fn (str) – Previous Firmware File Name

Returns:

numd (int) – Number of DWORDs limit for FW Download
numd_flag (int) – If NUMD check succeeded
start_fw_slot (int) – FW Slot as of execution of step 10

DSSD_25_Firmware_Update_Test_Case.py

Test objectives are to verify the following:

The firmware Commit command with Commit Action (CA) 000b, 001b, 010b and 011b are supported.

A minimum of 3 slots firmware slots are supported by verifying that the value of bits [3:1] in the Firmware Updates (FRMW) field is greater than or equal to 3.

The device shall complete the Firmware Activation process and be ready to accept host IO and admin commands within 1 second from the receipt of the firmware commit command. Verify that the value of Maximum Time for Firmware Activation (MTFA) field is less than or equal to Ah.

The device supports a read-only firmware slot in slot 1.

If the Firmware Slot field in the Firmware Commit command is cleared to 0h, verify that the device commits the firmware image to a firmware slot that is not currently active.

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

FWUP-3/4/6/7/20/21/25

enable_fw_update(dut)

Enables FW Update in SMBus command code 90 (byte 91)

Parameters:: dut (XML_API) – Device object under test
Return type:: None

verify_aer_completion(aer): Verify that the Asynchronous Event Type field in bits [2:0] of CQE Dword 0 is cleared to 0. Verify that the Asynchronous Event Information field in bits [15:08] of CQE Dword 0 is set to 5.

DSSD_25_Firmware_Update_Without_Data_Loss_Or_Destruction_Test_Case.py

Test objectives are to verify the following:

Device supports repeated Firmware Download and Commit operations.

Repeated Firmware Download and Commits shall not cause data to be lost or corrupted.

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

FWUP-2/10

download_commit(dut, prev_fw_fn, numd, alt_slot, start_step)

Downloads previous firmware and executes a FW commit command

Parameters:

dut (XML_API) – Device object under test
prev_fw_fn (str) – Previous firmware filename
numd (int) – Value of NUMD
alt_slot (int) – Alternate firmware slot
start_step (int) – Number of the first test step in the function

Returns:

fw_commit_flag – True if the FW commit command failed, else False

Return type:

bool

enable_fw_update(dut)

Enables FW Update in SMBus command code 90 (byte 91)

Parameters:: dut (XML_API) – Device object under test
Return type:: None

DSSD_25_Format_NVM_Command_Extended_Execution_Time_Verification_Test_Case.py

This script will run the following tests:: Verify each Format NVM commands completes within these timeout settings. 1. The Format NVM Command for Cryptographic Erase shall complete within 10 seconds. 2. The Format NVM Command for No Secure Erase shall complete within the per TB specific timeout parameter provided by the supplier in the Adaptation Data. 3. The Format NVM Command for User Data Erase shall complete within 10 seconds per TB of device capacity.

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

CTO-2, CTO-11

DSSD_25_Format_NVM_Command_On_A_Per_Namespace_Basis_Test_Case.py

This script will run the following tests:

Verify support for Format NVM command
Determine the maximum number of namespaces supported
Get and save the current namespace dataset
Calculate the LBA size
Read the namespace granularity list
Use the namespace granularity descriptor to calculate the capacity to use to create MaxNsCnt namespaces
Delete original namespace
Create and precondition new namespaces
Format (SES=1) two randomly selected namespaces
Verify the Format NVM only affected the two specific namespaces
Restore original namespace

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

NVMe-AD-2/5/8/23, SEC-4, NVMe Spec Format NVM Section

do_format(dut, nsid, lbaf, ses, pil, pi, mset, format_results)

Execute format command and put the results into a dictionary (since the format is done as part of a thread, a dictionary will allow the main part of the program to access the results)

Parameters:

dut (XML_API) – Device object under test
nsid (int) – Namespace under test
lbaf (int) – LBAF to use in the format
ses (int) – SES to use in the format
pil (int) – PIL to use in the format
pi (int) – PI to use in the format
mset (int) – MSET to use in the format
format_results (dict) – Dictionary to hold the results of the format command

Return type:

None

gen_2_ran(range_start, range_end)

Generates 2 random numbers between range_start, range_end

Parameters:

range_start (int) – Start of range (inclusive)
range_end (int) – End of range (inclusive)

Returns:

num1 (int) – First unique integer
num2 (int) – Second unique integer

DSSD_25_Format_NVM_Crypto_Erase_Test_Case.py

This script will run the following tests:

Verify support for Format NVM command
Get and save current LBA size
Precondition namespace
Start Format NVM command (SES=2)
Verify Format command has ended
Verify the Format NVM results

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

NVMe-AD-2/5/8/23, SEC-4, NVMe Spec Format NVM Section

do_format(dut, nsid, lbaf, ses, pil, pi, mset, format_results)

Execute format command and put the results into a dictionary (since the format is done as part of a thread, a dictionary will allow the main part of the program to access the results)

Parameters:

dut (XML_API) – Device object under test
nsid (int) – Namespace under test
lbaf (int) – LBAF to use in the format
ses (int) – SES to use in the format
pil (int) – PIL to use in the format
pi (int) – PI to use in the format
mset (int) – MSET to use in the format
format_results (dict) – Dictionary to hold the results of the format command

Return type:

None

DSSD_25_Format_NVM_No_Secure_Erase_Test_Case.py

This script will run the following tests:

Verify support for Format NVM command
Get and save current LBA size
Precondition namespace
Start Format NVM command (SES=0)
Verify format command has ended
Verify the Format NVM results

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

NVMe-AD-2/5/8/23, SEC-4, NVMe Spec Format NVM Section

do_format(dut, nsid, lbaf, ses, pil, pi, mset, format_results)

Execute format command and put the results into a dictionary (since the format is done as part of a thread, a dictionary will allow the main part of the program to access the results)

Parameters:

dut (XML_API) – Device object under test
nsid (int) – Namespace under test
lbaf (int) – LBAF to use in the format
ses (int) – SES to use in the format
pil (int) – PIL to use in the format
pi (int) – PI to use in the format
mset (int) – MSET to use in the format
format_results (dict) – Dictionary to hold the results of the format command

Return type:

None

DSSD_25_Format_NVM_User_Data_Erase_Test_Case.py

This script will run the following tests:

Verify support for Format NVM command
Determine if the controller will use crypto erase instead of user data erase
Get and save current LBA size
Precondition namespace
Start Format NVM command (SES=1)
Verify format command has ended
Verify the Format NVM results

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

NVMe-AD-2/5/8/23, SEC-4, NVMe Spec Format NVM Section

do_format(dut, nsid, lbaf, ses, pil, pi, mset, format_results)

Execute format command and put the results into a dictionary (since the format is done as part of a thread, a dictionary will allow the main part of the program to access the results)

Parameters:

dut (XML_API) – Device object under test
nsid (int) – Namespace under test
lbaf (int) – LBAF to use in the format
ses (int) – SES to use in the format
pil (int) – PIL to use in the format
pi (int) – PI to use in the format
mset (int) – MSET to use in the format
format_results (dict) – Dictionary to hold the results of the format command

Return type:

None

DSSD_25_Get_Set_Feature_C6_PLP_Health_Check_Interval_Test_Case.py

This script will run the following tests:

Get factory default value of feature PLP Health Check Interval (0xC6) and it should be 000Fh.
Using set feature change the interval to X minute, value other than 000Fh, and using get feature check that the current state and saved state are set to Xh no later than next power cycle.
Current and saved state should be Xh even after drive goes through power cycle.
Default state should be 000Fh.
Using set feature change the interval to 0 , Disable Health Check, and using get feature check that the current state and saved state are set to 0h no later than next power cycle.
Current and saved state should be 0h even after drive goes through power cycle.
Default state should be 000Fh.
Using set feature change the interval to 000Fh and using get feature check that the current state and saved state are set to 000Fh no later than next power cycle.
Current and saved state should be 000Fh even after drive goes through power cycle.
Default state should be 000Fh.
If setting this feature is not supported by the controller then a status error code of 0x2 (Invalid Field in Command) shall be returned.
Check the default state of 0xC6 with sel=01b.It should be 000Fh and should not change over power cycle. Current state selection should not affect the default state.
Check the capabilities of 0xC6 with sel=11b and it should be 5h indicating that this feature is savable, changeable, and not name space specific.
Check the current state of 0xC6 with sel=00b and it should match with Interval selection made with set feature.
Check the saved state of 0xC6 with sel=10b.
If this feature is not supported by the controller, then a status error code of 0x2 (Invalid Field in Command) shall be returned

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SPLPI-1 to SPLPI-15, GPLPI-1/2, GETF-1/2, PLP-7

DSSD_25_Get_Set_Feature_DSSD_Asynchronous_Event_Feature_Verification_Test_Case.py

This script will run the following tests:

For Set feature: Get factory default value of feature 0xC9 and it should be cleared to 0.
Change “Enable Panic Notices” field to 1 using set feature and using get feature check that the current state is set to 1 no later than next power cycle.
Current state should be cleared to 0 after drive goes through power cycle
Default state should be cleared to 0
Change “Enable Panic Notices” field to 0 using set feature and using get feature check that the current state is cleared to 0 no later than next power cycle.
Current should be cleared to 0 after drive goes through power cycle.
Default state should be cleared to 0.
If setting this feature is not supported, then a status error code of 0x2 (Invalid Field in Command) shall be returned.
For Get feature: Check the default state of 0xC9 with SEL=01b.It should be cleared to 0 and should not change over a power cycle. Current state selection should not affect the default state.
Check the capabilities of 0xC9 with SEL=11b and it should be 100b indicating that this feature is not savable, changeable, and not namespace specific.
Check the current state of 0xC9 with SEL=00b and it should match with selection made with set feature.

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SDAEC-1 to SDAEC-15, GDAEC-1/2

get_feat_c9_and_check(dut, sel, expected, step_num)

Retrieves the stored values in a Get-Feature for FID = C9h, and verifies the feature command’s execution

Parameters:

dut (XML_API) – Device object under test
sel (int) – The Selection field for the Get-Feature command
expected (int) – Expected value for DWORD-0 bits [2:0] of the completion queue entry
step_num (int) – The current test step number

Return type:

None

DSSD_25_Hardware_Component_Log_Page_Test_Case.py

Test objectives are to verify the following:

That the Hardware Component log page is returned, and the command completes with status success.

That the Hardware Component log page format for recording the hardware components on the device matches OCP requirements.

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

HWCOMP-1/2/3/4/5

DSSD_25_IEEE1667_Feature_Test_Case.py

This script will run the following tests:

For Set feature the objectives are to test the following:

Get factory default state of feature IEEE1667
If the default state is enabled:
- Disable IEEE1667 Silo using set feature and using get feature check that the current state and saved state are set to “disabled” no later than next power cycle
- Current and saved state should be “disabled” even after drive goes through power cycle
- Default state should be “enabled”
- Enable IEEE1667 Silo using set feature and using get feature check that the current state and saved state are set to “enabled” no later than next power cycle
- Current and saved state should be “enabled” even after drive goes through power cycle
- Default state should be “enabled”
- If setting this feature is not supported, then a status error code of 0x2 (Invalid Field in Command) shall be returned
If the default state is disabled:
- Enable IEEE1667 Silo using set feature and using get feature check that the current state and saved state are set to “enabled” no later than next power cycle
- Current and saved state should be “enabled” even after drive goes through power cycle
- Default state should be “disabled”
- Disable IEEE1667 Silo using set feature and using get feature check that the current state and saved state are set to “disabled” no later than next power cycle
- Current and saved state should be “disabled” even after drive goes through power cycle
- Default state should be “disabled”
- If setting this feature is not supported, then a status error code of 0x2 (Invalid Field in Command) shall be returned

For Get feature the objectives are to test the following:

Check the default state of C4h with SEL=01b.It should match with factory default value and should not change during power cycle. Current state selection should not affect the default state
Check the capabilities of C4h with SEL=11b and it should be 101b indicating that this feature is savable, changeable, and not name space specific
Check the current state of C4h with SEL=00b and it should match with enabled/disable selection made with set feature
Check the saved state of C4h with SEL=10b

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

S1667-1 to S1667-15, GETF-1/2

DSSD_25_IO_Command_Execution_Time_Verification_Test_Case.py

I/O Command Execution Time Verification Test Case:

For I/O commands the CTO test objectives are to verify the following:

That when executing a stressing I/O workload over the course of 1 hour no more than 7 I/Os shall take more than 2s to complete.

That when executing the previous I/O workloads under full capacities of device (Maximum Data Transfer Size and Maximum Queue Entries Supported), the performance still shall be met.

DSSD_25_Incomplete_Shutdown_Test_Case.py

This script will run the following tests:

Perform sequential write and read for five minutes and collect performance logs
Issue GetLogPage for LID 2h and check Critical Warning bits 3-4
Issue GetLogPage for LID C0h and record Incomplete Shutdowns field
Create INCS scenario on the drive
Perform 4KB random writes with a queue depth of 128
Issue Identify command and verify it passes
Issue GetLogPage for LID C0h and check Incomplete Shutdowns field
Issue GetLogPage for LID 2h and check Critical Warning bit 3
Issue GetLogPage for LID C1h and check various fields
Perform sequential writes and verify they fail
Perform sequential reads and check if they pass or fail
Format the drive
Set CC.EN=1
Issue GetLogPage for LID C1h and check Panic ID field
Issue Identify command and verify it passes
Perform sequential write and read for five minutes and collect performance logs

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

INCS-1/4/5/6

DSSD_25_LBA_Status_Information_Log_Page_Test_Case.py

This script will run the following tests:

That reading the LBA Status Information Log page is supported by the DUT.
That the log page reports LBA ranges that have been marked uncorrectable by the Write Uncorrectable command.
The test case shall use the Write Uncorrectable command to create N separate LBA ranges marked as uncorrectable.
The test case shall next read the LBA Status Information Log Page and verify that it contains a single LBA Status Namespace Element.
The test case shall verify that the number of LBA Range Descriptors reported in the LBA Status Log Namespace Element is equal to N, where N is the number of uncorrectable LBA Ranges created.
The test case shall next verify that the LBA ranges reported in the LBA Range Descriptors in the LBA Status Namespace Element match the LBA ranges marked as uncorrectable.

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

STD-LOG-11

DSSD_25_Little_Endian_Verification_Test_Case.py

This script will run the following tests:

Do GetLogPage for LID 2h and get values of Data Units Read/Written, Host Read/Write Commands, Controller Busy Time, Power Cycles, Power On Hours, and Unsafe Shutdowns fields
Issue four write and read commands, each with 251 blocks
Power cycle the drive
Do GetLogPage for LID 2h and verify Data Units Read/Written and Host Read/Write Commands values increased by at least 1
Surprise power cycle the drive
Do GetLogPage for LID 2h and verify Power Cycle Count and Unsafe Shutdowns values increased by at least 1
Perform 4KB random reads and writes for 65 minutes
Do GetLogPage for LID 2h and verify Power On Hours value increased by at least 1
Verify Controller Busy Time value stayed the same or increased by at least 1

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

STD-LOG-2/3/18/23, SLOG-1/3/4/5/11

compare_values(field_name, baseline_dict, new_values_dict, difference)

Compare field values before and after various testing

Parameters:

field_name (str) – Field name
baseline_dict (dict) – Original field value
new_values_dict (dict) – New field value
difference (int) – Expected difference between the baseline values and the new values

Return type:

None

verify_io(io_test, io_type, seektype)

Verifies the succession of an I/O command

Parameters:

io_test (dict) – I/O Command
io_type (str) – Name of I/O test
seektype (int) – 0: ‘Sequential’, 1: ‘Random’

Returns:

io_test_failed – bool on the status of IO test completion

Return type:

bool

DSSD_25_Low_Power_Modes_Requirements_Test_Case.py

This script will run the following tests:

Verify that ASPM Optionality Compliance (AOC) bit is set to 1
Verify that ASPM Support (ASPMS) field is set to 10b or 11b
Execute PCIe reset
Verify that ASPM Control (ASPMC) field is cleared to 00b

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

LPWR-1/2

DSSD_25_M2_PCIe_Speed_And_Lane_Width_Test_Case.py

This script will run the following tests:

Verify PCI Express Link Capabilities register (0Ch) lane width and speed
Verify PCI Express Link Status register (12h) lane width and speed

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.0 requirements referenced by this script:

FFM2-5

DSSD_25_Maximum_Data_Transfer_Size_Test_Case.py

This script will run the following tests:

Verify MDTS >= 256KB
Verify NPWG and NOWS <= MDTS
Do Write command with transfer size < MDTS and > NPWG, and verify it passes
Do Write command with transfer size = MDTS, and verify it passes
Do Write command with transfer size > MDTS, and verify it fails

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

NVMe-CFG-2

DSSD_25_NVMe_Commands_Received_During_Sanitize_Operation_Test_Case.py

This script will run the following tests:

Verify support for sanitize crypto erase command
Verify initial sanitize state
Delete and recreate smaller fixed size namespace
Verify that a format NVM command in progress is aborted when DUT receives sanitize command
Wait until sanitize operation completes
Verify that pending I/Os are aborted when DUT receives sanitize command
Verify that all other NVM commands are aborted by DUT while sanitize operation is in progress
Verify that admin commands not supported during sanitize are aborted by DUT when received
Verify that DST during sanitize are aborted by DUT when received
Verify that admin commands supported during sanitize operation are not aborted by DUT

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

NVMe v2.0d 5.16.1.25/5.27.1.19/5.24/8.21

check_cmd_fail(dut, result, cmd, expected_status, sanact, wait=7200)

Checks for command failure during Sanitize

Parameters:

dut (XML_API) – Device object under test
result (dict) – The dictionary returned by an XML_API call
cmd (str) – Command name to print
expected_status (int) – Expected status to return
sanact (bin) – Sanitize action to use when starting sanitize operation

Returns:

True if the command needs to be resent, False otherwise

Return type:

bool

check_sanitize(dut, cmd, sanact, wait=7200)

Restart sanitize operation if it has completed

Parameters:

dut (XML_API) – Device object under test
cmd (str) – Command name to print
sanact (bin) – Sanitize action to use when starting sanitize operation

Returns:

True if the command needs to be resent, False otherwise

Return type:

bool

do_format(dut, nsid, lbaf, ses, format_results)

Execute format command and put the results into a dictionary (since the format is done as part of a thread, a dictionary will allow the main part of the program to access the results)

Parameters:

dut (XML_API) – Device object under test
nsid (int) – Namespace under test
lbaf (int) – LBAF to use in the format
ses (int) – SES to use in the format
format_results (dict) – Dictionary to hold the results of the format command

Return type:

None

do_sanitize(dut, sanact, sanitize_results)

Execute sanitize command and put the results into a dictionary (since the sanitize is done as part of a thread, a dictionary will allow the main part of the program to access the results)

Parameters:

dut (XML_API) – Device object under test
sanact (bin) – Sanitize action to use when starting sanitize operation
sanitize_results (dict) – Dictionary to hold the results of the sanitize command

Return type:

None

exit_sanitize_failure(dut)

Performs the necessary steps to exit sanitize failure mode

Parameters:: dut (XML_API) – Device object under test
Return type:: None

postcondition(dut, wait=7200, fail=True)

Performs the necessary postcondition steps to restore DUT back to original state

Parameters:

dut (XML_API) – Device object under test
wait (int) – Estimated time to wait for Sanitize Operation if Get Log Page with LID=81h fails
fail (bool) – If True, print ERROR message and exit the script; if False, print DETAIL message

Return type:

None

verify_io_status(test_id, sc)

Checks an IO test for a particular status code being returned

Parameters:

test_id (string) – IO Test identifier
sc (string) – Status code to check for, should be in hex format

Returns:

True or False

Return type:

bool

DSSD_25_NVMe_Controller_Configuration_And_Behavior_Test_Case.py

This script will run the following tests:

Verify the stride between doorbell properties is 4 bytes as set by CAP.DSTRD
Verify the device is NVM subsystem scope as set by CAP.CPS
Verify the device supports the NVM Command Set as set by CAP.CSS and CNTRLTYPE
Verify the minimum memory page size is 2^12
Verify the maximum memory page size is at least 2 ^ (12 + 1)
Verify the maximum number of Error Information log entries that are stored by the controller is 256 as set by ELPE
Verify the device does NOT support the Host Memory Buffer by checking HMMIN and HMPRE fields are set to zero
Verify the device shall NOT support the Controller Ready Independent of Media mode, by checking CAP.CRMS.CRIMS is set to zero

Pass/Fail: Script passes if all model number characters are ASCII

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

NVMe-CFG-9/12/13/16/17/18/19/20

DSSD_25_Namespace_Attachment_Command_Verification_Test_Case.py

This script will run the following tests:

Verify Identify data appropriately updates based on current state of namespaces.
Verify that when attaching an namespace to a controller that it shifts to active.
Verify that when deleting an attached namespace from an controller that it shifts to inactive.
Verify maximum allowed namespaces can be created, attached, and appropriate Identify data reflects changes.
Based on support, see if EUI64 and NGUID differs from stored namespace data of vendor parameters file.

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

NVMe-AD-4, NUSE-1, NSM-1/2/3/4/5/6/7, NVMe v2.0d Section 3.2.1/5.22/8.11

namespace_management(dut, id_ns, sel, format_index, mset, new_ns_capacity=0, max_ns_count=1, is_private=0)

Helper function to create a new Namespace with specific field information

Parameters:

dut (XML) – Device object under test
id_ns (dict) – Identify Namespace command dictionary
sel (int) – Select Field for namespace management action
new_ns_capacity (int) – Create Size capacity
max_ns_count (int) – Count of namespaces to be made
format_index (int) –
mset (int) – Metadata Settings
is_private (int) – Determines if namespace is private or not

Returns:

create_namespace

Return type:

dict

DSSD_25_Namespace_Attribute_Notices_AE_Test_Case.py

This script will run the following tests: The objectives for the Namespace Attribute Notices AE Test Case are to verify that the device completes an Asynchronous Event Request command for the “Namespace Attribute Changed” event when there is a change to one or more of the following:

LBA format has been changed by Format NVM command, the AEN will be triggered because of the Identify Namespace data structure (CNS = 00h).

The namespace is currently write-protected because of the Write Protection Config Set Feature Command, the AEN will be triggered because of the change of the I/O Command Set Independent Identify Namespace data structure (CNS = 08h).

The namespace has been detached/attached/deleted, the AENs will be triggered because of the change of the Active Namespace ID list (CNS = 02h).

The LBA format has been changed by Format NVM command, the AEN will be triggered because of the change of the Identify Namespace data structure for an Allocated Namespace ID (CNS = 11h).

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

NVMe-OPT-8/9/10/11, NVMe-AD-24/25

verify_aer_completion(aer)

Verify the AEN configuration as follows: a. Event Type = ‘Notice’, b. Asynchronous Event Information = ‘Namespace Attribute Changed’, c. Log Page Identifier = ‘Changed Namespace List (04h)’.

Parameters:: aer (str) – Asynchronous Event to examine
Return type:: None

DSSD_25_Namespace_Management_Command_Verification_Test_Case.py

This script will run the following tests:

Verify ability to create maxmimum allowed namespaces on DUT, accounting for NS Granularity
Verify namespace management behavior across all namespaces.
Verify Identify data updates accordingly with unattached namespaces.

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

NVMe-AD-3, NSM-1/2/3/4/5/6/7, NVMe v2.0d Section 3.2.1/5.23/8.11

namespace_management(dut, id_ns, sel, format_index, mset, new_ns_capacity=0, max_ns_count=1, is_private=0, pi=0, pil=0)

Helper function to create a new Namespace with specific field information

Parameters:

dut (XML) – Device object under test
id_ns (dict) – Identify Namespace command dictionary
sel (int) – Select Field for namespace management action
new_ns_capacity (int) – Create Size capacity
max_ns_count (int) – Count of namespaces to be made
format_index (int) –
mset (int) – Metadata Settings
is_private (int) – Determines if namespace is private or not
pi (int) – Protection Information
pil (int) – Protection Information Location

Returns:

create_namespace

Return type:

dict

DSSD_25_Namespace_Support_Test_Case.py

This script will run the following tests:

Issue Identify command with CNS = 1 and verify MNAN/NN values
Issue Identify command with CNS = 2 and verify active NSID list contains one NSID
Issue Identify command with CNS = 0
Verify MaxBlks = NSZE = NCAP

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SECTOR-3

DSSD_25_PCIe_Max_Payload_Size_Requirements_Test_Case.py

This script will run the following tests:

Verify PCI express Device Capabilities register (04h) max payload size
Verify PCI Express Link Status register (08h) max read request size through power cycle

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:: PCI-1

DSSD_25_PCIe_Resets_Requirements_Test_Case.py

This script will run the following tests:

While I/O is running, issue FLR for multiple instances and verify that the drive recovers and that I/O is still running
Issue cold reset for multiple instances and verify that the drive recovers
Issue warm reset for multiple instances and verify drive recovers
While I/O is running, issue hot reset for multiple instances and verify that the drive recovers and that I/O is still running

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

PCI-5/6

DSSD_25_PCIe_TLP_Completion_Timeout_Requirements_Test_Case.py

This script will run the following tests:

The TLP completion timeout is programmable to different supportable ranges by programming the timeout to a different subset range.
Disable the TLP completion timeout and verify that it was successful.

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

PCI-2/3/4

DSSD_25_PEL_Data_Persistence_Across_Format_NVM_Operations_Test_Case.py

The objectives for this test case are to verify the following:

That the device processes the Get Log Page commands to backup Persistent Event Log as the baseline.

That the data in the Persistent Event Log Page (LID 0Dh) persists across Format NVM commands by performing the following checks:

That all reserved and unsupported fields are cleared to 0 and do not change.

That all statically defined fields remain unchanged.

Verify that the Total Number of Events field in the Log Page data following successful Format NVM completion has increased as expected.

Verify that the event data in the Log Page has persisted.

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

STD-LOG-9/10/20/21/22/23

DSSD_25_PEL_Data_Persistence_Across_Sanitize_Operations_Test_Case.py

The objectives for the Data Persistence during Sanitize Operation test case are to verify the following:

That the device processes the Get Log Page commands to backup Persistent Event Log Page as the baseline.

That the data in Persistent Event Log Page (LID 0Dh) persists across the Sanitize operations by performing the following checks:

That all reserved and unsupported fields are cleared to 0 and do not change.

That all statically defined fields remain unchanged.

Verify that the Total Number of Events field in Log Page data following successful Sanitize completion has increased as expected.

Verify that the event data in the Log Page has persisted.

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

STD-LOG-9/10/20/21/22/23

DSSD_25_PEL_Data_Persistence_Across_TCG_Purge_Operations_Test_Case.py

The objectives for this test case are to verify the following:

That the device processes the Get Log Page commands to backup Persistent Event Log as the baseline.

That the data in Persistent Event Log Page (LID 0Dh) has persisted across the previous TCG command by performing the following checks:

That all reserved and unsupported fields are cleared to 0 and do not change.

That all statically defined fields remain unchanged.

That the data in the Persistent Event Log Page should be persisted across the previous TCG commands by checking the ‘Total Number of Events’ field in Log Page data.

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

STD-LOG-9/10/20/21/22/23

postcondition(dut)

Releases PEL reporting context

Parameters:: dut (XML_API) – Device Object Under Test
Return type:: None

DSSD_25_PERST_Test_Case.py

This script will run the following tests:

Assert and de-assert PERST on the drive
Verify CSTS.RDY transitions to 0 within one second
Verify Identify command is successful
Perform sequential write and read for five minutes and collect performance logs

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

TTR-20

DSSD_25_PLP_Start_Count_Test_Case.py

This script will run the following tests:

Do GetLogPage for LID C0h and get PLP Start Count field value
Power cycle the drive
Do GetLogPage for LID C0h and get PLP Start Count field value and verify it increased by 1

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SLOG-1/3/4/10, STD-LOG-23, SMART-1/2/12-28/30-33

DSSD_25_Persistent_Event_Log_Page_Test_Case.py

The objectives for the Persistent Event Log Page test case are to verify the following:

Verify that the Persistent Event Log page is supported by the DUT.

Verify that the maximum size of the Persistent Event log page reported in the Identify Controller data structure is 5 MiB or greater.

If the controller does not have a persistent event log reporting context, then the controller shall abort the command with a status code of Command Sequence Error.

Verify that the Supported Events Bitmap field has bits set to 1 indicating support for the following event logs.

Thermal Excursion Event

Telemetry Log Create Event

Sanitize Completion Event

Sanitize Start Event

Format NVM Completion Event

Format NVM Start Event

Change Namespace Event

NVM Subsystem Hardware Error Event

Power-on or Reset Event

Timestamp Change Event

Firmware Commit Event

SMART / Health Log Snapshot Event

Verify that the Persistent Event log page events are ordered by timestamp.

Verify that each of the following operations increases the TNE in the log page.

power cycle,

controller reset,

subsystem reset,

function level reset,

Format NVM Command.

Verify that mandatory events that occur while a reporting context is active are not reported in that reporting context.

Verify that the persistent event log reporting context is maintained for at least 5 minutes after the last host access to the log.

Verify that mandatory events that occur while a reporting context is not active are reported when the next reporting context is created.

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

STD-LOG-9/10/20/21/22/23

DSSD_25_Physical_Media_Units_Test_Case.py

This script will run the following tests:

Do GetLogPage for LID C0h and get physical media units written and read values
Perform 128KB sequential writes for 5 minutes
Perform 128KB sequential reads for 5 minutes
Do GetLogPage for LID C0h and verify physical media units written and read values increased

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SLOG-1/3/4/10, STD-LOG-23, SMART-1/2/12-28/30-33

get_logpage_fields(dut, lid, field_name1, field_name2)

Parameters:

dut –
lid –
field_name1 –
field_name2 –

DSSD_25_Power_Loss_And_Reset_Events_During_Firmware_Activation_Process_Test_Case.py

Test objectives of this test case is to verify that the device is not left in an unusable state if the firmware activation process is interrupted by the events listed below. The device shall either abort the firmware activation and continue running with the firmware revision that was running at the start of the firmware update process or complete the firmware activation and start running with the new firmware revision.

Unsafe Power Cycle,

Controller Level Reset,

NVM Subsystem Reset,

Function Level Reset,

PCIe Warm Reset,

PCIe Hot Reset.

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

FWUP-18

do_fwcommit(dut, slot, thread_flag)

Execute FW Commit command until it fails due to a controller reset

Parameters:

dut (XML_API) – Device object under test
slot (int) – FW slot for FW Commit
thread_flag (threading.Event) – Flag to stop the thread in case the FW Commit never fails

Return type:

None

do_fwcommit_step(dut, slot, reset)

Uses threading to make sure that the FW Commit is interrupted when a reset occurs

Parameters:

dut (XML_API) – Device object under test
slot (int) – FW slot for FW commit
reset (lambda function) – Reset function to execute: unsafe, controller level, subsystem, function level

Return type:

None

enable_fw_update(dut)

Enables FW Update in SMBus command code 90 (byte 91)

Parameters:: dut (XML_API) – Device object under test
Return type:: None

issue_io(dut, seektype, io_profile, threads, blocks, iosperpass=0, io_runtime=-1, io_pattern=0, extra_config=None)

Executes an IO Test

Parameters:

dut (XML_API) – Device object under test
seektype (str) – Either ‘Sequential’ | ‘Random’
io_profile (str) – IO Profile to be executed
threads (int | str) – Threads (QD) to execute IO on
blocks (int | str) – Number of Logical Blocks
iosperpass (int | str) – Param to determine what the IO does on the drive ‘0’: unlimited, ‘-1’: Iterate once over drive, ‘-2’: Iterate twice over drive
io_runtime (int) – Time in seconds for IO to execute
io_pattern (int) – Pattern for io to be executed
extra_config (dict | None) – Optional parameter for running IO test with additional configurations

Return type:

dict

steps_22_to_31(dut, prev_fw_rev, OriginalFirmwareRevision, AlternateSlot, OriginallyActiveSlot)

Run steps 22 to 31 to verify reset for revision changes

Parameters:

dut (XML_API) – Device object under test
prev_fw_rev (str) – The Previous Firmware Revision
OriginalFirmwareRevision (str) – The current Firmware Revision
AlternateSlot (int) – Alternate writable firmware slot chosen
OriginallyActiveSlot (int) – Originally active firmware slot

Returns:

TestSlot – The slot to use for the next iteration

Return type:

int

verify_ios(io_tests, is_verify_step=True)

Verifies the successful execution and wait for the completion of an I/O command

Parameters:

io_tests (list) – list of I/O test dicts
is_verify_step (bool) – Determines whether to execute resting action in method or not (Special case for if the IO verify logging comes in a later step)

Returns:

result_msg (tuple(func, msg) | none) – msg for later fail_action, or none if passed
bool – boolean to determine whether any I/O test failed

DSSD_25_Power_State_Change_Count_Test_Case.py

This script will run the following tests:

Verify Power State Change Count reported in the SMART/Health Information Extended Log has increased by the number of NVMe Power state changes
Verify Power State Change Count reported in the SMART/Health Information Extended Log has increased by the number of DSSD Power State changes

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SLOG-1/3/4/10, STD-LOG-23, SMART-1/2/12-28/30-33

postcondition(dut)

Sets the current power state back to the default NVMe Power State 0

Parameters:: dut (XML_API) – Device object under test
Return type:: None

DSSD_25_Queue_Depth_And_IO_Queue_Pairs_Test_Case.py

This script will run the following tests:

Verify SQES = 6 and CQES = 4
Set controller configuration IOSQES = 6
Set controller configuration IOCQES = 4
Do Set Features for FID 7h with NCQR = NSQR = 511
Verify CAP.MQES >= 1023
Create 512 queues with queue size = 1023

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

NVMe-CFG-5/6/14/15

DSSD_25_Read_Only_Or_Write_Through_Mode_Feature_Test_Case.py

This script will run the following tests:

The objective is to check that the factory default value of 0xC2 feature is set to Read Only Mode - Get factory default sate of feature 0xC2(ROWTM) and make sure that it is set to RO Mode

For Set feature the objectives are to test the following: a. Get factory default value of feature ROWTM(0xC2) and it should be RO Mode b. Change to Write Through Mode using set feature and using get feature check that the current state and saved state are set to Write Through Mode no later than next power cycle c. Current and saved state should be Write Through Mode even after drive goes through power cycle d. Default state should be Read Only Mode e. Change to Normal Mode using set feature and using get feature check that the current state and saved state are set to Normal Mode no later than next power cycle f. Current and saved state should be Normal Mode even after drive goes through power cycle g. Default state should be Read Only Mode h. Change to Read Only Mode using set feature and using get feature check that the current state and saved state are set to Read Only Mode no later than next power cycle i. Current and saved state should be Read Only Mode even after drive goes through power cycle j. Default state should be Read Only Mode k. If setting this feature is not supported, then a status error code of 0x2 (Invalid Field in Command) shall be returned

For Get feature the objectives are to test the following: a. Check the default state of 0xC2 with SEL=01b.It should be Read Only Mode and should not change over power cycle. Current state selection should not affect the default state. b. Check the capabilities of 0xC2 with SEL=11b and it should be 101b indicating that this feature is savable, changeable, and not name space specific c. Check the current state of 0xC2 with SEL=00b and it should match with Read Only, Write Through or Normal selection made with set feature d. Check the saved state of 0xC2 with SEL=10b e. Check whether smart page critical warning is reflecting ROWTM settings or not f. Check drive is in RO, WT or Normal Mode state by performing IO

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

ROWTM-1, SROWTM-1 to SROWTM-15, GROWTM-1 to GROWTM-15, GETF-1/2

check_set_feature_result(dut, set_feature_cmd, fid, sv=0, data=None, cdw11=None)

Receives the values stored in a Set-Feature Log, and verifies the feature command’s execution

Parameters:

dut (XML_API) – Device object under test
set_feature_cmd (dict) – Set-Feature command output
fid (int) – FID field value for the set-feature command
sv (int) – The Selection field for the set-feature command
data (int|None) – Data Pointer for the Set-feature, intended for original set-feature value at start of test
cdw11 (int|None) – Command DWord 11 for the Set-Feature, intended for original set-feature value at start of test

Return type:

None

DSSD_25_SMBus_Data_TTR_Verification_Test_Case.py

This script will run the following tests:

Do a power cycle
Get timestamp
Poll MI Basic subsystem management data structure command code 0 until it’s successful
Get timestamp
Verify MI Basic subsystem management data structure command code 0 info is correct
Verify difference between timestamps is within CAP.TO
Repeat steps 1-6 using controller reset
Repeat steps 1-6 using NSSR
Repeat steps 1-6 using FLR

Pass/Fail: Script passes if all info is correct

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SMBUS-1/2/3/4/7/9/10

basic_mgmt_status_during_reset(dut, mi_dut, step_num, mi_ver, cap_to_secs, TimeToIdentifyRdy)

Do Basic Management Status command during a reset and verify it finished within CAP.TO

Parameters:

dut (XML_API) – Device object under test
mi_dut (XML_API) – Device MI object under test
step_num (int) – Step number of the start timestamp step
mi_ver (int) – MI version supported by the controller
cap_to_secs (int) – CAP.TO value in seconds
TimeToIdentifyRdy (int) – TTR-1 value from DP-CFG-8 in ADP

Return type:

None

verify_basic_mgmt_status_output(dut, mi_dut, mi_output_cmd, mi_ver, power_cycle_flag)

Do GetFeatures with SEL value and verify returned info is correct

Parameters:

dut (XML_API) – Device object under test
mi_dut (XML_API) – Device MI object under test
mi_output_cmd (dict) – Output of MI command
mi_ver (int) – MI version supported by the controller
power_cycle_flag (int) – 1 = power cycle was executed, 0 = other reset was executed

Return type:

None

DSSD_25_SMBus_Data_Verification_256_Bytes_Test_Case.py

This script will run the following tests:

Get MI Basic subsystem management data structure with offset 0 and length 154 bytes
Get MI Basic subsystem management data structure with offset 154 and length 102 bytes
Verify various fields return correct info

Pass/Fail: Script passes if all info is correct

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SMBUS-1/2/3/5/6/9/10

DSSD_25_SMBus_Data_Verification_Cmd_Code_0_Test_Case.py

This script will run the following tests:

Get MI Basic subsystem management data structure command code 0 and verify it returns correct info

Pass/Fail: Script passes if all info is correct

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SMBUS-1/2/3/9/10

DSSD_25_SMBus_Data_Verification_Cmd_Code_154_Test_Case.py

This script will run the following tests:

Get MI Basic subsystem management data structure command code 154 and verify it returns correct info

Pass/Fail: Script passes if all info is correct

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SMBUS-1/2/3/8/9/10

DSSD_25_SMBus_Data_Verification_Cmd_Code_167_Test_Case.py

This script will run the following tests:

Get MI Basic subsystem management data structure command code 167 and verify it returns correct info

Pass/Fail: Script passes if all info is correct

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SMBUS-1/2/3/9/10

DSSD_25_SMBus_Data_Verification_Cmd_Code_242_Test_Case.py

This script will run the following tests:

Get MI Basic subsystem management data structure command code 242 and verify it returns correct info

Pass/Fail: Script passes if all info is correct

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SMBUS-1/2/3/5/9/10

check_basic_mgmt_value(output_cmd, field_name, field_name_descr, exp_value)

Verify a field value is correct

Parameters:

output_cmd (dict) – Data structure to check
field_name (str) – Name of parameter in data structure to check
field_name_descr (str) – Name of parameter to print in the report
exp_value (int) – Expected value of parameter

Return type:

None

DSSD_25_SMBus_Data_Verification_Cmd_Code_248_Test_Case.py

This script will run the following tests:

Get MI Basic subsystem management data structure command code 248 and verify it returns correct info

Pass/Fail: Script passes if all info is correct

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SMBUS-1/2/3/9/10

check_basic_mgmt_value(output_cmd, field_name, field_name_descr, exp_value)

Verify a field value is correct

Parameters:

output_cmd (dict) – Data structure to check
field_name (str) – Name of parameter in data structure to check
field_name_descr (str) – Name of parameter to print in the report
exp_value (int) – Expected value of parameter

Return type:

None

DSSD_25_SMBus_Data_Verification_Cmd_Code_32_Test_Case.py

This script will run the following tests:

Get MI Basic subsystem management data structure command code 32 and verify it returns correct info

Pass/Fail: Script passes if all info is correct

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SMBUS-1/2/39/10

DSSD_25_SMBus_Data_Verification_Cmd_Code_50_Test_Case.py

This script will run the following tests:

Get MI Basic subsystem management data structure command code 50 and verify it returns correct info

Pass/Fail: Script passes if all info is correct

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SMBUS-1/2/3/9/10

DSSD_25_SMBus_Data_Verification_Cmd_Code_8_Test_Case.py

This script will run the following tests:

Get MI Basic subsystem management data structure command code 8 and verify it returns correct info

Pass/Fail: Script passes if all info is correct

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SMBUS-1/2/3/9/10

DSSD_25_SMBus_Data_Verification_Cmd_Code_90_Test_Case.py

This script will run the following tests:

Get MI Basic subsystem management data structure command code 90 and verify it returns correct info

Pass/Fail: Script passes if all info is correct

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SMBUS-1/2/3/4/9/10, FB-CONF-6, MS-CONF-6

DSSD_25_SMBus_Data_Verification_Cmd_Code_96_Test_Case.py

This script will run the following tests:

Get MI Basic subsystem management data structure command code 96 and verify it returns correct info

Pass/Fail: Script passes if all info is correct

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SMBUS-1/2/3/9/10

DSSD_25_SMBus_Firmware_Update_Verification_Test_Case.py

This script will run the following tests:

Verify disabling Firmware Update using Basic Management SMBus Block Write command and verifying using SMBus Read Byte command.
Verify enabling Firmware Update using the SMBus Write Byte protocol

Pass/Fail: Script passes if all info is correct

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SMBUS-1/3/4/5/6/7/9/10, FB-CONF-6, MS-CONF-6

DSSD_25_SMBus_Invalid_Transaction_Test_Case.py

This script will run the following tests:

Send the NVMe Basic Management Block Read command with any invalid SMBus slave address
Verify that NVMe Basic Management command does not complete successfully

Pass/Fail: Script passes if all info is correct

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SMBUS-1/2/3/4/7/9/10

DSSD_25_SMBus_Secure_Boot_Failure_Verification_Test_Case.py

This script will run the following tests:

Get MI Basic subsystem management data structure command code 242 and verify it returns correct info
Inject secure boot failure
Power cycle the drive
Issue Identify command and verify it passes
Get MI Basic subsystem management data structure command code 242 and verify it returns correct info
Get MI Basic subsystem management data structure command code 0 and verify it returns correct info
Power cycle the drive
Issue Identify command and verify it passes

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SMBUS-1/3/5/6/9/10

DSSD_25_Sanitize_Operation_Block_Erase_Test_Case.py

This script will run the following tests:

Verify support for sanitize block erase command
Verify initial sanitize state
Delete and recreate smaller fixed size namespace
Setup AENs
Verify Sanitize command with No-Deallocate After Sanitize = 0 first
Precondition namespace for sanitize
Start block erase sanitize operation
Block erase sanitize operation has ended
Verify the block erase sanitize operation
Verify sanitize command with No-Deallocate After Sanitize = 1
Delete and recreate original namespace
Verify that block erase completes within 10s per TB of capacity

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

NVMe-AD-7/8/17/18, SEC-4, STD-LOG-9/10, CTO-8, NVMe v2.0d Section 5.16.1.25/5.27.1.19/5.24/8.21

exit_sanitize_failure(dut)

Performs the necessary steps to exit sanitize failure mode

Parameters:: dut (XML_API) – Device object under test
Return type:: None

postcondition(dut, wait=7200, fail=True)

Performs the necessary postcondition steps to restore DUT back to original state

Parameters:

dut (XML_API) – Device object under test
wait (int) – Estimated time to wait for Sanitize Operation if Get Log Page with LID=81h fails
fail (bool) – If True, print ERROR message and exit the script; if False, print DETAIL message

Return type:

None

verify_data_buffer(dut, params, config)

Start an IO test, wait for it to finish, check test status

Parameters:

dut (XML_API) – Device object under test
params (dict) – Parameters for IO test
config (dict) – Configuration for IO test

Return type:

None

DSSD_25_Sanitize_Operation_Crypto_Erase_Test_Case.py

This script will run the following tests:

Verify support for sanitize crypto erase command
Verify initial sanitize state
Delete and recreate smaller fixed size namespace
Setup AENs
Verify Sanitize command with No-Deallocate After Sanitize = 0 first
Precondition namespace for sanitize
Start crypto erase sanitize operation
Crypto erase sanitize operation has ended
Verify the crypto erase sanitize operation
Verify sanitize command with No-Deallocate After Sanitize = 1
Delete and recreate original namespace

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

NVMe-AD-7/8/18, SEC-4, STD-LOG-9/10, NVMe v2.0d Section 5.16.1.25/5.27.1.19/5.24/8.21

execute_IO_Profile(dut, test_type, io_profile, io_runtime=-1, io_pattern=1, config=None)

Executes each of the IO Profiles listed in Table 4

Sequential Read (MiB/s) (128kiB, QD = 128)
Sequential Write (MiB/s) (128kiB, QD = 128)
Random Read (KIOPS) (4kiB, QD = 128)
Random Writes (KIOPS) (4kiB, QD = 128)
Random 70R:30W mix (KIOPS) (4kiB, QD = 128)

Parameters:

dut (XML_API) – Device object under test
test_type (str) – Either ‘Sequential’ | ‘Random’
io_profile (str) – IO Profile to be executed
io_runtime (int) – Time in seconds for IO to execute
io_pattern (int) – Pattern for io to be executed
config (dict) – Configuration parameters for the I/O

Return type:

dict

exit_sanitize_failure(dut)

Performs the necessary steps to exit sanitize failure mode

Parameters:: dut (XML_API) – Device object under test
Return type:: None

postcondition(dut, wait=7200, fail=True)

Performs the necessary postcondition steps to restore DUT back to original state

Parameters:

dut (XML_API) – Device object under test
wait (int) – Estimated time to wait for Sanitize Operation if Get Log Page with LID=81h fails
fail (bool) – If True, print ERROR message and exit the script; if False, print DETAIL message

Return type:

None

verify_ios(io_tests, fail_type='warn')

Verifies the succession of an I/O command

Parameters:

io_tests (list) – list of I/O Command dicts
fail_type (str) – fail type upon I/O failure

Returns:

io_failed – Returns failed if any io test failed

Return type:

bool

DSSD_25_Sanitize_Operation_Overwrite_Erase_Test_Case.py

This script will run the following tests:

Verify support for sanitize overwrite command
Verify initial sanitize state
Delete and recreate smaller fixed size namespace
Setup AENs
Verify Sanitize command with No-Deallocate After Sanitize = 0 first
Precondition namespace for sanitize
Start overwrite sanitize operation
Overwrite sanitize operation has ended
Verify the overwrite sanitize operation
Verify sanitize command with No-Deallocate After Sanitize = 1
Delete and recreate original namespace

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

NVMe-AD-7/8/18, SEC-4, STD-LOG-9/10, NVMe v2.0d Section 5.16.1.25/5.27.1.19/5.24/8.21

execute_IO_Profile(dut, test_type, io_profile, io_runtime=-1, io_pattern=1, config=None)

Executes each of the IO Profiles listed in Table 4

Sequential Read (MiB/s) (128kiB, QD = 128)
Sequential Write (MiB/s) (128kiB, QD = 128)
Random Read (KIOPS) (4kiB, QD = 128)
Random Writes (KIOPS) (4kiB, QD = 128)
Random 70R:30W mix (KIOPS) (4kiB, QD = 128)

Parameters:

dut (XML_API) – Device object under test
test_type (str) – Either ‘Sequential’ | ‘Random’
io_profile (str) – IO Profile to be executed
io_runtime (int) – Time in seconds for IO to execute
io_pattern (int) – Pattern for io to be executed
config (dict) – Configuration parameters for the I/O

Return type:

dict

exit_sanitize_failure(dut)

Performs the necessary steps to exit sanitize failure mode

Parameters:: dut (XML_API) – Device object under test
Return type:: None

postcondition(dut, wait=7200, fail=True)

Performs the necessary postcondition steps to restore DUT back to original state

Parameters:

dut (XML_API) – Device object under test
wait (int) – Estimated time to wait for Sanitize Operation if Get Log Page with LID=81h fails
fail (bool) – If True, print ERROR message and exit the script; if False, print DETAIL message

Return type:

None

verify_ios(io_tests, fail_type='warn')

Verifies the succession of an I/O command

Parameters:

io_tests (list) – list of I/O Command dicts
fail_type (str) – fail type upon I/O failure

Returns:

io_failed – Returns failed if any io test failed

Return type:

bool

DSSD_25_Sector_Size_Test_Case.py

This script will run the following tests:

The device supports both 512-byte and 4096-byte sector sizes
The device is configured from the factory with the default sector size specified by OCP requirements per form factor

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SECTOR-4, MS-CONF-1/2, NSM-2/3

DSSD_25_Security_Version_Number_Test_Case.py

This script will run the following tests:

Do GetLogPage for LID C0h
Check Security Version field against parameterization data

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SLOG-1/3/4/10, STD-LOG-23, SMART-1/2/12-28/30-33

DSSD_25_Set_Get_Feature_Telemetry_Profile_C8h_Test_Case.py

This script will run the following tests:

Send the Set Feature command with FID C8h to set each telemetry profile type
Verify that the correct profile is then reported in the Telemetry Area 1 data.
Verify that the SEL field is ignored with the Get Feature command with FID C8h

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

TEL-16/17, TEL-CFG-SF-1/2/3/4/5/6/7/8/9/10/11/12/13/14/15/16/17, TEL-CFG-GF-1

cleanup_action(filenames)

Deletes temporary files before ending script

Parameters:: list[str] (filenames) – temporary file names to remove
Return type:: None

get_data_area_1_fields(filename)

Parses OCP 2.5 Telemetry Data Format (see Datacenter NVMe SSD spec section 4.9.16.1)

Parameters:: filename (str) – Filename of raw binary output from get log page command
Returns:: result – Result dictionary with fields parsed out similar to api_core.py and core.json
Return type:: dict

parse_thi_output(cmd_output, filename)

Parses out the data from the GetLogPage hexdump and appends it to the proper file. Ignores data that is not hex-dumped like CQE.

Parameters:

cmd_output (List) – List of hex-dump strings to parse
filename (str) – File to append to

Returns:

Number of blocks read

Return type:

int

read_seq_blocks_from_log(dut, mdtsb, data_area_blks, depth, filename)

Reads data_area_blks from the telemetry host log. Assumes the header (512 Bytes) has already been parsed. A MDTS value that is not a multiple of 512 bytes will produce undefined behavior, although all valid MDTS alues should be multiples of 512 bytes.

Parameters:

dut (XML_API) – Device Object Under Test
mdtsb (int) – Maximum Data Transfer Size in Bytes
data_area_blks (int) – Number of data area blocks left to read
depth (int) – multiplier for offset for subsequent get log page command calls
filename – File to append binary data from get log page command to

Returns:

True if all-around success, else False

Return type:

bool

DSSD_25_Shutdown_Notification_And_Status_Test_Case.py

This script will run the following tests:

Do Identify Controller and verify it’s successful
Check RTD3 Entry Latency field value
Execute normal shutdown process and verify CC.SHN and CSTS.SHST values
Execute abrupt shutdown process and verify CC.SHN and CSTS.SHST values

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

TTR-5/6/23

DSSD_25_Subsystem_Reset_Test_Case.py

This script will run the following tests:

Execute NSSR

Pass/Fail: Script passes if NSSR is successful

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

NVMeR-1

steps_1_8(dut)

Allows steps 1-8 to easily loop

Parameters:

dut (XML_API) – Device object under test

Returns:

nssro (int) – CSTS.NSSRO register bit value
cap_to – Controller Timeout, converted to seconds

DSSD_25_TCG_Activity_Events_For_Persistent_Event_Log_Test_Case.py

The objective for the TCG Persistent Event Log is to verify the following:

Perform all TCG methods according to TCGHST-PE-2 requirements.

Level 0 Discovery

Start Session

Authenticate method (entries only recorded when the authority specified is not locked out)

Close Session by the host when it sends an End-Of-Session token

Close Session due to timeout

Properties method

Stack Reset

TPer Reset

Get method

Set method

GenKey method

Random method

Activate method

Revert method

RevertSP method

Reactivate method

Erase method

Block SID Authentication

Assign method

Deassign method

To generate a sufficient number of persistent log entries (at least 100 entries), the Assign and Deassign methods will be invoked multiple times.

Utilize the Get Log Page command to retrieve the persistence event log page.

Verify that the “Total Number of Events” increment at least 100.

Verify that all methods invoked above are logged in the event log entries except SyncSession method.

Verify that all the TCG Activity PEL entries comply with OCP 2.5 requirements in the TCG Activity Event Format Table.

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

TCGHST-PE-1 - TCGHST-PE-5 TCGCE-1 - TCGCE-24 TCG-AUTHM-1 - TCG-AUTHM-3 TCG-ACT-1 TCG-ACT-2 TCG-RACT-1 TCG-RACT-2 TCG-ASGN-1 TCG-ASGN-2 TCG-BSID-1 TCG-BSID-2

DSSD_25_TCG_Configuration_Log_Page_C7h_Block_SID_Authentication_Test_Case.py

The objective for the TCG Block SID Authentication is to verify the following:

Verify that the “C_PIN_SID Authentication Blocked”, TCGL-1 bit[1], will be set to 1(Blocked) upon successful completion of the Block SID Authentication command.

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

TCGL-1

DSSD_25_TCG_Configuration_Log_Page_C7h_Programmatic_Count_Test_Case.py

The objective for the TCG Programmatic count is to verify the following:

Verify that the Programmatic TCG Reset Count(TCGL -17) and Programmatic TCG Reset Lock Count(TCGL -18) have been updated correctly after performing a programmatic reset.

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

TCGL-17 - TCGL-18

DSSD_25_TCG_Configuration_Log_Page_C7h_Test_Case.py

The objective for the TCG Configuration Log Page C7h is to verify the following:

Verify that the default values of the log page shall be cleared to 0.

Perform TCG activate method to locking SP.

Perform TCG assign method to assign Namespace non-Global Range Locking object for all Namespaces exist on the device.

Verify that the number of Locking Objects, Number of Range Provisioned Locking Objects, and Number of Namespace Provisioned Locking Objects have been updated accordingly and correctly.

Perform TCG set method to enable ReadLockEnabled, WriteLockEnabled, ReadLocked, and WriteLocked.

Verify that the Number of Read Locked Locking Objects, Number of Write Locked Locking Objects, Number of Read Unlocked Locking Objects, and Number of Write Unlocked Locking Objects have been updated accordingly and correctly.

Perform TCG revertSP method to locking SP.

Verify that the TPer Revert Count has increased.

Perform TCG revert method to Admin SP.

Verify that the TPer Revert Count has increased.

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

TCGL-1 - TCGL-16, TCGL-19 - TCGL-21

DSSD_25_TCG_Operation_Execution_Time_Verification_Test_Case.py

TCG Operation Execution Time Verification Test Case:

For the TCG operations listed in the TCG Operation Table, the CTO test objectives are to verify that each validly formatted TCG command completes successfully within 10 seconds under the following scenarios:

Host level TCG commands executed sequentially resulting in TCG Operations being sent to DUT via Security Send/Receive commands,

Host level TCG commands issued in the presence of a stressing background I/O workload.

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

CTO-1

DSSD_25_The_Expected_Value_Of_NSID_Field_Of_Set_Get_Feature_ROWTM_Test_Case.py

This script will run the following tests:

Issue Identify Controller command and get value of NN field
Issue Get Features command for FID = C2h and save Dword0 bits 2:0
Issue Set Features command for FID = C2h with NSID = FFFFFFFFh to set drive to EOL behavior from Get Features and verify it’s successful
Repeat step 3 with NSID = 1 and verify it fails
Repeat step 3 with NSID = NN + 1 and verify it fails

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.0 requirements referenced by this script:

SROWTM-6

DSSD_25_Time_To_Admin_And_IO_Ready_Test_Case.py

The objectives of the Time to Admin and IO Ready test case are as follows:

Perform a controller reset and verify that the device successfully responds to Identify commands within DP-CFG-8 seconds (from Adaptation data) after setting CC.EN=1.

Perform a controller reset and verify that the device successfully responds to I/O commands within DP-CFG-9 seconds (from Adaptation data) of setting CC.EN=1.

Perform a safe power cycle and verify that the device successfully responds to Identify commands within DP-CFG-8 seconds (from Adaptation data) after setting CC.EN=1.

Perform a safe power cycle and verify that the device successfully responds to I/O commands within DP-CFG-9 seconds (from Adaptation data) of setting CC.EN=1.

Perform an unsafe safe power cycle and verify that the device successfully responds to Identify

commands within DP-CFG-8 seconds (from Adaptation data) after setting CC.EN=1.

Perform an unsafe power cycle and verify that the device successfully responds to I/O commands within DP-CFG-9 seconds (from Adaptation data) of setting CC.EN=1.

Ensure that device complies TTR-4 and with DP-CFG-10 is if column B is supported.

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

TTR-1/2/4, DP-CFG-8/9/10

DSSD_25_Timestamp_Feature_Test_Case.py

The objectives of the test case are as follows:

Default state

Get the Identify Controller Data for DUT and verify that the timestamp feature is set as supported in ONCS field.

Issue a Get Features command with select field set to 011b for timestamp feature(0Eh) and verify that feature is changeable and not namespace specific from the command status.

Basic functionality

Using set features for Timestamp feature (0Eh), set the timestamp to X milliseconds and using Get Features check that the value returned is greater than X for all subsequent Get features before NVM Subsystem Reset or power cycle.

Verify that Timestamp Origin value in Timestamp Attribute field is not set to 000b before NVM Subsystem reset or power cycle is issued.

Verify that Synch value in Timestamp Attribute field is not set to 1b.

Reset

Perform a power cycle and using Get Features check that the timestamp value returned has been reset to 0.

Verify that both the Timestamp Origin value and the Synch value in Timestamp Attribute field are cleared to 0b after a power cycle is issued.

Perform NVM Subsystem Reset and using Get Features verify that the timestamp value has been reset to 0.

Verify that both the Timestamp Origin value and the Synch value in Timestamp Attribute field are cleared to 0b after NVM Subsystem Reset is issued.

Persistence

Issue Controller Level Reset and verify the timestamp value read after reset not been reset to 0.

Also verify the Synch value is not set in the Get Features command status indicating timestamp did not stop during reset handling.

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

NVMe-OPT-2/4/5

get_nvme_timestamp_feature_value()

Returns the value of /sys/module/nvme_core/parameters/nvme_timestamp_feature

Parameters:: None –
Return type:: Integer value

power_cycle_nssr_steps(dut, TimeToIdentifyRdy, iteration)

Executes steps 23-35 for power cycle and steps 36-37 for NSSR in the testplan

Parameters:

dut (XML_API) – Device Object Under Test
TimeToIdentifyRdy (int) – TimeToIdentifyRdy value
iteration (int) – 1 = execute power cycle steps, 2 = execute NSSR steps

Return type:

None

DSSD_25_Total_NUSE_Test_Case.py

This script will run the following tests:

Precondition the device to have a single namespace
Verify that the values of NUSE in Identify Namespace and Total NUSE in LID C0h are the same
Calculate the temporary namespace capacity to use, factoring in the namespace granularity descriptor size
Delete the namespace
Create, attach and write to namespaces, from 1 to MNAN/NN value
Power cycle the device and delay for 10 minutes
Verify that the Total NUSE value reported in LID C0h is equal to the value of total NUSE summed over all the namespaces created
Delete all of the namespaces
Create and attach a new namespace

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SLOG-1/3/4/10, STD-LOG-23, SMART-1/2/12-28/30-33

get_ID_NS_DATA_1(params)

Helper function to retrieve and parse the ADP’s ID_NS_DATA_1 field information

Parameters:

params (dict) – ADP parameter values

Returns:

adp_id_ns (dict) – Dictionary of parsed values from the ADP’s ID_NS_DATA_1 field
create_Namespace (dict)

namespace_management(dut, sel, format_index, mset, nvmsetid, anagrpid, endgid, new_ns_capacity=0, max_ns_count=1, pi=0, pil=0, is_private=0)

Helper function to create a new Namespace with specific field information

Parameters:

dut (XML) – Device object under test
sel (int) – Select Field for namespace management action
new_ns_capacity (int) – Create Size capacity
max_ns_count (int) – Count of namespaces to be made
format_index (int) –
mset (int) – Metadata Settings
nvmsetid (int) – NVM Set identifier associated with the submission queue
anagrpid (int) – ANA Group Identifier
pi (int) – Protection Information
pil (int) – Protection Information Location
is_private (int) – Determines if namespace is private or not

Returns:

create_Namespace

Return type:

dict

DSSD_25_UUID_Test_Case.py

This script will run the following tests:

Verify that the UUID List obtained by using the NVMe Identify Command using CNS=17h contains the UUID value C194D55BE0944794A21D29998F56BE6F in big endian format as shown below:

[——————–Bytes——————–] 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00 6F BE 56 8F 99 29 1d A2 94 47 94 E0 5B D5 94 C1
Verify that sending Get/Set Feature commands with vendor unique FIDs and the UUID index = matching UUID Index complete successfully.
Verify that Get/Set Feature commands with valid vendor unique FIDs and UUID index = 0 complete successfully.
Verify that Get/Set Feature commands with valid vendor unique FIDs and UUID index = invalid index fail with Invalid Field in Command status.
Verify that the Get Log Page commands with valid vendor unique LIDs and the UUID index = matching UUID Index complete successfully.
Verify that the Get Log Page commands with valid vendor unique LIDs and the UUID index = 0 complete successfully.
Verify that the Get Log Page commands with valid vendor unique LIDs and invalid UUID index fail with Invalid Field in Command status.

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

UUID-1/2/3/4/5/6

get_latency_monitor_values(dut, get_log_c3_input=None)

Receives the values stored in a Latency Monitoring Log (C3h), returning each field

Parameters:

dut (XML_API) – Device object under test
get_log_c3_input (dict) – Latency Monitor Log Page dictionary

Returns:

data – Value of all lmdata fields

Return type:

int

issue_get_features(dut, uuid_index, starting_step, check_sc=False, orig_values=None, orig_values_pristine=None)

Issues a series of get-feature commands and verifies if they are successful

Parameters:

dut (XML_API) – Device object under test
uuid_index (int) – Index to be used for UUID
starting_step (int) – Step to start incrementing from throughout the loop
check_sc (bool) – bool flag to check for expected failure status
orig_values (list) – List of original feature values to check against
orig_values_pristine (list) – List of original feature values (before reversing the bit order for use in Set Features) to check against

Returns:

get_feat_values

Return type:

list

issue_log_pages(dut, uuid_index, starting_step, check_sc=False)

Issues a series of GetLog Page commands and verifies if they are successful

Parameters:

dut (XML_API) – Device object under test
uuid_index (int) – Index to be used for UUID
starting_step (int) – Step to start incrementing from throughout the loop
check_sc (bool) – bool flag to check for expected failure status

Return type:

None

issue_set_features(dut, uuid_index, get_feat_values, starting_step, check_sc=False, data_buffer='')

Issues a series of set-feature commands and verifies if they are successful

Parameters:

dut (XML_API) – Device object under test
uuid_index (int) – Index to be used for UUID
get_feat_values (list) – List of values from get features for FIDs 0xC2, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xC3
starting_step (int) – Step to start incrementing from throughout the loop
check_sc (bool) – bool flag to check for expected failure status
data_buffer (hex) – Data buffer

Return type:

None

obtain_values(current_states)

Returns valid values to set in the Set Features commands from the Get Features values

Parameters:

current_states (dict) – Dictionary of FID to value

Returns:

get_feat_values (dict)
get_feat_values_pristine (dict)

DSSD_25_Unaligned_IO_Test_Case.py

This script will run the following tests:

Power cycle the device
Do GetLogPage for LID C0h and verify Unaligned I/O field is 0
Send 10 4KB sequential write I/O commands starting at LBA 1
Do GetLogPage for LID C0h and verify Unaligned I/O field increased by at least 10
Power cycle the device
Do GetLogPage for LID C0h and verify Unaligned I/O field is 0

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SLOG-1/3/4/10, STD-LOG-23, SMART-1/2/12-28/30-33

perform_cleanup(dut, orig_lbaf)

Used to postcondition drive in the event of a test-wide failure

Parameters:

dut (XML_API) – Device object under test
orig_lbaf (int) – Original LBA to re-format drive to

Returns:

‘test’ – fail_action=’test’

Return type:

str

DSSD_25_Unsafe_Shutdowns_Verification_Test_Case.py

This script will run the following tests:

Do GetLogPage for LID 2h and get Unsafe Shutdowns field value
Surprise power cycle the drive 10 times
Do GetLogPage for LID 2h and get Unsafe Shutdowns field value and verify it increased by 1

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

STD-LOG-2/3/18/23, SLOG-1/3/4/5/11

DSSD_25_Unsupported_Command_Verification_Test_Case.py

This script will run the following tests:

Verify reserved Admin and NVM opcodes in the table return an “invalid command opcode” error
Verify unsupported optional Admin and NVM opcodes in the table return an “invalid command opcode” error
Verify unsupported vendor unique Admin opcodes in the table return an “invalid command opcode” error
Verify every supported vendor unique Admin opcode that requires challenge-response action to unlock returns an error
Verify unsupported vendor unique NVM in the table return an “invalid command opcode” error
Verify every supported vendor unique NVM that requires challenge-response action to unlock returns an error

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SEC-19

check_opcode_optional(dut, opcode_list, admin_nvm_flag, num_cmds_supp, cmds_supp, cmds_supp_len)

Verify unsupported optional opcode returns INVALID_OPCODE error

Parameters:

dut (XML_API) – Device object under test
opcode_list (list) – List of opcodes (in integer format) to loop through
admin_nvm_flag (int) – 0 = Execute Admin command, 1 = Execute NVM command
num_cmds_supp (int) – Value of NUM_OPT_ADM_CMDS_SUPPORTED or NUM_OPT_NVM_CMDS_SUPPORTED
cmds_supp (list) – List of OPT_ADM_CMD_OPCODES or OPT_NVM_CMD_OPCODES
cmds_supp_len (int) – Length of OPT_ADM_CMD_OPCODES or OPT_NVM_CMD_OPCODES

Return type:

None

check_opcode_reserved(dut, nvme_ver, opcode_list, admin_nvm_flag)

Verify reserved opcode returns INVALID_OPCODE error

Parameters:

dut (XML_API) – Device object under test
nvme_ver (int) – NVMe version supported by the controller
opcode_list (list) – List of opcodes (in integer format) to loop through
admin_nvm_flag (int) – 0 = Execute Admin command, 1 = Execute NVM command

Return type:

None

check_opcode_vendor_unique(dut, opcode_list, admin_nvm_flag, num_cmds_supp, cmds_supp, cmds_supp_len, num_req_cra_cmds_supp, req_cra_cmds_supp, req_cra_cmds_supp_len)

Verify unsupported vendor unique opcode returns INVALID_OPCODE error

Parameters:

dut (XML_API) – Device object under test
opcode_list (list) – List of opcodes (in integer format) to loop through
admin_nvm_flag (int) – 0 = Execute Admin command, 1 = Execute NVM command
num_cmds_supp (int) – Value of NUM_OPT_ADM_CMDS_SUPPORTED or NUM_OPT_NVM_CMDS_SUPPORTED
cmds_supp (list) – List of OPT_ADM_CMD_OPCODES or OPT_NVM_CMD_OPCODES
cmds_supp_len (int) – Length of OPT_ADM_CMD_OPCODES or OPT_NVM_CMD_OPCODES
num_req_cra_cmds_supp (int) – Value of NUM_VU_ADMIN_CMDS_SUP_REQ_CRA or NUM_VU_NVM_CMDS_SUP_REQ_CRA
req_cra_cmds_supp (list) – List of VU_ADMIN_CMD_OPC_VALS_REQ_CRA or VU_NVM_CMD_OPC_VALS_REQ_CRA
req_cra_cmds_supp_len (int) – Length of VU_ADMIN_CMD_OPC_VALS_REQ_CRA or VU_NVM_CMD_OPC_VALS_REQ_CRA

Return type:

None

check_opcode_vendor_unique_locked(dut, num_req_cra_cmds_supp, req_cra_cmds_supp, admin_nvm_flag)

Verify unsupported vendor unique LID returns an error

Parameters:

dut (XML_API) – Device object under test
num_req_cra_cmds_supp (int) – Value of NUM_VU_ADMIN_CMDS_SUP_REQ_CRA or NUM_VU_NVM_CMDS_SUP_REQ_CRA
req_cra_cmds_supp (list) – List of VU_ADMIN_CMD_OPC_VALS_REQ_CRA or VU_NVM_CMD_OPC_VALS_REQ_CRA
admin_nvm_flag (int) – 0 = Execute Admin command, 1 = Execute NVM command

Return type:

None

print_cmds_supp_hex(param_name, cmds_supp_hex, cmds_supp_len_hex)

Print a hexadecimal list of controller-supported opcodes

Parameters:

param_name (str) – Parameter name (e.g. OPT_ADM_CMD_OPCODES or OPT_NVM_CMD_OPCODES or VU_ADM_CMD_OPCODES or VU_NVM_CMD_OPCODES or VU_ADMIN_CMD_OPC_VALS_REQ_CRA or VU_NVM_CMD_OPC_VALS_REQ_CRA)
cmds_supp_hex (list) – List of OPT_ADM_CMD_OPCODES or OPT_NVM_CMD_OPCODES or VU_ADM_CMD_OPCODES or VU_NVM_CMD_OPCODES or VU_ADMIN_CMD_OPC_VALS_REQ_CRA or VU_NVM_CMD_OPC_VALS_REQ_CRA
cmds_supp_len_hex (int) – Length of OPT_ADM_CMD_OPCODES or OPT_NVM_CMD_OPCODES or VU_ADM_CMD_OPCODES or VU_NVM_CMD_OPCODES or VU_ADMIN_CMD_OPC_VALS_REQ_CRA or VU_NVM_CMD_OPC_VALS_REQ_CRA

Return type:

None

DSSD_25_Unsupported_Feature_Verification_Test_Case.py

This script will run the following tests:

Do GetFeatures and SetFeatures for every reserved FID in the table and verify “invalid field” error is returned
Do GetFeatures and SetFeatures for every unsupported optional FID in the table and verify “invalid field” error is returned
Do GetFeatures and SetFeatures for every unsupported vendor unique FID in the table and verify “invalid field” error is returned
Do GetFeatures and SetFeatures for every supported vendor unique FID that requires challenge-response action to unlock and verify an error is returned

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SEC-19

check_fid_optional(dut, fid_list, num_fids_supp, fids_supp, fids_supp_len)

Verify unsupported optional FID returns INVALID_FIELD error

Parameters:

dut (XML_API) – Device object under test
fid_list (list) – List of FIDs (in integer format) to loop through
num_fids_supp (int) – Value of NUM_OPT_FIDS_SUPPORTED
fids_supp (list) – List of OPT_FIDS_SUPPORTED
fids_supp_len (int) – Length of OPT_FIDS_SUPPORTED

Return type:

None

check_fid_reserved(dut, nvme_ver, fid_list)

Verify reserved FID returns INVALID_FIELD error

Parameters:

dut (XML_API) – Device object under test
nvme_ver (int) – NVMe version supported by the controller
fid_list (list) – List of FIDs (in integer format) to loop through

Return type:

None

check_fid_vendor_unique(dut, fid_list, num_fids_supp, fids_supp, fids_supp_len, num_req_cra_fids_supp, req_cra_fids_supp, req_cra_fids_supp_len)

Verify unsupported vendor unique FID returns INVALID_FIELD error

Parameters:

dut (XML_API) – Device object under test
fid_list (list) – List of FIDs (in integer format) to loop through
num_fids_supp (int) – Value of NUM_VU_FIDS_SUPPORTED
fids_supp (list) – List of VU_FIDS_SUPPORTED
fids_supp_len (int) – Length of VU_FIDS_SUPPORTED
num_req_cra_fids_supp (int) – Value of NUM_VU_FIDS_SUP_REQ_CRA
req_cra_fids_supp (list) – List of VU_FID_VALS_REQ_CRA
req_cra_fids_supp_len (int) – Length of VU_FID_VALS_REQ_CRA

Return type:

None

check_fid_vendor_unique_locked(dut, num_req_cra_fids_supp, req_cra_fids_supp)

Verify unsupported vendor unique FID returns an error

Parameters:

dut (XML_API) – Device object under test
num_req_cra_fids_supp (int) – Value of NUM_VU_FIDS_SUP_REQ_CRA
req_cra_fids_supp (list) – List of VU_FID_VALS_REQ_CRA

Return type:

None

print_fids_supp_hex(param_name, fids_supp_hex, fids_supp_len_hex)

Print a hexadecimal list of controller-supported FIDs

Parameters:

param_name (str) – Parameter name (e.g. OPT_FIDS_SUPPORTED or VU_FIDS_SUPPORTED or VU_FID_VALS_REQ_CRA)
fids_supp_hex (list) – List of OPT_FIDS_SUPPORTED or VU_FIDS_SUPPORTED or VU_FID_VALS_REQ_CRA
fids_supp_len_hex (int) – Length of OPT_FIDS_SUPPORTED or VU_FIDS_SUPPORTED or VU_FID_VALS_REQ_CRA

Return type:

None

DSSD_25_Unsupported_Log_Pages_Verification_Test_Case.py

This script will run the following tests:

Do GetLogPage for every reserved LID in the table and verify “invalid log page” error is returned
Do GetLogPage for every unsupported optional LID in the table and verify “invalid log page” error is returned
Do GetLogPage for every unsupported vendor unique LID in the table and verify “invalid log page” error is returned
Do GetLogPage for every supported vendor unique LID that requires challenge-response action to unlock and verify an error is returned

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SEC-19

check_lid_optional(dut, lid_list, num_lids_supp, lids_supp, lids_supp_len)

Verify unsupported optional LID returns INVALID_LOG_PAGE error

Parameters:

dut (XML_API) – Device object under test
lid_list (list) – List of LIDs (in integer format) to loop through
num_lids_supp (int) – Value of NUM_OPT_LIDS_SUPPORTED
lids_supp (list) – List of OPT_LIDS_SUPPORTED
lids_supp_len (int) – Length of OPT_LIDS_SUPPORTED

Return type:

None

check_lid_reserved(dut, nvme_ver, lid_list)

Verify reserved LID returns INVALID_LOG_PAGE error

Parameters:

dut (XML_API) – Device object under test
nvme_ver (int) – NVMe version supported by the controller
lid_list (list) – List of LIDs (in integer format) to loop through

Return type:

None

check_lid_vendor_unique(dut, lid_list, num_lids_supp, lids_supp, lids_supp_len, num_req_cra_lids_supp, req_cra_lids_supp, req_cra_lids_supp_len)

Verify unsupported vendor unique LID returns INVALID_LOG_PAGE error

Parameters:

dut (XML_API) – Device object under test
lid_list (list) – List of LIDs (in integer format) to loop through
num_lids_supp (int) – Value of NUM_VU_LIDS_SUPPORTED
lids_supp (list) – List of VU_LIDS_SUPPORTED
lids_supp_len (int) – Length of VU_LIDS_SUPPORTED
num_req_cra_lids_supp (int) – Value of NUM_VU_LIDS_SUP_REQ_CRA
req_cra_lids_supp (list) – List of VU_LID_VALS_REQ_CRA
req_cra_lids_supp_len (int) – Length of VU_LID_VALS_REQ_CRA

Return type:

None

check_lid_vendor_unique_locked(dut, num_req_cra_lids_supp, req_cra_lids_supp)

Verify unsupported vendor unique LID returns an error

Parameters:

dut (XML_API) – Device object under test
num_req_cra_lids_supp (int) – Value of NUM_VU_LIDS_SUP_REQ_CRA
req_cra_lids_supp (list) – List of VU_LID_VALS_REQ_CRA

Return type:

None

print_lids_supp_hex(param_name, lids_supp_hex, lids_supp_len_hex)

Print a hexadecimal list of controller-supported LIDs

Parameters:

param_name (str) – Parameter name (e.g. OPT_LIDS_SUPPORTED or VU_LIDS_SUPPORTED or VU_LID_VALS_REQ_CRA)
lids_supp_hex (list) – List of OPT_LIDS_SUPPORTED or VU_LIDS_SUPPORTED or VU_LID_VALS_REQ_CRAD
lids_supp_len_hex (int) – Length of OPT_LIDS_SUPPORTED or VU_LIDS_SUPPORTED or VU_LID_VALS_REQ_CRAD

Return type:

None

DSSD_25_Unsupported_Requirements_Log_Page_Test_Case.py

This script will run the following tests:

Verify Unsupported Requirements Log Page, LID = C5h, default values are set to values as specified in OCP document.
1. Reserved fields “URLP-2” and “URLP-4” are cleared to zero.
2. Log Page Version field “URLP-5” is set to one.
3. Log Page GUID field “URLP-6” is set to C7BB98B7D0324863BB2C23990E9C722Fh
Collection Unsupported Count, “URLP-1.” Verify that nonzero values in Unsupported Requirement list matches with Unsupported Count.
Verify that Requirement IDs in Unsupported Requirements list matches with Unsupported Requirement ID passed in Adaptation Parameters file.

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

URLP-1/2/3/4/5/6

DSSD_25_Verify_NSID_Value_In_Get_Set_DSSD_Asynchronous_Event_Feature_Test_Case.py

This script will run the following tests:

Using NSID = 0 in the set features command passes as expected.
Using NSID = FFFFFFFFh in the set features command passes as expected.
Using NSID = NN+1 (invalid NSID) fails with Invalid Field in Command status.
NSID = any NSID between 1 and NN (valid NSID) fails with Feature Not Namespace Specific status.

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

SDAEC-6

DSSD_25_Write_Read_Command_And_Data_Verification_Test_Case.py

This script will run the following tests:

Do GetLogPage for LID 2h and get values of various fields
Perform 4KB random reads and writes for 65 minutes
Do GetLogPage for LID 2h and verify the various fields increased

Pass/Fail: Script passes if all tests pass

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

STD-LOG-2/3/18/23, SLOG-1/3/4/5/11

DSSD_25_Write_Uncorrectable_Test_Case.py

The objective of this test case is to verify the NVME IO requirements NVMe-IO-10 and NVMe-IO-14

The device’s support for NVMe Write Uncorrectable command is verified by issuing the NVMe Write Uncorrectable command.

LBAs that were written using the Write Uncorrectable command should fail read operations. These read errors should not increase the value of the SMART/Health information field Media field.

The case where the WUSL field in the Identify Controller dataset(CNS==6) is 0 and bit-1 of the ONCS field in the Identify Controller dataset(CNS==1) is also 0 shall be treated as a controller error and test case failure.

In the case where the WUSL field in the Identify Controller dataset(CNS==6) is greater than 0, WUSL shall be used to set the value of MAXLBAS using Identify Controller(CNS==1) and Identify Namespace(CNS==0) data as 2^(WUSL + 12 + CAP.MPSMIN) / 2^LBA Format[FLBAS].

Verify that when the WUSL field in the Identify controller dataset(CNS==6) is greater than 0 and bit-1 of the ONCS field in the Identify Controller dataset is 0 and the host sends a Write Uncorrectable command with an NLB value greater than that specified by the value of WUSL, the controller shall abort the Write Uncorrectable command with Invalid Field in Command.

The case where the WUSL field in the Identify Controller dataset(CNS==6) is 0 and bit-1 of the ONCS field in the Identify Controller dataset(CNS==1) is 1 shall be treated as the controller is not specifying a maximum size. In this scenario, MAXLBAS shall be computed using Identify Controller(CNS==1) and Identify Namespace(CNS==0) data as 2^(MDTS + 12 + CAP.MPSMIN) / 2^LBA Format[FLBAS].

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

NVMe-IO-1/3/4/5/6/7/8/9/10/11/12/13/14, GETF-2

DSSD_25_Write_Zeroes_Test_Case.py

The objective of this test case is to verify the NVME IO requirements NVMe-IO-4, NVMe-IO-5, NVMe-IO-6 and NVMe-IO-7.

The device’s support for NVMe write zeroes commands is checked by issuing NVMe Write Zeros command.

Verify that the NVMe read command send after the NVMe Write Zeroes command with DEAC=0 and FUA=0 returns all zeros.

Verify that the NVMe read command send after the NVMe Write Zeroes command with DEAC=0 and FUA=1 returns all zeros.

Verify that the NVMe read command send after the NVMe Write Zeroes command with DEAC=1 and FUA=0 returns all zeros.

Verify that the NVMe read command send after the NVMe Write Zeroes command with DEAC=1 and FUA=0 returns all zeros.

Verify that the NVMe Write Zeroes command with DEAC=1, FUA=0, can deallocate the full capacity of the DUT in less than 1 minute.

The case where the WZSL field in the Identify Controller dataset(CNS==6) is 0 and bit-3 of the ONCS field in the Identify Controller dataset(CNS==1) is also 0 shall be treated as an error and test case failure.

In the case where the WZSL field in the Identify Controller dataset(CNS==6) is greater than 0, WZSL shall be used to set the value of MAXLBAS using Identify Controller(CNS==1) and Identify Namespace(CNS==0) data as 2^(WZSL + 12 + CAP.MPSMIN) / 2^LBA Format[FLBAS].

Verify that when the WZSL field in the Identify controller dataset(CNS==6) is greater than 0 and bit-3 of the ONCS field in the Identify Controller dataset is 0 and the host sends a Write Zeroes command with an NLB value greater than that specified by the value of WZSL, the controller shall abort the Write Zeroes command with Invalid Field in Command.

The case where the WZSL field in the Identify Controller dataset(CNS==6) is 0 and bit-3 of the ONCS field in the Identify Controller dataset(CNS==1) is 1 shall be treated as the controller is not specifying a maximum size. In this scenario, MAXLBAS shall be computed using Identify Controller(CNS==1) and Identify Namespace(CNS==0) data as 2^(MDTS + 12 + CAP.MPSMIN) / 2^LBA Format[FLBAS].

Open Compute Project Datacenter NVMe SSD Spec v2.5 requirements referenced by this script:

NVMe-IO-1/3/4/5/6/7/8/9/10/11/12/13/14, GETF-2

OCP_2_5_Group_2

DSSD_25_Admin_Command_Execution_Time_Verification_Test_Case.py

DSSD_25_Arbitration_Test_Case.py

DSSD_25_Basic_Command_And_Data_Verification_Test_Case.py

DSSD_25_Basic_Data_Persistence_Test_Case.py

DSSD_25_Basic_Namespace_Data_Verification_Test_Case.py

DSSD_25_Basic_Verification_Of_Asynchronous_Event_Requests_Test_Case.py

DSSD_25_Boot_Requirements_Test_Case.py

DSSD_25_Clear_FW_Update_History_Test_Case.py

DSSD_25_Clear_PCIe_Correctable_Error_Counters_Test_Case.py

DSSD_25_Commands_Received_During_Device_Self_Test_Operation_Test_Case.py

DSSD_25_Commands_Supported_And_Effects_Log_Page_Test_Case.py

DSSD_25_Compare_Test_Case.py

DSSD_25_Controller_Memory_Buffer_Test_Case.py

DSSD_25_Controller_Reset_Test_Case.py

DSSD_25_Controller_Status_Ready_Test_Case.py

DSSD_25_Data_Persistence_Across_Format_NVM_Operations_Test_Case.py

DSSD_25_Data_Persistence_Across_Sanitize_Operations_Test_Case.py

DSSD_25_Data_Persistence_Across_TCG_Operations_Test_Case.py

DSSD_25_Dataset_Management_Command_Verification_Test_Case.py

DSSD_25_Destructiveness_For_Device_Self_Test_Operation_Test_Case.py

DSSD_25_Device_Capabilities_Log_Page_Test_Case.py

DSSD_25_Drive_Behavior_In_Case_Of_PLP_Failure_Test_Case.py

DSSD_25_Drive_State_After_Firmware_Activation_Without_Reset_Test_Case.py

DSSD_25_E1L_PCIe_Speed_And_Lane_Width_Test_Case.py

DSSD_25_E1L_PWRDIS_Test_Case.py

DSSD_25_E1S_PCIe_Speed_And_Lane_Width_Test_Case.py

DSSD_25_E1S_PWRDIS_Test_Case.py

DSSD_25_EUI64_And_NGUID_Test_Case.py

DSSD_25_Endianness_Verification_Test_Case.py

DSSD_25_Endurance_Estimate_Test_Case.py

DSSD_25_Endurance_Group_Information_Log_Page_09h_Test_Case.py

DSSD_25_Error_Information_Log_Page_Test_Case.py

DSSD_25_Error_Recovery_Log_Page_Test_Case.py

DSSD_25_Execution_Time_Device_Self_Test_Operation_Test_Case.py

DSSD_25_Factory_Default_Settings_Verification_Test_Case.py

DSSD_25_Failed_Sanitize_Operations_Test_Case.py

DSSD_25_Fatal_Status_Test_Case.py

DSSD_25_Firmware_Activation_Notice_AE_Test_Case.py

DSSD_25_Firmware_Slot_Information_Log_Page_Test_Case.py

DSSD_25_Firmware_Update_Test_Case.py

DSSD_25_Firmware_Update_Without_Data_Loss_Or_Destruction_Test_Case.py

DSSD_25_Format_NVM_Command_Extended_Execution_Time_Verification_Test_Case.py

DSSD_25_Format_NVM_Command_On_A_Per_Namespace_Basis_Test_Case.py

DSSD_25_Format_NVM_Crypto_Erase_Test_Case.py

DSSD_25_Format_NVM_No_Secure_Erase_Test_Case.py

DSSD_25_Format_NVM_User_Data_Erase_Test_Case.py

DSSD_25_Get_Set_Feature_C6_PLP_Health_Check_Interval_Test_Case.py

DSSD_25_Get_Set_Feature_DSSD_Asynchronous_Event_Feature_Verification_Test_Case.py

DSSD_25_Hardware_Component_Log_Page_Test_Case.py

DSSD_25_IEEE1667_Feature_Test_Case.py

DSSD_25_IO_Command_Execution_Time_Verification_Test_Case.py

DSSD_25_Incomplete_Shutdown_Test_Case.py

DSSD_25_LBA_Status_Information_Log_Page_Test_Case.py

DSSD_25_Little_Endian_Verification_Test_Case.py

DSSD_25_Low_Power_Modes_Requirements_Test_Case.py

DSSD_25_M2_PCIe_Speed_And_Lane_Width_Test_Case.py

DSSD_25_Maximum_Data_Transfer_Size_Test_Case.py

DSSD_25_NVMe_Commands_Received_During_Sanitize_Operation_Test_Case.py

DSSD_25_NVMe_Controller_Configuration_And_Behavior_Test_Case.py

DSSD_25_Namespace_Attachment_Command_Verification_Test_Case.py

DSSD_25_Namespace_Attribute_Notices_AE_Test_Case.py

DSSD_25_Namespace_Management_Command_Verification_Test_Case.py

DSSD_25_Namespace_Support_Test_Case.py

DSSD_25_PCIe_Max_Payload_Size_Requirements_Test_Case.py

DSSD_25_PCIe_Resets_Requirements_Test_Case.py

DSSD_25_PCIe_TLP_Completion_Timeout_Requirements_Test_Case.py

DSSD_25_PEL_Data_Persistence_Across_Format_NVM_Operations_Test_Case.py

DSSD_25_PEL_Data_Persistence_Across_Sanitize_Operations_Test_Case.py

DSSD_25_PEL_Data_Persistence_Across_TCG_Purge_Operations_Test_Case.py

DSSD_25_PERST_Test_Case.py

DSSD_25_PLP_Start_Count_Test_Case.py

DSSD_25_Persistent_Event_Log_Page_Test_Case.py

DSSD_25_Physical_Media_Units_Test_Case.py

DSSD_25_Power_Loss_And_Reset_Events_During_Firmware_Activation_Process_Test_Case.py

DSSD_25_Power_State_Change_Count_Test_Case.py

DSSD_25_Purge_Data_By_TCG_Related_Operations_Test_Case.py

DSSD_25_Queue_Depth_And_IO_Queue_Pairs_Test_Case.py

DSSD_25_Read_Only_Or_Write_Through_Mode_Feature_Test_Case.py

DSSD_25_SMBus_Data_TTR_Verification_Test_Case.py