[fio.git] / fio-ini.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <ctype.h>
#include <string.h>
#include <errno.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <sys/stat.h>

#include "fio.h"

#define DEF_BS		(4096)
#define DEF_TIMEOUT	(0)
#define DEF_RATE_CYCLE	(1000)
#define DEF_ODIRECT	(1)
#define DEF_IO_ENGINE	(FIO_SYNCIO)
#define DEF_IO_ENGINE_NAME	"sync"
#define DEF_SEQUENTIAL	(1)
#define DEF_RAND_REPEAT	(1)
#define DEF_OVERWRITE	(1)
#define DEF_CREATE	(1)
#define DEF_INVALIDATE	(1)
#define DEF_SYNCIO	(0)
#define DEF_RANDSEED	(0xb1899bedUL)
#define DEF_BWAVGTIME	(500)
#define DEF_CREATE_SER	(1)
#define DEF_CREATE_FSYNC	(1)
#define DEF_LOOPS	(1)
#define DEF_VERIFY	(0)
#define DEF_STONEWALL	(0)
#define DEF_NUMJOBS	(1)
#define DEF_USE_THREAD	(0)
#define DEF_FILE_SIZE	(1024 * 1024 * 1024UL)

static char fio_version_string[] = "fio 1.1";

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

struct thread_data def_thread;
struct thread_data *threads = NULL;

int rate_quit = 0;
int write_lat_log = 0;
int write_bw_log = 0;
int exitall_on_terminate = 0;

static int setup_rate(struct thread_data *td)
{
	int nr_reads_per_sec;

	if (!td->rate)
		return 0;

	if (td->rate < td->ratemin) {
		fprintf(stderr, "min rate larger than nominal rate\n");
		return -1;
	}

	nr_reads_per_sec = (td->rate * 1024) / td->min_bs;
	td->rate_usec_cycle = 1000000 / nr_reads_per_sec;
	td->rate_pending_usleep = 0;
	return 0;
}

static void setup_log(struct io_log **log)
{
	struct io_log *l = malloc(sizeof(*l));

	l->nr_samples = 0;
	l->max_samples = 1024;
	l->log = malloc(l->max_samples * sizeof(struct io_sample));
	*log = l;
}

void finish_log(struct thread_data *td, struct io_log *log, const char *name)
{
	char file_name[128];
	FILE *f;
	unsigned int i;

	sprintf(file_name, "client%d_%s.log", td->thread_number, name);
	f = fopen(file_name, "w");
	if (!f) {
		perror("fopen log");
		return;
	}

	for (i = 0; i < log->nr_samples; i++)
		fprintf(f, "%lu, %lu, %u\n", log->log[i].time, log->log[i].val, log->log[i].ddir);

	fclose(f);
	free(log->log);
	free(log);
}

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++];
	memset(td, 0, sizeof(*td));

	td->fd = -1;
	td->thread_number = thread_number;

	td->ddir = parent->ddir;
	td->ioprio = parent->ioprio;
	td->sequential = parent->sequential;
	td->bs = parent->bs;
	td->min_bs = parent->min_bs;
	td->max_bs = parent->max_bs;
	td->odirect = parent->odirect;
	td->thinktime = parent->thinktime;
	td->fsync_blocks = parent->fsync_blocks;
	td->start_delay = parent->start_delay;
	td->timeout = parent->timeout;
	td->io_engine = parent->io_engine;
	td->create_file = parent->create_file;
	td->overwrite = parent->overwrite;
	td->invalidate_cache = parent->invalidate_cache;
	td->file_size = parent->file_size;
	td->file_offset = parent->file_offset;
	td->rate = parent->rate;
	td->ratemin = parent->ratemin;
	td->ratecycle = parent->ratecycle;
	td->iodepth = parent->iodepth;
	td->sync_io = parent->sync_io;
	td->mem_type = parent->mem_type;
	td->bw_avg_time = parent->bw_avg_time;
	td->create_serialize = parent->create_serialize;
	td->create_fsync = parent->create_fsync;
	td->loops = parent->loops;
	td->verify = parent->verify;
	td->stonewall = parent->stonewall;
	td->numjobs = parent->numjobs;
	td->use_thread = parent->use_thread;
	td->do_disk_util = parent->do_disk_util;
	memcpy(&td->cpumask, &parent->cpumask, sizeof(td->cpumask));
	strcpy(td->io_engine_name, parent->io_engine_name);

	return td;
}

static void put_job(struct thread_data *td)
{
	memset(&threads[td->thread_number - 1], 0, sizeof(*td));
	thread_number--;
}

static int add_job(struct thread_data *td, const char *jobname, int prioclass,
		   int prio)
{
	char *ddir_str[] = { "read", "write", "randread", "randwrite" };
	struct stat sb;
	int numjobs, ddir;

#ifndef FIO_HAVE_LIBAIO
	if (td->io_engine == FIO_LIBAIO) {
		fprintf(stderr, "Linux libaio not available\n");
		return 1;
	}
#endif
#ifndef FIO_HAVE_POSIXAIO
	if (td->io_engine == FIO_POSIXAIO) {
		fprintf(stderr, "posix aio not available\n");
		return 1;
	}
#endif
#ifdef FIO_HAVE_IOPRIO
	td->ioprio = (prioclass << IOPRIO_CLASS_SHIFT) | prio;
#endif

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

	if (td->io_engine & FIO_SYNCIO)
		td->iodepth = 1;
	else {
		if (!td->iodepth)
			td->iodepth = 1;
	}

	td->filetype = FIO_TYPE_FILE;
	if (!stat(jobname, &sb) && S_ISBLK(sb.st_mode))
		td->filetype = FIO_TYPE_BD;

	if (td->filetype == FIO_TYPE_FILE) {
		if (td->directory[0] != '\0')
			sprintf(td->file_name, "%s/%s.%d", td->directory, jobname, td->thread_number);
		else
			sprintf(td->file_name, "%s.%d", jobname, td->thread_number);
	} else
		strcpy(td->file_name, jobname);

	sem_init(&td->mutex, 0, 0);

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

	if (td->min_bs == -1U)
		td->min_bs = td->bs;
	if (td->max_bs == -1U)
		td->max_bs = td->bs;
	if (td_read(td))
		td->verify = 0;

	if (td->stonewall && td->thread_number > 1)
		groupid++;

	td->groupid = groupid;

	if (setup_rate(td))
		goto err;

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

	ddir = td->ddir + (!td->sequential << 1);
	printf("Client%d (g=%d): rw=%s, prio=%d/%d, odir=%d, bs=%d-%d, rate=%d, ioengine=%s, iodepth=%d\n", td->thread_number, td->groupid, ddir_str[ddir], prioclass, prio, td->odirect, td->min_bs, td->max_bs, td->rate, td->io_engine_name, td->iodepth);

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

		if (!td_new)
			goto err;

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

		if (add_job(td_new, jobname, prioclass, prio))
			goto err;
	}
	return 0;
