FD.io VPP  v17.01.1-3-gc6833f8
Vector Packet Processing
tuntap.c
Go to the documentation of this file.
1 /*
2  *------------------------------------------------------------------
3  * tuntap.c - kernel stack (reverse) punt/inject path
4  *
5  * Copyright (c) 2009 Cisco and/or its affiliates.
6  * Licensed under the Apache License, Version 2.0 (the "License");
7  * you may not use this file except in compliance with the License.
8  * You may obtain a copy of the License at:
9  *
10  * http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  *------------------------------------------------------------------
18  */
19 /**
20  * @file
21  * @brief TunTap Kernel stack (reverse) punt/inject path.
22  *
23  * This driver runs in one of two distinct modes:
24  * - "punt/inject" mode, where we send pkts not otherwise processed
25  * by the forwarding to the Linux kernel stack, and
26  *
27  * - "normal interface" mode, where we treat the Linux kernel stack
28  * as a peer.
29  *
30  * By default, we select punt/inject mode.
31  */
32 
33 #include <fcntl.h> /* for open */
34 #include <sys/ioctl.h>
35 #include <sys/socket.h>
36 #include <sys/stat.h>
37 #include <sys/types.h>
38 #include <sys/uio.h> /* for iovec */
39 #include <netinet/in.h>
40 
41 #include <linux/if_arp.h>
42 #include <linux/if_tun.h>
43 
44 #include <vlib/vlib.h>
45 #include <vlib/unix/unix.h>
46 
47 #include <vnet/ip/ip.h>
48 
49 #include <vnet/ethernet/ethernet.h>
50 #include <vnet/devices/devices.h>
51 #include <vnet/feature/feature.h>
52 
55 
56 static void tuntap_punt_frame (vlib_main_t * vm,
57  vlib_node_runtime_t * node,
58  vlib_frame_t * frame);
59 static void tuntap_nopunt_frame (vlib_main_t * vm,
60  vlib_node_runtime_t * node,
61  vlib_frame_t * frame);
62 
63 typedef struct {
66  u8 addr[16];
68 
69 /**
70  * @brief TUNTAP node main state
71  */
72 typedef struct {
73  /** Vector of iovecs for readv/writev calls. */
74  struct iovec * iovecs;
75 
76  /** Vector of VLIB rx buffers to use. We allocate them in blocks
77  of VLIB_FRAME_SIZE (256). */
79 
80  /** File descriptors for /dev/net/tun and provisioning socket. */
81  int dev_net_tun_fd, dev_tap_fd;
82 
83  /** Create a "tap" [ethernet] encaps device */
84  int is_ether;
85 
86  /** 1 if a "normal" routed intfc, 0 if a punt/inject interface */
87 
89 
90  /** tap device destination MAC address. Required, or Linux drops pkts */
91  u8 ether_dst_mac[6];
92 
93  /** Interface MTU in bytes and # of default sized buffers. */
94  u32 mtu_bytes, mtu_buffers;
95 
96  /** Linux interface name for tun device. */
97  char * tun_name;
98 
99  /** Pool of subinterface addresses */
101 
102  /** Hash for subif addresses */
104 
105  /** Unix file index */
107 
108  /** For the "normal" interface, if configured */
109  u32 hw_if_index, sw_if_index;
110 
111 } tuntap_main_t;
112 
113 static tuntap_main_t tuntap_main = {
114  .tun_name = "vnet",
115 
116  /** Suitable defaults for an Ethernet-like tun/tap device */
117  .mtu_bytes = 4096 + 256,
118 };
119 
120 /**
121  * @brief tuntap_tx
122  * @node tuntap-tx
123  *
124  * Output node, writes the buffers comprising the incoming frame
125  * to the tun/tap device, aka hands them to the Linux kernel stack.
126  *
127  * @param *vm - vlib_main_t
128  * @param *node - vlib_node_runtime_t
129  * @param *frame - vlib_frame_t
130  *
131  * @return rc - uword
132  *
133  */
134 static uword
136  vlib_node_runtime_t * node,
137  vlib_frame_t * frame)
138 {
139  u32 * buffers = vlib_frame_args (frame);
140  uword n_packets = frame->n_vectors;
141  tuntap_main_t * tm = &tuntap_main;
142  vnet_main_t *vnm = vnet_get_main ();
144  u32 n_bytes = 0;
145  int i;
146 
147  for (i = 0; i < n_packets; i++)
148  {
149  struct iovec * iov;
150  vlib_buffer_t * b;
151  uword l;
152 
153  b = vlib_get_buffer (vm, buffers[i]);
154 
155  if (tm->is_ether && (!tm->have_normal_interface))
156  {
159  }
160 
161  /* Re-set iovecs if present. */
162  if (tm->iovecs)
163  _vec_len (tm->iovecs) = 0;
164 
165  /** VLIB buffer chain -> Unix iovec(s). */
166  vec_add2 (tm->iovecs, iov, 1);
167  iov->iov_base = b->data + b->current_data;
168  iov->iov_len = l = b->current_length;
169 
171  {
172  do {
173  b = vlib_get_buffer (vm, b->next_buffer);
174 
175  vec_add2 (tm->iovecs, iov, 1);
176 
177  iov->iov_base = b->data + b->current_data;
178  iov->iov_len = b->current_length;
179  l += b->current_length;
180  } while (b->flags & VLIB_BUFFER_NEXT_PRESENT);
181  }
182 
183  if (writev (tm->dev_net_tun_fd, tm->iovecs, vec_len (tm->iovecs)) < l)
184  clib_unix_warning ("writev");
185 
186  n_bytes += l;
187  }
188 
189  /* Update tuntap interface output stats. */
192  vm->cpu_index,
193  tm->sw_if_index, n_packets, n_bytes);
194 
195 
196  /** The normal interface path flattens the buffer chain */
197  if (tm->have_normal_interface)
198  vlib_buffer_free_no_next (vm, buffers, n_packets);
199  else
200  vlib_buffer_free (vm, buffers, n_packets);
201 
202  return n_packets;
203 }
204 
206  .function = tuntap_tx,
207  .name = "tuntap-tx",
208  .type = VLIB_NODE_TYPE_INTERNAL,
209  .vector_size = 4,
210 };
211 
212 /**
213  * @brief TUNTAP receive node
214  * @node tuntap-rx
215  *
216  * @param *vm - vlib_main_t
217  * @param *node - vlib_node_runtime_t
218  * @param *frame - vlib_frame_t
219  *
220  * @return rc - uword
221  *
222  */
223 static uword
225  vlib_node_runtime_t * node,
226  vlib_frame_t * frame)
227 {
228  tuntap_main_t * tm = &tuntap_main;
229  vlib_buffer_t * b;
230  u32 bi;
231  const uword buffer_size = VLIB_BUFFER_DATA_SIZE;
232 
233  /** Make sure we have some RX buffers. */
234  {
235  uword n_left = vec_len (tm->rx_buffers);
236  uword n_alloc;
237 
238  if (n_left < VLIB_FRAME_SIZE / 2)
239  {
240  if (! tm->rx_buffers)
242 
243  n_alloc = vlib_buffer_alloc (vm, tm->rx_buffers + n_left, VLIB_FRAME_SIZE - n_left);
244  _vec_len (tm->rx_buffers) = n_left + n_alloc;
245  }
246  }
247 
248  /** Allocate RX buffers from end of rx_buffers.
249  Turn them into iovecs to pass to readv. */
250  {
251  uword i_rx = vec_len (tm->rx_buffers) - 1;
252  vlib_buffer_t * b;
253  word i, n_bytes_left, n_bytes_in_packet;
254 
255  /** We should have enough buffers left for an MTU sized packet. */
256  ASSERT (vec_len (tm->rx_buffers) >= tm->mtu_buffers);
257 
258  vec_validate (tm->iovecs, tm->mtu_buffers - 1);
259  for (i = 0; i < tm->mtu_buffers; i++)
260  {
261  b = vlib_get_buffer (vm, tm->rx_buffers[i_rx - i]);
262  tm->iovecs[i].iov_base = b->data;
263  tm->iovecs[i].iov_len = buffer_size;
264  }
265 
266  n_bytes_left = readv (tm->dev_net_tun_fd, tm->iovecs, tm->mtu_buffers);
267  n_bytes_in_packet = n_bytes_left;
268  if (n_bytes_left <= 0)
269  {
270  if (errno != EAGAIN)
271  clib_unix_warning ("readv %d", n_bytes_left);
272  return 0;
273  }
274 
275  bi = tm->rx_buffers[i_rx];
276 
277  while (1)
278  {
279  b = vlib_get_buffer (vm, tm->rx_buffers[i_rx]);
280  b->flags = 0;
281  b->current_data = 0;
282  b->current_length = n_bytes_left < buffer_size ? n_bytes_left : buffer_size;
283 
284  n_bytes_left -= buffer_size;
285 
286  if (n_bytes_left <= 0)
287  {
288  break;
289  }
290 
291  i_rx--;
293  b->next_buffer = tm->rx_buffers[i_rx];
294  }
295 
296  /** Interface counters for tuntap interface. */
301  tm->sw_if_index,
302  1, n_bytes_in_packet);
303 
304  _vec_len (tm->rx_buffers) = i_rx;
305  }
306 
307  b = vlib_get_buffer (vm, bi);
308 
309  {
310  u32 next_index;
311  uword n_trace = vlib_get_trace_count (vm, node);
312 
313  vnet_buffer (b)->sw_if_index[VLIB_RX] = tm->sw_if_index;
314  vnet_buffer (b)->sw_if_index[VLIB_TX] = (u32)~0;
315 
316  /*
317  * Turn this on if you run into
318  * "bad monkey" contexts, and you want to know exactly
319  * which nodes they've visited...
320  */
322  b->pre_data[0] = 0;
323 
324  b->error = node->errors[0];
325 
326  if (tm->is_ether)
327  {
329  }
330  else
331  switch (b->data[0] & 0xf0)
332  {
333  case 0x40:
335  break;
336  case 0x60:
338  break;
339  default:
340  next_index = VNET_DEVICE_INPUT_NEXT_DROP;
341  break;
342  }
343 
344  /* The linux kernel couldn't care less if our interface is up */
345  if (tm->have_normal_interface)
346  {
347  vnet_main_t *vnm = vnet_get_main();
348  vnet_sw_interface_t * si;
349  si = vnet_get_sw_interface (vnm, tm->sw_if_index);
351  next_index = VNET_DEVICE_INPUT_NEXT_DROP;
352  }
353 
354  vnet_feature_start_device_input_x1 (tm->sw_if_index, &next_index, b, 0);
355 
356  vlib_set_next_frame_buffer (vm, node, next_index, bi);
357 
358  if (n_trace > 0)
359  {
360  vlib_trace_buffer (vm, node, next_index,
361  b, /* follow_chain */ 1);
362  vlib_set_trace_count (vm, node, n_trace - 1);
363  }
364  }
365 
366  return 1;
367 }
368 
369 /**
370  * @brief TUNTAP_RX error strings
371  */
372 static char * tuntap_rx_error_strings[] = {
373  "unknown packet type",
374 };
375 
377  .function = tuntap_rx,
378  .name = "tuntap-rx",
379  .sibling_of = "device-input",
380  .type = VLIB_NODE_TYPE_INPUT,
381  .state = VLIB_NODE_STATE_INTERRUPT,
382  .vector_size = 4,
383  .n_errors = 1,
384  .error_strings = tuntap_rx_error_strings,
385 };
386 
387 /**
388  * @brief Gets called when file descriptor is ready from epoll.
389  *
390  * @param *uf - unix_file_t
391  *
392  * @return error - clib_error_t
393  */
395 {
396  vlib_main_t * vm = vlib_get_main();
398  return 0;
399 }
400 
401 /**
402  * @brief Clean up the tun/tap device
403  *
404  * @param *vm - vlib_main_t
405  *
406  * @return error - clib_error_t
407  *
408  */
409 static clib_error_t *
411 {
412  tuntap_main_t *tm = &tuntap_main;
413  struct ifreq ifr;
414  int sfd;
415 
416  /* Not present. */
417  if (! tm->dev_net_tun_fd || tm->dev_net_tun_fd < 0)
418  return 0;
419 
420  sfd = socket (AF_INET, SOCK_STREAM, 0);
421  if (sfd < 0)
422  clib_unix_warning("provisioning socket");
423 
424  memset(&ifr, 0, sizeof (ifr));
425  strncpy (ifr.ifr_name, tm->tun_name, sizeof (ifr.ifr_name)-1);
426 
427  /* get flags, modify to bring down interface... */
428  if (ioctl (sfd, SIOCGIFFLAGS, &ifr) < 0)
429  clib_unix_warning ("SIOCGIFFLAGS");
430 
431  ifr.ifr_flags &= ~(IFF_UP | IFF_RUNNING);
432 
433  if (ioctl (sfd, SIOCSIFFLAGS, &ifr) < 0)
434  clib_unix_warning ("SIOCSIFFLAGS");
435 
436  /* Turn off persistence */
437  if (ioctl (tm->dev_net_tun_fd, TUNSETPERSIST, 0) < 0)
438  clib_unix_warning ("TUNSETPERSIST");
439  close(tm->dev_tap_fd);
440  if (tm->dev_net_tun_fd >= 0)
441  close(tm->dev_net_tun_fd);
442  if (sfd >= 0)
443  close (sfd);
444 
445  return 0;
446 }
447 
449 
450 /**
451  * @brief CLI function for tun/tap config
452  *
453  * @param *vm - vlib_main_t
454  * @param *input - unformat_input_t
455  *
456  * @return error - clib_error_t
457  *
458  */
459 static clib_error_t *
461 {
462  tuntap_main_t *tm = &tuntap_main;
463  clib_error_t * error = 0;
464  struct ifreq ifr;
465  u8 * name;
466  int flags = IFF_TUN | IFF_NO_PI;
467  int is_enabled = 0, is_ether = 0, have_normal_interface = 0;
468  const uword buffer_size = VLIB_BUFFER_DATA_SIZE;
469 
471  {
472  if (unformat (input, "mtu %d", &tm->mtu_bytes))
473  ;
474  else if (unformat (input, "enable"))
475  is_enabled = 1;
476  else if (unformat (input, "disable"))
477  is_enabled = 0;
478  else if (unformat (input, "ethernet") ||
479  unformat (input, "ether"))
480  is_ether = 1;
481  else if (unformat (input, "have-normal-interface") ||
482  unformat (input, "have-normal"))
483  have_normal_interface = 1;
484  else if (unformat (input, "name %s", &name))
485  tm->tun_name = (char *) name;
486  else
487  return clib_error_return (0, "unknown input `%U'",
488  format_unformat_error, input);
489  }
490 
491  tm->dev_net_tun_fd = -1;
492  tm->dev_tap_fd = -1;
493 
494  if (is_enabled == 0)
495  return 0;
496 
497  if (geteuid())
498  {
499  clib_warning ("tuntap disabled: must be superuser");
500  return 0;
501  }
502 
503  tm->is_ether = is_ether;
504  tm->have_normal_interface = have_normal_interface;
505 
506  if (is_ether)
507  flags = IFF_TAP | IFF_NO_PI;
508 
509  if ((tm->dev_net_tun_fd = open ("/dev/net/tun", O_RDWR)) < 0)
510  {
511  error = clib_error_return_unix (0, "open /dev/net/tun");
512  goto done;
513  }
514 
515  memset (&ifr, 0, sizeof (ifr));
516  strncpy(ifr.ifr_name, tm->tun_name, sizeof(ifr.ifr_name)-1);
517  ifr.ifr_flags = flags;
518  if (ioctl (tm->dev_net_tun_fd, TUNSETIFF, (void *)&ifr) < 0)
519  {
520  error = clib_error_return_unix (0, "ioctl TUNSETIFF");
521  goto done;
522  }
523 
524  /* Make it persistent, at least until we split. */
525  if (ioctl (tm->dev_net_tun_fd, TUNSETPERSIST, 1) < 0)
526  {
527  error = clib_error_return_unix (0, "TUNSETPERSIST");
528  goto done;
529  }
530 
531  /* Open a provisioning socket */
532  if ((tm->dev_tap_fd = socket(PF_PACKET, SOCK_RAW,
533  htons(ETH_P_ALL))) < 0 )
534  {
535  error = clib_error_return_unix (0, "socket");
536  goto done;
537  }
538 
539  /* Find the interface index. */
540  {
541  struct ifreq ifr;
542  struct sockaddr_ll sll;
543 
544  memset (&ifr, 0, sizeof(ifr));
545  strncpy (ifr.ifr_name, tm->tun_name, sizeof(ifr.ifr_name)-1);
546  if (ioctl (tm->dev_tap_fd, SIOCGIFINDEX, &ifr) < 0 )
547  {
548  error = clib_error_return_unix (0, "ioctl SIOCGIFINDEX");
549  goto done;
550  }
551 
552  /* Bind the provisioning socket to the interface. */
553  memset(&sll, 0, sizeof(sll));
554  sll.sll_family = AF_PACKET;
555  sll.sll_ifindex = ifr.ifr_ifindex;
556  sll.sll_protocol = htons(ETH_P_ALL);
557 
558  if (bind(tm->dev_tap_fd, (struct sockaddr*) &sll, sizeof(sll)) < 0)
559  {
560  error = clib_error_return_unix (0, "bind");
561  goto done;
562  }
563  }
564 
565  /* non-blocking I/O on /dev/tapX */
566  {
567  int one = 1;
568  if (ioctl (tm->dev_net_tun_fd, FIONBIO, &one) < 0)
569  {
570  error = clib_error_return_unix (0, "ioctl FIONBIO");
571  goto done;
572  }
573  }
574 
575  tm->mtu_buffers = (tm->mtu_bytes + (buffer_size - 1)) / buffer_size;
576 
577  ifr.ifr_mtu = tm->mtu_bytes;
578  if (ioctl (tm->dev_tap_fd, SIOCSIFMTU, &ifr) < 0)
579  {
580  error = clib_error_return_unix (0, "ioctl SIOCSIFMTU");
581  goto done;
582  }
583 
584  /* get flags, modify to bring up interface... */
585  if (ioctl (tm->dev_tap_fd, SIOCGIFFLAGS, &ifr) < 0)
586  {
587  error = clib_error_return_unix (0, "ioctl SIOCGIFFLAGS");
588  goto done;
589  }
590 
591  ifr.ifr_flags |= (IFF_UP | IFF_RUNNING);
592 
593  if (ioctl (tm->dev_tap_fd, SIOCSIFFLAGS, &ifr) < 0)
594  {
595  error = clib_error_return_unix (0, "ioctl SIOCSIFFLAGS");
596  goto done;
597  }
598 
599  if (is_ether)
600  {
601  if (ioctl (tm->dev_tap_fd, SIOCGIFHWADDR, &ifr) < 0)
602  {
603  error = clib_error_return_unix (0, "ioctl SIOCGIFHWADDR");
604  goto done;
605  }
606  else
607  clib_memcpy (tm->ether_dst_mac, ifr.ifr_hwaddr.sa_data, 6);
608  }
609 
610  if (have_normal_interface)
611  {
612  vnet_main_t *vnm = vnet_get_main();
614  (vnm,
615  tuntap_dev_class.index,
616  0 /* device instance */,
617  tm->ether_dst_mac /* ethernet address */,
618  &tm->hw_if_index,
619  0 /* flag change */);
620  if (error)
621  clib_error_report (error);
622  tm->sw_if_index = tm->hw_if_index;
624  }
625  else
626  {
627  vnet_main_t *vnm = vnet_get_main();
629 
631 
633  (vnm,
634  tuntap_dev_class.index, 0 /* device instance */,
635  tuntap_interface_class.index, 0);
636  hi = vnet_get_hw_interface (vnm, tm->hw_if_index);
637  tm->sw_if_index = hi->sw_if_index;
638 
639  /* Interface is always up. */
644  }
645 
646  {
647  unix_file_t template = {0};
648  template.read_function = tuntap_read_ready;
649  template.file_descriptor = tm->dev_net_tun_fd;
650  tm->unix_file_index = unix_file_add (&unix_main, &template);
651  }
652 
653  done:
654  if (error)
655  {
656  if (tm->dev_net_tun_fd >= 0)
657  close (tm->dev_net_tun_fd);
658  if (tm->dev_tap_fd >= 0)
659  close (tm->dev_tap_fd);
660  }
661 
662  return error;
663 }
664 
666 
667 /**
668  * @brief Add or Del IP4 address to tun/tap interface
669  *
670  * @param *im - ip4_main_t
671  * @param opaque - uword
672  * @param sw_if_index - u32
673  * @param *address - ip4_address_t
674  * @param is_delete - u32
675  *
676  */
677 void
679  uword opaque,
680  u32 sw_if_index,
681  ip4_address_t * address,
682  u32 address_length,
683  u32 if_address_index,
684  u32 is_delete)
685 {
686  tuntap_main_t * tm = &tuntap_main;
687  struct ifreq ifr;
688  subif_address_t subif_addr, * ap;
689  uword * p;
690 
691  /** Tuntap disabled, or using a "normal" interface. */
692  if (tm->have_normal_interface || tm->dev_tap_fd < 0)
693  return;
694 
695  /** See if we already know about this subif */
696  memset (&subif_addr, 0, sizeof (subif_addr));
697  subif_addr.sw_if_index = sw_if_index;
698  clib_memcpy (&subif_addr.addr, address, sizeof (*address));
699 
700  p = mhash_get (&tm->subif_mhash, &subif_addr);
701 
702  if (p)
703  ap = pool_elt_at_index (tm->subifs, p[0]);
704  else
705  {
706  pool_get (tm->subifs, ap);
707  *ap = subif_addr;
708  mhash_set (&tm->subif_mhash, ap, ap - tm->subifs, 0);
709  }
710 
711  /* Use subif pool index to select alias device. */
712  memset (&ifr, 0, sizeof (ifr));
713  snprintf (ifr.ifr_name, sizeof(ifr.ifr_name),
714  "%s:%d", tm->tun_name, (int)(ap - tm->subifs));
715 
716  /* the tuntap punt/inject is enabled for IPv4 RX so long as
717  * any vpp interface has an IPv4 address.
718  * this is also ref counted.
719  */
721 
722  if (! is_delete)
723  {
724  struct sockaddr_in * sin;
725 
726  sin = (struct sockaddr_in *)&ifr.ifr_addr;
727 
728  /* Set ipv4 address, netmask. */
729  sin->sin_family = AF_INET;
730  clib_memcpy (&sin->sin_addr.s_addr, address, 4);
731  if (ioctl (tm->dev_tap_fd, SIOCSIFADDR, &ifr) < 0)
732  clib_unix_warning ("ioctl SIOCSIFADDR");
733 
734  sin->sin_addr.s_addr = im->fib_masks[address_length];
735  if (ioctl (tm->dev_tap_fd, SIOCSIFNETMASK, &ifr) < 0)
736  clib_unix_warning ("ioctl SIOCSIFNETMASK");
737  }
738  else
739  {
740  mhash_unset (&tm->subif_mhash, &subif_addr, 0 /* old value ptr */);
741  pool_put (tm->subifs, ap);
742  }
743 
744  /* get flags, modify to bring up interface... */
745  if (ioctl (tm->dev_tap_fd, SIOCGIFFLAGS, &ifr) < 0)
746  clib_unix_warning ("ioctl SIOCGIFFLAGS");
747 
748  if (is_delete)
749  ifr.ifr_flags &= ~(IFF_UP | IFF_RUNNING);
750  else
751  ifr.ifr_flags |= (IFF_UP | IFF_RUNNING);
752 
753  if (ioctl (tm->dev_tap_fd, SIOCSIFFLAGS, &ifr) < 0)
754  clib_unix_warning ("ioctl SIOCSIFFLAGS");
755 }
756 
757 /**
758  * @brief workaround for a known include file bug.
759  * including @c <linux/ipv6.h> causes multiple definitions if
760  * @c <netinet/in.h is also included.
761  */
762 struct in6_ifreq {
763  struct in6_addr ifr6_addr;
766 };
767 
768 /**
769  * @brief Add or Del tun/tap interface address.
770  *
771  * Both the v6 interface address API and the way ifconfig
772  * displays subinterfaces differ from their v4 couterparts.
773  * The code given here seems to work but YMMV.
774  *
775  * @param *im - ip6_main_t
776  * @param opaque - uword
777  * @param sw_if_index - u32
778  * @param *address - ip6_address_t
779  * @param address_length - u32
780  * @param if_address_index - u32
781  * @param is_delete - u32
782  */
783 void
785  uword opaque,
786  u32 sw_if_index,
787  ip6_address_t * address,
788  u32 address_length,
789  u32 if_address_index,
790  u32 is_delete)
791 {
792  tuntap_main_t * tm = &tuntap_main;
793  struct ifreq ifr;
794  struct in6_ifreq ifr6;
795  subif_address_t subif_addr, * ap;
796  uword * p;
797 
798  /* Tuntap disabled, or using a "normal" interface. */
799  if (tm->have_normal_interface || tm->dev_tap_fd < 0)
800  return;
801 
802  /* See if we already know about this subif */
803  memset (&subif_addr, 0, sizeof (subif_addr));
804  subif_addr.sw_if_index = sw_if_index;
805  subif_addr.is_v6 = 1;
806  clib_memcpy (&subif_addr.addr, address, sizeof (*address));
807 
808  p = mhash_get (&tm->subif_mhash, &subif_addr);
809 
810  if (p)
811  ap = pool_elt_at_index (tm->subifs, p[0]);
812  else
813  {
814  pool_get (tm->subifs, ap);
815  *ap = subif_addr;
816  mhash_set (&tm->subif_mhash, ap, ap - tm->subifs, 0);
817  }
818 
819  /* Use subif pool index to select alias device. */
820  memset (&ifr, 0, sizeof (ifr));
821  memset (&ifr6, 0, sizeof (ifr6));
822  snprintf (ifr.ifr_name, sizeof(ifr.ifr_name),
823  "%s:%d", tm->tun_name, (int)(ap - tm->subifs));
824 
825  /* the tuntap punt/inject is enabled for IPv6 RX so long as
826  * any vpp interface has an IPv6 address.
827  * this is also ref counted.
828  */
830 
831  if (! is_delete)
832  {
833  int sockfd = socket (AF_INET6, SOCK_STREAM, 0);
834  if (sockfd < 0)
835  clib_unix_warning ("get ifindex socket");
836 
837  if (ioctl (sockfd, SIOGIFINDEX, &ifr) < 0)
838  clib_unix_warning ("get ifindex");
839 
840  ifr6.ifr6_ifindex = ifr.ifr_ifindex;
841  ifr6.ifr6_prefixlen = address_length;
842  clib_memcpy (&ifr6.ifr6_addr, address, 16);
843 
844  if (ioctl (sockfd, SIOCSIFADDR, &ifr6) < 0)
845  clib_unix_warning ("set address");
846 
847  if (sockfd >= 0)
848  close (sockfd);
849  }
850  else
851  {
852  int sockfd = socket (AF_INET6, SOCK_STREAM, 0);
853  if (sockfd < 0)
854  clib_unix_warning ("get ifindex socket");
855 
856  if (ioctl (sockfd, SIOGIFINDEX, &ifr) < 0)
857  clib_unix_warning ("get ifindex");
858 
859  ifr6.ifr6_ifindex = ifr.ifr_ifindex;
860  ifr6.ifr6_prefixlen = address_length;
861  clib_memcpy (&ifr6.ifr6_addr, address, 16);
862 
863  if (ioctl (sockfd, SIOCDIFADDR, &ifr6) < 0)
864  clib_unix_warning ("del address");
865 
866  if (sockfd >= 0)
867  close (sockfd);
868 
869  mhash_unset (&tm->subif_mhash, &subif_addr, 0 /* old value ptr */);
870  pool_put (tm->subifs, ap);
871  }
872 }
873 
874 /**
875  * @brief TX the tun/tap frame
876  *
877  * @param *vm - vlib_main_t
878  * @param *node - vlib_node_runtime_t
879  * @param *frame - vlib_frame_t
880  *
881  */
882 static void
884  vlib_node_runtime_t * node,
885  vlib_frame_t * frame)
886 {
887  tuntap_tx (vm, node, frame);
888  vlib_frame_free (vm, node, frame);
889 }
890 
891 /**
892  * @brief Free the tun/tap frame
893  *
894  * @param *vm - vlib_main_t
895  * @param *node - vlib_node_runtime_t
896  * @param *frame - vlib_frame_t
897  *
898  */
899 static void
901  vlib_node_runtime_t * node,
902  vlib_frame_t * frame)
903 {
904  u32 * buffers = vlib_frame_args (frame);
905  uword n_packets = frame->n_vectors;
906  vlib_buffer_free (vm, buffers, n_packets);
907  vlib_frame_free (vm, node, frame);
908 }
909 
911  .name = "tuntap",
913 };
914 
915 /**
916  * @brief Format tun/tap interface name
917  *
918  * @param *s - u8 - formatter string
919  * @param *args - va_list
920  *
921  * @return *s - u8 - formatted string
922  *
923  */
924 static u8 * format_tuntap_interface_name (u8 * s, va_list * args)
925 {
926  u32 i = va_arg (*args, u32);
927 
928  s = format (s, "tuntap-%d", i);
929  return s;
930 }
931 
932 /**
933  * @brief TX packet out tun/tap
934  *
935  * @param *vm - vlib_main_t
936  * @param *node - vlib_node_runtime_t
937  * @param *frame - vlib_frame_t
938  *
939  * @return n_buffers - uword - Packets transmitted
940  *
941  */
942 static uword
944  vlib_node_runtime_t * node,
945  vlib_frame_t * frame)
946 {
947  tuntap_main_t * tm = &tuntap_main;
948  u32 * buffers = vlib_frame_args (frame);
949  uword n_buffers = frame->n_vectors;
950 
951  /* Normal interface transmit happens only on the normal interface... */
952  if (tm->have_normal_interface)
953  return tuntap_tx (vm, node, frame);
954 
955  vlib_buffer_free (vm, buffers, n_buffers);
956  return n_buffers;
957 }
958 
960  .name = "tuntap",
961  .tx_function = tuntap_intfc_tx,
962  .format_device_name = format_tuntap_interface_name,
963 };
964 
965 /**
966  * @brief tun/tap node init
967  *
968  * @param *vm - vlib_main_t
969  *
970  * @return error - clib_error_t
971  *
972  */
973 static clib_error_t *
975 {
976  clib_error_t * error;
977  ip4_main_t * im4 = &ip4_main;
978  ip6_main_t * im6 = &ip6_main;
981  tuntap_main_t * tm = &tuntap_main;
982 
983  error = vlib_call_init_function (vm, ip4_init);
984  if (error)
985  return error;
986 
987  mhash_init (&tm->subif_mhash, sizeof (u32), sizeof(subif_address_t));
988 
990  cb4.function_opaque = 0;
992 
994  cb6.function_opaque = 0;
996 
997  return 0;
998 }
999 
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:396
static clib_error_t * tuntap_exit(vlib_main_t *vm)
Clean up the tun/tap device.
Definition: tuntap.c:410
vmrglw vmrglh hi
Definition: mhash.h:46
static uword tuntap_rx(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
TUNTAP receive node.
Definition: tuntap.c:224
static vlib_node_registration_t tuntap_tx_node
(constructor) VLIB_REGISTER_NODE (tuntap_tx_node)
Definition: tuntap.c:205
sll srl srl sll sra u16x4 i
Definition: vector_sse2.h:343
#define VLIB_BUFFER_TRACE_TRAJECTORY
Compile time buffer trajectory tracing option Turn this on if you run into "bad monkey" contexts...
Definition: buffer.h:401
uword unformat(unformat_input_t *i, char *fmt,...)
Definition: unformat.c:966
clib_error_t * vnet_hw_interface_set_flags(vnet_main_t *vnm, u32 hw_if_index, u32 flags)
Definition: interface.c:531
static u32 vlib_get_trace_count(vlib_main_t *vm, vlib_node_runtime_t *rt)
Definition: trace_funcs.h:143
ip4_add_del_interface_address_callback_t * add_del_interface_address_callbacks
Functions to call when interface address changes.
Definition: ip4.h:116
unix_file_function_t * read_function
Definition: unix.h:62
void tuntap_ip4_add_del_interface_address(ip4_main_t *im, uword opaque, u32 sw_if_index, ip4_address_t *address, u32 address_length, u32 if_address_index, u32 is_delete)
Add or Del IP4 address to tun/tap interface.
Definition: tuntap.c:678
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
static void vlib_set_next_frame_buffer(vlib_main_t *vm, vlib_node_runtime_t *node, u32 next_index, u32 buffer_index)
Definition: node_funcs.h:383
vnet_interface_main_t interface_main
Definition: vnet.h:57
static void vlib_node_set_interrupt_pending(vlib_main_t *vm, u32 node_index)
Definition: node_funcs.h:181
#define UNFORMAT_END_OF_INPUT
Definition: format.h:143
uword mhash_unset(mhash_t *h, void *key, uword *old_value)
Definition: mhash.c:353
int ifr6_ifindex
Definition: tuntap.c:765
static vnet_hw_interface_t * vnet_get_hw_interface(vnet_main_t *vnm, u32 hw_if_index)
static_always_inline void vnet_feature_start_device_input_x1(u32 sw_if_index, u32 *next0, vlib_buffer_t *b0, u16 buffer_advanced0)
Definition: feature.h:229
mhash_t subif_mhash
Hash for subif addresses.
Definition: tuntap.c:103
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:482
char * tun_name
Linux interface name for tun device.
Definition: tuntap.c:97
#define vec_add2(V, P, N)
Add N elements to end of vector V, return pointer to new elements in P.
Definition: vec.h:521
static vnet_sw_interface_t * vnet_get_sw_interface(vnet_main_t *vnm, u32 sw_if_index)
#define clib_error_report(e)
Definition: error.h:125
#define VNET_HW_INTERFACE_FLAG_LINK_UP
Definition: interface.h:377
TUNTAP node main state.
Definition: tuntap.c:72
struct _vnet_device_class vnet_device_class_t
vlib_error_t * errors
Definition: node.h:419
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:200
struct in6_addr ifr6_addr
Definition: tuntap.c:763
#define vec_alloc(V, N)
Allocate space for N more elements (no header, unspecified alignment)
Definition: vec.h:239
int dev_net_tun_fd
File descriptors for /dev/net/tun and provisioning socket.
Definition: tuntap.c:81
static uword unix_file_add(unix_main_t *um, unix_file_t *template)
Definition: unix.h:136
int dev_tap_fd
Definition: tuntap.c:81
static void vlib_trace_buffer(vlib_main_t *vm, vlib_node_runtime_t *r, u32 next_index, vlib_buffer_t *b, int follow_chain)
Definition: trace_funcs.h:104
vnet_main_t * vnet_get_main(void)
Definition: misc.c:46
u32 hw_if_index
For the "normal" interface, if configured.
Definition: tuntap.c:109
i16 current_data
signed offset in data[], pre_data[] that we are currently processing.
Definition: buffer.h:78
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:111
static clib_error_t * ip4_init(vlib_main_t *vm)
Definition: ip4_input.c:464
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:194
vlib_combined_counter_main_t * combined_sw_if_counters
Definition: interface.h:615
u8 pre_data[VLIB_BUFFER_PRE_DATA_SIZE]
Space for inserting data before buffer start.
Definition: buffer.h:150
static vnet_device_class_t tuntap_dev_class
Definition: tuntap.c:53
u32 cpu_index
Definition: main.h:159
#define clib_warning(format, args...)
Definition: error.h:59
static clib_error_t * tuntap_read_ready(unix_file_t *uf)
Gets called when file descriptor is ready from epoll.
Definition: tuntap.c:394
#define vlib_call_init_function(vm, x)
Definition: init.h:161
u32 vnet_register_interface(vnet_main_t *vnm, u32 dev_class_index, u32 dev_instance, u32 hw_class_index, u32 hw_instance)
Definition: interface.c:688
static u8 * format_tuntap_interface_name(u8 *s, va_list *args)
Format tun/tap interface name.
Definition: tuntap.c:924
#define VLIB_BUFFER_NEXT_PRESENT
Definition: buffer.h:97
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:369
void ip4_sw_interface_enable_disable(u32 sw_if_index, u32 is_enable)
Definition: ip4_forward.c:807
u16 current_length
Nbytes between current data and the end of this buffer.
Definition: buffer.h:82
subif_address_t * subifs
Pool of subinterface addresses.
Definition: tuntap.c:100
void vlib_frame_free(vlib_main_t *vm, vlib_node_runtime_t *r, vlib_frame_t *f)
Definition: main.c:216
uword os_get_cpu_number(void)
Definition: unix-misc.c:224
#define clib_error_return_unix(e, args...)
Definition: error.h:114
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:214
static tuntap_main_t tuntap_main
Definition: tuntap.c:113
#define PREDICT_FALSE(x)
Definition: clib.h:97
#define VLIB_CONFIG_FUNCTION(x, n,...)
Definition: init.h:118
vnet_main_t vnet_main
Definition: misc.c:43
#define VLIB_FRAME_SIZE
Definition: node.h:328
static void vlib_buffer_reset(vlib_buffer_t *b)
Reset current header & length to state they were in when packet was received.
Definition: buffer.h:221
static uword mhash_set(mhash_t *h, void *key, uword new_value, uword *old_value)
Definition: mhash.h:117
static uword tuntap_intfc_tx(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
TX packet out tun/tap.
Definition: tuntap.c:943
ip6_add_del_interface_address_callback_t * add_del_interface_address_callbacks
Definition: ip6.h:158
struct iovec * iovecs
Vector of iovecs for readv/writev calls.
Definition: tuntap.c:74
vlib_error_t error
Error code for buffers to be enqueued to error handler.
Definition: buffer.h:121
void tuntap_ip6_add_del_interface_address(ip6_main_t *im, uword opaque, u32 sw_if_index, ip6_address_t *address, u32 address_length, u32 if_address_index, u32 is_delete)
Add or Del tun/tap interface address.
Definition: tuntap.c:784
static void tuntap_nopunt_frame(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
Free the tun/tap frame.
Definition: tuntap.c:900
void mhash_init(mhash_t *h, uword n_value_bytes, uword n_key_bytes)
Definition: mhash.c:168
u16 n_vectors
Definition: node.h:344
ip4_add_del_interface_address_function_t * function
Definition: ip4.h:82
u8 addr[16]
Definition: tuntap.c:66
#define VLIB_MAIN_LOOP_EXIT_FUNCTION(x)
Definition: init.h:115
#define clib_memcpy(a, b, c)
Definition: string.h:69
#define clib_unix_warning(format, args...)
Definition: error.h:68
static void tuntap_punt_frame(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
TX the tun/tap frame.
Definition: tuntap.c:883
ip6_add_del_interface_address_function_t * function
Definition: ip6.h:89
#define VNET_SW_INTERFACE_FLAG_ADMIN_UP
Definition: interface.h:528
static void vlib_increment_combined_counter(vlib_combined_counter_main_t *cm, u32 cpu_index, u32 index, u32 packet_increment, u32 byte_increment)
Increment a combined counter.
Definition: counter.h:241
#define ASSERT(truth)
unsigned int u32
Definition: types.h:88
u32 mtu_buffers
Definition: tuntap.c:94
u8 ether_dst_mac[6]
tap device destination MAC address.
Definition: tuntap.c:91
static uword * mhash_get(mhash_t *h, const void *key)
Definition: mhash.h:110
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
#define vnet_buffer(b)
Definition: buffer.h:361
ip6_main_t ip6_main
Definition: ip6_forward.c:2828
void vlib_buffer_free(vlib_main_t *vm, u32 *buffers, u32 n_buffers)
Free buffers Frees the entire buffer chain for each buffer.
u32 mtu_bytes
Interface MTU in bytes and # of default sized buffers.
Definition: tuntap.c:94
IPv4 main type.
Definition: ip4.h:95
static vlib_node_registration_t tuntap_rx_node
(constructor) VLIB_REGISTER_NODE (tuntap_rx_node)
Definition: tuntap.c:376
u32 next_buffer
Next buffer for this linked-list of buffers.
Definition: buffer.h:117
clib_error_t * ethernet_register_interface(vnet_main_t *vnm, u32 dev_class_index, u32 dev_instance, u8 *address, u32 *hw_if_index_return, ethernet_flag_change_function_t flag_change)
Definition: interface.c:226
u32 unix_file_index
Unix file index.
Definition: tuntap.c:106
int have_normal_interface
1 if a "normal" routed intfc, 0 if a punt/inject interface
Definition: tuntap.c:88
static void * vlib_frame_args(vlib_frame_t *f)
Get pointer to frame scalar data.
Definition: node_funcs.h:270
u32 * rx_buffers
Vector of VLIB rx buffers to use.
Definition: tuntap.c:78
u32 vlib_buffer_alloc(vlib_main_t *vm, u32 *buffers, u32 n_buffers)
Allocate buffers into supplied array.
unix_main_t unix_main
Definition: main.c:57
u32 ifr6_prefixlen
Definition: tuntap.c:764
workaround for a known include file bug.
Definition: tuntap.c:762
VNET_DEVICE_CLASS(tuntap_dev_class, static)
int is_ether
Create a "tap" [ethernet] encaps device.
Definition: tuntap.c:84
u64 uword
Definition: types.h:112
static uword tuntap_tx(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
tuntap_tx
Definition: tuntap.c:135
Definition: defs.h:47
static clib_error_t * tuntap_config(vlib_main_t *vm, unformat_input_t *input)
CLI function for tun/tap config.
Definition: tuntap.c:460
i64 word
Definition: types.h:111
struct _vnet_hw_interface_class vnet_hw_interface_class_t
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
unsigned char u8
Definition: types.h:56
Definition: unix.h:49
a point 2 point interface
Definition: interface.h:272
#define VLIB_BUFFER_DATA_SIZE
Definition: buffer.h:51
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:169
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:143
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:418
ip4_main_t ip4_main
Global ip4 main structure.
Definition: ip4_forward.c:1099
u8 data[0]
Packet data.
Definition: buffer.h:158
void(* os_punt_frame)(struct vlib_main_t *vm, struct vlib_node_runtime_t *node, vlib_frame_t *frame)
Definition: main.h:128
clib_error_t * vnet_sw_interface_set_flags(vnet_main_t *vnm, u32 sw_if_index, u32 flags)
Definition: interface.c:539
u32 sw_if_index
Definition: tuntap.c:109
vhost_vring_addr_t addr
Definition: vhost-user.h:81
static clib_error_t * tuntap_init(vlib_main_t *vm)
tun/tap node init
Definition: tuntap.c:974
#define clib_error_return(e, args...)
Definition: error.h:111
struct _unformat_input_t unformat_input_t
void vlib_buffer_free_no_next(vlib_main_t *vm, u32 *buffers, u32 n_buffers)
Free buffers, does not free the buffer chain for each buffer.
static void vlib_set_trace_count(vlib_main_t *vm, vlib_node_runtime_t *rt, u32 count)
Definition: trace_funcs.h:159
VNET_HW_INTERFACE_CLASS(tuntap_interface_class, static)
static vnet_hw_interface_class_t tuntap_interface_class
Definition: tuntap.c:54
static char * tuntap_rx_error_strings[]
TUNTAP_RX error strings.
Definition: tuntap.c:372
u32 flags
Definition: vhost-user.h:75
u32 flags
buffer flags: VLIB_BUFFER_IS_TRACED: trace this buffer.
Definition: buffer.h:85
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
Definition: buffer_funcs.h:57
u32 sw_if_index
Definition: tuntap.c:64
void ip6_sw_interface_enable_disable(u32 sw_if_index, u32 is_enable)
Definition: ip6_forward.c:391
Definition: defs.h:46
u32 fib_masks[33]
Definition: ip4.h:102