He, Yue Initiated Date: 2/15/2007 Implemented Functions: Blocking Bandwidth, Handling CAC failure, PathErr Message Mechanism, Flooding
Reviewing the simulation:
A figure of the whole process is as following: Trigger CAC and PathError if not succeeded Path: Block LSP BW Path Path
Resv
Resv: Reserv LSP BW
Resv
flooding if needed
Figure 1. Added: LSP-setup using RSVP-TE Trigger CAC and PathError if not succeeded Path: Reserve LSP BW Path Path
Resv
Resv: Do not touch LSP BW
Resv
flooding if needed
Figure 2. OPNET: LSP-setup using RSVP-TE
Yue He, Initiated Date: 2/15/2007 Implemented Functions: Blocking Bandwidth, Handling CAC failure, PathErr Message Mechanism, Flooding
Implementation:
1. Adding block_bandwidth() function while establishing LSP: Purpose: Referring to the process of bandwidth for Path and Resv Messages in Figure 1 and 2 The block_bandwidth() function is done using reserve_bandwidth() functionality. Since the Resv Message backwards has already been guaranteed with the needed bandwidth that is blocked during the forward Path Message phase, the blocking of bandwidth for Path Message can be done as reservation of the bandwidth for Resv Message. The process of Resv Message can be accordingly modified as leaving bandwidth as it is. The promotion of this method is based on the ideal situation such that the reserve_bandwidth process rarely has mistakes of obtaining the link bandwidth due to the bandwidth blocked when establishing the LSP. What block_bandwidth() function does (Added case): When setting up a LSP from sender node to the receiver node, three procedures will happen in this process. First, the transmitting sender node's RSVP module sends LSP PATH message and traverse the intermediate nodes along the path, while the same time blocking the bandwidth on each link it traverses (+link_bandwidth). The PATH messages create a path state on each RSVP-aware router that is traversed, and are forwarded on a hop-by-hop basis. The path state should contain source and destination informations, the IP address of the previous node in the direction of data traffic, as well as the link bandwidth that should be blocked on each incoming link of the receiver node. Then, after the receiver node gets the PATH message and makes the decision to reserve/block the bandwidth (reservation_done == OPC_TRUE), the reserve message is sent backwards to the sender router. Finally, the sender node sends the confirmation and completes the reservation. The block_bandwidth() function here is realized by the PATH message while traversing each incoming link of the intermediate router and the egress LER. When the intermediate node gets the PATH message, it will block the amount of bandwidth the message indicates of its incoming link. What reserve_bandwidth() does (OPNET case): OPNET does not support blocking the bandwidth while establishing the LSP PATH, and the feature of release the blocked bandwidth while reserving the bandwidth backwards to the sender nodes. In order to realize the block_bandwidth() function in the real case, based on the nature of reserving bandwidth, the reserve_bandwidth() functionality could be used for block_bandwidth(). And for releasing the bandwidth, it could be implemented in the reserve_bandwidth() backwards without actually changing the value of LSP bandwidth. The content of block_bandwidth() will contain setting up LSP as well as blocking (`reserving') the link bandwidth, and send out the PATH message containing the reservation confirmation. While at the same time, a field called TYPE BLOCK_BANDWIDTH should also be added in the
Yue He, Initiated Date: 2/15/2007 Implemented Functions: Blocking Bandwidth, Handling CAC failure, PathErr Message Mechanism, Flooding OspfT_Lsa_Mpls_Info structure to guarantee the correctness of current link bandwidth being used by other means. The process of setting up the LSP is the same with the action taken in rsvp_msg_path_send (), while the action of blocking the bandwidth should be added to rsvp_msg_path_send () accordingly to the functionality of reserving link bandwidth (bucket_rate) in ip_te_resource_reserve(). An example of blocking and reserving bandwidth is given below: if iface_info_ptr->avail_bw > packet_fields_ptr->in_tspec_ptr->bucket_rate + iface_info_ptr->block_bw iface_info_ptr->block_bw += packet_fields_ptr->in_tspec_ptr->bucket_rate Continue the path process Else Send Path_Err Stop the path process Bandwidth to be blocked from the sender = 10 M, bandwidth decided to be reserved by the receiver = 8 M, bandwidth already blocked from other LSP request = 3 M, available bandwidth = 20 M, bandwidth in using = 80 M Thus, sender's bucket_rate = 10 M, avail_bw = 80 M, block_bw = 3 M, receiver's bucket_rate = 8 M. Here 6) becomes to: If 20 M > 10 M + 3 M 13 M = 3 M + 10 M Continue the path process Then in the Resv process, iface_info_ptr->block_bw -= sender's bucket_rate 3 M = 13 M 10 M iface_info_ptr->avail_bw -= receiver's bucket_rate 12 M = 20 M 8 M Here completes the whole block and reserve process. Method: The blocking bandwidth process is implemented through the help of the reservation process functionality in OPNET. The backwards reservation process in OPNET is modified and applied to the blocking bandwidth function in the forwarding process of our scenario. In order to achieve these, steps are taken as following: 1). A field is added in file ip_rte_v4.h: typedef struct IpT_Interface_Info { ... double block_bw; ... } IpT_Interface_Info; This is used to record the blocked bandwidth value on each interface of all the routers. Correspondingly, this variable is initiated in function static IpT_Interface_Info * ip_interface_info_create (int intf_type) of the ip_dispath process function block:
Yue He, Initiated Date: 2/15/2007 Implemented Functions: Blocking Bandwidth, Handling CAC failure, PathErr Message Mechanism, Flooding iface_info_ptr->block_bw = 0.0; 2). A new header file Yue_ip_te_resource_block.h file is added under the local MY PATH/include path (the path should also be added in the OPNET compilation properties). Correspondingly, the implementation external source file Yue_ip_te_resource_block.ex.c is also created, and declared in the process using it. The details of these two file could be viewed in the Appendix. The header file is the declaration of the two functions implemented in the external C file: ip_te_resource_block (IpT_Rte_Module_Data* ipmd_data_ptr, int iface_index, CspfT_Resource_Type resource_type, double resource_value) and ip_te_resource_free_block (IpT_Rte_Module_Data* ipmd_data_ptr, int iface_index, CspfT_Resource_Type resource_type, double resource_value). The first function is used to block the bandwidth while sending the PATH messages from sender to destination during the establishing LSP process; while the second the function is used to free the bandwidth been blocked from the destination to sender in the backwards direction. The freeing blocked bandwidth process happens in both the case of regular reservation process and the case of releasing the blocked bandwidth during sending the PathErr message process. 3). In order to execute the functions, some changes should be applied to the sate machine of the rsvp module. Accordingly, some functions in the function block of the rsvp process are modified. a. Block the outgoing links' bandwidth at Ingress LER for all the LSPs traverse it: rsvp_send_label_request (void* lsp_info_void_ptr, int code): ... // Yue, Added, Date, Brief Description int index_i, num_registered_procs; IpT_Te_Notif_Info* ith_notif_handle = OPC_NIL; // Yue, end adding ... if (route_query_status == OPC_COMPCODE_SUCCESS) { /* Send a Path message for the state. This sequence will send path */ /* message on all outgoing interfaces from the Path state. */ /* Incoming interface is set to be invalid. */ /* Create a list that will be used to record the route for LSP */ /* visualization purposes. */ ... // Yue, Added, Date, Brief Description if ((ip_te_resource_block (ip_module_data_ptr, out_intf_index, CspfC_Resource_Type_Bandwidth, path_state_ptr->in_tspec_ptr->bucket_rate)) == OPC_COMPCODE_FAILURE) { /** The Resource block failed **/
Yue He, Initiated Date: 2/15/2007 Implemented Functions: Blocking Bandwidth, Handling CAC failure, PathErr Message Mechanism, Flooding /** CAC failure, send PathErr message **/ /* flooding */ num_registered_procs = op_prg_list_size (intf_info_ptr>notif_proc_lptr); for (index_i = 0; index_i < num_registered_procs; index_i++) { ith_notif_handle = (IpT_Te_Notif_Info*) op_prg_list_access (intf_info_ptr->notif_proc_lptr, index_i); printf ("ith_notif_handle: %d\n", ith_notif_handle == OPC_NIL); op_intrpt_schedule_process (ith_notif_handle>registered_pro_handle, op_sim_time (), IPTEC_INTRPT_CODE_SIG_CHANGE); } if (op_prg_odb_ltrace_active("CAC_fail")) { op_prg_odb_print_major("CAC failure, send PathErr message", OPC_NIL); } } // Yue, End Adding // Yue, Added, Date, Brief Description else { number_msg = rsvp_msg_path_send (path_state_ptr, RsvpC_Path, OPC_INT_INVALID, ip_module_data_ptr, refresh_timer, LTRACE_PATH || LTRACE_MSG, route_data_lptr); /* Schedule the retry interrupt. */ /* Since we are taking the retry timer into account in the schedule_call,*/ /* when the interrupt occurs, the retry attempt must be immediate. */ lsp_attrs_ptr->retry_evhandle = op_intrpt_schedule_call (op_sim_time () + lsp_attrs_ptr->retry_timer, RSVPC_LSP_RETRY_ON_TIMER_EXPIRY, rsvp_start_lsp_switchover, (void *) lsp_info_ptr); if (op_prg_odb_ltrace_active (lsp_attrs_ptr->lsp_name) || op_prg_odb_ltrace_active ("lsp_rsvp")) { op_prg_odb_print_major ("Sending label request for", lsp_attrs_ptr->lsp_name, OPC_NIL);
Yue He, Initiated Date: 2/15/2007 Implemented Functions: Blocking Bandwidth, Handling CAC failure, PathErr Message Mechanism, Flooding } /* Update the statistics. */ rsvp_stats_sent_update (RsvpC_Path, number_msg); } // Yue, end adding b. Block the outgoing links' bandwidth of all the nodes along the LSP being setup, while for the Egress node, we do nothing with it since only the bandwidth of outgoing links are being blocked: rsvp_process_path_msg (void): ... // Yue, Added, Date, Brief Description int index_i, num_registered_procs; IpT_Interface_Info* iface_info_ptr = OPC_NIL; IpT_Te_Notif_Info* ith_notif_handle = OPC_NIL; // Yue, end adding if (route_query_status == OPC_COMPCODE_SUCCESS) { /** Routing knows how to route the packet. /* Send the path message
**/ */
// Yue, Added, Date, Brief Description if (local_dest_flag == OPC_FALSE) /* while the node is not Egress node */ { if ((ip_te_resource_block (ip_module_data_ptr, intf_info_ptr>intf_index, CspfC_Resource_Type_Bandwidth, packet_fields_ptr->in_tspec_ptr>bucket_rate)) == OPC_COMPCODE_FAILURE) { /** The Resource block failed **/ /** CAC failure, send PathErr message **/ rsvp_path_error_msg_send (packet_fields_ptr, my_ip_address, /* ERR_CONFIRM); PathErr Msg */ /* flooding */ iface_info_ptr = ip_rte_intf_tbl_access (ip_module_data_ptr, intf_info_ptr->intf_index); num_registered_procs = op_prg_list_size (iface_info_ptr>notif_proc_lptr); for (index_i = 0; index_i < num_registered_procs; index_i++) {
Yue He, Initiated Date: 2/15/2007 Implemented Functions: Blocking Bandwidth, Handling CAC failure, PathErr Message Mechanism, Flooding ith_notif_handle = (IpT_Te_Notif_Info*) op_prg_list_access (iface_info_ptr->notif_proc_lptr, index_i); printf ("ith_notif_handle: %d\n", ith_notif_handle == OPC_NIL); op_intrpt_schedule_process (ith_notif_handle>registered_pro_handle, op_sim_time (), IPTEC_INTRPT_CODE_SIG_CHANGE); } if (op_prg_odb_ltrace_active("CAC_fail")) { op_prg_odb_print_major("CAC failure, send PathErr message", OPC_NIL); } } else { rsvp_path_message_send (matching_path_state_ptr, forwarding_path_state_ptr, packet_fields_ptr, expect_in_intf, local_dest_flag, outgoing_interface_list_ptr, setting_up_lsps, path_refresh_needed, multicast_dest_flag, resv_refresh_needed); if (((packet_fields_ptr->session_ptr != OPC_NIL) && (packet_fields_ptr->session_ptr->lsp_id_ptr != OPC_NIL)) && (op_prg_odb_ltrace_active (packet_fields_ptr->session_ptr->lsp_id_ptr->lsp_name) || op_prg_odb_ltrace_active ("lsp_rsvp"))) { op_prg_odb_print_major ("Processing Path Message for", packet_fields_ptr->session_ptr->lsp_id_ptr->lsp_name, OPC_NIL); } } } else /* the following code is to ensure the path message at the last node along the LSP, other than Egress node, will be sent to the Egress node, thus ensuring the Egress router to process and start up the backwards reservation process */ { rsvp_path_message_send (matching_path_state_ptr, forwarding_path_state_ptr, packet_fields_ptr, expect_in_intf, local_dest_flag, outgoing_interface_list_ptr, setting_up_lsps, path_refresh_needed, multicast_dest_flag, resv_refresh_needed); if (((packet_fields_ptr->session_ptr != OPC_NIL) && (packet_fields_ptr->session_ptr->lsp_id_ptr != OPC_NIL)) &&
Yue He, Initiated Date: 2/15/2007 Implemented Functions: Blocking Bandwidth, Handling CAC failure, PathErr Message Mechanism, Flooding (op_prg_odb_ltrace_active (packet_fields_ptr->session_ptr->lsp_id_ptr->lsp_name) || op_prg_odb_ltrace_active ("lsp_rsvp"))) { op_prg_odb_print_major ("Processing Path Message for", packet_fields_ptr->session_ptr->lsp_id_ptr->lsp_name, OPC_NIL); } } // Yue, End Adding c. Free the blocked bandwidth during the backwards reservation process: rsvp_process_resv_msg_for_lsps (): ... if ((packet_fields_ptr->in_tspec_ptr->bucket_rate > 0.0) && (resv_state_ptr == OPC_NIL)) { /* Do the reservation */ /* The reservation is done based on the bandwidth */ /* configuration of the interface at this time. If */ /* the metric specified is greater than the phys. */ /* interface bw, then LSPs with bw requirement */ /* of more than that of the physical interface may */ /* get set up. */ // Yue, Added, Date, Brief Description if ((ip_te_resource_free_block(ip_module_data_ptr, event_info.in_interface, CspfC_Resource_Type_Bandwidth, packet_fields_ptr>in_tspec_ptr->bucket_rate)) == OPC_COMPCODE_FAILURE) { /* Actions for free_block failure (not being able to find in iface_tbl) */ if (op_prg_odb_ltrace_active("free_fail")) { op_prg_odb_print_major("Free blocked bandwidth fail", OPC_NIL); } } // Yue, end adding 2. CAC Error & Notification function: CAC error is triggered immediately when there is not enough bandwidth during the Path blocking bw phase. Upon receiving the reservation request, the router/ingress LER will calculate the reservation request bandwidth with the available bandwidth. If request link bandwidth + blocked bandwidth < available bandwidth, a CAC failure will result. Once the calculation failure happens, a PathErr message will be sent and OSPF flooding will be triggered. These actions will be added in RSVP FB, following the checking of function ip_te_resource_block(). ...
Yue He, Initiated Date: 2/15/2007 Implemented Functions: Blocking Bandwidth, Handling CAC failure, PathErr Message Mechanism, Flooding if ((ip_te_resource_block (ip_module_data_ptr, intf_info_ptr->intf_index, CspfC_Resource_Type_Bandwidth, packet_fields_ptr->in_tspec_ptr->bucket_rate)) == OPC_COMPCODE_FAILURE) { /** The Resource block failed **/ /** CAC failure, send PathErr message **/ rsvp_path_error_msg_send (packet_fields_ptr, my_ip_address, ERR_CONFIRM); /* PathErr Msg */ /* flooding */ //op_intrpt_schedule_process (ith_notif_handle->registered_pro_handle, op_sim_time (), IPTEC_INTRPT_CODE_SIG_CHANGE); if (op_prg_odb_ltrace_active("CAC_fail")) { op_prg_odb_print_major("CAC failure, send PathErr message", OPC_NIL); } } 3. PathError: The path error message is send whenever there is a link failure and a CAC failure. In both the code of link failure example in OPNET, a Path_Tear message is generated along the path to send inform the error to the source node. The intermediate nodes receiving PathErr should release the bandwidth that is previously blocked in the Path block_bw phase. This should be done by locating RsvpT_Tspec -> bucket_rate information from parameters of PathErr. The releasing of the bandwidth is the same as in rsvp_process_tear_msg().
Link Failure: Through one test on Link Failure case in OPNET, it is demonstrated that the functionality of supporting PathErr mechanism has already been realized by OPNET. Supporting following functionalities: 1). Routing back from the failure node to inform source node about the failure; 2). Let source node deal with the failure case on this LSP (i.e. sending out the Path Tear message in OPNET.). The calling stack of "Sending a Path Tear Message" in OPNET is as following: rsvp_handle_mpls_intrpt_at_ingress ()
/* /* /* /* /* This function is called when there is an interrupt is from Mpls Mgr and code is Ingress_Notif. This means that the node is ingress LER for atleast one Dynamic LSP This function gets list of LSPs in ICI passed by MPLS and Schedules self interrupt to start the first LSP */ */ */ */ */
Yue He, Initiated Date: 2/15/2007 Implemented Functions: Blocking Bandwidth, Handling CAC failure, PathErr Message Mechanism, Flooding rsvp_lsps_sort_and_schedule ();
/* Schedule primary LSPs and sort bypass tunnels. */ /** This function sorts bypass tunnels based on start time, **/ /** and schedules start and end ...