More for ITS#6045: clear o_callback as well.

[openldap] / servers / slapd / connection.c

diff --git a/servers/slapd/connection.c b/servers/slapd/connection.c
index 4c3178e338c74a58b00cc00beabccb38e8f3259d..6781d2a34f92d271c863ff4622c3495a85011cd2 100644 (file)
--- a/servers/slapd/connection.c
+++ b/servers/slapd/connection.c
@@ -1,7 +1,7 @@
 /* $OpenLDAP$ */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *
- * Copyright 1998-2008 The OpenLDAP Foundation.
+ * Copyright 1998-2009 The OpenLDAP Foundation.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -163,8 +163,10 @@ int connections_destroy(void)
                if( connections[i].c_struct_state != SLAP_C_UNINITIALIZED ) {
                        ber_sockbuf_free( connections[i].c_sb );
                        ldap_pvt_thread_mutex_destroy( &connections[i].c_mutex );
-                       ldap_pvt_thread_mutex_destroy( &connections[i].c_write_mutex );
-                       ldap_pvt_thread_cond_destroy( &connections[i].c_write_cv );
+                       ldap_pvt_thread_mutex_destroy( &connections[i].c_write1_mutex );
+                       ldap_pvt_thread_mutex_destroy( &connections[i].c_write2_mutex );
+                       ldap_pvt_thread_cond_destroy( &connections[i].c_write1_cv );
+                       ldap_pvt_thread_cond_destroy( &connections[i].c_write2_cv );
 #ifdef LDAP_SLAPI
                        if ( slapi_plugins_used ) {
                                slapi_int_free_object_extensions( SLAPI_X_EXT_CONNECTION,
@@ -216,17 +218,23 @@ int connections_shutdown(void)
  */
 int connections_timeout_idle(time_t now)
 {
-       int i = 0;
+       int i = 0, writers = 0;
        int connindex;
        Connection* c;
+       time_t old;
+
+       old = slapd_get_writetime();
 
        for( c = connection_first( &connindex );
                c != NULL;
                c = connection_next( c, &connindex ) )
        {
                /* Don't timeout a slow-running request or a persistent
-                * outbound connection */
-               if( c->c_n_ops_executing || c->c_conn_state == SLAP_C_CLIENT ) {
+                * outbound connection. But if it has a writewaiter, see
+                * if the waiter has been there too long.
+                */
+               if(( c->c_n_ops_executing && !c->c_writewaiter)
+                       || c->c_conn_state == SLAP_C_CLIENT ) {
                        continue;
                }
 
@@ -235,9 +243,21 @@ int connections_timeout_idle(time_t now)
                        connection_closing( c, "idletimeout" );
                        connection_close( c );
                        i++;
+                       continue;
+               }
+               if ( c->c_writewaiter ) {
+                       writers = 1;
+                       if( difftime( c->c_activitytime+global_writetimeout, now) < 0 ) {
+                               /* close it */
+                               connection_closing( c, "writetimeout" );
+                               connection_close( c );
+                               i++;
+                       }
                }
        }
        connection_done( c );
+       if ( !writers )
+               slapd_clr_writetime( old );
 
        return i;
 }
@@ -384,8 +404,10 @@ Connection * connection_init(
 
                /* should check status of thread calls */
                ldap_pvt_thread_mutex_init( &c->c_mutex );
-               ldap_pvt_thread_mutex_init( &c->c_write_mutex );
-               ldap_pvt_thread_cond_init( &c->c_write_cv );
+               ldap_pvt_thread_mutex_init( &c->c_write1_mutex );
+               ldap_pvt_thread_mutex_init( &c->c_write2_mutex );
+               ldap_pvt_thread_cond_init( &c->c_write1_cv );
+               ldap_pvt_thread_cond_init( &c->c_write2_cv );
 
 #ifdef LDAP_SLAPI
                if ( slapi_plugins_used ) {
@@ -417,6 +439,7 @@ Connection * connection_init(
        assert( c->c_sasl_bindop == NULL );
        assert( c->c_currentber == NULL );
        assert( c->c_writewaiter == 0);
+       assert( c->c_writers == 0);
 
        c->c_listener = listener;
        c->c_sd = s;
@@ -593,6 +616,7 @@ connection_destroy( Connection *c )
        assert( LDAP_STAILQ_EMPTY(&c->c_txn_ops) );
 #endif
        assert( c->c_writewaiter == 0);
+       assert( c->c_writers == 0);
 
        /* only for stats (print -1 as "%lu" may give unexpected results ;) */
        connid = c->c_connid;
@@ -752,18 +776,24 @@ void connection_closing( Connection *c, const char *why )
                connection_abandon( c );
 
                /* wake write blocked operations */
-               if ( c->c_writewaiter ) {
-                       ldap_pvt_thread_cond_signal( &c->c_write_cv );
-                       /* ITS#4667 this may allow another thread to drop into
-                        * connection_resched / connection_close before we
-                        * finish, but that's OK.
-                        */
-                       slapd_clr_write( c->c_sd, 1 );
-                       ldap_pvt_thread_mutex_unlock( &c->c_mutex );
-                       ldap_pvt_thread_mutex_lock( &c->c_write_mutex );
-                       ldap_pvt_thread_mutex_lock( &c->c_mutex );
-                       ldap_pvt_thread_mutex_unlock( &c->c_write_mutex );
+               ldap_pvt_thread_mutex_lock( &c->c_write1_mutex );
+               if ( c->c_writers > 0 ) {
+                       c->c_writers = -c->c_writers;
+                       ldap_pvt_thread_cond_broadcast( &c->c_write1_cv );
+                       ldap_pvt_thread_mutex_unlock( &c->c_write1_mutex );
+                       if ( c->c_writewaiter ) {
+                               ldap_pvt_thread_mutex_lock( &c->c_write2_mutex );
+                               ldap_pvt_thread_cond_signal( &c->c_write2_cv );
+                               slapd_clr_write( c->c_sd, 1 );
+                               ldap_pvt_thread_mutex_unlock( &c->c_write2_mutex );
+                       }
+                       ldap_pvt_thread_mutex_lock( &c->c_write1_mutex );
+                       while ( c->c_writers ) {
+                               ldap_pvt_thread_cond_wait( &c->c_write1_cv, &c->c_write1_mutex );
+                       }
+                       ldap_pvt_thread_mutex_unlock( &c->c_write1_mutex );
                } else {
+                       ldap_pvt_thread_mutex_unlock( &c->c_write1_mutex );
                        slapd_clr_write( c->c_sd, 1 );
                }
 
@@ -778,11 +808,6 @@ connection_close( Connection *c )
 {
        assert( connections != NULL );
        assert( c != NULL );
-
-       /* ITS#4667 we may have gotten here twice */
-       if ( c->c_conn_state == SLAP_C_INVALID )
-               return;
-
        assert( c->c_struct_state == SLAP_C_USED );
        assert( c->c_conn_state == SLAP_C_CLOSING );
 
@@ -1174,7 +1199,7 @@ void connection_client_stop(
 
        /* get (locked) connection */
        c = connection_get( s );
-       
+
        assert( c->c_conn_state == SLAP_C_CLIENT );
 
        c->c_listener = NULL;
@@ -1246,6 +1271,24 @@ int connection_read_activate( ber_socket_t s )
        return rc;
 }
 
+void
+connection_hangup( ber_socket_t s )
+{
+       Connection *c;
+
+       c = connection_get( s );
+       if ( c ) {
+               if ( c->c_conn_state == SLAP_C_CLIENT ) {
+                       connection_return( c );
+                       connection_read_activate( s );
+               } else {
+                       connection_closing( c, "connection lost" );
+                       connection_close( c );
+                       connection_return( c );
+               }
+       }
+}
+
 static int
 connection_read( ber_socket_t s, conn_readinfo *cri )
 {
@@ -1831,7 +1874,9 @@ int connection_write(ber_socket_t s)
        Debug( LDAP_DEBUG_TRACE,
                "connection_write(%d): waking output for id=%lu\n",
                s, c->c_connid, 0 );
-       ldap_pvt_thread_cond_signal( &c->c_write_cv );
+       ldap_pvt_thread_mutex_lock( &c->c_write2_mutex );
+       ldap_pvt_thread_cond_signal( &c->c_write2_cv );
+       ldap_pvt_thread_mutex_unlock( &c->c_write2_mutex );
 
        if ( ber_sockbuf_ctrl( c->c_sb, LBER_SB_OPT_NEEDS_READ, NULL ) ) {
                slapd_set_read( s, 1 );