Merge branch 'devlink-finish-conversion-to-generated-split_ops'

Jiri Pirko says:

====================
devlink: finish conversion to generated split_ops

This patchset converts the remaining genetlink commands to generated
split_ops and removes the existing small_ops arrays entirely
alongside with shared netlink attribute policy.

Patches #1-#6 are just small preparations and small fixes on multiple
              places. Note that couple of patches contain the "Fixes"
              tag but no need to put them into -net tree.
Patch #7 is a simple rename preparation
Patch #8 is the main one in this set and adds actual definitions of cmds
         in to yaml file.
Patches #9-#10 finalize the change removing bits that are no longer in
               use.
====================

Link: https://lore.kernel.org/r/20231021112711.660606-1-jiri@resnulli.us
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

diff --cc tools/net/ynl/generated/devlink-user.h
index f5656bc28db4a12695e405ebba35c45302f25404,9f45cc0d854c52559b8f75492016e66c014d088d..1db4edc36eaa1c2e67d2ca9fa5372ee72c6e8f0b
--- 1/tools/net/ynl/generated/devlink-user.h
--- 2/tools/net/ynl/generated/devlink-user.h
+++ b/tools/net/ynl/generated/devlink-user.h
@@@ -809,21 -994,19 +994,19 @@@ devlink_sb_get_req_dump_set_dev_name(st
        req->dev_name[req->_present.dev_name_len] = 0;
  }
  
