4af6a74339468ea32000680abd16dc8c4bf54809
[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
14 #include "list.h"
15 #include "md5.h"
16 #include "crc32.h"
17 #include "arch.h"
18 #include "os.h"
19
20 struct io_stat {
21         unsigned long val;
22         unsigned long val_sq;
23         unsigned long max_val;
24         unsigned long min_val;
25         unsigned long samples;
26 };
27
28 struct io_sample {
29         unsigned long time;
30         unsigned long val;
31         unsigned int ddir;
32 };
33
34 struct io_log {
35         unsigned long nr_samples;
36         unsigned long max_samples;
37         struct io_sample *log;
38 };
39
40 struct io_piece {
41         struct list_head list;
42         struct fio_file *file;
43         unsigned long long offset;
44         unsigned int len;
45         int ddir;
46 };
47
48 /*
49  * The io unit
50  */
51 struct io_u {
52         union {
53 #ifdef FIO_HAVE_LIBAIO
54                 struct iocb iocb;
55 #endif
56 #ifdef FIO_HAVE_POSIXAIO
57                 struct aiocb aiocb;
58 #endif
59 #ifdef FIO_HAVE_SGIO
60                 struct sg_io_hdr hdr;
61 #endif
62         };
63         struct timeval start_time;
64         struct timeval issue_time;
65
66         char *buf;
67         unsigned int buflen;
68         unsigned long long offset;
69         unsigned int index;
70
71         unsigned int resid;
72         unsigned int error;
73
74         unsigned char seen;
75         unsigned char ddir;
76
77         struct fio_file *file;
78
79         struct list_head list;
80 };
81
82 #define FIO_HDR_MAGIC   0xf00baaef
83
84 enum {
85         VERIFY_NONE = 0,
86         VERIFY_MD5,
87         VERIFY_CRC32,
88 };
89
90 struct verify_header {
91         unsigned int fio_magic;
92         unsigned int len;
93         unsigned int verify_type;
94         union {
95                 char md5_digest[MD5_HASH_WORDS * 4];
96                 unsigned long crc32;
97         };
98 };
99
100 struct group_run_stats {
101         unsigned long long max_run[2], min_run[2];
102         unsigned long long max_bw[2], min_bw[2];
103         unsigned long long io_kb[2];
104         unsigned long long agg[2];
105 };
106
107 enum fio_ddir {
108         DDIR_READ = 0,
109         DDIR_WRITE,
110 };
111
112 /*
113  * What type of allocation to use for io buffers
114  */
115 enum fio_memtype {
116         MEM_MALLOC = 0, /* ordinary malloc */
117         MEM_SHM,        /* use shared memory segments */
118         MEM_MMAP,       /* use anonynomous mmap */
119 };
120
121 /*
122  * The type of object we are working on
123  */
124 enum fio_filetype {
125         FIO_TYPE_FILE = 1,
126         FIO_TYPE_BD,
127         FIO_TYPE_CHAR,
128 };
129
130 enum fio_ioengine_flags {
131         FIO_SYNCIO      = 1 << 0,
132         FIO_CPUIO       = 1 << 1,
133         FIO_MMAPIO      = 1 << 2,
134         FIO_RAWIO       = 1 << 3,
135 };
136
137 struct fio_file {
138         /*
139          * A file may not be a file descriptor, let the io engine decide
140          */
141         union {
142                 unsigned long file_data;
143                 int fd;
144         };
145         char *file_name;
146         void *mmap;
147         unsigned long long file_size;
148         unsigned long long real_file_size;
149         unsigned long long file_offset;
150         unsigned long long last_pos;
151
152         unsigned long *file_map;
153         unsigned int num_maps;
154
155         int fileno;
156 };
157
158 /*
159  * This describes a single thread/process executing a fio job.
160  */
161 struct thread_data {
162         char name[32];
163         char *directory;
164         char verror[80];
165         pthread_t thread;
166         int thread_number;
167         int groupid;
168         enum fio_filetype filetype;
169         struct fio_file *files;
170         unsigned int nr_files;
171         unsigned int next_file;
172         int error;
173         pid_t pid;
174         char *orig_buffer;
175         size_t orig_buffer_size;
176         volatile int terminate;
177         volatile int runstate;
178         enum fio_ddir ddir;
179         unsigned int iomix;
180         unsigned int ioprio;
181
182         unsigned char sequential;
183         unsigned char odirect;
184         unsigned char invalidate_cache;
185         unsigned char create_serialize;
186         unsigned char create_fsync;
187         unsigned char end_fsync;
188         unsigned char sync_io;
189         unsigned char verify;
190         unsigned char use_thread;
191         unsigned char unlink;
192         unsigned char do_disk_util;
193         unsigned char override_sync;
194         unsigned char rand_repeatable;
195         unsigned char write_lat_log;
196         unsigned char write_bw_log;
197
198         unsigned int bs;
199         unsigned int min_bs;
200         unsigned int max_bs;
201         unsigned int thinktime;
202         unsigned int fsync_blocks;
203         unsigned int start_delay;
204         unsigned long timeout;
205         unsigned int overwrite;
206         unsigned int bw_avg_time;
207         unsigned int loops;
208         unsigned long long zone_size;
209         unsigned long long zone_skip;
210         enum fio_memtype mem_type;
211         unsigned int stonewall;
212         unsigned int numjobs;
213         unsigned int iodepth;
214         os_cpu_mask_t cpumask;
215         unsigned int iolog;
216         unsigned int read_iolog;
217         unsigned int write_iolog;
218         unsigned int rwmixcycle;
219         unsigned int rwmixread;
220         unsigned int nice;
221
222         char *iolog_file;
223         void *iolog_buf;
224         FILE *iolog_f;
225
226         char *sysfs_root;
227         char *ioscheduler;
228
229         os_random_state_t bsrange_state;
230         os_random_state_t verify_state;
231
232         int shm_id;
233
234         /*
235          * IO engine hooks, contains everything needed to submit an io_u
236          * to any of the available IO engines.
237          */
238         struct ioengine_ops *io_ops;
239
240         /*
241          * Current IO depth and list of free and busy io_u's.
242          */
243         unsigned int cur_depth;
244         struct list_head io_u_freelist;
245         struct list_head io_u_busylist;
246
247         /*
248          * Rate state
249          */
250         unsigned int rate;
251         unsigned int ratemin;
252         unsigned int ratecycle;
253         unsigned long rate_usec_cycle;
254         long rate_pending_usleep;
255         unsigned long rate_bytes;
256         struct timeval lastrate;
257
258         unsigned long runtime[2];               /* msec */
259         unsigned long long io_size;
260         unsigned long long total_file_size;
261         unsigned long long start_offset;
262         unsigned long long total_io_size;
263
264         unsigned long long io_blocks[2];
265         unsigned long long io_bytes[2];
266         unsigned long long zone_bytes;
267         unsigned long long this_io_bytes[2];
268         volatile int mutex;
269
270         /*
271          * State for random io, a bitmap of blocks done vs not done
272          */
273         os_random_state_t random_state;
274
275         /*
276          * CPU "io" cycle burner
277          */
278         unsigned int cpuload;
279         unsigned int cpucycle;
280
281         /*
282          * bandwidth and latency stats
283          */
284         struct io_stat clat_stat[2];            /* completion latency */
285         struct io_stat slat_stat[2];            /* submission latency */
286         struct io_stat bw_stat[2];              /* bandwidth stats */
287
288         unsigned long long stat_io_bytes[2];
289         struct timeval stat_sample_time[2];
290
291         struct io_log *slat_log;
292         struct io_log *clat_log;
293         struct io_log *bw_log;
294
295         struct timeval start;   /* start of this loop */
296         struct timeval epoch;   /* time job was started */
297
298         /*
299          * fio system usage accounting
300          */
301         struct rusage ru_start;
302         struct rusage ru_end;
303         unsigned long usr_time;
304         unsigned long sys_time;
305         unsigned long ctx;
306
307         /*
308          * read/write mixed workload state
309          */
310         os_random_state_t rwmix_state;
311         struct timeval rwmix_switch;
312         enum fio_ddir rwmix_ddir;
313
314         /*
315          * Pre-run and post-run shell
316          */
317         char *exec_prerun;
318         char *exec_postrun;
319
320         /*
321          * IO historic logs
322          */
323         struct list_head io_hist_list;
324         struct list_head io_log_list;
325 };
326
327 #define __td_verror(td, err, msg)                                       \
328         do {                                                            \
329                 int e = (err);                                          \
330                 (td)->error = e;                                        \
331                 snprintf(td->verror, sizeof(td->verror) - 1, "file:%s:%d, error=%s", __FILE__, __LINE__, (msg));        \
332         } while (0)
333
334
335 #define td_verror(td, err)      __td_verror((td), (err), strerror((err)))
336 #define td_vmsg(td, err, msg)   __td_verror((td), (err), (msg))
337
338 extern struct io_u *__get_io_u(struct thread_data *);
339 extern void put_io_u(struct thread_data *, struct io_u *);
340
341 extern int rate_quit;
342 extern int exitall_on_terminate;
343 extern int thread_number;
344 extern int shm_id;
345 extern int groupid;
346 extern int terse_output;
347 extern FILE *f_out;
348 extern FILE *f_err;
349 extern char *fio_inst_prefix;
350 extern int temp_stall_ts;
351
352 extern struct thread_data *threads;
353
354 #define td_read(td)             ((td)->ddir == DDIR_READ)
355 #define td_write(td)            ((td)->ddir == DDIR_WRITE)
356 #define td_rw(td)               ((td)->iomix != 0)
357
358 #define BLOCKS_PER_MAP          (8 * sizeof(long))
359 #define TO_MAP_BLOCK(td, f, b)  ((b) - ((f)->file_offset / (td)->min_bs))
360 #define RAND_MAP_IDX(td, f, b)  (TO_MAP_BLOCK(td, f, b) / BLOCKS_PER_MAP)
361 #define RAND_MAP_BIT(td, f, b)  (TO_MAP_BLOCK(td, f, b) & (BLOCKS_PER_MAP - 1))
362
363 #define MAX_JOBS        (1024)
364
365 struct disk_util_stat {
366         unsigned ios[2];
367         unsigned merges[2];
368         unsigned long long sectors[2];
369         unsigned ticks[2];
370         unsigned io_ticks;
371         unsigned time_in_queue;
372 };
373
374 struct disk_util {
375         struct list_head list;
376
377         char *name;
378         char path[256];
379         dev_t dev;
380
381         struct disk_util_stat dus;
382         struct disk_util_stat last_dus;
383
384         unsigned long msec;
385         struct timeval time;
386 };
387
388 struct io_completion_data {
389         int nr;                         /* input */
390
391         int error;                      /* output */
392         unsigned long bytes_done[2];    /* output */
393 };
394
395 #define DISK_UTIL_MSEC  (250)
396
397 #ifndef min
398 #define min(a, b)       ((a) < (b) ? (a) : (b))
399 #endif
400
401 /*
402  * Log exports
403  */
404 extern int read_iolog_get(struct thread_data *, struct io_u *);
405 extern void write_iolog_put(struct thread_data *, struct io_u *);
406 extern int init_iolog(struct thread_data *td);
407 extern void log_io_piece(struct thread_data *, struct io_u *);
408 extern void prune_io_piece_log(struct thread_data *);
409 extern void write_iolog_close(struct thread_data *);
410
411 /*
412  * Logging
413  */
414 extern void add_clat_sample(struct thread_data *, int, unsigned long);
415 extern void add_slat_sample(struct thread_data *, int, unsigned long);
416 extern void add_bw_sample(struct thread_data *, int);
417 extern void show_run_stats(void);
418 extern void init_disk_util(struct thread_data *);
419 extern void update_rusage_stat(struct thread_data *);
420 extern void update_io_ticks(void);
421 extern void disk_util_timer_arm(void);
422 extern void setup_log(struct io_log **);
423 extern void finish_log(struct thread_data *, struct io_log *, const char *);
424 extern int setup_rate(struct thread_data *);
425
426 /*
427  * Time functions
428  */
429 extern void time_init(void);
430 extern unsigned long utime_since(struct timeval *, struct timeval *);
431 extern unsigned long mtime_since(struct timeval *, struct timeval *);
432 extern unsigned long mtime_since_now(struct timeval *);
433 extern unsigned long time_since_now(struct timeval *);
434 extern unsigned long mtime_since_genesis(void);
435 extern void __usec_sleep(unsigned int);
436 extern void usec_sleep(struct thread_data *, unsigned long);
437 extern void rate_throttle(struct thread_data *, unsigned long, unsigned int);
438
439 /*
440  * Init functions
441  */
442 extern int parse_options(int, char **);
443 extern int init_random_state(struct thread_data *);
444
445 /*
446  * File setup/shutdown
447  */
448 extern void close_files(struct thread_data *);
449 extern int setup_files(struct thread_data *);
450 extern int file_invalidate_cache(struct thread_data *, struct fio_file *);
451
452 /*
453  * ETA/status stuff
454  */
455 extern void print_thread_status(void);
456 extern void print_status_init(int);
457
458 /*
459  * Thread life cycle. Once a thread has a runstate beyond TD_INITIALIZED, it
460  * will never back again. It may cycle between running/verififying/fsyncing.
461  * Once the thread reaches TD_EXITED, it is just waiting for the core to
462  * reap it.
463  */
464 enum {
465         TD_NOT_CREATED = 0,
466         TD_CREATED,
467         TD_INITIALIZED,
468         TD_RUNNING,
469         TD_VERIFYING,
470         TD_FSYNCING,
471         TD_EXITED,
472         TD_REAPED,
473 };
474
475 /*
476  * Verify helpers
477  */
478 extern void populate_verify_io_u(struct thread_data *, struct io_u *);
479 extern int get_next_verify(struct thread_data *td, struct io_u *);
480 extern int do_io_u_verify(struct thread_data *, struct io_u **);
481
482 /*
483  * This is a pretty crappy semaphore implementation, but with the use that fio
484  * has (just signalling start/go conditions), it doesn't have to be better.
485  * Naturally this would not work for any type of contended semaphore or
486  * for real locking.
487  */
488 static inline void fio_sem_init(volatile int *sem, int val)
489 {
490         *sem = val;
491 }
492
493 static inline void fio_sem_down(volatile int *sem)
494 {
495         while (*sem == 0)
496                 usleep(10000);
497
498         (*sem)--;
499 }
500
501 static inline void fio_sem_up(volatile int *sem)
502 {
503         (*sem)++;
504 }
505
506 /*
507  * If logging output to a file, stderr should go to both stderr and f_err
508  */
509 #define log_err(args...)        do {            \
510         fprintf(f_err, ##args);                 \
511         if (f_err != stderr)                    \
512                 fprintf(stderr, ##args);        \
513         } while (0)
514
515 struct ioengine_ops {
516         char name[16];
517         int version;
518         int flags;
519         int (*setup)(struct thread_data *);
520         int (*init)(struct thread_data *);
521         int (*prep)(struct thread_data *, struct io_u *);
522         int (*queue)(struct thread_data *, struct io_u *);
523         int (*getevents)(struct thread_data *, int, int, struct timespec *);
524         struct io_u *(*event)(struct thread_data *, int);
525         int (*cancel)(struct thread_data *, struct io_u *);
526         void (*cleanup)(struct thread_data *);
527         int (*sync)(struct thread_data *, struct fio_file *);
528         void *data;
529         void *dlhandle;
530 };
531
532 #define FIO_IOOPS_VERSION       2
533
534 extern struct ioengine_ops *load_ioengine(struct thread_data *, char *);
535 extern void close_ioengine(struct thread_data *);
536
537 /*
538  * Mark unused variables passed to ops functions as unused, to silence gcc
539  */
540 #define fio_unused      __attribute((__unused__))
541
542 #define for_each_td(td, i)      \
543         for ((i) = 0, (td) = &threads[0]; (i) < (int) thread_number; (i)++, (td)++)
544 #define for_each_file(td, f, i) \
545         for ((i) = 0, (f) = &(td)->files[0]; (i) < (int) (td)->nr_files; (i)++, (f)++)
546
547 #endif