Blame SOURCES/0028-Ticket-48864-Add-cgroup-memory-limit-detection-to-38.patch

74ca47
From 57b6e5afb6265363ede667ad450e267f8a803b9e Mon Sep 17 00:00:00 2001
74ca47
From: Mark Reynolds <mreynolds@redhat.com>
74ca47
Date: Wed, 19 Apr 2017 13:37:10 -0400
74ca47
Subject: [PATCH] Ticket 48864 - Add cgroup memory limit detection to 389-ds
74ca47
74ca47
Bug Description:  Previously our memory limits only check hardware
74ca47
    limits and shell resource limits. However, we may be in a container
74ca47
    like docker or lxc, and unable to detect these limits. This can lead
74ca47
    to crash conditions or worse, especially with autosizing
74ca47
    on import we may have conditions where the server may not
74ca47
    even be able to install.
74ca47
74ca47
Fix Description:  Add support for cgroup memory limit detection
74ca47
    so that we can properly determine our resource availability regardless
74ca47
    of lxc, docker, systemd or others.
74ca47
74ca47
https://pagure.io/389-ds-base/issue/48864
74ca47
74ca47
Author: wibrown
74ca47
74ca47
Review by: mreynolds (Thanks!)
74ca47
---
74ca47
 Makefile.am                                        |   7 +-
74ca47
 ldap/servers/plugins/acl/acl.c                     |  18 +-
74ca47
 ldap/servers/plugins/acl/acl.h                     |  16 -
74ca47
 ldap/servers/plugins/acl/aclanom.c                 |   8 +-
74ca47
 ldap/servers/plugins/dna/dna.c                     |  50 ++-
74ca47
 ldap/servers/plugins/posix-winsync/posix-winsync.c |   4 +-
74ca47
 ldap/servers/plugins/replication/repl.h            |  17 +-
74ca47
 .../plugins/replication/repl5_inc_protocol.c       |   2 +-
74ca47
 ldap/servers/plugins/replication/repl5_init.c      |   2 +-
74ca47
 ldap/servers/plugins/replication/repl5_plugins.c   |   2 +-
74ca47
 ldap/servers/plugins/replication/repl5_replica.c   |   8 +-
74ca47
 ldap/servers/plugins/replication/repl5_total.c     |   4 +-
74ca47
 ldap/servers/plugins/replication/repl_connext.c    |  20 +-
74ca47
 ldap/servers/plugins/replication/repl_extop.c      |  26 +-
74ca47
 ldap/servers/plugins/sync/sync_persist.c           |   6 +-
74ca47
 ldap/servers/plugins/syntaxes/validate_task.c      |   6 +-
74ca47
 ldap/servers/plugins/usn/usn.c                     |   8 +-
74ca47
 ldap/servers/slapd/abandon.c                       |   8 +-
74ca47
 ldap/servers/slapd/add.c                           |   4 +-
74ca47
 ldap/servers/slapd/auth.c                          |  18 +-
74ca47
 ldap/servers/slapd/back-ldbm/back-ldbm.h           |  23 +-
74ca47
 ldap/servers/slapd/back-ldbm/cache.c               |  34 +-
74ca47
 ldap/servers/slapd/back-ldbm/dblayer.c             |  72 ++--
74ca47
 ldap/servers/slapd/back-ldbm/dblayer.h             |   8 -
74ca47
 ldap/servers/slapd/back-ldbm/import-threads.c      |   2 +-
74ca47
 ldap/servers/slapd/back-ldbm/import.c              |  12 +-
74ca47
 ldap/servers/slapd/back-ldbm/ldbm_config.c         |  32 +-
74ca47
 ldap/servers/slapd/back-ldbm/ldbm_delete.c         |   4 +-
74ca47
 .../servers/slapd/back-ldbm/ldbm_instance_config.c |  20 +-
74ca47
 ldap/servers/slapd/back-ldbm/ldbm_modrdn.c         |   4 +-
74ca47
 ldap/servers/slapd/back-ldbm/ldbm_search.c         |   4 +-
74ca47
 ldap/servers/slapd/back-ldbm/misc.c                |   2 +-
74ca47
 ldap/servers/slapd/back-ldbm/monitor.c             |  10 +-
74ca47
 ldap/servers/slapd/back-ldbm/perfctrs.h            |   2 +-
74ca47
 ldap/servers/slapd/back-ldbm/start.c               | 113 +++----
74ca47
 ldap/servers/slapd/bind.c                          |   8 +-
74ca47
 ldap/servers/slapd/compare.c                       |   2 +-
74ca47
 ldap/servers/slapd/connection.c                    |  72 ++--
74ca47
 ldap/servers/slapd/conntable.c                     |   8 +-
74ca47
 ldap/servers/slapd/control.c                       |   2 +-
74ca47
 ldap/servers/slapd/daemon.c                        |  48 +--
74ca47
 ldap/servers/slapd/delete.c                        |   2 +-
74ca47
 ldap/servers/slapd/entry.c                         |   2 +-
74ca47
 ldap/servers/slapd/extendop.c                      |   4 +-
74ca47
 ldap/servers/slapd/log.c                           |  10 +-
74ca47
 ldap/servers/slapd/modify.c                        |  12 +-
74ca47
 ldap/servers/slapd/modrdn.c                        |   6 +-
74ca47
 ldap/servers/slapd/monitor.c                       |   8 +-
74ca47
 ldap/servers/slapd/operation.c                     |   6 +-
74ca47
 ldap/servers/slapd/opshared.c                      |   4 +-
74ca47
 ldap/servers/slapd/pagedresults.c                  |   2 +-
74ca47
 ldap/servers/slapd/psearch.c                       |  10 +-
74ca47
 ldap/servers/slapd/result.c                        |  12 +-
74ca47
 ldap/servers/slapd/sasl_io.c                       |  52 +--
74ca47
 ldap/servers/slapd/saslbind.c                      |   2 +-
74ca47
 ldap/servers/slapd/search.c                        |   2 +-
74ca47
 ldap/servers/slapd/slap.h                          |   9 +-
74ca47
 ldap/servers/slapd/slapi-plugin.h                  |  14 +-
74ca47
 ldap/servers/slapd/slapi-private.h                 |  38 ++-
74ca47
 ldap/servers/slapd/slapi_pal.c                     | 311 +++++++++++++++++
74ca47
 ldap/servers/slapd/slapi_pal.h                     |  62 ++++
74ca47
 ldap/servers/slapd/snmp_collator.c                 |   2 +-
74ca47
 ldap/servers/slapd/unbind.c                        |   6 +-
74ca47
 ldap/servers/slapd/util.c                          | 376 +--------------------
74ca47
 test/libslapd/spal/meminfo.c                       |  54 +++
74ca47
 test/libslapd/test.c                               |   2 +
74ca47
 test/test_slapd.h                                  |   5 +
74ca47
 67 files changed, 870 insertions(+), 859 deletions(-)
74ca47
 create mode 100644 ldap/servers/slapd/slapi_pal.c
74ca47
 create mode 100644 ldap/servers/slapd/slapi_pal.h
74ca47
 create mode 100644 test/libslapd/spal/meminfo.c
74ca47
74ca47
diff --git a/Makefile.am b/Makefile.am
74ca47
index 485a460..429a345 100644
74ca47
--- a/Makefile.am
74ca47
+++ b/Makefile.am
74ca47
@@ -481,6 +481,7 @@ dist_noinst_HEADERS = \
74ca47
 	ldap/servers/slapd/pw_verify.h \
74ca47
 	ldap/servers/slapd/secerrstrs.h \
74ca47
 	ldap/servers/slapd/slap.h \
74ca47
+	ldap/servers/slapd/slapi_pal.h \
74ca47
 	ldap/servers/slapd/slapi-plugin-compat4.h \
74ca47
 	ldap/servers/slapd/slapi-plugin.h \
74ca47
 	ldap/servers/slapd/slapi-private.h \
74ca47
@@ -850,6 +851,7 @@ pkgconfig_DATA = src/pkgconfig/dirsrv.pc \
74ca47
 # header files
74ca47
 #------------------------
74ca47
 serverinc_HEADERS = ldap/servers/plugins/replication/repl-session-plugin.h \
74ca47
+	ldap/servers/slapd/slapi_pal.h \
74ca47
 	ldap/servers/slapd/slapi-plugin.h \
74ca47
 	ldap/servers/plugins/replication/winsync-plugin.h \
74ca47
 	src/nunc-stans/include/nunc-stans.h \
74ca47
@@ -1219,6 +1221,7 @@ libslapd_la_SOURCES = ldap/servers/slapd/add.c \
74ca47
 	ldap/servers/slapd/value.c \
74ca47
 	ldap/servers/slapd/valueset.c \
74ca47
 	ldap/servers/slapd/vattr.c \
74ca47
+	ldap/servers/slapd/slapi_pal.c \
74ca47
 	$(libavl_a_SOURCES)
74ca47
 
74ca47
 libslapd_la_CPPFLAGS = $(AM_CPPFLAGS) $(DSPLUGIN_CPPFLAGS) $(SASL_INCLUDES) @db_inc@ $(SVRCORE_INCLUDES) @kerberos_inc@ @pcre_inc@
74ca47
@@ -2004,7 +2007,9 @@ test_slapd_SOURCES = test/main.c \
74ca47
 	test/libslapd/counters/atomic.c \
74ca47
 	test/libslapd/pblock/analytics.c \
74ca47
 	test/libslapd/pblock/v3_compat.c \
74ca47
-	test/libslapd/operation/v3_compat.c
74ca47
+	test/libslapd/operation/v3_compat.c \
74ca47
+	test/libslapd/spal/meminfo.c
74ca47
+
74ca47
 test_slapd_LDADD = libslapd.la
74ca47
 test_slapd_LDFLAGS = $(AM_CPPFLAGS) $(CMOCKA_LINKS)
74ca47
 ### WARNING: Slap.h needs cert.h, which requires the -I/lib/ldaputil!!!
