Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (c) 2021 NVIDIA Corporation & Affiliates
3 : : */
4 : :
5 : : #include <stdlib.h>
6 : : #include <stdio.h>
7 : : #include <string.h>
8 : :
9 : : #include <ethdev_driver.h>
10 : : #include <rte_common.h>
11 : : #include <rte_devargs.h>
12 : : #include <rte_kvargs.h>
13 : : #include <bus_driver.h>
14 : : #include <rte_class.h>
15 : :
16 : : #include "test.h"
17 : :
18 : : /* Check layer arguments. */
19 : : static int
20 : 30 : test_args(const char *devargs, const char *layer, const char *args, const int n)
21 : : {
22 : : struct rte_kvargs *kvlist;
23 : :
24 [ + + ]: 30 : if (n == 0) {
25 [ + + - + ]: 17 : if (args != NULL && strlen(args) > 0) {
26 : : printf("rte_devargs_parse(%s) %s args parsed (not expected)\n",
27 : : devargs, layer);
28 : 0 : return -1;
29 : : } else {
30 : : return 0;
31 : : }
32 : : }
33 [ - + ]: 13 : if (args == NULL) {
34 : : printf("rte_devargs_parse(%s) %s args not parsed\n",
35 : : devargs, layer);
36 : 0 : return -1;
37 : : }
38 : 13 : kvlist = rte_kvargs_parse(args, NULL);
39 [ - + ]: 13 : if (kvlist == NULL) {
40 : : printf("rte_devargs_parse(%s) %s_str: %s not parsed\n",
41 : : devargs, layer, args);
42 : 0 : return -1;
43 : : }
44 [ - + ]: 13 : if ((int)kvlist->count != n) {
45 : : printf("rte_devargs_parse(%s) %s_str: %s kv number %u, not %d\n",
46 : : devargs, layer, args, kvlist->count, n);
47 : 0 : rte_kvargs_free(kvlist);
48 : 0 : return -1;
49 : : }
50 : 13 : rte_kvargs_free(kvlist);
51 : 13 : return 0;
52 : : }
53 : :
54 : : struct devargs_case {
55 : : const char *devargs;
56 : : int bus_kv;
57 : : int class_kv;
58 : : int driver_kv;
59 : : const char *bus;
60 : : const char *name;
61 : : const char *class;
62 : : };
63 : :
64 : : static int
65 : 2 : test_valid_devargs_cases(const struct devargs_case *list, size_t n)
66 : : {
67 : : struct rte_devargs da;
68 : : uint32_t i;
69 : : int ret;
70 : : int fail = TEST_SUCCESS;
71 : 2 : struct rte_bus *pci_bus = rte_bus_find_by_name("pci");
72 : 2 : struct rte_bus *vdev_bus = rte_bus_find_by_name("vdev");
73 : 2 : struct rte_class *eth_class = rte_class_find_by_name("eth");
74 : :
75 [ + + ]: 12 : for (i = 0; i < n; i++) {
76 [ - + - - ]: 10 : if (pci_bus == NULL && list[i].bus != NULL &&
77 [ # # ]: 0 : strcmp(list[i].bus, "pci") == 0)
78 : 0 : continue;
79 [ - + - - ]: 10 : if (vdev_bus == NULL && list[i].bus != NULL &&
80 [ # # ]: 0 : strcmp(list[i].bus, "vdev") == 0)
81 : 0 : continue;
82 [ - + - - ]: 10 : if (eth_class == NULL && list[i].class != NULL &&
83 [ # # ]: 0 : strcmp(list[i].class, "eth") == 0)
84 : 0 : continue;
85 : : memset(&da, 0, sizeof(da));
86 : 10 : ret = rte_devargs_parse(&da, list[i].devargs);
87 [ - + ]: 10 : if (ret < 0) {
88 : : printf("rte_devargs_parse(%s) returned %d (but should not)\n",
89 : 0 : list[i].devargs, ret);
90 : 0 : goto fail;
91 : : }
92 [ + + + + ]: 10 : if ((list[i].bus_kv > 0 || list[i].bus != NULL) &&
93 [ - + ]: 9 : da.bus == NULL) {
94 : : printf("rte_devargs_parse(%s) bus not parsed\n",
95 : 0 : list[i].devargs);
96 : 0 : goto fail;
97 : : }
98 [ - + ]: 10 : if (test_args(list[i].devargs, "bus", da.bus_str,
99 : : list[i].bus_kv) != 0)
100 : 0 : goto fail;
101 [ + + ]: 10 : if (list[i].bus != NULL &&
102 [ - + ]: 9 : strcmp(rte_bus_name(da.bus), list[i].bus) != 0) {
103 : 0 : printf("rte_devargs_parse(%s) bus name (%s) not expected (%s)\n",
104 : 0 : list[i].devargs, rte_bus_name(da.bus), list[i].bus);
105 : 0 : goto fail;
106 : : }
107 [ + + - + ]: 10 : if ((list[i].class_kv > 0 || list[i].class != NULL) &&
108 [ - + ]: 5 : da.cls == NULL) {
109 : : printf("rte_devargs_parse(%s) class not parsed\n",
110 : 0 : list[i].devargs);
111 : 0 : goto fail;
112 : : }
113 [ - + ]: 10 : if (test_args(list[i].devargs, "class", da.cls_str,
114 : : list[i].class_kv) != 0)
115 : 0 : goto fail;
116 [ + + ]: 10 : if (list[i].class != NULL &&
117 [ - + ]: 5 : strcmp(da.cls->name, list[i].class) != 0) {
118 : : printf("rte_devargs_parse(%s) class name (%s) not expected (%s)\n",
119 : 0 : list[i].devargs, da.cls->name, list[i].class);
120 : 0 : goto fail;
121 : : }
122 [ - + ]: 10 : if (test_args(list[i].devargs, "driver", da.drv_str,
123 : 10 : list[i].driver_kv) != 0)
124 : 0 : goto fail;
125 [ + + ]: 10 : if (list[i].name != NULL &&
126 [ - + ]: 8 : strcmp(da.name, list[i].name) != 0) {
127 : : printf("rte_devargs_parse(%s) device name (%s) not expected (%s)\n",
128 : 0 : list[i].devargs, da.name, list[i].name);
129 : 0 : goto fail;
130 : : }
131 : 10 : goto cleanup;
132 : : fail:
133 : : fail = TEST_FAILED;
134 : 10 : cleanup:
135 : 10 : rte_devargs_reset(&da);
136 : : }
137 : 2 : return fail;
138 : : }
139 : :
140 : : /* Test several valid cases */
141 : : static int
142 : 1 : test_valid_devargs(void)
143 : : {
144 : : static const struct devargs_case list[] = {
145 : : /* Global devargs syntax: */
146 : : { "bus=pci",
147 : : 1, 0, 0, "pci", NULL, NULL},
148 : : { "class=eth",
149 : : 0, 1, 0, NULL, NULL, "eth" },
150 : : { "bus=pci,addr=1:2.3/class=eth/driver=abc,k0=v0",
151 : : 2, 1, 2, "pci", "0000:01:02.3", "eth" },
152 : : { "bus=vdev,name=/dev/file/name/class=eth",
153 : : 2, 1, 0, "vdev", "/dev/file/name", "eth" },
154 : : { "bus=vdev,name=/class/bus/path/class=eth",
155 : : 2, 1, 0, "vdev", "/class/bus/path", "eth" },
156 : : { "bus=vdev,name=///dblslsh/class=eth",
157 : : 2, 1, 0, "vdev", "///dblslsh", "eth" },
158 : : /* Legacy devargs syntax: */
159 : : { "1:2.3", 0, 0, 0,
160 : : "pci", "1:2.3", NULL },
161 : : { "pci:1:2.3,k0=v0",
162 : : 0, 0, 1, "pci", "1:2.3", NULL },
163 : : };
164 : : static const struct devargs_case legacy_ring_list[] = {
165 : : { "net_ring0",
166 : : 0, 0, 0, "vdev", "net_ring0", NULL },
167 : : { "net_ring0,iface=test,path=/class/bus/,queues=1",
168 : : 0, 0, 3, "vdev", "net_ring0", NULL },
169 : : };
170 : 1 : struct rte_bus *vdev_bus = rte_bus_find_by_name("vdev");
171 : : int ret;
172 : :
173 : 1 : ret = test_valid_devargs_cases(list, RTE_DIM(list));
174 [ + - + - ]: 1 : if (vdev_bus != NULL && vdev_bus->parse("net_ring0", NULL) == 0)
175 : : /* Ring vdev driver enabled. */
176 : 1 : ret |= test_valid_devargs_cases(legacy_ring_list,
177 : : RTE_DIM(legacy_ring_list));
178 : 1 : return ret;
179 : : }
180 : :
181 : : /* Test several invalid cases */
182 : : static int
183 : 1 : test_invalid_devargs(void)
184 : : {
185 : : static const char * const list[] = {
186 : : "bus=wrong-bus",
187 : : "class=wrong-class"};
188 : : struct rte_devargs da;
189 : : uint32_t i;
190 : : int ret;
191 : : int fail = 0;
192 : :
193 [ + + ]: 3 : for (i = 0; i < RTE_DIM(list); i++) {
194 : 2 : ret = rte_devargs_parse(&da, list[i]);
195 [ - + ]: 2 : if (ret >= 0) {
196 : : printf("rte_devargs_parse(%s) returned %d (but should not)\n",
197 : : list[i], ret);
198 : : fail = ret;
199 : : }
200 : 2 : rte_devargs_reset(&da);
201 : : }
202 : 1 : return fail;
203 : : }
204 : :
205 : : struct devargs_parse_case {
206 : : const char *devargs;
207 : : uint8_t devargs_count;
208 : : };
209 : :
210 : : static int
211 : 1 : test_valid_devargs_parsing(void)
212 : : {
213 : : static const struct devargs_parse_case list[] = {
214 : : /* Single representors patterns */
215 : : {"representor=1", 1},
216 : : {"representor=[1,2,3]", 1},
217 : : {"representor=[0-3,5,7]", 1},
218 : : {"representor=vf[0-1]", 1},
219 : : {"representor=sf[0-1]", 1},
220 : : {"representor=pf1vf[0-1]", 1},
221 : : {"representor=pf[0-1]vf[1-2]", 1},
222 : : {"representor=pf[0-1]sf[1-2]", 1},
223 : : {"representor=c0pf[0-1]", 1},
224 : : {"representor=sf[1,2]vf[2]", 1}, /* Only SF ports will be represented */
225 : : {"representor=vf2sf[1-2]", 1}, /* Only VF ports will be represented */
226 : : {"representor=c[0-1]pf[0-1]vf[1-2]", 1},
227 : : /* Single devarg inside multiple representor pattern */
228 : : {"representor=[c[0-1]pf[0-1]vf[1-2]]", 1},
229 : : /* Multiple representors patterns */
230 : : {"representor=[vf0,3]", 2},
231 : : {"representor=[vf0,vf1]", 2},
232 : : {"representor=[vf[0],vf[1]]", 2},
233 : : {"representor=[vf[0,1],3]", 2},
234 : : {"representor=[vf[0,1],[3]]", 2},
235 : : {"representor=[pf1vf[0-1],3]", 2},
236 : : {"representor=[pf1vf[0-1],pf[0-1]]", 2},
237 : : {"representor=[pf1,pf3,pf1vf[0-1],vf[0],vf[1],vf0,vf1,vf2]", 8},
238 : : {"representor=[1,3,5,pf1,pf2,pf3,pf1vf[0-1],vf[0],vf[1],vf0,vf1,vf2]", 12},
239 : : {"representor=[[1,3,5],pf1,pf2,pf3,pf1vf[0-1],vf[0],vf[1],vf0,vf1,vf2]", 10},
240 : : {"representor=[c[0,2-4]pf[1,6]vf[0-1],vf[0],vf4,[3-5,7],pf1vf[0-1,6],pf[2,4,6]]", 6}
241 : : };
242 : : struct rte_eth_devargs eth_da[RTE_MAX_ETHPORTS];
243 : : uint32_t i;
244 : : int ret;
245 : : int fail = 0;
246 : :
247 [ + + ]: 25 : for (i = 0; i < RTE_DIM(list); i++) {
248 : : memset(eth_da, 0, RTE_MAX_ETHPORTS * sizeof(*eth_da));
249 : 24 : ret = rte_eth_devargs_parse(list[i].devargs, eth_da, RTE_MAX_ETHPORTS);
250 [ - + ]: 24 : if (ret <= 0) {
251 : : printf("rte_devargs_parse(%s) returned %d (but should not)\n",
252 : : list[i].devargs, ret);
253 : : fail = ret;
254 : 0 : break;
255 : : }
256 : :
257 : : /* Check the return value, count should be equivalent to no of devargs. */
258 [ - + ]: 24 : if (ret != list[i].devargs_count) {
259 : : printf("Devargs returned count %d != expected count %d\n", ret,
260 : : list[i].devargs_count);
261 : : fail = -1;
262 : 0 : break;
263 : : }
264 : : }
265 : 1 : return fail;
266 : : }
267 : :
268 : : static int
269 : 1 : test_invalid_devargs_parsing(void)
270 : : {
271 : : static const char * const list[] = {
272 : : "representor=1,2,3,4", /* Out [] missing */
273 : : "representor=[1 2 3]", /* , missing */
274 : : "representor=c[1,2]", /* Only controller no valid */
275 : : "representor=c0vf[0-1]", /* Controller with vf alone not valid */
276 : : "representor=c0sf[0-1]", /* Controller with sf alone not valid */
277 : : "representor=vf[0-1],vf3", /* Out [] missing */
278 : : "representor=[[vf0,3]]", /* Double [] is invalid */
279 : : "representor=pfvf[1-2]", /* No PF index provided */
280 : : "representor=pf1[vf[1-2]]", /* Additional [] across vf */
281 : : "representor=c0[pf1vf[1-2]]", /* Additional [] across pfvf */
282 : : "representor=c0[pf1[vf[1-2]]]", /* Additional [] across pfvf */
283 : : "representor=[pf1vf[0-1], pf[0-1]]", /* Space between two devargs is invalid */
284 : : "representor=[pf1vf[0-1], 3]", /* Space between two devargs is invalid */
285 : : "representor=pf1vf[1-2],representor=1", /* Multiple representor keys */
286 : : };
287 : : struct rte_eth_devargs eth_da[RTE_MAX_ETHPORTS];
288 : : uint32_t i;
289 : : int ret;
290 : : int fail = 0;
291 : :
292 [ + + ]: 15 : for (i = 0; i < RTE_DIM(list); i++) {
293 : : memset(eth_da, 0, RTE_MAX_ETHPORTS * sizeof(*eth_da));
294 : 14 : ret = rte_eth_devargs_parse(list[i], eth_da, RTE_MAX_ETHPORTS);
295 [ - + ]: 14 : if (ret > 0) {
296 : : printf("rte_devargs_parse(%s) returned %d (but should not)\n",
297 : : list[i], ret);
298 : : fail = ret;
299 : 0 : break;
300 : : }
301 : : }
302 : 1 : return fail;
303 : : }
304 : :
305 : : static int
306 : 1 : test_devargs(void)
307 : : {
308 : : printf("== test valid case ==\n");
309 [ + - ]: 1 : if (test_valid_devargs() < 0)
310 : : return -1;
311 : : printf("== test invalid case ==\n");
312 [ + - ]: 1 : if (test_invalid_devargs() < 0)
313 : : return -1;
314 : : printf("== test devargs parsing valid case ==\n");
315 [ + - ]: 1 : if (test_valid_devargs_parsing() < 0)
316 : : return -1;
317 : : printf("== test devargs parsing invalid case ==\n");
318 [ - + ]: 1 : if (test_invalid_devargs_parsing() < 0)
319 : 0 : return -1;
320 : : return 0;
321 : : }
322 : :
323 : 251 : REGISTER_FAST_TEST(devargs_autotest, true, true, test_devargs);
|
