[fio.git] / init.c

/*
 * This file contains job initialization and setup functions.
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <ctype.h>
#include <string.h>
#include <errno.h>
#include <getopt.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <sys/stat.h>

#include "fio.h"
#include "parse.h"

static char fio_version_string[] = "fio 1.14a";

#define FIO_RANDSEED		(0xb1899bedUL)

static char **ini_file;
static int max_jobs = MAX_JOBS;

struct thread_data def_thread;
struct thread_data *threads = NULL;

int exitall_on_terminate = 0;
int terse_output = 0;
unsigned long long mlock_size = 0;
FILE *f_out = NULL;
FILE *f_err = NULL;

int write_bw_log = 0;

static int def_timeout = 0;
static int write_lat_log = 0;

static int prev_group_jobs;

/*
 * Command line options. These will contain the above, plus a few
 * extra that only pertain to fio itself and not jobs.
 */
static struct option long_options[FIO_NR_OPTIONS] = {
	{
		.name		= "output",
		.has_arg	= required_argument,
		.val		= 'o',
	},
	{
		.name		= "timeout",
		.has_arg	= required_argument,
		.val		= 't',
	},
	{
		.name		= "latency-log",
		.has_arg	= required_argument,
		.val		= 'l',
	},
	{
		.name		= "bandwidth-log",
		.has_arg	= required_argument,
		.val		= 'b',
	},
	{
		.name		= "minimal",
		.has_arg	= optional_argument,
		.val		= 'm',
	},
	{
		.name		= "version",
		.has_arg	= no_argument,
		.val		= 'v',
	},
	{
		.name		= "help",
		.has_arg	= no_argument,
		.val		= 'h',
	},
	{
		.name		= "cmdhelp",
		.has_arg	= optional_argument,
		.val		= 'c',
	},
	{
		.name		= NULL,
	},
};

FILE *get_f_out()
{
	return f_out;
}

FILE *get_f_err()
{
	return f_err;
}

/*
 * Return a free job structure.
 */
static struct thread_data *get_new_job(int global, struct thread_data *parent)
{
	struct thread_data *td;

	if (global)
		return &def_thread;
	if (thread_number >= max_jobs)
		return NULL;

	td = &threads[thread_number++];
	*td = *parent;

	td->thread_number = thread_number;
	return td;
}

static void put_job(struct thread_data *td)
{
	if (td == &def_thread)
		return;

	if (td->error)
		log_info("fio: %s\n", td->verror);

	memset(&threads[td->thread_number - 1], 0, sizeof(*td));
	thread_number--;
}

static int setup_rate(struct thread_data *td)
{
	unsigned long nr_reads_per_msec;
	unsigned long long rate;
	unsigned int bs;

	if (!td->o.rate && !td->o.rate_iops)
		return 0;

	if (td_rw(td))
		bs = td->o.rw_min_bs;
	else if (td_read(td))
		bs = td->o.min_bs[DDIR_READ];
	else
		bs = td->o.min_bs[DDIR_WRITE];

	if (td->o.rate) {
		rate = td->o.rate;
		nr_reads_per_msec = (rate * 1024 * 1000LL) / bs;
	} else
		nr_reads_per_msec = td->o.rate_iops * 1000UL;

	if (!nr_reads_per_msec) {
		log_err("rate lower than supported\n");
		return -1;
	}

	td->rate_usec_cycle = 1000000000ULL / nr_reads_per_msec;
	td->rate_pending_usleep = 0;
	return 0;
}

/*
 * Lazy way of fixing up options that depend on each other. We could also
 * define option callback handlers, but this is easier.
 */
static int fixup_options(struct thread_data *td)
{
	struct thread_options *o = &td->o;

	if (!o->rwmixread && o->rwmixwrite)
		o->rwmixread = 100 - o->rwmixwrite;

	if (o->write_iolog_file && o->read_iolog_file) {
		log_err("fio: read iolog overrides write_iolog\n");
		free(o->write_iolog_file);
		o->write_iolog_file = NULL;
	}

	if (td->io_ops->flags & FIO_SYNCIO)
		o->iodepth = 1;
	else {
		if (!o->iodepth)
			o->iodepth = o->open_files;
	}

	/*
	 * only really works for sequential io for now, and with 1 file
	 */
	if (o->zone_size && td_random(td) && o->open_files == 1)
		o->zone_size = 0;

	/*
	 * Reads can do overwrites, we always need to pre-create the file
	 */
	if (td_read(td) || td_rw(td))
		o->overwrite = 1;

	if (!o->min_bs[DDIR_READ])
		o->min_bs[DDIR_READ]= o->bs[DDIR_READ];
	if (!o->max_bs[DDIR_READ])
		o->max_bs[DDIR_READ] = o->bs[DDIR_READ];
	if (!o->min_bs[DDIR_WRITE])
		o->min_bs[DDIR_WRITE]= o->bs[DDIR_WRITE];
	if (!o->max_bs[DDIR_WRITE])
		o->max_bs[DDIR_WRITE] = o->bs[DDIR_WRITE];

	o->rw_min_bs = min(o->min_bs[DDIR_READ], o->min_bs[DDIR_WRITE]);

	if (!o->file_size_high)
		o->file_size_high = o->file_size_low;

	if (td_read(td) && !td_rw(td))
		o->verify = 0;

	if (o->norandommap && o->verify != VERIFY_NONE) {
		log_err("fio: norandommap given, verify disabled\n");
		o->verify = VERIFY_NONE;
	}
	if (o->bs_unaligned && (o->odirect || td->io_ops->flags & FIO_RAWIO))
		log_err("fio: bs_unaligned may not work with raw io\n");

	/*
	 * thinktime_spin must be less than thinktime
	 */
	if (o->thinktime_spin > o->thinktime)
		o->thinktime_spin = o->thinktime;

	/*
	 * The low water mark cannot be bigger than the iodepth
	 */
	if (o->iodepth_low > o->iodepth || !o->iodepth_low) {
		/*
		 * syslet work around - if the workload is sequential,
		 * we want to let the queue drain all the way down to
		 * avoid seeking between async threads
		 */
		if (!strcmp(td->io_ops->name, "syslet-rw") && !td_random(td))
			o->iodepth_low = 1;
		else
			o->iodepth_low = o->iodepth;
	}

	/*
	 * If batch number isn't set, default to the same as iodepth
	 */
	if (o->iodepth_batch > o->iodepth || !o->iodepth_batch)
		o->iodepth_batch = o->iodepth;

	if (o->nr_files > td->files_index)
		o->nr_files = td->files_index;

	if (o->open_files > o->nr_files || !o->open_files)
		o->open_files = o->nr_files;

	if ((o->rate && o->rate_iops) || (o->ratemin && o->rate_iops_min)) {
		log_err("fio: rate and rate_iops are mutually exclusive\n");
		return 1;
	}
	if ((o->rate < o->ratemin) || (o->rate_iops < o->rate_iops_min)) {
		log_err("fio: minimum rate exceeds rate\n");
		return 1;
	}

	return 0;
}

