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