#include "idletime.h"
#include "filelock.h"
-#include "lib/getopt.h"
-#include "lib/strcasestr.h"
+#include "oslib/getopt.h"
+#include "oslib/strcasestr.h"
#include "crc/test.h"
static int nr_job_sections;
int exitall_on_terminate = 0;
+int exitall_on_terminate_error = 0;
int output_format = FIO_OUTPUT_NORMAL;
-int append_terse_output = 0;
int eta_print = FIO_ETA_AUTO;
int eta_new_line = 0;
FILE *f_out = NULL;
int read_only = 0;
int status_interval = 0;
-static int write_lat_log;
+char *trigger_file = NULL;
+long long trigger_timeout = 0;
+char *trigger_cmd = NULL;
+char *trigger_remote_cmd = NULL;
+
+char *aux_path = NULL;
static int prev_group_jobs;
.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,
.has_arg = required_argument,
.val = 'L',
},
+ {
+ .name = (char *) "trigger-file",
+ .has_arg = required_argument,
+ .val = 'W',
+ },
+ {
+ .name = (char *) "trigger-timeout",
+ .has_arg = required_argument,
+ .val = 'B',
+ },
+ {
+ .name = (char *) "trigger",
+ .has_arg = required_argument,
+ .val = 'H',
+ },
+ {
+ .name = (char *) "trigger-remote",
+ .has_arg = required_argument,
+ .val = 'J',
+ },
+ {
+ .name = (char *) "aux-path",
+ .has_arg = required_argument,
+ .val = 'K',
+ },
{
.name = NULL,
},
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
}
}
free_threads_shm();
}
+ free(trigger_file);
+ free(trigger_cmd);
+ free(trigger_remote_cmd);
+ trigger_file = trigger_cmd = trigger_remote_cmd = NULL;
+
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);
o->timeout = def_timeout;
}
+static void dump_print_option(struct print_option *p)
+{
+ const char *delim;
+
+ if (!strcmp("description", p->name))
+ delim = "\"";
+ else
+ delim = "";
+
+ log_info("--%s%s", p->name, p->value ? "" : " ");
+ if (p->value)
+ log_info("=%s%s%s ", delim, p->value, delim);
+}
+
+static void dump_opt_list(struct thread_data *td)
+{
+ struct flist_head *entry;
+ struct print_option *p;
+
+ if (flist_empty(&td->opt_list))
+ return;
+
+ flist_for_each(entry, &td->opt_list) {
+ p = flist_entry(entry, struct print_option, list);
+ dump_print_option(p);
+ }
+}
+
+static void fio_dump_options_free(struct thread_data *td)
+{
+ while (!flist_empty(&td->opt_list)) {
+ struct print_option *p;
+
+ p = flist_first_entry(&td->opt_list, struct print_option, list);
+ flist_del_init(&p->list);
+ free(p->name);
+ free(p->value);
+ free(p);
+ }
+}
+
+static void copy_opt_list(struct thread_data *dst, struct thread_data *src)
+{
+ struct flist_head *entry;
+
+ if (flist_empty(&src->opt_list))
+ return;
+
+ flist_for_each(entry, &src->opt_list) {
+ struct print_option *srcp, *dstp;
+
+ srcp = flist_entry(entry, struct print_option, list);
+ dstp = malloc(sizeof(*dstp));
+ dstp->name = strdup(srcp->name);
+ if (srcp->value)
+ dstp->value = strdup(srcp->value);
+ else
+ dstp->value = NULL;
+ flist_add_tail(&dstp->list, &dst->opt_list);
+ }
+}
+
/*
* 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;
td = &threads[thread_number++];
*td = *parent;
+ INIT_FLIST_HEAD(&td->opt_list);
+ if (parent != &def_thread)
+ copy_opt_list(td, parent);
+
td->io_ops = NULL;
if (!preserve_eo)
td->eo = NULL;
profile_add_hooks(td);
td->thread_number = thread_number;
+ td->subjob_number = 0;
+
+ if (jobname)
+ td->o.name = strdup(jobname);
- if (!parent->o.group_reporting)
+ if (!parent->o.group_reporting || parent == &def_thread)
stat_number++;
set_cmd_options(td);
log_info("fio: %s\n", td->verror);
fio_options_free(td);
+ fio_dump_options_free(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--;
}
if (td->o.rate[ddir])
td->rate_bps[ddir] = td->o.rate[ddir];
else
- td->rate_bps[ddir] = td->o.rate_iops[ddir] * bs;
+ td->rate_bps[ddir] = (uint64_t) td->o.rate_iops[ddir] * bs;
if (!td->rate_bps[ddir]) {
log_err("rate lower than supported\n");
return -1;
}
- td->rate_pending_usleep[ddir] = 0;
+ td->rate_next_io_time[ddir] = 0;
+ td->rate_io_issue_bytes[ddir] = 0;
+ td->last_usec = 0;
return 0;
}
static unsigned long long get_rand_start_delay(struct thread_data *td)
{
unsigned long long delayrange;
+ uint64_t frand_max;
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)));
- }
+ frand_max = rand_max(&td->delay_state);
+ r = __rand(&td->delay_state);
+ delayrange = (unsigned long long) ((double) delayrange * (r / (frand_max + 1.0)));
delayrange += td->o.start_delay;
return delayrange;
if (!o->max_bs[DDIR_TRIM])
o->max_bs[DDIR_TRIM] = o->bs[DDIR_TRIM];
-
o->rw_min_bs = min(o->min_bs[DDIR_READ], o->min_bs[DDIR_WRITE]);
o->rw_min_bs = min(o->min_bs[DDIR_TRIM], o->rw_min_bs);
if (o->norandommap && o->verify != VERIFY_NONE
&& !fixed_block_size(o)) {
log_err("fio: norandommap given for variable block sizes, "
- "verify disabled\n");
- o->verify = VERIFY_NONE;
+ "verify limited\n");
ret = warnings_fatal;
}
if (o->bs_unaligned && (o->odirect || td->io_ops->flags & FIO_RAWIO))
if (o->iodepth_batch > o->iodepth || !o->iodepth_batch)
o->iodepth_batch = o->iodepth;
+ /*
+ * If max batch complete number isn't set or set incorrectly,
+ * default to the same as iodepth_batch_complete_min
+ */
+ if (o->iodepth_batch_complete_min > o->iodepth_batch_complete_max)
+ o->iodepth_batch_complete_max = o->iodepth_batch_complete_min;
+
if (o->nr_files > td->files_index)
o->nr_files = td->files_index;
log_err("fio: rate and rate_iops are mutually exclusive\n");
ret = 1;
}
- if ((o->rate[DDIR_READ] < o->ratemin[DDIR_READ]) ||
- (o->rate[DDIR_WRITE] < o->ratemin[DDIR_WRITE]) ||
- (o->rate[DDIR_TRIM] < o->ratemin[DDIR_TRIM]) ||
- (o->rate_iops[DDIR_READ] < o->rate_iops_min[DDIR_READ]) ||
- (o->rate_iops[DDIR_WRITE] < o->rate_iops_min[DDIR_WRITE]) ||
- (o->rate_iops[DDIR_TRIM] < o->rate_iops_min[DDIR_TRIM])) {
+ if ((o->rate[DDIR_READ] && (o->rate[DDIR_READ] < o->ratemin[DDIR_READ])) ||
+ (o->rate[DDIR_WRITE] && (o->rate[DDIR_WRITE] < o->ratemin[DDIR_WRITE])) ||
+ (o->rate[DDIR_TRIM] && (o->rate[DDIR_TRIM] < o->ratemin[DDIR_TRIM])) ||
+ (o->rate_iops[DDIR_READ] && (o->rate_iops[DDIR_READ] < o->rate_iops_min[DDIR_READ])) ||
+ (o->rate_iops[DDIR_WRITE] && (o->rate_iops[DDIR_WRITE] < o->rate_iops_min[DDIR_WRITE])) ||
+ (o->rate_iops[DDIR_TRIM] && (o->rate_iops[DDIR_TRIM] < o->rate_iops_min[DDIR_TRIM]))) {
log_err("fio: minimum rate exceeds rate\n");
ret = 1;
}
ret = warnings_fatal;
}
- o->refill_buffers = 1;
+ if (!fio_option_is_set(o, refill_buffers))
+ o->refill_buffers = 1;
+
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) {
/*
* For fully compressible data, just zero them at init time.
- * It's faster than repeatedly filling it.
+ * It's faster than repeatedly filling it. For non-zero
+ * compression, we should have refill_buffers set. Set it, unless
+ * the job file already changed it.
*/
- if (td->o.compress_percentage == 100) {
- td->o.zero_buffers = 1;
- td->o.compress_percentage = 0;
+ if (o->compress_percentage) {
+ if (o->compress_percentage == 100) {
+ o->zero_buffers = 1;
+ o->compress_percentage = 0;
+ } else if (!fio_option_is_set(o, refill_buffers))
+ o->refill_buffers = 1;
}
/*
/*
* If randseed is set, that overrides randrepeat
*/
- if (td->o.rand_seed)
+ if (fio_option_is_set(&td->o, rand_seed))
td->o.rand_repeatable = 0;
if ((td->io_ops->flags & FIO_NOEXTEND) && td->o.file_append) {
ret = 1;
}
+ if (fio_option_is_set(o, gtod_cpu)) {
+ fio_gtod_init();
+ fio_gtod_set_cpu(o->gtod_cpu);
+ fio_gtod_offload = 1;
+ }
+
+ td->loops = o->loops;
+ if (!td->loops)
+ td->loops = 1;
+
+ if (td->o.block_error_hist && td->o.nr_files != 1) {
+ log_err("fio: block error histogram only available with "
+ "with a single file per job, but %d files "
+ "provided\n", td->o.nr_files);
+ ret = 1;
+ }
+
return ret;
}
return 1;
}
-static void td_fill_rand_seeds_os(struct thread_data *td)
+static void init_rand_file_service(struct thread_data *td)
{
- os_random_seed(td->rand_seeds[FIO_RAND_BS_OFF], &td->bsrange_state);
- os_random_seed(td->rand_seeds[FIO_RAND_VER_OFF], &td->verify_state);
- os_random_seed(td->rand_seeds[FIO_RAND_MIX_OFF], &td->rwmix_state);
-
- if (td->o.file_service_type == FIO_FSERVICE_RANDOM)
- os_random_seed(td->rand_seeds[FIO_RAND_FILE_OFF], &td->next_file_state);
-
- 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;
-
- if (td->o.rand_repeatable)
- 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]);
+ unsigned long nranges = td->o.nr_files << FIO_FSERVICE_SHIFT;
+ const unsigned int seed = td->rand_seeds[FIO_RAND_FILE_OFF];
+
+ if (td->o.file_service_type == FIO_FSERVICE_ZIPF) {
+ zipf_init(&td->next_file_zipf, nranges, td->zipf_theta, seed);
+ zipf_disable_hash(&td->next_file_zipf);
+ } else if (td->o.file_service_type == FIO_FSERVICE_PARETO) {
+ pareto_init(&td->next_file_zipf, nranges, td->pareto_h, seed);
+ zipf_disable_hash(&td->next_file_zipf);
+ } else if (td->o.file_service_type == FIO_FSERVICE_GAUSS) {
+ gauss_init(&td->next_file_gauss, nranges, td->gauss_dev, seed);
+ gauss_disable_hash(&td->next_file_gauss);
+ }
}
-static void td_fill_rand_seeds_internal(struct thread_data *td)
+static void td_fill_rand_seeds_internal(struct thread_data *td, bool use64)
{
- init_rand_seed(&td->__bsrange_state, td->rand_seeds[FIO_RAND_BS_OFF]);
- init_rand_seed(&td->__verify_state, td->rand_seeds[FIO_RAND_VER_OFF]);
- init_rand_seed(&td->__rwmix_state, td->rand_seeds[FIO_RAND_MIX_OFF]);
+ int i;
+
+ init_rand_seed(&td->bsrange_state, td->rand_seeds[FIO_RAND_BS_OFF], use64);
+ init_rand_seed(&td->verify_state, td->rand_seeds[FIO_RAND_VER_OFF], use64);
+ init_rand_seed(&td->rwmix_state, td->rand_seeds[FIO_RAND_MIX_OFF], false);
if (td->o.file_service_type == FIO_FSERVICE_RANDOM)
- init_rand_seed(&td->__next_file_state, td->rand_seeds[FIO_RAND_FILE_OFF]);
+ init_rand_seed(&td->next_file_state, td->rand_seeds[FIO_RAND_FILE_OFF], use64);
+ else if (td->o.file_service_type & __FIO_FSERVICE_NONUNIFORM)
+ init_rand_file_service(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]);
+ init_rand_seed(&td->file_size_state, td->rand_seeds[FIO_RAND_FILE_SIZE_OFF], use64);
+ init_rand_seed(&td->trim_state, td->rand_seeds[FIO_RAND_TRIM_OFF], use64);
+ init_rand_seed(&td->delay_state, td->rand_seeds[FIO_RAND_START_DELAY], use64);
+ init_rand_seed(&td->poisson_state, td->rand_seeds[FIO_RAND_POISSON_OFF], 0);
+ init_rand_seed(&td->dedupe_state, td->rand_seeds[FIO_DEDUPE_OFF], false);
+ init_rand_seed(&td->zone_state, td->rand_seeds[FIO_RAND_ZONE_OFF], false);
if (!td_random(td))
return;
if (td->o.rand_repeatable)
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]);
+ init_rand_seed(&td->random_state, td->rand_seeds[FIO_RAND_BLOCK_OFF], use64);
+
+ for (i = 0; i < DDIR_RWDIR_CNT; i++) {
+ struct frand_state *s = &td->seq_rand_state[i];
+
+ init_rand_seed(s, td->rand_seeds[FIO_RAND_SEQ_RAND_READ_OFF], false);
+ }
}
void td_fill_rand_seeds(struct thread_data *td)
{
+ bool use64;
+
if (td->o.allrand_repeatable) {
- for (int i = 0; i < FIO_RAND_NR_OFFS; i++)
+ 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);
+ if (td->o.random_generator == FIO_RAND_GEN_TAUSWORTHE64)
+ use64 = 1;
else
- td_fill_rand_seeds_internal(td);
+ use64 = 0;
+
+ td_fill_rand_seeds_internal(td, use64);
- init_rand_seed(&td->buf_state, td->rand_seeds[FIO_RAND_BUF_OFF]);
+ init_rand_seed(&td->buf_state, td->rand_seeds[FIO_RAND_BUF_OFF], use64);
+ frand_copy(&td->buf_state_prev, &td->buf_state);
}
/*
td->flags |= TD_F_READ_IOLOG;
if (o->refill_buffers)
td->flags |= TD_F_REFILL_BUFFERS;
- if (o->scramble_buffers)
+ /*
+ * Always scramble buffers if asked to
+ */
+ if (o->scramble_buffers && fio_option_is_set(o, scramble_buffers))
+ td->flags |= TD_F_SCRAMBLE_BUFFERS;
+ /*
+ * But also scramble buffers, unless we were explicitly asked
+ * to zero them.
+ */
+ if (o->scramble_buffers && !(o->zero_buffers &&
+ fio_option_is_set(o, zero_buffers)))
td->flags |= TD_F_SCRAMBLE_BUFFERS;
if (o->verify != VERIFY_NONE)
td->flags |= TD_F_VER_NONE;
+
+ if (o->verify_async || o->io_submit_mode == IO_MODE_OFFLOAD)
+ td->flags |= TD_F_NEED_LOCK;
}
static int setup_random_seeds(struct thread_data *td)
unsigned long seed;
unsigned int i;
- if (!td->o.rand_repeatable && !td->o.rand_seed)
+ if (!td->o.rand_repeatable && !fio_option_is_set(&td->o, rand_seed))
return init_random_state(td, td->rand_seeds, sizeof(td->rand_seeds));
- if (!td->o.rand_seed)
- seed = 0x89;
- else
- seed = td->o.rand_seed;
-
+ seed = td->o.rand_seed;
for (i = 0; i < 4; i++)
seed *= 0x9e370001UL;
for (i = 0; i < FIO_RAND_NR_OFFS; i++) {
- td->rand_seeds[i] = seed;
+ td->rand_seeds[i] = seed * td->thread_number + i;
seed *= 0x9e370001UL;
}
{ .keyword = NULL, },
};
-static char *make_filename(char *buf, struct thread_options *o,
+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;
for (f = &fpre_keywords[0]; f->keyword; f++)
f->strlen = strlen(f->keyword);
- strcpy(buf, o->filename_format);
+ 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 {
ret = snprintf(dst, dst_left, "%s", jobname);
if (ret < 0)
break;
- dst += ret;
- dst_left -= ret;
+ else if (ret > dst_left) {
+ log_err("fio: truncated filename\n");
+ dst += dst_left;
+ dst_left = 0;
+ } else {
+ dst += ret;
+ dst_left -= ret;
+ }
break;
}
case FPRE_JOBNUM: {
ret = snprintf(dst, dst_left, "%d", jobnum);
if (ret < 0)
break;
- dst += ret;
- dst_left -= ret;
+ else if (ret > dst_left) {
+ log_err("fio: truncated filename\n");
+ dst += dst_left;
+ dst_left = 0;
+ } else {
+ dst += ret;
+ dst_left -= ret;
+ }
break;
}
case FPRE_FILENUM: {
ret = snprintf(dst, dst_left, "%d", filenum);
if (ret < 0)
break;
- dst += ret;
- dst_left -= ret;
+ else if (ret > dst_left) {
+ log_err("fio: truncated filename\n");
+ dst += dst_left;
+ dst_left = 0;
+ } else {
+ dst += ret;
+ dst_left -= ret;
+ }
break;
}
default:
if (post_start)
strncpy(dst, buf + post_start, dst_left);
- strcpy(buf, copy);
+ strncpy(buf, copy, buf_size - 1);
} while (1);
}
return dump_cmdline || parse_only;
}
+static void gen_log_name(char *name, size_t size, const char *logtype,
+ const char *logname, unsigned int num,
+ const char *suf, int per_job)
+{
+ if (per_job)
+ snprintf(name, size, "%s_%s.%d.%s", logname, logtype, num, suf);
+ else
+ snprintf(name, size, "%s_%s.%s", logname, logtype, suf);
+}
+
+static int check_waitees(char *waitee)
+{
+ struct thread_data *td;
+ int i, ret = 0;
+
+ for_each_td(td, i) {
+ if (td->subjob_number)
+ continue;
+
+ ret += !strcmp(td->o.name, waitee);
+ }
+
+ return ret;
+}
+
+static bool wait_for_ok(const char *jobname, struct thread_options *o)
+{
+ int nw;
+
+ if (!o->wait_for)
+ return true;
+
+ if (!strcmp(jobname, o->wait_for)) {
+ log_err("%s: a job cannot wait for itself (wait_for=%s).\n",
+ jobname, o->wait_for);
+ return false;
+ }
+
+ if (!(nw = check_waitees(o->wait_for))) {
+ log_err("%s: waitee job %s unknown.\n", jobname, o->wait_for);
+ return false;
+ }
+
+ if (nw > 1) {
+ log_err("%s: multiple waitees %s found,\n"
+ "please avoid duplicates when using wait_for option.\n",
+ jobname, o->wait_for);
+ return false;
+ }
+
+ return true;
+}
+
/*
* Adds a job to the list of things todo. Sanitizes the various options
* to make sure we don't have conflicts, and initializes various
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
add_file(td, jobname, job_add_num, 0);
else {
for (i = 0; i < o->nr_files; i++)
- add_file(td, make_filename(fname, o, jobname, job_add_num, i), job_add_num, 0);
+ add_file(td, make_filename(fname, sizeof(fname), o, jobname, job_add_num, i), job_add_num, 0);
}
}
if (fixup_options(td))
goto err;
+ /*
+ * Belongs to fixup_options, but o->name is not necessarily set as yet
+ */
+ if (!wait_for_ok(jobname, o))
+ goto err;
+
flow_init_job(td);
/*
if ((o->stonewall || o->new_group) && prev_group_jobs) {
prev_group_jobs = 0;
groupid++;
+ if (groupid == INT_MAX) {
+ log_err("fio: too many groups defined\n");
+ goto err;
+ }
}
td->groupid = groupid;
if (setup_rate(td))
goto err;
- if (o->lat_log_file || write_lat_log) {
- setup_log(&td->lat_log, o->log_avg_msec, IO_LOG_TYPE_LAT);
- setup_log(&td->slat_log, o->log_avg_msec, IO_LOG_TYPE_SLAT);
- setup_log(&td->clat_log, o->log_avg_msec, IO_LOG_TYPE_CLAT);
+ if (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";
+
+ gen_log_name(logname, sizeof(logname), "lat", o->lat_log_file,
+ td->thread_number, suf, o->per_job_logs);
+ setup_log(&td->lat_log, &p, logname);
+
+ gen_log_name(logname, sizeof(logname), "slat", o->lat_log_file,
+ td->thread_number, suf, o->per_job_logs);
+ setup_log(&td->slat_log, &p, logname);
+
+ gen_log_name(logname, sizeof(logname), "clat", o->lat_log_file,
+ td->thread_number, suf, o->per_job_logs);
+ setup_log(&td->clat_log, &p, logname);
+ }
+ 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 (fio_option_is_set(o, bw_avg_time))
+ p.avg_msec = min(o->log_avg_msec, o->bw_avg_time);
+ else
+ o->bw_avg_time = p.avg_msec;
+
+ if (p.log_gz_store)
+ suf = "log.fz";
+ else
+ suf = "log";
+
+ gen_log_name(logname, sizeof(logname), "bw", o->bw_log_file,
+ td->thread_number, suf, o->per_job_logs);
+ 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 (fio_option_is_set(o, iops_avg_time))
+ p.avg_msec = min(o->log_avg_msec, o->iops_avg_time);
+ else
+ o->iops_avg_time = p.avg_msec;
+
+ if (p.log_gz_store)
+ suf = "log.fz";
+ else
+ suf = "log";
+
+ gen_log_name(logname, sizeof(logname), "iops", o->iops_log_file,
+ td->thread_number, suf, o->per_job_logs);
+ setup_log(&td->iops_log, &p, logname);
}
- if (o->bw_log_file || write_bw_log)
- setup_log(&td->bw_log, o->log_avg_msec, IO_LOG_TYPE_BW);
- if (o->iops_log_file)
- setup_log(&td->iops_log, o->log_avg_msec, IO_LOG_TYPE_IOPS);
if (!o->name)
o->name = strdup(jobname);
- if (output_format == FIO_OUTPUT_NORMAL) {
+ if (output_format & FIO_OUTPUT_NORMAL) {
if (!job_add_num) {
if (is_backend && !recursed)
fio_server_send_add_job(td);
*/
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) {
if (td_new->files) {
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, 0);
+ fio_options_parse(td_parent, (char **) &o[i], 1);
else
- fio_options_parse(td, (char **) &o[i], 1, 0);
+ fio_options_parse(td, (char **) &o[i], 1);
i++;
}
/*
* This is our [ini] type file parser.
*/
-int parse_jobs_ini(char *file, int is_buf, int stonewall_flag, int type)
+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;
+ }
- /*
- * Separate 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,
+ *ts, *full_fn = NULL;
+
+ /*
+ * Allow for the include filename
+ * specification to be relative.
+ */
+ if (access(filename, F_OK) &&
+ (ts = strrchr(file, '/'))) {
+ int len = ts - file +
+ strlen(filename) + 2;
+
+ if (!(full_fn = calloc(1, len))) {
+ ret = ENOMEM;
+ break;
+ }
+
+ strncpy(full_fn,
+ file, (ts - file) + 1);
+ strncpy(full_fn + (ts - file) + 1,
+ filename, strlen(filename));
+ full_fn[len - 1] = 0;
+ filename = full_fn;
+ }
+
+ ret = __parse_jobs_ini(td, filename, is_buf,
+ stonewall_flag, type, 1,
+ name, &opts,
+ &alloc_opts, &num_opts);
+
+ if (ret) {
+ log_err("Error %d while parsing "
+ "include file %s\n",
+ ret, filename);
+ }
+
+ if (full_fn)
+ free(full_fn);
+
+ if (ret)
+ break;
+
+ continue;
+ }
+
if (num_opts == alloc_opts) {
alloc_opts <<= 1;
opts = realloc(opts,
num_opts++;
}
- ret = fio_options_parse(td, opts, num_opts, dump_cmdline);
- if (!ret)
+ if (nested) {
+ *popts = opts;
+ *aopts = alloc_opts;
+ *nopts = num_opts;
+ goto out;
+ }
+
+ ret = fio_options_parse(td, opts, num_opts);
+ if (!ret) {
+ if (dump_cmdline)
+ dump_opt_list(td);
+
ret = add_job(td, name, 0, 0, type);
- else {
+ } else {
log_err("fio: job %s dropped\n", name);
put_job(td);
}
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));
+ INIT_FLIST_HEAD(&def_thread.opt_list);
fio_getaffinity(getpid(), &def_thread.o.cpumask);
def_thread.o.error_dump = 1;
return 0;
}
+static void show_debug_categories(void)
+{
+#ifdef FIO_INC_DEBUG
+ struct debug_level *dl = &debug_levels[0];
+ int curlen, first = 1;
+
+ curlen = 0;
+ while (dl->name) {
+ int has_next = (dl + 1)->name != NULL;
+
+ if (first || curlen + strlen(dl->name) >= 80) {
+ if (!first) {
+ printf("\n");
+ curlen = 0;
+ }
+ curlen += printf("\t\t\t%s", dl->name);
+ curlen += 3 * (8 - 1);
+ if (has_next)
+ curlen += printf(",");
+ } else {
+ curlen += printf("%s", dl->name);
+ if (has_next)
+ curlen += printf(",");
+ }
+ dl++;
+ first = 0;
+ }
+ printf("\n");
+#endif
+}
+
static void usage(const char *name)
{
printf("%s\n", fio_version_string);
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,rate\n");
+ printf(" --debug=options\tEnable debug logging. May be one/more of:\n");
+ show_debug_categories();
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(" --output-format=x\tOutput format (terse,json,json+,normal)\n");
printf(" --terse-version=x\tSet terse version output format to 'x'\n");
printf(" --version\t\tPrint version info and exit\n");
printf(" --help\t\tPrint this page\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(" --trigger-file=file\tExecute trigger cmd when file exists\n");
+ printf(" --trigger-timeout=t\tExecute trigger af this time\n");
+ printf(" --trigger=cmd\t\tSet this command as local trigger\n");
+ printf(" --trigger-remote=cmd\tSet this command as remote trigger\n");
+ printf(" --aux-path=path\tUse this path for fio state generated files\n");
printf("\nFio was written by Jens Axboe <jens.axboe@oracle.com>");
printf("\n Jens Axboe <jaxboe@fusionio.com>");
printf("\n Jens Axboe <axboe@fb.com>\n");
.help = "Rate logging",
.shift = FD_RATE,
},
+ { .name = "compress",
+ .help = "Log compression logging",
+ .shift = FD_COMPRESS,
+ },
{ .name = NULL, },
};
char *opt;
int i;
+ if (!string)
+ return 0;
+
if (!strcmp(string, "?") || !strcmp(string, "help")) {
log_info("fio: dumping debug options:");
for (i = 0; debug_levels[i].name; i++) {
fio_client_add_cmd_option(client, opt);
}
+static void show_closest_option(const char *name)
+{
+ int best_option, best_distance;
+ int i, distance;
+
+ while (*name == '-')
+ name++;
+
+ best_option = -1;
+ best_distance = INT_MAX;
+ i = 0;
+ while (l_opts[i].name) {
+ distance = string_distance(name, l_opts[i].name);
+ if (distance < best_distance) {
+ best_distance = distance;
+ best_option = i;
+ }
+ i++;
+ }
+
+ if (best_option != -1 && string_distance_ok(name, best_distance))
+ log_err("Did you mean %s?\n", l_opts[best_option].name);
+}
+
+static int parse_output_format(const char *optarg)
+{
+ char *p, *orig, *opt;
+ int ret = 0;
+
+ p = orig = strdup(optarg);
+
+ output_format = 0;
+
+ while ((opt = strsep(&p, ",")) != NULL) {
+ if (!strcmp(opt, "minimal") ||
+ !strcmp(opt, "terse") ||
+ !strcmp(opt, "csv"))
+ output_format |= FIO_OUTPUT_TERSE;
+ else if (!strcmp(opt, "json"))
+ output_format |= FIO_OUTPUT_JSON;
+ else if (!strcmp(opt, "json+"))
+ output_format |= (FIO_OUTPUT_JSON | FIO_OUTPUT_JSON_PLUS);
+ else if (!strcmp(opt, "normal"))
+ output_format |= FIO_OUTPUT_NORMAL;
+ else {
+ log_err("fio: invalid output format %s\n", opt);
+ ret = 1;
+ break;
+ }
+ }
+
+ free(orig);
+ return ret;
+}
+
int parse_cmd_line(int argc, char *argv[], int client_type)
{
struct thread_data *td = NULL;
}
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)
+ if (f_out && f_out != stdout)
fclose(f_out);
f_out = fopen(optarg, "w+");
do_exit++;
break;
}
- if (!strcmp(optarg, "minimal") ||
- !strcmp(optarg, "terse") ||
- !strcmp(optarg, "csv"))
- output_format = FIO_OUTPUT_TERSE;
- else if (!strcmp(optarg, "json"))
- output_format = FIO_OUTPUT_JSON;
- else
- output_format = FIO_OUTPUT_NORMAL;
+ if (parse_output_format(optarg)) {
+ log_err("fio: failed parsing output-format\n");
+ exit_val = 1;
+ do_exit++;
+ break;
+ }
break;
case 'f':
- append_terse_output = 1;
+ output_format |= FIO_OUTPUT_TERSE;
break;
case 'h':
did_arg = 1;
case 'E': {
long long t = 0;
- if (str_to_decimal(optarg, &t, 0, NULL, 1)) {
+ if (check_str_time(optarg, &t, 1)) {
log_err("fio: failed parsing eta time %s\n", optarg);
exit_val = 1;
do_exit++;
}
- eta_new_line = t;
+ eta_new_line = t / 1000;
break;
}
case 'd':
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)
if (is_section && skip_this_section(val))
continue;
- td = get_new_job(global, &def_thread, 1);
- if (!td || ioengine_load(td))
- goto out_free;
+ td = get_new_job(global, &def_thread, 1, NULL);
+ if (!td || ioengine_load(td)) {
+ if (td) {
+ put_job(td);
+ td = NULL;
+ }
+ do_exit++;
+ exit_val = 1;
+ break;
+ }
fio_options_set_ioengine_opts(l_opts, td);
}
td = NULL;
}
do_exit++;
+ exit_val = 1;
}
if (!ret && !strcmp(opt, "ioengine")) {
free_ioengine(td);
- if (ioengine_load(td))
- goto out_free;
+ if (ioengine_load(td)) {
+ put_job(td);
+ td = NULL;
+ do_exit++;
+ exit_val = 1;
+ break;
+ }
fio_options_set_ioengine_opts(l_opts, td);
}
break;
break;
ret = fio_cmd_ioengine_option_parse(td, opt, val);
- did_arg = 1;
break;
}
case 'w':
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)
exit_val = 1;
break;
}
+ /* if --client parameter contains a pathname */
+ if (0 == access(optarg, R_OK)) {
+ /* file contains a list of host addrs or names */
+ char hostaddr[PATH_MAX] = {0};
+ char formatstr[8];
+ FILE * hostf = fopen(optarg, "r");
+ if (!hostf) {
+ log_err("fio: could not open client list file %s for read\n", optarg);
+ do_exit++;
+ exit_val = 1;
+ break;
+ }
+ sprintf(formatstr, "%%%ds", PATH_MAX - 1);
+ /*
+ * read at most PATH_MAX-1 chars from each
+ * record in this file
+ */
+ while (fscanf(hostf, formatstr, hostaddr) == 1) {
+ /* expect EVERY host in file to be valid */
+ if (fio_client_add(&fio_client_ops, hostaddr, &cur_client)) {
+ log_err("fio: failed adding client %s from file %s\n", hostaddr, optarg);
+ do_exit++;
+ exit_val = 1;
+ break;
+ }
+ }
+ fclose(hostf);
+ break; /* no possibility of job file for "this client only" */
+ }
if (fio_client_add(&fio_client_ops, optarg, &cur_client)) {
log_err("fio: failed adding client %s\n", optarg);
do_exit++;
!strncmp(argv[optind], "-", 1))
break;
- fio_client_add_ini_file(cur_client, argv[optind]);
+ if (fio_client_add_ini_file(cur_client, argv[optind], false))
+ break;
optind++;
}
break;
+ case 'R':
+ did_arg = 1;
+ if (fio_client_add_ini_file(cur_client, optarg, true)) {
+ do_exit++;
+ exit_val = 1;
+ }
+ break;
case 'T':
did_arg = 1;
do_exit++;
- exit_val = fio_monotonic_clocktest();
+ exit_val = fio_monotonic_clocktest(1);
break;
case 'G':
did_arg = 1;
case 'L': {
long long val;
- if (check_str_time(optarg, &val, 0)) {
+ if (check_str_time(optarg, &val, 1)) {
log_err("fio: failed parsing time %s\n", optarg);
do_exit++;
exit_val = 1;
break;
}
- status_interval = val * 1000;
+ status_interval = val / 1000;
+ break;
+ }
+ case 'W':
+ if (trigger_file)
+ free(trigger_file);
+ trigger_file = strdup(optarg);
+ break;
+ case 'H':
+ if (trigger_cmd)
+ free(trigger_cmd);
+ trigger_cmd = strdup(optarg);
+ break;
+ case 'J':
+ if (trigger_remote_cmd)
+ free(trigger_remote_cmd);
+ trigger_remote_cmd = strdup(optarg);
break;
+ case 'K':
+ if (aux_path)
+ free(aux_path);
+ aux_path = strdup(optarg);
+ break;
+ case 'B':
+ if (check_str_time(optarg, &trigger_timeout, 1)) {
+ log_err("fio: failed parsing time %s\n", optarg);
+ do_exit++;
+ exit_val = 1;
}
+ trigger_timeout /= 1000000;
+ break;
case '?':
log_err("%s: unrecognized option '%s'\n", argv[0],
argv[optind - 1]);
+ show_closest_option(argv[optind - 1]);
default:
do_exit++;
exit_val = 1;
return 0;
}
- if (def_thread.o.gtod_offload) {
- fio_gtod_init();
- fio_gtod_offload = 1;
- fio_gtod_cpu = def_thread.o.gtod_cpu;
- }
-
- if (output_format == FIO_OUTPUT_NORMAL)
+ if (output_format & FIO_OUTPUT_NORMAL)
log_info("%s\n", fio_version_string);
return 0;
{
memcpy(o, &def_thread.o, sizeof(*o));
}
+
+struct thread_data *get_global_options(void)
+{
+ return &def_thread;
+}
projects / fio.git / blobdiff