diff --git a/doc/bgp_error_handling/BGP_Route_Error_Handling_Arlo.md b/doc/bgp_error_handling/BGP_Route_Error_Handling_Arlo.md new file mode 100644 index 00000000000..99c53610930 --- /dev/null +++ b/doc/bgp_error_handling/BGP_Route_Error_Handling_Arlo.md @@ -0,0 +1,251 @@ + + + + +# BGP Route Install Error Handling +# High Level Design Document +#### Rev 0.1 + +# Table of Contents + * [List of Tables](#list-of-tables) + * [Revision](#revision) + * [About This Manual](#about-this-manual) + * [Scope](#scope) + * [Definition/Abbreviation](#definitionabbreviation) + +# List of Tables +[Table 1: Abbreviations](#table-1-abbreviations) + +# Revision +| Rev | Date | Author | Change Description | +|:---:|:-----------:|:------------------:|-----------------------------------| +| 0.1 | 05/07/2019 | Sudhanshu Kumar | Initial version | + +# About this Manual +This document provides information about how to handle the "route add failure in hardware" related errors in BGP in SONIC. +# Scope +This document describes the high level design of BGP route install error handling feature. Implementation for warm reboot and GR for BGP is out of scope for this feature. When route installation fails in hardware due to table full, BGP may retry again when some routes get deleted. This Retry mechanism in BGP for failed routes will not be implemented in this release. + +# Definition/Abbreviation +### Table 1: Abbreviations + +| **Term** | ***Meaning*** | +|-------------------|-------------------------| +| BGP | Border Gateway Protocol | +| GR | Graceful Restart | +| SONIC | Software for Open Networking in the Cloud | +| FRR | FRRouting | +| FPM | Forwarding Plane Manager | +| SwSS | SONiC Switch State Service | +# 1 Requirement Overview + When BGP learns a prefix, it sends it to route table manager(Zebra). The routes are installed in kernel and sent to APP_DB via fpmsyncd. +The Orchagent reads the route from APP_DB, creates new resources like nexthop or nexthop group Id and installs the route in ASIC_DB. The syncd triggers the appropriate SAI API and route is installed in hardware. The CRM manages the count of critical resources allocated by orchagent through SAI API. +Due to resource allocations failures in hardware, SAI API calls can fail and these failures should be notified to Zebra and BGP. +On learning the prefix, BGP can immediately advertise the prefix to its neighbors. However, if the error-handling feature is enabled, BGP waits for success notification from hardware before advertising the same to its peers. If the hardware returns error, the routes are not advertised to the peers. + +## 1.1 Functional Requirements + + + + 1. BGP should not advertise the routes which have failed to be installed in hardware. + 1. BGP should mark the routes which are not installed in hardware as "FIB-install pending" routes in its RIB-IN table. + 1. Zebra should mark the routes which are not successfully installed in hardware as failed routes. + +## 1.2 Configuration and Management Requirements +## 1.3 Scalability Requirements +## 1.4 Warm Boot Requirements + There is no change needed in BGP warm reboot for supporting this feature. +# 2 Functionality +Refer to section 1 + +## 2.1 Target Deployment Use Cases + +## 2.2 Functional Description +Refer to section 1.1 + +# 3 Design +## 3.1 Overview +On enabling the error-handling feature, fpmsyncd subscribes to the changes in the ERROR_ROUTE_TABLE entries. Whenever the error status in ERROR_ROUTE_TABLE is updated, fpmsyncd is notified. It then sends a message to Zebra's routing table to take appropriate action. +Zebra should lookup the route and mark it as not installed in hardware. It should create a route-netlink message to withdraw this state in kernel. Also, it sends message to the source protocol for the route (BGP). +BGP marks the route as not installed in hardware and does not advertise the route to its peers. It should mark the route in RIB-IN as not installed in hardware and remove it from RIB-OUT list, if any. +For ECMP case, BGP sends route with list of nexthops to Zebra for programming. In fpmsyncd, as per the route table schema, the route is received with a list of nexthops. If the nexthop group programming fails, it is treated as route add failure in BGP. +If the error-handling feature is disabled, fpmsyncd does not receive any notification from ERROR_ROUTE_TABLE. +## 3.2 DB Changes +### 3.2.1 CONFIG DB +A new table BGP_ERROR_CFG_TABLE has been introduced in CONFIG DB (refer section 3.7). +### 3.2.2 APP DB +### 3.2.3 STATE DB +### 3.2.4 ASIC DB +### 3.2.5 COUNTER DB + +## 3.3 FRRouting Design +### 3.3.1 Zebra changes +Zebra, on receiving the message containing route install success, will notify BGP so that it can advertise the route to its peers. +Zebra, on receiving the message containing failed route notification, will withdraw the route from kernel. It will also mark the route with flag as "Not installed in hardware" and store the route. It will not send the next best route to fpmsyncd. At this stage, route is present in Zebra. It will NOT notify BGP of the route add failure. + +### 3.3.2 BGP changes +When BGP learns a route, it marks the route as "pending FIB install" and sends the route to Zebra. The route may or may not be successfully installed in hardware. On receiving route add sucess notification message, BGP will remove the "pending FIB install" flag and advertise the route to its peers. + +In case user wants to retry the installation of failed routes, he/she can issue the command in Zebra. The command will reprogram the failed route in kernel and send that route to hardware. If the route is successfully programmed in hardware, it will notify Zebra. Zebra will, in turn, notify BGP and route will be advertised to its neighbors. + +## 3.4 SwSS Design + +### 3.4.1 fpmsyncd changes +A new class is added in fpmsyncd to subscribe to ERROR_ROUTE_TABLE present inside the ERROR_DB. Subscription to this table is sufficient to handle the errors in route installation. +Currently, fpmsyncd has a TCP socket with Zebra listening on FPM_DEFAULT_PORT. This socket is used by Zebra to send route add/delete related messages to fpmsyncd. We will reuse the same socket to send information back to Zebra. +fpmsyncd will convert the ERROR_ROUTE_TABLE entry to Zebra common header format and send the message. Zebra will send a delete route message to clean the route from APP_DB so that OrchAgent can process it. If processing this results in a further error, then fpmsyncd silently ignores this. + +## 3.5 SyncD + +## 3.6 SAI + + +## 3.7 CLI +### 3.7.1 Data Models +A new table is added in CONFIG_DB to enable and disable error_handling feature. +BGP_ERROR_CFG_TABLE +``` +key = BGP_ERROR_CFG_TABLE:config +``` +The above key has field-value pair as {"enable", "true"/"false"} based on configuration. +### 3.7.2 Configuration Commands +A command is provided in SONIC to enable or disable this feature. + +``` +root@sonic:~# config bgp error-handling --help +Usage: config bgp error-handling [OPTIONS] COMMAND [ARGS]... + + Handle BGP route install errors + +Options: + --help Show this message and exit. + +Commands: + disable Administratively Disable BGP error-handling + enable Administratively Enable BGP error handling + ``` + When the error-handling is disabled, fpmsyncd will not subcribe to any notification from ERROR_ROUTE_TABLE. By default, the error-handling feature is disabled. During system reload, config replay for this feature is possible when the docker routing config mode is unified or split. + This feature can be turned off on demand. But it can affect the system stability. When the config was turned on, there may be some routes in BGP, for which, it is waiting for update from hardware. When the feature is turned off, we will unsubscribe from ERROR_DB and will no longer receive any notifications from hardware. Hence, some of the routes may not receive any notification from hardware. +It is recommended to restart the BGP docker when the config state is changed to disable from enable. By default, this config is disabled. If the config is changed from disable to enable, we do not need to restart the docker. But the feature will be affecting only those routes which will be learnt after enabling the feature. + +### 3.7.3 Show Commands +``` +sonic(config-router-af)# do show bgp ipv4 unicast +BGP table version is 1, local router ID is 10.1.0.1, vrf id 0 +Status codes: s suppressed, d damped, h history, * valid, > best, = multipath,# FIB install pending. + i internal, r RIB-failure, S Stale, R Removed +Nexthop codes: @NNN nexthop's vrf id, < announce-nh-self +Origin codes: i - IGP, e - EGP, ? - incomplete + + Network Next Hop Metric LocPrf Weight Path +*># 21.21.21.21/32 4.1.1.2 0 0 101 ? + +Displayed 1 routes and 1 total paths + ``` + + + + +``` +sonic(config-router-af)# do show ip route +Codes: K - kernel route, C - connected, S - static, R - RIP, + O - OSPF, I - IS-IS, B - BGP, E - EIGRP, N - NHRP, + T - Table, v - VNC, V - VNC-Direct, A - Babel, D - SHARP, + F - PBR, + > - selected route, * - FIB route, # - Not installed in hardware + +K>* 0.0.0.0/0 [0/0] via 10.59.128.1, eth0, 09:44:37 +C>* 4.1.1.0/24 is directly connected, Ethernet4, 00:01:48 +C>* 10.1.0.1/32 is directly connected, lo, 09:44:37 +C>* 10.59.128.0/20 is directly connected, eth0, 09:44:37 +B># 21.21.21.21/32 [20/0] via 4.1.1.2, Ethernet4, 00:00:07 +``` +A new command has been introduced for seeing the failed routes as follows + show {ip | ipv6} route not-installed [prefix/mask] +``` +sonic# show ip route not-installed +Codes: K - kernel route, C - connected, S - static, R - RIP, + O - OSPF, I - IS-IS, B - BGP, E - EIGRP, N - NHRP, + T - Table, v - VNC, V - VNC-Direct, A - Babel, D - SHARP, + F - PBR, + > - selected route, * - FIB route # - not installed in hardware +B> # 22.1.1.1/32 [20/0] via 4.1.1.2, Ethernet4, 00:00:20 +B> # 22.1.1.2/32 [20/0] via 4.1.1.2, Ethernet4, 00:00:20 +B> # 30.1.1.1/32 [20/0] via 4.1.1.2, Ethernet4, 00:00:20 +B> # 30.1.1.2/32 [20/0] via 4.1.1.2, Ethernet4, 00:00:20 +B> # 30.1.1.3/32 [20/0] via 4.1.1.2, Ethernet4, 00:00:20 +B> # 30.1.1.4/32 [20/0] via 4.1.1.2, Ethernet4, 00:00:20 +B> # 30.1.1.5/32 [20/0] via 4.1.1.2, Ethernet4, 00:00:20 +B> # 30.1.1.6/32 [20/0] via 4.1.1.2, Ethernet4, 00:00:20 +B> # 30.1.1.7/32 [20/0] via 4.1.1.2, Ethernet4, 00:00:20 +B> # 30.1.1.8/32 [20/0] via 4.1.1.2, Ethernet4, 00:00:20 +``` +### 3.7.4 Debug Commands +In order to retry the installation of failed routes from Zebra, a clear command has been provided. + clear {ip | ipv6} route {not-installed | } + ``` +sonic# clear ip route + not-installed not installed in hardware +sonic# clear ip route not-installed + + A.B.C.D/M ipv4 prefix with mask + X:X::X:X/M ipv6 prefix with mask +``` +The above command will send route add message for the failed route from Zebra to fpmsyncd. + +### 3.7.5 REST API Support + +# 4 Flow Diagrams + ![BGP](images/bgp_error_handling_flow1.png "Figure 1: High level module interaction for route install error notification") + +__Figure 1: High level module interaction for route install error notification__ + +![BGP](images/bgp_error_handling_flow2.png "Figure 2: Module flow for route add error notification") + +__Figure 2: Module flow for route add error notification__ + +![BGP](images/bgp_error_handling_flow3.png "Figure 3: Module flow for route install success notification") + +__Figure 3: Module flow for route add success notification__ + ![BGP](images/bgp_error_handling_flow4.png "Figure 4: Module flow for route delete success/fail notification") + +__Figure 4: Module flow for route delete success/fail notification__ + +# 5 Serviceability and Debug + + +# 6 Warm Boot Support +There are two scenarios here. One is warm-reboot case and another is unplanned reboot (like bgp restart or docker restart due to cold reboot). Note that in current sonic code, we don't retain routes learnt by Zebra across +warm-reboot. +During warm reboot, fpmsyncd supports syncing of existing routes in APP_DB with newly learnt routes. After warm reboot of BGP docker, BGP sends newly learnt routes to fpmsyncd. Since warm reboot is enabled, fpmsyncd will mark the existing db routes and send only the newly learnt routes to APP_DB. If BGP error-handling is enabled, for the routes which were same as before, we will send an implicit positive ACK to Zebra. +Before warm reboot, suppose, we had 5 routes sent by BGP to fpmsynd, out of them., 5th route failed to be installed in hardware. Zebra will delete the 5th route from kernel, APP_DB, ASIC_DB and ERROR_DB. After warm reboot, when fpmsyncd receives the 5 routes again from BGP, it will send add for the 5th route again (since 5th route was never present in APP_DB prior to warm reboot). +During unplanned reboot, for the same 5 routes, suppose, fpmsyncd crashed before processing the add failure for the 5th route. Now, all the 5 routes are present in APP_DB and ASIC_DB. Since +the 5th route failed to be installed in hardware, it is present in ERROR_DB. When docker comes up again, orchagent will send the notification for the 5th route failure to fpmsyncd. fpmsyncd will send this message to Zebra. Zebra cleans the route from APP_DB and ASIC_DB. After the warm reboot timer expires, fpmsyncd will +receive the implicit ACK for the remaining routes (routes which did not change during warm-reboot). If any route changes during warm-reboot, the route will be sent to orchagent for installation in hardware and ACK will take its normal flow. + +# 7 Scalability + +# 8 Unit Test + +The UT testcases are as follows: + +|**Test-Case ID**|**Description**|**Status**|**Comments**| +|----------------|---------------|----------|------------| +1 | Send an iBGP route from the traffic generator and see that route is learnt in BGP. | | Check the route in zebra. fpmsyncd should send route to APP_DB. Check APP_DB. Check that orchagent should send this route to ASIC_DB. Check that syncd should send the route to ASIC. | + 2 | Send an eBGP route from the traffic generator and see that route is learnt in BGP. | | | + 3 | Install a route and check that error status is present in "show ip route" in zebra. | | | + 4 | Install a route and check that route is present in kernel. | | | + 5 | Install a route and check that route is present in APP_DB and ASIC_DB. | | | + 6 | Execute the command "show bgp ipv4". Check that the error status (installed in hardware flag) is shown as 0. | | | + 7 | Check that routes with installed flag as TRUE is sent to eBGP peers. Also, BGP ribout list should have this route. | | | + 8 | Check that routes with installed flag as TRUE is sent to iBGP peers. (Rules for iBGP and route reflector will apply). | | | + 9 | Send an iBGP route from the traffic generator and see that route is learnt in BGP. But this route is not installed in ASIC_DB. Check that error status is correctly shown in APP_DB. Please note that route will be present in BGP/Zebra/APP_DB. | | Check the route in zebra. fpmsyncd should send route to APP_DB. Check APP_DB. Check that orchagent should send this route to ASIC_DB. Check that syncd should send the route to ASIC. | + 10 | Send an eBGP route from the traffic generator and see that route is learnt in BGP. But this route is not installed in ASIC_DB. Check that error status is correctly shown in APP_DB. Check different kinds of errors like nexthop group-id add failed, nexthop add failed, route add failed, route table/nexthop table is full etc. | | | + 11 | Install a route and check that route is present in zebra, but not in ASIC_DB and kernel. | | | + 12 | Install a route and check that route is not present in APP_DB and ASIC_DB. (Can be due to send error from fpmsyncd). | | | + 13 | Execute the command "show bgp ipv4". Check that the error status (installed flag) is shown as some non-zero value. Also check the rib failure flag. In case of error, check if BGP ribout message does not contain this route. | | | + 14 | Check that routes with installed flag as FALSE is not sent to eBGP peers. Also, BGP ribout list should not have this route. If route has already been sent by BGP, it should be withdrawn. | | | + 15 | Check that routes with installed flag as FALSE is not sent to iBGP peers. (Rules for iBGP and route reflector will apply). If route has already been sent by BGP, it should be withdrawn. | | | + 16 | Send a route. Execute "show bgp ipv4". Check that this command shows the error status (installed flag). See that it shows error. Also, check the rib-failure flag. | | | +17 | Send a route. Execute "show bgp ipv4". Check that this command shows the error status (installed flag). See that it shows error. Also, check the rib-failure flag. Now,send the same route again so that it in installed successfully. Check all the flags. | | | +# 9 Internal Design Information \ No newline at end of file diff --git a/doc/bgp_error_handling/images/bgp_error_handling_flow1.png b/doc/bgp_error_handling/images/bgp_error_handling_flow1.png new file mode 100644 index 00000000000..810a9ca6bfa Binary files /dev/null and b/doc/bgp_error_handling/images/bgp_error_handling_flow1.png differ diff --git a/doc/bgp_error_handling/images/bgp_error_handling_flow1.xml b/doc/bgp_error_handling/images/bgp_error_handling_flow1.xml new file mode 100644 index 00000000000..bbeb117c54f --- /dev/null +++ b/doc/bgp_error_handling/images/bgp_error_handling_flow1.xml @@ -0,0 +1,2 @@ + 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 \ No newline at end of file diff --git a/doc/bgp_error_handling/images/bgp_error_handling_flow2.png b/doc/bgp_error_handling/images/bgp_error_handling_flow2.png new file mode 100644 index 00000000000..60a68ff85b6 Binary files /dev/null and b/doc/bgp_error_handling/images/bgp_error_handling_flow2.png differ diff --git a/doc/bgp_error_handling/images/bgp_error_handling_flow2.xml b/doc/bgp_error_handling/images/bgp_error_handling_flow2.xml new file mode 100644 index 00000000000..3e092ccc594 --- /dev/null +++ b/doc/bgp_error_handling/images/bgp_error_handling_flow2.xml @@ -0,0 +1,2 @@ + +7Vttc+I2EP41zNx9CGNbfgkfAwm5XK8Xhsxd23zpCFs2amSLChGgv76SLRvbIiH4TCAzZDLBWsnrZffZF62VDhjEq1sGZ9PfaYBIxzKCVQdcdyzLtC2rI3+NYJ1RPNPJCBHDgVq0ITzg/5AiGoq6wAGaVxZySgnHsyrRp0mCfF6hQcbosrospKT61BmMkEZ48CHRqX/ggE8z6qXlbehfEI6m+ZNNt5fNxDBfrL7JfAoDuiyRwE0HDBilPLuKVwNEpPJyvWT3DV+YLQRjKOFvuWHUx1/v3ODCDO8mj+OR/ePxJrmwMy7PkCzUF+7fjpS8fJ0rgdFFEiDJx+yA/nKKOXqYQV/OLoXZBW3KY6KmdbmUqM+IcbQqkZSct4jGiLO1WKJmHaUyhRlHQWZZMoBaMS3pHigaVCaPCr4brYgLpZg9lORpStI0JIw7k5cEJ09VdRRmN8SAwAkifeg/RalKB5RQljIAvd5gMBRC9jlkEeIjxLAQHjGpZ5xEYpErmdEF89ELk0LfbP2nfFLXyYd/KSnSwfVKiZGN1mr0osEyUXajBwUVH9LNWjKcs8VwOY0hAjl+rnreNmuqJ4woFhIXqOlVUQOsGh6U8rKbyo5S43NZ5XPpVNkoA9XZpMgqvnNzsPV+BWytQyDT2SviAu+NWMkD+omApUgwysq22xAtRdhZV1H4TnDJv0YJL49owuDRY7jpnVYQN62Tcqzd/gJOyl+A3VJ0Be5x/QVoMAhn8Xyd+MHRXQYYJ+YyeuFzNRr9fd1/0XH8tXCdALHd6ppkuv02KQhFVXS/4IILak+vtr1Tr+42vTqH0utp5fgTiTC211KEsd1e1zlmjLH0GGN2xfgBJSLIGJ+Y0M0gMT9LiQI97IhVV3LnKv2JwPkc+412FMP05wMYvla3m2bTSszcwejQZnfObq1bxTWNmjc2dmzXPGrpYLlb7OsSoa5+SFM5N4Z2/13QfOJinna1rsQC05itNpPiKpKfN+Px/ThNqxk3IV3GMJv+YNnWqe2fHa975Hxr6XXMPfOnMEIKKMcs+jyrqq5cM8cq+qzLk4piO/dJuXFPJNx5bktVjAtqNcz7tqEsvUa1SjXMTZJj7ZCVy5wz+oRKM2bPMAD4AFlPq0Uab5ftHYwOjIM8zpRwAM44aNw2Metx+82bGm8Ho0PjwNRwYEscfKcch2cEvIwAzXB2QwTUM4vG6NAIsDQEOBIBY7rgSHzeJXMOUzZDiMkZGvvXCmbTdxD1jZHG6NDQ0BseblcBYcFQjgXsC23R5IyI1zbLVUN6bZUNdUaHRoR+sKAnEXGNCEqjxblw2K+AtJrGhjoSNEaHRoLeFesdvnAI058PjYB64WAZLRUOGqNDI0Dvm3nn7NDGZqLeAG3cKX/nTirYdqJqv05qb1sj9TKtR1FMn0spxhgyGouP3xBL5OHEt/VYOVrxGs7quCkQFWJCttEhwVEiYSvwlHZpZVdQwJxcqYkYB4F84NY246YR+WqDbI8TGXa1o1ScTCyht9hWluFbbzm01msEp/UidGevEZxWr7Huxo17jXVGrR15+zFH7H7yjzyYaxlpbM4YioCv/DjfPeJi9xgWaQEnUm+QBUuYjoOF/MuptB6jEYNxLE8/WsZE6lyd4RC6T9lM5NokTSwoyG+jedv/E0OhcElhSpFaWPqYJCAZty/frj93FUiIcMkpJQFi1XPECYyV1X5ChuFEoDWlv37Y1inZUvnHHiEnofI1TSXaKFIeaAgK+b5hRsRKFpI0gU7FOpS0dZalCk1bjzVeS7FGDEs42x5+LMASGH3tfXdABGxrNWTuzwu9pbX3+zxzWxoyjW1bnbflnV3VzkerUYqXV7/a8NQYNQ5KYrg5dZ8t3/zvArj5Hw== \ No newline at end of file diff --git a/doc/bgp_error_handling/images/bgp_error_handling_flow3.png b/doc/bgp_error_handling/images/bgp_error_handling_flow3.png new file mode 100644 index 00000000000..be435a6a19c Binary files /dev/null and b/doc/bgp_error_handling/images/bgp_error_handling_flow3.png differ diff --git a/doc/bgp_error_handling/images/bgp_error_handling_flow3.xml b/doc/bgp_error_handling/images/bgp_error_handling_flow3.xml new file mode 100644 index 00000000000..930be9b53e3 --- /dev/null +++ b/doc/bgp_error_handling/images/bgp_error_handling_flow3.xml @@ -0,0 +1,2 @@ + +7Vtbc6s2EP41nmkfnEGIS3j0LWl6ek489nTak5eODDJmgpErcByfX18JBAaEDw42sZPaL4GVWKTd71vtSqQDB8vXe4pWi6/EwX5HVZzXDhx2VPbTLPaHS7aJxAR6InCp5yQisBNMvR9YCBUhXXsODgsdI0L8yFsVhTYJAmxHBRmilGyK3ebEL751hVwsCaY28mXpX54TLRLprWru5L9hz12kbwaGmPASpZ3FTMIFcsgmJ4KjDhxQQqLkavk6wD43XmqX5Lm7Pa3ZwCgOokMeGPe93x8MpwvmD7OnyVj782kUdLVEywvy12LC/fuxGG+0TY1AyTpwMNcDOrC/WXgRnq6QzVs3zO1MtoiWvmiWxyWG+oJphF9zIjHOe0yWOKJb1kW06rfJEwIzuoDMJucAYdRFzvZQyJBwuZvp3VmFXQjDvMFIpmQkyULMuSt+6XvBc9EczAp0+ze7UW709PZ7vm3IJ61kd1txl8GF3/hohv0+sp/d2BUD4hMavxha1mBwxybXjxB1cTTG1GOTxpT7xwtc1sngysia2nhP416HJSrr0YOdAodkt+Ycp1c4LpVR7KPIeykyr8qb4g1j4rERZ6ixiqjJMJJqEEZIHsoTpaQHgKIiq6RHWLqsJ4ZWNunmaLPOgbbmGEgD9YWAQIUlFOgNUVAOQu+MgtSsORg84RlFZ4/NwLqs4AzUD8YXeFF8gcaJoia8PS9foASD+WoZbgPbOTtloHphlJETmt54/M+wv5c49pZRx8G03lyzxLZ/zDJBlrU8riOmBZ/OrppRa1ejyq56W3a9rKX7QiKMdqq8TLPMG/2cMUaVYwy4YfdTHLAgo/xCmW0GAfiVj8iRww7r1eMVKeeTj8LQs4sAODDjv4t/vH9EyTPOtQBLUSD8AJAoIQKUI93BORqsUdQ2IPQr4WWvGKmeYwlvaNaZCW9U+Nfwmbn6cxKPdOdo4981SRu6YbyP1WMdgLJ63TWyK5f/HU0mj5N4wU20sdElCpPmD7YOG2rR4emie651WJXzm0dqL5CLBUzOmQyasNZY75oMprnphcSw2vopde6FBDvTPFWwM2Ax1JXY0Xaok3NXNZfbjIIUa9eM5qBMpOm2U7kelxS1jIM0zuRwAK84aLydAszGxU6NorZxACQcaBwH30jkza8I2I8AqdxVGiJAWlnKitpGwHU345DzhabrvaRIe1/3avLR71trG6uqtLF4lBhjVqOoSo/vghxW4VwDyL5jzDevIPsePB2ghsHLnWLcG+Ppw7fJly9fF93J9668YLzZyZV+qPDVxST7TTeupC2S9jauKn2lHs396n0NnZP/IQgjFI8hXNs2DsNc2nBYMGCldFREBsXs1WgWd+ARYMUtE9tK73f0IZMg33MDDiwGlXiDhJfkno38nmhYeo7Dn/9J9JjHv2xEUlGffWYkRtLJPu7JQ3Q/O/ZuCig3KjDMAiRSHx0JWVCsKtXi82Q+D3ErCJO3yj9dNJBIXF7BD675ymGlvVSg0ldyJmAUeTyVePz5CQvrCKuboIpaR4Kqa1RGgfYJe8BRxkcnrMSzxt8GaTWKWiasvL9t/qQ2/4Tk1GvICfRSdZVmp00R1D7/qo6aPhn/JNoYDfkHlBpFLfNPPjK5/X/xz6jjn5aeJ5xmcTyGfux295F90n33rwpw9B8= \ No newline at end of file diff --git a/doc/bgp_error_handling/images/bgp_error_handling_flow4.png b/doc/bgp_error_handling/images/bgp_error_handling_flow4.png new file mode 100644 index 00000000000..aa18f18ba85 Binary files /dev/null and b/doc/bgp_error_handling/images/bgp_error_handling_flow4.png differ diff --git a/doc/bgp_error_handling/images/bgp_error_handling_flow4.xml b/doc/bgp_error_handling/images/bgp_error_handling_flow4.xml new file mode 100644 index 00000000000..b06c7e9f646 --- /dev/null +++ b/doc/bgp_error_handling/images/bgp_error_handling_flow4.xml @@ -0,0 +1,2 @@ + +7Vrfk6I4EP5rrLp70AIiODz6a+Zm63bHdepubuflKkLE1CDxQhx1//pNICAQOJTV1anSF6QTOkn393U6DS0wXG4fKFwtPhMX+S1Dc7ctMGoZ4qfzi5DsYklPN2OBR7Ebi/S94Bl/R1KoSekauyjMdWSE+Ayv8kKHBAFyWE4GKSWbfLc58fOjrqCHFMGzA31V+oJdtoild0ZvL/8DYW+RjKxbdtyyhElnuZJwAV2yyYjAuAWGlBAW/1tuh8gXxkvsEj93X9GaToyigB3ywGSAPz1ablufP85ep5PuX6/joN2NtbxDfy0XPHiYyPmyXWIEStaBi4QevQUGmwVm6HkFHdG64W7nsgVb+rJZnZec6juiDG0zIjnPB0SWiNEd7yJbzbv4CYkZU0Jmk3GANOoiY3sgZVC63Ev17q3C/0jDHGGknmIkxULcuSvx18fBW94c3Ap09w+/0Tpmcvst2zYSi9bSu528S+Eibnw4Q/4AOm9e5Ioh8QmNBga2PRze88UNGKQeYhNEMV80osI/OPB4J0soI2vqoIrGSofFKuvRg9wch1S3ZhxnljgukVHkQ4bf88wr86YcYUIwn3GKGjuPmhQjiQZphPihLFEKenQ9r8gu6JGWLuqJoJUuujna7EugrTkGkkB9JSAwQAEFZkMUFIPQL0ZBYtYMDF7RjMKLx2bdvq7grBsfjC/gqvgCrAJftIZ8AXeX5QtQYDBfLcNd4LgXpwwwrowyakLTn0z+HQ0qiePsOHVcROvNNYtt++csFaRZy9OacS3odHbtWrV2tcrsap7Lrte1dV9JhOmeKi/r2r2OeckYY6gxxujw+2cU8CCj/Ua5bYaB/rs47opjcMH1vFdfnEgFn3wYhtjJA+DAjP8++on+jJI3lGnRbU0D4ANAooAI3Wiao4EaRecGhHkjvOoVK9m4fpbwlmFfmPBWiX8tn5trMCfRTPeOtv5bk6ShHUZ1rD7voGur7b6R//PEdTydPk2jDTfWxmcXK4ybP9g+bGl5h5tpnL7UTmyoGc4TdRbQQxIol0wHe91ezlyJZS6VDibZ6ZVEsdoTVOLcKwl3vbu8O5uHOwvkg12BHecOdmr2CjLZzThIsHbLaQ7KRbpND9JWjaIz4yCJMxkcdG84aFxQ0a3Gx50aRefGga7gwBQ4+EIYnt8QUI0As5AO6U03hJ5do6gCAdwPcJfpthIdwuoJW2b5OHtAxRpPC69bseSQ1xdNsaMo+sW7SPe6ksorca9SbW/q3tqy/bndq7LXEpvDlKwZ4tfHIGQwUjOKPgiZQ+zf9o4DDhOFkN/4dYxShDkQINV7x6khZKp5Zq+TAuY+AxjscJOS4Aab6h286O2mFVXQq1F05rhiqklnUiNz8XurrODG0Ja1oY+9IK64OdxHiKo1t0RPuIJBqaKDKnd3EUQpWfHLZxSG4vOxfREv1p0fj4ujqVeU9sT0C7DNwTAgolQ3mGPfL8OsXPhIrhoMRB2KE8bvy4Yldl0xVmlha1/6+t/ds/mrzjTtqCluFWHWpLhlPnwbvXz6+n37ZbF2vr69euP+3+0yPB0ZRkqZXmKnS5FfL543jt4zqh48HdlLfaN+fHhsdd0uo6guKDpBIgZoL5gtXAo3hxbaVTZSxIeDs6iDIIncEHlvc9AyR0dRsHoPmke/dEYK4dIPXOVMWiljsjCsZkAlYbVO4aCQMOZnX/HlIZl/nMznIToSUvx2/61s3H3/xTEY/wA= \ No newline at end of file