X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=blktrace.c;h=b4d05c739cdc6843dedda732908dbd67fdfb21de;hp=afa699cd1a3f7f4225e4b220654d347c9641397a;hb=7437ee87e4f6457168e8440f9308b4296ddb9263;hpb=d84f8d4931be0c7519bd9f97f9914b07578a9854 diff --git a/blktrace.c b/blktrace.c index afa699cd..b4d05c73 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); } /* @@ -32,10 +75,8 @@ int is_blktrace(const char *filename) int fd, ret; fd = open(filename, O_RDONLY); - if (fd < 0) { - perror("open blktrace"); + if (fd < 0) return 0; - } ret = read(fd, &t, sizeof(t)); close(fd); @@ -54,6 +95,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. */ @@ -92,13 +210,11 @@ 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]) @@ -120,6 +236,7 @@ int load_blktrace(struct thread_data *td, const char *filename) unsigned long ios[2]; unsigned int cpu; unsigned int rw_bs[2]; + struct fifo *fifo; int fd; fd = open(filename, O_RDONLY); @@ -128,6 +245,8 @@ int load_blktrace(struct thread_data *td, const char *filename) return 1; } + fifo = fifo_alloc(TRACE_FIFO_SIZE); + td->o.size = 0; cpu = 0; @@ -135,36 +254,32 @@ int load_blktrace(struct thread_data *td, const char *filename) 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) { ttime = t.time; @@ -178,6 +293,7 @@ int load_blktrace(struct thread_data *td, const char *filename) cpu = t.cpu; } while (1); + fifo_free(fifo); close(fd); if (!ios[DDIR_READ] && !ios[DDIR_WRITE]) { @@ -204,5 +320,6 @@ int load_blktrace(struct thread_data *td, const char *filename) return 0; err: close(fd); + fifo_free(fifo); return 1; }