blob: e195f7f1fdbf4dea9eff8b252b606273431027a1 [file] [log] [blame]
Jens Axboefb7b71a2007-05-15 08:44:04 +02001/*
2 * blktrace support code for fio
3 */
4#include <stdio.h>
5#include <stdlib.h>
Jens Axboe5e6c2062007-05-16 14:40:29 +02006#include <sys/stat.h>
7#include <dirent.h>
Jens Axboe8c1fdf02007-05-15 11:54:21 +02008
Jens Axboe01743ee2008-06-02 12:19:19 +02009#include "flist.h"
Jens Axboefb7b71a2007-05-15 08:44:04 +020010#include "fio.h"
11#include "blktrace_api.h"
12
Jens Axboe2da7df12010-08-01 21:27:28 +020013#define TRACE_FIFO_SIZE 8192
Jens Axboee2887562007-05-16 09:25:09 +020014
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];
Jens Axboef12b3232007-05-16 12:16:44 +020021 unsigned int total;
Jens Axboee2887562007-05-16 09:25:09 +020022 int ret;
23
Jens Axboef12b3232007-05-16 12:16:44 +020024 total = sizeof(buf);
25 if (total > fifo_room(fifo))
26 total = fifo_room(fifo);
Jens Axboee2887562007-05-16 09:25:09 +020027
Jens Axboef12b3232007-05-16 12:16:44 +020028 ret = read(fd, buf, total);
29 if (ret < 0) {
30 td_verror(td, errno, "read blktrace file");
31 return -1;
Jens Axboee2887562007-05-16 09:25:09 +020032 }
33
Jens Axboef12b3232007-05-16 12:16:44 +020034 if (ret > 0)
35 ret = fifo_put(fifo, buf, ret);
36
Jens Axboebd6f78b2008-02-01 20:27:52 +010037 dprint(FD_BLKTRACE, "refill: filled %d bytes\n", ret);
Jens Axboef12b3232007-05-16 12:16:44 +020038 return ret;
Jens Axboee2887562007-05-16 09:25:09 +020039}
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{
Jens Axboef12b3232007-05-16 12:16:44 +020047 if (fifo_len(fifo) < len) {
48 int ret = refill_fifo(td, fifo, fd);
Jens Axboee2887562007-05-16 09:25:09 +020049
Jens Axboef12b3232007-05-16 12:16:44 +020050 if (ret < 0)
51 return ret;
52 }
Jens Axboee2887562007-05-16 09:25:09 +020053
54 return fifo_get(fifo, buf, len);
55}
56
Jens Axboe8c1fdf02007-05-15 11:54:21 +020057/*
58 * Just discard the pdu by seeking past it.
59 */
Jens Axboef12b3232007-05-16 12:16:44 +020060static int discard_pdu(struct thread_data *td, struct fifo *fifo, int fd,
61 struct blk_io_trace *t)
Jens Axboefb7b71a2007-05-15 08:44:04 +020062{
63 if (t->pdu_len == 0)
64 return 0;
65
Jens Axboebd6f78b2008-02-01 20:27:52 +010066 dprint(FD_BLKTRACE, "discard pdu len %u\n", t->pdu_len);
Jens Axboef12b3232007-05-16 12:16:44 +020067 return trace_fifo_get(td, fifo, fd, NULL, t->pdu_len);
Jens Axboefb7b71a2007-05-15 08:44:04 +020068}
69
Jens Axboe8c1fdf02007-05-15 11:54:21 +020070/*
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 */
Jens Axboefb7b71a2007-05-15 08:44:04 +020074int is_blktrace(const char *filename)
75{
76 struct blk_io_trace t;
77 int fd, ret;
78
79 fd = open(filename, O_RDONLY);
Jens Axboe4dced402007-07-23 14:16:55 +020080 if (fd < 0)
Jens Axboefb7b71a2007-05-15 08:44:04 +020081 return 0;
Jens Axboefb7b71a2007-05-15 08:44:04 +020082
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
David Nellansd1c46c02010-08-31 21:20:47 +0200100static int lookup_device(struct thread_data *td, char *path, unsigned int maj,
101 unsigned int min)
Jens Axboe5e6c2062007-05-16 14:40:29 +0200102{
103 struct dirent *dir;
104 struct stat st;
105 int found = 0;
106 DIR *D;
107
108 D = opendir(path);
109 if (!D)
110 return 0;
111
112 while ((dir = readdir(D)) != NULL) {
113 char full_path[256];
114
115 if (!strcmp(dir->d_name, ".") || !strcmp(dir->d_name, ".."))
116 continue;
117
Bruce Cranb9fd7882012-02-20 17:01:46 +0000118 sprintf(full_path, "%s%s%s", path, FIO_OS_PATH_SEPARATOR, dir->d_name);
Jens Axboe5e6c2062007-05-16 14:40:29 +0200119 if (lstat(full_path, &st) == -1) {
120 perror("lstat");
121 break;
122 }
123
124 if (S_ISDIR(st.st_mode)) {
David Nellansd1c46c02010-08-31 21:20:47 +0200125 found = lookup_device(td, full_path, maj, min);
Jens Axboe5e6c2062007-05-16 14:40:29 +0200126 if (found) {
127 strcpy(path, full_path);
128 break;
129 }
130 }
131
132 if (!S_ISBLK(st.st_mode))
133 continue;
134
David Nellansd1c46c02010-08-31 21:20:47 +0200135 /*
136 * If replay_redirect is set then always return this device
137 * upon lookup which overrides the device lookup based on
138 * major minor in the actual blktrace
139 */
140 if (td->o.replay_redirect) {
141 dprint(FD_BLKTRACE, "device lookup: %d/%d\n overridden"
142 " with: %s", maj, min,
143 td->o.replay_redirect);
144 strcpy(path, td->o.replay_redirect);
145 found = 1;
146 break;
147 }
148
Jens Axboe5e6c2062007-05-16 14:40:29 +0200149 if (maj == major(st.st_rdev) && min == minor(st.st_rdev)) {
Jens Axboe5ec10ea2008-03-06 15:42:00 +0100150 dprint(FD_BLKTRACE, "device lookup: %d/%d\n", maj, min);
Jens Axboe5e6c2062007-05-16 14:40:29 +0200151 strcpy(path, full_path);
152 found = 1;
153 break;
154 }
155 }
156
157 closedir(D);
158 return found;
159}
160
Jens Axboec69aa912007-05-22 15:51:50 +0200161#define FMINORBITS 20
162#define FMINORMASK ((1U << FMINORBITS) - 1)
163#define FMAJOR(dev) ((unsigned int) ((dev) >> FMINORBITS))
164#define FMINOR(dev) ((unsigned int) ((dev) & FMINORMASK))
Jens Axboeeeb9c2a2007-05-16 18:28:47 +0200165
Shaohua Li89ac1d42012-06-11 08:56:32 +0200166static void trace_add_open_close_event(struct thread_data *td, int fileno, enum file_log_act action)
Jens Axboe691c8fb2008-03-07 14:26:26 +0100167{
168 struct io_piece *ipo;
169
170 ipo = calloc(1, sizeof(*ipo));
Jens Axboe0d29de82010-09-01 13:54:15 +0200171 init_ipo(ipo);
Jens Axboe691c8fb2008-03-07 14:26:26 +0100172
173 ipo->ddir = DDIR_INVAL;
174 ipo->fileno = fileno;
Shaohua Li89ac1d42012-06-11 08:56:32 +0200175 ipo->file_action = action;
Jens Axboe01743ee2008-06-02 12:19:19 +0200176 flist_add_tail(&ipo->list, &td->io_log_list);
Jens Axboe691c8fb2008-03-07 14:26:26 +0100177}
178
Shaohua Li89ac1d42012-06-11 08:56:32 +0200179static int trace_add_file(struct thread_data *td, __u32 device)
Jens Axboe5e6c2062007-05-16 14:40:29 +0200180{
Shaohua Li89ac1d42012-06-11 08:56:32 +0200181 static unsigned int last_maj, last_min, last_fileno;
Jens Axboec69aa912007-05-22 15:51:50 +0200182 unsigned int maj = FMAJOR(device);
183 unsigned int min = FMINOR(device);
Jens Axboe5e6c2062007-05-16 14:40:29 +0200184 struct fio_file *f;
185 char dev[256];
186 unsigned int i;
187
188 if (last_maj == maj && last_min == min)
Shaohua Li89ac1d42012-06-11 08:56:32 +0200189 return last_fileno;
Jens Axboe5e6c2062007-05-16 14:40:29 +0200190
191 last_maj = maj;
192 last_min = min;
193
194 /*
195 * check for this file in our list
196 */
197 for_each_file(td, f, i)
Shaohua Li89ac1d42012-06-11 08:56:32 +0200198 if (f->major == maj && f->minor == min) {
199 last_fileno = f->fileno;
200 return last_fileno;
201 }
Jens Axboe5e6c2062007-05-16 14:40:29 +0200202
203 strcpy(dev, "/dev");
David Nellansd1c46c02010-08-31 21:20:47 +0200204 if (lookup_device(td, dev, maj, min)) {
Jens Axboe691c8fb2008-03-07 14:26:26 +0100205 int fileno;
206
Jens Axboebd6f78b2008-02-01 20:27:52 +0100207 dprint(FD_BLKTRACE, "add devices %s\n", dev);
Jens Axboe49ffb4a2010-08-24 15:01:37 +0200208 fileno = add_file_exclusive(td, dev);
Shaohua Li89ac1d42012-06-11 08:56:32 +0200209 trace_add_open_close_event(td, fileno, FIO_LOG_OPEN_FILE);
210 last_fileno = fileno;
Jens Axboebd6f78b2008-02-01 20:27:52 +0100211 }
Shaohua Li89ac1d42012-06-11 08:56:32 +0200212 return last_fileno;
Jens Axboe5e6c2062007-05-16 14:40:29 +0200213}
214
Jens Axboe8c1fdf02007-05-15 11:54:21 +0200215/*
216 * Store blk_io_trace data in an ipo for later retrieval.
217 */
Jens Axboefdefd982007-05-15 10:12:26 +0200218static void store_ipo(struct thread_data *td, unsigned long long offset,
Shaohua Li89ac1d42012-06-11 08:56:32 +0200219 unsigned int bytes, int rw, unsigned long long ttime,
220 int fileno)
Jens Axboefdefd982007-05-15 10:12:26 +0200221{
222 struct io_piece *ipo = malloc(sizeof(*ipo));
223
Jens Axboe0d29de82010-09-01 13:54:15 +0200224 init_ipo(ipo);
225
Jens Axboea2eea812007-05-15 13:10:41 +0200226 /*
227 * the 512 is wrong here, it should be the hardware sector size...
228 */
229 ipo->offset = offset * 512;
Jens Axboefdefd982007-05-15 10:12:26 +0200230 ipo->len = bytes;
Jens Axboe8c1fdf02007-05-15 11:54:21 +0200231 ipo->delay = ttime / 1000;
Jens Axboefdefd982007-05-15 10:12:26 +0200232 if (rw)
233 ipo->ddir = DDIR_WRITE;
234 else
235 ipo->ddir = DDIR_READ;
Shaohua Li89ac1d42012-06-11 08:56:32 +0200236 ipo->fileno = fileno;
Jens Axboefdefd982007-05-15 10:12:26 +0200237
Jens Axboebd6f78b2008-02-01 20:27:52 +0100238 dprint(FD_BLKTRACE, "store ddir=%d, off=%llu, len=%lu, delay=%lu\n",
239 ipo->ddir, ipo->offset,
240 ipo->len, ipo->delay);
Jens Axboe691c8fb2008-03-07 14:26:26 +0100241 queue_io_piece(td, ipo);
Jens Axboefdefd982007-05-15 10:12:26 +0200242}
243
Jens Axboe0b9d69e2009-09-11 22:29:54 +0200244static void handle_trace_notify(struct blk_io_trace *t)
Jens Axboe691c8fb2008-03-07 14:26:26 +0100245{
246 switch (t->action) {
247 case BLK_TN_PROCESS:
248 printf("got process notify: %x, %d\n", t->action, t->pid);
249 break;
250 case BLK_TN_TIMESTAMP:
251 printf("got timestamp notify: %x, %d\n", t->action, t->pid);
252 break;
Jens Axboeff58fce2010-08-25 12:02:08 +0200253 case BLK_TN_MESSAGE:
254 break;
Jens Axboe691c8fb2008-03-07 14:26:26 +0100255 default:
256 dprint(FD_BLKTRACE, "unknown trace act %x\n", t->action);
257 break;
258 }
259}
260
Jens Axboeff58fce2010-08-25 12:02:08 +0200261static void handle_trace_discard(struct thread_data *td, struct blk_io_trace *t,
262 unsigned long long ttime, unsigned long *ios)
263{
264 struct io_piece *ipo = malloc(sizeof(*ipo));
Shaohua Li89ac1d42012-06-11 08:56:32 +0200265 int fileno;
Jens Axboeff58fce2010-08-25 12:02:08 +0200266
Jens Axboe0d29de82010-09-01 13:54:15 +0200267 init_ipo(ipo);
Shaohua Li89ac1d42012-06-11 08:56:32 +0200268 fileno = trace_add_file(td, t->device);
Jens Axboeff58fce2010-08-25 12:02:08 +0200269
270 ios[DDIR_WRITE]++;
271 td->o.size += t->bytes;
272
273 memset(ipo, 0, sizeof(*ipo));
274 INIT_FLIST_HEAD(&ipo->list);
275
276 /*
277 * the 512 is wrong here, it should be the hardware sector size...
278 */
279 ipo->offset = t->sector * 512;
280 ipo->len = t->bytes;
281 ipo->delay = ttime / 1000;
282 ipo->ddir = DDIR_TRIM;
Shaohua Li89ac1d42012-06-11 08:56:32 +0200283 ipo->fileno = fileno;
Jens Axboeff58fce2010-08-25 12:02:08 +0200284
285 dprint(FD_BLKTRACE, "store discard, off=%llu, len=%lu, delay=%lu\n",
286 ipo->offset, ipo->len,
287 ipo->delay);
288 queue_io_piece(td, ipo);
289}
290
Jens Axboe691c8fb2008-03-07 14:26:26 +0100291static void handle_trace_fs(struct thread_data *td, struct blk_io_trace *t,
292 unsigned long long ttime, unsigned long *ios,
293 unsigned int *bs)
Jens Axboefb7b71a2007-05-15 08:44:04 +0200294{
Jens Axboefdefd982007-05-15 10:12:26 +0200295 int rw;
Shaohua Li89ac1d42012-06-11 08:56:32 +0200296 int fileno;
Jens Axboefdefd982007-05-15 10:12:26 +0200297
Shaohua Li89ac1d42012-06-11 08:56:32 +0200298 fileno = trace_add_file(td, t->device);
Jens Axboe5e6c2062007-05-16 14:40:29 +0200299
Jens Axboee7a7d702007-05-15 10:13:04 +0200300 rw = (t->action & BLK_TC_ACT(BLK_TC_WRITE)) != 0;
Jens Axboed84f8d42007-05-16 08:47:46 +0200301
302 if (t->bytes > bs[rw])
303 bs[rw] = t->bytes;
304
Jens Axboe8c1fdf02007-05-15 11:54:21 +0200305 ios[rw]++;
Jens Axboe6df8ada2007-05-15 13:23:19 +0200306 td->o.size += t->bytes;
Shaohua Li89ac1d42012-06-11 08:56:32 +0200307 store_ipo(td, t->sector, t->bytes, rw, ttime, fileno);
Jens Axboefb7b71a2007-05-15 08:44:04 +0200308}
309
Jens Axboe8c1fdf02007-05-15 11:54:21 +0200310/*
Jens Axboe691c8fb2008-03-07 14:26:26 +0100311 * We only care for queue traces, most of the others are side effects
312 * due to internal workings of the block layer.
313 */
314static void handle_trace(struct thread_data *td, struct blk_io_trace *t,
315 unsigned long long ttime, unsigned long *ios,
316 unsigned int *bs)
317{
318 if ((t->action & 0xffff) != __BLK_TA_QUEUE)
319 return;
320 if (t->action & BLK_TC_ACT(BLK_TC_PC))
321 return;
322
323 if (t->action & BLK_TC_ACT(BLK_TC_NOTIFY))
Jens Axboeaec2de22008-04-24 12:44:42 +0200324 handle_trace_notify(t);
Jens Axboeff58fce2010-08-25 12:02:08 +0200325 else if (t->action & BLK_TC_ACT(BLK_TC_DISCARD))
326 handle_trace_discard(td, t, ttime, ios);
Jens Axboe691c8fb2008-03-07 14:26:26 +0100327 else
328 handle_trace_fs(td, t, ttime, ios, bs);
329}
330
331/*
Jens Axboe8c1fdf02007-05-15 11:54:21 +0200332 * Load a blktrace file by reading all the blk_io_trace entries, and storing
333 * them as io_pieces like the fio text version would do.
334 */
Jens Axboefb7b71a2007-05-15 08:44:04 +0200335int load_blktrace(struct thread_data *td, const char *filename)
336{
Jens Axboea61edde2007-05-15 14:29:58 +0200337 unsigned long long ttime, delay;
Jens Axboefb7b71a2007-05-15 08:44:04 +0200338 struct blk_io_trace t;
Jens Axboe4241ea82007-09-12 08:18:36 +0200339 unsigned long ios[2], skipped_writes;
Jens Axboea61edde2007-05-15 14:29:58 +0200340 unsigned int cpu;
Jens Axboed84f8d42007-05-16 08:47:46 +0200341 unsigned int rw_bs[2];
Jens Axboee2887562007-05-16 09:25:09 +0200342 struct fifo *fifo;
Shaohua Li89ac1d42012-06-11 08:56:32 +0200343 int fd, i;
344 struct fio_file *f;
Jens Axboefb7b71a2007-05-15 08:44:04 +0200345
346 fd = open(filename, O_RDONLY);
347 if (fd < 0) {
348 td_verror(td, errno, "open blktrace file");
349 return 1;
350 }
351
Jens Axboee2887562007-05-16 09:25:09 +0200352 fifo = fifo_alloc(TRACE_FIFO_SIZE);
353
Jens Axboe6df8ada2007-05-15 13:23:19 +0200354 td->o.size = 0;
355
Jens Axboea61edde2007-05-15 14:29:58 +0200356 cpu = 0;
Jens Axboed84f8d42007-05-16 08:47:46 +0200357 ttime = 0;
358 ios[0] = ios[1] = 0;
359 rw_bs[0] = rw_bs[1] = 0;
Jens Axboe4241ea82007-09-12 08:18:36 +0200360 skipped_writes = 0;
Jens Axboefb7b71a2007-05-15 08:44:04 +0200361 do {
Jens Axboee2887562007-05-16 09:25:09 +0200362 int ret = trace_fifo_get(td, fifo, fd, &t, sizeof(t));
Jens Axboefb7b71a2007-05-15 08:44:04 +0200363
Jens Axboee2887562007-05-16 09:25:09 +0200364 if (ret < 0)
Jens Axboe8c1fdf02007-05-15 11:54:21 +0200365 goto err;
Jens Axboee2887562007-05-16 09:25:09 +0200366 else if (!ret)
Jens Axboefb7b71a2007-05-15 08:44:04 +0200367 break;
Jens Axboee2887562007-05-16 09:25:09 +0200368 else if (ret < (int) sizeof(t)) {
369 log_err("fio: short fifo get\n");
370 break;
Jens Axboefb7b71a2007-05-15 08:44:04 +0200371 }
372
373 if ((t.magic & 0xffffff00) != BLK_IO_TRACE_MAGIC) {
Jens Axboe5ec10ea2008-03-06 15:42:00 +0100374 log_err("fio: bad magic in blktrace data: %x\n",
375 t.magic);
Jens Axboe8c1fdf02007-05-15 11:54:21 +0200376 goto err;
Jens Axboefb7b71a2007-05-15 08:44:04 +0200377 }
378 if ((t.magic & 0xff) != BLK_IO_TRACE_VERSION) {
Jens Axboe5ec10ea2008-03-06 15:42:00 +0100379 log_err("fio: bad blktrace version %d\n",
380 t.magic & 0xff);
Jens Axboe8c1fdf02007-05-15 11:54:21 +0200381 goto err;
Jens Axboefb7b71a2007-05-15 08:44:04 +0200382 }
Jens Axboef12b3232007-05-16 12:16:44 +0200383 ret = discard_pdu(td, fifo, fd, &t);
384 if (ret < 0) {
Jens Axboefb7b71a2007-05-15 08:44:04 +0200385 td_verror(td, ret, "blktrace lseek");
Jens Axboe8c1fdf02007-05-15 11:54:21 +0200386 goto err;
Jens Axboef12b3232007-05-16 12:16:44 +0200387 } else if (t.pdu_len != ret) {
388 log_err("fio: discarded %d of %d\n", ret, t.pdu_len);
389 goto err;
Jens Axboefb7b71a2007-05-15 08:44:04 +0200390 }
Jens Axboe691c8fb2008-03-07 14:26:26 +0100391 if ((t.action & BLK_TC_ACT(BLK_TC_NOTIFY)) == 0) {
392 if (!ttime) {
393 ttime = t.time;
394 cpu = t.cpu;
395 }
396
397 delay = 0;
398 if (cpu == t.cpu)
399 delay = t.time - ttime;
400 if ((t.action & BLK_TC_ACT(BLK_TC_WRITE)) && read_only)
401 skipped_writes++;
David Nellans64bbb862010-08-24 22:13:30 +0200402 else {
403 /*
404 * set delay to zero if no_stall enabled for
405 * fast replay
406 */
407 if (td->o.no_stall)
408 delay = 0;
409
Jens Axboe691c8fb2008-03-07 14:26:26 +0100410 handle_trace(td, &t, delay, ios, rw_bs);
David Nellans64bbb862010-08-24 22:13:30 +0200411 }
Jens Axboe691c8fb2008-03-07 14:26:26 +0100412
Jens Axboe8c1fdf02007-05-15 11:54:21 +0200413 ttime = t.time;
Jens Axboea61edde2007-05-15 14:29:58 +0200414 cpu = t.cpu;
Jens Axboea6edd632008-03-07 21:41:54 +0100415 } else {
416 delay = 0;
Jens Axboe4241ea82007-09-12 08:18:36 +0200417 handle_trace(td, &t, delay, ios, rw_bs);
Jens Axboea6edd632008-03-07 21:41:54 +0100418 }
Jens Axboefb7b71a2007-05-15 08:44:04 +0200419 } while (1);
420
Jens Axboe85a47ca2012-06-11 13:19:13 +0200421 for (i = 0; i < td->files_index; i++) {
422 f= td->files[i];
Shaohua Li89ac1d42012-06-11 08:56:32 +0200423 trace_add_open_close_event(td, f->fileno, FIO_LOG_CLOSE_FILE);
Jens Axboe85a47ca2012-06-11 13:19:13 +0200424 }
Shaohua Li89ac1d42012-06-11 08:56:32 +0200425
Jens Axboe38470f82007-05-16 09:26:23 +0200426 fifo_free(fifo);
Jens Axboefb7b71a2007-05-15 08:44:04 +0200427 close(fd);
Jens Axboe8c1fdf02007-05-15 11:54:21 +0200428
Jens Axboe4241ea82007-09-12 08:18:36 +0200429 if (skipped_writes)
Jens Axboe5ec10ea2008-03-06 15:42:00 +0100430 log_err("fio: %s skips replay of %lu writes due to read-only\n",
431 td->o.name, skipped_writes);
Jens Axboe4241ea82007-09-12 08:18:36 +0200432
Jens Axboe8c1fdf02007-05-15 11:54:21 +0200433 if (!ios[DDIR_READ] && !ios[DDIR_WRITE]) {
434 log_err("fio: found no ios in blktrace data\n");
435 return 1;
Jens Axboed84f8d42007-05-16 08:47:46 +0200436 } else if (ios[DDIR_READ] && !ios[DDIR_READ]) {
Jens Axboe8c1fdf02007-05-15 11:54:21 +0200437 td->o.td_ddir = TD_DDIR_READ;
Jens Axboed84f8d42007-05-16 08:47:46 +0200438 td->o.max_bs[DDIR_READ] = rw_bs[DDIR_READ];
439 } else if (!ios[DDIR_READ] && ios[DDIR_WRITE]) {
Jens Axboe8c1fdf02007-05-15 11:54:21 +0200440 td->o.td_ddir = TD_DDIR_WRITE;
Jens Axboed84f8d42007-05-16 08:47:46 +0200441 td->o.max_bs[DDIR_WRITE] = rw_bs[DDIR_WRITE];
442 } else {
Jens Axboe8c1fdf02007-05-15 11:54:21 +0200443 td->o.td_ddir = TD_DDIR_RW;
Jens Axboed84f8d42007-05-16 08:47:46 +0200444 td->o.max_bs[DDIR_READ] = rw_bs[DDIR_READ];
445 td->o.max_bs[DDIR_WRITE] = rw_bs[DDIR_WRITE];
446 }
Jens Axboe8c1fdf02007-05-15 11:54:21 +0200447
448 /*
449 * We need to do direct/raw ios to the device, to avoid getting
450 * read-ahead in our way.
451 */
452 td->o.odirect = 1;
453
Jens Axboefb7b71a2007-05-15 08:44:04 +0200454 return 0;
Jens Axboe8c1fdf02007-05-15 11:54:21 +0200455err:
456 close(fd);
Jens Axboe38470f82007-05-16 09:26:23 +0200457 fifo_free(fifo);
Jens Axboe8c1fdf02007-05-15 11:54:21 +0200458 return 1;
Jens Axboefb7b71a2007-05-15 08:44:04 +0200459}