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
devlink_op_str(int op)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
devlink_sb_pool_type_str(enum devlink_sb_pool_type value)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 */
devlink_dl_info_version_free(struct devlink_dl_info_version * obj)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
devlink_dl_info_version_parse(struct ynl_parse_arg * yarg,const struct nlattr * nested)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
devlink_dl_reload_stats_entry_free(struct devlink_dl_reload_stats_entry * obj)198 devlink_dl_reload_stats_entry_free(struct devlink_dl_reload_stats_entry *obj)
199 {
200 }
201
devlink_dl_reload_stats_entry_parse(struct ynl_parse_arg * yarg,const struct nlattr * nested)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
devlink_dl_reload_act_stats_free(struct devlink_dl_reload_act_stats * obj)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
devlink_dl_reload_act_stats_parse(struct ynl_parse_arg * yarg,const struct nlattr * nested)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
devlink_dl_reload_act_info_free(struct devlink_dl_reload_act_info * obj)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
devlink_dl_reload_act_info_parse(struct ynl_parse_arg * yarg,const struct nlattr * nested)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
devlink_dl_reload_stats_free(struct devlink_dl_reload_stats * obj)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
devlink_dl_reload_stats_parse(struct ynl_parse_arg * yarg,const struct nlattr * nested)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
devlink_dl_dev_stats_free(struct devlink_dl_dev_stats * obj)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
devlink_dl_dev_stats_parse(struct ynl_parse_arg * yarg,const struct nlattr * nested)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 */
devlink_get_req_free(struct devlink_get_req * req)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
devlink_get_rsp_free(struct devlink_get_rsp * rsp)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
devlink_get_rsp_parse(const struct nlmsghdr * nlh,void * data)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 *
devlink_get(struct ynl_sock * ys,struct devlink_get_req * req)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 */
devlink_get_list_free(struct devlink_get_list * rsp)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
devlink_get_dump(struct ynl_sock * ys)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 */
devlink_port_get_req_free(struct devlink_port_get_req * req)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
devlink_port_get_rsp_free(struct devlink_port_get_rsp * rsp)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
devlink_port_get_rsp_parse(const struct nlmsghdr * nlh,void * data)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 *
devlink_port_get(struct ynl_sock * ys,struct devlink_port_get_req * req)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 */
devlink_port_get_rsp_dump_parse(const struct nlmsghdr * nlh,void * data)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
devlink_port_get_rsp_list_free(struct devlink_port_get_rsp_list * rsp)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 *
devlink_port_get_dump(struct ynl_sock * ys,struct devlink_port_get_req_dump * req)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 */
devlink_sb_get_req_free(struct devlink_sb_get_req * req)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
devlink_sb_get_rsp_free(struct devlink_sb_get_rsp * rsp)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
devlink_sb_get_rsp_parse(const struct nlmsghdr * nlh,void * data)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 *
devlink_sb_get(struct ynl_sock * ys,struct devlink_sb_get_req * req)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 */
devlink_sb_get_list_free(struct devlink_sb_get_list * rsp)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 *
devlink_sb_get_dump(struct ynl_sock * ys,struct devlink_sb_get_req_dump * req)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 */
devlink_sb_pool_get_req_free(struct devlink_sb_pool_get_req * req)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
devlink_sb_pool_get_rsp_free(struct devlink_sb_pool_get_rsp * rsp)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
devlink_sb_pool_get_rsp_parse(const struct nlmsghdr * nlh,void * data)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 *
devlink_sb_pool_get(struct ynl_sock * ys,struct devlink_sb_pool_get_req * req)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 */
devlink_sb_pool_get_list_free(struct devlink_sb_pool_get_list * rsp)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 *
devlink_sb_pool_get_dump(struct ynl_sock * ys,struct devlink_sb_pool_get_req_dump * req)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
devlink_sb_port_pool_get_req_free(struct devlink_sb_port_pool_get_req * req)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
devlink_sb_port_pool_get_rsp_free(struct devlink_sb_port_pool_get_rsp * rsp)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
devlink_sb_port_pool_get_rsp_parse(const struct nlmsghdr * nlh,void * data)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 *
devlink_sb_port_pool_get(struct ynl_sock * ys,struct devlink_sb_port_pool_get_req * req)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
devlink_sb_port_pool_get_list_free(struct devlink_sb_port_pool_get_list * rsp)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 *
devlink_sb_port_pool_get_dump(struct ynl_sock * ys,struct devlink_sb_port_pool_get_req_dump * req)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
devlink_sb_tc_pool_bind_get_req_free(struct devlink_sb_tc_pool_bind_get_req * req)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
devlink_sb_tc_pool_bind_get_rsp_free(struct devlink_sb_tc_pool_bind_get_rsp * rsp)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
devlink_sb_tc_pool_bind_get_rsp_parse(const struct nlmsghdr * nlh,void * data)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 *
devlink_sb_tc_pool_bind_get(struct ynl_sock * ys,struct devlink_sb_tc_pool_bind_get_req * req)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
devlink_sb_tc_pool_bind_get_list_free(struct devlink_sb_tc_pool_bind_get_list * rsp)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 *
devlink_sb_tc_pool_bind_get_dump(struct ynl_sock * ys,struct devlink_sb_tc_pool_bind_get_req_dump * req)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 */
devlink_param_get_req_free(struct devlink_param_get_req * req)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
devlink_param_get_rsp_free(struct devlink_param_get_rsp * rsp)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
devlink_param_get_rsp_parse(const struct nlmsghdr * nlh,void * data)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 *
devlink_param_get(struct ynl_sock * ys,struct devlink_param_get_req * req)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 */
devlink_param_get_list_free(struct devlink_param_get_list * rsp)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 *
devlink_param_get_dump(struct ynl_sock * ys,struct devlink_param_get_req_dump * req)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 */
devlink_region_get_req_free(struct devlink_region_get_req * req)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
devlink_region_get_rsp_free(struct devlink_region_get_rsp * rsp)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
devlink_region_get_rsp_parse(const struct nlmsghdr * nlh,void * data)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 *
devlink_region_get(struct ynl_sock * ys,struct devlink_region_get_req * req)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 */
devlink_region_get_list_free(struct devlink_region_get_list * rsp)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 *
devlink_region_get_dump(struct ynl_sock * ys,struct devlink_region_get_req_dump * req)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 */
devlink_info_get_req_free(struct devlink_info_get_req * req)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
devlink_info_get_rsp_free(struct devlink_info_get_rsp * rsp)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
devlink_info_get_rsp_parse(const struct nlmsghdr * nlh,void * data)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 *
devlink_info_get(struct ynl_sock * ys,struct devlink_info_get_req * req)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 */
devlink_info_get_list_free(struct devlink_info_get_list * rsp)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
devlink_info_get_dump(struct ynl_sock * ys)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
devlink_health_reporter_get_req_free(struct devlink_health_reporter_get_req * req)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
devlink_health_reporter_get_rsp_free(struct devlink_health_reporter_get_rsp * rsp)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
devlink_health_reporter_get_rsp_parse(const struct nlmsghdr * nlh,void * data)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 *
devlink_health_reporter_get(struct ynl_sock * ys,struct devlink_health_reporter_get_req * req)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
devlink_health_reporter_get_list_free(struct devlink_health_reporter_get_list * rsp)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 *
devlink_health_reporter_get_dump(struct ynl_sock * ys,struct devlink_health_reporter_get_req_dump * req)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 */
devlink_trap_get_req_free(struct devlink_trap_get_req * req)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
devlink_trap_get_rsp_free(struct devlink_trap_get_rsp * rsp)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
devlink_trap_get_rsp_parse(const struct nlmsghdr * nlh,void * data)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 *
devlink_trap_get(struct ynl_sock * ys,struct devlink_trap_get_req * req)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 */
devlink_trap_get_list_free(struct devlink_trap_get_list * rsp)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 *
devlink_trap_get_dump(struct ynl_sock * ys,struct devlink_trap_get_req_dump * req)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 */
devlink_trap_group_get_req_free(struct devlink_trap_group_get_req * req)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
devlink_trap_group_get_rsp_free(struct devlink_trap_group_get_rsp * rsp)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
devlink_trap_group_get_rsp_parse(const struct nlmsghdr * nlh,void * data)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 *
devlink_trap_group_get(struct ynl_sock * ys,struct devlink_trap_group_get_req * req)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 */
devlink_trap_group_get_list_free(struct devlink_trap_group_get_list * rsp)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 *
devlink_trap_group_get_dump(struct ynl_sock * ys,struct devlink_trap_group_get_req_dump * req)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
devlink_trap_policer_get_req_free(struct devlink_trap_policer_get_req * req)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
devlink_trap_policer_get_rsp_free(struct devlink_trap_policer_get_rsp * rsp)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
devlink_trap_policer_get_rsp_parse(const struct nlmsghdr * nlh,void * data)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 *
devlink_trap_policer_get(struct ynl_sock * ys,struct devlink_trap_policer_get_req * req)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
devlink_trap_policer_get_list_free(struct devlink_trap_policer_get_list * rsp)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 *
devlink_trap_policer_get_dump(struct ynl_sock * ys,struct devlink_trap_policer_get_req_dump * req)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 */
devlink_rate_get_req_free(struct devlink_rate_get_req * req)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
devlink_rate_get_rsp_free(struct devlink_rate_get_rsp * rsp)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
devlink_rate_get_rsp_parse(const struct nlmsghdr * nlh,void * data)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 *
devlink_rate_get(struct ynl_sock * ys,struct devlink_rate_get_req * req)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 */
devlink_rate_get_list_free(struct devlink_rate_get_list * rsp)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 *
devlink_rate_get_dump(struct ynl_sock * ys,struct devlink_rate_get_req_dump * req)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 */
devlink_linecard_get_req_free(struct devlink_linecard_get_req * req)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
devlink_linecard_get_rsp_free(struct devlink_linecard_get_rsp * rsp)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
devlink_linecard_get_rsp_parse(const struct nlmsghdr * nlh,void * data)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 *
devlink_linecard_get(struct ynl_sock * ys,struct devlink_linecard_get_req * req)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 */
devlink_linecard_get_list_free(struct devlink_linecard_get_list * rsp)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 *
devlink_linecard_get_dump(struct ynl_sock * ys,struct devlink_linecard_get_req_dump * req)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 */
devlink_selftests_get_req_free(struct devlink_selftests_get_req * req)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
devlink_selftests_get_rsp_free(struct devlink_selftests_get_rsp * rsp)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
devlink_selftests_get_rsp_parse(const struct nlmsghdr * nlh,void * data)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 *
devlink_selftests_get(struct ynl_sock * ys,struct devlink_selftests_get_req * req)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 */
devlink_selftests_get_list_free(struct devlink_selftests_get_list * rsp)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 *
devlink_selftests_get_dump(struct ynl_sock * ys)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