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