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