X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Finit.c;h=ae15d0515a099ef5b145cbec94f6adf9d428017a;hb=450f352ec14a6c053b50cd2016c197d461990d8e;hp=0f658614ad3b4792c5c7df71fb16ae89e97817da;hpb=fda3d6260e25f1d0b9c035b0d520b2c9d0f22e49;p=openldap diff --git a/servers/slapd/init.c b/servers/slapd/init.c index 0f658614ad..ae15d0515a 100644 --- a/servers/slapd/init.c +++ b/servers/slapd/init.c @@ -2,7 +2,7 @@ /* $OpenLDAP$ */ /* This work is part of OpenLDAP Software . * - * Copyright 1998-2004 The OpenLDAP Foundation. + * Copyright 1998-2009 The OpenLDAP Foundation. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -34,9 +34,8 @@ #include "slap.h" #include "lber_pvt.h" -#ifdef LDAP_SLAPI -#include "slapi/slapi.h" -#endif + +#include "ldap_rq.h" /* * read-only global variables or variables only written by the listener @@ -44,29 +43,28 @@ */ int slap_debug = 0; -struct berval AllUser = BER_BVC( LDAP_ALL_USER_ATTRIBUTES ); -struct berval AllOper = BER_BVC( LDAP_ALL_OPERATIONAL_ATTRIBUTES ); -struct berval NoAttrs = BER_BVC( LDAP_NO_ATTRS ); - -/* - * global variables that need mutex protection - */ #ifdef LDAP_DEBUG -int ldap_syslog = LDAP_DEBUG_STATS; +int ldap_syslog = LDAP_DEBUG_STATS; #else -int ldap_syslog; +int ldap_syslog; #endif #ifdef LOG_DEBUG -int ldap_syslog_level = LOG_DEBUG; -#else -int ldap_syslog_level; +int ldap_syslog_level = LOG_DEBUG; #endif +BerVarray default_referral = NULL; + /* - * these mutexes must be used when calling the entry2str() - * routine since it returns a pointer to static data. + * global variables that need mutex protection */ +ldap_pvt_thread_pool_t connection_pool; +int connection_pool_max = SLAP_MAX_WORKER_THREADS; +int slap_tool_thread_max = 1; +ldap_pvt_thread_mutex_t gmtime_mutex; + +slap_counters_t slap_counters, *slap_counters_list; + static const char* slap_name = NULL; int slapMode = SLAP_UNDEFINED_MODE; @@ -74,11 +72,12 @@ int slap_init( int mode, const char *name ) { int rc; - int i; assert( mode ); if ( slapMode != SLAP_UNDEFINED_MODE ) { + /* Make sure we write something to stderr */ + slap_debug |= LDAP_DEBUG_NONE; Debug( LDAP_DEBUG_ANY, "%s init: init called twice (old=%d, new=%d)\n", name, slapMode, mode ); @@ -88,56 +87,79 @@ slap_init( int mode, const char *name ) slapMode = mode; + slap_op_init(); + +#ifdef SLAPD_MODULES + if ( module_init() != 0 ) { + slap_debug |= LDAP_DEBUG_NONE; + Debug( LDAP_DEBUG_ANY, + "%s: module_init failed\n", + name, 0, 0 ); + return 1; + } +#endif + + if ( slap_schema_init( ) != 0 ) { + slap_debug |= LDAP_DEBUG_NONE; + Debug( LDAP_DEBUG_ANY, + "%s: slap_schema_init failed\n", + name, 0, 0 ); + return 1; + } + + if ( filter_init() != 0 ) { + slap_debug |= LDAP_DEBUG_NONE; + Debug( LDAP_DEBUG_ANY, + "%s: filter_init failed\n", + name, 0, 0 ); + return 1; + } + + if ( entry_init() != 0 ) { + slap_debug |= LDAP_DEBUG_NONE; + Debug( LDAP_DEBUG_ANY, + "%s: entry_init failed\n", + name, 0, 0 ); + return 1; + } + switch ( slapMode & SLAP_MODE ) { case SLAP_SERVER_MODE: + root_dse_init(); + + /* FALLTHRU */ case SLAP_TOOL_MODE: Debug( LDAP_DEBUG_TRACE, "%s init: initiated %s.\n", name, (mode & SLAP_MODE) == SLAP_TOOL_MODE ? "tool" : "server", 0 ); - slap_name = name; - ldap_pvt_thread_pool_init( &SLAPD_GLOBAL(connection_pool), - SLAPD_GLOBAL(connection_pool_max), 0); - - ldap_pvt_thread_mutex_init( &SLAPD_GLOBAL(entry2str_mutex) ); - ldap_pvt_thread_mutex_init( &SLAPD_GLOBAL(replog_mutex) ); + ldap_pvt_thread_pool_init( &connection_pool, + connection_pool_max, 0); - ldap_pvt_thread_mutex_init( &SLAPD_GLOBAL(counters).sc_sent_mutex ); - ldap_pvt_thread_mutex_init( &SLAPD_GLOBAL(counters).sc_ops_mutex ); - ldap_pvt_mp_init( SLAPD_GLOBAL(counters).sc_bytes ); - ldap_pvt_mp_init( SLAPD_GLOBAL(counters).sc_pdu ); - ldap_pvt_mp_init( SLAPD_GLOBAL(counters).sc_entries ); - ldap_pvt_mp_init( SLAPD_GLOBAL(counters).sc_refs ); + slap_counters_init( &slap_counters ); - ldap_pvt_mp_init( SLAPD_GLOBAL(counters).sc_ops_completed ); - ldap_pvt_mp_init( SLAPD_GLOBAL(counters).sc_ops_initiated ); + ldap_pvt_thread_mutex_init( &slapd_rq.rq_mutex ); + LDAP_STAILQ_INIT( &slapd_rq.task_list ); + LDAP_STAILQ_INIT( &slapd_rq.run_list ); -#ifdef SLAPD_MONITOR - for ( i = 0; i < SLAP_OP_LAST; i++ ) { - ldap_pvt_mp_init( SLAPD_GLOBAL(counters).sc_ops_initiated_[ i ] ); - ldap_pvt_mp_init( SLAPD_GLOBAL(counters).sc_ops_completed_[ i ] ); - } -#endif /* SLAPD_MONITOR */ - -#ifndef HAVE_GMTIME_R - ldap_pvt_thread_mutex_init( &SLAPD_GLOBAL(gmtime_mutex) ); -#endif -#if defined( SLAPD_CRYPT ) || defined( SLAPD_SPASSWD ) - ldap_pvt_thread_mutex_init( &passwd_mutex ); -#endif + ldap_pvt_thread_mutex_init( &gmtime_mutex ); + slap_passwd_init(); rc = slap_sasl_init(); if( rc == 0 ) { rc = backend_init( ); } + if ( rc ) + return rc; break; default: + slap_debug |= LDAP_DEBUG_NONE; Debug( LDAP_DEBUG_ANY, "%s init: undefined mode (%d).\n", name, mode, 0 ); @@ -145,95 +167,98 @@ slap_init( int mode, const char *name ) break; } + if ( slap_controls_init( ) != 0 ) { + slap_debug |= LDAP_DEBUG_NONE; + Debug( LDAP_DEBUG_ANY, + "%s: slap_controls_init failed\n", + name, 0, 0 ); + return 1; + } + + if ( frontend_init() ) { + slap_debug |= LDAP_DEBUG_NONE; + Debug( LDAP_DEBUG_ANY, + "%s: frontend_init failed\n", + name, 0, 0 ); + return 1; + } + + if ( overlay_init() ) { + slap_debug |= LDAP_DEBUG_NONE; + Debug( LDAP_DEBUG_ANY, + "%s: overlay_init failed\n", + name, 0, 0 ); + return 1; + } + + if ( glue_sub_init() ) { + slap_debug |= LDAP_DEBUG_NONE; + Debug( LDAP_DEBUG_ANY, + "%s: glue/subordinate init failed\n", + name, 0, 0 ); + + return 1; + } + + if ( acl_init() ) { + slap_debug |= LDAP_DEBUG_NONE; + Debug( LDAP_DEBUG_ANY, + "%s: acl_init failed\n", + name, 0, 0 ); + return 1; + } + return rc; } int slap_startup( Backend *be ) { - int rc; - Debug( LDAP_DEBUG_TRACE, "%s startup: initiated.\n", slap_name, 0, 0 ); - rc = backend_startup( be ); - -#ifdef LDAP_SLAPI - if( rc == 0 ) { - Slapi_PBlock *pb = slapi_pblock_new(); - - if ( slapi_int_call_plugins( NULL, SLAPI_PLUGIN_START_FN, pb ) < 0 ) { - rc = -1; - } - slapi_pblock_destroy( pb ); - } -#endif /* LDAP_SLAPI */ - - return rc; + return backend_startup( be ); } int slap_shutdown( Backend *be ) { - int rc; -#ifdef LDAP_SLAPI - Slapi_PBlock *pb; -#endif - Debug( LDAP_DEBUG_TRACE, "%s shutdown: initiated\n", slap_name, 0, 0 ); /* let backends do whatever cleanup they need to do */ - rc = backend_shutdown( be ); - -#ifdef LDAP_SLAPI - pb = slapi_pblock_new(); - (void) slapi_int_call_plugins( NULL, SLAPI_PLUGIN_CLOSE_FN, pb ); - slapi_pblock_destroy( pb ); -#endif /* LDAP_SLAPI */ - - return rc; + return backend_shutdown( be ); } int slap_destroy(void) { int rc; - int i; Debug( LDAP_DEBUG_TRACE, "%s destroy: freeing system resources.\n", slap_name, 0, 0 ); - if ( SLAPD_GLOBAL(default_referral) ) { - ber_bvarray_free( SLAPD_GLOBAL(default_referral) ); + if ( default_referral ) { + ber_bvarray_free( default_referral ); } + /* clear out any thread-keys for the main thread */ + ldap_pvt_thread_pool_context_reset( ldap_pvt_thread_pool_context()); + rc = backend_destroy(); slap_sasl_destroy(); + /* rootdse destroy goes before entry_destroy() + * because it may use entry_free() */ + root_dse_destroy(); entry_destroy(); switch ( slapMode & SLAP_MODE ) { case SLAP_SERVER_MODE: case SLAP_TOOL_MODE: - - ldap_pvt_thread_mutex_destroy( &SLAPD_GLOBAL(counters).sc_sent_mutex ); - ldap_pvt_thread_mutex_destroy( &SLAPD_GLOBAL(counters).sc_ops_mutex ); - ldap_pvt_mp_clear( SLAPD_GLOBAL(counters).sc_bytes ); - ldap_pvt_mp_clear( SLAPD_GLOBAL(counters).sc_pdu ); - ldap_pvt_mp_clear( SLAPD_GLOBAL(counters).sc_entries ); - ldap_pvt_mp_clear( SLAPD_GLOBAL(counters).sc_refs ); - ldap_pvt_mp_clear( SLAPD_GLOBAL(counters).sc_ops_completed ); - ldap_pvt_mp_clear( SLAPD_GLOBAL(counters).sc_ops_initiated ); - -#ifdef SLAPD_MONITOR - for ( i = 0; i < SLAP_OP_LAST; i++ ) { - ldap_pvt_mp_clear( SLAPD_GLOBAL(counters).sc_ops_initiated_[ i ] ); - ldap_pvt_mp_clear( SLAPD_GLOBAL(counters).sc_ops_completed_[ i ] ); - } -#endif /* SLAPD_MONITOR */ + slap_counters_destroy( &slap_counters ); break; default: @@ -245,8 +270,53 @@ int slap_destroy(void) } + slap_op_destroy(); + ldap_pvt_thread_destroy(); - /* should destory the above mutex */ + /* should destroy the above mutex */ return rc; } + +void slap_counters_init( slap_counters_t *sc ) +{ + int i; + + ldap_pvt_thread_mutex_init( &sc->sc_mutex ); + ldap_pvt_mp_init( sc->sc_bytes ); + ldap_pvt_mp_init( sc->sc_pdu ); + ldap_pvt_mp_init( sc->sc_entries ); + ldap_pvt_mp_init( sc->sc_refs ); + + ldap_pvt_mp_init( sc->sc_ops_initiated ); + ldap_pvt_mp_init( sc->sc_ops_completed ); + +#ifdef SLAPD_MONITOR + for ( i = 0; i < SLAP_OP_LAST; i++ ) { + ldap_pvt_mp_init( sc->sc_ops_initiated_[ i ] ); + ldap_pvt_mp_init( sc->sc_ops_completed_[ i ] ); + } +#endif /* SLAPD_MONITOR */ +} + +void slap_counters_destroy( slap_counters_t *sc ) +{ + int i; + + ldap_pvt_thread_mutex_destroy( &sc->sc_mutex ); + ldap_pvt_mp_clear( sc->sc_bytes ); + ldap_pvt_mp_clear( sc->sc_pdu ); + ldap_pvt_mp_clear( sc->sc_entries ); + ldap_pvt_mp_clear( sc->sc_refs ); + + ldap_pvt_mp_clear( sc->sc_ops_initiated ); + ldap_pvt_mp_clear( sc->sc_ops_completed ); + +#ifdef SLAPD_MONITOR + for ( i = 0; i < SLAP_OP_LAST; i++ ) { + ldap_pvt_mp_clear( sc->sc_ops_initiated_[ i ] ); + ldap_pvt_mp_clear( sc->sc_ops_completed_[ i ] ); + } +#endif /* SLAPD_MONITOR */ +} +