Check for ENOSPC on shmget() failure
[fio.git] / init.c
diff --git a/init.c b/init.c
index ee6c139db28c03da7f77727e403c5d6c3acb36a8..b3215f52fca3ebb2306c5e02e8437aac0a6d57fa 100644 (file)
--- a/init.c
+++ b/init.c
 
 #include "lib/getopt.h"
 
-#include "fio_version.h"
-
-#if FIO_PATCH > 0
-const char fio_version_string[] =      __fio_stringify(FIO_MAJOR) "."  \
-                                       __fio_stringify(FIO_MINOR) "."  \
-                                       __fio_stringify(FIO_PATCH);
-#else
-const char fio_version_string[] =      __fio_stringify(FIO_MAJOR) "."  \
-                                       __fio_stringify(FIO_MINOR);
-#endif
+const char fio_version_string[] = FIO_VERSION;
 
 #define FIO_RANDSEED           (0xb1899bedUL)
 
@@ -45,7 +36,7 @@ static struct thread_data def_thread;
 struct thread_data *threads = NULL;
 
 int exitall_on_terminate = 0;
-int terse_output = 0;
+int output_format = FIO_OUTPUT_NORMAL;
 int eta_print;
 unsigned long long mlock_size = 0;
 FILE *f_out = NULL;
@@ -74,21 +65,23 @@ static char cmd_optstr[256];
 static int did_arg;
 
 const fio_fp64_t def_percentile_list[FIO_IO_U_LIST_MAX_LEN] = {
-       { .u.f  =  1.0 },
-       { .u.f  =  5.0 },
-       { .u.f  = 10.0 },
-       { .u.f  = 20.0 },
-       { .u.f  = 30.0 },
-       { .u.f  = 40.0 },
-       { .u.f  = 50.0 },
-       { .u.f  = 60.0 },
-       { .u.f  = 70.0 },
-       { .u.f  = 80.0 },
-       { .u.f  = 90.0 },
-       { .u.f  = 95.0 },
-       { .u.f  = 99.0 },
-       { .u.f  = 99.5 },
-       { .u.f  = 99.9 },
+       { .u.f  =  1.00 },
+       { .u.f  =  5.00 },
+       { .u.f  = 10.00 },
+       { .u.f  = 20.00 },
+       { .u.f  = 30.00 },
+       { .u.f  = 40.00 },
+       { .u.f  = 50.00 },
+       { .u.f  = 60.00 },
+       { .u.f  = 70.00 },
+       { .u.f  = 80.00 },
+       { .u.f  = 90.00 },
+       { .u.f  = 95.00 },
+       { .u.f  = 99.00 },
+       { .u.f  = 99.50 },
+       { .u.f  = 99.90 },
+       { .u.f  = 99.95 },
+       { .u.f  = 99.99 },
 };
 
 #define FIO_CLIENT_FLAG                (1 << 16)
@@ -123,6 +116,11 @@ static struct option l_opts[FIO_NR_OPTIONS] = {
                .has_arg        = optional_argument,
                .val            = 'm' | FIO_CLIENT_FLAG,
        },
