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