Ensure that command line options also end up in json output

[fio.git] / init.c

diff --git a/init.c b/init.c
index af35ee6810eefdc1828bbb688b6802cd951c309d..8773138c766af52f8a77397d9bacf53378d14172 100644 (file)
--- a/init.c
+++ b/init.c
@@ -27,7 +27,7 @@
 #include "filelock.h"
 
 #include "lib/getopt.h"
-#include "lib/strcasestr.h"
+#include "oslib/strcasestr.h"
 
 #include "crc/test.h"
 
@@ -47,6 +47,7 @@ static char **job_sections;
 static int nr_job_sections;
 
 int exitall_on_terminate = 0;
+int exitall_on_terminate_error = 0;
 int output_format = FIO_OUTPUT_NORMAL;
 int eta_print = FIO_ETA_AUTO;
 int eta_new_line = 0;
@@ -384,6 +385,68 @@ static void set_cmd_options(struct thread_data *td)
                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.
  */
@@ -409,6 +472,10 @@ static struct thread_data *get_new_job(int global, struct thread_data *parent,
        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;
@@ -445,6 +512,7 @@ static void put_job(struct thread_data *td)
                log_info("fio: %s\n", td->verror);
 
        fio_options_free(td);
+       fio_dump_options_free(td);
        if (td->io_ops)
                free_ioengine(td);
 
@@ -737,11 +805,16 @@ static int fixup_options(struct thread_data *td)
 
        /*
         * 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;
        }
 
        /*
@@ -1438,9 +1511,9 @@ void add_job_opts(const char **o, int client_type)
                        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++;
        }
 
@@ -1680,10 +1753,13 @@ int __parse_jobs_ini(struct thread_data *td,
                        goto out;
                }
 
-               ret = fio_options_parse(td, opts, num_opts, dump_cmdline);
-               if (!ret)
+               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);
                }
@@ -1721,6 +1797,7 @@ int parse_jobs_ini(char *file, int is_buf, int stonewall_flag, int type)
 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;
@@ -1894,6 +1971,9 @@ static int set_debug(const char *string)
        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++) {
@@ -2576,3 +2656,8 @@ void options_default_fill(struct thread_options *o)
 {
        memcpy(o, &def_thread.o, sizeof(*o));
 }
+
+struct thread_data *get_global_options(void)
+{
+       return &def_thread;
+}