trema 0.4.5 → 0.4.6

data/src/lib/chibach.c

@@ -33,6 +33,7 @@
 #include <unistd.h>
 #include "chibach.h"
 #include "chibach_private.h"
+#include "external_callback.h"
 #include "daemon.h"
 #include "doubly_linked_list.h"
 #include "log.h"
@@ -191,7 +192,7 @@ parse_argv( int *argc, char ***argv ) {
 
   run_as_daemon = false;
   controller.ip = 0x7f000001;
-  controller.port = 6633;
+  controller.port = 6653;
 
   for ( int i = 0; i < *argc; ++i ) {
     new_argv[ i ] = ( *argv )[ i ];
@@ -286,7 +287,7 @@ set_exit_handler() {
 
 static void
 set_dump_stats_as_external_callback() {
-  set_external_callback( dump_stats );
+  push_external_callback( dump_stats );
 }
 
 

data/src/lib/event_handler.c

@@ -23,6 +23,7 @@
 #include <unistd.h>
 #include "checks.h"
 #include "event_handler.h"
+#include "external_callback.h"
 #include "log.h"
 #include "timer.h"
 
@@ -61,6 +62,30 @@ extern bool mock_add_periodic_event_callback( const time_t seconds, void ( *call
 #define execute_timer_events mock_execute_timer_events
 extern void mock_execute_timer_events( int *next_timeout_usec );
 
+#ifdef init_external_callback
+#undef init_external_callback
+#endif
+#define init_external_callback mock_init_external_callback
+extern void mock_init_external_callback( void );
+
+#ifdef finalize_external_callback
+#undef finalize_external_callback
+#endif
+#define finalize_external_callback mock_finalize_external_callback
+extern void mock_finalize_external_callback( void );
+
+#ifdef push_external_callback
+#undef push_external_callback
+#endif
+#define push_external_callback mock_push_external_callback
+extern void mock_push_external_callback( external_callback_t callback );
+
+#ifdef run_external_callback
+#undef run_external_callback
+#endif
+#define run_external_callback mock_run_external_callback
+extern void mock_run_external_callback( void );
+
 #endif // UNIT_TESTING
 
 
@@ -94,19 +119,19 @@ fd_set current_write_set;
 
 int fd_set_size = 0;
 
-external_callback_t external_callback = ( external_callback_t ) NULL;
-
-
 static void
 _init_event_handler() {
   event_last = event_list;
-  event_handler_state = EVENT_HANDLER_INITIALIZED;
 
   memset( event_list, 0, sizeof( event_fd ) * FD_SETSIZE );
   memset( event_fd_set, 0, sizeof( event_fd * ) * FD_SETSIZE );
 
   FD_ZERO( &event_read_set );
   FD_ZERO( &event_write_set );
+
+  init_external_callback();
+
+  event_handler_state = EVENT_HANDLER_INITIALIZED;
 }
 void ( *init_event_handler )() = _init_event_handler;
 
@@ -120,18 +145,15 @@ _finalize_event_handler() {
   }
 
   event_handler_state = EVENT_HANDLER_FINALIZED;
+
+  finalize_external_callback();
 }
 void ( *finalize_event_handler )() = _finalize_event_handler;
 
 
 static bool
 _run_event_handler_once( int timeout_usec ) {
-  if ( external_callback != NULL ) {
-    external_callback_t callback = external_callback;
-    external_callback = NULL;
-
-    callback();
-  }
+  run_external_callback();
 
   memcpy( &current_read_set, &event_read_set, sizeof( fd_set ) );
   memcpy( &current_write_set, &event_write_set, sizeof( fd_set ) );
@@ -143,6 +165,7 @@ _run_event_handler_once( int timeout_usec ) {
 
   if ( set_count == -1 ) {
     if ( errno == EINTR ) {
+      run_external_callback();
       return true;
     }
     error( "Failed to select ( errno = %s [%d] ).", strerror( errno ), errno );
@@ -151,11 +174,13 @@ _run_event_handler_once( int timeout_usec ) {
   }
   else if ( set_count == 0 ) {
     // timed out
+    run_external_callback();
     return true;
   }
 
-  event_fd *event_itr = event_list;
+  run_external_callback();
 
+  event_fd *event_itr = event_list;
   while ( event_itr < event_last ) {
     event_fd current_event = *event_itr;
 
@@ -163,6 +188,23 @@ _run_event_handler_once( int timeout_usec ) {
       current_event.write_callback( current_event.fd, current_event.write_data );
     }
 
+    // In the rare cases the current fd is closed, a new one is opened
+    // with the same fd and is put in the same location we can just
+    // wait for the next select call.
+    if ( current_event.fd == event_itr->fd ) {
+      event_itr = event_itr + 1;
+    }
+    else {
+      debug( "run_event_handler_once: event fd is changed ( current = %d, new = %d )", current_event.fd, event_itr->fd );
+    }
+  }
+
+  run_external_callback();
+
+  event_itr = event_list;
+  while ( event_itr < event_last ) {
+    event_fd current_event = *event_itr;
+
     if ( FD_ISSET( current_event.fd, &current_read_set ) ) {
       current_event.read_callback( current_event.fd, current_event.read_data );
     }
@@ -178,6 +220,8 @@ _run_event_handler_once( int timeout_usec ) {
     }
   }
 
+  run_external_callback();
+
   return true;
 }
 bool ( *run_event_handler_once )( int ) = _run_event_handler_once;
@@ -367,18 +411,6 @@ _writable( int fd ) {
 bool ( *writable )( int fd ) = _writable;
 
 
-static bool
-_set_external_callback( external_callback_t callback ) {
-  if ( external_callback != NULL ) {
-    return false;
-  }
-
-  external_callback = callback;
-  return true;
-}
-bool ( *set_external_callback )( external_callback_t callback ) = _set_external_callback;
-
-
 /*
  * Local variables:
  * c-basic-offset: 2

data/src/lib/event_handler.h

@@ -27,7 +27,6 @@
 
 
 typedef void ( *event_fd_callback )( int, void *data );
-typedef void ( *external_callback_t )( void );
 
 extern void ( *init_event_handler )();
 extern void ( *finalize_event_handler )();
@@ -46,10 +45,6 @@ extern void ( *set_writable )( int fd, bool state );
 extern bool ( *readable )( int fd );
 extern bool ( *writable )( int fd );
 
-// Optional functions for event handlers to implement, must be signal
-// safe. Leave as NULL if not supported.
-extern bool ( *set_external_callback )( external_callback_t callback );
-
 
 #endif // EVENT_HANDLER_H
 

data/src/lib/external_callback.c

@@ -0,0 +1,126 @@
+/*
+ * Copyright (C) 2013 NEC Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+
+#include <assert.h>
+#include "external_callback.h"
+#include "log.h"
+#include "wrapper.h"
+
+#ifdef UNIT_TESTING
+
+#ifdef xcalloc
+#undef xcalloc
+#endif
+#define xcalloc mock_xcalloc
+extern void *mock_xcalloc( size_t nmemb, size_t size );
+
+#ifdef xfree
+#undef xfree
+#endif
+#define xfree mock_xfree
+extern void mock_xfree( void *ptr );
+
+#ifdef debug
+#undef debug
+#endif
+#define debug mock_debug
+extern void mock_debug( const char *format, ... );
+
+#define static
+
+#endif // UNIT_TESTING
+
+
+typedef struct {
+  external_callback_t *buffer;
+  unsigned int size;
+  unsigned int write_position;
+  unsigned int read_position;
+} ring_buffer;
+
+static const unsigned int MAX_EXTERNAL_CALLBACK = 16;
+static ring_buffer *external_callbacks = NULL;
+
+
+static void
+_init_external_callback() {
+  assert( external_callbacks == NULL );
+
+  external_callbacks = xcalloc( 1, sizeof( ring_buffer ) );
+  external_callbacks->buffer = xcalloc( MAX_EXTERNAL_CALLBACK, sizeof( external_callback_t * ) );
+  external_callbacks->size = MAX_EXTERNAL_CALLBACK;
+}
+void ( *init_external_callback )() = _init_external_callback;
+
+
+static void
+_finalize_external_callback() {
+  assert( external_callbacks != NULL );
+  assert( external_callbacks->buffer != NULL );
+
+  xfree( external_callbacks->buffer );
+  xfree( external_callbacks );
+  external_callbacks = NULL;
+}
+void ( *finalize_external_callback )() = _finalize_external_callback;
+
+
+static bool
+_push_external_callback( external_callback_t callback ) {
+  if ( callback == NULL ) {
+    return false;
+  }
+  if ( external_callbacks == NULL ) {
+    return false;
+  }
+  assert( external_callbacks->buffer != NULL );
+
+  debug( "push_external_callback: %p", callback );
+  unsigned int write_pos = __sync_fetch_and_add( &external_callbacks->write_position, 1 ) % external_callbacks->size;
+  assert( __sync_bool_compare_and_swap( &( external_callbacks->buffer[ write_pos ] ), NULL, callback ) );
+
+  return true;
+}
+bool ( *push_external_callback )( external_callback_t callback ) = _push_external_callback;
+
+
+static void
+_run_external_callback() {
+  assert( external_callbacks != NULL );
+  assert( external_callbacks->buffer != NULL );
+
+  while ( external_callbacks->write_position != external_callbacks->read_position ) {
+    unsigned int read_pos = external_callbacks->read_position % external_callbacks->size;
+    external_callback_t callback = external_callbacks->buffer[ read_pos ];
+    assert( callback != NULL );
+    external_callbacks->buffer[ read_pos ] = NULL;
+    external_callbacks->read_position++;
+    debug( "run_external_callback: %p ( write_position = %u, read_position = %u )", callback,
+           external_callbacks->write_position, external_callbacks->read_position );
+    callback();
+  }
+}
+void ( *run_external_callback )() = _run_external_callback;
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */

data/src/lib/external_callback.h

@@ -0,0 +1,46 @@
+/*
+ * External callback implementation
+ *
+ * Copyright (C) 2013 NEC Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+
+#ifndef EXTERNAL_CALLBACK_H
+#define EXTERNAL_CALLBACK_H
+
+
+#include <sys/types.h>
+#include "bool.h"
+
+typedef void ( *external_callback_t )( void );
+
+extern void ( *init_external_callback )( void );
+extern void ( *finalize_external_callback )( void );
+extern bool ( *push_external_callback )( external_callback_t callback );
+extern void ( *run_external_callback )( void );
+
+#define set_external_callback( callback ) push_external_callback( callback )
+
+
+#endif // EXTERNAL_CALLBACK_H
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */

data/src/lib/messenger.c

@@ -141,6 +141,7 @@ enum {
   MESSAGE_TYPE_NOTIFY,
   MESSAGE_TYPE_REQUEST,
   MESSAGE_TYPE_REPLY,
+  MESSAGE_TYPE_INVALID = 255,
 };
 
 typedef struct message_buffer {
@@ -172,6 +173,7 @@ typedef struct receive_queue {
   struct sockaddr_un listen_addr;
   dlist_element *client_sockets;
   message_buffer *buffer;
+  bool in_progress;
 } receive_queue;
 
 typedef struct send_queue {
@@ -425,12 +427,14 @@ delete_receive_queue( void *service_name, void *_rq, void *user_data ) {
   receive_queue_callback *cb;
 
   assert( rq != NULL );
+  assert( rq->in_progress == false );
   for ( element = rq->message_callbacks->next; element; element = element->next ) {
     cb = element->data;
     debug( "Deleting a callback ( function = %p, message_type = %#x ).", cb->function, cb->message_type );
     xfree( cb );
   }
   delete_dlist( rq->message_callbacks );
+  rq->message_callbacks = NULL;
 
   for ( element = rq->client_sockets->next; element; element = element->next ) {
     client_socket = element->data;
@@ -591,6 +595,7 @@ create_receive_queue( const char *service_name ) {
   rq->message_callbacks = create_dlist();
   rq->client_sockets = create_dlist();
   rq->buffer = create_message_buffer( messenger_recv_queue_length );
+  rq->in_progress = false;
 
   insert_hash_entry( receive_queues, rq->service_name, rq );
 
@@ -699,11 +704,17 @@ delete_message_callback( const char *service_name, uint8_t message_type, void (
       cb = e->data;
       if ( ( cb->function == callback ) && ( cb->message_type == message_type ) ) {
         debug( "Deleting a callback ( message_type = %#x, callback = %p ).", message_type, callback );
-        xfree( cb );
-        delete_dlist_element( e );
-        if ( rq->message_callbacks->next == NULL ) {
-          debug( "No more callback for message_type = %#x.", message_type );
-          delete_receive_queue( rq->service_name, rq, NULL );
+        if ( rq->in_progress ) {
+          cb->function = NULL;
+          cb->message_type = MESSAGE_TYPE_INVALID;
+        }
+        else {
+          xfree( cb );
+          delete_dlist_element( e );
+          if ( rq->message_callbacks->next == NULL ) {
+            debug( "No more callback for message_type = %#x.", message_type );
+            delete_receive_queue( rq->service_name, rq, NULL );
+          }
         }
         return true;
       }
@@ -844,17 +855,15 @@ send_queue_connect( send_queue *sq ) {
     return -1;
   }
 
-  if ( geteuid() == 0 ) {
-    int wmem_size = 1048576;
-    int ret = setsockopt( sq->server_socket, SOL_SOCKET, SO_SNDBUFFORCE, ( const void * ) &wmem_size, ( socklen_t ) sizeof( wmem_size ) );
-    if ( ret < 0 ) {
-      error( "Failed to set SO_SNDBUFFORCE to %d ( %s [%d] ).", wmem_size, strerror( errno ), errno );
-      close( sq->server_socket );
-      sq->server_socket = -1;
-      return -1;
-    }
+  sq->socket_buffer_size = 1048576;
+  int ret = setsockopt( sq->server_socket, SOL_SOCKET, SO_SNDBUF, ( const void * ) &sq->socket_buffer_size, ( socklen_t ) sizeof( sq->socket_buffer_size ) );
+  if ( ret < 0 ) {
+    error( "Failed to set SO_SNDBUF to %d ( %s [%d] ).", sq->socket_buffer_size, strerror( errno ), errno );
+    close( sq->server_socket );
+    sq->server_socket = -1;
+    return -1;
   }
-  int ret = fcntl( sq->server_socket, F_SETFL, O_NONBLOCK );
+  ret = fcntl( sq->server_socket, F_SETFL, O_NONBLOCK );
   if ( ret < 0 ) {
     error( "Failed to set O_NONBLOCK ( %s [%d] ).", strerror( errno ), errno );
     close( sq->server_socket );
@@ -873,7 +882,7 @@ send_queue_connect( send_queue *sq ) {
     return 0;
   }
 
-  set_fd_handler( sq->server_socket, on_send_read, sq, &on_send_write, sq );
+  set_fd_handler( sq->server_socket, on_send_read, sq, on_send_write, sq );
   set_readable( sq->server_socket, true );
 
   if ( sq->buffer != NULL && sq->buffer->data_length >= sizeof( message_header ) ) {
@@ -1092,9 +1101,7 @@ push_message_to_send_queue( const char *service_name, const uint8_t message_type
   }
 
   set_writable( sq->server_socket, true );
-  if ( sq->buffer->data_length > messenger_send_length_for_flush ) {
-    on_send_write( sq->server_socket, sq );
-  }
+
   return true;
 }
 
@@ -1215,7 +1222,7 @@ _clear_send_queue( const char *service_name ) {
     return false;
   }
 
-  if ( sq->buffer->data_length > 0 ) {
+  if ( sq->server_socket > -1 ) {
     set_writable( sq->server_socket, false );
   }
 
@@ -1369,14 +1376,13 @@ truncate_message_buffer( message_buffer *buf, size_t len ) {
     len = buf->data_length;
   }
 
-  if ( ( buf->head_offset + len ) <= buf->size ) {
-    buf->head_offset += len;
+  buf->data_length -= len;
+  if ( buf->data_length == 0 ) {
+    buf->head_offset = 0;
   }
   else {
-    memmove( buf->buffer, ( char * ) buf->buffer + buf->head_offset + len, buf->data_length - len );
-    buf->head_offset = 0;
+    buf->head_offset += len;
   }
-  buf->data_length -= len;
 }
 
 
@@ -1437,15 +1443,18 @@ static void
 call_message_callbacks( receive_queue *rq, const uint8_t message_type, const uint16_t tag, void *data, size_t len ) {
   assert( rq != NULL );
 
-  dlist_element *element;
+  dlist_element *element, *next;
   receive_queue_callback *cb;
 
   debug( "Calling message callbacks ( service_name = %s, message_type = %#x, tag = %#x, data = %p, len = %zu ).",
          rq->service_name, message_type, tag, data, len );
 
-  for ( element = rq->message_callbacks->next; element; element = element->next ) {
+  assert( rq->in_progress != true );
+  rq->in_progress = true;
+  for ( element = rq->message_callbacks->next; element; element = next ) {
+    next = element->next;
     cb = element->data;
-    if ( cb->message_type != message_type ) {
+    if ( cb == NULL || cb->function == NULL || cb->message_type != message_type ) {
       continue;
     }
     switch ( message_type ) {
@@ -1511,6 +1520,19 @@ call_message_callbacks( receive_queue *rq, const uint8_t message_type, const uin
       assert( 0 );
     }
   }
+  for ( element = rq->message_callbacks->next; element; element = next ) {
+    next = element->next;
+    cb = element->data;
+    if ( cb->function == NULL ) {
+      xfree( cb );
+      delete_dlist_element( element );
+    }
+  }
+  rq->in_progress = false;
+  if ( rq->message_callbacks->next == NULL ) {
+     debug( "No more callback for message_type = %#x.", message_type );
+     delete_receive_queue( rq->service_name, rq, NULL );
+  }
 }
 
 
@@ -1648,11 +1670,6 @@ on_send_write( int fd, void *data ) {
   debug( "Sending data to remote ( fd = %d, service_name = %s, buffer = %p, data_length = %zu ).",
          fd, sq->service_name, get_message_buffer_head( sq->buffer ), sq->buffer->data_length );
 
-  if ( sq->buffer->data_length < sizeof( message_header ) ) {
-    set_writable( sq->server_socket, false );
-    return;
-  }
-
   void *send_data;
   size_t send_len;
   ssize_t sent_len;
@@ -1664,8 +1681,14 @@ on_send_write( int fd, void *data ) {
     if ( sent_len == -1 ) {
       int err = errno;
       if ( err != EAGAIN && err != EWOULDBLOCK ) {
-        error( "Failed to send ( service_name = %s, fd = %d, errno = %s [%d] ).",
-               sq->service_name, fd, strerror( err ), err );
+        if ( err == EPIPE ) {
+          debug( "Failed to send ( service_name = %s, fd = %d, errno = %s [%d] ).",
+                 sq->service_name, fd, strerror( err ), err );
+        }
+        else {
+          error( "Failed to send ( service_name = %s, fd = %d, errno = %s [%d] ).",
+                 sq->service_name, fd, strerror( err ), err );
+        }
         send_dump_message( MESSENGER_DUMP_SEND_CLOSED, sq->service_name, NULL, 0 );
 
         set_readable( sq->server_socket, false );