err:
	put_job(td);
	return -1;
}

int init_random_state(struct thread_data *td)
{
	unsigned long seed;
	int fd, num_maps, blocks;

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

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

	close(fd);

	srand48_r(seed, &td->bsrange_state);
	srand48_r(seed, &td->verify_state);

	if (td->sequential)
		return 0;

	if (repeatable)
		seed = DEF_RANDSEED;

	blocks = (td->io_size + td->min_bs - 1) / td->min_bs;
	num_maps = blocks / BLOCKS_PER_MAP;
	td->file_map = malloc(num_maps * sizeof(long));
	td->num_maps = num_maps;
	memset(td->file_map, 0, num_maps * sizeof(long));

	srand48_r(seed, &td->random_state);
	return 0;
}

static void fill_cpu_mask(os_cpu_mask_t cpumask, int cpu)
{
#ifdef FIO_HAVE_CPU_AFFINITY
	unsigned int i;

	CPU_ZERO(&cpumask);

	for (i = 0; i < sizeof(int) * 8; i++) {
		if ((1 << i) & cpu)
			CPU_SET(i, &cpumask);
	}
#endif
}

static unsigned long get_mult(char c)
{
	switch (c) {
		case 'k':
		case 'K':
			return 1024;
		case 'm':
		case 'M':
			return 1024 * 1024;
		case 'g':
		case 'G':
			return 1024 * 1024 * 1024;
		default:
			return 1;
	}
}

/*
 * convert string after '=' into decimal value, noting any size suffix
 */
static int str_cnv(char *p, unsigned long long *val)
{
	char *str;
	int len;

	str = strstr(p, "=");
	if (!str)
		return 1;

	str++;
	len = strlen(str);

	*val = strtoul(str, NULL, 10);
	if (*val == ULONG_MAX && errno == ERANGE)
		return 1;

	*val *= get_mult(str[len - 2]);
	return 0;
}

static int check_strcnv(char *p, char *name, unsigned long long *val)
{
	if (!strstr(p, name))
		return 1;

	return str_cnv(p, val);
}

static void strip_blank_front(char **p)
{
	char *s = *p;

	while (isblank(*s))
		s++;
}

static void strip_blank_end(char *p)
{
	while (isblank(*p)) {
		*p = '\0';
		p--;
	}
}

typedef int (str_cb_fn)(struct thread_data *, char *);

static int check_str(char *p, char *name, str_cb_fn *cb, struct thread_data *td)
{
	char *s = strstr(p, name);

	if (!s)
		return 1;

	s = strstr(s, "=");
	if (!s)
		return 1;

	s++;
	strip_blank_front(&s);
	return cb(td, s);
}

static int check_strstore(char *p, char *name, char *dest)
{
	char *s = strstr(p, name);

	if (!s)
		return 1;

	s = strstr(p, "=");
	if (!s)
		return 1;

	s++;
	strip_blank_front(&s);

	strcpy(dest, s);

	s = dest + strlen(dest) - 1;
	strip_blank_end(s);
	return 0;
}

static int check_range(char *p, char *name, unsigned long *s, unsigned long *e)
{
	char str[128];
	char s1, s2;

	sprintf(str, "%s=%%lu%%c-%%lu%%c", name);
	if (sscanf(p, str, s, &s1, e, &s2) == 4) {
		*s *= get_mult(s1);
		*e *= get_mult(s2);
		return 0;
	}

	sprintf(str, "%s = %%lu%%c-%%lu%%c", name);
	if (sscanf(p, str, s, &s1, e, &s2) == 4) {
		*s *= get_mult(s1);
		*e *= get_mult(s2);
		return 0;
	}

	sprintf(str, "%s=%%lu-%%lu", name);
	if (sscanf(p, str, s, e) == 2)
		return 0;

	sprintf(str, "%s = %%lu-%%lu", name);
	if (sscanf(p, str, s, e) == 2)
		return 0;

	return 1;

}

static int check_int(char *p, char *name, unsigned int *val)
{
	char str[128];

	sprintf(str, "%s=%%d", name);
	if (sscanf(p, str, val) == 1)
		return 0;

	sprintf(str, "%s = %%d", name);
	if (sscanf(p, str, val) == 1)
		return 0;

	return 1;
}

static int check_strset(char *p, char *name)
{
	return strncmp(p, name, strlen(name));
}

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

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

	return 1;
}

static int str_rw_cb(struct thread_data *td, char *mem)
{
	if (!strncmp(mem, "read", 4) || !strncmp(mem, "0", 1)) {
		td->ddir = DDIR_READ;
		td->sequential = 1;
		return 0;
	} else if (!strncmp(mem, "randread", 8)) {
		td->ddir = DDIR_READ;
		td->sequential = 0;
		return 0;
	} else if (!strncmp(mem, "write", 5) || !strncmp(mem, "1", 1)) {
		td->ddir = DDIR_WRITE;
		td->sequential = 1;
		return 0;
	} else if (!strncmp(mem, "randwrite", 9)) {
		td->ddir = DDIR_WRITE;
		td->sequential = 0;
		return 0;
	}

	fprintf(stderr, "bad data direction: %s\n", mem);
	return 1;
}

static int str_verify_cb(struct thread_data *td, char *mem)
{
	if (!strncmp(mem, "0", 1)) {
		td->verify = VERIFY_NONE;
		return 0;
	} else if (!strncmp(mem, "md5", 3) || !strncmp(mem, "1", 1)) {
		td->verify = VERIFY_MD5;
		return 0;
	} else if (!strncmp(mem, "crc32", 5)) {
		td->verify = VERIFY_CRC32;
		return 0;
	}

	fprintf(stderr, "bad verify type: %s\n", mem);
	return 1;
}

static int str_mem_cb(struct thread_data *td, char *mem)
{
	if (!strncmp(mem, "malloc", 6)) {
		td->mem_type = MEM_MALLOC;
		return 0;
	} else if (!strncmp(mem, "shm", 3)) {
		td->mem_type = MEM_SHM;
		return 0;
	} else if (!strncmp(mem, "mmap", 4)) {
		td->mem_type = MEM_MMAP;
		return 0;
	}

	fprintf(stderr, "bad mem type: %s\n", mem);
	return 1;
}

