X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=options.c;h=87515ef13313da1d0cd0c2282306e75e6cf011ed;hp=5b4e3938d5765711a36c2845e1b6f7eb8bc14c70;hb=e0ae4dfde29797aa33141100205cea3b2dc8f034;hpb=bac39e0e8807a1d52863ad8304e67221df2bc63b;ds=sidebyside

diff --git a/options.c b/options.c
index 5b4e3938..87515ef1 100644
--- a/options.c
+++ b/options.c
@@ -11,6 +11,7 @@
 #include <sys/stat.h>
 
 #include "fio.h"
+#include "verify.h"
 #include "parse.h"
 #include "lib/fls.h"
 
@@ -40,21 +41,16 @@ static int bs_cmp(const void *p1, const void *p2)
 	return bsp1->perc < bsp2->perc;
 }
 
-static int str_bssplit_cb(void *data, const char *input)
+static int bssplit_ddir(struct thread_data *td, int ddir, char *str)
 {
-	struct thread_data *td = data;
-	char *fname, *str, *p;
+	struct bssplit *bssplit;
 	unsigned int i, perc, perc_missing;
 	unsigned int max_bs, min_bs;
 	long long val;
+	char *fname;
 
-	p = str = strdup(input);
-
-	strip_blank_front(&str);
-	strip_blank_end(str);
-
-	td->o.bssplit_nr = 4;
-	td->o.bssplit = malloc(4 * sizeof(struct bssplit));
+	td->o.bssplit_nr[ddir] = 4;
+	bssplit = malloc(4 * sizeof(struct bssplit));
 
 	i = 0;
 	max_bs = 0;
@@ -68,10 +64,9 @@ static int str_bssplit_cb(void *data, const char *input)
 		/*
 		 * grow struct buffer, if needed
 		 */
-		if (i == td->o.bssplit_nr) {
-			td->o.bssplit_nr <<= 1;
-			td->o.bssplit = realloc(td->o.bssplit,
-						td->o.bssplit_nr
+		if (i == td->o.bssplit_nr[ddir]) {
+			td->o.bssplit_nr[ddir] <<= 1;
+			bssplit = realloc(bssplit, td->o.bssplit_nr[ddir]
 						  * sizeof(struct bssplit));
 		}
 
@@ -98,19 +93,19 @@ static int str_bssplit_cb(void *data, const char *input)
 		if (val < min_bs)
 			min_bs = val;
 
-		td->o.bssplit[i].bs = val;
-		td->o.bssplit[i].perc = perc;
+		bssplit[i].bs = val;
+		bssplit[i].perc = perc;
 		i++;
 	}
 
-	td->o.bssplit_nr = i;
+	td->o.bssplit_nr[ddir] = i;
 
 	/*
 	 * Now check if the percentages add up, and how much is missing
 	 */
 	perc = perc_missing = 0;
-	for (i = 0; i < td->o.bssplit_nr; i++) {
-		struct bssplit *bsp = &td->o.bssplit[i];
+	for (i = 0; i < td->o.bssplit_nr[ddir]; i++) {
+		struct bssplit *bsp = &bssplit[i];
 
 		if (bsp->perc == (unsigned char) -1)
 			perc_missing++;
@@ -120,7 +115,7 @@ static int str_bssplit_cb(void *data, const char *input)
 
 	if (perc > 100) {
 		log_err("fio: bssplit percentages add to more than 100%%\n");
-		free(td->o.bssplit);
+		free(bssplit);
 		return 1;
 	}
 	/*
@@ -128,24 +123,58 @@ static int str_bssplit_cb(void *data, const char *input)
 	 * them.
 	 */
 	if (perc_missing) {
-		for (i = 0; i < td->o.bssplit_nr; i++) {
-			struct bssplit *bsp = &td->o.bssplit[i];
+		for (i = 0; i < td->o.bssplit_nr[ddir]; i++) {
+			struct bssplit *bsp = &bssplit[i];
 
 			if (bsp->perc == (unsigned char) -1)
 				bsp->perc = (100 - perc) / perc_missing;
 		}
 	}
 
-	td->o.min_bs[DDIR_READ] = td->o.min_bs[DDIR_WRITE] = min_bs;
-	td->o.max_bs[DDIR_READ] = td->o.max_bs[DDIR_WRITE] = max_bs;
+	td->o.min_bs[ddir] = min_bs;
+	td->o.max_bs[ddir] = max_bs;
 
 	/*
 	 * now sort based on percentages, for ease of lookup
 	 */
-	qsort(td->o.bssplit, td->o.bssplit_nr, sizeof(struct bssplit), bs_cmp);
+	qsort(bssplit, td->o.bssplit_nr[ddir], sizeof(struct bssplit), bs_cmp);
+	td->o.bssplit[ddir] = bssplit;
+	return 0;
+
+}
+
+static int str_bssplit_cb(void *data, const char *input)
+{
+	struct thread_data *td = data;
+	char *str, *p, *odir;
+	int ret = 0;
+
+	p = str = strdup(input);
+
+	strip_blank_front(&str);
+	strip_blank_end(str);
+
+	odir = strchr(str, ',');
+	if (odir) {
+		ret = bssplit_ddir(td, DDIR_WRITE, odir + 1);
+		if (!ret) {
+			*odir = '\0';
+			ret = bssplit_ddir(td, DDIR_READ, str);
+		}
+	} else {
+		char *op;
+
+		op = strdup(str);
+
+		ret = bssplit_ddir(td, DDIR_READ, str);
+		if (!ret)
+			ret = bssplit_ddir(td, DDIR_WRITE, op);
+
+		free(op);
+	}
 
 	free(p);
-	return 0;
+	return ret;
 }
 
 static int str_rw_cb(void *data, const char *str)
@@ -154,8 +183,10 @@ static int str_rw_cb(void *data, const char *str)
 	char *nr = get_opt_postfix(str);
 
 	td->o.ddir_nr = 1;
-	if (nr)
+	if (nr) {
 		td->o.ddir_nr = atoi(nr);
+		free(nr);
+	}
 
 	return 0;
 }
@@ -244,12 +275,29 @@ static int str_cpumask_cb(void *data, unsigned int *val)
 {
 	struct thread_data *td = data;
 	unsigned int i;
+	long max_cpu;
+	int ret;
 
-	CPU_ZERO(&td->o.cpumask);
+	ret = fio_cpuset_init(&td->o.cpumask);
+	if (ret < 0) {
+		log_err("fio: cpuset_init failed\n");
+		td_verror(td, ret, "fio_cpuset_init");
+		return 1;
+	}
+
+	max_cpu = sysconf(_SC_NPROCESSORS_ONLN);
 
-	for (i = 0; i < sizeof(int) * 8; i++)
-		if ((1 << i) & *val)
-			CPU_SET(*val, &td->o.cpumask);
+	for (i = 0; i < sizeof(int) * 8; i++) {
+		if ((1 << i) & *val) {
+			if (i > max_cpu) {
+				log_err("fio: CPU %d too large (max=%ld)\n", i,
+								max_cpu);
+				return 1;
+			}
+			dprint(FD_PARSE, "set cpu allowed %d\n", i);
+			fio_cpu_set(&td->o.cpumask, i);
+		}
+	}
 
 	td->o.cpumask_set = 1;
 	return 0;
@@ -259,23 +307,68 @@ static int str_cpus_allowed_cb(void *data, const char *input)
 {
 	struct thread_data *td = data;
 	char *cpu, *str, *p;
+	long max_cpu;
+	int ret = 0;
 
-	CPU_ZERO(&td->o.cpumask);
+	ret = fio_cpuset_init(&td->o.cpumask);
+	if (ret < 0) {
+		log_err("fio: cpuset_init failed\n");
+		td_verror(td, ret, "fio_cpuset_init");
+		return 1;
+	}
 
 	p = str = strdup(input);
 
 	strip_blank_front(&str);
 	strip_blank_end(str);
 
+	max_cpu = sysconf(_SC_NPROCESSORS_ONLN);
+
 	while ((cpu = strsep(&str, ",")) != NULL) {
+		char *str2, *cpu2;
+		int icpu, icpu2;
+
 		if (!strlen(cpu))
 			break;
-		CPU_SET(atoi(cpu), &td->o.cpumask);
+
+		str2 = cpu;
+		icpu2 = -1;
+		while ((cpu2 = strsep(&str2, "-")) != NULL) {
+			if (!strlen(cpu2))
+				break;
+
+			icpu2 = atoi(cpu2);
+		}
+
+		icpu = atoi(cpu);
+		if (icpu2 == -1)
+			icpu2 = icpu;
+		while (icpu <= icpu2) {
+			if (icpu >= FIO_MAX_CPUS) {
+				log_err("fio: your OS only supports up to"
+					" %d CPUs\n", (int) FIO_MAX_CPUS);
+				ret = 1;
+				break;
+			}
+			if (icpu > max_cpu) {
+				log_err("fio: CPU %d too large (max=%ld)\n",
+							icpu, max_cpu);
+				ret = 1;
+				break;
+			}
+	
+			dprint(FD_PARSE, "set cpu allowed %d\n", icpu);
+			fio_cpu_set(&td->o.cpumask, icpu);
+			icpu++;
+		}
+		if (ret)
+			break;
 	}
 
 	free(p);
-	td->o.cpumask_set = 1;
-	return 0;
+	if (!ret)
+		td->o.cpumask_set = 1;
+	return ret;
 }
 #endif
 
@@ -285,8 +378,10 @@ static int str_fst_cb(void *data, const char *str)
 	char *nr = get_opt_postfix(str);
 
 	td->file_service_nr = 1;
-	if (nr)
+	if (nr) {
 		td->file_service_nr = atoi(nr);
+		free(nr);
+	}
 
 	return 0;
 }
@@ -426,8 +521,84 @@ static int str_lockfile_cb(void *data, const char *str)
 	char *nr = get_opt_postfix(str);
 
 	td->o.lockfile_batch = 1;
-	if (nr)
+	if (nr) {
 		td->o.lockfile_batch = atoi(nr);
+		free(nr);
+	}
+
+	return 0;
+}
+
+static int str_write_bw_log_cb(void *data, const char *str)
+{
+	struct thread_data *td = data;
+
+	if (str)
+		td->o.bw_log_file = strdup(str);
+
+	td->o.write_bw_log = 1;
+	return 0;
+}
+
+static int str_write_lat_log_cb(void *data, const char *str)
+{
+	struct thread_data *td = data;
+
+	if (str)
+		td->o.lat_log_file = strdup(str);
+
+	td->o.write_lat_log = 1;
+	return 0;
+}
+
+static int str_gtod_reduce_cb(void *data, int *il)
+{
+	struct thread_data *td = data;
+	int val = *il;
+
+	td->o.disable_clat = !!val;
+	td->o.disable_slat = !!val;
+	td->o.disable_bw = !!val;
+	if (val)
+		td->tv_cache_mask = 63;
+
+	return 0;
+}
+
+static int str_gtod_cpu_cb(void *data, int *il)
+{
+	struct thread_data *td = data;
+	int val = *il;
+
+	td->o.gtod_cpu = val;
+	td->o.gtod_offload = 1;
+	return 0;
+}
+
+static int rw_verify(struct fio_option *o, void *data)
+{
+	struct thread_data *td = data;
+
+	if (read_only && td_write(td)) {
+		log_err("fio: job <%s> has write bit set, but fio is in"
+			" read-only mode\n", td->o.name);
+		return 1;
+	}
+
+	return 0;
+}
+
+static int gtod_cpu_verify(struct fio_option *o, void *data)
+{
+#ifndef FIO_HAVE_CPU_AFFINITY
+	struct thread_data *td = data;
+
+	if (td->o.gtod_cpu) {
+		log_err("fio: platform must support CPU affinity for"
+			"gettimeofday() offloading\n");
+		return 1;
+	}
+#endif
 
 	return 0;
 }
@@ -463,7 +634,7 @@ static struct fio_option options[] = {
 		.type	= FIO_OPT_STR_STORE,
 		.off1	= td_var_offset(filename),
 		.cb	= str_filename_cb,
-		.prio	= 1, /* must come before "directory" */
+		.prio	= -1, /* must come after "directory" */
 		.help	= "File(s) to use for the workload",
 	},
 	{
@@ -505,6 +676,7 @@ static struct fio_option options[] = {
 		.off1	= td_var_offset(td_ddir),
 		.help	= "IO direction",
 		.def	= "read",
+		.verify	= rw_verify,
 		.posval = {
 			  { .ival = "read",
 			    .oval = TD_DDIR_READ,
@@ -616,7 +788,7 @@ static struct fio_option options[] = {
 		.alias	= "iodepth_batch_submit",
 		.type	= FIO_OPT_INT,
 		.off1	= td_var_offset(iodepth_batch),
-		.help	= "Number of IO to submit in one go",
+		.help	= "Number of IO buffers to submit in one go",
 		.parent	= "iodepth",
 		.minval	= 1,
 		.def	= "1",
@@ -625,7 +797,7 @@ static struct fio_option options[] = {
 		.name	= "iodepth_batch_complete",
 		.type	= FIO_OPT_INT,
 		.off1	= td_var_offset(iodepth_batch_complete),
-		.help	= "Number of IO to retrieve in one go",
+		.help	= "Number of IO buffers to retrieve in one go",
 		.parent	= "iodepth",
 		.minval	= 0,
 		.def	= "1",
@@ -670,7 +842,7 @@ static struct fio_option options[] = {
 	{
 		.name	= "bs",
 		.alias	= "blocksize",
-		.type	= FIO_OPT_STR_VAL_INT,
+		.type	= FIO_OPT_INT,
 		.off1	= td_var_offset(bs[DDIR_READ]),
 		.off2	= td_var_offset(bs[DDIR_WRITE]),
 		.minval = 1,
@@ -678,6 +850,16 @@ static struct fio_option options[] = {
 		.def	= "4k",
 		.parent = "rw",
 	},
+	{
+		.name	= "ba",
+		.alias	= "blockalign",
+		.type	= FIO_OPT_INT,
+		.off1	= td_var_offset(ba[DDIR_READ]),
+		.off2	= td_var_offset(ba[DDIR_WRITE]),
+		.minval	= 1,
+		.help	= "IO block offset alignment",
+		.parent	= "rw",
+	},
 	{
 		.name	= "bsrange",
 		.alias	= "blocksize_range",
@@ -757,6 +939,10 @@ static struct fio_option options[] = {
 			    .oval = FIO_FSERVICE_RR,
 			    .help = "Round robin select files",
 			  },
+			  { .ival = "sequential",
+			    .oval = FIO_FSERVICE_SEQ,
+			    .help = "Finish one file before moving to the next",
+			  },
 		},
 		.parent = "nrfiles",
 	},
@@ -774,6 +960,13 @@ static struct fio_option options[] = {
 		.help	= "Issue fsync for writes every given number of blocks",
 		.def	= "0",
 	},
+	{
+		.name	= "fdatasync",
+		.type	= FIO_OPT_INT,
+		.off1	= td_var_offset(fdatasync_blocks),
+		.help	= "Issue fdatasync for writes every given number of blocks",
+		.def	= "0",
+	},
 	{
 		.name	= "direct",
 		.type	= FIO_OPT_BOOL,
@@ -831,6 +1024,12 @@ static struct fio_option options[] = {
 		.off1	= td_var_offset(time_based),
 		.help	= "Keep running until runtime/timeout is met",
 	},
+	{
+		.name	= "ramp_time",
+		.type	= FIO_OPT_STR_VAL_TIME,
+		.off1	= td_var_offset(ramp_time),
+		.help	= "Ramp up time before measuring performance",
+	},
 	{
 		.name	= "mem",
 		.alias	= "iomem",
@@ -866,6 +1065,16 @@ static struct fio_option options[] = {
 #endif
 		  },
 	},
+	{
+		.name	= "iomem_align",
+		.alias	= "mem_align",
+		.type	= FIO_OPT_INT,
+		.off1	= td_var_offset(mem_align),
+		.minval	= 0,
+		.help	= "IO memory buffer offset alignment",
+		.def	= "0",
+		.parent	= "iomem",
+	},
 	{
 		.name	= "verify",
 		.type	= FIO_OPT_STR,
@@ -889,6 +1098,10 @@ static struct fio_option options[] = {
 			    .oval = VERIFY_CRC32,
 			    .help = "Use crc32 checksums for verification",
 			  },
+			  { .ival = "crc32c-intel",
+			    .oval = VERIFY_CRC32C_INTEL,
+			    .help = "Use hw crc32c checksums for verification",
+			  },
 			  { .ival = "crc32c",
 			    .oval = VERIFY_CRC32C,
 			    .help = "Use crc32c checksums for verification",
@@ -938,7 +1151,7 @@ static struct fio_option options[] = {
 	},
 	{
 		.name   = "verify_interval",
-		.type   = FIO_OPT_STR_VAL_INT,
+		.type   = FIO_OPT_INT,
 		.off1   = td_var_offset(verify_interval),
 		.minval	= 2 * sizeof(struct verify_header),
 		.help   = "Store verify buffer header every N bytes",
@@ -946,7 +1159,7 @@ static struct fio_option options[] = {
 	},
 	{
 		.name	= "verify_offset",
-		.type	= FIO_OPT_STR_VAL_INT,
+		.type	= FIO_OPT_INT,
 		.help	= "Offset verify header location by N bytes",
 		.def	= "0",
 		.cb	= str_verify_offset_cb,
@@ -1093,26 +1306,30 @@ static struct fio_option options[] = {
 	{
 		.name	= "rate",
 		.type	= FIO_OPT_INT,
-		.off1	= td_var_offset(rate),
+		.off1	= td_var_offset(rate[0]),
+		.off2	= td_var_offset(rate[1]),
 		.help	= "Set bandwidth rate",
 	},
 	{
 		.name	= "ratemin",
 		.type	= FIO_OPT_INT,
-		.off1	= td_var_offset(ratemin),
+		.off1	= td_var_offset(ratemin[0]),
+		.off2	= td_var_offset(ratemin[1]),
 		.help	= "Job must meet this rate or it will be shutdown",
 		.parent	= "rate",
 	},
 	{
 		.name	= "rate_iops",
 		.type	= FIO_OPT_INT,
-		.off1	= td_var_offset(rate_iops),
+		.off1	= td_var_offset(rate_iops[0]),
+		.off2	= td_var_offset(rate_iops[1]),
 		.help	= "Limit IO used to this number of IO operations/sec",
 	},
 	{
 		.name	= "rate_iops_min",
 		.type	= FIO_OPT_INT,
-		.off1	= td_var_offset(rate_iops_min),
+		.off1	= td_var_offset(rate_iops_min[0]),
+		.off2	= td_var_offset(rate_iops_min[1]),
 		.help	= "Job must meet this rate or it will be shutdown",
 		.parent	= "rate_iops",
 	},
@@ -1161,6 +1378,20 @@ static struct fio_option options[] = {
 		.help	= "Fsync file after creation",
 		.def	= "1",
 	},
+	{
+		.name	= "create_on_open",
+		.type	= FIO_OPT_BOOL,
+		.off1	= td_var_offset(create_on_open),
+		.help	= "Create files when they are opened for IO",
+		.def	= "0",
+	},
+ 	{
+		.name	= "pre_read",
+		.type	= FIO_OPT_BOOL,
+		.off1	= td_var_offset(pre_read),
+		.help	= "Preread files before starting official testing",
+		.def	= "0",
+	},
 	{
 		.name	= "cpuload",
 		.type	= FIO_OPT_INT,
@@ -1236,19 +1467,21 @@ static struct fio_option options[] = {
 	},
 	{
 		.name	= "write_bw_log",
-		.type	= FIO_OPT_STR_SET,
+		.type	= FIO_OPT_STR,
 		.off1	= td_var_offset(write_bw_log),
+		.cb	= str_write_bw_log_cb,
 		.help	= "Write log of bandwidth during run",
 	},
 	{
 		.name	= "write_lat_log",
-		.type	= FIO_OPT_STR_SET,
+		.type	= FIO_OPT_STR,
 		.off1	= td_var_offset(write_lat_log),
+		.cb	= str_write_lat_log_cb,
 		.help	= "Write log of latency during run",
 	},
 	{
 		.name	= "hugepage-size",
-		.type	= FIO_OPT_STR_VAL_INT,
+		.type	= FIO_OPT_INT,
 		.off1	= td_var_offset(hugepage_size),
 		.help	= "When using hugepages, specify size of each page",
 		.def	= __stringify(FIO_HUGE_PAGE),
@@ -1280,6 +1513,51 @@ static struct fio_option options[] = {
 		.def	= "1",
 	},
 #endif
+	{
+		.name	= "gtod_reduce",
+		.type	= FIO_OPT_BOOL,
+		.help	= "Greatly reduce number of gettimeofday() calls",
+		.cb	= str_gtod_reduce_cb,
+		.def	= "0",
+	},
+	{
+		.name	= "disable_clat",
+		.type	= FIO_OPT_BOOL,
+		.off1	= td_var_offset(disable_clat),
+		.help	= "Disable completion latency numbers",
+		.parent	= "gtod_reduce",
+		.def	= "0",
+	},
+	{
+		.name	= "disable_slat",
+		.type	= FIO_OPT_BOOL,
+		.off1	= td_var_offset(disable_slat),
+		.help	= "Disable submissionn latency numbers",
+		.parent	= "gtod_reduce",
+		.def	= "0",
+	},
+	{
+		.name	= "disable_bw_measurement",
+		.type	= FIO_OPT_BOOL,
+		.off1	= td_var_offset(disable_bw),
+		.help	= "Disable bandwidth logging",
+		.parent	= "gtod_reduce",
+		.def	= "0",
+	},
+	{
+		.name	= "gtod_cpu",
+		.type	= FIO_OPT_INT,
+		.cb	= str_gtod_cpu_cb,
+		.help	= "Setup dedicated gettimeofday() thread on this CPU",
+		.verify	= gtod_cpu_verify,
+	},
+	{
+		.name	= "continue_on_error",
+		.type	= FIO_OPT_BOOL,
+		.off1	= td_var_offset(continue_on_error),
+		.help	= "Continue on non-fatal errors during I/O",
+		.def	= "0",
+	},
 	{
 		.name = NULL,
 	},