blktrace.c

   1 /*
   2  * blktrace support code for fio
   3  */
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <sys/stat.h>
   7 #include <dirent.h>
   8
   9 #include "list.h"
  10 #include "fio.h"
  11 #include "blktrace_api.h"
  12
  13 #define TRACE_FIFO_SIZE 65536
  14
  15 /*
  16  * fifo refill frontend, to avoid reading data in trace sized bites
  17  */
  18 static int refill_fifo(struct thread_data *td, struct fifo *fifo, int fd)
  19 {
  20         char buf[TRACE_FIFO_SIZE];
  21         unsigned int total;
  22         int ret;
  23
  24         total = sizeof(buf);
  25         if (total > fifo_room(fifo))
  26                 total = fifo_room(fifo);
  27
  28         ret = read(fd, buf, total);
  29         if (ret < 0) {
  30                 td_verror(td, errno, "read blktrace file");
  31                 return -1;
  32         }
  33
  34         if (ret > 0)
  35                 ret = fifo_put(fifo, buf, ret);
  36
  37         dprint(FD_BLKTRACE, "refill: filled %d bytes\n", ret);
  38         return ret;
  39 }
  40
  41 /*
  42  * Retrieve 'len' bytes from the fifo, refilling if necessary.
  43  */
  44 static int trace_fifo_get(struct thread_data *td, struct fifo *fifo, int fd,
  45                           void *buf, unsigned int len)
  46 {
  47         if (fifo_len(fifo) < len) {
  48                 int ret = refill_fifo(td, fifo, fd);
  49
  50                 if (ret < 0)
  51                         return ret;
  52         }
  53
  54         return fifo_get(fifo, buf, len);
  55 }
  56
  57 /*
  58  * Just discard the pdu by seeking past it.
  59  */
  60 static int discard_pdu(struct thread_data *td, struct fifo *fifo, int fd,
  61                        struct blk_io_trace *t)
  62 {
  63         if (t->pdu_len == 0)
  64                 return 0;
  65
  66         dprint(FD_BLKTRACE, "discard pdu len %u\n", t->pdu_len);
  67         return trace_fifo_get(td, fifo, fd, NULL, t->pdu_len);
  68 }
  69
  70 /*
  71  * Check if this is a blktrace binary data file. We read a single trace
  72  * into memory and check for the magic signature.
  73  */
  74 int is_blktrace(const char *filename)
  75 {
  76         struct blk_io_trace t;
  77         int fd, ret;
  78
  79         fd = open(filename, O_RDONLY);
  80         if (fd < 0)
  81                 return 0;
  82
  83         ret = read(fd, &t, sizeof(t));
  84         close(fd);
  85
  86         if (ret < 0) {
  87                 perror("read blktrace");
  88                 return 0;
  89         } else if (ret != sizeof(t)) {
  90                 log_err("fio: short read on blktrace file\n");
  91                 return 0;
  92         }
  93
  94         if ((t.magic & 0xffffff00) == BLK_IO_TRACE_MAGIC)
  95                 return 1;
  96
  97         return 0;
  98 }
  99
 100 static int lookup_device(char *path, unsigned int maj, unsigned int min)
 101 {
 102         struct dirent *dir;
 103         struct stat st;
 104         int found = 0;
 105         DIR *D;
 106
 107         D = opendir(path);
 108         if (!D)
 109                 return 0;
 110
 111         while ((dir = readdir(D)) != NULL) {
 112                 char full_path[256];
 113
 114                 if (!strcmp(dir->d_name, ".") || !strcmp(dir->d_name, ".."))
 115                         continue;
 116
 117                 sprintf(full_path, "%s/%s", path, dir->d_name);
 118                 if (lstat(full_path, &st) == -1) {
 119                         perror("lstat");
 120                         break;
 121                 }
 122
 123                 if (S_ISDIR(st.st_mode)) {
 124                         found = lookup_device(full_path, maj, min);
 125                         if (found) {
 126                                 strcpy(path, full_path);
 127                                 break;
 128                         }
 129                 }
 130
 131                 if (!S_ISBLK(st.st_mode))
 132                         continue;
 133
 134                 if (maj == major(st.st_rdev) && min == minor(st.st_rdev)) {
 135                         dprint(FD_BLKTRACE, "device lookup: %d/%d\n", maj,min);
 136                         strcpy(path, full_path);
 137                         found = 1;
 138                         break;
 139                 }
 140         }
 141
 142         closedir(D);
 143         return found;
 144 }
 145
 146 #define FMINORBITS      20
 147 #define FMINORMASK      ((1U << FMINORBITS) - 1)
 148 #define FMAJOR(dev)     ((unsigned int) ((dev) >> FMINORBITS))
 149 #define FMINOR(dev)     ((unsigned int) ((dev) & FMINORMASK))
 150
 151 static void trace_add_file(struct thread_data *td, __u32 device)
 152 {
 153         static unsigned int last_maj, last_min;
 154         unsigned int maj = FMAJOR(device);
 155         unsigned int min = FMINOR(device);
 156         struct fio_file *f;
 157         char dev[256];
 158         unsigned int i;
 159
 160         if (last_maj == maj && last_min == min)
 161                 return;
 162
 163         last_maj = maj;
 164         last_min = min;
 165
 166         /*
 167          * check for this file in our list
 168          */
 169         for_each_file(td, f, i)
 170                 if (f->major == maj && f->minor == min)
 171                         return;
 172
 173         strcpy(dev, "/dev");
 174         if (lookup_device(dev, maj, min)) {
 175                 dprint(FD_BLKTRACE, "add devices %s\n", dev);
 176                 add_file(td, dev);
 177         }
 178 }
 179
 180 /*
 181  * Store blk_io_trace data in an ipo for later retrieval.
 182  */
 183 static void store_ipo(struct thread_data *td, unsigned long long offset,
 184                       unsigned int bytes, int rw, unsigned long long ttime)
 185 {
 186         struct io_piece *ipo = malloc(sizeof(*ipo));
 187
 188         memset(ipo, 0, sizeof(*ipo));
 189         INIT_LIST_HEAD(&ipo->list);
 190         /*
 191          * the 512 is wrong here, it should be the hardware sector size...
 192          */
 193         ipo->offset = offset * 512;
 194         ipo->len = bytes;
 195         ipo->delay = ttime / 1000;
 196         if (rw)
 197                 ipo->ddir = DDIR_WRITE;
 198         else
 199                 ipo->ddir = DDIR_READ;
 200
 201         dprint(FD_BLKTRACE, "store ddir=%d, off=%llu, len=%lu, delay=%lu\n",
 202                                                         ipo->ddir, ipo->offset,
 203                                                         ipo->len, ipo->delay);
 204         list_add_tail(&ipo->list, &td->io_log_list);
 205 }
 206
 207 /*
 208  * We only care for queue traces, most of the others are side effects
 209  * due to internal workings of the block layer.
 210  */
 211 static void handle_trace(struct thread_data *td, struct blk_io_trace *t,
 212                          unsigned long long ttime, unsigned long *ios,
 213                          unsigned int *bs)
 214 {
 215         int rw;
 216
 217         if ((t->action & 0xffff) != __BLK_TA_QUEUE)
 218                 return;
 219         if (t->action & BLK_TC_ACT(BLK_TC_PC))
 220                 return;
 221         if (t->action & BLK_TC_ACT(BLK_TC_NOTIFY))
 222                 return;
 223
 224         trace_add_file(td, t->device);
 225
 226         rw = (t->action & BLK_TC_ACT(BLK_TC_WRITE)) != 0;
 227
 228         if (t->bytes > bs[rw])
 229                 bs[rw] = t->bytes;
 230
 231         ios[rw]++;
 232         td->o.size += t->bytes;
 233         store_ipo(td, t->sector, t->bytes, rw, ttime);
 234 }
 235
 236 /*
 237  * Load a blktrace file by reading all the blk_io_trace entries, and storing
 238  * them as io_pieces like the fio text version would do.
 239  */
 240 int load_blktrace(struct thread_data *td, const char *filename)
 241 {
 242         unsigned long long ttime, delay;
 243         struct blk_io_trace t;
 244         unsigned long ios[2], skipped_writes;
 245         unsigned int cpu;
 246         unsigned int rw_bs[2];
 247         struct fifo *fifo;
 248         int fd;
 249
 250         fd = open(filename, O_RDONLY);
 251         if (fd < 0) {
 252                 td_verror(td, errno, "open blktrace file");
 253                 return 1;
 254         }
 255
 256         fifo = fifo_alloc(TRACE_FIFO_SIZE);
 257
 258         td->o.size = 0;
 259
 260         cpu = 0;
 261         ttime = 0;
 262         ios[0] = ios[1] = 0;
 263         rw_bs[0] = rw_bs[1] = 0;
 264         skipped_writes = 0;
 265         do {
 266                 int ret = trace_fifo_get(td, fifo, fd, &t, sizeof(t));
 267
 268                 if (ret < 0)
 269                         goto err;
 270                 else if (!ret)
 271                         break;
 272                 else if (ret < (int) sizeof(t)) {
 273                         log_err("fio: short fifo get\n");
 274                         break;
 275                 }
 276
 277                 if ((t.magic & 0xffffff00) != BLK_IO_TRACE_MAGIC) {
 278                         log_err("fio: bad magic in blktrace data: %x\n", t.magic);
 279                         goto err;
 280                 }
 281                 if ((t.magic & 0xff) != BLK_IO_TRACE_VERSION) {
 282                         log_err("fio: bad blktrace version %d\n", t.magic & 0xff);
 283                         goto err;
 284                 }
 285                 ret = discard_pdu(td, fifo, fd, &t);
 286                 if (ret < 0) {
 287                         td_verror(td, ret, "blktrace lseek");
 288                         goto err;
 289                 } else if (t.pdu_len != ret) {
 290                         log_err("fio: discarded %d of %d\n", ret, t.pdu_len);
 291                         goto err;
 292                 }
 293                 if (t.action & BLK_TC_ACT(BLK_TC_NOTIFY))
 294                         continue;
 295                 if (!ttime) {
 296                         ttime = t.time;
 297                         cpu = t.cpu;
 298                 }
 299                 delay = 0;
 300                 if (cpu == t.cpu)
 301                         delay = t.time - ttime;
 302                 if ((t.action & BLK_TC_ACT(BLK_TC_WRITE)) && read_only)
 303                         skipped_writes++;
 304                 else
 305                         handle_trace(td, &t, delay, ios, rw_bs);
 306                 ttime = t.time;
 307                 cpu = t.cpu;
 308         } while (1);
 309
 310         fifo_free(fifo);
 311         close(fd);
 312
 313         if (skipped_writes)
 314                 log_err("fio: <%s> skips replay of %lu writes due to read-only\n", td->o.name, skipped_writes);
 315
 316         if (!ios[DDIR_READ] && !ios[DDIR_WRITE]) {
 317                 log_err("fio: found no ios in blktrace data\n");
 318                 return 1;
 319         } else if (ios[DDIR_READ] && !ios[DDIR_READ]) {
 320                 td->o.td_ddir = TD_DDIR_READ;
 321                 td->o.max_bs[DDIR_READ] = rw_bs[DDIR_READ];
 322         } else if (!ios[DDIR_READ] && ios[DDIR_WRITE]) {
 323                 td->o.td_ddir = TD_DDIR_WRITE;
 324                 td->o.max_bs[DDIR_WRITE] = rw_bs[DDIR_WRITE];
 325         } else {
 326                 td->o.td_ddir = TD_DDIR_RW;
 327                 td->o.max_bs[DDIR_READ] = rw_bs[DDIR_READ];
 328                 td->o.max_bs[DDIR_WRITE] = rw_bs[DDIR_WRITE];
 329         }
 330
 331         /*
 332          * We need to do direct/raw ios to the device, to avoid getting
 333          * read-ahead in our way.
 334          */
 335         td->o.odirect = 1;
 336
 337         return 0;
 338 err:
 339         close(fd);
 340         fifo_free(fifo);
 341         return 1;
 342 }