/*
 * This function leaks the buffer
 */
static char *to_kmg(unsigned int val)
{
	char *buf = malloc(32);
	char post[] = { 0, 'K', 'M', 'G', 'P', 'E', 0 };
	char *p = post;

	do {
		if (val & 1023)
			break;

		val >>= 10;
		p++;
	} while (*p);

	snprintf(buf, 31, "%u%c", val, *p);
	return buf;
}

/* External engines are specified by "external:name.o") */
static const char *get_engine_name(const char *str)
{
	char *p = strstr(str, ":");

	if (!p)
		return str;

	p++;
	strip_blank_front(&p);
	strip_blank_end(p);
	return p;
}

static int exists_and_not_file(const char *filename)
{
	struct stat sb;

	if (lstat(filename, &sb) == -1)
		return 0;

	if (S_ISREG(sb.st_mode))
		return 0;

	return 1;
}

/*
 * Initialize the various random states we need (random io, block size ranges,
 * read/write mix, etc).
 */
static int init_random_state(struct thread_data *td)
{
	unsigned long seeds[6];
	int fd, num_maps, blocks;
	struct fio_file *f;
	unsigned int i;

	fd = open("/dev/urandom", O_RDONLY);
	if (fd == -1) {
		td_verror(td, errno, "open");
		return 1;
	}

	if (read(fd, seeds, sizeof(seeds)) < (int) sizeof(seeds)) {
		td_verror(td, EIO, "read");
		close(fd);
		return 1;
	}

	close(fd);

	os_random_seed(seeds[0], &td->bsrange_state);
	os_random_seed(seeds[1], &td->verify_state);
	os_random_seed(seeds[2], &td->rwmix_state);

	if (td->o.file_service_type == FIO_FSERVICE_RANDOM)
		os_random_seed(seeds[3], &td->next_file_state);

	os_random_seed(seeds[5], &td->file_size_state);

	if (!td_random(td))
		return 0;

	if (td->o.rand_repeatable)
		seeds[4] = FIO_RANDSEED * td->thread_number;

	if (!td->o.norandommap) {
		for_each_file(td, f, i) {
			blocks = (f->real_file_size + td->o.rw_min_bs - 1) / td->o.rw_min_bs;
			num_maps = (blocks + BLOCKS_PER_MAP-1)/ BLOCKS_PER_MAP;
			f->file_map = malloc(num_maps * sizeof(long));
			if (!f->file_map) {
				log_err("fio: failed allocating random map. If running a large number of jobs, try the 'norandommap' option\n");
				return 1;
			}
			f->num_maps = num_maps;
			memset(f->file_map, 0, num_maps * sizeof(long));
		}
	}

	os_random_seed(seeds[4], &td->random_state);
	return 0;
}


/*
 * Adds a job to the list of things todo. Sanitizes the various options
 * to make sure we don't have conflicts, and initializes various
 * members of td.
 */
