#include <ac/time.h>
#include <ac/unistd.h>
-#include "ldap_pvt.h"
#include "lutil.h"
#include "slap.h"
assert( c->c_conn_state != SLAP_C_INVALID );
assert( sd != AC_SOCKET_INVALID );
-#ifdef SLAPD_MONITOR
- c->c_activitytime = slap_get_time();
-#else
- if( global_idletimeout > 0 ) {
+#ifndef SLAPD_MONITOR
+ if ( global_idletimeout > 0 )
+#endif /* ! SLAPD_MONITOR */
+ {
c->c_activitytime = slap_get_time();
}
-#endif
}
return c;
/* set to zero until bind, implies LDAP_VERSION3 */
c->c_protocol = 0;
-#ifdef SLAPD_MONITOR
- c->c_activitytime = c->c_starttime = slap_get_time();
-#else
- if( global_idletimeout > 0 ) {
+#ifndef SLAPD_MONITOR
+ if ( global_idletimeout > 0 )
+#endif /* ! SLAPD_MONITOR */
+ {
c->c_activitytime = c->c_starttime = slap_get_time();
}
-#endif
#ifdef LDAP_CONNECTIONLESS
c->c_is_udp = 0;
*/
#ifdef SLAPD_MONITOR
-#define INCR_OP(var,index) \
+/* FIXME: returns 0 in case of failure */
+#define INCR_OP_INITIATED(index) \
+ do { \
+ ldap_pvt_thread_mutex_lock( &slap_counters.sc_ops_mutex ); \
+ ldap_pvt_mp_add_ulong(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( &num_ops_mutex ); \
- (var)[(index)]++; \
- ldap_pvt_thread_mutex_unlock( &num_ops_mutex ); \
+ ldap_pvt_thread_mutex_lock( &slap_counters.sc_ops_mutex ); \
+ ldap_pvt_mp_add_ulong(slap_counters.sc_ops_completed, 1); \
+ ldap_pvt_mp_add_ulong(slap_counters.sc_ops_completed_[(index)], 1); \
+ ldap_pvt_thread_mutex_unlock( &slap_counters.sc_ops_mutex ); \
} while (0)
#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 );
+ /* FIXME: returns 0 in case of failure */
+ ldap_pvt_mp_add_ulong(slap_counters.sc_ops_initiated, 1);
+ ldap_pvt_thread_mutex_unlock( &slap_counters.sc_ops_mutex );
op->o_threadctx = ctx;
#endif
memsiz = SLAP_SLAB_SIZE;
- memctx = slap_sl_mem_create( memsiz, ctx );
+ memctx = slap_sl_mem_create( memsiz, SLAP_SLAB_STACK, ctx );
op->o_tmpmemctx = memctx;
op->o_tmpmfuncs = &slap_sl_mfuncs;
if ( tag != LDAP_REQ_ADD && tag != LDAP_REQ_MODIFY ) {
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;
ber_set_option( op->o_ber, LBER_OPT_BER_MEMCTX, &memctx_null );
+#if 0 /* DELETE ME */
if ( op->o_cancel != SLAP_CANCEL_ACK &&
( op->o_sync_mode & SLAP_SYNC_PERSIST ) )
{
slap_sl_mem_detach( ctx, memctx );
-
} else if ( op->o_sync_slog_size != -1 ) {
slap_sl_mem_detach( ctx, memctx );
LDAP_STAILQ_REMOVE( &conn->c_ops, op, slap_op, o_next);
conn->c_n_ops_executing--;
conn->c_n_ops_completed++;
- } else {
+ } else
+#endif
+ {
LDAP_STAILQ_REMOVE( &conn->c_ops, op, slap_op, o_next);
LDAP_STAILQ_NEXT(op, o_next) = NULL;
slap_op_free( op );
op = slap_op_alloc( ber, msgid, tag, conn->c_n_ops_received++ );
op->o_conn = conn;
- op->o_assertion = NULL;
- op->o_preread_attrs = NULL;
- op->o_postread_attrs = NULL;
- op->o_vrFilter = NULL;
/* clear state if the connection is being reused from inactive */
if ( conn->c_conn_state == SLAP_C_INACTIVE ) {
memset( &conn->c_pagedresults_state, 0, sizeof( conn->c_pagedresults_state ) );
}
- op->o_pagedresults_state = conn->c_pagedresults_state;
op->o_res_ber = NULL;
return 0;
}
+static void
+connection_init_log_prefix( Operation *op )
+{
+ if ( op->o_connid == (unsigned long)(-1) ) {
+ snprintf( op->o_log_prefix, sizeof( op->o_log_prefix ),
+ "conn=-1 op=%lu", op->o_opid );
+
+ } else {
+ snprintf( op->o_log_prefix, sizeof( op->o_log_prefix ),
+ "conn=%lu op=%lu", op->o_connid, op->o_opid );
+ }
+}
+
static int connection_op_activate( Operation *op )
{
int status;
}
op->o_connid = op->o_conn->c_connid;
+ connection_init_log_prefix( op );
LDAP_STAILQ_INSERT_TAIL( &op->o_conn->c_ops, op, o_next );
conn->c_peer_domain = slap_empty_bv;
conn->c_peer_name = slap_empty_bv;
+ memset(op, 0, OPERATION_BUFFER_SIZE);
+ op->o_hdr = (Opheader *)(op+1);
+ op->o_controls = (void **)(op->o_hdr+1);
/* set memory context */
- op->o_tmpmemctx = slap_sl_mem_create( SLAP_SLAB_SIZE, ctx );
+ op->o_tmpmemctx = slap_sl_mem_create(SLAP_SLAB_SIZE, SLAP_SLAB_STACK, ctx);
op->o_tmpmfuncs = &slap_sl_mfuncs;
op->o_threadctx = ctx;
op->o_conn = conn;
op->o_connid = op->o_conn->c_connid;
+ connection_init_log_prefix( op );
op->o_time = slap_get_time();
}