static int str_ioengine_cb(struct thread_data *td, char *str)
{
	if (!strncmp(str, "linuxaio", 8) || !strncmp(str, "aio", 3) ||
	    !strncmp(str, "libaio", 6)) {
		strcpy(td->io_engine_name, "libaio");
		td->io_engine = FIO_LIBAIO;
		return 0;
	} else if (!strncmp(str, "posixaio", 8)) {
		strcpy(td->io_engine_name, "posixaio");
		td->io_engine = FIO_POSIXAIO;
		return 0;
	} else if (!strncmp(str, "sync", 4)) {
		strcpy(td->io_engine_name, "sync");
		td->io_engine = FIO_SYNCIO;
		return 0;
	} else if (!strncmp(str, "mmap", 4)) {
		strcpy(td->io_engine_name, "mmap");
		td->io_engine = FIO_MMAPIO;
		return 0;
	} else if (!strncmp(str, "sgio", 4)) {
		strcpy(td->io_engine_name, "sgio");
		td->io_engine = FIO_SGIO;
		return 0;
	}

	fprintf(stderr, "bad ioengine type: %s\n", str);
	return 1;
}


int parse_jobs_ini(char *file)
{
	unsigned int prioclass, prio, cpu, global;
	unsigned long long ull;
	unsigned long ul1, ul2;
	struct thread_data *td;
	char *string, *name;
	fpos_t off;
	FILE *f;
	char *p;

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

	string = malloc(4096);
	name = malloc(256);

	while ((p = fgets(string, 4096, f)) != NULL) {
		if (is_empty_or_comment(p))
			continue;
		if (sscanf(p, "[%s]", name) != 1)
			continue;

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

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

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

		prioclass = 2;
		prio = 4;

		fgetpos(f, &off);
		while ((p = fgets(string, 4096, f)) != NULL) {
			if (is_empty_or_comment(p))
				continue;
			if (strstr(p, "["))
				break;
			if (!check_int(p, "prio", &prio)) {
#ifndef FIO_HAVE_IOPRIO
				fprintf(stderr, "io priorities not available\n");
				return 1;
#endif
				fgetpos(f, &off);
				continue;
			}
			if (!check_int(p, "prioclass", &prioclass)) {
#ifndef FIO_HAVE_IOPRIO
				fprintf(stderr, "io priorities not available\n");
				return 1;
#endif
				fgetpos(f, &off);
				continue;
			}
			if (!check_int(p, "direct", &td->odirect)) {
				fgetpos(f, &off);
				continue;
			}
			if (!check_int(p, "rate", &td->rate)) {
				fgetpos(f, &off);
				continue;
			}
			if (!check_int(p, "ratemin", &td->ratemin)) {
				fgetpos(f, &off);
				continue;
			}
			if (!check_int(p, "ratecycle", &td->ratecycle)) {
				fgetpos(f, &off);
				continue;
			}
			if (!check_int(p, "thinktime", &td->thinktime)) {
				fgetpos(f, &off);
				continue;
			}
			if (!check_int(p, "cpumask", &cpu)) {
#ifndef FIO_HAVE_CPU_AFFINITY
				fprintf(stderr, "cpu affinity not available\n");
				return 1;
#endif
				fill_cpu_mask(td->cpumask, cpu);
				fgetpos(f, &off);
				continue;
			}
			if (!check_int(p, "fsync", &td->fsync_blocks)) {
				fgetpos(f, &off);
				continue;
			}
			if (!check_int(p, "startdelay", &td->start_delay)) {
				fgetpos(f, &off);
				continue;
			}
			if (!check_int(p, "timeout", &td->timeout)) {
				fgetpos(f, &off);
				continue;
			}
			if (!check_int(p, "invalidate",&td->invalidate_cache)) {
				fgetpos(f, &off);
				continue;
			}
			if (!check_int(p, "iodepth", &td->iodepth)) {
				fgetpos(f, &off);
				continue;
			}
			if (!check_int(p, "sync", &td->sync_io)) {
				fgetpos(f, &off);
				continue;
			}
			if (!check_int(p, "bwavgtime", &td->bw_avg_time)) {
				fgetpos(f, &off);
				continue;
			}
			if (!check_int(p, "create_serialize", &td->create_serialize)) {
				fgetpos(f, &off);
				continue;
			}
			if (!check_int(p, "create_fsync", &td->create_fsync)) {
				fgetpos(f, &off);
				continue;
			}
			if (!check_int(p, "loops", &td->loops)) {
				fgetpos(f, &off);
				continue;
			}
			if (!check_int(p, "numjobs", &td->numjobs)) {
				fgetpos(f, &off);
				continue;
			}
			if (!check_int(p, "overwrite", &td->overwrite)) {
				fgetpos(f, &off);
				continue;
			}
			if (!check_range(p, "bsrange", &ul1, &ul2)) {
				if (ul1 > ul2) {
					td->max_bs = ul1;
					td->min_bs = ul2;
				} else {
					td->max_bs = ul2;
					td->min_bs = ul1;
				}
				fgetpos(f, &off);
				continue;
			}
			if (!check_strcnv(p, "bs", &ull)) {
				td->bs = ull;
				fgetpos(f, &off);
				continue;
			}
			if (!check_strcnv(p, "size", &td->file_size)) {
				fgetpos(f, &off);
				continue;
			}
			if (!check_strcnv(p, "offset", &td->file_offset)) {
				fgetpos(f, &off);
				continue;
			}
			if (!check_strstore(p, "directory", td->directory)) {
				fgetpos(f, &off);
				continue;
			}
			if (!check_str(p, "mem", str_mem_cb, td)) {
				fgetpos(f, &off);
				continue;
			}
			if (!check_str(p, "verify", str_verify_cb, td)) {
				fgetpos(f, &off);
				continue;
			}
			if (!check_str(p, "rw", str_rw_cb, td)) {
				fgetpos(f, &off);
				continue;
			}
			if (!check_str(p, "ioengine", str_ioengine_cb, td)) {
				fgetpos(f, &off);
				continue;
			}
			if (!check_strset(p, "create")) {
				td->create_file = 1;
				fgetpos(f, &off);
				continue;
			}
			if (!check_strset(p, "exitall")) {
				exitall_on_terminate = 1;
				fgetpos(f, &off);
				continue;
			}
			if (!check_strset(p, "stonewall")) {
				td->stonewall = 1;
				fgetpos(f, &off);
				continue;
			}
			if (!check_strset(p, "thread")) {
				td->use_thread = 1;
				fgetpos(f, &off);
				continue;
			}

			printf("Client%d: bad option %s\n",td->thread_number,p);
		}
		fsetpos(f, &off);

		if (add_job(td, name, prioclass, prio))
			return 1;
	}

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

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

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

	/*
	 * fill globals
	 */
	def_thread.ddir = DDIR_READ;
	def_thread.bs = DEF_BS;
	def_thread.min_bs = -1;
	def_thread.max_bs = -1;
	def_thread.io_engine = DEF_IO_ENGINE;
	strcpy(def_thread.io_engine_name, DEF_IO_ENGINE_NAME);
	def_thread.odirect = DEF_ODIRECT;
	def_thread.ratecycle = DEF_RATE_CYCLE;
	def_thread.sequential = DEF_SEQUENTIAL;
	def_thread.timeout = DEF_TIMEOUT;
	def_thread.create_file = DEF_CREATE;
	def_thread.overwrite = DEF_OVERWRITE;
	def_thread.invalidate_cache = DEF_INVALIDATE;
	def_thread.sync_io = DEF_SYNCIO;
	def_thread.mem_type = MEM_MALLOC;
	def_thread.bw_avg_time = DEF_BWAVGTIME;
	def_thread.create_serialize = DEF_CREATE_SER;
	def_thread.create_fsync = DEF_CREATE_FSYNC;
	def_thread.loops = DEF_LOOPS;
	def_thread.verify = DEF_VERIFY;
	def_thread.stonewall = DEF_STONEWALL;
	def_thread.numjobs = DEF_NUMJOBS;
	def_thread.use_thread = DEF_USE_THREAD;
#ifdef FIO_HAVE_DISK_UTIL
	def_thread.do_disk_util = 1;
#endif

	return 0;
}

