Fix crash with multiple files

[fio.git] / fio.c

diff --git a/fio.c b/fio.c
index 08011c94b82480bf7a875b4a3d193733e8e954cd..ad2282d7516fe7fc0033b3bc721a12b16d370fe1 100644 (file)
--- a/fio.c
+++ b/fio.c
@@ -55,6 +55,7 @@ static struct fio_mutex *startup_mutex;
 static volatile int fio_abort;
 static int exit_value;
 static struct itimerval itimer;
 static volatile int fio_abort;
 static int exit_value;
 static struct itimerval itimer;

+static pthread_t gtod_thread;

 
 struct io_log *agg_io_log[2];
 
 
 struct io_log *agg_io_log[2];
 


@@ -116,6 +117,13 @@ static void sig_alrm(int fio_unused sig)
        }
 }
 
        }
 }
 

+/*
+ * Happens on thread runs with ctrl-c, ignore our own SIGQUIT
+ */
+static void sig_quit(int sig)
+{
+}
+

 static void sig_int(int sig)
 {
        if (threads) {
 static void sig_int(int sig)
 {
        if (threads) {


@@ -154,17 +162,24 @@ static void set_sig_handlers(void)
        act.sa_handler = sig_ill;
        act.sa_flags = SA_RESTART;
        sigaction(SIGILL, &act, NULL);
        act.sa_handler = sig_ill;
        act.sa_flags = SA_RESTART;
        sigaction(SIGILL, &act, NULL);

+
+       memset(&act, 0, sizeof(act));
+       act.sa_handler = sig_quit;
+       act.sa_flags = SA_RESTART;
+       sigaction(SIGQUIT, &act, NULL);

 }
 
 static inline int should_check_rate(struct thread_data *td)
 {
 }
 
 static inline int should_check_rate(struct thread_data *td)
 {

+       struct thread_options *o = &td->o;
+

        /*
        /*

-        * No minimum rate set, always ok
+        * If some rate setting was given, we need to check it

         */
         */

-       if (!td->o.ratemin && !td->o.rate_iops_min)
-               return 0;
+       if (o->rate || o->ratemin || o->rate_iops || o->rate_iops_min)
+               return 1;

 
 

-       return 1;
+       return 0;

 }
 
 /*
 }
 
 /*


@@ -660,7 +675,7 @@ sync_done:
                                int left;
 
                                if (td->o.thinktime_spin)
                                int left;
 
                                if (td->o.thinktime_spin)

-                                       __usec_sleep(td->o.thinktime_spin);
+                                       usec_spin(td->o.thinktime_spin);

 
                                left = td->o.thinktime - td->o.thinktime_spin;
                                if (left)
 
                                left = td->o.thinktime - td->o.thinktime_spin;
                                if (left)


@@ -861,6 +876,11 @@ static void reset_io_counters(struct thread_data *td)
         */
        if (td->o.time_based || td->o.loops)
                td->nr_done_files = 0;
         */
        if (td->o.time_based || td->o.loops)
                td->nr_done_files = 0;

+
+       /*
+        * Set the same seed to get repeatable runs
+        */
+       td_fill_rand_seeds(td);

 }
 
 void reset_all_stats(struct thread_data *td)
 }
 
 void reset_all_stats(struct thread_data *td)


@@ -882,25 +902,16 @@ void reset_all_stats(struct thread_data *td)
        memcpy(&td->start, &tv, sizeof(tv));
 }
 
        memcpy(&td->start, &tv, sizeof(tv));
 }
 