74ca47
diff --git a/ldap/servers/plugins/acl/acl.c b/ldap/servers/plugins/acl/acl.c
74ca47
index 48b8efc..561dd91 100644
74ca47
--- a/ldap/servers/plugins/acl/acl.c
74ca47
+++ b/ldap/servers/plugins/acl/acl.c
74ca47
@@ -276,7 +276,7 @@ acl_access_allowed(
74ca47
 
74ca47
 		 if (  !privateBackend && (be_readonly ||  slapi_config_get_readonly () )){
74ca47
 			slapi_log_err(loglevel, plugin_name,
74ca47
-				"acl_access_allowed - conn=%" NSPRIu64 " op=%d (main): Deny %s on entry(%s)"
74ca47
+				"acl_access_allowed - conn=%" PRIu64 " op=%d (main): Deny %s on entry(%s)"
74ca47
 				": readonly backend\n", 
74ca47
 				o_connid, o_opid,
74ca47
 				acl_access2str(access),
74ca47
@@ -289,7 +289,7 @@ acl_access_allowed(
74ca47
 	TNF_PROBE_0_DEBUG(acl_skipaccess_start,"ACL","");
74ca47
 	if (  acl_skip_access_check ( pb, e, access )) {
74ca47
 		slapi_log_err(loglevel, plugin_name,
74ca47
-				"acl_access_allowed - conn=%" NSPRIu64 " op=%d (main): Allow %s on entry(%s)"
74ca47
+				"acl_access_allowed - conn=%" PRIu64 " op=%d (main): Allow %s on entry(%s)"
74ca47
 				": root user\n", 
74ca47
 				o_connid, o_opid,
74ca47
 				acl_access2str(access),
74ca47
@@ -448,7 +448,7 @@ acl_access_allowed(
74ca47
 		TNF_PROBE_0_DEBUG(acl_entry_first_touch_start,"ACL","");
74ca47
 
74ca47
 		slapi_log_err(loglevel, plugin_name,
74ca47
-			"acl_access_allowed - #### conn=%" NSPRIu64 " op=%d binddn=\"%s\"\n",
74ca47
+			"acl_access_allowed - #### conn=%" PRIu64 " op=%d binddn=\"%s\"\n",
74ca47
 			o_connid, o_opid, clientDn);
74ca47
 		aclpb->aclpb_stat_total_entries++;
74ca47
 
74ca47
@@ -776,7 +776,7 @@ print_access_control_summary( char *source, int ret_val, char *clientDn,
74ca47
                                 null_user);
74ca47
                         if (strcasecmp(right, access_str_moddn) == 0) {
74ca47
                                  slapi_log_err(loglevel, plugin_name, "print_access_control_summary - "                                            
74ca47
-                                        "conn=%" NSPRIu64 " op=%d (%s): %s %s on entry(%s).attr(%s) [from %s] to proxy (%s)"
74ca47
+                                        "conn=%" PRIu64 " op=%d (%s): %s %s on entry(%s).attr(%s) [from %s] to proxy (%s)"
74ca47
                                          ": %s\n",
74ca47
                                         o_connid, o_opid,
74ca47
                                         source,
74ca47
@@ -790,7 +790,7 @@ print_access_control_summary( char *source, int ret_val, char *clientDn,
74ca47
 
74ca47
                         } else {
74ca47
                                 slapi_log_err(loglevel, plugin_name, 
74ca47
-                                        "print_access_control_summary - conn=%" NSPRIu64 " op=%d (%s): %s %s on entry(%s).attr(%s) to proxy (%s)"
74ca47
+                                        "print_access_control_summary - conn=%" PRIu64 " op=%d (%s): %s %s on entry(%s).attr(%s) to proxy (%s)"
74ca47
                                          ": %s\n",
74ca47
                                         o_connid, o_opid,
74ca47
                                         source,
74ca47
@@ -805,7 +805,7 @@ print_access_control_summary( char *source, int ret_val, char *clientDn,
74ca47
                         proxy_user = null_user;
74ca47
                         if (strcasecmp(right, access_str_moddn) == 0) {
74ca47
                                 slapi_log_err(loglevel, plugin_name, 
74ca47
-                                        "print_access_control_summary - conn=%" NSPRIu64 " op=%d (%s): %s %s on entry(%s).attr(%s) [from %s] to proxy (%s)"
74ca47
+                                        "print_access_control_summary - conn=%" PRIu64 " op=%d (%s): %s %s on entry(%s).attr(%s) [from %s] to proxy (%s)"
74ca47
                                         ": %s\n",
74ca47
                                         o_connid, o_opid,
74ca47
                                         source,
74ca47
@@ -819,7 +819,7 @@ print_access_control_summary( char *source, int ret_val, char *clientDn,
74ca47
                                 
74ca47
                         } else {
74ca47
                                 slapi_log_err(loglevel, plugin_name, 
74ca47
-                                        "print_access_control_summary - conn=%" NSPRIu64 " op=%d (%s): %s %s on entry(%s).attr(%s) to proxy (%s)"
74ca47
+                                        "print_access_control_summary - conn=%" PRIu64 " op=%d (%s): %s %s on entry(%s).attr(%s) to proxy (%s)"
74ca47
                                         ": %s\n",
74ca47
                                         o_connid, o_opid,
74ca47
                                         source,
74ca47
@@ -834,7 +834,7 @@ print_access_control_summary( char *source, int ret_val, char *clientDn,
74ca47
 	} else {
74ca47
                 if (strcasecmp(right, access_str_moddn) == 0) {
74ca47
                         slapi_log_err(loglevel, plugin_name, 
74ca47
-                                "print_access_control_summary - conn=%" NSPRIu64 " op=%d (%s): %s %s on entry(%s).attr(%s) [from %s] to %s"
74ca47
+                                "print_access_control_summary - conn=%" PRIu64 " op=%d (%s): %s %s on entry(%s).attr(%s) [from %s] to %s"
74ca47
                                 ": %s\n",
74ca47
                                 o_connid, o_opid,
74ca47
                                 source,
74ca47
@@ -848,7 +848,7 @@ print_access_control_summary( char *source, int ret_val, char *clientDn,
74ca47
                         
74ca47
                 } else {
74ca47
                         slapi_log_err(loglevel, plugin_name, 
74ca47
-                                "print_access_control_summary - conn=%" NSPRIu64 " op=%d (%s): %s %s on entry(%s).attr(%s) to %s"
74ca47
+                                "print_access_control_summary - conn=%" PRIu64 " op=%d (%s): %s %s on entry(%s).attr(%s) to %s"
74ca47
                                 ": %s\n",
74ca47
                                 o_connid, o_opid,
74ca47
                                 source,
74ca47
diff --git a/ldap/servers/plugins/acl/acl.h b/ldap/servers/plugins/acl/acl.h
74ca47
index 91f5071..8b3486c 100644
74ca47
--- a/ldap/servers/plugins/acl/acl.h
74ca47
+++ b/ldap/servers/plugins/acl/acl.h
74ca47
@@ -20,22 +20,6 @@
74ca47
 #ifndef _ACL_H_
74ca47
 #define _ACL_H_
74ca47
 
74ca47
-/* Required to get portable printf/scanf format macros */
74ca47
-#ifdef HAVE_INTTYPES_H
74ca47
-#include <inttypes.h>
74ca47
-
74ca47
-/* NSPR uses the print macros a bit differently than ANSI C.  We
74ca47
- * need to use ll for a 64-bit integer, even when a long is 64-bit.
74ca47
- */
74ca47
-#undef PRIu64
74ca47
-#define PRIu64  "llu"
74ca47
-#undef PRI64
74ca47
-#define PRI64   "ll"
74ca47
-
74ca47
-#else
74ca47
-#error Need to define portable format macros such as PRIu64
74ca47
-#endif /* HAVE_INTTYPES_H */
74ca47
-
74ca47
 #include 	<stdio.h>
74ca47
 #include 	<string.h>
74ca47
 #include 	<sys/types.h>
74ca47
diff --git a/ldap/servers/plugins/acl/aclanom.c b/ldap/servers/plugins/acl/aclanom.c
74ca47
index 5462d87..96d0d9f 100644
74ca47
--- a/ldap/servers/plugins/acl/aclanom.c
74ca47
+++ b/ldap/servers/plugins/acl/aclanom.c
74ca47
@@ -523,7 +523,7 @@ aclanom_match_profile (Slapi_PBlock *pb, struct acl_pblock *aclpb, Slapi_Entry *
74ca47
 			aci_ndn = slapi_sdn_get_ndn (acl_anom_profile->anom_targetinfo[i].anom_target);
74ca47
 			if (access & SLAPI_ACL_MODDN) {
74ca47
 				slapi_log_err(loglevel, plugin_name, 
74ca47
-					"aclanom_match_profile - conn=%" NSPRIu64 " op=%d: Allow access on entry(%s).attr(%s) (from %s) to anonymous: acidn=\"%s\"\n",
74ca47
+					"aclanom_match_profile - conn=%" PRIu64 " op=%d: Allow access on entry(%s).attr(%s) (from %s) to anonymous: acidn=\"%s\"\n",
74ca47
 					o_connid, o_opid,
74ca47
 					ndn,
74ca47
 					attr ? attr:"NULL",
74ca47
@@ -532,7 +532,7 @@ aclanom_match_profile (Slapi_PBlock *pb, struct acl_pblock *aclpb, Slapi_Entry *
74ca47
 				
74ca47
 			} else {
74ca47
 				slapi_log_err(loglevel, plugin_name, 
74ca47
-					"aclanom_match_profile - conn=%" NSPRIu64 " op=%d: Allow access on entry(%s).attr(%s) to anonymous: acidn=\"%s\"\n",
74ca47
+					"aclanom_match_profile - conn=%" PRIu64 " op=%d: Allow access on entry(%s).attr(%s) to anonymous: acidn=\"%s\"\n",
74ca47
 					o_connid, o_opid,
74ca47
 					ndn,
74ca47
 					attr ? attr:"NULL",
74ca47
@@ -541,13 +541,13 @@ aclanom_match_profile (Slapi_PBlock *pb, struct acl_pblock *aclpb, Slapi_Entry *
74ca47
 		} else {
74ca47
 			if (access & SLAPI_ACL_MODDN) {
74ca47
 				slapi_log_err(loglevel, plugin_name,
74ca47
-					"aclanom_match_profile - conn=%" NSPRIu64 " op=%d: Deny access on entry(%s).attr(%s) (from %s) to anonymous\n",
74ca47
+					"aclanom_match_profile - conn=%" PRIu64 " op=%d: Deny access on entry(%s).attr(%s) (from %s) to anonymous\n",
74ca47
 					o_connid, o_opid,
74ca47
 					ndn, attr ? attr:"NULL" ,
74ca47
 					aclpb->aclpb_moddn_source_sdn ? slapi_sdn_get_dn(aclpb->aclpb_moddn_source_sdn) : "NULL");
74ca47
 			} else {
74ca47
 				slapi_log_err(loglevel, plugin_name,
74ca47
-					"aclanom_match_profile - conn=%" NSPRIu64 " op=%d: Deny access on entry(%s).attr(%s) to anonymous\n",
74ca47
+					"aclanom_match_profile - conn=%" PRIu64 " op=%d: Deny access on entry(%s).attr(%s) to anonymous\n",
74ca47
 					o_connid, o_opid,
74ca47
 					ndn, attr ? attr:"NULL" );
74ca47
 			}
74ca47
diff --git a/ldap/servers/plugins/dna/dna.c b/ldap/servers/plugins/dna/dna.c
74ca47
index 34011b9..a085941 100644
74ca47
--- a/ldap/servers/plugins/dna/dna.c
74ca47
+++ b/ldap/servers/plugins/dna/dna.c
74ca47
@@ -23,14 +23,6 @@
74ca47
 #include "slapi-private.h"
74ca47
 #include "prclist.h"
74ca47
 
74ca47
-/* Required to get portable printf/scanf format macros */
74ca47
-#ifdef HAVE_INTTYPES_H
74ca47
-#include <inttypes.h>
74ca47
-
74ca47
-#else
74ca47
-#error Need to define portable format macros such as PRIu64
74ca47
-#endif /* HAVE_INTTYPES_H */
74ca47
-
74ca47
 #include <sys/stat.h>
74ca47
 
74ca47
 #define DNA_PLUGIN_SUBSYSTEM "dna-plugin"
74ca47
@@ -997,7 +989,7 @@ dna_parse_config_entry(Slapi_PBlock *pb, Slapi_Entry * e, int apply)
74ca47
     }
74ca47
 
74ca47
     slapi_log_err(SLAPI_LOG_CONFIG, DNA_PLUGIN_SUBSYSTEM,
74ca47
-                    "dna_parse_config_entry - %s [%" NSPRIu64 "]\n", DNA_NEXTVAL,
74ca47
+                    "dna_parse_config_entry - %s [%" PRIu64 "]\n", DNA_NEXTVAL,
74ca47
                     entry->nextval);
74ca47
 
74ca47
     value = slapi_entry_attr_get_charptr(e, DNA_PREFIX);
74ca47
@@ -1026,7 +1018,7 @@ dna_parse_config_entry(Slapi_PBlock *pb, Slapi_Entry * e, int apply)
74ca47
     }
74ca47
 
74ca47
     slapi_log_err(SLAPI_LOG_CONFIG, DNA_PLUGIN_SUBSYSTEM,
74ca47
-                    "dna_parse_config_entry - %s [%" NSPRIu64 "]\n", DNA_INTERVAL, entry->interval);
74ca47
+                    "dna_parse_config_entry - %s [%" PRIu64 "]\n", DNA_INTERVAL, entry->interval);
74ca47
 #endif
74ca47
 
74ca47
     value = slapi_entry_attr_get_charptr(e, DNA_GENERATE);
74ca47
@@ -1126,7 +1118,7 @@ dna_parse_config_entry(Slapi_PBlock *pb, Slapi_Entry * e, int apply)
74ca47
     }
74ca47
 
74ca47
     slapi_log_err(SLAPI_LOG_CONFIG, DNA_PLUGIN_SUBSYSTEM,
74ca47
-                    "dna_parse_config_entry - %s [%" NSPRIu64 "]\n", DNA_MAXVAL,
74ca47
+                    "dna_parse_config_entry - %s [%" PRIu64 "]\n", DNA_MAXVAL,
74ca47
                     entry->maxval);
74ca47
 
74ca47
     /* get the global bind dn and password(if any) */
74ca47
@@ -1256,7 +1248,7 @@ dna_parse_config_entry(Slapi_PBlock *pb, Slapi_Entry * e, int apply)
74ca47
     }
74ca47
 
74ca47
     slapi_log_err(SLAPI_LOG_CONFIG, DNA_PLUGIN_SUBSYSTEM,
74ca47
-                    "dna_parse_config_entry - %s [%" NSPRIu64 "]\n", DNA_THRESHOLD,
74ca47
+                    "dna_parse_config_entry - %s [%" PRIu64 "]\n", DNA_THRESHOLD,
74ca47
                     entry->threshold);
74ca47
 
74ca47
     value = slapi_entry_attr_get_charptr(e, DNA_RANGE_REQUEST_TIMEOUT);
74ca47
@@ -1268,7 +1260,7 @@ dna_parse_config_entry(Slapi_PBlock *pb, Slapi_Entry * e, int apply)
74ca47
     }
74ca47
 
74ca47
     slapi_log_err(SLAPI_LOG_CONFIG, DNA_PLUGIN_SUBSYSTEM,
74ca47
-                    "dna_parse_config_entry - %s [%" NSPRIu64 "]\n", DNA_RANGE_REQUEST_TIMEOUT,
74ca47
+                    "dna_parse_config_entry - %s [%" PRIu64 "]\n", DNA_RANGE_REQUEST_TIMEOUT,
74ca47
                     entry->timeout);
74ca47
 
74ca47
     value = slapi_entry_attr_get_charptr(e, DNA_NEXT_RANGE);
74ca47
@@ -2307,7 +2299,7 @@ dna_first_free_value(struct configEntry *config_entry,
74ca47
             return LDAP_OPERATIONS_ERROR;
74ca47
         }
74ca47
 
74ca47
-        filter = slapi_ch_smprintf("(&%s(&(%s>=%" NSPRIu64 ")(%s<=%" NSPRIu64 ")))",
74ca47
+        filter = slapi_ch_smprintf("(&%s(&(%s>=%" PRIu64 ")(%s<=%" PRIu64 ")))",
74ca47
                                    config_entry->filter,
74ca47
                                    config_entry->types[0], tmpval,
74ca47
                                    config_entry->types[0], config_entry->maxval);
74ca47
@@ -2497,7 +2489,7 @@ static int dna_get_next_value(struct configEntry *config_entry,
74ca47
     if ((config_entry->maxval == -1) ||
74ca47
         (nextval <= (config_entry->maxval + config_entry->interval))) {
74ca47
         /* try to set the new next value in the config entry */
74ca47
-        snprintf(next_value, sizeof(next_value),"%" NSPRIu64, nextval);
74ca47
+        snprintf(next_value, sizeof(next_value),"%" PRIu64, nextval);
74ca47
 
74ca47
         /* set up our replace modify operation */
74ca47
         replace_val[0] = next_value;
74ca47
@@ -2524,7 +2516,7 @@ static int dna_get_next_value(struct configEntry *config_entry,
74ca47
 
74ca47
     if (LDAP_SUCCESS == ret) {
74ca47
         slapi_ch_free_string(next_value_ret);
74ca47
-        *next_value_ret = slapi_ch_smprintf("%" NSPRIu64, setval);
74ca47
+        *next_value_ret = slapi_ch_smprintf("%" PRIu64, setval);
74ca47
         if (NULL == *next_value_ret) {
74ca47
             ret = LDAP_OPERATIONS_ERROR;
74ca47
             goto done;
74ca47
@@ -2609,7 +2601,7 @@ dna_update_shared_config(struct configEntry *config_entry)
74ca47
 
74ca47
         /* We store the number of remaining assigned values
74ca47
          * in the shared config entry. */
74ca47
-        snprintf(remaining_vals, sizeof(remaining_vals),"%" NSPRIu64,
74ca47
+        snprintf(remaining_vals, sizeof(remaining_vals),"%" PRIu64,
74ca47
                 config_entry->remaining);
74ca47
 
74ca47
         /* set up our replace modify operation */
74ca47
@@ -2709,7 +2701,7 @@ dna_update_next_range(struct configEntry *config_entry,
74ca47
     int ret = 0;
74ca47
 
74ca47
     /* Try to set the new next range in the config entry. */
74ca47
-    snprintf(nextrange_value, sizeof(nextrange_value), "%" NSPRIu64 "-%" NSPRIu64,
74ca47
+    snprintf(nextrange_value, sizeof(nextrange_value), "%" PRIu64 "-%" PRIu64,
74ca47
     		lower, upper);
74ca47
 
74ca47
     /* set up our replace modify operation */
74ca47
@@ -2778,8 +2770,8 @@ dna_activate_next_range(struct configEntry *config_entry)
74ca47
     int ret = 0;
74ca47
 
74ca47
     /* Setup the modify operation for the config entry */
74ca47
-    snprintf(maxval_val, sizeof(maxval_val),"%" NSPRIu64, config_entry->next_range_upper);
74ca47
-    snprintf(nextval_val, sizeof(nextval_val),"%" NSPRIu64, config_entry->next_range_lower);
74ca47
+    snprintf(maxval_val, sizeof(maxval_val),"%" PRIu64, config_entry->next_range_upper);
74ca47
+    snprintf(nextval_val, sizeof(nextval_val),"%" PRIu64, config_entry->next_range_lower);
74ca47
 
74ca47
     maxval_vals[0] = maxval_val;
74ca47
     maxval_vals[1] = 0;
74ca47
@@ -3319,7 +3311,7 @@ dna_create_valcheck_filter(struct configEntry *config_entry, PRUint64 value, cha
74ca47
      * - the string length of the filter in the config
74ca47
      * - the string length sum of all configured types
74ca47
      * - 23 bytes for each type (20 for the max string
74ca47
-     *   representation of a NSPRIu64, 3 for "(=)"
74ca47
+     *   representation of a PRIu64, 3 for "(=)"
74ca47
      * - 3 bytes for the beginning and end of the filter - "(&" and ")"
74ca47
      * - 3 bytes to OR together multiple types (if present) - "(|" and ")"
74ca47
      * - the string length of the prefix (if one is configured) for each type
74ca47
@@ -3556,8 +3548,8 @@ _dna_pre_op_add(Slapi_PBlock *pb, Slapi_Entry *e, char **errstr)
74ca47
                     (config_entry->remaining <= config_entry->threshold)) {
74ca47
                     slapi_log_err(SLAPI_LOG_PLUGIN, DNA_PLUGIN_SUBSYSTEM,
74ca47
                                     "_dna_pre_op_add - Passed threshold of %" 
74ca47
-                                    NSPRIu64 " remaining values "
74ca47
-                                    "for range %s. (%" NSPRIu64 " values remain)\n",
74ca47
+                                    PRIu64 " remaining values "
74ca47
+                                    "for range %s. (%" PRIu64 " values remain)\n",
74ca47
                                     config_entry->threshold, config_entry->dn,
74ca47
                                     config_entry->remaining);
74ca47
                     dna_fix_maxval(config_entry, 0);
74ca47
@@ -3828,8 +3820,8 @@ _dna_pre_op_modify(Slapi_PBlock *pb, Slapi_Entry *e, Slapi_Mods *smods, char **e
74ca47
                     (config_entry->remaining <= config_entry->threshold)) {
74ca47
                     slapi_log_err(SLAPI_LOG_ERR, DNA_PLUGIN_SUBSYSTEM,
74ca47
                                     "_dna_pre_op_modify - Passed threshold of %" 
74ca47
-                                    NSPRIu64 " remaining values "
74ca47
-                                    "for range %s. (%" NSPRIu64 " values remain)\n",
74ca47
+                                    PRIu64 " remaining values "
74ca47
+                                    "for range %s. (%" PRIu64 " values remain)\n",
74ca47
                                     config_entry->threshold, config_entry->dn,
74ca47
                                     config_entry->remaining);
74ca47
                     dna_fix_maxval(config_entry, 0);
74ca47
@@ -4411,8 +4403,8 @@ static int dna_extend_exop(Slapi_PBlock *pb)
74ca47
         char highstr[16];
74ca47
 
74ca47
         /* Create the exop response */
74ca47
-        snprintf(lowstr, sizeof(lowstr), "%" NSPRIu64, lower);
74ca47
-        snprintf(highstr, sizeof(highstr), "%" NSPRIu64, upper);
74ca47
+        snprintf(lowstr, sizeof(lowstr), "%" PRIu64, lower);
74ca47
+        snprintf(highstr, sizeof(highstr), "%" PRIu64, upper);
74ca47
         range_low.bv_val = lowstr;
74ca47
         range_low.bv_len = strlen(range_low.bv_val);
74ca47
         range_high.bv_val = highstr;
74ca47
@@ -4445,7 +4437,7 @@ static int dna_extend_exop(Slapi_PBlock *pb)
74ca47
         ber_bvfree(respdata);
74ca47
 
74ca47
         slapi_log_err(SLAPI_LOG_PLUGIN, DNA_PLUGIN_SUBSYSTEM,
74ca47
-                        "dna_extend_exop - Released range %" NSPRIu64 "-%" NSPRIu64 ".\n",
74ca47
+                        "dna_extend_exop - Released range %" PRIu64 "-%" PRIu64 ".\n",
74ca47
                         lower, upper);
74ca47
     }
74ca47
 
74ca47
@@ -4588,7 +4580,7 @@ dna_release_range(char *range_dn, PRUint64 *lower, PRUint64 *upper)
74ca47
                 *lower = *upper - release + 1;
74ca47
 
74ca47
                 /* try to set the new maxval in the config entry */
74ca47
-                snprintf(max_value, sizeof(max_value),"%" NSPRIu64, (*lower - 1));
74ca47
+                snprintf(max_value, sizeof(max_value),"%" PRIu64, (*lower - 1));
74ca47
 
74ca47
                 /* set up our replace modify operation */
74ca47
                 replace_val[0] = max_value;
74ca47
diff --git a/ldap/servers/plugins/posix-winsync/posix-winsync.c b/ldap/servers/plugins/posix-winsync/posix-winsync.c
74ca47
index 63444e5..21e4ad0 100644
74ca47
--- a/ldap/servers/plugins/posix-winsync/posix-winsync.c
74ca47
+++ b/ldap/servers/plugins/posix-winsync/posix-winsync.c
74ca47
@@ -270,7 +270,7 @@ sync_acct_disable(void *cbdata, /* the usual domain config data */
74ca47
         if (update_entry) {
74ca47
             slapi_entry_attr_set_ulong(update_entry, "userAccountControl", adval);
74ca47
             slapi_log_err(SLAPI_LOG_PLUGIN, posix_winsync_plugin_name,
74ca47
-                "<-- sync_acct_disable - %s AD account [%s] - new value is [%" NSPRIu64 "]\n",
74ca47
+                "<-- sync_acct_disable - %s AD account [%s] - new value is [%" PRIu64 "]\n",
74ca47
 				(ds_is_enabled) ? "enabled" : "disabled", slapi_entry_get_dn_const(update_entry), adval);
74ca47
         } else {
74ca47
             /* iterate through the mods - if there is already a mod
74ca47
@@ -326,7 +326,7 @@ sync_acct_disable(void *cbdata, /* the usual domain config data */
74ca47
                 mod_bval->bv_len = strlen(acctvalstr);
74ca47
             }
74ca47
             slapi_log_err(SLAPI_LOG_PLUGIN, posix_winsync_plugin_name,
74ca47
-                "<-- sync_acct_disable - %s AD account [%s] - new value is [%" NSPRIu64 "]\n",
74ca47
+                "<-- sync_acct_disable - %s AD account [%s] - new value is [%" PRIu64 "]\n",
74ca47
 				(ds_is_enabled) ? "enabled" : "disabled", slapi_entry_get_dn_const(ad_entry), adval);
74ca47
         }
74ca47
     }
74ca47
diff --git a/ldap/servers/plugins/replication/repl.h b/ldap/servers/plugins/replication/repl.h
74ca47
index 89ad481..9460ca9 100644
74ca47
--- a/ldap/servers/plugins/replication/repl.h
74ca47
+++ b/ldap/servers/plugins/replication/repl.h
74ca47
@@ -15,21 +15,8 @@
74ca47
 #ifndef _REPL_H_
74ca47
 #define _REPL_H_
74ca47
 
74ca47
-/* Required to get portable printf/scanf format macros */
74ca47
-#ifdef HAVE_INTTYPES_H
74ca47
-#include <inttypes.h>
74ca47
-
74ca47
-/* NSPR uses the print macros a bit differently than ANSI C.  We
74ca47
- * need to use ll for a 64-bit integer, even when a long is 64-bit.
74ca47
- */
74ca47
-#undef PRIu64
74ca47
-#define PRIu64  "llu"
74ca47
-#undef PRI64
74ca47
-#define PRI64   "ll"
74ca47
-
74ca47
-#else
74ca47
-#error Need to define portable format macros such as PRIu64
74ca47
-#endif /* HAVE_INTTYPES_H */
74ca47
+/* Provides our int types and platform specific requirements. */
74ca47
+#include <slapi_pal.h>
74ca47
 
74ca47
 #include <limits.h>
74ca47
 #include <time.h>
74ca47
diff --git a/ldap/servers/plugins/replication/repl5_inc_protocol.c b/ldap/servers/plugins/replication/repl5_inc_protocol.c
74ca47
index a5ae885..36c279e 100644
74ca47
--- a/ldap/servers/plugins/replication/repl5_inc_protocol.c
74ca47
+++ b/ldap/servers/plugins/replication/repl5_inc_protocol.c
74ca47
@@ -2104,7 +2104,7 @@ repl5_inc_stop(Private_Repl_Protocol *prp)
74ca47
 		/* Isn't listening. Do something drastic. */
74ca47
 		return_value = -1;
74ca47
 		slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,
74ca47
-				"repl5_inc_stop - %s: Protocol does not stop after %" NSPRIu64 " seconds\n",
74ca47
+				"repl5_inc_stop - %s: Protocol does not stop after %" PRIu64 " seconds\n",
74ca47
 				agmt_get_long_name(prp->agmt), timeout);
74ca47
 	}
74ca47
 	else
74ca47
diff --git a/ldap/servers/plugins/replication/repl5_init.c b/ldap/servers/plugins/replication/repl5_init.c
74ca47
index 9549dcf..edffb84 100644
74ca47
--- a/ldap/servers/plugins/replication/repl5_init.c
74ca47
+++ b/ldap/servers/plugins/replication/repl5_init.c
74ca47
@@ -208,7 +208,7 @@ get_repl_session_id (Slapi_PBlock *pb, char *idstr, CSN **csn)
74ca47
 		/* Avoid "Connection is NULL and hence cannot access SLAPI_CONN_ID" */
74ca47
 		if (opid) {
74ca47
 			slapi_pblock_get (pb, SLAPI_CONN_ID, &connid);
74ca47
-			snprintf (idstr, REPL_SESSION_ID_SIZE, "conn=%" NSPRIu64 " op=%d",
74ca47
+			snprintf (idstr, REPL_SESSION_ID_SIZE, "conn=%" PRIu64 " op=%d",
74ca47
 					connid, opid);
74ca47
 		}
74ca47
 
74ca47
diff --git a/ldap/servers/plugins/replication/repl5_plugins.c b/ldap/servers/plugins/replication/repl5_plugins.c
74ca47
index 357c093..ebcc230 100644
74ca47
--- a/ldap/servers/plugins/replication/repl5_plugins.c
74ca47
+++ b/ldap/servers/plugins/replication/repl5_plugins.c
74ca47
@@ -1335,7 +1335,7 @@ process_postop (Slapi_PBlock *pb)
74ca47
 			{
74ca47
 				slapi_log_err(SLAPI_LOG_ERR, repl_plugin_name,
74ca47
 					"process_postop - Failed to apply update (%s) error (%d).  "
74ca47
-					"Aborting replication session(conn=%" NSPRIu64 " op=%d)\n",
74ca47
+					"Aborting replication session(conn=%" PRIu64 " op=%d)\n",
74ca47
 					csn_as_string(opcsn, PR_FALSE, csn_str), retval,
74ca47
 					connid, opid);
74ca47
 				/*
74ca47
diff --git a/ldap/servers/plugins/replication/repl5_replica.c b/ldap/servers/plugins/replication/repl5_replica.c
74ca47
index 5718a98..a106f8b 100644
74ca47
--- a/ldap/servers/plugins/replication/repl5_replica.c
74ca47
+++ b/ldap/servers/plugins/replication/repl5_replica.c
74ca47
@@ -596,7 +596,7 @@ replica_get_exclusive_access(Replica *r, PRBool *isInc, PRUint64 connid, int opi
74ca47
 
74ca47
 		slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,
74ca47
 				"replica_get_exclusive_access - "
74ca47
-				"conn=%" NSPRIu64 " op=%d repl=\"%s\": "
74ca47
+				"conn=%" PRIu64 " op=%d repl=\"%s\": "
74ca47
 				"Replica in use locking_purl=%s\n",
74ca47
 				connid, opid,
74ca47
 				slapi_sdn_get_dn(r->repl_root),
74ca47
@@ -620,7 +620,7 @@ replica_get_exclusive_access(Replica *r, PRBool *isInc, PRUint64 connid, int opi
74ca47
 	{
74ca47
         slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,
74ca47
         		"replica_get_exclusive_access - "
74ca47
-				"conn=%" NSPRIu64 " op=%d repl=\"%s\": Acquired replica\n",
74ca47
+				"conn=%" PRIu64 " op=%d repl=\"%s\": Acquired replica\n",
74ca47
 				connid, opid,
74ca47
 				slapi_sdn_get_dn(r->repl_root));
74ca47
 		r->repl_state_flags |= REPLICA_IN_USE;
74ca47
@@ -664,13 +664,13 @@ replica_relinquish_exclusive_access(Replica *r, PRUint64 connid, int opid)
74ca47
 	{
74ca47
 		slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,
74ca47
 				"replica_relinquish_exclusive_access - "
74ca47
-				"conn=%" NSPRIu64 " op=%d repl=\"%s\": "
74ca47
+				"conn=%" PRIu64 " op=%d repl=\"%s\": "
74ca47
 				"Replica not in use\n",
74ca47
 				connid, opid, slapi_sdn_get_dn(r->repl_root));
74ca47
 	} else {
74ca47
 		slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,
74ca47
 				"replica_relinquish_exclusive_access - "
74ca47
-				"conn=%" NSPRIu64 " op=%d repl=\"%s\": "
74ca47
+				"conn=%" PRIu64 " op=%d repl=\"%s\": "
74ca47
 				"Released replica held by locking_purl=%s\n",
74ca47
 				connid, opid,
74ca47
 				slapi_sdn_get_dn(r->repl_root),	r->locking_purl);
74ca47
diff --git a/ldap/servers/plugins/replication/repl5_total.c b/ldap/servers/plugins/replication/repl5_total.c
74ca47
index af570a8..064a099 100644
74ca47
--- a/ldap/servers/plugins/replication/repl5_total.c
74ca47
+++ b/ldap/servers/plugins/replication/repl5_total.c
74ca47
@@ -853,7 +853,7 @@ multimaster_extop_NSDS50ReplicationEntry(Slapi_PBlock  *pb)
74ca47
            const char *dn = slapi_entry_get_dn_const(e);
74ca47
            slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,
74ca47
                    "multimaster_extop_NSDS50ReplicationEntry - "
74ca47
-                   "Error %d: could not import entry dn %s for total update operation conn=%" NSPRIu64 " op=%d\n",
74ca47
+                   "Error %d: could not import entry dn %s for total update operation conn=%" PRIu64 " op=%d\n",
74ca47
                    rc, dn, connid, opid);
74ca47
 		   rc = -1;
74ca47
 	   }
74ca47
@@ -864,7 +864,7 @@ multimaster_extop_NSDS50ReplicationEntry(Slapi_PBlock  *pb)
74ca47
 		slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,
74ca47
 				"multimaster_extop_NSDS50ReplicationEntry - "
74ca47
 				"Error %d: could not decode the total update extop "
74ca47
-				"for total update operation conn=%" NSPRIu64 " op=%d\n",
74ca47
+				"for total update operation conn=%" PRIu64 " op=%d\n",
74ca47
 				rc, connid, opid);
74ca47
 	}
74ca47
    
74ca47
diff --git a/ldap/servers/plugins/replication/repl_connext.c b/ldap/servers/plugins/replication/repl_connext.c
74ca47
index 29dc2a7..ba0fa15 100644
74ca47
--- a/ldap/servers/plugins/replication/repl_connext.c
74ca47
+++ b/ldap/servers/plugins/replication/repl_connext.c
74ca47
@@ -84,7 +84,7 @@ void consumer_connection_extension_destructor (void *ext, void *object, void *pa
74ca47
 					slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,
74ca47
 							"consumer_connection_extension_destructor - "
74ca47
 							"Aborting total update in progress for replicated "
74ca47
-							"area %s connid=%" NSPRIu64 "\n", slapi_sdn_get_dn(repl_root_sdn), connid);
74ca47
+							"area %s connid=%" PRIu64 "\n", slapi_sdn_get_dn(repl_root_sdn), connid);
74ca47
 					slapi_stop_bulk_import(pb);
74ca47
 				}
74ca47
 				else
74ca47
@@ -156,7 +156,7 @@ consumer_connection_extension_acquire_exclusive_access(void* conn, PRUint64 conn
74ca47
             ret = connext;
74ca47
             slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,
74ca47
             		"consumer_connection_extension_acquire_exclusive_access - "
74ca47
-                    "conn=%" NSPRIu64 " op=%d Acquired consumer connection extension\n",
74ca47
+                    "conn=%" PRIu64 " op=%d Acquired consumer connection extension\n",
74ca47
                     connid, opid);
74ca47
         }
74ca47
         else if (opid == connext->in_use_opid)
74ca47
@@ -164,14 +164,14 @@ consumer_connection_extension_acquire_exclusive_access(void* conn, PRUint64 conn
74ca47
             ret = connext;
74ca47
             slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,
74ca47
             		"consumer_connection_extension_acquire_exclusive_access - "
74ca47
-                    "conn=%" NSPRIu64 " op=%d Reacquired consumer connection extension\n",
74ca47
+                    "conn=%" PRIu64 " op=%d Reacquired consumer connection extension\n",
74ca47
                     connid, opid);
74ca47
         }
74ca47
         else
74ca47
         {
74ca47
             slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,
74ca47
             		"consumer_connection_extension_acquire_exclusive_access - "
74ca47
-                    "conn=%" NSPRIu64 " op=%d Could not acquire consumer connection extension; it is in use by op=%d\n",
74ca47
+                    "conn=%" PRIu64 " op=%d Could not acquire consumer connection extension; it is in use by op=%d\n",
74ca47
                     connid, opid, connext->in_use_opid);
74ca47
         }
74ca47
 
74ca47
@@ -182,7 +182,7 @@ consumer_connection_extension_acquire_exclusive_access(void* conn, PRUint64 conn
74ca47
     {
74ca47
         slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,
74ca47
         		"consumer_connection_extension_acquire_exclusive_access - "
74ca47
-                "conn=%" NSPRIu64 " op=%d Could not acquire consumer extension, it is NULL!\n",
74ca47
+                "conn=%" PRIu64 " op=%d Could not acquire consumer extension, it is NULL!\n",
74ca47
                 connid, opid);
74ca47
     }
74ca47
     
74ca47
@@ -221,7 +221,7 @@ consumer_connection_extension_relinquish_exclusive_access(void* conn, PRUint64 c
74ca47
         {
74ca47
             slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,
74ca47
             		"consumer_connection_extension_relinquish_exclusive_access - "
74ca47
-                    "conn=%" NSPRIu64 " op=%d Consumer connection extension is not in use\n",
74ca47
+                    "conn=%" PRIu64 " op=%d Consumer connection extension is not in use\n",
74ca47
                     connid, opid);
74ca47
             ret = 2;
74ca47
         }
74ca47
@@ -230,7 +230,7 @@ consumer_connection_extension_relinquish_exclusive_access(void* conn, PRUint64 c
74ca47
             /* step 4, relinquish it (normal) */
74ca47
             slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,
74ca47
             		"consumer_connection_extension_relinquish_exclusive_access - "
74ca47
-                    "conn=%" NSPRIu64 " op=%d Relinquishing consumer connection extension\n",
74ca47
+                    "conn=%" PRIu64 " op=%d Relinquishing consumer connection extension\n",
74ca47
                     connid, opid);
74ca47
             connext->in_use_opid = -1;
74ca47
             ret = 1;
74ca47
@@ -240,7 +240,7 @@ consumer_connection_extension_relinquish_exclusive_access(void* conn, PRUint64 c
74ca47
             /* step 4, relinquish it (forced) */
74ca47
             slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,
74ca47
             		"consumer_connection_extension_relinquish_exclusive_access - "
74ca47
-                    "conn=%" NSPRIu64 " op=%d Forced to relinquish consumer connection extension held by op=%d\n",
74ca47
+                    "conn=%" PRIu64 " op=%d Forced to relinquish consumer connection extension held by op=%d\n",
74ca47
                     connid, opid, connext->in_use_opid);
74ca47
             connext->in_use_opid = -1;
74ca47
             ret = 1;
74ca47
@@ -249,7 +249,7 @@ consumer_connection_extension_relinquish_exclusive_access(void* conn, PRUint64 c
74ca47
         {
74ca47
             slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,
74ca47
             		"consumer_connection_extension_relinquish_exclusive_access - "
74ca47
-                    "conn=%" NSPRIu64 " op=%d Not relinquishing consumer connection extension, it is held by op=%d!\n",
74ca47
+                    "conn=%" PRIu64 " op=%d Not relinquishing consumer connection extension, it is held by op=%d!\n",
74ca47
                     connid, opid, connext->in_use_opid);
74ca47
         }
74ca47
         
74ca47
@@ -260,7 +260,7 @@ consumer_connection_extension_relinquish_exclusive_access(void* conn, PRUint64 c
74ca47
     {
74ca47
         slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,
74ca47
         		"consumer_connection_extension_relinquish_exclusive_access - "
74ca47
-                "conn=%" NSPRIu64 " op=%d Could not relinquish consumer extension, it is NULL!\n",
74ca47
+                "conn=%" PRIu64 " op=%d Could not relinquish consumer extension, it is NULL!\n",
74ca47
                 connid, opid);
74ca47
     }
74ca47
     
74ca47
diff --git a/ldap/servers/plugins/replication/repl_extop.c b/ldap/servers/plugins/replication/repl_extop.c
74ca47
index 80580f9..412caec 100644
74ca47
--- a/ldap/servers/plugins/replication/repl_extop.c
74ca47
+++ b/ldap/servers/plugins/replication/repl_extop.c
74ca47
@@ -668,7 +668,7 @@ multimaster_extop_StartNSDS50ReplicationRequest(Slapi_PBlock *pb)
74ca47
 		connext->repl_protocol_version = REPL_PROTOCOL_50_INCREMENTAL;
74ca47
 		slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,
74ca47
 			"multimaster_extop_StartNSDS50ReplicationRequest - "
74ca47
-			"conn=%" NSPRIu64 " op=%d repl=\"%s\": Begin incremental protocol\n",
74ca47
+			"conn=%" PRIu64 " op=%d repl=\"%s\": Begin incremental protocol\n",
74ca47
 			connid, opid, repl_root);
74ca47
 		isInc = PR_TRUE;
74ca47
 	}
74ca47
@@ -695,7 +695,7 @@ multimaster_extop_StartNSDS50ReplicationRequest(Slapi_PBlock *pb)
74ca47
 		}
74ca47
 		slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,
74ca47
 				"multimaster_extop_StartNSDS50ReplicationRequest - "
74ca47
-				"conn=%" NSPRIu64 " op=%d repl=\"%s\": Begin total protocol\n",
74ca47
+				"conn=%" PRIu64 " op=%d repl=\"%s\": Begin total protocol\n",
74ca47
 				connid, opid, repl_root);
74ca47
 		isInc = PR_FALSE;
74ca47
 	}
74ca47
@@ -705,7 +705,7 @@ multimaster_extop_StartNSDS50ReplicationRequest(Slapi_PBlock *pb)
74ca47
 		connext->repl_protocol_version = REPL_PROTOCOL_50_INCREMENTAL;
74ca47
 		slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,
74ca47
 			"multimaster_extop_StartNSDS50ReplicationRequest - "
74ca47
-			"conn=%" NSPRIu64 " op=%d repl=\"%s\": Begin 7.1 incremental protocol\n",
74ca47
+			"conn=%" PRIu64 " op=%d repl=\"%s\": Begin 7.1 incremental protocol\n",
74ca47
 			connid, opid, repl_root);
74ca47
 		isInc = PR_TRUE;
74ca47
 	}
74ca47
@@ -718,7 +718,7 @@ multimaster_extop_StartNSDS50ReplicationRequest(Slapi_PBlock *pb)
74ca47
 		}
74ca47
 		slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,
74ca47
 				"multimaster_extop_StartNSDS50ReplicationRequest - "
74ca47
-				"conn=%" NSPRIu64 " op=%d repl=\"%s\": Begin 7.1 total protocol\n",
74ca47
+				"conn=%" PRIu64 " op=%d repl=\"%s\": Begin 7.1 total protocol\n",
74ca47
 				connid, opid, repl_root);
74ca47
 		isInc = PR_FALSE;
74ca47
 	}
74ca47
@@ -741,7 +741,7 @@ multimaster_extop_StartNSDS50ReplicationRequest(Slapi_PBlock *pb)
74ca47
 	{
74ca47
         slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,
74ca47
         		"multimaster_extop_StartNSDS50ReplicationRequest - "
74ca47
-				"conn=%" NSPRIu64 " op=%d replica=\"%s\": "
74ca47
+				"conn=%" PRIu64 " op=%d replica=\"%s\": "
74ca47
 				"Replica is being configured: try again later\n",
74ca47
 				connid, opid, repl_root);
74ca47
 		response = NSDS50_REPL_REPLICA_BUSY;
74ca47
@@ -814,7 +814,7 @@ multimaster_extop_StartNSDS50ReplicationRequest(Slapi_PBlock *pb)
74ca47
 				{
74ca47
 					slapi_log_err(SLAPI_LOG_ERR, repl_plugin_name,
74ca47
 							"multimaster_extop_StartNSDS50ReplicationRequest - "
74ca47
-							"conn=%" NSPRIu64 " op=%d repl=\"%s\": "
74ca47
+							"conn=%" PRIu64 " op=%d repl=\"%s\": "
74ca47
 							"Excessive clock skew from supplier RUV\n",
74ca47
 							connid, opid, repl_root);
74ca47
 					response = NSDS50_REPL_EXCESSIVE_CLOCK_SKEW;
74ca47
@@ -852,7 +852,7 @@ multimaster_extop_StartNSDS50ReplicationRequest(Slapi_PBlock *pb)
74ca47
 	if (check_replica_id_uniqueness(replica, supplier_ruv) != 0){
74ca47
         slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,
74ca47
         		"multimaster_extop_StartNSDS50ReplicationRequest - "
74ca47
-				"conn=%" NSPRIu64 " op=%d repl=\"%s\": "
74ca47
+				"conn=%" PRIu64 " op=%d repl=\"%s\": "
74ca47
 				"Replica has same replicaID %d as supplier\n",
74ca47
 				connid, opid, repl_root, replica_get_rid(replica));
74ca47
 		response = NSDS50_REPL_REPLICAID_ERROR;
74ca47
@@ -865,7 +865,7 @@ multimaster_extop_StartNSDS50ReplicationRequest(Slapi_PBlock *pb)
74ca47
 	 * the session's conn id and op id to identify the the supplier.
74ca47
 	 */
74ca47
 	/* junkrc = ruv_get_first_id_and_purl(supplier_ruv, &junkrid, &locking_purl); */
74ca47
-	snprintf(locking_session, sizeof(locking_session), "conn=%" NSPRIu64 " id=%d",
74ca47
+	snprintf(locking_session, sizeof(locking_session), "conn=%" PRIu64 " id=%d",
74ca47
 			connid, opid);
74ca47
 	locking_purl = &locking_session[0];
74ca47
 	if (replica_get_exclusive_access(replica, &isInc, connid, opid,
74ca47
@@ -892,7 +892,7 @@ multimaster_extop_StartNSDS50ReplicationRequest(Slapi_PBlock *pb)
74ca47
 		int max = 480 * 5;
74ca47
 		slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,
74ca47
 				"multimaster_extop_StartNSDS50ReplicationRequest - "
74ca47
-				"conn=%" NSPRIu64 " op=%d repl=\"%s\": "
74ca47
+				"conn=%" PRIu64 " op=%d repl=\"%s\": "
74ca47
 				"374 - Starting sleep: connext->repl_protocol_version == %d\n",
74ca47
 				connid, opid, repl_root, connext->repl_protocol_version);
74ca47
         
74ca47
@@ -902,7 +902,7 @@ multimaster_extop_StartNSDS50ReplicationRequest(Slapi_PBlock *pb)
74ca47
         
74ca47
 		slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,
74ca47
 				"multimaster_extop_StartNSDS50ReplicationRequest - "
74ca47
-				"conn=%" NSPRIu64 " op=%d repl=\"%s\": "
74ca47
+				"conn=%" PRIu64 " op=%d repl=\"%s\": "
74ca47
 				"374 - Finished sleep: connext->repl_protocol_version == %d\n",
74ca47
 				connid, opid, repl_root, connext->repl_protocol_version);
74ca47
 	}
74ca47
@@ -997,7 +997,7 @@ multimaster_extop_StartNSDS50ReplicationRequest(Slapi_PBlock *pb)
74ca47
 		response = NSDS50_REPL_INTERNAL_ERROR;
74ca47
 		slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,
74ca47
 				"multimaster_extop_StartNSDS50ReplicationRequest - "
74ca47
-				"conn=%" NSPRIu64 " op=%d repl=\"%s\": "
74ca47
+				"conn=%" PRIu64 " op=%d repl=\"%s\": "
74ca47
 				"Unexpected update protocol received: %d.  "
74ca47
 				"Expected incremental or total.\n",
74ca47
 				connid, opid, repl_root, connext->repl_protocol_version);
74ca47
@@ -1039,7 +1039,7 @@ send_response:
74ca47
 		slapi_log_err (resp_log_level,
74ca47
 			repl_plugin_name,
74ca47
 			"multimaster_extop_StartNSDS50ReplicationRequest - "
74ca47
-			"conn=%" NSPRIu64 " op=%d replica=\"%s\": "
74ca47
+			"conn=%" PRIu64 " op=%d replica=\"%s\": "
74ca47
 			"Unable to acquire replica: error: %s%s\n",
74ca47
 			connid, opid,
74ca47
 			(replica ? slapi_sdn_get_dn(replica_get_root(replica)) : "unknown"),
74ca47
@@ -1092,7 +1092,7 @@ send_response:
74ca47
 	slapi_pblock_set(pb, SLAPI_EXT_OP_RET_VALUE, resp_bval);
74ca47
 	slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name,
74ca47
 			"multimaster_extop_StartNSDS50ReplicationRequest - "
74ca47
-			"conn=%" NSPRIu64 " op=%d repl=\"%s\": "
74ca47
+			"conn=%" PRIu64 " op=%d repl=\"%s\": "
74ca47
 			"%s: response=%d rc=%d\n",
74ca47
 			connid, opid, repl_root,
74ca47
 			is90 ? "StartNSDS90ReplicationRequest" :
74ca47
diff --git a/ldap/servers/plugins/sync/sync_persist.c b/ldap/servers/plugins/sync/sync_persist.c
74ca47
index 667a529..bd856cb 100644
74ca47
--- a/ldap/servers/plugins/sync/sync_persist.c
74ca47
+++ b/ldap/servers/plugins/sync/sync_persist.c
74ca47
@@ -548,14 +548,14 @@ sync_send_results( void *arg )
74ca47
 	slapi_pblock_get(req->req_pblock, SLAPI_CONNECTION, &conn;;
74ca47
 	if (NULL == conn) {
74ca47
 		slapi_log_err(SLAPI_LOG_ERR, SYNC_PLUGIN_SUBSYSTEM,
74ca47
-			"sync_send_results - conn=%" NSPRIu64 " op=%d Null connection - aborted\n",
74ca47
+			"sync_send_results - conn=%" PRIu64 " op=%d Null connection - aborted\n",
74ca47
 			connid, opid);
74ca47
 		goto done;
74ca47
 	}
74ca47
 	conn_acq_flag = sync_acquire_connection (conn);
74ca47
 	if (conn_acq_flag) {
74ca47
 		slapi_log_err(SLAPI_LOG_ERR, SYNC_PLUGIN_SUBSYSTEM,
74ca47
-			"sync_send_results - conn=%" NSPRIu64 " op=%d Could not acquire the connection - aborted\n",
74ca47
+			"sync_send_results - conn=%" PRIu64 " op=%d Could not acquire the connection - aborted\n",
74ca47
 			connid, opid);
74ca47
 		goto done;
74ca47
 	}
74ca47
@@ -566,7 +566,7 @@ sync_send_results( void *arg )
74ca47
 		/* Check for an abandoned operation */
74ca47
 		if ( op == NULL || slapi_is_operation_abandoned( op ) ) {
74ca47
 			slapi_log_err(SLAPI_LOG_PLUGIN, SYNC_PLUGIN_SUBSYSTEM,
74ca47
-						"sync_send_results - conn=%" NSPRIu64 " op=%d Operation no longer active - terminating\n",
74ca47
+						"sync_send_results - conn=%" PRIu64 " op=%d Operation no longer active - terminating\n",
74ca47
 						connid, opid);
74ca47
 			break;
74ca47
 		}
74ca47
diff --git a/ldap/servers/plugins/syntaxes/validate_task.c b/ldap/servers/plugins/syntaxes/validate_task.c
74ca47
index eae2d2a..c051573 100644
74ca47
--- a/ldap/servers/plugins/syntaxes/validate_task.c
74ca47
+++ b/ldap/servers/plugins/syntaxes/validate_task.c
74ca47
@@ -201,12 +201,12 @@ syntax_validate_task_thread(void *arg)
74ca47
 	slapi_pblock_destroy(search_pb);
74ca47
 
74ca47
 	/* Log finished message. */
74ca47
-	slapi_task_log_notice(task, "Syntax validate task complete.  Found %" NSPRIu64
74ca47
+	slapi_task_log_notice(task, "Syntax validate task complete.  Found %" PRIu64
74ca47
 	                " invalid entries.\n", slapi_counter_get_value(td->invalid_entries));
74ca47
-	slapi_task_log_status(task, "Syntax validate task complete.  Found %" NSPRIu64
74ca47
+	slapi_task_log_status(task, "Syntax validate task complete.  Found %" PRIu64
74ca47
 	                " invalid entries.\n", slapi_counter_get_value(td->invalid_entries));
74ca47
 	slapi_log_err(SLAPI_LOG_ERR, SYNTAX_PLUGIN_SUBSYSTEM, "syntax_validate_task_thread - Complete."
74ca47
-	                "  Found %" NSPRIu64 " invalid entries.\n",
74ca47
+	                "  Found %" PRIu64 " invalid entries.\n",
74ca47
 	                slapi_counter_get_value(td->invalid_entries));
74ca47
 	slapi_task_inc_progress(task);
74ca47
 
74ca47
diff --git a/ldap/servers/plugins/usn/usn.c b/ldap/servers/plugins/usn/usn.c
74ca47
index 5e67e0a..54ebc31 100644
74ca47
--- a/ldap/servers/plugins/usn/usn.c
74ca47
+++ b/ldap/servers/plugins/usn/usn.c
74ca47
@@ -320,7 +320,7 @@ _usn_add_next_usn(Slapi_Entry *e, Slapi_Backend *be)
74ca47
                     "--> _usn_add_next_usn\n");
74ca47
 
74ca47
     /* add next USN to the entry; "be" contains the usn counter */
74ca47
-    usn_berval.bv_val = slapi_ch_smprintf("%" NSPRIu64, 
74ca47
+    usn_berval.bv_val = slapi_ch_smprintf("%" PRIu64, 
74ca47
                                           slapi_counter_get_value(be->be_usn_counter));
74ca47
     usn_berval.bv_len = strlen(usn_berval.bv_val);
74ca47
     slapi_entry_attr_find(e, SLAPI_ATTR_ENTRYUSN, &attr);
74ca47
@@ -360,7 +360,7 @@ _usn_mod_next_usn(LDAPMod ***mods, Slapi_Backend *be)
74ca47
 
74ca47
     /* add next USN to the mods; "be" contains the usn counter */
74ca47
     usn_berval.bv_val = counter_buf;
74ca47
-    snprintf(usn_berval.bv_val, USN_COUNTER_BUF_LEN, "%" NSPRIu64,
74ca47
+    snprintf(usn_berval.bv_val, USN_COUNTER_BUF_LEN, "%" PRIu64,
74ca47
                 slapi_counter_get_value(be->be_usn_counter));
74ca47
     usn_berval.bv_len = strlen(usn_berval.bv_val);
74ca47
     bvals[0] = &usn_berval;
74ca47
@@ -681,7 +681,7 @@ usn_rootdse_search(Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entry* entryAfter,
74ca47
             /* get a next USN counter from be_usn_counter; 
74ca47
              * then minus 1 from it (except if be_usn_counter has value 0) */
74ca47
             if (slapi_counter_get_value(be->be_usn_counter)) {
74ca47
-                snprintf(usn_berval.bv_val, USN_COUNTER_BUF_LEN, "%" NSPRIu64,
74ca47
+                snprintf(usn_berval.bv_val, USN_COUNTER_BUF_LEN, "%" PRIu64,
74ca47
                             slapi_counter_get_value(be->be_usn_counter)-1);
74ca47
             } else {
74ca47
                 snprintf(usn_berval.bv_val, USN_COUNTER_BUF_LEN, "-1");
74ca47
@@ -704,7 +704,7 @@ usn_rootdse_search(Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entry* entryAfter,
74ca47
             /* get a next USN counter from be_usn_counter; 
74ca47
              * then minus 1 from it (except if be_usn_counter has value 0) */
74ca47
             if (slapi_counter_get_value(be->be_usn_counter)) {
74ca47
-                snprintf(usn_berval.bv_val, USN_COUNTER_BUF_LEN, "%" NSPRIu64,
74ca47
+                snprintf(usn_berval.bv_val, USN_COUNTER_BUF_LEN, "%" PRIu64,
74ca47
                             slapi_counter_get_value(be->be_usn_counter)-1);
74ca47
             } else {
74ca47
                 snprintf(usn_berval.bv_val, USN_COUNTER_BUF_LEN, "-1");
74ca47
diff --git a/ldap/servers/slapd/abandon.c b/ldap/servers/slapd/abandon.c
74ca47
index 18ff8ce..0485006 100644
74ca47
--- a/ldap/servers/slapd/abandon.c
74ca47
+++ b/ldap/servers/slapd/abandon.c
74ca47
@@ -119,19 +119,19 @@ do_abandon( Slapi_PBlock *pb )
74ca47
 	}
74ca47
 
74ca47
 	if ( 0 == pagedresults_free_one_msgid_nolock(pb->pb_conn, id) ) {
74ca47
-		slapi_log_access( LDAP_DEBUG_STATS, "conn=%" NSPRIu64 
74ca47
+		slapi_log_access( LDAP_DEBUG_STATS, "conn=%" PRIu64 
74ca47
 		    " op=%d ABANDON targetop=Simple Paged Results msgid=%d\n",
74ca47
 		    pb->pb_conn->c_connid, pb->pb_op->o_opid, id );
74ca47
 	} else if ( NULL == o ) {
74ca47
-		slapi_log_access( LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d ABANDON"
74ca47
+		slapi_log_access( LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d ABANDON"
74ca47
 			" targetop=NOTFOUND msgid=%d\n",
74ca47
 			pb->pb_conn->c_connid, pb->pb_op->o_opid, id );
74ca47
 	} else if ( suppressed_by_plugin ) {
74ca47
-		slapi_log_access( LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d ABANDON"
74ca47
+		slapi_log_access( LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d ABANDON"
74ca47
 			" targetop=SUPPRESSED-BY-PLUGIN msgid=%d\n",
74ca47
 			pb->pb_conn->c_connid, pb->pb_op->o_opid, id );
74ca47
 	} else {
74ca47
-		slapi_log_access( LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d ABANDON"
74ca47
+		slapi_log_access( LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d ABANDON"
74ca47
 			" targetop=%d msgid=%d nentries=%d etime=%ld\n",
74ca47
 			pb->pb_conn->c_connid, pb->pb_op->o_opid, o->o_opid, id,
74ca47
 			o->o_results.r.r_search.nentries, current_time() - o->o_time );
74ca47
diff --git a/ldap/servers/slapd/add.c b/ldap/servers/slapd/add.c
74ca47
index 1b994a0..9c4001e 100644
74ca47
--- a/ldap/servers/slapd/add.c
74ca47
+++ b/ldap/servers/slapd/add.c
74ca47
@@ -168,7 +168,7 @@ do_add( Slapi_PBlock *pb )
74ca47
 			if (( rc = slapi_entry_add_values( e, normtype, vals ))
74ca47
 				!= LDAP_SUCCESS ) {
74ca47
 				slapi_log_access( LDAP_DEBUG_STATS, 
74ca47
-					"conn=%" NSPRIu64 " op=%d ADD dn=\"%s\", add values for type %s failed\n",
74ca47
+					"conn=%" PRIu64 " op=%d ADD dn=\"%s\", add values for type %s failed\n",
74ca47
 					pb->pb_conn->c_connid, operation->o_opid,
74ca47
 					slapi_entry_get_dn_const(e), normtype );
74ca47
 				send_ldap_result( pb, rc, NULL, NULL, 0, NULL );
74ca47
@@ -460,7 +460,7 @@ static void op_shared_add (Slapi_PBlock *pb)
74ca47
 
74ca47
 		if ( !internal_op )
74ca47
 		{
74ca47
-			slapi_log_access(LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d ADD dn=\"%s\"%s\n",
74ca47
+			slapi_log_access(LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d ADD dn=\"%s\"%s\n",
74ca47
 							 pb->pb_conn->c_connid,
74ca47
 							 operation->o_opid,
74ca47
 							 slapi_entry_get_dn_const(e),
74ca47
diff --git a/ldap/servers/slapd/auth.c b/ldap/servers/slapd/auth.c
74ca47
index c787dd4..da1b586 100644
74ca47
--- a/ldap/servers/slapd/auth.c
74ca47
+++ b/ldap/servers/slapd/auth.c
74ca47
@@ -366,7 +366,7 @@ handle_bad_certificate (void* clientData, PRFileDesc *prfd)
74ca47
     char* subject = subject_of (clientCert);
74ca47
     char* issuer  = issuer_of  (clientCert);
74ca47
     slapi_log_access( LDAP_DEBUG_STATS,
74ca47
-	       "conn=%" NSPRIu64 " " SLAPI_COMPONENT_NAME_NSPR " error %i (%s); unauthenticated client %s; issuer %s\n",
74ca47
+	       "conn=%" PRIu64 " " SLAPI_COMPONENT_NAME_NSPR " error %i (%s); unauthenticated client %s; issuer %s\n",
74ca47
 	       conn->c_connid, errorCode, slapd_pr_strerror(errorCode),
74ca47
 	       subject ? escape_string( subject, sbuf ) : "NULL",
74ca47
 	       issuer  ? escape_string( issuer,  ibuf ) : "NULL" );
74ca47
@@ -402,7 +402,7 @@ handle_handshake_done (PRFileDesc *prfd, void* clientData)
74ca47
 	if ( (slapd_ssl_getChannelInfo (prfd, &channelInfo, sizeof(channelInfo))) != SECSuccess ) {
74ca47
 		PRErrorCode errorCode = PR_GetError();
74ca47
 		slapi_log_access (LDAP_DEBUG_STATS,
74ca47
-			"conn=%" NSPRIu64 " SSL failed to obtain channel info; "
74ca47
+			"conn=%" PRIu64 " SSL failed to obtain channel info; "
74ca47
 			SLAPI_COMPONENT_NAME_NSPR " error %i (%s)\n",
74ca47
 			conn->c_connid, errorCode, slapd_pr_strerror(errorCode));
74ca47
 		goto done;
74ca47
@@ -411,7 +411,7 @@ handle_handshake_done (PRFileDesc *prfd, void* clientData)
74ca47
 			!= SECSuccess) {
74ca47
 		PRErrorCode errorCode = PR_GetError();
74ca47
 		slapi_log_access (LDAP_DEBUG_STATS,
74ca47
-			"conn=%" NSPRIu64 " SSL failed to obtain cipher info; "
74ca47
+			"conn=%" PRIu64 " SSL failed to obtain cipher info; "
74ca47
 			SLAPI_COMPONENT_NAME_NSPR " error %i (%s)\n",
74ca47
 			conn->c_connid, errorCode, slapd_pr_strerror(errorCode));
74ca47
 		goto done;
74ca47
@@ -432,14 +432,14 @@ handle_handshake_done (PRFileDesc *prfd, void* clientData)
74ca47
 
74ca47
     if (config_get_SSLclientAuth() == SLAPD_SSLCLIENTAUTH_OFF ) {
74ca47
         (void) slapi_getSSLVersion_str(channelInfo.protocolVersion, sslversion, sizeof(sslversion));
74ca47
-        slapi_log_access (LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " %s %i-bit %s\n",
74ca47
+        slapi_log_access (LDAP_DEBUG_STATS, "conn=%" PRIu64 " %s %i-bit %s\n",
74ca47
                 conn->c_connid, 
74ca47
                 sslversion, keySize, cipher ? cipher : "NULL" );
74ca47
         goto done;
74ca47
     }
74ca47
     if (clientCert == NULL) {
74ca47
         (void) slapi_getSSLVersion_str(channelInfo.protocolVersion, sslversion, sizeof(sslversion));
74ca47
-        slapi_log_access (LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " %s %i-bit %s\n",
74ca47
+        slapi_log_access (LDAP_DEBUG_STATS, "conn=%" PRIu64 " %s %i-bit %s\n",
74ca47
                 conn->c_connid, 
74ca47
                 sslversion, keySize, cipher ? cipher : "NULL" );
74ca47
     } else {
74ca47
@@ -448,7 +448,7 @@ handle_handshake_done (PRFileDesc *prfd, void* clientData)
74ca47
             (void) slapi_getSSLVersion_str(channelInfo.protocolVersion,
74ca47
                                                  sslversion, sizeof(sslversion));
74ca47
             slapi_log_access( LDAP_DEBUG_STATS,
74ca47
-                       "conn=%" NSPRIu64 " %s %i-bit %s; missing subject\n",
74ca47
+                       "conn=%" PRIu64 " %s %i-bit %s; missing subject\n",
74ca47
                        conn->c_connid, 
74ca47
                        sslversion, keySize, cipher ? cipher : "NULL");
74ca47
             goto done;
74ca47
@@ -459,7 +459,7 @@ handle_handshake_done (PRFileDesc *prfd, void* clientData)
74ca47
             (void) slapi_getSSLVersion_str(channelInfo.protocolVersion,
74ca47
                                                  sslversion, sizeof(sslversion));
74ca47
             slapi_log_access( LDAP_DEBUG_STATS,
74ca47
-                        "conn=%" NSPRIu64 " %s %i-bit %s; client %s; issuer %s\n",
74ca47
+                        "conn=%" PRIu64 " %s %i-bit %s; client %s; issuer %s\n",
74ca47
                         conn->c_connid,
74ca47
                         sslversion, keySize, cipher ? cipher : "NULL",
74ca47
                         subject ? escape_string( subject, sbuf ) : "NULL",
74ca47
@@ -503,14 +503,14 @@ handle_handshake_done (PRFileDesc *prfd, void* clientData)
74ca47
         (void) slapi_getSSLVersion_str(channelInfo.protocolVersion,
74ca47
                                              sslversion, sizeof(sslversion));
74ca47
         slapi_log_access (LDAP_DEBUG_STATS, 
74ca47
-                          "conn=%" NSPRIu64 " %s client bound as %s\n",
74ca47
+                          "conn=%" PRIu64 " %s client bound as %s\n",
74ca47
                           conn->c_connid,
74ca47
                           sslversion, clientDN);
74ca47
     } else if (clientCert != NULL) {
74ca47
         (void) slapi_getSSLVersion_str(channelInfo.protocolVersion,
74ca47
                                              sslversion, sizeof(sslversion));
74ca47
         slapi_log_access (LDAP_DEBUG_STATS,
74ca47
-                          "conn=%" NSPRIu64 " %s failed to map client "
74ca47
+                          "conn=%" PRIu64 " %s failed to map client "
74ca47
                           "certificate to LDAP DN (%s)\n",
74ca47
                           conn->c_connid,
74ca47
                           sslversion, extraErrorMsg);
74ca47
diff --git a/ldap/servers/slapd/back-ldbm/back-ldbm.h b/ldap/servers/slapd/back-ldbm/back-ldbm.h
74ca47
index a5fc540..0bb15e3 100644
74ca47
--- a/ldap/servers/slapd/back-ldbm/back-ldbm.h
74ca47
+++ b/ldap/servers/slapd/back-ldbm/back-ldbm.h
74ca47
@@ -28,21 +28,8 @@
74ca47
 #endif
74ca47
 #endif
74ca47
 
74ca47
-/* Required to get portable printf/scanf format macros */
74ca47
-#ifdef HAVE_INTTYPES_H
74ca47
-#include <inttypes.h>
74ca47
-
74ca47
-/* NSPR uses the print macros a bit differently than ANSI C.  We
74ca47
- * need to use ll for a 64-bit integer, even when a long is 64-bit.
74ca47
- */
74ca47
-#undef PRIu64
74ca47
-#define PRIu64  "llu"
74ca47
-#undef PRI64
74ca47
-#define PRI64   "ll"
74ca47
-
74ca47
-#else
74ca47
-#error Need to define portable format macros such as PRIu64
74ca47
-#endif /* HAVE_INTTYPES_H */
74ca47
+/* Provides our int types and platform specific requirements. */
74ca47
+#include <slapi_pal.h>
74ca47
 
74ca47
 /* A bunch of random system headers taken from all the source files, no source file should #include
74ca47
    any system headers now */
74ca47
@@ -162,11 +149,11 @@ typedef unsigned short u_int16_t;
74ca47
 #define    DBVERSION_FILENAME    "DBVERSION"
74ca47
 /* 0 here means to let the autotuning reset the value on first run */
74ca47
 /* cache can't get any smaller than this (in bytes) */
74ca47
-#define MINCACHESIZE             (size_t)512000
74ca47
-#define DEFAULT_CACHE_SIZE       (size_t)0
74ca47
+#define MINCACHESIZE             (uint64_t)512000
74ca47
+#define DEFAULT_CACHE_SIZE       (uint64_t)0
74ca47
 #define DEFAULT_CACHE_SIZE_STR   "0"
74ca47
 #define DEFAULT_CACHE_ENTRIES    -1        /* no limit */
74ca47
-#define DEFAULT_DNCACHE_SIZE     (size_t)16777216
74ca47
+#define DEFAULT_DNCACHE_SIZE     (uint64_t)16777216
74ca47
 #define DEFAULT_DNCACHE_SIZE_STR "16777216"
74ca47
 #define DEFAULT_DNCACHE_MAXCOUNT -1        /* no limit */
74ca47
 #define DEFAULT_DBCACHE_SIZE     33554432
74ca47
diff --git a/ldap/servers/slapd/back-ldbm/cache.c b/ldap/servers/slapd/back-ldbm/cache.c
74ca47
index ade2240..0f0cf3b 100644
74ca47
--- a/ldap/servers/slapd/back-ldbm/cache.c
74ca47
+++ b/ldap/servers/slapd/back-ldbm/cache.c
74ca47
@@ -649,7 +649,7 @@ void cache_set_max_size(struct cache *cache, size_t bytes, int type)
74ca47
     }
74ca47
 }
74ca47
 
74ca47
-static void entrycache_set_max_size(struct cache *cache, size_t bytes)
74ca47
+static void entrycache_set_max_size(struct cache *cache, uint64_t bytes)
74ca47
 {
74ca47
     struct backentry *eflush = NULL;
74ca47
     struct backentry *eflushtemp = NULL;
74ca47
@@ -659,16 +659,17 @@ static void entrycache_set_max_size(struct cache *cache, size_t bytes)
74ca47
          * to happen. In that case, suppress this warning.
74ca47
          */
74ca47
         if (bytes > 0) {
74ca47
-            slapi_log_err(SLAPI_LOG_WARNING, "entrycache_set_max_size", "Minimum cache size is %lu -- rounding up\n", MINCACHESIZE);
74ca47
+            slapi_log_err(SLAPI_LOG_WARNING, "entrycache_set_max_size", "Minimum cache size is %"PRIu64" -- rounding up\n", MINCACHESIZE);
74ca47
         }
74ca47
         bytes = MINCACHESIZE;
74ca47
     }
74ca47
     cache_lock(cache);
74ca47
     cache->c_maxsize = bytes;
74ca47
-    LOG("entry cache size set to %lu\n", bytes);
74ca47
+    LOG("entry cache size set to %"PRIu64"\n", bytes);
74ca47
     /* check for full cache, and clear out if necessary */
74ca47
-    if (CACHE_FULL(cache))
74ca47
+    if (CACHE_FULL(cache)) {
74ca47
        eflush = entrycache_flush(cache);
74ca47
+    }
74ca47
     while (eflush)
74ca47
     {
74ca47
         eflushtemp = BACK_LRU_NEXT(eflush, struct backentry *);
74ca47
@@ -686,12 +687,11 @@ static void entrycache_set_max_size(struct cache *cache, size_t bytes)
74ca47
     /* This may already have been called by one of the functions in
74ca47
      * ldbm_instance_config
74ca47
      */
74ca47
-    if (! util_is_cachesize_sane(&bytes)) {
74ca47
-       slapi_log_err(SLAPI_LOG_WARNING,
74ca47
-                "entrycache_set_max_size", "Possible CONFIGURATION ERROR -- cachesize "
74ca47
-                "(%lu) may be configured to use more than the available "
74ca47
-                "physical memory.\n", bytes);
74ca47
+    slapi_pal_meminfo *mi = spal_meminfo_get();
74ca47
+    if (util_is_cachesize_sane(mi, &bytes) != UTIL_CACHESIZE_VALID) {
74ca47
+       slapi_log_err(SLAPI_LOG_WARNING, "entrycache_set_max_size", "Cachesize (%"PRIu64") may use more than the available physical memory.\n", bytes);
74ca47
     }
74ca47
+    spal_meminfo_destroy(mi);
74ca47
 }
74ca47
 
74ca47
 void cache_set_max_entries(struct cache *cache, long entries)
74ca47
@@ -1597,7 +1597,7 @@ dn_same_id(const void *bdn, const void *k)
74ca47
 }
74ca47
 
74ca47
 static void
74ca47
-dncache_set_max_size(struct cache *cache, size_t bytes)
74ca47
+dncache_set_max_size(struct cache *cache, uint64_t bytes)
74ca47
 {
74ca47
     struct backdn *dnflush = NULL;
74ca47
     struct backdn *dnflushtemp = NULL;
74ca47
@@ -1609,12 +1609,12 @@ dncache_set_max_size(struct cache *cache, size_t bytes)
74ca47
     if (bytes < MINCACHESIZE) {
74ca47
        bytes = MINCACHESIZE;
74ca47
        slapi_log_err(SLAPI_LOG_WARNING,
74ca47
-                "dncache_set_max_size", "Minimum cache size is %lu -- rounding up\n",
74ca47
+                "dncache_set_max_size", "Minimum cache size is %"PRIu64" -- rounding up\n",
74ca47
                 MINCACHESIZE);
74ca47
     }
74ca47
     cache_lock(cache);
74ca47
     cache->c_maxsize = bytes;
74ca47
-    LOG("entry cache size set to %lu\n", bytes);
74ca47
+    LOG("entry cache size set to %"PRIu64"\n", bytes);
74ca47
     /* check for full cache, and clear out if necessary */
74ca47
     if (CACHE_FULL(cache)) {
74ca47
        dnflush = dncache_flush(cache);
74ca47
@@ -1636,12 +1636,12 @@ dncache_set_max_size(struct cache *cache, size_t bytes)
74ca47
     /* This may already have been called by one of the functions in
74ca47
      * ldbm_instance_config
74ca47
      */
74ca47
-    if (! util_is_cachesize_sane(&bytes)) {
74ca47
-       slapi_log_err(SLAPI_LOG_WARNING,
74ca47
-                "dncache_set_max_size", "Possible CONFIGURATION ERROR -- cachesize "
74ca47
-                "(%lu) may be configured to use more than the available "
74ca47
-                "physical memory.\n", bytes);
74ca47
+
74ca47
+    slapi_pal_meminfo *mi = spal_meminfo_get();
74ca47
+    if (util_is_cachesize_sane(mi, &bytes) != UTIL_CACHESIZE_VALID) {
74ca47
+       slapi_log_err(SLAPI_LOG_WARNING, "dncache_set_max_size", "Cachesize (%"PRIu64") may use more than the available physical memory.\n", bytes);
74ca47
     }
74ca47
+    spal_meminfo_destroy(mi);
74ca47
 }
74ca47
 
74ca47
 /* remove a dn from the cache */
74ca47
diff --git a/ldap/servers/slapd/back-ldbm/dblayer.c b/ldap/servers/slapd/back-ldbm/dblayer.c
74ca47
index 507a3cc..3c1fbb0 100644
74ca47
--- a/ldap/servers/slapd/back-ldbm/dblayer.c
74ca47
+++ b/ldap/servers/slapd/back-ldbm/dblayer.c
74ca47
@@ -1386,14 +1386,16 @@ dblayer_start(struct ldbminfo *li, int dbmode)
74ca47
 
74ca47
     /* Sanity check on cache size on platforms which allow us to figure out
74ca47
      * the available phys mem */
74ca47
-    if (!util_is_cachesize_sane(&(priv->dblayer_cachesize))) {
74ca47
+    slapi_pal_meminfo *mi = spal_meminfo_get();
74ca47
+    if (!util_is_cachesize_sane(mi, &(priv->dblayer_cachesize))) {
74ca47
         /* Oops---looks like the admin misconfigured, let's warn them */
74ca47
         slapi_log_err(SLAPI_LOG_WARNING,"dblayer_start", "Likely CONFIGURATION ERROR -"
74ca47
                   "dbcachesize is configured to use more than the available "
74ca47
-                  "physical memory, decreased to the largest available size (%lu bytes).\n",
74ca47
+                  "physical memory, decreased to the largest available size (%"PRIu64" bytes).\n",
74ca47
                   priv->dblayer_cachesize);
74ca47
         li->li_dbcachesize = priv->dblayer_cachesize;
74ca47
     }
74ca47
+    spal_meminfo_destroy(mi);
74ca47
 
74ca47
     /* fill in DB_ENV stuff from the common configuration */
74ca47
     return_value = dblayer_make_env(&pEnv, li);
74ca47
@@ -1690,9 +1692,6 @@ dblayer_start(struct ldbminfo *li, int dbmode)
74ca47
  *    nsslapd-import-cache-autosize: 0
74ca47
  * get the nsslapd-import-cachesize.
74ca47
  * Calculate the memory size left after allocating the import cache size.
74ca47
- * If the size is less than the hard limit, it issues an error and quit.
74ca47
- * If the size is greater than the hard limit and less than the soft limit,
74ca47
- * it issues a warning, but continues the import task.
74ca47
  *
74ca47
  * Note: this function is called only if the import is executed as a stand
74ca47
  * alone command line (ldif2db).
74ca47
@@ -1700,27 +1699,17 @@ dblayer_start(struct ldbminfo *li, int dbmode)
74ca47
 int
74ca47
 check_and_set_import_cache(struct ldbminfo *li)
74ca47
 {
74ca47
-    size_t import_pages = 0;
74ca47
-    size_t pagesize, pages, procpages, availpages;
74ca47
-    size_t soft_limit = 0;
74ca47
-    size_t hard_limit = 0;
74ca47
-    size_t page_delta = 0;
74ca47
+    uint64_t import_cache = 0;
74ca47
     char s[64];   /* big enough to hold %ld */
74ca47
+    /* Get our platform memory values. */
74ca47
+    slapi_pal_meminfo *mi = spal_meminfo_get();
74ca47
 
74ca47
-    if (util_info_sys_pages(&pagesize, &pages, &procpages, &availpages) != 0 || 0 == pagesize || 0 == pages) {
74ca47
-        slapi_log_err(SLAPI_LOG_ERR, "check_and_set_import_cache",
74ca47
-                       "Failed to get pagesize: %ld or pages: %ld\n",
74ca47
-                       pagesize, pages);
74ca47
+    if (mi == NULL) {
74ca47
+        slapi_log_err(SLAPI_LOG_ERR, "check_and_set_import_cache", "Failed to get system memory infomation\n");
74ca47
         return ENOENT;
74ca47
     }
74ca47
-    slapi_log_err(SLAPI_LOG_INFO, "check_and_set_import_cache",
74ca47
-                  "pagesize: %ld, pages: %ld, procpages: %ld\n",
74ca47
-                  pagesize, pages, procpages);
74ca47
+    slapi_log_err(SLAPI_LOG_INFO, "check_and_set_import_cache", "pagesize: %"PRIu64", available bytes %"PRIu64", process usage %"PRIu64" \n", mi->pagesize_bytes, mi->system_available_bytes, mi->process_consumed_bytes);
74ca47
 
74ca47
-    /* Soft limit: pages equivalent to 1GB (defined in dblayer.h) */
74ca47
-    soft_limit = (DBLAYER_IMPORTCACHESIZE_SL*1024) / (pagesize/1024);
74ca47
-    /* Hard limit: pages equivalent to 100MB (defined in dblayer.h) */
74ca47
-    hard_limit = (DBLAYER_IMPORTCACHESIZE_HL*1024) / (pagesize/1024);
74ca47
     /*
74ca47
      * default behavior for ldif2db import cache,
74ca47
      * nsslapd-import-cache-autosize==-1,
74ca47
@@ -1741,48 +1730,29 @@ check_and_set_import_cache(struct ldbminfo *li)
74ca47
 
74ca47
     if (li->li_import_cache_autosize == 0) {
74ca47
         /* user specified importCache */
74ca47
-        import_pages = li->li_import_cachesize / pagesize;
74ca47
+        import_cache = li->li_import_cachesize;
74ca47
 
74ca47
     } else {
74ca47
         /* autosizing importCache */
74ca47
         /* ./125 instead of ./100 is for adjusting the BDB overhead. */
74ca47
-#ifdef LINUX
74ca47
-        /* On linux, availpages is correct so we should use it! */
74ca47
-        import_pages = (li->li_import_cache_autosize * availpages) / 125;
74ca47
-#else
74ca47
-        import_pages = (li->li_import_cache_autosize * pages) / 125;
74ca47
-#endif
74ca47
+        import_cache = (li->li_import_cache_autosize * mi->system_available_bytes) / 125;
74ca47
     }
74ca47
 
74ca47
-    page_delta = pages - import_pages;
74ca47
-    if (page_delta < hard_limit) {
74ca47
-        slapi_log_err(SLAPI_LOG_ERR, 
74ca47
-            "check_and_set_import_cache", "After allocating import cache %ldKB, "
74ca47
-            "the available memory is %ldKB, "
74ca47
-            "which is less than the hard limit %ldKB. "
74ca47
-            "Please decrease the import cache size and rerun import.\n",
74ca47
-            import_pages*(pagesize/1024), page_delta*(pagesize/1024),
74ca47
-            hard_limit*(pagesize/1024));
74ca47
+    if (util_is_cachesize_sane(mi, &import_cache) == UTIL_CACHESIZE_ERROR) {
74ca47
+
74ca47
+        slapi_log_err(SLAPI_LOG_INFO, "check_and_set_import_cache", "Import failed to run: unable to validate system memory limits.\n");
74ca47
+        spal_meminfo_destroy(mi);
74ca47
         return ENOMEM;
74ca47
     }
74ca47
-    if (page_delta < soft_limit) {
74ca47
-        slapi_log_err(SLAPI_LOG_WARNING, 
74ca47
-            "check_and_set_import_cache", "After allocating import cache %ldKB, "
74ca47
-            "the available memory is %ldKB, "
74ca47
-            "which is less than the soft limit %ldKB. "
74ca47
-            "You may want to decrease the import cache size and "
74ca47
-            "rerun import.\n",
74ca47
-            import_pages*(pagesize/1024), page_delta*(pagesize/1024),
74ca47
-            soft_limit*(pagesize/1024));
74ca47
-    }
74ca47
 
74ca47
-    slapi_log_err(SLAPI_LOG_INFO, "check_and_set_import_cache", "Import allocates %ldKB import cache.\n", 
74ca47
-                  import_pages*(pagesize/1024));
74ca47
-    if (li->li_import_cache_autosize > 0) { /* import cache autosizing */
74ca47
+    slapi_log_err(SLAPI_LOG_INFO, "check_and_set_import_cache", "Import allocates %"PRIu64"KB import cache.\n", import_cache / 1024);
74ca47
+    if (li->li_import_cache_autosize > 0) {
74ca47
+        /* import cache autosizing */
74ca47
         /* set the calculated import cache size to the config */
74ca47
-        sprintf(s, "%lu", (unsigned long)(import_pages * pagesize));
74ca47
+        sprintf(s, "%"PRIu64, import_cache);
74ca47
         ldbm_config_internal_set(li, CONFIG_IMPORT_CACHESIZE, s);
74ca47
     }
74ca47
+    spal_meminfo_destroy(mi);
74ca47
     return 0;
74ca47
 }
74ca47
 
74ca47
diff --git a/ldap/servers/slapd/back-ldbm/dblayer.h b/ldap/servers/slapd/back-ldbm/dblayer.h
74ca47
index e4307fc..816c943 100644
74ca47
--- a/ldap/servers/slapd/back-ldbm/dblayer.h
74ca47
+++ b/ldap/servers/slapd/back-ldbm/dblayer.h
74ca47
@@ -68,14 +68,6 @@
74ca47
 #define	DB_REGION_NAME	25		/* DB: named regions, no backing file. */
74ca47
 #endif
74ca47
 
74ca47
-/* Used in check_and_set_import_cache */
74ca47
-/* After allocating the import cache, free memory must be left more than
74ca47
- * the hard limit to run import. */
74ca47
-/* If the free memory size left is greater than hard limit and less than
74ca47
- * soft limit, the import utility issues a warning, but it runs */
74ca47
-#define DBLAYER_IMPORTCACHESIZE_HL 100  /* import cache hard limit 100MB */
74ca47
-#define DBLAYER_IMPORTCACHESIZE_SL 1024 /* import cache soft limit 1GB */
74ca47
-
74ca47
 struct dblayer_private_env {
74ca47
 	DB_ENV	*dblayer_DB_ENV;
74ca47
 	Slapi_RWLock * dblayer_env_lock;
74ca47
diff --git a/ldap/servers/slapd/back-ldbm/import-threads.c b/ldap/servers/slapd/back-ldbm/import-threads.c
74ca47
index 087103b..ab32e0a 100644
74ca47
--- a/ldap/servers/slapd/back-ldbm/import-threads.c
74ca47
+++ b/ldap/servers/slapd/back-ldbm/import-threads.c
74ca47
@@ -3979,7 +3979,7 @@ _get_import_entryusn(ImportJob *job, Slapi_Value **usn_value)
74ca47
              * Use the counter which stores the old DB's
74ca47
              * next entryusn. */
74ca47
             PR_snprintf(counter_buf, sizeof(counter_buf),
74ca47
-                    "%" NSPRIu64, slapi_counter_get_value(be->be_usn_counter));
74ca47
+                    "%" PRIu64, slapi_counter_get_value(be->be_usn_counter));
74ca47
         } else {
74ca47
             /* import_init value is digit.
74ca47
              * Initialize the entryusn values with the digit */
74ca47
diff --git a/ldap/servers/slapd/back-ldbm/import.c b/ldap/servers/slapd/back-ldbm/import.c
74ca47
index d0cef1a..7161bac 100644
74ca47
--- a/ldap/servers/slapd/back-ldbm/import.c
74ca47
+++ b/ldap/servers/slapd/back-ldbm/import.c
74ca47
@@ -84,17 +84,19 @@ static int import_fifo_init(ImportJob *job)
74ca47
 int import_fifo_validate_capacity_or_expand(ImportJob *job, size_t entrysize) {
74ca47
     int result = 1;
74ca47
     /* We shoot for four times as much to start with. */
74ca47
-    size_t request = entrysize * 4;
74ca47
-    int sane = 0;
74ca47
+    uint64_t request = entrysize * 4;
74ca47
+    util_cachesize_result sane;
74ca47
 
74ca47
     if (entrysize > job->fifo.bsize) {
74ca47
         /* Check the amount of memory on the system */
74ca47
-        sane = util_is_cachesize_sane(&request);
74ca47
-        if (!sane && entrysize <= request) {
74ca47
+        slapi_pal_meminfo *mi = spal_meminfo_get();
74ca47
+        sane = util_is_cachesize_sane(mi, &request);
74ca47
+        spal_meminfo_destroy(mi);
74ca47
+        if (sane == UTIL_CACHESIZE_REDUCED && entrysize <= request) {
74ca47
             /* Did the amount cachesize set still exceed entrysize? It'll do ... */
74ca47
             job->fifo.bsize = request;
74ca47
             result = 0;
74ca47
-        } else if (!sane) {
74ca47
+        } else if (sane != UTIL_CACHESIZE_VALID) {
74ca47
             /* Can't allocate! No!!! */
74ca47
             result = 1;
74ca47
         } else {
74ca47
diff --git a/ldap/servers/slapd/back-ldbm/ldbm_config.c b/ldap/servers/slapd/back-ldbm/ldbm_config.c
74ca47
index dfe7a13..d5120d3 100644
74ca47
--- a/ldap/servers/slapd/back-ldbm/ldbm_config.c
74ca47
+++ b/ldap/servers/slapd/back-ldbm/ldbm_config.c
74ca47
@@ -403,8 +403,8 @@ static int ldbm_config_dbcachesize_set(void *arg, void *value, char *errorbuf, i
74ca47
 {
74ca47
     struct ldbminfo *li = (struct ldbminfo *) arg;
74ca47
     int retval = LDAP_SUCCESS;
74ca47
-    size_t val = (size_t)value;
74ca47
-    size_t delta = (size_t)value;
74ca47
+    uint64_t val = (size_t)value;
74ca47
+    uint64_t delta = (size_t)value;
74ca47
 
74ca47
     /* There is an error here. We check the new val against our current mem-alloc 
74ca47
      * Issue is that we already are using system pages, so while our value *might*
74ca47
@@ -430,7 +430,13 @@ static int ldbm_config_dbcachesize_set(void *arg, void *value, char *errorbuf, i
74ca47
             val = DBDEFMINSIZ;
74ca47
         } else if (val > li->li_dbcachesize) {
74ca47
             delta = val - li->li_dbcachesize;
74ca47
-            if (!util_is_cachesize_sane(&delta)){
74ca47
+
74ca47
+            util_cachesize_result sane;
74ca47
+            slapi_pal_meminfo *mi = spal_meminfo_get();
74ca47
+            sane = util_is_cachesize_sane(mi, &delta);
74ca47
+            spal_meminfo_destroy(mi);
74ca47
+
74ca47
+            if (sane != UTIL_CACHESIZE_VALID){
74ca47
                 slapi_create_errormsg(errorbuf, SLAPI_DSE_RETURNTEXT_SIZE, "Error: nsslapd-dbcachesize value is too large.");
74ca47
                 slapi_log_err(SLAPI_LOG_ERR, "ldbm_config_dbcachesize_set",
74ca47
                         "nsslapd-dbcachesize value is too large.\n");
74ca47
@@ -1086,7 +1092,7 @@ static int ldbm_config_db_cache_set(void *arg, void *value, char *errorbuf, int
74ca47
     struct ldbminfo *li = (struct ldbminfo *) arg;
74ca47
     int retval = LDAP_SUCCESS;
74ca47
     int val = ((uintptr_t)value);
74ca47
-    size_t delta = 0;
74ca47
+    uint64_t delta = 0;
74ca47
 
74ca47
     /* There is an error here. We check the new val against our current mem-alloc 
74ca47
      * Issue is that we already are using system pages, so while our value *might*
74ca47
@@ -1101,7 +1107,13 @@ static int ldbm_config_db_cache_set(void *arg, void *value, char *errorbuf, int
74ca47
     if (apply) {
74ca47
         if (val > li->li_dblayer_private->dblayer_cache_config) {
74ca47
             delta = val - li->li_dblayer_private->dblayer_cache_config;
74ca47
-            if (!util_is_cachesize_sane(&delta)){
74ca47
+            util_cachesize_result sane;
74ca47
+
74ca47
+            slapi_pal_meminfo *mi = spal_meminfo_get();
74ca47
+            sane = util_is_cachesize_sane(mi, &delta);
74ca47
+            spal_meminfo_destroy(mi);
74ca47
+
74ca47
+            if (sane != UTIL_CACHESIZE_VALID){
74ca47
                 slapi_create_errormsg(errorbuf, SLAPI_DSE_RETURNTEXT_SIZE, "Error: db cachesize value is too large");
74ca47
                 slapi_log_err(SLAPI_LOG_ERR,"ldbm_config_db_cache_set", "db cachesize value is too large.\n");
74ca47
                 return LDAP_UNWILLING_TO_PERFORM;
74ca47
@@ -1219,7 +1231,7 @@ static int ldbm_config_import_cachesize_set(void *arg, void *value, char *errorb
74ca47
 {
74ca47
     struct ldbminfo *li = (struct ldbminfo *)arg;
74ca47
     size_t val = (size_t)value;
74ca47
-    size_t delta = (size_t)value;
74ca47
+    uint64_t delta = (size_t)value;
74ca47
     /* There is an error here. We check the new val against our current mem-alloc 
74ca47
      * Issue is that we already are using system pages, so while our value *might*
74ca47
      * be valid, we may reject it here due to the current procs page usage.
74ca47
@@ -1232,7 +1244,13 @@ static int ldbm_config_import_cachesize_set(void *arg, void *value, char *errorb
74ca47
     if (apply){
74ca47
         if (val > li->li_import_cachesize) {
74ca47
             delta = val - li->li_import_cachesize;
74ca47
-            if (!util_is_cachesize_sane(&delta)){
74ca47
+
74ca47
+            util_cachesize_result sane;
74ca47
+            slapi_pal_meminfo *mi = spal_meminfo_get();
74ca47
+            sane = util_is_cachesize_sane(mi, &delta);
74ca47
+            spal_meminfo_destroy(mi);
74ca47
+
74ca47
+            if (sane != UTIL_CACHESIZE_VALID){
74ca47
                 slapi_create_errormsg(errorbuf, SLAPI_DSE_RETURNTEXT_SIZE, "Error: import cachesize value is too large.");
74ca47
                 slapi_log_err(SLAPI_LOG_ERR,"ldbm_config_import_cachesize_set",
74ca47
                         "Import cachesize value is too large.\n");
74ca47
diff --git a/ldap/servers/slapd/back-ldbm/ldbm_delete.c b/ldap/servers/slapd/back-ldbm/ldbm_delete.c
74ca47
index 92d982e..0b0b37e 100644
74ca47
--- a/ldap/servers/slapd/back-ldbm/ldbm_delete.c
74ca47
+++ b/ldap/servers/slapd/back-ldbm/ldbm_delete.c
74ca47
@@ -107,7 +107,7 @@ ldbm_back_delete( Slapi_PBlock *pb )
74ca47
 
74ca47
 	if (pb->pb_conn)
74ca47
 	{
74ca47
-		slapi_log_err(SLAPI_LOG_TRACE, "ldbm_back_delete", "Enter conn=%" NSPRIu64 " op=%d\n",
74ca47
+		slapi_log_err(SLAPI_LOG_TRACE, "ldbm_back_delete", "Enter conn=%" PRIu64 " op=%d\n",
74ca47
 				pb->pb_conn->c_connid, operation->o_opid);
74ca47
 	}
74ca47
 
74ca47
@@ -1493,7 +1493,7 @@ diskfull_return:
74ca47
 	slapi_sdn_done(&parentsdn);
74ca47
 	if (pb->pb_conn)
74ca47
 	{
74ca47
-		slapi_log_err(SLAPI_LOG_TRACE, "ldbm_back_delete", "leave conn=%" NSPRIu64 " op=%d\n",
74ca47
+		slapi_log_err(SLAPI_LOG_TRACE, "ldbm_back_delete", "leave conn=%" PRIu64 " op=%d\n",
74ca47
 				pb->pb_conn->c_connid, operation->o_opid);
74ca47
 	}
74ca47
 
74ca47
diff --git a/ldap/servers/slapd/back-ldbm/ldbm_instance_config.c b/ldap/servers/slapd/back-ldbm/ldbm_instance_config.c
74ca47
index e03954d..62cdbc3 100644
74ca47
--- a/ldap/servers/slapd/back-ldbm/ldbm_instance_config.c
74ca47
+++ b/ldap/servers/slapd/back-ldbm/ldbm_instance_config.c
74ca47
@@ -92,7 +92,7 @@ ldbm_instance_config_cachememsize_set(void *arg, void *value, char *errorbuf, in
74ca47
     ldbm_instance *inst = (ldbm_instance *) arg;
74ca47
     int retval = LDAP_SUCCESS;
74ca47
     size_t val = (size_t) value;
74ca47
-    size_t delta = 0;
74ca47
+    uint64_t delta = 0;
74ca47
 
74ca47
     /* Do whatever we can to make sure the data is ok. */
74ca47
     /* There is an error here. We check the new val against our current mem-alloc 
74ca47
@@ -108,7 +108,13 @@ ldbm_instance_config_cachememsize_set(void *arg, void *value, char *errorbuf, in
74ca47
     if (apply) {
74ca47
         if (val > inst->inst_cache.c_maxsize) {
74ca47
             delta = val - inst->inst_cache.c_maxsize;
74ca47
-            if (!util_is_cachesize_sane(&delta)){
74ca47
+
74ca47
+            util_cachesize_result sane;
74ca47
+            slapi_pal_meminfo *mi = spal_meminfo_get();
74ca47
+            sane = util_is_cachesize_sane(mi, &delta);
74ca47
+            spal_meminfo_destroy(mi);
74ca47
+
74ca47
+            if (sane != UTIL_CACHESIZE_VALID){
74ca47
                 slapi_create_errormsg(errorbuf, SLAPI_DSE_RETURNTEXT_SIZE, "Error: cachememsize value is too large.");
74ca47
                 slapi_log_err(SLAPI_LOG_ERR, "ldbm_instance_config_cachememsize_set", "cachememsize value is too large.\n");
74ca47
                 return LDAP_UNWILLING_TO_PERFORM;
74ca47
@@ -134,7 +140,7 @@ ldbm_instance_config_dncachememsize_set(void *arg, void *value, char *errorbuf,
74ca47
     ldbm_instance *inst = (ldbm_instance *) arg;
74ca47
     int retval = LDAP_SUCCESS;
74ca47
     size_t val = (size_t)value;
74ca47
-    size_t delta = 0;
74ca47
+    uint64_t delta = 0;
74ca47
 
74ca47
     /* Do whatever we can to make sure the data is ok. */
74ca47
     /* There is an error here. We check the new val against our current mem-alloc 
74ca47
@@ -150,7 +156,13 @@ ldbm_instance_config_dncachememsize_set(void *arg, void *value, char *errorbuf,
74ca47
     if (apply) {
74ca47
         if (val > inst->inst_dncache.c_maxsize) {
74ca47
             delta = val - inst->inst_dncache.c_maxsize;
74ca47
-            if (!util_is_cachesize_sane(&delta)){
74ca47
+
74ca47
+            util_cachesize_result sane;
74ca47
+            slapi_pal_meminfo *mi = spal_meminfo_get();
74ca47
+            sane = util_is_cachesize_sane(mi, &delta);
74ca47
+            spal_meminfo_destroy(mi);
74ca47
+
74ca47
+            if (sane != UTIL_CACHESIZE_VALID){
74ca47
                 slapi_create_errormsg(errorbuf, SLAPI_DSE_RETURNTEXT_SIZE,
74ca47
                     "Error: dncachememsize value is too large.");
74ca47
                 slapi_log_err(SLAPI_LOG_ERR,"ldbm_instance_config_dncachememsize_set",
74ca47
diff --git a/ldap/servers/slapd/back-ldbm/ldbm_modrdn.c b/ldap/servers/slapd/back-ldbm/ldbm_modrdn.c
74ca47
index a78d850..533273b 100644
74ca47
--- a/ldap/servers/slapd/back-ldbm/ldbm_modrdn.c
74ca47
+++ b/ldap/servers/slapd/back-ldbm/ldbm_modrdn.c
74ca47
@@ -142,7 +142,7 @@ ldbm_back_modrdn( Slapi_PBlock *pb )
74ca47
 
74ca47
     if (pb->pb_conn)
74ca47
     {
74ca47
-        slapi_log_err(SLAPI_LOG_TRACE, "ldbm_back_modrdn", "enter conn=%" NSPRIu64 " op=%d\n",
74ca47
+        slapi_log_err(SLAPI_LOG_TRACE, "ldbm_back_modrdn", "enter conn=%" PRIu64 " op=%d\n",
74ca47
                 pb->pb_conn->c_connid, operation->o_opid);
74ca47
     }
74ca47
 
74ca47
@@ -1539,7 +1539,7 @@ common_return:
74ca47
     if (pb->pb_conn)
74ca47
     {
74ca47
         slapi_log_err(SLAPI_LOG_TRACE, "ldbm_back_modrdn",
74ca47
-                "leave conn=%" NSPRIu64 " op=%d\n",
74ca47
+                "leave conn=%" PRIu64 " op=%d\n",
74ca47
                 pb->pb_conn->c_connid, operation->o_opid);
74ca47
     }
74ca47
     return retval;
74ca47
diff --git a/ldap/servers/slapd/back-ldbm/ldbm_search.c b/ldap/servers/slapd/back-ldbm/ldbm_search.c
74ca47
index a6c3b74..cfb0d6b 100644
74ca47
--- a/ldap/servers/slapd/back-ldbm/ldbm_search.c
74ca47
+++ b/ldap/servers/slapd/back-ldbm/ldbm_search.c
74ca47
@@ -407,7 +407,7 @@ ldbm_back_search( Slapi_PBlock *pb )
74ca47
                     slapi_pblock_get(pb, SLAPI_OPERATION_ID, &op_id);
74ca47
 
74ca47
                     slapi_log_err(SLAPI_LOG_WARNING,
74ca47
-                            "ldbm_back_search", "Sort control ignored for conn=%" NSPRIu64 " op=%d\n",
74ca47
+                            "ldbm_back_search", "Sort control ignored for conn=%" PRIu64 " op=%d\n",
74ca47
                             conn_id, op_id);                    
74ca47
                 }
74ca47
             } else {
74ca47
@@ -442,7 +442,7 @@ ldbm_back_search( Slapi_PBlock *pb )
74ca47
                         slapi_pblock_get(pb, SLAPI_OPERATION_ID, &op_id);
74ca47
 
74ca47
                         slapi_log_err(SLAPI_LOG_WARNING,
74ca47
-                                "ldbm_back_search", "VLV control ignored for conn=%" NSPRIu64 " op=%d\n",
74ca47
+                                "ldbm_back_search", "VLV control ignored for conn=%" PRIu64 " op=%d\n",
74ca47
                                 conn_id, op_id);             
74ca47
                     }
74ca47
 
74ca47
diff --git a/ldap/servers/slapd/back-ldbm/misc.c b/ldap/servers/slapd/back-ldbm/misc.c
74ca47
index 5268087..7192b3a 100644
74ca47
--- a/ldap/servers/slapd/back-ldbm/misc.c
74ca47
+++ b/ldap/servers/slapd/back-ldbm/misc.c
74ca47
@@ -54,7 +54,7 @@ void ldbm_log_access_message(Slapi_PBlock *pblock,char *string)
74ca47
         return;
74ca47
     }
74ca47
     operation_id = operation->o_opid;
74ca47
-    slapi_log_access(LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d %s\n",
74ca47
+    slapi_log_access(LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d %s\n",
74ca47
                      connection_id, operation_id, string);
74ca47
 }
74ca47
 
74ca47
diff --git a/ldap/servers/slapd/back-ldbm/monitor.c b/ldap/servers/slapd/back-ldbm/monitor.c
74ca47
index 757792b..c58b069 100644
74ca47
--- a/ldap/servers/slapd/back-ldbm/monitor.c
74ca47
+++ b/ldap/servers/slapd/back-ldbm/monitor.c
74ca47
@@ -101,9 +101,9 @@ int ldbm_back_monitor_instance_search(Slapi_PBlock *pb, Slapi_Entry *e,
74ca47
         /* fetch cache statistics */
74ca47
         cache_get_stats(&(inst->inst_dncache), &hits, &tries, 
74ca47
                         &nentries, &maxentries, &size, &maxsize);
74ca47
-        sprintf(buf, "%" NSPRIu64, hits);
74ca47
+        sprintf(buf, "%" PRIu64, hits);
74ca47
         MSET("dnCacheHits");
74ca47
-        sprintf(buf, "%" NSPRIu64, tries);
74ca47
+        sprintf(buf, "%" PRIu64, tries);
74ca47
         MSET("dnCacheTries");
74ca47
         sprintf(buf, "%lu", (unsigned long)(100.0*(double)hits / (double)(tries > 0 ? tries : 1)));
74ca47
         MSET("dnCacheHitRatio");
74ca47
@@ -119,11 +119,11 @@ int ldbm_back_monitor_instance_search(Slapi_PBlock *pb, Slapi_Entry *e,
74ca47
     /* normalized dn cache stats */
74ca47
     if(ndn_cache_started()){
74ca47
         ndn_cache_get_stats(&hits, &tries, &size, &maxsize, &count);
74ca47
-        sprintf(buf, "%" NSPRIu64, tries);
74ca47
+        sprintf(buf, "%" PRIu64, tries);
74ca47
         MSET("normalizedDnCacheTries");
74ca47
-        sprintf(buf, "%" NSPRIu64, hits);
74ca47
+        sprintf(buf, "%" PRIu64, hits);
74ca47
         MSET("normalizedDnCacheHits");
74ca47
-        sprintf(buf, "%" NSPRIu64, (tries - hits));
74ca47
+        sprintf(buf, "%" PRIu64, (tries - hits));
74ca47
         MSET("normalizedDnCacheMisses");
74ca47
         sprintf(buf, "%lu", (unsigned long)(100.0*(double)hits / (double)(tries > 0 ? tries : 1)));
74ca47
         MSET("normalizedDnCacheHitRatio");
74ca47
diff --git a/ldap/servers/slapd/back-ldbm/perfctrs.h b/ldap/servers/slapd/back-ldbm/perfctrs.h
74ca47
index 57be1d1..64c79e1 100644
74ca47
--- a/ldap/servers/slapd/back-ldbm/perfctrs.h
74ca47
+++ b/ldap/servers/slapd/back-ldbm/perfctrs.h
74ca47
@@ -11,7 +11,7 @@
74ca47
 #  include <config.h>
74ca47
 #endif
74ca47
 
74ca47
-#include <inttypes.h>
74ca47
+#include <slapi_pal.h>
74ca47
 
74ca47
 /* Structure definition for performance data */
74ca47
 /* This stuff goes in shared memory, so make sure the packing is consistent */
74ca47
diff --git a/ldap/servers/slapd/back-ldbm/start.c b/ldap/servers/slapd/back-ldbm/start.c
74ca47
index 1ae9858..a207bd8 100644
74ca47
--- a/ldap/servers/slapd/back-ldbm/start.c
74ca47
+++ b/ldap/servers/slapd/back-ldbm/start.c
74ca47
@@ -32,34 +32,25 @@ ldbm_back_start_autotune(struct ldbminfo *li) {
74ca47
     Object *inst_obj = NULL;
74ca47
     ldbm_instance *inst = NULL;
74ca47
     /* size_t is a platform unsigned int, IE uint64_t */
74ca47
-    size_t total_cache_size = 0;
74ca47
-    size_t pagesize = 0;
74ca47
-    size_t pages = 0;
74ca47
-    size_t procpages __attribute__((unused)) = 0;
74ca47
-    size_t availpages = 0;
74ca47
-    size_t cache_size_to_configure = 0;
74ca47
-    size_t zone_pages = 0;
74ca47
-    size_t db_pages = 0;
74ca47
-    size_t entry_pages = 0;
74ca47
-    size_t import_pages = 0;
74ca47
-    size_t zone_size = 0;
74ca47
-    size_t import_size = 0;
74ca47
-    size_t cache_size = 0;
74ca47
-    size_t db_size = 0;
74ca47
+    uint64_t total_cache_size = 0;
74ca47
+    uint64_t entry_size = 0;
74ca47
+    uint64_t zone_size = 0;
74ca47
+    uint64_t import_size = 0;
74ca47
+    uint64_t cache_size = 0;
74ca47
+    uint64_t db_size = 0;
74ca47
     /* For clamping the autotune value to a 64Mb boundary */
74ca47
-    size_t clamp_pages = 0;
74ca47
-    size_t clamp_div = 0;
74ca47
-    size_t clamp_mod = 0;
74ca47
+    uint64_t clamp_div = 0;
74ca47
     /* Backend count */
74ca47
-    size_t backend_count = 0;
74ca47
+    uint64_t backend_count = 0;
74ca47
 
74ca47
     int_fast32_t autosize_percentage = 0;
74ca47
     int_fast32_t autosize_db_percentage_split = 0;
74ca47
     int_fast32_t import_percentage = 0;
74ca47
-    int32_t issane = 0;
74ca47
+    util_cachesize_result issane;
74ca47
     char *msg = ""; /* This will be set by one of the two cache sizing paths below. */
74ca47
     char size_to_str[32];    /* big enough to hold %ld */
74ca47
 
74ca47
+
74ca47
     /* == Begin autotune == */
74ca47
 
74ca47
     /*
74ca47
@@ -120,42 +111,34 @@ ldbm_back_start_autotune(struct ldbminfo *li) {
74ca47
         return SLAPI_FAIL_GENERAL;
74ca47
     }
74ca47
 
74ca47
-    if (util_info_sys_pages(&pagesize, &pages, &procpages, &availpages) != 0) {
74ca47
+    /* Get our platform memory values. */
74ca47
+    slapi_pal_meminfo *mi = spal_meminfo_get();
74ca47
+    if (mi == NULL) {
74ca47
         slapi_log_err(SLAPI_LOG_CRIT, "ldbm_back_start", "Unable to determine system page limits\n");
74ca47
         return SLAPI_FAIL_GENERAL;
74ca47
     }
74ca47
 
74ca47
-    if (pagesize == 0) {
74ca47
-        /* If this happens, we are in a very bad state indeed... */
74ca47
-        slapi_log_err(SLAPI_LOG_CRIT, "ldbm_back_start", "Unable to determine system page size\n");
74ca47
-        return SLAPI_FAIL_GENERAL;
74ca47
-    }
74ca47
-
74ca47
     /* calculate the needed values */
74ca47
-    zone_pages = (autosize_percentage * pages) / 100;
74ca47
-    zone_size = zone_pages * pagesize;
74ca47
+    zone_size = (autosize_percentage * mi->system_total_bytes) / 100;
74ca47
     /* This is how much we "might" use, lets check it's sane. */
74ca47
     /* In the case it is not, this will *reduce* the allocation */
74ca47
-    issane = util_is_cachesize_sane(&zone_size);
74ca47
-    if (!issane) {
74ca47
+    issane = util_is_cachesize_sane(mi, &zone_size);
74ca47
+    if (issane == UTIL_CACHESIZE_REDUCED) {
74ca47
         slapi_log_err(SLAPI_LOG_WARNING, "ldbm_back_start", "Your autosized cache values have been reduced. Likely your nsslapd-cache-autosize percentage is too high.\n");
74ca47
         slapi_log_err(SLAPI_LOG_WARNING, "ldbm_back_start", "%s", msg);
74ca47
     }
74ca47
     /* It's valid, lets divide it up and set according to user prefs */
74ca47
-    zone_pages = zone_size / pagesize;
74ca47
-    db_pages = (autosize_db_percentage_split * zone_pages) / 100;
74ca47
+    db_size = (autosize_db_percentage_split * zone_size) / 100;
74ca47
 
74ca47
     /* Cap the DB size at 512MB, as this doesn't help perf much more (lkrispen's advice) */
74ca47
-    if ((db_pages * pagesize) > (512 * MEGABYTE)) {
74ca47
-        db_pages = (512 * MEGABYTE) / pagesize;
74ca47
+    if (db_size > (512 * MEGABYTE)) {
74ca47
+        db_size = (512 * MEGABYTE);
74ca47
     }
74ca47
 
74ca47
     if (backend_count > 0 ) {
74ca47
         /* Number of entry cache pages per backend. */
74ca47
-        entry_pages = (zone_pages - db_pages) / backend_count;
74ca47
+        entry_size = (zone_size - db_size) / backend_count;
74ca47
         /* Now, clamp this value to a 64mb boundary. */
74ca47
-        /* How many pages are in 64mb? */
74ca47
-        clamp_pages = (64 * MEGABYTE) / pagesize;
74ca47
         /* Now divide the entry pages by this, and also mod. If mod != 0, we need
74ca47
          * to add 1 to the diveded number. This should give us:
74ca47
          * 510 * 1024 * 1024 == 510MB
74ca47
@@ -166,17 +149,15 @@ ldbm_back_start_autotune(struct ldbminfo *li) {
74ca47
          * 130560 % 16384 = 15872 which is != 0
74ca47
          * therfore 7 + 1, aka 8 * 16384 = 131072 pages = 536870912 bytes = 512MB.
74ca47
          */
74ca47
-        clamp_div = entry_pages / clamp_pages;
74ca47
-        clamp_mod = entry_pages % clamp_pages;
74ca47
-        if (clamp_mod != 0) {
74ca47
-            /* If we want to clamp down, remove this line. This would change the above from 510mb -> 448mb. */
74ca47
-            clamp_div += 1;
74ca47
-            entry_pages = clamp_div * clamp_pages;
74ca47
+        if (entry_size % (64 * MEGABYTE) != 0) {
74ca47
+            /* If we want to clamp down, remove the "+1". This would change the above from 510mb -> 448mb. */
74ca47
+            clamp_div = (entry_size / (64 * MEGABYTE)) + 1;
74ca47
+            entry_size = clamp_div * (64 * MEGABYTE);
74ca47
         }
74ca47
     }
74ca47
 
74ca47
-    slapi_log_err(SLAPI_LOG_NOTICE, "ldbm_back_start", "found %luk physical memory\n", pages*(pagesize/1024));
74ca47
-    slapi_log_err(SLAPI_LOG_NOTICE, "ldbm_back_start", "found %luk avaliable\n", zone_pages*(pagesize/1024));
74ca47
+    slapi_log_err(SLAPI_LOG_NOTICE, "ldbm_back_start", "found %luk physical memory\n", mi->system_total_bytes / 1024);
74ca47
+    slapi_log_err(SLAPI_LOG_NOTICE, "ldbm_back_start", "found %luk avaliable\n", mi->system_available_bytes / 1024);
74ca47
 
74ca47
     /* We've now calculated the autotuning values. Do we need to apply it?
74ca47
      * we use the logic of "if size is 0, or autosize is > 0. This way three
74ca47
@@ -191,13 +172,12 @@ ldbm_back_start_autotune(struct ldbminfo *li) {
74ca47
 
74ca47
     /* First, check the dbcache */
74ca47
     if (li->li_dbcachesize == 0 || li->li_cache_autosize > 0) {
74ca47
-        slapi_log_err(SLAPI_LOG_NOTICE, "ldbm_back_start", "cache autosizing: db cache: %luk\n", db_pages*(pagesize/1024));
74ca47
-        cache_size_to_configure = (unsigned long)(db_pages * pagesize);
74ca47
-        if (cache_size_to_configure < (500 * MEGABYTE)) {
74ca47
-            cache_size_to_configure = (unsigned long)((db_pages * pagesize) / 1.25);
74ca47
+        slapi_log_err(SLAPI_LOG_NOTICE, "ldbm_back_start", "cache autosizing: db cache: %luk\n", db_size / 1024);
74ca47
+        if (db_size < (500 * MEGABYTE)) {
74ca47
+            db_size = db_size / 1.25;
74ca47
         }
74ca47
         /* Have to set this value through text. */
74ca47
-        sprintf(size_to_str, "%lu", cache_size_to_configure);
74ca47
+        sprintf(size_to_str, "%" PRIu64 , db_size);
74ca47
         ldbm_config_internal_set(li, CONFIG_DBCACHESIZE, size_to_str);
74ca47
     }
74ca47
     total_cache_size += li->li_dbcachesize;
74ca47
@@ -205,7 +185,7 @@ ldbm_back_start_autotune(struct ldbminfo *li) {
74ca47
     /* For each backend */
74ca47
     /*   apply the appropriate cache size if 0 */
74ca47
     if (backend_count > 0 ) {
74ca47
-        li->li_cache_autosize_ec = (unsigned long)entry_pages * pagesize;
74ca47
+        li->li_cache_autosize_ec = entry_size;
74ca47
     }
74ca47
 
74ca47
     for (inst_obj = objset_first_obj(li->li_instance_set); inst_obj;
74ca47
@@ -220,7 +200,7 @@ ldbm_back_start_autotune(struct ldbminfo *li) {
74ca47
          * it's highly unlikely.
74ca47
          */
74ca47
         if (cache_size == 0 || cache_size == MINCACHESIZE || li->li_cache_autosize > 0) {
74ca47
-            slapi_log_err(SLAPI_LOG_NOTICE, "ldbm_back_start", "cache autosizing: %s entry cache (%lu total): %luk\n", inst->inst_name, backend_count, entry_pages*(pagesize/1024));
74ca47
+            slapi_log_err(SLAPI_LOG_NOTICE, "ldbm_back_start", "cache autosizing: %s entry cache (%lu total): %luk\n", inst->inst_name, backend_count, entry_size / 1024);
74ca47
             cache_set_max_entries(&(inst->inst_cache), -1);
74ca47
             cache_set_max_size(&(inst->inst_cache), li->li_cache_autosize_ec, CACHE_TYPE_ENTRY);
74ca47
         }
74ca47
@@ -229,8 +209,8 @@ ldbm_back_start_autotune(struct ldbminfo *li) {
74ca47
         db_size = dblayer_get_id2entry_size(inst);
74ca47
         if (cache_size < db_size) {
74ca47
             slapi_log_err(SLAPI_LOG_NOTICE, "ldbm_back_start",
74ca47
-                  "%s: entry cache size %lu B is "
74ca47
-                  "less than db size %lu B; "
74ca47
+                  "%s: entry cache size %"PRIu64" B is "
74ca47
+                  "less than db size %"PRIu64" B; "
74ca47
                   "We recommend to increase the entry cache size "
74ca47
                   "nsslapd-cachememsize.\n",
74ca47
                   inst->inst_name, cache_size, db_size);
74ca47
@@ -244,37 +224,36 @@ ldbm_back_start_autotune(struct ldbminfo *li) {
74ca47
     /* autosizing importCache */
74ca47
     if (li->li_import_cache_autosize > 0) {
74ca47
         /* Use import percentage here, as it's been corrected for -1 behaviour */
74ca47
-        import_pages = (import_percentage * pages) / 100;
74ca47
-        import_size = import_pages * pagesize;
74ca47
-        issane = util_is_cachesize_sane(&import_size);
74ca47
-        if (!issane) {
74ca47
+        import_size = (import_percentage * mi->system_total_bytes) / 100;
74ca47
+        issane = util_is_cachesize_sane(mi, &import_size);
74ca47
+        if (issane == UTIL_CACHESIZE_REDUCED) {
74ca47
             slapi_log_err(SLAPI_LOG_WARNING, "ldbm_back_start", "Your autosized import cache values have been reduced. Likely your nsslapd-import-cache-autosize percentage is too high.\n");
74ca47
         }
74ca47
         /* We just accept the reduced allocation here. */
74ca47
-        import_pages = import_size / pagesize;
74ca47
-        slapi_log_err(SLAPI_LOG_NOTICE, "ldbm_back_start", "cache autosizing: import cache: %luk\n",
74ca47
-        import_pages*(pagesize/1024));
74ca47
+        slapi_log_err(SLAPI_LOG_NOTICE, "ldbm_back_start", "cache autosizing: import cache: %"PRIu64"k\n", import_size / 1024);
74ca47
 
74ca47
-        sprintf(size_to_str, "%lu", (unsigned long)(import_pages * pagesize));
74ca47
+        sprintf(size_to_str, "%"PRIu64, import_size);
74ca47
         ldbm_config_internal_set(li, CONFIG_IMPORT_CACHESIZE, size_to_str);
74ca47
     }
74ca47
 
74ca47
     /* Finally, lets check that the total result is sane. */
74ca47
-    slapi_log_err(SLAPI_LOG_NOTICE, "ldbm_back_start", "total cache size: %lu B; \n", total_cache_size);
74ca47
+    slapi_log_err(SLAPI_LOG_NOTICE, "ldbm_back_start", "total cache size: %"PRIu64" B; \n", total_cache_size);
74ca47
 
74ca47
-    issane = util_is_cachesize_sane(&total_cache_size);
74ca47
-    if (!issane) {
74ca47
+    issane = util_is_cachesize_sane(mi, &total_cache_size);
74ca47
+    if (issane != UTIL_CACHESIZE_VALID) {
74ca47
         /* Right, it's time to panic */
74ca47
         slapi_log_err(SLAPI_LOG_WARNING, "ldbm_back_start", "It is highly likely your memory configuration of all backends will EXCEED your systems memory.\n");
74ca47
         slapi_log_err(SLAPI_LOG_WARNING, "ldbm_back_start", "In a future release this WILL prevent server start up. You MUST alter your configuration.\n");
74ca47
-        slapi_log_err(SLAPI_LOG_WARNING, "ldbm_back_start", "Total entry cache size: %lu B; dbcache size: %lu B; available memory size: %lu B; \n",
74ca47
-                  (PRUint64)total_cache_size, (PRUint64)li->li_dbcachesize, availpages * pagesize
74ca47
+        slapi_log_err(SLAPI_LOG_WARNING, "ldbm_back_start", "Total entry cache size: %"PRIu64" B; dbcache size: %"PRIu64" B; available memory size: %"PRIu64" B; \n",
74ca47
+                    total_cache_size, (uint64_t)li->li_dbcachesize, mi->system_available_bytes
74ca47
         );
74ca47
         slapi_log_err(SLAPI_LOG_WARNING, "ldbm_back_start", "%s\n", msg);
74ca47
         /* WB 2016 - This should be UNCOMMENTED in a future release */
74ca47
         /* return SLAPI_FAIL_GENERAL; */
74ca47
     }
74ca47
 
74ca47
+    spal_meminfo_destroy(mi);
74ca47
+
74ca47
     /* == End autotune == */
74ca47
     return 0;
74ca47
 }
74ca47
diff --git a/ldap/servers/slapd/bind.c b/ldap/servers/slapd/bind.c
74ca47
index f83df7d..648a0f9 100644
74ca47
--- a/ldap/servers/slapd/bind.c
74ca47
+++ b/ldap/servers/slapd/bind.c
74ca47
@@ -853,25 +853,25 @@ log_bind_access (
74ca47
 {
74ca47
     if (method == LDAP_AUTH_SASL && saslmech && msg) {
74ca47
         slapi_log_access( LDAP_DEBUG_STATS, 
74ca47
-                          "conn=%" NSPRIu64 " op=%d BIND dn=\"%s\" "
74ca47
+                          "conn=%" PRIu64 " op=%d BIND dn=\"%s\" "
74ca47
                           "method=sasl version=%d mech=%s, %s\n",
74ca47
                           pb->pb_conn->c_connid, pb->pb_op->o_opid, dn,
74ca47
                           version, saslmech, msg );
74ca47
     } else if (method == LDAP_AUTH_SASL && saslmech) {
74ca47
         slapi_log_access( LDAP_DEBUG_STATS, 
74ca47
-                          "conn=%" NSPRIu64 " op=%d BIND dn=\"%s\" "
74ca47
+                          "conn=%" PRIu64 " op=%d BIND dn=\"%s\" "
74ca47
                           "method=sasl version=%d mech=%s\n",
74ca47
                           pb->pb_conn->c_connid, pb->pb_op->o_opid, dn,
74ca47
                           version, saslmech );
74ca47
     } else if (msg) {
74ca47
         slapi_log_access( LDAP_DEBUG_STATS, 
74ca47
-                          "conn=%" NSPRIu64 " op=%d BIND dn=\"%s\" "
74ca47
+                          "conn=%" PRIu64 " op=%d BIND dn=\"%s\" "
74ca47
                           "method=%" BERTAG_T " version=%d, %s\n",
74ca47
                           pb->pb_conn->c_connid, pb->pb_op->o_opid, dn,
74ca47
                           method, version, msg );
74ca47
     } else {
74ca47
         slapi_log_access( LDAP_DEBUG_STATS, 
74ca47
-                          "conn=%" NSPRIu64 " op=%d BIND dn=\"%s\" "
74ca47
+                          "conn=%" PRIu64 " op=%d BIND dn=\"%s\" "
74ca47
                           "method=%" BERTAG_T " version=%d\n",
74ca47
                           pb->pb_conn->c_connid, pb->pb_op->o_opid, dn,
74ca47
                           method, version );
74ca47
diff --git a/ldap/servers/slapd/compare.c b/ldap/servers/slapd/compare.c
74ca47
index 07ded98..3c03053 100644
74ca47
--- a/ldap/servers/slapd/compare.c
74ca47
+++ b/ldap/servers/slapd/compare.c
74ca47
@@ -111,7 +111,7 @@ do_compare( Slapi_PBlock *pb )
74ca47
 	    rawdn, ava.ava_type, 0 );
74ca47
 
74ca47
 	slapi_log_access( LDAP_DEBUG_STATS,
74ca47
-	    "conn=%" NSPRIu64 " op=%d CMP dn=\"%s\" attr=\"%s\"\n",
74ca47
+	    "conn=%" PRIu64 " op=%d CMP dn=\"%s\" attr=\"%s\"\n",
74ca47
 	    pb->pb_conn->c_connid, pb->pb_op->o_opid, dn, ava.ava_type );
74ca47
 
74ca47
 	/*
74ca47
diff --git a/ldap/servers/slapd/connection.c b/ldap/servers/slapd/connection.c
74ca47
index 7c83c66..359b59a 100644
74ca47
--- a/ldap/servers/slapd/connection.c
74ca47
+++ b/ldap/servers/slapd/connection.c
74ca47
@@ -411,7 +411,7 @@ connection_reset(Connection* conn, int ns, PRNetAddr * from, int fromLen, int is
74ca47
 
74ca47
     /* log useful stuff to our access log */
74ca47
     slapi_log_access( LDAP_DEBUG_STATS,
74ca47
-        "conn=%" NSPRIu64 " fd=%d slot=%d %sconnection from %s to %s\n",
74ca47
+        "conn=%" PRIu64 " fd=%d slot=%d %sconnection from %s to %s\n",
74ca47
         conn->c_connid, conn->c_sd, ns, pTmp, str_ip, str_destip );
74ca47
 
74ca47
     /* initialize the remaining connection fields */
74ca47
@@ -511,7 +511,7 @@ connection_need_new_password(const Connection *conn, const Operation *op, Slapi_
74ca47
 		op->o_tag != LDAP_REQ_ABANDON && op->o_tag != LDAP_REQ_EXTENDED)
74ca47
 	{
74ca47
 		slapi_add_pwd_control ( pb, LDAP_CONTROL_PWEXPIRED, 0);	
74ca47
-		slapi_log_access( LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d %s\n",
74ca47
+		slapi_log_access( LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d %s\n",
74ca47
 			pb->pb_conn->c_connid, pb->pb_op->o_opid,
74ca47
 			"UNPROCESSED OPERATION - need new password" );
74ca47
 		send_ldap_result( pb, LDAP_UNWILLING_TO_PERFORM, 
74ca47
@@ -562,7 +562,7 @@ connection_dispatch_operation(Connection *conn, Operation *op, Slapi_PBlock *pb)
74ca47
 	    (op->o_tag != LDAP_REQ_EXTENDED) && (op->o_tag != LDAP_REQ_UNBIND) &&
74ca47
 	    (op->o_tag != LDAP_REQ_ABANDON)) {
74ca47
 		slapi_log_access( LDAP_DEBUG_STATS,
74ca47
-			"conn=%" NSPRIu64 " op=%d UNPROCESSED OPERATION"
74ca47
+			"conn=%" PRIu64 " op=%d UNPROCESSED OPERATION"
74ca47
 			" - Insufficient SSF (local_ssf=%d sasl_ssf=%d ssl_ssf=%d)\n",
74ca47
 			conn->c_connid, op->o_opid, conn->c_local_ssf,
74ca47
 			conn->c_sasl_ssf, conn->c_ssl_ssf );
74ca47
@@ -591,7 +591,7 @@ connection_dispatch_operation(Connection *conn, Operation *op, Slapi_PBlock *pb)
74ca47
 	    (op->o_tag != LDAP_REQ_ABANDON) && (op->o_tag != LDAP_REQ_SEARCH))))
74ca47
 	{
74ca47
 		slapi_log_access( LDAP_DEBUG_STATS,
74ca47
-			"conn=%" NSPRIu64 " op=%d UNPROCESSED OPERATION"
74ca47
+			"conn=%" PRIu64 " op=%d UNPROCESSED OPERATION"
74ca47
 			" - Anonymous access not allowed\n",
74ca47
 			conn->c_connid, op->o_opid );
74ca47
 
74ca47
@@ -650,7 +650,7 @@ connection_dispatch_operation(Connection *conn, Operation *op, Slapi_PBlock *pb)
74ca47
 			int ret = setsockopt(conn->c_sd,IPPROTO_TCP,TCP_CORK,&i,sizeof(i));
74ca47
 			if (ret < 0) {
74ca47
 				slapi_log_err(SLAPI_LOG_ERR, "connection_dispatch_operation",
74ca47
-					"Failed to set TCP_CORK on connection %" NSPRIu64 "\n",conn->c_connid);
74ca47
+					"Failed to set TCP_CORK on connection %" PRIu64 "\n",conn->c_connid);
74ca47
 			}
74ca47
 			pop_cork = 1;
74ca47
 		}
74ca47
@@ -664,7 +664,7 @@ connection_dispatch_operation(Connection *conn, Operation *op, Slapi_PBlock *pb)
74ca47
 			int ret = setsockopt(conn->c_sd,IPPROTO_TCP,TCP_CORK,&i,sizeof(i));
74ca47
 			if (ret < 0) {
74ca47
 				slapi_log_err(SLAPI_LOG_ERR, "connection_dispatch_operation",
74ca47
-					"Failed to clear TCP_CORK on connection %" NSPRIu64 "\n",conn->c_connid);
74ca47
+					"Failed to clear TCP_CORK on connection %" PRIu64 "\n",conn->c_connid);
74ca47
 			}
74ca47
 		}
74ca47
 #endif
74ca47
@@ -690,7 +690,7 @@ connection_dispatch_operation(Connection *conn, Operation *op, Slapi_PBlock *pb)
74ca47
 
74ca47
 	default:
74ca47
 		slapi_log_err(SLAPI_LOG_ERR,
74ca47
-		    "connection_dispatch_operation", "Ignoring unknown LDAP request (conn=%" NSPRIu64 ", tag=0x%lx)\n",
74ca47
+		    "connection_dispatch_operation", "Ignoring unknown LDAP request (conn=%" PRIu64 ", tag=0x%lx)\n",
74ca47
 		    conn->c_connid, op->o_tag);
74ca47
 		break;
74ca47
 	}
74ca47
@@ -702,7 +702,7 @@ int connection_release_nolock_ext (Connection *conn, int release_only)
74ca47
     if (conn->c_refcnt <= 0)
74ca47
     {
74ca47
         slapi_log_err(SLAPI_LOG_ERR, "connection_release_nolock_ext",
74ca47
-		                "conn=%" NSPRIu64 " fd=%d Attempt to release connection that is not acquired\n",
74ca47
+		                "conn=%" PRIu64 " fd=%d Attempt to release connection that is not acquired\n",
74ca47
 		                conn->c_connid, conn->c_sd);
74ca47
         PR_ASSERT (PR_FALSE);
74ca47
         return -1;
74ca47
@@ -734,7 +734,7 @@ int connection_acquire_nolock_ext (Connection *conn, int allow_when_closing)
74ca47
     {
74ca47
 	/* This may happen while other threads are still working on this connection */
74ca47
         slapi_log_err(SLAPI_LOG_ERR, "connection_acquire_nolock_ext",
74ca47
-		                "conn=%" NSPRIu64 " fd=%d Attempt to acquire connection in the closing state\n",
74ca47
+		                "conn=%" PRIu64 " fd=%d Attempt to acquire connection in the closing state\n",
74ca47
 		                conn->c_connid, conn->c_sd);
74ca47
         return -1;
74ca47
     }
74ca47
@@ -1070,7 +1070,7 @@ get_next_from_buffer( void *buffer, size_t buffer_size, ber_len_t *lenp,
74ca47
 		syserr = errno;
74ca47
 		/* Bad stuff happened, like the client sent us some junk */
74ca47
 		slapi_log_err(SLAPI_LOG_CONNS, "get_next_from_buffer",
74ca47
-			"ber_get_next failed for connection %" NSPRIu64 "\n", conn->c_connid);
74ca47
+			"ber_get_next failed for connection %" PRIu64 "\n", conn->c_connid);
74ca47
 		/* reset private buffer */
74ca47
 		conn->c_private->c_buffer_bytes = conn->c_private->c_buffer_offset = 0;
74ca47
 
74ca47
@@ -1232,7 +1232,7 @@ int connection_read_operation(Connection *conn, Operation *op, ber_tag_t *tag, i
74ca47
 						/* Otherwise we loop, unless we exceeded the ioblock timeout */
74ca47
 						if (waits_done > ioblocktimeout_waits) {
74ca47
 							slapi_log_err(SLAPI_LOG_CONNS,"connection_read_operation",
74ca47
-								"ioblocktimeout expired on connection %" NSPRIu64 "\n", conn->c_connid);
74ca47
+								"ioblocktimeout expired on connection %" PRIu64 "\n", conn->c_connid);
74ca47
 							disconnect_server_nomutex( conn, conn->c_connid, -1,
74ca47
 									SLAPD_DISCONNECT_IO_TIMEOUT, 0 );
74ca47
 							ret = CONN_DONE;
74ca47
@@ -1253,19 +1253,19 @@ int connection_read_operation(Connection *conn, Operation *op, ber_tag_t *tag, i
74ca47
 					err = PR_GetError();
74ca47
 					syserr = PR_GetOSError();
74ca47
 					slapi_log_err(SLAPI_LOG_ERR, "connection_read_operation",
74ca47
-						"PR_Poll for connection %" NSPRIu64 " returns %d (%s)\n", conn->c_connid, err, slapd_pr_strerror( err ) );
74ca47
+						"PR_Poll for connection %" PRIu64 " returns %d (%s)\n", conn->c_connid, err, slapd_pr_strerror( err ) );
74ca47
 					/* If this happens we should close the connection */
74ca47
 					disconnect_server_nomutex( conn, conn->c_connid, -1, err, syserr );
74ca47
 					ret = CONN_DONE;
74ca47
 					goto done;
74ca47
 				}
74ca47
 				slapi_log_err(SLAPI_LOG_CONNS,
74ca47
-					   "connection_read_operation", "connection %" NSPRIu64 " waited %d times for read to be ready\n", conn->c_connid, waits_done);
74ca47
+					   "connection_read_operation", "connection %" PRIu64 " waited %d times for read to be ready\n", conn->c_connid, waits_done);
74ca47
 			} else {
74ca47
 				/* Some other error, typically meaning bad stuff */
74ca47
 					syserr = PR_GetOSError();
74ca47
 					slapi_log_err(SLAPI_LOG_CONNS, "connection_read_operation",
74ca47
-						"PR_Recv for connection %" NSPRIu64 " returns %d (%s)\n", conn->c_connid, err, slapd_pr_strerror( err ) );
74ca47
+						"PR_Recv for connection %" PRIu64 " returns %d (%s)\n", conn->c_connid, err, slapd_pr_strerror( err ) );
74ca47
 					/* If this happens we should close the connection */
74ca47
 					disconnect_server_nomutex( conn, conn->c_connid, -1, err, syserr );
74ca47
 					ret = CONN_DONE;
74ca47
@@ -1286,7 +1286,7 @@ int connection_read_operation(Connection *conn, Operation *op, ber_tag_t *tag, i
74ca47
 				}
74ca47
 			}
74ca47
 			slapi_log_err(SLAPI_LOG_CONNS,
74ca47
-				   "connection_read_operation", "connection %" NSPRIu64 " read %d bytes\n", conn->c_connid, ret);
74ca47
+				   "connection_read_operation", "connection %" PRIu64 " read %d bytes\n", conn->c_connid, ret);
74ca47
 
74ca47
 			new_operation = 0;
74ca47
 			ret = CONN_FOUND_WORK_TO_DO;
74ca47
@@ -1307,7 +1307,7 @@ int connection_read_operation(Connection *conn, Operation *op, ber_tag_t *tag, i
74ca47
 		 * We received a non-LDAP message.  Log and close connection.
74ca47
 		 */
74ca47
 		slapi_log_err(SLAPI_LOG_ERR,
74ca47
-			"connection_read_operation", "conn=%" NSPRIu64 " received a non-LDAP message (tag 0x%lx, expected 0x%lx)\n",
74ca47
+			"connection_read_operation", "conn=%" PRIu64 " received a non-LDAP message (tag 0x%lx, expected 0x%lx)\n",
74ca47
 			conn->c_connid, *tag, LDAP_TAG_MESSAGE );
74ca47
 		disconnect_server_nomutex( conn, conn->c_connid, -1,
74ca47
 			SLAPD_DISCONNECT_BAD_BER_TAG, EPROTO );
74ca47
@@ -1319,7 +1319,7 @@ int connection_read_operation(Connection *conn, Operation *op, ber_tag_t *tag, i
74ca47
 		!= LDAP_TAG_MSGID ) {
74ca47
 		/* log, close and send error */
74ca47
 		slapi_log_err(SLAPI_LOG_ERR,
74ca47
-			"connection_read_operation", "conn=%" NSPRIu64 " unable to read tag for incoming request\n", conn->c_connid);
74ca47
+			"connection_read_operation", "conn=%" PRIu64 " unable to read tag for incoming request\n", conn->c_connid);
74ca47
 		disconnect_server_nomutex( conn, conn->c_connid, -1, SLAPD_DISCONNECT_BAD_BER_TAG, EPROTO );
74ca47
 		ret = CONN_DONE;
74ca47
 		goto done;
74ca47
@@ -1337,7 +1337,7 @@ int connection_read_operation(Connection *conn, Operation *op, ber_tag_t *tag, i
74ca47
 	  case LDAP_TAG_LDAPDN: /* optional username, for CLDAP */
74ca47
 		/* log, close and send error */
74ca47
 		slapi_log_err(SLAPI_LOG_ERR,
74ca47
-			"connection_read_operation", "conn=%" NSPRIu64 " ber_peek_tag returns 0x%lx\n", conn->c_connid, *tag);
74ca47
+			"connection_read_operation", "conn=%" PRIu64 " ber_peek_tag returns 0x%lx\n", conn->c_connid, *tag);
74ca47
 		disconnect_server_nomutex( conn, conn->c_connid, -1, SLAPD_DISCONNECT_BER_PEEK, EPROTO );
74ca47
 		ret = CONN_DONE;
74ca47
 		goto done;
74ca47
@@ -1361,7 +1361,7 @@ void connection_make_readable(Connection *conn)
74ca47
 void connection_make_readable_nolock(Connection *conn)
74ca47
 {
74ca47
 	conn->c_gettingber = 0;
74ca47
-	slapi_log_err(SLAPI_LOG_CONNS, "connection_make_readable_nolock", "making readable conn %" NSPRIu64 " fd=%d\n",
74ca47
+	slapi_log_err(SLAPI_LOG_CONNS, "connection_make_readable_nolock", "making readable conn %" PRIu64 " fd=%d\n",
74ca47
 		       conn->c_connid, conn->c_sd);
74ca47
 	if (!(conn->c_flags & CONN_FLAG_CLOSING)) {
74ca47
 		/* if the connection is closing, try the close in connection_release_nolock */
74ca47
@@ -1388,7 +1388,7 @@ void connection_check_activity_level(Connection *conn)
74ca47
 	/* update the last checked time */
74ca47
 	conn->c_private->previous_count_check_time = current_time();
74ca47
 	PR_ExitMonitor(conn->c_mutex);
74ca47
-	slapi_log_err(SLAPI_LOG_CONNS,"connection_check_activity_level", "conn %" NSPRIu64 " activity level = %d\n",conn->c_connid,delta_count); 
74ca47
+	slapi_log_err(SLAPI_LOG_CONNS,"connection_check_activity_level", "conn %" PRIu64 " activity level = %d\n",conn->c_connid,delta_count); 
74ca47
 }
74ca47
 
74ca47
 typedef struct table_iterate_info_struct {
74ca47
@@ -1450,7 +1450,7 @@ void connection_enter_leave_turbo(Connection *conn, int current_turbo_flag, int
74ca47
 	  double activet = 0.0;
74ca47
 	  connection_find_our_rank(conn,&connection_count, &our_rank);
74ca47
 	  slapi_log_err(SLAPI_LOG_CONNS,"connection_enter_leave_turbo",
74ca47
-	      "conn %" NSPRIu64 " turbo rank = %d out of %d conns\n",conn->c_connid,our_rank,connection_count); 
74ca47
+	      "conn %" PRIu64 " turbo rank = %d out of %d conns\n",conn->c_connid,our_rank,connection_count); 
74ca47
 	  activet = (double)g_get_active_threadcnt();
74ca47
 	  threshold_rank = (int)(activet * ((double)CONN_TURBO_PERCENTILE / 100.0));
74ca47
 
74ca47
@@ -1491,9 +1491,9 @@ void connection_enter_leave_turbo(Connection *conn, int current_turbo_flag, int
74ca47
 	PR_ExitMonitor(conn->c_mutex);
74ca47
 	if (current_mode != new_mode) {
74ca47
 		if (current_mode) {
74ca47
-			slapi_log_err(SLAPI_LOG_CONNS,"connection_enter_leave_turbo", "conn %" NSPRIu64 " leaving turbo mode\n",conn->c_connid); 
74ca47
+			slapi_log_err(SLAPI_LOG_CONNS,"connection_enter_leave_turbo", "conn %" PRIu64 " leaving turbo mode\n",conn->c_connid); 
74ca47
 		} else {
74ca47
-			slapi_log_err(SLAPI_LOG_CONNS,"connection_enter_leave_turbo", "conn %" NSPRIu64 " entering turbo mode\n",conn->c_connid); 
74ca47
+			slapi_log_err(SLAPI_LOG_CONNS,"connection_enter_leave_turbo", "conn %" PRIu64 " entering turbo mode\n",conn->c_connid); 
74ca47
 		}
74ca47
 	}
74ca47
 	*new_turbo_flag = new_mode;
74ca47
@@ -1617,12 +1617,12 @@ connection_threadmain()
74ca47
 		ret = connection_read_operation(conn, op, &tag, &more_data);
74ca47
 		if ((ret == CONN_DONE) || (ret == CONN_TIMEDOUT)) {
74ca47
 			slapi_log_err(SLAPI_LOG_CONNS, "connection_threadmain",
74ca47
-					"conn %" NSPRIu64 " read not ready due to %d - thread_turbo_flag %d more_data %d "
74ca47
+					"conn %" PRIu64 " read not ready due to %d - thread_turbo_flag %d more_data %d "
74ca47
 					"ops_initiated %d refcnt %d flags %d\n", conn->c_connid, ret, thread_turbo_flag, more_data,
74ca47
 					conn->c_opsinitiated, conn->c_refcnt, conn->c_flags);
74ca47
 		} else if (ret == CONN_FOUND_WORK_TO_DO) {
74ca47
 			slapi_log_err(SLAPI_LOG_CONNS, "connection_threadmain",
74ca47
-					"conn %" NSPRIu64 " read operation successfully - thread_turbo_flag %d more_data %d "
74ca47
+					"conn %" PRIu64 " read operation successfully - thread_turbo_flag %d more_data %d "
74ca47
 					"ops_initiated %d refcnt %d flags %d\n", conn->c_connid, thread_turbo_flag, more_data,
74ca47
 					conn->c_opsinitiated, conn->c_refcnt, conn->c_flags);
74ca47
 		}
74ca47
@@ -1648,7 +1648,7 @@ connection_threadmain()
74ca47
 		if (thread_turbo_flag && !WORK_Q_EMPTY) {
74ca47
 			thread_turbo_flag = 0;
74ca47
 			slapi_log_err(SLAPI_LOG_CONNS,"connection_threadmain",
74ca47
-				"conn %" NSPRIu64 " leaving turbo mode - pb_q is not empty %d\n",
74ca47
+				"conn %" PRIu64 " leaving turbo mode - pb_q is not empty %d\n",
74ca47
 			    conn->c_connid,work_q_size);
74ca47
 		}
74ca47
 #endif
74ca47
@@ -1675,7 +1675,7 @@ connection_threadmain()
74ca47
 				 * connection_make_readable(conn);
74ca47
 				 */
74ca47
 				slapi_log_err(SLAPI_LOG_CONNS,"connection_threadmain",
74ca47
-					"conn %" NSPRIu64 " leaving turbo mode due to %d\n",
74ca47
+					"conn %" PRIu64 " leaving turbo mode due to %d\n",
74ca47
 					conn->c_connid,ret);
74ca47
 				goto done;
74ca47
 			case CONN_SHUTDOWN:
74ca47
@@ -1732,7 +1732,7 @@ connection_threadmain()
74ca47
 					 */
74ca47
 					conn->c_idlesince = curtime;
74ca47
 					connection_activity(conn, maxthreads);
74ca47
-					slapi_log_err(SLAPI_LOG_CONNS,"connection_threadmain", "conn %" NSPRIu64 " queued because more_data\n",
74ca47
+					slapi_log_err(SLAPI_LOG_CONNS,"connection_threadmain", "conn %" PRIu64 " queued because more_data\n",
74ca47
 					          conn->c_connid);
74ca47
 				} else {
74ca47
 					/* keep count of how many times maxthreads has blocked an operation */
74ca47
@@ -1814,7 +1814,7 @@ done:
74ca47
 			/* If we're in turbo mode, we keep our reference to the connection alive */
74ca47
 			/* can't use the more_data var because connection could have changed in another thread */
74ca47
 			more_data = conn_buffered_data_avail_nolock(conn, &conn_closed) ? 1 : 0;
74ca47
-			slapi_log_err(SLAPI_LOG_CONNS,"connection_threadmain", "conn %" NSPRIu64 " check more_data %d thread_turbo_flag %d\n",
74ca47
+			slapi_log_err(SLAPI_LOG_CONNS,"connection_threadmain", "conn %" PRIu64 " check more_data %d thread_turbo_flag %d\n",
74ca47
 			          conn->c_connid,more_data,thread_turbo_flag);
74ca47
 			if (!more_data) {
74ca47
 				if (!thread_turbo_flag) {
74ca47
@@ -1863,7 +1863,7 @@ connection_activity(Connection *conn, int maxthreads)
74ca47
 
74ca47
 	if (connection_acquire_nolock (conn) == -1) {
74ca47
 		slapi_log_err(SLAPI_LOG_CONNS,
74ca47
-		          "connection_activity", "Could not acquire lock in connection_activity as conn %" NSPRIu64 " closing fd=%d\n",
74ca47
+		          "connection_activity", "Could not acquire lock in connection_activity as conn %" PRIu64 " closing fd=%d\n",
74ca47
 		          conn->c_connid,conn->c_sd);
74ca47
 		/* XXX how to handle this error? */
74ca47
 		/* MAB: 25 Jan 01: let's return on error and pray this won't leak */
74ca47
@@ -2046,7 +2046,7 @@ connection_remove_operation( Connection *conn, Operation *op )
74ca47
 
74ca47
 	if ( *tmp == NULL )
74ca47
 	{
74ca47
-		slapi_log_err(SLAPI_LOG_ERR, "connection_remove_operation", "Can't find op %d for conn %" NSPRIu64 "\n",
74ca47
+		slapi_log_err(SLAPI_LOG_ERR, "connection_remove_operation", "Can't find op %d for conn %" PRIu64 "\n",
74ca47
 		    (int)op->o_msgid, conn->c_connid);
74ca47
 	}
74ca47
 	else
74ca47
@@ -2187,13 +2187,13 @@ log_ber_too_big_error(const Connection *conn, ber_len_t ber_len,
74ca47
 	}
74ca47
 	if (0 == ber_len) {
74ca47
 		slapi_log_err(SLAPI_LOG_ERR, "log_ber_too_big_error",
74ca47
-			"conn=%" NSPRIu64 " fd=%d Incoming BER Element was too long, max allowable"
74ca47
+			"conn=%" PRIu64 " fd=%d Incoming BER Element was too long, max allowable"
74ca47
 			" is %" BERLEN_T " bytes. Change the nsslapd-maxbersize attribute in"
74ca47
 			" cn=config to increase.\n",
74ca47
 			conn->c_connid, conn->c_sd, maxbersize );
74ca47
 	} else {
74ca47
 		slapi_log_err(SLAPI_LOG_ERR, "log_ber_too_big_error",
74ca47
-			"conn=%" NSPRIu64 " fd=%d Incoming BER Element was %" BERLEN_T " bytes, max allowable"
74ca47
+			"conn=%" PRIu64 " fd=%d Incoming BER Element was %" BERLEN_T " bytes, max allowable"
74ca47
 			" is %" BERLEN_T " bytes. Change the nsslapd-maxbersize attribute in"
74ca47
 			" cn=config to increase.\n",
74ca47
 			conn->c_connid, conn->c_sd, ber_len, maxbersize );
74ca47
@@ -2224,7 +2224,7 @@ disconnect_server_nomutex_ext( Connection *conn, PRUint64 opconnid, int opid, PR
74ca47
     if ( ( conn->c_sd != SLAPD_INVALID_SOCKET &&
74ca47
 	    conn->c_connid == opconnid ) && !(conn->c_flags & CONN_FLAG_CLOSING) )
74ca47
 	{
74ca47
-		slapi_log_err(SLAPI_LOG_CONNS, "disconnect_server_nomutex_ext", "Setting conn %" NSPRIu64 " fd=%d "
74ca47
+		slapi_log_err(SLAPI_LOG_CONNS, "disconnect_server_nomutex_ext", "Setting conn %" PRIu64 " fd=%d "
74ca47
 			  "to be disconnected: reason %d\n", conn->c_connid, conn->c_sd, reason);
74ca47
 		/*
74ca47
 		 * PR_Close must be called before anything else is done because
74ca47
@@ -2248,13 +2248,13 @@ disconnect_server_nomutex_ext( Connection *conn, PRUint64 opconnid, int opid, PR
74ca47
 		 */
74ca47
 		if (error && (EPIPE != error) ) {
74ca47
 			slapi_log_access( LDAP_DEBUG_STATS,
74ca47
-			  "conn=%" NSPRIu64 " op=%d fd=%d closed error %d (%s) - %s\n",
74ca47
+			  "conn=%" PRIu64 " op=%d fd=%d closed error %d (%s) - %s\n",
74ca47
 			  conn->c_connid, opid, conn->c_sd, error,
74ca47
 			  slapd_system_strerror(error),
74ca47
 			  slapd_pr_strerror(reason));
74ca47
 		} else {
74ca47
 			slapi_log_access( LDAP_DEBUG_STATS,
74ca47
-			  "conn=%" NSPRIu64 " op=%d fd=%d closed - %s\n",
74ca47
+			  "conn=%" PRIu64 " op=%d fd=%d closed - %s\n",
74ca47
 			  conn->c_connid, opid, conn->c_sd,
74ca47
 			  slapd_pr_strerror(reason));
74ca47
 		}
74ca47
diff --git a/ldap/servers/slapd/conntable.c b/ldap/servers/slapd/conntable.c
74ca47
index bcafa4e..30da055 100644
74ca47
--- a/ldap/servers/slapd/conntable.c
74ca47
+++ b/ldap/servers/slapd/conntable.c
74ca47
@@ -395,7 +395,7 @@ connection_table_as_entry(Connection_Table *ct, Slapi_Entry *e)
74ca47
 			 * 3 = The number of operations attempted that were blocked
74ca47
 			 *     by max threads.
74ca47
 			 */
74ca47
-			snprintf(maxthreadbuf, sizeof(maxthreadbuf), "%d:%"NSPRIu64":%"NSPRIu64"",
74ca47
+			snprintf(maxthreadbuf, sizeof(maxthreadbuf), "%d:%"PRIu64":%"PRIu64"",
74ca47
 				maxthreadstate, ct->c[i].c_maxthreadscount,
74ca47
 				ct->c[i].c_maxthreadsblocked);
74ca47
 
74ca47
@@ -431,17 +431,17 @@ connection_table_as_entry(Connection_Table *ct, Slapi_Entry *e)
74ca47
 	val.bv_len = strlen( buf );
74ca47
 	attrlist_replace( &e->e_attrs, "currentconnections", vals );
74ca47
 
74ca47
-	snprintf( buf, sizeof(buf), "%" NSPRIu64, slapi_counter_get_value(num_conns));
74ca47
+	snprintf( buf, sizeof(buf), "%" PRIu64, slapi_counter_get_value(num_conns));
74ca47
 	val.bv_val = buf;
74ca47
 	val.bv_len = strlen( buf );
74ca47
 	attrlist_replace( &e->e_attrs, "totalconnections", vals );
74ca47
 
74ca47
-	snprintf( buf, sizeof(buf), "%" NSPRIu64, slapi_counter_get_value(conns_in_maxthreads));
74ca47
+	snprintf( buf, sizeof(buf), "%" PRIu64, slapi_counter_get_value(conns_in_maxthreads));
74ca47
 	val.bv_val = buf;
74ca47
 	val.bv_len = strlen( buf );
74ca47
 	attrlist_replace( &e->e_attrs, "currentconnectionsatmaxthreads", vals );
74ca47
 
74ca47
-	snprintf( buf, sizeof(buf), "%" NSPRIu64, slapi_counter_get_value(max_threads_count));
74ca47
+	snprintf( buf, sizeof(buf), "%" PRIu64, slapi_counter_get_value(max_threads_count));
74ca47
 	val.bv_val = buf;
74ca47
 	val.bv_len = strlen( buf );
74ca47
 	attrlist_replace( &e->e_attrs, "maxthreadsperconnhits", vals );
74ca47
diff --git a/ldap/servers/slapd/control.c b/ldap/servers/slapd/control.c
74ca47
index 8f9e74e..52f2519 100644
74ca47
--- a/ldap/servers/slapd/control.c
74ca47
+++ b/ldap/servers/slapd/control.c
74ca47
@@ -335,7 +335,7 @@ get_ldapmessage_controls_ext(
74ca47
                 slapi_pblock_set(pb, SLAPI_REQCONTROLS, NULL);
74ca47
                 slapi_pblock_set(pb, SLAPI_MANAGEDSAIT, &ctrl_not_found);
74ca47
                 slapi_pblock_set(pb, SLAPI_PWPOLICY, &ctrl_not_found);
74ca47
-                slapi_log_err(SLAPI_LOG_CONNS, "get_ldapmessage_controls_ext", "Warning: conn=%" NSPRIu64 " op=%d contains an empty list of controls\n",
74ca47
+                slapi_log_err(SLAPI_LOG_CONNS, "get_ldapmessage_controls_ext", "Warning: conn=%" PRIu64 " op=%d contains an empty list of controls\n",
74ca47
                         pb->pb_conn->c_connid, pb->pb_op->o_opid);
74ca47
         } else {
74ca47
                 /* len, ber_len_t is uint, not int, cannot be != -1, may be better to remove this check.  */
74ca47
diff --git a/ldap/servers/slapd/daemon.c b/ldap/servers/slapd/daemon.c
74ca47
index a4ea4c0..5f2471e 100644
74ca47
--- a/ldap/servers/slapd/daemon.c
74ca47
+++ b/ldap/servers/slapd/daemon.c
74ca47
@@ -616,7 +616,7 @@ disk_monitoring_thread(void *nothing)
74ca47
          */
74ca47
         if(disk_space < 4096){ /* 4 k */
74ca47
             slapi_log_err(SLAPI_LOG_ALERT, "disk_monitoring_thread", "Disk space is critically low on disk (%s), "
74ca47
-            	"remaining space: %" NSPRIu64 " Kb.  Signaling slapd for shutdown...\n", dirstr , (disk_space / 1024));
74ca47
+            	"remaining space: %" PRIu64 " Kb.  Signaling slapd for shutdown...\n", dirstr , (disk_space / 1024));
74ca47
             g_set_shutdown( SLAPI_SHUTDOWN_EXIT );
74ca47
             return;
74ca47
         }
74ca47
@@ -626,7 +626,7 @@ disk_monitoring_thread(void *nothing)
74ca47
          */
74ca47
         if(verbose_logging != 0 && verbose_logging != LDAP_DEBUG_ANY){
74ca47
             slapi_log_err(SLAPI_LOG_ALERT, "disk_monitoring_thread", "Disk space is low on disk (%s), remaining space: "
74ca47
-            	"%" NSPRIu64 " Kb, temporarily setting error loglevel to the default level(%d).\n", dirstr,
74ca47
+            	"%" PRIu64 " Kb, temporarily setting error loglevel to the default level(%d).\n", dirstr,
74ca47
                 (disk_space / 1024), SLAPD_DEFAULT_ERRORLOG_LEVEL);
74ca47
             /* Setting the log level back to zero, actually sets the value to LDAP_DEBUG_ANY */
74ca47
             config_set_errorlog_level(CONFIG_LOGLEVEL_ATTRIBUTE,
74ca47
@@ -640,7 +640,7 @@ disk_monitoring_thread(void *nothing)
74ca47
          */
74ca47
         if(!logs_disabled && !logging_critical){
74ca47
             slapi_log_err(SLAPI_LOG_ALERT, "disk_monitoring_thread", "Disk space is too low on disk (%s), remaining "
74ca47
-            	"space: %" NSPRIu64 " Kb, disabling access and audit logging.\n", dirstr, (disk_space / 1024));
74ca47
+            	"space: %" PRIu64 " Kb, disabling access and audit logging.\n", dirstr, (disk_space / 1024));
74ca47
             config_set_accesslog_enabled(LOGGING_OFF);
74ca47
             config_set_auditlog_enabled(LOGGING_OFF);
74ca47
             config_set_auditfaillog_enabled(LOGGING_OFF);
74ca47
@@ -653,7 +653,7 @@ disk_monitoring_thread(void *nothing)
74ca47
          */
74ca47
         if(!deleted_rotated_logs && !logging_critical){
74ca47
             slapi_log_err(SLAPI_LOG_ALERT, "disk_monitoring_thread", "Disk space is too low on disk (%s), remaining "
74ca47
-            	"space: %" NSPRIu64 " Kb, deleting rotated logs.\n", dirstr, (disk_space / 1024));
74ca47
+            	"space: %" PRIu64 " Kb, deleting rotated logs.\n", dirstr, (disk_space / 1024));
74ca47
             log__delete_rotated_logs();
74ca47
             deleted_rotated_logs = 1;
74ca47
             continue;
74ca47
@@ -663,7 +663,7 @@ disk_monitoring_thread(void *nothing)
74ca47
          */
74ca47
         if(disk_space < previous_mark){
74ca47
             slapi_log_err(SLAPI_LOG_ALERT, "disk_monitoring_thread", "Disk space is too low on disk (%s), remaining "
74ca47
-            	"space: %" NSPRIu64 " Kb\n", dirstr, (disk_space / 1024));
74ca47
+            	"space: %" PRIu64 " Kb\n", dirstr, (disk_space / 1024));
74ca47
         }
74ca47
         /*
74ca47
          *
74ca47
@@ -674,7 +674,7 @@ disk_monitoring_thread(void *nothing)
74ca47
          *
74ca47
          */
74ca47
         if(disk_space < halfway){
74ca47
-            slapi_log_err(SLAPI_LOG_ALERT, "disk_monitoring_thread", "Disk space on (%s) is too far below the threshold(%" NSPRIu64 " bytes).  "
74ca47
+            slapi_log_err(SLAPI_LOG_ALERT, "disk_monitoring_thread", "Disk space on (%s) is too far below the threshold(%" PRIu64 " bytes).  "
74ca47
                 "Waiting %d minutes for disk space to be cleaned up before shutting slapd down...\n",
74ca47
                 dirstr, threshold, (grace_period / 60));
74ca47
             time(&start;;
74ca47
@@ -697,7 +697,7 @@ disk_monitoring_thread(void *nothing)
74ca47
                      *  Excellent, we are back to acceptable levels, reset everything...
74ca47
                      */
74ca47
                     slapi_log_err(SLAPI_LOG_INFO, "disk_monitoring_thread", "Available disk space is now "
74ca47
-                    	"acceptable (%" NSPRIu64 " bytes).  Aborting shutdown, and restoring the log settings.\n",
74ca47
+                    	"acceptable (%" PRIu64 " bytes).  Aborting shutdown, and restoring the log settings.\n",
74ca47
                     	disk_space);
74ca47
                     if(logs_disabled && using_accesslog){
74ca47
                         config_set_accesslog_enabled(LOGGING_ON);
74ca47
@@ -721,7 +721,7 @@ disk_monitoring_thread(void *nothing)
74ca47
                      *  Disk space is critical, log an error, and shut it down now!
74ca47
                      */
74ca47
                     slapi_log_err(SLAPI_LOG_ALERT, "disk_monitoring_thread", "Disk space is critically low "
74ca47
-                    	"on disk (%s), remaining space: %" NSPRIu64 " Kb.  Signaling slapd for shutdown...\n", 
74ca47
+                    	"on disk (%s), remaining space: %" PRIu64 " Kb.  Signaling slapd for shutdown...\n", 
74ca47
                     	dirstr, (disk_space / 1024));
74ca47
                     g_set_shutdown( SLAPI_SHUTDOWN_DISKFULL );
74ca47
                     return;
74ca47
@@ -739,7 +739,7 @@ disk_monitoring_thread(void *nothing)
74ca47
              *  If disk space was freed up we would of detected in the above while loop.  So shut it down.
74ca47
              */
74ca47
             slapi_log_err(SLAPI_LOG_ALERT, "disk_monitoring_thread", "Disk space is still too low "
74ca47
-            	"(%" NSPRIu64 " Kb).  Signaling slapd for shutdown...\n", (disk_space / 1024));
74ca47
+            	"(%" PRIu64 " Kb).  Signaling slapd for shutdown...\n", (disk_space / 1024));
74ca47
             g_set_shutdown( SLAPI_SHUTDOWN_DISKFULL );
74ca47
 
74ca47
             return;
74ca47
@@ -1785,7 +1785,7 @@ handle_pr_read_ready(Connection_Table *ct, PRIntn num_poll)
74ca47
 						 * trying to acquire a closing connection
74ca47
 						 */
74ca47
 						slapi_log_err(SLAPI_LOG_ERR,
74ca47
-							"handle_pr_read_ready", "connection_activity: abandoning conn %" NSPRIu64 " as "
74ca47
+							"handle_pr_read_ready", "connection_activity: abandoning conn %" PRIu64 " as "
74ca47
 							"fd=%d is already closing\n", c->c_connid,c->c_sd);
74ca47
 						/* The call disconnect_server should do nothing,
74ca47
 						 * as the connection c should be already set to CLOSING */
74ca47
@@ -1843,7 +1843,7 @@ ns_handle_closure(struct ns_job_t *job)
74ca47
 #else
74ca47
     /* This doesn't actually confirm it's in the event loop thread, but it's a start */
74ca47
 	if (NS_JOB_IS_THREAD(ns_job_get_type(job)) != 0) {
74ca47
-		slapi_log_err(SLAPI_LOG_ERR, "ns_handle_closure", "Attempt to close outside of event loop thread %" NSPRIu64 " for fd=%d\n",
74ca47
+		slapi_log_err(SLAPI_LOG_ERR, "ns_handle_closure", "Attempt to close outside of event loop thread %" PRIu64 " for fd=%d\n",
74ca47
 			c->c_connid, c->c_sd);
74ca47
 		return;
74ca47
 	}
74ca47
@@ -1883,7 +1883,7 @@ ns_connection_post_io_or_closing(Connection *conn)
74ca47
 		PR_ASSERT((conn->c_ns_close_jobs == 0) || (conn->c_ns_close_jobs == 1));
74ca47
 		if (conn->c_ns_close_jobs) {
74ca47
 			slapi_log_err(SLAPI_LOG_CONNS, "ns_connection_post_io_or_closing", "Already a close "
74ca47
-				"job in progress on conn %" NSPRIu64 " for fd=%d\n", conn->c_connid, conn->c_sd);
74ca47
+				"job in progress on conn %" PRIu64 " for fd=%d\n", conn->c_connid, conn->c_sd);
74ca47
 			return;
74ca47
 		} else {
74ca47
 			/* just make sure we schedule the event to be closed in a timely manner */
74ca47
@@ -1898,10 +1898,10 @@ ns_connection_post_io_or_closing(Connection *conn)
74ca47
 #endif
74ca47
 			if (job_result != PR_SUCCESS) {
74ca47
 				slapi_log_err(SLAPI_LOG_WARNING, "ns_connection_post_io_or_closing", "post closure job "
74ca47
-					"for conn %" NSPRIu64 " for fd=%d failed to be added to event queue\n", conn->c_connid, conn->c_sd);
74ca47
+					"for conn %" PRIu64 " for fd=%d failed to be added to event queue\n", conn->c_connid, conn->c_sd);
74ca47
 			} else {
74ca47
 				slapi_log_err(SLAPI_LOG_CONNS, "ns_connection_post_io_or_closing", "post closure job "
74ca47
-					"for conn %" NSPRIu64 " for fd=%d\n", conn->c_connid, conn->c_sd);
74ca47
+					"for conn %" PRIu64 " for fd=%d\n", conn->c_connid, conn->c_sd);
74ca47
 			}
74ca47
 			
74ca47
 		}
74ca47
@@ -1938,10 +1938,10 @@ ns_connection_post_io_or_closing(Connection *conn)
74ca47
 #endif
74ca47
 		if (job_result != PR_SUCCESS) {
74ca47
 			slapi_log_err(SLAPI_LOG_WARNING, "ns_connection_post_io_or_closing", "post I/O job for "
74ca47
-				"conn %" NSPRIu64 " for fd=%d failed to be added to event queue\n", conn->c_connid, conn->c_sd);
74ca47
+				"conn %" PRIu64 " for fd=%d failed to be added to event queue\n", conn->c_connid, conn->c_sd);
74ca47
 		} else {
74ca47
 			slapi_log_err(SLAPI_LOG_CONNS, "ns_connection_post_io_or_closing", "post I/O job for "
74ca47
-				"conn %" NSPRIu64 " for fd=%d\n", conn->c_connid, conn->c_sd);
74ca47
+				"conn %" PRIu64 " for fd=%d\n", conn->c_connid, conn->c_sd);
74ca47
 		}
74ca47
 	}
74ca47
 #endif
74ca47
@@ -1964,14 +1964,14 @@ ns_handle_pr_read_ready(struct ns_job_t *job)
74ca47
 #else
74ca47
     /* This doesn't actually confirm it's in the event loop thread, but it's a start */
74ca47
 	if (NS_JOB_IS_THREAD(ns_job_get_type(job)) != 0) {
74ca47
-		slapi_log_err(SLAPI_LOG_ERR, "ns_handle_pr_read_ready", "Attempt to handle read ready outside of event loop thread %" NSPRIu64 " for fd=%d\n",
74ca47
+		slapi_log_err(SLAPI_LOG_ERR, "ns_handle_pr_read_ready", "Attempt to handle read ready outside of event loop thread %" PRIu64 " for fd=%d\n",
74ca47
 			c->c_connid, c->c_sd);
74ca47
 		return;
74ca47
 	}
74ca47
 #endif
74ca47
 
74ca47
 	PR_EnterMonitor(c->c_mutex);
74ca47
-	slapi_log_err(SLAPI_LOG_CONNS, "ns_handle_pr_read_ready", "activity on conn %" NSPRIu64 " for fd=%d\n",
74ca47
+	slapi_log_err(SLAPI_LOG_CONNS, "ns_handle_pr_read_ready", "activity on conn %" PRIu64 " for fd=%d\n",
74ca47
 		       c->c_connid, c->c_sd);
74ca47
 	/* if we were called due to some i/o event, see what the state of the socket is */
74ca47
 	if (slapi_is_loglevel_set(SLAPI_LOG_CONNS) && !NS_JOB_IS_TIMER(ns_job_get_output_type(job)) && c && c->c_sd) {
74ca47
@@ -1980,16 +1980,16 @@ ns_handle_pr_read_ready(struct ns_job_t *job)
74ca47
 		ssize_t rc = recv(c->c_sd, buf, sizeof(buf), MSG_PEEK);
74ca47
 		if (!rc) {
74ca47
 			slapi_log_err(SLAPI_LOG_CONNS, "ns_handle_pr_read_ready", "socket is closed conn"
74ca47
-				" %" NSPRIu64 " for fd=%d\n", c->c_connid, c->c_sd);
74ca47
+				" %" PRIu64 " for fd=%d\n", c->c_connid, c->c_sd);
74ca47
 		} else if (rc > 0) {
74ca47
 			slapi_log_err(SLAPI_LOG_CONNS, "ns_handle_pr_read_ready", "socket read data available"
74ca47
-				" for conn %" NSPRIu64 " for fd=%d\n", c->c_connid, c->c_sd);
74ca47
+				" for conn %" PRIu64 " for fd=%d\n", c->c_connid, c->c_sd);
74ca47
 		} else if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) {
74ca47
 			slapi_log_err(SLAPI_LOG_CONNS, "ns_handle_pr_read_ready", "socket has no data available"
74ca47
-				" conn %" NSPRIu64 " for fd=%d\n", c->c_connid, c->c_sd);
74ca47
+				" conn %" PRIu64 " for fd=%d\n", c->c_connid, c->c_sd);
74ca47
 		} else {
74ca47
 			slapi_log_err(SLAPI_LOG_CONNS, "ns_handle_pr_read_ready", "socket has error [%d] "
74ca47
-				"conn %" NSPRIu64 " for fd=%d\n", errno, c->c_connid, c->c_sd);
74ca47
+				"conn %" PRIu64 " for fd=%d\n", errno, c->c_connid, c->c_sd);
74ca47
 		}
74ca47
 	}
74ca47
 	connection_release_nolock_ext(c, 1); /* release ref acquired when job was added */
74ca47
@@ -2013,7 +2013,7 @@ ns_handle_pr_read_ready(struct ns_job_t *job)
74ca47
 		 * trying to acquire a closing connection
74ca47
 		 */
74ca47
 		slapi_log_err(SLAPI_LOG_ERR, "ns_handle_pr_read_ready", "connection_activity: abandoning"
74ca47
-			" conn %" NSPRIu64 " as fd=%d is already closing\n", c->c_connid, c->c_sd);
74ca47
+			" conn %" PRIu64 " as fd=%d is already closing\n", c->c_connid, c->c_sd);
74ca47
 		/* The call disconnect_server should do nothing,
74ca47
 		 * as the connection c should be already set to CLOSING */
74ca47
 		disconnect_server_nomutex_ext(c, c->c_connid, -1,
74ca47
@@ -2021,7 +2021,7 @@ ns_handle_pr_read_ready(struct ns_job_t *job)
74ca47
 				              0 /* do not schedule closure, do it next */);
74ca47
 		ns_handle_closure_nomutex(c);
74ca47
 	} else {
74ca47
-		slapi_log_err(SLAPI_LOG_CONNS, "ns_handle_pr_read_ready", "queued conn %" NSPRIu64 " for fd=%d\n",
74ca47
+		slapi_log_err(SLAPI_LOG_CONNS, "ns_handle_pr_read_ready", "queued conn %" PRIu64 " for fd=%d\n",
74ca47
 			       c->c_connid, c->c_sd);
74ca47
 	}
74ca47
 	PR_ExitMonitor(c->c_mutex);
74ca47
diff --git a/ldap/servers/slapd/delete.c b/ldap/servers/slapd/delete.c
74ca47
index a16718a..e4e82a3 100644
74ca47
--- a/ldap/servers/slapd/delete.c
74ca47
+++ b/ldap/servers/slapd/delete.c
74ca47
@@ -260,7 +260,7 @@ static void op_shared_delete (Slapi_PBlock *pb)
74ca47
 
74ca47
 		if (!internal_op )
74ca47
 		{
74ca47
-			slapi_log_access(LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d DEL dn=\"%s\"%s\n",
74ca47
+			slapi_log_access(LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d DEL dn=\"%s\"%s\n",
74ca47
 							pb->pb_conn->c_connid,
74ca47
 							pb->pb_op->o_opid,
74ca47
 							slapi_sdn_get_dn(sdn),
74ca47
diff --git a/ldap/servers/slapd/entry.c b/ldap/servers/slapd/entry.c
74ca47
index abacc57..b56e3da 100644
74ca47
--- a/ldap/servers/slapd/entry.c
74ca47
+++ b/ldap/servers/slapd/entry.c
74ca47
@@ -3095,7 +3095,7 @@ slapi_entry_attr_set_ulong( Slapi_Entry* e, const char *type, uint64_t l)
74ca47
 	struct berval *bvals[2];
74ca47
 	bvals[0] = &bv;
74ca47
 	bvals[1] = NULL;
74ca47
-    sprintf(value,"%" NSPRIu64, l);
74ca47
+    sprintf(value,"%" PRIu64, l);
74ca47
 	bv.bv_val = value;
74ca47
 	bv.bv_len = strlen( value );
74ca47
     slapi_entry_attr_replace( e, type, bvals );
74ca47
diff --git a/ldap/servers/slapd/extendop.c b/ldap/servers/slapd/extendop.c
74ca47
index 7e41b8c..6a5d2e3 100644
74ca47
--- a/ldap/servers/slapd/extendop.c
74ca47
+++ b/ldap/servers/slapd/extendop.c
74ca47
@@ -247,14 +247,14 @@ do_extended( Slapi_PBlock *pb )
74ca47
     if ( NULL == ( name = extended_op_oid2string( extoid ))) {
74ca47
         slapi_log_err(SLAPI_LOG_ARGS, "do_extended", "oid (%s)\n", extoid);
74ca47
 
74ca47
-        slapi_log_access( LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d EXT oid=\"%s\"\n",
74ca47
+        slapi_log_access( LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d EXT oid=\"%s\"\n",
74ca47
                 pb->pb_conn->c_connid, pb->pb_op->o_opid, extoid );
74ca47
     } else {
74ca47
         slapi_log_err(SLAPI_LOG_ARGS, "do_extended", "oid (%s-%s)\n",
74ca47
                 extoid, name);
74ca47
 
74ca47
         slapi_log_access( LDAP_DEBUG_STATS,
74ca47
-            "conn=%" NSPRIu64 " op=%d EXT oid=\"%s\" name=\"%s\"\n",
74ca47
+            "conn=%" PRIu64 " op=%d EXT oid=\"%s\" name=\"%s\"\n",
74ca47
             pb->pb_conn->c_connid, pb->pb_op->o_opid, extoid, name );
74ca47
     }
74ca47
 
74ca47
diff --git a/ldap/servers/slapd/log.c b/ldap/servers/slapd/log.c
74ca47
index afedd5b..a63c6a6 100644
74ca47
--- a/ldap/servers/slapd/log.c
74ca47
+++ b/ldap/servers/slapd/log.c
74ca47
@@ -2769,7 +2769,7 @@ log__open_accesslogfile(int logfile_state, int locked)
74ca47
 	while ( logp) {
74ca47
 		log_convert_time (logp->l_ctime, tbuf, 1 /*short*/);
74ca47
 		PR_snprintf(buffer, sizeof(buffer), "LOGINFO:%s%s.%s (%lu) (%"
74ca47
-			NSPRI64 "d)\n", PREVLOGFILE, loginfo.log_access_file, tbuf, 
74ca47
+			PRId64 "d)\n", PREVLOGFILE, loginfo.log_access_file, tbuf, 
74ca47
 			logp->l_ctime, logp->l_size);
74ca47
 		LOG_WRITE(fpinfo, buffer, strlen(buffer), 0);
74ca47
 		logp = logp->l_next;
74ca47
@@ -2907,7 +2907,7 @@ log_rotate:
74ca47
 		if (type == LOG_SIZE_EXCEEDED) {
74ca47
 			slapi_log_err(SLAPI_LOG_TRACE, "log__needrotation",
74ca47
 				"LOGINFO:End of Log because size exceeded(Max:%" 
74ca47
-				NSPRI64 "d bytes) (Is:%" NSPRI64 "d bytes)\n",
74ca47
+				PRId64 "d bytes) (Is:%" PRId64 "d bytes)\n",
74ca47
 				maxlogsize, f_size);
74ca47
 		} else  if ( type == LOG_EXPIRED) {
74ca47
 			slapi_log_err(SLAPI_LOG_TRACE, "log__needrotation",
74ca47
@@ -4636,7 +4636,7 @@ log__open_errorlogfile(int logfile_state, int locked)
74ca47
 	while (logp) {
74ca47
 		log_convert_time (logp->l_ctime, tbuf, 1 /*short */);
74ca47
 		PR_snprintf(buffer, sizeof(buffer), "LOGINFO:%s%s.%s (%lu) (%" 
74ca47
-			NSPRI64 "d)\n", PREVLOGFILE, loginfo.log_error_file, tbuf,
74ca47
+			PRId64 "d)\n", PREVLOGFILE, loginfo.log_error_file, tbuf,
74ca47
 			logp->l_ctime, logp->l_size);
74ca47
 		LOG_WRITE(fpinfo, buffer, strlen(buffer), 0);
74ca47
 		logp = logp->l_next;
74ca47
@@ -4763,7 +4763,7 @@ log__open_auditlogfile(int logfile_state, int locked)
74ca47
 	while ( logp) {
74ca47
 		log_convert_time (logp->l_ctime, tbuf, 1 /*short */);	
74ca47
 		PR_snprintf(buffer, sizeof(buffer), "LOGINFO:%s%s.%s (%lu) (%"
74ca47
-			NSPRI64 "d)\n", PREVLOGFILE, loginfo.log_audit_file, tbuf, 
74ca47
+			PRId64 "d)\n", PREVLOGFILE, loginfo.log_audit_file, tbuf, 
74ca47
 			logp->l_ctime, logp->l_size);
74ca47
 		LOG_WRITE(fpinfo, buffer, strlen(buffer), 0);
74ca47
 		logp = logp->l_next;
74ca47
@@ -4889,7 +4889,7 @@ log__open_auditfaillogfile(int logfile_state, int locked)
74ca47
     while ( logp) {
74ca47
         log_convert_time (logp->l_ctime, tbuf, 1 /*short */);   
74ca47
         PR_snprintf(buffer, sizeof(buffer), "LOGINFO:%s%s.%s (%lu) (%"
74ca47
-            NSPRI64 "d)\n", PREVLOGFILE, loginfo.log_auditfail_file, tbuf, 
74ca47
+            PRId64 "d)\n", PREVLOGFILE, loginfo.log_auditfail_file, tbuf, 
74ca47
             logp->l_ctime, logp->l_size);
74ca47
         LOG_WRITE(fpinfo, buffer, strlen(buffer), 0);
74ca47
         logp = logp->l_next;
74ca47
diff --git a/ldap/servers/slapd/modify.c b/ldap/servers/slapd/modify.c
74ca47
index e23fe67..da66b44 100644
74ca47
--- a/ldap/servers/slapd/modify.c
74ca47
+++ b/ldap/servers/slapd/modify.c
74ca47
@@ -680,7 +680,7 @@ static void op_shared_modify (Slapi_PBlock *pb, int pw_change, char *old_pw)
74ca47
 
74ca47
 		if ( !internal_op )
74ca47
 		{
74ca47
-			slapi_log_access(LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d MOD dn=\"%s\"%s\n",
74ca47
+			slapi_log_access(LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d MOD dn=\"%s\"%s\n",
74ca47
 							 pb->pb_conn->c_connid,
74ca47
 							 pb->pb_op->o_opid,
74ca47
 							 slapi_sdn_get_dn(sdn),
74ca47
@@ -1227,7 +1227,7 @@ static int op_shared_allow_pw_change (Slapi_PBlock *pb, LDAPMod *mod, char **old
74ca47
 	{
74ca47
 		if (operation_is_flag_set(operation,OP_FLAG_ACTION_LOG_ACCESS))
74ca47
 		{
74ca47
-			slapi_log_access(LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d MOD dn=\"%s\"\n",
74ca47
+			slapi_log_access(LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d MOD dn=\"%s\"\n",
74ca47
 					pb->pb_conn->c_connid, pb->pb_op->o_opid,
74ca47
 					slapi_sdn_get_dn(&sdn));
74ca47
 		}
74ca47
@@ -1267,7 +1267,7 @@ static int op_shared_allow_pw_change (Slapi_PBlock *pb, LDAPMod *mod, char **old
74ca47
 				if (proxydn){
74ca47
 					proxystr = slapi_ch_smprintf(" authzid=\"%s\"", proxydn);
74ca47
 				}
74ca47
-				slapi_log_access(LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d MOD dn=\"%s\"%s\n",
74ca47
+				slapi_log_access(LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d MOD dn=\"%s\"%s\n",
74ca47
 						pb->pb_conn->c_connid, pb->pb_op->o_opid,
74ca47
 						slapi_sdn_get_dn(&sdn), proxystr ? proxystr : "");
74ca47
 			}
74ca47
@@ -1312,7 +1312,7 @@ static int op_shared_allow_pw_change (Slapi_PBlock *pb, LDAPMod *mod, char **old
74ca47
 					proxystr = slapi_ch_smprintf(" authzid=\"%s\"", proxydn);
74ca47
 				}
74ca47
 
74ca47
-				slapi_log_access(LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d MOD dn=\"%s\"%s, %s\n",
74ca47
+				slapi_log_access(LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d MOD dn=\"%s\"%s, %s\n",
74ca47
 						pb->pb_conn->c_connid, pb->pb_op->o_opid,
74ca47
 						slapi_sdn_get_dn(&sdn),
74ca47
 						proxystr ? proxystr : "",
74ca47
@@ -1338,7 +1338,7 @@ static int op_shared_allow_pw_change (Slapi_PBlock *pb, LDAPMod *mod, char **old
74ca47
 
74ca47
 			if ( !internal_op )
74ca47
 			{
74ca47
-				slapi_log_access(LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d MOD dn=\"%s\"%s, %s\n",
74ca47
+				slapi_log_access(LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d MOD dn=\"%s\"%s, %s\n",
74ca47
 								 pb->pb_conn->c_connid,
74ca47
 								 pb->pb_op->o_opid,
74ca47
 								 slapi_sdn_get_dn(&sdn),
74ca47
@@ -1381,7 +1381,7 @@ static int op_shared_allow_pw_change (Slapi_PBlock *pb, LDAPMod *mod, char **old
74ca47
 
74ca47
 					if ( !internal_op )
74ca47
 					{
74ca47
-						slapi_log_access(LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d MOD dn=\"%s\"%s, %s\n",
74ca47
+						slapi_log_access(LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d MOD dn=\"%s\"%s, %s\n",
74ca47
 										 pb->pb_conn->c_connid,
74ca47
 										 pb->pb_op->o_opid,
74ca47
 										 slapi_sdn_get_dn(&sdn),
74ca47
diff --git a/ldap/servers/slapd/modrdn.c b/ldap/servers/slapd/modrdn.c
74ca47
index 15f5210..69cca40 100644
74ca47
--- a/ldap/servers/slapd/modrdn.c
74ca47
+++ b/ldap/servers/slapd/modrdn.c
74ca47
@@ -463,7 +463,7 @@ op_shared_rename(Slapi_PBlock *pb, int passin_args)
74ca47
 		if ( !internal_op )
74ca47
 		{
74ca47
 			slapi_log_access(LDAP_DEBUG_STATS,
74ca47
-					 "conn=%" NSPRIu64 " op=%d MODRDN dn=\"%s\" newrdn=\"%s\" newsuperior=\"%s\"%s\n",
74ca47
+					 "conn=%" PRIu64 " op=%d MODRDN dn=\"%s\" newrdn=\"%s\" newsuperior=\"%s\"%s\n",
74ca47
 					 pb->pb_conn->c_connid,
74ca47
 					 pb->pb_op->o_opid,
74ca47
 					 dn,
74ca47
@@ -497,7 +497,7 @@ op_shared_rename(Slapi_PBlock *pb, int passin_args)
74ca47
 	{
74ca47
 		if ( !internal_op ) {
74ca47
 			slapi_log_err(SLAPI_LOG_ARGS, "op_shared_rename", 
74ca47
-				 "conn=%" NSPRIu64 " op=%d MODRDN invalid new RDN (\"%s\")\n",
74ca47
+				 "conn=%" PRIu64 " op=%d MODRDN invalid new RDN (\"%s\")\n",
74ca47
 				 pb->pb_conn->c_connid,
74ca47
 				 pb->pb_op->o_opid,
74ca47
 				 (NULL == newrdn) ? "(null)" : newrdn);
74ca47
@@ -531,7 +531,7 @@ op_shared_rename(Slapi_PBlock *pb, int passin_args)
74ca47
 			"Syntax check of newSuperior failed\n");
74ca47
 		if (!internal_op) {
74ca47
 			slapi_log_err(SLAPI_LOG_ARGS, "op_shared_rename",
74ca47
-				 "conn=%" NSPRIu64 " op=%d MODRDN invalid new superior (\"%s\")",
74ca47
+				 "conn=%" PRIu64 " op=%d MODRDN invalid new superior (\"%s\")",
74ca47
 				 pb->pb_conn->c_connid,
74ca47
 				 pb->pb_op->o_opid,
74ca47
 				 newsuperior ? newsuperior : "(null)");
74ca47
diff --git a/ldap/servers/slapd/monitor.c b/ldap/servers/slapd/monitor.c
74ca47
index f1fb38f..8d1788f 100644
74ca47
--- a/ldap/servers/slapd/monitor.c
74ca47
+++ b/ldap/servers/slapd/monitor.c
74ca47
@@ -60,19 +60,19 @@ monitor_info(Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entry* entryAfter, int *ret
74ca47
 
74ca47
 	connection_table_as_entry(the_connection_table, e);
74ca47
 
74ca47
-	val.bv_len = snprintf( buf, sizeof(buf), "%" NSPRIu64, slapi_counter_get_value(ops_initiated) );
74ca47
+	val.bv_len = snprintf( buf, sizeof(buf), "%" PRIu64, slapi_counter_get_value(ops_initiated) );
74ca47
 	val.bv_val = buf;
74ca47
 	attrlist_replace( &e->e_attrs, "opsinitiated", vals );
74ca47
 
74ca47
-	val.bv_len = snprintf( buf, sizeof(buf), "%" NSPRIu64, slapi_counter_get_value(ops_completed) );
74ca47
+	val.bv_len = snprintf( buf, sizeof(buf), "%" PRIu64, slapi_counter_get_value(ops_completed) );
74ca47
 	val.bv_val = buf;
74ca47
 	attrlist_replace( &e->e_attrs, "opscompleted", vals );
74ca47
 
74ca47
-	val.bv_len = snprintf ( buf, sizeof(buf), "%" NSPRIu64, g_get_num_entries_sent() );
74ca47
+	val.bv_len = snprintf ( buf, sizeof(buf), "%" PRIu64, g_get_num_entries_sent() );
74ca47
 	val.bv_val = buf;
74ca47
 	attrlist_replace( &e->e_attrs, "entriessent", vals );
74ca47
 
74ca47
-	val.bv_len = snprintf ( buf, sizeof(buf), "%" NSPRIu64, g_get_num_bytes_sent() );
74ca47
+	val.bv_len = snprintf ( buf, sizeof(buf), "%" PRIu64, g_get_num_bytes_sent() );
74ca47
 	val.bv_val = buf;
74ca47
 	attrlist_replace( &e->e_attrs, "bytessent", vals );
74ca47
 
74ca47
diff --git a/ldap/servers/slapd/operation.c b/ldap/servers/slapd/operation.c
74ca47
index ccbc549..00fb9b8 100644
74ca47
--- a/ldap/servers/slapd/operation.c
74ca47
+++ b/ldap/servers/slapd/operation.c
74ca47
@@ -580,7 +580,7 @@ int slapi_connection_acquire(Slapi_Connection *conn)
74ca47
     {
74ca47
 	/* This may happen while other threads are still working on this connection */
74ca47
         slapi_log_err(SLAPI_LOG_ERR, "slapi_connection_acquire",
74ca47
-		                "conn=%" NSPRIu64 " fd=%d Attempt to acquire connection in the closing state\n",
74ca47
+		                "conn=%" PRIu64 " fd=%d Attempt to acquire connection in the closing state\n",
74ca47
 		                conn->c_connid, conn->c_sd);
74ca47
         rc = -1;
74ca47
     }
74ca47
@@ -606,7 +606,7 @@ slapi_connection_remove_operation( Slapi_PBlock *pb, Slapi_Connection *conn, Sla
74ca47
 	if ( *tmp == NULL ) {
74ca47
 		if (op) {
74ca47
 			slapi_log_err(SLAPI_LOG_ERR, "slapi_connection_remove_operation",
74ca47
-				"Can't find op %d for conn %" NSPRIu64 "\n",
74ca47
+				"Can't find op %d for conn %" PRIu64 "\n",
74ca47
 			    (int)op->o_msgid, conn->c_connid);
74ca47
 		} else {
74ca47
 			slapi_log_err(SLAPI_LOG_ERR, "slapi_connection_remove_operation",
74ca47
@@ -620,7 +620,7 @@ slapi_connection_remove_operation( Slapi_PBlock *pb, Slapi_Connection *conn, Sla
74ca47
 		/* connection_release_nolock(conn); */
74ca47
 		if (conn->c_refcnt <= 0) {
74ca47
 			slapi_log_err(SLAPI_LOG_ERR, "slapi_connection_remove_operation",
74ca47
-			                "conn=%" NSPRIu64 " fd=%d Attempt to release connection that is not acquired\n",
74ca47
+			                "conn=%" PRIu64 " fd=%d Attempt to release connection that is not acquired\n",
74ca47
 			                conn->c_connid, conn->c_sd);
74ca47
 			rc = -1;
74ca47
 		} else {
74ca47
diff --git a/ldap/servers/slapd/opshared.c b/ldap/servers/slapd/opshared.c
74ca47
index 3ce7970..4682a73 100644
74ca47
--- a/ldap/servers/slapd/opshared.c
74ca47
+++ b/ldap/servers/slapd/opshared.c
74ca47
@@ -289,7 +289,7 @@ op_shared_search (Slapi_PBlock *pb, int send_result)
74ca47
   {
74ca47
       char *fmtstr;
74ca47
         
74ca47
-#define SLAPD_SEARCH_FMTSTR_BASE "conn=%" NSPRIu64 " op=%d SRCH base=\"%s\" scope=%d "
74ca47
+#define SLAPD_SEARCH_FMTSTR_BASE "conn=%" PRIu64 " op=%d SRCH base=\"%s\" scope=%d "
74ca47
 #define SLAPD_SEARCH_FMTSTR_BASE_INT "conn=%s op=%d SRCH base=\"%s\" scope=%d "
74ca47
 #define SLAPD_SEARCH_FMTSTR_REMAINDER " attrs=%s%s%s\n"
74ca47
 
74ca47
@@ -1744,7 +1744,7 @@ void op_shared_log_error_access (Slapi_PBlock *pb, const char *type, const char
74ca47
         proxystr = slapi_ch_smprintf(" authzid=\"%s\"", proxydn);
74ca47
     }
74ca47
 
74ca47
-    slapi_log_access( LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d %s dn=\"%s\"%s, %s\n",
74ca47
+    slapi_log_access( LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d %s dn=\"%s\"%s, %s\n",
74ca47
                       ( pb->pb_conn ? pb->pb_conn->c_connid : 0),
74ca47
                       ( pb->pb_op ? pb->pb_op->o_opid : 0), 
74ca47
                       type, 
74ca47
diff --git a/ldap/servers/slapd/pagedresults.c b/ldap/servers/slapd/pagedresults.c
74ca47
index a30e2fa..e8c80e7 100644
74ca47
--- a/ldap/servers/slapd/pagedresults.c
74ca47
+++ b/ldap/servers/slapd/pagedresults.c
74ca47
@@ -310,7 +310,7 @@ pagedresults_free_one( Connection *conn, Operation *op, int index )
74ca47
         PR_EnterMonitor(conn->c_mutex);
74ca47
         if (conn->c_pagedresults.prl_count <= 0) {
74ca47
             slapi_log_err(SLAPI_LOG_TRACE, "pagedresults_free_one",
74ca47
-                           "conn=%" NSPRIu64 " paged requests list count is %d\n",
74ca47
+                           "conn=%" PRIu64 " paged requests list count is %d\n",
74ca47
                            conn->c_connid, conn->c_pagedresults.prl_count);
74ca47
         } else if (index < conn->c_pagedresults.prl_maxlen) {
74ca47
             PagedResults *prp = conn->c_pagedresults.prl_list + index;
74ca47
diff --git a/ldap/servers/slapd/psearch.c b/ldap/servers/slapd/psearch.c
74ca47
index 793bea3..2d0badc 100644
74ca47
--- a/ldap/servers/slapd/psearch.c
74ca47
+++ b/ldap/servers/slapd/psearch.c
74ca47
@@ -283,7 +283,7 @@ ps_send_results( void *arg )
74ca47
 
74ca47
 	if (conn_acq_flag) {
74ca47
 		slapi_log_err(SLAPI_LOG_CONNS, "ps_send_results",
74ca47
-				"conn=%" NSPRIu64 " op=%d Could not acquire the connection - psearch aborted\n",
74ca47
+				"conn=%" PRIu64 " op=%d Could not acquire the connection - psearch aborted\n",
74ca47
 				ps->ps_pblock->pb_conn->c_connid, ps->ps_pblock->pb_op->o_opid);
74ca47
 	}
74ca47
 
74ca47
@@ -293,7 +293,7 @@ ps_send_results( void *arg )
74ca47
 	/* Check for an abandoned operation */
74ca47
 	if ( ps->ps_pblock->pb_op == NULL || slapi_op_abandoned( ps->ps_pblock ) ) {
74ca47
 		slapi_log_err(SLAPI_LOG_CONNS, "ps_send_results",
74ca47
-				"conn=%" NSPRIu64 " op=%d The operation has been abandoned\n",
74ca47
+				"conn=%" PRIu64 " op=%d The operation has been abandoned\n",
74ca47
 				ps->ps_pblock->pb_conn->c_connid, ps->ps_pblock->pb_op->o_opid);
74ca47
 	    break;
74ca47
 	}
74ca47
@@ -351,7 +351,7 @@ ps_send_results( void *arg )
74ca47
 										 ectrls, attrs, attrsonly );
74ca47
 			if (rc) {
74ca47
 				slapi_log_err(SLAPI_LOG_CONNS, "ps_send_results",
74ca47
-								"conn=%" NSPRIu64 " op=%d Error %d sending entry %s with op status %d\n",
74ca47
+								"conn=%" PRIu64 " op=%d Error %d sending entry %s with op status %d\n",
74ca47
 								ps->ps_pblock->pb_conn->c_connid, ps->ps_pblock->pb_op->o_opid,
74ca47
 								rc, slapi_entry_get_dn_const(ec), ps->ps_pblock->pb_op->o_status);
74ca47
 			}
74ca47
@@ -400,7 +400,7 @@ ps_send_results( void *arg )
74ca47
     PR_EnterMonitor(conn->c_mutex);
74ca47
 
74ca47
 	slapi_log_err(SLAPI_LOG_CONNS, "ps_send_results",
74ca47
-					"conn=%" NSPRIu64 " op=%d Releasing the connection and operation\n",
74ca47
+					"conn=%" PRIu64 " op=%d Releasing the connection and operation\n",
74ca47
 					conn->c_connid, ps->ps_pblock->pb_op->o_opid);
74ca47
     /* Delete this op from the connection's list */
74ca47
     connection_remove_operation_ext( ps->ps_pblock, conn, ps->ps_pblock->pb_op );
74ca47
@@ -535,7 +535,7 @@ ps_service_persistent_searches( Slapi_Entry *e, Slapi_Entry *eprev, ber_int_t ch
74ca47
 		}
74ca47
 
74ca47
 		slapi_log_err(SLAPI_LOG_CONNS, "ps_service_persistent_searches",
74ca47
-						"conn=%" NSPRIu64 " op=%d entry %s with chgtype %d "
74ca47
+						"conn=%" PRIu64 " op=%d entry %s with chgtype %d "
74ca47
 						"matches the ps changetype %d\n",
74ca47
 						ps->ps_pblock->pb_conn->c_connid,
74ca47
 						ps->ps_pblock->pb_op->o_opid,
74ca47
diff --git a/ldap/servers/slapd/result.c b/ldap/servers/slapd/result.c
74ca47
index 5c38bae..56257c3 100644
74ca47
--- a/ldap/servers/slapd/result.c
74ca47
+++ b/ldap/servers/slapd/result.c
74ca47
@@ -1980,7 +1980,7 @@ log_result( Slapi_PBlock *pb, Operation *op, int err, ber_tag_t tag, int nentrie
74ca47
 		if ( !internal_op )
74ca47
 		{
74ca47
 			slapi_log_access( LDAP_DEBUG_STATS,
74ca47
-							  "conn=%" NSPRIu64 " op=%d RESULT err=%d"
74ca47
+							  "conn=%" PRIu64 " op=%d RESULT err=%d"
74ca47
 							  " tag=%" BERTAG_T " nentries=%d etime=%s%s%s"
74ca47
 							  ", SASL bind in progress\n",
74ca47
 							  op->o_connid,
74ca47
@@ -2012,7 +2012,7 @@ log_result( Slapi_PBlock *pb, Operation *op, int err, ber_tag_t tag, int nentrie
74ca47
 		if ( !internal_op )
74ca47
 		{
74ca47
 			slapi_log_access( LDAP_DEBUG_STATS,
74ca47
-							  "conn=%" NSPRIu64 " op=%d RESULT err=%d"
74ca47
+							  "conn=%" PRIu64 " op=%d RESULT err=%d"
74ca47
 							  " tag=%" BERTAG_T " nentries=%d etime=%s%s%s"
74ca47
 							  " dn=\"%s\"\n",
74ca47
 							  op->o_connid,
74ca47
@@ -2040,7 +2040,7 @@ log_result( Slapi_PBlock *pb, Operation *op, int err, ber_tag_t tag, int nentrie
74ca47
 			if ( !internal_op )
74ca47
 			{
74ca47
 				slapi_log_access( LDAP_DEBUG_STATS,
74ca47
-								  "conn=%" NSPRIu64 " op=%d RESULT err=%d"
74ca47
+								  "conn=%" PRIu64 " op=%d RESULT err=%d"
74ca47
 								  " tag=%" BERTAG_T " nentries=%d etime=%s%s%s"
74ca47
 								  " pr_idx=%d pr_cookie=%d\n",
74ca47
 								  op->o_connid, 
74ca47
@@ -2073,7 +2073,7 @@ log_result( Slapi_PBlock *pb, Operation *op, int err, ber_tag_t tag, int nentrie
74ca47
 				ext_str = "";
74ca47
 			}
74ca47
 			slapi_log_access( LDAP_DEBUG_STATS,
74ca47
-							  "conn=%" NSPRIu64 " op=%d RESULT err=%d"
74ca47
+							  "conn=%" PRIu64 " op=%d RESULT err=%d"
74ca47
 							  " tag=%" BERTAG_T " nentries=%d etime=%s%s%s%s\n",
74ca47
 							  op->o_connid,
74ca47
 							  op->o_opid,
74ca47
@@ -2142,7 +2142,7 @@ log_entry( Operation *op, Slapi_Entry *e )
74ca47
 
74ca47
 	if ( !internal_op )
74ca47
 	{
74ca47
-		slapi_log_access( LDAP_DEBUG_STATS2, "conn=%" NSPRIu64 " op=%d ENTRY dn=\"%s\"\n",
74ca47
+		slapi_log_access( LDAP_DEBUG_STATS2, "conn=%" PRIu64 " op=%d ENTRY dn=\"%s\"\n",
74ca47
 			op->o_connid, op->o_opid,
74ca47
 			slapi_entry_get_dn_const(e));
74ca47
 	}
74ca47
@@ -2167,7 +2167,7 @@ log_referral( Operation *op )
74ca47
 
74ca47
 	if ( !internal_op )
74ca47
 	{
74ca47
-		slapi_log_access( LDAP_DEBUG_STATS2, "conn=%" NSPRIu64 " op=%d REFERRAL\n",
74ca47
+		slapi_log_access( LDAP_DEBUG_STATS2, "conn=%" PRIu64 " op=%d REFERRAL\n",
74ca47
 			op->o_connid, op->o_opid );
74ca47
 	}
74ca47
 	else
74ca47
diff --git a/ldap/servers/slapd/sasl_io.c b/ldap/servers/slapd/sasl_io.c
74ca47
index 1337e1c..9458083 100644
74ca47
--- a/ldap/servers/slapd/sasl_io.c
74ca47
+++ b/ldap/servers/slapd/sasl_io.c
74ca47
@@ -198,17 +198,17 @@ sasl_io_start_packet(PRFileDesc *fd, PRIntn flags, PRIntervalTime timeout, PRInt
74ca47
     /* first we need the length bytes */
74ca47
     ret = PR_Recv(fd->lower, buffer, amount, flags, timeout);
74ca47
     slapi_log_err(SLAPI_LOG_CONNS, "sasl_io_start_packet",
74ca47
-            "Read sasl packet length returned %d on connection %" NSPRIu64 "\n",
74ca47
+            "Read sasl packet length returned %d on connection %" PRIu64 "\n",
74ca47
             ret, c->c_connid);
74ca47
     if (ret <= 0) {
74ca47
         *err = PR_GetError();
74ca47
         if (ret == 0) {
74ca47
             slapi_log_err(SLAPI_LOG_CONNS, "sasl_io_start_packet",
74ca47
-                    "Connection closed while reading sasl packet length on connection %" NSPRIu64 "\n",
74ca47
+                    "Connection closed while reading sasl packet length on connection %" PRIu64 "\n",
74ca47
                     c->c_connid );
74ca47
         } else {
74ca47
             slapi_log_err(SLAPI_LOG_CONNS, "sasl_io_start_packet",
74ca47
-                    "Error reading sasl packet length on connection %" NSPRIu64 " %d:%s\n",
74ca47
+                    "Error reading sasl packet length on connection %" PRIu64 " %d:%s\n",
74ca47
                     c->c_connid, *err, slapd_pr_strerror(*err) );
74ca47
         }
74ca47
         return ret;
74ca47
@@ -226,7 +226,7 @@ sasl_io_start_packet(PRFileDesc *fd, PRIntn flags, PRIntervalTime timeout, PRInt
74ca47
     if (sp->encrypted_buffer_offset < sizeof(buffer)) {
74ca47
         slapi_log_err(SLAPI_LOG_CONNS,
74ca47
                "sasl_io_start_packet", "Read only %d bytes of sasl packet "
74ca47
-               "length on connection %" NSPRIu64 "\n", ret, c->c_connid );
74ca47
+               "length on connection %" PRIu64 "\n", ret, c->c_connid );
74ca47
 #if defined(EWOULDBLOCK)
74ca47
         errno = EWOULDBLOCK;
74ca47
 #elif defined(EAGAIN)
74ca47
@@ -251,7 +251,7 @@ sasl_io_start_packet(PRFileDesc *fd, PRIntn flags, PRIntervalTime timeout, PRInt
74ca47
         ber_len_t ber_len = 0;
74ca47
         ber_tag_t tag = 0;
74ca47
 
74ca47
-        slapi_log_err(SLAPI_LOG_CONNS, "sasl_io_start_packet", "conn=%" NSPRIu64 " fd=%d "
74ca47
+        slapi_log_err(SLAPI_LOG_CONNS, "sasl_io_start_packet", "conn=%" PRIu64 " fd=%d "
74ca47
                 "Sent an LDAP message that was not encrypted.\n", c->c_connid,
74ca47
                 c->c_sd);
74ca47
 
74ca47
@@ -265,7 +265,7 @@ sasl_io_start_packet(PRFileDesc *fd, PRIntn flags, PRIntervalTime timeout, PRInt
74ca47
         /* Is the ldap operation too large? */
74ca47
         if(ber_len > maxbersize){
74ca47
             slapi_log_err(SLAPI_LOG_ERR, "sasl_io_start_packet",
74ca47
-                    "conn=%" NSPRIu64 " fd=%d Incoming BER Element was too long, max allowable "
74ca47
+                    "conn=%" PRIu64 " fd=%d Incoming BER Element was too long, max allowable "
74ca47
                     "is %" BERLEN_T " bytes. Change the nsslapd-maxbersize attribute in "
74ca47
                     "cn=config to increase.\n",
74ca47
                     c->c_connid, c->c_sd, maxbersize );
74ca47
@@ -305,7 +305,7 @@ sasl_io_start_packet(PRFileDesc *fd, PRIntn flags, PRIntervalTime timeout, PRInt
74ca47
             } else if (ret > 0) {
74ca47
                 slapi_log_err(SLAPI_LOG_CONNS,
74ca47
                         "sasl_io_start_packet",
74ca47
-                        "Continued: read sasl packet length returned %d on connection %" NSPRIu64 "\n",
74ca47
+                        "Continued: read sasl packet length returned %d on connection %" PRIu64 "\n",
74ca47
                         ret, c->c_connid);
74ca47
                 if((ret + sp->encrypted_buffer_offset) > sp->encrypted_buffer_size){
74ca47
                 	sasl_io_resize_encrypted_buffer(sp, ret + sp->encrypted_buffer_offset);
74ca47
@@ -316,7 +316,7 @@ sasl_io_start_packet(PRFileDesc *fd, PRIntn flags, PRIntervalTime timeout, PRInt
74ca47
                 *err = PR_GetError();
74ca47
                 slapi_log_err(SLAPI_LOG_CONNS, "sasl_io_start_packet",
74ca47
                 		"Error reading sasl packet length on connection "
74ca47
-                        "%" NSPRIu64 " %d:%s\n", c->c_connid, *err, slapd_pr_strerror(*err) );
74ca47
+                        "%" PRIu64 " %d:%s\n", c->c_connid, *err, slapd_pr_strerror(*err) );
74ca47
                 return ret;
74ca47
             }
74ca47
         }
74ca47
@@ -360,7 +360,7 @@ sasl_io_start_packet(PRFileDesc *fd, PRIntn flags, PRIntervalTime timeout, PRInt
74ca47
                 tag = *ber->ber_ptr++;
74ca47
                 if (*ber->ber_ptr == LDAP_REQ_UNBIND){
74ca47
 #endif
74ca47
-                    slapi_log_err(SLAPI_LOG_CONNS, "sasl_io_start_packet", "conn=%" NSPRIu64 " fd=%d "
74ca47
+                    slapi_log_err(SLAPI_LOG_CONNS, "sasl_io_start_packet", "conn=%" PRIu64 " fd=%d "
74ca47
                             "Received unencrypted UNBIND operation.\n", c->c_connid,
74ca47
                             c->c_sd);
74ca47
                     sp->encrypted_buffer_count = sp->encrypted_buffer_offset;
74ca47
@@ -368,7 +368,7 @@ sasl_io_start_packet(PRFileDesc *fd, PRIntn flags, PRIntervalTime timeout, PRInt
74ca47
                     ber_free(ber, 1);
74ca47
                     return SASL_IO_BUFFER_NOT_ENCRYPTED;
74ca47
                 }
74ca47
-                slapi_log_err(SLAPI_LOG_CONNS, "sasl_io_start_packet", "conn=%" NSPRIu64 " fd=%d "
74ca47
+                slapi_log_err(SLAPI_LOG_CONNS, "sasl_io_start_packet", "conn=%" PRIu64 " fd=%d "
74ca47
                         "Error: received an LDAP message (tag 0x%lx) that was not encrypted.\n",
74ca47
 #ifdef USE_OPENLDAP
74ca47
                         c->c_connid, c->c_sd, (long unsigned int)tag);
74ca47
@@ -380,7 +380,7 @@ sasl_io_start_packet(PRFileDesc *fd, PRIntn flags, PRIntervalTime timeout, PRInt
74ca47
 
74ca47
 done:
74ca47
         /* If we got here we have garbage, or a denied LDAP operation */
74ca47
-        slapi_log_err(SLAPI_LOG_CONNS, "sasl_io_start_packet", "conn=%" NSPRIu64 " fd=%d "
74ca47
+        slapi_log_err(SLAPI_LOG_CONNS, "sasl_io_start_packet", "conn=%" PRIu64 " fd=%d "
74ca47
                 "Error: received an invalid message that was not encrypted.\n",
74ca47
                 c->c_connid, c->c_sd);
74ca47
 
74ca47
@@ -399,7 +399,7 @@ done:
74ca47
     packet_length += sizeof(uint32_t);
74ca47
 
74ca47
     slapi_log_err(SLAPI_LOG_CONNS, "sasl_io_start_packet",
74ca47
-                    "read sasl packet length %ld on connection %" NSPRIu64 "\n", 
74ca47
+                    "read sasl packet length %ld on connection %" PRIu64 "\n", 
74ca47
                     packet_length, c->c_connid );
74ca47
 
74ca47
     /* Check if the packet length is larger than our max allowed.  A
74ca47
@@ -432,17 +432,17 @@ sasl_io_read_packet(PRFileDesc *fd, PRIntn flags, PRIntervalTime timeout, PRInt3
74ca47
     size_t bytes_remaining_to_read = sp->encrypted_buffer_count - sp->encrypted_buffer_offset;
74ca47
 
74ca47
     slapi_log_err(SLAPI_LOG_CONNS,
74ca47
-               "sasl_io_read_packet", "Reading %lu bytes for connection %" NSPRIu64 "\n",
74ca47
+               "sasl_io_read_packet", "Reading %lu bytes for connection %" PRIu64 "\n",
74ca47
                bytes_remaining_to_read, c->c_connid );
74ca47
     ret = PR_Recv(fd->lower, sp->encrypted_buffer + sp->encrypted_buffer_offset, bytes_remaining_to_read, flags, timeout);
74ca47
     if (ret <= 0) {
74ca47
         *err = PR_GetError();
74ca47
         if (ret == 0) {
74ca47
             slapi_log_err(SLAPI_LOG_CONNS, "sasl_io_read_packet",
74ca47
-                    "Connection closed while reading sasl packet on connection %" NSPRIu64 "\n", c->c_connid );
74ca47
+                    "Connection closed while reading sasl packet on connection %" PRIu64 "\n", c->c_connid );
74ca47
         } else {
74ca47
             slapi_log_err(SLAPI_LOG_CONNS, "sasl_io_read_packet",
74ca47
-                    "Error reading sasl packet on connection %" NSPRIu64 " %d:%s\n",
74ca47
+                    "Error reading sasl packet on connection %" PRIu64 " %d:%s\n",
74ca47
                     c->c_connid, *err, slapd_pr_strerror(*err) );
74ca47
         }
74ca47
         return ret;
74ca47
@@ -464,10 +464,10 @@ sasl_io_recv(PRFileDesc *fd, void *buf, PRInt32 len, PRIntn flags,
74ca47
     /* Do we have decrypted data buffered from 'before' ? */
74ca47
     bytes_in_buffer = sp->decrypted_buffer_count - sp->decrypted_buffer_offset;
74ca47
     slapi_log_err(SLAPI_LOG_CONNS, "sasl_io_recv",
74ca47
-            "Connection %" NSPRIu64 " len %d bytes_in_buffer %lu\n",
74ca47
+            "Connection %" PRIu64 " len %d bytes_in_buffer %lu\n",
74ca47
             c->c_connid, len, bytes_in_buffer );
74ca47
     slapi_log_err(SLAPI_LOG_CONNS, "sasl_io_recv",
74ca47
-            "Connection %" NSPRIu64 " len %d encrypted buffer count %lu\n",
74ca47
+            "Connection %" PRIu64 " len %d encrypted buffer count %lu\n",
74ca47
             c->c_connid, len, sp->encrypted_buffer_count );
74ca47
     if (0 == bytes_in_buffer) {
74ca47
         /* If there wasn't buffered decrypted data, we need to get some... */
74ca47
@@ -502,7 +502,7 @@ sasl_io_recv(PRFileDesc *fd, void *buf, PRInt32 len, PRIntn flags,
74ca47
          */
74ca47
         if (!sasl_io_finished_packet(sp)) {
74ca47
             slapi_log_err(SLAPI_LOG_CONNS, "sasl_io_recv",
74ca47
-                    "Connection %" NSPRIu64 " - not finished reading packet yet\n", c->c_connid);
74ca47
+                    "Connection %" PRIu64 " - not finished reading packet yet\n", c->c_connid);
74ca47
 #if defined(EWOULDBLOCK)
74ca47
             errno = EWOULDBLOCK;
74ca47
 #elif defined(EAGAIN)
74ca47
@@ -516,7 +516,7 @@ sasl_io_recv(PRFileDesc *fd, void *buf, PRInt32 len, PRIntn flags,
74ca47
             const char *output_buffer = NULL;
74ca47
             unsigned int output_length = 0;
74ca47
             slapi_log_err(SLAPI_LOG_CONNS, "sasl_io_recv",
74ca47
-                    "Finished reading packet for connection %" NSPRIu64 "\n", c->c_connid );
74ca47
+                    "Finished reading packet for connection %" PRIu64 "\n", c->c_connid );
74ca47
             /* Now decode it */
74ca47
             ret = sasl_decode(c->c_sasl_conn,sp->encrypted_buffer,sp->encrypted_buffer_count,&output_buffer,&output_length);
74ca47
             /* even if decode fails, need re-initialize the encrypted_buffer */
74ca47
@@ -524,7 +524,7 @@ sasl_io_recv(PRFileDesc *fd, void *buf, PRInt32 len, PRIntn flags,
74ca47
             sp->encrypted_buffer_count = 0;
74ca47
             if (SASL_OK == ret) {
74ca47
                 slapi_log_err(SLAPI_LOG_CONNS, "sasl_io_recv",
74ca47
-                        "Decoded packet length %u for connection %" NSPRIu64 "\n", output_length, c->c_connid );
74ca47
+                        "Decoded packet length %u for connection %" PRIu64 "\n", output_length, c->c_connid );
74ca47
                 if (output_length) {
74ca47
                     sasl_io_resize_decrypted_buffer(sp,output_length);
74ca47
                     memcpy(sp->decrypted_buffer,output_buffer,output_length);
74ca47
@@ -534,7 +534,7 @@ sasl_io_recv(PRFileDesc *fd, void *buf, PRInt32 len, PRIntn flags,
74ca47
                 }
74ca47
             } else {
74ca47
                 slapi_log_err(SLAPI_LOG_ERR, "sasl_io_recv",
74ca47
-                        "Failed to decode packet for connection %" NSPRIu64 "\n", c->c_connid );
74ca47
+                        "Failed to decode packet for connection %" PRIu64 "\n", c->c_connid );
74ca47
                 PR_SetError(PR_IO_ERROR, 0);
74ca47
                 return PR_FAILURE;
74ca47
             }
74ca47
@@ -552,11 +552,11 @@ sasl_io_recv(PRFileDesc *fd, void *buf, PRInt32 len, PRIntn flags,
74ca47
             sp->decrypted_buffer_offset = 0;
74ca47
             sp->decrypted_buffer_count = 0;
74ca47
             slapi_log_err(SLAPI_LOG_CONNS, "sasl_io_recv",
74ca47
-                    "All decrypted data returned for connection %" NSPRIu64 "\n", c->c_connid );
74ca47
+                    "All decrypted data returned for connection %" PRIu64 "\n", c->c_connid );
74ca47
         } else {
74ca47
             sp->decrypted_buffer_offset += bytes_to_return;
74ca47
             slapi_log_err(SLAPI_LOG_CONNS, "sasl_io_recv",
74ca47
-                    "Returning %lu bytes to caller %lu bytes left to return for connection %" NSPRIu64 "\n",
74ca47
+                    "Returning %lu bytes to caller %lu bytes left to return for connection %" PRIu64 "\n",
74ca47
                     bytes_to_return, sp->decrypted_buffer_count - sp->decrypted_buffer_offset, c->c_connid );
74ca47
         }
74ca47
         ret = bytes_to_return;
74ca47
@@ -772,11 +772,11 @@ sasl_io_enable(Connection *c, void *data /* UNUSED */)
74ca47
         rv = PR_PushIOLayer(c->c_prfd, PR_TOP_IO_LAYER, layer);
74ca47
         if (rv) {
74ca47
             slapi_log_err(SLAPI_LOG_ERR, "sasl_io_enable",
74ca47
-                    "Error enabling sasl io on connection %" NSPRIu64 " %d:%s\n",
74ca47
+                    "Error enabling sasl io on connection %" PRIu64 " %d:%s\n",
74ca47
                     c->c_connid, rv, slapd_pr_strerror(rv) );
74ca47
         } else {
74ca47
             slapi_log_err(SLAPI_LOG_CONNS, "sasl_io_enable",
74ca47
-                    "Enabled sasl io on connection %" NSPRIu64 " \n", c->c_connid);
74ca47
+                    "Enabled sasl io on connection %" PRIu64 " \n", c->c_connid);
74ca47
             debug_print_layers(c->c_prfd);
74ca47
         }
74ca47
     }
74ca47
@@ -794,7 +794,7 @@ sasl_io_cleanup(Connection *c, void *data /* UNUSED */)
74ca47
     int ret = 0;
74ca47
 
74ca47
     slapi_log_err(SLAPI_LOG_CONNS, "sasl_io_cleanup",
74ca47
-            "Connection %" NSPRIu64 "\n", c->c_connid);
74ca47
+            "Connection %" PRIu64 "\n", c->c_connid);
74ca47
 
74ca47
     ret = sasl_pop_IO_layer(c->c_prfd, 0 /* do not close */);
74ca47
 
74ca47
diff --git a/ldap/servers/slapd/saslbind.c b/ldap/servers/slapd/saslbind.c
74ca47
index 9e5d1f0..2d6fb64 100644
74ca47
--- a/ldap/servers/slapd/saslbind.c
74ca47
+++ b/ldap/servers/slapd/saslbind.c
74ca47
@@ -929,7 +929,7 @@ void ids_sasl_check_bind(Slapi_PBlock *pb)
74ca47
         Slapi_Operation *operation;
74ca47
         slapi_pblock_get( pb, SLAPI_OPERATION, &operation);
74ca47
         slapi_log_err(SLAPI_LOG_CONNS, "ids_sasl_check_bind",
74ca47
-                        "cleaning up sasl IO conn=%" NSPRIu64 " op=%d complete=%d continuing=%d\n",
74ca47
+                        "cleaning up sasl IO conn=%" PRIu64 " op=%d complete=%d continuing=%d\n",
74ca47
                         pb->pb_conn->c_connid, operation->o_opid,
74ca47
                         (pb->pb_conn->c_flags & CONN_FLAG_SASL_COMPLETE), continuing);
74ca47
         /* reset flag */
74ca47
diff --git a/ldap/servers/slapd/search.c b/ldap/servers/slapd/search.c
74ca47
index 670347e..ea8b479 100644
74ca47
--- a/ldap/servers/slapd/search.c
74ca47
+++ b/ldap/servers/slapd/search.c
74ca47
@@ -380,7 +380,7 @@ free_and_return:;
74ca47
 static void log_search_access (Slapi_PBlock *pb, const char *base, int scope, const char *fstr, const char *msg)
74ca47
 {
74ca47
 	slapi_log_access(LDAP_DEBUG_STATS,
74ca47
-					 "conn=%" NSPRIu64 " op=%d SRCH base=\"%s\" scope=%d filter=\"%s\", %s\n",
74ca47
+					 "conn=%" PRIu64 " op=%d SRCH base=\"%s\" scope=%d filter=\"%s\", %s\n",
74ca47
 					 pb->pb_conn->c_connid, pb->pb_op->o_opid,
74ca47
 					 base, scope, fstr, msg ? msg : "");
74ca47
 
74ca47
diff --git a/ldap/servers/slapd/slap.h b/ldap/servers/slapd/slap.h
74ca47
index 5871bf0..abfad20 100644
74ca47
--- a/ldap/servers/slapd/slap.h
74ca47
+++ b/ldap/servers/slapd/slap.h
74ca47
@@ -72,13 +72,8 @@ static char ptokPBE[34] = "Internal (Software) Token        ";
74ca47
 #include <sys/socket.h>
74ca47
 #include <netinet/in.h>
74ca47
 
74ca47
-/* Required to get portable printf/scanf format macros */
74ca47
-#ifdef HAVE_INTTYPES_H
74ca47
-#include <inttypes.h>
74ca47
-
74ca47
-#else
74ca47
-#error Need to define portable format macros such as PRIu64
74ca47
-#endif /* HAVE_INTTYPES_H */
74ca47
+/* Provides our int types and platform specific requirements. */
74ca47
+#include <slapi_pal.h>
74ca47
 
74ca47
 #define LOG_INTERNAL_OP_CON_ID      "Internal"
74ca47
 #define LOG_INTERNAL_OP_OP_ID       -1
74ca47
diff --git a/ldap/servers/slapd/slapi-plugin.h b/ldap/servers/slapd/slapi-plugin.h
74ca47
index 725fa1c..ec8917d 100644
74ca47
--- a/ldap/servers/slapd/slapi-plugin.h
74ca47
+++ b/ldap/servers/slapd/slapi-plugin.h
74ca47
@@ -27,6 +27,9 @@
74ca47
 extern "C" {
74ca47
 #endif
74ca47
 
74ca47
+/* Provides our int types and platform specific requirements. */
74ca47
+#include <slapi_pal.h>
74ca47
+
74ca47
 #include "prtypes.h"
74ca47
 #include "ldap.h"
74ca47
 #include "prprf.h"
74ca47
@@ -57,17 +60,6 @@ NSPR_API(PRUint32) PR_fprintf(struct PRFileDesc* fd, const char *fmt, ...)
74ca47
         ;
74ca47
 #endif
74ca47
 
74ca47
-/* NSPR uses the print macros a bit differently than ANSI C.  We
74ca47
- * need to use ll for a 64-bit integer, even when a long is 64-bit.
74ca47
- */
74ca47
-#if defined(HAVE_LONG_LONG) && PR_BYTES_PER_LONG == 8 && !defined(PR_ALTERNATE_INT64_TYPEDEF)
74ca47
-#define NSPRIu64	"lu"
74ca47
-#define NSPRI64	"l"
74ca47
-#else /* just assume long long is used */
74ca47
-#define NSPRIu64	"llu"
74ca47
-#define NSPRI64	"ll"
74ca47
-#endif
74ca47
-
74ca47
 /* OpenLDAP uses unsigned long for ber_tag_t and ber_len_t but mozldap uses unsigned int */
74ca47
 /* use this macro for printf statements for ber_tag_t and ber_len_t */
74ca47
 #if defined(USE_OPENLDAP)
74ca47
diff --git a/ldap/servers/slapd/slapi-private.h b/ldap/servers/slapd/slapi-private.h
74ca47
index dd180a7..0c76580 100644
74ca47
--- a/ldap/servers/slapd/slapi-private.h
74ca47
+++ b/ldap/servers/slapd/slapi-private.h
74ca47
@@ -30,6 +30,9 @@ extern "C" {
74ca47
  */
74ca47
 #include "slapi-plugin-compat4.h"
74ca47
 
74ca47
+/* slapi platform abstraction functions. */
74ca47
+#include <slapi_pal.h>
74ca47
+
74ca47
 /* Define our internal logging macro */
74ca47
 #define slapi_log_err(level, subsystem, fmt, ...)
74ca47
 #ifdef LDAP_ERROR_LOGGING
74ca47
@@ -1363,26 +1366,33 @@ long long slapi_parse_duration_longlong(const char *value);
74ca47
 int slapi_is_duration_valid(const char *value);
74ca47
 
74ca47
 /**
74ca47
- * Populate the pointers with the system memory information.
74ca47
- * At this time, Linux is the only "reliable" system for returning these values
74ca47
- *
74ca47
- * \param pagesize Will return the system page size in bytes.
74ca47
- * \param pages The total number of memory pages on the system. May include swap pages depending on OS.
74ca47
- * \param procpages Number of memory pages our current process is consuming. May not be accurate on all platforms as this could be the VMSize rather than the actual number of consumed pages.
74ca47
- * \param availpages Number of available pages of memory on the system. Not all operating systems set this correctly.
74ca47
- *
74ca47
- * \return 0 on success, non-zero on failure to determine memory sizings.
74ca47
+ * Possible results of a cachesize check
74ca47
  */
74ca47
-int util_info_sys_pages(size_t *pagesize, size_t *pages, size_t *procpages, size_t *availpages);
74ca47
-
74ca47
+typedef enum _util_cachesize_result {
74ca47
+    /**
74ca47
+     * The requested cachesize was valid and can be used.
74ca47
+     */
74ca47
+    UTIL_CACHESIZE_VALID = 0,
74ca47
+    /**
74ca47
+     * The requested cachesize may cause OOM and was reduced.
74ca47
+     */
74ca47
+    UTIL_CACHESIZE_REDUCED = 1,
74ca47
+    /**
74ca47
+     * An error occured resolving the cache size. You must stop processing.
74ca47
+     */
74ca47
+    UTIL_CACHESIZE_ERROR = 2,
74ca47
+} util_cachesize_result;
74ca47
 /**
74ca47
- * Determine if the requested cachesize will exceed the system memory limits causing an out of memory condition
74ca47
+ * Determine if the requested cachesize will exceed the system memory limits causing an out of memory condition. You must
74ca47
+ * check the result before proceeding to correctly use the cache.
74ca47
  *
74ca47
+ * \param mi. The system memory infomation. You should retrieve this with spal_meminfo_get(), and destroy it after use.
74ca47
  * \param cachesize. The requested allocation. If this value is greater than the memory available, this value will be REDUCED to be valid.
74ca47
  *
74ca47
- * \return 0 if the size is "sane". 1 if the value will cause OOM and has been REDUCED
74ca47
+ * \return util_cachesize_result.
74ca47
+ * \sa util_cachesize_result, spal_meminfo_get
74ca47
  */
74ca47
-int util_is_cachesize_sane(size_t *cachesize);
74ca47
+util_cachesize_result util_is_cachesize_sane(slapi_pal_meminfo *mi, size_t *cachesize);
74ca47
 
74ca47
 /**
74ca47
  * Retrieve the number of threads the server should run with based on this hardware.
74ca47
diff --git a/ldap/servers/slapd/slapi_pal.c b/ldap/servers/slapd/slapi_pal.c
74ca47
new file mode 100644
74ca47
index 0000000..91576ca
74ca47
--- /dev/null
74ca47
+++ b/ldap/servers/slapd/slapi_pal.c
74ca47
@@ -0,0 +1,311 @@
74ca47
+/** BEGIN COPYRIGHT BLOCK
74ca47
+ * Copyright (C) 2017 Red Hat, Inc.
74ca47
+ * All rights reserved.
74ca47
+ *
74ca47
+ * License: GPL (version 3 or any later version).
74ca47
+ * See LICENSE for details. 
74ca47
+ * END COPYRIGHT BLOCK **/
74ca47
+
74ca47
+/*
74ca47
+ * Implementation of functions to abstract from platform
74ca47
+ * specific issues.
74ca47
+ */
74ca47
+
74ca47
+/* Provide ch_malloc etc. */
74ca47
+#include <slapi-plugin.h>
74ca47
+/* Provide slapi_log_err macro wrapper */
74ca47
+#include <slapi-private.h>
74ca47
+#include <slapi_pal.h>
74ca47
+
74ca47
+/* Assert macros */
74ca47
+#include <assert.h>
74ca47
+/* Access errno */
74ca47
+#include <errno.h>
74ca47
+
74ca47
+/* For getpagesize */
74ca47
+#include <unistd.h>
74ca47
+
74ca47
+/* For rlimit */
74ca47
+#include <sys/time.h>
74ca47
+#include <sys/resource.h>
74ca47
+
74ca47
+#ifdef OS_solaris
74ca47
+#include <sys/procfs.h>
74ca47
+#endif
74ca47
+
74ca47
+#if defined ( hpux )
74ca47
+#include <sys/pstat.h>
74ca47
+#endif
74ca47
+
74ca47
+static int_fast32_t
74ca47
+_spal_rlimit_get(int resource, uint64_t *soft_limit, uint64_t *hard_limit) {
74ca47
+    struct rlimit rl = {0};
74ca47
+
74ca47
+    if (getrlimit(resource, &rl) != 0) {
74ca47
+        int errsrv = errno;
74ca47
+        slapi_log_err(SLAPI_LOG_ERR, "_spal_rlimit_mem_get", "Failed to access system resource limits %d\n", errsrv);
74ca47
+        return 1;
74ca47
+    }
74ca47
+
74ca47
+    if (rl.rlim_cur != RLIM_INFINITY) {
74ca47
+        *soft_limit = (uint64_t)rl.rlim_cur;
74ca47
+    }
74ca47
+    if (rl.rlim_max != RLIM_INFINITY) {
74ca47
+        *hard_limit = (uint64_t)rl.rlim_max;
74ca47
+    }
74ca47
+
74ca47
+    return 0;
74ca47
+}
74ca47
+
74ca47
+
74ca47
+#ifdef LINUX
74ca47
+static int_fast32_t
74ca47
+_spal_uint64_t_file_get(char *name, char *prefix, uint64_t *dest) {
74ca47
+    FILE *f;
74ca47
+    char s[40] = {0};
74ca47
+    size_t prefix_len = 0;
74ca47
+
74ca47
+    if (prefix != NULL) {
74ca47
+        prefix_len = strlen(prefix);
74ca47
+    }
74ca47
+
74ca47
+    /* Make sure we can fit into our buffer */
74ca47
+    assert((prefix_len + 20) < 39);
74ca47
+
74ca47
+    f = fopen(name, "r");
74ca47
+    if (!f) {    /* fopen failed */
74ca47
+        int errsrv = errno;
74ca47
+        slapi_log_err(SLAPI_LOG_ERR,"_spal_get_uint64_t_file", "Unable to open file \"%s\". errno=%d\n", name, errsrv);
74ca47
+        return 1;
74ca47
+    }
74ca47
+
74ca47
+    int_fast32_t retval = 0;
74ca47
+    while (! feof(f)) {
74ca47
+        if (!fgets(s, 39, f)) {
74ca47
+            retval = 1;
74ca47
+            break; /* error or eof */
74ca47
+        }
74ca47
+        if (feof(f)) {
74ca47
+            retval = 1;
74ca47
+            break;
74ca47
+        }
74ca47
+        if (prefix_len > 0 && strncmp(s, prefix, prefix_len) == 0) {
74ca47
+            sscanf(s + prefix_len, "%"SCNu64, dest);
74ca47
+            break;
74ca47
+        } else if (prefix_len == 0) {
74ca47
+            sscanf(s, "%"SCNu64, dest);
74ca47
+            break;
74ca47
+        }
74ca47
+    }
74ca47
+    fclose(f);
74ca47
+    return retval;
74ca47
+}
74ca47
+
74ca47
+
74ca47
+
74ca47
+slapi_pal_meminfo *
74ca47
+spal_meminfo_get() {
74ca47
+    slapi_pal_meminfo *mi = (slapi_pal_meminfo *)slapi_ch_calloc(1, sizeof(slapi_pal_meminfo));
74ca47
+
74ca47
+    mi->pagesize_bytes = getpagesize();
74ca47
+
74ca47
+    /*
74ca47
+     * We have to compare values from a number of sources to ensure we have
74ca47
+     * the correct result.
74ca47
+     */
74ca47
+
74ca47
+    char f_proc_status[30] = {0};
74ca47
+    sprintf(f_proc_status, "/proc/%d/status", getpid());
74ca47
+    char *p_vmrss = "VmRSS:";
74ca47
+    uint64_t vmrss = 0;
74ca47
+
74ca47
+    if (_spal_uint64_t_file_get(f_proc_status, p_vmrss, &vmrss)) {
74ca47
+        slapi_log_err(SLAPI_LOG_ERR, "spal_meminfo_get", "Unable to retrieve vmrss\n");
74ca47
+    }
74ca47
+
74ca47
+    /* vmrss is in kb, so convert to bytes */
74ca47
+    vmrss = vmrss * 1024;
74ca47
+
74ca47
+    uint64_t rl_mem_soft = 0;
74ca47
+    uint64_t rl_mem_hard = 0;
74ca47
+    uint64_t rl_mem_soft_avail = 0;
74ca47
+
74ca47
+    if (_spal_rlimit_get(RLIMIT_AS, &rl_mem_soft, &rl_mem_hard)) {
74ca47
+        slapi_log_err(SLAPI_LOG_ERR, "spal_meminfo_get", "Unable to retrieve memory rlimit\n");
74ca47
+    }
74ca47
+
74ca47
+    if (rl_mem_soft != 0 && vmrss != 0 && rl_mem_soft > vmrss) {
74ca47
+        rl_mem_soft_avail = rl_mem_soft - vmrss;
74ca47
+    }
74ca47
+
74ca47
+    char *f_meminfo = "/proc/meminfo";
74ca47
+    char *p_memtotal = "MemTotal:";
74ca47
+    char *p_memavail = "MemAvailable:";
74ca47
+
74ca47
+    uint64_t memtotal = 0;
74ca47
+    uint64_t memavail = 0;
74ca47
+
74ca47
+    if (_spal_uint64_t_file_get(f_meminfo, p_memtotal, &memtotal)) {
74ca47
+        slapi_log_err(SLAPI_LOG_ERR, "spal_meminfo_get", "Unable to retrieve %s : %s\n", f_meminfo, p_memtotal);
74ca47
+    }
74ca47
+
74ca47
+    if (_spal_uint64_t_file_get(f_meminfo, p_memavail, &memavail)) {
74ca47
+        slapi_log_err(SLAPI_LOG_ERR, "spal_meminfo_get", "Unable to retrieve %s : %s\n", f_meminfo, p_memavail);
74ca47
+    }
74ca47
+
74ca47
+    /* Both memtotal and memavail are in kb */
74ca47
+    memtotal = memtotal * 1024;
74ca47
+    memavail = memavail * 1024;
74ca47
+
74ca47
+    /* If it's possible, get our cgroup info */
74ca47
+    uint64_t cg_mem_soft = 0;
74ca47
+    uint64_t cg_mem_hard = 0;
74ca47
+    uint64_t cg_mem_usage = 0;
74ca47
+    uint64_t cg_mem_soft_avail = 0;
74ca47
+
74ca47
+    char *f_cg_soft = "/sys/fs/cgroup/memory/memory.soft_limit_in_bytes";
74ca47
+    char *f_cg_hard = "/sys/fs/cgroup/memory/memory.limit_in_bytes";
74ca47
+    char *f_cg_usage = "/sys/fs/cgroup/memory/memory.usage_in_bytes";
74ca47
+
74ca47
+    if (_spal_uint64_t_file_get(f_cg_soft, NULL, &cg_mem_soft)) {
74ca47
+        slapi_log_err(SLAPI_LOG_WARNING, "spal_meminfo_get", "Unable to retrieve %s. There may be no cgroup support on this platform\n", f_cg_soft);
74ca47
+    }
74ca47
+
74ca47
+    if (_spal_uint64_t_file_get(f_cg_hard, NULL, &cg_mem_hard)) {
74ca47
+        slapi_log_err(SLAPI_LOG_WARNING, "spal_meminfo_get", "Unable to retrieve %s. There may be no cgroup support on this platform\n", f_cg_hard);
74ca47
+    }
74ca47
+
74ca47
+    if (_spal_uint64_t_file_get(f_cg_usage, NULL, &cg_mem_usage)) {
74ca47
+        slapi_log_err(SLAPI_LOG_WARNING, "spal_meminfo_get", "Unable to retrieve %s. There may be no cgroup support on this platform\n", f_cg_hard);
74ca47
+    }
74ca47
+
74ca47
+    /*
74ca47
+     * In some conditions, like docker, we only have a *hard* limit set.
74ca47
+     * This obviously breaks our logic, so we need to make sure we correct this
74ca47
+     */
74ca47
+
74ca47
+    if (cg_mem_hard != 0 && cg_mem_soft != 0 && cg_mem_hard < cg_mem_soft) {
74ca47
+        /* Right, we only have a hard limit. Impose a 10% watermark. */
74ca47
+        cg_mem_soft = cg_mem_hard * 0.9;
74ca47
+    }
74ca47
+
74ca47
+    if (cg_mem_soft != 0 && cg_mem_usage != 0 && cg_mem_soft > cg_mem_usage) {
74ca47
+        cg_mem_soft_avail = cg_mem_soft - cg_mem_usage;
74ca47
+    }
74ca47
+
74ca47
+
74ca47
+    /* Now, compare the values and make a choice to which is provided */
74ca47
+
74ca47
+    /* Process consumed memory */
74ca47
+    mi->process_consumed_bytes = vmrss;
74ca47
+    mi->process_consumed_pages = vmrss / mi->pagesize_bytes;
74ca47
+
74ca47
+    /* System Total memory */
74ca47
+    /*                       If we have a memtotal, OR if no memtotal but rlimit */
74ca47
+    if (rl_mem_hard != 0 &&
74ca47
+            ((memtotal != 0 && rl_mem_hard < memtotal) || memtotal == 0) &&
74ca47
+            ((cg_mem_hard != 0 && rl_mem_hard < cg_mem_hard) || cg_mem_hard == 0)
74ca47
+        )
74ca47
+    {
74ca47
+        slapi_log_err(SLAPI_LOG_TRACE, "spal_meminfo_get", "system_total_bytes - using rlimit\n");
74ca47
+        mi->system_total_bytes = rl_mem_hard;
74ca47
+        mi->system_total_pages = rl_mem_hard / mi->pagesize_bytes;
74ca47
+    } else if (cg_mem_hard != 0 && ((memtotal != 0 && cg_mem_hard < memtotal) || memtotal == 0)) {
74ca47
+        slapi_log_err(SLAPI_LOG_TRACE, "spal_meminfo_get", "system_total_bytes - using cgroup\n");
74ca47
+        mi->system_total_bytes = cg_mem_hard;
74ca47
+        mi->system_total_pages = cg_mem_hard / mi->pagesize_bytes;
74ca47
+    } else if (memtotal != 0) {
74ca47
+        slapi_log_err(SLAPI_LOG_TRACE, "spal_meminfo_get", "system_total_bytes - using memtotal\n");
74ca47
+        mi->system_total_bytes = memtotal;
74ca47
+        mi->system_total_pages = memtotal / mi->pagesize_bytes;
74ca47
+    } else {
74ca47
+        slapi_log_err(SLAPI_LOG_CRIT, "spal_meminfo_get", "Unable to determine system total memory!\n");
74ca47
+        spal_meminfo_destroy(mi);
74ca47
+        return NULL;
74ca47
+    }
74ca47
+
74ca47
+    /* System Available memory */
74ca47
+
74ca47
+    if (rl_mem_soft_avail != 0 &&
74ca47
+            ((memavail != 0 && (rl_mem_soft_avail) < memavail) || memavail == 0) &&
74ca47
+            ((cg_mem_soft_avail != 0 && rl_mem_soft_avail < cg_mem_soft_avail) || cg_mem_soft_avail == 0)
74ca47
+        )
74ca47
+    {
74ca47
+        slapi_log_err(SLAPI_LOG_TRACE, "spal_meminfo_get", "system_available_bytes - using rlimit\n");
74ca47
+        mi->system_available_bytes = rl_mem_soft_avail;
74ca47
+        mi->system_available_pages = rl_mem_soft_avail / mi->pagesize_bytes;
74ca47
+    } else if (cg_mem_soft_avail != 0 && ((memavail != 0 && (cg_mem_soft_avail) < memavail) || memavail == 0)) {
74ca47
+        slapi_log_err(SLAPI_LOG_TRACE, "spal_meminfo_get", "system_available_bytes - using cgroup\n");
74ca47
+        mi->system_available_bytes = cg_mem_soft_avail;
74ca47
+        mi->system_available_pages = cg_mem_soft_avail / mi->pagesize_bytes;
74ca47
+    } else if (memavail != 0) {
74ca47
+        slapi_log_err(SLAPI_LOG_TRACE, "spal_meminfo_get", "system_available_bytes - using memavail\n");
74ca47
+        mi->system_available_bytes = memavail;
74ca47
+        mi->system_available_pages = memavail / mi->pagesize_bytes;
74ca47
+    } else {
74ca47
+        slapi_log_err(SLAPI_LOG_CRIT, "spal_meminfo_get", "Unable to determine system available memory!\n");
74ca47
+        spal_meminfo_destroy(mi);
74ca47
+        return NULL;
74ca47
+    }
74ca47
+
74ca47
+    slapi_log_err(SLAPI_LOG_TRACE, "spal_meminfo_get", "{pagesize_bytes = %"PRIu64", system_total_pages = %"PRIu64", system_total_bytes = %"PRIu64", process_consumed_pages = %"PRIu64", process_consumed_bytes = %"PRIu64", system_available_pages = %"PRIu64", system_available_bytes = %"PRIu64"},\n",
74ca47
+        mi->pagesize_bytes, mi->system_total_pages, mi->system_total_bytes, mi->process_consumed_pages, mi->process_consumed_bytes, mi->system_available_pages, mi->system_available_bytes);
74ca47
+
74ca47
+    return mi;
74ca47
+}
74ca47
+
74ca47
+
74ca47
+#endif
74ca47
+
74ca47
+#ifdef OS_solaris
74ca47
+uint64_t
74ca47
+_spal_solaris_resident_pages_get() {
74ca47
+    uint64_t procpages = 0;
74ca47
+    struct prpsinfo psi = {0};
74ca47
+    char fn[40];
74ca47
+    int fd;
74ca47
+
74ca47
+    sprintf(fn, "/proc/%d", getpid());
74ca47
+    fd = open(fn, O_RDONLY);
74ca47
+    if (fd >= 0) {
74ca47
+        if (ioctl(fd, PIOCPSINFO, (void *)&psi) == 0) {
74ca47
+            procpages = (uint64_t)psi.pr_size;
74ca47
+        }
74ca47
+        close(fd);
74ca47
+    }
74ca47
+    return procpages;
74ca47
+}
74ca47
+
74ca47
+slapi_pal_meminfo *
74ca47
+spal_meminfo_get() {
74ca47
+    slapi_pal_meminfo *mi = (slapi_pal_meminfo *)slapi_ch_calloc(1, sizeof(slapi_pal_meminfo));
74ca47
+
74ca47
+    uint64_t rl_mem_soft = 0;
74ca47
+    uint64_t rl_mem_hard = 0;
74ca47
+
74ca47
+    if (_spal_rlimit_get(RLIMIT_AS, &rl_mem_soft, &rl_mem_hard)) {
74ca47
+        slapi_log_err(SLAPI_LOG_ERR, "spal_meminfo_get", "Unable to retrieve memory rlimit\n");
74ca47
+    }
74ca47
+
74ca47
+    mi->pagesize_bytes = sysconf(_SC_PAGESIZE);
74ca47
+    mi->system_total_pages = sysconf(_SC_PHYS_PAGES);
74ca47
+    mi->system_total_bytes = mi->system_total_pages * mi->pagesize_bytes;
74ca47
+    mi->system_available_bytes = rl_mem_soft;
74ca47
+    if (rl_mem_soft != 0) {
74ca47
+        mi->system_available_pages = rl_mem_soft / mi->pagesize_bytes;
74ca47
+    }
74ca47
+    mi->process_consumed_pages = _spal_solaris_resident_pages_get();
74ca47
+    mi->process_consumed_bytes = mi->process_consumed_pages * mi->pagesize_bytes;
74ca47
+
74ca47
+    return mi;
74ca47
+
74ca47
+}
74ca47
+#endif
74ca47
+
74ca47
+#ifdef HPUX
74ca47
+#endif
74ca47
+
74ca47
+void
74ca47
+spal_meminfo_destroy(slapi_pal_meminfo *mi) {
74ca47
+    slapi_ch_free((void **)&mi);
74ca47
+}
74ca47
diff --git a/ldap/servers/slapd/slapi_pal.h b/ldap/servers/slapd/slapi_pal.h
74ca47
new file mode 100644
74ca47
index 0000000..cb61d84
74ca47
--- /dev/null
74ca47
+++ b/ldap/servers/slapd/slapi_pal.h
74ca47
@@ -0,0 +1,62 @@
74ca47
+/** BEGIN COPYRIGHT BLOCK
74ca47
+ * Copyright (C) 2017 Red Hat, Inc.
74ca47
+ * All rights reserved.
74ca47
+ *
74ca47
+ * License: GPL (version 3 or any later version).
74ca47
+ * See LICENSE for details. 
74ca47
+ * END COPYRIGHT BLOCK **/
74ca47
+
74ca47
+/*
74ca47
+ * Header for the slapi platform abstraction layer.
74ca47
+ *
74ca47
+ * This implements a number of functions that help to provide vendor
74ca47
+ * neutral requests. Candidates for this are memory, thread, disk size
74ca47
+ * and other operations.
74ca47
+ *
74ca47
+ * Basically anywhere you see a "ifdef PLATFORM" is a candidate
74ca47
+ * for this.
74ca47
+ */
74ca47
+
74ca47
+#pragma once
74ca47
+
74ca47
+#include <config.h>
74ca47
+
74ca47
+#ifdef HAVE_INTTYPES_H
74ca47
+#include <inttypes.h>
74ca47
+#else
74ca47
+#error Need to define portable format macros such as PRIu64
74ca47
+#endif /* HAVE_INTTYPES_H */
74ca47
+
74ca47
+/**
74ca47
+ * Structure that contains our system memory information in bytes and pages.
74ca47
+ *
74ca47
+ */
74ca47
+typedef struct _slapi_pal_meminfo {
74ca47
+    uint64_t pagesize_bytes;
74ca47
+    uint64_t system_total_pages;
74ca47
+    uint64_t system_total_bytes;
74ca47
+    uint64_t process_consumed_pages;
74ca47
+    uint64_t process_consumed_bytes;
74ca47
+    /* This value may be limited by cgroup or others. */
74ca47
+    uint64_t system_available_pages;
74ca47
+    uint64_t system_available_bytes;
74ca47
+} slapi_pal_meminfo;
74ca47
+
74ca47
+/**
74ca47
+ * Allocate and returne a populated memory info structure. This will be NULL
74ca47
+ * on error, or contain a structure populated with platform information on
74ca47
+ * success. You should free this with spal_meminfo_destroy.
74ca47
+ *
74ca47
+ * \return slapi_pal_meminfo * pointer to structure containing data, or NULL.
74ca47
+ */
74ca47
+slapi_pal_meminfo * spal_meminfo_get();
74ca47
+
74ca47
+/**
74ca47
+ * Destroy an allocated memory info structure. The caller is responsible for
74ca47
+ * ensuring this is called.
74ca47
+ *
74ca47
+ * \param mi the allocated slapi_pal_meminfo structure from spal_meminfo_get();
74ca47
+ */
74ca47
+void spal_meminfo_destroy(slapi_pal_meminfo *mi);
74ca47
+
74ca47
+
74ca47
diff --git a/ldap/servers/slapd/snmp_collator.c b/ldap/servers/slapd/snmp_collator.c
74ca47
index b0c873d..21043d9 100644
74ca47
--- a/ldap/servers/slapd/snmp_collator.c
74ca47
+++ b/ldap/servers/slapd/snmp_collator.c
74ca47
@@ -711,7 +711,7 @@ static void
74ca47
 add_counter_to_value(Slapi_Entry *e, const char *type, PRUint64 countervalue)
74ca47
 {
74ca47
 	char value[40];
74ca47
-	snprintf(value,sizeof(value),"%" NSPRIu64, countervalue);
74ca47
+	snprintf(value,sizeof(value),"%" PRIu64, countervalue);
74ca47
 	slapi_entry_attr_set_charptr( e, type, value);
74ca47
 }
74ca47
 
74ca47
diff --git a/ldap/servers/slapd/unbind.c b/ldap/servers/slapd/unbind.c
74ca47
index fd44249..92dd905 100644
74ca47
--- a/ldap/servers/slapd/unbind.c
74ca47
+++ b/ldap/servers/slapd/unbind.c
74ca47
@@ -49,7 +49,7 @@ do_unbind( Slapi_PBlock *pb )
74ca47
 	 *	UnBindRequest ::= NULL
74ca47
 	 */
74ca47
 	if ( ber_get_null( ber ) == LBER_ERROR ) {
74ca47
-		slapi_log_access( LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d UNBIND,"
74ca47
+		slapi_log_access( LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d UNBIND,"
74ca47
 				" decoding error: UnBindRequest not null\n",
74ca47
 				pb->pb_conn->c_connid, operation->o_opid );
74ca47
 		/* LDAPv3 does not allow a response to an unbind... so just return. */
74ca47
@@ -64,7 +64,7 @@ do_unbind( Slapi_PBlock *pb )
74ca47
 	 * MUST ignore the criticality field of controls
74ca47
 	 */
74ca47
 	if ( (err = get_ldapmessage_controls_ext( pb, ber, NULL, ignore_criticality )) != 0 ) {
74ca47
-		slapi_log_access( LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d UNBIND,"
74ca47
+		slapi_log_access( LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d UNBIND,"
74ca47
 				" error processing controls - error %d (%s)\n",
74ca47
 				pb->pb_conn->c_connid, operation->o_opid,
74ca47
 				err, ldap_err2string( err ));
74ca47
@@ -79,7 +79,7 @@ do_unbind( Slapi_PBlock *pb )
74ca47
 
74ca47
 	/* ONREPL - plugins should be called and passed bind dn and, possibly, other data */
74ca47
 
74ca47
-	slapi_log_access( LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d UNBIND\n",
74ca47
+	slapi_log_access( LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d UNBIND\n",
74ca47
 			pb->pb_conn->c_connid, operation->o_opid );
74ca47
 
74ca47
 	/* pass the unbind to all backends */
74ca47
diff --git a/ldap/servers/slapd/util.c b/ldap/servers/slapd/util.c
74ca47
index 48fa3c4..012e83d 100644
74ca47
--- a/ldap/servers/slapd/util.c
74ca47
+++ b/ldap/servers/slapd/util.c
74ca47
@@ -40,20 +40,8 @@
74ca47
 #define FILTER_BUF 128 /* initial buffer size for attr value */
74ca47
 #define BUF_INCR 16    /* the amount to increase the FILTER_BUF once it fills up */
74ca47
 
74ca47
-/* Used by our util_info_sys_pages function
74ca47
- *
74ca47
- * platforms supported so far:
74ca47
- * Solaris, Linux, Windows
74ca47
- */
74ca47
-#ifdef OS_solaris
74ca47
-#include <sys/procfs.h>
74ca47
-#endif
74ca47
-#ifdef LINUX
74ca47
-#include <linux/kernel.h>
74ca47
-#endif
74ca47
-#if defined ( hpux )
74ca47
-#include <sys/pstat.h>
74ca47
-#endif
74ca47
+/* slapi-private contains the pal. */
74ca47
+#include <slapi-private.h>
74ca47
 
74ca47
 static int special_filename(unsigned char c)
74ca47
 {
74ca47
@@ -1471,361 +1459,25 @@ slapi_uniqueIDRdnSize(void)
74ca47
 	return util_uniqueidlen;
74ca47
 }
74ca47
 
74ca47
-
74ca47
-/**
74ca47
- * Get the virtual memory size as defined by system rlimits.
74ca47
- *
74ca47
- * \return size_t bytes available
74ca47
- */
74ca47
-static size_t util_getvirtualmemsize(void)
74ca47
-{
74ca47
-    struct rlimit rl;
74ca47
-    /* the maximum size of a process's total available memory, in bytes */
74ca47
-    if (getrlimit(RLIMIT_AS, &rl) != 0) {
74ca47
-        /* We received an error condition. There are a number of possible 
74ca47
-         * reasons we have have gotten here, but most likely is EINVAL, where
74ca47
-         * rlim->rlim_cur was greater than rlim->rlim_max.
74ca47
-         * As a result, we should return a 0, to tell the system we can't alloc
74ca47
-         * memory.
74ca47
-         */
74ca47
-        int errsrv = errno;
74ca47
-        slapi_log_err(SLAPI_LOG_ERR,"util_getvirtualmemsize",
74ca47
-                "getrlimit returned non-zero. errno=%u\n", errsrv);
74ca47
-        return 0;
74ca47
-    }
74ca47
-    return rl.rlim_cur;
74ca47
-}
74ca47
-
74ca47
-/* pages = number of pages of physical ram on the machine (corrected for 32-bit build on 64-bit machine).
74ca47
- * procpages = pages currently used by this process (or working set size, sometimes)
74ca47
- * availpages = some notion of the number of pages 'free'. Typically this number is not useful.
74ca47
- */
74ca47
-int util_info_sys_pages(size_t *pagesize, size_t *pages, size_t *procpages, size_t *availpages)
74ca47
-{
74ca47
-    if ((NULL == pagesize) || (NULL == pages) || (NULL == procpages) || (NULL == availpages)) {
74ca47
-        slapi_log_err(SLAPI_LOG_ERR, "util_info_sys_pages",
74ca47
-                        "Null return variables are passed.  Skip getting the system info.\n");
74ca47
-        return 1;
74ca47
-    }
74ca47
-    *pagesize = 0;
74ca47
-    *pages = 0;
74ca47
-    *availpages = 0;
74ca47
-    *procpages = 0;
74ca47
-
74ca47
-#ifdef OS_solaris
74ca47
-    *pagesize = (int)sysconf(_SC_PAGESIZE);
74ca47
-    *pages = (int)sysconf(_SC_PHYS_PAGES);
74ca47
-    *availpages = util_getvirtualmemsize() / *pagesize;
74ca47
-    /* solaris has THE most annoying way to get this info */
74ca47
-    {
74ca47
-        struct prpsinfo psi = {0};
74ca47
-        char fn[40];
74ca47
-        int fd;
74ca47
-
74ca47
-        sprintf(fn, "/proc/%d", getpid());
74ca47
-        fd = open(fn, O_RDONLY);
74ca47
-        if (fd >= 0) {
74ca47
-            if (ioctl(fd, PIOCPSINFO, (void *)&psi) == 0) {
74ca47
-                *procpages = psi.pr_size;
74ca47
-            }
74ca47
-            close(fd);
74ca47
-        }
74ca47
-    }
74ca47
-#endif
74ca47
-
74ca47
-#ifdef LINUX
74ca47
-    {
74ca47
-        /*
74ca47
-         * On linux because of the way that the virtual memory system works, we
74ca47
-         * don't really need to think about other processes, or fighting them.
74ca47
-         * But that's not without quirks.
74ca47
-         *
74ca47
-         * We are given a virtual memory space, represented by vsize (man 5 proc)
74ca47
-         * This space is a "funny number". It's a best effort based system
74ca47
-         * where linux instead of telling us how much memory *actually* exists
74ca47
-         * for us to use, gives us a virtual memory allocation which is the
74ca47
-         * value of ram + swap.... sometimes. Depends on platform.
74ca47
-         *
74ca47
-         * But none of these pages even exist or belong to us on the real system
74ca47
-         * until will malloc them AND write a non-zero to them.
74ca47
-         *
74ca47
-         * The biggest issue with this is that vsize does NOT consider the
74ca47
-         * effect other processes have on the system. So a process can malloc
74ca47
-         * 2 Gig from the host, and our vsize doesn't reflect that until we
74ca47
-         * suddenly can't malloc anything.
74ca47
-         *
74ca47
-         * We can see exactly what we are using inside of the vmm by
74ca47
-         * looking at rss (man 5 proc). This shows us the current actual
74ca47
-         * allocation of memory we are using. This is a good thing.
74ca47
-         *
74ca47
-         * We obviously don't want to have any pages in swap, but sometimes we
74ca47
-         * can't help that: And there is also no guarantee that while we have
74ca47
-         * X bytes in vsize, that we can even allocate any of them. Plus, we
74ca47
-         * don't know if we are about to allocate to swap or not .... or get us
74ca47
-         * killed in a blaze of oom glory.
74ca47
-         *
74ca47
-         * So there are now two strategies avaliable in this function.
74ca47
-         * The first is to blindly accept what the VMM tells us about vsize
74ca47
-         * while we hope and pray that we don't get nailed because we used
74ca47
-         * too much.
74ca47
-         *
74ca47
-         * The other is a more conservative approach: We check vsize from
74ca47
-         * proc/pid/status, and we check /proc/meminfo for freemem
74ca47
-         * Which ever value is "lower" is the upper bound on pages we could
74ca47
-         * potentially allocate: generally, this will be MemAvailable.
74ca47
-         */
74ca47
-
74ca47
-        size_t freesize = 0;
74ca47
-        size_t rlimsize = 0;
74ca47
-
74ca47
-        *pagesize = getpagesize();
74ca47
-
74ca47
-        /* Get the amount of freeram, rss */
74ca47
-
74ca47
-        FILE *f;
74ca47
-        char fn[40], s[80];
74ca47
-
74ca47
-        sprintf(fn, "/proc/%d/status", getpid());
74ca47
-        f = fopen(fn, "r");
74ca47
-        if (!f) {    /* fopen failed */
74ca47
-            /* We should probably make noise here! */
74ca47
-            int errsrv = errno;
74ca47
-            slapi_log_err(SLAPI_LOG_ERR,"util_info_sys_pages", "Unable to open file /proc/%d/status. errno=%u\n", getpid(), errsrv);
74ca47
-            return 1;
74ca47
-        }
74ca47
-        while (! feof(f)) {
74ca47
-            if (!fgets(s, 79, f)) {
74ca47
-                break; /* error or eof */
74ca47
-            }
74ca47
-            if (feof(f)) {
74ca47
-                break;
74ca47
-            }
74ca47
-            /* VmRSS shows us what we are ACTUALLY using for proc pages
74ca47
-             * Rather than "funny" pages.
74ca47
-             */
74ca47
-            if (strncmp(s, "VmRSS:", 6) == 0) {
74ca47
-                sscanf(s+6, "%lu", (long unsigned int *)procpages);
74ca47
-            }
74ca47
-        }
74ca47
-        fclose(f);
74ca47
-
74ca47
-        FILE *fm;
74ca47
-        char *fmn = "/proc/meminfo";
74ca47
-        fm = fopen(fmn, "r");
74ca47
-        if (!fm) {
74ca47
-            int errsrv = errno;
74ca47
-            slapi_log_err(SLAPI_LOG_ERR,"util_info_sys_pages", "Unable to open file /proc/meminfo. errno=%u\n", errsrv);
74ca47
-            return 1;
74ca47
-        }
74ca47
-        while (! feof(fm)) {
74ca47
-            if (!fgets(s, 79, fm)) {
74ca47
-                break; /* error or eof */
74ca47
-            }
74ca47
-            if (feof(fm)) {
74ca47
-                break;
74ca47
-            }
74ca47
-            if (strncmp(s, "MemTotal:", 9) == 0) {
74ca47
-                sscanf(s+9, "%lu", (long unsigned int *)pages);
74ca47
-            }
74ca47
-            if (strncmp(s, "MemAvailable:", 13) == 0) {
74ca47
-                sscanf(s+13, "%lu", (long unsigned int *)&freesize);
74ca47
-            }
74ca47
-        }
74ca47
-        fclose(fm);
74ca47
-
74ca47
-
74ca47
-        *pages /= (*pagesize / 1024);
74ca47
-        freesize /= (*pagesize / 1024);
74ca47
-        /* procpages is now in kb not pages... */
74ca47
-        *procpages /= (*pagesize / 1024);
74ca47
-
74ca47
-        rlimsize = util_getvirtualmemsize();
74ca47
-        /* On a 64 bit system, this is uint64 max, but on 32 it's -1 */
74ca47
-        /* Either way, we should be ignoring it at this point if it's infinite */
74ca47
-        if (rlimsize != RLIM_INFINITY) {
74ca47
-            /* This is in bytes, make it pages  */
74ca47
-            rlimsize = rlimsize / *pagesize;
74ca47
-        }
74ca47
-
74ca47
-        /* Pages is the total ram on the system. */
74ca47
-        slapi_log_err(SLAPI_LOG_TRACE,"util_info_sys_pages", "pages=%lu, \n", 
74ca47
-            (unsigned long) *pages);
74ca47
-        slapi_log_err(SLAPI_LOG_TRACE,"util_info_sys_pages", "using pages for pages \n");
74ca47
-
74ca47
-        /* Availpages is how much we *could* alloc. We should take the smallest:
74ca47
-         * - pages
74ca47
-         * - getrlimit (availpages)
74ca47
-         * - freesize
74ca47
-         */
74ca47
-        if (rlimsize == RLIM_INFINITY) {
74ca47
-            slapi_log_err(SLAPI_LOG_TRACE,"util_info_sys_pages", "pages=%lu, getrlim=RLIM_INFINITY, freesize=%lu\n",
74ca47
-                (unsigned long)*pages, (unsigned long)freesize);
74ca47
-        } else {
74ca47
-            slapi_log_err(SLAPI_LOG_TRACE,"util_info_sys_pages", "pages=%lu, getrlim=%lu, freesize=%lu\n",
74ca47
-                (unsigned long)*pages, (unsigned long)*availpages, (unsigned long)freesize);
74ca47
-        }
74ca47
-
74ca47
-        if (rlimsize != RLIM_INFINITY && rlimsize < freesize && rlimsize < *pages && rlimsize > 0) {
74ca47
-            slapi_log_err(SLAPI_LOG_TRACE,"util_info_sys_pages", "using getrlim for availpages \n");
74ca47
-            *availpages = rlimsize;
74ca47
-        } else if (freesize < *pages && freesize > 0) {
74ca47
-            slapi_log_err(SLAPI_LOG_TRACE,"util_info_sys_pages", "using freesize for availpages \n");
74ca47
-            *availpages = freesize;
74ca47
-        } else {
74ca47
-            slapi_log_err(SLAPI_LOG_TRACE,"util_info_sys_pages", "using pages for availpages \n");
74ca47
-            *availpages = *pages;
74ca47
-        }
74ca47
-
74ca47
-    }
74ca47
-#endif /* linux */
74ca47
-
74ca47
-
74ca47
-
74ca47
-#if defined ( hpux )
74ca47
-    {
74ca47
-        struct pst_static pst;
74ca47
-        int rval = pstat_getstatic(&pst, sizeof(pst), (size_t)1, 0);
74ca47
-        if (rval < 0) {   /* pstat_getstatic failed */
74ca47
-            return 1;
74ca47
-        }
74ca47
-        *pagesize = pst.page_size;
74ca47
-        *pages = pst.physical_memory;
74ca47
-        *availpages = util_getvirtualmemsize() / *pagesize;
74ca47
-        if (procpages)
74ca47
-        {
74ca47
-#define BURST (size_t)32        /* get BURST proc info at one time... */
74ca47
-            struct pst_status psts[BURST];
74ca47
-            int i, count;
74ca47
-            int idx = 0; /* index within the context */
74ca47
-            int mypid = getpid();
74ca47
-
74ca47
-            *procpages = 0;
74ca47
-            /* loop until count == 0, will occur all have been returned */
74ca47
-            while ((count = pstat_getproc(psts, sizeof(psts[0]), BURST, idx)) > 0) {
74ca47
-                /* got count (max of BURST) this time.  process them */
74ca47
-                for (i = 0; i < count; i++) {
74ca47
-                    if (psts[i].pst_pid == mypid)
74ca47
-                    {
74ca47
-                        *procpages = (size_t)(psts[i].pst_dsize + psts[i].pst_tsize + psts[i].pst_ssize);
74ca47
-                        break;
74ca47
-                    }
74ca47
-                }
74ca47
-                if (i < count)
74ca47
-                    break;
74ca47
-
74ca47
-                /*
74ca47
-                 * now go back and do it again, using the next index after
74ca47
-                 * the current 'burst'
74ca47
-                 */
74ca47
-                idx = psts[count-1].pst_idx + 1;
74ca47
-            }
74ca47
-        }
74ca47
-    }
74ca47
-#endif
74ca47
-    /* If this is a 32-bit build, it might be running on a 64-bit machine,
74ca47
-     * in which case, if the box has tons of ram, we can end up telling 
74ca47
-     * the auto cache code to use more memory than the process can address.
74ca47
-     * so we cap the number returned here.
74ca47
-     */
74ca47
-#if defined(__LP64__) || defined (_LP64)
74ca47
-#else
74ca47
-    {    
74ca47
-#define GIGABYTE (1024*1024*1024)
74ca47
-        size_t one_gig_pages = GIGABYTE / *pagesize;
74ca47
-        if (*pages > (2 * one_gig_pages) ) {
74ca47
-            slapi_log_err(SLAPI_LOG_TRACE,"util_info_sys_pages",
74ca47
-                    "More than 2Gbytes physical memory detected. Since this is a 32-bit process, truncating memory size used for auto cache calculations to 2Gbytes\n");
74ca47
-            *pages = (2 * one_gig_pages);
74ca47
-        }
74ca47
-    }
74ca47
-#endif
74ca47
-
74ca47
-    /* This is stupid. If you set %u to %zu to print a size_t, you get literal %zu in your logs 
74ca47
-     * So do the filthy cast instead.
74ca47
-     */
74ca47
-    slapi_log_err(SLAPI_LOG_TRACE,"util_info_sys_pages", "USING pages=%lu, procpages=%lu, availpages=%lu \n", 
74ca47
-        (unsigned long)*pages, (unsigned long)*procpages, (unsigned long)*availpages);
74ca47
-    return 0;
74ca47
-
74ca47
-}
74ca47
-
74ca47
-int util_is_cachesize_sane(size_t *cachesize)
74ca47
+util_cachesize_result
74ca47
+util_is_cachesize_sane(slapi_pal_meminfo *mi, uint64_t *cachesize)
74ca47
 {
74ca47
-    size_t pages = 0;
74ca47
-    size_t pagesize = 0;
74ca47
-    size_t procpages = 0;
74ca47
-    size_t availpages = 0;
74ca47
-
74ca47
-    size_t cachepages = 0;
74ca47
-
74ca47
-    int issane = 1;
74ca47
-
74ca47
-    if (util_info_sys_pages(&pagesize, &pages, &procpages, &availpages) != 0) {
74ca47
-        goto out;
74ca47
-    }
74ca47
-#ifdef LINUX
74ca47
-    /* Linux we calculate availpages correctly, so USE IT */
74ca47
-    if (!pagesize || !availpages) {
74ca47
-        goto out;
74ca47
-    }
74ca47
-#else
74ca47
-    if (!pagesize || !pages) {
74ca47
-        goto out;
74ca47
+    /* Check we have a valid meminfo struct */
74ca47
+    if (mi->system_available_bytes == 0) {
74ca47
+        slapi_log_err(SLAPI_LOG_CRIT, "util_is_cachesize_sane", "Invalid system memory info, can not proceed.");
74ca47
+        return UTIL_CACHESIZE_ERROR;
74ca47
     }
74ca47
-#endif
74ca47
-    /* do nothing when we can't get the avail mem */
74ca47
-
74ca47
-
74ca47
-    /* If the requested cache size is larger than the remaining physical memory
74ca47
-     * after the current working set size for this process has been subtracted,
74ca47
-     * then we say that's insane and try to correct.
74ca47
-     */
74ca47
-
74ca47
-    cachepages = *cachesize / pagesize;
74ca47
-    slapi_log_err(SLAPI_LOG_TRACE,"util_is_cachesize_sane", "cachesize=%lu / pagesize=%lu \n",
74ca47
-        (unsigned long)*cachesize,(unsigned long)pagesize);
74ca47
-
74ca47
-#ifdef LINUX
74ca47
-    /* Linux we calculate availpages correctly, so USE IT */
74ca47
-    issane = (int)(cachepages <= availpages);
74ca47
-    slapi_log_err(SLAPI_LOG_TRACE,"util_is_cachesize_sane", "cachepages=%lu <= availpages=%lu\n",
74ca47
-        (unsigned long)cachepages,(unsigned long)availpages);
74ca47
 
74ca47
-    if (!issane) {
74ca47
+    slapi_log_err(SLAPI_LOG_TRACE, "util_is_cachesize_sane", "Available bytes %"PRIu64", requested bytes %"PRIu64"\n", mi->system_available_bytes, *cachesize);
74ca47
+    if (*cachesize > mi->system_available_bytes) {
74ca47
         /* Since we are ask for more than what's available, we give 3/4 of the remaining.
74ca47
          * the remaining system mem to the cachesize instead, and log a warning
74ca47
          */
74ca47
-        *cachesize = (size_t)((availpages * 0.75 ) * pagesize);
74ca47
-        /* These are now trace warnings, because it was to confusing to log this *then* kill the request anyway.
74ca47
-         * Instead, we will let the caller worry about the notification, and we'll just use this in debugging and tracing.
74ca47
-         */
74ca47
-        slapi_log_err(SLAPI_LOG_TRACE, "util_is_cachesize_sane", 
74ca47
-                "Available pages %lu, requested pages %lu, pagesize %lu\n", (unsigned long)availpages, (unsigned long)cachepages, (unsigned long)pagesize);
74ca47
-        slapi_log_err(SLAPI_LOG_TRACE, "util_is_cachesize_sane",
74ca47
-        		"WARNING adjusted cachesize to %lu\n", (unsigned long)*cachesize);
74ca47
-    }
74ca47
-#else
74ca47
-    size_t freepages = 0;
74ca47
-    freepages = pages - procpages;
74ca47
-    slapi_log_err(SLAPI_LOG_TRACE,"util_is_cachesize_sane", "pages=%lu - procpages=%lu\n",
74ca47
-        (unsigned long)pages,(unsigned long)procpages);
74ca47
-
74ca47
-    issane = (int)(cachepages <= freepages);
74ca47
-    slapi_log_err(SLAPI_LOG_TRACE,"util_is_cachesize_sane", "cachepages=%lu <= freepages=%lu\n",
74ca47
-        (unsigned long)cachepages,(unsigned long)freepages);
74ca47
-
74ca47
-    if (!issane) {
74ca47
-        *cachesize = (size_t)((pages - procpages) * pagesize);
74ca47
-        slapi_log_err(SLAPI_LOG_WARNING, "util_is_cachesize_sane", "WARNING adjusted cachesize to %lu\n",
74ca47
-            (unsigned long )*cachesize);
74ca47
+        *cachesize = (mi->system_available_bytes * 0.75);
74ca47
+        slapi_log_err(SLAPI_LOG_TRACE, "util_is_cachesize_sane", "Adjusted cachesize to %"PRIu64"\n", *cachesize);
74ca47
+        return UTIL_CACHESIZE_REDUCED;
74ca47
     }
74ca47
-#endif
74ca47
-out:
74ca47
-    if (!issane) {
74ca47
-        slapi_log_err(SLAPI_LOG_TRACE,"util_is_cachesize_sane", "WARNING: Cachesize not sane \n");
74ca47
-    }
74ca47
-
74ca47
-    return issane;
74ca47
+    return UTIL_CACHESIZE_VALID;
74ca47
 }
74ca47
 
74ca47
 long
74ca47
diff --git a/test/libslapd/spal/meminfo.c b/test/libslapd/spal/meminfo.c
74ca47
new file mode 100644
74ca47
index 0000000..776141a
74ca47
--- /dev/null
74ca47
+++ b/test/libslapd/spal/meminfo.c
74ca47
@@ -0,0 +1,54 @@
74ca47
+/** BEGIN COPYRIGHT BLOCK
74ca47
+ * Copyright (C) 2017 Red Hat, Inc.
74ca47
+ * All rights reserved.
74ca47
+ *
74ca47
+ * License: GPL (version 3 or any later version).
74ca47
+ * See LICENSE for details.
74ca47
+ * END COPYRIGHT BLOCK **/
74ca47
+
74ca47
+#include "../../test_slapd.h"
74ca47
+
74ca47
+#include <slapi_pal.h>
74ca47
+#include <slapi-private.h>
74ca47
+
74ca47
+/*
74ca47
+ * Assert that our meminfo interface in slapi_pal works.
74ca47
+ */
74ca47
+
74ca47
+void
74ca47
+test_libslapd_pal_meminfo(void **state __attribute__((unused))) {
74ca47
+    slapi_pal_meminfo *mi = spal_meminfo_get();
74ca47
+    assert_true(mi->pagesize_bytes > 0);
74ca47
+    assert_true(mi->system_total_pages > 0);
74ca47
+    assert_true(mi->system_total_bytes > 0);
74ca47
+    assert_true(mi->process_consumed_pages > 0);
74ca47
+    assert_true(mi->process_consumed_bytes > 0);
74ca47
+    assert_true(mi->system_available_pages > 0);
74ca47
+    assert_true(mi->system_available_bytes > 0);
74ca47
+    spal_meminfo_destroy(mi);
74ca47
+}
74ca47
+
74ca47
+void
74ca47
+test_libslapd_util_cachesane(void **state __attribute__((unused))) {
74ca47
+    slapi_pal_meminfo *mi = spal_meminfo_get();
74ca47
+    uint64_t request = 0;
74ca47
+    mi->system_available_bytes = 0;
74ca47
+    assert_true(util_is_cachesize_sane(mi, &request) == UTIL_CACHESIZE_ERROR);
74ca47
+
74ca47
+    // Set the values to known quantities
74ca47
+    request = 50000;
74ca47
+    mi->system_available_bytes = 99999;
74ca47
+    assert_true(util_is_cachesize_sane(mi, &request) == UTIL_CACHESIZE_VALID);
74ca47
+
74ca47
+    request = 99999;
74ca47
+    assert_true(util_is_cachesize_sane(mi, &request) == UTIL_CACHESIZE_VALID);
74ca47
+
74ca47
+    request = 100000;
74ca47
+    assert_true(util_is_cachesize_sane(mi, &request) == UTIL_CACHESIZE_REDUCED);
74ca47
+    assert_true(request <= 75000);
74ca47
+
74ca47
+    spal_meminfo_destroy(mi);
74ca47
+}
74ca47
+
74ca47
+
74ca47
+
74ca47
diff --git a/test/libslapd/test.c b/test/libslapd/test.c
74ca47
index 6e1171a..6fa7996 100644
74ca47
--- a/test/libslapd/test.c
74ca47
+++ b/test/libslapd/test.c
74ca47
@@ -26,6 +26,8 @@ run_libslapd_tests (void) {
74ca47
         cmocka_unit_test(test_libslapd_operation_v3c_target_spec),
74ca47
         cmocka_unit_test(test_libslapd_counters_atomic_usage),
74ca47
         cmocka_unit_test(test_libslapd_counters_atomic_overflow),
74ca47
+        cmocka_unit_test(test_libslapd_pal_meminfo),
74ca47
+        cmocka_unit_test(test_libslapd_util_cachesane),
74ca47
     };
74ca47
     return cmocka_run_group_tests(tests, NULL, NULL);
74ca47
 }
74ca47
diff --git a/test/test_slapd.h b/test/test_slapd.h
74ca47
index b8f1aba..50de11b 100644
74ca47
--- a/test/test_slapd.h
74ca47
+++ b/test/test_slapd.h
74ca47
@@ -42,3 +42,8 @@ void test_libslapd_operation_v3c_target_spec(void **state);
74ca47
 void test_libslapd_counters_atomic_usage(void **state);
74ca47
 void test_libslapd_counters_atomic_overflow(void **state);
74ca47
 
74ca47
+/* libslapd-pal-meminfo */
74ca47
+
74ca47
+void test_libslapd_pal_meminfo(void **state);
74ca47
+void test_libslapd_util_cachesane(void **state);
74ca47
+
74ca47
-- 
74ca47
2.9.3
74ca47