FD.io VPP  v19.08.3-2-gbabecb413
Vector Packet Processing
ip_neighbor.c
Go to the documentation of this file.
1 /*
2  * src/vnet/ip/ip_neighbor.c: ip neighbor generic handling
3  *
4  * Copyright (c) 2018 Cisco and/or its affiliates.
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at:
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17 
18 #include <vnet/vnet.h>
19 #include <vnet/ip/ip.h>
20 #include <vnet/ip/ip6_neighbor.h>
21 #include <vnet/ip/ip_neighbor.h>
22 #include <vnet/ethernet/arp.h>
23 
24 /*
25  * IP neighbor scan parameter defaults are as follows:
26  * - Scan interval : 60 sec
27  * - Max processing allowed per run : 20 usec
28  * - Max probe/delete operations per run : 10
29  * - Scan interrupt delay to resume scan : 1 msec
30  * - Neighbor stale threshold : 4 x scan-interval
31  */
32 #define IP_NEIGHBOR_DEF_SCAN_INTERVAL (60.0)
33 #define IP_NEIGHBOR_DEF_MAX_PROC_TIME (20e-6)
34 #define IP_NEIGHBOR_DEF_SCAN_INT_DELAY (1e-3)
35 #define IP_NEIGHBOR_DEF_STALE (4*IP_NEIGHBOR_DEF_SCAN_INTERVAL)
36 #define IP_NEIGHBOR_DEF_MAX_UPDATE 10
37 
38 typedef struct
39 {
40  f64 scan_interval; /* Periodic scan interval */
41  f64 max_proc_time; /* Max processing time allowed per run */
42  f64 scan_int_delay; /* Scan interrupt delay to resume scan */
43  f64 stale_threshold; /* IP neighbor stale threshod */
44  u8 max_update; /* Max probe/delete actions allowed per run */
45  u8 mode; /* IP neighbor scan mode */
47 
49 
50 u8 *
51 format_ip_neighbor_flags (u8 * s, va_list * args)
52 {
53  const ip_neighbor_flags_t flags = va_arg (*args, int);
54 
55  if (flags & IP_NEIGHBOR_FLAG_STATIC)
56  s = format (s, "S");
57 
58  if (flags & IP_NEIGHBOR_FLAG_DYNAMIC)
59  s = format (s, "D");
60 
62  s = format (s, "N");
63 
64  return s;
65 }
66 
67 int
68 ip_neighbor_add (const ip46_address_t * ip,
70  const mac_address_t * mac,
72  ip_neighbor_flags_t flags, u32 * stats_index)
73 {
74  fib_protocol_t fproto;
75  vnet_link_t linkt;
76  int rv;
77 
78  /*
79  * there's no validation here of the ND/ARP entry being added.
80  * The expectation is that the FIB will ensure that nothing bad
81  * will come of adding bogus entries.
82  */
83  if (IP46_TYPE_IP6 == type)
84  {
86  sw_if_index, &ip->ip6, mac, flags);
87  fproto = FIB_PROTOCOL_IP6;
88  linkt = VNET_LINK_IP6;
89  }
90  else
91  {
92  ethernet_arp_ip4_over_ethernet_address_t a = {
93  .ip4 = ip->ip4,
94  .mac = *mac,
95  };
96 
97  rv =
98  vnet_arp_set_ip4_over_ethernet (vnet_get_main (), sw_if_index, &a,
99  flags);
100  fproto = FIB_PROTOCOL_IP4;
101  linkt = VNET_LINK_IP4;
102  }
103 
104  if (0 == rv && stats_index)
105  *stats_index = adj_nbr_find (fproto, linkt, ip, sw_if_index);
106 
107  return (rv);
108 }
109 
110 int
111 ip_neighbor_del (const ip46_address_t * ip, ip46_type_t type, u32 sw_if_index)
112 {
113  int rv;
114 
115  if (IP46_TYPE_IP6 == type)
116  {
118  sw_if_index, &ip->ip6);
119  }
120  else
121  {
122  ethernet_arp_ip4_over_ethernet_address_t a = {
123  .ip4 = ip->ip4,
124  };
125 
126  rv =
127  vnet_arp_unset_ip4_over_ethernet (vnet_get_main (), sw_if_index, &a);
128  }
129 
130  return (rv);
131 }
132 
133 void
135 {
137 
138  cfg->mode = arg->mode;
139 
140  if (arg->mode)
141  {
142  cfg->scan_interval = arg->scan_interval ?
144  cfg->max_proc_time = arg->max_proc_time ?
146  cfg->scan_int_delay = arg->scan_int_delay ?
148  cfg->stale_threshold = arg->stale_threshold ?
149  arg->stale_threshold * 60.0 : cfg->scan_interval * 4;
150  cfg->max_update = arg->max_update ?
152  }
153  else
155 }
156 
158 ip_neighbor_scan (vlib_main_t * vm, f64 start_time, u32 start_idx,
159  u8 is_ip6, u8 delete_stale, u8 * update_count)
160 {
161  vnet_main_t *vnm = vnet_get_main ();
166  ip6_neighbor_t *n6;
167  u32 curr_idx = start_idx;
168  u32 loop_count = 0;
169  f64 delta, update_time;
170 
171  if (!is_ip6)
172  {
173  if (pool_is_free_index (np4, start_idx))
174  curr_idx = pool_next_index (np4, start_idx);
175  }
176  else
177  {
178  if (pool_is_free_index (np6, start_idx))
179  curr_idx = pool_next_index (np6, start_idx);
180  }
181 
182  while (curr_idx != ~0)
183  {
184  /* allow no more than 10 neighbor updates or 20 usec of scan */
185  if ((update_count[0] >= cfg->max_update) ||
186  (((loop_count % 100) == 0) &&
187  ((vlib_time_now (vm) - start_time) > cfg->max_proc_time)))
188  break;
189 
190  if (!is_ip6)
191  {
192  n4 = pool_elt_at_index (np4, curr_idx);
193  if (n4->flags & IP_NEIGHBOR_FLAG_STATIC)
194  goto next_neighbor;
195  update_time = n4->time_last_updated;
196  }
197  else
198  {
199  n6 = pool_elt_at_index (np6, curr_idx);
200  if (n6->flags & IP_NEIGHBOR_FLAG_STATIC)
201  goto next_neighbor;
202  update_time = n6->time_last_updated;
203  }
204 
205  delta = start_time - update_time;
206  if (delete_stale && (delta >= cfg->stale_threshold))
207  {
208  update_count[0]++;
209  /* delete stale neighbor */
210  if (!is_ip6)
211  {
212  ethernet_arp_ip4_over_ethernet_address_t delme = {
213  .ip4.as_u32 = n4->ip4_address.as_u32,
214  .mac = n4->mac,
215  };
216 
218  }
219  else
220  {
222  (vm, n6->key.sw_if_index, &n6->key.ip6_address);
223  }
224  }
225  else if (delta >= cfg->scan_interval)
226  {
227  update_count[0]++;
228  /* probe neighbor */
229  if (!is_ip6)
230  ip4_probe_neighbor (vm, &n4->ip4_address, n4->sw_if_index, 1);
231  else
233  n6->key.sw_if_index, 1);
234  }
235 
236  next_neighbor:
237  loop_count++;
238 
239  if (!is_ip6)
240  curr_idx = pool_next_index (np4, curr_idx);
241  else
242  curr_idx = pool_next_index (np6, curr_idx);
243  }
244 
245  return curr_idx;
246 }
247 
248 static uword
251 {
254  f64 start, next_scan = CLIB_TIME_MAX;
255  u32 ip4_nidx = 0; /* ip4 neighbor pool index */
256  u32 ip6_nidx = 0; /* ip6 neighbor pool index */
257  uword *event_data = 0;
258  u8 purge4 = 0, purge6 = 0; /* flags to purge stale entry during scan */
259  u8 update;
260 
261  cfg->mode = IP_SCAN_DISABLED;
264 
265  while (1)
266  {
268  vlib_process_get_events (vm, &event_data);
269  vec_reset_length (event_data);
270 
271  start = vlib_time_now (vm);
272  update = 0;
273 
274  if ((ip4_nidx == 0) && (ip6_nidx == 0)) /* starting a fresh scan */
275  next_scan = start + cfg->scan_interval;
276 
277  if ((cfg->mode & IP_SCAN_V4_NEIGHBORS) == 0)
278  ip4_nidx = ~0; /* disable ip4 neighbor scan */
279 
280  if ((cfg->mode & IP_SCAN_V6_NEIGHBORS) == 0)
281  ip6_nidx = ~0; /* disable ip6 neighbor scan */
282 
283  if (ip4_nidx != ~0) /* scan ip4 neighbors */
284  ip4_nidx = ip_neighbor_scan (vm, start, ip4_nidx, /* ip4 */ 0,
285  purge4, &update);
286 
287  if (ip6_nidx != ~0) /* scan ip6 neighbors */
288  ip6_nidx = ip_neighbor_scan (vm, start, ip6_nidx, /* ip6 */ 1,
289  purge6, &update);
290 
291  if ((ip4_nidx == ~0) && (ip6_nidx == ~0))
292  { /* scan complete */
293  timeout = next_scan - vlib_time_now (vm);
294  ip4_nidx = ip6_nidx = 0;
295  purge4 = cfg->mode & IP_SCAN_V4_NEIGHBORS;
296  purge6 = cfg->mode & IP_SCAN_V6_NEIGHBORS;
297  }
298  else /* scan incomplete */
299  timeout = cfg->scan_int_delay;
300 
301  if (timeout > cfg->scan_interval)
302  timeout = cfg->scan_interval;
303  else if (timeout < cfg->scan_int_delay)
304  timeout = cfg->scan_int_delay;
305 
306  }
307  return 0;
308 }
309 
310 /* *INDENT-OFF* */
312  .function = neighbor_scan_process,
313  .type = VLIB_NODE_TYPE_PROCESS,
314  .name = "ip-neighbor-scan-process",
315 };
316 /* *INDENT-ON* */
317 
318 static clib_error_t *
320  vlib_cli_command_t * cmd)
321 {
322  unformat_input_t _line_input, *line_input = &_line_input;
323  clib_error_t *error = 0;
324  u32 interval = 0, time = 0, update = 0, delay = 0, stale = 0;
326 
327  clib_memset (&arg, 0, sizeof (arg));
329 
330  /* Get a line of input. */
331  if (!unformat_user (input, unformat_line_input, line_input))
332  {
334  return error;
335  }
336 
337  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
338  {
339  if (unformat (line_input, "ip4"))
341 
342  else if (unformat (line_input, "ip6"))
344 
345  else if (unformat (line_input, "both"))
347 
348  else if (unformat (line_input, "disable"))
349  arg.mode = IP_SCAN_DISABLED;
350 
351  else if (unformat (line_input, "interval %d", &interval))
352  arg.scan_interval = interval;
353 
354  else if (unformat (line_input, "max-time %d", &time))
355  arg.max_proc_time = time;
356 
357  else if (unformat (line_input, "max-update %d", &update))
358  arg.max_update = update;
359 
360  else if (unformat (line_input, "delay %d", &delay))
361  arg.scan_int_delay = delay;
362 
363  else if (unformat (line_input, "stale %d", &stale))
364  arg.stale_threshold = stale;
365 
366  else
367  {
368  error = clib_error_return (0, "unknown input '%U'",
369  format_unformat_error, line_input);
370  goto done;
371  }
372  }
373 
374  if (interval > 255)
375  {
376  error = clib_error_return (0, "interval cannot exceed 255 minutes.");
377  goto done;
378  }
379  if (time > 255)
380  {
381  error = clib_error_return (0, "max-time cannot exceed 255 usec.");
382  goto done;
383  }
384  if (update > 255)
385  {
386  error = clib_error_return (0, "max-update cannot exceed 255.");
387  goto done;
388  }
389  if (delay > 255)
390  {
391  error = clib_error_return (0, "delay cannot exceed 255 msec.");
392  goto done;
393  }
394  if (stale > 255)
395  {
396  error = clib_error_return (0, "stale cannot exceed 255 minutes.");
397  goto done;
398  }
399 
401 
402 done:
403  unformat_free (line_input);
404 
405  return error;
406 }
407 
408 /*?
409  * The '<em>ip scan-neighbor</em>' command can be used to enable and disable
410  * periodic IP neighbor scan and change various scan parameters.
411  *
412  * @note The default parameters used for IP neighbor scan should work fine
413  * under normal conditions. They should not be changed from the default unless
414  * properly tested to work as desired.
415  *
416  * @cliexpar
417  * Example of enabling IP neighbor scan:
418  * @cliexcmd{ip neighbor-scan enable}
419 ?*/
420 /* *INDENT-OFF* */
421 VLIB_CLI_COMMAND (ip_scan_neighbor_command, static) = {
422  .path = "ip scan-neighbor",
423  .function = ip_neighbor_scan_cli,
424  .short_help = "ip scan-neighbor [ip4|ip6|both|disable] [interval <n-min>] [max-time <n-usec>] [max-update <n>] [delay <n-msec>] [stale <n-min>]",
425  .is_mp_safe = 1,
426 };
427 /* *INDENT-ON* */
428 
429 static u8 *
430 format_ip_scan_mode (u8 * s, va_list * args)
431 {
432  u8 mode = va_arg (*args, u32);
433  switch (mode)
434  {
436  return format (s, "IPv4");
438  return format (s, "IPv6");
440  return format (s, "IPv4 and IPv6");
441  }
442  return format (s, "unknown");
443 }
444 
445 static clib_error_t *
447  vlib_cli_command_t * cmd)
448 {
450 
451  if (cfg->mode == 0)
452  vlib_cli_output (vm,
453  "IP neighbor scan disabled - current time is %.4f sec",
454  vlib_time_now (vm));
455  else
456  vlib_cli_output (vm, "IP neighbor scan enabled for %U neighbors - "
457  "current time is %.4f sec\n "
458  "Full_scan_interval: %f min "
459  "Stale_purge_threshod: %f min\n "
460  "Max_process_time: %f usec Max_updates %d "
461  "Delay_to_resume_after_max_limit: %f msec",
463  vlib_time_now (vm), cfg->scan_interval / 60.0,
464  cfg->stale_threshold / 60.0, cfg->max_proc_time / 1e-6,
465  cfg->max_update, cfg->scan_int_delay / 1e-3);
466  return 0;
467 }
468 
469 /*?
470  * The '<em>show ip scan-neighbor</em>' command can be used to show the current
471  * periodic IP neighbor scan parameters
472  *
473  * @cliexpar
474  * Example of showing IP neighbor scan current parameters:
475  * @cliexcmd{show ip neighbor-scan}
476 ?*/
477 /* *INDENT-OFF* */
478 VLIB_CLI_COMMAND (show_ip_scan_neighbor_command, static) = {
479  .path = "show ip scan-neighbor",
480  .function = show_ip_neighbor_scan,
481  .short_help = "show ip scan-neighbor",
482  .is_mp_safe = 1,
483 };
484 /* *INDENT-ON* */
485 
486 /*
487  * fd.io coding-style-patch-verification: ON
488  *
489  * Local Variables:
490  * eval: (c-set-style "gnu")
491  * End:
492  */
ip_neighbor_flags_t flags
Definition: arp.h:31
int vnet_arp_set_ip4_over_ethernet(vnet_main_t *vnm, u32 sw_if_index, const ethernet_arp_ip4_over_ethernet_address_t *a, ip_neighbor_flags_t flags)
Definition: arp.c:2380
#define pool_next_index(P, I)
Return next occupied pool index after i, useful for safe iteration.
Definition: pool.h:522
u32 flags
Definition: vhost_user.h:141
#define IP_NEIGHBOR_DEF_MAX_UPDATE
Definition: ip_neighbor.c:36
static f64 vlib_process_wait_for_event_or_clock(vlib_main_t *vm, f64 dt)
Suspend a cooperative multi-tasking thread Waits for an event, or for the indicated number of seconds...
Definition: node_funcs.h:673
vl_api_mac_address_t mac
Definition: l2.api:490
a
Definition: bitmap.h:538
int vnet_arp_unset_ip4_over_ethernet(vnet_main_t *vnm, u32 sw_if_index, const ethernet_arp_ip4_over_ethernet_address_t *a)
Control Plane hook to remove an ARP entry.
Definition: arp.c:1945
vnet_main_t * vnet_get_main(void)
Definition: misc.c:46
int ip_neighbor_add(const ip46_address_t *ip, ip46_type_t type, const mac_address_t *mac, u32 sw_if_index, ip_neighbor_flags_t flags, u32 *stats_index)
Definition: ip_neighbor.c:68
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
static f64 vlib_time_now(vlib_main_t *vm)
Definition: main.h:279
#define IP_SCAN_V6_NEIGHBORS
Definition: ip_neighbor.h:23
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:989
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
#define IP_SCAN_V46_NEIGHBORS
Definition: ip_neighbor.h:24
static ip_neighbor_scan_config_t ip_neighbor_scan_conf
Definition: ip_neighbor.c:48
unsigned char u8
Definition: types.h:56
#define IP_NEIGHBOR_DEF_SCAN_INTERVAL
Definition: ip_neighbor.c:32
enum fib_protocol_t_ fib_protocol_t
Protocol Type.
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
double f64
Definition: types.h:142
int ip_neighbor_del(const ip46_address_t *ip, ip46_type_t type, u32 sw_if_index)
Definition: ip_neighbor.c:111
ip6_neighbor_t * ip6_neighbors_pool(void)
Definition: ip6_neighbor.c:978
#define static_always_inline
Definition: clib.h:100
vl_api_interface_index_t sw_if_index
Definition: gre.api:50
void ip_neighbor_scan_enable_disable(ip_neighbor_scan_arg_t *arg)
Definition: ip_neighbor.c:134
static uword vlib_process_get_events(vlib_main_t *vm, uword **data_vector)
Return the first event type which has occurred and a vector of per-event data of that type...
Definition: node_funcs.h:516
enum ip_neighbor_flags_t_ ip_neighbor_flags_t
#define clib_error_return(e, args...)
Definition: error.h:99
#define IP_SCAN_V4_NEIGHBORS
Definition: ip_neighbor.h:22
unsigned int u32
Definition: types.h:88
clib_error_t * ip6_probe_neighbor(vlib_main_t *vm, ip6_address_t *dst, u32 sw_if_index, u8 refresh)
Definition: ip6_forward.c:1603
#define IP_NEIGHBOR_DEF_MAX_PROC_TIME
Definition: ip_neighbor.c:33
unformat_function_t unformat_line_input
Definition: format.h:283
vl_api_fib_path_type_t type
Definition: fib_types.api:123
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:514
static clib_error_t * show_ip_neighbor_scan(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: ip_neighbor.c:446
ip4_address_t ip4_address
Definition: arp.h:27
mac_address_t mac
Definition: arp.h:29
struct _unformat_input_t unformat_input_t
u32 sw_if_index
Definition: arp.h:26
ethernet_arp_ip4_entry_t * ip4_neighbors_pool(void)
Definition: arp.c:1779
#define IP_SCAN_DISABLED
Definition: ip_neighbor.h:21
clib_error_t * ip4_probe_neighbor(vlib_main_t *vm, ip4_address_t *dst, u32 sw_if_index, u8 refresh)
Definition: ip4_forward.c:2169
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:169
#define UNFORMAT_END_OF_INPUT
Definition: format.h:145
vlib_main_t * vm
Definition: buffer.c:323
static vlib_node_registration_t neighbor_scan_process_node
(constructor) VLIB_REGISTER_NODE (neighbor_scan_process_node)
Definition: ip_neighbor.c:311
u8 * format_ip_neighbor_flags(u8 *s, va_list *args)
Definition: ip_neighbor.c:51
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
Definition: pool.h:283
static_always_inline u32 ip_neighbor_scan(vlib_main_t *vm, f64 start_time, u32 start_idx, u8 is_ip6, u8 delete_stale, u8 *update_count)
Definition: ip_neighbor.c:158
vl_api_vxlan_gbp_api_tunnel_mode_t mode
Definition: vxlan_gbp.api:44
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:161
ip6_address_t ip6_address
Definition: ip6_neighbor.h:28
enum vnet_link_t_ vnet_link_t
Link Type: A description of the protocol of packets on the link.
ip46_type_t
Definition: ip6_packet.h:70
#define CLIB_TIME_MAX
Definition: time.h:227
int vnet_set_ip6_ethernet_neighbor(vlib_main_t *vm, u32 sw_if_index, const ip6_address_t *a, const mac_address_t *mac, ip_neighbor_flags_t flags)
Definition: ip6_neighbor.c:760
static uword neighbor_scan_process(vlib_main_t *vm, vlib_node_runtime_t *rt, vlib_frame_t *f)
Definition: ip_neighbor.c:249
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
f64 time_last_updated
Definition: arp.h:33
static u8 * format_ip_scan_mode(u8 *s, va_list *args)
Definition: ip_neighbor.c:430
vl_api_address_t ip
Definition: l2.api:489
int vnet_unset_ip6_ethernet_neighbor(vlib_main_t *vm, u32 sw_if_index, const ip6_address_t *a)
Definition: ip6_neighbor.c:912
ip6_neighbor_key_t key
Definition: ip6_neighbor.h:35
u64 uword
Definition: types.h:112
static void unformat_free(unformat_input_t *i)
Definition: format.h:163
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
ip_neighbor_flags_t flags
Definition: ip6_neighbor.h:37
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:772
static clib_error_t * ip_neighbor_scan_cli(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: ip_neighbor.c:319
#define IP_NEIGHBOR_DEF_SCAN_INT_DELAY
Definition: ip_neighbor.c:34
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:978
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:171
Definition: arp.h:24
adj_index_t adj_nbr_find(fib_protocol_t nh_proto, vnet_link_t link_type, const ip46_address_t *nh_addr, u32 sw_if_index)
Lookup neighbor adjancency.
Definition: adj_nbr.c:99