Recent changes (master)

[Jens Axboe <axboe@kernel.dk>]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 21269 bytes --]

The following changes since commit 3ed8eea0ee9b5d7de603e9b128e6c05941b99938:

  t/zbd: avoid test case 31 failure with small devices (2024-04-30 11:11:58 -0400)

are available in the Git repository at:

  git://git.kernel.dk/fio.git master

for you to fetch changes up to d3bcdd30da4ad2d6f845e65d6a358c080e120b5e:

  Merge branch 'enable-dataplacement-scheme' of https://github.com/parkvibes/fio (2024-05-21 14:06:32 -0400)

----------------------------------------------------------------
Hyunwoo Park (2):
      fdp: support scheme placement id (index) selection
      t/nvmept_fdp: add tests(302,303,400,401) for fdp scheme

Vincent Fu (1):
      Merge branch 'enable-dataplacement-scheme' of https://github.com/parkvibes/fio

 HOWTO.rst        |  28 +++++++++++-
 cconv.c          |   2 +
 dataplacement.c  |  78 +++++++++++++++++++++++++++++++++
 dataplacement.h  |  14 +++++-
 file.h           |   1 +
 fio.1            |  32 +++++++++++++-
 options.c        |  52 ++++++++++++++++++++++
 server.h         |   2 +-
 t/nvmept_fdp.py  | 131 +++++++++++++++++++++++++++++++++++++++++++++++++++----
 thread_options.h |   2 +
 10 files changed, 329 insertions(+), 13 deletions(-)

---

Diff of recent changes:

diff --git a/HOWTO.rst b/HOWTO.rst
index 2f8ef6d4..3b262fae 100644
--- a/HOWTO.rst
+++ b/HOWTO.rst
@@ -2529,8 +2529,12 @@ with the caveat that when used on the command line, they must come after the
 			Round robin over available placement IDs. This is the
 			default.
 
-	The available placement ID (indices) are defined by the option
-	:option:`plids`.
+		**scheme**
+			Choose a placement ID (index) based on the scheme file defined by
+			the option :option:`dp_scheme`.
+
+	The available placement ID (indices) are defined by the option :option:`fdp_pli`
+	or :option:`plids` except for the case of **scheme**.
 
 .. option:: plids=str, fdp_pli=str : [io_uring_cmd] [xnvme]
 
@@ -2541,6 +2545,26 @@ with the caveat that when used on the command line, they must come after the
         identifiers only at indices 0, 2 and 5 specify ``plids=0,2,5``. For
         streams this should be a comma-separated list of Stream IDs.
 
+.. option:: dp_scheme=str : [io_uring_cmd] [xnvme]
+
+	Defines which placement ID (index) to be selected based on offset(LBA) range.
+	The file should contains one or more scheme entries in the following format:
+
+		0, 10737418240, 0
+		10737418240, 21474836480, 1
+		21474836480, 32212254720, 2
+		...
+
+	Each line, a scheme entry, contains start offset, end offset, and placement ID
+	(index) separated by comma(,). If the write offset is within the range of a certain
+	scheme entry(start offset ≤ offset < end offset), the corresponding placement ID
+	(index) will be selected. If the write offset belongs to multiple scheme entries,
+	the first matched scheme entry will be applied. If the offset is not within any range
+	of scheme entry, dspec field will be set to 0, default RUH. (Caution: In case of
+	multiple devices in a job, all devices of the job will be affected by the scheme. If
+	this option is specified, the option :option:`plids` or :option:`fdp_pli` will be
+	ignored.)
+
 .. option:: md_per_io_size=int : [io_uring_cmd] [xnvme]
 
 	Size in bytes for separate metadata buffer per IO. Default: 0.
