Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2016 Cisco and/or its affiliates. |
| 3 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 4 | * you may not use this file except in compliance with the License. |
| 5 | * You may obtain a copy of the License at: |
| 6 | * |
| 7 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 8 | * |
| 9 | * Unless required by applicable law or agreed to in writing, software |
| 10 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 11 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 12 | * See the License for the specific language governing permissions and |
| 13 | * limitations under the License. |
| 14 | */ |
| 15 | |
| 16 | #include <vnet/adj/adj_nbr.h> |
| 17 | #include <vnet/adj/adj_internal.h> |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 18 | #include <vnet/adj/adj_l2.h> |
Florin Coras | ce1b4c7 | 2017-01-26 14:25:34 -0800 | [diff] [blame] | 19 | #include <vnet/adj/adj_nsh.h> |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 20 | #include <vnet/adj/adj_midchain.h> |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 21 | #include <vnet/ethernet/arp_packet.h> |
| 22 | #include <vnet/dpo/drop_dpo.h> |
Neale Ranns | 521a8d7 | 2018-12-06 13:46:49 +0000 | [diff] [blame] | 23 | #include <vnet/dpo/load_balance.h> |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 24 | #include <vnet/fib/fib_walk.h> |
Neale Ranns | 521a8d7 | 2018-12-06 13:46:49 +0000 | [diff] [blame] | 25 | #include <vnet/fib/fib_entry.h> |
Neale Ranns | e403113 | 2020-10-26 13:00:06 +0000 | [diff] [blame] | 26 | #include <vnet/ip/ip4_inlines.h> |
| 27 | #include <vnet/ip/ip6_inlines.h> |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 28 | |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 29 | /** |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 30 | * @brief Trace data for packets traversing the midchain tx node |
| 31 | */ |
| 32 | typedef struct adj_midchain_tx_trace_t_ |
| 33 | { |
| 34 | /** |
| 35 | * @brief the midchain adj we are traversing |
| 36 | */ |
| 37 | adj_index_t ai; |
| 38 | } adj_midchain_tx_trace_t; |
| 39 | |
| 40 | always_inline uword |
Damjan Marion | 77766a1 | 2016-11-02 01:21:05 +0100 | [diff] [blame] | 41 | adj_midchain_tx_inline (vlib_main_t * vm, |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 42 | vlib_node_runtime_t * node, |
| 43 | vlib_frame_t * frame, |
| 44 | int interface_count) |
| 45 | { |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 46 | vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b; |
| 47 | u16 nexts[VLIB_FRAME_SIZE], *next; |
| 48 | u32 * from, n_left, thread_index; |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 49 | vnet_main_t *vnm = vnet_get_main (); |
| 50 | vnet_interface_main_t *im = &vnm->interface_main; |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 51 | |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 52 | thread_index = vm->thread_index; |
| 53 | n_left = frame->n_vectors; |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 54 | from = vlib_frame_vector_args (frame); |
| 55 | |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 56 | vlib_get_buffers (vm, from, bufs, n_left); |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 57 | |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 58 | next = nexts; |
| 59 | b = bufs; |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 60 | |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 61 | while (n_left > 8) |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 62 | { |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 63 | u32 adj_index0, adj_index1, adj_index2, adj_index3; |
| 64 | const ip_adjacency_t *adj0, *adj1, *adj2, *adj3; |
| 65 | const dpo_id_t *dpo0, *dpo1, *dpo2, *dpo3; |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 66 | |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 67 | /* Prefetch next iteration. */ |
| 68 | { |
| 69 | vlib_prefetch_buffer_header (b[4], LOAD); |
| 70 | vlib_prefetch_buffer_header (b[5], LOAD); |
| 71 | vlib_prefetch_buffer_header (b[6], LOAD); |
| 72 | vlib_prefetch_buffer_header (b[7], LOAD); |
| 73 | } |
Neale Ranns | d3b85b0 | 2016-10-22 15:17:21 -0700 | [diff] [blame] | 74 | |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 75 | /* Follow the DPO on which the midchain is stacked */ |
| 76 | adj_index0 = vnet_buffer(b[0])->ip.adj_index[VLIB_TX]; |
| 77 | adj_index1 = vnet_buffer(b[1])->ip.adj_index[VLIB_TX]; |
| 78 | adj_index2 = vnet_buffer(b[2])->ip.adj_index[VLIB_TX]; |
| 79 | adj_index3 = vnet_buffer(b[3])->ip.adj_index[VLIB_TX]; |
Neale Ranns | d3b85b0 | 2016-10-22 15:17:21 -0700 | [diff] [blame] | 80 | |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 81 | adj0 = adj_get(adj_index0); |
| 82 | adj1 = adj_get(adj_index1); |
| 83 | adj2 = adj_get(adj_index2); |
| 84 | adj3 = adj_get(adj_index3); |
Neale Ranns | d3b85b0 | 2016-10-22 15:17:21 -0700 | [diff] [blame] | 85 | |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 86 | dpo0 = &adj0->sub_type.midchain.next_dpo; |
| 87 | dpo1 = &adj1->sub_type.midchain.next_dpo; |
| 88 | dpo2 = &adj2->sub_type.midchain.next_dpo; |
| 89 | dpo3 = &adj3->sub_type.midchain.next_dpo; |
Neale Ranns | d3b85b0 | 2016-10-22 15:17:21 -0700 | [diff] [blame] | 90 | |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 91 | next[0] = dpo0->dpoi_next_node; |
| 92 | next[1] = dpo1->dpoi_next_node; |
| 93 | next[2] = dpo2->dpoi_next_node; |
| 94 | next[3] = dpo3->dpoi_next_node; |
Neale Ranns | d3b85b0 | 2016-10-22 15:17:21 -0700 | [diff] [blame] | 95 | |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 96 | vnet_buffer(b[0])->ip.adj_index[VLIB_TX] = dpo0->dpoi_index; |
| 97 | vnet_buffer(b[1])->ip.adj_index[VLIB_TX] = dpo1->dpoi_index; |
| 98 | vnet_buffer(b[2])->ip.adj_index[VLIB_TX] = dpo2->dpoi_index; |
| 99 | vnet_buffer(b[3])->ip.adj_index[VLIB_TX] = dpo3->dpoi_index; |
Neale Ranns | d3b85b0 | 2016-10-22 15:17:21 -0700 | [diff] [blame] | 100 | |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 101 | if (interface_count) |
| 102 | { |
| 103 | vlib_increment_combined_counter (im->combined_sw_if_counters |
| 104 | + VNET_INTERFACE_COUNTER_TX, |
| 105 | thread_index, |
| 106 | adj0->rewrite_header.sw_if_index, |
| 107 | 1, |
| 108 | vlib_buffer_length_in_chain (vm, b[0])); |
| 109 | vlib_increment_combined_counter (im->combined_sw_if_counters |
| 110 | + VNET_INTERFACE_COUNTER_TX, |
| 111 | thread_index, |
| 112 | adj1->rewrite_header.sw_if_index, |
| 113 | 1, |
| 114 | vlib_buffer_length_in_chain (vm, b[1])); |
| 115 | vlib_increment_combined_counter (im->combined_sw_if_counters |
| 116 | + VNET_INTERFACE_COUNTER_TX, |
| 117 | thread_index, |
| 118 | adj2->rewrite_header.sw_if_index, |
| 119 | 1, |
| 120 | vlib_buffer_length_in_chain (vm, b[2])); |
| 121 | vlib_increment_combined_counter (im->combined_sw_if_counters |
| 122 | + VNET_INTERFACE_COUNTER_TX, |
| 123 | thread_index, |
| 124 | adj3->rewrite_header.sw_if_index, |
| 125 | 1, |
| 126 | vlib_buffer_length_in_chain (vm, b[3])); |
| 127 | } |
Neale Ranns | d3b85b0 | 2016-10-22 15:17:21 -0700 | [diff] [blame] | 128 | |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 129 | if (PREDICT_FALSE(node->flags & VLIB_NODE_FLAG_TRACE)) |
| 130 | { |
| 131 | if (PREDICT_FALSE(b[0]->flags & VLIB_BUFFER_IS_TRACED)) |
| 132 | { |
| 133 | adj_midchain_tx_trace_t *tr = vlib_add_trace (vm, node, |
| 134 | b[0], sizeof (*tr)); |
| 135 | tr->ai = adj_index0; |
| 136 | } |
| 137 | if (PREDICT_FALSE(b[1]->flags & VLIB_BUFFER_IS_TRACED)) |
| 138 | { |
| 139 | adj_midchain_tx_trace_t *tr = vlib_add_trace (vm, node, |
| 140 | b[1], sizeof (*tr)); |
| 141 | tr->ai = adj_index1; |
| 142 | } |
| 143 | if (PREDICT_FALSE(b[2]->flags & VLIB_BUFFER_IS_TRACED)) |
| 144 | { |
| 145 | adj_midchain_tx_trace_t *tr = vlib_add_trace (vm, node, |
| 146 | b[2], sizeof (*tr)); |
| 147 | tr->ai = adj_index2; |
| 148 | } |
| 149 | if (PREDICT_FALSE(b[3]->flags & VLIB_BUFFER_IS_TRACED)) |
| 150 | { |
| 151 | adj_midchain_tx_trace_t *tr = vlib_add_trace (vm, node, |
| 152 | b[3], sizeof (*tr)); |
| 153 | tr->ai = adj_index3; |
| 154 | } |
| 155 | } |
| 156 | n_left -= 4; |
| 157 | b += 4; |
| 158 | next += 4; |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 159 | } |
| 160 | |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 161 | while (n_left) |
| 162 | { |
| 163 | const ip_adjacency_t * adj0; |
| 164 | const dpo_id_t *dpo0; |
| 165 | u32 adj_index0; |
| 166 | |
| 167 | /* Follow the DPO on which the midchain is stacked */ |
| 168 | adj_index0 = vnet_buffer(b[0])->ip.adj_index[VLIB_TX]; |
| 169 | adj0 = adj_get(adj_index0); |
| 170 | dpo0 = &adj0->sub_type.midchain.next_dpo; |
| 171 | next[0] = dpo0->dpoi_next_node; |
| 172 | vnet_buffer(b[0])->ip.adj_index[VLIB_TX] = dpo0->dpoi_index; |
| 173 | |
| 174 | if (interface_count) |
| 175 | { |
| 176 | vlib_increment_combined_counter (im->combined_sw_if_counters |
| 177 | + VNET_INTERFACE_COUNTER_TX, |
| 178 | thread_index, |
| 179 | adj0->rewrite_header.sw_if_index, |
| 180 | 1, |
| 181 | vlib_buffer_length_in_chain (vm, b[0])); |
| 182 | } |
| 183 | |
| 184 | if (PREDICT_FALSE(b[0]->flags & VLIB_BUFFER_IS_TRACED)) |
| 185 | { |
| 186 | adj_midchain_tx_trace_t *tr = vlib_add_trace (vm, node, |
| 187 | b[0], sizeof (*tr)); |
| 188 | tr->ai = adj_index0; |
| 189 | } |
| 190 | |
| 191 | n_left -= 1; |
| 192 | b += 1; |
| 193 | next += 1; |
| 194 | } |
| 195 | |
| 196 | vlib_buffer_enqueue_to_next (vm, node, from, nexts, frame->n_vectors); |
| 197 | |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 198 | return frame->n_vectors; |
| 199 | } |
| 200 | |
| 201 | static u8 * |
| 202 | format_adj_midchain_tx_trace (u8 * s, va_list * args) |
| 203 | { |
| 204 | CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *); |
| 205 | CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *); |
| 206 | adj_midchain_tx_trace_t *tr = va_arg (*args, adj_midchain_tx_trace_t*); |
| 207 | |
| 208 | s = format(s, "adj-midchain:[%d]:%U", tr->ai, |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 209 | format_ip_adjacency, tr->ai, |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 210 | FORMAT_IP_ADJACENCY_NONE); |
| 211 | |
| 212 | return (s); |
| 213 | } |
| 214 | |
| 215 | static uword |
| 216 | adj_midchain_tx (vlib_main_t * vm, |
| 217 | vlib_node_runtime_t * node, |
| 218 | vlib_frame_t * frame) |
| 219 | { |
Damjan Marion | 77766a1 | 2016-11-02 01:21:05 +0100 | [diff] [blame] | 220 | return (adj_midchain_tx_inline(vm, node, frame, 1)); |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 221 | } |
| 222 | |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 223 | VLIB_REGISTER_NODE (adj_midchain_tx_node) = { |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 224 | .function = adj_midchain_tx, |
| 225 | .name = "adj-midchain-tx", |
| 226 | .vector_size = sizeof (u32), |
| 227 | |
| 228 | .format_trace = format_adj_midchain_tx_trace, |
| 229 | |
| 230 | .n_next_nodes = 1, |
| 231 | .next_nodes = { |
| 232 | [0] = "error-drop", |
| 233 | }, |
| 234 | }; |
| 235 | |
| 236 | static uword |
| 237 | adj_midchain_tx_no_count (vlib_main_t * vm, |
| 238 | vlib_node_runtime_t * node, |
| 239 | vlib_frame_t * frame) |
| 240 | { |
Damjan Marion | 77766a1 | 2016-11-02 01:21:05 +0100 | [diff] [blame] | 241 | return (adj_midchain_tx_inline(vm, node, frame, 0)); |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 242 | } |
| 243 | |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 244 | VLIB_REGISTER_NODE (adj_midchain_tx_no_count_node) = { |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 245 | .function = adj_midchain_tx_no_count, |
| 246 | .name = "adj-midchain-tx-no-count", |
| 247 | .vector_size = sizeof (u32), |
| 248 | |
| 249 | .format_trace = format_adj_midchain_tx_trace, |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 250 | .sibling_of = "adj-midchain-tx", |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 251 | }; |
| 252 | |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 253 | #ifndef CLIB_MARCH_VARIANT |
| 254 | |
| 255 | u8 |
| 256 | adj_is_midchain (adj_index_t ai) |
| 257 | { |
| 258 | ip_adjacency_t *adj; |
| 259 | |
| 260 | adj = adj_get(ai); |
| 261 | |
| 262 | switch (adj->lookup_next_index) |
| 263 | { |
| 264 | case IP_LOOKUP_NEXT_MIDCHAIN: |
| 265 | case IP_LOOKUP_NEXT_MCAST_MIDCHAIN: |
| 266 | return (1); |
| 267 | case IP_LOOKUP_NEXT_ARP: |
| 268 | case IP_LOOKUP_NEXT_GLEAN: |
| 269 | case IP_LOOKUP_NEXT_BCAST: |
| 270 | case IP_LOOKUP_NEXT_MCAST: |
| 271 | case IP_LOOKUP_NEXT_DROP: |
| 272 | case IP_LOOKUP_NEXT_PUNT: |
| 273 | case IP_LOOKUP_NEXT_LOCAL: |
| 274 | case IP_LOOKUP_NEXT_REWRITE: |
| 275 | case IP_LOOKUP_NEXT_ICMP_ERROR: |
| 276 | case IP_LOOKUP_N_NEXT: |
| 277 | return (0); |
| 278 | } |
| 279 | |
| 280 | return (0); |
| 281 | } |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 282 | |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 283 | static inline u32 |
Neale Ranns | 924d03a | 2016-10-19 08:25:46 +0100 | [diff] [blame] | 284 | adj_get_midchain_node (vnet_link_t link) |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 285 | { |
| 286 | switch (link) { |
Neale Ranns | 924d03a | 2016-10-19 08:25:46 +0100 | [diff] [blame] | 287 | case VNET_LINK_IP4: |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 288 | return (ip4_midchain_node.index); |
Neale Ranns | 924d03a | 2016-10-19 08:25:46 +0100 | [diff] [blame] | 289 | case VNET_LINK_IP6: |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 290 | return (ip6_midchain_node.index); |
Neale Ranns | 924d03a | 2016-10-19 08:25:46 +0100 | [diff] [blame] | 291 | case VNET_LINK_MPLS: |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 292 | return (mpls_midchain_node.index); |
Neale Ranns | 924d03a | 2016-10-19 08:25:46 +0100 | [diff] [blame] | 293 | case VNET_LINK_ETHERNET: |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 294 | return (adj_l2_midchain_node.index); |
Florin Coras | ce1b4c7 | 2017-01-26 14:25:34 -0800 | [diff] [blame] | 295 | case VNET_LINK_NSH: |
| 296 | return (adj_nsh_midchain_node.index); |
Neale Ranns | 924d03a | 2016-10-19 08:25:46 +0100 | [diff] [blame] | 297 | case VNET_LINK_ARP: |
| 298 | break; |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 299 | } |
| 300 | ASSERT(0); |
| 301 | return (0); |
| 302 | } |
| 303 | |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 304 | static u8 |
| 305 | adj_midchain_get_feature_arc_index_for_link_type (const ip_adjacency_t *adj) |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 306 | { |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 307 | u8 arc = (u8) ~0; |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 308 | switch (adj->ia_link) |
| 309 | { |
Neale Ranns | 924d03a | 2016-10-19 08:25:46 +0100 | [diff] [blame] | 310 | case VNET_LINK_IP4: |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 311 | { |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 312 | arc = ip4_main.lookup_main.output_feature_arc_index; |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 313 | break; |
| 314 | } |
Neale Ranns | 924d03a | 2016-10-19 08:25:46 +0100 | [diff] [blame] | 315 | case VNET_LINK_IP6: |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 316 | { |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 317 | arc = ip6_main.lookup_main.output_feature_arc_index; |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 318 | break; |
| 319 | } |
Neale Ranns | 924d03a | 2016-10-19 08:25:46 +0100 | [diff] [blame] | 320 | case VNET_LINK_MPLS: |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 321 | { |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 322 | arc = mpls_main.output_feature_arc_index; |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 323 | break; |
| 324 | } |
Neale Ranns | 924d03a | 2016-10-19 08:25:46 +0100 | [diff] [blame] | 325 | case VNET_LINK_ETHERNET: |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 326 | { |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 327 | arc = ethernet_main.output_feature_arc_index; |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 328 | break; |
| 329 | } |
Florin Coras | ce1b4c7 | 2017-01-26 14:25:34 -0800 | [diff] [blame] | 330 | case VNET_LINK_NSH: |
| 331 | { |
Dave Barach | 11fb09e | 2020-08-06 12:10:09 -0400 | [diff] [blame] | 332 | arc = nsh_main_placeholder.output_feature_arc_index; |
Florin Coras | ce1b4c7 | 2017-01-26 14:25:34 -0800 | [diff] [blame] | 333 | break; |
| 334 | } |
Neale Ranns | 924d03a | 2016-10-19 08:25:46 +0100 | [diff] [blame] | 335 | case VNET_LINK_ARP: |
| 336 | ASSERT(0); |
| 337 | break; |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 338 | } |
| 339 | |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 340 | ASSERT (arc != (u8) ~0); |
| 341 | |
| 342 | return (arc); |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 343 | } |
| 344 | |
Neale Ranns | fa5d198 | 2017-02-20 14:19:51 -0800 | [diff] [blame] | 345 | static u32 |
| 346 | adj_nbr_midchain_get_tx_node (ip_adjacency_t *adj) |
| 347 | { |
| 348 | return ((adj->ia_flags & ADJ_FLAG_MIDCHAIN_NO_COUNT) ? |
| 349 | adj_midchain_tx_no_count_node.index : |
| 350 | adj_midchain_tx_node.index); |
| 351 | } |
| 352 | |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 353 | /** |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 354 | * adj_midchain_setup |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 355 | * |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 356 | * Setup the adj as a mid-chain |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 357 | */ |
| 358 | void |
Neale Ranns | 3ebebc3 | 2020-02-18 13:56:24 +0000 | [diff] [blame] | 359 | adj_midchain_teardown (ip_adjacency_t *adj) |
| 360 | { |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 361 | vlib_main_t *vm = vlib_get_main(); |
Neale Ranns | 3ebebc3 | 2020-02-18 13:56:24 +0000 | [diff] [blame] | 362 | |
| 363 | dpo_reset(&adj->sub_type.midchain.next_dpo); |
| 364 | |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 365 | vlib_worker_thread_barrier_sync(vm); |
Neale Ranns | 5d0136f | 2020-05-12 08:51:02 +0000 | [diff] [blame] | 366 | adj->ia_cfg_index = vnet_feature_modify_end_node( |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 367 | adj_midchain_get_feature_arc_index_for_link_type (adj), |
| 368 | adj->rewrite_header.sw_if_index, |
| 369 | vlib_get_node_by_name (vlib_get_main(), |
| 370 | (u8*) "interface-output")->index); |
| 371 | vlib_worker_thread_barrier_release(vm); |
Neale Ranns | 3ebebc3 | 2020-02-18 13:56:24 +0000 | [diff] [blame] | 372 | } |
| 373 | |
| 374 | /** |
| 375 | * adj_midchain_setup |
| 376 | * |
| 377 | * Setup the adj as a mid-chain |
| 378 | */ |
| 379 | void |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 380 | adj_midchain_setup (adj_index_t adj_index, |
| 381 | adj_midchain_fixup_t fixup, |
Neale Ranns | db14f5a | 2018-01-29 10:43:33 -0800 | [diff] [blame] | 382 | const void *data, |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 383 | adj_flags_t flags) |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 384 | { |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 385 | vlib_main_t *vm = vlib_get_main(); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 386 | ip_adjacency_t *adj; |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 387 | u32 tx_node; |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 388 | |
| 389 | ASSERT(ADJ_INDEX_INVALID != adj_index); |
| 390 | |
| 391 | adj = adj_get(adj_index); |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 392 | |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 393 | adj->sub_type.midchain.fixup_func = fixup; |
Neale Ranns | db14f5a | 2018-01-29 10:43:33 -0800 | [diff] [blame] | 394 | adj->sub_type.midchain.fixup_data = data; |
Neale Ranns | 521a8d7 | 2018-12-06 13:46:49 +0000 | [diff] [blame] | 395 | adj->sub_type.midchain.fei = FIB_NODE_INDEX_INVALID; |
Neale Ranns | fa5d198 | 2017-02-20 14:19:51 -0800 | [diff] [blame] | 396 | adj->ia_flags |= flags; |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 397 | |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 398 | if (flags & ADJ_FLAG_MIDCHAIN_FIXUP_IP4O4_HDR) |
| 399 | { |
| 400 | adj->rewrite_header.flags |= VNET_REWRITE_FIXUP_IP4_O_4; |
| 401 | } |
| 402 | else |
| 403 | { |
| 404 | adj->rewrite_header.flags &= ~VNET_REWRITE_FIXUP_IP4_O_4; |
| 405 | } |
Neale Ranns | 5c544c8 | 2020-11-17 09:47:07 +0000 | [diff] [blame] | 406 | if (!(flags & ADJ_FLAG_MIDCHAIN_FIXUP_FLOW_HASH)) |
| 407 | { |
| 408 | adj->rewrite_header.flags &= ~VNET_REWRITE_FIXUP_FLOW_HASH; |
| 409 | } |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 410 | |
Neale Ranns | fa5d198 | 2017-02-20 14:19:51 -0800 | [diff] [blame] | 411 | tx_node = adj_nbr_midchain_get_tx_node(adj); |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 412 | |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 413 | vlib_worker_thread_barrier_sync(vm); |
Neale Ranns | 5d0136f | 2020-05-12 08:51:02 +0000 | [diff] [blame] | 414 | adj->ia_cfg_index = vnet_feature_modify_end_node( |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 415 | adj_midchain_get_feature_arc_index_for_link_type (adj), |
| 416 | adj->rewrite_header.sw_if_index, |
| 417 | tx_node); |
| 418 | vlib_worker_thread_barrier_release(vm); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 419 | |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 420 | /* |
| 421 | * stack the midchain on the drop so it's ready to forward in the adj-midchain-tx. |
| 422 | * The graph arc used/created here is from the midchain-tx node to the |
| 423 | * child's registered node. This is because post adj processing the next |
| 424 | * node are any output features, then the midchain-tx. from there we |
| 425 | * need to get to the stacked child's node. |
| 426 | */ |
Neale Ranns | fa5d198 | 2017-02-20 14:19:51 -0800 | [diff] [blame] | 427 | dpo_stack_from_node(tx_node, |
Neale Ranns | 43161a8 | 2017-08-12 02:12:00 -0700 | [diff] [blame] | 428 | &adj->sub_type.midchain.next_dpo, |
| 429 | drop_dpo_get(vnet_link_to_dpo_proto(adj->ia_link))); |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 430 | } |
| 431 | |
| 432 | /** |
| 433 | * adj_nbr_midchain_update_rewrite |
| 434 | * |
| 435 | * Update the adjacency's rewrite string. A NULL string implies the |
Paul Vinciguerra | 8feeaff | 2019-03-27 11:25:48 -0700 | [diff] [blame] | 436 | * rewrite is reset (i.e. when ARP/ND entry is gone). |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 437 | * NB: the adj being updated may be handling traffic in the DP. |
| 438 | */ |
| 439 | void |
| 440 | adj_nbr_midchain_update_rewrite (adj_index_t adj_index, |
| 441 | adj_midchain_fixup_t fixup, |
Neale Ranns | db14f5a | 2018-01-29 10:43:33 -0800 | [diff] [blame] | 442 | const void *fixup_data, |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 443 | adj_flags_t flags, |
| 444 | u8 *rewrite) |
| 445 | { |
| 446 | ip_adjacency_t *adj; |
| 447 | |
| 448 | ASSERT(ADJ_INDEX_INVALID != adj_index); |
| 449 | |
| 450 | adj = adj_get(adj_index); |
| 451 | |
| 452 | /* |
Paul Vinciguerra | 8feeaff | 2019-03-27 11:25:48 -0700 | [diff] [blame] | 453 | * one time only update. since we don't support changing the tunnel |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 454 | * src,dst, this is all we need. |
| 455 | */ |
Neale Ranns | 174959c | 2020-02-03 10:33:51 +0000 | [diff] [blame] | 456 | if (adj->lookup_next_index != IP_LOOKUP_NEXT_MIDCHAIN && |
Neale Ranns | 14053c9 | 2019-12-29 23:55:18 +0000 | [diff] [blame] | 457 | adj->lookup_next_index != IP_LOOKUP_NEXT_MCAST_MIDCHAIN) |
| 458 | { |
| 459 | adj_midchain_setup(adj_index, fixup, fixup_data, flags); |
| 460 | } |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 461 | |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 462 | /* |
Paul Vinciguerra | 8feeaff | 2019-03-27 11:25:48 -0700 | [diff] [blame] | 463 | * update the rewrite with the workers paused. |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 464 | */ |
| 465 | adj_nbr_update_rewrite_internal(adj, |
| 466 | IP_LOOKUP_NEXT_MIDCHAIN, |
| 467 | adj_get_midchain_node(adj->ia_link), |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 468 | adj_nbr_midchain_get_tx_node(adj), |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 469 | rewrite); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 470 | } |
| 471 | |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 472 | void |
| 473 | adj_nbr_midchain_update_next_node (adj_index_t adj_index, |
| 474 | u32 next_node) |
| 475 | { |
| 476 | ip_adjacency_t *adj; |
| 477 | vlib_main_t * vm; |
| 478 | |
| 479 | ASSERT(ADJ_INDEX_INVALID != adj_index); |
| 480 | |
| 481 | adj = adj_get(adj_index); |
| 482 | vm = vlib_get_main(); |
| 483 | |
| 484 | vlib_worker_thread_barrier_sync(vm); |
| 485 | |
| 486 | adj->rewrite_header.next_index = vlib_node_add_next(vlib_get_main(), |
| 487 | adj->ia_node_index, |
| 488 | next_node); |
| 489 | |
Neale Ranns | 5d0136f | 2020-05-12 08:51:02 +0000 | [diff] [blame] | 490 | adj->ia_cfg_index = vnet_feature_modify_end_node( |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 491 | adj_midchain_get_feature_arc_index_for_link_type (adj), |
| 492 | adj->rewrite_header.sw_if_index, |
| 493 | next_node); |
| 494 | |
| 495 | vlib_worker_thread_barrier_release(vm); |
| 496 | } |
| 497 | |
| 498 | void |
Neale Ranns | 5d0136f | 2020-05-12 08:51:02 +0000 | [diff] [blame] | 499 | adj_nbr_midchain_reset_next_node (adj_index_t adj_index) |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 500 | { |
| 501 | ip_adjacency_t *adj; |
| 502 | vlib_main_t * vm; |
| 503 | |
| 504 | ASSERT(ADJ_INDEX_INVALID != adj_index); |
| 505 | |
| 506 | adj = adj_get(adj_index); |
| 507 | vm = vlib_get_main(); |
| 508 | |
| 509 | vlib_worker_thread_barrier_sync(vm); |
| 510 | |
| 511 | adj->rewrite_header.next_index = |
| 512 | vlib_node_add_next(vlib_get_main(), |
| 513 | adj->ia_node_index, |
| 514 | adj_nbr_midchain_get_tx_node(adj)); |
| 515 | |
Neale Ranns | 5d0136f | 2020-05-12 08:51:02 +0000 | [diff] [blame] | 516 | adj->ia_cfg_index = vnet_feature_modify_end_node( |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 517 | adj_midchain_get_feature_arc_index_for_link_type (adj), |
| 518 | adj->rewrite_header.sw_if_index, |
| 519 | adj_nbr_midchain_get_tx_node(adj)); |
| 520 | |
| 521 | vlib_worker_thread_barrier_release(vm); |
| 522 | } |
| 523 | |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 524 | /** |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 525 | * adj_nbr_midchain_unstack |
| 526 | * |
| 527 | * Unstack the adj. stack it on drop |
| 528 | */ |
| 529 | void |
| 530 | adj_nbr_midchain_unstack (adj_index_t adj_index) |
| 531 | { |
Neale Ranns | 521a8d7 | 2018-12-06 13:46:49 +0000 | [diff] [blame] | 532 | fib_node_index_t *entry_indicies, tmp; |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 533 | ip_adjacency_t *adj; |
| 534 | |
| 535 | ASSERT(ADJ_INDEX_INVALID != adj_index); |
Neale Ranns | 521a8d7 | 2018-12-06 13:46:49 +0000 | [diff] [blame] | 536 | adj = adj_get (adj_index); |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 537 | |
Neale Ranns | 521a8d7 | 2018-12-06 13:46:49 +0000 | [diff] [blame] | 538 | /* |
| 539 | * check to see if this unstacking breaks a recursion loop |
| 540 | */ |
| 541 | entry_indicies = NULL; |
| 542 | tmp = adj->sub_type.midchain.fei; |
| 543 | adj->sub_type.midchain.fei = FIB_NODE_INDEX_INVALID; |
| 544 | |
| 545 | if (FIB_NODE_INDEX_INVALID != tmp) |
| 546 | { |
| 547 | fib_entry_recursive_loop_detect(tmp, &entry_indicies); |
| 548 | vec_free(entry_indicies); |
| 549 | } |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 550 | |
| 551 | /* |
| 552 | * stack on the drop |
| 553 | */ |
| 554 | dpo_stack(DPO_ADJACENCY_MIDCHAIN, |
Neale Ranns | 43161a8 | 2017-08-12 02:12:00 -0700 | [diff] [blame] | 555 | vnet_link_to_dpo_proto(adj->ia_link), |
| 556 | &adj->sub_type.midchain.next_dpo, |
| 557 | drop_dpo_get(vnet_link_to_dpo_proto(adj->ia_link))); |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 558 | CLIB_MEMORY_BARRIER(); |
| 559 | } |
| 560 | |
Neale Ranns | 521a8d7 | 2018-12-06 13:46:49 +0000 | [diff] [blame] | 561 | void |
| 562 | adj_nbr_midchain_stack_on_fib_entry (adj_index_t ai, |
| 563 | fib_node_index_t fei, |
| 564 | fib_forward_chain_type_t fct) |
| 565 | { |
| 566 | fib_node_index_t *entry_indicies; |
| 567 | dpo_id_t tmp = DPO_INVALID; |
| 568 | ip_adjacency_t *adj; |
| 569 | |
| 570 | adj = adj_get (ai); |
| 571 | |
| 572 | /* |
| 573 | * check to see if this stacking will form a recursion loop |
| 574 | */ |
| 575 | entry_indicies = NULL; |
| 576 | adj->sub_type.midchain.fei = fei; |
| 577 | |
| 578 | if (fib_entry_recursive_loop_detect(adj->sub_type.midchain.fei, &entry_indicies)) |
| 579 | { |
| 580 | /* |
| 581 | * loop formed, stack on the drop. |
| 582 | */ |
| 583 | dpo_copy(&tmp, drop_dpo_get(fib_forw_chain_type_to_dpo_proto(fct))); |
| 584 | } |
| 585 | else |
| 586 | { |
| 587 | fib_entry_contribute_forwarding (fei, fct, &tmp); |
| 588 | |
Neale Ranns | 5c544c8 | 2020-11-17 09:47:07 +0000 | [diff] [blame] | 589 | if (DPO_LOAD_BALANCE == tmp.dpoi_type) |
Neale Ranns | 521a8d7 | 2018-12-06 13:46:49 +0000 | [diff] [blame] | 590 | { |
Neale Ranns | 521a8d7 | 2018-12-06 13:46:49 +0000 | [diff] [blame] | 591 | load_balance_t *lb; |
Neale Ranns | 521a8d7 | 2018-12-06 13:46:49 +0000 | [diff] [blame] | 592 | |
| 593 | lb = load_balance_get (tmp.dpoi_index); |
| 594 | |
Neale Ranns | 5c544c8 | 2020-11-17 09:47:07 +0000 | [diff] [blame] | 595 | if ((adj->ia_flags & ADJ_FLAG_MIDCHAIN_IP_STACK) || |
| 596 | lb->lb_n_buckets == 1) |
Neale Ranns | 521a8d7 | 2018-12-06 13:46:49 +0000 | [diff] [blame] | 597 | { |
Neale Ranns | 5c544c8 | 2020-11-17 09:47:07 +0000 | [diff] [blame] | 598 | /* |
| 599 | * do that hash now and stack on the choice. |
| 600 | * If the choice is an incomplete adj then we will need a poke when |
| 601 | * it becomes complete. This happens since the adj update walk propagates |
| 602 | * as far a recursive paths. |
| 603 | */ |
| 604 | const dpo_id_t *choice; |
| 605 | int hash; |
Neale Ranns | 521a8d7 | 2018-12-06 13:46:49 +0000 | [diff] [blame] | 606 | |
Neale Ranns | 5c544c8 | 2020-11-17 09:47:07 +0000 | [diff] [blame] | 607 | if (FIB_FORW_CHAIN_TYPE_UNICAST_IP4 == fct) |
| 608 | { |
| 609 | hash = ip4_compute_flow_hash ((ip4_header_t *) adj_get_rewrite (ai), |
| 610 | lb->lb_hash_config); |
| 611 | } |
| 612 | else if (FIB_FORW_CHAIN_TYPE_UNICAST_IP6 == fct) |
| 613 | { |
| 614 | hash = ip6_compute_flow_hash ((ip6_header_t *) adj_get_rewrite (ai), |
| 615 | lb->lb_hash_config); |
| 616 | } |
| 617 | else |
| 618 | { |
| 619 | hash = 0; |
| 620 | ASSERT(0); |
| 621 | } |
| 622 | |
| 623 | choice = load_balance_get_bucket_i (lb, hash & lb->lb_n_buckets_minus_1); |
| 624 | dpo_copy (&tmp, choice); |
| 625 | } |
| 626 | else if (adj->ia_flags & ADJ_FLAG_MIDCHAIN_FIXUP_FLOW_HASH) |
| 627 | { |
| 628 | adj->rewrite_header.flags |= VNET_REWRITE_FIXUP_FLOW_HASH; |
| 629 | } |
Neale Ranns | 521a8d7 | 2018-12-06 13:46:49 +0000 | [diff] [blame] | 630 | } |
| 631 | } |
| 632 | adj_nbr_midchain_stack (ai, &tmp); |
| 633 | dpo_reset(&tmp); |
| 634 | vec_free(entry_indicies); |
| 635 | } |
| 636 | |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 637 | /** |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 638 | * adj_nbr_midchain_stack |
| 639 | */ |
| 640 | void |
| 641 | adj_nbr_midchain_stack (adj_index_t adj_index, |
| 642 | const dpo_id_t *next) |
| 643 | { |
| 644 | ip_adjacency_t *adj; |
| 645 | |
| 646 | ASSERT(ADJ_INDEX_INVALID != adj_index); |
| 647 | |
| 648 | adj = adj_get(adj_index); |
| 649 | |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 650 | ASSERT((IP_LOOKUP_NEXT_MIDCHAIN == adj->lookup_next_index) || |
| 651 | (IP_LOOKUP_NEXT_MCAST_MIDCHAIN == adj->lookup_next_index)); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 652 | |
Neale Ranns | fa5d198 | 2017-02-20 14:19:51 -0800 | [diff] [blame] | 653 | dpo_stack_from_node(adj_nbr_midchain_get_tx_node(adj), |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 654 | &adj->sub_type.midchain.next_dpo, |
| 655 | next); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 656 | } |
| 657 | |
Neale Ranns | 521a8d7 | 2018-12-06 13:46:49 +0000 | [diff] [blame] | 658 | int |
| 659 | adj_ndr_midchain_recursive_loop_detect (adj_index_t ai, |
| 660 | fib_node_index_t **entry_indicies) |
| 661 | { |
| 662 | fib_node_index_t *entry_index, *entries; |
| 663 | ip_adjacency_t * adj; |
| 664 | |
| 665 | adj = adj_get(ai); |
| 666 | entries = *entry_indicies; |
| 667 | |
| 668 | vec_foreach(entry_index, entries) |
| 669 | { |
| 670 | if (*entry_index == adj->sub_type.midchain.fei) |
| 671 | { |
| 672 | /* |
| 673 | * The entry this midchain links to is already in the set |
Paul Vinciguerra | 8feeaff | 2019-03-27 11:25:48 -0700 | [diff] [blame] | 674 | * of visited entries, this is a loop |
Neale Ranns | 521a8d7 | 2018-12-06 13:46:49 +0000 | [diff] [blame] | 675 | */ |
| 676 | adj->ia_flags |= ADJ_FLAG_MIDCHAIN_LOOPED; |
| 677 | return (1); |
| 678 | } |
| 679 | } |
| 680 | |
| 681 | adj->ia_flags &= ~ADJ_FLAG_MIDCHAIN_LOOPED; |
| 682 | return (0); |
| 683 | } |
| 684 | |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 685 | u8* |
| 686 | format_adj_midchain (u8* s, va_list *ap) |
| 687 | { |
Billy McFall | cfcf1e2 | 2016-10-14 09:51:49 -0400 | [diff] [blame] | 688 | index_t index = va_arg(*ap, index_t); |
| 689 | u32 indent = va_arg(*ap, u32); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 690 | ip_adjacency_t * adj = adj_get(index); |
| 691 | |
Neale Ranns | 924d03a | 2016-10-19 08:25:46 +0100 | [diff] [blame] | 692 | s = format (s, "%U", format_vnet_link, adj->ia_link); |
Neale Ranns | 25edf14 | 2019-03-22 08:12:48 +0000 | [diff] [blame] | 693 | if (adj->rewrite_header.flags & VNET_REWRITE_HAS_FEATURES) |
| 694 | s = format(s, " [features]"); |
Neale Ranns | c819fc6 | 2018-02-16 02:44:05 -0800 | [diff] [blame] | 695 | s = format (s, " via %U", |
| 696 | format_ip46_address, &adj->sub_type.nbr.next_hop, |
| 697 | adj_proto_to_46(adj->ia_nh_proto)); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 698 | s = format (s, " %U", |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 699 | format_vnet_rewrite, |
Neale Ranns | b069a69 | 2017-03-15 12:34:25 -0400 | [diff] [blame] | 700 | &adj->rewrite_header, sizeof (adj->rewrite_data), indent); |
Neale Ranns | 521a8d7 | 2018-12-06 13:46:49 +0000 | [diff] [blame] | 701 | s = format (s, "\n%Ustacked-on", |
| 702 | format_white_space, indent); |
| 703 | |
| 704 | if (FIB_NODE_INDEX_INVALID != adj->sub_type.midchain.fei) |
| 705 | { |
| 706 | s = format (s, " entry:%d", adj->sub_type.midchain.fei); |
| 707 | |
| 708 | } |
| 709 | s = format (s, ":\n%U%U", |
Neale Ranns | 43161a8 | 2017-08-12 02:12:00 -0700 | [diff] [blame] | 710 | format_white_space, indent+2, |
| 711 | format_dpo_id, &adj->sub_type.midchain.next_dpo, indent+2); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 712 | |
| 713 | return (s); |
| 714 | } |
| 715 | |
| 716 | static void |
| 717 | adj_dpo_lock (dpo_id_t *dpo) |
| 718 | { |
| 719 | adj_lock(dpo->dpoi_index); |
| 720 | } |
| 721 | static void |
| 722 | adj_dpo_unlock (dpo_id_t *dpo) |
| 723 | { |
| 724 | adj_unlock(dpo->dpoi_index); |
| 725 | } |
| 726 | |
| 727 | const static dpo_vft_t adj_midchain_dpo_vft = { |
| 728 | .dv_lock = adj_dpo_lock, |
| 729 | .dv_unlock = adj_dpo_unlock, |
| 730 | .dv_format = format_adj_midchain, |
Andrew Yourtchenko | 5f3fcb9 | 2017-10-25 05:50:37 -0700 | [diff] [blame] | 731 | .dv_get_urpf = adj_dpo_get_urpf, |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 732 | }; |
| 733 | |
| 734 | /** |
| 735 | * @brief The per-protocol VLIB graph nodes that are assigned to a midchain |
| 736 | * object. |
| 737 | * |
| 738 | * this means that these graph nodes are ones from which a midchain is the |
| 739 | * parent object in the DPO-graph. |
| 740 | */ |
| 741 | const static char* const midchain_ip4_nodes[] = |
| 742 | { |
| 743 | "ip4-midchain", |
| 744 | NULL, |
| 745 | }; |
| 746 | const static char* const midchain_ip6_nodes[] = |
| 747 | { |
| 748 | "ip6-midchain", |
| 749 | NULL, |
| 750 | }; |
| 751 | const static char* const midchain_mpls_nodes[] = |
| 752 | { |
| 753 | "mpls-midchain", |
| 754 | NULL, |
| 755 | }; |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 756 | const static char* const midchain_ethernet_nodes[] = |
| 757 | { |
| 758 | "adj-l2-midchain", |
| 759 | NULL, |
| 760 | }; |
Florin Coras | b69111e | 2017-02-13 23:55:27 -0800 | [diff] [blame] | 761 | const static char* const midchain_nsh_nodes[] = |
| 762 | { |
| 763 | "adj-nsh-midchain", |
| 764 | NULL, |
| 765 | }; |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 766 | |
| 767 | const static char* const * const midchain_nodes[DPO_PROTO_NUM] = |
| 768 | { |
| 769 | [DPO_PROTO_IP4] = midchain_ip4_nodes, |
| 770 | [DPO_PROTO_IP6] = midchain_ip6_nodes, |
| 771 | [DPO_PROTO_MPLS] = midchain_mpls_nodes, |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 772 | [DPO_PROTO_ETHERNET] = midchain_ethernet_nodes, |
Florin Coras | b69111e | 2017-02-13 23:55:27 -0800 | [diff] [blame] | 773 | [DPO_PROTO_NSH] = midchain_nsh_nodes, |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 774 | }; |
| 775 | |
| 776 | void |
| 777 | adj_midchain_module_init (void) |
| 778 | { |
| 779 | dpo_register(DPO_ADJACENCY_MIDCHAIN, &adj_midchain_dpo_vft, midchain_nodes); |
| 780 | } |
Neale Ranns | 4ec36c5 | 2020-03-31 09:21:29 -0400 | [diff] [blame] | 781 | |
| 782 | #endif |