src/plugins/af_xdp/device.c

   1 /*
   2  *------------------------------------------------------------------
   3  * Copyright (c) 2018 Cisco and/or its affiliates.
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *------------------------------------------------------------------
  16  */
  17
  18 #include <stdio.h>
  19 #include <net/if.h>
  20 #include <sys/ioctl.h>
  21 #include <linux/ethtool.h>
  22 #include <linux/if_link.h>
  23 #include <linux/sockios.h>
  24 #include <bpf/libbpf.h>
  25 #include <vlib/vlib.h>
  26 #include <vlib/unix/unix.h>
  27 #include <vlib/pci/pci.h>
  28 #include <vppinfra/linux/netns.h>
  29 #include <vppinfra/linux/sysfs.h>
  30 #include <vppinfra/unix.h>
  31 #include <vnet/ethernet/ethernet.h>
  32 #include <vnet/interface/rx_queue_funcs.h>
  33 #include <vnet/interface/tx_queue_funcs.h>
  34 #include "af_xdp.h"
  35
  36 af_xdp_main_t af_xdp_main;
  37
  38 typedef struct
  39 {
  40   u32 prod;
  41   u32 cons;
  42 } gdb_af_xdp_pair_t;
  43
  44 gdb_af_xdp_pair_t
  45 gdb_af_xdp_get_prod (const struct xsk_ring_prod *prod)
  46 {
  47   gdb_af_xdp_pair_t pair = { *prod->producer, *prod->consumer };
  48   return pair;
  49 }
  50
  51 gdb_af_xdp_pair_t
  52 gdb_af_xdp_get_cons (const struct xsk_ring_cons * cons)
  53 {
  54   gdb_af_xdp_pair_t pair = { *cons->producer, *cons->consumer };
  55   return pair;
  56 }
  57
  58 static clib_error_t *
  59 af_xdp_mac_change (vnet_hw_interface_t * hw, const u8 * old, const u8 * new)
  60 {
  61   af_xdp_main_t *am = &af_xdp_main;
  62   af_xdp_device_t *ad = vec_elt_at_index (am->devices, hw->dev_instance);
  63   errno_t err = memcpy_s (ad->hwaddr, sizeof (ad->hwaddr), new, 6);
  64   if (err)
  65     return clib_error_return_code (0, -err, CLIB_ERROR_ERRNO_VALID,
  66                                    "mac change failed");
  67   return 0;
  68 }
  69
  70 static clib_error_t *
  71 af_xdp_set_max_frame_size (vnet_main_t *vnm, vnet_hw_interface_t *hw,
  72                            u32 frame_size)
  73 {
  74   af_xdp_main_t *am = &af_xdp_main;
  75   af_xdp_device_t *ad = vec_elt_at_index (am->devices, hw->dev_instance);
  76   af_xdp_log (VLIB_LOG_LEVEL_ERR, ad, "set mtu not supported yet");
  77   return vnet_error (VNET_ERR_UNSUPPORTED, 0);
  78 }
  79
  80 static u32
  81 af_xdp_flag_change (vnet_main_t * vnm, vnet_hw_interface_t * hw, u32 flags)
  82 {
  83   af_xdp_main_t *am = &af_xdp_main;
  84   af_xdp_device_t *ad = vec_elt_at_index (am->devices, hw->dev_instance);
  85
  86   switch (flags)
  87     {
  88     case 0:
  89       af_xdp_log (VLIB_LOG_LEVEL_ERR, ad, "set unicast not supported yet");
  90       return ~0;
  91     case ETHERNET_INTERFACE_FLAG_ACCEPT_ALL:
  92       af_xdp_log (VLIB_LOG_LEVEL_ERR, ad,
  93                   "set promiscuous not supported yet");
  94       return ~0;
  95     }
  96
  97   af_xdp_log (VLIB_LOG_LEVEL_ERR, ad, "unknown flag %x requested", flags);
  98   return ~0;
  99 }
 100
 101 int
 102 af_xdp_enter_netns (char *netns, int *fds)
 103 {
 104   *fds = *(fds + 1) = -1;
 105   if (netns != NULL)
 106     {
 107       *fds = clib_netns_open (NULL /* self */);
 108       if ((*(fds + 1) = clib_netns_open ((u8 *) netns)) == -1)
 109         return VNET_API_ERROR_SYSCALL_ERROR_8;
 110       if (clib_setns (*(fds + 1)) == -1)
 111         return VNET_API_ERROR_SYSCALL_ERROR_9;
 112     }
 113   return 0;
 114 }
 115
 116 void
 117 af_xdp_cleanup_netns (int *fds)
 118 {
 119   if (*fds != -1)
 120     close (*fds);
 121
 122   if (*(fds + 1) != -1)
 123     close (*(fds + 1));
 124
 125   *fds = *(fds + 1) = -1;
 126 }
 127
 128 int
 129 af_xdp_exit_netns (char *netns, int *fds)
 130 {
 131   int ret = 0;
 132   if (netns != NULL)
 133     {
 134       if (*fds != -1)
 135         ret = clib_setns (*fds);
 136
 137       af_xdp_cleanup_netns (fds);
 138     }
 139
 140   return ret;
 141 }
 142
 143 void
 144 af_xdp_delete_if (vlib_main_t * vm, af_xdp_device_t * ad)
 145 {
 146   vnet_main_t *vnm = vnet_get_main ();
 147   af_xdp_main_t *axm = &af_xdp_main;
 148   struct xsk_socket **xsk;
 149   struct xsk_umem **umem;
 150   int i;
 151
 152   if (ad->hw_if_index)
 153     {
 154       vnet_hw_interface_set_flags (vnm, ad->hw_if_index, 0);
 155       ethernet_delete_interface (vnm, ad->hw_if_index);
 156     }
 157
 158   for (i = 0; i < ad->txq_num; i++)
 159     clib_spinlock_free (&vec_elt (ad->txqs, i).lock);
 160
 161   vec_foreach (xsk, ad->xsk)
 162     xsk_socket__delete (*xsk);
 163
 164   vec_foreach (umem, ad->umem)
 165     xsk_umem__delete (*umem);
 166
 167   for (i = 0; i < ad->rxq_num; i++)
 168     clib_file_del_by_index (&file_main, vec_elt (ad->rxqs, i).file_index);
 169
 170   if (ad->bpf_obj)
 171     {
 172       int ns_fds[2];
 173       af_xdp_enter_netns (ad->netns, ns_fds);
 174       bpf_set_link_xdp_fd (ad->linux_ifindex, -1, 0);
 175       af_xdp_exit_netns (ad->netns, ns_fds);
 176
 177       bpf_object__unload (ad->bpf_obj);
 178     }
 179
 180   vec_free (ad->xsk);
 181   vec_free (ad->umem);
 182   vec_free (ad->buffer_template);
 183   vec_free (ad->rxqs);
 184   vec_free (ad->txqs);
 185   vec_free (ad->name);
 186   vec_free (ad->linux_ifname);
 187   vec_free (ad->netns);
 188   clib_error_free (ad->error);
 189   pool_put (axm->devices, ad);
 190 }
 191
 192 static int
 193 af_xdp_load_program (af_xdp_create_if_args_t * args, af_xdp_device_t * ad)
 194 {
 195   int fd;
 196
 197   ad->linux_ifindex = if_nametoindex (ad->linux_ifname);
 198   if (!ad->linux_ifindex)
 199     {
 200       args->rv = VNET_API_ERROR_INVALID_VALUE;
 201       args->error =
 202         clib_error_return_unix (0, "if_nametoindex(%s) failed",
 203                                 ad->linux_ifname);
 204       goto err0;
 205     }
 206
 207   if (bpf_prog_load (args->prog, BPF_PROG_TYPE_XDP, &ad->bpf_obj, &fd))
 208     {
 209       args->rv = VNET_API_ERROR_SYSCALL_ERROR_5;
 210       args->error =
 211         clib_error_return_unix (0, "bpf_prog_load(%s) failed", args->prog);
 212       goto err0;
 213     }
 214
 215 #ifndef XDP_FLAGS_REPLACE
 216 #define XDP_FLAGS_REPLACE 0
 217 #endif
 218   if (bpf_set_link_xdp_fd (ad->linux_ifindex, fd, XDP_FLAGS_REPLACE))
 219     {
 220       args->rv = VNET_API_ERROR_SYSCALL_ERROR_6;
 221       args->error =
 222         clib_error_return_unix (0, "bpf_set_link_xdp_fd(%s) failed",
 223                                 ad->linux_ifname);
 224       goto err1;
 225     }
 226
 227   return 0;
 228
 229 err1:
 230   bpf_object__unload (ad->bpf_obj);
 231   ad->bpf_obj = 0;
 232 err0:
 233   ad->linux_ifindex = ~0;
 234   return -1;
 235 }
 236
 237 static int
 238 af_xdp_create_queue (vlib_main_t *vm, af_xdp_create_if_args_t *args,
 239                      af_xdp_device_t *ad, int qid)
 240 {
 241   struct xsk_umem **umem;
 242   struct xsk_socket **xsk;
 243   af_xdp_rxq_t *rxq;
 244   af_xdp_txq_t *txq;
 245   struct xsk_umem_config umem_config;
 246   struct xsk_socket_config sock_config;
 247   struct xdp_options opt;
 248   socklen_t optlen;
 249   const int is_rx = qid < ad->rxq_num;
 250   const int is_tx = qid < ad->txq_num;
 251
 252   umem = vec_elt_at_index (ad->umem, qid);
 253   xsk = vec_elt_at_index (ad->xsk, qid);
 254   rxq = vec_elt_at_index (ad->rxqs, qid);
 255   txq = vec_elt_at_index (ad->txqs, qid);
 256
 257   /*
 258    * fq and cq must always be allocated even if unused
 259    * whereas rx and tx indicates whether we want rxq, txq, or both
 260    */
 261   struct xsk_ring_cons *rx = is_rx ? &rxq->rx : 0;
 262   struct xsk_ring_prod *fq = &rxq->fq;
 263   struct xsk_ring_prod *tx = is_tx ? &txq->tx : 0;
 264   struct xsk_ring_cons *cq = &txq->cq;
 265   int fd;
 266
 267   memset (&umem_config, 0, sizeof (umem_config));
 268   umem_config.fill_size = args->rxq_size;
 269   umem_config.comp_size = args->txq_size;
 270   umem_config.frame_size =
 271     sizeof (vlib_buffer_t) + vlib_buffer_get_default_data_size (vm);
 272   umem_config.frame_headroom = sizeof (vlib_buffer_t);
 273   umem_config.flags = XDP_UMEM_UNALIGNED_CHUNK_FLAG;
 274   if (xsk_umem__create
 275       (umem, uword_to_pointer (vm->buffer_main->buffer_mem_start, void *),
 276        vm->buffer_main->buffer_mem_size, fq, cq, &umem_config))
 277     {
 278       args->rv = VNET_API_ERROR_SYSCALL_ERROR_1;
 279       args->error = clib_error_return_unix (0, "xsk_umem__create() failed");
 280       goto err0;
 281     }
 282
 283   memset (&sock_config, 0, sizeof (sock_config));
 284   sock_config.rx_size = args->rxq_size;
 285   sock_config.tx_size = args->txq_size;
 286   sock_config.bind_flags = XDP_USE_NEED_WAKEUP;
 287   switch (args->mode)
 288     {
 289     case AF_XDP_MODE_AUTO:
 290       break;
 291     case AF_XDP_MODE_COPY:
 292       sock_config.bind_flags |= XDP_COPY;
 293       break;
 294     case AF_XDP_MODE_ZERO_COPY:
 295       sock_config.bind_flags |= XDP_ZEROCOPY;
 296       break;
 297     }
 298   if (xsk_socket__create
 299       (xsk, ad->linux_ifname, qid, *umem, rx, tx, &sock_config))
 300     {
 301       args->rv = VNET_API_ERROR_SYSCALL_ERROR_2;
 302       args->error =
 303         clib_error_return_unix (0,
 304                                 "xsk_socket__create() failed (is linux netdev %s up?)",
 305                                 ad->linux_ifname);
 306       goto err1;
 307     }
 308
 309   fd = xsk_socket__fd (*xsk);
 310   optlen = sizeof (opt);
 311   if (getsockopt (fd, SOL_XDP, XDP_OPTIONS, &opt, &optlen))
 312     {
 313       args->rv = VNET_API_ERROR_SYSCALL_ERROR_3;
 314       args->error =
 315         clib_error_return_unix (0, "getsockopt(XDP_OPTIONS) failed");
 316       goto err2;
 317     }
 318   if (opt.flags & XDP_OPTIONS_ZEROCOPY)
 319     ad->flags |= AF_XDP_DEVICE_F_ZEROCOPY;
 320
 321   rxq->xsk_fd = is_rx ? fd : -1;
 322
 323   if (is_tx)
 324     {
 325       txq->xsk_fd = fd;
 326       clib_spinlock_init (&txq->lock);
 327       if (is_rx && (ad->flags & AF_XDP_DEVICE_F_SYSCALL_LOCK))
 328         {
 329           /* This is a shared rx+tx queue and we need to lock before syscalls.
 330            * Prior to Linux 5.6 there is a race condition preventing to call
 331            * poll() and sendto() concurrently on AF_XDP sockets. This was
 332            * fixed with commit 11cc2d21499cabe7e7964389634ed1de3ee91d33
 333            * to workaround this issue, we protect the syscalls with a
 334            * spinlock. Note that it also prevents to use interrupt mode in
 335            * multi workers setup, because in this case the poll() is done in
 336            * the framework w/o any possibility to protect it.
 337            * See
 338            * https://lore.kernel.org/bpf/BYAPR11MB365382C5DB1E5FCC53242609C1549@BYAPR11MB3653.namprd11.prod.outlook.com/
 339            */
 340           clib_spinlock_init (&rxq->syscall_lock);
 341           txq->syscall_lock = rxq->syscall_lock;
 342         }
 343     }
 344   else
 345     {
 346       txq->xsk_fd = -1;
 347     }
 348
 349   return 0;
 350
 351 err2:
 352   xsk_socket__delete (*xsk);
 353 err1:
 354   xsk_umem__delete (*umem);
 355 err0:
 356   *umem = 0;
 357   *xsk = 0;
 358   return -1;
 359 }
 360
 361 static int
 362 af_xdp_get_numa (const char *ifname)
 363 {
 364   char *path;
 365   clib_error_t *err;
 366   int numa;
 367
 368   path =
 369     (char *) format (0, "/sys/class/net/%s/device/numa_node%c", ifname, 0);
 370   err = clib_sysfs_read (path, "%d", &numa);
 371   if (err || numa < 0)
 372     numa = 0;
 373
 374   clib_error_free (err);
 375   vec_free (path);
 376   return numa;
 377 }
 378
 379 static void
 380 af_xdp_get_q_count (const char *ifname, int *rxq_num, int *txq_num)
 381 {
 382   struct ethtool_channels ec = { .cmd = ETHTOOL_GCHANNELS };
 383   struct ifreq ifr = { .ifr_data = (void *) &ec };
 384   int fd, err;
 385
 386   *rxq_num = *txq_num = 1;
 387
 388   fd = socket (AF_INET, SOCK_DGRAM, 0);
 389   if (fd < 0)
 390     return;
 391
 392   snprintf (ifr.ifr_name, sizeof (ifr.ifr_name), "%s", ifname);
 393   err = ioctl (fd, SIOCETHTOOL, &ifr);
 394
 395   close (fd);
 396
 397   if (err)
 398     return;
 399
 400   *rxq_num = clib_max (ec.combined_count, ec.rx_count);
 401   *txq_num = clib_max (ec.combined_count, ec.tx_count);
 402 }
 403
 404 static clib_error_t *
 405 af_xdp_device_rxq_read_ready (clib_file_t * f)
 406 {
 407   vnet_hw_if_rx_queue_set_int_pending (vnet_get_main (), f->private_data);
 408   return 0;
 409 }
 410
 411 static clib_error_t *
 412 af_xdp_device_set_rxq_mode (const af_xdp_device_t *ad, af_xdp_rxq_t *rxq,
 413                             const af_xdp_rxq_mode_t mode)
 414 {
 415   clib_file_main_t *fm = &file_main;
 416   clib_file_update_type_t update;
 417   clib_file_t *f;
 418
 419   if (rxq->mode == mode)
 420     return 0;
 421
 422   switch (mode)
 423     {
 424     case AF_XDP_RXQ_MODE_POLLING:
 425       update = UNIX_FILE_UPDATE_DELETE;
 426       break;
 427     case AF_XDP_RXQ_MODE_INTERRUPT:
 428       if (ad->flags & AF_XDP_DEVICE_F_SYSCALL_LOCK)
 429         return clib_error_create (
 430           "kernel workaround incompatible with interrupt mode");
 431       update = UNIX_FILE_UPDATE_ADD;
 432       break;
 433     default:
 434       ASSERT (0);
 435       return clib_error_create ("unknown rxq mode %i", mode);
 436     }
 437
 438   f = clib_file_get (fm, rxq->file_index);
 439   fm->file_update (f, update);
 440   rxq->mode = mode;
 441   return 0;
 442 }
 443
 444 static u32
 445 af_xdp_find_rxq_for_thread (vnet_main_t *vnm, const af_xdp_device_t *ad,
 446                             const u32 thread)
 447 {
 448   u32 i;
 449   for (i = 0; i < ad->rxq_num; i++)
 450     {
 451       const u32 qid = vec_elt (ad->rxqs, i).queue_index;
 452       const u32 tid = vnet_hw_if_get_rx_queue (vnm, qid)->thread_index;
 453       if (tid == thread)
 454         return i;
 455     }
 456   return ~0;
 457 }
 458
 459 static clib_error_t *
 460 af_xdp_finalize_queues (vnet_main_t *vnm, af_xdp_device_t *ad,
 461                         const int n_vlib_mains)
 462 {
 463   clib_error_t *err = 0;
 464   int i;
 465
 466   for (i = 0; i < ad->rxq_num; i++)
 467     {
 468       af_xdp_rxq_t *rxq = vec_elt_at_index (ad->rxqs, i);
 469       rxq->queue_index = vnet_hw_if_register_rx_queue (
 470         vnm, ad->hw_if_index, i, VNET_HW_IF_RXQ_THREAD_ANY);
 471       u8 *desc = format (0, "%U rxq %d", format_af_xdp_device_name,
 472                          ad->dev_instance, i);
 473       clib_file_t f = {
 474         .file_descriptor = rxq->xsk_fd,
 475         .private_data = rxq->queue_index,
 476         .read_function = af_xdp_device_rxq_read_ready,
 477         .description = desc,
 478       };
 479       rxq->file_index = clib_file_add (&file_main, &f);
 480       vnet_hw_if_set_rx_queue_file_index (vnm, rxq->queue_index,
 481                                           rxq->file_index);
 482       err = af_xdp_device_set_rxq_mode (ad, rxq, AF_XDP_RXQ_MODE_POLLING);
 483       if (err)
 484         return err;
 485     }
 486
 487   for (i = 0; i < ad->txq_num; i++)
 488     vec_elt (ad->txqs, i).queue_index =
 489       vnet_hw_if_register_tx_queue (vnm, ad->hw_if_index, i);
 490
 491   /* We set the rxq and txq of the same queue pair on the same thread
 492    * by default to avoid locking because of the syscall lock. */
 493   int last_qid = clib_min (ad->rxq_num, ad->txq_num - 1);
 494   for (i = 0; i < n_vlib_mains; i++)
 495     {
 496       /* search for the 1st rxq assigned on this thread, if any */
 497       u32 qid = af_xdp_find_rxq_for_thread (vnm, ad, i);
 498       /* if this rxq is combined with a txq, use it. Otherwise, we'll
 499        * assign txq in a round-robin fashion. We start from the 1st txq
 500        * not shared with a rxq if possible... */
 501       qid = qid < ad->txq_num ? qid : (last_qid++ % ad->txq_num);
 502       vnet_hw_if_tx_queue_assign_thread (
 503         vnm, vec_elt (ad->txqs, qid).queue_index, i);
 504     }
 505
 506   vnet_hw_if_update_runtime_data (vnm, ad->hw_if_index);
 507   return 0;
 508 }
 509
 510 void
 511 af_xdp_create_if (vlib_main_t * vm, af_xdp_create_if_args_t * args)
 512 {
 513   vnet_main_t *vnm = vnet_get_main ();
 514   vlib_thread_main_t *tm = vlib_get_thread_main ();
 515   vnet_eth_interface_registration_t eir = {};
 516   af_xdp_main_t *am = &af_xdp_main;
 517   af_xdp_device_t *ad;
 518   vnet_sw_interface_t *sw;
 519   int rxq_num, txq_num, q_num;
 520   int ns_fds[2];
 521   int i, ret;
 522
 523   args->rxq_size = args->rxq_size ? args->rxq_size : 2 * VLIB_FRAME_SIZE;
 524   args->txq_size = args->txq_size ? args->txq_size : 2 * VLIB_FRAME_SIZE;
 525   args->rxq_num = args->rxq_num ? args->rxq_num : 1;
 526
 527   if (!args->linux_ifname)
 528     {
 529       args->rv = VNET_API_ERROR_INVALID_VALUE;
 530       args->error = clib_error_return (0, "missing host interface");
 531       goto err0;
 532     }
 533
 534   if (args->rxq_size < VLIB_FRAME_SIZE || args->txq_size < VLIB_FRAME_SIZE ||
 535       args->rxq_size > 65535 || args->txq_size > 65535 ||
 536       !is_pow2 (args->rxq_size) || !is_pow2 (args->txq_size))
 537     {
 538       args->rv = VNET_API_ERROR_INVALID_VALUE;
 539       args->error =
 540         clib_error_return (0,
 541                            "queue size must be a power of two between %i and 65535",
 542                            VLIB_FRAME_SIZE);
 543       goto err0;
 544     }
 545
 546   ret = af_xdp_enter_netns (args->netns, ns_fds);
 547   if (ret)
 548     {
 549       args->rv = ret;
 550       args->error = clib_error_return (0, "enter netns %s failed, ret %d",
 551                                        args->netns, args->rv);
 552       goto err0;
 553     }
 554
 555   af_xdp_get_q_count (args->linux_ifname, &rxq_num, &txq_num);
 556   if (args->rxq_num > rxq_num && AF_XDP_NUM_RX_QUEUES_ALL != args->rxq_num)
 557     {
 558       args->rv = VNET_API_ERROR_INVALID_VALUE;
 559       args->error = clib_error_create ("too many rxq requested (%d > %d)",
 560                                        args->rxq_num, rxq_num);
 561       goto err1;
 562     }
 563   rxq_num = clib_min (rxq_num, args->rxq_num);
 564   txq_num = clib_min (txq_num, tm->n_vlib_mains);
 565
 566   pool_get_zero (am->devices, ad);
 567
 568   if (tm->n_vlib_mains > 1 &&
 569       0 == (args->flags & AF_XDP_CREATE_FLAGS_NO_SYSCALL_LOCK))
 570     ad->flags |= AF_XDP_DEVICE_F_SYSCALL_LOCK;
 571
 572   ad->linux_ifname = (char *) format (0, "%s", args->linux_ifname);
 573   vec_validate (ad->linux_ifname, IFNAMSIZ - 1);        /* libbpf expects ifname to be at least IFNAMSIZ */
 574
 575   ad->netns = (char *) format (0, "%s", args->netns);
 576
 577   if (args->prog && af_xdp_load_program (args, ad))
 578     goto err2;
 579
 580   q_num = clib_max (rxq_num, txq_num);
 581   ad->rxq_num = rxq_num;
 582   ad->txq_num = txq_num;
 583
 584   vec_validate_aligned (ad->umem, q_num - 1, CLIB_CACHE_LINE_BYTES);
 585   vec_validate_aligned (ad->xsk, q_num - 1, CLIB_CACHE_LINE_BYTES);
 586   vec_validate_aligned (ad->rxqs, q_num - 1, CLIB_CACHE_LINE_BYTES);
 587   vec_validate_aligned (ad->txqs, q_num - 1, CLIB_CACHE_LINE_BYTES);
 588
 589   for (i = 0; i < q_num; i++)
 590     {
 591       if (af_xdp_create_queue (vm, args, ad, i))
 592         {
 593           /*
 594            * queue creation failed
 595            * it is only a fatal error if we could not create the number of rx
 596            * queues requested explicitely by the user and the user did not
 597            * requested 'max'
 598            * we might create less tx queues than workers but this is ok
 599            */
 600           af_xdp_log (VLIB_LOG_LEVEL_DEBUG, ad,
 601                       "create interface failed to create queue qid=%d", i);
 602
 603           /* fixup vectors length */
 604           vec_set_len (ad->umem, i);
 605           vec_set_len (ad->xsk, i);
 606           vec_set_len (ad->rxqs, i);
 607           vec_set_len (ad->txqs, i);
 608
 609           ad->rxq_num = clib_min (i, rxq_num);
 610           ad->txq_num = clib_min (i, txq_num);
 611
 612           if (i == 0 ||
 613               (i < rxq_num && AF_XDP_NUM_RX_QUEUES_ALL != args->rxq_num))
 614             {
 615               ad->rxq_num = ad->txq_num = 0;
 616               goto err2; /* failed creating requested rxq: fatal error, bailing
 617                             out */
 618             }
 619
 620
 621           args->rv = 0;
 622           clib_error_free (args->error);
 623           break;
 624         }
 625     }
 626
 627   if (af_xdp_exit_netns (args->netns, ns_fds))
 628     {
 629       args->rv = VNET_API_ERROR_SYSCALL_ERROR_10;
 630       args->error = clib_error_return (0, "exit netns failed");
 631       goto err2;
 632     }
 633
 634   ad->dev_instance = ad - am->devices;
 635   ad->per_interface_next_index = VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT;
 636   ad->pool =
 637     vlib_buffer_pool_get_default_for_numa (vm,
 638                                            af_xdp_get_numa
 639                                            (ad->linux_ifname));
 640   if (!args->name)
 641     {
 642       char *ifname = ad->linux_ifname;
 643       if (args->netns != NULL && strncmp (args->netns, "pid:", 4) == 0)
 644         {
 645           ad->name =
 646             (char *) format (0, "%s/%u", ifname, atoi (args->netns + 4));
 647         }
 648       else
 649         ad->name = (char *) format (0, "%s/%d", ifname, ad->dev_instance);
 650     }
 651   else
 652     ad->name = (char *) format (0, "%s", args->name);
 653
 654   ethernet_mac_address_generate (ad->hwaddr);
 655
 656   /* create interface */
 657   eir.dev_class_index = af_xdp_device_class.index;
 658   eir.dev_instance = ad->dev_instance;
 659   eir.address = ad->hwaddr;
 660   eir.cb.flag_change = af_xdp_flag_change;
 661   eir.cb.set_max_frame_size = af_xdp_set_max_frame_size;
 662   ad->hw_if_index = vnet_eth_register_interface (vnm, &eir);
 663
 664   sw = vnet_get_hw_sw_interface (vnm, ad->hw_if_index);
 665   args->sw_if_index = ad->sw_if_index = sw->sw_if_index;
 666
 667   vnet_hw_if_set_caps (vnm, ad->hw_if_index, VNET_HW_IF_CAP_INT_MODE);
 668
 669   vnet_hw_if_set_input_node (vnm, ad->hw_if_index, af_xdp_input_node.index);
 670
 671   args->error = af_xdp_finalize_queues (vnm, ad, tm->n_vlib_mains);
 672   if (args->error)
 673     {
 674       args->rv = VNET_API_ERROR_SYSCALL_ERROR_7;
 675       goto err2;
 676     }
 677
 678   /* buffer template */
 679   vec_validate_aligned (ad->buffer_template, 1, CLIB_CACHE_LINE_BYTES);
 680   ad->buffer_template->flags = VLIB_BUFFER_TOTAL_LENGTH_VALID;
 681   ad->buffer_template->ref_count = 1;
 682   vnet_buffer (ad->buffer_template)->sw_if_index[VLIB_RX] = ad->sw_if_index;
 683   vnet_buffer (ad->buffer_template)->sw_if_index[VLIB_TX] = (u32) ~ 0;
 684   ad->buffer_template->buffer_pool_index = ad->pool;
 685
 686   return;
 687
 688 err2:
 689   af_xdp_delete_if (vm, ad);
 690 err1:
 691   af_xdp_cleanup_netns (ns_fds);
 692 err0:
 693   vlib_log_err (am->log_class, "%U", format_clib_error, args->error);
 694 }
 695
 696 static clib_error_t *
 697 af_xdp_interface_admin_up_down (vnet_main_t * vnm, u32 hw_if_index, u32 flags)
 698 {
 699   vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
 700   af_xdp_main_t *am = &af_xdp_main;
 701   af_xdp_device_t *ad = vec_elt_at_index (am->devices, hi->dev_instance);
 702   uword is_up = (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) != 0;
 703
 704   if (ad->flags & AF_XDP_DEVICE_F_ERROR)
 705     return clib_error_return (0, "device is in error state");
 706
 707   if (is_up)
 708     {
 709       vnet_hw_interface_set_flags (vnm, ad->hw_if_index,
 710                                    VNET_HW_INTERFACE_FLAG_LINK_UP);
 711       ad->flags |= AF_XDP_DEVICE_F_ADMIN_UP;
 712       af_xdp_device_input_refill (ad);
 713     }
 714   else
 715     {
 716       vnet_hw_interface_set_flags (vnm, ad->hw_if_index, 0);
 717       ad->flags &= ~AF_XDP_DEVICE_F_ADMIN_UP;
 718     }
 719   return 0;
 720 }
 721
 722 static clib_error_t *
 723 af_xdp_interface_rx_mode_change (vnet_main_t *vnm, u32 hw_if_index, u32 qid,
 724                                  vnet_hw_if_rx_mode mode)
 725 {
 726   af_xdp_main_t *am = &af_xdp_main;
 727   vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, hw_if_index);
 728   af_xdp_device_t *ad = pool_elt_at_index (am->devices, hw->dev_instance);
 729   af_xdp_rxq_t *rxq = vec_elt_at_index (ad->rxqs, qid);
 730
 731   switch (mode)
 732     {
 733     default:                         /* fallthrough */
 734     case VNET_HW_IF_RX_MODE_UNKNOWN: /* fallthrough */
 735     case VNET_HW_IF_NUM_RX_MODES:
 736       return clib_error_create ("uknown rx mode - doing nothing");
 737     case VNET_HW_IF_RX_MODE_DEFAULT: /* fallthrough */
 738     case VNET_HW_IF_RX_MODE_POLLING:
 739       return af_xdp_device_set_rxq_mode (ad, rxq, AF_XDP_RXQ_MODE_POLLING);
 740     case VNET_HW_IF_RX_MODE_INTERRUPT: /* fallthrough */
 741     case VNET_HW_IF_RX_MODE_ADAPTIVE:
 742       return af_xdp_device_set_rxq_mode (ad, rxq, AF_XDP_RXQ_MODE_INTERRUPT);
 743     }
 744
 745   ASSERT (0 && "unreachable");
 746   return clib_error_create ("unreachable");
 747 }
 748
 749 static void
 750 af_xdp_set_interface_next_node (vnet_main_t * vnm, u32 hw_if_index,
 751                                 u32 node_index)
 752 {
 753   af_xdp_main_t *am = &af_xdp_main;
 754   vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, hw_if_index);
 755   af_xdp_device_t *ad = pool_elt_at_index (am->devices, hw->dev_instance);
 756
 757   /* Shut off redirection */
 758   if (node_index == ~0)
 759     {
 760       ad->per_interface_next_index = node_index;
 761       return;
 762     }
 763
 764   ad->per_interface_next_index =
 765     vlib_node_add_next (vlib_get_main (), af_xdp_input_node.index,
 766                         node_index);
 767 }
 768
 769 static char *af_xdp_tx_func_error_strings[] = {
 770 #define _(n,s) s,
 771   foreach_af_xdp_tx_func_error
 772 #undef _
 773 };
 774
 775 static void
 776 af_xdp_clear (u32 dev_instance)
 777 {
 778   af_xdp_main_t *am = &af_xdp_main;
 779   af_xdp_device_t *ad = pool_elt_at_index (am->devices, dev_instance);
 780   clib_error_free (ad->error);
 781 }
 782
 783 /* *INDENT-OFF* */
 784 VNET_DEVICE_CLASS (af_xdp_device_class) = {
 785   .name = "AF_XDP interface",
 786   .format_device = format_af_xdp_device,
 787   .format_device_name = format_af_xdp_device_name,
 788   .admin_up_down_function = af_xdp_interface_admin_up_down,
 789   .rx_mode_change_function = af_xdp_interface_rx_mode_change,
 790   .rx_redirect_to_node = af_xdp_set_interface_next_node,
 791   .tx_function_n_errors = AF_XDP_TX_N_ERROR,
 792   .tx_function_error_strings = af_xdp_tx_func_error_strings,
 793   .mac_addr_change_function = af_xdp_mac_change,
 794   .clear_counters = af_xdp_clear,
 795 };
 796 /* *INDENT-ON* */
 797
 798 clib_error_t *
 799 af_xdp_init (vlib_main_t * vm)
 800 {
 801   af_xdp_main_t *am = &af_xdp_main;
 802
 803   am->log_class = vlib_log_register_class ("af_xdp", 0);
 804
 805   return 0;
 806 }
 807
 808 VLIB_INIT_FUNCTION (af_xdp_init);
 809
 810 /*
 811  * fd.io coding-style-patch-verification: ON
 812  *
 813  * Local Variables:
 814  * eval: (c-set-style "gnu")
 815  * End:
 816  */