From f19dec383e24e2aaa40a6bdce2ca0e657ffc6e10 Mon Sep 17 00:00:00 2001

From: Mark Reynolds <mreynolds@redhat.com>

Date: Wed, 27 Sep 2017 09:26:14 -0400

Subject: [PATCH] Ticket 49305 - Need to wrap atomic calls

Bug Description:  Some RHEL 7.5 platforms (ppc 32bit) still do not support

                  all the gcc builtin atomics.  This breaks the downstream

                  builds.

Fix Description:  Use wrapper functions for the atomic's using #define's

                  to detect if builtin atomics are supported, otherwise

                  use the egneric nspr atomic functions.

https://pagure.io/389-ds-base/issue/49305

Reviewed by: tbordaz(Thanks!)

(cherry picked from commit af723fd632d355642babeed1dbdb5a308c21fa79)

---

 ldap/servers/slapd/attrsyntax.c                  |   8 +-

 ldap/servers/slapd/back-ldbm/dblayer.c           |  66 +++++-----

 ldap/servers/slapd/entry.c                       |  11 +-

 ldap/servers/slapd/libglobs.c                    | 161 ++++++++++++-----------

 ldap/servers/slapd/log.c                         |   9 +-

 ldap/servers/slapd/mapping_tree.c                |  28 ++--

 ldap/servers/slapd/object.c                      |   8 +-

 ldap/servers/slapd/psearch.c                     |   7 +-

 ldap/servers/slapd/slapi-plugin.h                |  52 ++++++++

 ldap/servers/slapd/slapi_counter.c               | 100 ++++++++++++++

 ldap/servers/slapd/thread_data.c                 |   2 +-

 src/nunc-stans/ns/ns_thrpool.c                   |  17 ++-

 src/nunc-stans/test/test_nuncstans_stress_core.c |  42 +++++-

 13 files changed, 361 insertions(+), 150 deletions(-)

diff --git a/ldap/servers/slapd/attrsyntax.c b/ldap/servers/slapd/attrsyntax.c

index 03f05d9..a0a60c4 100644

--- a/ldap/servers/slapd/attrsyntax.c

+++ b/ldap/servers/slapd/attrsyntax.c

@@ -274,7 +274,7 @@ attr_syntax_get_by_oid_locking_optional(const char *oid, PRBool use_lock, PRUint

         }

         asi = (struct asyntaxinfo *)PL_HashTableLookup_const(ht, oid);

         if (asi) {

-            __atomic_add_fetch_8(&(asi->asi_refcnt), 1, __ATOMIC_RELEASE);

+            slapi_atomic_incr(&(asi->asi_refcnt), __ATOMIC_RELEASE, ATOMIC_LONG);

         }

         if (use_lock) {

             AS_UNLOCK_READ(oid2asi_lock);

@@ -371,7 +371,7 @@ attr_syntax_get_by_name_locking_optional(const char *name, PRBool use_lock, PRUi

         }

         asi = (struct asyntaxinfo *)PL_HashTableLookup_const(ht, name);

         if (NULL != asi) {

-            __atomic_add_fetch_8(&(asi->asi_refcnt), 1, __ATOMIC_RELEASE);

+            slapi_atomic_incr(&(asi->asi_refcnt), __ATOMIC_RELEASE, ATOMIC_LONG);

         }

         if (use_lock) {

             AS_UNLOCK_READ(name2asi_lock);

@@ -406,7 +406,7 @@ attr_syntax_return_locking_optional(struct asyntaxinfo *asi, PRBool use_lock)

     }

     if (NULL != asi) {

         PRBool delete_it = PR_FALSE;

-        if (0 == __atomic_sub_fetch_8(&(asi->asi_refcnt), 1, __ATOMIC_ACQ_REL)) {

+        if (0 == slapi_atomic_decr(&(asi->asi_refcnt), __ATOMIC_ACQ_REL, ATOMIC_LONG)) {

             delete_it = asi->asi_marked_for_delete;

         }

@@ -540,7 +540,7 @@ attr_syntax_delete_no_lock(struct asyntaxinfo *asi,

                 PL_HashTableRemove(ht, asi->asi_aliases[i]);

             }

         }

-        if (__atomic_load_8(&(asi->asi_refcnt), __ATOMIC_ACQUIRE) > 0) {

+        if (slapi_atomic_load(&(asi->asi_refcnt), __ATOMIC_ACQUIRE, ATOMIC_LONG) > 0) {

             asi->asi_marked_for_delete = PR_TRUE;

         } else {

             /* This is ok, but the correct thing is to call delete first,

diff --git a/ldap/servers/slapd/back-ldbm/dblayer.c b/ldap/servers/slapd/back-ldbm/dblayer.c

index d43258d..c4c4959 100644

--- a/ldap/servers/slapd/back-ldbm/dblayer.c

+++ b/ldap/servers/slapd/back-ldbm/dblayer.c

@@ -2860,16 +2860,16 @@ int

 dblayer_get_index_file(backend *be, struct attrinfo *a, DB **ppDB, int open_flags)

 {

     /*

-   * We either already have a DB* handle in the attrinfo structure.

-   * in which case we simply return it to the caller, OR:

-   * we need to make one. We do this as follows:

-   * 1a) acquire the mutex that protects the handle list.

-   * 1b) check that the DB* is still null.

-   * 2) get the filename, and call libdb to open it

-   * 3) if successful, store the result in the attrinfo stucture

-   * 4) store the DB* in our own list so we can close it later.

-   * 5) release the mutex.

-   */

+     * We either already have a DB* handle in the attrinfo structure.

+     * in which case we simply return it to the caller, OR:

+     * we need to make one. We do this as follows:

+     * 1a) acquire the mutex that protects the handle list.

+     * 1b) check that the DB* is still null.

+     * 2) get the filename, and call libdb to open it

+     * 3) if successful, store the result in the attrinfo stucture

