helper_thread: Initialize all helper_data members before using it

[fio.git] / helper_thread.c

diff --git a/helper_thread.c b/helper_thread.c
index 47ec728cfa31d25f68742af81178bb95f3e5f928..b05f8212a6210e4cd9f00f6147759e3e5418249a 100644 (file)
--- a/helper_thread.c
+++ b/helper_thread.c
@@ -71,45 +71,45 @@ static void *helper_thread_main(void *data)
 {
        struct helper_data *hd = data;
        unsigned int msec_to_next_event, next_log, next_ss = STEADYSTATE_MSEC;
-       struct timeval tv, last_du, last_ss;
+       struct timeval tv;
+       struct timespec ts, last_du, last_ss;
        int ret = 0;
 
        sk_out_assign(hd->sk_out);
 
        gettimeofday(&tv, NULL);
-       memcpy(&last_du, &tv, sizeof(tv));
-       memcpy(&last_ss, &tv, sizeof(tv));
+       ts.tv_sec = tv.tv_sec;
+       ts.tv_nsec = tv.tv_usec * 1000;
+       memcpy(&last_du, &ts, sizeof(ts));
+       memcpy(&last_ss, &ts, sizeof(ts));
 
        fio_mutex_up(hd->startup_mutex);
 
        msec_to_next_event = DISK_UTIL_MSEC;
        while (!ret && !hd->exit) {
-               struct timespec ts;
-               struct timeval now;
                uint64_t since_du, since_ss = 0;
 
-               timeval_add_msec(&tv, msec_to_next_event);
-               ts.tv_sec = tv.tv_sec;
-               ts.tv_nsec = tv.tv_usec * 1000;
+               timespec_add_msec(&ts, msec_to_next_event);
 
                pthread_mutex_lock(&hd->lock);
                pthread_cond_timedwait(&hd->cond, &hd->lock, &ts);
 
-               gettimeofday(&now, NULL);
+               gettimeofday(&tv, NULL);
+               ts.tv_sec = tv.tv_sec;
+               ts.tv_nsec = tv.tv_usec * 1000;
 
                if (hd->reset) {
-                       memcpy(&tv, &now, sizeof(tv));
-                       memcpy(&last_du, &now, sizeof(last_du));
-                       memcpy(&last_ss, &now, sizeof(last_ss));
+                       memcpy(&last_du, &ts, sizeof(ts));
+                       memcpy(&last_ss, &ts, sizeof(ts));
                        hd->reset = 0;
                }
 
                pthread_mutex_unlock(&hd->lock);
 
-               since_du = mtime_since(&last_du, &now);
+               since_du = mtime_since(&last_du, &ts);
                if (since_du >= DISK_UTIL_MSEC || DISK_UTIL_MSEC - since_du < 10) {
                        ret = update_io_ticks();
-                       timeval_add_msec(&last_du, DISK_UTIL_MSEC);
+                       timespec_add_msec(&last_du, DISK_UTIL_MSEC);
                        msec_to_next_event = DISK_UTIL_MSEC;
                        if (since_du >= DISK_UTIL_MSEC)
                                msec_to_next_event -= (since_du - DISK_UTIL_MSEC);
@@ -126,16 +126,15 @@ static void *helper_thread_main(void *data)
                        next_log = DISK_UTIL_MSEC;
 
                if (steadystate_enabled) {
-                       since_ss = mtime_since(&last_ss, &now);
+                       since_ss = mtime_since(&last_ss, &ts);
                        if (since_ss >= STEADYSTATE_MSEC || STEADYSTATE_MSEC - since_ss < 10) {
                                steadystate_check();
-                               timeval_add_msec(&last_ss, since_ss);
+                               timespec_add_msec(&last_ss, since_ss);
                                if (since_ss > STEADYSTATE_MSEC)
                                        next_ss = STEADYSTATE_MSEC - (since_ss - STEADYSTATE_MSEC);
                                else
                                        next_ss = STEADYSTATE_MSEC;
-                       }
-                       else
+                       } else
                                next_ss = STEADYSTATE_MSEC - since_ss;
                 }
 
@@ -157,7 +156,7 @@ int helper_thread_create(struct fio_mutex *startup_mutex, struct sk_out *sk_out)
        struct helper_data *hd;
        int ret;
 
-       hd = smalloc(sizeof(*hd));
+       hd = scalloc(1, sizeof(*hd));
 
        setup_disk_util();
        steadystate_setup();