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