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}
35 vlib_simple_counter_main_t vrrp_errs[] = {
36 /* Total number of VRRP packets received with invalid checksum */
38 .name = "CHKSUM_ERRS",
39 .stat_segment_name = "/net/vrrp/chksum-errs",
41 /* Total number of VRRP packets received with unknown or unsupported version
44 .name = "VERSION_ERRS",
45 .stat_segment_name = "/net/vrrp/version-errs",
47 /* Total number of VRRP packets received with invalid VRID */
50 .stat_segment_name = "/net/vrrp/vrid-errs",
52 /* Total number of VRRP packets received with TTL/Hop limit != 255 */
55 .stat_segment_name = "/net/vrrp/ttl-errs",
57 /* Number of packets received with an address list not matching the locally
60 .name = "ADDR_LIST_ERRS",
61 .stat_segment_name = "/net/vrrp/addr-list-errs",
63 /* Number of packets received with a length less than the VRRP header */
65 .name = "PACKET_LEN_ERRS",
66 .stat_segment_name = "/net/vrrp/packet-len-errs",
71 vrrp_incr_err_counter (vrrp_err_counter_t err_type)
73 if (err_type >= VRRP_ERR_COUNTER_MAX)
75 clib_warning ("Attempt to increse error counter of unknown type %u",
79 vlib_increment_simple_counter (&vrrp_errs[err_type],
80 vlib_get_main ()->thread_index, 0, 1);
83 // per-VRRP statistics
85 /* Number of times a VRRP instance has transitioned to master */
86 vlib_simple_counter_main_t vrrp_stats[] = {
88 .name = "MASTER_TRANS",
89 .stat_segment_name = "/net/vrrp/master-trans",
91 /* Number of VRRP advertisements sent by a VRRP instance */
94 .stat_segment_name = "/net/vrrp/adv-sent",
96 /* Number of VRRP advertisements received by a VRRP instance */
99 .stat_segment_name = "/net/vrrp/adv-rcvd",
101 /* Number of VRRP priority-0 packets sent by a VRRP instance */
103 .name = "PRIO0_SENT",
104 .stat_segment_name = "/net/vrrp/prio0-sent",
106 /* Number of VRRP priority-0 packets received by a VRRP instance */
108 .name = "PRIO0_RCVD",
109 .stat_segment_name = "/net/vrrp/prio0-rcvd",
114 vrrp_incr_stat_counter (vrrp_stat_counter_t stat_type, u32 stat_index)
116 if (stat_type >= VRRP_STAT_COUNTER_MAX)
118 clib_warning ("Attempt to increse stat counter of unknown type %u",
122 vlib_increment_simple_counter (
123 &vrrp_stats[stat_type], vlib_get_main ()->thread_index, stat_index, 1);
130 } vrrp_hwif_vr_count_t;
135 VRRP_IF_UPDATE_HW_LINK,
136 VRRP_IF_UPDATE_SW_ADMIN,
137 } vrrp_intf_update_type_t;
141 vrrp_intf_update_type_t type;
145 } vrrp_intf_update_t;
147 static int vrrp_intf_is_up (u32 sw_if_index, u8 is_ipv6,
148 vrrp_intf_update_t * pending);
151 vrrp_hwif_master_count_walk (vnet_main_t * vnm, u32 sw_if_index, void *arg)
153 vrrp_hwif_vr_count_t *vr_count = arg;
156 vr = vrrp_vr_lookup (sw_if_index, vr_count->key.vr_id,
157 vr_count->key.is_ipv6);
159 if (vr && (vr->runtime.state == VRRP_VR_STATE_MASTER))
162 return WALK_CONTINUE;
166 * Get a count of VRs in master state on a given hardware interface with
167 * the provided VR ID and AF.
170 vrrp_vr_hwif_master_vrs_by_vrid (u32 hw_if_index, u8 vr_id, u8 is_ipv6)
172 vnet_main_t *vnm = vnet_get_main ();
173 vrrp_hwif_vr_count_t vr_count;
175 clib_memset (&vr_count, 0, sizeof (vr_count));
177 vr_count.key.vr_id = vr_id;
178 vr_count.key.is_ipv6 = is_ipv6;
180 vnet_hw_interface_walk_sw (vnm, hw_if_index,
181 vrrp_hwif_master_count_walk, &vr_count);
183 return vr_count.count;
187 * Add or delete the VR virtual MAC address on the hardware interface
188 * when a VR enters or leaves the master state.
190 * Multiple subinterfaces may host the same VR ID. We should only add or
191 * delete the virtual MAC if this is the first VR being enabled on the
192 * hardware interface or the last one being disabled, respectively.
195 vrrp_vr_transition_vmac (vrrp_vr_t * vr, vrrp_vr_state_t new_state)
197 vnet_main_t *vnm = vnet_get_main ();
198 clib_error_t *error = 0;
199 vnet_hw_interface_t *hw;
200 u8 enable = (new_state == VRRP_VR_STATE_MASTER);
203 hw = vnet_get_sup_hw_interface (vnm, vr->config.sw_if_index);
205 vrrp_vr_hwif_master_vrs_by_vrid (hw->hw_if_index, vr->config.vr_id,
206 vrrp_vr_is_ipv6 (vr));
208 /* enable only if current master vrs is 0, disable only if 0 or 1 */
209 if ((enable && !n_master_vrs) || (!enable && (n_master_vrs < 2)))
211 clib_warning ("%s virtual MAC address %U on hardware interface %u",
212 (enable) ? "Adding" : "Deleting",
213 format_ethernet_address, vr->runtime.mac.bytes,
216 error = vnet_hw_interface_add_del_mac_address
217 (vnm, hw->hw_if_index, vr->runtime.mac.bytes, enable);
221 clib_error_report (error);
225 * Manage VR interface data on transition to/from master:
226 * - enable or disable ARP/ND input feature if appropriate
227 * - update count of VRs in master state
230 vrrp_vr_transition_intf (vrrp_vr_t * vr, vrrp_vr_state_t new_state)
233 const char *arc_name = 0, *node_name = 0;
234 const char *mc_arc_name = 0, *mc_node_name = 0;
235 u8 is_ipv6 = vrrp_vr_is_ipv6 (vr);
237 int n_master_accept = 0;
242 arc_name = "ip6-local";
243 node_name = "vrrp6-nd-input";
244 mc_arc_name = "ip6-multicast";
245 mc_node_name = "vrrp6-accept-owner-input";
250 node_name = "vrrp4-arp-input";
251 mc_arc_name = "ip4-multicast";
252 mc_node_name = "vrrp4-accept-owner-input";
255 intf = vrrp_intf_get (vr->config.sw_if_index);
257 /* Check other VRs on this intf to see if features need to be toggled */
258 vec_foreach (vr_index, intf->vr_indices[is_ipv6])
260 vrrp_vr_t *intf_vr = vrrp_vr_lookup_index (*vr_index);
265 if (intf_vr->runtime.state == VRRP_VR_STATE_INIT)
270 if ((intf_vr->runtime.state == VRRP_VR_STATE_MASTER) &&
271 vrrp_vr_accept_mode_enabled (intf_vr))
275 /* If entering/leaving init state, start/stop ARP or ND feature if no other
276 * VRs are active on the interface.
278 if (((vr->runtime.state == VRRP_VR_STATE_INIT) ||
279 (new_state == VRRP_VR_STATE_INIT)) && (n_started == 0))
280 vnet_feature_enable_disable (arc_name, node_name,
281 vr->config.sw_if_index,
282 (new_state != VRRP_VR_STATE_INIT), NULL, 0);
284 /* Special housekeeping when entering/leaving master mode */
285 if ((vr->runtime.state == VRRP_VR_STATE_MASTER) ||
286 (new_state == VRRP_VR_STATE_MASTER))
288 /* Maintain count of master state VRs on interface */
289 if (new_state == VRRP_VR_STATE_MASTER)
290 intf->n_master_vrs[is_ipv6]++;
291 else if (intf->n_master_vrs[is_ipv6] > 0)
292 intf->n_master_vrs[is_ipv6]--;
294 /* If accept mode is enabled and no other master on intf has accept
295 * mode enabled, enable/disable feature node to avoid spurious drops by
298 if (vrrp_vr_accept_mode_enabled (vr) && !n_master_accept)
299 vnet_feature_enable_disable (mc_arc_name, mc_node_name,
300 vr->config.sw_if_index,
301 (new_state == VRRP_VR_STATE_MASTER),
306 /* If accept mode enabled, add/remove VR addresses from interface */
308 vrrp_vr_transition_addrs (vrrp_vr_t * vr, vrrp_vr_state_t new_state)
310 vlib_main_t *vm = vlib_get_main ();
312 ip46_address_t *vr_addr;
314 if (!vrrp_vr_accept_mode_enabled (vr))
317 /* owner always has VR addresses configured, should never remove them */
318 if (vrrp_vr_is_owner (vr))
321 /* only need to do something if entering or leaving master state */
322 if ((vr->runtime.state != VRRP_VR_STATE_MASTER) &&
323 (new_state != VRRP_VR_STATE_MASTER))
326 is_del = (new_state != VRRP_VR_STATE_MASTER);
328 clib_warning ("%s VR addresses on sw_if_index %u",
329 (is_del) ? "Deleting" : "Adding", vr->config.sw_if_index);
331 vec_foreach (vr_addr, vr->config.vr_addrs)
333 ip_interface_address_t *ia = NULL;
335 /* We need to know the address length to use, find it from another
336 * address on the interface. Or use a default (/24, /64).
338 if (!vrrp_vr_is_ipv6 (vr))
340 ip4_main_t *im = &ip4_main;
341 ip4_address_t *intf4;
344 ip4_interface_address_matching_destination
345 (im, &vr_addr->ip4, vr->config.sw_if_index, &ia);
347 ip4_add_del_interface_address (vm, vr->config.sw_if_index,
349 (intf4 ? ia->address_length : 24),
354 ip6_main_t *im = &ip6_main;
355 ip6_address_t *intf6;
358 ip6_interface_address_matching_destination
359 (im, &vr_addr->ip6, vr->config.sw_if_index, &ia);
361 ip6_add_del_interface_address (vm, vr->config.sw_if_index,
363 (intf6 ? ia->address_length : 64),
370 vrrp_vr_transition (vrrp_vr_t * vr, vrrp_vr_state_t new_state, void *data)
373 clib_warning ("VR %U transitioning to %U", format_vrrp_vr_key, vr,
374 format_vrrp_vr_state, new_state);
376 /* Don't do anything if transitioning to the state VR is already in.
377 * This should never happen, just covering our bases.
379 if (new_state == vr->runtime.state)
382 if (new_state == VRRP_VR_STATE_MASTER)
384 vrrp_incr_stat_counter (VRRP_STAT_COUNTER_MASTER_TRANS, vr->stat_index);
385 /* RFC 5798 sec 6.4.1 (105) - startup event for VR with priority 255
386 * sec 6.4.2 (365) - master down timer fires on backup VR
389 vrrp_vr_multicast_group_join (vr);
390 vrrp_adv_send (vr, 0);
391 vrrp_garp_or_na_send (vr);
393 vrrp_vr_timer_set (vr, VRRP_VR_TIMER_ADV);
395 else if (new_state == VRRP_VR_STATE_BACKUP)
397 /* RFC 5798 sec 6.4.1 (150) - startup event for VR with priority < 255
398 * sec 6.4.3 (735) - master preempted by higher priority VR
401 vrrp_vr_multicast_group_join (vr);
403 if (vr->runtime.state == VRRP_VR_STATE_MASTER)
405 vrrp_input_process_args_t *args = data;
408 vr->runtime.master_adv_int = args->max_adv_int;
410 else /* INIT, INTF_DOWN */
411 vr->runtime.master_adv_int = vr->config.adv_interval;
413 vrrp_vr_skew_compute (vr);
414 vrrp_vr_master_down_compute (vr);
415 vrrp_vr_timer_set (vr, VRRP_VR_TIMER_MASTER_DOWN);
418 else if (new_state == VRRP_VR_STATE_INIT)
420 /* RFC 5798 sec 6.4.2 (345) - shutdown event for backup VR
421 * sec 6.4.3 (655) - shutdown event for master VR
424 vrrp_vr_timer_cancel (vr);
425 if (vr->runtime.state == VRRP_VR_STATE_MASTER)
426 vrrp_adv_send (vr, 1);
428 else if (new_state == VRRP_VR_STATE_INTF_DOWN)
429 /* State is not specified by RFC. This is to avoid attempting to
430 * send packets on an interface that's down and to avoid having a
431 * VR believe it is already the master when an interface is brought up
433 vrrp_vr_timer_cancel (vr);
435 /* add/delete virtual IP addrs if accept_mode is true */
436 vrrp_vr_transition_addrs (vr, new_state);
438 /* enable/disable input features if necessary */
439 vrrp_vr_transition_intf (vr, new_state);
441 /* add/delete virtual MAC address on NIC if necessary */
442 vrrp_vr_transition_vmac (vr, new_state);
444 vrrp_vr_event (vr, new_state);
446 vr->runtime.state = new_state;
449 #define VRRP4_MCAST_ADDR_AS_U8 { 224, 0, 0, 18 }
450 #define VRRP6_MCAST_ADDR_AS_U8 \
451 { 0xff, 0x2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x12 }
453 static const mfib_prefix_t all_vrrp4_routers = {
454 .fp_proto = FIB_PROTOCOL_IP4,
458 .as_u8 = VRRP4_MCAST_ADDR_AS_U8,
463 static const mfib_prefix_t all_vrrp6_routers = {
464 .fp_proto = FIB_PROTOCOL_IP6,
468 .as_u8 = VRRP6_MCAST_ADDR_AS_U8,
474 vrrp_intf_enable_disable_mcast (u8 enable, u32 sw_if_index, u8 is_ipv6)
476 vrrp_main_t *vrm = &vrrp_main;
479 u32 n_vrs_in_fib = 0;
480 const mfib_prefix_t *vrrp_prefix;
481 fib_protocol_t proto;
482 vnet_link_t link_type;
483 fib_route_path_t for_us = {
484 .frp_sw_if_index = 0xffffffff,
486 .frp_flags = FIB_ROUTE_PATH_LOCAL,
487 .frp_mitf_flags = MFIB_ITF_FLAG_FORWARD,
489 fib_route_path_t via_itf = {
490 .frp_sw_if_index = sw_if_index,
492 .frp_mitf_flags = MFIB_ITF_FLAG_ACCEPT,
495 intf = vrrp_intf_get (sw_if_index);
499 proto = FIB_PROTOCOL_IP6;
500 link_type = VNET_LINK_IP6;
501 vrrp_prefix = &all_vrrp6_routers;
505 proto = FIB_PROTOCOL_IP4;
506 link_type = VNET_LINK_IP4;
507 vrrp_prefix = &all_vrrp4_routers;
510 for_us.frp_proto = fib_proto_to_dpo (proto);
511 via_itf.frp_proto = fib_proto_to_dpo (proto);
512 fib_index = mfib_table_get_index_for_sw_if_index (proto, sw_if_index);
514 vec_foreach_index (i, vrm->vrrp_intfs)
516 if (mfib_table_get_index_for_sw_if_index (proto, i) != fib_index)
519 n_vrs_in_fib += vrrp_intf_num_vrs (i, is_ipv6);
524 /* ensure that the local mcast route exists */
525 mfib_table_entry_path_update (fib_index, vrrp_prefix, MFIB_SOURCE_API,
526 MFIB_ENTRY_FLAG_NONE, &for_us);
528 mfib_table_entry_path_update (fib_index, vrrp_prefix, MFIB_SOURCE_API,
529 MFIB_ENTRY_FLAG_NONE, &via_itf);
530 intf->mcast_adj_index[! !is_ipv6] =
531 adj_mcast_add_or_lock (proto, link_type, sw_if_index);
535 /* Remove mcast local routes if this is the last VR being deleted */
536 if (n_vrs_in_fib == 0)
537 mfib_table_entry_path_remove (fib_index, vrrp_prefix, MFIB_SOURCE_API,
540 mfib_table_entry_path_remove (fib_index, vrrp_prefix, MFIB_SOURCE_API,
548 vrrp_intf_vr_add_del (u8 is_add, u32 sw_if_index, u32 vr_index, u8 is_ipv6)
550 vrrp_intf_t *vr_intf;
552 vr_intf = vrrp_intf_get (sw_if_index);
558 if (!vec_len (vr_intf->vr_indices[is_ipv6]))
559 vrrp_intf_enable_disable_mcast (1, sw_if_index, is_ipv6);
561 vec_add1 (vr_intf->vr_indices[is_ipv6], vr_index);
566 vec_search (vr_intf->vr_indices[is_ipv6], vr_index);
568 if (per_intf_index != ~0)
569 vec_del1 (vr_intf->vr_indices[is_ipv6], per_intf_index);
571 /* no more VRs on this interface, disable multicast */
572 if (!vec_len (vr_intf->vr_indices[is_ipv6]))
573 vrrp_intf_enable_disable_mcast (0, sw_if_index, is_ipv6);
579 /* RFC 5798 section 8.3.2 says to take care not to configure more than
580 * one VRRP router as the "IPvX address owner" of a VRID. Make sure that
581 * all of the addresses configured for this VR are configured on the
585 vrrp_vr_valid_addrs_owner (vrrp_vr_config_t * vr_conf)
587 ip46_address_t *addr;
588 u8 is_ipv6 = (vr_conf->flags & VRRP_VR_IPV6) != 0;
590 vec_foreach (addr, vr_conf->vr_addrs)
592 if (!ip_interface_has_address (vr_conf->sw_if_index, addr, !is_ipv6))
593 return VNET_API_ERROR_ADDRESS_NOT_FOUND_FOR_INTERFACE;
600 vrrp_vr_valid_addrs_unused (vrrp_vr_config_t *vr_conf, index_t vrrp_index)
602 ip46_address_t *vr_addr;
603 u8 is_ipv6 = (vr_conf->flags & VRRP_VR_IPV6) != 0;
605 vec_foreach (vr_addr, vr_conf->vr_addrs)
610 addr = (is_ipv6) ? (void *) &vr_addr->ip6 : (void *) &vr_addr->ip4;
611 vr_index = vrrp_vr_lookup_address (vr_conf->sw_if_index, is_ipv6, addr);
612 if (vr_index != ~0 && vrrp_index != vr_index)
613 return VNET_API_ERROR_ADDRESS_IN_USE;
620 vrrp_vr_valid_addrs (vrrp_vr_config_t *vr_conf, index_t vrrp_index)
624 /* If the VR owns the addresses, make sure they are configured */
625 if (vr_conf->priority == 255 &&
626 (ret = vrrp_vr_valid_addrs_owner (vr_conf)) < 0)
629 /* make sure no other VR has already configured any of the VR addresses */
630 ret = vrrp_vr_valid_addrs_unused (vr_conf, vrrp_index);
636 vrrp_vr_addr_add_del (vrrp_vr_t * vr, u8 is_add, ip46_address_t * vr_addr)
638 vrrp_main_t *vmp = &vrrp_main;
640 vrrp4_arp_key_t key4;
642 ip46_address_t *addr;
645 return VNET_API_ERROR_INVALID_ARGUMENT;
647 vr_index = vr - vmp->vrs;
649 if (vrrp_vr_is_ipv6 (vr))
651 key6.sw_if_index = vr->config.sw_if_index;
652 key6.addr = vr_addr->ip6;
655 hash_set_mem_alloc (&vmp->vrrp6_nd_lookup, &key6, vr_index);
656 vec_add1 (vr->config.vr_addrs, vr_addr[0]);
660 hash_unset_mem_free (&vmp->vrrp6_nd_lookup, &key6);
661 vec_foreach (addr, vr->config.vr_addrs)
663 if (!ip46_address_cmp (addr, vr_addr))
665 vec_del1 (vr->config.vr_addrs, addr - vr->config.vr_addrs);
673 key4.sw_if_index = vr->config.sw_if_index;
674 key4.addr = vr_addr->ip4;
677 hash_set (vmp->vrrp4_arp_lookup, key4.as_u64, vr_index);
678 vec_add1 (vr->config.vr_addrs, vr_addr[0]);
682 hash_unset (vmp->vrrp4_arp_lookup, key4.as_u64);
683 vec_foreach (addr, vr->config.vr_addrs)
685 if (!ip46_address_cmp (addr, vr_addr))
687 vec_del1 (vr->config.vr_addrs, addr - vr->config.vr_addrs);
698 vrrp_vr_addrs_add_del (vrrp_vr_t * vr, u8 is_add, ip46_address_t * vr_addrs)
700 ip46_address_t *vr_addr;
702 vec_foreach (vr_addr, vr_addrs)
704 vrrp_vr_addr_add_del (vr, is_add, vr_addr);
709 vrrp_vr_update (index_t *vrrp_index, vrrp_vr_config_t *vr_conf)
711 index_t index = *vrrp_index;
712 vrrp_main_t *vrm = &vrrp_main;
713 vrrp_vr_t *vr = NULL;
714 vrrp_vr_key_t key = { 0 };
715 uint8_t must_restart = 0;
718 /* no valid index -> create and return allocated index */
719 if (index == INDEX_INVALID)
721 return vrrp_vr_add_del (1, vr_conf, vrrp_index);
723 /* update: lookup vrrp instance */
724 if (pool_is_free_index (vrm->vrs, index))
725 return (VNET_API_ERROR_NO_SUCH_ENTRY);
727 /* fetch existing VR */
728 vr = pool_elt_at_index (vrm->vrs, index);
731 key.vr_id = vr->config.vr_id;
732 key.is_ipv6 = !!(vr->config.flags & VRRP_VR_IPV6);
734 key.sw_if_index = vr->config.sw_if_index;
736 /* Do not allow changes to the keys of the VRRP instance */
737 if (vr_conf->vr_id != key.vr_id || vr_conf->sw_if_index != key.sw_if_index ||
738 !!(vr_conf->flags & VRRP_VR_IPV6) != key.is_ipv6)
740 clib_warning ("Attempt to change VR ID, IP version or interface index "
741 "for VRRP instance with index %u",
743 return VNET_API_ERROR_INVALID_ARGUMENT;
746 /* were IPvX addresses included ? */
747 if (!vec_len (vr_conf->vr_addrs))
749 clib_warning ("Conf of VR %u for IPv%d on sw_if_index %u "
750 " does not contain IP addresses",
751 key.vr_id, key.is_ipv6 ? 6 : 4, key.sw_if_index);
752 return VNET_API_ERROR_INVALID_SRC_ADDRESS;
755 /* Make sure the addresses are ok to use */
756 if ((ret = vrrp_vr_valid_addrs (vr_conf, index)) < 0)
759 /* stop it if needed */
760 must_restart = (vr->runtime.state != VRRP_VR_STATE_INIT);
762 vrrp_vr_start_stop (0, &key);
764 /* overwrite new config */
765 vr->config.priority = vr_conf->priority;
766 vr->config.adv_interval = vr_conf->adv_interval;
767 vr->config.flags = vr_conf->flags;
769 /* check if any address has changed */
770 ip46_address_t *vr_addr, *conf_addr;
772 vec_foreach (vr_addr, vr->config.vr_addrs)
775 vec_foreach (conf_addr, vr_conf->vr_addrs)
777 if (ip46_address_is_equal (vr_addr, conf_addr))
785 vrrp_vr_addr_add_del (vr, 0, vr_addr);
788 vec_foreach (conf_addr, vr_conf->vr_addrs)
791 vec_foreach (vr_addr, vr->config.vr_addrs)
793 if (ip46_address_is_equal (vr_addr, conf_addr))
801 vrrp_vr_addr_add_del (vr, 1, conf_addr);
805 /* restart it if needed */
807 vrrp_vr_start_stop (1, &key);
813 vrrp_vr_del_common (vrrp_vr_t *vr, vrrp_vr_key_t *key)
815 vrrp_main_t *vrm = &vrrp_main;
816 ip46_address_t *vr_addrs_del_copy;
818 vrrp_vr_timer_cancel (vr);
819 vrrp_vr_tracking_ifs_add_del (vr, vr->tracking.interfaces, 0);
820 vr_addrs_del_copy = vec_dup (vr->config.vr_addrs);
821 vrrp_vr_addrs_add_del (vr, 0, vr_addrs_del_copy);
822 mhash_unset (&vrm->vr_index_by_key, key, 0);
823 vec_free (vr_addrs_del_copy);
824 vec_free (vr->config.peer_addrs);
825 vec_free (vr->config.vr_addrs);
826 vec_free (vr->tracking.interfaces);
827 pool_put (vrm->vrs, vr);
831 vrrp_vr_del (index_t vrrp_index)
833 vrrp_main_t *vrm = &vrrp_main;
837 if (pool_is_free_index (vrm->vrs, vrrp_index))
839 return (VNET_API_ERROR_NO_SUCH_ENTRY);
843 vr = pool_elt_at_index (vrm->vrs, vrrp_index);
844 key.sw_if_index = vr->config.sw_if_index;
845 key.vr_id = vr->config.vr_id;
846 key.is_ipv6 = vrrp_vr_is_ipv6 (vr);
847 vrrp_vr_del_common (vr, &key);
852 /* Action function shared between message handler and debug CLI */
854 vrrp_vr_add_del (u8 is_add, vrrp_vr_config_t *vr_conf, index_t *ret_index)
856 vrrp_main_t *vrm = &vrrp_main;
857 vnet_main_t *vnm = vnet_get_main ();
864 if (vr_conf->sw_if_index == ~0 ||
865 !vnet_sw_interface_is_valid (vnm, vr_conf->sw_if_index))
866 return VNET_API_ERROR_INVALID_SW_IF_INDEX;
868 clib_memset (&key, 0, sizeof (key));
870 key.sw_if_index = vr_conf->sw_if_index;
871 key.vr_id = vr_conf->vr_id;
872 key.is_ipv6 = ((vr_conf->flags & VRRP_VR_IPV6) != 0);
874 p = mhash_get (&vrm->vr_index_by_key, &key);
878 /* does a VR matching this key already exist ? */
881 clib_warning ("VR %u for IPv%d already exists on sw_if_index %u",
882 key.vr_id, (key.is_ipv6) ? 6 : 4, key.sw_if_index);
883 return VNET_API_ERROR_ENTRY_ALREADY_EXISTS;
886 /* were IPvX addresses included ? */
887 if (!vec_len (vr_conf->vr_addrs))
889 clib_warning ("Conf of VR %u for IPv%d on sw_if_index %u "
890 " does not contain IP addresses",
891 key.vr_id, (key.is_ipv6) ? 6 : 4, key.sw_if_index);
892 return VNET_API_ERROR_INVALID_SRC_ADDRESS;
895 /* Make sure the addresses are ok to use */
896 if ((ret = vrrp_vr_valid_addrs (vr_conf, INDEX_INVALID)) < 0)
899 pool_get_zero (vrm->vrs, vr);
900 vr_index = vr - vrm->vrs;
902 clib_memcpy (&vr->config, vr_conf, sizeof (vrrp_vr_config_t));
904 vr->config.vr_addrs = 0; /* allocate our own memory */
905 vrrp_vr_addrs_add_del (vr, is_add, vr_conf->vr_addrs);
907 vr->runtime.state = VRRP_VR_STATE_INIT;
908 vr->runtime.timer_index = ~0;
910 /* set virtual MAC based on IP version and VR ID */
911 vr->runtime.mac = (key.is_ipv6) ? ipv6_vmac : ipv4_vmac;
912 vr->runtime.mac.bytes[5] = vr_conf->vr_id;
914 /* recall pool index for stats */
915 vr->stat_index = vr_index;
916 /* and return it if we were asked to */
917 if (ret_index != NULL)
919 *ret_index = vr_index;
921 /* allocate & reset stats */
922 for (int i = 0; i < VRRP_STAT_COUNTER_MAX; i++)
924 vlib_validate_simple_counter (&vrrp_stats[i], vr_index);
925 vlib_zero_simple_counter (&vrrp_stats[i], vr_index);
928 mhash_set (&vrm->vr_index_by_key, &key, vr_index, 0);
934 clib_warning ("No VR %u for IPv%d exists on sw_if_index %u",
935 key.vr_id, (key.is_ipv6) ? 6 : 4, key.sw_if_index);
936 return VNET_API_ERROR_NO_SUCH_ENTRY;
940 vr = pool_elt_at_index (vrm->vrs, vr_index);
941 vrrp_vr_del_common (vr, &key);
944 vrrp_intf_vr_add_del (is_add, vr_conf->sw_if_index, vr_index, key.is_ipv6);
950 vrrp_vr_start_stop (u8 is_start, vrrp_vr_key_t * vr_key)
952 vrrp_main_t *vmp = &vrrp_main;
956 p = mhash_get (&vmp->vr_index_by_key, vr_key);
958 return VNET_API_ERROR_NO_SUCH_ENTRY;
960 vr = pool_elt_at_index (vmp->vrs, p[0]);
962 /* return success if already in the desired state */
963 switch (vr->runtime.state)
965 case VRRP_VR_STATE_INIT:
968 clib_warning ("Attempting to stop already stopped VR (%U)",
969 format_vrrp_vr_key, vr);
976 clib_warning ("Attempting to start already started VR (%U)",
977 format_vrrp_vr_key, vr);
985 if (vrrp_vr_is_unicast (vr) && vec_len (vr->config.peer_addrs) == 0)
987 clib_warning ("Cannot start unicast VR without peers");
988 return VNET_API_ERROR_INIT_FAILED;
991 vmp->n_vrs_started++;
993 if (!vrrp_intf_is_up (vr->config.sw_if_index, vrrp_vr_is_ipv6 (vr),
996 clib_warning ("VRRP VR started on down interface (%U)",
997 format_vrrp_vr_key, vr);
998 vrrp_vr_transition (vr, VRRP_VR_STATE_INTF_DOWN, NULL);
1000 else if (vrrp_vr_is_owner (vr))
1001 vrrp_vr_transition (vr, VRRP_VR_STATE_MASTER, NULL);
1003 vrrp_vr_transition (vr, VRRP_VR_STATE_BACKUP, NULL);
1007 vmp->n_vrs_started--;
1009 vrrp_vr_transition (vr, VRRP_VR_STATE_INIT, NULL);
1012 clib_warning ("%d VRs configured, %d VRs running",
1013 pool_elts (vmp->vrs), vmp->n_vrs_started);
1019 vrrp_vr_set_peers_validate (vrrp_vr_t * vr, ip46_address_t * peers)
1021 if (!vrrp_vr_is_unicast (vr))
1023 clib_warning ("Peers can only be set on a unicast VR");
1024 return VNET_API_ERROR_INVALID_ARGUMENT;
1027 if (vr->runtime.state != VRRP_VR_STATE_INIT)
1029 clib_warning ("Cannot set peers on a running VR");
1030 return VNET_API_ERROR_RSRC_IN_USE;
1033 if (vec_len (peers) == 0)
1035 clib_warning ("No peer addresses provided");
1036 return VNET_API_ERROR_INVALID_DST_ADDRESS;
1043 vrrp_vr_set_peers (vrrp_vr_key_t * vr_key, ip46_address_t * peers)
1045 vrrp_main_t *vmp = &vrrp_main;
1050 p = mhash_get (&vmp->vr_index_by_key, vr_key);
1052 return VNET_API_ERROR_NO_SUCH_ENTRY;
1054 vr = pool_elt_at_index (vmp->vrs, p[0]);
1056 ret = vrrp_vr_set_peers_validate (vr, peers);
1060 if (vr->config.peer_addrs)
1061 vec_free (vr->config.peer_addrs);
1063 vr->config.peer_addrs = vec_dup (peers);
1068 /* Manage reference on the interface to the VRs which track that interface */
1070 vrrp_intf_tracking_vr_add_del (u32 sw_if_index, vrrp_vr_t * vr, u8 is_add)
1074 u8 is_ipv6 = vrrp_vr_is_ipv6 (vr);
1077 intf = vrrp_intf_get (sw_if_index);
1078 vr_index = vrrp_vr_index (vr);
1080 /* Try to find the VR index in the list of tracking VRs */
1081 vec_foreach_index (i, intf->tracking_vrs[is_ipv6])
1083 if (vec_elt (intf->tracking_vrs[is_ipv6], i) != vr_index)
1086 /* Current index matches VR index */
1088 vec_delete (intf->tracking_vrs[is_ipv6], 1, i);
1090 /* If deleting, the job is done. If adding, it's already here */
1094 /* vr index was not found. */
1096 vec_add1 (intf->tracking_vrs[is_ipv6], vr_index);
1099 /* Check if sw intf admin state is up or in the process of coming up */
1101 vrrp_intf_sw_admin_up (u32 sw_if_index, vrrp_intf_update_t * pending)
1103 vnet_main_t *vnm = vnet_get_main ();
1106 if (pending && (pending->type == VRRP_IF_UPDATE_SW_ADMIN))
1107 admin_up = pending->intf_up;
1109 admin_up = vnet_sw_interface_is_admin_up (vnm, sw_if_index);
1114 /* Check if hw intf link state is up or int the process of coming up */
1116 vrrp_intf_hw_link_up (u32 sw_if_index, vrrp_intf_update_t * pending)
1118 vnet_main_t *vnm = vnet_get_main ();
1119 vnet_sw_interface_t *sup_sw;
1122 sup_sw = vnet_get_sup_sw_interface (vnm, sw_if_index);
1124 if (pending && (pending->type == VRRP_IF_UPDATE_HW_LINK) &&
1125 (pending->hw_if_index == sup_sw->hw_if_index))
1126 link_up = pending->intf_up;
1128 link_up = vnet_hw_interface_is_link_up (vnm, sup_sw->hw_if_index);
1133 /* Check if interface has ability to send IP packets. */
1135 vrrp_intf_ip_up (u32 sw_if_index, u8 is_ipv6, vrrp_intf_update_t * pending)
1139 if (pending && pending->type == VRRP_IF_UPDATE_IP)
1140 ip_up = pending->intf_up;
1142 /* Either a unicast address has to be explicitly assigned, or
1143 * for IPv6 only, a link local assigned and multicast/ND enabled
1146 ((ip_interface_get_first_ip (sw_if_index, !is_ipv6) != 0) ||
1147 (is_ipv6 && ip6_link_is_enabled (sw_if_index)));
1153 vrrp_intf_is_up (u32 sw_if_index, u8 is_ipv6, vrrp_intf_update_t * pending)
1155 int admin_up, link_up, ip_up;
1157 admin_up = vrrp_intf_sw_admin_up (sw_if_index, pending);
1158 link_up = vrrp_intf_hw_link_up (sw_if_index, pending);
1159 ip_up = vrrp_intf_ip_up (sw_if_index, is_ipv6, pending);
1161 return (admin_up && link_up && ip_up);
1164 /* Examine the state of interfaces tracked by a VR and compute the priority
1165 * adjustment that should be applied to the VR. If this is being called
1166 * by the hw_link_up_down callback, the pending new flags on the sup hw
1167 * interface have not been updated yet, so accept those as an optional
1171 vrrp_vr_tracking_ifs_compute (vrrp_vr_t * vr, vrrp_intf_update_t * pending)
1173 vrrp_vr_tracking_if_t *intf;
1174 u32 total_priority = 0;
1176 vec_foreach (intf, vr->tracking.interfaces)
1178 if (vrrp_intf_is_up (intf->sw_if_index, vrrp_vr_is_ipv6 (vr), pending))
1181 total_priority += intf->priority;
1184 if (total_priority != vr->tracking.interfaces_dec)
1186 clib_warning ("VR %U interface track adjustment change from %u to %u",
1187 format_vrrp_vr_key, vr, vr->tracking.interfaces_dec,
1189 vr->tracking.interfaces_dec = total_priority;
1193 /* Manage tracked interfaces on a VR */
1195 vrrp_vr_tracking_if_add_del (vrrp_vr_t * vr, u32 sw_if_index, u8 prio,
1198 vnet_main_t *vnm = vnet_get_main ();
1199 vrrp_vr_tracking_if_t *track_intf;
1201 /* VR can't track non-existent interface */
1202 if (!vnet_sw_interface_is_valid (vnm, sw_if_index))
1203 return VNET_API_ERROR_INVALID_SW_IF_INDEX;
1205 /* VR can't track it's own interface */
1206 if (sw_if_index == vr->config.sw_if_index)
1207 return VNET_API_ERROR_INVALID_SW_IF_INDEX_2;
1209 /* update intf vector of tracking VRs */
1210 vrrp_intf_tracking_vr_add_del (sw_if_index, vr, is_add);
1212 /* update VR vector of tracked interfaces */
1213 vec_foreach (track_intf, vr->tracking.interfaces)
1215 if (track_intf->sw_if_index != sw_if_index)
1221 (vr->tracking.interfaces, 1, track_intf - vr->tracking.interfaces);
1228 vec_add2 (vr->tracking.interfaces, track_intf, 1);
1230 track_intf->sw_if_index = sw_if_index;
1231 track_intf->priority = prio;
1238 vrrp_vr_tracking_ifs_add_del (vrrp_vr_t * vr,
1239 vrrp_vr_tracking_if_t * track_ifs, u8 is_add)
1241 vrrp_vr_tracking_if_t *track_if, *ifs_copy;
1244 /* if deleting & track_ifs points to the VR list of tracked intfs, the
1245 * vector could be modified as we iterate it. make a copy instead */
1246 ifs_copy = vec_dup (track_ifs);
1248 /* add each tracked interface in the vector */
1249 vec_foreach (track_if, ifs_copy)
1251 rv = vrrp_vr_tracking_if_add_del (vr, track_if->sw_if_index,
1252 track_if->priority, (is_add != 0));
1254 /* if operation failed, undo the previous changes */
1257 vrrp_vr_tracking_if_t *rb_if;
1259 for (rb_if = track_if - 1; rb_if >= track_ifs; rb_if -= 1)
1260 vrrp_vr_tracking_if_add_del (vr, rb_if->sw_if_index,
1261 rb_if->priority, !(is_add != 0));
1266 vec_free (ifs_copy);
1268 vrrp_vr_tracking_ifs_compute (vr, 0);
1273 /* Compute priority to advertise on all VRs which track the given interface
1274 * and address family. The flags on an HW interface are not updated until
1275 * after link up/down callbacks are invoked, so if this function is called
1276 * by the link up/down callback, the flags about to be set will be passed
1277 * via the 'pending' argument. Otherwise, pending will be NULL.
1280 vrrp_intf_tracking_vrs_compute (u32 sw_if_index,
1281 vrrp_intf_update_t * pending, u8 is_ipv6)
1285 vrrp_intf_t *intf = vrrp_intf_get (sw_if_index);
1287 vec_foreach (vr_index, intf->tracking_vrs[is_ipv6])
1289 vr = vrrp_vr_lookup_index (*vr_index);
1291 vrrp_vr_tracking_ifs_compute (vr, pending);
1295 /* Interface being brought up/down is a quasi-{startup/shutdown} event.
1296 * Execute an appropriate state transition for all VRs on the interface.
1297 * This function may be invoked by:
1298 * sw interface admin up/down event
1299 * hw interface link up/down event
1302 vrrp_sw_interface_up_down (vrrp_intf_update_t * pending)
1309 intf = vrrp_intf_get (pending->sw_if_index);
1313 /* adjust state of VR's configured on this interface */
1314 for (i = 0; i < 2; i++)
1318 if (!intf->vr_indices[i])
1321 is_up = vrrp_intf_is_up (pending->sw_if_index, i, pending);
1323 vec_foreach (vr_index, intf->vr_indices[i])
1325 vrrp_vr_state_t vr_state;
1327 vr = vrrp_vr_lookup_index (*vr_index);
1331 if (vr->runtime.state == VRRP_VR_STATE_INIT)
1332 continue; /* VR not started yet, no transition */
1335 vr_state = VRRP_VR_STATE_INTF_DOWN;
1338 if (vr->runtime.state != VRRP_VR_STATE_INTF_DOWN)
1339 continue; /* shouldn't happen */
1341 vr_state = (vrrp_vr_is_owner (vr)) ?
1342 VRRP_VR_STATE_MASTER : VRRP_VR_STATE_BACKUP;
1345 vrrp_vr_transition (vr, vr_state, NULL);
1349 /* compute adjustments on any VR's tracking this interface */
1350 vrrp_intf_tracking_vrs_compute (pending->sw_if_index, pending,
1352 vrrp_intf_tracking_vrs_compute (pending->sw_if_index, pending,
1358 /* Process change in admin status on an interface */
1360 vrrp_sw_interface_admin_up_down (vnet_main_t * vnm, u32 sw_if_index,
1363 vrrp_intf_update_t pending = {
1364 .type = VRRP_IF_UPDATE_SW_ADMIN,
1365 .sw_if_index = sw_if_index,
1366 .intf_up = ((flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) != 0),
1369 return vrrp_sw_interface_up_down (&pending);
1372 VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION (vrrp_sw_interface_admin_up_down);
1375 vrrp_hw_interface_link_up_down_walk (vnet_main_t * vnm,
1376 u32 sw_if_index, void *arg)
1378 vrrp_intf_update_t *pending = arg;
1380 pending->sw_if_index = sw_if_index;
1381 vrrp_sw_interface_up_down (pending);
1383 return WALK_CONTINUE;
1386 static clib_error_t *
1387 vrrp_hw_interface_link_up_down (vnet_main_t * vnm, u32 hw_if_index, u32 flags)
1389 vrrp_intf_update_t pending = {
1390 .type = VRRP_IF_UPDATE_HW_LINK,
1391 .hw_if_index = hw_if_index,
1392 .intf_up = ((flags & VNET_HW_INTERFACE_FLAG_LINK_UP) != 0),
1395 /* walk the sw interface and sub interfaces to adjust interface tracking */
1396 vnet_hw_interface_walk_sw (vnm, hw_if_index,
1397 vrrp_hw_interface_link_up_down_walk, &pending);
1402 VNET_HW_INTERFACE_LINK_UP_DOWN_FUNCTION (vrrp_hw_interface_link_up_down);
1405 vrrp_ip4_add_del_interface_addr (ip4_main_t * im,
1408 ip4_address_t * address,
1410 u32 if_address_index, u32 is_del)
1412 vrrp_intf_tracking_vrs_compute (sw_if_index, NULL, 0 /* is_ipv6 */ );
1415 static ip6_link_delegate_id_t vrrp_ip6_delegate_id;
1418 format_vrrp_ip6_link (u8 * s, va_list * args)
1420 index_t indi = va_arg (*args, index_t);
1421 u32 indent = va_arg (*args, u32);
1425 intf = vrrp_intf_get ((u32) indi);
1427 s = format (s, "%UVRRP VRs monitoring this link:\n",
1428 format_white_space, indent);
1430 vec_foreach (vr_index, intf->tracking_vrs[1])
1432 vrrp_vr_t *vr = vrrp_vr_lookup_index (*vr_index);
1434 s = format (s, "%U%U\n", format_white_space, indent + 2,
1435 format_vrrp_vr_key, vr);
1442 vrrp_intf_ip6_enable_disable (u32 sw_if_index, int enable)
1444 vrrp_intf_update_t pending = {
1445 .type = VRRP_IF_UPDATE_IP,
1446 .sw_if_index = sw_if_index,
1450 vrrp_intf_tracking_vrs_compute (sw_if_index, &pending, 1 /* is_ipv6 */ );
1454 vrrp_intf_ip6_enable (u32 sw_if_index)
1456 vrrp_intf_ip6_enable_disable (sw_if_index, 1 /* enable */ );
1457 ip6_link_delegate_update (sw_if_index, vrrp_ip6_delegate_id, sw_if_index);
1461 vrrp_intf_ip6_disable (index_t indi)
1463 vrrp_intf_ip6_enable_disable (indi, 0 /* enable */ );
1466 const static ip6_link_delegate_vft_t vrrp_ip6_delegate_vft = {
1467 .ildv_enable = vrrp_intf_ip6_enable,
1468 .ildv_disable = vrrp_intf_ip6_disable,
1469 .ildv_format = format_vrrp_ip6_link,
1472 static clib_error_t *
1473 vrrp_init (vlib_main_t * vm)
1475 vrrp_main_t *vmp = &vrrp_main;
1476 clib_error_t *error = 0;
1477 ip4_main_t *im4 = &ip4_main;
1478 ip4_add_del_interface_address_callback_t cb4;
1479 vlib_node_t *intf_output_node;
1481 clib_memset (vmp, 0, sizeof (*vmp));
1483 if ((error = vlib_call_init_function (vm, ip4_lookup_init)) ||
1484 (error = vlib_call_init_function (vm, ip6_lookup_init)))
1487 vmp->vlib_main = vm;
1488 vmp->vnet_main = vnet_get_main ();
1490 intf_output_node = vlib_get_node_by_name (vm, (u8 *) "interface-output");
1491 vmp->intf_output_node_idx = intf_output_node->index;
1493 error = vrrp_plugin_api_hookup (vm);
1498 mhash_init (&vmp->vr_index_by_key, sizeof (u32), sizeof (vrrp_vr_key_t));
1499 vmp->vrrp4_arp_lookup = hash_create (0, sizeof (uword));
1500 vmp->vrrp6_nd_lookup = hash_create_mem (0, sizeof (vrrp6_nd_key_t),
1503 cb4.function = vrrp_ip4_add_del_interface_addr;
1504 cb4.function_opaque = 0;
1505 vec_add1 (im4->add_del_interface_address_callbacks, cb4);
1507 vrrp_ip6_delegate_id = ip6_link_delegate_register (&vrrp_ip6_delegate_vft);
1509 /* allocate & reset error counters */
1510 for (int i = 0; i < VRRP_ERR_COUNTER_MAX; i++)
1512 vlib_validate_simple_counter (&vrrp_errs[i], 0);
1513 vlib_zero_simple_counter (&vrrp_errs[i], 0);
1519 VLIB_INIT_FUNCTION (vrrp_init);
1523 VLIB_PLUGIN_REGISTER () =
1525 .version = VPP_BUILD_VER,
1526 .description = "VRRP v3 (RFC 5798)",
1531 * fd.io coding-style-patch-verification: ON
1534 * eval: (c-set-style "gnu")