SLAPD_SQL_INCLUDES = @SLAPD_SQL_INCLUDES@
SLAPD_SQL_LIBS = @SLAPD_SQL_LIBS@
-SLAPD_LIBS = @SLAPD_LIBS@ @SLAPD_PERL_LDFLAGS@ @SLAPD_SQL_LDFLAGS@ @SLAPD_SQL_LIBS@ @SLAPD_SLP_LIBS@
+SLAPD_LIBS = @SLAPD_LIBS@ @SLAPD_PERL_LDFLAGS@ @SLAPD_SQL_LDFLAGS@ @SLAPD_SQL_LIBS@ @SLAPD_SLP_LIBS@ @SLAPD_GMP_LIBS@
SLURPD_LIBS = @SLURPD_LIBS@
# Our Defaults
AUTH_LIBS=
SLAPD_SLP_LIBS=
+SLAPD_GMP_LIBS=
dnl ================================================================
dnl Checks for programs
fi
fi
+dnl ----------------------------------------------------------------
+dnl Check for GMP API Library
+AC_CHECK_HEADERS( gmp.h )
+
+if test $ac_cv_header_gmp_h = yes ; then
+ AC_CHECK_LIB(gmp, __gmpz_add_ui, [have_gmp=yes], [have_gmp=no])
+ if test $have_gmp = yes ; then
+ AC_DEFINE(HAVE_GMP, 1, [define if you have -lgmp])
+ SLAPD_GMP_LIBS=-lgmp
+ fi
+fi
+
dnl ----------------------------------------------------------------
dnl Checks for typedefs, structures, and compiler characteristics.
AC_SUBST(AUTH_LIBS)
AC_SUBST(SLAPD_SLP_LIBS)
+AC_SUBST(SLAPD_GMP_LIBS)
AC_SUBST(SLAPD_SQL_LDFLAGS)
AC_SUBST(SLAPD_SQL_LIBS)
#include "back-monitor.h"
#include "lber_pvt.h"
-static struct berval
- bv_op[] = {
- BER_BVC( "Bind" ),
- BER_BVC( "Unbind" ),
- BER_BVC( "Add" ),
- BER_BVC( "Delete" ),
- BER_BVC( "Modrdn" ),
- BER_BVC( "Modify" ),
- BER_BVC( "Compare" ),
- BER_BVC( "Search" ),
- BER_BVC( "Abandon" ),
- BER_BVC( "Extended" ),
- BER_BVNULL
- };
+struct monitor_ops_t {
+ struct berval rdn;
+ struct berval nrdn;
+} monitor_op[] = {
+ { BER_BVC( "cn=Bind" ), BER_BVC( "cn=bind" ) },
+ { BER_BVC( "cn=Unbind" ), BER_BVC( "cn=unbind" ) },
+ { BER_BVC( "cn=Add" ), BER_BVC( "cn=add" ) },
+ { BER_BVC( "cn=Delete" ), BER_BVC( "cn=delete" ) },
+ { BER_BVC( "cn=Modrdn" ), BER_BVC( "cn=modrdn" ) },
+ { BER_BVC( "cn=Modify" ), BER_BVC( "cn=modify" ) },
+ { BER_BVC( "cn=Compare" ), BER_BVC( "cn=compare" ) },
+ { BER_BVC( "cn=Search" ), BER_BVC( "cn=search" ) },
+ { BER_BVC( "cn=Abandon" ), BER_BVC( "cn=abandon" ) },
+ { BER_BVC( "cn=Extended" ), BER_BVC( "cn=extended" ) },
+ { BER_BVNULL, BER_BVNULL }
+};
int
monitor_subsys_ops_init(
&monitor_subsys[SLAPD_MONITOR_OPS].mss_ndn, &e_op ) ) {
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_ops_init: "
- "unable to get entry '%s'\n%s%s",
+ "unable to get entry \"%s\"\n",
monitor_subsys[SLAPD_MONITOR_OPS].mss_ndn.bv_val,
- "", "" );
+ 0, 0 );
return( -1 );
}
* Initiated ops
*/
snprintf( buf, sizeof( buf ),
- "dn: cn=%s,%s\n"
+ "dn: %s,%s\n"
"objectClass: %s\n"
"structuralObjectClass: %s\n"
"cn: %s\n"
"modifiersName: %s\n"
"createTimestamp: %s\n"
"modifyTimestamp: %s\n",
- bv_op[ i ].bv_val,
+ monitor_op[ i ].rdn.bv_val,
monitor_subsys[SLAPD_MONITOR_OPS].mss_dn.bv_val,
mi->mi_oc_monitorOperation->soc_cname.bv_val,
mi->mi_oc_monitorOperation->soc_cname.bv_val,
- bv_op[ i ].bv_val,
+ &monitor_op[ i ].rdn.bv_val[STRLENOF( "cn=" )],
mi->mi_ad_monitorOpInitiated->ad_cname.bv_val,
mi->mi_ad_monitorOpCompleted->ad_cname.bv_val,
mi->mi_creatorsName.bv_val,
if ( e == NULL ) {
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_ops_init: "
- "unable to create entry 'cn=%s,%s'\n",
- bv_op[ i ].bv_val,
+ "unable to create entry \"%s,%s\"\n",
+ monitor_op[ i ].rdn.bv_val,
monitor_subsys[SLAPD_MONITOR_OPS].mss_ndn.bv_val, 0 );
return( -1 );
}
if ( monitor_cache_add( mi, e ) ) {
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_ops_init: "
- "unable to add entry 'cn=%s,%s'\n",
- bv_op[ i ].bv_val,
+ "unable to add entry \"%s,%s\"\n",
+ monitor_op[ i ].rdn.bv_val,
monitor_subsys[SLAPD_MONITOR_OPS].mss_ndn.bv_val, 0 );
return( -1 );
}
Entry *e
)
{
- struct monitorinfo *mi = (struct monitorinfo *)op->o_bd->be_private;
- long nInitiated = 0, nCompleted = 0;
- char *rdnvalue;
- int i;
- Attribute *a;
- char buf[] = "+9223372036854775807L";
+ struct monitorinfo *mi =
+ (struct monitorinfo *)op->o_bd->be_private;
+
+#ifdef HAVE_GMP
+ mpz_t nInitiated,
+ nCompleted;
+#else /* ! HAVE_GMP */
+ unsigned long nInitiated = 0,
+ nCompleted = 0;
+ char buf[] = "+9223372036854775807L";
+#endif /* ! HAVE_GMP */
+ struct berval rdn;
+ int i;
+ Attribute *a;
+ static struct berval bv_ops = BER_BVC( "cn=operations" );
assert( mi );
assert( e );
- rdnvalue = e->e_dn + ( sizeof( "cn=" ) - 1 );
+ dnRdn( &e->e_nname, &rdn );
- if ( strncmp( rdnvalue, SLAPD_MONITOR_OPS_NAME,
- sizeof( SLAPD_MONITOR_OPS_NAME ) - 1 ) == 0 )
- {
+ if ( dn_match( &rdn, &bv_ops ) ) {
+#ifdef HAVE_GMP
+ mpz_init( nInitiated );
+ mpz_init( nCompleted );
+#endif /* ! HAVE_GMP */
+
+ ldap_pvt_thread_mutex_lock( &slap_counters.sc_ops_mutex );
for ( i = 0; i < SLAP_OP_LAST; i++ ) {
- nInitiated += num_ops_initiated_[ i ];
- nCompleted += num_ops_completed_[ i ];
+#ifdef HAVE_GMP
+ mpz_add( nInitiated, nInitiated, slap_counters.sc_ops_initiated_[ i ] );
+ mpz_add( nCompleted, nCompleted, slap_counters.sc_ops_completed_[ i ] );
+#else /* ! HAVE_GMP */
+ nInitiated += slap_counter.sc_ops_initiated_[ i ];
+ nCompleted += slap_counter.sc_ops_completed_[ i ];
+#endif /* ! HAVE_GMP */
}
+ ldap_pvt_thread_mutex_unlock( &slap_counters.sc_ops_mutex );
} else {
for ( i = 0; i < SLAP_OP_LAST; i++ ) {
- if ( strncmp( rdnvalue, bv_op[ i ].bv_val,
- bv_op[ i ].bv_len ) == 0 )
+ if ( dn_match( &rdn, &monitor_op[ i ].nrdn ) )
{
- nInitiated = num_ops_initiated_[ i ];
- nCompleted = num_ops_completed_[ i ];
+ ldap_pvt_thread_mutex_lock( &slap_counters.sc_ops_mutex );
+#ifdef HAVE_GMP
+ mpz_init_set( nInitiated, slap_counters.sc_ops_initiated_[ i ] );
+ mpz_init_set( nCompleted, slap_counters.sc_ops_completed_[ i ] );
+#else /* ! HAVE_GMP */
+ nInitiated = slap_counter.sc_ops_initiated_[ i ];
+ nCompleted = slap_counter.sc_ops_completed_[ i ];
+#endif /* ! HAVE_GMP */
+ ldap_pvt_thread_mutex_unlock( &slap_counters.sc_ops_mutex );
break;
}
}
a = attr_find( e->e_attrs, mi->mi_ad_monitorOpInitiated );
assert ( a != NULL );
- snprintf( buf, sizeof( buf ), "%ld", nInitiated );
free( a->a_vals[ 0 ].bv_val );
+#ifdef HAVE_GMP
+ /* NOTE: there should be no minus sign allowed in the counters... */
+ a->a_vals[ 0 ].bv_len = mpz_sizeinbase( nInitiated, 10 );
+ a->a_vals[ 0 ].bv_val = ber_memalloc( a->a_vals[ 0 ].bv_len + 1 );
+ (void)mpz_get_str( a->a_vals[ 0 ].bv_val, 10, nInitiated );
+ mpz_clear( nInitiated );
+ /* NOTE: according to the documentation, the result
+ * of mpz_sizeinbase() can exceed the length of the
+ * string representation of the number by 1
+ */
+ if ( a->a_vals[ 0 ].bv_val[ a->a_vals[ 0 ].bv_len - 1 ] == '\0' ) {
+ a->a_vals[ 0 ].bv_len--;
+ }
+#else /* ! HAVE_GMP */
+ snprintf( buf, sizeof( buf ), "%ld", nInitiated );
ber_str2bv( buf, 0, 1, &a->a_vals[ 0 ] );
-
+#endif /* ! HAVE_GMP */
+
a = attr_find( e->e_attrs, mi->mi_ad_monitorOpCompleted );
assert ( a != NULL );
- snprintf( buf, sizeof( buf ), "%ld", nCompleted );
free( a->a_vals[ 0 ].bv_val );
+#ifdef HAVE_GMP
+ /* NOTE: there should be no minus sign allowed in the counters... */
+ a->a_vals[ 0 ].bv_len = mpz_sizeinbase( nCompleted, 10 );
+ a->a_vals[ 0 ].bv_val = ber_memalloc( a->a_vals[ 0 ].bv_len + 1 );
+ (void)mpz_get_str( a->a_vals[ 0 ].bv_val, 10, nCompleted );
+ mpz_clear( nCompleted );
+ /* NOTE: according to the documentation, the result
+ * of mpz_sizeinbase() can exceed the length of the
+ * string representation of the number by 1
+ */
+ if ( a->a_vals[ 0 ].bv_val[ a->a_vals[ 0 ].bv_len - 1 ] == '\0' ) {
+ a->a_vals[ 0 ].bv_len--;
+ }
+#else /* ! HAVE_GMP */
+ snprintf( buf, sizeof( buf ), "%ld", nCompleted );
ber_str2bv( buf, 0, 1, &a->a_vals[ 0 ] );
-
+#endif /* ! HAVE_GMP */
+
return( 0 );
}
struct berval rdn;
struct berval nrdn;
} monitor_sent[] = {
+ { BER_BVC("cn=Bytes"), BER_BVC("cn=bytes") },
+ { BER_BVC("cn=PDU"), BER_BVC("cn=pdu") },
{ BER_BVC("cn=Entries"), BER_BVC("cn=entries") },
{ BER_BVC("cn=Referrals"), BER_BVC("cn=referrals") },
- { BER_BVC("cn=PDU"), BER_BVC("cn=pdu") },
- { BER_BVC("cn=Bytes"), BER_BVC("cn=bytes") },
{ BER_BVNULL, BER_BVNULL }
};
(struct monitorinfo *)op->o_bd->be_private;
struct berval rdn;
+#ifdef HAVE_GMP
+ mpz_t n;
+#else /* ! HAVE_GMP */
unsigned long n;
+#endif /* ! HAVE_GMP */
Attribute *a;
+#ifndef HAVE_GMP
char buf[] = "+9223372036854775807L";
+#endif /* ! HAVE_GMP */
int i;
assert( mi );
return 0;
}
- ldap_pvt_thread_mutex_lock(&num_sent_mutex);
+ ldap_pvt_thread_mutex_lock(&slap_counters.sc_sent_mutex);
switch ( i ) {
case MONITOR_SENT_ENTRIES:
- n = num_entries_sent;
+#ifdef HAVE_GMP
+ mpz_init_set( n, slap_counters.sc_entries );
+#else /* ! HAVE_GMP */
+ n = slap_counters.sc_entries;
+#endif /* ! HAVE_GMP */
break;
case MONITOR_SENT_REFERRALS:
- n = num_refs_sent;
+#ifdef HAVE_GMP
+ mpz_init_set( n, slap_counters.sc_refs );
+#else /* ! HAVE_GMP */
+ n = slap_counters.sc_refs;
+#endif /* ! HAVE_GMP */
break;
case MONITOR_SENT_PDU:
- n = num_pdu_sent;
+#ifdef HAVE_GMP
+ mpz_init_set( n, slap_counters.sc_pdu );
+#else /* ! HAVE_GMP */
+ n = slap_counters.sc_pdu;
+#endif /* ! HAVE_GMP */
break;
case MONITOR_SENT_BYTES:
- n = num_bytes_sent;
+#ifdef HAVE_GMP
+ mpz_init_set( n, slap_counters.sc_bytes );
+#else /* ! HAVE_GMP */
+ n = slap_counters.sc_bytes;
+#endif /* ! HAVE_GMP */
break;
default:
assert(0);
}
- ldap_pvt_thread_mutex_unlock(&num_sent_mutex);
+ ldap_pvt_thread_mutex_unlock(&slap_counters.sc_sent_mutex);
a = attr_find( e->e_attrs, mi->mi_ad_monitorCounter );
if ( a == NULL ) {
return -1;
}
- snprintf( buf, sizeof( buf ), "%lu", n );
free( a->a_vals[ 0 ].bv_val );
+#ifdef HAVE_GMP
+ /* NOTE: there should be no minus sign allowed in the counters... */
+ a->a_vals[ 0 ].bv_len = mpz_sizeinbase( n, 10 );
+ a->a_vals[ 0 ].bv_val = ber_memalloc( a->a_vals[ 0 ].bv_len + 1 );
+ (void)mpz_get_str( a->a_vals[ 0 ].bv_val, 10, n );
+ mpz_clear( n );
+ /* NOTE: according to the documentation, the result
+ * of mpz_sizeinbase() can exceed the length of the
+ * string representation of the number by 1
+ */
+ if ( a->a_vals[ 0 ].bv_val[ a->a_vals[ 0 ].bv_len - 1 ] == '\0' ) {
+ a->a_vals[ 0 ].bv_len--;
+ }
+#else /* ! HAVE_GMP */
+ snprintf( buf, sizeof( buf ), "%lu", n );
ber_str2bv( buf, 0, 1, &a->a_vals[ 0 ] );
+#endif /* ! HAVE_GMP */
return 0;
}
*/
#ifdef SLAPD_MONITOR
-#define INCR_OP(var,index) \
+#ifdef HAVE_GMP
+#define INCR_OP_INITIATED(index) \
do { \
- ldap_pvt_thread_mutex_lock( &num_ops_mutex ); \
- (var)[(index)]++; \
- ldap_pvt_thread_mutex_unlock( &num_ops_mutex ); \
+ ldap_pvt_thread_mutex_lock( &slap_counters.sc_ops_mutex ); \
+ mpz_add_ui(slap_counters.sc_ops_initiated_[(index)], \
+ slap_counters.sc_ops_initiated_[(index)], 1); \
+ ldap_pvt_thread_mutex_unlock( &slap_counters.sc_ops_mutex ); \
} while (0)
+#define INCR_OP_COMPLETED(index) \
+ do { \
+ ldap_pvt_thread_mutex_lock( &slap_counters.sc_ops_mutex ); \
+ mpz_add_ui(slap_counters.sc_ops_completed, \
+ slap_counters.sc_ops_completed, 1); \
+ mpz_add_ui(slap_counters.sc_ops_completed_[(index)], \
+ slap_counters.sc_ops_completed_[(index)], 1); \
+ ldap_pvt_thread_mutex_unlock( &slap_counters.sc_ops_mutex ); \
+ } while (0)
+#else /* ! HAVE_GMP */
+#define INCR_OP_INITIATED(index) \
+ do { \
+ ldap_pvt_thread_mutex_lock( &slap_counters.sc_ops_mutex ); \
+ slap_counters.sc_ops_initiated_[(index)]++; \
+ ldap_pvt_thread_mutex_unlock( &slap_counters.sc_ops_mutex ); \
+ } while (0)
+#define INCR_OP_COMPLETED(index) \
+ do { \
+ ldap_pvt_thread_mutex_lock( &slap_counters.sc_ops_mutex ); \
+ slap_counters.sc_ops_completed++; \
+ slap_counters.sc_ops_completed_[(index)]++; \
+ ldap_pvt_thread_mutex_unlock( &slap_counters.sc_ops_mutex ); \
+ } while (0)
+#endif /* ! HAVE_GMP */
#else /* !SLAPD_MONITOR */
-#define INCR_OP(var,index)
+#define INCR_OP_INITIATED(index)
+#define INCR_OP_COMPLETED(index)
#endif /* !SLAPD_MONITOR */
static void *
void *memctx_null = NULL;
ber_len_t memsiz;
- ldap_pvt_thread_mutex_lock( &num_ops_mutex );
- num_ops_initiated++;
- ldap_pvt_thread_mutex_unlock( &num_ops_mutex );
+ ldap_pvt_thread_mutex_lock( &slap_counters.sc_ops_mutex );
+#ifdef HAVE_GMP
+ mpz_add_ui(slap_counters.sc_ops_initiated, slap_counters.sc_ops_initiated, 1);
+#else /* ! HAVE_GMP */
+ slap_counters.sc_ops_initiated++;
+#endif /* ! HAVE_GMP */
+ ldap_pvt_thread_mutex_unlock( &slap_counters.sc_ops_mutex );
op->o_threadctx = ctx;
switch ( tag ) {
case LDAP_REQ_BIND:
- INCR_OP(num_ops_initiated_, SLAP_OP_BIND);
+ INCR_OP_INITIATED(SLAP_OP_BIND);
rc = do_bind( op, &rs );
break;
case LDAP_REQ_UNBIND:
- INCR_OP(num_ops_initiated_, SLAP_OP_UNBIND);
+ INCR_OP_INITIATED(SLAP_OP_UNBIND);
rc = do_unbind( op, &rs );
break;
case LDAP_REQ_ADD:
- INCR_OP(num_ops_initiated_, SLAP_OP_ADD);
+ INCR_OP_INITIATED(SLAP_OP_ADD);
rc = do_add( op, &rs );
break;
case LDAP_REQ_DELETE:
- INCR_OP(num_ops_initiated_, SLAP_OP_DELETE);
+ INCR_OP_INITIATED(SLAP_OP_DELETE);
rc = do_delete( op, &rs );
break;
case LDAP_REQ_MODRDN:
- INCR_OP(num_ops_initiated_, SLAP_OP_MODRDN);
+ INCR_OP_INITIATED(SLAP_OP_MODRDN);
rc = do_modrdn( op, &rs );
break;
case LDAP_REQ_MODIFY:
- INCR_OP(num_ops_initiated_, SLAP_OP_MODIFY);
+ INCR_OP_INITIATED(SLAP_OP_MODIFY);
rc = do_modify( op, &rs );
break;
case LDAP_REQ_COMPARE:
- INCR_OP(num_ops_initiated_, SLAP_OP_COMPARE);
+ INCR_OP_INITIATED(SLAP_OP_COMPARE);
rc = do_compare( op, &rs );
break;
case LDAP_REQ_SEARCH:
- INCR_OP(num_ops_initiated_, SLAP_OP_SEARCH);
+ INCR_OP_INITIATED(SLAP_OP_SEARCH);
rc = do_search( op, &rs );
break;
case LDAP_REQ_ABANDON:
- INCR_OP(num_ops_initiated_, SLAP_OP_ABANDON);
+ INCR_OP_INITIATED(SLAP_OP_ABANDON);
rc = do_abandon( op, &rs );
break;
case LDAP_REQ_EXTENDED:
- INCR_OP(num_ops_initiated_, SLAP_OP_EXTENDED);
+ INCR_OP_INITIATED(SLAP_OP_EXTENDED);
rc = do_extended( op, &rs );
break;
operations_error:
if( rc == SLAPD_DISCONNECT ) tag = LBER_ERROR;
- ldap_pvt_thread_mutex_lock( &num_ops_mutex );
-
- num_ops_completed++;
#ifdef SLAPD_MONITOR
switch (oldtag) {
case LDAP_REQ_BIND:
- num_ops_completed_[SLAP_OP_BIND]++;
+ INCR_OP_COMPLETED(SLAP_OP_BIND);
break;
case LDAP_REQ_UNBIND:
- num_ops_completed_[SLAP_OP_UNBIND]++;
+ INCR_OP_COMPLETED(SLAP_OP_UNBIND);
break;
case LDAP_REQ_ADD:
- num_ops_completed_[SLAP_OP_ADD]++;
+ INCR_OP_COMPLETED(SLAP_OP_ADD);
break;
case LDAP_REQ_DELETE:
- num_ops_completed_[SLAP_OP_DELETE]++;
+ INCR_OP_COMPLETED(SLAP_OP_DELETE);
break;
case LDAP_REQ_MODRDN:
- num_ops_completed_[SLAP_OP_MODRDN]++;
+ INCR_OP_COMPLETED(SLAP_OP_MODRDN);
break;
case LDAP_REQ_MODIFY:
- num_ops_completed_[SLAP_OP_MODIFY]++;
+ INCR_OP_COMPLETED(SLAP_OP_MODIFY);
break;
case LDAP_REQ_COMPARE:
- num_ops_completed_[SLAP_OP_COMPARE]++;
+ INCR_OP_COMPLETED(SLAP_OP_COMPARE);
break;
case LDAP_REQ_SEARCH:
- num_ops_completed_[SLAP_OP_SEARCH]++;
+ INCR_OP_COMPLETED(SLAP_OP_SEARCH);
break;
case LDAP_REQ_ABANDON:
- num_ops_completed_[SLAP_OP_ABANDON]++;
+ INCR_OP_COMPLETED(SLAP_OP_ABANDON);
break;
case LDAP_REQ_EXTENDED:
- num_ops_completed_[SLAP_OP_EXTENDED]++;
+ INCR_OP_COMPLETED(SLAP_OP_EXTENDED);
break;
default:
/* not reachable */
assert( 0 );
}
#endif /* SLAPD_MONITOR */
- ldap_pvt_thread_mutex_unlock( &num_ops_mutex );
+ ldap_pvt_thread_mutex_unlock( &slap_counters.sc_ops_mutex );
if ( op->o_cancel == SLAP_CANCEL_REQ ) {
op->o_cancel = LDAP_TOO_LATE;
ldap_pvt_thread_mutex_t passwd_mutex;
#endif
-unsigned long num_ops_initiated = 0;
-unsigned long num_ops_completed = 0;
-#ifdef SLAPD_MONITOR
-unsigned long num_ops_initiated_[SLAP_OP_LAST];
-unsigned long num_ops_completed_[SLAP_OP_LAST];
-#endif /* SLAPD_MONITOR */
-ldap_pvt_thread_mutex_t num_ops_mutex;
+slap_counters_t slap_counters;
-unsigned long num_entries_sent;
-unsigned long num_refs_sent;
-unsigned long num_bytes_sent;
-unsigned long num_pdu_sent;
-ldap_pvt_thread_mutex_t num_sent_mutex;
/*
* these mutexes must be used when calling the entry2str()
* routine since it returns a pointer to static data.
slap_init( int mode, const char *name )
{
int rc;
+ int i;
assert( mode );
- if( slapMode != SLAP_UNDEFINED_MODE ) {
+ if ( slapMode != SLAP_UNDEFINED_MODE ) {
Debug( LDAP_DEBUG_ANY,
"%s init: init called twice (old=%d, new=%d)\n",
name, slapMode, mode );
slapMode = mode;
switch ( slapMode & SLAP_MODE ) {
- case SLAP_SERVER_MODE:
- case SLAP_TOOL_MODE:
- Debug( LDAP_DEBUG_TRACE,
- "%s init: initiated %s.\n", name,
- (mode & SLAP_MODE) == SLAP_TOOL_MODE ? "tool" : "server",
- 0 );
+ case SLAP_SERVER_MODE:
+ 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;
- slap_name = name;
-
- (void) ldap_pvt_thread_initialize();
+ (void) ldap_pvt_thread_initialize();
- ldap_pvt_thread_pool_init( &connection_pool,
+ 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( &num_ops_mutex );
- ldap_pvt_thread_mutex_init( &num_sent_mutex );
+ 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 );
+#ifdef HAVE_GMP
+ mpz_init( slap_counters.sc_bytes );
+ mpz_init( slap_counters.sc_pdu );
+ mpz_init( slap_counters.sc_entries );
+ mpz_init( slap_counters.sc_refs );
+
+ mpz_init( slap_counters.sc_ops_completed );
+ mpz_init( slap_counters.sc_ops_initiated );
#ifdef SLAPD_MONITOR
- {
- int i;
- for ( i = 0; i < SLAP_OP_LAST; i++ ) {
- num_ops_initiated_[ i ] = 0;
- num_ops_completed_[ i ] = 0;
- }
- }
-#endif
+ for ( i = 0; i < SLAP_OP_LAST; i++ ) {
+ mpz_init( slap_counters.sc_ops_initiated_[ i ] );
+ mpz_init( slap_counters.sc_ops_completed_[ i ] );
+ }
+#endif /* SLAPD_MONITOR */
+#else /* ! HAVE_GMP */
+ slap_counters.sc_bytes = 0;
+ slap_counters.sc_pdu = 0;
+ slap_counters.sc_entries = 0;
+ slap_counters.sc_refs = 0;
+
+ slap_counters.sc_ops_completed = 0;
+ slap_counters.sc_ops_initiated = 0;
+#ifdef SLAPD_MONITOR
+ for ( i = 0; i < SLAP_OP_LAST; i++ ) {
+ slap_counters.sc_ops_initiated_[ i ] = 0;
+ slap_counters.sc_ops_completed_[ i ] = 0;
+ }
+#endif /* SLAPD_MONITOR */
+#endif /* ! HAVE_GMP */
#ifndef HAVE_GMTIME_R
- ldap_pvt_thread_mutex_init( &gmtime_mutex );
+ ldap_pvt_thread_mutex_init( &gmtime_mutex );
#endif
#if defined( SLAPD_CRYPT ) || defined( SLAPD_SPASSWD )
- ldap_pvt_thread_mutex_init( &passwd_mutex );
+ ldap_pvt_thread_mutex_init( &passwd_mutex );
#endif
- rc = slap_sasl_init();
+ rc = slap_sasl_init();
- if( rc == 0 ) {
- rc = backend_init( );
- }
+ if( rc == 0 ) {
+ rc = backend_init( );
+ }
- break;
+ break;
- default:
- Debug( LDAP_DEBUG_ANY,
- "%s init: undefined mode (%d).\n", name, mode, 0 );
+ default:
+ Debug( LDAP_DEBUG_ANY,
+ "%s init: undefined mode (%d).\n", name, mode, 0 );
- rc = 1;
- break;
+ rc = 1;
+ break;
}
return rc;
int slap_destroy(void)
{
int rc;
+ int i;
Debug( LDAP_DEBUG_TRACE,
"%s destroy: freeing system resources.\n",
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 );
+#ifdef HAVE_GMP
+ mpz_clear( slap_counters.sc_bytes );
+ mpz_clear( slap_counters.sc_pdu );
+ mpz_clear( slap_counters.sc_entries );
+ mpz_clear( slap_counters.sc_refs );
+ mpz_clear( slap_counters.sc_ops_completed );
+ mpz_clear( slap_counters.sc_ops_initiated );
+
+#ifdef SLAPD_MONITOR
+ for ( i = 0; i < SLAP_OP_LAST; i++ ) {
+ mpz_clear( slap_counters.sc_ops_initiated_[ i ] );
+ mpz_clear( slap_counters.sc_ops_completed_[ i ] );
+ }
+#endif /* SLAPD_MONITOR */
+#endif /* HAVE_GMP */
+ break;
+
+ default:
+ Debug( LDAP_DEBUG_ANY,
+ "slap_destroy(): undefined mode (%d).\n", slapMode, 0, 0 );
+
+ rc = 1;
+ break;
+
+ }
+
ldap_pvt_thread_destroy();
/* should destory the above mutex */
LDAP_SLAPD_F (int) test_filter LDAP_P(( Operation *op, Entry *e, Filter *f ));
+/*
+ * frontend.c
+ */
+LDAP_SLAPD_F (int) frontend_init LDAP_P(( void ));
+
/*
* globals.c
*/
LDAP_SLAPD_V (struct berval) default_search_base;
LDAP_SLAPD_V (struct berval) default_search_nbase;
-LDAP_SLAPD_V (ldap_pvt_thread_mutex_t) num_sent_mutex;
-LDAP_SLAPD_V (unsigned long) num_bytes_sent;
-LDAP_SLAPD_V (unsigned long) num_pdu_sent;
-LDAP_SLAPD_V (unsigned long) num_entries_sent;
-LDAP_SLAPD_V (unsigned long) num_refs_sent;
-
-LDAP_SLAPD_V (ldap_pvt_thread_mutex_t) num_ops_mutex;
-LDAP_SLAPD_V (unsigned long) num_ops_completed;
-LDAP_SLAPD_V (unsigned long) num_ops_initiated;
-#ifdef SLAPD_MONITOR
-LDAP_SLAPD_V (unsigned long) num_ops_completed_[SLAP_OP_LAST];
-LDAP_SLAPD_V (unsigned long) num_ops_initiated_[SLAP_OP_LAST];
-#endif /* SLAPD_MONITOR */
+LDAP_SLAPD_V (slap_counters_t) slap_counters;
LDAP_SLAPD_V (char *) slapd_pid_file;
LDAP_SLAPD_V (char *) slapd_args_file;
}
#endif /* LDAP_SLAPI */
- ldap_pvt_thread_mutex_lock( &num_sent_mutex );
- num_bytes_sent += bytes;
- num_pdu_sent++;
- ldap_pvt_thread_mutex_unlock( &num_sent_mutex );
+ ldap_pvt_thread_mutex_lock( &slap_counters.sc_sent_mutex );
+#ifdef HAVE_GMP
+ mpz_add_ui( slap_counters.sc_pdu, slap_counters.sc_pdu, 1 );
+ mpz_add_ui( slap_counters.sc_bytes, slap_counters.sc_bytes, bytes );
+#else /* ! HAVE_GMP */
+ slap_counters.sc_bytes += bytes;
+ slap_counters.sc_pdu++;
+#endif /* ! HAVE_GMP */
+ ldap_pvt_thread_mutex_unlock( &slap_counters.sc_sent_mutex );
cleanup:;
/* Tell caller that we did this for real, as opposed to being
}
rs->sr_nentries++;
- ldap_pvt_thread_mutex_lock( &num_sent_mutex );
- num_bytes_sent += bytes;
- num_entries_sent++;
- num_pdu_sent++;
- ldap_pvt_thread_mutex_unlock( &num_sent_mutex );
+ ldap_pvt_thread_mutex_lock( &slap_counters.sc_sent_mutex );
+#ifdef HAVE_GMP
+ mpz_add_ui( slap_counters.sc_bytes, slap_counters.sc_bytes, bytes );
+ mpz_add_ui( slap_counters.sc_entries, slap_counters.sc_entries, 1 );
+ mpz_add_ui( slap_counters.sc_pdu, slap_counters.sc_pdu, 1 );
+#else /* ! HAVE_GMP */
+ slap_counters.sc_bytes += bytes;
+ slap_counters.sc_entries++;
+ slap_counters.sc_pdu++;
+#endif /* ! HAVE_GMP */
+ ldap_pvt_thread_mutex_unlock( &slap_counters.sc_sent_mutex );
}
Statslog( LDAP_DEBUG_STATS2, "conn=%lu op=%lu ENTRY dn=\"%s\"\n",
bytes = send_ldap_ber( op->o_conn, ber );
ber_free_buf( ber );
- ldap_pvt_thread_mutex_lock( &num_sent_mutex );
- num_bytes_sent += bytes;
- num_refs_sent++;
- num_pdu_sent++;
- ldap_pvt_thread_mutex_unlock( &num_sent_mutex );
+ ldap_pvt_thread_mutex_lock( &slap_counters.sc_sent_mutex );
+#ifdef HAVE_GMP
+ mpz_add_ui( slap_counters.sc_bytes, slap_counters.sc_bytes, bytes );
+ mpz_add_ui( slap_counters.sc_refs, slap_counters.sc_refs, 1 );
+ mpz_add_ui( slap_counters.sc_pdu, slap_counters.sc_pdu, 1 );
+#else /* ! HAVE_GMP */
+ slap_counters.sc_bytes += bytes;
+ slap_counters.sc_refs++;
+ slap_counters.sc_pdu++;
+#endif /* ! HAVE_GMP */
+ ldap_pvt_thread_mutex_unlock( &slap_counters.sc_sent_mutex );
#ifdef LDAP_CONNECTIONLESS
}
#endif
#include "ldap_defaults.h"
+#ifdef HAVE_GMP
+#include <gmp.h>
+#endif /* HAVE_GMP */
+
#include <stdio.h>
#include <ac/stdlib.h>
};
#endif /* SLAPD_MONITOR */
+typedef struct slap_counters_t {
+ ldap_pvt_thread_mutex_t sc_sent_mutex;
+#ifdef HAVE_GMP
+ mpz_t sc_bytes;
+ mpz_t sc_pdu;
+ mpz_t sc_entries;
+ mpz_t sc_refs;
+#else /* ! HAVE_GMP */
+ unsigned long sc_bytes;
+ unsigned long sc_pdu;
+ unsigned long sc_entries;
+ unsigned long sc_refs;
+#endif /* ! HAVE_GMP */
+
+ ldap_pvt_thread_mutex_t sc_ops_mutex;
+#ifdef HAVE_GMP
+ mpz_t sc_ops_completed;
+ mpz_t sc_ops_initiated;
+#ifdef SLAPD_MONITOR
+ mpz_t sc_ops_completed_[SLAP_OP_LAST];
+ mpz_t sc_ops_initiated_[SLAP_OP_LAST];
+#endif /* SLAPD_MONITOR */
+#else /* ! HAVE_GMP */
+ unsigned long sc_ops_completed;
+ unsigned long sc_ops_initiated;
+#ifdef SLAPD_MONITOR
+ unsigned long sc_ops_completed_[SLAP_OP_LAST];
+ unsigned long sc_ops_initiated_[SLAP_OP_LAST];
+#endif /* SLAPD_MONITOR */
+#endif /* ! HAVE_GMP */
+} slap_counters_t;
+
+#define num_sent_mutex slap_counters.sc_sent_mutex
+#define num_bytes_sent slap_counters.sc_bytes
+#define num_pdu_sent slap_counters.sc_pdu
+#define num_entries_sent slap_counters.sc_entries
+#define num_refs_sent slap_counters.sc_refs
+#define num_ops_mutex slap_counters.sc_ops_mutex
+#define num_ops_completed slap_counters.sc_ops_completed
+#define num_ops_initiated slap_counters.sc_ops_initiated
+#define num_ops_completed_ slap_counters.sc_ops_completed_
+#define num_ops_initiated_ slap_counters.sc_ops_initiated_
+
/*
* Better know these all around slapd
*/
projects / openldap / commitdiff