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 rdma_main_t rdma_main;
  33
  34 #define rdma_log_debug(dev, f, ...) \
  35 {                                                                   \
  36   vlib_log(VLIB_LOG_LEVEL_DEBUG, rdma_main.log_class, "%U: " f,      \
  37            format_vlib_pci_addr, &rd->pci_addr, ##__VA_ARGS__);     \
  38 };
  39
  40 static u32
  41 rdma_flag_change (vnet_main_t * vnm, vnet_hw_interface_t * hw, u32 flags)
  42 {
  43   rdma_main_t *rm = &rdma_main;
  44   vlib_log_warn (rm->log_class, "TODO");
  45   return 0;
  46 }
  47
  48 static void
  49 rdma_update_state (vnet_main_t * vnm, rdma_device_t * rd, int port)
  50 {
  51   struct ibv_port_attr attr;
  52   u32 width = 0;
  53   u32 speed = 0;
  54
  55   if (ibv_query_port (rd->ctx, port, &attr))
  56     {
  57       vnet_hw_interface_set_link_speed (vnm, rd->hw_if_index, 0);
  58       vnet_hw_interface_set_flags (vnm, rd->hw_if_index, 0);
  59       return;
  60     }
  61
  62   /* update state */
  63   switch (attr.state)
  64     {
  65     case IBV_PORT_ACTIVE:       /* fallthrough */
  66     case IBV_PORT_ACTIVE_DEFER:
  67       rd->flags |= RDMA_DEVICE_F_LINK_UP;
  68       vnet_hw_interface_set_flags (vnm, rd->hw_if_index,
  69                                    VNET_HW_INTERFACE_FLAG_LINK_UP);
  70       break;
  71     default:
  72       rd->flags &= ~RDMA_DEVICE_F_LINK_UP;
  73       vnet_hw_interface_set_flags (vnm, rd->hw_if_index, 0);
  74       break;
  75     }
  76
  77   /* update speed */
  78   switch (attr.active_width)
  79     {
  80     case 1:
  81       width = 1;
  82       break;
  83     case 2:
  84       width = 4;
  85       break;
  86     case 4:
  87       width = 8;
  88       break;
  89     case 8:
  90       width = 12;
  91       break;
  92     }
  93   switch (attr.active_speed)
  94     {
  95     case 1:
  96       speed = 2500000;
  97       break;
  98     case 2:
  99       speed = 5000000;
 100       break;
 101     case 4:                     /* fallthrough */
 102     case 8:
 103       speed = 10000000;
 104       break;
 105     case 16:
 106       speed = 14000000;
 107       break;
 108     case 32:
 109       speed = 25000000;
 110       break;
 111     }
 112   vnet_hw_interface_set_link_speed (vnm, rd->hw_if_index, width * speed);
 113 }
 114
 115 static clib_error_t *
 116 rdma_async_event_error_ready (clib_file_t * f)
 117 {
 118   rdma_main_t *rm = &rdma_main;
 119   rdma_device_t *rd = vec_elt_at_index (rm->devices, f->private_data);
 120   return clib_error_return (0, "RDMA async event error for device %U",
 121                             format_vlib_pci_addr, &rd->pci_addr);
 122 }
 123
 124 static clib_error_t *
 125 rdma_async_event_read_ready (clib_file_t * f)
 126 {
 127   vnet_main_t *vnm = vnet_get_main ();
 128   rdma_main_t *rm = &rdma_main;
 129   rdma_device_t *rd = vec_elt_at_index (rm->devices, f->private_data);
 130   int ret;
 131   struct ibv_async_event event;
 132   ret = ibv_get_async_event (rd->ctx, &event);
 133   if (ret < 0)
 134     {
 135       return clib_error_return_unix (0, "ibv_get_async_event() failed");
 136     }
 137
 138   switch (event.event_type)
 139     {
 140     case IBV_EVENT_PORT_ACTIVE:
 141       rdma_update_state (vnm, rd, event.element.port_num);
 142       break;
 143     case IBV_EVENT_PORT_ERR:
 144       rdma_update_state (vnm, rd, event.element.port_num);
 145       break;
 146     case IBV_EVENT_DEVICE_FATAL:
 147       rd->flags &= ~RDMA_DEVICE_F_LINK_UP;
 148       vnet_hw_interface_set_flags (vnm, rd->hw_if_index, 0);
 149       vlib_log_emerg (rm->log_class, "Fatal RDMA error for device %U",
 150                       format_vlib_pci_addr, &rd->pci_addr);
 151       break;
 152     default:
 153       vlib_log_warn (rm->log_class,
 154                      "Unhandeld RDMA async event %i for device %U",
 155                      event.event_type, format_vlib_pci_addr, &rd->pci_addr);
 156       break;
 157     }
 158
 159   ibv_ack_async_event (&event);
 160   return 0;
 161 }
 162
 163 static clib_error_t *
 164 rdma_async_event_init (rdma_device_t * rd)
 165 {
 166   clib_file_t t = { 0 };
 167   int ret;
 168
 169   /* make RDMA async event fd non-blocking */
 170   ret = fcntl (rd->ctx->async_fd, F_GETFL);
 171   if (ret < 0)
 172     {
 173       return clib_error_return_unix (0, "fcntl(F_GETFL) failed");
 174     }
 175   ret = fcntl (rd->ctx->async_fd, F_SETFL, ret | O_NONBLOCK);
 176   if (ret < 0)
 177     {
 178       return clib_error_return_unix (0, "fcntl(F_SETFL, O_NONBLOCK) failed");
 179     }
 180
 181   /* register RDMA async event fd */
 182   t.read_function = rdma_async_event_read_ready;
 183   t.file_descriptor = rd->ctx->async_fd;
 184   t.error_function = rdma_async_event_error_ready;
 185   t.private_data = rd->dev_instance;
 186   t.description =
 187     format (0, "RMDA %U async event", format_vlib_pci_addr, &rd->pci_addr);
 188
 189   rd->async_event_clib_file_index = clib_file_add (&file_main, &t);
 190
 191   return 0;
 192 }
 193
 194 static void
 195 rdma_async_event_cleanup (rdma_device_t * rd)
 196 {
 197   clib_file_del_by_index (&file_main, rd->async_event_clib_file_index);
 198 }
 199
 200 static clib_error_t *
 201 rdma_register_interface (vnet_main_t * vnm, rdma_device_t * rd)
 202 {
 203   return ethernet_register_interface (vnm, rdma_device_class.index,
 204                                       rd->dev_instance, rd->hwaddr,
 205                                       &rd->hw_if_index, rdma_flag_change);
 206 }
 207
 208 static void
 209 rdma_unregister_interface (vnet_main_t * vnm, rdma_device_t * rd)
 210 {
 211   vnet_hw_interface_set_flags (vnm, rd->hw_if_index, 0);
 212   vnet_hw_interface_unassign_rx_thread (vnm, rd->hw_if_index, 0);
 213   ethernet_delete_interface (vnm, rd->hw_if_index);
 214 }
 215
 216 static void
 217 rdma_dev_cleanup (rdma_device_t * rd)
 218 {
 219   rdma_main_t *rm = &rdma_main;
 220   rdma_rxq_t *rxq;
 221   rdma_txq_t *txq;
 222
 223 #define _(fn, arg) if (arg) \
 224   { \
 225     int rv; \
 226     if ((rv = fn (arg))) \
 227        rdma_log_debug (rd, #fn "() failed (rv = %d)", rv); \
 228   }
 229
 230   _(ibv_destroy_flow, rd->flow_mcast);
 231   _(ibv_destroy_flow, rd->flow_ucast);
 232   _(ibv_dereg_mr, rd->mr);
 233   vec_foreach (txq, rd->txqs)
 234   {
 235     _(ibv_destroy_qp, txq->qp);
 236     _(ibv_destroy_cq, txq->cq);
 237   }
 238   vec_foreach (rxq, rd->rxqs)
 239   {
 240     _(ibv_destroy_qp, rxq->qp);
 241     _(ibv_destroy_cq, rxq->cq);
 242   }
 243   _(ibv_dealloc_pd, rd->pd);
 244   _(ibv_close_device, rd->ctx);
 245 #undef _
 246
 247   clib_error_free (rd->error);
 248
 249   vec_free (rd->rxqs);
 250   vec_free (rd->txqs);
 251   vec_free (rd->name);
 252   pool_put (rm->devices, rd);
 253 }
 254
 255 static clib_error_t *
 256 rdma_rxq_init (vlib_main_t * vm, rdma_device_t * rd, u16 qid, u32 n_desc)
 257 {
 258   rdma_rxq_t *rxq;
 259   struct ibv_qp_init_attr qpia;
 260   struct ibv_qp_attr qpa;
 261   int qp_flags;
 262
 263   vec_validate_aligned (rd->rxqs, qid, CLIB_CACHE_LINE_BYTES);
 264   rxq = vec_elt_at_index (rd->rxqs, qid);
 265   rxq->size = n_desc;
 266
 267   if ((rxq->cq = ibv_create_cq (rd->ctx, n_desc, NULL, NULL, 0)) == 0)
 268     return clib_error_return_unix (0, "Create CQ Failed");
 269
 270   memset (&qpia, 0, sizeof (qpia));
 271   qpia.send_cq = rxq->cq;
 272   qpia.recv_cq = rxq->cq;
 273   qpia.cap.max_recv_wr = n_desc;
 274   qpia.cap.max_recv_sge = 1;
 275   qpia.qp_type = IBV_QPT_RAW_PACKET;
 276
 277   if ((rxq->qp = ibv_create_qp (rd->pd, &qpia)) == 0)
 278     return clib_error_return_unix (0, "Queue Pair create failed");
 279
 280   memset (&qpa, 0, sizeof (qpa));
 281   qp_flags = IBV_QP_STATE | IBV_QP_PORT;
 282   qpa.qp_state = IBV_QPS_INIT;
 283   qpa.port_num = 1;
 284   if (ibv_modify_qp (rxq->qp, &qpa, qp_flags) != 0)
 285     return clib_error_return_unix (0, "Modify QP (init) Failed");
 286
 287   memset (&qpa, 0, sizeof (qpa));
 288   qp_flags = IBV_QP_STATE;
 289   qpa.qp_state = IBV_QPS_RTR;
 290   if (ibv_modify_qp (rxq->qp, &qpa, qp_flags) != 0)
 291     return clib_error_return_unix (0, "Modify QP (receive) Failed");
 292
 293   return 0;
 294 }
 295
 296 static clib_error_t *
 297 rdma_txq_init (vlib_main_t * vm, rdma_device_t * rd, u16 qid, u32 n_desc)
 298 {
 299   rdma_txq_t *txq;
 300   struct ibv_qp_init_attr qpia;
 301   struct ibv_qp_attr qpa;
 302   int qp_flags;
 303
 304   vec_validate_aligned (rd->txqs, qid, CLIB_CACHE_LINE_BYTES);
 305   txq = vec_elt_at_index (rd->txqs, qid);
 306   txq->size = n_desc;
 307
 308   if ((txq->cq = ibv_create_cq (rd->ctx, n_desc, NULL, NULL, 0)) == 0)
 309     return clib_error_return_unix (0, "Create CQ Failed");
 310
 311   memset (&qpia, 0, sizeof (qpia));
 312   qpia.send_cq = txq->cq;
 313   qpia.recv_cq = txq->cq;
 314   qpia.cap.max_send_wr = n_desc;
 315   qpia.cap.max_send_sge = 1;
 316   qpia.qp_type = IBV_QPT_RAW_PACKET;
 317   qpia.sq_sig_all = 1;
 318
 319   if ((txq->qp = ibv_create_qp (rd->pd, &qpia)) == 0)
 320     return clib_error_return_unix (0, "Queue Pair create failed");
 321
 322   memset (&qpa, 0, sizeof (qpa));
 323   qp_flags = IBV_QP_STATE | IBV_QP_PORT;
 324   qpa.qp_state = IBV_QPS_INIT;
 325   qpa.port_num = 1;
 326   if (ibv_modify_qp (txq->qp, &qpa, qp_flags) != 0)
 327     return clib_error_return_unix (0, "Modify QP (init) Failed");
 328
 329   memset (&qpa, 0, sizeof (qpa));
 330   qp_flags = IBV_QP_STATE;
 331   qpa.qp_state = IBV_QPS_RTR;
 332   if (ibv_modify_qp (txq->qp, &qpa, qp_flags) != 0)
 333     return clib_error_return_unix (0, "Modify QP (receive) Failed");
 334
 335   memset (&qpa, 0, sizeof (qpa));
 336   qp_flags = IBV_QP_STATE;
 337   qpa.qp_state = IBV_QPS_RTS;
 338   if (ibv_modify_qp (txq->qp, &qpa, qp_flags) != 0)
 339     return clib_error_return_unix (0, "Modify QP (send) Failed");
 340   return 0;
 341 }
 342
 343 static clib_error_t *
 344 rdma_dev_init (vlib_main_t * vm, rdma_device_t * rd)
 345 {
 346   clib_error_t *err;
 347   vlib_buffer_main_t *bm = vm->buffer_main;
 348   vlib_thread_main_t *tm = vlib_get_thread_main ();
 349   u16 i;
 350
 351   if (rd->ctx == 0)
 352     return clib_error_return_unix (0, "Device Open Failed");
 353
 354   if ((rd->pd = ibv_alloc_pd (rd->ctx)) == 0)
 355     return clib_error_return_unix (0, "PD Alloc Failed");
 356
 357   if ((err = rdma_rxq_init (vm, rd, 0, 512)))
 358     return err;
 359
 360   for (i = 0; i < tm->n_vlib_mains; i++)
 361     if ((err = rdma_txq_init (vm, rd, i, 512)))
 362       return err;
 363
 364   if ((rd->mr = ibv_reg_mr (rd->pd, (void *) bm->buffer_mem_start,
 365                             bm->buffer_mem_size,
 366                             IBV_ACCESS_LOCAL_WRITE)) == 0)
 367     return clib_error_return_unix (0, "Register MR Failed");
 368
 369   ethernet_mac_address_generate (rd->hwaddr);
 370
 371   /*
 372    * restrict packets steering to our MAC
 373    * allows to share a single HW NIC with multiple RDMA ifaces
 374    * and/or Linux
 375    */
 376   struct raw_eth_flow_attr
 377   {
 378     struct ibv_flow_attr attr;
 379     struct ibv_flow_spec_eth spec_eth;
 380   } __attribute__ ((packed)) fa;
 381   memset (&fa, 0, sizeof (fa));
 382   fa.attr.num_of_specs = 1;
 383   fa.attr.port = 1;
 384   fa.spec_eth.type = IBV_FLOW_SPEC_ETH;
 385   fa.spec_eth.size = sizeof (struct ibv_flow_spec_eth);
 386   memcpy (fa.spec_eth.val.dst_mac, rd->hwaddr,
 387           sizeof (fa.spec_eth.val.dst_mac));
 388   memset (fa.spec_eth.mask.dst_mac, 0xff, sizeof (fa.spec_eth.mask.dst_mac));
 389   if ((rd->flow_ucast = ibv_create_flow (rd->rxqs[0].qp, &fa.attr)) == 0)
 390     return clib_error_return_unix (0, "create Flow Failed");
 391
 392   /* receive multicast packets too */
 393   memset (&fa, 0, sizeof (fa));
 394   fa.attr.num_of_specs = 1;
 395   fa.attr.port = 1;
 396   fa.attr.flags = IBV_FLOW_ATTR_FLAGS_DONT_TRAP;        /* let others receive them too */
 397   fa.spec_eth.type = IBV_FLOW_SPEC_ETH;
 398   fa.spec_eth.size = sizeof (struct ibv_flow_spec_eth);
 399   fa.spec_eth.val.dst_mac[0] = 1;
 400   fa.spec_eth.mask.dst_mac[0] = 1;
 401   if ((rd->flow_mcast = ibv_create_flow (rd->rxqs[0].qp, &fa.attr)) == 0)
 402     return clib_error_return_unix (0, "create Flow Failed");
 403
 404   return 0;
 405 }
 406
 407 static uword
 408 sysfs_path_to_pci_addr (char *path, vlib_pci_addr_t * addr)
 409 {
 410   uword rv;
 411   unformat_input_t in;
 412   u8 *s;
 413
 414   s = clib_sysfs_link_to_name (path);
 415   unformat_init_string (&in, (char *) s, strlen ((char *) s));
 416   rv = unformat (&in, "%U", unformat_vlib_pci_addr, addr);
 417   unformat_free (&in);
 418   vec_free (s);
 419   return rv;
 420 }
 421
 422 void
 423 rdma_create_if (vlib_main_t * vm, rdma_create_if_args_t * args)
 424 {
 425   vnet_main_t *vnm = vnet_get_main ();
 426   rdma_main_t *rm = &rdma_main;
 427   rdma_device_t *rd = 0;
 428   struct ibv_device **dev_list = 0;
 429   int n_devs;
 430   u8 *s = 0, *s2 = 0;
 431
 432   pool_get_zero (rm->devices, rd);
 433   rd->dev_instance = rd - rm->devices;
 434   rd->per_interface_next_index = VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT;
 435   rd->name = vec_dup (args->name);
 436
 437   /* check if device exist and if it is bound to mlx5_core */
 438   s = format (s, "/sys/class/net/%s/device/driver/module%c", args->ifname, 0);
 439   s2 = clib_sysfs_link_to_name ((char *) s);
 440
 441   if (s2 == 0 || strncmp ((char *) s2, "mlx5_core", 9) != 0)
 442     {
 443       args->error =
 444         clib_error_return (0,
 445                            "invalid interface (only mlx5 supported for now)");
 446       goto err0;
 447     }
 448
 449   /* extract PCI address */
 450   vec_reset_length (s);
 451   s = format (s, "/sys/class/net/%s/device%c", args->ifname, 0);
 452   if (sysfs_path_to_pci_addr ((char *) s, &rd->pci_addr) == 0)
 453     {
 454       args->error = clib_error_return (0, "cannot find PCI address");
 455       goto err0;
 456     }
 457
 458   dev_list = ibv_get_device_list (&n_devs);
 459   if (n_devs == 0)
 460     {
 461       args->error =
 462         clib_error_return_unix (0,
 463                                 "no RDMA devices available, errno = %d. Is the ib_uverbs module loaded?",
 464                                 errno);
 465       goto err1;
 466     }
 467
 468   for (int i = 0; i < n_devs; i++)
 469     {
 470       vlib_pci_addr_t addr;
 471
 472       vec_reset_length (s);
 473       s = format (s, "%s/device%c", dev_list[i]->dev_path, 0);
 474
 475       if (sysfs_path_to_pci_addr ((char *) s, &addr) == 0)
 476         continue;
 477
 478       if (addr.as_u32 != rd->pci_addr.as_u32)
 479         continue;
 480
 481       if ((rd->ctx = ibv_open_device (dev_list[i])))
 482         break;
 483     }
 484
 485   if ((args->error = rdma_dev_init (vm, rd)))
 486     goto err2;
 487
 488   if ((args->error = rdma_register_interface (vnm, rd)))
 489     goto err2;
 490
 491   if ((args->error = rdma_async_event_init (rd)))
 492     goto err3;
 493
 494   rdma_update_state (vnm, rd, 1);
 495
 496   vnet_sw_interface_t *sw = vnet_get_hw_sw_interface (vnm, rd->hw_if_index);
 497   args->sw_if_index = rd->sw_if_index = sw->sw_if_index;
 498   /*
 499    * FIXME: add support for interrupt mode
 500    * vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, rd->hw_if_index);
 501    * hw->flags |= VNET_HW_INTERFACE_FLAG_SUPPORTS_INT_MODE;
 502    */
 503   vnet_hw_interface_set_input_node (vnm, rd->hw_if_index,
 504                                     rdma_input_node.index);
 505   vnet_hw_interface_assign_rx_thread (vnm, rd->hw_if_index, 0, ~0);
 506   return;
 507
 508 err3:
 509   rdma_unregister_interface (vnm, rd);
 510 err2:
 511   rdma_dev_cleanup (rd);
 512 err1:
 513   ibv_free_device_list (dev_list);
 514 err0:
 515   vec_free (s2);
 516   vec_free (s);
 517   args->rv = VNET_API_ERROR_INVALID_INTERFACE;
 518   vlib_log_err (rm->log_class, "%U", format_clib_error, args->error);
 519 }
 520
 521 void
 522 rdma_delete_if (vlib_main_t * vm, rdma_device_t * rd)
 523 {
 524   rdma_async_event_cleanup (rd);
 525   rdma_unregister_interface (vnet_get_main (), rd);
 526   rdma_dev_cleanup (rd);
 527 }
 528
 529 static clib_error_t *
 530 rdma_interface_admin_up_down (vnet_main_t * vnm, u32 hw_if_index, u32 flags)
 531 {
 532   vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
 533   rdma_main_t *rm = &rdma_main;
 534   rdma_device_t *rd = vec_elt_at_index (rm->devices, hi->dev_instance);
 535   uword is_up = (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) != 0;
 536
 537   if (rd->flags & RDMA_DEVICE_F_ERROR)
 538     return clib_error_return (0, "device is in error state");
 539
 540   if (is_up)
 541     {
 542       vnet_hw_interface_set_flags (vnm, rd->hw_if_index,
 543                                    VNET_HW_INTERFACE_FLAG_LINK_UP);
 544       rd->flags |= RDMA_DEVICE_F_ADMIN_UP;
 545     }
 546   else
 547     {
 548       vnet_hw_interface_set_flags (vnm, rd->hw_if_index, 0);
 549       rd->flags &= ~RDMA_DEVICE_F_ADMIN_UP;
 550     }
 551   return 0;
 552 }
 553
 554 static void
 555 rdma_set_interface_next_node (vnet_main_t * vnm, u32 hw_if_index,
 556                               u32 node_index)
 557 {
 558   rdma_main_t *rm = &rdma_main;
 559   vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, hw_if_index);
 560   rdma_device_t *rd = pool_elt_at_index (rm->devices, hw->dev_instance);
 561
 562   /* Shut off redirection */
 563   if (node_index == ~0)
 564     {
 565       rd->per_interface_next_index = node_index;
 566       return;
 567     }
 568
 569   rd->per_interface_next_index =
 570     vlib_node_add_next (vlib_get_main (), rdma_input_node.index, node_index);
 571 }
 572
 573 static char *rdma_tx_func_error_strings[] = {
 574 #define _(n,s) s,
 575   foreach_rdma_tx_func_error
 576 #undef _
 577 };
 578
 579 /* *INDENT-OFF* */
 580 VNET_DEVICE_CLASS (rdma_device_class,) =
 581 {
 582   .name = "RDMA interface",
 583   .format_device = format_rdma_device,
 584   .format_device_name = format_rdma_device_name,
 585   .admin_up_down_function = rdma_interface_admin_up_down,
 586   .rx_redirect_to_node = rdma_set_interface_next_node,
 587   .tx_function_n_errors = RDMA_TX_N_ERROR,
 588   .tx_function_error_strings = rdma_tx_func_error_strings,
 589 };
 590 /* *INDENT-ON* */
 591
 592 clib_error_t *
 593 rdma_init (vlib_main_t * vm)
 594 {
 595   rdma_main_t *rm = &rdma_main;
 596
 597   rm->log_class = vlib_log_register_class ("rdma", 0);
 598
 599   return 0;
 600 }
 601
 602 VLIB_INIT_FUNCTION (rdma_init);
 603
 604 /*
 605  * fd.io coding-style-patch-verification: ON
 606  *
 607  * Local Variables:
 608  * eval: (c-set-style "gnu")
 609  * End:
 610  */