X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Finit.c;h=73e42250679fc54d1fd3c91ff4d21baa1a16710f;hb=294da7ed11a9a5721b15d0ed81682f123e20cbb0;hp=91c699efc719ab54ff0852f6522022d3f22c91fd;hpb=b5ef8ea6f404e4c7d6e288a55ec3156959cec744;p=openldap diff --git a/servers/slapd/init.c b/servers/slapd/init.c index 91c699efc7..73e4225067 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-2005 The OpenLDAP Foundation. + * Copyright 1998-2008 The OpenLDAP Foundation. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -34,9 +34,6 @@ #include "slap.h" #include "lber_pvt.h" -#ifdef LDAP_SLAPI -#include "slapi/slapi.h" -#endif #include "ldap_rq.h" @@ -67,18 +64,10 @@ struct berval NoAttrs = BER_BVC( LDAP_NO_ATTRS ); */ ldap_pvt_thread_pool_t connection_pool; int connection_pool_max = SLAP_MAX_WORKER_THREADS; -#ifndef HAVE_GMTIME_R +int slap_tool_thread_max = 1; ldap_pvt_thread_mutex_t gmtime_mutex; -#endif -slap_counters_t slap_counters; - -/* - * these mutexes must be used when calling the entry2str() - * routine since it returns a pointer to static data. - */ -ldap_pvt_thread_mutex_t entry2str_mutex; -ldap_pvt_thread_mutex_t replog_mutex; +slap_counters_t slap_counters, *slap_counters_list; static const char* slap_name = NULL; int slapMode = SLAP_UNDEFINED_MODE; @@ -87,11 +76,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 ); @@ -101,47 +91,65 @@ 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( &connection_pool, connection_pool_max, 0); - ldap_pvt_thread_mutex_init( &entry2str_mutex ); - ldap_pvt_thread_mutex_init( &replog_mutex ); - - ldap_pvt_thread_mutex_init( &slap_counters.sc_sent_mutex ); - ldap_pvt_thread_mutex_init( &slap_counters.sc_ops_mutex ); - ldap_pvt_mp_init( slap_counters.sc_bytes ); - ldap_pvt_mp_init( slap_counters.sc_pdu ); - ldap_pvt_mp_init( slap_counters.sc_entries ); - ldap_pvt_mp_init( slap_counters.sc_refs ); - - ldap_pvt_mp_init( slap_counters.sc_ops_initiated ); - ldap_pvt_mp_init( slap_counters.sc_ops_completed ); + slap_counters_init( &slap_counters ); 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( slap_counters.sc_ops_initiated_[ i ] ); - ldap_pvt_mp_init( slap_counters.sc_ops_completed_[ i ] ); - } -#endif /* SLAPD_MONITOR */ - -#ifndef HAVE_GMTIME_R ldap_pvt_thread_mutex_init( &gmtime_mutex ); -#endif slap_passwd_init(); rc = slap_sasl_init(); @@ -149,10 +157,13 @@ slap_init( int mode, const char *name ) 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 ); @@ -160,61 +171,73 @@ 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", @@ -224,31 +247,22 @@ int slap_destroy(void) 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( &slap_counters.sc_sent_mutex ); - ldap_pvt_thread_mutex_destroy( &slap_counters.sc_ops_mutex ); - ldap_pvt_mp_clear( slap_counters.sc_bytes ); - ldap_pvt_mp_clear( slap_counters.sc_pdu ); - ldap_pvt_mp_clear( slap_counters.sc_entries ); - ldap_pvt_mp_clear( slap_counters.sc_refs ); - ldap_pvt_mp_clear( slap_counters.sc_ops_initiated ); - ldap_pvt_mp_clear( slap_counters.sc_ops_completed ); - -#ifdef SLAPD_MONITOR - for ( i = 0; i < SLAP_OP_LAST; i++ ) { - ldap_pvt_mp_clear( slap_counters.sc_ops_initiated_[ i ] ); - ldap_pvt_mp_clear( slap_counters.sc_ops_completed_[ i ] ); - } -#endif /* SLAPD_MONITOR */ + slap_counters_destroy( &slap_counters ); break; default: @@ -260,8 +274,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 */ +} +