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 */ 16static 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 35const 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 42static const char * const devlink_sb_pool_type_strmap[] = { 43 [0] = "ingress", 44 [1] = "egress", 45}; 46 47const 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 */ 55struct 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 60struct ynl_policy_nest devlink_dl_info_version_nest = { 61 .max_attr = DEVLINK_ATTR_MAX, 62 .table = devlink_dl_info_version_policy, 63}; 64 65struct 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 70struct 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 75struct 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 79struct 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 84struct 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 89struct 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 94struct 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 98struct ynl_policy_nest devlink_dl_reload_stats_nest = { 99 .max_attr = DEVLINK_ATTR_MAX, 100 .table = devlink_dl_reload_stats_policy, 101}; 102 103struct 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 108struct ynl_policy_nest devlink_dl_dev_stats_nest = { 109 .max_attr = DEVLINK_ATTR_MAX, 110 .table = devlink_dl_dev_stats_policy, 111}; 112 113struct 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 148struct ynl_policy_nest devlink_nest = { 149 .max_attr = DEVLINK_ATTR_MAX, 150 .table = devlink_policy, 151}; 152 153/* Common nested types */ 154void 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 160int 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 197void 198devlink_dl_reload_stats_entry_free(struct devlink_dl_reload_stats_entry *obj) 199{ 200} 201 202int 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 227void 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 236int 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 276void 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 285int 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 330void 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 339int 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 379void 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 385int 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 */ 423void 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 430void 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 438int 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 498struct devlink_get_rsp * 499devlink_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 526err_free: 527 devlink_get_rsp_free(rsp); 528 return NULL; 529} 530 531/* DEVLINK_CMD_GET - dump */ 532void 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 547struct 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 567free_list: 568 devlink_get_list_free(yds.first); 569 return NULL; 570} 571 572/* ============== DEVLINK_CMD_PORT_GET ============== */ 573/* DEVLINK_CMD_PORT_GET - do */ 574void 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 581void 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 588int 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 632struct devlink_port_get_rsp * 633devlink_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 662err_free: 663 devlink_port_get_rsp_free(rsp); 664 return NULL; 665} 666 667/* DEVLINK_CMD_PORT_GET - dump */ 668int 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 712void 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 726struct devlink_port_get_rsp_list * 727devlink_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 754free_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 */ 761void 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 768void 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 775int 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 819struct devlink_sb_get_rsp * 820devlink_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 849err_free: 850 devlink_sb_get_rsp_free(rsp); 851 return NULL; 852} 853 854/* DEVLINK_CMD_SB_GET - dump */ 855void 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 869struct devlink_sb_get_list * 870devlink_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 896free_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 */ 903void 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 910void 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 917int 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 966struct devlink_sb_pool_get_rsp * 967devlink_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 998err_free: 999 devlink_sb_pool_get_rsp_free(rsp); 1000 return NULL; 1001} 1002 1003/* DEVLINK_CMD_SB_POOL_GET - dump */ 1004void 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 1018struct devlink_sb_pool_get_list * 1019devlink_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 1046free_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 */ 1053void 1054devlink_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 1061void 1062devlink_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 1069int 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 1123struct devlink_sb_port_pool_get_rsp * 1124devlink_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 1158err_free: 1159 devlink_sb_port_pool_get_rsp_free(rsp); 1160 return NULL; 1161} 1162 1163/* DEVLINK_CMD_SB_PORT_POOL_GET - dump */ 1164void 1165devlink_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 1179struct devlink_sb_port_pool_get_list * 1180devlink_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 1207free_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 */ 1214void 1215devlink_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 1222void 1223devlink_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 1230int 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 1290struct devlink_sb_tc_pool_bind_get_rsp * 1291devlink_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 1327err_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 */ 1333void 1334devlink_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 1348struct devlink_sb_tc_pool_bind_get_list * 1349devlink_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 1376free_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 */ 1383void 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 1391void 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 1399int 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 1449struct devlink_param_get_rsp * 1450devlink_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 1479err_free: 1480 devlink_param_get_rsp_free(rsp); 1481 return NULL; 1482} 1483 1484/* DEVLINK_CMD_PARAM_GET - dump */ 1485void 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 1500struct devlink_param_get_list * 1501devlink_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 1528free_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 */ 1535void 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 1543void 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 1551int 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 1606struct devlink_region_get_rsp * 1607devlink_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 1638err_free: 1639 devlink_region_get_rsp_free(rsp); 1640 return NULL; 1641} 1642 1643/* DEVLINK_CMD_REGION_GET - dump */ 1644void 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 1659struct devlink_region_get_list * 1660devlink_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 1687free_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 */ 1694void 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 1701void 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 1721int 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 1844struct devlink_info_get_rsp * 1845devlink_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 1872err_free: 1873 devlink_info_get_rsp_free(rsp); 1874 return NULL; 1875} 1876 1877/* DEVLINK_CMD_INFO_GET - dump */ 1878void 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 1905struct 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 1925free_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 */ 1932void 1933devlink_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 1941void 1942devlink_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 1950int 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 2006struct devlink_health_reporter_get_rsp * 2007devlink_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 2039err_free: 2040 devlink_health_reporter_get_rsp_free(rsp); 2041 return NULL; 2042} 2043 2044/* DEVLINK_CMD_HEALTH_REPORTER_GET - dump */ 2045void 2046devlink_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 2061struct devlink_health_reporter_get_list * 2062devlink_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 2091free_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 */ 2098void 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 2106void 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 2114int 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 2164struct devlink_trap_get_rsp * 2165devlink_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 2194err_free: 2195 devlink_trap_get_rsp_free(rsp); 2196 return NULL; 2197} 2198 2199/* DEVLINK_CMD_TRAP_GET - dump */ 2200void 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 2215struct devlink_trap_get_list * 2216devlink_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 2243free_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 */ 2250void 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 2258void 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 2266int 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 2316struct devlink_trap_group_get_rsp * 2317devlink_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 2347err_free: 2348 devlink_trap_group_get_rsp_free(rsp); 2349 return NULL; 2350} 2351 2352/* DEVLINK_CMD_TRAP_GROUP_GET - dump */ 2353void 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 2368struct devlink_trap_group_get_list * 2369devlink_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 2396free_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 */ 2403void 2404devlink_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 2411void 2412devlink_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 2419int 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 2463struct devlink_trap_policer_get_rsp * 2464devlink_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 2494err_free: 2495 devlink_trap_policer_get_rsp_free(rsp); 2496 return NULL; 2497} 2498 2499/* DEVLINK_CMD_TRAP_POLICER_GET - dump */ 2500void 2501devlink_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 2515struct devlink_trap_policer_get_list * 2516devlink_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 2543free_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 */ 2550void 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 2558void 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 2566int 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 2621struct devlink_rate_get_rsp * 2622devlink_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 2653err_free: 2654 devlink_rate_get_rsp_free(rsp); 2655 return NULL; 2656} 2657 2658/* DEVLINK_CMD_RATE_GET - dump */ 2659void 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 2674struct devlink_rate_get_list * 2675devlink_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 2702free_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 */ 2709void 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 2716void 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 2723int 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 2767struct devlink_linecard_get_rsp * 2768devlink_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 2797err_free: 2798 devlink_linecard_get_rsp_free(rsp); 2799 return NULL; 2800} 2801 2802/* DEVLINK_CMD_LINECARD_GET - dump */ 2803void 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 2817struct devlink_linecard_get_list * 2818devlink_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 2845free_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 */ 2852void 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 2859void 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 2866int 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 2905struct devlink_selftests_get_rsp * 2906devlink_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 2934err_free: 2935 devlink_selftests_get_rsp_free(rsp); 2936 return NULL; 2937} 2938 2939/* DEVLINK_CMD_SELFTESTS_GET - dump */ 2940void 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 2954struct devlink_selftests_get_list * 2955devlink_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 2975free_list: 2976 devlink_selftests_get_list_free(yds.first); 2977 return NULL; 2978} 2979 2980const struct ynl_family ynl_devlink_family = { 2981 .name = "devlink", 2982}; 2983