bonding: support custom interface IDs

[vpp.git] / src / vnet / bfd / bfd_udp.c

diff --git a/src/vnet/bfd/bfd_udp.c b/src/vnet/bfd/bfd_udp.c
index e05f10f..d35c6de 100644 (file)
--- a/src/vnet/bfd/bfd_udp.c
+++ b/src/vnet/bfd/bfd_udp.c
@@ -261,7 +261,7 @@ bfd_add_udp4_transport (vlib_main_t * vm, u32 bi, const bfd_session_t * bs,
   ip4_udp_headers *headers = NULL;
   vlib_buffer_advance (b, -sizeof (*headers));
   headers = vlib_buffer_get_current (b);
-  memset (headers, 0, sizeof (*headers));
+  clib_memset (headers, 0, sizeof (*headers));
   headers->ip4.ip_version_and_header_length = 0x45;
   headers->ip4.ttl = 255;
   headers->ip4.protocol = IP_PROTOCOL_UDP;
@@ -316,7 +316,7 @@ bfd_add_udp6_transport (vlib_main_t * vm, u32 bi, const bfd_session_t * bs,
   ip6_udp_headers *headers = NULL;
   vlib_buffer_advance (b, -sizeof (*headers));
   headers = vlib_buffer_get_current (b);
-  memset (headers, 0, sizeof (*headers));
+  clib_memset (headers, 0, sizeof (*headers));
   headers->ip6.ip_version_traffic_class_and_flow_label =
     clib_host_to_net_u32 (0x6 << 28);
   headers->ip6.hop_limit = 255;
@@ -330,17 +330,17 @@ bfd_add_udp6_transport (vlib_main_t * vm, u32 bi, const bfd_session_t * bs,
        {
          return rv;
        }
-      clib_memcpy (&headers->ip6.dst_address, &key->local_addr.ip6,
-                  sizeof (headers->ip6.dst_address));
+      clib_memcpy_fast (&headers->ip6.dst_address, &key->local_addr.ip6,
+                       sizeof (headers->ip6.dst_address));
 
       headers->udp.dst_port = clib_host_to_net_u16 (UDP_DST_PORT_bfd_echo6);
     }
   else
     {
-      clib_memcpy (&headers->ip6.src_address, &key->local_addr.ip6,
-                  sizeof (headers->ip6.src_address));
-      clib_memcpy (&headers->ip6.dst_address, &key->peer_addr.ip6,
-                  sizeof (headers->ip6.dst_address));
+      clib_memcpy_fast (&headers->ip6.src_address, &key->local_addr.ip6,
+                       sizeof (headers->ip6.src_address));
+      clib_memcpy_fast (&headers->ip6.dst_address, &key->peer_addr.ip6,
+                       sizeof (headers->ip6.dst_address));
       headers->udp.dst_port = clib_host_to_net_u16 (UDP_DST_PORT_bfd6);
     }
 
@@ -448,7 +448,7 @@ bfd_udp_key_init (bfd_udp_key_t * key, u32 sw_if_index,
                  const ip46_address_t * local_addr,
                  const ip46_address_t * peer_addr)
 {
-  memset (key, 0, sizeof (*key));
+  clib_memset (key, 0, sizeof (*key));
   key->sw_if_index = sw_if_index;
   key->local_addr.as_u64[0] = local_addr->as_u64[0];
   key->local_addr.as_u64[1] = local_addr->as_u64[1];
@@ -476,7 +476,7 @@ bfd_udp_add_session_internal (bfd_udp_main_t * bum, u32 sw_if_index,
       return VNET_API_ERROR_BFD_EAGAIN;
     }
   bfd_udp_session_t *bus = &bs->udp;
-  memset (bus, 0, sizeof (*bus));
+  clib_memset (bus, 0, sizeof (*bus));
   bfd_udp_key_t *key = &bus->key;
   bfd_udp_key_init (key, sw_if_index, local_addr, peer_addr);
   const bfd_session_t *tmp = bfd_lookup_session (bum, key);
@@ -670,6 +670,9 @@ bfd_udp_add_session (u32 sw_if_index, const ip46_address_t * local_addr,
                     u8 detect_mult, u8 is_authenticated, u32 conf_key_id,
                     u8 bfd_key_id)
 {
+  bfd_main_t *bm = &bfd_main;
+  bfd_lock (bm);
+
   vnet_api_error_t rv =
     bfd_api_verify_common (sw_if_index, desired_min_tx_usec,
                           required_min_rx_usec, detect_mult,
@@ -703,6 +706,7 @@ bfd_udp_add_session (u32 sw_if_index, const ip46_address_t * local_addr,
       bfd_session_start (bfd_udp_main.bfd_main, bs);
     }
 
+  bfd_unlock (bm);
   return rv;
 }
 
@@ -714,17 +718,23 @@ bfd_udp_mod_session (u32 sw_if_index,
                     u32 required_min_rx_usec, u8 detect_mult)
 {
   bfd_session_t *bs = NULL;
+  bfd_main_t *bm = &bfd_main;
+  vnet_api_error_t error;
+  bfd_lock (bm);
   vnet_api_error_t rv =
     bfd_udp_find_session_by_api_input (sw_if_index, local_addr, peer_addr,
                                       &bs);
   if (rv)
     {
+      bfd_unlock (bm);
       return rv;
     }
 
-  return bfd_session_set_params (bfd_udp_main.bfd_main, bs,
-                                desired_min_tx_usec, required_min_rx_usec,
-                                detect_mult);
+  error = bfd_session_set_params (bfd_udp_main.bfd_main, bs,
+                                 desired_min_tx_usec, required_min_rx_usec,
+                                 detect_mult);
+  bfd_unlock (bm);
+  return error;
 }
 
 vnet_api_error_t
@@ -733,14 +743,18 @@ bfd_udp_del_session (u32 sw_if_index,
                     const ip46_address_t * peer_addr)
 {
   bfd_session_t *bs = NULL;
+  bfd_main_t *bm = &bfd_main;
+  bfd_lock (bm);
   vnet_api_error_t rv =
     bfd_udp_find_session_by_api_input (sw_if_index, local_addr, peer_addr,
                                       &bs);
   if (rv)
     {
+      bfd_unlock (bm);
       return rv;
     }
   bfd_udp_del_session_internal (bs);
+  bfd_unlock (bm);
   return 0;
 }
 
@@ -750,14 +764,18 @@ bfd_udp_session_set_flags (u32 sw_if_index,
                           const ip46_address_t * peer_addr, u8 admin_up_down)
 {
   bfd_session_t *bs = NULL;
+  bfd_main_t *bm = &bfd_main;
+  bfd_lock (bm);
   vnet_api_error_t rv =
     bfd_udp_find_session_by_api_input (sw_if_index, local_addr, peer_addr,
                                       &bs);
   if (rv)
     {
+      bfd_unlock (bm);
       return rv;
     }
   bfd_session_set_flags (bs, admin_up_down);
+  bfd_unlock (bm);
   return 0;
 }
 
@@ -767,6 +785,10 @@ bfd_udp_auth_activate (u32 sw_if_index,
                       const ip46_address_t * peer_addr,
                       u32 conf_key_id, u8 key_id, u8 is_delayed)
 {
+  bfd_main_t *bm = &bfd_main;
+  bfd_lock (bm);
+  vnet_api_error_t error;
+
 #if WITH_LIBSSL > 0
   bfd_session_t *bs = NULL;
   vnet_api_error_t rv =
@@ -774,12 +796,16 @@ bfd_udp_auth_activate (u32 sw_if_index,
                                       &bs);
   if (rv)
     {
+      bfd_unlock (bm);
       return rv;
     }
-  return bfd_auth_activate (bs, conf_key_id, key_id, is_delayed);
+  error = bfd_auth_activate (bs, conf_key_id, key_id, is_delayed);
+  bfd_unlock (bm);
+  return error;
 #else
   vlib_log_err (bfd_udp_main->log_class,
                "SSL missing, cannot activate BFD authentication");
+  bfd_unlock (bm);
   return VNET_API_ERROR_BFD_NOTSUPP;
 #endif
 }
@@ -789,15 +815,21 @@ bfd_udp_auth_deactivate (u32 sw_if_index,
                         const ip46_address_t * local_addr,
                         const ip46_address_t * peer_addr, u8 is_delayed)
 {
+  bfd_main_t *bm = &bfd_main;
+  vnet_api_error_t error;
+  bfd_lock (bm);
   bfd_session_t *bs = NULL;
   vnet_api_error_t rv =
     bfd_udp_find_session_by_api_input (sw_if_index, local_addr, peer_addr,
                                       &bs);
   if (rv)
     {
+      bfd_unlock (bm);
       return rv;
     }
-  return bfd_auth_deactivate (bs, is_delayed);
+  error = bfd_auth_deactivate (bs, is_delayed);
+  bfd_unlock (bm);
+  return error;
 }
 
 typedef enum
@@ -919,23 +951,13 @@ typedef struct
   bfd_pkt_t pkt;
 } bfd_rpc_update_t;
 
-static void
-bfd_rpc_update_session_cb (const bfd_rpc_update_t * a)
-{
-  bfd_consume_pkt (bfd_udp_main.bfd_main, &a->pkt, a->bs_idx);
-}
-
 static void
 bfd_rpc_update_session (u32 bs_idx, const bfd_pkt_t * pkt)
 {
-  /* packet length was already verified to be correct by the caller */
-  const u32 data_size = sizeof (bfd_rpc_update_t) -
-    STRUCT_SIZE_OF (bfd_rpc_update_t, pkt) + pkt->head.length;
-  u8 data[data_size];
-  bfd_rpc_update_t *update = (bfd_rpc_update_t *) data;
-  update->bs_idx = bs_idx;
-  clib_memcpy (&update->pkt, pkt, pkt->head.length);
-  vl_api_rpc_call_main_thread (bfd_rpc_update_session_cb, data, data_size);
+  bfd_main_t *bm = &bfd_main;
+  bfd_lock (bm);
+  bfd_consume_pkt (bm, pkt, bs_idx);
+  bfd_unlock (bm);
 }
 
 static bfd_udp_error_t
@@ -980,7 +1002,7 @@ bfd_udp4_scan (vlib_main_t * vm, vlib_node_runtime_t * rt,
   else
     {
       bfd_udp_key_t key;
-      memset (&key, 0, sizeof (key));
+      clib_memset (&key, 0, sizeof (key));
       key.sw_if_index = vnet_buffer (b)->sw_if_index[VLIB_RX];
       key.local_addr.ip4.as_u32 = ip4->dst_address.as_u32;
       key.peer_addr.ip4.as_u32 = ip4->src_address.as_u32;
@@ -1122,7 +1144,7 @@ bfd_udp6_scan (vlib_main_t * vm, vlib_node_runtime_t * rt,
   else
     {
       bfd_udp_key_t key;
-      memset (&key, 0, sizeof (key));
+      clib_memset (&key, 0, sizeof (key));
       key.sw_if_index = vnet_buffer (b)->sw_if_index[VLIB_RX];
       key.local_addr.ip6.as_u64[0] = ip6->dst_address.as_u64[0];
       key.local_addr.ip6.as_u64[1] = ip6->dst_address.as_u64[1];
@@ -1165,6 +1187,7 @@ bfd_udp_input (vlib_main_t * vm, vlib_node_runtime_t * rt,
 {
   u32 n_left_from, *from;
   bfd_input_trace_t *t0;
+  bfd_main_t *bm = &bfd_main;
 
   from = vlib_frame_vector_args (f);   /* array of buffer indices */
   n_left_from = f->n_vectors;  /* number of buffer indices */
@@ -1188,10 +1211,11 @@ bfd_udp_input (vlib_main_t * vm, vlib_node_runtime_t * rt,
          len = (b0->current_length < sizeof (t0->data)) ? b0->current_length
            : sizeof (t0->data);
          t0->len = len;
-         clib_memcpy (t0->data, vlib_buffer_get_current (b0), len);
+         clib_memcpy_fast (t0->data, vlib_buffer_get_current (b0), len);
        }
 
       /* scan this bfd pkt. error0 is the counter index to bmp */
+      bfd_lock (bm);
       if (is_ipv6)
        {
          error0 = bfd_udp6_scan (vm, rt, b0, &bs);
@@ -1215,7 +1239,7 @@ bfd_udp_input (vlib_main_t * vm, vlib_node_runtime_t * rt,
            {
              b0->current_data = 0;
              b0->current_length = 0;
-             memset (vnet_buffer (b0), 0, sizeof (*vnet_buffer (b0)));
+             clib_memset (vnet_buffer (b0), 0, sizeof (*vnet_buffer (b0)));
              bfd_init_final_control_frame (vm, b0, bfd_udp_main.bfd_main, bs,
                                            0);
              if (is_ipv6)
@@ -1244,6 +1268,7 @@ bfd_udp_input (vlib_main_t * vm, vlib_node_runtime_t * rt,
                }
            }
        }
+      bfd_unlock (bm);
       vlib_set_next_frame_buffer (vm, rt, next0, bi0);
 
       from += 1;
@@ -1322,6 +1347,7 @@ bfd_udp_echo_input (vlib_main_t * vm, vlib_node_runtime_t * rt,
 {
   u32 n_left_from, *from;
   bfd_input_trace_t *t0;
+  bfd_main_t *bm = &bfd_main;
 
   from = vlib_frame_vector_args (f);   /* array of buffer indices */
   n_left_from = f->n_vectors;  /* number of buffer indices */
@@ -1343,9 +1369,10 @@ bfd_udp_echo_input (vlib_main_t * vm, vlib_node_runtime_t * rt,
          len = (b0->current_length < sizeof (t0->data)) ? b0->current_length
            : sizeof (t0->data);
          t0->len = len;
-         clib_memcpy (t0->data, vlib_buffer_get_current (b0), len);
+         clib_memcpy_fast (t0->data, vlib_buffer_get_current (b0), len);
        }
 
+      bfd_lock (bm);
       if (bfd_consume_echo_pkt (bfd_udp_main.bfd_main, b0))
        {
          b0->error = rt->errors[BFD_UDP_ERROR_NONE];
@@ -1368,6 +1395,7 @@ bfd_udp_echo_input (vlib_main_t * vm, vlib_node_runtime_t * rt,
          next0 = BFD_UDP_INPUT_NEXT_REPLY_REWRITE;
        }
 
+      bfd_unlock (bm);
       vlib_set_next_frame_buffer (vm, rt, next0, bi0);
 
       from += 1;