+       {
+               .name           = (char *) "output-format",
+               .has_arg        = optional_argument,
+               .val            = 'F' | FIO_CLIENT_FLAG,
+       },
        {
                .name           = (char *) "version",
                .has_arg        = no_argument,
@@ -138,6 +136,11 @@ static struct option l_opts[FIO_NR_OPTIONS] = {
                .has_arg        = optional_argument,
                .val            = 'c' | FIO_CLIENT_FLAG,
        },
+       {
+               .name              = (char *) "enghelp",
+               .has_arg        = optional_argument,
+               .val                = 'i' | FIO_CLIENT_FLAG,
+       },
        {
                .name           = (char *) "showcmd",
                .has_arg        = no_argument,
@@ -216,6 +219,7 @@ static void free_shm(void)
 
                threads = NULL;
                file_hash_exit();
+               flow_exit();
                fio_debug_jobp = NULL;
                shmdt(tp);
                shmctl(shm_id, IPC_RMID, &sbuf);
@@ -250,7 +254,7 @@ static int setup_thread_area(void)
                shm_id = shmget(0, size, IPC_CREAT | 0600);
                if (shm_id != -1)
                        break;
-               if (errno != EINVAL) {
+               if (errno != EINVAL && errno != ENOMEM && errno != ENOSPC) {
                        perror("shmget");
                        break;
                }
@@ -272,13 +276,17 @@ static int setup_thread_area(void)
        fio_debug_jobp = (void *) hash + file_hash_size;
        *fio_debug_jobp = -1;
        file_hash_init(hash);
+
+       flow_init();
+
        return 0;
 }
 
 /*
  * Return a free job structure.
  */
-static struct thread_data *get_new_job(int global, struct thread_data *parent)
+static struct thread_data *get_new_job(int global, struct thread_data *parent,
+                                      int preserve_eo)
 {
        struct thread_data *td;
 
@@ -297,10 +305,14 @@ static struct thread_data *get_new_job(int global, struct thread_data *parent)
        td = &threads[thread_number++];
        *td = *parent;
 
+       td->io_ops = NULL;
+       if (!preserve_eo)
+               td->eo = NULL;
+
        td->o.uid = td->o.gid = -1U;
 
        dup_files(td, parent);
-       options_mem_dupe(td);
+       fio_options_mem_dupe(td);
 
        profile_add_hooks(td);
 
@@ -314,11 +326,14 @@ static void put_job(struct thread_data *td)
                return;
 
        profile_td_exit(td);
+       flow_exit_job(td);
 
        if (td->error)
                log_info("fio: %s\n", td->verror);
 
        fio_options_free(td);
+       if (td->io_ops)
+               free_ioengine(td);
 
        memset(&threads[td->thread_number - 1], 0, sizeof(*td));
        thread_number--;
@@ -327,21 +342,19 @@ static void put_job(struct thread_data *td)
 static int __setup_rate(struct thread_data *td, enum fio_ddir ddir)
 {
        unsigned int bs = td->o.min_bs[ddir];
-       unsigned long long bytes_per_sec;
 
        assert(ddir_rw(ddir));
 
        if (td->o.rate[ddir])
-               bytes_per_sec = td->o.rate[ddir];
+               td->rate_bps[ddir] = td->o.rate[ddir];
        else
-               bytes_per_sec = td->o.rate_iops[ddir] * bs;
+               td->rate_bps[ddir] = td->o.rate_iops[ddir] * bs;
 
-       if (!bytes_per_sec) {
+       if (!td->rate_bps[ddir]) {
                log_err("rate lower than supported\n");
                return -1;
        }
 
-       td->rate_nsec_cycle[ddir] = 1000000000ULL / bytes_per_sec;
        td->rate_pending_usleep[ddir] = 0;
        return 0;
 }
@@ -354,6 +367,8 @@ static int setup_rate(struct thread_data *td)
                ret = __setup_rate(td, DDIR_READ);
        if (td->o.rate[DDIR_WRITE] || td->o.rate_iops[DDIR_WRITE])
                ret |= __setup_rate(td, DDIR_WRITE);
+       if (td->o.rate[DDIR_TRIM] || td->o.rate_iops[DDIR_TRIM])
+               ret |= __setup_rate(td, DDIR_TRIM);
 
        return ret;
 }
@@ -362,7 +377,9 @@ static int fixed_block_size(struct thread_options *o)
 {
        return o->min_bs[DDIR_READ] == o->max_bs[DDIR_READ] &&
                o->min_bs[DDIR_WRITE] == o->max_bs[DDIR_WRITE] &&
-               o->min_bs[DDIR_READ] == o->min_bs[DDIR_WRITE];
+               o->min_bs[DDIR_TRIM] == o->max_bs[DDIR_TRIM] &&
+               o->min_bs[DDIR_READ] == o->min_bs[DDIR_WRITE] &&
+               o->min_bs[DDIR_READ] == o->min_bs[DDIR_TRIM];
 }
 
 /*
@@ -392,11 +409,18 @@ static int fixup_options(struct thread_data *td)
        }
 
        /*
-        * only really works for sequential io for now, and with 1 file
+        * only really works with 1 file
         */
-       if (o->zone_size && td_random(td) && o->open_files == 1)
+       if (o->zone_size && o->open_files == 1)
                o->zone_size = 0;
 
+       /*
+        * If zone_range isn't specified, backward compatibility dictates it
+        * should be made equal to zone_size.
+        */
+       if (o->zone_size && !o->zone_range)
+               o->zone_range = o->zone_size;
+
        /*
         * Reads can do overwrites, we always need to pre-create the file
         */
@@ -411,8 +435,14 @@ static int fixup_options(struct thread_data *td)
                o->min_bs[DDIR_WRITE] = o->bs[DDIR_WRITE];
        if (!o->max_bs[DDIR_WRITE])
                o->max_bs[DDIR_WRITE] = o->bs[DDIR_WRITE];
+       if (!o->min_bs[DDIR_TRIM])
+               o->min_bs[DDIR_TRIM] = o->bs[DDIR_TRIM];
+       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);
 
        /*
         * For random IO, allow blockalign offset other than min_bs.
@@ -421,9 +451,12 @@ static int fixup_options(struct thread_data *td)
                o->ba[DDIR_READ] = o->min_bs[DDIR_READ];
        if (!o->ba[DDIR_WRITE] || !td_random(td))
                o->ba[DDIR_WRITE] = o->min_bs[DDIR_WRITE];
+       if (!o->ba[DDIR_TRIM] || !td_random(td))
+               o->ba[DDIR_TRIM] = o->min_bs[DDIR_TRIM];
 
        if ((o->ba[DDIR_READ] != o->min_bs[DDIR_READ] ||
-           o->ba[DDIR_WRITE] != o->min_bs[DDIR_WRITE]) &&
+           o->ba[DDIR_WRITE] != o->min_bs[DDIR_WRITE] ||
+           o->ba[DDIR_TRIM] != o->min_bs[DDIR_TRIM]) &&
            !o->norandommap) {
                log_err("fio: Any use of blockalign= turns off randommap\n");
                o->norandommap = 1;
@@ -476,15 +509,19 @@ static int fixup_options(struct thread_data *td)
        if (o->open_files > o->nr_files || !o->open_files)
                o->open_files = o->nr_files;
 
-       if (((o->rate[0] + o->rate[1]) && (o->rate_iops[0] + o->rate_iops[1]))||
-           ((o->ratemin[0] + o->ratemin[1]) && (o->rate_iops_min[0] +
-               o->rate_iops_min[1]))) {
+       if (((o->rate[DDIR_READ] + o->rate[DDIR_WRITE] + o->rate[DDIR_TRIM]) &&
+           (o->rate_iops[DDIR_READ] + o->rate_iops[DDIR_WRITE] + o->rate_iops[DDIR_TRIM])) ||
+           ((o->ratemin[DDIR_READ] + o->ratemin[DDIR_WRITE] + o->ratemin[DDIR_TRIM]) &&
+           (o->rate_iops_min[DDIR_READ] + o->rate_iops_min[DDIR_WRITE] + o->rate_iops_min[DDIR_TRIM]))) {
                log_err("fio: rate and rate_iops are mutually exclusive\n");
                ret = 1;
        }
-       if ((o->rate[0] < o->ratemin[0]) || (o->rate[1] < o->ratemin[1]) ||
-           (o->rate_iops[0] < o->rate_iops_min[0]) ||
-           (o->rate_iops[1] < o->rate_iops_min[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])) {
                log_err("fio: minimum rate exceeds rate\n");
                ret = 1;
        }
@@ -533,6 +570,28 @@ static int fixup_options(struct thread_data *td)
        }
 #endif
 
+#ifdef WIN32
+       /*
+        * Windows doesn't support O_DIRECT or O_SYNC with the _open interface,
+        * so fail if we're passed those flags
+        */
+       if ((td->io_ops->flags & FIO_SYNCIO) && (td->o.odirect || td->o.sync_io)) {
+               log_err("fio: Windows does not support direct or non-buffered io with"
+                               " the synchronous ioengines. Use the 'windowsaio' ioengine"
+                               " with 'direct=1' and 'iodepth=1' instead.\n");
+               ret = 1;
+       }
+#endif
+
+       /*
+        * For fully compressible data, just zero them at init time.
+        * It's faster than repeatedly filling it.
+        */
+       if (td->o.compress_percentage == 100) {
+               td->o.zero_buffers = 1;
+               td->o.compress_percentage = 0;
+       }
+
        return ret;
 }
 
@@ -638,29 +697,60 @@ void td_fill_rand_seeds(struct thread_data *td)
        init_rand_seed(&td->buf_state, td->rand_seeds[7]);
 }
 