- struct devlink_sb_tc_pool_bind_get_list {
-       struct devlink_sb_tc_pool_bind_get_list *next;
-       struct devlink_sb_tc_pool_bind_get_rsp obj __attribute__((aligned(8)));
+ struct devlink_sb_get_list {
+       struct devlink_sb_get_list *next;
 -      struct devlink_sb_get_rsp obj __attribute__ ((aligned (8)));
++      struct devlink_sb_get_rsp obj __attribute__((aligned(8)));
  };
  
- void
- devlink_sb_tc_pool_bind_get_list_free(struct devlink_sb_tc_pool_bind_get_list *rsp);
+ void devlink_sb_get_list_free(struct devlink_sb_get_list *rsp);
  
- struct devlink_sb_tc_pool_bind_get_list *
- devlink_sb_tc_pool_bind_get_dump(struct ynl_sock *ys,
-                                struct devlink_sb_tc_pool_bind_get_req_dump *req);
+ struct devlink_sb_get_list *
+ devlink_sb_get_dump(struct ynl_sock *ys, struct devlink_sb_get_req_dump *req);
  
- /* ============== DEVLINK_CMD_PARAM_GET ============== */
- /* DEVLINK_CMD_PARAM_GET - do */
- struct devlink_param_get_req {
+ /* ============== DEVLINK_CMD_SB_POOL_GET ============== */
+ /* DEVLINK_CMD_SB_POOL_GET - do */
+ struct devlink_sb_pool_get_req {
        struct {
                __u32 bus_name_len;
                __u32 dev_name_len;
@@@ -903,16 -1095,2307 +1095,2307 @@@ struct devlink_sb_pool_get_req_dump 
        char *dev_name;
  };
  
- static inline struct devlink_param_get_req_dump *
- devlink_param_get_req_dump_alloc(void)
+ static inline struct devlink_sb_pool_get_req_dump *
+ devlink_sb_pool_get_req_dump_alloc(void)
  {
-       return calloc(1, sizeof(struct devlink_param_get_req_dump));
+       return calloc(1, sizeof(struct devlink_sb_pool_get_req_dump));
+ }
+ void
+ devlink_sb_pool_get_req_dump_free(struct devlink_sb_pool_get_req_dump *req);
+ 
+ static inline void
+ devlink_sb_pool_get_req_dump_set_bus_name(struct devlink_sb_pool_get_req_dump *req,
+                                         const char *bus_name)
+ {
+       free(req->bus_name);
+       req->_present.bus_name_len = strlen(bus_name);
+       req->bus_name = malloc(req->_present.bus_name_len + 1);
+       memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
+       req->bus_name[req->_present.bus_name_len] = 0;
+ }
+ static inline void
+ devlink_sb_pool_get_req_dump_set_dev_name(struct devlink_sb_pool_get_req_dump *req,
+                                         const char *dev_name)
+ {
+       free(req->dev_name);
+       req->_present.dev_name_len = strlen(dev_name);
+       req->dev_name = malloc(req->_present.dev_name_len + 1);
+       memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
+       req->dev_name[req->_present.dev_name_len] = 0;
+ }
+ 
+ struct devlink_sb_pool_get_list {
+       struct devlink_sb_pool_get_list *next;
 -      struct devlink_sb_pool_get_rsp obj __attribute__ ((aligned (8)));
++      struct devlink_sb_pool_get_rsp obj __attribute__((aligned(8)));
+ };
+ 
+ void devlink_sb_pool_get_list_free(struct devlink_sb_pool_get_list *rsp);
+ 
+ struct devlink_sb_pool_get_list *
+ devlink_sb_pool_get_dump(struct ynl_sock *ys,
+                        struct devlink_sb_pool_get_req_dump *req);
+ 
+ /* ============== DEVLINK_CMD_SB_POOL_SET ============== */
+ /* DEVLINK_CMD_SB_POOL_SET - do */
+ struct devlink_sb_pool_set_req {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 sb_index:1;
+               __u32 sb_pool_index:1;
+               __u32 sb_pool_threshold_type:1;
+               __u32 sb_pool_size:1;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       __u32 sb_index;
+       __u16 sb_pool_index;
+       enum devlink_sb_threshold_type sb_pool_threshold_type;
+       __u32 sb_pool_size;
+ };
+ 
+ static inline struct devlink_sb_pool_set_req *
+ devlink_sb_pool_set_req_alloc(void)
+ {
+       return calloc(1, sizeof(struct devlink_sb_pool_set_req));
+ }
+ void devlink_sb_pool_set_req_free(struct devlink_sb_pool_set_req *req);
+ 
+ static inline void
+ devlink_sb_pool_set_req_set_bus_name(struct devlink_sb_pool_set_req *req,
+                                    const char *bus_name)
+ {
+       free(req->bus_name);
+       req->_present.bus_name_len = strlen(bus_name);
+       req->bus_name = malloc(req->_present.bus_name_len + 1);
+       memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
+       req->bus_name[req->_present.bus_name_len] = 0;
+ }
+ static inline void
+ devlink_sb_pool_set_req_set_dev_name(struct devlink_sb_pool_set_req *req,
+                                    const char *dev_name)
+ {
+       free(req->dev_name);
+       req->_present.dev_name_len = strlen(dev_name);
+       req->dev_name = malloc(req->_present.dev_name_len + 1);
+       memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
+       req->dev_name[req->_present.dev_name_len] = 0;
+ }
+ static inline void
+ devlink_sb_pool_set_req_set_sb_index(struct devlink_sb_pool_set_req *req,
+                                    __u32 sb_index)
+ {
+       req->_present.sb_index = 1;
+       req->sb_index = sb_index;
+ }
+ static inline void
+ devlink_sb_pool_set_req_set_sb_pool_index(struct devlink_sb_pool_set_req *req,
+                                         __u16 sb_pool_index)
+ {
+       req->_present.sb_pool_index = 1;
+       req->sb_pool_index = sb_pool_index;
+ }
+ static inline void
+ devlink_sb_pool_set_req_set_sb_pool_threshold_type(struct devlink_sb_pool_set_req *req,
+                                                  enum devlink_sb_threshold_type sb_pool_threshold_type)
+ {
+       req->_present.sb_pool_threshold_type = 1;
+       req->sb_pool_threshold_type = sb_pool_threshold_type;
+ }
+ static inline void
+ devlink_sb_pool_set_req_set_sb_pool_size(struct devlink_sb_pool_set_req *req,
+                                        __u32 sb_pool_size)
+ {
+       req->_present.sb_pool_size = 1;
+       req->sb_pool_size = sb_pool_size;
+ }
+ 
+ /*
+  * Set shared buffer pool instances.
+  */
+ int devlink_sb_pool_set(struct ynl_sock *ys,
+                       struct devlink_sb_pool_set_req *req);
+ 
+ /* ============== DEVLINK_CMD_SB_PORT_POOL_GET ============== */
+ /* DEVLINK_CMD_SB_PORT_POOL_GET - do */
+ struct devlink_sb_port_pool_get_req {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 port_index:1;
+               __u32 sb_index:1;
+               __u32 sb_pool_index:1;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       __u32 port_index;
+       __u32 sb_index;
+       __u16 sb_pool_index;
+ };
+ 
+ static inline struct devlink_sb_port_pool_get_req *
+ devlink_sb_port_pool_get_req_alloc(void)
+ {
+       return calloc(1, sizeof(struct devlink_sb_port_pool_get_req));
+ }
+ void
+ devlink_sb_port_pool_get_req_free(struct devlink_sb_port_pool_get_req *req);
+ 
+ static inline void
+ devlink_sb_port_pool_get_req_set_bus_name(struct devlink_sb_port_pool_get_req *req,
+                                         const char *bus_name)
+ {
+       free(req->bus_name);
+       req->_present.bus_name_len = strlen(bus_name);
+       req->bus_name = malloc(req->_present.bus_name_len + 1);
+       memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
+       req->bus_name[req->_present.bus_name_len] = 0;
+ }
+ static inline void
+ devlink_sb_port_pool_get_req_set_dev_name(struct devlink_sb_port_pool_get_req *req,
+                                         const char *dev_name)
+ {
+       free(req->dev_name);
+       req->_present.dev_name_len = strlen(dev_name);
+       req->dev_name = malloc(req->_present.dev_name_len + 1);
+       memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
+       req->dev_name[req->_present.dev_name_len] = 0;
+ }
+ static inline void
+ devlink_sb_port_pool_get_req_set_port_index(struct devlink_sb_port_pool_get_req *req,
+                                           __u32 port_index)
+ {
+       req->_present.port_index = 1;
+       req->port_index = port_index;
+ }
+ static inline void
+ devlink_sb_port_pool_get_req_set_sb_index(struct devlink_sb_port_pool_get_req *req,
+                                         __u32 sb_index)
+ {
+       req->_present.sb_index = 1;
+       req->sb_index = sb_index;
+ }
+ static inline void
+ devlink_sb_port_pool_get_req_set_sb_pool_index(struct devlink_sb_port_pool_get_req *req,
+                                              __u16 sb_pool_index)
+ {
+       req->_present.sb_pool_index = 1;
+       req->sb_pool_index = sb_pool_index;
+ }
+ 
+ struct devlink_sb_port_pool_get_rsp {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 port_index:1;
+               __u32 sb_index:1;
+               __u32 sb_pool_index:1;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       __u32 port_index;
+       __u32 sb_index;
+       __u16 sb_pool_index;
+ };
+ 
+ void
+ devlink_sb_port_pool_get_rsp_free(struct devlink_sb_port_pool_get_rsp *rsp);
+ 
+ /*
+  * Get shared buffer port-pool combinations and threshold.
+  */
+ struct devlink_sb_port_pool_get_rsp *
+ devlink_sb_port_pool_get(struct ynl_sock *ys,
+                        struct devlink_sb_port_pool_get_req *req);
+ 
+ /* DEVLINK_CMD_SB_PORT_POOL_GET - dump */
+ struct devlink_sb_port_pool_get_req_dump {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+ };
+ 
+ static inline struct devlink_sb_port_pool_get_req_dump *
+ devlink_sb_port_pool_get_req_dump_alloc(void)
+ {
+       return calloc(1, sizeof(struct devlink_sb_port_pool_get_req_dump));
+ }
+ void
+ devlink_sb_port_pool_get_req_dump_free(struct devlink_sb_port_pool_get_req_dump *req);
+ 
+ static inline void
+ devlink_sb_port_pool_get_req_dump_set_bus_name(struct devlink_sb_port_pool_get_req_dump *req,
+                                              const char *bus_name)
+ {
+       free(req->bus_name);
+       req->_present.bus_name_len = strlen(bus_name);
+       req->bus_name = malloc(req->_present.bus_name_len + 1);
+       memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
+       req->bus_name[req->_present.bus_name_len] = 0;
+ }
+ static inline void
+ devlink_sb_port_pool_get_req_dump_set_dev_name(struct devlink_sb_port_pool_get_req_dump *req,
+                                              const char *dev_name)
+ {
+       free(req->dev_name);
+       req->_present.dev_name_len = strlen(dev_name);
+       req->dev_name = malloc(req->_present.dev_name_len + 1);
+       memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
+       req->dev_name[req->_present.dev_name_len] = 0;
+ }
+ 
+ struct devlink_sb_port_pool_get_list {
+       struct devlink_sb_port_pool_get_list *next;
 -      struct devlink_sb_port_pool_get_rsp obj __attribute__ ((aligned (8)));
++      struct devlink_sb_port_pool_get_rsp obj __attribute__((aligned(8)));
+ };
+ 
+ void
+ devlink_sb_port_pool_get_list_free(struct devlink_sb_port_pool_get_list *rsp);
+ 
+ struct devlink_sb_port_pool_get_list *
+ devlink_sb_port_pool_get_dump(struct ynl_sock *ys,
+                             struct devlink_sb_port_pool_get_req_dump *req);
+ 
+ /* ============== DEVLINK_CMD_SB_PORT_POOL_SET ============== */
+ /* DEVLINK_CMD_SB_PORT_POOL_SET - do */
+ struct devlink_sb_port_pool_set_req {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 port_index:1;
+               __u32 sb_index:1;
+               __u32 sb_pool_index:1;
+               __u32 sb_threshold:1;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       __u32 port_index;
+       __u32 sb_index;
+       __u16 sb_pool_index;
+       __u32 sb_threshold;
+ };
+ 
+ static inline struct devlink_sb_port_pool_set_req *
+ devlink_sb_port_pool_set_req_alloc(void)
+ {
+       return calloc(1, sizeof(struct devlink_sb_port_pool_set_req));
+ }
+ void
+ devlink_sb_port_pool_set_req_free(struct devlink_sb_port_pool_set_req *req);
+ 
+ static inline void
+ devlink_sb_port_pool_set_req_set_bus_name(struct devlink_sb_port_pool_set_req *req,
+                                         const char *bus_name)
+ {
+       free(req->bus_name);
+       req->_present.bus_name_len = strlen(bus_name);
+       req->bus_name = malloc(req->_present.bus_name_len + 1);
+       memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
+       req->bus_name[req->_present.bus_name_len] = 0;
+ }
+ static inline void
+ devlink_sb_port_pool_set_req_set_dev_name(struct devlink_sb_port_pool_set_req *req,
+                                         const char *dev_name)
+ {
+       free(req->dev_name);
+       req->_present.dev_name_len = strlen(dev_name);
+       req->dev_name = malloc(req->_present.dev_name_len + 1);
+       memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
+       req->dev_name[req->_present.dev_name_len] = 0;
+ }
+ static inline void
+ devlink_sb_port_pool_set_req_set_port_index(struct devlink_sb_port_pool_set_req *req,
+                                           __u32 port_index)
+ {
+       req->_present.port_index = 1;
+       req->port_index = port_index;
+ }
+ static inline void
+ devlink_sb_port_pool_set_req_set_sb_index(struct devlink_sb_port_pool_set_req *req,
+                                         __u32 sb_index)
+ {
+       req->_present.sb_index = 1;
+       req->sb_index = sb_index;
+ }
+ static inline void
+ devlink_sb_port_pool_set_req_set_sb_pool_index(struct devlink_sb_port_pool_set_req *req,
+                                              __u16 sb_pool_index)
+ {
+       req->_present.sb_pool_index = 1;
+       req->sb_pool_index = sb_pool_index;
+ }
+ static inline void
+ devlink_sb_port_pool_set_req_set_sb_threshold(struct devlink_sb_port_pool_set_req *req,
+                                             __u32 sb_threshold)
+ {
+       req->_present.sb_threshold = 1;
+       req->sb_threshold = sb_threshold;
+ }
+ 
+ /*
+  * Set shared buffer port-pool combinations and threshold.
+  */
+ int devlink_sb_port_pool_set(struct ynl_sock *ys,
+                            struct devlink_sb_port_pool_set_req *req);
+ 
+ /* ============== DEVLINK_CMD_SB_TC_POOL_BIND_GET ============== */
+ /* DEVLINK_CMD_SB_TC_POOL_BIND_GET - do */
+ struct devlink_sb_tc_pool_bind_get_req {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 port_index:1;
+               __u32 sb_index:1;
+               __u32 sb_pool_type:1;
+               __u32 sb_tc_index:1;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       __u32 port_index;
+       __u32 sb_index;
+       enum devlink_sb_pool_type sb_pool_type;
+       __u16 sb_tc_index;
+ };
+ 
+ static inline struct devlink_sb_tc_pool_bind_get_req *
+ devlink_sb_tc_pool_bind_get_req_alloc(void)
+ {
+       return calloc(1, sizeof(struct devlink_sb_tc_pool_bind_get_req));
+ }
+ void
+ devlink_sb_tc_pool_bind_get_req_free(struct devlink_sb_tc_pool_bind_get_req *req);
+ 
+ static inline void
+ devlink_sb_tc_pool_bind_get_req_set_bus_name(struct devlink_sb_tc_pool_bind_get_req *req,
+                                            const char *bus_name)
+ {
+       free(req->bus_name);
+       req->_present.bus_name_len = strlen(bus_name);
+       req->bus_name = malloc(req->_present.bus_name_len + 1);
+       memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
+       req->bus_name[req->_present.bus_name_len] = 0;
+ }
+ static inline void
+ devlink_sb_tc_pool_bind_get_req_set_dev_name(struct devlink_sb_tc_pool_bind_get_req *req,
+                                            const char *dev_name)
+ {
+       free(req->dev_name);
+       req->_present.dev_name_len = strlen(dev_name);
+       req->dev_name = malloc(req->_present.dev_name_len + 1);
+       memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
+       req->dev_name[req->_present.dev_name_len] = 0;
+ }
+ static inline void
+ devlink_sb_tc_pool_bind_get_req_set_port_index(struct devlink_sb_tc_pool_bind_get_req *req,
+                                              __u32 port_index)
+ {
+       req->_present.port_index = 1;
+       req->port_index = port_index;
+ }
+ static inline void
+ devlink_sb_tc_pool_bind_get_req_set_sb_index(struct devlink_sb_tc_pool_bind_get_req *req,
+                                            __u32 sb_index)
+ {
+       req->_present.sb_index = 1;
+       req->sb_index = sb_index;
+ }
+ static inline void
+ devlink_sb_tc_pool_bind_get_req_set_sb_pool_type(struct devlink_sb_tc_pool_bind_get_req *req,
+                                                enum devlink_sb_pool_type sb_pool_type)
+ {
+       req->_present.sb_pool_type = 1;
+       req->sb_pool_type = sb_pool_type;
+ }
+ static inline void
+ devlink_sb_tc_pool_bind_get_req_set_sb_tc_index(struct devlink_sb_tc_pool_bind_get_req *req,
+                                               __u16 sb_tc_index)
+ {
+       req->_present.sb_tc_index = 1;
+       req->sb_tc_index = sb_tc_index;
+ }
+ 
+ struct devlink_sb_tc_pool_bind_get_rsp {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 port_index:1;
+               __u32 sb_index:1;
+               __u32 sb_pool_type:1;
+               __u32 sb_tc_index:1;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       __u32 port_index;
+       __u32 sb_index;
+       enum devlink_sb_pool_type sb_pool_type;
+       __u16 sb_tc_index;
+ };
+ 
+ void
+ devlink_sb_tc_pool_bind_get_rsp_free(struct devlink_sb_tc_pool_bind_get_rsp *rsp);
+ 
+ /*
+  * Get shared buffer port-TC to pool bindings and threshold.
+  */
+ struct devlink_sb_tc_pool_bind_get_rsp *
+ devlink_sb_tc_pool_bind_get(struct ynl_sock *ys,
+                           struct devlink_sb_tc_pool_bind_get_req *req);
+ 
+ /* DEVLINK_CMD_SB_TC_POOL_BIND_GET - dump */
+ struct devlink_sb_tc_pool_bind_get_req_dump {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+ };
+ 
+ static inline struct devlink_sb_tc_pool_bind_get_req_dump *
+ devlink_sb_tc_pool_bind_get_req_dump_alloc(void)
+ {
+       return calloc(1, sizeof(struct devlink_sb_tc_pool_bind_get_req_dump));
+ }
+ void
+ devlink_sb_tc_pool_bind_get_req_dump_free(struct devlink_sb_tc_pool_bind_get_req_dump *req);
+ 
+ static inline void
+ devlink_sb_tc_pool_bind_get_req_dump_set_bus_name(struct devlink_sb_tc_pool_bind_get_req_dump *req,
+                                                 const char *bus_name)
+ {
+       free(req->bus_name);
+       req->_present.bus_name_len = strlen(bus_name);
+       req->bus_name = malloc(req->_present.bus_name_len + 1);
+       memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
+       req->bus_name[req->_present.bus_name_len] = 0;
+ }
+ static inline void
+ devlink_sb_tc_pool_bind_get_req_dump_set_dev_name(struct devlink_sb_tc_pool_bind_get_req_dump *req,
+                                                 const char *dev_name)
+ {
+       free(req->dev_name);
+       req->_present.dev_name_len = strlen(dev_name);
+       req->dev_name = malloc(req->_present.dev_name_len + 1);
+       memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
+       req->dev_name[req->_present.dev_name_len] = 0;
+ }
+ 
+ struct devlink_sb_tc_pool_bind_get_list {
+       struct devlink_sb_tc_pool_bind_get_list *next;
 -      struct devlink_sb_tc_pool_bind_get_rsp obj __attribute__ ((aligned (8)));
++      struct devlink_sb_tc_pool_bind_get_rsp obj __attribute__((aligned(8)));
+ };
+ 
+ void
+ devlink_sb_tc_pool_bind_get_list_free(struct devlink_sb_tc_pool_bind_get_list *rsp);
+ 
+ struct devlink_sb_tc_pool_bind_get_list *
+ devlink_sb_tc_pool_bind_get_dump(struct ynl_sock *ys,
+                                struct devlink_sb_tc_pool_bind_get_req_dump *req);
+ 
+ /* ============== DEVLINK_CMD_SB_TC_POOL_BIND_SET ============== */
+ /* DEVLINK_CMD_SB_TC_POOL_BIND_SET - do */
+ struct devlink_sb_tc_pool_bind_set_req {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 port_index:1;
+               __u32 sb_index:1;
+               __u32 sb_pool_index:1;
+               __u32 sb_pool_type:1;
+               __u32 sb_tc_index:1;
+               __u32 sb_threshold:1;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       __u32 port_index;
+       __u32 sb_index;
+       __u16 sb_pool_index;
+       enum devlink_sb_pool_type sb_pool_type;
+       __u16 sb_tc_index;
+       __u32 sb_threshold;
+ };
+ 
+ static inline struct devlink_sb_tc_pool_bind_set_req *
+ devlink_sb_tc_pool_bind_set_req_alloc(void)
+ {
+       return calloc(1, sizeof(struct devlink_sb_tc_pool_bind_set_req));
+ }
+ void
+ devlink_sb_tc_pool_bind_set_req_free(struct devlink_sb_tc_pool_bind_set_req *req);
+ 
+ static inline void
+ devlink_sb_tc_pool_bind_set_req_set_bus_name(struct devlink_sb_tc_pool_bind_set_req *req,
+                                            const char *bus_name)
+ {
+       free(req->bus_name);
+       req->_present.bus_name_len = strlen(bus_name);
+       req->bus_name = malloc(req->_present.bus_name_len + 1);
+       memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
+       req->bus_name[req->_present.bus_name_len] = 0;
+ }
+ static inline void
+ devlink_sb_tc_pool_bind_set_req_set_dev_name(struct devlink_sb_tc_pool_bind_set_req *req,
+                                            const char *dev_name)
+ {
+       free(req->dev_name);
+       req->_present.dev_name_len = strlen(dev_name);
+       req->dev_name = malloc(req->_present.dev_name_len + 1);
+       memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
+       req->dev_name[req->_present.dev_name_len] = 0;
+ }
+ static inline void
+ devlink_sb_tc_pool_bind_set_req_set_port_index(struct devlink_sb_tc_pool_bind_set_req *req,
+                                              __u32 port_index)
+ {
+       req->_present.port_index = 1;
+       req->port_index = port_index;
+ }
+ static inline void
+ devlink_sb_tc_pool_bind_set_req_set_sb_index(struct devlink_sb_tc_pool_bind_set_req *req,
+                                            __u32 sb_index)
+ {
+       req->_present.sb_index = 1;
+       req->sb_index = sb_index;
+ }
+ static inline void
+ devlink_sb_tc_pool_bind_set_req_set_sb_pool_index(struct devlink_sb_tc_pool_bind_set_req *req,
+                                                 __u16 sb_pool_index)
+ {
+       req->_present.sb_pool_index = 1;
+       req->sb_pool_index = sb_pool_index;
+ }
+ static inline void
+ devlink_sb_tc_pool_bind_set_req_set_sb_pool_type(struct devlink_sb_tc_pool_bind_set_req *req,
+                                                enum devlink_sb_pool_type sb_pool_type)
+ {
+       req->_present.sb_pool_type = 1;
+       req->sb_pool_type = sb_pool_type;
+ }
+ static inline void
+ devlink_sb_tc_pool_bind_set_req_set_sb_tc_index(struct devlink_sb_tc_pool_bind_set_req *req,
+                                               __u16 sb_tc_index)
+ {
+       req->_present.sb_tc_index = 1;
+       req->sb_tc_index = sb_tc_index;
+ }
+ static inline void
+ devlink_sb_tc_pool_bind_set_req_set_sb_threshold(struct devlink_sb_tc_pool_bind_set_req *req,
+                                                __u32 sb_threshold)
+ {
+       req->_present.sb_threshold = 1;
+       req->sb_threshold = sb_threshold;
+ }
+ 
+ /*
+  * Set shared buffer port-TC to pool bindings and threshold.
+  */
+ int devlink_sb_tc_pool_bind_set(struct ynl_sock *ys,
+                               struct devlink_sb_tc_pool_bind_set_req *req);
+ 
+ /* ============== DEVLINK_CMD_SB_OCC_SNAPSHOT ============== */
+ /* DEVLINK_CMD_SB_OCC_SNAPSHOT - do */
+ struct devlink_sb_occ_snapshot_req {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 sb_index:1;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       __u32 sb_index;
+ };
+ 
+ static inline struct devlink_sb_occ_snapshot_req *
+ devlink_sb_occ_snapshot_req_alloc(void)
+ {
+       return calloc(1, sizeof(struct devlink_sb_occ_snapshot_req));
+ }
+ void devlink_sb_occ_snapshot_req_free(struct devlink_sb_occ_snapshot_req *req);
+ 
+ static inline void
+ devlink_sb_occ_snapshot_req_set_bus_name(struct devlink_sb_occ_snapshot_req *req,
+                                        const char *bus_name)
+ {
+       free(req->bus_name);
+       req->_present.bus_name_len = strlen(bus_name);
+       req->bus_name = malloc(req->_present.bus_name_len + 1);
+       memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
+       req->bus_name[req->_present.bus_name_len] = 0;
+ }
+ static inline void
+ devlink_sb_occ_snapshot_req_set_dev_name(struct devlink_sb_occ_snapshot_req *req,
+                                        const char *dev_name)
+ {
+       free(req->dev_name);
+       req->_present.dev_name_len = strlen(dev_name);
+       req->dev_name = malloc(req->_present.dev_name_len + 1);
+       memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
+       req->dev_name[req->_present.dev_name_len] = 0;
+ }
+ static inline void
+ devlink_sb_occ_snapshot_req_set_sb_index(struct devlink_sb_occ_snapshot_req *req,
+                                        __u32 sb_index)
+ {
+       req->_present.sb_index = 1;
+       req->sb_index = sb_index;
+ }
+ 
+ /*
+  * Take occupancy snapshot of shared buffer.
+  */
+ int devlink_sb_occ_snapshot(struct ynl_sock *ys,
+                           struct devlink_sb_occ_snapshot_req *req);
+ 
+ /* ============== DEVLINK_CMD_SB_OCC_MAX_CLEAR ============== */
+ /* DEVLINK_CMD_SB_OCC_MAX_CLEAR - do */
+ struct devlink_sb_occ_max_clear_req {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 sb_index:1;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       __u32 sb_index;
+ };
+ 
+ static inline struct devlink_sb_occ_max_clear_req *
+ devlink_sb_occ_max_clear_req_alloc(void)
+ {
+       return calloc(1, sizeof(struct devlink_sb_occ_max_clear_req));
+ }
+ void
+ devlink_sb_occ_max_clear_req_free(struct devlink_sb_occ_max_clear_req *req);
+ 
+ static inline void
+ devlink_sb_occ_max_clear_req_set_bus_name(struct devlink_sb_occ_max_clear_req *req,
+                                         const char *bus_name)
+ {
+       free(req->bus_name);
+       req->_present.bus_name_len = strlen(bus_name);
+       req->bus_name = malloc(req->_present.bus_name_len + 1);
+       memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
+       req->bus_name[req->_present.bus_name_len] = 0;
+ }
+ static inline void
+ devlink_sb_occ_max_clear_req_set_dev_name(struct devlink_sb_occ_max_clear_req *req,
+                                         const char *dev_name)
+ {
+       free(req->dev_name);
+       req->_present.dev_name_len = strlen(dev_name);
+       req->dev_name = malloc(req->_present.dev_name_len + 1);
+       memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
+       req->dev_name[req->_present.dev_name_len] = 0;
+ }
+ static inline void
+ devlink_sb_occ_max_clear_req_set_sb_index(struct devlink_sb_occ_max_clear_req *req,
+                                         __u32 sb_index)
+ {
+       req->_present.sb_index = 1;
+       req->sb_index = sb_index;
+ }
+ 
+ /*
+  * Clear occupancy watermarks of shared buffer.
+  */
+ int devlink_sb_occ_max_clear(struct ynl_sock *ys,
+                            struct devlink_sb_occ_max_clear_req *req);
+ 
+ /* ============== DEVLINK_CMD_ESWITCH_GET ============== */
+ /* DEVLINK_CMD_ESWITCH_GET - do */
+ struct devlink_eswitch_get_req {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+ };
+ 
+ static inline struct devlink_eswitch_get_req *
+ devlink_eswitch_get_req_alloc(void)
+ {
+       return calloc(1, sizeof(struct devlink_eswitch_get_req));
+ }
+ void devlink_eswitch_get_req_free(struct devlink_eswitch_get_req *req);
+ 
+ static inline void
+ devlink_eswitch_get_req_set_bus_name(struct devlink_eswitch_get_req *req,
+                                    const char *bus_name)
+ {
+       free(req->bus_name);
+       req->_present.bus_name_len = strlen(bus_name);
+       req->bus_name = malloc(req->_present.bus_name_len + 1);
+       memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
+       req->bus_name[req->_present.bus_name_len] = 0;
+ }
+ static inline void
+ devlink_eswitch_get_req_set_dev_name(struct devlink_eswitch_get_req *req,
+                                    const char *dev_name)
+ {
+       free(req->dev_name);
+       req->_present.dev_name_len = strlen(dev_name);
+       req->dev_name = malloc(req->_present.dev_name_len + 1);
+       memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
+       req->dev_name[req->_present.dev_name_len] = 0;
+ }
+ 
+ struct devlink_eswitch_get_rsp {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 eswitch_mode:1;
+               __u32 eswitch_inline_mode:1;
+               __u32 eswitch_encap_mode:1;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       enum devlink_eswitch_mode eswitch_mode;
+       enum devlink_eswitch_inline_mode eswitch_inline_mode;
+       enum devlink_eswitch_encap_mode eswitch_encap_mode;
+ };
+ 
+ void devlink_eswitch_get_rsp_free(struct devlink_eswitch_get_rsp *rsp);
+ 
+ /*
+  * Get eswitch attributes.
+  */
+ struct devlink_eswitch_get_rsp *
+ devlink_eswitch_get(struct ynl_sock *ys, struct devlink_eswitch_get_req *req);
+ 
+ /* ============== DEVLINK_CMD_ESWITCH_SET ============== */
+ /* DEVLINK_CMD_ESWITCH_SET - do */
+ struct devlink_eswitch_set_req {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 eswitch_mode:1;
+               __u32 eswitch_inline_mode:1;
+               __u32 eswitch_encap_mode:1;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       enum devlink_eswitch_mode eswitch_mode;
+       enum devlink_eswitch_inline_mode eswitch_inline_mode;
+       enum devlink_eswitch_encap_mode eswitch_encap_mode;
+ };
+ 
+ static inline struct devlink_eswitch_set_req *
+ devlink_eswitch_set_req_alloc(void)
+ {
+       return calloc(1, sizeof(struct devlink_eswitch_set_req));
+ }
+ void devlink_eswitch_set_req_free(struct devlink_eswitch_set_req *req);
+ 
+ static inline void
+ devlink_eswitch_set_req_set_bus_name(struct devlink_eswitch_set_req *req,
+                                    const char *bus_name)
+ {
+       free(req->bus_name);
+       req->_present.bus_name_len = strlen(bus_name);
+       req->bus_name = malloc(req->_present.bus_name_len + 1);
+       memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
+       req->bus_name[req->_present.bus_name_len] = 0;
+ }
+ static inline void
+ devlink_eswitch_set_req_set_dev_name(struct devlink_eswitch_set_req *req,
+                                    const char *dev_name)
+ {
+       free(req->dev_name);
+       req->_present.dev_name_len = strlen(dev_name);
+       req->dev_name = malloc(req->_present.dev_name_len + 1);
+       memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
+       req->dev_name[req->_present.dev_name_len] = 0;
+ }
+ static inline void
+ devlink_eswitch_set_req_set_eswitch_mode(struct devlink_eswitch_set_req *req,
+                                        enum devlink_eswitch_mode eswitch_mode)
+ {
+       req->_present.eswitch_mode = 1;
+       req->eswitch_mode = eswitch_mode;
+ }
+ static inline void
+ devlink_eswitch_set_req_set_eswitch_inline_mode(struct devlink_eswitch_set_req *req,
+                                               enum devlink_eswitch_inline_mode eswitch_inline_mode)
+ {
+       req->_present.eswitch_inline_mode = 1;
+       req->eswitch_inline_mode = eswitch_inline_mode;
+ }
+ static inline void
+ devlink_eswitch_set_req_set_eswitch_encap_mode(struct devlink_eswitch_set_req *req,
+                                              enum devlink_eswitch_encap_mode eswitch_encap_mode)
+ {
+       req->_present.eswitch_encap_mode = 1;
+       req->eswitch_encap_mode = eswitch_encap_mode;
+ }
+ 
+ /*
+  * Set eswitch attributes.
+  */
+ int devlink_eswitch_set(struct ynl_sock *ys,
+                       struct devlink_eswitch_set_req *req);
+ 
+ /* ============== DEVLINK_CMD_DPIPE_TABLE_GET ============== */
+ /* DEVLINK_CMD_DPIPE_TABLE_GET - do */
+ struct devlink_dpipe_table_get_req {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 dpipe_table_name_len;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       char *dpipe_table_name;
+ };
+ 
+ static inline struct devlink_dpipe_table_get_req *
+ devlink_dpipe_table_get_req_alloc(void)
+ {
+       return calloc(1, sizeof(struct devlink_dpipe_table_get_req));
+ }
+ void devlink_dpipe_table_get_req_free(struct devlink_dpipe_table_get_req *req);
+ 
+ static inline void
+ devlink_dpipe_table_get_req_set_bus_name(struct devlink_dpipe_table_get_req *req,
+                                        const char *bus_name)
+ {
+       free(req->bus_name);
+       req->_present.bus_name_len = strlen(bus_name);
+       req->bus_name = malloc(req->_present.bus_name_len + 1);
+       memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
+       req->bus_name[req->_present.bus_name_len] = 0;
+ }
+ static inline void
+ devlink_dpipe_table_get_req_set_dev_name(struct devlink_dpipe_table_get_req *req,
+                                        const char *dev_name)
+ {
+       free(req->dev_name);
+       req->_present.dev_name_len = strlen(dev_name);
+       req->dev_name = malloc(req->_present.dev_name_len + 1);
+       memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
+       req->dev_name[req->_present.dev_name_len] = 0;
+ }
+ static inline void
+ devlink_dpipe_table_get_req_set_dpipe_table_name(struct devlink_dpipe_table_get_req *req,
+                                                const char *dpipe_table_name)
+ {
+       free(req->dpipe_table_name);
+       req->_present.dpipe_table_name_len = strlen(dpipe_table_name);
+       req->dpipe_table_name = malloc(req->_present.dpipe_table_name_len + 1);
+       memcpy(req->dpipe_table_name, dpipe_table_name, req->_present.dpipe_table_name_len);
+       req->dpipe_table_name[req->_present.dpipe_table_name_len] = 0;
+ }
+ 
+ struct devlink_dpipe_table_get_rsp {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 dpipe_tables:1;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       struct devlink_dl_dpipe_tables dpipe_tables;
+ };
+ 
+ void devlink_dpipe_table_get_rsp_free(struct devlink_dpipe_table_get_rsp *rsp);
+ 
+ /*
+  * Get dpipe table attributes.
+  */
+ struct devlink_dpipe_table_get_rsp *
+ devlink_dpipe_table_get(struct ynl_sock *ys,
+                       struct devlink_dpipe_table_get_req *req);
+ 
+ /* ============== DEVLINK_CMD_DPIPE_ENTRIES_GET ============== */
+ /* DEVLINK_CMD_DPIPE_ENTRIES_GET - do */
+ struct devlink_dpipe_entries_get_req {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 dpipe_table_name_len;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       char *dpipe_table_name;
+ };
+ 
+ static inline struct devlink_dpipe_entries_get_req *
+ devlink_dpipe_entries_get_req_alloc(void)
+ {
+       return calloc(1, sizeof(struct devlink_dpipe_entries_get_req));
+ }
+ void
+ devlink_dpipe_entries_get_req_free(struct devlink_dpipe_entries_get_req *req);
+ 
+ static inline void
+ devlink_dpipe_entries_get_req_set_bus_name(struct devlink_dpipe_entries_get_req *req,
+                                          const char *bus_name)
+ {
+       free(req->bus_name);
+       req->_present.bus_name_len = strlen(bus_name);
+       req->bus_name = malloc(req->_present.bus_name_len + 1);
+       memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
+       req->bus_name[req->_present.bus_name_len] = 0;
+ }
+ static inline void
+ devlink_dpipe_entries_get_req_set_dev_name(struct devlink_dpipe_entries_get_req *req,
+                                          const char *dev_name)
+ {
+       free(req->dev_name);
+       req->_present.dev_name_len = strlen(dev_name);
+       req->dev_name = malloc(req->_present.dev_name_len + 1);
+       memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
+       req->dev_name[req->_present.dev_name_len] = 0;
+ }
+ static inline void
+ devlink_dpipe_entries_get_req_set_dpipe_table_name(struct devlink_dpipe_entries_get_req *req,
+                                                  const char *dpipe_table_name)
+ {
+       free(req->dpipe_table_name);
+       req->_present.dpipe_table_name_len = strlen(dpipe_table_name);
+       req->dpipe_table_name = malloc(req->_present.dpipe_table_name_len + 1);
+       memcpy(req->dpipe_table_name, dpipe_table_name, req->_present.dpipe_table_name_len);
+       req->dpipe_table_name[req->_present.dpipe_table_name_len] = 0;
+ }
+ 
+ struct devlink_dpipe_entries_get_rsp {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 dpipe_entries:1;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       struct devlink_dl_dpipe_entries dpipe_entries;
+ };
+ 
+ void
+ devlink_dpipe_entries_get_rsp_free(struct devlink_dpipe_entries_get_rsp *rsp);
+ 
+ /*
+  * Get dpipe entries attributes.
+  */
+ struct devlink_dpipe_entries_get_rsp *
+ devlink_dpipe_entries_get(struct ynl_sock *ys,
+                         struct devlink_dpipe_entries_get_req *req);
+ 
+ /* ============== DEVLINK_CMD_DPIPE_HEADERS_GET ============== */
+ /* DEVLINK_CMD_DPIPE_HEADERS_GET - do */
+ struct devlink_dpipe_headers_get_req {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+ };
+ 
+ static inline struct devlink_dpipe_headers_get_req *
+ devlink_dpipe_headers_get_req_alloc(void)
+ {
+       return calloc(1, sizeof(struct devlink_dpipe_headers_get_req));
+ }
+ void
+ devlink_dpipe_headers_get_req_free(struct devlink_dpipe_headers_get_req *req);
+ 
+ static inline void
+ devlink_dpipe_headers_get_req_set_bus_name(struct devlink_dpipe_headers_get_req *req,
+                                          const char *bus_name)
+ {
+       free(req->bus_name);
+       req->_present.bus_name_len = strlen(bus_name);
+       req->bus_name = malloc(req->_present.bus_name_len + 1);
+       memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
+       req->bus_name[req->_present.bus_name_len] = 0;
+ }
+ static inline void
+ devlink_dpipe_headers_get_req_set_dev_name(struct devlink_dpipe_headers_get_req *req,
+                                          const char *dev_name)
+ {
+       free(req->dev_name);
+       req->_present.dev_name_len = strlen(dev_name);
+       req->dev_name = malloc(req->_present.dev_name_len + 1);
+       memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
+       req->dev_name[req->_present.dev_name_len] = 0;
+ }
+ 
+ struct devlink_dpipe_headers_get_rsp {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 dpipe_headers:1;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       struct devlink_dl_dpipe_headers dpipe_headers;
+ };
+ 
+ void
+ devlink_dpipe_headers_get_rsp_free(struct devlink_dpipe_headers_get_rsp *rsp);
+ 
+ /*
+  * Get dpipe headers attributes.
+  */
+ struct devlink_dpipe_headers_get_rsp *
+ devlink_dpipe_headers_get(struct ynl_sock *ys,
+                         struct devlink_dpipe_headers_get_req *req);
+ 
+ /* ============== DEVLINK_CMD_DPIPE_TABLE_COUNTERS_SET ============== */
+ /* DEVLINK_CMD_DPIPE_TABLE_COUNTERS_SET - do */
+ struct devlink_dpipe_table_counters_set_req {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 dpipe_table_name_len;
+               __u32 dpipe_table_counters_enabled:1;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       char *dpipe_table_name;
+       __u8 dpipe_table_counters_enabled;
+ };
+ 
+ static inline struct devlink_dpipe_table_counters_set_req *
+ devlink_dpipe_table_counters_set_req_alloc(void)
+ {
+       return calloc(1, sizeof(struct devlink_dpipe_table_counters_set_req));
+ }
+ void
+ devlink_dpipe_table_counters_set_req_free(struct devlink_dpipe_table_counters_set_req *req);
+ 
+ static inline void
+ devlink_dpipe_table_counters_set_req_set_bus_name(struct devlink_dpipe_table_counters_set_req *req,
+                                                 const char *bus_name)
+ {
+       free(req->bus_name);
+       req->_present.bus_name_len = strlen(bus_name);
+       req->bus_name = malloc(req->_present.bus_name_len + 1);
+       memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
+       req->bus_name[req->_present.bus_name_len] = 0;
+ }
+ static inline void
+ devlink_dpipe_table_counters_set_req_set_dev_name(struct devlink_dpipe_table_counters_set_req *req,
+                                                 const char *dev_name)
+ {
+       free(req->dev_name);
+       req->_present.dev_name_len = strlen(dev_name);
+       req->dev_name = malloc(req->_present.dev_name_len + 1);
+       memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
+       req->dev_name[req->_present.dev_name_len] = 0;
+ }
+ static inline void
+ devlink_dpipe_table_counters_set_req_set_dpipe_table_name(struct devlink_dpipe_table_counters_set_req *req,
+                                                         const char *dpipe_table_name)
+ {
+       free(req->dpipe_table_name);
+       req->_present.dpipe_table_name_len = strlen(dpipe_table_name);
+       req->dpipe_table_name = malloc(req->_present.dpipe_table_name_len + 1);
+       memcpy(req->dpipe_table_name, dpipe_table_name, req->_present.dpipe_table_name_len);
+       req->dpipe_table_name[req->_present.dpipe_table_name_len] = 0;
+ }
+ static inline void
+ devlink_dpipe_table_counters_set_req_set_dpipe_table_counters_enabled(struct devlink_dpipe_table_counters_set_req *req,
+                                                                     __u8 dpipe_table_counters_enabled)
+ {
+       req->_present.dpipe_table_counters_enabled = 1;
+       req->dpipe_table_counters_enabled = dpipe_table_counters_enabled;
+ }
+ 
+ /*
+  * Set dpipe counter attributes.
+  */
+ int devlink_dpipe_table_counters_set(struct ynl_sock *ys,
+                                    struct devlink_dpipe_table_counters_set_req *req);
+ 
+ /* ============== DEVLINK_CMD_RESOURCE_SET ============== */
+ /* DEVLINK_CMD_RESOURCE_SET - do */
+ struct devlink_resource_set_req {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 resource_id:1;
+               __u32 resource_size:1;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       __u64 resource_id;
+       __u64 resource_size;
+ };
+ 
+ static inline struct devlink_resource_set_req *
+ devlink_resource_set_req_alloc(void)
+ {
+       return calloc(1, sizeof(struct devlink_resource_set_req));
+ }
+ void devlink_resource_set_req_free(struct devlink_resource_set_req *req);
+ 
+ static inline void
+ devlink_resource_set_req_set_bus_name(struct devlink_resource_set_req *req,
+                                     const char *bus_name)
+ {
+       free(req->bus_name);
+       req->_present.bus_name_len = strlen(bus_name);
+       req->bus_name = malloc(req->_present.bus_name_len + 1);
+       memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
+       req->bus_name[req->_present.bus_name_len] = 0;
+ }
+ static inline void
+ devlink_resource_set_req_set_dev_name(struct devlink_resource_set_req *req,
+                                     const char *dev_name)
+ {
+       free(req->dev_name);
+       req->_present.dev_name_len = strlen(dev_name);
+       req->dev_name = malloc(req->_present.dev_name_len + 1);
+       memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
+       req->dev_name[req->_present.dev_name_len] = 0;
+ }
+ static inline void
+ devlink_resource_set_req_set_resource_id(struct devlink_resource_set_req *req,
+                                        __u64 resource_id)
+ {
+       req->_present.resource_id = 1;
+       req->resource_id = resource_id;
+ }
+ static inline void
+ devlink_resource_set_req_set_resource_size(struct devlink_resource_set_req *req,
+                                          __u64 resource_size)
+ {
+       req->_present.resource_size = 1;
+       req->resource_size = resource_size;
+ }
+ 
+ /*
+  * Set resource attributes.
+  */
+ int devlink_resource_set(struct ynl_sock *ys,
+                        struct devlink_resource_set_req *req);
+ 
+ /* ============== DEVLINK_CMD_RESOURCE_DUMP ============== */
+ /* DEVLINK_CMD_RESOURCE_DUMP - do */
+ struct devlink_resource_dump_req {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+ };
+ 
+ static inline struct devlink_resource_dump_req *
+ devlink_resource_dump_req_alloc(void)
+ {
+       return calloc(1, sizeof(struct devlink_resource_dump_req));
+ }
+ void devlink_resource_dump_req_free(struct devlink_resource_dump_req *req);
+ 
+ static inline void
+ devlink_resource_dump_req_set_bus_name(struct devlink_resource_dump_req *req,
+                                      const char *bus_name)
+ {
+       free(req->bus_name);
+       req->_present.bus_name_len = strlen(bus_name);
+       req->bus_name = malloc(req->_present.bus_name_len + 1);
+       memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
+       req->bus_name[req->_present.bus_name_len] = 0;
+ }
+ static inline void
+ devlink_resource_dump_req_set_dev_name(struct devlink_resource_dump_req *req,
+                                      const char *dev_name)
+ {
+       free(req->dev_name);
+       req->_present.dev_name_len = strlen(dev_name);
+       req->dev_name = malloc(req->_present.dev_name_len + 1);
+       memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
+       req->dev_name[req->_present.dev_name_len] = 0;
+ }
+ 
+ struct devlink_resource_dump_rsp {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 resource_list:1;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       struct devlink_dl_resource_list resource_list;
+ };
+ 
+ void devlink_resource_dump_rsp_free(struct devlink_resource_dump_rsp *rsp);
+ 
+ /*
+  * Get resource attributes.
+  */
+ struct devlink_resource_dump_rsp *
+ devlink_resource_dump(struct ynl_sock *ys,
+                     struct devlink_resource_dump_req *req);
+ 
+ /* ============== DEVLINK_CMD_RELOAD ============== */
+ /* DEVLINK_CMD_RELOAD - do */
+ struct devlink_reload_req {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 reload_action:1;
+               __u32 reload_limits:1;
+               __u32 netns_pid:1;
+               __u32 netns_fd:1;
+               __u32 netns_id:1;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       enum devlink_reload_action reload_action;
+       struct nla_bitfield32 reload_limits;
+       __u32 netns_pid;
+       __u32 netns_fd;
+       __u32 netns_id;
+ };
+ 
+ static inline struct devlink_reload_req *devlink_reload_req_alloc(void)
+ {
+       return calloc(1, sizeof(struct devlink_reload_req));
+ }
+ void devlink_reload_req_free(struct devlink_reload_req *req);
+ 
+ static inline void
+ devlink_reload_req_set_bus_name(struct devlink_reload_req *req,
+                               const char *bus_name)
+ {
+       free(req->bus_name);
+       req->_present.bus_name_len = strlen(bus_name);
+       req->bus_name = malloc(req->_present.bus_name_len + 1);
+       memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
+       req->bus_name[req->_present.bus_name_len] = 0;
+ }
+ static inline void
+ devlink_reload_req_set_dev_name(struct devlink_reload_req *req,
+                               const char *dev_name)
+ {
+       free(req->dev_name);
+       req->_present.dev_name_len = strlen(dev_name);
+       req->dev_name = malloc(req->_present.dev_name_len + 1);
+       memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
+       req->dev_name[req->_present.dev_name_len] = 0;
+ }
+ static inline void
+ devlink_reload_req_set_reload_action(struct devlink_reload_req *req,
+                                    enum devlink_reload_action reload_action)
+ {
+       req->_present.reload_action = 1;
+       req->reload_action = reload_action;
+ }
+ static inline void
+ devlink_reload_req_set_reload_limits(struct devlink_reload_req *req,
+                                    struct nla_bitfield32 *reload_limits)
+ {
+       req->_present.reload_limits = 1;
+       memcpy(&req->reload_limits, reload_limits, sizeof(struct nla_bitfield32));
+ }
+ static inline void
+ devlink_reload_req_set_netns_pid(struct devlink_reload_req *req,
+                                __u32 netns_pid)
+ {
+       req->_present.netns_pid = 1;
+       req->netns_pid = netns_pid;
+ }
+ static inline void
+ devlink_reload_req_set_netns_fd(struct devlink_reload_req *req, __u32 netns_fd)
+ {
+       req->_present.netns_fd = 1;
+       req->netns_fd = netns_fd;
+ }
+ static inline void
+ devlink_reload_req_set_netns_id(struct devlink_reload_req *req, __u32 netns_id)
+ {
+       req->_present.netns_id = 1;
+       req->netns_id = netns_id;
+ }
+ 
+ struct devlink_reload_rsp {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 reload_actions_performed:1;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       struct nla_bitfield32 reload_actions_performed;
+ };
+ 
+ void devlink_reload_rsp_free(struct devlink_reload_rsp *rsp);
+ 
+ /*
+  * Reload devlink.
+  */
+ struct devlink_reload_rsp *
+ devlink_reload(struct ynl_sock *ys, struct devlink_reload_req *req);
+ 
+ /* ============== DEVLINK_CMD_PARAM_GET ============== */
+ /* DEVLINK_CMD_PARAM_GET - do */
+ struct devlink_param_get_req {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 param_name_len;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       char *param_name;
+ };
+ 
+ static inline struct devlink_param_get_req *devlink_param_get_req_alloc(void)
+ {
+       return calloc(1, sizeof(struct devlink_param_get_req));
+ }
+ void devlink_param_get_req_free(struct devlink_param_get_req *req);
+ 
+ static inline void
+ devlink_param_get_req_set_bus_name(struct devlink_param_get_req *req,
+                                  const char *bus_name)
+ {
+       free(req->bus_name);
+       req->_present.bus_name_len = strlen(bus_name);
+       req->bus_name = malloc(req->_present.bus_name_len + 1);
+       memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
+       req->bus_name[req->_present.bus_name_len] = 0;
+ }
+ static inline void
+ devlink_param_get_req_set_dev_name(struct devlink_param_get_req *req,
+                                  const char *dev_name)
+ {
+       free(req->dev_name);
+       req->_present.dev_name_len = strlen(dev_name);
+       req->dev_name = malloc(req->_present.dev_name_len + 1);
+       memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
+       req->dev_name[req->_present.dev_name_len] = 0;
+ }
+ static inline void
+ devlink_param_get_req_set_param_name(struct devlink_param_get_req *req,
+                                    const char *param_name)
+ {
+       free(req->param_name);
+       req->_present.param_name_len = strlen(param_name);
+       req->param_name = malloc(req->_present.param_name_len + 1);
+       memcpy(req->param_name, param_name, req->_present.param_name_len);
+       req->param_name[req->_present.param_name_len] = 0;
+ }
+ 
+ struct devlink_param_get_rsp {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 param_name_len;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       char *param_name;
+ };
+ 
+ void devlink_param_get_rsp_free(struct devlink_param_get_rsp *rsp);
+ 
+ /*
+  * Get param instances.
+  */
+ struct devlink_param_get_rsp *
+ devlink_param_get(struct ynl_sock *ys, struct devlink_param_get_req *req);
+ 
+ /* DEVLINK_CMD_PARAM_GET - dump */
+ struct devlink_param_get_req_dump {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+ };
+ 
+ static inline struct devlink_param_get_req_dump *
+ devlink_param_get_req_dump_alloc(void)
+ {
+       return calloc(1, sizeof(struct devlink_param_get_req_dump));
  }
  void devlink_param_get_req_dump_free(struct devlink_param_get_req_dump *req);
  
  static inline void
- devlink_param_get_req_dump_set_bus_name(struct devlink_param_get_req_dump *req,
-                                       const char *bus_name)
+ devlink_param_get_req_dump_set_bus_name(struct devlink_param_get_req_dump *req,
+                                       const char *bus_name)
+ {
+       free(req->bus_name);
+       req->_present.bus_name_len = strlen(bus_name);
+       req->bus_name = malloc(req->_present.bus_name_len + 1);
+       memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
+       req->bus_name[req->_present.bus_name_len] = 0;
+ }
+ static inline void
+ devlink_param_get_req_dump_set_dev_name(struct devlink_param_get_req_dump *req,
+                                       const char *dev_name)
+ {
+       free(req->dev_name);
+       req->_present.dev_name_len = strlen(dev_name);
+       req->dev_name = malloc(req->_present.dev_name_len + 1);
+       memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
+       req->dev_name[req->_present.dev_name_len] = 0;
+ }
+ 
+ struct devlink_param_get_list {
+       struct devlink_param_get_list *next;
 -      struct devlink_param_get_rsp obj __attribute__ ((aligned (8)));
++      struct devlink_param_get_rsp obj __attribute__((aligned(8)));
+ };
+ 
+ void devlink_param_get_list_free(struct devlink_param_get_list *rsp);
+ 
+ struct devlink_param_get_list *
+ devlink_param_get_dump(struct ynl_sock *ys,
+                      struct devlink_param_get_req_dump *req);
+ 
+ /* ============== DEVLINK_CMD_PARAM_SET ============== */
+ /* DEVLINK_CMD_PARAM_SET - do */
+ struct devlink_param_set_req {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 param_name_len;
+               __u32 param_type:1;
+               __u32 param_value_cmode:1;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       char *param_name;
+       __u8 param_type;
+       enum devlink_param_cmode param_value_cmode;
+ };
+ 
+ static inline struct devlink_param_set_req *devlink_param_set_req_alloc(void)
+ {
+       return calloc(1, sizeof(struct devlink_param_set_req));
+ }
+ void devlink_param_set_req_free(struct devlink_param_set_req *req);
+ 
+ static inline void
+ devlink_param_set_req_set_bus_name(struct devlink_param_set_req *req,
+                                  const char *bus_name)
+ {
+       free(req->bus_name);
+       req->_present.bus_name_len = strlen(bus_name);
+       req->bus_name = malloc(req->_present.bus_name_len + 1);
+       memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
+       req->bus_name[req->_present.bus_name_len] = 0;
+ }
+ static inline void
+ devlink_param_set_req_set_dev_name(struct devlink_param_set_req *req,
+                                  const char *dev_name)
+ {
+       free(req->dev_name);
+       req->_present.dev_name_len = strlen(dev_name);
+       req->dev_name = malloc(req->_present.dev_name_len + 1);
+       memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
+       req->dev_name[req->_present.dev_name_len] = 0;
+ }
+ static inline void
+ devlink_param_set_req_set_param_name(struct devlink_param_set_req *req,
+                                    const char *param_name)
+ {
+       free(req->param_name);
+       req->_present.param_name_len = strlen(param_name);
+       req->param_name = malloc(req->_present.param_name_len + 1);
+       memcpy(req->param_name, param_name, req->_present.param_name_len);
+       req->param_name[req->_present.param_name_len] = 0;
+ }
+ static inline void
+ devlink_param_set_req_set_param_type(struct devlink_param_set_req *req,
+                                    __u8 param_type)
+ {
+       req->_present.param_type = 1;
+       req->param_type = param_type;
+ }
+ static inline void
+ devlink_param_set_req_set_param_value_cmode(struct devlink_param_set_req *req,
+                                           enum devlink_param_cmode param_value_cmode)
+ {
+       req->_present.param_value_cmode = 1;
+       req->param_value_cmode = param_value_cmode;
+ }
+ 
+ /*
+  * Set param instances.
+  */
+ int devlink_param_set(struct ynl_sock *ys, struct devlink_param_set_req *req);
+ 
+ /* ============== DEVLINK_CMD_REGION_GET ============== */
+ /* DEVLINK_CMD_REGION_GET - do */
+ struct devlink_region_get_req {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 port_index:1;
+               __u32 region_name_len;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       __u32 port_index;
+       char *region_name;
+ };
+ 
+ static inline struct devlink_region_get_req *devlink_region_get_req_alloc(void)
+ {
+       return calloc(1, sizeof(struct devlink_region_get_req));
+ }
+ void devlink_region_get_req_free(struct devlink_region_get_req *req);
+ 
+ static inline void
+ devlink_region_get_req_set_bus_name(struct devlink_region_get_req *req,
+                                   const char *bus_name)
+ {
+       free(req->bus_name);
+       req->_present.bus_name_len = strlen(bus_name);
+       req->bus_name = malloc(req->_present.bus_name_len + 1);
+       memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
+       req->bus_name[req->_present.bus_name_len] = 0;
+ }
+ static inline void
+ devlink_region_get_req_set_dev_name(struct devlink_region_get_req *req,
+                                   const char *dev_name)
+ {
+       free(req->dev_name);
+       req->_present.dev_name_len = strlen(dev_name);
+       req->dev_name = malloc(req->_present.dev_name_len + 1);
+       memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
+       req->dev_name[req->_present.dev_name_len] = 0;
+ }
+ static inline void
+ devlink_region_get_req_set_port_index(struct devlink_region_get_req *req,
+                                     __u32 port_index)
+ {
+       req->_present.port_index = 1;
+       req->port_index = port_index;
+ }
+ static inline void
+ devlink_region_get_req_set_region_name(struct devlink_region_get_req *req,
+                                      const char *region_name)
+ {
+       free(req->region_name);
+       req->_present.region_name_len = strlen(region_name);
+       req->region_name = malloc(req->_present.region_name_len + 1);
+       memcpy(req->region_name, region_name, req->_present.region_name_len);
+       req->region_name[req->_present.region_name_len] = 0;
+ }
+ 
+ struct devlink_region_get_rsp {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 port_index:1;
+               __u32 region_name_len;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       __u32 port_index;
+       char *region_name;
+ };
+ 
+ void devlink_region_get_rsp_free(struct devlink_region_get_rsp *rsp);
+ 
+ /*
+  * Get region instances.
+  */
+ struct devlink_region_get_rsp *
+ devlink_region_get(struct ynl_sock *ys, struct devlink_region_get_req *req);
+ 
+ /* DEVLINK_CMD_REGION_GET - dump */
+ struct devlink_region_get_req_dump {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+ };
+ 
+ static inline struct devlink_region_get_req_dump *
+ devlink_region_get_req_dump_alloc(void)
+ {
+       return calloc(1, sizeof(struct devlink_region_get_req_dump));
+ }
+ void devlink_region_get_req_dump_free(struct devlink_region_get_req_dump *req);
+ 
+ static inline void
+ devlink_region_get_req_dump_set_bus_name(struct devlink_region_get_req_dump *req,
+                                        const char *bus_name)
+ {
+       free(req->bus_name);
+       req->_present.bus_name_len = strlen(bus_name);
+       req->bus_name = malloc(req->_present.bus_name_len + 1);
+       memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
+       req->bus_name[req->_present.bus_name_len] = 0;
+ }
+ static inline void
+ devlink_region_get_req_dump_set_dev_name(struct devlink_region_get_req_dump *req,
+                                        const char *dev_name)
+ {
+       free(req->dev_name);
+       req->_present.dev_name_len = strlen(dev_name);
+       req->dev_name = malloc(req->_present.dev_name_len + 1);
+       memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
+       req->dev_name[req->_present.dev_name_len] = 0;
+ }
+ 
+ struct devlink_region_get_list {
+       struct devlink_region_get_list *next;
 -      struct devlink_region_get_rsp obj __attribute__ ((aligned (8)));
++      struct devlink_region_get_rsp obj __attribute__((aligned(8)));
+ };
+ 
+ void devlink_region_get_list_free(struct devlink_region_get_list *rsp);
+ 
+ struct devlink_region_get_list *
+ devlink_region_get_dump(struct ynl_sock *ys,
+                       struct devlink_region_get_req_dump *req);
+ 
+ /* ============== DEVLINK_CMD_REGION_NEW ============== */
+ /* DEVLINK_CMD_REGION_NEW - do */
+ struct devlink_region_new_req {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 port_index:1;
+               __u32 region_name_len;
+               __u32 region_snapshot_id:1;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       __u32 port_index;
+       char *region_name;
+       __u32 region_snapshot_id;
+ };
+ 
+ static inline struct devlink_region_new_req *devlink_region_new_req_alloc(void)
+ {
+       return calloc(1, sizeof(struct devlink_region_new_req));
+ }
+ void devlink_region_new_req_free(struct devlink_region_new_req *req);
+ 
+ static inline void
+ devlink_region_new_req_set_bus_name(struct devlink_region_new_req *req,
+                                   const char *bus_name)
+ {
+       free(req->bus_name);
+       req->_present.bus_name_len = strlen(bus_name);
+       req->bus_name = malloc(req->_present.bus_name_len + 1);
+       memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
+       req->bus_name[req->_present.bus_name_len] = 0;
+ }
+ static inline void
+ devlink_region_new_req_set_dev_name(struct devlink_region_new_req *req,
+                                   const char *dev_name)
+ {
+       free(req->dev_name);
+       req->_present.dev_name_len = strlen(dev_name);
+       req->dev_name = malloc(req->_present.dev_name_len + 1);
+       memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
+       req->dev_name[req->_present.dev_name_len] = 0;
+ }
+ static inline void
+ devlink_region_new_req_set_port_index(struct devlink_region_new_req *req,
+                                     __u32 port_index)
+ {
+       req->_present.port_index = 1;
+       req->port_index = port_index;
+ }
+ static inline void
+ devlink_region_new_req_set_region_name(struct devlink_region_new_req *req,
+                                      const char *region_name)
+ {
+       free(req->region_name);
+       req->_present.region_name_len = strlen(region_name);
+       req->region_name = malloc(req->_present.region_name_len + 1);
+       memcpy(req->region_name, region_name, req->_present.region_name_len);
+       req->region_name[req->_present.region_name_len] = 0;
+ }
+ static inline void
+ devlink_region_new_req_set_region_snapshot_id(struct devlink_region_new_req *req,
+                                             __u32 region_snapshot_id)
+ {
+       req->_present.region_snapshot_id = 1;
+       req->region_snapshot_id = region_snapshot_id;
+ }
+ 
+ struct devlink_region_new_rsp {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 port_index:1;
+               __u32 region_name_len;
+               __u32 region_snapshot_id:1;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       __u32 port_index;
+       char *region_name;
+       __u32 region_snapshot_id;
+ };
+ 
+ void devlink_region_new_rsp_free(struct devlink_region_new_rsp *rsp);
+ 
+ /*
+  * Create region snapshot.
+  */
+ struct devlink_region_new_rsp *
+ devlink_region_new(struct ynl_sock *ys, struct devlink_region_new_req *req);
+ 
+ /* ============== DEVLINK_CMD_REGION_DEL ============== */
+ /* DEVLINK_CMD_REGION_DEL - do */
+ struct devlink_region_del_req {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 port_index:1;
+               __u32 region_name_len;
+               __u32 region_snapshot_id:1;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       __u32 port_index;
+       char *region_name;
+       __u32 region_snapshot_id;
+ };
+ 
+ static inline struct devlink_region_del_req *devlink_region_del_req_alloc(void)
+ {
+       return calloc(1, sizeof(struct devlink_region_del_req));
+ }
+ void devlink_region_del_req_free(struct devlink_region_del_req *req);
+ 
+ static inline void
+ devlink_region_del_req_set_bus_name(struct devlink_region_del_req *req,
+                                   const char *bus_name)
+ {
+       free(req->bus_name);
+       req->_present.bus_name_len = strlen(bus_name);
+       req->bus_name = malloc(req->_present.bus_name_len + 1);
+       memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
+       req->bus_name[req->_present.bus_name_len] = 0;
+ }
+ static inline void
+ devlink_region_del_req_set_dev_name(struct devlink_region_del_req *req,
+                                   const char *dev_name)
+ {
+       free(req->dev_name);
+       req->_present.dev_name_len = strlen(dev_name);
+       req->dev_name = malloc(req->_present.dev_name_len + 1);
+       memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
+       req->dev_name[req->_present.dev_name_len] = 0;
+ }
+ static inline void
+ devlink_region_del_req_set_port_index(struct devlink_region_del_req *req,
+                                     __u32 port_index)
+ {
+       req->_present.port_index = 1;
+       req->port_index = port_index;
+ }
+ static inline void
+ devlink_region_del_req_set_region_name(struct devlink_region_del_req *req,
+                                      const char *region_name)
+ {
+       free(req->region_name);
+       req->_present.region_name_len = strlen(region_name);
+       req->region_name = malloc(req->_present.region_name_len + 1);
+       memcpy(req->region_name, region_name, req->_present.region_name_len);
+       req->region_name[req->_present.region_name_len] = 0;
+ }
+ static inline void
+ devlink_region_del_req_set_region_snapshot_id(struct devlink_region_del_req *req,
+                                             __u32 region_snapshot_id)
+ {
+       req->_present.region_snapshot_id = 1;
+       req->region_snapshot_id = region_snapshot_id;
+ }
+ 
+ /*
+  * Delete region snapshot.
+  */
+ int devlink_region_del(struct ynl_sock *ys, struct devlink_region_del_req *req);
+ 
+ /* ============== DEVLINK_CMD_REGION_READ ============== */
+ /* DEVLINK_CMD_REGION_READ - dump */
+ struct devlink_region_read_req_dump {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 port_index:1;
+               __u32 region_name_len;
+               __u32 region_snapshot_id:1;
+               __u32 region_direct:1;
+               __u32 region_chunk_addr:1;
+               __u32 region_chunk_len:1;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       __u32 port_index;
+       char *region_name;
+       __u32 region_snapshot_id;
+       __u64 region_chunk_addr;
+       __u64 region_chunk_len;
+ };
+ 
+ static inline struct devlink_region_read_req_dump *
+ devlink_region_read_req_dump_alloc(void)
+ {
+       return calloc(1, sizeof(struct devlink_region_read_req_dump));
+ }
+ void
+ devlink_region_read_req_dump_free(struct devlink_region_read_req_dump *req);
+ 
+ static inline void
+ devlink_region_read_req_dump_set_bus_name(struct devlink_region_read_req_dump *req,
+                                         const char *bus_name)
+ {
+       free(req->bus_name);
+       req->_present.bus_name_len = strlen(bus_name);
+       req->bus_name = malloc(req->_present.bus_name_len + 1);
+       memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
+       req->bus_name[req->_present.bus_name_len] = 0;
+ }
+ static inline void
+ devlink_region_read_req_dump_set_dev_name(struct devlink_region_read_req_dump *req,
+                                         const char *dev_name)
+ {
+       free(req->dev_name);
+       req->_present.dev_name_len = strlen(dev_name);
+       req->dev_name = malloc(req->_present.dev_name_len + 1);
+       memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
+       req->dev_name[req->_present.dev_name_len] = 0;
+ }
+ static inline void
+ devlink_region_read_req_dump_set_port_index(struct devlink_region_read_req_dump *req,
+                                           __u32 port_index)
+ {
+       req->_present.port_index = 1;
+       req->port_index = port_index;
+ }
+ static inline void
+ devlink_region_read_req_dump_set_region_name(struct devlink_region_read_req_dump *req,
+                                            const char *region_name)
+ {
+       free(req->region_name);
+       req->_present.region_name_len = strlen(region_name);
+       req->region_name = malloc(req->_present.region_name_len + 1);
+       memcpy(req->region_name, region_name, req->_present.region_name_len);
+       req->region_name[req->_present.region_name_len] = 0;
+ }
+ static inline void
+ devlink_region_read_req_dump_set_region_snapshot_id(struct devlink_region_read_req_dump *req,
+                                                   __u32 region_snapshot_id)
+ {
+       req->_present.region_snapshot_id = 1;
+       req->region_snapshot_id = region_snapshot_id;
+ }
+ static inline void
+ devlink_region_read_req_dump_set_region_direct(struct devlink_region_read_req_dump *req)
+ {
+       req->_present.region_direct = 1;
+ }
+ static inline void
+ devlink_region_read_req_dump_set_region_chunk_addr(struct devlink_region_read_req_dump *req,
+                                                  __u64 region_chunk_addr)
+ {
+       req->_present.region_chunk_addr = 1;
+       req->region_chunk_addr = region_chunk_addr;
+ }
+ static inline void
+ devlink_region_read_req_dump_set_region_chunk_len(struct devlink_region_read_req_dump *req,
+                                                 __u64 region_chunk_len)
+ {
+       req->_present.region_chunk_len = 1;
+       req->region_chunk_len = region_chunk_len;
+ }
+ 
+ struct devlink_region_read_rsp_dump {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 port_index:1;
+               __u32 region_name_len;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       __u32 port_index;
+       char *region_name;
+ };
+ 
+ struct devlink_region_read_rsp_list {
+       struct devlink_region_read_rsp_list *next;
+       struct devlink_region_read_rsp_dump obj __attribute__((aligned(8)));
+ };
+ 
+ void
+ devlink_region_read_rsp_list_free(struct devlink_region_read_rsp_list *rsp);
+ 
+ struct devlink_region_read_rsp_list *
+ devlink_region_read_dump(struct ynl_sock *ys,
+                        struct devlink_region_read_req_dump *req);
+ 
+ /* ============== DEVLINK_CMD_PORT_PARAM_GET ============== */
+ /* DEVLINK_CMD_PORT_PARAM_GET - do */
+ struct devlink_port_param_get_req {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 port_index:1;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       __u32 port_index;
+ };
+ 
+ static inline struct devlink_port_param_get_req *
+ devlink_port_param_get_req_alloc(void)
+ {
+       return calloc(1, sizeof(struct devlink_port_param_get_req));
+ }
+ void devlink_port_param_get_req_free(struct devlink_port_param_get_req *req);
+ 
+ static inline void
+ devlink_port_param_get_req_set_bus_name(struct devlink_port_param_get_req *req,
+                                       const char *bus_name)
+ {
+       free(req->bus_name);
+       req->_present.bus_name_len = strlen(bus_name);
+       req->bus_name = malloc(req->_present.bus_name_len + 1);
+       memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
+       req->bus_name[req->_present.bus_name_len] = 0;
+ }
+ static inline void
+ devlink_port_param_get_req_set_dev_name(struct devlink_port_param_get_req *req,
+                                       const char *dev_name)
+ {
+       free(req->dev_name);
+       req->_present.dev_name_len = strlen(dev_name);
+       req->dev_name = malloc(req->_present.dev_name_len + 1);
+       memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
+       req->dev_name[req->_present.dev_name_len] = 0;
+ }
+ static inline void
+ devlink_port_param_get_req_set_port_index(struct devlink_port_param_get_req *req,
+                                         __u32 port_index)
+ {
+       req->_present.port_index = 1;
+       req->port_index = port_index;
+ }
+ 
+ struct devlink_port_param_get_rsp {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 port_index:1;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       __u32 port_index;
+ };
+ 
+ void devlink_port_param_get_rsp_free(struct devlink_port_param_get_rsp *rsp);
+ 
+ /*
+  * Get port param instances.
+  */
+ struct devlink_port_param_get_rsp *
+ devlink_port_param_get(struct ynl_sock *ys,
+                      struct devlink_port_param_get_req *req);
+ 
+ /* DEVLINK_CMD_PORT_PARAM_GET - dump */
+ struct devlink_port_param_get_list {
+       struct devlink_port_param_get_list *next;
+       struct devlink_port_param_get_rsp obj __attribute__((aligned(8)));
+ };
+ 
+ void devlink_port_param_get_list_free(struct devlink_port_param_get_list *rsp);
+ 
+ struct devlink_port_param_get_list *
+ devlink_port_param_get_dump(struct ynl_sock *ys);
+ 
+ /* ============== DEVLINK_CMD_PORT_PARAM_SET ============== */
+ /* DEVLINK_CMD_PORT_PARAM_SET - do */
+ struct devlink_port_param_set_req {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 port_index:1;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       __u32 port_index;
+ };
+ 
+ static inline struct devlink_port_param_set_req *
+ devlink_port_param_set_req_alloc(void)
+ {
+       return calloc(1, sizeof(struct devlink_port_param_set_req));
+ }
+ void devlink_port_param_set_req_free(struct devlink_port_param_set_req *req);
+ 
+ static inline void
+ devlink_port_param_set_req_set_bus_name(struct devlink_port_param_set_req *req,
+                                       const char *bus_name)
+ {
+       free(req->bus_name);
+       req->_present.bus_name_len = strlen(bus_name);
+       req->bus_name = malloc(req->_present.bus_name_len + 1);
+       memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
+       req->bus_name[req->_present.bus_name_len] = 0;
+ }
+ static inline void
+ devlink_port_param_set_req_set_dev_name(struct devlink_port_param_set_req *req,
+                                       const char *dev_name)
+ {
+       free(req->dev_name);
+       req->_present.dev_name_len = strlen(dev_name);
+       req->dev_name = malloc(req->_present.dev_name_len + 1);
+       memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
+       req->dev_name[req->_present.dev_name_len] = 0;
+ }
+ static inline void
+ devlink_port_param_set_req_set_port_index(struct devlink_port_param_set_req *req,
+                                         __u32 port_index)
+ {
+       req->_present.port_index = 1;
+       req->port_index = port_index;
+ }
+ 
+ /*
+  * Set port param instances.
+  */
+ int devlink_port_param_set(struct ynl_sock *ys,
+                          struct devlink_port_param_set_req *req);
+ 
+ /* ============== DEVLINK_CMD_INFO_GET ============== */
+ /* DEVLINK_CMD_INFO_GET - do */
+ struct devlink_info_get_req {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+ };
+ 
+ static inline struct devlink_info_get_req *devlink_info_get_req_alloc(void)
+ {
+       return calloc(1, sizeof(struct devlink_info_get_req));
+ }
+ void devlink_info_get_req_free(struct devlink_info_get_req *req);
+ 
+ static inline void
+ devlink_info_get_req_set_bus_name(struct devlink_info_get_req *req,
+                                 const char *bus_name)
+ {
+       free(req->bus_name);
+       req->_present.bus_name_len = strlen(bus_name);
+       req->bus_name = malloc(req->_present.bus_name_len + 1);
+       memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
+       req->bus_name[req->_present.bus_name_len] = 0;
+ }
+ static inline void
+ devlink_info_get_req_set_dev_name(struct devlink_info_get_req *req,
+                                 const char *dev_name)
+ {
+       free(req->dev_name);
+       req->_present.dev_name_len = strlen(dev_name);
+       req->dev_name = malloc(req->_present.dev_name_len + 1);
+       memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
+       req->dev_name[req->_present.dev_name_len] = 0;
+ }
+ 
+ struct devlink_info_get_rsp {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 info_driver_name_len;
+               __u32 info_serial_number_len;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       char *info_driver_name;
+       char *info_serial_number;
+       unsigned int n_info_version_fixed;
+       struct devlink_dl_info_version *info_version_fixed;
+       unsigned int n_info_version_running;
+       struct devlink_dl_info_version *info_version_running;
+       unsigned int n_info_version_stored;
+       struct devlink_dl_info_version *info_version_stored;
+ };
+ 
+ void devlink_info_get_rsp_free(struct devlink_info_get_rsp *rsp);
+ 
+ /*
+  * Get device information, like driver name, hardware and firmware versions etc.
+  */
+ struct devlink_info_get_rsp *
+ devlink_info_get(struct ynl_sock *ys, struct devlink_info_get_req *req);
+ 
+ /* DEVLINK_CMD_INFO_GET - dump */
+ struct devlink_info_get_list {
+       struct devlink_info_get_list *next;
 -      struct devlink_info_get_rsp obj __attribute__ ((aligned (8)));
++      struct devlink_info_get_rsp obj __attribute__((aligned(8)));
+ };
+ 
+ void devlink_info_get_list_free(struct devlink_info_get_list *rsp);
+ 
+ struct devlink_info_get_list *devlink_info_get_dump(struct ynl_sock *ys);
+ 
+ /* ============== DEVLINK_CMD_HEALTH_REPORTER_GET ============== */
+ /* DEVLINK_CMD_HEALTH_REPORTER_GET - do */
+ struct devlink_health_reporter_get_req {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 port_index:1;
+               __u32 health_reporter_name_len;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       __u32 port_index;
+       char *health_reporter_name;
+ };
+ 
+ static inline struct devlink_health_reporter_get_req *
+ devlink_health_reporter_get_req_alloc(void)
+ {
+       return calloc(1, sizeof(struct devlink_health_reporter_get_req));
+ }
+ void
+ devlink_health_reporter_get_req_free(struct devlink_health_reporter_get_req *req);
+ 
+ static inline void
+ devlink_health_reporter_get_req_set_bus_name(struct devlink_health_reporter_get_req *req,
+                                            const char *bus_name)
+ {
+       free(req->bus_name);
+       req->_present.bus_name_len = strlen(bus_name);
+       req->bus_name = malloc(req->_present.bus_name_len + 1);
+       memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
+       req->bus_name[req->_present.bus_name_len] = 0;
+ }
+ static inline void
+ devlink_health_reporter_get_req_set_dev_name(struct devlink_health_reporter_get_req *req,
+                                            const char *dev_name)
+ {
+       free(req->dev_name);
+       req->_present.dev_name_len = strlen(dev_name);
+       req->dev_name = malloc(req->_present.dev_name_len + 1);
+       memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
+       req->dev_name[req->_present.dev_name_len] = 0;
+ }
+ static inline void
+ devlink_health_reporter_get_req_set_port_index(struct devlink_health_reporter_get_req *req,
+                                              __u32 port_index)
+ {
+       req->_present.port_index = 1;
+       req->port_index = port_index;
+ }
+ static inline void
+ devlink_health_reporter_get_req_set_health_reporter_name(struct devlink_health_reporter_get_req *req,
+                                                        const char *health_reporter_name)
+ {
+       free(req->health_reporter_name);
+       req->_present.health_reporter_name_len = strlen(health_reporter_name);
+       req->health_reporter_name = malloc(req->_present.health_reporter_name_len + 1);
+       memcpy(req->health_reporter_name, health_reporter_name, req->_present.health_reporter_name_len);
+       req->health_reporter_name[req->_present.health_reporter_name_len] = 0;
+ }
+ 
+ struct devlink_health_reporter_get_rsp {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 port_index:1;
+               __u32 health_reporter_name_len;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       __u32 port_index;
+       char *health_reporter_name;
+ };
+ 
+ void
+ devlink_health_reporter_get_rsp_free(struct devlink_health_reporter_get_rsp *rsp);
+ 
+ /*
+  * Get health reporter instances.
+  */
+ struct devlink_health_reporter_get_rsp *
+ devlink_health_reporter_get(struct ynl_sock *ys,
+                           struct devlink_health_reporter_get_req *req);
+ 
+ /* DEVLINK_CMD_HEALTH_REPORTER_GET - dump */
+ struct devlink_health_reporter_get_req_dump {
+       struct {
+               __u32 bus_name_len;
+               __u32 dev_name_len;
+               __u32 port_index:1;
+       } _present;
+ 
+       char *bus_name;
+       char *dev_name;
+       __u32 port_index;
+ };
+ 
+ static inline struct devlink_health_reporter_get_req_dump *
+ devlink_health_reporter_get_req_dump_alloc(void)
+ {
+       return calloc(1, sizeof(struct devlink_health_reporter_get_req_dump));
+ }
+ void
+ devlink_health_reporter_get_req_dump_free(struct devlink_health_reporter_get_req_dump *req);
+ 
+ static inline void
+ devlink_health_reporter_get_req_dump_set_bus_name(struct devlink_health_reporter_get_req_dump *req,
+                                                 const char *bus_name)
  {
        free(req->bus_name);
        req->_present.bus_name_len = strlen(bus_name);
@@@ -930,21 -3413,29 +3413,29 @@@ devlink_health_reporter_get_req_dump_se
        memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
        req->dev_name[req->_present.dev_name_len] = 0;
  }
+ static inline void
+ devlink_health_reporter_get_req_dump_set_port_index(struct devlink_health_reporter_get_req_dump *req,
+                                                   __u32 port_index)
+ {
+       req->_present.port_index = 1;
+       req->port_index = port_index;
+ }
  
- struct devlink_param_get_list {
-       struct devlink_param_get_list *next;
-       struct devlink_param_get_rsp obj __attribute__((aligned(8)));
+ struct devlink_health_reporter_get_list {
+       struct devlink_health_reporter_get_list *next;
 -      struct devlink_health_reporter_get_rsp obj __attribute__ ((aligned (8)));
++      struct devlink_health_reporter_get_rsp obj __attribute__((aligned(8)));
  };
  
- void devlink_param_get_list_free(struct devlink_param_get_list *rsp);
+ void
+ devlink_health_reporter_get_list_free(struct devlink_health_reporter_get_list *rsp);
  
- struct devlink_param_get_list *
- devlink_param_get_dump(struct ynl_sock *ys,
-                      struct devlink_param_get_req_dump *req);
+ struct devlink_health_reporter_get_list *
+ devlink_health_reporter_get_dump(struct ynl_sock *ys,
+                                struct devlink_health_reporter_get_req_dump *req);
  
- /* ============== DEVLINK_CMD_REGION_GET ============== */
- /* DEVLINK_CMD_REGION_GET - do */
- struct devlink_region_get_req {
+ /* ============== DEVLINK_CMD_HEALTH_REPORTER_SET ============== */
+ /* DEVLINK_CMD_HEALTH_REPORTER_SET - do */
+ struct devlink_health_reporter_set_req {
        struct {
                __u32 bus_name_len;
                __u32 dev_name_len;

diff --cc tools/net/ynl/lib/ynl.h
Simple merge

diff --cc tools/net/ynl/ynl-gen-c.py
Simple merge