diff --git a/cconv.c b/cconv.c
index 16112248..9b344940 100644
--- a/cconv.c
+++ b/cconv.c
@@ -94,6 +94,7 @@ int convert_thread_options_to_cpu(struct thread_options *o,
 	string_to_cpu(&o->ioscheduler, top->ioscheduler);
 	string_to_cpu(&o->profile, top->profile);
 	string_to_cpu(&o->cgroup, top->cgroup);
+	string_to_cpu(&o->dp_scheme_file, top->dp_scheme_file);
 
 	o->allow_create = le32_to_cpu(top->allow_create);
 	o->allow_mounted_write = le32_to_cpu(top->allow_mounted_write);
@@ -398,6 +399,7 @@ void convert_thread_options_to_net(struct thread_options_pack *top,
 	string_to_net(top->ioscheduler, o->ioscheduler);
 	string_to_net(top->profile, o->profile);
 	string_to_net(top->cgroup, o->cgroup);
+	string_to_net(top->dp_scheme_file, o->dp_scheme_file);
 
 	top->allow_create = cpu_to_le32(o->allow_create);
 	top->allow_mounted_write = cpu_to_le32(o->allow_mounted_write);
diff --git a/dataplacement.c b/dataplacement.c
index 1d5b21ed..8a4c8e64 100644
--- a/dataplacement.c
+++ b/dataplacement.c
@@ -100,6 +100,56 @@ out:
 	return ret;
 }
 
+static int init_ruh_scheme(struct thread_data *td, struct fio_file *f)
+{
+	struct fio_ruhs_scheme *ruh_scheme;
+	FILE *scheme_fp;
+	unsigned long long start, end;
+	uint16_t pli;
+	int ret = 0;
+
+	if (td->o.dp_id_select != FIO_DP_SCHEME)
+		return 0;
+
+	/* Get the scheme from the file */
+	scheme_fp = fopen(td->o.dp_scheme_file, "r");
+
+	if (!scheme_fp) {
+		log_err("fio: ruh scheme failed to open scheme file %s\n",
+			 td->o.dp_scheme_file);
+		ret = -errno;
+		goto out;
+	}
+
+	ruh_scheme = scalloc(1, sizeof(*ruh_scheme));
+	if (!ruh_scheme) {
+		ret = -ENOMEM;
+		goto out_with_close_fp;
+	}
+
+	for (int i = 0;
+		i < DP_MAX_SCHEME_ENTRIES && fscanf(scheme_fp, "%llu,%llu,%hu\n", &start, &end, &pli) == 3;
+		i++) {
+
+		ruh_scheme->scheme_entries[i].start_offset = start;
+		ruh_scheme->scheme_entries[i].end_offset = end;
+		ruh_scheme->scheme_entries[i].pli = pli;
+		ruh_scheme->nr_schemes++;
+	}
+
+	if (fscanf(scheme_fp, "%llu,%llu,%hu\n", &start, &end, &pli) == 3)
+		log_info("fio: too many scheme entries in %s. Only the first %d scheme entries are applied\n",
+			 td->o.dp_scheme_file,
+			 DP_MAX_SCHEME_ENTRIES);
+
+	f->ruhs_scheme = ruh_scheme;
+
+out_with_close_fp:
+	fclose(scheme_fp);
+out:
+	return ret;
+}
+
 int dp_init(struct thread_data *td)
 {
 	struct fio_file *f;
@@ -109,6 +159,10 @@ int dp_init(struct thread_data *td)
 		ret = init_ruh_info(td, f);
 		if (ret)
 			break;
+
+		ret = init_ruh_scheme(td, f);
+		if (ret)
+			break;
 	}
 	return ret;
 }
@@ -119,6 +173,11 @@ void fdp_free_ruhs_info(struct fio_file *f)
 		return;
 	sfree(f->ruhs_info);
 	f->ruhs_info = NULL;
+
+	if (!f->ruhs_scheme)
+		return;
+	sfree(f->ruhs_scheme);
+	f->ruhs_scheme = NULL;
 }
 
 void dp_fill_dspec_data(struct thread_data *td, struct io_u *io_u)
@@ -138,6 +197,25 @@ void dp_fill_dspec_data(struct thread_data *td, struct io_u *io_u)
 			ruhs->pli_loc = 0;
 
 		dspec = ruhs->plis[ruhs->pli_loc++];
