tests: handle PI and MS settings

Teach the test framework about PI and MS.

Signed-off-by: Daniel Wagner <wagi@kernel.org>

Author: igaw

tests/nvme_compare_test.py

@@ -60,13 +60,19 @@ def setUp(self):
         super().setUp()
         if not self.compare_cmd_supported():
             self.skipTest("because: Optional NVM Command 'Compare' (NVMCMPS) not supported")
-        self.data_size = 1024
         self.start_block = 1023
         self.setup_log_dir(self.__class__.__name__)
         self.compare_file = self.test_log_dir + "/" + "compare_file.txt"
         self.write_file = self.test_log_dir + "/" + self.write_file
         self.create_data_file(self.write_file, self.data_size, "15")
         self.create_data_file(self.compare_file, self.data_size, "25")
+        self.compare_meta_file = None
+        if self.ms > 0 and not self.ns_meta_ext:
+            self.write_meta_file = self.test_log_dir + "/" + self.write_meta_file
+            self.compare_meta_file = \
+                self.test_log_dir + "/" + "compare_meta_file.bin"
+            self.create_meta_file(self.write_meta_file, self.ms)
+            self.create_meta_file(self.compare_meta_file, self.ms)
 
     def tearDown(self):
         """ Post Section for TestNVMeCompareCmd """
@@ -83,6 +89,11 @@ def nvme_compare(self, cmp_file):
             f"--start-block={str(self.start_block)} " + \
             f"--block-count={str(self.block_count)} " + \
             f"--data-size={str(self.data_size)} --data={cmp_file}"
+        if self.prinfo:
+            compare_cmd += f" --prinfo={self.prinfo}"
+        if self.compare_meta_file:
+            compare_cmd += \
+                f" --metadata-size={self.ms} --metadata={self.compare_meta_file}"
         return self.exec_cmd(compare_cmd)
 
     def test_nvme_compare(self):

tests/nvme_read_write_test.py

@@ -54,6 +54,10 @@ def setUp(self):
         self.read_file = self.test_log_dir + "/" + self.read_file
         self.create_data_file(self.write_file, self.data_size, "15")
         open(self.read_file, 'a').close()
+        if self.ms > 0 and not self.ns_meta_ext:
+            self.write_meta_file = self.test_log_dir + "/" + self.write_meta_file
+            self.read_meta_file = self.test_log_dir + "/" + self.read_meta_file
+            self.create_meta_file(self.write_meta_file, self.ms)
 
     def tearDown(self):
         """ Post Section for TestNVMeReadWriteTest """

tests/nvme_test.py

@@ -80,6 +80,9 @@ def setUp(self):
         self.do_validate_pci_device = True
         self.default_nsid = 0x1
         self.flbas = 0
+        self.ns_dps = 0
+        self.ns_meta_ext = False
+        self.pif = 0
         self.config_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'config.json')
 
         self.load_config()
@@ -88,6 +91,11 @@ def setUp(self):
         self.ns_mgmt_supported = self.get_ns_mgmt_support()
         if self.ns_mgmt_supported:
             self.create_and_attach_default_ns()
+        else:
+            self.flbas = self._get_active_lbaf_index()
+            self.ns_dps = self._get_ns_dps()
+            self.ns_meta_ext = self._is_metadata_ext()
+            self.pif = self._get_pif()
         logger.debug("setup: ctrl: %s, ns1: %s, default_nsid: %s, flbas: %s",
                      self.ctrl, self.ns1, self.default_nsid, self.flbas)
 
