net/mlx5: modify get ifindex routine for multiport IB
[dpdk.git] / 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 <string.h>
16 #include <sys/socket.h>
17 #include <unistd.h>
18
19 #include <rte_errno.h>
20
21 #include "mlx5.h"
22 #include "mlx5_utils.h"
23
24 /* Size of the buffer to receive kernel messages */
25 #define MLX5_NL_BUF_SIZE (32 * 1024)
26 /* Send buffer size for the Netlink socket */
27 #define MLX5_SEND_BUF_SIZE 32768
28 /* Receive buffer size for the Netlink socket */
29 #define MLX5_RECV_BUF_SIZE 32768
30
31 /*
32  * Define NDA_RTA as defined in iproute2 sources.
33  *
34  * see in iproute2 sources file include/libnetlink.h
35  */
36 #ifndef MLX5_NDA_RTA
37 #define MLX5_NDA_RTA(r) \
38         ((struct rtattr *)(((char *)(r)) + NLMSG_ALIGN(sizeof(struct ndmsg))))
39 #endif
40
41 /*
42  * The following definitions are normally found in rdma/rdma_netlink.h,
43  * however they are so recent that most systems do not expose them yet.
44  */
45 #ifndef HAVE_RDMA_NL_NLDEV
46 #define RDMA_NL_NLDEV 5
47 #endif
48 #ifndef HAVE_RDMA_NLDEV_CMD_GET
49 #define RDMA_NLDEV_CMD_GET 1
50 #endif
51 #ifndef HAVE_RDMA_NLDEV_CMD_PORT_GET
52 #define RDMA_NLDEV_CMD_PORT_GET 5
53 #endif
54 #ifndef HAVE_RDMA_NLDEV_ATTR_DEV_INDEX
55 #define RDMA_NLDEV_ATTR_DEV_INDEX 1
56 #endif
57 #ifndef HAVE_RDMA_NLDEV_ATTR_DEV_NAME
58 #define RDMA_NLDEV_ATTR_DEV_NAME 2
59 #endif
60 #ifndef HAVE_RDMA_NLDEV_ATTR_PORT_INDEX
61 #define RDMA_NLDEV_ATTR_PORT_INDEX 3
62 #endif
63 #ifndef HAVE_RDMA_NLDEV_ATTR_NDEV_INDEX
64 #define RDMA_NLDEV_ATTR_NDEV_INDEX 50
65 #endif
66
67 /* These are normally found in linux/if_link.h. */
68 #ifndef HAVE_IFLA_NUM_VF
69 #define IFLA_NUM_VF 21
70 #endif
71 #ifndef HAVE_IFLA_EXT_MASK
72 #define IFLA_EXT_MASK 29
73 #endif
74 #ifndef HAVE_IFLA_PHYS_SWITCH_ID
75 #define IFLA_PHYS_SWITCH_ID 36
76 #endif
77 #ifndef HAVE_IFLA_PHYS_PORT_NAME
78 #define IFLA_PHYS_PORT_NAME 38
79 #endif
80
81 /* Add/remove MAC address through Netlink */
82 struct mlx5_nl_mac_addr {
83         struct ether_addr (*mac)[];
84         /**< MAC address handled by the device. */
85         int mac_n; /**< Number of addresses in the array. */
86 };
87
88 /** Data structure used by mlx5_nl_cmdget_cb(). */
89 struct mlx5_nl_ifindex_data {
90         const char *name; /**< IB device name (in). */
91         uint32_t ibindex; /**< IB device index (out). */
92         uint32_t ifindex; /**< Network interface index (out). */
93         uint32_t portnum; /**< IB device max port number. */
94 };
95
96 /**
97  * Opens a Netlink socket.
98  *
99  * @param protocol
100  *   Netlink protocol (e.g. NETLINK_ROUTE, NETLINK_RDMA).
101  *
102  * @return
103  *   A file descriptor on success, a negative errno value otherwise and
104  *   rte_errno is set.
105  */
106 int
107 mlx5_nl_init(int protocol)
108 {
109         int fd;
110         int sndbuf_size = MLX5_SEND_BUF_SIZE;
111         int rcvbuf_size = MLX5_RECV_BUF_SIZE;
112         struct sockaddr_nl local = {
113                 .nl_family = AF_NETLINK,
114         };
115         int ret;
116
117         fd = socket(AF_NETLINK, SOCK_RAW | SOCK_CLOEXEC, protocol);
118         if (fd == -1) {
119                 rte_errno = errno;
120                 return -rte_errno;
121         }
122         ret = setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &sndbuf_size, sizeof(int));
123         if (ret == -1) {
124                 rte_errno = errno;
125                 goto error;
126         }
127         ret = setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &rcvbuf_size, sizeof(int));
128         if (ret == -1) {
129                 rte_errno = errno;
130                 goto error;
131         }
132         ret = bind(fd, (struct sockaddr *)&local, sizeof(local));
133         if (ret == -1) {
134                 rte_errno = errno;
135                 goto error;
136         }
137         return fd;
138 error:
139         close(fd);
140         return -rte_errno;
141 }
142
143 /**
144  * Send a request message to the kernel on the Netlink socket.
145  *
146  * @param[in] nlsk_fd
147  *   Netlink socket file descriptor.
148  * @param[in] nh
149  *   The Netlink message send to the kernel.
150  * @param[in] ssn
151  *   Sequence number.
152  * @param[in] req
153  *   Pointer to the request structure.
154  * @param[in] len
155  *   Length of the request in bytes.
156  *
157  * @return
158  *   The number of sent bytes on success, a negative errno value otherwise and
159  *   rte_errno is set.
160  */
161 static int
162 mlx5_nl_request(int nlsk_fd, struct nlmsghdr *nh, uint32_t sn, void *req,
163                 int len)
164 {
165         struct sockaddr_nl sa = {
166                 .nl_family = AF_NETLINK,
167         };
168         struct iovec iov[2] = {
169                 { .iov_base = nh, .iov_len = sizeof(*nh), },
170                 { .iov_base = req, .iov_len = len, },
171         };
172         struct msghdr msg = {
173                 .msg_name = &sa,
174                 .msg_namelen = sizeof(sa),
175                 .msg_iov = iov,
176                 .msg_iovlen = 2,
177         };
178         int send_bytes;
179
180         nh->nlmsg_pid = 0; /* communication with the kernel uses pid 0 */
181         nh->nlmsg_seq = sn;
182         send_bytes = sendmsg(nlsk_fd, &msg, 0);
183         if (send_bytes < 0) {
184                 rte_errno = errno;
185                 return -rte_errno;
186         }
187         return send_bytes;
188 }
189
190 /**
191  * Send a message to the kernel on the Netlink socket.
192  *
193  * @param[in] nlsk_fd
194  *   The Netlink socket file descriptor used for communication.
195  * @param[in] nh
196  *   The Netlink message send to the kernel.
197  * @param[in] sn
198  *   Sequence number.
199  *
200  * @return
201  *   The number of sent bytes on success, a negative errno value otherwise and
202  *   rte_errno is set.
203  */
204 static int
205 mlx5_nl_send(int nlsk_fd, struct nlmsghdr *nh, uint32_t sn)
206 {
207         struct sockaddr_nl sa = {
208                 .nl_family = AF_NETLINK,
209         };
210         struct iovec iov = {
211                 .iov_base = nh,
212                 .iov_len = nh->nlmsg_len,
213         };
214         struct msghdr msg = {
215                 .msg_name = &sa,
216                 .msg_namelen = sizeof(sa),
217                 .msg_iov = &iov,
218                 .msg_iovlen = 1,
219         };
220         int send_bytes;
221
222         nh->nlmsg_pid = 0; /* communication with the kernel uses pid 0 */
223         nh->nlmsg_seq = sn;
224         send_bytes = sendmsg(nlsk_fd, &msg, 0);
225         if (send_bytes < 0) {
226                 rte_errno = errno;
227                 return -rte_errno;
228         }
229         return send_bytes;
230 }
231
232 /**
233  * Receive a message from the kernel on the Netlink socket, following
234  * mlx5_nl_send().
235  *
236  * @param[in] nlsk_fd
237  *   The Netlink socket file descriptor used for communication.
238  * @param[in] sn
239  *   Sequence number.
240  * @param[in] cb
241  *   The callback function to call for each Netlink message received.
242  * @param[in, out] arg
243  *   Custom arguments for the callback.
244  *
245  * @return
246  *   0 on success, a negative errno value otherwise and rte_errno is set.
247  */
248 static int
249 mlx5_nl_recv(int nlsk_fd, uint32_t sn, int (*cb)(struct nlmsghdr *, void *arg),
250              void *arg)
251 {
252         struct sockaddr_nl sa;
253         char buf[MLX5_RECV_BUF_SIZE];
254         struct iovec iov = {
255                 .iov_base = buf,
256                 .iov_len = sizeof(buf),
257         };
258         struct msghdr msg = {
259                 .msg_name = &sa,
260                 .msg_namelen = sizeof(sa),
261                 .msg_iov = &iov,
262                 /* One message at a time */
263                 .msg_iovlen = 1,
264         };
265         int multipart = 0;
266         int ret = 0;
267
268         do {
269                 struct nlmsghdr *nh;
270                 int recv_bytes = 0;
271
272                 do {
273                         recv_bytes = recvmsg(nlsk_fd, &msg, 0);
274                         if (recv_bytes == -1) {
275                                 rte_errno = errno;
276                                 return -rte_errno;
277                         }
278                         nh = (struct nlmsghdr *)buf;
279                 } while (nh->nlmsg_seq != sn);
280                 for (;
281                      NLMSG_OK(nh, (unsigned int)recv_bytes);
282                      nh = NLMSG_NEXT(nh, recv_bytes)) {
283                         if (nh->nlmsg_type == NLMSG_ERROR) {
284                                 struct nlmsgerr *err_data = NLMSG_DATA(nh);
285
286                                 if (err_data->error < 0) {
287                                         rte_errno = -err_data->error;
288                                         return -rte_errno;
289                                 }
290                                 /* Ack message. */
291                                 return 0;
292                         }
293                         /* Multi-part msgs and their trailing DONE message. */
294                         if (nh->nlmsg_flags & NLM_F_MULTI) {
295                                 if (nh->nlmsg_type == NLMSG_DONE)
296                                         return 0;
297                                 multipart = 1;
298                         }
299                         if (cb) {
300                                 ret = cb(nh, arg);
301                                 if (ret < 0)
302                                         return ret;
303                         }
304                 }
305         } while (multipart);
306         return ret;
307 }
308
309 /**
310  * Parse Netlink message to retrieve the bridge MAC address.
311  *
312  * @param nh
313  *   Pointer to Netlink Message Header.
314  * @param arg
315  *   PMD data register with this callback.
316  *
317  * @return
318  *   0 on success, a negative errno value otherwise and rte_errno is set.
319  */
320 static int
321 mlx5_nl_mac_addr_cb(struct nlmsghdr *nh, void *arg)
322 {
323         struct mlx5_nl_mac_addr *data = arg;
324         struct ndmsg *r = NLMSG_DATA(nh);
325         struct rtattr *attribute;
326         int len;
327
328         len = nh->nlmsg_len - NLMSG_LENGTH(sizeof(*r));
329         for (attribute = MLX5_NDA_RTA(r);
330              RTA_OK(attribute, len);
331              attribute = RTA_NEXT(attribute, len)) {
332                 if (attribute->rta_type == NDA_LLADDR) {
333                         if (data->mac_n == MLX5_MAX_MAC_ADDRESSES) {
334                                 DRV_LOG(WARNING,
335                                         "not enough room to finalize the"
336                                         " request");
337                                 rte_errno = ENOMEM;
338                                 return -rte_errno;
339                         }
340 #ifndef NDEBUG
341                         char m[18];
342
343                         ether_format_addr(m, 18, RTA_DATA(attribute));
344                         DRV_LOG(DEBUG, "bridge MAC address %s", m);
345 #endif
346                         memcpy(&(*data->mac)[data->mac_n++],
347                                RTA_DATA(attribute), ETHER_ADDR_LEN);
348                 }
349         }
350         return 0;
351 }
352
353 /**
354  * Get bridge MAC addresses.
355  *
356  * @param dev
357  *   Pointer to Ethernet device.
358  * @param mac[out]
359  *   Pointer to the array table of MAC addresses to fill.
360  *   Its size should be of MLX5_MAX_MAC_ADDRESSES.
361  * @param mac_n[out]
362  *   Number of entries filled in MAC array.
363  *
364  * @return
365  *   0 on success, a negative errno value otherwise and rte_errno is set.
366  */
367 static int
368 mlx5_nl_mac_addr_list(struct rte_eth_dev *dev, struct ether_addr (*mac)[],
369                       int *mac_n)
370 {
371         struct mlx5_priv *priv = dev->data->dev_private;
372         unsigned int iface_idx = mlx5_ifindex(dev);
373         struct {
374                 struct nlmsghdr hdr;
375                 struct ifinfomsg ifm;
376         } req = {
377                 .hdr = {
378                         .nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg)),
379                         .nlmsg_type = RTM_GETNEIGH,
380                         .nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST,
381                 },
382                 .ifm = {
383                         .ifi_family = PF_BRIDGE,
384                         .ifi_index = iface_idx,
385                 },
386         };
387         struct mlx5_nl_mac_addr data = {
388                 .mac = mac,
389                 .mac_n = 0,
390         };
391         int fd;
392         int ret;
393         uint32_t sn = priv->nl_sn++;
394
395         if (priv->nl_socket_route == -1)
396                 return 0;
397         fd = priv->nl_socket_route;
398         ret = mlx5_nl_request(fd, &req.hdr, sn, &req.ifm,
399                               sizeof(struct ifinfomsg));
400         if (ret < 0)
401                 goto error;
402         ret = mlx5_nl_recv(fd, sn, mlx5_nl_mac_addr_cb, &data);
403         if (ret < 0)
404                 goto error;
405         *mac_n = data.mac_n;
406         return 0;
407 error:
408         DRV_LOG(DEBUG, "port %u cannot retrieve MAC address list %s",
409                 dev->data->port_id, strerror(rte_errno));
410         return -rte_errno;
411 }
412
413 /**
414  * Modify the MAC address neighbour table with Netlink.
415  *
416  * @param dev
417  *   Pointer to Ethernet device.
418  * @param mac
419  *   MAC address to consider.
420  * @param add
421  *   1 to add the MAC address, 0 to remove the MAC address.
422  *
423  * @return
424  *   0 on success, a negative errno value otherwise and rte_errno is set.
425  */
426 static int
427 mlx5_nl_mac_addr_modify(struct rte_eth_dev *dev, struct ether_addr *mac,
428                         int add)
429 {
430         struct mlx5_priv *priv = dev->data->dev_private;
431         unsigned int iface_idx = mlx5_ifindex(dev);
432         struct {
433                 struct nlmsghdr hdr;
434                 struct ndmsg ndm;
435                 struct rtattr rta;
436                 uint8_t buffer[ETHER_ADDR_LEN];
437         } req = {
438                 .hdr = {
439                         .nlmsg_len = NLMSG_LENGTH(sizeof(struct ndmsg)),
440                         .nlmsg_flags = NLM_F_REQUEST | NLM_F_CREATE |
441                                 NLM_F_EXCL | NLM_F_ACK,
442                         .nlmsg_type = add ? RTM_NEWNEIGH : RTM_DELNEIGH,
443                 },
444                 .ndm = {
445                         .ndm_family = PF_BRIDGE,
446                         .ndm_state = NUD_NOARP | NUD_PERMANENT,
447                         .ndm_ifindex = iface_idx,
448                         .ndm_flags = NTF_SELF,
449                 },
450                 .rta = {
451                         .rta_type = NDA_LLADDR,
452                         .rta_len = RTA_LENGTH(ETHER_ADDR_LEN),
453                 },
454         };
455         int fd;
456         int ret;
457         uint32_t sn = priv->nl_sn++;
458
459         if (priv->nl_socket_route == -1)
460                 return 0;
461         fd = priv->nl_socket_route;
462         memcpy(RTA_DATA(&req.rta), mac, ETHER_ADDR_LEN);
463         req.hdr.nlmsg_len = NLMSG_ALIGN(req.hdr.nlmsg_len) +
464                 RTA_ALIGN(req.rta.rta_len);
465         ret = mlx5_nl_send(fd, &req.hdr, sn);
466         if (ret < 0)
467                 goto error;
468         ret = mlx5_nl_recv(fd, sn, NULL, NULL);
469         if (ret < 0)
470                 goto error;
471         return 0;
472 error:
473         DRV_LOG(DEBUG,
474                 "port %u cannot %s MAC address %02X:%02X:%02X:%02X:%02X:%02X"
475                 " %s",
476                 dev->data->port_id,
477                 add ? "add" : "remove",
478                 mac->addr_bytes[0], mac->addr_bytes[1],
479                 mac->addr_bytes[2], mac->addr_bytes[3],
480                 mac->addr_bytes[4], mac->addr_bytes[5],
481                 strerror(rte_errno));
482         return -rte_errno;
483 }
484
485 /**
486  * Add a MAC address.
487  *
488  * @param dev
489  *   Pointer to Ethernet device.
490  * @param mac
491  *   MAC address to register.
492  * @param index
493  *   MAC address index.
494  *
495  * @return
496  *   0 on success, a negative errno value otherwise and rte_errno is set.
497  */
498 int
499 mlx5_nl_mac_addr_add(struct rte_eth_dev *dev, struct ether_addr *mac,
500                      uint32_t index)
501 {
502         struct mlx5_priv *priv = dev->data->dev_private;
503         int ret;
504
505         ret = mlx5_nl_mac_addr_modify(dev, mac, 1);
506         if (!ret)
507                 BITFIELD_SET(priv->mac_own, index);
508         if (ret == -EEXIST)
509                 return 0;
510         return ret;
511 }
512
513 /**
514  * Remove a MAC address.
515  *
516  * @param dev
517  *   Pointer to Ethernet device.
518  * @param mac
519  *   MAC address to remove.
520  * @param index
521  *   MAC address index.
522  *
523  * @return
524  *   0 on success, a negative errno value otherwise and rte_errno is set.
525  */
526 int
527 mlx5_nl_mac_addr_remove(struct rte_eth_dev *dev, struct ether_addr *mac,
528                         uint32_t index)
529 {
530         struct mlx5_priv *priv = dev->data->dev_private;
531
532         BITFIELD_RESET(priv->mac_own, index);
533         return mlx5_nl_mac_addr_modify(dev, mac, 0);
534 }
535
536 /**
537  * Synchronize Netlink bridge table to the internal table.
538  *
539  * @param dev
540  *   Pointer to Ethernet device.
541  */
542 void
543 mlx5_nl_mac_addr_sync(struct rte_eth_dev *dev)
544 {
545         struct ether_addr macs[MLX5_MAX_MAC_ADDRESSES];
546         int macs_n = 0;
547         int i;
548         int ret;
549
550         ret = mlx5_nl_mac_addr_list(dev, &macs, &macs_n);
551         if (ret)
552                 return;
553         for (i = 0; i != macs_n; ++i) {
554                 int j;
555
556                 /* Verify the address is not in the array yet. */
557                 for (j = 0; j != MLX5_MAX_MAC_ADDRESSES; ++j)
558                         if (is_same_ether_addr(&macs[i],
559                                                &dev->data->mac_addrs[j]))
560                                 break;
561                 if (j != MLX5_MAX_MAC_ADDRESSES)
562                         continue;
563                 /* Find the first entry available. */
564                 for (j = 0; j != MLX5_MAX_MAC_ADDRESSES; ++j) {
565                         if (is_zero_ether_addr(&dev->data->mac_addrs[j])) {
566                                 dev->data->mac_addrs[j] = macs[i];
567                                 break;
568                         }
569                 }
570         }
571 }
572
573 /**
574  * Flush all added MAC addresses.
575  *
576  * @param dev
577  *   Pointer to Ethernet device.
578  */
579 void
580 mlx5_nl_mac_addr_flush(struct rte_eth_dev *dev)
581 {
582         struct mlx5_priv *priv = dev->data->dev_private;
583         int i;
584
585         for (i = MLX5_MAX_MAC_ADDRESSES - 1; i >= 0; --i) {
586                 struct ether_addr *m = &dev->data->mac_addrs[i];
587
588                 if (BITFIELD_ISSET(priv->mac_own, i))
589                         mlx5_nl_mac_addr_remove(dev, m, i);
590         }
591 }
592
593 /**
594  * Enable promiscuous / all multicast mode through Netlink.
595  *
596  * @param dev
597  *   Pointer to Ethernet device structure.
598  * @param flags
599  *   IFF_PROMISC for promiscuous, IFF_ALLMULTI for allmulti.
600  * @param enable
601  *   Nonzero to enable, disable otherwise.
602  *
603  * @return
604  *   0 on success, a negative errno value otherwise and rte_errno is set.
605  */
606 static int
607 mlx5_nl_device_flags(struct rte_eth_dev *dev, uint32_t flags, int enable)
608 {
609         struct mlx5_priv *priv = dev->data->dev_private;
610         unsigned int iface_idx = mlx5_ifindex(dev);
611         struct {
612                 struct nlmsghdr hdr;
613                 struct ifinfomsg ifi;
614         } req = {
615                 .hdr = {
616                         .nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg)),
617                         .nlmsg_type = RTM_NEWLINK,
618                         .nlmsg_flags = NLM_F_REQUEST,
619                 },
620                 .ifi = {
621                         .ifi_flags = enable ? flags : 0,
622                         .ifi_change = flags,
623                         .ifi_index = iface_idx,
624                 },
625         };
626         int fd;
627         int ret;
628
629         assert(!(flags & ~(IFF_PROMISC | IFF_ALLMULTI)));
630         if (priv->nl_socket_route < 0)
631                 return 0;
632         fd = priv->nl_socket_route;
633         ret = mlx5_nl_send(fd, &req.hdr, priv->nl_sn++);
634         if (ret < 0)
635                 return ret;
636         return 0;
637 }
638
639 /**
640  * Enable promiscuous mode through Netlink.
641  *
642  * @param dev
643  *   Pointer to Ethernet device structure.
644  * @param enable
645  *   Nonzero to enable, disable otherwise.
646  *
647  * @return
648  *   0 on success, a negative errno value otherwise and rte_errno is set.
649  */
650 int
651 mlx5_nl_promisc(struct rte_eth_dev *dev, int enable)
652 {
653         int ret = mlx5_nl_device_flags(dev, IFF_PROMISC, enable);
654
655         if (ret)
656                 DRV_LOG(DEBUG,
657                         "port %u cannot %s promisc mode: Netlink error %s",
658                         dev->data->port_id, enable ? "enable" : "disable",
659                         strerror(rte_errno));
660         return ret;
661 }
662
663 /**
664  * Enable all multicast mode through Netlink.
665  *
666  * @param dev
667  *   Pointer to Ethernet device structure.
668  * @param enable
669  *   Nonzero to enable, disable otherwise.
670  *
671  * @return
672  *   0 on success, a negative errno value otherwise and rte_errno is set.
673  */
674 int
675 mlx5_nl_allmulti(struct rte_eth_dev *dev, int enable)
676 {
677         int ret = mlx5_nl_device_flags(dev, IFF_ALLMULTI, enable);
678
679         if (ret)
680                 DRV_LOG(DEBUG,
681                         "port %u cannot %s allmulti mode: Netlink error %s",
682                         dev->data->port_id, enable ? "enable" : "disable",
683                         strerror(rte_errno));
684         return ret;
685 }
686
687 /**
688  * Process network interface information from Netlink message.
689  *
690  * @param nh
691  *   Pointer to Netlink message header.
692  * @param arg
693  *   Opaque data pointer for this callback.
694  *
695  * @return
696  *   0 on success, a negative errno value otherwise and rte_errno is set.
697  */
698 static int
699 mlx5_nl_cmdget_cb(struct nlmsghdr *nh, void *arg)
700 {
701         struct mlx5_nl_ifindex_data *data = arg;
702         size_t off = NLMSG_HDRLEN;
703         uint32_t ibindex = 0;
704         uint32_t ifindex = 0;
705         uint32_t portnum = 0;
706         int found = 0;
707
708         if (nh->nlmsg_type !=
709             RDMA_NL_GET_TYPE(RDMA_NL_NLDEV, RDMA_NLDEV_CMD_GET) &&
710             nh->nlmsg_type !=
711             RDMA_NL_GET_TYPE(RDMA_NL_NLDEV, RDMA_NLDEV_CMD_PORT_GET))
712                 goto error;
713         while (off < nh->nlmsg_len) {
714                 struct nlattr *na = (void *)((uintptr_t)nh + off);
715                 void *payload = (void *)((uintptr_t)na + NLA_HDRLEN);
716
717                 if (na->nla_len > nh->nlmsg_len - off)
718                         goto error;
719                 switch (na->nla_type) {
720                 case RDMA_NLDEV_ATTR_DEV_INDEX:
721                         ibindex = *(uint32_t *)payload;
722                         break;
723                 case RDMA_NLDEV_ATTR_DEV_NAME:
724                         if (!strcmp(payload, data->name))
725                                 found = 1;
726                         break;
727                 case RDMA_NLDEV_ATTR_NDEV_INDEX:
728                         ifindex = *(uint32_t *)payload;
729                         break;
730                 case RDMA_NLDEV_ATTR_PORT_INDEX:
731                         portnum = *(uint32_t *)payload;
732                         break;
733                 default:
734                         break;
735                 }
736                 off += NLA_ALIGN(na->nla_len);
737         }
738         if (found) {
739                 data->ibindex = ibindex;
740                 data->ifindex = ifindex;
741                 data->portnum = portnum;
742         }
743         return 0;
744 error:
745         rte_errno = EINVAL;
746         return -rte_errno;
747 }
748
749 /**
750  * Get index of network interface associated with some IB device.
751  *
752  * This is the only somewhat safe method to avoid resorting to heuristics
753  * when faced with port representors. Unfortunately it requires at least
754  * Linux 4.17.
755  *
756  * @param nl
757  *   Netlink socket of the RDMA kind (NETLINK_RDMA).
758  * @param[in] name
759  *   IB device name.
760  * @param[in] pindex
761  *   IB device port index, starting from 1
762  * @return
763  *   A valid (nonzero) interface index on success, 0 otherwise and rte_errno
764  *   is set.
765  */
766 unsigned int
767 mlx5_nl_ifindex(int nl, const char *name, uint32_t pindex)
768 {
769         uint32_t seq = random();
770         struct mlx5_nl_ifindex_data data = {
771                 .name = name,
772                 .ibindex = 0, /* Determined during first pass. */
773                 .ifindex = 0, /* Determined during second pass. */
774         };
775         union {
776                 struct nlmsghdr nh;
777                 uint8_t buf[NLMSG_HDRLEN +
778                             NLA_HDRLEN + NLA_ALIGN(sizeof(data.ibindex)) +
779                             NLA_HDRLEN + NLA_ALIGN(sizeof(pindex))];
780         } req = {
781                 .nh = {
782                         .nlmsg_len = NLMSG_LENGTH(0),
783                         .nlmsg_type = RDMA_NL_GET_TYPE(RDMA_NL_NLDEV,
784                                                        RDMA_NLDEV_CMD_GET),
785                         .nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | NLM_F_DUMP,
786                 },
787         };
788         struct nlattr *na;
789         int ret;
790
791         ret = mlx5_nl_send(nl, &req.nh, seq);
792         if (ret < 0)
793                 return 0;
794         ret = mlx5_nl_recv(nl, seq, mlx5_nl_cmdget_cb, &data);
795         if (ret < 0)
796                 return 0;
797         if (!data.ibindex)
798                 goto error;
799         ++seq;
800         req.nh.nlmsg_type = RDMA_NL_GET_TYPE(RDMA_NL_NLDEV,
801                                              RDMA_NLDEV_CMD_PORT_GET);
802         req.nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
803         req.nh.nlmsg_len = NLMSG_LENGTH(sizeof(req.buf) - NLMSG_HDRLEN);
804         na = (void *)((uintptr_t)req.buf + NLMSG_HDRLEN);
805         na->nla_len = NLA_HDRLEN + sizeof(data.ibindex);
806         na->nla_type = RDMA_NLDEV_ATTR_DEV_INDEX;
807         memcpy((void *)((uintptr_t)na + NLA_HDRLEN),
808                &data.ibindex, sizeof(data.ibindex));
809         na = (void *)((uintptr_t)na + NLA_ALIGN(na->nla_len));
810         na->nla_len = NLA_HDRLEN + sizeof(pindex);
811         na->nla_type = RDMA_NLDEV_ATTR_PORT_INDEX;
812         memcpy((void *)((uintptr_t)na + NLA_HDRLEN),
813                &pindex, sizeof(pindex));
814         ret = mlx5_nl_send(nl, &req.nh, seq);
815         if (ret < 0)
816                 return 0;
817         ret = mlx5_nl_recv(nl, seq, mlx5_nl_cmdget_cb, &data);
818         if (ret < 0)
819                 return 0;
820         if (!data.ifindex)
821                 goto error;
822         return data.ifindex;
823 error:
824         rte_errno = ENODEV;
825         return 0;
826 }
827
828 /**
829  * Process switch information from Netlink message.
830  *
831  * @param nh
832  *   Pointer to Netlink message header.
833  * @param arg
834  *   Opaque data pointer for this callback.
835  *
836  * @return
837  *   0 on success, a negative errno value otherwise and rte_errno is set.
838  */
839 static int
840 mlx5_nl_switch_info_cb(struct nlmsghdr *nh, void *arg)
841 {
842         struct mlx5_switch_info info = {
843                 .master = 0,
844                 .representor = 0,
845                 .port_name_new = 0,
846                 .port_name = 0,
847                 .switch_id = 0,
848         };
849         size_t off = NLMSG_LENGTH(sizeof(struct ifinfomsg));
850         bool port_name_set = false;
851         bool switch_id_set = false;
852         bool num_vf_set = false;
853
854         if (nh->nlmsg_type != RTM_NEWLINK)
855                 goto error;
856         while (off < nh->nlmsg_len) {
857                 struct rtattr *ra = (void *)((uintptr_t)nh + off);
858                 void *payload = RTA_DATA(ra);
859                 unsigned int i;
860
861                 if (ra->rta_len > nh->nlmsg_len - off)
862                         goto error;
863                 switch (ra->rta_type) {
864                 case IFLA_NUM_VF:
865                         num_vf_set = true;
866                         break;
867                 case IFLA_PHYS_PORT_NAME:
868                         port_name_set =
869                                 mlx5_translate_port_name((char *)payload,
870                                                          &info);
871                         break;
872                 case IFLA_PHYS_SWITCH_ID:
873                         info.switch_id = 0;
874                         for (i = 0; i < RTA_PAYLOAD(ra); ++i) {
875                                 info.switch_id <<= 8;
876                                 info.switch_id |= ((uint8_t *)payload)[i];
877                         }
878                         switch_id_set = true;
879                         break;
880                 }
881                 off += RTA_ALIGN(ra->rta_len);
882         }
883         if (switch_id_set) {
884                 if (info.port_name_new) {
885                         /* New representors naming schema. */
886                         if (port_name_set) {
887                                 info.master = (info.port_name == -1);
888                                 info.representor = (info.port_name != -1);
889                         }
890                 } else {
891                         /* Legacy representors naming schema. */
892                         info.master = (!port_name_set || num_vf_set);
893                         info.representor = port_name_set && !num_vf_set;
894                 }
895         }
896         assert(!(info.master && info.representor));
897         memcpy(arg, &info, sizeof(info));
898         return 0;
899 error:
900         rte_errno = EINVAL;
901         return -rte_errno;
902 }
903
904 /**
905  * Get switch information associated with network interface.
906  *
907  * @param nl
908  *   Netlink socket of the ROUTE kind (NETLINK_ROUTE).
909  * @param ifindex
910  *   Network interface index.
911  * @param[out] info
912  *   Switch information object, populated in case of success.
913  *
914  * @return
915  *   0 on success, a negative errno value otherwise and rte_errno is set.
916  */
917 int
918 mlx5_nl_switch_info(int nl, unsigned int ifindex, struct mlx5_switch_info *info)
919 {
920         uint32_t seq = random();
921         struct {
922                 struct nlmsghdr nh;
923                 struct ifinfomsg info;
924                 struct rtattr rta;
925                 uint32_t extmask;
926         } req = {
927                 .nh = {
928                         .nlmsg_len = NLMSG_LENGTH
929                                         (sizeof(req.info) +
930                                          RTA_LENGTH(sizeof(uint32_t))),
931                         .nlmsg_type = RTM_GETLINK,
932                         .nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK,
933                 },
934                 .info = {
935                         .ifi_family = AF_UNSPEC,
936                         .ifi_index = ifindex,
937                 },
938                 .rta = {
939                         .rta_type = IFLA_EXT_MASK,
940                         .rta_len = RTA_LENGTH(sizeof(int32_t)),
941                 },
942                 .extmask = RTE_LE32(1),
943         };
944         int ret;
945
946         ret = mlx5_nl_send(nl, &req.nh, seq);
947         if (ret >= 0)
948                 ret = mlx5_nl_recv(nl, seq, mlx5_nl_switch_info_cb, info);
949         if (info->master && info->representor) {
950                 DRV_LOG(ERR, "ifindex %u device is recognized as master"
951                              " and as representor", ifindex);
952                 rte_errno = ENODEV;
953                 ret = -rte_errno;
954         }
955         return ret;
956 }