Reduce stack consumption in blktrace load
[fio.git] / blktrace.c
CommitLineData
fb7b71a3
JA
1/*
2 * blktrace support code for fio
3 */
4#include <stdio.h>
5#include <stdlib.h>
5e6c2067
JA
6#include <sys/stat.h>
7#include <dirent.h>
8c1fdf04 8
01743ee1 9#include "flist.h"
fb7b71a3
JA
10#include "fio.h"
11#include "blktrace_api.h"
12
2da7df1d 13#define TRACE_FIFO_SIZE 8192
e2887563
JA
14
15/*
16 * fifo refill frontend, to avoid reading data in trace sized bites
17 */
18static int refill_fifo(struct thread_data *td, struct fifo *fifo, int fd)
19{
20 char buf[TRACE_FIFO_SIZE];
f12b323f 21 unsigned int total;
e2887563
JA
22 int ret;
23
f12b323f
JA
24 total = sizeof(buf);
25 if (total > fifo_room(fifo))
26 total = fifo_room(fifo);
e2887563 27
f12b323f
JA
28 ret = read(fd, buf, total);
29 if (ret < 0) {
30 td_verror(td, errno, "read blktrace file");
31 return -1;
e2887563
JA
32 }
33
f12b323f
JA
34 if (ret > 0)
35 ret = fifo_put(fifo, buf, ret);
36
bd6f78b2 37 dprint(FD_BLKTRACE, "refill: filled %d bytes\n", ret);
f12b323f 38 return ret;
e2887563
JA
39}
40
41/*
42 * Retrieve 'len' bytes from the fifo, refilling if necessary.
43 */
44static int trace_fifo_get(struct thread_data *td, struct fifo *fifo, int fd,
45 void *buf, unsigned int len)
46{
f12b323f
JA
47 if (fifo_len(fifo) < len) {
48 int ret = refill_fifo(td, fifo, fd);
e2887563 49
f12b323f
JA
50 if (ret < 0)
51 return ret;
52 }
e2887563
JA
53
54 return fifo_get(fifo, buf, len);
55}
56
8c1fdf04
JA
57/*
58 * Just discard the pdu by seeking past it.
59 */
f12b323f
JA
60static int discard_pdu(struct thread_data *td, struct fifo *fifo, int fd,
61 struct blk_io_trace *t)
fb7b71a3
JA
62{
63 if (t->pdu_len == 0)
64 return 0;
65
bd6f78b2 66 dprint(FD_BLKTRACE, "discard pdu len %u\n", t->pdu_len);
f12b323f 67 return trace_fifo_get(td, fifo, fd, NULL, t->pdu_len);
fb7b71a3
JA
68}
69
8c1fdf04
JA
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 */
fb7b71a3
JA
74int is_blktrace(const char *filename)
75{
76 struct blk_io_trace t;
77 int fd, ret;
78
79 fd = open(filename, O_RDONLY);
4dced407 80 if (fd < 0)
fb7b71a3 81 return 0;
fb7b71a3
JA
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
5e6c2067
JA
100static 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)) {
5ec10eaa 135 dprint(FD_BLKTRACE, "device lookup: %d/%d\n", maj, min);
5e6c2067
JA
136 strcpy(path, full_path);
137 found = 1;
138 break;
139 }
140 }
141
142 closedir(D);
143 return found;
144}
145
c69aa91f
JA
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))
eeb9c2aa 150
691c8fb0
JA
151static void trace_add_open_event(struct thread_data *td, int fileno)
152{
153 struct io_piece *ipo;
154
155 ipo = calloc(1, sizeof(*ipo));
156
157 ipo->ddir = DDIR_INVAL;
158 ipo->fileno = fileno;
159 ipo->file_action = FIO_LOG_OPEN_FILE;
01743ee1 160 flist_add_tail(&ipo->list, &td->io_log_list);
691c8fb0
JA
161}
162
5e6c2067
JA
163static void trace_add_file(struct thread_data *td, __u32 device)
164{
165 static unsigned int last_maj, last_min;
c69aa91f
JA
166 unsigned int maj = FMAJOR(device);
167 unsigned int min = FMINOR(device);
5e6c2067
JA
168 struct fio_file *f;
169 char dev[256];
170 unsigned int i;
171
172 if (last_maj == maj && last_min == min)
173 return;
174
175 last_maj = maj;
176 last_min = min;
177
178 /*
179 * check for this file in our list
180 */
181 for_each_file(td, f, i)
182 if (f->major == maj && f->minor == min)
183 return;
184
185 strcpy(dev, "/dev");
bd6f78b2 186 if (lookup_device(dev, maj, min)) {
691c8fb0
JA
187 int fileno;
188
bd6f78b2 189 dprint(FD_BLKTRACE, "add devices %s\n", dev);
691c8fb0
JA
190 fileno = add_file(td, dev);
191 trace_add_open_event(td, fileno);
bd6f78b2 192 }
5e6c2067
JA
193}
194
8c1fdf04
JA
195/*
196 * Store blk_io_trace data in an ipo for later retrieval.
197 */
fdefd987 198static void store_ipo(struct thread_data *td, unsigned long long offset,
8c1fdf04 199 unsigned int bytes, int rw, unsigned long long ttime)
fdefd987
JA
200{
201 struct io_piece *ipo = malloc(sizeof(*ipo));
202
203 memset(ipo, 0, sizeof(*ipo));
01743ee1 204 INIT_FLIST_HEAD(&ipo->list);
a2eea81b
JA
205 /*
206 * the 512 is wrong here, it should be the hardware sector size...
207 */
208 ipo->offset = offset * 512;
fdefd987 209 ipo->len = bytes;
8c1fdf04 210 ipo->delay = ttime / 1000;
fdefd987
JA
211 if (rw)
212 ipo->ddir = DDIR_WRITE;
213 else
214 ipo->ddir = DDIR_READ;
215
bd6f78b2
JA
216 dprint(FD_BLKTRACE, "store ddir=%d, off=%llu, len=%lu, delay=%lu\n",
217 ipo->ddir, ipo->offset,
218 ipo->len, ipo->delay);
691c8fb0 219 queue_io_piece(td, ipo);
fdefd987
JA
220}
221
0b9d69ec 222static void handle_trace_notify(struct blk_io_trace *t)
cd991b9e 223{
691c8fb0
JA
224 switch (t->action) {
225 case BLK_TN_PROCESS:
226 printf("got process notify: %x, %d\n", t->action, t->pid);
227 break;
228 case BLK_TN_TIMESTAMP:
229 printf("got timestamp notify: %x, %d\n", t->action, t->pid);
230 break;
231 default:
232 dprint(FD_BLKTRACE, "unknown trace act %x\n", t->action);
233 break;
234 }
235}
5b3023b8 236
691c8fb0
JA
237static void handle_trace_fs(struct thread_data *td, struct blk_io_trace *t,
238 unsigned long long ttime, unsigned long *ios,
239 unsigned int *bs)
240{
241 int rw;
5b3023b8
JA
242
243 trace_add_file(td, t->device);
244
245 rw = (t->action & BLK_TC_ACT(BLK_TC_WRITE)) != 0;
246
247 if (t->bytes > bs[rw])
248 bs[rw] = t->bytes;
249
250 ios[rw]++;
251 td->o.size += t->bytes;
252 store_ipo(td, t->sector, t->bytes, rw, ttime);
cd991b9e
JA
253}
254
691c8fb0
JA
255/*
256 * We only care for queue traces, most of the others are side effects
257 * due to internal workings of the block layer.
258 */
259static void handle_trace(struct thread_data *td, struct blk_io_trace *t,
260 unsigned long long ttime, unsigned long *ios,
261 unsigned int *bs)
262{
263 if ((t->action & 0xffff) != __BLK_TA_QUEUE)
264 return;
265 if (t->action & BLK_TC_ACT(BLK_TC_PC))
266 return;
267
268 if (t->action & BLK_TC_ACT(BLK_TC_NOTIFY))
aec2de20 269 handle_trace_notify(t);
691c8fb0
JA
270 else
271 handle_trace_fs(td, t, ttime, ios, bs);
272}
273
8c1fdf04
JA
274/*
275 * Load a blktrace file by reading all the blk_io_trace entries, and storing
276 * them as io_pieces like the fio text version would do.
277 */
fb7b71a3
JA
278int load_blktrace(struct thread_data *td, const char *filename)
279{
a61eddec 280 unsigned long long ttime, delay;
fb7b71a3 281 struct blk_io_trace t;
4241ea8f 282 unsigned long ios[2], skipped_writes;
a61eddec 283 unsigned int cpu;
d84f8d49 284 unsigned int rw_bs[2];
e2887563 285 struct fifo *fifo;
fb7b71a3
JA
286 int fd;
287
288 fd = open(filename, O_RDONLY);
289 if (fd < 0) {
290 td_verror(td, errno, "open blktrace file");
291 return 1;
292 }
293
e2887563
JA
294 fifo = fifo_alloc(TRACE_FIFO_SIZE);
295
6df8adaa
JA
296 td->o.size = 0;
297
a61eddec 298 cpu = 0;
d84f8d49
JA
299 ttime = 0;
300 ios[0] = ios[1] = 0;
301 rw_bs[0] = rw_bs[1] = 0;
4241ea8f 302 skipped_writes = 0;
fb7b71a3 303 do {
e2887563 304 int ret = trace_fifo_get(td, fifo, fd, &t, sizeof(t));
fb7b71a3 305
e2887563 306 if (ret < 0)
8c1fdf04 307 goto err;
e2887563
JA
308 else if (!ret)
309 break;
310 else if (ret < (int) sizeof(t)) {
311 log_err("fio: short fifo get\n");
fb7b71a3 312 break;
fb7b71a3
JA
313 }
314
315 if ((t.magic & 0xffffff00) != BLK_IO_TRACE_MAGIC) {
5ec10eaa
JA
316 log_err("fio: bad magic in blktrace data: %x\n",
317 t.magic);
8c1fdf04 318 goto err;
fb7b71a3
JA
319 }
320 if ((t.magic & 0xff) != BLK_IO_TRACE_VERSION) {
5ec10eaa
JA
321 log_err("fio: bad blktrace version %d\n",
322 t.magic & 0xff);
8c1fdf04 323 goto err;
fb7b71a3 324 }
f12b323f
JA
325 ret = discard_pdu(td, fifo, fd, &t);
326 if (ret < 0) {
fb7b71a3 327 td_verror(td, ret, "blktrace lseek");
8c1fdf04 328 goto err;
f12b323f
JA
329 } else if (t.pdu_len != ret) {
330 log_err("fio: discarded %d of %d\n", ret, t.pdu_len);
331 goto err;
fb7b71a3 332 }
691c8fb0
JA
333 if ((t.action & BLK_TC_ACT(BLK_TC_NOTIFY)) == 0) {
334 if (!ttime) {
335 ttime = t.time;
336 cpu = t.cpu;
337 }
338
339 delay = 0;
340 if (cpu == t.cpu)
341 delay = t.time - ttime;
342 if ((t.action & BLK_TC_ACT(BLK_TC_WRITE)) && read_only)
343 skipped_writes++;
344 else
345 handle_trace(td, &t, delay, ios, rw_bs);
346
8c1fdf04 347 ttime = t.time;
a61eddec 348 cpu = t.cpu;
a6edd638
JA
349 } else {
350 delay = 0;
4241ea8f 351 handle_trace(td, &t, delay, ios, rw_bs);
a6edd638 352 }
fb7b71a3
JA
353 } while (1);
354
38470f85 355 fifo_free(fifo);
fb7b71a3 356 close(fd);
8c1fdf04 357
4241ea8f 358 if (skipped_writes)
5ec10eaa
JA
359 log_err("fio: %s skips replay of %lu writes due to read-only\n",
360 td->o.name, skipped_writes);
4241ea8f 361
8c1fdf04
JA
362 if (!ios[DDIR_READ] && !ios[DDIR_WRITE]) {
363 log_err("fio: found no ios in blktrace data\n");
364 return 1;
d84f8d49 365 } else if (ios[DDIR_READ] && !ios[DDIR_READ]) {
8c1fdf04 366 td->o.td_ddir = TD_DDIR_READ;
d84f8d49
JA
367 td->o.max_bs[DDIR_READ] = rw_bs[DDIR_READ];
368 } else if (!ios[DDIR_READ] && ios[DDIR_WRITE]) {
8c1fdf04 369 td->o.td_ddir = TD_DDIR_WRITE;
d84f8d49
JA
370 td->o.max_bs[DDIR_WRITE] = rw_bs[DDIR_WRITE];
371 } else {
8c1fdf04 372 td->o.td_ddir = TD_DDIR_RW;
d84f8d49
JA
373 td->o.max_bs[DDIR_READ] = rw_bs[DDIR_READ];
374 td->o.max_bs[DDIR_WRITE] = rw_bs[DDIR_WRITE];
375 }
8c1fdf04
JA
376
377 /*
378 * We need to do direct/raw ios to the device, to avoid getting
379 * read-ahead in our way.
380 */
381 td->o.odirect = 1;
382
fb7b71a3 383 return 0;
8c1fdf04
JA
384err:
385 close(fd);
38470f85 386 fifo_free(fifo);
8c1fdf04 387 return 1;
fb7b71a3 388}