sr: add "set sr encaps hop-limit" command

[vpp.git] / src / vnet / srv6 / sr_policy_rewrite.c

diff --git a/src/vnet/srv6/sr_policy_rewrite.c b/src/vnet/srv6/sr_policy_rewrite.c
index 62ce224..8d11da6 100755 (executable)
--- a/src/vnet/srv6/sr_policy_rewrite.c
+++ b/src/vnet/srv6/sr_policy_rewrite.c
@@ -107,6 +107,7 @@ static dpo_type_t sr_pr_bsid_insert_dpo_type;
  * @brief IPv6 SA for encapsulated packets
  */
 static ip6_address_t sr_pr_encaps_src;
+static u8 sr_pr_encaps_hop_limit = IPv6_DEFAULT_HOP_LIMIT;
 
 /******************* SR rewrite set encaps IPv6 source addr *******************/
 /* Note:  This is temporal. We don't know whether to follow this path or
@@ -115,7 +116,7 @@ static ip6_address_t sr_pr_encaps_src;
 void
 sr_set_source (ip6_address_t * address)
 {
-  clib_memcpy (&sr_pr_encaps_src, address, sizeof (sr_pr_encaps_src));
+  clib_memcpy_fast (&sr_pr_encaps_src, address, sizeof (sr_pr_encaps_src));
 }
 
 static clib_error_t *
@@ -141,6 +142,44 @@ VLIB_CLI_COMMAND (set_sr_src_command, static) = {
 };
 /* *INDENT-ON* */
 
+/******************** SR rewrite set encaps IPv6 hop-limit ********************/
+
+void
+sr_set_hop_limit (u8 hop_limit)
+{
+  sr_pr_encaps_hop_limit = hop_limit;
+}
+
+u8
+sr_get_hop_limit (void)
+{
+  return sr_pr_encaps_hop_limit;
+}
+
+static clib_error_t *
+set_sr_hop_limit_command_fn (vlib_main_t * vm, unformat_input_t * input,
+                            vlib_cli_command_t * cmd)
+{
+  int hop_limit = sr_get_hop_limit ();
+
+  if (unformat_check_input (input) == UNFORMAT_END_OF_INPUT)
+    return clib_error_return (0, "No value specified");
+  if (!unformat (input, "%d", &hop_limit))
+    return clib_error_return (0, "Invalid value");
+  if (hop_limit <= 0 || hop_limit > 255)
+    return clib_error_return (0, "Value out of range [1-255]");
+  sr_pr_encaps_hop_limit = (u8) hop_limit;
+  return 0;
+}
+
+/* *INDENT-OFF* */
+VLIB_CLI_COMMAND (set_sr_hop_limit_command, static) = {
+  .path = "set sr encaps hop-limit",
+  .short_help = "set sr encaps hop-limit <value>",
+  .function = set_sr_hop_limit_command_fn,
+};
+/* *INDENT-ON* */
+
 /*********************** SR rewrite string computation ************************/
 /**
  * @brief SR rewrite string computation for IPv6 encapsulation (inline)
@@ -175,7 +214,7 @@ compute_rewrite_encaps (ip6_address_t * sl)
   iph->src_address.as_u64[1] = sr_pr_encaps_src.as_u64[1];
   iph->payload_length = header_length - IPv6_DEFAULT_HEADER_LENGTH;
   iph->protocol = IP_PROTOCOL_IPV6;
-  iph->hop_limit = IPv6_DEFAULT_HOP_LIMIT;
+  iph->hop_limit = sr_pr_encaps_hop_limit;
 
   if (vec_len (sl) > 1)
     {
@@ -184,16 +223,16 @@ compute_rewrite_encaps (ip6_address_t * sl)
       srh->protocol = IP_PROTOCOL_IPV6;
       srh->type = ROUTING_HEADER_TYPE_SR;
       srh->segments_left = vec_len (sl) - 1;
-      srh->first_segment = vec_len (sl) - 1;
+      srh->last_entry = vec_len (sl) - 1;
       srh->length = ((sizeof (ip6_sr_header_t) +
                      (vec_len (sl) * sizeof (ip6_address_t))) / 8) - 1;
       srh->flags = 0x00;
-      srh->reserved = 0x00;
+      srh->tag = 0x0000;
       addrp = srh->segments + vec_len (sl) - 1;
       vec_foreach (this_address, sl)
       {
-       clib_memcpy (addrp->as_u8, this_address->as_u8,
-                    sizeof (ip6_address_t));
+       clib_memcpy_fast (addrp->as_u8, this_address->as_u8,
+                         sizeof (ip6_address_t));
        addrp--;
       }
     }
@@ -226,15 +265,16 @@ compute_rewrite_insert (ip6_address_t * sl)
   srh = (ip6_sr_header_t *) rs;
   srh->type = ROUTING_HEADER_TYPE_SR;
   srh->segments_left = vec_len (sl);
-  srh->first_segment = vec_len (sl);
+  srh->last_entry = vec_len (sl);
   srh->length = ((sizeof (ip6_sr_header_t) +
                  ((vec_len (sl) + 1) * sizeof (ip6_address_t))) / 8) - 1;
   srh->flags = 0x00;
-  srh->reserved = 0x0000;
+  srh->tag = 0x0000;
   addrp = srh->segments + vec_len (sl);
   vec_foreach (this_address, sl)
   {
-    clib_memcpy (addrp->as_u8, this_address->as_u8, sizeof (ip6_address_t));
+    clib_memcpy_fast (addrp->as_u8, this_address->as_u8,
+                     sizeof (ip6_address_t));
     addrp--;
   }
   return rs;
@@ -264,15 +304,16 @@ compute_rewrite_bsid (ip6_address_t * sl)
   srh = (ip6_sr_header_t *) rs;
   srh->type = ROUTING_HEADER_TYPE_SR;
   srh->segments_left = vec_len (sl) - 1;
-  srh->first_segment = vec_len (sl) - 1;
+  srh->last_entry = vec_len (sl) - 1;
   srh->length = ((sizeof (ip6_sr_header_t) +
                  (vec_len (sl) * sizeof (ip6_address_t))) / 8) - 1;
   srh->flags = 0x00;
-  srh->reserved = 0x0000;
+  srh->tag = 0x0000;
   addrp = srh->segments + vec_len (sl) - 1;
   vec_foreach (this_address, sl)
   {
-    clib_memcpy (addrp->as_u8, this_address->as_u8, sizeof (ip6_address_t));
+    clib_memcpy_fast (addrp->as_u8, this_address->as_u8,
+                     sizeof (ip6_address_t));
     addrp--;
   }
   return rs;
@@ -301,7 +342,7 @@ create_sl (ip6_sr_policy_t * sr_policy, ip6_address_t * sl, u32 weight,
   ip6_sr_sl_t *segment_list;
 
   pool_get (sm->sid_lists, segment_list);
-  memset (segment_list, 0, sizeof (*segment_list));
+  clib_memset (segment_list, 0, sizeof (*segment_list));
 
   vec_add1 (sr_policy->segments_lists, segment_list - sm->sid_lists);
 
@@ -588,8 +629,8 @@ sr_policy_add (ip6_address_t * bsid, ip6_address_t * segments,
 
   /* Add an SR policy object */
   pool_get (sm->sr_policies, sr_policy);
