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