X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=options.c;h=923076752b6f6c03b979e52682c5de3c4dbf518f;hp=8c0c2abd295c667ddc195f7acaa34f9aa7ce5f14;hb=a5737c9363912baaa21af978358fb9f42e756beb;hpb=29d43ff9b1f342fe6658b17f0e349afcb6b76014

diff --git a/options.c b/options.c
index 8c0c2abd..92307675 100644
--- a/options.c
+++ b/options.c
@@ -14,8 +14,9 @@
 #include "verify.h"
 #include "parse.h"
 #include "lib/fls.h"
+#include "options.h"
 
-#define td_var_offset(var)	((size_t) &((struct thread_options *)0)->var)
+#include "crc/crc32c.h"
 
 /*
  * Check if mmap/mmaphuge has a :/foo/bar/file at the end. If so, return that.
@@ -33,6 +34,26 @@ static char *get_opt_postfix(const char *str)
 	return strdup(p);
 }
 
+static int converthexchartoint(char a)
+{
+	int base;
+
+	switch(a) {
+	case '0'...'9':
+		base = '0';
+		break;
+	case 'A'...'F':
+		base = 'A' - 10;
+		break;
+	case 'a'...'f':
+		base = 'a' - 10;
+		break;
+	default:
+		base = 0;
+	}
+	return (a - base);
+}
+
 static int bs_cmp(const void *p1, const void *p2)
 {
 	const struct bssplit *bsp1 = p1;
@@ -82,7 +103,7 @@ static int bssplit_ddir(struct thread_data *td, int ddir, char *str)
 		} else
 			perc = -1;
 
-		if (str_to_decimal(fname, &val, 1)) {
+		if (str_to_decimal(fname, &val, 1, td)) {
 			log_err("fio: bssplit conversion failed\n");
 			free(td->o.bssplit);
 			return 1;
@@ -206,6 +227,30 @@ static int str_mem_cb(void *data, const char *mem)
 	return 0;
 }
 
+static int str_verify_cb(void *data, const char *mem)
+{
+	struct thread_data *td = data;
+
+	if (td->o.verify != VERIFY_CRC32C_INTEL)
+		return 0;
+
+	if (!crc32c_intel_works()) {
+		log_info("fio: System does not support hw accelerated crc32c. Falling back to sw crc32c.\n");
+		td->o.verify = VERIFY_CRC32C;
+	}
+
+	return 0;
+}
+
+static int fio_clock_source_cb(void *data, const char *str)
+{
+	struct thread_data *td = data;
+
+	fio_clock_source = td->o.clocksource;
+	fio_time_init();
+	return 0;
+}
+
 static int str_lockmem_cb(void fio_unused *data, unsigned long *val)
 {
 	mlock_size = *val;
@@ -303,14 +348,14 @@ static int str_cpumask_cb(void *data, unsigned int *val)
 	return 0;
 }
 
-static int str_cpus_allowed_cb(void *data, const char *input)
+static int set_cpus_allowed(struct thread_data *td, os_cpu_mask_t *mask,
+			    const char *input)
 {
-	struct thread_data *td = data;
 	char *cpu, *str, *p;
 	long max_cpu;
 	int ret = 0;
 
-	ret = fio_cpuset_init(&td->o.cpumask);
+	ret = fio_cpuset_init(mask);
 	if (ret < 0) {
 		log_err("fio: cpuset_init failed\n");
 		td_verror(td, ret, "fio_cpuset_init");
@@ -356,9 +401,9 @@ static int str_cpus_allowed_cb(void *data, const char *input)
 				ret = 1;
 				break;
 			}
-	
+
 			dprint(FD_PARSE, "set cpu allowed %d\n", icpu);
-			fio_cpu_set(&td->o.cpumask, icpu);
+			fio_cpu_set(mask, icpu);
 			icpu++;
 		}
 		if (ret)
@@ -370,6 +415,30 @@ static int str_cpus_allowed_cb(void *data, const char *input)
 		td->o.cpumask_set = 1;
 	return ret;
 }
+
+static int str_cpus_allowed_cb(void *data, const char *input)
+{
+	struct thread_data *td = data;
+	int ret;
+
+	ret = set_cpus_allowed(td, &td->o.cpumask, input);
+	if (!ret)
+		td->o.cpumask_set = 1;
+
+	return ret;
+}
+
+static int str_verify_cpus_allowed_cb(void *data, const char *input)
+{
+	struct thread_data *td = data;
+	int ret;
+
+	ret = set_cpus_allowed(td, &td->o.verify_cpumask, input);
+	if (!ret)
+		td->o.verify_cpumask_set = 1;
+
+	return ret;
+}
 #endif
 
 static int str_fst_cb(void *data, const char *str)
@@ -386,6 +455,22 @@ static int str_fst_cb(void *data, const char *str)
 	return 0;
 }
 
+#ifdef FIO_HAVE_SYNC_FILE_RANGE
+static int str_sfr_cb(void *data, const char *str)
+{
+	struct thread_data *td = data;
+	char *nr = get_opt_postfix(str);
+
+	td->sync_file_range_nr = 1;
+	if (nr) {
+		td->sync_file_range_nr = atoi(nr);
+		free(nr);
+	}
+
+	return 0;
+}
+#endif
+
 static int check_dir(struct thread_data *td, char *fname)
 {
 	char file[PATH_MAX], *dir;
@@ -425,6 +510,52 @@ static int check_dir(struct thread_data *td, char *fname)
 	return 0;
 }
 
+/*
+ * Return next file in the string. Files are separated with ':'. If the ':'
+ * is escaped with a '\', then that ':' is part of the filename and does not
+ * indicate a new file.
+ */
+static char *get_next_file_name(char **ptr)
+{
+	char *str = *ptr;
+	char *p, *start;
+
+	if (!str || !strlen(str))
+		return NULL;
+
+	start = str;
+	do {
+		/*
+		 * No colon, we are done
+		 */
+		p = strchr(str, ':');
+		if (!p) {
+			*ptr = NULL;
+			break;
+		}
+
+		/*
+		 * We got a colon, but it's the first character. Skip and
+		 * continue
+		 */
+		if (p == start) {
+			str = ++start;
+			continue;
+		}
+
+		if (*(p - 1) != '\\') {
+			*p = '\0';
+			*ptr = p + 1;
+			break;
+		}
+
+		memmove(p - 1, p, strlen(p) + 1);
+		str = p;
+	} while (1);
+
+	return start;
+}
+
 static int str_filename_cb(void *data, const char *input)
 {
 	struct thread_data *td = data;
@@ -438,7 +569,7 @@ static int str_filename_cb(void *data, const char *input)
 	if (!td->files_index)
 		td->o.nr_files = 0;
 
-	while ((fname = strsep(&str, ":")) != NULL) {
+	while ((fname = get_next_file_name(&str)) != NULL) {
 		if (!strlen(fname))
 			break;
 		if (check_dir(td, fname)) {
@@ -496,22 +627,45 @@ static int str_verify_offset_cb(void *data, unsigned int *off)
 	return 0;
 }
 
-static int str_verify_pattern_cb(void *data, unsigned int *off)
+static int str_verify_pattern_cb(void *data, const char *input)
 {
 	struct thread_data *td = data;
-	unsigned int msb;
-
-	msb = __fls(*off);
-	if (msb <= 8)
-		td->o.verify_pattern_bytes = 1;
-	else if (msb <= 16)
-		td->o.verify_pattern_bytes = 2;
-	else if (msb <= 24)
-		td->o.verify_pattern_bytes = 3;
-	else
-		td->o.verify_pattern_bytes = 4;
-
-	td->o.verify_pattern = *off;
+	long off;
+	int i = 0, j = 0, len, k, base = 10;
+	char* loc1, * loc2;
+
+	loc1 = strstr(input, "0x");
+	loc2 = strstr(input, "0X");
+	if (loc1 || loc2)
+		base = 16;
+	off = strtol(input, NULL, base);
+	if (off != LONG_MAX || errno != ERANGE) {
+		while (off) {
+			td->o.verify_pattern[i] = off & 0xff;
+			off >>= 8;
+			i++;
+		}
+	} else {
+		len = strlen(input);
+		k = len - 1;
+		if (base == 16) {
+			if (loc1)
+				j = loc1 - input + 2;
+			else
+				j = loc2 - input + 2;
+		} else
+			return 1;
+		if (len - j < MAX_PATTERN_SIZE * 2) {
+			while (k >= j) {
+				off = converthexchartoint(input[k--]);
+				if (k >= j)
+					off += (converthexchartoint(input[k--])
+						* 16);
+				td->o.verify_pattern[i++] = (char) off;
+			}
+		}
+	}
+	td->o.verify_pattern_bytes = i;
 	return 0;
 }
 
@@ -556,6 +710,7 @@ static int str_gtod_reduce_cb(void *data, int *il)
 	struct thread_data *td = data;
 	int val = *il;
 
+	td->o.disable_lat = !!val;
 	td->o.disable_clat = !!val;
 	td->o.disable_slat = !!val;
 	td->o.disable_bw = !!val;
@@ -588,11 +743,11 @@ static int rw_verify(struct fio_option *o, void *data)
 	return 0;
 }
 
-static int gtod_cpu_rw_verify(struct fio_option *o, void *data)
+static int gtod_cpu_verify(struct fio_option *o, void *data)
 {
+#ifndef FIO_HAVE_CPU_AFFINITY
 	struct thread_data *td = data;
 
-#ifndef FIO_HAVE_CPU_AFFINITY
 	if (td->o.gtod_cpu) {
 		log_err("fio: platform must support CPU affinity for"
 			"gettimeofday() offloading\n");
@@ -603,13 +758,26 @@ static int gtod_cpu_rw_verify(struct fio_option *o, void *data)
 	return 0;
 }
 
+static int kb_base_verify(struct fio_option *o, void *data)
+{
+	struct thread_data *td = data;
+
+	if (td->o.kb_base != 1024 && td->o.kb_base != 1000) {
+		log_err("fio: kb_base set to nonsensical value: %u\n",
+				td->o.kb_base);
+		return 1;
+	}
+
+	return 0;
+}
+
 #define __stringify_1(x)	#x
 #define __stringify(x)		__stringify_1(x)
 
 /*
  * Map of job/command line options
  */
-static struct fio_option options[] = {
+static struct fio_option options[FIO_MAX_OPTS] = {
 	{
 		.name	= "description",
 		.type	= FIO_OPT_STR_STORE,
@@ -637,6 +805,15 @@ static struct fio_option options[] = {
 		.prio	= -1, /* must come after "directory" */
 		.help	= "File(s) to use for the workload",
 	},
+	{
+		.name	= "kb_base",
+		.type	= FIO_OPT_INT,
+		.off1	= td_var_offset(kb_base),
+		.verify	= kb_base_verify,
+		.prio	= 1,
+		.def	= "1024",
+		.help	= "How many bytes per KB for reporting (1000 or 1024)",
+	},
 	{
 		.name	= "lockfile",
 		.type	= FIO_OPT_STR,
@@ -946,6 +1123,15 @@ static struct fio_option options[] = {
 		},
 		.parent = "nrfiles",
 	},
+#ifdef FIO_HAVE_FALLOCATE
+	{
+		.name	= "fallocate",
+		.type	= FIO_OPT_BOOL,
+		.off1	= td_var_offset(fallocate),
+		.help	= "Use fallocate() when laying out files",
+		.def	= "1",
+	},
+#endif
 	{
 		.name	= "fadvise_hint",
 		.type	= FIO_OPT_BOOL,
@@ -967,6 +1153,33 @@ static struct fio_option options[] = {
 		.help	= "Issue fdatasync for writes every given number of blocks",
 		.def	= "0",
 	},
+#ifdef FIO_HAVE_SYNC_FILE_RANGE
+	{
+		.name	= "sync_file_range",
+		.posval	= {
+			  { .ival = "wait_before",
+			    .oval = SYNC_FILE_RANGE_WAIT_BEFORE,
+			    .help = "SYNC_FILE_RANGE_WAIT_BEFORE",
+			    .or	  = 1,
+			  },
+			  { .ival = "write",
+			    .oval = SYNC_FILE_RANGE_WRITE,
+			    .help = "SYNC_FILE_RANGE_WRITE",
+			    .or	  = 1,
+			  },
+			  {
+			    .ival = "wait_after",
+			    .oval = SYNC_FILE_RANGE_WAIT_AFTER,
+			    .help = "SYNC_FILE_RANGE_WAIT_AFTER",
+			    .or	  = 1,
+			  },
+		},
+		.type	= FIO_OPT_STR_MULTI,
+		.cb	= str_sfr_cb,
+		.off1	= td_var_offset(sync_file_range),
+		.help	= "Use sync_file_range()",
+	},
+#endif
 	{
 		.name	= "direct",
 		.type	= FIO_OPT_BOOL,
@@ -1005,7 +1218,7 @@ static struct fio_option options[] = {
 	},
 	{
 		.name	= "startdelay",
-		.type	= FIO_OPT_INT,
+		.type	= FIO_OPT_STR_VAL_TIME,
 		.off1	= td_var_offset(start_delay),
 		.help	= "Only start job when this period has passed",
 		.def	= "0",
@@ -1030,6 +1243,29 @@ static struct fio_option options[] = {
 		.off1	= td_var_offset(ramp_time),
 		.help	= "Ramp up time before measuring performance",
 	},
+	{
+		.name	= "clocksource",
+		.type	= FIO_OPT_STR,
+		.cb	= fio_clock_source_cb,
+		.off1	= td_var_offset(clocksource),
+		.help	= "What type of timing source to use",
+		.posval	= {
+			  { .ival = "gettimeofday",
+			    .oval = CS_GTOD,
+			    .help = "Use gettimeofday(2) for timing",
+			  },
+			  { .ival = "clock_gettime",
+			    .oval = CS_CGETTIME,
+			    .help = "Use clock_gettime(2) for timing",
+			  },
+#ifdef ARCH_HAVE_CPU_CLOCK
+			  { .ival = "cpu",
+			    .oval = CS_CPUCLOCK,
+			    .help = "Use CPU private clock",
+			  },
+#endif
+		},
+	},
 	{
 		.name	= "mem",
 		.alias	= "iomem",
@@ -1080,6 +1316,7 @@ static struct fio_option options[] = {
 		.type	= FIO_OPT_STR,
 		.off1	= td_var_offset(verify),
 		.help	= "Verify data written",
+		.cb	= str_verify_cb,
 		.def	= "0",
 		.posval = {
 			  { .ival = "0",
@@ -1114,6 +1351,10 @@ static struct fio_option options[] = {
 			    .oval = VERIFY_CRC7,
 			    .help = "Use crc7 checksums for verification",
 			  },
+			  { .ival = "sha1",
+			    .oval = VERIFY_SHA1,
+			    .help = "Use sha1 checksums for verification",
+			  },
 			  { .ival = "sha256",
 			    .oval = VERIFY_SHA256,
 			    .help = "Use sha256 checksums for verification",
@@ -1167,7 +1408,7 @@ static struct fio_option options[] = {
 	},
 	{
 		.name	= "verify_pattern",
-		.type	= FIO_OPT_INT,
+		.type	= FIO_OPT_STR,
 		.cb	= str_verify_pattern_cb,
 		.help	= "Fill pattern for IO buffers",
 		.parent	= "verify",
@@ -1180,6 +1421,37 @@ static struct fio_option options[] = {
 		.help	= "Exit on a single verify failure, don't continue",
 		.parent = "verify",
 	},
+	{
+		.name	= "verify_async",
+		.type	= FIO_OPT_INT,
+		.off1	= td_var_offset(verify_async),
+		.def	= "0",
+		.help	= "Number of async verifier threads to use",
+		.parent	= "verify",
+	},
+	{
+		.name	= "verify_backlog",
+		.type	= FIO_OPT_STR_VAL,
+		.off1	= td_var_offset(verify_backlog),
+		.help	= "Verify after this number of blocks are written",
+		.parent	= "verify",
+	},
+	{
+		.name	= "verify_backlog_batch",
+		.type	= FIO_OPT_INT,
+		.off1	= td_var_offset(verify_batch),
+		.help	= "Verify this number of IO blocks",
+		.parent	= "verify_backlog",
+	},
+#ifdef FIO_HAVE_CPU_AFFINITY
+	{
+		.name	= "verify_async_cpus",
+		.type	= FIO_OPT_STR,
+		.cb	= str_verify_cpus_allowed_cb,
+		.help	= "Set CPUs allowed for async verify threads",
+		.parent	= "verify_async",
+	},
+#endif
 	{
 		.name	= "write_iolog",
 		.type	= FIO_OPT_STR_STORE,
@@ -1385,7 +1657,7 @@ static struct fio_option options[] = {
 		.help	= "Create files when they are opened for IO",
 		.def	= "0",
 	},
- 	{
+	{
 		.name	= "pre_read",
 		.type	= FIO_OPT_BOOL,
 		.off1	= td_var_offset(pre_read),
@@ -1520,6 +1792,14 @@ static struct fio_option options[] = {
 		.cb	= str_gtod_reduce_cb,
 		.def	= "0",
 	},
+	{
+		.name	= "disable_lat",
+		.type	= FIO_OPT_BOOL,
+		.off1	= td_var_offset(disable_lat),
+		.help	= "Disable latency numbers",
+		.parent	= "gtod_reduce",
+		.def	= "0",
+	},
 	{
 		.name	= "disable_clat",
 		.type	= FIO_OPT_BOOL,
@@ -1558,11 +1838,61 @@ static struct fio_option options[] = {
 		.help	= "Continue on non-fatal errors during I/O",
 		.def	= "0",
 	},
+	{
+		.name	= "profile",
+		.type	= FIO_OPT_STR_STORE,
+		.off1	= td_var_offset(profile),
+		.help	= "Select a specific builtin performance test",
+	},
+	{
+		.name	= "cgroup",
+		.type	= FIO_OPT_STR_STORE,
+		.off1	= td_var_offset(cgroup),
+		.help	= "Add job to cgroup of this name",
+	},
+	{
+		.name	= "cgroup_weight",
+		.type	= FIO_OPT_INT,
+		.off1	= td_var_offset(cgroup_weight),
+		.help	= "Use given weight for cgroup",
+		.minval = 100,
+		.maxval	= 1000,
+	},
+	{
+		.name	= "cgroup_nodelete",
+		.type	= FIO_OPT_BOOL,
+		.off1	= td_var_offset(cgroup_nodelete),
+		.help	= "Do not delete cgroups after job completion",
+		.def	= "0",
+	},
+	{
+		.name	= "uid",
+		.type	= FIO_OPT_INT,
+		.off1	= td_var_offset(uid),
+		.help	= "Run job with this user ID",
+	},
+	{
+		.name	= "gid",
+		.type	= FIO_OPT_INT,
+		.off1	= td_var_offset(gid),
+		.help	= "Run job with this group ID",
+	},
 	{
 		.name = NULL,
 	},
 };
 
+static void add_to_lopt(struct option *lopt, struct fio_option *o,
+			const char *name)
+{
+	lopt->name = (char *) name;
+	lopt->val = FIO_GETOPT_JOB;
+	if (o->type == FIO_OPT_STR_SET)
+		lopt->has_arg = no_argument;
+	else
+		lopt->has_arg = required_argument;
+}
+
 void fio_options_dup_and_init(struct option *long_options)
 {
 	struct fio_option *o;
@@ -1576,12 +1906,11 @@ void fio_options_dup_and_init(struct option *long_options)
 
 	o = &options[0];
 	while (o->name) {
-		long_options[i].name = (char *) o->name;
-		long_options[i].val = FIO_GETOPT_JOB;
-		if (o->type == FIO_OPT_STR_SET)
-			long_options[i].has_arg = no_argument;
-		else
-			long_options[i].has_arg = required_argument;
+		add_to_lopt(&long_options[i], o, o->name);
+		if (o->alias) {
+			i++;
+			add_to_lopt(&long_options[i], o, o->alias);
+		}
 
 		i++;
 		o++;
@@ -1589,14 +1918,162 @@ void fio_options_dup_and_init(struct option *long_options)
 	}
 }
 
+struct fio_keyword {
+	const char *word;
+	const char *desc;
+	char *replace;
+};
+
+static struct fio_keyword fio_keywords[] = {
+	{
+		.word	= "$pagesize",
+		.desc	= "Page size in the system",
+	},
+	{
+		.word	= "$mb_memory",
+		.desc	= "Megabytes of memory online",
+	},
+	{
+		.word	= "$ncpus",
+		.desc	= "Number of CPUs online in the system",
+	},
+	{
+		.word	= NULL,
+	},
+};
+
+void fio_keywords_init(void)
+{
+	unsigned long long mb_memory;
+	char buf[128];
+	long l;
+
+	sprintf(buf, "%lu", page_size);
+	fio_keywords[0].replace = strdup(buf);
+
+	mb_memory = os_phys_mem() / page_size;
+	sprintf(buf, "%llu", mb_memory);
+	fio_keywords[1].replace = strdup(buf);
+
+	l = sysconf(_SC_NPROCESSORS_ONLN);
+	sprintf(buf, "%lu", l);
+	fio_keywords[2].replace = strdup(buf);
+}
+
+#define BC_APP		"bc"
+
+static char *bc_calc(char *str)
+{
+	char *buf, *tmp, opt[80];
+	FILE *f;
+	int ret;
+
+	/*
+	 * No math, just return string
+	 */
+	if (!strchr(str, '+') && !strchr(str, '-') && !strchr(str, '*') &&
+	    !strchr(str, '/'))
+		return str;
+
+	/*
+	 * Split option from value, we only need to calculate the value
+	 */
+	tmp = strchr(str, '=');
+	if (!tmp)
+		return str;
+
+	tmp++;
+	memset(opt, 0, sizeof(opt));
+	strncpy(opt, str, tmp - str);
+
+	buf = malloc(128);
+
+	sprintf(buf, "which %s > /dev/null", BC_APP);
+	if (system(buf)) {
+		log_err("fio: bc is needed for performing math\n");
+		free(buf);
+		return NULL;
+	}
+
+	sprintf(buf, "echo %s | %s", tmp, BC_APP);
+	f = popen(buf, "r");
+	if (!f) {
+		free(buf);
+		return NULL;
+	}
+
+	ret = fread(buf, 1, 128, f);
+	if (ret <= 0) {
+		free(buf);
+		return NULL;
+	}
+
+	buf[ret - 1] = '\0';
+	strcat(opt, buf);
+	strcpy(buf, opt);
+	pclose(f);
+	free(str);
+	return buf;
+}
+
+/*
+ * Look for reserved variable names and replace them with real values
+ */
+static char *fio_keyword_replace(char *opt)
+{
+	char *s;
+	int i;
+
+	for (i = 0; fio_keywords[i].word != NULL; i++) {
+		struct fio_keyword *kw = &fio_keywords[i];
+
+		while ((s = strstr(opt, kw->word)) != NULL) {
+			char *new = malloc(strlen(opt) + 1);
+			char *o_org = opt;
+			int olen = s - opt;
+			int len;
+
+			/*
+			 * Copy part of the string before the keyword and
+			 * sprintf() the replacement after it.
+			 */
+			memcpy(new, opt, olen);
+			len = sprintf(new + olen, "%s", kw->replace);
+
+			/*
+			 * If there's more in the original string, copy that
+			 * in too
+			 */
+			opt += strlen(kw->word) + olen;
+			if (strlen(opt))
+				memcpy(new + olen + len, opt, opt - o_org - 1);
+
+			/*
+			 * replace opt and free the old opt
+			 */
+			opt = new;
+			//free(o_org);
+
+			/*
+			 * Check for potential math and invoke bc, if possible
+			 */
+			opt = bc_calc(opt);
+		}
+	}
+
+	return opt;
+}
+
 int fio_options_parse(struct thread_data *td, char **opts, int num_opts)
 {
 	int i, ret;
 
 	sort_options(opts, options, num_opts);
 
-	for (ret = 0, i = 0; i < num_opts; i++)
+	for (ret = 0, i = 0; i < num_opts; i++) {
+		opts[i] = fio_keyword_replace(opts[i]);
 		ret |= parse_option(opts[i], options, td);
+	}
 
 	return ret;
 }
@@ -1653,3 +2130,84 @@ void options_mem_free(struct thread_data fio_unused *td)
 	__options_mem(td, 0);
 #endif
 }
+
+unsigned int fio_get_kb_base(void *data)
+{
+	struct thread_data *td = data;
+	unsigned int kb_base = 0;
+
+	if (td)
+		kb_base = td->o.kb_base;
+	if (!kb_base)
+		kb_base = 1024;
+
+	return kb_base;
+}
+
+int add_option(struct fio_option *o)
+{
+	struct fio_option *__o;
+	int opt_index = 0;
+
+	__o = options;
+	while (__o->name) {
+		opt_index++;
+		__o++;
+	}
+
+	memcpy(&options[opt_index], o, sizeof(*o));
+	return 0;
+}
+
+void invalidate_profile_options(const char *prof_name)
+{
+	struct fio_option *o;
+
+	o = options;
+	while (o->name) {
+		if (o->prof_name && !strcmp(o->prof_name, prof_name)) {
+			o->type = FIO_OPT_INVALID;
+			o->prof_name = NULL;
+		}
+		o++;
+	}
+}
+
+void add_opt_posval(const char *optname, const char *ival, const char *help)
+{
+	struct fio_option *o;
+	unsigned int i;
+
+	o = find_option(options, optname);
+	if (!o)
+		return;
+
+	for (i = 0; i < PARSE_MAX_VP; i++) {
+		if (o->posval[i].ival)
+			continue;
+
+		o->posval[i].ival = ival;
+		o->posval[i].help = help;
+		break;
+	}
+}
+
+void del_opt_posval(const char *optname, const char *ival)
+{
+	struct fio_option *o;
+	unsigned int i;
+
+	o = find_option(options, optname);
+	if (!o)
+		return;
+
+	for (i = 0; i < PARSE_MAX_VP; i++) {
+		if (!o->posval[i].ival)
+			continue;
+		if (strcmp(o->posval[i].ival, ival))
+			continue;
+
+		o->posval[i].ival = NULL;
+		o->posval[i].help = NULL;
+	}
+}