static int add_job(struct thread_data *td, const char *jobname, int job_add_num)
{
	const char *ddir_str[] = { NULL, "read", "write", "rw", NULL,
				   "randread", "randwrite", "randrw" };
	unsigned int i;
	struct fio_file *f;
	const char *engine;
	char fname[PATH_MAX];
	int numjobs, file_alloced;

	/*
	 * the def_thread is just for options, it's not a real job
	 */
	if (td == &def_thread)
		return 0;

	engine = get_engine_name(td->o.ioengine);
	td->io_ops = load_ioengine(td, engine);
	if (!td->io_ops) {
		log_err("fio: failed to load engine %s\n", engine);
		goto err;
	}

	if (td->o.use_thread)
		nr_thread++;
	else
		nr_process++;

	if (td->o.odirect)
		td->io_ops->flags |= FIO_RAWIO;

	file_alloced = 0;
	if (!td->o.filename && !td->files_index) {
		file_alloced = 1;

		if (td->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);
			}
		}
	}

	if (fixup_options(td))
		goto err;

	for_each_file(td, f, i) {
		if (td->o.directory && f->filetype == FIO_TYPE_FILE) {
			sprintf(fname, "%s/%s", td->o.directory, f->file_name);
			f->file_name = strdup(fname);
		}
	}
		
	td->mutex = fio_sem_init(0);

	td->ts.clat_stat[0].min_val = td->ts.clat_stat[1].min_val = ULONG_MAX;
	td->ts.slat_stat[0].min_val = td->ts.slat_stat[1].min_val = ULONG_MAX;
	td->ts.bw_stat[0].min_val = td->ts.bw_stat[1].min_val = ULONG_MAX;

	if ((td->o.stonewall || td->o.numjobs > 1) && prev_group_jobs) {
		prev_group_jobs = 0;
		groupid++;
	}

	td->groupid = groupid;
	prev_group_jobs++;

	if (init_random_state(td))
		goto err;

	if (setup_rate(td))
		goto err;

	if (td->o.write_lat_log) {
		setup_log(&td->ts.slat_log);
		setup_log(&td->ts.clat_log);
	}
	if (td->o.write_bw_log)
		setup_log(&td->ts.bw_log);

	if (!td->o.name)
		td->o.name = strdup(jobname);

	if (!terse_output) {
		if (!job_add_num) {
			if (!strcmp(td->io_ops->name, "cpuio"))
				log_info("%s: ioengine=cpu, cpuload=%u, cpucycle=%u\n", td->o.name, td->o.cpuload, td->o.cpucycle);
			else {
				char *c1, *c2, *c3, *c4;

				c1 = to_kmg(td->o.min_bs[DDIR_READ]);
				c2 = to_kmg(td->o.max_bs[DDIR_READ]);
				c3 = to_kmg(td->o.min_bs[DDIR_WRITE]);
				c4 = to_kmg(td->o.max_bs[DDIR_WRITE]);

				log_info("%s: (g=%d): rw=%s, bs=%s-%s/%s-%s, ioengine=%s, iodepth=%u\n", td->o.name, td->groupid, ddir_str[td->o.td_ddir], c1, c2, c3, c4, td->io_ops->name, td->o.iodepth);

				free(c1);
				free(c2);
				free(c3);
				free(c4);
			}
		} else if (job_add_num == 1)
			log_info("...\n");
	}

	/*
	 * recurse add identical jobs, clear numjobs and stonewall options
	 * as they don't apply to sub-jobs
	 */
	numjobs = td->o.numjobs;
	while (--numjobs) {
		struct thread_data *td_new = get_new_job(0, td);

		if (!td_new)
			goto err;

		td_new->o.numjobs = 1;
		td_new->o.stonewall = 0;

		if (file_alloced) {
			td_new->o.filename = NULL;
			td_new->files_index = 0;
			td_new->files = NULL;
		}

		job_add_num = numjobs - 1;

		if (add_job(td_new, jobname, job_add_num))
			goto err;
	}

	if (td->o.numjobs > 1) {
		groupid++;
		prev_group_jobs = 0;
	}

	return 0;
err:
	put_job(td);
	return -1;
}

static int is_empty_or_comment(char *line)
{
	unsigned int i;

	for (i = 0; i < strlen(line); i++) {
		if (line[i] == ';')
			return 1;
		if (line[i] == '#')
			return 1;
		if (!isspace(line[i]) && !iscntrl(line[i]))
			return 0;
	}

	return 1;
}

/*
 * This is our [ini] type file parser.
 */
static int parse_jobs_ini(char *file, int stonewall_flag)
{
	unsigned int global;
	struct thread_data *td;
	char *string, *name;
	fpos_t off;
	FILE *f;
	char *p;
	int ret = 0, stonewall;

	f = fopen(file, "r");
	if (!f) {
		perror("fopen job file");
		return 1;
	}

	string = malloc(4096);
	name = malloc(256);
	memset(name, 0, 256);

	stonewall = stonewall_flag;
	do {
		p = fgets(string, 4095, f);
		if (!p)
			break;
		if (is_empty_or_comment(p))
			continue;
		if (sscanf(p, "[%255s]", name) != 1)
			continue;

		global = !strncmp(name, "global", 6);

		name[strlen(name) - 1] = '\0';

		td = get_new_job(global, &def_thread);
		if (!td) {
			ret = 1;
			break;
		}

		/*
		 * Seperate multiple job files by a stonewall
		 */
		if (!global && stonewall) {
			td->o.stonewall = stonewall;
			stonewall = 0;
		}

		fgetpos(f, &off);
		while ((p = fgets(string, 4096, f)) != NULL) {
			if (is_empty_or_comment(p))
				continue;

			strip_blank_front(&p);

			if (p[0] == '[')
				break;

			strip_blank_end(p);

			fgetpos(f, &off);

			/*
			 * Don't break here, continue parsing options so we
			 * dump all the bad ones. Makes trial/error fixups
			 * easier on the user.
			 */
			ret |= fio_option_parse(td, p);
		}

		if (!ret) {
			fsetpos(f, &off);
			ret = add_job(td, name, 0);
		} else {
			log_err("fio: job %s dropped\n", name);
			put_job(td);
		}
	} while (!ret);

	free(string);
	free(name);
	fclose(f);
	return ret;
}

static int fill_def_thread(void)
{
	memset(&def_thread, 0, sizeof(def_thread));

	if (fio_getaffinity(getpid(), &def_thread.o.cpumask) == -1) {
		perror("sched_getaffinity");
		return 1;
	}

	/*
	 * fill default options
	 */
	fio_fill_default_options(&def_thread);

	def_thread.o.timeout = def_timeout;
	def_thread.o.write_bw_log = write_bw_log;
	def_thread.o.write_lat_log = write_lat_log;

#ifdef FIO_HAVE_DISK_UTIL
	def_thread.o.do_disk_util = 1;
#endif

	return 0;
}

static void free_shm(void)
{
	struct shmid_ds sbuf;

	if (threads) {
		shmdt((void *) threads);
		threads = NULL;
		shmctl(shm_id, IPC_RMID, &sbuf);
	}
}

/*
 * The thread area is shared between the main process and the job
 * threads/processes. So setup a shared memory segment that will hold
 * all the job info.
 */
static int setup_thread_area(void)
{
	/*
	 * 1024 is too much on some machines, scale max_jobs if
	 * we get a failure that looks like too large a shm segment
	 */
	do {
		size_t size = max_jobs * sizeof(struct thread_data);

		shm_id = shmget(0, size, IPC_CREAT | 0600);
		if (shm_id != -1)
			break;
		if (errno != EINVAL) {
			perror("shmget");
			break;
		}

		max_jobs >>= 1;
	} while (max_jobs);

	if (shm_id == -1)
		return 1;

	threads = shmat(shm_id, NULL, 0);
	if (threads == (void *) -1) {
		perror("shmat");
		return 1;
	}

	atexit(free_shm);
	return 0;
}

