tests: handle data size based on dsp and ms settings

The read, write and compare use case have hard coded dependencies on data size.
Use dsp and ms from the namespace and set the data size correctly.

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

Author: igaw

tests/nvme_compare_test.py

@@ -60,7 +60,6 @@ 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"
@@ -83,6 +82,8 @@ 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}"
         return self.exec_cmd(compare_cmd)
 
     def test_nvme_compare(self):

tests/nvme_test.py

@@ -80,6 +80,7 @@ def setUp(self):
         self.do_validate_pci_device = True
         self.default_nsid = 0x1
         self.flbas = 0
+        self.ns_dps = 0
         self.config_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'config.json')
 
         self.load_config()
@@ -88,6 +89,13 @@ def setUp(self):
         self.ns_mgmt_supported = self.get_ns_mgmt_support()
         if self.ns_mgmt_supported:
             self.create_and_attach_default_ns()
+        else:
+            # Namespace is managed externally (e.g. by QEMU). Discover the
+            # active lbaf so that get_lba_format_size() returns the correct
+            # ds and ms values for the format actually in use.  Also read
+            # the DPS field so IO tests can enable PRACT when PI is active.
+            self.flbas = self._get_active_lbaf_index()
+            self.ns_dps = self._get_ns_dps()
         logger.debug("setup: ctrl: %s, ns1: %s, default_nsid: %s, flbas: %s",
                      self.ctrl, self.ns1, self.default_nsid, self.flbas)
 
@@ -300,6 +308,38 @@ 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); non-zero means end-to-end PI is enabled.
+        """
+        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_lba_format_size(self):
         """ Wrapper for extracting lba format size of the given flbas
             - Args:

tests/nvme_test_io.py

@@ -43,7 +43,22 @@ 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()
+        if self.ns_dps != 0 and ms != 0:
+            # End-to-end protection information (PI) is active.  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.
+            self.prinfo = 8
+            self.data_size = ds
+        else:
+            # No PI.  Include the full LBA (user data + metadata) in the
+            # buffer so the read file size matches the write file size and
+            # so that uninitialized trailing metadata bytes are consistent
+            # across write and compare operations.
+            self.prinfo = 0
+            self.data_size = ds + ms
         self.start_block = 0
         self.block_count = 0
         self.write_file = "write_file.txt"
@@ -81,6 +96,8 @@ 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}"
         return self.exec_cmd(write_cmd)
 
     def nvme_read(self):
@@ -94,4 +111,6 @@ 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}"
         return self.exec_cmd(read_cmd)