@@ -300,6 +308,77 @@ def get_lba_status_supported(self):
         """
         return to_decimal(self.get_id_ctrl_field_value("oacs")) & (1 << 9)
 
+    def _get_active_lbaf_index(self):
+        """ Return the index of the currently active LBA format for ns1.
+            - Args:
+                - None
+            - Returns:
+                - lbaf index (int) of the format whose in_use flag is set,
+                  or 0 if no in_use entry is found.
+        """
+        nvme_id_ns_cmd = f"{self.nvme_bin} id-ns {self.ns1} " + \
+            "--output-format=json"
+        result = self.run_cmd(nvme_id_ns_cmd)
+        self.assertEqual(result.returncode, 0, "ERROR : reading id-ns")
+        json_output = json.loads(result.stdout)
+        for lbaf in json_output.get('lbafs', []):
+            if lbaf.get('in_use') == 1:
+                return int(lbaf['lbaf'])
+        return 0
+
+    def _get_ns_dps(self):
+        """ Return the Data Protection Settings (DPS) field for ns1.
+            - Args:
+                - None
+            - Returns:
+                - dps value (int); bits 2:0 are the PI type (non-zero means
+                  end-to-end PI is enabled), bits 5:3 are the Protection
+                  Information Format (PIF) on NVMe 2.0+ devices.
+        """
+        nvme_id_ns_cmd = f"{self.nvme_bin} id-ns {self.ns1} " + \
+            "--output-format=json"
+        result = self.run_cmd(nvme_id_ns_cmd)
+        self.assertEqual(result.returncode, 0, "ERROR : reading id-ns")
+        json_output = json.loads(result.stdout)
+        return int(json_output.get('dps', 0))
+
+    def _get_pif(self):
+        """ Return the Protection Information Format (PIF) for ns1.
+
+            The PIF is stored in bits 5:3 of the DPS field (NVMe 2.0+):
+              PIF 0 - 8-byte PI, 16-bit CRC guard (Type 1/2/3, all NVMe 1.x)
+              PIF 1 - 16-byte PI, 64-bit CRC guard
+              PIF 2 - 8-byte PI, 32-bit CRC guard
+
+            NVMe 1.x devices always return 0 for these bits.
+
+            - Args:
+                - None
+            - Returns:
+                - pif value (int, 0-7).
+        """
+        nvme_id_ns_cmd = f"{self.nvme_bin} id-ns {self.ns1} " + \
+            "--output-format=json"
+        result = self.run_cmd(nvme_id_ns_cmd)
+        self.assertEqual(result.returncode, 0, "ERROR : reading id-ns")
+        json_output = json.loads(result.stdout)
+        dps = int(json_output.get('dps', 0))
+        return (dps >> 3) & 0x7
+
+    def _is_metadata_ext(self):
+        """ Return True if the active LBA format uses extended LBA (bit 4 of
+            the flbas field is set, meaning metadata is appended at the end of
+            the data buffer). Return False if bit 4 is clear, meaning metadata
+            is transferred as a separate, contiguous buffer.
+        """
+        nvme_id_ns_cmd = f"{self.nvme_bin} id-ns {self.ns1} " + \
+            "--output-format=json"
+        result = self.run_cmd(nvme_id_ns_cmd)
+        self.assertEqual(result.returncode, 0, "ERROR : reading id-ns")
+        json_output = json.loads(result.stdout)
+        flbas = int(json_output.get('flbas', 0))
+        return bool(flbas & (1 << 4))
+
     def get_lba_format_size(self):
         """ Wrapper for extracting lba format size of the given flbas
             - Args:

tests/nvme_test_io.py

@@ -43,11 +43,54 @@ def setUp(self):
         """ Pre Section for TestNVMeIO """
         super().setUp()
         # common code used in various testcases.