+     * 4) store the DB* in our own list so we can close it later.

+     * 5) release the mutex.

+     */

     ldbm_instance *inst = (ldbm_instance *)be->be_instance_info;

     int return_value = -1;

     DB *pDB = NULL;

@@ -2878,9 +2878,9 @@ dblayer_get_index_file(backend *be, struct attrinfo *a, DB **ppDB, int open_flag

     *ppDB = NULL;

     /* it's like a semaphore -- when count > 0, any file handle that's in

-   * the attrinfo will remain valid from here on.

-   */

-    __atomic_add_fetch_8(&(a->ai_dblayer_count), 1, __ATOMIC_RELEASE);

+     * the attrinfo will remain valid from here on.

+     */

+    slapi_atomic_incr(&(a->ai_dblayer_count), __ATOMIC_RELEASE, ATOMIC_LONG);

     if (a->ai_dblayer && ((dblayer_handle *)(a->ai_dblayer))->dblayer_dbp) {

         /* This means that the pointer is valid, so we should return it. */

@@ -2888,9 +2888,7 @@ dblayer_get_index_file(backend *be, struct attrinfo *a, DB **ppDB, int open_flag

         return 0;

     }

-    /* attrinfo handle is NULL, at least for now -- grab the mutex and try

-   * again.

-   */

+    /* attrinfo handle is NULL, at least for now -- grab the mutex and try again. */

     PR_Lock(inst->inst_handle_list_mutex);

     if (a->ai_dblayer && ((dblayer_handle *)(a->ai_dblayer))->dblayer_dbp) {

         /* another thread set the handle while we were waiting on the lock */

@@ -2900,8 +2898,8 @@ dblayer_get_index_file(backend *be, struct attrinfo *a, DB **ppDB, int open_flag

     }

     /* attrinfo handle is still blank, and we have the mutex: open the

-   * index file and stuff it in the attrinfo.

-   */

+     * index file and stuff it in the attrinfo.

+     */

     return_value = dblayer_open_file(be, attribute_name, open_flags,

                                      a, &pDB);

     if (0 == return_value) {

@@ -2911,40 +2909,36 @@ dblayer_get_index_file(backend *be, struct attrinfo *a, DB **ppDB, int open_flag

         PR_ASSERT(NULL != pDB);

         /* Store the returned DB* in our own private list of

-       * open files */

+         * open files */

         if (NULL == prev_handle) {

             /* List was empty */

             inst->inst_handle_tail = handle;

             inst->inst_handle_head = handle;

         } else {

-            /* Chain the handle onto the last structure in the

-           * list */

+            /* Chain the handle onto the last structure in the list */

             inst->inst_handle_tail = handle;

             prev_handle->dblayer_handle_next = handle;

         }

-        /* Stash a pointer to our wrapper structure in the

-       * attrinfo structure */

+        /* Stash a pointer to our wrapper structure in the attrinfo structure */

         handle->dblayer_dbp = pDB;

         /* And, most importantly, return something to the caller!*/

         *ppDB = pDB;

-        /* and save the hande in the attrinfo structure for

-       * next time */

+        /* and save the hande in the attrinfo structure for next time */

         a->ai_dblayer = handle;

         /* don't need to update count -- we incr'd it already */

         handle->dblayer_handle_ai_backpointer = &(a->ai_dblayer);

     } else {

         /* Did not open it OK ! */

         /* Do nothing, because return value and fact that we didn't

-     * store a DB* in the attrinfo is enough

-     */

+         * store a DB* in the attrinfo is enough */

     }

     PR_Unlock(inst->inst_handle_list_mutex);

     if (return_value != 0) {

         /* some sort of error -- we didn't open a handle at all.

-     * decrement the refcount back to where it was.

-     */

-        __atomic_sub_fetch_8(&(a->ai_dblayer_count), 1, __ATOMIC_RELEASE);

+         * decrement the refcount back to where it was.

+         */

+        slapi_atomic_decr(&(a->ai_dblayer_count), __ATOMIC_RELEASE, ATOMIC_LONG);

     }

     return return_value;

@@ -2956,7 +2950,7 @@ dblayer_get_index_file(backend *be, struct attrinfo *a, DB **ppDB, int open_flag

 int

 dblayer_release_index_file(backend *be __attribute__((unused)), struct attrinfo *a, DB *pDB __attribute__((unused)))

 {

-    __atomic_sub_fetch_8(&(a->ai_dblayer_count), 1, __ATOMIC_RELEASE);

+    slapi_atomic_decr(&(a->ai_dblayer_count), __ATOMIC_RELEASE, ATOMIC_LONG);

     return 0;

 }

@@ -3063,13 +3057,13 @@ dblayer_erase_index_file_ex(backend *be, struct attrinfo *a, PRBool use_lock, in

             dblayer_release_index_file(be, a, db);

-            while (__atomic_load_8(&(a->ai_dblayer_count), __ATOMIC_ACQUIRE) > 0) {

+            while (slapi_atomic_load(&(a->ai_dblayer_count), __ATOMIC_ACQUIRE, ATOMIC_LONG) > 0) {

                 /* someone is using this index file */

                 /* ASSUMPTION: you have already set the INDEX_OFFLINE flag, because

-         * you intend to mess with this index.  therefore no new requests

-         * for this indexfile should happen, so the dblayer_count should

-         * NEVER increase.

-         */

+                 * you intend to mess with this index.  therefore no new requests

+                 * for this indexfile should happen, so the dblayer_count should

+                 * NEVER increase.

+                 */

                 PR_ASSERT(a->ai_indexmask & INDEX_OFFLINE);

                 PR_Unlock(inst->inst_handle_list_mutex);

                 DS_Sleep(DBLAYER_CACHE_DELAY);

diff --git a/ldap/servers/slapd/entry.c b/ldap/servers/slapd/entry.c

index 62d10c2..289a149 100644

--- a/ldap/servers/slapd/entry.c

+++ b/ldap/servers/slapd/entry.c

@@ -2244,18 +2244,19 @@ slapi_entry_attr_find(const Slapi_Entry *e, const char *type, Slapi_Attr **a)

 /* the following functions control virtual attribute cache invalidation */

-static uint32_t g_virtual_watermark = 0; /* good enough to init */

+static int32_t g_virtual_watermark = 0; /* good enough to init */

 int

 slapi_entry_vattrcache_watermark_isvalid(const Slapi_Entry *e)

 {

-    return e->e_virtual_watermark == __atomic_load_4(&g_virtual_watermark, __ATOMIC_ACQUIRE);

+    return e->e_virtual_watermark == slapi_atomic_load(&g_virtual_watermark, __ATOMIC_ACQUIRE, ATOMIC_INT);

+

 }

 void

 slapi_entry_vattrcache_watermark_set(Slapi_Entry *e)

 {

-    e->e_virtual_watermark = __atomic_load_4(&g_virtual_watermark, __ATOMIC_ACQUIRE);

+    e->e_virtual_watermark = slapi_atomic_load(&g_virtual_watermark, __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 void

@@ -2268,8 +2269,8 @@ void

 slapi_entrycache_vattrcache_watermark_invalidate()

 {

     /* Make sure the value is never 0 */

-    if (__atomic_add_fetch_4(&g_virtual_watermark, 1, __ATOMIC_RELEASE) == 0) {

-        __atomic_add_fetch_4(&g_virtual_watermark, 1, __ATOMIC_RELEASE);

+    if (slapi_atomic_incr(&g_virtual_watermark, __ATOMIC_RELEASE, ATOMIC_INT) == 0) {

+        slapi_atomic_incr(&g_virtual_watermark, __ATOMIC_RELEASE, ATOMIC_INT);

     }

 }

diff --git a/ldap/servers/slapd/libglobs.c b/ldap/servers/slapd/libglobs.c

index 0eeb16a..4c54cf7 100644

--- a/ldap/servers/slapd/libglobs.c

+++ b/ldap/servers/slapd/libglobs.c

@@ -1335,19 +1335,19 @@ static uint64_t active_threads = 0;

 void

 g_incr_active_threadcnt(void)

 {

-    __atomic_add_fetch_8(&active_threads, 1, __ATOMIC_RELEASE);

+    slapi_atomic_incr(&active_threads, __ATOMIC_RELEASE, ATOMIC_LONG);

 }

 void

 g_decr_active_threadcnt(void)

 {

-    __atomic_sub_fetch_8(&active_threads, 1, __ATOMIC_RELEASE);

+    slapi_atomic_decr(&active_threads, __ATOMIC_RELEASE, ATOMIC_LONG);

 }

 uint64_t

 g_get_active_threadcnt(void)

 {

-    return __atomic_load_8(&active_threads, __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&active_threads, __ATOMIC_RELEASE, ATOMIC_LONG);

 }

 /*

@@ -1936,7 +1936,7 @@ config_set_ndn_cache_max_size(const char *attrname, char *value, char *errorbuf,

         size = NDN_DEFAULT_SIZE;

     }

     if (apply) {

-        __atomic_store_8(&(slapdFrontendConfig->ndn_cache_max_size), size, __ATOMIC_RELEASE);

+        slapi_atomic_store(&(slapdFrontendConfig->ndn_cache_max_size), &size, __ATOMIC_RELEASE, ATOMIC_LONG);

     }

     return retVal;

@@ -3476,7 +3476,8 @@ int32_t

 config_get_dynamic_plugins(void)

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->dynamic_plugins), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->dynamic_plugins), __ATOMIC_ACQUIRE, ATOMIC_INT);

+

 }

 int32_t

@@ -3498,7 +3499,7 @@ int32_t

 config_get_cn_uses_dn_syntax_in_dns()

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->cn_uses_dn_syntax_in_dns), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->cn_uses_dn_syntax_in_dns), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 int32_t

@@ -3543,7 +3544,7 @@ config_set_onoff(const char *attrname, char *value, int32_t *configvalue, char *

         newval = LDAP_OFF;

     }

-    __atomic_store_4(configvalue, newval, __ATOMIC_RELEASE);

+    slapi_atomic_store(configvalue, &newval, __ATOMIC_RELEASE, ATOMIC_INT);

     return retVal;

 }

@@ -3915,7 +3916,7 @@ config_set_threadnumber(const char *attrname, char *value, char *errorbuf, int a

         retVal = LDAP_OPERATIONS_ERROR;

     }

     if (apply) {

-        __atomic_store_4(&(slapdFrontendConfig->threadnumber), threadnum, __ATOMIC_RELAXED);

+        slapi_atomic_store(&(slapdFrontendConfig->threadnumber), &threadnum, __ATOMIC_RELAXED, ATOMIC_INT);

     }

     return retVal;

 }

@@ -3944,7 +3945,7 @@ config_set_maxthreadsperconn(const char *attrname, char *value, char *errorbuf,

     }

     if (apply) {

-        __atomic_store_4(&(slapdFrontendConfig->maxthreadsperconn), maxthreadnum, __ATOMIC_RELEASE);

+        slapi_atomic_store(&(slapdFrontendConfig->maxthreadsperconn), &maxthreadnum, __ATOMIC_RELEASE, ATOMIC_INT);

     }

     return retVal;

 }

@@ -4102,7 +4103,7 @@ config_set_ioblocktimeout(const char *attrname, char *value, char *errorbuf, int

     }

     if (apply) {

-        __atomic_store_4(&(slapdFrontendConfig->ioblocktimeout), nValue, __ATOMIC_RELEASE);

+        slapi_atomic_store(&(slapdFrontendConfig->ioblocktimeout), &nValue, __ATOMIC_RELEASE, ATOMIC_INT);

     }

     return retVal;

 }

@@ -4606,21 +4607,22 @@ int32_t

 config_get_sasl_mapping_fallback()

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->sasl_mapping_fallback), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->sasl_mapping_fallback), __ATOMIC_ACQUIRE, ATOMIC_INT);

+

 }

 int32_t

 config_get_disk_monitoring()

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->disk_monitoring), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->disk_monitoring), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 int32_t

 config_get_disk_logging_critical()

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->disk_logging_critical), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->disk_logging_critical), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 int

@@ -4667,14 +4669,14 @@ int32_t

 config_get_ldapi_switch()

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->ldapi_switch), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->ldapi_switch), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 int32_t

 config_get_ldapi_bind_switch()

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->ldapi_bind_switch), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->ldapi_bind_switch), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 char *

@@ -4693,7 +4695,7 @@ int

 config_get_ldapi_map_entries()

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->ldapi_map_entries), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->ldapi_map_entries), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 char *

@@ -4763,7 +4765,8 @@ int32_t

 config_get_slapi_counters()

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->slapi_counters), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->slapi_counters), __ATOMIC_ACQUIRE, ATOMIC_INT);

+

 }

 char *

@@ -4945,7 +4948,7 @@ int32_t

 config_get_pw_change(void)

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->pw_policy.pw_change), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->pw_policy.pw_change), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

@@ -4953,7 +4956,7 @@ int32_t

 config_get_pw_history(void)

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->pw_policy.pw_history), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->pw_policy.pw_history), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

@@ -4961,21 +4964,21 @@ int32_t

 config_get_pw_must_change(void)

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->pw_policy.pw_must_change), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->pw_policy.pw_must_change), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 int32_t

 config_get_allow_hashed_pw(void)

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->allow_hashed_pw), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->allow_hashed_pw), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 int32_t

 config_get_pw_syntax(void)

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->pw_policy.pw_syntax), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->pw_policy.pw_syntax), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

@@ -5164,21 +5167,21 @@ int32_t

 config_get_pw_is_global_policy(void)

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->pw_is_global_policy), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->pw_is_global_policy), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 int32_t

 config_get_pw_is_legacy_policy(void)

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->pw_policy.pw_is_legacy), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->pw_policy.pw_is_legacy), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 int32_t

 config_get_pw_exp(void)

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->pw_policy.pw_exp), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->pw_policy.pw_exp), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

@@ -5186,14 +5189,14 @@ int32_t

 config_get_pw_unlock(void)

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->pw_policy.pw_unlock), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->pw_policy.pw_unlock), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 int32_t

 config_get_pw_lockout()

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->pw_policy.pw_lockout), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->pw_policy.pw_lockout), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 int

@@ -5213,112 +5216,112 @@ int32_t

 config_get_lastmod()

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->lastmod), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->lastmod), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 int32_t

 config_get_enquote_sup_oc()

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->enquote_sup_oc), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->enquote_sup_oc), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 int32_t

 config_get_nagle(void)

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->nagle), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->nagle), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 int32_t

 config_get_accesscontrol(void)

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->accesscontrol), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->accesscontrol), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 int32_t

 config_get_return_exact_case(void)

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->return_exact_case), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->return_exact_case), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 int32_t

 config_get_result_tweak(void)

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->result_tweak), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->result_tweak), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 int32_t

 config_get_moddn_aci(void)

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->moddn_aci), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->moddn_aci), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 int32_t

 config_get_security(void)

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->security), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->security), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 int32_t

 slapi_config_get_readonly(void)

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->readonly), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->readonly), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 int32_t

 config_get_schemacheck(void)

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->schemacheck), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->schemacheck), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 int32_t

 config_get_schemamod(void)

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->schemamod), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->schemamod), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 int32_t

 config_get_syntaxcheck(void)

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->syntaxcheck), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->syntaxcheck), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 int32_t

 config_get_syntaxlogging(void)

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->syntaxlogging), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->syntaxlogging), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 int32_t

 config_get_dn_validate_strict(void)

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->dn_validate_strict), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->dn_validate_strict), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 int32_t

 config_get_ds4_compatible_schema(void)

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->ds4_compatible_schema), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->ds4_compatible_schema), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 int32_t

 config_get_schema_ignore_trailing_spaces(void)

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->schema_ignore_trailing_spaces), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->schema_ignore_trailing_spaces), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 char *

@@ -5402,7 +5405,7 @@ config_get_threadnumber(void)

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

     int32_t retVal;

-    retVal = __atomic_load_4(&(slapdFrontendConfig->threadnumber), __ATOMIC_RELAXED);

+    retVal = slapi_atomic_load(&(slapdFrontendConfig->threadnumber), __ATOMIC_RELAXED, ATOMIC_INT);

     if (retVal <= 0) {

         retVal = util_get_hardware_threads();

@@ -5420,7 +5423,7 @@ int32_t

 config_get_maxthreadsperconn()

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->maxthreadsperconn), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->maxthreadsperconn), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 int

@@ -5452,7 +5455,7 @@ int32_t

 config_get_ioblocktimeout()

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->ioblocktimeout), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->ioblocktimeout), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 int

@@ -5769,21 +5772,21 @@ int32_t

 config_get_unauth_binds_switch(void)

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->allow_unauth_binds), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->allow_unauth_binds), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 int32_t

 config_get_require_secure_binds(void)

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->require_secure_binds), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->require_secure_binds), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 int32_t

 config_get_anon_access_switch(void)

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->allow_anon_access), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->allow_anon_access), __ATOMIC_ACQUIRE, ATOMIC_INT);

 }

 int

@@ -6025,7 +6028,8 @@ int32_t

 config_get_minssf_exclude_rootdse()

 {

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

-    return __atomic_load_4(&(slapdFrontendConfig->minssf_exclude_rootdse), __ATOMIC_ACQUIRE);

+    return slapi_atomic_load(&(slapdFrontendConfig->minssf_exclude_rootdse), __ATOMIC_ACQUIRE, ATOMIC_INT);

+

 }

 int

@@ -6034,18 +6038,17 @@ config_set_max_filter_nest_level(const char *attrname, char *value, char *errorb

     int retVal = LDAP_SUCCESS;

     slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig();

     char *endp;

-    long level;

+    int32_t level;

     if (config_value_is_null(attrname, value, errorbuf, 0)) {

         return LDAP_OPERATIONS_ERROR;

     }

     errno = 0;

-    level = strtol(value, &endp, 10);

+    level = (int32_t)strtol(value, &endp, 10);

     if (*endp != '\0' || errno == ERANGE) {

-        slapi_create_errormsg(errorbuf, SLAPI_DSE_RETURNTEXT_SIZE, "(%s) value (%s) "

-                                                                   "is invalid\n",

-                              attrname, value);

+        slapi_create_errormsg(errorbuf, SLAPI_DSE_RETURNTEXT_SIZE,

+                              "(%s) value (%s) is invalid\n", attrname, value);

         retVal = LDAP_OPERATIONS_ERROR;

         return retVal;

     }

@@ -6054,7 +6057,7 @@ config_set_max_filter_nest_level(const char *attrname, char *value, char *errorb

         return retVal;

     }

-    __atomic_store_4(&(slapdFrontendConfig->max_filter_nest_level), level, __ATOMIC_RELEASE);

+    slapi_atomic_store(&(slapdFrontendConfig->max_filter_nest_level), &level, __ATOMIC_RELEASE, ATOMIC_INT);

     return retVal;

 }

@@ -6062,29 +6065,28 @@ int32_t

 config_get_max_filter_nest_level()

 {