From: Jakub Kicinski <kuba@kernel.org>
Date: Mon, 23 Oct 2023 23:16:52 +0000 (-0700)
Subject: Merge branch 'devlink-finish-conversion-to-generated-split_ops'
X-Git-Url: http://git.maquefel.me/?a=commitdiff_plain;h=4fb56e3e92bcac98625ebb85bd931785e7779cec;p=linux.git

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>
---

4fb56e3e92bcac98625ebb85bd931785e7779cec
diff --cc tools/net/ynl/generated/devlink-user.h
index f5656bc28db4a,9f45cc0d854c5..1db4edc36eaa1
--- a/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;