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