static void usage(void)
{
	printf("%s\n", fio_version_string);
	printf("\t--output\tWrite output to file\n");
	printf("\t--timeout\tRuntime in seconds\n");
	printf("\t--latency-log\tGenerate per-job latency logs\n");
	printf("\t--bandwidth-log\tGenerate per-job bandwidth logs\n");
	printf("\t--minimal\tMinimal (terse) output\n");
	printf("\t--version\tPrint version info and exit\n");
	printf("\t--help\t\tPrint this page\n");
	printf("\t--cmdhelp=cmd\tPrint command help, \"all\" for all of them\n");
}

static int parse_cmd_line(int argc, char *argv[])
{
	struct thread_data *td = NULL;
	int c, ini_idx = 0, lidx, ret, dont_add_job = 0;

	while ((c = getopt_long_only(argc, argv, "", long_options, &lidx)) != -1) {
		switch (c) {
		case 't':
			def_timeout = atoi(optarg);
			break;
		case 'l':
			write_lat_log = 1;
			break;
		case 'w':
			write_bw_log = 1;
			break;
		case 'o':
			f_out = fopen(optarg, "w+");
			if (!f_out) {
				perror("fopen output");
				exit(1);
			}
			f_err = f_out;
			break;
		case 'm':
			terse_output = 1;
			break;
		case 'h':
			usage();
			exit(0);
		case 'c':
			exit(fio_show_option_help(optarg));
		case 'v':
			printf("%s\n", fio_version_string);
			exit(0);
		case FIO_GETOPT_JOB: {
			const char *opt = long_options[lidx].name;
			char *val = optarg;

			if (!strncmp(opt, "name", 4) && td) {
				ret = add_job(td, td->o.name ?: "fio", 0);
				if (ret) {
					put_job(td);
					return 0;
				}
				td = NULL;
			}
			if (!td) {
				int global = !strncmp(val, "global", 6);

				td = get_new_job(global, &def_thread);
				if (!td)
					return 0;
			}

			ret = fio_cmd_option_parse(td, opt, val);
			if (ret)
				dont_add_job = 1;
			break;
		}
		default:
			break;
		}
	}

	if (td) {
		if (dont_add_job)
			put_job(td);
		else {
			ret = add_job(td, td->o.name ?: "fio", 0);
			if (ret)
				put_job(td);
		}
	}

	while (optind < argc) {
		ini_idx++;
		ini_file = realloc(ini_file, ini_idx * sizeof(char *));
		ini_file[ini_idx - 1] = strdup(argv[optind]);
		optind++;
	}

	return ini_idx;
}