-  memset (sr_policy, 0, sizeof (*sr_policy));
-  clib_memcpy (&sr_policy->bsid, bsid, sizeof (ip6_address_t));
+  clib_memset (sr_policy, 0, sizeof (*sr_policy));
+  clib_memcpy_fast (&sr_policy->bsid, bsid, sizeof (ip6_address_t));
   sr_policy->type = behavior;
   sr_policy->fib_table = (fib_table != (u32) ~ 0 ? fib_table : 0);     //Is default FIB 0 ?
   sr_policy->is_encap = is_encap;
@@ -852,8 +893,8 @@ sr_policy_command_fn (vlib_main_t * vm, unformat_input_t * input,
        if (unformat (input, "next %U", unformat_ip6_address, &next_address))
        {
          vec_add2 (segments, this_seg, 1);
-         clib_memcpy (this_seg->as_u8, next_address.as_u8,
-                      sizeof (*this_seg));
+         clib_memcpy_fast (this_seg->as_u8, next_address.as_u8,
+                           sizeof (*this_seg));
        }
       else if (unformat (input, "add sl"))
        operation = 1;
@@ -1159,14 +1200,14 @@ sr_policy_rewrite_encaps (vlib_main_t * vm, vlib_node_runtime_t * node,
          ip2_encap = vlib_buffer_get_current (b2);
          ip3_encap = vlib_buffer_get_current (b3);
 
-         clib_memcpy (((u8 *) ip0_encap) - vec_len (sl0->rewrite),
-                      sl0->rewrite, vec_len (sl0->rewrite));
-         clib_memcpy (((u8 *) ip1_encap) - vec_len (sl1->rewrite),
-                      sl1->rewrite, vec_len (sl1->rewrite));
-         clib_memcpy (((u8 *) ip2_encap) - vec_len (sl2->rewrite),
-                      sl2->rewrite, vec_len (sl2->rewrite));
-         clib_memcpy (((u8 *) ip3_encap) - vec_len (sl3->rewrite),
-                      sl3->rewrite, vec_len (sl3->rewrite));
+         clib_memcpy_fast (((u8 *) ip0_encap) - vec_len (sl0->rewrite),
+                           sl0->rewrite, vec_len (sl0->rewrite));
+         clib_memcpy_fast (((u8 *) ip1_encap) - vec_len (sl1->rewrite),
+                           sl1->rewrite, vec_len (sl1->rewrite));
+         clib_memcpy_fast (((u8 *) ip2_encap) - vec_len (sl2->rewrite),
+                           sl2->rewrite, vec_len (sl2->rewrite));
+         clib_memcpy_fast (((u8 *) ip3_encap) - vec_len (sl3->rewrite),
+                           sl3->rewrite, vec_len (sl3->rewrite));
 
          vlib_buffer_advance (b0, -(word) vec_len (sl0->rewrite));
          vlib_buffer_advance (b1, -(word) vec_len (sl1->rewrite));
@@ -1189,40 +1230,40 @@ sr_policy_rewrite_encaps (vlib_main_t * vm, vlib_node_runtime_t * node,
                {
                  sr_policy_rewrite_trace_t *tr =
                    vlib_add_trace (vm, node, b0, sizeof (*tr));
-                 clib_memcpy (tr->src.as_u8, ip0->src_address.as_u8,
-                              sizeof (tr->src.as_u8));
-                 clib_memcpy (tr->dst.as_u8, ip0->dst_address.as_u8,
-                              sizeof (tr->dst.as_u8));
+                 clib_memcpy_fast (tr->src.as_u8, ip0->src_address.as_u8,
+                                   sizeof (tr->src.as_u8));
+                 clib_memcpy_fast (tr->dst.as_u8, ip0->dst_address.as_u8,
+                                   sizeof (tr->dst.as_u8));
                }
 
              if (PREDICT_FALSE (b1->flags & VLIB_BUFFER_IS_TRACED))
                {
                  sr_policy_rewrite_trace_t *tr =
                    vlib_add_trace (vm, node, b1, sizeof (*tr));
-                 clib_memcpy (tr->src.as_u8, ip1->src_address.as_u8,
-                              sizeof (tr->src.as_u8));
-                 clib_memcpy (tr->dst.as_u8, ip1->dst_address.as_u8,
-                              sizeof (tr->dst.as_u8));
+                 clib_memcpy_fast (tr->src.as_u8, ip1->src_address.as_u8,
+                                   sizeof (tr->src.as_u8));
+                 clib_memcpy_fast (tr->dst.as_u8, ip1->dst_address.as_u8,
+                                   sizeof (tr->dst.as_u8));
                }
 
              if (PREDICT_FALSE (b2->flags & VLIB_BUFFER_IS_TRACED))
                {
                  sr_policy_rewrite_trace_t *tr =
                    vlib_add_trace (vm, node, b2, sizeof (*tr));
-                 clib_memcpy (tr->src.as_u8, ip2->src_address.as_u8,
-                              sizeof (tr->src.as_u8));
-                 clib_memcpy (tr->dst.as_u8, ip2->dst_address.as_u8,
-                              sizeof (tr->dst.as_u8));
+                 clib_memcpy_fast (tr->src.as_u8, ip2->src_address.as_u8,
+                                   sizeof (tr->src.as_u8));
+                 clib_memcpy_fast (tr->dst.as_u8, ip2->dst_address.as_u8,
+                                   sizeof (tr->dst.as_u8));
                }
 
              if (PREDICT_FALSE (b3->flags & VLIB_BUFFER_IS_TRACED))
                {
                  sr_policy_rewrite_trace_t *tr =
                    vlib_add_trace (vm, node, b3, sizeof (*tr));
-                 clib_memcpy (tr->src.as_u8, ip3->src_address.as_u8,
-                              sizeof (tr->src.as_u8));
-                 clib_memcpy (tr->dst.as_u8, ip3->dst_address.as_u8,
-                              sizeof (tr->dst.as_u8));
+                 clib_memcpy_fast (tr->src.as_u8, ip3->src_address.as_u8,
+                                   sizeof (tr->src.as_u8));
+                 clib_memcpy_fast (tr->dst.as_u8, ip3->dst_address.as_u8,
+                                   sizeof (tr->dst.as_u8));
                }
            }
 
@@ -1257,8 +1298,8 @@ sr_policy_rewrite_encaps (vlib_main_t * vm, vlib_node_runtime_t * node,
 
          ip0_encap = vlib_buffer_get_current (b0);
 
-         clib_memcpy (((u8 *) ip0_encap) - vec_len (sl0->rewrite),
-                      sl0->rewrite, vec_len (sl0->rewrite));
+         clib_memcpy_fast (((u8 *) ip0_encap) - vec_len (sl0->rewrite),
+                           sl0->rewrite, vec_len (sl0->rewrite));
          vlib_buffer_advance (b0, -(word) vec_len (sl0->rewrite));
 
          ip0 = vlib_buffer_get_current (b0);
@@ -1270,10 +1311,10 @@ sr_policy_rewrite_encaps (vlib_main_t * vm, vlib_node_runtime_t * node,
            {
              sr_policy_rewrite_trace_t *tr =
                vlib_add_trace (vm, node, b0, sizeof (*tr));
-             clib_memcpy (tr->src.as_u8, ip0->src_address.as_u8,
-                          sizeof (tr->src.as_u8));
-             clib_memcpy (tr->dst.as_u8, ip0->dst_address.as_u8,
-                          sizeof (tr->dst.as_u8));
+             clib_memcpy_fast (tr->src.as_u8, ip0->src_address.as_u8,
+                               sizeof (tr->src.as_u8));
+             clib_memcpy_fast (tr->dst.as_u8, ip0->dst_address.as_u8,
+                               sizeof (tr->dst.as_u8));
            }
 
          encap_pkts++;
@@ -1442,14 +1483,14 @@ sr_policy_rewrite_encaps_v4 (vlib_main_t * vm, vlib_node_runtime_t * node,
          ip2_encap = vlib_buffer_get_current (b2);
          ip3_encap = vlib_buffer_get_current (b3);
 
-         clib_memcpy (((u8 *) ip0_encap) - vec_len (sl0->rewrite),
-                      sl0->rewrite, vec_len (sl0->rewrite));
-         clib_memcpy (((u8 *) ip1_encap) - vec_len (sl1->rewrite),
-                      sl1->rewrite, vec_len (sl1->rewrite));
-         clib_memcpy (((u8 *) ip2_encap) - vec_len (sl2->rewrite),
-                      sl2->rewrite, vec_len (sl2->rewrite));
-         clib_memcpy (((u8 *) ip3_encap) - vec_len (sl3->rewrite),
-                      sl3->rewrite, vec_len (sl3->rewrite));
+         clib_memcpy_fast (((u8 *) ip0_encap) - vec_len (sl0->rewrite),
+                           sl0->rewrite, vec_len (sl0->rewrite));
+         clib_memcpy_fast (((u8 *) ip1_encap) - vec_len (sl1->rewrite),
+                           sl1->rewrite, vec_len (sl1->rewrite));
+         clib_memcpy_fast (((u8 *) ip2_encap) - vec_len (sl2->rewrite),
+                           sl2->rewrite, vec_len (sl2->rewrite));
+         clib_memcpy_fast (((u8 *) ip3_encap) - vec_len (sl3->rewrite),
+                           sl3->rewrite, vec_len (sl3->rewrite));
 
          vlib_buffer_advance (b0, -(word) vec_len (sl0->rewrite));
          vlib_buffer_advance (b1, -(word) vec_len (sl1->rewrite));
@@ -1472,40 +1513,40 @@ sr_policy_rewrite_encaps_v4 (vlib_main_t * vm, vlib_node_runtime_t * node,
                {
                  sr_policy_rewrite_trace_t *tr =
                    vlib_add_trace (vm, node, b0, sizeof (*tr));
-                 clib_memcpy (tr->src.as_u8, ip0->src_address.as_u8,
-                              sizeof (tr->src.as_u8));
-                 clib_memcpy (tr->dst.as_u8, ip0->dst_address.as_u8,
-                              sizeof (tr->dst.as_u8));
+                 clib_memcpy_fast (tr->src.as_u8, ip0->src_address.as_u8,
+                                   sizeof (tr->src.as_u8));
+                 clib_memcpy_fast (tr->dst.as_u8, ip0->dst_address.as_u8,
+                                   sizeof (tr->dst.as_u8));
                }
 
              if (PREDICT_FALSE (b1->flags & VLIB_BUFFER_IS_TRACED))
                {
                  sr_policy_rewrite_trace_t *tr =
                    vlib_add_trace (vm, node, b1, sizeof (*tr));
-                 clib_memcpy (tr->src.as_u8, ip1->src_address.as_u8,
-                              sizeof (tr->src.as_u8));
-                 clib_memcpy (tr->dst.as_u8, ip1->dst_address.as_u8,
-                              sizeof (tr->dst.as_u8));
+                 clib_memcpy_fast (tr->src.as_u8, ip1->src_address.as_u8,
+                                   sizeof (tr->src.as_u8));
+                 clib_memcpy_fast (tr->dst.as_u8, ip1->dst_address.as_u8,
+                                   sizeof (tr->dst.as_u8));
                }
 
              if (PREDICT_FALSE (b2->flags & VLIB_BUFFER_IS_TRACED))
                {
                  sr_policy_rewrite_trace_t *tr =
                    vlib_add_trace (vm, node, b2, sizeof (*tr));
-                 clib_memcpy (tr->src.as_u8, ip2->src_address.as_u8,
-                              sizeof (tr->src.as_u8));
-                 clib_memcpy (tr->dst.as_u8, ip2->dst_address.as_u8,
-                              sizeof (tr->dst.as_u8));
+                 clib_memcpy_fast (tr->src.as_u8, ip2->src_address.as_u8,
+                                   sizeof (tr->src.as_u8));
+                 clib_memcpy_fast (tr->dst.as_u8, ip2->dst_address.as_u8,
+                                   sizeof (tr->dst.as_u8));
                }
 
              if (PREDICT_FALSE (b3->flags & VLIB_BUFFER_IS_TRACED))
                {
                  sr_policy_rewrite_trace_t *tr =
                    vlib_add_trace (vm, node, b3, sizeof (*tr));
-                 clib_memcpy (tr->src.as_u8, ip3->src_address.as_u8,
-                              sizeof (tr->src.as_u8));
-                 clib_memcpy (tr->dst.as_u8, ip3->dst_address.as_u8,
-                              sizeof (tr->dst.as_u8));
+                 clib_memcpy_fast (tr->src.as_u8, ip3->src_address.as_u8,
+                                   sizeof (tr->src.as_u8));
+                 clib_memcpy_fast (tr->dst.as_u8, ip3->dst_address.as_u8,
+                                   sizeof (tr->dst.as_u8));
                }
            }
 
@@ -1541,8 +1582,8 @@ sr_policy_rewrite_encaps_v4 (vlib_main_t * vm, vlib_node_runtime_t * node,
 
          ip0_encap = vlib_buffer_get_current (b0);
 
-         clib_memcpy (((u8 *) ip0_encap) - vec_len (sl0->rewrite),
-                      sl0->rewrite, vec_len (sl0->rewrite));
+         clib_memcpy_fast (((u8 *) ip0_encap) - vec_len (sl0->rewrite),
+                           sl0->rewrite, vec_len (sl0->rewrite));
          vlib_buffer_advance (b0, -(word) vec_len (sl0->rewrite));
 
          ip0 = vlib_buffer_get_current (b0);
@@ -1554,10 +1595,10 @@ sr_policy_rewrite_encaps_v4 (vlib_main_t * vm, vlib_node_runtime_t * node,
            {
              sr_policy_rewrite_trace_t *tr =
                vlib_add_trace (vm, node, b0, sizeof (*tr));
-             clib_memcpy (tr->src.as_u8, ip0->src_address.as_u8,
-                          sizeof (tr->src.as_u8));
-             clib_memcpy (tr->dst.as_u8, ip0->dst_address.as_u8,
-                          sizeof (tr->dst.as_u8));
+             clib_memcpy_fast (tr->src.as_u8, ip0->src_address.as_u8,
+                               sizeof (tr->src.as_u8));
+             clib_memcpy_fast (tr->dst.as_u8, ip0->dst_address.as_u8,
+                               sizeof (tr->dst.as_u8));
            }
 
          encap_pkts++;
@@ -1799,14 +1840,14 @@ sr_policy_rewrite_encaps_l2 (vlib_main_t * vm, vlib_node_runtime_t * node,
          en2 = vlib_buffer_get_current (b2);
          en3 = vlib_buffer_get_current (b3);
 
-         clib_memcpy (((u8 *) en0) - vec_len (sl0->rewrite), sl0->rewrite,
-                      vec_len (sl0->rewrite));
-         clib_memcpy (((u8 *) en1) - vec_len (sl1->rewrite), sl1->rewrite,
-                      vec_len (sl1->rewrite));
-         clib_memcpy (((u8 *) en2) - vec_len (sl2->rewrite), sl2->rewrite,
-                      vec_len (sl2->rewrite));
-         clib_memcpy (((u8 *) en3) - vec_len (sl3->rewrite), sl3->rewrite,
-                      vec_len (sl3->rewrite));
+         clib_memcpy_fast (((u8 *) en0) - vec_len (sl0->rewrite),
+                           sl0->rewrite, vec_len (sl0->rewrite));
+         clib_memcpy_fast (((u8 *) en1) - vec_len (sl1->rewrite),
+                           sl1->rewrite, vec_len (sl1->rewrite));
+         clib_memcpy_fast (((u8 *) en2) - vec_len (sl2->rewrite),
+                           sl2->rewrite, vec_len (sl2->rewrite));
+         clib_memcpy_fast (((u8 *) en3) - vec_len (sl3->rewrite),
+                           sl3->rewrite, vec_len (sl3->rewrite));
 
          vlib_buffer_advance (b0, -(word) vec_len (sl0->rewrite));
          vlib_buffer_advance (b1, -(word) vec_len (sl1->rewrite));
@@ -1868,40 +1909,40 @@ sr_policy_rewrite_encaps_l2 (vlib_main_t * vm, vlib_node_runtime_t * node,
                {
                  sr_policy_rewrite_trace_t *tr =
                    vlib_add_trace (vm, node, b0, sizeof (*tr));
-                 clib_memcpy (tr->src.as_u8, ip0->src_address.as_u8,
-                              sizeof (tr->src.as_u8));
-                 clib_memcpy (tr->dst.as_u8, ip0->dst_address.as_u8,
-                              sizeof (tr->dst.as_u8));
+                 clib_memcpy_fast (tr->src.as_u8, ip0->src_address.as_u8,
+                                   sizeof (tr->src.as_u8));
+                 clib_memcpy_fast (tr->dst.as_u8, ip0->dst_address.as_u8,
+                                   sizeof (tr->dst.as_u8));
                }
 
              if (PREDICT_FALSE (b1->flags & VLIB_BUFFER_IS_TRACED))
                {
                  sr_policy_rewrite_trace_t *tr =
                    vlib_add_trace (vm, node, b1, sizeof (*tr));
-                 clib_memcpy (tr->src.as_u8, ip1->src_address.as_u8,
-                              sizeof (tr->src.as_u8));
-                 clib_memcpy (tr->dst.as_u8, ip1->dst_address.as_u8,
-                              sizeof (tr->dst.as_u8));
+                 clib_memcpy_fast (tr->src.as_u8, ip1->src_address.as_u8,
+                                   sizeof (tr->src.as_u8));
+                 clib_memcpy_fast (tr->dst.as_u8, ip1->dst_address.as_u8,
+                                   sizeof (tr->dst.as_u8));
                }
 
              if (PREDICT_FALSE (b2->flags & VLIB_BUFFER_IS_TRACED))
                {
                  sr_policy_rewrite_trace_t *tr =
                    vlib_add_trace (vm, node, b2, sizeof (*tr));
-                 clib_memcpy (tr->src.as_u8, ip2->src_address.as_u8,
-                              sizeof (tr->src.as_u8));
-                 clib_memcpy (tr->dst.as_u8, ip2->dst_address.as_u8,
-                              sizeof (tr->dst.as_u8));
+                 clib_memcpy_fast (tr->src.as_u8, ip2->src_address.as_u8,
+                                   sizeof (tr->src.as_u8));
+                 clib_memcpy_fast (tr->dst.as_u8, ip2->dst_address.as_u8,
+                                   sizeof (tr->dst.as_u8));
                }
 
              if (PREDICT_FALSE (b3->flags & VLIB_BUFFER_IS_TRACED))
                {
                  sr_policy_rewrite_trace_t *tr =
                    vlib_add_trace (vm, node, b3, sizeof (*tr));
-                 clib_memcpy (tr->src.as_u8, ip3->src_address.as_u8,
-                              sizeof (tr->src.as_u8));
-                 clib_memcpy (tr->dst.as_u8, ip3->dst_address.as_u8,
-                              sizeof (tr->dst.as_u8));
+                 clib_memcpy_fast (tr->src.as_u8, ip3->src_address.as_u8,
+                                   sizeof (tr->src.as_u8));
+                 clib_memcpy_fast (tr->dst.as_u8, ip3->dst_address.as_u8,
+                                   sizeof (tr->dst.as_u8));
                }
            }
 
@@ -1955,8 +1996,8 @@ sr_policy_rewrite_encaps_l2 (vlib_main_t * vm, vlib_node_runtime_t * node,
 
          en0 = vlib_buffer_get_current (b0);
 
-         clib_memcpy (((u8 *) en0) - vec_len (sl0->rewrite), sl0->rewrite,
-                      vec_len (sl0->rewrite));
+         clib_memcpy_fast (((u8 *) en0) - vec_len (sl0->rewrite),
+                           sl0->rewrite, vec_len (sl0->rewrite));
 
          vlib_buffer_advance (b0, -(word) vec_len (sl0->rewrite));
 
@@ -1978,10 +2019,10 @@ sr_policy_rewrite_encaps_l2 (vlib_main_t * vm, vlib_node_runtime_t * node,
            {
              sr_policy_rewrite_trace_t *tr =
                vlib_add_trace (vm, node, b0, sizeof (*tr));
-             clib_memcpy (tr->src.as_u8, ip0->src_address.as_u8,
-                          sizeof (tr->src.as_u8));
-             clib_memcpy (tr->dst.as_u8, ip0->dst_address.as_u8,
-                          sizeof (tr->dst.as_u8));
+             clib_memcpy_fast (tr->src.as_u8, ip0->src_address.as_u8,
+                               sizeof (tr->src.as_u8));
+             clib_memcpy_fast (tr->dst.as_u8, ip0->dst_address.as_u8,
+                               sizeof (tr->dst.as_u8));
            }
 
          encap_pkts++;
@@ -2145,23 +2186,23 @@ sr_policy_rewrite_insert (vlib_main_t * vm, vlib_node_runtime_t * node,
          else
            sr3 = (ip6_sr_header_t *) (ip3 + 1);
 
-         clib_memcpy ((u8 *) ip0 - vec_len (sl0->rewrite), (u8 *) ip0,
-                      (void *) sr0 - (void *) ip0);
-         clib_memcpy ((u8 *) ip1 - vec_len (sl1->rewrite), (u8 *) ip1,
-                      (void *) sr1 - (void *) ip1);
-         clib_memcpy ((u8 *) ip2 - vec_len (sl2->rewrite), (u8 *) ip2,
-                      (void *) sr2 - (void *) ip2);
-         clib_memcpy ((u8 *) ip3 - vec_len (sl3->rewrite), (u8 *) ip3,
-                      (void *) sr3 - (void *) ip3);
-
-         clib_memcpy (((u8 *) sr0 - vec_len (sl0->rewrite)), sl0->rewrite,
-                      vec_len (sl0->rewrite));
-         clib_memcpy (((u8 *) sr1 - vec_len (sl1->rewrite)), sl1->rewrite,
-                      vec_len (sl1->rewrite));
-         clib_memcpy (((u8 *) sr2 - vec_len (sl2->rewrite)), sl2->rewrite,
-                      vec_len (sl2->rewrite));
-         clib_memcpy (((u8 *) sr3 - vec_len (sl3->rewrite)), sl3->rewrite,
-                      vec_len (sl3->rewrite));
+         clib_memcpy_fast ((u8 *) ip0 - vec_len (sl0->rewrite), (u8 *) ip0,
+                           (void *) sr0 - (void *) ip0);
+         clib_memcpy_fast ((u8 *) ip1 - vec_len (sl1->rewrite), (u8 *) ip1,
+                           (void *) sr1 - (void *) ip1);
+         clib_memcpy_fast ((u8 *) ip2 - vec_len (sl2->rewrite), (u8 *) ip2,
+                           (void *) sr2 - (void *) ip2);
+         clib_memcpy_fast ((u8 *) ip3 - vec_len (sl3->rewrite), (u8 *) ip3,
+                           (void *) sr3 - (void *) ip3);
+
+         clib_memcpy_fast (((u8 *) sr0 - vec_len (sl0->rewrite)),
+                           sl0->rewrite, vec_len (sl0->rewrite));
+         clib_memcpy_fast (((u8 *) sr1 - vec_len (sl1->rewrite)),
+                           sl1->rewrite, vec_len (sl1->rewrite));
+         clib_memcpy_fast (((u8 *) sr2 - vec_len (sl2->rewrite)),
+                           sl2->rewrite, vec_len (sl2->rewrite));
+         clib_memcpy_fast (((u8 *) sr3 - vec_len (sl3->rewrite)),
+                           sl3->rewrite, vec_len (sl3->rewrite));
 
          vlib_buffer_advance (b0, -(word) vec_len (sl0->rewrite));
          vlib_buffer_advance (b1, -(word) vec_len (sl1->rewrite));
@@ -2284,40 +2325,40 @@ sr_policy_rewrite_insert (vlib_main_t * vm, vlib_node_runtime_t * node,
                {
                  sr_policy_rewrite_trace_t *tr =
                    vlib_add_trace (vm, node, b0, sizeof (*tr));
-                 clib_memcpy (tr->src.as_u8, ip0->src_address.as_u8,
-                              sizeof (tr->src.as_u8));
-                 clib_memcpy (tr->dst.as_u8, ip0->dst_address.as_u8,
-                              sizeof (tr->dst.as_u8));
+                 clib_memcpy_fast (tr->src.as_u8, ip0->src_address.as_u8,
+                                   sizeof (tr->src.as_u8));
+                 clib_memcpy_fast (tr->dst.as_u8, ip0->dst_address.as_u8,
+                                   sizeof (tr->dst.as_u8));
                }
 
              if (PREDICT_FALSE (b1->flags & VLIB_BUFFER_IS_TRACED))
                {
                  sr_policy_rewrite_trace_t *tr =
                    vlib_add_trace (vm, node, b1, sizeof (*tr));
-                 clib_memcpy (tr->src.as_u8, ip1->src_address.as_u8,
-                              sizeof (tr->src.as_u8));
-                 clib_memcpy (tr->dst.as_u8, ip1->dst_address.as_u8,
-                              sizeof (tr->dst.as_u8));
+                 clib_memcpy_fast (tr->src.as_u8, ip1->src_address.as_u8,
+                                   sizeof (tr->src.as_u8));
+                 clib_memcpy_fast (tr->dst.as_u8, ip1->dst_address.as_u8,
+                                   sizeof (tr->dst.as_u8));
                }
 
              if (PREDICT_FALSE (b2->flags & VLIB_BUFFER_IS_TRACED))
                {
                  sr_policy_rewrite_trace_t *tr =
                    vlib_add_trace (vm, node, b2, sizeof (*tr));
-                 clib_memcpy (tr->src.as_u8, ip2->src_address.as_u8,
-                              sizeof (tr->src.as_u8));
-                 clib_memcpy (tr->dst.as_u8, ip2->dst_address.as_u8,
-                              sizeof (tr->dst.as_u8));
+                 clib_memcpy_fast (tr->src.as_u8, ip2->src_address.as_u8,
+                                   sizeof (tr->src.as_u8));
+                 clib_memcpy_fast (tr->dst.as_u8, ip2->dst_address.as_u8,
+                                   sizeof (tr->dst.as_u8));
                }
 
              if (PREDICT_FALSE (b3->flags & VLIB_BUFFER_IS_TRACED))
                {
                  sr_policy_rewrite_trace_t *tr =
                    vlib_add_trace (vm, node, b3, sizeof (*tr));
-                 clib_memcpy (tr->src.as_u8, ip3->src_address.as_u8,
-                              sizeof (tr->src.as_u8));
-                 clib_memcpy (tr->dst.as_u8, ip3->dst_address.as_u8,
-                              sizeof (tr->dst.as_u8));
+                 clib_memcpy_fast (tr->src.as_u8, ip3->src_address.as_u8,
+                                   sizeof (tr->src.as_u8));
+                 clib_memcpy_fast (tr->dst.as_u8, ip3->dst_address.as_u8,
+                                   sizeof (tr->dst.as_u8));
                }
            }
 
@@ -2360,10 +2401,10 @@ sr_policy_rewrite_insert (vlib_main_t * vm, vlib_node_runtime_t * node,
          else
            sr0 = (ip6_sr_header_t *) (ip0 + 1);
 
-         clib_memcpy ((u8 *) ip0 - vec_len (sl0->rewrite), (u8 *) ip0,
-                      (void *) sr0 - (void *) ip0);
-         clib_memcpy (((u8 *) sr0 - vec_len (sl0->rewrite)), sl0->rewrite,
-                      vec_len (sl0->rewrite));
+         clib_memcpy_fast ((u8 *) ip0 - vec_len (sl0->rewrite), (u8 *) ip0,
+                           (void *) sr0 - (void *) ip0);
+         clib_memcpy_fast (((u8 *) sr0 - vec_len (sl0->rewrite)),
+                           sl0->rewrite, vec_len (sl0->rewrite));
 
          vlib_buffer_advance (b0, -(word) vec_len (sl0->rewrite));
 
@@ -2400,10 +2441,10 @@ sr_policy_rewrite_insert (vlib_main_t * vm, vlib_node_runtime_t * node,
            {
              sr_policy_rewrite_trace_t *tr =
                vlib_add_trace (vm, node, b0, sizeof (*tr));
-             clib_memcpy (tr->src.as_u8, ip0->src_address.as_u8,
-                          sizeof (tr->src.as_u8));
-             clib_memcpy (tr->dst.as_u8, ip0->dst_address.as_u8,
-                          sizeof (tr->dst.as_u8));
+             clib_memcpy_fast (tr->src.as_u8, ip0->src_address.as_u8,
+                               sizeof (tr->src.as_u8));
+             clib_memcpy_fast (tr->dst.as_u8, ip0->dst_address.as_u8,
+                               sizeof (tr->dst.as_u8));
            }
 
          insert_pkts++;
@@ -2567,23 +2608,23 @@ sr_policy_rewrite_b_insert (vlib_main_t * vm, vlib_node_runtime_t * node,
          else
            sr3 = (ip6_sr_header_t *) (ip3 + 1);
 
-         clib_memcpy ((u8 *) ip0 - vec_len (sl0->rewrite_bsid), (u8 *) ip0,
-                      (void *) sr0 - (void *) ip0);
-         clib_memcpy ((u8 *) ip1 - vec_len (sl1->rewrite_bsid), (u8 *) ip1,
-                      (void *) sr1 - (void *) ip1);
-         clib_memcpy ((u8 *) ip2 - vec_len (sl2->rewrite_bsid), (u8 *) ip2,
-                      (void *) sr2 - (void *) ip2);
-         clib_memcpy ((u8 *) ip3 - vec_len (sl3->rewrite_bsid), (u8 *) ip3,
-                      (void *) sr3 - (void *) ip3);
-
-         clib_memcpy (((u8 *) sr0 - vec_len (sl0->rewrite_bsid)),
-                      sl0->rewrite_bsid, vec_len (sl0->rewrite_bsid));
-         clib_memcpy (((u8 *) sr1 - vec_len (sl1->rewrite_bsid)),
-                      sl1->rewrite_bsid, vec_len (sl1->rewrite_bsid));
-         clib_memcpy (((u8 *) sr2 - vec_len (sl2->rewrite_bsid)),
-                      sl2->rewrite_bsid, vec_len (sl2->rewrite_bsid));
-         clib_memcpy (((u8 *) sr3 - vec_len (sl3->rewrite_bsid)),
-                      sl3->rewrite_bsid, vec_len (sl3->rewrite_bsid));
+         clib_memcpy_fast ((u8 *) ip0 - vec_len (sl0->rewrite_bsid),
+                           (u8 *) ip0, (void *) sr0 - (void *) ip0);
+         clib_memcpy_fast ((u8 *) ip1 - vec_len (sl1->rewrite_bsid),
+                           (u8 *) ip1, (void *) sr1 - (void *) ip1);
+         clib_memcpy_fast ((u8 *) ip2 - vec_len (sl2->rewrite_bsid),
+                           (u8 *) ip2, (void *) sr2 - (void *) ip2);
+         clib_memcpy_fast ((u8 *) ip3 - vec_len (sl3->rewrite_bsid),
+                           (u8 *) ip3, (void *) sr3 - (void *) ip3);
+
+         clib_memcpy_fast (((u8 *) sr0 - vec_len (sl0->rewrite_bsid)),
+                           sl0->rewrite_bsid, vec_len (sl0->rewrite_bsid));
+         clib_memcpy_fast (((u8 *) sr1 - vec_len (sl1->rewrite_bsid)),
+                           sl1->rewrite_bsid, vec_len (sl1->rewrite_bsid));
+         clib_memcpy_fast (((u8 *) sr2 - vec_len (sl2->rewrite_bsid)),
+                           sl2->rewrite_bsid, vec_len (sl2->rewrite_bsid));
+         clib_memcpy_fast (((u8 *) sr3 - vec_len (sl3->rewrite_bsid)),
+                           sl3->rewrite_bsid, vec_len (sl3->rewrite_bsid));
 
          vlib_buffer_advance (b0, -(word) vec_len (sl0->rewrite_bsid));
          vlib_buffer_advance (b1, -(word) vec_len (sl1->rewrite_bsid));
@@ -2697,40 +2738,40 @@ sr_policy_rewrite_b_insert (vlib_main_t * vm, vlib_node_runtime_t * node,
                {
                  sr_policy_rewrite_trace_t *tr =
                    vlib_add_trace (vm, node, b0, sizeof (*tr));
-                 clib_memcpy (tr->src.as_u8, ip0->src_address.as_u8,
-                              sizeof (tr->src.as_u8));
-                 clib_memcpy (tr->dst.as_u8, ip0->dst_address.as_u8,
-                              sizeof (tr->dst.as_u8));
+                 clib_memcpy_fast (tr->src.as_u8, ip0->src_address.as_u8,
+                                   sizeof (tr->src.as_u8));
+                 clib_memcpy_fast (tr->dst.as_u8, ip0->dst_address.as_u8,
+                                   sizeof (tr->dst.as_u8));
                }
 
              if (PREDICT_FALSE (b1->flags & VLIB_BUFFER_IS_TRACED))
                {
                  sr_policy_rewrite_trace_t *tr =
                    vlib_add_trace (vm, node, b1, sizeof (*tr));
-                 clib_memcpy (tr->src.as_u8, ip1->src_address.as_u8,
-                              sizeof (tr->src.as_u8));
-                 clib_memcpy (tr->dst.as_u8, ip1->dst_address.as_u8,
-                              sizeof (tr->dst.as_u8));
+                 clib_memcpy_fast (tr->src.as_u8, ip1->src_address.as_u8,
+                                   sizeof (tr->src.as_u8));
+                 clib_memcpy_fast (tr->dst.as_u8, ip1->dst_address.as_u8,
+                                   sizeof (tr->dst.as_u8));
                }
 
              if (PREDICT_FALSE (b2->flags & VLIB_BUFFER_IS_TRACED))
                {
                  sr_policy_rewrite_trace_t *tr =
                    vlib_add_trace (vm, node, b2, sizeof (*tr));
-                 clib_memcpy (tr->src.as_u8, ip2->src_address.as_u8,
-                              sizeof (tr->src.as_u8));
-                 clib_memcpy (tr->dst.as_u8, ip2->dst_address.as_u8,
-                              sizeof (tr->dst.as_u8));
+                 clib_memcpy_fast (tr->src.as_u8, ip2->src_address.as_u8,
+                                   sizeof (tr->src.as_u8));
+                 clib_memcpy_fast (tr->dst.as_u8, ip2->dst_address.as_u8,
+                                   sizeof (tr->dst.as_u8));
                }
 
              if (PREDICT_FALSE (b3->flags & VLIB_BUFFER_IS_TRACED))
                {
                  sr_policy_rewrite_trace_t *tr =
                    vlib_add_trace (vm, node, b3, sizeof (*tr));
-                 clib_memcpy (tr->src.as_u8, ip3->src_address.as_u8,
-                              sizeof (tr->src.as_u8));
-                 clib_memcpy (tr->dst.as_u8, ip3->dst_address.as_u8,
-                              sizeof (tr->dst.as_u8));
+                 clib_memcpy_fast (tr->src.as_u8, ip3->src_address.as_u8,
+                                   sizeof (tr->src.as_u8));
+                 clib_memcpy_fast (tr->dst.as_u8, ip3->dst_address.as_u8,
+                                   sizeof (tr->dst.as_u8));
                }
            }
 
@@ -2773,10 +2814,10 @@ sr_policy_rewrite_b_insert (vlib_main_t * vm, vlib_node_runtime_t * node,
          else
            sr0 = (ip6_sr_header_t *) (ip0 + 1);
 
-         clib_memcpy ((u8 *) ip0 - vec_len (sl0->rewrite_bsid), (u8 *) ip0,
-                      (void *) sr0 - (void *) ip0);
-         clib_memcpy (((u8 *) sr0 - vec_len (sl0->rewrite_bsid)),
-                      sl0->rewrite_bsid, vec_len (sl0->rewrite_bsid));
+         clib_memcpy_fast ((u8 *) ip0 - vec_len (sl0->rewrite_bsid),
+                           (u8 *) ip0, (void *) sr0 - (void *) ip0);
+         clib_memcpy_fast (((u8 *) sr0 - vec_len (sl0->rewrite_bsid)),
+                           sl0->rewrite_bsid, vec_len (sl0->rewrite_bsid));
 
          vlib_buffer_advance (b0, -(word) vec_len (sl0->rewrite_bsid));
 
@@ -2811,10 +2852,10 @@ sr_policy_rewrite_b_insert (vlib_main_t * vm, vlib_node_runtime_t * node,
            {
              sr_policy_rewrite_trace_t *tr =
                vlib_add_trace (vm, node, b0, sizeof (*tr));
-             clib_memcpy (tr->src.as_u8, ip0->src_address.as_u8,
-                          sizeof (tr->src.as_u8));
-             clib_memcpy (tr->dst.as_u8, ip0->dst_address.as_u8,
-                          sizeof (tr->dst.as_u8));
+             clib_memcpy_fast (tr->src.as_u8, ip0->src_address.as_u8,
+                               sizeof (tr->src.as_u8));
+             clib_memcpy_fast (tr->dst.as_u8, ip0->dst_address.as_u8,
+                               sizeof (tr->dst.as_u8));
            }
 
          insert_pkts++;
@@ -2919,7 +2960,6 @@ sr_policy_rewrite_b_encaps (vlib_main_t * vm, vlib_node_runtime_t * node,
          ip6_header_t *ip0, *ip1, *ip2, *ip3;
          ip6_header_t *ip0_encap, *ip1_encap, *ip2_encap, *ip3_encap;
          ip6_sr_header_t *sr0, *sr1, *sr2, *sr3;
-         ip6_ext_header_t *prev0, *prev1, *prev2, *prev3;
          ip6_sr_sl_t *sl0, *sl1, *sl2, *sl3;
 
          /* Prefetch next iteration. */
@@ -2983,28 +3023,32 @@ sr_policy_rewrite_b_encaps (vlib_main_t * vm, vlib_node_runtime_t * node,
          ip2_encap = vlib_buffer_get_current (b2);
          ip3_encap = vlib_buffer_get_current (b3);
 
-         ip6_ext_header_find_t (ip0_encap, prev0, sr0,
-                                IP_PROTOCOL_IPV6_ROUTE);
-         ip6_ext_header_find_t (ip1_encap, prev1, sr1,
-                                IP_PROTOCOL_IPV6_ROUTE);
-         ip6_ext_header_find_t (ip2_encap, prev2, sr2,
-                                IP_PROTOCOL_IPV6_ROUTE);
-         ip6_ext_header_find_t (ip3_encap, prev3, sr3,
-                                IP_PROTOCOL_IPV6_ROUTE);
+         sr0 =
+           ip6_ext_header_find (vm, b0, ip0_encap, IP_PROTOCOL_IPV6_ROUTE,
+                                NULL);
+         sr1 =
+           ip6_ext_header_find (vm, b1, ip1_encap, IP_PROTOCOL_IPV6_ROUTE,
+                                NULL);
+         sr2 =
+           ip6_ext_header_find (vm, b2, ip2_encap, IP_PROTOCOL_IPV6_ROUTE,
+                                NULL);
+         sr3 =
+           ip6_ext_header_find (vm, b3, ip3_encap, IP_PROTOCOL_IPV6_ROUTE,
+                                NULL);
 
          end_bsid_encaps_srh_processing (node, b0, ip0_encap, sr0, &next0);
          end_bsid_encaps_srh_processing (node, b1, ip1_encap, sr1, &next1);
          end_bsid_encaps_srh_processing (node, b2, ip2_encap, sr2, &next2);
          end_bsid_encaps_srh_processing (node, b3, ip3_encap, sr3, &next3);
 
-         clib_memcpy (((u8 *) ip0_encap) - vec_len (sl0->rewrite),
-                      sl0->rewrite, vec_len (sl0->rewrite));
-         clib_memcpy (((u8 *) ip1_encap) - vec_len (sl1->rewrite),
-                      sl1->rewrite, vec_len (sl1->rewrite));
-         clib_memcpy (((u8 *) ip2_encap) - vec_len (sl2->rewrite),
-                      sl2->rewrite, vec_len (sl2->rewrite));
-         clib_memcpy (((u8 *) ip3_encap) - vec_len (sl3->rewrite),
-                      sl3->rewrite, vec_len (sl3->rewrite));
+         clib_memcpy_fast (((u8 *) ip0_encap) - vec_len (sl0->rewrite),
+                           sl0->rewrite, vec_len (sl0->rewrite));
+         clib_memcpy_fast (((u8 *) ip1_encap) - vec_len (sl1->rewrite),
+                           sl1->rewrite, vec_len (sl1->rewrite));
+         clib_memcpy_fast (((u8 *) ip2_encap) - vec_len (sl2->rewrite),
+                           sl2->rewrite, vec_len (sl2->rewrite));
+         clib_memcpy_fast (((u8 *) ip3_encap) - vec_len (sl3->rewrite),
+                           sl3->rewrite, vec_len (sl3->rewrite));
 
          vlib_buffer_advance (b0, -(word) vec_len (sl0->rewrite));
          vlib_buffer_advance (b1, -(word) vec_len (sl1->rewrite));
@@ -3027,40 +3071,40 @@ sr_policy_rewrite_b_encaps (vlib_main_t * vm, vlib_node_runtime_t * node,
                {
                  sr_policy_rewrite_trace_t *tr =
                    vlib_add_trace (vm, node, b0, sizeof (*tr));
-                 clib_memcpy (tr->src.as_u8, ip0->src_address.as_u8,
-                              sizeof (tr->src.as_u8));
-                 clib_memcpy (tr->dst.as_u8, ip0->dst_address.as_u8,
-                              sizeof (tr->dst.as_u8));
+                 clib_memcpy_fast (tr->src.as_u8, ip0->src_address.as_u8,
+                                   sizeof (tr->src.as_u8));
+                 clib_memcpy_fast (tr->dst.as_u8, ip0->dst_address.as_u8,
+                                   sizeof (tr->dst.as_u8));
                }
 
              if (PREDICT_FALSE (b1->flags & VLIB_BUFFER_IS_TRACED))
                {
                  sr_policy_rewrite_trace_t *tr =
                    vlib_add_trace (vm, node, b1, sizeof (*tr));
-                 clib_memcpy (tr->src.as_u8, ip1->src_address.as_u8,
-                              sizeof (tr->src.as_u8));
-                 clib_memcpy (tr->dst.as_u8, ip1->dst_address.as_u8,
-                              sizeof (tr->dst.as_u8));
+                 clib_memcpy_fast (tr->src.as_u8, ip1->src_address.as_u8,
+                                   sizeof (tr->src.as_u8));
+                 clib_memcpy_fast (tr->dst.as_u8, ip1->dst_address.as_u8,
+                                   sizeof (tr->dst.as_u8));
                }
 
              if (PREDICT_FALSE (b2->flags & VLIB_BUFFER_IS_TRACED))
                {
                  sr_policy_rewrite_trace_t *tr =
                    vlib_add_trace (vm, node, b2, sizeof (*tr));
-                 clib_memcpy (tr->src.as_u8, ip2->src_address.as_u8,
-                              sizeof (tr->src.as_u8));
-                 clib_memcpy (tr->dst.as_u8, ip2->dst_address.as_u8,
-                              sizeof (tr->dst.as_u8));
+                 clib_memcpy_fast (tr->src.as_u8, ip2->src_address.as_u8,
+                                   sizeof (tr->src.as_u8));
+                 clib_memcpy_fast (tr->dst.as_u8, ip2->dst_address.as_u8,
+                                   sizeof (tr->dst.as_u8));
                }
 
              if (PREDICT_FALSE (b3->flags & VLIB_BUFFER_IS_TRACED))
                {
                  sr_policy_rewrite_trace_t *tr =
                    vlib_add_trace (vm, node, b3, sizeof (*tr));
-                 clib_memcpy (tr->src.as_u8, ip3->src_address.as_u8,
-                              sizeof (tr->src.as_u8));
-                 clib_memcpy (tr->dst.as_u8, ip3->dst_address.as_u8,
-                              sizeof (tr->dst.as_u8));
+                 clib_memcpy_fast (tr->src.as_u8, ip3->src_address.as_u8,
+                                   sizeof (tr->src.as_u8));
+                 clib_memcpy_fast (tr->dst.as_u8, ip3->dst_address.as_u8,
+                                   sizeof (tr->dst.as_u8));
                }
            }
 
@@ -3076,7 +3120,6 @@ sr_policy_rewrite_b_encaps (vlib_main_t * vm, vlib_node_runtime_t * node,
          u32 bi0;
          vlib_buffer_t *b0;
          ip6_header_t *ip0 = 0, *ip0_encap = 0;
-         ip6_ext_header_t *prev0;
          ip6_sr_header_t *sr0;
          ip6_sr_sl_t *sl0;
          u32 next0 = SR_POLICY_REWRITE_NEXT_IP6_LOOKUP;
@@ -3096,12 +3139,13 @@ sr_policy_rewrite_b_encaps (vlib_main_t * vm, vlib_node_runtime_t * node,
                  vec_len (sl0->rewrite));
 
          ip0_encap = vlib_buffer_get_current (b0);
-         ip6_ext_header_find_t (ip0_encap, prev0, sr0,
-                                IP_PROTOCOL_IPV6_ROUTE);
+         sr0 =
+           ip6_ext_header_find (vm, b0, ip0_encap, IP_PROTOCOL_IPV6_ROUTE,
+                                NULL);
          end_bsid_encaps_srh_processing (node, b0, ip0_encap, sr0, &next0);
 
-         clib_memcpy (((u8 *) ip0_encap) - vec_len (sl0->rewrite),
-                      sl0->rewrite, vec_len (sl0->rewrite));
+         clib_memcpy_fast (((u8 *) ip0_encap) - vec_len (sl0->rewrite),
+                           sl0->rewrite, vec_len (sl0->rewrite));
          vlib_buffer_advance (b0, -(word) vec_len (sl0->rewrite));
 
          ip0 = vlib_buffer_get_current (b0);
@@ -3113,10 +3157,10 @@ sr_policy_rewrite_b_encaps (vlib_main_t * vm, vlib_node_runtime_t * node,
            {
              sr_policy_rewrite_trace_t *tr =
                vlib_add_trace (vm, node, b0, sizeof (*tr));
-             clib_memcpy (tr->src.as_u8, ip0->src_address.as_u8,
-                          sizeof (tr->src.as_u8));
-             clib_memcpy (tr->dst.as_u8, ip0->dst_address.as_u8,
-                          sizeof (tr->dst.as_u8));
+             clib_memcpy_fast (tr->src.as_u8, ip0->src_address.as_u8,
+                               sizeof (tr->src.as_u8));
+             clib_memcpy_fast (tr->dst.as_u8, ip0->dst_address.as_u8,
+                               sizeof (tr->dst.as_u8));
            }
 
          encap_pkts++;