ldap/servers/slapd/backend_manager.c | 43 ++--
ldap/servers/slapd/ch_malloc.c | 360 +++++++++++++++++++----------------
ldap/servers/slapd/connection.c | 3
ldap/servers/slapd/daemon.c | 76 +------
ldap/servers/slapd/fe.h | 1
ldap/servers/slapd/pblock.c | 20 -
ldap/servers/slapd/slapi-plugin.h | 11 +
rpm/389-ds-base.spec.in | 2
8 files changed, 258 insertions(+), 258 deletions(-)
New commits:
commit ff9dafa5ca40e225e240597a5d5c52f0e6c7c677
Author: William Brown <william(a)blackhats.net.au>
Date: Thu Sep 29 10:32:08 2016 +1000
Ticket 48996 - update DS for ns 0.2.0
Bug Description: nunc stans changes a number of API's, but most importantly
it removes a number of options.
Fix Description: Make it possible for DS to use NS again. Remove options that
go away, and add the memalign api which NS now relies on. This removes the
(broken and nonfunctional) enable and disable listener function. It also fixes
the logging of FD exhaustion correctly, so we can see when the server is
overwhelmed. Tested with ldclt.
https://fedorahosted.org/389/ticket/48996
Author: wibrown
Review by: nhosoi, mreynolds (Thanks!)
diff --git a/ldap/servers/slapd/backend_manager.c b/ldap/servers/slapd/backend_manager.c
index 5fb0374..bfd6196 100644
--- a/ldap/servers/slapd/backend_manager.c
+++ b/ldap/servers/slapd/backend_manager.c
@@ -103,7 +103,7 @@ Slapi_Backend *
be_new_internal(struct dse *pdse, const char *type, const char *name)
{
Slapi_Backend *be= slapi_be_new(type, name, 1 /* Private */, 0 /* Do Not Log Changes
*/);
- be->be_database = (struct slapdplugin *) slapi_ch_calloc( 1, sizeof(struct
slapdplugin) );
+ be->be_database = (struct slapdplugin *) slapi_ch_calloc( 1, sizeof(struct
slapdplugin) );
be->be_database->plg_private= (void*)pdse;
be->be_database->plg_bind= &dse_bind;
be->be_database->plg_unbind= &dse_unbind;
@@ -351,29 +351,32 @@ be_flushall()
void
be_unbindall(Connection *conn, Operation *op)
{
- int i;
- Slapi_PBlock pb;
+ int i;
+ Slapi_PBlock pb = {0};
- for ( i = 0; i < maxbackends; i++ )
- {
- if ( backends[i] && (backends[i]->be_unbind != NULL) )
- {
- pblock_init_common( &pb, backends[i], conn, op );
-
- if ( plugin_call_plugins( &pb, SLAPI_PLUGIN_PRE_UNBIND_FN ) == 0 )
- {
- int rc = 0;
- slapi_pblock_set( &pb, SLAPI_PLUGIN, backends[i]->be_database );
+ for ( i = 0; i < maxbackends; i++ )
+ {
+ if ( backends[i] && (backends[i]->be_unbind != NULL) )
+ {
+ /* This is the modern, and faster way to do pb memset(0)
+ * It also doesn't trigger the HORRIBLE stack overflows I found ...
+ */
+ pblock_init_common( &pb, backends[i], conn, op );
+
+ if ( plugin_call_plugins( &pb, SLAPI_PLUGIN_PRE_UNBIND_FN ) == 0 )
+ {
+ int rc = 0;
+ slapi_pblock_set( &pb, SLAPI_PLUGIN, backends[i]->be_database );
if(backends[i]->be_state != BE_STATE_DELETED &&
- backends[i]->be_unbind!=NULL)
+ backends[i]->be_unbind!=NULL)
{
- rc = (*backends[i]->be_unbind)( &pb );
+ rc = (*backends[i]->be_unbind)( &pb );
}
- slapi_pblock_set( &pb, SLAPI_PLUGIN_OPRETURN, &rc );
- (void) plugin_call_plugins( &pb, SLAPI_PLUGIN_POST_UNBIND_FN );
- }
- }
- }
+ slapi_pblock_set( &pb, SLAPI_PLUGIN_OPRETURN, &rc );
+ (void) plugin_call_plugins( &pb, SLAPI_PLUGIN_POST_UNBIND_FN );
+ }
+ }
+ }
}
int
diff --git a/ldap/servers/slapd/ch_malloc.c b/ldap/servers/slapd/ch_malloc.c
index debac74..dad7ece 100644
--- a/ldap/servers/slapd/ch_malloc.c
+++ b/ldap/servers/slapd/ch_malloc.c
@@ -25,6 +25,7 @@
static int counters_created= 0;
PR_DEFINE_COUNTER(slapi_ch_counter_malloc);
+PR_DEFINE_COUNTER(slapi_ch_counter_memalign);
PR_DEFINE_COUNTER(slapi_ch_counter_calloc);
PR_DEFINE_COUNTER(slapi_ch_counter_realloc);
PR_DEFINE_COUNTER(slapi_ch_counter_strdup);
@@ -36,7 +37,7 @@ PR_DEFINE_COUNTER(slapi_ch_counter_exist);
static void *oom_emergency_area = NULL;
static PRLock *oom_emergency_lock = NULL;
-#define SLAPD_MODULE "memory allocator"
+#define SLAPD_MODULE "memory allocator"
static const char* const oom_advice =
"\nThe server has probably allocated all available virtual memory. To
solve\n"
@@ -51,21 +52,22 @@ static const char* const oom_advice =
static void
create_counters(void)
{
- PR_CREATE_COUNTER(slapi_ch_counter_malloc,"slapi_ch","malloc","");
- PR_CREATE_COUNTER(slapi_ch_counter_calloc,"slapi_ch","calloc","");
- PR_CREATE_COUNTER(slapi_ch_counter_realloc,"slapi_ch","realloc","");
- PR_CREATE_COUNTER(slapi_ch_counter_strdup,"slapi_ch","strdup","");
- PR_CREATE_COUNTER(slapi_ch_counter_free,"slapi_ch","free","");
- PR_CREATE_COUNTER(slapi_ch_counter_created,"slapi_ch","created","");
- PR_CREATE_COUNTER(slapi_ch_counter_exist,"slapi_ch","exist","");
-
- /* ensure that we have space to allow for shutdown calls to malloc()
- * from should we run out of memory.
- */
- if (oom_emergency_area == NULL) {
- oom_emergency_area = malloc(OOM_PREALLOC_SIZE);
- }
- oom_emergency_lock = PR_NewLock();
+
PR_CREATE_COUNTER(slapi_ch_counter_malloc,"slapi_ch","malloc","");
+
PR_CREATE_COUNTER(slapi_ch_counter_memalign,"slapi_ch","memalign","");
+
PR_CREATE_COUNTER(slapi_ch_counter_calloc,"slapi_ch","calloc","");
+
PR_CREATE_COUNTER(slapi_ch_counter_realloc,"slapi_ch","realloc","");
+
PR_CREATE_COUNTER(slapi_ch_counter_strdup,"slapi_ch","strdup","");
+
PR_CREATE_COUNTER(slapi_ch_counter_free,"slapi_ch","free","");
+
PR_CREATE_COUNTER(slapi_ch_counter_created,"slapi_ch","created","");
+
PR_CREATE_COUNTER(slapi_ch_counter_exist,"slapi_ch","exist","");
+
+ /* ensure that we have space to allow for shutdown calls to malloc()
+ * from should we run out of memory.
+ */
+ if (oom_emergency_area == NULL) {
+ oom_emergency_area = malloc(OOM_PREALLOC_SIZE);
+ }
+ oom_emergency_lock = PR_NewLock();
}
/* called when we have just detected an out of memory condition, before
@@ -75,161 +77,195 @@ create_counters(void)
*/
void oom_occurred(void)
{
- int tmp_errno = errno; /* callers will need the error from malloc */
- if (oom_emergency_lock == NULL) return;
-
- PR_Lock(oom_emergency_lock);
- if (oom_emergency_area) {
- free(oom_emergency_area);
- oom_emergency_area = NULL;
- }
- PR_Unlock(oom_emergency_lock);
- errno = tmp_errno;
+ int tmp_errno = errno; /* callers will need the error from malloc */
+ if (oom_emergency_lock == NULL) {
+ return;
+ }
+
+ PR_Lock(oom_emergency_lock);
+ if (oom_emergency_area) {
+ free(oom_emergency_area);
+ oom_emergency_area = NULL;
+ }
+ PR_Unlock(oom_emergency_lock);
+ errno = tmp_errno;
}
static void
log_negative_alloc_msg( const char *op, const char *units, unsigned long size )
{
- slapi_log_error(SLAPI_LOG_ERR, SLAPD_MODULE,
- "cannot %s %lu %s;\n"
- "trying to allocate 0 or a negative number of %s is not portable and\n"
- "gives different results on different platforms.\n",
- op, size, units, units );
+ slapi_log_error(SLAPI_LOG_ERR, SLAPD_MODULE,
+ "cannot %s %lu %s;\n"
+ "trying to allocate 0 or a negative number of %s is not portable
and\n"
+ "gives different results on different platforms.\n",
+ op, size, units, units );
}
#if !defined(MEMPOOL_EXPERIMENTAL)
char *
slapi_ch_malloc(
- unsigned long size
+ unsigned long size
)
{
- char *newmem;
-
- if (size <= 0) {
- log_negative_alloc_msg( "malloc", "bytes", size );
- return 0;
- }
-
- if ( (newmem = (char *) malloc( size )) == NULL ) {
- int oserr = errno;
-
- oom_occurred();
- slapi_log_error(SLAPI_LOG_ERR, SLAPD_MODULE,
- "malloc of %lu bytes failed; OS error %d (%s)%s\n",
- size, oserr, slapd_system_strerror( oserr ), oom_advice );
- exit( 1 );
- }
- if(!counters_created)
- {
- create_counters();
- counters_created= 1;
- }
+ char *newmem;
+
+ if (size <= 0) {
+ log_negative_alloc_msg( "malloc", "bytes", size );
+ return 0;
+ }
+
+ if ( (newmem = (char *) malloc( size )) == NULL ) {
+ int oserr = errno;
+
+ oom_occurred();
+ slapi_log_error(SLAPI_LOG_ERR, SLAPD_MODULE,
+ "malloc of %lu bytes failed; OS error %d (%s)%s\n",
+ size, oserr, slapd_system_strerror( oserr ), oom_advice );
+ exit( 1 );
+ }
+ if(!counters_created)
+ {
+ create_counters();
+ counters_created= 1;
+ }
PR_INCREMENT_COUNTER(slapi_ch_counter_malloc);
PR_INCREMENT_COUNTER(slapi_ch_counter_created);
PR_INCREMENT_COUNTER(slapi_ch_counter_exist);
- return( newmem );
+ return( newmem );
+}
+
+/* See slapi-plugin.h */
+char *
+slapi_ch_memalign(size_t size, size_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_error(SLAPI_LOG_ERR, SLAPD_MODULE,
+ "malloc of %lu bytes failed; OS error %d (%s)%s\n",
+ size, oserr, slapd_system_strerror( oserr ), oom_advice );
+ exit( 1 );
+ }
+ if(!counters_created)
+ {
+ create_counters();
+ counters_created= 1;
+ }
+ PR_INCREMENT_COUNTER(slapi_ch_counter_memalign);
+ PR_INCREMENT_COUNTER(slapi_ch_counter_created);
+ PR_INCREMENT_COUNTER(slapi_ch_counter_exist);
+
+ return( newmem );
}
char *
slapi_ch_realloc(
- char *block,
- unsigned long size
+ char *block,
+ unsigned long size
)
{
- char *newmem;
-
- if ( block == NULL ) {
- return( slapi_ch_malloc( size ) );
- }
-
- if (size <= 0) {
- log_negative_alloc_msg( "realloc", "bytes", size );
- return block;
- }
-
- if ( (newmem = (char *) realloc( block, size )) == NULL ) {
- int oserr = errno;
-
- oom_occurred();
- slapi_log_error(SLAPI_LOG_ERR, SLAPD_MODULE,
- "realloc of %lu bytes failed; OS error %d (%s)%s\n",
- size, oserr, slapd_system_strerror( oserr ), oom_advice );
- exit( 1 );
- }
- if(!counters_created)
- {
- create_counters();
- counters_created= 1;
- }
+ char *newmem;
+
+ if ( block == NULL ) {
+ return( slapi_ch_malloc( size ) );
+ }
+
+ if (size <= 0) {
+ log_negative_alloc_msg( "realloc", "bytes", size );
+ return block;
+ }
+
+ if ( (newmem = (char *) realloc( block, size )) == NULL ) {
+ int oserr = errno;
+
+ oom_occurred();
+ slapi_log_error(SLAPI_LOG_ERR, SLAPD_MODULE,
+ "realloc of %lu bytes failed; OS error %d (%s)%s\n",
+ size, oserr, slapd_system_strerror( oserr ), oom_advice );
+ exit( 1 );
+ }
+ if(!counters_created)
+ {
+ create_counters();
+ counters_created= 1;
+ }
PR_INCREMENT_COUNTER(slapi_ch_counter_realloc);
- return( newmem );
+ return( newmem );
}
char *
slapi_ch_calloc(
- unsigned long nelem,
- unsigned long size
+ unsigned long nelem,
+ unsigned long size
)
{
- char *newmem;
-
- if (size <= 0) {
- log_negative_alloc_msg( "calloc", "bytes", size );
- return 0;
- }
-
- if (nelem <= 0) {
- log_negative_alloc_msg( "calloc", "elements", nelem );
- return 0;
- }
-
- if ( (newmem = (char *) calloc( nelem, size )) == NULL ) {
- int oserr = errno;
-
- oom_occurred();
- slapi_log_error(SLAPI_LOG_ERR, SLAPD_MODULE,
- "calloc of %lu elems of %lu bytes failed; OS error %d (%s)%s\n",
- nelem, size, oserr, slapd_system_strerror( oserr ), oom_advice );
- exit( 1 );
- }
- if(!counters_created)
- {
- create_counters();
- counters_created= 1;
- }
+ char *newmem;
+
+ if (size <= 0) {
+ log_negative_alloc_msg( "calloc", "bytes", size );
+ return 0;
+ }
+
+ if (nelem <= 0) {
+ log_negative_alloc_msg( "calloc", "elements", nelem );
+ return 0;
+ }
+
+ if ( (newmem = (char *) calloc( nelem, size )) == NULL ) {
+ int oserr = errno;
+
+ oom_occurred();
+ slapi_log_error(SLAPI_LOG_ERR, SLAPD_MODULE,
+ "calloc of %lu elems of %lu bytes failed; OS error %d (%s)%s\n",
+ nelem, size, oserr, slapd_system_strerror( oserr ), oom_advice );
+ exit( 1 );
+ }
+ if(!counters_created)
+ {
+ create_counters();
+ counters_created= 1;
+ }
PR_INCREMENT_COUNTER(slapi_ch_counter_calloc);
PR_INCREMENT_COUNTER(slapi_ch_counter_created);
PR_INCREMENT_COUNTER(slapi_ch_counter_exist);
- return( newmem );
+ return( newmem );
}
char*
slapi_ch_strdup ( const char* s1)
{
char* newmem;
-
- /* strdup pukes on NULL strings...bail out now */
- if(NULL == s1)
- return NULL;
- newmem = strdup (s1);
+
+ /* strdup pukes on NULL strings...bail out now */
+ if(NULL == s1)
+ return NULL;
+ newmem = strdup (s1);
if (newmem == NULL) {
- int oserr = errno;
+ int oserr = errno;
oom_occurred();
- slapi_log_error(SLAPI_LOG_ERR, SLAPD_MODULE,
- "strdup of %lu characters failed; OS error %d (%s)%s\n",
- (unsigned long)strlen(s1), oserr, slapd_system_strerror( oserr ),
- oom_advice );
- exit (1);
+ slapi_log_error(SLAPI_LOG_ERR, SLAPD_MODULE,
+ "strdup of %lu characters failed; OS error %d (%s)%s\n",
+ (unsigned long)strlen(s1), oserr, slapd_system_strerror( oserr ),
+ oom_advice );
+ exit (1);
+ }
+ if(!counters_created)
+ {
+ create_counters();
+ counters_created= 1;
}
- if(!counters_created)
- {
- create_counters();
- counters_created= 1;
- }
PR_INCREMENT_COUNTER(slapi_ch_counter_strdup);
PR_INCREMENT_COUNTER(slapi_ch_counter_created);
PR_INCREMENT_COUNTER(slapi_ch_counter_exist);
@@ -243,14 +279,14 @@ slapi_ch_bvdup (const struct berval* v)
{
struct berval* newberval = ber_bvdup ((struct berval *)v);
if (newberval == NULL) {
- int oserr = errno;
-
- oom_occurred();
- slapi_log_error(SLAPI_LOG_ERR, SLAPD_MODULE,
- "ber_bvdup of %lu bytes failed; OS error %d (%s)%s\n",
- (unsigned long)v->bv_len, oserr, slapd_system_strerror( oserr ),
- oom_advice );
- exit( 1 );
+ int oserr = errno;
+
+ oom_occurred();
+ slapi_log_error(SLAPI_LOG_ERR, SLAPD_MODULE,
+ "ber_bvdup of %lu bytes failed; OS error %d (%s)%s\n",
+ (unsigned long)v->bv_len, oserr, slapd_system_strerror( oserr ),
+ oom_advice );
+ exit( 1 );
}
return newberval;
}
@@ -285,20 +321,20 @@ slapi_ch_bvecdup (struct berval** v)
void
slapi_ch_free(void **ptr)
{
- if (ptr==NULL || *ptr == NULL){
- return;
- }
-
- free (*ptr);
- *ptr = NULL;
- if(!counters_created)
- {
- create_counters();
- counters_created= 1;
- }
+ if (ptr==NULL || *ptr == NULL){
+ return;
+ }
+
+ free (*ptr);
+ *ptr = NULL;
+ if(!counters_created)
+ {
+ create_counters();
+ counters_created= 1;
+ }
PR_INCREMENT_COUNTER(slapi_ch_counter_free);
PR_DECREMENT_COUNTER(slapi_ch_counter_exist);
- return;
+ return;
}
#endif /* !MEMPOOL_EXPERIMENTAL */
@@ -307,13 +343,13 @@ slapi_ch_free(void **ptr)
void
slapi_ch_bvfree(struct berval** v)
{
- if (v == NULL || *v == NULL)
- return;
+ if (v == NULL || *v == NULL)
+ return;
- slapi_ch_free((void **)&((*v)->bv_val));
- slapi_ch_free((void **)v);
+ slapi_ch_free((void **)&((*v)->bv_val));
+ slapi_ch_free((void **)v);
- return;
+ return;
}
/* just like slapi_ch_free, but the argument is the address of a string
@@ -322,7 +358,7 @@ slapi_ch_bvfree(struct berval** v)
void
slapi_ch_free_string(char **s)
{
- slapi_ch_free((void **)s);
+ slapi_ch_free((void **)s);
}
/*
@@ -351,17 +387,17 @@ slapi_ch_free_string(char **s)
char *
slapi_ch_smprintf(const char *fmt, ...)
{
- char *p = NULL;
- va_list ap;
+ char *p = NULL;
+ va_list ap;
- if (NULL == fmt) {
- return NULL;
- }
+ if (NULL == fmt) {
+ return NULL;
+ }
- va_start(ap, fmt);
- p = PR_vsmprintf(fmt, ap);
- va_end(ap);
+ va_start(ap, fmt);
+ p = PR_vsmprintf(fmt, ap);
+ va_end(ap);
- return p;
+ return p;
}
#endif
diff --git a/ldap/servers/slapd/connection.c b/ldap/servers/slapd/connection.c
index 568eef3..7a054c5 100644
--- a/ldap/servers/slapd/connection.c
+++ b/ldap/servers/slapd/connection.c
@@ -229,9 +229,6 @@ connection_cleanup(Connection *conn)
/* free the connection socket buffer */
connection_free_private_buffer(conn);
- if (enable_listeners && !g_get_shutdown()) {
- ns_enable_listeners();
- }
#ifdef ENABLE_NUNC_STANS
/* even if !config_get_enable_nunc_stans, it is ok to set to 0 here */
conn->c_ns_close_jobs = 0;
diff --git a/ldap/servers/slapd/daemon.c b/ldap/servers/slapd/daemon.c
index 9f8a183..b949bba 100644
--- a/ldap/servers/slapd/daemon.c
+++ b/ldap/servers/slapd/daemon.c
@@ -902,50 +902,6 @@ convert_pbe_des_to_aes(void)
}
#ifdef ENABLE_NUNC_STANS
-static ns_job_type_t ns_listen_job_flags =
NS_JOB_ACCEPT|NS_JOB_PERSIST|NS_JOB_PRESERVE_FD;
-static PRStack *ns_disabled_listeners; /* holds the disabled listeners, if any */
-static PRInt32 num_disabled_listeners;
-#endif
-
-#ifdef ENABLE_NUNC_STANS
-static void
-ns_disable_listener(listener_info *listener)
-{
- /* tell the event framework not to listen for new connections on this listener */
- ns_job_modify(listener->ns_job, NS_JOB_DISABLE_ONLY|NS_JOB_PRESERVE_FD);
- /* add the listener to our list of disabled listeners */
- PR_StackPush(ns_disabled_listeners, (PRStackElem *)listener);
- PR_AtomicIncrement(&num_disabled_listeners);
- LDAPDebug2Args(LDAP_DEBUG_ERR, "ns_disable_listener - "
- "disabling listener for fd [%d]: [%d] now disabled\n",
- PR_FileDesc2NativeHandle(listener->listenfd),
- num_disabled_listeners);
-}
-#endif
-
-void
-ns_enable_listeners()
-{
-#ifdef ENABLE_NUNC_STANS
- if (!enable_nunc_stans) {
- return;
- }
- int num_enabled = 0;
- listener_info *listener;
- while ((listener = (listener_info *)PR_StackPop(ns_disabled_listeners))) {
- /* there was a disabled listener - re-enable it to listen for new connections */
- ns_job_modify(listener->ns_job, ns_listen_job_flags);
- PR_AtomicDecrement(&num_disabled_listeners);
- num_enabled++;
- }
- if (num_enabled) {
- LDAPDebug1Arg(LDAP_DEBUG_ERR, "ns_enable_listeners - "
- "enabled [%d] listeners\n", num_enabled);
- }
-#endif
-}
-
-#ifdef ENABLE_NUNC_STANS
/*
* Nunc stans logging function.
*/
@@ -972,6 +928,12 @@ nunc_stans_malloc(size_t size)
}
static void*
+nunc_stans_memalign(size_t size, size_t alignment)
+{
+ return (void*)slapi_ch_memalign(size, alignment);
+}
+
+static void*
nunc_stans_calloc(size_t count, size_t size)
{
return (void*)slapi_ch_calloc((unsigned long)count, (unsigned long)size);
@@ -1170,11 +1132,6 @@ void slapd_daemon( daemon_ports_t *ports )
#endif /* ENABLE_LDAPI */
listener_idxs = (listener_info *)slapi_ch_calloc(listeners, sizeof(*listener_idxs));
-#ifdef ENABLE_NUNC_STANS
- if (enable_nunc_stans) {
- ns_disabled_listeners = PR_CreateStack("disabled_listeners");
- }
-#endif
/*
* Convert old DES encoded passwords to AES
*/
@@ -1187,11 +1144,8 @@ void slapd_daemon( daemon_ports_t *ports )
/* Set the nunc-stans thread pool config */
ns_thrpool_config_init(&tp_config);
- tp_config.initial_threads = maxthreads;
tp_config.max_threads = maxthreads;
tp_config.stacksize = 0;
- tp_config.event_queue_size = config_get_maxdescriptors();
- tp_config.work_queue_size = config_get_maxdescriptors();
#ifdef LDAP_DEBUG
tp_config.log_fct = nunc_stans_logging;
#else
@@ -1200,6 +1154,7 @@ void slapd_daemon( daemon_ports_t *ports )
tp_config.log_start_fct = NULL;
tp_config.log_close_fct = NULL;
tp_config.malloc_fct = nunc_stans_malloc;
+ tp_config.memalign_fct = nunc_stans_memalign;
tp_config.calloc_fct = nunc_stans_calloc;
tp_config.realloc_fct = nunc_stans_realloc;
tp_config.free_fct = nunc_stans_free;
@@ -1211,7 +1166,7 @@ void slapd_daemon( daemon_ports_t *ports )
setup_pr_read_pds(the_connection_table,n_tcps,s_tcps,i_unix,&num_poll);
for (ii = 0; ii < listeners; ++ii) {
listener_idxs[ii].ct = the_connection_table; /* to pass to handle_new_connection */
- ns_add_io_job(tp, listener_idxs[ii].listenfd, ns_listen_job_flags,
+ ns_add_io_job(tp, listener_idxs[ii].listenfd,
NS_JOB_ACCEPT|NS_JOB_PERSIST|NS_JOB_PRESERVE_FD,
ns_handle_new_connection, &listener_idxs[ii],
&listener_idxs[ii].ns_job);
}
@@ -2632,10 +2587,8 @@ ns_handle_new_connection(struct ns_job_t *job)
*/
if ((li->ct->size - g_get_current_conn_count())
<= config_get_reservedescriptors()) {
- /* too many open fds - shut off this listener - when an fd is
- * closed, try to resume this listener
- */
- ns_disable_listener(li);
+ /* too many open fds - Just return, and hope next time is better. */
+ slapi_log_error(SLAPI_LOG_FATAL, "ns_handle_new_connection",
"Insufficient Reserve FD: File Descriptor exhaustion has occured! Connections will be
silently dropped!\n");
return;
}
@@ -2644,12 +2597,13 @@ ns_handle_new_connection(struct ns_job_t *job)
PRErrorCode prerr = PR_GetError();
if (PR_PROC_DESC_TABLE_FULL_ERROR == prerr) {
/* too many open fds - shut off this listener - when an fd is
- * closed, try to resume this listener
+ * closed, try to resume this listener.
+ *
+ * WARNING: This generates a lot of false negatives. Why?
*/
- ns_disable_listener(li);
+ slapi_log_error(SLAPI_LOG_FATAL, "ns_handle_new_connection",
"PR_PROC_DESC_TABLE_FULL_ERROR: File Descriptor exhaustion has occured! Connections
will be silently dropped!\n");
} else {
- LDAPDebug(LDAP_DEBUG_CONNS, "ns_handle_new_connection - Error accepting"
- " new connection listenfd=%d [%d:%s]\n",
+ slapi_log_error(SLAPI_LOG_FATAL, "ns_handle_new_connection", "Error
accepting new connection listenfd=%d [%d:%s]\n",
PR_FileDesc2NativeHandle(li->listenfd), prerr,
slapd_pr_strerror(prerr));
}
diff --git a/ldap/servers/slapd/fe.h b/ldap/servers/slapd/fe.h
index 4368cc6..3d9ac08 100644
--- a/ldap/servers/slapd/fe.h
+++ b/ldap/servers/slapd/fe.h
@@ -123,7 +123,6 @@ int daemon_register_reslimits( void );
PRFileDesc * get_ssl_listener_fd(void);
int configure_pr_socket( PRFileDesc **pr_socket, int secure, int local );
void configure_ns_socket( int * ns );
-void ns_enable_listeners(void);
/*
* sasl_io.c
diff --git a/ldap/servers/slapd/pblock.c b/ldap/servers/slapd/pblock.c
index 0cff834..f9b22a7 100644
--- a/ldap/servers/slapd/pblock.c
+++ b/ldap/servers/slapd/pblock.c
@@ -23,22 +23,22 @@
void
pblock_init( Slapi_PBlock *pb )
{
- memset( pb, '\0', sizeof(Slapi_PBlock) );
+ memset( pb, '\0', sizeof(Slapi_PBlock) );
}
void
pblock_init_common(
- Slapi_PBlock *pb,
- Slapi_Backend *be,
- Connection *conn,
- Operation *op
+ Slapi_PBlock *pb,
+ Slapi_Backend *be,
+ Connection *conn,
+ Operation *op
)
{
- PR_ASSERT( NULL != pb );
- memset( pb, '\0', sizeof(Slapi_PBlock) );
- pb->pb_backend = be;
- pb->pb_conn = conn;
- pb->pb_op = op;
+ PR_ASSERT( NULL != pb );
+ memset( pb, '\0', sizeof(Slapi_PBlock) );
+ pb->pb_backend = be;
+ pb->pb_conn = conn;
+ pb->pb_op = op;
}
void
diff --git a/ldap/servers/slapd/slapi-plugin.h b/ldap/servers/slapd/slapi-plugin.h
index c1a9acf..d7d130d 100644
--- a/ldap/servers/slapd/slapi-plugin.h
+++ b/ldap/servers/slapd/slapi-plugin.h
@@ -5820,6 +5820,17 @@ int slapi_is_shutting_down(void);
* checking routines for allocating and freeing memory
*/
char * slapi_ch_malloc( unsigned long size );
+/*
+ * memalign returns an alligned block of memory as a multiple of alignment.
+ * alignment must be a power of 2. This is not normally needed, but is required
+ * for memory that works with certain cpu operations. It's basically malloc
+ * with some extra guarantees.
+ *
+ * \param size The size of the memory to allocate
+ * \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_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/rpm/389-ds-base.spec.in b/rpm/389-ds-base.spec.in
index 94e0dac..75fae32 100644
--- a/rpm/389-ds-base.spec.in
+++ b/rpm/389-ds-base.spec.in
@@ -18,7 +18,7 @@
# To build without nunc-stans, set use_nunc_stans to 0.
%global use_nunc_stans __NUNC_STANS_ON__
%if %{use_nunc_stans}
-%global nunc_stans_ver 0.1.8
+%global nunc_stans_ver 0.2.0
%endif
# This enables an ASAN build. This should not go to production, so we rename.