+	} else if (td->o.dp_id_select == FIO_DP_SCHEME) {
+		struct fio_ruhs_scheme *ruhs_scheme = f->ruhs_scheme;
+		unsigned long long offset = io_u->offset;
+		int i;
+
+		for (i = 0; i < ruhs_scheme->nr_schemes; i++) {
+			if (offset >= ruhs_scheme->scheme_entries[i].start_offset &&
+			    offset < ruhs_scheme->scheme_entries[i].end_offset) {
+				dspec = ruhs_scheme->scheme_entries[i].pli;
+				break;
+			}
+		}
+
+		/*
+		 * If the write offset is not affected by any scheme entry,
+		 * 0(default RUH) will be assigned to dspec
+		 */
+		if (i == ruhs_scheme->nr_schemes)
+			dspec = 0;
 	} else {
 		ruhs->pli_loc = rand_between(&td->fdp_state, 0, ruhs->nr_ruhs - 1);
 		dspec = ruhs->plis[ruhs->pli_loc];
diff --git a/dataplacement.h b/dataplacement.h
index b5718c86..71d19d69 100644
--- a/dataplacement.h
+++ b/dataplacement.h
@@ -7,6 +7,7 @@
 #define FDP_DIR_DTYPE		2
 #define FDP_MAX_RUHS		128
 #define FIO_MAX_DP_IDS 		16
+#define DP_MAX_SCHEME_ENTRIES	32
 
 /*
  * How fio chooses what placement identifier to use next. Choice of
@@ -15,9 +16,9 @@
 enum {
 	FIO_DP_RANDOM	= 0x1,
 	FIO_DP_RR	= 0x2,
+	FIO_DP_SCHEME	= 0x3,
 };
 
-
 enum {
 	FIO_DP_NONE	= 0x0,
 	FIO_DP_FDP	= 0x1,
@@ -30,6 +31,17 @@ struct fio_ruhs_info {
 	uint16_t plis[];
 };
 
+struct fio_ruhs_scheme_entry {
+	unsigned long long start_offset;
+	unsigned long long end_offset;
+	uint16_t pli;
+};
+
+struct fio_ruhs_scheme {
+	uint16_t nr_schemes;
+	struct fio_ruhs_scheme_entry scheme_entries[DP_MAX_SCHEME_ENTRIES];
+};
+
 int dp_init(struct thread_data *td);
 void fdp_free_ruhs_info(struct fio_file *f);
 void dp_fill_dspec_data(struct thread_data *td, struct io_u *io_u);
diff --git a/file.h b/file.h
index deb36e02..e38ed2f1 100644
--- a/file.h
+++ b/file.h
@@ -103,6 +103,7 @@ struct fio_file {
 	uint64_t io_size;
 
 	struct fio_ruhs_info *ruhs_info;
+	struct fio_ruhs_scheme *ruhs_scheme;
 
 	/*
 	 * Zoned block device information. See also zonemode=zbd.
diff --git a/fio.1 b/fio.1
index ee812494..1c8e3a56 100644
--- a/fio.1
+++ b/fio.1
@@ -2294,9 +2294,14 @@ Choose a placement ID at random (uniform).
 .TP
 .B roundrobin
 Round robin over available placement IDs. This is the default.
+.TP
+.B scheme
+Choose a placement ID (index) based on the scheme file defined by
+the option \fBdp_scheme\fP.
 .RE
 .P
-The available placement ID (indices) are defined by the \fBplids\fR option.
+The available placement ID (indices) are defined by \fBplids\fR or
+\fBfdp_pli\fR option except for the case of \fBscheme\fP.
 .RE
 .TP
 .BI (io_uring_cmd,xnvme)plids=str, fdp_pli \fR=\fPstr
@@ -2307,6 +2312,31 @@ jobs. If you want fio to use placement identifier only at indices 0, 2 and 5
 specify, you would set `plids=0,2,5`. For streams this should be a
 comma-separated list of Stream IDs.
 .TP
+.BI (io_uring_cmd,xnvme)\fR\fBdp_scheme\fP=str
+Defines which placement ID (index) to be selected based on offset(LBA) range.
+The file should contains one or more scheme entries in the following format:
+.sp
+.RS
+.RS
+0, 10737418240, 0
+.br
+10737418240, 21474836480, 1
+.br
+21474836480, 32212254720, 2
+.br
+\&...
+.RE
+.sp
+Each line, a scheme entry, contains start offset, end offset, and placement ID
+(index) separated by comma(,). If the write offset is within the range of a certain
+scheme entry(start offset ≤ offset < end offset), the corresponding placement ID
+(index) will be selected. If the write offset belongs to multiple scheme entries,
+the first matched scheme entry will be applied. If the offset is not within any range
+of scheme entry, dspec field will be set to 0, default RUH. (Caution: In case of
+multiple devices in a job, all devices of the job will be affected by the scheme. If
+this option is specified, the option \fBplids\fP or \fBfdp_pli\fP will be ignored.)
+.RE
+.TP
 .BI (io_uring_cmd,xnvme)md_per_io_size \fR=\fPint
 Size in bytes for separate metadata buffer per IO. Default: 0.
 .TP
diff --git a/options.c b/options.c
index 61ea41cc..f5d221c7 100644
--- a/options.c
+++ b/options.c
@@ -287,6 +287,43 @@ static int str_fdp_pli_cb(void *data, const char *input)
 	return 0;
 }
 
+/* str_dp_scheme_cb() is a callback function for parsing the fdp_scheme option
+	This function validates the fdp_scheme filename. */
+static int str_dp_scheme_cb(void *data, const char *input)
+{
+	struct thread_data *td = cb_data_to_td(data);
+	struct stat sb;
+	char *filename;
+	int ret = 0;
+
+	if (parse_dryrun())
+		return 0;
+
+	filename = strdup(td->o.dp_scheme_file);
+	strip_blank_front(&filename);
+	strip_blank_end(filename);
+
+	strcpy(td->o.dp_scheme_file, filename);
+
+	if (lstat(filename, &sb) < 0){
+		ret = errno;
+		log_err("fio: lstat() error related to %s\n", filename);
+		td_verror(td, ret, "lstat");
+		goto out;
+	}
+
+	if (!S_ISREG(sb.st_mode)) {
+		ret = errno;
+		log_err("fio: %s is not a file\n", filename);
+		td_verror(td, ret, "S_ISREG");
+		goto out;
+	}
+
+out:
+	free(filename);
+	return ret;
+}
+
 static int str_bssplit_cb(void *data, const char *input)
 {
 	struct thread_data *td = cb_data_to_td(data);
@@ -3760,6 +3797,10 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 			    .oval = FIO_DP_RR,
 			    .help = "Round robin select Placement IDs",
 			  },
+			  { .ival = "scheme",
+			    .oval = FIO_DP_SCHEME,
+			    .help = "Use a scheme(based on LBA) to select Placement IDs",
+			  },
 		},
 	},
 	{
@@ -3774,6 +3815,17 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.category = FIO_OPT_C_IO,
 		.group	= FIO_OPT_G_INVALID,
 	},
