Line data Source code
1 : /*
2 : * Copyright (c) 2015 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 : * ip/ip4_forward.c: IP v4 forwarding
17 : *
18 : * Copyright (c) 2008 Eliot Dresselhaus
19 : *
20 : * Permission is hereby granted, free of charge, to any person obtaining
21 : * a copy of this software and associated documentation files (the
22 : * "Software"), to deal in the Software without restriction, including
23 : * without limitation the rights to use, copy, modify, merge, publish,
24 : * distribute, sublicense, and/or sell copies of the Software, and to
25 : * permit persons to whom the Software is furnished to do so, subject to
26 : * the following conditions:
27 : *
28 : * The above copyright notice and this permission notice shall be
29 : * included in all copies or substantial portions of the Software.
30 : *
31 : * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
32 : * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
33 : * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
34 : * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
35 : * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
36 : * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
37 : * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
38 : */
39 :
40 : #include <vnet/ip-neighbor/ip4_neighbor.h>
41 : #include <vnet/ip-neighbor/ip_neighbor.api_enum.h>
42 : #include <vnet/ethernet/ethernet.h>
43 : #include <vnet/util/throttle.h>
44 : #include <vnet/fib/fib_sas.h>
45 : #include <vnet/ip/ip_sas.h>
46 :
47 : /** ARP throttling */
48 : static throttle_t arp_throttle;
49 :
50 559 : VLIB_REGISTER_LOG_CLASS (ip4_neighbor_log, static) = {
51 : .class_name = "ip4",
52 : .subclass_name = "neighbor",
53 : };
54 :
55 : #define log_debug(fmt, ...) \
56 : vlib_log_debug (ip4_neighbor_log.class, fmt, __VA_ARGS__)
57 :
58 : void
59 811 : ip4_neighbor_probe_dst (u32 sw_if_index, u32 thread_index,
60 : const ip4_address_t *dst)
61 : {
62 : ip4_address_t src;
63 : adj_index_t ai;
64 :
65 : /* any glean will do, it's just for the rewrite */
66 811 : ai = adj_glean_get (FIB_PROTOCOL_IP4, sw_if_index, NULL);
67 :
68 1591 : if (ADJ_INDEX_INVALID != ai &&
69 833 : (fib_sas4_get (sw_if_index, dst, &src) ||
70 53 : ip4_sas_by_sw_if_index (sw_if_index, dst, &src)))
71 780 : ip4_neighbor_probe (vlib_get_main (),
72 780 : vnet_get_main (), adj_get (ai), &src, dst);
73 811 : }
74 :
75 : void
76 12 : ip4_neighbor_advertise (vlib_main_t *vm, vnet_main_t *vnm, u32 sw_if_index,
77 : u32 thread_index, const ip4_address_t *addr)
78 : {
79 12 : vnet_hw_interface_t *hi = vnet_get_sup_hw_interface (vnm, sw_if_index);
80 12 : ip4_main_t *i4m = &ip4_main;
81 : u8 *rewrite, rewrite_len;
82 : ip4_address_t tmp;
83 :
84 12 : if (NULL == addr)
85 : {
86 0 : if (fib_sas4_get (sw_if_index, NULL, &tmp) ||
87 0 : ip4_sas_by_sw_if_index (sw_if_index, NULL, &tmp))
88 0 : addr = &tmp;
89 : }
90 :
91 12 : if (addr)
92 : {
93 12 : log_debug ("Sending GARP for IP4 address %U on sw_if_idex %d",
94 : format_ip4_address, addr, sw_if_index);
95 :
96 : /* Form GARP packet for output - Gratuitous ARP is an ARP request packet
97 : where the interface IP/MAC pair is used for both source and request
98 : MAC/IP pairs in the request */
99 12 : u32 bi = 0;
100 12 : ethernet_arp_header_t *h = vlib_packet_template_get_packet
101 : (vm, &i4m->ip4_arp_request_packet_template, &bi);
102 :
103 12 : if (!h)
104 0 : return;
105 :
106 12 : mac_address_from_bytes (&h->ip4_over_ethernet[0].mac, hi->hw_address);
107 12 : mac_address_from_bytes (&h->ip4_over_ethernet[1].mac, hi->hw_address);
108 12 : h->ip4_over_ethernet[0].ip4 = addr[0];
109 12 : h->ip4_over_ethernet[1].ip4 = addr[0];
110 :
111 : /* Setup MAC header with ARP Etype and broadcast DMAC */
112 12 : vlib_buffer_t *b = vlib_get_buffer (vm, bi);
113 12 : rewrite =
114 12 : ethernet_build_rewrite (vnm, sw_if_index, VNET_LINK_ARP,
115 : VNET_REWRITE_FOR_SW_INTERFACE_ADDRESS_BROADCAST);
116 12 : rewrite_len = vec_len (rewrite);
117 12 : vlib_buffer_advance (b, -rewrite_len);
118 12 : ethernet_header_t *e = vlib_buffer_get_current (b);
119 12 : clib_memcpy_fast (e->dst_address, rewrite, rewrite_len);
120 12 : vec_free (rewrite);
121 :
122 : /* Send GARP packet out the specified interface */
123 12 : vnet_buffer (b)->sw_if_index[VLIB_RX] =
124 12 : vnet_buffer (b)->sw_if_index[VLIB_TX] = sw_if_index;
125 12 : vlib_frame_t *f = vlib_get_frame_to_node (vm, hi->output_node_index);
126 12 : u32 *to_next = vlib_frame_vector_args (f);
127 12 : to_next[0] = bi;
128 12 : f->n_vectors = 1;
129 12 : vlib_put_frame_to_node (vm, hi->output_node_index, f);
130 :
131 12 : vlib_increment_simple_counter (
132 : &ip_neighbor_counters[AF_IP4].ipnc[VLIB_TX][IP_NEIGHBOR_CTR_GRAT],
133 : thread_index, sw_if_index, 1);
134 : }
135 : }
136 :
137 : always_inline uword
138 62 : ip4_arp_inline (vlib_main_t * vm,
139 : vlib_node_runtime_t * node,
140 : vlib_frame_t * frame, int is_glean)
141 : {
142 62 : vnet_main_t *vnm = vnet_get_main ();
143 : u32 *from, *to_next_drop;
144 : uword n_left_from, n_left_to_next_drop, next_index;
145 62 : u32 thread_index = vm->thread_index;
146 : u64 seed;
147 :
148 62 : if (node->flags & VLIB_NODE_FLAG_TRACE)
149 33 : ip4_forward_next_trace (vm, node, frame, VLIB_TX);
150 :
151 62 : seed = throttle_seed (&arp_throttle, thread_index, vlib_time_now (vm));
152 :
153 62 : from = vlib_frame_vector_args (frame);
154 62 : n_left_from = frame->n_vectors;
155 62 : next_index = node->cached_next_index;
156 62 : if (next_index == IP4_ARP_NEXT_DROP)
157 62 : next_index = IP4_ARP_N_NEXT; /* point to first interface */
158 :
159 124 : while (n_left_from > 0)
160 : {
161 62 : vlib_get_next_frame (vm, node, IP4_ARP_NEXT_DROP,
162 : to_next_drop, n_left_to_next_drop);
163 :
164 379 : while (n_left_from > 0 && n_left_to_next_drop > 0)
165 : {
166 : u32 pi0, adj_index0, sw_if_index0;
167 : ip4_address_t resolve0, src0;
168 : vlib_buffer_t *p0, *b0;
169 : ip_adjacency_t *adj0;
170 : u64 r0;
171 :
172 317 : pi0 = from[0];
173 317 : p0 = vlib_get_buffer (vm, pi0);
174 :
175 317 : from += 1;
176 317 : n_left_from -= 1;
177 317 : to_next_drop[0] = pi0;
178 317 : to_next_drop += 1;
179 317 : n_left_to_next_drop -= 1;
180 :
181 317 : adj_index0 = vnet_buffer (p0)->ip.adj_index[VLIB_TX];
182 317 : adj0 = adj_get (adj_index0);
183 317 : sw_if_index0 = adj0->rewrite_header.sw_if_index;
184 :
185 317 : if (is_glean)
186 : {
187 : /* resolve the packet's destination */
188 46 : ip4_header_t *ip0 = vlib_buffer_get_current (p0);
189 46 : resolve0 = ip0->dst_address;
190 46 : src0 = adj0->sub_type.glean.rx_pfx.fp_addr.ip4;
191 : }
192 : else
193 : {
194 : /* resolve the incomplete adj */
195 271 : resolve0 = adj0->sub_type.nbr.next_hop.ip4;
196 : /* Src IP address in ARP header. */
197 271 : if (!fib_sas4_get (sw_if_index0, &resolve0, &src0) &&
198 0 : !ip4_sas_by_sw_if_index (sw_if_index0, &resolve0, &src0))
199 : {
200 : /* No source address available */
201 0 : p0->error =
202 0 : node->errors[IP4_NEIGHBOR_ERROR_NO_SOURCE_ADDRESS];
203 255 : continue;
204 : }
205 : }
206 :
207 : /* combine the address and interface for the hash key */
208 317 : r0 = (u64) resolve0.data_u32 << 32;
209 317 : r0 |= sw_if_index0;
210 :
211 317 : if (throttle_check (&arp_throttle, thread_index, r0, seed))
212 : {
213 255 : p0->error = node->errors[IP4_NEIGHBOR_ERROR_THROTTLED];
214 255 : continue;
215 : }
216 :
217 : /*
218 : * the adj has been updated to a rewrite but the node the DPO that got
219 : * us here hasn't - yet. no big deal. we'll drop while we wait.
220 : */
221 62 : if (IP_LOOKUP_NEXT_REWRITE == adj0->lookup_next_index)
222 : {
223 0 : p0->error = node->errors[IP4_NEIGHBOR_ERROR_RESOLVED];
224 0 : continue;
225 : }
226 :
227 : /*
228 : * Can happen if the control-plane is programming tables
229 : * with traffic flowing; at least that's today's lame excuse.
230 : */
231 62 : if ((is_glean && adj0->lookup_next_index != IP_LOOKUP_NEXT_GLEAN)
232 62 : || (!is_glean && adj0->lookup_next_index != IP_LOOKUP_NEXT_ARP))
233 : {
234 0 : p0->error = node->errors[IP4_NEIGHBOR_ERROR_NON_ARP_ADJ];
235 0 : continue;
236 : }
237 :
238 : /* Send ARP request. */
239 62 : b0 = ip4_neighbor_probe (vm, vnm, adj0, &src0, &resolve0);
240 :
241 62 : if (PREDICT_TRUE (NULL != b0))
242 : {
243 : /* copy the persistent fields from the original */
244 62 : clib_memcpy_fast (b0->opaque2, p0->opaque2,
245 : sizeof (p0->opaque2));
246 62 : p0->error = node->errors[IP4_NEIGHBOR_ERROR_REQUEST_SENT];
247 : }
248 : else
249 : {
250 0 : p0->error = node->errors[IP4_NEIGHBOR_ERROR_NO_BUFFERS];
251 0 : continue;
252 : }
253 : }
254 :
255 62 : vlib_put_next_frame (vm, node, IP4_ARP_NEXT_DROP, n_left_to_next_drop);
256 : }
257 :
258 62 : return frame->n_vectors;
259 : }
260 :
261 575 : VLIB_NODE_FN (ip4_arp_node) (vlib_main_t * vm, vlib_node_runtime_t * node,
262 : vlib_frame_t * frame)
263 : {
264 16 : return (ip4_arp_inline (vm, node, frame, 0));
265 : }
266 :
267 605 : VLIB_NODE_FN (ip4_glean_node) (vlib_main_t * vm, vlib_node_runtime_t * node,
268 : vlib_frame_t * frame)
269 : {
270 46 : return (ip4_arp_inline (vm, node, frame, 1));
271 : }
272 :
273 : /* *INDENT-OFF* */
274 178120 : VLIB_REGISTER_NODE (ip4_arp_node) =
275 : {
276 : .name = "ip4-arp",
277 : .vector_size = sizeof (u32),
278 : .format_trace = format_ip4_forward_next_trace,
279 : .n_errors = IP4_NEIGHBOR_N_ERROR,
280 : .error_counters = ip4_neighbor_error_counters,
281 : .n_next_nodes = IP4_ARP_N_NEXT,
282 : .next_nodes = {
283 : [IP4_ARP_NEXT_DROP] = "ip4-drop",
284 : },
285 : };
286 :
287 178120 : VLIB_REGISTER_NODE (ip4_glean_node) =
288 : {
289 : .name = "ip4-glean",
290 : .vector_size = sizeof (u32),
291 : .format_trace = format_ip4_forward_next_trace,
292 : .n_errors = IP4_NEIGHBOR_N_ERROR,
293 : .error_counters = ip4_neighbor_error_counters,
294 : .n_next_nodes = IP4_ARP_N_NEXT,
295 : .next_nodes = {
296 : [IP4_ARP_NEXT_DROP] = "ip4-drop",
297 : },
298 : };
299 : /* *INDENT-ON* */
300 :
301 : #define foreach_notrace_ip4_arp_error \
302 : _(THROTTLED) \
303 : _(RESOLVED) \
304 : _(NO_BUFFERS) \
305 : _(REQUEST_SENT) \
306 : _(NON_ARP_ADJ) \
307 : _(NO_SOURCE_ADDRESS)
308 :
309 : static clib_error_t *
310 559 : arp_notrace_init (vlib_main_t * vm)
311 : {
312 559 : vlib_node_runtime_t *rt = vlib_node_get_runtime (vm, ip4_arp_node.index);
313 :
314 : /* don't trace ARP request packets */
315 : #define _(a) \
316 : vnet_pcap_drop_trace_filter_add_del (rt->errors[IP4_NEIGHBOR_ERROR_##a], \
317 : 1 /* is_add */);
318 559 : foreach_notrace_ip4_arp_error;
319 : #undef _
320 559 : return 0;
321 : }
322 :
323 48159 : VLIB_INIT_FUNCTION (arp_notrace_init);
324 :
325 : static clib_error_t *
326 559 : ip4_neighbor_main_loop_enter (vlib_main_t * vm)
327 : {
328 559 : vlib_thread_main_t *tm = &vlib_thread_main;
329 559 : u32 n_vlib_mains = tm->n_vlib_mains;
330 :
331 559 : throttle_init (&arp_throttle, n_vlib_mains, THROTTLE_BITS, 1e-3);
332 :
333 559 : return (NULL);
334 : }
335 :
336 1119 : VLIB_MAIN_LOOP_ENTER_FUNCTION (ip4_neighbor_main_loop_enter);
337 :
338 :
339 : /*
340 : * fd.io coding-style-patch-verification: ON
341 : *
342 : * Local Variables:
343 : * eval: (c-set-style "gnu")
344 : * End:
345 : */
|
