Add 'null' verify option

[fio.git] / io_u.c

diff --git a/io_u.c b/io_u.c
index 2b18e9f8a9a606c349304d843156f2b9a26025d0..9c8ff2638df5ed3ea57bb943f04672a7b8f63077 100644 (file)
--- a/io_u.c
+++ b/io_u.c
@@ -52,7 +52,11 @@ static void mark_random_map(struct thread_data *td, struct io_u *io_u)
        while (blocks < nr_blocks) {
                unsigned int idx, bit;
 
-               if (!random_map_free(td, f, block))
+               /*
+                * If we have a mixed random workload, we may
+                * encounter blocks we already did IO to.
+                */
+               if (!td->o.ddir_nr && !random_map_free(td, f, block))
                        break;
 
                idx = RAND_MAP_IDX(td, f, block);
@@ -93,6 +97,35 @@ static int get_next_free_block(struct thread_data *td, struct fio_file *f,
        return 1;
 }
 
+static int get_next_rand_offset(struct thread_data *td, struct fio_file *f,
+                               int ddir, unsigned long long *b)
+{
+       unsigned long long max_blocks = f->file_size / td->o.min_bs[ddir];
+       unsigned long long r, rb;
+       int loops = 5;
+
+       do {
+               r = os_random_long(&td->random_state);
+               if (!max_blocks)
+                       *b = 0;
+               else
+                       *b = ((max_blocks - 1) * r / (unsigned long long) (RAND_MAX+1.0));
+               if (td->o.norandommap)
+                       break;
+               rb = *b + (f->file_offset / td->o.min_bs[ddir]);
+               loops--;
+       } while (!random_map_free(td, f, rb) && loops);
+
+       /*
+        * if we failed to retrieve a truly random offset within
+        * the loops assigned, see if there are free ones left at all
+        */
+       if (!loops && get_next_free_block(td, f, b))
+               return 1;
+
+       return 0;
+}
+
 /*
  * For random io, generate a random new block and see if it's used. Repeat
  * until we find a free one. For sequential io, just return the end of
@@ -102,30 +135,12 @@ static int get_next_offset(struct thread_data *td, struct io_u *io_u)
 {
        struct fio_file *f = io_u->file;
        const int ddir = io_u->ddir;
-       unsigned long long b, rb;
-       long r;
+       unsigned long long b;
 
-       if (td_random(td)) {
-               unsigned long long max_blocks = f->file_size / td->o.min_bs[ddir];
-               int loops = 5;
-
-               do {
-                       r = os_random_long(&td->random_state);
-                       if (!max_blocks)
-                               b = 0;
-                       else
-                               b = ((max_blocks - 1) * r / (unsigned long long) (RAND_MAX+1.0));
-                       if (td->o.norandommap)
-                               break;
-                       rb = b + (f->file_offset / td->o.min_bs[ddir]);
-                       loops--;
-               } while (!random_map_free(td, f, rb) && loops);
+       if (td_random(td) && (td->o.ddir_nr && !--td->ddir_nr)) {
+               td->ddir_nr = td->o.ddir_nr;
 
-               /*
-                * if we failed to retrieve a truly random offset within
-                * the loops assigned, see if there are free ones left at all
-                */
-               if (!loops && get_next_free_block(td, f, &b))
+               if (get_next_rand_offset(td, f, ddir, &b))
                        return 1;
        } else
                b = f->last_pos / td->o.min_bs[ddir];
@@ -651,7 +666,7 @@ static void io_completed(struct thread_data *td, struct io_u *io_u,
                icd->bytes_done[idx] += bytes;
 
                if (io_u->end_io) {
-                       ret = io_u->end_io(io_u);
+                       ret = io_u->end_io(td, io_u);
                        if (ret && !icd->error)
                                icd->error = ret;
                }