use trylock only where necessary

[openldap] / servers / slapd / back-ldap / bind.c

diff --git a/servers/slapd/back-ldap/bind.c b/servers/slapd/back-ldap/bind.c
index db6443f50423d70de9176abe546134af477d3b0f..d9e395d3ed25f189a5101ab4dbcfe7e16abcd526 100644 (file)
--- a/servers/slapd/back-ldap/bind.c
+++ b/servers/slapd/back-ldap/bind.c
@@ -37,12 +37,6 @@
 
 #define PRINT_CONNTREE 0
 
-/*
- * FIXME: temporarily disable pooled connections, as there seem to be
- * some concurrency problem
- */
-/* #undef LDAP_BACK_POOLED_CONNS */
-
 static LDAP_REBIND_PROC        ldap_back_rebind;
 
 static int
@@ -241,27 +235,7 @@ ldap_back_freeconn( Operation *op, struct ldapconn *lc )
 {
        struct ldapinfo *li = (struct ldapinfo *) op->o_bd->be_private;
 
-retry_lock:;
-       switch ( ldap_pvt_thread_mutex_trylock( &li->conn_mutex ) ) {
-       case LDAP_PVT_THREAD_EBUSY:
-       default:
-               ldap_pvt_thread_yield();
-               goto retry_lock;
-
-       case 0:
-               break;
-       }
-
-       switch ( ldap_pvt_thread_mutex_trylock( &lc->lc_mutex ) ) {
-       case LDAP_PVT_THREAD_EBUSY:
-       default:
-               ldap_pvt_thread_mutex_unlock( &li->conn_mutex );
-               ldap_pvt_thread_yield();
-               goto retry_lock;
-
-       case 0:
-               break;
-       }
+       ldap_pvt_thread_mutex_lock( &li->conn_mutex );
 
        assert( lc->lc_refcnt > 0 );
        if ( --lc->lc_refcnt == 0 ) {
@@ -269,12 +243,7 @@ retry_lock:;
                                ldap_back_conn_cmp );
                assert( lc != NULL );
 
-               ldap_pvt_thread_mutex_unlock( &lc->lc_mutex );
-
                ldap_back_conn_free( (void *)lc );
-
-       } else {
-               ldap_pvt_thread_mutex_unlock( &lc->lc_mutex );
        }
 
        ldap_pvt_thread_mutex_unlock( &li->conn_mutex );
@@ -389,7 +358,7 @@ retry:;
                if ( rs->sr_err == LDAP_SERVER_DOWN
                                || ( rs->sr_err != LDAP_SUCCESS && LDAP_BACK_TLS_CRITICAL( li ) ) )
                {
-                       ldap_unbind_ext_s( ld, NULL, NULL );
+                       ldap_unbind_ext( ld, NULL, NULL );
                        goto error_return;
                }
 
@@ -423,7 +392,9 @@ struct ldapconn *
 ldap_back_getconn( Operation *op, SlapReply *rs, ldap_back_send_t sendok )
 {
        struct ldapinfo *li = (struct ldapinfo *)op->o_bd->be_private;
-       struct ldapconn *lc, lc_curr = { 0 };
+       struct ldapconn *lc,
+                       lc_curr = { 0 };
+       int             refcnt = 1;
 
        /* Searches for a ldapconn in the avl tree */
 
@@ -440,34 +411,22 @@ ldap_back_getconn( Operation *op, SlapReply *rs, ldap_back_send_t sendok )
        }
        
        /* Internal searches are privileged and shared. So is root. */
-#ifdef LDAP_BACK_POOLED_CONNS
        /* FIXME: there seem to be concurrency issues */
        if ( op->o_do_not_cache || be_isroot( op ) ) {
                lc_curr.lc_local_ndn = op->o_bd->be_rootndn;
                lc_curr.lc_conn = NULL;
                lc_curr.lc_ispriv = 1;
 
-       } else 
-#endif /* LDAP_BACK_POOLED_CONNS */
-       {
+       } else {
                lc_curr.lc_local_ndn = op->o_ndn;
        }
 
