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