X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=blktrace.c;h=8ebbae6f2fbe788c3c2ee353385535dac68c90ce;hp=864e9dc7900bf4971fcc70dc7720a0b89be7b42e;hb=f24254e1d142e80dc76d1f2e316da12f6ec125ee;hpb=a2eea81b53fc1a71b91b20d82bcadffdd4ecb6cd diff --git a/blktrace.c b/blktrace.c index 864e9dc7..8ebbae6f 100644 --- a/blktrace.c +++ b/blktrace.c @@ -3,23 +3,66 @@ */ #include #include +#include +#include #include "list.h" #include "fio.h" #include "blktrace_api.h" +#define TRACE_FIFO_SIZE 65536 + +/* + * fifo refill frontend, to avoid reading data in trace sized bites + */ +static int refill_fifo(struct thread_data *td, struct fifo *fifo, int fd) +{ + char buf[TRACE_FIFO_SIZE]; + unsigned int total; + int ret; + + total = sizeof(buf); + if (total > fifo_room(fifo)) + total = fifo_room(fifo); + + ret = read(fd, buf, total); + if (ret < 0) { + td_verror(td, errno, "read blktrace file"); + return -1; + } + + if (ret > 0) + ret = fifo_put(fifo, buf, ret); + + return ret; +} + +/* + * Retrieve 'len' bytes from the fifo, refilling if necessary. + */ +static int trace_fifo_get(struct thread_data *td, struct fifo *fifo, int fd, + void *buf, unsigned int len) +{ + if (fifo_len(fifo) < len) { + int ret = refill_fifo(td, fifo, fd); + + if (ret < 0) + return ret; + } + + return fifo_get(fifo, buf, len); +} + /* * Just discard the pdu by seeking past it. */ -static int discard_pdu(int fd, struct blk_io_trace *t) +static int discard_pdu(struct thread_data *td, struct fifo *fifo, int fd, + struct blk_io_trace *t) { if (t->pdu_len == 0) return 0; - if (lseek(fd, t->pdu_len, SEEK_CUR) < 0) - return errno; - - return 0; + return trace_fifo_get(td, fifo, fd, NULL, t->pdu_len); } /* @@ -54,6 +97,83 @@ int is_blktrace(const char *filename) return 0; } +static int lookup_device(char *path, unsigned int maj, unsigned int min) +{ + struct dirent *dir; + struct stat st; + int found = 0; + DIR *D; + + D = opendir(path); + if (!D) + return 0; + + while ((dir = readdir(D)) != NULL) { + char full_path[256]; + + if (!strcmp(dir->d_name, ".") || !strcmp(dir->d_name, "..")) + continue; + + sprintf(full_path, "%s/%s", path, dir->d_name); + if (lstat(full_path, &st) == -1) { + perror("lstat"); + break; + } + + if (S_ISDIR(st.st_mode)) { + found = lookup_device(full_path, maj, min); + if (found) { + strcpy(path, full_path); + break; + } + } + + if (!S_ISBLK(st.st_mode)) + continue; + + if (maj == major(st.st_rdev) && min == minor(st.st_rdev)) { + strcpy(path, full_path); + found = 1; + break; + } + } + + closedir(D); + return found; +} + +#define FMINORBITS 20 +#define FMINORMASK ((1U << FMINORBITS) - 1) +#define FMAJOR(dev) ((unsigned int) ((dev) >> FMINORBITS)) +#define FMINOR(dev) ((unsigned int) ((dev) & FMINORMASK)) + +static void trace_add_file(struct thread_data *td, __u32 device) +{ + static unsigned int last_maj, last_min; + unsigned int maj = FMAJOR(device); + unsigned int min = FMINOR(device); + struct fio_file *f; + char dev[256]; + unsigned int i; + + if (last_maj == maj && last_min == min) + return; + + last_maj = maj; + last_min = min; + + /* + * check for this file in our list + */ + for_each_file(td, f, i) + if (f->major == maj && f->minor == min) + return; + + strcpy(dev, "/dev"); + if (lookup_device(dev, maj, min)) + add_file(td, dev); +} + /* * Store blk_io_trace data in an ipo for later retrieval. */ @@ -83,7 +203,8 @@ static void store_ipo(struct thread_data *td, unsigned long long offset, * due to internal workings of the block layer. */ static void handle_trace(struct thread_data *td, struct blk_io_trace *t, - unsigned long long ttime, unsigned long *ios) + unsigned long long ttime, unsigned long *ios, + unsigned int *bs) { int rw; @@ -91,15 +212,18 @@ static void handle_trace(struct thread_data *td, struct blk_io_trace *t, return; if (t->action & BLK_TC_ACT(BLK_TC_PC)) return; - - /* - * should not happen, need to look into that... - */ - if (!t->bytes) + if (t->action & BLK_TC_ACT(BLK_TC_NOTIFY)) return; + trace_add_file(td, t->device); + rw = (t->action & BLK_TC_ACT(BLK_TC_WRITE)) != 0; + + if (t->bytes > bs[rw]) + bs[rw] = t->bytes; + ios[rw]++; + td->o.size += t->bytes; store_ipo(td, t->sector, t->bytes, rw, ttime); } @@ -109,9 +233,12 @@ static void handle_trace(struct thread_data *td, struct blk_io_trace *t, */ int load_blktrace(struct thread_data *td, const char *filename) { - unsigned long long ttime; + unsigned long long ttime, delay; struct blk_io_trace t; unsigned long ios[2]; + unsigned int cpu; + unsigned int rw_bs[2]; + struct fifo *fifo; int fd; fd = open(filename, O_RDONLY); @@ -120,57 +247,71 @@ int load_blktrace(struct thread_data *td, const char *filename) return 1; } - ios[0] = ios[1] = 0; + fifo = fifo_alloc(TRACE_FIFO_SIZE); + + td->o.size = 0; + + cpu = 0; ttime = 0; + ios[0] = ios[1] = 0; + rw_bs[0] = rw_bs[1] = 0; do { - /* - * Once this is working fully, I'll add a layer between - * here and read to cache trace data. Then we can avoid - * doing itsy bitsy reads, but instead pull in a larger - * chunk of data at the time. - */ - int ret = read(fd, &t, sizeof(t)); + int ret = trace_fifo_get(td, fifo, fd, &t, sizeof(t)); - if (ret < 0) { - td_verror(td, errno, "read blktrace file"); + if (ret < 0) goto err; - } else if (!ret) { + else if (!ret) + break; + else if (ret < (int) sizeof(t)) { + log_err("fio: short fifo get\n"); break; - } else if (ret != sizeof(t)) { - log_err("fio: short read on blktrace file\n"); - goto err; } if ((t.magic & 0xffffff00) != BLK_IO_TRACE_MAGIC) { - log_err("fio: bad magic in blktrace data\n"); + log_err("fio: bad magic in blktrace data: %x\n", t.magic); goto err; } if ((t.magic & 0xff) != BLK_IO_TRACE_VERSION) { log_err("fio: bad blktrace version %d\n", t.magic & 0xff); goto err; } - ret = discard_pdu(fd, &t); - if (ret) { + ret = discard_pdu(td, fifo, fd, &t); + if (ret < 0) { td_verror(td, ret, "blktrace lseek"); goto err; + } else if (t.pdu_len != ret) { + log_err("fio: discarded %d of %d\n", ret, t.pdu_len); + goto err; } - if (!ttime) + if (!ttime) { ttime = t.time; - handle_trace(td, &t, t.time - ttime, ios); + cpu = t.cpu; + } + delay = 0; + if (cpu == t.cpu) + delay = t.time - ttime; + handle_trace(td, &t, delay, ios, rw_bs); ttime = t.time; + cpu = t.cpu; } while (1); + fifo_free(fifo); close(fd); if (!ios[DDIR_READ] && !ios[DDIR_WRITE]) { log_err("fio: found no ios in blktrace data\n"); return 1; - } else if (ios[DDIR_READ] && !ios[DDIR_READ]) + } else if (ios[DDIR_READ] && !ios[DDIR_READ]) { td->o.td_ddir = TD_DDIR_READ; - else if (!ios[DDIR_READ] && ios[DDIR_WRITE]) + td->o.max_bs[DDIR_READ] = rw_bs[DDIR_READ]; + } else if (!ios[DDIR_READ] && ios[DDIR_WRITE]) { td->o.td_ddir = TD_DDIR_WRITE; - else + td->o.max_bs[DDIR_WRITE] = rw_bs[DDIR_WRITE]; + } else { td->o.td_ddir = TD_DDIR_RW; + td->o.max_bs[DDIR_READ] = rw_bs[DDIR_READ]; + td->o.max_bs[DDIR_WRITE] = rw_bs[DDIR_WRITE]; + } /* * We need to do direct/raw ios to the device, to avoid getting @@ -181,5 +322,6 @@ int load_blktrace(struct thread_data *td, const char *filename) return 0; err: close(fd); + fifo_free(fifo); return 1; }