From 67f3fd8078a19fbe621285ee0dbf94012e54408e Mon Sep 17 00:00:00 2001 From: Pierangelo Masarati Date: Thu, 14 Sep 2006 18:55:02 +0000 Subject: [PATCH] monitor __ALL__ thread parameters --- include/ldap_pvt_thread.h | 20 ++ libraries/libldap_r/tpool.c | 107 +++++++- servers/slapd/back-monitor/thread.c | 404 +++++++++++++--------------- 3 files changed, 297 insertions(+), 234 deletions(-) diff --git a/include/ldap_pvt_thread.h b/include/ldap_pvt_thread.h index fe8b5beb94..c2c515f205 100644 --- a/include/ldap_pvt_thread.h +++ b/include/ldap_pvt_thread.h @@ -212,6 +212,26 @@ ldap_pvt_thread_pool_maxthreads LDAP_P(( ldap_pvt_thread_pool_t *pool, int max_threads )); +typedef enum { + LDAP_PVT_THREAD_POOL_PARAM_UNKNOWN = -1, + LDAP_PVT_THREAD_POOL_PARAM_MAX, + LDAP_PVT_THREAD_POOL_PARAM_MAX_PENDING, + LDAP_PVT_THREAD_POOL_PARAM_OPEN, + LDAP_PVT_THREAD_POOL_PARAM_STARTING, + LDAP_PVT_THREAD_POOL_PARAM_ACTIVE, + LDAP_PVT_THREAD_POOL_PARAM_PENDING, + LDAP_PVT_THREAD_POOL_PARAM_BACKLOAD, + LDAP_PVT_THREAD_POOL_PARAM_ACTIVE_MAX, + LDAP_PVT_THREAD_POOL_PARAM_PENDING_MAX, + LDAP_PVT_THREAD_POOL_PARAM_BACKLOAD_MAX, + LDAP_PVT_THREAD_POOL_PARAM_STATE +} ldap_pvt_thread_pool_param_t; + +LDAP_F( int ) +ldap_pvt_thread_pool_query LDAP_P(( + ldap_pvt_thread_pool_t *pool, + ldap_pvt_thread_pool_param_t param, void *value )); + LDAP_F( int ) ldap_pvt_thread_pool_backload LDAP_P(( ldap_pvt_thread_pool_t *pool )); diff --git a/libraries/libldap_r/tpool.c b/libraries/libldap_r/tpool.c index 4515d312ef..32d13dd9df 100644 --- a/libraries/libldap_r/tpool.c +++ b/libraries/libldap_r/tpool.c @@ -464,23 +464,110 @@ ldap_pvt_thread_pool_maxthreads ( ldap_pvt_thread_pool_t *tpool, int max_threads } int -ldap_pvt_thread_pool_backload ( ldap_pvt_thread_pool_t *tpool ) +ldap_pvt_thread_pool_query ( ldap_pvt_thread_pool_t *tpool, ldap_pvt_thread_pool_param_t param, void *value ) { - struct ldap_int_thread_pool_s *pool; - int count; + struct ldap_int_thread_pool_s *pool; + int count = -1; - if (tpool == NULL) - return(-1); + if ( tpool == NULL || value == NULL ) { + return -1; + } pool = *tpool; - if (pool == NULL) - return(0); + if ( pool == NULL ) { + return 0; + } ldap_pvt_thread_mutex_lock(&pool->ltp_mutex); - count = pool->ltp_pending_count + pool->ltp_active_count; - ldap_pvt_thread_mutex_unlock(&pool->ltp_mutex); - return(count); + switch ( param ) { + case LDAP_PVT_THREAD_POOL_PARAM_MAX: + count = pool->ltp_max_count; + break; + + case LDAP_PVT_THREAD_POOL_PARAM_MAX_PENDING: + count = pool->ltp_max_pending; + break; + + case LDAP_PVT_THREAD_POOL_PARAM_OPEN: + count = pool->ltp_open_count; + break; + + case LDAP_PVT_THREAD_POOL_PARAM_STARTING: + count = pool->ltp_starting; + break; + + case LDAP_PVT_THREAD_POOL_PARAM_ACTIVE: + count = pool->ltp_active_count; + break; + + case LDAP_PVT_THREAD_POOL_PARAM_PENDING: + count = pool->ltp_pending_count; + break; + + case LDAP_PVT_THREAD_POOL_PARAM_BACKLOAD: + count = pool->ltp_pending_count + pool->ltp_active_count; + break; + + case LDAP_PVT_THREAD_POOL_PARAM_ACTIVE_MAX: + break; + + case LDAP_PVT_THREAD_POOL_PARAM_PENDING_MAX: + break; + + case LDAP_PVT_THREAD_POOL_PARAM_BACKLOAD_MAX: + break; + + case LDAP_PVT_THREAD_POOL_PARAM_STATE: { + static struct { + char *name; + ldap_int_thread_pool_state_t state; + } str2state[] = { + { "running", LDAP_INT_THREAD_POOL_RUNNING }, + { "finishing", LDAP_INT_THREAD_POOL_FINISHING }, + { "stopping", LDAP_INT_THREAD_POOL_STOPPING }, + { "pausing", LDAP_INT_THREAD_POOL_PAUSING }, + { NULL } + }; + int i; + + for ( i = 0; str2state[ i ].name != NULL; i++ ) { + if ( str2state[ i ].state == pool->ltp_state ) { + break; + } + } + *((char **)value) = str2state[ i ].name; + if ( str2state[ i ].name != NULL ) { + count = -2; + } + } break; + } + ldap_pvt_thread_mutex_unlock( &pool->ltp_mutex ); + + if ( count > -1 ) { + *((int *)value) = count; + } + + return ( count == -1 ? -1 : 0 ); +} + +/* + * wrapper for ldap_pvt_thread_pool_query(), left around + * for backwards compatibility + */ +int +ldap_pvt_thread_pool_backload ( ldap_pvt_thread_pool_t *tpool ) +{ + int rc, count; + + rc = ldap_pvt_thread_pool_query( tpool, + LDAP_PVT_THREAD_POOL_PARAM_BACKLOAD, (void *)&count ); + + if ( rc == 0 ) { + return count; + } + + return rc; } int diff --git a/servers/slapd/back-monitor/thread.c b/servers/slapd/back-monitor/thread.c index 3ca7207388..a7dbb5920a 100644 --- a/servers/slapd/back-monitor/thread.c +++ b/servers/slapd/back-monitor/thread.c @@ -35,6 +35,40 @@ monitor_subsys_thread_update( SlapReply *rs, Entry *e ); +typedef enum { + MT_UNKNOWN, + MT_RUNQUEUE, + MT_TASKLIST, + + MT_LAST +} monitor_thread_t; + +static struct { + struct berval rdn; + struct berval nrdn; + ldap_pvt_thread_pool_param_t param; + monitor_thread_t mt; +} mt[] = { + { BER_BVC( "cn=Max" ), BER_BVNULL, LDAP_PVT_THREAD_POOL_PARAM_MAX, MT_UNKNOWN }, + { BER_BVC( "cn=Max Pending" ), BER_BVNULL, LDAP_PVT_THREAD_POOL_PARAM_MAX_PENDING, MT_UNKNOWN }, + { BER_BVC( "cn=Open" ), BER_BVNULL, LDAP_PVT_THREAD_POOL_PARAM_OPEN, MT_UNKNOWN }, + { BER_BVC( "cn=Starting" ), BER_BVNULL, LDAP_PVT_THREAD_POOL_PARAM_STARTING, MT_UNKNOWN }, + { BER_BVC( "cn=Active" ), BER_BVNULL, LDAP_PVT_THREAD_POOL_PARAM_ACTIVE, MT_UNKNOWN }, + { BER_BVC( "cn=Pending" ), BER_BVNULL, LDAP_PVT_THREAD_POOL_PARAM_PENDING, MT_UNKNOWN }, + { BER_BVC( "cn=Backload" ), BER_BVNULL, LDAP_PVT_THREAD_POOL_PARAM_BACKLOAD, MT_UNKNOWN }, +#if 0 /* not meaningful right now */ + { BER_BVC( "cn=Active Max" ), BER_BVNULL, LDAP_PVT_THREAD_POOL_PARAM_ACTIVE_MAX, MT_UNKNOWN }, + { BER_BVC( "cn=Pending Max" ), BER_BVNULL, LDAP_PVT_THREAD_POOL_PARAM_PENDING_MAX, MT_UNKNOWN }, + { BER_BVC( "cn=Backload Max" ), BER_BVNULL, LDAP_PVT_THREAD_POOL_PARAM_BACKLOAD_MAX,MT_UNKNOWN }, +#endif + { BER_BVC( "cn=State" ), BER_BVNULL, LDAP_PVT_THREAD_POOL_PARAM_STATE, MT_UNKNOWN }, + + { BER_BVC( "cn=Runqueue" ), BER_BVNULL, LDAP_PVT_THREAD_POOL_PARAM_UNKNOWN, MT_RUNQUEUE }, + { BER_BVC( "cn=Tasklist" ), BER_BVNULL, LDAP_PVT_THREAD_POOL_PARAM_UNKNOWN, MT_TASKLIST }, + + { BER_BVNULL } +}; + /* * initializes log subentry */ @@ -47,8 +81,7 @@ monitor_subsys_thread_init( monitor_info_t *mi; monitor_entry_t *mp; Entry *e, **ep, *e_thread; - static char buf[ BACKMONITOR_BUFSIZE ]; - struct berval bv; + int i; ms->mss_update = monitor_subsys_thread_update; @@ -66,146 +99,74 @@ monitor_subsys_thread_init( mp->mp_children = NULL; ep = &mp->mp_children; - /* - * Max - */ - BER_BVSTR( &bv, "cn=Max" ); - e = monitor_entry_stub( &ms->mss_dn, &ms->mss_ndn, &bv, - mi->mi_oc_monitoredObject, mi, NULL, NULL ); - if ( e == NULL ) { - Debug( LDAP_DEBUG_ANY, - "monitor_subsys_thread_init: " - "unable to create entry \"cn=Max,%s\"\n", - ms->mss_ndn.bv_val, 0, 0 ); - return( -1 ); - } - bv.bv_len = snprintf( buf, sizeof( buf ), "%d", connection_pool_max ); - bv.bv_val = buf; - attr_merge_normalize_one( e, mi->mi_ad_monitoredInfo, &bv, NULL ); - - mp = monitor_entrypriv_create(); - if ( mp == NULL ) { - return -1; - } - e->e_private = ( void * )mp; - mp->mp_info = ms; - mp->mp_flags = ms->mss_flags \ - | MONITOR_F_SUB | MONITOR_F_PERSISTENT; + for ( i = 0; !BER_BVISNULL( &mt[ i ].rdn ); i++ ) { + static char buf[ BACKMONITOR_BUFSIZE ]; + int count = -1; + char *state = NULL; + struct berval bv = BER_BVNULL; + + /* + * Max + */ + e = monitor_entry_stub( &ms->mss_dn, &ms->mss_ndn, + &mt[ i ].rdn, + mi->mi_oc_monitoredObject, mi, NULL, NULL ); + if ( e == NULL ) { + Debug( LDAP_DEBUG_ANY, + "monitor_subsys_thread_init: " + "unable to create entry \"%s,%s\"\n", + mt[ i ].rdn.bv_val, + ms->mss_ndn.bv_val, 0 ); + return( -1 ); + } - if ( monitor_cache_add( mi, e ) ) { - Debug( LDAP_DEBUG_ANY, - "monitor_subsys_thread_init: " - "unable to add entry \"cn=Max,%s\"\n", - ms->mss_ndn.bv_val, 0, 0 ); - return( -1 ); - } - - *ep = e; - ep = &mp->mp_next; - - /* - * Backload - */ - BER_BVSTR( &bv, "cn=Backload" ); - e = monitor_entry_stub( &ms->mss_dn, &ms->mss_ndn, &bv, - mi->mi_oc_monitoredObject, mi, NULL, NULL ); - if ( e == NULL ) { - Debug( LDAP_DEBUG_ANY, - "monitor_subsys_thread_init: " - "unable to create entry \"cn=Backload,%s\"\n", - ms->mss_ndn.bv_val, 0, 0 ); - return( -1 ); - } - BER_BVSTR( &bv, "0" ); - attr_merge_normalize_one( e, mi->mi_ad_monitoredInfo, &bv, NULL ); + /* NOTE: reference to the normalized DN of the entry, + * under the assumption it's not modified */ + dnRdn( &e->e_nname, &mt[ i ].nrdn ); - mp = monitor_entrypriv_create(); - if ( mp == NULL ) { - return -1; - } - e->e_private = ( void * )mp; - mp->mp_info = ms; - mp->mp_flags = ms->mss_flags \ - | MONITOR_F_SUB | MONITOR_F_PERSISTENT; + switch ( mt[ i ].param ) { + case LDAP_PVT_THREAD_POOL_PARAM_UNKNOWN: + break; - if ( monitor_cache_add( mi, e ) ) { - Debug( LDAP_DEBUG_ANY, - "monitor_subsys_thread_init: " - "unable to add entry \"cn=Backload,%s\"\n", - ms->mss_ndn.bv_val, 0, 0 ); - return( -1 ); - } - - *ep = e; - ep = &mp->mp_next; - - /* - * Runqueue runners - */ - BER_BVSTR( &bv, "cn=Runqueue" ); - e = monitor_entry_stub( &ms->mss_dn, &ms->mss_ndn, &bv, - mi->mi_oc_monitoredObject, mi, NULL, NULL ); - if ( e == NULL ) { - Debug( LDAP_DEBUG_ANY, - "monitor_subsys_thread_init: " - "unable to create entry \"cn=Runqueue,%s\"\n", - ms->mss_ndn.bv_val, 0, 0 ); - return( -1 ); - } + case LDAP_PVT_THREAD_POOL_PARAM_STATE: + ldap_pvt_thread_pool_query( &connection_pool, + mt[ i ].param, (void *)&state ); + ber_str2bv( state, 0, 0, &bv ); + break; - mp = monitor_entrypriv_create(); - if ( mp == NULL ) { - return -1; - } - e->e_private = ( void * )mp; - mp->mp_info = ms; - mp->mp_flags = ms->mss_flags \ - | MONITOR_F_SUB | MONITOR_F_PERSISTENT; + default: + ldap_pvt_thread_pool_query( &connection_pool, + mt[ i ].param, (void *)&count ); + bv.bv_val = buf; + bv.bv_len = snprintf( buf, sizeof( buf ), "%d", count ); + break; + } - if ( monitor_cache_add( mi, e ) ) { - Debug( LDAP_DEBUG_ANY, - "monitor_subsys_thread_init: " - "unable to add entry \"cn=Runqueue,%s\"\n", - ms->mss_ndn.bv_val, 0, 0 ); - return( -1 ); - } + if ( !BER_BVISNULL( &bv ) ) { + attr_merge_normalize_one( e, mi->mi_ad_monitoredInfo, &bv, NULL ); + } - *ep = e; - ep = &mp->mp_next; - - /* - * Tasklist - */ - BER_BVSTR( &bv, "cn=Tasklist" ); - e = monitor_entry_stub( &ms->mss_dn, &ms->mss_ndn, &bv, - mi->mi_oc_monitoredObject, mi, NULL, NULL ); - if ( e == NULL ) { - Debug( LDAP_DEBUG_ANY, - "monitor_subsys_thread_init: " - "unable to create entry \"%s,%s\"\n", - bv.bv_val, ms->mss_ndn.bv_val, 0 ); - return( -1 ); - } - - mp = monitor_entrypriv_create(); - if ( mp == NULL ) { - return -1; - } - e->e_private = ( void * )mp; - mp->mp_info = ms; - mp->mp_flags = ms->mss_flags \ - | MONITOR_F_SUB | MONITOR_F_PERSISTENT; - - if ( monitor_cache_add( mi, e ) ) { - Debug( LDAP_DEBUG_ANY, - "monitor_subsys_thread_init: " - "unable to add entry \"%s\"\n", - e->e_name.bv_val, 0, 0 ); - return( -1 ); - } + mp = monitor_entrypriv_create(); + if ( mp == NULL ) { + return -1; + } + e->e_private = ( void * )mp; + mp->mp_info = ms; + mp->mp_flags = ms->mss_flags \ + | MONITOR_F_SUB | MONITOR_F_PERSISTENT; + + if ( monitor_cache_add( mi, e ) ) { + Debug( LDAP_DEBUG_ANY, + "monitor_subsys_thread_init: " + "unable to add entry \"%s,%s\"\n", + mt[ i ].rdn.bv_val, + ms->mss_ndn.bv_val, 0 ); + return( -1 ); + } - *ep = e; - ep = &mp->mp_next; + *ep = e; + ep = &mp->mp_next; + } monitor_cache_release( mi, e_thread ); @@ -222,124 +183,119 @@ monitor_subsys_thread_update( Attribute *a; BerVarray vals = NULL; char buf[ BACKMONITOR_BUFSIZE ]; - enum { - MT_UNKNOWN, - MT_MAX, - MT_BACKLOAD, - MT_RUNQUEUE, - MT_TASKLIST, - - MT_LAST - }; - static slap_verbmasks mt[] = { - { BER_BVC( "cn=max" ), MT_MAX }, - { BER_BVC( "cn=backload" ), MT_BACKLOAD }, - { BER_BVC( "cn=runqueue" ), MT_RUNQUEUE }, - { BER_BVC( "cn=tasklist" ), MT_TASKLIST }, - { BER_BVNULL, MT_UNKNOWN } - }; struct berval rdn, bv; int which, i; struct re_s *re; + int count = -1; + char *state = NULL; assert( mi != NULL ); dnRdn( &e->e_nname, &rdn ); - which = bverb_to_mask( &rdn, mt ); - if ( BER_BVISNULL( &mt[ which ].word ) - || mt[ which ].mask == MT_UNKNOWN ) - { + for ( i = 0; !BER_BVISNULL( &mt[ i ].nrdn ); i++ ) { + if ( dn_match( &mt[ i ].nrdn, &rdn ) ) { + which = i; + break; + } + } + + if ( BER_BVISNULL( &mt[ which ].nrdn ) ) { return SLAP_CB_CONTINUE; } a = attr_find( e->e_attrs, mi->mi_ad_monitoredInfo ); - switch ( mt[ which ].mask ) { - case MT_MAX: + switch ( mt[ which ].param ) { + case LDAP_PVT_THREAD_POOL_PARAM_UNKNOWN: + switch ( mt[ which ].mt ) { + case MT_RUNQUEUE: + if ( a != NULL ) { + if ( a->a_nvals != a->a_vals ) { + ber_bvarray_free( a->a_nvals ); + } + ber_bvarray_free( a->a_vals ); + a->a_vals = NULL; + a->a_nvals = NULL; + } + + i = 0; + bv.bv_val = buf; + ldap_pvt_thread_mutex_lock( &slapd_rq.rq_mutex ); + LDAP_STAILQ_FOREACH( re, &slapd_rq.run_list, rnext ) { + bv.bv_len = snprintf( buf, sizeof( buf ), "{%d}%s(%s)", + i, re->tname, re->tspec ); + if ( bv.bv_len < sizeof( buf ) ) { + value_add_one( &vals, &bv ); + } + i++; + } + ldap_pvt_thread_mutex_unlock( &slapd_rq.rq_mutex ); + + if ( vals ) { + attr_merge_normalize( e, mi->mi_ad_monitoredInfo, vals, NULL ); + ber_bvarray_free( vals ); + } + break; + + case MT_TASKLIST: + if ( a != NULL ) { + if ( a->a_nvals != a->a_vals ) { + ber_bvarray_free( a->a_nvals ); + } + ber_bvarray_free( a->a_vals ); + a->a_vals = NULL; + a->a_nvals = NULL; + } + + i = 0; + bv.bv_val = buf; + ldap_pvt_thread_mutex_lock( &slapd_rq.rq_mutex ); + LDAP_STAILQ_FOREACH( re, &slapd_rq.task_list, tnext ) { + bv.bv_len = snprintf( buf, sizeof( buf ), "{%d}%s(%s)", + i, re->tname, re->tspec ); + if ( bv.bv_len < sizeof( buf ) ) { + value_add_one( &vals, &bv ); + } + i++; + } + ldap_pvt_thread_mutex_unlock( &slapd_rq.rq_mutex ); + + if ( vals ) { + attr_merge_normalize( e, mi->mi_ad_monitoredInfo, vals, NULL ); + ber_bvarray_free( vals ); + } + break; + + default: + assert( 0 ); + } + break; + + case LDAP_PVT_THREAD_POOL_PARAM_STATE: if ( a == NULL ) { return rs->sr_err = LDAP_OTHER; } - bv.bv_val = buf; - bv.bv_len = snprintf( buf, sizeof( buf ), "%d", connection_pool_max ); - if ( bv.bv_len >= sizeof( buf ) ) { - /* FIXME? */ - break; - } + ldap_pvt_thread_pool_query( &connection_pool, + mt[ i ].param, (void *)&state ); + ber_str2bv( state, 0, 0, &bv ); ber_bvreplace( &a->a_vals[ 0 ], &bv ); break; - case MT_BACKLOAD: + default: if ( a == NULL ) { return rs->sr_err = LDAP_OTHER; } + ldap_pvt_thread_pool_query( &connection_pool, + mt[ i ].param, (void *)&count ); bv.bv_val = buf; - bv.bv_len = snprintf( buf, sizeof( buf ), "%d", - ldap_pvt_thread_pool_backload( &connection_pool ) ); + bv.bv_len = snprintf( buf, sizeof( buf ), "%d", count ); if ( bv.bv_len >= sizeof( buf ) ) { /* FIXME? */ break; } ber_bvreplace( &a->a_vals[ 0 ], &bv ); break; - - case MT_RUNQUEUE: - if ( a != NULL ) { - if ( a->a_nvals != a->a_vals ) { - ber_bvarray_free( a->a_nvals ); - } - ber_bvarray_free( a->a_vals ); - a->a_vals = NULL; - a->a_nvals = NULL; - } - - i = 0; - bv.bv_val = buf; - ldap_pvt_thread_mutex_lock( &slapd_rq.rq_mutex ); - LDAP_STAILQ_FOREACH( re, &slapd_rq.run_list, rnext ) { - bv.bv_len = snprintf( buf, sizeof( buf ), "{%d}%s(%s)", - i, re->tname, re->tspec ); - if ( bv.bv_len < sizeof( buf ) ) { - value_add_one( &vals, &bv ); - } - i++; - } - ldap_pvt_thread_mutex_unlock( &slapd_rq.rq_mutex ); - - if ( vals ) { - attr_merge_normalize( e, mi->mi_ad_monitoredInfo, vals, NULL ); - ber_bvarray_free( vals ); - } - break; - - case MT_TASKLIST: - if ( a != NULL ) { - if ( a->a_nvals != a->a_vals ) { - ber_bvarray_free( a->a_nvals ); - } - ber_bvarray_free( a->a_vals ); - a->a_vals = NULL; - a->a_nvals = NULL; - } - - i = 0; - bv.bv_val = buf; - ldap_pvt_thread_mutex_lock( &slapd_rq.rq_mutex ); - LDAP_STAILQ_FOREACH( re, &slapd_rq.task_list, tnext ) { - bv.bv_len = snprintf( buf, sizeof( buf ), "{%d}%s(%s)", - i, re->tname, re->tspec ); - if ( bv.bv_len < sizeof( buf ) ) { - value_add_one( &vals, &bv ); - } - i++; - } - ldap_pvt_thread_mutex_unlock( &slapd_rq.rq_mutex ); - - if ( vals ) { - attr_merge_normalize( e, mi->mi_ad_monitoredInfo, vals, NULL ); - ber_bvarray_free( vals ); - } - break; } /* FIXME: touch modifyTimestamp? */ -- 2.39.5