Fixup and improve per-thread data

[fio.git] / backend.c

diff --git a/backend.c b/backend.c
index d39968519fe3680a8ab0fe87716087eb61ad1d6e..c9875f480c726ec814ed916d02491a4dce442faf 100644 (file)
--- a/backend.c
+++ b/backend.c
@@ -974,7 +974,7 @@ reap:
 
                if (!in_ramp_time(td) && should_check_rate(td)) {
                        if (check_min_rate(td, &comp_time)) {
-                               if (exitall_on_terminate)
+                               if (exitall_on_terminate || td->o.exitall_error)
                                        fio_terminate_threads(td->groupid);
                                td_verror(td, EIO, "check_min_rate");
                                break;
@@ -1358,19 +1358,29 @@ static uint64_t do_dry_run(struct thread_data *td)
        return td->bytes_done[DDIR_WRITE] + td->bytes_done[DDIR_TRIM];
 }
 
+struct fork_data {
+       struct thread_data *td;
+       struct sk_out *sk_out;
+};
+
 /*
  * Entry point for the thread based jobs. The process based jobs end up
  * here as well, after a little setup.
  */
 static void *thread_main(void *data)
 {
+       struct fork_data *fd = data;
        unsigned long long elapsed_us[DDIR_RWDIR_CNT] = { 0, };
-       struct thread_data *td = data;
+       struct thread_data *td = fd->td;
        struct thread_options *o = &td->o;
+       struct sk_out *sk_out = fd->sk_out;
        pthread_condattr_t attr;
        int clear_state;
        int ret;
 
+       sk_out_assign(sk_out);
+       free(fd);
+
        if (!o->use_thread) {
                setsid();
                td->pid = getpid();
@@ -1550,13 +1560,12 @@ static void *thread_main(void *data)
                        goto err;
        }
 
-       if (iolog_compress_init(td))
+       if (iolog_compress_init(td, sk_out))
                goto err;
 
        fio_verify_init(td);
 
-       if ((o->io_submit_mode == IO_MODE_OFFLOAD) &&
-           workqueue_init(td, &td->io_wq, &rated_wq_ops, td->o.iodepth))
+       if (rate_submit_init(td, sk_out))
                goto err;
 
        fio_gettime(&td->epoch, NULL);
@@ -1588,8 +1597,11 @@ static void *thread_main(void *data)
 
                if (td->o.verify_only && (td_write(td) || td_rw(td)))
                        verify_bytes = do_dry_run(td);
-               else
+               else {
                        verify_bytes = do_io(td);
+                       if (!verify_bytes)
+                               fio_mark_td_terminate(td);
+               }
 
                clear_state = 1;
 
@@ -1654,15 +1666,13 @@ static void *thread_main(void *data)
 
        fio_writeout_logs(td);
 
-       if (o->io_submit_mode == IO_MODE_OFFLOAD)
-               workqueue_exit(&td->io_wq);
-
        iolog_compress_exit(td);
+       rate_submit_exit(td);
 
        if (o->exec_postrun)
                exec_string(o, o->exec_postrun, (const char *)"postrun");
 
-       if (exitall_on_terminate)
+       if (exitall_on_terminate || (o->exitall_error && td->error))
                fio_terminate_threads(td->groupid);
 
 err:
@@ -1702,6 +1712,7 @@ err:
         */
        check_update_rusage(td);
 
+       sk_out_drop();
        return (void *) (uintptr_t) td->error;
 }
 
@@ -1710,9 +1721,9 @@ err:
  * We cannot pass the td data into a forked process, so attach the td and
  * pass it to the thread worker.
  */
-static int fork_main(int shmid, int offset)
+static int fork_main(struct sk_out *sk_out, int shmid, int offset)
 {
-       struct thread_data *td;
+       struct fork_data *fd;
        void *data, *ret;
 
 #if !defined(__hpux) && !defined(CONFIG_NO_SHM)
@@ -1730,8 +1741,10 @@ static int fork_main(int shmid, int offset)
        data = threads;
 #endif
 
-       td = data + offset * sizeof(struct thread_data);
-       ret = thread_main(td);
+       fd = calloc(1, sizeof(*fd));
+       fd->td = data + offset * sizeof(struct thread_data);
+       fd->sk_out = sk_out;
+       ret = thread_main(fd);
        shmdt(data);
        return (int) (uintptr_t) ret;
 }
@@ -1956,7 +1969,7 @@ mounted:
 /*
  * Main function for kicking off and reaping jobs, as needed.
  */
-static void run_threads(void)
+static void run_threads(struct sk_out *sk_out)
 {
        struct thread_data *td;
        unsigned int i, todo, nr_running, m_rate, t_rate, nr_started;
@@ -2090,14 +2103,20 @@ reap:
                        nr_started++;
 
                        if (td->o.use_thread) {
+                               struct fork_data *fd;
                                int ret;
 
+                               fd = calloc(1, sizeof(*fd));
+                               fd->td = td;
+                               fd->sk_out = sk_out;
+
                                dprint(FD_PROCESS, "will pthread_create\n");
                                ret = pthread_create(&td->thread, NULL,
-                                                       thread_main, td);
+                                                       thread_main, fd);
                                if (ret) {
                                        log_err("pthread_create: %s\n",
                                                        strerror(ret));
+                                       free(fd);
                                        nr_started--;
                                        break;
                                }
@@ -2110,14 +2129,14 @@ reap:
                                dprint(FD_PROCESS, "will fork\n");
                                pid = fork();
                                if (!pid) {
-                                       int ret = fork_main(shm_id, i);
+                                       int ret = fork_main(sk_out, shm_id, i);
 
                                        _exit(ret);
                                } else if (i == fio_debug_jobno)
                                        *fio_debug_jobp = pid;
                        }
                        dprint(FD_MUTEX, "wait on startup_mutex\n");
-                       if (fio_mutex_down_timeout(startup_mutex, 10)) {
+                       if (fio_mutex_down_timeout(startup_mutex, 10000)) {
                                log_err("fio: job startup hung? exiting.\n");
                                fio_terminate_threads(TERMINATE_ALL);
                                fio_abort = 1;
@@ -2220,8 +2239,11 @@ static void free_disk_util(void)
 
 static void *helper_thread_main(void *data)
 {
+       struct sk_out *sk_out = data;
        int ret = 0;
 
+       sk_out_assign(sk_out);
+
        fio_mutex_up(startup_mutex);
 
        while (!ret) {
@@ -2252,10 +2274,11 @@ static void *helper_thread_main(void *data)
                        print_thread_status();
        }
 
+       sk_out_drop();
        return NULL;
 }
 
-static int create_helper_thread(void)
+static int create_helper_thread(struct sk_out *sk_out)
 {
        int ret;
 
@@ -2264,7 +2287,7 @@ static int create_helper_thread(void)
        pthread_cond_init(&helper_cond, NULL);
        pthread_mutex_init(&helper_lock, NULL);
 
-       ret = pthread_create(&helper_thread, NULL, helper_thread_main, NULL);
+       ret = pthread_create(&helper_thread, NULL, helper_thread_main, sk_out);
        if (ret) {
                log_err("Can't create helper thread: %s\n", strerror(ret));
                return 1;
@@ -2276,7 +2299,7 @@ static int create_helper_thread(void)
        return 0;
 }
 
-int fio_backend(void)
+int fio_backend(struct sk_out *sk_out)
 {
        struct thread_data *td;
        int i;
@@ -2306,12 +2329,12 @@ int fio_backend(void)
 
        set_genesis_time();
        stat_init();
-       create_helper_thread();
+       create_helper_thread(sk_out);
 
        cgroup_list = smalloc(sizeof(*cgroup_list));
        INIT_FLIST_HEAD(cgroup_list);
 
-       run_threads();
+       run_threads(sk_out);
 
        wait_for_helper_thread_exit();