-        (self.data_size, _) = self.get_lba_format_size()
+        (ds, ms) = self.get_lba_format_size()
+        self.ms = ms
+        # PI type occupies bits 2:0 of the DPS field; bits 5:3 are PIF.
+        pi_type = self.ns_dps & 0x7
+        if pi_type != 0 and ms != 0 and self.ns_meta_ext:
+            # PI active + extended LBA (metadata appended to data buffer).
+            # Use PRACT=1 (--prinfo=8) so the controller inserts and strips PI
+            # automatically.  With PRACT=1 the PI bytes are not transferred
+            # over the host interface, so data_size equals the logical block
+            # data size only (ds), not ds+ms.  This works for all PI sizes
+            # (8 bytes for PIF 0/2, 16 bytes for PIF 1) and all guard widths
+            # (16-bit, 32-bit, 64-bit CRC) because the controller handles
+            # the PI entirely.
+            self.prinfo = 8
+            self.data_size = ds
+        elif pi_type != 0 and ms != 0 and not self.ns_meta_ext:
+            # PI active + separate metadata (flbas bit 4 clear).  PRACT=1
+            # (--prinfo=8) is invalid for the Compare command on this format
+            # (NVMe spec: PRACT=1 for Compare requires PI in the host data
+            # buffer, which only applies to the extended-LBA layout).  Use
+            # prinfo=0 (PRACT=0, PRCHK=0) for all operations and supply an
+            # explicit zero-filled metadata buffer of ms bytes so that the
+            # stored metadata and the compared metadata are both known zeros.
+            # PRCHK=0 skips PI validation, so the zero PI bytes are accepted
+            # by the controller on write and matched exactly on compare.  This
+            # is PI-format and guard-width agnostic: the entire ms-byte
+            # metadata slot (whether holding an 8-byte PI with 16-bit or
+            # 32-bit guard, or a 16-byte PI with 64-bit guard) is zeroed.
+            self.prinfo = 0
+            self.data_size = ds
+        else:
+            # No PI.  For extended LBA format (metadata appended to the data
+            # buffer) include the metadata bytes so that the controller sees
+            # a consistent data+metadata unit.  For separate metadata format
+            # (flbas bit 4 clear) the metadata is transferred via a different
+            # pointer and must NOT be folded into the data buffer; use ds only
+            # so that the data transfer length matches exactly one LBA.
+            self.prinfo = 0
+            self.data_size = ds + ms if self.ns_meta_ext else ds
         self.start_block = 0
         self.block_count = 0
         self.write_file = "write_file.txt"
         self.read_file = "read_file.txt"
+        # Basename only; subclasses must prepend the test_log_dir path before
+        # use (same convention as write_file and read_file above).
+        if self.ms > 0 and not self.ns_meta_ext:
+            self.write_meta_file = "write_meta_file.bin"
+            self.read_meta_file = "read_meta_file.bin"
 
     def tearDown(self):
         """ Post Section for TestNVMeIO """
@@ -70,6 +113,18 @@ def create_data_file(self, pathname, data_size, pattern):
         os.fsync(data_file.fileno())
         data_file.close()
 
+    def create_meta_file(self, pathname, meta_size):
+        """ Creates a binary file of meta_size zero bytes for use as a
+            separate-metadata buffer in nvme write/read/compare commands.
+            - Args:
+                - pathname : metadata file path name.
+                - meta_size : total size of the metadata in bytes.
+            - Returns:
+            None
+        """
+        with open(pathname, "wb") as meta_file:
+            meta_file.write(bytes(meta_size))
+
     def nvme_write(self):
         """ Wrapper for nvme write operation
             - Args:
@@ -81,6 +136,11 @@ def nvme_write(self):
             f"--start-block={str(self.start_block)} " + \
             f"--block-count={str(self.block_count)} " + \
             f"--data-size={str(self.data_size)} --data={self.write_file}"
+        if self.prinfo:
+            write_cmd += f" --prinfo={self.prinfo}"
+        if self.ms > 0 and not self.ns_meta_ext:
+            write_cmd += \
+                f" --metadata-size={self.ms} --metadata={self.write_meta_file}"
         return self.exec_cmd(write_cmd)
 
     def nvme_read(self):
@@ -94,4 +154,9 @@ def nvme_read(self):
             f"--start-block={str(self.start_block)} " + \
             f"--block-count={str(self.block_count)} " + \
             f"--data-size={str(self.data_size)} --data={self.read_file}"
+        if self.prinfo:
+            read_cmd += f" --prinfo={self.prinfo}"
+        if self.ms > 0 and not self.ns_meta_ext:
+            read_cmd += \
+                f" --metadata-size={self.ms} --metadata={self.read_meta_file}"
         return self.exec_cmd(read_cmd)

tests/nvme_writezeros_test.py

@@ -59,6 +59,10 @@ def setUp(self):
         self.create_data_file(self.write_file, self.data_size, "15")
         self.create_data_file(self.zero_file, self.data_size, '\0')
         open(self.read_file, 'a').close()
+        if self.ms > 0 and not self.ns_meta_ext:
+            self.write_meta_file = self.test_log_dir + "/" + self.write_meta_file
+            self.read_meta_file = self.test_log_dir + "/" + self.read_meta_file
+            self.create_meta_file(self.write_meta_file, self.ms)
 
     def tearDown(self):
         """ Post Section for TestNVMeWriteZeros """