thread.c revision 1.1.1.1.6.2
1 /* thread.c - deal with thread subsystem */ 2 /* $OpenLDAP: pkg/ldap/servers/slapd/back-monitor/thread.c,v 1.38.2.7 2008/02/11 23:26:47 kurt Exp $ */ 3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>. 4 * 5 * Copyright 2001-2008 The OpenLDAP Foundation. 6 * Portions Copyright 2001-2003 Pierangelo Masarati. 7 * All rights reserved. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted only as authorized by the OpenLDAP 11 * Public License. 12 * 13 * A copy of this license is available in file LICENSE in the 14 * top-level directory of the distribution or, alternatively, at 15 * <http://www.OpenLDAP.org/license.html>. 16 */ 17 /* ACKNOWLEDGEMENTS: 18 * This work was initially developed by Pierangelo Masarati for inclusion 19 * in OpenLDAP Software. 20 */ 21 22 #include "portable.h" 23 24 #include <stdio.h> 25 #include <ac/string.h> 26 27 #include "slap.h" 28 #include "back-monitor.h" 29 30 #include <ldap_rq.h> 31 32 #ifndef NO_THREADS 33 typedef enum { 34 MT_UNKNOWN, 35 MT_RUNQUEUE, 36 MT_TASKLIST, 37 38 MT_LAST 39 } monitor_thread_t; 40 41 static struct { 42 struct berval rdn; 43 struct berval desc; 44 struct berval nrdn; 45 ldap_pvt_thread_pool_param_t param; 46 monitor_thread_t mt; 47 } mt[] = { 48 { BER_BVC( "cn=Max" ), 49 BER_BVC("Maximum number of threads as configured"), 50 BER_BVNULL, LDAP_PVT_THREAD_POOL_PARAM_MAX, MT_UNKNOWN }, 51 { BER_BVC( "cn=Max Pending" ), 52 BER_BVC("Maximum number of pending threads"), 53 BER_BVNULL, LDAP_PVT_THREAD_POOL_PARAM_MAX_PENDING, MT_UNKNOWN }, 54 { BER_BVC( "cn=Open" ), 55 BER_BVC("Number of open threads"), 56 BER_BVNULL, LDAP_PVT_THREAD_POOL_PARAM_OPEN, MT_UNKNOWN }, 57 { BER_BVC( "cn=Starting" ), 58 BER_BVC("Number of threads being started"), 59 BER_BVNULL, LDAP_PVT_THREAD_POOL_PARAM_STARTING, MT_UNKNOWN }, 60 { BER_BVC( "cn=Active" ), 61 BER_BVC("Number of active threads"), 62 BER_BVNULL, LDAP_PVT_THREAD_POOL_PARAM_ACTIVE, MT_UNKNOWN }, 63 { BER_BVC( "cn=Pending" ), 64 BER_BVC("Number of pending threads"), 65 BER_BVNULL, LDAP_PVT_THREAD_POOL_PARAM_PENDING, MT_UNKNOWN }, 66 { BER_BVC( "cn=Backload" ), 67 BER_BVC("Number of active plus pending threads"), 68 BER_BVNULL, LDAP_PVT_THREAD_POOL_PARAM_BACKLOAD, MT_UNKNOWN }, 69 #if 0 /* not meaningful right now */ 70 { BER_BVC( "cn=Active Max" ), 71 BER_BVNULL, 72 BER_BVNULL, LDAP_PVT_THREAD_POOL_PARAM_ACTIVE_MAX, MT_UNKNOWN }, 73 { BER_BVC( "cn=Pending Max" ), 74 BER_BVNULL, 75 BER_BVNULL, LDAP_PVT_THREAD_POOL_PARAM_PENDING_MAX, MT_UNKNOWN }, 76 { BER_BVC( "cn=Backload Max" ), 77 BER_BVNULL, 78 BER_BVNULL, LDAP_PVT_THREAD_POOL_PARAM_BACKLOAD_MAX,MT_UNKNOWN }, 79 #endif 80 { BER_BVC( "cn=State" ), 81 BER_BVC("Thread pool state"), 82 BER_BVNULL, LDAP_PVT_THREAD_POOL_PARAM_STATE, MT_UNKNOWN }, 83 84 { BER_BVC( "cn=Runqueue" ), 85 BER_BVC("Queue of running threads - besides those handling operations"), 86 BER_BVNULL, LDAP_PVT_THREAD_POOL_PARAM_UNKNOWN, MT_RUNQUEUE }, 87 { BER_BVC( "cn=Tasklist" ), 88 BER_BVC("List of running plus standby threads - besides those handling operations"), 89 BER_BVNULL, LDAP_PVT_THREAD_POOL_PARAM_UNKNOWN, MT_TASKLIST }, 90 91 { BER_BVNULL } 92 }; 93 94 static int 95 monitor_subsys_thread_update( 96 Operation *op, 97 SlapReply *rs, 98 Entry *e ); 99 #endif /* ! NO_THREADS */ 100 101 /* 102 * initializes log subentry 103 */ 104 int 105 monitor_subsys_thread_init( 106 BackendDB *be, 107 monitor_subsys_t *ms ) 108 { 109 #ifndef NO_THREADS 110 monitor_info_t *mi; 111 monitor_entry_t *mp; 112 Entry *e, **ep, *e_thread; 113 int i; 114 115 ms->mss_update = monitor_subsys_thread_update; 116 117 mi = ( monitor_info_t * )be->be_private; 118 119 if ( monitor_cache_get( mi, &ms->mss_ndn, &e_thread ) ) { 120 Debug( LDAP_DEBUG_ANY, 121 "monitor_subsys_thread_init: unable to get entry \"%s\"\n", 122 ms->mss_dn.bv_val, 123 0, 0 ); 124 return( -1 ); 125 } 126 127 mp = ( monitor_entry_t * )e_thread->e_private; 128 mp->mp_children = NULL; 129 ep = &mp->mp_children; 130 131 for ( i = 0; !BER_BVISNULL( &mt[ i ].rdn ); i++ ) { 132 static char buf[ BACKMONITOR_BUFSIZE ]; 133 int count = -1; 134 char *state = NULL; 135 struct berval bv = BER_BVNULL; 136 137 /* 138 * Max 139 */ 140 e = monitor_entry_stub( &ms->mss_dn, &ms->mss_ndn, 141 &mt[ i ].rdn, 142 mi->mi_oc_monitoredObject, mi, NULL, NULL ); 143 if ( e == NULL ) { 144 Debug( LDAP_DEBUG_ANY, 145 "monitor_subsys_thread_init: " 146 "unable to create entry \"%s,%s\"\n", 147 mt[ i ].rdn.bv_val, 148 ms->mss_ndn.bv_val, 0 ); 149 return( -1 ); 150 } 151 152 /* NOTE: reference to the normalized DN of the entry, 153 * under the assumption it's not modified */ 154 dnRdn( &e->e_nname, &mt[ i ].nrdn ); 155 156 switch ( mt[ i ].param ) { 157 case LDAP_PVT_THREAD_POOL_PARAM_UNKNOWN: 158 break; 159 160 case LDAP_PVT_THREAD_POOL_PARAM_STATE: 161 if ( ldap_pvt_thread_pool_query( &connection_pool, 162 mt[ i ].param, (void *)&state ) == 0 ) 163 { 164 ber_str2bv( state, 0, 0, &bv ); 165 166 } else { 167 BER_BVSTR( &bv, "unknown" ); 168 } 169 break; 170 171 default: 172 /* NOTE: in case of error, it'll be set to -1 */ 173 (void)ldap_pvt_thread_pool_query( &connection_pool, 174 mt[ i ].param, (void *)&count ); 175 bv.bv_val = buf; 176 bv.bv_len = snprintf( buf, sizeof( buf ), "%d", count ); 177 break; 178 } 179 180 if ( !BER_BVISNULL( &bv ) ) { 181 attr_merge_normalize_one( e, mi->mi_ad_monitoredInfo, &bv, NULL ); 182 } 183 184 if ( !BER_BVISNULL( &mt[ i ].desc ) ) { 185 attr_merge_normalize_one( e, 186 slap_schema.si_ad_description, 187 &mt[ i ].desc, NULL ); 188 } 189 190 mp = monitor_entrypriv_create(); 191 if ( mp == NULL ) { 192 return -1; 193 } 194 e->e_private = ( void * )mp; 195 mp->mp_info = ms; 196 mp->mp_flags = ms->mss_flags \ 197 | MONITOR_F_SUB | MONITOR_F_PERSISTENT; 198 199 if ( monitor_cache_add( mi, e ) ) { 200 Debug( LDAP_DEBUG_ANY, 201 "monitor_subsys_thread_init: " 202 "unable to add entry \"%s,%s\"\n", 203 mt[ i ].rdn.bv_val, 204 ms->mss_dn.bv_val, 0 ); 205 return( -1 ); 206 } 207 208 *ep = e; 209 ep = &mp->mp_next; 210 } 211 212 monitor_cache_release( mi, e_thread ); 213 214 #endif /* ! NO_THREADS */ 215 return( 0 ); 216 } 217 218 #ifndef NO_THREADS 219 static int 220 monitor_subsys_thread_update( 221 Operation *op, 222 SlapReply *rs, 223 Entry *e ) 224 { 225 monitor_info_t *mi = ( monitor_info_t * )op->o_bd->be_private; 226 Attribute *a; 227 BerVarray vals = NULL; 228 char buf[ BACKMONITOR_BUFSIZE ]; 229 struct berval rdn, bv; 230 int which, i; 231 struct re_s *re; 232 int count = -1; 233 char *state = NULL; 234 235 assert( mi != NULL ); 236 237 dnRdn( &e->e_nname, &rdn ); 238 239 for ( i = 0; !BER_BVISNULL( &mt[ i ].nrdn ); i++ ) { 240 if ( dn_match( &mt[ i ].nrdn, &rdn ) ) { 241 break; 242 } 243 } 244 245 which = i; 246 if ( BER_BVISNULL( &mt[ which ].nrdn ) ) { 247 return SLAP_CB_CONTINUE; 248 } 249 250 a = attr_find( e->e_attrs, mi->mi_ad_monitoredInfo ); 251 252 switch ( mt[ which ].param ) { 253 case LDAP_PVT_THREAD_POOL_PARAM_UNKNOWN: 254 switch ( mt[ which ].mt ) { 255 case MT_RUNQUEUE: 256 if ( a != NULL ) { 257 if ( a->a_nvals != a->a_vals ) { 258 ber_bvarray_free( a->a_nvals ); 259 } 260 ber_bvarray_free( a->a_vals ); 261 a->a_vals = NULL; 262 a->a_nvals = NULL; 263 a->a_numvals = 0; 264 } 265 266 i = 0; 267 bv.bv_val = buf; 268 ldap_pvt_thread_mutex_lock( &slapd_rq.rq_mutex ); 269 LDAP_STAILQ_FOREACH( re, &slapd_rq.run_list, rnext ) { 270 bv.bv_len = snprintf( buf, sizeof( buf ), "{%d}%s(%s)", 271 i, re->tname, re->tspec ); 272 if ( bv.bv_len < sizeof( buf ) ) { 273 value_add_one( &vals, &bv ); 274 } 275 i++; 276 } 277 ldap_pvt_thread_mutex_unlock( &slapd_rq.rq_mutex ); 278 279 if ( vals ) { 280 attr_merge_normalize( e, mi->mi_ad_monitoredInfo, vals, NULL ); 281 ber_bvarray_free( vals ); 282 283 } else { 284 attr_delete( &e->e_attrs, mi->mi_ad_monitoredInfo ); 285 } 286 break; 287 288 case MT_TASKLIST: 289 if ( a != NULL ) { 290 if ( a->a_nvals != a->a_vals ) { 291 ber_bvarray_free( a->a_nvals ); 292 } 293 ber_bvarray_free( a->a_vals ); 294 a->a_vals = NULL; 295 a->a_nvals = NULL; 296 a->a_numvals = 0; 297 } 298 299 i = 0; 300 bv.bv_val = buf; 301 ldap_pvt_thread_mutex_lock( &slapd_rq.rq_mutex ); 302 LDAP_STAILQ_FOREACH( re, &slapd_rq.task_list, tnext ) { 303 bv.bv_len = snprintf( buf, sizeof( buf ), "{%d}%s(%s)", 304 i, re->tname, re->tspec ); 305 if ( bv.bv_len < sizeof( buf ) ) { 306 value_add_one( &vals, &bv ); 307 } 308 i++; 309 } 310 ldap_pvt_thread_mutex_unlock( &slapd_rq.rq_mutex ); 311 312 if ( vals ) { 313 attr_merge_normalize( e, mi->mi_ad_monitoredInfo, vals, NULL ); 314 ber_bvarray_free( vals ); 315 316 } else { 317 attr_delete( &e->e_attrs, mi->mi_ad_monitoredInfo ); 318 } 319 break; 320 321 default: 322 assert( 0 ); 323 } 324 break; 325 326 case LDAP_PVT_THREAD_POOL_PARAM_STATE: 327 if ( a == NULL ) { 328 return rs->sr_err = LDAP_OTHER; 329 } 330 if ( ldap_pvt_thread_pool_query( &connection_pool, 331 mt[ i ].param, (void *)&state ) == 0 ) 332 { 333 ber_str2bv( state, 0, 0, &bv ); 334 ber_bvreplace( &a->a_vals[ 0 ], &bv ); 335 } 336 break; 337 338 default: 339 if ( a == NULL ) { 340 return rs->sr_err = LDAP_OTHER; 341 } 342 if ( ldap_pvt_thread_pool_query( &connection_pool, 343 mt[ i ].param, (void *)&count ) == 0 ) 344 { 345 bv.bv_val = buf; 346 bv.bv_len = snprintf( buf, sizeof( buf ), "%d", count ); 347 if ( bv.bv_len < sizeof( buf ) ) { 348 ber_bvreplace( &a->a_vals[ 0 ], &bv ); 349 } 350 } 351 break; 352 } 353 354 /* FIXME: touch modifyTimestamp? */ 355 356 return SLAP_CB_CONTINUE; 357 } 358 #endif /* ! NO_THREADS */ 359
Indexes created Thu Aug 06 00:25:04 UTC 2026