docs: description for experimental_verify
[fio.git] / init.c
CommitLineData
906c8d75 1/*
cb2c86fd 2 * This file contains job initialization and setup functions.
906c8d75 3 */
ebac4655
JA
4#include <stdio.h>
5#include <stdlib.h>
6#include <unistd.h>
ebac4655
JA
7#include <ctype.h>
8#include <string.h>
9#include <errno.h>
10#include <sys/ipc.h>
ebac4655 11#include <sys/types.h>
3e262e2f 12#include <dlfcn.h>
4f37732a
BVA
13#ifdef CONFIG_VALGRIND_DEV
14#include <valgrind/drd.h>
15#else
16#define DRD_IGNORE_VAR(x) do { } while (0)
17#endif
ebac4655
JA
18
19#include "fio.h"
a5e0ee11
O
20#ifndef FIO_NO_HAVE_SHM_H
21#include <sys/shm.h>
22#endif
23
cb2c86fd 24#include "parse.h"
2e5cdb11 25#include "smalloc.h"
380065aa 26#include "filehash.h"
4f5af7b2 27#include "verify.h"
79d16311 28#include "profile.h"
50d16976 29#include "server.h"
f2a2ce0e 30#include "idletime.h"
243bfe19 31#include "filelock.h"
16e56d25 32#include "steadystate.h"
b9921d1a 33#include "blktrace.h"
ebac4655 34
f5bff36e 35#include "oslib/asprintf.h"
f87cc561 36#include "oslib/getopt.h"
984f30c9 37#include "oslib/strcasestr.h"
bf2e821a 38
10aa136b 39#include "crc/test.h"
d694a6a7 40#include "lib/pow2.h"
b76d85a4 41#include "lib/memcpy.h"
10aa136b 42
3d43382c 43const char fio_version_string[] = FIO_VERSION;
214e1eca 44
ee738499 45#define FIO_RANDSEED (0xb1899bedUL)
ebac4655 46
214e1eca 47static char **ini_file;
f1867a7f
JA
48static bool dump_cmdline;
49static bool parse_only;
50static bool merge_blktrace_only;
e1f36503 51
be4ecfdf 52static struct thread_data def_thread;
d41647e6 53struct thread_segment segments[REAL_MAX_SEG];
10aa136b
JA
54static char **job_sections;
55static int nr_job_sections;
e1f36503 56
f1867a7f 57bool exitall_on_terminate = false;
f3afa57e 58int output_format = FIO_OUTPUT_NORMAL;
5be4c944 59int eta_print = FIO_ETA_AUTO;
db37d890 60unsigned int eta_interval_msec = 1000;
e382e661 61int eta_new_line = 0;
214e1eca
JA
62FILE *f_out = NULL;
63FILE *f_err = NULL;
07b3232d 64char *exec_profile = NULL;
a9523c6f 65int warnings_fatal = 0;
4d658652 66int terse_version = 3;
f1867a7f
JA
67bool is_backend = false;
68bool is_local_backend = false;
a37f69b7 69int nr_clients = 0;
f1867a7f 70bool log_syslog = false;
ee738499 71
f1867a7f
JA
72bool write_bw_log = false;
73bool read_only = false;
06464907 74int status_interval = 0;
214e1eca 75
ca09be4b 76char *trigger_file = NULL;
ca09be4b 77long long trigger_timeout = 0;
b63efd30
JA
78char *trigger_cmd = NULL;
79char *trigger_remote_cmd = NULL;
ca09be4b 80
d264264a
JA
81char *aux_path = NULL;
82
214e1eca 83static int prev_group_jobs;
b4692828 84
ee56ad50 85unsigned long fio_debug = 0;
5e1d306e
JA
86unsigned int fio_debug_jobno = -1;
87unsigned int *fio_debug_jobp = NULL;
5ec3bc54 88unsigned int *fio_warned = NULL;
ee56ad50 89
4c6107ff 90static char cmd_optstr[256];
1201b24a 91static bool did_arg;
4c6107ff 92
7a4b8240
JA
93#define FIO_CLIENT_FLAG (1 << 16)
94
b4692828
JA
95/*
96 * Command line options. These will contain the above, plus a few
97 * extra that only pertain to fio itself and not jobs.
98 */
5ec10eaa 99static struct option l_opts[FIO_NR_OPTIONS] = {
b4692828 100 {
08d2a19c 101 .name = (char *) "output",
b4692828 102 .has_arg = required_argument,
7a4b8240 103 .val = 'o' | FIO_CLIENT_FLAG,
b4692828 104 },
b4692828 105 {
08d2a19c 106 .name = (char *) "latency-log",
b4692828 107 .has_arg = required_argument,
7a4b8240 108 .val = 'l' | FIO_CLIENT_FLAG,
b4692828
JA
109 },
110 {
08d2a19c 111 .name = (char *) "bandwidth-log",
2fd6fad5 112 .has_arg = no_argument,
7a4b8240 113 .val = 'b' | FIO_CLIENT_FLAG,
b4692828
JA
114 },
115 {
08d2a19c 116 .name = (char *) "minimal",
c4ec0a1d 117 .has_arg = no_argument,
7a4b8240 118 .val = 'm' | FIO_CLIENT_FLAG,
b4692828 119 },
cc372b17 120 {
f3afa57e 121 .name = (char *) "output-format",
d2c87a78 122 .has_arg = required_argument,
f3afa57e 123 .val = 'F' | FIO_CLIENT_FLAG,
cc372b17 124 },
f6a7df53
JA
125 {
126 .name = (char *) "append-terse",
127 .has_arg = optional_argument,
128 .val = 'f',
129 },
b4692828 130 {
08d2a19c 131 .name = (char *) "version",
b4692828 132 .has_arg = no_argument,
7a4b8240 133 .val = 'v' | FIO_CLIENT_FLAG,
b4692828 134 },
fd28ca49 135 {
08d2a19c 136 .name = (char *) "help",
fd28ca49 137 .has_arg = no_argument,
7a4b8240 138 .val = 'h' | FIO_CLIENT_FLAG,
fd28ca49
JA
139 },
140 {
08d2a19c 141 .name = (char *) "cmdhelp",
320beefe 142 .has_arg = optional_argument,
7a4b8240 143 .val = 'c' | FIO_CLIENT_FLAG,
fd28ca49 144 },
de890a1e 145 {
06464907 146 .name = (char *) "enghelp",
de890a1e 147 .has_arg = optional_argument,
06464907 148 .val = 'i' | FIO_CLIENT_FLAG,
de890a1e 149 },
cca73aa7 150 {
08d2a19c 151 .name = (char *) "showcmd",
cca73aa7 152 .has_arg = no_argument,
7a4b8240 153 .val = 's' | FIO_CLIENT_FLAG,
724e4435
JA
154 },
155 {
08d2a19c 156 .name = (char *) "readonly",
724e4435 157 .has_arg = no_argument,
7a4b8240 158 .val = 'r' | FIO_CLIENT_FLAG,
cca73aa7 159 },
e592a06b 160 {
08d2a19c 161 .name = (char *) "eta",
e592a06b 162 .has_arg = required_argument,
7a4b8240 163 .val = 'e' | FIO_CLIENT_FLAG,
e592a06b 164 },
db37d890
JA
165 {
166 .name = (char *) "eta-interval",
167 .has_arg = required_argument,
168 .val = 'O' | FIO_CLIENT_FLAG,
169 },
e382e661
JA
170 {
171 .name = (char *) "eta-newline",
172 .has_arg = required_argument,
173 .val = 'E' | FIO_CLIENT_FLAG,
174 },
ee56ad50 175 {
08d2a19c 176 .name = (char *) "debug",
ee56ad50 177 .has_arg = required_argument,
7a4b8240 178 .val = 'd' | FIO_CLIENT_FLAG,
ee56ad50 179 },
111e032d
JA
180 {
181 .name = (char *) "parse-only",
182 .has_arg = no_argument,
183 .val = 'P' | FIO_CLIENT_FLAG,
184 },
01f06b63 185 {
08d2a19c 186 .name = (char *) "section",
01f06b63 187 .has_arg = required_argument,
7a4b8240 188 .val = 'x' | FIO_CLIENT_FLAG,
01f06b63 189 },
b26317c9
JA
190#ifdef CONFIG_ZLIB
191 {
192 .name = (char *) "inflate-log",
193 .has_arg = required_argument,
194 .val = 'X' | FIO_CLIENT_FLAG,
195 },
196#endif
2b386d25 197 {
08d2a19c 198 .name = (char *) "alloc-size",
2b386d25 199 .has_arg = required_argument,
7a4b8240 200 .val = 'a' | FIO_CLIENT_FLAG,
2b386d25 201 },
9ac8a797 202 {
08d2a19c 203 .name = (char *) "profile",
9ac8a797 204 .has_arg = required_argument,
7a4b8240 205 .val = 'p' | FIO_CLIENT_FLAG,
9ac8a797 206 },
a9523c6f 207 {
08d2a19c 208 .name = (char *) "warnings-fatal",
a9523c6f 209 .has_arg = no_argument,
7a4b8240 210 .val = 'w' | FIO_CLIENT_FLAG,
a9523c6f 211 },
fca70358
JA
212 {
213 .name = (char *) "max-jobs",
214 .has_arg = required_argument,
7a4b8240 215 .val = 'j' | FIO_CLIENT_FLAG,
fca70358 216 },
f57a9c59
JA
217 {
218 .name = (char *) "terse-version",
219 .has_arg = required_argument,
7a4b8240 220 .val = 'V' | FIO_CLIENT_FLAG,
f57a9c59 221 },
50d16976
JA
222 {
223 .name = (char *) "server",
87aa8f19 224 .has_arg = optional_argument,
50d16976
JA
225 .val = 'S',
226 },
f8fef4c6 227#ifdef WIN32
228 {
229 .name = (char *) "server-internal",
230 .has_arg = required_argument,
231 .val = 'N',
232 },
233#endif
e46d8091 234 { .name = (char *) "daemonize",
402668f3 235 .has_arg = required_argument,
e46d8091
JA
236 .val = 'D',
237 },
132159a5
JA
238 {
239 .name = (char *) "client",
240 .has_arg = required_argument,
241 .val = 'C',
242 },
323255cc
JA
243 {
244 .name = (char *) "remote-config",
245 .has_arg = required_argument,
246 .val = 'R',
247 },
7d11f871
JA
248 {
249 .name = (char *) "cpuclock-test",
250 .has_arg = no_argument,
251 .val = 'T',
252 },
fec0f21c
JA
253 {
254 .name = (char *) "crctest",
255 .has_arg = optional_argument,
256 .val = 'G',
257 },
b76d85a4
JA
258 {
259 .name = (char *) "memcpytest",
260 .has_arg = optional_argument,
261 .val = 'M',
262 },
f2a2ce0e
HL
263 {
264 .name = (char *) "idle-prof",
265 .has_arg = required_argument,
266 .val = 'I',
267 },
06464907
JA
268 {
269 .name = (char *) "status-interval",
270 .has_arg = required_argument,
b87ed299 271 .val = 'L' | FIO_CLIENT_FLAG,
06464907 272 },
ca09be4b 273 {
b63efd30 274 .name = (char *) "trigger-file",
ca09be4b
JA
275 .has_arg = required_argument,
276 .val = 'W',
277 },
278 {
279 .name = (char *) "trigger-timeout",
280 .has_arg = required_argument,
281 .val = 'B',
282 },
b63efd30
JA
283 {
284 .name = (char *) "trigger",
285 .has_arg = required_argument,
286 .val = 'H',
287 },
288 {
289 .name = (char *) "trigger-remote",
290 .has_arg = required_argument,
291 .val = 'J',
292 },
d264264a
JA
293 {
294 .name = (char *) "aux-path",
295 .has_arg = required_argument,
296 .val = 'K',
297 },
b9921d1a
DZ
298 {
299 .name = (char *) "merge-blktrace-only",
300 .has_arg = no_argument,
301 .val = 'A' | FIO_CLIENT_FLAG,
302 },
b4692828
JA
303 {
304 .name = NULL,
305 },
306};
307
2bb3f0a7 308void free_threads_shm(void)
9d9eb2e7 309{
2fbe1e19
JA
310 int i;
311
312 for (i = 0; i < nr_segments; i++) {
313 struct thread_segment *seg = &segments[i];
314
315 if (seg->threads) {
316 void *tp = seg->threads;
c8931876 317#ifndef CONFIG_NO_SHM
2fbe1e19 318 struct shmid_ds sbuf;
9d9eb2e7 319
2fbe1e19
JA
320 seg->threads = NULL;
321 shmdt(tp);
322 shmctl(seg->shm_id, IPC_RMID, &sbuf);
323 seg->shm_id = -1;
c8931876 324#else
2fbe1e19
JA
325 seg->threads = NULL;
326 free(tp);
c8931876 327#endif
2fbe1e19 328 }
2bb3f0a7 329 }
2fbe1e19
JA
330
331 nr_segments = 0;
332 cur_segment = 0;
2bb3f0a7
JA
333}
334
10aa136b 335static void free_shm(void)
2bb3f0a7 336{
1857e6b2 337#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
2fbe1e19 338 if (nr_segments) {
9e684a49 339 flow_exit();
9d9eb2e7 340 fio_debug_jobp = NULL;
5ec3bc54 341 fio_warned = NULL;
2bb3f0a7 342 free_threads_shm();
9d9eb2e7
JA
343 }
344
b63efd30
JA
345 free(trigger_file);
346 free(trigger_cmd);
347 free(trigger_remote_cmd);
348 trigger_file = trigger_cmd = trigger_remote_cmd = NULL;
349
5e333ada 350 options_free(fio_options, &def_thread.o);
243bfe19 351 fio_filelock_exit();
d619275c 352 file_hash_exit();
9d9eb2e7 353 scleanup();
1857e6b2 354#endif
9d9eb2e7
JA
355}
356
2fbe1e19 357static int add_thread_segment(void)
9d9eb2e7 358{
2fbe1e19
JA
359 struct thread_segment *seg = &segments[nr_segments];
360 size_t size = JOBS_PER_SEG * sizeof(struct thread_data);
4f37732a
BVA
361 int i;
362
42eb9952
JA
363 if (nr_segments + 1 >= REAL_MAX_SEG) {
364 log_err("error: maximum number of jobs reached.\n");
2fbe1e19 365 return -1;
42eb9952 366 }
9d9eb2e7 367
2fbe1e19 368 size += 2 * sizeof(unsigned int);
9d9eb2e7 369
c8931876 370#ifndef CONFIG_NO_SHM
2fbe1e19
JA
371 seg->shm_id = shmget(0, size, IPC_CREAT | 0600);
372 if (seg->shm_id == -1) {
373 if (errno != EINVAL && errno != ENOMEM && errno != ENOSPC)
9d9eb2e7 374 perror("shmget");
2fbe1e19
JA
375 return -1;
376 }
c8931876 377#else
2fbe1e19
JA
378 seg->threads = malloc(size);
379 if (!seg->threads)
380 return -1;
c8931876 381#endif
9d9eb2e7 382
c8931876 383#ifndef CONFIG_NO_SHM
d41647e6
JA
384 seg->threads = shmat(seg->shm_id, NULL, 0);
385 if (seg->threads == (void *) -1) {
9d9eb2e7
JA
386 perror("shmat");
387 return 1;
388 }
0cfe2089 389 if (shm_attach_to_open_removed())
d41647e6 390 shmctl(seg->shm_id, IPC_RMID, NULL);
c8931876 391#endif
9d9eb2e7 392
2fbe1e19
JA
393 nr_segments++;
394
395 memset(seg->threads, 0, JOBS_PER_SEG * sizeof(struct thread_data));
396 for (i = 0; i < JOBS_PER_SEG; i++)
d41647e6 397 DRD_IGNORE_VAR(seg->threads[i]);
2fbe1e19
JA
398 seg->nr_threads = 0;
399
400 /* Not first segment, we're done */
401 if (nr_segments != 1) {
402 cur_segment++;
403 return 0;
404 }
405
406 fio_debug_jobp = (unsigned int *)(seg->threads + JOBS_PER_SEG);
9d9eb2e7 407 *fio_debug_jobp = -1;
5ec3bc54
JA
408 fio_warned = fio_debug_jobp + 1;
409 *fio_warned = 0;
9e684a49
DE
410
411 flow_init();
9d9eb2e7
JA
412 return 0;
413}
414
2fbe1e19
JA
415/*
416 * The thread areas are shared between the main process and the job
417 * threads/processes, and is split into chunks of JOBS_PER_SEG. If the current
418 * segment has no more room, add a new chunk.
419 */
420static int expand_thread_area(void)
421{
422 struct thread_segment *seg = &segments[cur_segment];
423
424 if (nr_segments && seg->nr_threads < JOBS_PER_SEG)
425 return 0;
426
427 return add_thread_segment();
428}
429
c2292325
JA
430static void dump_print_option(struct print_option *p)
431{
432 const char *delim;
433
434 if (!strcmp("description", p->name))
435 delim = "\"";
436 else
437 delim = "";
438
439 log_info("--%s%s", p->name, p->value ? "" : " ");
440 if (p->value)
441 log_info("=%s%s%s ", delim, p->value, delim);
442}
443
444static void dump_opt_list(struct thread_data *td)
445{
446 struct flist_head *entry;
447 struct print_option *p;
448
449 if (flist_empty(&td->opt_list))
450 return;
451
452 flist_for_each(entry, &td->opt_list) {
453 p = flist_entry(entry, struct print_option, list);
454 dump_print_option(p);
455 }
456}
457
876e1001
JA
458static void copy_opt_list(struct thread_data *dst, struct thread_data *src)
459{
460 struct flist_head *entry;
461
462 if (flist_empty(&src->opt_list))
463 return;
464
465 flist_for_each(entry, &src->opt_list) {
466 struct print_option *srcp, *dstp;
467
468 srcp = flist_entry(entry, struct print_option, list);
469 dstp = malloc(sizeof(*dstp));
470 dstp->name = strdup(srcp->name);
471 if (srcp->value)
472 dstp->value = strdup(srcp->value);
473 else
474 dstp->value = NULL;
475 flist_add_tail(&dstp->list, &dst->opt_list);
476 }
477}
478
906c8d75
JA
479/*
480 * Return a free job structure.
481 */
8983ce71
JA
482static struct thread_data *get_new_job(bool global, struct thread_data *parent,
483 bool preserve_eo, const char *jobname)
ebac4655 484{
2fbe1e19 485 struct thread_segment *seg;
ebac4655
JA
486 struct thread_data *td;
487
5bba8b3a 488 if (global)
ebac4655 489 return &def_thread;
2fbe1e19 490 if (expand_thread_area()) {
9d9eb2e7
JA
491 log_err("error: failed to setup shm segment\n");
492 return NULL;
493 }
ebac4655 494
2fbe1e19
JA
495 seg = &segments[cur_segment];
496 td = &seg->threads[seg->nr_threads++];
497 thread_number++;
ddaeaa5a 498 *td = *parent;
ebac4655 499
c2292325 500 INIT_FLIST_HEAD(&td->opt_list);
876e1001
JA
501 if (parent != &def_thread)
502 copy_opt_list(td, parent);
c2292325 503
de890a1e 504 td->io_ops = NULL;
356ef1a1 505 td->io_ops_init = 0;
de890a1e
SL
506 if (!preserve_eo)
507 td->eo = NULL;
508
e0b0d892
JA
509 td->o.uid = td->o.gid = -1U;
510
cade3ef4 511 dup_files(td, parent);
de890a1e 512 fio_options_mem_dupe(td);
cade3ef4 513
15dc1934
JA
514 profile_add_hooks(td);
515
ebac4655 516 td->thread_number = thread_number;
69bdd6ba 517 td->subjob_number = 0;
108fea77 518
ef3d8e53
JA
519 if (jobname)
520 td->o.name = strdup(jobname);
521
13978e86 522 if (!parent->o.group_reporting || parent == &def_thread)
108fea77
JA
523 stat_number++;
524
ebac4655
JA
525 return td;
526}
527
528static void put_job(struct thread_data *td)
529{
549577a7
JA
530 if (td == &def_thread)
531 return;
84dd1886 532
58c55ba0 533 profile_td_exit(td);
9e684a49 534 flow_exit_job(td);
549577a7 535
16edf25d 536 if (td->error)
6d86144d 537 log_info("fio: %s\n", td->verror);
16edf25d 538
7e356b2d 539 fio_options_free(td);
c2292325 540 fio_dump_options_free(td);
de890a1e
SL
541 if (td->io_ops)
542 free_ioengine(td);
7e356b2d 543
ef3d8e53
JA
544 if (td->o.name)
545 free(td->o.name);
546
d41647e6 547 memset(td, 0, sizeof(*td));
2fbe1e19 548 segments[cur_segment].nr_threads--;
ebac4655
JA
549 thread_number--;
550}
551
581e7141 552static int __setup_rate(struct thread_data *td, enum fio_ddir ddir)
127f6865 553{
5fff9543 554 unsigned long long bs = td->o.min_bs[ddir];
127f6865 555
ff58fced
JA
556 assert(ddir_rw(ddir));
557
ba3e4e0c 558 if (td->o.rate[ddir])
1b8dbf25 559 td->rate_bps[ddir] = td->o.rate[ddir];
ba3e4e0c 560 else
194fffd0 561 td->rate_bps[ddir] = (uint64_t) td->o.rate_iops[ddir] * bs;
127f6865 562
1b8dbf25 563 if (!td->rate_bps[ddir]) {
127f6865
JA
564 log_err("rate lower than supported\n");
565 return -1;
566 }
567
50a8ce86 568 td->rate_next_io_time[ddir] = 0;
89cdea5e 569 td->rate_io_issue_bytes[ddir] = 0;
6c8611c7 570 td->last_usec[ddir] = 0;
127f6865
JA
571 return 0;
572}
573
581e7141
JA
574static int setup_rate(struct thread_data *td)
575{
576 int ret = 0;
577
dde39f8c
AD
578 for_each_rw_ddir(ddir) {
579 if (td->o.rate[ddir] || td->o.rate_iops[ddir]) {
580 ret |= __setup_rate(td, ddir);
581 }
582 }
581e7141
JA
583 return ret;
584}
585
8347239a
JA
586static int fixed_block_size(struct thread_options *o)
587{
588 return o->min_bs[DDIR_READ] == o->max_bs[DDIR_READ] &&
589 o->min_bs[DDIR_WRITE] == o->max_bs[DDIR_WRITE] &&
6eaf09d6
SL
590 o->min_bs[DDIR_TRIM] == o->max_bs[DDIR_TRIM] &&
591 o->min_bs[DDIR_READ] == o->min_bs[DDIR_WRITE] &&
592 o->min_bs[DDIR_READ] == o->min_bs[DDIR_TRIM];
8347239a
JA
593}
594
8c4e634a
JA
595/*
596 * <3 Johannes
597 */
9258468e
JA
598static unsigned int gcd(unsigned int m, unsigned int n)
599{
8c4e634a
JA
600 if (!n)
601 return m;
9258468e 602
8c4e634a 603 return gcd(n, m % n);
9258468e
JA
604}
605
dad915e3
JA
606/*
607 * Lazy way of fixing up options that depend on each other. We could also
608 * define option callback handlers, but this is easier.
609 */
4e991c23 610static int fixup_options(struct thread_data *td)
e1f36503 611{
2dc1bbeb 612 struct thread_options *o = &td->o;
eefd98b1 613 int ret = 0;
dad915e3 614
c0e9a238
VF
615 if (read_only && (td_write(td) || td_trim(td))) {
616 log_err("fio: trim and write operations are not allowed"
617 " with the --readonly parameter.\n");
618 ret |= 1;
619 }
620
06eac6b2 621#ifndef CONFIG_PSHARED
9bbf57cc 622 if (!o->use_thread) {
f356d01d
JA
623 log_info("fio: this platform does not support process shared"
624 " mutexes, forcing use of threads. Use the 'thread'"
625 " option to get rid of this warning.\n");
9bbf57cc 626 o->use_thread = 1;
1cce3c66 627 ret |= warnings_fatal;
f356d01d
JA
628 }
629#endif
630
2dc1bbeb 631 if (o->write_iolog_file && o->read_iolog_file) {
076efc7c 632 log_err("fio: read iolog overrides write_iolog\n");
2dc1bbeb
JA
633 free(o->write_iolog_file);
634 o->write_iolog_file = NULL;
1cce3c66 635 ret |= warnings_fatal;
076efc7c 636 }
16b462ae 637
7b865a2f
BVA
638 if (o->zone_mode == ZONE_MODE_NONE && o->zone_size) {
639 log_err("fio: --zonemode=none and --zonesize are not compatible.\n");
640 ret |= 1;
641 }
642
4662c206
NC
643 if (o->zone_mode == ZONE_MODE_ZBD && !o->create_serialize) {
644 log_err("fio: --zonemode=zbd and --create_serialize=0 are not compatible.\n");
645 ret |= 1;
646 }
647
bfbdd35b
BVA
648 if (o->zone_mode == ZONE_MODE_STRIDED && !o->zone_size) {
649 log_err("fio: --zonesize must be specified when using --zonemode=strided.\n");
650 ret |= 1;
651 }
652
7b865a2f
BVA
653 if (o->zone_mode == ZONE_MODE_NOT_SPECIFIED) {
654 if (o->zone_size)
655 o->zone_mode = ZONE_MODE_STRIDED;
656 else
657 o->zone_mode = ZONE_MODE_NONE;
658 }
659
16b462ae 660 /*
7b865a2f 661 * Strided zone mode only really works with 1 file.
16b462ae 662 */
7b865a2f
BVA
663 if (o->zone_mode == ZONE_MODE_STRIDED && o->open_files > 1)
664 o->zone_mode = ZONE_MODE_NONE;
16b462ae 665
ed335855
SN
666 /*
667 * If zone_range isn't specified, backward compatibility dictates it
668 * should be made equal to zone_size.
669 */
7b865a2f 670 if (o->zone_mode == ZONE_MODE_STRIDED && !o->zone_range)
ed335855
SN
671 o->zone_range = o->zone_size;
672
16b462ae
JA
673 /*
674 * Reads can do overwrites, we always need to pre-create the file
675 */
dcf9844e 676 if (td_read(td))
2dc1bbeb 677 o->overwrite = 1;
16b462ae 678
dde39f8c
AD
679 for_each_rw_ddir(ddir) {
680 if (!o->min_bs[ddir])
681 o->min_bs[ddir] = o->bs[ddir];
682 if (!o->max_bs[ddir])
683 o->max_bs[ddir] = o->bs[ddir];
684 }
685
686 o->rw_min_bs = -1;
687 for_each_rw_ddir(ddir) {
688 o->rw_min_bs = min(o->rw_min_bs, o->min_bs[ddir]);
689 }
a00735e6 690
2b7a01d0
JA
691 /*
692 * For random IO, allow blockalign offset other than min_bs.
693 */
dde39f8c
AD
694 for_each_rw_ddir(ddir) {
695 if (!o->ba[ddir] || !td_random(td))
696 o->ba[ddir] = o->min_bs[ddir];
697 }
2b7a01d0
JA
698
699 if ((o->ba[DDIR_READ] != o->min_bs[DDIR_READ] ||
6eaf09d6
SL
700 o->ba[DDIR_WRITE] != o->min_bs[DDIR_WRITE] ||
701 o->ba[DDIR_TRIM] != o->min_bs[DDIR_TRIM]) &&
9bbf57cc 702 !o->norandommap) {
2b7a01d0 703 log_err("fio: Any use of blockalign= turns off randommap\n");
9bbf57cc 704 o->norandommap = 1;
1cce3c66 705 ret |= warnings_fatal;
2b7a01d0
JA
706 }
707
2dc1bbeb
JA
708 if (!o->file_size_high)
709 o->file_size_high = o->file_size_low;
9c60ce64 710
49050b56
JA
711 if (o->start_delay_high) {
712 if (!o->start_delay_orig)
713 o->start_delay_orig = o->start_delay;
386501be 714 o->start_delay = rand_between(&td->delay_state,
5630eccf
JA
715 o->start_delay_orig,
716 o->start_delay_high);
49050b56 717 }
23ed19b0 718
8347239a
JA
719 if (o->norandommap && o->verify != VERIFY_NONE
720 && !fixed_block_size(o)) {
721 log_err("fio: norandommap given for variable block sizes, "
83da8fbf 722 "verify limited\n");
1cce3c66 723 ret |= warnings_fatal;
bb8895e0 724 }
9b87f09b 725 if (o->bs_unaligned && (o->odirect || td_ioengine_flagged(td, FIO_RAWIO)))
690adba3 726 log_err("fio: bs_unaligned may not work with raw io\n");
e0a22335 727
48097d5c
JA
728 /*
729 * thinktime_spin must be less than thinktime
730 */
2dc1bbeb
JA
731 if (o->thinktime_spin > o->thinktime)
732 o->thinktime_spin = o->thinktime;
e916b390
JA
733
734 /*
735 * The low water mark cannot be bigger than the iodepth
736 */
67bf9823
JA
737 if (o->iodepth_low > o->iodepth || !o->iodepth_low)
738 o->iodepth_low = o->iodepth;
cb5ab512
JA
739
740 /*
741 * If batch number isn't set, default to the same as iodepth
742 */
2dc1bbeb
JA
743 if (o->iodepth_batch > o->iodepth || !o->iodepth_batch)
744 o->iodepth_batch = o->iodepth;
b5af8293 745
82407585
RP
746 /*
747 * If max batch complete number isn't set or set incorrectly,
748 * default to the same as iodepth_batch_complete_min
749 */
750 if (o->iodepth_batch_complete_min > o->iodepth_batch_complete_max)
751 o->iodepth_batch_complete_max = o->iodepth_batch_complete_min;
752
997b5680
SW
753 /*
754 * There's no need to check for in-flight overlapping IOs if the job
755 * isn't changing data or the maximum iodepth is guaranteed to be 1
a67c6dd1 756 * when we are not in offload mode
997b5680
SW
757 */
758 if (o->serialize_overlap && !(td->flags & TD_F_READ_IOLOG) &&
a67c6dd1
VF
759 (!(td_write(td) || td_trim(td)) || o->iodepth == 1) &&
760 o->io_submit_mode != IO_MODE_OFFLOAD)
997b5680 761 o->serialize_overlap = 0;
997b5680 762
2dc1bbeb
JA
763 if (o->nr_files > td->files_index)
764 o->nr_files = td->files_index;
9f9214f2 765
2dc1bbeb
JA
766 if (o->open_files > o->nr_files || !o->open_files)
767 o->open_files = o->nr_files;
4e991c23 768
6eaf09d6
SL
769 if (((o->rate[DDIR_READ] + o->rate[DDIR_WRITE] + o->rate[DDIR_TRIM]) &&
770 (o->rate_iops[DDIR_READ] + o->rate_iops[DDIR_WRITE] + o->rate_iops[DDIR_TRIM])) ||
771 ((o->ratemin[DDIR_READ] + o->ratemin[DDIR_WRITE] + o->ratemin[DDIR_TRIM]) &&
772 (o->rate_iops_min[DDIR_READ] + o->rate_iops_min[DDIR_WRITE] + o->rate_iops_min[DDIR_TRIM]))) {
4e991c23 773 log_err("fio: rate and rate_iops are mutually exclusive\n");
1cce3c66 774 ret |= 1;
4e991c23 775 }
dde39f8c
AD
776 for_each_rw_ddir(ddir) {
777 if ((o->rate[ddir] && (o->rate[ddir] < o->ratemin[ddir])) ||
778 (o->rate_iops[ddir] && (o->rate_iops[ddir] < o->rate_iops_min[ddir]))) {
779 log_err("fio: minimum rate exceeds rate, ddir %d\n", +ddir);
780 ret |= 1;
781 }
4e991c23
JA
782 }
783
cf4464ca
JA
784 if (!o->timeout && o->time_based) {
785 log_err("fio: time_based requires a runtime/timeout setting\n");
786 o->time_based = 0;
1cce3c66 787 ret |= warnings_fatal;
cf4464ca
JA
788 }
789
aa31f1f1 790 if (o->fill_device && !o->size)
5921e80c 791 o->size = -1ULL;
5ec10eaa 792
9bbf57cc 793 if (o->verify != VERIFY_NONE) {
9f6d7080
SW
794 if (td_write(td) && o->do_verify && o->numjobs > 1 &&
795 (o->filename ||
796 !(o->unique_filename &&
797 strstr(o->filename_format, "$jobname") &&
798 strstr(o->filename_format, "$jobnum") &&
799 strstr(o->filename_format, "$filenum")))) {
800 log_info("fio: multiple writers may overwrite blocks "
801 "that belong to other jobs. This can cause "
a9523c6f 802 "verification failures.\n");
1cce3c66 803 ret |= warnings_fatal;
a9523c6f
JA
804 }
805
b9f3ee6c
SW
806 /*
807 * Warn if verification is requested but no verification of any
808 * kind can be started due to time constraints
809 */
810 if (td_write(td) && o->do_verify && o->timeout &&
811 o->time_based && !td_read(td) && !o->verify_backlog) {
812 log_info("fio: verification read phase will never "
813 "start because write phase uses all of "
814 "runtime\n");
1cce3c66 815 ret |= warnings_fatal;
b9f3ee6c
SW
816 }
817
7627557b
JA
818 if (!fio_option_is_set(o, refill_buffers))
819 o->refill_buffers = 1;
820
2f1b8e8b
JA
821 if (o->max_bs[DDIR_WRITE] != o->min_bs[DDIR_WRITE] &&
822 !o->verify_interval)
823 o->verify_interval = o->min_bs[DDIR_WRITE];
7ffa8930
JA
824
825 /*
826 * Verify interval must be smaller or equal to the
827 * write size.
828 */
829 if (o->verify_interval > o->min_bs[DDIR_WRITE])
830 o->verify_interval = o->min_bs[DDIR_WRITE];
831 else if (td_read(td) && o->verify_interval > o->min_bs[DDIR_READ])
832 o->verify_interval = o->min_bs[DDIR_READ];
9258468e
JA
833
834 /*
c82acb8d 835 * Verify interval must be a factor of both min and max
9258468e
JA
836 * write size
837 */
c82acb8d 838 if (!o->verify_interval ||
3c0a8bc2
JA
839 (o->min_bs[DDIR_WRITE] % o->verify_interval) ||
840 (o->max_bs[DDIR_WRITE] % o->verify_interval))
9258468e 841 o->verify_interval = gcd(o->min_bs[DDIR_WRITE],
3c0a8bc2 842 o->max_bs[DDIR_WRITE]);
d990588e 843 }
41ccd845 844
9bbf57cc 845 if (o->pre_read) {
49d719fc 846 if (o->invalidate_cache)
21c1b29e 847 o->invalidate_cache = 0;
9b87f09b 848 if (td_ioengine_flagged(td, FIO_PIPEIO)) {
9c0d2241
JA
849 log_info("fio: cannot pre-read files with an IO engine"
850 " that isn't seekable. Pre-read disabled.\n");
1cce3c66 851 ret |= warnings_fatal;
a9523c6f 852 }
9c0d2241 853 }
34f1c044 854
41a87019 855 if (o->unit_base == N2S_NONE) {
9b87f09b 856 if (td_ioengine_flagged(td, FIO_BIT_BASED))
41a87019 857 o->unit_base = N2S_BITPERSEC;
ad705bcb 858 else
41a87019 859 o->unit_base = N2S_BYTEPERSEC;
ad705bcb
SN
860 }
861
67bf9823 862#ifndef CONFIG_FDATASYNC
9bbf57cc 863 if (o->fdatasync_blocks) {
e72fa4d4
JA
864 log_info("fio: this platform does not support fdatasync()"
865 " falling back to using fsync(). Use the 'fsync'"
866 " option instead of 'fdatasync' to get rid of"
867 " this warning\n");
9bbf57cc
JA
868 o->fsync_blocks = o->fdatasync_blocks;
869 o->fdatasync_blocks = 0;
1cce3c66 870 ret |= warnings_fatal;
e72fa4d4
JA
871 }
872#endif
873
93bcfd20
BC
874#ifdef WIN32
875 /*
876 * Windows doesn't support O_DIRECT or O_SYNC with the _open interface,
877 * so fail if we're passed those flags
878 */
8945237c 879 if (td_ioengine_flagged(td, FIO_SYNCIO) && (o->odirect || o->sync_io)) {
93bcfd20
BC
880 log_err("fio: Windows does not support direct or non-buffered io with"
881 " the synchronous ioengines. Use the 'windowsaio' ioengine"
882 " with 'direct=1' and 'iodepth=1' instead.\n");
1cce3c66 883 ret |= 1;
93bcfd20
BC
884 }
885#endif
886
811ac503
JA
887 /*
888 * For fully compressible data, just zero them at init time.
6269123c
JA
889 * It's faster than repeatedly filling it. For non-zero
890 * compression, we should have refill_buffers set. Set it, unless
891 * the job file already changed it.
811ac503 892 */
6269123c
JA
893 if (o->compress_percentage) {
894 if (o->compress_percentage == 100) {
895 o->zero_buffers = 1;
896 o->compress_percentage = 0;
fbf6ded2 897 } else if (!fio_option_is_set(o, refill_buffers)) {
6269123c 898 o->refill_buffers = 1;
fbf6ded2
JA
899 td->flags |= TD_F_REFILL_BUFFERS;
900 }
811ac503
JA
901 }
902
5881fda4
JA
903 /*
904 * Using a non-uniform random distribution excludes usage of
905 * a random map
906 */
8945237c
JA
907 if (o->random_distribution != FIO_RAND_DIST_RANDOM)
908 o->norandommap = 1;
5881fda4 909
8d916c94
JA
910 /*
911 * If size is set but less than the min block size, complain
912 */
913 if (o->size && o->size < td_min_bs(td)) {
5fff9543 914 log_err("fio: size too small, must not be less than minimum block size: %llu < %llu\n",
13e0f06b 915 (unsigned long long) o->size, td_min_bs(td));
1cce3c66 916 ret |= 1;
8d916c94
JA
917 }
918
d01612f3
CM
919 /*
920 * O_ATOMIC implies O_DIRECT
921 */
8945237c
JA
922 if (o->oatomic)
923 o->odirect = 1;
d01612f3 924
04778baf
JA
925 /*
926 * If randseed is set, that overrides randrepeat
927 */
8945237c
JA
928 if (fio_option_is_set(o, rand_seed))
929 o->rand_repeatable = 0;
04778baf 930
8945237c 931 if (td_ioengine_flagged(td, FIO_NOEXTEND) && o->file_append) {
b1bebc32 932 log_err("fio: can't append/extent with IO engine %s\n", td->io_ops->name);
1cce3c66 933 ret |= 1;
b1bebc32
JA
934 }
935
79c896a1
JA
936 if (fio_option_is_set(o, gtod_cpu)) {
937 fio_gtod_init();
938 fio_gtod_set_cpu(o->gtod_cpu);
939 fio_gtod_offload = 1;
940 }
941
cf8a46a7
JA
942 td->loops = o->loops;
943 if (!td->loops)
944 td->loops = 1;
945
8945237c 946 if (o->block_error_hist && o->nr_files != 1) {
b3ec877c 947 log_err("fio: block error histogram only available "
66347cfa 948 "with a single file per job, but %d files "
8945237c 949 "provided\n", o->nr_files);
1cce3c66 950 ret |= 1;
66347cfa
DE
951 }
952
db43af34
SW
953 if (o->disable_lat)
954 o->lat_percentiles = 0;
955 if (o->disable_clat)
956 o->clat_percentiles = 0;
56440e63
VF
957 if (o->disable_slat)
958 o->slat_percentiles = 0;
db43af34 959
c3a32714
JA
960 /*
961 * Fix these up to be nsec internally
962 */
f7cf63bf
VR
963 for_each_rw_ddir(ddir)
964 o->max_latency[ddir] *= 1000ULL;
965
c3a32714 966 o->latency_target *= 1000ULL;
c3a32714 967
0d71aa98
BD
968 /*
969 * Dedupe working set verifications
970 */
971 if (o->dedupe_percentage && o->dedupe_mode == DEDUPE_MODE_WORKING_SET) {
972 if (!fio_option_is_set(o, size)) {
973 log_err("fio: pregenerated dedupe working set "
974 "requires size to be set\n");
975 ret |= 1;
976 } else if (o->nr_files != 1) {
977 log_err("fio: dedupe working set mode supported with "
978 "single file per job, but %d files "
979 "provided\n", o->nr_files);
980 ret |= 1;
981 } else if (o->dedupe_working_set_percentage + o->dedupe_percentage > 100) {
982 log_err("fio: impossible to reach expected dedupe percentage %u "
983 "since %u percentage of size is reserved to dedupe working set "
984 "(those are unique pages)\n",
985 o->dedupe_percentage, o->dedupe_working_set_percentage);
986 ret |= 1;
987 }
988 }
989
a9523c6f 990 return ret;
e1f36503
JA
991}
992
99c94a6b
JA
993static void init_rand_file_service(struct thread_data *td)
994{
995 unsigned long nranges = td->o.nr_files << FIO_FSERVICE_SHIFT;
996 const unsigned int seed = td->rand_seeds[FIO_RAND_FILE_OFF];
997
998 if (td->o.file_service_type == FIO_FSERVICE_ZIPF) {
a87c90fd 999 zipf_init(&td->next_file_zipf, nranges, td->zipf_theta, td->random_center, seed);
99c94a6b
JA
1000 zipf_disable_hash(&td->next_file_zipf);
1001 } else if (td->o.file_service_type == FIO_FSERVICE_PARETO) {
a87c90fd 1002 pareto_init(&td->next_file_zipf, nranges, td->pareto_h, td->random_center, seed);
99c94a6b
JA
1003 zipf_disable_hash(&td->next_file_zipf);
1004 } else if (td->o.file_service_type == FIO_FSERVICE_GAUSS) {
a87c90fd 1005 gauss_init(&td->next_file_gauss, nranges, td->gauss_dev, td->random_center, seed);
99c94a6b
JA
1006 gauss_disable_hash(&td->next_file_gauss);
1007 }
1008}
1009
8f380de2
CJ
1010void td_fill_verify_state_seed(struct thread_data *td)
1011{
1012 bool use64;
1013
1014 if (td->o.random_generator == FIO_RAND_GEN_TAUSWORTHE64)
40c49471 1015 use64 = true;
8f380de2 1016 else
40c49471 1017 use64 = false;
8f380de2
CJ
1018
1019 init_rand_seed(&td->verify_state, td->rand_seeds[FIO_RAND_VER_OFF],
1020 use64);
1021}
1022
36dd3379 1023static void td_fill_rand_seeds_internal(struct thread_data *td, bool use64)
4c07ad86 1024{
eda99d55
SW
1025 uint64_t read_seed = td->rand_seeds[FIO_RAND_BS_OFF];
1026 uint64_t write_seed = td->rand_seeds[FIO_RAND_BS1_OFF];
1027 uint64_t trim_seed = td->rand_seeds[FIO_RAND_BS2_OFF];
36dd3379
JA
1028 int i;
1029
71cf4d08
JA
1030 /*
1031 * trimwrite is special in that we need to generate the same
1032 * offsets to get the "write after trim" effect. If we are
1033 * using bssplit to set buffer length distributions, ensure that
a2e31314
JA
1034 * we seed the trim and write generators identically. Ditto for
1035 * verify, read and writes must have the same seed, if we are doing
1036 * read verify.
71cf4d08 1037 */
a2e31314
JA
1038 if (td->o.verify != VERIFY_NONE)
1039 write_seed = read_seed;
1040 if (td_trimwrite(td))
1041 trim_seed = write_seed;
1042 init_rand_seed(&td->bsrange_state[DDIR_READ], read_seed, use64);
1043 init_rand_seed(&td->bsrange_state[DDIR_WRITE], write_seed, use64);
1044 init_rand_seed(&td->bsrange_state[DDIR_TRIM], trim_seed, use64);
2f282cec 1045
8f380de2 1046 td_fill_verify_state_seed(td);
36dd3379 1047 init_rand_seed(&td->rwmix_state, td->rand_seeds[FIO_RAND_MIX_OFF], false);
4c07ad86
JA
1048
1049 if (td->o.file_service_type == FIO_FSERVICE_RANDOM)
c3546b53 1050 init_rand_seed(&td->next_file_state, td->rand_seeds[FIO_RAND_FILE_OFF], use64);
99c94a6b
JA
1051 else if (td->o.file_service_type & __FIO_FSERVICE_NONUNIFORM)
1052 init_rand_file_service(td);
4c07ad86 1053
c3546b53
JA
1054 init_rand_seed(&td->file_size_state, td->rand_seeds[FIO_RAND_FILE_SIZE_OFF], use64);
1055 init_rand_seed(&td->trim_state, td->rand_seeds[FIO_RAND_TRIM_OFF], use64);
1056 init_rand_seed(&td->delay_state, td->rand_seeds[FIO_RAND_START_DELAY], use64);
6c8611c7
JA
1057 init_rand_seed(&td->poisson_state[0], td->rand_seeds[FIO_RAND_POISSON_OFF], 0);
1058 init_rand_seed(&td->poisson_state[1], td->rand_seeds[FIO_RAND_POISSON2_OFF], 0);
1059 init_rand_seed(&td->poisson_state[2], td->rand_seeds[FIO_RAND_POISSON3_OFF], 0);
36dd3379
JA
1060 init_rand_seed(&td->dedupe_state, td->rand_seeds[FIO_DEDUPE_OFF], false);
1061 init_rand_seed(&td->zone_state, td->rand_seeds[FIO_RAND_ZONE_OFF], false);
b2a432bf 1062 init_rand_seed(&td->prio_state, td->rand_seeds[FIO_RAND_PRIO_CMDS], false);
0d71aa98 1063 init_rand_seed(&td->dedupe_working_set_index_state, td->rand_seeds[FIO_RAND_DEDUPE_WORKING_SET_IX], use64);
4c07ad86
JA
1064
1065 if (!td_random(td))
1066 return;
1067
1068 if (td->o.rand_repeatable)
d24945f0 1069 td->rand_seeds[FIO_RAND_BLOCK_OFF] = FIO_RANDSEED * td->thread_number;
4c07ad86 1070
c3546b53 1071 init_rand_seed(&td->random_state, td->rand_seeds[FIO_RAND_BLOCK_OFF], use64);
36dd3379
JA
1072
1073 for (i = 0; i < DDIR_RWDIR_CNT; i++) {
1074 struct frand_state *s = &td->seq_rand_state[i];
1075
1076 init_rand_seed(s, td->rand_seeds[FIO_RAND_SEQ_RAND_READ_OFF], false);
1077 }
5bfc35d7
JA
1078}
1079
4c07ad86
JA
1080void td_fill_rand_seeds(struct thread_data *td)
1081{
36dd3379 1082 bool use64;
c3546b53 1083
56e2a5fc 1084 if (td->o.allrand_repeatable) {
5c94b008
JA
1085 unsigned int i;
1086
1087 for (i = 0; i < FIO_RAND_NR_OFFS; i++)
56e2a5fc
CE
1088 td->rand_seeds[i] = FIO_RANDSEED * td->thread_number
1089 + i;
1090 }
1091
c3546b53 1092 if (td->o.random_generator == FIO_RAND_GEN_TAUSWORTHE64)
40c49471 1093 use64 = true;
c3546b53 1094 else
40c49471 1095 use64 = false;
c3546b53
JA
1096
1097 td_fill_rand_seeds_internal(td, use64);
3545a109 1098
c3546b53 1099 init_rand_seed(&td->buf_state, td->rand_seeds[FIO_RAND_BUF_OFF], use64);
5c94b008 1100 frand_copy(&td->buf_state_prev, &td->buf_state);
4c07ad86
JA
1101}
1102
de890a1e
SL
1103/*
1104 * Initializes the ioengine configured for a job, if it has not been done so
1105 * already.
1106 */
1107int ioengine_load(struct thread_data *td)
1108{
6e5c4b8e
JA
1109 if (!td->o.ioengine) {
1110 log_err("fio: internal fault, no IO engine specified\n");
1111 return 1;
1112 }
de890a1e 1113
800334db 1114 if (td->io_ops) {
3e262e2f
JA
1115 struct ioengine_ops *ops;
1116 void *dlhandle;
1117
800334db
BW
1118 /* An engine is loaded, but the requested ioengine
1119 * may have changed.
1120 */
1121 if (!strcmp(td->io_ops->name, td->o.ioengine)) {
1122 /* The right engine is already loaded */
1123 return 0;
1124 }
1125
3e262e2f
JA
1126 /*
1127 * Name of file and engine may be different, load ops
1128 * for this name and see if they match. If they do, then
1129 * the engine is unchanged.
1130 */
f6931a1d 1131 dlhandle = td->io_ops->dlhandle;
3e262e2f 1132 ops = load_ioengine(td);
685e367e
YK
1133 if (!ops)
1134 goto fail;
1135
48ff7df9 1136 if (ops == td->io_ops && dlhandle == td->io_ops->dlhandle)
3e262e2f
JA
1137 return 0;
1138
f6931a1d 1139 if (dlhandle && dlhandle != td->io_ops->dlhandle)
3e262e2f
JA
1140 dlclose(dlhandle);
1141
800334db
BW
1142 /* Unload the old engine. */
1143 free_ioengine(td);
1144 }
1145
4fedf59a 1146 td->io_ops = load_ioengine(td);
685e367e
YK
1147 if (!td->io_ops)
1148 goto fail;
de890a1e
SL
1149
1150 if (td->io_ops->option_struct_size && td->io_ops->options) {
1151 /*
1152 * In cases where td->eo is set, clone it for a child thread.
1153 * This requires that the parent thread has the same ioengine,
1154 * but that requirement must be enforced by the code which
1155 * cloned the thread.
1156 */
1157 void *origeo = td->eo;
1158 /*
1159 * Otherwise use the default thread options.
1160 */
1161 if (!origeo && td != &def_thread && def_thread.eo &&
1162 def_thread.io_ops->options == td->io_ops->options)
1163 origeo = def_thread.eo;
1164
1165 options_init(td->io_ops->options);
1166 td->eo = malloc(td->io_ops->option_struct_size);
1167 /*
1168 * Use the default thread as an option template if this uses the
1169 * same options structure and there are non-default options
1170 * used.
1171 */
1172 if (origeo) {
1173 memcpy(td->eo, origeo, td->io_ops->option_struct_size);
53b5693d 1174 options_mem_dupe(td->io_ops->options, td->eo);
de890a1e
SL
1175 } else {
1176 memset(td->eo, 0, td->io_ops->option_struct_size);
1177 fill_default_options(td->eo, td->io_ops->options);
1178 }
1179 *(struct thread_data **)td->eo = td;
1180 }
1181
9b87f09b
JA
1182 if (td->o.odirect)
1183 td->io_ops->flags |= FIO_RAWIO;
1184
1185 td_set_ioengine_flags(td);
de890a1e 1186 return 0;
685e367e
YK
1187
1188fail:
1189 log_err("fio: failed to load engine\n");
1190 return 1;
1191
de890a1e
SL
1192}
1193
d72be545
JA
1194static void init_flags(struct thread_data *td)
1195{
1196 struct thread_options *o = &td->o;
5c81ff5e 1197 int i;
d72be545
JA
1198
1199 if (o->verify_backlog)
1200 td->flags |= TD_F_VER_BACKLOG;
1201 if (o->trim_backlog)
1202 td->flags |= TD_F_TRIM_BACKLOG;
1203 if (o->read_iolog_file)
1204 td->flags |= TD_F_READ_IOLOG;
1205 if (o->refill_buffers)
1206 td->flags |= TD_F_REFILL_BUFFERS;
1bf2498d 1207 /*
b04f5905 1208 * Always scramble buffers if asked to
1bf2498d 1209 */
b04f5905
JA
1210 if (o->scramble_buffers && fio_option_is_set(o, scramble_buffers))
1211 td->flags |= TD_F_SCRAMBLE_BUFFERS;
1212 /*
1213 * But also scramble buffers, unless we were explicitly asked
1214 * to zero them.
1215 */
1216 if (o->scramble_buffers && !(o->zero_buffers &&
1217 fio_option_is_set(o, zero_buffers)))
d72be545
JA
1218 td->flags |= TD_F_SCRAMBLE_BUFFERS;
1219 if (o->verify != VERIFY_NONE)
553f9652 1220 td->flags |= TD_F_DO_VERIFY;
a9da8ab2
JA
1221
1222 if (o->verify_async || o->io_submit_mode == IO_MODE_OFFLOAD)
1223 td->flags |= TD_F_NEED_LOCK;
15600335
JA
1224
1225 if (o->mem_type == MEM_CUDA_MALLOC)
1226 td->flags &= ~TD_F_SCRAMBLE_BUFFERS;
5c81ff5e
JA
1227
1228 for (i = 0; i < DDIR_RWDIR_CNT; i++) {
1229 if (option_check_rate(td, i)) {
1230 td->flags |= TD_F_CHECK_RATE;
1231 break;
1232 }
1233 }
d72be545
JA
1234}
1235
9dbc7bfe
JA
1236static int setup_random_seeds(struct thread_data *td)
1237{
9781c080 1238 uint64_t seed;
9dbc7bfe
JA
1239 unsigned int i;
1240
1ed84d86
TK
1241 if (!td->o.rand_repeatable && !fio_option_is_set(&td->o, rand_seed)) {
1242 int ret = init_random_seeds(td->rand_seeds, sizeof(td->rand_seeds));
1243 if (!ret)
1244 td_fill_rand_seeds(td);
1245 return ret;
1246 }
9dbc7bfe 1247
40fe5e7b 1248 seed = td->o.rand_seed;
04778baf 1249 for (i = 0; i < 4; i++)
9dbc7bfe
JA
1250 seed *= 0x9e370001UL;
1251
1252 for (i = 0; i < FIO_RAND_NR_OFFS; i++) {
87a0ea3b 1253 td->rand_seeds[i] = seed * td->thread_number + i;
9dbc7bfe
JA
1254 seed *= 0x9e370001UL;
1255 }
1256
1257 td_fill_rand_seeds(td);
1258 return 0;
1259}
1260
de98bd30
JA
1261enum {
1262 FPRE_NONE = 0,
1263 FPRE_JOBNAME,
1264 FPRE_JOBNUM,
8d53c5f8
TG
1265 FPRE_FILENUM,
1266 FPRE_CLIENTUID
de98bd30
JA
1267};
1268
1269static struct fpre_keyword {
1270 const char *keyword;
1271 size_t strlen;
1272 int key;
1273} fpre_keywords[] = {
1274 { .keyword = "$jobname", .key = FPRE_JOBNAME, },
1275 { .keyword = "$jobnum", .key = FPRE_JOBNUM, },
1276 { .keyword = "$filenum", .key = FPRE_FILENUM, },
8d53c5f8 1277 { .keyword = "$clientuid", .key = FPRE_CLIENTUID, },
de98bd30
JA
1278 { .keyword = NULL, },
1279 };
1280
3660ceae 1281static char *make_filename(char *buf, size_t buf_size,struct thread_options *o,
de98bd30
JA
1282 const char *jobname, int jobnum, int filenum)
1283{
1284 struct fpre_keyword *f;
1285 char copy[PATH_MAX];
b400a20e 1286 size_t dst_left = PATH_MAX - 1;
de98bd30
JA
1287
1288 if (!o->filename_format || !strlen(o->filename_format)) {
1289 sprintf(buf, "%s.%d.%d", jobname, jobnum, filenum);
e5a43605 1290 return buf;
de98bd30
JA
1291 }
1292
1293 for (f = &fpre_keywords[0]; f->keyword; f++)
1294 f->strlen = strlen(f->keyword);
1295
36833fb0 1296 snprintf(buf, buf_size, "%s", o->filename_format);
3660ceae 1297
de98bd30
JA
1298 memset(copy, 0, sizeof(copy));
1299 for (f = &fpre_keywords[0]; f->keyword; f++) {
1300 do {
1301 size_t pre_len, post_start = 0;
1302 char *str, *dst = copy;
1303
e25b6d5a 1304 str = strcasestr(buf, f->keyword);
de98bd30
JA
1305 if (!str)
1306 break;
1307
1308 pre_len = str - buf;
1309 if (strlen(str) != f->strlen)
1310 post_start = pre_len + f->strlen;
1311
1312 if (pre_len) {
1313 strncpy(dst, buf, pre_len);
1314 dst += pre_len;
73a467e6 1315 dst_left -= pre_len;
de98bd30
JA
1316 }
1317
1318 switch (f->key) {
73a467e6
JA
1319 case FPRE_JOBNAME: {
1320 int ret;
1321
1322 ret = snprintf(dst, dst_left, "%s", jobname);
1323 if (ret < 0)
1324 break;
17a2be59
JA
1325 else if (ret > dst_left) {
1326 log_err("fio: truncated filename\n");
1327 dst += dst_left;
1328 dst_left = 0;
1329 } else {
1330 dst += ret;
1331 dst_left -= ret;
1332 }
de98bd30 1333 break;
73a467e6
JA
1334 }
1335 case FPRE_JOBNUM: {
1336 int ret;
1337
1338 ret = snprintf(dst, dst_left, "%d", jobnum);
1339 if (ret < 0)
1340 break;
17a2be59
JA
1341 else if (ret > dst_left) {
1342 log_err("fio: truncated filename\n");
1343 dst += dst_left;
1344 dst_left = 0;
1345 } else {
1346 dst += ret;
1347 dst_left -= ret;
1348 }
de98bd30 1349 break;
73a467e6
JA
1350 }
1351 case FPRE_FILENUM: {
1352 int ret;
1353
1354 ret = snprintf(dst, dst_left, "%d", filenum);
1355 if (ret < 0)
1356 break;
17a2be59
JA
1357 else if (ret > dst_left) {
1358 log_err("fio: truncated filename\n");
1359 dst += dst_left;
1360 dst_left = 0;
1361 } else {
1362 dst += ret;
1363 dst_left -= ret;
1364 }
de98bd30 1365 break;
73a467e6 1366 }
8d53c5f8
TG
1367 case FPRE_CLIENTUID: {
1368 int ret;
1369 ret = snprintf(dst, dst_left, "%s", client_sockaddr_str);
1370 if (ret < 0)
1371 break;
1372 else if (ret > dst_left) {
1373 log_err("fio: truncated filename\n");
1374 dst += dst_left;
1375 dst_left = 0;
1376 } else {
1377 dst += ret;
1378 dst_left -= ret;
1379 }
1380 break;
1381 }
de98bd30
JA
1382 default:
1383 assert(0);
1384 break;
1385 }
1386
1387 if (post_start)
73a467e6 1388 strncpy(dst, buf + post_start, dst_left);
de98bd30 1389
36833fb0 1390 snprintf(buf, buf_size, "%s", copy);
de98bd30
JA
1391 } while (1);
1392 }
1393
1394 return buf;
1395}
f9633d72 1396
8aa89d70 1397bool parse_dryrun(void)
f9633d72
JA
1398{
1399 return dump_cmdline || parse_only;
1400}
1401
3a5db920
JA
1402static void gen_log_name(char *name, size_t size, const char *logtype,
1403 const char *logname, unsigned int num,
1404 const char *suf, int per_job)
1405{
1406 if (per_job)
1407 snprintf(name, size, "%s_%s.%d.%s", logname, logtype, num, suf);
1408 else
1409 snprintf(name, size, "%s_%s.%s", logname, logtype, suf);
1410}
1411
9cc8cb91
AK
1412static int check_waitees(char *waitee)
1413{
1414 struct thread_data *td;
1415 int i, ret = 0;
1416
1417 for_each_td(td, i) {
1418 if (td->subjob_number)
1419 continue;
1420
1421 ret += !strcmp(td->o.name, waitee);
1422 }
1423
1424 return ret;
1425}
1426
1427static bool wait_for_ok(const char *jobname, struct thread_options *o)
1428{
1429 int nw;
1430
1431 if (!o->wait_for)
1432 return true;
1433
1434 if (!strcmp(jobname, o->wait_for)) {
1435 log_err("%s: a job cannot wait for itself (wait_for=%s).\n",
1436 jobname, o->wait_for);
1437 return false;
1438 }
1439
1440 if (!(nw = check_waitees(o->wait_for))) {
1441 log_err("%s: waitee job %s unknown.\n", jobname, o->wait_for);
1442 return false;
1443 }
1444
1445 if (nw > 1) {
1446 log_err("%s: multiple waitees %s found,\n"
1447 "please avoid duplicates when using wait_for option.\n",
1448 jobname, o->wait_for);
1449 return false;
1450 }
1451
1452 return true;
1453}
1454
13f475ad
NC
1455static int verify_per_group_options(struct thread_data *td, const char *jobname)
1456{
1457 struct thread_data *td2;
1458 int i;
1459
1460 for_each_td(td2, i) {
1461 if (td->groupid != td2->groupid)
1462 continue;
1463
1464 if (td->o.stats &&
1465 td->o.lat_percentiles != td2->o.lat_percentiles) {
1466 log_err("fio: lat_percentiles in job: %s differs from group\n",
1467 jobname);
1468 return 1;
1469 }
1470 }
1471
1472 return 0;
1473}
1474
789b8673
JA
1475/*
1476 * Treat an empty log file name the same as a one not given
1477 */
1478static const char *make_log_name(const char *logname, const char *jobname)
1479{
1480 if (logname && strcmp(logname, ""))
1481 return logname;
1482
1483 return jobname;
1484}
1485
906c8d75
JA
1486/*
1487 * Adds a job to the list of things todo. Sanitizes the various options
1488 * to make sure we don't have conflicts, and initializes various
1489 * members of td.
1490 */
b7cfb2e1 1491static int add_job(struct thread_data *td, const char *jobname, int job_add_num,
46bcd498 1492 int recursed, int client_type)
ebac4655 1493{
af52b345 1494 unsigned int i;
32e31c8c 1495 char fname[PATH_MAX + 1];
e132cbae 1496 int numjobs, file_alloced;
de98bd30 1497 struct thread_options *o = &td->o;
cb7e0ace 1498 char logname[PATH_MAX + 32];
ebac4655 1499
ebac4655
JA
1500 /*
1501 * the def_thread is just for options, it's not a real job
1502 */
1503 if (td == &def_thread)
1504 return 0;
1505
d72be545
JA
1506 init_flags(td);
1507
cca73aa7
JA
1508 /*
1509 * if we are just dumping the output command line, don't add the job
1510 */
f9633d72 1511 if (parse_dryrun()) {
cca73aa7
JA
1512 put_job(td);
1513 return 0;
1514 }
1515
46bcd498
JA
1516 td->client_type = client_type;
1517
58c55ba0 1518 if (profile_td_init(td))
66251554 1519 goto err;
58c55ba0 1520
de890a1e 1521 if (ioengine_load(td))
205927a3 1522 goto err;
df64119d 1523
e132cbae 1524 file_alloced = 0;
de98bd30 1525 if (!o->filename && !td->files_index && !o->read_iolog_file) {
e132cbae 1526 file_alloced = 1;
80be24f4 1527
5e62565b 1528 if (o->nr_files == 1 && exists_and_not_regfile(jobname))
5903e7b7 1529 add_file(td, jobname, job_add_num, 0);
7b05a215 1530 else {
de98bd30 1531 for (i = 0; i < o->nr_files; i++)
3660ceae 1532 add_file(td, make_filename(fname, sizeof(fname), o, jobname, job_add_num, i), job_add_num, 0);
af52b345 1533 }
0af7b542 1534 }
ebac4655 1535
49050b56
JA
1536 if (setup_random_seeds(td)) {
1537 td_verror(td, errno, "setup_random_seeds");
1538 goto err;
1539 }
1540
4e991c23
JA
1541 if (fixup_options(td))
1542 goto err;
e0a22335 1543
c49cfc76 1544 if (!td->o.dedupe_global && init_dedupe_working_set_seeds(td, 0))
0d71aa98
BD
1545 goto err;
1546
9cc8cb91
AK
1547 /*
1548 * Belongs to fixup_options, but o->name is not necessarily set as yet
1549 */
1550 if (!wait_for_ok(jobname, o))
1551 goto err;
1552
9e684a49
DE
1553 flow_init_job(td);
1554
de890a1e
SL
1555 /*
1556 * IO engines only need this for option callbacks, and the address may
1557 * change in subprocesses.
1558 */
1559 if (td->eo)
1560 *(struct thread_data **)td->eo = NULL;
1561
9b87f09b 1562 if (td_ioengine_flagged(td, FIO_DISKLESSIO)) {
07eb79df
JA
1563 struct fio_file *f;
1564
1565 for_each_file(td, f, i)
1566 f->real_file_size = -1ULL;
1567 }
1568
971caeb1 1569 td->sem = fio_sem_init(FIO_SEM_LOCKED);
ebac4655 1570
de98bd30 1571 td->ts.clat_percentiles = o->clat_percentiles;
b599759b 1572 td->ts.lat_percentiles = o->lat_percentiles;
56440e63 1573 td->ts.slat_percentiles = o->slat_percentiles;
de98bd30
JA
1574 td->ts.percentile_precision = o->percentile_precision;
1575 memcpy(td->ts.percentile_list, o->percentile_list, sizeof(o->percentile_list));
18aa1998 1576 td->ts.sig_figs = o->sig_figs;
83349190 1577
6619fc32 1578 init_thread_stat_min_vals(&td->ts);
54833d02 1579
1580 /*
1581 * td->>ddir_seq_nr needs to be initialized to 1, NOT o->ddir_seq_nr,
1582 * so that get_next_offset gets a new random offset the first time it
1583 * is called, instead of keeping an initial offset of 0 for the first
1584 * nr-1 calls
1585 */
1586 td->ddir_seq_nr = 1;
ebac4655 1587
de98bd30 1588 if ((o->stonewall || o->new_group) && prev_group_jobs) {
3c5df6fa 1589 prev_group_jobs = 0;
ebac4655 1590 groupid++;
d883efbd
JA
1591 if (groupid == INT_MAX) {
1592 log_err("fio: too many groups defined\n");
1593 goto err;
1594 }
3c5df6fa 1595 }
ebac4655
JA
1596
1597 td->groupid = groupid;
3c5df6fa 1598 prev_group_jobs++;
ebac4655 1599
13f475ad
NC
1600 if (td->o.group_reporting && prev_group_jobs > 1 &&
1601 verify_per_group_options(td, jobname))
1602 goto err;
1603
ebac4655
JA
1604 if (setup_rate(td))
1605 goto err;
1606
dded427c 1607 if (o->write_lat_log) {
aee2ab67
JA
1608 struct log_params p = {
1609 .td = td,
1610 .avg_msec = o->log_avg_msec,
1e613c9c
KC
1611 .hist_msec = o->log_hist_msec,
1612 .hist_coarseness = o->log_hist_coarseness,
aee2ab67
JA
1613 .log_type = IO_LOG_TYPE_LAT,
1614 .log_offset = o->log_offset,
03ec570f 1615 .log_prio = o->log_prio,
aee2ab67 1616 .log_gz = o->log_gz,
b26317c9 1617 .log_gz_store = o->log_gz_store,
aee2ab67 1618 };
789b8673 1619 const char *pre = make_log_name(o->lat_log_file, o->name);
b26317c9 1620 const char *suf;
aee2ab67 1621
b26317c9
JA
1622 if (p.log_gz_store)
1623 suf = "log.fz";
1624 else
1625 suf = "log";
1626
ef37053e
DLM
1627 if (!o->disable_lat) {
1628 gen_log_name(logname, sizeof(logname), "lat", pre,
1629 td->thread_number, suf, o->per_job_logs);
1630 setup_log(&td->lat_log, &p, logname);
1631 }
3a5db920 1632
ef37053e
DLM
1633 if (!o->disable_slat) {
1634 gen_log_name(logname, sizeof(logname), "slat", pre,
1635 td->thread_number, suf, o->per_job_logs);
1636 setup_log(&td->slat_log, &p, logname);
1637 }
3a5db920 1638
ef37053e
DLM
1639 if (!o->disable_clat) {
1640 gen_log_name(logname, sizeof(logname), "clat", pre,
1641 td->thread_number, suf, o->per_job_logs);
1642 setup_log(&td->clat_log, &p, logname);
1643 }
a7935806 1644
ebac4655 1645 }
1e613c9c 1646
dded427c 1647 if (o->write_hist_log) {
1e613c9c
KC
1648 struct log_params p = {
1649 .td = td,
1650 .avg_msec = o->log_avg_msec,
1651 .hist_msec = o->log_hist_msec,
1652 .hist_coarseness = o->log_hist_coarseness,
1653 .log_type = IO_LOG_TYPE_HIST,
1654 .log_offset = o->log_offset,
03ec570f 1655 .log_prio = o->log_prio,
1e613c9c
KC
1656 .log_gz = o->log_gz,
1657 .log_gz_store = o->log_gz_store,
1658 };
789b8673 1659 const char *pre = make_log_name(o->hist_log_file, o->name);
1e613c9c
KC
1660 const char *suf;
1661
66da8a60
JA
1662#ifndef CONFIG_ZLIB
1663 if (td->client_type) {
1664 log_err("fio: --write_hist_log requires zlib in client/server mode\n");
1665 goto err;
1666 }
1667#endif
1668
1e613c9c
KC
1669 if (p.log_gz_store)
1670 suf = "log.fz";
1671 else
1672 suf = "log";
1673
dded427c 1674 gen_log_name(logname, sizeof(logname), "clat_hist", pre,
1e613c9c
KC
1675 td->thread_number, suf, o->per_job_logs);
1676 setup_log(&td->clat_hist_log, &p, logname);
1677 }
1678
dded427c 1679 if (o->write_bw_log) {
aee2ab67
JA
1680 struct log_params p = {
1681 .td = td,
1682 .avg_msec = o->log_avg_msec,
1e613c9c
KC
1683 .hist_msec = o->log_hist_msec,
1684 .hist_coarseness = o->log_hist_coarseness,
aee2ab67
JA
1685 .log_type = IO_LOG_TYPE_BW,
1686 .log_offset = o->log_offset,
03ec570f 1687 .log_prio = o->log_prio,
aee2ab67 1688 .log_gz = o->log_gz,
b26317c9 1689 .log_gz_store = o->log_gz_store,
aee2ab67 1690 };
789b8673 1691 const char *pre = make_log_name(o->bw_log_file, o->name);
b26317c9
JA
1692 const char *suf;
1693
a47591e4
JA
1694 if (fio_option_is_set(o, bw_avg_time))
1695 p.avg_msec = min(o->log_avg_msec, o->bw_avg_time);
1696 else
1697 o->bw_avg_time = p.avg_msec;
c82acb8d 1698
1e613c9c
KC
1699 p.hist_msec = o->log_hist_msec;
1700 p.hist_coarseness = o->log_hist_coarseness;
a47591e4 1701
b26317c9
JA
1702 if (p.log_gz_store)
1703 suf = "log.fz";
1704 else
1705 suf = "log";
aee2ab67 1706
dded427c 1707 gen_log_name(logname, sizeof(logname), "bw", pre,
3a5db920 1708 td->thread_number, suf, o->per_job_logs);
aee2ab67 1709 setup_log(&td->bw_log, &p, logname);
cb7e0ace 1710 }
dded427c 1711 if (o->write_iops_log) {
aee2ab67
JA
1712 struct log_params p = {
1713 .td = td,
1714 .avg_msec = o->log_avg_msec,
1e613c9c
KC
1715 .hist_msec = o->log_hist_msec,
1716 .hist_coarseness = o->log_hist_coarseness,
aee2ab67
JA
1717 .log_type = IO_LOG_TYPE_IOPS,
1718 .log_offset = o->log_offset,
03ec570f 1719 .log_prio = o->log_prio,
aee2ab67 1720 .log_gz = o->log_gz,
b26317c9 1721 .log_gz_store = o->log_gz_store,
aee2ab67 1722 };
789b8673 1723 const char *pre = make_log_name(o->iops_log_file, o->name);
b26317c9
JA
1724 const char *suf;
1725
a47591e4
JA
1726 if (fio_option_is_set(o, iops_avg_time))
1727 p.avg_msec = min(o->log_avg_msec, o->iops_avg_time);
1728 else
1729 o->iops_avg_time = p.avg_msec;
c82acb8d 1730
1e613c9c
KC
1731 p.hist_msec = o->log_hist_msec;
1732 p.hist_coarseness = o->log_hist_coarseness;
a47591e4 1733
b26317c9
JA
1734 if (p.log_gz_store)
1735 suf = "log.fz";
1736 else
1737 suf = "log";
aee2ab67 1738
dded427c 1739 gen_log_name(logname, sizeof(logname), "iops", pre,
3a5db920 1740 td->thread_number, suf, o->per_job_logs);
aee2ab67 1741 setup_log(&td->iops_log, &p, logname);
cb7e0ace 1742 }
ebac4655 1743
de98bd30
JA
1744 if (!o->name)
1745 o->name = strdup(jobname);
01452055 1746
129fb2d4 1747 if (output_format & FIO_OUTPUT_NORMAL) {
b990b5c0 1748 if (!job_add_num) {
b7cfb2e1 1749 if (is_backend && !recursed)
2f122b13 1750 fio_server_send_add_job(td);
807f9971 1751
9b87f09b 1752 if (!td_ioengine_flagged(td, FIO_NOIO)) {
d21e2535
JA
1753 char *c1, *c2, *c3, *c4;
1754 char *c5 = NULL, *c6 = NULL;
d694a6a7 1755 int i2p = is_power_of_2(o->kb_base);
a41fc529 1756 struct buf_output out;
f8977ee6 1757
e883cb35
JF
1758 c1 = num2str(o->min_bs[DDIR_READ], o->sig_figs, 1, i2p, N2S_BYTE);
1759 c2 = num2str(o->max_bs[DDIR_READ], o->sig_figs, 1, i2p, N2S_BYTE);
1760 c3 = num2str(o->min_bs[DDIR_WRITE], o->sig_figs, 1, i2p, N2S_BYTE);
1761 c4 = num2str(o->max_bs[DDIR_WRITE], o->sig_figs, 1, i2p, N2S_BYTE);
d21e2535
JA
1762
1763 if (!o->bs_is_seq_rand) {
e883cb35
JF
1764 c5 = num2str(o->min_bs[DDIR_TRIM], o->sig_figs, 1, i2p, N2S_BYTE);
1765 c6 = num2str(o->max_bs[DDIR_TRIM], o->sig_figs, 1, i2p, N2S_BYTE);
d21e2535
JA
1766 }
1767
a41fc529 1768 buf_output_init(&out);
71ccdf58 1769 __log_buf(&out, "%s: (g=%d): rw=%s, ", td->o.name,
d21e2535
JA
1770 td->groupid,
1771 ddir_str(o->td_ddir));
1772
1773 if (o->bs_is_seq_rand)
71ccdf58 1774 __log_buf(&out, "bs=(R) %s-%s, (W) %s-%s, bs_is_seq_rand, ",
d21e2535
JA
1775 c1, c2, c3, c4);
1776 else
71ccdf58 1777 __log_buf(&out, "bs=(R) %s-%s, (W) %s-%s, (T) %s-%s, ",
d21e2535
JA
1778 c1, c2, c3, c4, c5, c6);
1779
71ccdf58 1780 __log_buf(&out, "ioengine=%s, iodepth=%u\n",
de98bd30 1781 td->io_ops->name, o->iodepth);
a41fc529 1782 log_info_buf(out.buf, out.buflen);
d5bb0a89 1783 buf_output_free(&out);
f8977ee6
JA
1784
1785 free(c1);
1786 free(c2);
1787 free(c3);
1788 free(c4);
6eaf09d6
SL
1789 free(c5);
1790 free(c6);
f8977ee6 1791 }
b990b5c0 1792 } else if (job_add_num == 1)
6d86144d 1793 log_info("...\n");
c6ae0a5b 1794 }
ebac4655 1795
56a90eba
VF
1796 if (td_steadystate_init(td))
1797 goto err;
16e56d25 1798
b9921d1a
DZ
1799 if (o->merge_blktrace_file && !merge_blktrace_iologs(td))
1800 goto err;
1801
1802 if (merge_blktrace_only) {
1803 put_job(td);
1804 return 0;
1805 }
1806
ebac4655
JA
1807 /*
1808 * recurse add identical jobs, clear numjobs and stonewall options
1809 * as they don't apply to sub-jobs
1810 */
de98bd30 1811 numjobs = o->numjobs;
ebac4655 1812 while (--numjobs) {
8983ce71 1813 struct thread_data *td_new = get_new_job(false, td, true, jobname);
ebac4655
JA
1814
1815 if (!td_new)
1816 goto err;
1817
2dc1bbeb
JA
1818 td_new->o.numjobs = 1;
1819 td_new->o.stonewall = 0;
92c1d41f 1820 td_new->o.new_group = 0;
69bdd6ba 1821 td_new->subjob_number = numjobs;
16e56d25
VF
1822 td_new->o.ss_dur = o->ss_dur * 1000000l;
1823 td_new->o.ss_limit = o->ss_limit;
e132cbae
JA
1824
1825 if (file_alloced) {
455a50fa
CE
1826 if (td_new->files) {
1827 struct fio_file *f;
e711df54
JA
1828 for_each_file(td_new, f, i)
1829 fio_file_free(f);
ece6d647 1830 free(td_new->files);
455a50fa
CE
1831 td_new->files = NULL;
1832 }
ece6d647
AK
1833 td_new->files_index = 0;
1834 td_new->files_size = 0;
455a50fa
CE
1835 if (td_new->o.filename) {
1836 free(td_new->o.filename);
1837 td_new->o.filename = NULL;
1838 }
e132cbae
JA
1839 }
1840
bcbfeefa 1841 if (add_job(td_new, jobname, numjobs, 1, client_type))
ebac4655
JA
1842 goto err;
1843 }
3c5df6fa 1844
ebac4655
JA
1845 return 0;
1846err:
1847 put_job(td);
1848 return -1;
1849}
1850
79d16311
JA
1851/*
1852 * Parse as if 'o' was a command line
1853 */
46bcd498 1854void add_job_opts(const char **o, int client_type)
79d16311
JA
1855{
1856 struct thread_data *td, *td_parent;
1857 int i, in_global = 1;
1858 char jobname[32];
1859
1860 i = 0;
1861 td_parent = td = NULL;
1862 while (o[i]) {
1863 if (!strncmp(o[i], "name", 4)) {
1864 in_global = 0;
1865 if (td)
46bcd498 1866 add_job(td, jobname, 0, 0, client_type);
79d16311
JA
1867 td = NULL;
1868 sprintf(jobname, "%s", o[i] + 5);
1869 }
1870 if (in_global && !td_parent)
8983ce71 1871 td_parent = get_new_job(true, &def_thread, false, jobname);
79d16311
JA
1872 else if (!in_global && !td) {
1873 if (!td_parent)
1874 td_parent = &def_thread;
8983ce71 1875 td = get_new_job(false, td_parent, false, jobname);
79d16311
JA
1876 }
1877 if (in_global)
c2292325 1878 fio_options_parse(td_parent, (char **) &o[i], 1);
79d16311 1879 else
c2292325 1880 fio_options_parse(td, (char **) &o[i], 1);
79d16311
JA
1881 i++;
1882 }
1883
1884 if (td)
46bcd498 1885 add_job(td, jobname, 0, 0, client_type);
79d16311
JA
1886}
1887
01f06b63
JA
1888static int skip_this_section(const char *name)
1889{
ad0a2735
JA
1890 int i;
1891
1892 if (!nr_job_sections)
01f06b63
JA
1893 return 0;
1894 if (!strncmp(name, "global", 6))
1895 return 0;
1896
ad0a2735
JA
1897 for (i = 0; i < nr_job_sections; i++)
1898 if (!strcmp(job_sections[i], name))
1899 return 0;
1900
1901 return 1;
01f06b63
JA
1902}
1903
ebac4655
JA
1904static int is_empty_or_comment(char *line)
1905{
1906 unsigned int i;
1907
1908 for (i = 0; i < strlen(line); i++) {
1909 if (line[i] == ';')
1910 return 1;
5cc2da30
IM
1911 if (line[i] == '#')
1912 return 1;
76cd9378 1913 if (!isspace((int) line[i]) && !iscntrl((int) line[i]))
ebac4655
JA
1914 return 0;
1915 }
1916
1917 return 1;
1918}
1919
07261983
JA
1920/*
1921 * This is our [ini] type file parser.
1922 */
fc8d6d05 1923static int __parse_jobs_ini(struct thread_data *td,
b3270921
AK
1924 char *file, int is_buf, int stonewall_flag, int type,
1925 int nested, char *name, char ***popts, int *aopts, int *nopts)
ebac4655 1926{
8983ce71 1927 bool global = false;
cd91e482 1928 bool stdin_occupied = false;
b3270921 1929 char *string;
ebac4655
JA
1930 FILE *f;
1931 char *p;
0c7e37a0 1932 int ret = 0, stonewall;
097b2991 1933 int first_sect = 1;
ccf8f127 1934 int skip_fgets = 0;
01f06b63 1935 int inside_skip = 0;
3b8b7135
JA
1936 char **opts;
1937 int i, alloc_opts, num_opts;
ebac4655 1938
b3270921
AK
1939 dprint(FD_PARSE, "Parsing ini file %s\n", file);
1940 assert(td || !nested);
1941
50d16976
JA
1942 if (is_buf)
1943 f = NULL;
1944 else {
cd91e482 1945 if (!strcmp(file, "-")) {
50d16976 1946 f = stdin;
cd91e482 1947 stdin_occupied = true;
1948 } else
50d16976 1949 f = fopen(file, "r");
5a729cbe 1950
50d16976 1951 if (!f) {
323255cc
JA
1952 int __err = errno;
1953
1954 log_err("fio: unable to open '%s' job file\n", file);
02957cd4
JA
1955 if (td)
1956 td_verror(td, __err, "job file open");
50d16976
JA
1957 return 1;
1958 }
ebac4655
JA
1959 }
1960
07a2919d 1961 string = malloc(OPT_LEN_MAX);
7f7e6e59
JA
1962
1963 /*
1964 * it's really 256 + small bit, 280 should suffice
1965 */
b3270921
AK
1966 if (!nested) {
1967 name = malloc(280);
1968 memset(name, 0, 280);
1969 }
ebac4655 1970
b3270921
AK
1971 opts = NULL;
1972 if (nested && popts) {
1973 opts = *popts;
1974 alloc_opts = *aopts;
1975 num_opts = *nopts;
1976 }
1977
1978 if (!opts) {
1979 alloc_opts = 8;
1980 opts = malloc(sizeof(char *) * alloc_opts);
1981 num_opts = 0;
1982 }
3b8b7135 1983
0c7e37a0 1984 stonewall = stonewall_flag;
7c124ac1 1985 do {
ccf8f127
JA
1986 /*
1987 * if skip_fgets is set, we already have loaded a line we
1988 * haven't handled.
1989 */
1990 if (!skip_fgets) {
50d16976
JA
1991 if (is_buf)
1992 p = strsep(&file, "\n");
1993 else
07a2919d 1994 p = fgets(string, OPT_LEN_MAX, f);
ccf8f127
JA
1995 if (!p)
1996 break;
1997 }
cdc7f193 1998
ccf8f127 1999 skip_fgets = 0;
cdc7f193 2000 strip_blank_front(&p);
6c7c7da1 2001 strip_blank_end(p);
cdc7f193 2002
b3270921 2003 dprint(FD_PARSE, "%s\n", p);
ebac4655
JA
2004 if (is_empty_or_comment(p))
2005 continue;
b3270921
AK
2006
2007 if (!nested) {
2008 if (sscanf(p, "[%255[^\n]]", name) != 1) {
2009 if (inside_skip)
2010 continue;
2011
2012 log_err("fio: option <%s> outside of "
2013 "[] job section\n", p);
0e9c21a2 2014 ret = 1;
b3270921
AK
2015 break;
2016 }
2017
2018 name[strlen(name) - 1] = '\0';
2019
2020 if (skip_this_section(name)) {
2021 inside_skip = 1;
01f06b63 2022 continue;
b3270921
AK
2023 } else
2024 inside_skip = 0;
ebac4655 2025
b3270921 2026 dprint(FD_PARSE, "Parsing section [%s]\n", name);
7a4b80a1 2027
b3270921 2028 global = !strncmp(name, "global", 6);
01f06b63 2029
b3270921
AK
2030 if (dump_cmdline) {
2031 if (first_sect)
2032 log_info("fio ");
2033 if (!global)
2034 log_info("--name=%s ", name);
2035 first_sect = 0;
2036 }
ebac4655 2037
8983ce71 2038 td = get_new_job(global, &def_thread, false, name);
b3270921
AK
2039 if (!td) {
2040 ret = 1;
2041 break;
2042 }
cca73aa7 2043
b3270921
AK
2044 /*
2045 * Separate multiple job files by a stonewall
2046 */
2047 if (!global && stonewall) {
2048 td->o.stonewall = stonewall;
2049 stonewall = 0;
2050 }
ebac4655 2051
b3270921
AK
2052 num_opts = 0;
2053 memset(opts, 0, alloc_opts * sizeof(char *));
972cfd25 2054 }
b3270921
AK
2055 else
2056 skip_fgets = 1;
3b8b7135 2057
50d16976 2058 while (1) {
b3270921
AK
2059 if (!skip_fgets) {
2060 if (is_buf)
2061 p = strsep(&file, "\n");
2062 else
07a2919d 2063 p = fgets(string, OPT_LEN_MAX, f);
b3270921
AK
2064 if (!p)
2065 break;
2066 dprint(FD_PARSE, "%s", p);
2067 }
50d16976 2068 else
b3270921 2069 skip_fgets = 0;
50d16976 2070
ebac4655
JA
2071 if (is_empty_or_comment(p))
2072 continue;
e1f36503 2073
b6754f9d 2074 strip_blank_front(&p);
7c124ac1 2075
ccf8f127
JA
2076 /*
2077 * new section, break out and make sure we don't
2078 * fgets() a new line at the top.
2079 */
2080 if (p[0] == '[') {
b3270921
AK
2081 if (nested) {
2082 log_err("No new sections in included files\n");
1809e349
JA
2083 ret = 1;
2084 goto out;
b3270921
AK
2085 }
2086
ccf8f127 2087 skip_fgets = 1;
7c124ac1 2088 break;
ccf8f127 2089 }
7c124ac1 2090
4ae3f763 2091 strip_blank_end(p);
aea47d44 2092
b3270921 2093 if (!strncmp(p, "include", strlen("include"))) {
c0821a08
AK
2094 char *filename = p + strlen("include") + 1,
2095 *ts, *full_fn = NULL;
2096
2097 /*
2098 * Allow for the include filename
2099 * specification to be relative.
2100 */
2101 if (access(filename, F_OK) &&
2102 (ts = strrchr(file, '/'))) {
36833fb0
BVA
2103 if (asprintf(&full_fn, "%.*s%s",
2104 (int)(ts - file + 1), file,
2105 filename) < 0) {
c0821a08
AK
2106 ret = ENOMEM;
2107 break;
2108 }
c0821a08
AK
2109 filename = full_fn;
2110 }
2111
2112 ret = __parse_jobs_ini(td, filename, is_buf,
2113 stonewall_flag, type, 1,
2114 name, &opts,
2115 &alloc_opts, &num_opts);
b3270921 2116
c0821a08
AK
2117 if (ret) {
2118 log_err("Error %d while parsing "
2119 "include file %s\n",
b3270921 2120 ret, filename);
b3270921 2121 }
c0821a08
AK
2122
2123 if (full_fn)
2124 free(full_fn);
2125
2126 if (ret)
2127 break;
2128
b3270921
AK
2129 continue;
2130 }
2131
3b8b7135
JA
2132 if (num_opts == alloc_opts) {
2133 alloc_opts <<= 1;
2134 opts = realloc(opts,
2135 alloc_opts * sizeof(char *));
2136 }
2137
2138 opts[num_opts] = strdup(p);
2139 num_opts++;
ebac4655 2140 }
ebac4655 2141
b3270921
AK
2142 if (nested) {
2143 *popts = opts;
2144 *aopts = alloc_opts;
2145 *nopts = num_opts;
2146 goto out;
2147 }
2148
c2292325 2149 ret = fio_options_parse(td, opts, num_opts);
d19c04d1 2150
cd91e482 2151 if (!ret && td->o.read_iolog_file != NULL) {
2152 char *fname = get_name_by_idx(td->o.read_iolog_file,
2153 td->subjob_number);
2154 if (!strcmp(fname, "-")) {
2155 if (stdin_occupied) {
2156 log_err("fio: only one user (read_iolog_file/job "
2157 "file) of stdin is permitted at once but "
2158 "more than one was found.\n");
d19c04d1 2159 ret = 1;
2160 }
cd91e482 2161 stdin_occupied = true;
d19c04d1 2162 }
2163 }
c2292325
JA
2164 if (!ret) {
2165 if (dump_cmdline)
2166 dump_opt_list(td);
2167
46bcd498 2168 ret = add_job(td, name, 0, 0, type);
c2292325 2169 } else {
b1508cf9
JA
2170 log_err("fio: job %s dropped\n", name);
2171 put_job(td);
45410acb 2172 }
3b8b7135
JA
2173
2174 for (i = 0; i < num_opts; i++)
2175 free(opts[i]);
2176 num_opts = 0;
7c124ac1 2177 } while (!ret);
ebac4655 2178
cca73aa7
JA
2179 if (dump_cmdline)
2180 log_info("\n");
2181
7e356b2d
JA
2182 i = 0;
2183 while (i < nr_job_sections) {
2184 free(job_sections[i]);
2185 i++;
2186 }
2187
593737d9
DP
2188 free(job_sections);
2189 job_sections = NULL;
2190 nr_job_sections = 0;
2191
2577594d 2192 free(opts);
b3270921
AK
2193out:
2194 free(string);
2195 if (!nested)
2196 free(name);
50d16976 2197 if (!is_buf && f != stdin)
5a729cbe 2198 fclose(f);
45410acb 2199 return ret;
ebac4655
JA
2200}
2201
b3270921
AK
2202int parse_jobs_ini(char *file, int is_buf, int stonewall_flag, int type)
2203{
2204 return __parse_jobs_ini(NULL, file, is_buf, stonewall_flag, type,
2205 0, NULL, NULL, NULL, NULL);
2206}
2207
ebac4655
JA
2208static int fill_def_thread(void)
2209{
2210 memset(&def_thread, 0, sizeof(def_thread));
66e19a38 2211 INIT_FLIST_HEAD(&def_thread.opt_list);
ebac4655 2212
375b2695 2213 fio_getaffinity(getpid(), &def_thread.o.cpumask);
8b28bd41 2214 def_thread.o.error_dump = 1;
25bd16ce 2215
ebac4655 2216 /*
ee738499 2217 * fill default options
ebac4655 2218 */
214e1eca 2219 fio_fill_default_options(&def_thread);
ebac4655
JA
2220 return 0;
2221}
2222
2236df3d
JA
2223static void show_debug_categories(void)
2224{
44acdcf4 2225#ifdef FIO_INC_DEBUG
447931d9 2226 const struct debug_level *dl = &debug_levels[0];
2236df3d
JA
2227 int curlen, first = 1;
2228
2229 curlen = 0;
2230 while (dl->name) {
2231 int has_next = (dl + 1)->name != NULL;
2232
2233 if (first || curlen + strlen(dl->name) >= 80) {
2234 if (!first) {
2235 printf("\n");
2236 curlen = 0;
2237 }
2238 curlen += printf("\t\t\t%s", dl->name);
2239 curlen += 3 * (8 - 1);
2240 if (has_next)
2241 curlen += printf(",");
2242 } else {
2243 curlen += printf("%s", dl->name);
2244 if (has_next)
2245 curlen += printf(",");
2246 }
2247 dl++;
2248 first = 0;
2249 }
2250 printf("\n");
44acdcf4 2251#endif
2236df3d
JA
2252}
2253
baa9fe6b
TK
2254/*
2255 * Following options aren't printed by usage().
2256 * --append-terse - Equivalent to --output-format=terse, see f6a7df53.
2257 * --latency-log - Deprecated option.
2258 */
45378b35 2259static void usage(const char *name)
4785f995 2260{
3d43382c 2261 printf("%s\n", fio_version_string);
45378b35 2262 printf("%s [options] [job options] <job file(s)>\n", name);
2236df3d
JA
2263 printf(" --debug=options\tEnable debug logging. May be one/more of:\n");
2264 show_debug_categories();
111e032d 2265 printf(" --parse-only\t\tParse options only, don't start any IO\n");
b9921d1a 2266 printf(" --merge-blktrace-only\tMerge blktraces only, don't start any IO\n");
83881283 2267 printf(" --output\t\tWrite output to file\n");
d23ae827 2268 printf(" --bandwidth-log\tGenerate aggregate bandwidth logs\n");
83881283 2269 printf(" --minimal\t\tMinimal (terse) output\n");
95a12fbe
TK
2270 printf(" --output-format=type\tOutput format (terse,json,json+,normal)\n");
2271 printf(" --terse-version=type\tSet terse version output format"
52c9872f 2272 " (default 3, or 2 or 4 or 5)\n");
f3afa57e 2273 printf(" --version\t\tPrint version info and exit\n");
83881283 2274 printf(" --help\t\tPrint this page\n");
23893646 2275 printf(" --cpuclock-test\tPerform test/validation of CPU clock\n");
1a1822bf 2276 printf(" --crctest=[type]\tTest speed of checksum functions\n");
83881283 2277 printf(" --cmdhelp=cmd\t\tPrint command help, \"all\" for all of"
5ec10eaa 2278 " them\n");
de890a1e
SL
2279 printf(" --enghelp=engine\tPrint ioengine help, or list"
2280 " available ioengines\n");
2281 printf(" --enghelp=engine,cmd\tPrint help for an ioengine"
2282 " cmd\n");
83881283
JA
2283 printf(" --showcmd\t\tTurn a job file into command line options\n");
2284 printf(" --eta=when\t\tWhen ETA estimate should be printed\n");
2285 printf(" \t\tMay be \"always\", \"never\" or \"auto\"\n");
9a496382 2286 printf(" --eta-newline=t\tForce a new line for every 't'");
e382e661 2287 printf(" period passed\n");
06464907
JA
2288 printf(" --status-interval=t\tForce full status dump every");
2289 printf(" 't' period passed\n");
83881283 2290 printf(" --readonly\t\tTurn on safety read-only checks, preventing"
5ec10eaa 2291 " writes\n");
95a12fbe
TK
2292 printf(" --section=name\tOnly run specified section in job file,"
2293 " multiple sections can be specified\n");
83881283 2294 printf(" --alloc-size=kb\tSet smalloc pool to this size in kb"
95a12fbe 2295 " (def 16384)\n");
83881283
JA
2296 printf(" --warnings-fatal\tFio parser warnings are fatal\n");
2297 printf(" --max-jobs=nr\t\tMaximum number of threads/processes to support\n");
2298 printf(" --server=args\t\tStart a backend fio server\n");
2299 printf(" --daemonize=pidfile\tBackground fio server, write pid to file\n");
95a12fbe 2300 printf(" --client=hostname\tTalk to remote backend(s) fio server at hostname\n");
323255cc 2301 printf(" --remote-config=file\tTell fio server to load this local job file\n");
f2a2ce0e
HL
2302 printf(" --idle-prof=option\tReport cpu idleness on a system or percpu basis\n"
2303 "\t\t\t(option=system,percpu) or run unit work\n"
2304 "\t\t\tcalibration only (option=calibrate)\n");
b26317c9
JA
2305#ifdef CONFIG_ZLIB
2306 printf(" --inflate-log=log\tInflate and output compressed log\n");
2307#endif
b63efd30 2308 printf(" --trigger-file=file\tExecute trigger cmd when file exists\n");
2ae7a90d 2309 printf(" --trigger-timeout=t\tExecute trigger at this time\n");
b63efd30
JA
2310 printf(" --trigger=cmd\t\tSet this command as local trigger\n");
2311 printf(" --trigger-remote=cmd\tSet this command as remote trigger\n");
d264264a 2312 printf(" --aux-path=path\tUse this path for fio state generated files\n");
d292596c 2313 printf("\nFio was written by Jens Axboe <axboe@kernel.dk>\n");
4785f995
JA
2314}
2315
79e48f72 2316#ifdef FIO_INC_DEBUG
447931d9 2317const struct debug_level debug_levels[] = {
0b8d11ed
JA
2318 { .name = "process",
2319 .help = "Process creation/exit logging",
2320 .shift = FD_PROCESS,
2321 },
2322 { .name = "file",
2323 .help = "File related action logging",
2324 .shift = FD_FILE,
2325 },
2326 { .name = "io",
2327 .help = "IO and IO engine action logging (offsets, queue, completions, etc)",
2328 .shift = FD_IO,
2329 },
2330 { .name = "mem",
2331 .help = "Memory allocation/freeing logging",
2332 .shift = FD_MEM,
2333 },
2334 { .name = "blktrace",
2335 .help = "blktrace action logging",
2336 .shift = FD_BLKTRACE,
2337 },
2338 { .name = "verify",
2339 .help = "IO verification action logging",
2340 .shift = FD_VERIFY,
2341 },
2342 { .name = "random",
2343 .help = "Random generation logging",
2344 .shift = FD_RANDOM,
2345 },
2346 { .name = "parse",
2347 .help = "Parser logging",
2348 .shift = FD_PARSE,
2349 },
2350 { .name = "diskutil",
2351 .help = "Disk utility logging actions",
2352 .shift = FD_DISKUTIL,
2353 },
2354 { .name = "job",
2355 .help = "Logging related to creating/destroying jobs",
2356 .shift = FD_JOB,
2357 },
2358 { .name = "mutex",
2359 .help = "Mutex logging",
2360 .shift = FD_MUTEX
2361 },
2362 { .name = "profile",
2363 .help = "Logging related to profiles",
2364 .shift = FD_PROFILE,
2365 },
2366 { .name = "time",
2367 .help = "Logging related to time keeping functions",
2368 .shift = FD_TIME,
2369 },
2370 { .name = "net",
2371 .help = "Network logging",
2372 .shift = FD_NET,
2373 },
3e260a46
JA
2374 { .name = "rate",
2375 .help = "Rate logging",
2376 .shift = FD_RATE,
2377 },
0c56718d
JA
2378 { .name = "compress",
2379 .help = "Log compression logging",
2380 .shift = FD_COMPRESS,
2381 },
16e56d25
VF
2382 { .name = "steadystate",
2383 .help = "Steady state detection logging",
2384 .shift = FD_STEADYSTATE,
2385 },
e569ca6b
VF
2386 { .name = "helperthread",
2387 .help = "Helper thread logging",
2388 .shift = FD_HELPERTHREAD,
2389 },
4806b824
BVA
2390 { .name = "zbd",
2391 .help = "Zoned Block Device logging",
2392 .shift = FD_ZBD,
2393 },
02444ad1 2394 { .name = NULL, },
ee56ad50
JA
2395};
2396
c09823ab 2397static int set_debug(const char *string)
ee56ad50 2398{
447931d9 2399 const struct debug_level *dl;
ee56ad50
JA
2400 char *p = (char *) string;
2401 char *opt;
2402 int i;
2403
2706fa00
JA
2404 if (!string)
2405 return 0;
2406
ee56ad50 2407 if (!strcmp(string, "?") || !strcmp(string, "help")) {
ee56ad50
JA
2408 log_info("fio: dumping debug options:");
2409 for (i = 0; debug_levels[i].name; i++) {
2410 dl = &debug_levels[i];
2411 log_info("%s,", dl->name);
2412 }
bd6f78b2 2413 log_info("all\n");
c09823ab 2414 return 1;
ee56ad50
JA
2415 }
2416
2417 while ((opt = strsep(&p, ",")) != NULL) {
2418 int found = 0;
2419
5e1d306e
JA
2420 if (!strncmp(opt, "all", 3)) {
2421 log_info("fio: set all debug options\n");
2422 fio_debug = ~0UL;
2423 continue;
2424 }
2425
ee56ad50
JA
2426 for (i = 0; debug_levels[i].name; i++) {
2427 dl = &debug_levels[i];
5e1d306e
JA
2428 found = !strncmp(opt, dl->name, strlen(dl->name));
2429 if (!found)
2430 continue;
2431
2432 if (dl->shift == FD_JOB) {
2433 opt = strchr(opt, ':');
2434 if (!opt) {
2435 log_err("fio: missing job number\n");
2436 break;
2437 }
2438 opt++;
2439 fio_debug_jobno = atoi(opt);
2440 log_info("fio: set debug jobno %d\n",
2441 fio_debug_jobno);
2442 } else {
ee56ad50 2443 log_info("fio: set debug option %s\n", opt);
bd6f78b2 2444 fio_debug |= (1UL << dl->shift);
ee56ad50 2445 }
5e1d306e 2446 break;
ee56ad50
JA
2447 }
2448
2449 if (!found)
2450 log_err("fio: debug mask %s not found\n", opt);
2451 }
c09823ab 2452 return 0;
ee56ad50 2453}
79e48f72 2454#else
69b98d4c 2455static int set_debug(const char *string)
79e48f72
JA
2456{
2457 log_err("fio: debug tracing not included in build\n");
c09823ab 2458 return 1;
79e48f72
JA
2459}
2460#endif
9ac8a797 2461
4c6107ff
JA
2462static void fio_options_fill_optstring(void)
2463{
2464 char *ostr = cmd_optstr;
2465 int i, c;
2466
2467 c = i = 0;
2468 while (l_opts[i].name) {
2469 ostr[c++] = l_opts[i].val;
2470 if (l_opts[i].has_arg == required_argument)
2471 ostr[c++] = ':';
2472 else if (l_opts[i].has_arg == optional_argument) {
2473 ostr[c++] = ':';
2474 ostr[c++] = ':';
2475 }
2476 i++;
2477 }
2478 ostr[c] = '\0';
2479}
2480
c2c94585
JA
2481static int client_flag_set(char c)
2482{
2483 int i;
2484
2485 i = 0;
2486 while (l_opts[i].name) {
2487 int val = l_opts[i].val;
2488
2489 if (c == (val & 0xff))
2490 return (val & FIO_CLIENT_FLAG);
2491
2492 i++;
2493 }
2494
2495 return 0;
2496}
2497
10aa136b 2498static void parse_cmd_client(void *client, char *opt)
7a4b8240 2499{
fa2ea806 2500 fio_client_add_cmd_option(client, opt);
7a4b8240
JA
2501}
2502
a893c261
JA
2503static void show_closest_option(const char *name)
2504{
2505 int best_option, best_distance;
2506 int i, distance;
2507
2508 while (*name == '-')
2509 name++;
2510
2511 best_option = -1;
2512 best_distance = INT_MAX;
2513 i = 0;
2514 while (l_opts[i].name) {
2515 distance = string_distance(name, l_opts[i].name);
2516 if (distance < best_distance) {
2517 best_distance = distance;
2518 best_option = i;
2519 }
2520 i++;
2521 }
2522
3701636d 2523 if (best_option != -1 && string_distance_ok(name, best_distance))
a893c261
JA
2524 log_err("Did you mean %s?\n", l_opts[best_option].name);
2525}
2526
a666cab8
JA
2527static int parse_output_format(const char *optarg)
2528{
2529 char *p, *orig, *opt;
2530 int ret = 0;
2531
2532 p = orig = strdup(optarg);
2533
2534 output_format = 0;
2535
2536 while ((opt = strsep(&p, ",")) != NULL) {
2537 if (!strcmp(opt, "minimal") ||
2538 !strcmp(opt, "terse") ||
2539 !strcmp(opt, "csv"))
2540 output_format |= FIO_OUTPUT_TERSE;
2541 else if (!strcmp(opt, "json"))
2542 output_format |= FIO_OUTPUT_JSON;
513e37ee
VF
2543 else if (!strcmp(opt, "json+"))
2544 output_format |= (FIO_OUTPUT_JSON | FIO_OUTPUT_JSON_PLUS);
a666cab8
JA
2545 else if (!strcmp(opt, "normal"))
2546 output_format |= FIO_OUTPUT_NORMAL;
2547 else {
2548 log_err("fio: invalid output format %s\n", opt);
2549 ret = 1;
2550 break;
2551 }
2552 }
2553
2554 free(orig);
2555 return ret;
2556}
2557
46bcd498 2558int parse_cmd_line(int argc, char *argv[], int client_type)
ebac4655 2559{
b4692828 2560 struct thread_data *td = NULL;
c09823ab 2561 int c, ini_idx = 0, lidx, ret = 0, do_exit = 0, exit_val = 0;
4c6107ff 2562 char *ostr = cmd_optstr;
977b9596 2563 char *pid_file = NULL;
9bae26e8 2564 void *cur_client = NULL;
f1867a7f 2565 bool backend = false;
ebac4655 2566
c2c94585
JA
2567 /*
2568 * Reset optind handling, since we may call this multiple times
2569 * for the backend.
2570 */
2571 optind = 1;
7a4b8240 2572
c2c94585
JA
2573 while ((c = getopt_long_only(argc, argv, ostr, l_opts, &lidx)) != -1) {
2574 if ((c & FIO_CLIENT_FLAG) || client_flag_set(c)) {
fa2ea806 2575 parse_cmd_client(cur_client, argv[optind - 1]);
7a4b8240
JA
2576 c &= ~FIO_CLIENT_FLAG;
2577 }
2578
ebac4655 2579 switch (c) {
2b386d25
JA
2580 case 'a':
2581 smalloc_pool_size = atoi(optarg);
52d892b2 2582 smalloc_pool_size <<= 10;
5f9454a2 2583 sinit();
2b386d25 2584 break;
b4692828 2585 case 'l':
cb7e0ace
JA
2586 log_err("fio: --latency-log is deprecated. Use per-job latency log options.\n");
2587 do_exit++;
2588 exit_val = 1;
b4692828 2589 break;
3d73e5a9 2590 case 'b':
f1867a7f 2591 write_bw_log = true;
b4692828 2592 break;
34b1b5c6
JA
2593 case 'o': {
2594 FILE *tmp;
2595
988da120 2596 if (f_out && f_out != stdout)
5e1d8745
JA
2597 fclose(f_out);
2598
34b1b5c6
JA
2599 tmp = fopen(optarg, "w+");
2600 if (!tmp) {
2601 log_err("fio: output file open error: %s\n", strerror(errno));
2602 exit_val = 1;
2603 do_exit++;
2604 break;
b4692828 2605 }
34b1b5c6 2606 f_err = f_out = tmp;
b4692828 2607 break;
34b1b5c6 2608 }
b4692828 2609 case 'm':
f3afa57e 2610 output_format = FIO_OUTPUT_TERSE;
b4692828 2611 break;
f3afa57e 2612 case 'F':
a666cab8
JA
2613 if (parse_output_format(optarg)) {
2614 log_err("fio: failed parsing output-format\n");
2615 exit_val = 1;
2616 do_exit++;
2617 break;
2618 }
2b8c71b0 2619 break;
f6a7df53
JA
2620 case 'f':
2621 output_format |= FIO_OUTPUT_TERSE;
2622 break;
b4692828 2623 case 'h':
1201b24a 2624 did_arg = true;
7874f8b7 2625 if (!cur_client) {
c2c94585 2626 usage(argv[0]);
7874f8b7
JA
2627 do_exit++;
2628 }
c2c94585 2629 break;
fd28ca49 2630 case 'c':
1201b24a 2631 did_arg = true;
7874f8b7 2632 if (!cur_client) {
c2c94585 2633 fio_show_option_help(optarg);
7874f8b7
JA
2634 do_exit++;
2635 }
c2c94585 2636 break;
de890a1e 2637 case 'i':
1201b24a 2638 did_arg = true;
de890a1e 2639 if (!cur_client) {
291a2d85 2640 exit_val = fio_show_ioengine_help(optarg);
de890a1e
SL
2641 do_exit++;
2642 }
2643 break;
cca73aa7 2644 case 's':
1201b24a 2645 did_arg = true;
f1867a7f 2646 dump_cmdline = true;
cca73aa7 2647 break;
724e4435
JA
2648 case 'r':
2649 read_only = 1;
2650 break;
b4692828 2651 case 'v':
1201b24a 2652 did_arg = true;
7874f8b7 2653 if (!cur_client) {
3d43382c 2654 log_info("%s\n", fio_version_string);
7874f8b7
JA
2655 do_exit++;
2656 }
c2c94585 2657 break;
f57a9c59
JA
2658 case 'V':
2659 terse_version = atoi(optarg);
a2c95580 2660 if (!(terse_version >= 2 && terse_version <= 5)) {
f57a9c59
JA
2661 log_err("fio: bad terse version format\n");
2662 exit_val = 1;
2663 do_exit++;
2664 }
2665 break;
e592a06b
AC
2666 case 'e':
2667 if (!strcmp("always", optarg))
2668 eta_print = FIO_ETA_ALWAYS;
2669 else if (!strcmp("never", optarg))
2670 eta_print = FIO_ETA_NEVER;
2671 break;
e382e661
JA
2672 case 'E': {
2673 long long t = 0;
2674
88038bc7 2675 if (check_str_time(optarg, &t, 1)) {
e382e661
JA
2676 log_err("fio: failed parsing eta time %s\n", optarg);
2677 exit_val = 1;
2678 do_exit++;
db37d890 2679 break;
e382e661 2680 }
88038bc7 2681 eta_new_line = t / 1000;
db37d890
JA
2682 if (!eta_new_line) {
2683 log_err("fio: eta new line time too short\n");
2684 exit_val = 1;
2685 do_exit++;
2686 }
2687 break;
2688 }
2689 case 'O': {
2690 long long t = 0;
2691
2692 if (check_str_time(optarg, &t, 1)) {
2693 log_err("fio: failed parsing eta interval %s\n", optarg);
2694 exit_val = 1;
2695 do_exit++;
2696 break;
2697 }
2698 eta_interval_msec = t / 1000;
2699 if (eta_interval_msec < DISK_UTIL_MSEC) {
2700 log_err("fio: eta interval time too short (%umsec min)\n", DISK_UTIL_MSEC);
2701 exit_val = 1;
2702 do_exit++;
2703 }
e382e661
JA
2704 break;
2705 }
ee56ad50 2706 case 'd':
c09823ab
JA
2707 if (set_debug(optarg))
2708 do_exit++;
ee56ad50 2709 break;
111e032d 2710 case 'P':
1201b24a 2711 did_arg = true;
f1867a7f 2712 parse_only = true;
111e032d 2713 break;
ad0a2735
JA
2714 case 'x': {
2715 size_t new_size;
2716
01f06b63 2717 if (!strcmp(optarg, "global")) {
5ec10eaa
JA
2718 log_err("fio: can't use global as only "
2719 "section\n");
c09823ab
JA
2720 do_exit++;
2721 exit_val = 1;
01f06b63
JA
2722 break;
2723 }
ad0a2735
JA
2724 new_size = (nr_job_sections + 1) * sizeof(char *);
2725 job_sections = realloc(job_sections, new_size);
2726 job_sections[nr_job_sections] = strdup(optarg);
2727 nr_job_sections++;
01f06b63 2728 break;
ad0a2735 2729 }
b26317c9
JA
2730#ifdef CONFIG_ZLIB
2731 case 'X':
2732 exit_val = iolog_file_inflate(optarg);
1201b24a 2733 did_arg = true;
b26317c9
JA
2734 do_exit++;
2735 break;
2736#endif
9ac8a797 2737 case 'p':
1201b24a 2738 did_arg = true;
4af7c007
JA
2739 if (exec_profile)
2740 free(exec_profile);
07b3232d 2741 exec_profile = strdup(optarg);
9ac8a797 2742 break;
b4692828 2743 case FIO_GETOPT_JOB: {
5ec10eaa 2744 const char *opt = l_opts[lidx].name;
b4692828
JA
2745 char *val = optarg;
2746
c2b1e753 2747 if (!strncmp(opt, "name", 4) && td) {
46bcd498 2748 ret = add_job(td, td->o.name ?: "fio", 0, 0, client_type);
66251554 2749 if (ret)
4a4ac4e3 2750 goto out_free;
c2b1e753 2751 td = NULL;
1201b24a 2752 did_arg = true;
c2b1e753 2753 }
b4692828 2754 if (!td) {
01f06b63 2755 int is_section = !strncmp(opt, "name", 4);
3106f220
JA
2756 int global = 0;
2757
01f06b63 2758 if (!is_section || !strncmp(val, "global", 6))
3106f220 2759 global = 1;
c2b1e753 2760
01f06b63
JA
2761 if (is_section && skip_this_section(val))
2762 continue;
2763
8983ce71 2764 td = get_new_job(global, &def_thread, true, NULL);
f6ff24cb
JA
2765 if (!td || ioengine_load(td)) {
2766 if (td) {
2767 put_job(td);
2768 td = NULL;
2769 }
2770 do_exit++;
205a719e 2771 exit_val = 1;
f6ff24cb
JA
2772 break;
2773 }
de890a1e 2774 fio_options_set_ioengine_opts(l_opts, td);
b4692828 2775 }
38d0adb0 2776
9d918187
JA
2777 if ((!val || !strlen(val)) &&
2778 l_opts[lidx].has_arg == required_argument) {
2779 log_err("fio: option %s requires an argument\n", opt);
2780 ret = 1;
2781 } else
2782 ret = fio_cmd_option_parse(td, opt, val);
2783
bfb3ea22
JA
2784 if (ret) {
2785 if (td) {
2786 put_job(td);
2787 td = NULL;
2788 }
a88c8c14 2789 do_exit++;
205a719e 2790 exit_val = 1;
bfb3ea22 2791 }
de890a1e
SL
2792
2793 if (!ret && !strcmp(opt, "ioengine")) {
f6ff24cb 2794 if (ioengine_load(td)) {
342f570e
JA
2795 put_job(td);
2796 td = NULL;
f6ff24cb 2797 do_exit++;
205a719e 2798 exit_val = 1;
f6ff24cb
JA
2799 break;
2800 }
de890a1e
SL
2801 fio_options_set_ioengine_opts(l_opts, td);
2802 }
2803 break;
2804 }
2805 case FIO_GETOPT_IOENGINE: {
2806 const char *opt = l_opts[lidx].name;
2807 char *val = optarg;
b1ed74e0
JA
2808
2809 if (!td)
2810 break;
2811
de890a1e 2812 ret = fio_cmd_ioengine_option_parse(td, opt, val);
f43aab59
AG
2813
2814 if (ret) {
2815 if (td) {
2816 put_job(td);
2817 td = NULL;
2818 }
2819 do_exit++;
2820 exit_val = 1;
2821 }
b4692828
JA
2822 break;
2823 }
a9523c6f
JA
2824 case 'w':
2825 warnings_fatal = 1;
2826 break;
fca70358 2827 case 'j':
42eb9952 2828 /* we don't track/need this anymore, ignore it */
fca70358 2829 break;
50d16976 2830 case 'S':
1201b24a 2831 did_arg = true;
c8931876 2832#ifndef CONFIG_NO_SHM
a37f69b7 2833 if (nr_clients) {
132159a5
JA
2834 log_err("fio: can't be both client and server\n");
2835 do_exit++;
2836 exit_val = 1;
2837 break;
2838 }
87aa8f19 2839 if (optarg)
bebe6398 2840 fio_server_set_arg(optarg);
f1867a7f
JA
2841 is_backend = true;
2842 backend = true;
c8931876
JA
2843#else
2844 log_err("fio: client/server requires SHM support\n");
2845 do_exit++;
2846 exit_val = 1;
2847#endif
50d16976 2848 break;
f8fef4c6 2849#ifdef WIN32
2850 case 'N':
2851 did_arg = true;
2852 fio_server_internal_set(optarg);
2853 break;
2854#endif
e46d8091 2855 case 'D':
6cfe9a8c
JA
2856 if (pid_file)
2857 free(pid_file);
402668f3 2858 pid_file = strdup(optarg);
e46d8091 2859 break;
f2a2ce0e
HL
2860 case 'I':
2861 if ((ret = fio_idle_prof_parse_opt(optarg))) {
2862 /* exit on error and calibration only */
1201b24a 2863 did_arg = true;
f2a2ce0e 2864 do_exit++;
7d8ea970 2865 if (ret == -1)
f2a2ce0e
HL
2866 exit_val = 1;
2867 }
2868 break;
132159a5 2869 case 'C':
1201b24a 2870 did_arg = true;
132159a5
JA
2871 if (is_backend) {
2872 log_err("fio: can't be both client and server\n");
2873 do_exit++;
2874 exit_val = 1;
2875 break;
2876 }
08633c32
BE
2877 /* if --client parameter contains a pathname */
2878 if (0 == access(optarg, R_OK)) {
2879 /* file contains a list of host addrs or names */
2972708f 2880 char hostaddr[PATH_MAX] = {0};
08633c32
BE
2881 char formatstr[8];
2882 FILE * hostf = fopen(optarg, "r");
2883 if (!hostf) {
2884 log_err("fio: could not open client list file %s for read\n", optarg);
2885 do_exit++;
2886 exit_val = 1;
2887 break;
2888 }
2972708f
JA
2889 sprintf(formatstr, "%%%ds", PATH_MAX - 1);
2890 /*
2891 * read at most PATH_MAX-1 chars from each
2892 * record in this file
2893 */
08633c32
BE
2894 while (fscanf(hostf, formatstr, hostaddr) == 1) {
2895 /* expect EVERY host in file to be valid */
2896 if (fio_client_add(&fio_client_ops, hostaddr, &cur_client)) {
2897 log_err("fio: failed adding client %s from file %s\n", hostaddr, optarg);
2898 do_exit++;
2899 exit_val = 1;
2900 break;
2901 }
2902 }
2903 fclose(hostf);
2904 break; /* no possibility of job file for "this client only" */
2905 }
a5276616 2906 if (fio_client_add(&fio_client_ops, optarg, &cur_client)) {
bebe6398
JA
2907 log_err("fio: failed adding client %s\n", optarg);
2908 do_exit++;
2909 exit_val = 1;
2910 break;
2911 }
14ea90ed
JA
2912 /*
2913 * If the next argument exists and isn't an option,
2914 * assume it's a job file for this client only.
2915 */
2916 while (optind < argc) {
2917 if (!strncmp(argv[optind], "--", 2) ||
2918 !strncmp(argv[optind], "-", 1))
2919 break;
2920
bb781643 2921 if (fio_client_add_ini_file(cur_client, argv[optind], false))
323255cc 2922 break;
14ea90ed
JA
2923 optind++;
2924 }
132159a5 2925 break;
323255cc 2926 case 'R':
1201b24a 2927 did_arg = true;
bb781643 2928 if (fio_client_add_ini_file(cur_client, optarg, true)) {
323255cc
JA
2929 do_exit++;
2930 exit_val = 1;
2931 }
2932 break;
7d11f871 2933 case 'T':
1201b24a 2934 did_arg = true;
7d11f871 2935 do_exit++;
aad918e4 2936 exit_val = fio_monotonic_clocktest(1);
7d11f871 2937 break;
fec0f21c 2938 case 'G':
1201b24a 2939 did_arg = true;
fec0f21c
JA
2940 do_exit++;
2941 exit_val = fio_crctest(optarg);
2942 break;
b76d85a4
JA
2943 case 'M':
2944 did_arg = true;
2945 do_exit++;
2946 exit_val = fio_memcpy_test(optarg);
2947 break;
06464907
JA
2948 case 'L': {
2949 long long val;
2950
88038bc7 2951 if (check_str_time(optarg, &val, 1)) {
06464907
JA
2952 log_err("fio: failed parsing time %s\n", optarg);
2953 do_exit++;
2954 exit_val = 1;
2955 break;
2956 }
969357b0
JA
2957 if (val < 1000) {
2958 log_err("fio: status interval too small\n");
2959 do_exit++;
2960 exit_val = 1;
2961 }
88038bc7 2962 status_interval = val / 1000;
06464907
JA
2963 break;
2964 }
b63efd30 2965 case 'W':
f9cbae9e
JA
2966 if (trigger_file)
2967 free(trigger_file);
b63efd30
JA
2968 trigger_file = strdup(optarg);
2969 break;
2970 case 'H':
f9cbae9e
JA
2971 if (trigger_cmd)
2972 free(trigger_cmd);
b63efd30
JA
2973 trigger_cmd = strdup(optarg);
2974 break;
2975 case 'J':
f9cbae9e
JA
2976 if (trigger_remote_cmd)
2977 free(trigger_remote_cmd);
b63efd30 2978 trigger_remote_cmd = strdup(optarg);
ca09be4b 2979 break;
d264264a
JA
2980 case 'K':
2981 if (aux_path)
2982 free(aux_path);
2983 aux_path = strdup(optarg);
2984 break;
ca09be4b
JA
2985 case 'B':
2986 if (check_str_time(optarg, &trigger_timeout, 1)) {
2987 log_err("fio: failed parsing time %s\n", optarg);
2988 do_exit++;
2989 exit_val = 1;
2990 }
2991 trigger_timeout /= 1000000;
2992 break;
b9921d1a
DZ
2993
2994 case 'A':
2995 did_arg = true;
f1867a7f 2996 merge_blktrace_only = true;
b9921d1a 2997 break;
798827c8
JA
2998 case '?':
2999 log_err("%s: unrecognized option '%s'\n", argv[0],
3000 argv[optind - 1]);
a893c261 3001 show_closest_option(argv[optind - 1]);
87933e32 3002 fio_fallthrough;
b4692828 3003 default:
c09823ab
JA
3004 do_exit++;
3005 exit_val = 1;
b4692828 3006 break;
ebac4655 3007 }
c7d5c941
JA
3008 if (do_exit)
3009 break;
ebac4655 3010 }
c9fad893 3011
0b14f0a8
JA
3012 if (do_exit && !(is_backend || nr_clients))
3013 exit(exit_val);
536582bf 3014
fb296043
JA
3015 if (nr_clients && fio_clients_connect())
3016 exit(1);
132159a5 3017
81179eec 3018 if (is_backend && backend)
402668f3 3019 return fio_start_server(pid_file);
b8ba87ac
JA
3020 else if (pid_file)
3021 free(pid_file);
50d16976 3022
b4692828 3023 if (td) {
7d8ea970 3024 if (!ret) {
46bcd498 3025 ret = add_job(td, td->o.name ?: "fio", 0, 0, client_type);
7d8ea970 3026 if (ret)
3bc20ebd 3027 exit(1);
7d8ea970 3028 }
972cfd25 3029 }
774a6177 3030
7874f8b7 3031 while (!ret && optind < argc) {
b4692828
JA
3032 ini_idx++;
3033 ini_file = realloc(ini_file, ini_idx * sizeof(char *));
3034 ini_file[ini_idx - 1] = strdup(argv[optind]);
3035 optind++;
eb8bbf48 3036 }
972cfd25 3037
4a4ac4e3 3038out_free:
972cfd25 3039 return ini_idx;
ebac4655
JA
3040}
3041
0420ba6a 3042int fio_init_options(void)
ebac4655 3043{
b4692828
JA
3044 f_out = stdout;
3045 f_err = stderr;
3046
4c6107ff 3047 fio_options_fill_optstring();
5ec10eaa 3048 fio_options_dup_and_init(l_opts);
b4692828 3049
9d9eb2e7
JA
3050 atexit(free_shm);
3051
ebac4655
JA
3052 if (fill_def_thread())
3053 return 1;
3054
0420ba6a
JA
3055 return 0;
3056}
3057
51167799
JA
3058extern int fio_check_options(struct thread_options *);
3059
0420ba6a
JA
3060int parse_options(int argc, char *argv[])
3061{
46bcd498 3062 const int type = FIO_CLIENT_TYPE_CLI;
0420ba6a
JA
3063 int job_files, i;
3064
3065 if (fio_init_options())
3066 return 1;
51167799
JA
3067 if (fio_test_cconv(&def_thread.o))
3068 log_err("fio: failed internal cconv test\n");
0420ba6a 3069
46bcd498 3070 job_files = parse_cmd_line(argc, argv, type);
ebac4655 3071
cdf54d85
JA
3072 if (job_files > 0) {
3073 for (i = 0; i < job_files; i++) {
bc4f5ef6 3074 if (i && fill_def_thread())
132159a5 3075 return 1;
cdf54d85
JA
3076 if (nr_clients) {
3077 if (fio_clients_send_ini(ini_file[i]))
3078 return 1;
3079 free(ini_file[i]);
3080 } else if (!is_backend) {
46bcd498 3081 if (parse_jobs_ini(ini_file[i], 0, i, type))
cdf54d85
JA
3082 return 1;
3083 free(ini_file[i]);
3084 }
132159a5 3085 }
14ea90ed
JA
3086 } else if (nr_clients) {
3087 if (fill_def_thread())
3088 return 1;
3089 if (fio_clients_send_ini(NULL))
3090 return 1;
972cfd25 3091 }
ebac4655 3092
88c6ed80 3093 free(ini_file);
7e356b2d 3094 fio_options_free(&def_thread);
bcbfeefa 3095 filesetup_mem_free();
b4692828
JA
3096
3097 if (!thread_number) {
f9633d72 3098 if (parse_dryrun())
cca73aa7 3099 return 0;
07b3232d
JA
3100 if (exec_profile)
3101 return 0;
a37f69b7 3102 if (is_backend || nr_clients)
5c341e9a 3103 return 0;
085399db
JA
3104 if (did_arg)
3105 return 0;
cca73aa7 3106
4bb7a775 3107 log_err("No job(s) defined\n\n");
a2e4a093
JA
3108 usage(argv[0]);
3109 return 1;
b4692828
JA
3110 }
3111
129fb2d4 3112 if (output_format & FIO_OUTPUT_NORMAL)
3d43382c 3113 log_info("%s\n", fio_version_string);
f6dea4d3 3114
ebac4655
JA
3115 return 0;
3116}
588b7f09
JA
3117
3118void options_default_fill(struct thread_options *o)
3119{
3120 memcpy(o, &def_thread.o, sizeof(*o));
3121}
c2292325 3122
66e19a38 3123struct thread_data *get_global_options(void)
c2292325 3124{
66e19a38 3125 return &def_thread;
c2292325 3126}