-retry_lock:;
-       switch ( ldap_pvt_thread_mutex_trylock( &li->conn_mutex ) ) {
-       case LDAP_PVT_THREAD_EBUSY:
-       default:
-               ldap_pvt_thread_yield();
-               goto retry_lock;
-
-       case 0:
-               break;
-       }
+       ldap_pvt_thread_mutex_lock( &li->conn_mutex );
 
        lc = (struct ldapconn *)avl_find( li->conntree, 
                        (caddr_t)&lc_curr, ldap_back_conn_cmp );
        if ( lc != NULL ) {
-               lc->lc_refcnt++;
+               refcnt = ++lc->lc_refcnt;
        }
        ldap_pvt_thread_mutex_unlock( &li->conn_mutex );
 
@@ -480,8 +439,6 @@ retry_lock:;
                lc->lc_conn = lc_curr.lc_conn;
                ber_dupbv( &lc->lc_local_ndn, &lc_curr.lc_local_ndn );
 
-               ldap_pvt_thread_mutex_init( &lc->lc_mutex );
-
                if ( lc_curr.lc_ispriv ) {
                        ber_dupbv( &lc->lc_cred, &li->acl_passwd );
                        ber_dupbv( &lc->lc_bound_ndn, &li->acl_authcDN );
@@ -500,16 +457,7 @@ retry_lock:;
                lc->lc_bound = 0;
 
                /* Inserts the newly created ldapconn in the avl tree */
-retry_lock2:;
-               switch ( ldap_pvt_thread_mutex_trylock( &li->conn_mutex ) ) {
-               case LDAP_PVT_THREAD_EBUSY:
-               default:
-                       ldap_pvt_thread_yield();
-                       goto retry_lock2;
-
-               case 0:
-                       break;
-               }
+               ldap_pvt_thread_mutex_lock( &li->conn_mutex );
 
                assert( lc->lc_refcnt == 1 );
                rs->sr_err = avl_insert( &li->conntree, (caddr_t)lc,
@@ -523,7 +471,7 @@ retry_lock2:;
 
                Debug( LDAP_DEBUG_TRACE,
                        "=>ldap_back_getconn: conn %p inserted (refcnt=%u)\n",
-                       (void *)lc, lc->lc_refcnt, 0 );
+                       (void *)lc, refcnt, 0 );
        
                /* Err could be -1 in case a duplicate ldapconn is inserted */
                if ( rs->sr_err != 0 ) {
@@ -539,7 +487,7 @@ retry_lock2:;
        } else {
                Debug( LDAP_DEBUG_TRACE,
                        "=>ldap_back_getconn: conn %p fetched (refcnt=%u)\n",
-                       (void *)lc, lc->lc_refcnt, 0 );
+                       (void *)lc, refcnt, 0 );
        }
        
        return lc;
