X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=init.c;h=bf54e9537bb8a7505653cfb48779ca8bfb41d9f0;hp=27370bb43eb04d4dceb184cedecb106057058c3b;hb=52c0cea392321740cba72f65b9cf5d2102658edf;hpb=62232d0618e3f5aa4805b4be34e872895ba1beb2

diff --git a/init.c b/init.c
index 27370bb4..bf54e953 100644
--- a/init.c
+++ b/init.c
@@ -26,6 +26,7 @@
 #include "idletime.h"
 
 #include "lib/getopt.h"
+#include "lib/strcasestr.h"
 
 const char fio_version_string[] = FIO_VERSION;
 
@@ -44,7 +45,6 @@ int exitall_on_terminate = 0;
 int output_format = FIO_OUTPUT_NORMAL;
 int eta_print = FIO_ETA_AUTO;
 int eta_new_line = 0;
-unsigned long long mlock_size = 0;
 FILE *f_out = NULL;
 FILE *f_err = NULL;
 char **job_sections = NULL;
@@ -58,6 +58,7 @@ int log_syslog = 0;
 
 int write_bw_log = 0;
 int read_only = 0;
+int status_interval = 0;
 
 static int write_lat_log;
 
@@ -123,9 +124,9 @@ static struct option l_opts[FIO_NR_OPTIONS] = {
 		.val		= 'c' | FIO_CLIENT_FLAG,
 	},
 	{
-		.name		   = (char *) "enghelp",
+		.name		= (char *) "enghelp",
 		.has_arg	= optional_argument,
-		.val		    = 'i' | FIO_CLIENT_FLAG,
+		.val		= 'i' | FIO_CLIENT_FLAG,
 	},
 	{
 		.name		= (char *) "showcmd",
@@ -211,6 +212,11 @@ static struct option l_opts[FIO_NR_OPTIONS] = {
 		.has_arg	= required_argument,
 		.val		= 'I',
 	},
+	{
+		.name		= (char *) "status-interval",
+		.has_arg	= required_argument,
+		.val		= 'L',
+	},
 	{
 		.name		= NULL,
 	},
@@ -567,6 +573,13 @@ static int fixup_options(struct thread_data *td)
 		}
 	}
 
+	if (!o->unit_base) {
+		if (td->io_ops->flags & FIO_BIT_BASED)
+			o->unit_base = 1;
+		else
+			o->unit_base = 8;
+	}
+
 #ifndef CONFIG_FDATASYNC
 	if (o->fdatasync_blocks) {
 		log_info("fio: this platform does not support fdatasync()"
@@ -608,6 +621,14 @@ static int fixup_options(struct thread_data *td)
 	if (td->o.random_distribution != FIO_RAND_DIST_RANDOM)
 		td->o.norandommap = 1;
 
+	/*
+	 * If size is set but less than the min block size, complain
+	 */
+	if (o->size && o->size < td_min_bs(td)) {
+		log_err("fio: size too small, must be larger than the IO size: %llu\n", (unsigned long long) o->size);
+		ret = 1;
+	}
+
 	return ret;
 }
 
@@ -680,6 +701,10 @@ static void td_fill_rand_seeds_os(struct thread_data *td)
 		td->rand_seeds[FIO_RAND_BLOCK_OFF] = FIO_RANDSEED * td->thread_number;
 
 	os_random_seed(td->rand_seeds[FIO_RAND_BLOCK_OFF], &td->random_state);
+
+	os_random_seed(td->rand_seeds[FIO_RAND_SEQ_RAND_READ_OFF], &td->seq_rand_state[DDIR_READ]);
+	os_random_seed(td->rand_seeds[FIO_RAND_SEQ_RAND_WRITE_OFF], &td->seq_rand_state[DDIR_WRITE]);
+	os_random_seed(td->rand_seeds[FIO_RAND_SEQ_RAND_TRIM_OFF], &td->seq_rand_state[DDIR_TRIM]);
 }
 
 static void td_fill_rand_seeds_internal(struct thread_data *td)
@@ -701,6 +726,9 @@ static void td_fill_rand_seeds_internal(struct thread_data *td)
 		td->rand_seeds[FIO_RAND_BLOCK_OFF] = FIO_RANDSEED * td->thread_number;
 
 	init_rand_seed(&td->__random_state, td->rand_seeds[FIO_RAND_BLOCK_OFF]);
+	init_rand_seed(&td->__seq_rand_state[DDIR_READ], td->rand_seeds[FIO_RAND_SEQ_RAND_READ_OFF]);
+	init_rand_seed(&td->__seq_rand_state[DDIR_WRITE], td->rand_seeds[FIO_RAND_SEQ_RAND_WRITE_OFF]);
+	init_rand_seed(&td->__seq_rand_state[DDIR_TRIM], td->rand_seeds[FIO_RAND_SEQ_RAND_TRIM_OFF]);
 }
 
 void td_fill_rand_seeds(struct thread_data *td)