int parse_options(int argc, char *argv[])
{
	int job_files, i;

	f_out = stdout;
	f_err = stderr;

	fio_options_dup_and_init(long_options);

	if (setup_thread_area())
		return 1;
	if (fill_def_thread())
		return 1;

	job_files = parse_cmd_line(argc, argv);

	for (i = 0; i < job_files; i++) {
		if (fill_def_thread())
			return 1;
		if (parse_jobs_ini(ini_file[i], i))
			return 1;
		free(ini_file[i]);
	}

	free(ini_file);

	if (!thread_number) {
		log_err("No jobs defined(s)\n");
		return 1;
	}

	return 0;
}
Commit	Line	Data
	1	/*
	2	* This file contains job initialization and setup functions.
	3	*/
	4	#include <stdio.h>
	5	#include <stdlib.h>
	6	#include <unistd.h>
	7	#include <fcntl.h>
	8	#include <ctype.h>
	9	#include <string.h>
	10	#include <errno.h>
	11	#include <getopt.h>
	12	#include <sys/ipc.h>
	13	#include <sys/shm.h>
	14	#include <sys/types.h>
	15	#include <sys/stat.h>
	16
	17	#include "fio.h"
	18	#include "parse.h"
	19
	20	static char fio_version_string[] = "fio 1.14a";
	21
	22	#define FIO_RANDSEED (0xb1899bedUL)
	23
	24	static char **ini_file;
	25	static int max_jobs = MAX_JOBS;
	26
	27	struct thread_data def_thread;
	28	struct thread_data *threads = NULL;
	29
	30	int exitall_on_terminate = 0;
	31	int terse_output = 0;
	32	unsigned long long mlock_size = 0;
	33	FILE *f_out = NULL;
	34	FILE *f_err = NULL;
	35
	36	int write_bw_log = 0;
	37
	38	static int def_timeout = 0;
	39	static int write_lat_log = 0;
	40
	41	static int prev_group_jobs;
	42
	43	/*
	44	* Command line options. These will contain the above, plus a few
	45	* extra that only pertain to fio itself and not jobs.
	46	*/
	47	static struct option long_options[FIO_NR_OPTIONS] = {
	48	{
	49	.name = "output",
	50	.has_arg = required_argument,
	51	.val = 'o',
	52	},
	53	{
	54	.name = "timeout",
	55	.has_arg = required_argument,
	56	.val = 't',
	57	},
	58	{
	59	.name = "latency-log",
	60	.has_arg = required_argument,
	61	.val = 'l',
	62	},
	63	{
	64	.name = "bandwidth-log",
	65	.has_arg = required_argument,
	66	.val = 'b',
	67	},
	68	{
	69	.name = "minimal",
	70	.has_arg = optional_argument,
	71	.val = 'm',
	72	},
	73	{
	74	.name = "version",
	75	.has_arg = no_argument,
	76	.val = 'v',
	77	},
	78	{
	79	.name = "help",
	80	.has_arg = no_argument,
	81	.val = 'h',
	82	},
	83	{
	84	.name = "cmdhelp",
	85	.has_arg = optional_argument,
	86	.val = 'c',
	87	},
	88	{
	89	.name = NULL,
	90	},
	91	};
	92
	93	FILE *get_f_out()
	94	{
	95	return f_out;
	96	}
	97
	98	FILE *get_f_err()
	99	{
	100	return f_err;
	101	}
	102
	103	/*
	104	* Return a free job structure.
	105	*/
	106	static struct thread_data get_new_job(int global, struct thread_data parent)
	107	{
	108	struct thread_data *td;
	109
	110	if (global)
	111	return &def_thread;
	112	if (thread_number >= max_jobs)
	113	return NULL;
	114
	115	td = &threads[thread_number++];
	116	td = parent;
	117
	118	td->thread_number = thread_number;
	119	return td;
	120	}
	121
	122	static void put_job(struct thread_data *td)
	123	{
	124	if (td == &def_thread)
	125	return;
	126
	127	if (td->error)
	128	log_info("fio: %s\n", td->verror);
	129
	130	memset(&threads[td->thread_number - 1], 0, sizeof(*td));
	131	thread_number--;
	132	}
	133
	134	static int setup_rate(struct thread_data *td)
	135	{
	136	unsigned long nr_reads_per_msec;
	137	unsigned long long rate;
	138	unsigned int bs;
	139
	140	if (!td->o.rate && !td->o.rate_iops)
	141	return 0;
	142
	143	if (td_rw(td))
	144	bs = td->o.rw_min_bs;
	145	else if (td_read(td))
	146	bs = td->o.min_bs[DDIR_READ];
	147	else
	148	bs = td->o.min_bs[DDIR_WRITE];
	149
	150	if (td->o.rate) {
	151	rate = td->o.rate;
	152	nr_reads_per_msec = (rate * 1024 * 1000LL) / bs;
	153	} else
	154	nr_reads_per_msec = td->o.rate_iops * 1000UL;
	155
	156	if (!nr_reads_per_msec) {
	157	log_err("rate lower than supported\n");
	158	return -1;
	159	}
	160
	161	td->rate_usec_cycle = 1000000000ULL / nr_reads_per_msec;
	162	td->rate_pending_usleep = 0;
	163	return 0;
	164	}
	165
	166	/*
	167	* Lazy way of fixing up options that depend on each other. We could also
	168	* define option callback handlers, but this is easier.
	169	*/
	170	static int fixup_options(struct thread_data *td)
	171	{
	172	struct thread_options *o = &td->o;
	173
	174	if (!o->rwmixread && o->rwmixwrite)
	175	o->rwmixread = 100 - o->rwmixwrite;
	176
	177	if (o->write_iolog_file && o->read_iolog_file) {
	178	log_err("fio: read iolog overrides write_iolog\n");
	179	free(o->write_iolog_file);
	180	o->write_iolog_file = NULL;
	181	}
	182
	183	if (td->io_ops->flags & FIO_SYNCIO)
	184	o->iodepth = 1;
	185	else {
	186	if (!o->iodepth)
	187	o->iodepth = o->open_files;
	188	}
	189
	190	/*
	191	* only really works for sequential io for now, and with 1 file
	192	*/
	193	if (o->zone_size && td_random(td) && o->open_files == 1)
	194	o->zone_size = 0;
	195
	196	/*
	197	* Reads can do overwrites, we always need to pre-create the file
	198	*/
	199	if (td_read(td) \|\| td_rw(td))
	200	o->overwrite = 1;
	201
	202	if (!o->min_bs[DDIR_READ])
	203	o->min_bs[DDIR_READ]= o->bs[DDIR_READ];
	204	if (!o->max_bs[DDIR_READ])
	205	o->max_bs[DDIR_READ] = o->bs[DDIR_READ];
	206	if (!o->min_bs[DDIR_WRITE])
	207	o->min_bs[DDIR_WRITE]= o->bs[DDIR_WRITE];
	208	if (!o->max_bs[DDIR_WRITE])
	209	o->max_bs[DDIR_WRITE] = o->bs[DDIR_WRITE];
	210
	211	o->rw_min_bs = min(o->min_bs[DDIR_READ], o->min_bs[DDIR_WRITE]);
	212
	213	if (!o->file_size_high)
	214	o->file_size_high = o->file_size_low;
	215
	216	if (td_read(td) && !td_rw(td))
	217	o->verify = 0;
	218
	219	if (o->norandommap && o->verify != VERIFY_NONE) {
	220	log_err("fio: norandommap given, verify disabled\n");
	221	o->verify = VERIFY_NONE;
	222	}
	223	if (o->bs_unaligned && (o->odirect \|\| td->io_ops->flags & FIO_RAWIO))
	224	log_err("fio: bs_unaligned may not work with raw io\n");
	225
	226	/*
	227	* thinktime_spin must be less than thinktime
	228	*/
	229	if (o->thinktime_spin > o->thinktime)
	230	o->thinktime_spin = o->thinktime;
	231
	232	/*
	233	* The low water mark cannot be bigger than the iodepth
	234	*/
	235	if (o->iodepth_low > o->iodepth \|\| !o->iodepth_low) {
	236	/*
	237	* syslet work around - if the workload is sequential,
	238	* we want to let the queue drain all the way down to
	239	* avoid seeking between async threads
	240	*/
	241	if (!strcmp(td->io_ops->name, "syslet-rw") && !td_random(td))
	242	o->iodepth_low = 1;
	243	else
	244	o->iodepth_low = o->iodepth;
	245	}
	246
	247	/*
	248	* If batch number isn't set, default to the same as iodepth
	249	*/
	250	if (o->iodepth_batch > o->iodepth \|\| !o->iodepth_batch)
	251	o->iodepth_batch = o->iodepth;
	252
	253	if (o->nr_files > td->files_index)
	254	o->nr_files = td->files_index;
	255
	256	if (o->open_files > o->nr_files \|\| !o->open_files)
	257	o->open_files = o->nr_files;
	258
	259	if ((o->rate && o->rate_iops) \|\| (o->ratemin && o->rate_iops_min)) {
	260	log_err("fio: rate and rate_iops are mutually exclusive\n");
	261	return 1;
	262	}
	263	if ((o->rate < o->ratemin) \|\| (o->rate_iops < o->rate_iops_min)) {
	264	log_err("fio: minimum rate exceeds rate\n");
	265	return 1;
	266	}
	267
	268	return 0;
	269	}
	270
	271	/*
	272	* This function leaks the buffer
	273	*/
	274	static char *to_kmg(unsigned int val)
	275	{
	276	char *buf = malloc(32);
	277	char post[] = { 0, 'K', 'M', 'G', 'P', 'E', 0 };
	278	char *p = post;
	279
	280	do {
	281	if (val & 1023)
	282	break;
	283
	284	val >>= 10;
	285	p++;
	286	} while (*p);
	287
	288	snprintf(buf, 31, "%u%c", val, *p);
	289	return buf;
	290	}
	291
	292	/* External engines are specified by "external:name.o") */
	293	static const char get_engine_name(const char str)
	294	{
	295	char *p = strstr(str, ":");
	296
	297	if (!p)
	298	return str;
	299
	300	p++;
	301	strip_blank_front(&p);
	302	strip_blank_end(p);
	303	return p;
	304	}
	305
	306	static int exists_and_not_file(const char *filename)
	307	{
	308	struct stat sb;
	309
	310	if (lstat(filename, &sb) == -1)
	311	return 0;
	312
	313	if (S_ISREG(sb.st_mode))
	314	return 0;
	315
	316	return 1;
	317	}
	318
	319	/*
	320	* Initialize the various random states we need (random io, block size ranges,
	321	* read/write mix, etc).
	322	*/
	323	static int init_random_state(struct thread_data *td)
	324	{
	325	unsigned long seeds[6];
	326	int fd, num_maps, blocks;
	327	struct fio_file *f;
	328	unsigned int i;
	329
	330	fd = open("/dev/urandom", O_RDONLY);
	331	if (fd == -1) {
	332	td_verror(td, errno, "open");
	333	return 1;
	334	}
	335
	336	if (read(fd, seeds, sizeof(seeds)) < (int) sizeof(seeds)) {
	337	td_verror(td, EIO, "read");
	338	close(fd);
	339	return 1;
	340	}
	341
	342	close(fd);
	343
	344	os_random_seed(seeds[0], &td->bsrange_state);
	345	os_random_seed(seeds[1], &td->verify_state);
	346	os_random_seed(seeds[2], &td->rwmix_state);
	347
	348	if (td->o.file_service_type == FIO_FSERVICE_RANDOM)
	349	os_random_seed(seeds[3], &td->next_file_state);
	350
	351	os_random_seed(seeds[5], &td->file_size_state);
	352
	353	if (!td_random(td))
	354	return 0;
	355
	356	if (td->o.rand_repeatable)
	357	seeds[4] = FIO_RANDSEED * td->thread_number;
	358
	359	if (!td->o.norandommap) {
	360	for_each_file(td, f, i) {
	361	blocks = (f->real_file_size + td->o.rw_min_bs - 1) / td->o.rw_min_bs;
	362	num_maps = (blocks + BLOCKS_PER_MAP-1)/ BLOCKS_PER_MAP;
	363	f->file_map = malloc(num_maps * sizeof(long));
	364	if (!f->file_map) {
	365	log_err("fio: failed allocating random map. If running a large number of jobs, try the 'norandommap' option\n");
	366	return 1;
	367	}
	368	f->num_maps = num_maps;
	369	memset(f->file_map, 0, num_maps * sizeof(long));
	370	}
	371	}
	372
	373	os_random_seed(seeds[4], &td->random_state);
	374	return 0;
	375	}
	376
	377
	378	/*
	379	* Adds a job to the list of things todo. Sanitizes the various options
	380	* to make sure we don't have conflicts, and initializes various
	381	* members of td.
	382	*/
	383	static int add_job(struct thread_data td, const char jobname, int job_add_num)
	384	{
	385	const char *ddir_str[] = { NULL, "read", "write", "rw", NULL,
	386	"randread", "randwrite", "randrw" };
	387	unsigned int i;
	388	struct fio_file *f;
	389	const char *engine;
	390	char fname[PATH_MAX];
	391	int numjobs, file_alloced;
	392
	393	/*
	394	* the def_thread is just for options, it's not a real job
	395	*/
	396	if (td == &def_thread)
	397	return 0;
	398
	399	engine = get_engine_name(td->o.ioengine);
	400	td->io_ops = load_ioengine(td, engine);
	401	if (!td->io_ops) {
	402	log_err("fio: failed to load engine %s\n", engine);
	403	goto err;
	404	}
	405
	406	if (td->o.use_thread)
	407	nr_thread++;
	408	else
	409	nr_process++;
	410
	411	if (td->o.odirect)
	412	td->io_ops->flags \|= FIO_RAWIO;
	413
	414	file_alloced = 0;
	415	if (!td->o.filename && !td->files_index) {
	416	file_alloced = 1;
	417
	418	if (td->o.nr_files == 1 && exists_and_not_file(jobname))
	419	add_file(td, jobname);
	420	else {
	421	for (i = 0; i < td->o.nr_files; i++) {
	422	sprintf(fname, "%s.%d.%d", jobname, td->thread_number, i);
	423	add_file(td, fname);
	424	}
	425	}
	426	}
	427
	428	if (fixup_options(td))
	429	goto err;
	430
	431	for_each_file(td, f, i) {
	432	if (td->o.directory && f->filetype == FIO_TYPE_FILE) {
	433	sprintf(fname, "%s/%s", td->o.directory, f->file_name);
	434	f->file_name = strdup(fname);
	435	}
	436	}
	437
	438	td->mutex = fio_sem_init(0);
	439
	440	td->ts.clat_stat[0].min_val = td->ts.clat_stat[1].min_val = ULONG_MAX;
	441	td->ts.slat_stat[0].min_val = td->ts.slat_stat[1].min_val = ULONG_MAX;
	442	td->ts.bw_stat[0].min_val = td->ts.bw_stat[1].min_val = ULONG_MAX;
	443
	444	if ((td->o.stonewall \|\| td->o.numjobs > 1) && prev_group_jobs) {
	445	prev_group_jobs = 0;
	446	groupid++;
	447	}
	448
	449	td->groupid = groupid;
	450	prev_group_jobs++;
	451
	452	if (init_random_state(td))
	453	goto err;
	454
	455	if (setup_rate(td))
	456	goto err;
	457
	458	if (td->o.write_lat_log) {
	459	setup_log(&td->ts.slat_log);
	460	setup_log(&td->ts.clat_log);
	461	}
	462	if (td->o.write_bw_log)
	463	setup_log(&td->ts.bw_log);
	464
	465	if (!td->o.name)
	466	td->o.name = strdup(jobname);
	467
	468	if (!terse_output) {
	469	if (!job_add_num) {
	470	if (!strcmp(td->io_ops->name, "cpuio"))
	471	log_info("%s: ioengine=cpu, cpuload=%u, cpucycle=%u\n", td->o.name, td->o.cpuload, td->o.cpucycle);
	472	else {
	473	char c1, c2, c3, c4;
	474
	475	c1 = to_kmg(td->o.min_bs[DDIR_READ]);
	476	c2 = to_kmg(td->o.max_bs[DDIR_READ]);
	477	c3 = to_kmg(td->o.min_bs[DDIR_WRITE]);
	478	c4 = to_kmg(td->o.max_bs[DDIR_WRITE]);
	479
	480	log_info("%s: (g=%d): rw=%s, bs=%s-%s/%s-%s, ioengine=%s, iodepth=%u\n", td->o.name, td->groupid, ddir_str[td->o.td_ddir], c1, c2, c3, c4, td->io_ops->name, td->o.iodepth);
	481
	482	free(c1);
	483	free(c2);
	484	free(c3);
	485	free(c4);
	486	}
	487	} else if (job_add_num == 1)
	488	log_info("...\n");
	489	}
	490
	491	/*
	492	* recurse add identical jobs, clear numjobs and stonewall options
	493	* as they don't apply to sub-jobs
	494	*/
	495	numjobs = td->o.numjobs;
	496	while (--numjobs) {
	497	struct thread_data *td_new = get_new_job(0, td);
	498
	499	if (!td_new)
	500	goto err;
	501
	502	td_new->o.numjobs = 1;
	503	td_new->o.stonewall = 0;
	504
	505	if (file_alloced) {
	506	td_new->o.filename = NULL;
	507	td_new->files_index = 0;
	508	td_new->files = NULL;
	509	}
	510
	511	job_add_num = numjobs - 1;
	512
	513	if (add_job(td_new, jobname, job_add_num))
	514	goto err;
	515	}
	516
	517	if (td->o.numjobs > 1) {
	518	groupid++;
	519	prev_group_jobs = 0;
	520	}
	521
	522	return 0;
	523	err:
	524	put_job(td);
	525	return -1;
	526	}
	527
	528	static int is_empty_or_comment(char *line)
	529	{
	530	unsigned int i;
	531
	532	for (i = 0; i < strlen(line); i++) {
	533	if (line[i] == ';')
	534	return 1;
	535	if (line[i] == '#')
	536	return 1;
	537	if (!isspace(line[i]) && !iscntrl(line[i]))
	538	return 0;
	539	}
	540
	541	return 1;
	542	}
	543
	544	/*
	545	* This is our [ini] type file parser.
	546	*/
	547	static int parse_jobs_ini(char *file, int stonewall_flag)
	548	{
	549	unsigned int global;
	550	struct thread_data *td;
	551	char string, name;
	552	fpos_t off;
	553	FILE *f;
	554	char *p;
	555	int ret = 0, stonewall;
	556
	557	f = fopen(file, "r");
	558	if (!f) {
	559	perror("fopen job file");
	560	return 1;
	561	}
	562
	563	string = malloc(4096);
	564	name = malloc(256);
	565	memset(name, 0, 256);
	566
	567	stonewall = stonewall_flag;
	568	do {
	569	p = fgets(string, 4095, f);
	570	if (!p)
	571	break;
	572	if (is_empty_or_comment(p))
	573	continue;
	574	if (sscanf(p, "[%255s]", name) != 1)
	575	continue;
	576
	577	global = !strncmp(name, "global", 6);
	578
	579	name[strlen(name) - 1] = '\0';
	580
	581	td = get_new_job(global, &def_thread);
	582	if (!td) {
	583	ret = 1;
	584	break;
	585	}
	586
	587	/*
	588	* Seperate multiple job files by a stonewall
	589	*/
	590	if (!global && stonewall) {
	591	td->o.stonewall = stonewall;
	592	stonewall = 0;
	593	}
	594
	595	fgetpos(f, &off);
	596	while ((p = fgets(string, 4096, f)) != NULL) {
	597	if (is_empty_or_comment(p))
	598	continue;
	599
	600	strip_blank_front(&p);
	601
	602	if (p[0] == '[')
	603	break;
	604
	605	strip_blank_end(p);
	606
	607	fgetpos(f, &off);
	608
	609	/*
	610	* Don't break here, continue parsing options so we
	611	* dump all the bad ones. Makes trial/error fixups
	612	* easier on the user.
	613	*/
	614	ret \|= fio_option_parse(td, p);
	615	}
	616
	617	if (!ret) {
	618	fsetpos(f, &off);
	619	ret = add_job(td, name, 0);
	620	} else {
	621	log_err("fio: job %s dropped\n", name);
	622	put_job(td);
	623	}
	624	} while (!ret);
	625
	626	free(string);
	627	free(name);
	628	fclose(f);
	629	return ret;
	630	}
	631
	632	static int fill_def_thread(void)
	633	{
	634	memset(&def_thread, 0, sizeof(def_thread));
	635
	636	if (fio_getaffinity(getpid(), &def_thread.o.cpumask) == -1) {
	637	perror("sched_getaffinity");
	638	return 1;
	639	}
	640
	641	/*
	642	* fill default options
	643	*/
	644	fio_fill_default_options(&def_thread);
	645
	646	def_thread.o.timeout = def_timeout;
	647	def_thread.o.write_bw_log = write_bw_log;
	648	def_thread.o.write_lat_log = write_lat_log;
	649
	650	#ifdef FIO_HAVE_DISK_UTIL
	651	def_thread.o.do_disk_util = 1;
	652	#endif
	653
	654	return 0;
	655	}
	656
	657	static void free_shm(void)
	658	{
	659	struct shmid_ds sbuf;
	660
	661	if (threads) {
	662	shmdt((void *) threads);
	663	threads = NULL;
	664	shmctl(shm_id, IPC_RMID, &sbuf);
	665	}
	666	}
	667
	668	/*
	669	* The thread area is shared between the main process and the job
	670	* threads/processes. So setup a shared memory segment that will hold
	671	* all the job info.
	672	*/
	673	static int setup_thread_area(void)
	674	{
	675	/*
	676	* 1024 is too much on some machines, scale max_jobs if
	677	* we get a failure that looks like too large a shm segment
	678	*/
	679	do {
	680	size_t size = max_jobs * sizeof(struct thread_data);
	681
	682	shm_id = shmget(0, size, IPC_CREAT \| 0600);
	683	if (shm_id != -1)
	684	break;
	685	if (errno != EINVAL) {
	686	perror("shmget");
	687	break;
	688	}
	689
	690	max_jobs >>= 1;
	691	} while (max_jobs);
	692
	693	if (shm_id == -1)
	694	return 1;
	695
	696	threads = shmat(shm_id, NULL, 0);
	697	if (threads == (void *) -1) {
	698	perror("shmat");
	699	return 1;
	700	}
	701
	702	atexit(free_shm);
	703	return 0;
	704	}
	705
	706	static void usage(void)
	707	{
	708	printf("%s\n", fio_version_string);
	709	printf("\t--output\tWrite output to file\n");
	710	printf("\t--timeout\tRuntime in seconds\n");
	711	printf("\t--latency-log\tGenerate per-job latency logs\n");
	712	printf("\t--bandwidth-log\tGenerate per-job bandwidth logs\n");
	713	printf("\t--minimal\tMinimal (terse) output\n");
	714	printf("\t--version\tPrint version info and exit\n");
	715	printf("\t--help\t\tPrint this page\n");
	716	printf("\t--cmdhelp=cmd\tPrint command help, \"all\" for all of them\n");
	717	}
	718
	719	static int parse_cmd_line(int argc, char *argv[])
	720	{
	721	struct thread_data *td = NULL;
	722	int c, ini_idx = 0, lidx, ret, dont_add_job = 0;
	723
	724	while ((c = getopt_long_only(argc, argv, "", long_options, &lidx)) != -1) {
	725	switch (c) {
	726	case 't':
	727	def_timeout = atoi(optarg);
	728	break;
	729	case 'l':
	730	write_lat_log = 1;
	731	break;
	732	case 'w':
	733	write_bw_log = 1;
	734	break;
	735	case 'o':
	736	f_out = fopen(optarg, "w+");
	737	if (!f_out) {
	738	perror("fopen output");
	739	exit(1);
	740	}
	741	f_err = f_out;
	742	break;
	743	case 'm':
	744	terse_output = 1;
	745	break;
	746	case 'h':
	747	usage();
	748	exit(0);
	749	case 'c':
	750	exit(fio_show_option_help(optarg));
	751	case 'v':
	752	printf("%s\n", fio_version_string);
	753	exit(0);
	754	case FIO_GETOPT_JOB: {
	755	const char *opt = long_options[lidx].name;
	756	char *val = optarg;
	757
	758	if (!strncmp(opt, "name", 4) && td) {
	759	ret = add_job(td, td->o.name ?: "fio", 0);
	760	if (ret) {
	761	put_job(td);
	762	return 0;
	763	}
	764	td = NULL;
	765	}
	766	if (!td) {
	767	int global = !strncmp(val, "global", 6);
	768
	769	td = get_new_job(global, &def_thread);
	770	if (!td)
	771	return 0;
	772	}
	773
	774	ret = fio_cmd_option_parse(td, opt, val);
	775	if (ret)
	776	dont_add_job = 1;
	777	break;
	778	}
	779	default:
	780	break;
	781	}
	782	}
	783
	784	if (td) {
	785	if (dont_add_job)
	786	put_job(td);
	787	else {
	788	ret = add_job(td, td->o.name ?: "fio", 0);
	789	if (ret)
	790	put_job(td);
	791	}
	792	}
	793
	794	while (optind < argc) {
	795	ini_idx++;
	796	ini_file = realloc(ini_file, ini_idx * sizeof(char *));
	797	ini_file[ini_idx - 1] = strdup(argv[optind]);
	798	optind++;
	799	}
	800
	801	return ini_idx;
	802	}
	803
	804
	805	int parse_options(int argc, char *argv[])
	806	{
	807	int job_files, i;
	808
	809	f_out = stdout;
	810	f_err = stderr;
	811
	812	fio_options_dup_and_init(long_options);
	813
	814	if (setup_thread_area())
	815	return 1;
	816	if (fill_def_thread())
	817	return 1;
	818
	819	job_files = parse_cmd_line(argc, argv);
	820
	821	for (i = 0; i < job_files; i++) {
	822	if (fill_def_thread())
	823	return 1;
	824	if (parse_jobs_ini(ini_file[i], i))
	825	return 1;
	826	free(ini_file[i]);
	827	}
	828
	829	free(ini_file);
	830
	831	if (!thread_number) {
	832	log_err("No jobs defined(s)\n");
	833	return 1;
	834	}
	835
	836	return 0;
	837	}