ethdev: support MAC address as iterator filter
[dpdk.git] / lib / librte_ethdev / rte_class_eth.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2018 GaĆ«tan Rivet
3  */
4
5 #include <string.h>
6
7 #include <cmdline_parse_etheraddr.h>
8 #include <rte_class.h>
9 #include <rte_compat.h>
10 #include <rte_errno.h>
11 #include <rte_kvargs.h>
12 #include <rte_log.h>
13
14 #include "rte_ethdev.h"
15 #include "rte_ethdev_core.h"
16 #include "rte_ethdev_driver.h"
17 #include "ethdev_private.h"
18
19 enum eth_params {
20         RTE_ETH_PARAM_MAC,
21         RTE_ETH_PARAM_REPRESENTOR,
22         RTE_ETH_PARAM_MAX,
23 };
24
25 static const char * const eth_params_keys[] = {
26         [RTE_ETH_PARAM_MAC] = "mac",
27         [RTE_ETH_PARAM_REPRESENTOR] = "representor",
28         [RTE_ETH_PARAM_MAX] = NULL,
29 };
30
31 struct eth_dev_match_arg {
32         struct rte_device *device;
33         struct rte_kvargs *kvlist;
34 };
35
36 #define eth_dev_match_arg(d, k) \
37         (&(const struct eth_dev_match_arg) { \
38                 .device = (d), \
39                 .kvlist = (k), \
40         })
41
42 static int
43 eth_mac_cmp(const char *key __rte_unused,
44                 const char *value, void *opaque)
45 {
46         int ret;
47         struct ether_addr mac;
48         const struct rte_eth_dev_data *data = opaque;
49         struct rte_eth_dev_info dev_info;
50         uint32_t index;
51
52         /* Parse devargs MAC address. */
53         /*
54          * cannot use ether_aton_r(value, &mac)
55          * because of include conflict with rte_ether.h
56          */
57         ret = cmdline_parse_etheraddr(NULL, value, &mac, sizeof(mac));
58         if (ret < 0)
59                 return -1; /* invalid devargs value */
60
61         /* Return 0 if devargs MAC is matching one of the device MACs. */
62         rte_eth_dev_info_get(data->port_id, &dev_info);
63         for (index = 0; index < dev_info.max_mac_addrs; index++)
64                 if (is_same_ether_addr(&mac, &data->mac_addrs[index]))
65                         return 0;
66         return -1; /* no match */
67 }
68
69 static int
70 eth_representor_cmp(const char *key __rte_unused,
71                 const char *value, void *opaque)
72 {
73         int ret;
74         char *values;
75         const struct rte_eth_dev_data *data = opaque;
76         struct rte_eth_devargs representors;
77         uint16_t index;
78
79         if ((data->dev_flags & RTE_ETH_DEV_REPRESENTOR) == 0)
80                 return -1; /* not a representor port */
81
82         /* Parse devargs representor values. */
83         values = strdup(value);
84         if (values == NULL)
85                 return -1;
86         memset(&representors, 0, sizeof(representors));
87         ret = rte_eth_devargs_parse_list(values,
88                         rte_eth_devargs_parse_representor_ports,
89                         &representors);
90         free(values);
91         if (ret != 0)
92                 return -1; /* invalid devargs value */
93
94         /* Return 0 if representor id is matching one of the values. */
95         for (index = 0; index < representors.nb_representor_ports; index++)
96                 if (data->representor_id ==
97                                 representors.representor_ports[index])
98                         return 0;
99         return -1; /* no match */
100 }
101
102 static int
103 eth_dev_match(const struct rte_eth_dev *edev,
104               const void *_arg)
105 {
106         int ret;
107         const struct eth_dev_match_arg *arg = _arg;
108         const struct rte_kvargs *kvlist = arg->kvlist;
109
110         if (edev->state == RTE_ETH_DEV_UNUSED)
111                 return -1;
112         if (arg->device != NULL && arg->device != edev->device)
113                 return -1;
114         if (kvlist == NULL)
115                 /* Empty string matches everything. */
116                 return 0;
117
118         ret = rte_kvargs_process(kvlist,
119                         eth_params_keys[RTE_ETH_PARAM_MAC],
120                         eth_mac_cmp, edev->data);
121         if (ret != 0)
122                 return -1;
123
124         ret = rte_kvargs_process(kvlist,
125                         eth_params_keys[RTE_ETH_PARAM_REPRESENTOR],
126                         eth_representor_cmp, edev->data);
127         if (ret != 0)
128                 return -1;
129
130         return 0;
131 }
132
133 static void *
134 eth_dev_iterate(const void *start,
135                 const char *str,
136                 const struct rte_dev_iterator *it)
137 {
138         struct rte_kvargs *kvargs = NULL;
139         struct rte_eth_dev *edev = NULL;
140         const char * const *valid_keys = NULL;
141
142         if (str != NULL) {
143                 if (str[0] == '+') /* no validation of keys */
144                         str++;
145                 else
146                         valid_keys = eth_params_keys;
147                 kvargs = rte_kvargs_parse(str, valid_keys);
148                 if (kvargs == NULL) {
149                         RTE_LOG(ERR, EAL, "cannot parse argument list\n");
150                         rte_errno = EINVAL;
151                         return NULL;
152                 }
153         }
154         edev = eth_find_device(start, eth_dev_match,
155                                eth_dev_match_arg(it->device, kvargs));
156         rte_kvargs_free(kvargs);
157         return edev;
158 }
159
160 struct rte_class rte_class_eth = {
161         .dev_iterate = eth_dev_iterate,
162 };
163
164 RTE_REGISTER_CLASS(eth, rte_class_eth);