@@ -726,6 +754,10 @@ int ioengine_load(struct thread_data *td)
 	 */
 	if (td->io_ops)
 		return 0;
+	if (!td->o.ioengine) {
+		log_err("fio: internal fault, no IO engine specified\n");
+		return 1;
+	}
 
 	engine = get_engine_name(td->o.ioengine);
 	td->io_ops = load_ioengine(td, engine);
@@ -807,6 +839,88 @@ static int setup_random_seeds(struct thread_data *td)
 	return 0;
 }
 
+enum {
+	FPRE_NONE = 0,
+	FPRE_JOBNAME,
+	FPRE_JOBNUM,
+	FPRE_FILENUM
+};
+
+static struct fpre_keyword {
+	const char *keyword;
+	size_t strlen;
+	int key;
+} fpre_keywords[] = {
+	{ .keyword = "$jobname",	.key = FPRE_JOBNAME, },
+	{ .keyword = "$jobnum",		.key = FPRE_JOBNUM, },
+	{ .keyword = "$filenum",	.key = FPRE_FILENUM, },
+	{ .keyword = NULL, },
+	};
+
+static char *make_filename(char *buf, struct thread_options *o,
+			   const char *jobname, int jobnum, int filenum)
+{
+	struct fpre_keyword *f;
+	char copy[PATH_MAX];
+
+	if (!o->filename_format || !strlen(o->filename_format)) {
+		sprintf(buf, "%s.%d.%d", jobname, jobnum, filenum);
+		return NULL;
+	}
+
+	for (f = &fpre_keywords[0]; f->keyword; f++)
+		f->strlen = strlen(f->keyword);
+
+	strcpy(buf, o->filename_format);
+	memset(copy, 0, sizeof(copy));
+	for (f = &fpre_keywords[0]; f->keyword; f++) {
+		do {
+			size_t pre_len, post_start = 0;
+			char *str, *dst = copy;
+
+			str = strcasestr(buf, f->keyword);
+			if (!str)
+				break;
+
+			pre_len = str - buf;
+			if (strlen(str) != f->strlen)
+				post_start = pre_len + f->strlen;
+
+			if (pre_len) {
+				strncpy(dst, buf, pre_len);
+				dst += pre_len;
+			}
+
+			switch (f->key) {
+			case FPRE_JOBNAME:
+				dst += sprintf(dst, "%s", jobname);
+				break;
+			case FPRE_JOBNUM:
+				dst += sprintf(dst, "%d", jobnum);
+				break;
+			case FPRE_FILENUM:
+				dst += sprintf(dst, "%d", filenum);
+				break;
+			default:
+				assert(0);
+				break;
+			}
+
+			if (post_start)
+				strcpy(dst, buf + post_start);
+
+			strcpy(buf, copy);
+		} while (1);
+	}
+
+	return buf;
+}
+
+int parse_dryrun(void)
+{
+	return dump_cmdline || parse_only;
+}
+
 /*
  * Adds a job to the list of things todo. Sanitizes the various options
  * to make sure we don't have conflicts, and initializes various
@@ -818,6 +932,7 @@ static int add_job(struct thread_data *td, const char *jobname, int job_add_num,
 	unsigned int i;
 	char fname[PATH_MAX];
 	int numjobs, file_alloced;
+	struct thread_options *o = &td->o;
 
 	/*
 	 * the def_thread is just for options, it's not a real job
@@ -830,7 +945,7 @@ static int add_job(struct thread_data *td, const char *jobname, int job_add_num,
 	/*
 	 * if we are just dumping the output command line, don't add the job
 	 */