+	{
+		.name	= "dp_scheme",
+		.lname	= "Data Placement Scheme",
+		.type	= FIO_OPT_STR_STORE,
+		.cb	= str_dp_scheme_cb,
+		.off1	= offsetof(struct thread_options, dp_scheme_file),
+		.maxlen	= PATH_MAX,
+		.help	= "scheme file that specifies offset-RUH mapping",
+		.category = FIO_OPT_C_IO,
+		.group	= FIO_OPT_G_INVALID,
+	},
 	{
 		.name	= "lockmem",
 		.lname	= "Lock memory",
diff --git a/server.h b/server.h
index 83ce449b..e8659f79 100644
--- a/server.h
+++ b/server.h
@@ -51,7 +51,7 @@ struct fio_net_cmd_reply {
 };
 
 enum {
-	FIO_SERVER_VER			= 104,
+	FIO_SERVER_VER			= 105,
 
 	FIO_SERVER_MAX_FRAGMENT_PDU	= 1024,
 	FIO_SERVER_MAX_CMD_MB		= 2048,
diff --git a/t/nvmept_fdp.py b/t/nvmept_fdp.py
index 031b439c..d6a543f2 100755
--- a/t/nvmept_fdp.py
+++ b/t/nvmept_fdp.py
@@ -56,6 +56,7 @@ class FDPTest(FioJobCmdTest):
             f"--output={self.filenames['output']}",
             f"--output-format={self.fio_opts['output-format']}",
         ]
+
         for opt in ['fixedbufs', 'nonvectored', 'force_async', 'registerfiles',
                     'sqthread_poll', 'sqthread_poll_cpu', 'hipri', 'nowait',
                     'time_based', 'runtime', 'verify', 'io_size', 'num_range',
@@ -63,7 +64,7 @@ class FDPTest(FioJobCmdTest):
                     'size', 'rate', 'bs', 'bssplit', 'bsrange', 'randrepeat',
                     'buffer_pattern', 'verify_pattern', 'offset', 'fdp',
                     'fdp_pli', 'fdp_pli_select', 'dataplacement', 'plid_select',
-                    'plids', 'number_ios']:
+                    'plids', 'dp_scheme', 'number_ios']:
             if opt in self.fio_opts:
                 option = f"--{opt}={self.fio_opts[opt]}"
                 fio_args.append(option)