@@ -553,31 +501,9 @@ ldap_back_release_conn(
 {
        struct ldapinfo *li = (struct ldapinfo *)op->o_bd->be_private;
 
-retry_lock:;
-       switch ( ldap_pvt_thread_mutex_trylock( &li->conn_mutex ) ) {
-       case LDAP_PVT_THREAD_EBUSY:
-       default:
-               ldap_pvt_thread_yield();
-               goto retry_lock;
-
-       case 0:
-               break;
-       }
-
-       switch ( ldap_pvt_thread_mutex_trylock( &lc->lc_mutex ) ) {
-       case LDAP_PVT_THREAD_EBUSY:
-       default:
-               ldap_pvt_thread_mutex_unlock( &li->conn_mutex );
-               ldap_pvt_thread_yield();
-               goto retry_lock;
-
-       case 0:
-               break;
-       }
-       
+       ldap_pvt_thread_mutex_lock( &li->conn_mutex );
        assert( lc->lc_refcnt > 0 );
        lc->lc_refcnt--;
-       ldap_pvt_thread_mutex_unlock( &lc->lc_mutex );
        ldap_pvt_thread_mutex_unlock( &li->conn_mutex );
 }
 
@@ -588,8 +514,7 @@ retry_lock:;
  * it from all the callers, and I made the function return the flag, so
  * it can be used to simplify the check.
  *
- * Note: lc_mutex is locked; dolock indicates whether li->conn_mutex
- * must be locked or not
+ * Note: dolock indicates whether li->conn_mutex must be locked or not
  */
 static int
 ldap_back_dobind_int(
@@ -693,21 +618,12 @@ retry:;
                if ( rs->sr_err == LDAP_SERVER_DOWN ) {
                        if ( retries > 0 ) {
                                if ( dolock ) {
-retry_lock:;
-                                       switch ( ldap_pvt_thread_mutex_trylock( &li->conn_mutex ) ) {
-                                       case LDAP_PVT_THREAD_EBUSY:
-                                       default:
-                                               ldap_pvt_thread_yield();
-                                               goto retry_lock;
-
-                                       case 0:
-                                               break;
-                                       }
+                                       ldap_pvt_thread_mutex_lock( &li->conn_mutex );
                                }
 
                                assert( lc->lc_refcnt > 0 );
                                if ( lc->lc_refcnt == 1 ) {
-                                       ldap_unbind_ext_s( lc->lc_ld, NULL, NULL );
+                                       ldap_unbind_ext( lc->lc_ld, NULL, NULL );
                                        lc->lc_ld = NULL;
 
                                        /* lc here must be the regular lc, reset and ready for init */
@@ -742,13 +658,7 @@ done:;
 int
 ldap_back_dobind( struct ldapconn *lc, Operation *op, SlapReply *rs, ldap_back_send_t sendok )
 {
-       int     rc;
-
-       ldap_pvt_thread_mutex_lock( &lc->lc_mutex );
-       rc = ldap_back_dobind_int( lc, op, rs, sendok, 1, 1 );
-       ldap_pvt_thread_mutex_unlock( &lc->lc_mutex );
-
-       return rc;
+       return ldap_back_dobind_int( lc, op, rs, sendok, 1, 1 );
 }
 
 /*
@@ -864,30 +774,10 @@ ldap_back_retry( struct ldapconn *lc, Operation *op, SlapReply *rs, ldap_back_se
        int             rc = 0;
        struct ldapinfo *li = (struct ldapinfo *)op->o_bd->be_private;
        
-retry_lock:;
-       switch ( ldap_pvt_thread_mutex_trylock( &li->conn_mutex ) ) {
-       case LDAP_PVT_THREAD_EBUSY:
-       default:
-               ldap_pvt_thread_yield();
-               goto retry_lock;
-
-       case 0:
-               break;
-       }
-
-       switch ( ldap_pvt_thread_mutex_trylock( &lc->lc_mutex ) ) {
-       case LDAP_PVT_THREAD_EBUSY:
-       default:
-               ldap_pvt_thread_mutex_unlock( &li->conn_mutex );
-               ldap_pvt_thread_yield();
-               goto retry_lock;
-
-       case 0:
-               break;  
-       }
+       ldap_pvt_thread_mutex_lock( &li->conn_mutex );
 
        if ( lc->lc_refcnt == 1 ) {
-               ldap_unbind_ext_s( lc->lc_ld, NULL, NULL );
+               ldap_unbind_ext( lc->lc_ld, NULL, NULL );
                lc->lc_ld = NULL;
                lc->lc_bound = 0;
 
@@ -898,7 +788,6 @@ retry_lock:;
                }
        }
 
-       ldap_pvt_thread_mutex_unlock( &lc->lc_mutex );
        ldap_pvt_thread_mutex_unlock( &li->conn_mutex );
 
        return rc;