Don't assume read IO are always verifies if verify is enabled
[fio.git] / fio.h
1 #ifndef FIO_H
2 #define FIO_H
3
4 #include <sched.h>
5 #include <limits.h>
6 #include <pthread.h>
7 #include <sys/time.h>
8 #include <sys/resource.h>
9 #include <errno.h>
10 #include <stdlib.h>
11 #include <stdio.h>
12 #include <unistd.h>
13 #include <string.h>
14 #include <getopt.h>
15 #include <inttypes.h>
16 #include <assert.h>
17
18 #include "compiler/compiler.h"
19 #include "flist.h"
20 #include "fifo.h"
21 #include "rbtree.h"
22 #include "arch/arch.h"
23 #include "os/os.h"
24 #include "mutex.h"
25 #include "log.h"
26 #include "debug.h"
27 #include "file.h"
28 #include "io_ddir.h"
29 #include "ioengine.h"
30 #include "iolog.h"
31
32 #ifdef FIO_HAVE_GUASI
33 #include <guasi.h>
34 #endif
35
36 #ifdef FIO_HAVE_SOLARISAIO
37 #include <sys/asynch.h>
38 #endif
39
40 struct group_run_stats {
41         unsigned long long max_run[2], min_run[2];
42         unsigned long long max_bw[2], min_bw[2];
43         unsigned long long io_kb[2];
44         unsigned long long agg[2];
45         unsigned int kb_base;
46 };
47
48 /*
49  * What type of allocation to use for io buffers
50  */
51 enum fio_memtype {
52         MEM_MALLOC = 0, /* ordinary malloc */
53         MEM_SHM,        /* use shared memory segments */
54         MEM_SHMHUGE,    /* use shared memory segments with huge pages */
55         MEM_MMAP,       /* use anonynomous mmap */
56         MEM_MMAPHUGE,   /* memory mapped huge file */
57 };
58
59 /*
60  * How many depth levels to log
61  */
62 #define FIO_IO_U_MAP_NR 8
63 #define FIO_IO_U_LAT_U_NR 10
64 #define FIO_IO_U_LAT_M_NR 12
65
66 struct thread_stat {
67         char *name;
68         char *verror;
69         int error;
70         int groupid;
71         pid_t pid;
72         char *description;
73         int members;
74
75         struct io_log *slat_log;
76         struct io_log *clat_log;
77         struct io_log *bw_log;
78
79         /*
80          * bandwidth and latency stats
81          */
82         struct io_stat clat_stat[2];            /* completion latency */
83         struct io_stat slat_stat[2];            /* submission latency */
84         struct io_stat bw_stat[2];              /* bandwidth stats */
85
86         unsigned long long stat_io_bytes[2];
87         struct timeval stat_sample_time[2];
88
89         /*
90          * fio system usage accounting
91          */
92         struct rusage ru_start;
93         struct rusage ru_end;
94         unsigned long usr_time;
95         unsigned long sys_time;
96         unsigned long ctx;
97         unsigned long minf, majf;
98
99         /*
100          * IO depth and latency stats
101          */
102         unsigned int io_u_map[FIO_IO_U_MAP_NR];
103         unsigned int io_u_submit[FIO_IO_U_MAP_NR];
104         unsigned int io_u_complete[FIO_IO_U_MAP_NR];
105         unsigned int io_u_lat_u[FIO_IO_U_LAT_U_NR];
106         unsigned int io_u_lat_m[FIO_IO_U_LAT_M_NR];
107         unsigned long total_io_u[2];
108         unsigned long short_io_u[2];
109         unsigned long total_submit;
110         unsigned long total_complete;
111
112         unsigned long long io_bytes[2];
113         unsigned long runtime[2];
114         unsigned long total_run_time;
115
116         /*
117          * IO Error related stats
118          */
119         unsigned continue_on_error;
120         unsigned long total_err_count;
121         int first_error;
122
123         unsigned int kb_base;
124 };
125
126 struct bssplit {
127         unsigned int bs;
128         unsigned char perc;
129 };
130
131 struct thread_options {
132         int pad;
133         char *description;
134         char *name;
135         char *directory;
136         char *filename;
137         char *opendir;
138         char *ioengine;
139         enum td_ddir td_ddir;
140         unsigned int kb_base;
141         unsigned int ddir_nr;
142         unsigned int iodepth;
143         unsigned int iodepth_low;
144         unsigned int iodepth_batch;
145         unsigned int iodepth_batch_complete;
146
147         unsigned long long size;
148         unsigned int fill_device;
149         unsigned long long file_size_low;
150         unsigned long long file_size_high;
151         unsigned long long start_offset;
152
153         unsigned int bs[2];
154         unsigned int ba[2];
155         unsigned int min_bs[2];
156         unsigned int max_bs[2];
157         struct bssplit *bssplit[2];
158         unsigned int bssplit_nr[2];
159
160         unsigned int nr_files;
161         unsigned int open_files;
162         enum file_lock_mode file_lock_mode;
163         unsigned int lockfile_batch;
164
165         unsigned int odirect;
166         unsigned int invalidate_cache;
167         unsigned int create_serialize;
168         unsigned int create_fsync;
169         unsigned int create_on_open;
170         unsigned int end_fsync;
171         unsigned int pre_read;
172         unsigned int sync_io;
173         unsigned int verify;
174         unsigned int do_verify;
175         unsigned int verifysort;
176         unsigned int verify_interval;
177         unsigned int verify_offset;
178         unsigned int verify_pattern;
179         unsigned int verify_pattern_bytes;
180         unsigned int verify_fatal;
181         unsigned int verify_async;
182         unsigned int use_thread;
183         unsigned int unlink;
184         unsigned int do_disk_util;
185         unsigned int override_sync;
186         unsigned int rand_repeatable;
187         unsigned int write_lat_log;
188         unsigned int write_bw_log;
189         unsigned int norandommap;
190         unsigned int softrandommap;
191         unsigned int bs_unaligned;
192         unsigned int fsync_on_close;
193
194         unsigned int hugepage_size;
195         unsigned int rw_min_bs;
196         unsigned int thinktime;
197         unsigned int thinktime_spin;
198         unsigned int thinktime_blocks;
199         unsigned int fsync_blocks;
200         unsigned int fdatasync_blocks;
201         unsigned int start_delay;
202         unsigned long long timeout;
203         unsigned long long ramp_time;
204         unsigned int overwrite;
205         unsigned int bw_avg_time;
206         unsigned int loops;
207         unsigned long long zone_size;
208         unsigned long long zone_skip;
209         enum fio_memtype mem_type;
210         unsigned int mem_align;
211
212         unsigned int stonewall;
213         unsigned int new_group;
214         unsigned int numjobs;
215         os_cpu_mask_t cpumask;
216         unsigned int cpumask_set;
217         os_cpu_mask_t verify_cpumask;
218         unsigned int verify_cpumask_set;
219         unsigned int iolog;
220         unsigned int rwmixcycle;
221         unsigned int rwmix[2];
222         unsigned int nice;
223         unsigned int file_service_type;
224         unsigned int group_reporting;
225         unsigned int fadvise_hint;
226         unsigned int zero_buffers;
227         unsigned int refill_buffers;
228         unsigned int time_based;
229         unsigned int disable_clat;
230         unsigned int disable_slat;
231         unsigned int disable_bw;
232         unsigned int gtod_reduce;
233         unsigned int gtod_cpu;
234         unsigned int gtod_offload;
235
236         char *read_iolog_file;
237         char *write_iolog_file;
238         char *bw_log_file;
239         char *lat_log_file;
240
241         /*
242          * Pre-run and post-run shell
243          */
244         char *exec_prerun;
245         char *exec_postrun;
246
247         unsigned int rate[2];
248         unsigned int ratemin[2];
249         unsigned int ratecycle;
250         unsigned int rate_iops[2];
251         unsigned int rate_iops_min[2];
252
253         char *ioscheduler;
254
255         /*
256          * CPU "io" cycle burner
257          */
258         unsigned int cpuload;
259         unsigned int cpucycle;
260
261         /*
262          * I/O Error handling
263          */
264         unsigned int continue_on_error;
265 };
266
267 #define FIO_VERROR_SIZE 128
268
269 /*
270  * This describes a single thread/process executing a fio job.
271  */
272 struct thread_data {
273         struct thread_options o;
274         char verror[FIO_VERROR_SIZE];
275         pthread_t thread;
276         int thread_number;
277         int groupid;
278         struct thread_stat ts;
279         struct fio_file **files;
280         unsigned int files_size;
281         unsigned int files_index;
282         unsigned int nr_open_files;
283         unsigned int nr_done_files;
284         unsigned int nr_normal_files;
285         union {
286                 unsigned int next_file;
287                 os_random_state_t next_file_state;
288         };
289         int error;
290         int done;
291         pid_t pid;
292         char *orig_buffer;
293         size_t orig_buffer_size;
294         volatile int terminate;
295         volatile int runstate;
296         unsigned int ioprio;
297         unsigned int ioprio_set;
298         unsigned int last_was_sync;
299
300         char *mmapfile;
301         int mmapfd;
302
303         void *iolog_buf;
304         FILE *iolog_f;
305
306         char *sysfs_root;
307
308         unsigned long rand_seeds[6];
309
310         os_random_state_t bsrange_state;
311         os_random_state_t verify_state;
312
313         int shm_id;
314
315         /*
316          * IO engine hooks, contains everything needed to submit an io_u
317          * to any of the available IO engines.
318          */
319         struct ioengine_ops *io_ops;
320
321         /*
322          * Current IO depth and list of free and busy io_u's.
323          */
324         unsigned int cur_depth;
325         unsigned int io_u_queued;
326         struct flist_head io_u_freelist;
327         struct flist_head io_u_busylist;
328         struct flist_head io_u_requeues;
329         pthread_mutex_t io_u_lock;
330         pthread_cond_t free_cond;
331
332         /*
333          * async verify offload
334          */
335         struct flist_head verify_list;
336         pthread_t *verify_threads;
337         unsigned int nr_verify_threads;
338         pthread_cond_t verify_cond;
339         int verify_thread_exit;
340
341         /*
342          * Rate state
343          */
344         unsigned long rate_usec_cycle[2];
345         long rate_pending_usleep[2];
346         unsigned long rate_bytes[2];
347         unsigned long rate_blocks[2];
348         struct timeval lastrate[2];
349
350         unsigned long long total_io_size;
351
352         unsigned long io_issues[2];
353         unsigned long long io_blocks[2];
354         unsigned long long io_bytes[2];
355         unsigned long long io_skip_bytes;
356         unsigned long long this_io_bytes[2];
357         unsigned long long zone_bytes;
358         struct fio_mutex *mutex;
359
360         /*
361          * State for random io, a bitmap of blocks done vs not done
362          */
363         os_random_state_t random_state;
364
365         struct timeval start;   /* start of this loop */
366         struct timeval epoch;   /* time job was started */
367         struct timeval last_issue;
368         struct timeval tv_cache;
369         unsigned int tv_cache_nr;
370         unsigned int tv_cache_mask;
371         unsigned int ramp_time_over;
372
373         /*
374          * read/write mixed workload state
375          */
376         os_random_state_t rwmix_state;
377         unsigned long rwmix_issues;
378         enum fio_ddir rwmix_ddir;
379         unsigned int ddir_nr;
380
381         /*
382          * IO history logs for verification. We use a tree for sorting,
383          * if we are overwriting. Otherwise just use a fifo.
384          */
385         struct rb_root io_hist_tree;
386         struct flist_head io_hist_list;
387
388         /*
389          * For IO replaying
390          */
391         struct flist_head io_log_list;
392
393         /*
394          * for fileservice, how often to switch to a new file
395          */
396         unsigned int file_service_nr;
397         unsigned int file_service_left;
398         struct fio_file *file_service_file;
399
400         /*
401          * For generating file sizes
402          */
403         os_random_state_t file_size_state;
404
405         /*
406          * Error counts
407          */
408         unsigned int total_err_count;
409         int first_error;
410 };
411
412 /*
413  * when should interactive ETA output be generated
414  */
415 enum {
416         FIO_ETA_AUTO,
417         FIO_ETA_ALWAYS,
418         FIO_ETA_NEVER,
419 };
420
421 #define __td_verror(td, err, msg, func)                                 \
422         do {                                                            \
423                 if ((td)->error)                                        \
424                         break;                                          \
425                 int e = (err);                                          \
426                 (td)->error = e;                                        \
427                 if (!(td)->first_error)                                 \
428                         snprintf(td->verror, sizeof(td->verror) - 1, "file:%s:%d, func=%s, error=%s", __FILE__, __LINE__, (func), (msg));               \
429         } while (0)
430
431
432 #define td_clear_error(td)              \
433         (td)->error = 0;
434 #define td_verror(td, err, func)        \
435         __td_verror((td), (err), strerror((err)), (func))
436 #define td_vmsg(td, err, msg, func)     \
437         __td_verror((td), (err), (msg), (func))
438
439 extern int exitall_on_terminate;
440 extern int thread_number;
441 extern int nr_process, nr_thread;
442 extern int shm_id;
443 extern int groupid;
444 extern int terse_output;
445 extern int temp_stall_ts;
446 extern unsigned long long mlock_size;
447 extern unsigned long page_mask, page_size;
448 extern int read_only;
449 extern int eta_print;
450 extern unsigned long done_secs;
451 extern char *job_section;
452 extern int fio_gtod_offload;
453 extern int fio_gtod_cpu;
454
455 extern struct thread_data *threads;
456
457 static inline void fio_ro_check(struct thread_data *td, struct io_u *io_u)
458 {
459         assert(!(io_u->ddir == DDIR_WRITE && !td_write(td)));
460 }
461
462 #define BLOCKS_PER_MAP          (8 * sizeof(int))
463 #define TO_MAP_BLOCK(f, b)      (b)
464 #define RAND_MAP_IDX(f, b)      (TO_MAP_BLOCK(f, b) / BLOCKS_PER_MAP)
465 #define RAND_MAP_BIT(f, b)      (TO_MAP_BLOCK(f, b) & (BLOCKS_PER_MAP - 1))
466
467 #define MAX_JOBS        (1024)
468
469 #define td_non_fatal_error(e)   ((e) == EIO || (e) == EILSEQ)
470
471 static inline void update_error_count(struct thread_data *td, int err)
472 {
473         td->total_err_count++;
474         if (td->total_err_count == 1)
475                 td->first_error = err;
476 }
477
478 static inline int should_fsync(struct thread_data *td)
479 {
480         if (td->last_was_sync)
481                 return 0;
482         if (td->o.odirect)
483                 return 0;
484         if (td_write(td) || td_rw(td) || td->o.override_sync)
485                 return 1;
486
487         return 0;
488 }
489
490 /*
491  * Time functions
492  */
493 extern unsigned long long utime_since(struct timeval *, struct timeval *);
494 extern unsigned long long utime_since_now(struct timeval *);
495 extern unsigned long mtime_since(struct timeval *, struct timeval *);
496 extern unsigned long mtime_since_now(struct timeval *);
497 extern unsigned long time_since_now(struct timeval *);
498 extern unsigned long mtime_since_genesis(void);
499 extern void usec_spin(unsigned int);
500 extern void usec_sleep(struct thread_data *, unsigned long);
501 extern void fill_start_time(struct timeval *);
502 extern void fio_gettime(struct timeval *, void *);
503 extern void fio_gtod_init(void);
504 extern void fio_gtod_update(void);
505 extern void set_genesis_time(void);
506 extern int ramp_time_over(struct thread_data *);
507 extern int in_ramp_time(struct thread_data *);
508
509 /*
510  * Init/option functions
511  */
512 extern int __must_check parse_options(int, char **);
513 extern int fio_options_parse(struct thread_data *, char **, int);
514 extern void fio_keywords_init(void);
515 extern int fio_cmd_option_parse(struct thread_data *, const char *, char *);
516 extern void fio_fill_default_options(struct thread_data *);
517 extern int fio_show_option_help(const char *);
518 extern void fio_options_dup_and_init(struct option *);
519 extern void options_mem_dupe(struct thread_data *);
520 extern void options_mem_free(struct thread_data *);
521 extern void td_fill_rand_seeds(struct thread_data *);
522 #define FIO_GETOPT_JOB          0x89988998
523 #define FIO_NR_OPTIONS          128
524
525 /*
526  * ETA/status stuff
527  */
528 extern void print_thread_status(void);
529 extern void print_status_init(int);
530
531 /*
532  * Thread life cycle. Once a thread has a runstate beyond TD_INITIALIZED, it
533  * will never back again. It may cycle between running/verififying/fsyncing.
534  * Once the thread reaches TD_EXITED, it is just waiting for the core to
535  * reap it.
536  */
537 enum {
538         TD_NOT_CREATED = 0,
539         TD_CREATED,
540         TD_INITIALIZED,
541         TD_RAMP,
542         TD_RUNNING,
543         TD_PRE_READING,
544         TD_VERIFYING,
545         TD_FSYNCING,
546         TD_EXITED,
547         TD_REAPED,
548 };
549
550 extern void td_set_runstate(struct thread_data *, int);
551
552 /*
553  * Memory helpers
554  */
555 extern int __must_check fio_pin_memory(void);
556 extern void fio_unpin_memory(void);
557 extern int __must_check allocate_io_mem(struct thread_data *);
558 extern void free_io_mem(struct thread_data *);
559
560 /*
561  * Reset stats after ramp time completes
562  */
563 extern void reset_all_stats(struct thread_data *);
564
565 /*
566  * blktrace support
567  */
568 #ifdef FIO_HAVE_BLKTRACE
569 extern int is_blktrace(const char *);
570 extern int load_blktrace(struct thread_data *, const char *);
571 #endif
572
573 /*
574  * Mark unused variables passed to ops functions as unused, to silence gcc
575  */
576 #define fio_unused      __attribute((__unused__))
577 #define fio_init        __attribute__((constructor))
578 #define fio_exit        __attribute__((destructor))
579
580 #define for_each_td(td, i)      \
581         for ((i) = 0, (td) = &threads[0]; (i) < (int) thread_number; (i)++, (td)++)
582 #define for_each_file(td, f, i) \
583         if ((td)->files_index)                                          \
584                 for ((i) = 0, (f) = (td)->files[0];                     \
585                  (i) < (td)->o.nr_files && ((f) = (td)->files[i]) != NULL; \
586                  (i)++)
587
588 #define fio_assert(td, cond)    do {    \
589         if (!(cond)) {                  \
590                 int *__foo = NULL;      \
591                 fprintf(stderr, "file:%s:%d, assert %s failed\n", __FILE__, __LINE__, #cond);   \
592                 (td)->runstate = TD_EXITED;     \
593                 (td)->error = EFAULT;           \
594                 *__foo = 0;                     \
595         }       \
596 } while (0)
597
598 static inline int fio_fill_issue_time(struct thread_data *td)
599 {
600         if (td->o.read_iolog_file ||
601             !td->o.disable_clat || !td->o.disable_slat || !td->o.disable_bw)
602                 return 1;
603
604         return 0;
605 }
606
607 /*
608  * Cheesy number->string conversion, complete with carry rounding error.
609  */
610 static inline char *num2str(unsigned long num, int maxlen, int base, int pow2)
611 {
612         char postfix[] = { ' ', 'K', 'M', 'G', 'P', 'E' };
613         unsigned int thousand;
614         char *buf;
615         int i;
616
617         if (pow2)
618                 thousand = 1024;
619         else
620                 thousand = 1000;
621
622         buf = malloc(128);
623
624         for (i = 0; base > 1; i++)
625                 base /= thousand;
626
627         do {
628                 int len, carry = 0;
629
630                 len = sprintf(buf, "%'lu", num);
631                 if (len <= maxlen) {
632                         if (i >= 1) {
633                                 buf[len] = postfix[i];
634                                 buf[len + 1] = '\0';
635                         }
636                         return buf;
637                 }
638
639                 if ((num % thousand) >= (thousand / 2))
640                         carry = 1;
641
642                 num /= thousand;
643                 num += carry;
644                 i++;
645         } while (i <= 5);
646
647         return buf;
648 }
649
650 static inline int __should_check_rate(struct thread_data *td,
651                                       enum fio_ddir ddir)
652 {
653         struct thread_options *o = &td->o;
654
655         /*
656          * If some rate setting was given, we need to check it
657          */
658         if (o->rate[ddir] || o->ratemin[ddir] || o->rate_iops[ddir] ||
659             o->rate_iops_min[ddir])
660                 return 1;
661
662         return 0;
663 }
664
665 static inline int should_check_rate(struct thread_data *td,
666                                     unsigned long *bytes_done)
667 {
668         int ret = 0;
669
670         if (bytes_done[0])
671                 ret |= __should_check_rate(td, 0);
672         if (bytes_done[1])
673                 ret |= __should_check_rate(td, 1);
674
675         return ret;
676 }
677
678 static inline int is_power_of_2(unsigned int val)
679 {
680         return (val != 0 && ((val & (val - 1)) == 0));
681 }
682
683 /*
684  * We currently only need to do locking if we have verifier threads
685  * accessing our internal structures too
686  */
687 static inline void td_io_u_lock(struct thread_data *td)
688 {
689         if (td->o.verify_async)
690                 pthread_mutex_lock(&td->io_u_lock);
691 }
692
693 static inline void td_io_u_unlock(struct thread_data *td)
694 {
695         if (td->o.verify_async)
696                 pthread_mutex_unlock(&td->io_u_lock);
697 }
698
699 static inline void td_io_u_free_notify(struct thread_data *td)
700 {
701         if (td->o.verify_async)
702                 pthread_cond_signal(&td->free_cond);
703 }
704
705 #endif