@@ -91,19 +92,20 @@ class FDPTest(FioJobCmdTest):
             return
 
         job = self.json_data['jobs'][0]
+        rw_fio_opts = self.fio_opts['rw'].split(':')[0]
 
-        if self.fio_opts['rw'] in ['read', 'randread']:
+        if rw_fio_opts in ['read', 'randread']:
             self.passed = self.check_all_ddirs(['read'], job)
-        elif self.fio_opts['rw'] in ['write', 'randwrite']:
+        elif rw_fio_opts in ['write', 'randwrite']:
             if 'verify' not in self.fio_opts:
                 self.passed = self.check_all_ddirs(['write'], job)
             else:
                 self.passed = self.check_all_ddirs(['read', 'write'], job)
-        elif self.fio_opts['rw'] in ['trim', 'randtrim']:
+        elif rw_fio_opts in ['trim', 'randtrim']:
             self.passed = self.check_all_ddirs(['trim'], job)
-        elif self.fio_opts['rw'] in ['readwrite', 'randrw']:
+        elif rw_fio_opts in ['readwrite', 'randrw']:
             self.passed = self.check_all_ddirs(['read', 'write'], job)
-        elif self.fio_opts['rw'] in ['trimwrite', 'randtrimwrite']:
+        elif rw_fio_opts in ['trimwrite', 'randtrimwrite']:
             self.passed = self.check_all_ddirs(['trim', 'write'], job)
         else:
             logging.error("Unhandled rw value %s", self.fio_opts['rw'])
@@ -128,12 +130,25 @@ class FDPMultiplePLIDTest(FDPTest):
         mapping = {
                     'nruhsd': FIO_FDP_NUMBER_PLIDS,
                     'max_ruamw': FIO_FDP_MAX_RUAMW,
+                    # parameters for 400, 401 tests
+                    'hole_size': 64*1024,
+                    'nios_for_scheme': FIO_FDP_NUMBER_PLIDS//2,
                 }
         if 'number_ios' in self.fio_opts and isinstance(self.fio_opts['number_ios'], str):
             self.fio_opts['number_ios'] = eval(self.fio_opts['number_ios'].format(**mapping))
+        if 'bs' in self.fio_opts and isinstance(self.fio_opts['bs'], str):
+            self.fio_opts['bs'] = eval(self.fio_opts['bs'].format(**mapping))
+        if 'rw' in self.fio_opts and isinstance(self.fio_opts['rw'], str):
+            self.fio_opts['rw'] = self.fio_opts['rw'].format(**mapping)
 
         super().setup(parameters)
-
+        
+        if 'dp_scheme' in self.fio_opts:
+            scheme_path = os.path.join(self.paths['test_dir'], self.fio_opts['dp_scheme'])
+            with open(scheme_path, mode='w') as f:
+                for i in range(mapping['nios_for_scheme']):
+                    f.write(f'{mapping["hole_size"] * 2 * i}, {mapping["hole_size"] * 2 * (i+1)}, {i}\n')
+ 
     def _check_result(self):
         if 'fdp_pli' in self.fio_opts:
             plid_list = self.fio_opts['fdp_pli'].split(',')
@@ -157,10 +172,12 @@ class FDPMultiplePLIDTest(FDPTest):
             self._check_robin(plid_list, fdp_status)
         elif select == "random":
             self._check_random(plid_list, fdp_status)
+        elif select == "scheme":
+            self._check_scheme(plid_list, fdp_status)
         else:
             logging.error("Unknown plid selection strategy %s", select)
             self.passed = False
-
+        
         super()._check_result()
 
     def _check_robin(self, plid_list, fdp_status):
@@ -220,6 +237,42 @@ class FDPMultiplePLIDTest(FDPTest):
                 logging.debug("Observed expected ruamw %d for idx %d, pid %d", ruhs['ruamw'], idx,
                               ruhs['pid'])
 
