Properly initialize all atomic variables

diff --git a/lib/isc/counter.c b/lib/isc/counter.c
index d0a16c5278600c205fd45f47b3f58edef0d7c223..bd54c0d6292a3c6bab62866ecba603d18647d362 100644 (file)
--- a/lib/isc/counter.c
+++ b/lib/isc/counter.c
@@ -44,9 +44,9 @@ isc_counter_create(isc_mem_t *mctx, int limit, isc_counter_t **counterp) {
        counter->mctx = NULL;
        isc_mem_attach(mctx, &counter->mctx);
 
-       atomic_store(&counter->references, 1);
-       atomic_store(&counter->limit, limit);
-       atomic_store(&counter->used, 0);
+       atomic_init(&counter->references, 1);
+       atomic_init(&counter->limit, limit);
+       atomic_init(&counter->used, 0);
 
        counter->magic = COUNTER_MAGIC;
        *counterp = counter;

diff --git a/lib/isc/stats.c b/lib/isc/stats.c
index 123c6dff97def8926ad33e796c90f0281ef16d43..d41e7aa95f910ec7ba431b75743bd44e38661dda 100644 (file)
--- a/lib/isc/stats.c
+++ b/lib/isc/stats.c
@@ -45,13 +45,16 @@ struct isc_stats {
 static isc_result_t
 create_stats(isc_mem_t *mctx, int ncounters, isc_stats_t **statsp) {
        isc_stats_t *stats;
+       int i;
 
        REQUIRE(statsp != NULL && *statsp == NULL);
 
        stats = isc_mem_get(mctx, sizeof(*stats));
        stats->counters = isc_mem_get(mctx, sizeof(isc_stat_t) * ncounters);
        isc_refcount_init(&stats->refs, 1);
-       memset(stats->counters, 0, sizeof(isc_stat_t) * ncounters);
+       for (i = 0; i < ncounters; i++) {
+               atomic_init(&stats->counters[i], 0);
+       }
        stats->mctx = NULL;
        isc_mem_attach(mctx, &stats->mctx);
        stats->ncounters = ncounters;

diff --git a/lib/isc/task.c b/lib/isc/task.c
index d3413db2e9cd8f786986cf8dc079cfb10864f1ab..bda2c3428276f9557b11cd4db30965cafdda4552 100644 (file)
--- a/lib/isc/task.c
+++ b/lib/isc/task.c
@@ -1243,7 +1243,7 @@ dispatch(isc__taskmgr_t *manager, unsigned int threadid) {
                 * we're stuck.  Automatically drop privileges at that
                 * point and continue with the regular ready queue.
                 */
-               if (manager->mode != isc_taskmgrmode_normal &&
+               if (atomic_load_relaxed(&manager->mode) != isc_taskmgrmode_normal &&
                    atomic_load_explicit(&manager->tasks_running,
                                         memory_order_acquire) == 0)
                {
@@ -1256,7 +1256,7 @@ dispatch(isc__taskmgr_t *manager, unsigned int threadid) {
                         * we'll end up in a deadlock over queue locks.
                         *
                         */
-                       if (manager->mode != isc_taskmgrmode_normal &&
+                       if (atomic_load_relaxed(&manager->mode) != isc_taskmgrmode_normal &&
                            atomic_load_explicit(&manager->tasks_running,
                                                 memory_order_acquire) == 0)
                        {
@@ -1341,7 +1341,7 @@ isc_taskmgr_create(isc_mem_t *mctx, unsigned int workers,
        RUNTIME_CHECK(manager != NULL);
        manager->common.impmagic = TASK_MANAGER_MAGIC;
        manager->common.magic = ISCAPI_TASKMGR_MAGIC;
-       atomic_store(&manager->mode, isc_taskmgrmode_normal);
+       atomic_init(&manager->mode, isc_taskmgrmode_normal);
        manager->mctx = NULL;
        isc_mutex_init(&manager->lock);
        isc_mutex_init(&manager->excl_lock);
@@ -1356,18 +1356,18 @@ isc_taskmgr_create(isc_mem_t *mctx, unsigned int workers,
        }
        manager->default_quantum = default_quantum;
        INIT_LIST(manager->tasks);
-       atomic_store(&manager->tasks_count, 0);
+       atomic_init(&manager->tasks_count, 0);
        manager->queues = isc_mem_get(mctx, workers * sizeof(isc__taskqueue_t));
        RUNTIME_CHECK(manager->queues != NULL);
 
-       manager->tasks_running = 0;
-       manager->tasks_ready = 0;
-       manager->curq = 0;
-       manager->exiting = false;
+       atomic_init(&manager->tasks_running, 0);
+       atomic_init(&manager->tasks_ready, 0);
+       atomic_init(&manager->curq, 0);
+       atomic_init(&manager->exiting, false);
        manager->excl = NULL;
        manager->halted = 0;
-       atomic_store_relaxed(&manager->exclusive_req, false);
-       atomic_store_relaxed(&manager->pause_req, false);
+       atomic_init(&manager->exclusive_req, false);
+       atomic_init(&manager->pause_req, false);
 
        isc_mem_attach(mctx, &manager->mctx);
 
@@ -1529,8 +1529,8 @@ void
 isc__taskmgr_resume(isc_taskmgr_t *manager0) {
        isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
        LOCK(&manager->halt_lock);
-       if (manager->pause_req) {
-               manager->pause_req = false;
+       if (atomic_load_relaxed(&manager->pause_req)) {
+               atomic_store_relaxed(&manager->pause_req, false);
                while (manager->halted > 0) {
                        BROADCAST(&manager->halt_cond);
                        WAIT(&manager->halt_cond, &manager->halt_lock);

diff --git a/lib/ns/query.c b/lib/ns/query.c
index 9c8086cfc9f640b287247dc6f68177947b601e15..abb88fbe3359634ffcbe88ce0e7ed706e73de3cf 100644 (file)
--- a/lib/ns/query.c
+++ b/lib/ns/query.c
@@ -25,6 +25,7 @@
 #include <isc/string.h>
 #include <isc/thread.h>
 #include <isc/util.h>
+#include <isc/once.h>
 
 #include <dns/adb.h>
 #include <dns/badcache.h>
@@ -5738,7 +5739,12 @@ ns_query_recurse(ns_client_t *client, dns_rdatatype_t qtype, dns_name_t *qname,
                }
 
                if  (result == ISC_R_SOFTQUOTA) {
-                       static atomic_uint_fast32_t last = 0;
+                       static atomic_uint_fast32_t last;
+                       static isc_once_t once = ISC_ONCE_INIT;
+                       void __ain() {
+                               atomic_init(&last, 0);
+                       }
+                       isc_once_do(&once, __ain);
                        isc_stdtime_t now;
                        isc_stdtime_get(&now);
                        if (now != atomic_load_relaxed(&last)) {
@@ -5755,7 +5761,12 @@ ns_query_recurse(ns_client_t *client, dns_rdatatype_t qtype, dns_name_t *qname,
                        ns_client_killoldestquery(client);
                        result = ISC_R_SUCCESS;
                } else if (result == ISC_R_QUOTA) {
-                       static atomic_uint_fast32_t last = 0;
+                       static atomic_uint_fast32_t last;
+                       static isc_once_t once = ISC_ONCE_INIT;
+                       void __ain() {
+                               atomic_init(&last, 0);
+                       }
+                       isc_once_do(&once, __ain);
                        isc_stdtime_t now;
                        isc_stdtime_get(&now);
                        if (now != atomic_load_relaxed(&last)) {