Blame SOURCES/0000-Ticket-49305-Need-to-wrap-atomic-calls.patch

96373c
From f19dec383e24e2aaa40a6bdce2ca0e657ffc6e10 Mon Sep 17 00:00:00 2001
96373c
From: Mark Reynolds <mreynolds@redhat.com>
96373c
Date: Wed, 27 Sep 2017 09:26:14 -0400
96373c
Subject: [PATCH] Ticket 49305 - Need to wrap atomic calls
96373c
96373c
Bug Description:  Some RHEL 7.5 platforms (ppc 32bit) still do not support
96373c
                  all the gcc builtin atomics.  This breaks the downstream
96373c
                  builds.
96373c
96373c
Fix Description:  Use wrapper functions for the atomic's using #define's
96373c
                  to detect if builtin atomics are supported, otherwise
96373c
                  use the egneric nspr atomic functions.
96373c
96373c
https://pagure.io/389-ds-base/issue/49305
96373c
96373c
Reviewed by: tbordaz(Thanks!)
96373c
96373c
(cherry picked from commit af723fd632d355642babeed1dbdb5a308c21fa79)
96373c
---
96373c
 ldap/servers/slapd/attrsyntax.c                  |   8 +-
96373c
 ldap/servers/slapd/back-ldbm/dblayer.c           |  66 +++++-----
96373c
 ldap/servers/slapd/entry.c                       |  11 +-
96373c
 ldap/servers/slapd/libglobs.c                    | 161 ++++++++++++-----------
96373c
 ldap/servers/slapd/log.c                         |   9 +-
96373c
 ldap/servers/slapd/mapping_tree.c                |  28 ++--
96373c
 ldap/servers/slapd/object.c                      |   8 +-
96373c
 ldap/servers/slapd/psearch.c                     |   7 +-
96373c
 ldap/servers/slapd/slapi-plugin.h                |  52 ++++++++
96373c
 ldap/servers/slapd/slapi_counter.c               | 100 ++++++++++++++
96373c
 ldap/servers/slapd/thread_data.c                 |   2 +-
96373c
 src/nunc-stans/ns/ns_thrpool.c                   |  17 ++-
96373c
 src/nunc-stans/test/test_nuncstans_stress_core.c |  42 +++++-
96373c
 13 files changed, 361 insertions(+), 150 deletions(-)
96373c
96373c
diff --git a/ldap/servers/slapd/attrsyntax.c b/ldap/servers/slapd/attrsyntax.c
96373c
index 03f05d9..a0a60c4 100644
96373c
--- a/ldap/servers/slapd/attrsyntax.c
96373c
+++ b/ldap/servers/slapd/attrsyntax.c
96373c
@@ -274,7 +274,7 @@ attr_syntax_get_by_oid_locking_optional(const char *oid, PRBool use_lock, PRUint
96373c
         }
96373c
         asi = (struct asyntaxinfo *)PL_HashTableLookup_const(ht, oid);
96373c
         if (asi) {
96373c
-            __atomic_add_fetch_8(&(asi->asi_refcnt), 1, __ATOMIC_RELEASE);
96373c
+            slapi_atomic_incr(&(asi->asi_refcnt), __ATOMIC_RELEASE, ATOMIC_LONG);
96373c
         }
96373c
         if (use_lock) {
96373c
             AS_UNLOCK_READ(oid2asi_lock);
96373c
@@ -371,7 +371,7 @@ attr_syntax_get_by_name_locking_optional(const char *name, PRBool use_lock, PRUi
96373c
         }
96373c
         asi = (struct asyntaxinfo *)PL_HashTableLookup_const(ht, name);
96373c
         if (NULL != asi) {
96373c
-            __atomic_add_fetch_8(&(asi->asi_refcnt), 1, __ATOMIC_RELEASE);
96373c
+            slapi_atomic_incr(&(asi->asi_refcnt), __ATOMIC_RELEASE, ATOMIC_LONG);
96373c
         }
96373c
         if (use_lock) {
96373c
             AS_UNLOCK_READ(name2asi_lock);
96373c
@@ -406,7 +406,7 @@ attr_syntax_return_locking_optional(struct asyntaxinfo *asi, PRBool use_lock)
96373c
     }
96373c
     if (NULL != asi) {
96373c
         PRBool delete_it = PR_FALSE;
96373c
-        if (0 == __atomic_sub_fetch_8(&(asi->asi_refcnt), 1, __ATOMIC_ACQ_REL)) {
96373c
+        if (0 == slapi_atomic_decr(&(asi->asi_refcnt), __ATOMIC_ACQ_REL, ATOMIC_LONG)) {
96373c
             delete_it = asi->asi_marked_for_delete;
96373c
         }
96373c
 
96373c
@@ -540,7 +540,7 @@ attr_syntax_delete_no_lock(struct asyntaxinfo *asi,
96373c
                 PL_HashTableRemove(ht, asi->asi_aliases[i]);
96373c
             }
96373c
         }
96373c
-        if (__atomic_load_8(&(asi->asi_refcnt), __ATOMIC_ACQUIRE) > 0) {
96373c
+        if (slapi_atomic_load(&(asi->asi_refcnt), __ATOMIC_ACQUIRE, ATOMIC_LONG) > 0) {
96373c
             asi->asi_marked_for_delete = PR_TRUE;
96373c
         } else {
96373c
             /* This is ok, but the correct thing is to call delete first,
96373c
diff --git a/ldap/servers/slapd/back-ldbm/dblayer.c b/ldap/servers/slapd/back-ldbm/dblayer.c
96373c
index d43258d..c4c4959 100644
96373c
--- a/ldap/servers/slapd/back-ldbm/dblayer.c
96373c
+++ b/ldap/servers/slapd/back-ldbm/dblayer.c
96373c
@@ -2860,16 +2860,16 @@ int
96373c
 dblayer_get_index_file(backend *be, struct attrinfo *a, DB **ppDB, int open_flags)
96373c
 {
96373c
     /*
96373c
-   * We either already have a DB* handle in the attrinfo structure.
96373c
-   * in which case we simply return it to the caller, OR:
96373c
-   * we need to make one. We do this as follows:
96373c
-   * 1a) acquire the mutex that protects the handle list.
96373c
-   * 1b) check that the DB* is still null.
96373c
-   * 2) get the filename, and call libdb to open it
96373c
-   * 3) if successful, store the result in the attrinfo stucture
96373c
-   * 4) store the DB* in our own list so we can close it later.
96373c
-   * 5) release the mutex.
96373c
-   */
96373c
+     * We either already have a DB* handle in the attrinfo structure.
96373c
+     * in which case we simply return it to the caller, OR:
96373c
+     * we need to make one. We do this as follows:
96373c
+     * 1a) acquire the mutex that protects the handle list.
96373c
+     * 1b) check that the DB* is still null.
96373c
+     * 2) get the filename, and call libdb to open it
96373c
+     * 3) if successful, store the result in the attrinfo stucture
96373c
+     * 4) store the DB* in our own list so we can close it later.
96373c
+     * 5) release the mutex.
96373c
+     */
96373c
     ldbm_instance *inst = (ldbm_instance *)be->be_instance_info;
96373c
     int return_value = -1;
96373c
     DB *pDB = NULL;