static void parse_cmd_line(int argc, char *argv[])
{
	int c;

	while ((c = getopt(argc, argv, "s:b:t:r:R:o:f:lwv")) != EOF) {
		switch (c) {
			case 's':
				def_thread.sequential = !!atoi(optarg);
				break;
			case 'b':
				def_thread.bs = atoi(optarg);
				def_thread.bs <<= 10;
				if (!def_thread.bs) {
					printf("bad block size\n");
					def_thread.bs = DEF_BS;
				}
				break;
			case 't':
				def_thread.timeout = atoi(optarg);
				break;
			case 'r':
				repeatable = !!atoi(optarg);
				break;
			case 'R':
				rate_quit = !!atoi(optarg);
				break;
			case 'o':
				def_thread.odirect = !!atoi(optarg);
				break;
			case 'f':
				ini_file = strdup(optarg);
				break;
			case 'l':
				write_lat_log = 1;
				break;
			case 'w':
				write_bw_log = 1;
				break;
			case 'v':
				printf("%s\n", fio_version_string);
				exit(0);
		}
	}
}

static void free_shm(void)
{
	struct shmid_ds sbuf;

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

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 {
		int s = max_jobs * sizeof(struct thread_data);

		shm_id = shmget(0, s, 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;
}

int parse_options(int argc, char *argv[])
{
	if (setup_thread_area())
		return 1;
	if (fill_def_thread())
		return 1;

	parse_cmd_line(argc, argv);

	if (!ini_file) {
		printf("Need job file\n");
		return 1;
	}

	if (parse_jobs_ini(ini_file))
		return 1;

	return 0;
}
Commit	Line	Data
ebac4655 JA	1	#include <stdio.h>
	2	#include <stdlib.h>
	3	#include <unistd.h>
	4	#include <fcntl.h>
	5	#include <ctype.h>
	6	#include <string.h>
	7	#include <errno.h>
	8	#include <sys/ipc.h>
	9	#include <sys/shm.h>
	10	#include <sys/types.h>
	11	#include <sys/stat.h>
	12
	13	#include "fio.h"
	14
	15	#define DEF_BS (4096)
	16	#define DEF_TIMEOUT (0)
	17	#define DEF_RATE_CYCLE (1000)
	18	#define DEF_ODIRECT (1)
	19	#define DEF_IO_ENGINE (FIO_SYNCIO)
	20	#define DEF_IO_ENGINE_NAME "sync"
	21	#define DEF_SEQUENTIAL (1)
	22	#define DEF_RAND_REPEAT (1)
	23	#define DEF_OVERWRITE (1)
	24	#define DEF_CREATE (1)
	25	#define DEF_INVALIDATE (1)
	26	#define DEF_SYNCIO (0)
	27	#define DEF_RANDSEED (0xb1899bedUL)
	28	#define DEF_BWAVGTIME (500)
	29	#define DEF_CREATE_SER (1)
	30	#define DEF_CREATE_FSYNC (1)
	31	#define DEF_LOOPS (1)
	32	#define DEF_VERIFY (0)
	33	#define DEF_STONEWALL (0)
	34	#define DEF_NUMJOBS (1)
	35	#define DEF_USE_THREAD (0)
	36	#define DEF_FILE_SIZE (1024 * 1024 * 1024UL)
	37
3e7ba7c5	38	static char fio_version_string[] = "fio 1.1";
ebac4655 JA	39
	40	static int repeatable = DEF_RAND_REPEAT;
	41	static char *ini_file;
	42	static int max_jobs = MAX_JOBS;
	43
	44	struct thread_data def_thread;
	45	struct thread_data *threads = NULL;
	46
	47	int rate_quit = 0;
	48	int write_lat_log = 0;
	49	int write_bw_log = 0;
	50	int exitall_on_terminate = 0;
	51
	52	static int setup_rate(struct thread_data *td)
	53	{
	54	int nr_reads_per_sec;
	55
	56	if (!td->rate)
	57	return 0;
	58
	59	if (td->rate < td->ratemin) {
	60	fprintf(stderr, "min rate larger than nominal rate\n");
	61	return -1;
	62	}
	63
	64	nr_reads_per_sec = (td->rate * 1024) / td->min_bs;
	65	td->rate_usec_cycle = 1000000 / nr_reads_per_sec;
	66	td->rate_pending_usleep = 0;
	67	return 0;
	68	}
	69
	70	static void setup_log(struct io_log **log)
	71	{
	72	struct io_log l = malloc(sizeof(l));
	73
	74	l->nr_samples = 0;
	75	l->max_samples = 1024;
	76	l->log = malloc(l->max_samples * sizeof(struct io_sample));
	77	*log = l;
	78	}
	79
	80	void finish_log(struct thread_data td, struct io_log log, const char *name)
	81	{
	82	char file_name[128];
	83	FILE *f;
	84	unsigned int i;
	85
	86	sprintf(file_name, "client%d_%s.log", td->thread_number, name);
	87	f = fopen(file_name, "w");
	88	if (!f) {
	89	perror("fopen log");
	90	return;
	91	}
	92
	93	for (i = 0; i < log->nr_samples; i++)
	94	fprintf(f, "%lu, %lu, %u\n", log->log[i].time, log->log[i].val, log->log[i].ddir);
	95
	96	fclose(f);
	97	free(log->log);
	98	free(log);
	99	}
	100
	101	static struct thread_data get_new_job(int global, struct thread_data parent)
	102	{
103	struct thread_data *td;
104
105	if (global)
106	return &def_thread;
107	if (thread_number >= max_jobs)
108	return NULL;
109
110	td = &threads[thread_number++];
111	memset(td, 0, sizeof(*td));
112
113	td->fd = -1;
114	td->thread_number = thread_number;
115
116	td->ddir = parent->ddir;
117	td->ioprio = parent->ioprio;
118	td->sequential = parent->sequential;
119	td->bs = parent->bs;
120	td->min_bs = parent->min_bs;
121	td->max_bs = parent->max_bs;
122	td->odirect = parent->odirect;
123	td->thinktime = parent->thinktime;
124	td->fsync_blocks = parent->fsync_blocks;
125	td->start_delay = parent->start_delay;
126	td->timeout = parent->timeout;
127	td->io_engine = parent->io_engine;
128	td->create_file = parent->create_file;
129	td->overwrite = parent->overwrite;
130	td->invalidate_cache = parent->invalidate_cache;
131	td->file_size = parent->file_size;
132	td->file_offset = parent->file_offset;
133	td->rate = parent->rate;
134	td->ratemin = parent->ratemin;
135	td->ratecycle = parent->ratecycle;
136	td->iodepth = parent->iodepth;
137	td->sync_io = parent->sync_io;
138	td->mem_type = parent->mem_type;
139	td->bw_avg_time = parent->bw_avg_time;
140	td->create_serialize = parent->create_serialize;
141	td->create_fsync = parent->create_fsync;
142	td->loops = parent->loops;
143	td->verify = parent->verify;
144	td->stonewall = parent->stonewall;
145	td->numjobs = parent->numjobs;
146	td->use_thread = parent->use_thread;
147	td->do_disk_util = parent->do_disk_util;
148	memcpy(&td->cpumask, &parent->cpumask, sizeof(td->cpumask));
149	strcpy(td->io_engine_name, parent->io_engine_name);
150
151	return td;
152	}
153
154	static void put_job(struct thread_data *td)
155	{
156	memset(&threads[td->thread_number - 1], 0, sizeof(*td));
157	thread_number--;
158	}
159
160	static int add_job(struct thread_data td, const char jobname, int prioclass,
161	int prio)
162	{
163	char *ddir_str[] = { "read", "write", "randread", "randwrite" };
164	struct stat sb;
165	int numjobs, ddir;
166
167	#ifndef FIO_HAVE_LIBAIO
168	if (td->io_engine == FIO_LIBAIO) {
169	fprintf(stderr, "Linux libaio not available\n");
170	return 1;
171	}
172	#endif
173	#ifndef FIO_HAVE_POSIXAIO
174	if (td->io_engine == FIO_POSIXAIO) {
175	fprintf(stderr, "posix aio not available\n");
176	return 1;
177	}
178	#endif
179	#ifdef FIO_HAVE_IOPRIO
180	td->ioprio = (prioclass << IOPRIO_CLASS_SHIFT) \| prio;
181	#endif
182
183	/*
184	* the def_thread is just for options, it's not a real job
185	*/
186	if (td == &def_thread)
187	return 0;
188
189	if (td->io_engine & FIO_SYNCIO)
190	td->iodepth = 1;
191	else {
192	if (!td->iodepth)
193	td->iodepth = 1;
194	}
195
196	td->filetype = FIO_TYPE_FILE;
197	if (!stat(jobname, &sb) && S_ISBLK(sb.st_mode))
198	td->filetype = FIO_TYPE_BD;
199
200	if (td->filetype == FIO_TYPE_FILE) {
201	if (td->directory[0] != '\0')
202	sprintf(td->file_name, "%s/%s.%d", td->directory, jobname, td->thread_number);
203	else
204	sprintf(td->file_name, "%s.%d", jobname, td->thread_number);
205	} else
206	strcpy(td->file_name, jobname);
207
208	sem_init(&td->mutex, 0, 0);
209
210	td->clat_stat[0].min_val = td->clat_stat[1].min_val = ULONG_MAX;
211	td->slat_stat[0].min_val = td->slat_stat[1].min_val = ULONG_MAX;
212	td->bw_stat[0].min_val = td->bw_stat[1].min_val = ULONG_MAX;
213
214	if (td->min_bs == -1U)
215	td->min_bs = td->bs;
216	if (td->max_bs == -1U)
217	td->max_bs = td->bs;
218	if (td_read(td))
219	td->verify = 0;
220
221	if (td->stonewall && td->thread_number > 1)
222	groupid++;
223
224	td->groupid = groupid;
225
226	if (setup_rate(td))
227	goto err;
228
229	if (write_lat_log) {
230	setup_log(&td->slat_log);
231	setup_log(&td->clat_log);
232	}
233	if (write_bw_log)
234	setup_log(&td->bw_log);
235
236	ddir = td->ddir + (!td->sequential << 1);
237	printf("Client%d (g=%d): rw=%s, prio=%d/%d, odir=%d, bs=%d-%d, rate=%d, ioengine=%s, iodepth=%d\n", td->thread_number, td->groupid, ddir_str[ddir], prioclass, prio, td->odirect, td->min_bs, td->max_bs, td->rate, td->io_engine_name, td->iodepth);
238
239	/*
240	* recurse add identical jobs, clear numjobs and stonewall options
241	* as they don't apply to sub-jobs
242	*/
243	numjobs = td->numjobs;
244	while (--numjobs) {
245	struct thread_data *td_new = get_new_job(0, td);
246
247	if (!td_new)
248	goto err;
249
250	td_new->numjobs = 1;
251	td_new->stonewall = 0;
252
253	if (add_job(td_new, jobname, prioclass, prio))
254	goto err;
255	}
256	return 0;
257	err:
258	put_job(td);
259	return -1;
260	}
261
262	int init_random_state(struct thread_data *td)
263	{
264	unsigned long seed;
265	int fd, num_maps, blocks;
266
267	fd = open("/dev/random", O_RDONLY);
268	if (fd == -1) {
269	td_verror(td, errno);
270	return 1;
271	}
272
273	if (read(fd, &seed, sizeof(seed)) < (int) sizeof(seed)) {
274	td_verror(td, EIO);
275	close(fd);
276	return 1;
277	}
278
279	close(fd);
280
281	srand48_r(seed, &td->bsrange_state);
282	srand48_r(seed, &td->verify_state);
283
284	if (td->sequential)
285	return 0;
286
287	if (repeatable)
288	seed = DEF_RANDSEED;
289
290	blocks = (td->io_size + td->min_bs - 1) / td->min_bs;
291	num_maps = blocks / BLOCKS_PER_MAP;
292	td->file_map = malloc(num_maps * sizeof(long));
293	td->num_maps = num_maps;
294	memset(td->file_map, 0, num_maps * sizeof(long));
295
296	srand48_r(seed, &td->random_state);
297	return 0;
298	}
299
300	static void fill_cpu_mask(os_cpu_mask_t cpumask, int cpu)
301	{
302	#ifdef FIO_HAVE_CPU_AFFINITY
303	unsigned int i;
304
305	CPU_ZERO(&cpumask);
306
307	for (i = 0; i < sizeof(int) * 8; i++) {
308	if ((1 << i) & cpu)
309	CPU_SET(i, &cpumask);
310	}
311	#endif
312	}
313
314	static unsigned long get_mult(char c)
315	{
316	switch (c) {
317	case 'k':
318	case 'K':
319	return 1024;
320	case 'm':
321	case 'M':
322	return 1024 * 1024;
323	case 'g':
324	case 'G':
325	return 1024 * 1024 * 1024;
326	default:
327	return 1;
328	}
329	}
330
331	/*
332	* convert string after '=' into decimal value, noting any size suffix
333	*/
334	static int str_cnv(char p, unsigned long long val)
335	{
336	char *str;
337	int len;
338
339	str = strstr(p, "=");
340	if (!str)
341	return 1;
342
343	str++;
344	len = strlen(str);
345
346	*val = strtoul(str, NULL, 10);
347	if (*val == ULONG_MAX && errno == ERANGE)
348	return 1;
349
350	val = get_mult(str[len - 2]);
351	return 0;
352	}
353
354	static int check_strcnv(char p, char name, unsigned long long *val)
355	{
356	if (!strstr(p, name))
357	return 1;
358
359	return str_cnv(p, val);
360	}
361
362	static void strip_blank_front(char **p)
363	{
364	char s = p;
365
366	while (isblank(*s))
367	s++;
368	}
369
370	static void strip_blank_end(char *p)
371	{
372	while (isblank(*p)) {
373	*p = '\0';
374	p--;
375	}
376	}
377
378	typedef int (str_cb_fn)(struct thread_data , char );
379
380	static int check_str(char p, char name, str_cb_fn cb, struct thread_data td)
381	{
382	char *s = strstr(p, name);
383
384	if (!s)
385	return 1;
386
387	s = strstr(s, "=");
388	if (!s)
389	return 1;
390
391	s++;
392	strip_blank_front(&s);
393	return cb(td, s);
394	}
395
396	static int check_strstore(char p, char name, char *dest)
397	{
398	char *s = strstr(p, name);
399
400	if (!s)
401	return 1;
402
403	s = strstr(p, "=");
404	if (!s)
405	return 1;
406
407	s++;
408	strip_blank_front(&s);
409
410	strcpy(dest, s);
411
412	s = dest + strlen(dest) - 1;
413	strip_blank_end(s);
414	return 0;
415	}
416
417	static int check_range(char p, char name, unsigned long s, unsigned long e)
418	{
419	char str[128];
420	char s1, s2;
421
422	sprintf(str, "%s=%%lu%%c-%%lu%%c", name);
423	if (sscanf(p, str, s, &s1, e, &s2) == 4) {
424	s = get_mult(s1);
425	e = get_mult(s2);
426	return 0;
427	}
428
429	sprintf(str, "%s = %%lu%%c-%%lu%%c", name);
430	if (sscanf(p, str, s, &s1, e, &s2) == 4) {
431	s = get_mult(s1);
432	e = get_mult(s2);
433	return 0;
434	}
435
436	sprintf(str, "%s=%%lu-%%lu", name);
437	if (sscanf(p, str, s, e) == 2)
438	return 0;
439
440	sprintf(str, "%s = %%lu-%%lu", name);
441	if (sscanf(p, str, s, e) == 2)
442	return 0;
443
444	return 1;
445
446	}
447
448	static int check_int(char p, char name, unsigned int *val)
449	{
450	char str[128];
451
452	sprintf(str, "%s=%%d", name);
453	if (sscanf(p, str, val) == 1)
454	return 0;
455
456	sprintf(str, "%s = %%d", name);
457	if (sscanf(p, str, val) == 1)
458	return 0;
459
460	return 1;
461	}
462
463	static int check_strset(char p, char name)
464	{
465	return strncmp(p, name, strlen(name));
466	}
467
468	static int is_empty_or_comment(char *line)
469	{
470	unsigned int i;
471
472	for (i = 0; i < strlen(line); i++) {
473	if (line[i] == ';')
474	return 1;
475	if (!isspace(line[i]) && !iscntrl(line[i]))
476	return 0;
477	}
478
479	return 1;
480	}
481
482	static int str_rw_cb(struct thread_data td, char mem)
483	{
484	if (!strncmp(mem, "read", 4) \|\| !strncmp(mem, "0", 1)) {
485	td->ddir = DDIR_READ;
486	td->sequential = 1;
487	return 0;
488	} else if (!strncmp(mem, "randread", 8)) {
489	td->ddir = DDIR_READ;
490	td->sequential = 0;
491	return 0;
492	} else if (!strncmp(mem, "write", 5) \|\| !strncmp(mem, "1", 1)) {
493	td->ddir = DDIR_WRITE;
494	td->sequential = 1;
495	return 0;
496	} else if (!strncmp(mem, "randwrite", 9)) {
497	td->ddir = DDIR_WRITE;
498	td->sequential = 0;
499	return 0;
500	}
501
502	fprintf(stderr, "bad data direction: %s\n", mem);
503	return 1;
504	}
505
506	static int str_verify_cb(struct thread_data td, char mem)
507	{
508	if (!strncmp(mem, "0", 1)) {
509	td->verify = VERIFY_NONE;
510	return 0;
511	} else if (!strncmp(mem, "md5", 3) \|\| !strncmp(mem, "1", 1)) {
512	td->verify = VERIFY_MD5;
513	return 0;
514	} else if (!strncmp(mem, "crc32", 5)) {
515	td->verify = VERIFY_CRC32;
516	return 0;
517	}
518
519	fprintf(stderr, "bad verify type: %s\n", mem);
520	return 1;
521	}
522
523	static int str_mem_cb(struct thread_data td, char mem)
524	{
525	if (!strncmp(mem, "malloc", 6)) {
526	td->mem_type = MEM_MALLOC;
527	return 0;
528	} else if (!strncmp(mem, "shm", 3)) {
529	td->mem_type = MEM_SHM;
530	return 0;
531	} else if (!strncmp(mem, "mmap", 4)) {
532	td->mem_type = MEM_MMAP;
533	return 0;
534	}
535
536	fprintf(stderr, "bad mem type: %s\n", mem);
537	return 1;
538	}
539
540	static int str_ioengine_cb(struct thread_data td, char str)
541	{
542	if (!strncmp(str, "linuxaio", 8) \|\| !strncmp(str, "aio", 3) \|\|
543	!strncmp(str, "libaio", 6)) {
544	strcpy(td->io_engine_name, "libaio");
545	td->io_engine = FIO_LIBAIO;
546	return 0;
547	} else if (!strncmp(str, "posixaio", 8)) {
548	strcpy(td->io_engine_name, "posixaio");
549	td->io_engine = FIO_POSIXAIO;
550	return 0;
551	} else if (!strncmp(str, "sync", 4)) {
552	strcpy(td->io_engine_name, "sync");
553	td->io_engine = FIO_SYNCIO;
554	return 0;
555	} else if (!strncmp(str, "mmap", 4)) {
556	strcpy(td->io_engine_name, "mmap");
557	td->io_engine = FIO_MMAPIO;
558	return 0;
559	} else if (!strncmp(str, "sgio", 4)) {
560	strcpy(td->io_engine_name, "sgio");
561	td->io_engine = FIO_SGIO;
562	return 0;
563	}
564
565	fprintf(stderr, "bad ioengine type: %s\n", str);
566	return 1;
567	}
568
569
570	int parse_jobs_ini(char *file)
571	{
572	unsigned int prioclass, prio, cpu, global;
573	unsigned long long ull;
574	unsigned long ul1, ul2;
575	struct thread_data *td;
576	char string, name;
577	fpos_t off;
578	FILE *f;
579	char *p;
580
581	f = fopen(file, "r");
582	if (!f) {
583	perror("fopen");
584	return 1;
585	}
586
587	string = malloc(4096);
588	name = malloc(256);
589
590	while ((p = fgets(string, 4096, f)) != NULL) {
591	if (is_empty_or_comment(p))
592	continue;
593	if (sscanf(p, "[%s]", name) != 1)
594	continue;
595
596	global = !strncmp(name, "global", 6);
597
598	name[strlen(name) - 1] = '\0';
599
600	td = get_new_job(global, &def_thread);
601	if (!td)
602	return 1;
603
604	prioclass = 2;
605	prio = 4;
606
607	fgetpos(f, &off);
608	while ((p = fgets(string, 4096, f)) != NULL) {
609	if (is_empty_or_comment(p))
610	continue;
611	if (strstr(p, "["))
612	break;
613	if (!check_int(p, "prio", &prio)) {
614	#ifndef FIO_HAVE_IOPRIO
615	fprintf(stderr, "io priorities not available\n");
616	return 1;
617	#endif
618	fgetpos(f, &off);
619	continue;
620	}
621	if (!check_int(p, "prioclass", &prioclass)) {
622	#ifndef FIO_HAVE_IOPRIO
623	fprintf(stderr, "io priorities not available\n");
624	return 1;
625	#endif
626	fgetpos(f, &off);
627	continue;
628	}
629	if (!check_int(p, "direct", &td->odirect)) {
630	fgetpos(f, &off);
631	continue;
632	}
633	if (!check_int(p, "rate", &td->rate)) {
634	fgetpos(f, &off);
635	continue;
636	}
637	if (!check_int(p, "ratemin", &td->ratemin)) {
638	fgetpos(f, &off);
639	continue;
640	}
641	if (!check_int(p, "ratecycle", &td->ratecycle)) {
642	fgetpos(f, &off);
643	continue;
644	}
645	if (!check_int(p, "thinktime", &td->thinktime)) {
646	fgetpos(f, &off);
647	continue;
648	}
649	if (!check_int(p, "cpumask", &cpu)) {
650	#ifndef FIO_HAVE_CPU_AFFINITY
651	fprintf(stderr, "cpu affinity not available\n");
652	return 1;
653	#endif
654	fill_cpu_mask(td->cpumask, cpu);
655	fgetpos(f, &off);
656	continue;
657	}
658	if (!check_int(p, "fsync", &td->fsync_blocks)) {
659	fgetpos(f, &off);
660	continue;
661	}
662	if (!check_int(p, "startdelay", &td->start_delay)) {
663	fgetpos(f, &off);
664	continue;
665	}
666	if (!check_int(p, "timeout", &td->timeout)) {
667	fgetpos(f, &off);
668	continue;
669	}
670	if (!check_int(p, "invalidate",&td->invalidate_cache)) {
671	fgetpos(f, &off);
672	continue;
673	}
674	if (!check_int(p, "iodepth", &td->iodepth)) {
675	fgetpos(f, &off);
676	continue;
677	}
678	if (!check_int(p, "sync", &td->sync_io)) {
679	fgetpos(f, &off);
680	continue;
681	}
682	if (!check_int(p, "bwavgtime", &td->bw_avg_time)) {
683	fgetpos(f, &off);
684	continue;
685	}
686	if (!check_int(p, "create_serialize", &td->create_serialize)) {
687	fgetpos(f, &off);
688	continue;
689	}
690	if (!check_int(p, "create_fsync", &td->create_fsync)) {
691	fgetpos(f, &off);
692	continue;
693	}
694	if (!check_int(p, "loops", &td->loops)) {
695	fgetpos(f, &off);
696	continue;
697	}
698	if (!check_int(p, "numjobs", &td->numjobs)) {
699	fgetpos(f, &off);
700	continue;
701	}
702	if (!check_int(p, "overwrite", &td->overwrite)) {
703	fgetpos(f, &off);
704	continue;
705	}
706	if (!check_range(p, "bsrange", &ul1, &ul2)) {
707	if (ul1 > ul2) {
708	td->max_bs = ul1;
709	td->min_bs = ul2;
710	} else {
711	td->max_bs = ul2;
712	td->min_bs = ul1;
713	}
714	fgetpos(f, &off);
715	continue;
716	}
717	if (!check_strcnv(p, "bs", &ull)) {
718	td->bs = ull;
719	fgetpos(f, &off);
720	continue;
721	}
722	if (!check_strcnv(p, "size", &td->file_size)) {
723	fgetpos(f, &off);
724	continue;
725	}
726	if (!check_strcnv(p, "offset", &td->file_offset)) {
727	fgetpos(f, &off);
728	continue;
729	}
730	if (!check_strstore(p, "directory", td->directory)) {
731	fgetpos(f, &off);
732	continue;
733	}
734	if (!check_str(p, "mem", str_mem_cb, td)) {
735	fgetpos(f, &off);
736	continue;
737	}
738	if (!check_str(p, "verify", str_verify_cb, td)) {
739	fgetpos(f, &off);
740	continue;
741	}
742	if (!check_str(p, "rw", str_rw_cb, td)) {
743	fgetpos(f, &off);
744	continue;
745	}
746	if (!check_str(p, "ioengine", str_ioengine_cb, td)) {
747	fgetpos(f, &off);
748	continue;
749	}
750	if (!check_strset(p, "create")) {
751	td->create_file = 1;
752	fgetpos(f, &off);
753	continue;
754	}
755	if (!check_strset(p, "exitall")) {
756	exitall_on_terminate = 1;
757	fgetpos(f, &off);
758	continue;
759	}
760	if (!check_strset(p, "stonewall")) {
761	td->stonewall = 1;
762	fgetpos(f, &off);
763	continue;
764	}
765	if (!check_strset(p, "thread")) {
766	td->use_thread = 1;
767	fgetpos(f, &off);
768	continue;
769	}
770
771	printf("Client%d: bad option %s\n",td->thread_number,p);
772	}
773	fsetpos(f, &off);
774
775	if (add_job(td, name, prioclass, prio))
776	return 1;
777	}
778
779	free(string);
780	free(name);
781	fclose(f);
782	return 0;
783	}
784
785	static int fill_def_thread(void)
786	{
787	memset(&def_thread, 0, sizeof(def_thread));
788
789	if (fio_getaffinity(getpid(), &def_thread.cpumask) == -1) {
790	perror("sched_getaffinity");
791	return 1;
792	}
793
794	/*
795	* fill globals
796	*/
797	def_thread.ddir = DDIR_READ;
798	def_thread.bs = DEF_BS;
799	def_thread.min_bs = -1;
800	def_thread.max_bs = -1;
801	def_thread.io_engine = DEF_IO_ENGINE;
802	strcpy(def_thread.io_engine_name, DEF_IO_ENGINE_NAME);
803	def_thread.odirect = DEF_ODIRECT;
804	def_thread.ratecycle = DEF_RATE_CYCLE;
805	def_thread.sequential = DEF_SEQUENTIAL;
806	def_thread.timeout = DEF_TIMEOUT;
807	def_thread.create_file = DEF_CREATE;
808	def_thread.overwrite = DEF_OVERWRITE;
809	def_thread.invalidate_cache = DEF_INVALIDATE;
810	def_thread.sync_io = DEF_SYNCIO;
811	def_thread.mem_type = MEM_MALLOC;
812	def_thread.bw_avg_time = DEF_BWAVGTIME;
813	def_thread.create_serialize = DEF_CREATE_SER;
814	def_thread.create_fsync = DEF_CREATE_FSYNC;
815	def_thread.loops = DEF_LOOPS;
816	def_thread.verify = DEF_VERIFY;
817	def_thread.stonewall = DEF_STONEWALL;
818	def_thread.numjobs = DEF_NUMJOBS;
819	def_thread.use_thread = DEF_USE_THREAD;
820	#ifdef FIO_HAVE_DISK_UTIL
821	def_thread.do_disk_util = 1;
822	#endif
823
824	return 0;
825	}
826
827	static void parse_cmd_line(int argc, char *argv[])
828	{
829	int c;
830
831	while ((c = getopt(argc, argv, "s:b:t:r:R:o:f:lwv")) != EOF) {
832	switch (c) {
833	case 's':
834	def_thread.sequential = !!atoi(optarg);
835	break;
836	case 'b':
837	def_thread.bs = atoi(optarg);
838	def_thread.bs <<= 10;
839	if (!def_thread.bs) {
840	printf("bad block size\n");
841	def_thread.bs = DEF_BS;
842	}
843	break;
844	case 't':
845	def_thread.timeout = atoi(optarg);
846	break;
847	case 'r':
848	repeatable = !!atoi(optarg);
849	break;
850	case 'R':
851	rate_quit = !!atoi(optarg);
852	break;
853	case 'o':
854	def_thread.odirect = !!atoi(optarg);
855	break;
856	case 'f':
857	ini_file = strdup(optarg);
858	break;
859	case 'l':
860	write_lat_log = 1;
861	break;
862	case 'w':
863	write_bw_log = 1;
864	break;
865	case 'v':
866	printf("%s\n", fio_version_string);
867	exit(0);
868	}
869	}
870	}
871
872	static void free_shm(void)
873	{
874	struct shmid_ds sbuf;
875
876	if (threads) {
877	shmdt(threads);
878	threads = NULL;
879	shmctl(shm_id, IPC_RMID, &sbuf);
880	}
881	}
882
883	static int setup_thread_area(void)
884	{
885	/*
886	* 1024 is too much on some machines, scale max_jobs if
887	* we get a failure that looks like too large a shm segment
888	*/
889	do {
890	int s = max_jobs * sizeof(struct thread_data);
891
892	shm_id = shmget(0, s, IPC_CREAT \| 0600);
893	if (shm_id != -1)
894	break;
895	if (errno != EINVAL) {
896	perror("shmget");
897	break;
898	}
899
900	max_jobs >>= 1;
901	} while (max_jobs);
902
903	if (shm_id == -1)
904	return 1;
905
906	threads = shmat(shm_id, NULL, 0);
907	if (threads == (void *) -1) {
908	perror("shmat");
909	return 1;
910	}
911
912	atexit(free_shm);
913	return 0;
914	}
915
916	int parse_options(int argc, char *argv[])
917	{
918	if (setup_thread_area())
919	return 1;
920	if (fill_def_thread())
921	return 1;
922
923	parse_cmd_line(argc, argv);
924
925	if (!ini_file) {
926	printf("Need job file\n");
927	return 1;
928	}
929
930	if (parse_jobs_ini(ini_file))
931	return 1;
932
933	return 0;
934	}