From 5e383c8152d1273ff3df11578d4c9a94850ca60a Mon Sep 17 00:00:00 2001 From: Mark Reynolds Date: Mar 28 2018 18:28:42 +0000 Subject: Ticket 46918 - Fix compiler warnings on arm Description: On "arm" architecture there were many compiler warnings and after fixing some it also adressed a crash in replication when trying to update the agreement maxcsn. All updatream architectures build without compilar warnings, and coverity scan did not report any regressions. https://pagure.io/389-ds-base/issue/49618 Reviewed by: simon(Thanks!) --- diff --git a/ldap/servers/plugins/posix-winsync/posix-winsync.c b/ldap/servers/plugins/posix-winsync/posix-winsync.c index 07e4804..8e5ca4f 100644 --- a/ldap/servers/plugins/posix-winsync/posix-winsync.c +++ b/ldap/servers/plugins/posix-winsync/posix-winsync.c @@ -318,7 +318,7 @@ sync_acct_disable(void *cbdata __attribute__((unused)), /* the usual domain conf mask = 0x2; adval |= mask; /* set the 0x2 disable bit */ } - PR_snprintf(acctvalstr, sizeof(acctvalstr), "%lu", adval); + PR_snprintf(acctvalstr, sizeof(acctvalstr), "%" PRIu64, adval); slapi_ch_free_string(&mod_bval->bv_val); mod_bval->bv_val = slapi_ch_strdup(acctvalstr); mod_bval->bv_len = strlen(acctvalstr); diff --git a/ldap/servers/plugins/replication/repl5_agmt.c b/ldap/servers/plugins/replication/repl5_agmt.c index d71d3f3..9c88d58 100644 --- a/ldap/servers/plugins/replication/repl5_agmt.c +++ b/ldap/servers/plugins/replication/repl5_agmt.c @@ -182,25 +182,25 @@ agmt_is_valid(Repl_Agmt *ra) } if (ra->port <= 0) { slapi_log_err(SLAPI_LOG_ERR, repl_plugin_name, "agmt_is_valid - Replication agreement \"%s\" " - "is malformed: invalid port number %ld.\n", + "is malformed: invalid port number %" PRId64 ".\n", slapi_sdn_get_dn(ra->dn), ra->port); return_value = 0; } if (ra->timeout < 0) { slapi_log_err(SLAPI_LOG_ERR, repl_plugin_name, "agmt_is_valid - Replication agreement \"%s\" " - "is malformed: invalid timeout %ld.\n", + "is malformed: invalid timeout %" PRId64 ".\n", slapi_sdn_get_dn(ra->dn), ra->timeout); return_value = 0; } if (ra->busywaittime < 0) { slapi_log_err(SLAPI_LOG_ERR, repl_plugin_name, "agmt_is_valid - Replication agreement \"%s\" " - "is malformed: invalid busy wait time %ld.\n", + "is malformed: invalid busy wait time %" PRId64 ".\n", slapi_sdn_get_dn(ra->dn), ra->busywaittime); return_value = 0; } if (ra->pausetime < 0) { slapi_log_err(SLAPI_LOG_ERR, repl_plugin_name, "agmt_is_valid - Replication agreement \"%s\" " - "is malformed: invalid pausetime %ld.\n", + "is malformed: invalid pausetime %" PRId64 ".\n", slapi_sdn_get_dn(ra->dn), ra->pausetime); return_value = 0; } @@ -468,7 +468,7 @@ agmt_new_from_entry(Slapi_Entry *e) if (dot) { *dot = '\0'; } - ra->long_name = slapi_ch_smprintf("agmt=\"%s\" (%s:%ld)", agmtname, hostname, ra->port); + ra->long_name = slapi_ch_smprintf("agmt=\"%s\" (%s:%" PRId64 ")", agmtname, hostname, ra->port); } /* DBDB: review this code */ @@ -791,10 +791,10 @@ agmt_start(Repl_Agmt *ra) char buf[BUFSIZ]; char unavail_buf[BUFSIZ]; - PR_snprintf(buf, BUFSIZ, "%s;%s;%s;%ld;", slapi_sdn_get_dn(repl_sdn), + PR_snprintf(buf, BUFSIZ, "%s;%s;%s;%" PRId64 ";", slapi_sdn_get_dn(repl_sdn), slapi_rdn_get_value_by_ref(slapi_rdn_get_rdn(ra->rdn)), ra->hostname, ra->port); - PR_snprintf(unavail_buf, BUFSIZ, "%s;%s;%s;%ld;unavailable", slapi_sdn_get_dn(repl_sdn), + PR_snprintf(unavail_buf, BUFSIZ, "%s;%s;%s;%" PRId64 ";unavailable", slapi_sdn_get_dn(repl_sdn), slapi_rdn_get_value_by_ref(slapi_rdn_get_rdn(ra->rdn)), ra->hostname, ra->port); if (strstr(maxcsns[i], buf) || strstr(maxcsns[i], unavail_buf)) { @@ -3029,11 +3029,11 @@ agmt_update_maxcsn(Replica *r, Slapi_DN *sdn, int op, LDAPMod **mods, CSN *csn) * temporarily mark it as "unavailable". */ slapi_ch_free_string(&agmt->maxcsn); - agmt->maxcsn = slapi_ch_smprintf("%s;%s;%s;%ld;unavailable", slapi_sdn_get_dn(agmt->replarea), + agmt->maxcsn = slapi_ch_smprintf("%s;%s;%s;%" PRId64 ";unavailable", slapi_sdn_get_dn(agmt->replarea), slapi_rdn_get_value_by_ref(slapi_rdn_get_rdn(agmt->rdn)), agmt->hostname, agmt->port); } else if (rid == oprid) { slapi_ch_free_string(&agmt->maxcsn); - agmt->maxcsn = slapi_ch_smprintf("%s;%s;%s;%ld;%d;%s", slapi_sdn_get_dn(agmt->replarea), + agmt->maxcsn = slapi_ch_smprintf("%s;%s;%s;%" PRId64 ";%" PRIu16 ";%s", slapi_sdn_get_dn(agmt->replarea), slapi_rdn_get_value_by_ref(slapi_rdn_get_rdn(agmt->rdn)), agmt->hostname, agmt->port, agmt->consumerRID, maxcsn); } @@ -3227,10 +3227,10 @@ agmt_remove_maxcsn(Repl_Agmt *ra) char unavail_buf[BUFSIZ]; struct berval val; - PR_snprintf(buf, BUFSIZ, "%s;%s;%s;%ld;", slapi_sdn_get_dn(ra->replarea), + PR_snprintf(buf, BUFSIZ, "%s;%s;%s;%" PRId64 ";", slapi_sdn_get_dn(ra->replarea), slapi_rdn_get_value_by_ref(slapi_rdn_get_rdn(ra->rdn)), ra->hostname, ra->port); - PR_snprintf(unavail_buf, BUFSIZ, "%s;%s;%s;%ld;unavailable", + PR_snprintf(unavail_buf, BUFSIZ, "%s;%s;%s;%" PRId64 ";unavailable", slapi_sdn_get_dn(ra->replarea), slapi_rdn_get_value_by_ref(slapi_rdn_get_rdn(ra->rdn)), ra->hostname, ra->port); diff --git a/ldap/servers/plugins/replication/repl5_replica.c b/ldap/servers/plugins/replication/repl5_replica.c index 5473d5b..2738b7a 100644 --- a/ldap/servers/plugins/replication/repl5_replica.c +++ b/ldap/servers/plugins/replication/repl5_replica.c @@ -72,8 +72,8 @@ struct replica typedef struct reap_callback_data { int rc; - unsigned long num_entries; - unsigned long num_purged_entries; + uint64_t num_entries; + uint64_t num_purged_entries; CSN *purge_csn; PRBool *tombstone_reap_stop; } reap_callback_data; @@ -1897,7 +1897,7 @@ _replica_init_from_config(Replica *r, Slapi_Entry *e, char *errortext) /* Verify backoff min and max work together */ if (backoff_min > backoff_max) { PR_snprintf(errormsg, SLAPI_DSE_RETURNTEXT_SIZE, - "Backoff minimum (%ld) can not be greater than the backoff maximum (%ld).", + "Backoff minimum (%" PRId64 ") can not be greater than the backoff maximum (%" PRId64 ").", backoff_min, backoff_max); slapi_log_err(SLAPI_LOG_ERR, repl_plugin_name, "_replica_init_from_config - " "%s\n", errormsg); @@ -2996,8 +2996,8 @@ process_reap_entry(Slapi_Entry *entry, void *cb_data) { char deletion_csn_str[CSN_STRSIZE]; char purge_csn_str[CSN_STRSIZE]; - unsigned long *num_entriesp = &((reap_callback_data *)cb_data)->num_entries; - unsigned long *num_purged_entriesp = &((reap_callback_data *)cb_data)->num_purged_entries; + uint64_t *num_entriesp = &((reap_callback_data *)cb_data)->num_entries; + uint64_t *num_purged_entriesp = &((reap_callback_data *)cb_data)->num_purged_entries; CSN *purge_csn = ((reap_callback_data *)cb_data)->purge_csn; /* this is a pointer into the actual value in the Replica object - so that if the value is set in the replica, we will know about it immediately */ @@ -3181,14 +3181,14 @@ _replica_reap_tombstones(void *arg) if (LDAP_SUCCESS != oprc) { slapi_log_err(SLAPI_LOG_ERR, repl_plugin_name, "_replica_reap_tombstones - Failed when searching for " - "tombstones in replica %s: %s. Will try again in %ld " + "tombstones in replica %s: %s. Will try again in %" PRId64 " " "seconds.\n", slapi_sdn_get_dn(replica->repl_root), ldap_err2string(oprc), replica->tombstone_reap_interval); } else { slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name, - "_replica_reap_tombstones - Purged %ld of %ld tombstones " - "in replica %s. Will try again in %ld " + "_replica_reap_tombstones - Purged %" PRIu64 " of %" PRIu64 " tombstones " + "in replica %s. Will try again in %" PRId64 " " "seconds.\n", cb_data.num_purged_entries, cb_data.num_entries, slapi_sdn_get_dn(replica->repl_root), @@ -3617,7 +3617,7 @@ replica_set_tombstone_reap_interval(Replica *r, long interval) found = slapi_eq_cancel(r->repl_eqcxt_tr); slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name, - "replica_set_tombstone_reap_interval - tombstone_reap event (interval=%ld) was %s\n", + "replica_set_tombstone_reap_interval - tombstone_reap event (interval=%" PRId64 ") was %s\n", r->tombstone_reap_interval, (found ? "cancelled" : "not found")); r->repl_eqcxt_tr = NULL; } @@ -3627,7 +3627,7 @@ replica_set_tombstone_reap_interval(Replica *r, long interval) slapi_current_utc_time() + r->tombstone_reap_interval, 1000 * r->tombstone_reap_interval); slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name, - "replica_set_tombstone_reap_interval - tombstone_reap event (interval=%ld) was %s\n", + "replica_set_tombstone_reap_interval - tombstone_reap event (interval=%" PRId64 ") was %s\n", r->tombstone_reap_interval, (r->repl_eqcxt_tr ? "scheduled" : "not scheduled successfully")); } replica_unlock(r->repl_lock); diff --git a/ldap/servers/plugins/replication/replutil.c b/ldap/servers/plugins/replication/replutil.c index 7cc1323..a852f24 100644 --- a/ldap/servers/plugins/replication/replutil.c +++ b/ldap/servers/plugins/replication/replutil.c @@ -1076,7 +1076,7 @@ repl_config_valid_num(const char *config_attr, char *config_attr_value, int64_t *returncode = LDAP_UNWILLING_TO_PERFORM; if (errortext){ PR_snprintf(errortext, SLAPI_DSE_RETURNTEXT_SIZE, - "Attribute %s value (%s) is invalid, must be a number between %ld and %ld.", + "Attribute %s value (%s) is invalid, must be a number between %" PRId64 " and %" PRId64 ".", config_attr, config_attr_value, min, max); slapi_log_err(SLAPI_LOG_ERR, repl_plugin_name, "repl_config_valid_num - %s\n", errortext); diff --git a/ldap/servers/slapd/abandon.c b/ldap/servers/slapd/abandon.c index e2237e5..3f7bef0 100644 --- a/ldap/servers/slapd/abandon.c +++ b/ldap/servers/slapd/abandon.c @@ -148,7 +148,7 @@ do_abandon(Slapi_PBlock *pb) slapi_log_access(LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d ABANDON" " targetop=%d msgid=%d nentries=%d etime=%" PRId64 ".%010" PRId64 "\n", pb_conn->c_connid, pb_op->o_opid, o->o_opid, id, - o->o_results.r.r_search.nentries, o_hr_time_end.tv_sec, o_hr_time_end.tv_nsec); + o->o_results.r.r_search.nentries, (int64_t)o_hr_time_end.tv_sec, (int64_t)o_hr_time_end.tv_nsec); } PR_ExitMonitor(pb_conn->c_mutex); diff --git a/ldap/servers/slapd/back-ldbm/back-ldbm.h b/ldap/servers/slapd/back-ldbm/back-ldbm.h index d2b25a7..ffc803e 100644 --- a/ldap/servers/slapd/back-ldbm/back-ldbm.h +++ b/ldap/servers/slapd/back-ldbm/back-ldbm.h @@ -351,7 +351,7 @@ struct backdn ID ep_id; /* entry id */ char ep_state; /* state in the cache; share ENTRY_STATE_* */ int ep_refcnt; /* entry reference cnt */ - size_t ep_size; /* for cache tracking */ + uint64_t ep_size; /* for cache tracking */ Slapi_DN *dn_sdn; void *dn_id_link; /* for hash table */ }; @@ -359,10 +359,10 @@ struct backdn /* for the in-core cache of entries */ struct cache { - size_t c_maxsize; /* max size in bytes */ + uint64_t c_maxsize; /* max size in bytes */ Slapi_Counter *c_cursize; /* size in bytes */ - long c_maxentries; /* max entries allowed (-1: no limit) */ - long c_curentries; /* current # entries in cache */ + uint64_t c_maxentries; /* max entries allowed (-1: no limit) */ + uint64_t c_curentries; /* current # entries in cache */ Hashtable *c_dntable; Hashtable *c_idtable; #ifdef UUIDCACHE_ON @@ -551,63 +551,45 @@ struct ldbminfo int li_allidsthreshold; char *li_directory; int li_reslimit_lookthrough_handle; - size_t li_dbcachesize; + uint64_t li_dbcachesize; int li_dblock; int li_dbncache; - int li_import_cache_autosize; /* % of free memory to use - * for the import caches - * (-1=default, 80% on cmd import) - * (0 = off) -- overrides - * import cache size settings */ - int li_cache_autosize; /* % of free memory to use - * for the combined caches - * (0 = off) -- overrides - * other cache size settings */ - int li_cache_autosize_split; /* % of li_cache_autosize to - * use for the libdb cache. - * the rest is split up among - * the instance entry caches */ - uint64_t li_cache_autosize_ec; /* new instances created while - * the server is up, should - * use this as the entry cache - * size (0 = autosize off) */ + int li_import_cache_autosize; /* % of free memory to use for the import caches + * (-1=default, 80% on cmd import) + * (0 = off) -- overrides import cache size settings */ + int li_cache_autosize; /* % of free memory to use for the combined caches + * (0 = off) -- overrides other cache size settings */ + int li_cache_autosize_split; /* % of li_cache_autosize to use for the libdb cache. + * the rest is split up among the instance entry caches */ + uint64_t li_cache_autosize_ec; /* new instances created while the server is up, should + * use this as the entry cache size (0 = autosize off) */ uint64_t li_dncache_autosize_ec; /* Same as above, but dncache. */ - size_t li_import_cachesize; /* size of the mpool for - * imports */ + uint64_t li_import_cachesize; /* size of the mpool for imports */ PRLock *li_dbcache_mutex; PRCondVar *li_dbcache_cv; - int li_shutdown; /* flag to tell any BE threads - * to end */ + int li_shutdown; /* flag to tell any BE threads to end */ PRLock *li_shutdown_mutex; /* protect shutdown flag */ dblayer_private *li_dblayer_private; /* session ptr for databases */ - int li_noparentcheck; /* check if parent exists on - * add */ + int li_noparentcheck; /* check if parent exists on add */ /* the next 3 fields are for the params that don't get changed until * the server is restarted (used by the admin console) */ char *li_new_directory; - size_t li_new_dbcachesize; + uint64_t li_new_dbcachesize; int li_new_dblock; int li_new_dbncache; db_upgrade_info *upgrade_info; - int li_filter_bypass; /* bypass filter testing, - * when possible */ - int li_filter_bypass_check; /* check that filter bypass - * is doing the right thing */ - int li_use_vlv; /* use vlv indexes to short- - * circuit matches when - * possible */ - void *li_identity; /* The ldbm plugin needs to keep - * track of its identity so it can - * perform internal ops. Its - * identity is given to it when - * its init function is called. */ - - Objset *li_instance_set; /* A set containing the ldbm - * instances. */ + int li_filter_bypass; /* bypass filter testing, when possible */ + int li_filter_bypass_check; /* check that filter bypass is doing the right thing */ + int li_use_vlv; /* use vlv indexes to short-circuit matches when possible */ + void *li_identity; /* The ldbm plugin needs to keep track of its identity so it can + * perform internal ops. Its identity is given to it when + * its init function is called. */ + + Objset *li_instance_set; /* A set containing the ldbm instances. */ PRLock *li_config_mutex; diff --git a/ldap/servers/slapd/back-ldbm/cache.c b/ldap/servers/slapd/back-ldbm/cache.c index ee20dc3..77757c2 100644 --- a/ldap/servers/slapd/back-ldbm/cache.c +++ b/ldap/servers/slapd/back-ldbm/cache.c @@ -183,7 +183,7 @@ new_hash(u_long size, u_long offset, HashFn hfn, HashTestFn tfn) * already there (filled into 'alt' if 'alt' is not NULL) */ int -add_hash(Hashtable *ht, void *key, size_t keylen, void *entry, void **alt) +add_hash(Hashtable *ht, void *key, uint32_t keylen, void *entry, void **alt) { u_long val, slot; void *e; @@ -209,7 +209,7 @@ add_hash(Hashtable *ht, void *key, size_t keylen, void *entry, void **alt) /* returns 1 if the item was found, and puts a ptr to it in 'entry' */ int -find_hash(Hashtable *ht, const void *key, size_t keylen, void **entry) +find_hash(Hashtable *ht, const void *key, uint32_t keylen, void **entry) { u_long val, slot; void *e; @@ -231,7 +231,7 @@ find_hash(Hashtable *ht, const void *key, size_t keylen, void **entry) /* returns 1 if the item was found and removed */ int -remove_hash(Hashtable *ht, const void *key, size_t keylen) +remove_hash(Hashtable *ht, const void *key, uint32_t keylen) { u_long val, slot; void *e, *laste = NULL; @@ -494,7 +494,7 @@ cache_make_hashes(struct cache *cache, int type) /* initialize the cache */ int -cache_init(struct cache *cache, size_t maxsize, long maxentries, int type) +cache_init(struct cache *cache, uint64_t maxsize, uint64_t maxentries, int type) { slapi_log_err(SLAPI_LOG_TRACE, "cache_init", "-->\n"); cache->c_maxsize = maxsize; @@ -598,7 +598,7 @@ entrycache_clear_int(struct cache *cache) cache->c_maxsize = size; if (cache->c_curentries > 0) { slapi_log_err(SLAPI_LOG_WARNING, - "entrycache_clear_int", "There are still %ld entries " + "entrycache_clear_int", "There are still %" PRIu64 " entries " "in the entry cache.\n", cache->c_curentries); #ifdef LDAP_CACHE_DEBUG @@ -648,7 +648,7 @@ cache_destroy_please(struct cache *cache, int type) } void -cache_set_max_size(struct cache *cache, size_t bytes, int type) +cache_set_max_size(struct cache *cache, uint64_t bytes, int type) { if (CACHE_TYPE_ENTRY == type) { entrycache_set_max_size(cache, bytes); @@ -773,7 +773,7 @@ cache_entry_size(struct backentry *e) * these u_long *'s to a struct */ void -cache_get_stats(struct cache *cache, PRUint64 *hits, PRUint64 *tries, long *nentries, long *maxentries, size_t *size, size_t *maxsize) +cache_get_stats(struct cache *cache, PRUint64 *hits, PRUint64 *tries, uint64_t *nentries, uint64_t *maxentries, uint64_t *size, uint64_t *maxsize) { cache_lock(cache); if (hits) @@ -1580,7 +1580,7 @@ dncache_clear_int(struct cache *cache) cache->c_maxsize = size; if (cache->c_curentries > 0) { slapi_log_err(SLAPI_LOG_WARNING, - "dncache_clear_int", "There are still %ld dn's " + "dncache_clear_int", "There are still %" PRIu64 " dn's " "in the dn cache. :/\n", cache->c_curentries); } diff --git a/ldap/servers/slapd/back-ldbm/dblayer.c b/ldap/servers/slapd/back-ldbm/dblayer.c index 5d870e3..5ab2211 100644 --- a/ldap/servers/slapd/back-ldbm/dblayer.c +++ b/ldap/servers/slapd/back-ldbm/dblayer.c @@ -822,10 +822,10 @@ dblayer_dump_config_tracing(dblayer_private *priv) slapi_log_err(SLAPI_LOG_TRACE, "dblayer_dump_config_tracing", "dbhome_directory=%s\n", priv->dblayer_dbhome_directory); } slapi_log_err(SLAPI_LOG_TRACE, "dblayer_dump_config_tracing", "trickle_percentage=%d\n", priv->dblayer_trickle_percentage); - slapi_log_err(SLAPI_LOG_TRACE, "dblayer_dump_config_tracing", "page_size=%lu\n", priv->dblayer_page_size); - slapi_log_err(SLAPI_LOG_TRACE, "dblayer_dump_config_tracing", "index_page_size=%lu\n", priv->dblayer_index_page_size); - slapi_log_err(SLAPI_LOG_TRACE, "dblayer_dump_config_tracing", "cachesize=%lu\n", priv->dblayer_cachesize); - slapi_log_err(SLAPI_LOG_TRACE, "dblayer_dump_config_tracing", "previous_cachesize=%lu\n", priv->dblayer_previous_cachesize); + slapi_log_err(SLAPI_LOG_TRACE, "dblayer_dump_config_tracing", "page_size=%" PRIu32 "\n", priv->dblayer_page_size); + slapi_log_err(SLAPI_LOG_TRACE, "dblayer_dump_config_tracing", "index_page_size=%" PRIu32 "\n", priv->dblayer_index_page_size); + slapi_log_err(SLAPI_LOG_TRACE, "dblayer_dump_config_tracing", "cachesize=%" PRIu64 "\n", priv->dblayer_cachesize); + slapi_log_err(SLAPI_LOG_TRACE, "dblayer_dump_config_tracing", "previous_cachesize=%" PRIu64 "\n", priv->dblayer_previous_cachesize); slapi_log_err(SLAPI_LOG_TRACE, "dblayer_dump_config_tracing", "ncache=%d\n", priv->dblayer_ncache); slapi_log_err(SLAPI_LOG_TRACE, "dblayer_dump_config_tracing", "previous_ncache=%d\n", priv->dblayer_previous_ncache); slapi_log_err(SLAPI_LOG_TRACE, "dblayer_dump_config_tracing", "recovery_required=%d\n", priv->dblayer_recovery_required); @@ -834,8 +834,8 @@ dblayer_dump_config_tracing(dblayer_private *priv) slapi_log_err(SLAPI_LOG_TRACE, "dblayer_dump_config_tracing", "transaction_batch_val=%d\n", trans_batch_limit); slapi_log_err(SLAPI_LOG_TRACE, "dblayer_dump_config_tracing", "circular_logging=%d\n", priv->dblayer_circular_logging); slapi_log_err(SLAPI_LOG_TRACE, "dblayer_dump_config_tracing", "idl_divisor=%d\n", priv->dblayer_idl_divisor); - slapi_log_err(SLAPI_LOG_TRACE, "dblayer_dump_config_tracing", "logfile_size=%lu\n", priv->dblayer_logfile_size); - slapi_log_err(SLAPI_LOG_TRACE, "dblayer_dump_config_tracing", "logbuf_size=%lu\n", priv->dblayer_logbuf_size); + slapi_log_err(SLAPI_LOG_TRACE, "dblayer_dump_config_tracing", "logfile_size=%" PRIu64 "\n", priv->dblayer_logfile_size); + slapi_log_err(SLAPI_LOG_TRACE, "dblayer_dump_config_tracing", "logbuf_size=%" PRIu64 "\n", priv->dblayer_logbuf_size); slapi_log_err(SLAPI_LOG_TRACE, "dblayer_dump_config_tracing", "file_mode=%d\n", priv->dblayer_file_mode); slapi_log_err(SLAPI_LOG_TRACE, "dblayer_dump_config_tracing", "cache_config=%d\n", priv->dblayer_cache_config); slapi_log_err(SLAPI_LOG_TRACE, "dblayer_dump_config_tracing", "lib_version=%d\n", priv->dblayer_lib_version); @@ -1203,8 +1203,8 @@ no_diskspace(struct ldbminfo *li, int dbenv_flags) /* Check if we have enough space */ if (fsiz < expected_siz) { slapi_log_err(SLAPI_LOG_ERR, - "no_diskspace", "No enough space left on device (%s) (%lu bytes); " - "at least %lu bytes space is needed for db region files\n", + "no_diskspace", "No enough space left on device (%s) (%" PRIu64 " bytes); " + "at least %" PRIu64 " bytes space is needed for db region files\n", region_dir, fsiz, expected_siz); return 1; } @@ -1322,9 +1322,9 @@ dblayer_start(struct ldbminfo *li, int dbmode) priv->dblayer_cachesize = MINCACHESIZE; } /* Oops---looks like the admin misconfigured, let's warn them */ - slapi_log_err(SLAPI_LOG_WARNING, "dblayer_start", "Likely CONFIGURATION ERROR - dbcachesize is configured to use more than the available " - "memory, decreased to (%" PRIu64 " bytes).\n", - priv->dblayer_cachesize); + slapi_log_err(SLAPI_LOG_WARNING, "dblayer_start", + "Likely CONFIGURATION ERROR - dbcachesize is configured to use more than the available " + "memory, decreased to (%" PRIu64 " bytes).\n", priv->dblayer_cachesize); li->li_dbcachesize = priv->dblayer_cachesize; } spal_meminfo_destroy(mi); @@ -1406,7 +1406,7 @@ dblayer_start(struct ldbminfo *li, int dbmode) (priv->dblayer_lock_config != priv->dblayer_previous_lock_config)) && !(dbmode & (DBLAYER_ARCHIVE_MODE | DBLAYER_EXPORT_MODE))) { if (priv->dblayer_cachesize != priv->dblayer_previous_cachesize) { - slapi_log_err(SLAPI_LOG_INFO, "dblayer_start", "Resizing db cache size: %lu -> %lu\n", + slapi_log_err(SLAPI_LOG_INFO, "dblayer_start", "Resizing db cache size: %" PRIu64 " -> %" PRIu64 "\n", priv->dblayer_previous_cachesize, priv->dblayer_cachesize); } if (priv->dblayer_ncache != priv->dblayer_previous_ncache) { @@ -1448,8 +1448,9 @@ dblayer_start(struct ldbminfo *li, int dbmode) if (priv->dblayer_logbuf_size >= 32768) { pEnv->dblayer_DB_ENV->set_lg_bsize(pEnv->dblayer_DB_ENV, priv->dblayer_logbuf_size); } else { - slapi_log_err(SLAPI_LOG_NOTICE, "dblayer_start", "Using default value for log bufsize because configured value (%lu) is too small.\n", - priv->dblayer_logbuf_size); + slapi_log_err(SLAPI_LOG_NOTICE, "dblayer_start", + "Using default value for log bufsize because configured value (%" PRIu64 ") is too small.\n", + priv->dblayer_logbuf_size); } } @@ -1499,7 +1500,7 @@ dblayer_start(struct ldbminfo *li, int dbmode) */ slapi_log_err(SLAPI_LOG_CRIT, "dblayer_start", "mmap in opening database environment (recovery mode) " - "failed trying to allocate %lu bytes. (OS err %d - %s)\n", + "failed trying to allocate %" PRIu64 " bytes. (OS err %d - %s)\n", li->li_dbcachesize, return_value, dblayer_strerror(return_value)); dblayer_free_env(&priv->dblayer_env); priv->dblayer_env = CATASTROPHIC; @@ -1509,7 +1510,7 @@ dblayer_start(struct ldbminfo *li, int dbmode) return_value, dblayer_strerror(return_value)); slapi_log_err(SLAPI_LOG_CRIT, "dblayer_start", "Please make sure there is enough disk space for " - "dbcache (%lu bytes) and db region files\n", + "dbcache (%" PRIu64 " bytes) and db region files\n", li->li_dbcachesize); } return return_value; @@ -1588,7 +1589,7 @@ dblayer_start(struct ldbminfo *li, int dbmode) */ slapi_log_err(SLAPI_LOG_CRIT, "dblayer_start", "mmap in opening database environment " - "failed trying to allocate %lu bytes. (OS err %d - %s)\n", + "failed trying to allocate %" PRIu64 " bytes. (OS err %d - %s)\n", li->li_dbcachesize, return_value, dblayer_strerror(return_value)); dblayer_free_env(&priv->dblayer_env); priv->dblayer_env = CATASTROPHIC; @@ -1949,7 +1950,7 @@ dblayer_instance_start(backend *be, int mode) (priv->dblayer_page_size == 0) ? DBLAYER_PAGESIZE : priv->dblayer_page_size); if (0 != return_value) { slapi_log_err(SLAPI_LOG_ERR, - "dblayer_instance_start", "dbp->set_pagesize(%lu or %lu) failed %d\n", + "dblayer_instance_start", "dbp->set_pagesize(%" PRIu32 " or %" PRIu32 ") failed %d\n", priv->dblayer_page_size, DBLAYER_PAGESIZE, return_value); goto out; @@ -1976,7 +1977,7 @@ dblayer_instance_start(backend *be, int mode) (priv->dblayer_page_size == 0) ? DBLAYER_PAGESIZE : priv->dblayer_page_size); if (0 != return_value) { slapi_log_err(SLAPI_LOG_ERR, - "dblayer_instance_start", "dbp->set_pagesize(%lu or %lu) failed %d\n", + "dblayer_instance_start", "dbp->set_pagesize(%" PRIu32 " or %" PRIu32 ") failed %d\n", priv->dblayer_page_size, DBLAYER_PAGESIZE, return_value); goto out; @@ -2223,7 +2224,7 @@ dblayer_get_aux_id2entry_ext(backend *be, DB **ppDB, DB_ENV **ppEnv, char **path rval = dbp->set_pagesize(dbp, (priv->dblayer_page_size == 0) ? DBLAYER_PAGESIZE : priv->dblayer_page_size); if (rval) { slapi_log_err(SLAPI_LOG_ERR, - "dblayer_get_aux_id2entry_ext", "dbp->set_pagesize(%lu or %lu) failed %d\n", + "dblayer_get_aux_id2entry_ext", "dbp->set_pagesize(%" PRIu32 " or %" PRIu32 ") failed %d\n", priv->dblayer_page_size, DBLAYER_PAGESIZE, rval); goto err; } @@ -3495,11 +3496,11 @@ dblayer_txn_abort_all(struct ldbminfo *li, back_txn *txn) return (dblayer_txn_abort_ext(li, txn, PR_TRUE)); } -size_t +uint32_t dblayer_get_optimal_block_size(struct ldbminfo *li) { dblayer_private *priv = NULL; - size_t page_size = 0; + uint32_t page_size = 0; PR_ASSERT(NULL != li); @@ -3650,7 +3651,7 @@ typedef struct txn_test_iter DBC *cur; uint64_t cnt; const char *attr; - u_int32_t flags; + uint32_t flags; backend *be; } txn_test_iter; @@ -3658,14 +3659,14 @@ typedef struct txn_test_cfg { PRUint32 hold_msec; PRUint32 loop_msec; - u_int32_t flags; + uint32_t flags; int use_txn; char **indexes; int verbose; } txn_test_cfg; static txn_test_iter * -new_txn_test_iter(DB *db, const char *attr, backend *be, u_int32_t flags) +new_txn_test_iter(DB *db, const char *attr, backend *be, uint32_t flags) { txn_test_iter *tti = (txn_test_iter *)slapi_ch_malloc(sizeof(txn_test_iter)); tti->db = db; @@ -3702,7 +3703,7 @@ free_txn_test_iter(txn_test_iter *tti) } static void -free_ttilist(txn_test_iter ***ttilist, size_t *tticnt) +free_ttilist(txn_test_iter ***ttilist, uint64_t *tticnt) { if (!ttilist || !*ttilist || !**ttilist) { return; @@ -3715,7 +3716,7 @@ free_ttilist(txn_test_iter ***ttilist, size_t *tticnt) } static void -init_ttilist(txn_test_iter **ttilist, size_t tticnt) +init_ttilist(txn_test_iter **ttilist, uint64_t tticnt) { if (!ttilist || !*ttilist) { return; @@ -3727,12 +3728,12 @@ init_ttilist(txn_test_iter **ttilist, size_t tticnt) } static void -print_ttilist(txn_test_iter **ttilist, size_t tticnt) +print_ttilist(txn_test_iter **ttilist, uint64_t tticnt) { while (tticnt > 0) { tticnt--; slapi_log_err(SLAPI_LOG_ERR, - "txn_test_threadmain", "attr [%s] cnt [%lu]\n", + "txn_test_threadmain", "attr [%s] cnt [%" PRIu64 "]\n", ttilist[tticnt]->attr, ttilist[tticnt]->cnt); } } @@ -3903,7 +3904,7 @@ wait_for_init: /* phase 1 - open a cursor to each db */ if (cfg.verbose) { slapi_log_err(SLAPI_LOG_ERR, - "txn_test_threadmain", "Starting [%lu] indexes\n", tticnt); + "txn_test_threadmain", "Starting [%" PRIu64 "] indexes\n", tticnt); } for (ii = 0; ii < tticnt; ++ii) { txn_test_iter *tti = ttilist[ii]; @@ -4015,7 +4016,7 @@ wait_for_init: init_ttilist(ttilist, tticnt); if (cfg.verbose) { slapi_log_err(SLAPI_LOG_ERR, - "txn_test_threadmain", "Finished [%lu] indexes [%lu] records\n", tticnt, cnt); + "txn_test_threadmain", "Finished [%" PRIu64 "] indexes [%" PRIu64 "] records\n", tticnt, cnt); } TXN_TEST_LOOP_WAIT(cfg.loop_msec); } else { @@ -4612,10 +4613,10 @@ db_atoi(char *str, int *err) return db_atol(str, err); } -unsigned long +uint32_t db_strtoul(const char *str, int *err) { - unsigned long val = 0, result, multiplier = 1; + uint32_t val = 0, result, multiplier = 1; char *p; errno = 0; @@ -4678,6 +4679,72 @@ db_strtoul(const char *str, int *err) return result; } +uint64_t +db_strtoull(const char *str, int *err) +{ + uint64_t val = 0, result, multiplier = 1; + char *p; + errno = 0; + + /* + * manpage of strtoull: Negative values are considered valid input and + * are silently converted to the equivalent unsigned long int value. + */ + /* We don't want to make it happen. */ + for (p = (char *)str; p && *p && (*p == ' ' || *p == '\t'); p++) + ; + if ('-' == *p) { + if (err) { + *err = ERANGE; + } + return val; + } + val = strtoull(str, &p, 10); + if (errno != 0) { + if (err) { + *err = errno; + } + return val; + } + + switch (*p) { + case 'g': + case 'G': + multiplier *= 1024 * 1024 * 1024; + break; + case 'm': + case 'M': + multiplier *= 1024 * 1024; + break; + case 'k': + case 'K': + multiplier *= 1024; + p++; + if (*p == 'b' || *p == 'B') { + p++; + } + if (err) { + /* extra chars? */ + *err = (*p != '\0') ? EINVAL : 0; + } + break; + case '\0': + if (err) { + *err = 0; + } + break; + default: + if (err) { + *err = EINVAL; + } + return val; + } + + result = val * multiplier; + + return result; +} + /* functions called directly by the plugin interface from the front-end */ /* Begin transaction */ @@ -7200,9 +7267,9 @@ ldbm_back_get_info(Slapi_Backend *be, int cmd, void **info) if (li) { dblayer_private *prv = (dblayer_private *)li->li_dblayer_private; if (prv && prv->dblayer_index_page_size) { - *(size_t *)info = prv->dblayer_index_page_size; + *(uint32_t *)info = prv->dblayer_index_page_size; } else { - *(size_t *)info = DBLAYER_INDEX_PAGESIZE; + *(uint32_t *)info = DBLAYER_INDEX_PAGESIZE; } rc = 0; } diff --git a/ldap/servers/slapd/back-ldbm/dblayer.h b/ldap/servers/slapd/back-ldbm/dblayer.h index 6fe28d1..5e4433e 100644 --- a/ldap/servers/slapd/back-ldbm/dblayer.h +++ b/ldap/servers/slapd/back-ldbm/dblayer.h @@ -28,8 +28,8 @@ #endif /* solaris: mmap */ #endif /* DB_USE_64LFS */ -#define DBLAYER_PAGESIZE (size_t)8 * 1024 -#define DBLAYER_INDEX_PAGESIZE (size_t)8 * 1024 /* With the new idl design, \ +#define DBLAYER_PAGESIZE (uint32_t)8 * 1024 +#define DBLAYER_INDEX_PAGESIZE (uint32_t)8 * 1024 /* With the new idl design, \ the large 8Kbyte pages we use are not optimal. The page pool churns very \ quickly as we add new IDs under a sustained add load. Smaller pages stop \ this happening so much and consequently make us spend less time flushing \ @@ -103,9 +103,9 @@ struct dblayer_private int dblayer_durable_transactions; int dblayer_checkpoint_interval; int dblayer_circular_logging; - uint64_t dblayer_page_size; /* db page size if configured, + uint32_t dblayer_page_size; /* db page size if configured, * otherwise default to DBLAYER_PAGESIZE */ - uint64_t dblayer_index_page_size; /* db index page size if configured, + uint32_t dblayer_index_page_size; /* db index page size if configured, * otherwise default to * DBLAYER_INDEX_PAGESIZE */ int dblayer_idl_divisor; /* divide page size by this to get IDL diff --git a/ldap/servers/slapd/back-ldbm/filterindex.c b/ldap/servers/slapd/back-ldbm/filterindex.c index e8c3c20..9a6d33f 100644 --- a/ldap/servers/slapd/back-ldbm/filterindex.c +++ b/ldap/servers/slapd/back-ldbm/filterindex.c @@ -974,7 +974,7 @@ keys2idl( IDList *idl = NULL; slapi_log_err(SLAPI_LOG_TRACE, "keys2idl", "=> type %s indextype %s\n", type, indextype); - for (size_t i = 0; ivals[i] != NULL; i++) { + for (uint32_t i = 0; ivals[i] != NULL; i++) { IDList *idl2 = NULL; idl2 = index_read_ext_allids(pb, be, type, indextype, slapi_value_get_berval(ivals[i]), txn, err, unindexed, allidslimit); @@ -985,8 +985,8 @@ keys2idl( char buf[BUFSIZ]; slapi_log_err(SLAPI_LOG_TRACE, "keys2idl", - " ival[%lu] = \"%s\" => %lu IDs\n", i, - encode(slapi_value_get_berval(ivals[i]), buf), (u_long)IDL_NIDS(idl2)); + " ival[%" PRIu32 "] = \"%s\" => %" PRIu32 " IDs\n", i, + encode(slapi_value_get_berval(ivals[i]), buf), (uint32_t)IDL_NIDS(idl2)); } #endif if (idl2 == NULL) { diff --git a/ldap/servers/slapd/back-ldbm/idl_new.c b/ldap/servers/slapd/back-ldbm/idl_new.c index 6c4abc2..7d56d19 100644 --- a/ldap/servers/slapd/back-ldbm/idl_new.c +++ b/ldap/servers/slapd/back-ldbm/idl_new.c @@ -83,10 +83,10 @@ idl_new_get_allidslimit(struct attrinfo *a, int allidslimit) } int -idl_new_exceeds_allidslimit(size_t count, struct attrinfo *a, int allidslimit) +idl_new_exceeds_allidslimit(uint64_t count, struct attrinfo *a, int allidslimit) { - size_t limit = idl_new_get_allidslimit(a, allidslimit); - return (limit != (size_t)-1) && (count > limit); + uint64_t limit = idl_new_get_allidslimit(a, allidslimit); + return (limit != (uint64_t)-1) && (count > limit); } @@ -138,7 +138,7 @@ idl_new_fetch( DBT key; DBT data; ID id = 0; - size_t count = 0; + uint64_t count = 0; /* beware that a large buffer on the stack might cause a stack overflow on some platforms */ char buffer[BULK_FETCH_BUFFER_SIZE]; void *ptr; @@ -245,7 +245,7 @@ idl_new_fetch( count++; } - slapi_log_err(SLAPI_LOG_TRACE, "idl_new_fetch", "bulk fetch buffer nids=%lu\n", count); + slapi_log_err(SLAPI_LOG_TRACE, "idl_new_fetch", "bulk fetch buffer nids=%" PRIu64 "\n", count); #if defined(DB_ALLIDS_ON_READ) /* enforce the allids read limit */ if ((NEW_IDL_NO_ALLID != *flag_err) && (NULL != a) && @@ -254,7 +254,7 @@ idl_new_fetch( idl->b_ids[0] = ALLID; ret = DB_NOTFOUND; /* fool the code below into thinking that we finished the dups */ slapi_log_err(SLAPI_LOG_BACKLDBM, "idl_new_fetch", "Search for key for attribute index %s " - "exceeded allidslimit %d - count is %lu\n", + "exceeded allidslimit %d - count is %" PRIu64 "\n", a->ai_type, allidslimit, count); break; } @@ -348,7 +348,7 @@ idl_new_range_fetch( DBT cur_key = {0}; DBT data = {0}; ID id = 0; - size_t count = 0; + uint64_t count = 0; /* beware that a large buffer on the stack might cause a stack overflow on some platforms */ char buffer[BULK_FETCH_BUFFER_SIZE]; void *ptr; @@ -522,7 +522,7 @@ idl_new_range_fetch( } slapi_log_err(SLAPI_LOG_TRACE, "idl_new_range_fetch", - "Bulk fetch buffer nids=%lu\n", count); + "Bulk fetch buffer nids=%" PRIu64 "\n", count); #if defined(DB_ALLIDS_ON_READ) /* enforce the allids read limit */ if ((NEW_IDL_NO_ALLID != *flag_err) && ai && (idl != NULL) && diff --git a/ldap/servers/slapd/back-ldbm/import-threads.c b/ldap/servers/slapd/back-ldbm/import-threads.c index 0419865..1be15a4 100644 --- a/ldap/servers/slapd/back-ldbm/import-threads.c +++ b/ldap/servers/slapd/back-ldbm/import-threads.c @@ -3563,7 +3563,7 @@ dse_conf_backup_core(struct ldbminfo *li, char *dest_dir, char *file_name, char slapi_search_internal_pb(srch_pb); slapi_pblock_get(srch_pb, SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES, &entries); for (ep = entries; ep != NULL && *ep != NULL; ep++) { - size_t l = strlen(slapi_entry_get_dn_const(*ep)) + 5 /* "dn: \n" */; + int32_t l = strlen(slapi_entry_get_dn_const(*ep)) + 5 /* "dn: \n" */; slapi_log_err(SLAPI_LOG_TRACE, "dse_conf_backup_core", "dn: %s\n", slapi_entry_get_dn_const(*ep)); @@ -3573,9 +3573,9 @@ dse_conf_backup_core(struct ldbminfo *li, char *dest_dir, char *file_name, char tp = (char *)slapi_ch_malloc(l); /* should be very rare ... */ sprintf(tp, "dn: %s\n", slapi_entry_get_dn_const(*ep)); prrval = PR_Write(prfd, tp, l); - if ((size_t)prrval != l) { + if (prrval != l) { slapi_log_err(SLAPI_LOG_ERR, "dse_conf_backup_core", - "(%s): write %lu failed: %d (%s)\n", + "(%s): write %" PRId32 " failed: %d (%s)\n", filter, l, PR_GetError(), slapd_pr_strerror(PR_GetError())); rval = -1; if (l > sizeof(tmpbuf)) @@ -3609,9 +3609,9 @@ dse_conf_backup_core(struct ldbminfo *li, char *dest_dir, char *file_name, char tp = (char *)slapi_ch_malloc(l); sprintf(tp, "%s: %s\n", attr_name, attr_val->bv_val); prrval = PR_Write(prfd, tp, l); - if ((size_t)prrval != l) { + if (prrval != l) { slapi_log_err(SLAPI_LOG_ERR, "dse_conf_backup_core", - "(%s): write %lu failed: %d (%s)\n", + "(%s): write %" PRId32 " failed: %d (%s)\n", filter, l, PR_GetError(), slapd_pr_strerror(PR_GetError())); rval = -1; if (l > sizeof(tmpbuf)) @@ -3624,9 +3624,9 @@ dse_conf_backup_core(struct ldbminfo *li, char *dest_dir, char *file_name, char } if (ep + 1 != NULL && *(ep + 1) != NULL) { prrval = PR_Write(prfd, "\n", 1); - if ((int)prrval != 1) { + if (prrval != 1) { slapi_log_err(SLAPI_LOG_ERR, "dse_conf_backup_core", - "(%s): write %lu failed: %d (%s)\n", + "(%s): write %" PRId32 " failed: %d (%s)\n", filter, l, PR_GetError(), slapd_pr_strerror(PR_GetError())); rval = -1; goto out; diff --git a/ldap/servers/slapd/back-ldbm/ldbm_add.c b/ldap/servers/slapd/back-ldbm/ldbm_add.c index 412e1d3..32c8e71 100644 --- a/ldap/servers/slapd/back-ldbm/ldbm_add.c +++ b/ldap/servers/slapd/back-ldbm/ldbm_add.c @@ -857,7 +857,7 @@ ldbm_back_add(Slapi_PBlock *pb) } retval = parent_update_on_childchange(&parent_modify_c, op, NULL); slapi_log_err(SLAPI_LOG_BACKLDBM, "ldbm_back_add", - "conn=%lu op=%d parent_update_on_childchange: old_entry=0x%p, new_entry=0x%p, rc=%d\n", + "conn=%" PRIu64 " op=%d parent_update_on_childchange: old_entry=0x%p, new_entry=0x%p, rc=%d\n", conn_id, op_id, parent_modify_c.old_entry, parent_modify_c.new_entry, retval); /* The modify context now contains info needed later */ if (retval) { @@ -1053,7 +1053,7 @@ ldbm_back_add(Slapi_PBlock *pb) /* Push out the db modifications from the parent entry */ retval = modify_update_all(be, pb, &parent_modify_c, &txn); slapi_log_err(SLAPI_LOG_BACKLDBM, "ldbm_back_add", - "conn=%lu op=%d modify_update_all: old_entry=0x%p, new_entry=0x%p, rc=%d\n", + "conn=%" PRIu64 " op=%d modify_update_all: old_entry=0x%p, new_entry=0x%p, rc=%d\n", conn_id, op_id, parent_modify_c.old_entry, parent_modify_c.new_entry, retval); if (DB_LOCK_DEADLOCK == retval) { slapi_log_err(SLAPI_LOG_ARGS, "ldbm_back_add", "add 6 DEADLOCK\n"); @@ -1177,7 +1177,7 @@ ldbm_back_add(Slapi_PBlock *pb) /* switch the parent entry copy into play */ myrc = modify_switch_entries(&parent_modify_c, be); slapi_log_err(SLAPI_LOG_BACKLDBM, "ldbm_back_add", - "conn=%lu op=%d modify_switch_entries: old_entry=0x%p, new_entry=0x%p, rc=%d\n", + "conn=%" PRIu64 " op=%d modify_switch_entries: old_entry=0x%p, new_entry=0x%p, rc=%d\n", conn_id, op_id, parent_modify_c.old_entry, parent_modify_c.new_entry, myrc); if (0 == myrc) { parent_switched = 1; @@ -1257,7 +1257,7 @@ error_return: */ myrc = modify_unswitch_entries(&parent_modify_c, be); slapi_log_err(SLAPI_LOG_BACKLDBM, "ldbm_back_add", - "conn=%lu op=%d modify_unswitch_entries: old_entry=0x%p, new_entry=0x%p, rc=%d\n", + "conn=%" PRIu64 " op=%d modify_unswitch_entries: old_entry=0x%p, new_entry=0x%p, rc=%d\n", conn_id, op_id, parent_modify_c.old_entry, parent_modify_c.new_entry, myrc); } diskfull_return: @@ -1394,7 +1394,7 @@ common_return: modify_term(&ruv_c, be); } slapi_log_err(SLAPI_LOG_BACKLDBM, "ldbm_back_add", - "conn=%lu op=%d modify_term: old_entry=0x%p, new_entry=0x%p\n", + "conn=%" PRIu64 " op=%d modify_term: old_entry=0x%p, new_entry=0x%p\n", conn_id, op_id, parent_modify_c.old_entry, parent_modify_c.new_entry); myrc = modify_term(&parent_modify_c, be); done_with_pblock_entry(pb, SLAPI_ADD_EXISTING_DN_ENTRY); diff --git a/ldap/servers/slapd/back-ldbm/ldbm_config.c b/ldap/servers/slapd/back-ldbm/ldbm_config.c index feb9933..67a6475 100644 --- a/ldap/servers/slapd/back-ldbm/ldbm_config.c +++ b/ldap/servers/slapd/back-ldbm/ldbm_config.c @@ -413,7 +413,7 @@ ldbm_config_dbcachesize_get(void *arg) { struct ldbminfo *li = (struct ldbminfo *)arg; - return (void *)(li->li_new_dbcachesize); + return (void *)((uintptr_t)li->li_new_dbcachesize); } static int @@ -724,7 +724,7 @@ ldbm_config_db_logbuf_size_get(void *arg) { struct ldbminfo *li = (struct ldbminfo *)arg; - return (void *)li->li_dblayer_private->dblayer_logbuf_size; + return (void *)((uintptr_t)li->li_dblayer_private->dblayer_logbuf_size); } static int @@ -736,7 +736,7 @@ ldbm_config_db_logbuf_size_set(void *arg, { struct ldbminfo *li = (struct ldbminfo *)arg; int retval = LDAP_SUCCESS; - size_t val = (size_t)value; + uint64_t val = (uint64_t)((uintptr_t)value); if (apply) { li->li_dblayer_private->dblayer_logbuf_size = val; @@ -802,7 +802,7 @@ ldbm_config_db_page_size_get(void *arg) { struct ldbminfo *li = (struct ldbminfo *)arg; - return (void *)li->li_dblayer_private->dblayer_page_size; + return (void *)((uintptr_t)li->li_dblayer_private->dblayer_page_size); } static int @@ -814,7 +814,7 @@ ldbm_config_db_page_size_set(void *arg, { struct ldbminfo *li = (struct ldbminfo *)arg; int retval = LDAP_SUCCESS; - size_t val = (size_t)value; + uint32_t val = (uint32_t)((uintptr_t)value); if (apply) { li->li_dblayer_private->dblayer_page_size = val; @@ -828,7 +828,7 @@ ldbm_config_db_index_page_size_get(void *arg) { struct ldbminfo *li = (struct ldbminfo *)arg; - return (void *)li->li_dblayer_private->dblayer_index_page_size; + return (void *)((uintptr_t)li->li_dblayer_private->dblayer_index_page_size); } static int @@ -840,7 +840,7 @@ ldbm_config_db_index_page_size_set(void *arg, { struct ldbminfo *li = (struct ldbminfo *)arg; int retval = LDAP_SUCCESS; - size_t val = (size_t)value; + uint32_t val = (uint32_t)((uintptr_t)value); if (apply) { li->li_dblayer_private->dblayer_index_page_size = val; @@ -913,7 +913,7 @@ ldbm_config_db_logfile_size_get(void *arg) { struct ldbminfo *li = (struct ldbminfo *)arg; - return (void *)li->li_dblayer_private->dblayer_logfile_size; + return (void *)((uintptr_t)li->li_dblayer_private->dblayer_logfile_size); } static int @@ -925,7 +925,7 @@ ldbm_config_db_logfile_size_set(void *arg, { struct ldbminfo *li = (struct ldbminfo *)arg; int retval = LDAP_SUCCESS; - size_t val = (size_t)value; + uint64_t val = (uint64_t)((uintptr_t)value); if (apply) { li->li_dblayer_private->dblayer_logfile_size = val; @@ -1218,12 +1218,12 @@ ldbm_config_db_lock_set(void *arg, void *value, char *errorbuf, int phase, int a { struct ldbminfo *li = (struct ldbminfo *)arg; int retval = LDAP_SUCCESS; - size_t val = (size_t)value; + uint64_t val = (uint64_t)((uintptr_t)value); if (val < BDB_LOCK_NB_MIN) { slapi_create_errormsg(errorbuf, SLAPI_DSE_RETURNTEXT_SIZE, "Error: Invalid value for %s (%d). Must be greater than %d\n", CONFIG_DB_LOCK, val, BDB_LOCK_NB_MIN); - slapi_log_err(SLAPI_LOG_ERR, "ldbm_config_db_lock_set", "Invalid value for %s (%lu)\n", + slapi_log_err(SLAPI_LOG_ERR, "ldbm_config_db_lock_set", "Invalid value for %s (%" PRIu64 ")\n", CONFIG_DB_LOCK, val); return LDAP_UNWILLING_TO_PERFORM; } @@ -1439,7 +1439,7 @@ ldbm_config_import_cachesize_get(void *arg) { struct ldbminfo *li = (struct ldbminfo *)arg; - return (void *)(li->li_import_cachesize); + return (void *)((uintptr_t)li->li_import_cachesize); } static int @@ -1450,8 +1450,8 @@ ldbm_config_import_cachesize_set(void *arg, int apply) { struct ldbminfo *li = (struct ldbminfo *)arg; - size_t val = (size_t)value; - uint64_t delta = (size_t)value; + uint64_t val = (uint64_t)((uintptr_t)value); + uint64_t delta; /* There is an error here. We check the new val against our current mem-alloc * Issue is that we already are using system pages, so while our value *might* * be valid, we may reject it here due to the current procs page usage. @@ -1819,7 +1819,7 @@ static config_info ldbm_config[] = { {CONFIG_MODE, CONFIG_TYPE_INT_OCTAL, "0600", &ldbm_config_mode_get, &ldbm_config_mode_set, CONFIG_FLAG_ALWAYS_SHOW | CONFIG_FLAG_ALLOW_RUNNING_CHANGE}, {CONFIG_IDLISTSCANLIMIT, CONFIG_TYPE_INT, "4000", &ldbm_config_allidsthreshold_get, &ldbm_config_allidsthreshold_set, CONFIG_FLAG_ALWAYS_SHOW | CONFIG_FLAG_ALLOW_RUNNING_CHANGE}, {CONFIG_DIRECTORY, CONFIG_TYPE_STRING, "", &ldbm_config_directory_get, &ldbm_config_directory_set, CONFIG_FLAG_ALWAYS_SHOW | CONFIG_FLAG_ALLOW_RUNNING_CHANGE | CONFIG_FLAG_SKIP_DEFAULT_SETTING}, - {CONFIG_DBCACHESIZE, CONFIG_TYPE_SIZE_T, DEFAULT_CACHE_SIZE_STR, &ldbm_config_dbcachesize_get, &ldbm_config_dbcachesize_set, CONFIG_FLAG_ALWAYS_SHOW | CONFIG_FLAG_ALLOW_RUNNING_CHANGE}, + {CONFIG_DBCACHESIZE, CONFIG_TYPE_UINT64, DEFAULT_CACHE_SIZE_STR, &ldbm_config_dbcachesize_get, &ldbm_config_dbcachesize_set, CONFIG_FLAG_ALWAYS_SHOW | CONFIG_FLAG_ALLOW_RUNNING_CHANGE}, {CONFIG_DBNCACHE, CONFIG_TYPE_INT, "0", &ldbm_config_dbncache_get, &ldbm_config_dbncache_set, CONFIG_FLAG_ALLOW_RUNNING_CHANGE}, {CONFIG_MAXPASSBEFOREMERGE, CONFIG_TYPE_INT, "100", &ldbm_config_maxpassbeforemerge_get, &ldbm_config_maxpassbeforemerge_set, 0}, @@ -1839,7 +1839,7 @@ static config_info ldbm_config[] = { {CONFIG_DB_INDEX_PAGE_SIZE, CONFIG_TYPE_SIZE_T, "0", &ldbm_config_db_index_page_size_get, &ldbm_config_db_index_page_size_set, 0}, {CONFIG_DB_IDL_DIVISOR, CONFIG_TYPE_INT, "0", &ldbm_config_db_idl_divisor_get, &ldbm_config_db_idl_divisor_set, 0}, {CONFIG_DB_OLD_IDL_MAXIDS, CONFIG_TYPE_INT, "0", &ldbm_config_db_old_idl_maxids_get, &ldbm_config_db_old_idl_maxids_set, 0}, - {CONFIG_DB_LOGFILE_SIZE, CONFIG_TYPE_SIZE_T, "0", &ldbm_config_db_logfile_size_get, &ldbm_config_db_logfile_size_set, 0}, + {CONFIG_DB_LOGFILE_SIZE, CONFIG_TYPE_UINT64, "0", &ldbm_config_db_logfile_size_get, &ldbm_config_db_logfile_size_set, 0}, {CONFIG_DB_TRICKLE_PERCENTAGE, CONFIG_TYPE_INT, "5", &ldbm_config_db_trickle_percentage_get, &ldbm_config_db_trickle_percentage_set, 0}, {CONFIG_DB_SPIN_COUNT, CONFIG_TYPE_INT, "0", &ldbm_config_db_spin_count_get, &ldbm_config_db_spin_count_set, 0}, {CONFIG_DB_VERBOSE, CONFIG_TYPE_ONOFF, "off", &ldbm_config_db_verbose_get, &ldbm_config_db_verbose_set, 0}, @@ -1856,7 +1856,7 @@ static config_info ldbm_config[] = { {CONFIG_IMPORT_CACHE_AUTOSIZE, CONFIG_TYPE_INT, "-1", &ldbm_config_import_cache_autosize_get, &ldbm_config_import_cache_autosize_set, CONFIG_FLAG_ALWAYS_SHOW | CONFIG_FLAG_ALLOW_RUNNING_CHANGE}, {CONFIG_CACHE_AUTOSIZE, CONFIG_TYPE_INT, "10", &ldbm_config_cache_autosize_get, &ldbm_config_cache_autosize_set, CONFIG_FLAG_ALWAYS_SHOW | CONFIG_FLAG_ALLOW_RUNNING_CHANGE}, {CONFIG_CACHE_AUTOSIZE_SPLIT, CONFIG_TYPE_INT, "25", &ldbm_config_cache_autosize_split_get, &ldbm_config_cache_autosize_split_set, CONFIG_FLAG_ALWAYS_SHOW | CONFIG_FLAG_ALLOW_RUNNING_CHANGE}, - {CONFIG_IMPORT_CACHESIZE, CONFIG_TYPE_SIZE_T, "16777216", &ldbm_config_import_cachesize_get, &ldbm_config_import_cachesize_set, CONFIG_FLAG_ALWAYS_SHOW | CONFIG_FLAG_ALLOW_RUNNING_CHANGE}, + {CONFIG_IMPORT_CACHESIZE, CONFIG_TYPE_UINT64, "16777216", &ldbm_config_import_cachesize_get, &ldbm_config_import_cachesize_set, CONFIG_FLAG_ALWAYS_SHOW | CONFIG_FLAG_ALLOW_RUNNING_CHANGE}, {CONFIG_IDL_SWITCH, CONFIG_TYPE_STRING, "new", &ldbm_config_idl_get_idl_new, &ldbm_config_idl_set_tune, CONFIG_FLAG_ALWAYS_SHOW}, {CONFIG_IDL_UPDATE, CONFIG_TYPE_ONOFF, "on", &ldbm_config_idl_get_update, &ldbm_config_idl_set_update, 0}, {CONFIG_BYPASS_FILTER_TEST, CONFIG_TYPE_STRING, "on", &ldbm_config_get_bypass_filter_test, &ldbm_config_set_bypass_filter_test, CONFIG_FLAG_ALWAYS_SHOW | CONFIG_FLAG_ALLOW_RUNNING_CHANGE}, @@ -2118,7 +2118,11 @@ ldbm_config_get(void *arg, config_info *config, char *buf) break; case CONFIG_TYPE_SIZE_T: val = (size_t)config->config_get_fn(arg); - sprintf(buf, "%lu", (long unsigned int)val); + sprintf(buf, "%" PRIu32, (uint32_t)val); + break; + case CONFIG_TYPE_UINT64: + val = (uint64_t)((uintptr_t)config->config_get_fn(arg)); + sprintf(buf, "%" PRIu64, (uint64_t)val); break; case CONFIG_TYPE_STRING: /* Remember the get function for strings returns memory @@ -2371,6 +2375,34 @@ ldbm_config_set(void *arg, char *attr_name, config_info *config_array, struct be } retval = config->config_set_fn(arg, (void *)sz_val, err_buf, phase, apply_mod); break; + + + case CONFIG_TYPE_UINT64: + if (use_default) { + str_val = config->config_default_value; + } else { + str_val = bval->bv_val; + } + /* get the value as a size_t value */ + sz_val = db_strtoull(str_val, &err); + + /* check for parsing error (e.g. not a number) */ + if (err == EINVAL) { + slapi_create_errormsg(err_buf, SLAPI_DSE_RETURNTEXT_SIZE, "Error: value %s for attr %s is not a number\n", + str_val, attr_name); + slapi_log_err(SLAPI_LOG_ERR, "ldbm_config_set", "Value %s for attr %s is not a number\n", + str_val, attr_name); + return LDAP_UNWILLING_TO_PERFORM; + /* check for overflow */ + } else if (err == ERANGE) { + slapi_create_errormsg(err_buf, SLAPI_DSE_RETURNTEXT_SIZE, "Error: value %s for attr %s is outside the range of representable values\n", + str_val, attr_name); + slapi_log_err(SLAPI_LOG_ERR, "ldbm_config_set", "Value %s for attr %s is outside the range of representable values\n", + str_val, attr_name); + return LDAP_UNWILLING_TO_PERFORM; + } + retval = config->config_set_fn(arg, (void *)sz_val, err_buf, phase, apply_mod); + break; case CONFIG_TYPE_STRING: if (use_default) { retval = config->config_set_fn(arg, config->config_default_value, err_buf, phase, apply_mod); diff --git a/ldap/servers/slapd/back-ldbm/ldbm_config.h b/ldap/servers/slapd/back-ldbm/ldbm_config.h index c0f5d31..29fb7a7 100644 --- a/ldap/servers/slapd/back-ldbm/ldbm_config.h +++ b/ldap/servers/slapd/back-ldbm/ldbm_config.h @@ -18,19 +18,17 @@ struct config_info; typedef struct config_info config_info; typedef int config_set_fn_t(void *arg, void *value, char *errorbuf, int phase, int apply); -typedef void *config_get_fn_t(void *arg); -/* The value for these is passed around as a - * void *, the actual value should be gotten - * by casting the void * as shown below. */ +typedef void *config_get_fn_t(void *arg); /* The value for these is passed around as a + * void *, the actual value should be gotten + * by casting the void * as shown below. */ #define CONFIG_TYPE_ONOFF 1 /* val = (int) value */ -#define CONFIG_TYPE_STRING 2 /* val = (char *) value - The get functions \ - * for this type must return alloced memory \ - * that should be freed by the caller. */ +#define CONFIG_TYPE_STRING 2 /* val = (char *) value - The get functions for this type + * must return alloced memory that should be freed by the caller. */ #define CONFIG_TYPE_INT 3 /* val = (int) value */ #define CONFIG_TYPE_LONG 4 /* val = (long) value */ -#define CONFIG_TYPE_INT_OCTAL 5 /* Same as CONFIG_TYPE_INT, but shown in \ - * octal */ +#define CONFIG_TYPE_INT_OCTAL 5 /* Same as CONFIG_TYPE_INT, but shown in octal */ #define CONFIG_TYPE_SIZE_T 6 /* val = (size_t) value */ +#define CONFIG_TYPE_UINT64 7 /* val = (uint64_t) value */ /* How changes to some config attributes are handled depends on what * "phase" the server is in. Initialization, reading the config diff --git a/ldap/servers/slapd/back-ldbm/ldbm_delete.c b/ldap/servers/slapd/back-ldbm/ldbm_delete.c index bc0a365..3a27fd0 100644 --- a/ldap/servers/slapd/back-ldbm/ldbm_delete.c +++ b/ldap/servers/slapd/back-ldbm/ldbm_delete.c @@ -211,7 +211,7 @@ ldbm_back_delete(Slapi_PBlock *pb) CACHE_RETURN(&inst->inst_cache, &tombstone); if (tombstone) { slapi_log_err(SLAPI_LOG_ERR, "ldbm_back_delete", - "conn=%lu op=%d [retry: %d] tombstone %s is not freed!!! refcnt %d, state %d\n", + "conn=%" PRIu64 " op=%d [retry: %d] tombstone %s is not freed!!! refcnt %d, state %d\n", conn_id, op_id, retry_count, slapi_entry_get_dn(tombstone->ep_entry), tombstone->ep_refcnt, tombstone->ep_state); } @@ -220,7 +220,7 @@ ldbm_back_delete(Slapi_PBlock *pb) tmptombstone = NULL; } else { slapi_log_err(SLAPI_LOG_ERR, "ldbm_back_delete", - "conn=%lu op=%d [retry: %d] No original_tombstone for %s!!\n", + "conn=%" PRIu64 " op=%d [retry: %d] No original_tombstone for %s!!\n", conn_id, op_id, retry_count, slapi_entry_get_dn(e->ep_entry)); } } @@ -294,11 +294,11 @@ replace_entry: if (slapi_entry_has_conflict_children(e->ep_entry, (void *)li->li_identity) > 0) { ldap_result_message = "Entry has replication conflicts as children"; slapi_log_err(SLAPI_LOG_ERR, "ldbm_back_delete", - "conn=%lu op=%d Deleting entry %s has replication conflicts as children.\n", + "conn=%" PRIu64 " op=%d Deleting entry %s has replication conflicts as children.\n", conn_id, op_id, slapi_entry_get_dn(e->ep_entry)); } else { slapi_log_err(SLAPI_LOG_BACKLDBM, "ldbm_back_delete", - "conn=%lu op=%d Deleting entry %s has %d children.\n", + "conn=%" PRIu64 " op=%d Deleting entry %s has %d children.\n", conn_id, op_id, slapi_entry_get_dn(e->ep_entry), retval); } retval = -1; @@ -566,7 +566,7 @@ replace_entry: /* The modify context now contains info needed later */ if (0 != retval) { slapi_log_err(SLAPI_LOG_ERR, "ldbm_back_delete", - "conn=%lu op=%d parent_update_on_childchange: old_entry=0x%p, new_entry=0x%p, rc=%d\n", + "conn=%" PRIu64 " op=%d parent_update_on_childchange: old_entry=0x%p, new_entry=0x%p, rc=%d\n", conn_id, op_id, parent_modify_c.old_entry, parent_modify_c.new_entry, retval); ldap_result_code = LDAP_OPERATIONS_ERROR; slapi_sdn_done(&parentsdn); @@ -604,7 +604,7 @@ replace_entry: if (slapi_entry_attr_hasvalue(e->ep_entry, SLAPI_ATTR_OBJECTCLASS, SLAPI_ATTR_VALUE_TOMBSTONE) && slapi_is_special_rdn(edn, RDN_IS_TOMBSTONE)) { slapi_log_err(SLAPI_LOG_ERR, "ldbm_back_delete", - "conn=%lu op=%d Turning a tombstone into a tombstone! \"%s\"; e: 0x%p, cache_state: 0x%x, refcnt: %d\n", + "conn=%" PRIu64 " op=%d Turning a tombstone into a tombstone! \"%s\"; e: 0x%p, cache_state: 0x%x, refcnt: %d\n", conn_id, op_id, edn, e, e->ep_state, e->ep_refcnt); ldap_result_code = LDAP_OPERATIONS_ERROR; retval = -1; @@ -612,7 +612,7 @@ replace_entry: } if (!childuniqueid) { slapi_log_err(SLAPI_LOG_ERR, "ldbm_back_delete", - "conn=%lu op=%d No nsUniqueId in the entry \"%s\"; e: 0x%p, cache_state: 0x%x, refcnt: %d\n", + "conn=%" PRIu64 " op=%d No nsUniqueId in the entry \"%s\"; e: 0x%p, cache_state: 0x%x, refcnt: %d\n", conn_id, op_id, edn, e, e->ep_state, e->ep_refcnt); ldap_result_code = LDAP_OPERATIONS_ERROR; retval = -1; @@ -743,7 +743,7 @@ replace_entry: retval = cache_add_tentative(&inst->inst_cache, tombstone, NULL); if (0 > retval) { slapi_log_err(SLAPI_LOG_CACHE, "ldbm_back_delete", - "conn=%lu op=%d tombstone entry %s failed to add to the cache: %d\n", + "conn=%" PRIu64 " op=%d tombstone entry %s failed to add to the cache: %d\n", conn_id, op_id, slapi_entry_get_dn(tombstone->ep_entry), retval); if (LDBM_OS_ERR_IS_DISKFULL(retval)) disk_full = 1; @@ -844,7 +844,7 @@ replace_entry: } if (0 != retval) { slapi_log_err(SLAPI_LOG_ERR, - "ldbm_back_delete", "delete tombsone csn(adding %s) failed, err=%d %s\n", + "ldbm_back_delete", "delete tombstone csn(adding %s) failed, err=%d %s\n", deletion_csn_str, retval, (msg = dblayer_strerror(retval)) ? msg : ""); @@ -1148,7 +1148,7 @@ replace_entry: /* Push out the db modifications from the parent entry */ retval = modify_update_all(be, pb, &parent_modify_c, &txn); slapi_log_err(SLAPI_LOG_BACKLDBM, "ldbm_back_delete", - "conn=%lu op=%d modify_update_all: old_entry=0x%p, new_entry=0x%p, rc=%d\n", + "conn=%" PRIu64 " op=%d modify_update_all: old_entry=0x%p, new_entry=0x%p, rc=%d\n", conn_id, op_id, parent_modify_c.old_entry, parent_modify_c.new_entry, retval); if (DB_LOCK_DEADLOCK == retval) { slapi_log_err(SLAPI_LOG_BACKLDBM, "ldbm_back_delete", "4 DEADLOCK\n"); @@ -1276,7 +1276,7 @@ replace_entry: /* Replace the old parent entry with the newly modified one */ myrc = modify_switch_entries(&parent_modify_c, be); slapi_log_err(SLAPI_LOG_BACKLDBM, "ldbm_back_delete", - "conn=%lu op=%d modify_switch_entries: old_entry=0x%p, new_entry=0x%p, rc=%d\n", + "conn=%" PRIu64 " op=%d modify_switch_entries: old_entry=0x%p, new_entry=0x%p, rc=%d\n", conn_id, op_id, parent_modify_c.old_entry, parent_modify_c.new_entry, myrc); if (myrc == 0) { parent_switched = 1; @@ -1435,7 +1435,7 @@ error_return: */ myrc = modify_unswitch_entries(&parent_modify_c, be); slapi_log_err(SLAPI_LOG_BACKLDBM, "ldbm_back_delete", - "conn=%lu op=%d modify_unswitch_entries: old_entry=0x%p, new_entry=0x%p, rc=%d\n", + "conn=%" PRIu64 " op=%d modify_unswitch_entries: old_entry=0x%p, new_entry=0x%p, rc=%d\n", conn_id, op_id, parent_modify_c.old_entry, parent_modify_c.new_entry, myrc); } @@ -1514,7 +1514,7 @@ diskfull_return: } } slapi_log_err(SLAPI_LOG_BACKLDBM, "ldbm_back_delete", - "conn=%lu op=%d modify_term: old_entry=0x%p, new_entry=0x%p, in_cache=%d\n", + "conn=%" PRIu64 " op=%d modify_term: old_entry=0x%p, new_entry=0x%p, in_cache=%d\n", conn_id, op_id, parent_modify_c.old_entry, parent_modify_c.new_entry, cache_is_in_cache(&inst->inst_cache, parent_modify_c.new_entry)); myrc = modify_term(&parent_modify_c, be); diff --git a/ldap/servers/slapd/back-ldbm/ldbm_instance_config.c b/ldap/servers/slapd/back-ldbm/ldbm_instance_config.c index eb26038..6f4f4e2 100644 --- a/ldap/servers/slapd/back-ldbm/ldbm_instance_config.c +++ b/ldap/servers/slapd/back-ldbm/ldbm_instance_config.c @@ -110,7 +110,7 @@ ldbm_instance_config_cachememsize_set(void *arg, { ldbm_instance *inst = (ldbm_instance *)arg; int retval = LDAP_SUCCESS; - size_t val = (size_t)value; + uint64_t val = (uint64_t)((uintptr_t)value); uint64_t delta = 0; uint64_t delta_original = 0; @@ -194,7 +194,7 @@ ldbm_instance_config_dncachememsize_set(void *arg, { ldbm_instance *inst = (ldbm_instance *)arg; int retval = LDAP_SUCCESS; - size_t val = (size_t)value; + uint64_t val = (uint64_t)((uintptr_t)value); uint64_t delta = 0; /* Do whatever we can to make sure the data is ok. */ @@ -366,11 +366,11 @@ ldbm_instance_config_require_index_set(void *arg, *----------------------------------------------------------------------*/ static config_info ldbm_instance_config[] = { {CONFIG_INSTANCE_CACHESIZE, CONFIG_TYPE_LONG, "-1", &ldbm_instance_config_cachesize_get, &ldbm_instance_config_cachesize_set, CONFIG_FLAG_ALWAYS_SHOW | CONFIG_FLAG_ALLOW_RUNNING_CHANGE}, - {CONFIG_INSTANCE_CACHEMEMSIZE, CONFIG_TYPE_SIZE_T, DEFAULT_CACHE_SIZE_STR, &ldbm_instance_config_cachememsize_get, &ldbm_instance_config_cachememsize_set, CONFIG_FLAG_ALWAYS_SHOW | CONFIG_FLAG_ALLOW_RUNNING_CHANGE}, + {CONFIG_INSTANCE_CACHEMEMSIZE, CONFIG_TYPE_LONG, DEFAULT_CACHE_SIZE_STR, &ldbm_instance_config_cachememsize_get, &ldbm_instance_config_cachememsize_set, CONFIG_FLAG_ALWAYS_SHOW | CONFIG_FLAG_ALLOW_RUNNING_CHANGE}, {CONFIG_INSTANCE_READONLY, CONFIG_TYPE_ONOFF, "off", &ldbm_instance_config_readonly_get, &ldbm_instance_config_readonly_set, CONFIG_FLAG_ALWAYS_SHOW | CONFIG_FLAG_ALLOW_RUNNING_CHANGE}, {CONFIG_INSTANCE_REQUIRE_INDEX, CONFIG_TYPE_ONOFF, "off", &ldbm_instance_config_require_index_get, &ldbm_instance_config_require_index_set, CONFIG_FLAG_ALWAYS_SHOW | CONFIG_FLAG_ALLOW_RUNNING_CHANGE}, {CONFIG_INSTANCE_DIR, CONFIG_TYPE_STRING, NULL, &ldbm_instance_config_instance_dir_get, &ldbm_instance_config_instance_dir_set, CONFIG_FLAG_ALWAYS_SHOW}, - {CONFIG_INSTANCE_DNCACHEMEMSIZE, CONFIG_TYPE_SIZE_T, DEFAULT_DNCACHE_SIZE_STR, &ldbm_instance_config_dncachememsize_get, &ldbm_instance_config_dncachememsize_set, CONFIG_FLAG_ALWAYS_SHOW | CONFIG_FLAG_ALLOW_RUNNING_CHANGE}, + {CONFIG_INSTANCE_DNCACHEMEMSIZE, CONFIG_TYPE_LONG, DEFAULT_DNCACHE_SIZE_STR, &ldbm_instance_config_dncachememsize_get, &ldbm_instance_config_dncachememsize_set, CONFIG_FLAG_ALWAYS_SHOW | CONFIG_FLAG_ALLOW_RUNNING_CHANGE}, {NULL, 0, NULL, NULL, NULL, 0}}; void diff --git a/ldap/servers/slapd/back-ldbm/ldbm_modrdn.c b/ldap/servers/slapd/back-ldbm/ldbm_modrdn.c index 5b4ea05..71e2a8f 100644 --- a/ldap/servers/slapd/back-ldbm/ldbm_modrdn.c +++ b/ldap/servers/slapd/back-ldbm/ldbm_modrdn.c @@ -713,7 +713,7 @@ ldbm_back_modrdn(Slapi_PBlock *pb) ldap_result_code = LDAP_ALREADY_EXISTS; if (is_resurect_operation) { slapi_log_err(SLAPI_LOG_CACHE, "ldbm_back_modrdn", - "conn=%lu op=%d cache_add_tentative failed: %s\n", + "conn=%" PRIu64 " op=%d cache_add_tentative failed: %s\n", conn_id, op_id, slapi_entry_get_dn(ec->ep_entry)); } goto error_return; @@ -845,7 +845,7 @@ ldbm_back_modrdn(Slapi_PBlock *pb) retval = parent_update_on_childchange(&parent_modify_context, PARENTUPDATE_DEL, NULL); slapi_log_err(SLAPI_LOG_BACKLDBM, "ldbm_back_modrdn", - "conn=%lu op=%d parent_update_on_childchange: old_entry=0x%p, new_entry=0x%p, rc=%d\n", + "conn=%" PRIu64 " op=%d parent_update_on_childchange: old_entry=0x%p, new_entry=0x%p, rc=%d\n", conn_id, op_id, parent_modify_context.old_entry, parent_modify_context.new_entry, retval); /* The parent modify context now contains info needed later */ @@ -857,7 +857,7 @@ ldbm_back_modrdn(Slapi_PBlock *pb) retval = parent_update_on_childchange(&newparent_modify_context, PARENTUPDATE_ADD, NULL); slapi_log_err(SLAPI_LOG_BACKLDBM, "ldbm_back_modrdn", - "conn=%lu op=%d parent_update_on_childchange: old_entry=0x%p, new_entry=0x%p, rc=%d\n", + "conn=%" PRIu64 " op=%d parent_update_on_childchange: old_entry=0x%p, new_entry=0x%p, rc=%d\n", conn_id, op_id, parent_modify_context.old_entry, parent_modify_context.new_entry, retval); /* The newparent modify context now contains info needed later */ if (retval) { @@ -870,7 +870,7 @@ ldbm_back_modrdn(Slapi_PBlock *pb) retval = parent_update_on_childchange(&parent_modify_context, PARENTUPDATE_RESURECT, NULL); if (retval) { slapi_log_err(SLAPI_LOG_BACKLDBM, "ldbm_back_modrdn", - "conn=%lu op=%d parent_update_on_childchange parent %s of %s failed, rc=%d\n", + "conn=%" PRIu64 " op=%d parent_update_on_childchange parent %s of %s failed, rc=%d\n", conn_id, op_id, slapi_entry_get_dn_const(parent_modify_context.old_entry->ep_entry), slapi_entry_get_dn_const(ec->ep_entry), retval); @@ -1053,7 +1053,7 @@ ldbm_back_modrdn(Slapi_PBlock *pb) { retval = modify_update_all(be, pb, &newparent_modify_context, &txn); slapi_log_err(SLAPI_LOG_BACKLDBM, "ldbm_back_modrdn", - "conn=%lu op=%d modify_update_all: old_entry=0x%p, new_entry=0x%p, rc=%d\n", + "conn=%" PRIu64 " op=%d modify_update_all: old_entry=0x%p, new_entry=0x%p, rc=%d\n", conn_id, op_id, parent_modify_context.old_entry, parent_modify_context.new_entry, retval); if (DB_LOCK_DEADLOCK == retval) { /* Retry txn */ @@ -1178,7 +1178,7 @@ ldbm_back_modrdn(Slapi_PBlock *pb) if (newparententry != NULL) { myrc = modify_switch_entries(&newparent_modify_context, be); slapi_log_err(SLAPI_LOG_BACKLDBM, "ldbm_back_modrdn", - "conn=%lu op=%d modify_switch_entries: old_entry=0x%p, new_entry=0x%p, rc=%d\n", + "conn=%" PRIu64 " op=%d modify_switch_entries: old_entry=0x%p, new_entry=0x%p, rc=%d\n", conn_id, op_id, parent_modify_context.old_entry, parent_modify_context.new_entry, myrc); } @@ -1455,13 +1455,13 @@ common_return: slapi_sdn_done(&dn_newrdn); slapi_sdn_done(&dn_parentdn); slapi_log_err(SLAPI_LOG_BACKLDBM, "ldbm_back_modrdn", - "conn=%lu op=%d modify_term: old_entry=0x%p, new_entry=0x%p\n", + "conn=%" PRIu64 " op=%d modify_term: old_entry=0x%p, new_entry=0x%p\n", conn_id, op_id, parent_modify_context.old_entry, parent_modify_context.new_entry); myrc = modify_term(&parent_modify_context, be); slapi_log_err(SLAPI_LOG_BACKLDBM, "ldbm_back_modrdn", - "conn=%lu op=%d modify_term: rc=%d\n", conn_id, op_id, myrc); + "conn=%" PRIu64 " op=%d modify_term: rc=%d\n", conn_id, op_id, myrc); slapi_log_err(SLAPI_LOG_BACKLDBM, "ldbm_back_modrdn", - "conn=%lu op=%d modify_term: old_entry=0x%p, new_entry=0x%p\n", + "conn=%" PRIu64 " op=%d modify_term: old_entry=0x%p, new_entry=0x%p\n", conn_id, op_id, newparent_modify_context.old_entry, newparent_modify_context.new_entry); myrc = modify_term(&newparent_modify_context, be); if (free_modrdn_existing_entry) { diff --git a/ldap/servers/slapd/back-ldbm/monitor.c b/ldap/servers/slapd/back-ldbm/monitor.c index f912dca..06f2b27 100644 --- a/ldap/servers/slapd/back-ldbm/monitor.c +++ b/ldap/servers/slapd/back-ldbm/monitor.c @@ -47,10 +47,9 @@ ldbm_back_monitor_instance_search(Slapi_PBlock *pb __attribute__((unused)), struct berval val; struct berval *vals[2]; char buf[BUFSIZ]; - PRUint64 hits, tries; - int64_t nentries; - int64_t maxentries; - size_t size, maxsize; + uint64_t hits, tries; + uint64_t nentries, maxentries; + uint64_t size, maxsize; /* NPCTE fix for bugid 544365, esc 0. <04-Jul-2001> */ struct stat astat; /* end of NPCTE fix for bugid 544365 */ @@ -89,19 +88,19 @@ ldbm_back_monitor_instance_search(Slapi_PBlock *pb __attribute__((unused)), /* fetch cache statistics */ cache_get_stats(&(inst->inst_cache), &hits, &tries, &nentries, &maxentries, &size, &maxsize); - sprintf(buf, "%lu", (long unsigned int)hits); + sprintf(buf, "%" PRIu64, hits); MSET("entryCacheHits"); - sprintf(buf, "%lu", (long unsigned int)tries); + sprintf(buf, "%" PRIu64, tries); MSET("entryCacheTries"); - sprintf(buf, "%lu", (long unsigned int)(100.0 * (double)hits / (double)(tries > 0 ? tries : 1))); + sprintf(buf, "%" PRIu64, (uint64_t)(100.0 * (double)hits / (double)(tries > 0 ? tries : 1))); MSET("entryCacheHitRatio"); - sprintf(buf, "%lu", (long unsigned int)size); + sprintf(buf, "%" PRIu64, size); MSET("currentEntryCacheSize"); - sprintf(buf, "%lu", (long unsigned int)maxsize); + sprintf(buf, "%" PRIu64, maxsize); MSET("maxEntryCacheSize"); - sprintf(buf, "%" PRId64, nentries); + sprintf(buf, "%" PRIu64, nentries); MSET("currentEntryCacheCount"); - sprintf(buf, "%" PRId64, maxentries); + sprintf(buf, "%" PRIu64, maxentries); MSET("maxEntryCacheCount"); if (entryrdn_get_switch()) { @@ -112,15 +111,15 @@ ldbm_back_monitor_instance_search(Slapi_PBlock *pb __attribute__((unused)), MSET("dnCacheHits"); sprintf(buf, "%" PRIu64, tries); MSET("dnCacheTries"); - sprintf(buf, "%lu", (unsigned long)(100.0 * (double)hits / (double)(tries > 0 ? tries : 1))); + sprintf(buf, "%" PRIu64, (uint64_t)(100.0 * (double)hits / (double)(tries > 0 ? tries : 1))); MSET("dnCacheHitRatio"); - sprintf(buf, "%lu", (long unsigned int)size); + sprintf(buf, "%" PRIu64, size); MSET("currentDnCacheSize"); - sprintf(buf, "%lu", (long unsigned int)maxsize); + sprintf(buf, "%" PRIu64, maxsize); MSET("maxDnCacheSize"); - sprintf(buf, "%" PRId64, nentries); + sprintf(buf, "%" PRIu64, nentries); MSET("currentDnCacheCount"); - sprintf(buf, "%" PRId64, maxentries); + sprintf(buf, "%" PRIu64, maxentries); MSET("maxDnCacheCount"); } @@ -204,8 +203,8 @@ ldbm_back_monitor_search(Slapi_PBlock *pb, Slapi_Entry *e, Slapi_Entry *entryAft char buf[BUFSIZ]; DB_MPOOL_STAT *mpstat = NULL; DB_MPOOL_FSTAT **mpfstat = NULL; - uintmax_t cache_tries; - int64_t count; + uint64_t cache_tries; + uint64_t count; uint64_t hits; uint64_t tries; uint64_t size; @@ -233,7 +232,7 @@ ldbm_back_monitor_search(Slapi_PBlock *pb, Slapi_Entry *e, Slapi_Entry *entryAft /* cache tries*/ cache_tries = (mpstat->st_cache_miss + mpstat->st_cache_hit); - sprintf(buf, "%lu", cache_tries); + sprintf(buf, "%" PRIu64, cache_tries); MSET("dbCacheTries"); /* cache hit ratio*/ @@ -274,7 +273,7 @@ ldbm_back_monitor_search(Slapi_PBlock *pb, Slapi_Entry *e, Slapi_Entry *entryAft MSET("NormalizedDnCacheThreadSize"); sprintf(buf, "%" PRIu64, slots); MSET("NormalizedDnCacheThreadSlots"); - sprintf(buf, "%" PRId64, count); + sprintf(buf, "%" PRIu64, count); MSET("currentNormalizedDnCacheCount"); } diff --git a/ldap/servers/slapd/back-ldbm/proto-back-ldbm.h b/ldap/servers/slapd/back-ldbm/proto-back-ldbm.h index 3327faa..2898a35 100644 --- a/ldap/servers/slapd/back-ldbm/proto-back-ldbm.h +++ b/ldap/servers/slapd/back-ldbm/proto-back-ldbm.h @@ -32,14 +32,14 @@ void attr_create_empty(backend *be, char *type, struct attrinfo **ai); /* * cache.c */ -int cache_init(struct cache *cache, size_t maxsize, long maxentries, int type); +int cache_init(struct cache *cache, uint64_t maxsize, uint64_t maxentries, int type); void cache_clear(struct cache *cache, int type); void cache_destroy_please(struct cache *cache, int type); -void cache_set_max_size(struct cache *cache, size_t bytes, int type); +void cache_set_max_size(struct cache *cache, uint64_t bytes, int type); void cache_set_max_entries(struct cache *cache, long entries); size_t cache_get_max_size(struct cache *cache); long cache_get_max_entries(struct cache *cache); -void cache_get_stats(struct cache *cache, PRUint64 *hits, PRUint64 *tries, long *entries, long *maxentries, size_t *size, size_t *maxsize); +void cache_get_stats(struct cache *cache, uint64_t *hits, uint64_t *tries, uint64_t *entries, uint64_t *maxentries, uint64_t *size, uint64_t *maxsize); void cache_debug_hash(struct cache *cache, char **out); int cache_remove(struct cache *cache, void *e); void cache_return(struct cache *cache, void **bep); @@ -61,9 +61,9 @@ void check_entry_cache(struct cache *cache, struct backentry *e); #endif Hashtable *new_hash(u_long size, u_long offset, HashFn hfn, HashTestFn tfn); -int add_hash(Hashtable *ht, void *key, size_t keylen, void *entry, void **alt); -int find_hash(Hashtable *ht, const void *key, size_t keylen, void **entry); -int remove_hash(Hashtable *ht, const void *key, size_t keylen); +int add_hash(Hashtable *ht, void *key, uint32_t keylen, void *entry, void **alt); +int find_hash(Hashtable *ht, const void *key, uint32_t keylen, void **entry); +int remove_hash(Hashtable *ht, const void *key, uint32_t keylen); struct backdn *dncache_find_id(struct cache *cache, ID id); @@ -99,7 +99,7 @@ int dblayer_read_txn_commit(backend *be, back_txn *txn); int dblayer_txn_begin_all(struct ldbminfo *li, back_txnid parent_txn, back_txn *txn); int dblayer_txn_commit_all(struct ldbminfo *li, back_txn *txn); int dblayer_txn_abort_all(struct ldbminfo *li, back_txn *txn); -size_t dblayer_get_optimal_block_size(struct ldbminfo *li); +uint32_t dblayer_get_optimal_block_size(struct ldbminfo *li); void dblayer_unlock_backend(backend *be); void dblayer_lock_backend(backend *be); int dblayer_plugin_begin(Slapi_PBlock *pb); @@ -126,7 +126,8 @@ int dblayer_get_instance_data_dir(backend *be); char *dblayer_strerror(int error); PRInt64 db_atol(char *str, int *err); PRInt64 db_atoi(char *str, int *err); -unsigned long db_strtoul(const char *str, int *err); +uint32_t db_strtoul(const char *str, int *err); +uint64_t db_strtoull(const char *str, int *err); int dblayer_set_batch_transactions(void *arg, void *value, char *errorbuf, int phase, int apply); int dblayer_set_batch_txn_min_sleep(void *arg, void *value, char *errorbuf, int phase, int apply); int dblayer_set_batch_txn_max_sleep(void *arg, void *value, char *errorbuf, int phase, int apply); diff --git a/ldap/servers/slapd/back-ldbm/start.c b/ldap/servers/slapd/back-ldbm/start.c index 45ed091..7d0cd22 100644 --- a/ldap/servers/slapd/back-ldbm/start.c +++ b/ldap/servers/slapd/back-ldbm/start.c @@ -177,8 +177,8 @@ ldbm_back_start_autotune(struct ldbminfo *li) } } - slapi_log_err(SLAPI_LOG_NOTICE, "ldbm_back_start", "found %luk physical memory\n", mi->system_total_bytes / 1024); - slapi_log_err(SLAPI_LOG_NOTICE, "ldbm_back_start", "found %luk available\n", mi->system_available_bytes / 1024); + slapi_log_err(SLAPI_LOG_NOTICE, "ldbm_back_start", "found %" PRIu64 "k physical memory\n", mi->system_total_bytes / 1024); + slapi_log_err(SLAPI_LOG_NOTICE, "ldbm_back_start", "found %" PRIu64 "k available\n", mi->system_available_bytes / 1024); /* We've now calculated the autotuning values. Do we need to apply it? * we use the logic of "if size is 0, or autosize is > 0. This way three @@ -193,7 +193,7 @@ ldbm_back_start_autotune(struct ldbminfo *li) /* First, check the dbcache */ if (li->li_dbcachesize == 0 || li->li_cache_autosize > 0) { - slapi_log_err(SLAPI_LOG_NOTICE, "ldbm_back_start", "cache autosizing: db cache: %luk\n", db_size / 1024); + slapi_log_err(SLAPI_LOG_NOTICE, "ldbm_back_start", "cache autosizing: db cache: %" PRIu64 "k\n", db_size / 1024); if (db_size < (500 * MEGABYTE)) { db_size = db_size / 1.25; } @@ -223,12 +223,12 @@ ldbm_back_start_autotune(struct ldbminfo *li) * it's highly unlikely. */ if (cache_size == 0 || cache_size == MINCACHESIZE || li->li_cache_autosize > 0) { - 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); + slapi_log_err(SLAPI_LOG_NOTICE, "ldbm_back_start", "cache autosizing: %s entry cache (%" PRIu64 " total): %" PRIu64 "k\n", inst->inst_name, backend_count, entry_size / 1024); cache_set_max_entries(&(inst->inst_cache), -1); cache_set_max_size(&(inst->inst_cache), li->li_cache_autosize_ec, CACHE_TYPE_ENTRY); } if (dncache_size == 0 || dncache_size == MINCACHESIZE || li->li_cache_autosize > 0) { - slapi_log_err(SLAPI_LOG_NOTICE, "ldbm_back_start", "cache autosizing: %s dn cache (%lu total): %luk\n", inst->inst_name, backend_count, dn_size / 1024); + slapi_log_err(SLAPI_LOG_NOTICE, "ldbm_back_start", "cache autosizing: %s dn cache (%" PRIu64 " total): %" PRIu64 "k\n", inst->inst_name, backend_count, dn_size / 1024); cache_set_max_entries(&(inst->inst_dncache), -1); cache_set_max_size(&(inst->inst_dncache), li->li_dncache_autosize_ec, CACHE_TYPE_DN); } @@ -389,7 +389,7 @@ ldbm_back_start(Slapi_PBlock *pb) return return_on_disk_full(li); else { if ((li->li_cache_autosize > 0) && (li->li_cache_autosize <= 100)) { - slapi_log_err(SLAPI_LOG_ERR, "ldbm_back_start", "Failed to allocate %lu byte dbcache. " + slapi_log_err(SLAPI_LOG_ERR, "ldbm_back_start", "Failed to allocate %" PRIu64 " byte dbcache. " "Please reduce the value of %s and restart the server.\n", li->li_dbcachesize, CONFIG_CACHE_AUTOSIZE); } diff --git a/ldap/servers/slapd/ch_malloc.c b/ldap/servers/slapd/ch_malloc.c index ef436b3..75e7911 100644 --- a/ldap/servers/slapd/ch_malloc.c +++ b/ldap/servers/slapd/ch_malloc.c @@ -109,21 +109,16 @@ slapi_ch_malloc( /* See slapi-plugin.h */ char * -slapi_ch_memalign(size_t size, size_t alignment) +slapi_ch_memalign(uint32_t size, uint32_t alignment) { char *newmem; - if (size <= 0) { - log_negative_alloc_msg("memalign", "bytes", size); - return 0; - } - if (posix_memalign((void **)&newmem, alignment, size) != 0) { int oserr = errno; oom_occurred(); slapi_log_err(SLAPI_LOG_ERR, SLAPD_MODULE, - "malloc of %lu bytes failed; OS error %d (%s)%s\n", + "malloc of %" PRIu32 " bytes failed; OS error %d (%s)%s\n", size, oserr, slapd_system_strerror(oserr), oom_advice); exit(1); } diff --git a/ldap/servers/slapd/conntable.c b/ldap/servers/slapd/conntable.c index f2f763d..4fae174 100644 --- a/ldap/servers/slapd/conntable.c +++ b/ldap/servers/slapd/conntable.c @@ -416,7 +416,7 @@ connection_table_as_entry(Connection_Table *ct, Slapi_Entry *e) bufptr = newbuf; } - sprintf(bufptr, "%d:%s:%d:%d:%s%s:%s:%s:%lu:ip=%s", + sprintf(bufptr, "%d:%s:%d:%d:%s%s:%s:%s:%" PRIu64 ":ip=%s", i, buf2, ct->c[i].c_opsinitiated, diff --git a/ldap/servers/slapd/daemon.c b/ldap/servers/slapd/daemon.c index c245a4d..3358f34 100644 --- a/ldap/servers/slapd/daemon.c +++ b/ldap/servers/slapd/daemon.c @@ -1087,7 +1087,7 @@ slapd_daemon(daemon_ports_t *ports, ns_thrpool_t *tp) /* we have exited from ns_thrpool_wait. This means we are shutting down! */ /* Please see https://firstyear.fedorapeople.org/nunc-stans/md_docs_job-safety.html */ /* tldr is shutdown needs to run first to allow job_done on an ARMED job */ - for (size_t i = 0; i < listeners; i++) { + for (uint64_t i = 0; i < listeners; i++) { PRStatus shutdown_status = ns_job_done(listener_idxs[i].ns_job); if (shutdown_status != PR_SUCCESS) { slapi_log_err(SLAPI_LOG_CRIT, "ns_set_shutdown", "Failed to shutdown listener idx %" PRIu64 " !\n", i); @@ -1203,7 +1203,7 @@ slapd_daemon(daemon_ports_t *ports, ns_thrpool_t *tp) threads = g_get_active_threadcnt(); if (threads > 0) { slapi_log_err(SLAPI_LOG_INFO, "slapd_daemon", - "slapd shutting down - waiting for %lu thread%s to terminate\n", + "slapd shutting down - waiting for %" PRIu64 " thread%s to terminate\n", threads, (threads > 1) ? "s" : ""); } @@ -1240,7 +1240,7 @@ slapd_daemon(daemon_ports_t *ports, ns_thrpool_t *tp) DS_Sleep(PR_INTERVAL_NO_WAIT); if (threads != g_get_active_threadcnt()) { slapi_log_err(SLAPI_LOG_TRACE, "slapd_daemon", - "slapd shutting down - waiting for %lu threads to terminate\n", + "slapd shutting down - waiting for %" PRIu64 " threads to terminate\n", g_get_active_threadcnt()); threads = g_get_active_threadcnt(); } diff --git a/ldap/servers/slapd/dn.c b/ldap/servers/slapd/dn.c index abc1555..2af3f38 100644 --- a/ldap/servers/slapd/dn.c +++ b/ldap/servers/slapd/dn.c @@ -41,14 +41,14 @@ struct ndn_cache_stats { Slapi_Counter *cache_count; Slapi_Counter *cache_size; Slapi_Counter *cache_evicts; - size_t max_size; - size_t thread_max_size; - size_t slots; + uint64_t max_size; + uint64_t thread_max_size; + uint64_t slots; }; struct ndn_cache_value { - size_t size; - size_t slot; + uint64_t size; + uint64_t slot; char *dn; char *ndn; struct ndn_cache_value *next; @@ -64,23 +64,22 @@ struct ndn_cache { /* * We keep per thread stats and flush them occasionally */ - size_t max_size; + uint64_t max_size; /* Need to track this because we need to provide diffs to counter */ - size_t last_count; - size_t count; + uint64_t last_count; + uint64_t count; /* Number of ops */ - size_t tries; + uint64_t tries; /* hit vs miss. in theroy miss == tries - hits.*/ - size_t hits; + uint64_t hits; /* How many values we kicked out */ - size_t evicts; + uint64_t evicts; /* Need to track this because we need to provide diffs to counter */ - size_t last_size; - size_t size; - - size_t slots; + uint64_t last_size; + uint64_t size; + uint64_t slots; /* - * This is used by siphash to prevent hash bugket attacks + * This is used by siphash to prevent hash bucket attacks */ char key[16]; @@ -3260,7 +3259,7 @@ ndn_cache_add(char *dn, size_t dn_len, char *ndn, size_t ndn_len) /* stats for monitor */ void -ndn_cache_get_stats(PRUint64 *hits, PRUint64 *tries, size_t *size, size_t *max_size, size_t *thread_size, size_t *evicts, size_t *slots, long *count) +ndn_cache_get_stats(uint64_t *hits, uint64_t *tries, uint64_t *size, uint64_t *max_size, uint64_t *thread_size, uint64_t *evicts, uint64_t *slots, uint64_t *count) { *max_size = t_cache_stats.max_size; *thread_size = t_cache_stats.thread_max_size; diff --git a/ldap/servers/slapd/libglobs.c b/ldap/servers/slapd/libglobs.c index d0865e1..4ec447b 100644 --- a/ldap/servers/slapd/libglobs.c +++ b/ldap/servers/slapd/libglobs.c @@ -5966,10 +5966,10 @@ config_set_maxsasliosize(const char *attrname, char *value, char *errorbuf, int return retVal; } -size_t +int32_t config_get_maxsasliosize() { - size_t maxsasliosize; + int32_t maxsasliosize; slapdFrontendConfig_t *slapdFrontendConfig = getFrontendConfig(); maxsasliosize = slapdFrontendConfig->maxsasliosize; diff --git a/ldap/servers/slapd/main.c b/ldap/servers/slapd/main.c index 521d314..1108ad2 100644 --- a/ldap/servers/slapd/main.c +++ b/ldap/servers/slapd/main.c @@ -688,7 +688,7 @@ main(int argc, char **argv) } else if (secs > 3600) { secs = 3600; } - printf("slapd pid is %d - sleeping for %ld\n", getpid(), secs); + printf("slapd pid is %d - sleeping for %" PRId64 "\n", getpid(), secs); sleep(secs); } } diff --git a/ldap/servers/slapd/monitor.c b/ldap/servers/slapd/monitor.c index a281608..68c4864 100644 --- a/ldap/servers/slapd/monitor.c +++ b/ldap/servers/slapd/monitor.c @@ -59,7 +59,7 @@ monitor_info(Slapi_PBlock *pb __attribute__((unused)), attrlist_replace(&e->e_attrs, "version", vals); slapi_ch_free((void **)&val.bv_val); - val.bv_len = snprintf(buf, sizeof(buf), "%lu", g_get_active_threadcnt()); + val.bv_len = snprintf(buf, sizeof(buf), "%" PRIu64, g_get_active_threadcnt()); val.bv_val = buf; attrlist_replace(&e->e_attrs, "threads", vals); diff --git a/ldap/servers/slapd/proto-slap.h b/ldap/servers/slapd/proto-slap.h index b13334a..4a6b8f0 100644 --- a/ldap/servers/slapd/proto-slap.h +++ b/ldap/servers/slapd/proto-slap.h @@ -491,7 +491,7 @@ char *config_get_referral_mode(void); int config_get_conntablesize(void); int config_check_referral_mode(void); ber_len_t config_get_maxbersize(void); -size_t config_get_maxsasliosize(void); +int32_t config_get_maxsasliosize(void); char *config_get_versionstring(void); char *config_get_buildnum(void); int config_get_enquote_sup_oc(void); diff --git a/ldap/servers/slapd/result.c b/ldap/servers/slapd/result.c index 6892ccf..d9f431c 100644 --- a/ldap/servers/slapd/result.c +++ b/ldap/servers/slapd/result.c @@ -1920,7 +1920,7 @@ log_result(Slapi_PBlock *pb, Operation *op, int err, ber_tag_t tag, int nentries struct timespec o_hr_time_end; slapi_operation_time_elapsed(op, &o_hr_time_end); - snprintf(etime, ETIME_BUFSIZ, "%" PRId64 ".%010" PRId64 "", o_hr_time_end.tv_sec, o_hr_time_end.tv_nsec); + snprintf(etime, ETIME_BUFSIZ, "%" PRId64 ".%010" PRId64 "", (int64_t)o_hr_time_end.tv_sec, (int64_t)o_hr_time_end.tv_nsec); slapi_pblock_get(pb, SLAPI_OPERATION_NOTES, &operation_notes); diff --git a/ldap/servers/slapd/sasl_io.c b/ldap/servers/slapd/sasl_io.c index 5fe37dc..751832b 100644 --- a/ldap/servers/slapd/sasl_io.c +++ b/ldap/servers/slapd/sasl_io.c @@ -46,13 +46,13 @@ MOZLDAP is newer than expected, if the ber structure has not changed(see ldap / struct PRFilePrivate { char *decrypted_buffer; - size_t decrypted_buffer_size; - size_t decrypted_buffer_count; - size_t decrypted_buffer_offset; + uint32_t decrypted_buffer_size; + uint32_t decrypted_buffer_count; + uint32_t decrypted_buffer_offset; char *encrypted_buffer; - size_t encrypted_buffer_size; - size_t encrypted_buffer_count; - size_t encrypted_buffer_offset; + uint32_t encrypted_buffer_size; + uint32_t encrypted_buffer_count; + uint32_t encrypted_buffer_offset; Connection *conn; /* needed for connid and sasl_conn context */ PRBool send_encrypted; /* can only send encrypted data after the first read - that is, we cannot send back an encrypted response @@ -130,7 +130,7 @@ sasl_io_init_buffers(sasl_io_private *sp) static void -sasl_io_resize_encrypted_buffer(sasl_io_private *sp, size_t requested_size) +sasl_io_resize_encrypted_buffer(sasl_io_private *sp, uint32_t requested_size) { if (requested_size > sp->encrypted_buffer_size) { sp->encrypted_buffer = slapi_ch_realloc(sp->encrypted_buffer, requested_size); @@ -139,7 +139,7 @@ sasl_io_resize_encrypted_buffer(sasl_io_private *sp, size_t requested_size) } static void -sasl_io_resize_decrypted_buffer(sasl_io_private *sp, size_t requested_size) +sasl_io_resize_decrypted_buffer(sasl_io_private *sp, uint32_t requested_size) { if (requested_size > sp->decrypted_buffer_size) { sp->decrypted_buffer = slapi_ch_realloc(sp->decrypted_buffer, requested_size); @@ -189,10 +189,10 @@ sasl_io_start_packet(PRFileDesc *fd, PRIntn flags, PRIntervalTime timeout, PRInt unsigned char buffer[SASL_IO_BUFFER_START_SIZE]; sasl_io_private *sp = sasl_get_io_private(fd); Connection *c = sp->conn; - PRInt32 amount = sizeof(buffer); - PRInt32 ret = 0; - size_t packet_length = 0; - size_t saslio_limit; + uint32_t amount = sizeof(buffer); + uint32_t ret = 0; + uint32_t packet_length = 0; + int32_t saslio_limit; *err = 0; debug_print_layers(fd); @@ -404,15 +404,15 @@ sasl_io_start_packet(PRFileDesc *fd, PRIntn flags, PRIntervalTime timeout, PRInt packet_length += sizeof(uint32_t); slapi_log_err(SLAPI_LOG_CONNS, "sasl_io_start_packet", - "read sasl packet length %ld on connection %" PRIu64 "\n", + "read sasl packet length %" PRIu32 " on connection %" PRIu64 "\n", packet_length, c->c_connid); /* Check if the packet length is larger than our max allowed. A * setting of -1 means that we allow any size SASL IO packet. */ saslio_limit = config_get_maxsasliosize(); - if (((long)saslio_limit != -1) && (packet_length > saslio_limit)) { + if ((saslio_limit != -1) && (packet_length > saslio_limit)) { slapi_log_err(SLAPI_LOG_ERR, "sasl_io_start_packet", - "SASL encrypted packet length exceeds maximum allowed limit (length=%ld, limit=%ld)." + "SASL encrypted packet length exceeds maximum allowed limit (length=%" PRIu32 ", limit=%" PRIu32")." " Change the nsslapd-maxsasliosize attribute in cn=config to increase limit.\n", packet_length, config_get_maxsasliosize()); PR_SetError(PR_BUFFER_OVERFLOW_ERROR, 0); @@ -434,10 +434,10 @@ sasl_io_read_packet(PRFileDesc *fd, PRIntn flags, PRIntervalTime timeout, PRInt3 PRInt32 ret = 0; sasl_io_private *sp = sasl_get_io_private(fd); Connection *c = sp->conn; - size_t bytes_remaining_to_read = sp->encrypted_buffer_count - sp->encrypted_buffer_offset; + uint32_t bytes_remaining_to_read = sp->encrypted_buffer_count - sp->encrypted_buffer_offset; slapi_log_err(SLAPI_LOG_CONNS, - "sasl_io_read_packet", "Reading %lu bytes for connection %" PRIu64 "\n", + "sasl_io_read_packet", "Reading %" PRIu32" bytes for connection %" PRIu64 "\n", bytes_remaining_to_read, c->c_connid); ret = PR_Recv(fd->lower, sp->encrypted_buffer + sp->encrypted_buffer_offset, bytes_remaining_to_read, flags, timeout); if (ret <= 0) { @@ -461,17 +461,17 @@ sasl_io_recv(PRFileDesc *fd, void *buf, PRInt32 len, PRIntn flags, PRIntervalTim { sasl_io_private *sp = sasl_get_io_private(fd); Connection *c = sp->conn; - PRInt32 ret = 0; - size_t bytes_in_buffer = 0; - PRInt32 err = 0; + int32_t ret = 0; + uint32_t bytes_in_buffer = 0; + int32_t err = 0; /* Do we have decrypted data buffered from 'before' ? */ bytes_in_buffer = sp->decrypted_buffer_count - sp->decrypted_buffer_offset; slapi_log_err(SLAPI_LOG_CONNS, "sasl_io_recv", - "Connection %" PRIu64 " len %d bytes_in_buffer %lu\n", + "Connection %" PRIu64 " len %d bytes_in_buffer %" PRIu32 "\n", c->c_connid, len, bytes_in_buffer); slapi_log_err(SLAPI_LOG_CONNS, "sasl_io_recv", - "Connection %" PRIu64 " len %d encrypted buffer count %lu\n", + "Connection %" PRIu64 " len %d encrypted buffer count %" PRIu32 "\n", c->c_connid, len, sp->encrypted_buffer_count); if (0 == bytes_in_buffer) { /* If there wasn't buffered decrypted data, we need to get some... */ @@ -546,7 +546,7 @@ sasl_io_recv(PRFileDesc *fd, void *buf, PRInt32 len, PRIntn flags, PRIntervalTim } /* Finally, return data from the buffer to the caller */ { - size_t bytes_to_return = sp->decrypted_buffer_count - sp->decrypted_buffer_offset; + uint32_t bytes_to_return = sp->decrypted_buffer_count - sp->decrypted_buffer_offset; if (bytes_to_return > len) { bytes_to_return = len; } @@ -560,7 +560,7 @@ sasl_io_recv(PRFileDesc *fd, void *buf, PRInt32 len, PRIntn flags, PRIntervalTim } else { sp->decrypted_buffer_offset += bytes_to_return; slapi_log_err(SLAPI_LOG_CONNS, "sasl_io_recv", - "Returning %lu bytes to caller %lu bytes left to return for connection %" PRIu64 "\n", + "Returning %" PRIu32 " bytes to caller %" PRIu32 " bytes left to return for connection %" PRIu64 "\n", bytes_to_return, sp->decrypted_buffer_count - sp->decrypted_buffer_offset, c->c_connid); } ret = bytes_to_return; diff --git a/ldap/servers/slapd/slap.h b/ldap/servers/slapd/slap.h index e58f488..bbaa7a4 100644 --- a/ldap/servers/slapd/slap.h +++ b/ldap/servers/slapd/slap.h @@ -2435,7 +2435,7 @@ typedef struct _slapdFrontendConfig int localssf; /* the security strength factor to assign to local conns (ldapi) */ int minssf; /* minimum security strength factor (for SASL and SSL/TLS) */ slapi_onoff_t minssf_exclude_rootdse; /* ON: minssf is ignored when searching rootdse */ - size_t maxsasliosize; /* limit incoming SASL IO packet size */ + int32_t maxsasliosize; /* limit incoming SASL IO packet size */ char *anon_limits_dn; /* template entry for anonymous resource limits */ slapi_int_t listen_backlog_size; /* size of backlog parameter to PR_Listen */ struct passwd *localuserinfo; /* userinfo of localuser */ @@ -2450,7 +2450,7 @@ typedef struct _slapdFrontendConfig /* disk monitoring */ slapi_onoff_t disk_monitoring; - PRInt64 disk_threshold; + uint64_t disk_threshold; int disk_grace_period; slapi_onoff_t disk_logging_critical; diff --git a/ldap/servers/slapd/slapi-plugin.h b/ldap/servers/slapd/slapi-plugin.h index 33e2b95..e862382 100644 --- a/ldap/servers/slapd/slapi-plugin.h +++ b/ldap/servers/slapd/slapi-plugin.h @@ -29,7 +29,6 @@ extern "C" { /* Provides our int types and platform specific requirements. */ #include "slapi_pal.h" - #include "prtypes.h" #include "ldap.h" #include "prprf.h" @@ -5834,7 +5833,7 @@ char *slapi_ch_malloc(unsigned long size); * \param alignment The alignment. MUST be a power of 2! * \return Pointer to the allocated memory aligned by alignment. */ -char *slapi_ch_memalign(size_t size, size_t alignment); +char *slapi_ch_memalign(uint32_t size, uint32_t alignment); char *slapi_ch_realloc(char *block, unsigned long size); char *slapi_ch_calloc(unsigned long nelem, unsigned long size); char *slapi_ch_strdup(const char *s); diff --git a/ldap/servers/slapd/slapi-private.h b/ldap/servers/slapd/slapi-private.h index c28c6e7..9c90dfb 100644 --- a/ldap/servers/slapd/slapi-private.h +++ b/ldap/servers/slapd/slapi-private.h @@ -376,7 +376,7 @@ char *slapi_dn_normalize_case_original(char *dn); int32_t ndn_cache_init(void); void ndn_cache_destroy(void); int ndn_cache_started(void); -void ndn_cache_get_stats(PRUint64 *hits, PRUint64 *tries, size_t *size, size_t *max_size, size_t *thread_size, size_t *evicts, size_t *slots, long *count); +void ndn_cache_get_stats(uint64_t *hits, uint64_t *tries, uint64_t *size, uint64_t *max_size, uint64_t *thread_size, uint64_t *evicts, uint64_t *slots, uint64_t *count); #define NDN_DEFAULT_SIZE 20971520 /* 20mb - size of normalized dn cache */ /* filter.c */ diff --git a/ldap/servers/slapd/tools/dbscan.c b/ldap/servers/slapd/tools/dbscan.c index f4001d2..53cdb89 100644 --- a/ldap/servers/slapd/tools/dbscan.c +++ b/ldap/servers/slapd/tools/dbscan.c @@ -81,13 +81,13 @@ #include #endif -typedef PRUint32 ID; +typedef uint32_t ID; typedef struct { - PRUint32 max; - PRUint32 used; - PRUint32 id[1]; + uint32_t max; + uint32_t used; + uint32_t id[1]; } IDL; #define RDN_BULK_FETCH_BUFFER_SIZE (8 * 1024) @@ -109,9 +109,9 @@ static void display_entryrdn_self(DB *db, ID id, const char *nrdn, int indent); static void display_entryrdn_children(DB *db, ID id, const char *nrdn, int indent); static void display_entryrdn_item(DB *db, DBC *cursor, DBT *key); -PRUint32 file_type = 0; -PRUint32 min_display = 0; -PRUint32 display_mode = 0; +uint32_t file_type = 0; +uint32_t min_display = 0; +uint32_t display_mode = 0; int truncatesiz = 0; long pres_cnt = 0; long eq_cnt = 0; @@ -145,15 +145,15 @@ db_printfln(char *fmt, ...) fprintf(stdout, "\n"); } -size_t MAX_BUFFER = 4096; -size_t MIN_BUFFER = 20; +uint32_t MAX_BUFFER = 4096; +uint32_t MIN_BUFFER = 20; static IDL * idl_make(DBT *data) { IDL *idl = NULL, *xidl; - if (data->size < 2 * sizeof(PRUint32)) { + if (data->size < 2 * sizeof(uint32_t)) { idl = (IDL *)malloc(sizeof(IDL) + 64 * sizeof(ID)); if (!idl) return NULL; @@ -283,7 +283,7 @@ idl_format(IDL *idl, int isfirsttime, int *done) for (; i < idl->used; i++) { sprintf((char *)buf + strlen(buf), "%d ", idl->id[i]); - if (strlen(buf) > (size_t)MAX_BUFFER - MIN_BUFFER) { + if (strlen(buf) > MAX_BUFFER - MIN_BUFFER) { i++; done = 0; return (char *)buf; @@ -360,7 +360,7 @@ _cl5ReadMods(char **buff) { char *pos = *buff; ID i; - PRUint32 mod_count; + uint32_t mod_count; /* need to copy first, to skirt around alignment problems on certain architectures */ @@ -384,7 +384,7 @@ void print_ber_attr(char *attrname, char **buff) { char *val = NULL; - PRUint32 bv_len; + uint32_t bv_len; memcpy((char *)&bv_len, *buff, sizeof(bv_len)); bv_len = ntohl(bv_len); @@ -447,8 +447,8 @@ void _cl5ReadMod(char **buff) { char *pos = *buff; - PRUint32 i; - PRUint32 val_count; + uint32_t i; + uint32_t val_count; char *type = NULL; pos++; @@ -458,7 +458,7 @@ _cl5ReadMod(char **buff) certain architectures */ memcpy((char *)&val_count, pos, sizeof(val_count)); val_count = ntohl(val_count); - pos += sizeof(PRUint32); + pos += sizeof(uint32_t); for (i = 0; i < val_count; i++) { print_ber_attr(type, &pos); @@ -473,14 +473,14 @@ void print_ruv(unsigned char *buff) { char *pos = (char *)buff; - PRUint32 i; - PRUint32 val_count; + uint32_t i; + uint32_t val_count; /* need to do the copy first, to skirt around alignment problems on certain architectures */ memcpy((char *)&val_count, pos, sizeof(val_count)); val_count = ntohl(val_count); - pos += sizeof(PRUint32); + pos += sizeof(uint32_t); for (i = 0; i < val_count; i++) { print_ber_attr(NULL, &pos); @@ -491,11 +491,11 @@ print_ruv(unsigned char *buff) *** Copied from cl5_api:cl5DBData2Entry *** Data in db format: ------------------ - <1 byte version><1 byte change_type> + <1 byte version><1 byte change_type> [<1 byte deleteoldrdn>][<4 byte mod count>....] -Note: the length of time is set PRUint32 instead of time_t. Regardless of the +Note: the length of time is set uint32_t instead of time_t. Regardless of the width of long (32-bit or 64-bit), it's stored using 4bytes by the server [153306]. mod format: @@ -509,9 +509,9 @@ print_changelog(unsigned char *data, int len __attribute__((unused))) uint8_t version; unsigned long operation_type; char *pos = (char *)data; - PRUint32 thetime32; + uint32_t thetime32; time_t thetime; - PRUint32 replgen; + uint32_t replgen; /* read byte of version */ version = *((uint8_t *)pos); @@ -530,7 +530,7 @@ print_changelog(unsigned char *data, int len __attribute__((unused))) memcpy((char *)&thetime32, pos, sizeof(thetime32)); replgen = ntohl(thetime32); - pos += sizeof(PRUint32); + pos += sizeof(uint32_t); thetime = (time_t)replgen; db_printf("\treplgen: %ld %s", replgen, ctime((time_t *)&thetime)); @@ -608,7 +608,7 @@ display_index_item(DBC *cursor, DBT *key, DBT *data, unsigned char *buf, int buf while (ret == 0) { ret = cursor->c_get(cursor, key, data, DB_NEXT_DUP); if (ret == 0) - idl = idl_append(idl, *(PRUint32 *)(data->data)); + idl = idl_append(idl, *(uint32_t *)(data->data)); } if (ret == DB_NOTFOUND) ret = 0; @@ -944,7 +944,7 @@ display_entryrdn_item(DB *db, DBC *cursor, DBT *key) int indent = 2; DBT data; int rc; - PRUint32 flags = 0; + uint32_t flags = 0; char buffer[RDN_BULK_FETCH_BUFFER_SIZE]; DBT dataret; int find_key_flag = 0; @@ -1102,7 +1102,7 @@ usage(char *argv0) printf(" index file options:\n"); printf(" -k lookup only a specific key\n"); printf(" -l max length of dumped id list\n"); - printf(" (default %lu; 40 bytes <= size <= 1048576 bytes)\n", MAX_BUFFER); + printf(" (default %" PRIu32 "; 40 bytes <= size <= 1048576 bytes)\n", MAX_BUFFER); printf(" -G only display index entries with more than ids\n"); printf(" -n display ID list lengths\n"); printf(" -r display the conents of ID list\n"); @@ -1132,7 +1132,7 @@ main(int argc, char **argv) DBT key = {0}, data = {0}; int ret; char *find_key = NULL; - PRUint32 entry_id = 0xffffffff; + uint32_t entry_id = 0xffffffff; int c; key.flags = DB_DBT_REALLOC; @@ -1146,7 +1146,7 @@ main(int argc, char **argv) display_mode |= RAWDATA; break; case 'l': { - PRUint32 tmpmaxbufsz = atoi(optarg); + uint32_t tmpmaxbufsz = atoi(optarg); if (tmpmaxbufsz > ONEMEG) { tmpmaxbufsz = ONEMEG; printf("WARNING: max length of dumped id list too long, " diff --git a/ldap/servers/snmp/main.c b/ldap/servers/snmp/main.c index 95cc261..1e64705 100644 --- a/ldap/servers/snmp/main.c +++ b/ldap/servers/snmp/main.c @@ -71,7 +71,7 @@ main(int argc, char *argv[]) } else if (secs > 3600) { secs = 3600; } - printf("%s pid is %d - sleeping for %ld\n", argv[0], getpid(), secs); + printf("%s pid is %d - sleeping for %" PRId64 "\n", argv[0], getpid(), secs); sleep(secs); } } diff --git a/src/libsds/sds/bpt/map.c b/src/libsds/sds/bpt/map.c index 096a38b..ae528f3 100644 --- a/src/libsds/sds/bpt/map.c +++ b/src/libsds/sds/bpt/map.c @@ -294,8 +294,8 @@ sds_node_to_dot(sds_bptree_instance *binst __attribute__((unused)), sds_bptree_n // Given the node write it out as: fprintf(fp, "subgraph c%" PRIu32 " { \n rank=\"same\";\n", node->level); fprintf(fp, " node_%p [label =\" { node=%p items=%d txn=%" PRIu64 " parent=%p | { ", node, node, node->item_count, node->txn_id, node->parent); - for (size_t i = 0; i < SDS_BPTREE_DEFAULT_CAPACITY; i++) { - fprintf(fp, "| %" PRIu64 " | ", (uint64_t)node->keys[i], i + 1); + for (uint64_t i = 0; i < SDS_BPTREE_DEFAULT_CAPACITY; i++) { + fprintf(fp, "| %" PRIu64 " | ", (uint64_t)((uintptr_t)node->keys[i]), i + 1); } fprintf(fp, "}}\"]; \n}\n"); return SDS_SUCCESS; @@ -312,7 +312,7 @@ sds_node_ptrs_to_dot(sds_bptree_instance *binst __attribute__((unused)), sds_bpt fprintf(fp, "\"node_%p\" -> \"node_%p\"; \n", node, node->values[SDS_BPTREE_DEFAULT_CAPACITY]); } } else { - for (size_t i = 0; i < SDS_BPTREE_BRANCH; i++) { + for (uint64_t i = 0; i < SDS_BPTREE_BRANCH; i++) { if (node->values[i] != NULL) { if (i == SDS_BPTREE_DEFAULT_CAPACITY) { // Work around a graphviz display issue, with Left and Right pointers @@ -332,7 +332,7 @@ sds_bptree_display(sds_bptree_instance *binst) { sds_result result = SDS_SUCCESS; - char *path = malloc(sizeof(char) * 20); + char *path = malloc(sizeof(char) * 21); #ifdef SDS_DEBUG sds_log("sds_bptree_display", "Writing step %03d\n", binst->print_iter); #endif diff --git a/src/libsds/sds/bpt_cow/bpt_cow.c b/src/libsds/sds/bpt_cow/bpt_cow.c index 0b6f229..c2ab607 100644 --- a/src/libsds/sds/bpt_cow/bpt_cow.c +++ b/src/libsds/sds/bpt_cow/bpt_cow.c @@ -527,8 +527,8 @@ sds_node_to_dot(sds_bptree_instance *binst __attribute__((unused)), sds_bptree_n // Given the node write it out as: fprintf(fp, "subgraph c%" PRIu32 " { \n rank=\"same\";\n", node->level); fprintf(fp, " node_%p [label =\" { node=%p items=%d txn=%" PRIu64 " parent=%p | { ", node, node, node->item_count, node->txn_id, node->parent); - for (size_t i = 0; i < SDS_BPTREE_DEFAULT_CAPACITY; i++) { - fprintf(fp, "| %" PRIu64 " | ", (uint64_t)node->keys[i], i + 1); + for (uint64_t i = 0; i < SDS_BPTREE_DEFAULT_CAPACITY; i++) { + fprintf(fp, "| %" PRIu64 " | ", (uint64_t)((uintptr_t)node->keys[i]), i + 1); } fprintf(fp, "}}\"]; \n}\n"); return SDS_SUCCESS; @@ -545,7 +545,7 @@ sds_node_ptrs_to_dot(sds_bptree_instance *binst __attribute__((unused)), sds_bpt fprintf(fp, "\"node_%p\" -> \"node_%p\"; \n", node, node->values[SDS_BPTREE_DEFAULT_CAPACITY]); } } else { - for (size_t i = 0; i < SDS_BPTREE_BRANCH; i++) { + for (uint64_t i = 0; i < SDS_BPTREE_BRANCH; i++) { if (node->values[i] != NULL) { if (i == SDS_BPTREE_DEFAULT_CAPACITY) { // Work around a graphviz display issue, with Left and Right pointers @@ -566,7 +566,7 @@ sds_bptree_cow_display(sds_bptree_transaction *btxn) { sds_result result = SDS_SUCCESS; - char *path = malloc(sizeof(char) * 20); + char *path = malloc(sizeof(char) * 36); print_iter += 1; #ifdef SDS_DEBUG sds_log("sds_bptree_cow_display", "Writing step %03d\n", print_iter);