96373c
@@ -2878,9 +2878,9 @@ dblayer_get_index_file(backend *be, struct attrinfo *a, DB **ppDB, int open_flag
96373c
     *ppDB = NULL;
96373c
 
96373c
     /* it's like a semaphore -- when count > 0, any file handle that's in
96373c
-   * the attrinfo will remain valid from here on.
96373c
-   */
96373c
-    __atomic_add_fetch_8(&(a->ai_dblayer_count), 1, __ATOMIC_RELEASE);
96373c
+     * the attrinfo will remain valid from here on.
96373c
+     */
96373c
+    slapi_atomic_incr(&(a->ai_dblayer_count), __ATOMIC_RELEASE, ATOMIC_LONG);
96373c
 
96373c
     if (a->ai_dblayer && ((dblayer_handle *)(a->ai_dblayer))->dblayer_dbp) {
96373c
         /* This means that the pointer is valid, so we should return it. */
96373c
@@ -2888,9 +2888,7 @@ dblayer_get_index_file(backend *be, struct attrinfo *a, DB **ppDB, int open_flag
96373c
         return 0;
96373c
     }
96373c
 
96373c
-    /* attrinfo handle is NULL, at least for now -- grab the mutex and try
96373c
-   * again.
96373c
-   */
96373c
+    /* attrinfo handle is NULL, at least for now -- grab the mutex and try again. */
96373c
     PR_Lock(inst->inst_handle_list_mutex);
96373c
     if (a->ai_dblayer && ((dblayer_handle *)(a->ai_dblayer))->dblayer_dbp) {
96373c
         /* another thread set the handle while we were waiting on the lock */
96373c
@@ -2900,8 +2898,8 @@ dblayer_get_index_file(backend *be, struct attrinfo *a, DB **ppDB, int open_flag
96373c
     }
96373c
 
96373c
     /* attrinfo handle is still blank, and we have the mutex: open the
96373c
-   * index file and stuff it in the attrinfo.
96373c
-   */
96373c
+     * index file and stuff it in the attrinfo.
96373c
+     */
96373c
     return_value = dblayer_open_file(be, attribute_name, open_flags,
96373c
                                      a, &pDB);
96373c
     if (0 == return_value) {
96373c
@@ -2911,40 +2909,36 @@ dblayer_get_index_file(backend *be, struct attrinfo *a, DB **ppDB, int open_flag
96373c
 
96373c
         PR_ASSERT(NULL != pDB);
96373c
         /* Store the returned DB* in our own private list of
96373c
-       * open files */
96373c
+         * open files */
96373c
         if (NULL == prev_handle) {
96373c
             /* List was empty */
96373c
             inst->inst_handle_tail = handle;
96373c
             inst->inst_handle_head = handle;
96373c
         } else {
96373c
-            /* Chain the handle onto the last structure in the
96373c
-           * list */
96373c
+            /* Chain the handle onto the last structure in the list */
96373c
             inst->inst_handle_tail = handle;
96373c
             prev_handle->dblayer_handle_next = handle;
96373c
         }
96373c
-        /* Stash a pointer to our wrapper structure in the
96373c
-       * attrinfo structure */
96373c
+        /* Stash a pointer to our wrapper structure in the attrinfo structure */
96373c
         handle->dblayer_dbp = pDB;
96373c
         /* And, most importantly, return something to the caller!*/
96373c
         *ppDB = pDB;
96373c
-        /* and save the hande in the attrinfo structure for
96373c
-       * next time */
96373c
+        /* and save the hande in the attrinfo structure for next time */
96373c
         a->ai_dblayer = handle;
96373c
         /* don't need to update count -- we incr'd it already */
96373c
         handle->dblayer_handle_ai_backpointer = &(a->ai_dblayer);
96373c
     } else {
96373c
         /* Did not open it OK ! */
96373c
         /* Do nothing, because return value and fact that we didn't
96373c
-     * store a DB* in the attrinfo is enough
96373c
-     */
96373c
+         * store a DB* in the attrinfo is enough */
96373c
     }
96373c
     PR_Unlock(inst->inst_handle_list_mutex);
96373c
 
96373c
     if (return_value != 0) {
96373c
         /* some sort of error -- we didn't open a handle at all.
96373c
-     * decrement the refcount back to where it was.
96373c
-     */
96373c
-        __atomic_sub_fetch_8(&(a->ai_dblayer_count), 1, __ATOMIC_RELEASE);
96373c
+         * decrement the refcount back to where it was.
96373c
+         */
96373c
+        slapi_atomic_decr(&(a->ai_dblayer_count), __ATOMIC_RELEASE, ATOMIC_LONG);
96373c
     }
96373c
 
96373c
     return return_value;
96373c
@@ -2956,7 +2950,7 @@ dblayer_get_index_file(backend *be, struct attrinfo *a, DB **ppDB, int open_flag
96373c
 int
96373c
 dblayer_release_index_file(backend *be __attribute__((unused)), struct attrinfo *a, DB *pDB __attribute__((unused)))
96373c
 {
96373c
-    __atomic_sub_fetch_8(&(a->ai_dblayer_count), 1, __ATOMIC_RELEASE);
96373c
+    slapi_atomic_decr(&(a->ai_dblayer_count), __ATOMIC_RELEASE, ATOMIC_LONG);
96373c
     return 0;
96373c
 }
96373c
 
96373c
@@ -3063,13 +3057,13 @@ dblayer_erase_index_file_ex(backend *be, struct attrinfo *a, PRBool use_lock, in
96373c
 
96373c
             dblayer_release_index_file(be, a, db);
96373c
 
96373c
-            while (__atomic_load_8(&(a->ai_dblayer_count), __ATOMIC_ACQUIRE) > 0) {
96373c
+            while (slapi_atomic_load(&(a->ai_dblayer_count), __ATOMIC_ACQUIRE, ATOMIC_LONG) > 0) {
96373c
                 /* someone is using this index file */
96373c
                 /* ASSUMPTION: you have already set the INDEX_OFFLINE flag, because
96373c
-         * you intend to mess with this index.  therefore no new requests
96373c
-         * for this indexfile should happen, so the dblayer_count should
96373c
-         * NEVER increase.
96373c
-         */
96373c
+                 * you intend to mess with this index.  therefore no new requests
96373c
+                 * for this indexfile should happen, so the dblayer_count should
96373c
+                 * NEVER increase.
96373c
+                 */
96373c
                 PR_ASSERT(a->ai_indexmask & INDEX_OFFLINE);
96373c
                 PR_Unlock(inst->inst_handle_list_mutex);
96373c
                 DS_Sleep(DBLAYER_CACHE_DELAY);
96373c
diff --git a/ldap/servers/slapd/entry.c b/ldap/servers/slapd/entry.c
96373c
index 62d10c2..289a149 100644
96373c
--- a/ldap/servers/slapd/entry.c
96373c
+++ b/ldap/servers/slapd/entry.c
96373c
@@ -2244,18 +2244,19 @@ slapi_entry_attr_find(const Slapi_Entry *e, const char *type, Slapi_Attr **a)
96373c
 
96373c
 /* the following functions control virtual attribute cache invalidation */
96373c
 
96373c
-static uint32_t g_virtual_watermark = 0; /* good enough to init */
96373c
+static int32_t g_virtual_watermark = 0; /* good enough to init */
96373c
 
96373c
 int
96373c
 slapi_entry_vattrcache_watermark_isvalid(const Slapi_Entry *e)
96373c
 {
96373c
-    return e->e_virtual_watermark == __atomic_load_4(&g_virtual_watermark, __ATOMIC_ACQUIRE);
96373c
+    return e->e_virtual_watermark == slapi_atomic_load(&g_virtual_watermark, __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
+
96373c
 }
96373c
 
96373c
 void
96373c
 slapi_entry_vattrcache_watermark_set(Slapi_Entry *e)
96373c
 {
96373c
-    e->e_virtual_watermark = __atomic_load_4(&g_virtual_watermark, __ATOMIC_ACQUIRE);
96373c
+    e->e_virtual_watermark = slapi_atomic_load(&g_virtual_watermark, __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 void
96373c
@@ -2268,8 +2269,8 @@ void
96373c
 slapi_entrycache_vattrcache_watermark_invalidate()
96373c
 {
96373c
     /* Make sure the value is never 0 */
96373c
-    if (__atomic_add_fetch_4(&g_virtual_watermark, 1, __ATOMIC_RELEASE) == 0) {
96373c
-        __atomic_add_fetch_4(&g_virtual_watermark, 1, __ATOMIC_RELEASE);
96373c
+    if (slapi_atomic_incr(&g_virtual_watermark, __ATOMIC_RELEASE, ATOMIC_INT) == 0) {
96373c
+        slapi_atomic_incr(&g_virtual_watermark, __ATOMIC_RELEASE, ATOMIC_INT);
96373c
     }
96373c
 }
96373c
 
96373c
diff --git a/ldap/servers/slapd/libglobs.c b/ldap/servers/slapd/libglobs.c
96373c
index 0eeb16a..4c54cf7 100644
96373c
--- a/ldap/servers/slapd/libglobs.c
96373c
+++ b/ldap/servers/slapd/libglobs.c
96373c
@@ -1335,19 +1335,19 @@ static uint64_t active_threads = 0;
96373c
 void
96373c
 g_incr_active_threadcnt(void)
96373c
 {
96373c
-    __atomic_add_fetch_8(&active_threads, 1, __ATOMIC_RELEASE);
96373c
+    slapi_atomic_incr(&active_threads, __ATOMIC_RELEASE, ATOMIC_LONG);
96373c
 }
96373c
 
96373c
 void
96373c
 g_decr_active_threadcnt(void)
96373c
 {
96373c
-    __atomic_sub_fetch_8(&active_threads, 1, __ATOMIC_RELEASE);
96373c
+    slapi_atomic_decr(&active_threads, __ATOMIC_RELEASE, ATOMIC_LONG);
96373c
 }
96373c
 
96373c
 uint64_t
96373c
 g_get_active_threadcnt(void)
96373c
 {
96373c
-    return __atomic_load_8(&active_threads, __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&active_threads, __ATOMIC_RELEASE, ATOMIC_LONG);
96373c
 }
96373c
 
96373c
 /*
96373c
@@ -1936,7 +1936,7 @@ config_set_ndn_cache_max_size(const char *attrname, char *value, char *errorbuf,
96373c
         size = NDN_DEFAULT_SIZE;
96373c
     }
96373c
     if (apply) {
96373c
-        __atomic_store_8(&(slapdFrontendConfig->ndn_cache_max_size), size, __ATOMIC_RELEASE);
96373c
+        slapi_atomic_store(&(slapdFrontendConfig->ndn_cache_max_size), &size, __ATOMIC_RELEASE, ATOMIC_LONG);
96373c
     }
96373c
 
96373c
     return retVal;
96373c
@@ -3476,7 +3476,8 @@ int32_t
96373c
 config_get_dynamic_plugins(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->dynamic_plugins), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->dynamic_plugins), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
+
96373c
 }
96373c
 
96373c
 int32_t
96373c
@@ -3498,7 +3499,7 @@ int32_t
96373c
 config_get_cn_uses_dn_syntax_in_dns()
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->cn_uses_dn_syntax_in_dns), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->cn_uses_dn_syntax_in_dns), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
@@ -3543,7 +3544,7 @@ config_set_onoff(const char *attrname, char *value, int32_t *configvalue, char *
96373c
         newval = LDAP_OFF;
96373c
     }
96373c
 
96373c
-    __atomic_store_4(configvalue, newval, __ATOMIC_RELEASE);
96373c
+    slapi_atomic_store(configvalue, &newval, __ATOMIC_RELEASE, ATOMIC_INT);
96373c
 
96373c
     return retVal;
96373c
 }
96373c
@@ -3915,7 +3916,7 @@ config_set_threadnumber(const char *attrname, char *value, char *errorbuf, int a
96373c
         retVal = LDAP_OPERATIONS_ERROR;
96373c
     }
96373c
     if (apply) {
96373c
-        __atomic_store_4(&(slapdFrontendConfig->threadnumber), threadnum, __ATOMIC_RELAXED);
96373c
+        slapi_atomic_store(&(slapdFrontendConfig->threadnumber), &threadnum, __ATOMIC_RELAXED, ATOMIC_INT);
96373c
     }
96373c
     return retVal;
96373c
 }
96373c
@@ -3944,7 +3945,7 @@ config_set_maxthreadsperconn(const char *attrname, char *value, char *errorbuf,
96373c
     }
96373c
 
96373c
     if (apply) {
96373c
-        __atomic_store_4(&(slapdFrontendConfig->maxthreadsperconn), maxthreadnum, __ATOMIC_RELEASE);
96373c
+        slapi_atomic_store(&(slapdFrontendConfig->maxthreadsperconn), &maxthreadnum, __ATOMIC_RELEASE, ATOMIC_INT);
96373c
     }
96373c
     return retVal;
96373c
 }
96373c
@@ -4102,7 +4103,7 @@ config_set_ioblocktimeout(const char *attrname, char *value, char *errorbuf, int
96373c
     }
96373c
 
96373c
     if (apply) {
96373c
-        __atomic_store_4(&(slapdFrontendConfig->ioblocktimeout), nValue, __ATOMIC_RELEASE);
96373c
+        slapi_atomic_store(&(slapdFrontendConfig->ioblocktimeout), &nValue, __ATOMIC_RELEASE, ATOMIC_INT);
96373c
     }
96373c
     return retVal;
96373c
 }
96373c
@@ -4606,21 +4607,22 @@ int32_t
96373c
 config_get_sasl_mapping_fallback()
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->sasl_mapping_fallback), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->sasl_mapping_fallback), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
+
96373c
 }
96373c
 
96373c
 int32_t
96373c
 config_get_disk_monitoring()
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->disk_monitoring), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->disk_monitoring), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
 config_get_disk_logging_critical()
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->disk_logging_critical), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->disk_logging_critical), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int
96373c
@@ -4667,14 +4669,14 @@ int32_t
96373c
 config_get_ldapi_switch()
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->ldapi_switch), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->ldapi_switch), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
 config_get_ldapi_bind_switch()
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->ldapi_bind_switch), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->ldapi_bind_switch), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 char *
96373c
@@ -4693,7 +4695,7 @@ int
96373c
 config_get_ldapi_map_entries()
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->ldapi_map_entries), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->ldapi_map_entries), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 char *
96373c
@@ -4763,7 +4765,8 @@ int32_t
96373c
 config_get_slapi_counters()
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->slapi_counters), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->slapi_counters), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
+
96373c
 }
96373c
 
96373c
 char *
96373c
@@ -4945,7 +4948,7 @@ int32_t
96373c
 config_get_pw_change(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->pw_policy.pw_change), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->pw_policy.pw_change), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 
96373c
@@ -4953,7 +4956,7 @@ int32_t
96373c
 config_get_pw_history(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->pw_policy.pw_history), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->pw_policy.pw_history), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 
96373c
@@ -4961,21 +4964,21 @@ int32_t
96373c
 config_get_pw_must_change(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->pw_policy.pw_must_change), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->pw_policy.pw_must_change), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
 config_get_allow_hashed_pw(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->allow_hashed_pw), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->allow_hashed_pw), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
 config_get_pw_syntax(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->pw_policy.pw_syntax), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->pw_policy.pw_syntax), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 
96373c
@@ -5164,21 +5167,21 @@ int32_t
96373c
 config_get_pw_is_global_policy(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->pw_is_global_policy), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->pw_is_global_policy), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
 config_get_pw_is_legacy_policy(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->pw_policy.pw_is_legacy), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->pw_policy.pw_is_legacy), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
 config_get_pw_exp(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->pw_policy.pw_exp), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->pw_policy.pw_exp), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 
96373c
@@ -5186,14 +5189,14 @@ int32_t
96373c
 config_get_pw_unlock(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->pw_policy.pw_unlock), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->pw_policy.pw_unlock), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
 config_get_pw_lockout()
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->pw_policy.pw_lockout), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->pw_policy.pw_lockout), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int
96373c
@@ -5213,112 +5216,112 @@ int32_t
96373c
 config_get_lastmod()
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->lastmod), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->lastmod), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
 config_get_enquote_sup_oc()
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->enquote_sup_oc), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->enquote_sup_oc), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
 config_get_nagle(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->nagle), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->nagle), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
 config_get_accesscontrol(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->accesscontrol), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->accesscontrol), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
 config_get_return_exact_case(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->return_exact_case), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->return_exact_case), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
 config_get_result_tweak(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->result_tweak), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->result_tweak), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
 config_get_moddn_aci(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->moddn_aci), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->moddn_aci), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
 config_get_security(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->security), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->security), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
 slapi_config_get_readonly(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->readonly), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->readonly), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
 config_get_schemacheck(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->schemacheck), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->schemacheck), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
 config_get_schemamod(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->schemamod), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->schemamod), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
 config_get_syntaxcheck(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->syntaxcheck), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->syntaxcheck), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
 config_get_syntaxlogging(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->syntaxlogging), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->syntaxlogging), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
 config_get_dn_validate_strict(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->dn_validate_strict), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->dn_validate_strict), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
 config_get_ds4_compatible_schema(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->ds4_compatible_schema), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->ds4_compatible_schema), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
 config_get_schema_ignore_trailing_spaces(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->schema_ignore_trailing_spaces), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->schema_ignore_trailing_spaces), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 char *
96373c
@@ -5402,7 +5405,7 @@ config_get_threadnumber(void)
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
     int32_t retVal;
96373c
 
96373c
-    retVal = __atomic_load_4(&(slapdFrontendConfig->threadnumber), __ATOMIC_RELAXED);
96373c
+    retVal = slapi_atomic_load(&(slapdFrontendConfig->threadnumber), __ATOMIC_RELAXED, ATOMIC_INT);
96373c
 
96373c
     if (retVal <= 0) {
96373c
         retVal = util_get_hardware_threads();
96373c
@@ -5420,7 +5423,7 @@ int32_t
96373c
 config_get_maxthreadsperconn()
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->maxthreadsperconn), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->maxthreadsperconn), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int
96373c
@@ -5452,7 +5455,7 @@ int32_t
96373c
 config_get_ioblocktimeout()
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->ioblocktimeout), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->ioblocktimeout), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int
96373c
@@ -5769,21 +5772,21 @@ int32_t
96373c
 config_get_unauth_binds_switch(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->allow_unauth_binds), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->allow_unauth_binds), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
 config_get_require_secure_binds(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->require_secure_binds), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->require_secure_binds), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
 config_get_anon_access_switch(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->allow_anon_access), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->allow_anon_access), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int
96373c
@@ -6025,7 +6028,8 @@ int32_t
96373c
 config_get_minssf_exclude_rootdse()
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->minssf_exclude_rootdse), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->minssf_exclude_rootdse), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
+
96373c
 }
96373c
 
96373c
 int
96373c
@@ -6034,18 +6038,17 @@ config_set_max_filter_nest_level(const char *attrname, char *value, char *errorb
96373c
     int retVal = LDAP_SUCCESS;
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
     char *endp;
96373c
-    long level;
96373c
+    int32_t level;
96373c
 
96373c
     if (config_value_is_null(attrname, value, errorbuf, 0)) {
96373c
         return LDAP_OPERATIONS_ERROR;
96373c
     }
96373c
 
96373c
     errno = 0;
96373c
-    level = strtol(value, &endp, 10);
96373c
+    level = (int32_t)strtol(value, &endp, 10);
96373c
     if (*endp != '\0' || errno == ERANGE) {
96373c
-        slapi_create_errormsg(errorbuf, SLAPI_DSE_RETURNTEXT_SIZE, "(%s) value (%s) "
96373c
-                                                                   "is invalid\n",
96373c
-                              attrname, value);
96373c
+        slapi_create_errormsg(errorbuf, SLAPI_DSE_RETURNTEXT_SIZE,
96373c
+                              "(%s) value (%s) is invalid\n", attrname, value);
96373c
         retVal = LDAP_OPERATIONS_ERROR;
96373c
         return retVal;
96373c
     }
96373c
@@ -6054,7 +6057,7 @@ config_set_max_filter_nest_level(const char *attrname, char *value, char *errorb
96373c
         return retVal;
96373c
     }
96373c
 
96373c
-    __atomic_store_4(&(slapdFrontendConfig->max_filter_nest_level), level, __ATOMIC_RELEASE);
96373c
+    slapi_atomic_store(&(slapdFrontendConfig->max_filter_nest_level), &level, __ATOMIC_RELEASE, ATOMIC_INT);
96373c
     return retVal;
96373c
 }
96373c
 
96373c
@@ -6062,29 +6065,28 @@ int32_t
96373c
 config_get_max_filter_nest_level()
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->max_filter_nest_level), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->max_filter_nest_level), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 uint64_t
96373c
 config_get_ndn_cache_size()
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-
96373c
-    return __atomic_load_8(&(slapdFrontendConfig->ndn_cache_max_size), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->ndn_cache_max_size), __ATOMIC_ACQUIRE, ATOMIC_LONG);
96373c
 }
96373c
 
96373c
 int32_t
96373c
 config_get_ndn_cache_enabled()
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->ndn_cache_enabled), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->ndn_cache_enabled), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
 config_get_return_orig_type_switch()
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->return_orig_type), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->return_orig_type), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 char *
96373c
@@ -6786,7 +6788,7 @@ int32_t
96373c
 config_get_force_sasl_external(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->force_sasl_external), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->force_sasl_external), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
@@ -6808,7 +6810,7 @@ int32_t
96373c
 config_get_entryusn_global(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->entryusn_global), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->entryusn_global), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
@@ -7046,21 +7048,21 @@ int32_t
96373c
 config_get_enable_turbo_mode(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->enable_turbo_mode), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->enable_turbo_mode), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
 config_get_connection_nocanon(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->connection_nocanon), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->connection_nocanon), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
 config_get_plugin_logging(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->plugin_logging), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->plugin_logging), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
@@ -7073,21 +7075,21 @@ int32_t
96373c
 config_get_unhashed_pw_switch()
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->unhashed_pw_switch), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->unhashed_pw_switch), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
 config_get_ignore_time_skew(void)
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->ignore_time_skew), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->ignore_time_skew), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
 config_get_global_backend_lock()
96373c
 {
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
-    return __atomic_load_4(&(slapdFrontendConfig->global_backend_lock), __ATOMIC_ACQUIRE);
96373c
+    return slapi_atomic_load(&(slapdFrontendConfig->global_backend_lock), __ATOMIC_ACQUIRE, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 int32_t
96373c
@@ -7163,8 +7165,9 @@ config_get_connection_buffer(void)
96373c
 int
96373c
 config_set_connection_buffer(const char *attrname, char *value, char *errorbuf, int apply)
96373c
 {
96373c
-    int retVal = LDAP_SUCCESS;
96373c
     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();
96373c
+    int retVal = LDAP_SUCCESS;
96373c
+    int32_t val;
96373c
 
96373c
     if (config_value_is_null(attrname, value, errorbuf, 0)) {
96373c
         return LDAP_OPERATIONS_ERROR;
96373c
@@ -7181,7 +7184,9 @@ config_set_connection_buffer(const char *attrname, char *value, char *errorbuf,
96373c
         return retVal;
96373c
     }
96373c
 
96373c
-    __atomic_store_4(&(slapdFrontendConfig->connection_buffer), atoi(value), __ATOMIC_RELEASE);
96373c
+    val = atoi(value);
96373c
+    slapi_atomic_store(&(slapdFrontendConfig->connection_buffer), &val, __ATOMIC_RELEASE, ATOMIC_INT);
96373c
+
96373c
     return retVal;
96373c
 }
96373c
 
96373c
@@ -7204,7 +7209,7 @@ config_set_listen_backlog_size(const char *attrname, char *value, char *errorbuf
96373c
     }
96373c
 
96373c
     if (apply) {
96373c
-        __atomic_store_4(&(slapdFrontendConfig->listen_backlog_size), size, __ATOMIC_RELEASE);
96373c
+        slapi_atomic_store(&(slapdFrontendConfig->listen_backlog_size), &size, __ATOMIC_RELEASE, ATOMIC_INT);
96373c
     }
96373c
     return LDAP_SUCCESS;
96373c
 }
96373c
@@ -7617,7 +7622,7 @@ config_set_accesslog_enabled(int value)
96373c
     char errorbuf[SLAPI_DSE_RETURNTEXT_SIZE];
96373c
     errorbuf[0] = '\0';
96373c
 
96373c
-    __atomic_store_4(&(slapdFrontendConfig->accesslog_logging_enabled), value, __ATOMIC_RELEASE);
96373c
+    slapi_atomic_store(&(slapdFrontendConfig->accesslog_logging_enabled), &value, __ATOMIC_RELEASE, ATOMIC_INT);
96373c
     if (value) {
96373c
         log_set_logging(CONFIG_ACCESSLOG_LOGGING_ENABLED_ATTRIBUTE, "on", SLAPD_ACCESS_LOG, errorbuf, CONFIG_APPLY);
96373c
     } else {
96373c
@@ -7635,7 +7640,7 @@ config_set_auditlog_enabled(int value)
96373c
     char errorbuf[SLAPI_DSE_RETURNTEXT_SIZE];
96373c
     errorbuf[0] = '\0';
96373c
 
96373c
-    __atomic_store_4(&(slapdFrontendConfig->auditlog_logging_enabled), value, __ATOMIC_RELEASE);
96373c
+    slapi_atomic_store(&(slapdFrontendConfig->auditlog_logging_enabled), &value, __ATOMIC_RELEASE, ATOMIC_INT);
96373c
     if (value) {
96373c
         log_set_logging(CONFIG_AUDITLOG_LOGGING_ENABLED_ATTRIBUTE, "on", SLAPD_AUDIT_LOG, errorbuf, CONFIG_APPLY);
96373c
     } else {
96373c
@@ -7653,7 +7658,7 @@ config_set_auditfaillog_enabled(int value)
96373c
     char errorbuf[SLAPI_DSE_RETURNTEXT_SIZE];
96373c
     errorbuf[0] = '\0';
96373c
 
96373c
-    __atomic_store_4(&(slapdFrontendConfig->auditfaillog_logging_enabled), value, __ATOMIC_RELEASE);
96373c
+    slapi_atomic_store(&(slapdFrontendConfig->auditfaillog_logging_enabled), &value, __ATOMIC_RELEASE, ATOMIC_INT);
96373c
     if (value) {
96373c
         log_set_logging(CONFIG_AUDITFAILLOG_LOGGING_ENABLED_ATTRIBUTE, "on", SLAPD_AUDITFAIL_LOG, errorbuf, CONFIG_APPLY);
96373c
     } else {
96373c
@@ -7744,7 +7749,7 @@ config_set_malloc_mxfast(const char *attrname, char *value, char *errorbuf, int
96373c
                               value, CONFIG_MALLOC_MXFAST, max);
96373c
         return LDAP_OPERATIONS_ERROR;
96373c
     }
96373c
-    __atomic_store_4(&(slapdFrontendConfig->malloc_mxfast), mxfast, __ATOMIC_RELEASE);
96373c
+    slapi_atomic_store(&(slapdFrontendConfig->malloc_mxfast), &mxfast, __ATOMIC_RELEASE, ATOMIC_INT);
96373c
 
96373c
     if ((mxfast >= 0) && (mxfast <= max)) {
96373c
         mallopt(M_MXFAST, mxfast);
96373c
@@ -7784,7 +7789,7 @@ config_set_malloc_trim_threshold(const char *attrname, char *value, char *errorb
96373c
         return LDAP_OPERATIONS_ERROR;
96373c
     }
96373c
 
96373c
-    __atomic_store_4(&(slapdFrontendConfig->malloc_trim_threshold), trim_threshold, __ATOMIC_RELEASE);
96373c
+    slapi_atomic_store(&(slapdFrontendConfig->malloc_trim_threshold), &trim_threshold, __ATOMIC_RELEASE, ATOMIC_INT);
96373c
 
96373c
     if (trim_threshold >= -1) {
96373c
         mallopt(M_TRIM_THRESHOLD, trim_threshold);
96373c
@@ -7831,7 +7836,7 @@ config_set_malloc_mmap_threshold(const char *attrname, char *value, char *errorb
96373c
         return LDAP_OPERATIONS_ERROR;
96373c
     }
96373c
 
96373c
-    __atomic_store_4(&(slapdFrontendConfig->malloc_mmap_threshold), mmap_threshold, __ATOMIC_RELEASE);
96373c
+    slapi_atomic_store(&(slapdFrontendConfig->malloc_mmap_threshold), &mmap_threshold, __ATOMIC_RELEASE, ATOMIC_INT);
96373c
 
96373c
     if ((mmap_threshold >= 0) && (mmap_threshold <= max)) {
96373c
         mallopt(M_MMAP_THRESHOLD, mmap_threshold);
96373c
diff --git a/ldap/servers/slapd/log.c b/ldap/servers/slapd/log.c
96373c
index 41b5c99..4d44c87 100644
96373c
--- a/ldap/servers/slapd/log.c
96373c
+++ b/ldap/servers/slapd/log.c
96373c
@@ -4942,12 +4942,13 @@ static LogBufferInfo *
96373c
 log_create_buffer(size_t sz)
96373c
 {
96373c
     LogBufferInfo *lbi;
96373c
+    uint64_t init_val = 0;
96373c
 
96373c
     lbi = (LogBufferInfo *)slapi_ch_malloc(sizeof(LogBufferInfo));
96373c
     lbi->top = (char *)slapi_ch_malloc(sz);
96373c
     lbi->current = lbi->top;
96373c
     lbi->maxsize = sz;
96373c
-    __atomic_store_8(&(lbi->refcount), 0, __ATOMIC_RELEASE);
96373c
+    slapi_atomic_store(&(lbi->refcount), &init_val, __ATOMIC_RELEASE, ATOMIC_LONG);
96373c
     return lbi;
96373c
 }
96373c
 
96373c
@@ -5009,7 +5010,7 @@ log_append_buffer2(time_t tnl, LogBufferInfo *lbi, char *msg1, size_t size1, cha
96373c
     insert_point = lbi->current;
96373c
     lbi->current += size;
96373c
     /* Increment the copy refcount */
96373c
-    __atomic_add_fetch_8(&(lbi->refcount), 1, __ATOMIC_RELEASE);
96373c
+    slapi_atomic_incr(&(lbi->refcount), __ATOMIC_RELEASE, ATOMIC_LONG);
96373c
     PR_Unlock(lbi->lock);
96373c
 
96373c
     /* Now we can copy without holding the lock */
96373c
@@ -5017,7 +5018,7 @@ log_append_buffer2(time_t tnl, LogBufferInfo *lbi, char *msg1, size_t size1, cha
96373c
     memcpy(insert_point + size1, msg2, size2);
96373c
 
96373c
     /* Decrement the copy refcount */
96373c
-    __atomic_sub_fetch_8(&(lbi->refcount), 1, __ATOMIC_RELEASE);
96373c
+    slapi_atomic_decr(&(lbi->refcount), __ATOMIC_RELEASE, ATOMIC_LONG);
96373c
 
96373c
     /* If we are asked to sync to disk immediately, do so */
96373c
     if (!slapdFrontendConfig->accesslogbuffering) {
96373c
@@ -5037,7 +5038,7 @@ log_flush_buffer(LogBufferInfo *lbi, int type, int sync_now)
96373c
     if (type == SLAPD_ACCESS_LOG) {
96373c
 
96373c
         /* It is only safe to flush once any other threads which are copying are finished */
96373c
-        while (__atomic_load_8(&(lbi->refcount), __ATOMIC_ACQUIRE) > 0) {
96373c
+        while (slapi_atomic_load(&(lbi->refcount), __ATOMIC_ACQUIRE, ATOMIC_LONG) > 0) {
96373c
             /* It's ok to sleep for a while because we only flush every second or so */
96373c
             DS_Sleep(PR_MillisecondsToInterval(1));
96373c
         }
96373c
diff --git a/ldap/servers/slapd/mapping_tree.c b/ldap/servers/slapd/mapping_tree.c
96373c
index 651d70e..6621ceb 100644
96373c
--- a/ldap/servers/slapd/mapping_tree.c
96373c
+++ b/ldap/servers/slapd/mapping_tree.c
96373c
@@ -1647,7 +1647,7 @@ mapping_tree_init()
96373c
 
96373c
     /* we call this function from a single thread, so it should be ok */
96373c
 
96373c
-    if (__atomic_load_4(&mapping_tree_freed, __ATOMIC_RELAXED)) {
96373c
+    if (slapi_atomic_load(&mapping_tree_freed, __ATOMIC_RELAXED, ATOMIC_INT)) {
96373c
         /* shutdown has been detected */
96373c
         return 0;
96373c
     }
96373c
@@ -1759,6 +1759,8 @@ mtn_free_node(mapping_tree_node **node)
96373c
 void
96373c
 mapping_tree_free()
96373c
 {
96373c
+    int init_val = 1;
96373c
+
96373c
     /* unregister dse callbacks */
96373c
     slapi_config_remove_callback(SLAPI_OPERATION_MODIFY, DSE_FLAG_PREOP, MAPPING_TREE_BASE_DN, LDAP_SCOPE_BASE, "(objectclass=*)", mapping_tree_entry_modify_callback);
96373c
     slapi_config_remove_callback(SLAPI_OPERATION_ADD, DSE_FLAG_PREOP, MAPPING_TREE_BASE_DN, LDAP_SCOPE_BASE, "(objectclass=*)", mapping_tree_entry_add_callback);
96373c
@@ -1771,7 +1773,7 @@ mapping_tree_free()
96373c
     slapi_unregister_backend_state_change_all();
96373c
     /* recursively free tree nodes */
96373c
     mtn_free_node(&mapping_tree_root);
96373c
-    __atomic_store_4(&mapping_tree_freed, 1, __ATOMIC_RELAXED);
96373c
+    slapi_atomic_store(&mapping_tree_freed, &init_val, __ATOMIC_RELAXED, ATOMIC_INT);
96373c
 }
96373c
 
96373c
 /* This function returns the first node to parse when a search is done
96373c
@@ -2022,7 +2024,7 @@ slapi_dn_write_needs_referral(Slapi_DN *target_sdn, Slapi_Entry **referral)
96373c
     mapping_tree_node *target_node = NULL;
96373c
     int ret = 0;
96373c
 
96373c
-    if (__atomic_load_4(&mapping_tree_freed, __ATOMIC_RELAXED)) {
96373c
+    if (slapi_atomic_load(&mapping_tree_freed, __ATOMIC_RELAXED, ATOMIC_INT)) {
96373c
         /* shutdown detected */
96373c
         goto done;
96373c
     }
96373c
@@ -2093,7 +2095,7 @@ slapi_mapping_tree_select(Slapi_PBlock *pb, Slapi_Backend **be, Slapi_Entry **re
96373c
     int fixup = 0;
96373c
 
96373c
 
96373c
-    if (__atomic_load_4(&mapping_tree_freed, __ATOMIC_RELAXED)) {
96373c
+    if (slapi_atomic_load(&mapping_tree_freed, __ATOMIC_RELAXED, ATOMIC_INT)) {
96373c
         /* shutdown detected */
96373c
         return LDAP_OPERATIONS_ERROR;
96373c
     }
96373c
@@ -2198,7 +2200,7 @@ slapi_mapping_tree_select_all(Slapi_PBlock *pb, Slapi_Backend **be_list, Slapi_E
96373c
     int flag_partial_result = 0;
96373c
     int op_type;
96373c
 
96373c
-    if (__atomic_load_4(&mapping_tree_freed, __ATOMIC_RELAXED)) {
96373c
+    if (slapi_atomic_load(&mapping_tree_freed, __ATOMIC_RELAXED, ATOMIC_INT)) {
96373c
         return LDAP_OPERATIONS_ERROR;
96373c
     }
96373c
 
96373c
@@ -2358,7 +2360,7 @@ slapi_mapping_tree_select_and_check(Slapi_PBlock *pb, char *newdn, Slapi_Backend
96373c
     int ret;
96373c
     int need_unlock = 0;
96373c
 
96373c
-    if (__atomic_load_4(&mapping_tree_freed, __ATOMIC_RELAXED)) {
96373c
+    if (slapi_atomic_load(&mapping_tree_freed, __ATOMIC_RELAXED, ATOMIC_INT)) {
96373c
         return LDAP_OPERATIONS_ERROR;
96373c
     }
96373c
 
96373c
@@ -2524,7 +2526,7 @@ mtn_get_be(mapping_tree_node *target_node, Slapi_PBlock *pb, Slapi_Backend **be,
96373c
     int flag_stop = 0;
96373c
     struct slapi_componentid *cid = NULL;
96373c
 
96373c
-    if (__atomic_load_4(&mapping_tree_freed, __ATOMIC_RELAXED)) {
96373c
+    if (slapi_atomic_load(&mapping_tree_freed, __ATOMIC_RELAXED, ATOMIC_INT)) {
96373c
         /* shut down detected */
96373c
         return LDAP_OPERATIONS_ERROR;
96373c
     }
96373c
@@ -2712,7 +2714,7 @@ best_matching_child(mapping_tree_node *parent,
96373c
     mapping_tree_node *highest_match_node = NULL;
96373c
     mapping_tree_node *current;
96373c
 
96373c
-    if (__atomic_load_4(&mapping_tree_freed, __ATOMIC_RELAXED)) {
96373c
+    if (slapi_atomic_load(&mapping_tree_freed, __ATOMIC_RELAXED, ATOMIC_INT)) {
96373c
         /* shutdown detected */
96373c
         return NULL;
96373c
     }
96373c
@@ -2739,7 +2741,7 @@ mtn_get_mapping_tree_node_by_entry(mapping_tree_node *node, const Slapi_DN *dn)
96373c
 {
96373c
     mapping_tree_node *found_node = NULL;
96373c
 
96373c
-    if (__atomic_load_4(&mapping_tree_freed, __ATOMIC_RELAXED)) {
96373c
+    if (slapi_atomic_load(&mapping_tree_freed, __ATOMIC_RELAXED, ATOMIC_INT)) {
96373c
         /* shutdown detected */
96373c
         return NULL;
96373c
     }
96373c
@@ -2782,7 +2784,7 @@ slapi_get_mapping_tree_node_by_dn(const Slapi_DN *dn)
96373c
     mapping_tree_node *current_best_match = mapping_tree_root;
96373c
     mapping_tree_node *next_best_match = mapping_tree_root;
96373c
 
96373c
-    if (__atomic_load_4(&mapping_tree_freed, __ATOMIC_RELAXED)) {
96373c
+    if (slapi_atomic_load(&mapping_tree_freed, __ATOMIC_RELAXED, ATOMIC_INT)) {
96373c
         /* shutdown detected */
96373c
         return NULL;
96373c
     }
96373c
@@ -2816,7 +2818,7 @@ get_mapping_tree_node_by_name(mapping_tree_node *node, char *be_name)
96373c
     int i;
96373c
     mapping_tree_node *found_node = NULL;
96373c
 
96373c
-    if (__atomic_load_4(&mapping_tree_freed, __ATOMIC_RELAXED)) {
96373c
+    if (slapi_atomic_load(&mapping_tree_freed, __ATOMIC_RELAXED, ATOMIC_INT)) {
96373c
         /* shutdown detected */
96373c
         return NULL;
96373c
     }
96373c
@@ -2863,7 +2865,7 @@ slapi_get_mapping_tree_node_configdn(const Slapi_DN *root)
96373c
 {
96373c
     char *dn = NULL;
96373c
 
96373c
-    if (__atomic_load_4(&mapping_tree_freed, __ATOMIC_RELAXED)) {
96373c
+    if (slapi_atomic_load(&mapping_tree_freed, __ATOMIC_RELAXED, ATOMIC_INT)) {
96373c
         /* shutdown detected */
96373c
         return NULL;
96373c
     }
96373c
@@ -2890,7 +2892,7 @@ slapi_get_mapping_tree_node_configsdn(const Slapi_DN *root)
96373c
     char *dn = NULL;
96373c
     Slapi_DN *sdn = NULL;
96373c
 
96373c
-    if (__atomic_load_4(&mapping_tree_freed, __ATOMIC_RELAXED)) {
96373c
+    if (slapi_atomic_load(&mapping_tree_freed, __ATOMIC_RELAXED, ATOMIC_INT)) {
96373c
         /* shutdown detected */
96373c
         return NULL;
96373c
     }
96373c
diff --git a/ldap/servers/slapd/object.c b/ldap/servers/slapd/object.c
96373c
index 84845d3..6a1a9a5 100644
96373c
--- a/ldap/servers/slapd/object.c
96373c
+++ b/ldap/servers/slapd/object.c
96373c
@@ -43,10 +43,12 @@ Object *
96373c
 object_new(void *user_data, FNFree destructor)
96373c
 {
96373c
     Object *o;
96373c
+    uint64_t init_val = 1;
96373c
+
96373c
     o = (object *)slapi_ch_malloc(sizeof(object));
96373c
     o->destructor = destructor;
96373c
     o->data = user_data;
96373c
-    __atomic_store_8(&(o->refcnt), 1, __ATOMIC_RELEASE);
96373c
+    slapi_atomic_store(&(o->refcnt), &init_val, __ATOMIC_RELEASE, ATOMIC_LONG);
96373c
     return o;
96373c
 }
96373c
 
96373c
@@ -60,7 +62,7 @@ void
96373c
 object_acquire(Object *o)
96373c
 {
96373c
     PR_ASSERT(NULL != o);
96373c
-    __atomic_add_fetch_8(&(o->refcnt), 1, __ATOMIC_RELEASE);
96373c
+    slapi_atomic_incr(&(o->refcnt), __ATOMIC_RELEASE, ATOMIC_LONG);
96373c
 }
96373c
 
96373c
 
96373c
@@ -75,7 +77,7 @@ object_release(Object *o)
96373c
     PRInt32 refcnt_after_release;
96373c
 
96373c
     PR_ASSERT(NULL != o);
96373c
-    refcnt_after_release = __atomic_sub_fetch_8(&(o->refcnt), 1, __ATOMIC_ACQ_REL);
96373c
+    refcnt_after_release = slapi_atomic_decr(&(o->refcnt), __ATOMIC_ACQ_REL, ATOMIC_LONG);
96373c
     if (refcnt_after_release == 0) {
96373c
         /* Object can be destroyed */
96373c
         if (o->destructor)
96373c
diff --git a/ldap/servers/slapd/psearch.c b/ldap/servers/slapd/psearch.c
96373c
index 0489122..70c530b 100644
96373c
--- a/ldap/servers/slapd/psearch.c
96373c
+++ b/ldap/servers/slapd/psearch.c
96373c
@@ -134,7 +134,7 @@ ps_stop_psearch_system()
96373c
     if (PS_IS_INITIALIZED()) {
96373c
         PSL_LOCK_WRITE();
96373c
         for (ps = psearch_list->pl_head; NULL != ps; ps = ps->ps_next) {
96373c
-            __atomic_add_fetch_8(&(ps->ps_complete), 1, __ATOMIC_RELEASE);
96373c
+            slapi_atomic_incr(&(ps->ps_complete), __ATOMIC_RELEASE, ATOMIC_LONG);
96373c
         }
96373c
         PSL_UNLOCK_WRITE();
96373c
         ps_wakeup_all();
96373c
@@ -285,7 +285,7 @@ ps_send_results(void *arg)
96373c
 
96373c
     PR_Lock(psearch_list->pl_cvarlock);
96373c
 
96373c
-    while ((conn_acq_flag == 0) && __atomic_load_8(&(ps->ps_complete), __ATOMIC_ACQUIRE) == 0) {
96373c
+    while ((conn_acq_flag == 0) && slapi_atomic_load(&(ps->ps_complete), __ATOMIC_ACQUIRE, ATOMIC_LONG) == 0) {
96373c
         /* Check for an abandoned operation */
96373c
         if (pb_op == NULL || slapi_op_abandoned(ps->ps_pblock)) {
96373c
             slapi_log_err(SLAPI_LOG_CONNS, "ps_send_results",
96373c
@@ -427,6 +427,7 @@ static PSearch *
96373c
 psearch_alloc(void)
96373c
 {
96373c
     PSearch *ps;
96373c
+    uint64_t init_val = 0;
96373c
 
96373c
     ps = (PSearch *)slapi_ch_calloc(1, sizeof(PSearch));
96373c
 
96373c
@@ -437,7 +438,7 @@ psearch_alloc(void)
96373c
         slapi_ch_free((void **)&ps);
96373c
         return (NULL);
96373c
     }
96373c
-    __atomic_store_8(&(ps->ps_complete), 0, __ATOMIC_RELEASE);
96373c
+    slapi_atomic_store(&(ps->ps_complete), &init_val, __ATOMIC_RELEASE, ATOMIC_LONG);
96373c
     ps->ps_eq_head = ps->ps_eq_tail = (PSEQNode *)NULL;
96373c
     ps->ps_lasttime = (time_t)0L;
96373c
     ps->ps_next = NULL;
96373c
diff --git a/ldap/servers/slapd/slapi-plugin.h b/ldap/servers/slapd/slapi-plugin.h
96373c
index 3397c63..c434add 100644
96373c
--- a/ldap/servers/slapd/slapi-plugin.h
96373c
+++ b/ldap/servers/slapd/slapi-plugin.h
96373c
@@ -8202,6 +8202,58 @@ void slapi_operation_time_initiated(Slapi_Operation *o, struct timespec *initiat
96373c
  */
96373c
 #endif
96373c
 
96373c
+/* See: https://gcc.gnu.org/ml/gcc/2016-11/txt6ZlA_JS27i.txt */
96373c
+#define ATOMIC_GENERIC  0
96373c
+#define ATOMIC_INT      4
96373c
+#define ATOMIC_LONG     8
96373c
+#define ATOMIC_INT128  16  /* Future */
96373c
+
96373c
+/**
96373c
+ * Store an integral value atomicly
96373c
+ *
96373c
+ * \param ptr - integral pointer
96373c
+ * \param val - pointer to integral value (use integral type int32_t with ATOMIC_INT, or uint64_t
96373c
+ * with ATOMIC_LONG & ATOMIC_GENERIC)
96373c
+ * \param memorder - __ATOMIC_RELAXED, __ATOMIC_CONSUME, __ATOMIC_ACQUIRE,
96373c
+ * __ATOMIC_RELEASE, __ATOMIC_ACQ_REL, __ATOMIC_SEQ_CST
96373c
+ * \param type - "ptr" type: ATOMIC_GENERIC, ATOMIC_INT, or ATOMIC_LONG
96373c
+ */
96373c
+void slapi_atomic_store(void *ptr, void *val, int memorder, int type);
96373c
+
96373c
+/**
96373c
+ * Get an integral value atomicly
96373c
+ *
96373c
+ * \param ptr - integral pointer
96373c
+ * \param memorder - __ATOMIC_RELAXED, __ATOMIC_CONSUME, __ATOMIC_ACQUIRE,
96373c
+ * __ATOMIC_RELEASE, __ATOMIC_ACQ_REL, __ATOMIC_SEQ_CST
96373c
+ * \param type - "ptr" type: ATOMIC_GENERIC, ATOMIC_INT, or ATOMIC_LONG
96373c
+ * \return -
96373c
+ */
96373c
+uint64_t slapi_atomic_load(void *ptr, int memorder, int type);
96373c
+
96373c
+/**
96373c
+ * Increment integral atomicly
96373c
+ *
96373c
+ * \param ptr - pointer to integral to increment
96373c
+ * \param memorder - __ATOMIC_RELAXED, __ATOMIC_CONSUME, __ATOMIC_ACQUIRE,
96373c
+ * __ATOMIC_RELEASE, __ATOMIC_ACQ_REL, __ATOMIC_SEQ_CST
96373c
+ * \param type - "ptr" type: ATOMIC_GENERIC, ATOMIC_INT, or ATOMIC_LONG
96373c
+ * \return - new value of ptr
96373c
+ */
96373c
+uint64_t slapi_atomic_incr(void *ptr, int memorder, int type);
96373c
+
96373c
+/**
96373c
+ * Decrement integral atomicly
96373c
+ *
96373c
+ * \param ptr - pointer to integral to decrement
96373c
+ * \param memorder - __ATOMIC_RELAXED, __ATOMIC_CONSUME, __ATOMIC_ACQUIRE,
96373c
+ * __ATOMIC_RELEASE, __ATOMIC_ACQ_REL, __ATOMIC_SEQ_CST
96373c
+ * \param type - "ptr" type: ATOMIC_GENERIC, ATOMIC_INT, or ATOMIC_LONG
96373c
+ * \return - new value of ptr
96373c
+ */
96373c
+uint64_t slapi_atomic_decr(void *ptr, int memorder, int type);
96373c
+
96373c
+
96373c
 #ifdef __cplusplus
96373c
 }
96373c
 #endif
96373c
diff --git a/ldap/servers/slapd/slapi_counter.c b/ldap/servers/slapd/slapi_counter.c
96373c
index ba0091f..9e705b3 100644
96373c
--- a/ldap/servers/slapd/slapi_counter.c
96373c
+++ b/ldap/servers/slapd/slapi_counter.c
96373c
@@ -283,3 +283,103 @@ slapi_counter_get_value(Slapi_Counter *counter)
96373c
 
96373c
     return value;
96373c
 }
96373c
+
96373c
+
96373c
+/*
96373c
+ *
96373c
+ * Atomic functions
96373c
+ *
96373c
+ * ptr - a pointer to an integral type variable: int, uint32_t, uint64_t, etc
96373c
+ *
96373c
+ * memorder - __ATOMIC_RELAXED, __ATOMIC_CONSUME, __ATOMIC_ACQUIRE,
96373c
+ * __ATOMIC_RELEASE, __ATOMIC_ACQ_REL, or __ATOMIC_SEQ_CST
96373c
+ *
96373c
+ *     See: https://gcc.gnu.org/onlinedocs/gcc-4.9.2/gcc/_005f_005fatomic-Builtins.html
96373c
+ *
96373c
+ * type_size - ATOMIC_GENERIC, ATOMIC_INT, or ATOMIC_LONG, see slapi-plugin.h for more info
96373c
+ *
96373c
+ * Future:
96373c
+ *    If we need to support ATOMIC_INT128 (not available on 32bit systems):
96373c
+ *         __atomic_store_16((uint64_t *)&ptr, val, memorder);
96373c
+ *         __atomic_load_16((uint64_t *)&ptr, memorder);
96373c
+ *         __atomic_add_fetch_16((uint64_t *)&ptr, 1, memorder);
96373c
+ *         __atomic_sub_fetch_16((uint64_t *)&ptr, 1, memorder);
96373c
+ */
96373c
+
96373c
+/*
96373c
+ * "val" must be either int32_t or uint64_t
96373c
+ */
96373c
+void
96373c
+slapi_atomic_store(void *ptr, void *val, int memorder, int type_size)
96373c
+{
96373c
+#ifdef ATOMIC_64BIT_OPERATIONS
96373c
+    if (type_size == ATOMIC_INT) {
96373c
+        __atomic_store_4((int32_t *)ptr, *(int32_t *)val, memorder);
96373c
+    } else if (type_size == ATOMIC_LONG) {
96373c
+        __atomic_store_8((uint64_t *)ptr, *(uint64_t *)val, memorder);
96373c
+    } else {
96373c
+        /* ATOMIC_GENERIC or unknown size */
96373c
+        __atomic_store((uint64_t *)&ptr, (uint64_t *)val, memorder);
96373c
+    }
96373c
+#else
96373c
+    PRInt32 *pr_ptr = (PRInt32 *)ptr;
96373c
+    PR_AtomicSet(pr_ptr, *(PRInt32 *)val);
96373c
+#endif
96373c
+}
96373c
+
96373c
+uint64_t
96373c
+slapi_atomic_load(void *ptr, int memorder, int type_size)
96373c
+{
96373c
+#ifdef ATOMIC_64BIT_OPERATIONS
96373c
+    uint64_t ret;
96373c
+
96373c
+    if (type_size == ATOMIC_INT) {
96373c
+        return __atomic_load_4((int32_t *)ptr, memorder);
96373c
+    } else if (type_size == ATOMIC_LONG) {
96373c
+        return __atomic_load_8((uint64_t *)ptr, memorder);
96373c
+    } else {
96373c
+        /* ATOMIC_GENERIC or unknown size */
96373c
+        __atomic_load((uint64_t *)ptr, &ret, memorder);
96373c
+        return ret;
96373c
+    }
96373c
+#else
96373c
+    PRInt32 *pr_ptr = (PRInt32 *)ptr;
96373c
+    return PR_AtomicAdd(pr_ptr, 0);
96373c
+#endif
96373c
+}
96373c
+
96373c
+uint64_t
96373c
+slapi_atomic_incr(void *ptr, int memorder, int type_size)
96373c
+{
96373c
+#ifdef ATOMIC_64BIT_OPERATIONS
96373c
+    if (type_size == ATOMIC_INT) {
96373c
+        return __atomic_add_fetch_4((int32_t *)ptr, 1, memorder);
96373c
+    } else if (type_size == ATOMIC_LONG) {
96373c
+        return __atomic_add_fetch_8((uint64_t *)ptr, 1, memorder);
96373c
+    } else {
96373c
+        /* ATOMIC_GENERIC or unknown size */
96373c
+        return __atomic_add_fetch((uint64_t *)ptr, 1, memorder);
96373c
+    }
96373c
+#else
96373c
+    PRInt32 *pr_ptr = (PRInt32 *)ptr;
96373c
+    return PR_AtomicIncrement(pr_ptr);
96373c
+#endif
96373c
+}
96373c
+
96373c
+uint64_t
96373c
+slapi_atomic_decr(void *ptr, int memorder, int type_size)
96373c
+{
96373c
+#ifdef ATOMIC_64BIT_OPERATIONS
96373c
+    if (type_size == ATOMIC_INT) {
96373c
+        return __atomic_sub_fetch_4((int32_t *)ptr, 1, memorder);
96373c
+    } else if (type_size == ATOMIC_LONG) {
96373c
+        return __atomic_sub_fetch_8((uint64_t *)ptr, 1, memorder);
96373c
+    } else {
96373c
+        /* ATOMIC_GENERIC or unknown size */
96373c
+        return __atomic_sub_fetch((uint64_t *)ptr, 1, memorder);
96373c
+    }
96373c
+#else
96373c
+    PRInt32 *pr_ptr = (PRInt32 *)ptr;
96373c
+    return PR_AtomicDecrement(pr_ptr);
96373c
+#endif
96373c
+}
96373c
diff --git a/ldap/servers/slapd/thread_data.c b/ldap/servers/slapd/thread_data.c
96373c
index 9964832..d473710 100644
96373c
--- a/ldap/servers/slapd/thread_data.c
96373c
+++ b/ldap/servers/slapd/thread_data.c
96373c
@@ -9,7 +9,7 @@
96373c
 /*
96373c
  *   Thread Local Storage Functions
96373c
  */
96373c
-#include <slapi-plugin.h>
96373c
+#include "slap.h"
96373c
 #include <prthread.h>
96373c
 
96373c
 void td_dn_destructor(void *priv);
96373c
diff --git a/src/nunc-stans/ns/ns_thrpool.c b/src/nunc-stans/ns/ns_thrpool.c
96373c
index 7921cbc..2ad0bd7 100644
96373c
--- a/src/nunc-stans/ns/ns_thrpool.c
96373c
+++ b/src/nunc-stans/ns/ns_thrpool.c
96373c
@@ -169,7 +169,11 @@ int32_t
96373c
 ns_thrpool_is_shutdown(struct ns_thrpool_t *tp)
96373c
 {
96373c
     int32_t result = 0;
96373c
+#ifdef ATOMIC_64BIT_OPERATIONS
96373c
     __atomic_load(&(tp->shutdown), &result, __ATOMIC_ACQUIRE);
96373c
+#else
96373c
+    result = PR_AtomicAdd(&(tp->shutdown), 0);
96373c
+#endif
96373c
     return result;
96373c
 }
96373c
 
96373c
@@ -177,7 +181,11 @@ int32_t
96373c
 ns_thrpool_is_event_shutdown(struct ns_thrpool_t *tp)
96373c
 {
96373c
     int32_t result = 0;
96373c
+#ifdef ATOMIC_64BIT_OPERATIONS
96373c
     __atomic_load(&(tp->shutdown_event_loop), &result, __ATOMIC_ACQUIRE);
96373c
+#else
96373c
+    result = PR_AtomicAdd(&(tp->shutdown_event_loop), 0);
96373c
+#endif
96373c
     return result;
96373c
 }
96373c
 
96373c
@@ -1442,8 +1450,11 @@ ns_thrpool_destroy(struct ns_thrpool_t *tp)
96373c
 #endif
96373c
     if (tp) {
96373c
         /* Set the flag to shutdown the event loop. */
96373c
+#ifdef ATOMIC_64BIT_OPERATIONS
96373c
         __atomic_add_fetch(&(tp->shutdown_event_loop), 1, __ATOMIC_RELEASE);
96373c
-
96373c
+#else
96373c
+        PR_AtomicIncrement(&(tp->shutdown_event_loop));
96373c
+#endif
96373c
         /* Finish the event queue wakeup job.  This has the
96373c
          * side effect of waking up the event loop thread, which
96373c
          * will cause it to exit since we set the event loop
96373c
@@ -1532,7 +1543,11 @@ ns_thrpool_shutdown(struct ns_thrpool_t *tp)
96373c
 
96373c
     /* Set the shutdown flag.  This will cause the worker
96373c
      * threads to exit after they finish all remaining work. */
96373c
+#ifdef ATOMIC_64BIT_OPERATIONS
96373c
     __atomic_add_fetch(&(tp->shutdown), 1, __ATOMIC_RELEASE);
96373c
+#else
96373c
+    PR_AtomicIncrement(&(tp->shutdown));
96373c
+#endif
96373c
 
96373c
     /* Send worker shutdown jobs into the queues. This allows
96373c
      * currently queued jobs to complete.
96373c
diff --git a/src/nunc-stans/test/test_nuncstans_stress_core.c b/src/nunc-stans/test/test_nuncstans_stress_core.c
96373c
index a678800..2fc4ef4 100644
96373c
--- a/src/nunc-stans/test/test_nuncstans_stress_core.c
96373c
+++ b/src/nunc-stans/test/test_nuncstans_stress_core.c
96373c
@@ -128,7 +128,11 @@ server_conn_write(struct ns_job_t *job)
96373c
     assert(connctx != NULL);
96373c
     if (NS_JOB_IS_TIMER(ns_job_get_output_type(job))) {
96373c
         do_logging(LOG_ERR, "conn_write: job [%p] timeout\n", job);
96373c
+#ifdef ATOMIC_64BIT_OPERATIONS
96373c
         __atomic_add_fetch(&server_fail_count, 1, __ATOMIC_SEQ_CST);
96373c
+#else
96373c
+        PR_AtomicIncrement(&server_fail_count);
96373c
+#endif
96373c
         conn_ctx_free(connctx);
96373c
         assert_int_equal(ns_job_done(job), 0);
96373c
         return;
96373c
@@ -173,7 +177,11 @@ server_conn_read(struct ns_job_t *job)
96373c
     if (NS_JOB_IS_TIMER(ns_job_get_output_type(job))) {
96373c
         /* The event that triggered this call back is because we timed out waiting for IO */
96373c
         do_logging(LOG_ERR, "conn_read: job [%p] timed out\n", job);
96373c
+#ifdef ATOMIC_64BIT_OPERATIONS
96373c
         __atomic_add_fetch(&server_fail_count, 1, __ATOMIC_SEQ_CST);
96373c
+#else
96373c
+        PR_AtomicIncrement(&server_fail_count);
96373c
+#endif
96373c
         conn_ctx_free(connctx);
96373c
         assert_int_equal(ns_job_done(job), 0);
96373c
         return;
96373c
@@ -204,7 +212,11 @@ server_conn_read(struct ns_job_t *job)
96373c
             return;
96373c
         } else {
96373c
             do_logging(LOG_ERR, "conn_read: read error for job [%p] %d: %s\n", job, PR_GetError(), PR_ErrorToString(PR_GetError(), PR_LANGUAGE_I_DEFAULT));
96373c
+#ifdef ATOMIC_64BIT_OPERATIONS
96373c
             __atomic_add_fetch(&server_fail_count, 1, __ATOMIC_SEQ_CST);
96373c
+#else
96373c
+            PR_AtomicIncrement(&server_fail_count);
96373c
+#endif
96373c
             conn_ctx_free(connctx);
96373c
             assert_int_equal(ns_job_done(job), 0);
96373c
             return;
96373c
@@ -214,7 +226,11 @@ server_conn_read(struct ns_job_t *job)
96373c
         /* Didn't read anything */
96373c
         do_logging(LOG_DEBUG, "conn_read: job [%p] closed\n", job);
96373c
         /* Increment the success */
96373c
+#ifdef ATOMIC_64BIT_OPERATIONS
96373c
         __atomic_add_fetch(&server_success_count, 1, __ATOMIC_SEQ_CST);
96373c
+#else
96373c
+        PR_AtomicIncrement(&server_success_count);
96373c
+#endif
96373c
         conn_ctx_free(connctx);
96373c
         assert_int_equal(ns_job_done(job), 0);
96373c
         return;
96373c
@@ -314,26 +330,41 @@ client_response_cb(struct ns_job_t *job)
96373c
     if (len < 0) {
96373c
         /* PRErrorCode prerr = PR_GetError(); */
96373c
         do_logging(LOG_ERR, "FAIL: connection error, no data \n");
96373c
+#ifdef ATOMIC_64BIT_OPERATIONS
96373c
         __atomic_add_fetch(&client_fail_count, 1, __ATOMIC_SEQ_CST);
96373c
+#else
96373c
+        PR_AtomicIncrement(&client_fail_count);
96373c
+#endif
96373c
         goto done;
96373c
     } else if (len == 0) {
96373c
         do_logging(LOG_ERR, "FAIL: connection closed, no data \n");
96373c
+#ifdef ATOMIC_64BIT_OPERATIONS
96373c
         __atomic_add_fetch(&client_fail_count, 1, __ATOMIC_SEQ_CST);
96373c
+#else
96373c
+        PR_AtomicIncrement(&client_fail_count);
96373c
+#endif
96373c
         goto done;
96373c
     } else {
96373c
         /* Be paranoid, force last byte null */
96373c
         buffer[buflen - 1] = '\0';
96373c
         if (strncmp("this is a test!\n", buffer, strlen("this is a test!\n")) != 0) {
96373c
             do_logging(LOG_ERR, "FAIL: connection incorrect response, no data \n");
96373c
+#ifdef ATOMIC_64BIT_OPERATIONS
96373c
             __atomic_add_fetch(&client_fail_count, 1, __ATOMIC_SEQ_CST);
96373c
+#else
96373c
+            PR_AtomicIncrement(&client_fail_count);
96373c
+#endif
96373c
             goto done;
96373c
         }
96373c
     }
96373c
 
96373c
     struct timespec ts;
96373c
     clock_gettime(CLOCK_MONOTONIC, &ts);
96373c
-
96373c
+#ifdef ATOMIC_64BIT_OPERATIONS
96373c
     __atomic_add_fetch(&client_success_count, 1, __ATOMIC_SEQ_CST);
96373c
+#else
96373c
+    PR_AtomicIncrement(&client_success_count);
96373c
+#endif
96373c
     do_logging(LOG_ERR, "PASS: %ld.%ld %d\n", ts.tv_sec, ts.tv_nsec, client_success_count);
96373c
 
96373c
 done:
96373c
@@ -354,7 +385,11 @@ client_initiate_connection_cb(struct ns_job_t *job)
96373c
         char *err = NULL;
96373c
         PR_GetErrorText(err);
96373c
         do_logging(LOG_ERR, "FAIL: Socket failed, %d -> %s\n", PR_GetError(), err);
96373c
+#ifdef ATOMIC_64BIT_OPERATIONS
96373c
         __atomic_add_fetch(&client_fail_count, 1, __ATOMIC_SEQ_CST);
96373c
+#else
96373c
+        PR_AtomicIncrement(&client_fail_count);
96373c
+#endif
96373c
         goto done;
96373c
     }
96373c
 
96373c
@@ -368,8 +403,11 @@ client_initiate_connection_cb(struct ns_job_t *job)
96373c
         PR_GetErrorText(err);
96373c
         do_logging(LOG_ERR, "FAIL: cannot connect, timeout %d -> %s \n", PR_GetError(), err);
96373c
         /* Atomic increment fail */
96373c
+#ifdef ATOMIC_64BIT_OPERATIONS
96373c
         __atomic_add_fetch(&client_timeout_count, 1, __ATOMIC_SEQ_CST);
96373c
-
96373c
+#else
96373c
+        PR_AtomicIncrement(&client_timeout_count);
96373c
+#endif
96373c
         if (sock != NULL) {
96373c
             PR_Close(sock);
96373c
         }
96373c
-- 
96373c
2.9.5
96373c