log.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include "list.h"
   4 #include "fio.h"
   5
   6 void write_iolog_put(struct thread_data *td, struct io_u *io_u)
   7 {
   8         fprintf(td->iolog_f, "%u,%llu,%lu\n", io_u->ddir, io_u->offset, io_u->buflen);
   9 }
  10
  11 int read_iolog_get(struct thread_data *td, struct io_u *io_u)
  12 {
  13         struct io_piece *ipo;
  14
  15         if (!list_empty(&td->io_log_list)) {
  16                 ipo = list_entry(td->io_log_list.next, struct io_piece, list);
  17                 list_del(&ipo->list);
  18                 io_u->offset = ipo->offset;
  19                 io_u->buflen = ipo->len;
  20                 io_u->ddir = ipo->ddir;
  21                 io_u->file = ipo->file;
  22                 free(ipo);
  23                 return 0;
  24         }
  25
  26         return 1;
  27 }
  28
  29 void prune_io_piece_log(struct thread_data *td)
  30 {
  31         struct io_piece *ipo;
  32         struct rb_node *n;
  33
  34         while ((n = rb_first(&td->io_hist_tree)) != NULL) {
  35                 ipo = rb_entry(n, struct io_piece, rb_node);
  36                 rb_erase(n, &td->io_hist_tree);
  37                 free(ipo);
  38         }
  39 }
  40
  41 /*
  42  * log a successful write, so we can unwind the log for verify
  43  */
  44 void log_io_piece(struct thread_data *td, struct io_u *io_u)
  45 {
  46         struct rb_node **p, *parent;
  47         struct io_piece *ipo, *__ipo;
  48
  49         ipo = malloc(sizeof(struct io_piece));
  50         ipo->file = io_u->file;
  51         ipo->offset = io_u->offset;
  52         ipo->len = io_u->buflen;
  53
  54         /*
  55          * We don't need to sort the entries, if:
  56          *
  57          *      Sequential writes, or
  58          *      Random writes that lay out the file as it goes along
  59          *
  60          * For both these cases, just reading back data in the order we
  61          * wrote it out is the fastest.
  62          */
  63         if (!td_random(td) || !td->o.overwrite ||
  64              (io_u->file->flags & FIO_FILE_NOSORT)) {
  65                 INIT_LIST_HEAD(&ipo->list);
  66                 list_add_tail(&ipo->list, &td->io_hist_list);
  67                 return;
  68         }
  69
  70         RB_CLEAR_NODE(&ipo->rb_node);
  71         p = &td->io_hist_tree.rb_node;
  72         parent = NULL;
  73
  74         /*
  75          * Sort the entry into the verification list
  76          */
  77         while (*p) {
  78                 parent = *p;
  79
  80                 __ipo = rb_entry(parent, struct io_piece, rb_node);
  81                 if (ipo->offset <= __ipo->offset)
  82                         p = &(*p)->rb_left;
  83                 else
  84                         p = &(*p)->rb_right;
  85         }
  86
  87         rb_link_node(&ipo->rb_node, parent, p);
  88         rb_insert_color(&ipo->rb_node, &td->io_hist_tree);
  89 }
  90
  91 void write_iolog_close(struct thread_data *td)
  92 {
  93         fflush(td->iolog_f);
  94         fclose(td->iolog_f);
  95         free(td->iolog_buf);
  96 }
  97
  98 /*
  99  * Open a stored log and read in the entries.
 100  */
 101 static int init_iolog_read(struct thread_data *td)
 102 {
 103         unsigned long long offset;
 104         unsigned int bytes;
 105         char *str, *p;
 106         FILE *f;
 107         int rw, reads, writes;
 108
 109         f = fopen(td->o.read_iolog_file, "r");
 110         if (!f) {
 111                 perror("fopen read iolog");
 112                 return 1;
 113         }
 114
 115         /*
 116          * Read in the read iolog and store it, reuse the infrastructure
 117          * for doing verifications.
 118          */
 119         str = malloc(4096);
 120         reads = writes = 0;
 121         while ((p = fgets(str, 4096, f)) != NULL) {
 122                 struct io_piece *ipo;
 123
 124                 if (sscanf(p, "%d,%llu,%u", &rw, &offset, &bytes) != 3) {
 125                         log_err("bad iolog: %s\n", p);
 126                         continue;
 127                 }
 128                 if (rw == DDIR_READ)
 129                         reads++;
 130                 else if (rw == DDIR_WRITE)
 131                         writes++;
 132                 else if (rw != DDIR_SYNC) {
 133                         log_err("bad ddir: %d\n", rw);
 134                         continue;
 135                 }
 136
 137                 ipo = malloc(sizeof(*ipo));
 138                 INIT_LIST_HEAD(&ipo->list);
 139                 ipo->offset = offset;
 140                 ipo->len = bytes;
 141                 ipo->ddir = (enum fio_ddir) rw;
 142                 if (bytes > td->o.max_bs[rw])
 143                         td->o.max_bs[rw] = bytes;
 144                 list_add_tail(&ipo->list, &td->io_log_list);
 145         }
 146
 147         free(str);
 148         fclose(f);
 149
 150         if (!reads && !writes)
 151                 return 1;
 152         else if (reads && !writes)
 153                 td->o.td_ddir = TD_DDIR_READ;
 154         else if (!reads && writes)
 155                 td->o.td_ddir = TD_DDIR_READ;
 156         else
 157                 td->o.td_ddir = TD_DDIR_RW;
 158
 159         return 0;
 160 }
 161
 162 /*
 163  * Setup a log for storing io patterns.
 164  */
 165 static int init_iolog_write(struct thread_data *td)
 166 {
 167         FILE *f;
 168
 169         f = fopen(td->o.write_iolog_file, "w+");
 170         if (!f) {
 171                 perror("fopen write iolog");
 172                 return 1;
 173         }
 174
 175         /*
 176          * That's it for writing, setup a log buffer and we're done.
 177           */
 178         td->iolog_f = f;
 179         td->iolog_buf = malloc(8192);
 180         setvbuf(f, td->iolog_buf, _IOFBF, 8192);
 181         return 0;
 182 }
 183
 184 int init_iolog(struct thread_data *td)
 185 {
 186         int ret = 0;
 187
 188         if (td->io_ops->flags & FIO_DISKLESSIO)
 189                 return 0;
 190
 191         if (td->o.read_iolog_file)
 192                 ret = init_iolog_read(td);
 193         else if (td->o.write_iolog_file)
 194                 ret = init_iolog_write(td);
 195
 196         return ret;
 197 }
 198
 199 void setup_log(struct io_log **log)
 200 {
 201         struct io_log *l = malloc(sizeof(*l));
 202
 203         l->nr_samples = 0;
 204         l->max_samples = 1024;
 205         l->log = malloc(l->max_samples * sizeof(struct io_sample));
 206         *log = l;
 207 }
 208
 209 void __finish_log(struct io_log *log, const char *name)
 210 {
 211         unsigned int i;
 212         FILE *f;
 213
 214         f = fopen(name, "w");
 215         if (!f) {
 216                 perror("fopen log");
 217                 return;
 218         }
 219
 220         for (i = 0; i < log->nr_samples; i++)
 221                 fprintf(f, "%lu, %lu, %u\n", log->log[i].time, log->log[i].val, log->log[i].ddir);
 222
 223         fclose(f);
 224         free(log->log);
 225         free(log);
 226 }
 227
 228 void finish_log(struct thread_data *td, struct io_log *log, const char *name)
 229 {
 230         char file_name[256];
 231
 232         snprintf(file_name, 200, "client%d_%s.log", td->thread_number, name);
 233         __finish_log(log, file_name);
 234 }