monitor __ALL__ thread parameters

diff --git a/include/ldap_pvt_thread.h b/include/ldap_pvt_thread.h
index fe8b5beb94d12f9c1a6accb45fb9ca23ae9246ff..c2c515f205d3422ab31de1ae8d7bd3971b7d3b71 100644 (file)
--- 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 4515d312ef6ff171e75b51df4b2d836792120150..32d13dd9dff1648222000439f0f3db087024396c 100644 (file)
--- 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 3ca7207388e0b306cd61b55e380a9ea7a2fa5a97..a7dbb5920a62344667c52d5a3d92879ab3a5ad39 100644 (file)
--- 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? */