blktrace improvements and fixups
[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 "list.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
28 #ifdef FIO_HAVE_GUASI
29 #include <guasi.h>
30 #endif
31
32 enum fio_ddir {
33         DDIR_READ = 0,
34         DDIR_WRITE,
35         DDIR_SYNC,
36         DDIR_INVAL = -1,
37 };
38
39 enum td_ddir {
40         TD_DDIR_READ            = 1 << 0,
41         TD_DDIR_WRITE           = 1 << 1,
42         TD_DDIR_RAND            = 1 << 2,
43         TD_DDIR_RW              = TD_DDIR_READ | TD_DDIR_WRITE,
44         TD_DDIR_RANDREAD        = TD_DDIR_READ | TD_DDIR_RAND,
45         TD_DDIR_RANDWRITE       = TD_DDIR_WRITE | TD_DDIR_RAND,
46         TD_DDIR_RANDRW          = TD_DDIR_RW | TD_DDIR_RAND,
47 };
48
49 enum file_lock_mode {
50         FILE_LOCK_NONE,
51         FILE_LOCK_EXCLUSIVE,
52         FILE_LOCK_READWRITE,
53 };
54
55 /*
56  * Use for maintaining statistics
57  */
58 struct io_stat {
59         unsigned long max_val;
60         unsigned long min_val;
61         unsigned long samples;
62
63         double mean;
64         double S;
65 };
66
67 /*
68  * A single data sample
69  */
70 struct io_sample {
71         unsigned long time;
72         unsigned long val;
73         enum fio_ddir ddir;
74 };
75
76 /*
77  * Dynamically growing data sample log
78  */
79 struct io_log {
80         unsigned long nr_samples;
81         unsigned long max_samples;
82         struct io_sample *log;
83 };
84
85 /*
86  * When logging io actions, this matches a single sent io_u
87  */
88 struct io_piece {
89         union {
90                 struct rb_node rb_node;
91                 struct list_head list;
92         };
93         union {
94                 int fileno;
95                 struct fio_file *file;
96         };
97         unsigned long long offset;
98         unsigned long len;
99         enum fio_ddir ddir;
100         union {
101                 unsigned long delay;
102                 unsigned int file_action;
103         };
104 };
105
106 enum {
107         IO_U_F_FREE     = 1 << 0,
108         IO_U_F_FLIGHT   = 1 << 1,
109 };
110
111 struct thread_data;
112
113 /*
114  * The io unit
115  */
116 struct io_u {
117         union {
118 #ifdef FIO_HAVE_LIBAIO
119                 struct iocb iocb;
120 #endif
121 #ifdef FIO_HAVE_POSIXAIO
122                 struct aiocb aiocb;
123 #endif
124 #ifdef FIO_HAVE_SGIO
125                 struct sg_io_hdr hdr;
126 #endif
127 #ifdef FIO_HAVE_GUASI
128                 guasi_req_t greq;
129 #endif
130         };
131         struct timeval start_time;
132         struct timeval issue_time;
133
134         /*
135          * Allocated/set buffer and length
136          */
137         void *buf;
138         unsigned long buflen;
139         unsigned long long offset;
140         unsigned long long endpos;
141
142         /*
143          * IO engine state, may be different from above when we get
144          * partial transfers / residual data counts
145          */
146         void *xfer_buf;
147         unsigned long xfer_buflen;
148
149         unsigned int resid;
150         unsigned int error;
151
152         enum fio_ddir ddir;
153
154         /*
155          * io engine private data
156          */
157         union {
158                 unsigned int index;
159                 unsigned int seen;
160         };
161
162         unsigned int flags;
163
164         struct fio_file *file;
165
166         struct list_head list;
167
168         /*
169          * Callback for io completion
170          */
171         int (*end_io)(struct thread_data *, struct io_u *);
172 };
173
174 /*
175  * io_ops->queue() return values
176  */
177 enum {
178         FIO_Q_COMPLETED = 0,            /* completed sync */
179         FIO_Q_QUEUED    = 1,            /* queued, will complete async */
180         FIO_Q_BUSY      = 2,            /* no more room, call ->commit() */
181 };
182
183 #define FIO_HDR_MAGIC   0xf00baaef
184
185 enum {
186         VERIFY_NONE = 0,                /* no verification */
187         VERIFY_MD5,                     /* md5 sum data blocks */
188         VERIFY_CRC64,                   /* crc64 sum data blocks */
189         VERIFY_CRC32,                   /* crc32 sum data blocks */
190         VERIFY_CRC16,                   /* crc16 sum data blocks */
191         VERIFY_CRC7,                    /* crc7 sum data blocks */
192         VERIFY_SHA256,                  /* sha256 sum data blocks */
193         VERIFY_SHA512,                  /* sha512 sum data blocks */
194         VERIFY_META,                    /* block_num, timestamp etc. */
195         VERIFY_NULL,                    /* pretend to verify */
196 };
197
198 /*
199  * A header structure associated with each checksummed data block. It is
200  * followed by a checksum specific header that contains the verification
201  * data.
202  */
203 struct verify_header {
204         unsigned int fio_magic;
205         unsigned int len;
206         unsigned int verify_type;
207 };
208
209 struct vhdr_md5 {
210         uint32_t md5_digest[16];
211 };
212 struct vhdr_sha512 {
213         uint8_t sha512[128];
214 };
215 struct vhdr_sha256 {
216         uint8_t sha256[128];
217 };
218 struct vhdr_crc64 {
219         uint64_t crc64;
220 };
221 struct vhdr_crc32 {
222         uint32_t crc32;
223 };
224 struct vhdr_crc16 {
225         uint16_t crc16;
226 };
227 struct vhdr_crc7 {
228         uint8_t crc7;
229 };
230 struct vhdr_meta {
231         uint64_t offset;
232         unsigned char thread;
233         unsigned short numberio;
234         unsigned long time_sec;
235         unsigned long time_usec;
236 };
237
238 struct group_run_stats {
239         unsigned long long max_run[2], min_run[2];
240         unsigned long long max_bw[2], min_bw[2];
241         unsigned long long io_kb[2];
242         unsigned long long agg[2];
243 };
244
245 /*
246  * What type of allocation to use for io buffers
247  */
248 enum fio_memtype {
249         MEM_MALLOC = 0, /* ordinary malloc */
250         MEM_SHM,        /* use shared memory segments */
251         MEM_SHMHUGE,    /* use shared memory segments with huge pages */
252         MEM_MMAP,       /* use anonynomous mmap */
253         MEM_MMAPHUGE,   /* memory mapped huge file */
254 };
255
256 /*
257  * The type of object we are working on
258  */
259 enum fio_filetype {
260         FIO_TYPE_FILE = 1,              /* plain file */
261         FIO_TYPE_BD,                    /* block device */
262         FIO_TYPE_CHAR,                  /* character device */
263         FIO_TYPE_PIPE,                  /* pipe */
264 };
265
266 enum fio_ioengine_flags {
267         FIO_SYNCIO      = 1 << 0,       /* io engine has synchronous ->queue */
268         FIO_RAWIO       = 1 << 1,       /* some sort of direct/raw io */
269         FIO_DISKLESSIO  = 1 << 2,       /* no disk involved */
270         FIO_NOEXTEND    = 1 << 3,       /* engine can't extend file */
271         FIO_NODISKUTIL  = 1 << 4,       /* diskutil can't handle filename */
272         FIO_UNIDIR      = 1 << 5,       /* engine is uni-directional */
273         FIO_NOIO        = 1 << 6,       /* thread does only pseudo IO */
274         FIO_SIGQUIT     = 1 << 7,       /* needs SIGQUIT to exit */
275 };
276
277 enum fio_file_flags {
278         FIO_FILE_OPEN           = 1 << 0,       /* file is open */
279         FIO_FILE_CLOSING        = 1 << 1,       /* file being closed */
280         FIO_FILE_EXTEND         = 1 << 2,       /* needs extend */
281         FIO_FILE_DONE           = 1 << 3,       /* io completed to this file */
282         FIO_SIZE_KNOWN          = 1 << 4,       /* size has been set */
283         FIO_FILE_HASHED         = 1 << 5,       /* file is on hash */
284 };
285
286 /*
287  * Each thread_data structure has a number of files associated with it,
288  * this structure holds state information for a single file.
289  */
290 struct fio_file {
291         struct list_head hash_list;
292         enum fio_filetype filetype;
293
294         /*
295          * A file may not be a file descriptor, let the io engine decide
296          */
297         union {
298                 unsigned long file_data;
299                 int fd;
300         };
301
302         /*
303          * filename and possible memory mapping
304          */
305         char *file_name;
306         void *mmap;
307         unsigned int major, minor;
308
309         /*
310          * size of the file, offset into file, and io size from that offset
311          */
312         unsigned long long real_file_size;
313         unsigned long long file_offset;
314         unsigned long long io_size;
315
316         unsigned long long last_pos;
317
318         /*
319          * if io is protected by a semaphore, this is set
320          */
321         struct fio_mutex *lock;
322         void *lock_owner;
323         unsigned int lock_batch;
324         enum fio_ddir lock_ddir;
325
326         /*
327          * block map for random io
328          */
329         unsigned long *file_map;
330         unsigned int num_maps;
331         unsigned int last_free_lookup;
332
333         int references;
334         enum fio_file_flags flags;
335 };
336
337 /*
338  * How many depth levels to log
339  */
340 #define FIO_IO_U_MAP_NR 8
341 #define FIO_IO_U_LAT_U_NR 10
342 #define FIO_IO_U_LAT_M_NR 12
343
344 struct thread_stat {
345         char *name;
346         char *verror;
347         int error;
348         int groupid;
349         pid_t pid;
350         char *description;
351         int members;
352
353         struct io_log *slat_log;
354         struct io_log *clat_log;
355         struct io_log *bw_log;
356
357         /*
358          * bandwidth and latency stats
359          */
360         struct io_stat clat_stat[2];            /* completion latency */
361         struct io_stat slat_stat[2];            /* submission latency */
362         struct io_stat bw_stat[2];              /* bandwidth stats */
363
364         unsigned long long stat_io_bytes[2];
365         struct timeval stat_sample_time[2];
366
367         /*
368          * fio system usage accounting
369          */
370         struct rusage ru_start;
371         struct rusage ru_end;
372         unsigned long usr_time;
373         unsigned long sys_time;
374         unsigned long ctx;
375         unsigned long minf, majf;
376
377         /*
378          * IO depth and latency stats
379          */
380         unsigned int io_u_map[FIO_IO_U_MAP_NR];
381         unsigned int io_u_lat_u[FIO_IO_U_LAT_U_NR];
382         unsigned int io_u_lat_m[FIO_IO_U_LAT_M_NR];
383         unsigned long total_io_u[2];
384         unsigned long short_io_u[2];
385
386         unsigned long long io_bytes[2];
387         unsigned long runtime[2];
388         unsigned long total_run_time;
389 };
390
391 struct bssplit {
392         unsigned int bs;
393         unsigned char perc;
394 };
395
396 struct thread_options {
397         int pad;
398         char *description;
399         char *name;
400         char *directory;
401         char *filename;
402         char *opendir;
403         char *ioengine;
404         enum td_ddir td_ddir;
405         unsigned int ddir_nr;
406         unsigned int iodepth;
407         unsigned int iodepth_low;
408         unsigned int iodepth_batch;
409
410         unsigned long long size;
411         unsigned int fill_device;
412         unsigned long long file_size_low;
413         unsigned long long file_size_high;
414         unsigned long long start_offset;
415
416         unsigned int bs[2];
417         unsigned int min_bs[2];
418         unsigned int max_bs[2];
419         struct bssplit *bssplit;
420         unsigned int bssplit_nr;
421
422         unsigned int nr_files;
423         unsigned int open_files;
424         enum file_lock_mode file_lock_mode;
425         unsigned int lockfile_batch;
426
427         unsigned int odirect;
428         unsigned int invalidate_cache;
429         unsigned int create_serialize;
430         unsigned int create_fsync;
431         unsigned int end_fsync;
432         unsigned int sync_io;
433         unsigned int verify;
434         unsigned int do_verify;
435         unsigned int verifysort;
436         unsigned int verify_interval;
437         unsigned int verify_offset;
438         unsigned int verify_pattern;
439         unsigned int verify_pattern_bytes;
440         unsigned int verify_fatal;
441         unsigned int use_thread;
442         unsigned int unlink;
443         unsigned int do_disk_util;
444         unsigned int override_sync;
445         unsigned int rand_repeatable;
446         unsigned int write_lat_log;
447         unsigned int write_bw_log;
448         unsigned int norandommap;
449         unsigned int bs_unaligned;
450         unsigned int fsync_on_close;
451
452         unsigned int hugepage_size;
453         unsigned int rw_min_bs;
454         unsigned int thinktime;
455         unsigned int thinktime_spin;
456         unsigned int thinktime_blocks;
457         unsigned int fsync_blocks;
458         unsigned int start_delay;
459         unsigned long long timeout;
460         unsigned int overwrite;
461         unsigned int bw_avg_time;
462         unsigned int loops;
463         unsigned long long zone_size;
464         unsigned long long zone_skip;
465         enum fio_memtype mem_type;
466
467         unsigned int stonewall;
468         unsigned int new_group;
469         unsigned int numjobs;
470         os_cpu_mask_t cpumask;
471         unsigned int cpumask_set;
472         unsigned int iolog;
473         unsigned int rwmixcycle;
474         unsigned int rwmix[2];
475         unsigned int nice;
476         unsigned int file_service_type;
477         unsigned int group_reporting;
478         unsigned int fadvise_hint;
479         unsigned int zero_buffers;
480         unsigned int time_based;
481
482         char *read_iolog_file;
483         char *write_iolog_file;
484
485         /*
486          * Pre-run and post-run shell
487          */
488         char *exec_prerun;
489         char *exec_postrun;
490
491         unsigned int rate;
492         unsigned int ratemin;
493         unsigned int ratecycle;
494         unsigned int rate_iops;
495         unsigned int rate_iops_min;
496
497         char *ioscheduler;
498
499         /*
500          * CPU "io" cycle burner
501          */
502         unsigned int cpuload;
503         unsigned int cpucycle;
504 };
505
506 #define FIO_VERROR_SIZE 128
507
508 /*
509  * This describes a single thread/process executing a fio job.
510  */
511 struct thread_data {
512         struct thread_options o;
513         char verror[FIO_VERROR_SIZE];
514         pthread_t thread;
515         int thread_number;
516         int groupid;
517         struct thread_stat ts;
518         struct fio_file **files;
519         unsigned int files_index;
520         unsigned int nr_open_files;
521         unsigned int nr_done_files;
522         unsigned int nr_normal_files;
523         union {
524                 unsigned int next_file;
525                 os_random_state_t next_file_state;
526         };
527         int error;
528         int done;
529         pid_t pid;
530         char *orig_buffer;
531         size_t orig_buffer_size;
532         volatile int terminate;
533         volatile int runstate;
534         unsigned int ioprio;
535         unsigned int ioprio_set;
536         unsigned int last_was_sync;
537
538         char *mmapfile;
539         int mmapfd;
540
541         void *iolog_buf;
542         FILE *iolog_f;
543
544         char *sysfs_root;
545
546         os_random_state_t bsrange_state;
547         os_random_state_t verify_state;
548
549         int shm_id;
550
551         /*
552          * IO engine hooks, contains everything needed to submit an io_u
553          * to any of the available IO engines.
554          */
555         struct ioengine_ops *io_ops;
556
557         /*
558          * Current IO depth and list of free and busy io_u's.
559          */
560         unsigned int cur_depth;
561         struct list_head io_u_freelist;
562         struct list_head io_u_busylist;
563         struct list_head io_u_requeues;
564         unsigned int io_u_queued;
565
566         /*
567          * Rate state
568          */
569         unsigned long rate_usec_cycle;
570         long rate_pending_usleep;
571         unsigned long rate_bytes;
572         unsigned long rate_blocks;
573         struct timeval lastrate;
574
575         unsigned long long total_io_size;
576
577         unsigned long io_issues[2];
578         unsigned long long io_blocks[2];
579         unsigned long long io_bytes[2];
580         unsigned long long io_skip_bytes;
581         unsigned long long this_io_bytes[2];
582         unsigned long long zone_bytes;
583         struct fio_mutex *mutex;
584
585         /*
586          * State for random io, a bitmap of blocks done vs not done
587          */
588         os_random_state_t random_state;
589
590         struct timeval start;   /* start of this loop */
591         struct timeval epoch;   /* time job was started */
592         struct timeval rw_end[2];
593         struct timeval last_issue;
594         unsigned int rw_end_set[2];
595
596         /*
597          * read/write mixed workload state
598          */
599         os_random_state_t rwmix_state;
600         unsigned long long rwmix_bytes;
601         struct timeval rwmix_switch;
602         enum fio_ddir rwmix_ddir;
603         unsigned int ddir_nr;
604
605         /*
606          * IO history logs for verification. We use a tree for sorting,
607          * if we are overwriting. Otherwise just use a fifo.
608          */
609         struct rb_root io_hist_tree;
610         struct list_head io_hist_list;
611
612         /*
613          * For IO replaying
614          */
615         struct list_head io_log_list;
616
617         /*
618          * timeout handling
619          */
620         struct timeval timeout_end;
621         struct itimerval timer;
622
623         /*
624          * for fileservice, how often to switch to a new file
625          */
626         unsigned int file_service_nr;
627         unsigned int file_service_left;
628         struct fio_file *file_service_file;
629
630         /*
631          * For generating file sizes
632          */
633         os_random_state_t file_size_state;
634 };
635
636 /*
637  * roundrobin available files, or choose one at random.
638  */
639 enum {
640         FIO_FSERVICE_RANDOM     = 1,
641         FIO_FSERVICE_RR         = 2,
642 };
643
644 /*
645  * when should interactive ETA output be generated
646  */
647 enum {
648         FIO_ETA_AUTO,
649         FIO_ETA_ALWAYS,
650         FIO_ETA_NEVER,
651 };
652
653 /*
654  * 30 second per-io_u timeout, with 5 second intervals to avoid resetting
655  * the timer on each queue operation.
656  */
657 #define IO_U_TIMEOUT_INC        5
658 #define IO_U_TIMEOUT            30
659
660 #define __td_verror(td, err, msg, func)                                 \
661         do {                                                            \
662                 if ((td)->error)                                        \
663                         break;                                          \
664                 int e = (err);                                          \
665                 (td)->error = e;                                        \
666                 snprintf(td->verror, sizeof(td->verror) - 1, "file:%s:%d, func=%s, error=%s", __FILE__, __LINE__, (func), (msg));       \
667         } while (0)
668
669
670 #define td_verror(td, err, func)        \
671         __td_verror((td), (err), strerror((err)), (func))
672 #define td_vmsg(td, err, msg, func)     \
673         __td_verror((td), (err), (msg), (func))
674
675 extern int exitall_on_terminate;
676 extern int thread_number;
677 extern int nr_process, nr_thread;
678 extern int shm_id;
679 extern int groupid;
680 extern int terse_output;
681 extern int temp_stall_ts;
682 extern unsigned long long mlock_size;
683 extern unsigned long page_mask, page_size;
684 extern int read_only;
685 extern int eta_print;
686 extern char *job_section;
687
688 extern struct thread_data *threads;
689
690 #define td_read(td)             ((td)->o.td_ddir & TD_DDIR_READ)
691 #define td_write(td)            ((td)->o.td_ddir & TD_DDIR_WRITE)
692 #define td_rw(td)               (((td)->o.td_ddir & TD_DDIR_RW) == TD_DDIR_RW)
693 #define td_random(td)           ((td)->o.td_ddir & TD_DDIR_RAND)
694
695 static inline void fio_ro_check(struct thread_data *td, struct io_u *io_u)
696 {
697         assert(!(io_u->ddir == DDIR_WRITE && !td_write(td)));
698 }
699
700 #define BLOCKS_PER_MAP          (8 * sizeof(long))
701 #define TO_MAP_BLOCK(td, f, b)  (b)
702 #define RAND_MAP_IDX(td, f, b)  (TO_MAP_BLOCK(td, f, b) / BLOCKS_PER_MAP)
703 #define RAND_MAP_BIT(td, f, b)  (TO_MAP_BLOCK(td, f, b) & (BLOCKS_PER_MAP - 1))
704
705 #define MAX_JOBS        (1024)
706
707 static inline int should_fsync(struct thread_data *td)
708 {
709         if (td->last_was_sync)
710                 return 0;
711         if (td->o.odirect)
712                 return 0;
713         if (td_write(td) || td_rw(td) || td->o.override_sync)
714                 return 1;
715
716         return 0;
717 }
718
719 /*
720  * Disk utils as read in /sys/block/<dev>/stat
721  */
722 struct disk_util_stat {
723         unsigned ios[2];
724         unsigned merges[2];
725         unsigned long long sectors[2];
726         unsigned ticks[2];
727         unsigned io_ticks;
728         unsigned time_in_queue;
729 };
730
731 /*
732  * Per-device disk util management
733  */
734 struct disk_util {
735         struct list_head list;
736
737         char *name;
738         char *sysfs_root;
739         char path[256];
740         int major, minor;
741
742         struct disk_util_stat dus;
743         struct disk_util_stat last_dus;
744
745         unsigned long msec;
746         struct timeval time;
747 };
748
749 #define DISK_UTIL_MSEC  (250)
750
751 /*
752  * Log exports
753  */
754 enum file_log_act {
755         FIO_LOG_ADD_FILE,
756         FIO_LOG_OPEN_FILE,
757         FIO_LOG_CLOSE_FILE,
758 };
759
760 extern int __must_check read_iolog_get(struct thread_data *, struct io_u *);
761 extern void log_io_u(struct thread_data *, struct io_u *);
762 extern void log_file(struct thread_data *, struct fio_file *, enum file_log_act);
763 extern int __must_check init_iolog(struct thread_data *td);
764 extern void log_io_piece(struct thread_data *, struct io_u *);
765 extern void queue_io_piece(struct thread_data *, struct io_piece *);
766 extern void prune_io_piece_log(struct thread_data *);
767 extern void write_iolog_close(struct thread_data *);
768
769 /*
770  * Logging
771  */
772 extern void add_clat_sample(struct thread_data *, enum fio_ddir, unsigned long);
773 extern void add_slat_sample(struct thread_data *, enum fio_ddir, unsigned long);
774 extern void add_bw_sample(struct thread_data *, enum fio_ddir, struct timeval *);
775 extern void show_run_stats(void);
776 extern void init_disk_util(struct thread_data *);
777 extern void update_rusage_stat(struct thread_data *);
778 extern void update_io_ticks(void);
779 extern void disk_util_timer_arm(void);
780 extern void setup_log(struct io_log **);
781 extern void finish_log(struct thread_data *, struct io_log *, const char *);
782 extern void __finish_log(struct io_log *, const char *);
783 extern struct io_log *agg_io_log[2];
784 extern int write_bw_log;
785 extern void add_agg_sample(unsigned long, enum fio_ddir);
786
787 /*
788  * Time functions
789  */
790 extern unsigned long long utime_since(struct timeval *, struct timeval *);
791 extern unsigned long long utime_since_now(struct timeval *);
792 extern unsigned long mtime_since(struct timeval *, struct timeval *);
793 extern unsigned long mtime_since_now(struct timeval *);
794 extern unsigned long time_since_now(struct timeval *);
795 extern unsigned long mtime_since_genesis(void);
796 extern void __usec_sleep(unsigned int);
797 extern void usec_sleep(struct thread_data *, unsigned long);
798 extern void rate_throttle(struct thread_data *, unsigned long, unsigned int);
799 extern void fill_start_time(struct timeval *);
800 extern void fio_gettime(struct timeval *, void *);
801 extern void set_genesis_time(void);
802
803 /*
804  * Init/option functions
805  */
806 extern int __must_check parse_options(int, char **);
807 extern int fio_option_parse(struct thread_data *, const char *);
808 extern int fio_cmd_option_parse(struct thread_data *, const char *, char *);
809 extern void fio_fill_default_options(struct thread_data *);
810 extern int fio_show_option_help(const char *);
811 extern void fio_options_dup_and_init(struct option *);
812 extern void options_mem_dupe(struct thread_data *);
813 extern void options_mem_free(struct thread_data *);
814 #define FIO_GETOPT_JOB          0x89988998
815 #define FIO_NR_OPTIONS          128
816
817 /*
818  * File setup/shutdown
819  */
820 extern void close_files(struct thread_data *);
821 extern void close_and_free_files(struct thread_data *);
822 extern int __must_check setup_files(struct thread_data *);
823 extern int __must_check open_files(struct thread_data *);
824 extern int __must_check file_invalidate_cache(struct thread_data *, struct fio_file *);
825 extern int __must_check generic_open_file(struct thread_data *, struct fio_file *);
826 extern int __must_check generic_close_file(struct thread_data *, struct fio_file *);
827 extern int add_file(struct thread_data *, const char *);
828 extern void get_file(struct fio_file *);
829 extern int __must_check put_file(struct thread_data *, struct fio_file *);
830 extern void lock_file(struct thread_data *, struct fio_file *, enum fio_ddir);
831 extern void unlock_file(struct thread_data *, struct fio_file *);
832 extern void unlock_file_all(struct thread_data *, struct fio_file *);
833 extern int add_dir_files(struct thread_data *, const char *);
834 extern int init_random_map(struct thread_data *);
835 extern void dup_files(struct thread_data *, struct thread_data *);
836 extern int get_fileno(struct thread_data *, const char *);
837 extern void free_release_files(struct thread_data *);
838
839 /*
840  * ETA/status stuff
841  */
842 extern void print_thread_status(void);
843 extern void print_status_init(int);
844
845 /*
846  * disk util stuff
847  */
848 #ifdef FIO_HAVE_DISK_UTIL
849 extern void show_disk_util(void);
850 extern void disk_util_timer_arm(void);
851 extern void init_disk_util(struct thread_data *);
852 extern void update_io_ticks(void);
853 #else
854 #define show_disk_util()
855 #define disk_util_timer_arm()
856 #define init_disk_util(td)
857 #define update_io_ticks()
858 #endif
859
860 /*
861  * Thread life cycle. Once a thread has a runstate beyond TD_INITIALIZED, it
862  * will never back again. It may cycle between running/verififying/fsyncing.
863  * Once the thread reaches TD_EXITED, it is just waiting for the core to
864  * reap it.
865  */
866 enum {
867         TD_NOT_CREATED = 0,
868         TD_CREATED,
869         TD_INITIALIZED,
870         TD_RUNNING,
871         TD_VERIFYING,
872         TD_FSYNCING,
873         TD_EXITED,
874         TD_REAPED,
875 };
876
877 /*
878  * Verify helpers
879  */
880 extern void populate_verify_io_u(struct thread_data *, struct io_u *);
881 extern int __must_check get_next_verify(struct thread_data *td, struct io_u *);
882 extern int __must_check verify_io_u(struct thread_data *, struct io_u *);
883
884 /*
885  * Memory helpers
886  */
887 extern int __must_check fio_pin_memory(void);
888 extern void fio_unpin_memory(void);
889 extern int __must_check allocate_io_mem(struct thread_data *);
890 extern void free_io_mem(struct thread_data *);
891
892 /*
893  * io unit handling
894  */
895 #define queue_full(td)  list_empty(&(td)->io_u_freelist)
896 extern struct io_u *__get_io_u(struct thread_data *);
897 extern struct io_u *get_io_u(struct thread_data *);
898 extern void put_io_u(struct thread_data *, struct io_u *);
899 extern void requeue_io_u(struct thread_data *, struct io_u **);
900 extern long __must_check io_u_sync_complete(struct thread_data *, struct io_u *);
901 extern long __must_check io_u_queued_complete(struct thread_data *, int);
902 extern void io_u_queued(struct thread_data *, struct io_u *);
903 extern void io_u_log_error(struct thread_data *, struct io_u *);
904 extern void io_u_init_timeout(void);
905 extern void io_u_set_timeout(struct thread_data *);
906 extern void io_u_mark_depth(struct thread_data *, struct io_u *);
907
908 /*
909  * io engine entry points
910  */
911 extern int __must_check td_io_init(struct thread_data *);
912 extern int __must_check td_io_prep(struct thread_data *, struct io_u *);
913 extern int __must_check td_io_queue(struct thread_data *, struct io_u *);
914 extern int __must_check td_io_sync(struct thread_data *, struct fio_file *);
915 extern int __must_check td_io_getevents(struct thread_data *, unsigned int, unsigned int, struct timespec *);
916 extern int __must_check td_io_commit(struct thread_data *);
917 extern int __must_check td_io_open_file(struct thread_data *, struct fio_file *);
918 extern int td_io_close_file(struct thread_data *, struct fio_file *);
919
920 /*
921  * blktrace support
922  */
923 #ifdef FIO_HAVE_BLKTRACE
924 extern int is_blktrace(const char *);
925 extern int load_blktrace(struct thread_data *, const char *);
926 #endif
927
928 struct ioengine_ops {
929         struct list_head list;
930         char name[16];
931         int version;
932         int flags;
933         int (*setup)(struct thread_data *);
934         int (*init)(struct thread_data *);
935         int (*prep)(struct thread_data *, struct io_u *);
936         int (*queue)(struct thread_data *, struct io_u *);
937         int (*commit)(struct thread_data *);
938         int (*getevents)(struct thread_data *, unsigned int, unsigned int, struct timespec *);
939         struct io_u *(*event)(struct thread_data *, int);
940         int (*cancel)(struct thread_data *, struct io_u *);
941         void (*cleanup)(struct thread_data *);
942         int (*open_file)(struct thread_data *, struct fio_file *);
943         int (*close_file)(struct thread_data *, struct fio_file *);
944         void *data;
945         void *dlhandle;
946 };
947
948 #define FIO_IOOPS_VERSION       9
949
950 extern struct ioengine_ops *load_ioengine(struct thread_data *, const char *);
951 extern void register_ioengine(struct ioengine_ops *);
952 extern void unregister_ioengine(struct ioengine_ops *);
953 extern void close_ioengine(struct thread_data *);
954
955 /*
956  * Mark unused variables passed to ops functions as unused, to silence gcc
957  */
958 #define fio_unused      __attribute((__unused__))
959 #define fio_init        __attribute__((constructor))
960 #define fio_exit        __attribute__((destructor))
961
962 #define for_each_td(td, i)      \
963         for ((i) = 0, (td) = &threads[0]; (i) < (int) thread_number; (i)++, (td)++)
964 #define for_each_file(td, f, i) \
965         if ((td)->files_index)                                          \
966                 for ((i) = 0, (f) = (td)->files[0];                     \
967                  (i) < (td)->o.nr_files && ((f) = (td)->files[i]) != NULL; \
968                  (i)++)
969
970 #define fio_assert(td, cond)    do {    \
971         if (!(cond)) {                  \
972                 int *__foo = NULL;      \
973                 fprintf(stderr, "file:%s:%d, assert %s failed\n", __FILE__, __LINE__, #cond);   \
974                 (td)->runstate = TD_EXITED;     \
975                 (td)->error = EFAULT;           \
976                 *__foo = 0;                     \
977         }       \
978 } while (0)
979
980 static inline void clear_error(struct thread_data *td)
981 {
982         td->error = 0;
983         td->verror[0] = '\0';
984 }
985
986 #ifdef FIO_INC_DEBUG
987 static inline void dprint_io_u(struct io_u *io_u, const char *p)
988 {
989         struct fio_file *f = io_u->file;
990
991         dprint(FD_IO, "%s: io_u %p: off=%llu/len=%lu/ddir=%d", p, io_u,
992                                         io_u->offset, io_u->buflen, io_u->ddir);
993         if (fio_debug & (1 << FD_IO)) {
994                 if (f)
995                         log_info("/%s", f->file_name);
996
997                 log_info("\n");
998         }
999 }
1000 #else
1001 #define dprint_io_u(io_u, p)
1002 #endif
1003
1004 #endif