2 * vrrp.c - vrrp plugin action functions
4 * Copyright 2019-2020 Rubicon Communications, LLC (Netgate)
6 * SPDX-License-Identifier: Apache-2.0
10 #include <vnet/vnet.h>
11 #include <vnet/plugin/plugin.h>
12 #include <vnet/mfib/mfib_entry.h>
13 #include <vnet/mfib/mfib_table.h>
14 #include <vnet/adj/adj.h>
15 #include <vnet/adj/adj_mcast.h>
16 #include <vnet/fib/fib_table.h>
17 #include <vnet/ip/igmp_packet.h>
18 #include <vnet/ip/ip6_link.h>
20 #include <vrrp/vrrp.h>
21 #include <vrrp/vrrp_packet.h>
23 #include <vpp/app/version.h>
25 vrrp_main_t vrrp_main;
27 static const mac_address_t ipv4_vmac = {
28 .bytes = {0x00, 0x00, 0x5e, 0x00, 0x01, 0x00}
31 static const mac_address_t ipv6_vmac = {
32 .bytes = {0x00, 0x00, 0x5e, 0x00, 0x02, 0x00}
39 } vrrp_hwif_vr_count_t;
44 VRRP_IF_UPDATE_HW_LINK,
45 VRRP_IF_UPDATE_SW_ADMIN,
46 } vrrp_intf_update_type_t;
50 vrrp_intf_update_type_t type;
56 static int vrrp_intf_is_up (u32 sw_if_index, u8 is_ipv6,
57 vrrp_intf_update_t * pending);
60 vrrp_hwif_master_count_walk (vnet_main_t * vnm, u32 sw_if_index, void *arg)
62 vrrp_hwif_vr_count_t *vr_count = arg;
65 vr = vrrp_vr_lookup (sw_if_index, vr_count->key.vr_id,
66 vr_count->key.is_ipv6);
68 if (vr && (vr->runtime.state == VRRP_VR_STATE_MASTER))
75 * Get a count of VRs in master state on a given hardware interface with
76 * the provided VR ID and AF.
79 vrrp_vr_hwif_master_vrs_by_vrid (u32 hw_if_index, u8 vr_id, u8 is_ipv6)
81 vnet_main_t *vnm = vnet_get_main ();
82 vrrp_hwif_vr_count_t vr_count;
84 clib_memset (&vr_count, 0, sizeof (vr_count));
86 vr_count.key.vr_id = vr_id;
87 vr_count.key.is_ipv6 = is_ipv6;
89 vnet_hw_interface_walk_sw (vnm, hw_if_index,
90 vrrp_hwif_master_count_walk, &vr_count);
92 return vr_count.count;
96 * Add or delete the VR virtual MAC address on the hardware interface
97 * when a VR enters or leaves the master state.
99 * Multiple subinterfaces may host the same VR ID. We should only add or
100 * delete the virtual MAC if this is the first VR being enabled on the
101 * hardware interface or the last one being disabled, respectively.
104 vrrp_vr_transition_vmac (vrrp_vr_t * vr, vrrp_vr_state_t new_state)
106 vnet_main_t *vnm = vnet_get_main ();
107 clib_error_t *error = 0;
108 vnet_hw_interface_t *hw;
109 u8 enable = (new_state == VRRP_VR_STATE_MASTER);
112 hw = vnet_get_sup_hw_interface (vnm, vr->config.sw_if_index);
114 vrrp_vr_hwif_master_vrs_by_vrid (hw->hw_if_index, vr->config.vr_id,
115 vrrp_vr_is_ipv6 (vr));
117 /* enable only if current master vrs is 0, disable only if 0 or 1 */
118 if ((enable && !n_master_vrs) || (!enable && (n_master_vrs < 2)))
120 clib_warning ("%s virtual MAC address %U on hardware interface %u",
121 (enable) ? "Adding" : "Deleting",
122 format_ethernet_address, vr->runtime.mac.bytes,
125 error = vnet_hw_interface_add_del_mac_address
126 (vnm, hw->hw_if_index, vr->runtime.mac.bytes, enable);
130 clib_error_report (error);
134 * Manage VR interface data on transition to/from master:
135 * - enable or disable ARP/ND input feature if appropriate
136 * - update count of VRs in master state
139 vrrp_vr_transition_intf (vrrp_vr_t * vr, vrrp_vr_state_t new_state)
142 const char *arc_name = 0, *node_name = 0;
143 const char *mc_arc_name = 0, *mc_node_name = 0;
144 u8 is_ipv6 = vrrp_vr_is_ipv6 (vr);
146 int n_master_accept = 0;
148 /* only need to do something if entering or leaving master state */
149 if ((vr->runtime.state != VRRP_VR_STATE_MASTER) &&
150 (new_state != VRRP_VR_STATE_MASTER))
155 arc_name = "ip6-local";
156 node_name = "vrrp6-nd-input";
157 mc_arc_name = "ip6-multicast";
158 mc_node_name = "vrrp6-accept-owner-input";
163 node_name = "vrrp4-arp-input";
164 mc_arc_name = "ip4-multicast";
165 mc_node_name = "vrrp4-accept-owner-input";
168 intf = vrrp_intf_get (vr->config.sw_if_index);
170 if (new_state == VRRP_VR_STATE_MASTER)
172 intf->n_master_vrs[is_ipv6]++;
173 if (intf->n_master_vrs[is_ipv6] == 1)
174 vnet_feature_enable_disable (arc_name, node_name,
175 vr->config.sw_if_index, 1, NULL, 0);
179 if (intf->n_master_vrs[is_ipv6] == 1)
180 vnet_feature_enable_disable (arc_name, node_name,
181 vr->config.sw_if_index, 0, NULL, 0);
182 /* If the count were already 0, leave it at 0 */
183 if (intf->n_master_vrs[is_ipv6])
184 intf->n_master_vrs[is_ipv6]--;
187 /* accept mode enabled, count the other master VRs w/ accept mode on intf */
188 if (vrrp_vr_accept_mode_enabled (vr))
190 vec_foreach (vr_index, intf->vr_indices[is_ipv6])
192 vrrp_vr_t *intf_vr = vrrp_vr_lookup_index (*vr_index);
197 if (vrrp_vr_accept_mode_enabled (intf_vr) &&
198 (intf_vr->runtime.state == VRRP_VR_STATE_MASTER))
202 /* If no others, enable or disable the feature based on new state */
203 if (!n_master_accept)
204 vnet_feature_enable_disable (mc_arc_name, mc_node_name,
205 vr->config.sw_if_index,
206 (new_state == VRRP_VR_STATE_MASTER),
212 /* If accept mode enabled, add/remove VR addresses from interface */
214 vrrp_vr_transition_addrs (vrrp_vr_t * vr, vrrp_vr_state_t new_state)
216 vlib_main_t *vm = vlib_get_main ();
218 ip46_address_t *vr_addr;
220 if (!vrrp_vr_accept_mode_enabled (vr))
223 /* owner always has VR addresses configured, should never remove them */
224 if (vrrp_vr_is_owner (vr))
227 if (vrrp_vr_is_unicast (vr))
230 /* only need to do something if entering or leaving master state */
231 if ((vr->runtime.state != VRRP_VR_STATE_MASTER) &&
232 (new_state != VRRP_VR_STATE_MASTER))
235 is_del = (new_state != VRRP_VR_STATE_MASTER);
237 clib_warning ("%s VR addresses on sw_if_index %u",
238 (is_del) ? "Deleting" : "Adding", vr->config.sw_if_index);
240 vec_foreach (vr_addr, vr->config.vr_addrs)
242 ip_interface_address_t *ia = NULL;
244 /* We need to know the address length to use, find it from another
245 * address on the interface. Or use a default (/24, /64).
247 if (!vrrp_vr_is_ipv6 (vr))
249 ip4_main_t *im = &ip4_main;
250 ip4_address_t *intf4;
253 ip4_interface_address_matching_destination
254 (im, &vr_addr->ip4, vr->config.sw_if_index, &ia);
256 ip4_add_del_interface_address (vm, vr->config.sw_if_index,
258 (intf4 ? ia->address_length : 24),
263 ip6_main_t *im = &ip6_main;
264 ip6_address_t *intf6;
267 ip6_interface_address_matching_destination
268 (im, &vr_addr->ip6, vr->config.sw_if_index, &ia);
270 ip6_add_del_interface_address (vm, vr->config.sw_if_index,
272 (intf6 ? ia->address_length : 64),
279 vrrp_vr_transition (vrrp_vr_t * vr, vrrp_vr_state_t new_state, void *data)
282 clib_warning ("VR %U transitioning to %U", format_vrrp_vr_key, vr,
283 format_vrrp_vr_state, new_state);
285 /* Don't do anything if transitioning to the state VR is already in.
286 * This should never happen, just covering our bases.
288 if (new_state == vr->runtime.state)
291 if (new_state == VRRP_VR_STATE_MASTER)
293 /* RFC 5798 sec 6.4.1 (105) - startup event for VR with priority 255
294 * sec 6.4.2 (365) - master down timer fires on backup VR
297 vrrp_vr_multicast_group_join (vr);
298 vrrp_adv_send (vr, 0);
299 vrrp_garp_or_na_send (vr);
301 vrrp_vr_timer_set (vr, VRRP_VR_TIMER_ADV);
303 else if (new_state == VRRP_VR_STATE_BACKUP)
305 /* RFC 5798 sec 6.4.1 (150) - startup event for VR with priority < 255
306 * sec 6.4.3 (735) - master preempted by higher priority VR
309 vrrp_vr_multicast_group_join (vr);
311 if (vr->runtime.state == VRRP_VR_STATE_MASTER)
313 vrrp_header_t *pkt = data;
314 vr->runtime.master_adv_int = vrrp_adv_int_from_packet (pkt);
317 else /* INIT, INTF_DOWN */
318 vr->runtime.master_adv_int = vr->config.adv_interval;
320 vrrp_vr_skew_compute (vr);
321 vrrp_vr_master_down_compute (vr);
322 vrrp_vr_timer_set (vr, VRRP_VR_TIMER_MASTER_DOWN);
325 else if (new_state == VRRP_VR_STATE_INIT)
327 /* RFC 5798 sec 6.4.2 (345) - shutdown event for backup VR
328 * sec 6.4.3 (655) - shutdown event for master VR
331 vrrp_vr_timer_cancel (vr);
332 if (vr->runtime.state == VRRP_VR_STATE_MASTER)
333 vrrp_adv_send (vr, 1);
335 else if (new_state == VRRP_VR_STATE_INTF_DOWN)
336 /* State is not specified by RFC. This is to avoid attempting to
337 * send packets on an interface that's down and to avoid having a
338 * VR believe it is already the master when an interface is brought up
340 vrrp_vr_timer_cancel (vr);
342 /* add/delete virtual IP addrs if accept_mode is true */
343 vrrp_vr_transition_addrs (vr, new_state);
345 /* enable/disable input features if necessary */
346 vrrp_vr_transition_intf (vr, new_state);
348 /* add/delete virtual MAC address on NIC if necessary */
349 vrrp_vr_transition_vmac (vr, new_state);
351 vr->runtime.state = new_state;
354 #define VRRP4_MCAST_ADDR_AS_U8 { 224, 0, 0, 18 }
355 #define VRRP6_MCAST_ADDR_AS_U8 \
356 { 0xff, 0x2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x12 }
358 static const mfib_prefix_t all_vrrp4_routers = {
359 .fp_proto = FIB_PROTOCOL_IP4,
363 .as_u8 = VRRP4_MCAST_ADDR_AS_U8,
368 static const mfib_prefix_t all_vrrp6_routers = {
369 .fp_proto = FIB_PROTOCOL_IP6,
373 .as_u8 = VRRP6_MCAST_ADDR_AS_U8,
379 vrrp_intf_enable_disable_mcast (u8 enable, u32 sw_if_index, u8 is_ipv6)
381 vrrp_main_t *vrm = &vrrp_main;
384 const mfib_prefix_t *vrrp_prefix;
385 fib_protocol_t proto;
386 vnet_link_t link_type;
387 fib_route_path_t for_us = {
388 .frp_sw_if_index = 0xffffffff,
390 .frp_flags = FIB_ROUTE_PATH_LOCAL,
391 .frp_mitf_flags = MFIB_ITF_FLAG_FORWARD,
393 fib_route_path_t via_itf = {
394 .frp_sw_if_index = sw_if_index,
396 .frp_mitf_flags = MFIB_ITF_FLAG_ACCEPT,
399 intf = vrrp_intf_get (sw_if_index);
403 proto = FIB_PROTOCOL_IP6;
404 link_type = VNET_LINK_IP6;
405 vrrp_prefix = &all_vrrp6_routers;
409 proto = FIB_PROTOCOL_IP4;
410 link_type = VNET_LINK_IP4;
411 vrrp_prefix = &all_vrrp4_routers;
414 for_us.frp_proto = fib_proto_to_dpo (proto);
415 via_itf.frp_proto = fib_proto_to_dpo (proto);
416 fib_index = mfib_table_get_index_for_sw_if_index (proto, sw_if_index);
420 if (pool_elts (vrm->vrs) == 1)
421 mfib_table_entry_path_update (fib_index, vrrp_prefix, MFIB_SOURCE_API,
424 mfib_table_entry_path_update (fib_index, vrrp_prefix, MFIB_SOURCE_API,
426 intf->mcast_adj_index[! !is_ipv6] =
427 adj_mcast_add_or_lock (proto, link_type, sw_if_index);
431 if (pool_elts (vrm->vrs) == 0)
432 mfib_table_entry_path_remove (fib_index, vrrp_prefix, MFIB_SOURCE_API,
435 mfib_table_entry_path_remove (fib_index, vrrp_prefix, MFIB_SOURCE_API,
443 vrrp_intf_vr_add_del (u8 is_add, u32 sw_if_index, u32 vr_index, u8 is_ipv6)
445 vrrp_intf_t *vr_intf;
447 vr_intf = vrrp_intf_get (sw_if_index);
453 if (!vec_len (vr_intf->vr_indices[is_ipv6]))
454 vrrp_intf_enable_disable_mcast (1, sw_if_index, is_ipv6);
456 vec_add1 (vr_intf->vr_indices[is_ipv6], vr_index);
461 vec_search (vr_intf->vr_indices[is_ipv6], vr_index);
463 if (per_intf_index != ~0)
464 vec_del1 (vr_intf->vr_indices[is_ipv6], per_intf_index);
466 /* no more VRs on this interface, disable multicast */
467 if (!vec_len (vr_intf->vr_indices[is_ipv6]))
468 vrrp_intf_enable_disable_mcast (0, sw_if_index, is_ipv6);
474 /* RFC 5798 section 8.3.2 says to take care not to configure more than
475 * one VRRP router as the "IPvX address owner" of a VRID. Make sure that
476 * all of the addresses configured for this VR are configured on the
480 vrrp_vr_valid_addrs_owner (vrrp_vr_config_t * vr_conf)
482 ip46_address_t *addr;
483 u8 is_ipv6 = (vr_conf->flags & VRRP_VR_IPV6) != 0;
485 vec_foreach (addr, vr_conf->vr_addrs)
487 if (!ip_interface_has_address (vr_conf->sw_if_index, addr, !is_ipv6))
488 return VNET_API_ERROR_ADDRESS_NOT_FOUND_FOR_INTERFACE;
495 vrrp_vr_valid_addrs_unused (vrrp_vr_config_t * vr_conf)
497 ip46_address_t *vr_addr;
498 u8 is_ipv6 = (vr_conf->flags & VRRP_VR_IPV6) != 0;
500 vec_foreach (vr_addr, vr_conf->vr_addrs)
505 addr = (is_ipv6) ? (void *) &vr_addr->ip6 : (void *) &vr_addr->ip4;
506 vr_index = vrrp_vr_lookup_address (vr_conf->sw_if_index, is_ipv6, addr);
508 return VNET_API_ERROR_ADDRESS_IN_USE;
515 vrrp_vr_valid_addrs (vrrp_vr_config_t * vr_conf)
519 /* If the VR owns the addresses, make sure they are configured */
520 if (vr_conf->priority == 255 &&
521 (ret = vrrp_vr_valid_addrs_owner (vr_conf)) < 0)
524 /* make sure no other VR has already configured any of the VR addresses */
525 ret = vrrp_vr_valid_addrs_unused (vr_conf);
531 vrrp_vr_addr_add_del (vrrp_vr_t * vr, u8 is_add, ip46_address_t * vr_addr)
533 vrrp_main_t *vmp = &vrrp_main;
535 vrrp4_arp_key_t key4;
537 ip46_address_t *addr;
540 return VNET_API_ERROR_INVALID_ARGUMENT;
542 vr_index = vr - vmp->vrs;
544 if (vrrp_vr_is_ipv6 (vr))
546 key6.sw_if_index = vr->config.sw_if_index;
547 key6.addr = vr_addr->ip6;
550 hash_set_mem_alloc (&vmp->vrrp6_nd_lookup, &key6, vr_index);
551 vec_add1 (vr->config.vr_addrs, vr_addr[0]);
555 hash_unset_mem_free (&vmp->vrrp6_nd_lookup, &key6);
556 vec_foreach (addr, vr->config.vr_addrs)
558 if (!ip46_address_cmp (addr, vr_addr))
560 vec_del1 (vr->config.vr_addrs, vr->config.vr_addrs - addr);
568 key4.sw_if_index = vr->config.sw_if_index;
569 key4.addr = vr_addr->ip4;
572 hash_set (vmp->vrrp4_arp_lookup, key4.as_u64, vr_index);
573 vec_add1 (vr->config.vr_addrs, vr_addr[0]);
577 hash_unset (vmp->vrrp4_arp_lookup, key4.as_u64);
578 vec_foreach (addr, vr->config.vr_addrs)
580 if (!ip46_address_cmp (addr, vr_addr))
582 vec_del1 (vr->config.vr_addrs, vr->config.vr_addrs - addr);
593 vrrp_vr_addrs_add_del (vrrp_vr_t * vr, u8 is_add, ip46_address_t * vr_addrs)
595 ip46_address_t *vr_addr;
597 vec_foreach (vr_addr, vr_addrs)
599 vrrp_vr_addr_add_del (vr, is_add, vr_addr);
603 /* Action function shared between message handler and debug CLI */
605 vrrp_vr_add_del (u8 is_add, vrrp_vr_config_t * vr_conf)
607 vrrp_main_t *vrm = &vrrp_main;
608 vnet_main_t *vnm = vnet_get_main ();
615 if (vr_conf->sw_if_index == ~0 ||
616 !vnet_sw_interface_is_valid (vnm, vr_conf->sw_if_index))
617 return VNET_API_ERROR_INVALID_SW_IF_INDEX;
619 clib_memset (&key, 0, sizeof (key));
621 key.sw_if_index = vr_conf->sw_if_index;
622 key.vr_id = vr_conf->vr_id;
623 key.is_ipv6 = ((vr_conf->flags & VRRP_VR_IPV6) != 0);
625 p = mhash_get (&vrm->vr_index_by_key, &key);
629 /* does a VR matching this key already exist ? */
632 clib_warning ("VR %u for IPv%d already exists on sw_if_index %u",
633 key.vr_id, (key.is_ipv6) ? 6 : 4, key.sw_if_index);
634 return VNET_API_ERROR_ENTRY_ALREADY_EXISTS;
637 /* were IPvX addresses included ? */
638 if (!vec_len (vr_conf->vr_addrs))
640 clib_warning ("Conf of VR %u for IPv%d on sw_if_index %u "
641 " does not contain IP addresses",
642 key.vr_id, (key.is_ipv6) ? 6 : 4, key.sw_if_index);
643 return VNET_API_ERROR_INVALID_SRC_ADDRESS;
646 /* Make sure the addresses are ok to use */
647 if ((ret = vrrp_vr_valid_addrs (vr_conf)) < 0)
650 pool_get_zero (vrm->vrs, vr);
651 vr_index = vr - vrm->vrs;
653 clib_memcpy (&vr->config, vr_conf, sizeof (vrrp_vr_config_t));
655 vr->config.vr_addrs = 0; /* allocate our own memory */
656 vrrp_vr_addrs_add_del (vr, is_add, vr_conf->vr_addrs);
658 vr->runtime.state = VRRP_VR_STATE_INIT;
659 vr->runtime.timer_index = ~0;
661 /* set virtual MAC based on IP version and VR ID */
662 vr->runtime.mac = (key.is_ipv6) ? ipv6_vmac : ipv4_vmac;
663 vr->runtime.mac.bytes[5] = vr_conf->vr_id;
665 mhash_set (&vrm->vr_index_by_key, &key, vr_index, 0);
671 clib_warning ("No VR %u for IPv%d exists on sw_if_index %u",
672 key.vr_id, (key.is_ipv6) ? 6 : 4, key.sw_if_index);
673 return VNET_API_ERROR_NO_SUCH_ENTRY;
677 vr = pool_elt_at_index (vrm->vrs, vr_index);
679 vrrp_vr_tracking_ifs_add_del (vr, vr->tracking.interfaces, is_add);
680 vrrp_vr_addrs_add_del (vr, is_add, vr->config.vr_addrs);
681 mhash_unset (&vrm->vr_index_by_key, &key, 0);
682 vec_free (vr->config.vr_addrs);
683 vec_free (vr->tracking.interfaces);
684 pool_put (vrm->vrs, vr);
687 vrrp_intf_vr_add_del (is_add, vr_conf->sw_if_index, vr_index, key.is_ipv6);
693 vrrp_vr_start_stop (u8 is_start, vrrp_vr_key_t * vr_key)
695 vrrp_main_t *vmp = &vrrp_main;
699 p = mhash_get (&vmp->vr_index_by_key, vr_key);
701 return VNET_API_ERROR_NO_SUCH_ENTRY;
703 vr = pool_elt_at_index (vmp->vrs, p[0]);
705 /* return success if already in the desired state */
706 switch (vr->runtime.state)
708 case VRRP_VR_STATE_INIT:
711 clib_warning ("Attempting to stop already stopped VR (%U)",
712 format_vrrp_vr_key, vr);
719 clib_warning ("Attempting to start already started VR (%U)",
720 format_vrrp_vr_key, vr);
728 if (vrrp_vr_is_unicast (vr) && vec_len (vr->config.peer_addrs) == 0)
730 clib_warning ("Cannot start unicast VR without peers");
731 return VNET_API_ERROR_INIT_FAILED;
734 vmp->n_vrs_started++;
736 if (!vrrp_intf_is_up (vr->config.sw_if_index, vrrp_vr_is_ipv6 (vr),
739 clib_warning ("VRRP VR started on down interface (%U)",
740 format_vrrp_vr_key, vr);
741 vrrp_vr_transition (vr, VRRP_VR_STATE_INTF_DOWN, NULL);
743 else if (vrrp_vr_is_owner (vr))
744 vrrp_vr_transition (vr, VRRP_VR_STATE_MASTER, NULL);
746 vrrp_vr_transition (vr, VRRP_VR_STATE_BACKUP, NULL);
750 vmp->n_vrs_started--;
752 vrrp_vr_transition (vr, VRRP_VR_STATE_INIT, NULL);
755 clib_warning ("%d VRs configured, %d VRs running",
756 pool_elts (vmp->vrs), vmp->n_vrs_started);
762 vrrp_vr_set_peers_validate (vrrp_vr_t * vr, ip46_address_t * peers)
764 if (!vrrp_vr_is_unicast (vr))
766 clib_warning ("Peers can only be set on a unicast VR");
767 return VNET_API_ERROR_INVALID_ARGUMENT;
770 if (vr->runtime.state != VRRP_VR_STATE_INIT)
772 clib_warning ("Cannot set peers on a running VR");
773 return VNET_API_ERROR_RSRC_IN_USE;
776 if (vec_len (peers) == 0)
778 clib_warning ("No peer addresses provided");
779 return VNET_API_ERROR_INVALID_DST_ADDRESS;
786 vrrp_vr_set_peers (vrrp_vr_key_t * vr_key, ip46_address_t * peers)
788 vrrp_main_t *vmp = &vrrp_main;
793 p = mhash_get (&vmp->vr_index_by_key, vr_key);
795 return VNET_API_ERROR_NO_SUCH_ENTRY;
797 vr = pool_elt_at_index (vmp->vrs, p[0]);
799 ret = vrrp_vr_set_peers_validate (vr, peers);
803 if (vr->config.peer_addrs)
804 vec_free (vr->config.peer_addrs);
806 vr->config.peer_addrs = vec_dup (peers);
811 /* Manage reference on the interface to the VRs which track that interface */
813 vrrp_intf_tracking_vr_add_del (u32 sw_if_index, vrrp_vr_t * vr, u8 is_add)
817 u8 is_ipv6 = vrrp_vr_is_ipv6 (vr);
820 intf = vrrp_intf_get (sw_if_index);
821 vr_index = vrrp_vr_index (vr);
823 /* Try to find the VR index in the list of tracking VRs */
824 vec_foreach_index (i, intf->tracking_vrs[is_ipv6])
826 if (vec_elt (intf->tracking_vrs[is_ipv6], i) != vr_index)
829 /* Current index matches VR index */
831 vec_delete (intf->tracking_vrs[is_ipv6], 1, i);
833 /* If deleting, the job is done. If adding, it's already here */
837 /* vr index was not found. */
839 vec_add1 (intf->tracking_vrs[is_ipv6], vr_index);
842 /* Check if sw intf admin state is up or in the process of coming up */
844 vrrp_intf_sw_admin_up (u32 sw_if_index, vrrp_intf_update_t * pending)
846 vnet_main_t *vnm = vnet_get_main ();
849 if (pending && (pending->type == VRRP_IF_UPDATE_SW_ADMIN))
850 admin_up = pending->intf_up;
852 admin_up = vnet_sw_interface_is_admin_up (vnm, sw_if_index);
857 /* Check if hw intf link state is up or int the process of coming up */
859 vrrp_intf_hw_link_up (u32 sw_if_index, vrrp_intf_update_t * pending)
861 vnet_main_t *vnm = vnet_get_main ();
862 vnet_sw_interface_t *sup_sw;
865 sup_sw = vnet_get_sup_sw_interface (vnm, sw_if_index);
867 if (pending && (pending->type == VRRP_IF_UPDATE_HW_LINK) &&
868 (pending->hw_if_index == sup_sw->hw_if_index))
869 link_up = pending->intf_up;
871 link_up = vnet_hw_interface_is_link_up (vnm, sup_sw->hw_if_index);
876 /* Check if interface has ability to send IP packets. */
878 vrrp_intf_ip_up (u32 sw_if_index, u8 is_ipv6, vrrp_intf_update_t * pending)
882 if (pending && pending->type == VRRP_IF_UPDATE_IP)
883 ip_up = pending->intf_up;
885 /* Either a unicast address has to be explicitly assigned, or
886 * for IPv6 only, a link local assigned and multicast/ND enabled
889 ((ip_interface_get_first_ip (sw_if_index, !is_ipv6) != 0) ||
890 (is_ipv6 && ip6_link_is_enabled (sw_if_index)));
896 vrrp_intf_is_up (u32 sw_if_index, u8 is_ipv6, vrrp_intf_update_t * pending)
898 int admin_up, link_up, ip_up;
900 admin_up = vrrp_intf_sw_admin_up (sw_if_index, pending);
901 link_up = vrrp_intf_hw_link_up (sw_if_index, pending);
902 ip_up = vrrp_intf_ip_up (sw_if_index, is_ipv6, pending);
904 return (admin_up && link_up && ip_up);
907 /* Examine the state of interfaces tracked by a VR and compute the priority
908 * adjustment that should be applied to the VR. If this is being called
909 * by the hw_link_up_down callback, the pending new flags on the sup hw
910 * interface have not been updated yet, so accept those as an optional
914 vrrp_vr_tracking_ifs_compute (vrrp_vr_t * vr, vrrp_intf_update_t * pending)
916 vrrp_vr_tracking_if_t *intf;
917 u32 total_priority = 0;
919 vec_foreach (intf, vr->tracking.interfaces)
921 if (vrrp_intf_is_up (intf->sw_if_index, vrrp_vr_is_ipv6 (vr), pending))
924 total_priority += intf->priority;
927 if (total_priority != vr->tracking.interfaces_dec)
929 clib_warning ("VR %U interface track adjustment change from %u to %u",
930 format_vrrp_vr_key, vr, vr->tracking.interfaces_dec,
932 vr->tracking.interfaces_dec = total_priority;
936 /* Manage tracked interfaces on a VR */
938 vrrp_vr_tracking_if_add_del (vrrp_vr_t * vr, u32 sw_if_index, u8 prio,
941 vnet_main_t *vnm = vnet_get_main ();
942 vrrp_vr_tracking_if_t *track_intf;
944 /* VR can't track non-existent interface */
945 if (!vnet_sw_interface_is_valid (vnm, sw_if_index))
946 return VNET_API_ERROR_INVALID_SW_IF_INDEX;
948 /* VR can't track it's own interface */
949 if (sw_if_index == vr->config.sw_if_index)
950 return VNET_API_ERROR_INVALID_SW_IF_INDEX_2;
952 /* update intf vector of tracking VRs */
953 vrrp_intf_tracking_vr_add_del (sw_if_index, vr, is_add);
955 /* update VR vector of tracked interfaces */
956 vec_foreach (track_intf, vr->tracking.interfaces)
958 if (track_intf->sw_if_index != sw_if_index)
964 (vr->tracking.interfaces, 1, track_intf - vr->tracking.interfaces);
971 vec_add2 (vr->tracking.interfaces, track_intf, 1);
973 track_intf->sw_if_index = sw_if_index;
974 track_intf->priority = prio;
981 vrrp_vr_tracking_ifs_add_del (vrrp_vr_t * vr,
982 vrrp_vr_tracking_if_t * track_ifs, u8 is_add)
984 vrrp_vr_tracking_if_t *track_if, *ifs_copy;
987 /* if deleting & track_ifs points to the VR list of tracked intfs, the
988 * vector could be modified as we iterate it. make a copy instead */
989 ifs_copy = vec_dup (track_ifs);
991 /* add each tracked interface in the vector */
992 vec_foreach (track_if, ifs_copy)
994 rv = vrrp_vr_tracking_if_add_del (vr, track_if->sw_if_index,
995 track_if->priority, (is_add != 0));
997 /* if operation failed, undo the previous changes */
1000 vrrp_vr_tracking_if_t *rb_if;
1002 for (rb_if = track_if - 1; rb_if >= track_ifs; rb_if -= 1)
1003 vrrp_vr_tracking_if_add_del (vr, rb_if->sw_if_index,
1004 rb_if->priority, !(is_add != 0));
1009 vec_free (ifs_copy);
1011 vrrp_vr_tracking_ifs_compute (vr, 0);
1016 /* Compute priority to advertise on all VRs which track the given interface
1017 * and address family. The flags on an HW interface are not updated until
1018 * after link up/down callbacks are invoked, so if this function is called
1019 * by the link up/down callback, the flags about to be set will be passed
1020 * via the 'pending' argument. Otherwise, pending will be NULL.
1023 vrrp_intf_tracking_vrs_compute (u32 sw_if_index,
1024 vrrp_intf_update_t * pending, u8 is_ipv6)
1028 vrrp_intf_t *intf = vrrp_intf_get (sw_if_index);
1030 vec_foreach (vr_index, intf->tracking_vrs[is_ipv6])
1032 vr = vrrp_vr_lookup_index (*vr_index);
1034 vrrp_vr_tracking_ifs_compute (vr, pending);
1038 /* Interface being brought up/down is a quasi-{startup/shutdown} event.
1039 * Execute an appropriate state transition for all VRs on the interface.
1040 * This function may be invoked by:
1041 * sw interface admin up/down event
1042 * hw interface link up/down event
1045 vrrp_sw_interface_up_down (vrrp_intf_update_t * pending)
1052 intf = vrrp_intf_get (pending->sw_if_index);
1056 /* adjust state of VR's configured on this interface */
1057 for (i = 0; i < 2; i++)
1061 if (!intf->vr_indices[i])
1064 is_up = vrrp_intf_is_up (pending->sw_if_index, i, pending);
1066 vec_foreach (vr_index, intf->vr_indices[i])
1068 vrrp_vr_state_t vr_state;
1070 vr = vrrp_vr_lookup_index (*vr_index);
1074 if (vr->runtime.state == VRRP_VR_STATE_INIT)
1075 continue; /* VR not started yet, no transition */
1078 vr_state = VRRP_VR_STATE_INTF_DOWN;
1081 if (vr->runtime.state != VRRP_VR_STATE_INTF_DOWN)
1082 continue; /* shouldn't happen */
1084 vr_state = (vrrp_vr_is_owner (vr)) ?
1085 VRRP_VR_STATE_MASTER : VRRP_VR_STATE_BACKUP;
1088 vrrp_vr_transition (vr, vr_state, NULL);
1092 /* compute adjustments on any VR's tracking this interface */
1093 vrrp_intf_tracking_vrs_compute (pending->sw_if_index, pending,
1095 vrrp_intf_tracking_vrs_compute (pending->sw_if_index, pending,
1101 /* Process change in admin status on an interface */
1103 vrrp_sw_interface_admin_up_down (vnet_main_t * vnm, u32 sw_if_index,
1106 vrrp_intf_update_t pending = {
1107 .type = VRRP_IF_UPDATE_SW_ADMIN,
1108 .sw_if_index = sw_if_index,
1109 .intf_up = ((flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) != 0),
1112 return vrrp_sw_interface_up_down (&pending);
1115 VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION (vrrp_sw_interface_admin_up_down);
1118 vrrp_hw_interface_link_up_down_walk (vnet_main_t * vnm,
1119 u32 sw_if_index, void *arg)
1121 vrrp_intf_update_t *pending = arg;
1123 pending->sw_if_index = sw_if_index;
1124 vrrp_sw_interface_up_down (pending);
1126 return WALK_CONTINUE;
1129 static clib_error_t *
1130 vrrp_hw_interface_link_up_down (vnet_main_t * vnm, u32 hw_if_index, u32 flags)
1132 vrrp_intf_update_t pending = {
1133 .type = VRRP_IF_UPDATE_HW_LINK,
1134 .hw_if_index = hw_if_index,
1135 .intf_up = ((flags & VNET_HW_INTERFACE_FLAG_LINK_UP) != 0),
1138 /* walk the sw interface and sub interfaces to adjust interface tracking */
1139 vnet_hw_interface_walk_sw (vnm, hw_if_index,
1140 vrrp_hw_interface_link_up_down_walk, &pending);
1145 VNET_HW_INTERFACE_LINK_UP_DOWN_FUNCTION (vrrp_hw_interface_link_up_down);
1148 vrrp_ip4_add_del_interface_addr (ip4_main_t * im,
1151 ip4_address_t * address,
1153 u32 if_address_index, u32 is_del)
1155 vrrp_intf_tracking_vrs_compute (sw_if_index, NULL, 0 /* is_ipv6 */ );
1158 static ip6_link_delegate_id_t vrrp_ip6_delegate_id;
1161 format_vrrp_ip6_link (u8 * s, va_list * args)
1163 index_t indi = va_arg (*args, index_t);
1164 u32 indent = va_arg (*args, u32);
1168 intf = vrrp_intf_get ((u32) indi);
1170 s = format (s, "%UVRRP VRs monitoring this link:\n",
1171 format_white_space, indent);
1173 vec_foreach (vr_index, intf->tracking_vrs[1])
1175 vrrp_vr_t *vr = vrrp_vr_lookup_index (*vr_index);
1177 s = format (s, "%U%U\n", format_white_space, indent + 2,
1178 format_vrrp_vr_key, vr);
1185 vrrp_intf_ip6_enable_disable (u32 sw_if_index, int enable)
1187 vrrp_intf_update_t pending = {
1188 .type = VRRP_IF_UPDATE_IP,
1189 .sw_if_index = sw_if_index,
1193 vrrp_intf_tracking_vrs_compute (sw_if_index, &pending, 1 /* is_ipv6 */ );
1197 vrrp_intf_ip6_enable (u32 sw_if_index)
1199 vrrp_intf_ip6_enable_disable (sw_if_index, 1 /* enable */ );
1200 ip6_link_delegate_update (sw_if_index, vrrp_ip6_delegate_id, sw_if_index);
1204 vrrp_intf_ip6_disable (index_t indi)
1206 vrrp_intf_ip6_enable_disable (indi, 0 /* enable */ );
1209 const static ip6_link_delegate_vft_t vrrp_ip6_delegate_vft = {
1210 .ildv_enable = vrrp_intf_ip6_enable,
1211 .ildv_disable = vrrp_intf_ip6_disable,
1212 .ildv_format = format_vrrp_ip6_link,
1215 static clib_error_t *
1216 vrrp_init (vlib_main_t * vm)
1218 vrrp_main_t *vmp = &vrrp_main;
1219 clib_error_t *error = 0;
1220 ip4_main_t *im4 = &ip4_main;
1221 ip4_add_del_interface_address_callback_t cb4;
1222 vlib_node_t *intf_output_node;
1224 clib_memset (vmp, 0, sizeof (*vmp));
1226 if ((error = vlib_call_init_function (vm, ip4_lookup_init)) ||
1227 (error = vlib_call_init_function (vm, ip6_lookup_init)))
1230 vmp->vlib_main = vm;
1231 vmp->vnet_main = vnet_get_main ();
1233 intf_output_node = vlib_get_node_by_name (vm, (u8 *) "interface-output");
1234 vmp->intf_output_node_idx = intf_output_node->index;
1236 error = vrrp_plugin_api_hookup (vm);
1241 mhash_init (&vmp->vr_index_by_key, sizeof (u32), sizeof (vrrp_vr_key_t));
1242 vmp->vrrp4_arp_lookup = hash_create (0, sizeof (uword));
1243 vmp->vrrp6_nd_lookup = hash_create_mem (0, sizeof (vrrp6_nd_key_t),
1246 cb4.function = vrrp_ip4_add_del_interface_addr;
1247 cb4.function_opaque = 0;
1248 vec_add1 (im4->add_del_interface_address_callbacks, cb4);
1250 vrrp_ip6_delegate_id = ip6_link_delegate_register (&vrrp_ip6_delegate_vft);
1255 VLIB_INIT_FUNCTION (vrrp_init);
1259 VLIB_PLUGIN_REGISTER () =
1261 .version = VPP_BUILD_VER,
1262 .description = "VRRP v3 (RFC 5798)",
1267 * fd.io coding-style-patch-verification: ON
1270 * eval: (c-set-style "gnu")