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"); }