+
 /*
- * Initialize the various random states we need (random io, block size ranges,
- * read/write mix, etc).
+ * Initializes the ioengine configured for a job, if it has not been done so
+ * already.
  */
-static int init_random_state(struct thread_data *td)
+int ioengine_load(struct thread_data *td)
 {
-       int fd;
+       const char *engine;
 
-       fd = open("/dev/urandom", O_RDONLY);
-       if (fd == -1) {
-               td_verror(td, errno, "open");
+       /*
+        * Engine has already been loaded.
+        */
+       if (td->io_ops)
+               return 0;
+
+       engine = get_engine_name(td->o.ioengine);
+       td->io_ops = load_ioengine(td, engine);
+       if (!td->io_ops) {
+               log_err("fio: failed to load engine %s\n", engine);
                return 1;
        }
 
-       if (read(fd, td->rand_seeds, sizeof(td->rand_seeds)) <
-           (int) sizeof(td->rand_seeds)) {
-               td_verror(td, EIO, "read");
-               close(fd);
-               return 1;
+       if (td->io_ops->option_struct_size && td->io_ops->options) {
+               /*
+                * In cases where td->eo is set, clone it for a child thread.
+                * This requires that the parent thread has the same ioengine,
+                * but that requirement must be enforced by the code which
+                * cloned the thread.
+                */
+               void *origeo = td->eo;
+               /*
+                * Otherwise use the default thread options.
+                */
+               if (!origeo && td != &def_thread && def_thread.eo &&
+                   def_thread.io_ops->options == td->io_ops->options)
+                       origeo = def_thread.eo;
+
+               options_init(td->io_ops->options);
+               td->eo = malloc(td->io_ops->option_struct_size);
+               /*
+                * Use the default thread as an option template if this uses the
+                * same options structure and there are non-default options
+                * used.
+                */
+               if (origeo) {
+                       memcpy(td->eo, origeo, td->io_ops->option_struct_size);
+                       options_mem_dupe(td->eo, td->io_ops->options);
+               } else {
+                       memset(td->eo, 0, td->io_ops->option_struct_size);
+                       fill_default_options(td->eo, td->io_ops->options);
+               }
+               *(struct thread_data **)td->eo = td;
        }
 
-       close(fd);
-       td_fill_rand_seeds(td);
        return 0;
 }
 
@@ -672,9 +762,9 @@ static int init_random_state(struct thread_data *td)
 static int add_job(struct thread_data *td, const char *jobname, int job_add_num)
 {
        const char *ddir_str[] = { NULL, "read", "write", "rw", NULL,
-                                  "randread", "randwrite", "randrw" };
+                                  "randread", "randwrite", "randrw",
+                                  "trim", NULL, NULL, NULL, "randtrim" };
        unsigned int i;
-       const char *engine;
        char fname[PATH_MAX];
        int numjobs, file_alloced;
 
@@ -695,12 +785,8 @@ static int add_job(struct thread_data *td, const char *jobname, int job_add_num)
        if (profile_td_init(td))
                goto err;
 
-       engine = get_engine_name(td->o.ioengine);
-       td->io_ops = load_ioengine(td, engine);
-       if (!td->io_ops) {
-               log_err("fio: failed to load engine %s\n", engine);
+       if (ioengine_load(td))
                goto err;
-       }
 
        if (td->o.use_thread)
                nr_thread++;
@@ -728,6 +814,15 @@ static int add_job(struct thread_data *td, const char *jobname, int job_add_num)
        if (fixup_options(td))
                goto err;
 
+       flow_init_job(td);
+
+       /*
+        * IO engines only need this for option callbacks, and the address may
+        * change in subprocesses.
+        */
+       if (td->eo)
+               *(struct thread_data **)td->eo = NULL;
+
        if (td->io_ops->flags & FIO_DISKLESSIO) {
                struct fio_file *f;
 
@@ -735,7 +830,7 @@ static int add_job(struct thread_data *td, const char *jobname, int job_add_num)
                        f->real_file_size = -1ULL;
        }
 
-       td->mutex = fio_mutex_init(0);
+       td->mutex = fio_mutex_init(FIO_MUTEX_LOCKED);
 
        td->ts.clat_percentiles = td->o.clat_percentiles;
        if (td->o.overwrite_plist)
@@ -743,10 +838,12 @@ static int add_job(struct thread_data *td, const char *jobname, int job_add_num)
        else
                memcpy(td->ts.percentile_list, def_percentile_list, sizeof(def_percentile_list));
 
-       td->ts.clat_stat[0].min_val = td->ts.clat_stat[1].min_val = ULONG_MAX;
-       td->ts.slat_stat[0].min_val = td->ts.slat_stat[1].min_val = ULONG_MAX;
-       td->ts.lat_stat[0].min_val = td->ts.lat_stat[1].min_val = ULONG_MAX;
-       td->ts.bw_stat[0].min_val = td->ts.bw_stat[1].min_val = ULONG_MAX;
+       for (i = 0; i < DDIR_RWDIR_CNT; i++) {
+               td->ts.clat_stat[i].min_val = ULONG_MAX;
+               td->ts.slat_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;
 
        if ((td->o.stonewall || td->o.new_group) && prev_group_jobs) {
@@ -757,26 +854,28 @@ static int add_job(struct thread_data *td, const char *jobname, int job_add_num)
        td->groupid = groupid;
        prev_group_jobs++;
 
-       if (init_random_state(td))
+       if (init_random_state(td, td->rand_seeds, sizeof(td->rand_seeds))) {
+               td_verror(td, errno, "init_random_state");
                goto err;
+       }
 
        if (setup_rate(td))
                goto err;
 
        if (td->o.write_lat_log) {
-               setup_log(&td->lat_log);
-               setup_log(&td->slat_log);
-               setup_log(&td->clat_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 (td->o.write_bw_log)
-               setup_log(&td->bw_log);
+               setup_log(&td->bw_log, td->o.log_avg_msec);
        if (td->o.write_iops_log)
-               setup_log(&td->iops_log);
+               setup_log(&td->iops_log, td->o.log_avg_msec);
 
        if (!td->o.name)
                td->o.name = strdup(jobname);
 
-       if (!terse_output) {
+       if (output_format == FIO_OUTPUT_NORMAL) {
                if (!job_add_num) {
                        if (!strcmp(td->io_ops->name, "cpuio")) {
                                log_info("%s: ioengine=cpu, cpuload=%u,"
@@ -784,18 +883,20 @@ static int add_job(struct thread_data *td, const char *jobname, int job_add_num)
                                                        td->o.cpuload,
                                                        td->o.cpucycle);
                        } else {
-                               char *c1, *c2, *c3, *c4;
+                               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,"
+                               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,
+                                               c1, c2, c3, c4, c5, c6,
                                                td->io_ops->name,
                                                td->o.iodepth);
 
@@ -803,6 +904,8 @@ static int add_job(struct thread_data *td, const char *jobname, int job_add_num)
                                free(c2);
                                free(c3);
                                free(c4);
+                               free(c5);
+                               free(c6);
                        }
                } else if (job_add_num == 1)
                        log_info("...\n");
@@ -814,7 +917,7 @@ static int add_job(struct thread_data *td, const char *jobname, int job_add_num)
         */
        numjobs = td->o.numjobs;
        while (--numjobs) {
-               struct thread_data *td_new = get_new_job(0, td);
+               struct thread_data *td_new = get_new_job(0, td, 1);
 
                if (!td_new)
                        goto err;
@@ -862,11 +965,11 @@ void add_job_opts(const char **o)
                        sprintf(jobname, "%s", o[i] + 5);
                }
                if (in_global && !td_parent)
-                       td_parent = get_new_job(1, &def_thread);
+                       td_parent = get_new_job(1, &def_thread, 0);
                else if (!in_global && !td) {
                        if (!td_parent)
                                td_parent = &def_thread;
-                       td = get_new_job(0, td_parent);
+                       td = get_new_job(0, td_parent, 0);
                }
                if (in_global)
                        fio_options_parse(td_parent, (char **) &o[i], 1);
@@ -1001,7 +1104,7 @@ int parse_jobs_ini(char *file, int is_buf, int stonewall_flag)
                        first_sect = 0;
                }
 
-               td = get_new_job(global, &def_thread);
+               td = get_new_job(global, &def_thread, 0);
                if (!td) {
                        ret = 1;
                        break;
@@ -1105,21 +1208,26 @@ static int fill_def_thread(void)
 
 static void usage(const char *name)
 {
-       printf("fio %s\n", fio_version_string);
+       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\n");
        printf("  --output\t\tWrite output to file\n");
-       printf("  --timeout\t\tRuntime in seconds\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("  --terse-version=x\tSet terse version output format to 'x'\n");
        printf("  --version\t\tPrint version info and exit\n");
-       printf("  --terse-version=x\tTerse version output format to 'x'\n");
        printf("  --help\t\tPrint this page\n");
        printf("  --cmdhelp=cmd\t\tPrint command help, \"all\" for all of"
                " them\n");
+       printf("  --enghelp=engine\tPrint ioengine help, or list"
+               " available ioengines\n");
+       printf("  --enghelp=engine,cmd\tPrint help for an ioengine"
+               " cmd\n");
        printf("  --showcmd\t\tTurn a job file into command line options\n");
        printf("  --eta=when\t\tWhen ETA estimate should be printed\n");
        printf("            \t\tMay be \"always\", \"never\" or \"auto\"\n");
@@ -1304,7 +1412,17 @@ int parse_cmd_line(int argc, char *argv[])
                        f_err = f_out;
                        break;
                case 'm':
-                       terse_output = 1;
+                       output_format = FIO_OUTPUT_TERSE;
+                       break;
+               case 'F':
+                       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;
                        break;
                case 'h':
                        if (!cur_client) {
@@ -1318,6 +1436,12 @@ int parse_cmd_line(int argc, char *argv[])
                                do_exit++;
                        }
                        break;
+               case 'i':
+                       if (!cur_client) {
+                               fio_show_ioengine_help(optarg);
+                               do_exit++;
+                       }
+                       break;
                case 's':
                        dump_cmdline = 1;
                        break;
@@ -1326,13 +1450,14 @@ int parse_cmd_line(int argc, char *argv[])
                        break;
                case 'v':
                        if (!cur_client) {
-                               log_info("fio %s\n", fio_version_string);
+                               log_info("%s\n", fio_version_string);
                                do_exit++;
                        }
                        break;
                case 'V':
                        terse_version = atoi(optarg);
-                       if (!(terse_version == 2 || terse_version == 3)) {
+                       if (!(terse_version == 2 || terse_version == 3) ||
+                            (terse_version == 4)) {
                                log_err("fio: bad terse version format\n");
                                exit_val = 1;
                                do_exit++;
@@ -1387,12 +1512,28 @@ int parse_cmd_line(int argc, char *argv[])
                                if (is_section && skip_this_section(val))
                                        continue;
 
-                               td = get_new_job(global, &def_thread);
-                               if (!td)
+                               td = get_new_job(global, &def_thread, 1);
+                               if (!td || ioengine_load(td))
                                        return 0;
+                               fio_options_set_ioengine_opts(l_opts, td);
                        }
 
                        ret = fio_cmd_option_parse(td, opt, val);
+
+                       if (!ret && !strcmp(opt, "ioengine")) {
+                               free_ioengine(td);
+                               if (ioengine_load(td))
+                                       return 0;
+                               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;
+                       ret = fio_cmd_ioengine_option_parse(td, opt, val);
                        break;
                }
                case 'w':
@@ -1434,6 +1575,18 @@ int parse_cmd_line(int argc, char *argv[])
                                exit_val = 1;
                                break;
                        }
+                       /*
+                        * If the next argument exists and isn't an option,
+                        * assume it's a job file for this client only.
+                        */
+                       while (optind < argc) {
+                               if (!strncmp(argv[optind], "--", 2) ||
+                                   !strncmp(argv[optind], "-", 1))
+                                       break;
+
+                               fio_client_add_ini_file(cur_client, argv[optind]);
+                               optind++;
+                       }
                        break;
                default:
                        do_exit++;
@@ -1504,6 +1657,11 @@ int parse_options(int argc, char *argv[])
                                free(ini_file[i]);
                        }
                }
+       } else if (nr_clients) {
+               if (fill_def_thread())
+                       return 1;
+               if (fio_clients_send_ini(NULL))
+                       return 1;
        }
 
        free(ini_file);
@@ -1535,8 +1693,8 @@ int parse_options(int argc, char *argv[])
                fio_gtod_cpu = def_thread.o.gtod_cpu;
        }
 
-       if (!terse_output)
-               log_info("fio %s\n", fio_version_string);
+       if (output_format == FIO_OUTPUT_NORMAL)
+               log_info("%s\n", fio_version_string);
 
        return 0;
 }