[PATCH] When logging to a file, stderr should go both to stderr and file
[fio.git] / init.c
CommitLineData
ebac4655
JA
1#include <stdio.h>
2#include <stdlib.h>
3#include <unistd.h>
4#include <fcntl.h>
5#include <ctype.h>
6#include <string.h>
7#include <errno.h>
8#include <sys/ipc.h>
9#include <sys/shm.h>
10#include <sys/types.h>
11#include <sys/stat.h>
12
13#include "fio.h"
14
20dc95c4
JA
15#define DEF_BS (4096)
16#define DEF_TIMEOUT (0)
17#define DEF_RATE_CYCLE (1000)
18#define DEF_ODIRECT (1)
19#define DEF_IO_ENGINE (FIO_SYNCIO)
ebac4655 20#define DEF_IO_ENGINE_NAME "sync"
20dc95c4
JA
21#define DEF_SEQUENTIAL (1)
22#define DEF_RAND_REPEAT (1)
23#define DEF_OVERWRITE (1)
24#define DEF_CREATE (1)
25#define DEF_INVALIDATE (1)
26#define DEF_SYNCIO (0)
27#define DEF_RANDSEED (0xb1899bedUL)
28#define DEF_BWAVGTIME (500)
29#define DEF_CREATE_SER (1)
ebac4655 30#define DEF_CREATE_FSYNC (1)
20dc95c4
JA
31#define DEF_LOOPS (1)
32#define DEF_VERIFY (0)
33#define DEF_STONEWALL (0)
34#define DEF_NUMJOBS (1)
35#define DEF_USE_THREAD (0)
36#define DEF_FILE_SIZE (1024 * 1024 * 1024UL)
37#define DEF_ZONE_SIZE (0)
38#define DEF_ZONE_SKIP (0)
a6ccc7be
JA
39#define DEF_RWMIX_CYCLE (500)
40#define DEF_RWMIX_READ (50)
b6f4d880 41#define DEF_NICE (0)
ebac4655 42
573275e7 43static char fio_version_string[] = "fio 1.4";
ebac4655
JA
44
45static int repeatable = DEF_RAND_REPEAT;
46static char *ini_file;
47static int max_jobs = MAX_JOBS;
48
49struct thread_data def_thread;
50struct thread_data *threads = NULL;
51
52int rate_quit = 0;
53int write_lat_log = 0;
54int write_bw_log = 0;
55int exitall_on_terminate = 0;
c04f7ec3 56unsigned long long mlock_size = 0;
eb8bbf48
JA
57FILE *f_out = NULL;
58FILE *f_err = NULL;
ebac4655 59
ebac4655
JA
60static struct thread_data *get_new_job(int global, struct thread_data *parent)
61{
62 struct thread_data *td;
63
64 if (global)
65 return &def_thread;
66 if (thread_number >= max_jobs)
67 return NULL;
68
69 td = &threads[thread_number++];
ddaeaa5a
JA
70 *td = *parent;
71 td->name[0] = '\0';
ebac4655
JA
72
73 td->fd = -1;
74 td->thread_number = thread_number;
75
ebac4655
JA
76 return td;
77}
78
79static void put_job(struct thread_data *td)
80{
81 memset(&threads[td->thread_number - 1], 0, sizeof(*td));
82 thread_number--;
83}
84
75154845 85static int add_job(struct thread_data *td, const char *jobname, int job_add_num)
ebac4655 86{
3d60d1ed
JA
87 char *ddir_str[] = { "read", "write", "randread", "randwrite",
88 "rw", NULL, "randrw" };
ebac4655
JA
89 struct stat sb;
90 int numjobs, ddir;
91
92#ifndef FIO_HAVE_LIBAIO
93 if (td->io_engine == FIO_LIBAIO) {
3b70d7e5 94 log_err("Linux libaio not available\n");
ebac4655
JA
95 return 1;
96 }
97#endif
98#ifndef FIO_HAVE_POSIXAIO
99 if (td->io_engine == FIO_POSIXAIO) {
3b70d7e5 100 log_err("posix aio not available\n");
ebac4655
JA
101 return 1;
102 }
103#endif
ebac4655
JA
104
105 /*
106 * the def_thread is just for options, it's not a real job
107 */
108 if (td == &def_thread)
109 return 0;
110
111 if (td->io_engine & FIO_SYNCIO)
112 td->iodepth = 1;
113 else {
114 if (!td->iodepth)
115 td->iodepth = 1;
116 }
117
20dc95c4
JA
118 /*
119 * only really works for sequential io for now
120 */
121 if (td->zone_size && !td->sequential)
122 td->zone_size = 0;
123
ebac4655 124 td->filetype = FIO_TYPE_FILE;
0af7b542
JA
125 if (!stat(jobname, &sb)) {
126 if (S_ISBLK(sb.st_mode))
127 td->filetype = FIO_TYPE_BD;
128 else if (S_ISCHR(sb.st_mode))
129 td->filetype = FIO_TYPE_CHAR;
130 }
ebac4655
JA
131
132 if (td->filetype == FIO_TYPE_FILE) {
e9c047a0
JA
133 char tmp[PATH_MAX];
134
ef899b63 135 if (td->directory && td->directory[0] != '\0')
e9c047a0 136 sprintf(tmp, "%s/%s.%d", td->directory, jobname, td->jobnum);
ebac4655 137 else
e9c047a0
JA
138 sprintf(tmp, "%s.%d", jobname, td->jobnum);
139 td->file_name = strdup(tmp);
ebac4655 140 } else
e9c047a0 141 td->file_name = strdup(jobname);
ebac4655 142
bbfd6b00 143 fio_sem_init(&td->mutex, 0);
ebac4655
JA
144
145 td->clat_stat[0].min_val = td->clat_stat[1].min_val = ULONG_MAX;
146 td->slat_stat[0].min_val = td->slat_stat[1].min_val = ULONG_MAX;
147 td->bw_stat[0].min_val = td->bw_stat[1].min_val = ULONG_MAX;
148
149 if (td->min_bs == -1U)
150 td->min_bs = td->bs;
151 if (td->max_bs == -1U)
152 td->max_bs = td->bs;
3d60d1ed 153 if (td_read(td) && !td_rw(td))
ebac4655
JA
154 td->verify = 0;
155
156 if (td->stonewall && td->thread_number > 1)
157 groupid++;
158
159 td->groupid = groupid;
160
161 if (setup_rate(td))
162 goto err;
163
164 if (write_lat_log) {
165 setup_log(&td->slat_log);
166 setup_log(&td->clat_log);
167 }
168 if (write_bw_log)
169 setup_log(&td->bw_log);
170
01452055
JA
171 if (td->name[0] == '\0')
172 snprintf(td->name, sizeof(td->name)-1, "client%d", td->thread_number);
173
3d60d1ed 174 ddir = td->ddir + (!td->sequential << 1) + (td->iomix << 2);
75154845
JA
175
176 if (!job_add_num)
eb8bbf48 177 fprintf(f_out, "%s: (g=%d): rw=%s, odir=%d, bs=%d-%d, rate=%d, ioengine=%s, iodepth=%d\n", td->name, td->groupid, ddir_str[ddir], td->odirect, td->min_bs, td->max_bs, td->rate, td->io_engine_name, td->iodepth);
75154845 178 else if (job_add_num == 1)
eb8bbf48 179 fprintf(f_out, "...\n");
ebac4655
JA
180
181 /*
182 * recurse add identical jobs, clear numjobs and stonewall options
183 * as they don't apply to sub-jobs
184 */
185 numjobs = td->numjobs;
186 while (--numjobs) {
187 struct thread_data *td_new = get_new_job(0, td);
188
189 if (!td_new)
190 goto err;
191
192 td_new->numjobs = 1;
193 td_new->stonewall = 0;
eba09dd3 194 td_new->jobnum = numjobs;
75154845 195 job_add_num = numjobs - 1;
ebac4655 196
75154845 197 if (add_job(td_new, jobname, job_add_num))
ebac4655
JA
198 goto err;
199 }
200 return 0;
201err:
202 put_job(td);
203 return -1;
204}
205
206int init_random_state(struct thread_data *td)
207{
a6ccc7be 208 unsigned long seeds[4];
ebac4655
JA
209 int fd, num_maps, blocks;
210
1ac267bb 211 fd = open("/dev/urandom", O_RDONLY);
ebac4655
JA
212 if (fd == -1) {
213 td_verror(td, errno);
214 return 1;
215 }
216
a6ccc7be 217 if (read(fd, seeds, sizeof(seeds)) < (int) sizeof(seeds)) {
ebac4655
JA
218 td_verror(td, EIO);
219 close(fd);
220 return 1;
221 }
222
223 close(fd);
224
6dfd46b9
JA
225 os_random_seed(seeds[0], &td->bsrange_state);
226 os_random_seed(seeds[1], &td->verify_state);
227 os_random_seed(seeds[2], &td->rwmix_state);
ebac4655
JA
228
229 if (td->sequential)
230 return 0;
231
232 if (repeatable)
a6ccc7be 233 seeds[3] = DEF_RANDSEED;
ebac4655
JA
234
235 blocks = (td->io_size + td->min_bs - 1) / td->min_bs;
236 num_maps = blocks / BLOCKS_PER_MAP;
237 td->file_map = malloc(num_maps * sizeof(long));
238 td->num_maps = num_maps;
239 memset(td->file_map, 0, num_maps * sizeof(long));
240
6dfd46b9 241 os_random_seed(seeds[3], &td->random_state);
ebac4655
JA
242 return 0;
243}
244
245static void fill_cpu_mask(os_cpu_mask_t cpumask, int cpu)
246{
247#ifdef FIO_HAVE_CPU_AFFINITY
248 unsigned int i;
249
250 CPU_ZERO(&cpumask);
251
252 for (i = 0; i < sizeof(int) * 8; i++) {
253 if ((1 << i) & cpu)
254 CPU_SET(i, &cpumask);
255 }
256#endif
257}
258
259static unsigned long get_mult(char c)
260{
261 switch (c) {
262 case 'k':
263 case 'K':
264 return 1024;
265 case 'm':
266 case 'M':
267 return 1024 * 1024;
268 case 'g':
269 case 'G':
270 return 1024 * 1024 * 1024;
271 default:
272 return 1;
273 }
274}
275
276/*
277 * convert string after '=' into decimal value, noting any size suffix
278 */
279static int str_cnv(char *p, unsigned long long *val)
280{
281 char *str;
282 int len;
283
f5d3e5ec 284 str = strchr(p, '=');
ebac4655
JA
285 if (!str)
286 return 1;
287
288 str++;
289 len = strlen(str);
290
291 *val = strtoul(str, NULL, 10);
292 if (*val == ULONG_MAX && errno == ERANGE)
293 return 1;
294
9d0d4247 295 *val *= get_mult(str[len - 1]);
ebac4655
JA
296 return 0;
297}
298
299static int check_strcnv(char *p, char *name, unsigned long long *val)
300{
20dc95c4 301 if (strncmp(p, name, strlen(name) - 1))
ebac4655
JA
302 return 1;
303
304 return str_cnv(p, val);
305}
306
307static void strip_blank_front(char **p)
308{
309 char *s = *p;
310
4ae3f763 311 while (isspace(*s))
ebac4655
JA
312 s++;
313}
314
315static void strip_blank_end(char *p)
316{
4ae3f763 317 char *s = p + strlen(p) - 1;
ebac4655 318
4ae3f763
JA
319 while (isspace(*s) || iscntrl(*s))
320 s--;
aea47d44 321
4ae3f763 322 *(s + 1) = '\0';
aea47d44
JA
323}
324
ebac4655
JA
325typedef int (str_cb_fn)(struct thread_data *, char *);
326
327static int check_str(char *p, char *name, str_cb_fn *cb, struct thread_data *td)
328{
843a7413 329 char *s;
ebac4655 330
843a7413
JA
331 if (strncmp(p, name, strlen(name)))
332 return 1;
333
334 s = strstr(p, name);
ebac4655
JA
335 if (!s)
336 return 1;
337
f5d3e5ec 338 s = strchr(s, '=');
ebac4655
JA
339 if (!s)
340 return 1;
341
342 s++;
343 strip_blank_front(&s);
344 return cb(td, s);
345}
346
347static int check_strstore(char *p, char *name, char *dest)
348{
843a7413 349 char *s;
ebac4655 350
843a7413
JA
351 if (strncmp(p, name, strlen(name)))
352 return 1;
353
354 s = strstr(p, name);
ebac4655
JA
355 if (!s)
356 return 1;
357
f5d3e5ec 358 s = strchr(p, '=');
ebac4655
JA
359 if (!s)
360 return 1;
361
362 s++;
363 strip_blank_front(&s);
364
365 strcpy(dest, s);
ebac4655
JA
366 return 0;
367}
368
01617be6 369static int __check_range(char *str, unsigned long *val)
ebac4655 370{
01617be6 371 char suffix;
ebac4655 372
01617be6
JA
373 if (sscanf(str, "%lu%c", val, &suffix) == 2) {
374 *val *= get_mult(suffix);
ebac4655
JA
375 return 0;
376 }
377
01617be6 378 if (sscanf(str, "%lu", val) == 1)
ebac4655 379 return 0;
ebac4655 380
01617be6
JA
381 return 1;
382}
383
384static int check_range(char *p, char *name, unsigned long *s, unsigned long *e)
385{
386 char option[128];
387 char *str, *p1, *p2;
388
843a7413
JA
389 if (strncmp(p, name, strlen(name)))
390 return 1;
391
01617be6
JA
392 strcpy(option, p);
393 p = option;
394
395 str = strstr(p, name);
396 if (!str)
397 return 1;
ebac4655 398
01617be6
JA
399 p += strlen(name);
400
401 str = strchr(p, '=');
402 if (!str)
403 return 1;
404
405 /*
406 * 'p' now holds whatever is after the '=' sign
407 */
408 p1 = str + 1;
409
410 /*
411 * terminate p1 at the '-' sign
412 */
413 p = strchr(p1, '-');
414 if (!p)
415 return 1;
416
417 p2 = p + 1;
418 *p = '\0';
419
420 if (!__check_range(p1, s) && !__check_range(p2, e))
ebac4655
JA
421 return 0;
422
423 return 1;
ebac4655
JA
424}
425
426static int check_int(char *p, char *name, unsigned int *val)
427{
f5d3e5ec 428 char *str;
ebac4655 429
b6754f9d
JA
430 if (strncmp(p, name, strlen(name)))
431 return 1;
432
f5d3e5ec
JA
433 str = strstr(p, name);
434 if (!str)
435 return 1;
436
437 str = strchr(p, '=');
438 if (!str)
439 return 1;
440
441 str++;
ebac4655 442
f5d3e5ec 443 if (sscanf(str, "%u", val) == 1)
ebac4655
JA
444 return 0;
445
446 return 1;
447}
448
449static int check_strset(char *p, char *name)
450{
451 return strncmp(p, name, strlen(name));
452}
453
454static int is_empty_or_comment(char *line)
455{
456 unsigned int i;
457
458 for (i = 0; i < strlen(line); i++) {
459 if (line[i] == ';')
460 return 1;
461 if (!isspace(line[i]) && !iscntrl(line[i]))
462 return 0;
463 }
464
465 return 1;
466}
467
468static int str_rw_cb(struct thread_data *td, char *mem)
469{
470 if (!strncmp(mem, "read", 4) || !strncmp(mem, "0", 1)) {
471 td->ddir = DDIR_READ;
472 td->sequential = 1;
473 return 0;
474 } else if (!strncmp(mem, "randread", 8)) {
475 td->ddir = DDIR_READ;
476 td->sequential = 0;
477 return 0;
478 } else if (!strncmp(mem, "write", 5) || !strncmp(mem, "1", 1)) {
479 td->ddir = DDIR_WRITE;
480 td->sequential = 1;
481 return 0;
482 } else if (!strncmp(mem, "randwrite", 9)) {
483 td->ddir = DDIR_WRITE;
484 td->sequential = 0;
485 return 0;
3d60d1ed
JA
486 } else if (!strncmp(mem, "rw", 2)) {
487 td->ddir = 0;
488 td->iomix = 1;
489 td->sequential = 1;
490 return 0;
491 } else if (!strncmp(mem, "randrw", 6)) {
492 td->ddir = 0;
493 td->iomix = 1;
494 td->sequential = 0;
495 return 0;
ebac4655
JA
496 }
497
3b70d7e5 498 log_err("fio: data direction: read, write, randread, randwrite, rw, randrw\n");
ebac4655
JA
499 return 1;
500}
501
502static int str_verify_cb(struct thread_data *td, char *mem)
503{
504 if (!strncmp(mem, "0", 1)) {
505 td->verify = VERIFY_NONE;
506 return 0;
507 } else if (!strncmp(mem, "md5", 3) || !strncmp(mem, "1", 1)) {
508 td->verify = VERIFY_MD5;
509 return 0;
510 } else if (!strncmp(mem, "crc32", 5)) {
511 td->verify = VERIFY_CRC32;
512 return 0;
513 }
514
3b70d7e5 515 log_err("fio: verify types: md5, crc32\n");
ebac4655
JA
516 return 1;
517}
518
519static int str_mem_cb(struct thread_data *td, char *mem)
520{
521 if (!strncmp(mem, "malloc", 6)) {
522 td->mem_type = MEM_MALLOC;
523 return 0;
524 } else if (!strncmp(mem, "shm", 3)) {
525 td->mem_type = MEM_SHM;
526 return 0;
527 } else if (!strncmp(mem, "mmap", 4)) {
528 td->mem_type = MEM_MMAP;
529 return 0;
530 }
531
3b70d7e5 532 log_err("fio: mem type: malloc, shm, mmap\n");
ebac4655
JA
533 return 1;
534}
535
536static int str_ioengine_cb(struct thread_data *td, char *str)
537{
538 if (!strncmp(str, "linuxaio", 8) || !strncmp(str, "aio", 3) ||
539 !strncmp(str, "libaio", 6)) {
540 strcpy(td->io_engine_name, "libaio");
541 td->io_engine = FIO_LIBAIO;
542 return 0;
543 } else if (!strncmp(str, "posixaio", 8)) {
544 strcpy(td->io_engine_name, "posixaio");
545 td->io_engine = FIO_POSIXAIO;
546 return 0;
547 } else if (!strncmp(str, "sync", 4)) {
548 strcpy(td->io_engine_name, "sync");
549 td->io_engine = FIO_SYNCIO;
550 return 0;
551 } else if (!strncmp(str, "mmap", 4)) {
552 strcpy(td->io_engine_name, "mmap");
553 td->io_engine = FIO_MMAPIO;
554 return 0;
555 } else if (!strncmp(str, "sgio", 4)) {
556 strcpy(td->io_engine_name, "sgio");
557 td->io_engine = FIO_SGIO;
558 return 0;
8756e4d4
JA
559 } else if (!strncmp(str, "splice", 6)) {
560 strcpy(td->io_engine_name, "splice");
561 td->io_engine = FIO_SPLICEIO;
562 return 0;
ebac4655
JA
563 }
564
3b70d7e5 565 log_err("fio: ioengine: { linuxaio, aio, libaio }, posixaio, sync, mmap, sgio, splice\n");
ebac4655
JA
566 return 1;
567}
568
07261983
JA
569/*
570 * This is our [ini] type file parser.
571 */
ebac4655
JA
572int parse_jobs_ini(char *file)
573{
a6ccc7be 574 unsigned int prioclass, prio, cpu, global, il;
ebac4655
JA
575 unsigned long long ull;
576 unsigned long ul1, ul2;
577 struct thread_data *td;
ef899b63 578 char *string, *name, *tmpbuf;
ebac4655
JA
579 fpos_t off;
580 FILE *f;
581 char *p;
45410acb 582 int ret = 0;
ebac4655
JA
583
584 f = fopen(file, "r");
585 if (!f) {
aea47d44 586 perror("fopen job file");
ebac4655
JA
587 return 1;
588 }
589
590 string = malloc(4096);
591 name = malloc(256);
ef899b63 592 tmpbuf = malloc(4096);
ebac4655
JA
593
594 while ((p = fgets(string, 4096, f)) != NULL) {
45410acb
JA
595 if (ret)
596 break;
ebac4655
JA
597 if (is_empty_or_comment(p))
598 continue;
599 if (sscanf(p, "[%s]", name) != 1)
600 continue;
601
602 global = !strncmp(name, "global", 6);
603
604 name[strlen(name) - 1] = '\0';
605
606 td = get_new_job(global, &def_thread);
45410acb
JA
607 if (!td) {
608 ret = 1;
609 break;
610 }
ebac4655 611
ebac4655
JA
612 fgetpos(f, &off);
613 while ((p = fgets(string, 4096, f)) != NULL) {
614 if (is_empty_or_comment(p))
615 continue;
616 if (strstr(p, "["))
617 break;
b6754f9d 618 strip_blank_front(&p);
4ae3f763 619 strip_blank_end(p);
aea47d44 620
ebac4655
JA
621 if (!check_int(p, "prio", &prio)) {
622#ifndef FIO_HAVE_IOPRIO
3b70d7e5 623 log_err("io priorities not available\n");
45410acb
JA
624 ret = 1;
625 break;
ebac4655 626#endif
8756e4d4 627 td->ioprio |= prio;
ebac4655
JA
628 fgetpos(f, &off);
629 continue;
630 }
631 if (!check_int(p, "prioclass", &prioclass)) {
632#ifndef FIO_HAVE_IOPRIO
3b70d7e5 633 log_err("io priorities not available\n");
45410acb
JA
634 ret = 1;
635 break;
5c4e1dbc 636#else
8756e4d4 637 td->ioprio |= prioclass << IOPRIO_CLASS_SHIFT;
ebac4655
JA
638 fgetpos(f, &off);
639 continue;
5c4e1dbc 640#endif
ebac4655 641 }
e9c047a0
JA
642 if (!check_int(p, "direct", &il)) {
643 td->odirect = il;
ebac4655
JA
644 fgetpos(f, &off);
645 continue;
646 }
647 if (!check_int(p, "rate", &td->rate)) {
648 fgetpos(f, &off);
649 continue;
650 }
651 if (!check_int(p, "ratemin", &td->ratemin)) {
652 fgetpos(f, &off);
653 continue;
654 }
655 if (!check_int(p, "ratecycle", &td->ratecycle)) {
656 fgetpos(f, &off);
657 continue;
658 }
659 if (!check_int(p, "thinktime", &td->thinktime)) {
660 fgetpos(f, &off);
661 continue;
662 }
663 if (!check_int(p, "cpumask", &cpu)) {
664#ifndef FIO_HAVE_CPU_AFFINITY
3b70d7e5 665 log_err("cpu affinity not available\n");
45410acb
JA
666 ret = 1;
667 break;
ebac4655
JA
668#endif
669 fill_cpu_mask(td->cpumask, cpu);
670 fgetpos(f, &off);
671 continue;
672 }
673 if (!check_int(p, "fsync", &td->fsync_blocks)) {
674 fgetpos(f, &off);
fc1a4713 675 td->end_fsync = 1;
ebac4655
JA
676 continue;
677 }
678 if (!check_int(p, "startdelay", &td->start_delay)) {
679 fgetpos(f, &off);
680 continue;
681 }
682 if (!check_int(p, "timeout", &td->timeout)) {
683 fgetpos(f, &off);
684 continue;
685 }
e9c047a0
JA
686 if (!check_int(p, "invalidate", &il)) {
687 td->invalidate_cache = il;
ebac4655
JA
688 fgetpos(f, &off);
689 continue;
690 }
691 if (!check_int(p, "iodepth", &td->iodepth)) {
692 fgetpos(f, &off);
693 continue;
694 }
e9c047a0
JA
695 if (!check_int(p, "sync", &il)) {
696 td->sync_io = il;
ebac4655
JA
697 fgetpos(f, &off);
698 continue;
699 }
700 if (!check_int(p, "bwavgtime", &td->bw_avg_time)) {
701 fgetpos(f, &off);
702 continue;
703 }
e9c047a0
JA
704 if (!check_int(p, "create_serialize", &il)) {
705 td->create_serialize = il;
ebac4655
JA
706 fgetpos(f, &off);
707 continue;
708 }
e9c047a0
JA
709 if (!check_int(p, "create_fsync", &il)) {
710 td->create_fsync = il;
ebac4655
JA
711 fgetpos(f, &off);
712 continue;
713 }
e9c047a0
JA
714 if (!check_int(p, "end_fsync", &il)) {
715 td->end_fsync = il;
fc1a4713
JA
716 fgetpos(f, &off);
717 continue;
718 }
ebac4655
JA
719 if (!check_int(p, "loops", &td->loops)) {
720 fgetpos(f, &off);
721 continue;
722 }
723 if (!check_int(p, "numjobs", &td->numjobs)) {
724 fgetpos(f, &off);
725 continue;
726 }
e9c047a0
JA
727 if (!check_int(p, "overwrite", &il)) {
728 td->overwrite = il;
ebac4655
JA
729 fgetpos(f, &off);
730 continue;
731 }
a6ccc7be
JA
732 if (!check_int(p, "rwmixcycle", &td->rwmixcycle)) {
733 fgetpos(f, &off);
734 continue;
735 }
736 if (!check_int(p, "rwmixread", &il)) {
737 if (il > 100)
738 il = 100;
739 td->rwmixread = il;
740 fgetpos(f, &off);
741 continue;
742 }
743 if (!check_int(p, "rwmixwrite", &il)) {
744 if (il > 100)
745 il = 100;
746 td->rwmixread = 100 - il;
747 fgetpos(f, &off);
748 continue;
749 }
b6f4d880
JA
750 if (!check_int(p, "nice", &td->nice)) {
751 fgetpos(f, &off);
752 continue;
753 }
ebac4655
JA
754 if (!check_range(p, "bsrange", &ul1, &ul2)) {
755 if (ul1 > ul2) {
756 td->max_bs = ul1;
757 td->min_bs = ul2;
758 } else {
759 td->max_bs = ul2;
760 td->min_bs = ul1;
761 }
762 fgetpos(f, &off);
763 continue;
764 }
765 if (!check_strcnv(p, "bs", &ull)) {
766 td->bs = ull;
767 fgetpos(f, &off);
768 continue;
769 }
770 if (!check_strcnv(p, "size", &td->file_size)) {
771 fgetpos(f, &off);
772 continue;
773 }
774 if (!check_strcnv(p, "offset", &td->file_offset)) {
775 fgetpos(f, &off);
20dc95c4
JA
776 continue;
777 }
778 if (!check_strcnv(p, "zonesize", &td->zone_size)) {
779 fgetpos(f, &off);
780 continue;
781 }
782 if (!check_strcnv(p, "zoneskip", &td->zone_skip)) {
783 fgetpos(f, &off);
ebac4655
JA
784 continue;
785 }
c04f7ec3
JA
786 if (!check_strcnv(p, "lockmem", &mlock_size)) {
787 fgetpos(f, &off);
788 continue;
789 }
ef899b63
JA
790 if (!check_strstore(p, "directory", tmpbuf)) {
791 td->directory = strdup(tmpbuf);
ebac4655
JA
792 fgetpos(f, &off);
793 continue;
794 }
01452055
JA
795 if (!check_strstore(p, "name", tmpbuf)) {
796 snprintf(td->name, sizeof(td->name)-1, "%s%d", tmpbuf, td->thread_number);
797 fgetpos(f, &off);
798 continue;
799 }
ebac4655
JA
800 if (!check_str(p, "mem", str_mem_cb, td)) {
801 fgetpos(f, &off);
802 continue;
803 }
804 if (!check_str(p, "verify", str_verify_cb, td)) {
805 fgetpos(f, &off);
806 continue;
807 }
808 if (!check_str(p, "rw", str_rw_cb, td)) {
809 fgetpos(f, &off);
810 continue;
811 }
812 if (!check_str(p, "ioengine", str_ioengine_cb, td)) {
813 fgetpos(f, &off);
814 continue;
815 }
816 if (!check_strset(p, "create")) {
817 td->create_file = 1;
818 fgetpos(f, &off);
819 continue;
820 }
821 if (!check_strset(p, "exitall")) {
822 exitall_on_terminate = 1;
823 fgetpos(f, &off);
824 continue;
825 }
826 if (!check_strset(p, "stonewall")) {
827 td->stonewall = 1;
828 fgetpos(f, &off);
829 continue;
830 }
831 if (!check_strset(p, "thread")) {
832 td->use_thread = 1;
833 fgetpos(f, &off);
834 continue;
835 }
80b9feb0 836 if (!check_strstore(p, "iolog", tmpbuf)) {
4f693b9d 837 if (td->write_iolog) {
3b70d7e5 838 log_err("fio: read iolog overrides given write_iolog\n");
af8c0b4f 839 free(td->iolog_file);
4f693b9d
JA
840 td->write_iolog = 0;
841 }
80b9feb0 842 td->iolog_file = strdup(tmpbuf);
843a7413 843 td->read_iolog = 1;
843a7413
JA
844 fgetpos(f, &off);
845 continue;
846 }
af8c0b4f
JA
847 if (!check_strstore(p, "write_iolog", tmpbuf)) {
848 if (!td->read_iolog) {
849 td->iolog_file = strdup(tmpbuf);
850 td->write_iolog = 1;
4f693b9d 851 } else
3b70d7e5 852 log_err("fio: read iolog overrides given write_iolog\n");
aea47d44
JA
853 fgetpos(f, &off);
854 continue;
855 }
80b9feb0
JA
856 if (!check_strstore(p, "exec_prerun", tmpbuf)) {
857 td->exec_prerun = strdup(tmpbuf);
4e0ba8af
JA
858 fgetpos(f, &off);
859 continue;
860 }
80b9feb0
JA
861 if (!check_strstore(p, "exec_postrun", tmpbuf)) {
862 td->exec_postrun = strdup(tmpbuf);
4e0ba8af
JA
863 fgetpos(f, &off);
864 continue;
865 }
80b9feb0 866 if (!check_strstore(p, "ioscheduler", tmpbuf)) {
22f78b32 867#ifndef FIO_HAVE_IOSCHED_SWITCH
3b70d7e5 868 log_err("io scheduler switching not available\n");
22f78b32
JA
869 ret = 1;
870 break;
871#else
80b9feb0 872 td->ioscheduler = strdup(tmpbuf);
da86774e
JA
873 fgetpos(f, &off);
874 continue;
22f78b32 875#endif
da86774e 876 }
ebac4655 877
45410acb
JA
878 /*
879 * Don't break here, continue parsing options so we
880 * dump all the bad ones. Makes trial/error fixups
881 * easier on the user.
882 */
ebac4655 883 printf("Client%d: bad option %s\n",td->thread_number,p);
45410acb 884 ret = 1;
ebac4655 885 }
ebac4655 886
45410acb
JA
887 if (!ret) {
888 fsetpos(f, &off);
889 ret = add_job(td, name, 0);
890 }
891 if (ret)
892 break;
ebac4655
JA
893 }
894
895 free(string);
896 free(name);
ef899b63 897 free(tmpbuf);
ebac4655 898 fclose(f);
45410acb 899 return ret;
ebac4655
JA
900}
901
902static int fill_def_thread(void)
903{
904 memset(&def_thread, 0, sizeof(def_thread));
905
906 if (fio_getaffinity(getpid(), &def_thread.cpumask) == -1) {
907 perror("sched_getaffinity");
908 return 1;
909 }
910
911 /*
912 * fill globals
913 */
914 def_thread.ddir = DDIR_READ;
3d60d1ed 915 def_thread.iomix = 0;
ebac4655
JA
916 def_thread.bs = DEF_BS;
917 def_thread.min_bs = -1;
918 def_thread.max_bs = -1;
919 def_thread.io_engine = DEF_IO_ENGINE;
920 strcpy(def_thread.io_engine_name, DEF_IO_ENGINE_NAME);
921 def_thread.odirect = DEF_ODIRECT;
922 def_thread.ratecycle = DEF_RATE_CYCLE;
923 def_thread.sequential = DEF_SEQUENTIAL;
924 def_thread.timeout = DEF_TIMEOUT;
925 def_thread.create_file = DEF_CREATE;
926 def_thread.overwrite = DEF_OVERWRITE;
927 def_thread.invalidate_cache = DEF_INVALIDATE;
928 def_thread.sync_io = DEF_SYNCIO;
929 def_thread.mem_type = MEM_MALLOC;
930 def_thread.bw_avg_time = DEF_BWAVGTIME;
931 def_thread.create_serialize = DEF_CREATE_SER;
932 def_thread.create_fsync = DEF_CREATE_FSYNC;
933 def_thread.loops = DEF_LOOPS;
934 def_thread.verify = DEF_VERIFY;
935 def_thread.stonewall = DEF_STONEWALL;
936 def_thread.numjobs = DEF_NUMJOBS;
937 def_thread.use_thread = DEF_USE_THREAD;
a6ccc7be
JA
938 def_thread.rwmixcycle = DEF_RWMIX_CYCLE;
939 def_thread.rwmixread = DEF_RWMIX_READ;
b6f4d880 940 def_thread.nice = DEF_NICE;
ebac4655
JA
941#ifdef FIO_HAVE_DISK_UTIL
942 def_thread.do_disk_util = 1;
943#endif
944
945 return 0;
946}
947
4785f995
JA
948static void usage(char *name)
949{
950 printf("%s\n", fio_version_string);
951 printf("\t-s IO is sequential\n");
952 printf("\t-b Block size in KiB for each IO\n");
953 printf("\t-t Runtime in seconds\n");
954 printf("\t-R Exit all threads on failure to meet rate goal\n");
955 printf("\t-o Use O_DIRECT\n");
956 printf("\t-l Generate per-job latency logs\n");
957 printf("\t-w Generate per-job bandwidth logs\n");
958 printf("\t-f Job file (Required)\n");
959 printf("\t-v Print version info and exit\n");
960}
961
ebac4655
JA
962static void parse_cmd_line(int argc, char *argv[])
963{
964 int c;
965
eb8bbf48 966 while ((c = getopt(argc, argv, "s:b:t:r:R:o:f:lwvhO:")) != EOF) {
ebac4655
JA
967 switch (c) {
968 case 's':
969 def_thread.sequential = !!atoi(optarg);
970 break;
971 case 'b':
972 def_thread.bs = atoi(optarg);
973 def_thread.bs <<= 10;
974 if (!def_thread.bs) {
975 printf("bad block size\n");
976 def_thread.bs = DEF_BS;
977 }
978 break;
979 case 't':
980 def_thread.timeout = atoi(optarg);
981 break;
982 case 'r':
983 repeatable = !!atoi(optarg);
984 break;
985 case 'R':
986 rate_quit = !!atoi(optarg);
987 break;
988 case 'o':
989 def_thread.odirect = !!atoi(optarg);
990 break;
991 case 'f':
992 ini_file = strdup(optarg);
993 break;
994 case 'l':
995 write_lat_log = 1;
996 break;
997 case 'w':
998 write_bw_log = 1;
999 break;
eb8bbf48
JA
1000 case 'O':
1001 f_out = fopen(optarg, "w+");
1002 if (!f_out) {
1003 perror("fopen output");
1004 exit(1);
1005 }
1006 f_err = f_out;
1007 break;
4785f995
JA
1008 case 'h':
1009 usage(argv[0]);
1010 exit(0);
ebac4655
JA
1011 case 'v':
1012 printf("%s\n", fio_version_string);
1013 exit(0);
1014 }
1015 }
c9fad893
JA
1016
1017 if (!ini_file && argc > 1 && argv[argc - 1][0] != '-')
1018 ini_file = strdup(argv[argc - 1]);
eb8bbf48
JA
1019 if (!f_out) {
1020 f_out = stdout;
1021 f_err = stderr;
1022 }
ebac4655
JA
1023}
1024
1025static void free_shm(void)
1026{
1027 struct shmid_ds sbuf;
1028
1029 if (threads) {
2c0ecd28 1030 shmdt((void *) threads);
ebac4655
JA
1031 threads = NULL;
1032 shmctl(shm_id, IPC_RMID, &sbuf);
1033 }
1034}
1035
1036static int setup_thread_area(void)
1037{
1038 /*
1039 * 1024 is too much on some machines, scale max_jobs if
1040 * we get a failure that looks like too large a shm segment
1041 */
1042 do {
1043 int s = max_jobs * sizeof(struct thread_data);
1044
1045 shm_id = shmget(0, s, IPC_CREAT | 0600);
1046 if (shm_id != -1)
1047 break;
1048 if (errno != EINVAL) {
1049 perror("shmget");
1050 break;
1051 }
1052
1053 max_jobs >>= 1;
1054 } while (max_jobs);
1055
1056 if (shm_id == -1)
1057 return 1;
1058
1059 threads = shmat(shm_id, NULL, 0);
1060 if (threads == (void *) -1) {
1061 perror("shmat");
1062 return 1;
1063 }
1064
1065 atexit(free_shm);
1066 return 0;
1067}
1068
1069int parse_options(int argc, char *argv[])
1070{
1071 if (setup_thread_area())
1072 return 1;
1073 if (fill_def_thread())
1074 return 1;
1075
1076 parse_cmd_line(argc, argv);
1077
1078 if (!ini_file) {
3b70d7e5 1079 log_err("Need job file\n");
4785f995 1080 usage(argv[0]);
ebac4655
JA
1081 return 1;
1082 }
1083
07261983 1084 if (parse_jobs_ini(ini_file))
ebac4655
JA
1085 return 1;
1086
1087 return 0;
1088}