drivers/net/mlx5/mlx5_glue.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright 2018 6WIND S.A.
   3  * Copyright 2018 Mellanox Technologies, Ltd
   4  */
   5
   6 #include <errno.h>
   7 #include <stdalign.h>
   8 #include <stddef.h>
   9 #include <stdint.h>
  10 #include <stdlib.h>
  11
  12 /*
  13  * Not needed by this file; included to work around the lack of off_t
  14  * definition for mlx5dv.h with unpatched rdma-core versions.
  15  */
  16 #include <sys/types.h>
  17
  18 /* Verbs headers do not support -pedantic. */
  19 #ifdef PEDANTIC
  20 #pragma GCC diagnostic ignored "-Wpedantic"
  21 #endif
  22 #include <infiniband/mlx5dv.h>
  23 #include <infiniband/verbs.h>
  24 #ifdef PEDANTIC
  25 #pragma GCC diagnostic error "-Wpedantic"
  26 #endif
  27
  28 #include <rte_config.h>
  29
  30 #include "mlx5_autoconf.h"
  31 #include "mlx5_glue.h"
  32
  33 static int
  34 mlx5_glue_fork_init(void)
  35 {
  36         return ibv_fork_init();
  37 }
  38
  39 static struct ibv_pd *
  40 mlx5_glue_alloc_pd(struct ibv_context *context)
  41 {
  42         return ibv_alloc_pd(context);
  43 }
  44
  45 static int
  46 mlx5_glue_dealloc_pd(struct ibv_pd *pd)
  47 {
  48         return ibv_dealloc_pd(pd);
  49 }
  50
  51 static struct ibv_device **
  52 mlx5_glue_get_device_list(int *num_devices)
  53 {
  54         return ibv_get_device_list(num_devices);
  55 }
  56
  57 static void
  58 mlx5_glue_free_device_list(struct ibv_device **list)
  59 {
  60         ibv_free_device_list(list);
  61 }
  62
  63 static struct ibv_context *
  64 mlx5_glue_open_device(struct ibv_device *device)
  65 {
  66         return ibv_open_device(device);
  67 }
  68
  69 static int
  70 mlx5_glue_close_device(struct ibv_context *context)
  71 {
  72         return ibv_close_device(context);
  73 }
  74
  75 static int
  76 mlx5_glue_query_device(struct ibv_context *context,
  77                        struct ibv_device_attr *device_attr)
  78 {
  79         return ibv_query_device(context, device_attr);
  80 }
  81
  82 static int
  83 mlx5_glue_query_device_ex(struct ibv_context *context,
  84                           const struct ibv_query_device_ex_input *input,
  85                           struct ibv_device_attr_ex *attr)
  86 {
  87         return ibv_query_device_ex(context, input, attr);
  88 }
  89
  90 static int
  91 mlx5_glue_query_port(struct ibv_context *context, uint8_t port_num,
  92                      struct ibv_port_attr *port_attr)
  93 {
  94         return ibv_query_port(context, port_num, port_attr);
  95 }
  96
  97 static struct ibv_comp_channel *
  98 mlx5_glue_create_comp_channel(struct ibv_context *context)
  99 {
 100         return ibv_create_comp_channel(context);
 101 }
 102
 103 static int
 104 mlx5_glue_destroy_comp_channel(struct ibv_comp_channel *channel)
 105 {
 106         return ibv_destroy_comp_channel(channel);
 107 }
 108
 109 static struct ibv_cq *
 110 mlx5_glue_create_cq(struct ibv_context *context, int cqe, void *cq_context,
 111                     struct ibv_comp_channel *channel, int comp_vector)
 112 {
 113         return ibv_create_cq(context, cqe, cq_context, channel, comp_vector);
 114 }
 115
 116 static int
 117 mlx5_glue_destroy_cq(struct ibv_cq *cq)
 118 {
 119         return ibv_destroy_cq(cq);
 120 }
 121
 122 static int
 123 mlx5_glue_get_cq_event(struct ibv_comp_channel *channel, struct ibv_cq **cq,
 124                        void **cq_context)
 125 {
 126         return ibv_get_cq_event(channel, cq, cq_context);
 127 }
 128
 129 static void
 130 mlx5_glue_ack_cq_events(struct ibv_cq *cq, unsigned int nevents)
 131 {
 132         ibv_ack_cq_events(cq, nevents);
 133 }
 134
 135 static struct ibv_rwq_ind_table *
 136 mlx5_glue_create_rwq_ind_table(struct ibv_context *context,
 137                                struct ibv_rwq_ind_table_init_attr *init_attr)
 138 {
 139         return ibv_create_rwq_ind_table(context, init_attr);
 140 }
 141
 142 static int
 143 mlx5_glue_destroy_rwq_ind_table(struct ibv_rwq_ind_table *rwq_ind_table)
 144 {
 145         return ibv_destroy_rwq_ind_table(rwq_ind_table);
 146 }
 147
 148 static struct ibv_wq *
 149 mlx5_glue_create_wq(struct ibv_context *context,
 150                     struct ibv_wq_init_attr *wq_init_attr)
 151 {
 152         return ibv_create_wq(context, wq_init_attr);
 153 }
 154
 155 static int
 156 mlx5_glue_destroy_wq(struct ibv_wq *wq)
 157 {
 158         return ibv_destroy_wq(wq);
 159 }
 160 static int
 161 mlx5_glue_modify_wq(struct ibv_wq *wq, struct ibv_wq_attr *wq_attr)
 162 {
 163         return ibv_modify_wq(wq, wq_attr);
 164 }
 165
 166 static struct ibv_flow *
 167 mlx5_glue_create_flow(struct ibv_qp *qp, struct ibv_flow_attr *flow)
 168 {
 169         return ibv_create_flow(qp, flow);
 170 }
 171
 172 static int
 173 mlx5_glue_destroy_flow(struct ibv_flow *flow_id)
 174 {
 175         return ibv_destroy_flow(flow_id);
 176 }
 177
 178 static int
 179 mlx5_glue_destroy_flow_action(void *action)
 180 {
 181 #ifdef HAVE_IBV_FLOW_DV_SUPPORT
 182 #ifdef HAVE_MLX5DV_DR
 183         return mlx5dv_dr_destroy_action(action);
 184 #else
 185         struct mlx5dv_flow_action_attr *attr = action;
 186         int res = 0;
 187         switch (attr->type) {
 188         case MLX5DV_FLOW_ACTION_TAG:
 189                 break;
 190         default:
 191                 res = ibv_destroy_flow_action(attr->action);
 192                 break;
 193         }
 194         free(action);
 195         return res;
 196 #endif
 197 #else
 198         (void)action;
 199         return ENOTSUP;
 200 #endif
 201 }
 202
 203 static struct ibv_qp *
 204 mlx5_glue_create_qp(struct ibv_pd *pd, struct ibv_qp_init_attr *qp_init_attr)
 205 {
 206         return ibv_create_qp(pd, qp_init_attr);
 207 }
 208
 209 static struct ibv_qp *
 210 mlx5_glue_create_qp_ex(struct ibv_context *context,
 211                        struct ibv_qp_init_attr_ex *qp_init_attr_ex)
 212 {
 213         return ibv_create_qp_ex(context, qp_init_attr_ex);
 214 }
 215
 216 static int
 217 mlx5_glue_destroy_qp(struct ibv_qp *qp)
 218 {
 219         return ibv_destroy_qp(qp);
 220 }
 221
 222 static int
 223 mlx5_glue_modify_qp(struct ibv_qp *qp, struct ibv_qp_attr *attr, int attr_mask)
 224 {
 225         return ibv_modify_qp(qp, attr, attr_mask);
 226 }
 227
 228 static struct ibv_mr *
 229 mlx5_glue_reg_mr(struct ibv_pd *pd, void *addr, size_t length, int access)
 230 {
 231         return ibv_reg_mr(pd, addr, length, access);
 232 }
 233
 234 static int
 235 mlx5_glue_dereg_mr(struct ibv_mr *mr)
 236 {
 237         return ibv_dereg_mr(mr);
 238 }
 239
 240 static struct ibv_counter_set *
 241 mlx5_glue_create_counter_set(struct ibv_context *context,
 242                              struct ibv_counter_set_init_attr *init_attr)
 243 {
 244 #ifndef HAVE_IBV_DEVICE_COUNTERS_SET_V42
 245         (void)context;
 246         (void)init_attr;
 247         return NULL;
 248 #else
 249         return ibv_create_counter_set(context, init_attr);
 250 #endif
 251 }
 252
 253 static int
 254 mlx5_glue_destroy_counter_set(struct ibv_counter_set *cs)
 255 {
 256 #ifndef HAVE_IBV_DEVICE_COUNTERS_SET_V42
 257         (void)cs;
 258         return ENOTSUP;
 259 #else
 260         return ibv_destroy_counter_set(cs);
 261 #endif
 262 }
 263
 264 static int
 265 mlx5_glue_describe_counter_set(struct ibv_context *context,
 266                                uint16_t counter_set_id,
 267                                struct ibv_counter_set_description *cs_desc)
 268 {
 269 #ifndef HAVE_IBV_DEVICE_COUNTERS_SET_V42
 270         (void)context;
 271         (void)counter_set_id;
 272         (void)cs_desc;
 273         return ENOTSUP;
 274 #else
 275         return ibv_describe_counter_set(context, counter_set_id, cs_desc);
 276 #endif
 277 }
 278
 279 static int
 280 mlx5_glue_query_counter_set(struct ibv_query_counter_set_attr *query_attr,
 281                             struct ibv_counter_set_data *cs_data)
 282 {
 283 #ifndef HAVE_IBV_DEVICE_COUNTERS_SET_V42
 284         (void)query_attr;
 285         (void)cs_data;
 286         return ENOTSUP;
 287 #else
 288         return ibv_query_counter_set(query_attr, cs_data);
 289 #endif
 290 }
 291
 292 static struct ibv_counters *
 293 mlx5_glue_create_counters(struct ibv_context *context,
 294                           struct ibv_counters_init_attr *init_attr)
 295 {
 296 #ifndef HAVE_IBV_DEVICE_COUNTERS_SET_V45
 297         (void)context;
 298         (void)init_attr;
 299         return NULL;
 300 #else
 301         return ibv_create_counters(context, init_attr);
 302 #endif
 303 }
 304
 305 static int
 306 mlx5_glue_destroy_counters(struct ibv_counters *counters)
 307 {
 308 #ifndef HAVE_IBV_DEVICE_COUNTERS_SET_V45
 309         (void)counters;
 310         return ENOTSUP;
 311 #else
 312         return ibv_destroy_counters(counters);
 313 #endif
 314 }
 315
 316 static int
 317 mlx5_glue_attach_counters(struct ibv_counters *counters,
 318                           struct ibv_counter_attach_attr *attr,
 319                           struct ibv_flow *flow)
 320 {
 321 #ifndef HAVE_IBV_DEVICE_COUNTERS_SET_V45
 322         (void)counters;
 323         (void)attr;
 324         (void)flow;
 325         return ENOTSUP;
 326 #else
 327         return ibv_attach_counters_point_flow(counters, attr, flow);
 328 #endif
 329 }
 330
 331 static int
 332 mlx5_glue_query_counters(struct ibv_counters *counters,
 333                          uint64_t *counters_value,
 334                          uint32_t ncounters,
 335                          uint32_t flags)
 336 {
 337 #ifndef HAVE_IBV_DEVICE_COUNTERS_SET_V45
 338         (void)counters;
 339         (void)counters_value;
 340         (void)ncounters;
 341         (void)flags;
 342         return ENOTSUP;
 343 #else
 344         return ibv_read_counters(counters, counters_value, ncounters, flags);
 345 #endif
 346 }
 347
 348 static void
 349 mlx5_glue_ack_async_event(struct ibv_async_event *event)
 350 {
 351         ibv_ack_async_event(event);
 352 }
 353
 354 static int
 355 mlx5_glue_get_async_event(struct ibv_context *context,
 356                           struct ibv_async_event *event)
 357 {
 358         return ibv_get_async_event(context, event);
 359 }
 360
 361 static const char *
 362 mlx5_glue_port_state_str(enum ibv_port_state port_state)
 363 {
 364         return ibv_port_state_str(port_state);
 365 }
 366
 367 static struct ibv_cq *
 368 mlx5_glue_cq_ex_to_cq(struct ibv_cq_ex *cq)
 369 {
 370         return ibv_cq_ex_to_cq(cq);
 371 }
 372
 373 static void *
 374 mlx5_glue_dr_create_flow_action_dest_flow_tbl(void *tbl)
 375 {
 376 #ifdef HAVE_MLX5DV_DR
 377         return mlx5dv_dr_create_action_dest_flow_table(tbl);
 378 #else
 379         (void)tbl;
 380         return NULL;
 381 #endif
 382 }
 383
 384 static void *
 385 mlx5_glue_dr_create_flow_tbl(void *ns, uint32_t level)
 386 {
 387 #ifdef HAVE_MLX5DV_DR
 388         return mlx5dv_dr_create_ft(ns, level);
 389 #else
 390         (void)ns;
 391         (void)level;
 392         return NULL;
 393 #endif
 394 }
 395
 396 static int
 397 mlx5_glue_dr_destroy_flow_tbl(void *tbl)
 398 {
 399 #ifdef HAVE_MLX5DV_DR
 400         return mlx5dv_dr_destroy_ft(tbl);
 401 #else
 402         (void)tbl;
 403         return 0;
 404 #endif
 405 }
 406
 407 static void *
 408 mlx5_glue_dr_create_ns(struct ibv_context *ctx,
 409                        enum  mlx5dv_dr_ns_domain domain)
 410 {
 411 #ifdef HAVE_MLX5DV_DR
 412         return mlx5dv_dr_create_ns(ctx, domain);
 413 #else
 414         (void)ctx;
 415         (void)domain;
 416         return NULL;
 417 #endif
 418 }
 419
 420 static int
 421 mlx5_glue_dr_destroy_ns(void *ns)
 422 {
 423 #ifdef HAVE_MLX5DV_DR
 424         return mlx5dv_dr_destroy_ns(ns);
 425 #else
 426         (void)ns;
 427         return 0;
 428 #endif
 429 }
 430
 431 static struct ibv_cq_ex *
 432 mlx5_glue_dv_create_cq(struct ibv_context *context,
 433                        struct ibv_cq_init_attr_ex *cq_attr,
 434                        struct mlx5dv_cq_init_attr *mlx5_cq_attr)
 435 {
 436         return mlx5dv_create_cq(context, cq_attr, mlx5_cq_attr);
 437 }
 438
 439 static struct ibv_wq *
 440 mlx5_glue_dv_create_wq(struct ibv_context *context,
 441                        struct ibv_wq_init_attr *wq_attr,
 442                        struct mlx5dv_wq_init_attr *mlx5_wq_attr)
 443 {
 444 #ifndef HAVE_IBV_DEVICE_STRIDING_RQ_SUPPORT
 445         (void)context;
 446         (void)wq_attr;
 447         (void)mlx5_wq_attr;
 448         return NULL;
 449 #else
 450         return mlx5dv_create_wq(context, wq_attr, mlx5_wq_attr);
 451 #endif
 452 }
 453
 454 static int
 455 mlx5_glue_dv_query_device(struct ibv_context *ctx,
 456                           struct mlx5dv_context *attrs_out)
 457 {
 458         return mlx5dv_query_device(ctx, attrs_out);
 459 }
 460
 461 static int
 462 mlx5_glue_dv_set_context_attr(struct ibv_context *ibv_ctx,
 463                               enum mlx5dv_set_ctx_attr_type type, void *attr)
 464 {
 465         return mlx5dv_set_context_attr(ibv_ctx, type, attr);
 466 }
 467
 468 static int
 469 mlx5_glue_dv_init_obj(struct mlx5dv_obj *obj, uint64_t obj_type)
 470 {
 471         return mlx5dv_init_obj(obj, obj_type);
 472 }
 473
 474 static struct ibv_qp *
 475 mlx5_glue_dv_create_qp(struct ibv_context *context,
 476                        struct ibv_qp_init_attr_ex *qp_init_attr_ex,
 477                        struct mlx5dv_qp_init_attr *dv_qp_init_attr)
 478 {
 479 #ifdef HAVE_IBV_DEVICE_TUNNEL_SUPPORT
 480         return mlx5dv_create_qp(context, qp_init_attr_ex, dv_qp_init_attr);
 481 #else
 482         (void)context;
 483         (void)qp_init_attr_ex;
 484         (void)dv_qp_init_attr;
 485         return NULL;
 486 #endif
 487 }
 488
 489 static void *
 490 mlx5_glue_dv_create_flow_matcher(struct ibv_context *context,
 491                                  struct mlx5dv_flow_matcher_attr *matcher_attr,
 492                                  void *tbl)
 493 {
 494 #ifdef HAVE_IBV_FLOW_DV_SUPPORT
 495 #ifdef HAVE_MLX5DV_DR
 496         (void)context;
 497         return mlx5dv_dr_create_matcher(tbl, matcher_attr->priority,
 498                                        matcher_attr->match_criteria_enable,
 499                                        matcher_attr->match_mask);
 500 #else
 501         (void)tbl;
 502         return mlx5dv_create_flow_matcher(context, matcher_attr);
 503 #endif
 504 #else
 505         (void)context;
 506         (void)matcher_attr;
 507         (void)tbl;
 508         return NULL;
 509 #endif
 510 }
 511
 512 static void *
 513 mlx5_glue_dv_create_flow(void *matcher,
 514                          void *match_value,
 515                          size_t num_actions,
 516                          void *actions[])
 517 {
 518 #ifdef HAVE_IBV_FLOW_DV_SUPPORT
 519 #ifdef HAVE_MLX5DV_DR
 520         return mlx5dv_dr_create_rule(matcher, match_value, num_actions,
 521                                      (struct mlx5dv_dr_action **)actions);
 522 #else
 523         struct mlx5dv_flow_action_attr actions_attr[8];
 524
 525         if (num_actions > 8)
 526                 return NULL;
 527         for (size_t i = 0; i < num_actions; i++)
 528                 actions_attr[i] =
 529                         *((struct mlx5dv_flow_action_attr *)(actions[i]));
 530         return mlx5dv_create_flow(matcher, match_value,
 531                                   num_actions, actions_attr);
 532 #endif
 533 #else
 534         (void)matcher;
 535         (void)match_value;
 536         (void)num_actions;
 537         (void)actions;
 538         return NULL;
 539 #endif
 540 }
 541
 542 static void *
 543 mlx5_glue_dv_create_flow_action_counter(void *counter_obj, uint32_t offset)
 544 {
 545 #ifdef HAVE_IBV_FLOW_DV_SUPPORT
 546 #ifdef HAVE_MLX5DV_DR
 547         return mlx5dv_dr_create_action_devx_counter(counter_obj, offset);
 548 #else
 549         struct mlx5dv_flow_action_attr *action;
 550
 551         (void)offset;
 552         action = malloc(sizeof(*action));
 553         if (!action)
 554                 return NULL;
 555         action->type = MLX5DV_FLOW_ACTION_COUNTERS_DEVX;
 556         action->obj = counter_obj;
 557         return action;
 558 #endif
 559 #else
 560         (void)counter_obj;
 561         (void)offset;
 562         return NULL;
 563 #endif
 564 }
 565
 566 static void *
 567 mlx5_glue_dv_create_flow_action_dest_ibv_qp(void *qp)
 568 {
 569 #ifdef HAVE_IBV_FLOW_DV_SUPPORT
 570 #ifdef HAVE_MLX5DV_DR
 571         return mlx5dv_dr_create_action_dest_ibv_qp(qp);
 572 #else
 573         struct mlx5dv_flow_action_attr *action;
 574
 575         action = malloc(sizeof(*action));
 576         if (!action)
 577                 return NULL;
 578         action->type = MLX5DV_FLOW_ACTION_DEST_IBV_QP;
 579         action->obj = qp;
 580         return action;
 581 #endif
 582 #else
 583         (void)qp;
 584         return NULL;
 585 #endif
 586 }
 587
 588 static void *
 589 mlx5_glue_dv_create_flow_action_modify_header
 590                                         (struct ibv_context *ctx,
 591                                          enum mlx5dv_flow_table_type ft_type,
 592                                          void *ns, uint64_t flags,
 593                                          size_t actions_sz,
 594                                          uint64_t actions[])
 595 {
 596 #ifdef HAVE_IBV_FLOW_DV_SUPPORT
 597 #ifdef HAVE_MLX5DV_DR
 598         (void)ctx;
 599         (void)ft_type;
 600         return mlx5dv_dr_create_action_modify_header(ns, flags, actions_sz,
 601                                                     actions);
 602 #else
 603         struct mlx5dv_flow_action_attr *action;
 604
 605         (void)ns;
 606         (void)flags;
 607         action = malloc(sizeof(*action));
 608         if (!action)
 609                 return NULL;
 610         action->type = MLX5DV_FLOW_ACTION_IBV_FLOW_ACTION;
 611         action->action = mlx5dv_create_flow_action_modify_header
 612                 (ctx, actions_sz, actions, ft_type);
 613         return action;
 614 #endif
 615 #else
 616         (void)ctx;
 617         (void)ft_type;
 618         (void)ns;
 619         (void)flags;
 620         (void)actions_sz;
 621         (void)actions;
 622         return NULL;
 623 #endif
 624 }
 625
 626 static void *
 627 mlx5_glue_dv_create_flow_action_packet_reformat
 628                 (struct ibv_context *ctx,
 629                  enum mlx5dv_flow_action_packet_reformat_type reformat_type,
 630                  enum mlx5dv_flow_table_type ft_type, struct mlx5dv_dr_ns *ns,
 631                  uint32_t flags, size_t data_sz, void *data)
 632 {
 633 #ifdef HAVE_IBV_FLOW_DV_SUPPORT
 634 #ifdef HAVE_MLX5DV_DR
 635         (void)ctx;
 636         (void)ft_type;
 637         return mlx5dv_dr_create_action_packet_reformat(ns, flags,
 638                                                        reformat_type, data_sz,
 639                                                        data);
 640 #else
 641         (void)ns;
 642         (void)flags;
 643         struct mlx5dv_flow_action_attr *action;
 644
 645         action = malloc(sizeof(*action));
 646         if (!action)
 647                 return NULL;
 648         action->type = MLX5DV_FLOW_ACTION_IBV_FLOW_ACTION;
 649         action->action = mlx5dv_create_flow_action_packet_reformat
 650                 (ctx, data_sz, data, reformat_type, ft_type);
 651         return action;
 652 #endif
 653 #else
 654         (void)ctx;
 655         (void)reformat_type;
 656         (void)ft_type;
 657         (void)ns;
 658         (void)flags;
 659         (void)data_sz;
 660         (void)data;
 661         return NULL;
 662 #endif
 663 }
 664
 665 static void *
 666 mlx5_glue_dv_create_flow_action_tag(uint32_t tag)
 667 {
 668 #ifdef HAVE_IBV_FLOW_DV_SUPPORT
 669 #ifdef HAVE_MLX5DV_DR
 670         return mlx5dv_dr_create_action_tag(tag);
 671 #else
 672         struct mlx5dv_flow_action_attr *action;
 673         action = malloc(sizeof(*action));
 674         if (!action)
 675                 return NULL;
 676         action->type = MLX5DV_FLOW_ACTION_TAG;
 677         action->tag_value = tag;
 678         return action;
 679 #endif
 680 #endif
 681         (void)tag;
 682         return NULL;
 683 }
 684
 685 static int
 686 mlx5_glue_dv_destroy_flow(void *flow_id)
 687 {
 688 #ifdef HAVE_MLX5DV_DR
 689         return mlx5dv_dr_destroy_rule(flow_id);
 690 #else
 691         return ibv_destroy_flow(flow_id);
 692 #endif
 693 }
 694
 695 static int
 696 mlx5_glue_dv_destroy_flow_matcher(void *matcher)
 697 {
 698 #ifdef HAVE_IBV_FLOW_DV_SUPPORT
 699 #ifdef HAVE_MLX5DV_DR
 700         return mlx5dv_dr_destroy_matcher(matcher);
 701 #else
 702         return mlx5dv_destroy_flow_matcher(matcher);
 703 #endif
 704 #else
 705         (void)matcher;
 706         return 0;
 707 #endif
 708 }
 709
 710 static struct ibv_context *
 711 mlx5_glue_dv_open_device(struct ibv_device *device)
 712 {
 713 #ifdef HAVE_IBV_DEVX_OBJ
 714         return mlx5dv_open_device(device,
 715                                   &(struct mlx5dv_context_attr){
 716                                         .flags = MLX5DV_CONTEXT_FLAGS_DEVX,
 717                                   });
 718 #else
 719         (void)device;
 720         return NULL;
 721 #endif
 722 }
 723
 724 static struct mlx5dv_devx_obj *
 725 mlx5_glue_devx_obj_create(struct ibv_context *ctx,
 726                           const void *in, size_t inlen,
 727                           void *out, size_t outlen)
 728 {
 729 #ifdef HAVE_IBV_DEVX_OBJ
 730         return mlx5dv_devx_obj_create(ctx, in, inlen, out, outlen);
 731 #else
 732         (void)ctx;
 733         (void)in;
 734         (void)inlen;
 735         (void)out;
 736         (void)outlen;
 737         return NULL;
 738 #endif
 739 }
 740
 741 static int
 742 mlx5_glue_devx_obj_destroy(struct mlx5dv_devx_obj *obj)
 743 {
 744 #ifdef HAVE_IBV_DEVX_OBJ
 745         return mlx5dv_devx_obj_destroy(obj);
 746 #else
 747         (void)obj;
 748         return -ENOTSUP;
 749 #endif
 750 }
 751
 752 static int
 753 mlx5_glue_devx_obj_query(struct mlx5dv_devx_obj *obj,
 754                          const void *in, size_t inlen,
 755                          void *out, size_t outlen)
 756 {
 757 #ifdef HAVE_IBV_DEVX_OBJ
 758         return mlx5dv_devx_obj_query(obj, in, inlen, out, outlen);
 759 #else
 760         (void)obj;
 761         (void)in;
 762         (void)inlen;
 763         (void)out;
 764         (void)outlen;
 765         return -ENOTSUP;
 766 #endif
 767 }
 768
 769 static int
 770 mlx5_glue_devx_obj_modify(struct mlx5dv_devx_obj *obj,
 771                           const void *in, size_t inlen,
 772                           void *out, size_t outlen)
 773 {
 774 #ifdef HAVE_IBV_DEVX_OBJ
 775         return mlx5dv_devx_obj_modify(obj, in, inlen, out, outlen);
 776 #else
 777         (void)obj;
 778         (void)in;
 779         (void)inlen;
 780         (void)out;
 781         (void)outlen;
 782         return -ENOTSUP;
 783 #endif
 784 }
 785
 786 static int
 787 mlx5_glue_devx_general_cmd(struct ibv_context *ctx,
 788                            const void *in, size_t inlen,
 789                            void *out, size_t outlen)
 790 {
 791 #ifdef HAVE_IBV_DEVX_OBJ
 792         return mlx5dv_devx_general_cmd(ctx, in, inlen, out, outlen);
 793 #else
 794         (void)ctx;
 795         (void)in;
 796         (void)inlen;
 797         (void)out;
 798         (void)outlen;
 799         return -ENOTSUP;
 800 #endif
 801 }
 802
 803 alignas(RTE_CACHE_LINE_SIZE)
 804 const struct mlx5_glue *mlx5_glue = &(const struct mlx5_glue){
 805         .version = MLX5_GLUE_VERSION,
 806         .fork_init = mlx5_glue_fork_init,
 807         .alloc_pd = mlx5_glue_alloc_pd,
 808         .dealloc_pd = mlx5_glue_dealloc_pd,
 809         .get_device_list = mlx5_glue_get_device_list,
 810         .free_device_list = mlx5_glue_free_device_list,
 811         .open_device = mlx5_glue_open_device,
 812         .close_device = mlx5_glue_close_device,
 813         .query_device = mlx5_glue_query_device,
 814         .query_device_ex = mlx5_glue_query_device_ex,
 815         .query_port = mlx5_glue_query_port,
 816         .create_comp_channel = mlx5_glue_create_comp_channel,
 817         .destroy_comp_channel = mlx5_glue_destroy_comp_channel,
 818         .create_cq = mlx5_glue_create_cq,
 819         .destroy_cq = mlx5_glue_destroy_cq,
 820         .get_cq_event = mlx5_glue_get_cq_event,
 821         .ack_cq_events = mlx5_glue_ack_cq_events,
 822         .create_rwq_ind_table = mlx5_glue_create_rwq_ind_table,
 823         .destroy_rwq_ind_table = mlx5_glue_destroy_rwq_ind_table,
 824         .create_wq = mlx5_glue_create_wq,
 825         .destroy_wq = mlx5_glue_destroy_wq,
 826         .modify_wq = mlx5_glue_modify_wq,
 827         .create_flow = mlx5_glue_create_flow,
 828         .destroy_flow = mlx5_glue_destroy_flow,
 829         .destroy_flow_action = mlx5_glue_destroy_flow_action,
 830         .create_qp = mlx5_glue_create_qp,
 831         .create_qp_ex = mlx5_glue_create_qp_ex,
 832         .destroy_qp = mlx5_glue_destroy_qp,
 833         .modify_qp = mlx5_glue_modify_qp,
 834         .reg_mr = mlx5_glue_reg_mr,
 835         .dereg_mr = mlx5_glue_dereg_mr,
 836         .create_counter_set = mlx5_glue_create_counter_set,
 837         .destroy_counter_set = mlx5_glue_destroy_counter_set,
 838         .describe_counter_set = mlx5_glue_describe_counter_set,
 839         .query_counter_set = mlx5_glue_query_counter_set,
 840         .create_counters = mlx5_glue_create_counters,
 841         .destroy_counters = mlx5_glue_destroy_counters,
 842         .attach_counters = mlx5_glue_attach_counters,
 843         .query_counters = mlx5_glue_query_counters,
 844         .ack_async_event = mlx5_glue_ack_async_event,
 845         .get_async_event = mlx5_glue_get_async_event,
 846         .port_state_str = mlx5_glue_port_state_str,
 847         .cq_ex_to_cq = mlx5_glue_cq_ex_to_cq,
 848         .dr_create_flow_action_dest_flow_tbl =
 849                 mlx5_glue_dr_create_flow_action_dest_flow_tbl,
 850         .dr_create_flow_tbl = mlx5_glue_dr_create_flow_tbl,
 851         .dr_destroy_flow_tbl = mlx5_glue_dr_destroy_flow_tbl,
 852         .dr_create_ns = mlx5_glue_dr_create_ns,
 853         .dr_destroy_ns = mlx5_glue_dr_destroy_ns,
 854         .dv_create_cq = mlx5_glue_dv_create_cq,
 855         .dv_create_wq = mlx5_glue_dv_create_wq,
 856         .dv_query_device = mlx5_glue_dv_query_device,
 857         .dv_set_context_attr = mlx5_glue_dv_set_context_attr,
 858         .dv_init_obj = mlx5_glue_dv_init_obj,
 859         .dv_create_qp = mlx5_glue_dv_create_qp,
 860         .dv_create_flow_matcher = mlx5_glue_dv_create_flow_matcher,
 861         .dv_create_flow = mlx5_glue_dv_create_flow,
 862         .dv_create_flow_action_counter =
 863                 mlx5_glue_dv_create_flow_action_counter,
 864         .dv_create_flow_action_dest_ibv_qp =
 865                 mlx5_glue_dv_create_flow_action_dest_ibv_qp,
 866         .dv_create_flow_action_modify_header =
 867                 mlx5_glue_dv_create_flow_action_modify_header,
 868         .dv_create_flow_action_packet_reformat =
 869                 mlx5_glue_dv_create_flow_action_packet_reformat,
 870         .dv_create_flow_action_tag =  mlx5_glue_dv_create_flow_action_tag,
 871         .dv_destroy_flow = mlx5_glue_dv_destroy_flow,
 872         .dv_destroy_flow_matcher = mlx5_glue_dv_destroy_flow_matcher,
 873         .dv_open_device = mlx5_glue_dv_open_device,
 874         .devx_obj_create = mlx5_glue_devx_obj_create,
 875         .devx_obj_destroy = mlx5_glue_devx_obj_destroy,
 876         .devx_obj_query = mlx5_glue_devx_obj_query,
 877         .devx_obj_modify = mlx5_glue_devx_obj_modify,
 878         .devx_general_cmd = mlx5_glue_devx_general_cmd,
 879 };