FIB: encode the label stack in the FIB path during table dump

[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 b42942c..e9c4221 100755 (executable)
--- a/src/vnet/srv6/sr_policy_rewrite.c
+++ b/src/vnet/srv6/sr_policy_rewrite.c
@@ -115,7 +115,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 *
@@ -177,22 +177,26 @@ compute_rewrite_encaps (ip6_address_t * sl)
   iph->protocol = IP_PROTOCOL_IPV6;
   iph->hop_limit = IPv6_DEFAULT_HOP_LIMIT;
 
-  srh = (ip6_sr_header_t *) (iph + 1);
-  iph->protocol = IP_PROTOCOL_IPV6_ROUTE;
-  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->length = ((sizeof (ip6_sr_header_t) +
-                 (vec_len (sl) * sizeof (ip6_address_t))) / 8) - 1;
-  srh->flags = 0x00;
-  srh->reserved = 0x00;
-  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));
-    addrp--;
-  }
+  if (vec_len (sl) > 1)
+    {
+      srh = (ip6_sr_header_t *) (iph + 1);
+      iph->protocol = IP_PROTOCOL_IPV6_ROUTE;
+      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->length = ((sizeof (ip6_sr_header_t) +
+                     (vec_len (sl) * sizeof (ip6_address_t))) / 8) - 1;
+      srh->flags = 0x00;
+      srh->reserved = 0x00;
+      addrp = srh->segments + vec_len (sl) - 1;
+      vec_foreach (this_address, sl)
+      {
+       clib_memcpy_fast (addrp->as_u8, this_address->as_u8,
+                         sizeof (ip6_address_t));
+       addrp--;
+      }
+    }
   iph->dst_address.as_u64[0] = sl->as_u64[0];
   iph->dst_address.as_u64[1] = sl->as_u64[1];
   return rs;
@@ -230,7 +234,8 @@ compute_rewrite_insert (ip6_address_t * sl)
   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;
@@ -268,7 +273,8 @@ compute_rewrite_bsid (ip6_address_t * sl)
   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;
@@ -297,7 +303,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);
 
@@ -584,8 +590,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;
@@ -848,8 +854,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;
@@ -882,6 +888,7 @@ sr_policy_command_fn (vlib_main_t * vm, unformat_input_t * input,
       rv = sr_policy_add (&bsid, segments, weight,
                          (is_spray ? SR_POLICY_TYPE_SPRAY :
                           SR_POLICY_TYPE_DEFAULT), fib_table, is_encap);
+      vec_free (segments);
     }
   else if (is_del)
     rv = sr_policy_del ((sr_policy_index != (u32) ~ 0 ? NULL : &bsid),
@@ -899,6 +906,7 @@ sr_policy_command_fn (vlib_main_t * vm, unformat_input_t * input,
       rv = sr_policy_mod ((sr_policy_index != (u32) ~ 0 ? NULL : &bsid),
                          sr_policy_index, fib_table, operation, segments,
                          sl_index, weight);
+      vec_free (segments);
     }
 
   switch (rv)
@@ -1153,14 +1161,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));
@@ -1183,40 +1191,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));
                }
            }
 
