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