X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=options.c;h=f5cab6558c8d636411f4055370019d47dedb619b;hp=88b9142e809271f9d95b2e0f660e99f26ebf6806;hb=b7f487cf80a8299a656df9c2214ff73e72956d71;hpb=a01a1bc58d096dd593fa458f99f3c6f423c4b69a

diff --git a/options.c b/options.c
index 88b9142e..f5cab655 100644
--- a/options.c
+++ b/options.c
@@ -37,7 +37,7 @@ static int converthexchartoint(char a)
 {
 	int base;
 
-	switch(a) {
+	switch (a) {
 	case '0'...'9':
 		base = '0';
 		break;
@@ -50,7 +50,7 @@ static int converthexchartoint(char a)
 	default:
 		base = 0;
 	}
-	return (a - base);
+	return a - base;
 }
 
 static int bs_cmp(const void *p1, const void *p2)
@@ -61,7 +61,7 @@ static int bs_cmp(const void *p1, const void *p2)
 	return bsp1->perc < bsp2->perc;
 }
 
-static int bssplit_ddir(struct thread_data *td, int ddir, char *str)
+static int bssplit_ddir(struct thread_options *o, int ddir, char *str)
 {
 	struct bssplit *bssplit;
 	unsigned int i, perc, perc_missing;
@@ -69,7 +69,7 @@ static int bssplit_ddir(struct thread_data *td, int ddir, char *str)
 	long long val;
 	char *fname;
 
-	td->o.bssplit_nr[ddir] = 4;
+	o->bssplit_nr[ddir] = 4;
 	bssplit = malloc(4 * sizeof(struct bssplit));
 
 	i = 0;
@@ -84,9 +84,9 @@ static int bssplit_ddir(struct thread_data *td, int ddir, char *str)
 		/*
 		 * grow struct buffer, if needed
 		 */
-		if (i == td->o.bssplit_nr[ddir]) {
-			td->o.bssplit_nr[ddir] <<= 1;
-			bssplit = realloc(bssplit, td->o.bssplit_nr[ddir]
+		if (i == o->bssplit_nr[ddir]) {
+			o->bssplit_nr[ddir] <<= 1;
+			bssplit = realloc(bssplit, o->bssplit_nr[ddir]
 						  * sizeof(struct bssplit));
 		}
 
@@ -102,9 +102,9 @@ static int bssplit_ddir(struct thread_data *td, int ddir, char *str)
 		} else
 			perc = -1;
 
-		if (str_to_decimal(fname, &val, 1, td)) {
+		if (str_to_decimal(fname, &val, 1, o)) {
 			log_err("fio: bssplit conversion failed\n");
-			free(td->o.bssplit);
+			free(o->bssplit);
 			return 1;
 		}
 
@@ -118,13 +118,13 @@ static int bssplit_ddir(struct thread_data *td, int ddir, char *str)
 		i++;
 	}
 
-	td->o.bssplit_nr[ddir] = i;
+	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[ddir]; i++) {
+	for (i = 0; i < o->bssplit_nr[ddir]; i++) {
 		struct bssplit *bsp = &bssplit[i];
 
 		if (bsp->perc == (unsigned char) -1)
@@ -143,7 +143,7 @@ static int bssplit_ddir(struct thread_data *td, int ddir, char *str)
 	 * them.
 	 */
 	if (perc_missing) {
-		for (i = 0; i < td->o.bssplit_nr[ddir]; i++) {
+		for (i = 0; i < o->bssplit_nr[ddir]; i++) {
 			struct bssplit *bsp = &bssplit[i];
 
 			if (bsp->perc == (unsigned char) -1)
@@ -151,21 +151,21 @@ static int bssplit_ddir(struct thread_data *td, int ddir, char *str)
 		}
 	}
 
-	td->o.min_bs[ddir] = min_bs;
-	td->o.max_bs[ddir] = max_bs;
+	o->min_bs[ddir] = min_bs;
+	o->max_bs[ddir] = max_bs;
 
 	/*
 	 * now sort based on percentages, for ease of lookup
 	 */
-	qsort(bssplit, td->o.bssplit_nr[ddir], sizeof(struct bssplit), bs_cmp);
-	td->o.bssplit[ddir] = bssplit;
+	qsort(bssplit, o->bssplit_nr[ddir], sizeof(struct bssplit), bs_cmp);
+	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;
+	char *str, *p, *odir, *ddir;
 	int ret = 0;
 
 	p = str = strdup(input);
@@ -175,50 +175,163 @@ static int str_bssplit_cb(void *data, const char *input)
 
 	odir = strchr(str, ',');
 	if (odir) {
-		ret = bssplit_ddir(td, DDIR_WRITE, odir + 1);
+		ddir = strchr(odir + 1, ',');
+		if (ddir) {
+			ret = bssplit_ddir(&td->o, DDIR_TRIM, ddir + 1);
+			if (!ret)
+				*ddir = '\0';
+		} else {
+			char *op;
+
+			op = strdup(odir + 1);
+			ret = bssplit_ddir(&td->o, DDIR_TRIM, op);
+
+			free(op);
+		}
+		if (!ret)
+			ret = bssplit_ddir(&td->o, DDIR_WRITE, odir + 1);
 		if (!ret) {
 			*odir = '\0';
-			ret = bssplit_ddir(td, DDIR_READ, str);
+			ret = bssplit_ddir(&td->o, 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);
-
+		ret = bssplit_ddir(&td->o, DDIR_WRITE, op);
 		free(op);
+
+		if (!ret) {
+			op = strdup(str);
+			ret = bssplit_ddir(&td->o, DDIR_TRIM, op);
+			free(op);
+		}
+		ret = bssplit_ddir(&td->o, DDIR_READ, str);
 	}
 
 	free(p);
 	return ret;
 }
 
+static int str2error(char *str)
+{
+	const char *err[] = { "EPERM", "ENOENT", "ESRCH", "EINTR", "EIO",
+			    "ENXIO", "E2BIG", "ENOEXEC", "EBADF",
+			    "ECHILD", "EAGAIN", "ENOMEM", "EACCES",
+			    "EFAULT", "ENOTBLK", "EBUSY", "EEXIST",
+			    "EXDEV", "ENODEV", "ENOTDIR", "EISDIR",
+			    "EINVAL", "ENFILE", "EMFILE", "ENOTTY",
+			    "ETXTBSY","EFBIG", "ENOSPC", "ESPIPE",
+			    "EROFS","EMLINK", "EPIPE", "EDOM", "ERANGE" };
+	int i = 0, num = sizeof(err) / sizeof(void *);
+
+	while (i < num) {
+		if (!strcmp(err[i], str))
+			return i + 1;
+		i++;
+	}
+	return 0;
+}
+
+static int ignore_error_type(struct thread_data *td, int etype, char *str)
+{
+	unsigned int i;
+	int *error;
+	char *fname;
+
+	if (etype >= ERROR_TYPE_CNT) {
+		log_err("Illegal error type\n");
+		return 1;
+	}
+
+	td->o.ignore_error_nr[etype] = 4;
+	error = malloc(4 * sizeof(struct bssplit));
+
+	i = 0;
+	while ((fname = strsep(&str, ":")) != NULL) {
+
+		if (!strlen(fname))
+			break;
+
+		/*
+		 * grow struct buffer, if needed
+		 */
+		if (i == td->o.ignore_error_nr[etype]) {
+			td->o.ignore_error_nr[etype] <<= 1;
+			error = realloc(error, td->o.ignore_error_nr[etype]
+						  * sizeof(int));
+		}
+		if (fname[0] == 'E') {
+			error[i] = str2error(fname);
+		} else {
+			error[i] = atoi(fname);
+			if (error[i] < 0)
+				error[i] = error[i];
+		}
+		if (!error[i]) {
+			log_err("Unknown error %s, please use number value \n",
+				  fname);
+			return 1;
+		}
+		i++;
+	}
+	if (i) {
+		td->o.continue_on_error |= 1 << etype;
+		td->o.ignore_error_nr[etype] = i;
+		td->o.ignore_error[etype] = error;
+	}
+	return 0;
+
+}
+
+static int str_ignore_error_cb(void *data, const char *input)
+{
+	struct thread_data *td = data;
+	char *str, *p, *n;
+	int type = 0, ret = 1;
+	p = str = strdup(input);
+
+	strip_blank_front(&str);
+	strip_blank_end(str);
+
+	while (p) {
+		n = strchr(p, ',');
+		if (n)
+			*n++ = '\0';
+		ret = ignore_error_type(td, type, p);
+		if (ret)
+			break;
+		p = n;
+		type++;
+	}
+	free(str);
+	return ret;
+}
+
 static int str_rw_cb(void *data, const char *str)
 {
 	struct thread_data *td = data;
+	struct thread_options *o = &td->o;
 	char *nr = get_opt_postfix(str);
 
-	td->o.ddir_seq_nr = 1;
-	td->o.ddir_seq_add = 0;
+	o->ddir_seq_nr = 1;
+	o->ddir_seq_add = 0;
 
 	if (!nr)
 		return 0;
 
 	if (td_random(td))
-		td->o.ddir_seq_nr = atoi(nr);
+		o->ddir_seq_nr = atoi(nr);
 	else {
 		long long val;
 
-		if (str_to_decimal(nr, &val, 1, td)) {
+		if (str_to_decimal(nr, &val, 1, o)) {
 			log_err("fio: rw postfix parsing failed\n");
 			free(nr);
 			return 1;
 		}
 
-		td->o.ddir_seq_add = val;
+		o->ddir_seq_add = val;
 	}
 
 	free(nr);
@@ -229,25 +342,8 @@ static int str_mem_cb(void *data, const char *mem)
 {
 	struct thread_data *td = data;
 
-	if (td->o.mem_type == MEM_MMAPHUGE || td->o.mem_type == MEM_MMAP) {
-		td->mmapfile = get_opt_postfix(mem);
-		if (td->o.mem_type == MEM_MMAPHUGE && !td->mmapfile) {
-			log_err("fio: mmaphuge:/path/to/file\n");
-			return 1;
-		}
-	}
-
-	return 0;
-}
-
-static int str_verify_cb(void *data, const char *mem)
-{
-	struct thread_data *td = data;
-
-	if (td->o.verify == VERIFY_CRC32C_INTEL ||
-	    td->o.verify == VERIFY_CRC32C) {
-		crc32c_intel_probe();
-	}
+	if (td->o.mem_type == MEM_MMAPHUGE || td->o.mem_type == MEM_MMAP)
+		td->o.mmapfile = get_opt_postfix(mem);
 
 	return 0;
 }
@@ -257,13 +353,8 @@ 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 long *val)
-{
-	mlock_size = *val;
+	fio_clock_source_set = 1;
+	fio_clock_init();
 	return 0;
 }
 
@@ -285,40 +376,6 @@ static int str_rwmix_write_cb(void *data, unsigned long long *val)
 	return 0;
 }
 
-#ifdef FIO_HAVE_IOPRIO
-static int str_prioclass_cb(void *data, unsigned long long *val)
-{
-	struct thread_data *td = data;
-	unsigned short mask;
-
-	/*
-	 * mask off old class bits, str_prio_cb() may have set a default class
-	 */
-	mask = (1 << IOPRIO_CLASS_SHIFT) - 1;
-	td->ioprio &= mask;
-
-	td->ioprio |= *val << IOPRIO_CLASS_SHIFT;
-	td->ioprio_set = 1;
-	return 0;
-}
-
-static int str_prio_cb(void *data, unsigned long long *val)
-{
-	struct thread_data *td = data;
-
-	td->ioprio |= *val;
-
-	/*
-	 * If no class is set, assume BE
-	 */
-	if ((td->ioprio >> IOPRIO_CLASS_SHIFT) == 0)
-		td->ioprio |= IOPRIO_CLASS_BE << IOPRIO_CLASS_SHIFT;
-
-	td->ioprio_set = 1;
-	return 0;
-}
-#endif
-
 static int str_exitall_cb(void)
 {
 	exitall_on_terminate = 1;
@@ -451,14 +508,128 @@ static int str_verify_cpus_allowed_cb(void *data, const char *input)
 }
 #endif
 
-#ifdef FIO_HAVE_TRIM
-static int str_verify_trim_cb(void *data, unsigned long long *val)
+#ifdef CONFIG_LIBNUMA
+static int str_numa_cpunodes_cb(void *data, char *input)
 {
 	struct thread_data *td = data;
 
-	td->o.trim_percentage = *val;
+	/* numa_parse_nodestring() parses a character string list
+	 * of nodes into a bit mask. The bit mask is allocated by
+	 * numa_allocate_nodemask(), so it should be freed by
+	 * numa_free_nodemask().
+	 */
+	td->o.numa_cpunodesmask = numa_parse_nodestring(input);
+	if (td->o.numa_cpunodesmask == NULL) {
+		log_err("fio: numa_parse_nodestring failed\n");
+		td_verror(td, 1, "str_numa_cpunodes_cb");
+		return 1;
+	}
+
+	td->o.numa_cpumask_set = 1;
 	return 0;
 }
+
+static int str_numa_mpol_cb(void *data, char *input)
+{
+	struct thread_data *td = data;
+	const char * const policy_types[] =
+		{ "default", "prefer", "bind", "interleave", "local" };
+	int i;
+
+	char *nodelist = strchr(input, ':');
+	if (nodelist) {
+		/* NUL-terminate mode */
+		*nodelist++ = '\0';
+	}
+
+	for (i = 0; i <= MPOL_LOCAL; i++) {
+		if (!strcmp(input, policy_types[i])) {
+			td->o.numa_mem_mode = i;
+			break;
+		}
+	}
+	if (i > MPOL_LOCAL) {
+		log_err("fio: memory policy should be: default, prefer, bind, interleave, local\n");
+		goto out;
+	}
+
+	switch (td->o.numa_mem_mode) {
+	case MPOL_PREFERRED:
+		/*
+		 * Insist on a nodelist of one node only
+		 */
+		if (nodelist) {
+			char *rest = nodelist;
+			while (isdigit(*rest))
+				rest++;
+			if (*rest) {
+				log_err("fio: one node only for \'prefer\'\n");
+				goto out;
+			}
+		} else {
+			log_err("fio: one node is needed for \'prefer\'\n");
+			goto out;
+		}
+		break;
+	case MPOL_INTERLEAVE:
+		/*
+		 * Default to online nodes with memory if no nodelist
+		 */
+		if (!nodelist)
+			nodelist = strdup("all");
+		break;
+	case MPOL_LOCAL:
+	case MPOL_DEFAULT:
+		/*
+		 * Don't allow a nodelist
+		 */
+		if (nodelist) {
+			log_err("fio: NO nodelist for \'local\'\n");
+			goto out;
+		}
+		break;
+	case MPOL_BIND:
+		/*
+		 * Insist on a nodelist
+		 */
+		if (!nodelist) {
+			log_err("fio: a nodelist is needed for \'bind\'\n");
+			goto out;
+		}
+		break;
+	}
+
+
+	/* numa_parse_nodestring() parses a character string list
+	 * of nodes into a bit mask. The bit mask is allocated by
+	 * numa_allocate_nodemask(), so it should be freed by
+	 * numa_free_nodemask().
+	 */
+	switch (td->o.numa_mem_mode) {
+	case MPOL_PREFERRED:
+		td->o.numa_mem_prefer_node = atoi(nodelist);
+		break;
+	case MPOL_INTERLEAVE:
+	case MPOL_BIND:
+		td->o.numa_memnodesmask = numa_parse_nodestring(nodelist);
+		if (td->o.numa_memnodesmask == NULL) {
+			log_err("fio: numa_parse_nodestring failed\n");
+			td_verror(td, 1, "str_numa_memnodes_cb");
+			return 1;
+		}
+		break;
+	case MPOL_LOCAL:
+	case MPOL_DEFAULT:
+	default:
+		break;
+	}
+
+	td->o.numa_memmask_set = 1;
+	return 0;
+
+out:
+	return 1;
+}
 #endif
 
 static int str_fst_cb(void *data, const char *str)
@@ -475,7 +646,7 @@ static int str_fst_cb(void *data, const char *str)
 	return 0;
 }
 
-#ifdef FIO_HAVE_SYNC_FILE_RANGE
+#ifdef CONFIG_SYNC_FILE_RANGE
 static int str_sfr_cb(void *data, const char *str)
 {
 	struct thread_data *td = data;
@@ -491,41 +662,41 @@ static int str_sfr_cb(void *data, const char *str)
 }
 #endif
 
-static int check_dir(struct thread_data *td, char *fname)
+static int str_random_distribution_cb(void *data, const char *str)
 {
-#if 0
-	char file[PATH_MAX], *dir;
-	int elen = 0;
-
-	if (td->o.directory) {
-		strcpy(file, td->o.directory);
-		strcat(file, "/");
-		elen = strlen(file);
-	}
-
-	sprintf(file + elen, "%s", fname);
-	dir = dirname(file);
+	struct thread_data *td = data;
+	double val;
+	char *nr;
 
-	{
-	struct stat sb;
-	/*
-	 * We can't do this on FIO_DISKLESSIO engines. The engine isn't loaded
-	 * yet, so we can't do this check right here...
-	 */
-	if (lstat(dir, &sb) < 0) {
-		int ret = errno;
+	if (td->o.random_distribution == FIO_RAND_DIST_ZIPF)
+		val = 1.1;
+	else if (td->o.random_distribution == FIO_RAND_DIST_PARETO)
+		val = 0.2;
+	else
+		return 0;
 
-		log_err("fio: %s is not a directory\n", dir);
-		td_verror(td, ret, "lstat");
+	nr = get_opt_postfix(str);
+	if (nr && !str_to_float(nr, &val)) {
+		log_err("fio: random postfix parsing failed\n");
+		free(nr);
 		return 1;
 	}
 
-	if (!S_ISDIR(sb.st_mode)) {
-		log_err("fio: %s is not a directory\n", dir);
-		return 1;
-	}
+	free(nr);
+
+	if (td->o.random_distribution == FIO_RAND_DIST_ZIPF) {
+		if (val == 1.00) {
+			log_err("fio: zipf theta must different than 1.0\n");
+			return 1;
+		}
+		td->o.zipf_theta.u.f = val;
+	} else {
+		if (val <= 0.00 || val >= 1.00) {
+			log_err("fio: pareto input out of range (0 < input < 1.0)\n");
+			return 1;
+		}
+		td->o.pareto_h.u.f = val;
 	}
-#endif
 
 	return 0;
 }
@@ -592,10 +763,6 @@ static int str_filename_cb(void *data, const char *input)
 	while ((fname = get_next_file_name(&str)) != NULL) {
 		if (!strlen(fname))
 			break;
-		if (check_dir(td, fname)) {
-			free(p);
-			return 1;
-		}
 		add_file(td, fname);
 		td->o.nr_files++;
 	}
@@ -634,25 +801,12 @@ static int str_opendir_cb(void *data, const char fio_unused *str)
 	return add_dir_files(td, td->o.opendir);
 }
 
-static int str_verify_offset_cb(void *data, unsigned long long *off)
-{
-	struct thread_data *td = data;
-
-	if (*off && *off < sizeof(struct verify_header)) {
-		log_err("fio: verify_offset too small\n");
-		return 1;
-	}
-
-	td->o.verify_offset = *off;
-	return 0;
-}
-
 static int str_verify_pattern_cb(void *data, const char *input)
 {
 	struct thread_data *td = data;
 	long off;
 	int i = 0, j = 0, len, k, base = 10;
-	char* loc1, * loc2;
+	char *loc1, *loc2;
 
 	loc1 = strstr(input, "0x");
 	loc2 = strstr(input, "0X");
@@ -714,53 +868,6 @@ static int str_verify_pattern_cb(void *data, const char *input)
 	return 0;
 }
 
-static int str_lockfile_cb(void *data, const char *str)
-{
-	struct thread_data *td = data;
-	char *nr = get_opt_postfix(str);
-
-	td->o.lockfile_batch = 1;
-	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_write_iops_log_cb(void *data, const char *str)
-{
-	struct thread_data *td = data;
-
-	if (str)
-		td->o.iops_log_file = strdup(str);
-
-	td->o.write_iops_log = 1;
-	return 0;
-}
-
 static int str_gtod_reduce_cb(void *data, int *il)
 {
 	struct thread_data *td = data;
@@ -829,19 +936,6 @@ static int gtod_cpu_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;
-}
-
 /*
  * Option grouping
  */
@@ -866,6 +960,10 @@ static struct opt_group fio_opt_groups[] = {
 		.name	= "Logging",
 		.mask	= FIO_OPT_C_LOG,
 	},
+	{
+		.name	= "Profiles",
+		.mask	= FIO_OPT_C_PROFILE,
+	},
 	{
 		.name	= NULL,
 	},
@@ -962,6 +1060,27 @@ static struct opt_group fio_opt_cat_groups[] = {
 		.name	= "Clock settings",
 		.mask	= FIO_OPT_G_CLOCK,
 	},
+	{
+		.name	= "I/O Type",
+		.mask	= FIO_OPT_G_IO_TYPE,
+	},
+	{
+		.name	= "I/O Thinktime",
+		.mask	= FIO_OPT_G_THINKTIME,
+	},
+	{
+		.name	= "Randomizations",
+		.mask	= FIO_OPT_G_RANDOM,
+	},
+	{
+		.name	= "I/O buffers",
+		.mask	= FIO_OPT_G_IO_BUF,
+	},
+	{
+		.name	= "Tiobench profile",
+		.mask	= FIO_OPT_G_TIOBENCH,
+	},
+
 	{
 		.name	= NULL,
 	}
@@ -1015,11 +1134,20 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.category = FIO_OPT_C_FILE,
 		.group	= FIO_OPT_G_FILENAME,
 	},
+	{
+		.name	= "filename_format",
+		.type	= FIO_OPT_STR_STORE,
+		.off1	= td_var_offset(filename_format),
+		.prio	= -1, /* must come after "directory" */
+		.help	= "Override default $jobname.$jobnum.$filenum naming",
+		.def	= "$jobname.$jobnum.$filenum",
+		.category = FIO_OPT_C_FILE,
+		.group	= FIO_OPT_G_FILENAME,
+	},
 	{
 		.name	= "lockfile",
 		.lname	= "Lockfile",
 		.type	= FIO_OPT_STR,
-		.cb	= str_lockfile_cb,
 		.off1	= td_var_offset(file_lock_mode),
 		.help	= "Lock file when doing IO to it",
 		.parent	= "filename",
@@ -1074,6 +1202,10 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 			    .oval = TD_DDIR_WRITE,
 			    .help = "Sequential write",
 			  },
+			  { .ival = "trim",
+			    .oval = TD_DDIR_TRIM,
+			    .help = "Sequential trim",
+			  },
 			  { .ival = "randread",
 			    .oval = TD_DDIR_RANDREAD,
 			    .help = "Random read",
@@ -1082,10 +1214,18 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 			    .oval = TD_DDIR_RANDWRITE,
 			    .help = "Random write",
 			  },
+			  { .ival = "randtrim",
+			    .oval = TD_DDIR_RANDTRIM,
+			    .help = "Random trim",
+			  },
 			  { .ival = "rw",
 			    .oval = TD_DDIR_RW,
 			    .help = "Sequential read and write mix",
 			  },
+			  { .ival = "readwrite",
+			    .oval = TD_DDIR_RW,
+			    .help = "Sequential read and write mix",
+			  },
 			  { .ival = "randrw",
 			    .oval = TD_DDIR_RANDRW,
 			    .help = "Random read and write mix"
@@ -1132,22 +1272,22 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 			  { .ival = "vsync",
 			    .help = "Use readv/writev",
 			  },
-#ifdef FIO_HAVE_LIBAIO
+#ifdef CONFIG_LIBAIO
 			  { .ival = "libaio",
 			    .help = "Linux native asynchronous IO",
 			  },
 #endif
-#ifdef FIO_HAVE_POSIXAIO
+#ifdef CONFIG_POSIXAIO
 			  { .ival = "posixaio",
 			    .help = "POSIX asynchronous IO",
 			  },
 #endif
-#ifdef FIO_HAVE_SOLARISAIO
+#ifdef CONFIG_SOLARISAIO
 			  { .ival = "solarisaio",
 			    .help = "Solaris native asynchronous IO",
 			  },
 #endif
-#ifdef FIO_HAVE_WINDOWSAIO
+#ifdef CONFIG_WINDOWSAIO
 			  { .ival = "windowsaio",
 			    .help = "Windows native asynchronous IO"
 			  },
@@ -1155,7 +1295,7 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 			  { .ival = "mmap",
 			    .help = "Memory mapped IO"
 			  },
-#ifdef FIO_HAVE_SPLICE
+#ifdef CONFIG_LINUX_SPLICE
 			  { .ival = "splice",
 			    .help = "splice/vmsplice based IO",
 			  },
@@ -1174,15 +1314,10 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 			  { .ival = "net",
 			    .help = "Network IO",
 			  },
-#ifdef FIO_HAVE_SYSLET
-			  { .ival = "syslet-rw",
-			    .help = "syslet enabled async pread/pwrite IO",
-			  },
-#endif
 			  { .ival = "cpuio",
 			    .help = "CPU cycle burner engine",
 			  },
-#ifdef FIO_HAVE_GUASI
+#ifdef CONFIG_GUASI
 			  { .ival = "guasi",
 			    .help = "GUASI IO engine",
 			  },
@@ -1192,10 +1327,25 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 			    .help = "binject direct inject block engine",
 			  },
 #endif
-#ifdef FIO_HAVE_RDMA
+#ifdef CONFIG_RDMA
 			  { .ival = "rdma",
 			    .help = "RDMA IO engine",
 			  },
+#endif
+#ifdef CONFIG_FUSION_AW
+			  { .ival = "fusion-aw-sync",
+			    .help = "Fusion-io atomic write engine",
+			  },
+#endif
+#ifdef CONFIG_LINUX_EXT4_MOVE_EXTENT
+			  { .ival = "e4defrag",
+			    .help = "ext4 defrag engine",
+			  },
+#endif
+#ifdef CONFIG_LINUX_FALLOCATE
+			  { .ival = "falloc",
+			    .help = "fallocate() file based engine",
+			  },
 #endif
 			  { .ival = "external",
 			    .help = "Load external engine (append name)",
@@ -1320,6 +1470,7 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.type	= FIO_OPT_INT,
 		.off1	= td_var_offset(bs[DDIR_READ]),
 		.off2	= td_var_offset(bs[DDIR_WRITE]),
+		.off3	= td_var_offset(bs[DDIR_TRIM]),
 		.minval = 1,
 		.help	= "Block size unit",
 		.def	= "4k",
@@ -1336,6 +1487,7 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.type	= FIO_OPT_INT,
 		.off1	= td_var_offset(ba[DDIR_READ]),
 		.off2	= td_var_offset(ba[DDIR_WRITE]),
+		.off3	= td_var_offset(ba[DDIR_TRIM]),
 		.minval	= 1,
 		.help	= "IO block offset alignment",
 		.parent	= "rw",
@@ -1353,6 +1505,8 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.off2	= td_var_offset(max_bs[DDIR_READ]),
 		.off3	= td_var_offset(min_bs[DDIR_WRITE]),
 		.off4	= td_var_offset(max_bs[DDIR_WRITE]),
+		.off5	= td_var_offset(min_bs[DDIR_TRIM]),
+		.off6	= td_var_offset(max_bs[DDIR_TRIM]),
 		.minval = 1,
 		.help	= "Set block size range (in more detail than bs)",
 		.parent = "rw",
@@ -1394,7 +1548,7 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.parent = "rw",
 		.hide	= 1,
 		.category = FIO_OPT_C_IO,
-		.group	= FIO_OPT_G_INVALID,
+		.group	= FIO_OPT_G_RANDOM,
 	},
 	{
 		.name	= "use_os_rand",
@@ -1406,7 +1560,7 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.parent = "rw",
 		.hide	= 1,
 		.category = FIO_OPT_C_IO,
-		.group	= FIO_OPT_G_INVALID,
+		.group	= FIO_OPT_G_RANDOM,
 	},
 	{
 		.name	= "norandommap",
@@ -1416,8 +1570,9 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.help	= "Accept potential duplicate random blocks",
 		.parent = "rw",
 		.hide	= 1,
+		.hide_on_set = 1,
 		.category = FIO_OPT_C_IO,
-		.group	= FIO_OPT_G_INVALID,
+		.group	= FIO_OPT_G_RANDOM,
 	},
 	{
 		.name	= "softrandommap",
@@ -1429,7 +1584,50 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.hide	= 1,
 		.def	= "0",
 		.category = FIO_OPT_C_IO,
-		.group	= FIO_OPT_G_INVALID,
+		.group	= FIO_OPT_G_RANDOM,
+	},
+	{
+		.name	= "random_generator",
+		.type	= FIO_OPT_STR,
+		.off1	= td_var_offset(random_generator),
+		.help	= "Type of random number generator to use",
+		.def	= "tausworthe",
+		.posval	= {
+			  { .ival = "tausworthe",
+			    .oval = FIO_RAND_GEN_TAUSWORTHE,
+			    .help = "Strong Tausworthe generator",
+			  },
+			  { .ival = "lfsr",
+			    .oval = FIO_RAND_GEN_LFSR,
+			    .help = "Variable length LFSR",
+			  },
+		},
+		.category = FIO_OPT_C_IO,
+		.group	= FIO_OPT_G_RANDOM,
+	},
+	{
+		.name	= "random_distribution",
+		.type	= FIO_OPT_STR,
+		.off1	= td_var_offset(random_distribution),
+		.cb	= str_random_distribution_cb,
+		.help	= "Random offset distribution generator",
+		.def	= "random",
+		.posval	= {
+			  { .ival = "random",
+			    .oval = FIO_RAND_DIST_RANDOM,
+			    .help = "Completely random",
+			  },
+			  { .ival = "zipf",
+			    .oval = FIO_RAND_DIST_ZIPF,
+			    .help = "Zipf distribution",
+			  },
+			  { .ival = "pareto",
+			    .oval = FIO_RAND_DIST_PARETO,
+			    .help = "Pareto distribution",
+			  },
+		},
+		.category = FIO_OPT_C_IO,
+		.group	= FIO_OPT_G_RANDOM,
 	},
 	{
 		.name	= "nrfiles",
@@ -1479,7 +1677,7 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.parent = "nrfiles",
 		.hide	= 1,
 	},
-#ifdef FIO_HAVE_FALLOCATE
+#ifdef CONFIG_POSIX_FALLOCATE
 	{
 		.name	= "fallocate",
 		.lname	= "Fallocate",
@@ -1498,7 +1696,7 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 			    .oval = FIO_FALLOCATE_POSIX,
 			    .help = "Use posix_fallocate()",
 			  },
-#ifdef FIO_HAVE_LINUX_FALLOCATE
+#ifdef CONFIG_LINUX_FALLOCATE
 			  { .ival = "keep",
 			    .oval = FIO_FALLOCATE_KEEP_SIZE,
 			    .help = "Use fallocate(..., FALLOC_FL_KEEP_SIZE, ...)",
@@ -1515,7 +1713,7 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 			  },
 		},
 	},
-#endif	/* FIO_HAVE_FALLOCATE */
+#endif	/* CONFIG_POSIX_FALLOCATE */
 	{
 		.name	= "fadvise_hint",
 		.lname	= "Fadvise hint",
@@ -1559,7 +1757,7 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.category = FIO_OPT_C_IO,
 		.group	= FIO_OPT_G_INVALID,
 	},
-#ifdef FIO_HAVE_SYNC_FILE_RANGE
+#ifdef CONFIG_SYNC_FILE_RANGE
 	{
 		.name	= "sync_file_range",
 		.lname	= "Sync file range",
@@ -1598,7 +1796,7 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.def	= "0",
 		.inverse = "buffered",
 		.category = FIO_OPT_C_IO,
-		.group	= FIO_OPT_G_INVALID,
+		.group	= FIO_OPT_G_IO_TYPE,
 	},
 	{
 		.name	= "buffered",
@@ -1610,7 +1808,7 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.def	= "1",
 		.inverse = "direct",
 		.category = FIO_OPT_C_IO,
-		.group	= FIO_OPT_G_INVALID,
+		.group	= FIO_OPT_G_IO_TYPE,
 	},
 	{
 		.name	= "overwrite",
@@ -1693,14 +1891,18 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.category = FIO_OPT_C_GENERAL,
 		.group	= FIO_OPT_G_CLOCK,
 		.posval	= {
+#ifdef CONFIG_GETTIMEOFDAY
 			  { .ival = "gettimeofday",
 			    .oval = CS_GTOD,
 			    .help = "Use gettimeofday(2) for timing",
 			  },
+#endif
+#ifdef CONFIG_CLOCK_GETTIME
 			  { .ival = "clock_gettime",
 			    .oval = CS_CGETTIME,
 			    .help = "Use clock_gettime(2) for timing",
 			  },
+#endif
 #ifdef ARCH_HAVE_CPU_CLOCK
 			  { .ival = "cpu",
 			    .oval = CS_CPUCLOCK,
@@ -1767,10 +1969,9 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.type	= FIO_OPT_STR,
 		.off1	= td_var_offset(verify),
 		.help	= "Verify data written",
-		.cb	= str_verify_cb,
 		.def	= "0",
 		.category = FIO_OPT_C_IO,
-		.group	= FIO_OPT_G_INVALID,
+		.group	= FIO_OPT_G_VERIFY,
 		.posval = {
 			  { .ival = "0",
 			    .oval = VERIFY_NONE,
@@ -1851,6 +2052,18 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.category = FIO_OPT_C_IO,
 		.group	= FIO_OPT_G_VERIFY,
 	},
+	{
+		.name	= "verifysort_nr",
+		.type	= FIO_OPT_INT,
+		.off1	= td_var_offset(verifysort_nr),
+		.help	= "Pre-load and sort verify blocks for a read workload",
+		.minval	= 0,
+		.maxval	= 131072,
+		.def	= "1024",
+		.parent = "verify",
+		.category = FIO_OPT_C_IO,
+		.group	= FIO_OPT_G_VERIFY,
+	},
 	{
 		.name   = "verify_interval",
 		.lname	= "Verify interval",
@@ -1869,8 +2082,8 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.lname	= "Verify offset",
 		.type	= FIO_OPT_INT,
 		.help	= "Offset verify header location by N bytes",
-		.def	= "0",
-		.cb	= str_verify_offset_cb,
+		.off1	= td_var_offset(verify_offset),
+		.minval	= sizeof(struct verify_header),
 		.parent	= "verify",
 		.hide	= 1,
 		.category = FIO_OPT_C_IO,
@@ -1958,12 +2171,20 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.group	= FIO_OPT_G_VERIFY,
 	},
 #endif
+	{
+		.name	= "experimental_verify",
+		.off1	= td_var_offset(experimental_verify),
+		.type	= FIO_OPT_BOOL,
+		.help	= "Enable experimental verification",
+		.category = FIO_OPT_C_IO,
+		.group	= FIO_OPT_G_VERIFY,
+	},
 #ifdef FIO_HAVE_TRIM
 	{
 		.name	= "trim_percentage",
 		.lname	= "Trim percentage",
 		.type	= FIO_OPT_INT,
-		.cb	= str_verify_trim_cb,
+		.off1	= td_var_offset(trim_percentage),
 		.minval = 0,
 		.maxval = 100,
 		.help	= "Number of verify blocks to discard/trim",
@@ -2118,8 +2339,8 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.name	= "lockmem",
 		.lname	= "Lock memory",
 		.type	= FIO_OPT_STR_VAL,
-		.cb	= str_lockmem_cb,
-		.help	= "Lock down this amount of memory",
+		.off1	= td_var_offset(lockmem),
+		.help	= "Lock down this amount of memory (per worker)",
 		.def	= "0",
 		.interval = 1024 * 1024,
 		.category = FIO_OPT_C_GENERAL,
@@ -2176,7 +2397,7 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.name	= "prio",
 		.lname	= "I/O nice priority",
 		.type	= FIO_OPT_INT,
-		.cb	= str_prio_cb,
+		.off1	= td_var_offset(ioprio),
 		.help	= "Set job IO priority value",
 		.minval	= 0,
 		.maxval	= 7,
@@ -2188,7 +2409,7 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.name	= "prioclass",
 		.lname	= "I/O nice priority class",
 		.type	= FIO_OPT_INT,
-		.cb	= str_prioclass_cb,
+		.off1	= td_var_offset(ioprio_class),
 		.help	= "Set job IO priority class",
 		.minval	= 0,
 		.maxval	= 3,
@@ -2205,7 +2426,7 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.help	= "Idle time between IO buffers (usec)",
 		.def	= "0",
 		.category = FIO_OPT_C_IO,
-		.group	= FIO_OPT_G_INVALID,
+		.group	= FIO_OPT_G_THINKTIME,
 	},
 	{
 		.name	= "thinktime_spin",
@@ -2217,7 +2438,7 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.parent	= "thinktime",
 		.hide	= 1,
 		.category = FIO_OPT_C_IO,
-		.group	= FIO_OPT_G_INVALID,
+		.group	= FIO_OPT_G_THINKTIME,
 	},
 	{
 		.name	= "thinktime_blocks",
@@ -2229,14 +2450,15 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.parent	= "thinktime",
 		.hide	= 1,
 		.category = FIO_OPT_C_IO,
-		.group	= FIO_OPT_G_INVALID,
+		.group	= FIO_OPT_G_THINKTIME,
 	},
 	{
 		.name	= "rate",
 		.lname	= "I/O rate",
 		.type	= FIO_OPT_INT,
-		.off1	= td_var_offset(rate[0]),
-		.off2	= td_var_offset(rate[1]),
+		.off1	= td_var_offset(rate[DDIR_READ]),
+		.off2	= td_var_offset(rate[DDIR_WRITE]),
+		.off3	= td_var_offset(rate[DDIR_TRIM]),
 		.help	= "Set bandwidth rate",
 		.category = FIO_OPT_C_IO,
 		.group	= FIO_OPT_G_RATE,
@@ -2245,8 +2467,9 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.name	= "ratemin",
 		.lname	= "I/O min rate",
 		.type	= FIO_OPT_INT,
-		.off1	= td_var_offset(ratemin[0]),
-		.off2	= td_var_offset(ratemin[1]),
+		.off1	= td_var_offset(ratemin[DDIR_READ]),
+		.off2	= td_var_offset(ratemin[DDIR_WRITE]),
+		.off3	= td_var_offset(ratemin[DDIR_TRIM]),
 		.help	= "Job must meet this rate or it will be shutdown",
 		.parent	= "rate",
 		.hide	= 1,
@@ -2257,8 +2480,9 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.name	= "rate_iops",
 		.lname	= "I/O rate IOPS",
 		.type	= FIO_OPT_INT,
-		.off1	= td_var_offset(rate_iops[0]),
-		.off2	= td_var_offset(rate_iops[1]),
+		.off1	= td_var_offset(rate_iops[DDIR_READ]),
+		.off2	= td_var_offset(rate_iops[DDIR_WRITE]),
+		.off3	= td_var_offset(rate_iops[DDIR_TRIM]),
 		.help	= "Limit IO used to this number of IO operations/sec",
 		.hide	= 1,
 		.category = FIO_OPT_C_IO,
@@ -2268,8 +2492,9 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.name	= "rate_iops_min",
 		.lname	= "I/O min rate IOPS",
 		.type	= FIO_OPT_INT,
-		.off1	= td_var_offset(rate_iops_min[0]),
-		.off2	= td_var_offset(rate_iops_min[1]),
+		.off1	= td_var_offset(rate_iops_min[DDIR_READ]),
+		.off2	= td_var_offset(rate_iops_min[DDIR_WRITE]),
+		.off3	= td_var_offset(rate_iops_min[DDIR_TRIM]),
 		.help	= "Job must meet this rate or it will be shut down",
 		.parent	= "rate_iops",
 		.hide	= 1,
@@ -2288,6 +2513,14 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.category = FIO_OPT_C_IO,
 		.group	= FIO_OPT_G_RATE,
 	},
+	{
+		.name	= "max_latency",
+		.type	= FIO_OPT_INT,
+		.off1	= td_var_offset(max_latency),
+		.help	= "Maximum tolerated IO latency (usec)",
+		.category = FIO_OPT_C_IO,
+		.group = FIO_OPT_G_RATE,
+	},
 	{
 		.name	= "invalidate",
 		.lname	= "Cache invalidate",
@@ -2296,7 +2529,7 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.help	= "Invalidate buffer/page cache prior to running job",
 		.def	= "1",
 		.category = FIO_OPT_C_IO,
-		.group	= FIO_OPT_G_INVALID,
+		.group	= FIO_OPT_G_IO_TYPE,
 	},
 	{
 		.name	= "sync",
@@ -2308,34 +2541,7 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.parent = "buffered",
 		.hide	= 1,
 		.category = FIO_OPT_C_IO,
-		.group	= FIO_OPT_G_INVALID,
-	},
-	{
-		.name	= "bwavgtime",
-		.lname	= "Bandwidth average time",
-		.type	= FIO_OPT_INT,
-		.off1	= td_var_offset(bw_avg_time),
-		.help	= "Time window over which to calculate bandwidth"
-			  " (msec)",
-		.def	= "500",
-		.parent	= "write_bw_log",
-		.hide	= 1,
-		.interval = 100,
-		.category = FIO_OPT_C_LOG,
-		.group	= FIO_OPT_G_INVALID,
-	},
-	{
-		.name	= "iopsavgtime",
-		.lname	= "IOPS average time",
-		.type	= FIO_OPT_INT,
-		.off1	= td_var_offset(iops_avg_time),
-		.help	= "Time window over which to calculate IOPS (msec)",
-		.def	= "500",
-		.parent	= "write_iops_log",
-		.hide	= 1,
-		.interval = 100,
-		.category = FIO_OPT_C_LOG,
-		.group	= FIO_OPT_G_INVALID,
+		.group	= FIO_OPT_G_IO_TYPE,
 	},
 	{
 		.name	= "create_serialize",
@@ -2367,6 +2573,14 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.category = FIO_OPT_C_FILE,
 		.group	= FIO_OPT_G_INVALID,
 	},
+	{
+		.name	= "create_only",
+		.type	= FIO_OPT_BOOL,
+		.off1	= td_var_offset(create_only),
+		.help	= "Only perform file creation phase",
+		.category = FIO_OPT_C_FILE,
+		.def	= "0",
+	},
 	{
 		.name	= "pre_read",
 		.lname	= "Pre-read files",
@@ -2377,27 +2591,6 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.category = FIO_OPT_C_FILE,
 		.group	= FIO_OPT_G_INVALID,
 	},
-	{
-		.name	= "cpuload",
-		.lname	= "CPU load",
-		.type	= FIO_OPT_INT,
-		.off1	= td_var_offset(cpuload),
-		.help	= "Use this percentage of CPU",
-		.category = FIO_OPT_C_GENERAL,
-		.group	= FIO_OPT_G_INVALID,
-	},
-	{
-		.name	= "cpuchunks",
-		.lname	= "CPU chunk",
-		.type	= FIO_OPT_INT,
-		.off1	= td_var_offset(cpucycle),
-		.help	= "Length of the CPU burn cycles (usecs)",
-		.def	= "50000",
-		.parent = "cpuload",
-		.hide	= 1,
-		.category = FIO_OPT_C_GENERAL,
-		.group	= FIO_OPT_G_INVALID,
-	},
 #ifdef FIO_HAVE_CPU_AFFINITY
 	{
 		.name	= "cpumask",
@@ -2417,6 +2610,24 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.category = FIO_OPT_C_GENERAL,
 		.group	= FIO_OPT_G_CRED,
 	},
+#endif
+#ifdef CONFIG_LIBNUMA
+	{
+		.name	= "numa_cpu_nodes",
+		.type	= FIO_OPT_STR,
+		.cb	= str_numa_cpunodes_cb,
+		.help	= "NUMA CPU nodes bind",
+		.category = FIO_OPT_C_GENERAL,
+		.group	= FIO_OPT_G_INVALID,
+	},
+	{
+		.name	= "numa_mem_policy",
+		.type	= FIO_OPT_STR,
+		.cb	= str_numa_mpol_cb,
+		.help	= "NUMA memory policy setup",
+		.category = FIO_OPT_C_GENERAL,
+		.group	= FIO_OPT_G_INVALID,
+	},
 #endif
 	{
 		.name	= "end_fsync",
@@ -2488,9 +2699,8 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 	{
 		.name	= "write_bw_log",
 		.lname	= "Write bandwidth log",
-		.type	= FIO_OPT_STR,
-		.off1	= td_var_offset(write_bw_log),
-		.cb	= str_write_bw_log_cb,
+		.type	= FIO_OPT_STR_STORE,
+		.off1	= td_var_offset(bw_log_file),
 		.help	= "Write log of bandwidth during run",
 		.category = FIO_OPT_C_LOG,
 		.group	= FIO_OPT_G_INVALID,
@@ -2498,9 +2708,8 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 	{
 		.name	= "write_lat_log",
 		.lname	= "Write latency log",
-		.type	= FIO_OPT_STR,
-		.off1	= td_var_offset(write_lat_log),
-		.cb	= str_write_lat_log_cb,
+		.type	= FIO_OPT_STR_STORE,
+		.off1	= td_var_offset(lat_log_file),
 		.help	= "Write log of latency during run",
 		.category = FIO_OPT_C_LOG,
 		.group	= FIO_OPT_G_INVALID,
@@ -2509,8 +2718,7 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.name	= "write_iops_log",
 		.lname	= "Write IOPS log",
 		.type	= FIO_OPT_STR,
-		.off1	= td_var_offset(write_iops_log),
-		.cb	= str_write_iops_log_cb,
+		.off1	= td_var_offset(iops_log_file),
 		.help	= "Write log of IOPS during run",
 		.category = FIO_OPT_C_LOG,
 		.group	= FIO_OPT_G_INVALID,
@@ -2526,14 +2734,30 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.group	= FIO_OPT_G_INVALID,
 	},
 	{
-		.name	= "hugepage-size",
-		.lname	= "Hugepage size",
+		.name	= "bwavgtime",
+		.lname	= "Bandwidth average time",
 		.type	= FIO_OPT_INT,
-		.off1	= td_var_offset(hugepage_size),
-		.help	= "When using hugepages, specify size of each page",
-		.def	= __fio_stringify(FIO_HUGE_PAGE),
-		.interval = 1024 * 1024,
-		.category = FIO_OPT_C_GENERAL,
+		.off1	= td_var_offset(bw_avg_time),
+		.help	= "Time window over which to calculate bandwidth"
+			  " (msec)",
+		.def	= "500",
+		.parent	= "write_bw_log",
+		.hide	= 1,
+		.interval = 100,
+		.category = FIO_OPT_C_LOG,
+		.group	= FIO_OPT_G_INVALID,
+	},
+	{
+		.name	= "iopsavgtime",
+		.lname	= "IOPS average time",
+		.type	= FIO_OPT_INT,
+		.off1	= td_var_offset(iops_avg_time),
+		.help	= "Time window over which to calculate IOPS (msec)",
+		.def	= "500",
+		.parent	= "write_iops_log",
+		.hide	= 1,
+		.interval = 100,
+		.category = FIO_OPT_C_LOG,
 		.group	= FIO_OPT_G_INVALID,
 	},
 	{
@@ -2553,7 +2777,7 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.off1	= td_var_offset(zero_buffers),
 		.help	= "Init IO buffers to all zeroes",
 		.category = FIO_OPT_C_IO,
-		.group	= FIO_OPT_G_INVALID,
+		.group	= FIO_OPT_G_IO_BUF,
 	},
 	{
 		.name	= "refill_buffers",
@@ -2562,7 +2786,7 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.off1	= td_var_offset(refill_buffers),
 		.help	= "Refill IO buffers on every IO submit",
 		.category = FIO_OPT_C_IO,
-		.group	= FIO_OPT_G_INVALID,
+		.group	= FIO_OPT_G_IO_BUF,
 	},
 	{
 		.name	= "scramble_buffers",
@@ -2572,7 +2796,7 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.help	= "Slightly scramble buffers on every IO submit",
 		.def	= "1",
 		.category = FIO_OPT_C_IO,
-		.group	= FIO_OPT_G_INVALID,
+		.group	= FIO_OPT_G_IO_BUF,
 	},
 	{
 		.name	= "buffer_compress_percentage",
@@ -2584,7 +2808,7 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.help	= "How compressible the buffer is (approximately)",
 		.interval = 5,
 		.category = FIO_OPT_C_IO,
-		.group	= FIO_OPT_G_INVALID,
+		.group	= FIO_OPT_G_IO_BUF,
 	},
 	{
 		.name	= "buffer_compress_chunk",
@@ -2596,7 +2820,7 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.help	= "Size of compressible region in buffer",
 		.interval = 256,
 		.category = FIO_OPT_C_IO,
-		.group	= FIO_OPT_G_INVALID,
+		.group	= FIO_OPT_G_IO_BUF,
 	},
 	{
 		.name	= "clat_percentiles",
@@ -2613,8 +2837,9 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.lname	= "Completion latency percentile list",
 		.type	= FIO_OPT_FLOAT_LIST,
 		.off1	= td_var_offset(percentile_list),
-		.off2   = td_var_offset(overwrite_plist),
+		.off2	= td_var_offset(percentile_precision),
 		.help	= "Specify a custom list of percentiles to report",
+		.def    = "1:5:10:20:30:40:50:60:70:80:90:95:99:99.5:99.9:99.95:99.99",
 		.maxlen	= FIO_IO_U_LIST_MAX_LEN,
 		.minfp	= 0.0,
 		.maxfp	= 100.0,
@@ -2641,6 +2866,7 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.help	= "Greatly reduce number of gettimeofday() calls",
 		.cb	= str_gtod_reduce_cb,
 		.def	= "0",
+		.hide_on_set = 1,
 		.category = FIO_OPT_C_STAT,
 		.group	= FIO_OPT_G_INVALID,
 	},
@@ -2702,6 +2928,15 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.category = FIO_OPT_C_GENERAL,
 		.group	= FIO_OPT_G_CLOCK,
 	},
+	{
+		.name	= "unified_rw_reporting",
+		.type	= FIO_OPT_BOOL,
+		.off1	= td_var_offset(unified_rw_rep),
+		.help	= "Unify reporting across data direction",
+		.def	= "0",
+		.category = FIO_OPT_C_GENERAL,
+		.group	= FIO_OPT_G_INVALID,
+	},
 	{
 		.name	= "continue_on_error",
 		.lname	= "Continue on error",
@@ -2710,7 +2945,7 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.help	= "Continue on non-fatal errors during IO",
 		.def	= "none",
 		.category = FIO_OPT_C_GENERAL,
-		.group	= FIO_OPT_G_INVALID,
+		.group	= FIO_OPT_G_ERR,
 		.posval = {
 			  { .ival = "none",
 			    .oval = ERROR_TYPE_NONE,
@@ -2746,13 +2981,31 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 			  },
 		},
 	},
+	{
+		.name	= "ignore_error",
+		.type	= FIO_OPT_STR,
+		.cb	= str_ignore_error_cb,
+		.help	= "Set a specific list of errors to ignore",
+		.parent	= "rw",
+		.category = FIO_OPT_C_GENERAL,
+		.group	= FIO_OPT_G_ERR,
+	},
+	{
+		.name	= "error_dump",
+		.type	= FIO_OPT_BOOL,
+		.off1	= td_var_offset(error_dump),
+		.def	= "0",
+		.help	= "Dump info on each error",
+		.category = FIO_OPT_C_GENERAL,
+		.group	= FIO_OPT_G_ERR,
+	},
 	{
 		.name	= "profile",
 		.lname	= "Profile",
 		.type	= FIO_OPT_STR_STORE,
 		.off1	= td_var_offset(profile),
 		.help	= "Select a specific builtin performance test",
-		.category = FIO_OPT_C_GENERAL,
+		.category = FIO_OPT_C_PROFILE,
 		.group	= FIO_OPT_G_INVALID,
 	},
 	{
@@ -2810,13 +3063,57 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
 		.lname	= "KB Base",
 		.type	= FIO_OPT_INT,
 		.off1	= td_var_offset(kb_base),
-		.verify	= kb_base_verify,
 		.prio	= 1,
 		.def	= "1024",
+		.posval = {
+			  { .ival = "1024",
+			    .oval = 1024,
+			    .help = "Use 1024 as the K base",
+			  },
+			  { .ival = "1000",
+			    .oval = 1000,
+			    .help = "Use 1000 as the K base",
+			  },
+		},
 		.help	= "How many bytes per KB for reporting (1000 or 1024)",
 		.category = FIO_OPT_C_GENERAL,
 		.group	= FIO_OPT_G_INVALID,
 	},
+	{
+		.name	= "unit_base",
+		.lname	= "Base unit for reporting (Bits or Bytes)",
+		.type	= FIO_OPT_INT,
+		.off1	= td_var_offset(unit_base),
+		.prio	= 1,
+		.posval = {
+			  { .ival = "0",
+			    .oval = 0,
+			    .help = "Auto-detect",
+			  },
+			  { .ival = "8",
+			    .oval = 8,
+			    .help = "Normal (byte based)",
+			  },
+			  { .ival = "1",
+			    .oval = 1,
+			    .help = "Bit based",
+			  },
+		},
+		.help	= "Bit multiple of result summary data (8 for byte, 1 for bit)",
+		.category = FIO_OPT_C_GENERAL,
+		.group	= FIO_OPT_G_INVALID,
+	},
+	{
+		.name	= "hugepage-size",
+		.lname	= "Hugepage size",
+		.type	= FIO_OPT_INT,
+		.off1	= td_var_offset(hugepage_size),
+		.help	= "When using hugepages, specify size of each page",
+		.def	= __fio_stringify(FIO_HUGE_PAGE),
+		.interval = 1024 * 1024,
+		.category = FIO_OPT_C_GENERAL,
+		.group	= FIO_OPT_G_INVALID,
+	},
 	{
 		.name	= "flow_id",
 		.lname	= "I/O flow ID",
@@ -2967,7 +3264,7 @@ void fio_keywords_init(void)
 	char buf[128];
 	long l;
 
-	sprintf(buf, "%lu", page_size);
+	sprintf(buf, "%lu", (unsigned long) page_size);
 	fio_keywords[0].replace = strdup(buf);
 
 	mb_memory = os_phys_mem() / (1024 * 1024);
@@ -3017,14 +3314,12 @@ static char *bc_calc(char *str)
 
 	sprintf(buf, "echo '%s' | %s", tmp, BC_APP);
 	f = popen(buf, "r");
-	if (!f) {
+	if (!f)
 		return NULL;
-	}
 
 	ret = fread(&buf[tmp - str], 1, 128 - (tmp - str), f);
-	if (ret <= 0) {
+	if (ret <= 0)
 		return NULL;
-	}
 
 	pclose(f);
 	buf[(tmp - str) + ret - 1] = '\0';
@@ -3261,11 +3556,11 @@ void fio_options_mem_dupe(struct thread_data *td)
 
 unsigned int fio_get_kb_base(void *data)
 {
-	struct thread_data *td = data;
+	struct thread_options *o = data;
 	unsigned int kb_base = 0;
 
-	if (td)
-		kb_base = td->o.kb_base;
+	if (o)
+		kb_base = o->kb_base;
 	if (!kb_base)
 		kb_base = 1024;
 
@@ -3349,3 +3644,9 @@ void fio_options_free(struct thread_data *td)
 		td->eo = NULL;
 	}
 }
+
+struct fio_option *fio_option_find(const char *name)
+{
+	return find_option(fio_options, name);
+}
+