tools/net/ynl/generated/devlink-user.h

   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/netlink.h>
  13 #include <linux/devlink.h>
  14
  15 struct ynl_sock;
  16
  17 extern const struct ynl_family ynl_devlink_family;
  18
  19 /* Enums */
  20 const char *devlink_op_str(int op);
  21 const char *devlink_sb_pool_type_str(enum devlink_sb_pool_type value);
  22 const char *devlink_port_type_str(enum devlink_port_type value);
  23 const char *devlink_port_flavour_str(enum devlink_port_flavour value);
  24 const char *devlink_port_fn_state_str(enum devlink_port_fn_state value);
  25 const char *devlink_port_fn_opstate_str(enum devlink_port_fn_opstate value);
  26 const char *devlink_port_fn_attr_cap_str(enum devlink_port_fn_attr_cap value);
  27 const char *
  28 devlink_sb_threshold_type_str(enum devlink_sb_threshold_type value);
  29 const char *devlink_eswitch_mode_str(enum devlink_eswitch_mode value);
  30 const char *
  31 devlink_eswitch_inline_mode_str(enum devlink_eswitch_inline_mode value);
  32 const char *
  33 devlink_eswitch_encap_mode_str(enum devlink_eswitch_encap_mode value);
  34 const char *devlink_dpipe_match_type_str(enum devlink_dpipe_match_type value);
  35 const char *
  36 devlink_dpipe_action_type_str(enum devlink_dpipe_action_type value);
  37 const char *
  38 devlink_dpipe_field_mapping_type_str(enum devlink_dpipe_field_mapping_type value);
  39 const char *devlink_resource_unit_str(enum devlink_resource_unit value);
  40 const char *devlink_reload_action_str(enum devlink_reload_action value);
  41 const char *devlink_param_cmode_str(enum devlink_param_cmode value);
  42 const char *devlink_flash_overwrite_str(enum devlink_flash_overwrite value);
  43 const char *devlink_trap_action_str(enum devlink_trap_action value);
  44
  45 /* Common nested types */
  46 struct devlink_dl_dpipe_match {
  47         struct {
  48                 __u32 dpipe_match_type:1;
  49                 __u32 dpipe_header_id:1;
  50                 __u32 dpipe_header_global:1;
  51                 __u32 dpipe_header_index:1;
  52                 __u32 dpipe_field_id:1;
  53         } _present;
  54
  55         enum devlink_dpipe_match_type dpipe_match_type;
  56         __u32 dpipe_header_id;
  57         __u8 dpipe_header_global;
  58         __u32 dpipe_header_index;
  59         __u32 dpipe_field_id;
  60 };
  61
  62 struct devlink_dl_dpipe_match_value {
  63         struct {
  64                 __u32 dpipe_value_len;
  65                 __u32 dpipe_value_mask_len;
  66                 __u32 dpipe_value_mapping:1;
  67         } _present;
  68
  69         unsigned int n_dpipe_match;
  70         struct devlink_dl_dpipe_match *dpipe_match;
  71         void *dpipe_value;
  72         void *dpipe_value_mask;
  73         __u32 dpipe_value_mapping;
  74 };
  75
  76 struct devlink_dl_dpipe_action {
  77         struct {
  78                 __u32 dpipe_action_type:1;
  79                 __u32 dpipe_header_id:1;
  80                 __u32 dpipe_header_global:1;
  81                 __u32 dpipe_header_index:1;
  82                 __u32 dpipe_field_id:1;
  83         } _present;
  84
  85         enum devlink_dpipe_action_type dpipe_action_type;
  86         __u32 dpipe_header_id;
  87         __u8 dpipe_header_global;
  88         __u32 dpipe_header_index;
  89         __u32 dpipe_field_id;
  90 };
  91
  92 struct devlink_dl_dpipe_action_value {
  93         struct {
  94                 __u32 dpipe_value_len;
  95                 __u32 dpipe_value_mask_len;
  96                 __u32 dpipe_value_mapping:1;
  97         } _present;
  98
  99         unsigned int n_dpipe_action;
 100         struct devlink_dl_dpipe_action *dpipe_action;
 101         void *dpipe_value;
 102         void *dpipe_value_mask;
 103         __u32 dpipe_value_mapping;
 104 };
 105
 106 struct devlink_dl_dpipe_field {
 107         struct {
 108                 __u32 dpipe_field_name_len;
 109                 __u32 dpipe_field_id:1;
 110                 __u32 dpipe_field_bitwidth:1;
 111                 __u32 dpipe_field_mapping_type:1;
 112         } _present;
 113
 114         char *dpipe_field_name;
 115         __u32 dpipe_field_id;
 116         __u32 dpipe_field_bitwidth;
 117         enum devlink_dpipe_field_mapping_type dpipe_field_mapping_type;
 118 };
 119
 120 struct devlink_dl_resource {
 121         struct {
 122                 __u32 resource_name_len;
 123                 __u32 resource_id:1;
 124                 __u32 resource_size:1;
 125                 __u32 resource_size_new:1;
 126                 __u32 resource_size_valid:1;
 127                 __u32 resource_size_min:1;
 128                 __u32 resource_size_max:1;
 129                 __u32 resource_size_gran:1;
 130                 __u32 resource_unit:1;
 131                 __u32 resource_occ:1;
 132         } _present;
 133
 134         char *resource_name;
 135         __u64 resource_id;
 136         __u64 resource_size;
 137         __u64 resource_size_new;
 138         __u8 resource_size_valid;
 139         __u64 resource_size_min;
 140         __u64 resource_size_max;
 141         __u64 resource_size_gran;
 142         enum devlink_resource_unit resource_unit;
 143         __u64 resource_occ;
 144 };
 145
 146 struct devlink_dl_info_version {
 147         struct {
 148                 __u32 info_version_name_len;
 149                 __u32 info_version_value_len;
 150         } _present;
 151
 152         char *info_version_name;
 153         char *info_version_value;
 154 };
 155
 156 struct devlink_dl_fmsg {
 157         struct {
 158                 __u32 fmsg_obj_nest_start:1;
 159                 __u32 fmsg_pair_nest_start:1;
 160                 __u32 fmsg_arr_nest_start:1;
 161                 __u32 fmsg_nest_end:1;
 162                 __u32 fmsg_obj_name_len;
 163         } _present;
 164
 165         char *fmsg_obj_name;
 166 };
 167
 168 struct devlink_dl_port_function {
 169         struct {
 170                 __u32 hw_addr_len;
 171                 __u32 state:1;
 172                 __u32 opstate:1;
 173                 __u32 caps:1;
 174         } _present;
 175
 176         void *hw_addr;
 177         enum devlink_port_fn_state state;
 178         enum devlink_port_fn_opstate opstate;
 179         struct nla_bitfield32 caps;
 180 };
 181
 182 struct devlink_dl_reload_stats_entry {
 183         struct {
 184                 __u32 reload_stats_limit:1;
 185                 __u32 reload_stats_value:1;
 186         } _present;
 187
 188         __u8 reload_stats_limit;
 189         __u32 reload_stats_value;
 190 };
 191
 192 struct devlink_dl_reload_act_stats {
 193         unsigned int n_reload_stats_entry;
 194         struct devlink_dl_reload_stats_entry *reload_stats_entry;
 195 };
 196
 197 struct devlink_dl_selftest_id {
 198         struct {
 199                 __u32 flash:1;
 200         } _present;
 201 };
 202
 203 struct devlink_dl_dpipe_table_matches {
 204         unsigned int n_dpipe_match;
 205         struct devlink_dl_dpipe_match *dpipe_match;
 206 };
 207
 208 struct devlink_dl_dpipe_table_actions {
 209         unsigned int n_dpipe_action;
 210         struct devlink_dl_dpipe_action *dpipe_action;
 211 };
 212
 213 struct devlink_dl_dpipe_entry_match_values {
 214         unsigned int n_dpipe_match_value;
 215         struct devlink_dl_dpipe_match_value *dpipe_match_value;
 216 };
 217
 218 struct devlink_dl_dpipe_entry_action_values {
 219         unsigned int n_dpipe_action_value;
 220         struct devlink_dl_dpipe_action_value *dpipe_action_value;
 221 };
 222
 223 struct devlink_dl_dpipe_header_fields {
 224         unsigned int n_dpipe_field;
 225         struct devlink_dl_dpipe_field *dpipe_field;
 226 };
 227
 228 struct devlink_dl_resource_list {
 229         unsigned int n_resource;
 230         struct devlink_dl_resource *resource;
 231 };
 232
 233 struct devlink_dl_reload_act_info {
 234         struct {
 235                 __u32 reload_action:1;
 236         } _present;
 237
 238         enum devlink_reload_action reload_action;
 239         unsigned int n_reload_action_stats;
 240         struct devlink_dl_reload_act_stats *reload_action_stats;
 241 };
 242
 243 struct devlink_dl_dpipe_table {
 244         struct {
 245                 __u32 dpipe_table_name_len;
 246                 __u32 dpipe_table_size:1;
 247                 __u32 dpipe_table_matches:1;
 248                 __u32 dpipe_table_actions:1;
 249                 __u32 dpipe_table_counters_enabled:1;
 250                 __u32 dpipe_table_resource_id:1;
 251                 __u32 dpipe_table_resource_units:1;
 252         } _present;
 253
 254         char *dpipe_table_name;
 255         __u64 dpipe_table_size;
 256         struct devlink_dl_dpipe_table_matches dpipe_table_matches;
 257         struct devlink_dl_dpipe_table_actions dpipe_table_actions;
 258         __u8 dpipe_table_counters_enabled;
 259         __u64 dpipe_table_resource_id;
 260         __u64 dpipe_table_resource_units;
 261 };
 262
 263 struct devlink_dl_dpipe_entry {
 264         struct {
 265                 __u32 dpipe_entry_index:1;
 266                 __u32 dpipe_entry_match_values:1;
 267                 __u32 dpipe_entry_action_values:1;
 268                 __u32 dpipe_entry_counter:1;
 269         } _present;
 270
 271         __u64 dpipe_entry_index;
 272         struct devlink_dl_dpipe_entry_match_values dpipe_entry_match_values;
 273         struct devlink_dl_dpipe_entry_action_values dpipe_entry_action_values;
 274         __u64 dpipe_entry_counter;
 275 };
 276
 277 struct devlink_dl_dpipe_header {
 278         struct {
 279                 __u32 dpipe_header_name_len;
 280                 __u32 dpipe_header_id:1;
 281                 __u32 dpipe_header_global:1;
 282                 __u32 dpipe_header_fields:1;
 283         } _present;
 284
 285         char *dpipe_header_name;
 286         __u32 dpipe_header_id;
 287         __u8 dpipe_header_global;
 288         struct devlink_dl_dpipe_header_fields dpipe_header_fields;
 289 };
 290
 291 struct devlink_dl_reload_stats {
 292         unsigned int n_reload_action_info;
 293         struct devlink_dl_reload_act_info *reload_action_info;
 294 };
 295
 296 struct devlink_dl_dpipe_tables {
 297         unsigned int n_dpipe_table;
 298         struct devlink_dl_dpipe_table *dpipe_table;
 299 };
 300
 301 struct devlink_dl_dpipe_entries {
 302         unsigned int n_dpipe_entry;
 303         struct devlink_dl_dpipe_entry *dpipe_entry;
 304 };
 305
 306 struct devlink_dl_dpipe_headers {
 307         unsigned int n_dpipe_header;
 308         struct devlink_dl_dpipe_header *dpipe_header;
 309 };
 310
 311 struct devlink_dl_dev_stats {
 312         struct {
 313                 __u32 reload_stats:1;
 314                 __u32 remote_reload_stats:1;
 315         } _present;
 316
 317         struct devlink_dl_reload_stats reload_stats;
 318         struct devlink_dl_reload_stats remote_reload_stats;
 319 };
 320
 321 /* ============== DEVLINK_CMD_GET ============== */
 322 /* DEVLINK_CMD_GET - do */
 323 struct devlink_get_req {
 324         struct {
 325                 __u32 bus_name_len;
 326                 __u32 dev_name_len;
 327         } _present;
 328
 329         char *bus_name;
 330         char *dev_name;
 331 };
 332
 333 static inline struct devlink_get_req *devlink_get_req_alloc(void)
 334 {
 335         return calloc(1, sizeof(struct devlink_get_req));
 336 }
 337 void devlink_get_req_free(struct devlink_get_req *req);
 338
 339 static inline void
 340 devlink_get_req_set_bus_name(struct devlink_get_req *req, const char *bus_name)
 341 {
 342         free(req->bus_name);
 343         req->_present.bus_name_len = strlen(bus_name);
 344         req->bus_name = malloc(req->_present.bus_name_len + 1);
 345         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
 346         req->bus_name[req->_present.bus_name_len] = 0;
 347 }
 348 static inline void
 349 devlink_get_req_set_dev_name(struct devlink_get_req *req, const char *dev_name)
 350 {
 351         free(req->dev_name);
 352         req->_present.dev_name_len = strlen(dev_name);
 353         req->dev_name = malloc(req->_present.dev_name_len + 1);
 354         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
 355         req->dev_name[req->_present.dev_name_len] = 0;
 356 }
 357
 358 struct devlink_get_rsp {
 359         struct {
 360                 __u32 bus_name_len;
 361                 __u32 dev_name_len;
 362                 __u32 reload_failed:1;
 363                 __u32 dev_stats:1;
 364         } _present;
 365
 366         char *bus_name;
 367         char *dev_name;
 368         __u8 reload_failed;
 369         struct devlink_dl_dev_stats dev_stats;
 370 };
 371
 372 void devlink_get_rsp_free(struct devlink_get_rsp *rsp);
 373
 374 /*
 375  * Get devlink instances.
 376  */
 377 struct devlink_get_rsp *
 378 devlink_get(struct ynl_sock *ys, struct devlink_get_req *req);
 379
 380 /* DEVLINK_CMD_GET - dump */
 381 struct devlink_get_list {
 382         struct devlink_get_list *next;
 383         struct devlink_get_rsp obj __attribute__ ((aligned (8)));
 384 };
 385
 386 void devlink_get_list_free(struct devlink_get_list *rsp);
 387
 388 struct devlink_get_list *devlink_get_dump(struct ynl_sock *ys);
 389
 390 /* ============== DEVLINK_CMD_PORT_GET ============== */
 391 /* DEVLINK_CMD_PORT_GET - do */
 392 struct devlink_port_get_req {
 393         struct {
 394                 __u32 bus_name_len;
 395                 __u32 dev_name_len;
 396                 __u32 port_index:1;
 397         } _present;
 398
 399         char *bus_name;
 400         char *dev_name;
 401         __u32 port_index;
 402 };
 403
 404 static inline struct devlink_port_get_req *devlink_port_get_req_alloc(void)
 405 {
 406         return calloc(1, sizeof(struct devlink_port_get_req));
 407 }
 408 void devlink_port_get_req_free(struct devlink_port_get_req *req);
 409
 410 static inline void
 411 devlink_port_get_req_set_bus_name(struct devlink_port_get_req *req,
 412                                   const char *bus_name)
 413 {
 414         free(req->bus_name);
 415         req->_present.bus_name_len = strlen(bus_name);
 416         req->bus_name = malloc(req->_present.bus_name_len + 1);
 417         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
 418         req->bus_name[req->_present.bus_name_len] = 0;
 419 }
 420 static inline void
 421 devlink_port_get_req_set_dev_name(struct devlink_port_get_req *req,
 422                                   const char *dev_name)
 423 {
 424         free(req->dev_name);
 425         req->_present.dev_name_len = strlen(dev_name);
 426         req->dev_name = malloc(req->_present.dev_name_len + 1);
 427         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
 428         req->dev_name[req->_present.dev_name_len] = 0;
 429 }
 430 static inline void
 431 devlink_port_get_req_set_port_index(struct devlink_port_get_req *req,
 432                                     __u32 port_index)
 433 {
 434         req->_present.port_index = 1;
 435         req->port_index = port_index;
 436 }
 437
 438 struct devlink_port_get_rsp {
 439         struct {
 440                 __u32 bus_name_len;
 441                 __u32 dev_name_len;
 442                 __u32 port_index:1;
 443         } _present;
 444
 445         char *bus_name;
 446         char *dev_name;
 447         __u32 port_index;
 448 };
 449
 450 void devlink_port_get_rsp_free(struct devlink_port_get_rsp *rsp);
 451
 452 /*
 453  * Get devlink port instances.
 454  */
 455 struct devlink_port_get_rsp *
 456 devlink_port_get(struct ynl_sock *ys, struct devlink_port_get_req *req);
 457
 458 /* DEVLINK_CMD_PORT_GET - dump */
 459 struct devlink_port_get_req_dump {
 460         struct {
 461                 __u32 bus_name_len;
 462                 __u32 dev_name_len;
 463         } _present;
 464
 465         char *bus_name;
 466         char *dev_name;
 467 };
 468
 469 static inline struct devlink_port_get_req_dump *
 470 devlink_port_get_req_dump_alloc(void)
 471 {
 472         return calloc(1, sizeof(struct devlink_port_get_req_dump));
 473 }
 474 void devlink_port_get_req_dump_free(struct devlink_port_get_req_dump *req);
 475
 476 static inline void
 477 devlink_port_get_req_dump_set_bus_name(struct devlink_port_get_req_dump *req,
 478                                        const char *bus_name)
 479 {
 480         free(req->bus_name);
 481         req->_present.bus_name_len = strlen(bus_name);
 482         req->bus_name = malloc(req->_present.bus_name_len + 1);
 483         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
 484         req->bus_name[req->_present.bus_name_len] = 0;
 485 }
 486 static inline void
 487 devlink_port_get_req_dump_set_dev_name(struct devlink_port_get_req_dump *req,
 488                                        const char *dev_name)
 489 {
 490         free(req->dev_name);
 491         req->_present.dev_name_len = strlen(dev_name);
 492         req->dev_name = malloc(req->_present.dev_name_len + 1);
 493         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
 494         req->dev_name[req->_present.dev_name_len] = 0;
 495 }
 496
 497 struct devlink_port_get_rsp_dump {
 498         struct {
 499                 __u32 bus_name_len;
 500                 __u32 dev_name_len;
 501                 __u32 port_index:1;
 502         } _present;
 503
 504         char *bus_name;
 505         char *dev_name;
 506         __u32 port_index;
 507 };
 508
 509 struct devlink_port_get_rsp_list {
 510         struct devlink_port_get_rsp_list *next;
 511         struct devlink_port_get_rsp_dump obj __attribute__ ((aligned (8)));
 512 };
 513
 514 void devlink_port_get_rsp_list_free(struct devlink_port_get_rsp_list *rsp);
 515
 516 struct devlink_port_get_rsp_list *
 517 devlink_port_get_dump(struct ynl_sock *ys,
 518                       struct devlink_port_get_req_dump *req);
 519
 520 /* ============== DEVLINK_CMD_PORT_SET ============== */
 521 /* DEVLINK_CMD_PORT_SET - do */
 522 struct devlink_port_set_req {
 523         struct {
 524                 __u32 bus_name_len;
 525                 __u32 dev_name_len;
 526                 __u32 port_index:1;
 527                 __u32 port_type:1;
 528                 __u32 port_function:1;
 529         } _present;
 530
 531         char *bus_name;
 532         char *dev_name;
 533         __u32 port_index;
 534         enum devlink_port_type port_type;
 535         struct devlink_dl_port_function port_function;
 536 };
 537
 538 static inline struct devlink_port_set_req *devlink_port_set_req_alloc(void)
 539 {
 540         return calloc(1, sizeof(struct devlink_port_set_req));
 541 }
 542 void devlink_port_set_req_free(struct devlink_port_set_req *req);
 543
 544 static inline void
 545 devlink_port_set_req_set_bus_name(struct devlink_port_set_req *req,
 546                                   const char *bus_name)
 547 {
 548         free(req->bus_name);
 549         req->_present.bus_name_len = strlen(bus_name);
 550         req->bus_name = malloc(req->_present.bus_name_len + 1);
 551         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
 552         req->bus_name[req->_present.bus_name_len] = 0;
 553 }
 554 static inline void
 555 devlink_port_set_req_set_dev_name(struct devlink_port_set_req *req,
 556                                   const char *dev_name)
 557 {
 558         free(req->dev_name);
 559         req->_present.dev_name_len = strlen(dev_name);
 560         req->dev_name = malloc(req->_present.dev_name_len + 1);
 561         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
 562         req->dev_name[req->_present.dev_name_len] = 0;
 563 }
 564 static inline void
 565 devlink_port_set_req_set_port_index(struct devlink_port_set_req *req,
 566                                     __u32 port_index)
 567 {
 568         req->_present.port_index = 1;
 569         req->port_index = port_index;
 570 }
 571 static inline void
 572 devlink_port_set_req_set_port_type(struct devlink_port_set_req *req,
 573                                    enum devlink_port_type port_type)
 574 {
 575         req->_present.port_type = 1;
 576         req->port_type = port_type;
 577 }
 578 static inline void
 579 devlink_port_set_req_set_port_function_hw_addr(struct devlink_port_set_req *req,
 580                                                const void *hw_addr, size_t len)
 581 {
 582         free(req->port_function.hw_addr);
 583         req->port_function._present.hw_addr_len = len;
 584         req->port_function.hw_addr = malloc(req->port_function._present.hw_addr_len);
 585         memcpy(req->port_function.hw_addr, hw_addr, req->port_function._present.hw_addr_len);
 586 }
 587 static inline void
 588 devlink_port_set_req_set_port_function_state(struct devlink_port_set_req *req,
 589                                              enum devlink_port_fn_state state)
 590 {
 591         req->_present.port_function = 1;
 592         req->port_function._present.state = 1;
 593         req->port_function.state = state;
 594 }
 595 static inline void
 596 devlink_port_set_req_set_port_function_opstate(struct devlink_port_set_req *req,
 597                                                enum devlink_port_fn_opstate opstate)
 598 {
 599         req->_present.port_function = 1;
 600         req->port_function._present.opstate = 1;
 601         req->port_function.opstate = opstate;
 602 }
 603 static inline void
 604 devlink_port_set_req_set_port_function_caps(struct devlink_port_set_req *req,
 605                                             struct nla_bitfield32 *caps)
 606 {
 607         req->_present.port_function = 1;
 608         req->port_function._present.caps = 1;
 609         memcpy(&req->port_function.caps, caps, sizeof(struct nla_bitfield32));
 610 }
 611
 612 /*
 613  * Set devlink port instances.
 614  */
 615 int devlink_port_set(struct ynl_sock *ys, struct devlink_port_set_req *req);
 616
 617 /* ============== DEVLINK_CMD_PORT_NEW ============== */
 618 /* DEVLINK_CMD_PORT_NEW - do */
 619 struct devlink_port_new_req {
 620         struct {
 621                 __u32 bus_name_len;
 622                 __u32 dev_name_len;
 623                 __u32 port_index:1;
 624                 __u32 port_flavour:1;
 625                 __u32 port_pci_pf_number:1;
 626                 __u32 port_pci_sf_number:1;
 627                 __u32 port_controller_number:1;
 628         } _present;
 629
 630         char *bus_name;
 631         char *dev_name;
 632         __u32 port_index;
 633         enum devlink_port_flavour port_flavour;
 634         __u16 port_pci_pf_number;
 635         __u32 port_pci_sf_number;
 636         __u32 port_controller_number;
 637 };
 638
 639 static inline struct devlink_port_new_req *devlink_port_new_req_alloc(void)
 640 {
 641         return calloc(1, sizeof(struct devlink_port_new_req));
 642 }
 643 void devlink_port_new_req_free(struct devlink_port_new_req *req);
 644
 645 static inline void
 646 devlink_port_new_req_set_bus_name(struct devlink_port_new_req *req,
 647                                   const char *bus_name)
 648 {
 649         free(req->bus_name);
 650         req->_present.bus_name_len = strlen(bus_name);
 651         req->bus_name = malloc(req->_present.bus_name_len + 1);
 652         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
 653         req->bus_name[req->_present.bus_name_len] = 0;
 654 }
 655 static inline void
 656 devlink_port_new_req_set_dev_name(struct devlink_port_new_req *req,
 657                                   const char *dev_name)
 658 {
 659         free(req->dev_name);
 660         req->_present.dev_name_len = strlen(dev_name);
 661         req->dev_name = malloc(req->_present.dev_name_len + 1);
 662         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
 663         req->dev_name[req->_present.dev_name_len] = 0;
 664 }
 665 static inline void
 666 devlink_port_new_req_set_port_index(struct devlink_port_new_req *req,
 667                                     __u32 port_index)
 668 {
 669         req->_present.port_index = 1;
 670         req->port_index = port_index;
 671 }
 672 static inline void
 673 devlink_port_new_req_set_port_flavour(struct devlink_port_new_req *req,
 674                                       enum devlink_port_flavour port_flavour)
 675 {
 676         req->_present.port_flavour = 1;
 677         req->port_flavour = port_flavour;
 678 }
 679 static inline void
 680 devlink_port_new_req_set_port_pci_pf_number(struct devlink_port_new_req *req,
 681                                             __u16 port_pci_pf_number)
 682 {
 683         req->_present.port_pci_pf_number = 1;
 684         req->port_pci_pf_number = port_pci_pf_number;
 685 }
 686 static inline void
 687 devlink_port_new_req_set_port_pci_sf_number(struct devlink_port_new_req *req,
 688                                             __u32 port_pci_sf_number)
 689 {
 690         req->_present.port_pci_sf_number = 1;
 691         req->port_pci_sf_number = port_pci_sf_number;
 692 }
 693 static inline void
 694 devlink_port_new_req_set_port_controller_number(struct devlink_port_new_req *req,
 695                                                 __u32 port_controller_number)
 696 {
 697         req->_present.port_controller_number = 1;
 698         req->port_controller_number = port_controller_number;
 699 }
 700
 701 struct devlink_port_new_rsp {
 702         struct {
 703                 __u32 bus_name_len;
 704                 __u32 dev_name_len;
 705                 __u32 port_index:1;
 706         } _present;
 707
 708         char *bus_name;
 709         char *dev_name;
 710         __u32 port_index;
 711 };
 712
 713 void devlink_port_new_rsp_free(struct devlink_port_new_rsp *rsp);
 714
 715 /*
 716  * Create devlink port instances.
 717  */
 718 struct devlink_port_new_rsp *
 719 devlink_port_new(struct ynl_sock *ys, struct devlink_port_new_req *req);
 720
 721 /* ============== DEVLINK_CMD_PORT_DEL ============== */
 722 /* DEVLINK_CMD_PORT_DEL - do */
 723 struct devlink_port_del_req {
 724         struct {
 725                 __u32 bus_name_len;
 726                 __u32 dev_name_len;
 727                 __u32 port_index:1;
 728         } _present;
 729
 730         char *bus_name;
 731         char *dev_name;
 732         __u32 port_index;
 733 };
 734
 735 static inline struct devlink_port_del_req *devlink_port_del_req_alloc(void)
 736 {
 737         return calloc(1, sizeof(struct devlink_port_del_req));
 738 }
 739 void devlink_port_del_req_free(struct devlink_port_del_req *req);
 740
 741 static inline void
 742 devlink_port_del_req_set_bus_name(struct devlink_port_del_req *req,
 743                                   const char *bus_name)
 744 {
 745         free(req->bus_name);
 746         req->_present.bus_name_len = strlen(bus_name);
 747         req->bus_name = malloc(req->_present.bus_name_len + 1);
 748         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
 749         req->bus_name[req->_present.bus_name_len] = 0;
 750 }
 751 static inline void
 752 devlink_port_del_req_set_dev_name(struct devlink_port_del_req *req,
 753                                   const char *dev_name)
 754 {
 755         free(req->dev_name);
 756         req->_present.dev_name_len = strlen(dev_name);
 757         req->dev_name = malloc(req->_present.dev_name_len + 1);
 758         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
 759         req->dev_name[req->_present.dev_name_len] = 0;
 760 }
 761 static inline void
 762 devlink_port_del_req_set_port_index(struct devlink_port_del_req *req,
 763                                     __u32 port_index)
 764 {
 765         req->_present.port_index = 1;
 766         req->port_index = port_index;
 767 }
 768
 769 /*
 770  * Delete devlink port instances.
 771  */
 772 int devlink_port_del(struct ynl_sock *ys, struct devlink_port_del_req *req);
 773
 774 /* ============== DEVLINK_CMD_PORT_SPLIT ============== */
 775 /* DEVLINK_CMD_PORT_SPLIT - do */
 776 struct devlink_port_split_req {
 777         struct {
 778                 __u32 bus_name_len;
 779                 __u32 dev_name_len;
 780                 __u32 port_index:1;
 781                 __u32 port_split_count:1;
 782         } _present;
 783
 784         char *bus_name;
 785         char *dev_name;
 786         __u32 port_index;
 787         __u32 port_split_count;
 788 };
 789
 790 static inline struct devlink_port_split_req *devlink_port_split_req_alloc(void)
 791 {
 792         return calloc(1, sizeof(struct devlink_port_split_req));
 793 }
 794 void devlink_port_split_req_free(struct devlink_port_split_req *req);
 795
 796 static inline void
 797 devlink_port_split_req_set_bus_name(struct devlink_port_split_req *req,
 798                                     const char *bus_name)
 799 {
 800         free(req->bus_name);
 801         req->_present.bus_name_len = strlen(bus_name);
 802         req->bus_name = malloc(req->_present.bus_name_len + 1);
 803         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
 804         req->bus_name[req->_present.bus_name_len] = 0;
 805 }
 806 static inline void
 807 devlink_port_split_req_set_dev_name(struct devlink_port_split_req *req,
 808                                     const char *dev_name)
 809 {
 810         free(req->dev_name);
 811         req->_present.dev_name_len = strlen(dev_name);
 812         req->dev_name = malloc(req->_present.dev_name_len + 1);
 813         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
 814         req->dev_name[req->_present.dev_name_len] = 0;
 815 }
 816 static inline void
 817 devlink_port_split_req_set_port_index(struct devlink_port_split_req *req,
 818                                       __u32 port_index)
 819 {
 820         req->_present.port_index = 1;
 821         req->port_index = port_index;
 822 }
 823 static inline void
 824 devlink_port_split_req_set_port_split_count(struct devlink_port_split_req *req,
 825                                             __u32 port_split_count)
 826 {
 827         req->_present.port_split_count = 1;
 828         req->port_split_count = port_split_count;
 829 }
 830
 831 /*
 832  * Split devlink port instances.
 833  */
 834 int devlink_port_split(struct ynl_sock *ys, struct devlink_port_split_req *req);
 835
 836 /* ============== DEVLINK_CMD_PORT_UNSPLIT ============== */
 837 /* DEVLINK_CMD_PORT_UNSPLIT - do */
 838 struct devlink_port_unsplit_req {
 839         struct {
 840                 __u32 bus_name_len;
 841                 __u32 dev_name_len;
 842                 __u32 port_index:1;
 843         } _present;
 844
 845         char *bus_name;
 846         char *dev_name;
 847         __u32 port_index;
 848 };
 849
 850 static inline struct devlink_port_unsplit_req *
 851 devlink_port_unsplit_req_alloc(void)
 852 {
 853         return calloc(1, sizeof(struct devlink_port_unsplit_req));
 854 }
 855 void devlink_port_unsplit_req_free(struct devlink_port_unsplit_req *req);
 856
 857 static inline void
 858 devlink_port_unsplit_req_set_bus_name(struct devlink_port_unsplit_req *req,
 859                                       const char *bus_name)
 860 {
 861         free(req->bus_name);
 862         req->_present.bus_name_len = strlen(bus_name);
 863         req->bus_name = malloc(req->_present.bus_name_len + 1);
 864         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
 865         req->bus_name[req->_present.bus_name_len] = 0;
 866 }
 867 static inline void
 868 devlink_port_unsplit_req_set_dev_name(struct devlink_port_unsplit_req *req,
 869                                       const char *dev_name)
 870 {
 871         free(req->dev_name);
 872         req->_present.dev_name_len = strlen(dev_name);
 873         req->dev_name = malloc(req->_present.dev_name_len + 1);
 874         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
 875         req->dev_name[req->_present.dev_name_len] = 0;
 876 }
 877 static inline void
 878 devlink_port_unsplit_req_set_port_index(struct devlink_port_unsplit_req *req,
 879                                         __u32 port_index)
 880 {
 881         req->_present.port_index = 1;
 882         req->port_index = port_index;
 883 }
 884
 885 /*
 886  * Unplit devlink port instances.
 887  */
 888 int devlink_port_unsplit(struct ynl_sock *ys,
 889                          struct devlink_port_unsplit_req *req);
 890
 891 /* ============== DEVLINK_CMD_SB_GET ============== */
 892 /* DEVLINK_CMD_SB_GET - do */
 893 struct devlink_sb_get_req {
 894         struct {
 895                 __u32 bus_name_len;
 896                 __u32 dev_name_len;
 897                 __u32 sb_index:1;
 898         } _present;
 899
 900         char *bus_name;
 901         char *dev_name;
 902         __u32 sb_index;
 903 };
 904
 905 static inline struct devlink_sb_get_req *devlink_sb_get_req_alloc(void)
 906 {
 907         return calloc(1, sizeof(struct devlink_sb_get_req));
 908 }
 909 void devlink_sb_get_req_free(struct devlink_sb_get_req *req);
 910
 911 static inline void
 912 devlink_sb_get_req_set_bus_name(struct devlink_sb_get_req *req,
 913                                 const char *bus_name)
 914 {
 915         free(req->bus_name);
 916         req->_present.bus_name_len = strlen(bus_name);
 917         req->bus_name = malloc(req->_present.bus_name_len + 1);
 918         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
 919         req->bus_name[req->_present.bus_name_len] = 0;
 920 }
 921 static inline void
 922 devlink_sb_get_req_set_dev_name(struct devlink_sb_get_req *req,
 923                                 const char *dev_name)
 924 {
 925         free(req->dev_name);
 926         req->_present.dev_name_len = strlen(dev_name);
 927         req->dev_name = malloc(req->_present.dev_name_len + 1);
 928         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
 929         req->dev_name[req->_present.dev_name_len] = 0;
 930 }
 931 static inline void
 932 devlink_sb_get_req_set_sb_index(struct devlink_sb_get_req *req, __u32 sb_index)
 933 {
 934         req->_present.sb_index = 1;
 935         req->sb_index = sb_index;
 936 }
 937
 938 struct devlink_sb_get_rsp {
 939         struct {
 940                 __u32 bus_name_len;
 941                 __u32 dev_name_len;
 942                 __u32 sb_index:1;
 943         } _present;
 944
 945         char *bus_name;
 946         char *dev_name;
 947         __u32 sb_index;
 948 };
 949
 950 void devlink_sb_get_rsp_free(struct devlink_sb_get_rsp *rsp);
 951
 952 /*
 953  * Get shared buffer instances.
 954  */
 955 struct devlink_sb_get_rsp *
 956 devlink_sb_get(struct ynl_sock *ys, struct devlink_sb_get_req *req);
 957
 958 /* DEVLINK_CMD_SB_GET - dump */
 959 struct devlink_sb_get_req_dump {
 960         struct {
 961                 __u32 bus_name_len;
 962                 __u32 dev_name_len;
 963         } _present;
 964
 965         char *bus_name;
 966         char *dev_name;
 967 };
 968
 969 static inline struct devlink_sb_get_req_dump *
 970 devlink_sb_get_req_dump_alloc(void)
 971 {
 972         return calloc(1, sizeof(struct devlink_sb_get_req_dump));
 973 }
 974 void devlink_sb_get_req_dump_free(struct devlink_sb_get_req_dump *req);
 975
 976 static inline void
 977 devlink_sb_get_req_dump_set_bus_name(struct devlink_sb_get_req_dump *req,
 978                                      const char *bus_name)
 979 {
 980         free(req->bus_name);
 981         req->_present.bus_name_len = strlen(bus_name);
 982         req->bus_name = malloc(req->_present.bus_name_len + 1);
 983         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
 984         req->bus_name[req->_present.bus_name_len] = 0;
 985 }
 986 static inline void
 987 devlink_sb_get_req_dump_set_dev_name(struct devlink_sb_get_req_dump *req,
 988                                      const char *dev_name)
 989 {
 990         free(req->dev_name);
 991         req->_present.dev_name_len = strlen(dev_name);
 992         req->dev_name = malloc(req->_present.dev_name_len + 1);
 993         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
 994         req->dev_name[req->_present.dev_name_len] = 0;
 995 }
 996
 997 struct devlink_sb_get_list {
 998         struct devlink_sb_get_list *next;
 999         struct devlink_sb_get_rsp obj __attribute__ ((aligned (8)));
1000 };
1001
1002 void devlink_sb_get_list_free(struct devlink_sb_get_list *rsp);
1003
1004 struct devlink_sb_get_list *
1005 devlink_sb_get_dump(struct ynl_sock *ys, struct devlink_sb_get_req_dump *req);
1006
1007 /* ============== DEVLINK_CMD_SB_POOL_GET ============== */
1008 /* DEVLINK_CMD_SB_POOL_GET - do */
1009 struct devlink_sb_pool_get_req {
1010         struct {
1011                 __u32 bus_name_len;
1012                 __u32 dev_name_len;
1013                 __u32 sb_index:1;
1014                 __u32 sb_pool_index:1;
1015         } _present;
1016
1017         char *bus_name;
1018         char *dev_name;
1019         __u32 sb_index;
1020         __u16 sb_pool_index;
1021 };
1022
1023 static inline struct devlink_sb_pool_get_req *
1024 devlink_sb_pool_get_req_alloc(void)
1025 {
1026         return calloc(1, sizeof(struct devlink_sb_pool_get_req));
1027 }
1028 void devlink_sb_pool_get_req_free(struct devlink_sb_pool_get_req *req);
1029
1030 static inline void
1031 devlink_sb_pool_get_req_set_bus_name(struct devlink_sb_pool_get_req *req,
1032                                      const char *bus_name)
1033 {
1034         free(req->bus_name);
1035         req->_present.bus_name_len = strlen(bus_name);
1036         req->bus_name = malloc(req->_present.bus_name_len + 1);
1037         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1038         req->bus_name[req->_present.bus_name_len] = 0;
1039 }
1040 static inline void
1041 devlink_sb_pool_get_req_set_dev_name(struct devlink_sb_pool_get_req *req,
1042                                      const char *dev_name)
1043 {
1044         free(req->dev_name);
1045         req->_present.dev_name_len = strlen(dev_name);
1046         req->dev_name = malloc(req->_present.dev_name_len + 1);
1047         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1048         req->dev_name[req->_present.dev_name_len] = 0;
1049 }
1050 static inline void
1051 devlink_sb_pool_get_req_set_sb_index(struct devlink_sb_pool_get_req *req,
1052                                      __u32 sb_index)
1053 {
1054         req->_present.sb_index = 1;
1055         req->sb_index = sb_index;
1056 }
1057 static inline void
1058 devlink_sb_pool_get_req_set_sb_pool_index(struct devlink_sb_pool_get_req *req,
1059                                           __u16 sb_pool_index)
1060 {
1061         req->_present.sb_pool_index = 1;
1062         req->sb_pool_index = sb_pool_index;
1063 }
1064
1065 struct devlink_sb_pool_get_rsp {
1066         struct {
1067                 __u32 bus_name_len;
1068                 __u32 dev_name_len;
1069                 __u32 sb_index:1;
1070                 __u32 sb_pool_index:1;
1071         } _present;
1072
1073         char *bus_name;
1074         char *dev_name;
1075         __u32 sb_index;
1076         __u16 sb_pool_index;
1077 };
1078
1079 void devlink_sb_pool_get_rsp_free(struct devlink_sb_pool_get_rsp *rsp);
1080
1081 /*
1082  * Get shared buffer pool instances.
1083  */
1084 struct devlink_sb_pool_get_rsp *
1085 devlink_sb_pool_get(struct ynl_sock *ys, struct devlink_sb_pool_get_req *req);
1086
1087 /* DEVLINK_CMD_SB_POOL_GET - dump */
1088 struct devlink_sb_pool_get_req_dump {
1089         struct {
1090                 __u32 bus_name_len;
1091                 __u32 dev_name_len;
1092         } _present;
1093
1094         char *bus_name;
1095         char *dev_name;
1096 };
1097
1098 static inline struct devlink_sb_pool_get_req_dump *
1099 devlink_sb_pool_get_req_dump_alloc(void)
1100 {
1101         return calloc(1, sizeof(struct devlink_sb_pool_get_req_dump));
1102 }
1103 void
1104 devlink_sb_pool_get_req_dump_free(struct devlink_sb_pool_get_req_dump *req);
1105
1106 static inline void
1107 devlink_sb_pool_get_req_dump_set_bus_name(struct devlink_sb_pool_get_req_dump *req,
1108                                           const char *bus_name)
1109 {
1110         free(req->bus_name);
1111         req->_present.bus_name_len = strlen(bus_name);
1112         req->bus_name = malloc(req->_present.bus_name_len + 1);
1113         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1114         req->bus_name[req->_present.bus_name_len] = 0;
1115 }
1116 static inline void
1117 devlink_sb_pool_get_req_dump_set_dev_name(struct devlink_sb_pool_get_req_dump *req,
1118                                           const char *dev_name)
1119 {
1120         free(req->dev_name);
1121         req->_present.dev_name_len = strlen(dev_name);
1122         req->dev_name = malloc(req->_present.dev_name_len + 1);
1123         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1124         req->dev_name[req->_present.dev_name_len] = 0;
1125 }
1126
1127 struct devlink_sb_pool_get_list {
1128         struct devlink_sb_pool_get_list *next;
1129         struct devlink_sb_pool_get_rsp obj __attribute__ ((aligned (8)));
1130 };
1131
1132 void devlink_sb_pool_get_list_free(struct devlink_sb_pool_get_list *rsp);
1133
1134 struct devlink_sb_pool_get_list *
1135 devlink_sb_pool_get_dump(struct ynl_sock *ys,
1136                          struct devlink_sb_pool_get_req_dump *req);
1137
1138 /* ============== DEVLINK_CMD_SB_POOL_SET ============== */
1139 /* DEVLINK_CMD_SB_POOL_SET - do */
1140 struct devlink_sb_pool_set_req {
1141         struct {
1142                 __u32 bus_name_len;
1143                 __u32 dev_name_len;
1144                 __u32 sb_index:1;
1145                 __u32 sb_pool_index:1;
1146                 __u32 sb_pool_threshold_type:1;
1147                 __u32 sb_pool_size:1;
1148         } _present;
1149
1150         char *bus_name;
1151         char *dev_name;
1152         __u32 sb_index;
1153         __u16 sb_pool_index;
1154         enum devlink_sb_threshold_type sb_pool_threshold_type;
1155         __u32 sb_pool_size;
1156 };
1157
1158 static inline struct devlink_sb_pool_set_req *
1159 devlink_sb_pool_set_req_alloc(void)
1160 {
1161         return calloc(1, sizeof(struct devlink_sb_pool_set_req));
1162 }
1163 void devlink_sb_pool_set_req_free(struct devlink_sb_pool_set_req *req);
1164
1165 static inline void
1166 devlink_sb_pool_set_req_set_bus_name(struct devlink_sb_pool_set_req *req,
1167                                      const char *bus_name)
1168 {
1169         free(req->bus_name);
1170         req->_present.bus_name_len = strlen(bus_name);
1171         req->bus_name = malloc(req->_present.bus_name_len + 1);
1172         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1173         req->bus_name[req->_present.bus_name_len] = 0;
1174 }
1175 static inline void
1176 devlink_sb_pool_set_req_set_dev_name(struct devlink_sb_pool_set_req *req,
1177                                      const char *dev_name)
1178 {
1179         free(req->dev_name);
1180         req->_present.dev_name_len = strlen(dev_name);
1181         req->dev_name = malloc(req->_present.dev_name_len + 1);
1182         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1183         req->dev_name[req->_present.dev_name_len] = 0;
1184 }
1185 static inline void
1186 devlink_sb_pool_set_req_set_sb_index(struct devlink_sb_pool_set_req *req,
1187                                      __u32 sb_index)
1188 {
1189         req->_present.sb_index = 1;
1190         req->sb_index = sb_index;
1191 }
1192 static inline void
1193 devlink_sb_pool_set_req_set_sb_pool_index(struct devlink_sb_pool_set_req *req,
1194                                           __u16 sb_pool_index)
1195 {
1196         req->_present.sb_pool_index = 1;
1197         req->sb_pool_index = sb_pool_index;
1198 }
1199 static inline void
1200 devlink_sb_pool_set_req_set_sb_pool_threshold_type(struct devlink_sb_pool_set_req *req,
1201                                                    enum devlink_sb_threshold_type sb_pool_threshold_type)
1202 {
1203         req->_present.sb_pool_threshold_type = 1;
1204         req->sb_pool_threshold_type = sb_pool_threshold_type;
1205 }
1206 static inline void
1207 devlink_sb_pool_set_req_set_sb_pool_size(struct devlink_sb_pool_set_req *req,
1208                                          __u32 sb_pool_size)
1209 {
1210         req->_present.sb_pool_size = 1;
1211         req->sb_pool_size = sb_pool_size;
1212 }
1213
1214 /*
1215  * Set shared buffer pool instances.
1216  */
1217 int devlink_sb_pool_set(struct ynl_sock *ys,
1218                         struct devlink_sb_pool_set_req *req);
1219
1220 /* ============== DEVLINK_CMD_SB_PORT_POOL_GET ============== */
1221 /* DEVLINK_CMD_SB_PORT_POOL_GET - do */
1222 struct devlink_sb_port_pool_get_req {
1223         struct {
1224                 __u32 bus_name_len;
1225                 __u32 dev_name_len;
1226                 __u32 port_index:1;
1227                 __u32 sb_index:1;
1228                 __u32 sb_pool_index:1;
1229         } _present;
1230
1231         char *bus_name;
1232         char *dev_name;
1233         __u32 port_index;
1234         __u32 sb_index;
1235         __u16 sb_pool_index;
1236 };
1237
1238 static inline struct devlink_sb_port_pool_get_req *
1239 devlink_sb_port_pool_get_req_alloc(void)
1240 {
1241         return calloc(1, sizeof(struct devlink_sb_port_pool_get_req));
1242 }
1243 void
1244 devlink_sb_port_pool_get_req_free(struct devlink_sb_port_pool_get_req *req);
1245
1246 static inline void
1247 devlink_sb_port_pool_get_req_set_bus_name(struct devlink_sb_port_pool_get_req *req,
1248                                           const char *bus_name)
1249 {
1250         free(req->bus_name);
1251         req->_present.bus_name_len = strlen(bus_name);
1252         req->bus_name = malloc(req->_present.bus_name_len + 1);
1253         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1254         req->bus_name[req->_present.bus_name_len] = 0;
1255 }
1256 static inline void
1257 devlink_sb_port_pool_get_req_set_dev_name(struct devlink_sb_port_pool_get_req *req,
1258                                           const char *dev_name)
1259 {
1260         free(req->dev_name);
1261         req->_present.dev_name_len = strlen(dev_name);
1262         req->dev_name = malloc(req->_present.dev_name_len + 1);
1263         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1264         req->dev_name[req->_present.dev_name_len] = 0;
1265 }
1266 static inline void
1267 devlink_sb_port_pool_get_req_set_port_index(struct devlink_sb_port_pool_get_req *req,
1268                                             __u32 port_index)
1269 {
1270         req->_present.port_index = 1;
1271         req->port_index = port_index;
1272 }
1273 static inline void
1274 devlink_sb_port_pool_get_req_set_sb_index(struct devlink_sb_port_pool_get_req *req,
1275                                           __u32 sb_index)
1276 {
1277         req->_present.sb_index = 1;
1278         req->sb_index = sb_index;
1279 }
1280 static inline void
1281 devlink_sb_port_pool_get_req_set_sb_pool_index(struct devlink_sb_port_pool_get_req *req,
1282                                                __u16 sb_pool_index)
1283 {
1284         req->_present.sb_pool_index = 1;
1285         req->sb_pool_index = sb_pool_index;
1286 }
1287
1288 struct devlink_sb_port_pool_get_rsp {
1289         struct {
1290                 __u32 bus_name_len;
1291                 __u32 dev_name_len;
1292                 __u32 port_index:1;
1293                 __u32 sb_index:1;
1294                 __u32 sb_pool_index:1;
1295         } _present;
1296
1297         char *bus_name;
1298         char *dev_name;
1299         __u32 port_index;
1300         __u32 sb_index;
1301         __u16 sb_pool_index;
1302 };
1303
1304 void
1305 devlink_sb_port_pool_get_rsp_free(struct devlink_sb_port_pool_get_rsp *rsp);
1306
1307 /*
1308  * Get shared buffer port-pool combinations and threshold.
1309  */
1310 struct devlink_sb_port_pool_get_rsp *
1311 devlink_sb_port_pool_get(struct ynl_sock *ys,
1312                          struct devlink_sb_port_pool_get_req *req);
1313
1314 /* DEVLINK_CMD_SB_PORT_POOL_GET - dump */
1315 struct devlink_sb_port_pool_get_req_dump {
1316         struct {
1317                 __u32 bus_name_len;
1318                 __u32 dev_name_len;
1319         } _present;
1320
1321         char *bus_name;
1322         char *dev_name;
1323 };
1324
1325 static inline struct devlink_sb_port_pool_get_req_dump *
1326 devlink_sb_port_pool_get_req_dump_alloc(void)
1327 {
1328         return calloc(1, sizeof(struct devlink_sb_port_pool_get_req_dump));
1329 }
1330 void
1331 devlink_sb_port_pool_get_req_dump_free(struct devlink_sb_port_pool_get_req_dump *req);
1332
1333 static inline void
1334 devlink_sb_port_pool_get_req_dump_set_bus_name(struct devlink_sb_port_pool_get_req_dump *req,
1335                                                const char *bus_name)
1336 {
1337         free(req->bus_name);
1338         req->_present.bus_name_len = strlen(bus_name);
1339         req->bus_name = malloc(req->_present.bus_name_len + 1);
1340         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1341         req->bus_name[req->_present.bus_name_len] = 0;
1342 }
1343 static inline void
1344 devlink_sb_port_pool_get_req_dump_set_dev_name(struct devlink_sb_port_pool_get_req_dump *req,
1345                                                const char *dev_name)
1346 {
1347         free(req->dev_name);
1348         req->_present.dev_name_len = strlen(dev_name);
1349         req->dev_name = malloc(req->_present.dev_name_len + 1);
1350         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1351         req->dev_name[req->_present.dev_name_len] = 0;
1352 }
1353
1354 struct devlink_sb_port_pool_get_list {
1355         struct devlink_sb_port_pool_get_list *next;
1356         struct devlink_sb_port_pool_get_rsp obj __attribute__ ((aligned (8)));
1357 };
1358
1359 void
1360 devlink_sb_port_pool_get_list_free(struct devlink_sb_port_pool_get_list *rsp);
1361
1362 struct devlink_sb_port_pool_get_list *
1363 devlink_sb_port_pool_get_dump(struct ynl_sock *ys,
1364                               struct devlink_sb_port_pool_get_req_dump *req);
1365
1366 /* ============== DEVLINK_CMD_SB_PORT_POOL_SET ============== */
1367 /* DEVLINK_CMD_SB_PORT_POOL_SET - do */
1368 struct devlink_sb_port_pool_set_req {
1369         struct {
1370                 __u32 bus_name_len;
1371                 __u32 dev_name_len;
1372                 __u32 port_index:1;
1373                 __u32 sb_index:1;
1374                 __u32 sb_pool_index:1;
1375                 __u32 sb_threshold:1;
1376         } _present;
1377
1378         char *bus_name;
1379         char *dev_name;
1380         __u32 port_index;
1381         __u32 sb_index;
1382         __u16 sb_pool_index;
1383         __u32 sb_threshold;
1384 };
1385
1386 static inline struct devlink_sb_port_pool_set_req *
1387 devlink_sb_port_pool_set_req_alloc(void)
1388 {
1389         return calloc(1, sizeof(struct devlink_sb_port_pool_set_req));
1390 }
1391 void
1392 devlink_sb_port_pool_set_req_free(struct devlink_sb_port_pool_set_req *req);
1393
1394 static inline void
1395 devlink_sb_port_pool_set_req_set_bus_name(struct devlink_sb_port_pool_set_req *req,
1396                                           const char *bus_name)
1397 {
1398         free(req->bus_name);
1399         req->_present.bus_name_len = strlen(bus_name);
1400         req->bus_name = malloc(req->_present.bus_name_len + 1);
1401         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1402         req->bus_name[req->_present.bus_name_len] = 0;
1403 }
1404 static inline void
1405 devlink_sb_port_pool_set_req_set_dev_name(struct devlink_sb_port_pool_set_req *req,
1406                                           const char *dev_name)
1407 {
1408         free(req->dev_name);
1409         req->_present.dev_name_len = strlen(dev_name);
1410         req->dev_name = malloc(req->_present.dev_name_len + 1);
1411         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1412         req->dev_name[req->_present.dev_name_len] = 0;
1413 }
1414 static inline void
1415 devlink_sb_port_pool_set_req_set_port_index(struct devlink_sb_port_pool_set_req *req,
1416                                             __u32 port_index)
1417 {
1418         req->_present.port_index = 1;
1419         req->port_index = port_index;
1420 }
1421 static inline void
1422 devlink_sb_port_pool_set_req_set_sb_index(struct devlink_sb_port_pool_set_req *req,
1423                                           __u32 sb_index)
1424 {
1425         req->_present.sb_index = 1;
1426         req->sb_index = sb_index;
1427 }
1428 static inline void
1429 devlink_sb_port_pool_set_req_set_sb_pool_index(struct devlink_sb_port_pool_set_req *req,
1430                                                __u16 sb_pool_index)
1431 {
1432         req->_present.sb_pool_index = 1;
1433         req->sb_pool_index = sb_pool_index;
1434 }
1435 static inline void
1436 devlink_sb_port_pool_set_req_set_sb_threshold(struct devlink_sb_port_pool_set_req *req,
1437                                               __u32 sb_threshold)
1438 {
1439         req->_present.sb_threshold = 1;
1440         req->sb_threshold = sb_threshold;
1441 }
1442
1443 /*
1444  * Set shared buffer port-pool combinations and threshold.
1445  */
1446 int devlink_sb_port_pool_set(struct ynl_sock *ys,
1447                              struct devlink_sb_port_pool_set_req *req);
1448
1449 /* ============== DEVLINK_CMD_SB_TC_POOL_BIND_GET ============== */
1450 /* DEVLINK_CMD_SB_TC_POOL_BIND_GET - do */
1451 struct devlink_sb_tc_pool_bind_get_req {
1452         struct {
1453                 __u32 bus_name_len;
1454                 __u32 dev_name_len;
1455                 __u32 port_index:1;
1456                 __u32 sb_index:1;
1457                 __u32 sb_pool_type:1;
1458                 __u32 sb_tc_index:1;
1459         } _present;
1460
1461         char *bus_name;
1462         char *dev_name;
1463         __u32 port_index;
1464         __u32 sb_index;
1465         enum devlink_sb_pool_type sb_pool_type;
1466         __u16 sb_tc_index;
1467 };
1468
1469 static inline struct devlink_sb_tc_pool_bind_get_req *
1470 devlink_sb_tc_pool_bind_get_req_alloc(void)
1471 {
1472         return calloc(1, sizeof(struct devlink_sb_tc_pool_bind_get_req));
1473 }
1474 void
1475 devlink_sb_tc_pool_bind_get_req_free(struct devlink_sb_tc_pool_bind_get_req *req);
1476
1477 static inline void
1478 devlink_sb_tc_pool_bind_get_req_set_bus_name(struct devlink_sb_tc_pool_bind_get_req *req,
1479                                              const char *bus_name)
1480 {
1481         free(req->bus_name);
1482         req->_present.bus_name_len = strlen(bus_name);
1483         req->bus_name = malloc(req->_present.bus_name_len + 1);
1484         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1485         req->bus_name[req->_present.bus_name_len] = 0;
1486 }
1487 static inline void
1488 devlink_sb_tc_pool_bind_get_req_set_dev_name(struct devlink_sb_tc_pool_bind_get_req *req,
1489                                              const char *dev_name)
1490 {
1491         free(req->dev_name);
1492         req->_present.dev_name_len = strlen(dev_name);
1493         req->dev_name = malloc(req->_present.dev_name_len + 1);
1494         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1495         req->dev_name[req->_present.dev_name_len] = 0;
1496 }
1497 static inline void
1498 devlink_sb_tc_pool_bind_get_req_set_port_index(struct devlink_sb_tc_pool_bind_get_req *req,
1499                                                __u32 port_index)
1500 {
1501         req->_present.port_index = 1;
1502         req->port_index = port_index;
1503 }
1504 static inline void
1505 devlink_sb_tc_pool_bind_get_req_set_sb_index(struct devlink_sb_tc_pool_bind_get_req *req,
1506                                              __u32 sb_index)
1507 {
1508         req->_present.sb_index = 1;
1509         req->sb_index = sb_index;
1510 }
1511 static inline void
1512 devlink_sb_tc_pool_bind_get_req_set_sb_pool_type(struct devlink_sb_tc_pool_bind_get_req *req,
1513                                                  enum devlink_sb_pool_type sb_pool_type)
1514 {
1515         req->_present.sb_pool_type = 1;
1516         req->sb_pool_type = sb_pool_type;
1517 }
1518 static inline void
1519 devlink_sb_tc_pool_bind_get_req_set_sb_tc_index(struct devlink_sb_tc_pool_bind_get_req *req,
1520                                                 __u16 sb_tc_index)
1521 {
1522         req->_present.sb_tc_index = 1;
1523         req->sb_tc_index = sb_tc_index;
1524 }
1525
1526 struct devlink_sb_tc_pool_bind_get_rsp {
1527         struct {
1528                 __u32 bus_name_len;
1529                 __u32 dev_name_len;
1530                 __u32 port_index:1;
1531                 __u32 sb_index:1;
1532                 __u32 sb_pool_type:1;
1533                 __u32 sb_tc_index:1;
1534         } _present;
1535
1536         char *bus_name;
1537         char *dev_name;
1538         __u32 port_index;
1539         __u32 sb_index;
1540         enum devlink_sb_pool_type sb_pool_type;
1541         __u16 sb_tc_index;
1542 };
1543
1544 void
1545 devlink_sb_tc_pool_bind_get_rsp_free(struct devlink_sb_tc_pool_bind_get_rsp *rsp);
1546
1547 /*
1548  * Get shared buffer port-TC to pool bindings and threshold.
1549  */
1550 struct devlink_sb_tc_pool_bind_get_rsp *
1551 devlink_sb_tc_pool_bind_get(struct ynl_sock *ys,
1552                             struct devlink_sb_tc_pool_bind_get_req *req);
1553
1554 /* DEVLINK_CMD_SB_TC_POOL_BIND_GET - dump */
1555 struct devlink_sb_tc_pool_bind_get_req_dump {
1556         struct {
1557                 __u32 bus_name_len;
1558                 __u32 dev_name_len;
1559         } _present;
1560
1561         char *bus_name;
1562         char *dev_name;
1563 };
1564
1565 static inline struct devlink_sb_tc_pool_bind_get_req_dump *
1566 devlink_sb_tc_pool_bind_get_req_dump_alloc(void)
1567 {
1568         return calloc(1, sizeof(struct devlink_sb_tc_pool_bind_get_req_dump));
1569 }
1570 void
1571 devlink_sb_tc_pool_bind_get_req_dump_free(struct devlink_sb_tc_pool_bind_get_req_dump *req);
1572
1573 static inline void
1574 devlink_sb_tc_pool_bind_get_req_dump_set_bus_name(struct devlink_sb_tc_pool_bind_get_req_dump *req,
1575                                                   const char *bus_name)
1576 {
1577         free(req->bus_name);
1578         req->_present.bus_name_len = strlen(bus_name);
1579         req->bus_name = malloc(req->_present.bus_name_len + 1);
1580         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1581         req->bus_name[req->_present.bus_name_len] = 0;
1582 }
1583 static inline void
1584 devlink_sb_tc_pool_bind_get_req_dump_set_dev_name(struct devlink_sb_tc_pool_bind_get_req_dump *req,
1585                                                   const char *dev_name)
1586 {
1587         free(req->dev_name);
1588         req->_present.dev_name_len = strlen(dev_name);
1589         req->dev_name = malloc(req->_present.dev_name_len + 1);
1590         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1591         req->dev_name[req->_present.dev_name_len] = 0;
1592 }
1593
1594 struct devlink_sb_tc_pool_bind_get_list {
1595         struct devlink_sb_tc_pool_bind_get_list *next;
1596         struct devlink_sb_tc_pool_bind_get_rsp obj __attribute__ ((aligned (8)));
1597 };
1598
1599 void
1600 devlink_sb_tc_pool_bind_get_list_free(struct devlink_sb_tc_pool_bind_get_list *rsp);
1601
1602 struct devlink_sb_tc_pool_bind_get_list *
1603 devlink_sb_tc_pool_bind_get_dump(struct ynl_sock *ys,
1604                                  struct devlink_sb_tc_pool_bind_get_req_dump *req);
1605
1606 /* ============== DEVLINK_CMD_SB_TC_POOL_BIND_SET ============== */
1607 /* DEVLINK_CMD_SB_TC_POOL_BIND_SET - do */
1608 struct devlink_sb_tc_pool_bind_set_req {
1609         struct {
1610                 __u32 bus_name_len;
1611                 __u32 dev_name_len;
1612                 __u32 port_index:1;
1613                 __u32 sb_index:1;
1614                 __u32 sb_pool_index:1;
1615                 __u32 sb_pool_type:1;
1616                 __u32 sb_tc_index:1;
1617                 __u32 sb_threshold:1;
1618         } _present;
1619
1620         char *bus_name;
1621         char *dev_name;
1622         __u32 port_index;
1623         __u32 sb_index;
1624         __u16 sb_pool_index;
1625         enum devlink_sb_pool_type sb_pool_type;
1626         __u16 sb_tc_index;
1627         __u32 sb_threshold;
1628 };
1629
1630 static inline struct devlink_sb_tc_pool_bind_set_req *
1631 devlink_sb_tc_pool_bind_set_req_alloc(void)
1632 {
1633         return calloc(1, sizeof(struct devlink_sb_tc_pool_bind_set_req));
1634 }
1635 void
1636 devlink_sb_tc_pool_bind_set_req_free(struct devlink_sb_tc_pool_bind_set_req *req);
1637
1638 static inline void
1639 devlink_sb_tc_pool_bind_set_req_set_bus_name(struct devlink_sb_tc_pool_bind_set_req *req,
1640                                              const char *bus_name)
1641 {
1642         free(req->bus_name);
1643         req->_present.bus_name_len = strlen(bus_name);
1644         req->bus_name = malloc(req->_present.bus_name_len + 1);
1645         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1646         req->bus_name[req->_present.bus_name_len] = 0;
1647 }
1648 static inline void
1649 devlink_sb_tc_pool_bind_set_req_set_dev_name(struct devlink_sb_tc_pool_bind_set_req *req,
1650                                              const char *dev_name)
1651 {
1652         free(req->dev_name);
1653         req->_present.dev_name_len = strlen(dev_name);
1654         req->dev_name = malloc(req->_present.dev_name_len + 1);
1655         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1656         req->dev_name[req->_present.dev_name_len] = 0;
1657 }
1658 static inline void
1659 devlink_sb_tc_pool_bind_set_req_set_port_index(struct devlink_sb_tc_pool_bind_set_req *req,
1660                                                __u32 port_index)
1661 {
1662         req->_present.port_index = 1;
1663         req->port_index = port_index;
1664 }
1665 static inline void
1666 devlink_sb_tc_pool_bind_set_req_set_sb_index(struct devlink_sb_tc_pool_bind_set_req *req,
1667                                              __u32 sb_index)
1668 {
1669         req->_present.sb_index = 1;
1670         req->sb_index = sb_index;
1671 }
1672 static inline void
1673 devlink_sb_tc_pool_bind_set_req_set_sb_pool_index(struct devlink_sb_tc_pool_bind_set_req *req,
1674                                                   __u16 sb_pool_index)
1675 {
1676         req->_present.sb_pool_index = 1;
1677         req->sb_pool_index = sb_pool_index;
1678 }
1679 static inline void
1680 devlink_sb_tc_pool_bind_set_req_set_sb_pool_type(struct devlink_sb_tc_pool_bind_set_req *req,
1681                                                  enum devlink_sb_pool_type sb_pool_type)
1682 {
1683         req->_present.sb_pool_type = 1;
1684         req->sb_pool_type = sb_pool_type;
1685 }
1686 static inline void
1687 devlink_sb_tc_pool_bind_set_req_set_sb_tc_index(struct devlink_sb_tc_pool_bind_set_req *req,
1688                                                 __u16 sb_tc_index)
1689 {
1690         req->_present.sb_tc_index = 1;
1691         req->sb_tc_index = sb_tc_index;
1692 }
1693 static inline void
1694 devlink_sb_tc_pool_bind_set_req_set_sb_threshold(struct devlink_sb_tc_pool_bind_set_req *req,
1695                                                  __u32 sb_threshold)
1696 {
1697         req->_present.sb_threshold = 1;
1698         req->sb_threshold = sb_threshold;
1699 }
1700
1701 /*
1702  * Set shared buffer port-TC to pool bindings and threshold.
1703  */
1704 int devlink_sb_tc_pool_bind_set(struct ynl_sock *ys,
1705                                 struct devlink_sb_tc_pool_bind_set_req *req);
1706
1707 /* ============== DEVLINK_CMD_SB_OCC_SNAPSHOT ============== */
1708 /* DEVLINK_CMD_SB_OCC_SNAPSHOT - do */
1709 struct devlink_sb_occ_snapshot_req {
1710         struct {
1711                 __u32 bus_name_len;
1712                 __u32 dev_name_len;
1713                 __u32 sb_index:1;
1714         } _present;
1715
1716         char *bus_name;
1717         char *dev_name;
1718         __u32 sb_index;
1719 };
1720
1721 static inline struct devlink_sb_occ_snapshot_req *
1722 devlink_sb_occ_snapshot_req_alloc(void)
1723 {
1724         return calloc(1, sizeof(struct devlink_sb_occ_snapshot_req));
1725 }
1726 void devlink_sb_occ_snapshot_req_free(struct devlink_sb_occ_snapshot_req *req);
1727
1728 static inline void
1729 devlink_sb_occ_snapshot_req_set_bus_name(struct devlink_sb_occ_snapshot_req *req,
1730                                          const char *bus_name)
1731 {
1732         free(req->bus_name);
1733         req->_present.bus_name_len = strlen(bus_name);
1734         req->bus_name = malloc(req->_present.bus_name_len + 1);
1735         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1736         req->bus_name[req->_present.bus_name_len] = 0;
1737 }
1738 static inline void
1739 devlink_sb_occ_snapshot_req_set_dev_name(struct devlink_sb_occ_snapshot_req *req,
1740                                          const char *dev_name)
1741 {
1742         free(req->dev_name);
1743         req->_present.dev_name_len = strlen(dev_name);
1744         req->dev_name = malloc(req->_present.dev_name_len + 1);
1745         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1746         req->dev_name[req->_present.dev_name_len] = 0;
1747 }
1748 static inline void
1749 devlink_sb_occ_snapshot_req_set_sb_index(struct devlink_sb_occ_snapshot_req *req,
1750                                          __u32 sb_index)
1751 {
1752         req->_present.sb_index = 1;
1753         req->sb_index = sb_index;
1754 }
1755
1756 /*
1757  * Take occupancy snapshot of shared buffer.
1758  */
1759 int devlink_sb_occ_snapshot(struct ynl_sock *ys,
1760                             struct devlink_sb_occ_snapshot_req *req);
1761
1762 /* ============== DEVLINK_CMD_SB_OCC_MAX_CLEAR ============== */
1763 /* DEVLINK_CMD_SB_OCC_MAX_CLEAR - do */
1764 struct devlink_sb_occ_max_clear_req {
1765         struct {
1766                 __u32 bus_name_len;
1767                 __u32 dev_name_len;
1768                 __u32 sb_index:1;
1769         } _present;
1770
1771         char *bus_name;
1772         char *dev_name;
1773         __u32 sb_index;
1774 };
1775
1776 static inline struct devlink_sb_occ_max_clear_req *
1777 devlink_sb_occ_max_clear_req_alloc(void)
1778 {
1779         return calloc(1, sizeof(struct devlink_sb_occ_max_clear_req));
1780 }
1781 void
1782 devlink_sb_occ_max_clear_req_free(struct devlink_sb_occ_max_clear_req *req);
1783
1784 static inline void
1785 devlink_sb_occ_max_clear_req_set_bus_name(struct devlink_sb_occ_max_clear_req *req,
1786                                           const char *bus_name)
1787 {
1788         free(req->bus_name);
1789         req->_present.bus_name_len = strlen(bus_name);
1790         req->bus_name = malloc(req->_present.bus_name_len + 1);
1791         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1792         req->bus_name[req->_present.bus_name_len] = 0;
1793 }
1794 static inline void
1795 devlink_sb_occ_max_clear_req_set_dev_name(struct devlink_sb_occ_max_clear_req *req,
1796                                           const char *dev_name)
1797 {
1798         free(req->dev_name);
1799         req->_present.dev_name_len = strlen(dev_name);
1800         req->dev_name = malloc(req->_present.dev_name_len + 1);
1801         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1802         req->dev_name[req->_present.dev_name_len] = 0;
1803 }
1804 static inline void
1805 devlink_sb_occ_max_clear_req_set_sb_index(struct devlink_sb_occ_max_clear_req *req,
1806                                           __u32 sb_index)
1807 {
1808         req->_present.sb_index = 1;
1809         req->sb_index = sb_index;
1810 }
1811
1812 /*
1813  * Clear occupancy watermarks of shared buffer.
1814  */
1815 int devlink_sb_occ_max_clear(struct ynl_sock *ys,
1816                              struct devlink_sb_occ_max_clear_req *req);
1817
1818 /* ============== DEVLINK_CMD_ESWITCH_GET ============== */
1819 /* DEVLINK_CMD_ESWITCH_GET - do */
1820 struct devlink_eswitch_get_req {
1821         struct {
1822                 __u32 bus_name_len;
1823                 __u32 dev_name_len;
1824         } _present;
1825
1826         char *bus_name;
1827         char *dev_name;
1828 };
1829
1830 static inline struct devlink_eswitch_get_req *
1831 devlink_eswitch_get_req_alloc(void)
1832 {
1833         return calloc(1, sizeof(struct devlink_eswitch_get_req));
1834 }
1835 void devlink_eswitch_get_req_free(struct devlink_eswitch_get_req *req);
1836
1837 static inline void
1838 devlink_eswitch_get_req_set_bus_name(struct devlink_eswitch_get_req *req,
1839                                      const char *bus_name)
1840 {
1841         free(req->bus_name);
1842         req->_present.bus_name_len = strlen(bus_name);
1843         req->bus_name = malloc(req->_present.bus_name_len + 1);
1844         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1845         req->bus_name[req->_present.bus_name_len] = 0;
1846 }
1847 static inline void
1848 devlink_eswitch_get_req_set_dev_name(struct devlink_eswitch_get_req *req,
1849                                      const char *dev_name)
1850 {
1851         free(req->dev_name);
1852         req->_present.dev_name_len = strlen(dev_name);
1853         req->dev_name = malloc(req->_present.dev_name_len + 1);
1854         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1855         req->dev_name[req->_present.dev_name_len] = 0;
1856 }
1857
1858 struct devlink_eswitch_get_rsp {
1859         struct {
1860                 __u32 bus_name_len;
1861                 __u32 dev_name_len;
1862                 __u32 eswitch_mode:1;
1863                 __u32 eswitch_inline_mode:1;
1864                 __u32 eswitch_encap_mode:1;
1865         } _present;
1866
1867         char *bus_name;
1868         char *dev_name;
1869         enum devlink_eswitch_mode eswitch_mode;
1870         enum devlink_eswitch_inline_mode eswitch_inline_mode;
1871         enum devlink_eswitch_encap_mode eswitch_encap_mode;
1872 };
1873
1874 void devlink_eswitch_get_rsp_free(struct devlink_eswitch_get_rsp *rsp);
1875
1876 /*
1877  * Get eswitch attributes.
1878  */
1879 struct devlink_eswitch_get_rsp *
1880 devlink_eswitch_get(struct ynl_sock *ys, struct devlink_eswitch_get_req *req);
1881
1882 /* ============== DEVLINK_CMD_ESWITCH_SET ============== */
1883 /* DEVLINK_CMD_ESWITCH_SET - do */
1884 struct devlink_eswitch_set_req {
1885         struct {
1886                 __u32 bus_name_len;
1887                 __u32 dev_name_len;
1888                 __u32 eswitch_mode:1;
1889                 __u32 eswitch_inline_mode:1;
1890                 __u32 eswitch_encap_mode:1;
1891         } _present;
1892
1893         char *bus_name;
1894         char *dev_name;
1895         enum devlink_eswitch_mode eswitch_mode;
1896         enum devlink_eswitch_inline_mode eswitch_inline_mode;
1897         enum devlink_eswitch_encap_mode eswitch_encap_mode;
1898 };
1899
1900 static inline struct devlink_eswitch_set_req *
1901 devlink_eswitch_set_req_alloc(void)
1902 {
1903         return calloc(1, sizeof(struct devlink_eswitch_set_req));
1904 }
1905 void devlink_eswitch_set_req_free(struct devlink_eswitch_set_req *req);
1906
1907 static inline void
1908 devlink_eswitch_set_req_set_bus_name(struct devlink_eswitch_set_req *req,
1909                                      const char *bus_name)
1910 {
1911         free(req->bus_name);
1912         req->_present.bus_name_len = strlen(bus_name);
1913         req->bus_name = malloc(req->_present.bus_name_len + 1);
1914         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1915         req->bus_name[req->_present.bus_name_len] = 0;
1916 }
1917 static inline void
1918 devlink_eswitch_set_req_set_dev_name(struct devlink_eswitch_set_req *req,
1919                                      const char *dev_name)
1920 {
1921         free(req->dev_name);
1922         req->_present.dev_name_len = strlen(dev_name);
1923         req->dev_name = malloc(req->_present.dev_name_len + 1);
1924         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1925         req->dev_name[req->_present.dev_name_len] = 0;
1926 }
1927 static inline void
1928 devlink_eswitch_set_req_set_eswitch_mode(struct devlink_eswitch_set_req *req,
1929                                          enum devlink_eswitch_mode eswitch_mode)
1930 {
1931         req->_present.eswitch_mode = 1;
1932         req->eswitch_mode = eswitch_mode;
1933 }
1934 static inline void
1935 devlink_eswitch_set_req_set_eswitch_inline_mode(struct devlink_eswitch_set_req *req,
1936                                                 enum devlink_eswitch_inline_mode eswitch_inline_mode)
1937 {
1938         req->_present.eswitch_inline_mode = 1;
1939         req->eswitch_inline_mode = eswitch_inline_mode;
1940 }
1941 static inline void
1942 devlink_eswitch_set_req_set_eswitch_encap_mode(struct devlink_eswitch_set_req *req,
1943                                                enum devlink_eswitch_encap_mode eswitch_encap_mode)
1944 {
1945         req->_present.eswitch_encap_mode = 1;
1946         req->eswitch_encap_mode = eswitch_encap_mode;
1947 }
1948
1949 /*
1950  * Set eswitch attributes.
1951  */
1952 int devlink_eswitch_set(struct ynl_sock *ys,
1953                         struct devlink_eswitch_set_req *req);
1954
1955 /* ============== DEVLINK_CMD_DPIPE_TABLE_GET ============== */
1956 /* DEVLINK_CMD_DPIPE_TABLE_GET - do */
1957 struct devlink_dpipe_table_get_req {
1958         struct {
1959                 __u32 bus_name_len;
1960                 __u32 dev_name_len;
1961                 __u32 dpipe_table_name_len;
1962         } _present;
1963
1964         char *bus_name;
1965         char *dev_name;
1966         char *dpipe_table_name;
1967 };
1968
1969 static inline struct devlink_dpipe_table_get_req *
1970 devlink_dpipe_table_get_req_alloc(void)
1971 {
1972         return calloc(1, sizeof(struct devlink_dpipe_table_get_req));
1973 }
1974 void devlink_dpipe_table_get_req_free(struct devlink_dpipe_table_get_req *req);
1975
1976 static inline void
1977 devlink_dpipe_table_get_req_set_bus_name(struct devlink_dpipe_table_get_req *req,
1978                                          const char *bus_name)
1979 {
1980         free(req->bus_name);
1981         req->_present.bus_name_len = strlen(bus_name);
1982         req->bus_name = malloc(req->_present.bus_name_len + 1);
1983         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1984         req->bus_name[req->_present.bus_name_len] = 0;
1985 }
1986 static inline void
1987 devlink_dpipe_table_get_req_set_dev_name(struct devlink_dpipe_table_get_req *req,
1988                                          const char *dev_name)
1989 {
1990         free(req->dev_name);
1991         req->_present.dev_name_len = strlen(dev_name);
1992         req->dev_name = malloc(req->_present.dev_name_len + 1);
1993         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1994         req->dev_name[req->_present.dev_name_len] = 0;
1995 }
1996 static inline void
1997 devlink_dpipe_table_get_req_set_dpipe_table_name(struct devlink_dpipe_table_get_req *req,
1998                                                  const char *dpipe_table_name)
1999 {
2000         free(req->dpipe_table_name);
2001         req->_present.dpipe_table_name_len = strlen(dpipe_table_name);
2002         req->dpipe_table_name = malloc(req->_present.dpipe_table_name_len + 1);
2003         memcpy(req->dpipe_table_name, dpipe_table_name, req->_present.dpipe_table_name_len);
2004         req->dpipe_table_name[req->_present.dpipe_table_name_len] = 0;
2005 }
2006
2007 struct devlink_dpipe_table_get_rsp {
2008         struct {
2009                 __u32 bus_name_len;
2010                 __u32 dev_name_len;
2011                 __u32 dpipe_tables:1;
2012         } _present;
2013
2014         char *bus_name;
2015         char *dev_name;
2016         struct devlink_dl_dpipe_tables dpipe_tables;
2017 };
2018
2019 void devlink_dpipe_table_get_rsp_free(struct devlink_dpipe_table_get_rsp *rsp);
2020
2021 /*
2022  * Get dpipe table attributes.
2023  */
2024 struct devlink_dpipe_table_get_rsp *
2025 devlink_dpipe_table_get(struct ynl_sock *ys,
2026                         struct devlink_dpipe_table_get_req *req);
2027
2028 /* ============== DEVLINK_CMD_DPIPE_ENTRIES_GET ============== */
2029 /* DEVLINK_CMD_DPIPE_ENTRIES_GET - do */
2030 struct devlink_dpipe_entries_get_req {
2031         struct {
2032                 __u32 bus_name_len;
2033                 __u32 dev_name_len;
2034                 __u32 dpipe_table_name_len;
2035         } _present;
2036
2037         char *bus_name;
2038         char *dev_name;
2039         char *dpipe_table_name;
2040 };
2041
2042 static inline struct devlink_dpipe_entries_get_req *
2043 devlink_dpipe_entries_get_req_alloc(void)
2044 {
2045         return calloc(1, sizeof(struct devlink_dpipe_entries_get_req));
2046 }
2047 void
2048 devlink_dpipe_entries_get_req_free(struct devlink_dpipe_entries_get_req *req);
2049
2050 static inline void
2051 devlink_dpipe_entries_get_req_set_bus_name(struct devlink_dpipe_entries_get_req *req,
2052                                            const char *bus_name)
2053 {
2054         free(req->bus_name);
2055         req->_present.bus_name_len = strlen(bus_name);
2056         req->bus_name = malloc(req->_present.bus_name_len + 1);
2057         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
2058         req->bus_name[req->_present.bus_name_len] = 0;
2059 }
2060 static inline void
2061 devlink_dpipe_entries_get_req_set_dev_name(struct devlink_dpipe_entries_get_req *req,
2062                                            const char *dev_name)
2063 {
2064         free(req->dev_name);
2065         req->_present.dev_name_len = strlen(dev_name);
2066         req->dev_name = malloc(req->_present.dev_name_len + 1);
2067         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
2068         req->dev_name[req->_present.dev_name_len] = 0;
2069 }
2070 static inline void
2071 devlink_dpipe_entries_get_req_set_dpipe_table_name(struct devlink_dpipe_entries_get_req *req,
2072                                                    const char *dpipe_table_name)
2073 {
2074         free(req->dpipe_table_name);
2075         req->_present.dpipe_table_name_len = strlen(dpipe_table_name);
2076         req->dpipe_table_name = malloc(req->_present.dpipe_table_name_len + 1);
2077         memcpy(req->dpipe_table_name, dpipe_table_name, req->_present.dpipe_table_name_len);
2078         req->dpipe_table_name[req->_present.dpipe_table_name_len] = 0;
2079 }
2080
2081 struct devlink_dpipe_entries_get_rsp {
2082         struct {
2083                 __u32 bus_name_len;
2084                 __u32 dev_name_len;
2085                 __u32 dpipe_entries:1;
2086         } _present;
2087
2088         char *bus_name;
2089         char *dev_name;
2090         struct devlink_dl_dpipe_entries dpipe_entries;
2091 };
2092
2093 void
2094 devlink_dpipe_entries_get_rsp_free(struct devlink_dpipe_entries_get_rsp *rsp);
2095
2096 /*
2097  * Get dpipe entries attributes.
2098  */
2099 struct devlink_dpipe_entries_get_rsp *
2100 devlink_dpipe_entries_get(struct ynl_sock *ys,
2101                           struct devlink_dpipe_entries_get_req *req);
2102
2103 /* ============== DEVLINK_CMD_DPIPE_HEADERS_GET ============== */
2104 /* DEVLINK_CMD_DPIPE_HEADERS_GET - do */
2105 struct devlink_dpipe_headers_get_req {
2106         struct {
2107                 __u32 bus_name_len;
2108                 __u32 dev_name_len;
2109         } _present;
2110
2111         char *bus_name;
2112         char *dev_name;
2113 };
2114
2115 static inline struct devlink_dpipe_headers_get_req *
2116 devlink_dpipe_headers_get_req_alloc(void)
2117 {
2118         return calloc(1, sizeof(struct devlink_dpipe_headers_get_req));
2119 }
2120 void
2121 devlink_dpipe_headers_get_req_free(struct devlink_dpipe_headers_get_req *req);
2122
2123 static inline void
2124 devlink_dpipe_headers_get_req_set_bus_name(struct devlink_dpipe_headers_get_req *req,
2125                                            const char *bus_name)
2126 {
2127         free(req->bus_name);
2128         req->_present.bus_name_len = strlen(bus_name);
2129         req->bus_name = malloc(req->_present.bus_name_len + 1);
2130         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
2131         req->bus_name[req->_present.bus_name_len] = 0;
2132 }
2133 static inline void
2134 devlink_dpipe_headers_get_req_set_dev_name(struct devlink_dpipe_headers_get_req *req,
2135                                            const char *dev_name)
2136 {
2137         free(req->dev_name);
2138         req->_present.dev_name_len = strlen(dev_name);
2139         req->dev_name = malloc(req->_present.dev_name_len + 1);
2140         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
2141         req->dev_name[req->_present.dev_name_len] = 0;
2142 }
2143
2144 struct devlink_dpipe_headers_get_rsp {
2145         struct {
2146                 __u32 bus_name_len;
2147                 __u32 dev_name_len;
2148                 __u32 dpipe_headers:1;
2149         } _present;
2150
2151         char *bus_name;
2152         char *dev_name;
2153         struct devlink_dl_dpipe_headers dpipe_headers;
2154 };
2155
2156 void
2157 devlink_dpipe_headers_get_rsp_free(struct devlink_dpipe_headers_get_rsp *rsp);
2158
2159 /*
2160  * Get dpipe headers attributes.
2161  */
2162 struct devlink_dpipe_headers_get_rsp *
2163 devlink_dpipe_headers_get(struct ynl_sock *ys,
2164                           struct devlink_dpipe_headers_get_req *req);
2165
2166 /* ============== DEVLINK_CMD_DPIPE_TABLE_COUNTERS_SET ============== */
2167 /* DEVLINK_CMD_DPIPE_TABLE_COUNTERS_SET - do */
2168 struct devlink_dpipe_table_counters_set_req {
2169         struct {
2170                 __u32 bus_name_len;
2171                 __u32 dev_name_len;
2172                 __u32 dpipe_table_name_len;
2173                 __u32 dpipe_table_counters_enabled:1;
2174         } _present;
2175
2176         char *bus_name;
2177         char *dev_name;
2178         char *dpipe_table_name;
2179         __u8 dpipe_table_counters_enabled;
2180 };
2181
2182 static inline struct devlink_dpipe_table_counters_set_req *
2183 devlink_dpipe_table_counters_set_req_alloc(void)
2184 {
2185         return calloc(1, sizeof(struct devlink_dpipe_table_counters_set_req));
2186 }
2187 void
2188 devlink_dpipe_table_counters_set_req_free(struct devlink_dpipe_table_counters_set_req *req);
2189
2190 static inline void
2191 devlink_dpipe_table_counters_set_req_set_bus_name(struct devlink_dpipe_table_counters_set_req *req,
2192                                                   const char *bus_name)
2193 {
2194         free(req->bus_name);
2195         req->_present.bus_name_len = strlen(bus_name);
2196         req->bus_name = malloc(req->_present.bus_name_len + 1);
2197         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
2198         req->bus_name[req->_present.bus_name_len] = 0;
2199 }
2200 static inline void
2201 devlink_dpipe_table_counters_set_req_set_dev_name(struct devlink_dpipe_table_counters_set_req *req,
2202                                                   const char *dev_name)
2203 {
2204         free(req->dev_name);
2205         req->_present.dev_name_len = strlen(dev_name);
2206         req->dev_name = malloc(req->_present.dev_name_len + 1);
2207         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
2208         req->dev_name[req->_present.dev_name_len] = 0;
2209 }
2210 static inline void
2211 devlink_dpipe_table_counters_set_req_set_dpipe_table_name(struct devlink_dpipe_table_counters_set_req *req,
2212                                                           const char *dpipe_table_name)
2213 {
2214         free(req->dpipe_table_name);
2215         req->_present.dpipe_table_name_len = strlen(dpipe_table_name);
2216         req->dpipe_table_name = malloc(req->_present.dpipe_table_name_len + 1);
2217         memcpy(req->dpipe_table_name, dpipe_table_name, req->_present.dpipe_table_name_len);
2218         req->dpipe_table_name[req->_present.dpipe_table_name_len] = 0;
2219 }
2220 static inline void
2221 devlink_dpipe_table_counters_set_req_set_dpipe_table_counters_enabled(struct devlink_dpipe_table_counters_set_req *req,
2222                                                                       __u8 dpipe_table_counters_enabled)
2223 {
2224         req->_present.dpipe_table_counters_enabled = 1;
2225         req->dpipe_table_counters_enabled = dpipe_table_counters_enabled;
2226 }
2227
2228 /*
2229  * Set dpipe counter attributes.
2230  */
2231 int devlink_dpipe_table_counters_set(struct ynl_sock *ys,
2232                                      struct devlink_dpipe_table_counters_set_req *req);
2233
2234 /* ============== DEVLINK_CMD_RESOURCE_SET ============== */
2235 /* DEVLINK_CMD_RESOURCE_SET - do */
2236 struct devlink_resource_set_req {
2237         struct {
2238                 __u32 bus_name_len;
2239                 __u32 dev_name_len;
2240                 __u32 resource_id:1;
2241                 __u32 resource_size:1;
2242         } _present;
2243
2244         char *bus_name;
2245         char *dev_name;
2246         __u64 resource_id;
2247         __u64 resource_size;
2248 };
2249
2250 static inline struct devlink_resource_set_req *
2251 devlink_resource_set_req_alloc(void)
2252 {
2253         return calloc(1, sizeof(struct devlink_resource_set_req));
2254 }
2255 void devlink_resource_set_req_free(struct devlink_resource_set_req *req);
2256
2257 static inline void
2258 devlink_resource_set_req_set_bus_name(struct devlink_resource_set_req *req,
2259                                       const char *bus_name)
2260 {
2261         free(req->bus_name);
2262         req->_present.bus_name_len = strlen(bus_name);
2263         req->bus_name = malloc(req->_present.bus_name_len + 1);
2264         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
2265         req->bus_name[req->_present.bus_name_len] = 0;
2266 }
2267 static inline void
2268 devlink_resource_set_req_set_dev_name(struct devlink_resource_set_req *req,
2269                                       const char *dev_name)
2270 {
2271         free(req->dev_name);
2272         req->_present.dev_name_len = strlen(dev_name);
2273         req->dev_name = malloc(req->_present.dev_name_len + 1);
2274         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
2275         req->dev_name[req->_present.dev_name_len] = 0;
2276 }
2277 static inline void
2278 devlink_resource_set_req_set_resource_id(struct devlink_resource_set_req *req,
2279                                          __u64 resource_id)
2280 {
2281         req->_present.resource_id = 1;
2282         req->resource_id = resource_id;
2283 }
2284 static inline void
2285 devlink_resource_set_req_set_resource_size(struct devlink_resource_set_req *req,
2286                                            __u64 resource_size)
2287 {
2288         req->_present.resource_size = 1;
2289         req->resource_size = resource_size;
2290 }
2291
2292 /*
2293  * Set resource attributes.
2294  */
2295 int devlink_resource_set(struct ynl_sock *ys,
2296                          struct devlink_resource_set_req *req);
2297
2298 /* ============== DEVLINK_CMD_RESOURCE_DUMP ============== */
2299 /* DEVLINK_CMD_RESOURCE_DUMP - do */
2300 struct devlink_resource_dump_req {
2301         struct {
2302                 __u32 bus_name_len;
2303                 __u32 dev_name_len;
2304         } _present;
2305
2306         char *bus_name;
2307         char *dev_name;
2308 };
2309
2310 static inline struct devlink_resource_dump_req *
2311 devlink_resource_dump_req_alloc(void)
2312 {
2313         return calloc(1, sizeof(struct devlink_resource_dump_req));
2314 }
2315 void devlink_resource_dump_req_free(struct devlink_resource_dump_req *req);
2316
2317 static inline void
2318 devlink_resource_dump_req_set_bus_name(struct devlink_resource_dump_req *req,
2319                                        const char *bus_name)
2320 {
2321         free(req->bus_name);
2322         req->_present.bus_name_len = strlen(bus_name);
2323         req->bus_name = malloc(req->_present.bus_name_len + 1);
2324         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
2325         req->bus_name[req->_present.bus_name_len] = 0;
2326 }
2327 static inline void
2328 devlink_resource_dump_req_set_dev_name(struct devlink_resource_dump_req *req,
2329                                        const char *dev_name)
2330 {
2331         free(req->dev_name);
2332         req->_present.dev_name_len = strlen(dev_name);
2333         req->dev_name = malloc(req->_present.dev_name_len + 1);
2334         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
2335         req->dev_name[req->_present.dev_name_len] = 0;
2336 }
2337
2338 struct devlink_resource_dump_rsp {
2339         struct {
2340                 __u32 bus_name_len;
2341                 __u32 dev_name_len;
2342                 __u32 resource_list:1;
2343         } _present;
2344
2345         char *bus_name;
2346         char *dev_name;
2347         struct devlink_dl_resource_list resource_list;
2348 };
2349
2350 void devlink_resource_dump_rsp_free(struct devlink_resource_dump_rsp *rsp);
2351
2352 /*
2353  * Get resource attributes.
2354  */
2355 struct devlink_resource_dump_rsp *
2356 devlink_resource_dump(struct ynl_sock *ys,
2357                       struct devlink_resource_dump_req *req);
2358
2359 /* ============== DEVLINK_CMD_RELOAD ============== */
2360 /* DEVLINK_CMD_RELOAD - do */
2361 struct devlink_reload_req {
2362         struct {
2363                 __u32 bus_name_len;
2364                 __u32 dev_name_len;
2365                 __u32 reload_action:1;
2366                 __u32 reload_limits:1;
2367                 __u32 netns_pid:1;
2368                 __u32 netns_fd:1;
2369                 __u32 netns_id:1;
2370         } _present;
2371
2372         char *bus_name;
2373         char *dev_name;
2374         enum devlink_reload_action reload_action;
2375         struct nla_bitfield32 reload_limits;
2376         __u32 netns_pid;
2377         __u32 netns_fd;
2378         __u32 netns_id;
2379 };
2380
2381 static inline struct devlink_reload_req *devlink_reload_req_alloc(void)
2382 {
2383         return calloc(1, sizeof(struct devlink_reload_req));
2384 }
2385 void devlink_reload_req_free(struct devlink_reload_req *req);
2386
2387 static inline void
2388 devlink_reload_req_set_bus_name(struct devlink_reload_req *req,
2389                                 const char *bus_name)
2390 {
2391         free(req->bus_name);
2392         req->_present.bus_name_len = strlen(bus_name);
2393         req->bus_name = malloc(req->_present.bus_name_len + 1);
2394         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
2395         req->bus_name[req->_present.bus_name_len] = 0;
2396 }
2397 static inline void
2398 devlink_reload_req_set_dev_name(struct devlink_reload_req *req,
2399                                 const char *dev_name)
2400 {
2401         free(req->dev_name);
2402         req->_present.dev_name_len = strlen(dev_name);
2403         req->dev_name = malloc(req->_present.dev_name_len + 1);
2404         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
2405         req->dev_name[req->_present.dev_name_len] = 0;
2406 }
2407 static inline void
2408 devlink_reload_req_set_reload_action(struct devlink_reload_req *req,
2409                                      enum devlink_reload_action reload_action)
2410 {
2411         req->_present.reload_action = 1;
2412         req->reload_action = reload_action;
2413 }
2414 static inline void
2415 devlink_reload_req_set_reload_limits(struct devlink_reload_req *req,
2416                                      struct nla_bitfield32 *reload_limits)
2417 {
2418         req->_present.reload_limits = 1;
2419         memcpy(&req->reload_limits, reload_limits, sizeof(struct nla_bitfield32));
2420 }
2421 static inline void
2422 devlink_reload_req_set_netns_pid(struct devlink_reload_req *req,
2423                                  __u32 netns_pid)
2424 {
2425         req->_present.netns_pid = 1;
2426         req->netns_pid = netns_pid;
2427 }
2428 static inline void
2429 devlink_reload_req_set_netns_fd(struct devlink_reload_req *req, __u32 netns_fd)
2430 {
2431         req->_present.netns_fd = 1;
2432         req->netns_fd = netns_fd;
2433 }
2434 static inline void
2435 devlink_reload_req_set_netns_id(struct devlink_reload_req *req, __u32 netns_id)
2436 {
2437         req->_present.netns_id = 1;
2438         req->netns_id = netns_id;
2439 }
2440
2441 struct devlink_reload_rsp {
2442         struct {
2443                 __u32 bus_name_len;
2444                 __u32 dev_name_len;
2445                 __u32 reload_actions_performed:1;
2446         } _present;
2447
2448         char *bus_name;
2449         char *dev_name;
2450         struct nla_bitfield32 reload_actions_performed;
2451 };
2452
2453 void devlink_reload_rsp_free(struct devlink_reload_rsp *rsp);
2454
2455 /*
2456  * Reload devlink.
2457  */
2458 struct devlink_reload_rsp *
2459 devlink_reload(struct ynl_sock *ys, struct devlink_reload_req *req);
2460
2461 /* ============== DEVLINK_CMD_PARAM_GET ============== */
2462 /* DEVLINK_CMD_PARAM_GET - do */
2463 struct devlink_param_get_req {
2464         struct {
2465                 __u32 bus_name_len;
2466                 __u32 dev_name_len;
2467                 __u32 param_name_len;
2468         } _present;
2469
2470         char *bus_name;
2471         char *dev_name;
2472         char *param_name;
2473 };
2474
2475 static inline struct devlink_param_get_req *devlink_param_get_req_alloc(void)
2476 {
2477         return calloc(1, sizeof(struct devlink_param_get_req));
2478 }
2479 void devlink_param_get_req_free(struct devlink_param_get_req *req);
2480
2481 static inline void
2482 devlink_param_get_req_set_bus_name(struct devlink_param_get_req *req,
2483                                    const char *bus_name)
2484 {
2485         free(req->bus_name);
2486         req->_present.bus_name_len = strlen(bus_name);
2487         req->bus_name = malloc(req->_present.bus_name_len + 1);
2488         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
2489         req->bus_name[req->_present.bus_name_len] = 0;
2490 }
2491 static inline void
2492 devlink_param_get_req_set_dev_name(struct devlink_param_get_req *req,
2493                                    const char *dev_name)
2494 {
2495         free(req->dev_name);
2496         req->_present.dev_name_len = strlen(dev_name);
2497         req->dev_name = malloc(req->_present.dev_name_len + 1);
2498         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
2499         req->dev_name[req->_present.dev_name_len] = 0;
2500 }
2501 static inline void
2502 devlink_param_get_req_set_param_name(struct devlink_param_get_req *req,
2503                                      const char *param_name)
2504 {
2505         free(req->param_name);
2506         req->_present.param_name_len = strlen(param_name);
2507         req->param_name = malloc(req->_present.param_name_len + 1);
2508         memcpy(req->param_name, param_name, req->_present.param_name_len);
2509         req->param_name[req->_present.param_name_len] = 0;
2510 }
2511
2512 struct devlink_param_get_rsp {
2513         struct {
2514                 __u32 bus_name_len;
2515                 __u32 dev_name_len;
2516                 __u32 param_name_len;
2517         } _present;
2518
2519         char *bus_name;
2520         char *dev_name;
2521         char *param_name;
2522 };
2523
2524 void devlink_param_get_rsp_free(struct devlink_param_get_rsp *rsp);
2525
2526 /*
2527  * Get param instances.
2528  */
2529 struct devlink_param_get_rsp *
2530 devlink_param_get(struct ynl_sock *ys, struct devlink_param_get_req *req);
2531
2532 /* DEVLINK_CMD_PARAM_GET - dump */
2533 struct devlink_param_get_req_dump {
2534         struct {
2535                 __u32 bus_name_len;
2536                 __u32 dev_name_len;
2537         } _present;
2538
2539         char *bus_name;
2540         char *dev_name;
2541 };
2542
2543 static inline struct devlink_param_get_req_dump *
2544 devlink_param_get_req_dump_alloc(void)
2545 {
2546         return calloc(1, sizeof(struct devlink_param_get_req_dump));
2547 }
2548 void devlink_param_get_req_dump_free(struct devlink_param_get_req_dump *req);
2549
2550 static inline void
2551 devlink_param_get_req_dump_set_bus_name(struct devlink_param_get_req_dump *req,
2552                                         const char *bus_name)
2553 {
2554         free(req->bus_name);
2555         req->_present.bus_name_len = strlen(bus_name);
2556         req->bus_name = malloc(req->_present.bus_name_len + 1);
2557         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
2558         req->bus_name[req->_present.bus_name_len] = 0;
2559 }
2560 static inline void
2561 devlink_param_get_req_dump_set_dev_name(struct devlink_param_get_req_dump *req,
2562                                         const char *dev_name)
2563 {
2564         free(req->dev_name);
2565         req->_present.dev_name_len = strlen(dev_name);
2566         req->dev_name = malloc(req->_present.dev_name_len + 1);
2567         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
2568         req->dev_name[req->_present.dev_name_len] = 0;
2569 }
2570
2571 struct devlink_param_get_list {
2572         struct devlink_param_get_list *next;
2573         struct devlink_param_get_rsp obj __attribute__ ((aligned (8)));
2574 };
2575
2576 void devlink_param_get_list_free(struct devlink_param_get_list *rsp);
2577
2578 struct devlink_param_get_list *
2579 devlink_param_get_dump(struct ynl_sock *ys,
2580                        struct devlink_param_get_req_dump *req);
2581
2582 /* ============== DEVLINK_CMD_PARAM_SET ============== */
2583 /* DEVLINK_CMD_PARAM_SET - do */
2584 struct devlink_param_set_req {
2585         struct {
2586                 __u32 bus_name_len;
2587                 __u32 dev_name_len;
2588                 __u32 param_name_len;
2589                 __u32 param_type:1;
2590                 __u32 param_value_cmode:1;
2591         } _present;
2592
2593         char *bus_name;
2594         char *dev_name;
2595         char *param_name;
2596         __u8 param_type;
2597         enum devlink_param_cmode param_value_cmode;
2598 };
2599
2600 static inline struct devlink_param_set_req *devlink_param_set_req_alloc(void)
2601 {
2602         return calloc(1, sizeof(struct devlink_param_set_req));
2603 }
2604 void devlink_param_set_req_free(struct devlink_param_set_req *req);
2605
2606 static inline void
2607 devlink_param_set_req_set_bus_name(struct devlink_param_set_req *req,
2608                                    const char *bus_name)
2609 {
2610         free(req->bus_name);
2611         req->_present.bus_name_len = strlen(bus_name);
2612         req->bus_name = malloc(req->_present.bus_name_len + 1);
2613         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
2614         req->bus_name[req->_present.bus_name_len] = 0;
2615 }
2616 static inline void
2617 devlink_param_set_req_set_dev_name(struct devlink_param_set_req *req,
2618                                    const char *dev_name)
2619 {
2620         free(req->dev_name);
2621         req->_present.dev_name_len = strlen(dev_name);
2622         req->dev_name = malloc(req->_present.dev_name_len + 1);
2623         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
2624         req->dev_name[req->_present.dev_name_len] = 0;
2625 }
2626 static inline void
2627 devlink_param_set_req_set_param_name(struct devlink_param_set_req *req,
2628                                      const char *param_name)
2629 {
2630         free(req->param_name);
2631         req->_present.param_name_len = strlen(param_name);
2632         req->param_name = malloc(req->_present.param_name_len + 1);
2633         memcpy(req->param_name, param_name, req->_present.param_name_len);
2634         req->param_name[req->_present.param_name_len] = 0;
2635 }
2636 static inline void
2637 devlink_param_set_req_set_param_type(struct devlink_param_set_req *req,
2638                                      __u8 param_type)
2639 {
2640         req->_present.param_type = 1;
2641         req->param_type = param_type;
2642 }
2643 static inline void
2644 devlink_param_set_req_set_param_value_cmode(struct devlink_param_set_req *req,
2645                                             enum devlink_param_cmode param_value_cmode)
2646 {
2647         req->_present.param_value_cmode = 1;
2648         req->param_value_cmode = param_value_cmode;
2649 }
2650
2651 /*
2652  * Set param instances.
2653  */
2654 int devlink_param_set(struct ynl_sock *ys, struct devlink_param_set_req *req);
2655
2656 /* ============== DEVLINK_CMD_REGION_GET ============== */
2657 /* DEVLINK_CMD_REGION_GET - do */
2658 struct devlink_region_get_req {
2659         struct {
2660                 __u32 bus_name_len;
2661                 __u32 dev_name_len;
2662                 __u32 port_index:1;
2663                 __u32 region_name_len;
2664         } _present;
2665
2666         char *bus_name;
2667         char *dev_name;
2668         __u32 port_index;
2669         char *region_name;
2670 };
2671
2672 static inline struct devlink_region_get_req *devlink_region_get_req_alloc(void)
2673 {
2674         return calloc(1, sizeof(struct devlink_region_get_req));
2675 }
2676 void devlink_region_get_req_free(struct devlink_region_get_req *req);
2677
2678 static inline void
2679 devlink_region_get_req_set_bus_name(struct devlink_region_get_req *req,
2680                                     const char *bus_name)
2681 {
2682         free(req->bus_name);
2683         req->_present.bus_name_len = strlen(bus_name);
2684         req->bus_name = malloc(req->_present.bus_name_len + 1);
2685         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
2686         req->bus_name[req->_present.bus_name_len] = 0;
2687 }
2688 static inline void
2689 devlink_region_get_req_set_dev_name(struct devlink_region_get_req *req,
2690                                     const char *dev_name)
2691 {
2692         free(req->dev_name);
2693         req->_present.dev_name_len = strlen(dev_name);
2694         req->dev_name = malloc(req->_present.dev_name_len + 1);
2695         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
2696         req->dev_name[req->_present.dev_name_len] = 0;
2697 }
2698 static inline void
2699 devlink_region_get_req_set_port_index(struct devlink_region_get_req *req,
2700                                       __u32 port_index)
2701 {
2702         req->_present.port_index = 1;
2703         req->port_index = port_index;
2704 }
2705 static inline void
2706 devlink_region_get_req_set_region_name(struct devlink_region_get_req *req,
2707                                        const char *region_name)
2708 {
2709         free(req->region_name);
2710         req->_present.region_name_len = strlen(region_name);
2711         req->region_name = malloc(req->_present.region_name_len + 1);
2712         memcpy(req->region_name, region_name, req->_present.region_name_len);
2713         req->region_name[req->_present.region_name_len] = 0;
2714 }
2715
2716 struct devlink_region_get_rsp {
2717         struct {
2718                 __u32 bus_name_len;
2719                 __u32 dev_name_len;
2720                 __u32 port_index:1;
2721                 __u32 region_name_len;
2722         } _present;
2723
2724         char *bus_name;
2725         char *dev_name;
2726         __u32 port_index;
2727         char *region_name;
2728 };
2729
2730 void devlink_region_get_rsp_free(struct devlink_region_get_rsp *rsp);
2731
2732 /*
2733  * Get region instances.
2734  */
2735 struct devlink_region_get_rsp *
2736 devlink_region_get(struct ynl_sock *ys, struct devlink_region_get_req *req);
2737
2738 /* DEVLINK_CMD_REGION_GET - dump */
2739 struct devlink_region_get_req_dump {
2740         struct {
2741                 __u32 bus_name_len;
2742                 __u32 dev_name_len;
2743         } _present;
2744
2745         char *bus_name;
2746         char *dev_name;
2747 };
2748
2749 static inline struct devlink_region_get_req_dump *
2750 devlink_region_get_req_dump_alloc(void)
2751 {
2752         return calloc(1, sizeof(struct devlink_region_get_req_dump));
2753 }
2754 void devlink_region_get_req_dump_free(struct devlink_region_get_req_dump *req);
2755
2756 static inline void
2757 devlink_region_get_req_dump_set_bus_name(struct devlink_region_get_req_dump *req,
2758                                          const char *bus_name)
2759 {
2760         free(req->bus_name);
2761         req->_present.bus_name_len = strlen(bus_name);
2762         req->bus_name = malloc(req->_present.bus_name_len + 1);
2763         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
2764         req->bus_name[req->_present.bus_name_len] = 0;
2765 }
2766 static inline void
2767 devlink_region_get_req_dump_set_dev_name(struct devlink_region_get_req_dump *req,
2768                                          const char *dev_name)
2769 {
2770         free(req->dev_name);
2771         req->_present.dev_name_len = strlen(dev_name);
2772         req->dev_name = malloc(req->_present.dev_name_len + 1);
2773         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
2774         req->dev_name[req->_present.dev_name_len] = 0;
2775 }
2776
2777 struct devlink_region_get_list {
2778         struct devlink_region_get_list *next;
2779         struct devlink_region_get_rsp obj __attribute__ ((aligned (8)));
2780 };
2781
2782 void devlink_region_get_list_free(struct devlink_region_get_list *rsp);
2783
2784 struct devlink_region_get_list *
2785 devlink_region_get_dump(struct ynl_sock *ys,
2786                         struct devlink_region_get_req_dump *req);
2787
2788 /* ============== DEVLINK_CMD_REGION_NEW ============== */
2789 /* DEVLINK_CMD_REGION_NEW - do */
2790 struct devlink_region_new_req {
2791         struct {
2792                 __u32 bus_name_len;
2793                 __u32 dev_name_len;
2794                 __u32 port_index:1;
2795                 __u32 region_name_len;
2796                 __u32 region_snapshot_id:1;
2797         } _present;
2798
2799         char *bus_name;
2800         char *dev_name;
2801         __u32 port_index;
2802         char *region_name;
2803         __u32 region_snapshot_id;
2804 };
2805
2806 static inline struct devlink_region_new_req *devlink_region_new_req_alloc(void)
2807 {
2808         return calloc(1, sizeof(struct devlink_region_new_req));
2809 }
2810 void devlink_region_new_req_free(struct devlink_region_new_req *req);
2811
2812 static inline void
2813 devlink_region_new_req_set_bus_name(struct devlink_region_new_req *req,
2814                                     const char *bus_name)
2815 {
2816         free(req->bus_name);
2817         req->_present.bus_name_len = strlen(bus_name);
2818         req->bus_name = malloc(req->_present.bus_name_len + 1);
2819         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
2820         req->bus_name[req->_present.bus_name_len] = 0;
2821 }
2822 static inline void
2823 devlink_region_new_req_set_dev_name(struct devlink_region_new_req *req,
2824                                     const char *dev_name)
2825 {
2826         free(req->dev_name);
2827         req->_present.dev_name_len = strlen(dev_name);
2828         req->dev_name = malloc(req->_present.dev_name_len + 1);
2829         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
2830         req->dev_name[req->_present.dev_name_len] = 0;
2831 }
2832 static inline void
2833 devlink_region_new_req_set_port_index(struct devlink_region_new_req *req,
2834                                       __u32 port_index)
2835 {
2836         req->_present.port_index = 1;
2837         req->port_index = port_index;
2838 }
2839 static inline void
2840 devlink_region_new_req_set_region_name(struct devlink_region_new_req *req,
2841                                        const char *region_name)
2842 {
2843         free(req->region_name);
2844         req->_present.region_name_len = strlen(region_name);
2845         req->region_name = malloc(req->_present.region_name_len + 1);
2846         memcpy(req->region_name, region_name, req->_present.region_name_len);
2847         req->region_name[req->_present.region_name_len] = 0;
2848 }
2849 static inline void
2850 devlink_region_new_req_set_region_snapshot_id(struct devlink_region_new_req *req,
2851                                               __u32 region_snapshot_id)
2852 {
2853         req->_present.region_snapshot_id = 1;
2854         req->region_snapshot_id = region_snapshot_id;
2855 }
2856
2857 struct devlink_region_new_rsp {
2858         struct {
2859                 __u32 bus_name_len;
2860                 __u32 dev_name_len;
2861                 __u32 port_index:1;
2862                 __u32 region_name_len;
2863                 __u32 region_snapshot_id:1;
2864         } _present;
2865
2866         char *bus_name;
2867         char *dev_name;
2868         __u32 port_index;
2869         char *region_name;
2870         __u32 region_snapshot_id;
2871 };
2872
2873 void devlink_region_new_rsp_free(struct devlink_region_new_rsp *rsp);
2874
2875 /*
2876  * Create region snapshot.
2877  */
2878 struct devlink_region_new_rsp *
2879 devlink_region_new(struct ynl_sock *ys, struct devlink_region_new_req *req);
2880
2881 /* ============== DEVLINK_CMD_REGION_DEL ============== */
2882 /* DEVLINK_CMD_REGION_DEL - do */
2883 struct devlink_region_del_req {
2884         struct {
2885                 __u32 bus_name_len;
2886                 __u32 dev_name_len;
2887                 __u32 port_index:1;
2888                 __u32 region_name_len;
2889                 __u32 region_snapshot_id:1;
2890         } _present;
2891
2892         char *bus_name;
2893         char *dev_name;
2894         __u32 port_index;
2895         char *region_name;
2896         __u32 region_snapshot_id;
2897 };
2898
2899 static inline struct devlink_region_del_req *devlink_region_del_req_alloc(void)
2900 {
2901         return calloc(1, sizeof(struct devlink_region_del_req));
2902 }
2903 void devlink_region_del_req_free(struct devlink_region_del_req *req);
2904
2905 static inline void
2906 devlink_region_del_req_set_bus_name(struct devlink_region_del_req *req,
2907                                     const char *bus_name)
2908 {
2909         free(req->bus_name);
2910         req->_present.bus_name_len = strlen(bus_name);
2911         req->bus_name = malloc(req->_present.bus_name_len + 1);
2912         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
2913         req->bus_name[req->_present.bus_name_len] = 0;
2914 }
2915 static inline void
2916 devlink_region_del_req_set_dev_name(struct devlink_region_del_req *req,
2917                                     const char *dev_name)
2918 {
2919         free(req->dev_name);
2920         req->_present.dev_name_len = strlen(dev_name);
2921         req->dev_name = malloc(req->_present.dev_name_len + 1);
2922         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
2923         req->dev_name[req->_present.dev_name_len] = 0;
2924 }
2925 static inline void
2926 devlink_region_del_req_set_port_index(struct devlink_region_del_req *req,
2927                                       __u32 port_index)
2928 {
2929         req->_present.port_index = 1;
2930         req->port_index = port_index;
2931 }
2932 static inline void
2933 devlink_region_del_req_set_region_name(struct devlink_region_del_req *req,
2934                                        const char *region_name)
2935 {
2936         free(req->region_name);
2937         req->_present.region_name_len = strlen(region_name);
2938         req->region_name = malloc(req->_present.region_name_len + 1);
2939         memcpy(req->region_name, region_name, req->_present.region_name_len);
2940         req->region_name[req->_present.region_name_len] = 0;
2941 }
2942 static inline void
2943 devlink_region_del_req_set_region_snapshot_id(struct devlink_region_del_req *req,
2944                                               __u32 region_snapshot_id)
2945 {
2946         req->_present.region_snapshot_id = 1;
2947         req->region_snapshot_id = region_snapshot_id;
2948 }
2949
2950 /*
2951  * Delete region snapshot.
2952  */
2953 int devlink_region_del(struct ynl_sock *ys, struct devlink_region_del_req *req);
2954
2955 /* ============== DEVLINK_CMD_REGION_READ ============== */
2956 /* DEVLINK_CMD_REGION_READ - dump */
2957 struct devlink_region_read_req_dump {
2958         struct {
2959                 __u32 bus_name_len;
2960                 __u32 dev_name_len;
2961                 __u32 port_index:1;
2962                 __u32 region_name_len;
2963                 __u32 region_snapshot_id:1;
2964                 __u32 region_direct:1;
2965                 __u32 region_chunk_addr:1;
2966                 __u32 region_chunk_len:1;
2967         } _present;
2968
2969         char *bus_name;
2970         char *dev_name;
2971         __u32 port_index;
2972         char *region_name;
2973         __u32 region_snapshot_id;
2974         __u64 region_chunk_addr;
2975         __u64 region_chunk_len;
2976 };
2977
2978 static inline struct devlink_region_read_req_dump *
2979 devlink_region_read_req_dump_alloc(void)
2980 {
2981         return calloc(1, sizeof(struct devlink_region_read_req_dump));
2982 }
2983 void
2984 devlink_region_read_req_dump_free(struct devlink_region_read_req_dump *req);
2985
2986 static inline void
2987 devlink_region_read_req_dump_set_bus_name(struct devlink_region_read_req_dump *req,
2988                                           const char *bus_name)
2989 {
2990         free(req->bus_name);
2991         req->_present.bus_name_len = strlen(bus_name);
2992         req->bus_name = malloc(req->_present.bus_name_len + 1);
2993         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
2994         req->bus_name[req->_present.bus_name_len] = 0;
2995 }
2996 static inline void
2997 devlink_region_read_req_dump_set_dev_name(struct devlink_region_read_req_dump *req,
2998                                           const char *dev_name)
2999 {
3000         free(req->dev_name);
3001         req->_present.dev_name_len = strlen(dev_name);
3002         req->dev_name = malloc(req->_present.dev_name_len + 1);
3003         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
3004         req->dev_name[req->_present.dev_name_len] = 0;
3005 }
3006 static inline void
3007 devlink_region_read_req_dump_set_port_index(struct devlink_region_read_req_dump *req,
3008                                             __u32 port_index)
3009 {
3010         req->_present.port_index = 1;
3011         req->port_index = port_index;
3012 }
3013 static inline void
3014 devlink_region_read_req_dump_set_region_name(struct devlink_region_read_req_dump *req,
3015                                              const char *region_name)
3016 {
3017         free(req->region_name);
3018         req->_present.region_name_len = strlen(region_name);
3019         req->region_name = malloc(req->_present.region_name_len + 1);
3020         memcpy(req->region_name, region_name, req->_present.region_name_len);
3021         req->region_name[req->_present.region_name_len] = 0;
3022 }
3023 static inline void
3024 devlink_region_read_req_dump_set_region_snapshot_id(struct devlink_region_read_req_dump *req,
3025                                                     __u32 region_snapshot_id)
3026 {
3027         req->_present.region_snapshot_id = 1;
3028         req->region_snapshot_id = region_snapshot_id;
3029 }
3030 static inline void
3031 devlink_region_read_req_dump_set_region_direct(struct devlink_region_read_req_dump *req)
3032 {
3033         req->_present.region_direct = 1;
3034 }
3035 static inline void
3036 devlink_region_read_req_dump_set_region_chunk_addr(struct devlink_region_read_req_dump *req,
3037                                                    __u64 region_chunk_addr)
3038 {
3039         req->_present.region_chunk_addr = 1;
3040         req->region_chunk_addr = region_chunk_addr;
3041 }
3042 static inline void
3043 devlink_region_read_req_dump_set_region_chunk_len(struct devlink_region_read_req_dump *req,
3044                                                   __u64 region_chunk_len)
3045 {
3046         req->_present.region_chunk_len = 1;
3047         req->region_chunk_len = region_chunk_len;
3048 }
3049
3050 struct devlink_region_read_rsp_dump {
3051         struct {
3052                 __u32 bus_name_len;
3053                 __u32 dev_name_len;
3054                 __u32 port_index:1;
3055                 __u32 region_name_len;
3056         } _present;
3057
3058         char *bus_name;
3059         char *dev_name;
3060         __u32 port_index;
3061         char *region_name;
3062 };
3063
3064 struct devlink_region_read_rsp_list {
3065         struct devlink_region_read_rsp_list *next;
3066         struct devlink_region_read_rsp_dump obj __attribute__((aligned(8)));
3067 };
3068
3069 void
3070 devlink_region_read_rsp_list_free(struct devlink_region_read_rsp_list *rsp);
3071
3072 struct devlink_region_read_rsp_list *
3073 devlink_region_read_dump(struct ynl_sock *ys,
3074                          struct devlink_region_read_req_dump *req);
3075
3076 /* ============== DEVLINK_CMD_PORT_PARAM_GET ============== */
3077 /* DEVLINK_CMD_PORT_PARAM_GET - do */
3078 struct devlink_port_param_get_req {
3079         struct {
3080                 __u32 bus_name_len;
3081                 __u32 dev_name_len;
3082                 __u32 port_index:1;
3083         } _present;
3084
3085         char *bus_name;
3086         char *dev_name;
3087         __u32 port_index;
3088 };
3089
3090 static inline struct devlink_port_param_get_req *
3091 devlink_port_param_get_req_alloc(void)
3092 {
3093         return calloc(1, sizeof(struct devlink_port_param_get_req));
3094 }
3095 void devlink_port_param_get_req_free(struct devlink_port_param_get_req *req);
3096
3097 static inline void
3098 devlink_port_param_get_req_set_bus_name(struct devlink_port_param_get_req *req,
3099                                         const char *bus_name)
3100 {
3101         free(req->bus_name);
3102         req->_present.bus_name_len = strlen(bus_name);
3103         req->bus_name = malloc(req->_present.bus_name_len + 1);
3104         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
3105         req->bus_name[req->_present.bus_name_len] = 0;
3106 }
3107 static inline void
3108 devlink_port_param_get_req_set_dev_name(struct devlink_port_param_get_req *req,
3109                                         const char *dev_name)
3110 {
3111         free(req->dev_name);
3112         req->_present.dev_name_len = strlen(dev_name);
3113         req->dev_name = malloc(req->_present.dev_name_len + 1);
3114         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
3115         req->dev_name[req->_present.dev_name_len] = 0;
3116 }
3117 static inline void
3118 devlink_port_param_get_req_set_port_index(struct devlink_port_param_get_req *req,
3119                                           __u32 port_index)
3120 {
3121         req->_present.port_index = 1;
3122         req->port_index = port_index;
3123 }
3124
3125 struct devlink_port_param_get_rsp {
3126         struct {
3127                 __u32 bus_name_len;
3128                 __u32 dev_name_len;
3129                 __u32 port_index:1;
3130         } _present;
3131
3132         char *bus_name;
3133         char *dev_name;
3134         __u32 port_index;
3135 };
3136
3137 void devlink_port_param_get_rsp_free(struct devlink_port_param_get_rsp *rsp);
3138
3139 /*
3140  * Get port param instances.
3141  */
3142 struct devlink_port_param_get_rsp *
3143 devlink_port_param_get(struct ynl_sock *ys,
3144                        struct devlink_port_param_get_req *req);
3145
3146 /* DEVLINK_CMD_PORT_PARAM_GET - dump */
3147 struct devlink_port_param_get_list {
3148         struct devlink_port_param_get_list *next;
3149         struct devlink_port_param_get_rsp obj __attribute__((aligned(8)));
3150 };
3151
3152 void devlink_port_param_get_list_free(struct devlink_port_param_get_list *rsp);
3153
3154 struct devlink_port_param_get_list *
3155 devlink_port_param_get_dump(struct ynl_sock *ys);
3156
3157 /* ============== DEVLINK_CMD_PORT_PARAM_SET ============== */
3158 /* DEVLINK_CMD_PORT_PARAM_SET - do */
3159 struct devlink_port_param_set_req {
3160         struct {
3161                 __u32 bus_name_len;
3162                 __u32 dev_name_len;
3163                 __u32 port_index:1;
3164         } _present;
3165
3166         char *bus_name;
3167         char *dev_name;
3168         __u32 port_index;
3169 };
3170
3171 static inline struct devlink_port_param_set_req *
3172 devlink_port_param_set_req_alloc(void)
3173 {
3174         return calloc(1, sizeof(struct devlink_port_param_set_req));
3175 }
3176 void devlink_port_param_set_req_free(struct devlink_port_param_set_req *req);
3177
3178 static inline void
3179 devlink_port_param_set_req_set_bus_name(struct devlink_port_param_set_req *req,
3180                                         const char *bus_name)
3181 {
3182         free(req->bus_name);
3183         req->_present.bus_name_len = strlen(bus_name);
3184         req->bus_name = malloc(req->_present.bus_name_len + 1);
3185         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
3186         req->bus_name[req->_present.bus_name_len] = 0;
3187 }
3188 static inline void
3189 devlink_port_param_set_req_set_dev_name(struct devlink_port_param_set_req *req,
3190                                         const char *dev_name)
3191 {
3192         free(req->dev_name);
3193         req->_present.dev_name_len = strlen(dev_name);
3194         req->dev_name = malloc(req->_present.dev_name_len + 1);
3195         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
3196         req->dev_name[req->_present.dev_name_len] = 0;
3197 }
3198 static inline void
3199 devlink_port_param_set_req_set_port_index(struct devlink_port_param_set_req *req,
3200                                           __u32 port_index)
3201 {
3202         req->_present.port_index = 1;
3203         req->port_index = port_index;
3204 }
3205
3206 /*
3207  * Set port param instances.
3208  */
3209 int devlink_port_param_set(struct ynl_sock *ys,
3210                            struct devlink_port_param_set_req *req);
3211
3212 /* ============== DEVLINK_CMD_INFO_GET ============== */
3213 /* DEVLINK_CMD_INFO_GET - do */
3214 struct devlink_info_get_req {
3215         struct {
3216                 __u32 bus_name_len;
3217                 __u32 dev_name_len;
3218         } _present;
3219
3220         char *bus_name;
3221         char *dev_name;
3222 };
3223
3224 static inline struct devlink_info_get_req *devlink_info_get_req_alloc(void)
3225 {
3226         return calloc(1, sizeof(struct devlink_info_get_req));
3227 }
3228 void devlink_info_get_req_free(struct devlink_info_get_req *req);
3229
3230 static inline void
3231 devlink_info_get_req_set_bus_name(struct devlink_info_get_req *req,
3232                                   const char *bus_name)
3233 {
3234         free(req->bus_name);
3235         req->_present.bus_name_len = strlen(bus_name);
3236         req->bus_name = malloc(req->_present.bus_name_len + 1);
3237         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
3238         req->bus_name[req->_present.bus_name_len] = 0;
3239 }
3240 static inline void
3241 devlink_info_get_req_set_dev_name(struct devlink_info_get_req *req,
3242                                   const char *dev_name)
3243 {
3244         free(req->dev_name);
3245         req->_present.dev_name_len = strlen(dev_name);
3246         req->dev_name = malloc(req->_present.dev_name_len + 1);
3247         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
3248         req->dev_name[req->_present.dev_name_len] = 0;
3249 }
3250
3251 struct devlink_info_get_rsp {
3252         struct {
3253                 __u32 bus_name_len;
3254                 __u32 dev_name_len;
3255                 __u32 info_driver_name_len;
3256                 __u32 info_serial_number_len;
3257         } _present;
3258
3259         char *bus_name;
3260         char *dev_name;
3261         char *info_driver_name;
3262         char *info_serial_number;
3263         unsigned int n_info_version_fixed;
3264         struct devlink_dl_info_version *info_version_fixed;
3265         unsigned int n_info_version_running;
3266         struct devlink_dl_info_version *info_version_running;
3267         unsigned int n_info_version_stored;
3268         struct devlink_dl_info_version *info_version_stored;
3269 };
3270
3271 void devlink_info_get_rsp_free(struct devlink_info_get_rsp *rsp);
3272
3273 /*
3274  * Get device information, like driver name, hardware and firmware versions etc.
3275  */
3276 struct devlink_info_get_rsp *
3277 devlink_info_get(struct ynl_sock *ys, struct devlink_info_get_req *req);
3278
3279 /* DEVLINK_CMD_INFO_GET - dump */
3280 struct devlink_info_get_list {
3281         struct devlink_info_get_list *next;
3282         struct devlink_info_get_rsp obj __attribute__ ((aligned (8)));
3283 };
3284
3285 void devlink_info_get_list_free(struct devlink_info_get_list *rsp);
3286
3287 struct devlink_info_get_list *devlink_info_get_dump(struct ynl_sock *ys);
3288
3289 /* ============== DEVLINK_CMD_HEALTH_REPORTER_GET ============== */
3290 /* DEVLINK_CMD_HEALTH_REPORTER_GET - do */
3291 struct devlink_health_reporter_get_req {
3292         struct {
3293                 __u32 bus_name_len;
3294                 __u32 dev_name_len;
3295                 __u32 port_index:1;
3296                 __u32 health_reporter_name_len;
3297         } _present;
3298
3299         char *bus_name;
3300         char *dev_name;
3301         __u32 port_index;
3302         char *health_reporter_name;
3303 };
3304
3305 static inline struct devlink_health_reporter_get_req *
3306 devlink_health_reporter_get_req_alloc(void)
3307 {
3308         return calloc(1, sizeof(struct devlink_health_reporter_get_req));
3309 }
3310 void
3311 devlink_health_reporter_get_req_free(struct devlink_health_reporter_get_req *req);
3312
3313 static inline void
3314 devlink_health_reporter_get_req_set_bus_name(struct devlink_health_reporter_get_req *req,
3315                                              const char *bus_name)
3316 {
3317         free(req->bus_name);
3318         req->_present.bus_name_len = strlen(bus_name);
3319         req->bus_name = malloc(req->_present.bus_name_len + 1);
3320         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
3321         req->bus_name[req->_present.bus_name_len] = 0;
3322 }
3323 static inline void
3324 devlink_health_reporter_get_req_set_dev_name(struct devlink_health_reporter_get_req *req,
3325                                              const char *dev_name)
3326 {
3327         free(req->dev_name);
3328         req->_present.dev_name_len = strlen(dev_name);
3329         req->dev_name = malloc(req->_present.dev_name_len + 1);
3330         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
3331         req->dev_name[req->_present.dev_name_len] = 0;
3332 }
3333 static inline void
3334 devlink_health_reporter_get_req_set_port_index(struct devlink_health_reporter_get_req *req,
3335                                                __u32 port_index)
3336 {
3337         req->_present.port_index = 1;
3338         req->port_index = port_index;
3339 }
3340 static inline void
3341 devlink_health_reporter_get_req_set_health_reporter_name(struct devlink_health_reporter_get_req *req,
3342                                                          const char *health_reporter_name)
3343 {
3344         free(req->health_reporter_name);
3345         req->_present.health_reporter_name_len = strlen(health_reporter_name);
3346         req->health_reporter_name = malloc(req->_present.health_reporter_name_len + 1);
3347         memcpy(req->health_reporter_name, health_reporter_name, req->_present.health_reporter_name_len);
3348         req->health_reporter_name[req->_present.health_reporter_name_len] = 0;
3349 }
3350
3351 struct devlink_health_reporter_get_rsp {
3352         struct {
3353                 __u32 bus_name_len;
3354                 __u32 dev_name_len;
3355                 __u32 port_index:1;
3356                 __u32 health_reporter_name_len;
3357         } _present;
3358
3359         char *bus_name;
3360         char *dev_name;
3361         __u32 port_index;
3362         char *health_reporter_name;
3363 };
3364
3365 void
3366 devlink_health_reporter_get_rsp_free(struct devlink_health_reporter_get_rsp *rsp);
3367
3368 /*
3369  * Get health reporter instances.
3370  */
3371 struct devlink_health_reporter_get_rsp *
3372 devlink_health_reporter_get(struct ynl_sock *ys,
3373                             struct devlink_health_reporter_get_req *req);
3374
3375 /* DEVLINK_CMD_HEALTH_REPORTER_GET - dump */
3376 struct devlink_health_reporter_get_req_dump {
3377         struct {
3378                 __u32 bus_name_len;
3379                 __u32 dev_name_len;
3380                 __u32 port_index:1;
3381         } _present;
3382
3383         char *bus_name;
3384         char *dev_name;
3385         __u32 port_index;
3386 };
3387
3388 static inline struct devlink_health_reporter_get_req_dump *
3389 devlink_health_reporter_get_req_dump_alloc(void)
3390 {
3391         return calloc(1, sizeof(struct devlink_health_reporter_get_req_dump));
3392 }
3393 void
3394 devlink_health_reporter_get_req_dump_free(struct devlink_health_reporter_get_req_dump *req);
3395
3396 static inline void
3397 devlink_health_reporter_get_req_dump_set_bus_name(struct devlink_health_reporter_get_req_dump *req,
3398                                                   const char *bus_name)
3399 {
3400         free(req->bus_name);
3401         req->_present.bus_name_len = strlen(bus_name);
3402         req->bus_name = malloc(req->_present.bus_name_len + 1);
3403         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
3404         req->bus_name[req->_present.bus_name_len] = 0;
3405 }
3406 static inline void
3407 devlink_health_reporter_get_req_dump_set_dev_name(struct devlink_health_reporter_get_req_dump *req,
3408                                                   const char *dev_name)
3409 {
3410         free(req->dev_name);
3411         req->_present.dev_name_len = strlen(dev_name);
3412         req->dev_name = malloc(req->_present.dev_name_len + 1);
3413         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
3414         req->dev_name[req->_present.dev_name_len] = 0;
3415 }
3416 static inline void
3417 devlink_health_reporter_get_req_dump_set_port_index(struct devlink_health_reporter_get_req_dump *req,
3418                                                     __u32 port_index)
3419 {
3420         req->_present.port_index = 1;
3421         req->port_index = port_index;
3422 }
3423
3424 struct devlink_health_reporter_get_list {
3425         struct devlink_health_reporter_get_list *next;
3426         struct devlink_health_reporter_get_rsp obj __attribute__ ((aligned (8)));
3427 };
3428
3429 void
3430 devlink_health_reporter_get_list_free(struct devlink_health_reporter_get_list *rsp);
3431
3432 struct devlink_health_reporter_get_list *
3433 devlink_health_reporter_get_dump(struct ynl_sock *ys,
3434                                  struct devlink_health_reporter_get_req_dump *req);
3435
3436 /* ============== DEVLINK_CMD_HEALTH_REPORTER_SET ============== */
3437 /* DEVLINK_CMD_HEALTH_REPORTER_SET - do */
3438 struct devlink_health_reporter_set_req {
3439         struct {
3440                 __u32 bus_name_len;
3441                 __u32 dev_name_len;
3442                 __u32 port_index:1;
3443                 __u32 health_reporter_name_len;
3444                 __u32 health_reporter_graceful_period:1;
3445                 __u32 health_reporter_auto_recover:1;
3446                 __u32 health_reporter_auto_dump:1;
3447         } _present;
3448
3449         char *bus_name;
3450         char *dev_name;
3451         __u32 port_index;
3452         char *health_reporter_name;
3453         __u64 health_reporter_graceful_period;
3454         __u8 health_reporter_auto_recover;
3455         __u8 health_reporter_auto_dump;
3456 };
3457
3458 static inline struct devlink_health_reporter_set_req *
3459 devlink_health_reporter_set_req_alloc(void)
3460 {
3461         return calloc(1, sizeof(struct devlink_health_reporter_set_req));
3462 }
3463 void
3464 devlink_health_reporter_set_req_free(struct devlink_health_reporter_set_req *req);
3465
3466 static inline void
3467 devlink_health_reporter_set_req_set_bus_name(struct devlink_health_reporter_set_req *req,
3468                                              const char *bus_name)
3469 {
3470         free(req->bus_name);
3471         req->_present.bus_name_len = strlen(bus_name);
3472         req->bus_name = malloc(req->_present.bus_name_len + 1);
3473         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
3474         req->bus_name[req->_present.bus_name_len] = 0;
3475 }
3476 static inline void
3477 devlink_health_reporter_set_req_set_dev_name(struct devlink_health_reporter_set_req *req,
3478                                              const char *dev_name)
3479 {
3480         free(req->dev_name);
3481         req->_present.dev_name_len = strlen(dev_name);
3482         req->dev_name = malloc(req->_present.dev_name_len + 1);
3483         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
3484         req->dev_name[req->_present.dev_name_len] = 0;
3485 }
3486 static inline void
3487 devlink_health_reporter_set_req_set_port_index(struct devlink_health_reporter_set_req *req,
3488                                                __u32 port_index)
3489 {
3490         req->_present.port_index = 1;
3491         req->port_index = port_index;
3492 }
3493 static inline void
3494 devlink_health_reporter_set_req_set_health_reporter_name(struct devlink_health_reporter_set_req *req,
3495                                                          const char *health_reporter_name)
3496 {
3497         free(req->health_reporter_name);
3498         req->_present.health_reporter_name_len = strlen(health_reporter_name);
3499         req->health_reporter_name = malloc(req->_present.health_reporter_name_len + 1);
3500         memcpy(req->health_reporter_name, health_reporter_name, req->_present.health_reporter_name_len);
3501         req->health_reporter_name[req->_present.health_reporter_name_len] = 0;
3502 }
3503 static inline void
3504 devlink_health_reporter_set_req_set_health_reporter_graceful_period(struct devlink_health_reporter_set_req *req,
3505                                                                     __u64 health_reporter_graceful_period)
3506 {
3507         req->_present.health_reporter_graceful_period = 1;
3508         req->health_reporter_graceful_period = health_reporter_graceful_period;
3509 }
3510 static inline void
3511 devlink_health_reporter_set_req_set_health_reporter_auto_recover(struct devlink_health_reporter_set_req *req,
3512                                                                  __u8 health_reporter_auto_recover)
3513 {
3514         req->_present.health_reporter_auto_recover = 1;
3515         req->health_reporter_auto_recover = health_reporter_auto_recover;
3516 }
3517 static inline void
3518 devlink_health_reporter_set_req_set_health_reporter_auto_dump(struct devlink_health_reporter_set_req *req,
3519                                                               __u8 health_reporter_auto_dump)
3520 {
3521         req->_present.health_reporter_auto_dump = 1;
3522         req->health_reporter_auto_dump = health_reporter_auto_dump;
3523 }
3524
3525 /*
3526  * Set health reporter instances.
3527  */
3528 int devlink_health_reporter_set(struct ynl_sock *ys,
3529                                 struct devlink_health_reporter_set_req *req);
3530
3531 /* ============== DEVLINK_CMD_HEALTH_REPORTER_RECOVER ============== */
3532 /* DEVLINK_CMD_HEALTH_REPORTER_RECOVER - do */
3533 struct devlink_health_reporter_recover_req {
3534         struct {
3535                 __u32 bus_name_len;
3536                 __u32 dev_name_len;
3537                 __u32 port_index:1;
3538                 __u32 health_reporter_name_len;
3539         } _present;
3540
3541         char *bus_name;
3542         char *dev_name;
3543         __u32 port_index;
3544         char *health_reporter_name;
3545 };
3546
3547 static inline struct devlink_health_reporter_recover_req *
3548 devlink_health_reporter_recover_req_alloc(void)
3549 {
3550         return calloc(1, sizeof(struct devlink_health_reporter_recover_req));
3551 }
3552 void
3553 devlink_health_reporter_recover_req_free(struct devlink_health_reporter_recover_req *req);
3554
3555 static inline void
3556 devlink_health_reporter_recover_req_set_bus_name(struct devlink_health_reporter_recover_req *req,
3557                                                  const char *bus_name)
3558 {
3559         free(req->bus_name);
3560         req->_present.bus_name_len = strlen(bus_name);
3561         req->bus_name = malloc(req->_present.bus_name_len + 1);
3562         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
3563         req->bus_name[req->_present.bus_name_len] = 0;
3564 }
3565 static inline void
3566 devlink_health_reporter_recover_req_set_dev_name(struct devlink_health_reporter_recover_req *req,
3567                                                  const char *dev_name)
3568 {
3569         free(req->dev_name);
3570         req->_present.dev_name_len = strlen(dev_name);
3571         req->dev_name = malloc(req->_present.dev_name_len + 1);
3572         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
3573         req->dev_name[req->_present.dev_name_len] = 0;
3574 }
3575 static inline void
3576 devlink_health_reporter_recover_req_set_port_index(struct devlink_health_reporter_recover_req *req,
3577                                                    __u32 port_index)
3578 {
3579         req->_present.port_index = 1;
3580         req->port_index = port_index;
3581 }
3582 static inline void
3583 devlink_health_reporter_recover_req_set_health_reporter_name(struct devlink_health_reporter_recover_req *req,
3584                                                              const char *health_reporter_name)
3585 {
3586         free(req->health_reporter_name);
3587         req->_present.health_reporter_name_len = strlen(health_reporter_name);
3588         req->health_reporter_name = malloc(req->_present.health_reporter_name_len + 1);
3589         memcpy(req->health_reporter_name, health_reporter_name, req->_present.health_reporter_name_len);
3590         req->health_reporter_name[req->_present.health_reporter_name_len] = 0;
3591 }
3592
3593 /*
3594  * Recover health reporter instances.
3595  */
3596 int devlink_health_reporter_recover(struct ynl_sock *ys,
3597                                     struct devlink_health_reporter_recover_req *req);
3598
3599 /* ============== DEVLINK_CMD_HEALTH_REPORTER_DIAGNOSE ============== */
3600 /* DEVLINK_CMD_HEALTH_REPORTER_DIAGNOSE - do */
3601 struct devlink_health_reporter_diagnose_req {
3602         struct {
3603                 __u32 bus_name_len;
3604                 __u32 dev_name_len;
3605                 __u32 port_index:1;
3606                 __u32 health_reporter_name_len;
3607         } _present;
3608
3609         char *bus_name;
3610         char *dev_name;
3611         __u32 port_index;
3612         char *health_reporter_name;
3613 };
3614
3615 static inline struct devlink_health_reporter_diagnose_req *
3616 devlink_health_reporter_diagnose_req_alloc(void)
3617 {
3618         return calloc(1, sizeof(struct devlink_health_reporter_diagnose_req));
3619 }
3620 void
3621 devlink_health_reporter_diagnose_req_free(struct devlink_health_reporter_diagnose_req *req);
3622
3623 static inline void
3624 devlink_health_reporter_diagnose_req_set_bus_name(struct devlink_health_reporter_diagnose_req *req,
3625                                                   const char *bus_name)
3626 {
3627         free(req->bus_name);
3628         req->_present.bus_name_len = strlen(bus_name);
3629         req->bus_name = malloc(req->_present.bus_name_len + 1);
3630         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
3631         req->bus_name[req->_present.bus_name_len] = 0;
3632 }
3633 static inline void
3634 devlink_health_reporter_diagnose_req_set_dev_name(struct devlink_health_reporter_diagnose_req *req,
3635                                                   const char *dev_name)
3636 {
3637         free(req->dev_name);
3638         req->_present.dev_name_len = strlen(dev_name);
3639         req->dev_name = malloc(req->_present.dev_name_len + 1);
3640         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
3641         req->dev_name[req->_present.dev_name_len] = 0;
3642 }
3643 static inline void
3644 devlink_health_reporter_diagnose_req_set_port_index(struct devlink_health_reporter_diagnose_req *req,
3645                                                     __u32 port_index)
3646 {
3647         req->_present.port_index = 1;
3648         req->port_index = port_index;
3649 }
3650 static inline void
3651 devlink_health_reporter_diagnose_req_set_health_reporter_name(struct devlink_health_reporter_diagnose_req *req,
3652                                                               const char *health_reporter_name)
3653 {
3654         free(req->health_reporter_name);
3655         req->_present.health_reporter_name_len = strlen(health_reporter_name);
3656         req->health_reporter_name = malloc(req->_present.health_reporter_name_len + 1);
3657         memcpy(req->health_reporter_name, health_reporter_name, req->_present.health_reporter_name_len);
3658         req->health_reporter_name[req->_present.health_reporter_name_len] = 0;
3659 }
3660
3661 /*
3662  * Diagnose health reporter instances.
3663  */
3664 int devlink_health_reporter_diagnose(struct ynl_sock *ys,
3665                                      struct devlink_health_reporter_diagnose_req *req);
3666
3667 /* ============== DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET ============== */
3668 /* DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET - dump */
3669 struct devlink_health_reporter_dump_get_req_dump {
3670         struct {
3671                 __u32 bus_name_len;
3672                 __u32 dev_name_len;
3673                 __u32 port_index:1;
3674                 __u32 health_reporter_name_len;
3675         } _present;
3676
3677         char *bus_name;
3678         char *dev_name;
3679         __u32 port_index;
3680         char *health_reporter_name;
3681 };
3682
3683 static inline struct devlink_health_reporter_dump_get_req_dump *
3684 devlink_health_reporter_dump_get_req_dump_alloc(void)
3685 {
3686         return calloc(1, sizeof(struct devlink_health_reporter_dump_get_req_dump));
3687 }
3688 void
3689 devlink_health_reporter_dump_get_req_dump_free(struct devlink_health_reporter_dump_get_req_dump *req);
3690
3691 static inline void
3692 devlink_health_reporter_dump_get_req_dump_set_bus_name(struct devlink_health_reporter_dump_get_req_dump *req,
3693                                                        const char *bus_name)
3694 {
3695         free(req->bus_name);
3696         req->_present.bus_name_len = strlen(bus_name);
3697         req->bus_name = malloc(req->_present.bus_name_len + 1);
3698         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
3699         req->bus_name[req->_present.bus_name_len] = 0;
3700 }
3701 static inline void
3702 devlink_health_reporter_dump_get_req_dump_set_dev_name(struct devlink_health_reporter_dump_get_req_dump *req,
3703                                                        const char *dev_name)
3704 {
3705         free(req->dev_name);
3706         req->_present.dev_name_len = strlen(dev_name);
3707         req->dev_name = malloc(req->_present.dev_name_len + 1);
3708         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
3709         req->dev_name[req->_present.dev_name_len] = 0;
3710 }
3711 static inline void
3712 devlink_health_reporter_dump_get_req_dump_set_port_index(struct devlink_health_reporter_dump_get_req_dump *req,
3713                                                          __u32 port_index)
3714 {
3715         req->_present.port_index = 1;
3716         req->port_index = port_index;
3717 }
3718 static inline void
3719 devlink_health_reporter_dump_get_req_dump_set_health_reporter_name(struct devlink_health_reporter_dump_get_req_dump *req,
3720                                                                    const char *health_reporter_name)
3721 {
3722         free(req->health_reporter_name);
3723         req->_present.health_reporter_name_len = strlen(health_reporter_name);
3724         req->health_reporter_name = malloc(req->_present.health_reporter_name_len + 1);
3725         memcpy(req->health_reporter_name, health_reporter_name, req->_present.health_reporter_name_len);
3726         req->health_reporter_name[req->_present.health_reporter_name_len] = 0;
3727 }
3728
3729 struct devlink_health_reporter_dump_get_rsp_dump {
3730         struct {
3731                 __u32 fmsg:1;
3732         } _present;
3733
3734         struct devlink_dl_fmsg fmsg;
3735 };
3736
3737 struct devlink_health_reporter_dump_get_rsp_list {
3738         struct devlink_health_reporter_dump_get_rsp_list *next;
3739         struct devlink_health_reporter_dump_get_rsp_dump obj __attribute__((aligned(8)));
3740 };
3741
3742 void
3743 devlink_health_reporter_dump_get_rsp_list_free(struct devlink_health_reporter_dump_get_rsp_list *rsp);
3744
3745 struct devlink_health_reporter_dump_get_rsp_list *
3746 devlink_health_reporter_dump_get_dump(struct ynl_sock *ys,
3747                                       struct devlink_health_reporter_dump_get_req_dump *req);
3748
3749 /* ============== DEVLINK_CMD_HEALTH_REPORTER_DUMP_CLEAR ============== */
3750 /* DEVLINK_CMD_HEALTH_REPORTER_DUMP_CLEAR - do */
3751 struct devlink_health_reporter_dump_clear_req {
3752         struct {
3753                 __u32 bus_name_len;
3754                 __u32 dev_name_len;
3755                 __u32 port_index:1;
3756                 __u32 health_reporter_name_len;
3757         } _present;
3758
3759         char *bus_name;
3760         char *dev_name;
3761         __u32 port_index;
3762         char *health_reporter_name;
3763 };
3764
3765 static inline struct devlink_health_reporter_dump_clear_req *
3766 devlink_health_reporter_dump_clear_req_alloc(void)
3767 {
3768         return calloc(1, sizeof(struct devlink_health_reporter_dump_clear_req));
3769 }
3770 void
3771 devlink_health_reporter_dump_clear_req_free(struct devlink_health_reporter_dump_clear_req *req);
3772
3773 static inline void
3774 devlink_health_reporter_dump_clear_req_set_bus_name(struct devlink_health_reporter_dump_clear_req *req,
3775                                                     const char *bus_name)
3776 {
3777         free(req->bus_name);
3778         req->_present.bus_name_len = strlen(bus_name);
3779         req->bus_name = malloc(req->_present.bus_name_len + 1);
3780         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
3781         req->bus_name[req->_present.bus_name_len] = 0;
3782 }
3783 static inline void
3784 devlink_health_reporter_dump_clear_req_set_dev_name(struct devlink_health_reporter_dump_clear_req *req,
3785                                                     const char *dev_name)
3786 {
3787         free(req->dev_name);
3788         req->_present.dev_name_len = strlen(dev_name);
3789         req->dev_name = malloc(req->_present.dev_name_len + 1);
3790         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
3791         req->dev_name[req->_present.dev_name_len] = 0;
3792 }
3793 static inline void
3794 devlink_health_reporter_dump_clear_req_set_port_index(struct devlink_health_reporter_dump_clear_req *req,
3795                                                       __u32 port_index)
3796 {
3797         req->_present.port_index = 1;
3798         req->port_index = port_index;
3799 }
3800 static inline void
3801 devlink_health_reporter_dump_clear_req_set_health_reporter_name(struct devlink_health_reporter_dump_clear_req *req,
3802                                                                 const char *health_reporter_name)
3803 {
3804         free(req->health_reporter_name);
3805         req->_present.health_reporter_name_len = strlen(health_reporter_name);
3806         req->health_reporter_name = malloc(req->_present.health_reporter_name_len + 1);
3807         memcpy(req->health_reporter_name, health_reporter_name, req->_present.health_reporter_name_len);
3808         req->health_reporter_name[req->_present.health_reporter_name_len] = 0;
3809 }
3810
3811 /*
3812  * Clear dump of health reporter instances.
3813  */
3814 int devlink_health_reporter_dump_clear(struct ynl_sock *ys,
3815                                        struct devlink_health_reporter_dump_clear_req *req);
3816
3817 /* ============== DEVLINK_CMD_FLASH_UPDATE ============== */
3818 /* DEVLINK_CMD_FLASH_UPDATE - do */
3819 struct devlink_flash_update_req {
3820         struct {
3821                 __u32 bus_name_len;
3822                 __u32 dev_name_len;
3823                 __u32 flash_update_file_name_len;
3824                 __u32 flash_update_component_len;
3825                 __u32 flash_update_overwrite_mask:1;
3826         } _present;
3827
3828         char *bus_name;
3829         char *dev_name;
3830         char *flash_update_file_name;
3831         char *flash_update_component;
3832         struct nla_bitfield32 flash_update_overwrite_mask;
3833 };
3834
3835 static inline struct devlink_flash_update_req *
3836 devlink_flash_update_req_alloc(void)
3837 {
3838         return calloc(1, sizeof(struct devlink_flash_update_req));
3839 }
3840 void devlink_flash_update_req_free(struct devlink_flash_update_req *req);
3841
3842 static inline void
3843 devlink_flash_update_req_set_bus_name(struct devlink_flash_update_req *req,
3844                                       const char *bus_name)
3845 {
3846         free(req->bus_name);
3847         req->_present.bus_name_len = strlen(bus_name);
3848         req->bus_name = malloc(req->_present.bus_name_len + 1);
3849         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
3850         req->bus_name[req->_present.bus_name_len] = 0;
3851 }
3852 static inline void
3853 devlink_flash_update_req_set_dev_name(struct devlink_flash_update_req *req,
3854                                       const char *dev_name)
3855 {
3856         free(req->dev_name);
3857         req->_present.dev_name_len = strlen(dev_name);
3858         req->dev_name = malloc(req->_present.dev_name_len + 1);
3859         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
3860         req->dev_name[req->_present.dev_name_len] = 0;
3861 }
3862 static inline void
3863 devlink_flash_update_req_set_flash_update_file_name(struct devlink_flash_update_req *req,
3864                                                     const char *flash_update_file_name)
3865 {
3866         free(req->flash_update_file_name);
3867         req->_present.flash_update_file_name_len = strlen(flash_update_file_name);
3868         req->flash_update_file_name = malloc(req->_present.flash_update_file_name_len + 1);
3869         memcpy(req->flash_update_file_name, flash_update_file_name, req->_present.flash_update_file_name_len);
3870         req->flash_update_file_name[req->_present.flash_update_file_name_len] = 0;
3871 }
3872 static inline void
3873 devlink_flash_update_req_set_flash_update_component(struct devlink_flash_update_req *req,
3874                                                     const char *flash_update_component)
3875 {
3876         free(req->flash_update_component);
3877         req->_present.flash_update_component_len = strlen(flash_update_component);
3878         req->flash_update_component = malloc(req->_present.flash_update_component_len + 1);
3879         memcpy(req->flash_update_component, flash_update_component, req->_present.flash_update_component_len);
3880         req->flash_update_component[req->_present.flash_update_component_len] = 0;
3881 }
3882 static inline void
3883 devlink_flash_update_req_set_flash_update_overwrite_mask(struct devlink_flash_update_req *req,
3884                                                          struct nla_bitfield32 *flash_update_overwrite_mask)
3885 {
3886         req->_present.flash_update_overwrite_mask = 1;
3887         memcpy(&req->flash_update_overwrite_mask, flash_update_overwrite_mask, sizeof(struct nla_bitfield32));
3888 }
3889
3890 /*
3891  * Flash update devlink instances.
3892  */
3893 int devlink_flash_update(struct ynl_sock *ys,
3894                          struct devlink_flash_update_req *req);
3895
3896 /* ============== DEVLINK_CMD_TRAP_GET ============== */
3897 /* DEVLINK_CMD_TRAP_GET - do */
3898 struct devlink_trap_get_req {
3899         struct {
3900                 __u32 bus_name_len;
3901                 __u32 dev_name_len;
3902                 __u32 trap_name_len;
3903         } _present;
3904
3905         char *bus_name;
3906         char *dev_name;
3907         char *trap_name;
3908 };
3909
3910 static inline struct devlink_trap_get_req *devlink_trap_get_req_alloc(void)
3911 {
3912         return calloc(1, sizeof(struct devlink_trap_get_req));
3913 }
3914 void devlink_trap_get_req_free(struct devlink_trap_get_req *req);
3915
3916 static inline void
3917 devlink_trap_get_req_set_bus_name(struct devlink_trap_get_req *req,
3918                                   const char *bus_name)
3919 {
3920         free(req->bus_name);
3921         req->_present.bus_name_len = strlen(bus_name);
3922         req->bus_name = malloc(req->_present.bus_name_len + 1);
3923         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
3924         req->bus_name[req->_present.bus_name_len] = 0;
3925 }
3926 static inline void
3927 devlink_trap_get_req_set_dev_name(struct devlink_trap_get_req *req,
3928                                   const char *dev_name)
3929 {
3930         free(req->dev_name);
3931         req->_present.dev_name_len = strlen(dev_name);
3932         req->dev_name = malloc(req->_present.dev_name_len + 1);
3933         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
3934         req->dev_name[req->_present.dev_name_len] = 0;
3935 }
3936 static inline void
3937 devlink_trap_get_req_set_trap_name(struct devlink_trap_get_req *req,
3938                                    const char *trap_name)
3939 {
3940         free(req->trap_name);
3941         req->_present.trap_name_len = strlen(trap_name);
3942         req->trap_name = malloc(req->_present.trap_name_len + 1);
3943         memcpy(req->trap_name, trap_name, req->_present.trap_name_len);
3944         req->trap_name[req->_present.trap_name_len] = 0;
3945 }
3946
3947 struct devlink_trap_get_rsp {
3948         struct {
3949                 __u32 bus_name_len;
3950                 __u32 dev_name_len;
3951                 __u32 trap_name_len;
3952         } _present;
3953
3954         char *bus_name;
3955         char *dev_name;
3956         char *trap_name;
3957 };
3958
3959 void devlink_trap_get_rsp_free(struct devlink_trap_get_rsp *rsp);
3960
3961 /*
3962  * Get trap instances.
3963  */
3964 struct devlink_trap_get_rsp *
3965 devlink_trap_get(struct ynl_sock *ys, struct devlink_trap_get_req *req);
3966
3967 /* DEVLINK_CMD_TRAP_GET - dump */
3968 struct devlink_trap_get_req_dump {
3969         struct {
3970                 __u32 bus_name_len;
3971                 __u32 dev_name_len;
3972         } _present;
3973
3974         char *bus_name;
3975         char *dev_name;
3976 };
3977
3978 static inline struct devlink_trap_get_req_dump *
3979 devlink_trap_get_req_dump_alloc(void)
3980 {
3981         return calloc(1, sizeof(struct devlink_trap_get_req_dump));
3982 }
3983 void devlink_trap_get_req_dump_free(struct devlink_trap_get_req_dump *req);
3984
3985 static inline void
3986 devlink_trap_get_req_dump_set_bus_name(struct devlink_trap_get_req_dump *req,
3987                                        const char *bus_name)
3988 {
3989         free(req->bus_name);
3990         req->_present.bus_name_len = strlen(bus_name);
3991         req->bus_name = malloc(req->_present.bus_name_len + 1);
3992         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
3993         req->bus_name[req->_present.bus_name_len] = 0;
3994 }
3995 static inline void
3996 devlink_trap_get_req_dump_set_dev_name(struct devlink_trap_get_req_dump *req,
3997                                        const char *dev_name)
3998 {
3999         free(req->dev_name);
4000         req->_present.dev_name_len = strlen(dev_name);
4001         req->dev_name = malloc(req->_present.dev_name_len + 1);
4002         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
4003         req->dev_name[req->_present.dev_name_len] = 0;
4004 }
4005
4006 struct devlink_trap_get_list {
4007         struct devlink_trap_get_list *next;
4008         struct devlink_trap_get_rsp obj __attribute__ ((aligned (8)));
4009 };
4010
4011 void devlink_trap_get_list_free(struct devlink_trap_get_list *rsp);
4012
4013 struct devlink_trap_get_list *
4014 devlink_trap_get_dump(struct ynl_sock *ys,
4015                       struct devlink_trap_get_req_dump *req);
4016
4017 /* ============== DEVLINK_CMD_TRAP_SET ============== */
4018 /* DEVLINK_CMD_TRAP_SET - do */
4019 struct devlink_trap_set_req {
4020         struct {
4021                 __u32 bus_name_len;
4022                 __u32 dev_name_len;
4023                 __u32 trap_name_len;
4024                 __u32 trap_action:1;
4025         } _present;
4026
4027         char *bus_name;
4028         char *dev_name;
4029         char *trap_name;
4030         enum devlink_trap_action trap_action;
4031 };
4032
4033 static inline struct devlink_trap_set_req *devlink_trap_set_req_alloc(void)
4034 {
4035         return calloc(1, sizeof(struct devlink_trap_set_req));
4036 }
4037 void devlink_trap_set_req_free(struct devlink_trap_set_req *req);
4038
4039 static inline void
4040 devlink_trap_set_req_set_bus_name(struct devlink_trap_set_req *req,
4041                                   const char *bus_name)
4042 {
4043         free(req->bus_name);
4044         req->_present.bus_name_len = strlen(bus_name);
4045         req->bus_name = malloc(req->_present.bus_name_len + 1);
4046         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
4047         req->bus_name[req->_present.bus_name_len] = 0;
4048 }
4049 static inline void
4050 devlink_trap_set_req_set_dev_name(struct devlink_trap_set_req *req,
4051                                   const char *dev_name)
4052 {
4053         free(req->dev_name);
4054         req->_present.dev_name_len = strlen(dev_name);
4055         req->dev_name = malloc(req->_present.dev_name_len + 1);
4056         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
4057         req->dev_name[req->_present.dev_name_len] = 0;
4058 }
4059 static inline void
4060 devlink_trap_set_req_set_trap_name(struct devlink_trap_set_req *req,
4061                                    const char *trap_name)
4062 {
4063         free(req->trap_name);
4064         req->_present.trap_name_len = strlen(trap_name);
4065         req->trap_name = malloc(req->_present.trap_name_len + 1);
4066         memcpy(req->trap_name, trap_name, req->_present.trap_name_len);
4067         req->trap_name[req->_present.trap_name_len] = 0;
4068 }
4069 static inline void
4070 devlink_trap_set_req_set_trap_action(struct devlink_trap_set_req *req,
4071                                      enum devlink_trap_action trap_action)
4072 {
4073         req->_present.trap_action = 1;
4074         req->trap_action = trap_action;
4075 }
4076
4077 /*
4078  * Set trap instances.
4079  */
4080 int devlink_trap_set(struct ynl_sock *ys, struct devlink_trap_set_req *req);
4081
4082 /* ============== DEVLINK_CMD_TRAP_GROUP_GET ============== */
4083 /* DEVLINK_CMD_TRAP_GROUP_GET - do */
4084 struct devlink_trap_group_get_req {
4085         struct {
4086                 __u32 bus_name_len;
4087                 __u32 dev_name_len;
4088                 __u32 trap_group_name_len;
4089         } _present;
4090
4091         char *bus_name;
4092         char *dev_name;
4093         char *trap_group_name;
4094 };
4095
4096 static inline struct devlink_trap_group_get_req *
4097 devlink_trap_group_get_req_alloc(void)
4098 {
4099         return calloc(1, sizeof(struct devlink_trap_group_get_req));
4100 }
4101 void devlink_trap_group_get_req_free(struct devlink_trap_group_get_req *req);
4102
4103 static inline void
4104 devlink_trap_group_get_req_set_bus_name(struct devlink_trap_group_get_req *req,
4105                                         const char *bus_name)
4106 {
4107         free(req->bus_name);
4108         req->_present.bus_name_len = strlen(bus_name);
4109         req->bus_name = malloc(req->_present.bus_name_len + 1);
4110         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
4111         req->bus_name[req->_present.bus_name_len] = 0;
4112 }
4113 static inline void
4114 devlink_trap_group_get_req_set_dev_name(struct devlink_trap_group_get_req *req,
4115                                         const char *dev_name)
4116 {
4117         free(req->dev_name);
4118         req->_present.dev_name_len = strlen(dev_name);
4119         req->dev_name = malloc(req->_present.dev_name_len + 1);
4120         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
4121         req->dev_name[req->_present.dev_name_len] = 0;
4122 }
4123 static inline void
4124 devlink_trap_group_get_req_set_trap_group_name(struct devlink_trap_group_get_req *req,
4125                                                const char *trap_group_name)
4126 {
4127         free(req->trap_group_name);
4128         req->_present.trap_group_name_len = strlen(trap_group_name);
4129         req->trap_group_name = malloc(req->_present.trap_group_name_len + 1);
4130         memcpy(req->trap_group_name, trap_group_name, req->_present.trap_group_name_len);
4131         req->trap_group_name[req->_present.trap_group_name_len] = 0;
4132 }
4133
4134 struct devlink_trap_group_get_rsp {
4135         struct {
4136                 __u32 bus_name_len;
4137                 __u32 dev_name_len;
4138                 __u32 trap_group_name_len;
4139         } _present;
4140
4141         char *bus_name;
4142         char *dev_name;
4143         char *trap_group_name;
4144 };
4145
4146 void devlink_trap_group_get_rsp_free(struct devlink_trap_group_get_rsp *rsp);
4147
4148 /*
4149  * Get trap group instances.
4150  */
4151 struct devlink_trap_group_get_rsp *
4152 devlink_trap_group_get(struct ynl_sock *ys,
4153                        struct devlink_trap_group_get_req *req);
4154
4155 /* DEVLINK_CMD_TRAP_GROUP_GET - dump */
4156 struct devlink_trap_group_get_req_dump {
4157         struct {
4158                 __u32 bus_name_len;
4159                 __u32 dev_name_len;
4160         } _present;
4161
4162         char *bus_name;
4163         char *dev_name;
4164 };
4165
4166 static inline struct devlink_trap_group_get_req_dump *
4167 devlink_trap_group_get_req_dump_alloc(void)
4168 {
4169         return calloc(1, sizeof(struct devlink_trap_group_get_req_dump));
4170 }
4171 void
4172 devlink_trap_group_get_req_dump_free(struct devlink_trap_group_get_req_dump *req);
4173
4174 static inline void
4175 devlink_trap_group_get_req_dump_set_bus_name(struct devlink_trap_group_get_req_dump *req,
4176                                              const char *bus_name)
4177 {
4178         free(req->bus_name);
4179         req->_present.bus_name_len = strlen(bus_name);
4180         req->bus_name = malloc(req->_present.bus_name_len + 1);
4181         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
4182         req->bus_name[req->_present.bus_name_len] = 0;
4183 }
4184 static inline void
4185 devlink_trap_group_get_req_dump_set_dev_name(struct devlink_trap_group_get_req_dump *req,
4186                                              const char *dev_name)
4187 {
4188         free(req->dev_name);
4189         req->_present.dev_name_len = strlen(dev_name);
4190         req->dev_name = malloc(req->_present.dev_name_len + 1);
4191         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
4192         req->dev_name[req->_present.dev_name_len] = 0;
4193 }
4194
4195 struct devlink_trap_group_get_list {
4196         struct devlink_trap_group_get_list *next;
4197         struct devlink_trap_group_get_rsp obj __attribute__ ((aligned (8)));
4198 };
4199
4200 void devlink_trap_group_get_list_free(struct devlink_trap_group_get_list *rsp);
4201
4202 struct devlink_trap_group_get_list *
4203 devlink_trap_group_get_dump(struct ynl_sock *ys,
4204                             struct devlink_trap_group_get_req_dump *req);
4205
4206 /* ============== DEVLINK_CMD_TRAP_GROUP_SET ============== */
4207 /* DEVLINK_CMD_TRAP_GROUP_SET - do */
4208 struct devlink_trap_group_set_req {
4209         struct {
4210                 __u32 bus_name_len;
4211                 __u32 dev_name_len;
4212                 __u32 trap_group_name_len;
4213                 __u32 trap_action:1;
4214                 __u32 trap_policer_id:1;
4215         } _present;
4216
4217         char *bus_name;
4218         char *dev_name;
4219         char *trap_group_name;
4220         enum devlink_trap_action trap_action;
4221         __u32 trap_policer_id;
4222 };
4223
4224 static inline struct devlink_trap_group_set_req *
4225 devlink_trap_group_set_req_alloc(void)
4226 {
4227         return calloc(1, sizeof(struct devlink_trap_group_set_req));
4228 }
4229 void devlink_trap_group_set_req_free(struct devlink_trap_group_set_req *req);
4230
4231 static inline void
4232 devlink_trap_group_set_req_set_bus_name(struct devlink_trap_group_set_req *req,
4233                                         const char *bus_name)
4234 {
4235         free(req->bus_name);
4236         req->_present.bus_name_len = strlen(bus_name);
4237         req->bus_name = malloc(req->_present.bus_name_len + 1);
4238         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
4239         req->bus_name[req->_present.bus_name_len] = 0;
4240 }
4241 static inline void
4242 devlink_trap_group_set_req_set_dev_name(struct devlink_trap_group_set_req *req,
4243                                         const char *dev_name)
4244 {
4245         free(req->dev_name);
4246         req->_present.dev_name_len = strlen(dev_name);
4247         req->dev_name = malloc(req->_present.dev_name_len + 1);
4248         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
4249         req->dev_name[req->_present.dev_name_len] = 0;
4250 }
4251 static inline void
4252 devlink_trap_group_set_req_set_trap_group_name(struct devlink_trap_group_set_req *req,
4253                                                const char *trap_group_name)
4254 {
4255         free(req->trap_group_name);
4256         req->_present.trap_group_name_len = strlen(trap_group_name);
4257         req->trap_group_name = malloc(req->_present.trap_group_name_len + 1);
4258         memcpy(req->trap_group_name, trap_group_name, req->_present.trap_group_name_len);
4259         req->trap_group_name[req->_present.trap_group_name_len] = 0;
4260 }
4261 static inline void
4262 devlink_trap_group_set_req_set_trap_action(struct devlink_trap_group_set_req *req,
4263                                            enum devlink_trap_action trap_action)
4264 {
4265         req->_present.trap_action = 1;
4266         req->trap_action = trap_action;
4267 }
4268 static inline void
4269 devlink_trap_group_set_req_set_trap_policer_id(struct devlink_trap_group_set_req *req,
4270                                                __u32 trap_policer_id)
4271 {
4272         req->_present.trap_policer_id = 1;
4273         req->trap_policer_id = trap_policer_id;
4274 }
4275
4276 /*
4277  * Set trap group instances.
4278  */
4279 int devlink_trap_group_set(struct ynl_sock *ys,
4280                            struct devlink_trap_group_set_req *req);
4281
4282 /* ============== DEVLINK_CMD_TRAP_POLICER_GET ============== */
4283 /* DEVLINK_CMD_TRAP_POLICER_GET - do */
4284 struct devlink_trap_policer_get_req {
4285         struct {
4286                 __u32 bus_name_len;
4287                 __u32 dev_name_len;
4288                 __u32 trap_policer_id:1;
4289         } _present;
4290
4291         char *bus_name;
4292         char *dev_name;
4293         __u32 trap_policer_id;
4294 };
4295
4296 static inline struct devlink_trap_policer_get_req *
4297 devlink_trap_policer_get_req_alloc(void)
4298 {
4299         return calloc(1, sizeof(struct devlink_trap_policer_get_req));
4300 }
4301 void
4302 devlink_trap_policer_get_req_free(struct devlink_trap_policer_get_req *req);
4303
4304 static inline void
4305 devlink_trap_policer_get_req_set_bus_name(struct devlink_trap_policer_get_req *req,
4306                                           const char *bus_name)
4307 {
4308         free(req->bus_name);
4309         req->_present.bus_name_len = strlen(bus_name);
4310         req->bus_name = malloc(req->_present.bus_name_len + 1);
4311         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
4312         req->bus_name[req->_present.bus_name_len] = 0;
4313 }
4314 static inline void
4315 devlink_trap_policer_get_req_set_dev_name(struct devlink_trap_policer_get_req *req,
4316                                           const char *dev_name)
4317 {
4318         free(req->dev_name);
4319         req->_present.dev_name_len = strlen(dev_name);
4320         req->dev_name = malloc(req->_present.dev_name_len + 1);
4321         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
4322         req->dev_name[req->_present.dev_name_len] = 0;
4323 }
4324 static inline void
4325 devlink_trap_policer_get_req_set_trap_policer_id(struct devlink_trap_policer_get_req *req,
4326                                                  __u32 trap_policer_id)
4327 {
4328         req->_present.trap_policer_id = 1;
4329         req->trap_policer_id = trap_policer_id;
4330 }
4331
4332 struct devlink_trap_policer_get_rsp {
4333         struct {
4334                 __u32 bus_name_len;
4335                 __u32 dev_name_len;
4336                 __u32 trap_policer_id:1;
4337         } _present;
4338
4339         char *bus_name;
4340         char *dev_name;
4341         __u32 trap_policer_id;
4342 };
4343
4344 void
4345 devlink_trap_policer_get_rsp_free(struct devlink_trap_policer_get_rsp *rsp);
4346
4347 /*
4348  * Get trap policer instances.
4349  */
4350 struct devlink_trap_policer_get_rsp *
4351 devlink_trap_policer_get(struct ynl_sock *ys,
4352                          struct devlink_trap_policer_get_req *req);
4353
4354 /* DEVLINK_CMD_TRAP_POLICER_GET - dump */
4355 struct devlink_trap_policer_get_req_dump {
4356         struct {
4357                 __u32 bus_name_len;
4358                 __u32 dev_name_len;
4359         } _present;
4360
4361         char *bus_name;
4362         char *dev_name;
4363 };
4364
4365 static inline struct devlink_trap_policer_get_req_dump *
4366 devlink_trap_policer_get_req_dump_alloc(void)
4367 {
4368         return calloc(1, sizeof(struct devlink_trap_policer_get_req_dump));
4369 }
4370 void
4371 devlink_trap_policer_get_req_dump_free(struct devlink_trap_policer_get_req_dump *req);
4372
4373 static inline void
4374 devlink_trap_policer_get_req_dump_set_bus_name(struct devlink_trap_policer_get_req_dump *req,
4375                                                const char *bus_name)
4376 {
4377         free(req->bus_name);
4378         req->_present.bus_name_len = strlen(bus_name);
4379         req->bus_name = malloc(req->_present.bus_name_len + 1);
4380         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
4381         req->bus_name[req->_present.bus_name_len] = 0;
4382 }
4383 static inline void
4384 devlink_trap_policer_get_req_dump_set_dev_name(struct devlink_trap_policer_get_req_dump *req,
4385                                                const char *dev_name)
4386 {
4387         free(req->dev_name);
4388         req->_present.dev_name_len = strlen(dev_name);
4389         req->dev_name = malloc(req->_present.dev_name_len + 1);
4390         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
4391         req->dev_name[req->_present.dev_name_len] = 0;
4392 }
4393
4394 struct devlink_trap_policer_get_list {
4395         struct devlink_trap_policer_get_list *next;
4396         struct devlink_trap_policer_get_rsp obj __attribute__ ((aligned (8)));
4397 };
4398
4399 void
4400 devlink_trap_policer_get_list_free(struct devlink_trap_policer_get_list *rsp);
4401
4402 struct devlink_trap_policer_get_list *
4403 devlink_trap_policer_get_dump(struct ynl_sock *ys,
4404                               struct devlink_trap_policer_get_req_dump *req);
4405
4406 /* ============== DEVLINK_CMD_TRAP_POLICER_SET ============== */
4407 /* DEVLINK_CMD_TRAP_POLICER_SET - do */
4408 struct devlink_trap_policer_set_req {
4409         struct {
4410                 __u32 bus_name_len;
4411                 __u32 dev_name_len;
4412                 __u32 trap_policer_id:1;
4413                 __u32 trap_policer_rate:1;
4414                 __u32 trap_policer_burst:1;
4415         } _present;
4416
4417         char *bus_name;
4418         char *dev_name;
4419         __u32 trap_policer_id;
4420         __u64 trap_policer_rate;
4421         __u64 trap_policer_burst;
4422 };
4423
4424 static inline struct devlink_trap_policer_set_req *
4425 devlink_trap_policer_set_req_alloc(void)
4426 {
4427         return calloc(1, sizeof(struct devlink_trap_policer_set_req));
4428 }
4429 void
4430 devlink_trap_policer_set_req_free(struct devlink_trap_policer_set_req *req);
4431
4432 static inline void
4433 devlink_trap_policer_set_req_set_bus_name(struct devlink_trap_policer_set_req *req,
4434                                           const char *bus_name)
4435 {
4436         free(req->bus_name);
4437         req->_present.bus_name_len = strlen(bus_name);
4438         req->bus_name = malloc(req->_present.bus_name_len + 1);
4439         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
4440         req->bus_name[req->_present.bus_name_len] = 0;
4441 }
4442 static inline void
4443 devlink_trap_policer_set_req_set_dev_name(struct devlink_trap_policer_set_req *req,
4444                                           const char *dev_name)
4445 {
4446         free(req->dev_name);
4447         req->_present.dev_name_len = strlen(dev_name);
4448         req->dev_name = malloc(req->_present.dev_name_len + 1);
4449         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
4450         req->dev_name[req->_present.dev_name_len] = 0;
4451 }
4452 static inline void
4453 devlink_trap_policer_set_req_set_trap_policer_id(struct devlink_trap_policer_set_req *req,
4454                                                  __u32 trap_policer_id)
4455 {
4456         req->_present.trap_policer_id = 1;
4457         req->trap_policer_id = trap_policer_id;
4458 }
4459 static inline void
4460 devlink_trap_policer_set_req_set_trap_policer_rate(struct devlink_trap_policer_set_req *req,
4461                                                    __u64 trap_policer_rate)
4462 {
4463         req->_present.trap_policer_rate = 1;
4464         req->trap_policer_rate = trap_policer_rate;
4465 }
4466 static inline void
4467 devlink_trap_policer_set_req_set_trap_policer_burst(struct devlink_trap_policer_set_req *req,
4468                                                     __u64 trap_policer_burst)
4469 {
4470         req->_present.trap_policer_burst = 1;
4471         req->trap_policer_burst = trap_policer_burst;
4472 }
4473
4474 /*
4475  * Get trap policer instances.
4476  */
4477 int devlink_trap_policer_set(struct ynl_sock *ys,
4478                              struct devlink_trap_policer_set_req *req);
4479
4480 /* ============== DEVLINK_CMD_HEALTH_REPORTER_TEST ============== */
4481 /* DEVLINK_CMD_HEALTH_REPORTER_TEST - do */
4482 struct devlink_health_reporter_test_req {
4483         struct {
4484                 __u32 bus_name_len;
4485                 __u32 dev_name_len;
4486                 __u32 port_index:1;
4487                 __u32 health_reporter_name_len;
4488         } _present;
4489
4490         char *bus_name;
4491         char *dev_name;
4492         __u32 port_index;
4493         char *health_reporter_name;
4494 };
4495
4496 static inline struct devlink_health_reporter_test_req *
4497 devlink_health_reporter_test_req_alloc(void)
4498 {
4499         return calloc(1, sizeof(struct devlink_health_reporter_test_req));
4500 }
4501 void
4502 devlink_health_reporter_test_req_free(struct devlink_health_reporter_test_req *req);
4503
4504 static inline void
4505 devlink_health_reporter_test_req_set_bus_name(struct devlink_health_reporter_test_req *req,
4506                                               const char *bus_name)
4507 {
4508         free(req->bus_name);
4509         req->_present.bus_name_len = strlen(bus_name);
4510         req->bus_name = malloc(req->_present.bus_name_len + 1);
4511         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
4512         req->bus_name[req->_present.bus_name_len] = 0;
4513 }
4514 static inline void
4515 devlink_health_reporter_test_req_set_dev_name(struct devlink_health_reporter_test_req *req,
4516                                               const char *dev_name)
4517 {
4518         free(req->dev_name);
4519         req->_present.dev_name_len = strlen(dev_name);
4520         req->dev_name = malloc(req->_present.dev_name_len + 1);
4521         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
4522         req->dev_name[req->_present.dev_name_len] = 0;
4523 }
4524 static inline void
4525 devlink_health_reporter_test_req_set_port_index(struct devlink_health_reporter_test_req *req,
4526                                                 __u32 port_index)
4527 {
4528         req->_present.port_index = 1;
4529         req->port_index = port_index;
4530 }
4531 static inline void
4532 devlink_health_reporter_test_req_set_health_reporter_name(struct devlink_health_reporter_test_req *req,
4533                                                           const char *health_reporter_name)
4534 {
4535         free(req->health_reporter_name);
4536         req->_present.health_reporter_name_len = strlen(health_reporter_name);
4537         req->health_reporter_name = malloc(req->_present.health_reporter_name_len + 1);
4538         memcpy(req->health_reporter_name, health_reporter_name, req->_present.health_reporter_name_len);
4539         req->health_reporter_name[req->_present.health_reporter_name_len] = 0;
4540 }
4541
4542 /*
4543  * Test health reporter instances.
4544  */
4545 int devlink_health_reporter_test(struct ynl_sock *ys,
4546                                  struct devlink_health_reporter_test_req *req);
4547
4548 /* ============== DEVLINK_CMD_RATE_GET ============== */
4549 /* DEVLINK_CMD_RATE_GET - do */
4550 struct devlink_rate_get_req {
4551         struct {
4552                 __u32 bus_name_len;
4553                 __u32 dev_name_len;
4554                 __u32 port_index:1;
4555                 __u32 rate_node_name_len;
4556         } _present;
4557
4558         char *bus_name;
4559         char *dev_name;
4560         __u32 port_index;
4561         char *rate_node_name;
4562 };
4563
4564 static inline struct devlink_rate_get_req *devlink_rate_get_req_alloc(void)
4565 {
4566         return calloc(1, sizeof(struct devlink_rate_get_req));
4567 }
4568 void devlink_rate_get_req_free(struct devlink_rate_get_req *req);
4569
4570 static inline void
4571 devlink_rate_get_req_set_bus_name(struct devlink_rate_get_req *req,
4572                                   const char *bus_name)
4573 {
4574         free(req->bus_name);
4575         req->_present.bus_name_len = strlen(bus_name);
4576         req->bus_name = malloc(req->_present.bus_name_len + 1);
4577         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
4578         req->bus_name[req->_present.bus_name_len] = 0;
4579 }
4580 static inline void
4581 devlink_rate_get_req_set_dev_name(struct devlink_rate_get_req *req,
4582                                   const char *dev_name)
4583 {
4584         free(req->dev_name);
4585         req->_present.dev_name_len = strlen(dev_name);
4586         req->dev_name = malloc(req->_present.dev_name_len + 1);
4587         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
4588         req->dev_name[req->_present.dev_name_len] = 0;
4589 }
4590 static inline void
4591 devlink_rate_get_req_set_port_index(struct devlink_rate_get_req *req,
4592                                     __u32 port_index)
4593 {
4594         req->_present.port_index = 1;
4595         req->port_index = port_index;
4596 }
4597 static inline void
4598 devlink_rate_get_req_set_rate_node_name(struct devlink_rate_get_req *req,
4599                                         const char *rate_node_name)
4600 {
4601         free(req->rate_node_name);
4602         req->_present.rate_node_name_len = strlen(rate_node_name);
4603         req->rate_node_name = malloc(req->_present.rate_node_name_len + 1);
4604         memcpy(req->rate_node_name, rate_node_name, req->_present.rate_node_name_len);
4605         req->rate_node_name[req->_present.rate_node_name_len] = 0;
4606 }
4607
4608 struct devlink_rate_get_rsp {
4609         struct {
4610                 __u32 bus_name_len;
4611                 __u32 dev_name_len;
4612                 __u32 port_index:1;
4613                 __u32 rate_node_name_len;
4614         } _present;
4615
4616         char *bus_name;
4617         char *dev_name;
4618         __u32 port_index;
4619         char *rate_node_name;
4620 };
4621
4622 void devlink_rate_get_rsp_free(struct devlink_rate_get_rsp *rsp);
4623
4624 /*
4625  * Get rate instances.
4626  */
4627 struct devlink_rate_get_rsp *
4628 devlink_rate_get(struct ynl_sock *ys, struct devlink_rate_get_req *req);
4629
4630 /* DEVLINK_CMD_RATE_GET - dump */
4631 struct devlink_rate_get_req_dump {
4632         struct {
4633                 __u32 bus_name_len;
4634                 __u32 dev_name_len;
4635         } _present;
4636
4637         char *bus_name;
4638         char *dev_name;
4639 };
4640
4641 static inline struct devlink_rate_get_req_dump *
4642 devlink_rate_get_req_dump_alloc(void)
4643 {
4644         return calloc(1, sizeof(struct devlink_rate_get_req_dump));
4645 }
4646 void devlink_rate_get_req_dump_free(struct devlink_rate_get_req_dump *req);
4647
4648 static inline void
4649 devlink_rate_get_req_dump_set_bus_name(struct devlink_rate_get_req_dump *req,
4650                                        const char *bus_name)
4651 {
4652         free(req->bus_name);
4653         req->_present.bus_name_len = strlen(bus_name);
4654         req->bus_name = malloc(req->_present.bus_name_len + 1);
4655         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
4656         req->bus_name[req->_present.bus_name_len] = 0;
4657 }
4658 static inline void
4659 devlink_rate_get_req_dump_set_dev_name(struct devlink_rate_get_req_dump *req,
4660                                        const char *dev_name)
4661 {
4662         free(req->dev_name);
4663         req->_present.dev_name_len = strlen(dev_name);
4664         req->dev_name = malloc(req->_present.dev_name_len + 1);
4665         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
4666         req->dev_name[req->_present.dev_name_len] = 0;
4667 }
4668
4669 struct devlink_rate_get_list {
4670         struct devlink_rate_get_list *next;
4671         struct devlink_rate_get_rsp obj __attribute__ ((aligned (8)));
4672 };
4673
4674 void devlink_rate_get_list_free(struct devlink_rate_get_list *rsp);
4675
4676 struct devlink_rate_get_list *
4677 devlink_rate_get_dump(struct ynl_sock *ys,
4678                       struct devlink_rate_get_req_dump *req);
4679
4680 /* ============== DEVLINK_CMD_RATE_SET ============== */
4681 /* DEVLINK_CMD_RATE_SET - do */
4682 struct devlink_rate_set_req {
4683         struct {
4684                 __u32 bus_name_len;
4685                 __u32 dev_name_len;
4686                 __u32 rate_node_name_len;
4687                 __u32 rate_tx_share:1;
4688                 __u32 rate_tx_max:1;
4689                 __u32 rate_tx_priority:1;
4690                 __u32 rate_tx_weight:1;
4691                 __u32 rate_parent_node_name_len;
4692         } _present;
4693
4694         char *bus_name;
4695         char *dev_name;
4696         char *rate_node_name;
4697         __u64 rate_tx_share;
4698         __u64 rate_tx_max;
4699         __u32 rate_tx_priority;
4700         __u32 rate_tx_weight;
4701         char *rate_parent_node_name;
4702 };
4703
4704 static inline struct devlink_rate_set_req *devlink_rate_set_req_alloc(void)
4705 {
4706         return calloc(1, sizeof(struct devlink_rate_set_req));
4707 }
4708 void devlink_rate_set_req_free(struct devlink_rate_set_req *req);
4709
4710 static inline void
4711 devlink_rate_set_req_set_bus_name(struct devlink_rate_set_req *req,
4712                                   const char *bus_name)
4713 {
4714         free(req->bus_name);
4715         req->_present.bus_name_len = strlen(bus_name);
4716         req->bus_name = malloc(req->_present.bus_name_len + 1);
4717         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
4718         req->bus_name[req->_present.bus_name_len] = 0;
4719 }
4720 static inline void
4721 devlink_rate_set_req_set_dev_name(struct devlink_rate_set_req *req,
4722                                   const char *dev_name)
4723 {
4724         free(req->dev_name);
4725         req->_present.dev_name_len = strlen(dev_name);
4726         req->dev_name = malloc(req->_present.dev_name_len + 1);
4727         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
4728         req->dev_name[req->_present.dev_name_len] = 0;
4729 }
4730 static inline void
4731 devlink_rate_set_req_set_rate_node_name(struct devlink_rate_set_req *req,
4732                                         const char *rate_node_name)
4733 {
4734         free(req->rate_node_name);
4735         req->_present.rate_node_name_len = strlen(rate_node_name);
4736         req->rate_node_name = malloc(req->_present.rate_node_name_len + 1);
4737         memcpy(req->rate_node_name, rate_node_name, req->_present.rate_node_name_len);
4738         req->rate_node_name[req->_present.rate_node_name_len] = 0;
4739 }
4740 static inline void
4741 devlink_rate_set_req_set_rate_tx_share(struct devlink_rate_set_req *req,
4742                                        __u64 rate_tx_share)
4743 {
4744         req->_present.rate_tx_share = 1;
4745         req->rate_tx_share = rate_tx_share;
4746 }
4747 static inline void
4748 devlink_rate_set_req_set_rate_tx_max(struct devlink_rate_set_req *req,
4749                                      __u64 rate_tx_max)
4750 {
4751         req->_present.rate_tx_max = 1;
4752         req->rate_tx_max = rate_tx_max;
4753 }
4754 static inline void
4755 devlink_rate_set_req_set_rate_tx_priority(struct devlink_rate_set_req *req,
4756                                           __u32 rate_tx_priority)
4757 {
4758         req->_present.rate_tx_priority = 1;
4759         req->rate_tx_priority = rate_tx_priority;
4760 }
4761 static inline void
4762 devlink_rate_set_req_set_rate_tx_weight(struct devlink_rate_set_req *req,
4763                                         __u32 rate_tx_weight)
4764 {
4765         req->_present.rate_tx_weight = 1;
4766         req->rate_tx_weight = rate_tx_weight;
4767 }
4768 static inline void
4769 devlink_rate_set_req_set_rate_parent_node_name(struct devlink_rate_set_req *req,
4770                                                const char *rate_parent_node_name)
4771 {
4772         free(req->rate_parent_node_name);
4773         req->_present.rate_parent_node_name_len = strlen(rate_parent_node_name);
4774         req->rate_parent_node_name = malloc(req->_present.rate_parent_node_name_len + 1);
4775         memcpy(req->rate_parent_node_name, rate_parent_node_name, req->_present.rate_parent_node_name_len);
4776         req->rate_parent_node_name[req->_present.rate_parent_node_name_len] = 0;
4777 }
4778
4779 /*
4780  * Set rate instances.
4781  */
4782 int devlink_rate_set(struct ynl_sock *ys, struct devlink_rate_set_req *req);
4783
4784 /* ============== DEVLINK_CMD_RATE_NEW ============== */
4785 /* DEVLINK_CMD_RATE_NEW - do */
4786 struct devlink_rate_new_req {
4787         struct {
4788                 __u32 bus_name_len;
4789                 __u32 dev_name_len;
4790                 __u32 rate_node_name_len;
4791                 __u32 rate_tx_share:1;
4792                 __u32 rate_tx_max:1;
4793                 __u32 rate_tx_priority:1;
4794                 __u32 rate_tx_weight:1;
4795                 __u32 rate_parent_node_name_len;
4796         } _present;
4797
4798         char *bus_name;
4799         char *dev_name;
4800         char *rate_node_name;
4801         __u64 rate_tx_share;
4802         __u64 rate_tx_max;
4803         __u32 rate_tx_priority;
4804         __u32 rate_tx_weight;
4805         char *rate_parent_node_name;
4806 };
4807
4808 static inline struct devlink_rate_new_req *devlink_rate_new_req_alloc(void)
4809 {
4810         return calloc(1, sizeof(struct devlink_rate_new_req));
4811 }
4812 void devlink_rate_new_req_free(struct devlink_rate_new_req *req);
4813
4814 static inline void
4815 devlink_rate_new_req_set_bus_name(struct devlink_rate_new_req *req,
4816                                   const char *bus_name)
4817 {
4818         free(req->bus_name);
4819         req->_present.bus_name_len = strlen(bus_name);
4820         req->bus_name = malloc(req->_present.bus_name_len + 1);
4821         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
4822         req->bus_name[req->_present.bus_name_len] = 0;
4823 }
4824 static inline void
4825 devlink_rate_new_req_set_dev_name(struct devlink_rate_new_req *req,
4826                                   const char *dev_name)
4827 {
4828         free(req->dev_name);
4829         req->_present.dev_name_len = strlen(dev_name);
4830         req->dev_name = malloc(req->_present.dev_name_len + 1);
4831         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
4832         req->dev_name[req->_present.dev_name_len] = 0;
4833 }
4834 static inline void
4835 devlink_rate_new_req_set_rate_node_name(struct devlink_rate_new_req *req,
4836                                         const char *rate_node_name)
4837 {
4838         free(req->rate_node_name);
4839         req->_present.rate_node_name_len = strlen(rate_node_name);
4840         req->rate_node_name = malloc(req->_present.rate_node_name_len + 1);
4841         memcpy(req->rate_node_name, rate_node_name, req->_present.rate_node_name_len);
4842         req->rate_node_name[req->_present.rate_node_name_len] = 0;
4843 }
4844 static inline void
4845 devlink_rate_new_req_set_rate_tx_share(struct devlink_rate_new_req *req,
4846                                        __u64 rate_tx_share)
4847 {
4848         req->_present.rate_tx_share = 1;
4849         req->rate_tx_share = rate_tx_share;
4850 }
4851 static inline void
4852 devlink_rate_new_req_set_rate_tx_max(struct devlink_rate_new_req *req,
4853                                      __u64 rate_tx_max)
4854 {
4855         req->_present.rate_tx_max = 1;
4856         req->rate_tx_max = rate_tx_max;
4857 }
4858 static inline void
4859 devlink_rate_new_req_set_rate_tx_priority(struct devlink_rate_new_req *req,
4860                                           __u32 rate_tx_priority)
4861 {
4862         req->_present.rate_tx_priority = 1;
4863         req->rate_tx_priority = rate_tx_priority;
4864 }
4865 static inline void
4866 devlink_rate_new_req_set_rate_tx_weight(struct devlink_rate_new_req *req,
4867                                         __u32 rate_tx_weight)
4868 {
4869         req->_present.rate_tx_weight = 1;
4870         req->rate_tx_weight = rate_tx_weight;
4871 }
4872 static inline void
4873 devlink_rate_new_req_set_rate_parent_node_name(struct devlink_rate_new_req *req,
4874                                                const char *rate_parent_node_name)
4875 {
4876         free(req->rate_parent_node_name);
4877         req->_present.rate_parent_node_name_len = strlen(rate_parent_node_name);
4878         req->rate_parent_node_name = malloc(req->_present.rate_parent_node_name_len + 1);
4879         memcpy(req->rate_parent_node_name, rate_parent_node_name, req->_present.rate_parent_node_name_len);
4880         req->rate_parent_node_name[req->_present.rate_parent_node_name_len] = 0;
4881 }
4882
4883 /*
4884  * Create rate instances.
4885  */
4886 int devlink_rate_new(struct ynl_sock *ys, struct devlink_rate_new_req *req);
4887
4888 /* ============== DEVLINK_CMD_RATE_DEL ============== */
4889 /* DEVLINK_CMD_RATE_DEL - do */
4890 struct devlink_rate_del_req {
4891         struct {
4892                 __u32 bus_name_len;
4893                 __u32 dev_name_len;
4894                 __u32 rate_node_name_len;
4895         } _present;
4896
4897         char *bus_name;
4898         char *dev_name;
4899         char *rate_node_name;
4900 };
4901
4902 static inline struct devlink_rate_del_req *devlink_rate_del_req_alloc(void)
4903 {
4904         return calloc(1, sizeof(struct devlink_rate_del_req));
4905 }
4906 void devlink_rate_del_req_free(struct devlink_rate_del_req *req);
4907
4908 static inline void
4909 devlink_rate_del_req_set_bus_name(struct devlink_rate_del_req *req,
4910                                   const char *bus_name)
4911 {
4912         free(req->bus_name);
4913         req->_present.bus_name_len = strlen(bus_name);
4914         req->bus_name = malloc(req->_present.bus_name_len + 1);
4915         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
4916         req->bus_name[req->_present.bus_name_len] = 0;
4917 }
4918 static inline void
4919 devlink_rate_del_req_set_dev_name(struct devlink_rate_del_req *req,
4920                                   const char *dev_name)
4921 {
4922         free(req->dev_name);
4923         req->_present.dev_name_len = strlen(dev_name);
4924         req->dev_name = malloc(req->_present.dev_name_len + 1);
4925         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
4926         req->dev_name[req->_present.dev_name_len] = 0;
4927 }
4928 static inline void
4929 devlink_rate_del_req_set_rate_node_name(struct devlink_rate_del_req *req,
4930                                         const char *rate_node_name)
4931 {
4932         free(req->rate_node_name);
4933         req->_present.rate_node_name_len = strlen(rate_node_name);
4934         req->rate_node_name = malloc(req->_present.rate_node_name_len + 1);
4935         memcpy(req->rate_node_name, rate_node_name, req->_present.rate_node_name_len);
4936         req->rate_node_name[req->_present.rate_node_name_len] = 0;
4937 }
4938
4939 /*
4940  * Delete rate instances.
4941  */
4942 int devlink_rate_del(struct ynl_sock *ys, struct devlink_rate_del_req *req);
4943
4944 /* ============== DEVLINK_CMD_LINECARD_GET ============== */
4945 /* DEVLINK_CMD_LINECARD_GET - do */
4946 struct devlink_linecard_get_req {
4947         struct {
4948                 __u32 bus_name_len;
4949                 __u32 dev_name_len;
4950                 __u32 linecard_index:1;
4951         } _present;
4952
4953         char *bus_name;
4954         char *dev_name;
4955         __u32 linecard_index;
4956 };
4957
4958 static inline struct devlink_linecard_get_req *
4959 devlink_linecard_get_req_alloc(void)
4960 {
4961         return calloc(1, sizeof(struct devlink_linecard_get_req));
4962 }
4963 void devlink_linecard_get_req_free(struct devlink_linecard_get_req *req);
4964
4965 static inline void
4966 devlink_linecard_get_req_set_bus_name(struct devlink_linecard_get_req *req,
4967                                       const char *bus_name)
4968 {
4969         free(req->bus_name);
4970         req->_present.bus_name_len = strlen(bus_name);
4971         req->bus_name = malloc(req->_present.bus_name_len + 1);
4972         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
4973         req->bus_name[req->_present.bus_name_len] = 0;
4974 }
4975 static inline void
4976 devlink_linecard_get_req_set_dev_name(struct devlink_linecard_get_req *req,
4977                                       const char *dev_name)
4978 {
4979         free(req->dev_name);
4980         req->_present.dev_name_len = strlen(dev_name);
4981         req->dev_name = malloc(req->_present.dev_name_len + 1);
4982         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
4983         req->dev_name[req->_present.dev_name_len] = 0;
4984 }
4985 static inline void
4986 devlink_linecard_get_req_set_linecard_index(struct devlink_linecard_get_req *req,
4987                                             __u32 linecard_index)
4988 {
4989         req->_present.linecard_index = 1;
4990         req->linecard_index = linecard_index;
4991 }
4992
4993 struct devlink_linecard_get_rsp {
4994         struct {
4995                 __u32 bus_name_len;
4996                 __u32 dev_name_len;
4997                 __u32 linecard_index:1;
4998         } _present;
4999
5000         char *bus_name;
5001         char *dev_name;
5002         __u32 linecard_index;
5003 };
5004
5005 void devlink_linecard_get_rsp_free(struct devlink_linecard_get_rsp *rsp);
5006
5007 /*
5008  * Get line card instances.
5009  */
5010 struct devlink_linecard_get_rsp *
5011 devlink_linecard_get(struct ynl_sock *ys, struct devlink_linecard_get_req *req);
5012
5013 /* DEVLINK_CMD_LINECARD_GET - dump */
5014 struct devlink_linecard_get_req_dump {
5015         struct {
5016                 __u32 bus_name_len;
5017                 __u32 dev_name_len;
5018         } _present;
5019
5020         char *bus_name;
5021         char *dev_name;
5022 };
5023
5024 static inline struct devlink_linecard_get_req_dump *
5025 devlink_linecard_get_req_dump_alloc(void)
5026 {
5027         return calloc(1, sizeof(struct devlink_linecard_get_req_dump));
5028 }
5029 void
5030 devlink_linecard_get_req_dump_free(struct devlink_linecard_get_req_dump *req);
5031
5032 static inline void
5033 devlink_linecard_get_req_dump_set_bus_name(struct devlink_linecard_get_req_dump *req,
5034                                            const char *bus_name)
5035 {
5036         free(req->bus_name);
5037         req->_present.bus_name_len = strlen(bus_name);
5038         req->bus_name = malloc(req->_present.bus_name_len + 1);
5039         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
5040         req->bus_name[req->_present.bus_name_len] = 0;
5041 }
5042 static inline void
5043 devlink_linecard_get_req_dump_set_dev_name(struct devlink_linecard_get_req_dump *req,
5044                                            const char *dev_name)
5045 {
5046         free(req->dev_name);
5047         req->_present.dev_name_len = strlen(dev_name);
5048         req->dev_name = malloc(req->_present.dev_name_len + 1);
5049         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
5050         req->dev_name[req->_present.dev_name_len] = 0;
5051 }
5052
5053 struct devlink_linecard_get_list {
5054         struct devlink_linecard_get_list *next;
5055         struct devlink_linecard_get_rsp obj __attribute__ ((aligned (8)));
5056 };
5057
5058 void devlink_linecard_get_list_free(struct devlink_linecard_get_list *rsp);
5059
5060 struct devlink_linecard_get_list *
5061 devlink_linecard_get_dump(struct ynl_sock *ys,
5062                           struct devlink_linecard_get_req_dump *req);
5063
5064 /* ============== DEVLINK_CMD_LINECARD_SET ============== */
5065 /* DEVLINK_CMD_LINECARD_SET - do */
5066 struct devlink_linecard_set_req {
5067         struct {
5068                 __u32 bus_name_len;
5069                 __u32 dev_name_len;
5070                 __u32 linecard_index:1;
5071                 __u32 linecard_type_len;
5072         } _present;
5073
5074         char *bus_name;
5075         char *dev_name;
5076         __u32 linecard_index;
5077         char *linecard_type;
5078 };
5079
5080 static inline struct devlink_linecard_set_req *
5081 devlink_linecard_set_req_alloc(void)
5082 {
5083         return calloc(1, sizeof(struct devlink_linecard_set_req));
5084 }
5085 void devlink_linecard_set_req_free(struct devlink_linecard_set_req *req);
5086
5087 static inline void
5088 devlink_linecard_set_req_set_bus_name(struct devlink_linecard_set_req *req,
5089                                       const char *bus_name)
5090 {
5091         free(req->bus_name);
5092         req->_present.bus_name_len = strlen(bus_name);
5093         req->bus_name = malloc(req->_present.bus_name_len + 1);
5094         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
5095         req->bus_name[req->_present.bus_name_len] = 0;
5096 }
5097 static inline void
5098 devlink_linecard_set_req_set_dev_name(struct devlink_linecard_set_req *req,
5099                                       const char *dev_name)
5100 {
5101         free(req->dev_name);
5102         req->_present.dev_name_len = strlen(dev_name);
5103         req->dev_name = malloc(req->_present.dev_name_len + 1);
5104         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
5105         req->dev_name[req->_present.dev_name_len] = 0;
5106 }
5107 static inline void
5108 devlink_linecard_set_req_set_linecard_index(struct devlink_linecard_set_req *req,
5109                                             __u32 linecard_index)
5110 {
5111         req->_present.linecard_index = 1;
5112         req->linecard_index = linecard_index;
5113 }
5114 static inline void
5115 devlink_linecard_set_req_set_linecard_type(struct devlink_linecard_set_req *req,
5116                                            const char *linecard_type)
5117 {
5118         free(req->linecard_type);
5119         req->_present.linecard_type_len = strlen(linecard_type);
5120         req->linecard_type = malloc(req->_present.linecard_type_len + 1);
5121         memcpy(req->linecard_type, linecard_type, req->_present.linecard_type_len);
5122         req->linecard_type[req->_present.linecard_type_len] = 0;
5123 }
5124
5125 /*
5126  * Set line card instances.
5127  */
5128 int devlink_linecard_set(struct ynl_sock *ys,
5129                          struct devlink_linecard_set_req *req);
5130
5131 /* ============== DEVLINK_CMD_SELFTESTS_GET ============== */
5132 /* DEVLINK_CMD_SELFTESTS_GET - do */
5133 struct devlink_selftests_get_req {
5134         struct {
5135                 __u32 bus_name_len;
5136                 __u32 dev_name_len;
5137         } _present;
5138
5139         char *bus_name;
5140         char *dev_name;
5141 };
5142
5143 static inline struct devlink_selftests_get_req *
5144 devlink_selftests_get_req_alloc(void)
5145 {
5146         return calloc(1, sizeof(struct devlink_selftests_get_req));
5147 }
5148 void devlink_selftests_get_req_free(struct devlink_selftests_get_req *req);
5149
5150 static inline void
5151 devlink_selftests_get_req_set_bus_name(struct devlink_selftests_get_req *req,
5152                                        const char *bus_name)
5153 {
5154         free(req->bus_name);
5155         req->_present.bus_name_len = strlen(bus_name);
5156         req->bus_name = malloc(req->_present.bus_name_len + 1);
5157         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
5158         req->bus_name[req->_present.bus_name_len] = 0;
5159 }
5160 static inline void
5161 devlink_selftests_get_req_set_dev_name(struct devlink_selftests_get_req *req,
5162                                        const char *dev_name)
5163 {
5164         free(req->dev_name);
5165         req->_present.dev_name_len = strlen(dev_name);
5166         req->dev_name = malloc(req->_present.dev_name_len + 1);
5167         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
5168         req->dev_name[req->_present.dev_name_len] = 0;
5169 }
5170
5171 struct devlink_selftests_get_rsp {
5172         struct {
5173                 __u32 bus_name_len;
5174                 __u32 dev_name_len;
5175         } _present;
5176
5177         char *bus_name;
5178         char *dev_name;
5179 };
5180
5181 void devlink_selftests_get_rsp_free(struct devlink_selftests_get_rsp *rsp);
5182
5183 /*
5184  * Get device selftest instances.
5185  */
5186 struct devlink_selftests_get_rsp *
5187 devlink_selftests_get(struct ynl_sock *ys,
5188                       struct devlink_selftests_get_req *req);
5189
5190 /* DEVLINK_CMD_SELFTESTS_GET - dump */
5191 struct devlink_selftests_get_list {
5192         struct devlink_selftests_get_list *next;
5193         struct devlink_selftests_get_rsp obj __attribute__ ((aligned (8)));
5194 };
5195
5196 void devlink_selftests_get_list_free(struct devlink_selftests_get_list *rsp);
5197
5198 struct devlink_selftests_get_list *
5199 devlink_selftests_get_dump(struct ynl_sock *ys);
5200
5201 /* ============== DEVLINK_CMD_SELFTESTS_RUN ============== */
5202 /* DEVLINK_CMD_SELFTESTS_RUN - do */
5203 struct devlink_selftests_run_req {
5204         struct {
5205                 __u32 bus_name_len;
5206                 __u32 dev_name_len;
5207                 __u32 selftests:1;
5208         } _present;
5209
5210         char *bus_name;
5211         char *dev_name;
5212         struct devlink_dl_selftest_id selftests;
5213 };
5214
5215 static inline struct devlink_selftests_run_req *
5216 devlink_selftests_run_req_alloc(void)
5217 {
5218         return calloc(1, sizeof(struct devlink_selftests_run_req));
5219 }
5220 void devlink_selftests_run_req_free(struct devlink_selftests_run_req *req);
5221
5222 static inline void
5223 devlink_selftests_run_req_set_bus_name(struct devlink_selftests_run_req *req,
5224                                        const char *bus_name)
5225 {
5226         free(req->bus_name);
5227         req->_present.bus_name_len = strlen(bus_name);
5228         req->bus_name = malloc(req->_present.bus_name_len + 1);
5229         memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
5230         req->bus_name[req->_present.bus_name_len] = 0;
5231 }
5232 static inline void
5233 devlink_selftests_run_req_set_dev_name(struct devlink_selftests_run_req *req,
5234                                        const char *dev_name)
5235 {
5236         free(req->dev_name);
5237         req->_present.dev_name_len = strlen(dev_name);
5238         req->dev_name = malloc(req->_present.dev_name_len + 1);
5239         memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
5240         req->dev_name[req->_present.dev_name_len] = 0;
5241 }
5242 static inline void
5243 devlink_selftests_run_req_set_selftests_flash(struct devlink_selftests_run_req *req)
5244 {
5245         req->_present.selftests = 1;
5246         req->selftests._present.flash = 1;
5247 }
5248
5249 /*
5250  * Run device selftest instances.
5251  */
5252 int devlink_selftests_run(struct ynl_sock *ys,
5253                           struct devlink_selftests_run_req *req);
5254
5255 #endif /* _LINUX_DEVLINK_GEN_H */