Fix bad indexing of options
[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>
12#include <sys/shm.h>
13#include <sys/types.h>
14#include <sys/stat.h>
15
16#include "fio.h"
cb2c86fd 17#include "parse.h"
2e5cdb11 18#include "smalloc.h"
380065aa 19#include "filehash.h"
4f5af7b2 20#include "verify.h"
79d16311 21#include "profile.h"
50d16976 22#include "server.h"
ebac4655 23
bf2e821a
CC
24#include "lib/getopt.h"
25
81179eec
JA
26#if FIO_PATCH > 0
27static char fio_version_string[] = __fio_stringify(FIO_MAJOR) "." \
28 __fio_stringify(FIO_MINOR) "." \
29 __fio_stringify(FIO_PATCH);
30#else
31static char fio_version_string[] = __fio_stringify(FIO_MAJOR) "." \
32 __fio_stringify(FIO_MINOR);
33#endif
214e1eca 34
ee738499 35#define FIO_RANDSEED (0xb1899bedUL)
ebac4655 36
214e1eca 37static char **ini_file;
fca70358 38static int max_jobs = FIO_MAX_JOBS;
cca73aa7 39static int dump_cmdline;
e1f36503 40
be4ecfdf 41static struct thread_data def_thread;
214e1eca 42struct thread_data *threads = NULL;
e1f36503 43
214e1eca
JA
44int exitall_on_terminate = 0;
45int terse_output = 0;
e592a06b 46int eta_print;
214e1eca
JA
47unsigned long long mlock_size = 0;
48FILE *f_out = NULL;
49FILE *f_err = NULL;
ad0a2735
JA
50char **job_sections = NULL;
51int nr_job_sections = 0;
07b3232d 52char *exec_profile = NULL;
a9523c6f 53int warnings_fatal = 0;
f57a9c59 54int terse_version = 2;
50d16976 55int is_backend = 0;
a37f69b7 56int nr_clients = 0;
e46d8091 57int log_syslog = 0;
ee738499 58
214e1eca 59int write_bw_log = 0;
4241ea8f 60int read_only = 0;
214e1eca 61
5ec10eaa 62static int write_lat_log;
e1f36503 63
214e1eca 64static int prev_group_jobs;
b4692828 65
ee56ad50 66unsigned long fio_debug = 0;
5e1d306e
JA
67unsigned int fio_debug_jobno = -1;
68unsigned int *fio_debug_jobp = NULL;
ee56ad50 69
4c6107ff
JA
70static char cmd_optstr[256];
71
b4692828
JA
72/*
73 * Command line options. These will contain the above, plus a few
74 * extra that only pertain to fio itself and not jobs.
75 */
5ec10eaa 76static struct option l_opts[FIO_NR_OPTIONS] = {
b4692828 77 {
08d2a19c 78 .name = (char *) "output",
b4692828
JA
79 .has_arg = required_argument,
80 .val = 'o',
81 },
82 {
08d2a19c 83 .name = (char *) "timeout",
b4692828
JA
84 .has_arg = required_argument,
85 .val = 't',
86 },
87 {
08d2a19c 88 .name = (char *) "latency-log",
b4692828
JA
89 .has_arg = required_argument,
90 .val = 'l',
91 },
92 {
08d2a19c 93 .name = (char *) "bandwidth-log",
b4692828
JA
94 .has_arg = required_argument,
95 .val = 'b',
96 },
97 {
08d2a19c 98 .name = (char *) "minimal",
b4692828
JA
99 .has_arg = optional_argument,
100 .val = 'm',
101 },
102 {
08d2a19c 103 .name = (char *) "version",
b4692828
JA
104 .has_arg = no_argument,
105 .val = 'v',
106 },
fd28ca49 107 {
08d2a19c 108 .name = (char *) "help",
fd28ca49
JA
109 .has_arg = no_argument,
110 .val = 'h',
111 },
112 {
08d2a19c 113 .name = (char *) "cmdhelp",
320beefe 114 .has_arg = optional_argument,
fd28ca49
JA
115 .val = 'c',
116 },
cca73aa7 117 {
08d2a19c 118 .name = (char *) "showcmd",
cca73aa7 119 .has_arg = no_argument,
724e4435
JA
120 .val = 's',
121 },
122 {
08d2a19c 123 .name = (char *) "readonly",
724e4435
JA
124 .has_arg = no_argument,
125 .val = 'r',
cca73aa7 126 },
e592a06b 127 {
08d2a19c 128 .name = (char *) "eta",
e592a06b
AC
129 .has_arg = required_argument,
130 .val = 'e',
131 },
ee56ad50 132 {
08d2a19c 133 .name = (char *) "debug",
ee56ad50
JA
134 .has_arg = required_argument,
135 .val = 'd',
136 },
01f06b63 137 {
08d2a19c 138 .name = (char *) "section",
01f06b63
JA
139 .has_arg = required_argument,
140 .val = 'x',
141 },
2b386d25 142 {
08d2a19c 143 .name = (char *) "alloc-size",
2b386d25
JA
144 .has_arg = required_argument,
145 .val = 'a',
146 },
9ac8a797 147 {
08d2a19c 148 .name = (char *) "profile",
9ac8a797
JA
149 .has_arg = required_argument,
150 .val = 'p',
151 },
a9523c6f 152 {
08d2a19c 153 .name = (char *) "warnings-fatal",
a9523c6f
JA
154 .has_arg = no_argument,
155 .val = 'w',
156 },
fca70358
JA
157 {
158 .name = (char *) "max-jobs",
159 .has_arg = required_argument,
160 .val = 'j',
161 },
f57a9c59
JA
162 {
163 .name = (char *) "terse-version",
164 .has_arg = required_argument,
165 .val = 'V',
166 },
50d16976
JA
167 {
168 .name = (char *) "server",
169 .has_arg = no_argument,
170 .val = 'S',
171 },
e46d8091
JA
172 { .name = (char *) "daemonize",
173 .has_arg = no_argument,
174 .val = 'D',
175 },
132159a5
JA
176 {
177 .name = (char *) "net-port",
178 .has_arg = required_argument,
179 .val = 'P',
180 },
181 {
182 .name = (char *) "client",
183 .has_arg = required_argument,
184 .val = 'C',
185 },
b4692828
JA
186 {
187 .name = NULL,
188 },
189};
190
9d9eb2e7
JA
191static void free_shm(void)
192{
193 struct shmid_ds sbuf;
194
195 if (threads) {
196 void *tp = threads;
197
198 threads = NULL;
199 file_hash_exit();
200 fio_debug_jobp = NULL;
201 shmdt(tp);
202 shmctl(shm_id, IPC_RMID, &sbuf);
203 }
204
205 scleanup();
206}
207
208/*
209 * The thread area is shared between the main process and the job
210 * threads/processes. So setup a shared memory segment that will hold
211 * all the job info. We use the end of the region for keeping track of
212 * open files across jobs, for file sharing.
213 */
214static int setup_thread_area(void)
215{
216 void *hash;
217
218 if (threads)
219 return 0;
220
221 /*
222 * 1024 is too much on some machines, scale max_jobs if
223 * we get a failure that looks like too large a shm segment
224 */
225 do {
226 size_t size = max_jobs * sizeof(struct thread_data);
227
228 size += file_hash_size;
229 size += sizeof(unsigned int);
230
231 shm_id = shmget(0, size, IPC_CREAT | 0600);
232 if (shm_id != -1)
233 break;
234 if (errno != EINVAL) {
235 perror("shmget");
236 break;
237 }
238
239 max_jobs >>= 1;
240 } while (max_jobs);
241
242 if (shm_id == -1)
243 return 1;
244
245 threads = shmat(shm_id, NULL, 0);
246 if (threads == (void *) -1) {
247 perror("shmat");
248 return 1;
249 }
250
251 memset(threads, 0, max_jobs * sizeof(struct thread_data));
252 hash = (void *) threads + max_jobs * sizeof(struct thread_data);
253 fio_debug_jobp = (void *) hash + file_hash_size;
254 *fio_debug_jobp = -1;
255 file_hash_init(hash);
256 return 0;
257}
258
906c8d75
JA
259/*
260 * Return a free job structure.
261 */
ebac4655
JA
262static struct thread_data *get_new_job(int global, struct thread_data *parent)
263{
264 struct thread_data *td;
265
266 if (global)
267 return &def_thread;
9d9eb2e7
JA
268 if (setup_thread_area()) {
269 log_err("error: failed to setup shm segment\n");
270 return NULL;
271 }
e61f1ec8
BC
272 if (thread_number >= max_jobs) {
273 log_err("error: maximum number of jobs (%d) reached.\n",
274 max_jobs);
ebac4655 275 return NULL;
e61f1ec8 276 }
ebac4655
JA
277
278 td = &threads[thread_number++];
ddaeaa5a 279 *td = *parent;
ebac4655 280
e0b0d892
JA
281 td->o.uid = td->o.gid = -1U;
282
cade3ef4 283 dup_files(td, parent);
d23bb327 284 options_mem_dupe(td);
cade3ef4 285
15dc1934
JA
286 profile_add_hooks(td);
287
ebac4655 288 td->thread_number = thread_number;
ebac4655
JA
289 return td;
290}
291
292static void put_job(struct thread_data *td)
293{
549577a7
JA
294 if (td == &def_thread)
295 return;
84dd1886 296
58c55ba0 297 profile_td_exit(td);
549577a7 298
16edf25d 299 if (td->error)
6d86144d 300 log_info("fio: %s\n", td->verror);
16edf25d 301
ebac4655
JA
302 memset(&threads[td->thread_number - 1], 0, sizeof(*td));
303 thread_number--;
304}
305
581e7141 306static int __setup_rate(struct thread_data *td, enum fio_ddir ddir)
127f6865 307{
581e7141 308 unsigned int bs = td->o.min_bs[ddir];
ba3e4e0c 309 unsigned long long bytes_per_sec;
127f6865 310
ff58fced
JA
311 assert(ddir_rw(ddir));
312
ba3e4e0c
RR
313 if (td->o.rate[ddir])
314 bytes_per_sec = td->o.rate[ddir];
315 else
316 bytes_per_sec = td->o.rate_iops[ddir] * bs;
127f6865 317
ba3e4e0c 318 if (!bytes_per_sec) {
127f6865
JA
319 log_err("rate lower than supported\n");
320 return -1;
321 }
322
ba3e4e0c 323 td->rate_nsec_cycle[ddir] = 1000000000ULL / bytes_per_sec;
581e7141 324 td->rate_pending_usleep[ddir] = 0;
127f6865
JA
325 return 0;
326}
327
581e7141
JA
328static int setup_rate(struct thread_data *td)
329{
330 int ret = 0;
331
332 if (td->o.rate[DDIR_READ] || td->o.rate_iops[DDIR_READ])
333 ret = __setup_rate(td, DDIR_READ);
334 if (td->o.rate[DDIR_WRITE] || td->o.rate_iops[DDIR_WRITE])
335 ret |= __setup_rate(td, DDIR_WRITE);
336
337 return ret;
338}
339
8347239a
JA
340static int fixed_block_size(struct thread_options *o)
341{
342 return o->min_bs[DDIR_READ] == o->max_bs[DDIR_READ] &&
343 o->min_bs[DDIR_WRITE] == o->max_bs[DDIR_WRITE] &&
344 o->min_bs[DDIR_READ] == o->min_bs[DDIR_WRITE];
345}
346
dad915e3
JA
347/*
348 * Lazy way of fixing up options that depend on each other. We could also
349 * define option callback handlers, but this is easier.
350 */
4e991c23 351static int fixup_options(struct thread_data *td)
e1f36503 352{
2dc1bbeb 353 struct thread_options *o = &td->o;
ff217451 354 int ret = 0;
dad915e3 355
f356d01d 356#ifndef FIO_HAVE_PSHARED_MUTEX
9bbf57cc 357 if (!o->use_thread) {
f356d01d
JA
358 log_info("fio: this platform does not support process shared"
359 " mutexes, forcing use of threads. Use the 'thread'"
360 " option to get rid of this warning.\n");
9bbf57cc 361 o->use_thread = 1;
a9523c6f 362 ret = warnings_fatal;
f356d01d
JA
363 }
364#endif
365
2dc1bbeb 366 if (o->write_iolog_file && o->read_iolog_file) {
076efc7c 367 log_err("fio: read iolog overrides write_iolog\n");
2dc1bbeb
JA
368 free(o->write_iolog_file);
369 o->write_iolog_file = NULL;
a9523c6f 370 ret = warnings_fatal;
076efc7c 371 }
16b462ae 372
16b462ae
JA
373 /*
374 * only really works for sequential io for now, and with 1 file
375 */
2dc1bbeb
JA
376 if (o->zone_size && td_random(td) && o->open_files == 1)
377 o->zone_size = 0;
16b462ae
JA
378
379 /*
380 * Reads can do overwrites, we always need to pre-create the file
381 */
382 if (td_read(td) || td_rw(td))
2dc1bbeb 383 o->overwrite = 1;
16b462ae 384
2dc1bbeb 385 if (!o->min_bs[DDIR_READ])
5ec10eaa 386 o->min_bs[DDIR_READ] = o->bs[DDIR_READ];
2dc1bbeb
JA
387 if (!o->max_bs[DDIR_READ])
388 o->max_bs[DDIR_READ] = o->bs[DDIR_READ];
389 if (!o->min_bs[DDIR_WRITE])
5ec10eaa 390 o->min_bs[DDIR_WRITE] = o->bs[DDIR_WRITE];
2dc1bbeb
JA
391 if (!o->max_bs[DDIR_WRITE])
392 o->max_bs[DDIR_WRITE] = o->bs[DDIR_WRITE];
a00735e6 393
2dc1bbeb 394 o->rw_min_bs = min(o->min_bs[DDIR_READ], o->min_bs[DDIR_WRITE]);
a00735e6 395
2b7a01d0
JA
396 /*
397 * For random IO, allow blockalign offset other than min_bs.
398 */
399 if (!o->ba[DDIR_READ] || !td_random(td))
400 o->ba[DDIR_READ] = o->min_bs[DDIR_READ];
401 if (!o->ba[DDIR_WRITE] || !td_random(td))
402 o->ba[DDIR_WRITE] = o->min_bs[DDIR_WRITE];
403
404 if ((o->ba[DDIR_READ] != o->min_bs[DDIR_READ] ||
405 o->ba[DDIR_WRITE] != o->min_bs[DDIR_WRITE]) &&
9bbf57cc 406 !o->norandommap) {
2b7a01d0 407 log_err("fio: Any use of blockalign= turns off randommap\n");
9bbf57cc 408 o->norandommap = 1;
a9523c6f 409 ret = warnings_fatal;
2b7a01d0
JA
410 }
411
2dc1bbeb
JA
412 if (!o->file_size_high)
413 o->file_size_high = o->file_size_low;
9c60ce64 414
8347239a
JA
415 if (o->norandommap && o->verify != VERIFY_NONE
416 && !fixed_block_size(o)) {
417 log_err("fio: norandommap given for variable block sizes, "
418 "verify disabled\n");
2dc1bbeb 419 o->verify = VERIFY_NONE;
a9523c6f 420 ret = warnings_fatal;
bb8895e0 421 }
2dc1bbeb 422 if (o->bs_unaligned && (o->odirect || td->io_ops->flags & FIO_RAWIO))
690adba3 423 log_err("fio: bs_unaligned may not work with raw io\n");
e0a22335 424
48097d5c
JA
425 /*
426 * thinktime_spin must be less than thinktime
427 */
2dc1bbeb
JA
428 if (o->thinktime_spin > o->thinktime)
429 o->thinktime_spin = o->thinktime;
e916b390
JA
430
431 /*
432 * The low water mark cannot be bigger than the iodepth
433 */
2dc1bbeb 434 if (o->iodepth_low > o->iodepth || !o->iodepth_low) {
9467b77c
JA
435 /*
436 * syslet work around - if the workload is sequential,
437 * we want to let the queue drain all the way down to
438 * avoid seeking between async threads
439 */
440 if (!strcmp(td->io_ops->name, "syslet-rw") && !td_random(td))
2dc1bbeb 441 o->iodepth_low = 1;
9467b77c 442 else
2dc1bbeb 443 o->iodepth_low = o->iodepth;
9467b77c 444 }
cb5ab512
JA
445
446 /*
447 * If batch number isn't set, default to the same as iodepth
448 */
2dc1bbeb
JA
449 if (o->iodepth_batch > o->iodepth || !o->iodepth_batch)
450 o->iodepth_batch = o->iodepth;
b5af8293 451
2dc1bbeb
JA
452 if (o->nr_files > td->files_index)
453 o->nr_files = td->files_index;
9f9214f2 454
2dc1bbeb
JA
455 if (o->open_files > o->nr_files || !o->open_files)
456 o->open_files = o->nr_files;
4e991c23 457
581e7141
JA
458 if (((o->rate[0] + o->rate[1]) && (o->rate_iops[0] + o->rate_iops[1]))||
459 ((o->ratemin[0] + o->ratemin[1]) && (o->rate_iops_min[0] +
460 o->rate_iops_min[1]))) {
4e991c23 461 log_err("fio: rate and rate_iops are mutually exclusive\n");
a9523c6f 462 ret = 1;
4e991c23 463 }
581e7141
JA
464 if ((o->rate[0] < o->ratemin[0]) || (o->rate[1] < o->ratemin[1]) ||
465 (o->rate_iops[0] < o->rate_iops_min[0]) ||
466 (o->rate_iops[1] < o->rate_iops_min[1])) {
4e991c23 467 log_err("fio: minimum rate exceeds rate\n");
a9523c6f 468 ret = 1;
4e991c23
JA
469 }
470
cf4464ca
JA
471 if (!o->timeout && o->time_based) {
472 log_err("fio: time_based requires a runtime/timeout setting\n");
473 o->time_based = 0;
a9523c6f 474 ret = warnings_fatal;
cf4464ca
JA
475 }
476
aa31f1f1 477 if (o->fill_device && !o->size)
5921e80c 478 o->size = -1ULL;
5ec10eaa 479
9bbf57cc 480 if (o->verify != VERIFY_NONE) {
996936f9 481 if (td_write(td) && o->do_verify && o->numjobs > 1) {
a9523c6f
JA
482 log_info("Multiple writers may overwrite blocks that "
483 "belong to other jobs. This can cause "
484 "verification failures.\n");
485 ret = warnings_fatal;
486 }
487
9bbf57cc 488 o->refill_buffers = 1;
2f1b8e8b
JA
489 if (o->max_bs[DDIR_WRITE] != o->min_bs[DDIR_WRITE] &&
490 !o->verify_interval)
491 o->verify_interval = o->min_bs[DDIR_WRITE];
d990588e 492 }
41ccd845 493
9bbf57cc
JA
494 if (o->pre_read) {
495 o->invalidate_cache = 0;
a9523c6f 496 if (td->io_ops->flags & FIO_PIPEIO) {
9c0d2241
JA
497 log_info("fio: cannot pre-read files with an IO engine"
498 " that isn't seekable. Pre-read disabled.\n");
a9523c6f
JA
499 ret = warnings_fatal;
500 }
9c0d2241 501 }
34f1c044 502
e72fa4d4 503#ifndef FIO_HAVE_FDATASYNC
9bbf57cc 504 if (o->fdatasync_blocks) {
e72fa4d4
JA
505 log_info("fio: this platform does not support fdatasync()"
506 " falling back to using fsync(). Use the 'fsync'"
507 " option instead of 'fdatasync' to get rid of"
508 " this warning\n");
9bbf57cc
JA
509 o->fsync_blocks = o->fdatasync_blocks;
510 o->fdatasync_blocks = 0;
a9523c6f 511 ret = warnings_fatal;
e72fa4d4
JA
512 }
513#endif
514
a9523c6f 515 return ret;
e1f36503
JA
516}
517
f8977ee6
JA
518/*
519 * This function leaks the buffer
520 */
521static char *to_kmg(unsigned int val)
522{
523 char *buf = malloc(32);
f3502ba2 524 char post[] = { 0, 'K', 'M', 'G', 'P', 'E', 0 };
f8977ee6
JA
525 char *p = post;
526
245142ff 527 do {
f8977ee6
JA
528 if (val & 1023)
529 break;
530
531 val >>= 10;
532 p++;
245142ff 533 } while (*p);
f8977ee6
JA
534
535 snprintf(buf, 31, "%u%c", val, *p);
536 return buf;
537}
538
09629a90
JA
539/* External engines are specified by "external:name.o") */
540static const char *get_engine_name(const char *str)
541{
542 char *p = strstr(str, ":");
543
544 if (!p)
545 return str;
546
547 p++;
548 strip_blank_front(&p);
549 strip_blank_end(p);
550 return p;
551}
552
e132cbae
JA
553static int exists_and_not_file(const char *filename)
554{
555 struct stat sb;
556
557 if (lstat(filename, &sb) == -1)
558 return 0;
559
ecc314ba
BC
560 /* \\.\ is the device namespace in Windows, where every file
561 * is a device node */
562 if (S_ISREG(sb.st_mode) && strncmp(filename, "\\\\.\\", 4) != 0)
e132cbae
JA
563 return 0;
564
565 return 1;
566}
567
4c07ad86 568static void td_fill_rand_seeds_os(struct thread_data *td)
5bfc35d7
JA
569{
570 os_random_seed(td->rand_seeds[0], &td->bsrange_state);
571 os_random_seed(td->rand_seeds[1], &td->verify_state);
572 os_random_seed(td->rand_seeds[2], &td->rwmix_state);
573
574 if (td->o.file_service_type == FIO_FSERVICE_RANDOM)
575 os_random_seed(td->rand_seeds[3], &td->next_file_state);
576
577 os_random_seed(td->rand_seeds[5], &td->file_size_state);
0d29de83 578 os_random_seed(td->rand_seeds[6], &td->trim_state);
5bfc35d7
JA
579
580 if (!td_random(td))
581 return;
582
583 if (td->o.rand_repeatable)
584 td->rand_seeds[4] = FIO_RANDSEED * td->thread_number;
585
586 os_random_seed(td->rand_seeds[4], &td->random_state);
4c07ad86
JA
587}
588
589static void td_fill_rand_seeds_internal(struct thread_data *td)
590{
591 init_rand_seed(&td->__bsrange_state, td->rand_seeds[0]);
592 init_rand_seed(&td->__verify_state, td->rand_seeds[1]);
593 init_rand_seed(&td->__rwmix_state, td->rand_seeds[2]);
594
595 if (td->o.file_service_type == FIO_FSERVICE_RANDOM)
596 init_rand_seed(&td->__next_file_state, td->rand_seeds[3]);
597
598 init_rand_seed(&td->__file_size_state, td->rand_seeds[5]);
599 init_rand_seed(&td->__trim_state, td->rand_seeds[6]);
600
601 if (!td_random(td))
602 return;
603
604 if (td->o.rand_repeatable)
605 td->rand_seeds[4] = FIO_RANDSEED * td->thread_number;
606
2615cc4b 607 init_rand_seed(&td->__random_state, td->rand_seeds[4]);
5bfc35d7
JA
608}
609
4c07ad86
JA
610void td_fill_rand_seeds(struct thread_data *td)
611{
612 if (td->o.use_os_rand)
613 td_fill_rand_seeds_os(td);
614 else
615 td_fill_rand_seeds_internal(td);
3545a109
JA
616
617 init_rand_seed(&td->buf_state, td->rand_seeds[7]);
4c07ad86
JA
618}
619
9c60ce64
JA
620/*
621 * Initialize the various random states we need (random io, block size ranges,
622 * read/write mix, etc).
623 */
624static int init_random_state(struct thread_data *td)
625{
68727076 626 int fd;
9c60ce64
JA
627
628 fd = open("/dev/urandom", O_RDONLY);
629 if (fd == -1) {
630 td_verror(td, errno, "open");
631 return 1;
632 }
633
5bfc35d7
JA
634 if (read(fd, td->rand_seeds, sizeof(td->rand_seeds)) <
635 (int) sizeof(td->rand_seeds)) {
9c60ce64
JA
636 td_verror(td, EIO, "read");
637 close(fd);
638 return 1;
639 }
640
641 close(fd);
5bfc35d7 642 td_fill_rand_seeds(td);
9c60ce64
JA
643 return 0;
644}
645
906c8d75
JA
646/*
647 * Adds a job to the list of things todo. Sanitizes the various options
648 * to make sure we don't have conflicts, and initializes various
649 * members of td.
650 */
75154845 651static int add_job(struct thread_data *td, const char *jobname, int job_add_num)
ebac4655 652{
413dd459
JA
653 const char *ddir_str[] = { NULL, "read", "write", "rw", NULL,
654 "randread", "randwrite", "randrw" };
af52b345 655 unsigned int i;
09629a90 656 const char *engine;
af52b345 657 char fname[PATH_MAX];
e132cbae 658 int numjobs, file_alloced;
ebac4655 659
ebac4655
JA
660 /*
661 * the def_thread is just for options, it's not a real job
662 */
663 if (td == &def_thread)
664 return 0;
665
cca73aa7
JA
666 /*
667 * if we are just dumping the output command line, don't add the job
668 */
669 if (dump_cmdline) {
670 put_job(td);
671 return 0;
672 }
673
58c55ba0 674 if (profile_td_init(td))
66251554 675 goto err;
58c55ba0 676
2dc1bbeb 677 engine = get_engine_name(td->o.ioengine);
09629a90
JA
678 td->io_ops = load_ioengine(td, engine);
679 if (!td->io_ops) {
680 log_err("fio: failed to load engine %s\n", engine);
205927a3 681 goto err;
09629a90 682 }
df64119d 683
2dc1bbeb 684 if (td->o.use_thread)
9cedf167
JA
685 nr_thread++;
686 else
687 nr_process++;
688
2dc1bbeb 689 if (td->o.odirect)
690adba3
JA
690 td->io_ops->flags |= FIO_RAWIO;
691
e132cbae 692 file_alloced = 0;
691c8fb0 693 if (!td->o.filename && !td->files_index && !td->o.read_iolog_file) {
e132cbae 694 file_alloced = 1;
80be24f4 695
2dc1bbeb 696 if (td->o.nr_files == 1 && exists_and_not_file(jobname))
e132cbae 697 add_file(td, jobname);
7b05a215 698 else {
2dc1bbeb 699 for (i = 0; i < td->o.nr_files; i++) {
5ec10eaa
JA
700 sprintf(fname, "%s.%d.%d", jobname,
701 td->thread_number, i);
7b05a215
JA
702 add_file(td, fname);
703 }
af52b345 704 }
0af7b542 705 }
ebac4655 706
4e991c23
JA
707 if (fixup_options(td))
708 goto err;
e0a22335 709
07eb79df
JA
710 if (td->io_ops->flags & FIO_DISKLESSIO) {
711 struct fio_file *f;
712
713 for_each_file(td, f, i)
714 f->real_file_size = -1ULL;
715 }
716
cdd18ad8 717 td->mutex = fio_mutex_init(0);
ebac4655 718
83349190
YH
719 td->ts.clat_percentiles = td->o.clat_percentiles;
720 if (td->o.overwrite_plist)
721 td->ts.percentile_list = td->o.percentile_list;
722 else
723 td->ts.percentile_list = NULL;
724
756867bd
JA
725 td->ts.clat_stat[0].min_val = td->ts.clat_stat[1].min_val = ULONG_MAX;
726 td->ts.slat_stat[0].min_val = td->ts.slat_stat[1].min_val = ULONG_MAX;
02af0988 727 td->ts.lat_stat[0].min_val = td->ts.lat_stat[1].min_val = ULONG_MAX;
756867bd 728 td->ts.bw_stat[0].min_val = td->ts.bw_stat[1].min_val = ULONG_MAX;
cdd5411e 729 td->ddir_seq_nr = td->o.ddir_seq_nr;
ebac4655 730
755c3189 731 if ((td->o.stonewall || td->o.new_group) && prev_group_jobs) {
3c5df6fa 732 prev_group_jobs = 0;
ebac4655 733 groupid++;
3c5df6fa 734 }
ebac4655
JA
735
736 td->groupid = groupid;
3c5df6fa 737 prev_group_jobs++;
ebac4655 738
9c60ce64
JA
739 if (init_random_state(td))
740 goto err;
741
ebac4655
JA
742 if (setup_rate(td))
743 goto err;
744
2dc1bbeb 745 if (td->o.write_lat_log) {
7b9f733a
JA
746 setup_log(&td->lat_log);
747 setup_log(&td->slat_log);
748 setup_log(&td->clat_log);
ebac4655 749 }
2dc1bbeb 750 if (td->o.write_bw_log)
7b9f733a 751 setup_log(&td->bw_log);
ebac4655 752
2dc1bbeb
JA
753 if (!td->o.name)
754 td->o.name = strdup(jobname);
01452055 755
c6ae0a5b 756 if (!terse_output) {
b990b5c0 757 if (!job_add_num) {
5ec10eaa
JA
758 if (!strcmp(td->io_ops->name, "cpuio")) {
759 log_info("%s: ioengine=cpu, cpuload=%u,"
760 " cpucycle=%u\n", td->o.name,
761 td->o.cpuload,
762 td->o.cpucycle);
763 } else {
f8977ee6
JA
764 char *c1, *c2, *c3, *c4;
765
2dc1bbeb
JA
766 c1 = to_kmg(td->o.min_bs[DDIR_READ]);
767 c2 = to_kmg(td->o.max_bs[DDIR_READ]);
768 c3 = to_kmg(td->o.min_bs[DDIR_WRITE]);
769 c4 = to_kmg(td->o.max_bs[DDIR_WRITE]);
f8977ee6 770
5ec10eaa
JA
771 log_info("%s: (g=%d): rw=%s, bs=%s-%s/%s-%s,"
772 " ioengine=%s, iodepth=%u\n",
773 td->o.name, td->groupid,
774 ddir_str[td->o.td_ddir],
775 c1, c2, c3, c4,
776 td->io_ops->name,
777 td->o.iodepth);
f8977ee6
JA
778
779 free(c1);
780 free(c2);
781 free(c3);
782 free(c4);
783 }
b990b5c0 784 } else if (job_add_num == 1)
6d86144d 785 log_info("...\n");
c6ae0a5b 786 }
ebac4655
JA
787
788 /*
789 * recurse add identical jobs, clear numjobs and stonewall options
790 * as they don't apply to sub-jobs
791 */
2dc1bbeb 792 numjobs = td->o.numjobs;
ebac4655
JA
793 while (--numjobs) {
794 struct thread_data *td_new = get_new_job(0, td);
795
796 if (!td_new)
797 goto err;
798
2dc1bbeb
JA
799 td_new->o.numjobs = 1;
800 td_new->o.stonewall = 0;
92c1d41f 801 td_new->o.new_group = 0;
e132cbae
JA
802
803 if (file_alloced) {
2dc1bbeb 804 td_new->o.filename = NULL;
e132cbae 805 td_new->files_index = 0;
4e6ea2f1 806 td_new->files_size = 0;
e132cbae
JA
807 td_new->files = NULL;
808 }
809
75154845 810 job_add_num = numjobs - 1;
ebac4655 811
75154845 812 if (add_job(td_new, jobname, job_add_num))
ebac4655
JA
813 goto err;
814 }
3c5df6fa 815
ebac4655
JA
816 return 0;
817err:
818 put_job(td);
819 return -1;
820}
821
79d16311
JA
822/*
823 * Parse as if 'o' was a command line
824 */
825void add_job_opts(const char **o)
826{
827 struct thread_data *td, *td_parent;
828 int i, in_global = 1;
829 char jobname[32];
830
831 i = 0;
832 td_parent = td = NULL;
833 while (o[i]) {
834 if (!strncmp(o[i], "name", 4)) {
835 in_global = 0;
836 if (td)
837 add_job(td, jobname, 0);
838 td = NULL;
839 sprintf(jobname, "%s", o[i] + 5);
840 }
841 if (in_global && !td_parent)
842 td_parent = get_new_job(1, &def_thread);
843 else if (!in_global && !td) {
844 if (!td_parent)
845 td_parent = &def_thread;
846 td = get_new_job(0, td_parent);
847 }
848 if (in_global)
849 fio_options_parse(td_parent, (char **) &o[i], 1);
850 else
851 fio_options_parse(td, (char **) &o[i], 1);
852 i++;
853 }
854
855 if (td)
856 add_job(td, jobname, 0);
857}
858
01f06b63
JA
859static int skip_this_section(const char *name)
860{
ad0a2735
JA
861 int i;
862
863 if (!nr_job_sections)
01f06b63
JA
864 return 0;
865 if (!strncmp(name, "global", 6))
866 return 0;
867
ad0a2735
JA
868 for (i = 0; i < nr_job_sections; i++)
869 if (!strcmp(job_sections[i], name))
870 return 0;
871
872 return 1;
01f06b63
JA
873}
874
ebac4655
JA
875static int is_empty_or_comment(char *line)
876{
877 unsigned int i;
878
879 for (i = 0; i < strlen(line); i++) {
880 if (line[i] == ';')
881 return 1;
5cc2da30
IM
882 if (line[i] == '#')
883 return 1;
76cd9378 884 if (!isspace((int) line[i]) && !iscntrl((int) line[i]))
ebac4655
JA
885 return 0;
886 }
887
888 return 1;
889}
890
07261983
JA
891/*
892 * This is our [ini] type file parser.
893 */
50d16976 894int parse_jobs_ini(char *file, int is_buf, int stonewall_flag)
ebac4655 895{
e1f36503 896 unsigned int global;
ebac4655 897 struct thread_data *td;
fee3bb48 898 char *string, *name;
ebac4655
JA
899 FILE *f;
900 char *p;
0c7e37a0 901 int ret = 0, stonewall;
097b2991 902 int first_sect = 1;
ccf8f127 903 int skip_fgets = 0;
01f06b63 904 int inside_skip = 0;
3b8b7135
JA
905 char **opts;
906 int i, alloc_opts, num_opts;
ebac4655 907
50d16976
JA
908 if (is_buf)
909 f = NULL;
910 else {
911 if (!strcmp(file, "-"))
912 f = stdin;
913 else
914 f = fopen(file, "r");
5a729cbe 915
50d16976
JA
916 if (!f) {
917 perror("fopen job file");
918 return 1;
919 }
ebac4655
JA
920 }
921
922 string = malloc(4096);
7f7e6e59
JA
923
924 /*
925 * it's really 256 + small bit, 280 should suffice
926 */
927 name = malloc(280);
928 memset(name, 0, 280);
ebac4655 929
3b8b7135
JA
930 alloc_opts = 8;
931 opts = malloc(sizeof(char *) * alloc_opts);
b7c6302d 932 num_opts = 0;
3b8b7135 933
0c7e37a0 934 stonewall = stonewall_flag;
7c124ac1 935 do {
ccf8f127
JA
936 /*
937 * if skip_fgets is set, we already have loaded a line we
938 * haven't handled.
939 */
940 if (!skip_fgets) {
50d16976
JA
941 if (is_buf)
942 p = strsep(&file, "\n");
943 else
944 p = fgets(string, 4095, f);
ccf8f127
JA
945 if (!p)
946 break;
947 }
cdc7f193 948
ccf8f127 949 skip_fgets = 0;
cdc7f193 950 strip_blank_front(&p);
6c7c7da1 951 strip_blank_end(p);
cdc7f193 952
ebac4655
JA
953 if (is_empty_or_comment(p))
954 continue;
84dd1886 955 if (sscanf(p, "[%255[^\n]]", name) != 1) {
01f06b63
JA
956 if (inside_skip)
957 continue;
5ec10eaa
JA
958 log_err("fio: option <%s> outside of [] job section\n",
959 p);
088b4207 960 break;
6c7c7da1 961 }
ebac4655 962
7a4b80a1
JA
963 name[strlen(name) - 1] = '\0';
964
01f06b63
JA
965 if (skip_this_section(name)) {
966 inside_skip = 1;
967 continue;
968 } else
969 inside_skip = 0;
970
ebac4655
JA
971 global = !strncmp(name, "global", 6);
972
cca73aa7 973 if (dump_cmdline) {
097b2991
JA
974 if (first_sect)
975 log_info("fio ");
cca73aa7
JA
976 if (!global)
977 log_info("--name=%s ", name);
097b2991 978 first_sect = 0;
cca73aa7
JA
979 }
980
ebac4655 981 td = get_new_job(global, &def_thread);
45410acb
JA
982 if (!td) {
983 ret = 1;
984 break;
985 }
ebac4655 986
972cfd25
JA
987 /*
988 * Seperate multiple job files by a stonewall
989 */
f9481919 990 if (!global && stonewall) {
2dc1bbeb 991 td->o.stonewall = stonewall;
972cfd25
JA
992 stonewall = 0;
993 }
994
3b8b7135
JA
995 num_opts = 0;
996 memset(opts, 0, alloc_opts * sizeof(char *));
997
50d16976
JA
998 while (1) {
999 if (is_buf)
1000 p = strsep(&file, "\n");
1001 else
1002 p = fgets(string, 4096, f);
1003 if (!p)
1004 break;
1005
ebac4655
JA
1006 if (is_empty_or_comment(p))
1007 continue;
e1f36503 1008
b6754f9d 1009 strip_blank_front(&p);
7c124ac1 1010
ccf8f127
JA
1011 /*
1012 * new section, break out and make sure we don't
1013 * fgets() a new line at the top.
1014 */
1015 if (p[0] == '[') {
1016 skip_fgets = 1;
7c124ac1 1017 break;
ccf8f127 1018 }
7c124ac1 1019
4ae3f763 1020 strip_blank_end(p);
aea47d44 1021
3b8b7135
JA
1022 if (num_opts == alloc_opts) {
1023 alloc_opts <<= 1;
1024 opts = realloc(opts,
1025 alloc_opts * sizeof(char *));
1026 }
1027
1028 opts[num_opts] = strdup(p);
1029 num_opts++;
ebac4655 1030 }
ebac4655 1031
3b8b7135
JA
1032 ret = fio_options_parse(td, opts, num_opts);
1033 if (!ret) {
1034 if (dump_cmdline)
1035 for (i = 0; i < num_opts; i++)
1036 log_info("--%s ", opts[i]);
1037
45410acb 1038 ret = add_job(td, name, 0);
3b8b7135 1039 } else {
b1508cf9
JA
1040 log_err("fio: job %s dropped\n", name);
1041 put_job(td);
45410acb 1042 }
3b8b7135
JA
1043
1044 for (i = 0; i < num_opts; i++)
1045 free(opts[i]);
1046 num_opts = 0;
7c124ac1 1047 } while (!ret);
ebac4655 1048
cca73aa7
JA
1049 if (dump_cmdline)
1050 log_info("\n");
1051
3b8b7135
JA
1052 for (i = 0; i < num_opts; i++)
1053 free(opts[i]);
1054
ebac4655
JA
1055 free(string);
1056 free(name);
2577594d 1057 free(opts);
50d16976 1058 if (!is_buf && f != stdin)
5a729cbe 1059 fclose(f);
45410acb 1060 return ret;
ebac4655
JA
1061}
1062
1063static int fill_def_thread(void)
1064{
1065 memset(&def_thread, 0, sizeof(def_thread));
1066
375b2695 1067 fio_getaffinity(getpid(), &def_thread.o.cpumask);
ebac4655
JA
1068
1069 /*
ee738499 1070 * fill default options
ebac4655 1071 */
214e1eca 1072 fio_fill_default_options(&def_thread);
ebac4655
JA
1073 return 0;
1074}
1075
45378b35 1076static void usage(const char *name)
4785f995 1077{
43617628 1078 printf("%s\n", fio_version_string);
45378b35 1079 printf("%s [options] [job options] <job file(s)>\n", name);
ee56ad50 1080 printf("\t--debug=options\tEnable debug logging\n");
b4692828
JA
1081 printf("\t--output\tWrite output to file\n");
1082 printf("\t--timeout\tRuntime in seconds\n");
1083 printf("\t--latency-log\tGenerate per-job latency logs\n");
1084 printf("\t--bandwidth-log\tGenerate per-job bandwidth logs\n");
1085 printf("\t--minimal\tMinimal (terse) output\n");
1086 printf("\t--version\tPrint version info and exit\n");
f57a9c59 1087 printf("\t--terse-version=x Terse version output format\n");
fd28ca49 1088 printf("\t--help\t\tPrint this page\n");
5ec10eaa
JA
1089 printf("\t--cmdhelp=cmd\tPrint command help, \"all\" for all of"
1090 " them\n");
cca73aa7 1091 printf("\t--showcmd\tTurn a job file into command line options\n");
e592a06b
AC
1092 printf("\t--eta=when\tWhen ETA estimate should be printed\n");
1093 printf("\t \tMay be \"always\", \"never\" or \"auto\"\n");
5ec10eaa
JA
1094 printf("\t--readonly\tTurn on safety read-only checks, preventing"
1095 " writes\n");
01f06b63 1096 printf("\t--section=name\tOnly run specified section in job file\n");
2b386d25
JA
1097 printf("\t--alloc-size=kb\tSet smalloc pool to this size in kb"
1098 " (def 1024)\n");
a9523c6f 1099 printf("\t--warnings-fatal Fio parser warnings are fatal\n");
fca70358 1100 printf("\t--max-jobs\tMaximum number of threads/processes to support\n");
132159a5
JA
1101 printf("\t--server\tStart a backend fio server\n");
1102 printf("\t--client=hostname Talk to remove backend fio server at hostname\n");
1103 printf("\t--net-port=port\tUse specified port for client/server connection\n");
aa58d252
JA
1104 printf("\nFio was written by Jens Axboe <jens.axboe@oracle.com>");
1105 printf("\n Jens Axboe <jaxboe@fusionio.com>\n");
4785f995
JA
1106}
1107
79e48f72 1108#ifdef FIO_INC_DEBUG
ee56ad50 1109struct debug_level debug_levels[] = {
bd6f78b2
JA
1110 { .name = "process", .shift = FD_PROCESS, },
1111 { .name = "file", .shift = FD_FILE, },
1112 { .name = "io", .shift = FD_IO, },
1113 { .name = "mem", .shift = FD_MEM, },
1114 { .name = "blktrace", .shift = FD_BLKTRACE },
1115 { .name = "verify", .shift = FD_VERIFY },
84422acd 1116 { .name = "random", .shift = FD_RANDOM },
a3d741fa 1117 { .name = "parse", .shift = FD_PARSE },
cd991b9e 1118 { .name = "diskutil", .shift = FD_DISKUTIL },
5e1d306e 1119 { .name = "job", .shift = FD_JOB },
29adda3c 1120 { .name = "mutex", .shift = FD_MUTEX },
79d16311 1121 { .name = "profile", .shift = FD_PROFILE },
c223da83 1122 { .name = "time", .shift = FD_TIME },
eb7976ef 1123 { .name = "net", .shift = FD_NET },
02444ad1 1124 { .name = NULL, },
ee56ad50
JA
1125};
1126
c09823ab 1127static int set_debug(const char *string)
ee56ad50
JA
1128{
1129 struct debug_level *dl;
1130 char *p = (char *) string;
1131 char *opt;
1132 int i;
1133
1134 if (!strcmp(string, "?") || !strcmp(string, "help")) {
ee56ad50
JA
1135 log_info("fio: dumping debug options:");
1136 for (i = 0; debug_levels[i].name; i++) {
1137 dl = &debug_levels[i];
1138 log_info("%s,", dl->name);
1139 }
bd6f78b2 1140 log_info("all\n");
c09823ab 1141 return 1;
ee56ad50
JA
1142 }
1143
1144 while ((opt = strsep(&p, ",")) != NULL) {
1145 int found = 0;
1146
5e1d306e
JA
1147 if (!strncmp(opt, "all", 3)) {
1148 log_info("fio: set all debug options\n");
1149 fio_debug = ~0UL;
1150 continue;
1151 }
1152
ee56ad50
JA
1153 for (i = 0; debug_levels[i].name; i++) {
1154 dl = &debug_levels[i];
5e1d306e
JA
1155 found = !strncmp(opt, dl->name, strlen(dl->name));
1156 if (!found)
1157 continue;
1158
1159 if (dl->shift == FD_JOB) {
1160 opt = strchr(opt, ':');
1161 if (!opt) {
1162 log_err("fio: missing job number\n");
1163 break;
1164 }
1165 opt++;
1166 fio_debug_jobno = atoi(opt);
1167 log_info("fio: set debug jobno %d\n",
1168 fio_debug_jobno);
1169 } else {
ee56ad50 1170 log_info("fio: set debug option %s\n", opt);
bd6f78b2 1171 fio_debug |= (1UL << dl->shift);
ee56ad50 1172 }
5e1d306e 1173 break;
ee56ad50
JA
1174 }
1175
1176 if (!found)
1177 log_err("fio: debug mask %s not found\n", opt);
1178 }
c09823ab 1179 return 0;
ee56ad50 1180}
79e48f72 1181#else
69b98d4c 1182static int set_debug(const char *string)
79e48f72
JA
1183{
1184 log_err("fio: debug tracing not included in build\n");
c09823ab 1185 return 1;
79e48f72
JA
1186}
1187#endif
9ac8a797 1188
4c6107ff
JA
1189static void fio_options_fill_optstring(void)
1190{
1191 char *ostr = cmd_optstr;
1192 int i, c;
1193
1194 c = i = 0;
1195 while (l_opts[i].name) {
1196 ostr[c++] = l_opts[i].val;
1197 if (l_opts[i].has_arg == required_argument)
1198 ostr[c++] = ':';
1199 else if (l_opts[i].has_arg == optional_argument) {
1200 ostr[c++] = ':';
1201 ostr[c++] = ':';
1202 }
1203 i++;
1204 }
1205 ostr[c] = '\0';
1206}
1207
81179eec 1208int parse_cmd_line(int argc, char *argv[])
ebac4655 1209{
b4692828 1210 struct thread_data *td = NULL;
c09823ab 1211 int c, ini_idx = 0, lidx, ret = 0, do_exit = 0, exit_val = 0;
4c6107ff 1212 char *ostr = cmd_optstr;
e46d8091 1213 int daemonize_server = 0;
81179eec
JA
1214 char *cur_client = NULL;
1215 int backend = 0;
ebac4655 1216
4c6107ff 1217 while ((c = getopt_long_only(argc, argv, ostr, l_opts, &lidx)) != -1) {
ebac4655 1218 switch (c) {
2b386d25 1219 case 'a':
9ef56d46 1220 fio_client_add_cmd_option(cur_client, argv[optind-1]);
2b386d25
JA
1221 smalloc_pool_size = atoi(optarg);
1222 break;
b4692828 1223 case 't':
9ef56d46 1224 fio_client_add_cmd_option(cur_client, argv[optind-1]);
ab2cabdb 1225 def_thread.o.timeout = atoi(optarg);
b4692828
JA
1226 break;
1227 case 'l':
9ef56d46 1228 fio_client_add_cmd_option(cur_client, argv[optind-1]);
b4692828
JA
1229 write_lat_log = 1;
1230 break;
3d73e5a9 1231 case 'b':
9ef56d46 1232 fio_client_add_cmd_option(cur_client, argv[optind-1]);
b4692828
JA
1233 write_bw_log = 1;
1234 break;
1235 case 'o':
9ef56d46 1236 fio_client_add_cmd_option(cur_client, argv[optind-1]);
b4692828
JA
1237 f_out = fopen(optarg, "w+");
1238 if (!f_out) {
1239 perror("fopen output");
1240 exit(1);
1241 }
1242 f_err = f_out;
1243 break;
1244 case 'm':
9ef56d46 1245 fio_client_add_cmd_option(cur_client, argv[optind-1]);
b4692828
JA
1246 terse_output = 1;
1247 break;
1248 case 'h':
45378b35 1249 usage(argv[0]);
b4692828 1250 exit(0);
fd28ca49 1251 case 'c':
214e1eca 1252 exit(fio_show_option_help(optarg));
cca73aa7 1253 case 's':
9ef56d46 1254 fio_client_add_cmd_option(cur_client, argv[optind-1]);
cca73aa7
JA
1255 dump_cmdline = 1;
1256 break;
724e4435 1257 case 'r':
9ef56d46 1258 fio_client_add_cmd_option(cur_client, argv[optind-1]);
724e4435
JA
1259 read_only = 1;
1260 break;
b4692828 1261 case 'v':
ca740f4e 1262 log_info("%s\n", fio_version_string);
b4692828 1263 exit(0);
f57a9c59 1264 case 'V':
9ef56d46 1265 fio_client_add_cmd_option(cur_client, argv[optind-1]);
f57a9c59
JA
1266 terse_version = atoi(optarg);
1267 if (terse_version != 2) {
1268 log_err("fio: bad terse version format\n");
1269 exit_val = 1;
1270 do_exit++;
1271 }
1272 break;
e592a06b 1273 case 'e':
9ef56d46 1274 fio_client_add_cmd_option(cur_client, argv[optind-1]);
e592a06b
AC
1275 if (!strcmp("always", optarg))
1276 eta_print = FIO_ETA_ALWAYS;
1277 else if (!strcmp("never", optarg))
1278 eta_print = FIO_ETA_NEVER;
1279 break;
ee56ad50 1280 case 'd':
9ef56d46 1281 fio_client_add_cmd_option(cur_client, argv[optind-1]);
c09823ab
JA
1282 if (set_debug(optarg))
1283 do_exit++;
ee56ad50 1284 break;
ad0a2735
JA
1285 case 'x': {
1286 size_t new_size;
1287
9ef56d46 1288 fio_client_add_cmd_option(cur_client, argv[optind-1]);
81179eec 1289
01f06b63 1290 if (!strcmp(optarg, "global")) {
5ec10eaa
JA
1291 log_err("fio: can't use global as only "
1292 "section\n");
c09823ab
JA
1293 do_exit++;
1294 exit_val = 1;
01f06b63
JA
1295 break;
1296 }
ad0a2735
JA
1297 new_size = (nr_job_sections + 1) * sizeof(char *);
1298 job_sections = realloc(job_sections, new_size);
1299 job_sections[nr_job_sections] = strdup(optarg);
1300 nr_job_sections++;
01f06b63 1301 break;
ad0a2735 1302 }
9ac8a797 1303 case 'p':
9ef56d46 1304 fio_client_add_cmd_option(cur_client, argv[optind-1]);
07b3232d 1305 exec_profile = strdup(optarg);
9ac8a797 1306 break;
b4692828 1307 case FIO_GETOPT_JOB: {
5ec10eaa 1308 const char *opt = l_opts[lidx].name;
b4692828
JA
1309 char *val = optarg;
1310
9ef56d46 1311 fio_client_add_cmd_option(cur_client, argv[optind-1]);
81179eec 1312
c2b1e753 1313 if (!strncmp(opt, "name", 4) && td) {
2dc1bbeb 1314 ret = add_job(td, td->o.name ?: "fio", 0);
66251554 1315 if (ret)
c2b1e753 1316 return 0;
c2b1e753
JA
1317 td = NULL;
1318 }
b4692828 1319 if (!td) {
01f06b63 1320 int is_section = !strncmp(opt, "name", 4);
3106f220
JA
1321 int global = 0;
1322
01f06b63 1323 if (!is_section || !strncmp(val, "global", 6))
3106f220 1324 global = 1;
c2b1e753 1325
01f06b63
JA
1326 if (is_section && skip_this_section(val))
1327 continue;
1328
c2b1e753 1329 td = get_new_job(global, &def_thread);
b4692828
JA
1330 if (!td)
1331 return 0;
1332 }
38d0adb0 1333
214e1eca 1334 ret = fio_cmd_option_parse(td, opt, val);
b4692828
JA
1335 break;
1336 }
a9523c6f 1337 case 'w':
9ef56d46 1338 fio_client_add_cmd_option(cur_client, argv[optind-1]);
a9523c6f
JA
1339 warnings_fatal = 1;
1340 break;
fca70358 1341 case 'j':
9ef56d46 1342 fio_client_add_cmd_option(cur_client, argv[optind-1]);
fca70358
JA
1343 max_jobs = atoi(optarg);
1344 if (!max_jobs || max_jobs > REAL_MAX_JOBS) {
1345 log_err("fio: invalid max jobs: %d\n", max_jobs);
1346 do_exit++;
1347 exit_val = 1;
1348 }
1349 break;
50d16976 1350 case 'S':
a37f69b7 1351 if (nr_clients) {
132159a5
JA
1352 log_err("fio: can't be both client and server\n");
1353 do_exit++;
1354 exit_val = 1;
1355 break;
1356 }
50d16976 1357 is_backend = 1;
81179eec 1358 backend = 1;
50d16976 1359 break;
e46d8091
JA
1360 case 'D':
1361 daemonize_server = 1;
1362 break;
132159a5
JA
1363 case 'P':
1364 fio_net_port = atoi(optarg);
1365 break;
1366 case 'C':
1367 if (is_backend) {
1368 log_err("fio: can't be both client and server\n");
1369 do_exit++;
1370 exit_val = 1;
1371 break;
1372 }
a37f69b7 1373 fio_client_add(optarg);
81179eec 1374 cur_client = optarg;
132159a5 1375 break;
b4692828 1376 default:
c09823ab
JA
1377 do_exit++;
1378 exit_val = 1;
b4692828 1379 break;
ebac4655 1380 }
c7d5c941
JA
1381 if (do_exit)
1382 break;
ebac4655 1383 }
c9fad893 1384
c09823ab
JA
1385 if (do_exit)
1386 exit(exit_val);
536582bf 1387
a37f69b7 1388 if (nr_clients && fio_clients_connect()) {
132159a5
JA
1389 do_exit++;
1390 exit_val = 1;
cdf54d85 1391 return -1;
132159a5
JA
1392 }
1393
81179eec 1394 if (is_backend && backend)
e46d8091 1395 return fio_start_server(daemonize_server);
50d16976 1396
b4692828 1397 if (td) {
7d6a8904 1398 if (!ret)
2dc1bbeb 1399 ret = add_job(td, td->o.name ?: "fio", 0);
972cfd25 1400 }
774a6177 1401
b4692828
JA
1402 while (optind < argc) {
1403 ini_idx++;
1404 ini_file = realloc(ini_file, ini_idx * sizeof(char *));
1405 ini_file[ini_idx - 1] = strdup(argv[optind]);
1406 optind++;
eb8bbf48 1407 }
972cfd25
JA
1408
1409 return ini_idx;
ebac4655
JA
1410}
1411
ebac4655
JA
1412int parse_options(int argc, char *argv[])
1413{
972cfd25
JA
1414 int job_files, i;
1415
b4692828
JA
1416 f_out = stdout;
1417 f_err = stderr;
1418
4c6107ff 1419 fio_options_fill_optstring();
5ec10eaa 1420 fio_options_dup_and_init(l_opts);
b4692828 1421
9d9eb2e7
JA
1422 atexit(free_shm);
1423
ebac4655
JA
1424 if (fill_def_thread())
1425 return 1;
1426
972cfd25 1427 job_files = parse_cmd_line(argc, argv);
ebac4655 1428
cdf54d85
JA
1429 if (job_files > 0) {
1430 for (i = 0; i < job_files; i++) {
1431 if (fill_def_thread())
132159a5 1432 return 1;
cdf54d85
JA
1433 if (nr_clients) {
1434 if (fio_clients_send_ini(ini_file[i]))
1435 return 1;
1436 free(ini_file[i]);
1437 } else if (!is_backend) {
1438 if (parse_jobs_ini(ini_file[i], 0, i))
1439 return 1;
1440 free(ini_file[i]);
1441 }
132159a5 1442 }
972cfd25 1443 }
ebac4655 1444
88c6ed80 1445 free(ini_file);
d23bb327 1446 options_mem_free(&def_thread);
b4692828
JA
1447
1448 if (!thread_number) {
cca73aa7
JA
1449 if (dump_cmdline)
1450 return 0;
07b3232d
JA
1451 if (exec_profile)
1452 return 0;
a37f69b7 1453 if (is_backend || nr_clients)
5c341e9a 1454 return 0;
cca73aa7 1455
cdf54d85
JA
1456 if (job_files > 0) {
1457 log_err("No jobs(s) defined\n\n");
1458 usage(argv[0]);
1459 }
b4692828
JA
1460 return 1;
1461 }
1462
be4ecfdf
JA
1463 if (def_thread.o.gtod_offload) {
1464 fio_gtod_init();
1465 fio_gtod_offload = 1;
1466 fio_gtod_cpu = def_thread.o.gtod_cpu;
1467 }
1468
ca740f4e 1469 log_info("%s\n", fio_version_string);
ebac4655
JA
1470 return 0;
1471}