@@ -1251,8 +1259,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);
@@ -1264,10 +1272,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++;
@@ -1332,8 +1340,13 @@ encaps_processing_v4 (vlib_node_runtime_t * node,
   ip0->ip_version_traffic_class_and_flow_label =
     clib_host_to_net_u32 (0 | ((6 & 0xF) << 28) |
                          ((ip0_encap->tos & 0xFF) << 20));
-  sr0 = (void *) (ip0 + 1);
-  sr0->protocol = IP_PROTOCOL_IP_IN_IP;
+  if (ip0->protocol == IP_PROTOCOL_IPV6_ROUTE)
+    {
+      sr0 = (void *) (ip0 + 1);
+      sr0->protocol = IP_PROTOCOL_IP_IN_IP;
+    }
+  else
+    ip0->protocol = IP_PROTOCOL_IP_IN_IP;
 }
 
 /**
@@ -1431,14 +1444,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));
@@ -1461,40 +1474,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));
                }
            }
 
@@ -1530,8 +1543,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);
@@ -1543,10 +1556,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++;
@@ -1788,14 +1801,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));
@@ -1816,13 +1829,37 @@ sr_policy_rewrite_encaps_l2 (vlib_main_t * vm, vlib_node_runtime_t * node,
          ip3->payload_length =
            clib_host_to_net_u16 (b3->current_length - sizeof (ip6_header_t));
 
-         sr0 = (void *) (ip0 + 1);
-         sr1 = (void *) (ip1 + 1);
-         sr2 = (void *) (ip2 + 1);
-         sr3 = (void *) (ip3 + 1);
+         if (ip0->protocol == IP_PROTOCOL_IPV6_ROUTE)
+           {
+             sr0 = (void *) (ip0 + 1);
+             sr0->protocol = IP_PROTOCOL_IP6_NONXT;
+           }
+         else
+           ip0->protocol = IP_PROTOCOL_IP6_NONXT;
+
+         if (ip1->protocol == IP_PROTOCOL_IPV6_ROUTE)
+           {
+             sr1 = (void *) (ip1 + 1);
+             sr1->protocol = IP_PROTOCOL_IP6_NONXT;
+           }
+         else
+           ip1->protocol = IP_PROTOCOL_IP6_NONXT;
+
+         if (ip2->protocol == IP_PROTOCOL_IPV6_ROUTE)
+           {
+             sr2 = (void *) (ip2 + 1);
+             sr2->protocol = IP_PROTOCOL_IP6_NONXT;
+           }
+         else
+           ip2->protocol = IP_PROTOCOL_IP6_NONXT;
 
-         sr0->protocol = sr1->protocol = sr2->protocol = sr3->protocol =
-           IP_PROTOCOL_IP6_NONXT;
+         if (ip3->protocol == IP_PROTOCOL_IPV6_ROUTE)
+           {
+             sr3 = (void *) (ip3 + 1);
+             sr3->protocol = IP_PROTOCOL_IP6_NONXT;
+           }
+         else
+           ip3->protocol = IP_PROTOCOL_IP6_NONXT;
 
          /* Which Traffic class and flow label do I set ? */
          //ip0->ip_version_traffic_class_and_flow_label = clib_host_to_net_u32(0|((6&0xF)<<28)|((ip0_encap->tos&0xFF)<<20));
@@ -1833,40 +1870,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));
                }
            }
 
@@ -1920,8 +1957,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));
 
@@ -1930,18 +1967,23 @@ sr_policy_rewrite_encaps_l2 (vlib_main_t * vm, vlib_node_runtime_t * node,
          ip0->payload_length =
            clib_host_to_net_u16 (b0->current_length - sizeof (ip6_header_t));
 
-         sr0 = (void *) (ip0 + 1);
-         sr0->protocol = IP_PROTOCOL_IP6_NONXT;
+         if (ip0->protocol == IP_PROTOCOL_IPV6_ROUTE)
+           {
+             sr0 = (void *) (ip0 + 1);
+             sr0->protocol = IP_PROTOCOL_IP6_NONXT;
+           }
+         else
+           ip0->protocol = IP_PROTOCOL_IP6_NONXT;
 
          if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE) &&
              PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
            {
              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++;
@@ -2105,23 +2147,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));
@@ -2244,40 +2286,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));
                }
            }
 
@@ -2320,10 +2362,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));
 
@@ -2360,10 +2402,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++;
@@ -2527,23 +2569,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));
@@ -2657,40 +2699,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));
                }
            }
 
@@ -2733,10 +2775,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));
 
@@ -2771,10 +2813,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++;
@@ -2957,14 +2999,14 @@ sr_policy_rewrite_b_encaps (vlib_main_t * vm, vlib_node_runtime_t * node,
          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));
@@ -2987,40 +3029,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));
                }
            }
 
@@ -3060,8 +3102,8 @@ sr_policy_rewrite_b_encaps (vlib_main_t * vm, vlib_node_runtime_t * node,
                                 IP_PROTOCOL_IPV6_ROUTE);
          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);
@@ -3073,10 +3115,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++;