projects / fio.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] Kill old libaio/posixaio checks
[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>
b4692828
JA		 11#include <getopt.h>
12#include <assert.h>
ebac4655
JA		 13#include <sys/ipc.h>
14#include <sys/shm.h>
15#include <sys/types.h>
16#include <sys/stat.h>
17
18#include "fio.h"
cb2c86fd 19#include "parse.h"
ebac4655 20
906c8d75
JA		 21/*
22 * The default options
23 */
20dc95c4
JA		 24#define DEF_BS (4096)
25#define DEF_TIMEOUT (0)
26#define DEF_RATE_CYCLE (1000)
27#define DEF_ODIRECT (1)
28#define DEF_IO_ENGINE (FIO_SYNCIO)
ebac4655 29#define DEF_IO_ENGINE_NAME "sync"
20dc95c4
JA		 30#define DEF_SEQUENTIAL (1)
31#define DEF_RAND_REPEAT (1)
32#define DEF_OVERWRITE (1)
20dc95c4
JA		 33#define DEF_INVALIDATE (1)
34#define DEF_SYNCIO (0)
35#define DEF_RANDSEED (0xb1899bedUL)
36#define DEF_BWAVGTIME (500)
37#define DEF_CREATE_SER (1)
ebac4655 38#define DEF_CREATE_FSYNC (1)
20dc95c4
JA		 39#define DEF_LOOPS (1)
40#define DEF_VERIFY (0)
41#define DEF_STONEWALL (0)
42#define DEF_NUMJOBS (1)
43#define DEF_USE_THREAD (0)
44#define DEF_FILE_SIZE (1024 * 1024 * 1024UL)
45#define DEF_ZONE_SIZE (0)
46#define DEF_ZONE_SKIP (0)
a6ccc7be
JA		 47#define DEF_RWMIX_CYCLE (500)
48#define DEF_RWMIX_READ (50)
b6f4d880 49#define DEF_NICE (0)
53cdc686 50#define DEF_NR_FILES (1)
f6cbb269 51#define DEF_UNLINK (0)
ec94ec56
JA		 52#define DEF_WRITE_BW_LOG (0)
53#define DEF_WRITE_LAT_LOG (0)
bb8895e0 54#define DEF_NO_RAND_MAP (0)
ebac4655 55
e1f36503
JA		 56#define td_var_offset(var) ((size_t) &((struct thread_data *)0)->var)
57
b4692828
JA		 58static int str_rw_cb(void *, const char *);
59static int str_ioengine_cb(void *, const char *);
60static int str_mem_cb(void *, const char *);
61static int str_verify_cb(void *, const char *);
e1f36503
JA		 62static int str_lockmem_cb(void *, unsigned long *);
63static int str_prio_cb(void *, unsigned int *);
64static int str_prioclass_cb(void *, unsigned int *);
65static int str_exitall_cb(void);
66static int str_cpumask_cb(void *, unsigned int *);
67
68/*
69 * Map of job/command line options
70 */
71static struct fio_option options[] = {
72 {
73 .name = "name",
74 .type = FIO_OPT_STR_STORE,
75 .off1 = td_var_offset(name),
76 },
77 {
78 .name = "directory",
79 .type = FIO_OPT_STR_STORE,
80 .off1 = td_var_offset(directory),
81 },
82 {
83 .name = "filename",
84 .type = FIO_OPT_STR_STORE,
85 .off1 = td_var_offset(filename),
86 },
87 {
88 .name = "rw",
89 .type = FIO_OPT_STR,
90 .cb = str_rw_cb,
91 },
92 {
93 .name = "ioengine",
94 .type = FIO_OPT_STR,
95 .cb = str_ioengine_cb,
96 },
97 {
98 .name = "mem",
99 .type = FIO_OPT_STR,
100 .cb = str_mem_cb,
101 },
102 {
103 .name = "verify",
104 .type = FIO_OPT_STR,
105 .cb = str_verify_cb,
106 },
107 {
108 .name = "write_iolog",
076efc7c
JA		 109 .type = FIO_OPT_STR_STORE,
110 .off1 = td_var_offset(write_iolog_file),
e1f36503
JA		 111 },
112 {
076efc7c 113 .name = "read_iolog",
e1f36503 114 .type = FIO_OPT_STR_STORE,
076efc7c 115 .off1 = td_var_offset(read_iolog_file),
e1f36503
JA		 116 },
117 {
118 .name = "exec_prerun",
119 .type = FIO_OPT_STR_STORE,
120 .off1 = td_var_offset(exec_prerun),
121 },
122 {
123 .name = "exec_postrun",
124 .type = FIO_OPT_STR_STORE,
125 .off1 = td_var_offset(exec_postrun),
126 },
127#ifdef FIO_HAVE_IOSCHED_SWITCH
128 {
129 .name = "ioscheduler",
130 .type = FIO_OPT_STR_STORE,
131 .off1 = td_var_offset(ioscheduler),
132 },
133#endif
134 {
135 .name = "size",
136 .type = FIO_OPT_STR_VAL,
137 .off1 = td_var_offset(total_file_size),
138 },
139 {
140 .name = "bs",
75e6f36f 141 .type = FIO_OPT_STR_VAL_INT,
a00735e6
JA		 142 .off1 = td_var_offset(bs[DDIR_READ]),
143 },
144 {
145 .name = "read_bs",
75e6f36f 146 .type = FIO_OPT_STR_VAL_INT,
a00735e6
JA		 147 .off1 = td_var_offset(bs[DDIR_READ]),
148 },
149 {
150 .name = "write_bs",
75e6f36f 151 .type = FIO_OPT_STR_VAL_INT,
a00735e6 152 .off1 = td_var_offset(bs[DDIR_WRITE]),
e1f36503
JA		 153 },
154 {
155 .name = "offset",
156 .type = FIO_OPT_STR_VAL,
157 .off1 = td_var_offset(start_offset),
158 },
159 {
160 .name = "zonesize",
161 .type = FIO_OPT_STR_VAL,
162 .off1 = td_var_offset(zone_size),
163 },
164 {
165 .name = "zoneskip",
166 .type = FIO_OPT_STR_VAL,
167 .off1 = td_var_offset(zone_skip),
168 },
169 {
170 .name = "lockmem",
171 .type = FIO_OPT_STR_VAL,
172 .cb = str_lockmem_cb,
173 },
174 {
175 .name = "bsrange",
176 .type = FIO_OPT_RANGE,
a00735e6
JA		 177 .off1 = td_var_offset(min_bs[DDIR_READ]),
178 .off2 = td_var_offset(max_bs[DDIR_READ]),
179 },
180 {
181 .name = "read_bsrange",
182 .type = FIO_OPT_RANGE,
183 .off1 = td_var_offset(min_bs[DDIR_READ]),
184 .off2 = td_var_offset(max_bs[DDIR_READ]),
185 },
186 {
187 .name = "write_bsrange",
188 .type = FIO_OPT_RANGE,
189 .off1 = td_var_offset(min_bs[DDIR_WRITE]),
190 .off2 = td_var_offset(max_bs[DDIR_WRITE]),
e1f36503
JA		 191 },
192 {
193 .name = "nrfiles",
194 .type = FIO_OPT_INT,
195 .off1 = td_var_offset(nr_files),
196 },
197 {
198 .name = "iodepth",
199 .type = FIO_OPT_INT,
200 .off1 = td_var_offset(iodepth),
201 },
202 {
203 .name = "fsync",
204 .type = FIO_OPT_INT,
205 .off1 = td_var_offset(fsync_blocks),
206 },
207 {
208 .name = "rwmixcycle",
209 .type = FIO_OPT_INT,
210 .off1 = td_var_offset(rwmixcycle),
211 },
212 {
213 .name = "rwmixread",
214 .type = FIO_OPT_INT,
215 .off1 = td_var_offset(rwmixread),
216 .max_val= 100,
217 },
218 {
219 .name = "rwmixwrite",
220 .type = FIO_OPT_INT,
221 .off1 = td_var_offset(rwmixwrite),
222 .max_val= 100,
223 },
224 {
225 .name = "nice",
226 .type = FIO_OPT_INT,
227 .off1 = td_var_offset(nice),
228 },
229#ifdef FIO_HAVE_IOPRIO
230 {
231 .name = "prio",
232 .type = FIO_OPT_INT,
233 .cb = str_prio_cb,
234 },
235 {
236 .name = "prioclass",
237 .type = FIO_OPT_INT,
238 .cb = str_prioclass_cb,
239 },
240#endif
241 {
242 .name = "thinktime",
243 .type = FIO_OPT_INT,
244 .off1 = td_var_offset(thinktime)
245 },
246 {
247 .name = "rate",
248 .type = FIO_OPT_INT,
249 .off1 = td_var_offset(rate)
250 },
251 {
252 .name = "ratemin",
253 .type = FIO_OPT_INT,
254 .off1 = td_var_offset(ratemin)
255 },
256 {
257 .name = "ratecycle",
258 .type = FIO_OPT_INT,
259 .off1 = td_var_offset(ratecycle)
260 },
261 {
262 .name = "startdelay",
263 .type = FIO_OPT_INT,
264 .off1 = td_var_offset(start_delay)
265 },
266 {
267 .name = "timeout",
268 .type = FIO_OPT_STR_VAL_TIME,
269 .off1 = td_var_offset(timeout)
270 },
271 {
272 .name = "invalidate",
273 .type = FIO_OPT_INT,
274 .off1 = td_var_offset(invalidate_cache)
275 },
276 {
277 .name = "sync",
278 .type = FIO_OPT_INT,
279 .off1 = td_var_offset(sync_io)
280 },
281 {
282 .name = "bwavgtime",
283 .type = FIO_OPT_INT,
284 .off1 = td_var_offset(bw_avg_time)
285 },
286 {
287 .name = "create_serialize",
288 .type = FIO_OPT_INT,
289 .off1 = td_var_offset(create_serialize)
290 },
291 {
292 .name = "create_fsync",
293 .type = FIO_OPT_INT,
294 .off1 = td_var_offset(create_fsync)
295 },
296 {
297 .name = "loops",
298 .type = FIO_OPT_INT,
299 .off1 = td_var_offset(loops)
300 },
301 {
302 .name = "numjobs",
303 .type = FIO_OPT_INT,
304 .off1 = td_var_offset(numjobs)
305 },
306 {
307 .name = "cpuload",
308 .type = FIO_OPT_INT,
309 .off1 = td_var_offset(cpuload)
310 },
311 {
312 .name = "cpuchunks",
313 .type = FIO_OPT_INT,
314 .off1 = td_var_offset(cpucycle)
315 },
316 {
317 .name = "direct",
318 .type = FIO_OPT_INT,
319 .off1 = td_var_offset(odirect)
320 },
321 {
322 .name = "overwrite",
323 .type = FIO_OPT_INT,
324 .off1 = td_var_offset(overwrite)
325 },
326#ifdef FIO_HAVE_CPU_AFFINITY
327 {
328 .name = "cpumask",
329 .type = FIO_OPT_INT,
330 .cb = str_cpumask_cb,
331 },
332#endif
333 {
334 .name = "end_fsync",
335 .type = FIO_OPT_INT,
336 .off1 = td_var_offset(end_fsync)
337 },
338 {
339 .name = "unlink",
340 .type = FIO_OPT_STR_SET,
341 .off1 = td_var_offset(unlink),
342 },
343 {
344 .name = "exitall",
345 .type = FIO_OPT_STR_SET,
346 .cb = str_exitall_cb,
347 },
348 {
349 .name = "stonewall",
350 .type = FIO_OPT_STR_SET,
351 .off1 = td_var_offset(stonewall),
352 },
353 {
354 .name = "thread",
355 .type = FIO_OPT_STR_SET,
356 .off1 = td_var_offset(thread),
357 },
358 {
359 .name = "write_bw_log",
360 .type = FIO_OPT_STR_SET,
361 .off1 = td_var_offset(write_bw_log),
362 },
363 {
364 .name = "write_lat_log",
365 .type = FIO_OPT_STR_SET,
366 .off1 = td_var_offset(write_lat_log),
367 },
bb8895e0
JA		 368 {
369 .name = "norandommap",
370 .type = FIO_OPT_STR_SET,
371 .off1 = td_var_offset(norandommap),
372 },
690adba3
JA		 373 {
374 .name = "bs_unaligned",
375 .type = FIO_OPT_STR_SET,
376 .off1 = td_var_offset(bs_unaligned),
377 },
e1f36503
JA		 378 {
379 .name = NULL,
380 },
381};
382
b4692828
JA		 383#define FIO_JOB_OPTS (sizeof(options) / sizeof(struct fio_option))
384#define FIO_CMD_OPTS (16)
385#define FIO_GETOPT_JOB (0x89988998)
386
387/*
388 * Command line options. These will contain the above, plus a few
389 * extra that only pertain to fio itself and not jobs.
390 */
391static struct option long_options[FIO_JOB_OPTS + FIO_CMD_OPTS] = {
392 {
393 .name = "output",
394 .has_arg = required_argument,
395 .val = 'o',
396 },
397 {
398 .name = "timeout",
399 .has_arg = required_argument,
400 .val = 't',
401 },
402 {
403 .name = "latency-log",
404 .has_arg = required_argument,
405 .val = 'l',
406 },
407 {
408 .name = "bandwidth-log",
409 .has_arg = required_argument,
410 .val = 'b',
411 },
412 {
413 .name = "minimal",
414 .has_arg = optional_argument,
415 .val = 'm',
416 },
417 {
418 .name = "version",
419 .has_arg = no_argument,
420 .val = 'v',
421 },
422 {
423 .name = NULL,
424 },
425};
426
972cfd25 427static int def_timeout = DEF_TIMEOUT;
972cfd25 428
b4692828 429static char fio_version_string[] = "fio 1.7";
ebac4655 430
972cfd25 431static char **ini_file;
ebac4655
JA		 432static int max_jobs = MAX_JOBS;
433
434struct thread_data def_thread;
435struct thread_data *threads = NULL;
436
437int rate_quit = 0;
ebac4655 438int exitall_on_terminate = 0;
c6ae0a5b 439int terse_output = 0;
c04f7ec3 440unsigned long long mlock_size = 0;
eb8bbf48
JA		 441FILE *f_out = NULL;
442FILE *f_err = NULL;
ebac4655 443
ec94ec56
JA		 444static int write_lat_log = DEF_WRITE_LAT_LOG;
445static int write_bw_log = DEF_WRITE_BW_LOG;
446
906c8d75
JA		 447/*
448 * Return a free job structure.
449 */
ebac4655
JA		 450static struct thread_data *get_new_job(int global, struct thread_data *parent)
451{
452 struct thread_data *td;
453
454 if (global)
455 return &def_thread;
456 if (thread_number >= max_jobs)
457 return NULL;
458
459 td = &threads[thread_number++];
ddaeaa5a 460 *td = *parent;
ebac4655 461
ebac4655 462 td->thread_number = thread_number;
ebac4655
JA		 463 return td;
464}
465
466static void put_job(struct thread_data *td)
467{
549577a7
JA		 468 if (td == &def_thread)
469 return;
470
ebac4655
JA		 471 memset(&threads[td->thread_number - 1], 0, sizeof(*td));
472 thread_number--;
473}
474
dad915e3
JA		 475/*
476 * Lazy way of fixing up options that depend on each other. We could also
477 * define option callback handlers, but this is easier.
478 */
e1f36503
JA		 479static void fixup_options(struct thread_data *td)
480{
e1f36503
JA		 481 if (!td->rwmixread && td->rwmixwrite)
482 td->rwmixread = 100 - td->rwmixwrite;
dad915e3 483
076efc7c
JA		 484 if (td->write_iolog_file && td->read_iolog_file) {
485 log_err("fio: read iolog overrides write_iolog\n");
486 free(td->write_iolog_file);
487 td->write_iolog_file = NULL;
488 }
16b462ae
JA		 489
490 if (td->io_ops->flags & FIO_SYNCIO)
491 td->iodepth = 1;
492 else {
493 if (!td->iodepth)
494 td->iodepth = td->nr_files;
495 }
496
497 /*
498 * only really works for sequential io for now, and with 1 file
499 */
500 if (td->zone_size && !td->sequential && td->nr_files == 1)
501 td->zone_size = 0;
502
503 /*
504 * Reads can do overwrites, we always need to pre-create the file
505 */
506 if (td_read(td) || td_rw(td))
507 td->overwrite = 1;
508
a00735e6
JA		 509 if (td->bs[DDIR_READ] != DEF_BS)
510 td->bs[DDIR_WRITE] = td->bs[DDIR_READ];
511 if (!td->min_bs[DDIR_READ])
512 td->min_bs[DDIR_READ]= td->bs[DDIR_READ];
513 if (!td->max_bs[DDIR_READ])
514 td->max_bs[DDIR_READ] = td->bs[DDIR_READ];
515 if (!td->min_bs[DDIR_WRITE])
75e6f36f 516 td->min_bs[DDIR_WRITE]= td->bs[DDIR_WRITE];
a00735e6 517 if (!td->max_bs[DDIR_WRITE])
75e6f36f 518 td->max_bs[DDIR_WRITE] = td->bs[DDIR_WRITE];
a00735e6
JA		 519
520 td->rw_min_bs = min(td->min_bs[DDIR_READ], td->min_bs[DDIR_WRITE]);
521
16b462ae
JA		 522 if (td_read(td) && !td_rw(td))
523 td->verify = 0;
bb8895e0
JA		 524
525 if (td->norandommap && td->verify != VERIFY_NONE) {
526 log_err("fio: norandommap given, verify disabled\n");
527 td->verify = VERIFY_NONE;
528 }
690adba3
JA		 529 if (td->bs_unaligned && (td->odirect || td->io_ops->flags & FIO_RAWIO))
530 log_err("fio: bs_unaligned may not work with raw io\n");
e1f36503
JA		 531}
532
906c8d75
JA		 533/*
534 * Adds a job to the list of things todo. Sanitizes the various options
535 * to make sure we don't have conflicts, and initializes various
536 * members of td.
537 */
75154845 538static int add_job(struct thread_data *td, const char *jobname, int job_add_num)
ebac4655 539{
3d60d1ed
JA		 540 char *ddir_str[] = { "read", "write", "randread", "randwrite",
541 "rw", NULL, "randrw" };
ebac4655 542 struct stat sb;
53cdc686
JA		 543 int numjobs, ddir, i;
544 struct fio_file *f;
ebac4655 545
ebac4655
JA		 546 /*
547 * the def_thread is just for options, it's not a real job
548 */
549 if (td == &def_thread)
550 return 0;
551
df64119d
JA		 552 /*
553 * Set default io engine, if none set
554 */
555 if (!td->io_ops) {
556 td->io_ops = load_ioengine(td, DEF_IO_ENGINE_NAME);
557 if (!td->io_ops) {
558 log_err("default engine %s not there?\n", DEF_IO_ENGINE_NAME);
559 return 1;
560 }
561 }
562
690adba3
JA		 563 if (td->odirect)
564 td->io_ops->flags |= FIO_RAWIO;
565
16b462ae 566 fixup_options(td);
9cc935a1 567
ebac4655 568 td->filetype = FIO_TYPE_FILE;
0af7b542
JA		 569 if (!stat(jobname, &sb)) {
570 if (S_ISBLK(sb.st_mode))
571 td->filetype = FIO_TYPE_BD;
572 else if (S_ISCHR(sb.st_mode))
573 td->filetype = FIO_TYPE_CHAR;
574 }
ebac4655 575
13f8e2d2
JA		 576 if (td->filename)
577 td->nr_uniq_files = 1;
578 else
579 td->nr_uniq_files = td->nr_files;
580
581 if (td->filetype == FIO_TYPE_FILE || td->filename) {
e9c047a0 582 char tmp[PATH_MAX];
53cdc686
JA		 583 int len = 0;
584 int i;
e9c047a0 585
ef899b63 586 if (td->directory && td->directory[0] != '\0')
53cdc686 587 sprintf(tmp, "%s/", td->directory);
ebac4655 588
53cdc686
JA		 589 td->files = malloc(sizeof(struct fio_file) * td->nr_files);
590
591 for_each_file(td, f, i) {
592 memset(f, 0, sizeof(*f));
593 f->fd = -1;
594
13f8e2d2
JA		 595 if (td->filename)
596 sprintf(tmp + len, "%s", td->filename);
597 else
598 sprintf(tmp + len, "%s.%d.%d", jobname, td->thread_number, i);
53cdc686
JA		 599 f->file_name = strdup(tmp);
600 }
601 } else {
602 td->nr_files = 1;
603 td->files = malloc(sizeof(struct fio_file));
604 f = &td->files[0];
605
606 memset(f, 0, sizeof(*f));
607 f->fd = -1;
608 f->file_name = strdup(jobname);
609 }
610
611 for_each_file(td, f, i) {
612 f->file_size = td->total_file_size / td->nr_files;
613 f->file_offset = td->start_offset;
614 }
615
bbfd6b00 616 fio_sem_init(&td->mutex, 0);
ebac4655
JA		 617
618 td->clat_stat[0].min_val = td->clat_stat[1].min_val = ULONG_MAX;
619 td->slat_stat[0].min_val = td->slat_stat[1].min_val = ULONG_MAX;
620 td->bw_stat[0].min_val = td->bw_stat[1].min_val = ULONG_MAX;
621
ebac4655
JA		 622 if (td->stonewall && td->thread_number > 1)
623 groupid++;
624
625 td->groupid = groupid;
626
627 if (setup_rate(td))
628 goto err;
629
ec94ec56 630 if (td->write_lat_log) {
ebac4655
JA		 631 setup_log(&td->slat_log);
632 setup_log(&td->clat_log);
633 }
ec94ec56 634 if (td->write_bw_log)
ebac4655
JA		 635 setup_log(&td->bw_log);
636
b4692828
JA		 637 if (!td->name)
638 td->name = strdup(jobname);
01452055 639
3d60d1ed 640 ddir = td->ddir + (!td->sequential << 1) + (td->iomix << 2);
75154845 641
c6ae0a5b 642 if (!terse_output) {
b990b5c0 643 if (!job_add_num) {
2866c82d 644 if (td->io_ops->flags & FIO_CPUIO)
b990b5c0
JA		 645 fprintf(f_out, "%s: ioengine=cpu, cpuload=%u, cpucycle=%u\n", td->name, td->cpuload, td->cpucycle);
646 else
a00735e6 647 fprintf(f_out, "%s: (g=%d): rw=%s, odir=%d, bs=%d-%d/%d-%d, rate=%d, ioengine=%s, iodepth=%d\n", td->name, td->groupid, ddir_str[ddir], td->odirect, td->min_bs[DDIR_READ], td->max_bs[DDIR_READ], td->min_bs[DDIR_WRITE], td->max_bs[DDIR_WRITE], td->rate, td->io_ops->name, td->iodepth);
b990b5c0 648 } else if (job_add_num == 1)
c6ae0a5b
JA		 649 fprintf(f_out, "...\n");
650 }
ebac4655
JA		 651
652 /*
653 * recurse add identical jobs, clear numjobs and stonewall options
654 * as they don't apply to sub-jobs
655 */
656 numjobs = td->numjobs;
657 while (--numjobs) {
658 struct thread_data *td_new = get_new_job(0, td);
659
660 if (!td_new)
661 goto err;
662
663 td_new->numjobs = 1;
664 td_new->stonewall = 0;
75154845 665 job_add_num = numjobs - 1;
ebac4655 666
75154845 667 if (add_job(td_new, jobname, job_add_num))
ebac4655
JA		 668 goto err;
669 }
670 return 0;
671err:
672 put_job(td);
673 return -1;
674}
675
906c8d75
JA		 676/*
677 * Initialize the various random states we need (random io, block size ranges,
678 * read/write mix, etc).
679 */
ebac4655
JA		 680int init_random_state(struct thread_data *td)
681{
a6ccc7be 682 unsigned long seeds[4];
53cdc686 683 int fd, num_maps, blocks, i;
0ab8db89 684 struct fio_file *f;
ebac4655 685
f48b467c
JA		 686 if (td->io_ops->flags & FIO_CPUIO)
687 return 0;
688
1ac267bb 689 fd = open("/dev/urandom", O_RDONLY);
ebac4655
JA		 690 if (fd == -1) {
691 td_verror(td, errno);
692 return 1;
693 }
694
a6ccc7be 695 if (read(fd, seeds, sizeof(seeds)) < (int) sizeof(seeds)) {
ebac4655
JA		 696 td_verror(td, EIO);
697 close(fd);
698 return 1;
699 }
700
701 close(fd);
702
6dfd46b9
JA		 703 os_random_seed(seeds[0], &td->bsrange_state);
704 os_random_seed(seeds[1], &td->verify_state);
705 os_random_seed(seeds[2], &td->rwmix_state);
ebac4655
JA		 706
707 if (td->sequential)
708 return 0;
709
9ebc27e1 710 if (td->rand_repeatable)
a6ccc7be 711 seeds[3] = DEF_RANDSEED;
ebac4655 712
bb8895e0
JA		 713 if (!td->norandommap) {
714 for_each_file(td, f, i) {
a00735e6 715 blocks = (f->file_size + td->rw_min_bs - 1) / td->rw_min_bs;
c7c280ed 716 num_maps = (blocks + BLOCKS_PER_MAP-1)/ BLOCKS_PER_MAP;
bb8895e0
JA		 717 f->file_map = malloc(num_maps * sizeof(long));
718 f->num_maps = num_maps;
719 memset(f->file_map, 0, num_maps * sizeof(long));
720 }
53cdc686 721 }
ebac4655 722
6dfd46b9 723 os_random_seed(seeds[3], &td->random_state);
ebac4655
JA		 724 return 0;
725}
726
727static void fill_cpu_mask(os_cpu_mask_t cpumask, int cpu)
728{
729#ifdef FIO_HAVE_CPU_AFFINITY
730 unsigned int i;
731
732 CPU_ZERO(&cpumask);
733
734 for (i = 0; i < sizeof(int) * 8; i++) {
735 if ((1 << i) & cpu)
736 CPU_SET(i, &cpumask);
737 }
738#endif
739}
740
ebac4655
JA		 741static int is_empty_or_comment(char *line)
742{
743 unsigned int i;
744
745 for (i = 0; i < strlen(line); i++) {
746 if (line[i] == ';')
747 return 1;
748 if (!isspace(line[i]) && !iscntrl(line[i]))
749 return 0;
750 }
751
752 return 1;
753}
754
b4692828 755static int str_rw_cb(void *data, const char *mem)
ebac4655 756{
cb2c86fd
JA		 757 struct thread_data *td = data;
758
ebac4655
JA		 759 if (!strncmp(mem, "read", 4) || !strncmp(mem, "0", 1)) {
760 td->ddir = DDIR_READ;
761 td->sequential = 1;
762 return 0;
763 } else if (!strncmp(mem, "randread", 8)) {
764 td->ddir = DDIR_READ;
765 td->sequential = 0;
766 return 0;
767 } else if (!strncmp(mem, "write", 5) || !strncmp(mem, "1", 1)) {
768 td->ddir = DDIR_WRITE;
769 td->sequential = 1;
770 return 0;
771 } else if (!strncmp(mem, "randwrite", 9)) {
772 td->ddir = DDIR_WRITE;
773 td->sequential = 0;
774 return 0;
3d60d1ed
JA		 775 } else if (!strncmp(mem, "rw", 2)) {
776 td->ddir = 0;
777 td->iomix = 1;
778 td->sequential = 1;
779 return 0;
780 } else if (!strncmp(mem, "randrw", 6)) {
781 td->ddir = 0;
782 td->iomix = 1;
783 td->sequential = 0;
784 return 0;
ebac4655
JA		 785 }
786
3b70d7e5 787 log_err("fio: data direction: read, write, randread, randwrite, rw, randrw\n");
ebac4655
JA		 788 return 1;
789}
790
b4692828 791static int str_verify_cb(void *data, const char *mem)
ebac4655 792{
cb2c86fd
JA		 793 struct thread_data *td = data;
794
ebac4655
JA		 795 if (!strncmp(mem, "0", 1)) {
796 td->verify = VERIFY_NONE;
797 return 0;
798 } else if (!strncmp(mem, "md5", 3) || !strncmp(mem, "1", 1)) {
799 td->verify = VERIFY_MD5;
800 return 0;
801 } else if (!strncmp(mem, "crc32", 5)) {
802 td->verify = VERIFY_CRC32;
803 return 0;
804 }
805
3b70d7e5 806 log_err("fio: verify types: md5, crc32\n");
ebac4655
JA		 807 return 1;
808}
809
b4692828 810static int str_mem_cb(void *data, const char *mem)
ebac4655 811{
cb2c86fd
JA		 812 struct thread_data *td = data;
813
ebac4655
JA		 814 if (!strncmp(mem, "malloc", 6)) {
815 td->mem_type = MEM_MALLOC;
816 return 0;
817 } else if (!strncmp(mem, "shm", 3)) {
818 td->mem_type = MEM_SHM;
819 return 0;
820 } else if (!strncmp(mem, "mmap", 4)) {
821 td->mem_type = MEM_MMAP;
822 return 0;
823 }
824
3b70d7e5 825 log_err("fio: mem type: malloc, shm, mmap\n");
ebac4655
JA		 826 return 1;
827}
828
b4692828 829static int str_ioengine_cb(void *data, const char *str)
ebac4655 830{
cb2c86fd
JA		 831 struct thread_data *td = data;
832
2866c82d
JA		 833 td->io_ops = load_ioengine(td, str);
834 if (td->io_ops)
b990b5c0 835 return 0;
ebac4655 836
b990b5c0 837 log_err("fio: ioengine: { linuxaio, aio, libaio }, posixaio, sync, mmap, sgio, splice, cpu\n");
ebac4655
JA		 838 return 1;
839}
840
e1f36503
JA		 841static int str_lockmem_cb(void fio_unused *data, unsigned long *val)
842{
843 mlock_size = *val;
844 return 0;
845}
846
847static int str_prioclass_cb(void *data, unsigned int *val)
848{
849 struct thread_data *td = data;
850
851 td->ioprio |= *val << IOPRIO_CLASS_SHIFT;
852 return 0;
853}
854
855static int str_prio_cb(void *data, unsigned int *val)
856{
857 struct thread_data *td = data;
858
859 td->ioprio |= *val;
860 return 0;
861}
862
863static int str_exitall_cb(void)
864{
865 exitall_on_terminate = 1;
866 return 0;
867}
868
869static int str_cpumask_cb(void *data, unsigned int *val)
870{
871 struct thread_data *td = data;
872
873 fill_cpu_mask(td->cpumask, *val);
874 return 0;
875}
876
07261983
JA		 877/*
878 * This is our [ini] type file parser.
879 */
0c7e37a0 880int parse_jobs_ini(char *file, int stonewall_flag)
ebac4655 881{
e1f36503 882 unsigned int global;
ebac4655 883 struct thread_data *td;
fee3bb48 884 char *string, *name;
ebac4655
JA		 885 fpos_t off;
886 FILE *f;
887 char *p;
0c7e37a0 888 int ret = 0, stonewall;
ebac4655
JA		 889
890 f = fopen(file, "r");
891 if (!f) {
aea47d44 892 perror("fopen job file");
ebac4655
JA		 893 return 1;
894 }
895
896 string = malloc(4096);
897 name = malloc(256);
fee3bb48 898 memset(name, 0, 256);
ebac4655 899
0c7e37a0 900 stonewall = stonewall_flag;
7c124ac1
JA		 901 do {
902 p = fgets(string, 4095, f);
903 if (!p)
45410acb 904 break;
ebac4655
JA		 905 if (is_empty_or_comment(p))
906 continue;
fee3bb48 907 if (sscanf(p, "[%255s]", name) != 1)
ebac4655
JA		 908 continue;
909
910 global = !strncmp(name, "global", 6);
911
912 name[strlen(name) - 1] = '\0';
913
914 td = get_new_job(global, &def_thread);
45410acb
JA		 915 if (!td) {
916 ret = 1;
917 break;
918 }
ebac4655 919
972cfd25
JA		 920 /*
921 * Seperate multiple job files by a stonewall
922 */
f9481919 923 if (!global && stonewall) {
972cfd25
JA		 924 td->stonewall = stonewall;
925 stonewall = 0;
926 }
927
ebac4655
JA		 928 fgetpos(f, &off);
929 while ((p = fgets(string, 4096, f)) != NULL) {
930 if (is_empty_or_comment(p))
931 continue;
e1f36503 932
b6754f9d 933 strip_blank_front(&p);
7c124ac1
JA		 934
935 if (p[0] == '[')
936 break;
937
4ae3f763 938 strip_blank_end(p);
aea47d44 939
e1f36503 940 fgetpos(f, &off);
ebac4655 941
45410acb
JA		 942 /*
943 * Don't break here, continue parsing options so we
944 * dump all the bad ones. Makes trial/error fixups
945 * easier on the user.
946 */
7c124ac1 947 ret |= parse_option(p, options, td);
ebac4655 948 }
ebac4655 949
45410acb
JA		 950 if (!ret) {
951 fsetpos(f, &off);
952 ret = add_job(td, name, 0);
b1508cf9
JA		 953 } else {
954 log_err("fio: job %s dropped\n", name);
955 put_job(td);
45410acb 956 }
7c124ac1 957 } while (!ret);
ebac4655
JA		 958
959 free(string);
960 free(name);
961 fclose(f);
45410acb 962 return ret;
ebac4655
JA		 963}
964
965static int fill_def_thread(void)
966{
967 memset(&def_thread, 0, sizeof(def_thread));
968
969 if (fio_getaffinity(getpid(), &def_thread.cpumask) == -1) {
970 perror("sched_getaffinity");
971 return 1;
972 }
973
974 /*
975 * fill globals
976 */
977 def_thread.ddir = DDIR_READ;
3d60d1ed 978 def_thread.iomix = 0;
a00735e6
JA		 979 def_thread.bs[DDIR_READ] = DEF_BS;
980 def_thread.bs[DDIR_WRITE] = DEF_BS;
981 def_thread.min_bs[DDIR_READ] = def_thread.min_bs[DDIR_WRITE] = 0;
982 def_thread.max_bs[DDIR_READ] = def_thread.max_bs[DDIR_WRITE] = 0;
9ebc27e1 983 def_thread.odirect = DEF_ODIRECT;
ebac4655 984 def_thread.ratecycle = DEF_RATE_CYCLE;
9ebc27e1 985 def_thread.sequential = DEF_SEQUENTIAL;
972cfd25 986 def_thread.timeout = def_timeout;
ebac4655
JA		 987 def_thread.overwrite = DEF_OVERWRITE;
988 def_thread.invalidate_cache = DEF_INVALIDATE;
989 def_thread.sync_io = DEF_SYNCIO;
990 def_thread.mem_type = MEM_MALLOC;
991 def_thread.bw_avg_time = DEF_BWAVGTIME;
992 def_thread.create_serialize = DEF_CREATE_SER;
993 def_thread.create_fsync = DEF_CREATE_FSYNC;
994 def_thread.loops = DEF_LOOPS;
995 def_thread.verify = DEF_VERIFY;
996 def_thread.stonewall = DEF_STONEWALL;
997 def_thread.numjobs = DEF_NUMJOBS;
998 def_thread.use_thread = DEF_USE_THREAD;
a6ccc7be
JA		 999 def_thread.rwmixcycle = DEF_RWMIX_CYCLE;
1000 def_thread.rwmixread = DEF_RWMIX_READ;
b6f4d880 1001 def_thread.nice = DEF_NICE;
9ebc27e1 1002 def_thread.rand_repeatable = DEF_RAND_REPEAT;
53cdc686 1003 def_thread.nr_files = DEF_NR_FILES;
f6cbb269 1004 def_thread.unlink = DEF_UNLINK;
ec94ec56
JA		 1005 def_thread.write_bw_log = write_bw_log;
1006 def_thread.write_lat_log = write_lat_log;
bb8895e0 1007 def_thread.norandommap = DEF_NO_RAND_MAP;
ebac4655
JA		 1008#ifdef FIO_HAVE_DISK_UTIL
1009 def_thread.do_disk_util = 1;
1010#endif
1011
1012 return 0;
1013}
1014
0ab8db89 1015static void usage(void)
4785f995
JA		 1016{
1017 printf("%s\n", fio_version_string);
b4692828
JA		 1018 printf("\t--output\tWrite output to file\n");
1019 printf("\t--timeout\tRuntime in seconds\n");
1020 printf("\t--latency-log\tGenerate per-job latency logs\n");
1021 printf("\t--bandwidth-log\tGenerate per-job bandwidth logs\n");
1022 printf("\t--minimal\tMinimal (terse) output\n");
1023 printf("\t--version\tPrint version info and exit\n");
4785f995
JA		 1024}
1025
972cfd25 1026static int parse_cmd_line(int argc, char *argv[])
ebac4655 1027{
b4692828 1028 struct thread_data *td = NULL;
c2b1e753 1029 int c, ini_idx = 0, lidx, ret;
ebac4655 1030
b4692828 1031 while ((c = getopt_long(argc, argv, "", long_options, &lidx)) != -1) {
ebac4655 1032 switch (c) {
b4692828
JA		 1033 case 't':
1034 def_timeout = atoi(optarg);
1035 break;
1036 case 'l':
1037 write_lat_log = 1;
1038 break;
1039 case 'w':
1040 write_bw_log = 1;
1041 break;
1042 case 'o':
1043 f_out = fopen(optarg, "w+");
1044 if (!f_out) {
1045 perror("fopen output");
1046 exit(1);
1047 }
1048 f_err = f_out;
1049 break;
1050 case 'm':
1051 terse_output = 1;
1052 break;
1053 case 'h':
1054 usage();
1055 exit(0);
1056 case 'v':
1057 printf("%s\n", fio_version_string);
1058 exit(0);
1059 case FIO_GETOPT_JOB: {
1060 const char *opt = long_options[lidx].name;
1061 char *val = optarg;
1062
c2b1e753
JA		 1063 if (!strncmp(opt, "name", 4) && td) {
1064 ret = add_job(td, td->name ?: "fio", 0);
1065 if (ret) {
1066 put_job(td);
1067 return 0;
1068 }
1069 td = NULL;
1070 }
b4692828 1071 if (!td) {
38d0adb0 1072 int global = !strncmp(val, "global", 6);
c2b1e753
JA		 1073
1074 td = get_new_job(global, &def_thread);
b4692828
JA		 1075 if (!td)
1076 return 0;
1077 }
38d0adb0 1078
b1508cf9
JA		 1079 ret = parse_cmd_option(opt, val, options, td);
1080 if (ret) {
1081 log_err("fio: job dropped\n");
1082 put_job(td);
1083 td = NULL;
1084 }
b4692828
JA		 1085 break;
1086 }
1087 default:
1088 printf("optarg <<%s>>\n", argv[optind]);
1089 break;
ebac4655
JA		 1090 }
1091 }
c9fad893 1092
b4692828 1093 if (td) {
c2b1e753 1094 ret = add_job(td, td->name ?: "fio", 0);
b4692828
JA		 1095 if (ret)
1096 put_job(td);
972cfd25 1097 }
774a6177 1098
b4692828
JA		 1099 while (optind < argc) {
1100 ini_idx++;
1101 ini_file = realloc(ini_file, ini_idx * sizeof(char *));
1102 ini_file[ini_idx - 1] = strdup(argv[optind]);
1103 optind++;
eb8bbf48 1104 }
972cfd25
JA		 1105
1106 return ini_idx;
ebac4655
JA		 1107}
1108
1109static void free_shm(void)
1110{
1111 struct shmid_ds sbuf;
1112
1113 if (threads) {
2c0ecd28 1114 shmdt((void *) threads);
ebac4655
JA		 1115 threads = NULL;
1116 shmctl(shm_id, IPC_RMID, &sbuf);
1117 }
1118}
1119
906c8d75
JA		 1120/*
1121 * The thread area is shared between the main process and the job
1122 * threads/processes. So setup a shared memory segment that will hold
1123 * all the job info.
1124 */
ebac4655
JA		 1125static int setup_thread_area(void)
1126{
1127 /*
1128 * 1024 is too much on some machines, scale max_jobs if
1129 * we get a failure that looks like too large a shm segment
1130 */
1131 do {
906c8d75 1132 size_t size = max_jobs * sizeof(struct thread_data);
ebac4655 1133
906c8d75 1134 shm_id = shmget(0, size, IPC_CREAT | 0600);
ebac4655
JA		 1135 if (shm_id != -1)
1136 break;
1137 if (errno != EINVAL) {
1138 perror("shmget");
1139 break;
1140 }
1141
1142 max_jobs >>= 1;
1143 } while (max_jobs);
1144
1145 if (shm_id == -1)
1146 return 1;
1147
1148 threads = shmat(shm_id, NULL, 0);
1149 if (threads == (void *) -1) {
1150 perror("shmat");
1151 return 1;
1152 }
1153
1154 atexit(free_shm);
1155 return 0;
1156}
1157
b4692828
JA		 1158/*
1159 * Copy the fio options into the long options map, so we mirror
1160 * job and cmd line options.
1161 */
1162static void dupe_job_options(void)
1163{
1164 struct fio_option *o;
1165 unsigned int i;
1166
1167 i = 0;
1168 while (long_options[i].name)
1169 i++;
1170
1171 o = &options[0];
1172 while (o->name) {
1173 long_options[i].name = o->name;
1174 long_options[i].val = FIO_GETOPT_JOB;
1175 if (o->type == FIO_OPT_STR_SET)
1176 long_options[i].has_arg = no_argument;
1177 else
1178 long_options[i].has_arg = required_argument;
1179
1180 i++;
1181 o++;
1182 assert(i < FIO_JOB_OPTS + FIO_CMD_OPTS);
1183 }
1184}
1185
ebac4655
JA		 1186int parse_options(int argc, char *argv[])
1187{
972cfd25
JA		 1188 int job_files, i;
1189
b4692828
JA		 1190 f_out = stdout;
1191 f_err = stderr;
1192
1193 dupe_job_options();
1194
ebac4655
JA		 1195 if (setup_thread_area())
1196 return 1;
1197 if (fill_def_thread())
1198 return 1;
1199
972cfd25 1200 job_files = parse_cmd_line(argc, argv);
ebac4655 1201
972cfd25
JA		 1202 for (i = 0; i < job_files; i++) {
1203 if (fill_def_thread())
1204 return 1;
0c7e37a0 1205 if (parse_jobs_ini(ini_file[i], i))
972cfd25 1206 return 1;
88c6ed80 1207 free(ini_file[i]);
972cfd25 1208 }
ebac4655 1209
88c6ed80 1210 free(ini_file);
b4692828
JA		 1211
1212 if (!thread_number) {
1213 log_err("No jobs defined(s)\n");
b4692828
JA		 1214 return 1;
1215 }
1216
ebac4655
JA		 1217 return 0;
1218}
fio - Flexible IO Tester