#include "profile.h"
#include "server.h"
#include "idletime.h"
+#include "filelock.h"
#include "lib/getopt.h"
+#include "lib/strcasestr.h"
+
+#include "crc/test.h"
const char fio_version_string[] = FIO_VERSION;
static char **ini_file;
static int max_jobs = FIO_MAX_JOBS;
static int dump_cmdline;
-static int def_timeout;
+static long long def_timeout;
static int parse_only;
static struct thread_data def_thread;
struct thread_data *threads = NULL;
+static char **job_sections;
+static int nr_job_sections;
int exitall_on_terminate = 0;
int output_format = FIO_OUTPUT_NORMAL;
+int append_terse_output = 0;
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;
-int nr_job_sections = 0;
char *exec_profile = NULL;
int warnings_fatal = 0;
int terse_version = 3;
int write_bw_log = 0;
int read_only = 0;
-
-static int write_lat_log;
+int status_interval = 0;
static int prev_group_jobs;
},
{
.name = (char *) "minimal",
- .has_arg = optional_argument,
+ .has_arg = no_argument,
.val = 'm' | FIO_CLIENT_FLAG,
},
{
.has_arg = optional_argument,
.val = 'F' | FIO_CLIENT_FLAG,
},
+ {
+ .name = (char *) "append-terse",
+ .has_arg = optional_argument,
+ .val = 'f',
+ },
{
.name = (char *) "version",
.has_arg = no_argument,
.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",
.has_arg = required_argument,
.val = 'x' | FIO_CLIENT_FLAG,
},
+#ifdef CONFIG_ZLIB
+ {
+ .name = (char *) "inflate-log",
+ .has_arg = required_argument,
+ .val = 'X' | FIO_CLIENT_FLAG,
+ },
+#endif
{
.name = (char *) "alloc-size",
.has_arg = required_argument,
.has_arg = required_argument,
.val = 'C',
},
+ {
+ .name = (char *) "remote-config",
+ .has_arg = required_argument,
+ .val = 'R',
+ },
{
.name = (char *) "cpuclock-test",
.has_arg = no_argument,
.val = 'T',
},
+ {
+ .name = (char *) "crctest",
+ .has_arg = optional_argument,
+ .val = 'G',
+ },
{
.name = (char *) "idle-prof",
.has_arg = required_argument,
.val = 'I',
},
+ {
+ .name = (char *) "status-interval",
+ .has_arg = required_argument,
+ .val = 'L',
+ },
{
.name = NULL,
},
};
-static void free_shm(void)
+void free_threads_shm(void)
{
- struct shmid_ds sbuf;
-
if (threads) {
void *tp = threads;
+#ifndef CONFIG_NO_SHM
+ struct shmid_ds sbuf;
threads = NULL;
+ shmdt(tp);
+ shmctl(shm_id, IPC_RMID, &sbuf);
+ shm_id = -1;
+#else
+ threads = NULL;
+ free(tp);
+#endif
+ }
+}
+
+static void free_shm(void)
+{
+ if (threads) {
file_hash_exit();
flow_exit();
fio_debug_jobp = NULL;
- shmdt(tp);
- shmctl(shm_id, IPC_RMID, &sbuf);
+ free_threads_shm();
}
+ options_free(fio_options, &def_thread);
+ fio_filelock_exit();
scleanup();
}
size += file_hash_size;
size += sizeof(unsigned int);
+#ifndef CONFIG_NO_SHM
shm_id = shmget(0, size, IPC_CREAT | 0600);
if (shm_id != -1)
break;
perror("shmget");
break;
}
+#else
+ threads = malloc(size);
+ if (threads)
+ break;
+#endif
max_jobs >>= 1;
} while (max_jobs);
+#ifndef CONFIG_NO_SHM
if (shm_id == -1)
return 1;
perror("shmat");
return 1;
}
+#endif
memset(threads, 0, max_jobs * sizeof(struct thread_data));
hash = (void *) threads + max_jobs * sizeof(struct thread_data);
return 0;
}
+static void set_cmd_options(struct thread_data *td)
+{
+ struct thread_options *o = &td->o;
+
+ if (!o->timeout)
+ o->timeout = def_timeout;
+}
+
/*
* Return a free job structure.
*/
static struct thread_data *get_new_job(int global, struct thread_data *parent,
- int preserve_eo)
+ int preserve_eo, const char *jobname)
{
struct thread_data *td;
- if (global)
+ if (global) {
+ set_cmd_options(&def_thread);
return &def_thread;
+ }
if (setup_thread_area()) {
log_err("error: failed to setup shm segment\n");
return NULL;
profile_add_hooks(td);
td->thread_number = thread_number;
+ td->subjob_number = 0;
+
+ if (jobname)
+ td->o.name = strdup(jobname);
- if (!parent || !parent->o.group_reporting)
+ if (!parent->o.group_reporting)
stat_number++;
+ set_cmd_options(td);
return td;
}
if (td->io_ops)
free_ioengine(td);
+ if (td->o.name)
+ free(td->o.name);
+
memset(&threads[td->thread_number - 1], 0, sizeof(*td));
thread_number--;
}
o->min_bs[DDIR_READ] == o->min_bs[DDIR_TRIM];
}
+
+static unsigned long long get_rand_start_delay(struct thread_data *td)
+{
+ unsigned long long delayrange;
+ unsigned long r;
+
+ delayrange = td->o.start_delay_high - td->o.start_delay;
+
+ if (td->o.use_os_rand) {
+ r = os_random_long(&td->delay_state);
+ delayrange = (unsigned long long) ((double) delayrange * (r / (OS_RAND_MAX + 1.0)));
+ } else {
+ r = __rand(&td->__delay_state);
+ delayrange = (unsigned long long) ((double) delayrange * (r / (FRAND_MAX + 1.0)));
+ }
+
+ delayrange += td->o.start_delay;
+ return delayrange;
+}
+
/*
* Lazy way of fixing up options that depend on each other. We could also
* define option callback handlers, but this is easier.
if (!o->file_size_high)
o->file_size_high = o->file_size_low;
+ if (o->start_delay_high)
+ o->start_delay = get_rand_start_delay(td);
+
if (o->norandommap && o->verify != VERIFY_NONE
&& !fixed_block_size(o)) {
log_err("fio: norandommap given for variable block sizes, "
if (o->max_bs[DDIR_WRITE] != o->min_bs[DDIR_WRITE] &&
!o->verify_interval)
o->verify_interval = o->min_bs[DDIR_WRITE];
+
+ /*
+ * Verify interval must be smaller or equal to the
+ * write size.
+ */
+ if (o->verify_interval > o->min_bs[DDIR_WRITE])
+ o->verify_interval = o->min_bs[DDIR_WRITE];
+ else if (td_read(td) && o->verify_interval > o->min_bs[DDIR_READ])
+ o->verify_interval = o->min_bs[DDIR_READ];
}
if (o->pre_read) {
}
}
+ 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()"
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;
+ }
+
+ /*
+ * O_ATOMIC implies O_DIRECT
+ */
+ if (td->o.oatomic)
+ td->o.odirect = 1;
+
+ /*
+ * If randseed is set, that overrides randrepeat
+ */
+ if (td->o.rand_seed)
+ td->o.rand_repeatable = 0;
+
+ if ((td->io_ops->flags & FIO_NOEXTEND) && td->o.file_append) {
+ log_err("fio: can't append/extent with IO engine %s\n", td->io_ops->name);
+ ret = 1;
+ }
+
return ret;
}
/*
* This function leaks the buffer
*/
-static char *to_kmg(unsigned int val)
+char *fio_uint_to_kmg(unsigned int val)
{
char *buf = malloc(32);
char post[] = { 0, 'K', 'M', 'G', 'P', 'E', 0 };
os_random_seed(td->rand_seeds[FIO_RAND_FILE_SIZE_OFF], &td->file_size_state);
os_random_seed(td->rand_seeds[FIO_RAND_TRIM_OFF], &td->trim_state);
+ os_random_seed(td->rand_seeds[FIO_RAND_START_DELAY], &td->delay_state);
if (!td_random(td))
return;
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)
init_rand_seed(&td->__file_size_state, td->rand_seeds[FIO_RAND_FILE_SIZE_OFF]);
init_rand_seed(&td->__trim_state, td->rand_seeds[FIO_RAND_TRIM_OFF]);
+ init_rand_seed(&td->__delay_state, td->rand_seeds[FIO_RAND_START_DELAY]);
if (!td_random(td))
return;
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)
{
+ if (td->o.allrand_repeatable) {
+ unsigned int i;
+
+ for (i = 0; i < FIO_RAND_NR_OFFS; i++)
+ td->rand_seeds[i] = FIO_RANDSEED * td->thread_number
+ + i;
+ }
+
if (td->o.use_os_rand)
td_fill_rand_seeds_os(td);
else
td_fill_rand_seeds_internal(td);
init_rand_seed(&td->buf_state, td->rand_seeds[FIO_RAND_BUF_OFF]);
+ frand_copy(&td->buf_state_prev, &td->buf_state);
+
+ init_rand_seed(&td->dedupe_state, td->rand_seeds[FIO_DEDUPE_OFF]);
}
/*
*/
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);
unsigned long seed;
unsigned int i;
- if (!td->o.rand_repeatable)
+ if (!td->o.rand_repeatable && !td->o.rand_seed)
return init_random_state(td, td->rand_seeds, sizeof(td->rand_seeds));
- for (seed = 0x89, i = 0; i < 4; i++)
+ if (!td->o.rand_seed)
+ seed = 0x89;
+ else
+ seed = td->o.rand_seed;
+
+ for (i = 0; i < 4; i++)
seed *= 0x9e370001UL;
for (i = 0; i < FIO_RAND_NR_OFFS; i++) {
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, size_t buf_size,struct thread_options *o,
+ const char *jobname, int jobnum, int filenum)
+{
+ struct fpre_keyword *f;
+ char copy[PATH_MAX];
+ size_t dst_left = PATH_MAX - 1;
+
+ 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);
+
+ buf[buf_size - 1] = '\0';
+ strncpy(buf, o->filename_format, buf_size - 1);
+
+ 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;
+ dst_left -= pre_len;
+ }
+
+ switch (f->key) {
+ case FPRE_JOBNAME: {
+ int ret;
+
+ ret = snprintf(dst, dst_left, "%s", jobname);
+ if (ret < 0)
+ break;
+ dst += ret;
+ dst_left -= ret;
+ break;
+ }
+ case FPRE_JOBNUM: {
+ int ret;
+
+ ret = snprintf(dst, dst_left, "%d", jobnum);
+ if (ret < 0)
+ break;
+ dst += ret;
+ dst_left -= ret;
+ break;
+ }
+ case FPRE_FILENUM: {
+ int ret;
+
+ ret = snprintf(dst, dst_left, "%d", filenum);
+ if (ret < 0)
+ break;
+ dst += ret;
+ dst_left -= ret;
+ break;
+ }
+ default:
+ assert(0);
+ break;
+ }
+
+ if (post_start)
+ strncpy(dst, buf + post_start, dst_left);
+
+ strncpy(buf, copy, buf_size - 1);
+ } 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
* members of td.
*/
-static int add_job(struct thread_data *td, const char *jobname, int job_add_num)
+static int add_job(struct thread_data *td, const char *jobname, int job_add_num,
+ int recursed, int client_type)
{
- const char *ddir_str[] = { NULL, "read", "write", "rw", NULL,
- "randread", "randwrite", "randrw",
- "trim", NULL, NULL, NULL, "randtrim" };
unsigned int i;
char fname[PATH_MAX];
int numjobs, file_alloced;
+ struct thread_options *o = &td->o;
+ char logname[PATH_MAX + 32];
/*
* the def_thread is just for options, it's not a real job
/*
* 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;
}
+ td->client_type = client_type;
+
if (profile_td_init(td))
goto err;
if (ioengine_load(td))
goto err;
- if (td->o.use_thread)
- nr_thread++;
- else
- nr_process++;
-
- 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))
- add_file(td, jobname);
+ if (o->nr_files == 1 && exists_and_not_file(jobname))
+ add_file(td, jobname, job_add_num, 0);
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, sizeof(fname), o, jobname, job_add_num, i), job_add_num, 0);
}
}
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;
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++;
}
if (setup_rate(td))
goto err;
- if (td->o.write_lat_log) {
- setup_log(&td->lat_log, td->o.log_avg_msec);
- setup_log(&td->slat_log, td->o.log_avg_msec);
- setup_log(&td->clat_log, td->o.log_avg_msec);
+ if (o->lat_log_file) {
+ struct log_params p = {
+ .td = td,
+ .avg_msec = o->log_avg_msec,
+ .log_type = IO_LOG_TYPE_LAT,
+ .log_offset = o->log_offset,
+ .log_gz = o->log_gz,
+ .log_gz_store = o->log_gz_store,
+ };
+ const char *suf;
+
+ if (p.log_gz_store)
+ suf = "log.fz";
+ else
+ suf = "log";
+
+ snprintf(logname, sizeof(logname), "%s_lat.%d.%s",
+ o->lat_log_file, td->thread_number, suf);
+ setup_log(&td->lat_log, &p, logname);
+ snprintf(logname, sizeof(logname), "%s_slat.%d.%s",
+ o->lat_log_file, td->thread_number, suf);
+ setup_log(&td->slat_log, &p, logname);
+ snprintf(logname, sizeof(logname), "%s_clat.%d.%s",
+ o->lat_log_file, td->thread_number, suf);
+ setup_log(&td->clat_log, &p, logname);
}
- if (td->o.write_bw_log)
- setup_log(&td->bw_log, td->o.log_avg_msec);
- if (td->o.write_iops_log)
- setup_log(&td->iops_log, td->o.log_avg_msec);
+ if (o->bw_log_file) {
+ struct log_params p = {
+ .td = td,
+ .avg_msec = o->log_avg_msec,
+ .log_type = IO_LOG_TYPE_BW,
+ .log_offset = o->log_offset,
+ .log_gz = o->log_gz,
+ .log_gz_store = o->log_gz_store,
+ };
+ const char *suf;
+
+ if (p.log_gz_store)
+ suf = "log.fz";
+ else
+ suf = "log";
- if (!td->o.name)
- td->o.name = strdup(jobname);
+ snprintf(logname, sizeof(logname), "%s_bw.%d.%s",
+ o->bw_log_file, td->thread_number, suf);
+ setup_log(&td->bw_log, &p, logname);
+ }
+ if (o->iops_log_file) {
+ struct log_params p = {
+ .td = td,
+ .avg_msec = o->log_avg_msec,
+ .log_type = IO_LOG_TYPE_IOPS,
+ .log_offset = o->log_offset,
+ .log_gz = o->log_gz,
+ .log_gz_store = o->log_gz_store,
+ };
+ const char *suf;
+
+ if (p.log_gz_store)
+ suf = "log.fz";
+ else
+ suf = "log";
+
+ snprintf(logname, sizeof(logname), "%s_iops.%d.%s",
+ o->iops_log_file, td->thread_number, suf);
+ setup_log(&td->iops_log, &p, logname);
+ }
+
+ if (!o->name)
+ o->name = strdup(jobname);
if (output_format == FIO_OUTPUT_NORMAL) {
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, *c5, *c6;
-
- 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]);
- c5 = to_kmg(td->o.min_bs[DDIR_TRIM]);
- c6 = 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);
+ if (is_backend && !recursed)
+ fio_server_send_add_job(td);
+
+ if (!(td->io_ops->flags & FIO_NOIO)) {
+ 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);
* 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);
+ struct thread_data *td_new = get_new_job(0, td, 1, jobname);
if (!td_new)
goto err;
td_new->o.numjobs = 1;
td_new->o.stonewall = 0;
td_new->o.new_group = 0;
+ td_new->subjob_number = numjobs;
if (file_alloced) {
- td_new->o.filename = NULL;
+ if (td_new->files) {
+ struct fio_file *f;
+ for_each_file(td_new, f, i) {
+ if (f->file_name)
+ sfree(f->file_name);
+ sfree(f);
+ }
+ free(td_new->files);
+ td_new->files = NULL;
+ }
td_new->files_index = 0;
td_new->files_size = 0;
- td_new->files = NULL;
+ if (td_new->o.filename) {
+ free(td_new->o.filename);
+ td_new->o.filename = NULL;
+ }
}
- job_add_num = numjobs - 1;
-
- if (add_job(td_new, jobname, job_add_num))
+ if (add_job(td_new, jobname, numjobs, 1, client_type))
goto err;
}
/*
* Parse as if 'o' was a command line
*/
-void add_job_opts(const char **o)
+void add_job_opts(const char **o, int client_type)
{
struct thread_data *td, *td_parent;
int i, in_global = 1;
if (!strncmp(o[i], "name", 4)) {
in_global = 0;
if (td)
- add_job(td, jobname, 0);
+ add_job(td, jobname, 0, 0, client_type);
td = NULL;
sprintf(jobname, "%s", o[i] + 5);
}
if (in_global && !td_parent)
- td_parent = get_new_job(1, &def_thread, 0);
+ td_parent = get_new_job(1, &def_thread, 0, jobname);
else if (!in_global && !td) {
if (!td_parent)
td_parent = &def_thread;
- td = get_new_job(0, td_parent, 0);
+ td = get_new_job(0, td_parent, 0, jobname);
}
if (in_global)
- fio_options_parse(td_parent, (char **) &o[i], 1);
+ fio_options_parse(td_parent, (char **) &o[i], 1, 0);
else
- fio_options_parse(td, (char **) &o[i], 1);
+ fio_options_parse(td, (char **) &o[i], 1, 0);
i++;
}
if (td)
- add_job(td, jobname, 0);
+ add_job(td, jobname, 0, 0, client_type);
}
static int skip_this_section(const char *name)
/*
* This is our [ini] type file parser.
*/
-int parse_jobs_ini(char *file, int is_buf, int stonewall_flag)
+int __parse_jobs_ini(struct thread_data *td,
+ char *file, int is_buf, int stonewall_flag, int type,
+ int nested, char *name, char ***popts, int *aopts, int *nopts)
{
- unsigned int global;
- struct thread_data *td;
- char *string, *name;
+ unsigned int global = 0;
+ char *string;
FILE *f;
char *p;
int ret = 0, stonewall;
char **opts;
int i, alloc_opts, num_opts;
+ dprint(FD_PARSE, "Parsing ini file %s\n", file);
+ assert(td || !nested);
+
if (is_buf)
f = NULL;
else {
f = fopen(file, "r");
if (!f) {
- perror("fopen job file");
+ int __err = errno;
+
+ log_err("fio: unable to open '%s' job file\n", file);
+ if (td)
+ td_verror(td, __err, "job file open");
return 1;
}
}
/*
* it's really 256 + small bit, 280 should suffice
*/
- name = malloc(280);
- memset(name, 0, 280);
+ if (!nested) {
+ name = malloc(280);
+ memset(name, 0, 280);
+ }
- alloc_opts = 8;
- opts = malloc(sizeof(char *) * alloc_opts);
- num_opts = 0;
+ opts = NULL;
+ if (nested && popts) {
+ opts = *popts;
+ alloc_opts = *aopts;
+ num_opts = *nopts;
+ }
+
+ if (!opts) {
+ alloc_opts = 8;
+ opts = malloc(sizeof(char *) * alloc_opts);
+ num_opts = 0;
+ }
stonewall = stonewall_flag;
do {
strip_blank_front(&p);
strip_blank_end(p);
+ dprint(FD_PARSE, "%s\n", p);
if (is_empty_or_comment(p))
continue;
- if (sscanf(p, "[%255[^\n]]", name) != 1) {
- if (inside_skip)
+
+ if (!nested) {
+ if (sscanf(p, "[%255[^\n]]", name) != 1) {
+ if (inside_skip)
+ continue;
+
+ log_err("fio: option <%s> outside of "
+ "[] job section\n", p);
+ ret = 1;
+ break;
+ }
+
+ name[strlen(name) - 1] = '\0';
+
+ if (skip_this_section(name)) {
+ inside_skip = 1;
continue;
- log_err("fio: option <%s> outside of [] job section\n",
- p);
- break;
- }
+ } else
+ inside_skip = 0;
- name[strlen(name) - 1] = '\0';
+ dprint(FD_PARSE, "Parsing section [%s]\n", name);
- if (skip_this_section(name)) {
- inside_skip = 1;
- continue;
- } else
- inside_skip = 0;
+ global = !strncmp(name, "global", 6);
- global = !strncmp(name, "global", 6);
+ if (dump_cmdline) {
+ if (first_sect)
+ log_info("fio ");
+ if (!global)
+ log_info("--name=%s ", name);
+ first_sect = 0;
+ }
- if (dump_cmdline) {
- if (first_sect)
- log_info("fio ");
- if (!global)
- log_info("--name=%s ", name);
- first_sect = 0;
- }
+ td = get_new_job(global, &def_thread, 0, name);
+ if (!td) {
+ ret = 1;
+ break;
+ }
- td = get_new_job(global, &def_thread, 0);
- if (!td) {
- ret = 1;
- break;
- }
+ /*
+ * Separate multiple job files by a stonewall
+ */
+ if (!global && stonewall) {
+ td->o.stonewall = stonewall;
+ stonewall = 0;
+ }
- /*
- * Seperate multiple job files by a stonewall
- */
- if (!global && stonewall) {
- td->o.stonewall = stonewall;
- stonewall = 0;
+ num_opts = 0;
+ memset(opts, 0, alloc_opts * sizeof(char *));
}
-
- num_opts = 0;
- memset(opts, 0, alloc_opts * sizeof(char *));
+ else
+ skip_fgets = 1;
while (1) {
- if (is_buf)
- p = strsep(&file, "\n");
+ if (!skip_fgets) {
+ if (is_buf)
+ p = strsep(&file, "\n");
+ else
+ p = fgets(string, 4096, f);
+ if (!p)
+ break;
+ dprint(FD_PARSE, "%s", p);
+ }
else
- p = fgets(string, 4096, f);
- if (!p)
- break;
+ skip_fgets = 0;
if (is_empty_or_comment(p))
continue;
* fgets() a new line at the top.
*/
if (p[0] == '[') {
+ if (nested) {
+ log_err("No new sections in included files\n");
+ return 1;
+ }
+
skip_fgets = 1;
break;
}
strip_blank_end(p);
+ if (!strncmp(p, "include", strlen("include"))) {
+ char *filename = p + strlen("include") + 1;
+
+ if ((ret = __parse_jobs_ini(td, filename,
+ is_buf, stonewall_flag, type, 1,
+ name, &opts, &alloc_opts, &num_opts))) {
+ log_err("Error %d while parsing include file %s\n",
+ ret, filename);
+ break;
+ }
+ continue;
+ }
+
if (num_opts == alloc_opts) {
alloc_opts <<= 1;
opts = realloc(opts,
num_opts++;
}
- ret = fio_options_parse(td, opts, num_opts);
- if (!ret) {
- if (dump_cmdline)
- for (i = 0; i < num_opts; i++)
- log_info("--%s ", opts[i]);
+ if (nested) {
+ *popts = opts;
+ *aopts = alloc_opts;
+ *nopts = num_opts;
+ goto out;
+ }
- ret = add_job(td, name, 0);
- } else {
+ ret = fio_options_parse(td, opts, num_opts, dump_cmdline);
+ if (!ret)
+ ret = add_job(td, name, 0, 0, type);
+ else {
log_err("fio: job %s dropped\n", name);
put_job(td);
}
i++;
}
- for (i = 0; i < num_opts; i++)
- free(opts[i]);
-
- free(string);
- free(name);
free(opts);
+out:
+ free(string);
+ if (!nested)
+ free(name);
if (!is_buf && f != stdin)
fclose(f);
return ret;
}
+int parse_jobs_ini(char *file, int is_buf, int stonewall_flag, int type)
+{
+ return __parse_jobs_ini(NULL, file, is_buf, stonewall_flag, type,
+ 0, NULL, NULL, NULL, NULL);
+}
+
static int fill_def_thread(void)
{
memset(&def_thread, 0, sizeof(def_thread));
fio_getaffinity(getpid(), &def_thread.o.cpumask);
- def_thread.o.timeout = def_timeout;
def_thread.o.error_dump = 1;
+
/*
* fill default options
*/
printf("%s [options] [job options] <job file(s)>\n", name);
printf(" --debug=options\tEnable debug logging. May be one/more of:\n"
"\t\t\tprocess,file,io,mem,blktrace,verify,random,parse,\n"
- "\t\t\tdiskutil,job,mutex,profile,time,net\n");
+ "\t\t\tdiskutil,job,mutex,profile,time,net,rate,compress\n");
printf(" --parse-only\t\tParse options only, don't start any IO\n");
printf(" --output\t\tWrite output to file\n");
printf(" --runtime\t\tRuntime in seconds\n");
- printf(" --latency-log\t\tGenerate per-job latency logs\n");
printf(" --bandwidth-log\tGenerate per-job bandwidth logs\n");
printf(" --minimal\t\tMinimal (terse) output\n");
printf(" --output-format=x\tOutput format (terse,json,normal)\n");
printf(" --version\t\tPrint version info and exit\n");
printf(" --help\t\tPrint this page\n");
printf(" --cpuclock-test\tPerform test/validation of CPU clock\n");
+ printf(" --crctest\t\tTest speed of checksum functions\n");
printf(" --cmdhelp=cmd\t\tPrint command help, \"all\" for all of"
" them\n");
printf(" --enghelp=engine\tPrint ioengine help, or list"
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");
printf(" --server=args\t\tStart a backend fio server\n");
printf(" --daemonize=pidfile\tBackground fio server, write pid to file\n");
printf(" --client=hostname\tTalk to remote backend fio server at hostname\n");
+ printf(" --remote-config=file\tTell fio server to load this local job file\n");
printf(" --idle-prof=option\tReport cpu idleness on a system or percpu basis\n"
"\t\t\t(option=system,percpu) or run unit work\n"
"\t\t\tcalibration only (option=calibrate)\n");
+#ifdef CONFIG_ZLIB
+ printf(" --inflate-log=log\tInflate and output compressed log\n");
+#endif
printf("\nFio was written by Jens Axboe <jens.axboe@oracle.com>");
- printf("\n Jens Axboe <jaxboe@fusionio.com>\n");
+ printf("\n Jens Axboe <jaxboe@fusionio.com>");
+ printf("\n Jens Axboe <axboe@fb.com>\n");
}
#ifdef FIO_INC_DEBUG
struct debug_level debug_levels[] = {
- { .name = "process", .shift = FD_PROCESS, },
- { .name = "file", .shift = FD_FILE, },
- { .name = "io", .shift = FD_IO, },
- { .name = "mem", .shift = FD_MEM, },
- { .name = "blktrace", .shift = FD_BLKTRACE },
- { .name = "verify", .shift = FD_VERIFY },
- { .name = "random", .shift = FD_RANDOM },
- { .name = "parse", .shift = FD_PARSE },
- { .name = "diskutil", .shift = FD_DISKUTIL },
- { .name = "job", .shift = FD_JOB },
- { .name = "mutex", .shift = FD_MUTEX },
- { .name = "profile", .shift = FD_PROFILE },
- { .name = "time", .shift = FD_TIME },
- { .name = "net", .shift = FD_NET },
+ { .name = "process",
+ .help = "Process creation/exit logging",
+ .shift = FD_PROCESS,
+ },
+ { .name = "file",
+ .help = "File related action logging",
+ .shift = FD_FILE,
+ },
+ { .name = "io",
+ .help = "IO and IO engine action logging (offsets, queue, completions, etc)",
+ .shift = FD_IO,
+ },
+ { .name = "mem",
+ .help = "Memory allocation/freeing logging",
+ .shift = FD_MEM,
+ },
+ { .name = "blktrace",
+ .help = "blktrace action logging",
+ .shift = FD_BLKTRACE,
+ },
+ { .name = "verify",
+ .help = "IO verification action logging",
+ .shift = FD_VERIFY,
+ },
+ { .name = "random",
+ .help = "Random generation logging",
+ .shift = FD_RANDOM,
+ },
+ { .name = "parse",
+ .help = "Parser logging",
+ .shift = FD_PARSE,
+ },
+ { .name = "diskutil",
+ .help = "Disk utility logging actions",
+ .shift = FD_DISKUTIL,
+ },
+ { .name = "job",
+ .help = "Logging related to creating/destroying jobs",
+ .shift = FD_JOB,
+ },
+ { .name = "mutex",
+ .help = "Mutex logging",
+ .shift = FD_MUTEX
+ },
+ { .name = "profile",
+ .help = "Logging related to profiles",
+ .shift = FD_PROFILE,
+ },
+ { .name = "time",
+ .help = "Logging related to time keeping functions",
+ .shift = FD_TIME,
+ },
+ { .name = "net",
+ .help = "Network logging",
+ .shift = FD_NET,
+ },
+ { .name = "rate",
+ .help = "Rate logging",
+ .shift = FD_RATE,
+ },
+ { .name = "compress",
+ .help = "Log compression logging",
+ .shift = FD_COMPRESS,
+ },
{ .name = NULL, },
};
return 0;
}
-void parse_cmd_client(void *client, char *opt)
+static void parse_cmd_client(void *client, char *opt)
{
fio_client_add_cmd_option(client, opt);
}
-int parse_cmd_line(int argc, char *argv[])
+int parse_cmd_line(int argc, char *argv[], int client_type)
{
struct thread_data *td = NULL;
int c, ini_idx = 0, lidx, ret = 0, do_exit = 0, exit_val = 0;
optind = 1;
while ((c = getopt_long_only(argc, argv, ostr, l_opts, &lidx)) != -1) {
- did_arg = 1;
-
if ((c & FIO_CLIENT_FLAG) || client_flag_set(c)) {
parse_cmd_client(cur_client, argv[optind - 1]);
c &= ~FIO_CLIENT_FLAG;
smalloc_pool_size = atoi(optarg);
break;
case 't':
- def_timeout = atoi(optarg);
+ if (check_str_time(optarg, &def_timeout, 1)) {
+ log_err("fio: failed parsing time %s\n", optarg);
+ do_exit++;
+ exit_val = 1;
+ }
break;
case 'l':
- write_lat_log = 1;
+ log_err("fio: --latency-log is deprecated. Use per-job latency log options.\n");
+ do_exit++;
+ exit_val = 1;
break;
case 'b':
write_bw_log = 1;
break;
case 'o':
+ if (f_out && f_out != stdout)
+ fclose(f_out);
+
f_out = fopen(optarg, "w+");
if (!f_out) {
perror("fopen output");
output_format = FIO_OUTPUT_TERSE;
break;
case 'F':
+ if (!optarg) {
+ log_err("fio: missing --output-format argument\n");
+ exit_val = 1;
+ do_exit++;
+ break;
+ }
if (!strcmp(optarg, "minimal") ||
!strcmp(optarg, "terse") ||
!strcmp(optarg, "csv"))
else
output_format = FIO_OUTPUT_NORMAL;
break;
+ case 'f':
+ append_terse_output = 1;
+ break;
case 'h':
+ did_arg = 1;
if (!cur_client) {
usage(argv[0]);
do_exit++;
}
break;
case 'c':
+ did_arg = 1;
if (!cur_client) {
fio_show_option_help(optarg);
do_exit++;
}
break;
case 'i':
+ did_arg = 1;
if (!cur_client) {
fio_show_ioengine_help(optarg);
do_exit++;
}
break;
case 's':
+ did_arg = 1;
dump_cmdline = 1;
break;
case 'r':
read_only = 1;
break;
case 'v':
+ did_arg = 1;
if (!cur_client) {
log_info("%s\n", fio_version_string);
do_exit++;
case 'E': {
long long t = 0;
- if (str_to_decimal(optarg, &t, 0, NULL)) {
+ if (str_to_decimal(optarg, &t, 0, NULL, 1)) {
log_err("fio: failed parsing eta time %s\n", optarg);
exit_val = 1;
do_exit++;
do_exit++;
break;
case 'P':
+ did_arg = 1;
parse_only = 1;
break;
case 'x': {
nr_job_sections++;
break;
}
+#ifdef CONFIG_ZLIB
+ case 'X':
+ exit_val = iolog_file_inflate(optarg);
+ did_arg++;
+ do_exit++;
+ break;
+#endif
case 'p':
+ did_arg = 1;
+ if (exec_profile)
+ free(exec_profile);
exec_profile = strdup(optarg);
break;
case FIO_GETOPT_JOB: {
char *val = optarg;
if (!strncmp(opt, "name", 4) && td) {
- ret = add_job(td, td->o.name ?: "fio", 0);
+ ret = add_job(td, td->o.name ?: "fio", 0, 0, client_type);
if (ret)
- return 0;
+ goto out_free;
td = NULL;
+ did_arg = 1;
}
if (!td) {
int is_section = !strncmp(opt, "name", 4);
if (is_section && skip_this_section(val))
continue;
- td = get_new_job(global, &def_thread, 1);
- if (!td || ioengine_load(td))
- return 0;
+ td = get_new_job(global, &def_thread, 1, NULL);
+ if (!td || ioengine_load(td)) {
+ if (td) {
+ put_job(td);
+ td = NULL;
+ }
+ do_exit++;
+ break;
+ }
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);
- if (ioengine_load(td))
- return 0;
+ if (ioengine_load(td)) {
+ put_job(td);
+ td = NULL;
+ do_exit++;
+ break;
+ }
fio_options_set_ioengine_opts(l_opts, td);
}
break;
case FIO_GETOPT_IOENGINE: {
const char *opt = l_opts[lidx].name;
char *val = optarg;
- opt = l_opts[lidx].name;
- val = optarg;
+
+ if (!td)
+ break;
+
ret = fio_cmd_ioengine_option_parse(td, opt, val);
break;
}
}
break;
case 'S':
+ did_arg = 1;
+#ifndef CONFIG_NO_SHM
if (nr_clients) {
log_err("fio: can't be both client and server\n");
do_exit++;
fio_server_set_arg(optarg);
is_backend = 1;
backend = 1;
+#else
+ log_err("fio: client/server requires SHM support\n");
+ do_exit++;
+ exit_val = 1;
+#endif
break;
case 'D':
+ if (pid_file)
+ free(pid_file);
pid_file = strdup(optarg);
break;
case 'I':
if ((ret = fio_idle_prof_parse_opt(optarg))) {
/* exit on error and calibration only */
+ did_arg = 1;
do_exit++;
- if (ret == -1)
+ if (ret == -1)
exit_val = 1;
}
break;
case 'C':
+ did_arg = 1;
if (is_backend) {
log_err("fio: can't be both client and server\n");
do_exit++;
exit_val = 1;
break;
}
- if (fio_client_add(optarg, &cur_client)) {
+ if (fio_client_add(&fio_client_ops, optarg, &cur_client)) {
log_err("fio: failed adding client %s\n", optarg);
do_exit++;
exit_val = 1;
!strncmp(argv[optind], "-", 1))
break;
- fio_client_add_ini_file(cur_client, argv[optind]);
+ if (fio_client_add_ini_file(cur_client, argv[optind], 0))
+ break;
optind++;
}
break;
+ case 'R':
+ did_arg = 1;
+ if (fio_client_add_ini_file(cur_client, optarg, 1)) {
+ do_exit++;
+ exit_val = 1;
+ }
+ break;
case 'T':
+ did_arg = 1;
do_exit++;
exit_val = fio_monotonic_clocktest();
break;
+ case 'G':
+ did_arg = 1;
+ do_exit++;
+ exit_val = fio_crctest(optarg);
+ break;
+ case 'L': {
+ long long val;
+
+ if (check_str_time(optarg, &val, 0)) {
+ 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]);
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++;
- exit_val = 1;
- return -1;
- }
+ if (nr_clients && fio_clients_connect())
+ exit(1);
if (is_backend && backend)
return fio_start_server(pid_file);
+ else if (pid_file)
+ free(pid_file);
if (td) {
- if (!ret)
- ret = add_job(td, td->o.name ?: "fio", 0);
+ if (!ret) {
+ ret = add_job(td, td->o.name ?: "fio", 0, 0, client_type);
+ if (ret)
+ did_arg = 1;
+ }
}
while (!ret && optind < argc) {
optind++;
}
+out_free:
+ if (pid_file)
+ free(pid_file);
+
return ini_idx;
}
-int parse_options(int argc, char *argv[])
+int fio_init_options(void)
{
- int job_files, i;
-
f_out = stdout;
f_err = stderr;
if (fill_def_thread())
return 1;
- job_files = parse_cmd_line(argc, argv);
+ return 0;
+}
+
+extern int fio_check_options(struct thread_options *);
+
+int parse_options(int argc, char *argv[])
+{
+ const int type = FIO_CLIENT_TYPE_CLI;
+ int job_files, i;
+
+ if (fio_init_options())
+ return 1;
+ if (fio_test_cconv(&def_thread.o))
+ log_err("fio: failed internal cconv test\n");
+
+ job_files = parse_cmd_line(argc, argv, type);
if (job_files > 0) {
for (i = 0; i < job_files; i++) {
- if (fill_def_thread())
+ if (i && fill_def_thread())
return 1;
if (nr_clients) {
if (fio_clients_send_ini(ini_file[i]))
return 1;
free(ini_file[i]);
} else if (!is_backend) {
- if (parse_jobs_ini(ini_file[i], 0, i))
+ if (parse_jobs_ini(ini_file[i], 0, i, type))
return 1;
free(ini_file[i]);
}
free(ini_file);
fio_options_free(&def_thread);
+ filesetup_mem_free();
if (!thread_number) {
- if (dump_cmdline || parse_only)
+ if (parse_dryrun())
return 0;
if (exec_profile)
return 0;
return 0;
}
+
+void options_default_fill(struct thread_options *o)
+{
+ memcpy(o, &def_thread.o, sizeof(*o));
+}
projects / fio.git / blobdiff