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