src/plugins/rdma/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 <unistd.h>
  19 #include <fcntl.h>
  20 #include <net/if.h>
  21 #include <linux/if_link.h>
  22 #include <linux/if_ether.h>
  23
  24 #include <vppinfra/linux/sysfs.h>
  25 #include <vlib/vlib.h>
  26 #include <vlib/unix/unix.h>
  27 #include <vlib/pci/pci.h>
  28 #include <vnet/ethernet/ethernet.h>
  29 #include <vnet/interface/rx_queue_funcs.h>
  30
  31 #include <rdma/rdma.h>
  32
  33 /* Default RSS hash key (from DPDK MLX driver) */
  34 static u8 rdma_rss_hash_key[] = {
  35   0x2c, 0xc6, 0x81, 0xd1,
  36   0x5b, 0xdb, 0xf4, 0xf7,
  37   0xfc, 0xa2, 0x83, 0x19,
  38   0xdb, 0x1a, 0x3e, 0x94,
  39   0x6b, 0x9e, 0x38, 0xd9,
  40   0x2c, 0x9c, 0x03, 0xd1,
  41   0xad, 0x99, 0x44, 0xa7,
  42   0xd9, 0x56, 0x3d, 0x59,
  43   0x06, 0x3c, 0x25, 0xf3,
  44   0xfc, 0x1f, 0xdc, 0x2a,
  45 };
  46
  47 rdma_main_t rdma_main;
  48
  49 /* (dev) is of type (rdma_device_t *) */
  50 #define rdma_log__(lvl, dev, f, ...)                                          \
  51   do                                                                          \
  52     {                                                                         \
  53       vlib_log ((lvl), rdma_main.log_class, "%s: " f, (dev)->name,            \
  54                 ##__VA_ARGS__);                                               \
  55     }                                                                         \
  56   while (0)
  57
  58 #define rdma_log(lvl, dev, f, ...) \
  59    rdma_log__((lvl), (dev), "%s (%d): " f, strerror(errno), errno, ##__VA_ARGS__)
  60
  61 static struct ibv_flow *
  62 rdma_rxq_init_flow (const rdma_device_t * rd, struct ibv_qp *qp,
  63                     const mac_address_t * mac, const mac_address_t * mask,
  64                     u16 ether_type, u32 flags)
  65 {
  66   struct ibv_flow *flow;
  67   struct raw_eth_flow_attr
  68   {
  69     struct ibv_flow_attr attr;
  70     struct ibv_flow_spec_eth spec_eth;
  71   } __attribute__ ((packed)) fa;
  72
  73   memset (&fa, 0, sizeof (fa));
  74   fa.attr.num_of_specs = 1;
  75   fa.attr.port = 1;
  76   fa.attr.flags = flags;
  77   fa.spec_eth.type = IBV_FLOW_SPEC_ETH;
  78   fa.spec_eth.size = sizeof (struct ibv_flow_spec_eth);
  79
  80   memcpy (fa.spec_eth.val.dst_mac, mac, sizeof (fa.spec_eth.val.dst_mac));
  81   memcpy (fa.spec_eth.mask.dst_mac, mask, sizeof (fa.spec_eth.mask.dst_mac));
  82
  83   if (ether_type)
  84     {
  85       fa.spec_eth.val.ether_type = ether_type;
  86       fa.spec_eth.mask.ether_type = 0xffff;
  87     }
  88
  89   flow = ibv_create_flow (qp, &fa.attr);
  90   if (!flow)
  91     rdma_log (VLIB_LOG_LEVEL_ERR, rd, "ibv_create_flow() failed");
  92   return flow;
  93 }
  94
  95 static u32
  96 rdma_rxq_destroy_flow (const rdma_device_t * rd, struct ibv_flow **flow)
  97 {
  98   if (!*flow)
  99     return 0;
 100
 101   if (ibv_destroy_flow (*flow))
 102     {
 103       rdma_log (VLIB_LOG_LEVEL_ERR, rd, "ibv_destroy_flow() failed");
 104       return ~0;
 105     }
 106
 107   *flow = 0;
 108   return 0;
 109 }
 110
 111 static u32
 112 rdma_dev_set_promisc (rdma_device_t * rd)
 113 {
 114   const mac_address_t all = {.bytes = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0} };
 115   int err;
 116
 117   err = rdma_rxq_destroy_flow (rd, &rd->flow_mcast6);
 118   err |= rdma_rxq_destroy_flow (rd, &rd->flow_ucast6);
 119   err |= rdma_rxq_destroy_flow (rd, &rd->flow_mcast4);
 120   err |= rdma_rxq_destroy_flow (rd, &rd->flow_ucast4);
 121   if (err)
 122     return ~0;
 123
 124   rd->flow_ucast6 =
 125     rdma_rxq_init_flow (rd, rd->rx_qp6, &all, &all, ntohs (ETH_P_IPV6), 0);
 126   rd->flow_ucast4 = rdma_rxq_init_flow (rd, rd->rx_qp4, &all, &all, 0, 0);
 127   if (!rd->flow_ucast6 || !rd->flow_ucast4)
 128     return ~0;
 129
 130   rd->flags |= RDMA_DEVICE_F_PROMISC;
 131   return 0;
 132 }
 133
 134 static u32
 135 rdma_dev_set_ucast (rdma_device_t * rd)
 136 {
 137   const mac_address_t ucast = {.bytes = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}
 138   };
 139   const mac_address_t mcast = {.bytes = {0x1, 0x0, 0x0, 0x0, 0x0, 0x0} };
 140   int err;
 141
 142   err = rdma_rxq_destroy_flow (rd, &rd->flow_mcast6);
 143   err |= rdma_rxq_destroy_flow (rd, &rd->flow_ucast6);
 144   err |= rdma_rxq_destroy_flow (rd, &rd->flow_mcast4);
 145   err |= rdma_rxq_destroy_flow (rd, &rd->flow_ucast4);
 146   if (err)
 147     return ~0;
 148
 149   rd->flow_ucast6 =
 150     rdma_rxq_init_flow (rd, rd->rx_qp6, &rd->hwaddr, &ucast,
 151                         ntohs (ETH_P_IPV6), 0);
 152   rd->flow_mcast6 =
 153     rdma_rxq_init_flow (rd, rd->rx_qp6, &mcast, &mcast, ntohs (ETH_P_IPV6),
 154                         IBV_FLOW_ATTR_FLAGS_DONT_TRAP
 155                         /* let others receive mcast packet too (eg. Linux) */
 156     );
 157   rd->flow_ucast4 =
 158     rdma_rxq_init_flow (rd, rd->rx_qp4, &rd->hwaddr, &ucast, 0, 0);
 159   rd->flow_mcast4 =
 160     rdma_rxq_init_flow (rd, rd->rx_qp4, &mcast, &mcast, 0,
 161                         IBV_FLOW_ATTR_FLAGS_DONT_TRAP
 162                         /* let others receive mcast packet too (eg. Linux) */
 163     );
 164   if (!rd->flow_ucast6 || !rd->flow_mcast6 || !rd->flow_ucast4
 165       || !rd->flow_mcast4)
 166     return ~0;
 167
 168   rd->flags &= ~RDMA_DEVICE_F_PROMISC;
 169   return 0;
 170 }
 171
 172 static clib_error_t *
 173 rdma_mac_change (vnet_hw_interface_t * hw, const u8 * old, const u8 * new)
 174 {
 175   rdma_main_t *rm = &rdma_main;
 176   rdma_device_t *rd = vec_elt_at_index (rm->devices, hw->dev_instance);
 177   mac_address_from_bytes (&rd->hwaddr, new);
 178   if (!(rd->flags & RDMA_DEVICE_F_PROMISC) && rdma_dev_set_ucast (rd))
 179     {
 180       mac_address_from_bytes (&rd->hwaddr, old);
 181       return clib_error_return_unix (0, "MAC update failed");
 182     }
 183   return 0;
 184 }
 185
 186 static clib_error_t *
 187 rdma_set_max_frame_size (vnet_main_t *vnm, vnet_hw_interface_t *hw,
 188                          u32 frame_size)
 189 {
 190   return vnet_error (VNET_ERR_UNSUPPORTED, 0);
 191 }
 192
 193 static u32
 194 rdma_flag_change (vnet_main_t * vnm, vnet_hw_interface_t * hw, u32 flags)
 195 {
 196   rdma_main_t *rm = &rdma_main;
 197   rdma_device_t *rd = vec_elt_at_index (rm->devices, hw->dev_instance);
 198
 199   switch (flags)
 200     {
 201     case ETHERNET_INTERFACE_FLAG_DEFAULT_L3:
 202       return rdma_dev_set_ucast (rd);
 203     case ETHERNET_INTERFACE_FLAG_ACCEPT_ALL:
 204       return rdma_dev_set_promisc (rd);
 205     }
 206
 207   rdma_log__ (VLIB_LOG_LEVEL_ERR, rd, "unknown flag %x requested", flags);
 208   return ~0;
 209 }
 210
 211 static void
 212 rdma_update_state (vnet_main_t * vnm, rdma_device_t * rd, int port)
 213 {
 214   struct ibv_port_attr attr;
 215   u32 width = 0;
 216   u32 speed = 0;
 217
 218   if (ibv_query_port (rd->ctx, port, &attr))
 219     {
 220       vnet_hw_interface_set_link_speed (vnm, rd->hw_if_index, 0);
 221       vnet_hw_interface_set_flags (vnm, rd->hw_if_index, 0);
 222       return;
 223     }
 224
 225   /* update state */
 226   switch (attr.state)
 227     {
 228     case IBV_PORT_ACTIVE:       /* fallthrough */
 229     case IBV_PORT_ACTIVE_DEFER:
 230       rd->flags |= RDMA_DEVICE_F_LINK_UP;
 231       vnet_hw_interface_set_flags (vnm, rd->hw_if_index,
 232                                    VNET_HW_INTERFACE_FLAG_LINK_UP);
 233       break;
 234     default:
 235       rd->flags &= ~RDMA_DEVICE_F_LINK_UP;
 236       vnet_hw_interface_set_flags (vnm, rd->hw_if_index, 0);
 237       break;
 238     }
 239
 240   /* update speed */
 241   switch (attr.active_width)
 242     {
 243     case 1:
 244       width = 1;
 245       break;
 246     case 2:
 247       width = 4;
 248       break;
 249     case 4:
 250       width = 8;
 251       break;
 252     case 8:
 253       width = 12;
 254       break;
 255     }
 256   switch (attr.active_speed)
 257     {
 258     case 1:
 259       speed = 2500000;
 260       break;
 261     case 2:
 262       speed = 5000000;
 263       break;
 264     case 4:                     /* fallthrough */
 265     case 8:
 266       speed = 10000000;
 267       break;
 268     case 16:
 269       speed = 14000000;
 270       break;
 271     case 32:
 272       speed = 25000000;
 273       break;
 274     }
 275   vnet_hw_interface_set_link_speed (vnm, rd->hw_if_index, width * speed);
 276 }
 277
 278 static clib_error_t *
 279 rdma_async_event_error_ready (clib_file_t * f)
 280 {
 281   rdma_main_t *rm = &rdma_main;
 282   rdma_device_t *rd = vec_elt_at_index (rm->devices, f->private_data);
 283   return clib_error_return (0, "RDMA: %s: async event error", rd->name);
 284 }
 285
 286 static clib_error_t *
 287 rdma_async_event_read_ready (clib_file_t * f)
 288 {
 289   vnet_main_t *vnm = vnet_get_main ();
 290   rdma_main_t *rm = &rdma_main;
 291   rdma_device_t *rd = vec_elt_at_index (rm->devices, f->private_data);
 292   int ret;
 293   struct ibv_async_event event;
 294   ret = ibv_get_async_event (rd->ctx, &event);
 295   if (ret < 0)
 296     return clib_error_return_unix (0, "ibv_get_async_event() failed");
 297
 298   switch (event.event_type)
 299     {
 300     case IBV_EVENT_PORT_ACTIVE:
 301       rdma_update_state (vnm, rd, event.element.port_num);
 302       break;
 303     case IBV_EVENT_PORT_ERR:
 304       rdma_update_state (vnm, rd, event.element.port_num);
 305       break;
 306     case IBV_EVENT_DEVICE_FATAL:
 307       rd->flags &= ~RDMA_DEVICE_F_LINK_UP;
 308       vnet_hw_interface_set_flags (vnm, rd->hw_if_index, 0);
 309       vlib_log_emerg (rm->log_class, "%s: fatal error", rd->name);
 310       break;
 311     default:
 312       rdma_log__ (VLIB_LOG_LEVEL_ERR, rd, "unhandeld RDMA async event %d",
 313                   event.event_type);
 314       break;
 315     }
 316
 317   ibv_ack_async_event (&event);
 318   return 0;
 319 }
 320
 321 static clib_error_t *
 322 rdma_async_event_init (rdma_device_t * rd)
 323 {
 324   clib_file_t t = { 0 };
 325   int ret;
 326
 327   /* make RDMA async event fd non-blocking */
 328   ret = fcntl (rd->ctx->async_fd, F_GETFL);
 329   if (ret < 0)
 330     return clib_error_return_unix (0, "fcntl(F_GETFL) failed");
 331
 332   ret = fcntl (rd->ctx->async_fd, F_SETFL, ret | O_NONBLOCK);
 333   if (ret < 0)
 334     return clib_error_return_unix (0, "fcntl(F_SETFL, O_NONBLOCK) failed");
 335
 336   /* register RDMA async event fd */
 337   t.read_function = rdma_async_event_read_ready;
 338   t.file_descriptor = rd->ctx->async_fd;
 339   t.error_function = rdma_async_event_error_ready;
 340   t.private_data = rd->dev_instance;
 341   t.description = format (0, "%v async event", rd->name);
 342
 343   rd->async_event_clib_file_index = clib_file_add (&file_main, &t);
 344   return 0;
 345 }
 346
 347 static void
 348 rdma_async_event_cleanup (rdma_device_t * rd)
 349 {
 350   clib_file_del_by_index (&file_main, rd->async_event_clib_file_index);
 351 }
 352
 353 static clib_error_t *
 354 rdma_register_interface (vnet_main_t * vnm, rdma_device_t * rd)
 355 {
 356   vnet_eth_interface_registration_t eir = {};
 357
 358   eir.dev_class_index = rdma_device_class.index;
 359   eir.dev_instance = rd->dev_instance;
 360   eir.address = rd->hwaddr.bytes;
 361   eir.cb.flag_change = rdma_flag_change;
 362   eir.cb.set_max_frame_size = rdma_set_max_frame_size;
 363   rd->hw_if_index = vnet_eth_register_interface (vnm, &eir);
 364   /* Indicate ability to support L3 DMAC filtering and
 365    * initialize interface to L3 non-promisc mode */
 366   vnet_hw_if_set_caps (vnm, rd->hw_if_index, VNET_HW_IF_CAP_MAC_FILTER);
 367   ethernet_set_flags (vnm, rd->hw_if_index,
 368                       ETHERNET_INTERFACE_FLAG_DEFAULT_L3);
 369   return 0;
 370 }
 371
 372 static void
 373 rdma_unregister_interface (vnet_main_t * vnm, rdma_device_t * rd)
 374 {
 375   vnet_hw_interface_set_flags (vnm, rd->hw_if_index, 0);
 376   ethernet_delete_interface (vnm, rd->hw_if_index);
 377 }
 378
 379 static void
 380 rdma_dev_cleanup (rdma_device_t * rd)
 381 {
 382   rdma_main_t *rm = &rdma_main;
 383   rdma_rxq_t *rxq;
 384   rdma_txq_t *txq;
 385
 386 #define _(fn, arg) if (arg) \
 387   { \
 388     int rv; \
 389     if ((rv = fn (arg))) \
 390        rdma_log (VLIB_LOG_LEVEL_DEBUG, rd, #fn "() failed (rv = %d)", rv); \
 391   }
 392
 393   _(ibv_destroy_flow, rd->flow_mcast6);
 394   _(ibv_destroy_flow, rd->flow_ucast6);
 395   _(ibv_destroy_flow, rd->flow_mcast4);
 396   _(ibv_destroy_flow, rd->flow_ucast4);
 397   _(ibv_dereg_mr, rd->mr);
 398   vec_foreach (txq, rd->txqs)
 399   {
 400     _(ibv_destroy_qp, txq->qp);
 401     _(ibv_destroy_cq, txq->cq);
 402   }
 403   vec_foreach (rxq, rd->rxqs)
 404   {
 405     _(ibv_destroy_wq, rxq->wq);
 406     _(ibv_destroy_cq, rxq->cq);
 407   }
 408   _(ibv_destroy_rwq_ind_table, rd->rx_rwq_ind_tbl);
 409   _(ibv_destroy_qp, rd->rx_qp6);
 410   _(ibv_destroy_qp, rd->rx_qp4);
 411   _(ibv_dealloc_pd, rd->pd);
 412   _(ibv_close_device, rd->ctx);
 413 #undef _
 414
 415   clib_error_free (rd->error);
 416
 417   vec_free (rd->rxqs);
 418   vec_free (rd->txqs);
 419   vec_free (rd->name);
 420   vlib_pci_free_device_info (rd->pci);
 421   pool_put (rm->devices, rd);
 422 }
 423
 424 static clib_error_t *
 425 rdma_rxq_init (vlib_main_t * vm, rdma_device_t * rd, u16 qid, u32 n_desc,
 426                u8 no_multi_seg, u16 max_pktlen)
 427 {
 428   rdma_rxq_t *rxq;
 429   struct ibv_wq_init_attr wqia;
 430   struct ibv_cq_init_attr_ex cqa = { };
 431   struct ibv_wq_attr wqa;
 432   struct ibv_cq_ex *cqex;
 433   struct mlx5dv_wq_init_attr dv_wqia = { };
 434   int is_mlx5dv = ! !(rd->flags & RDMA_DEVICE_F_MLX5DV);
 435   int is_striding = ! !(rd->flags & RDMA_DEVICE_F_STRIDING_RQ);
 436
 437   vec_validate_aligned (rd->rxqs, qid, CLIB_CACHE_LINE_BYTES);
 438   rxq = vec_elt_at_index (rd->rxqs, qid);
 439   rxq->size = n_desc;
 440   rxq->log_wqe_sz = 0;
 441   rxq->buf_sz = vlib_buffer_get_default_data_size (vm);
 442   vec_validate_aligned (rxq->bufs, n_desc - 1, CLIB_CACHE_LINE_BYTES);
 443
 444   cqa.cqe = n_desc;
 445   if (is_mlx5dv)
 446     {
 447       struct mlx5dv_cq_init_attr dvcq = { };
 448       dvcq.comp_mask = MLX5DV_CQ_INIT_ATTR_MASK_COMPRESSED_CQE |
 449                        MLX5DV_CQ_INIT_ATTR_MASK_CQE_SIZE;
 450       dvcq.cqe_comp_res_format = MLX5DV_CQE_RES_FORMAT_HASH;
 451       dvcq.cqe_size = 64;
 452       if ((cqex = mlx5dv_create_cq (rd->ctx, &cqa, &dvcq)) == 0)
 453         return clib_error_return_unix (0, "Create mlx5dv rx CQ Failed");
 454     }
 455   else
 456     {
 457       if ((cqex = ibv_create_cq_ex (rd->ctx, &cqa)) == 0)
 458         return clib_error_return_unix (0, "Create CQ Failed");
 459     }
 460
 461   rxq->cq = ibv_cq_ex_to_cq (cqex);
 462
 463   memset (&wqia, 0, sizeof (wqia));
 464   wqia.wq_type = IBV_WQT_RQ;
 465   wqia.max_wr = n_desc;
 466   wqia.max_sge = 1;
 467   wqia.pd = rd->pd;
 468   wqia.cq = rxq->cq;
 469   if (is_mlx5dv)
 470     {
 471       if (is_striding)
 472         {
 473           /* In STRIDING_RQ mode, map a descriptor to a stride, not a full WQE buffer */
 474           uword data_seg_log2_sz =
 475             min_log2 (vlib_buffer_get_default_data_size (vm));
 476           rxq->buf_sz = 1 << data_seg_log2_sz;
 477           /* The trick is also to map a descriptor to a data segment in the WQE SG list
 478              The number of strides per WQE and the size of a WQE (in 16-bytes words) both
 479              must be powers of two.
 480              Moreover, in striding RQ mode, WQEs must include the SRQ header, which occupies
 481              one 16-bytes word. That is why WQEs have 2*RDMA_RXQ_MAX_CHAIN_SZ 16-bytes words:
 482              - One for the SRQ Header
 483              - RDMA_RXQ_MAX_CHAIN_SZ for the different data segments (each mapped to
 484              a stride, and a vlib_buffer)
 485              - RDMA_RXQ_MAX_CHAIN_SZ-1 null data segments
 486            */
 487           int max_chain_log_sz =
 488             max_pktlen ? max_log2 ((max_pktlen /
 489                                     (rxq->buf_sz)) +
 490                                    1) : RDMA_RXQ_MAX_CHAIN_LOG_SZ;
 491           max_chain_log_sz = clib_max (max_chain_log_sz, 3);
 492           wqia.max_sge = 1 << max_chain_log_sz;
 493           dv_wqia.comp_mask = MLX5DV_WQ_INIT_ATTR_MASK_STRIDING_RQ;
 494           dv_wqia.striding_rq_attrs.two_byte_shift_en = 0;
 495           dv_wqia.striding_rq_attrs.single_wqe_log_num_of_strides =
 496             max_chain_log_sz;
 497           dv_wqia.striding_rq_attrs.single_stride_log_num_of_bytes =
 498             data_seg_log2_sz;
 499           wqia.max_wr >>= max_chain_log_sz;
 500           rxq->log_wqe_sz = max_chain_log_sz + 1;
 501           rxq->log_stride_per_wqe = max_chain_log_sz;
 502         }
 503       else
 504         {
 505           /* In non STRIDING_RQ mode and if multiseg is not disabled, each WQE is a SG list of data
 506              segments, each pointing to a vlib_buffer.  */
 507           if (no_multi_seg)
 508             {
 509               wqia.max_sge = 1;
 510               rxq->log_wqe_sz = 0;
 511               rxq->n_ds_per_wqe = 1;
 512             }
 513           else
 514             {
 515               int max_chain_sz =
 516                 max_pktlen ? (max_pktlen /
 517                               (rxq->buf_sz)) +
 518                 1 : RDMA_RXQ_LEGACY_MODE_MAX_CHAIN_SZ;
 519               int max_chain_log_sz = max_log2 (max_chain_sz);
 520               wqia.max_sge = 1 << max_chain_log_sz;
 521               rxq->log_wqe_sz = max_chain_log_sz;
 522               rxq->n_ds_per_wqe = max_chain_sz;
 523             }
 524
 525         }
 526
 527       if ((rxq->wq = mlx5dv_create_wq (rd->ctx, &wqia, &dv_wqia)))
 528         {
 529           rxq->wq->events_completed = 0;
 530           pthread_mutex_init (&rxq->wq->mutex, NULL);
 531           pthread_cond_init (&rxq->wq->cond, NULL);
 532         }
 533       else
 534         return clib_error_return_unix (0, "Create WQ Failed");
 535     }
 536   else if ((rxq->wq = ibv_create_wq (rd->ctx, &wqia)) == 0)
 537     return clib_error_return_unix (0, "Create WQ Failed");
 538
 539   memset (&wqa, 0, sizeof (wqa));
 540   wqa.attr_mask = IBV_WQ_ATTR_STATE;
 541   wqa.wq_state = IBV_WQS_RDY;
 542   if (ibv_modify_wq (rxq->wq, &wqa) != 0)
 543     return clib_error_return_unix (0, "Modify WQ (RDY) Failed");
 544
 545   if (is_mlx5dv)
 546     {
 547       struct mlx5dv_obj obj = { };
 548       struct mlx5dv_cq dv_cq;
 549       struct mlx5dv_rwq dv_rwq;
 550       u64 qw0;
 551       u64 qw0_nullseg;
 552       u32 wqe_sz_mask = (1 << rxq->log_wqe_sz) - 1;
 553
 554       obj.cq.in = rxq->cq;
 555       obj.cq.out = &dv_cq;
 556       obj.rwq.in = rxq->wq;
 557       obj.rwq.out = &dv_rwq;
 558
 559       if ((mlx5dv_init_obj (&obj, MLX5DV_OBJ_CQ | MLX5DV_OBJ_RWQ)))
 560         return clib_error_return_unix (0, "mlx5dv: failed to init rx obj");
 561
 562       if (dv_cq.cqe_size != sizeof (mlx5dv_cqe_t))
 563         return clib_error_return_unix (0, "mlx5dv: incompatible rx CQE size");
 564
 565       rxq->log2_cq_size = max_log2 (dv_cq.cqe_cnt);
 566       rxq->cqes = (mlx5dv_cqe_t *) dv_cq.buf;
 567       rxq->cq_db = (volatile u32 *) dv_cq.dbrec;
 568       rxq->cqn = dv_cq.cqn;
 569
 570       rxq->wqes = (mlx5dv_wqe_ds_t *) dv_rwq.buf;
 571       rxq->wq_db = (volatile u32 *) dv_rwq.dbrec;
 572       rxq->wq_stride = dv_rwq.stride;
 573       rxq->wqe_cnt = dv_rwq.wqe_cnt;
 574
 575       qw0 = clib_host_to_net_u32 (rxq->buf_sz);
 576       qw0_nullseg = 0;
 577       qw0 |= (u64) clib_host_to_net_u32 (rd->lkey) << 32;
 578       qw0_nullseg |= (u64) clib_host_to_net_u32 (rd->lkey) << 32;
 579
 580 /* Prefill the different 16 bytes words of the WQ.
 581         - If not in striding RQ mode, for each WQE, init with qw0 the first
 582             RDMA_RXQ_LEGACY_MODE_MAX_CHAIN_SZ, and init the rest of the WQE
 583             with null segments.
 584         - If in striding RQ mode, for each WQE, the RDMA_RXQ_MAX_CHAIN_SZ + 1
 585         first 16-bytes words are initialised with qw0, the rest are null segments */
 586
 587       for (int i = 0; i < rxq->wqe_cnt << rxq->log_wqe_sz; i++)
 588         if ((!is_striding
 589              && ((i & wqe_sz_mask) < rxq->n_ds_per_wqe))
 590             || (is_striding
 591                 && ((i == 0)
 592                     || !(((i - 1) >> rxq->log_stride_per_wqe) & 0x1))))
 593           rxq->wqes[i].dsz_and_lkey = qw0;
 594         else
 595           rxq->wqes[i].dsz_and_lkey = qw0_nullseg;
 596
 597       for (int i = 0; i < (1 << rxq->log2_cq_size); i++)
 598         rxq->cqes[i].opcode_cqefmt_se_owner = 0xff;
 599
 600       if (!is_striding)
 601         {
 602           vec_validate_aligned (rxq->second_bufs, n_desc - 1,
 603                                 CLIB_CACHE_LINE_BYTES);
 604           vec_validate_aligned (rxq->n_used_per_chain, n_desc - 1,
 605                                 CLIB_CACHE_LINE_BYTES);
 606           rxq->n_total_additional_segs = n_desc * (rxq->n_ds_per_wqe - 1);
 607           for (int i = 0; i < n_desc; i++)
 608             rxq->n_used_per_chain[i] = rxq->n_ds_per_wqe - 1;
 609         }
 610     }
 611
 612   return 0;
 613 }
 614
 615 static uint64_t
 616 rdma_rss42ibv (const rdma_rss4_t rss4)
 617 {
 618   switch (rss4)
 619     {
 620     case RDMA_RSS4_IP:
 621       return IBV_RX_HASH_SRC_IPV4 | IBV_RX_HASH_DST_IPV4;
 622     case RDMA_RSS4_IP_UDP:
 623       return IBV_RX_HASH_SRC_IPV4 | IBV_RX_HASH_DST_IPV4 |
 624              IBV_RX_HASH_SRC_PORT_UDP | IBV_RX_HASH_DST_PORT_UDP;
 625     case RDMA_RSS4_AUTO: /* fallthrough */
 626     case RDMA_RSS4_IP_TCP:
 627       return IBV_RX_HASH_SRC_IPV4 | IBV_RX_HASH_DST_IPV4 |
 628              IBV_RX_HASH_SRC_PORT_TCP | IBV_RX_HASH_DST_PORT_TCP;
 629     }
 630   ASSERT (0);
 631   return 0;
 632 }
 633
 634 static uint64_t
 635 rdma_rss62ibv (const rdma_rss6_t rss6)
 636 {
 637   switch (rss6)
 638     {
 639     case RDMA_RSS6_IP:
 640       return IBV_RX_HASH_SRC_IPV6 | IBV_RX_HASH_DST_IPV6;
 641     case RDMA_RSS6_IP_UDP:
 642       return IBV_RX_HASH_SRC_IPV6 | IBV_RX_HASH_DST_IPV6 |
 643              IBV_RX_HASH_SRC_PORT_UDP | IBV_RX_HASH_DST_PORT_UDP;
 644     case RDMA_RSS6_AUTO: /* fallthrough */
 645     case RDMA_RSS6_IP_TCP:
 646       return IBV_RX_HASH_SRC_IPV6 | IBV_RX_HASH_DST_IPV6 |
 647              IBV_RX_HASH_SRC_PORT_TCP | IBV_RX_HASH_DST_PORT_TCP;
 648     }
 649   ASSERT (0);
 650   return 0;
 651 }
 652
 653 static clib_error_t *
 654 rdma_rxq_finalize (vlib_main_t *vm, rdma_device_t *rd)
 655 {
 656   struct ibv_rwq_ind_table_init_attr rwqia;
 657   struct ibv_qp_init_attr_ex qpia;
 658   struct ibv_wq **ind_tbl;
 659   const u32 rxq_sz = vec_len (rd->rxqs);
 660   u32 ind_tbl_sz = rxq_sz;
 661   u32 i;
 662
 663   if (!is_pow2 (ind_tbl_sz))
 664     {
 665       /* in case we do not have a power-of-2 number of rxq, we try to use the
 666        * maximum supported to minimize the imbalance */
 667       struct ibv_device_attr_ex attr;
 668       if (ibv_query_device_ex (rd->ctx, 0, &attr))
 669         return clib_error_return_unix (0, "device query failed");
 670       ind_tbl_sz = attr.rss_caps.max_rwq_indirection_table_size;
 671       if (ind_tbl_sz < rxq_sz)
 672         return clib_error_create ("too many rxqs requested (%d) compared to "
 673                                   "max indirection table size (%d)",
 674                                   rxq_sz, ind_tbl_sz);
 675     }
 676
 677   ind_tbl = vec_new (struct ibv_wq *, ind_tbl_sz);
 678   vec_foreach_index (i, ind_tbl)
 679     vec_elt (ind_tbl, i) = vec_elt (rd->rxqs, i % rxq_sz).wq;
 680   memset (&rwqia, 0, sizeof (rwqia));
 681   ASSERT (is_pow2 (vec_len (ind_tbl)));
 682   rwqia.log_ind_tbl_size = min_log2 (vec_len (ind_tbl));
 683   rwqia.ind_tbl = ind_tbl;
 684   if ((rd->rx_rwq_ind_tbl = ibv_create_rwq_ind_table (rd->ctx, &rwqia)) == 0)
 685     return clib_error_return_unix (0, "RWQ indirection table create failed");
 686   vec_free (ind_tbl);
 687
 688   memset (&qpia, 0, sizeof (qpia));
 689   qpia.qp_type = IBV_QPT_RAW_PACKET;
 690   qpia.comp_mask =
 691     IBV_QP_INIT_ATTR_PD | IBV_QP_INIT_ATTR_IND_TABLE |
 692     IBV_QP_INIT_ATTR_RX_HASH;
 693   qpia.pd = rd->pd;
 694   qpia.rwq_ind_tbl = rd->rx_rwq_ind_tbl;
 695   STATIC_ASSERT_SIZEOF (rdma_rss_hash_key, 40);
 696   qpia.rx_hash_conf.rx_hash_key_len = sizeof (rdma_rss_hash_key);
 697   qpia.rx_hash_conf.rx_hash_key = rdma_rss_hash_key;
 698   qpia.rx_hash_conf.rx_hash_function = IBV_RX_HASH_FUNC_TOEPLITZ;
 699
 700   qpia.rx_hash_conf.rx_hash_fields_mask = rdma_rss42ibv (rd->rss4);
 701   if ((rd->rx_qp4 = ibv_create_qp_ex (rd->ctx, &qpia)) == 0)
 702     return clib_error_return_unix (0, "IPv4 Queue Pair create failed");
 703
 704   qpia.rx_hash_conf.rx_hash_fields_mask = rdma_rss62ibv (rd->rss6);
 705   if ((rd->rx_qp6 = ibv_create_qp_ex (rd->ctx, &qpia)) == 0)
 706     return clib_error_return_unix (0, "IPv6 Queue Pair create failed");
 707
 708   if (rdma_dev_set_ucast (rd))
 709     return clib_error_return_unix (0, "Set unicast mode failed");
 710
 711   return 0;
 712 }
 713
 714 static clib_error_t *
 715 rdma_txq_init (vlib_main_t * vm, rdma_device_t * rd, u16 qid, u32 n_desc)
 716 {
 717   rdma_txq_t *txq;
 718   struct ibv_qp_init_attr qpia;
 719   struct ibv_qp_attr qpa;
 720   int qp_flags;
 721   int is_mlx5dv = !!(rd->flags & RDMA_DEVICE_F_MLX5DV);
 722
 723   vec_validate_aligned (rd->txqs, qid, CLIB_CACHE_LINE_BYTES);
 724   txq = vec_elt_at_index (rd->txqs, qid);
 725   ASSERT (is_pow2 (n_desc));
 726   txq->bufs_log2sz = min_log2 (n_desc);
 727   vec_validate_aligned (txq->bufs, n_desc - 1, CLIB_CACHE_LINE_BYTES);
 728   if (is_mlx5dv)
 729     {
 730       struct ibv_cq_init_attr_ex cqa = {};
 731       struct ibv_cq_ex *cqex;
 732       struct mlx5dv_cq_init_attr dvcq = {};
 733       dvcq.comp_mask = MLX5DV_CQ_INIT_ATTR_MASK_CQE_SIZE;
 734       dvcq.cqe_size = 64;
 735       cqa.cqe = n_desc;
 736       if ((cqex = mlx5dv_create_cq (rd->ctx, &cqa, &dvcq)) == 0)
 737         return clib_error_return_unix (0, "Create mlx5dv tx CQ Failed");
 738       txq->cq = ibv_cq_ex_to_cq (cqex);
 739     }
 740   else
 741     {
 742       if ((txq->cq = ibv_create_cq (rd->ctx, n_desc, NULL, NULL, 0)) == 0)
 743         return clib_error_return_unix (0, "Create CQ Failed");
 744     }
 745
 746   memset (&qpia, 0, sizeof (qpia));
 747   qpia.send_cq = txq->cq;
 748   qpia.recv_cq = txq->cq;
 749   qpia.cap.max_send_wr = n_desc;
 750   qpia.cap.max_send_sge = 1;
 751   qpia.qp_type = IBV_QPT_RAW_PACKET;
 752
 753   if ((txq->qp = ibv_create_qp (rd->pd, &qpia)) == 0)
 754     return clib_error_return_unix (0, "Queue Pair create failed");
 755
 756   memset (&qpa, 0, sizeof (qpa));
 757   qp_flags = IBV_QP_STATE | IBV_QP_PORT;
 758   qpa.qp_state = IBV_QPS_INIT;
 759   qpa.port_num = 1;
 760   if (ibv_modify_qp (txq->qp, &qpa, qp_flags) != 0)
 761     return clib_error_return_unix (0, "Modify QP (init) Failed");
 762
 763   memset (&qpa, 0, sizeof (qpa));
 764   qp_flags = IBV_QP_STATE;
 765   qpa.qp_state = IBV_QPS_RTR;
 766   if (ibv_modify_qp (txq->qp, &qpa, qp_flags) != 0)
 767     return clib_error_return_unix (0, "Modify QP (receive) Failed");
 768
 769   memset (&qpa, 0, sizeof (qpa));
 770   qp_flags = IBV_QP_STATE;
 771   qpa.qp_state = IBV_QPS_RTS;
 772   if (ibv_modify_qp (txq->qp, &qpa, qp_flags) != 0)
 773     return clib_error_return_unix (0, "Modify QP (send) Failed");
 774
 775   txq->ibv_cq = txq->cq;
 776   txq->ibv_qp = txq->qp;
 777
 778   if (rd->flags & RDMA_DEVICE_F_MLX5DV)
 779     {
 780       rdma_mlx5_wqe_t *tmpl = (void *) txq->dv_wqe_tmpl;
 781       struct mlx5dv_cq dv_cq;
 782       struct mlx5dv_qp dv_qp;
 783       struct mlx5dv_obj obj = { };
 784
 785       obj.cq.in = txq->cq;
 786       obj.cq.out = &dv_cq;
 787       obj.qp.in = txq->qp;
 788       obj.qp.out = &dv_qp;
 789
 790       if (mlx5dv_init_obj (&obj, MLX5DV_OBJ_CQ | MLX5DV_OBJ_QP))
 791         return clib_error_return_unix (0, "DV init obj failed");
 792
 793       if (RDMA_TXQ_BUF_SZ (txq) > dv_qp.sq.wqe_cnt
 794           || !is_pow2 (dv_qp.sq.wqe_cnt)
 795           || sizeof (rdma_mlx5_wqe_t) != dv_qp.sq.stride
 796           || (uword) dv_qp.sq.buf % sizeof (rdma_mlx5_wqe_t))
 797         return clib_error_return (0, "Unsupported DV SQ parameters");
 798
 799       if (RDMA_TXQ_BUF_SZ (txq) > dv_cq.cqe_cnt
 800           || !is_pow2 (dv_cq.cqe_cnt)
 801           || sizeof (struct mlx5_cqe64) != dv_cq.cqe_size
 802           || (uword) dv_cq.buf % sizeof (struct mlx5_cqe64))
 803         return clib_error_return (0, "Unsupported DV CQ parameters");
 804
 805       /* get SQ and doorbell addresses */
 806       txq->dv_sq_wqes = dv_qp.sq.buf;
 807       txq->dv_sq_dbrec = dv_qp.dbrec;
 808       txq->dv_sq_db = dv_qp.bf.reg;
 809       txq->dv_sq_log2sz = min_log2 (dv_qp.sq.wqe_cnt);
 810
 811       /* get CQ and doorbell addresses */
 812       txq->dv_cq_cqes = dv_cq.buf;
 813       txq->dv_cq_dbrec = dv_cq.dbrec;
 814       txq->dv_cq_log2sz = min_log2 (dv_cq.cqe_cnt);
 815
 816       /* init tx desc template */
 817       STATIC_ASSERT_SIZEOF (txq->dv_wqe_tmpl, sizeof (*tmpl));
 818       mlx5dv_set_ctrl_seg (&tmpl->ctrl, 0, MLX5_OPCODE_SEND, 0,
 819                            txq->qp->qp_num, 0, RDMA_MLX5_WQE_DS, 0,
 820                            RDMA_TXQ_DV_INVALID_ID);
 821       tmpl->eseg.inline_hdr_sz = htobe16 (MLX5_ETH_L2_INLINE_HEADER_SIZE);
 822       mlx5dv_set_data_seg (&tmpl->dseg, 0, rd->lkey, 0);
 823     }
 824
 825   return 0;
 826 }
 827
 828 static clib_error_t *
 829 rdma_dev_init (vlib_main_t * vm, rdma_device_t * rd,
 830                rdma_create_if_args_t * args)
 831 {
 832   clib_error_t *err;
 833   vlib_buffer_main_t *bm = vm->buffer_main;
 834   vlib_thread_main_t *tm = vlib_get_thread_main ();
 835   u32 rxq_num = args->rxq_num;
 836   u32 rxq_size = args->rxq_size;
 837   u32 txq_size = args->txq_size;
 838   u32 i;
 839
 840   if (rd->ctx == 0)
 841     return clib_error_return_unix (0, "Device Open Failed");
 842
 843   if ((rd->pd = ibv_alloc_pd (rd->ctx)) == 0)
 844     return clib_error_return_unix (0, "PD Alloc Failed");
 845
 846   if ((rd->mr = ibv_reg_mr (rd->pd, (void *) bm->buffer_mem_start,
 847                             bm->buffer_mem_size,
 848                             IBV_ACCESS_LOCAL_WRITE)) == 0)
 849     return clib_error_return_unix (0, "Register MR Failed");
 850
 851   rd->lkey = rd->mr->lkey;      /* avoid indirection in datapath */
 852
 853   ethernet_mac_address_generate (rd->hwaddr.bytes);
 854
 855   rd->rss4 = args->rss4;
 856   rd->rss6 = args->rss6;
 857
 858   /*
 859    * /!\ WARNING /!\ creation order is important
 860    * We *must* create TX queues *before* RX queues, otherwise we will receive
 861    * the broacast packets we sent
 862    */
 863   for (i = 0; i < tm->n_vlib_mains; i++)
 864     if ((err = rdma_txq_init (vm, rd, i, txq_size)))
 865       return err;
 866
 867   for (i = 0; i < rxq_num; i++)
 868     if ((err =
 869          rdma_rxq_init (vm, rd, i, rxq_size,
 870                         args->no_multi_seg, args->max_pktlen)))
 871       return err;
 872   if ((err = rdma_rxq_finalize (vm, rd)))
 873     return err;
 874
 875   return 0;
 876 }
 877
 878 static uword
 879 sysfs_path_to_pci_addr (char *path, vlib_pci_addr_t * addr)
 880 {
 881   uword rv;
 882   unformat_input_t in;
 883   u8 *s;
 884
 885   s = clib_file_get_resolved_basename (path);
 886   if (!s)
 887     return 0;
 888
 889   unformat_init_string (&in, (char *) s, strlen ((char *) s));
 890   rv = unformat (&in, "%U", unformat_vlib_pci_addr, addr);
 891   unformat_free (&in);
 892   vec_free (s);
 893   return rv;
 894 }
 895
 896 void
 897 rdma_create_if (vlib_main_t * vm, rdma_create_if_args_t * args)
 898 {
 899   vnet_main_t *vnm = vnet_get_main ();
 900   rdma_main_t *rm = &rdma_main;
 901   rdma_device_t *rd;
 902   vlib_pci_addr_t pci_addr;
 903   struct ibv_device **dev_list;
 904   int n_devs;
 905   u8 *s;
 906   u16 qid;
 907   int i;
 908
 909   args->rxq_size = args->rxq_size ? args->rxq_size : 1024;
 910   args->txq_size = args->txq_size ? args->txq_size : 1024;
 911   args->rxq_num = args->rxq_num ? args->rxq_num : 2;
 912
 913   if (args->rxq_size < VLIB_FRAME_SIZE || args->txq_size < VLIB_FRAME_SIZE ||
 914       args->rxq_size > 65535 || args->txq_size > 65535 ||
 915       !is_pow2 (args->rxq_size) || !is_pow2 (args->txq_size))
 916     {
 917       args->rv = VNET_API_ERROR_INVALID_VALUE;
 918       args->error = clib_error_return (0,
 919                                        "queue size must be a power of two "
 920                                        "between %d and 65535",
 921                                        VLIB_FRAME_SIZE);
 922       goto err0;
 923     }
 924
 925   dev_list = ibv_get_device_list (&n_devs);
 926   if (n_devs == 0)
 927     {
 928       args->error =
 929         clib_error_return_unix (0,
 930                                 "no RDMA devices available. Is the ib_uverbs module loaded?");
 931       goto err0;
 932     }
 933
 934   /* get PCI address */
 935   s = format (0, "/sys/class/net/%s/device%c", args->ifname, 0);
 936   if (sysfs_path_to_pci_addr ((char *) s, &pci_addr) == 0)
 937     {
 938       args->error =
 939         clib_error_return (0, "cannot find PCI address for device ");
 940       goto err1;
 941     }
 942
 943   pool_get_zero (rm->devices, rd);
 944   rd->dev_instance = rd - rm->devices;
 945   rd->per_interface_next_index = VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT;
 946   rd->linux_ifname = format (0, "%s", args->ifname);
 947
 948   if (!args->name || 0 == args->name[0])
 949     rd->name = format (0, "%s/%d", args->ifname, rd->dev_instance);
 950   else
 951     rd->name = format (0, "%s", args->name);
 952
 953   rd->pci = vlib_pci_get_device_info (vm, &pci_addr, &args->error);
 954   if (!rd->pci)
 955     goto err2;
 956
 957   /* if we failed to parse NUMA node, default to 0 */
 958   if (-1 == rd->pci->numa_node)
 959     rd->pci->numa_node = 0;
 960
 961   rd->pool = vlib_buffer_pool_get_default_for_numa (vm, rd->pci->numa_node);
 962
 963   if (strncmp ((char *) rd->pci->driver_name, "mlx5_core", 9))
 964     {
 965       args->error =
 966         clib_error_return (0,
 967                            "invalid interface (only mlx5 supported for now)");
 968       goto err2;
 969     }
 970
 971   for (i = 0; i < n_devs; i++)
 972     {
 973       vlib_pci_addr_t addr;
 974
 975       vec_reset_length (s);
 976       s = format (s, "%s/device%c", dev_list[i]->dev_path, 0);
 977
 978       if (sysfs_path_to_pci_addr ((char *) s, &addr) == 0)
 979         continue;
 980
 981       if (addr.as_u32 != rd->pci->addr.as_u32)
 982         continue;
 983
 984       if ((rd->ctx = ibv_open_device (dev_list[i])))
 985         break;
 986     }
 987
 988   if (args->mode != RDMA_MODE_IBV)
 989     {
 990       struct mlx5dv_context mlx5dv_attrs = { };
 991       mlx5dv_attrs.comp_mask |= MLX5DV_CONTEXT_MASK_STRIDING_RQ;
 992
 993       if (mlx5dv_query_device (rd->ctx, &mlx5dv_attrs) == 0)
 994         {
 995           uword data_seg_log2_sz =
 996             min_log2 (vlib_buffer_get_default_data_size (vm));
 997
 998           if ((mlx5dv_attrs.flags & MLX5DV_CONTEXT_FLAGS_CQE_V1))
 999             rd->flags |= RDMA_DEVICE_F_MLX5DV;
1000
1001 /* Enable striding RQ if neither multiseg nor striding rq
1002 are explicitly disabled, and if the interface supports it.*/
1003           if (!args->no_multi_seg && !args->disable_striding_rq
1004               && data_seg_log2_sz <=
1005               mlx5dv_attrs.striding_rq_caps.max_single_stride_log_num_of_bytes
1006               && data_seg_log2_sz >=
1007               mlx5dv_attrs.striding_rq_caps.min_single_stride_log_num_of_bytes
1008               && RDMA_RXQ_MAX_CHAIN_LOG_SZ >=
1009               mlx5dv_attrs.striding_rq_caps.min_single_wqe_log_num_of_strides
1010               && RDMA_RXQ_MAX_CHAIN_LOG_SZ <=
1011               mlx5dv_attrs.striding_rq_caps.max_single_wqe_log_num_of_strides)
1012             rd->flags |= RDMA_DEVICE_F_STRIDING_RQ;
1013         }
1014       else
1015         {
1016           if (args->mode == RDMA_MODE_DV)
1017             {
1018               args->error = clib_error_return (0, "Direct Verbs mode not "
1019                                                "supported on this interface");
1020               goto err2;
1021             }
1022         }
1023     }
1024
1025   if ((args->error = rdma_dev_init (vm, rd, args)))
1026     goto err2;
1027
1028   if ((args->error = rdma_register_interface (vnm, rd)))
1029     goto err2;
1030
1031   if ((args->error = rdma_async_event_init (rd)))
1032     goto err3;
1033
1034   rdma_update_state (vnm, rd, 1);
1035
1036   vnet_sw_interface_t *sw = vnet_get_hw_sw_interface (vnm, rd->hw_if_index);
1037   args->sw_if_index = rd->sw_if_index = sw->sw_if_index;
1038   /*
1039    * FIXME: add support for interrupt mode
1040    * vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, rd->hw_if_index);
1041    * hw->caps |= VNET_HW_IF_CAP_INT_MODE;
1042    */
1043   vnet_hw_if_set_input_node (vnm, rd->hw_if_index, rdma_input_node.index);
1044
1045   vec_foreach_index (qid, rd->rxqs)
1046     {
1047       u32 queue_index = vnet_hw_if_register_rx_queue (
1048         vnm, rd->hw_if_index, qid, VNET_HW_IF_RXQ_THREAD_ANY);
1049       rd->rxqs[qid].queue_index = queue_index;
1050     }
1051   vnet_hw_if_update_runtime_data (vnm, rd->hw_if_index);
1052   vec_free (s);
1053   return;
1054
1055 err3:
1056   rdma_unregister_interface (vnm, rd);
1057 err2:
1058   rdma_dev_cleanup (rd);
1059 err1:
1060   ibv_free_device_list (dev_list);
1061   vec_free (s);
1062   args->rv = VNET_API_ERROR_INVALID_INTERFACE;
1063 err0:
1064   vlib_log_err (rm->log_class, "%U", format_clib_error, args->error);
1065 }
1066
1067 void
1068 rdma_delete_if (vlib_main_t * vm, rdma_device_t * rd)
1069 {
1070   rdma_async_event_cleanup (rd);
1071   rdma_unregister_interface (vnet_get_main (), rd);
1072   rdma_dev_cleanup (rd);
1073 }
1074
1075 static clib_error_t *
1076 rdma_interface_admin_up_down (vnet_main_t * vnm, u32 hw_if_index, u32 flags)
1077 {
1078   vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
1079   rdma_main_t *rm = &rdma_main;
1080   rdma_device_t *rd = vec_elt_at_index (rm->devices, hi->dev_instance);
1081   uword is_up = (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) != 0;
1082
1083   if (rd->flags & RDMA_DEVICE_F_ERROR)
1084     return clib_error_return (0, "device is in error state");
1085
1086   if (is_up)
1087     {
1088       vnet_hw_interface_set_flags (vnm, rd->hw_if_index,
1089                                    VNET_HW_INTERFACE_FLAG_LINK_UP);
1090       rd->flags |= RDMA_DEVICE_F_ADMIN_UP;
1091     }
1092   else
1093     {
1094       vnet_hw_interface_set_flags (vnm, rd->hw_if_index, 0);
1095       rd->flags &= ~RDMA_DEVICE_F_ADMIN_UP;
1096     }
1097   return 0;
1098 }
1099
1100 static void
1101 rdma_set_interface_next_node (vnet_main_t * vnm, u32 hw_if_index,
1102                               u32 node_index)
1103 {
1104   rdma_main_t *rm = &rdma_main;
1105   vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, hw_if_index);
1106   rdma_device_t *rd = pool_elt_at_index (rm->devices, hw->dev_instance);
1107   rd->per_interface_next_index =
1108     ~0 ==
1109     node_index ? VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT :
1110     vlib_node_add_next (vlib_get_main (), rdma_input_node.index, node_index);
1111 }
1112
1113 static char *rdma_tx_func_error_strings[] = {
1114 #define _(n,s) s,
1115   foreach_rdma_tx_func_error
1116 #undef _
1117 };
1118
1119 VNET_DEVICE_CLASS (rdma_device_class) =
1120 {
1121   .name = "RDMA interface",
1122   .format_device = format_rdma_device,
1123   .format_device_name = format_rdma_device_name,
1124   .admin_up_down_function = rdma_interface_admin_up_down,
1125   .rx_redirect_to_node = rdma_set_interface_next_node,
1126   .tx_function_n_errors = RDMA_TX_N_ERROR,
1127   .tx_function_error_strings = rdma_tx_func_error_strings,
1128   .mac_addr_change_function = rdma_mac_change,
1129 };
1130
1131 clib_error_t *
1132 rdma_init (vlib_main_t * vm)
1133 {
1134   rdma_main_t *rm = &rdma_main;
1135   vlib_thread_main_t *tm = vlib_get_thread_main ();
1136
1137   rm->log_class = vlib_log_register_class ("rdma", 0);
1138
1139   /* vlib_buffer_t template */
1140   vec_validate_aligned (rm->per_thread_data, tm->n_vlib_mains - 1,
1141                         CLIB_CACHE_LINE_BYTES);
1142
1143   for (int i = 0; i < tm->n_vlib_mains; i++)
1144     {
1145       rdma_per_thread_data_t *ptd = vec_elt_at_index (rm->per_thread_data, i);
1146       clib_memset (&ptd->buffer_template, 0, sizeof (vlib_buffer_t));
1147       ptd->buffer_template.flags = VLIB_BUFFER_TOTAL_LENGTH_VALID;
1148       ptd->buffer_template.ref_count = 1;
1149       vnet_buffer (&ptd->buffer_template)->sw_if_index[VLIB_TX] = (u32) ~ 0;
1150     }
1151
1152   return 0;
1153 }
1154
1155 VLIB_INIT_FUNCTION (rdma_init);