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 header */ 5 6#ifndef _LINUX_DEVLINK_GEN_H 7#define _LINUX_DEVLINK_GEN_H 8 9#include <stdlib.h> 10#include <string.h> 11#include <linux/types.h> 12#include <linux/devlink.h> 13 14struct ynl_sock; 15 16extern const struct ynl_family ynl_devlink_family; 17 18/* Enums */ 19const char *devlink_op_str(int op); 20const char *devlink_sb_pool_type_str(enum devlink_sb_pool_type value); 21 22/* Common nested types */ 23struct devlink_dl_info_version { 24 struct { 25 __u32 info_version_name_len; 26 __u32 info_version_value_len; 27 } _present; 28 29 char *info_version_name; 30 char *info_version_value; 31}; 32 33struct devlink_dl_reload_stats_entry { 34 struct { 35 __u32 reload_stats_limit:1; 36 __u32 reload_stats_value:1; 37 } _present; 38 39 __u8 reload_stats_limit; 40 __u32 reload_stats_value; 41}; 42 43struct devlink_dl_reload_act_stats { 44 unsigned int n_reload_stats_entry; 45 struct devlink_dl_reload_stats_entry *reload_stats_entry; 46}; 47 48struct devlink_dl_reload_act_info { 49 struct { 50 __u32 reload_action:1; 51 } _present; 52 53 __u8 reload_action; 54 unsigned int n_reload_action_stats; 55 struct devlink_dl_reload_act_stats *reload_action_stats; 56}; 57 58struct devlink_dl_reload_stats { 59 unsigned int n_reload_action_info; 60 struct devlink_dl_reload_act_info *reload_action_info; 61}; 62 63struct devlink_dl_dev_stats { 64 struct { 65 __u32 reload_stats:1; 66 __u32 remote_reload_stats:1; 67 } _present; 68 69 struct devlink_dl_reload_stats reload_stats; 70 struct devlink_dl_reload_stats remote_reload_stats; 71}; 72 73/* ============== DEVLINK_CMD_GET ============== */ 74/* DEVLINK_CMD_GET - do */ 75struct devlink_get_req { 76 struct { 77 __u32 bus_name_len; 78 __u32 dev_name_len; 79 } _present; 80 81 char *bus_name; 82 char *dev_name; 83}; 84 85static inline struct devlink_get_req *devlink_get_req_alloc(void) 86{ 87 return calloc(1, sizeof(struct devlink_get_req)); 88} 89void devlink_get_req_free(struct devlink_get_req *req); 90 91static inline void 92devlink_get_req_set_bus_name(struct devlink_get_req *req, const char *bus_name) 93{ 94 free(req->bus_name); 95 req->_present.bus_name_len = strlen(bus_name); 96 req->bus_name = malloc(req->_present.bus_name_len + 1); 97 memcpy(req->bus_name, bus_name, req->_present.bus_name_len); 98 req->bus_name[req->_present.bus_name_len] = 0; 99} 100static inline void 101devlink_get_req_set_dev_name(struct devlink_get_req *req, const char *dev_name) 102{ 103 free(req->dev_name); 104 req->_present.dev_name_len = strlen(dev_name); 105 req->dev_name = malloc(req->_present.dev_name_len + 1); 106 memcpy(req->dev_name, dev_name, req->_present.dev_name_len); 107 req->dev_name[req->_present.dev_name_len] = 0; 108} 109 110struct devlink_get_rsp { 111 struct { 112 __u32 bus_name_len; 113 __u32 dev_name_len; 114 __u32 reload_failed:1; 115 __u32 reload_action:1; 116 __u32 dev_stats:1; 117 } _present; 118 119 char *bus_name; 120 char *dev_name; 121 __u8 reload_failed; 122 __u8 reload_action; 123 struct devlink_dl_dev_stats dev_stats; 124}; 125 126void devlink_get_rsp_free(struct devlink_get_rsp *rsp); 127 128/* 129 * Get devlink instances. 130 */ 131struct devlink_get_rsp * 132devlink_get(struct ynl_sock *ys, struct devlink_get_req *req); 133 134/* DEVLINK_CMD_GET - dump */ 135struct devlink_get_list { 136 struct devlink_get_list *next; 137 struct devlink_get_rsp obj __attribute__ ((aligned (8))); 138}; 139 140void devlink_get_list_free(struct devlink_get_list *rsp); 141 142struct devlink_get_list *devlink_get_dump(struct ynl_sock *ys); 143 144/* ============== DEVLINK_CMD_PORT_GET ============== */ 145/* DEVLINK_CMD_PORT_GET - do */ 146struct devlink_port_get_req { 147 struct { 148 __u32 bus_name_len; 149 __u32 dev_name_len; 150 __u32 port_index:1; 151 } _present; 152 153 char *bus_name; 154 char *dev_name; 155 __u32 port_index; 156}; 157 158static inline struct devlink_port_get_req *devlink_port_get_req_alloc(void) 159{ 160 return calloc(1, sizeof(struct devlink_port_get_req)); 161} 162void devlink_port_get_req_free(struct devlink_port_get_req *req); 163 164static inline void 165devlink_port_get_req_set_bus_name(struct devlink_port_get_req *req, 166 const char *bus_name) 167{ 168 free(req->bus_name); 169 req->_present.bus_name_len = strlen(bus_name); 170 req->bus_name = malloc(req->_present.bus_name_len + 1); 171 memcpy(req->bus_name, bus_name, req->_present.bus_name_len); 172 req->bus_name[req->_present.bus_name_len] = 0; 173} 174static inline void 175devlink_port_get_req_set_dev_name(struct devlink_port_get_req *req, 176 const char *dev_name) 177{ 178 free(req->dev_name); 179 req->_present.dev_name_len = strlen(dev_name); 180 req->dev_name = malloc(req->_present.dev_name_len + 1); 181 memcpy(req->dev_name, dev_name, req->_present.dev_name_len); 182 req->dev_name[req->_present.dev_name_len] = 0; 183} 184static inline void 185devlink_port_get_req_set_port_index(struct devlink_port_get_req *req, 186 __u32 port_index) 187{ 188 req->_present.port_index = 1; 189 req->port_index = port_index; 190} 191 192struct devlink_port_get_rsp { 193 struct { 194 __u32 bus_name_len; 195 __u32 dev_name_len; 196 __u32 port_index:1; 197 } _present; 198 199 char *bus_name; 200 char *dev_name; 201 __u32 port_index; 202}; 203 204void devlink_port_get_rsp_free(struct devlink_port_get_rsp *rsp); 205 206/* 207 * Get devlink port instances. 208 */ 209struct devlink_port_get_rsp * 210devlink_port_get(struct ynl_sock *ys, struct devlink_port_get_req *req); 211 212/* DEVLINK_CMD_PORT_GET - dump */ 213struct devlink_port_get_req_dump { 214 struct { 215 __u32 bus_name_len; 216 __u32 dev_name_len; 217 } _present; 218 219 char *bus_name; 220 char *dev_name; 221}; 222 223static inline struct devlink_port_get_req_dump * 224devlink_port_get_req_dump_alloc(void) 225{ 226 return calloc(1, sizeof(struct devlink_port_get_req_dump)); 227} 228void devlink_port_get_req_dump_free(struct devlink_port_get_req_dump *req); 229 230static inline void 231devlink_port_get_req_dump_set_bus_name(struct devlink_port_get_req_dump *req, 232 const char *bus_name) 233{ 234 free(req->bus_name); 235 req->_present.bus_name_len = strlen(bus_name); 236 req->bus_name = malloc(req->_present.bus_name_len + 1); 237 memcpy(req->bus_name, bus_name, req->_present.bus_name_len); 238 req->bus_name[req->_present.bus_name_len] = 0; 239} 240static inline void 241devlink_port_get_req_dump_set_dev_name(struct devlink_port_get_req_dump *req, 242 const char *dev_name) 243{ 244 free(req->dev_name); 245 req->_present.dev_name_len = strlen(dev_name); 246 req->dev_name = malloc(req->_present.dev_name_len + 1); 247 memcpy(req->dev_name, dev_name, req->_present.dev_name_len); 248 req->dev_name[req->_present.dev_name_len] = 0; 249} 250 251struct devlink_port_get_rsp_dump { 252 struct { 253 __u32 bus_name_len; 254 __u32 dev_name_len; 255 __u32 port_index:1; 256 } _present; 257 258 char *bus_name; 259 char *dev_name; 260 __u32 port_index; 261}; 262 263struct devlink_port_get_rsp_list { 264 struct devlink_port_get_rsp_list *next; 265 struct devlink_port_get_rsp_dump obj __attribute__ ((aligned (8))); 266}; 267 268void devlink_port_get_rsp_list_free(struct devlink_port_get_rsp_list *rsp); 269 270struct devlink_port_get_rsp_list * 271devlink_port_get_dump(struct ynl_sock *ys, 272 struct devlink_port_get_req_dump *req); 273 274/* ============== DEVLINK_CMD_SB_GET ============== */ 275/* DEVLINK_CMD_SB_GET - do */ 276struct devlink_sb_get_req { 277 struct { 278 __u32 bus_name_len; 279 __u32 dev_name_len; 280 __u32 sb_index:1; 281 } _present; 282 283 char *bus_name; 284 char *dev_name; 285 __u32 sb_index; 286}; 287 288static inline struct devlink_sb_get_req *devlink_sb_get_req_alloc(void) 289{ 290 return calloc(1, sizeof(struct devlink_sb_get_req)); 291} 292void devlink_sb_get_req_free(struct devlink_sb_get_req *req); 293 294static inline void 295devlink_sb_get_req_set_bus_name(struct devlink_sb_get_req *req, 296 const char *bus_name) 297{ 298 free(req->bus_name); 299 req->_present.bus_name_len = strlen(bus_name); 300 req->bus_name = malloc(req->_present.bus_name_len + 1); 301 memcpy(req->bus_name, bus_name, req->_present.bus_name_len); 302 req->bus_name[req->_present.bus_name_len] = 0; 303} 304static inline void 305devlink_sb_get_req_set_dev_name(struct devlink_sb_get_req *req, 306 const char *dev_name) 307{ 308 free(req->dev_name); 309 req->_present.dev_name_len = strlen(dev_name); 310 req->dev_name = malloc(req->_present.dev_name_len + 1); 311 memcpy(req->dev_name, dev_name, req->_present.dev_name_len); 312 req->dev_name[req->_present.dev_name_len] = 0; 313} 314static inline void 315devlink_sb_get_req_set_sb_index(struct devlink_sb_get_req *req, __u32 sb_index) 316{ 317 req->_present.sb_index = 1; 318 req->sb_index = sb_index; 319} 320 321struct devlink_sb_get_rsp { 322 struct { 323 __u32 bus_name_len; 324 __u32 dev_name_len; 325 __u32 sb_index:1; 326 } _present; 327 328 char *bus_name; 329 char *dev_name; 330 __u32 sb_index; 331}; 332 333void devlink_sb_get_rsp_free(struct devlink_sb_get_rsp *rsp); 334 335/* 336 * Get shared buffer instances. 337 */ 338struct devlink_sb_get_rsp * 339devlink_sb_get(struct ynl_sock *ys, struct devlink_sb_get_req *req); 340 341/* DEVLINK_CMD_SB_GET - dump */ 342struct devlink_sb_get_req_dump { 343 struct { 344 __u32 bus_name_len; 345 __u32 dev_name_len; 346 } _present; 347 348 char *bus_name; 349 char *dev_name; 350}; 351 352static inline struct devlink_sb_get_req_dump * 353devlink_sb_get_req_dump_alloc(void) 354{ 355 return calloc(1, sizeof(struct devlink_sb_get_req_dump)); 356} 357void devlink_sb_get_req_dump_free(struct devlink_sb_get_req_dump *req); 358 359static inline void 360devlink_sb_get_req_dump_set_bus_name(struct devlink_sb_get_req_dump *req, 361 const char *bus_name) 362{ 363 free(req->bus_name); 364 req->_present.bus_name_len = strlen(bus_name); 365 req->bus_name = malloc(req->_present.bus_name_len + 1); 366 memcpy(req->bus_name, bus_name, req->_present.bus_name_len); 367 req->bus_name[req->_present.bus_name_len] = 0; 368} 369static inline void 370devlink_sb_get_req_dump_set_dev_name(struct devlink_sb_get_req_dump *req, 371 const char *dev_name) 372{ 373 free(req->dev_name); 374 req->_present.dev_name_len = strlen(dev_name); 375 req->dev_name = malloc(req->_present.dev_name_len + 1); 376 memcpy(req->dev_name, dev_name, req->_present.dev_name_len); 377 req->dev_name[req->_present.dev_name_len] = 0; 378} 379 380struct devlink_sb_get_list { 381 struct devlink_sb_get_list *next; 382 struct devlink_sb_get_rsp obj __attribute__ ((aligned (8))); 383}; 384 385void devlink_sb_get_list_free(struct devlink_sb_get_list *rsp); 386 387struct devlink_sb_get_list * 388devlink_sb_get_dump(struct ynl_sock *ys, struct devlink_sb_get_req_dump *req); 389 390/* ============== DEVLINK_CMD_SB_POOL_GET ============== */ 391/* DEVLINK_CMD_SB_POOL_GET - do */ 392struct devlink_sb_pool_get_req { 393 struct { 394 __u32 bus_name_len; 395 __u32 dev_name_len; 396 __u32 sb_index:1; 397 __u32 sb_pool_index:1; 398 } _present; 399 400 char *bus_name; 401 char *dev_name; 402 __u32 sb_index; 403 __u16 sb_pool_index; 404}; 405 406static inline struct devlink_sb_pool_get_req * 407devlink_sb_pool_get_req_alloc(void) 408{ 409 return calloc(1, sizeof(struct devlink_sb_pool_get_req)); 410} 411void devlink_sb_pool_get_req_free(struct devlink_sb_pool_get_req *req); 412 413static inline void 414devlink_sb_pool_get_req_set_bus_name(struct devlink_sb_pool_get_req *req, 415 const char *bus_name) 416{ 417 free(req->bus_name); 418 req->_present.bus_name_len = strlen(bus_name); 419 req->bus_name = malloc(req->_present.bus_name_len + 1); 420 memcpy(req->bus_name, bus_name, req->_present.bus_name_len); 421 req->bus_name[req->_present.bus_name_len] = 0; 422} 423static inline void 424devlink_sb_pool_get_req_set_dev_name(struct devlink_sb_pool_get_req *req, 425 const char *dev_name) 426{ 427 free(req->dev_name); 428 req->_present.dev_name_len = strlen(dev_name); 429 req->dev_name = malloc(req->_present.dev_name_len + 1); 430 memcpy(req->dev_name, dev_name, req->_present.dev_name_len); 431 req->dev_name[req->_present.dev_name_len] = 0; 432} 433static inline void 434devlink_sb_pool_get_req_set_sb_index(struct devlink_sb_pool_get_req *req, 435 __u32 sb_index) 436{ 437 req->_present.sb_index = 1; 438 req->sb_index = sb_index; 439} 440static inline void 441devlink_sb_pool_get_req_set_sb_pool_index(struct devlink_sb_pool_get_req *req, 442 __u16 sb_pool_index) 443{ 444 req->_present.sb_pool_index = 1; 445 req->sb_pool_index = sb_pool_index; 446} 447 448struct devlink_sb_pool_get_rsp { 449 struct { 450 __u32 bus_name_len; 451 __u32 dev_name_len; 452 __u32 sb_index:1; 453 __u32 sb_pool_index:1; 454 } _present; 455 456 char *bus_name; 457 char *dev_name; 458 __u32 sb_index; 459 __u16 sb_pool_index; 460}; 461 462void devlink_sb_pool_get_rsp_free(struct devlink_sb_pool_get_rsp *rsp); 463 464/* 465 * Get shared buffer pool instances. 466 */ 467struct devlink_sb_pool_get_rsp * 468devlink_sb_pool_get(struct ynl_sock *ys, struct devlink_sb_pool_get_req *req); 469 470/* DEVLINK_CMD_SB_POOL_GET - dump */ 471struct devlink_sb_pool_get_req_dump { 472 struct { 473 __u32 bus_name_len; 474 __u32 dev_name_len; 475 } _present; 476 477 char *bus_name; 478 char *dev_name; 479}; 480 481static inline struct devlink_sb_pool_get_req_dump * 482devlink_sb_pool_get_req_dump_alloc(void) 483{ 484 return calloc(1, sizeof(struct devlink_sb_pool_get_req_dump)); 485} 486void 487devlink_sb_pool_get_req_dump_free(struct devlink_sb_pool_get_req_dump *req); 488 489static inline void 490devlink_sb_pool_get_req_dump_set_bus_name(struct devlink_sb_pool_get_req_dump *req, 491 const char *bus_name) 492{ 493 free(req->bus_name); 494 req->_present.bus_name_len = strlen(bus_name); 495 req->bus_name = malloc(req->_present.bus_name_len + 1); 496 memcpy(req->bus_name, bus_name, req->_present.bus_name_len); 497 req->bus_name[req->_present.bus_name_len] = 0; 498} 499static inline void 500devlink_sb_pool_get_req_dump_set_dev_name(struct devlink_sb_pool_get_req_dump *req, 501 const char *dev_name) 502{ 503 free(req->dev_name); 504 req->_present.dev_name_len = strlen(dev_name); 505 req->dev_name = malloc(req->_present.dev_name_len + 1); 506 memcpy(req->dev_name, dev_name, req->_present.dev_name_len); 507 req->dev_name[req->_present.dev_name_len] = 0; 508} 509 510struct devlink_sb_pool_get_list { 511 struct devlink_sb_pool_get_list *next; 512 struct devlink_sb_pool_get_rsp obj __attribute__ ((aligned (8))); 513}; 514 515void devlink_sb_pool_get_list_free(struct devlink_sb_pool_get_list *rsp); 516 517struct devlink_sb_pool_get_list * 518devlink_sb_pool_get_dump(struct ynl_sock *ys, 519 struct devlink_sb_pool_get_req_dump *req); 520 521/* ============== DEVLINK_CMD_SB_PORT_POOL_GET ============== */ 522/* DEVLINK_CMD_SB_PORT_POOL_GET - do */ 523struct devlink_sb_port_pool_get_req { 524 struct { 525 __u32 bus_name_len; 526 __u32 dev_name_len; 527 __u32 port_index:1; 528 __u32 sb_index:1; 529 __u32 sb_pool_index:1; 530 } _present; 531 532 char *bus_name; 533 char *dev_name; 534 __u32 port_index; 535 __u32 sb_index; 536 __u16 sb_pool_index; 537}; 538 539static inline struct devlink_sb_port_pool_get_req * 540devlink_sb_port_pool_get_req_alloc(void) 541{ 542 return calloc(1, sizeof(struct devlink_sb_port_pool_get_req)); 543} 544void 545devlink_sb_port_pool_get_req_free(struct devlink_sb_port_pool_get_req *req); 546 547static inline void 548devlink_sb_port_pool_get_req_set_bus_name(struct devlink_sb_port_pool_get_req *req, 549 const char *bus_name) 550{ 551 free(req->bus_name); 552 req->_present.bus_name_len = strlen(bus_name); 553 req->bus_name = malloc(req->_present.bus_name_len + 1); 554 memcpy(req->bus_name, bus_name, req->_present.bus_name_len); 555 req->bus_name[req->_present.bus_name_len] = 0; 556} 557static inline void 558devlink_sb_port_pool_get_req_set_dev_name(struct devlink_sb_port_pool_get_req *req, 559 const char *dev_name) 560{ 561 free(req->dev_name); 562 req->_present.dev_name_len = strlen(dev_name); 563 req->dev_name = malloc(req->_present.dev_name_len + 1); 564 memcpy(req->dev_name, dev_name, req->_present.dev_name_len); 565 req->dev_name[req->_present.dev_name_len] = 0; 566} 567static inline void 568devlink_sb_port_pool_get_req_set_port_index(struct devlink_sb_port_pool_get_req *req, 569 __u32 port_index) 570{ 571 req->_present.port_index = 1; 572 req->port_index = port_index; 573} 574static inline void 575devlink_sb_port_pool_get_req_set_sb_index(struct devlink_sb_port_pool_get_req *req, 576 __u32 sb_index) 577{ 578 req->_present.sb_index = 1; 579 req->sb_index = sb_index; 580} 581static inline void 582devlink_sb_port_pool_get_req_set_sb_pool_index(struct devlink_sb_port_pool_get_req *req, 583 __u16 sb_pool_index) 584{ 585 req->_present.sb_pool_index = 1; 586 req->sb_pool_index = sb_pool_index; 587} 588 589struct devlink_sb_port_pool_get_rsp { 590 struct { 591 __u32 bus_name_len; 592 __u32 dev_name_len; 593 __u32 port_index:1; 594 __u32 sb_index:1; 595 __u32 sb_pool_index:1; 596 } _present; 597 598 char *bus_name; 599 char *dev_name; 600 __u32 port_index; 601 __u32 sb_index; 602 __u16 sb_pool_index; 603}; 604 605void 606devlink_sb_port_pool_get_rsp_free(struct devlink_sb_port_pool_get_rsp *rsp); 607 608/* 609 * Get shared buffer port-pool combinations and threshold. 610 */ 611struct devlink_sb_port_pool_get_rsp * 612devlink_sb_port_pool_get(struct ynl_sock *ys, 613 struct devlink_sb_port_pool_get_req *req); 614 615/* DEVLINK_CMD_SB_PORT_POOL_GET - dump */ 616struct devlink_sb_port_pool_get_req_dump { 617 struct { 618 __u32 bus_name_len; 619 __u32 dev_name_len; 620 } _present; 621 622 char *bus_name; 623 char *dev_name; 624}; 625 626static inline struct devlink_sb_port_pool_get_req_dump * 627devlink_sb_port_pool_get_req_dump_alloc(void) 628{ 629 return calloc(1, sizeof(struct devlink_sb_port_pool_get_req_dump)); 630} 631void 632devlink_sb_port_pool_get_req_dump_free(struct devlink_sb_port_pool_get_req_dump *req); 633 634static inline void 635devlink_sb_port_pool_get_req_dump_set_bus_name(struct devlink_sb_port_pool_get_req_dump *req, 636 const char *bus_name) 637{ 638 free(req->bus_name); 639 req->_present.bus_name_len = strlen(bus_name); 640 req->bus_name = malloc(req->_present.bus_name_len + 1); 641 memcpy(req->bus_name, bus_name, req->_present.bus_name_len); 642 req->bus_name[req->_present.bus_name_len] = 0; 643} 644static inline void 645devlink_sb_port_pool_get_req_dump_set_dev_name(struct devlink_sb_port_pool_get_req_dump *req, 646 const char *dev_name) 647{ 648 free(req->dev_name); 649 req->_present.dev_name_len = strlen(dev_name); 650 req->dev_name = malloc(req->_present.dev_name_len + 1); 651 memcpy(req->dev_name, dev_name, req->_present.dev_name_len); 652 req->dev_name[req->_present.dev_name_len] = 0; 653} 654 655struct devlink_sb_port_pool_get_list { 656 struct devlink_sb_port_pool_get_list *next; 657 struct devlink_sb_port_pool_get_rsp obj __attribute__ ((aligned (8))); 658}; 659 660void 661devlink_sb_port_pool_get_list_free(struct devlink_sb_port_pool_get_list *rsp); 662 663struct devlink_sb_port_pool_get_list * 664devlink_sb_port_pool_get_dump(struct ynl_sock *ys, 665 struct devlink_sb_port_pool_get_req_dump *req); 666 667/* ============== DEVLINK_CMD_SB_TC_POOL_BIND_GET ============== */ 668/* DEVLINK_CMD_SB_TC_POOL_BIND_GET - do */ 669struct devlink_sb_tc_pool_bind_get_req { 670 struct { 671 __u32 bus_name_len; 672 __u32 dev_name_len; 673 __u32 port_index:1; 674 __u32 sb_index:1; 675 __u32 sb_pool_type:1; 676 __u32 sb_tc_index:1; 677 } _present; 678 679 char *bus_name; 680 char *dev_name; 681 __u32 port_index; 682 __u32 sb_index; 683 enum devlink_sb_pool_type sb_pool_type; 684 __u16 sb_tc_index; 685}; 686 687static inline struct devlink_sb_tc_pool_bind_get_req * 688devlink_sb_tc_pool_bind_get_req_alloc(void) 689{ 690 return calloc(1, sizeof(struct devlink_sb_tc_pool_bind_get_req)); 691} 692void 693devlink_sb_tc_pool_bind_get_req_free(struct devlink_sb_tc_pool_bind_get_req *req); 694 695static inline void 696devlink_sb_tc_pool_bind_get_req_set_bus_name(struct devlink_sb_tc_pool_bind_get_req *req, 697 const char *bus_name) 698{ 699 free(req->bus_name); 700 req->_present.bus_name_len = strlen(bus_name); 701 req->bus_name = malloc(req->_present.bus_name_len + 1); 702 memcpy(req->bus_name, bus_name, req->_present.bus_name_len); 703 req->bus_name[req->_present.bus_name_len] = 0; 704} 705static inline void 706devlink_sb_tc_pool_bind_get_req_set_dev_name(struct devlink_sb_tc_pool_bind_get_req *req, 707 const char *dev_name) 708{ 709 free(req->dev_name); 710 req->_present.dev_name_len = strlen(dev_name); 711 req->dev_name = malloc(req->_present.dev_name_len + 1); 712 memcpy(req->dev_name, dev_name, req->_present.dev_name_len); 713 req->dev_name[req->_present.dev_name_len] = 0; 714} 715static inline void 716devlink_sb_tc_pool_bind_get_req_set_port_index(struct devlink_sb_tc_pool_bind_get_req *req, 717 __u32 port_index) 718{ 719 req->_present.port_index = 1; 720 req->port_index = port_index; 721} 722static inline void 723devlink_sb_tc_pool_bind_get_req_set_sb_index(struct devlink_sb_tc_pool_bind_get_req *req, 724 __u32 sb_index) 725{ 726 req->_present.sb_index = 1; 727 req->sb_index = sb_index; 728} 729static inline void 730devlink_sb_tc_pool_bind_get_req_set_sb_pool_type(struct devlink_sb_tc_pool_bind_get_req *req, 731 enum devlink_sb_pool_type sb_pool_type) 732{ 733 req->_present.sb_pool_type = 1; 734 req->sb_pool_type = sb_pool_type; 735} 736static inline void 737devlink_sb_tc_pool_bind_get_req_set_sb_tc_index(struct devlink_sb_tc_pool_bind_get_req *req, 738 __u16 sb_tc_index) 739{ 740 req->_present.sb_tc_index = 1; 741 req->sb_tc_index = sb_tc_index; 742} 743 744struct devlink_sb_tc_pool_bind_get_rsp { 745 struct { 746 __u32 bus_name_len; 747 __u32 dev_name_len; 748 __u32 port_index:1; 749 __u32 sb_index:1; 750 __u32 sb_pool_type:1; 751 __u32 sb_tc_index:1; 752 } _present; 753 754 char *bus_name; 755 char *dev_name; 756 __u32 port_index; 757 __u32 sb_index; 758 enum devlink_sb_pool_type sb_pool_type; 759 __u16 sb_tc_index; 760}; 761 762void 763devlink_sb_tc_pool_bind_get_rsp_free(struct devlink_sb_tc_pool_bind_get_rsp *rsp); 764 765/* 766 * Get shared buffer port-TC to pool bindings and threshold. 767 */ 768struct devlink_sb_tc_pool_bind_get_rsp * 769devlink_sb_tc_pool_bind_get(struct ynl_sock *ys, 770 struct devlink_sb_tc_pool_bind_get_req *req); 771 772/* DEVLINK_CMD_SB_TC_POOL_BIND_GET - dump */ 773struct devlink_sb_tc_pool_bind_get_req_dump { 774 struct { 775 __u32 bus_name_len; 776 __u32 dev_name_len; 777 } _present; 778 779 char *bus_name; 780 char *dev_name; 781}; 782 783static inline struct devlink_sb_tc_pool_bind_get_req_dump * 784devlink_sb_tc_pool_bind_get_req_dump_alloc(void) 785{ 786 return calloc(1, sizeof(struct devlink_sb_tc_pool_bind_get_req_dump)); 787} 788void 789devlink_sb_tc_pool_bind_get_req_dump_free(struct devlink_sb_tc_pool_bind_get_req_dump *req); 790 791static inline void 792devlink_sb_tc_pool_bind_get_req_dump_set_bus_name(struct devlink_sb_tc_pool_bind_get_req_dump *req, 793 const char *bus_name) 794{ 795 free(req->bus_name); 796 req->_present.bus_name_len = strlen(bus_name); 797 req->bus_name = malloc(req->_present.bus_name_len + 1); 798 memcpy(req->bus_name, bus_name, req->_present.bus_name_len); 799 req->bus_name[req->_present.bus_name_len] = 0; 800} 801static inline void 802devlink_sb_tc_pool_bind_get_req_dump_set_dev_name(struct devlink_sb_tc_pool_bind_get_req_dump *req, 803 const char *dev_name) 804{ 805 free(req->dev_name); 806 req->_present.dev_name_len = strlen(dev_name); 807 req->dev_name = malloc(req->_present.dev_name_len + 1); 808 memcpy(req->dev_name, dev_name, req->_present.dev_name_len); 809 req->dev_name[req->_present.dev_name_len] = 0; 810} 811 812struct devlink_sb_tc_pool_bind_get_list { 813 struct devlink_sb_tc_pool_bind_get_list *next; 814 struct devlink_sb_tc_pool_bind_get_rsp obj __attribute__ ((aligned (8))); 815}; 816 817void 818devlink_sb_tc_pool_bind_get_list_free(struct devlink_sb_tc_pool_bind_get_list *rsp); 819 820struct devlink_sb_tc_pool_bind_get_list * 821devlink_sb_tc_pool_bind_get_dump(struct ynl_sock *ys, 822 struct devlink_sb_tc_pool_bind_get_req_dump *req); 823 824/* ============== DEVLINK_CMD_PARAM_GET ============== */ 825/* DEVLINK_CMD_PARAM_GET - do */ 826struct devlink_param_get_req { 827 struct { 828 __u32 bus_name_len; 829 __u32 dev_name_len; 830 __u32 param_name_len; 831 } _present; 832 833 char *bus_name; 834 char *dev_name; 835 char *param_name; 836}; 837 838static inline struct devlink_param_get_req *devlink_param_get_req_alloc(void) 839{ 840 return calloc(1, sizeof(struct devlink_param_get_req)); 841} 842void devlink_param_get_req_free(struct devlink_param_get_req *req); 843 844static inline void 845devlink_param_get_req_set_bus_name(struct devlink_param_get_req *req, 846 const char *bus_name) 847{ 848 free(req->bus_name); 849 req->_present.bus_name_len = strlen(bus_name); 850 req->bus_name = malloc(req->_present.bus_name_len + 1); 851 memcpy(req->bus_name, bus_name, req->_present.bus_name_len); 852 req->bus_name[req->_present.bus_name_len] = 0; 853} 854static inline void 855devlink_param_get_req_set_dev_name(struct devlink_param_get_req *req, 856 const char *dev_name) 857{ 858 free(req->dev_name); 859 req->_present.dev_name_len = strlen(dev_name); 860 req->dev_name = malloc(req->_present.dev_name_len + 1); 861 memcpy(req->dev_name, dev_name, req->_present.dev_name_len); 862 req->dev_name[req->_present.dev_name_len] = 0; 863} 864static inline void 865devlink_param_get_req_set_param_name(struct devlink_param_get_req *req, 866 const char *param_name) 867{ 868 free(req->param_name); 869 req->_present.param_name_len = strlen(param_name); 870 req->param_name = malloc(req->_present.param_name_len + 1); 871 memcpy(req->param_name, param_name, req->_present.param_name_len); 872 req->param_name[req->_present.param_name_len] = 0; 873} 874 875struct devlink_param_get_rsp { 876 struct { 877 __u32 bus_name_len; 878 __u32 dev_name_len; 879 __u32 param_name_len; 880 } _present; 881 882 char *bus_name; 883 char *dev_name; 884 char *param_name; 885}; 886 887void devlink_param_get_rsp_free(struct devlink_param_get_rsp *rsp); 888 889/* 890 * Get param instances. 891 */ 892struct devlink_param_get_rsp * 893devlink_param_get(struct ynl_sock *ys, struct devlink_param_get_req *req); 894 895/* DEVLINK_CMD_PARAM_GET - dump */ 896struct devlink_param_get_req_dump { 897 struct { 898 __u32 bus_name_len; 899 __u32 dev_name_len; 900 } _present; 901 902 char *bus_name; 903 char *dev_name; 904}; 905 906static inline struct devlink_param_get_req_dump * 907devlink_param_get_req_dump_alloc(void) 908{ 909 return calloc(1, sizeof(struct devlink_param_get_req_dump)); 910} 911void devlink_param_get_req_dump_free(struct devlink_param_get_req_dump *req); 912 913static inline void 914devlink_param_get_req_dump_set_bus_name(struct devlink_param_get_req_dump *req, 915 const char *bus_name) 916{ 917 free(req->bus_name); 918 req->_present.bus_name_len = strlen(bus_name); 919 req->bus_name = malloc(req->_present.bus_name_len + 1); 920 memcpy(req->bus_name, bus_name, req->_present.bus_name_len); 921 req->bus_name[req->_present.bus_name_len] = 0; 922} 923static inline void 924devlink_param_get_req_dump_set_dev_name(struct devlink_param_get_req_dump *req, 925 const char *dev_name) 926{ 927 free(req->dev_name); 928 req->_present.dev_name_len = strlen(dev_name); 929 req->dev_name = malloc(req->_present.dev_name_len + 1); 930 memcpy(req->dev_name, dev_name, req->_present.dev_name_len); 931 req->dev_name[req->_present.dev_name_len] = 0; 932} 933 934struct devlink_param_get_list { 935 struct devlink_param_get_list *next; 936 struct devlink_param_get_rsp obj __attribute__ ((aligned (8))); 937}; 938 939void devlink_param_get_list_free(struct devlink_param_get_list *rsp); 940 941struct devlink_param_get_list * 942devlink_param_get_dump(struct ynl_sock *ys, 943 struct devlink_param_get_req_dump *req); 944 945/* ============== DEVLINK_CMD_REGION_GET ============== */ 946/* DEVLINK_CMD_REGION_GET - do */ 947struct devlink_region_get_req { 948 struct { 949 __u32 bus_name_len; 950 __u32 dev_name_len; 951 __u32 port_index:1; 952 __u32 region_name_len; 953 } _present; 954 955 char *bus_name; 956 char *dev_name; 957 __u32 port_index; 958 char *region_name; 959}; 960 961static inline struct devlink_region_get_req *devlink_region_get_req_alloc(void) 962{ 963 return calloc(1, sizeof(struct devlink_region_get_req)); 964} 965void devlink_region_get_req_free(struct devlink_region_get_req *req); 966 967static inline void 968devlink_region_get_req_set_bus_name(struct devlink_region_get_req *req, 969 const char *bus_name) 970{ 971 free(req->bus_name); 972 req->_present.bus_name_len = strlen(bus_name); 973 req->bus_name = malloc(req->_present.bus_name_len + 1); 974 memcpy(req->bus_name, bus_name, req->_present.bus_name_len); 975 req->bus_name[req->_present.bus_name_len] = 0; 976} 977static inline void 978devlink_region_get_req_set_dev_name(struct devlink_region_get_req *req, 979 const char *dev_name) 980{ 981 free(req->dev_name); 982 req->_present.dev_name_len = strlen(dev_name); 983 req->dev_name = malloc(req->_present.dev_name_len + 1); 984 memcpy(req->dev_name, dev_name, req->_present.dev_name_len); 985 req->dev_name[req->_present.dev_name_len] = 0; 986} 987static inline void 988devlink_region_get_req_set_port_index(struct devlink_region_get_req *req, 989 __u32 port_index) 990{ 991 req->_present.port_index = 1; 992 req->port_index = port_index; 993} 994static inline void 995devlink_region_get_req_set_region_name(struct devlink_region_get_req *req, 996 const char *region_name) 997{ 998 free(req->region_name); 999 req->_present.region_name_len = strlen(region_name); 1000 req->region_name = malloc(req->_present.region_name_len + 1); 1001 memcpy(req->region_name, region_name, req->_present.region_name_len); 1002 req->region_name[req->_present.region_name_len] = 0; 1003} 1004 1005struct devlink_region_get_rsp { 1006 struct { 1007 __u32 bus_name_len; 1008 __u32 dev_name_len; 1009 __u32 port_index:1; 1010 __u32 region_name_len; 1011 } _present; 1012 1013 char *bus_name; 1014 char *dev_name; 1015 __u32 port_index; 1016 char *region_name; 1017}; 1018 1019void devlink_region_get_rsp_free(struct devlink_region_get_rsp *rsp); 1020 1021/* 1022 * Get region instances. 1023 */ 1024struct devlink_region_get_rsp * 1025devlink_region_get(struct ynl_sock *ys, struct devlink_region_get_req *req); 1026 1027/* DEVLINK_CMD_REGION_GET - dump */ 1028struct devlink_region_get_req_dump { 1029 struct { 1030 __u32 bus_name_len; 1031 __u32 dev_name_len; 1032 } _present; 1033 1034 char *bus_name; 1035 char *dev_name; 1036}; 1037 1038static inline struct devlink_region_get_req_dump * 1039devlink_region_get_req_dump_alloc(void) 1040{ 1041 return calloc(1, sizeof(struct devlink_region_get_req_dump)); 1042} 1043void devlink_region_get_req_dump_free(struct devlink_region_get_req_dump *req); 1044 1045static inline void 1046devlink_region_get_req_dump_set_bus_name(struct devlink_region_get_req_dump *req, 1047 const char *bus_name) 1048{ 1049 free(req->bus_name); 1050 req->_present.bus_name_len = strlen(bus_name); 1051 req->bus_name = malloc(req->_present.bus_name_len + 1); 1052 memcpy(req->bus_name, bus_name, req->_present.bus_name_len); 1053 req->bus_name[req->_present.bus_name_len] = 0; 1054} 1055static inline void 1056devlink_region_get_req_dump_set_dev_name(struct devlink_region_get_req_dump *req, 1057 const char *dev_name) 1058{ 1059 free(req->dev_name); 1060 req->_present.dev_name_len = strlen(dev_name); 1061 req->dev_name = malloc(req->_present.dev_name_len + 1); 1062 memcpy(req->dev_name, dev_name, req->_present.dev_name_len); 1063 req->dev_name[req->_present.dev_name_len] = 0; 1064} 1065 1066struct devlink_region_get_list { 1067 struct devlink_region_get_list *next; 1068 struct devlink_region_get_rsp obj __attribute__ ((aligned (8))); 1069}; 1070 1071void devlink_region_get_list_free(struct devlink_region_get_list *rsp); 1072 1073struct devlink_region_get_list * 1074devlink_region_get_dump(struct ynl_sock *ys, 1075 struct devlink_region_get_req_dump *req); 1076 1077/* ============== DEVLINK_CMD_INFO_GET ============== */ 1078/* DEVLINK_CMD_INFO_GET - do */ 1079struct devlink_info_get_req { 1080 struct { 1081 __u32 bus_name_len; 1082 __u32 dev_name_len; 1083 } _present; 1084 1085 char *bus_name; 1086 char *dev_name; 1087}; 1088 1089static inline struct devlink_info_get_req *devlink_info_get_req_alloc(void) 1090{ 1091 return calloc(1, sizeof(struct devlink_info_get_req)); 1092} 1093void devlink_info_get_req_free(struct devlink_info_get_req *req); 1094 1095static inline void 1096devlink_info_get_req_set_bus_name(struct devlink_info_get_req *req, 1097 const char *bus_name) 1098{ 1099 free(req->bus_name); 1100 req->_present.bus_name_len = strlen(bus_name); 1101 req->bus_name = malloc(req->_present.bus_name_len + 1); 1102 memcpy(req->bus_name, bus_name, req->_present.bus_name_len); 1103 req->bus_name[req->_present.bus_name_len] = 0; 1104} 1105static inline void 1106devlink_info_get_req_set_dev_name(struct devlink_info_get_req *req, 1107 const char *dev_name) 1108{ 1109 free(req->dev_name); 1110 req->_present.dev_name_len = strlen(dev_name); 1111 req->dev_name = malloc(req->_present.dev_name_len + 1); 1112 memcpy(req->dev_name, dev_name, req->_present.dev_name_len); 1113 req->dev_name[req->_present.dev_name_len] = 0; 1114} 1115 1116struct devlink_info_get_rsp { 1117 struct { 1118 __u32 bus_name_len; 1119 __u32 dev_name_len; 1120 __u32 info_driver_name_len; 1121 __u32 info_serial_number_len; 1122 } _present; 1123 1124 char *bus_name; 1125 char *dev_name; 1126 char *info_driver_name; 1127 char *info_serial_number; 1128 unsigned int n_info_version_fixed; 1129 struct devlink_dl_info_version *info_version_fixed; 1130 unsigned int n_info_version_running; 1131 struct devlink_dl_info_version *info_version_running; 1132 unsigned int n_info_version_stored; 1133 struct devlink_dl_info_version *info_version_stored; 1134}; 1135 1136void devlink_info_get_rsp_free(struct devlink_info_get_rsp *rsp); 1137 1138/* 1139 * Get device information, like driver name, hardware and firmware versions etc. 1140 */ 1141struct devlink_info_get_rsp * 1142devlink_info_get(struct ynl_sock *ys, struct devlink_info_get_req *req); 1143 1144/* DEVLINK_CMD_INFO_GET - dump */ 1145struct devlink_info_get_list { 1146 struct devlink_info_get_list *next; 1147 struct devlink_info_get_rsp obj __attribute__ ((aligned (8))); 1148}; 1149 1150void devlink_info_get_list_free(struct devlink_info_get_list *rsp); 1151 1152struct devlink_info_get_list *devlink_info_get_dump(struct ynl_sock *ys); 1153 1154/* ============== DEVLINK_CMD_HEALTH_REPORTER_GET ============== */ 1155/* DEVLINK_CMD_HEALTH_REPORTER_GET - do */ 1156struct devlink_health_reporter_get_req { 1157 struct { 1158 __u32 bus_name_len; 1159 __u32 dev_name_len; 1160 __u32 port_index:1; 1161 __u32 health_reporter_name_len; 1162 } _present; 1163 1164 char *bus_name; 1165 char *dev_name; 1166 __u32 port_index; 1167 char *health_reporter_name; 1168}; 1169 1170static inline struct devlink_health_reporter_get_req * 1171devlink_health_reporter_get_req_alloc(void) 1172{ 1173 return calloc(1, sizeof(struct devlink_health_reporter_get_req)); 1174} 1175void 1176devlink_health_reporter_get_req_free(struct devlink_health_reporter_get_req *req); 1177 1178static inline void 1179devlink_health_reporter_get_req_set_bus_name(struct devlink_health_reporter_get_req *req, 1180 const char *bus_name) 1181{ 1182 free(req->bus_name); 1183 req->_present.bus_name_len = strlen(bus_name); 1184 req->bus_name = malloc(req->_present.bus_name_len + 1); 1185 memcpy(req->bus_name, bus_name, req->_present.bus_name_len); 1186 req->bus_name[req->_present.bus_name_len] = 0; 1187} 1188static inline void 1189devlink_health_reporter_get_req_set_dev_name(struct devlink_health_reporter_get_req *req, 1190 const char *dev_name) 1191{ 1192 free(req->dev_name); 1193 req->_present.dev_name_len = strlen(dev_name); 1194 req->dev_name = malloc(req->_present.dev_name_len + 1); 1195 memcpy(req->dev_name, dev_name, req->_present.dev_name_len); 1196 req->dev_name[req->_present.dev_name_len] = 0; 1197} 1198static inline void 1199devlink_health_reporter_get_req_set_port_index(struct devlink_health_reporter_get_req *req, 1200 __u32 port_index) 1201{ 1202 req->_present.port_index = 1; 1203 req->port_index = port_index; 1204} 1205static inline void 1206devlink_health_reporter_get_req_set_health_reporter_name(struct devlink_health_reporter_get_req *req, 1207 const char *health_reporter_name) 1208{ 1209 free(req->health_reporter_name); 1210 req->_present.health_reporter_name_len = strlen(health_reporter_name); 1211 req->health_reporter_name = malloc(req->_present.health_reporter_name_len + 1); 1212 memcpy(req->health_reporter_name, health_reporter_name, req->_present.health_reporter_name_len); 1213 req->health_reporter_name[req->_present.health_reporter_name_len] = 0; 1214} 1215 1216struct devlink_health_reporter_get_rsp { 1217 struct { 1218 __u32 bus_name_len; 1219 __u32 dev_name_len; 1220 __u32 port_index:1; 1221 __u32 health_reporter_name_len; 1222 } _present; 1223 1224 char *bus_name; 1225 char *dev_name; 1226 __u32 port_index; 1227 char *health_reporter_name; 1228}; 1229 1230void 1231devlink_health_reporter_get_rsp_free(struct devlink_health_reporter_get_rsp *rsp); 1232 1233/* 1234 * Get health reporter instances. 1235 */ 1236struct devlink_health_reporter_get_rsp * 1237devlink_health_reporter_get(struct ynl_sock *ys, 1238 struct devlink_health_reporter_get_req *req); 1239 1240/* DEVLINK_CMD_HEALTH_REPORTER_GET - dump */ 1241struct devlink_health_reporter_get_req_dump { 1242 struct { 1243 __u32 bus_name_len; 1244 __u32 dev_name_len; 1245 __u32 port_index:1; 1246 } _present; 1247 1248 char *bus_name; 1249 char *dev_name; 1250 __u32 port_index; 1251}; 1252 1253static inline struct devlink_health_reporter_get_req_dump * 1254devlink_health_reporter_get_req_dump_alloc(void) 1255{ 1256 return calloc(1, sizeof(struct devlink_health_reporter_get_req_dump)); 1257} 1258void 1259devlink_health_reporter_get_req_dump_free(struct devlink_health_reporter_get_req_dump *req); 1260 1261static inline void 1262devlink_health_reporter_get_req_dump_set_bus_name(struct devlink_health_reporter_get_req_dump *req, 1263 const char *bus_name) 1264{ 1265 free(req->bus_name); 1266 req->_present.bus_name_len = strlen(bus_name); 1267 req->bus_name = malloc(req->_present.bus_name_len + 1); 1268 memcpy(req->bus_name, bus_name, req->_present.bus_name_len); 1269 req->bus_name[req->_present.bus_name_len] = 0; 1270} 1271static inline void 1272devlink_health_reporter_get_req_dump_set_dev_name(struct devlink_health_reporter_get_req_dump *req, 1273 const char *dev_name) 1274{ 1275 free(req->dev_name); 1276 req->_present.dev_name_len = strlen(dev_name); 1277 req->dev_name = malloc(req->_present.dev_name_len + 1); 1278 memcpy(req->dev_name, dev_name, req->_present.dev_name_len); 1279 req->dev_name[req->_present.dev_name_len] = 0; 1280} 1281static inline void 1282devlink_health_reporter_get_req_dump_set_port_index(struct devlink_health_reporter_get_req_dump *req, 1283 __u32 port_index) 1284{ 1285 req->_present.port_index = 1; 1286 req->port_index = port_index; 1287} 1288 1289struct devlink_health_reporter_get_list { 1290 struct devlink_health_reporter_get_list *next; 1291 struct devlink_health_reporter_get_rsp obj __attribute__ ((aligned (8))); 1292}; 1293 1294void 1295devlink_health_reporter_get_list_free(struct devlink_health_reporter_get_list *rsp); 1296 1297struct devlink_health_reporter_get_list * 1298devlink_health_reporter_get_dump(struct ynl_sock *ys, 1299 struct devlink_health_reporter_get_req_dump *req); 1300 1301/* ============== DEVLINK_CMD_TRAP_GET ============== */ 1302/* DEVLINK_CMD_TRAP_GET - do */ 1303struct devlink_trap_get_req { 1304 struct { 1305 __u32 bus_name_len; 1306 __u32 dev_name_len; 1307 __u32 trap_name_len; 1308 } _present; 1309 1310 char *bus_name; 1311 char *dev_name; 1312 char *trap_name; 1313}; 1314 1315static inline struct devlink_trap_get_req *devlink_trap_get_req_alloc(void) 1316{ 1317 return calloc(1, sizeof(struct devlink_trap_get_req)); 1318} 1319void devlink_trap_get_req_free(struct devlink_trap_get_req *req); 1320 1321static inline void 1322devlink_trap_get_req_set_bus_name(struct devlink_trap_get_req *req, 1323 const char *bus_name) 1324{ 1325 free(req->bus_name); 1326 req->_present.bus_name_len = strlen(bus_name); 1327 req->bus_name = malloc(req->_present.bus_name_len + 1); 1328 memcpy(req->bus_name, bus_name, req->_present.bus_name_len); 1329 req->bus_name[req->_present.bus_name_len] = 0; 1330} 1331static inline void 1332devlink_trap_get_req_set_dev_name(struct devlink_trap_get_req *req, 1333 const char *dev_name) 1334{ 1335 free(req->dev_name); 1336 req->_present.dev_name_len = strlen(dev_name); 1337 req->dev_name = malloc(req->_present.dev_name_len + 1); 1338 memcpy(req->dev_name, dev_name, req->_present.dev_name_len); 1339 req->dev_name[req->_present.dev_name_len] = 0; 1340} 1341static inline void 1342devlink_trap_get_req_set_trap_name(struct devlink_trap_get_req *req, 1343 const char *trap_name) 1344{ 1345 free(req->trap_name); 1346 req->_present.trap_name_len = strlen(trap_name); 1347 req->trap_name = malloc(req->_present.trap_name_len + 1); 1348 memcpy(req->trap_name, trap_name, req->_present.trap_name_len); 1349 req->trap_name[req->_present.trap_name_len] = 0; 1350} 1351 1352struct devlink_trap_get_rsp { 1353 struct { 1354 __u32 bus_name_len; 1355 __u32 dev_name_len; 1356 __u32 trap_name_len; 1357 } _present; 1358 1359 char *bus_name; 1360 char *dev_name; 1361 char *trap_name; 1362}; 1363 1364void devlink_trap_get_rsp_free(struct devlink_trap_get_rsp *rsp); 1365 1366/* 1367 * Get trap instances. 1368 */ 1369struct devlink_trap_get_rsp * 1370devlink_trap_get(struct ynl_sock *ys, struct devlink_trap_get_req *req); 1371 1372/* DEVLINK_CMD_TRAP_GET - dump */ 1373struct devlink_trap_get_req_dump { 1374 struct { 1375 __u32 bus_name_len; 1376 __u32 dev_name_len; 1377 } _present; 1378 1379 char *bus_name; 1380 char *dev_name; 1381}; 1382 1383static inline struct devlink_trap_get_req_dump * 1384devlink_trap_get_req_dump_alloc(void) 1385{ 1386 return calloc(1, sizeof(struct devlink_trap_get_req_dump)); 1387} 1388void devlink_trap_get_req_dump_free(struct devlink_trap_get_req_dump *req); 1389 1390static inline void 1391devlink_trap_get_req_dump_set_bus_name(struct devlink_trap_get_req_dump *req, 1392 const char *bus_name) 1393{ 1394 free(req->bus_name); 1395 req->_present.bus_name_len = strlen(bus_name); 1396 req->bus_name = malloc(req->_present.bus_name_len + 1); 1397 memcpy(req->bus_name, bus_name, req->_present.bus_name_len); 1398 req->bus_name[req->_present.bus_name_len] = 0; 1399} 1400static inline void 1401devlink_trap_get_req_dump_set_dev_name(struct devlink_trap_get_req_dump *req, 1402 const char *dev_name) 1403{ 1404 free(req->dev_name); 1405 req->_present.dev_name_len = strlen(dev_name); 1406 req->dev_name = malloc(req->_present.dev_name_len + 1); 1407 memcpy(req->dev_name, dev_name, req->_present.dev_name_len); 1408 req->dev_name[req->_present.dev_name_len] = 0; 1409} 1410 1411struct devlink_trap_get_list { 1412 struct devlink_trap_get_list *next; 1413 struct devlink_trap_get_rsp obj __attribute__ ((aligned (8))); 1414}; 1415 1416void devlink_trap_get_list_free(struct devlink_trap_get_list *rsp); 1417 1418struct devlink_trap_get_list * 1419devlink_trap_get_dump(struct ynl_sock *ys, 1420 struct devlink_trap_get_req_dump *req); 1421 1422/* ============== DEVLINK_CMD_TRAP_GROUP_GET ============== */ 1423/* DEVLINK_CMD_TRAP_GROUP_GET - do */ 1424struct devlink_trap_group_get_req { 1425 struct { 1426 __u32 bus_name_len; 1427 __u32 dev_name_len; 1428 __u32 trap_group_name_len; 1429 } _present; 1430 1431 char *bus_name; 1432 char *dev_name; 1433 char *trap_group_name; 1434}; 1435 1436static inline struct devlink_trap_group_get_req * 1437devlink_trap_group_get_req_alloc(void) 1438{ 1439 return calloc(1, sizeof(struct devlink_trap_group_get_req)); 1440} 1441void devlink_trap_group_get_req_free(struct devlink_trap_group_get_req *req); 1442 1443static inline void 1444devlink_trap_group_get_req_set_bus_name(struct devlink_trap_group_get_req *req, 1445 const char *bus_name) 1446{ 1447 free(req->bus_name); 1448 req->_present.bus_name_len = strlen(bus_name); 1449 req->bus_name = malloc(req->_present.bus_name_len + 1); 1450 memcpy(req->bus_name, bus_name, req->_present.bus_name_len); 1451 req->bus_name[req->_present.bus_name_len] = 0; 1452} 1453static inline void 1454devlink_trap_group_get_req_set_dev_name(struct devlink_trap_group_get_req *req, 1455 const char *dev_name) 1456{ 1457 free(req->dev_name); 1458 req->_present.dev_name_len = strlen(dev_name); 1459 req->dev_name = malloc(req->_present.dev_name_len + 1); 1460 memcpy(req->dev_name, dev_name, req->_present.dev_name_len); 1461 req->dev_name[req->_present.dev_name_len] = 0; 1462} 1463static inline void 1464devlink_trap_group_get_req_set_trap_group_name(struct devlink_trap_group_get_req *req, 1465 const char *trap_group_name) 1466{ 1467 free(req->trap_group_name); 1468 req->_present.trap_group_name_len = strlen(trap_group_name); 1469 req->trap_group_name = malloc(req->_present.trap_group_name_len + 1); 1470 memcpy(req->trap_group_name, trap_group_name, req->_present.trap_group_name_len); 1471 req->trap_group_name[req->_present.trap_group_name_len] = 0; 1472} 1473 1474struct devlink_trap_group_get_rsp { 1475 struct { 1476 __u32 bus_name_len; 1477 __u32 dev_name_len; 1478 __u32 trap_group_name_len; 1479 } _present; 1480 1481 char *bus_name; 1482 char *dev_name; 1483 char *trap_group_name; 1484}; 1485 1486void devlink_trap_group_get_rsp_free(struct devlink_trap_group_get_rsp *rsp); 1487 1488/* 1489 * Get trap group instances. 1490 */ 1491struct devlink_trap_group_get_rsp * 1492devlink_trap_group_get(struct ynl_sock *ys, 1493 struct devlink_trap_group_get_req *req); 1494 1495/* DEVLINK_CMD_TRAP_GROUP_GET - dump */ 1496struct devlink_trap_group_get_req_dump { 1497 struct { 1498 __u32 bus_name_len; 1499 __u32 dev_name_len; 1500 } _present; 1501 1502 char *bus_name; 1503 char *dev_name; 1504}; 1505 1506static inline struct devlink_trap_group_get_req_dump * 1507devlink_trap_group_get_req_dump_alloc(void) 1508{ 1509 return calloc(1, sizeof(struct devlink_trap_group_get_req_dump)); 1510} 1511void 1512devlink_trap_group_get_req_dump_free(struct devlink_trap_group_get_req_dump *req); 1513 1514static inline void 1515devlink_trap_group_get_req_dump_set_bus_name(struct devlink_trap_group_get_req_dump *req, 1516 const char *bus_name) 1517{ 1518 free(req->bus_name); 1519 req->_present.bus_name_len = strlen(bus_name); 1520 req->bus_name = malloc(req->_present.bus_name_len + 1); 1521 memcpy(req->bus_name, bus_name, req->_present.bus_name_len); 1522 req->bus_name[req->_present.bus_name_len] = 0; 1523} 1524static inline void 1525devlink_trap_group_get_req_dump_set_dev_name(struct devlink_trap_group_get_req_dump *req, 1526 const char *dev_name) 1527{ 1528 free(req->dev_name); 1529 req->_present.dev_name_len = strlen(dev_name); 1530 req->dev_name = malloc(req->_present.dev_name_len + 1); 1531 memcpy(req->dev_name, dev_name, req->_present.dev_name_len); 1532 req->dev_name[req->_present.dev_name_len] = 0; 1533} 1534 1535struct devlink_trap_group_get_list { 1536 struct devlink_trap_group_get_list *next; 1537 struct devlink_trap_group_get_rsp obj __attribute__ ((aligned (8))); 1538}; 1539 1540void devlink_trap_group_get_list_free(struct devlink_trap_group_get_list *rsp); 1541 1542struct devlink_trap_group_get_list * 1543devlink_trap_group_get_dump(struct ynl_sock *ys, 1544 struct devlink_trap_group_get_req_dump *req); 1545 1546/* ============== DEVLINK_CMD_TRAP_POLICER_GET ============== */ 1547/* DEVLINK_CMD_TRAP_POLICER_GET - do */ 1548struct devlink_trap_policer_get_req { 1549 struct { 1550 __u32 bus_name_len; 1551 __u32 dev_name_len; 1552 __u32 trap_policer_id:1; 1553 } _present; 1554 1555 char *bus_name; 1556 char *dev_name; 1557 __u32 trap_policer_id; 1558}; 1559 1560static inline struct devlink_trap_policer_get_req * 1561devlink_trap_policer_get_req_alloc(void) 1562{ 1563 return calloc(1, sizeof(struct devlink_trap_policer_get_req)); 1564} 1565void 1566devlink_trap_policer_get_req_free(struct devlink_trap_policer_get_req *req); 1567 1568static inline void 1569devlink_trap_policer_get_req_set_bus_name(struct devlink_trap_policer_get_req *req, 1570 const char *bus_name) 1571{ 1572 free(req->bus_name); 1573 req->_present.bus_name_len = strlen(bus_name); 1574 req->bus_name = malloc(req->_present.bus_name_len + 1); 1575 memcpy(req->bus_name, bus_name, req->_present.bus_name_len); 1576 req->bus_name[req->_present.bus_name_len] = 0; 1577} 1578static inline void 1579devlink_trap_policer_get_req_set_dev_name(struct devlink_trap_policer_get_req *req, 1580 const char *dev_name) 1581{ 1582 free(req->dev_name); 1583 req->_present.dev_name_len = strlen(dev_name); 1584 req->dev_name = malloc(req->_present.dev_name_len + 1); 1585 memcpy(req->dev_name, dev_name, req->_present.dev_name_len); 1586 req->dev_name[req->_present.dev_name_len] = 0; 1587} 1588static inline void 1589devlink_trap_policer_get_req_set_trap_policer_id(struct devlink_trap_policer_get_req *req, 1590 __u32 trap_policer_id) 1591{ 1592 req->_present.trap_policer_id = 1; 1593 req->trap_policer_id = trap_policer_id; 1594} 1595 1596struct devlink_trap_policer_get_rsp { 1597 struct { 1598 __u32 bus_name_len; 1599 __u32 dev_name_len; 1600 __u32 trap_policer_id:1; 1601 } _present; 1602 1603 char *bus_name; 1604 char *dev_name; 1605 __u32 trap_policer_id; 1606}; 1607 1608void 1609devlink_trap_policer_get_rsp_free(struct devlink_trap_policer_get_rsp *rsp); 1610 1611/* 1612 * Get trap policer instances. 1613 */ 1614struct devlink_trap_policer_get_rsp * 1615devlink_trap_policer_get(struct ynl_sock *ys, 1616 struct devlink_trap_policer_get_req *req); 1617 1618/* DEVLINK_CMD_TRAP_POLICER_GET - dump */ 1619struct devlink_trap_policer_get_req_dump { 1620 struct { 1621 __u32 bus_name_len; 1622 __u32 dev_name_len; 1623 } _present; 1624 1625 char *bus_name; 1626 char *dev_name; 1627}; 1628 1629static inline struct devlink_trap_policer_get_req_dump * 1630devlink_trap_policer_get_req_dump_alloc(void) 1631{ 1632 return calloc(1, sizeof(struct devlink_trap_policer_get_req_dump)); 1633} 1634void 1635devlink_trap_policer_get_req_dump_free(struct devlink_trap_policer_get_req_dump *req); 1636 1637static inline void 1638devlink_trap_policer_get_req_dump_set_bus_name(struct devlink_trap_policer_get_req_dump *req, 1639 const char *bus_name) 1640{ 1641 free(req->bus_name); 1642 req->_present.bus_name_len = strlen(bus_name); 1643 req->bus_name = malloc(req->_present.bus_name_len + 1); 1644 memcpy(req->bus_name, bus_name, req->_present.bus_name_len); 1645 req->bus_name[req->_present.bus_name_len] = 0; 1646} 1647static inline void 1648devlink_trap_policer_get_req_dump_set_dev_name(struct devlink_trap_policer_get_req_dump *req, 1649 const char *dev_name) 1650{ 1651 free(req->dev_name); 1652 req->_present.dev_name_len = strlen(dev_name); 1653 req->dev_name = malloc(req->_present.dev_name_len + 1); 1654 memcpy(req->dev_name, dev_name, req->_present.dev_name_len); 1655 req->dev_name[req->_present.dev_name_len] = 0; 1656} 1657 1658struct devlink_trap_policer_get_list { 1659 struct devlink_trap_policer_get_list *next; 1660 struct devlink_trap_policer_get_rsp obj __attribute__ ((aligned (8))); 1661}; 1662 1663void 1664devlink_trap_policer_get_list_free(struct devlink_trap_policer_get_list *rsp); 1665 1666struct devlink_trap_policer_get_list * 1667devlink_trap_policer_get_dump(struct ynl_sock *ys, 1668 struct devlink_trap_policer_get_req_dump *req); 1669 1670/* ============== DEVLINK_CMD_RATE_GET ============== */ 1671/* DEVLINK_CMD_RATE_GET - do */ 1672struct devlink_rate_get_req { 1673 struct { 1674 __u32 bus_name_len; 1675 __u32 dev_name_len; 1676 __u32 port_index:1; 1677 __u32 rate_node_name_len; 1678 } _present; 1679 1680 char *bus_name; 1681 char *dev_name; 1682 __u32 port_index; 1683 char *rate_node_name; 1684}; 1685 1686static inline struct devlink_rate_get_req *devlink_rate_get_req_alloc(void) 1687{ 1688 return calloc(1, sizeof(struct devlink_rate_get_req)); 1689} 1690void devlink_rate_get_req_free(struct devlink_rate_get_req *req); 1691 1692static inline void 1693devlink_rate_get_req_set_bus_name(struct devlink_rate_get_req *req, 1694 const char *bus_name) 1695{ 1696 free(req->bus_name); 1697 req->_present.bus_name_len = strlen(bus_name); 1698 req->bus_name = malloc(req->_present.bus_name_len + 1); 1699 memcpy(req->bus_name, bus_name, req->_present.bus_name_len); 1700 req->bus_name[req->_present.bus_name_len] = 0; 1701} 1702static inline void 1703devlink_rate_get_req_set_dev_name(struct devlink_rate_get_req *req, 1704 const char *dev_name) 1705{ 1706 free(req->dev_name); 1707 req->_present.dev_name_len = strlen(dev_name); 1708 req->dev_name = malloc(req->_present.dev_name_len + 1); 1709 memcpy(req->dev_name, dev_name, req->_present.dev_name_len); 1710 req->dev_name[req->_present.dev_name_len] = 0; 1711} 1712static inline void 1713devlink_rate_get_req_set_port_index(struct devlink_rate_get_req *req, 1714 __u32 port_index) 1715{ 1716 req->_present.port_index = 1; 1717 req->port_index = port_index; 1718} 1719static inline void 1720devlink_rate_get_req_set_rate_node_name(struct devlink_rate_get_req *req, 1721 const char *rate_node_name) 1722{ 1723 free(req->rate_node_name); 1724 req->_present.rate_node_name_len = strlen(rate_node_name); 1725 req->rate_node_name = malloc(req->_present.rate_node_name_len + 1); 1726 memcpy(req->rate_node_name, rate_node_name, req->_present.rate_node_name_len); 1727 req->rate_node_name[req->_present.rate_node_name_len] = 0; 1728} 1729 1730struct devlink_rate_get_rsp { 1731 struct { 1732 __u32 bus_name_len; 1733 __u32 dev_name_len; 1734 __u32 port_index:1; 1735 __u32 rate_node_name_len; 1736 } _present; 1737 1738 char *bus_name; 1739 char *dev_name; 1740 __u32 port_index; 1741 char *rate_node_name; 1742}; 1743 1744void devlink_rate_get_rsp_free(struct devlink_rate_get_rsp *rsp); 1745 1746/* 1747 * Get rate instances. 1748 */ 1749struct devlink_rate_get_rsp * 1750devlink_rate_get(struct ynl_sock *ys, struct devlink_rate_get_req *req); 1751 1752/* DEVLINK_CMD_RATE_GET - dump */ 1753struct devlink_rate_get_req_dump { 1754 struct { 1755 __u32 bus_name_len; 1756 __u32 dev_name_len; 1757 } _present; 1758 1759 char *bus_name; 1760 char *dev_name; 1761}; 1762 1763static inline struct devlink_rate_get_req_dump * 1764devlink_rate_get_req_dump_alloc(void) 1765{ 1766 return calloc(1, sizeof(struct devlink_rate_get_req_dump)); 1767} 1768void devlink_rate_get_req_dump_free(struct devlink_rate_get_req_dump *req); 1769 1770static inline void 1771devlink_rate_get_req_dump_set_bus_name(struct devlink_rate_get_req_dump *req, 1772 const char *bus_name) 1773{ 1774 free(req->bus_name); 1775 req->_present.bus_name_len = strlen(bus_name); 1776 req->bus_name = malloc(req->_present.bus_name_len + 1); 1777 memcpy(req->bus_name, bus_name, req->_present.bus_name_len); 1778 req->bus_name[req->_present.bus_name_len] = 0; 1779} 1780static inline void 1781devlink_rate_get_req_dump_set_dev_name(struct devlink_rate_get_req_dump *req, 1782 const char *dev_name) 1783{ 1784 free(req->dev_name); 1785 req->_present.dev_name_len = strlen(dev_name); 1786 req->dev_name = malloc(req->_present.dev_name_len + 1); 1787 memcpy(req->dev_name, dev_name, req->_present.dev_name_len); 1788 req->dev_name[req->_present.dev_name_len] = 0; 1789} 1790 1791struct devlink_rate_get_list { 1792 struct devlink_rate_get_list *next; 1793 struct devlink_rate_get_rsp obj __attribute__ ((aligned (8))); 1794}; 1795 1796void devlink_rate_get_list_free(struct devlink_rate_get_list *rsp); 1797 1798struct devlink_rate_get_list * 1799devlink_rate_get_dump(struct ynl_sock *ys, 1800 struct devlink_rate_get_req_dump *req); 1801 1802/* ============== DEVLINK_CMD_LINECARD_GET ============== */ 1803/* DEVLINK_CMD_LINECARD_GET - do */ 1804struct devlink_linecard_get_req { 1805 struct { 1806 __u32 bus_name_len; 1807 __u32 dev_name_len; 1808 __u32 linecard_index:1; 1809 } _present; 1810 1811 char *bus_name; 1812 char *dev_name; 1813 __u32 linecard_index; 1814}; 1815 1816static inline struct devlink_linecard_get_req * 1817devlink_linecard_get_req_alloc(void) 1818{ 1819 return calloc(1, sizeof(struct devlink_linecard_get_req)); 1820} 1821void devlink_linecard_get_req_free(struct devlink_linecard_get_req *req); 1822 1823static inline void 1824devlink_linecard_get_req_set_bus_name(struct devlink_linecard_get_req *req, 1825 const char *bus_name) 1826{ 1827 free(req->bus_name); 1828 req->_present.bus_name_len = strlen(bus_name); 1829 req->bus_name = malloc(req->_present.bus_name_len + 1); 1830 memcpy(req->bus_name, bus_name, req->_present.bus_name_len); 1831 req->bus_name[req->_present.bus_name_len] = 0; 1832} 1833static inline void 1834devlink_linecard_get_req_set_dev_name(struct devlink_linecard_get_req *req, 1835 const char *dev_name) 1836{ 1837 free(req->dev_name); 1838 req->_present.dev_name_len = strlen(dev_name); 1839 req->dev_name = malloc(req->_present.dev_name_len + 1); 1840 memcpy(req->dev_name, dev_name, req->_present.dev_name_len); 1841 req->dev_name[req->_present.dev_name_len] = 0; 1842} 1843static inline void 1844devlink_linecard_get_req_set_linecard_index(struct devlink_linecard_get_req *req, 1845 __u32 linecard_index) 1846{ 1847 req->_present.linecard_index = 1; 1848 req->linecard_index = linecard_index; 1849} 1850 1851struct devlink_linecard_get_rsp { 1852 struct { 1853 __u32 bus_name_len; 1854 __u32 dev_name_len; 1855 __u32 linecard_index:1; 1856 } _present; 1857 1858 char *bus_name; 1859 char *dev_name; 1860 __u32 linecard_index; 1861}; 1862 1863void devlink_linecard_get_rsp_free(struct devlink_linecard_get_rsp *rsp); 1864 1865/* 1866 * Get line card instances. 1867 */ 1868struct devlink_linecard_get_rsp * 1869devlink_linecard_get(struct ynl_sock *ys, struct devlink_linecard_get_req *req); 1870 1871/* DEVLINK_CMD_LINECARD_GET - dump */ 1872struct devlink_linecard_get_req_dump { 1873 struct { 1874 __u32 bus_name_len; 1875 __u32 dev_name_len; 1876 } _present; 1877 1878 char *bus_name; 1879 char *dev_name; 1880}; 1881 1882static inline struct devlink_linecard_get_req_dump * 1883devlink_linecard_get_req_dump_alloc(void) 1884{ 1885 return calloc(1, sizeof(struct devlink_linecard_get_req_dump)); 1886} 1887void 1888devlink_linecard_get_req_dump_free(struct devlink_linecard_get_req_dump *req); 1889 1890static inline void 1891devlink_linecard_get_req_dump_set_bus_name(struct devlink_linecard_get_req_dump *req, 1892 const char *bus_name) 1893{ 1894 free(req->bus_name); 1895 req->_present.bus_name_len = strlen(bus_name); 1896 req->bus_name = malloc(req->_present.bus_name_len + 1); 1897 memcpy(req->bus_name, bus_name, req->_present.bus_name_len); 1898 req->bus_name[req->_present.bus_name_len] = 0; 1899} 1900static inline void 1901devlink_linecard_get_req_dump_set_dev_name(struct devlink_linecard_get_req_dump *req, 1902 const char *dev_name) 1903{ 1904 free(req->dev_name); 1905 req->_present.dev_name_len = strlen(dev_name); 1906 req->dev_name = malloc(req->_present.dev_name_len + 1); 1907 memcpy(req->dev_name, dev_name, req->_present.dev_name_len); 1908 req->dev_name[req->_present.dev_name_len] = 0; 1909} 1910 1911struct devlink_linecard_get_list { 1912 struct devlink_linecard_get_list *next; 1913 struct devlink_linecard_get_rsp obj __attribute__ ((aligned (8))); 1914}; 1915 1916void devlink_linecard_get_list_free(struct devlink_linecard_get_list *rsp); 1917 1918struct devlink_linecard_get_list * 1919devlink_linecard_get_dump(struct ynl_sock *ys, 1920 struct devlink_linecard_get_req_dump *req); 1921 1922/* ============== DEVLINK_CMD_SELFTESTS_GET ============== */ 1923/* DEVLINK_CMD_SELFTESTS_GET - do */ 1924struct devlink_selftests_get_req { 1925 struct { 1926 __u32 bus_name_len; 1927 __u32 dev_name_len; 1928 } _present; 1929 1930 char *bus_name; 1931 char *dev_name; 1932}; 1933 1934static inline struct devlink_selftests_get_req * 1935devlink_selftests_get_req_alloc(void) 1936{ 1937 return calloc(1, sizeof(struct devlink_selftests_get_req)); 1938} 1939void devlink_selftests_get_req_free(struct devlink_selftests_get_req *req); 1940 1941static inline void 1942devlink_selftests_get_req_set_bus_name(struct devlink_selftests_get_req *req, 1943 const char *bus_name) 1944{ 1945 free(req->bus_name); 1946 req->_present.bus_name_len = strlen(bus_name); 1947 req->bus_name = malloc(req->_present.bus_name_len + 1); 1948 memcpy(req->bus_name, bus_name, req->_present.bus_name_len); 1949 req->bus_name[req->_present.bus_name_len] = 0; 1950} 1951static inline void 1952devlink_selftests_get_req_set_dev_name(struct devlink_selftests_get_req *req, 1953 const char *dev_name) 1954{ 1955 free(req->dev_name); 1956 req->_present.dev_name_len = strlen(dev_name); 1957 req->dev_name = malloc(req->_present.dev_name_len + 1); 1958 memcpy(req->dev_name, dev_name, req->_present.dev_name_len); 1959 req->dev_name[req->_present.dev_name_len] = 0; 1960} 1961 1962struct devlink_selftests_get_rsp { 1963 struct { 1964 __u32 bus_name_len; 1965 __u32 dev_name_len; 1966 } _present; 1967 1968 char *bus_name; 1969 char *dev_name; 1970}; 1971 1972void devlink_selftests_get_rsp_free(struct devlink_selftests_get_rsp *rsp); 1973 1974/* 1975 * Get device selftest instances. 1976 */ 1977struct devlink_selftests_get_rsp * 1978devlink_selftests_get(struct ynl_sock *ys, 1979 struct devlink_selftests_get_req *req); 1980 1981/* DEVLINK_CMD_SELFTESTS_GET - dump */ 1982struct devlink_selftests_get_list { 1983 struct devlink_selftests_get_list *next; 1984 struct devlink_selftests_get_rsp obj __attribute__ ((aligned (8))); 1985}; 1986 1987void devlink_selftests_get_list_free(struct devlink_selftests_get_list *rsp); 1988 1989struct devlink_selftests_get_list * 1990devlink_selftests_get_dump(struct ynl_sock *ys); 1991 1992#endif /* _LINUX_DEVLINK_GEN_H */ 1993