+    def _check_scheme(self, plid_list, fdp_status):
+        """
+        With scheme selection, a set of PLIDs touched by the scheme
+        """
+
+        PLID_IDX_POS = 2
+        plid_list_from_scheme = set()
+
+        scheme_path = os.path.join(self.paths['test_dir'], self.fio_opts['dp_scheme'])
+
+        with open(scheme_path) as f:
+            lines = f.readlines()
+            for line in lines:
+                line_elem = line.strip().replace(' ', '').split(',')
+                plid_list_from_scheme.add(int(line_elem[PLID_IDX_POS]))
+
+        logging.debug(f'plid_list_from_scheme: {plid_list_from_scheme}')
+
+        for idx, ruhs in enumerate(fdp_status['ruhss']):
+            if ruhs['pid'] in plid_list_from_scheme:
+                if ruhs['ruamw'] == FIO_FDP_MAX_RUAMW:
+                    logging.error("pid %d should be touched by the scheme. But ruamw of it(%d) equals to %d",
+                                    ruhs['pid'], ruhs['ruamw'], FIO_FDP_MAX_RUAMW)
+                    self.passed = False
+                else:
+                    logging.debug("pid %d should be touched by the scheme. ruamw of it(%d) is under %d",
+                                    ruhs['pid'], ruhs['ruamw'], FIO_FDP_MAX_RUAMW)
+            else:
+                if ruhs['ruamw'] == FIO_FDP_MAX_RUAMW:
+                    logging.debug("pid %d should not be touched by the scheme. ruamw of it(%d) equals to %d",
+                                    ruhs['pid'], ruhs['ruamw'], FIO_FDP_MAX_RUAMW)
+                else:
+                    logging.error("pid %d should not be touched by the scheme. But ruamw of it(%d) is under %d",
+                                    ruhs['pid'], ruhs['ruamw'], FIO_FDP_MAX_RUAMW)
+                    self.passed = False
+
 
 class FDPSinglePLIDTest(FDPTest):
     """
@@ -674,6 +727,68 @@ TEST_LIST = [
         "test_class": FDPTest,
         "success": SUCCESS_NONZERO,
     },
+    # Specify invalid options related to dataplacement scheme
+    ## using old and new sets of options
+    {
+        "test_id": 302,
+        "fio_opts": {
+            "rw": 'write',
+            "bs": 4096,
+            "io_size": 4096,
+            "verify": "crc32c",
+            "fdp": 1,
+            "fdp_pli": 3,
+            "fdp_pli_select": "scheme",
+            "output-format": "normal",
+        },
+        "test_class": FDPTest,
+        "success": SUCCESS_NONZERO,
+    },
+    {
+        "test_id": 303,
+        "fio_opts": {
+            "rw": 'write',
+            "bs": 4096,
+            "io_size": 4096,
+            "verify": "crc32c",
+            "dataplacement": "fdp",
+            "plids": 3,
+            "plid_select": "scheme",
+            "output-format": "normal",
+        },
+        "test_class": FDPTest,
+        "success": SUCCESS_NONZERO,
+    },
+    # write to multiple PLIDs using scheme selection of PLIDs
+    ## using old and new sets of options
+    {
+        "test_id": 400,
+        "fio_opts": {
+            "rw": "write:{hole_size}",
+            "bs": "{hole_size}",
+            "number_ios": "{nios_for_scheme}",
+            "verify": "crc32c",
+            "fdp": 1,
+            "fdp_pli_select": "scheme",
+            "dp_scheme": "lba.scheme",            
+            "output-format": "json",
+            },
+        "test_class": FDPMultiplePLIDTest,
+    },
+    {
+        "test_id": 401,
+        "fio_opts": {
+            "rw": "write:{hole_size}",
+            "bs": "{hole_size}",
+            "number_ios": "{nios_for_scheme}",
+            "verify": "crc32c",
+            "dataplacement": "fdp",
+            "plid_select": "scheme",
+            "dp_scheme": "lba.scheme",
+            "output-format": "json",
+            },
+        "test_class": FDPMultiplePLIDTest,
+    },
 ]
 
 def parse_args():
diff --git a/thread_options.h b/thread_options.h
index a36b7909..ccd0c064 100644
--- a/thread_options.h
+++ b/thread_options.h
@@ -396,6 +396,7 @@ struct thread_options {
 	unsigned int dp_id_select;
 	unsigned int dp_ids[FIO_MAX_DP_IDS];
 	unsigned int dp_nr_ids;
+	char *dp_scheme_file;
 
 	unsigned int log_entries;
 	unsigned int log_prio;
@@ -713,6 +714,7 @@ struct thread_options_pack {
 	uint32_t dp_id_select;
 	uint32_t dp_ids[FIO_MAX_DP_IDS];
 	uint32_t dp_nr_ids;
+	uint8_t dp_scheme_file[FIO_TOP_STR_MAX];
 
 	uint32_t num_range;
 	/*