iolog.h

   1 #ifndef FIO_IOLOG_H
   2 #define FIO_IOLOG_H
   3
   4 #include "lib/rbtree.h"
   5 #include "lib/ieee754.h"
   6 #include "flist.h"
   7 #include "ioengine.h"
   8
   9 /*
  10  * Use for maintaining statistics
  11  */
  12 struct io_stat {
  13         uint64_t max_val;
  14         uint64_t min_val;
  15         uint64_t samples;
  16
  17         fio_fp64_t mean;
  18         fio_fp64_t S;
  19 };
  20
  21 /*
  22  * A single data sample
  23  */
  24 struct io_sample {
  25         uint64_t time;
  26         uint64_t val;
  27         uint32_t __ddir;
  28         uint32_t bs;
  29 };
  30
  31 struct io_sample_offset {
  32         struct io_sample s;
  33         uint64_t offset;
  34 };
  35
  36 enum {
  37         IO_LOG_TYPE_LAT = 1,
  38         IO_LOG_TYPE_CLAT,
  39         IO_LOG_TYPE_SLAT,
  40         IO_LOG_TYPE_BW,
  41         IO_LOG_TYPE_IOPS,
  42 };
  43
  44 #define DEF_LOG_ENTRIES         1024
  45 #define MAX_LOG_ENTRIES         (1024 * DEF_LOG_ENTRIES)
  46
  47 #define LOG_QUIESCE_SZ          (64 * 1024 * 1024)
  48
  49 struct io_logs {
  50         struct flist_head list;
  51         uint64_t nr_samples;
  52         uint64_t max_samples;
  53         void *log;
  54 };
  55
  56 /*
  57  * Dynamically growing data sample log
  58  */
  59 struct io_log {
  60         /*
  61          * Entries already logged
  62          */
  63         struct flist_head io_logs;
  64         uint32_t cur_log_max;
  65
  66         unsigned int log_ddir_mask;
  67
  68         char *filename;
  69
  70         struct thread_data *td;
  71
  72         unsigned int log_type;
  73
  74         /*
  75          * If we fail extending the log, stop collecting more entries.
  76          */
  77         bool disabled;
  78
  79         /*
  80          * Log offsets
  81          */
  82         unsigned int log_offset;
  83
  84         /*
  85          * Max size of log entries before a chunk is compressed
  86          */
  87         unsigned int log_gz;
  88
  89         /*
  90          * Don't deflate for storing, just store the compressed bits
  91          */
  92         unsigned int log_gz_store;
  93
  94         /*
  95          * Windowed average, for logging single entries average over some
  96          * period of time.
  97          */
  98         struct io_stat avg_window[DDIR_RWDIR_CNT];
  99         unsigned long avg_msec;
 100         unsigned long avg_last;
 101
 102         pthread_mutex_t chunk_lock;
 103         unsigned int chunk_seq;
 104         struct flist_head chunk_list;
 105 };
 106
 107 /*
 108  * If the upper bit is set, then we have the offset as well
 109  */
 110 #define LOG_OFFSET_SAMPLE_BIT   0x80000000U
 111 #define io_sample_ddir(io)      ((io)->__ddir & ~LOG_OFFSET_SAMPLE_BIT)
 112
 113 static inline void io_sample_set_ddir(struct io_log *log,
 114                                       struct io_sample *io,
 115                                       enum fio_ddir ddir)
 116 {
 117         io->__ddir = ddir | log->log_ddir_mask;
 118 }
 119
 120 static inline size_t __log_entry_sz(int log_offset)
 121 {
 122         if (log_offset)
 123                 return sizeof(struct io_sample_offset);
 124         else
 125                 return sizeof(struct io_sample);
 126 }
 127
 128 static inline size_t log_entry_sz(struct io_log *log)
 129 {
 130         return __log_entry_sz(log->log_offset);
 131 }
 132
 133 static inline struct io_sample *__get_sample(void *samples, int log_offset,
 134                                              uint64_t sample)
 135 {
 136         uint64_t sample_offset = sample * __log_entry_sz(log_offset);
 137         return (struct io_sample *) ((char *) samples + sample_offset);
 138 }
 139
 140 struct io_logs *iolog_cur_log(struct io_log *);
 141 uint64_t iolog_nr_samples(struct io_log *);
 142
 143 static inline struct io_sample *get_sample(struct io_log *iolog,
 144                                            struct io_logs *cur_log,
 145                                            uint64_t sample)
 146 {
 147         return __get_sample(cur_log->log, iolog->log_offset, sample);
 148 }
 149
 150 enum {
 151         IP_F_ONRB       = 1,
 152         IP_F_ONLIST     = 2,
 153         IP_F_TRIMMED    = 4,
 154         IP_F_IN_FLIGHT  = 8,
 155 };
 156
 157 /*
 158  * When logging io actions, this matches a single sent io_u
 159  */
 160 struct io_piece {
 161         union {
 162                 struct rb_node rb_node;
 163                 struct flist_head list;
 164         };
 165         struct flist_head trim_list;
 166         union {
 167                 int fileno;
 168                 struct fio_file *file;
 169         };
 170         unsigned long long offset;
 171         unsigned short numberio;
 172         unsigned long len;
 173         unsigned int flags;
 174         enum fio_ddir ddir;
 175         union {
 176                 unsigned long delay;
 177                 unsigned int file_action;
 178         };
 179 };
 180
 181 /*
 182  * Log exports
 183  */
 184 enum file_log_act {
 185         FIO_LOG_ADD_FILE,
 186         FIO_LOG_OPEN_FILE,
 187         FIO_LOG_CLOSE_FILE,
 188         FIO_LOG_UNLINK_FILE,
 189 };
 190
 191 struct io_u;
 192 extern int __must_check read_iolog_get(struct thread_data *, struct io_u *);
 193 extern void log_io_u(const struct thread_data *, const struct io_u *);
 194 extern void log_file(struct thread_data *, struct fio_file *, enum file_log_act);
 195 extern int __must_check init_iolog(struct thread_data *td);
 196 extern void log_io_piece(struct thread_data *, struct io_u *);
 197 extern void unlog_io_piece(struct thread_data *, struct io_u *);
 198 extern void trim_io_piece(struct thread_data *, const struct io_u *);
 199 extern void queue_io_piece(struct thread_data *, struct io_piece *);
 200 extern void prune_io_piece_log(struct thread_data *);
 201 extern void write_iolog_close(struct thread_data *);
 202 extern int iolog_compress_init(struct thread_data *, struct sk_out *);
 203 extern void iolog_compress_exit(struct thread_data *);
 204 extern size_t log_chunk_sizes(struct io_log *);
 205
 206 #ifdef CONFIG_ZLIB
 207 extern int iolog_file_inflate(const char *);
 208 #endif
 209
 210 /*
 211  * Logging
 212  */
 213 struct log_params {
 214         struct thread_data *td;
 215         unsigned long avg_msec;
 216         int log_type;
 217         int log_offset;
 218         int log_gz;
 219         int log_gz_store;
 220         int log_compress;
 221 };
 222
 223 static inline bool per_unit_log(struct io_log *log)
 224 {
 225         return log && !log->avg_msec;
 226 }
 227
 228 extern void finalize_logs(struct thread_data *td, bool);
 229 extern void setup_log(struct io_log **, struct log_params *, const char *);
 230 extern void flush_log(struct io_log *, int);
 231 extern void flush_samples(FILE *, void *, uint64_t);
 232 extern void free_log(struct io_log *);
 233 extern void fio_writeout_logs(bool);
 234 extern void td_writeout_logs(struct thread_data *, bool);
 235 extern int iolog_cur_flush(struct io_log *, struct io_logs *);
 236
 237 static inline void init_ipo(struct io_piece *ipo)
 238 {
 239         memset(ipo, 0, sizeof(*ipo));
 240         INIT_FLIST_HEAD(&ipo->trim_list);
 241 }
 242
 243 struct iolog_compress {
 244         struct flist_head list;
 245         void *buf;
 246         size_t len;
 247         unsigned int seq;
 248 };
 249
 250 #endif