6f51e1
From be621fcd9f2215bba4c9190fd63815dc395814d8 Mon Sep 17 00:00:00 2001
6f51e1
From: Mark Reynolds <mreynolds@redhat.com>
6f51e1
Date: Tue, 28 Mar 2017 11:39:16 -0400
6f51e1
Subject: [PATCH] Issue 48989 - Integer overflow
6f51e1
6f51e1
Redo slapi_counters and monitors
6f51e1
---
6f51e1
 Makefile.am                                        |   4 +-
6f51e1
 configure.ac                                       |  74 +++--
6f51e1
 ldap/servers/plugins/dna/dna.c                     |  20 +-
6f51e1
 ldap/servers/plugins/posix-winsync/posix-winsync.c |  12 +-
6f51e1
 ldap/servers/plugins/replication/repl5_init.c      |   2 +-
6f51e1
 ldap/servers/plugins/replication/repl_extop.c      |   2 +-
6f51e1
 ldap/servers/plugins/usn/usn.c                     |  16 +-
6f51e1
 ldap/servers/slapd/back-ldbm/monitor.c             |   4 +-
6f51e1
 ldap/servers/slapd/back-ldbm/perfctrs.c            |  12 +-
6f51e1
 ldap/servers/slapd/back-ldbm/perfctrs.h            |  74 ++---
6f51e1
 ldap/servers/slapd/back-ldbm/vlv_srch.h            |   2 +-
6f51e1
 ldap/servers/slapd/conntable.c                     |  14 +-
6f51e1
 ldap/servers/slapd/entry.c                         |   4 +-
6f51e1
 ldap/servers/slapd/log.c                           |  13 +-
6f51e1
 ldap/servers/slapd/monitor.c                       |  14 +-
6f51e1
 ldap/servers/slapd/slapi-plugin.h                  |  14 +-
6f51e1
 ldap/servers/slapd/slapi_counter.c                 | 333 ++++-----------------
6f51e1
 ldap/servers/slapd/slapi_counter_sunos_sparcv9.S   | 105 -------
6f51e1
 ldap/servers/slapd/snmp_collator.c                 |   2 +-
6f51e1
 test/libslapd/test.c                               |   2 +
6f51e1
 test/test_slapd.h                                  |   4 +
6f51e1
 21 files changed, 205 insertions(+), 522 deletions(-)
6f51e1
 delete mode 100644 ldap/servers/slapd/slapi_counter_sunos_sparcv9.S
6f51e1
6f51e1
diff --git a/Makefile.am b/Makefile.am
6f51e1
index df4a037..982dd28 100644
6f51e1
--- a/Makefile.am
6f51e1
+++ b/Makefile.am
6f51e1
@@ -1222,9 +1222,6 @@ libslapd_la_SOURCES = ldap/servers/slapd/add.c \
6f51e1
 	$(libavl_a_SOURCES)
6f51e1
 
6f51e1
 libslapd_la_CPPFLAGS = $(AM_CPPFLAGS) $(DSPLUGIN_CPPFLAGS) $(SASL_INCLUDES) @db_inc@ $(SVRCORE_INCLUDES) @kerberos_inc@ @pcre_inc@
6f51e1
-if SPARC
6f51e1
-libslapd_la_SOURCES += ldap/servers/slapd/slapi_counter_sunos_sparcv9.S
6f51e1
-endif
6f51e1
 libslapd_la_LIBADD = $(LDAPSDK_LINK) $(SASL_LINK) $(SVRCORE_LINK) $(NSS_LINK) $(NSPR_LINK) $(KERBEROS_LINK) $(PCRE_LINK) $(THREADLIB) $(SYSTEMD_LINK)
6f51e1
 libslapd_la_LDFLAGS = $(AM_LDFLAGS) $(SLAPD_LDFLAGS)
6f51e1
 
6f51e1
@@ -2004,6 +2001,7 @@ TESTS = test_slapd \
6f51e1
 
6f51e1
 test_slapd_SOURCES = test/main.c \
6f51e1
 	test/libslapd/test.c \
6f51e1
+	test/libslapd/counters/atomic.c \
6f51e1
 	test/libslapd/pblock/analytics.c \
6f51e1
 	test/libslapd/pblock/v3_compat.c \
6f51e1
 	test/libslapd/operation/v3_compat.c
6f51e1
diff --git a/configure.ac b/configure.ac
6f51e1
index 3f2aa75..8172bab 100644
6f51e1
--- a/configure.ac
6f51e1
+++ b/configure.ac
6f51e1
@@ -555,7 +555,6 @@ case $host in
6f51e1
     case $host in
6f51e1
       i*86-*-linux*)
6f51e1
         AC_DEFINE([CPU_x86], [], [cpu type x86])
6f51e1
-        AC_DEFINE([ATOMIC_64BIT_OPERATIONS], [1], [enabling atomic counter])
6f51e1
         ;;
6f51e1
       x86_64-*-linux*)
6f51e1
         with_xsixfour="yes"
6f51e1
@@ -565,23 +564,6 @@ case $host in
6f51e1
         # wibrown -- 2017-02-21 disabled temporarily
6f51e1
         # with_atomic_queue="yes"
6f51e1
         # AC_DEFINE([ATOMIC_QUEUE_OPERATIONS], [1], [enabling atomic queue operations])
6f51e1
-        AC_DEFINE([ATOMIC_64BIT_OPERATIONS], [1], [enabling atomic counter])
6f51e1
-
6f51e1
-        AC_MSG_CHECKING([for SSE4.2 features ...])
6f51e1
-        save_CFLAGS="$CFLAGS"
6f51e1
-        CFLAGS="$CFLAGS -msse4.2"
6f51e1
-        AC_TRY_COMPILE(
6f51e1
-            [],
6f51e1
-            [return 0;],
6f51e1
-            [
6f51e1
-                AC_DEFINE([HAVE_SSE4_2], [1], [Have sss4.2 on this platform arch])
6f51e1
-                AC_MSG_RESULT([SSE4.2 avaliable on this platform])
6f51e1
-            ],
6f51e1
-            [
6f51e1
-                AC_MSG_RESULT([SSE4.2 not avaliable on this platform])
6f51e1
-            ]
6f51e1
-        )
6f51e1
-        CFLAGS="$save_CFLAGS"
6f51e1
         ;;
6f51e1
       aarch64-*-linux*)
6f51e1
         AC_DEFINE([CPU_arm], [], [cpu type arm])
6f51e1
@@ -600,17 +582,6 @@ case $host in
6f51e1
       s390x-*-linux*)
6f51e1
         ;;
6f51e1
     esac
6f51e1
-    AC_MSG_CHECKING([for GCC provided 64-bit atomic bool cas function ...])
6f51e1
-    AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],
6f51e1
-                                    [[long long ptrval = 0, val = 0, newval = 1; (void)__sync_bool_compare_and_swap_8(&ptrval, val, newval);]])],
6f51e1
-                   [AC_DEFINE([HAVE_64BIT_ATOMIC_CAS_FUNC], [1], [have 64-bit atomic bool compare and swap function provided by gcc])AC_MSG_RESULT([yes])],
6f51e1
-                   [AC_MSG_RESULT([no])])
6f51e1
-    AC_MSG_CHECKING([for GCC provided 64-bit atomic ops functions ...])
6f51e1
-    AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],
6f51e1
-                                    [[long long ptrval = 0, val = 0; (void)__sync_add_and_fetch_8(&ptrval, val);]])],
6f51e1
-                   [AC_DEFINE([HAVE_64BIT_ATOMIC_OP_FUNCS], [1], [have 64-bit atomic operation functions provided by gcc])AC_MSG_RESULT([yes])],
6f51e1
-                   [AC_MSG_RESULT([no])])
6f51e1
-
6f51e1
     # some programs use the native thread library directly
6f51e1
     THREADLIB=-lpthread
6f51e1
     AC_SUBST([THREADLIB], [$THREADLIB])
6f51e1
@@ -654,7 +625,6 @@ case $host in
6f51e1
     AC_DEFINE([_POSIX_C_SOURCE], [199506L], [POSIX revision])
6f51e1
     AC_DEFINE([_HPUX_SOURCE], [1], [Source namespace])
6f51e1
     AC_DEFINE([_INCLUDE_STDC__SOURCE_199901], [1], [to pick up all of the printf format macros in inttypes.h])
6f51e1
-    AC_DEFINE([ATOMIC_64BIT_OPERATIONS], [1], [enabling atomic counter])
6f51e1
     # assume 64 bit
6f51e1
     initconfigdir="/$PACKAGE_NAME/config"
6f51e1
     perlexec='/opt/perl_64/bin/perl'
6f51e1
@@ -689,12 +659,11 @@ dnl Cstd and Crun are required to link any C++ related code
6f51e1
     initdir='$(sysconfdir)/init.d'
6f51e1
     case $host in
6f51e1
       i?86-*-solaris2.1[[0-9]]*)
6f51e1
-dnl I dont know why i386 need this explicit
6f51e1
+        dnl I dont know why i386 need this explicit
6f51e1
         AC_DEFINE([HAVE_GETPEERUCRED], [1], [have getpeerucred])
6f51e1
         ;;
6f51e1
       sparc-*-solaris*)
6f51e1
-dnl includes some assembler stuff in counter.o
6f51e1
-        AC_DEFINE([ATOMIC_64BIT_OPERATIONS], [1], [enabling atomic counter])
6f51e1
+        dnl includes some assembler stuff in counter.o
6f51e1
         AC_DEFINE([CPU_sparc], [], [cpu type sparc])
6f51e1
         TARGET='SPARC'
6f51e1
         ;;
6f51e1
@@ -705,6 +674,45 @@ dnl includes some assembler stuff in counter.o
6f51e1
     ;;
6f51e1
 esac
6f51e1
 
