static void Send_status_query()
{
int32 proc_id;
proc p;
int proc_index;
int i,j;
Pack.type = STATUS_TYPE;
Pack.type = Set_endian( Pack.type );
Pack.conf_hash = MONITOR_HASH;
Pack.data_len= 0;
Pack_scat.num_elements = 1;
Alarm( PRINT , "Monitor: send status query\n");
for( i=0; i < Cn.num_segments ; i++ )
{
for( j=0; j < Cn.segments[i].num_procs; j++ )
{
proc_id = Cn.segments[i].procs[j]->id;
proc_index = Conf_proc_by_id( proc_id, &p );
if( Status_vector[proc_index] )
{
DL_send( SendChan, p.id, p.port, &Pack_scat );
}
}
}
#ifndef _REENTRANT
E_queue( Send_status_query, 0, NULL, Send_status_timeout );
#endif
}
static void Send_partition()
{
int32 proc_id;
proc p;
int proc_index;
int i,j;
Pack.type = PARTITION_TYPE;
Pack.type = Set_endian( Pack.type );
Pack.conf_hash = MONITOR_HASH;
Pack.data_len= sizeof( Partition );;
Pack_scat.num_elements = 2;
Pack_scat.elements[1].len = sizeof( Partition );
Pack_scat.elements[1].buf = (char *)&Partition;
Alarm( PRINT , "Monitor: send partition\n");
for( i=0; i < Cn.num_segments ; i++ )
{
for( j=0; j < Cn.segments[i].num_procs; j++ )
{
proc_id = Cn.segments[i].procs[j]->id;
proc_index = Conf_proc_by_id( proc_id, &p );
DL_send( SendChan, p.id, p.port, &Pack_scat );
DL_send( SendChan, p.id, p.port, &Pack_scat );
}
}
#ifndef _REENTRANT
E_queue( Send_partition, 0, NULL, Send_partition_timeout );
#endif
}
static void Send_flow_control()
{
int32 proc_id;
proc p;
int proc_index;
int i,j;
Pack.type = FC_TYPE;
Pack.type = Set_endian( Pack.type );
Pack.conf_hash = MONITOR_HASH;
Pack.data_len= sizeof( Fc_buf );;
Pack_scat.num_elements = 2;
Pack_scat.elements[1].len = sizeof( Fc_buf );
Pack_scat.elements[1].buf = (char *)&Fc_buf;
Alarm( PRINT , "Monitor: send flow control params\n");
for( i=0; i < Cn.num_segments ; i++ )
{
for( j=0; j < Cn.segments[i].num_procs; j++ )
{
proc_id = Cn.segments[i].procs[j]->id;
proc_index = Conf_proc_by_id( proc_id, &p );
DL_send( SendChan, p.id, p.port, &Pack_scat );
DL_send( SendChan, p.id, p.port, &Pack_scat );
}
}
}
static void Print_flow_control( int16 fc_buf[MAX_PROCS_RING][2] )
{
int32 proc_id;
proc p;
int proc_index;
int i,j;
printf("\n");
printf("========================\n");
printf("Flow Control Parameters:\n");
printf("------------------------\n");
printf("\n");
printf("Window size: %d\n",fc_buf[ Conf_num_procs( &Cn )][0]);
printf("\n");
for( i=0; i < Cn.num_segments ; i++ )
{
for( j=0; j < Cn.segments[i].num_procs; j++ )
{
proc_id = Cn.segments[i].procs[j]->id;
proc_index = Conf_proc_by_id( proc_id, &p );
printf("\t%s personal window\t%d\n", p.name, fc_buf[proc_index][0] );
if (Conf_get_accelerated_ring()) {
printf("\t%s accelerated window\t%d\n", p.name, fc_buf[proc_index][1] );
}
}
printf("\n");
}
printf("\n");
printf("Monitor> ");
fflush(stdout);
}
static void Print_partition( int16 partition[MAX_PROCS_RING] )
{
int32 proc_id;
proc p;
int proc_index;
int i,j;
printf("\n");
printf("=============\n");
printf("Partition Map:\n");
printf("-------------\n");
printf("\n");
for( i=0; i < Cn.num_segments ; i++ )
{
for( j=0; j < Cn.segments[i].num_procs; j++ )
{
proc_id = Cn.segments[i].procs[j]->id;
proc_index = Conf_proc_by_id( proc_id, &p );
printf("\t%s\t%d\n", p.name, partition[proc_index] );
}
printf("\n");
}
printf("\n");
printf("Monitor> ");
fflush(stdout);
}
void Stat_handle_message( sys_scatter *scat )
{
sp_time now;
sp_time delta;
packet_header *pack_ptr;
proc p;
int ret;
pack_ptr = (packet_header *)scat->elements[0].buf;
if( ! ( pack_ptr->memb_id.proc_id == 15051963 && Conf_id_in_conf( Conf_ref(), pack_ptr->proc_id ) != -1 ) )
{
Alarm( STATUS, "Stat_handle_message: Illegal monitor request\n");
return;
}
now = E_get_time();
delta = E_sub_time( now, Start_time );
GlobalStatus.sec = delta.sec;
DL_send( Report_channel, pack_ptr->proc_id, pack_ptr->seq, &Report_scat );
ret = Conf_proc_by_id( pack_ptr->proc_id, &p );
if( ret < 0 )
Alarm( STATUS,
"Stat_handle_message: sent status to Monitor at %d\n",
pack_ptr->proc_id );
else Alarm( STATUS,
"Stat_handle_message: sent status to Monitor at %s\n",
p.name );
}
void FC_handle_message( sys_scatter *scat )
{
int16 *cur_fc_buf;
packet_header *pack_ptr;
proc dummy_proc;
int my_index;
int16 temp_window,temp_personal_window;
configuration *Cn;
Cn = Conf_ref();
pack_ptr = (packet_header *)scat->elements[0].buf;
if ( ! Conf_get_dangerous_monitor_state() ) {
Alarm( FLOW_CONTROL, "FC_handle_message: Request to change flow control from (%d.%d.%d.%d) denied. Monitor in safe mode\n", IP1(pack_ptr->proc_id), IP2(pack_ptr->proc_id), IP3(pack_ptr->proc_id), IP4(pack_ptr->proc_id) );
return;
}
if( ! ( pack_ptr->memb_id.proc_id == 15051963 && Conf_id_in_conf( Cn, pack_ptr->proc_id ) != -1 ) )
{
Alarm( FLOW_CONTROL,
"FC_handle_message: Illegal monitor request\n");
return;
}
cur_fc_buf = (int16 *)scat->elements[1].buf;
my_index = Conf_proc_by_id( Conf_my().id, &dummy_proc );
if( Same_endian( pack_ptr->type ) ) {
temp_window = cur_fc_buf[Conf_num_procs( Cn )];
temp_personal_window = cur_fc_buf[my_index];
}else{
temp_window = Flip_int16( cur_fc_buf[Conf_num_procs( Cn )] );
temp_personal_window = Flip_int16( cur_fc_buf[my_index] );
}
if( temp_window != -1 ) Window = temp_window;
if( temp_personal_window != -1 ) Personal_window = temp_personal_window;
GlobalStatus.window = Window;
GlobalStatus.personal_window = Personal_window;
Alarm( FLOW_CONTROL,
"FC_handle_message: Got monitor mess, Window %d Personal %d\n",
Window, Personal_window );
}
/* Basic algorithm:
* 1) have configuration code load new conf file and check for modifications to conf.
* 2) If only add/sub of daemons, then initiate membership change with token_loss and return;
* 3) else, then set Conf_reload_state, create singleton partition, and schedule token_loss.
* 4) When membership completes in Discard_packets() cleanup partition and probe for new members.
*/
void Prot_initiate_conf_reload( int code, void *data )
{
bool need_memb_partition;
int16 singleton_partition[MAX_PROCS_RING];
int i;
if (Memb_state() != OP ) {
/* This is a race condition, that the Prot_initiate_conf_reload was scheduled when OP state,
* but another membership occured before it was executed.
* The membership system will requeue this function when it reaches OP state again.
*/
return;
}
/* Disable queueing of this function when OP state reached in membership */
Prot_clear_need_conf_reload();
need_memb_partition = Conf_reload_initiate();
/* Signal all subsystems to update Conf and My strucures */
Net_signal_conf_reload();
Memb_signal_conf_reload();
Sess_signal_conf_reload();
/* update protocol varialbes with new conf */
My = Conf_my();
My_index = Conf_proc_by_id( My.id, &My );
if (need_memb_partition) {
/* make partition */
for ( i = 0 ; i < Conf_num_procs( Conf_ref() ); i++ )
{
singleton_partition[i] = i;
}
Net_set_partition(singleton_partition);
Conf_reload_singleton_state_begin();
}
E_queue( Memb_token_loss, 0, NULL, Zero_timeout );
}
static void Define_partition()
{
int32 proc_id;
proc p;
int proc_index;
char str[80];
int legal,ret,temp;
int i,j;
printf("\n");
printf("=============\n");
printf("Define Partition\n");
printf("-------------\n");
printf("\n");
for( i=0; i < Cn.num_segments ; i++ )
{
for( j=0; j < Cn.segments[i].num_procs; j++ )
{
proc_id = Cn.segments[i].procs[j]->id;
proc_index = Conf_proc_by_id( proc_id, &p );
for( legal=0; !legal; )
{
printf("\t%s\t", p.name);
if( fgets( str, 70, stdin ) == NULL )
{
printf("Bye.\n");
exit(0);
}
ret = sscanf(str, "%d", &temp );
Work_partition[proc_index] = temp;
if( ret > 0 ) legal = 1;
else printf("Please enter a number\n");
}
}
printf("\n");
}
}
void Prot_init(void)
{
int i, num_bcast, num_token;
channel *bcast_channels;
channel *token_channels;
Mem_init_object( PACK_HEAD_OBJ, sizeof( packet_header ), MAX_PACKETS_IN_STRUCT, 0 );
Mem_init_object( PACKET_BODY, sizeof( packet_body ), MAX_PACKETS_IN_STRUCT, 0 );
Mem_init_object( TOKEN_HEAD_OBJ, sizeof( token_header ), 10, 0 );
Mem_init_object( TOKEN_BODY_OBJ, sizeof( token_body ), 10, 0 );
Mem_init_object( SCATTER, sizeof( scatter ), 200+MAX_PROCS_RING, 0 );
My = Conf_my();
My_index = Conf_proc_by_id( My.id, &My );
GlobalStatus.my_id = My.id;
GlobalStatus.packet_delivered = 0;
for( i=0; i < MAX_PROCS_RING+1; i++ )
Up_queue[i].exist = 0;
for( i=0; i < MAX_PACKETS_IN_STRUCT; i++ )
Packets[i].exist = 0;
if ( Conf_debug_initial_sequence() ) {
Highest_seq = INITIAL_SEQUENCE_NEAR_WRAP;
Highest_fifo_seq = INITIAL_SEQUENCE_NEAR_WRAP;
My_aru = INITIAL_SEQUENCE_NEAR_WRAP;
Aru = INITIAL_SEQUENCE_NEAR_WRAP;
Set_aru = INITIAL_SEQUENCE_NEAR_WRAP -1;
Last_discarded = INITIAL_SEQUENCE_NEAR_WRAP;
Last_delivered = INITIAL_SEQUENCE_NEAR_WRAP;
} else {
Highest_seq = 0;
Highest_fifo_seq = 0;
My_aru = 0;
Aru = 0;
Set_aru = -1;
Last_discarded = 0;
Last_delivered = 0;
}
New_pack.num_elements = 2;
New_pack.elements[0].len = sizeof(packet_header);
New_pack.elements[0].buf = (char *) new(PACK_HEAD_OBJ);
New_pack.elements[1].len = sizeof(packet_body);
New_pack.elements[1].buf = (char *) new(PACKET_BODY);
New_token.num_elements = 2;
New_token.elements[0].len = sizeof(token_header);
New_token.elements[0].buf = (char *) new(TOKEN_HEAD_OBJ);
New_token.elements[1].len = sizeof(token_body);
New_token.elements[1].buf = (char *) new(TOKEN_BODY_OBJ);
Send_pack.num_elements = 2;
Send_pack.elements[0].len = sizeof(packet_header);
Token = (token_header *)New_token.elements[0].buf;
Last_token = new(TOKEN_HEAD_OBJ);
Last_token->type = 0;
Last_token->seq = 0;
Last_token->aru = 0;
Last_token->flow_control = 0;
Last_token->conf_hash = 0;
Hurry_pack.num_elements = 1;
Hurry_pack.elements[0].len = sizeof(packet_header);
Hurry_pack.elements[0].buf = (char *) new(PACKET_BODY);
Hurry_head = (packet_header *)Hurry_pack.elements[0].buf;
Hurry_head->proc_id = My.id;
Hurry_head->type = HURRY_TYPE;
Net_init();
bcast_channels = Net_bcast_channel();
token_channels = Net_token_channel();
Net_num_channels( &num_bcast, &num_token);
for ( i = 0; i < num_bcast; i++) {
E_attach_fd( *bcast_channels, READ_FD, Prot_handle_bcast, 0, NULL, HIGH_PRIORITY );
bcast_channels++;
}
for ( i = 0; i < num_token; i++) {
E_attach_fd( *token_channels, READ_FD, Prot_handle_token, 0, NULL, MEDIUM_PRIORITY );
token_channels++;
}
FC_init( );
Memb_init();
Net_set_membership( Reg_membership );
}
static void Prot_handle_bcast(channel fd, int dummy, void *dummy_p)
{
packet_header *pack_ptr;
int pack_entry;
proc p;
int received_bytes;
int total_bytes_processed;
int num_buffered_packets;
int i;
int32 j;
/* int r1,r2; */
received_bytes = Net_recv( fd, &New_pack );
/* My own packet or from another monitor component */
if( received_bytes == 0 ) return;
/* problem in receiving */
if( received_bytes < 0 ) return;
pack_ptr = (packet_header *)New_pack.elements[0].buf;
/* ### Pack, this has to move down to network.c
* if( pack_ptr->data_len +sizeof(packet_header) != received_bytes )
* {
* Alarm( PRINT, "Prot_handle_bcast: received %d, should be %d\n",
* received_bytes, pack_ptr->data_len+sizeof(packet_header) );
* return;
* }
*/
if( Is_status( pack_ptr->type ) )
{
Stat_handle_message( &New_pack );
return;
}
if( Is_fc( pack_ptr->type ) )
{
FC_handle_message( &New_pack );
return;
}
if( Is_conf_reload( pack_ptr->type ) )
{
Prot_handle_conf_reload( &New_pack );
return;
}
/* delete random
r1 = ((-My.id)%17)+3;
r2 = get_rand() % (r1+3 );
if ( r2 == 0 ) return; */
if( Is_membership( pack_ptr->type ) )
{
Memb_handle_message( &New_pack );
return;
}
if( Is_hurry( pack_ptr->type ) )
{
Handle_hurry( pack_ptr );
return;
}
if( !Is_regular( pack_ptr->type ) )
{
Alarm( PROTOCOL, "Prot_handle_bcast: Unknown packet type %d\n",
pack_ptr->type );
return;
}
if( ! Memb_is_equal( Memb_id(), pack_ptr->memb_id ) )
{
/* Foreign message */
Memb_handle_message( &New_pack );
return;
}
if (Memb_token_alive() ) {
E_queue( Memb_token_loss, 0, NULL, Token_timeout );
if( Conf_leader( Memb_active_ptr() ) == My.id )
{
E_queue( Prot_token_hurry, 0, NULL, Hurry_timeout );
}
}
/* ### Pack: next 70 lines (almost till the end of the routine) have changed */
Buffered_packets[0].head = pack_ptr;
Buffered_packets[0].body = (packet_body *)New_pack.elements[1].buf;
received_bytes -= sizeof(packet_header);
total_bytes_processed = pack_ptr->data_len;
/* ignore any alignment padding */
switch(total_bytes_processed % 4)
{
case 1:
total_bytes_processed++;
case 2:
total_bytes_processed++;
case 3:
total_bytes_processed++;
case 0:
/* already aligned */
break;
}
for( i = 1; received_bytes > total_bytes_processed; i++ )
{
/* copy into each of the elements after the first element*/
Buffered_packets[i].head = (packet_header *)new(PACK_HEAD_OBJ);
Buffered_packets[i].body = (packet_body *)new(PACKET_BODY);
if (Buffered_packets[i].head == NULL)
Alarm(EXIT, "Prot_handle_bcast: Memory allocation failed for PACK_HEAD_OBJ\n");
if (Buffered_packets[i].body == NULL)
Alarm(EXIT, "Prot_handle_bcast: Memory allocation failed for PACKET_BODY\n");
pack_ptr = (packet_header *)&New_pack.elements[1].buf[total_bytes_processed];
memcpy( Buffered_packets[i].head, pack_ptr, sizeof( packet_header ) );
total_bytes_processed += sizeof(packet_header);
memcpy( Buffered_packets[i].body, &New_pack.elements[1].buf[total_bytes_processed], pack_ptr->data_len);
total_bytes_processed += pack_ptr->data_len;
/* ignore any alignment padding */
switch(total_bytes_processed % 4)
{
case 1:
total_bytes_processed++;
case 2:
total_bytes_processed++;
case 3:
total_bytes_processed++;
case 0:
/* already aligned */
break;
}
}
num_buffered_packets = i;
for( i = 0; i < num_buffered_packets; i++)
{
pack_ptr = Buffered_packets[i].head;
/* do we have this packet */
if( pack_ptr->seq <= Aru )
{
Alarm( PROTOCOL, "Prot_handle_bcast: delayed packet %d already delivered (Aru %d)\n",
pack_ptr->seq, Aru );
dispose(Buffered_packets[i].head);
dispose(Buffered_packets[i].body);
continue;
}
pack_entry = pack_ptr->seq & PACKET_MASK;
if( Packets[pack_entry].exist )
{
Alarm( PROTOCOL, "Prot_handle_bcast: packet %d already exist\n",
pack_ptr->seq );
dispose(Buffered_packets[i].head);
dispose(Buffered_packets[i].body);
continue;
}
Packets[pack_entry].proc_index = Conf_proc_by_id( pack_ptr->proc_id, &p );
if( Packets[pack_entry].proc_index < 0 )
{
Alarm( PROTOCOL, "Prot_handle_bcast: unknown proc %d\n", pack_ptr->proc_id );
dispose(Buffered_packets[i].head);
dispose(Buffered_packets[i].body);
continue;
}
/* insert new packet */
Packets[pack_entry].head = pack_ptr;
Packets[pack_entry].body = Buffered_packets[i].body;
Packets[pack_entry].exist = 1;
/* update variables */
if( Highest_seq < pack_ptr->seq ) Highest_seq = pack_ptr->seq;
if( pack_ptr->seq == My_aru+1 )
{
for( j=pack_ptr->seq; j <= Highest_seq; j++ )
{
if( ! Packets[j & PACKET_MASK].exist ) break;
My_aru++;
}
Deliver_agreed_packets();
}else Deliver_reliable_packets( pack_ptr->seq, 1 );
Alarm( PROTOCOL, "Prot_handle_bcast: packet %d inserted\n",
pack_ptr->seq );
} /* END OF LOOP */
GlobalStatus.packet_recv++;
GlobalStatus.my_aru = My_aru;
GlobalStatus.highest_seq = Highest_seq;
/* prepare New_pack for next packet */
New_pack.elements[0].buf = (char *) new(PACK_HEAD_OBJ);
New_pack.elements[1].buf = (char *) new(PACKET_BODY);
}
static void Report_message(mailbox fd, int dummy, void *dummy_p)
{
proc p;
proc leader_p;
int ret;
int ret1,ret2;
static int32 last_mes;
static int32 last_aru;
static int32 last_sec;
last_mes = GlobalStatus.message_delivered;
last_aru = GlobalStatus.aru;
last_sec = GlobalStatus.sec;
ret = DL_recv( fd, &Report_scat );
if( ret <= 0 ) {
Alarm( DEBUG, "Report_messsage: DL_recv failed with ret %d, errno %d\n", ret, sock_errno);
return;
}
if( !Same_endian( Report_pack.type ) )
{
GlobalStatus.sec = Flip_int32( GlobalStatus.sec );
GlobalStatus.state = Flip_int32( GlobalStatus.state );
GlobalStatus.gstate = Flip_int32( GlobalStatus.gstate );
GlobalStatus.packet_sent = Flip_int32( GlobalStatus.packet_sent );
GlobalStatus.packet_recv = Flip_int32( GlobalStatus.packet_recv );
GlobalStatus.packet_delivered = Flip_int32( GlobalStatus.packet_delivered );
GlobalStatus.retrans = Flip_int32( GlobalStatus.retrans );
GlobalStatus.u_retrans = Flip_int32( GlobalStatus.u_retrans );
GlobalStatus.s_retrans = Flip_int32( GlobalStatus.s_retrans );
GlobalStatus.b_retrans = Flip_int32( GlobalStatus.b_retrans );
GlobalStatus.aru = Flip_int32( GlobalStatus.aru );
GlobalStatus.my_aru = Flip_int32( GlobalStatus.my_aru );
GlobalStatus.highest_seq = Flip_int32( GlobalStatus.highest_seq );
GlobalStatus.token_hurry = Flip_int32( GlobalStatus.token_hurry );
GlobalStatus.token_rounds = Flip_int32( GlobalStatus.token_rounds );
GlobalStatus.my_id = Flip_int32( GlobalStatus.my_id );
GlobalStatus.leader_id = Flip_int32( GlobalStatus.leader_id );
GlobalStatus.message_delivered = Flip_int32( GlobalStatus.message_delivered );
GlobalStatus.membership_changes = Flip_int16( GlobalStatus.membership_changes);
GlobalStatus.num_procs = Flip_int16( GlobalStatus.num_procs );
GlobalStatus.num_segments = Flip_int16( GlobalStatus.num_segments );
GlobalStatus.window = Flip_int16( GlobalStatus.window );
GlobalStatus.personal_window = Flip_int16( GlobalStatus.personal_window );
GlobalStatus.accelerated_ring = Flip_int16( GlobalStatus.accelerated_ring );
GlobalStatus.accelerated_window = Flip_int16( GlobalStatus.accelerated_window );
GlobalStatus.num_sessions = Flip_int16( GlobalStatus.num_sessions );
GlobalStatus.num_groups = Flip_int16( GlobalStatus.num_groups );
GlobalStatus.major_version = Flip_int16( GlobalStatus.major_version );
GlobalStatus.minor_version = Flip_int16( GlobalStatus.minor_version );
GlobalStatus.patch_version = Flip_int16( GlobalStatus.patch_version );
}
printf("\n============================\n");
ret1 = Conf_proc_by_id( GlobalStatus.my_id, &p );
ret2 = Conf_proc_by_id( GlobalStatus.leader_id, &leader_p );
if( ret1 < 0 )
{
printf("Report_message: Skiping illegal status \n");
printf("==================================\n");
return;
}
printf("Status at %s V%2d.%02d.%2d (state %d, gstate %d) after %d seconds :\n",p.name,
GlobalStatus.major_version,GlobalStatus.minor_version,GlobalStatus.patch_version,
GlobalStatus.state, GlobalStatus.gstate, GlobalStatus.sec);
if( ret2 < 0 )
printf("Membership : %d procs in %d segments, leader is %d, ",
GlobalStatus.num_procs,GlobalStatus.num_segments,GlobalStatus.leader_id);
else printf("Membership : %d procs in %d segments, leader is %s, ",
GlobalStatus.num_procs,GlobalStatus.num_segments,leader_p.name);
if (GlobalStatus.accelerated_ring == 0)
printf("regular protocol\n");
else
printf("accelerated protocol\n");
printf("rounds : %7d\ttok_hurry : %7d\tmemb change: %7d\n",GlobalStatus.token_rounds,GlobalStatus.token_hurry,GlobalStatus.membership_changes);
printf("sent pack: %7d\trecv pack : %7d\tretrans : %7d\n",GlobalStatus.packet_sent,GlobalStatus.packet_recv,GlobalStatus.retrans);
printf("u retrans: %7d\ts retrans : %7d\tb retrans : %7d\n",GlobalStatus.u_retrans,GlobalStatus.s_retrans,GlobalStatus.b_retrans);
printf("My_aru : %7d\tAru : %7d\tHighest seq: %7d\n",GlobalStatus.my_aru,GlobalStatus.aru, GlobalStatus.highest_seq);
printf("Sessions : %7d\tGroups : %7d\tWindow : %7d\n",GlobalStatus.num_sessions,GlobalStatus.num_groups,GlobalStatus.window);
printf("Deliver M: %7d\tDeliver Pk: %7d\tP/A Window : %7d/%d\n",GlobalStatus.message_delivered,GlobalStatus.packet_delivered,GlobalStatus.personal_window,GlobalStatus.accelerated_window);
printf("Delta Mes: %7d\tDelta Pk : %7d\tDelta sec : %7d\n",GlobalStatus.message_delivered - last_mes,GlobalStatus.aru - last_aru,GlobalStatus.sec - last_sec);
printf("==================================\n");
printf("\n");
printf("Monitor> ");
fflush(stdout);
}
static void Kill_spreads()
{
int16 Kill_partition[MAX_PROCS_RING];
proc p;
int proc_index;
int32 proc_id;
char str[80];
int legal, ret;
int i, j;
int end;
for( i=0; i < MAX_PROCS_RING; i++ )
Kill_partition[i] = 0;
end = 0;
while( !end )
{
for( legal=0; !legal; )
{
printf("\tEnter Proc Name to Terminate: ");
if( fgets( str, 70, stdin ) == NULL )
{
printf("Bye.\n");
exit(0);
}
ret = sscanf(str, "%s", p.name );
if( ret > 0 || str[0] == '\n' ) legal = 1;
else printf("Please enter a legal proc name, none, or all\n");
}
if( str[0] == '\n' ){
end = 1;
}else if( !strcmp( p.name, "all" ) ){
for( i=0; i < Conf_num_procs( &Cn ); i++ )
Kill_partition[i] = -1;
}else if( !strcmp( p.name, "none" ) ){
for( i=0; i < Conf_num_procs( &Cn ); i++ )
Kill_partition[i] = 0;
}else{
proc_index = Conf_proc_by_name( p.name, &p );
if( proc_index != -1 ){
Kill_partition[proc_index] = -1;
}else printf("Please! enter a legal proc name, none, or all\n");
}
}
for( i=0; i < Conf_num_procs( &Cn ); i++ )
{
if( Kill_partition[i] != -1 ) Kill_partition[i] = Partition[i];
}
Pack.type = PARTITION_TYPE;
Pack.type = Set_endian( Pack.type );
Pack.conf_hash = MONITOR_HASH;
Pack.data_len= sizeof( Kill_partition );;
Pack_scat.num_elements = 2;
Pack_scat.elements[1].len = sizeof( Kill_partition );
Pack_scat.elements[1].buf = (char *)&Kill_partition;
for( i=0; i < Cn.num_segments ; i++ )
{
for( j=0; j < Cn.segments[i].num_procs; j++ )
{
proc_id = Cn.segments[i].procs[j]->id;
proc_index = Conf_proc_by_id( proc_id, &p );
if( Kill_partition[proc_index] == -1 )
{
Alarm( PRINT , "Monitor: Terminating %s\n", p.name );
DL_send( SendChan, p.id, p.port, &Pack_scat );
DL_send( SendChan, p.id, p.port, &Pack_scat );
}
}
}
}
static void Define_flow_control()
{
int32 proc_id;
proc p;
int proc_index;
char str[80];
int legal,ret,temp;
int i,j;
printf("\n");
printf("===================\n");
printf("Define Flow Control\n");
printf("-------------------\n");
printf("\n");
for( legal=0; !legal; )
{
printf(" Window size: ");
if( fgets( str,70,stdin ) == NULL )
{
printf("Bye.\n");
exit(0);
}
ret = sscanf(str, "%d", &temp );
Work_fc_buf[Conf_num_procs( &Cn )][0] = temp;
if( ret > 0 ) legal = 1;
else if( ret == -1 ){
legal = 1;
Work_fc_buf[Conf_num_procs( &Cn )][0] = -1;
}else printf("Please enter a number\n");
}
printf("\n");
for( i=0; i < Cn.num_segments ; i++ )
{
for( j=0; j < Cn.segments[i].num_procs; j++ )
{
proc_id = Cn.segments[i].procs[j]->id;
proc_index = Conf_proc_by_id( proc_id, &p );
for( legal=0; !legal; )
{
printf("\t%s personal window\t", p.name);
if( fgets( str, 70, stdin ) == NULL )
{
printf("Bye.\n");
exit(0);
}
ret = sscanf(str, "%d", &temp);
Work_fc_buf[proc_index][0] = temp;
if( ret > 0 ) legal = 1;
else if( ret == -1 ){
legal = 1;
Work_fc_buf[proc_index][0] = -1;
}else printf("Please enter a number\n");
}
if (Conf_get_accelerated_ring()) {
for( legal=0; !legal; )
{
printf("\t%s accelerated window\t", p.name);
if( fgets( str, 70, stdin ) == NULL )
{
printf("Bye.\n");
exit(0);
}
ret = sscanf(str, "%d", &temp);
Work_fc_buf[proc_index][1] = temp;
if( ret > 0 ) legal = 1;
else if( ret == -1 ){
legal = 1;
Work_fc_buf[proc_index][1] = -1;
}else printf("Please enter a number\n");
}
}
}
printf("\n");
}
}
/* Send message to all daemons to reload their configuration files to change the set of daemons */
static void Reload_Conf()
{
int32 proc_id;
proc p;
int proc_index;
int i,j;
Pack.type = RELOAD_TYPE;
Pack.type = Set_endian( Pack.type );
Pack.conf_hash = MONITOR_HASH;
Pack.data_len = 0;
Pack_scat.num_elements = 1;
Alarm( PRINT, "Old configuration hash is: %u\n", Cn.hash_code);
Alarm( PRINT , "Monitor: send conf reload command\n");
for( i=0; i < Cn.num_segments ; i++ )
{
for( j=0; j < Cn.segments[i].num_procs; j++ )
{
proc_id = Cn.segments[i].procs[j]->id;
proc_index = Conf_proc_by_id( proc_id, &p );
DL_send( SendChan, p.id, p.port, &Pack_scat );
}
}
/* Now reload monitor's configuration
* and clear all Partition, Status, FC arrays as they are now inaccurate
*/
read_configuration();
for( i=0; i < Conf_num_procs( &Cn ); i++ )
{
Partition[i] = 0;
Work_partition[i] = 0;
Fc_buf[i][0] = 0;
Fc_buf[i][1] = 0;
Work_fc_buf[i][0] = 0;
Work_fc_buf[i][1] = 0;
Status_vector[i] = 0;
}
Mutex_lock( &Partition_mutex );
Partition_active = 0;
Mutex_unlock( &Partition_mutex );
#ifndef _REENTRANT
E_dequeue( Send_partition, 0, NULL );
#endif
Mutex_lock( &Status_mutex );
Status_active = 0;
Mutex_unlock( &Status_mutex );
#ifndef _REENTRANT
E_dequeue( Send_status_query, 0, NULL );
#endif
Alarm( PRINT, "New configuration hash is: %u\n", Cn.hash_code);
Alarm( PRINT, "All Status, Partition, FC, etc commands are reset by configuration reload!\n");
}
