Add --readonly option
[fio.git] / io_u.c
1 #include <unistd.h>
2 #include <fcntl.h>
3 #include <string.h>
4 #include <signal.h>
5 #include <time.h>
6 #include <assert.h>
7
8 #include "fio.h"
9
10 /*
11  * Change this define to play with the timeout handling
12  */
13 #undef FIO_USE_TIMEOUT
14
15 struct io_completion_data {
16         int nr;                         /* input */
17
18         int error;                      /* output */
19         unsigned long bytes_done[2];    /* output */
20         struct timeval time;            /* output */
21 };
22
23 /*
24  * The ->file_map[] contains a map of blocks we have or have not done io
25  * to yet. Used to make sure we cover the entire range in a fair fashion.
26  */
27 static int random_map_free(struct thread_data *td, struct fio_file *f,
28                            unsigned long long block)
29 {
30         unsigned int idx = RAND_MAP_IDX(td, f, block);
31         unsigned int bit = RAND_MAP_BIT(td, f, block);
32
33         return (f->file_map[idx] & (1UL << bit)) == 0;
34 }
35
36 /*
37  * Mark a given offset as used in the map.
38  */
39 static void mark_random_map(struct thread_data *td, struct io_u *io_u)
40 {
41         unsigned int min_bs = td->o.rw_min_bs;
42         struct fio_file *f = io_u->file;
43         unsigned long long block;
44         unsigned int blocks;
45         unsigned int nr_blocks;
46
47         block = io_u->offset / (unsigned long long) min_bs;
48         blocks = 0;
49         nr_blocks = (io_u->buflen + min_bs - 1) / min_bs;
50
51         while (blocks < nr_blocks) {
52                 unsigned int idx, bit;
53
54                 /*
55                  * If we have a mixed random workload, we may
56                  * encounter blocks we already did IO to.
57                  */
58                 if (!td->o.ddir_nr == 1 && !random_map_free(td, f, block))
59                         break;
60
61                 idx = RAND_MAP_IDX(td, f, block);
62                 bit = RAND_MAP_BIT(td, f, block);
63
64                 fio_assert(td, idx < f->num_maps);
65
66                 f->file_map[idx] |= (1UL << bit);
67                 block++;
68                 blocks++;
69         }
70
71         if ((blocks * min_bs) < io_u->buflen)
72                 io_u->buflen = blocks * min_bs;
73 }
74
75 /*
76  * Return the next free block in the map.
77  */
78 static int get_next_free_block(struct thread_data *td, struct fio_file *f,
79                                unsigned long long *b)
80 {
81         int i;
82
83         i = f->last_free_lookup;
84         *b = (i * BLOCKS_PER_MAP);
85         while ((*b) * td->o.rw_min_bs < f->real_file_size) {
86                 if (f->file_map[i] != -1UL) {
87                         *b += fio_ffz(f->file_map[i]);
88                         f->last_free_lookup = i;
89                         return 0;
90                 }
91
92                 *b += BLOCKS_PER_MAP;
93                 i++;
94         }
95
96         return 1;
97 }
98
99 static int get_next_rand_offset(struct thread_data *td, struct fio_file *f,
100                                 int ddir, unsigned long long *b)
101 {
102         unsigned long long max_blocks = f->io_size / td->o.min_bs[ddir];
103         unsigned long long r, rb;
104         int loops = 5;
105
106         do {
107                 r = os_random_long(&td->random_state);
108                 if (!max_blocks)
109                         *b = 0;
110                 else
111                         *b = ((max_blocks - 1) * r / (unsigned long long) (RAND_MAX+1.0));
112                 /*
113                  * if we are not maintaining a random map, we are done.
114                  */
115                 if (td->o.norandommap)
116                         return 0;
117
118                 /*
119                  * calculate map offset and chec if it's free
120                  */
121                 rb = *b + (f->file_offset / td->o.min_bs[ddir]);
122                 if (random_map_free(td, f, rb))
123                         return 0;
124
125         } while (--loops);
126
127         /*
128          * we get here, if we didn't suceed in looking up a block. generate
129          * a random start offset into the filemap, and find the first free
130          * block from there.
131          */
132         loops = 10;
133         do {
134                 f->last_free_lookup = (f->num_maps - 1) * (r / (RAND_MAX+1.0));
135                 if (!get_next_free_block(td, f, b))
136                         return 0;
137
138                 r = os_random_long(&td->random_state);
139         } while (--loops);
140
141         /*
142          * that didn't work either, try exhaustive search from the start
143          */
144         f->last_free_lookup = 0;
145         return get_next_free_block(td, f, b);
146 }
147
148 /*
149  * For random io, generate a random new block and see if it's used. Repeat
150  * until we find a free one. For sequential io, just return the end of
151  * the last io issued.
152  */
153 static int get_next_offset(struct thread_data *td, struct io_u *io_u)
154 {
155         struct fio_file *f = io_u->file;
156         const int ddir = io_u->ddir;
157         unsigned long long b;
158
159         if (td_random(td) && (td->o.ddir_nr && !--td->ddir_nr)) {
160                 td->ddir_nr = td->o.ddir_nr;
161
162                 if (get_next_rand_offset(td, f, ddir, &b))
163                         return 1;
164         } else {
165                 if (f->last_pos >= f->real_file_size) {
166                         if (!td_random(td) || get_next_rand_offset(td, f, ddir, &b))
167                                 return 1;
168                 } else
169                         b = (f->last_pos - f->file_offset) / td->o.min_bs[ddir];
170         }
171
172         io_u->offset = (b * td->o.min_bs[ddir]) + f->file_offset;
173         if (io_u->offset >= f->real_file_size)
174                 return 1;
175
176         return 0;
177 }
178
179 static unsigned int get_next_buflen(struct thread_data *td, struct io_u *io_u)
180 {
181         const int ddir = io_u->ddir;
182         unsigned int buflen;
183         long r;
184
185         if (td->o.min_bs[ddir] == td->o.max_bs[ddir])
186                 buflen = td->o.min_bs[ddir];
187         else {
188                 r = os_random_long(&td->bsrange_state);
189                 buflen = (unsigned int) (1 + (double) (td->o.max_bs[ddir] - 1) * r / (RAND_MAX + 1.0));
190                 if (!td->o.bs_unaligned)
191                         buflen = (buflen + td->o.min_bs[ddir] - 1) & ~(td->o.min_bs[ddir] - 1);
192         }
193
194         if (io_u->offset + buflen > io_u->file->real_file_size)
195                 buflen = td->o.min_bs[ddir];
196
197         return buflen;
198 }
199
200 static void set_rwmix_bytes(struct thread_data *td)
201 {
202         unsigned long long rbytes;
203         unsigned int diff;
204
205         /*
206          * we do time or byte based switch. this is needed because
207          * buffered writes may issue a lot quicker than they complete,
208          * whereas reads do not.
209          */
210         rbytes = td->io_bytes[td->rwmix_ddir] - td->rwmix_bytes;
211         diff = td->o.rwmix[td->rwmix_ddir ^ 1];
212
213         td->rwmix_bytes = td->io_bytes[td->rwmix_ddir] + (rbytes * ((100 - diff)) / diff);
214 }
215
216 static inline enum fio_ddir get_rand_ddir(struct thread_data *td)
217 {
218         unsigned int v;
219         long r;
220
221         r = os_random_long(&td->rwmix_state);
222         v = 1 + (int) (100.0 * (r / (RAND_MAX + 1.0)));
223         if (v < td->o.rwmix[DDIR_READ])
224                 return DDIR_READ;
225
226         return DDIR_WRITE;
227 }
228
229 /*
230  * Return the data direction for the next io_u. If the job is a
231  * mixed read/write workload, check the rwmix cycle and switch if
232  * necessary.
233  */
234 static enum fio_ddir get_rw_ddir(struct thread_data *td)
235 {
236         if (td_rw(td)) {
237                 struct timeval now;
238                 unsigned long elapsed;
239                 unsigned int cycle;
240
241                 fio_gettime(&now, NULL);
242                 elapsed = mtime_since_now(&td->rwmix_switch);
243
244                 /*
245                  * if this is the first cycle, make it shorter
246                  */
247                 cycle = td->o.rwmixcycle;
248                 if (!td->rwmix_bytes)
249                         cycle /= 10;
250
251                 /*
252                  * Check if it's time to seed a new data direction.
253                  */
254                 if (elapsed >= cycle ||
255                     td->io_bytes[td->rwmix_ddir] >= td->rwmix_bytes) {
256                         unsigned long long max_bytes;
257                         enum fio_ddir ddir;                     
258
259                         /*
260                          * Put a top limit on how many bytes we do for
261                          * one data direction, to avoid overflowing the
262                          * ranges too much
263                          */
264                         ddir = get_rand_ddir(td);
265                         max_bytes = td->this_io_bytes[ddir];
266                         if (max_bytes >= (td->o.size * td->o.rwmix[ddir] / 100)) {
267                                 if (!td->rw_end_set[ddir]) {
268                                         td->rw_end_set[ddir] = 1;
269                                         memcpy(&td->rw_end[ddir], &now, sizeof(now));
270                                 }
271                                 ddir ^= 1;
272                         }
273
274                         if (ddir != td->rwmix_ddir)
275                                 set_rwmix_bytes(td);
276
277                         td->rwmix_ddir = ddir;
278                         memcpy(&td->rwmix_switch, &now, sizeof(now));
279                 }
280                 return td->rwmix_ddir;
281         } else if (td_read(td))
282                 return DDIR_READ;
283         else
284                 return DDIR_WRITE;
285 }
286
287 void put_io_u(struct thread_data *td, struct io_u *io_u)
288 {
289         assert((io_u->flags & IO_U_F_FREE) == 0);
290         io_u->flags |= IO_U_F_FREE;
291
292         if (io_u->file)
293                 put_file(td, io_u->file);
294
295         io_u->file = NULL;
296         list_del(&io_u->list);
297         list_add(&io_u->list, &td->io_u_freelist);
298         td->cur_depth--;
299 }
300
301 void requeue_io_u(struct thread_data *td, struct io_u **io_u)
302 {
303         struct io_u *__io_u = *io_u;
304
305         __io_u->flags |= IO_U_F_FREE;
306         __io_u->flags &= ~IO_U_F_FLIGHT;
307
308         list_del(&__io_u->list);
309         list_add_tail(&__io_u->list, &td->io_u_requeues);
310         td->cur_depth--;
311         *io_u = NULL;
312 }
313
314 static int fill_io_u(struct thread_data *td, struct io_u *io_u)
315 {
316         /*
317          * see if it's time to sync
318          */
319         if (td->o.fsync_blocks &&
320            !(td->io_issues[DDIR_WRITE] % td->o.fsync_blocks) &&
321              td->io_issues[DDIR_WRITE] && should_fsync(td)) {
322                 io_u->ddir = DDIR_SYNC;
323                 goto out;
324         }
325
326         io_u->ddir = get_rw_ddir(td);
327
328         /*
329          * See if it's time to switch to a new zone
330          */
331         if (td->zone_bytes >= td->o.zone_size) {
332                 td->zone_bytes = 0;
333                 io_u->file->last_pos += td->o.zone_skip;
334                 td->io_skip_bytes += td->o.zone_skip;
335         }
336
337         /*
338          * No log, let the seq/rand engine retrieve the next buflen and
339          * position.
340          */
341         if (get_next_offset(td, io_u))
342                 return 1;
343
344         io_u->buflen = get_next_buflen(td, io_u);
345         if (!io_u->buflen)
346                 return 1;
347
348         if (io_u->offset + io_u->buflen > io_u->file->real_file_size)
349                 return 1;
350
351         /*
352          * mark entry before potentially trimming io_u
353          */
354         if (td_random(td) && !td->o.norandommap)
355                 mark_random_map(td, io_u);
356
357         /*
358          * If using a write iolog, store this entry.
359          */
360 out:
361         log_io_u(td, io_u);
362         return 0;
363 }
364
365 void io_u_mark_depth(struct thread_data *td, struct io_u *io_u)
366 {
367         int index = 0;
368
369         if (io_u->ddir == DDIR_SYNC)
370                 return;
371
372         switch (td->cur_depth) {
373         default:
374                 index = 6;
375                 break;
376         case 32 ... 63:
377                 index = 5;
378                 break;
379         case 16 ... 31:
380                 index = 4;
381                 break;
382         case 8 ... 15:
383                 index = 3;
384                 break;
385         case 4 ... 7:
386                 index = 2;
387                 break;
388         case 2 ... 3:
389                 index = 1;
390         case 1:
391                 break;
392         }
393
394         td->ts.io_u_map[index]++;
395         td->ts.total_io_u[io_u->ddir]++;
396 }
397
398 static void io_u_mark_lat_usec(struct thread_data *td, unsigned long usec)
399 {
400         int index = 0;
401
402         assert(usec < 1000);
403
404         switch (usec) {
405         case 750 ... 999:
406                 index = 9;
407                 break;
408         case 500 ... 749:
409                 index = 8;
410                 break;
411         case 250 ... 499:
412                 index = 7;
413                 break;
414         case 100 ... 249:
415                 index = 6;
416                 break;
417         case 50 ... 99:
418                 index = 5;
419                 break;
420         case 20 ... 49:
421                 index = 4;
422                 break;
423         case 10 ... 19:
424                 index = 3;
425                 break;
426         case 4 ... 9:
427                 index = 2;
428                 break;
429         case 2 ... 3:
430                 index = 1;
431         case 0 ... 1:
432                 break;
433         }
434
435         assert(index < FIO_IO_U_LAT_U_NR);
436         td->ts.io_u_lat_u[index]++;
437 }
438
439 static void io_u_mark_lat_msec(struct thread_data *td, unsigned long msec)
440 {
441         int index = 0;
442
443         switch (msec) {
444         default:
445                 index = 11;
446                 break;
447         case 1000 ... 1999:
448                 index = 10;
449                 break;
450         case 750 ... 999:
451                 index = 9;
452                 break;
453         case 500 ... 749:
454                 index = 8;
455                 break;
456         case 250 ... 499:
457                 index = 7;
458                 break;
459         case 100 ... 249:
460                 index = 6;
461                 break;
462         case 50 ... 99:
463                 index = 5;
464                 break;
465         case 20 ... 49:
466                 index = 4;
467                 break;
468         case 10 ... 19:
469                 index = 3;
470                 break;
471         case 4 ... 9:
472                 index = 2;
473                 break;
474         case 2 ... 3:
475                 index = 1;
476         case 0 ... 1:
477                 break;
478         }
479
480         assert(index < FIO_IO_U_LAT_M_NR);
481         td->ts.io_u_lat_m[index]++;
482 }
483
484 static void io_u_mark_latency(struct thread_data *td, unsigned long usec)
485 {
486         if (usec < 1000)
487                 io_u_mark_lat_usec(td, usec);
488         else
489                 io_u_mark_lat_msec(td, usec / 1000);
490 }
491
492 /*
493  * Get next file to service by choosing one at random
494  */
495 static struct fio_file *get_next_file_rand(struct thread_data *td, int goodf,
496                                            int badf)
497 {
498         struct fio_file *f;
499         int fno;
500
501         do {
502                 long r = os_random_long(&td->next_file_state);
503
504                 fno = (unsigned int) ((double) td->o.nr_files * (r / (RAND_MAX + 1.0)));
505                 f = &td->files[fno];
506                 if (f->flags & FIO_FILE_DONE)
507                         continue;
508
509                 if ((!goodf || (f->flags & goodf)) && !(f->flags & badf))
510                         return f;
511         } while (1);
512 }
513
514 /*
515  * Get next file to service by doing round robin between all available ones
516  */
517 static struct fio_file *get_next_file_rr(struct thread_data *td, int goodf,
518                                          int badf)
519 {
520         unsigned int old_next_file = td->next_file;
521         struct fio_file *f;
522
523         do {
524                 f = &td->files[td->next_file];
525
526                 td->next_file++;
527                 if (td->next_file >= td->o.nr_files)
528                         td->next_file = 0;
529
530                 if (f->flags & FIO_FILE_DONE) {
531                         f = NULL;
532                         continue;
533                 }
534
535                 if ((!goodf || (f->flags & goodf)) && !(f->flags & badf))
536                         break;
537
538                 f = NULL;
539         } while (td->next_file != old_next_file);
540
541         return f;
542 }
543
544 static struct fio_file *get_next_file(struct thread_data *td)
545 {
546         struct fio_file *f;
547
548         assert(td->o.nr_files <= td->files_index);
549
550         if (!td->nr_open_files || td->nr_done_files >= td->o.nr_files)
551                 return NULL;
552
553         f = td->file_service_file;
554         if (f && (f->flags & FIO_FILE_OPEN) && td->file_service_left--)
555                 return f;
556
557         if (td->o.file_service_type == FIO_FSERVICE_RR)
558                 f = get_next_file_rr(td, FIO_FILE_OPEN, FIO_FILE_CLOSING);
559         else
560                 f = get_next_file_rand(td, FIO_FILE_OPEN, FIO_FILE_CLOSING);
561
562         td->file_service_file = f;
563         td->file_service_left = td->file_service_nr - 1;
564         return f;
565 }
566
567 static struct fio_file *find_next_new_file(struct thread_data *td)
568 {
569         struct fio_file *f;
570
571         if (!td->nr_open_files || td->nr_done_files >= td->o.nr_files)
572                 return NULL;
573
574         if (td->o.file_service_type == FIO_FSERVICE_RR)
575                 f = get_next_file_rr(td, 0, FIO_FILE_OPEN);
576         else
577                 f = get_next_file_rand(td, 0, FIO_FILE_OPEN);
578
579         return f;
580 }
581
582 static int set_io_u_file(struct thread_data *td, struct io_u *io_u)
583 {
584         struct fio_file *f;
585
586         do {
587                 f = get_next_file(td);
588                 if (!f)
589                         return 1;
590
591 set_file:
592                 io_u->file = f;
593                 get_file(f);
594
595                 if (!fill_io_u(td, io_u))
596                         break;
597
598                 /*
599                  * td_io_close() does a put_file() as well, so no need to
600                  * do that here.
601                  */
602                 io_u->file = NULL;
603                 td_io_close_file(td, f);
604                 f->flags |= FIO_FILE_DONE;
605                 td->nr_done_files++;
606
607                 /*
608                  * probably not the right place to do this, but see
609                  * if we need to open a new file
610                  */
611                 if (td->nr_open_files < td->o.open_files &&
612                     td->o.open_files != td->o.nr_files) {
613                         f = find_next_new_file(td);
614
615                         if (!f || td_io_open_file(td, f))
616                                 return 1;
617
618                         goto set_file;
619                 }
620         } while (1);
621
622         return 0;
623 }
624
625
626 struct io_u *__get_io_u(struct thread_data *td)
627 {
628         struct io_u *io_u = NULL;
629
630         if (!list_empty(&td->io_u_requeues))
631                 io_u = list_entry(td->io_u_requeues.next, struct io_u, list);
632         else if (!queue_full(td)) {
633                 io_u = list_entry(td->io_u_freelist.next, struct io_u, list);
634
635                 io_u->buflen = 0;
636                 io_u->resid = 0;
637                 io_u->file = NULL;
638                 io_u->end_io = NULL;
639         }
640
641         if (io_u) {
642                 assert(io_u->flags & IO_U_F_FREE);
643                 io_u->flags &= ~IO_U_F_FREE;
644
645                 io_u->error = 0;
646                 list_del(&io_u->list);
647                 list_add(&io_u->list, &td->io_u_busylist);
648                 td->cur_depth++;
649         }
650
651         return io_u;
652 }
653
654 /*
655  * Return an io_u to be processed. Gets a buflen and offset, sets direction,
656  * etc. The returned io_u is fully ready to be prepped and submitted.
657  */
658 struct io_u *get_io_u(struct thread_data *td)
659 {
660         struct fio_file *f;
661         struct io_u *io_u;
662
663         io_u = __get_io_u(td);
664         if (!io_u)
665                 return NULL;
666
667         /*
668          * from a requeue, io_u already setup
669          */
670         if (io_u->file)
671                 goto out;
672
673         /*
674          * If using an iolog, grab next piece if any available.
675          */
676         if (td->o.read_iolog_file) {
677                 if (read_iolog_get(td, io_u))
678                         goto err_put;
679         } else if (set_io_u_file(td, io_u))
680                 goto err_put;
681         
682         f = io_u->file;
683         assert(f->flags & FIO_FILE_OPEN);
684
685         if (io_u->ddir != DDIR_SYNC) {
686                 if (!io_u->buflen)
687                         goto err_put;
688
689                 f->last_pos = io_u->offset + io_u->buflen;
690
691                 if (td->o.verify != VERIFY_NONE)
692                         populate_verify_io_u(td, io_u);
693         }
694
695         /*
696          * Set io data pointers.
697          */
698         io_u->endpos = io_u->offset + io_u->buflen;
699 out:
700         io_u->xfer_buf = io_u->buf;
701         io_u->xfer_buflen = io_u->buflen;
702
703         if (!td_io_prep(td, io_u)) {
704                 fio_gettime(&io_u->start_time, NULL);
705                 return io_u;
706         }
707 err_put:
708         put_io_u(td, io_u);
709         return NULL;
710 }
711
712 void io_u_log_error(struct thread_data *td, struct io_u *io_u)
713 {
714         const char *msg[] = { "read", "write", "sync" };
715
716         log_err("fio: io_u error");
717
718         if (io_u->file)
719                 log_err(" on file %s", io_u->file->file_name);
720
721         log_err(": %s\n", strerror(io_u->error));
722
723         log_err("     %s offset=%llu, buflen=%lu\n", msg[io_u->ddir], io_u->offset, io_u->xfer_buflen);
724
725         if (!td->error)
726                 td_verror(td, io_u->error, "io_u error");
727 }
728
729 static void io_completed(struct thread_data *td, struct io_u *io_u,
730                          struct io_completion_data *icd)
731 {
732         unsigned long usec;
733
734         assert(io_u->flags & IO_U_F_FLIGHT);
735         io_u->flags &= ~IO_U_F_FLIGHT;
736
737         if (io_u->ddir == DDIR_SYNC) {
738                 td->last_was_sync = 1;
739                 return;
740         }
741
742         td->last_was_sync = 0;
743
744         if (!io_u->error) {
745                 unsigned int bytes = io_u->buflen - io_u->resid;
746                 const enum fio_ddir idx = io_u->ddir;
747                 int ret;
748
749                 td->io_blocks[idx]++;
750                 td->io_bytes[idx] += bytes;
751                 td->zone_bytes += bytes;
752                 td->this_io_bytes[idx] += bytes;
753
754                 io_u->file->last_completed_pos = io_u->endpos;
755
756                 usec = utime_since(&io_u->issue_time, &icd->time);
757
758                 add_clat_sample(td, idx, usec);
759                 add_bw_sample(td, idx, &icd->time);
760                 io_u_mark_latency(td, usec);
761
762                 if (td_write(td) && idx == DDIR_WRITE &&
763                     td->o.verify != VERIFY_NONE)
764                         log_io_piece(td, io_u);
765
766                 icd->bytes_done[idx] += bytes;
767
768                 if (io_u->end_io) {
769                         ret = io_u->end_io(td, io_u);
770                         if (ret && !icd->error)
771                                 icd->error = ret;
772                 }
773         } else {
774                 icd->error = io_u->error;
775                 io_u_log_error(td, io_u);
776         }
777 }
778
779 static void init_icd(struct io_completion_data *icd, int nr)
780 {
781         fio_gettime(&icd->time, NULL);
782
783         icd->nr = nr;
784
785         icd->error = 0;
786         icd->bytes_done[0] = icd->bytes_done[1] = 0;
787 }
788
789 static void ios_completed(struct thread_data *td,
790                           struct io_completion_data *icd)
791 {
792         struct io_u *io_u;
793         int i;
794
795         for (i = 0; i < icd->nr; i++) {
796                 io_u = td->io_ops->event(td, i);
797
798                 io_completed(td, io_u, icd);
799                 put_io_u(td, io_u);
800         }
801 }
802
803 /*
804  * Complete a single io_u for the sync engines.
805  */
806 long io_u_sync_complete(struct thread_data *td, struct io_u *io_u)
807 {
808         struct io_completion_data icd;
809
810         init_icd(&icd, 1);
811         io_completed(td, io_u, &icd);
812         put_io_u(td, io_u);
813
814         if (!icd.error)
815                 return icd.bytes_done[0] + icd.bytes_done[1];
816
817         td_verror(td, icd.error, "io_u_sync_complete");
818         return -1;
819 }
820
821 /*
822  * Called to complete min_events number of io for the async engines.
823  */
824 long io_u_queued_complete(struct thread_data *td, int min_events)
825 {
826         struct io_completion_data icd;
827         struct timespec *tvp = NULL;
828         int ret;
829         struct timespec ts = { .tv_sec = 0, .tv_nsec = 0, };
830
831         if (!min_events)
832                 tvp = &ts;
833
834         ret = td_io_getevents(td, min_events, td->cur_depth, tvp);
835         if (ret < 0) {
836                 td_verror(td, -ret, "td_io_getevents");
837                 return ret;
838         } else if (!ret)
839                 return ret;
840
841         init_icd(&icd, ret);
842         ios_completed(td, &icd);
843         if (!icd.error)
844                 return icd.bytes_done[0] + icd.bytes_done[1];
845
846         td_verror(td, icd.error, "io_u_queued_complete");
847         return -1;
848 }
849
850 /*
851  * Call when io_u is really queued, to update the submission latency.
852  */
853 void io_u_queued(struct thread_data *td, struct io_u *io_u)
854 {
855         unsigned long slat_time;
856
857         slat_time = utime_since(&io_u->start_time, &io_u->issue_time);
858         add_slat_sample(td, io_u->ddir, slat_time);
859 }
860
861 #ifdef FIO_USE_TIMEOUT
862 void io_u_set_timeout(struct thread_data *td)
863 {
864         assert(td->cur_depth);
865
866         td->timer.it_interval.tv_sec = 0;
867         td->timer.it_interval.tv_usec = 0;
868         td->timer.it_value.tv_sec = IO_U_TIMEOUT + IO_U_TIMEOUT_INC;
869         td->timer.it_value.tv_usec = 0;
870         setitimer(ITIMER_REAL, &td->timer, NULL);
871         fio_gettime(&td->timeout_end, NULL);
872 }
873
874 static void io_u_dump(struct io_u *io_u)
875 {
876         unsigned long t_start = mtime_since_now(&io_u->start_time);
877         unsigned long t_issue = mtime_since_now(&io_u->issue_time);
878
879         log_err("io_u=%p, t_start=%lu, t_issue=%lu\n", io_u, t_start, t_issue);
880         log_err("  buf=%p/%p, len=%lu/%lu, offset=%llu\n", io_u->buf, io_u->xfer_buf, io_u->buflen, io_u->xfer_buflen, io_u->offset);
881         log_err("  ddir=%d, fname=%s\n", io_u->ddir, io_u->file->file_name);
882 }
883 #else
884 void io_u_set_timeout(struct thread_data fio_unused *td)
885 {
886 }
887 #endif
888
889 #ifdef FIO_USE_TIMEOUT
890 static void io_u_timeout_handler(int fio_unused sig)
891 {
892         struct thread_data *td, *__td;
893         pid_t pid = getpid();
894         struct list_head *entry;
895         struct io_u *io_u;
896         int i;
897
898         log_err("fio: io_u timeout\n");
899
900         /*
901          * TLS would be nice...
902          */
903         td = NULL;
904         for_each_td(__td, i) {
905                 if (__td->pid == pid) {
906                         td = __td;
907                         break;
908                 }
909         }
910
911         if (!td) {
912                 log_err("fio: io_u timeout, can't find job\n");
913                 exit(1);
914         }
915
916         if (!td->cur_depth) {
917                 log_err("fio: timeout without pending work?\n");
918                 return;
919         }
920
921         log_err("fio: io_u timeout: job=%s, pid=%d\n", td->o.name, td->pid);
922
923         list_for_each(entry, &td->io_u_busylist) {
924                 io_u = list_entry(entry, struct io_u, list);
925
926                 io_u_dump(io_u);
927         }
928
929         td_verror(td, ETIMEDOUT, "io_u timeout");
930         exit(1);
931 }
932 #endif
933
934 void io_u_init_timeout(void)
935 {
936 #ifdef FIO_USE_TIMEOUT
937         signal(SIGALRM, io_u_timeout_handler);
938 #endif
939 }