-static int clear_io_state(struct thread_data *td)
+static void clear_io_state(struct thread_data *td)

 {
        struct fio_file *f;
        unsigned int i;
 {
        struct fio_file *f;
        unsigned int i;

-       int ret;

 
        reset_io_counters(td);
 
        close_files(td);
 
        reset_io_counters(td);
 
        close_files(td);

-
-       ret = 0;
-       for_each_file(td, f, i) {
+       for_each_file(td, f, i)

                f->flags &= ~FIO_FILE_DONE;
                f->flags &= ~FIO_FILE_DONE;

-               ret = td_io_open_file(td, f);
-               if (ret)
-                       break;
-       }
-
-       return ret;

 }
 
 /*
 }
 
 /*


@@ -928,8 +939,11 @@ static void *thread_main(void *data)
        td->io_hist_tree = RB_ROOT;
 
        td_set_runstate(td, TD_INITIALIZED);
        td->io_hist_tree = RB_ROOT;
 
        td_set_runstate(td, TD_INITIALIZED);

+       dprint(FD_MUTEX, "up startup_mutex\n");

        fio_mutex_up(startup_mutex);
        fio_mutex_up(startup_mutex);

+       dprint(FD_MUTEX, "wait on td->mutex\n");

        fio_mutex_down(td->mutex);
        fio_mutex_down(td->mutex);

+       dprint(FD_MUTEX, "done waiting on td->mutex\n");

 
        /*
         * the ->mutex mutex is now no longer used, close it to avoid
 
        /*
         * the ->mutex mutex is now no longer used, close it to avoid


@@ -952,6 +966,18 @@ static void *thread_main(void *data)
                goto err;
        }
 
                goto err;
        }
 

+       /*
+        * If we have a gettimeofday() thread, make sure we exclude that
+        * thread from this job
+        */
+       if (td->o.gtod_cpu) {
+               fio_cpu_clear(&td->o.cpumask, td->o.gtod_cpu);
+               if (fio_setaffinity(td) == -1) {
+                       td_verror(td, errno, "cpu_set_affinity");
+                       goto err;
+               }
+       }
+

        if (td->ioprio_set) {
                if (ioprio_set(IOPRIO_WHO_PROCESS, 0, td->ioprio) == -1) {
                        td_verror(td, errno, "ioprio_set");
        if (td->ioprio_set) {
                if (ioprio_set(IOPRIO_WHO_PROCESS, 0, td->ioprio) == -1) {
                        td_verror(td, errno, "ioprio_set");


@@ -973,9 +999,6 @@ static void *thread_main(void *data)
        if (td_io_init(td))
                goto err;
 
        if (td_io_init(td))
                goto err;
 

-       if (open_files(td))
-               goto err;
-

        if (init_random_map(td))
                goto err;
 
        if (init_random_map(td))
                goto err;
 


@@ -998,8 +1021,8 @@ static void *thread_main(void *data)
                        memcpy(&td->lastrate, &td->ts.stat_sample_time,
                                                        sizeof(td->lastrate));
 
                        memcpy(&td->lastrate, &td->ts.stat_sample_time,
                                                        sizeof(td->lastrate));
 

-               if (clear_state && clear_io_state(td))
-                       break;
+               if (clear_state)
+                       clear_io_state(td);

 
                prune_io_piece_log(td);
 
 
                prune_io_piece_log(td);
 


@@ -1034,8 +1057,7 @@ static void *thread_main(void *data)
                    (td->io_ops->flags & FIO_UNIDIR))
                        continue;
 
                    (td->io_ops->flags & FIO_UNIDIR))
                        continue;
 

-               if (clear_io_state(td))
-                       break;
+               clear_io_state(td);

 
                fio_gettime(&td->start, NULL);
 
 
                fio_gettime(&td->start, NULL);
 


@@ -1054,12 +1076,27 @@ static void *thread_main(void *data)
        td->ts.io_bytes[0] = td->io_bytes[0];
        td->ts.io_bytes[1] = td->io_bytes[1];
 
        td->ts.io_bytes[0] = td->io_bytes[0];
        td->ts.io_bytes[1] = td->io_bytes[1];
 

-       if (td->ts.bw_log)
-               finish_log(td, td->ts.bw_log, "bw");
-       if (td->ts.slat_log)
-               finish_log(td, td->ts.slat_log, "slat");
-       if (td->ts.clat_log)
-               finish_log(td, td->ts.clat_log, "clat");
+       if (td->ts.bw_log) {
+               if (td->o.bw_log_file) {
+                       finish_log_named(td, td->ts.bw_log,
+                                               td->o.bw_log_file, "bw");
+               } else
+                       finish_log(td, td->ts.bw_log, "bw");
+       }
+       if (td->ts.slat_log) {
+               if (td->o.lat_log_file) {
+                       finish_log_named(td, td->ts.slat_log,
+                                               td->o.lat_log_file, "clat");
+               } else
+                       finish_log(td, td->ts.slat_log, "slat");
+       }
+       if (td->ts.clat_log) {
+               if (td->o.lat_log_file) {
+                       finish_log_named(td, td->ts.clat_log,
+                                               td->o.lat_log_file, "clat");
+               } else
+                       finish_log(td, td->ts.clat_log, "clat");
+       }

        if (td->o.exec_postrun) {
                if (system(td->o.exec_postrun) < 0)
                        log_err("fio: postrun %s failed\n", td->o.exec_postrun);
        if (td->o.exec_postrun) {
                if (system(td->o.exec_postrun) < 0)
                        log_err("fio: postrun %s failed\n", td->o.exec_postrun);


@@ -1076,6 +1113,12 @@ err:
        close_ioengine(td);
        cleanup_io_u(td);
 
        close_ioengine(td);
        cleanup_io_u(td);
 

+       if (td->o.cpumask_set) {
+               int ret = fio_cpuset_exit(&td->o.cpumask);
+
+               td_verror(td, ret, "fio_cpuset_exit");
+       }
+

        /*
         * do this very late, it will log file closing as well
         */
        /*
         * do this very late, it will log file closing as well
         */


@@ -1205,6 +1248,46 @@ reaped:
                terminate_threads(TERMINATE_ALL);
 }
 
                terminate_threads(TERMINATE_ALL);
 }
 

+static void *gtod_thread_main(void *data)
+{
+       fio_mutex_up(startup_mutex);
+
+       /*
+        * As long as we have jobs around, update the clock. It would be nice
+        * to have some way of NOT hammering that CPU with gettimeofday(),
+        * but I'm not sure what to use outside of a simple CPU nop to relax
+        * it - we don't want to lose precision.
+        */
+       while (threads) {
+               fio_gtod_update();
+               nop;
+       }
+
+       return NULL;
+}
+
+static int fio_start_gtod_thread(void)
+{
+       int ret;
+
+       ret = pthread_create(&gtod_thread, NULL, gtod_thread_main, NULL);
+       if (ret) {
+               log_err("Can't create gtod thread: %s\n", strerror(ret));
+               return 1;
+       }
+
+       ret = pthread_detach(gtod_thread);
+       if (ret) {
+               log_err("Can't detatch gtod thread: %s\n", strerror(ret));
+               return 1;
+       }
+
+       dprint(FD_MUTEX, "wait on startup_mutex\n");
+       fio_mutex_down(startup_mutex);
+       dprint(FD_MUTEX, "done waiting on startup_mutex\n");
+       return 0;
+}
+

 /*
  * Main function for kicking off and reaping jobs, as needed.
  */
 /*
  * Main function for kicking off and reaping jobs, as needed.
  */


@@ -1217,6 +1300,9 @@ static void run_threads(void)
        if (fio_pin_memory())
                return;
 
        if (fio_pin_memory())
                return;
 

+       if (fio_gtod_offload && fio_start_gtod_thread())
+               return;
+

        if (!terse_output) {
                printf("Starting ");
                if (nr_thread)
        if (!terse_output) {
                printf("Starting ");
                if (nr_thread)


@@ -1320,15 +1406,21 @@ static void run_threads(void)
                        nr_started++;
 
                        if (td->o.use_thread) {
                        nr_started++;
 
                        if (td->o.use_thread) {

+                               int ret;
+

                                dprint(FD_PROCESS, "will pthread_create\n");
                                dprint(FD_PROCESS, "will pthread_create\n");

-                               if (pthread_create(&td->thread, NULL,
-                                                  thread_main, td)) {
-                                       perror("pthread_create");
+                               ret = pthread_create(&td->thread, NULL,
+                                                       thread_main, td);
+                               if (ret) {
+                                       log_err("pthread_create: %s\n",
+                                                       strerror(ret));

                                        nr_started--;
                                        break;
                                }
                                        nr_started--;
                                        break;
                                }

-                               if (pthread_detach(td->thread) < 0)
-                                       perror("pthread_detach");
+                               ret = pthread_detach(td->thread);
+                               if (ret)
+                                       log_err("pthread_detach: %s",
+                                                       strerror(ret));

                        } else {
                                pid_t pid;
                                dprint(FD_PROCESS, "will fork\n");
                        } else {
                                pid_t pid;
                                dprint(FD_PROCESS, "will fork\n");


@@ -1340,7 +1432,9 @@ static void run_threads(void)
                                } else if (i == fio_debug_jobno)
                                        *fio_debug_jobp = pid;
                        }
                                } else if (i == fio_debug_jobno)
                                        *fio_debug_jobp = pid;
                        }

+                       dprint(FD_MUTEX, "wait on startup_mutex\n");

                        fio_mutex_down(startup_mutex);
                        fio_mutex_down(startup_mutex);

+                       dprint(FD_MUTEX, "done waiting on startup_mutex\n");

                }
 
                /*
                }
 
                /*