Fedora Info: [389-commits] ldap/servers rpm/389-ds-base.spec.in

New commits:
commit ff9dafa5ca40e225e240597a5d5c52f0e6c7c677
Author: William Brown <william@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;
}

Fedora Info

Wednesday, October 5, 2016

[389-commits] ldap/servers rpm/389-ds-base.spec.in

No comments:

Post a Comment