6f51e1
+AC_MSG_CHECKING([for SSE4.2 features ...])
6f51e1
+save_CFLAGS="$CFLAGS"
6f51e1
+CFLAGS="$CFLAGS -msse4.2"
6f51e1
+AC_TRY_COMPILE(
6f51e1
+    [],
6f51e1
+    [return 0;],
6f51e1
+    [
6f51e1
+        AC_DEFINE([HAVE_SSE4_2], [1], [Have sss4.2 on this platform arch])
6f51e1
+        AC_MSG_RESULT([SSE4.2 avaliable on this platform])
6f51e1
+    ],
6f51e1
+    [
6f51e1
+        AC_MSG_RESULT([SSE4.2 not avaliable on this platform])
6f51e1
+    ]
6f51e1
+)
6f51e1
+CFLAGS="$save_CFLAGS"
6f51e1
+
6f51e1
+AC_MSG_CHECKING([for GCC provided 64-bit atomic operations])
6f51e1
+AC_LINK_IFELSE([AC_LANG_PROGRAM([[
6f51e1
+    #include <inttypes.h>
6f51e1
+    ]],
6f51e1
+    [[
6f51e1
+    uint64_t t_counter = 0;
6f51e1
+    uint64_t t_oldval = 0;
6f51e1
+    uint64_t t_newval = 1;
6f51e1
+
6f51e1
+    __atomic_compare_exchange_8(&t_counter, &t_oldval, t_newval, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
6f51e1
+    __atomic_add_fetch_8(&t_counter, t_newval, __ATOMIC_SEQ_CST);
6f51e1
+    __atomic_sub_fetch_8(&t_counter, t_newval, __ATOMIC_SEQ_CST);
6f51e1
+    __atomic_load(&t_counter, &t_oldval, __ATOMIC_SEQ_CST);
6f51e1
+    return 0;
6f51e1
+    ]])],
6f51e1
+    [
6f51e1
+        AC_DEFINE([ATOMIC_64BIT_OPERATIONS], [1], [have 64-bit atomic operation functions provided by gcc])
6f51e1
+        AC_MSG_RESULT([yes])
6f51e1
+    ],
6f51e1
+    [
6f51e1
+        AC_MSG_RESULT([no])
6f51e1
+    ]
6f51e1
+)
6f51e1
 
6f51e1
 # cmd line overrides default setting above
6f51e1
 if test -n "$with_initddir" ; then
6f51e1
diff --git a/ldap/servers/plugins/dna/dna.c b/ldap/servers/plugins/dna/dna.c
6f51e1
index 54bbe86..34011b9 100644
6f51e1
--- a/ldap/servers/plugins/dna/dna.c
6f51e1
+++ b/ldap/servers/plugins/dna/dna.c
6f51e1
@@ -2497,7 +2497,7 @@ static int dna_get_next_value(struct configEntry *config_entry,
6f51e1
     if ((config_entry->maxval == -1) ||
6f51e1
         (nextval <= (config_entry->maxval + config_entry->interval))) {
6f51e1
         /* try to set the new next value in the config entry */
6f51e1
-        PR_snprintf(next_value, sizeof(next_value),"%" NSPRIu64, nextval);
6f51e1
+        snprintf(next_value, sizeof(next_value),"%" NSPRIu64, nextval);
6f51e1
 
6f51e1
         /* set up our replace modify operation */
6f51e1
         replace_val[0] = next_value;
6f51e1
@@ -2565,13 +2565,13 @@ dna_get_shared_config_attr_val(struct configEntry *config_entry, char *attr, cha
6f51e1
             if(slapi_sdn_compare(server->sdn, server_sdn) == 0){
6f51e1
                 if(strcmp(attr, DNA_REMOTE_BIND_METHOD) == 0){
6f51e1
                     if (server->remote_bind_method) {
6f51e1
-                        PR_snprintf(value, DNA_REMOTE_BUFSIZ, "%s", server->remote_bind_method);
6f51e1
+                        snprintf(value, DNA_REMOTE_BUFSIZ, "%s", server->remote_bind_method);
6f51e1
                         found = 1;
6f51e1
                     }
6f51e1
                     break;
6f51e1
                 } else if(strcmp(attr, DNA_REMOTE_CONN_PROT) == 0){
6f51e1
                     if (server->remote_conn_prot) {
6f51e1
-                        PR_snprintf(value, DNA_REMOTE_BUFSIZ, "%s", server->remote_conn_prot);
6f51e1
+                        snprintf(value, DNA_REMOTE_BUFSIZ, "%s", server->remote_conn_prot);
6f51e1
                         found = 1;
6f51e1
                     }
6f51e1
                     break;
6f51e1
@@ -2609,7 +2609,7 @@ dna_update_shared_config(struct configEntry *config_entry)
6f51e1
 
6f51e1
         /* We store the number of remaining assigned values
6f51e1
          * in the shared config entry. */
6f51e1
-        PR_snprintf(remaining_vals, sizeof(remaining_vals),"%" NSPRIu64,
6f51e1
+        snprintf(remaining_vals, sizeof(remaining_vals),"%" NSPRIu64,
6f51e1
                 config_entry->remaining);
6f51e1
 
6f51e1
         /* set up our replace modify operation */
6f51e1
@@ -2709,7 +2709,7 @@ dna_update_next_range(struct configEntry *config_entry,
6f51e1
     int ret = 0;
6f51e1
 
6f51e1
     /* Try to set the new next range in the config entry. */
6f51e1
-    PR_snprintf(nextrange_value, sizeof(nextrange_value), "%" NSPRIu64 "-%" NSPRIu64,
6f51e1
+    snprintf(nextrange_value, sizeof(nextrange_value), "%" NSPRIu64 "-%" NSPRIu64,
6f51e1
     		lower, upper);
6f51e1
 
6f51e1
     /* set up our replace modify operation */
6f51e1
@@ -2778,8 +2778,8 @@ dna_activate_next_range(struct configEntry *config_entry)
6f51e1
     int ret = 0;
6f51e1
 
6f51e1
     /* Setup the modify operation for the config entry */
6f51e1
-    PR_snprintf(maxval_val, sizeof(maxval_val),"%" NSPRIu64, config_entry->next_range_upper);
6f51e1
-    PR_snprintf(nextval_val, sizeof(nextval_val),"%" NSPRIu64, config_entry->next_range_lower);
6f51e1
+    snprintf(maxval_val, sizeof(maxval_val),"%" NSPRIu64, config_entry->next_range_upper);
6f51e1
+    snprintf(nextval_val, sizeof(nextval_val),"%" NSPRIu64, config_entry->next_range_lower);
6f51e1
 
6f51e1
     maxval_vals[0] = maxval_val;
6f51e1
     maxval_vals[1] = 0;
6f51e1
@@ -4411,8 +4411,8 @@ static int dna_extend_exop(Slapi_PBlock *pb)
6f51e1
         char highstr[16];
6f51e1
 
6f51e1
         /* Create the exop response */
6f51e1
-        PR_snprintf(lowstr, sizeof(lowstr), "%" NSPRIu64, lower);
6f51e1
-        PR_snprintf(highstr, sizeof(highstr), "%" NSPRIu64, upper);
6f51e1
+        snprintf(lowstr, sizeof(lowstr), "%" NSPRIu64, lower);
6f51e1
+        snprintf(highstr, sizeof(highstr), "%" NSPRIu64, upper);
6f51e1
         range_low.bv_val = lowstr;
6f51e1
         range_low.bv_len = strlen(range_low.bv_val);
6f51e1
         range_high.bv_val = highstr;
6f51e1
@@ -4588,7 +4588,7 @@ dna_release_range(char *range_dn, PRUint64 *lower, PRUint64 *upper)
6f51e1
                 *lower = *upper - release + 1;
6f51e1
 
6f51e1
                 /* try to set the new maxval in the config entry */
6f51e1
-                PR_snprintf(max_value, sizeof(max_value),"%" NSPRIu64, (*lower - 1));
6f51e1
+                snprintf(max_value, sizeof(max_value),"%" NSPRIu64, (*lower - 1));
6f51e1
 
6f51e1
                 /* set up our replace modify operation */
6f51e1
                 replace_val[0] = max_value;
6f51e1
diff --git a/ldap/servers/plugins/posix-winsync/posix-winsync.c b/ldap/servers/plugins/posix-winsync/posix-winsync.c
6f51e1
index a7e024d..63444e5 100644
6f51e1
--- a/ldap/servers/plugins/posix-winsync/posix-winsync.c
6f51e1
+++ b/ldap/servers/plugins/posix-winsync/posix-winsync.c
6f51e1
@@ -234,7 +234,7 @@ sync_acct_disable(void *cbdata, /* the usual domain config data */
6f51e1
 {
6f51e1
     int ds_is_enabled = 1; /* default to true */
6f51e1
     int ad_is_enabled = 1; /* default to true */
6f51e1
-    unsigned long adval = 0; /* raw account val from ad entry */
6f51e1
+    uint64_t adval = 0; /* raw account val from ad entry */
6f51e1
     int isvirt = 0;
6f51e1
 
6f51e1
     /* get the account lock state of the ds entry */
6f51e1
@@ -270,9 +270,8 @@ sync_acct_disable(void *cbdata, /* the usual domain config data */
6f51e1
         if (update_entry) {
6f51e1
             slapi_entry_attr_set_ulong(update_entry, "userAccountControl", adval);
6f51e1
             slapi_log_err(SLAPI_LOG_PLUGIN, posix_winsync_plugin_name,
6f51e1
-                            "<-- sync_acct_disable - %s AD account [%s] - "
6f51e1
-                                "new value is [%ld]\n", (ds_is_enabled) ? "enabled" : "disabled",
6f51e1
-                            slapi_entry_get_dn_const(update_entry), adval);
6f51e1
+                "<-- sync_acct_disable - %s AD account [%s] - new value is [%" NSPRIu64 "]\n",
6f51e1
+				(ds_is_enabled) ? "enabled" : "disabled", slapi_entry_get_dn_const(update_entry), adval);
6f51e1
         } else {
6f51e1
             /* iterate through the mods - if there is already a mod
6f51e1
              for userAccountControl, change it - otherwise, add it */
6f51e1
@@ -327,9 +326,8 @@ sync_acct_disable(void *cbdata, /* the usual domain config data */
6f51e1
                 mod_bval->bv_len = strlen(acctvalstr);
6f51e1
             }
6f51e1
             slapi_log_err(SLAPI_LOG_PLUGIN, posix_winsync_plugin_name,
6f51e1
-                            "<-- sync_acct_disable - %s AD account [%s] - "
6f51e1
-                                "new value is [%ld]\n", (ds_is_enabled) ? "enabled" : "disabled",
6f51e1
-                            slapi_entry_get_dn_const(ad_entry), adval);
6f51e1
+                "<-- sync_acct_disable - %s AD account [%s] - new value is [%" NSPRIu64 "]\n",
6f51e1
+				(ds_is_enabled) ? "enabled" : "disabled", slapi_entry_get_dn_const(ad_entry), adval);
6f51e1
         }
6f51e1
     }
6f51e1
 
6f51e1
diff --git a/ldap/servers/plugins/replication/repl5_init.c b/ldap/servers/plugins/replication/repl5_init.c
6f51e1
index 0945f7b..9549dcf 100644
6f51e1
--- a/ldap/servers/plugins/replication/repl5_init.c
6f51e1
+++ b/ldap/servers/plugins/replication/repl5_init.c
6f51e1
@@ -208,7 +208,7 @@ get_repl_session_id (Slapi_PBlock *pb, char *idstr, CSN **csn)
6f51e1
 		/* Avoid "Connection is NULL and hence cannot access SLAPI_CONN_ID" */
6f51e1
 		if (opid) {
6f51e1
 			slapi_pblock_get (pb, SLAPI_CONN_ID, &connid);
6f51e1
-			PR_snprintf (idstr, REPL_SESSION_ID_SIZE, "conn=%" NSPRIu64 " op=%d",
6f51e1
+			snprintf (idstr, REPL_SESSION_ID_SIZE, "conn=%" NSPRIu64 " op=%d",
6f51e1
 					connid, opid);
6f51e1
 		}
6f51e1
 
6f51e1
diff --git a/ldap/servers/plugins/replication/repl_extop.c b/ldap/servers/plugins/replication/repl_extop.c
6f51e1
index 948f38d..80580f9 100644
6f51e1
--- a/ldap/servers/plugins/replication/repl_extop.c
6f51e1
+++ b/ldap/servers/plugins/replication/repl_extop.c
6f51e1
@@ -865,7 +865,7 @@ multimaster_extop_StartNSDS50ReplicationRequest(Slapi_PBlock *pb)
6f51e1
 	 * the session's conn id and op id to identify the the supplier.
6f51e1
 	 */
6f51e1
 	/* junkrc = ruv_get_first_id_and_purl(supplier_ruv, &junkrid, &locking_purl); */
6f51e1
-	PR_snprintf(locking_session, sizeof(locking_session), "conn=%" NSPRIu64 " id=%d",
6f51e1
+	snprintf(locking_session, sizeof(locking_session), "conn=%" NSPRIu64 " id=%d",
6f51e1
 			connid, opid);
6f51e1
 	locking_purl = &locking_session[0];
6f51e1
 	if (replica_get_exclusive_access(replica, &isInc, connid, opid,
6f51e1
diff --git a/ldap/servers/plugins/usn/usn.c b/ldap/servers/plugins/usn/usn.c
6f51e1
index 6fe8d2e..5e67e0a 100644
6f51e1
--- a/ldap/servers/plugins/usn/usn.c
6f51e1
+++ b/ldap/servers/plugins/usn/usn.c
6f51e1
@@ -360,7 +360,7 @@ _usn_mod_next_usn(LDAPMod ***mods, Slapi_Backend *be)
6f51e1
 
6f51e1
     /* add next USN to the mods; "be" contains the usn counter */
6f51e1
     usn_berval.bv_val = counter_buf;
6f51e1
-    PR_snprintf(usn_berval.bv_val, USN_COUNTER_BUF_LEN, "%" NSPRIu64, 
6f51e1
+    snprintf(usn_berval.bv_val, USN_COUNTER_BUF_LEN, "%" NSPRIu64,
6f51e1
                 slapi_counter_get_value(be->be_usn_counter));
6f51e1
     usn_berval.bv_len = strlen(usn_berval.bv_val);
6f51e1
     bvals[0] = &usn_berval;
6f51e1
@@ -670,7 +670,7 @@ usn_rootdse_search(Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entry* entryAfter,
6f51e1
         /* nsslapd-entryusn-global: on*/
6f51e1
         /* root dse shows ...
6f51e1
          * lastusn: <num> */
6f51e1
-        PR_snprintf(attr, USN_LAST_USN_ATTR_CORE_LEN + 1, "%s", USN_LAST_USN);
6f51e1
+        snprintf(attr, USN_LAST_USN_ATTR_CORE_LEN + 1, "%s", USN_LAST_USN);
6f51e1
         for (be = slapi_get_first_backend(&cookie); be;
6f51e1
              be = slapi_get_next_backend(cookie)) {
6f51e1
             if (be->be_usn_counter) {
6f51e1
@@ -681,10 +681,10 @@ usn_rootdse_search(Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entry* entryAfter,
6f51e1
             /* get a next USN counter from be_usn_counter; 
6f51e1
              * then minus 1 from it (except if be_usn_counter has value 0) */
6f51e1
             if (slapi_counter_get_value(be->be_usn_counter)) {
6f51e1
-                PR_snprintf(usn_berval.bv_val, USN_COUNTER_BUF_LEN, "%" NSPRIu64,
6f51e1
+                snprintf(usn_berval.bv_val, USN_COUNTER_BUF_LEN, "%" NSPRIu64,
6f51e1
                             slapi_counter_get_value(be->be_usn_counter)-1);
6f51e1
             } else {
6f51e1
-                PR_snprintf(usn_berval.bv_val, USN_COUNTER_BUF_LEN, "-1");
6f51e1
+                snprintf(usn_berval.bv_val, USN_COUNTER_BUF_LEN, "-1");
6f51e1
             }
6f51e1
             usn_berval.bv_len = strlen(usn_berval.bv_val);
6f51e1
             slapi_entry_attr_replace(e, attr, vals);
6f51e1
@@ -693,7 +693,7 @@ usn_rootdse_search(Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entry* entryAfter,
6f51e1
         /* nsslapd-entryusn-global: off (default) */
6f51e1
         /* root dse shows ...
6f51e1
          * lastusn;<backend>: <num> */
6f51e1
-        PR_snprintf(attr, USN_LAST_USN_ATTR_CORE_LEN + 2, "%s;", USN_LAST_USN);
6f51e1
+        snprintf(attr, USN_LAST_USN_ATTR_CORE_LEN + 2, "%s;", USN_LAST_USN);
6f51e1
         attr_subp = attr + USN_LAST_USN_ATTR_CORE_LEN + 1;
6f51e1
         for (be = slapi_get_first_backend(&cookie); be;
6f51e1
              be = slapi_get_next_backend(cookie)) {
6f51e1
@@ -704,10 +704,10 @@ usn_rootdse_search(Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entry* entryAfter,
6f51e1
             /* get a next USN counter from be_usn_counter; 
6f51e1
              * then minus 1 from it (except if be_usn_counter has value 0) */
6f51e1
             if (slapi_counter_get_value(be->be_usn_counter)) {
6f51e1
-                PR_snprintf(usn_berval.bv_val, USN_COUNTER_BUF_LEN, "%" NSPRIu64,
6f51e1
+                snprintf(usn_berval.bv_val, USN_COUNTER_BUF_LEN, "%" NSPRIu64,
6f51e1
                             slapi_counter_get_value(be->be_usn_counter)-1);
6f51e1
             } else {
6f51e1
-                PR_snprintf(usn_berval.bv_val, USN_COUNTER_BUF_LEN, "-1");
6f51e1
+                snprintf(usn_berval.bv_val, USN_COUNTER_BUF_LEN, "-1");
6f51e1
             }
6f51e1
             usn_berval.bv_len = strlen(usn_berval.bv_val);
6f51e1
     
6f51e1
@@ -716,7 +716,7 @@ usn_rootdse_search(Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entry* entryAfter,
6f51e1
                 attr = (char *)slapi_ch_realloc(attr, attr_len);
6f51e1
                 attr_subp = attr + USN_LAST_USN_ATTR_CORE_LEN;
6f51e1
             }
6f51e1
-            PR_snprintf(attr_subp, attr_len - USN_LAST_USN_ATTR_CORE_LEN,
6f51e1
+            snprintf(attr_subp, attr_len - USN_LAST_USN_ATTR_CORE_LEN,
6f51e1
                                     "%s", be->be_name);
6f51e1
             slapi_entry_attr_replace(e, attr, vals);
6f51e1
         }
6f51e1
diff --git a/ldap/servers/slapd/back-ldbm/monitor.c b/ldap/servers/slapd/back-ldbm/monitor.c
6f51e1
index dfcc735..757792b 100644
6f51e1
--- a/ldap/servers/slapd/back-ldbm/monitor.c
6f51e1
+++ b/ldap/servers/slapd/back-ldbm/monitor.c
6f51e1
@@ -26,7 +26,7 @@
6f51e1
 
6f51e1
 #define MSETF(_attr, _x) do { \
6f51e1
     char tmp_atype[37]; \
6f51e1
-    PR_snprintf(tmp_atype, sizeof(tmp_atype), _attr, _x); \
6f51e1
+    snprintf(tmp_atype, sizeof(tmp_atype), _attr, _x); \
6f51e1
     MSET(tmp_atype); \
6f51e1
 } while (0)
6f51e1
 
6f51e1
@@ -86,7 +86,7 @@ int ldbm_back_monitor_instance_search(Slapi_PBlock *pb, Slapi_Entry *e,
6f51e1
     MSET("entryCacheHits");
6f51e1
     sprintf(buf, "%lu", (long unsigned int)tries);
6f51e1
     MSET("entryCacheTries");
6f51e1
-    sprintf(buf, "%lu", (unsigned long)(100.0*(double)hits / (double)(tries > 0 ? tries : 1)));
6f51e1
+    sprintf(buf, "%lu", (long unsigned int)(100.0*(double)hits / (double)(tries > 0 ? tries : 1)));
6f51e1
     MSET("entryCacheHitRatio");
6f51e1
     sprintf(buf, "%lu", (long unsigned int)size);
6f51e1
     MSET("currentEntryCacheSize");
6f51e1
diff --git a/ldap/servers/slapd/back-ldbm/perfctrs.c b/ldap/servers/slapd/back-ldbm/perfctrs.c
6f51e1
index 2bd18bd..5929dea 100644
6f51e1
--- a/ldap/servers/slapd/back-ldbm/perfctrs.c
6f51e1
+++ b/ldap/servers/slapd/back-ldbm/perfctrs.c
6f51e1
@@ -49,7 +49,7 @@
6f51e1
 
6f51e1
 static void perfctrs_update(perfctrs_private *priv, DB_ENV *db_env);
6f51e1
 static void perfctr_add_to_entry( Slapi_Entry *e, char *type,
6f51e1
-	PRUint32 countervalue );
6f51e1
+	uint64_t countervalue );
6f51e1
 
6f51e1
 /* Init perf ctrs */
6f51e1
 void perfctrs_init(struct ldbminfo *li, perfctrs_private **ret_priv)
6f51e1
@@ -304,17 +304,13 @@ perfctrs_as_entry( Slapi_Entry *e, perfctrs_private *priv, DB_ENV *db_env )
6f51e1
      */
6f51e1
     for ( i = 0; i < SLAPI_LDBM_PERFCTR_AT_MAP_COUNT; ++i ) {
6f51e1
         perfctr_add_to_entry( e, perfctr_at_map[i].pam_type,
6f51e1
-            *((PRUint32 *)((char *)perf + perfctr_at_map[i].pam_offset)));
6f51e1
+            *((uint64_t *)((char *)perf + perfctr_at_map[i].pam_offset)));
6f51e1
     }
6f51e1
 }
6f51e1
 
6f51e1
 
6f51e1
 static void
6f51e1
-perfctr_add_to_entry( Slapi_Entry *e, char *type, PRUint32 countervalue )
6f51e1
+perfctr_add_to_entry( Slapi_Entry *e, char *type, uint64_t countervalue )
6f51e1
 {
6f51e1
-	/*
6f51e1
-	 * XXXmcs: the following line assumes that long's are 32 bits or larger,
6f51e1
-	 * which we assume in other places too I am sure.
6f51e1
-	 */
6f51e1
-	slapi_entry_attr_set_ulong( e, type, (unsigned long)countervalue );
6f51e1
+	slapi_entry_attr_set_ulong( e, type, countervalue );
6f51e1
 }
6f51e1
diff --git a/ldap/servers/slapd/back-ldbm/perfctrs.h b/ldap/servers/slapd/back-ldbm/perfctrs.h
6f51e1
index 65a7850..57be1d1 100644
6f51e1
--- a/ldap/servers/slapd/back-ldbm/perfctrs.h
6f51e1
+++ b/ldap/servers/slapd/back-ldbm/perfctrs.h
6f51e1
@@ -11,46 +11,48 @@
6f51e1
 #  include <config.h>
6f51e1
 #endif
6f51e1
 
6f51e1
+#include <inttypes.h>
6f51e1
+
6f51e1
 /* Structure definition for performance data */
6f51e1
 /* This stuff goes in shared memory, so make sure the packing is consistent */
6f51e1
 
6f51e1
 struct _performance_counters {
6f51e1
-	PRUint32	sequence_number;
6f51e1
-	PRUint32    lock_region_wait_rate;
6f51e1
-	PRUint32    deadlock_rate;
6f51e1
-	PRUint32    configured_locks;
6f51e1
-	PRUint32    current_locks;
6f51e1
-	PRUint32    max_locks;
6f51e1
-	PRUint32    lockers;
6f51e1
-	PRUint32    current_lock_objects;
6f51e1
-	PRUint32    max_lock_objects;
6f51e1
-	PRUint32    lock_conflicts;
6f51e1
-	PRUint32    lock_request_rate;
6f51e1
-	PRUint32    log_region_wait_rate;
6f51e1
-	PRUint32    log_write_rate;
6f51e1
-	PRUint32    log_bytes_since_checkpoint;
6f51e1
-	PRUint32    cache_size_bytes;
6f51e1
-	PRUint32    page_access_rate;
6f51e1
-	PRUint32    cache_hit;
6f51e1
-	PRUint32    cache_try;
6f51e1
-	PRUint32    page_create_rate;
6f51e1
-	PRUint32    page_read_rate;
6f51e1
-	PRUint32    page_write_rate;
6f51e1
-	PRUint32    page_ro_evict_rate;
6f51e1
-	PRUint32    page_rw_evict_rate;
6f51e1
-	PRUint32    hash_buckets;
6f51e1
-	PRUint32    hash_search_rate;
6f51e1
-	PRUint32    longest_chain_length;
6f51e1
-	PRUint32    hash_elements_examine_rate;
6f51e1
-	PRUint32    pages_in_use;
6f51e1
-	PRUint32    dirty_pages;
6f51e1
-	PRUint32    clean_pages;
6f51e1
-	PRUint32    page_trickle_rate;
6f51e1
-	PRUint32    cache_region_wait_rate;
6f51e1
-	PRUint32    active_txns;
6f51e1
-	PRUint32    commit_rate;
6f51e1
-	PRUint32    abort_rate;
6f51e1
-	PRUint32    txn_region_wait_rate;
6f51e1
+	uint64_t	sequence_number;
6f51e1
+	uint64_t    lock_region_wait_rate;
6f51e1
+	uint64_t    deadlock_rate;
6f51e1
+	uint64_t    configured_locks;
6f51e1
+	uint64_t    current_locks;
6f51e1
+	uint64_t    max_locks;
6f51e1
+	uint64_t    lockers;
6f51e1
+	uint64_t    current_lock_objects;
6f51e1
+	uint64_t    max_lock_objects;
6f51e1
+	uint64_t    lock_conflicts;
6f51e1
+	uint64_t    lock_request_rate;
6f51e1
+	uint64_t    log_region_wait_rate;
6f51e1
+	uint64_t    log_write_rate;
6f51e1
+	uint64_t    log_bytes_since_checkpoint;
6f51e1
+	uint64_t    cache_size_bytes;
6f51e1
+	uint64_t    page_access_rate;
6f51e1
+	uint64_t    cache_hit;
6f51e1
+	uint64_t    cache_try;
6f51e1
+	uint64_t    page_create_rate;
6f51e1
+	uint64_t    page_read_rate;
6f51e1
+	uint64_t    page_write_rate;
6f51e1
+	uint64_t    page_ro_evict_rate;
6f51e1
+	uint64_t    page_rw_evict_rate;
6f51e1
+	uint64_t    hash_buckets;
6f51e1
+	uint64_t    hash_search_rate;
6f51e1
+	uint64_t    longest_chain_length;
6f51e1
+	uint64_t    hash_elements_examine_rate;
6f51e1
+	uint64_t    pages_in_use;
6f51e1
+	uint64_t    dirty_pages;
6f51e1
+	uint64_t    clean_pages;
6f51e1
+	uint64_t    page_trickle_rate;
6f51e1
+	uint64_t    cache_region_wait_rate;
6f51e1
+	uint64_t    active_txns;
6f51e1
+	uint64_t    commit_rate;
6f51e1
+	uint64_t    abort_rate;
6f51e1
+	uint64_t    txn_region_wait_rate;
6f51e1
 };
6f51e1
 typedef struct _performance_counters performance_counters;
6f51e1
 
6f51e1
diff --git a/ldap/servers/slapd/back-ldbm/vlv_srch.h b/ldap/servers/slapd/back-ldbm/vlv_srch.h
6f51e1
index d1eba08..6322f80 100644
6f51e1
--- a/ldap/servers/slapd/back-ldbm/vlv_srch.h
6f51e1
+++ b/ldap/servers/slapd/back-ldbm/vlv_srch.h
6f51e1
@@ -92,7 +92,7 @@ struct vlvIndex
6f51e1
     time_t vlv_lastchecked;
6f51e1
 
6f51e1
     /* The number of uses this search has received since start up */
6f51e1
-    PRUint32 vlv_uses;
6f51e1
+    uint64_t vlv_uses;
6f51e1
 
6f51e1
 	struct backend* vlv_be; /* need backend to remove the index when done */
6f51e1
 
6f51e1
diff --git a/ldap/servers/slapd/conntable.c b/ldap/servers/slapd/conntable.c
6f51e1
index 004aeae..bcafa4e 100644
6f51e1
--- a/ldap/servers/slapd/conntable.c
6f51e1
+++ b/ldap/servers/slapd/conntable.c
6f51e1
@@ -395,7 +395,7 @@ connection_table_as_entry(Connection_Table *ct, Slapi_Entry *e)
6f51e1
 			 * 3 = The number of operations attempted that were blocked
6f51e1
 			 *     by max threads.
6f51e1
 			 */
6f51e1
-			PR_snprintf(maxthreadbuf, sizeof(maxthreadbuf), "%d:%"NSPRIu64":%"NSPRIu64"",
6f51e1
+			snprintf(maxthreadbuf, sizeof(maxthreadbuf), "%d:%"NSPRIu64":%"NSPRIu64"",
6f51e1
 				maxthreadstate, ct->c[i].c_maxthreadscount,
6f51e1
 				ct->c[i].c_maxthreadsblocked);
6f51e1
 
6f51e1
@@ -426,32 +426,32 @@ connection_table_as_entry(Connection_Table *ct, Slapi_Entry *e)
6f51e1
 		PR_ExitMonitor(ct->c[i].c_mutex);
6f51e1
 	}
6f51e1
 
6f51e1
-	PR_snprintf( buf, sizeof(buf), "%d", nconns );
6f51e1
+	snprintf( buf, sizeof(buf), "%d", nconns );
6f51e1
 	val.bv_val = buf;
6f51e1
 	val.bv_len = strlen( buf );
6f51e1
 	attrlist_replace( &e->e_attrs, "currentconnections", vals );
6f51e1
 
6f51e1
-	PR_snprintf( buf, sizeof(buf), "%" NSPRIu64, slapi_counter_get_value(num_conns));
6f51e1
+	snprintf( buf, sizeof(buf), "%" NSPRIu64, slapi_counter_get_value(num_conns));
6f51e1
 	val.bv_val = buf;
6f51e1
 	val.bv_len = strlen( buf );
6f51e1
 	attrlist_replace( &e->e_attrs, "totalconnections", vals );
6f51e1
 
6f51e1
-	PR_snprintf( buf, sizeof(buf), "%" NSPRIu64, slapi_counter_get_value(conns_in_maxthreads));
6f51e1
+	snprintf( buf, sizeof(buf), "%" NSPRIu64, slapi_counter_get_value(conns_in_maxthreads));
6f51e1
 	val.bv_val = buf;
6f51e1
 	val.bv_len = strlen( buf );
6f51e1
 	attrlist_replace( &e->e_attrs, "currentconnectionsatmaxthreads", vals );
6f51e1
 
6f51e1
-	PR_snprintf( buf, sizeof(buf), "%" NSPRIu64, slapi_counter_get_value(max_threads_count));
6f51e1
+	snprintf( buf, sizeof(buf), "%" NSPRIu64, slapi_counter_get_value(max_threads_count));
6f51e1
 	val.bv_val = buf;
6f51e1
 	val.bv_len = strlen( buf );
6f51e1
 	attrlist_replace( &e->e_attrs, "maxthreadsperconnhits", vals );
6f51e1
 
6f51e1
-	PR_snprintf( buf, sizeof(buf), "%d", (ct!=NULL?ct->size:0) );
6f51e1
+	snprintf( buf, sizeof(buf), "%d", (ct!=NULL?ct->size:0) );
6f51e1
 	val.bv_val = buf;
6f51e1
 	val.bv_len = strlen( buf );
6f51e1
 	attrlist_replace( &e->e_attrs, "dtablesize", vals );
6f51e1
 
6f51e1
-	PR_snprintf( buf, sizeof(buf), "%d", nreadwaiters );
6f51e1
+	snprintf( buf, sizeof(buf), "%d", nreadwaiters );
6f51e1
 	val.bv_val = buf;
6f51e1
 	val.bv_len = strlen( buf );
6f51e1
 	attrlist_replace( &e->e_attrs, "readwaiters", vals );
6f51e1
diff --git a/ldap/servers/slapd/entry.c b/ldap/servers/slapd/entry.c
6f51e1
index 7bbd2f4..abacc57 100644
6f51e1
--- a/ldap/servers/slapd/entry.c
6f51e1
+++ b/ldap/servers/slapd/entry.c
6f51e1
@@ -3088,14 +3088,14 @@ slapi_entry_attr_set_longlong( Slapi_Entry* e, const char *type, long long l)
6f51e1
 }
6f51e1
 
6f51e1
 void
6f51e1
-slapi_entry_attr_set_ulong( Slapi_Entry* e, const char *type, unsigned long l)
6f51e1
+slapi_entry_attr_set_ulong( Slapi_Entry* e, const char *type, uint64_t l)
6f51e1
 {
6f51e1
     char value[16];
6f51e1
 	struct berval bv;
6f51e1
 	struct berval *bvals[2];
6f51e1
 	bvals[0] = &bv;
6f51e1
 	bvals[1] = NULL;
6f51e1
-    sprintf(value,"%lu",l);
6f51e1
+    sprintf(value,"%" NSPRIu64, l);
6f51e1
 	bv.bv_val = value;
6f51e1
 	bv.bv_len = strlen( value );
6f51e1
     slapi_entry_attr_replace( e, type, bvals );
6f51e1
diff --git a/ldap/servers/slapd/log.c b/ldap/servers/slapd/log.c
6f51e1
index 2f43a98..afedd5b 100644
6f51e1
--- a/ldap/servers/slapd/log.c
6f51e1
+++ b/ldap/servers/slapd/log.c
6f51e1
@@ -2327,11 +2327,11 @@ vslapd_log_error(
6f51e1
     char      buffer[SLAPI_LOG_BUFSIZ];
6f51e1
     char      sev_name[10];
6f51e1
     int       blen = TBUFSIZE;
6f51e1
-    char      *vbuf;
6f51e1
+    char      *vbuf = NULL;
6f51e1
     int       header_len = 0;
6f51e1
     int       err = 0;
6f51e1
 
6f51e1
-    if ((vbuf = PR_vsmprintf(fmt, ap)) == NULL) {
6f51e1
+    if (vasprintf(&vbuf, fmt, ap) == -1) {
6f51e1
         log__error_emergency("CRITICAL: vslapd_log_error, Unable to format message", 1 , locked);
6f51e1
         return -1;
6f51e1
     }
6f51e1
@@ -2381,10 +2381,10 @@ vslapd_log_error(
6f51e1
     /* blen = strlen(buffer); */
6f51e1
     /* This truncates again .... But we have the nice smprintf above! */
6f51e1
     if (subsystem == NULL) {
6f51e1
-        PR_snprintf (buffer+blen, sizeof(buffer)-blen, "- %s - %s",
6f51e1
+        snprintf (buffer+blen, sizeof(buffer)-blen, "- %s - %s",
6f51e1
                      get_log_sev_name(sev_level, sev_name), vbuf);
6f51e1
     } else {
6f51e1
-        PR_snprintf (buffer+blen, sizeof(buffer)-blen, "- %s - %s - %s",
6f51e1
+        snprintf (buffer+blen, sizeof(buffer)-blen, "- %s - %s - %s",
6f51e1
                      get_log_sev_name(sev_level, sev_name), subsystem, vbuf);
6f51e1
     }
6f51e1
 
6f51e1
@@ -2418,7 +2418,7 @@ vslapd_log_error(
6f51e1
         g_set_shutdown( SLAPI_SHUTDOWN_EXIT );
6f51e1
     }
6f51e1
 
6f51e1
-    PR_smprintf_free (vbuf);
6f51e1
+    slapi_ch_free_string(&vbuf);
6f51e1
     return( 0 );
6f51e1
 }
6f51e1
 
6f51e1
@@ -2520,8 +2520,7 @@ static int vslapd_log_access(char *fmt, va_list ap)
6f51e1
     time_t tnl;
6f51e1
 
6f51e1
     /* We do this sooner, because that we we can use the message in other calls */
6f51e1
-    vlen = PR_vsnprintf(vbuf, SLAPI_LOG_BUFSIZ, fmt, ap);
6f51e1
-    if (! vlen) {
6f51e1
+    if ((vlen = vsnprintf(vbuf, SLAPI_LOG_BUFSIZ, fmt, ap)) == -1){
6f51e1
         log__error_emergency("CRITICAL: vslapd_log_access, Unable to format message", 1 ,0);
6f51e1
         return -1;
6f51e1
     }
6f51e1
diff --git a/ldap/servers/slapd/monitor.c b/ldap/servers/slapd/monitor.c
6f51e1
index 0917bc8..f1fb38f 100644
6f51e1
--- a/ldap/servers/slapd/monitor.c
6f51e1
+++ b/ldap/servers/slapd/monitor.c
6f51e1
@@ -54,25 +54,25 @@ monitor_info(Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entry* entryAfter, int *ret
6f51e1
 	attrlist_replace( &e->e_attrs, "version", vals );
6f51e1
 	slapi_ch_free( (void **) &val.bv_val );
6f51e1
 
6f51e1
-	val.bv_len = PR_snprintf( buf, sizeof(buf), "%d", g_get_active_threadcnt() );
6f51e1
+	val.bv_len = snprintf( buf, sizeof(buf), "%d", g_get_active_threadcnt() );
6f51e1
 	val.bv_val = buf;
6f51e1
 	attrlist_replace( &e->e_attrs, "threads", vals );
6f51e1
 
6f51e1
 	connection_table_as_entry(the_connection_table, e);
6f51e1
 
6f51e1
-	val.bv_len = PR_snprintf( buf, sizeof(buf), "%" NSPRIu64, slapi_counter_get_value(ops_initiated) );
6f51e1
+	val.bv_len = snprintf( buf, sizeof(buf), "%" NSPRIu64, slapi_counter_get_value(ops_initiated) );
6f51e1
 	val.bv_val = buf;
6f51e1
 	attrlist_replace( &e->e_attrs, "opsinitiated", vals );
6f51e1
 
6f51e1
-	val.bv_len = PR_snprintf( buf, sizeof(buf), "%" NSPRIu64, slapi_counter_get_value(ops_completed) );
6f51e1
+	val.bv_len = snprintf( buf, sizeof(buf), "%" NSPRIu64, slapi_counter_get_value(ops_completed) );
6f51e1
 	val.bv_val = buf;
6f51e1
 	attrlist_replace( &e->e_attrs, "opscompleted", vals );
6f51e1
 
6f51e1
-	val.bv_len = PR_snprintf ( buf, sizeof(buf), "%" NSPRIu64, g_get_num_entries_sent() );
6f51e1
+	val.bv_len = snprintf ( buf, sizeof(buf), "%" NSPRIu64, g_get_num_entries_sent() );
6f51e1
 	val.bv_val = buf;
6f51e1
 	attrlist_replace( &e->e_attrs, "entriessent", vals );
6f51e1
 
6f51e1
-	val.bv_len = PR_snprintf ( buf, sizeof(buf), "%" NSPRIu64, g_get_num_bytes_sent() );
6f51e1
+	val.bv_len = snprintf ( buf, sizeof(buf), "%" NSPRIu64, g_get_num_bytes_sent() );
6f51e1
 	val.bv_val = buf;
6f51e1
 	attrlist_replace( &e->e_attrs, "bytessent", vals );
6f51e1
 
6f51e1
@@ -88,12 +88,12 @@ monitor_info(Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entry* entryAfter, int *ret
6f51e1
 	val.bv_len = strlen( buf );
6f51e1
 	attrlist_replace( &e->e_attrs, "starttime", vals );
6f51e1
 
6f51e1
-	val.bv_len = PR_snprintf( buf, sizeof(buf), "%d", be_nbackends_public() );
6f51e1
+	val.bv_len = snprintf( buf, sizeof(buf), "%d", be_nbackends_public() );
6f51e1
 	val.bv_val = buf;
6f51e1
 	attrlist_replace( &e->e_attrs, "nbackends", vals );
6f51e1
 
6f51e1
 #ifdef THREAD_SUNOS5_LWP
6f51e1
-	val.bv_len = PR_snprintf( buf, sizeof(buf), "%d", thr_getconcurrency() );
6f51e1
+	val.bv_len = snprintf( buf, sizeof(buf), "%d", thr_getconcurrency() );
6f51e1
 	val.bv_val = buf;
6f51e1
 	attrlist_replace( &e->e_attrs, "concurrency", vals );
6f51e1
 #endif
6f51e1
diff --git a/ldap/servers/slapd/slapi-plugin.h b/ldap/servers/slapd/slapi-plugin.h
6f51e1
index 1bd8fc8..725fa1c 100644
6f51e1
--- a/ldap/servers/slapd/slapi-plugin.h
6f51e1
+++ b/ldap/servers/slapd/slapi-plugin.h
6f51e1
@@ -1954,7 +1954,7 @@ void slapi_entry_attr_set_longlong( Slapi_Entry* e, const char *type, long long
6f51e1
  * \param type Attribute type in which you want to set the value.
6f51e1
  * \param l Unsigned long value that you want to assign to the attribute.
6f51e1
  */
6f51e1
-void slapi_entry_attr_set_ulong(Slapi_Entry* e, const char *type, unsigned long l);
6f51e1
+void slapi_entry_attr_set_ulong(Slapi_Entry* e, const char *type, uint64_t l);
6f51e1
 
6f51e1
 /**
6f51e1
  * Check if an attribute is set in the entry
6f51e1
@@ -6746,12 +6746,12 @@ void slapi_destroy_task(void *arg);
6f51e1
 Slapi_Counter *slapi_counter_new(void);
6f51e1
 void slapi_counter_init(Slapi_Counter *counter);
6f51e1
 void slapi_counter_destroy(Slapi_Counter **counter);
6f51e1
-PRUint64 slapi_counter_increment(Slapi_Counter *counter);
6f51e1
-PRUint64 slapi_counter_decrement(Slapi_Counter *counter);
6f51e1
-PRUint64 slapi_counter_add(Slapi_Counter *counter, PRUint64 addvalue);
6f51e1
-PRUint64 slapi_counter_subtract(Slapi_Counter *counter, PRUint64 subvalue);
6f51e1
-PRUint64 slapi_counter_set_value(Slapi_Counter *counter, PRUint64 newvalue);
6f51e1
-PRUint64 slapi_counter_get_value(Slapi_Counter *counter);
6f51e1
+uint64_t slapi_counter_increment(Slapi_Counter *counter);
6f51e1
+uint64_t slapi_counter_decrement(Slapi_Counter *counter);
6f51e1
+uint64_t slapi_counter_add(Slapi_Counter *counter, uint64_t addvalue);
6f51e1
+uint64_t slapi_counter_subtract(Slapi_Counter *counter, uint64_t subvalue);
6f51e1
+uint64_t slapi_counter_set_value(Slapi_Counter *counter, uint64_t newvalue);
6f51e1
+uint64_t slapi_counter_get_value(Slapi_Counter *counter);
6f51e1
 
6f51e1
 /* Binder-based (connection centric) resource limits */
6f51e1
 /*
6f51e1
diff --git a/ldap/servers/slapd/slapi_counter.c b/ldap/servers/slapd/slapi_counter.c
6f51e1
index c3ac846..9904fe9 100644
6f51e1
--- a/ldap/servers/slapd/slapi_counter.c
6f51e1
+++ b/ldap/servers/slapd/slapi_counter.c
6f51e1
@@ -12,37 +12,21 @@
6f51e1
 
6f51e1
 #include "slap.h"
6f51e1
 
6f51e1
-#ifdef SOLARIS
6f51e1
-PRUint64 _sparcv9_AtomicSet(PRUint64 *address, PRUint64 newval);
6f51e1
-PRUint64 _sparcv9_AtomicAdd(PRUint64 *address, PRUint64 val);
6f51e1
-PRUint64 _sparcv9_AtomicSub(PRUint64 *address, PRUint64 val);
6f51e1
+#ifndef ATOMIC_64BIT_OPERATIONS
6f51e1
+#include <pthread.h>
6f51e1
 #endif
6f51e1
 
6f51e1
 #ifdef HPUX
6f51e1
-#ifdef ATOMIC_64BIT_OPERATIONS
6f51e1
 #include <machine sys="" inline.h="">
6f51e1
 #endif
6f51e1
-#endif
6f51e1
-
6f51e1
-#ifdef ATOMIC_64BIT_OPERATIONS
6f51e1
-#if defined(LINUX) && !HAVE_64BIT_ATOMIC_OP_FUNCS
6f51e1
-/* On systems that don't have the 64-bit GCC atomic builtins, we need to
6f51e1
- * implement our own atomic functions using inline assembly code. */
6f51e1
-PRUint64 __sync_add_and_fetch_8(PRUint64 *ptr, PRUint64 addval);
6f51e1
-PRUint64 __sync_sub_and_fetch_8(PRUint64 *ptr, PRUint64 subval);
6f51e1
-#define __sync_add_and_fetch __sync_add_and_fetch_8
6f51e1
-#define __sync_sub_and_fetch __sync_sub_and_fetch_8
6f51e1
-#endif
6f51e1
-#endif /* ATOMIC_64BIT_OPERATIONS */
6f51e1
-
6f51e1
 
6f51e1
 /*
6f51e1
  * Counter Structure
6f51e1
  */
6f51e1
 typedef struct slapi_counter {
6f51e1
-    PRUint64 value;
6f51e1
+    uint64_t value;
6f51e1
 #ifndef ATOMIC_64BIT_OPERATIONS
6f51e1
-    Slapi_Mutex *lock;
6f51e1
+    pthread_mutex_t _lock;
6f51e1
 #endif
6f51e1
 } slapi_counter;
6f51e1
 
6f51e1
@@ -72,15 +56,11 @@ Slapi_Counter *slapi_counter_new()
6f51e1
 void slapi_counter_init(Slapi_Counter *counter)
6f51e1
 {
6f51e1
     if (counter != NULL) {
6f51e1
-#ifndef ATOMIC_64BIT_OPERATIONS
6f51e1
-        /* Create the lock if necessary. */
6f51e1
-        if (counter->lock == NULL) {
6f51e1
-            counter->lock = slapi_new_mutex();
6f51e1
-        }
6f51e1
-#endif
6f51e1
-        
6f51e1
         /* Set the value to 0. */
6f51e1
         slapi_counter_set_value(counter, 0);
6f51e1
+#ifndef ATOMIC_64BIT_OPERATIONS
6f51e1
+        pthread_mutex_init(&(counter->_lock), NULL);
6f51e1
+#endif
6f51e1
     }
6f51e1
 }
6f51e1
 
6f51e1
@@ -94,7 +74,7 @@ void slapi_counter_destroy(Slapi_Counter **counter)
6f51e1
 {
6f51e1
     if ((counter != NULL) && (*counter != NULL)) {
6f51e1
 #ifndef ATOMIC_64BIT_OPERATIONS
6f51e1
-        slapi_destroy_mutex((*counter)->lock);
6f51e1
+        pthread_mutex_destroy(&((*counter)->_lock));
6f51e1
 #endif
6f51e1
         slapi_ch_free((void **)counter);
6f51e1
     }
6f51e1
@@ -105,7 +85,7 @@ void slapi_counter_destroy(Slapi_Counter **counter)
6f51e1
  *
6f51e1
  * Atomically increments a Slapi_Counter.
6f51e1
  */
6f51e1
-PRUint64 slapi_counter_increment(Slapi_Counter *counter)
6f51e1
+uint64_t slapi_counter_increment(Slapi_Counter *counter)
6f51e1
 {
6f51e1
     return slapi_counter_add(counter, 1);
6f51e1
 }
6f51e1
@@ -117,7 +97,7 @@ PRUint64 slapi_counter_increment(Slapi_Counter *counter)
6f51e1
  * that this will not prevent you from wrapping
6f51e1
  * around 0.
6f51e1
  */
6f51e1
-PRUint64 slapi_counter_decrement(Slapi_Counter *counter)
6f51e1
+uint64_t slapi_counter_decrement(Slapi_Counter *counter)
6f51e1
 {
6f51e1
     return slapi_counter_subtract(counter, 1);
6f51e1
 }
6f51e1
@@ -127,28 +107,18 @@ PRUint64 slapi_counter_decrement(Slapi_Counter *counter)
6f51e1
  *
6f51e1
  * Atomically add a value to a Slapi_Counter.
6f51e1
  */
6f51e1
-PRUint64 slapi_counter_add(Slapi_Counter *counter, PRUint64 addvalue)
6f51e1
+uint64_t slapi_counter_add(Slapi_Counter *counter, uint64_t addvalue)
6f51e1
 {
6f51e1
-    PRUint64 newvalue = 0;
6f51e1
-#ifdef HPUX
6f51e1
-    PRUint64 prev = 0;
6f51e1
-#endif
6f51e1
+    uint64_t newvalue = 0;
6f51e1
 
6f51e1
     if (counter == NULL) {
6f51e1
         return newvalue;
6f51e1
     }
6f51e1
-
6f51e1
-#ifndef ATOMIC_64BIT_OPERATIONS
6f51e1
-    slapi_lock_mutex(counter->lock);
6f51e1
-    counter->value += addvalue;
6f51e1
-    newvalue = counter->value;
6f51e1
-    slapi_unlock_mutex(counter->lock);
6f51e1
+#ifdef ATOMIC_64BIT_OPERATIONS
6f51e1
+    newvalue = __atomic_add_fetch_8(&(counter->value), addvalue, __ATOMIC_SEQ_CST);
6f51e1
 #else
6f51e1
-#ifdef LINUX
6f51e1
-    newvalue = __sync_add_and_fetch(&(counter->value), addvalue);
6f51e1
-#elif defined(SOLARIS)
6f51e1
-    newvalue = _sparcv9_AtomicAdd(&(counter->value), addvalue);
6f51e1
-#elif defined(HPUX)
6f51e1
+#ifdef HPUX
6f51e1
+    uint64_t prev = 0;
6f51e1
     /* fetchadd only works with values of 1, 4, 8, and 16.  In addition, it requires
6f51e1
      * it's argument to be an integer constant. */
6f51e1
     if (addvalue == 1) {
6f51e1
@@ -172,8 +142,13 @@ PRUint64 slapi_counter_add(Slapi_Counter *counter, PRUint64 addvalue)
6f51e1
            _Asm_mov_to_ar(_AREG_CCV, prev);
6f51e1
         } while (prev != _Asm_cmpxchg(_FASZ_D, _SEM_ACQ, &(counter->value), newvalue, _LDHINT_NONE));
6f51e1
     }
6f51e1
+#else
6f51e1
+    pthread_mutex_lock(&(counter->_lock));
6f51e1
+    counter->value += addvalue;
6f51e1
+    newvalue = counter->value;
6f51e1
+    pthread_mutex_unlock(&(counter->_lock));
6f51e1
+#endif
6f51e1
 #endif
6f51e1
-#endif /* ATOMIC_64BIT_OPERATIONS */
6f51e1
 
6f51e1
     return newvalue;
6f51e1
 }
6f51e1
@@ -184,28 +159,19 @@ PRUint64 slapi_counter_add(Slapi_Counter *counter, PRUint64 addvalue)
6f51e1
  * Atomically subtract a value from a Slapi_Counter.  Note
6f51e1
  * that this will not prevent you from wrapping around 0.
6f51e1
  */
6f51e1
-PRUint64 slapi_counter_subtract(Slapi_Counter *counter, PRUint64 subvalue)
6f51e1
+uint64_t slapi_counter_subtract(Slapi_Counter *counter, uint64_t subvalue)
6f51e1
 {
6f51e1
-    PRUint64 newvalue = 0;
6f51e1
-#ifdef HPUX
6f51e1
-    PRUint64 prev = 0;
6f51e1
-#endif
6f51e1
+    uint64_t newvalue = 0;
6f51e1
 
6f51e1
     if (counter == NULL) {
6f51e1
         return newvalue;
6f51e1
     }
6f51e1
 
6f51e1
-#ifndef ATOMIC_64BIT_OPERATIONS
6f51e1
-    slapi_lock_mutex(counter->lock);
6f51e1
-    counter->value -= subvalue;
6f51e1
-    newvalue = counter->value;
6f51e1
-    slapi_unlock_mutex(counter->lock);
6f51e1
+#ifdef ATOMIC_64BIT_OPERATIONS
6f51e1
+    newvalue = __atomic_sub_fetch_8(&(counter->value), subvalue, __ATOMIC_SEQ_CST);
6f51e1
 #else
6f51e1
-#ifdef LINUX
6f51e1
-    newvalue = __sync_sub_and_fetch(&(counter->value), subvalue);
6f51e1
-#elif defined(SOLARIS)
6f51e1
-    newvalue = _sparcv9_AtomicSub(&(counter->value), subvalue);
6f51e1
-#elif defined(HPUX)
6f51e1
+#ifdef HPUX
6f51e1
+    uint64_t prev = 0;
6f51e1
     /* fetchadd only works with values of -1, -4, -8, and -16.  In addition, it requires
6f51e1
      * it's argument to be an integer constant. */
6f51e1
     if (subvalue == 1) {
6f51e1
@@ -229,8 +195,13 @@ PRUint64 slapi_counter_subtract(Slapi_Counter *counter, PRUint64 subvalue)
6f51e1
            _Asm_mov_to_ar(_AREG_CCV, prev);
6f51e1
         } while (prev != _Asm_cmpxchg(_FASZ_D, _SEM_ACQ, &(counter->value), newvalue, _LDHINT_NONE));
6f51e1
     }
6f51e1
+#else
6f51e1
+    pthread_mutex_lock(&(counter->_lock));
6f51e1
+    counter->value -= subvalue;
6f51e1
+    newvalue = counter->value;
6f51e1
+    pthread_mutex_unlock(&(counter->_lock));
6f51e1
+#endif
6f51e1
 #endif
6f51e1
-#endif /* ATOMIC_64BIT_OPERATIONS */
6f51e1
 
6f51e1
     return newvalue;
6f51e1
 }
6f51e1
@@ -240,76 +211,30 @@ PRUint64 slapi_counter_subtract(Slapi_Counter *counter, PRUint64 subvalue)
6f51e1
  *
6f51e1
  * Atomically sets the value of a Slapi_Counter.
6f51e1
  */
6f51e1
-PRUint64 slapi_counter_set_value(Slapi_Counter *counter, PRUint64 newvalue)
6f51e1
+uint64_t slapi_counter_set_value(Slapi_Counter *counter, uint64_t newvalue)
6f51e1
 {
6f51e1
-    PRUint64 value = 0;
6f51e1
+    uint64_t value = 0;
6f51e1
 
6f51e1
     if (counter == NULL) {
6f51e1
         return value;
6f51e1
     }
6f51e1
 
6f51e1
-#ifndef ATOMIC_64BIT_OPERATIONS
6f51e1
-    slapi_lock_mutex(counter->lock);
6f51e1
-    counter->value = newvalue;
6f51e1
-    slapi_unlock_mutex(counter->lock);
6f51e1
-    return newvalue;
6f51e1
-#else
6f51e1
-#ifdef LINUX
6f51e1
-/* Use our own inline assembly for an atomic set if
6f51e1
- * the builtins aren't available. */
6f51e1
-#if !HAVE_64BIT_ATOMIC_CAS_FUNC
6f51e1
-    /*
6f51e1
-     * %0 = counter->value
6f51e1
-     * %1 = newvalue
6f51e1
-     */
6f51e1
-    __asm__ __volatile__(
6f51e1
-#ifdef CPU_x86
6f51e1
-        /* Save the PIC register */
6f51e1
-        " pushl %%ebx;"
6f51e1
-#endif /* CPU_x86 */
6f51e1
-        /* Put value of counter->value in EDX:EAX */
6f51e1
-        "retryset: movl %0, %%eax;"
6f51e1
-        " movl 4%0, %%edx;"
6f51e1
-        /* Put newval in ECX:EBX */
6f51e1
-        " movl %1, %%ebx;"
6f51e1
-        " movl 4+%1, %%ecx;"
6f51e1
-        /* If EDX:EAX and counter-> are the same,
6f51e1
-         * replace *ptr with ECX:EBX */
6f51e1
-        " lock; cmpxchg8b %0;"
6f51e1
-        " jnz retryset;"
6f51e1
-#ifdef CPU_x86
6f51e1
-        /* Restore the PIC register */
6f51e1
-        " popl %%ebx"
6f51e1
-#endif /* CPU_x86 */
6f51e1
-        : "+o" (counter->value)
6f51e1
-        : "m" (newvalue)
6f51e1
-#ifdef CPU_x86
6f51e1
-        : "memory", "eax", "ecx", "edx", "cc");
6f51e1
-#else
6f51e1
-        : "memory", "eax", "ebx", "ecx", "edx", "cc");
6f51e1
-#endif
6f51e1
-
6f51e1
-    return newvalue;
6f51e1
-#else
6f51e1
-    while (1) {
6f51e1
-        value = counter->value;
6f51e1
-        if (__sync_bool_compare_and_swap(&(counter->value), value, newvalue)) {
6f51e1
-            return newvalue;
6f51e1
-        }
6f51e1
-    }
6f51e1
-#endif /* CPU_x86 || !HAVE_DECL___SYNC_ADD_AND_FETCH */
6f51e1
-#elif defined(SOLARIS)
6f51e1
-    _sparcv9_AtomicSet(&(counter->value), newvalue);
6f51e1
-    return newvalue;
6f51e1
-#elif defined(HPUX)
6f51e1
+#ifdef ATOMIC_64BIT_OPERATIONS
6f51e1
+    __atomic_store_8(&(counter->value), newvalue, __ATOMIC_SEQ_CST);
6f51e1
+#else /* HPUX */
6f51e1
+#ifdef HPUX
6f51e1
     do {
6f51e1
         value = counter->value;
6f51e1
         /* Put value in a register for cmpxchg to compare against */
6f51e1
         _Asm_mov_to_ar(_AREG_CCV, value);
6f51e1
     } while (value != _Asm_cmpxchg(_FASZ_D, _SEM_ACQ, &(counter->value), newvalue, _LDHINT_NONE));
6f51e1
-    return newvalue;
6f51e1
+#else
6f51e1
+    pthread_mutex_lock(&(counter->_lock));
6f51e1
+    counter->value = newvalue;
6f51e1
+    pthread_mutex_unlock(&(counter->_lock));
6f51e1
+#endif
6f51e1
 #endif
6f51e1
-#endif /* ATOMIC_64BIT_OPERATIONS */
6f51e1
+    return newvalue;
6f51e1
 }
6f51e1
 
6f51e1
 /*
6f51e1
@@ -317,174 +242,30 @@ PRUint64 slapi_counter_set_value(Slapi_Counter *counter, PRUint64 newvalue)
6f51e1
  *
6f51e1
  * Returns the value of a Slapi_Counter.
6f51e1
  */
6f51e1
-PRUint64 slapi_counter_get_value(Slapi_Counter *counter)
6f51e1
+uint64_t slapi_counter_get_value(Slapi_Counter *counter)
6f51e1
 {
6f51e1
-    PRUint64 value = 0;
6f51e1
+    uint64_t value = 0;
6f51e1
 
6f51e1
     if (counter == NULL) {
6f51e1
         return value;
6f51e1
     }
6f51e1
 
6f51e1
-#ifndef ATOMIC_64BIT_OPERATIONS
6f51e1
-    slapi_lock_mutex(counter->lock);
6f51e1
-    value = counter->value;
6f51e1
-    slapi_unlock_mutex(counter->lock);
6f51e1
-#else
6f51e1
-#ifdef LINUX
6f51e1
-/* Use our own inline assembly for an atomic get if
6f51e1
- * the builtins aren't available. */
6f51e1
-#if !HAVE_64BIT_ATOMIC_CAS_FUNC
6f51e1
-    /*
6f51e1
-     * %0 = counter->value
6f51e1
-     * %1 = value
6f51e1
-     */
6f51e1
-    __asm__ __volatile__(
6f51e1
-#ifdef CPU_x86
6f51e1
-        /* Save the PIC register */
6f51e1
-        " pushl %%ebx;"
6f51e1
-#endif /* CPU_x86 */
6f51e1
-        /* Put value of counter->value in EDX:EAX */
6f51e1
-        "retryget: movl %0, %%eax;"
6f51e1
-        " movl 4%0, %%edx;"
6f51e1
-        /* Copy EDX:EAX to ECX:EBX */
6f51e1
-        " movl %%eax, %%ebx;"
6f51e1
-        " movl %%edx, %%ecx;"
6f51e1
-        /* If EDX:EAX and counter->value are the same,
6f51e1
-         * replace *ptr with ECX:EBX */
6f51e1
-        " lock; cmpxchg8b %0;"
6f51e1
-        " jnz retryget;"
6f51e1
-        /* Put retrieved value into value */
6f51e1
-        " movl %%ebx, %1;"
6f51e1
-        " movl %%ecx, 4%1;"
6f51e1
-#ifdef CPU_x86
6f51e1
-        /* Restore the PIC register */
6f51e1
-        " popl %%ebx"
6f51e1
-#endif /* CPU_x86 */
6f51e1
-        : "+o" (counter->value), "=m" (value)
6f51e1
-        : 
6f51e1
-#ifdef CPU_x86
6f51e1
-        : "memory", "eax", "ecx", "edx", "cc");
6f51e1
-#else
6f51e1
-        : "memory", "eax", "ebx", "ecx", "edx", "cc");
6f51e1
-#endif
6f51e1
-#else
6f51e1
-    while (1) {
6f51e1
-        value = counter->value;
6f51e1
-        if (__sync_bool_compare_and_swap(&(counter->value), value, value)) {
6f51e1
-            break;
6f51e1
-        }
6f51e1
-    }
6f51e1
-#endif /* CPU_x86 || !HAVE_DECL___SYNC_ADD_AND_FETCH */
6f51e1
-#elif defined(SOLARIS)
6f51e1
-    while (1) {
6f51e1
-        value = counter->value;
6f51e1
-        if (value == _sparcv9_AtomicSet(&(counter->value), value)) {
6f51e1
-            break;
6f51e1
-        }
6f51e1
-    }
6f51e1
-#elif defined(HPUX)
6f51e1
+#ifdef ATOMIC_64BIT_OPERATIONS
6f51e1
+    value = __atomic_load_8(&(counter->value), __ATOMIC_SEQ_CST);
6f51e1
+#else  /* HPUX */
6f51e1
+#ifdef HPUX
6f51e1
     do {
6f51e1
         value = counter->value;
6f51e1
         /* Put value in a register for cmpxchg to compare against */
6f51e1
         _Asm_mov_to_ar(_AREG_CCV, value);
6f51e1
     } while (value != _Asm_cmpxchg(_FASZ_D, _SEM_ACQ, &(counter->value), value, _LDHINT_NONE));
6f51e1
-#endif
6f51e1
-#endif /* ATOMIC_64BIT_OPERATIONS */
6f51e1
-
6f51e1
-    return value;
6f51e1
-}
6f51e1
-
6f51e1
-#ifdef ATOMIC_64BIT_OPERATIONS
6f51e1
-#if defined(LINUX) && !HAVE_64BIT_ATOMIC_OP_FUNCS
6f51e1
-/* On systems that don't have the 64-bit GCC atomic builtins, we need to
6f51e1
- * implement our own atomic add and subtract functions using inline
6f51e1
- * assembly code. */
6f51e1
-PRUint64 __sync_add_and_fetch_8(PRUint64 *ptr, PRUint64 addval)
6f51e1
-{
6f51e1
-    PRUint64 retval = 0;
6f51e1
-
6f51e1
-    /*
6f51e1
-     * %0 = *ptr
6f51e1
-     * %1 = retval
6f51e1
-     * %2 = addval
6f51e1
-     */
6f51e1
-    __asm__ __volatile__(
6f51e1
-#ifdef CPU_x86
6f51e1
-        /* Save the PIC register */
6f51e1
-        " pushl %%ebx;"
6f51e1
-#endif /* CPU_x86 */
6f51e1
-        /* Put value of *ptr in EDX:EAX */
6f51e1
-        "retryadd: movl %0, %%eax;"
6f51e1
-        " movl 4%0, %%edx;"
6f51e1
-        /* Put addval in ECX:EBX */
6f51e1
-        " movl %2, %%ebx;"
6f51e1
-        " movl 4+%2, %%ecx;"
6f51e1
-        /* Add value from EDX:EAX to value in ECX:EBX */
6f51e1
-        " addl %%eax, %%ebx;"
6f51e1
-        " adcl %%edx, %%ecx;"
6f51e1
-        /* If EDX:EAX and *ptr are the same, replace ptr with ECX:EBX */
6f51e1
-        " lock; cmpxchg8b %0;"
6f51e1
-        " jnz retryadd;"
6f51e1
-        /* Put new value into retval */
6f51e1
-        " movl %%ebx, %1;"
6f51e1
-        " movl %%ecx, 4%1;"
6f51e1
-#ifdef CPU_x86
6f51e1
-        /* Restore the PIC register */
6f51e1
-        " popl %%ebx"
6f51e1
-#endif /* CPU_x86 */
6f51e1
-        : "+o" (*ptr), "=m" (retval)
6f51e1
-        : "m" (addval)
6f51e1
-#ifdef CPU_x86
6f51e1
-        : "memory", "eax", "ecx", "edx", "cc");
6f51e1
 #else
6f51e1
-        : "memory", "eax", "ebx", "ecx", "edx", "cc");
6f51e1
+    pthread_mutex_lock(&(counter->_lock));
6f51e1
+    value = counter->value;
6f51e1
+    pthread_mutex_unlock(&(counter->_lock));
6f51e1
 #endif
6f51e1
-
6f51e1
-    return retval;
6f51e1
-}
6f51e1
-
6f51e1
-PRUint64 __sync_sub_and_fetch_8(PRUint64 *ptr, PRUint64 subval)
6f51e1
-{
6f51e1
-    PRUint64 retval = 0;
6f51e1
-
6f51e1
-    /*
6f51e1
-     * %0 = *ptr
6f51e1
-     * %1 = retval
6f51e1
-     * %2 = subval
6f51e1
-     */
6f51e1
-    __asm__ __volatile__(
6f51e1
-#ifdef CPU_x86
6f51e1
-        /* Save the PIC register */
6f51e1
-        " pushl %%ebx;"
6f51e1
-#endif /* CPU_x86 */
6f51e1
-        /* Put value of *ptr in EDX:EAX */
6f51e1
-        "retrysub: movl %0, %%eax;"
6f51e1
-        " movl 4%0, %%edx;"
6f51e1
-        /* Copy EDX:EAX to ECX:EBX */
6f51e1
-        " movl %%eax, %%ebx;"
6f51e1
-        " movl %%edx, %%ecx;"
6f51e1
-        /* Subtract subval from value in ECX:EBX */
6f51e1
-        " subl %2, %%ebx;"
6f51e1
-        " sbbl 4+%2, %%ecx;"
6f51e1
-        /* If EDX:EAX and ptr are the same, replace *ptr with ECX:EBX */
6f51e1
-        " lock; cmpxchg8b %0;"
6f51e1
-        " jnz retrysub;"
6f51e1
-        /* Put new value into retval */
6f51e1
-        " movl %%ebx, %1;"
6f51e1
-        " movl %%ecx, 4%1;"
6f51e1
-#ifdef CPU_x86
6f51e1
-        /* Restore the PIC register */
6f51e1
-        " popl %%ebx"
6f51e1
-#endif /* CPU_x86 */
6f51e1
-        : "+o" (*ptr), "=m" (retval)
6f51e1
-        : "m" (subval)
6f51e1
-#ifdef CPU_x86 
6f51e1
-        : "memory", "eax", "ecx", "edx", "cc");
6f51e1
-#else
6f51e1
-        : "memory", "eax", "ebx", "ecx", "edx", "cc");
6f51e1
 #endif
6f51e1
 
6f51e1
-    return retval;
6f51e1
+    return value;
6f51e1
 }
6f51e1
-#endif /* LINUX && !HAVE_64BIT_ATOMIC_OP_FUNCS */
6f51e1
-#endif /* ATOMIC_64BIT_OPERATIONS */
6f51e1
+
6f51e1
diff --git a/ldap/servers/slapd/slapi_counter_sunos_sparcv9.S b/ldap/servers/slapd/slapi_counter_sunos_sparcv9.S
6f51e1
deleted file mode 100644
6f51e1
index e582c2a..0000000
6f51e1
--- a/ldap/servers/slapd/slapi_counter_sunos_sparcv9.S
6f51e1
+++ /dev/null
6f51e1
@@ -1,105 +0,0 @@
6f51e1
-! BEGIN COPYRIGHT BLOCK
6f51e1
-! The Original Code is the Netscape Portable Runtime (NSPR).
6f51e1
-!
6f51e1
-! The Initial Developer of the Original Code is
6f51e1
-! Netscape Communications Corporation.
6f51e1
-! Portions created by the Initial Developer are Copyright (C) 1998-2000
6f51e1
-! the Initial Developer. All Rights Reserved.
6f51e1
-!
6f51e1
-! The original code has been modified to support 64-bit atomic increments by
6f51e1
-! Red Hat, Inc.  These portions are Copyright (C) 2008 Red Hat, Inc. All Rights
6f51e1
-! reserved.
6f51e1
-!
6f51e1
-! License: GPL (version 3 or any later version).
6f51e1
-! See LICENSE for details. 
6f51e1
-! END COPYRIGHT BLOCK
6f51e1
-!
6f51e1
-
6f51e1
-#define _ASM 1 /* force to set an assembler code macro _ASM */
6f51e1
-#include <sys asm_linkage.h="">
6f51e1
-
6f51e1
-!  ======================================================================
6f51e1
-!
6f51e1
-!  Perform the sequence a = b atomically with respect to other
6f51e1
-!  fetch-and-stores to location a in a wait-free fashion.
6f51e1
-!
6f51e1
-!  usage : old_val = PR_AtomicSet(address, newval)
6f51e1
-!
6f51e1
-!  -----------------------
6f51e1
-!  Note on REGISTER USAGE:
6f51e1
-!  as this is a LEAF procedure, a new stack frame is not created;
6f51e1
-!  we use the caller's stack frame so what would normally be %i (input)
6f51e1
-!  registers are actually %o (output registers).  Also, we must not
6f51e1
-!  overwrite the contents of %l (local) registers as they are not
6f51e1
-!  assumed to be volatile during calls.
6f51e1
-!  -----------------------
6f51e1
-
6f51e1
-        ENTRY(_sparcv9_AtomicSet)            ! standard assembler/ELF prologue
6f51e1
-
6f51e1
-retryAS:
6f51e1
-        ldx     [%o0], %o2              ! set o2 to the current value
6f51e1
-        mov     %o1, %o3                ! set up the new value
6f51e1
-        casx    [%o0], %o2, %o3         ! atomically set if o0 hasn't changed
6f51e1
-        cmp     %o2, %o3                ! see if we set the value
6f51e1
-        bne     retryAS                 ! if not, try again
6f51e1
-        nop                             ! empty out the branch pipeline
6f51e1
-        retl                            ! return back to the caller
6f51e1
-        mov     %o3, %o0                ! set the return code to the prev value
6f51e1
-
6f51e1
-        SET_SIZE(_sparcv9_AtomicSet)    ! standard assembler/ELF epilogue
6f51e1
-
6f51e1
-!
6f51e1
-!  end
6f51e1
-!
6f51e1
-!  ======================================================================
6f51e1
-!
6f51e1
-!  Perform the sequence a = a + b atomically with respect to other
6f51e1
-!  fetch-and-adds to location a in a wait-free fashion.
6f51e1
-!
6f51e1
-!  usage : newval = PR_AtomicAdd(address, val)
6f51e1
-!  return: the value after addition
6f51e1
-!
6f51e1
-        ENTRY(_sparcv9_AtomicAdd)      ! standard assembler/ELF prologue
6f51e1
-
6f51e1
-retryAA:
6f51e1
-        ldx     [%o0], %o2              ! set o2 to the current value
6f51e1
-        addx    %o2, %o1, %o3           ! calc the new value
6f51e1
-        mov     %o3, %o4                ! save the return value
6f51e1
-        casx    [%o0], %o2, %o3         ! atomically set if o0 hasn't changed
6f51e1
-        cmp     %o2, %o3                ! see if we set the value
6f51e1
-        bne     retryAA                 ! if not, try again
6f51e1
-        nop                             ! empty out the branch pipeline
6f51e1
-        retl                            ! return back to the caller
6f51e1
-        mov     %o4, %o0                ! set the return code to the new value
6f51e1
-
6f51e1
-        SET_SIZE(_sparcv9_AtomicAdd)    ! standard assembler/ELF epilogue
6f51e1
-
6f51e1
-!
6f51e1
-!  end
6f51e1
-!
6f51e1
-!  ======================================================================
6f51e1
-!
6f51e1
-!  Perform the sequence a = a - b atomically with respect to other
6f51e1
-!  fetch-and-subs to location a in a wait-free fashion.
6f51e1
-!
6f51e1
-!  usage : newval = PR_AtomicSub(address, val)
6f51e1
-!  return: the value after addition
6f51e1
-!
6f51e1
-        ENTRY(_sparcv9_AtomicSub)      ! standard assembler/ELF prologue
6f51e1
-
6f51e1
-retryAU:
6f51e1
-        ldx     [%o0], %o2              ! set o2 to the current value
6f51e1
-        subx    %o2, %o1, %o3           ! calc the new value
6f51e1
-        mov     %o3, %o4                ! save the return value
6f51e1
-        casx    [%o0], %o2, %o3         ! atomically set if o0 hasn't changed
6f51e1
-        cmp     %o2, %o3                ! see if we set the value
6f51e1
-        bne     retryAU                 ! if not, try again
6f51e1
-        nop                             ! empty out the branch pipeline
6f51e1
-        retl                            ! return back to the caller
6f51e1
-        mov     %o4, %o0                ! set the return code to the new value
6f51e1
-
6f51e1
-        SET_SIZE(_sparcv9_AtomicSub)    ! standard assembler/ELF epilogue
6f51e1
-
6f51e1
-!
6f51e1
-!  end
6f51e1
-!
6f51e1
diff --git a/ldap/servers/slapd/snmp_collator.c b/ldap/servers/slapd/snmp_collator.c
6f51e1
index 841922f..b0c873d 100644
6f51e1
--- a/ldap/servers/slapd/snmp_collator.c
6f51e1
+++ b/ldap/servers/slapd/snmp_collator.c
6f51e1
@@ -711,7 +711,7 @@ static void
6f51e1
 add_counter_to_value(Slapi_Entry *e, const char *type, PRUint64 countervalue)
6f51e1
 {
6f51e1
 	char value[40];
6f51e1
-	PR_snprintf(value,sizeof(value),"%" NSPRIu64, countervalue);
6f51e1
+	snprintf(value,sizeof(value),"%" NSPRIu64, countervalue);
6f51e1
 	slapi_entry_attr_set_charptr( e, type, value);
6f51e1
 }
6f51e1
 
6f51e1
diff --git a/test/libslapd/test.c b/test/libslapd/test.c
6f51e1
index 37d5543..6e1171a 100644
6f51e1
--- a/test/libslapd/test.c
6f51e1
+++ b/test/libslapd/test.c
6f51e1
@@ -24,6 +24,8 @@ run_libslapd_tests (void) {
6f51e1
         cmocka_unit_test(test_libslapd_pblock_v3c_original_target_dn),
6f51e1
         cmocka_unit_test(test_libslapd_pblock_v3c_target_uniqueid),
6f51e1
         cmocka_unit_test(test_libslapd_operation_v3c_target_spec),
6f51e1
+        cmocka_unit_test(test_libslapd_counters_atomic_usage),
6f51e1
+        cmocka_unit_test(test_libslapd_counters_atomic_overflow),
6f51e1
     };
6f51e1
     return cmocka_run_group_tests(tests, NULL, NULL);
6f51e1
 }
6f51e1
diff --git a/test/test_slapd.h b/test/test_slapd.h
6f51e1
index 02eefdd..b8f1aba 100644
6f51e1
--- a/test/test_slapd.h
6f51e1
+++ b/test/test_slapd.h
6f51e1
@@ -37,4 +37,8 @@ void test_libslapd_pblock_v3c_target_uniqueid(void **state);
6f51e1
 /* libslapd-operation-v3_compat */
6f51e1
 void test_libslapd_operation_v3c_target_spec(void **state);
6f51e1
 
6f51e1
+/* libslapd-counters-atomic */
6f51e1
+
6f51e1
+void test_libslapd_counters_atomic_usage(void **state);
6f51e1
+void test_libslapd_counters_atomic_overflow(void **state);
6f51e1
 
6f51e1
-- 
6f51e1
2.9.3
6f51e1