1 // SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause)
2 /* Do not edit directly, auto-generated from: */
3 /*	Documentation/netlink/specs/devlink.yaml */
4 /* YNL-GEN user source */
5 
6 #include <stdlib.h>
7 #include <string.h>
8 #include "devlink-user.h"
9 #include "ynl.h"
10 #include <linux/devlink.h>
11 
12 #include <libmnl/libmnl.h>
13 #include <linux/genetlink.h>
14 
15 /* Enums */
16 static const char * const devlink_op_strmap[] = {
17 	[3] = "get",
18 	[7] = "port-get",
19 	[13] = "sb-get",
20 	[17] = "sb-pool-get",
21 	[21] = "sb-port-pool-get",
22 	[25] = "sb-tc-pool-bind-get",
23 	[DEVLINK_CMD_PARAM_GET] = "param-get",
24 	[DEVLINK_CMD_REGION_GET] = "region-get",
25 	[DEVLINK_CMD_INFO_GET] = "info-get",
26 	[DEVLINK_CMD_HEALTH_REPORTER_GET] = "health-reporter-get",
27 	[63] = "trap-get",
28 	[67] = "trap-group-get",
29 	[71] = "trap-policer-get",
30 	[76] = "rate-get",
31 	[80] = "linecard-get",
32 	[DEVLINK_CMD_SELFTESTS_GET] = "selftests-get",
33 };
34 
35 const char *devlink_op_str(int op)
36 {
37 	if (op < 0 || op >= (int)MNL_ARRAY_SIZE(devlink_op_strmap))
38 		return NULL;
39 	return devlink_op_strmap[op];
40 }
41 
42 static const char * const devlink_sb_pool_type_strmap[] = {
43 	[0] = "ingress",
44 	[1] = "egress",
45 };
46 
47 const char *devlink_sb_pool_type_str(enum devlink_sb_pool_type value)
48 {
49 	if (value < 0 || value >= (int)MNL_ARRAY_SIZE(devlink_sb_pool_type_strmap))
50 		return NULL;
51 	return devlink_sb_pool_type_strmap[value];
52 }
53 
54 /* Policies */
55 struct ynl_policy_attr devlink_dl_info_version_policy[DEVLINK_ATTR_MAX + 1] = {
56 	[DEVLINK_ATTR_INFO_VERSION_NAME] = { .name = "info-version-name", .type = YNL_PT_NUL_STR, },
57 	[DEVLINK_ATTR_INFO_VERSION_VALUE] = { .name = "info-version-value", .type = YNL_PT_NUL_STR, },
58 };
59 
60 struct ynl_policy_nest devlink_dl_info_version_nest = {
61 	.max_attr = DEVLINK_ATTR_MAX,
62 	.table = devlink_dl_info_version_policy,
63 };
64 
65 struct ynl_policy_attr devlink_dl_reload_stats_entry_policy[DEVLINK_ATTR_MAX + 1] = {
66 	[DEVLINK_ATTR_RELOAD_STATS_LIMIT] = { .name = "reload-stats-limit", .type = YNL_PT_U8, },
67 	[DEVLINK_ATTR_RELOAD_STATS_VALUE] = { .name = "reload-stats-value", .type = YNL_PT_U32, },
68 };
69 
70 struct ynl_policy_nest devlink_dl_reload_stats_entry_nest = {
71 	.max_attr = DEVLINK_ATTR_MAX,
72 	.table = devlink_dl_reload_stats_entry_policy,
73 };
74 
75 struct ynl_policy_attr devlink_dl_reload_act_stats_policy[DEVLINK_ATTR_MAX + 1] = {
76 	[DEVLINK_ATTR_RELOAD_STATS_ENTRY] = { .name = "reload-stats-entry", .type = YNL_PT_NEST, .nest = &devlink_dl_reload_stats_entry_nest, },
77 };
78 
79 struct ynl_policy_nest devlink_dl_reload_act_stats_nest = {
80 	.max_attr = DEVLINK_ATTR_MAX,
81 	.table = devlink_dl_reload_act_stats_policy,
82 };
83 
84 struct ynl_policy_attr devlink_dl_reload_act_info_policy[DEVLINK_ATTR_MAX + 1] = {
85 	[DEVLINK_ATTR_RELOAD_ACTION] = { .name = "reload-action", .type = YNL_PT_U8, },
86 	[DEVLINK_ATTR_RELOAD_ACTION_STATS] = { .name = "reload-action-stats", .type = YNL_PT_NEST, .nest = &devlink_dl_reload_act_stats_nest, },
87 };
88 
89 struct ynl_policy_nest devlink_dl_reload_act_info_nest = {
90 	.max_attr = DEVLINK_ATTR_MAX,
91 	.table = devlink_dl_reload_act_info_policy,
92 };
93 
94 struct ynl_policy_attr devlink_dl_reload_stats_policy[DEVLINK_ATTR_MAX + 1] = {
95 	[DEVLINK_ATTR_RELOAD_ACTION_INFO] = { .name = "reload-action-info", .type = YNL_PT_NEST, .nest = &devlink_dl_reload_act_info_nest, },
96 };
97 
98 struct ynl_policy_nest devlink_dl_reload_stats_nest = {
99 	.max_attr = DEVLINK_ATTR_MAX,
100 	.table = devlink_dl_reload_stats_policy,
101 };
102 
103 struct ynl_policy_attr devlink_dl_dev_stats_policy[DEVLINK_ATTR_MAX + 1] = {
104 	[DEVLINK_ATTR_RELOAD_STATS] = { .name = "reload-stats", .type = YNL_PT_NEST, .nest = &devlink_dl_reload_stats_nest, },
105 	[DEVLINK_ATTR_REMOTE_RELOAD_STATS] = { .name = "remote-reload-stats", .type = YNL_PT_NEST, .nest = &devlink_dl_reload_stats_nest, },
106 };
107 
108 struct ynl_policy_nest devlink_dl_dev_stats_nest = {
109 	.max_attr = DEVLINK_ATTR_MAX,
110 	.table = devlink_dl_dev_stats_policy,
111 };
112 
113 struct ynl_policy_attr devlink_policy[DEVLINK_ATTR_MAX + 1] = {
114 	[DEVLINK_ATTR_BUS_NAME] = { .name = "bus-name", .type = YNL_PT_NUL_STR, },
115 	[DEVLINK_ATTR_DEV_NAME] = { .name = "dev-name", .type = YNL_PT_NUL_STR, },
116 	[DEVLINK_ATTR_PORT_INDEX] = { .name = "port-index", .type = YNL_PT_U32, },
117 	[DEVLINK_ATTR_SB_INDEX] = { .name = "sb-index", .type = YNL_PT_U32, },
118 	[DEVLINK_ATTR_SB_POOL_INDEX] = { .name = "sb-pool-index", .type = YNL_PT_U16, },
119 	[DEVLINK_ATTR_SB_POOL_TYPE] = { .name = "sb-pool-type", .type = YNL_PT_U8, },
120 	[DEVLINK_ATTR_SB_TC_INDEX] = { .name = "sb-tc-index", .type = YNL_PT_U16, },
121 	[DEVLINK_ATTR_PARAM_NAME] = { .name = "param-name", .type = YNL_PT_NUL_STR, },
122 	[DEVLINK_ATTR_REGION_NAME] = { .name = "region-name", .type = YNL_PT_NUL_STR, },
123 	[DEVLINK_ATTR_INFO_DRIVER_NAME] = { .name = "info-driver-name", .type = YNL_PT_NUL_STR, },
124 	[DEVLINK_ATTR_INFO_SERIAL_NUMBER] = { .name = "info-serial-number", .type = YNL_PT_NUL_STR, },
125 	[DEVLINK_ATTR_INFO_VERSION_FIXED] = { .name = "info-version-fixed", .type = YNL_PT_NEST, .nest = &devlink_dl_info_version_nest, },
126 	[DEVLINK_ATTR_INFO_VERSION_RUNNING] = { .name = "info-version-running", .type = YNL_PT_NEST, .nest = &devlink_dl_info_version_nest, },
127 	[DEVLINK_ATTR_INFO_VERSION_STORED] = { .name = "info-version-stored", .type = YNL_PT_NEST, .nest = &devlink_dl_info_version_nest, },
128 	[DEVLINK_ATTR_INFO_VERSION_NAME] = { .name = "info-version-name", .type = YNL_PT_NUL_STR, },
129 	[DEVLINK_ATTR_INFO_VERSION_VALUE] = { .name = "info-version-value", .type = YNL_PT_NUL_STR, },
130 	[DEVLINK_ATTR_HEALTH_REPORTER_NAME] = { .name = "health-reporter-name", .type = YNL_PT_NUL_STR, },
131 	[DEVLINK_ATTR_TRAP_NAME] = { .name = "trap-name", .type = YNL_PT_NUL_STR, },
132 	[DEVLINK_ATTR_TRAP_GROUP_NAME] = { .name = "trap-group-name", .type = YNL_PT_NUL_STR, },
133 	[DEVLINK_ATTR_RELOAD_FAILED] = { .name = "reload-failed", .type = YNL_PT_U8, },
134 	[DEVLINK_ATTR_TRAP_POLICER_ID] = { .name = "trap-policer-id", .type = YNL_PT_U32, },
135 	[DEVLINK_ATTR_RELOAD_ACTION] = { .name = "reload-action", .type = YNL_PT_U8, },
136 	[DEVLINK_ATTR_DEV_STATS] = { .name = "dev-stats", .type = YNL_PT_NEST, .nest = &devlink_dl_dev_stats_nest, },
137 	[DEVLINK_ATTR_RELOAD_STATS] = { .name = "reload-stats", .type = YNL_PT_NEST, .nest = &devlink_dl_reload_stats_nest, },
138 	[DEVLINK_ATTR_RELOAD_STATS_ENTRY] = { .name = "reload-stats-entry", .type = YNL_PT_NEST, .nest = &devlink_dl_reload_stats_entry_nest, },
139 	[DEVLINK_ATTR_RELOAD_STATS_LIMIT] = { .name = "reload-stats-limit", .type = YNL_PT_U8, },
140 	[DEVLINK_ATTR_RELOAD_STATS_VALUE] = { .name = "reload-stats-value", .type = YNL_PT_U32, },
141 	[DEVLINK_ATTR_REMOTE_RELOAD_STATS] = { .name = "remote-reload-stats", .type = YNL_PT_NEST, .nest = &devlink_dl_reload_stats_nest, },
142 	[DEVLINK_ATTR_RELOAD_ACTION_INFO] = { .name = "reload-action-info", .type = YNL_PT_NEST, .nest = &devlink_dl_reload_act_info_nest, },
143 	[DEVLINK_ATTR_RELOAD_ACTION_STATS] = { .name = "reload-action-stats", .type = YNL_PT_NEST, .nest = &devlink_dl_reload_act_stats_nest, },
144 	[DEVLINK_ATTR_RATE_NODE_NAME] = { .name = "rate-node-name", .type = YNL_PT_NUL_STR, },
145 	[DEVLINK_ATTR_LINECARD_INDEX] = { .name = "linecard-index", .type = YNL_PT_U32, },
146 };
147 
148 struct ynl_policy_nest devlink_nest = {
149 	.max_attr = DEVLINK_ATTR_MAX,
150 	.table = devlink_policy,
151 };
152 
153 /* Common nested types */
154 void devlink_dl_info_version_free(struct devlink_dl_info_version *obj)
155 {
156 	free(obj->info_version_name);
157 	free(obj->info_version_value);
158 }
159 
160 int devlink_dl_info_version_parse(struct ynl_parse_arg *yarg,
161 				  const struct nlattr *nested)
162 {
163 	struct devlink_dl_info_version *dst = yarg->data;
164 	const struct nlattr *attr;
165 
166 	mnl_attr_for_each_nested(attr, nested) {
167 		unsigned int type = mnl_attr_get_type(attr);
168 
169 		if (type == DEVLINK_ATTR_INFO_VERSION_NAME) {
170 			unsigned int len;
171 
172 			if (ynl_attr_validate(yarg, attr))
173 				return MNL_CB_ERROR;
174 
175 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
176 			dst->_present.info_version_name_len = len;
177 			dst->info_version_name = malloc(len + 1);
178 			memcpy(dst->info_version_name, mnl_attr_get_str(attr), len);
179 			dst->info_version_name[len] = 0;
180 		} else if (type == DEVLINK_ATTR_INFO_VERSION_VALUE) {
181 			unsigned int len;
182 
183 			if (ynl_attr_validate(yarg, attr))
184 				return MNL_CB_ERROR;
185 
186 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
187 			dst->_present.info_version_value_len = len;
188 			dst->info_version_value = malloc(len + 1);
189 			memcpy(dst->info_version_value, mnl_attr_get_str(attr), len);
190 			dst->info_version_value[len] = 0;
191 		}
192 	}
193 
194 	return 0;
195 }
196 
197 void
198 devlink_dl_reload_stats_entry_free(struct devlink_dl_reload_stats_entry *obj)
199 {
200 }
201 
202 int devlink_dl_reload_stats_entry_parse(struct ynl_parse_arg *yarg,
203 					const struct nlattr *nested)
204 {
205 	struct devlink_dl_reload_stats_entry *dst = yarg->data;
206 	const struct nlattr *attr;
207 
208 	mnl_attr_for_each_nested(attr, nested) {
209 		unsigned int type = mnl_attr_get_type(attr);
210 
211 		if (type == DEVLINK_ATTR_RELOAD_STATS_LIMIT) {
212 			if (ynl_attr_validate(yarg, attr))
213 				return MNL_CB_ERROR;
214 			dst->_present.reload_stats_limit = 1;
215 			dst->reload_stats_limit = mnl_attr_get_u8(attr);
216 		} else if (type == DEVLINK_ATTR_RELOAD_STATS_VALUE) {
217 			if (ynl_attr_validate(yarg, attr))
218 				return MNL_CB_ERROR;
219 			dst->_present.reload_stats_value = 1;
220 			dst->reload_stats_value = mnl_attr_get_u32(attr);
221 		}
222 	}
223 
224 	return 0;
225 }
226 
227 void devlink_dl_reload_act_stats_free(struct devlink_dl_reload_act_stats *obj)
228 {
229 	unsigned int i;
230 
231 	for (i = 0; i < obj->n_reload_stats_entry; i++)
232 		devlink_dl_reload_stats_entry_free(&obj->reload_stats_entry[i]);
233 	free(obj->reload_stats_entry);
234 }
235 
236 int devlink_dl_reload_act_stats_parse(struct ynl_parse_arg *yarg,
237 				      const struct nlattr *nested)
238 {
239 	struct devlink_dl_reload_act_stats *dst = yarg->data;
240 	unsigned int n_reload_stats_entry = 0;
241 	const struct nlattr *attr;
242 	struct ynl_parse_arg parg;
243 	int i;
244 
245 	parg.ys = yarg->ys;
246 
247 	if (dst->reload_stats_entry)
248 		return ynl_error_parse(yarg, "attribute already present (dl-reload-act-stats.reload-stats-entry)");
249 
250 	mnl_attr_for_each_nested(attr, nested) {
251 		unsigned int type = mnl_attr_get_type(attr);
252 
253 		if (type == DEVLINK_ATTR_RELOAD_STATS_ENTRY) {
254 			n_reload_stats_entry++;
255 		}
256 	}
257 
258 	if (n_reload_stats_entry) {
259 		dst->reload_stats_entry = calloc(n_reload_stats_entry, sizeof(*dst->reload_stats_entry));
260 		dst->n_reload_stats_entry = n_reload_stats_entry;
261 		i = 0;
262 		parg.rsp_policy = &devlink_dl_reload_stats_entry_nest;
263 		mnl_attr_for_each_nested(attr, nested) {
264 			if (mnl_attr_get_type(attr) == DEVLINK_ATTR_RELOAD_STATS_ENTRY) {
265 				parg.data = &dst->reload_stats_entry[i];
266 				if (devlink_dl_reload_stats_entry_parse(&parg, attr))
267 					return MNL_CB_ERROR;
268 				i++;
269 			}
270 		}
271 	}
272 
273 	return 0;
274 }
275 
276 void devlink_dl_reload_act_info_free(struct devlink_dl_reload_act_info *obj)
277 {
278 	unsigned int i;
279 
280 	for (i = 0; i < obj->n_reload_action_stats; i++)
281 		devlink_dl_reload_act_stats_free(&obj->reload_action_stats[i]);
282 	free(obj->reload_action_stats);
283 }
284 
285 int devlink_dl_reload_act_info_parse(struct ynl_parse_arg *yarg,
286 				     const struct nlattr *nested)
287 {
288 	struct devlink_dl_reload_act_info *dst = yarg->data;
289 	unsigned int n_reload_action_stats = 0;
290 	const struct nlattr *attr;
291 	struct ynl_parse_arg parg;
292 	int i;
293 
294 	parg.ys = yarg->ys;
295 
296 	if (dst->reload_action_stats)
297 		return ynl_error_parse(yarg, "attribute already present (dl-reload-act-info.reload-action-stats)");
298 
299 	mnl_attr_for_each_nested(attr, nested) {
300 		unsigned int type = mnl_attr_get_type(attr);
301 
302 		if (type == DEVLINK_ATTR_RELOAD_ACTION) {
303 			if (ynl_attr_validate(yarg, attr))
304 				return MNL_CB_ERROR;
305 			dst->_present.reload_action = 1;
306 			dst->reload_action = mnl_attr_get_u8(attr);
307 		} else if (type == DEVLINK_ATTR_RELOAD_ACTION_STATS) {
308 			n_reload_action_stats++;
309 		}
310 	}
311 
312 	if (n_reload_action_stats) {
313 		dst->reload_action_stats = calloc(n_reload_action_stats, sizeof(*dst->reload_action_stats));
314 		dst->n_reload_action_stats = n_reload_action_stats;
315 		i = 0;
316 		parg.rsp_policy = &devlink_dl_reload_act_stats_nest;
317 		mnl_attr_for_each_nested(attr, nested) {
318 			if (mnl_attr_get_type(attr) == DEVLINK_ATTR_RELOAD_ACTION_STATS) {
319 				parg.data = &dst->reload_action_stats[i];
320 				if (devlink_dl_reload_act_stats_parse(&parg, attr))
321 					return MNL_CB_ERROR;
322 				i++;
323 			}
324 		}
325 	}
326 
327 	return 0;
328 }
329 
330 void devlink_dl_reload_stats_free(struct devlink_dl_reload_stats *obj)
331 {
332 	unsigned int i;
333 
334 	for (i = 0; i < obj->n_reload_action_info; i++)
335 		devlink_dl_reload_act_info_free(&obj->reload_action_info[i]);
336 	free(obj->reload_action_info);
337 }
338 
339 int devlink_dl_reload_stats_parse(struct ynl_parse_arg *yarg,
340 				  const struct nlattr *nested)
341 {
342 	struct devlink_dl_reload_stats *dst = yarg->data;
343 	unsigned int n_reload_action_info = 0;
344 	const struct nlattr *attr;
345 	struct ynl_parse_arg parg;
346 	int i;
347 
348 	parg.ys = yarg->ys;
349 
350 	if (dst->reload_action_info)
351 		return ynl_error_parse(yarg, "attribute already present (dl-reload-stats.reload-action-info)");
352 
353 	mnl_attr_for_each_nested(attr, nested) {
354 		unsigned int type = mnl_attr_get_type(attr);
355 
356 		if (type == DEVLINK_ATTR_RELOAD_ACTION_INFO) {
357 			n_reload_action_info++;
358 		}
359 	}
360 
361 	if (n_reload_action_info) {
362 		dst->reload_action_info = calloc(n_reload_action_info, sizeof(*dst->reload_action_info));
363 		dst->n_reload_action_info = n_reload_action_info;
364 		i = 0;
365 		parg.rsp_policy = &devlink_dl_reload_act_info_nest;
366 		mnl_attr_for_each_nested(attr, nested) {
367 			if (mnl_attr_get_type(attr) == DEVLINK_ATTR_RELOAD_ACTION_INFO) {
368 				parg.data = &dst->reload_action_info[i];
369 				if (devlink_dl_reload_act_info_parse(&parg, attr))
370 					return MNL_CB_ERROR;
371 				i++;
372 			}
373 		}
374 	}
375 
376 	return 0;
377 }
378 
379 void devlink_dl_dev_stats_free(struct devlink_dl_dev_stats *obj)
380 {
381 	devlink_dl_reload_stats_free(&obj->reload_stats);
382 	devlink_dl_reload_stats_free(&obj->remote_reload_stats);
383 }
384 
385 int devlink_dl_dev_stats_parse(struct ynl_parse_arg *yarg,
386 			       const struct nlattr *nested)
387 {
388 	struct devlink_dl_dev_stats *dst = yarg->data;
389 	const struct nlattr *attr;
390 	struct ynl_parse_arg parg;
391 
392 	parg.ys = yarg->ys;
393 
394 	mnl_attr_for_each_nested(attr, nested) {
395 		unsigned int type = mnl_attr_get_type(attr);
396 
397 		if (type == DEVLINK_ATTR_RELOAD_STATS) {
398 			if (ynl_attr_validate(yarg, attr))
399 				return MNL_CB_ERROR;
400 			dst->_present.reload_stats = 1;
401 
402 			parg.rsp_policy = &devlink_dl_reload_stats_nest;
403 			parg.data = &dst->reload_stats;
404 			if (devlink_dl_reload_stats_parse(&parg, attr))
405 				return MNL_CB_ERROR;
406 		} else if (type == DEVLINK_ATTR_REMOTE_RELOAD_STATS) {
407 			if (ynl_attr_validate(yarg, attr))
408 				return MNL_CB_ERROR;
409 			dst->_present.remote_reload_stats = 1;
410 
411 			parg.rsp_policy = &devlink_dl_reload_stats_nest;
412 			parg.data = &dst->remote_reload_stats;
413 			if (devlink_dl_reload_stats_parse(&parg, attr))
414 				return MNL_CB_ERROR;
415 		}
416 	}
417 
418 	return 0;
419 }
420 
421 /* ============== DEVLINK_CMD_GET ============== */
422 /* DEVLINK_CMD_GET - do */
423 void devlink_get_req_free(struct devlink_get_req *req)
424 {
425 	free(req->bus_name);
426 	free(req->dev_name);
427 	free(req);
428 }
429 
430 void devlink_get_rsp_free(struct devlink_get_rsp *rsp)
431 {
432 	free(rsp->bus_name);
433 	free(rsp->dev_name);
434 	devlink_dl_dev_stats_free(&rsp->dev_stats);
435 	free(rsp);
436 }
437 
438 int devlink_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
439 {
440 	struct ynl_parse_arg *yarg = data;
441 	struct devlink_get_rsp *dst;
442 	const struct nlattr *attr;
443 	struct ynl_parse_arg parg;
444 
445 	dst = yarg->data;
446 	parg.ys = yarg->ys;
447 
448 	mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
449 		unsigned int type = mnl_attr_get_type(attr);
450 
451 		if (type == DEVLINK_ATTR_BUS_NAME) {
452 			unsigned int len;
453 
454 			if (ynl_attr_validate(yarg, attr))
455 				return MNL_CB_ERROR;
456 
457 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
458 			dst->_present.bus_name_len = len;
459 			dst->bus_name = malloc(len + 1);
460 			memcpy(dst->bus_name, mnl_attr_get_str(attr), len);
461 			dst->bus_name[len] = 0;
462 		} else if (type == DEVLINK_ATTR_DEV_NAME) {
463 			unsigned int len;
464 
465 			if (ynl_attr_validate(yarg, attr))
466 				return MNL_CB_ERROR;
467 
468 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
469 			dst->_present.dev_name_len = len;
470 			dst->dev_name = malloc(len + 1);
471 			memcpy(dst->dev_name, mnl_attr_get_str(attr), len);
472 			dst->dev_name[len] = 0;
473 		} else if (type == DEVLINK_ATTR_RELOAD_FAILED) {
474 			if (ynl_attr_validate(yarg, attr))
475 				return MNL_CB_ERROR;
476 			dst->_present.reload_failed = 1;
477 			dst->reload_failed = mnl_attr_get_u8(attr);
478 		} else if (type == DEVLINK_ATTR_RELOAD_ACTION) {
479 			if (ynl_attr_validate(yarg, attr))
480 				return MNL_CB_ERROR;
481 			dst->_present.reload_action = 1;
482 			dst->reload_action = mnl_attr_get_u8(attr);
483 		} else if (type == DEVLINK_ATTR_DEV_STATS) {
484 			if (ynl_attr_validate(yarg, attr))
485 				return MNL_CB_ERROR;
486 			dst->_present.dev_stats = 1;
487 
488 			parg.rsp_policy = &devlink_dl_dev_stats_nest;
489 			parg.data = &dst->dev_stats;
490 			if (devlink_dl_dev_stats_parse(&parg, attr))
491 				return MNL_CB_ERROR;
492 		}
493 	}
494 
495 	return MNL_CB_OK;
496 }
497 
498 struct devlink_get_rsp *
499 devlink_get(struct ynl_sock *ys, struct devlink_get_req *req)
500 {
501 	struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
502 	struct devlink_get_rsp *rsp;
503 	struct nlmsghdr *nlh;
504 	int err;
505 
506 	nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_GET, 1);
507 	ys->req_policy = &devlink_nest;
508 	yrs.yarg.rsp_policy = &devlink_nest;
509 
510 	if (req->_present.bus_name_len)
511 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
512 	if (req->_present.dev_name_len)
513 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
514 
515 	rsp = calloc(1, sizeof(*rsp));
516 	yrs.yarg.data = rsp;
517 	yrs.cb = devlink_get_rsp_parse;
518 	yrs.rsp_cmd = 3;
519 
520 	err = ynl_exec(ys, nlh, &yrs);
521 	if (err < 0)
522 		goto err_free;
523 
524 	return rsp;
525 
526 err_free:
527 	devlink_get_rsp_free(rsp);
528 	return NULL;
529 }
530 
531 /* DEVLINK_CMD_GET - dump */
532 void devlink_get_list_free(struct devlink_get_list *rsp)
533 {
534 	struct devlink_get_list *next = rsp;
535 
536 	while ((void *)next != YNL_LIST_END) {
537 		rsp = next;
538 		next = rsp->next;
539 
540 		free(rsp->obj.bus_name);
541 		free(rsp->obj.dev_name);
542 		devlink_dl_dev_stats_free(&rsp->obj.dev_stats);
543 		free(rsp);
544 	}
545 }
546 
547 struct devlink_get_list *devlink_get_dump(struct ynl_sock *ys)
548 {
549 	struct ynl_dump_state yds = {};
550 	struct nlmsghdr *nlh;
551 	int err;
552 
553 	yds.ys = ys;
554 	yds.alloc_sz = sizeof(struct devlink_get_list);
555 	yds.cb = devlink_get_rsp_parse;
556 	yds.rsp_cmd = 3;
557 	yds.rsp_policy = &devlink_nest;
558 
559 	nlh = ynl_gemsg_start_dump(ys, ys->family_id, DEVLINK_CMD_GET, 1);
560 
561 	err = ynl_exec_dump(ys, nlh, &yds);
562 	if (err < 0)
563 		goto free_list;
564 
565 	return yds.first;
566 
567 free_list:
568 	devlink_get_list_free(yds.first);
569 	return NULL;
570 }
571 
572 /* ============== DEVLINK_CMD_PORT_GET ============== */
573 /* DEVLINK_CMD_PORT_GET - do */
574 void devlink_port_get_req_free(struct devlink_port_get_req *req)
575 {
576 	free(req->bus_name);
577 	free(req->dev_name);
578 	free(req);
579 }
580 
581 void devlink_port_get_rsp_free(struct devlink_port_get_rsp *rsp)
582 {
583 	free(rsp->bus_name);
584 	free(rsp->dev_name);
585 	free(rsp);
586 }
587 
588 int devlink_port_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
589 {
590 	struct ynl_parse_arg *yarg = data;
591 	struct devlink_port_get_rsp *dst;
592 	const struct nlattr *attr;
593 
594 	dst = yarg->data;
595 
596 	mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
597 		unsigned int type = mnl_attr_get_type(attr);
598 
599 		if (type == DEVLINK_ATTR_BUS_NAME) {
600 			unsigned int len;
601 
602 			if (ynl_attr_validate(yarg, attr))
603 				return MNL_CB_ERROR;
604 
605 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
606 			dst->_present.bus_name_len = len;
607 			dst->bus_name = malloc(len + 1);
608 			memcpy(dst->bus_name, mnl_attr_get_str(attr), len);
609 			dst->bus_name[len] = 0;
610 		} else if (type == DEVLINK_ATTR_DEV_NAME) {
611 			unsigned int len;
612 
613 			if (ynl_attr_validate(yarg, attr))
614 				return MNL_CB_ERROR;
615 
616 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
617 			dst->_present.dev_name_len = len;
618 			dst->dev_name = malloc(len + 1);
619 			memcpy(dst->dev_name, mnl_attr_get_str(attr), len);
620 			dst->dev_name[len] = 0;
621 		} else if (type == DEVLINK_ATTR_PORT_INDEX) {
622 			if (ynl_attr_validate(yarg, attr))
623 				return MNL_CB_ERROR;
624 			dst->_present.port_index = 1;
625 			dst->port_index = mnl_attr_get_u32(attr);
626 		}
627 	}
628 
629 	return MNL_CB_OK;
630 }
631 
632 struct devlink_port_get_rsp *
633 devlink_port_get(struct ynl_sock *ys, struct devlink_port_get_req *req)
634 {
635 	struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
636 	struct devlink_port_get_rsp *rsp;
637 	struct nlmsghdr *nlh;
638 	int err;
639 
640 	nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_PORT_GET, 1);
641 	ys->req_policy = &devlink_nest;
642 	yrs.yarg.rsp_policy = &devlink_nest;
643 
644 	if (req->_present.bus_name_len)
645 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
646 	if (req->_present.dev_name_len)
647 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
648 	if (req->_present.port_index)
649 		mnl_attr_put_u32(nlh, DEVLINK_ATTR_PORT_INDEX, req->port_index);
650 
651 	rsp = calloc(1, sizeof(*rsp));
652 	yrs.yarg.data = rsp;
653 	yrs.cb = devlink_port_get_rsp_parse;
654 	yrs.rsp_cmd = 7;
655 
656 	err = ynl_exec(ys, nlh, &yrs);
657 	if (err < 0)
658 		goto err_free;
659 
660 	return rsp;
661 
662 err_free:
663 	devlink_port_get_rsp_free(rsp);
664 	return NULL;
665 }
666 
667 /* DEVLINK_CMD_PORT_GET - dump */
668 int devlink_port_get_rsp_dump_parse(const struct nlmsghdr *nlh, void *data)
669 {
670 	struct devlink_port_get_rsp_dump *dst;
671 	struct ynl_parse_arg *yarg = data;
672 	const struct nlattr *attr;
673 
674 	dst = yarg->data;
675 
676 	mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
677 		unsigned int type = mnl_attr_get_type(attr);
678 
679 		if (type == DEVLINK_ATTR_BUS_NAME) {
680 			unsigned int len;
681 
682 			if (ynl_attr_validate(yarg, attr))
683 				return MNL_CB_ERROR;
684 
685 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
686 			dst->_present.bus_name_len = len;
687 			dst->bus_name = malloc(len + 1);
688 			memcpy(dst->bus_name, mnl_attr_get_str(attr), len);
689 			dst->bus_name[len] = 0;
690 		} else if (type == DEVLINK_ATTR_DEV_NAME) {
691 			unsigned int len;
692 
693 			if (ynl_attr_validate(yarg, attr))
694 				return MNL_CB_ERROR;
695 
696 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
697 			dst->_present.dev_name_len = len;
698 			dst->dev_name = malloc(len + 1);
699 			memcpy(dst->dev_name, mnl_attr_get_str(attr), len);
700 			dst->dev_name[len] = 0;
701 		} else if (type == DEVLINK_ATTR_PORT_INDEX) {
702 			if (ynl_attr_validate(yarg, attr))
703 				return MNL_CB_ERROR;
704 			dst->_present.port_index = 1;
705 			dst->port_index = mnl_attr_get_u32(attr);
706 		}
707 	}
708 
709 	return MNL_CB_OK;
710 }
711 
712 void devlink_port_get_rsp_list_free(struct devlink_port_get_rsp_list *rsp)
713 {
714 	struct devlink_port_get_rsp_list *next = rsp;
715 
716 	while ((void *)next != YNL_LIST_END) {
717 		rsp = next;
718 		next = rsp->next;
719 
720 		free(rsp->obj.bus_name);
721 		free(rsp->obj.dev_name);
722 		free(rsp);
723 	}
724 }
725 
726 struct devlink_port_get_rsp_list *
727 devlink_port_get_dump(struct ynl_sock *ys,
728 		      struct devlink_port_get_req_dump *req)
729 {
730 	struct ynl_dump_state yds = {};
731 	struct nlmsghdr *nlh;
732 	int err;
733 
734 	yds.ys = ys;
735 	yds.alloc_sz = sizeof(struct devlink_port_get_rsp_list);
736 	yds.cb = devlink_port_get_rsp_dump_parse;
737 	yds.rsp_cmd = 7;
738 	yds.rsp_policy = &devlink_nest;
739 
740 	nlh = ynl_gemsg_start_dump(ys, ys->family_id, DEVLINK_CMD_PORT_GET, 1);
741 	ys->req_policy = &devlink_nest;
742 
743 	if (req->_present.bus_name_len)
744 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
745 	if (req->_present.dev_name_len)
746 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
747 
748 	err = ynl_exec_dump(ys, nlh, &yds);
749 	if (err < 0)
750 		goto free_list;
751 
752 	return yds.first;
753 
754 free_list:
755 	devlink_port_get_rsp_list_free(yds.first);
756 	return NULL;
757 }
758 
759 /* ============== DEVLINK_CMD_SB_GET ============== */
760 /* DEVLINK_CMD_SB_GET - do */
761 void devlink_sb_get_req_free(struct devlink_sb_get_req *req)
762 {
763 	free(req->bus_name);
764 	free(req->dev_name);
765 	free(req);
766 }
767 
768 void devlink_sb_get_rsp_free(struct devlink_sb_get_rsp *rsp)
769 {
770 	free(rsp->bus_name);
771 	free(rsp->dev_name);
772 	free(rsp);
773 }
774 
775 int devlink_sb_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
776 {
777 	struct ynl_parse_arg *yarg = data;
778 	struct devlink_sb_get_rsp *dst;
779 	const struct nlattr *attr;
780 
781 	dst = yarg->data;
782 
783 	mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
784 		unsigned int type = mnl_attr_get_type(attr);
785 
786 		if (type == DEVLINK_ATTR_BUS_NAME) {
787 			unsigned int len;
788 
789 			if (ynl_attr_validate(yarg, attr))
790 				return MNL_CB_ERROR;
791 
792 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
793 			dst->_present.bus_name_len = len;
794 			dst->bus_name = malloc(len + 1);
795 			memcpy(dst->bus_name, mnl_attr_get_str(attr), len);
796 			dst->bus_name[len] = 0;
797 		} else if (type == DEVLINK_ATTR_DEV_NAME) {
798 			unsigned int len;
799 
800 			if (ynl_attr_validate(yarg, attr))
801 				return MNL_CB_ERROR;
802 
803 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
804 			dst->_present.dev_name_len = len;
805 			dst->dev_name = malloc(len + 1);
806 			memcpy(dst->dev_name, mnl_attr_get_str(attr), len);
807 			dst->dev_name[len] = 0;
808 		} else if (type == DEVLINK_ATTR_SB_INDEX) {
809 			if (ynl_attr_validate(yarg, attr))
810 				return MNL_CB_ERROR;
811 			dst->_present.sb_index = 1;
812 			dst->sb_index = mnl_attr_get_u32(attr);
813 		}
814 	}
815 
816 	return MNL_CB_OK;
817 }
818 
819 struct devlink_sb_get_rsp *
820 devlink_sb_get(struct ynl_sock *ys, struct devlink_sb_get_req *req)
821 {
822 	struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
823 	struct devlink_sb_get_rsp *rsp;
824 	struct nlmsghdr *nlh;
825 	int err;
826 
827 	nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_SB_GET, 1);
828 	ys->req_policy = &devlink_nest;
829 	yrs.yarg.rsp_policy = &devlink_nest;
830 
831 	if (req->_present.bus_name_len)
832 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
833 	if (req->_present.dev_name_len)
834 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
835 	if (req->_present.sb_index)
836 		mnl_attr_put_u32(nlh, DEVLINK_ATTR_SB_INDEX, req->sb_index);
837 
838 	rsp = calloc(1, sizeof(*rsp));
839 	yrs.yarg.data = rsp;
840 	yrs.cb = devlink_sb_get_rsp_parse;
841 	yrs.rsp_cmd = 13;
842 
843 	err = ynl_exec(ys, nlh, &yrs);
844 	if (err < 0)
845 		goto err_free;
846 
847 	return rsp;
848 
849 err_free:
850 	devlink_sb_get_rsp_free(rsp);
851 	return NULL;
852 }
853 
854 /* DEVLINK_CMD_SB_GET - dump */
855 void devlink_sb_get_list_free(struct devlink_sb_get_list *rsp)
856 {
857 	struct devlink_sb_get_list *next = rsp;
858 
859 	while ((void *)next != YNL_LIST_END) {
860 		rsp = next;
861 		next = rsp->next;
862 
863 		free(rsp->obj.bus_name);
864 		free(rsp->obj.dev_name);
865 		free(rsp);
866 	}
867 }
868 
869 struct devlink_sb_get_list *
870 devlink_sb_get_dump(struct ynl_sock *ys, struct devlink_sb_get_req_dump *req)
871 {
872 	struct ynl_dump_state yds = {};
873 	struct nlmsghdr *nlh;
874 	int err;
875 
876 	yds.ys = ys;
877 	yds.alloc_sz = sizeof(struct devlink_sb_get_list);
878 	yds.cb = devlink_sb_get_rsp_parse;
879 	yds.rsp_cmd = 13;
880 	yds.rsp_policy = &devlink_nest;
881 
882 	nlh = ynl_gemsg_start_dump(ys, ys->family_id, DEVLINK_CMD_SB_GET, 1);
883 	ys->req_policy = &devlink_nest;
884 
885 	if (req->_present.bus_name_len)
886 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
887 	if (req->_present.dev_name_len)
888 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
889 
890 	err = ynl_exec_dump(ys, nlh, &yds);
891 	if (err < 0)
892 		goto free_list;
893 
894 	return yds.first;
895 
896 free_list:
897 	devlink_sb_get_list_free(yds.first);
898 	return NULL;
899 }
900 
901 /* ============== DEVLINK_CMD_SB_POOL_GET ============== */
902 /* DEVLINK_CMD_SB_POOL_GET - do */
903 void devlink_sb_pool_get_req_free(struct devlink_sb_pool_get_req *req)
904 {
905 	free(req->bus_name);
906 	free(req->dev_name);
907 	free(req);
908 }
909 
910 void devlink_sb_pool_get_rsp_free(struct devlink_sb_pool_get_rsp *rsp)
911 {
912 	free(rsp->bus_name);
913 	free(rsp->dev_name);
914 	free(rsp);
915 }
916 
917 int devlink_sb_pool_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
918 {
919 	struct devlink_sb_pool_get_rsp *dst;
920 	struct ynl_parse_arg *yarg = data;
921 	const struct nlattr *attr;
922 
923 	dst = yarg->data;
924 
925 	mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
926 		unsigned int type = mnl_attr_get_type(attr);
927 
928 		if (type == DEVLINK_ATTR_BUS_NAME) {
929 			unsigned int len;
930 
931 			if (ynl_attr_validate(yarg, attr))
932 				return MNL_CB_ERROR;
933 
934 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
935 			dst->_present.bus_name_len = len;
936 			dst->bus_name = malloc(len + 1);
937 			memcpy(dst->bus_name, mnl_attr_get_str(attr), len);
938 			dst->bus_name[len] = 0;
939 		} else if (type == DEVLINK_ATTR_DEV_NAME) {
940 			unsigned int len;
941 
942 			if (ynl_attr_validate(yarg, attr))
943 				return MNL_CB_ERROR;
944 
945 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
946 			dst->_present.dev_name_len = len;
947 			dst->dev_name = malloc(len + 1);
948 			memcpy(dst->dev_name, mnl_attr_get_str(attr), len);
949 			dst->dev_name[len] = 0;
950 		} else if (type == DEVLINK_ATTR_SB_INDEX) {
951 			if (ynl_attr_validate(yarg, attr))
952 				return MNL_CB_ERROR;
953 			dst->_present.sb_index = 1;
954 			dst->sb_index = mnl_attr_get_u32(attr);
955 		} else if (type == DEVLINK_ATTR_SB_POOL_INDEX) {
956 			if (ynl_attr_validate(yarg, attr))
957 				return MNL_CB_ERROR;
958 			dst->_present.sb_pool_index = 1;
959 			dst->sb_pool_index = mnl_attr_get_u16(attr);
960 		}
961 	}
962 
963 	return MNL_CB_OK;
964 }
965 
966 struct devlink_sb_pool_get_rsp *
967 devlink_sb_pool_get(struct ynl_sock *ys, struct devlink_sb_pool_get_req *req)
968 {
969 	struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
970 	struct devlink_sb_pool_get_rsp *rsp;
971 	struct nlmsghdr *nlh;
972 	int err;
973 
974 	nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_SB_POOL_GET, 1);
975 	ys->req_policy = &devlink_nest;
976 	yrs.yarg.rsp_policy = &devlink_nest;
977 
978 	if (req->_present.bus_name_len)
979 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
980 	if (req->_present.dev_name_len)
981 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
982 	if (req->_present.sb_index)
983 		mnl_attr_put_u32(nlh, DEVLINK_ATTR_SB_INDEX, req->sb_index);
984 	if (req->_present.sb_pool_index)
985 		mnl_attr_put_u16(nlh, DEVLINK_ATTR_SB_POOL_INDEX, req->sb_pool_index);
986 
987 	rsp = calloc(1, sizeof(*rsp));
988 	yrs.yarg.data = rsp;
989 	yrs.cb = devlink_sb_pool_get_rsp_parse;
990 	yrs.rsp_cmd = 17;
991 
992 	err = ynl_exec(ys, nlh, &yrs);
993 	if (err < 0)
994 		goto err_free;
995 
996 	return rsp;
997 
998 err_free:
999 	devlink_sb_pool_get_rsp_free(rsp);
1000 	return NULL;
1001 }
1002 
1003 /* DEVLINK_CMD_SB_POOL_GET - dump */
1004 void devlink_sb_pool_get_list_free(struct devlink_sb_pool_get_list *rsp)
1005 {
1006 	struct devlink_sb_pool_get_list *next = rsp;
1007 
1008 	while ((void *)next != YNL_LIST_END) {
1009 		rsp = next;
1010 		next = rsp->next;
1011 
1012 		free(rsp->obj.bus_name);
1013 		free(rsp->obj.dev_name);
1014 		free(rsp);
1015 	}
1016 }
1017 
1018 struct devlink_sb_pool_get_list *
1019 devlink_sb_pool_get_dump(struct ynl_sock *ys,
1020 			 struct devlink_sb_pool_get_req_dump *req)
1021 {
1022 	struct ynl_dump_state yds = {};
1023 	struct nlmsghdr *nlh;
1024 	int err;
1025 
1026 	yds.ys = ys;
1027 	yds.alloc_sz = sizeof(struct devlink_sb_pool_get_list);
1028 	yds.cb = devlink_sb_pool_get_rsp_parse;
1029 	yds.rsp_cmd = 17;
1030 	yds.rsp_policy = &devlink_nest;
1031 
1032 	nlh = ynl_gemsg_start_dump(ys, ys->family_id, DEVLINK_CMD_SB_POOL_GET, 1);
1033 	ys->req_policy = &devlink_nest;
1034 
1035 	if (req->_present.bus_name_len)
1036 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
1037 	if (req->_present.dev_name_len)
1038 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
1039 
1040 	err = ynl_exec_dump(ys, nlh, &yds);
1041 	if (err < 0)
1042 		goto free_list;
1043 
1044 	return yds.first;
1045 
1046 free_list:
1047 	devlink_sb_pool_get_list_free(yds.first);
1048 	return NULL;
1049 }
1050 
1051 /* ============== DEVLINK_CMD_SB_PORT_POOL_GET ============== */
1052 /* DEVLINK_CMD_SB_PORT_POOL_GET - do */
1053 void
1054 devlink_sb_port_pool_get_req_free(struct devlink_sb_port_pool_get_req *req)
1055 {
1056 	free(req->bus_name);
1057 	free(req->dev_name);
1058 	free(req);
1059 }
1060 
1061 void
1062 devlink_sb_port_pool_get_rsp_free(struct devlink_sb_port_pool_get_rsp *rsp)
1063 {
1064 	free(rsp->bus_name);
1065 	free(rsp->dev_name);
1066 	free(rsp);
1067 }
1068 
1069 int devlink_sb_port_pool_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
1070 {
1071 	struct devlink_sb_port_pool_get_rsp *dst;
1072 	struct ynl_parse_arg *yarg = data;
1073 	const struct nlattr *attr;
1074 
1075 	dst = yarg->data;
1076 
1077 	mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
1078 		unsigned int type = mnl_attr_get_type(attr);
1079 
1080 		if (type == DEVLINK_ATTR_BUS_NAME) {
1081 			unsigned int len;
1082 
1083 			if (ynl_attr_validate(yarg, attr))
1084 				return MNL_CB_ERROR;
1085 
1086 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1087 			dst->_present.bus_name_len = len;
1088 			dst->bus_name = malloc(len + 1);
1089 			memcpy(dst->bus_name, mnl_attr_get_str(attr), len);
1090 			dst->bus_name[len] = 0;
1091 		} else if (type == DEVLINK_ATTR_DEV_NAME) {
1092 			unsigned int len;
1093 
1094 			if (ynl_attr_validate(yarg, attr))
1095 				return MNL_CB_ERROR;
1096 
1097 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1098 			dst->_present.dev_name_len = len;
1099 			dst->dev_name = malloc(len + 1);
1100 			memcpy(dst->dev_name, mnl_attr_get_str(attr), len);
1101 			dst->dev_name[len] = 0;
1102 		} else if (type == DEVLINK_ATTR_PORT_INDEX) {
1103 			if (ynl_attr_validate(yarg, attr))
1104 				return MNL_CB_ERROR;
1105 			dst->_present.port_index = 1;
1106 			dst->port_index = mnl_attr_get_u32(attr);
1107 		} else if (type == DEVLINK_ATTR_SB_INDEX) {
1108 			if (ynl_attr_validate(yarg, attr))
1109 				return MNL_CB_ERROR;
1110 			dst->_present.sb_index = 1;
1111 			dst->sb_index = mnl_attr_get_u32(attr);
1112 		} else if (type == DEVLINK_ATTR_SB_POOL_INDEX) {
1113 			if (ynl_attr_validate(yarg, attr))
1114 				return MNL_CB_ERROR;
1115 			dst->_present.sb_pool_index = 1;
1116 			dst->sb_pool_index = mnl_attr_get_u16(attr);
1117 		}
1118 	}
1119 
1120 	return MNL_CB_OK;
1121 }
1122 
1123 struct devlink_sb_port_pool_get_rsp *
1124 devlink_sb_port_pool_get(struct ynl_sock *ys,
1125 			 struct devlink_sb_port_pool_get_req *req)
1126 {
1127 	struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
1128 	struct devlink_sb_port_pool_get_rsp *rsp;
1129 	struct nlmsghdr *nlh;
1130 	int err;
1131 
1132 	nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_SB_PORT_POOL_GET, 1);
1133 	ys->req_policy = &devlink_nest;
1134 	yrs.yarg.rsp_policy = &devlink_nest;
1135 
1136 	if (req->_present.bus_name_len)
1137 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
1138 	if (req->_present.dev_name_len)
1139 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
1140 	if (req->_present.port_index)
1141 		mnl_attr_put_u32(nlh, DEVLINK_ATTR_PORT_INDEX, req->port_index);
1142 	if (req->_present.sb_index)
1143 		mnl_attr_put_u32(nlh, DEVLINK_ATTR_SB_INDEX, req->sb_index);
1144 	if (req->_present.sb_pool_index)
1145 		mnl_attr_put_u16(nlh, DEVLINK_ATTR_SB_POOL_INDEX, req->sb_pool_index);
1146 
1147 	rsp = calloc(1, sizeof(*rsp));
1148 	yrs.yarg.data = rsp;
1149 	yrs.cb = devlink_sb_port_pool_get_rsp_parse;
1150 	yrs.rsp_cmd = 21;
1151 
1152 	err = ynl_exec(ys, nlh, &yrs);
1153 	if (err < 0)
1154 		goto err_free;
1155 
1156 	return rsp;
1157 
1158 err_free:
1159 	devlink_sb_port_pool_get_rsp_free(rsp);
1160 	return NULL;
1161 }
1162 
1163 /* DEVLINK_CMD_SB_PORT_POOL_GET - dump */
1164 void
1165 devlink_sb_port_pool_get_list_free(struct devlink_sb_port_pool_get_list *rsp)
1166 {
1167 	struct devlink_sb_port_pool_get_list *next = rsp;
1168 
1169 	while ((void *)next != YNL_LIST_END) {
1170 		rsp = next;
1171 		next = rsp->next;
1172 
1173 		free(rsp->obj.bus_name);
1174 		free(rsp->obj.dev_name);
1175 		free(rsp);
1176 	}
1177 }
1178 
1179 struct devlink_sb_port_pool_get_list *
1180 devlink_sb_port_pool_get_dump(struct ynl_sock *ys,
1181 			      struct devlink_sb_port_pool_get_req_dump *req)
1182 {
1183 	struct ynl_dump_state yds = {};
1184 	struct nlmsghdr *nlh;
1185 	int err;
1186 
1187 	yds.ys = ys;
1188 	yds.alloc_sz = sizeof(struct devlink_sb_port_pool_get_list);
1189 	yds.cb = devlink_sb_port_pool_get_rsp_parse;
1190 	yds.rsp_cmd = 21;
1191 	yds.rsp_policy = &devlink_nest;
1192 
1193 	nlh = ynl_gemsg_start_dump(ys, ys->family_id, DEVLINK_CMD_SB_PORT_POOL_GET, 1);
1194 	ys->req_policy = &devlink_nest;
1195 
1196 	if (req->_present.bus_name_len)
1197 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
1198 	if (req->_present.dev_name_len)
1199 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
1200 
1201 	err = ynl_exec_dump(ys, nlh, &yds);
1202 	if (err < 0)
1203 		goto free_list;
1204 
1205 	return yds.first;
1206 
1207 free_list:
1208 	devlink_sb_port_pool_get_list_free(yds.first);
1209 	return NULL;
1210 }
1211 
1212 /* ============== DEVLINK_CMD_SB_TC_POOL_BIND_GET ============== */
1213 /* DEVLINK_CMD_SB_TC_POOL_BIND_GET - do */
1214 void
1215 devlink_sb_tc_pool_bind_get_req_free(struct devlink_sb_tc_pool_bind_get_req *req)
1216 {
1217 	free(req->bus_name);
1218 	free(req->dev_name);
1219 	free(req);
1220 }
1221 
1222 void
1223 devlink_sb_tc_pool_bind_get_rsp_free(struct devlink_sb_tc_pool_bind_get_rsp *rsp)
1224 {
1225 	free(rsp->bus_name);
1226 	free(rsp->dev_name);
1227 	free(rsp);
1228 }
1229 
1230 int devlink_sb_tc_pool_bind_get_rsp_parse(const struct nlmsghdr *nlh,
1231 					  void *data)
1232 {
1233 	struct devlink_sb_tc_pool_bind_get_rsp *dst;
1234 	struct ynl_parse_arg *yarg = data;
1235 	const struct nlattr *attr;
1236 
1237 	dst = yarg->data;
1238 
1239 	mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
1240 		unsigned int type = mnl_attr_get_type(attr);
1241 
1242 		if (type == DEVLINK_ATTR_BUS_NAME) {
1243 			unsigned int len;
1244 
1245 			if (ynl_attr_validate(yarg, attr))
1246 				return MNL_CB_ERROR;
1247 
1248 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1249 			dst->_present.bus_name_len = len;
1250 			dst->bus_name = malloc(len + 1);
1251 			memcpy(dst->bus_name, mnl_attr_get_str(attr), len);
1252 			dst->bus_name[len] = 0;
1253 		} else if (type == DEVLINK_ATTR_DEV_NAME) {
1254 			unsigned int len;
1255 
1256 			if (ynl_attr_validate(yarg, attr))
1257 				return MNL_CB_ERROR;
1258 
1259 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1260 			dst->_present.dev_name_len = len;
1261 			dst->dev_name = malloc(len + 1);
1262 			memcpy(dst->dev_name, mnl_attr_get_str(attr), len);
1263 			dst->dev_name[len] = 0;
1264 		} else if (type == DEVLINK_ATTR_PORT_INDEX) {
1265 			if (ynl_attr_validate(yarg, attr))
1266 				return MNL_CB_ERROR;
1267 			dst->_present.port_index = 1;
1268 			dst->port_index = mnl_attr_get_u32(attr);
1269 		} else if (type == DEVLINK_ATTR_SB_INDEX) {
1270 			if (ynl_attr_validate(yarg, attr))
1271 				return MNL_CB_ERROR;
1272 			dst->_present.sb_index = 1;
1273 			dst->sb_index = mnl_attr_get_u32(attr);
1274 		} else if (type == DEVLINK_ATTR_SB_POOL_TYPE) {
1275 			if (ynl_attr_validate(yarg, attr))
1276 				return MNL_CB_ERROR;
1277 			dst->_present.sb_pool_type = 1;
1278 			dst->sb_pool_type = mnl_attr_get_u8(attr);
1279 		} else if (type == DEVLINK_ATTR_SB_TC_INDEX) {
1280 			if (ynl_attr_validate(yarg, attr))
1281 				return MNL_CB_ERROR;
1282 			dst->_present.sb_tc_index = 1;
1283 			dst->sb_tc_index = mnl_attr_get_u16(attr);
1284 		}
1285 	}
1286 
1287 	return MNL_CB_OK;
1288 }
1289 
1290 struct devlink_sb_tc_pool_bind_get_rsp *
1291 devlink_sb_tc_pool_bind_get(struct ynl_sock *ys,
1292 			    struct devlink_sb_tc_pool_bind_get_req *req)
1293 {
1294 	struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
1295 	struct devlink_sb_tc_pool_bind_get_rsp *rsp;
1296 	struct nlmsghdr *nlh;
1297 	int err;
1298 
1299 	nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_SB_TC_POOL_BIND_GET, 1);
1300 	ys->req_policy = &devlink_nest;
1301 	yrs.yarg.rsp_policy = &devlink_nest;
1302 
1303 	if (req->_present.bus_name_len)
1304 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
1305 	if (req->_present.dev_name_len)
1306 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
1307 	if (req->_present.port_index)
1308 		mnl_attr_put_u32(nlh, DEVLINK_ATTR_PORT_INDEX, req->port_index);
1309 	if (req->_present.sb_index)
1310 		mnl_attr_put_u32(nlh, DEVLINK_ATTR_SB_INDEX, req->sb_index);
1311 	if (req->_present.sb_pool_type)
1312 		mnl_attr_put_u8(nlh, DEVLINK_ATTR_SB_POOL_TYPE, req->sb_pool_type);
1313 	if (req->_present.sb_tc_index)
1314 		mnl_attr_put_u16(nlh, DEVLINK_ATTR_SB_TC_INDEX, req->sb_tc_index);
1315 
1316 	rsp = calloc(1, sizeof(*rsp));
1317 	yrs.yarg.data = rsp;
1318 	yrs.cb = devlink_sb_tc_pool_bind_get_rsp_parse;
1319 	yrs.rsp_cmd = 25;
1320 
1321 	err = ynl_exec(ys, nlh, &yrs);
1322 	if (err < 0)
1323 		goto err_free;
1324 
1325 	return rsp;
1326 
1327 err_free:
1328 	devlink_sb_tc_pool_bind_get_rsp_free(rsp);
1329 	return NULL;
1330 }
1331 
1332 /* DEVLINK_CMD_SB_TC_POOL_BIND_GET - dump */
1333 void
1334 devlink_sb_tc_pool_bind_get_list_free(struct devlink_sb_tc_pool_bind_get_list *rsp)
1335 {
1336 	struct devlink_sb_tc_pool_bind_get_list *next = rsp;
1337 
1338 	while ((void *)next != YNL_LIST_END) {
1339 		rsp = next;
1340 		next = rsp->next;
1341 
1342 		free(rsp->obj.bus_name);
1343 		free(rsp->obj.dev_name);
1344 		free(rsp);
1345 	}
1346 }
1347 
1348 struct devlink_sb_tc_pool_bind_get_list *
1349 devlink_sb_tc_pool_bind_get_dump(struct ynl_sock *ys,
1350 				 struct devlink_sb_tc_pool_bind_get_req_dump *req)
1351 {
1352 	struct ynl_dump_state yds = {};
1353 	struct nlmsghdr *nlh;
1354 	int err;
1355 
1356 	yds.ys = ys;
1357 	yds.alloc_sz = sizeof(struct devlink_sb_tc_pool_bind_get_list);
1358 	yds.cb = devlink_sb_tc_pool_bind_get_rsp_parse;
1359 	yds.rsp_cmd = 25;
1360 	yds.rsp_policy = &devlink_nest;
1361 
1362 	nlh = ynl_gemsg_start_dump(ys, ys->family_id, DEVLINK_CMD_SB_TC_POOL_BIND_GET, 1);
1363 	ys->req_policy = &devlink_nest;
1364 
1365 	if (req->_present.bus_name_len)
1366 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
1367 	if (req->_present.dev_name_len)
1368 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
1369 
1370 	err = ynl_exec_dump(ys, nlh, &yds);
1371 	if (err < 0)
1372 		goto free_list;
1373 
1374 	return yds.first;
1375 
1376 free_list:
1377 	devlink_sb_tc_pool_bind_get_list_free(yds.first);
1378 	return NULL;
1379 }
1380 
1381 /* ============== DEVLINK_CMD_PARAM_GET ============== */
1382 /* DEVLINK_CMD_PARAM_GET - do */
1383 void devlink_param_get_req_free(struct devlink_param_get_req *req)
1384 {
1385 	free(req->bus_name);
1386 	free(req->dev_name);
1387 	free(req->param_name);
1388 	free(req);
1389 }
1390 
1391 void devlink_param_get_rsp_free(struct devlink_param_get_rsp *rsp)
1392 {
1393 	free(rsp->bus_name);
1394 	free(rsp->dev_name);
1395 	free(rsp->param_name);
1396 	free(rsp);
1397 }
1398 
1399 int devlink_param_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
1400 {
1401 	struct devlink_param_get_rsp *dst;
1402 	struct ynl_parse_arg *yarg = data;
1403 	const struct nlattr *attr;
1404 
1405 	dst = yarg->data;
1406 
1407 	mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
1408 		unsigned int type = mnl_attr_get_type(attr);
1409 
1410 		if (type == DEVLINK_ATTR_BUS_NAME) {
1411 			unsigned int len;
1412 
1413 			if (ynl_attr_validate(yarg, attr))
1414 				return MNL_CB_ERROR;
1415 
1416 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1417 			dst->_present.bus_name_len = len;
1418 			dst->bus_name = malloc(len + 1);
1419 			memcpy(dst->bus_name, mnl_attr_get_str(attr), len);
1420 			dst->bus_name[len] = 0;
1421 		} else if (type == DEVLINK_ATTR_DEV_NAME) {
1422 			unsigned int len;
1423 
1424 			if (ynl_attr_validate(yarg, attr))
1425 				return MNL_CB_ERROR;
1426 
1427 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1428 			dst->_present.dev_name_len = len;
1429 			dst->dev_name = malloc(len + 1);
1430 			memcpy(dst->dev_name, mnl_attr_get_str(attr), len);
1431 			dst->dev_name[len] = 0;
1432 		} else if (type == DEVLINK_ATTR_PARAM_NAME) {
1433 			unsigned int len;
1434 
1435 			if (ynl_attr_validate(yarg, attr))
1436 				return MNL_CB_ERROR;
1437 
1438 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1439 			dst->_present.param_name_len = len;
1440 			dst->param_name = malloc(len + 1);
1441 			memcpy(dst->param_name, mnl_attr_get_str(attr), len);
1442 			dst->param_name[len] = 0;
1443 		}
1444 	}
1445 
1446 	return MNL_CB_OK;
1447 }
1448 
1449 struct devlink_param_get_rsp *
1450 devlink_param_get(struct ynl_sock *ys, struct devlink_param_get_req *req)
1451 {
1452 	struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
1453 	struct devlink_param_get_rsp *rsp;
1454 	struct nlmsghdr *nlh;
1455 	int err;
1456 
1457 	nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_PARAM_GET, 1);
1458 	ys->req_policy = &devlink_nest;
1459 	yrs.yarg.rsp_policy = &devlink_nest;
1460 
1461 	if (req->_present.bus_name_len)
1462 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
1463 	if (req->_present.dev_name_len)
1464 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
1465 	if (req->_present.param_name_len)
1466 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_PARAM_NAME, req->param_name);
1467 
1468 	rsp = calloc(1, sizeof(*rsp));
1469 	yrs.yarg.data = rsp;
1470 	yrs.cb = devlink_param_get_rsp_parse;
1471 	yrs.rsp_cmd = DEVLINK_CMD_PARAM_GET;
1472 
1473 	err = ynl_exec(ys, nlh, &yrs);
1474 	if (err < 0)
1475 		goto err_free;
1476 
1477 	return rsp;
1478 
1479 err_free:
1480 	devlink_param_get_rsp_free(rsp);
1481 	return NULL;
1482 }
1483 
1484 /* DEVLINK_CMD_PARAM_GET - dump */
1485 void devlink_param_get_list_free(struct devlink_param_get_list *rsp)
1486 {
1487 	struct devlink_param_get_list *next = rsp;
1488 
1489 	while ((void *)next != YNL_LIST_END) {
1490 		rsp = next;
1491 		next = rsp->next;
1492 
1493 		free(rsp->obj.bus_name);
1494 		free(rsp->obj.dev_name);
1495 		free(rsp->obj.param_name);
1496 		free(rsp);
1497 	}
1498 }
1499 
1500 struct devlink_param_get_list *
1501 devlink_param_get_dump(struct ynl_sock *ys,
1502 		       struct devlink_param_get_req_dump *req)
1503 {
1504 	struct ynl_dump_state yds = {};
1505 	struct nlmsghdr *nlh;
1506 	int err;
1507 
1508 	yds.ys = ys;
1509 	yds.alloc_sz = sizeof(struct devlink_param_get_list);
1510 	yds.cb = devlink_param_get_rsp_parse;
1511 	yds.rsp_cmd = DEVLINK_CMD_PARAM_GET;
1512 	yds.rsp_policy = &devlink_nest;
1513 
1514 	nlh = ynl_gemsg_start_dump(ys, ys->family_id, DEVLINK_CMD_PARAM_GET, 1);
1515 	ys->req_policy = &devlink_nest;
1516 
1517 	if (req->_present.bus_name_len)
1518 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
1519 	if (req->_present.dev_name_len)
1520 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
1521 
1522 	err = ynl_exec_dump(ys, nlh, &yds);
1523 	if (err < 0)
1524 		goto free_list;
1525 
1526 	return yds.first;
1527 
1528 free_list:
1529 	devlink_param_get_list_free(yds.first);
1530 	return NULL;
1531 }
1532 
1533 /* ============== DEVLINK_CMD_REGION_GET ============== */
1534 /* DEVLINK_CMD_REGION_GET - do */
1535 void devlink_region_get_req_free(struct devlink_region_get_req *req)
1536 {
1537 	free(req->bus_name);
1538 	free(req->dev_name);
1539 	free(req->region_name);
1540 	free(req);
1541 }
1542 
1543 void devlink_region_get_rsp_free(struct devlink_region_get_rsp *rsp)
1544 {
1545 	free(rsp->bus_name);
1546 	free(rsp->dev_name);
1547 	free(rsp->region_name);
1548 	free(rsp);
1549 }
1550 
1551 int devlink_region_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
1552 {
1553 	struct devlink_region_get_rsp *dst;
1554 	struct ynl_parse_arg *yarg = data;
1555 	const struct nlattr *attr;
1556 
1557 	dst = yarg->data;
1558 
1559 	mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
1560 		unsigned int type = mnl_attr_get_type(attr);
1561 
1562 		if (type == DEVLINK_ATTR_BUS_NAME) {
1563 			unsigned int len;
1564 
1565 			if (ynl_attr_validate(yarg, attr))
1566 				return MNL_CB_ERROR;
1567 
1568 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1569 			dst->_present.bus_name_len = len;
1570 			dst->bus_name = malloc(len + 1);
1571 			memcpy(dst->bus_name, mnl_attr_get_str(attr), len);
1572 			dst->bus_name[len] = 0;
1573 		} else if (type == DEVLINK_ATTR_DEV_NAME) {
1574 			unsigned int len;
1575 
1576 			if (ynl_attr_validate(yarg, attr))
1577 				return MNL_CB_ERROR;
1578 
1579 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1580 			dst->_present.dev_name_len = len;
1581 			dst->dev_name = malloc(len + 1);
1582 			memcpy(dst->dev_name, mnl_attr_get_str(attr), len);
1583 			dst->dev_name[len] = 0;
1584 		} else if (type == DEVLINK_ATTR_PORT_INDEX) {
1585 			if (ynl_attr_validate(yarg, attr))
1586 				return MNL_CB_ERROR;
1587 			dst->_present.port_index = 1;
1588 			dst->port_index = mnl_attr_get_u32(attr);
1589 		} else if (type == DEVLINK_ATTR_REGION_NAME) {
1590 			unsigned int len;
1591 
1592 			if (ynl_attr_validate(yarg, attr))
1593 				return MNL_CB_ERROR;
1594 
1595 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1596 			dst->_present.region_name_len = len;
1597 			dst->region_name = malloc(len + 1);
1598 			memcpy(dst->region_name, mnl_attr_get_str(attr), len);
1599 			dst->region_name[len] = 0;
1600 		}
1601 	}
1602 
1603 	return MNL_CB_OK;
1604 }
1605 
1606 struct devlink_region_get_rsp *
1607 devlink_region_get(struct ynl_sock *ys, struct devlink_region_get_req *req)
1608 {
1609 	struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
1610 	struct devlink_region_get_rsp *rsp;
1611 	struct nlmsghdr *nlh;
1612 	int err;
1613 
1614 	nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_REGION_GET, 1);
1615 	ys->req_policy = &devlink_nest;
1616 	yrs.yarg.rsp_policy = &devlink_nest;
1617 
1618 	if (req->_present.bus_name_len)
1619 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
1620 	if (req->_present.dev_name_len)
1621 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
1622 	if (req->_present.port_index)
1623 		mnl_attr_put_u32(nlh, DEVLINK_ATTR_PORT_INDEX, req->port_index);
1624 	if (req->_present.region_name_len)
1625 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_REGION_NAME, req->region_name);
1626 
1627 	rsp = calloc(1, sizeof(*rsp));
1628 	yrs.yarg.data = rsp;
1629 	yrs.cb = devlink_region_get_rsp_parse;
1630 	yrs.rsp_cmd = DEVLINK_CMD_REGION_GET;
1631 
1632 	err = ynl_exec(ys, nlh, &yrs);
1633 	if (err < 0)
1634 		goto err_free;
1635 
1636 	return rsp;
1637 
1638 err_free:
1639 	devlink_region_get_rsp_free(rsp);
1640 	return NULL;
1641 }
1642 
1643 /* DEVLINK_CMD_REGION_GET - dump */
1644 void devlink_region_get_list_free(struct devlink_region_get_list *rsp)
1645 {
1646 	struct devlink_region_get_list *next = rsp;
1647 
1648 	while ((void *)next != YNL_LIST_END) {
1649 		rsp = next;
1650 		next = rsp->next;
1651 
1652 		free(rsp->obj.bus_name);
1653 		free(rsp->obj.dev_name);
1654 		free(rsp->obj.region_name);
1655 		free(rsp);
1656 	}
1657 }
1658 
1659 struct devlink_region_get_list *
1660 devlink_region_get_dump(struct ynl_sock *ys,
1661 			struct devlink_region_get_req_dump *req)
1662 {
1663 	struct ynl_dump_state yds = {};
1664 	struct nlmsghdr *nlh;
1665 	int err;
1666 
1667 	yds.ys = ys;
1668 	yds.alloc_sz = sizeof(struct devlink_region_get_list);
1669 	yds.cb = devlink_region_get_rsp_parse;
1670 	yds.rsp_cmd = DEVLINK_CMD_REGION_GET;
1671 	yds.rsp_policy = &devlink_nest;
1672 
1673 	nlh = ynl_gemsg_start_dump(ys, ys->family_id, DEVLINK_CMD_REGION_GET, 1);
1674 	ys->req_policy = &devlink_nest;
1675 
1676 	if (req->_present.bus_name_len)
1677 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
1678 	if (req->_present.dev_name_len)
1679 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
1680 
1681 	err = ynl_exec_dump(ys, nlh, &yds);
1682 	if (err < 0)
1683 		goto free_list;
1684 
1685 	return yds.first;
1686 
1687 free_list:
1688 	devlink_region_get_list_free(yds.first);
1689 	return NULL;
1690 }
1691 
1692 /* ============== DEVLINK_CMD_INFO_GET ============== */
1693 /* DEVLINK_CMD_INFO_GET - do */
1694 void devlink_info_get_req_free(struct devlink_info_get_req *req)
1695 {
1696 	free(req->bus_name);
1697 	free(req->dev_name);
1698 	free(req);
1699 }
1700 
1701 void devlink_info_get_rsp_free(struct devlink_info_get_rsp *rsp)
1702 {
1703 	unsigned int i;
1704 
1705 	free(rsp->bus_name);
1706 	free(rsp->dev_name);
1707 	free(rsp->info_driver_name);
1708 	free(rsp->info_serial_number);
1709 	for (i = 0; i < rsp->n_info_version_fixed; i++)
1710 		devlink_dl_info_version_free(&rsp->info_version_fixed[i]);
1711 	free(rsp->info_version_fixed);
1712 	for (i = 0; i < rsp->n_info_version_running; i++)
1713 		devlink_dl_info_version_free(&rsp->info_version_running[i]);
1714 	free(rsp->info_version_running);
1715 	for (i = 0; i < rsp->n_info_version_stored; i++)
1716 		devlink_dl_info_version_free(&rsp->info_version_stored[i]);
1717 	free(rsp->info_version_stored);
1718 	free(rsp);
1719 }
1720 
1721 int devlink_info_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
1722 {
1723 	unsigned int n_info_version_running = 0;
1724 	unsigned int n_info_version_stored = 0;
1725 	unsigned int n_info_version_fixed = 0;
1726 	struct ynl_parse_arg *yarg = data;
1727 	struct devlink_info_get_rsp *dst;
1728 	const struct nlattr *attr;
1729 	struct ynl_parse_arg parg;
1730 	int i;
1731 
1732 	dst = yarg->data;
1733 	parg.ys = yarg->ys;
1734 
1735 	if (dst->info_version_fixed)
1736 		return ynl_error_parse(yarg, "attribute already present (devlink.info-version-fixed)");
1737 	if (dst->info_version_running)
1738 		return ynl_error_parse(yarg, "attribute already present (devlink.info-version-running)");
1739 	if (dst->info_version_stored)
1740 		return ynl_error_parse(yarg, "attribute already present (devlink.info-version-stored)");
1741 
1742 	mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
1743 		unsigned int type = mnl_attr_get_type(attr);
1744 
1745 		if (type == DEVLINK_ATTR_BUS_NAME) {
1746 			unsigned int len;
1747 
1748 			if (ynl_attr_validate(yarg, attr))
1749 				return MNL_CB_ERROR;
1750 
1751 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1752 			dst->_present.bus_name_len = len;
1753 			dst->bus_name = malloc(len + 1);
1754 			memcpy(dst->bus_name, mnl_attr_get_str(attr), len);
1755 			dst->bus_name[len] = 0;
1756 		} else if (type == DEVLINK_ATTR_DEV_NAME) {
1757 			unsigned int len;
1758 
1759 			if (ynl_attr_validate(yarg, attr))
1760 				return MNL_CB_ERROR;
1761 
1762 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1763 			dst->_present.dev_name_len = len;
1764 			dst->dev_name = malloc(len + 1);
1765 			memcpy(dst->dev_name, mnl_attr_get_str(attr), len);
1766 			dst->dev_name[len] = 0;
1767 		} else if (type == DEVLINK_ATTR_INFO_DRIVER_NAME) {
1768 			unsigned int len;
1769 
1770 			if (ynl_attr_validate(yarg, attr))
1771 				return MNL_CB_ERROR;
1772 
1773 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1774 			dst->_present.info_driver_name_len = len;
1775 			dst->info_driver_name = malloc(len + 1);
1776 			memcpy(dst->info_driver_name, mnl_attr_get_str(attr), len);
1777 			dst->info_driver_name[len] = 0;
1778 		} else if (type == DEVLINK_ATTR_INFO_SERIAL_NUMBER) {
1779 			unsigned int len;
1780 
1781 			if (ynl_attr_validate(yarg, attr))
1782 				return MNL_CB_ERROR;
1783 
1784 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1785 			dst->_present.info_serial_number_len = len;
1786 			dst->info_serial_number = malloc(len + 1);
1787 			memcpy(dst->info_serial_number, mnl_attr_get_str(attr), len);
1788 			dst->info_serial_number[len] = 0;
1789 		} else if (type == DEVLINK_ATTR_INFO_VERSION_FIXED) {
1790 			n_info_version_fixed++;
1791 		} else if (type == DEVLINK_ATTR_INFO_VERSION_RUNNING) {
1792 			n_info_version_running++;
1793 		} else if (type == DEVLINK_ATTR_INFO_VERSION_STORED) {
1794 			n_info_version_stored++;
1795 		}
1796 	}
1797 
1798 	if (n_info_version_fixed) {
1799 		dst->info_version_fixed = calloc(n_info_version_fixed, sizeof(*dst->info_version_fixed));
1800 		dst->n_info_version_fixed = n_info_version_fixed;
1801 		i = 0;
1802 		parg.rsp_policy = &devlink_dl_info_version_nest;
1803 		mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
1804 			if (mnl_attr_get_type(attr) == DEVLINK_ATTR_INFO_VERSION_FIXED) {
1805 				parg.data = &dst->info_version_fixed[i];
1806 				if (devlink_dl_info_version_parse(&parg, attr))
1807 					return MNL_CB_ERROR;
1808 				i++;
1809 			}
1810 		}
1811 	}
1812 	if (n_info_version_running) {
1813 		dst->info_version_running = calloc(n_info_version_running, sizeof(*dst->info_version_running));
1814 		dst->n_info_version_running = n_info_version_running;
1815 		i = 0;
1816 		parg.rsp_policy = &devlink_dl_info_version_nest;
1817 		mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
1818 			if (mnl_attr_get_type(attr) == DEVLINK_ATTR_INFO_VERSION_RUNNING) {
1819 				parg.data = &dst->info_version_running[i];
1820 				if (devlink_dl_info_version_parse(&parg, attr))
1821 					return MNL_CB_ERROR;
1822 				i++;
1823 			}
1824 		}
1825 	}
1826 	if (n_info_version_stored) {
1827 		dst->info_version_stored = calloc(n_info_version_stored, sizeof(*dst->info_version_stored));
1828 		dst->n_info_version_stored = n_info_version_stored;
1829 		i = 0;
1830 		parg.rsp_policy = &devlink_dl_info_version_nest;
1831 		mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
1832 			if (mnl_attr_get_type(attr) == DEVLINK_ATTR_INFO_VERSION_STORED) {
1833 				parg.data = &dst->info_version_stored[i];
1834 				if (devlink_dl_info_version_parse(&parg, attr))
1835 					return MNL_CB_ERROR;
1836 				i++;
1837 			}
1838 		}
1839 	}
1840 
1841 	return MNL_CB_OK;
1842 }
1843 
1844 struct devlink_info_get_rsp *
1845 devlink_info_get(struct ynl_sock *ys, struct devlink_info_get_req *req)
1846 {
1847 	struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
1848 	struct devlink_info_get_rsp *rsp;
1849 	struct nlmsghdr *nlh;
1850 	int err;
1851 
1852 	nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_INFO_GET, 1);
1853 	ys->req_policy = &devlink_nest;
1854 	yrs.yarg.rsp_policy = &devlink_nest;
1855 
1856 	if (req->_present.bus_name_len)
1857 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
1858 	if (req->_present.dev_name_len)
1859 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
1860 
1861 	rsp = calloc(1, sizeof(*rsp));
1862 	yrs.yarg.data = rsp;
1863 	yrs.cb = devlink_info_get_rsp_parse;
1864 	yrs.rsp_cmd = DEVLINK_CMD_INFO_GET;
1865 
1866 	err = ynl_exec(ys, nlh, &yrs);
1867 	if (err < 0)
1868 		goto err_free;
1869 
1870 	return rsp;
1871 
1872 err_free:
1873 	devlink_info_get_rsp_free(rsp);
1874 	return NULL;
1875 }
1876 
1877 /* DEVLINK_CMD_INFO_GET - dump */
1878 void devlink_info_get_list_free(struct devlink_info_get_list *rsp)
1879 {
1880 	struct devlink_info_get_list *next = rsp;
1881 
1882 	while ((void *)next != YNL_LIST_END) {
1883 		unsigned int i;
1884 
1885 		rsp = next;
1886 		next = rsp->next;
1887 
1888 		free(rsp->obj.bus_name);
1889 		free(rsp->obj.dev_name);
1890 		free(rsp->obj.info_driver_name);
1891 		free(rsp->obj.info_serial_number);
1892 		for (i = 0; i < rsp->obj.n_info_version_fixed; i++)
1893 			devlink_dl_info_version_free(&rsp->obj.info_version_fixed[i]);
1894 		free(rsp->obj.info_version_fixed);
1895 		for (i = 0; i < rsp->obj.n_info_version_running; i++)
1896 			devlink_dl_info_version_free(&rsp->obj.info_version_running[i]);
1897 		free(rsp->obj.info_version_running);
1898 		for (i = 0; i < rsp->obj.n_info_version_stored; i++)
1899 			devlink_dl_info_version_free(&rsp->obj.info_version_stored[i]);
1900 		free(rsp->obj.info_version_stored);
1901 		free(rsp);
1902 	}
1903 }
1904 
1905 struct devlink_info_get_list *devlink_info_get_dump(struct ynl_sock *ys)
1906 {
1907 	struct ynl_dump_state yds = {};
1908 	struct nlmsghdr *nlh;
1909 	int err;
1910 
1911 	yds.ys = ys;
1912 	yds.alloc_sz = sizeof(struct devlink_info_get_list);
1913 	yds.cb = devlink_info_get_rsp_parse;
1914 	yds.rsp_cmd = DEVLINK_CMD_INFO_GET;
1915 	yds.rsp_policy = &devlink_nest;
1916 
1917 	nlh = ynl_gemsg_start_dump(ys, ys->family_id, DEVLINK_CMD_INFO_GET, 1);
1918 
1919 	err = ynl_exec_dump(ys, nlh, &yds);
1920 	if (err < 0)
1921 		goto free_list;
1922 
1923 	return yds.first;
1924 
1925 free_list:
1926 	devlink_info_get_list_free(yds.first);
1927 	return NULL;
1928 }
1929 
1930 /* ============== DEVLINK_CMD_HEALTH_REPORTER_GET ============== */
1931 /* DEVLINK_CMD_HEALTH_REPORTER_GET - do */
1932 void
1933 devlink_health_reporter_get_req_free(struct devlink_health_reporter_get_req *req)
1934 {
1935 	free(req->bus_name);
1936 	free(req->dev_name);
1937 	free(req->health_reporter_name);
1938 	free(req);
1939 }
1940 
1941 void
1942 devlink_health_reporter_get_rsp_free(struct devlink_health_reporter_get_rsp *rsp)
1943 {
1944 	free(rsp->bus_name);
1945 	free(rsp->dev_name);
1946 	free(rsp->health_reporter_name);
1947 	free(rsp);
1948 }
1949 
1950 int devlink_health_reporter_get_rsp_parse(const struct nlmsghdr *nlh,
1951 					  void *data)
1952 {
1953 	struct devlink_health_reporter_get_rsp *dst;
1954 	struct ynl_parse_arg *yarg = data;
1955 	const struct nlattr *attr;
1956 
1957 	dst = yarg->data;
1958 
1959 	mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
1960 		unsigned int type = mnl_attr_get_type(attr);
1961 
1962 		if (type == DEVLINK_ATTR_BUS_NAME) {
1963 			unsigned int len;
1964 
1965 			if (ynl_attr_validate(yarg, attr))
1966 				return MNL_CB_ERROR;
1967 
1968 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1969 			dst->_present.bus_name_len = len;
1970 			dst->bus_name = malloc(len + 1);
1971 			memcpy(dst->bus_name, mnl_attr_get_str(attr), len);
1972 			dst->bus_name[len] = 0;
1973 		} else if (type == DEVLINK_ATTR_DEV_NAME) {
1974 			unsigned int len;
1975 
1976 			if (ynl_attr_validate(yarg, attr))
1977 				return MNL_CB_ERROR;
1978 
1979 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1980 			dst->_present.dev_name_len = len;
1981 			dst->dev_name = malloc(len + 1);
1982 			memcpy(dst->dev_name, mnl_attr_get_str(attr), len);
1983 			dst->dev_name[len] = 0;
1984 		} else if (type == DEVLINK_ATTR_PORT_INDEX) {
1985 			if (ynl_attr_validate(yarg, attr))
1986 				return MNL_CB_ERROR;
1987 			dst->_present.port_index = 1;
1988 			dst->port_index = mnl_attr_get_u32(attr);
1989 		} else if (type == DEVLINK_ATTR_HEALTH_REPORTER_NAME) {
1990 			unsigned int len;
1991 
1992 			if (ynl_attr_validate(yarg, attr))
1993 				return MNL_CB_ERROR;
1994 
1995 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1996 			dst->_present.health_reporter_name_len = len;
1997 			dst->health_reporter_name = malloc(len + 1);
1998 			memcpy(dst->health_reporter_name, mnl_attr_get_str(attr), len);
1999 			dst->health_reporter_name[len] = 0;
2000 		}
2001 	}
2002 
2003 	return MNL_CB_OK;
2004 }
2005 
2006 struct devlink_health_reporter_get_rsp *
2007 devlink_health_reporter_get(struct ynl_sock *ys,
2008 			    struct devlink_health_reporter_get_req *req)
2009 {
2010 	struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
2011 	struct devlink_health_reporter_get_rsp *rsp;
2012 	struct nlmsghdr *nlh;
2013 	int err;
2014 
2015 	nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_HEALTH_REPORTER_GET, 1);
2016 	ys->req_policy = &devlink_nest;
2017 	yrs.yarg.rsp_policy = &devlink_nest;
2018 
2019 	if (req->_present.bus_name_len)
2020 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
2021 	if (req->_present.dev_name_len)
2022 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
2023 	if (req->_present.port_index)
2024 		mnl_attr_put_u32(nlh, DEVLINK_ATTR_PORT_INDEX, req->port_index);
2025 	if (req->_present.health_reporter_name_len)
2026 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_HEALTH_REPORTER_NAME, req->health_reporter_name);
2027 
2028 	rsp = calloc(1, sizeof(*rsp));
2029 	yrs.yarg.data = rsp;
2030 	yrs.cb = devlink_health_reporter_get_rsp_parse;
2031 	yrs.rsp_cmd = DEVLINK_CMD_HEALTH_REPORTER_GET;
2032 
2033 	err = ynl_exec(ys, nlh, &yrs);
2034 	if (err < 0)
2035 		goto err_free;
2036 
2037 	return rsp;
2038 
2039 err_free:
2040 	devlink_health_reporter_get_rsp_free(rsp);
2041 	return NULL;
2042 }
2043 
2044 /* DEVLINK_CMD_HEALTH_REPORTER_GET - dump */
2045 void
2046 devlink_health_reporter_get_list_free(struct devlink_health_reporter_get_list *rsp)
2047 {
2048 	struct devlink_health_reporter_get_list *next = rsp;
2049 
2050 	while ((void *)next != YNL_LIST_END) {
2051 		rsp = next;
2052 		next = rsp->next;
2053 
2054 		free(rsp->obj.bus_name);
2055 		free(rsp->obj.dev_name);
2056 		free(rsp->obj.health_reporter_name);
2057 		free(rsp);
2058 	}
2059 }
2060 
2061 struct devlink_health_reporter_get_list *
2062 devlink_health_reporter_get_dump(struct ynl_sock *ys,
2063 				 struct devlink_health_reporter_get_req_dump *req)
2064 {
2065 	struct ynl_dump_state yds = {};
2066 	struct nlmsghdr *nlh;
2067 	int err;
2068 
2069 	yds.ys = ys;
2070 	yds.alloc_sz = sizeof(struct devlink_health_reporter_get_list);
2071 	yds.cb = devlink_health_reporter_get_rsp_parse;
2072 	yds.rsp_cmd = DEVLINK_CMD_HEALTH_REPORTER_GET;
2073 	yds.rsp_policy = &devlink_nest;
2074 
2075 	nlh = ynl_gemsg_start_dump(ys, ys->family_id, DEVLINK_CMD_HEALTH_REPORTER_GET, 1);
2076 	ys->req_policy = &devlink_nest;
2077 
2078 	if (req->_present.bus_name_len)
2079 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
2080 	if (req->_present.dev_name_len)
2081 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
2082 	if (req->_present.port_index)
2083 		mnl_attr_put_u32(nlh, DEVLINK_ATTR_PORT_INDEX, req->port_index);
2084 
2085 	err = ynl_exec_dump(ys, nlh, &yds);
2086 	if (err < 0)
2087 		goto free_list;
2088 
2089 	return yds.first;
2090 
2091 free_list:
2092 	devlink_health_reporter_get_list_free(yds.first);
2093 	return NULL;
2094 }
2095 
2096 /* ============== DEVLINK_CMD_TRAP_GET ============== */
2097 /* DEVLINK_CMD_TRAP_GET - do */
2098 void devlink_trap_get_req_free(struct devlink_trap_get_req *req)
2099 {
2100 	free(req->bus_name);
2101 	free(req->dev_name);
2102 	free(req->trap_name);
2103 	free(req);
2104 }
2105 
2106 void devlink_trap_get_rsp_free(struct devlink_trap_get_rsp *rsp)
2107 {
2108 	free(rsp->bus_name);
2109 	free(rsp->dev_name);
2110 	free(rsp->trap_name);
2111 	free(rsp);
2112 }
2113 
2114 int devlink_trap_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
2115 {
2116 	struct ynl_parse_arg *yarg = data;
2117 	struct devlink_trap_get_rsp *dst;
2118 	const struct nlattr *attr;
2119 
2120 	dst = yarg->data;
2121 
2122 	mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
2123 		unsigned int type = mnl_attr_get_type(attr);
2124 
2125 		if (type == DEVLINK_ATTR_BUS_NAME) {
2126 			unsigned int len;
2127 
2128 			if (ynl_attr_validate(yarg, attr))
2129 				return MNL_CB_ERROR;
2130 
2131 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
2132 			dst->_present.bus_name_len = len;
2133 			dst->bus_name = malloc(len + 1);
2134 			memcpy(dst->bus_name, mnl_attr_get_str(attr), len);
2135 			dst->bus_name[len] = 0;
2136 		} else if (type == DEVLINK_ATTR_DEV_NAME) {
2137 			unsigned int len;
2138 
2139 			if (ynl_attr_validate(yarg, attr))
2140 				return MNL_CB_ERROR;
2141 
2142 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
2143 			dst->_present.dev_name_len = len;
2144 			dst->dev_name = malloc(len + 1);
2145 			memcpy(dst->dev_name, mnl_attr_get_str(attr), len);
2146 			dst->dev_name[len] = 0;
2147 		} else if (type == DEVLINK_ATTR_TRAP_NAME) {
2148 			unsigned int len;
2149 
2150 			if (ynl_attr_validate(yarg, attr))
2151 				return MNL_CB_ERROR;
2152 
2153 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
2154 			dst->_present.trap_name_len = len;
2155 			dst->trap_name = malloc(len + 1);
2156 			memcpy(dst->trap_name, mnl_attr_get_str(attr), len);
2157 			dst->trap_name[len] = 0;
2158 		}
2159 	}
2160 
2161 	return MNL_CB_OK;
2162 }
2163 
2164 struct devlink_trap_get_rsp *
2165 devlink_trap_get(struct ynl_sock *ys, struct devlink_trap_get_req *req)
2166 {
2167 	struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
2168 	struct devlink_trap_get_rsp *rsp;
2169 	struct nlmsghdr *nlh;
2170 	int err;
2171 
2172 	nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_TRAP_GET, 1);
2173 	ys->req_policy = &devlink_nest;
2174 	yrs.yarg.rsp_policy = &devlink_nest;
2175 
2176 	if (req->_present.bus_name_len)
2177 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
2178 	if (req->_present.dev_name_len)
2179 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
2180 	if (req->_present.trap_name_len)
2181 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_TRAP_NAME, req->trap_name);
2182 
2183 	rsp = calloc(1, sizeof(*rsp));
2184 	yrs.yarg.data = rsp;
2185 	yrs.cb = devlink_trap_get_rsp_parse;
2186 	yrs.rsp_cmd = 63;
2187 
2188 	err = ynl_exec(ys, nlh, &yrs);
2189 	if (err < 0)
2190 		goto err_free;
2191 
2192 	return rsp;
2193 
2194 err_free:
2195 	devlink_trap_get_rsp_free(rsp);
2196 	return NULL;
2197 }
2198 
2199 /* DEVLINK_CMD_TRAP_GET - dump */
2200 void devlink_trap_get_list_free(struct devlink_trap_get_list *rsp)
2201 {
2202 	struct devlink_trap_get_list *next = rsp;
2203 
2204 	while ((void *)next != YNL_LIST_END) {
2205 		rsp = next;
2206 		next = rsp->next;
2207 
2208 		free(rsp->obj.bus_name);
2209 		free(rsp->obj.dev_name);
2210 		free(rsp->obj.trap_name);
2211 		free(rsp);
2212 	}
2213 }
2214 
2215 struct devlink_trap_get_list *
2216 devlink_trap_get_dump(struct ynl_sock *ys,
2217 		      struct devlink_trap_get_req_dump *req)
2218 {
2219 	struct ynl_dump_state yds = {};
2220 	struct nlmsghdr *nlh;
2221 	int err;
2222 
2223 	yds.ys = ys;
2224 	yds.alloc_sz = sizeof(struct devlink_trap_get_list);
2225 	yds.cb = devlink_trap_get_rsp_parse;
2226 	yds.rsp_cmd = 63;
2227 	yds.rsp_policy = &devlink_nest;
2228 
2229 	nlh = ynl_gemsg_start_dump(ys, ys->family_id, DEVLINK_CMD_TRAP_GET, 1);
2230 	ys->req_policy = &devlink_nest;
2231 
2232 	if (req->_present.bus_name_len)
2233 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
2234 	if (req->_present.dev_name_len)
2235 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
2236 
2237 	err = ynl_exec_dump(ys, nlh, &yds);
2238 	if (err < 0)
2239 		goto free_list;
2240 
2241 	return yds.first;
2242 
2243 free_list:
2244 	devlink_trap_get_list_free(yds.first);
2245 	return NULL;
2246 }
2247 
2248 /* ============== DEVLINK_CMD_TRAP_GROUP_GET ============== */
2249 /* DEVLINK_CMD_TRAP_GROUP_GET - do */
2250 void devlink_trap_group_get_req_free(struct devlink_trap_group_get_req *req)
2251 {
2252 	free(req->bus_name);
2253 	free(req->dev_name);
2254 	free(req->trap_group_name);
2255 	free(req);
2256 }
2257 
2258 void devlink_trap_group_get_rsp_free(struct devlink_trap_group_get_rsp *rsp)
2259 {
2260 	free(rsp->bus_name);
2261 	free(rsp->dev_name);
2262 	free(rsp->trap_group_name);
2263 	free(rsp);
2264 }
2265 
2266 int devlink_trap_group_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
2267 {
2268 	struct devlink_trap_group_get_rsp *dst;
2269 	struct ynl_parse_arg *yarg = data;
2270 	const struct nlattr *attr;
2271 
2272 	dst = yarg->data;
2273 
2274 	mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
2275 		unsigned int type = mnl_attr_get_type(attr);
2276 
2277 		if (type == DEVLINK_ATTR_BUS_NAME) {
2278 			unsigned int len;
2279 
2280 			if (ynl_attr_validate(yarg, attr))
2281 				return MNL_CB_ERROR;
2282 
2283 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
2284 			dst->_present.bus_name_len = len;
2285 			dst->bus_name = malloc(len + 1);
2286 			memcpy(dst->bus_name, mnl_attr_get_str(attr), len);
2287 			dst->bus_name[len] = 0;
2288 		} else if (type == DEVLINK_ATTR_DEV_NAME) {
2289 			unsigned int len;
2290 
2291 			if (ynl_attr_validate(yarg, attr))
2292 				return MNL_CB_ERROR;
2293 
2294 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
2295 			dst->_present.dev_name_len = len;
2296 			dst->dev_name = malloc(len + 1);
2297 			memcpy(dst->dev_name, mnl_attr_get_str(attr), len);
2298 			dst->dev_name[len] = 0;
2299 		} else if (type == DEVLINK_ATTR_TRAP_GROUP_NAME) {
2300 			unsigned int len;
2301 
2302 			if (ynl_attr_validate(yarg, attr))
2303 				return MNL_CB_ERROR;
2304 
2305 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
2306 			dst->_present.trap_group_name_len = len;
2307 			dst->trap_group_name = malloc(len + 1);
2308 			memcpy(dst->trap_group_name, mnl_attr_get_str(attr), len);
2309 			dst->trap_group_name[len] = 0;
2310 		}
2311 	}
2312 
2313 	return MNL_CB_OK;
2314 }
2315 
2316 struct devlink_trap_group_get_rsp *
2317 devlink_trap_group_get(struct ynl_sock *ys,
2318 		       struct devlink_trap_group_get_req *req)
2319 {
2320 	struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
2321 	struct devlink_trap_group_get_rsp *rsp;
2322 	struct nlmsghdr *nlh;
2323 	int err;
2324 
2325 	nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_TRAP_GROUP_GET, 1);
2326 	ys->req_policy = &devlink_nest;
2327 	yrs.yarg.rsp_policy = &devlink_nest;
2328 
2329 	if (req->_present.bus_name_len)
2330 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
2331 	if (req->_present.dev_name_len)
2332 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
2333 	if (req->_present.trap_group_name_len)
2334 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_TRAP_GROUP_NAME, req->trap_group_name);
2335 
2336 	rsp = calloc(1, sizeof(*rsp));
2337 	yrs.yarg.data = rsp;
2338 	yrs.cb = devlink_trap_group_get_rsp_parse;
2339 	yrs.rsp_cmd = 67;
2340 
2341 	err = ynl_exec(ys, nlh, &yrs);
2342 	if (err < 0)
2343 		goto err_free;
2344 
2345 	return rsp;
2346 
2347 err_free:
2348 	devlink_trap_group_get_rsp_free(rsp);
2349 	return NULL;
2350 }
2351 
2352 /* DEVLINK_CMD_TRAP_GROUP_GET - dump */
2353 void devlink_trap_group_get_list_free(struct devlink_trap_group_get_list *rsp)
2354 {
2355 	struct devlink_trap_group_get_list *next = rsp;
2356 
2357 	while ((void *)next != YNL_LIST_END) {
2358 		rsp = next;
2359 		next = rsp->next;
2360 
2361 		free(rsp->obj.bus_name);
2362 		free(rsp->obj.dev_name);
2363 		free(rsp->obj.trap_group_name);
2364 		free(rsp);
2365 	}
2366 }
2367 
2368 struct devlink_trap_group_get_list *
2369 devlink_trap_group_get_dump(struct ynl_sock *ys,
2370 			    struct devlink_trap_group_get_req_dump *req)
2371 {
2372 	struct ynl_dump_state yds = {};
2373 	struct nlmsghdr *nlh;
2374 	int err;
2375 
2376 	yds.ys = ys;
2377 	yds.alloc_sz = sizeof(struct devlink_trap_group_get_list);
2378 	yds.cb = devlink_trap_group_get_rsp_parse;
2379 	yds.rsp_cmd = 67;
2380 	yds.rsp_policy = &devlink_nest;
2381 
2382 	nlh = ynl_gemsg_start_dump(ys, ys->family_id, DEVLINK_CMD_TRAP_GROUP_GET, 1);
2383 	ys->req_policy = &devlink_nest;
2384 
2385 	if (req->_present.bus_name_len)
2386 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
2387 	if (req->_present.dev_name_len)
2388 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
2389 
2390 	err = ynl_exec_dump(ys, nlh, &yds);
2391 	if (err < 0)
2392 		goto free_list;
2393 
2394 	return yds.first;
2395 
2396 free_list:
2397 	devlink_trap_group_get_list_free(yds.first);
2398 	return NULL;
2399 }
2400 
2401 /* ============== DEVLINK_CMD_TRAP_POLICER_GET ============== */
2402 /* DEVLINK_CMD_TRAP_POLICER_GET - do */
2403 void
2404 devlink_trap_policer_get_req_free(struct devlink_trap_policer_get_req *req)
2405 {
2406 	free(req->bus_name);
2407 	free(req->dev_name);
2408 	free(req);
2409 }
2410 
2411 void
2412 devlink_trap_policer_get_rsp_free(struct devlink_trap_policer_get_rsp *rsp)
2413 {
2414 	free(rsp->bus_name);
2415 	free(rsp->dev_name);
2416 	free(rsp);
2417 }
2418 
2419 int devlink_trap_policer_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
2420 {
2421 	struct devlink_trap_policer_get_rsp *dst;
2422 	struct ynl_parse_arg *yarg = data;
2423 	const struct nlattr *attr;
2424 
2425 	dst = yarg->data;
2426 
2427 	mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
2428 		unsigned int type = mnl_attr_get_type(attr);
2429 
2430 		if (type == DEVLINK_ATTR_BUS_NAME) {
2431 			unsigned int len;
2432 
2433 			if (ynl_attr_validate(yarg, attr))
2434 				return MNL_CB_ERROR;
2435 
2436 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
2437 			dst->_present.bus_name_len = len;
2438 			dst->bus_name = malloc(len + 1);
2439 			memcpy(dst->bus_name, mnl_attr_get_str(attr), len);
2440 			dst->bus_name[len] = 0;
2441 		} else if (type == DEVLINK_ATTR_DEV_NAME) {
2442 			unsigned int len;
2443 
2444 			if (ynl_attr_validate(yarg, attr))
2445 				return MNL_CB_ERROR;
2446 
2447 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
2448 			dst->_present.dev_name_len = len;
2449 			dst->dev_name = malloc(len + 1);
2450 			memcpy(dst->dev_name, mnl_attr_get_str(attr), len);
2451 			dst->dev_name[len] = 0;
2452 		} else if (type == DEVLINK_ATTR_TRAP_POLICER_ID) {
2453 			if (ynl_attr_validate(yarg, attr))
2454 				return MNL_CB_ERROR;
2455 			dst->_present.trap_policer_id = 1;
2456 			dst->trap_policer_id = mnl_attr_get_u32(attr);
2457 		}
2458 	}
2459 
2460 	return MNL_CB_OK;
2461 }
2462 
2463 struct devlink_trap_policer_get_rsp *
2464 devlink_trap_policer_get(struct ynl_sock *ys,
2465 			 struct devlink_trap_policer_get_req *req)
2466 {
2467 	struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
2468 	struct devlink_trap_policer_get_rsp *rsp;
2469 	struct nlmsghdr *nlh;
2470 	int err;
2471 
2472 	nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_TRAP_POLICER_GET, 1);
2473 	ys->req_policy = &devlink_nest;
2474 	yrs.yarg.rsp_policy = &devlink_nest;
2475 
2476 	if (req->_present.bus_name_len)
2477 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
2478 	if (req->_present.dev_name_len)
2479 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
2480 	if (req->_present.trap_policer_id)
2481 		mnl_attr_put_u32(nlh, DEVLINK_ATTR_TRAP_POLICER_ID, req->trap_policer_id);
2482 
2483 	rsp = calloc(1, sizeof(*rsp));
2484 	yrs.yarg.data = rsp;
2485 	yrs.cb = devlink_trap_policer_get_rsp_parse;
2486 	yrs.rsp_cmd = 71;
2487 
2488 	err = ynl_exec(ys, nlh, &yrs);
2489 	if (err < 0)
2490 		goto err_free;
2491 
2492 	return rsp;
2493 
2494 err_free:
2495 	devlink_trap_policer_get_rsp_free(rsp);
2496 	return NULL;
2497 }
2498 
2499 /* DEVLINK_CMD_TRAP_POLICER_GET - dump */
2500 void
2501 devlink_trap_policer_get_list_free(struct devlink_trap_policer_get_list *rsp)
2502 {
2503 	struct devlink_trap_policer_get_list *next = rsp;
2504 
2505 	while ((void *)next != YNL_LIST_END) {
2506 		rsp = next;
2507 		next = rsp->next;
2508 
2509 		free(rsp->obj.bus_name);
2510 		free(rsp->obj.dev_name);
2511 		free(rsp);
2512 	}
2513 }
2514 
2515 struct devlink_trap_policer_get_list *
2516 devlink_trap_policer_get_dump(struct ynl_sock *ys,
2517 			      struct devlink_trap_policer_get_req_dump *req)
2518 {
2519 	struct ynl_dump_state yds = {};
2520 	struct nlmsghdr *nlh;
2521 	int err;
2522 
2523 	yds.ys = ys;
2524 	yds.alloc_sz = sizeof(struct devlink_trap_policer_get_list);
2525 	yds.cb = devlink_trap_policer_get_rsp_parse;
2526 	yds.rsp_cmd = 71;
2527 	yds.rsp_policy = &devlink_nest;
2528 
2529 	nlh = ynl_gemsg_start_dump(ys, ys->family_id, DEVLINK_CMD_TRAP_POLICER_GET, 1);
2530 	ys->req_policy = &devlink_nest;
2531 
2532 	if (req->_present.bus_name_len)
2533 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
2534 	if (req->_present.dev_name_len)
2535 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
2536 
2537 	err = ynl_exec_dump(ys, nlh, &yds);
2538 	if (err < 0)
2539 		goto free_list;
2540 
2541 	return yds.first;
2542 
2543 free_list:
2544 	devlink_trap_policer_get_list_free(yds.first);
2545 	return NULL;
2546 }
2547 
2548 /* ============== DEVLINK_CMD_RATE_GET ============== */
2549 /* DEVLINK_CMD_RATE_GET - do */
2550 void devlink_rate_get_req_free(struct devlink_rate_get_req *req)
2551 {
2552 	free(req->bus_name);
2553 	free(req->dev_name);
2554 	free(req->rate_node_name);
2555 	free(req);
2556 }
2557 
2558 void devlink_rate_get_rsp_free(struct devlink_rate_get_rsp *rsp)
2559 {
2560 	free(rsp->bus_name);
2561 	free(rsp->dev_name);
2562 	free(rsp->rate_node_name);
2563 	free(rsp);
2564 }
2565 
2566 int devlink_rate_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
2567 {
2568 	struct ynl_parse_arg *yarg = data;
2569 	struct devlink_rate_get_rsp *dst;
2570 	const struct nlattr *attr;
2571 
2572 	dst = yarg->data;
2573 
2574 	mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
2575 		unsigned int type = mnl_attr_get_type(attr);
2576 
2577 		if (type == DEVLINK_ATTR_BUS_NAME) {
2578 			unsigned int len;
2579 
2580 			if (ynl_attr_validate(yarg, attr))
2581 				return MNL_CB_ERROR;
2582 
2583 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
2584 			dst->_present.bus_name_len = len;
2585 			dst->bus_name = malloc(len + 1);
2586 			memcpy(dst->bus_name, mnl_attr_get_str(attr), len);
2587 			dst->bus_name[len] = 0;
2588 		} else if (type == DEVLINK_ATTR_DEV_NAME) {
2589 			unsigned int len;
2590 
2591 			if (ynl_attr_validate(yarg, attr))
2592 				return MNL_CB_ERROR;
2593 
2594 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
2595 			dst->_present.dev_name_len = len;
2596 			dst->dev_name = malloc(len + 1);
2597 			memcpy(dst->dev_name, mnl_attr_get_str(attr), len);
2598 			dst->dev_name[len] = 0;
2599 		} else if (type == DEVLINK_ATTR_PORT_INDEX) {
2600 			if (ynl_attr_validate(yarg, attr))
2601 				return MNL_CB_ERROR;
2602 			dst->_present.port_index = 1;
2603 			dst->port_index = mnl_attr_get_u32(attr);
2604 		} else if (type == DEVLINK_ATTR_RATE_NODE_NAME) {
2605 			unsigned int len;
2606 
2607 			if (ynl_attr_validate(yarg, attr))
2608 				return MNL_CB_ERROR;
2609 
2610 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
2611 			dst->_present.rate_node_name_len = len;
2612 			dst->rate_node_name = malloc(len + 1);
2613 			memcpy(dst->rate_node_name, mnl_attr_get_str(attr), len);
2614 			dst->rate_node_name[len] = 0;
2615 		}
2616 	}
2617 
2618 	return MNL_CB_OK;
2619 }
2620 
2621 struct devlink_rate_get_rsp *
2622 devlink_rate_get(struct ynl_sock *ys, struct devlink_rate_get_req *req)
2623 {
2624 	struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
2625 	struct devlink_rate_get_rsp *rsp;
2626 	struct nlmsghdr *nlh;
2627 	int err;
2628 
2629 	nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_RATE_GET, 1);
2630 	ys->req_policy = &devlink_nest;
2631 	yrs.yarg.rsp_policy = &devlink_nest;
2632 
2633 	if (req->_present.bus_name_len)
2634 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
2635 	if (req->_present.dev_name_len)
2636 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
2637 	if (req->_present.port_index)
2638 		mnl_attr_put_u32(nlh, DEVLINK_ATTR_PORT_INDEX, req->port_index);
2639 	if (req->_present.rate_node_name_len)
2640 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_RATE_NODE_NAME, req->rate_node_name);
2641 
2642 	rsp = calloc(1, sizeof(*rsp));
2643 	yrs.yarg.data = rsp;
2644 	yrs.cb = devlink_rate_get_rsp_parse;
2645 	yrs.rsp_cmd = 76;
2646 
2647 	err = ynl_exec(ys, nlh, &yrs);
2648 	if (err < 0)
2649 		goto err_free;
2650 
2651 	return rsp;
2652 
2653 err_free:
2654 	devlink_rate_get_rsp_free(rsp);
2655 	return NULL;
2656 }
2657 
2658 /* DEVLINK_CMD_RATE_GET - dump */
2659 void devlink_rate_get_list_free(struct devlink_rate_get_list *rsp)
2660 {
2661 	struct devlink_rate_get_list *next = rsp;
2662 
2663 	while ((void *)next != YNL_LIST_END) {
2664 		rsp = next;
2665 		next = rsp->next;
2666 
2667 		free(rsp->obj.bus_name);
2668 		free(rsp->obj.dev_name);
2669 		free(rsp->obj.rate_node_name);
2670 		free(rsp);
2671 	}
2672 }
2673 
2674 struct devlink_rate_get_list *
2675 devlink_rate_get_dump(struct ynl_sock *ys,
2676 		      struct devlink_rate_get_req_dump *req)
2677 {
2678 	struct ynl_dump_state yds = {};
2679 	struct nlmsghdr *nlh;
2680 	int err;
2681 
2682 	yds.ys = ys;
2683 	yds.alloc_sz = sizeof(struct devlink_rate_get_list);
2684 	yds.cb = devlink_rate_get_rsp_parse;
2685 	yds.rsp_cmd = 76;
2686 	yds.rsp_policy = &devlink_nest;
2687 
2688 	nlh = ynl_gemsg_start_dump(ys, ys->family_id, DEVLINK_CMD_RATE_GET, 1);
2689 	ys->req_policy = &devlink_nest;
2690 
2691 	if (req->_present.bus_name_len)
2692 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
2693 	if (req->_present.dev_name_len)
2694 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
2695 
2696 	err = ynl_exec_dump(ys, nlh, &yds);
2697 	if (err < 0)
2698 		goto free_list;
2699 
2700 	return yds.first;
2701 
2702 free_list:
2703 	devlink_rate_get_list_free(yds.first);
2704 	return NULL;
2705 }
2706 
2707 /* ============== DEVLINK_CMD_LINECARD_GET ============== */
2708 /* DEVLINK_CMD_LINECARD_GET - do */
2709 void devlink_linecard_get_req_free(struct devlink_linecard_get_req *req)
2710 {
2711 	free(req->bus_name);
2712 	free(req->dev_name);
2713 	free(req);
2714 }
2715 
2716 void devlink_linecard_get_rsp_free(struct devlink_linecard_get_rsp *rsp)
2717 {
2718 	free(rsp->bus_name);
2719 	free(rsp->dev_name);
2720 	free(rsp);
2721 }
2722 
2723 int devlink_linecard_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
2724 {
2725 	struct devlink_linecard_get_rsp *dst;
2726 	struct ynl_parse_arg *yarg = data;
2727 	const struct nlattr *attr;
2728 
2729 	dst = yarg->data;
2730 
2731 	mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
2732 		unsigned int type = mnl_attr_get_type(attr);
2733 
2734 		if (type == DEVLINK_ATTR_BUS_NAME) {
2735 			unsigned int len;
2736 
2737 			if (ynl_attr_validate(yarg, attr))
2738 				return MNL_CB_ERROR;
2739 
2740 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
2741 			dst->_present.bus_name_len = len;
2742 			dst->bus_name = malloc(len + 1);
2743 			memcpy(dst->bus_name, mnl_attr_get_str(attr), len);
2744 			dst->bus_name[len] = 0;
2745 		} else if (type == DEVLINK_ATTR_DEV_NAME) {
2746 			unsigned int len;
2747 
2748 			if (ynl_attr_validate(yarg, attr))
2749 				return MNL_CB_ERROR;
2750 
2751 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
2752 			dst->_present.dev_name_len = len;
2753 			dst->dev_name = malloc(len + 1);
2754 			memcpy(dst->dev_name, mnl_attr_get_str(attr), len);
2755 			dst->dev_name[len] = 0;
2756 		} else if (type == DEVLINK_ATTR_LINECARD_INDEX) {
2757 			if (ynl_attr_validate(yarg, attr))
2758 				return MNL_CB_ERROR;
2759 			dst->_present.linecard_index = 1;
2760 			dst->linecard_index = mnl_attr_get_u32(attr);
2761 		}
2762 	}
2763 
2764 	return MNL_CB_OK;
2765 }
2766 
2767 struct devlink_linecard_get_rsp *
2768 devlink_linecard_get(struct ynl_sock *ys, struct devlink_linecard_get_req *req)
2769 {
2770 	struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
2771 	struct devlink_linecard_get_rsp *rsp;
2772 	struct nlmsghdr *nlh;
2773 	int err;
2774 
2775 	nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_LINECARD_GET, 1);
2776 	ys->req_policy = &devlink_nest;
2777 	yrs.yarg.rsp_policy = &devlink_nest;
2778 
2779 	if (req->_present.bus_name_len)
2780 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
2781 	if (req->_present.dev_name_len)
2782 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
2783 	if (req->_present.linecard_index)
2784 		mnl_attr_put_u32(nlh, DEVLINK_ATTR_LINECARD_INDEX, req->linecard_index);
2785 
2786 	rsp = calloc(1, sizeof(*rsp));
2787 	yrs.yarg.data = rsp;
2788 	yrs.cb = devlink_linecard_get_rsp_parse;
2789 	yrs.rsp_cmd = 80;
2790 
2791 	err = ynl_exec(ys, nlh, &yrs);
2792 	if (err < 0)
2793 		goto err_free;
2794 
2795 	return rsp;
2796 
2797 err_free:
2798 	devlink_linecard_get_rsp_free(rsp);
2799 	return NULL;
2800 }
2801 
2802 /* DEVLINK_CMD_LINECARD_GET - dump */
2803 void devlink_linecard_get_list_free(struct devlink_linecard_get_list *rsp)
2804 {
2805 	struct devlink_linecard_get_list *next = rsp;
2806 
2807 	while ((void *)next != YNL_LIST_END) {
2808 		rsp = next;
2809 		next = rsp->next;
2810 
2811 		free(rsp->obj.bus_name);
2812 		free(rsp->obj.dev_name);
2813 		free(rsp);
2814 	}
2815 }
2816 
2817 struct devlink_linecard_get_list *
2818 devlink_linecard_get_dump(struct ynl_sock *ys,
2819 			  struct devlink_linecard_get_req_dump *req)
2820 {
2821 	struct ynl_dump_state yds = {};
2822 	struct nlmsghdr *nlh;
2823 	int err;
2824 
2825 	yds.ys = ys;
2826 	yds.alloc_sz = sizeof(struct devlink_linecard_get_list);
2827 	yds.cb = devlink_linecard_get_rsp_parse;
2828 	yds.rsp_cmd = 80;
2829 	yds.rsp_policy = &devlink_nest;
2830 
2831 	nlh = ynl_gemsg_start_dump(ys, ys->family_id, DEVLINK_CMD_LINECARD_GET, 1);
2832 	ys->req_policy = &devlink_nest;
2833 
2834 	if (req->_present.bus_name_len)
2835 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
2836 	if (req->_present.dev_name_len)
2837 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
2838 
2839 	err = ynl_exec_dump(ys, nlh, &yds);
2840 	if (err < 0)
2841 		goto free_list;
2842 
2843 	return yds.first;
2844 
2845 free_list:
2846 	devlink_linecard_get_list_free(yds.first);
2847 	return NULL;
2848 }
2849 
2850 /* ============== DEVLINK_CMD_SELFTESTS_GET ============== */
2851 /* DEVLINK_CMD_SELFTESTS_GET - do */
2852 void devlink_selftests_get_req_free(struct devlink_selftests_get_req *req)
2853 {
2854 	free(req->bus_name);
2855 	free(req->dev_name);
2856 	free(req);
2857 }
2858 
2859 void devlink_selftests_get_rsp_free(struct devlink_selftests_get_rsp *rsp)
2860 {
2861 	free(rsp->bus_name);
2862 	free(rsp->dev_name);
2863 	free(rsp);
2864 }
2865 
2866 int devlink_selftests_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
2867 {
2868 	struct devlink_selftests_get_rsp *dst;
2869 	struct ynl_parse_arg *yarg = data;
2870 	const struct nlattr *attr;
2871 
2872 	dst = yarg->data;
2873 
2874 	mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
2875 		unsigned int type = mnl_attr_get_type(attr);
2876 
2877 		if (type == DEVLINK_ATTR_BUS_NAME) {
2878 			unsigned int len;
2879 
2880 			if (ynl_attr_validate(yarg, attr))
2881 				return MNL_CB_ERROR;
2882 
2883 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
2884 			dst->_present.bus_name_len = len;
2885 			dst->bus_name = malloc(len + 1);
2886 			memcpy(dst->bus_name, mnl_attr_get_str(attr), len);
2887 			dst->bus_name[len] = 0;
2888 		} else if (type == DEVLINK_ATTR_DEV_NAME) {
2889 			unsigned int len;
2890 
2891 			if (ynl_attr_validate(yarg, attr))
2892 				return MNL_CB_ERROR;
2893 
2894 			len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
2895 			dst->_present.dev_name_len = len;
2896 			dst->dev_name = malloc(len + 1);
2897 			memcpy(dst->dev_name, mnl_attr_get_str(attr), len);
2898 			dst->dev_name[len] = 0;
2899 		}
2900 	}
2901 
2902 	return MNL_CB_OK;
2903 }
2904 
2905 struct devlink_selftests_get_rsp *
2906 devlink_selftests_get(struct ynl_sock *ys,
2907 		      struct devlink_selftests_get_req *req)
2908 {
2909 	struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
2910 	struct devlink_selftests_get_rsp *rsp;
2911 	struct nlmsghdr *nlh;
2912 	int err;
2913 
2914 	nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_SELFTESTS_GET, 1);
2915 	ys->req_policy = &devlink_nest;
2916 	yrs.yarg.rsp_policy = &devlink_nest;
2917 
2918 	if (req->_present.bus_name_len)
2919 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
2920 	if (req->_present.dev_name_len)
2921 		mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
2922 
2923 	rsp = calloc(1, sizeof(*rsp));
2924 	yrs.yarg.data = rsp;
2925 	yrs.cb = devlink_selftests_get_rsp_parse;
2926 	yrs.rsp_cmd = DEVLINK_CMD_SELFTESTS_GET;
2927 
2928 	err = ynl_exec(ys, nlh, &yrs);
2929 	if (err < 0)
2930 		goto err_free;
2931 
2932 	return rsp;
2933 
2934 err_free:
2935 	devlink_selftests_get_rsp_free(rsp);
2936 	return NULL;
2937 }
2938 
2939 /* DEVLINK_CMD_SELFTESTS_GET - dump */
2940 void devlink_selftests_get_list_free(struct devlink_selftests_get_list *rsp)
2941 {
2942 	struct devlink_selftests_get_list *next = rsp;
2943 
2944 	while ((void *)next != YNL_LIST_END) {
2945 		rsp = next;
2946 		next = rsp->next;
2947 
2948 		free(rsp->obj.bus_name);
2949 		free(rsp->obj.dev_name);
2950 		free(rsp);
2951 	}
2952 }
2953 
2954 struct devlink_selftests_get_list *
2955 devlink_selftests_get_dump(struct ynl_sock *ys)
2956 {
2957 	struct ynl_dump_state yds = {};
2958 	struct nlmsghdr *nlh;
2959 	int err;
2960 
2961 	yds.ys = ys;
2962 	yds.alloc_sz = sizeof(struct devlink_selftests_get_list);
2963 	yds.cb = devlink_selftests_get_rsp_parse;
2964 	yds.rsp_cmd = DEVLINK_CMD_SELFTESTS_GET;
2965 	yds.rsp_policy = &devlink_nest;
2966 
2967 	nlh = ynl_gemsg_start_dump(ys, ys->family_id, DEVLINK_CMD_SELFTESTS_GET, 1);
2968 
2969 	err = ynl_exec_dump(ys, nlh, &yds);
2970 	if (err < 0)
2971 		goto free_list;
2972 
2973 	return yds.first;
2974 
2975 free_list:
2976 	devlink_selftests_get_list_free(yds.first);
2977 	return NULL;
2978 }
2979 
2980 const struct ynl_family ynl_devlink_family =  {
2981 	.name		= "devlink",
2982 };
2983