drivers/net/mlx5/mlx5_nl.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 <linux/if_link.h>
   8 #include <linux/netlink.h>
   9 #include <linux/rtnetlink.h>
  10 #include <net/if.h>
  11 #include <rdma/rdma_netlink.h>
  12 #include <stdbool.h>
  13 #include <stdint.h>
  14 #include <stdlib.h>
  15 #include <stdalign.h>
  16 #include <string.h>
  17 #include <sys/socket.h>
  18 #include <unistd.h>
  19
  20 #include <rte_errno.h>
  21 #include <rte_malloc.h>
  22 #include <rte_hypervisor.h>
  23
  24 #include "mlx5.h"
  25 #include "mlx5_utils.h"
  26
  27 /* Size of the buffer to receive kernel messages */
  28 #define MLX5_NL_BUF_SIZE (32 * 1024)
  29 /* Send buffer size for the Netlink socket */
  30 #define MLX5_SEND_BUF_SIZE 32768
  31 /* Receive buffer size for the Netlink socket */
  32 #define MLX5_RECV_BUF_SIZE 32768
  33
  34 /** Parameters of VLAN devices created by driver. */
  35 #define MLX5_VMWA_VLAN_DEVICE_PFX "evmlx"
  36 /*
  37  * Define NDA_RTA as defined in iproute2 sources.
  38  *
  39  * see in iproute2 sources file include/libnetlink.h
  40  */
  41 #ifndef MLX5_NDA_RTA
  42 #define MLX5_NDA_RTA(r) \
  43         ((struct rtattr *)(((char *)(r)) + NLMSG_ALIGN(sizeof(struct ndmsg))))
  44 #endif
  45
  46 /*
  47  * The following definitions are normally found in rdma/rdma_netlink.h,
  48  * however they are so recent that most systems do not expose them yet.
  49  */
  50 #ifndef HAVE_RDMA_NL_NLDEV
  51 #define RDMA_NL_NLDEV 5
  52 #endif
  53 #ifndef HAVE_RDMA_NLDEV_CMD_GET
  54 #define RDMA_NLDEV_CMD_GET 1
  55 #endif
  56 #ifndef HAVE_RDMA_NLDEV_CMD_PORT_GET
  57 #define RDMA_NLDEV_CMD_PORT_GET 5
  58 #endif
  59 #ifndef HAVE_RDMA_NLDEV_ATTR_DEV_INDEX
  60 #define RDMA_NLDEV_ATTR_DEV_INDEX 1
  61 #endif
  62 #ifndef HAVE_RDMA_NLDEV_ATTR_DEV_NAME
  63 #define RDMA_NLDEV_ATTR_DEV_NAME 2
  64 #endif
  65 #ifndef HAVE_RDMA_NLDEV_ATTR_PORT_INDEX
  66 #define RDMA_NLDEV_ATTR_PORT_INDEX 3
  67 #endif
  68 #ifndef HAVE_RDMA_NLDEV_ATTR_NDEV_INDEX
  69 #define RDMA_NLDEV_ATTR_NDEV_INDEX 50
  70 #endif
  71
  72 /* These are normally found in linux/if_link.h. */
  73 #ifndef HAVE_IFLA_NUM_VF
  74 #define IFLA_NUM_VF 21
  75 #endif
  76 #ifndef HAVE_IFLA_EXT_MASK
  77 #define IFLA_EXT_MASK 29
  78 #endif
  79 #ifndef HAVE_IFLA_PHYS_SWITCH_ID
  80 #define IFLA_PHYS_SWITCH_ID 36
  81 #endif
  82 #ifndef HAVE_IFLA_PHYS_PORT_NAME
  83 #define IFLA_PHYS_PORT_NAME 38
  84 #endif
  85
  86 /* Add/remove MAC address through Netlink */
  87 struct mlx5_nl_mac_addr {
  88         struct rte_ether_addr (*mac)[];
  89         /**< MAC address handled by the device. */
  90         int mac_n; /**< Number of addresses in the array. */
  91 };
  92
  93 /** Data structure used by mlx5_nl_cmdget_cb(). */
  94 struct mlx5_nl_ifindex_data {
  95         const char *name; /**< IB device name (in). */
  96         uint32_t ibindex; /**< IB device index (out). */
  97         uint32_t ifindex; /**< Network interface index (out). */
  98         uint32_t portnum; /**< IB device max port number. */
  99 };
 100
 101 /**
 102  * Opens a Netlink socket.
 103  *
 104  * @param protocol
 105  *   Netlink protocol (e.g. NETLINK_ROUTE, NETLINK_RDMA).
 106  *
 107  * @return
 108  *   A file descriptor on success, a negative errno value otherwise and
 109  *   rte_errno is set.
 110  */
 111 int
 112 mlx5_nl_init(int protocol)
 113 {
 114         int fd;
 115         int sndbuf_size = MLX5_SEND_BUF_SIZE;
 116         int rcvbuf_size = MLX5_RECV_BUF_SIZE;
 117         struct sockaddr_nl local = {
 118                 .nl_family = AF_NETLINK,
 119         };
 120         int ret;
 121
 122         fd = socket(AF_NETLINK, SOCK_RAW | SOCK_CLOEXEC, protocol);
 123         if (fd == -1) {
 124                 rte_errno = errno;
 125                 return -rte_errno;
 126         }
 127         ret = setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &sndbuf_size, sizeof(int));
 128         if (ret == -1) {
 129                 rte_errno = errno;
 130                 goto error;
 131         }
 132         ret = setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &rcvbuf_size, sizeof(int));
 133         if (ret == -1) {
 134                 rte_errno = errno;
 135                 goto error;
 136         }
 137         ret = bind(fd, (struct sockaddr *)&local, sizeof(local));
 138         if (ret == -1) {
 139                 rte_errno = errno;
 140                 goto error;
 141         }
 142         return fd;
 143 error:
 144         close(fd);
 145         return -rte_errno;
 146 }
 147
 148 /**
 149  * Send a request message to the kernel on the Netlink socket.
 150  *
 151  * @param[in] nlsk_fd
 152  *   Netlink socket file descriptor.
 153  * @param[in] nh
 154  *   The Netlink message send to the kernel.
 155  * @param[in] ssn
 156  *   Sequence number.
 157  * @param[in] req
 158  *   Pointer to the request structure.
 159  * @param[in] len
 160  *   Length of the request in bytes.
 161  *
 162  * @return
 163  *   The number of sent bytes on success, a negative errno value otherwise and
 164  *   rte_errno is set.
 165  */
 166 static int
 167 mlx5_nl_request(int nlsk_fd, struct nlmsghdr *nh, uint32_t sn, void *req,
 168                 int len)
 169 {
 170         struct sockaddr_nl sa = {
 171                 .nl_family = AF_NETLINK,
 172         };
 173         struct iovec iov[2] = {
 174                 { .iov_base = nh, .iov_len = sizeof(*nh), },
 175                 { .iov_base = req, .iov_len = len, },
 176         };
 177         struct msghdr msg = {
 178                 .msg_name = &sa,
 179                 .msg_namelen = sizeof(sa),
 180                 .msg_iov = iov,
 181                 .msg_iovlen = 2,
 182         };
 183         int send_bytes;
 184
 185         nh->nlmsg_pid = 0; /* communication with the kernel uses pid 0 */
 186         nh->nlmsg_seq = sn;
 187         send_bytes = sendmsg(nlsk_fd, &msg, 0);
 188         if (send_bytes < 0) {
 189                 rte_errno = errno;
 190                 return -rte_errno;
 191         }
 192         return send_bytes;
 193 }
 194
 195 /**
 196  * Send a message to the kernel on the Netlink socket.
 197  *
 198  * @param[in] nlsk_fd
 199  *   The Netlink socket file descriptor used for communication.
 200  * @param[in] nh
 201  *   The Netlink message send to the kernel.
 202  * @param[in] sn
 203  *   Sequence number.
 204  *
 205  * @return
 206  *   The number of sent bytes on success, a negative errno value otherwise and
 207  *   rte_errno is set.
 208  */
 209 static int
 210 mlx5_nl_send(int nlsk_fd, struct nlmsghdr *nh, uint32_t sn)
 211 {
 212         struct sockaddr_nl sa = {
 213                 .nl_family = AF_NETLINK,
 214         };
 215         struct iovec iov = {
 216                 .iov_base = nh,
 217                 .iov_len = nh->nlmsg_len,
 218         };
 219         struct msghdr msg = {
 220                 .msg_name = &sa,
 221                 .msg_namelen = sizeof(sa),
 222                 .msg_iov = &iov,
 223                 .msg_iovlen = 1,
 224         };
 225         int send_bytes;
 226
 227         nh->nlmsg_pid = 0; /* communication with the kernel uses pid 0 */
 228         nh->nlmsg_seq = sn;
 229         send_bytes = sendmsg(nlsk_fd, &msg, 0);
 230         if (send_bytes < 0) {
 231                 rte_errno = errno;
 232                 return -rte_errno;
 233         }
 234         return send_bytes;
 235 }
 236
 237 /**
 238  * Receive a message from the kernel on the Netlink socket, following
 239  * mlx5_nl_send().
 240  *
 241  * @param[in] nlsk_fd
 242  *   The Netlink socket file descriptor used for communication.
 243  * @param[in] sn
 244  *   Sequence number.
 245  * @param[in] cb
 246  *   The callback function to call for each Netlink message received.
 247  * @param[in, out] arg
 248  *   Custom arguments for the callback.
 249  *
 250  * @return
 251  *   0 on success, a negative errno value otherwise and rte_errno is set.
 252  */
 253 static int
 254 mlx5_nl_recv(int nlsk_fd, uint32_t sn, int (*cb)(struct nlmsghdr *, void *arg),
 255              void *arg)
 256 {
 257         struct sockaddr_nl sa;
 258         char buf[MLX5_RECV_BUF_SIZE];
 259         struct iovec iov = {
 260                 .iov_base = buf,
 261                 .iov_len = sizeof(buf),
 262         };
 263         struct msghdr msg = {
 264                 .msg_name = &sa,
 265                 .msg_namelen = sizeof(sa),
 266                 .msg_iov = &iov,
 267                 /* One message at a time */
 268                 .msg_iovlen = 1,
 269         };
 270         int multipart = 0;
 271         int ret = 0;
 272
 273         do {
 274                 struct nlmsghdr *nh;
 275                 int recv_bytes = 0;
 276
 277                 do {
 278                         recv_bytes = recvmsg(nlsk_fd, &msg, 0);
 279                         if (recv_bytes == -1) {
 280                                 rte_errno = errno;
 281                                 return -rte_errno;
 282                         }
 283                         nh = (struct nlmsghdr *)buf;
 284                 } while (nh->nlmsg_seq != sn);
 285                 for (;
 286                      NLMSG_OK(nh, (unsigned int)recv_bytes);
 287                      nh = NLMSG_NEXT(nh, recv_bytes)) {
 288                         if (nh->nlmsg_type == NLMSG_ERROR) {
 289                                 struct nlmsgerr *err_data = NLMSG_DATA(nh);
 290
 291                                 if (err_data->error < 0) {
 292                                         rte_errno = -err_data->error;
 293                                         return -rte_errno;
 294                                 }
 295                                 /* Ack message. */
 296                                 return 0;
 297                         }
 298                         /* Multi-part msgs and their trailing DONE message. */
 299                         if (nh->nlmsg_flags & NLM_F_MULTI) {
 300                                 if (nh->nlmsg_type == NLMSG_DONE)
 301                                         return 0;
 302                                 multipart = 1;
 303                         }
 304                         if (cb) {
 305                                 ret = cb(nh, arg);
 306                                 if (ret < 0)
 307                                         return ret;
 308                         }
 309                 }
 310         } while (multipart);
 311         return ret;
 312 }
 313
 314 /**
 315  * Parse Netlink message to retrieve the bridge MAC address.
 316  *
 317  * @param nh
 318  *   Pointer to Netlink Message Header.
 319  * @param arg
 320  *   PMD data register with this callback.
 321  *
 322  * @return
 323  *   0 on success, a negative errno value otherwise and rte_errno is set.
 324  */
 325 static int
 326 mlx5_nl_mac_addr_cb(struct nlmsghdr *nh, void *arg)
 327 {
 328         struct mlx5_nl_mac_addr *data = arg;
 329         struct ndmsg *r = NLMSG_DATA(nh);
 330         struct rtattr *attribute;
 331         int len;
 332
 333         len = nh->nlmsg_len - NLMSG_LENGTH(sizeof(*r));
 334         for (attribute = MLX5_NDA_RTA(r);
 335              RTA_OK(attribute, len);
 336              attribute = RTA_NEXT(attribute, len)) {
 337                 if (attribute->rta_type == NDA_LLADDR) {
 338                         if (data->mac_n == MLX5_MAX_MAC_ADDRESSES) {
 339                                 DRV_LOG(WARNING,
 340                                         "not enough room to finalize the"
 341                                         " request");
 342                                 rte_errno = ENOMEM;
 343                                 return -rte_errno;
 344                         }
 345 #ifndef NDEBUG
 346                         char m[18];
 347
 348                         rte_ether_format_addr(m, 18, RTA_DATA(attribute));
 349                         DRV_LOG(DEBUG, "bridge MAC address %s", m);
 350 #endif
 351                         memcpy(&(*data->mac)[data->mac_n++],
 352                                RTA_DATA(attribute), RTE_ETHER_ADDR_LEN);
 353                 }
 354         }
 355         return 0;
 356 }
 357
 358 /**
 359  * Get bridge MAC addresses.
 360  *
 361  * @param dev
 362  *   Pointer to Ethernet device.
 363  * @param mac[out]
 364  *   Pointer to the array table of MAC addresses to fill.
 365  *   Its size should be of MLX5_MAX_MAC_ADDRESSES.
 366  * @param mac_n[out]
 367  *   Number of entries filled in MAC array.
 368  *
 369  * @return
 370  *   0 on success, a negative errno value otherwise and rte_errno is set.
 371  */
 372 static int
 373 mlx5_nl_mac_addr_list(struct rte_eth_dev *dev, struct rte_ether_addr (*mac)[],
 374                       int *mac_n)
 375 {
 376         struct mlx5_priv *priv = dev->data->dev_private;
 377         unsigned int iface_idx = mlx5_ifindex(dev);
 378         struct {
 379                 struct nlmsghdr hdr;
 380                 struct ifinfomsg ifm;
 381         } req = {
 382                 .hdr = {
 383                         .nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg)),
 384                         .nlmsg_type = RTM_GETNEIGH,
 385                         .nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST,
 386                 },
 387                 .ifm = {
 388                         .ifi_family = PF_BRIDGE,
 389                         .ifi_index = iface_idx,
 390                 },
 391         };
 392         struct mlx5_nl_mac_addr data = {
 393                 .mac = mac,
 394                 .mac_n = 0,
 395         };
 396         int fd;
 397         int ret;
 398         uint32_t sn = priv->nl_sn++;
 399
 400         if (priv->nl_socket_route == -1)
 401                 return 0;
 402         fd = priv->nl_socket_route;
 403         ret = mlx5_nl_request(fd, &req.hdr, sn, &req.ifm,
 404                               sizeof(struct ifinfomsg));
 405         if (ret < 0)
 406                 goto error;
 407         ret = mlx5_nl_recv(fd, sn, mlx5_nl_mac_addr_cb, &data);
 408         if (ret < 0)
 409                 goto error;
 410         *mac_n = data.mac_n;
 411         return 0;
 412 error:
 413         DRV_LOG(DEBUG, "port %u cannot retrieve MAC address list %s",
 414                 dev->data->port_id, strerror(rte_errno));
 415         return -rte_errno;
 416 }
 417
 418 /**
 419  * Modify the MAC address neighbour table with Netlink.
 420  *
 421  * @param dev
 422  *   Pointer to Ethernet device.
 423  * @param mac
 424  *   MAC address to consider.
 425  * @param add
 426  *   1 to add the MAC address, 0 to remove the MAC address.
 427  *
 428  * @return
 429  *   0 on success, a negative errno value otherwise and rte_errno is set.
 430  */
 431 static int
 432 mlx5_nl_mac_addr_modify(struct rte_eth_dev *dev, struct rte_ether_addr *mac,
 433                         int add)
 434 {
 435         struct mlx5_priv *priv = dev->data->dev_private;
 436         unsigned int iface_idx = mlx5_ifindex(dev);
 437         struct {
 438                 struct nlmsghdr hdr;
 439                 struct ndmsg ndm;
 440                 struct rtattr rta;
 441                 uint8_t buffer[RTE_ETHER_ADDR_LEN];
 442         } req = {
 443                 .hdr = {
 444                         .nlmsg_len = NLMSG_LENGTH(sizeof(struct ndmsg)),
 445                         .nlmsg_flags = NLM_F_REQUEST | NLM_F_CREATE |
 446                                 NLM_F_EXCL | NLM_F_ACK,
 447                         .nlmsg_type = add ? RTM_NEWNEIGH : RTM_DELNEIGH,
 448                 },
 449                 .ndm = {
 450                         .ndm_family = PF_BRIDGE,
 451                         .ndm_state = NUD_NOARP | NUD_PERMANENT,
 452                         .ndm_ifindex = iface_idx,
 453                         .ndm_flags = NTF_SELF,
 454                 },
 455                 .rta = {
 456                         .rta_type = NDA_LLADDR,
 457                         .rta_len = RTA_LENGTH(RTE_ETHER_ADDR_LEN),
 458                 },
 459         };
 460         int fd;
 461         int ret;
 462         uint32_t sn = priv->nl_sn++;
 463
 464         if (priv->nl_socket_route == -1)
 465                 return 0;
 466         fd = priv->nl_socket_route;
 467         memcpy(RTA_DATA(&req.rta), mac, RTE_ETHER_ADDR_LEN);
 468         req.hdr.nlmsg_len = NLMSG_ALIGN(req.hdr.nlmsg_len) +
 469                 RTA_ALIGN(req.rta.rta_len);
 470         ret = mlx5_nl_send(fd, &req.hdr, sn);
 471         if (ret < 0)
 472                 goto error;
 473         ret = mlx5_nl_recv(fd, sn, NULL, NULL);
 474         if (ret < 0)
 475                 goto error;
 476         return 0;
 477 error:
 478         DRV_LOG(DEBUG,
 479                 "port %u cannot %s MAC address %02X:%02X:%02X:%02X:%02X:%02X"
 480                 " %s",
 481                 dev->data->port_id,
 482                 add ? "add" : "remove",
 483                 mac->addr_bytes[0], mac->addr_bytes[1],
 484                 mac->addr_bytes[2], mac->addr_bytes[3],
 485                 mac->addr_bytes[4], mac->addr_bytes[5],
 486                 strerror(rte_errno));
 487         return -rte_errno;
 488 }
 489
 490 /**
 491  * Add a MAC address.
 492  *
 493  * @param dev
 494  *   Pointer to Ethernet device.
 495  * @param mac
 496  *   MAC address to register.
 497  * @param index
 498  *   MAC address index.
 499  *
 500  * @return
 501  *   0 on success, a negative errno value otherwise and rte_errno is set.
 502  */
 503 int
 504 mlx5_nl_mac_addr_add(struct rte_eth_dev *dev, struct rte_ether_addr *mac,
 505                      uint32_t index)
 506 {
 507         struct mlx5_priv *priv = dev->data->dev_private;
 508         int ret;
 509
 510         ret = mlx5_nl_mac_addr_modify(dev, mac, 1);
 511         if (!ret)
 512                 BITFIELD_SET(priv->mac_own, index);
 513         if (ret == -EEXIST)
 514                 return 0;
 515         return ret;
 516 }
 517
 518 /**
 519  * Remove a MAC address.
 520  *
 521  * @param dev
 522  *   Pointer to Ethernet device.
 523  * @param mac
 524  *   MAC address to remove.
 525  * @param index
 526  *   MAC address index.
 527  *
 528  * @return
 529  *   0 on success, a negative errno value otherwise and rte_errno is set.
 530  */
 531 int
 532 mlx5_nl_mac_addr_remove(struct rte_eth_dev *dev, struct rte_ether_addr *mac,
 533                         uint32_t index)
 534 {
 535         struct mlx5_priv *priv = dev->data->dev_private;
 536
 537         BITFIELD_RESET(priv->mac_own, index);
 538         return mlx5_nl_mac_addr_modify(dev, mac, 0);
 539 }
 540
 541 /**
 542  * Synchronize Netlink bridge table to the internal table.
 543  *
 544  * @param dev
 545  *   Pointer to Ethernet device.
 546  */
 547 void
 548 mlx5_nl_mac_addr_sync(struct rte_eth_dev *dev)
 549 {
 550         struct rte_ether_addr macs[MLX5_MAX_MAC_ADDRESSES];
 551         int macs_n = 0;
 552         int i;
 553         int ret;
 554
 555         ret = mlx5_nl_mac_addr_list(dev, &macs, &macs_n);
 556         if (ret)
 557                 return;
 558         for (i = 0; i != macs_n; ++i) {
 559                 int j;
 560
 561                 /* Verify the address is not in the array yet. */
 562                 for (j = 0; j != MLX5_MAX_MAC_ADDRESSES; ++j)
 563                         if (rte_is_same_ether_addr(&macs[i],
 564                                                &dev->data->mac_addrs[j]))
 565                                 break;
 566                 if (j != MLX5_MAX_MAC_ADDRESSES)
 567                         continue;
 568                 /* Find the first entry available. */
 569                 for (j = 0; j != MLX5_MAX_MAC_ADDRESSES; ++j) {
 570                         if (rte_is_zero_ether_addr(&dev->data->mac_addrs[j])) {
 571                                 dev->data->mac_addrs[j] = macs[i];
 572                                 break;
 573                         }
 574                 }
 575         }
 576 }
 577
 578 /**
 579  * Flush all added MAC addresses.
 580  *
 581  * @param dev
 582  *   Pointer to Ethernet device.
 583  */
 584 void
 585 mlx5_nl_mac_addr_flush(struct rte_eth_dev *dev)
 586 {
 587         struct mlx5_priv *priv = dev->data->dev_private;
 588         int i;
 589
 590         for (i = MLX5_MAX_MAC_ADDRESSES - 1; i >= 0; --i) {
 591                 struct rte_ether_addr *m = &dev->data->mac_addrs[i];
 592
 593                 if (BITFIELD_ISSET(priv->mac_own, i))
 594                         mlx5_nl_mac_addr_remove(dev, m, i);
 595         }
 596 }
 597
 598 /**
 599  * Enable promiscuous / all multicast mode through Netlink.
 600  *
 601  * @param dev
 602  *   Pointer to Ethernet device structure.
 603  * @param flags
 604  *   IFF_PROMISC for promiscuous, IFF_ALLMULTI for allmulti.
 605  * @param enable
 606  *   Nonzero to enable, disable otherwise.
 607  *
 608  * @return
 609  *   0 on success, a negative errno value otherwise and rte_errno is set.
 610  */
 611 static int
 612 mlx5_nl_device_flags(struct rte_eth_dev *dev, uint32_t flags, int enable)
 613 {
 614         struct mlx5_priv *priv = dev->data->dev_private;
 615         unsigned int iface_idx = mlx5_ifindex(dev);
 616         struct {
 617                 struct nlmsghdr hdr;
 618                 struct ifinfomsg ifi;
 619         } req = {
 620                 .hdr = {
 621                         .nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg)),
 622                         .nlmsg_type = RTM_NEWLINK,
 623                         .nlmsg_flags = NLM_F_REQUEST,
 624                 },
 625                 .ifi = {
 626                         .ifi_flags = enable ? flags : 0,
 627                         .ifi_change = flags,
 628                         .ifi_index = iface_idx,
 629                 },
 630         };
 631         int fd;
 632         int ret;
 633
 634         assert(!(flags & ~(IFF_PROMISC | IFF_ALLMULTI)));
 635         if (priv->nl_socket_route < 0)
 636                 return 0;
 637         fd = priv->nl_socket_route;
 638         ret = mlx5_nl_send(fd, &req.hdr, priv->nl_sn++);
 639         if (ret < 0)
 640                 return ret;
 641         return 0;
 642 }
 643
 644 /**
 645  * Enable promiscuous mode through Netlink.
 646  *
 647  * @param dev
 648  *   Pointer to Ethernet device structure.
 649  * @param enable
 650  *   Nonzero to enable, disable otherwise.
 651  *
 652  * @return
 653  *   0 on success, a negative errno value otherwise and rte_errno is set.
 654  */
 655 int
 656 mlx5_nl_promisc(struct rte_eth_dev *dev, int enable)
 657 {
 658         int ret = mlx5_nl_device_flags(dev, IFF_PROMISC, enable);
 659
 660         if (ret)
 661                 DRV_LOG(DEBUG,
 662                         "port %u cannot %s promisc mode: Netlink error %s",
 663                         dev->data->port_id, enable ? "enable" : "disable",
 664                         strerror(rte_errno));
 665         return ret;
 666 }
 667
 668 /**
 669  * Enable all multicast mode through Netlink.
 670  *
 671  * @param dev
 672  *   Pointer to Ethernet device structure.
 673  * @param enable
 674  *   Nonzero to enable, disable otherwise.
 675  *
 676  * @return
 677  *   0 on success, a negative errno value otherwise and rte_errno is set.
 678  */
 679 int
 680 mlx5_nl_allmulti(struct rte_eth_dev *dev, int enable)
 681 {
 682         int ret = mlx5_nl_device_flags(dev, IFF_ALLMULTI, enable);
 683
 684         if (ret)
 685                 DRV_LOG(DEBUG,
 686                         "port %u cannot %s allmulti mode: Netlink error %s",
 687                         dev->data->port_id, enable ? "enable" : "disable",
 688                         strerror(rte_errno));
 689         return ret;
 690 }
 691
 692 /**
 693  * Process network interface information from Netlink message.
 694  *
 695  * @param nh
 696  *   Pointer to Netlink message header.
 697  * @param arg
 698  *   Opaque data pointer for this callback.
 699  *
 700  * @return
 701  *   0 on success, a negative errno value otherwise and rte_errno is set.
 702  */
 703 static int
 704 mlx5_nl_cmdget_cb(struct nlmsghdr *nh, void *arg)
 705 {
 706         struct mlx5_nl_ifindex_data *data = arg;
 707         size_t off = NLMSG_HDRLEN;
 708         uint32_t ibindex = 0;
 709         uint32_t ifindex = 0;
 710         uint32_t portnum = 0;
 711         int found = 0;
 712
 713         if (nh->nlmsg_type !=
 714             RDMA_NL_GET_TYPE(RDMA_NL_NLDEV, RDMA_NLDEV_CMD_GET) &&
 715             nh->nlmsg_type !=
 716             RDMA_NL_GET_TYPE(RDMA_NL_NLDEV, RDMA_NLDEV_CMD_PORT_GET))
 717                 goto error;
 718         while (off < nh->nlmsg_len) {
 719                 struct nlattr *na = (void *)((uintptr_t)nh + off);
 720                 void *payload = (void *)((uintptr_t)na + NLA_HDRLEN);
 721
 722                 if (na->nla_len > nh->nlmsg_len - off)
 723                         goto error;
 724                 switch (na->nla_type) {
 725                 case RDMA_NLDEV_ATTR_DEV_INDEX:
 726                         ibindex = *(uint32_t *)payload;
 727                         break;
 728                 case RDMA_NLDEV_ATTR_DEV_NAME:
 729                         if (!strcmp(payload, data->name))
 730                                 found = 1;
 731                         break;
 732                 case RDMA_NLDEV_ATTR_NDEV_INDEX:
 733                         ifindex = *(uint32_t *)payload;
 734                         break;
 735                 case RDMA_NLDEV_ATTR_PORT_INDEX:
 736                         portnum = *(uint32_t *)payload;
 737                         break;
 738                 default:
 739                         break;
 740                 }
 741                 off += NLA_ALIGN(na->nla_len);
 742         }
 743         if (found) {
 744                 data->ibindex = ibindex;
 745                 data->ifindex = ifindex;
 746                 data->portnum = portnum;
 747         }
 748         return 0;
 749 error:
 750         rte_errno = EINVAL;
 751         return -rte_errno;
 752 }
 753
 754 /**
 755  * Get index of network interface associated with some IB device.
 756  *
 757  * This is the only somewhat safe method to avoid resorting to heuristics
 758  * when faced with port representors. Unfortunately it requires at least
 759  * Linux 4.17.
 760  *
 761  * @param nl
 762  *   Netlink socket of the RDMA kind (NETLINK_RDMA).
 763  * @param[in] name
 764  *   IB device name.
 765  * @param[in] pindex
 766  *   IB device port index, starting from 1
 767  * @return
 768  *   A valid (nonzero) interface index on success, 0 otherwise and rte_errno
 769  *   is set.
 770  */
 771 unsigned int
 772 mlx5_nl_ifindex(int nl, const char *name, uint32_t pindex)
 773 {
 774         uint32_t seq = random();
 775         struct mlx5_nl_ifindex_data data = {
 776                 .name = name,
 777                 .ibindex = 0, /* Determined during first pass. */
 778                 .ifindex = 0, /* Determined during second pass. */
 779         };
 780         union {
 781                 struct nlmsghdr nh;
 782                 uint8_t buf[NLMSG_HDRLEN +
 783                             NLA_HDRLEN + NLA_ALIGN(sizeof(data.ibindex)) +
 784                             NLA_HDRLEN + NLA_ALIGN(sizeof(pindex))];
 785         } req = {
 786                 .nh = {
 787                         .nlmsg_len = NLMSG_LENGTH(0),
 788                         .nlmsg_type = RDMA_NL_GET_TYPE(RDMA_NL_NLDEV,
 789                                                        RDMA_NLDEV_CMD_GET),
 790                         .nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | NLM_F_DUMP,
 791                 },
 792         };
 793         struct nlattr *na;
 794         int ret;
 795
 796         ret = mlx5_nl_send(nl, &req.nh, seq);
 797         if (ret < 0)
 798                 return 0;
 799         ret = mlx5_nl_recv(nl, seq, mlx5_nl_cmdget_cb, &data);
 800         if (ret < 0)
 801                 return 0;
 802         if (!data.ibindex)
 803                 goto error;
 804         ++seq;
 805         req.nh.nlmsg_type = RDMA_NL_GET_TYPE(RDMA_NL_NLDEV,
 806                                              RDMA_NLDEV_CMD_PORT_GET);
 807         req.nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
 808         req.nh.nlmsg_len = NLMSG_LENGTH(sizeof(req.buf) - NLMSG_HDRLEN);
 809         na = (void *)((uintptr_t)req.buf + NLMSG_HDRLEN);
 810         na->nla_len = NLA_HDRLEN + sizeof(data.ibindex);
 811         na->nla_type = RDMA_NLDEV_ATTR_DEV_INDEX;
 812         memcpy((void *)((uintptr_t)na + NLA_HDRLEN),
 813                &data.ibindex, sizeof(data.ibindex));
 814         na = (void *)((uintptr_t)na + NLA_ALIGN(na->nla_len));
 815         na->nla_len = NLA_HDRLEN + sizeof(pindex);
 816         na->nla_type = RDMA_NLDEV_ATTR_PORT_INDEX;
 817         memcpy((void *)((uintptr_t)na + NLA_HDRLEN),
 818                &pindex, sizeof(pindex));
 819         ret = mlx5_nl_send(nl, &req.nh, seq);
 820         if (ret < 0)
 821                 return 0;
 822         ret = mlx5_nl_recv(nl, seq, mlx5_nl_cmdget_cb, &data);
 823         if (ret < 0)
 824                 return 0;
 825         if (!data.ifindex)
 826                 goto error;
 827         return data.ifindex;
 828 error:
 829         rte_errno = ENODEV;
 830         return 0;
 831 }
 832
 833 /**
 834  * Get the number of physical ports of given IB device.
 835  *
 836  * @param nl
 837  *   Netlink socket of the RDMA kind (NETLINK_RDMA).
 838  * @param[in] name
 839  *   IB device name.
 840  *
 841  * @return
 842  *   A valid (nonzero) number of ports on success, 0 otherwise
 843  *   and rte_errno is set.
 844  */
 845 unsigned int
 846 mlx5_nl_portnum(int nl, const char *name)
 847 {
 848         uint32_t seq = random();
 849         struct mlx5_nl_ifindex_data data = {
 850                 .name = name,
 851                 .ibindex = 0,
 852                 .ifindex = 0,
 853                 .portnum = 0,
 854         };
 855         struct nlmsghdr req = {
 856                 .nlmsg_len = NLMSG_LENGTH(0),
 857                 .nlmsg_type = RDMA_NL_GET_TYPE(RDMA_NL_NLDEV,
 858                                                RDMA_NLDEV_CMD_GET),
 859                 .nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | NLM_F_DUMP,
 860         };
 861         int ret;
 862
 863         ret = mlx5_nl_send(nl, &req, seq);
 864         if (ret < 0)
 865                 return 0;
 866         ret = mlx5_nl_recv(nl, seq, mlx5_nl_cmdget_cb, &data);
 867         if (ret < 0)
 868                 return 0;
 869         if (!data.ibindex) {
 870                 rte_errno = ENODEV;
 871                 return 0;
 872         }
 873         if (!data.portnum)
 874                 rte_errno = EINVAL;
 875         return data.portnum;
 876 }
 877
 878 /**
 879  * Process switch information from Netlink message.
 880  *
 881  * @param nh
 882  *   Pointer to Netlink message header.
 883  * @param arg
 884  *   Opaque data pointer for this callback.
 885  *
 886  * @return
 887  *   0 on success, a negative errno value otherwise and rte_errno is set.
 888  */
 889 static int
 890 mlx5_nl_switch_info_cb(struct nlmsghdr *nh, void *arg)
 891 {
 892         struct mlx5_switch_info info = {
 893                 .master = 0,
 894                 .representor = 0,
 895                 .name_type = MLX5_PHYS_PORT_NAME_TYPE_NOTSET,
 896                 .port_name = 0,
 897                 .switch_id = 0,
 898         };
 899         size_t off = NLMSG_LENGTH(sizeof(struct ifinfomsg));
 900         bool switch_id_set = false;
 901         bool num_vf_set = false;
 902
 903         if (nh->nlmsg_type != RTM_NEWLINK)
 904                 goto error;
 905         while (off < nh->nlmsg_len) {
 906                 struct rtattr *ra = (void *)((uintptr_t)nh + off);
 907                 void *payload = RTA_DATA(ra);
 908                 unsigned int i;
 909
 910                 if (ra->rta_len > nh->nlmsg_len - off)
 911                         goto error;
 912                 switch (ra->rta_type) {
 913                 case IFLA_NUM_VF:
 914                         num_vf_set = true;
 915                         break;
 916                 case IFLA_PHYS_PORT_NAME:
 917                         mlx5_translate_port_name((char *)payload, &info);
 918                         break;
 919                 case IFLA_PHYS_SWITCH_ID:
 920                         info.switch_id = 0;
 921                         for (i = 0; i < RTA_PAYLOAD(ra); ++i) {
 922                                 info.switch_id <<= 8;
 923                                 info.switch_id |= ((uint8_t *)payload)[i];
 924                         }
 925                         switch_id_set = true;
 926                         break;
 927                 }
 928                 off += RTA_ALIGN(ra->rta_len);
 929         }
 930         if (switch_id_set) {
 931                 /* We have some E-Switch configuration. */
 932                 mlx5_nl_check_switch_info(num_vf_set, &info);
 933         }
 934         assert(!(info.master && info.representor));
 935         memcpy(arg, &info, sizeof(info));
 936         return 0;
 937 error:
 938         rte_errno = EINVAL;
 939         return -rte_errno;
 940 }
 941
 942 /**
 943  * Get switch information associated with network interface.
 944  *
 945  * @param nl
 946  *   Netlink socket of the ROUTE kind (NETLINK_ROUTE).
 947  * @param ifindex
 948  *   Network interface index.
 949  * @param[out] info
 950  *   Switch information object, populated in case of success.
 951  *
 952  * @return
 953  *   0 on success, a negative errno value otherwise and rte_errno is set.
 954  */
 955 int
 956 mlx5_nl_switch_info(int nl, unsigned int ifindex, struct mlx5_switch_info *info)
 957 {
 958         uint32_t seq = random();
 959         struct {
 960                 struct nlmsghdr nh;
 961                 struct ifinfomsg info;
 962                 struct rtattr rta;
 963                 uint32_t extmask;
 964         } req = {
 965                 .nh = {
 966                         .nlmsg_len = NLMSG_LENGTH
 967                                         (sizeof(req.info) +
 968                                          RTA_LENGTH(sizeof(uint32_t))),
 969                         .nlmsg_type = RTM_GETLINK,
 970                         .nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK,
 971                 },
 972                 .info = {
 973                         .ifi_family = AF_UNSPEC,
 974                         .ifi_index = ifindex,
 975                 },
 976                 .rta = {
 977                         .rta_type = IFLA_EXT_MASK,
 978                         .rta_len = RTA_LENGTH(sizeof(int32_t)),
 979                 },
 980                 .extmask = RTE_LE32(1),
 981         };
 982         int ret;
 983
 984         ret = mlx5_nl_send(nl, &req.nh, seq);
 985         if (ret >= 0)
 986                 ret = mlx5_nl_recv(nl, seq, mlx5_nl_switch_info_cb, info);
 987         if (info->master && info->representor) {
 988                 DRV_LOG(ERR, "ifindex %u device is recognized as master"
 989                              " and as representor", ifindex);
 990                 rte_errno = ENODEV;
 991                 ret = -rte_errno;
 992         }
 993         return ret;
 994 }
 995
 996 /*
 997  * Delete VLAN network device by ifindex.
 998  *
 999  * @param[in] tcf
1000  *   Context object initialized by mlx5_vlan_vmwa_init().
1001  * @param[in] ifindex
1002  *   Interface index of network device to delete.
1003  */
1004 static void
1005 mlx5_vlan_vmwa_delete(struct mlx5_vlan_vmwa_context *vmwa,
1006                       uint32_t ifindex)
1007 {
1008         int ret;
1009         struct {
1010                 struct nlmsghdr nh;
1011                 struct ifinfomsg info;
1012         } req = {
1013                 .nh = {
1014                         .nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg)),
1015                         .nlmsg_type = RTM_DELLINK,
1016                         .nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK,
1017                 },
1018                 .info = {
1019                         .ifi_family = AF_UNSPEC,
1020                         .ifi_index = ifindex,
1021                 },
1022         };
1023
1024         if (ifindex) {
1025                 ++vmwa->nl_sn;
1026                 if (!vmwa->nl_sn)
1027                         ++vmwa->nl_sn;
1028                 ret = mlx5_nl_send(vmwa->nl_socket, &req.nh, vmwa->nl_sn);
1029                 if (ret >= 0)
1030                         ret = mlx5_nl_recv(vmwa->nl_socket,
1031                                            vmwa->nl_sn,
1032                                            NULL, NULL);
1033                 if (ret < 0)
1034                         DRV_LOG(WARNING, "netlink: error deleting"
1035                                          " VLAN WA ifindex %u, %d",
1036                                          ifindex, ret);
1037         }
1038 }
1039
1040 /* Set of subroutines to build Netlink message. */
1041 static struct nlattr *
1042 nl_msg_tail(struct nlmsghdr *nlh)
1043 {
1044         return (struct nlattr *)
1045                 (((uint8_t *)nlh) + NLMSG_ALIGN(nlh->nlmsg_len));
1046 }
1047
1048 static void
1049 nl_attr_put(struct nlmsghdr *nlh, int type, const void *data, int alen)
1050 {
1051         struct nlattr *nla = nl_msg_tail(nlh);
1052
1053         nla->nla_type = type;
1054         nla->nla_len = NLMSG_ALIGN(sizeof(struct nlattr) + alen);
1055         nlh->nlmsg_len = NLMSG_ALIGN(nlh->nlmsg_len) + nla->nla_len;
1056
1057         if (alen)
1058                 memcpy((uint8_t *)nla + sizeof(struct nlattr), data, alen);
1059 }
1060
1061 static struct nlattr *
1062 nl_attr_nest_start(struct nlmsghdr *nlh, int type)
1063 {
1064         struct nlattr *nest = (struct nlattr *)nl_msg_tail(nlh);
1065
1066         nl_attr_put(nlh, type, NULL, 0);
1067         return nest;
1068 }
1069
1070 static void
1071 nl_attr_nest_end(struct nlmsghdr *nlh, struct nlattr *nest)
1072 {
1073         nest->nla_len = (uint8_t *)nl_msg_tail(nlh) - (uint8_t *)nest;
1074 }
1075
1076 /*
1077  * Create network VLAN device with specified VLAN tag.
1078  *
1079  * @param[in] tcf
1080  *   Context object initialized by mlx5_vlan_vmwa_init().
1081  * @param[in] ifindex
1082  *   Base network interface index.
1083  * @param[in] tag
1084  *   VLAN tag for VLAN network device to create.
1085  */
1086 static uint32_t
1087 mlx5_vlan_vmwa_create(struct mlx5_vlan_vmwa_context *vmwa,
1088                       uint32_t ifindex,
1089                       uint16_t tag)
1090 {
1091         struct nlmsghdr *nlh;
1092         struct ifinfomsg *ifm;
1093         char name[sizeof(MLX5_VMWA_VLAN_DEVICE_PFX) + 32];
1094
1095         alignas(RTE_CACHE_LINE_SIZE)
1096         uint8_t buf[NLMSG_ALIGN(sizeof(struct nlmsghdr)) +
1097                     NLMSG_ALIGN(sizeof(struct ifinfomsg)) +
1098                     NLMSG_ALIGN(sizeof(struct nlattr)) * 8 +
1099                     NLMSG_ALIGN(sizeof(uint32_t)) +
1100                     NLMSG_ALIGN(sizeof(name)) +
1101                     NLMSG_ALIGN(sizeof("vlan")) +
1102                     NLMSG_ALIGN(sizeof(uint32_t)) +
1103                     NLMSG_ALIGN(sizeof(uint16_t)) + 16];
1104         struct nlattr *na_info;
1105         struct nlattr *na_vlan;
1106         int ret;
1107
1108         memset(buf, 0, sizeof(buf));
1109         ++vmwa->nl_sn;
1110         if (!vmwa->nl_sn)
1111                 ++vmwa->nl_sn;
1112         nlh = (struct nlmsghdr *)buf;
1113         nlh->nlmsg_len = sizeof(struct nlmsghdr);
1114         nlh->nlmsg_type = RTM_NEWLINK;
1115         nlh->nlmsg_flags = NLM_F_REQUEST | NLM_F_CREATE |
1116                            NLM_F_EXCL | NLM_F_ACK;
1117         ifm = (struct ifinfomsg *)nl_msg_tail(nlh);
1118         nlh->nlmsg_len += sizeof(struct ifinfomsg);
1119         ifm->ifi_family = AF_UNSPEC;
1120         ifm->ifi_type = 0;
1121         ifm->ifi_index = 0;
1122         ifm->ifi_flags = IFF_UP;
1123         ifm->ifi_change = 0xffffffff;
1124         nl_attr_put(nlh, IFLA_LINK, &ifindex, sizeof(ifindex));
1125         ret = snprintf(name, sizeof(name), "%s.%u.%u",
1126                        MLX5_VMWA_VLAN_DEVICE_PFX, ifindex, tag);
1127         nl_attr_put(nlh, IFLA_IFNAME, name, ret + 1);
1128         na_info = nl_attr_nest_start(nlh, IFLA_LINKINFO);
1129         nl_attr_put(nlh, IFLA_INFO_KIND, "vlan", sizeof("vlan"));
1130         na_vlan = nl_attr_nest_start(nlh, IFLA_INFO_DATA);
1131         nl_attr_put(nlh, IFLA_VLAN_ID, &tag, sizeof(tag));
1132         nl_attr_nest_end(nlh, na_vlan);
1133         nl_attr_nest_end(nlh, na_info);
1134         assert(sizeof(buf) >= nlh->nlmsg_len);
1135         ret = mlx5_nl_send(vmwa->nl_socket, nlh, vmwa->nl_sn);
1136         if (ret >= 0)
1137                 ret = mlx5_nl_recv(vmwa->nl_socket, vmwa->nl_sn, NULL, NULL);
1138         if (ret < 0) {
1139                 DRV_LOG(WARNING,
1140                         "netlink: VLAN %s create failure (%d)",
1141                         name, ret);
1142         }
1143         // Try to get ifindex of created or pre-existing device.
1144         ret = if_nametoindex(name);
1145         if (!ret) {
1146                 DRV_LOG(WARNING,
1147                         "VLAN %s failed to get index (%d)",
1148                         name, errno);
1149                 return 0;
1150         }
1151         return ret;
1152 }
1153
1154 /*
1155  * Release VLAN network device, created for VM workaround.
1156  *
1157  * @param[in] dev
1158  *   Ethernet device object, Netlink context provider.
1159  * @param[in] vlan
1160  *   Object representing the network device to release.
1161  */
1162 void mlx5_vlan_vmwa_release(struct rte_eth_dev *dev,
1163                             struct mlx5_vf_vlan *vlan)
1164 {
1165         struct mlx5_priv *priv = dev->data->dev_private;
1166         struct mlx5_vlan_vmwa_context *vmwa = priv->vmwa_context;
1167         struct mlx5_vlan_dev *vlan_dev = &vmwa->vlan_dev[0];
1168
1169         assert(vlan->created);
1170         assert(priv->vmwa_context);
1171         if (!vlan->created || !vmwa)
1172                 return;
1173         vlan->created = 0;
1174         assert(vlan_dev[vlan->tag].refcnt);
1175         if (--vlan_dev[vlan->tag].refcnt == 0 &&
1176             vlan_dev[vlan->tag].ifindex) {
1177                 mlx5_vlan_vmwa_delete(vmwa, vlan_dev[vlan->tag].ifindex);
1178                 vlan_dev[vlan->tag].ifindex = 0;
1179         }
1180 }
1181
1182 /**
1183  * Acquire VLAN interface with specified tag for VM workaround.
1184  *
1185  * @param[in] dev
1186  *   Ethernet device object, Netlink context provider.
1187  * @param[in] vlan
1188  *   Object representing the network device to acquire.
1189  */
1190 void mlx5_vlan_vmwa_acquire(struct rte_eth_dev *dev,
1191                             struct mlx5_vf_vlan *vlan)
1192 {
1193         struct mlx5_priv *priv = dev->data->dev_private;
1194         struct mlx5_vlan_vmwa_context *vmwa = priv->vmwa_context;
1195         struct mlx5_vlan_dev *vlan_dev = &vmwa->vlan_dev[0];
1196
1197         assert(!vlan->created);
1198         assert(priv->vmwa_context);
1199         if (vlan->created || !vmwa)
1200                 return;
1201         if (vlan_dev[vlan->tag].refcnt == 0) {
1202                 assert(!vlan_dev[vlan->tag].ifindex);
1203                 vlan_dev[vlan->tag].ifindex =
1204                         mlx5_vlan_vmwa_create(vmwa,
1205                                               vmwa->vf_ifindex,
1206                                               vlan->tag);
1207         }
1208         if (vlan_dev[vlan->tag].ifindex) {
1209                 vlan_dev[vlan->tag].refcnt++;
1210                 vlan->created = 1;
1211         }
1212 }
1213
1214 /*
1215  * Create per ethernet device VLAN VM workaround context
1216  */
1217 struct mlx5_vlan_vmwa_context *
1218 mlx5_vlan_vmwa_init(struct rte_eth_dev *dev,
1219                     uint32_t ifindex)
1220 {
1221         struct mlx5_priv *priv = dev->data->dev_private;
1222         struct mlx5_dev_config *config = &priv->config;
1223         struct mlx5_vlan_vmwa_context *vmwa;
1224         enum rte_hypervisor hv_type;
1225
1226         /* Do not engage workaround over PF. */
1227         if (!config->vf)
1228                 return NULL;
1229         /* Check whether there is desired virtual environment */
1230         hv_type = rte_hypervisor_get();
1231         switch (hv_type) {
1232         case RTE_HYPERVISOR_UNKNOWN:
1233         case RTE_HYPERVISOR_VMWARE:
1234                 /*
1235                  * The "white list" of configurations
1236                  * to engage the workaround.
1237                  */
1238                 break;
1239         default:
1240                 /*
1241                  * The configuration is not found in the "white list".
1242                  * We should not engage the VLAN workaround.
1243                  */
1244                 return NULL;
1245         }
1246         vmwa = rte_zmalloc(__func__, sizeof(*vmwa), sizeof(uint32_t));
1247         if (!vmwa) {
1248                 DRV_LOG(WARNING,
1249                         "Can not allocate memory"
1250                         " for VLAN workaround context");
1251                 return NULL;
1252         }
1253         vmwa->nl_socket = mlx5_nl_init(NETLINK_ROUTE);
1254         if (vmwa->nl_socket < 0) {
1255                 DRV_LOG(WARNING,
1256                         "Can not create Netlink socket"
1257                         " for VLAN workaround context");
1258                 rte_free(vmwa);
1259                 return NULL;
1260         }
1261         vmwa->nl_sn = random();
1262         vmwa->vf_ifindex = ifindex;
1263         vmwa->dev = dev;
1264         /* Cleanup for existing VLAN devices. */
1265         return vmwa;
1266 }
1267
1268 /*
1269  * Destroy per ethernet device VLAN VM workaround context
1270  */
1271 void mlx5_vlan_vmwa_exit(struct mlx5_vlan_vmwa_context *vmwa)
1272 {
1273         unsigned int i;
1274
1275         /* Delete all remaining VLAN devices. */
1276         for (i = 0; i < RTE_DIM(vmwa->vlan_dev); i++) {
1277                 if (vmwa->vlan_dev[i].ifindex)
1278                         mlx5_vlan_vmwa_delete(vmwa, vmwa->vlan_dev[i].ifindex);
1279         }
1280         if (vmwa->nl_socket >= 0)
1281                 close(vmwa->nl_socket);
1282         rte_free(vmwa);
1283 }