backend: ensure that we run verification for short time based jobs

[fio.git] / backend.c

diff --git a/backend.c b/backend.c
index c9875f480c726ec814ed916d02491a4dce442faf..e093f75d5988d003901c30804595c8d7f5b6e9d3 100644 (file)
--- a/backend.c
+++ b/backend.c
@@ -309,6 +309,8 @@ requeue:
                put_io_u(td, io_u);
                return true;
        } else if (ret == FIO_Q_QUEUED) {
+               if (td_io_commit(td))
+                       return true;
                if (io_u_queued_complete(td, 1) < 0)
                        return true;
        } else if (ret == FIO_Q_COMPLETED) {
@@ -520,6 +522,14 @@ sync_done:
                        if (*ret < 0)
                                break;
                }
+
+               /*
+                * when doing I/O (not when verifying),
+                * check for any errors that are to be ignored
+                */
+               if (!from_verify)
+                       break;
+
                return 0;
        case FIO_Q_QUEUED:
                /*
@@ -808,12 +818,15 @@ static long long usec_for_io(struct thread_data *td, enum fio_ddir ddir)
  *
  * Returns number of bytes written and trimmed.
  */
-static uint64_t do_io(struct thread_data *td)
+static void do_io(struct thread_data *td, uint64_t *bytes_done)
 {
        unsigned int i;
        int ret = 0;
        uint64_t total_bytes, bytes_issued = 0;
 
+       for (i = 0; i < DDIR_RWDIR_CNT; i++)
+               bytes_done[i] = td->bytes_done[i];
+
        if (in_ramp_time(td))
                td_set_runstate(td, TD_RAMP);
        else
@@ -868,7 +881,14 @@ static uint64_t do_io(struct thread_data *td)
                if (flow_threshold_exceeded(td))
                        continue;
 
-               if (!td->o.time_based && bytes_issued >= total_bytes)
+               /*
+                * Break if we exceeded the bytes. The exception is time
+                * based runs, but we still need to break out of the loop
+                * for those to run verification, if enabled.
+                */
+               if (bytes_issued >= total_bytes &&
+                   (!td->o.time_based ||
+                    (td->o.time_based && td->o.verify != VERIFY_NONE)))
                        break;
 
                io_u = get_io_u(td);
@@ -1046,7 +1066,8 @@ reap:
        if (!ddir_rw_sum(td->this_io_bytes))
                td->done = 1;
 
-       return td->bytes_done[DDIR_WRITE] + td->bytes_done[DDIR_TRIM];
+       for (i = 0; i < DDIR_RWDIR_CNT; i++)
+               bytes_done[i] = td->bytes_done[i] - bytes_done[i];
 }
 
 static void cleanup_io_u(struct thread_data *td)
@@ -1289,7 +1310,7 @@ static bool keep_running(struct thread_data *td)
                if (diff < td_max_bs(td))
                        return false;
 
-               if (fio_files_done(td))
+               if (fio_files_done(td) && !td->o.io_limit)
                        return false;
 
                return true;
@@ -1598,9 +1619,17 @@ static void *thread_main(void *data)
                if (td->o.verify_only && (td_write(td) || td_rw(td)))
                        verify_bytes = do_dry_run(td);
                else {
-                       verify_bytes = do_io(td);
-                       if (!verify_bytes)
+                       uint64_t bytes_done[DDIR_RWDIR_CNT];
+
+                       do_io(td, bytes_done);
+
+                       if (!ddir_rw_sum(bytes_done)) {
                                fio_mark_td_terminate(td);
+                               verify_bytes = 0;
+                       } else {
+                               verify_bytes = bytes_done[DDIR_WRITE] +
+                                               bytes_done[DDIR_TRIM];
+                       }
                }
 
                clear_state = 1;
@@ -1689,6 +1718,15 @@ err:
        cgroup_shutdown(td, &cgroup_mnt);
        verify_free_state(td);
 
+       if (td->zone_state_index) {
+               int i;
+
+               for (i = 0; i < DDIR_RWDIR_CNT; i++)
+                       free(td->zone_state_index[i]);
+               free(td->zone_state_index);
+               td->zone_state_index = NULL;
+       }
+
        if (fio_option_is_set(o, cpumask)) {
                ret = fio_cpuset_exit(&o->cpumask);
                if (ret)
@@ -1966,6 +2004,32 @@ mounted:
        return true;
 }
 
+static bool waitee_running(struct thread_data *me)
+{
+       const char *waitee = me->o.wait_for;
+       const char *self = me->o.name;
+       struct thread_data *td;
+       int i;
+
+       if (!waitee)
+               return false;
+
+       for_each_td(td, i) {
+               if (!strcmp(td->o.name, self) || strcmp(td->o.name, waitee))
+                       continue;
+
+               if (td->runstate < TD_EXITED) {
+                       dprint(FD_PROCESS, "%s fenced by %s(%s)\n",
+                                       self, td->o.name,
+                                       runstate_to_name(td->runstate));
+                       return true;
+               }
+       }
+
+       dprint(FD_PROCESS, "%s: %s completed, can run\n", self, waitee);
+       return false;
+}
+
 /*
  * Main function for kicking off and reaping jobs, as needed.
  */
@@ -2089,6 +2153,12 @@ reap:
                                break;
                        }
 
+                       if (waitee_running(td)) {
+                               dprint(FD_PROCESS, "%s: waiting for %s\n",
+                                               td->o.name, td->o.wait_for);
+                               continue;
+                       }
+
                        init_disk_util(td);
 
                        td->rusage_sem = fio_mutex_init(FIO_MUTEX_LOCKED);