projects / fio.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
t/btrace2fio: don't dec inflight for requeue
[fio.git] / init.c
... / ...
CommitLineData
1/*
2 * This file contains job initialization and setup functions.
3 */
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>
12#include <sys/types.h>
13#include <sys/stat.h>
14
15#include "fio.h"
16#ifndef FIO_NO_HAVE_SHM_H
17#include <sys/shm.h>
18#endif
19
20#include "parse.h"
21#include "smalloc.h"
22#include "filehash.h"
23#include "verify.h"
24#include "profile.h"
25#include "server.h"
26#include "idletime.h"
27#include "filelock.h"
28
29#include "lib/getopt.h"
30#include "lib/strcasestr.h"
31
32#include "crc/test.h"
33
34const char fio_version_string[] = FIO_VERSION;
35
36#define FIO_RANDSEED (0xb1899bedUL)
37
38static char **ini_file;
39static int max_jobs = FIO_MAX_JOBS;
40static int dump_cmdline;
41static long long def_timeout;
42static int parse_only;
43
44static struct thread_data def_thread;
45struct thread_data *threads = NULL;
46static char **job_sections;
47static int nr_job_sections;
48
49int exitall_on_terminate = 0;
50int output_format = FIO_OUTPUT_NORMAL;
51int append_terse_output = 0;
52int eta_print = FIO_ETA_AUTO;
53int eta_new_line = 0;
54FILE *f_out = NULL;
55FILE *f_err = NULL;
56char *exec_profile = NULL;
57int warnings_fatal = 0;
58int terse_version = 3;
59int is_backend = 0;
60int nr_clients = 0;
61int log_syslog = 0;
62
63int write_bw_log = 0;
64int read_only = 0;
65int status_interval = 0;
66
67static int prev_group_jobs;
68
69unsigned long fio_debug = 0;
70unsigned int fio_debug_jobno = -1;
71unsigned int *fio_debug_jobp = NULL;
72
73static char cmd_optstr[256];
74static int did_arg;
75
76#define FIO_CLIENT_FLAG (1 << 16)
77
78/*
79 * Command line options. These will contain the above, plus a few
80 * extra that only pertain to fio itself and not jobs.
81 */
82static struct option l_opts[FIO_NR_OPTIONS] = {
83 {
84 .name = (char *) "output",
85 .has_arg = required_argument,
86 .val = 'o' | FIO_CLIENT_FLAG,
87 },
88 {
89 .name = (char *) "timeout",
90 .has_arg = required_argument,
91 .val = 't' | FIO_CLIENT_FLAG,
92 },
93 {
94 .name = (char *) "latency-log",
95 .has_arg = required_argument,
96 .val = 'l' | FIO_CLIENT_FLAG,
97 },
98 {
99 .name = (char *) "bandwidth-log",
100 .has_arg = required_argument,
101 .val = 'b' | FIO_CLIENT_FLAG,
102 },
103 {
104 .name = (char *) "minimal",
105 .has_arg = no_argument,
106 .val = 'm' | FIO_CLIENT_FLAG,
107 },
108 {
109 .name = (char *) "output-format",
110 .has_arg = optional_argument,
111 .val = 'F' | FIO_CLIENT_FLAG,
112 },
113 {
114 .name = (char *) "append-terse",
115 .has_arg = optional_argument,
116 .val = 'f',
117 },
118 {
119 .name = (char *) "version",
120 .has_arg = no_argument,
121 .val = 'v' | FIO_CLIENT_FLAG,
122 },
123 {
124 .name = (char *) "help",
125 .has_arg = no_argument,
126 .val = 'h' | FIO_CLIENT_FLAG,
127 },
128 {
129 .name = (char *) "cmdhelp",
130 .has_arg = optional_argument,
131 .val = 'c' | FIO_CLIENT_FLAG,
132 },
133 {
134 .name = (char *) "enghelp",
135 .has_arg = optional_argument,
136 .val = 'i' | FIO_CLIENT_FLAG,
137 },
138 {
139 .name = (char *) "showcmd",
140 .has_arg = no_argument,
141 .val = 's' | FIO_CLIENT_FLAG,
142 },
143 {
144 .name = (char *) "readonly",
145 .has_arg = no_argument,
146 .val = 'r' | FIO_CLIENT_FLAG,
147 },
148 {
149 .name = (char *) "eta",
150 .has_arg = required_argument,
151 .val = 'e' | FIO_CLIENT_FLAG,
152 },
153 {
154 .name = (char *) "eta-newline",
155 .has_arg = required_argument,
156 .val = 'E' | FIO_CLIENT_FLAG,
157 },
158 {
159 .name = (char *) "debug",
160 .has_arg = required_argument,
161 .val = 'd' | FIO_CLIENT_FLAG,
162 },
163 {
164 .name = (char *) "parse-only",
165 .has_arg = no_argument,
166 .val = 'P' | FIO_CLIENT_FLAG,
167 },
168 {
169 .name = (char *) "section",
170 .has_arg = required_argument,
171 .val = 'x' | FIO_CLIENT_FLAG,
172 },
173#ifdef CONFIG_ZLIB
174 {
175 .name = (char *) "inflate-log",
176 .has_arg = required_argument,
177 .val = 'X' | FIO_CLIENT_FLAG,
178 },
179#endif
180 {
181 .name = (char *) "alloc-size",
182 .has_arg = required_argument,
183 .val = 'a' | FIO_CLIENT_FLAG,
184 },
185 {
186 .name = (char *) "profile",
187 .has_arg = required_argument,
188 .val = 'p' | FIO_CLIENT_FLAG,
189 },
190 {
191 .name = (char *) "warnings-fatal",
192 .has_arg = no_argument,
193 .val = 'w' | FIO_CLIENT_FLAG,
194 },
195 {
196 .name = (char *) "max-jobs",
197 .has_arg = required_argument,
198 .val = 'j' | FIO_CLIENT_FLAG,
199 },
200 {
201 .name = (char *) "terse-version",
202 .has_arg = required_argument,
203 .val = 'V' | FIO_CLIENT_FLAG,
204 },
205 {
206 .name = (char *) "server",
207 .has_arg = optional_argument,
208 .val = 'S',
209 },
210 { .name = (char *) "daemonize",
211 .has_arg = required_argument,
212 .val = 'D',
213 },
214 {
215 .name = (char *) "client",
216 .has_arg = required_argument,
217 .val = 'C',
218 },
219 {
220 .name = (char *) "remote-config",
221 .has_arg = required_argument,
222 .val = 'R',
223 },
224 {
225 .name = (char *) "cpuclock-test",
226 .has_arg = no_argument,
227 .val = 'T',
228 },
229 {
230 .name = (char *) "crctest",
231 .has_arg = optional_argument,
232 .val = 'G',
233 },
234 {
235 .name = (char *) "idle-prof",
236 .has_arg = required_argument,
237 .val = 'I',
238 },
239 {
240 .name = (char *) "status-interval",
241 .has_arg = required_argument,
242 .val = 'L',
243 },
244 {
245 .name = NULL,
246 },
247};
248
249void free_threads_shm(void)
250{
251 if (threads) {
252 void *tp = threads;
253#ifndef CONFIG_NO_SHM
254 struct shmid_ds sbuf;
255
256 threads = NULL;
257 shmdt(tp);
258 shmctl(shm_id, IPC_RMID, &sbuf);
259 shm_id = -1;
260#else
261 threads = NULL;
262 free(tp);
263#endif
264 }
265}
266
267static void free_shm(void)
268{
269 if (threads) {
270 file_hash_exit();
271 flow_exit();
272 fio_debug_jobp = NULL;
273 free_threads_shm();
274 }
275
276 options_free(fio_options, &def_thread);
277 fio_filelock_exit();
278 scleanup();
279}
280
281/*
282 * The thread area is shared between the main process and the job
283 * threads/processes. So setup a shared memory segment that will hold
284 * all the job info. We use the end of the region for keeping track of
285 * open files across jobs, for file sharing.
286 */
287static int setup_thread_area(void)
288{
289 void *hash;
290
291 if (threads)
292 return 0;
293
294 /*
295 * 1024 is too much on some machines, scale max_jobs if
296 * we get a failure that looks like too large a shm segment
297 */
298 do {
299 size_t size = max_jobs * sizeof(struct thread_data);
300
301 size += file_hash_size;
302 size += sizeof(unsigned int);
303
304#ifndef CONFIG_NO_SHM
305 shm_id = shmget(0, size, IPC_CREAT | 0600);
306 if (shm_id != -1)
307 break;
308 if (errno != EINVAL && errno != ENOMEM && errno != ENOSPC) {
309 perror("shmget");
310 break;
311 }
312#else
313 threads = malloc(size);
314 if (threads)
315 break;
316#endif
317
318 max_jobs >>= 1;
319 } while (max_jobs);
320
321#ifndef CONFIG_NO_SHM
322 if (shm_id == -1)
323 return 1;
324
325 threads = shmat(shm_id, NULL, 0);
326 if (threads == (void *) -1) {
327 perror("shmat");
328 return 1;
329 }
330#endif
331
332 memset(threads, 0, max_jobs * sizeof(struct thread_data));
333 hash = (void *) threads + max_jobs * sizeof(struct thread_data);
334 fio_debug_jobp = (void *) hash + file_hash_size;
335 *fio_debug_jobp = -1;
336 file_hash_init(hash);
337
338 flow_init();
339
340 return 0;
341}
342
343static void set_cmd_options(struct thread_data *td)
344{
345 struct thread_options *o = &td->o;
346
347 if (!o->timeout)
348 o->timeout = def_timeout;
349}
350
351/*
352 * Return a free job structure.
353 */
354static struct thread_data *get_new_job(int global, struct thread_data *parent,
355 int preserve_eo, const char *jobname)
356{
357 struct thread_data *td;
358
359 if (global) {
360 set_cmd_options(&def_thread);
361 return &def_thread;
362 }
363 if (setup_thread_area()) {
364 log_err("error: failed to setup shm segment\n");
365 return NULL;
366 }
367 if (thread_number >= max_jobs) {
368 log_err("error: maximum number of jobs (%d) reached.\n",
369 max_jobs);
370 return NULL;
371 }
372
373 td = &threads[thread_number++];
374 *td = *parent;
375
376 td->io_ops = NULL;
377 if (!preserve_eo)
378 td->eo = NULL;
379
380 td->o.uid = td->o.gid = -1U;
381
382 dup_files(td, parent);
383 fio_options_mem_dupe(td);
384
385 profile_add_hooks(td);
386
387 td->thread_number = thread_number;
388 td->subjob_number = 0;
389
390 if (jobname)
391 td->o.name = strdup(jobname);
392
393 if (!parent->o.group_reporting)
394 stat_number++;
395
396 set_cmd_options(td);
397 return td;
398}
399
400static void put_job(struct thread_data *td)
401{
402 if (td == &def_thread)
403 return;
404
405 profile_td_exit(td);
406 flow_exit_job(td);
407
408 if (td->error)
409 log_info("fio: %s\n", td->verror);
410
411 fio_options_free(td);
412 if (td->io_ops)
413 free_ioengine(td);
414
415 if (td->o.name)
416 free(td->o.name);
417
418 memset(&threads[td->thread_number - 1], 0, sizeof(*td));
419 thread_number--;
420}
421
422static int __setup_rate(struct thread_data *td, enum fio_ddir ddir)
423{
424 unsigned int bs = td->o.min_bs[ddir];
425
426 assert(ddir_rw(ddir));
427
428 if (td->o.rate[ddir])
429 td->rate_bps[ddir] = td->o.rate[ddir];
430 else
431 td->rate_bps[ddir] = td->o.rate_iops[ddir] * bs;
432
433 if (!td->rate_bps[ddir]) {
434 log_err("rate lower than supported\n");
435 return -1;
436 }
437
438 td->rate_pending_usleep[ddir] = 0;
439 return 0;
440}
441
442static int setup_rate(struct thread_data *td)
443{
444 int ret = 0;
445
446 if (td->o.rate[DDIR_READ] || td->o.rate_iops[DDIR_READ])
447 ret = __setup_rate(td, DDIR_READ);
448 if (td->o.rate[DDIR_WRITE] || td->o.rate_iops[DDIR_WRITE])
449 ret |= __setup_rate(td, DDIR_WRITE);
450 if (td->o.rate[DDIR_TRIM] || td->o.rate_iops[DDIR_TRIM])
451 ret |= __setup_rate(td, DDIR_TRIM);
452
453 return ret;
454}
455
456static int fixed_block_size(struct thread_options *o)
457{
458 return o->min_bs[DDIR_READ] == o->max_bs[DDIR_READ] &&
459 o->min_bs[DDIR_WRITE] == o->max_bs[DDIR_WRITE] &&
460 o->min_bs[DDIR_TRIM] == o->max_bs[DDIR_TRIM] &&
461 o->min_bs[DDIR_READ] == o->min_bs[DDIR_WRITE] &&
462 o->min_bs[DDIR_READ] == o->min_bs[DDIR_TRIM];
463}
464
465
466static unsigned long long get_rand_start_delay(struct thread_data *td)
467{
468 unsigned long long delayrange;
469 unsigned long r;
470
471 delayrange = td->o.start_delay_high - td->o.start_delay;
472
473 r = __rand(&td->delay_state);
474 delayrange = (unsigned long long) ((double) delayrange * (r / (FRAND_MAX + 1.0)));
475
476 delayrange += td->o.start_delay;
477 return delayrange;
478}
479
480/*
481 * Lazy way of fixing up options that depend on each other. We could also
482 * define option callback handlers, but this is easier.
483 */
484static int fixup_options(struct thread_data *td)
485{
486 struct thread_options *o = &td->o;
487 int ret = 0;
488
489#ifndef FIO_HAVE_PSHARED_MUTEX
490 if (!o->use_thread) {
491 log_info("fio: this platform does not support process shared"
492 " mutexes, forcing use of threads. Use the 'thread'"
493 " option to get rid of this warning.\n");
494 o->use_thread = 1;
495 ret = warnings_fatal;
496 }
497#endif
498
499 if (o->write_iolog_file && o->read_iolog_file) {
500 log_err("fio: read iolog overrides write_iolog\n");
501 free(o->write_iolog_file);
502 o->write_iolog_file = NULL;
503 ret = warnings_fatal;
504 }
505
506 /*
507 * only really works with 1 file
508 */
509 if (o->zone_size && o->open_files > 1)
510 o->zone_size = 0;
511
512 /*
513 * If zone_range isn't specified, backward compatibility dictates it
514 * should be made equal to zone_size.
515 */
516 if (o->zone_size && !o->zone_range)
517 o->zone_range = o->zone_size;
518
519 /*
520 * Reads can do overwrites, we always need to pre-create the file
521 */
522 if (td_read(td) || td_rw(td))
523 o->overwrite = 1;
524
525 if (!o->min_bs[DDIR_READ])
526 o->min_bs[DDIR_READ] = o->bs[DDIR_READ];
527 if (!o->max_bs[DDIR_READ])
528 o->max_bs[DDIR_READ] = o->bs[DDIR_READ];
529 if (!o->min_bs[DDIR_WRITE])
530 o->min_bs[DDIR_WRITE] = o->bs[DDIR_WRITE];
531 if (!o->max_bs[DDIR_WRITE])
532 o->max_bs[DDIR_WRITE] = o->bs[DDIR_WRITE];
533 if (!o->min_bs[DDIR_TRIM])
534 o->min_bs[DDIR_TRIM] = o->bs[DDIR_TRIM];
535 if (!o->max_bs[DDIR_TRIM])
536 o->max_bs[DDIR_TRIM] = o->bs[DDIR_TRIM];
537
538
539 o->rw_min_bs = min(o->min_bs[DDIR_READ], o->min_bs[DDIR_WRITE]);
540 o->rw_min_bs = min(o->min_bs[DDIR_TRIM], o->rw_min_bs);
541
542 /*
543 * For random IO, allow blockalign offset other than min_bs.
544 */
545 if (!o->ba[DDIR_READ] || !td_random(td))
546 o->ba[DDIR_READ] = o->min_bs[DDIR_READ];
547 if (!o->ba[DDIR_WRITE] || !td_random(td))
548 o->ba[DDIR_WRITE] = o->min_bs[DDIR_WRITE];
549 if (!o->ba[DDIR_TRIM] || !td_random(td))
550 o->ba[DDIR_TRIM] = o->min_bs[DDIR_TRIM];
551
552 if ((o->ba[DDIR_READ] != o->min_bs[DDIR_READ] ||
553 o->ba[DDIR_WRITE] != o->min_bs[DDIR_WRITE] ||
554 o->ba[DDIR_TRIM] != o->min_bs[DDIR_TRIM]) &&
555 !o->norandommap) {
556 log_err("fio: Any use of blockalign= turns off randommap\n");
557 o->norandommap = 1;
558 ret = warnings_fatal;
559 }
560
561 if (!o->file_size_high)
562 o->file_size_high = o->file_size_low;
563
564 if (o->start_delay_high)
565 o->start_delay = get_rand_start_delay(td);
566
567 if (o->norandommap && o->verify != VERIFY_NONE
568 && !fixed_block_size(o)) {
569 log_err("fio: norandommap given for variable block sizes, "
570 "verify disabled\n");
571 o->verify = VERIFY_NONE;
572 ret = warnings_fatal;
573 }
574 if (o->bs_unaligned && (o->odirect || td->io_ops->flags & FIO_RAWIO))
575 log_err("fio: bs_unaligned may not work with raw io\n");
576
577 /*
578 * thinktime_spin must be less than thinktime
579 */
580 if (o->thinktime_spin > o->thinktime)
581 o->thinktime_spin = o->thinktime;
582
583 /*
584 * The low water mark cannot be bigger than the iodepth
585 */
586 if (o->iodepth_low > o->iodepth || !o->iodepth_low)
587 o->iodepth_low = o->iodepth;
588
589 /*
590 * If batch number isn't set, default to the same as iodepth
591 */
592 if (o->iodepth_batch > o->iodepth || !o->iodepth_batch)
593 o->iodepth_batch = o->iodepth;
594
595 if (o->nr_files > td->files_index)
596 o->nr_files = td->files_index;
597
598 if (o->open_files > o->nr_files || !o->open_files)
599 o->open_files = o->nr_files;
600
601 if (((o->rate[DDIR_READ] + o->rate[DDIR_WRITE] + o->rate[DDIR_TRIM]) &&
602 (o->rate_iops[DDIR_READ] + o->rate_iops[DDIR_WRITE] + o->rate_iops[DDIR_TRIM])) ||
603 ((o->ratemin[DDIR_READ] + o->ratemin[DDIR_WRITE] + o->ratemin[DDIR_TRIM]) &&
604 (o->rate_iops_min[DDIR_READ] + o->rate_iops_min[DDIR_WRITE] + o->rate_iops_min[DDIR_TRIM]))) {
605 log_err("fio: rate and rate_iops are mutually exclusive\n");
606 ret = 1;
607 }
608 if ((o->rate[DDIR_READ] < o->ratemin[DDIR_READ]) ||
609 (o->rate[DDIR_WRITE] < o->ratemin[DDIR_WRITE]) ||
610 (o->rate[DDIR_TRIM] < o->ratemin[DDIR_TRIM]) ||
611 (o->rate_iops[DDIR_READ] < o->rate_iops_min[DDIR_READ]) ||
612 (o->rate_iops[DDIR_WRITE] < o->rate_iops_min[DDIR_WRITE]) ||
613 (o->rate_iops[DDIR_TRIM] < o->rate_iops_min[DDIR_TRIM])) {
614 log_err("fio: minimum rate exceeds rate\n");
615 ret = 1;
616 }
617
618 if (!o->timeout && o->time_based) {
619 log_err("fio: time_based requires a runtime/timeout setting\n");
620 o->time_based = 0;
621 ret = warnings_fatal;
622 }
623
624 if (o->fill_device && !o->size)
625 o->size = -1ULL;
626
627 if (o->verify != VERIFY_NONE) {
628 if (td_write(td) && o->do_verify && o->numjobs > 1) {
629 log_info("Multiple writers may overwrite blocks that "
630 "belong to other jobs. This can cause "
631 "verification failures.\n");
632 ret = warnings_fatal;
633 }
634
635 o->refill_buffers = 1;
636 if (o->max_bs[DDIR_WRITE] != o->min_bs[DDIR_WRITE] &&
637 !o->verify_interval)
638 o->verify_interval = o->min_bs[DDIR_WRITE];
639
640 /*
641 * Verify interval must be smaller or equal to the
642 * write size.
643 */
644 if (o->verify_interval > o->min_bs[DDIR_WRITE])
645 o->verify_interval = o->min_bs[DDIR_WRITE];
646 else if (td_read(td) && o->verify_interval > o->min_bs[DDIR_READ])
647 o->verify_interval = o->min_bs[DDIR_READ];
648 }
649
650 if (o->pre_read) {
651 o->invalidate_cache = 0;
652 if (td->io_ops->flags & FIO_PIPEIO) {
653 log_info("fio: cannot pre-read files with an IO engine"
654 " that isn't seekable. Pre-read disabled.\n");
655 ret = warnings_fatal;
656 }
657 }
658
659 if (!o->unit_base) {
660 if (td->io_ops->flags & FIO_BIT_BASED)
661 o->unit_base = 1;
662 else
663 o->unit_base = 8;
664 }
665
666#ifndef CONFIG_FDATASYNC
667 if (o->fdatasync_blocks) {
668 log_info("fio: this platform does not support fdatasync()"
669 " falling back to using fsync(). Use the 'fsync'"
670 " option instead of 'fdatasync' to get rid of"
671 " this warning\n");
672 o->fsync_blocks = o->fdatasync_blocks;
673 o->fdatasync_blocks = 0;
674 ret = warnings_fatal;
675 }
676#endif
677
678#ifdef WIN32
679 /*
680 * Windows doesn't support O_DIRECT or O_SYNC with the _open interface,
681 * so fail if we're passed those flags
682 */
683 if ((td->io_ops->flags & FIO_SYNCIO) && (td->o.odirect || td->o.sync_io)) {
684 log_err("fio: Windows does not support direct or non-buffered io with"
685 " the synchronous ioengines. Use the 'windowsaio' ioengine"
686 " with 'direct=1' and 'iodepth=1' instead.\n");
687 ret = 1;
688 }
689#endif
690
691 /*
692 * For fully compressible data, just zero them at init time.
693 * It's faster than repeatedly filling it.
694 */
695 if (td->o.compress_percentage == 100) {
696 td->o.zero_buffers = 1;
697 td->o.compress_percentage = 0;
698 }
699
700 /*
701 * Using a non-uniform random distribution excludes usage of
702 * a random map
703 */
704 if (td->o.random_distribution != FIO_RAND_DIST_RANDOM)
705 td->o.norandommap = 1;
706
707 /*
708 * If size is set but less than the min block size, complain
709 */
710 if (o->size && o->size < td_min_bs(td)) {
711 log_err("fio: size too small, must be larger than the IO size: %llu\n", (unsigned long long) o->size);
712 ret = 1;
713 }
714
715 /*
716 * O_ATOMIC implies O_DIRECT
717 */
718 if (td->o.oatomic)
719 td->o.odirect = 1;
720
721 /*
722 * If randseed is set, that overrides randrepeat
723 */
724 if (td->o.rand_seed)
725 td->o.rand_repeatable = 0;
726
727 if ((td->io_ops->flags & FIO_NOEXTEND) && td->o.file_append) {
728 log_err("fio: can't append/extent with IO engine %s\n", td->io_ops->name);
729 ret = 1;
730 }
731
732 return ret;
733}
734
735/*
736 * This function leaks the buffer
737 */
738char *fio_uint_to_kmg(unsigned int val)
739{
740 char *buf = malloc(32);
741 char post[] = { 0, 'K', 'M', 'G', 'P', 'E', 0 };
742 char *p = post;
743
744 do {
745 if (val & 1023)
746 break;
747
748 val >>= 10;
749 p++;
750 } while (*p);
751
752 snprintf(buf, 32, "%u%c", val, *p);
753 return buf;
754}
755
756/* External engines are specified by "external:name.o") */
757static const char *get_engine_name(const char *str)
758{
759 char *p = strstr(str, ":");
760
761 if (!p)
762 return str;
763
764 p++;
765 strip_blank_front(&p);
766 strip_blank_end(p);
767 return p;
768}
769
770static int exists_and_not_file(const char *filename)
771{
772 struct stat sb;
773
774 if (lstat(filename, &sb) == -1)
775 return 0;
776
777 /* \\.\ is the device namespace in Windows, where every file
778 * is a device node */
779 if (S_ISREG(sb.st_mode) && strncmp(filename, "\\\\.\\", 4) != 0)
780 return 0;
781
782 return 1;
783}
784
785static void td_fill_rand_seeds_internal(struct thread_data *td)
786{
787 init_rand_seed(&td->bsrange_state, td->rand_seeds[FIO_RAND_BS_OFF]);
788 init_rand_seed(&td->verify_state, td->rand_seeds[FIO_RAND_VER_OFF]);
789 init_rand_seed(&td->rwmix_state, td->rand_seeds[FIO_RAND_MIX_OFF]);
790
791 if (td->o.file_service_type == FIO_FSERVICE_RANDOM)
792 init_rand_seed(&td->next_file_state, td->rand_seeds[FIO_RAND_FILE_OFF]);
793
794 init_rand_seed(&td->file_size_state, td->rand_seeds[FIO_RAND_FILE_SIZE_OFF]);
795 init_rand_seed(&td->trim_state, td->rand_seeds[FIO_RAND_TRIM_OFF]);
796 init_rand_seed(&td->delay_state, td->rand_seeds[FIO_RAND_START_DELAY]);
797
798 if (!td_random(td))
799 return;
800
801 if (td->o.rand_repeatable)
802 td->rand_seeds[FIO_RAND_BLOCK_OFF] = FIO_RANDSEED * td->thread_number;
803
804 init_rand_seed(&td->random_state, td->rand_seeds[FIO_RAND_BLOCK_OFF]);
805 init_rand_seed(&td->seq_rand_state[DDIR_READ], td->rand_seeds[FIO_RAND_SEQ_RAND_READ_OFF]);
806 init_rand_seed(&td->seq_rand_state[DDIR_WRITE], td->rand_seeds[FIO_RAND_SEQ_RAND_WRITE_OFF]);
807 init_rand_seed(&td->seq_rand_state[DDIR_TRIM], td->rand_seeds[FIO_RAND_SEQ_RAND_TRIM_OFF]);
808}
809
810void td_fill_rand_seeds(struct thread_data *td)
811{
812 if (td->o.allrand_repeatable) {
813 unsigned int i;
814
815 for (i = 0; i < FIO_RAND_NR_OFFS; i++)
816 td->rand_seeds[i] = FIO_RANDSEED * td->thread_number
817 + i;
818 }
819
820 td_fill_rand_seeds_internal(td);
821
822 init_rand_seed(&td->buf_state, td->rand_seeds[FIO_RAND_BUF_OFF]);
823 frand_copy(&td->buf_state_prev, &td->buf_state);
824
825 init_rand_seed(&td->dedupe_state, td->rand_seeds[FIO_DEDUPE_OFF]);
826}
827
828/*
829 * Initializes the ioengine configured for a job, if it has not been done so
830 * already.
831 */
832int ioengine_load(struct thread_data *td)
833{
834 const char *engine;
835
836 /*
837 * Engine has already been loaded.
838 */
839 if (td->io_ops)
840 return 0;
841 if (!td->o.ioengine) {
842 log_err("fio: internal fault, no IO engine specified\n");
843 return 1;
844 }
845
846 engine = get_engine_name(td->o.ioengine);
847 td->io_ops = load_ioengine(td, engine);
848 if (!td->io_ops) {
849 log_err("fio: failed to load engine %s\n", engine);
850 return 1;
851 }
852
853 if (td->io_ops->option_struct_size && td->io_ops->options) {
854 /*
855 * In cases where td->eo is set, clone it for a child thread.
856 * This requires that the parent thread has the same ioengine,
857 * but that requirement must be enforced by the code which
858 * cloned the thread.
859 */
860 void *origeo = td->eo;
861 /*
862 * Otherwise use the default thread options.
863 */
864 if (!origeo && td != &def_thread && def_thread.eo &&
865 def_thread.io_ops->options == td->io_ops->options)
866 origeo = def_thread.eo;
867
868 options_init(td->io_ops->options);
869 td->eo = malloc(td->io_ops->option_struct_size);
870 /*
871 * Use the default thread as an option template if this uses the
872 * same options structure and there are non-default options
873 * used.
874 */
875 if (origeo) {
876 memcpy(td->eo, origeo, td->io_ops->option_struct_size);
877 options_mem_dupe(td->eo, td->io_ops->options);
878 } else {
879 memset(td->eo, 0, td->io_ops->option_struct_size);
880 fill_default_options(td->eo, td->io_ops->options);
881 }
882 *(struct thread_data **)td->eo = td;
883 }
884
885 return 0;
886}
887
888static void init_flags(struct thread_data *td)
889{
890 struct thread_options *o = &td->o;
891
892 if (o->verify_backlog)
893 td->flags |= TD_F_VER_BACKLOG;
894 if (o->trim_backlog)
895 td->flags |= TD_F_TRIM_BACKLOG;
896 if (o->read_iolog_file)
897 td->flags |= TD_F_READ_IOLOG;
898 if (o->refill_buffers)
899 td->flags |= TD_F_REFILL_BUFFERS;
900 if (o->scramble_buffers)
901 td->flags |= TD_F_SCRAMBLE_BUFFERS;
902 if (o->verify != VERIFY_NONE)
903 td->flags |= TD_F_VER_NONE;
904}
905
906static int setup_random_seeds(struct thread_data *td)
907{
908 unsigned long seed;
909 unsigned int i;
910
911 if (!td->o.rand_repeatable && !td->o.rand_seed)
912 return init_random_state(td, td->rand_seeds, sizeof(td->rand_seeds));
913
914 if (!td->o.rand_seed)
915 seed = 0x89;
916 else
917 seed = td->o.rand_seed;
918
919 for (i = 0; i < 4; i++)
920 seed *= 0x9e370001UL;
921
922 for (i = 0; i < FIO_RAND_NR_OFFS; i++) {
923 td->rand_seeds[i] = seed;
924 seed *= 0x9e370001UL;
925 }
926
927 td_fill_rand_seeds(td);
928 return 0;
929}
930
931enum {
932 FPRE_NONE = 0,
933 FPRE_JOBNAME,
934 FPRE_JOBNUM,
935 FPRE_FILENUM
936};
937
938static struct fpre_keyword {
939 const char *keyword;
940 size_t strlen;
941 int key;
942} fpre_keywords[] = {
943 { .keyword = "$jobname", .key = FPRE_JOBNAME, },
944 { .keyword = "$jobnum", .key = FPRE_JOBNUM, },
945 { .keyword = "$filenum", .key = FPRE_FILENUM, },
946 { .keyword = NULL, },
947 };
948
949static char *make_filename(char *buf, size_t buf_size,struct thread_options *o,
950 const char *jobname, int jobnum, int filenum)
951{
952 struct fpre_keyword *f;
953 char copy[PATH_MAX];
954 size_t dst_left = PATH_MAX - 1;
955
956 if (!o->filename_format || !strlen(o->filename_format)) {
957 sprintf(buf, "%s.%d.%d", jobname, jobnum, filenum);
958 return NULL;
959 }
960
961 for (f = &fpre_keywords[0]; f->keyword; f++)
962 f->strlen = strlen(f->keyword);
963
964 buf[buf_size - 1] = '\0';
965 strncpy(buf, o->filename_format, buf_size - 1);
966
967 memset(copy, 0, sizeof(copy));
968 for (f = &fpre_keywords[0]; f->keyword; f++) {
969 do {
970 size_t pre_len, post_start = 0;
971 char *str, *dst = copy;
972
973 str = strcasestr(buf, f->keyword);
974 if (!str)
975 break;
976
977 pre_len = str - buf;
978 if (strlen(str) != f->strlen)
979 post_start = pre_len + f->strlen;
980
981 if (pre_len) {
982 strncpy(dst, buf, pre_len);
983 dst += pre_len;
984 dst_left -= pre_len;
985 }
986
987 switch (f->key) {
988 case FPRE_JOBNAME: {
989 int ret;
990
991 ret = snprintf(dst, dst_left, "%s", jobname);
992 if (ret < 0)
993 break;
994 dst += ret;
995 dst_left -= ret;
996 break;
997 }
998 case FPRE_JOBNUM: {
999 int ret;
1000
1001 ret = snprintf(dst, dst_left, "%d", jobnum);
1002 if (ret < 0)
1003 break;
1004 dst += ret;
1005 dst_left -= ret;
1006 break;
1007 }
1008 case FPRE_FILENUM: {
1009 int ret;
1010
1011 ret = snprintf(dst, dst_left, "%d", filenum);
1012 if (ret < 0)
1013 break;
1014 dst += ret;
1015 dst_left -= ret;
1016 break;
1017 }
1018 default:
1019 assert(0);
1020 break;
1021 }
1022
1023 if (post_start)
1024 strncpy(dst, buf + post_start, dst_left);
1025
1026 strncpy(buf, copy, buf_size - 1);
1027 } while (1);
1028 }
1029
1030 return buf;
1031}
1032
1033int parse_dryrun(void)
1034{
1035 return dump_cmdline || parse_only;
1036}
1037
1038/*
1039 * Adds a job to the list of things todo. Sanitizes the various options
1040 * to make sure we don't have conflicts, and initializes various
1041 * members of td.
1042 */
1043static int add_job(struct thread_data *td, const char *jobname, int job_add_num,
1044 int recursed, int client_type)
1045{
1046 unsigned int i;
1047 char fname[PATH_MAX];
1048 int numjobs, file_alloced;
1049 struct thread_options *o = &td->o;
1050 char logname[PATH_MAX + 32];
1051
1052 /*
1053 * the def_thread is just for options, it's not a real job
1054 */
1055 if (td == &def_thread)
1056 return 0;
1057
1058 init_flags(td);
1059
1060 /*
1061 * if we are just dumping the output command line, don't add the job
1062 */
1063 if (parse_dryrun()) {
1064 put_job(td);
1065 return 0;
1066 }
1067
1068 td->client_type = client_type;
1069
1070 if (profile_td_init(td))
1071 goto err;
1072
1073 if (ioengine_load(td))
1074 goto err;
1075
1076 if (o->odirect)
1077 td->io_ops->flags |= FIO_RAWIO;
1078
1079 file_alloced = 0;
1080 if (!o->filename && !td->files_index && !o->read_iolog_file) {
1081 file_alloced = 1;
1082
1083 if (o->nr_files == 1 && exists_and_not_file(jobname))
1084 add_file(td, jobname, job_add_num, 0);
1085 else {
1086 for (i = 0; i < o->nr_files; i++)
1087 add_file(td, make_filename(fname, sizeof(fname), o, jobname, job_add_num, i), job_add_num, 0);
1088 }
1089 }
1090
1091 if (fixup_options(td))
1092 goto err;
1093
1094 flow_init_job(td);
1095
1096 /*
1097 * IO engines only need this for option callbacks, and the address may
1098 * change in subprocesses.
1099 */
1100 if (td->eo)
1101 *(struct thread_data **)td->eo = NULL;
1102
1103 if (td->io_ops->flags & FIO_DISKLESSIO) {
1104 struct fio_file *f;
1105
1106 for_each_file(td, f, i)
1107 f->real_file_size = -1ULL;
1108 }
1109
1110 td->mutex = fio_mutex_init(FIO_MUTEX_LOCKED);
1111
1112 td->ts.clat_percentiles = o->clat_percentiles;
1113 td->ts.percentile_precision = o->percentile_precision;
1114 memcpy(td->ts.percentile_list, o->percentile_list, sizeof(o->percentile_list));
1115
1116 for (i = 0; i < DDIR_RWDIR_CNT; i++) {
1117 td->ts.clat_stat[i].min_val = ULONG_MAX;
1118 td->ts.slat_stat[i].min_val = ULONG_MAX;
1119 td->ts.lat_stat[i].min_val = ULONG_MAX;
1120 td->ts.bw_stat[i].min_val = ULONG_MAX;
1121 }
1122 td->ddir_seq_nr = o->ddir_seq_nr;
1123
1124 if ((o->stonewall || o->new_group) && prev_group_jobs) {
1125 prev_group_jobs = 0;
1126 groupid++;
1127 }
1128
1129 td->groupid = groupid;
1130 prev_group_jobs++;
1131
1132 if (setup_random_seeds(td)) {
1133 td_verror(td, errno, "init_random_state");
1134 goto err;
1135 }
1136
1137 if (setup_rate(td))
1138 goto err;
1139
1140 if (o->lat_log_file) {
1141 struct log_params p = {
1142 .td = td,
1143 .avg_msec = o->log_avg_msec,
1144 .log_type = IO_LOG_TYPE_LAT,
1145 .log_offset = o->log_offset,
1146 .log_gz = o->log_gz,
1147 .log_gz_store = o->log_gz_store,
1148 };
1149 const char *suf;
1150
1151 if (p.log_gz_store)
1152 suf = "log.fz";
1153 else
1154 suf = "log";
1155
1156 snprintf(logname, sizeof(logname), "%s_lat.%d.%s",
1157 o->lat_log_file, td->thread_number, suf);
1158 setup_log(&td->lat_log, &p, logname);
1159 snprintf(logname, sizeof(logname), "%s_slat.%d.%s",
1160 o->lat_log_file, td->thread_number, suf);
1161 setup_log(&td->slat_log, &p, logname);
1162 snprintf(logname, sizeof(logname), "%s_clat.%d.%s",
1163 o->lat_log_file, td->thread_number, suf);
1164 setup_log(&td->clat_log, &p, logname);
1165 }
1166 if (o->bw_log_file) {
1167 struct log_params p = {
1168 .td = td,
1169 .avg_msec = o->log_avg_msec,
1170 .log_type = IO_LOG_TYPE_BW,
1171 .log_offset = o->log_offset,
1172 .log_gz = o->log_gz,
1173 .log_gz_store = o->log_gz_store,
1174 };
1175 const char *suf;
1176
1177 if (p.log_gz_store)
1178 suf = "log.fz";
1179 else
1180 suf = "log";
1181
1182 snprintf(logname, sizeof(logname), "%s_bw.%d.%s",
1183 o->bw_log_file, td->thread_number, suf);
1184 setup_log(&td->bw_log, &p, logname);
1185 }
1186 if (o->iops_log_file) {
1187 struct log_params p = {
1188 .td = td,
1189 .avg_msec = o->log_avg_msec,
1190 .log_type = IO_LOG_TYPE_IOPS,
1191 .log_offset = o->log_offset,
1192 .log_gz = o->log_gz,
1193 .log_gz_store = o->log_gz_store,
1194 };
1195 const char *suf;
1196
1197 if (p.log_gz_store)
1198 suf = "log.fz";
1199 else
1200 suf = "log";
1201
1202 snprintf(logname, sizeof(logname), "%s_iops.%d.%s",
1203 o->iops_log_file, td->thread_number, suf);
1204 setup_log(&td->iops_log, &p, logname);
1205 }
1206
1207 if (!o->name)
1208 o->name = strdup(jobname);
1209
1210 if (output_format == FIO_OUTPUT_NORMAL) {
1211 if (!job_add_num) {
1212 if (is_backend && !recursed)
1213 fio_server_send_add_job(td);
1214
1215 if (!(td->io_ops->flags & FIO_NOIO)) {
1216 char *c1, *c2, *c3, *c4;
1217 char *c5 = NULL, *c6 = NULL;
1218
1219 c1 = fio_uint_to_kmg(o->min_bs[DDIR_READ]);
1220 c2 = fio_uint_to_kmg(o->max_bs[DDIR_READ]);
1221 c3 = fio_uint_to_kmg(o->min_bs[DDIR_WRITE]);
1222 c4 = fio_uint_to_kmg(o->max_bs[DDIR_WRITE]);
1223
1224 if (!o->bs_is_seq_rand) {
1225 c5 = fio_uint_to_kmg(o->min_bs[DDIR_TRIM]);
1226 c6 = fio_uint_to_kmg(o->max_bs[DDIR_TRIM]);
1227 }
1228
1229 log_info("%s: (g=%d): rw=%s, ", td->o.name,
1230 td->groupid,
1231 ddir_str(o->td_ddir));
1232
1233 if (o->bs_is_seq_rand)
1234 log_info("bs(seq/rand)=%s-%s/%s-%s, ",
1235 c1, c2, c3, c4);
1236 else
1237 log_info("bs=%s-%s/%s-%s/%s-%s, ",
1238 c1, c2, c3, c4, c5, c6);
1239
1240 log_info("ioengine=%s, iodepth=%u\n",
1241 td->io_ops->name, o->iodepth);
1242
1243 free(c1);
1244 free(c2);
1245 free(c3);
1246 free(c4);
1247 free(c5);
1248 free(c6);
1249 }
1250 } else if (job_add_num == 1)
1251 log_info("...\n");
1252 }
1253
1254 /*
1255 * recurse add identical jobs, clear numjobs and stonewall options
1256 * as they don't apply to sub-jobs
1257 */
1258 numjobs = o->numjobs;
1259 while (--numjobs) {
1260 struct thread_data *td_new = get_new_job(0, td, 1, jobname);
1261
1262 if (!td_new)
1263 goto err;
1264
1265 td_new->o.numjobs = 1;
1266 td_new->o.stonewall = 0;
1267 td_new->o.new_group = 0;
1268 td_new->subjob_number = numjobs;
1269
1270 if (file_alloced) {
1271 if (td_new->files) {
1272 struct fio_file *f;
1273 for_each_file(td_new, f, i) {
1274 if (f->file_name)
1275 sfree(f->file_name);
1276 sfree(f);
1277 }
1278 free(td_new->files);
1279 td_new->files = NULL;
1280 }
1281 td_new->files_index = 0;
1282 td_new->files_size = 0;
1283 if (td_new->o.filename) {
1284 free(td_new->o.filename);
1285 td_new->o.filename = NULL;
1286 }
1287 }
1288
1289 if (add_job(td_new, jobname, numjobs, 1, client_type))
1290 goto err;
1291 }
1292
1293 return 0;
1294err:
1295 put_job(td);
1296 return -1;
1297}
1298
1299/*
1300 * Parse as if 'o' was a command line
1301 */
1302void add_job_opts(const char **o, int client_type)
1303{
1304 struct thread_data *td, *td_parent;
1305 int i, in_global = 1;
1306 char jobname[32];
1307
1308 i = 0;
1309 td_parent = td = NULL;
1310 while (o[i]) {
1311 if (!strncmp(o[i], "name", 4)) {
1312 in_global = 0;
1313 if (td)
1314 add_job(td, jobname, 0, 0, client_type);
1315 td = NULL;
1316 sprintf(jobname, "%s", o[i] + 5);
1317 }
1318 if (in_global && !td_parent)
1319 td_parent = get_new_job(1, &def_thread, 0, jobname);
1320 else if (!in_global && !td) {
1321 if (!td_parent)
1322 td_parent = &def_thread;
1323 td = get_new_job(0, td_parent, 0, jobname);
1324 }
1325 if (in_global)
1326 fio_options_parse(td_parent, (char **) &o[i], 1, 0);
1327 else
1328 fio_options_parse(td, (char **) &o[i], 1, 0);
1329 i++;
1330 }
1331
1332 if (td)
1333 add_job(td, jobname, 0, 0, client_type);
1334}
1335
1336static int skip_this_section(const char *name)
1337{
1338 int i;
1339
1340 if (!nr_job_sections)
1341 return 0;
1342 if (!strncmp(name, "global", 6))
1343 return 0;
1344
1345 for (i = 0; i < nr_job_sections; i++)
1346 if (!strcmp(job_sections[i], name))
1347 return 0;
1348
1349 return 1;
1350}
1351
1352static int is_empty_or_comment(char *line)
1353{
1354 unsigned int i;
1355
1356 for (i = 0; i < strlen(line); i++) {
1357 if (line[i] == ';')
1358 return 1;
1359 if (line[i] == '#')
1360 return 1;
1361 if (!isspace((int) line[i]) && !iscntrl((int) line[i]))
1362 return 0;
1363 }
1364
1365 return 1;
1366}
1367
1368/*
1369 * This is our [ini] type file parser.
1370 */
1371int __parse_jobs_ini(struct thread_data *td,
1372 char *file, int is_buf, int stonewall_flag, int type,
1373 int nested, char *name, char ***popts, int *aopts, int *nopts)
1374{
1375 unsigned int global = 0;
1376 char *string;
1377 FILE *f;
1378 char *p;
1379 int ret = 0, stonewall;
1380 int first_sect = 1;
1381 int skip_fgets = 0;
1382 int inside_skip = 0;
1383 char **opts;
1384 int i, alloc_opts, num_opts;
1385
1386 dprint(FD_PARSE, "Parsing ini file %s\n", file);
1387 assert(td || !nested);
1388
1389 if (is_buf)
1390 f = NULL;
1391 else {
1392 if (!strcmp(file, "-"))
1393 f = stdin;
1394 else
1395 f = fopen(file, "r");
1396
1397 if (!f) {
1398 int __err = errno;
1399
1400 log_err("fio: unable to open '%s' job file\n", file);
1401 if (td)
1402 td_verror(td, __err, "job file open");
1403 return 1;
1404 }
1405 }
1406
1407 string = malloc(4096);
1408
1409 /*
1410 * it's really 256 + small bit, 280 should suffice
1411 */
1412 if (!nested) {
1413 name = malloc(280);
1414 memset(name, 0, 280);
1415 }
1416
1417 opts = NULL;
1418 if (nested && popts) {
1419 opts = *popts;
1420 alloc_opts = *aopts;
1421 num_opts = *nopts;
1422 }
1423
1424 if (!opts) {
1425 alloc_opts = 8;
1426 opts = malloc(sizeof(char *) * alloc_opts);
1427 num_opts = 0;
1428 }
1429
1430 stonewall = stonewall_flag;
1431 do {
1432 /*
1433 * if skip_fgets is set, we already have loaded a line we
1434 * haven't handled.
1435 */
1436 if (!skip_fgets) {
1437 if (is_buf)
1438 p = strsep(&file, "\n");
1439 else
1440 p = fgets(string, 4096, f);
1441 if (!p)
1442 break;
1443 }
1444
1445 skip_fgets = 0;
1446 strip_blank_front(&p);
1447 strip_blank_end(p);
1448
1449 dprint(FD_PARSE, "%s\n", p);
1450 if (is_empty_or_comment(p))
1451 continue;
1452
1453 if (!nested) {
1454 if (sscanf(p, "[%255[^\n]]", name) != 1) {
1455 if (inside_skip)
1456 continue;
1457
1458 log_err("fio: option <%s> outside of "
1459 "[] job section\n", p);
1460 ret = 1;
1461 break;
1462 }
1463
1464 name[strlen(name) - 1] = '\0';
1465
1466 if (skip_this_section(name)) {
1467 inside_skip = 1;
1468 continue;
1469 } else
1470 inside_skip = 0;
1471
1472 dprint(FD_PARSE, "Parsing section [%s]\n", name);
1473
1474 global = !strncmp(name, "global", 6);
1475
1476 if (dump_cmdline) {
1477 if (first_sect)
1478 log_info("fio ");
1479 if (!global)
1480 log_info("--name=%s ", name);
1481 first_sect = 0;
1482 }
1483
1484 td = get_new_job(global, &def_thread, 0, name);
1485 if (!td) {
1486 ret = 1;
1487 break;
1488 }
1489
1490 /*
1491 * Separate multiple job files by a stonewall
1492 */
1493 if (!global && stonewall) {
1494 td->o.stonewall = stonewall;
1495 stonewall = 0;
1496 }
1497
1498 num_opts = 0;
1499 memset(opts, 0, alloc_opts * sizeof(char *));
1500 }
1501 else
1502 skip_fgets = 1;
1503
1504 while (1) {
1505 if (!skip_fgets) {
1506 if (is_buf)
1507 p = strsep(&file, "\n");
1508 else
1509 p = fgets(string, 4096, f);
1510 if (!p)
1511 break;
1512 dprint(FD_PARSE, "%s", p);
1513 }
1514 else
1515 skip_fgets = 0;
1516
1517 if (is_empty_or_comment(p))
1518 continue;
1519
1520 strip_blank_front(&p);
1521
1522 /*
1523 * new section, break out and make sure we don't
1524 * fgets() a new line at the top.
1525 */
1526 if (p[0] == '[') {
1527 if (nested) {
1528 log_err("No new sections in included files\n");
1529 return 1;
1530 }
1531
1532 skip_fgets = 1;
1533 break;
1534 }
1535
1536 strip_blank_end(p);
1537
1538 if (!strncmp(p, "include", strlen("include"))) {
1539 char *filename = p + strlen("include") + 1;
1540
1541 if ((ret = __parse_jobs_ini(td, filename,
1542 is_buf, stonewall_flag, type, 1,
1543 name, &opts, &alloc_opts, &num_opts))) {
1544 log_err("Error %d while parsing include file %s\n",
1545 ret, filename);
1546 break;
1547 }
1548 continue;
1549 }
1550
1551 if (num_opts == alloc_opts) {
1552 alloc_opts <<= 1;
1553 opts = realloc(opts,
1554 alloc_opts * sizeof(char *));
1555 }
1556
1557 opts[num_opts] = strdup(p);
1558 num_opts++;
1559 }
1560
1561 if (nested) {
1562 *popts = opts;
1563 *aopts = alloc_opts;
1564 *nopts = num_opts;
1565 goto out;
1566 }
1567
1568 ret = fio_options_parse(td, opts, num_opts, dump_cmdline);
1569 if (!ret)
1570 ret = add_job(td, name, 0, 0, type);
1571 else {
1572 log_err("fio: job %s dropped\n", name);
1573 put_job(td);
1574 }
1575
1576 for (i = 0; i < num_opts; i++)
1577 free(opts[i]);
1578 num_opts = 0;
1579 } while (!ret);
1580
1581 if (dump_cmdline)
1582 log_info("\n");
1583
1584 i = 0;
1585 while (i < nr_job_sections) {
1586 free(job_sections[i]);
1587 i++;
1588 }
1589
1590 free(opts);
1591out:
1592 free(string);
1593 if (!nested)
1594 free(name);
1595 if (!is_buf && f != stdin)
1596 fclose(f);
1597 return ret;
1598}
1599
1600int parse_jobs_ini(char *file, int is_buf, int stonewall_flag, int type)
1601{
1602 return __parse_jobs_ini(NULL, file, is_buf, stonewall_flag, type,
1603 0, NULL, NULL, NULL, NULL);
1604}
1605
1606static int fill_def_thread(void)
1607{
1608 memset(&def_thread, 0, sizeof(def_thread));
1609
1610 fio_getaffinity(getpid(), &def_thread.o.cpumask);
1611 def_thread.o.error_dump = 1;
1612
1613 /*
1614 * fill default options
1615 */
1616 fio_fill_default_options(&def_thread);
1617 return 0;
1618}
1619
1620static void usage(const char *name)
1621{
1622 printf("%s\n", fio_version_string);
1623 printf("%s [options] [job options] <job file(s)>\n", name);
1624 printf(" --debug=options\tEnable debug logging. May be one/more of:\n"
1625 "\t\t\tprocess,file,io,mem,blktrace,verify,random,parse,\n"
1626 "\t\t\tdiskutil,job,mutex,profile,time,net,rate,compress\n");
1627 printf(" --parse-only\t\tParse options only, don't start any IO\n");
1628 printf(" --output\t\tWrite output to file\n");
1629 printf(" --runtime\t\tRuntime in seconds\n");
1630 printf(" --bandwidth-log\tGenerate per-job bandwidth logs\n");
1631 printf(" --minimal\t\tMinimal (terse) output\n");
1632 printf(" --output-format=x\tOutput format (terse,json,normal)\n");
1633 printf(" --terse-version=x\tSet terse version output format to 'x'\n");
1634 printf(" --version\t\tPrint version info and exit\n");
1635 printf(" --help\t\tPrint this page\n");
1636 printf(" --cpuclock-test\tPerform test/validation of CPU clock\n");
1637 printf(" --crctest\t\tTest speed of checksum functions\n");
1638 printf(" --cmdhelp=cmd\t\tPrint command help, \"all\" for all of"
1639 " them\n");
1640 printf(" --enghelp=engine\tPrint ioengine help, or list"
1641 " available ioengines\n");
1642 printf(" --enghelp=engine,cmd\tPrint help for an ioengine"
1643 " cmd\n");
1644 printf(" --showcmd\t\tTurn a job file into command line options\n");
1645 printf(" --eta=when\t\tWhen ETA estimate should be printed\n");
1646 printf(" \t\tMay be \"always\", \"never\" or \"auto\"\n");
1647 printf(" --eta-newline=time\tForce a new line for every 'time'");
1648 printf(" period passed\n");
1649 printf(" --status-interval=t\tForce full status dump every");
1650 printf(" 't' period passed\n");
1651 printf(" --readonly\t\tTurn on safety read-only checks, preventing"
1652 " writes\n");
1653 printf(" --section=name\tOnly run specified section in job file\n");
1654 printf(" --alloc-size=kb\tSet smalloc pool to this size in kb"
1655 " (def 1024)\n");
1656 printf(" --warnings-fatal\tFio parser warnings are fatal\n");
1657 printf(" --max-jobs=nr\t\tMaximum number of threads/processes to support\n");
1658 printf(" --server=args\t\tStart a backend fio server\n");
1659 printf(" --daemonize=pidfile\tBackground fio server, write pid to file\n");
1660 printf(" --client=hostname\tTalk to remote backend fio server at hostname\n");
1661 printf(" --remote-config=file\tTell fio server to load this local job file\n");
1662 printf(" --idle-prof=option\tReport cpu idleness on a system or percpu basis\n"
1663 "\t\t\t(option=system,percpu) or run unit work\n"
1664 "\t\t\tcalibration only (option=calibrate)\n");
1665#ifdef CONFIG_ZLIB
1666 printf(" --inflate-log=log\tInflate and output compressed log\n");
1667#endif
1668 printf("\nFio was written by Jens Axboe <jens.axboe@oracle.com>");
1669 printf("\n Jens Axboe <jaxboe@fusionio.com>");
1670 printf("\n Jens Axboe <axboe@fb.com>\n");
1671}
1672
1673#ifdef FIO_INC_DEBUG
1674struct debug_level debug_levels[] = {
1675 { .name = "process",
1676 .help = "Process creation/exit logging",
1677 .shift = FD_PROCESS,
1678 },
1679 { .name = "file",
1680 .help = "File related action logging",
1681 .shift = FD_FILE,
1682 },
1683 { .name = "io",
1684 .help = "IO and IO engine action logging (offsets, queue, completions, etc)",
1685 .shift = FD_IO,
1686 },
1687 { .name = "mem",
1688 .help = "Memory allocation/freeing logging",
1689 .shift = FD_MEM,
1690 },
1691 { .name = "blktrace",
1692 .help = "blktrace action logging",
1693 .shift = FD_BLKTRACE,
1694 },
1695 { .name = "verify",
1696 .help = "IO verification action logging",
1697 .shift = FD_VERIFY,
1698 },
1699 { .name = "random",
1700 .help = "Random generation logging",
1701 .shift = FD_RANDOM,
1702 },
1703 { .name = "parse",
1704 .help = "Parser logging",
1705 .shift = FD_PARSE,
1706 },
1707 { .name = "diskutil",
1708 .help = "Disk utility logging actions",
1709 .shift = FD_DISKUTIL,
1710 },
1711 { .name = "job",
1712 .help = "Logging related to creating/destroying jobs",
1713 .shift = FD_JOB,
1714 },
1715 { .name = "mutex",
1716 .help = "Mutex logging",
1717 .shift = FD_MUTEX
1718 },
1719 { .name = "profile",
1720 .help = "Logging related to profiles",
1721 .shift = FD_PROFILE,
1722 },
1723 { .name = "time",
1724 .help = "Logging related to time keeping functions",
1725 .shift = FD_TIME,
1726 },
1727 { .name = "net",
1728 .help = "Network logging",
1729 .shift = FD_NET,
1730 },
1731 { .name = "rate",
1732 .help = "Rate logging",
1733 .shift = FD_RATE,
1734 },
1735 { .name = "compress",
1736 .help = "Log compression logging",
1737 .shift = FD_COMPRESS,
1738 },
1739 { .name = NULL, },
1740};
1741
1742static int set_debug(const char *string)
1743{
1744 struct debug_level *dl;
1745 char *p = (char *) string;
1746 char *opt;
1747 int i;
1748
1749 if (!strcmp(string, "?") || !strcmp(string, "help")) {
1750 log_info("fio: dumping debug options:");
1751 for (i = 0; debug_levels[i].name; i++) {
1752 dl = &debug_levels[i];
1753 log_info("%s,", dl->name);
1754 }
1755 log_info("all\n");
1756 return 1;
1757 }
1758
1759 while ((opt = strsep(&p, ",")) != NULL) {
1760 int found = 0;
1761
1762 if (!strncmp(opt, "all", 3)) {
1763 log_info("fio: set all debug options\n");
1764 fio_debug = ~0UL;
1765 continue;
1766 }
1767
1768 for (i = 0; debug_levels[i].name; i++) {
1769 dl = &debug_levels[i];
1770 found = !strncmp(opt, dl->name, strlen(dl->name));
1771 if (!found)
1772 continue;
1773
1774 if (dl->shift == FD_JOB) {
1775 opt = strchr(opt, ':');
1776 if (!opt) {
1777 log_err("fio: missing job number\n");
1778 break;
1779 }
1780 opt++;
1781 fio_debug_jobno = atoi(opt);
1782 log_info("fio: set debug jobno %d\n",
1783 fio_debug_jobno);
1784 } else {
1785 log_info("fio: set debug option %s\n", opt);
1786 fio_debug |= (1UL << dl->shift);
1787 }
1788 break;
1789 }
1790
1791 if (!found)
1792 log_err("fio: debug mask %s not found\n", opt);
1793 }
1794 return 0;
1795}
1796#else
1797static int set_debug(const char *string)
1798{
1799 log_err("fio: debug tracing not included in build\n");
1800 return 1;
1801}
1802#endif
1803
1804static void fio_options_fill_optstring(void)
1805{
1806 char *ostr = cmd_optstr;
1807 int i, c;
1808
1809 c = i = 0;
1810 while (l_opts[i].name) {
1811 ostr[c++] = l_opts[i].val;
1812 if (l_opts[i].has_arg == required_argument)
1813 ostr[c++] = ':';
1814 else if (l_opts[i].has_arg == optional_argument) {
1815 ostr[c++] = ':';
1816 ostr[c++] = ':';
1817 }
1818 i++;
1819 }
1820 ostr[c] = '\0';
1821}
1822
1823static int client_flag_set(char c)
1824{
1825 int i;
1826
1827 i = 0;
1828 while (l_opts[i].name) {
1829 int val = l_opts[i].val;
1830
1831 if (c == (val & 0xff))
1832 return (val & FIO_CLIENT_FLAG);
1833
1834 i++;
1835 }
1836
1837 return 0;
1838}
1839
1840static void parse_cmd_client(void *client, char *opt)
1841{
1842 fio_client_add_cmd_option(client, opt);
1843}
1844
1845int parse_cmd_line(int argc, char *argv[], int client_type)
1846{
1847 struct thread_data *td = NULL;
1848 int c, ini_idx = 0, lidx, ret = 0, do_exit = 0, exit_val = 0;
1849 char *ostr = cmd_optstr;
1850 void *pid_file = NULL;
1851 void *cur_client = NULL;
1852 int backend = 0;
1853
1854 /*
1855 * Reset optind handling, since we may call this multiple times
1856 * for the backend.
1857 */
1858 optind = 1;
1859
1860 while ((c = getopt_long_only(argc, argv, ostr, l_opts, &lidx)) != -1) {
1861 if ((c & FIO_CLIENT_FLAG) || client_flag_set(c)) {
1862 parse_cmd_client(cur_client, argv[optind - 1]);
1863 c &= ~FIO_CLIENT_FLAG;
1864 }
1865
1866 switch (c) {
1867 case 'a':
1868 smalloc_pool_size = atoi(optarg);
1869 break;
1870 case 't':
1871 if (check_str_time(optarg, &def_timeout, 1)) {
1872 log_err("fio: failed parsing time %s\n", optarg);
1873 do_exit++;
1874 exit_val = 1;
1875 }
1876 break;
1877 case 'l':
1878 log_err("fio: --latency-log is deprecated. Use per-job latency log options.\n");
1879 do_exit++;
1880 exit_val = 1;
1881 break;
1882 case 'b':
1883 write_bw_log = 1;
1884 break;
1885 case 'o':
1886 if (f_out && f_out != stdout)
1887 fclose(f_out);
1888
1889 f_out = fopen(optarg, "w+");
1890 if (!f_out) {
1891 perror("fopen output");
1892 exit(1);
1893 }
1894 f_err = f_out;
1895 break;
1896 case 'm':
1897 output_format = FIO_OUTPUT_TERSE;
1898 break;
1899 case 'F':
1900 if (!optarg) {
1901 log_err("fio: missing --output-format argument\n");
1902 exit_val = 1;
1903 do_exit++;
1904 break;
1905 }
1906 if (!strcmp(optarg, "minimal") ||
1907 !strcmp(optarg, "terse") ||
1908 !strcmp(optarg, "csv"))
1909 output_format = FIO_OUTPUT_TERSE;
1910 else if (!strcmp(optarg, "json"))
1911 output_format = FIO_OUTPUT_JSON;
1912 else
1913 output_format = FIO_OUTPUT_NORMAL;
1914 break;
1915 case 'f':
1916 append_terse_output = 1;
1917 break;
1918 case 'h':
1919 did_arg = 1;
1920 if (!cur_client) {
1921 usage(argv[0]);
1922 do_exit++;
1923 }
1924 break;
1925 case 'c':
1926 did_arg = 1;
1927 if (!cur_client) {
1928 fio_show_option_help(optarg);
1929 do_exit++;
1930 }
1931 break;
1932 case 'i':
1933 did_arg = 1;
1934 if (!cur_client) {
1935 fio_show_ioengine_help(optarg);
1936 do_exit++;
1937 }
1938 break;
1939 case 's':
1940 did_arg = 1;
1941 dump_cmdline = 1;
1942 break;
1943 case 'r':
1944 read_only = 1;
1945 break;
1946 case 'v':
1947 did_arg = 1;
1948 if (!cur_client) {
1949 log_info("%s\n", fio_version_string);
1950 do_exit++;
1951 }
1952 break;
1953 case 'V':
1954 terse_version = atoi(optarg);
1955 if (!(terse_version == 2 || terse_version == 3 ||
1956 terse_version == 4)) {
1957 log_err("fio: bad terse version format\n");
1958 exit_val = 1;
1959 do_exit++;
1960 }
1961 break;
1962 case 'e':
1963 if (!strcmp("always", optarg))
1964 eta_print = FIO_ETA_ALWAYS;
1965 else if (!strcmp("never", optarg))
1966 eta_print = FIO_ETA_NEVER;
1967 break;
1968 case 'E': {
1969 long long t = 0;
1970
1971 if (check_str_time(optarg, &t, 1)) {
1972 log_err("fio: failed parsing eta time %s\n", optarg);
1973 exit_val = 1;
1974 do_exit++;
1975 }
1976 eta_new_line = t / 1000;
1977 break;
1978 }
1979 case 'd':
1980 if (set_debug(optarg))
1981 do_exit++;
1982 break;
1983 case 'P':
1984 did_arg = 1;
1985 parse_only = 1;
1986 break;
1987 case 'x': {
1988 size_t new_size;
1989
1990 if (!strcmp(optarg, "global")) {
1991 log_err("fio: can't use global as only "
1992 "section\n");
1993 do_exit++;
1994 exit_val = 1;
1995 break;
1996 }
1997 new_size = (nr_job_sections + 1) * sizeof(char *);
1998 job_sections = realloc(job_sections, new_size);
1999 job_sections[nr_job_sections] = strdup(optarg);
2000 nr_job_sections++;
2001 break;
2002 }
2003#ifdef CONFIG_ZLIB
2004 case 'X':
2005 exit_val = iolog_file_inflate(optarg);
2006 did_arg++;
2007 do_exit++;
2008 break;
2009#endif
2010 case 'p':
2011 did_arg = 1;
2012 if (exec_profile)
2013 free(exec_profile);
2014 exec_profile = strdup(optarg);
2015 break;
2016 case FIO_GETOPT_JOB: {
2017 const char *opt = l_opts[lidx].name;
2018 char *val = optarg;
2019
2020 if (!strncmp(opt, "name", 4) && td) {
2021 ret = add_job(td, td->o.name ?: "fio", 0, 0, client_type);
2022 if (ret)
2023 goto out_free;
2024 td = NULL;
2025 did_arg = 1;
2026 }
2027 if (!td) {
2028 int is_section = !strncmp(opt, "name", 4);
2029 int global = 0;
2030
2031 if (!is_section || !strncmp(val, "global", 6))
2032 global = 1;
2033
2034 if (is_section && skip_this_section(val))
2035 continue;
2036
2037 td = get_new_job(global, &def_thread, 1, NULL);
2038 if (!td || ioengine_load(td)) {
2039 if (td) {
2040 put_job(td);
2041 td = NULL;
2042 }
2043 do_exit++;
2044 break;
2045 }
2046 fio_options_set_ioengine_opts(l_opts, td);
2047 }
2048
2049 if ((!val || !strlen(val)) &&
2050 l_opts[lidx].has_arg == required_argument) {
2051 log_err("fio: option %s requires an argument\n", opt);
2052 ret = 1;
2053 } else
2054 ret = fio_cmd_option_parse(td, opt, val);
2055
2056 if (ret) {
2057 if (td) {
2058 put_job(td);
2059 td = NULL;
2060 }
2061 do_exit++;
2062 }
2063
2064 if (!ret && !strcmp(opt, "ioengine")) {
2065 free_ioengine(td);
2066 if (ioengine_load(td)) {
2067 put_job(td);
2068 td = NULL;
2069 do_exit++;
2070 break;
2071 }
2072 fio_options_set_ioengine_opts(l_opts, td);
2073 }
2074 break;
2075 }
2076 case FIO_GETOPT_IOENGINE: {
2077 const char *opt = l_opts[lidx].name;
2078 char *val = optarg;
2079
2080 if (!td)
2081 break;
2082
2083 ret = fio_cmd_ioengine_option_parse(td, opt, val);
2084 break;
2085 }
2086 case 'w':
2087 warnings_fatal = 1;
2088 break;
2089 case 'j':
2090 max_jobs = atoi(optarg);
2091 if (!max_jobs || max_jobs > REAL_MAX_JOBS) {
2092 log_err("fio: invalid max jobs: %d\n", max_jobs);
2093 do_exit++;
2094 exit_val = 1;
2095 }
2096 break;
2097 case 'S':
2098 did_arg = 1;
2099#ifndef CONFIG_NO_SHM
2100 if (nr_clients) {
2101 log_err("fio: can't be both client and server\n");
2102 do_exit++;
2103 exit_val = 1;
2104 break;
2105 }
2106 if (optarg)
2107 fio_server_set_arg(optarg);
2108 is_backend = 1;
2109 backend = 1;
2110#else
2111 log_err("fio: client/server requires SHM support\n");
2112 do_exit++;
2113 exit_val = 1;
2114#endif
2115 break;
2116 case 'D':
2117 if (pid_file)
2118 free(pid_file);
2119 pid_file = strdup(optarg);
2120 break;
2121 case 'I':
2122 if ((ret = fio_idle_prof_parse_opt(optarg))) {
2123 /* exit on error and calibration only */
2124 did_arg = 1;
2125 do_exit++;
2126 if (ret == -1)
2127 exit_val = 1;
2128 }
2129 break;
2130 case 'C':
2131 did_arg = 1;
2132 if (is_backend) {
2133 log_err("fio: can't be both client and server\n");
2134 do_exit++;
2135 exit_val = 1;
2136 break;
2137 }
2138 if (fio_client_add(&fio_client_ops, optarg, &cur_client)) {
2139 log_err("fio: failed adding client %s\n", optarg);
2140 do_exit++;
2141 exit_val = 1;
2142 break;
2143 }
2144 /*
2145 * If the next argument exists and isn't an option,
2146 * assume it's a job file for this client only.
2147 */
2148 while (optind < argc) {
2149 if (!strncmp(argv[optind], "--", 2) ||
2150 !strncmp(argv[optind], "-", 1))
2151 break;
2152
2153 if (fio_client_add_ini_file(cur_client, argv[optind], 0))
2154 break;
2155 optind++;
2156 }
2157 break;
2158 case 'R':
2159 did_arg = 1;
2160 if (fio_client_add_ini_file(cur_client, optarg, 1)) {
2161 do_exit++;
2162 exit_val = 1;
2163 }
2164 break;
2165 case 'T':
2166 did_arg = 1;
2167 do_exit++;
2168 exit_val = fio_monotonic_clocktest();
2169 break;
2170 case 'G':
2171 did_arg = 1;
2172 do_exit++;
2173 exit_val = fio_crctest(optarg);
2174 break;
2175 case 'L': {
2176 long long val;
2177
2178 if (check_str_time(optarg, &val, 1)) {
2179 log_err("fio: failed parsing time %s\n", optarg);
2180 do_exit++;
2181 exit_val = 1;
2182 break;
2183 }
2184 status_interval = val / 1000;
2185 break;
2186 }
2187 case '?':
2188 log_err("%s: unrecognized option '%s'\n", argv[0],
2189 argv[optind - 1]);
2190 default:
2191 do_exit++;
2192 exit_val = 1;
2193 break;
2194 }
2195 if (do_exit)
2196 break;
2197 }
2198
2199 if (do_exit && !(is_backend || nr_clients))
2200 exit(exit_val);
2201
2202 if (nr_clients && fio_clients_connect())
2203 exit(1);
2204
2205 if (is_backend && backend)
2206 return fio_start_server(pid_file);
2207 else if (pid_file)
2208 free(pid_file);
2209
2210 if (td) {
2211 if (!ret) {
2212 ret = add_job(td, td->o.name ?: "fio", 0, 0, client_type);
2213 if (ret)
2214 did_arg = 1;
2215 }
2216 }
2217
2218 while (!ret && optind < argc) {
2219 ini_idx++;
2220 ini_file = realloc(ini_file, ini_idx * sizeof(char *));
2221 ini_file[ini_idx - 1] = strdup(argv[optind]);
2222 optind++;
2223 }
2224
2225out_free:
2226 if (pid_file)
2227 free(pid_file);
2228
2229 return ini_idx;
2230}
2231
2232int fio_init_options(void)
2233{
2234 f_out = stdout;
2235 f_err = stderr;
2236
2237 fio_options_fill_optstring();
2238 fio_options_dup_and_init(l_opts);
2239
2240 atexit(free_shm);
2241
2242 if (fill_def_thread())
2243 return 1;
2244
2245 return 0;
2246}
2247
2248extern int fio_check_options(struct thread_options *);
2249
2250int parse_options(int argc, char *argv[])
2251{
2252 const int type = FIO_CLIENT_TYPE_CLI;
2253 int job_files, i;
2254
2255 if (fio_init_options())
2256 return 1;
2257 if (fio_test_cconv(&def_thread.o))
2258 log_err("fio: failed internal cconv test\n");
2259
2260 job_files = parse_cmd_line(argc, argv, type);
2261
2262 if (job_files > 0) {
2263 for (i = 0; i < job_files; i++) {
2264 if (i && fill_def_thread())
2265 return 1;
2266 if (nr_clients) {
2267 if (fio_clients_send_ini(ini_file[i]))
2268 return 1;
2269 free(ini_file[i]);
2270 } else if (!is_backend) {
2271 if (parse_jobs_ini(ini_file[i], 0, i, type))
2272 return 1;
2273 free(ini_file[i]);
2274 }
2275 }
2276 } else if (nr_clients) {
2277 if (fill_def_thread())
2278 return 1;
2279 if (fio_clients_send_ini(NULL))
2280 return 1;
2281 }
2282
2283 free(ini_file);
2284 fio_options_free(&def_thread);
2285 filesetup_mem_free();
2286
2287 if (!thread_number) {
2288 if (parse_dryrun())
2289 return 0;
2290 if (exec_profile)
2291 return 0;
2292 if (is_backend || nr_clients)
2293 return 0;
2294 if (did_arg)
2295 return 0;
2296
2297 log_err("No jobs(s) defined\n\n");
2298
2299 if (!did_arg) {
2300 usage(argv[0]);
2301 return 1;
2302 }
2303
2304 return 0;
2305 }
2306
2307 if (def_thread.o.gtod_offload) {
2308 fio_gtod_init();
2309 fio_gtod_offload = 1;
2310 fio_gtod_cpu = def_thread.o.gtod_cpu;
2311 }
2312
2313 if (output_format == FIO_OUTPUT_NORMAL)
2314 log_info("%s\n", fio_version_string);
2315
2316 return 0;
2317}
2318
2319void options_default_fill(struct thread_options *o)
2320{
2321 memcpy(o, &def_thread.o, sizeof(*o));
2322}
fio - Flexible IO Tester