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