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