static void
test_delete_timer_event() {
init_timer();
will_return_count( mock_clock_gettime, 0, -1 );
char user_data_1[] = "1";
char user_data_2[] = "2";
struct itimerspec interval;
interval.it_value.tv_sec = 1;
interval.it_value.tv_nsec = 0;
interval.it_interval.tv_sec = 1;
interval.it_interval.tv_nsec = 0;
assert_true( add_timer_event_callback( &interval, mock_timer_event_callback, user_data_1 ) );
interval.it_value.tv_sec = 2;
interval.it_interval.tv_sec = 2;
assert_true( add_timer_event_callback( &interval, mock_timer_event_callback, user_data_2 ) );
delete_timer_event( mock_timer_event_callback, user_data_1 );
timer_callback_info *callback = find_timer_callback( mock_timer_event_callback );
assert_true( callback != NULL );
assert_true( callback->user_data == user_data_2 );
delete_timer_event( mock_timer_event_callback, user_data_2 );
assert_true( find_timer_callback( mock_timer_event_callback ) == NULL );
finalize_timer();
}
static void
set_interval_timer( void ) {
unset_interval_timer();
if ( probe_timer_table->next == NULL ) {
debug( "interval: nil" );
return;
}
probe_timer_entry *entry = probe_timer_table->next->data;
struct timespec now;
struct itimerspec interval;
interval.it_interval.tv_sec = 0;
interval.it_interval.tv_nsec = 0;
get_current_time( &now );
timespec_sub( &( entry->expires ), &now, &( interval.it_value ) );
if ( interval.it_value.tv_sec < 0 || interval.it_value.tv_nsec < 0 ) {
interval.it_value.tv_sec = 0;
interval.it_value.tv_nsec = 1;
}
debug( "interval: %d.%09d", interval.it_value.tv_sec, interval.it_value.tv_nsec );
add_timer_event_callback( &interval, interval_timer_event, NULL );
debug( "set interval timer" );
}
static void
test_timer_event_callback() {
init_timer();
will_return_count( mock_clock_gettime, 0, -1 );
char user_data[] = "It's time!!!";
struct itimerspec interval;
interval.it_value.tv_sec = 1;
interval.it_value.tv_nsec = 1000;
interval.it_interval.tv_sec = 2;
interval.it_interval.tv_nsec = 2000;
assert_true( add_timer_event_callback( &interval, mock_timer_event_callback, user_data ) );
timer_callback_info *callback = find_timer_callback( mock_timer_event_callback );
assert_true( callback != NULL );
assert_true( callback->function == mock_timer_event_callback );
assert_string_equal( callback->user_data, "It's time!!!" );
assert_int_equal( callback->interval.tv_sec, 2 );
assert_int_equal( callback->interval.tv_nsec, 2000 );
delete_timer_event( mock_timer_event_callback, user_data );
assert_true( find_timer_callback( mock_timer_event_callback ) == NULL );
finalize_timer();
}
static void
backoff() {
if ( connection.fd >= 0 ) {
close( connection.fd );
}
struct itimerspec spec = { { 0, 0 }, { 5, 0 } };
add_timer_event_callback( &spec, reconnect, NULL );
}
static void
switch_set_timeout( long sec, timer_callback callback, void *user_data ) {
struct itimerspec interval;
interval.it_value.tv_sec = sec;
interval.it_value.tv_nsec = 0;
interval.it_interval.tv_sec = 0;
interval.it_interval.tv_nsec = 0;
add_timer_event_callback( &interval, callback, user_data );
switch_info.running_timer = true;
}
static void
switch_set_timeout( long sec, void ( *callback )( void *user_data ), void *user_data ) {
struct itimerspec interval;
UNUSED( user_data );
interval.it_value.tv_sec = sec;
interval.it_value.tv_nsec = 0;
interval.it_interval.tv_sec = 0;
interval.it_interval.tv_nsec = 0;
add_timer_event_callback( &interval, callback, NULL );
}
static void
set_interval_timer( void ) {
struct itimerspec interval;
interval.it_interval.tv_sec = 0;
interval.it_interval.tv_nsec = 500000000;
interval.it_value.tv_sec = 0;
interval.it_value.tv_nsec = 0;
add_timer_event_callback( &interval, interval_timer_event, NULL );
debug( "set interval timer" );
}
static VALUE
switch_start_chibach( VALUE self ) {
struct itimerspec interval;
interval.it_interval.tv_sec = 0;
interval.it_interval.tv_nsec = 1000000;
interval.it_value.tv_sec = 0;
interval.it_value.tv_nsec = 0;
add_timer_event_callback( &interval, thread_pass, NULL );
start_chibach();
return self;
}
/*
* In the context of trema framework invokes the scheduler to start its applications.
*/
static VALUE
controller_start_trema( VALUE self ) {
struct itimerspec interval;
interval.it_interval.tv_sec = 0;
interval.it_interval.tv_nsec = 1000000;
interval.it_value.tv_sec = 0;
interval.it_value.tv_nsec = 0;
add_timer_event_callback( &interval, thread_pass, NULL );
start_trema();
return self;
}
static void
set_timer_event( void ) {
struct itimerspec ts;
ts.it_value.tv_sec = 0;
ts.it_value.tv_nsec = 0;
ts.it_interval.tv_sec = 0;
ts.it_interval.tv_nsec = 1000000;
bool ret = add_timer_event_callback( &ts, flush_packet_buffer, NULL );
if ( !ret ) {
error( "Failed to set queue flush timer." );
}
}
static void
test_add_timer_event_callback_fail_with_invalid_timespec() {
init_timer();
will_return_count( mock_clock_gettime, 0, -1 );
char user_data[] = "It's time!!!";
struct itimerspec interval;
interval.it_value.tv_sec = 0;
interval.it_value.tv_nsec = 0;
interval.it_interval.tv_sec = 0;
interval.it_interval.tv_nsec = 0;
assert_false( add_timer_event_callback( &interval, mock_timer_event_callback, user_data ) );
finalize_timer();
}
/**
* Updates the timer interval for a timer represented by the callback function
* and calls add_timer_event_callback which updates this entry to event list.
* @param seconds Time interval in seconds for timer entry
* @param callback Pointer to callback function
* @param user_data Pointer to string
* @return bool True if timer is sucessfully added in list, else False
* @see add_timer_event_callback
*/
bool
add_periodic_event_callback( const time_t seconds, void ( *callback )( void *user_data ), void *user_data ) {
assert( callback != NULL );
debug( "Adding a periodic event callback ( interval = %u, callback = %p, user_data = %p ).",
seconds, callback, user_data );
struct itimerspec interval;
interval.it_value.tv_sec = 0;
interval.it_value.tv_nsec = 0;
interval.it_interval.tv_sec = seconds;
interval.it_interval.tv_nsec = 0;
return add_timer_event_callback( &interval, callback, user_data );
}
bool
_add_periodic_event_callback( const time_t seconds, timer_callback callback, void *user_data ) {
assert( callback != NULL );
debug( "Adding a periodic event callback ( interval = %" PRIu64 ", callback = %p, user_data = %p ).",
( const int64_t ) seconds, callback, user_data );
struct itimerspec interval;
interval.it_value.tv_sec = 0;
interval.it_value.tv_nsec = 0;
interval.it_interval.tv_sec = seconds;
interval.it_interval.tv_nsec = 0;
return add_timer_event_callback( &interval, callback, user_data );
}
bool
init_transaction_manager() {
debug( "Initializing transaction manager." );
create_transaction_db();
set_barrier_reply_handler( handle_barrier_reply, NULL );
set_error_handler( handle_error, NULL );
struct itimerspec interval;
interval.it_interval = TRANSACTION_AGING_INTERVAL;
interval.it_value = TRANSACTION_AGING_INTERVAL;
add_timer_event_callback( &interval, age_transaction_entries, NULL );
debug( "Initialization completed." );
return true;
}
/*
* Starts this controller. Usually you do not need to invoke
* explicitly, because this is called implicitly by "trema run"
* command.
*/
static VALUE
controller_run( VALUE self ) {
setenv( "TREMA_HOME", STR2CSTR( rb_funcall( mTrema, rb_intern( "home" ), 0 ) ), 1 );
VALUE name = rb_funcall( self, rb_intern( "name" ), 0 );
rb_gv_set( "$PROGRAM_NAME", name );
int argc = 3;
char **argv = xmalloc( sizeof( char * ) * ( uint32_t ) ( argc + 1 ) );
argv[ 0 ] = STR2CSTR( name );
argv[ 1 ] = ( char * ) ( uintptr_t ) "--name";
argv[ 2 ] = STR2CSTR( name );
argv[ 3 ] = NULL;
init_trema( &argc, &argv );
xfree( argv );
set_switch_ready_handler( handle_switch_ready, ( void * ) self );
set_features_reply_handler( handle_features_reply, ( void * ) self );
set_packet_in_handler( handle_packet_in, ( void * ) self );
set_flow_removed_handler( handle_flow_removed, ( void * ) self );
set_switch_disconnected_handler( handle_switch_disconnected, ( void * ) self );
set_port_status_handler( handle_port_status, ( void * ) self );
set_stats_reply_handler( handle_stats_reply, ( void * ) self );
set_error_handler( handle_openflow_error, ( void * ) self );
set_get_config_reply_handler( handle_get_config_reply, ( void * ) self );
set_barrier_reply_handler( handle_barrier_reply, ( void * ) self );
set_vendor_handler( handle_vendor, ( void * ) self );
set_queue_get_config_reply_handler( handle_queue_get_config_reply, ( void * ) self );
set_list_switches_reply_handler( handle_list_switches_reply );
struct itimerspec interval;
interval.it_interval.tv_sec = 1;
interval.it_interval.tv_nsec = 0;
interval.it_value.tv_sec = 0;
interval.it_value.tv_nsec = 0;
add_timer_event_callback( &interval, handle_timer_event, ( void * ) self );
if ( rb_respond_to( self, rb_intern( "start" ) ) == Qtrue ) {
rb_funcall( self, rb_intern( "start" ), 0 );
}
rb_funcall( self, rb_intern( "start_trema" ), 0 );
return self;
}
void
_dispatch_to_all_switch( uint64_t *dpids, size_t n_dpids, void *user_data ) {
struct event_forward_operation_to_all_request_param *param = user_data;
all_sw_tx *tx = _insert_tx( n_dpids, param );
info( "txid %#x Start dispatching to switches", tx->txid );
debug( "dispatching to %zd switches", n_dpids );
// copy dpid hash to transaction.
for ( size_t i = 0 ; i < n_dpids ; ++i ) {
uint64_t *dpid = xmalloc( sizeof( uint64_t ) );
*dpid = dpids[i];
uint64_t *dupe_dpid = insert_hash_entry( tx->waiting_dpid, dpid, dpid );
if ( dupe_dpid == NULL ) {
struct txinfo *txinfo = xcalloc( 1, sizeof( struct txinfo ) );
txinfo->dpid = *dpid;
txinfo->txid = tx->txid;
bool send_ok;
if ( param->add ) {
send_ok = add_switch_event_forward_entry( *dpid, param->type, param->service_name, _switch_response_handler, txinfo );
}
else {
send_ok = delete_switch_event_forward_entry( *dpid, param->type, param->service_name, _switch_response_handler, txinfo );
}
if ( !send_ok ) {
tx->tx_result = EFI_OPERATION_FAILED;
warn( "txid %#x Failed to send request to switch %#" PRIx64 ".", tx->txid, *dpid );
xfree( delete_hash_entry( tx->waiting_dpid, dpid ) );
dpid = NULL;
xfree( txinfo );
continue;
}
struct itimerspec interval;
interval.it_interval.tv_sec = 0;
interval.it_interval.tv_nsec = 0;
interval.it_value.tv_sec = 5; // FIXME make this configurable?
interval.it_value.tv_nsec = 0;
bool set_ok = add_timer_event_callback( &interval, _switch_response_timeout, txinfo );
if ( !set_ok ) {
tx->tx_result = EFI_OPERATION_FAILED;
warn( "txid %#x Failed to set timeout timer for switch %#" PRIx64 ".", tx->txid, *dpid );
xfree( delete_hash_entry( tx->waiting_dpid, dpid ) );
dpid = NULL;
// txinfo will be freed by _switch_response_handler
continue;
}
}
else {
warn( "Duplicate dpid returned %#." PRIx64, *dupe_dpid );
xfree( dupe_dpid );
}
}
if ( n_dpids == 0 || tx->tx_result == EFI_OPERATION_FAILED ) {
if ( n_dpids == 0 ) {
info( "txid %#x completed. No switches found.", tx->txid );
}
else if ( tx->tx_result == EFI_OPERATION_FAILED ) {
info( "txid %#x completed with failure.", tx->txid );
}
if ( param->callback != NULL ) {
param->callback( tx->tx_result, param->user_data );
}
// remove and cleanup tx
delete_hash_entry( efi_tx_table, &tx->txid );
xfree_all_sw_tx( tx );
}
}