-	if (dump_cmdline || parse_only) {
+	if (parse_dryrun()) {
 		put_job(td);
 		return 0;
 	}
@@ -843,21 +958,18 @@ static int add_job(struct thread_data *td, const char *jobname, int job_add_num,
 	if (ioengine_load(td))
 		goto err;
 
-	if (td->o.odirect)
+	if (o->odirect)
 		td->io_ops->flags |= FIO_RAWIO;
 
 	file_alloced = 0;
-	if (!td->o.filename && !td->files_index && !td->o.read_iolog_file) {
+	if (!o->filename && !td->files_index && !o->read_iolog_file) {
 		file_alloced = 1;
 
-		if (td->o.nr_files == 1 && exists_and_not_file(jobname))
+		if (o->nr_files == 1 && exists_and_not_file(jobname))
 			add_file(td, jobname);
 		else {
-			for (i = 0; i < td->o.nr_files; i++) {
-				sprintf(fname, "%s.%d.%d", jobname,
-							td->thread_number, i);
-				add_file(td, fname);
-			}
+			for (i = 0; i < o->nr_files; i++)
+				add_file(td, make_filename(fname, o, jobname, td->thread_number, i));
 		}
 	}
 
@@ -882,9 +994,9 @@ static int add_job(struct thread_data *td, const char *jobname, int job_add_num,
 
 	td->mutex = fio_mutex_init(FIO_MUTEX_LOCKED);
 
-	td->ts.clat_percentiles = td->o.clat_percentiles;
-	td->ts.percentile_precision = td->o.percentile_precision;
-	memcpy(td->ts.percentile_list, td->o.percentile_list, sizeof(td->o.percentile_list));
+	td->ts.clat_percentiles = o->clat_percentiles;
+	td->ts.percentile_precision = o->percentile_precision;
+	memcpy(td->ts.percentile_list, o->percentile_list, sizeof(o->percentile_list));
 
 	for (i = 0; i < DDIR_RWDIR_CNT; i++) {
 		td->ts.clat_stat[i].min_val = ULONG_MAX;
@@ -892,9 +1004,9 @@ static int add_job(struct thread_data *td, const char *jobname, int job_add_num,
 		td->ts.lat_stat[i].min_val = ULONG_MAX;
 		td->ts.bw_stat[i].min_val = ULONG_MAX;
 	}
-	td->ddir_seq_nr = td->o.ddir_seq_nr;
+	td->ddir_seq_nr = o->ddir_seq_nr;
 
-	if ((td->o.stonewall || td->o.new_group) && prev_group_jobs) {
+	if ((o->stonewall || o->new_group) && prev_group_jobs) {
 		prev_group_jobs = 0;
 		groupid++;
 	}
@@ -910,18 +1022,18 @@ static int add_job(struct thread_data *td, const char *jobname, int job_add_num,
 	if (setup_rate(td))
 		goto err;
 
-	if (td->o.lat_log_file) {
-		setup_log(&td->lat_log, td->o.log_avg_msec, IO_LOG_TYPE_LAT);
-		setup_log(&td->slat_log, td->o.log_avg_msec, IO_LOG_TYPE_SLAT);
-		setup_log(&td->clat_log, td->o.log_avg_msec, IO_LOG_TYPE_CLAT);
+	if (o->lat_log_file) {
+		setup_log(&td->lat_log, o->log_avg_msec, IO_LOG_TYPE_LAT);
+		setup_log(&td->slat_log, o->log_avg_msec, IO_LOG_TYPE_SLAT);
+		setup_log(&td->clat_log, o->log_avg_msec, IO_LOG_TYPE_CLAT);
 	}
-	if (td->o.bw_log_file)
-		setup_log(&td->bw_log, td->o.log_avg_msec, IO_LOG_TYPE_BW);
-	if (td->o.iops_log_file)
-		setup_log(&td->iops_log, td->o.log_avg_msec, IO_LOG_TYPE_IOPS);
+	if (o->bw_log_file)
+		setup_log(&td->bw_log, o->log_avg_msec, IO_LOG_TYPE_BW);
+	if (o->iops_log_file)
+		setup_log(&td->iops_log, o->log_avg_msec, IO_LOG_TYPE_IOPS);
 
-	if (!td->o.name)
-		td->o.name = strdup(jobname);
+	if (!o->name)
+		o->name = strdup(jobname);
 
 	if (output_format == FIO_OUTPUT_NORMAL) {
 		if (!job_add_num) {
@@ -929,22 +1041,32 @@ static int add_job(struct thread_data *td, const char *jobname, int job_add_num,
 				fio_server_send_add_job(td);
 
 			if (!(td->io_ops->flags & FIO_NOIO)) {
-				char *c1, *c2, *c3, *c4, *c5, *c6;
-
-				c1 = fio_uint_to_kmg(td->o.min_bs[DDIR_READ]);
-				c2 = fio_uint_to_kmg(td->o.max_bs[DDIR_READ]);
-				c3 = fio_uint_to_kmg(td->o.min_bs[DDIR_WRITE]);
-				c4 = fio_uint_to_kmg(td->o.max_bs[DDIR_WRITE]);
-				c5 = fio_uint_to_kmg(td->o.min_bs[DDIR_TRIM]);
-				c6 = fio_uint_to_kmg(td->o.max_bs[DDIR_TRIM]);
-
-				log_info("%s: (g=%d): rw=%s, bs=%s-%s/%s-%s/%s-%s,"
-					 " ioengine=%s, iodepth=%u\n",
-						td->o.name, td->groupid,
-						ddir_str(td->o.td_ddir),
-						c1, c2, c3, c4, c5, c6,
-						td->io_ops->name,
-						td->o.iodepth);
+				char *c1, *c2, *c3, *c4;
+				char *c5 = NULL, *c6 = NULL;
+
+				c1 = fio_uint_to_kmg(o->min_bs[DDIR_READ]);
+				c2 = fio_uint_to_kmg(o->max_bs[DDIR_READ]);
+				c3 = fio_uint_to_kmg(o->min_bs[DDIR_WRITE]);
+				c4 = fio_uint_to_kmg(o->max_bs[DDIR_WRITE]);
+
+				if (!o->bs_is_seq_rand) {
+					c5 = fio_uint_to_kmg(o->min_bs[DDIR_TRIM]);
+					c6 = fio_uint_to_kmg(o->max_bs[DDIR_TRIM]);
+				}
+
+				log_info("%s: (g=%d): rw=%s, ", td->o.name,
+							td->groupid,
+							ddir_str(o->td_ddir));
+
+				if (o->bs_is_seq_rand)
+					log_info("bs(seq/rand)=%s-%s/%s-%s, ",
+							c1, c2, c3, c4);
+				else
+					log_info("bs=%s-%s/%s-%s/%s-%s, ",
+							c1, c2, c3, c4, c5, c6);
+
+				log_info("ioengine=%s, iodepth=%u\n",
+						td->io_ops->name, o->iodepth);
 
 				free(c1);
 				free(c2);
@@ -961,7 +1083,7 @@ static int add_job(struct thread_data *td, const char *jobname, int job_add_num,
 	 * recurse add identical jobs, clear numjobs and stonewall options
 	 * as they don't apply to sub-jobs
 	 */
-	numjobs = td->o.numjobs;
+	numjobs = o->numjobs;
 	while (--numjobs) {
 		struct thread_data *td_new = get_new_job(0, td, 1);
 
@@ -1281,6 +1403,8 @@ static void usage(const char *name)
 	printf("            \t\tMay be \"always\", \"never\" or \"auto\"\n");
 	printf("  --eta-newline=time\tForce a new line for every 'time'");
 	printf(" period passed\n");
+	printf("  --status-interval=t\tForce full status dump every");
+	printf(" 't' period passed\n");
 	printf("  --readonly\t\tTurn on safety read-only checks, preventing"
 		" writes\n");
 	printf("  --section=name\tOnly run specified section in job file\n");
@@ -1627,7 +1751,20 @@ int parse_cmd_line(int argc, char *argv[], int client_type)
 				fio_options_set_ioengine_opts(l_opts, td);
 			}
 
-			ret = fio_cmd_option_parse(td, opt, val);
+			if ((!val || !strlen(val)) &&
+			    l_opts[lidx].has_arg == required_argument) {
+				log_err("fio: option %s requires an argument\n", opt);
+				ret = 1;
+			} else
+				ret = fio_cmd_option_parse(td, opt, val);
+
+			if (ret) {
+				if (td) {
+					put_job(td);
+					td = NULL;
+				}
+				do_exit++;
+			}
 
 			if (!ret && !strcmp(opt, "ioengine")) {
 				free_ioengine(td);
@@ -1640,8 +1777,6 @@ int parse_cmd_line(int argc, char *argv[], int client_type)
 		case FIO_GETOPT_IOENGINE: {
 			const char *opt = l_opts[lidx].name;
 			char *val = optarg;
-			opt = l_opts[lidx].name;
-			val = optarg;
 			ret = fio_cmd_ioengine_option_parse(td, opt, val);
 			break;
 		}
@@ -1709,6 +1844,18 @@ int parse_cmd_line(int argc, char *argv[], int client_type)
 			do_exit++;
 			exit_val = fio_monotonic_clocktest();
 			break;
+		case 'L': {
+			long long val;
+
+			if (check_str_time(optarg, &val)) {
+				log_err("fio: failed parsing time %s\n", optarg);
+				do_exit++;
+				exit_val = 1;
+				break;
+			}
+			status_interval = val * 1000;
+			break;
+			}
 		case '?':
 			log_err("%s: unrecognized option '%s'\n", argv[0],
 							argv[optind - 1]);
@@ -1721,10 +1868,8 @@ int parse_cmd_line(int argc, char *argv[], int client_type)
 			break;
 	}
 
-	if (do_exit) {
-		if (exit_val && !(is_backend || nr_clients))
-			exit(exit_val);
-	}
+	if (do_exit && !(is_backend || nr_clients))
+		exit(exit_val);
 
 	if (nr_clients && fio_clients_connect()) {
 		do_exit++;
@@ -1805,7 +1950,7 @@ int parse_options(int argc, char *argv[])
 	fio_options_free(&def_thread);
 
 	if (!thread_number) {
-		if (dump_cmdline || parse_only)
+		if (parse_dryrun())
 			return 0;
 		if (exec_profile)
 			return 0;