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 575 : 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 810 : 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 810 : ai = adj_glean_get (FIB_PROTOCOL_IP4, sw_if_index, NULL);
67 :
68 1589 : if (ADJ_INDEX_INVALID != ai &&
69 832 : (fib_sas4_get (sw_if_index, dst, &src) ||
70 53 : ip4_sas_by_sw_if_index (sw_if_index, dst, &src)))
71 779 : ip4_neighbor_probe (vlib_get_main (),
72 779 : vnet_get_main (), adj_get (ai), &src, dst);
73 810 : }
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 77 : ip4_arp_inline (vlib_main_t * vm,
139 : vlib_node_runtime_t * node,
140 : vlib_frame_t * frame, int is_glean)
141 : {
142 77 : 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 77 : u32 thread_index = vm->thread_index;
146 : u64 seed;
147 :
148 77 : if (node->flags & VLIB_NODE_FLAG_TRACE)
149 37 : ip4_forward_next_trace (vm, node, frame, VLIB_TX);
150 :
151 77 : seed = throttle_seed (&arp_throttle, thread_index, vlib_time_now (vm));
152 :
153 77 : from = vlib_frame_vector_args (frame);
154 77 : n_left_from = frame->n_vectors;
155 77 : next_index = node->cached_next_index;
156 77 : if (next_index == IP4_ARP_NEXT_DROP)
157 77 : next_index = IP4_ARP_N_NEXT; /* point to first interface */
158 :
159 154 : while (n_left_from > 0)
160 : {
161 77 : vlib_get_next_frame (vm, node, IP4_ARP_NEXT_DROP,
162 : to_next_drop, n_left_to_next_drop);
163 :
164 409 : 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 332 : pi0 = from[0];
173 332 : p0 = vlib_get_buffer (vm, pi0);
174 :
175 332 : from += 1;
176 332 : n_left_from -= 1;
177 332 : to_next_drop[0] = pi0;
178 332 : to_next_drop += 1;
179 332 : n_left_to_next_drop -= 1;
180 :
181 332 : adj_index0 = vnet_buffer (p0)->ip.adj_index[VLIB_TX];
182 332 : adj0 = adj_get (adj_index0);
183 332 : sw_if_index0 = adj0->rewrite_header.sw_if_index;
184 :
185 332 : if (is_glean)
186 : {
187 : /* resolve the packet's destination */
188 63 : ip4_header_t *ip0 = vlib_buffer_get_current (p0);
189 63 : resolve0 = ip0->dst_address;
190 : }
191 : else
192 : /* resolve the incomplete adj */
193 269 : resolve0 = adj0->sub_type.nbr.next_hop.ip4;
194 :
195 332 : if (is_glean && adj0->sub_type.glean.rx_pfx.fp_len)
196 : /* the glean is for a connected, local prefix */
197 61 : src0 = adj0->sub_type.glean.rx_pfx.fp_addr.ip4;
198 : else
199 : {
200 : /* Src IP address in ARP header. */
201 271 : if (!fib_sas4_get (sw_if_index0, &resolve0, &src0) &&
202 0 : !ip4_sas_by_sw_if_index (sw_if_index0, &resolve0, &src0))
203 : {
204 : /* No source address available */
205 0 : p0->error =
206 0 : node->errors[IP4_NEIGHBOR_ERROR_NO_SOURCE_ADDRESS];
207 255 : continue;
208 : }
209 : }
210 :
211 : /* combine the address and interface for the hash key */
212 332 : r0 = (u64) resolve0.data_u32 << 32;
213 332 : r0 |= sw_if_index0;
214 :
215 332 : if (throttle_check (&arp_throttle, thread_index, r0, seed))
216 : {
217 255 : p0->error = node->errors[IP4_NEIGHBOR_ERROR_THROTTLED];
218 255 : continue;
219 : }
220 :
221 : /*
222 : * the adj has been updated to a rewrite but the node the DPO that got
223 : * us here hasn't - yet. no big deal. we'll drop while we wait.
224 : */
225 77 : if (IP_LOOKUP_NEXT_REWRITE == adj0->lookup_next_index)
226 : {
227 0 : p0->error = node->errors[IP4_NEIGHBOR_ERROR_RESOLVED];
228 0 : continue;
229 : }
230 :
231 : /*
232 : * Can happen if the control-plane is programming tables
233 : * with traffic flowing; at least that's today's lame excuse.
234 : */
235 77 : if ((is_glean && adj0->lookup_next_index != IP_LOOKUP_NEXT_GLEAN)
236 77 : || (!is_glean && adj0->lookup_next_index != IP_LOOKUP_NEXT_ARP))
237 : {
238 0 : p0->error = node->errors[IP4_NEIGHBOR_ERROR_NON_ARP_ADJ];
239 0 : continue;
240 : }
241 :
242 : /* Send ARP request. */
243 77 : b0 = ip4_neighbor_probe (vm, vnm, adj0, &src0, &resolve0);
244 :
245 77 : if (PREDICT_TRUE (NULL != b0))
246 : {
247 : /* copy the persistent fields from the original */
248 77 : clib_memcpy_fast (b0->opaque2, p0->opaque2,
249 : sizeof (p0->opaque2));
250 77 : p0->error = node->errors[IP4_NEIGHBOR_ERROR_REQUEST_SENT];
251 : }
252 : else
253 : {
254 0 : p0->error = node->errors[IP4_NEIGHBOR_ERROR_NO_BUFFERS];
255 0 : continue;
256 : }
257 : }
258 :
259 77 : vlib_put_next_frame (vm, node, IP4_ARP_NEXT_DROP, n_left_to_next_drop);
260 : }
261 :
262 77 : return frame->n_vectors;
263 : }
264 :
265 589 : VLIB_NODE_FN (ip4_arp_node) (vlib_main_t * vm, vlib_node_runtime_t * node,
266 : vlib_frame_t * frame)
267 : {
268 14 : return (ip4_arp_inline (vm, node, frame, 0));
269 : }
270 :
271 638 : VLIB_NODE_FN (ip4_glean_node) (vlib_main_t * vm, vlib_node_runtime_t * node,
272 : vlib_frame_t * frame)
273 : {
274 63 : return (ip4_arp_inline (vm, node, frame, 1));
275 : }
276 :
277 : /* *INDENT-OFF* */
278 183788 : VLIB_REGISTER_NODE (ip4_arp_node) =
279 : {
280 : .name = "ip4-arp",
281 : .vector_size = sizeof (u32),
282 : .format_trace = format_ip4_forward_next_trace,
283 : .n_errors = IP4_NEIGHBOR_N_ERROR,
284 : .error_counters = ip4_neighbor_error_counters,
285 : .n_next_nodes = IP4_ARP_N_NEXT,
286 : .next_nodes = {
287 : [IP4_ARP_NEXT_DROP] = "ip4-drop",
288 : },
289 : };
290 :
291 183788 : VLIB_REGISTER_NODE (ip4_glean_node) =
292 : {
293 : .name = "ip4-glean",
294 : .vector_size = sizeof (u32),
295 : .format_trace = format_ip4_forward_next_trace,
296 : .n_errors = IP4_NEIGHBOR_N_ERROR,
297 : .error_counters = ip4_neighbor_error_counters,
298 : .n_next_nodes = IP4_ARP_N_NEXT,
299 : .next_nodes = {
300 : [IP4_ARP_NEXT_DROP] = "ip4-drop",
301 : },
302 : };
303 : /* *INDENT-ON* */
304 :
305 : #define foreach_notrace_ip4_arp_error \
306 : _(THROTTLED) \
307 : _(RESOLVED) \
308 : _(NO_BUFFERS) \
309 : _(REQUEST_SENT) \
310 : _(NON_ARP_ADJ) \
311 : _(NO_SOURCE_ADDRESS)
312 :
313 : static clib_error_t *
314 575 : arp_notrace_init (vlib_main_t * vm)
315 : {
316 575 : vlib_node_runtime_t *rt = vlib_node_get_runtime (vm, ip4_arp_node.index);
317 :
318 : /* don't trace ARP request packets */
319 : #define _(a) \
320 : vnet_pcap_drop_trace_filter_add_del (rt->errors[IP4_NEIGHBOR_ERROR_##a], \
321 : 1 /* is_add */);
322 575 : foreach_notrace_ip4_arp_error;
323 : #undef _
324 575 : return 0;
325 : }
326 :
327 48959 : VLIB_INIT_FUNCTION (arp_notrace_init);
328 :
329 : static clib_error_t *
330 575 : ip4_neighbor_main_loop_enter (vlib_main_t * vm)
331 : {
332 575 : vlib_thread_main_t *tm = &vlib_thread_main;
333 575 : u32 n_vlib_mains = tm->n_vlib_mains;
334 :
335 575 : throttle_init (&arp_throttle, n_vlib_mains, THROTTLE_BITS, 1e-3);
336 :
337 575 : return (NULL);
338 : }
339 :
340 1151 : VLIB_MAIN_LOOP_ENTER_FUNCTION (ip4_neighbor_main_loop_enter);
341 :
342 :
343 : /*
344 : * fd.io coding-style-patch-verification: ON
345 : *
346 : * Local Variables:
347 : * eval: (c-set-style "gnu")
348 : * End:
349 : */
|
