1 /* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */
2 /* Do not edit directly, auto-generated from: */
3 /* Documentation/netlink/specs/devlink.yaml */
4 /* YNL-GEN user header */
6 #ifndef _LINUX_DEVLINK_GEN_H
7 #define _LINUX_DEVLINK_GEN_H
11 #include <linux/types.h>
12 #include <linux/netlink.h>
13 #include <linux/devlink.h>
17 extern const struct ynl_family ynl_devlink_family;
20 const char *devlink_op_str(int op);
21 const char *devlink_sb_pool_type_str(enum devlink_sb_pool_type value);
22 const char *devlink_port_type_str(enum devlink_port_type value);
23 const char *devlink_port_flavour_str(enum devlink_port_flavour value);
24 const char *devlink_port_fn_state_str(enum devlink_port_fn_state value);
25 const char *devlink_port_fn_opstate_str(enum devlink_port_fn_opstate value);
26 const char *devlink_port_fn_attr_cap_str(enum devlink_port_fn_attr_cap value);
28 devlink_sb_threshold_type_str(enum devlink_sb_threshold_type value);
29 const char *devlink_eswitch_mode_str(enum devlink_eswitch_mode value);
31 devlink_eswitch_inline_mode_str(enum devlink_eswitch_inline_mode value);
33 devlink_eswitch_encap_mode_str(enum devlink_eswitch_encap_mode value);
34 const char *devlink_dpipe_match_type_str(enum devlink_dpipe_match_type value);
36 devlink_dpipe_action_type_str(enum devlink_dpipe_action_type value);
38 devlink_dpipe_field_mapping_type_str(enum devlink_dpipe_field_mapping_type value);
39 const char *devlink_resource_unit_str(enum devlink_resource_unit value);
40 const char *devlink_reload_action_str(enum devlink_reload_action value);
41 const char *devlink_param_cmode_str(enum devlink_param_cmode value);
42 const char *devlink_flash_overwrite_str(enum devlink_flash_overwrite value);
43 const char *devlink_trap_action_str(enum devlink_trap_action value);
45 /* Common nested types */
46 struct devlink_dl_dpipe_match {
48 __u32 dpipe_match_type:1;
49 __u32 dpipe_header_id:1;
50 __u32 dpipe_header_global:1;
51 __u32 dpipe_header_index:1;
52 __u32 dpipe_field_id:1;
55 enum devlink_dpipe_match_type dpipe_match_type;
56 __u32 dpipe_header_id;
57 __u8 dpipe_header_global;
58 __u32 dpipe_header_index;
62 struct devlink_dl_dpipe_match_value {
64 __u32 dpipe_value_len;
65 __u32 dpipe_value_mask_len;
66 __u32 dpipe_value_mapping:1;
69 unsigned int n_dpipe_match;
70 struct devlink_dl_dpipe_match *dpipe_match;
72 void *dpipe_value_mask;
73 __u32 dpipe_value_mapping;
76 struct devlink_dl_dpipe_action {
78 __u32 dpipe_action_type:1;
79 __u32 dpipe_header_id:1;
80 __u32 dpipe_header_global:1;
81 __u32 dpipe_header_index:1;
82 __u32 dpipe_field_id:1;
85 enum devlink_dpipe_action_type dpipe_action_type;
86 __u32 dpipe_header_id;
87 __u8 dpipe_header_global;
88 __u32 dpipe_header_index;
92 struct devlink_dl_dpipe_action_value {
94 __u32 dpipe_value_len;
95 __u32 dpipe_value_mask_len;
96 __u32 dpipe_value_mapping:1;
99 unsigned int n_dpipe_action;
100 struct devlink_dl_dpipe_action *dpipe_action;
102 void *dpipe_value_mask;
103 __u32 dpipe_value_mapping;
106 struct devlink_dl_dpipe_field {
108 __u32 dpipe_field_name_len;
109 __u32 dpipe_field_id:1;
110 __u32 dpipe_field_bitwidth:1;
111 __u32 dpipe_field_mapping_type:1;
114 char *dpipe_field_name;
115 __u32 dpipe_field_id;
116 __u32 dpipe_field_bitwidth;
117 enum devlink_dpipe_field_mapping_type dpipe_field_mapping_type;
120 struct devlink_dl_resource {
122 __u32 resource_name_len;
124 __u32 resource_size:1;
125 __u32 resource_size_new:1;
126 __u32 resource_size_valid:1;
127 __u32 resource_size_min:1;
128 __u32 resource_size_max:1;
129 __u32 resource_size_gran:1;
130 __u32 resource_unit:1;
131 __u32 resource_occ:1;
137 __u64 resource_size_new;
138 __u8 resource_size_valid;
139 __u64 resource_size_min;
140 __u64 resource_size_max;
141 __u64 resource_size_gran;
142 enum devlink_resource_unit resource_unit;
146 struct devlink_dl_info_version {
148 __u32 info_version_name_len;
149 __u32 info_version_value_len;
152 char *info_version_name;
153 char *info_version_value;
156 struct devlink_dl_fmsg {
158 __u32 fmsg_obj_nest_start:1;
159 __u32 fmsg_pair_nest_start:1;
160 __u32 fmsg_arr_nest_start:1;
161 __u32 fmsg_nest_end:1;
162 __u32 fmsg_obj_name_len;
168 struct devlink_dl_port_function {
177 enum devlink_port_fn_state state;
178 enum devlink_port_fn_opstate opstate;
179 struct nla_bitfield32 caps;
182 struct devlink_dl_reload_stats_entry {
184 __u32 reload_stats_limit:1;
185 __u32 reload_stats_value:1;
188 __u8 reload_stats_limit;
189 __u32 reload_stats_value;
192 struct devlink_dl_reload_act_stats {
193 unsigned int n_reload_stats_entry;
194 struct devlink_dl_reload_stats_entry *reload_stats_entry;
197 struct devlink_dl_selftest_id {
203 struct devlink_dl_dpipe_table_matches {
204 unsigned int n_dpipe_match;
205 struct devlink_dl_dpipe_match *dpipe_match;
208 struct devlink_dl_dpipe_table_actions {
209 unsigned int n_dpipe_action;
210 struct devlink_dl_dpipe_action *dpipe_action;
213 struct devlink_dl_dpipe_entry_match_values {
214 unsigned int n_dpipe_match_value;
215 struct devlink_dl_dpipe_match_value *dpipe_match_value;
218 struct devlink_dl_dpipe_entry_action_values {
219 unsigned int n_dpipe_action_value;
220 struct devlink_dl_dpipe_action_value *dpipe_action_value;
223 struct devlink_dl_dpipe_header_fields {
224 unsigned int n_dpipe_field;
225 struct devlink_dl_dpipe_field *dpipe_field;
228 struct devlink_dl_resource_list {
229 unsigned int n_resource;
230 struct devlink_dl_resource *resource;
233 struct devlink_dl_reload_act_info {
235 __u32 reload_action:1;
238 enum devlink_reload_action reload_action;
239 unsigned int n_reload_action_stats;
240 struct devlink_dl_reload_act_stats *reload_action_stats;
243 struct devlink_dl_dpipe_table {
245 __u32 dpipe_table_name_len;
246 __u32 dpipe_table_size:1;
247 __u32 dpipe_table_matches:1;
248 __u32 dpipe_table_actions:1;
249 __u32 dpipe_table_counters_enabled:1;
250 __u32 dpipe_table_resource_id:1;
251 __u32 dpipe_table_resource_units:1;
254 char *dpipe_table_name;
255 __u64 dpipe_table_size;
256 struct devlink_dl_dpipe_table_matches dpipe_table_matches;
257 struct devlink_dl_dpipe_table_actions dpipe_table_actions;
258 __u8 dpipe_table_counters_enabled;
259 __u64 dpipe_table_resource_id;
260 __u64 dpipe_table_resource_units;
263 struct devlink_dl_dpipe_entry {
265 __u32 dpipe_entry_index:1;
266 __u32 dpipe_entry_match_values:1;
267 __u32 dpipe_entry_action_values:1;
268 __u32 dpipe_entry_counter:1;
271 __u64 dpipe_entry_index;
272 struct devlink_dl_dpipe_entry_match_values dpipe_entry_match_values;
273 struct devlink_dl_dpipe_entry_action_values dpipe_entry_action_values;
274 __u64 dpipe_entry_counter;
277 struct devlink_dl_dpipe_header {
279 __u32 dpipe_header_name_len;
280 __u32 dpipe_header_id:1;
281 __u32 dpipe_header_global:1;
282 __u32 dpipe_header_fields:1;
285 char *dpipe_header_name;
286 __u32 dpipe_header_id;
287 __u8 dpipe_header_global;
288 struct devlink_dl_dpipe_header_fields dpipe_header_fields;
291 struct devlink_dl_reload_stats {
292 unsigned int n_reload_action_info;
293 struct devlink_dl_reload_act_info *reload_action_info;
296 struct devlink_dl_dpipe_tables {
297 unsigned int n_dpipe_table;
298 struct devlink_dl_dpipe_table *dpipe_table;
301 struct devlink_dl_dpipe_entries {
302 unsigned int n_dpipe_entry;
303 struct devlink_dl_dpipe_entry *dpipe_entry;
306 struct devlink_dl_dpipe_headers {
307 unsigned int n_dpipe_header;
308 struct devlink_dl_dpipe_header *dpipe_header;
311 struct devlink_dl_dev_stats {
313 __u32 reload_stats:1;
314 __u32 remote_reload_stats:1;
317 struct devlink_dl_reload_stats reload_stats;
318 struct devlink_dl_reload_stats remote_reload_stats;
321 /* ============== DEVLINK_CMD_GET ============== */
322 /* DEVLINK_CMD_GET - do */
323 struct devlink_get_req {
333 static inline struct devlink_get_req *devlink_get_req_alloc(void)
335 return calloc(1, sizeof(struct devlink_get_req));
337 void devlink_get_req_free(struct devlink_get_req *req);
340 devlink_get_req_set_bus_name(struct devlink_get_req *req, const char *bus_name)
343 req->_present.bus_name_len = strlen(bus_name);
344 req->bus_name = malloc(req->_present.bus_name_len + 1);
345 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
346 req->bus_name[req->_present.bus_name_len] = 0;
349 devlink_get_req_set_dev_name(struct devlink_get_req *req, const char *dev_name)
352 req->_present.dev_name_len = strlen(dev_name);
353 req->dev_name = malloc(req->_present.dev_name_len + 1);
354 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
355 req->dev_name[req->_present.dev_name_len] = 0;
358 struct devlink_get_rsp {
362 __u32 reload_failed:1;
369 struct devlink_dl_dev_stats dev_stats;
372 void devlink_get_rsp_free(struct devlink_get_rsp *rsp);
375 * Get devlink instances.
377 struct devlink_get_rsp *
378 devlink_get(struct ynl_sock *ys, struct devlink_get_req *req);
380 /* DEVLINK_CMD_GET - dump */
381 struct devlink_get_list {
382 struct devlink_get_list *next;
383 struct devlink_get_rsp obj __attribute__((aligned(8)));
386 void devlink_get_list_free(struct devlink_get_list *rsp);
388 struct devlink_get_list *devlink_get_dump(struct ynl_sock *ys);
390 /* ============== DEVLINK_CMD_PORT_GET ============== */
391 /* DEVLINK_CMD_PORT_GET - do */
392 struct devlink_port_get_req {
404 static inline struct devlink_port_get_req *devlink_port_get_req_alloc(void)
406 return calloc(1, sizeof(struct devlink_port_get_req));
408 void devlink_port_get_req_free(struct devlink_port_get_req *req);
411 devlink_port_get_req_set_bus_name(struct devlink_port_get_req *req,
412 const char *bus_name)
415 req->_present.bus_name_len = strlen(bus_name);
416 req->bus_name = malloc(req->_present.bus_name_len + 1);
417 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
418 req->bus_name[req->_present.bus_name_len] = 0;
421 devlink_port_get_req_set_dev_name(struct devlink_port_get_req *req,
422 const char *dev_name)
425 req->_present.dev_name_len = strlen(dev_name);
426 req->dev_name = malloc(req->_present.dev_name_len + 1);
427 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
428 req->dev_name[req->_present.dev_name_len] = 0;
431 devlink_port_get_req_set_port_index(struct devlink_port_get_req *req,
434 req->_present.port_index = 1;
435 req->port_index = port_index;
438 struct devlink_port_get_rsp {
450 void devlink_port_get_rsp_free(struct devlink_port_get_rsp *rsp);
453 * Get devlink port instances.
455 struct devlink_port_get_rsp *
456 devlink_port_get(struct ynl_sock *ys, struct devlink_port_get_req *req);
458 /* DEVLINK_CMD_PORT_GET - dump */
459 struct devlink_port_get_req_dump {
469 static inline struct devlink_port_get_req_dump *
470 devlink_port_get_req_dump_alloc(void)
472 return calloc(1, sizeof(struct devlink_port_get_req_dump));
474 void devlink_port_get_req_dump_free(struct devlink_port_get_req_dump *req);
477 devlink_port_get_req_dump_set_bus_name(struct devlink_port_get_req_dump *req,
478 const char *bus_name)
481 req->_present.bus_name_len = strlen(bus_name);
482 req->bus_name = malloc(req->_present.bus_name_len + 1);
483 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
484 req->bus_name[req->_present.bus_name_len] = 0;
487 devlink_port_get_req_dump_set_dev_name(struct devlink_port_get_req_dump *req,
488 const char *dev_name)
491 req->_present.dev_name_len = strlen(dev_name);
492 req->dev_name = malloc(req->_present.dev_name_len + 1);
493 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
494 req->dev_name[req->_present.dev_name_len] = 0;
497 struct devlink_port_get_rsp_dump {
509 struct devlink_port_get_rsp_list {
510 struct devlink_port_get_rsp_list *next;
511 struct devlink_port_get_rsp_dump obj __attribute__((aligned(8)));
514 void devlink_port_get_rsp_list_free(struct devlink_port_get_rsp_list *rsp);
516 struct devlink_port_get_rsp_list *
517 devlink_port_get_dump(struct ynl_sock *ys,
518 struct devlink_port_get_req_dump *req);
520 /* ============== DEVLINK_CMD_PORT_SET ============== */
521 /* DEVLINK_CMD_PORT_SET - do */
522 struct devlink_port_set_req {
528 __u32 port_function:1;
534 enum devlink_port_type port_type;
535 struct devlink_dl_port_function port_function;
538 static inline struct devlink_port_set_req *devlink_port_set_req_alloc(void)
540 return calloc(1, sizeof(struct devlink_port_set_req));
542 void devlink_port_set_req_free(struct devlink_port_set_req *req);
545 devlink_port_set_req_set_bus_name(struct devlink_port_set_req *req,
546 const char *bus_name)
549 req->_present.bus_name_len = strlen(bus_name);
550 req->bus_name = malloc(req->_present.bus_name_len + 1);
551 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
552 req->bus_name[req->_present.bus_name_len] = 0;
555 devlink_port_set_req_set_dev_name(struct devlink_port_set_req *req,
556 const char *dev_name)
559 req->_present.dev_name_len = strlen(dev_name);
560 req->dev_name = malloc(req->_present.dev_name_len + 1);
561 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
562 req->dev_name[req->_present.dev_name_len] = 0;
565 devlink_port_set_req_set_port_index(struct devlink_port_set_req *req,
568 req->_present.port_index = 1;
569 req->port_index = port_index;
572 devlink_port_set_req_set_port_type(struct devlink_port_set_req *req,
573 enum devlink_port_type port_type)
575 req->_present.port_type = 1;
576 req->port_type = port_type;
579 devlink_port_set_req_set_port_function_hw_addr(struct devlink_port_set_req *req,
580 const void *hw_addr, size_t len)
582 free(req->port_function.hw_addr);
583 req->port_function._present.hw_addr_len = len;
584 req->port_function.hw_addr = malloc(req->port_function._present.hw_addr_len);
585 memcpy(req->port_function.hw_addr, hw_addr, req->port_function._present.hw_addr_len);
588 devlink_port_set_req_set_port_function_state(struct devlink_port_set_req *req,
589 enum devlink_port_fn_state state)
591 req->_present.port_function = 1;
592 req->port_function._present.state = 1;
593 req->port_function.state = state;
596 devlink_port_set_req_set_port_function_opstate(struct devlink_port_set_req *req,
597 enum devlink_port_fn_opstate opstate)
599 req->_present.port_function = 1;
600 req->port_function._present.opstate = 1;
601 req->port_function.opstate = opstate;
604 devlink_port_set_req_set_port_function_caps(struct devlink_port_set_req *req,
605 struct nla_bitfield32 *caps)
607 req->_present.port_function = 1;
608 req->port_function._present.caps = 1;
609 memcpy(&req->port_function.caps, caps, sizeof(struct nla_bitfield32));
613 * Set devlink port instances.
615 int devlink_port_set(struct ynl_sock *ys, struct devlink_port_set_req *req);
617 /* ============== DEVLINK_CMD_PORT_NEW ============== */
618 /* DEVLINK_CMD_PORT_NEW - do */
619 struct devlink_port_new_req {
624 __u32 port_flavour:1;
625 __u32 port_pci_pf_number:1;
626 __u32 port_pci_sf_number:1;
627 __u32 port_controller_number:1;
633 enum devlink_port_flavour port_flavour;
634 __u16 port_pci_pf_number;
635 __u32 port_pci_sf_number;
636 __u32 port_controller_number;
639 static inline struct devlink_port_new_req *devlink_port_new_req_alloc(void)
641 return calloc(1, sizeof(struct devlink_port_new_req));
643 void devlink_port_new_req_free(struct devlink_port_new_req *req);
646 devlink_port_new_req_set_bus_name(struct devlink_port_new_req *req,
647 const char *bus_name)
650 req->_present.bus_name_len = strlen(bus_name);
651 req->bus_name = malloc(req->_present.bus_name_len + 1);
652 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
653 req->bus_name[req->_present.bus_name_len] = 0;
656 devlink_port_new_req_set_dev_name(struct devlink_port_new_req *req,
657 const char *dev_name)
660 req->_present.dev_name_len = strlen(dev_name);
661 req->dev_name = malloc(req->_present.dev_name_len + 1);
662 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
663 req->dev_name[req->_present.dev_name_len] = 0;
666 devlink_port_new_req_set_port_index(struct devlink_port_new_req *req,
669 req->_present.port_index = 1;
670 req->port_index = port_index;
673 devlink_port_new_req_set_port_flavour(struct devlink_port_new_req *req,
674 enum devlink_port_flavour port_flavour)
676 req->_present.port_flavour = 1;
677 req->port_flavour = port_flavour;
680 devlink_port_new_req_set_port_pci_pf_number(struct devlink_port_new_req *req,
681 __u16 port_pci_pf_number)
683 req->_present.port_pci_pf_number = 1;
684 req->port_pci_pf_number = port_pci_pf_number;
687 devlink_port_new_req_set_port_pci_sf_number(struct devlink_port_new_req *req,
688 __u32 port_pci_sf_number)
690 req->_present.port_pci_sf_number = 1;
691 req->port_pci_sf_number = port_pci_sf_number;
694 devlink_port_new_req_set_port_controller_number(struct devlink_port_new_req *req,
695 __u32 port_controller_number)
697 req->_present.port_controller_number = 1;
698 req->port_controller_number = port_controller_number;
701 struct devlink_port_new_rsp {
713 void devlink_port_new_rsp_free(struct devlink_port_new_rsp *rsp);
716 * Create devlink port instances.
718 struct devlink_port_new_rsp *
719 devlink_port_new(struct ynl_sock *ys, struct devlink_port_new_req *req);
721 /* ============== DEVLINK_CMD_PORT_DEL ============== */
722 /* DEVLINK_CMD_PORT_DEL - do */
723 struct devlink_port_del_req {
735 static inline struct devlink_port_del_req *devlink_port_del_req_alloc(void)
737 return calloc(1, sizeof(struct devlink_port_del_req));
739 void devlink_port_del_req_free(struct devlink_port_del_req *req);
742 devlink_port_del_req_set_bus_name(struct devlink_port_del_req *req,
743 const char *bus_name)
746 req->_present.bus_name_len = strlen(bus_name);
747 req->bus_name = malloc(req->_present.bus_name_len + 1);
748 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
749 req->bus_name[req->_present.bus_name_len] = 0;
752 devlink_port_del_req_set_dev_name(struct devlink_port_del_req *req,
753 const char *dev_name)
756 req->_present.dev_name_len = strlen(dev_name);
757 req->dev_name = malloc(req->_present.dev_name_len + 1);
758 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
759 req->dev_name[req->_present.dev_name_len] = 0;
762 devlink_port_del_req_set_port_index(struct devlink_port_del_req *req,
765 req->_present.port_index = 1;
766 req->port_index = port_index;
770 * Delete devlink port instances.
772 int devlink_port_del(struct ynl_sock *ys, struct devlink_port_del_req *req);
774 /* ============== DEVLINK_CMD_PORT_SPLIT ============== */
775 /* DEVLINK_CMD_PORT_SPLIT - do */
776 struct devlink_port_split_req {
781 __u32 port_split_count:1;
787 __u32 port_split_count;
790 static inline struct devlink_port_split_req *devlink_port_split_req_alloc(void)
792 return calloc(1, sizeof(struct devlink_port_split_req));
794 void devlink_port_split_req_free(struct devlink_port_split_req *req);
797 devlink_port_split_req_set_bus_name(struct devlink_port_split_req *req,
798 const char *bus_name)
801 req->_present.bus_name_len = strlen(bus_name);
802 req->bus_name = malloc(req->_present.bus_name_len + 1);
803 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
804 req->bus_name[req->_present.bus_name_len] = 0;
807 devlink_port_split_req_set_dev_name(struct devlink_port_split_req *req,
808 const char *dev_name)
811 req->_present.dev_name_len = strlen(dev_name);
812 req->dev_name = malloc(req->_present.dev_name_len + 1);
813 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
814 req->dev_name[req->_present.dev_name_len] = 0;
817 devlink_port_split_req_set_port_index(struct devlink_port_split_req *req,
820 req->_present.port_index = 1;
821 req->port_index = port_index;
824 devlink_port_split_req_set_port_split_count(struct devlink_port_split_req *req,
825 __u32 port_split_count)
827 req->_present.port_split_count = 1;
828 req->port_split_count = port_split_count;
832 * Split devlink port instances.
834 int devlink_port_split(struct ynl_sock *ys, struct devlink_port_split_req *req);
836 /* ============== DEVLINK_CMD_PORT_UNSPLIT ============== */
837 /* DEVLINK_CMD_PORT_UNSPLIT - do */
838 struct devlink_port_unsplit_req {
850 static inline struct devlink_port_unsplit_req *
851 devlink_port_unsplit_req_alloc(void)
853 return calloc(1, sizeof(struct devlink_port_unsplit_req));
855 void devlink_port_unsplit_req_free(struct devlink_port_unsplit_req *req);
858 devlink_port_unsplit_req_set_bus_name(struct devlink_port_unsplit_req *req,
859 const char *bus_name)
862 req->_present.bus_name_len = strlen(bus_name);
863 req->bus_name = malloc(req->_present.bus_name_len + 1);
864 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
865 req->bus_name[req->_present.bus_name_len] = 0;
868 devlink_port_unsplit_req_set_dev_name(struct devlink_port_unsplit_req *req,
869 const char *dev_name)
872 req->_present.dev_name_len = strlen(dev_name);
873 req->dev_name = malloc(req->_present.dev_name_len + 1);
874 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
875 req->dev_name[req->_present.dev_name_len] = 0;
878 devlink_port_unsplit_req_set_port_index(struct devlink_port_unsplit_req *req,
881 req->_present.port_index = 1;
882 req->port_index = port_index;
886 * Unplit devlink port instances.
888 int devlink_port_unsplit(struct ynl_sock *ys,
889 struct devlink_port_unsplit_req *req);
891 /* ============== DEVLINK_CMD_SB_GET ============== */
892 /* DEVLINK_CMD_SB_GET - do */
893 struct devlink_sb_get_req {
905 static inline struct devlink_sb_get_req *devlink_sb_get_req_alloc(void)
907 return calloc(1, sizeof(struct devlink_sb_get_req));
909 void devlink_sb_get_req_free(struct devlink_sb_get_req *req);
912 devlink_sb_get_req_set_bus_name(struct devlink_sb_get_req *req,
913 const char *bus_name)
916 req->_present.bus_name_len = strlen(bus_name);
917 req->bus_name = malloc(req->_present.bus_name_len + 1);
918 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
919 req->bus_name[req->_present.bus_name_len] = 0;
922 devlink_sb_get_req_set_dev_name(struct devlink_sb_get_req *req,
923 const char *dev_name)
926 req->_present.dev_name_len = strlen(dev_name);
927 req->dev_name = malloc(req->_present.dev_name_len + 1);
928 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
929 req->dev_name[req->_present.dev_name_len] = 0;
932 devlink_sb_get_req_set_sb_index(struct devlink_sb_get_req *req, __u32 sb_index)
934 req->_present.sb_index = 1;
935 req->sb_index = sb_index;
938 struct devlink_sb_get_rsp {
950 void devlink_sb_get_rsp_free(struct devlink_sb_get_rsp *rsp);
953 * Get shared buffer instances.
955 struct devlink_sb_get_rsp *
956 devlink_sb_get(struct ynl_sock *ys, struct devlink_sb_get_req *req);
958 /* DEVLINK_CMD_SB_GET - dump */
959 struct devlink_sb_get_req_dump {
969 static inline struct devlink_sb_get_req_dump *
970 devlink_sb_get_req_dump_alloc(void)
972 return calloc(1, sizeof(struct devlink_sb_get_req_dump));
974 void devlink_sb_get_req_dump_free(struct devlink_sb_get_req_dump *req);
977 devlink_sb_get_req_dump_set_bus_name(struct devlink_sb_get_req_dump *req,
978 const char *bus_name)
981 req->_present.bus_name_len = strlen(bus_name);
982 req->bus_name = malloc(req->_present.bus_name_len + 1);
983 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
984 req->bus_name[req->_present.bus_name_len] = 0;
987 devlink_sb_get_req_dump_set_dev_name(struct devlink_sb_get_req_dump *req,
988 const char *dev_name)
991 req->_present.dev_name_len = strlen(dev_name);
992 req->dev_name = malloc(req->_present.dev_name_len + 1);
993 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
994 req->dev_name[req->_present.dev_name_len] = 0;
997 struct devlink_sb_get_list {
998 struct devlink_sb_get_list *next;
999 struct devlink_sb_get_rsp obj __attribute__((aligned(8)));
1002 void devlink_sb_get_list_free(struct devlink_sb_get_list *rsp);
1004 struct devlink_sb_get_list *
1005 devlink_sb_get_dump(struct ynl_sock *ys, struct devlink_sb_get_req_dump *req);
1007 /* ============== DEVLINK_CMD_SB_POOL_GET ============== */
1008 /* DEVLINK_CMD_SB_POOL_GET - do */
1009 struct devlink_sb_pool_get_req {
1014 __u32 sb_pool_index:1;
1020 __u16 sb_pool_index;
1023 static inline struct devlink_sb_pool_get_req *
1024 devlink_sb_pool_get_req_alloc(void)
1026 return calloc(1, sizeof(struct devlink_sb_pool_get_req));
1028 void devlink_sb_pool_get_req_free(struct devlink_sb_pool_get_req *req);
1031 devlink_sb_pool_get_req_set_bus_name(struct devlink_sb_pool_get_req *req,
1032 const char *bus_name)
1034 free(req->bus_name);
1035 req->_present.bus_name_len = strlen(bus_name);
1036 req->bus_name = malloc(req->_present.bus_name_len + 1);
1037 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1038 req->bus_name[req->_present.bus_name_len] = 0;
1041 devlink_sb_pool_get_req_set_dev_name(struct devlink_sb_pool_get_req *req,
1042 const char *dev_name)
1044 free(req->dev_name);
1045 req->_present.dev_name_len = strlen(dev_name);
1046 req->dev_name = malloc(req->_present.dev_name_len + 1);
1047 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1048 req->dev_name[req->_present.dev_name_len] = 0;
1051 devlink_sb_pool_get_req_set_sb_index(struct devlink_sb_pool_get_req *req,
1054 req->_present.sb_index = 1;
1055 req->sb_index = sb_index;
1058 devlink_sb_pool_get_req_set_sb_pool_index(struct devlink_sb_pool_get_req *req,
1059 __u16 sb_pool_index)
1061 req->_present.sb_pool_index = 1;
1062 req->sb_pool_index = sb_pool_index;
1065 struct devlink_sb_pool_get_rsp {
1070 __u32 sb_pool_index:1;
1076 __u16 sb_pool_index;
1079 void devlink_sb_pool_get_rsp_free(struct devlink_sb_pool_get_rsp *rsp);
1082 * Get shared buffer pool instances.
1084 struct devlink_sb_pool_get_rsp *
1085 devlink_sb_pool_get(struct ynl_sock *ys, struct devlink_sb_pool_get_req *req);
1087 /* DEVLINK_CMD_SB_POOL_GET - dump */
1088 struct devlink_sb_pool_get_req_dump {
1098 static inline struct devlink_sb_pool_get_req_dump *
1099 devlink_sb_pool_get_req_dump_alloc(void)
1101 return calloc(1, sizeof(struct devlink_sb_pool_get_req_dump));
1104 devlink_sb_pool_get_req_dump_free(struct devlink_sb_pool_get_req_dump *req);
1107 devlink_sb_pool_get_req_dump_set_bus_name(struct devlink_sb_pool_get_req_dump *req,
1108 const char *bus_name)
1110 free(req->bus_name);
1111 req->_present.bus_name_len = strlen(bus_name);
1112 req->bus_name = malloc(req->_present.bus_name_len + 1);
1113 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1114 req->bus_name[req->_present.bus_name_len] = 0;
1117 devlink_sb_pool_get_req_dump_set_dev_name(struct devlink_sb_pool_get_req_dump *req,
1118 const char *dev_name)
1120 free(req->dev_name);
1121 req->_present.dev_name_len = strlen(dev_name);
1122 req->dev_name = malloc(req->_present.dev_name_len + 1);
1123 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1124 req->dev_name[req->_present.dev_name_len] = 0;
1127 struct devlink_sb_pool_get_list {
1128 struct devlink_sb_pool_get_list *next;
1129 struct devlink_sb_pool_get_rsp obj __attribute__((aligned(8)));
1132 void devlink_sb_pool_get_list_free(struct devlink_sb_pool_get_list *rsp);
1134 struct devlink_sb_pool_get_list *
1135 devlink_sb_pool_get_dump(struct ynl_sock *ys,
1136 struct devlink_sb_pool_get_req_dump *req);
1138 /* ============== DEVLINK_CMD_SB_POOL_SET ============== */
1139 /* DEVLINK_CMD_SB_POOL_SET - do */
1140 struct devlink_sb_pool_set_req {
1145 __u32 sb_pool_index:1;
1146 __u32 sb_pool_threshold_type:1;
1147 __u32 sb_pool_size:1;
1153 __u16 sb_pool_index;
1154 enum devlink_sb_threshold_type sb_pool_threshold_type;
1158 static inline struct devlink_sb_pool_set_req *
1159 devlink_sb_pool_set_req_alloc(void)
1161 return calloc(1, sizeof(struct devlink_sb_pool_set_req));
1163 void devlink_sb_pool_set_req_free(struct devlink_sb_pool_set_req *req);
1166 devlink_sb_pool_set_req_set_bus_name(struct devlink_sb_pool_set_req *req,
1167 const char *bus_name)
1169 free(req->bus_name);
1170 req->_present.bus_name_len = strlen(bus_name);
1171 req->bus_name = malloc(req->_present.bus_name_len + 1);
1172 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1173 req->bus_name[req->_present.bus_name_len] = 0;
1176 devlink_sb_pool_set_req_set_dev_name(struct devlink_sb_pool_set_req *req,
1177 const char *dev_name)
1179 free(req->dev_name);
1180 req->_present.dev_name_len = strlen(dev_name);
1181 req->dev_name = malloc(req->_present.dev_name_len + 1);
1182 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1183 req->dev_name[req->_present.dev_name_len] = 0;
1186 devlink_sb_pool_set_req_set_sb_index(struct devlink_sb_pool_set_req *req,
1189 req->_present.sb_index = 1;
1190 req->sb_index = sb_index;
1193 devlink_sb_pool_set_req_set_sb_pool_index(struct devlink_sb_pool_set_req *req,
1194 __u16 sb_pool_index)
1196 req->_present.sb_pool_index = 1;
1197 req->sb_pool_index = sb_pool_index;
1200 devlink_sb_pool_set_req_set_sb_pool_threshold_type(struct devlink_sb_pool_set_req *req,
1201 enum devlink_sb_threshold_type sb_pool_threshold_type)
1203 req->_present.sb_pool_threshold_type = 1;
1204 req->sb_pool_threshold_type = sb_pool_threshold_type;
1207 devlink_sb_pool_set_req_set_sb_pool_size(struct devlink_sb_pool_set_req *req,
1210 req->_present.sb_pool_size = 1;
1211 req->sb_pool_size = sb_pool_size;
1215 * Set shared buffer pool instances.
1217 int devlink_sb_pool_set(struct ynl_sock *ys,
1218 struct devlink_sb_pool_set_req *req);
1220 /* ============== DEVLINK_CMD_SB_PORT_POOL_GET ============== */
1221 /* DEVLINK_CMD_SB_PORT_POOL_GET - do */
1222 struct devlink_sb_port_pool_get_req {
1228 __u32 sb_pool_index:1;
1235 __u16 sb_pool_index;
1238 static inline struct devlink_sb_port_pool_get_req *
1239 devlink_sb_port_pool_get_req_alloc(void)
1241 return calloc(1, sizeof(struct devlink_sb_port_pool_get_req));
1244 devlink_sb_port_pool_get_req_free(struct devlink_sb_port_pool_get_req *req);
1247 devlink_sb_port_pool_get_req_set_bus_name(struct devlink_sb_port_pool_get_req *req,
1248 const char *bus_name)
1250 free(req->bus_name);
1251 req->_present.bus_name_len = strlen(bus_name);
1252 req->bus_name = malloc(req->_present.bus_name_len + 1);
1253 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1254 req->bus_name[req->_present.bus_name_len] = 0;
1257 devlink_sb_port_pool_get_req_set_dev_name(struct devlink_sb_port_pool_get_req *req,
1258 const char *dev_name)
1260 free(req->dev_name);
1261 req->_present.dev_name_len = strlen(dev_name);
1262 req->dev_name = malloc(req->_present.dev_name_len + 1);
1263 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1264 req->dev_name[req->_present.dev_name_len] = 0;
1267 devlink_sb_port_pool_get_req_set_port_index(struct devlink_sb_port_pool_get_req *req,
1270 req->_present.port_index = 1;
1271 req->port_index = port_index;
1274 devlink_sb_port_pool_get_req_set_sb_index(struct devlink_sb_port_pool_get_req *req,
1277 req->_present.sb_index = 1;
1278 req->sb_index = sb_index;
1281 devlink_sb_port_pool_get_req_set_sb_pool_index(struct devlink_sb_port_pool_get_req *req,
1282 __u16 sb_pool_index)
1284 req->_present.sb_pool_index = 1;
1285 req->sb_pool_index = sb_pool_index;
1288 struct devlink_sb_port_pool_get_rsp {
1294 __u32 sb_pool_index:1;
1301 __u16 sb_pool_index;
1305 devlink_sb_port_pool_get_rsp_free(struct devlink_sb_port_pool_get_rsp *rsp);
1308 * Get shared buffer port-pool combinations and threshold.
1310 struct devlink_sb_port_pool_get_rsp *
1311 devlink_sb_port_pool_get(struct ynl_sock *ys,
1312 struct devlink_sb_port_pool_get_req *req);
1314 /* DEVLINK_CMD_SB_PORT_POOL_GET - dump */
1315 struct devlink_sb_port_pool_get_req_dump {
1325 static inline struct devlink_sb_port_pool_get_req_dump *
1326 devlink_sb_port_pool_get_req_dump_alloc(void)
1328 return calloc(1, sizeof(struct devlink_sb_port_pool_get_req_dump));
1331 devlink_sb_port_pool_get_req_dump_free(struct devlink_sb_port_pool_get_req_dump *req);
1334 devlink_sb_port_pool_get_req_dump_set_bus_name(struct devlink_sb_port_pool_get_req_dump *req,
1335 const char *bus_name)
1337 free(req->bus_name);
1338 req->_present.bus_name_len = strlen(bus_name);
1339 req->bus_name = malloc(req->_present.bus_name_len + 1);
1340 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1341 req->bus_name[req->_present.bus_name_len] = 0;
1344 devlink_sb_port_pool_get_req_dump_set_dev_name(struct devlink_sb_port_pool_get_req_dump *req,
1345 const char *dev_name)
1347 free(req->dev_name);
1348 req->_present.dev_name_len = strlen(dev_name);
1349 req->dev_name = malloc(req->_present.dev_name_len + 1);
1350 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1351 req->dev_name[req->_present.dev_name_len] = 0;
1354 struct devlink_sb_port_pool_get_list {
1355 struct devlink_sb_port_pool_get_list *next;
1356 struct devlink_sb_port_pool_get_rsp obj __attribute__((aligned(8)));
1360 devlink_sb_port_pool_get_list_free(struct devlink_sb_port_pool_get_list *rsp);
1362 struct devlink_sb_port_pool_get_list *
1363 devlink_sb_port_pool_get_dump(struct ynl_sock *ys,
1364 struct devlink_sb_port_pool_get_req_dump *req);
1366 /* ============== DEVLINK_CMD_SB_PORT_POOL_SET ============== */
1367 /* DEVLINK_CMD_SB_PORT_POOL_SET - do */
1368 struct devlink_sb_port_pool_set_req {
1374 __u32 sb_pool_index:1;
1375 __u32 sb_threshold:1;
1382 __u16 sb_pool_index;
1386 static inline struct devlink_sb_port_pool_set_req *
1387 devlink_sb_port_pool_set_req_alloc(void)
1389 return calloc(1, sizeof(struct devlink_sb_port_pool_set_req));
1392 devlink_sb_port_pool_set_req_free(struct devlink_sb_port_pool_set_req *req);
1395 devlink_sb_port_pool_set_req_set_bus_name(struct devlink_sb_port_pool_set_req *req,
1396 const char *bus_name)
1398 free(req->bus_name);
1399 req->_present.bus_name_len = strlen(bus_name);
1400 req->bus_name = malloc(req->_present.bus_name_len + 1);
1401 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1402 req->bus_name[req->_present.bus_name_len] = 0;
1405 devlink_sb_port_pool_set_req_set_dev_name(struct devlink_sb_port_pool_set_req *req,
1406 const char *dev_name)
1408 free(req->dev_name);
1409 req->_present.dev_name_len = strlen(dev_name);
1410 req->dev_name = malloc(req->_present.dev_name_len + 1);
1411 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1412 req->dev_name[req->_present.dev_name_len] = 0;
1415 devlink_sb_port_pool_set_req_set_port_index(struct devlink_sb_port_pool_set_req *req,
1418 req->_present.port_index = 1;
1419 req->port_index = port_index;
1422 devlink_sb_port_pool_set_req_set_sb_index(struct devlink_sb_port_pool_set_req *req,
1425 req->_present.sb_index = 1;
1426 req->sb_index = sb_index;
1429 devlink_sb_port_pool_set_req_set_sb_pool_index(struct devlink_sb_port_pool_set_req *req,
1430 __u16 sb_pool_index)
1432 req->_present.sb_pool_index = 1;
1433 req->sb_pool_index = sb_pool_index;
1436 devlink_sb_port_pool_set_req_set_sb_threshold(struct devlink_sb_port_pool_set_req *req,
1439 req->_present.sb_threshold = 1;
1440 req->sb_threshold = sb_threshold;
1444 * Set shared buffer port-pool combinations and threshold.
1446 int devlink_sb_port_pool_set(struct ynl_sock *ys,
1447 struct devlink_sb_port_pool_set_req *req);
1449 /* ============== DEVLINK_CMD_SB_TC_POOL_BIND_GET ============== */
1450 /* DEVLINK_CMD_SB_TC_POOL_BIND_GET - do */
1451 struct devlink_sb_tc_pool_bind_get_req {
1457 __u32 sb_pool_type:1;
1458 __u32 sb_tc_index:1;
1465 enum devlink_sb_pool_type sb_pool_type;
1469 static inline struct devlink_sb_tc_pool_bind_get_req *
1470 devlink_sb_tc_pool_bind_get_req_alloc(void)
1472 return calloc(1, sizeof(struct devlink_sb_tc_pool_bind_get_req));
1475 devlink_sb_tc_pool_bind_get_req_free(struct devlink_sb_tc_pool_bind_get_req *req);
1478 devlink_sb_tc_pool_bind_get_req_set_bus_name(struct devlink_sb_tc_pool_bind_get_req *req,
1479 const char *bus_name)
1481 free(req->bus_name);
1482 req->_present.bus_name_len = strlen(bus_name);
1483 req->bus_name = malloc(req->_present.bus_name_len + 1);
1484 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1485 req->bus_name[req->_present.bus_name_len] = 0;
1488 devlink_sb_tc_pool_bind_get_req_set_dev_name(struct devlink_sb_tc_pool_bind_get_req *req,
1489 const char *dev_name)
1491 free(req->dev_name);
1492 req->_present.dev_name_len = strlen(dev_name);
1493 req->dev_name = malloc(req->_present.dev_name_len + 1);
1494 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1495 req->dev_name[req->_present.dev_name_len] = 0;
1498 devlink_sb_tc_pool_bind_get_req_set_port_index(struct devlink_sb_tc_pool_bind_get_req *req,
1501 req->_present.port_index = 1;
1502 req->port_index = port_index;
1505 devlink_sb_tc_pool_bind_get_req_set_sb_index(struct devlink_sb_tc_pool_bind_get_req *req,
1508 req->_present.sb_index = 1;
1509 req->sb_index = sb_index;
1512 devlink_sb_tc_pool_bind_get_req_set_sb_pool_type(struct devlink_sb_tc_pool_bind_get_req *req,
1513 enum devlink_sb_pool_type sb_pool_type)
1515 req->_present.sb_pool_type = 1;
1516 req->sb_pool_type = sb_pool_type;
1519 devlink_sb_tc_pool_bind_get_req_set_sb_tc_index(struct devlink_sb_tc_pool_bind_get_req *req,
1522 req->_present.sb_tc_index = 1;
1523 req->sb_tc_index = sb_tc_index;
1526 struct devlink_sb_tc_pool_bind_get_rsp {
1532 __u32 sb_pool_type:1;
1533 __u32 sb_tc_index:1;
1540 enum devlink_sb_pool_type sb_pool_type;
1545 devlink_sb_tc_pool_bind_get_rsp_free(struct devlink_sb_tc_pool_bind_get_rsp *rsp);
1548 * Get shared buffer port-TC to pool bindings and threshold.
1550 struct devlink_sb_tc_pool_bind_get_rsp *
1551 devlink_sb_tc_pool_bind_get(struct ynl_sock *ys,
1552 struct devlink_sb_tc_pool_bind_get_req *req);
1554 /* DEVLINK_CMD_SB_TC_POOL_BIND_GET - dump */
1555 struct devlink_sb_tc_pool_bind_get_req_dump {
1565 static inline struct devlink_sb_tc_pool_bind_get_req_dump *
1566 devlink_sb_tc_pool_bind_get_req_dump_alloc(void)
1568 return calloc(1, sizeof(struct devlink_sb_tc_pool_bind_get_req_dump));
1571 devlink_sb_tc_pool_bind_get_req_dump_free(struct devlink_sb_tc_pool_bind_get_req_dump *req);
1574 devlink_sb_tc_pool_bind_get_req_dump_set_bus_name(struct devlink_sb_tc_pool_bind_get_req_dump *req,
1575 const char *bus_name)
1577 free(req->bus_name);
1578 req->_present.bus_name_len = strlen(bus_name);
1579 req->bus_name = malloc(req->_present.bus_name_len + 1);
1580 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1581 req->bus_name[req->_present.bus_name_len] = 0;
1584 devlink_sb_tc_pool_bind_get_req_dump_set_dev_name(struct devlink_sb_tc_pool_bind_get_req_dump *req,
1585 const char *dev_name)
1587 free(req->dev_name);
1588 req->_present.dev_name_len = strlen(dev_name);
1589 req->dev_name = malloc(req->_present.dev_name_len + 1);
1590 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1591 req->dev_name[req->_present.dev_name_len] = 0;
1594 struct devlink_sb_tc_pool_bind_get_list {
1595 struct devlink_sb_tc_pool_bind_get_list *next;
1596 struct devlink_sb_tc_pool_bind_get_rsp obj __attribute__((aligned(8)));
1600 devlink_sb_tc_pool_bind_get_list_free(struct devlink_sb_tc_pool_bind_get_list *rsp);
1602 struct devlink_sb_tc_pool_bind_get_list *
1603 devlink_sb_tc_pool_bind_get_dump(struct ynl_sock *ys,
1604 struct devlink_sb_tc_pool_bind_get_req_dump *req);
1606 /* ============== DEVLINK_CMD_SB_TC_POOL_BIND_SET ============== */
1607 /* DEVLINK_CMD_SB_TC_POOL_BIND_SET - do */
1608 struct devlink_sb_tc_pool_bind_set_req {
1614 __u32 sb_pool_index:1;
1615 __u32 sb_pool_type:1;
1616 __u32 sb_tc_index:1;
1617 __u32 sb_threshold:1;
1624 __u16 sb_pool_index;
1625 enum devlink_sb_pool_type sb_pool_type;
1630 static inline struct devlink_sb_tc_pool_bind_set_req *
1631 devlink_sb_tc_pool_bind_set_req_alloc(void)
1633 return calloc(1, sizeof(struct devlink_sb_tc_pool_bind_set_req));
1636 devlink_sb_tc_pool_bind_set_req_free(struct devlink_sb_tc_pool_bind_set_req *req);
1639 devlink_sb_tc_pool_bind_set_req_set_bus_name(struct devlink_sb_tc_pool_bind_set_req *req,
1640 const char *bus_name)
1642 free(req->bus_name);
1643 req->_present.bus_name_len = strlen(bus_name);
1644 req->bus_name = malloc(req->_present.bus_name_len + 1);
1645 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1646 req->bus_name[req->_present.bus_name_len] = 0;
1649 devlink_sb_tc_pool_bind_set_req_set_dev_name(struct devlink_sb_tc_pool_bind_set_req *req,
1650 const char *dev_name)
1652 free(req->dev_name);
1653 req->_present.dev_name_len = strlen(dev_name);
1654 req->dev_name = malloc(req->_present.dev_name_len + 1);
1655 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1656 req->dev_name[req->_present.dev_name_len] = 0;
1659 devlink_sb_tc_pool_bind_set_req_set_port_index(struct devlink_sb_tc_pool_bind_set_req *req,
1662 req->_present.port_index = 1;
1663 req->port_index = port_index;
1666 devlink_sb_tc_pool_bind_set_req_set_sb_index(struct devlink_sb_tc_pool_bind_set_req *req,
1669 req->_present.sb_index = 1;
1670 req->sb_index = sb_index;
1673 devlink_sb_tc_pool_bind_set_req_set_sb_pool_index(struct devlink_sb_tc_pool_bind_set_req *req,
1674 __u16 sb_pool_index)
1676 req->_present.sb_pool_index = 1;
1677 req->sb_pool_index = sb_pool_index;
1680 devlink_sb_tc_pool_bind_set_req_set_sb_pool_type(struct devlink_sb_tc_pool_bind_set_req *req,
1681 enum devlink_sb_pool_type sb_pool_type)
1683 req->_present.sb_pool_type = 1;
1684 req->sb_pool_type = sb_pool_type;
1687 devlink_sb_tc_pool_bind_set_req_set_sb_tc_index(struct devlink_sb_tc_pool_bind_set_req *req,
1690 req->_present.sb_tc_index = 1;
1691 req->sb_tc_index = sb_tc_index;
1694 devlink_sb_tc_pool_bind_set_req_set_sb_threshold(struct devlink_sb_tc_pool_bind_set_req *req,
1697 req->_present.sb_threshold = 1;
1698 req->sb_threshold = sb_threshold;
1702 * Set shared buffer port-TC to pool bindings and threshold.
1704 int devlink_sb_tc_pool_bind_set(struct ynl_sock *ys,
1705 struct devlink_sb_tc_pool_bind_set_req *req);
1707 /* ============== DEVLINK_CMD_SB_OCC_SNAPSHOT ============== */
1708 /* DEVLINK_CMD_SB_OCC_SNAPSHOT - do */
1709 struct devlink_sb_occ_snapshot_req {
1721 static inline struct devlink_sb_occ_snapshot_req *
1722 devlink_sb_occ_snapshot_req_alloc(void)
1724 return calloc(1, sizeof(struct devlink_sb_occ_snapshot_req));
1726 void devlink_sb_occ_snapshot_req_free(struct devlink_sb_occ_snapshot_req *req);
1729 devlink_sb_occ_snapshot_req_set_bus_name(struct devlink_sb_occ_snapshot_req *req,
1730 const char *bus_name)
1732 free(req->bus_name);
1733 req->_present.bus_name_len = strlen(bus_name);
1734 req->bus_name = malloc(req->_present.bus_name_len + 1);
1735 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1736 req->bus_name[req->_present.bus_name_len] = 0;
1739 devlink_sb_occ_snapshot_req_set_dev_name(struct devlink_sb_occ_snapshot_req *req,
1740 const char *dev_name)
1742 free(req->dev_name);
1743 req->_present.dev_name_len = strlen(dev_name);
1744 req->dev_name = malloc(req->_present.dev_name_len + 1);
1745 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1746 req->dev_name[req->_present.dev_name_len] = 0;
1749 devlink_sb_occ_snapshot_req_set_sb_index(struct devlink_sb_occ_snapshot_req *req,
1752 req->_present.sb_index = 1;
1753 req->sb_index = sb_index;
1757 * Take occupancy snapshot of shared buffer.
1759 int devlink_sb_occ_snapshot(struct ynl_sock *ys,
1760 struct devlink_sb_occ_snapshot_req *req);
1762 /* ============== DEVLINK_CMD_SB_OCC_MAX_CLEAR ============== */
1763 /* DEVLINK_CMD_SB_OCC_MAX_CLEAR - do */
1764 struct devlink_sb_occ_max_clear_req {
1776 static inline struct devlink_sb_occ_max_clear_req *
1777 devlink_sb_occ_max_clear_req_alloc(void)
1779 return calloc(1, sizeof(struct devlink_sb_occ_max_clear_req));
1782 devlink_sb_occ_max_clear_req_free(struct devlink_sb_occ_max_clear_req *req);
1785 devlink_sb_occ_max_clear_req_set_bus_name(struct devlink_sb_occ_max_clear_req *req,
1786 const char *bus_name)
1788 free(req->bus_name);
1789 req->_present.bus_name_len = strlen(bus_name);
1790 req->bus_name = malloc(req->_present.bus_name_len + 1);
1791 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1792 req->bus_name[req->_present.bus_name_len] = 0;
1795 devlink_sb_occ_max_clear_req_set_dev_name(struct devlink_sb_occ_max_clear_req *req,
1796 const char *dev_name)
1798 free(req->dev_name);
1799 req->_present.dev_name_len = strlen(dev_name);
1800 req->dev_name = malloc(req->_present.dev_name_len + 1);
1801 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1802 req->dev_name[req->_present.dev_name_len] = 0;
1805 devlink_sb_occ_max_clear_req_set_sb_index(struct devlink_sb_occ_max_clear_req *req,
1808 req->_present.sb_index = 1;
1809 req->sb_index = sb_index;
1813 * Clear occupancy watermarks of shared buffer.
1815 int devlink_sb_occ_max_clear(struct ynl_sock *ys,
1816 struct devlink_sb_occ_max_clear_req *req);
1818 /* ============== DEVLINK_CMD_ESWITCH_GET ============== */
1819 /* DEVLINK_CMD_ESWITCH_GET - do */
1820 struct devlink_eswitch_get_req {
1830 static inline struct devlink_eswitch_get_req *
1831 devlink_eswitch_get_req_alloc(void)
1833 return calloc(1, sizeof(struct devlink_eswitch_get_req));
1835 void devlink_eswitch_get_req_free(struct devlink_eswitch_get_req *req);
1838 devlink_eswitch_get_req_set_bus_name(struct devlink_eswitch_get_req *req,
1839 const char *bus_name)
1841 free(req->bus_name);
1842 req->_present.bus_name_len = strlen(bus_name);
1843 req->bus_name = malloc(req->_present.bus_name_len + 1);
1844 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1845 req->bus_name[req->_present.bus_name_len] = 0;
1848 devlink_eswitch_get_req_set_dev_name(struct devlink_eswitch_get_req *req,
1849 const char *dev_name)
1851 free(req->dev_name);
1852 req->_present.dev_name_len = strlen(dev_name);
1853 req->dev_name = malloc(req->_present.dev_name_len + 1);
1854 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1855 req->dev_name[req->_present.dev_name_len] = 0;
1858 struct devlink_eswitch_get_rsp {
1862 __u32 eswitch_mode:1;
1863 __u32 eswitch_inline_mode:1;
1864 __u32 eswitch_encap_mode:1;
1869 enum devlink_eswitch_mode eswitch_mode;
1870 enum devlink_eswitch_inline_mode eswitch_inline_mode;
1871 enum devlink_eswitch_encap_mode eswitch_encap_mode;
1874 void devlink_eswitch_get_rsp_free(struct devlink_eswitch_get_rsp *rsp);
1877 * Get eswitch attributes.
1879 struct devlink_eswitch_get_rsp *
1880 devlink_eswitch_get(struct ynl_sock *ys, struct devlink_eswitch_get_req *req);
1882 /* ============== DEVLINK_CMD_ESWITCH_SET ============== */
1883 /* DEVLINK_CMD_ESWITCH_SET - do */
1884 struct devlink_eswitch_set_req {
1888 __u32 eswitch_mode:1;
1889 __u32 eswitch_inline_mode:1;
1890 __u32 eswitch_encap_mode:1;
1895 enum devlink_eswitch_mode eswitch_mode;
1896 enum devlink_eswitch_inline_mode eswitch_inline_mode;
1897 enum devlink_eswitch_encap_mode eswitch_encap_mode;
1900 static inline struct devlink_eswitch_set_req *
1901 devlink_eswitch_set_req_alloc(void)
1903 return calloc(1, sizeof(struct devlink_eswitch_set_req));
1905 void devlink_eswitch_set_req_free(struct devlink_eswitch_set_req *req);
1908 devlink_eswitch_set_req_set_bus_name(struct devlink_eswitch_set_req *req,
1909 const char *bus_name)
1911 free(req->bus_name);
1912 req->_present.bus_name_len = strlen(bus_name);
1913 req->bus_name = malloc(req->_present.bus_name_len + 1);
1914 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1915 req->bus_name[req->_present.bus_name_len] = 0;
1918 devlink_eswitch_set_req_set_dev_name(struct devlink_eswitch_set_req *req,
1919 const char *dev_name)
1921 free(req->dev_name);
1922 req->_present.dev_name_len = strlen(dev_name);
1923 req->dev_name = malloc(req->_present.dev_name_len + 1);
1924 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1925 req->dev_name[req->_present.dev_name_len] = 0;
1928 devlink_eswitch_set_req_set_eswitch_mode(struct devlink_eswitch_set_req *req,
1929 enum devlink_eswitch_mode eswitch_mode)
1931 req->_present.eswitch_mode = 1;
1932 req->eswitch_mode = eswitch_mode;
1935 devlink_eswitch_set_req_set_eswitch_inline_mode(struct devlink_eswitch_set_req *req,
1936 enum devlink_eswitch_inline_mode eswitch_inline_mode)
1938 req->_present.eswitch_inline_mode = 1;
1939 req->eswitch_inline_mode = eswitch_inline_mode;
1942 devlink_eswitch_set_req_set_eswitch_encap_mode(struct devlink_eswitch_set_req *req,
1943 enum devlink_eswitch_encap_mode eswitch_encap_mode)
1945 req->_present.eswitch_encap_mode = 1;
1946 req->eswitch_encap_mode = eswitch_encap_mode;
1950 * Set eswitch attributes.
1952 int devlink_eswitch_set(struct ynl_sock *ys,
1953 struct devlink_eswitch_set_req *req);
1955 /* ============== DEVLINK_CMD_DPIPE_TABLE_GET ============== */
1956 /* DEVLINK_CMD_DPIPE_TABLE_GET - do */
1957 struct devlink_dpipe_table_get_req {
1961 __u32 dpipe_table_name_len;
1966 char *dpipe_table_name;
1969 static inline struct devlink_dpipe_table_get_req *
1970 devlink_dpipe_table_get_req_alloc(void)
1972 return calloc(1, sizeof(struct devlink_dpipe_table_get_req));
1974 void devlink_dpipe_table_get_req_free(struct devlink_dpipe_table_get_req *req);
1977 devlink_dpipe_table_get_req_set_bus_name(struct devlink_dpipe_table_get_req *req,
1978 const char *bus_name)
1980 free(req->bus_name);
1981 req->_present.bus_name_len = strlen(bus_name);
1982 req->bus_name = malloc(req->_present.bus_name_len + 1);
1983 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1984 req->bus_name[req->_present.bus_name_len] = 0;
1987 devlink_dpipe_table_get_req_set_dev_name(struct devlink_dpipe_table_get_req *req,
1988 const char *dev_name)
1990 free(req->dev_name);
1991 req->_present.dev_name_len = strlen(dev_name);
1992 req->dev_name = malloc(req->_present.dev_name_len + 1);
1993 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1994 req->dev_name[req->_present.dev_name_len] = 0;
1997 devlink_dpipe_table_get_req_set_dpipe_table_name(struct devlink_dpipe_table_get_req *req,
1998 const char *dpipe_table_name)
2000 free(req->dpipe_table_name);
2001 req->_present.dpipe_table_name_len = strlen(dpipe_table_name);
2002 req->dpipe_table_name = malloc(req->_present.dpipe_table_name_len + 1);
2003 memcpy(req->dpipe_table_name, dpipe_table_name, req->_present.dpipe_table_name_len);
2004 req->dpipe_table_name[req->_present.dpipe_table_name_len] = 0;
2007 struct devlink_dpipe_table_get_rsp {
2011 __u32 dpipe_tables:1;
2016 struct devlink_dl_dpipe_tables dpipe_tables;
2019 void devlink_dpipe_table_get_rsp_free(struct devlink_dpipe_table_get_rsp *rsp);
2022 * Get dpipe table attributes.
2024 struct devlink_dpipe_table_get_rsp *
2025 devlink_dpipe_table_get(struct ynl_sock *ys,
2026 struct devlink_dpipe_table_get_req *req);
2028 /* ============== DEVLINK_CMD_DPIPE_ENTRIES_GET ============== */
2029 /* DEVLINK_CMD_DPIPE_ENTRIES_GET - do */
2030 struct devlink_dpipe_entries_get_req {
2034 __u32 dpipe_table_name_len;
2039 char *dpipe_table_name;
2042 static inline struct devlink_dpipe_entries_get_req *
2043 devlink_dpipe_entries_get_req_alloc(void)
2045 return calloc(1, sizeof(struct devlink_dpipe_entries_get_req));
2048 devlink_dpipe_entries_get_req_free(struct devlink_dpipe_entries_get_req *req);
2051 devlink_dpipe_entries_get_req_set_bus_name(struct devlink_dpipe_entries_get_req *req,
2052 const char *bus_name)
2054 free(req->bus_name);
2055 req->_present.bus_name_len = strlen(bus_name);
2056 req->bus_name = malloc(req->_present.bus_name_len + 1);
2057 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
2058 req->bus_name[req->_present.bus_name_len] = 0;
2061 devlink_dpipe_entries_get_req_set_dev_name(struct devlink_dpipe_entries_get_req *req,
2062 const char *dev_name)
2064 free(req->dev_name);
2065 req->_present.dev_name_len = strlen(dev_name);
2066 req->dev_name = malloc(req->_present.dev_name_len + 1);
2067 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
2068 req->dev_name[req->_present.dev_name_len] = 0;
2071 devlink_dpipe_entries_get_req_set_dpipe_table_name(struct devlink_dpipe_entries_get_req *req,
2072 const char *dpipe_table_name)
2074 free(req->dpipe_table_name);
2075 req->_present.dpipe_table_name_len = strlen(dpipe_table_name);
2076 req->dpipe_table_name = malloc(req->_present.dpipe_table_name_len + 1);
2077 memcpy(req->dpipe_table_name, dpipe_table_name, req->_present.dpipe_table_name_len);
2078 req->dpipe_table_name[req->_present.dpipe_table_name_len] = 0;
2081 struct devlink_dpipe_entries_get_rsp {
2085 __u32 dpipe_entries:1;
2090 struct devlink_dl_dpipe_entries dpipe_entries;
2094 devlink_dpipe_entries_get_rsp_free(struct devlink_dpipe_entries_get_rsp *rsp);
2097 * Get dpipe entries attributes.
2099 struct devlink_dpipe_entries_get_rsp *
2100 devlink_dpipe_entries_get(struct ynl_sock *ys,
2101 struct devlink_dpipe_entries_get_req *req);
2103 /* ============== DEVLINK_CMD_DPIPE_HEADERS_GET ============== */
2104 /* DEVLINK_CMD_DPIPE_HEADERS_GET - do */
2105 struct devlink_dpipe_headers_get_req {
2115 static inline struct devlink_dpipe_headers_get_req *
2116 devlink_dpipe_headers_get_req_alloc(void)
2118 return calloc(1, sizeof(struct devlink_dpipe_headers_get_req));
2121 devlink_dpipe_headers_get_req_free(struct devlink_dpipe_headers_get_req *req);
2124 devlink_dpipe_headers_get_req_set_bus_name(struct devlink_dpipe_headers_get_req *req,
2125 const char *bus_name)
2127 free(req->bus_name);
2128 req->_present.bus_name_len = strlen(bus_name);
2129 req->bus_name = malloc(req->_present.bus_name_len + 1);
2130 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
2131 req->bus_name[req->_present.bus_name_len] = 0;
2134 devlink_dpipe_headers_get_req_set_dev_name(struct devlink_dpipe_headers_get_req *req,
2135 const char *dev_name)
2137 free(req->dev_name);
2138 req->_present.dev_name_len = strlen(dev_name);
2139 req->dev_name = malloc(req->_present.dev_name_len + 1);
2140 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
2141 req->dev_name[req->_present.dev_name_len] = 0;
2144 struct devlink_dpipe_headers_get_rsp {
2148 __u32 dpipe_headers:1;
2153 struct devlink_dl_dpipe_headers dpipe_headers;
2157 devlink_dpipe_headers_get_rsp_free(struct devlink_dpipe_headers_get_rsp *rsp);
2160 * Get dpipe headers attributes.
2162 struct devlink_dpipe_headers_get_rsp *
2163 devlink_dpipe_headers_get(struct ynl_sock *ys,
2164 struct devlink_dpipe_headers_get_req *req);
2166 /* ============== DEVLINK_CMD_DPIPE_TABLE_COUNTERS_SET ============== */
2167 /* DEVLINK_CMD_DPIPE_TABLE_COUNTERS_SET - do */
2168 struct devlink_dpipe_table_counters_set_req {
2172 __u32 dpipe_table_name_len;
2173 __u32 dpipe_table_counters_enabled:1;
2178 char *dpipe_table_name;
2179 __u8 dpipe_table_counters_enabled;
2182 static inline struct devlink_dpipe_table_counters_set_req *
2183 devlink_dpipe_table_counters_set_req_alloc(void)
2185 return calloc(1, sizeof(struct devlink_dpipe_table_counters_set_req));
2188 devlink_dpipe_table_counters_set_req_free(struct devlink_dpipe_table_counters_set_req *req);
2191 devlink_dpipe_table_counters_set_req_set_bus_name(struct devlink_dpipe_table_counters_set_req *req,
2192 const char *bus_name)
2194 free(req->bus_name);
2195 req->_present.bus_name_len = strlen(bus_name);
2196 req->bus_name = malloc(req->_present.bus_name_len + 1);
2197 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
2198 req->bus_name[req->_present.bus_name_len] = 0;
2201 devlink_dpipe_table_counters_set_req_set_dev_name(struct devlink_dpipe_table_counters_set_req *req,
2202 const char *dev_name)
2204 free(req->dev_name);
2205 req->_present.dev_name_len = strlen(dev_name);
2206 req->dev_name = malloc(req->_present.dev_name_len + 1);
2207 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
2208 req->dev_name[req->_present.dev_name_len] = 0;
2211 devlink_dpipe_table_counters_set_req_set_dpipe_table_name(struct devlink_dpipe_table_counters_set_req *req,
2212 const char *dpipe_table_name)
2214 free(req->dpipe_table_name);
2215 req->_present.dpipe_table_name_len = strlen(dpipe_table_name);
2216 req->dpipe_table_name = malloc(req->_present.dpipe_table_name_len + 1);
2217 memcpy(req->dpipe_table_name, dpipe_table_name, req->_present.dpipe_table_name_len);
2218 req->dpipe_table_name[req->_present.dpipe_table_name_len] = 0;
2221 devlink_dpipe_table_counters_set_req_set_dpipe_table_counters_enabled(struct devlink_dpipe_table_counters_set_req *req,
2222 __u8 dpipe_table_counters_enabled)
2224 req->_present.dpipe_table_counters_enabled = 1;
2225 req->dpipe_table_counters_enabled = dpipe_table_counters_enabled;
2229 * Set dpipe counter attributes.
2231 int devlink_dpipe_table_counters_set(struct ynl_sock *ys,
2232 struct devlink_dpipe_table_counters_set_req *req);
2234 /* ============== DEVLINK_CMD_RESOURCE_SET ============== */
2235 /* DEVLINK_CMD_RESOURCE_SET - do */
2236 struct devlink_resource_set_req {
2240 __u32 resource_id:1;
2241 __u32 resource_size:1;
2247 __u64 resource_size;
2250 static inline struct devlink_resource_set_req *
2251 devlink_resource_set_req_alloc(void)
2253 return calloc(1, sizeof(struct devlink_resource_set_req));
2255 void devlink_resource_set_req_free(struct devlink_resource_set_req *req);
2258 devlink_resource_set_req_set_bus_name(struct devlink_resource_set_req *req,
2259 const char *bus_name)
2261 free(req->bus_name);
2262 req->_present.bus_name_len = strlen(bus_name);
2263 req->bus_name = malloc(req->_present.bus_name_len + 1);
2264 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
2265 req->bus_name[req->_present.bus_name_len] = 0;
2268 devlink_resource_set_req_set_dev_name(struct devlink_resource_set_req *req,
2269 const char *dev_name)
2271 free(req->dev_name);
2272 req->_present.dev_name_len = strlen(dev_name);
2273 req->dev_name = malloc(req->_present.dev_name_len + 1);
2274 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
2275 req->dev_name[req->_present.dev_name_len] = 0;
2278 devlink_resource_set_req_set_resource_id(struct devlink_resource_set_req *req,
2281 req->_present.resource_id = 1;
2282 req->resource_id = resource_id;
2285 devlink_resource_set_req_set_resource_size(struct devlink_resource_set_req *req,
2286 __u64 resource_size)
2288 req->_present.resource_size = 1;
2289 req->resource_size = resource_size;
2293 * Set resource attributes.
2295 int devlink_resource_set(struct ynl_sock *ys,
2296 struct devlink_resource_set_req *req);
2298 /* ============== DEVLINK_CMD_RESOURCE_DUMP ============== */
2299 /* DEVLINK_CMD_RESOURCE_DUMP - do */
2300 struct devlink_resource_dump_req {
2310 static inline struct devlink_resource_dump_req *
2311 devlink_resource_dump_req_alloc(void)
2313 return calloc(1, sizeof(struct devlink_resource_dump_req));
2315 void devlink_resource_dump_req_free(struct devlink_resource_dump_req *req);
2318 devlink_resource_dump_req_set_bus_name(struct devlink_resource_dump_req *req,
2319 const char *bus_name)
2321 free(req->bus_name);
2322 req->_present.bus_name_len = strlen(bus_name);
2323 req->bus_name = malloc(req->_present.bus_name_len + 1);
2324 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
2325 req->bus_name[req->_present.bus_name_len] = 0;
2328 devlink_resource_dump_req_set_dev_name(struct devlink_resource_dump_req *req,
2329 const char *dev_name)
2331 free(req->dev_name);
2332 req->_present.dev_name_len = strlen(dev_name);
2333 req->dev_name = malloc(req->_present.dev_name_len + 1);
2334 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
2335 req->dev_name[req->_present.dev_name_len] = 0;
2338 struct devlink_resource_dump_rsp {
2342 __u32 resource_list:1;
2347 struct devlink_dl_resource_list resource_list;
2350 void devlink_resource_dump_rsp_free(struct devlink_resource_dump_rsp *rsp);
2353 * Get resource attributes.
2355 struct devlink_resource_dump_rsp *
2356 devlink_resource_dump(struct ynl_sock *ys,
2357 struct devlink_resource_dump_req *req);
2359 /* ============== DEVLINK_CMD_RELOAD ============== */
2360 /* DEVLINK_CMD_RELOAD - do */
2361 struct devlink_reload_req {
2365 __u32 reload_action:1;
2366 __u32 reload_limits:1;
2374 enum devlink_reload_action reload_action;
2375 struct nla_bitfield32 reload_limits;
2381 static inline struct devlink_reload_req *devlink_reload_req_alloc(void)
2383 return calloc(1, sizeof(struct devlink_reload_req));
2385 void devlink_reload_req_free(struct devlink_reload_req *req);
2388 devlink_reload_req_set_bus_name(struct devlink_reload_req *req,
2389 const char *bus_name)
2391 free(req->bus_name);
2392 req->_present.bus_name_len = strlen(bus_name);
2393 req->bus_name = malloc(req->_present.bus_name_len + 1);
2394 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
2395 req->bus_name[req->_present.bus_name_len] = 0;
2398 devlink_reload_req_set_dev_name(struct devlink_reload_req *req,
2399 const char *dev_name)
2401 free(req->dev_name);
2402 req->_present.dev_name_len = strlen(dev_name);
2403 req->dev_name = malloc(req->_present.dev_name_len + 1);
2404 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
2405 req->dev_name[req->_present.dev_name_len] = 0;
2408 devlink_reload_req_set_reload_action(struct devlink_reload_req *req,
2409 enum devlink_reload_action reload_action)
2411 req->_present.reload_action = 1;
2412 req->reload_action = reload_action;
2415 devlink_reload_req_set_reload_limits(struct devlink_reload_req *req,
2416 struct nla_bitfield32 *reload_limits)
2418 req->_present.reload_limits = 1;
2419 memcpy(&req->reload_limits, reload_limits, sizeof(struct nla_bitfield32));
2422 devlink_reload_req_set_netns_pid(struct devlink_reload_req *req,
2425 req->_present.netns_pid = 1;
2426 req->netns_pid = netns_pid;
2429 devlink_reload_req_set_netns_fd(struct devlink_reload_req *req, __u32 netns_fd)
2431 req->_present.netns_fd = 1;
2432 req->netns_fd = netns_fd;
2435 devlink_reload_req_set_netns_id(struct devlink_reload_req *req, __u32 netns_id)
2437 req->_present.netns_id = 1;
2438 req->netns_id = netns_id;
2441 struct devlink_reload_rsp {
2445 __u32 reload_actions_performed:1;
2450 struct nla_bitfield32 reload_actions_performed;
2453 void devlink_reload_rsp_free(struct devlink_reload_rsp *rsp);
2458 struct devlink_reload_rsp *
2459 devlink_reload(struct ynl_sock *ys, struct devlink_reload_req *req);
2461 /* ============== DEVLINK_CMD_PARAM_GET ============== */
2462 /* DEVLINK_CMD_PARAM_GET - do */
2463 struct devlink_param_get_req {
2467 __u32 param_name_len;
2475 static inline struct devlink_param_get_req *devlink_param_get_req_alloc(void)
2477 return calloc(1, sizeof(struct devlink_param_get_req));
2479 void devlink_param_get_req_free(struct devlink_param_get_req *req);
2482 devlink_param_get_req_set_bus_name(struct devlink_param_get_req *req,
2483 const char *bus_name)
2485 free(req->bus_name);
2486 req->_present.bus_name_len = strlen(bus_name);
2487 req->bus_name = malloc(req->_present.bus_name_len + 1);
2488 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
2489 req->bus_name[req->_present.bus_name_len] = 0;
2492 devlink_param_get_req_set_dev_name(struct devlink_param_get_req *req,
2493 const char *dev_name)
2495 free(req->dev_name);
2496 req->_present.dev_name_len = strlen(dev_name);
2497 req->dev_name = malloc(req->_present.dev_name_len + 1);
2498 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
2499 req->dev_name[req->_present.dev_name_len] = 0;
2502 devlink_param_get_req_set_param_name(struct devlink_param_get_req *req,
2503 const char *param_name)
2505 free(req->param_name);
2506 req->_present.param_name_len = strlen(param_name);
2507 req->param_name = malloc(req->_present.param_name_len + 1);
2508 memcpy(req->param_name, param_name, req->_present.param_name_len);
2509 req->param_name[req->_present.param_name_len] = 0;
2512 struct devlink_param_get_rsp {
2516 __u32 param_name_len;
2524 void devlink_param_get_rsp_free(struct devlink_param_get_rsp *rsp);
2527 * Get param instances.
2529 struct devlink_param_get_rsp *
2530 devlink_param_get(struct ynl_sock *ys, struct devlink_param_get_req *req);
2532 /* DEVLINK_CMD_PARAM_GET - dump */
2533 struct devlink_param_get_req_dump {
2543 static inline struct devlink_param_get_req_dump *
2544 devlink_param_get_req_dump_alloc(void)
2546 return calloc(1, sizeof(struct devlink_param_get_req_dump));
2548 void devlink_param_get_req_dump_free(struct devlink_param_get_req_dump *req);
2551 devlink_param_get_req_dump_set_bus_name(struct devlink_param_get_req_dump *req,
2552 const char *bus_name)
2554 free(req->bus_name);
2555 req->_present.bus_name_len = strlen(bus_name);
2556 req->bus_name = malloc(req->_present.bus_name_len + 1);
2557 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
2558 req->bus_name[req->_present.bus_name_len] = 0;
2561 devlink_param_get_req_dump_set_dev_name(struct devlink_param_get_req_dump *req,
2562 const char *dev_name)
2564 free(req->dev_name);
2565 req->_present.dev_name_len = strlen(dev_name);
2566 req->dev_name = malloc(req->_present.dev_name_len + 1);
2567 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
2568 req->dev_name[req->_present.dev_name_len] = 0;
2571 struct devlink_param_get_list {
2572 struct devlink_param_get_list *next;
2573 struct devlink_param_get_rsp obj __attribute__((aligned(8)));
2576 void devlink_param_get_list_free(struct devlink_param_get_list *rsp);
2578 struct devlink_param_get_list *
2579 devlink_param_get_dump(struct ynl_sock *ys,
2580 struct devlink_param_get_req_dump *req);
2582 /* ============== DEVLINK_CMD_PARAM_SET ============== */
2583 /* DEVLINK_CMD_PARAM_SET - do */
2584 struct devlink_param_set_req {
2588 __u32 param_name_len;
2590 __u32 param_value_cmode:1;
2597 enum devlink_param_cmode param_value_cmode;
2600 static inline struct devlink_param_set_req *devlink_param_set_req_alloc(void)
2602 return calloc(1, sizeof(struct devlink_param_set_req));
2604 void devlink_param_set_req_free(struct devlink_param_set_req *req);
2607 devlink_param_set_req_set_bus_name(struct devlink_param_set_req *req,
2608 const char *bus_name)
2610 free(req->bus_name);
2611 req->_present.bus_name_len = strlen(bus_name);
2612 req->bus_name = malloc(req->_present.bus_name_len + 1);
2613 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
2614 req->bus_name[req->_present.bus_name_len] = 0;
2617 devlink_param_set_req_set_dev_name(struct devlink_param_set_req *req,
2618 const char *dev_name)
2620 free(req->dev_name);
2621 req->_present.dev_name_len = strlen(dev_name);
2622 req->dev_name = malloc(req->_present.dev_name_len + 1);
2623 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
2624 req->dev_name[req->_present.dev_name_len] = 0;
2627 devlink_param_set_req_set_param_name(struct devlink_param_set_req *req,
2628 const char *param_name)
2630 free(req->param_name);
2631 req->_present.param_name_len = strlen(param_name);
2632 req->param_name = malloc(req->_present.param_name_len + 1);
2633 memcpy(req->param_name, param_name, req->_present.param_name_len);
2634 req->param_name[req->_present.param_name_len] = 0;
2637 devlink_param_set_req_set_param_type(struct devlink_param_set_req *req,
2640 req->_present.param_type = 1;
2641 req->param_type = param_type;
2644 devlink_param_set_req_set_param_value_cmode(struct devlink_param_set_req *req,
2645 enum devlink_param_cmode param_value_cmode)
2647 req->_present.param_value_cmode = 1;
2648 req->param_value_cmode = param_value_cmode;
2652 * Set param instances.
2654 int devlink_param_set(struct ynl_sock *ys, struct devlink_param_set_req *req);
2656 /* ============== DEVLINK_CMD_REGION_GET ============== */
2657 /* DEVLINK_CMD_REGION_GET - do */
2658 struct devlink_region_get_req {
2663 __u32 region_name_len;
2672 static inline struct devlink_region_get_req *devlink_region_get_req_alloc(void)
2674 return calloc(1, sizeof(struct devlink_region_get_req));
2676 void devlink_region_get_req_free(struct devlink_region_get_req *req);
2679 devlink_region_get_req_set_bus_name(struct devlink_region_get_req *req,
2680 const char *bus_name)
2682 free(req->bus_name);
2683 req->_present.bus_name_len = strlen(bus_name);
2684 req->bus_name = malloc(req->_present.bus_name_len + 1);
2685 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
2686 req->bus_name[req->_present.bus_name_len] = 0;
2689 devlink_region_get_req_set_dev_name(struct devlink_region_get_req *req,
2690 const char *dev_name)
2692 free(req->dev_name);
2693 req->_present.dev_name_len = strlen(dev_name);
2694 req->dev_name = malloc(req->_present.dev_name_len + 1);
2695 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
2696 req->dev_name[req->_present.dev_name_len] = 0;
2699 devlink_region_get_req_set_port_index(struct devlink_region_get_req *req,
2702 req->_present.port_index = 1;
2703 req->port_index = port_index;
2706 devlink_region_get_req_set_region_name(struct devlink_region_get_req *req,
2707 const char *region_name)
2709 free(req->region_name);
2710 req->_present.region_name_len = strlen(region_name);
2711 req->region_name = malloc(req->_present.region_name_len + 1);
2712 memcpy(req->region_name, region_name, req->_present.region_name_len);
2713 req->region_name[req->_present.region_name_len] = 0;
2716 struct devlink_region_get_rsp {
2721 __u32 region_name_len;
2730 void devlink_region_get_rsp_free(struct devlink_region_get_rsp *rsp);
2733 * Get region instances.
2735 struct devlink_region_get_rsp *
2736 devlink_region_get(struct ynl_sock *ys, struct devlink_region_get_req *req);
2738 /* DEVLINK_CMD_REGION_GET - dump */
2739 struct devlink_region_get_req_dump {
2749 static inline struct devlink_region_get_req_dump *
2750 devlink_region_get_req_dump_alloc(void)
2752 return calloc(1, sizeof(struct devlink_region_get_req_dump));
2754 void devlink_region_get_req_dump_free(struct devlink_region_get_req_dump *req);
2757 devlink_region_get_req_dump_set_bus_name(struct devlink_region_get_req_dump *req,
2758 const char *bus_name)
2760 free(req->bus_name);
2761 req->_present.bus_name_len = strlen(bus_name);
2762 req->bus_name = malloc(req->_present.bus_name_len + 1);
2763 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
2764 req->bus_name[req->_present.bus_name_len] = 0;
2767 devlink_region_get_req_dump_set_dev_name(struct devlink_region_get_req_dump *req,
2768 const char *dev_name)
2770 free(req->dev_name);
2771 req->_present.dev_name_len = strlen(dev_name);
2772 req->dev_name = malloc(req->_present.dev_name_len + 1);
2773 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
2774 req->dev_name[req->_present.dev_name_len] = 0;
2777 struct devlink_region_get_list {
2778 struct devlink_region_get_list *next;
2779 struct devlink_region_get_rsp obj __attribute__((aligned(8)));
2782 void devlink_region_get_list_free(struct devlink_region_get_list *rsp);
2784 struct devlink_region_get_list *
2785 devlink_region_get_dump(struct ynl_sock *ys,
2786 struct devlink_region_get_req_dump *req);
2788 /* ============== DEVLINK_CMD_REGION_NEW ============== */
2789 /* DEVLINK_CMD_REGION_NEW - do */
2790 struct devlink_region_new_req {
2795 __u32 region_name_len;
2796 __u32 region_snapshot_id:1;
2803 __u32 region_snapshot_id;
2806 static inline struct devlink_region_new_req *devlink_region_new_req_alloc(void)
2808 return calloc(1, sizeof(struct devlink_region_new_req));
2810 void devlink_region_new_req_free(struct devlink_region_new_req *req);
2813 devlink_region_new_req_set_bus_name(struct devlink_region_new_req *req,
2814 const char *bus_name)
2816 free(req->bus_name);
2817 req->_present.bus_name_len = strlen(bus_name);
2818 req->bus_name = malloc(req->_present.bus_name_len + 1);
2819 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
2820 req->bus_name[req->_present.bus_name_len] = 0;
2823 devlink_region_new_req_set_dev_name(struct devlink_region_new_req *req,
2824 const char *dev_name)
2826 free(req->dev_name);
2827 req->_present.dev_name_len = strlen(dev_name);
2828 req->dev_name = malloc(req->_present.dev_name_len + 1);
2829 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
2830 req->dev_name[req->_present.dev_name_len] = 0;
2833 devlink_region_new_req_set_port_index(struct devlink_region_new_req *req,
2836 req->_present.port_index = 1;
2837 req->port_index = port_index;
2840 devlink_region_new_req_set_region_name(struct devlink_region_new_req *req,
2841 const char *region_name)
2843 free(req->region_name);
2844 req->_present.region_name_len = strlen(region_name);
2845 req->region_name = malloc(req->_present.region_name_len + 1);
2846 memcpy(req->region_name, region_name, req->_present.region_name_len);
2847 req->region_name[req->_present.region_name_len] = 0;
2850 devlink_region_new_req_set_region_snapshot_id(struct devlink_region_new_req *req,
2851 __u32 region_snapshot_id)
2853 req->_present.region_snapshot_id = 1;
2854 req->region_snapshot_id = region_snapshot_id;
2857 struct devlink_region_new_rsp {
2862 __u32 region_name_len;
2863 __u32 region_snapshot_id:1;
2870 __u32 region_snapshot_id;
2873 void devlink_region_new_rsp_free(struct devlink_region_new_rsp *rsp);
2876 * Create region snapshot.
2878 struct devlink_region_new_rsp *
2879 devlink_region_new(struct ynl_sock *ys, struct devlink_region_new_req *req);
2881 /* ============== DEVLINK_CMD_REGION_DEL ============== */
2882 /* DEVLINK_CMD_REGION_DEL - do */
2883 struct devlink_region_del_req {
2888 __u32 region_name_len;
2889 __u32 region_snapshot_id:1;
2896 __u32 region_snapshot_id;
2899 static inline struct devlink_region_del_req *devlink_region_del_req_alloc(void)
2901 return calloc(1, sizeof(struct devlink_region_del_req));
2903 void devlink_region_del_req_free(struct devlink_region_del_req *req);
2906 devlink_region_del_req_set_bus_name(struct devlink_region_del_req *req,
2907 const char *bus_name)
2909 free(req->bus_name);
2910 req->_present.bus_name_len = strlen(bus_name);
2911 req->bus_name = malloc(req->_present.bus_name_len + 1);
2912 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
2913 req->bus_name[req->_present.bus_name_len] = 0;
2916 devlink_region_del_req_set_dev_name(struct devlink_region_del_req *req,
2917 const char *dev_name)
2919 free(req->dev_name);
2920 req->_present.dev_name_len = strlen(dev_name);
2921 req->dev_name = malloc(req->_present.dev_name_len + 1);
2922 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
2923 req->dev_name[req->_present.dev_name_len] = 0;
2926 devlink_region_del_req_set_port_index(struct devlink_region_del_req *req,
2929 req->_present.port_index = 1;
2930 req->port_index = port_index;
2933 devlink_region_del_req_set_region_name(struct devlink_region_del_req *req,
2934 const char *region_name)
2936 free(req->region_name);
2937 req->_present.region_name_len = strlen(region_name);
2938 req->region_name = malloc(req->_present.region_name_len + 1);
2939 memcpy(req->region_name, region_name, req->_present.region_name_len);
2940 req->region_name[req->_present.region_name_len] = 0;
2943 devlink_region_del_req_set_region_snapshot_id(struct devlink_region_del_req *req,
2944 __u32 region_snapshot_id)
2946 req->_present.region_snapshot_id = 1;
2947 req->region_snapshot_id = region_snapshot_id;
2951 * Delete region snapshot.
2953 int devlink_region_del(struct ynl_sock *ys, struct devlink_region_del_req *req);
2955 /* ============== DEVLINK_CMD_REGION_READ ============== */
2956 /* DEVLINK_CMD_REGION_READ - dump */
2957 struct devlink_region_read_req_dump {
2962 __u32 region_name_len;
2963 __u32 region_snapshot_id:1;
2964 __u32 region_direct:1;
2965 __u32 region_chunk_addr:1;
2966 __u32 region_chunk_len:1;
2973 __u32 region_snapshot_id;
2974 __u64 region_chunk_addr;
2975 __u64 region_chunk_len;
2978 static inline struct devlink_region_read_req_dump *
2979 devlink_region_read_req_dump_alloc(void)
2981 return calloc(1, sizeof(struct devlink_region_read_req_dump));
2984 devlink_region_read_req_dump_free(struct devlink_region_read_req_dump *req);
2987 devlink_region_read_req_dump_set_bus_name(struct devlink_region_read_req_dump *req,
2988 const char *bus_name)
2990 free(req->bus_name);
2991 req->_present.bus_name_len = strlen(bus_name);
2992 req->bus_name = malloc(req->_present.bus_name_len + 1);
2993 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
2994 req->bus_name[req->_present.bus_name_len] = 0;
2997 devlink_region_read_req_dump_set_dev_name(struct devlink_region_read_req_dump *req,
2998 const char *dev_name)
3000 free(req->dev_name);
3001 req->_present.dev_name_len = strlen(dev_name);
3002 req->dev_name = malloc(req->_present.dev_name_len + 1);
3003 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
3004 req->dev_name[req->_present.dev_name_len] = 0;
3007 devlink_region_read_req_dump_set_port_index(struct devlink_region_read_req_dump *req,
3010 req->_present.port_index = 1;
3011 req->port_index = port_index;
3014 devlink_region_read_req_dump_set_region_name(struct devlink_region_read_req_dump *req,
3015 const char *region_name)
3017 free(req->region_name);
3018 req->_present.region_name_len = strlen(region_name);
3019 req->region_name = malloc(req->_present.region_name_len + 1);
3020 memcpy(req->region_name, region_name, req->_present.region_name_len);
3021 req->region_name[req->_present.region_name_len] = 0;
3024 devlink_region_read_req_dump_set_region_snapshot_id(struct devlink_region_read_req_dump *req,
3025 __u32 region_snapshot_id)
3027 req->_present.region_snapshot_id = 1;
3028 req->region_snapshot_id = region_snapshot_id;
3031 devlink_region_read_req_dump_set_region_direct(struct devlink_region_read_req_dump *req)
3033 req->_present.region_direct = 1;
3036 devlink_region_read_req_dump_set_region_chunk_addr(struct devlink_region_read_req_dump *req,
3037 __u64 region_chunk_addr)
3039 req->_present.region_chunk_addr = 1;
3040 req->region_chunk_addr = region_chunk_addr;
3043 devlink_region_read_req_dump_set_region_chunk_len(struct devlink_region_read_req_dump *req,
3044 __u64 region_chunk_len)
3046 req->_present.region_chunk_len = 1;
3047 req->region_chunk_len = region_chunk_len;
3050 struct devlink_region_read_rsp_dump {
3055 __u32 region_name_len;
3064 struct devlink_region_read_rsp_list {
3065 struct devlink_region_read_rsp_list *next;
3066 struct devlink_region_read_rsp_dump obj __attribute__((aligned(8)));
3070 devlink_region_read_rsp_list_free(struct devlink_region_read_rsp_list *rsp);
3072 struct devlink_region_read_rsp_list *
3073 devlink_region_read_dump(struct ynl_sock *ys,
3074 struct devlink_region_read_req_dump *req);
3076 /* ============== DEVLINK_CMD_PORT_PARAM_GET ============== */
3077 /* DEVLINK_CMD_PORT_PARAM_GET - do */
3078 struct devlink_port_param_get_req {
3090 static inline struct devlink_port_param_get_req *
3091 devlink_port_param_get_req_alloc(void)
3093 return calloc(1, sizeof(struct devlink_port_param_get_req));
3095 void devlink_port_param_get_req_free(struct devlink_port_param_get_req *req);
3098 devlink_port_param_get_req_set_bus_name(struct devlink_port_param_get_req *req,
3099 const char *bus_name)
3101 free(req->bus_name);
3102 req->_present.bus_name_len = strlen(bus_name);
3103 req->bus_name = malloc(req->_present.bus_name_len + 1);
3104 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
3105 req->bus_name[req->_present.bus_name_len] = 0;
3108 devlink_port_param_get_req_set_dev_name(struct devlink_port_param_get_req *req,
3109 const char *dev_name)
3111 free(req->dev_name);
3112 req->_present.dev_name_len = strlen(dev_name);
3113 req->dev_name = malloc(req->_present.dev_name_len + 1);
3114 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
3115 req->dev_name[req->_present.dev_name_len] = 0;
3118 devlink_port_param_get_req_set_port_index(struct devlink_port_param_get_req *req,
3121 req->_present.port_index = 1;
3122 req->port_index = port_index;
3125 struct devlink_port_param_get_rsp {
3137 void devlink_port_param_get_rsp_free(struct devlink_port_param_get_rsp *rsp);
3140 * Get port param instances.
3142 struct devlink_port_param_get_rsp *
3143 devlink_port_param_get(struct ynl_sock *ys,
3144 struct devlink_port_param_get_req *req);
3146 /* DEVLINK_CMD_PORT_PARAM_GET - dump */
3147 struct devlink_port_param_get_list {
3148 struct devlink_port_param_get_list *next;
3149 struct devlink_port_param_get_rsp obj __attribute__((aligned(8)));
3152 void devlink_port_param_get_list_free(struct devlink_port_param_get_list *rsp);
3154 struct devlink_port_param_get_list *
3155 devlink_port_param_get_dump(struct ynl_sock *ys);
3157 /* ============== DEVLINK_CMD_PORT_PARAM_SET ============== */
3158 /* DEVLINK_CMD_PORT_PARAM_SET - do */
3159 struct devlink_port_param_set_req {
3171 static inline struct devlink_port_param_set_req *
3172 devlink_port_param_set_req_alloc(void)
3174 return calloc(1, sizeof(struct devlink_port_param_set_req));
3176 void devlink_port_param_set_req_free(struct devlink_port_param_set_req *req);
3179 devlink_port_param_set_req_set_bus_name(struct devlink_port_param_set_req *req,
3180 const char *bus_name)
3182 free(req->bus_name);
3183 req->_present.bus_name_len = strlen(bus_name);
3184 req->bus_name = malloc(req->_present.bus_name_len + 1);
3185 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
3186 req->bus_name[req->_present.bus_name_len] = 0;
3189 devlink_port_param_set_req_set_dev_name(struct devlink_port_param_set_req *req,
3190 const char *dev_name)
3192 free(req->dev_name);
3193 req->_present.dev_name_len = strlen(dev_name);
3194 req->dev_name = malloc(req->_present.dev_name_len + 1);
3195 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
3196 req->dev_name[req->_present.dev_name_len] = 0;
3199 devlink_port_param_set_req_set_port_index(struct devlink_port_param_set_req *req,
3202 req->_present.port_index = 1;
3203 req->port_index = port_index;
3207 * Set port param instances.
3209 int devlink_port_param_set(struct ynl_sock *ys,
3210 struct devlink_port_param_set_req *req);
3212 /* ============== DEVLINK_CMD_INFO_GET ============== */
3213 /* DEVLINK_CMD_INFO_GET - do */
3214 struct devlink_info_get_req {
3224 static inline struct devlink_info_get_req *devlink_info_get_req_alloc(void)
3226 return calloc(1, sizeof(struct devlink_info_get_req));
3228 void devlink_info_get_req_free(struct devlink_info_get_req *req);
3231 devlink_info_get_req_set_bus_name(struct devlink_info_get_req *req,
3232 const char *bus_name)
3234 free(req->bus_name);
3235 req->_present.bus_name_len = strlen(bus_name);
3236 req->bus_name = malloc(req->_present.bus_name_len + 1);
3237 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
3238 req->bus_name[req->_present.bus_name_len] = 0;
3241 devlink_info_get_req_set_dev_name(struct devlink_info_get_req *req,
3242 const char *dev_name)
3244 free(req->dev_name);
3245 req->_present.dev_name_len = strlen(dev_name);
3246 req->dev_name = malloc(req->_present.dev_name_len + 1);
3247 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
3248 req->dev_name[req->_present.dev_name_len] = 0;
3251 struct devlink_info_get_rsp {
3255 __u32 info_driver_name_len;
3256 __u32 info_serial_number_len;
3261 char *info_driver_name;
3262 char *info_serial_number;
3263 unsigned int n_info_version_fixed;
3264 struct devlink_dl_info_version *info_version_fixed;
3265 unsigned int n_info_version_running;
3266 struct devlink_dl_info_version *info_version_running;
3267 unsigned int n_info_version_stored;
3268 struct devlink_dl_info_version *info_version_stored;
3271 void devlink_info_get_rsp_free(struct devlink_info_get_rsp *rsp);
3274 * Get device information, like driver name, hardware and firmware versions etc.
3276 struct devlink_info_get_rsp *
3277 devlink_info_get(struct ynl_sock *ys, struct devlink_info_get_req *req);
3279 /* DEVLINK_CMD_INFO_GET - dump */
3280 struct devlink_info_get_list {
3281 struct devlink_info_get_list *next;
3282 struct devlink_info_get_rsp obj __attribute__((aligned(8)));
3285 void devlink_info_get_list_free(struct devlink_info_get_list *rsp);
3287 struct devlink_info_get_list *devlink_info_get_dump(struct ynl_sock *ys);
3289 /* ============== DEVLINK_CMD_HEALTH_REPORTER_GET ============== */
3290 /* DEVLINK_CMD_HEALTH_REPORTER_GET - do */
3291 struct devlink_health_reporter_get_req {
3296 __u32 health_reporter_name_len;
3302 char *health_reporter_name;
3305 static inline struct devlink_health_reporter_get_req *
3306 devlink_health_reporter_get_req_alloc(void)
3308 return calloc(1, sizeof(struct devlink_health_reporter_get_req));
3311 devlink_health_reporter_get_req_free(struct devlink_health_reporter_get_req *req);
3314 devlink_health_reporter_get_req_set_bus_name(struct devlink_health_reporter_get_req *req,
3315 const char *bus_name)
3317 free(req->bus_name);
3318 req->_present.bus_name_len = strlen(bus_name);
3319 req->bus_name = malloc(req->_present.bus_name_len + 1);
3320 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
3321 req->bus_name[req->_present.bus_name_len] = 0;
3324 devlink_health_reporter_get_req_set_dev_name(struct devlink_health_reporter_get_req *req,
3325 const char *dev_name)
3327 free(req->dev_name);
3328 req->_present.dev_name_len = strlen(dev_name);
3329 req->dev_name = malloc(req->_present.dev_name_len + 1);
3330 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
3331 req->dev_name[req->_present.dev_name_len] = 0;
3334 devlink_health_reporter_get_req_set_port_index(struct devlink_health_reporter_get_req *req,
3337 req->_present.port_index = 1;
3338 req->port_index = port_index;
3341 devlink_health_reporter_get_req_set_health_reporter_name(struct devlink_health_reporter_get_req *req,
3342 const char *health_reporter_name)
3344 free(req->health_reporter_name);
3345 req->_present.health_reporter_name_len = strlen(health_reporter_name);
3346 req->health_reporter_name = malloc(req->_present.health_reporter_name_len + 1);
3347 memcpy(req->health_reporter_name, health_reporter_name, req->_present.health_reporter_name_len);
3348 req->health_reporter_name[req->_present.health_reporter_name_len] = 0;
3351 struct devlink_health_reporter_get_rsp {
3356 __u32 health_reporter_name_len;
3362 char *health_reporter_name;
3366 devlink_health_reporter_get_rsp_free(struct devlink_health_reporter_get_rsp *rsp);
3369 * Get health reporter instances.
3371 struct devlink_health_reporter_get_rsp *
3372 devlink_health_reporter_get(struct ynl_sock *ys,
3373 struct devlink_health_reporter_get_req *req);
3375 /* DEVLINK_CMD_HEALTH_REPORTER_GET - dump */
3376 struct devlink_health_reporter_get_req_dump {
3388 static inline struct devlink_health_reporter_get_req_dump *
3389 devlink_health_reporter_get_req_dump_alloc(void)
3391 return calloc(1, sizeof(struct devlink_health_reporter_get_req_dump));
3394 devlink_health_reporter_get_req_dump_free(struct devlink_health_reporter_get_req_dump *req);
3397 devlink_health_reporter_get_req_dump_set_bus_name(struct devlink_health_reporter_get_req_dump *req,
3398 const char *bus_name)
3400 free(req->bus_name);
3401 req->_present.bus_name_len = strlen(bus_name);
3402 req->bus_name = malloc(req->_present.bus_name_len + 1);
3403 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
3404 req->bus_name[req->_present.bus_name_len] = 0;
3407 devlink_health_reporter_get_req_dump_set_dev_name(struct devlink_health_reporter_get_req_dump *req,
3408 const char *dev_name)
3410 free(req->dev_name);
3411 req->_present.dev_name_len = strlen(dev_name);
3412 req->dev_name = malloc(req->_present.dev_name_len + 1);
3413 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
3414 req->dev_name[req->_present.dev_name_len] = 0;
3417 devlink_health_reporter_get_req_dump_set_port_index(struct devlink_health_reporter_get_req_dump *req,
3420 req->_present.port_index = 1;
3421 req->port_index = port_index;
3424 struct devlink_health_reporter_get_list {
3425 struct devlink_health_reporter_get_list *next;
3426 struct devlink_health_reporter_get_rsp obj __attribute__((aligned(8)));
3430 devlink_health_reporter_get_list_free(struct devlink_health_reporter_get_list *rsp);
3432 struct devlink_health_reporter_get_list *
3433 devlink_health_reporter_get_dump(struct ynl_sock *ys,
3434 struct devlink_health_reporter_get_req_dump *req);
3436 /* ============== DEVLINK_CMD_HEALTH_REPORTER_SET ============== */
3437 /* DEVLINK_CMD_HEALTH_REPORTER_SET - do */
3438 struct devlink_health_reporter_set_req {
3443 __u32 health_reporter_name_len;
3444 __u32 health_reporter_graceful_period:1;
3445 __u32 health_reporter_auto_recover:1;
3446 __u32 health_reporter_auto_dump:1;
3452 char *health_reporter_name;
3453 __u64 health_reporter_graceful_period;
3454 __u8 health_reporter_auto_recover;
3455 __u8 health_reporter_auto_dump;
3458 static inline struct devlink_health_reporter_set_req *
3459 devlink_health_reporter_set_req_alloc(void)
3461 return calloc(1, sizeof(struct devlink_health_reporter_set_req));
3464 devlink_health_reporter_set_req_free(struct devlink_health_reporter_set_req *req);
3467 devlink_health_reporter_set_req_set_bus_name(struct devlink_health_reporter_set_req *req,
3468 const char *bus_name)
3470 free(req->bus_name);
3471 req->_present.bus_name_len = strlen(bus_name);
3472 req->bus_name = malloc(req->_present.bus_name_len + 1);
3473 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
3474 req->bus_name[req->_present.bus_name_len] = 0;
3477 devlink_health_reporter_set_req_set_dev_name(struct devlink_health_reporter_set_req *req,
3478 const char *dev_name)
3480 free(req->dev_name);
3481 req->_present.dev_name_len = strlen(dev_name);
3482 req->dev_name = malloc(req->_present.dev_name_len + 1);
3483 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
3484 req->dev_name[req->_present.dev_name_len] = 0;
3487 devlink_health_reporter_set_req_set_port_index(struct devlink_health_reporter_set_req *req,
3490 req->_present.port_index = 1;
3491 req->port_index = port_index;
3494 devlink_health_reporter_set_req_set_health_reporter_name(struct devlink_health_reporter_set_req *req,
3495 const char *health_reporter_name)
3497 free(req->health_reporter_name);
3498 req->_present.health_reporter_name_len = strlen(health_reporter_name);
3499 req->health_reporter_name = malloc(req->_present.health_reporter_name_len + 1);
3500 memcpy(req->health_reporter_name, health_reporter_name, req->_present.health_reporter_name_len);
3501 req->health_reporter_name[req->_present.health_reporter_name_len] = 0;
3504 devlink_health_reporter_set_req_set_health_reporter_graceful_period(struct devlink_health_reporter_set_req *req,
3505 __u64 health_reporter_graceful_period)
3507 req->_present.health_reporter_graceful_period = 1;
3508 req->health_reporter_graceful_period = health_reporter_graceful_period;
3511 devlink_health_reporter_set_req_set_health_reporter_auto_recover(struct devlink_health_reporter_set_req *req,
3512 __u8 health_reporter_auto_recover)
3514 req->_present.health_reporter_auto_recover = 1;
3515 req->health_reporter_auto_recover = health_reporter_auto_recover;
3518 devlink_health_reporter_set_req_set_health_reporter_auto_dump(struct devlink_health_reporter_set_req *req,
3519 __u8 health_reporter_auto_dump)
3521 req->_present.health_reporter_auto_dump = 1;
3522 req->health_reporter_auto_dump = health_reporter_auto_dump;
3526 * Set health reporter instances.
3528 int devlink_health_reporter_set(struct ynl_sock *ys,
3529 struct devlink_health_reporter_set_req *req);
3531 /* ============== DEVLINK_CMD_HEALTH_REPORTER_RECOVER ============== */
3532 /* DEVLINK_CMD_HEALTH_REPORTER_RECOVER - do */
3533 struct devlink_health_reporter_recover_req {
3538 __u32 health_reporter_name_len;
3544 char *health_reporter_name;
3547 static inline struct devlink_health_reporter_recover_req *
3548 devlink_health_reporter_recover_req_alloc(void)
3550 return calloc(1, sizeof(struct devlink_health_reporter_recover_req));
3553 devlink_health_reporter_recover_req_free(struct devlink_health_reporter_recover_req *req);
3556 devlink_health_reporter_recover_req_set_bus_name(struct devlink_health_reporter_recover_req *req,
3557 const char *bus_name)
3559 free(req->bus_name);
3560 req->_present.bus_name_len = strlen(bus_name);
3561 req->bus_name = malloc(req->_present.bus_name_len + 1);
3562 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
3563 req->bus_name[req->_present.bus_name_len] = 0;
3566 devlink_health_reporter_recover_req_set_dev_name(struct devlink_health_reporter_recover_req *req,
3567 const char *dev_name)
3569 free(req->dev_name);
3570 req->_present.dev_name_len = strlen(dev_name);
3571 req->dev_name = malloc(req->_present.dev_name_len + 1);
3572 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
3573 req->dev_name[req->_present.dev_name_len] = 0;
3576 devlink_health_reporter_recover_req_set_port_index(struct devlink_health_reporter_recover_req *req,
3579 req->_present.port_index = 1;
3580 req->port_index = port_index;
3583 devlink_health_reporter_recover_req_set_health_reporter_name(struct devlink_health_reporter_recover_req *req,
3584 const char *health_reporter_name)
3586 free(req->health_reporter_name);
3587 req->_present.health_reporter_name_len = strlen(health_reporter_name);
3588 req->health_reporter_name = malloc(req->_present.health_reporter_name_len + 1);
3589 memcpy(req->health_reporter_name, health_reporter_name, req->_present.health_reporter_name_len);
3590 req->health_reporter_name[req->_present.health_reporter_name_len] = 0;
3594 * Recover health reporter instances.
3596 int devlink_health_reporter_recover(struct ynl_sock *ys,
3597 struct devlink_health_reporter_recover_req *req);
3599 /* ============== DEVLINK_CMD_HEALTH_REPORTER_DIAGNOSE ============== */
3600 /* DEVLINK_CMD_HEALTH_REPORTER_DIAGNOSE - do */
3601 struct devlink_health_reporter_diagnose_req {
3606 __u32 health_reporter_name_len;
3612 char *health_reporter_name;
3615 static inline struct devlink_health_reporter_diagnose_req *
3616 devlink_health_reporter_diagnose_req_alloc(void)
3618 return calloc(1, sizeof(struct devlink_health_reporter_diagnose_req));
3621 devlink_health_reporter_diagnose_req_free(struct devlink_health_reporter_diagnose_req *req);
3624 devlink_health_reporter_diagnose_req_set_bus_name(struct devlink_health_reporter_diagnose_req *req,
3625 const char *bus_name)
3627 free(req->bus_name);
3628 req->_present.bus_name_len = strlen(bus_name);
3629 req->bus_name = malloc(req->_present.bus_name_len + 1);
3630 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
3631 req->bus_name[req->_present.bus_name_len] = 0;
3634 devlink_health_reporter_diagnose_req_set_dev_name(struct devlink_health_reporter_diagnose_req *req,
3635 const char *dev_name)
3637 free(req->dev_name);
3638 req->_present.dev_name_len = strlen(dev_name);
3639 req->dev_name = malloc(req->_present.dev_name_len + 1);
3640 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
3641 req->dev_name[req->_present.dev_name_len] = 0;
3644 devlink_health_reporter_diagnose_req_set_port_index(struct devlink_health_reporter_diagnose_req *req,
3647 req->_present.port_index = 1;
3648 req->port_index = port_index;
3651 devlink_health_reporter_diagnose_req_set_health_reporter_name(struct devlink_health_reporter_diagnose_req *req,
3652 const char *health_reporter_name)
3654 free(req->health_reporter_name);
3655 req->_present.health_reporter_name_len = strlen(health_reporter_name);
3656 req->health_reporter_name = malloc(req->_present.health_reporter_name_len + 1);
3657 memcpy(req->health_reporter_name, health_reporter_name, req->_present.health_reporter_name_len);
3658 req->health_reporter_name[req->_present.health_reporter_name_len] = 0;
3662 * Diagnose health reporter instances.
3664 int devlink_health_reporter_diagnose(struct ynl_sock *ys,
3665 struct devlink_health_reporter_diagnose_req *req);
3667 /* ============== DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET ============== */
3668 /* DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET - dump */
3669 struct devlink_health_reporter_dump_get_req_dump {
3674 __u32 health_reporter_name_len;
3680 char *health_reporter_name;
3683 static inline struct devlink_health_reporter_dump_get_req_dump *
3684 devlink_health_reporter_dump_get_req_dump_alloc(void)
3686 return calloc(1, sizeof(struct devlink_health_reporter_dump_get_req_dump));
3689 devlink_health_reporter_dump_get_req_dump_free(struct devlink_health_reporter_dump_get_req_dump *req);
3692 devlink_health_reporter_dump_get_req_dump_set_bus_name(struct devlink_health_reporter_dump_get_req_dump *req,
3693 const char *bus_name)
3695 free(req->bus_name);
3696 req->_present.bus_name_len = strlen(bus_name);
3697 req->bus_name = malloc(req->_present.bus_name_len + 1);
3698 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
3699 req->bus_name[req->_present.bus_name_len] = 0;
3702 devlink_health_reporter_dump_get_req_dump_set_dev_name(struct devlink_health_reporter_dump_get_req_dump *req,
3703 const char *dev_name)
3705 free(req->dev_name);
3706 req->_present.dev_name_len = strlen(dev_name);
3707 req->dev_name = malloc(req->_present.dev_name_len + 1);
3708 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
3709 req->dev_name[req->_present.dev_name_len] = 0;
3712 devlink_health_reporter_dump_get_req_dump_set_port_index(struct devlink_health_reporter_dump_get_req_dump *req,
3715 req->_present.port_index = 1;
3716 req->port_index = port_index;
3719 devlink_health_reporter_dump_get_req_dump_set_health_reporter_name(struct devlink_health_reporter_dump_get_req_dump *req,
3720 const char *health_reporter_name)
3722 free(req->health_reporter_name);
3723 req->_present.health_reporter_name_len = strlen(health_reporter_name);
3724 req->health_reporter_name = malloc(req->_present.health_reporter_name_len + 1);
3725 memcpy(req->health_reporter_name, health_reporter_name, req->_present.health_reporter_name_len);
3726 req->health_reporter_name[req->_present.health_reporter_name_len] = 0;
3729 struct devlink_health_reporter_dump_get_rsp_dump {
3734 struct devlink_dl_fmsg fmsg;
3737 struct devlink_health_reporter_dump_get_rsp_list {
3738 struct devlink_health_reporter_dump_get_rsp_list *next;
3739 struct devlink_health_reporter_dump_get_rsp_dump obj __attribute__((aligned(8)));
3743 devlink_health_reporter_dump_get_rsp_list_free(struct devlink_health_reporter_dump_get_rsp_list *rsp);
3745 struct devlink_health_reporter_dump_get_rsp_list *
3746 devlink_health_reporter_dump_get_dump(struct ynl_sock *ys,
3747 struct devlink_health_reporter_dump_get_req_dump *req);
3749 /* ============== DEVLINK_CMD_HEALTH_REPORTER_DUMP_CLEAR ============== */
3750 /* DEVLINK_CMD_HEALTH_REPORTER_DUMP_CLEAR - do */
3751 struct devlink_health_reporter_dump_clear_req {
3756 __u32 health_reporter_name_len;
3762 char *health_reporter_name;
3765 static inline struct devlink_health_reporter_dump_clear_req *
3766 devlink_health_reporter_dump_clear_req_alloc(void)
3768 return calloc(1, sizeof(struct devlink_health_reporter_dump_clear_req));
3771 devlink_health_reporter_dump_clear_req_free(struct devlink_health_reporter_dump_clear_req *req);
3774 devlink_health_reporter_dump_clear_req_set_bus_name(struct devlink_health_reporter_dump_clear_req *req,
3775 const char *bus_name)
3777 free(req->bus_name);
3778 req->_present.bus_name_len = strlen(bus_name);
3779 req->bus_name = malloc(req->_present.bus_name_len + 1);
3780 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
3781 req->bus_name[req->_present.bus_name_len] = 0;
3784 devlink_health_reporter_dump_clear_req_set_dev_name(struct devlink_health_reporter_dump_clear_req *req,
3785 const char *dev_name)
3787 free(req->dev_name);
3788 req->_present.dev_name_len = strlen(dev_name);
3789 req->dev_name = malloc(req->_present.dev_name_len + 1);
3790 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
3791 req->dev_name[req->_present.dev_name_len] = 0;
3794 devlink_health_reporter_dump_clear_req_set_port_index(struct devlink_health_reporter_dump_clear_req *req,
3797 req->_present.port_index = 1;
3798 req->port_index = port_index;
3801 devlink_health_reporter_dump_clear_req_set_health_reporter_name(struct devlink_health_reporter_dump_clear_req *req,
3802 const char *health_reporter_name)
3804 free(req->health_reporter_name);
3805 req->_present.health_reporter_name_len = strlen(health_reporter_name);
3806 req->health_reporter_name = malloc(req->_present.health_reporter_name_len + 1);
3807 memcpy(req->health_reporter_name, health_reporter_name, req->_present.health_reporter_name_len);
3808 req->health_reporter_name[req->_present.health_reporter_name_len] = 0;
3812 * Clear dump of health reporter instances.
3814 int devlink_health_reporter_dump_clear(struct ynl_sock *ys,
3815 struct devlink_health_reporter_dump_clear_req *req);
3817 /* ============== DEVLINK_CMD_FLASH_UPDATE ============== */
3818 /* DEVLINK_CMD_FLASH_UPDATE - do */
3819 struct devlink_flash_update_req {
3823 __u32 flash_update_file_name_len;
3824 __u32 flash_update_component_len;
3825 __u32 flash_update_overwrite_mask:1;
3830 char *flash_update_file_name;
3831 char *flash_update_component;
3832 struct nla_bitfield32 flash_update_overwrite_mask;
3835 static inline struct devlink_flash_update_req *
3836 devlink_flash_update_req_alloc(void)
3838 return calloc(1, sizeof(struct devlink_flash_update_req));
3840 void devlink_flash_update_req_free(struct devlink_flash_update_req *req);
3843 devlink_flash_update_req_set_bus_name(struct devlink_flash_update_req *req,
3844 const char *bus_name)
3846 free(req->bus_name);
3847 req->_present.bus_name_len = strlen(bus_name);
3848 req->bus_name = malloc(req->_present.bus_name_len + 1);
3849 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
3850 req->bus_name[req->_present.bus_name_len] = 0;
3853 devlink_flash_update_req_set_dev_name(struct devlink_flash_update_req *req,
3854 const char *dev_name)
3856 free(req->dev_name);
3857 req->_present.dev_name_len = strlen(dev_name);
3858 req->dev_name = malloc(req->_present.dev_name_len + 1);
3859 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
3860 req->dev_name[req->_present.dev_name_len] = 0;
3863 devlink_flash_update_req_set_flash_update_file_name(struct devlink_flash_update_req *req,
3864 const char *flash_update_file_name)
3866 free(req->flash_update_file_name);
3867 req->_present.flash_update_file_name_len = strlen(flash_update_file_name);
3868 req->flash_update_file_name = malloc(req->_present.flash_update_file_name_len + 1);
3869 memcpy(req->flash_update_file_name, flash_update_file_name, req->_present.flash_update_file_name_len);
3870 req->flash_update_file_name[req->_present.flash_update_file_name_len] = 0;
3873 devlink_flash_update_req_set_flash_update_component(struct devlink_flash_update_req *req,
3874 const char *flash_update_component)
3876 free(req->flash_update_component);
3877 req->_present.flash_update_component_len = strlen(flash_update_component);
3878 req->flash_update_component = malloc(req->_present.flash_update_component_len + 1);
3879 memcpy(req->flash_update_component, flash_update_component, req->_present.flash_update_component_len);
3880 req->flash_update_component[req->_present.flash_update_component_len] = 0;
3883 devlink_flash_update_req_set_flash_update_overwrite_mask(struct devlink_flash_update_req *req,
3884 struct nla_bitfield32 *flash_update_overwrite_mask)
3886 req->_present.flash_update_overwrite_mask = 1;
3887 memcpy(&req->flash_update_overwrite_mask, flash_update_overwrite_mask, sizeof(struct nla_bitfield32));
3891 * Flash update devlink instances.
3893 int devlink_flash_update(struct ynl_sock *ys,
3894 struct devlink_flash_update_req *req);
3896 /* ============== DEVLINK_CMD_TRAP_GET ============== */
3897 /* DEVLINK_CMD_TRAP_GET - do */
3898 struct devlink_trap_get_req {
3902 __u32 trap_name_len;
3910 static inline struct devlink_trap_get_req *devlink_trap_get_req_alloc(void)
3912 return calloc(1, sizeof(struct devlink_trap_get_req));
3914 void devlink_trap_get_req_free(struct devlink_trap_get_req *req);
3917 devlink_trap_get_req_set_bus_name(struct devlink_trap_get_req *req,
3918 const char *bus_name)
3920 free(req->bus_name);
3921 req->_present.bus_name_len = strlen(bus_name);
3922 req->bus_name = malloc(req->_present.bus_name_len + 1);
3923 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
3924 req->bus_name[req->_present.bus_name_len] = 0;
3927 devlink_trap_get_req_set_dev_name(struct devlink_trap_get_req *req,
3928 const char *dev_name)
3930 free(req->dev_name);
3931 req->_present.dev_name_len = strlen(dev_name);
3932 req->dev_name = malloc(req->_present.dev_name_len + 1);
3933 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
3934 req->dev_name[req->_present.dev_name_len] = 0;
3937 devlink_trap_get_req_set_trap_name(struct devlink_trap_get_req *req,
3938 const char *trap_name)
3940 free(req->trap_name);
3941 req->_present.trap_name_len = strlen(trap_name);
3942 req->trap_name = malloc(req->_present.trap_name_len + 1);
3943 memcpy(req->trap_name, trap_name, req->_present.trap_name_len);
3944 req->trap_name[req->_present.trap_name_len] = 0;
3947 struct devlink_trap_get_rsp {
3951 __u32 trap_name_len;
3959 void devlink_trap_get_rsp_free(struct devlink_trap_get_rsp *rsp);
3962 * Get trap instances.
3964 struct devlink_trap_get_rsp *
3965 devlink_trap_get(struct ynl_sock *ys, struct devlink_trap_get_req *req);
3967 /* DEVLINK_CMD_TRAP_GET - dump */
3968 struct devlink_trap_get_req_dump {
3978 static inline struct devlink_trap_get_req_dump *
3979 devlink_trap_get_req_dump_alloc(void)
3981 return calloc(1, sizeof(struct devlink_trap_get_req_dump));
3983 void devlink_trap_get_req_dump_free(struct devlink_trap_get_req_dump *req);
3986 devlink_trap_get_req_dump_set_bus_name(struct devlink_trap_get_req_dump *req,
3987 const char *bus_name)
3989 free(req->bus_name);
3990 req->_present.bus_name_len = strlen(bus_name);
3991 req->bus_name = malloc(req->_present.bus_name_len + 1);
3992 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
3993 req->bus_name[req->_present.bus_name_len] = 0;
3996 devlink_trap_get_req_dump_set_dev_name(struct devlink_trap_get_req_dump *req,
3997 const char *dev_name)
3999 free(req->dev_name);
4000 req->_present.dev_name_len = strlen(dev_name);
4001 req->dev_name = malloc(req->_present.dev_name_len + 1);
4002 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
4003 req->dev_name[req->_present.dev_name_len] = 0;
4006 struct devlink_trap_get_list {
4007 struct devlink_trap_get_list *next;
4008 struct devlink_trap_get_rsp obj __attribute__((aligned(8)));
4011 void devlink_trap_get_list_free(struct devlink_trap_get_list *rsp);
4013 struct devlink_trap_get_list *
4014 devlink_trap_get_dump(struct ynl_sock *ys,
4015 struct devlink_trap_get_req_dump *req);
4017 /* ============== DEVLINK_CMD_TRAP_SET ============== */
4018 /* DEVLINK_CMD_TRAP_SET - do */
4019 struct devlink_trap_set_req {
4023 __u32 trap_name_len;
4024 __u32 trap_action:1;
4030 enum devlink_trap_action trap_action;
4033 static inline struct devlink_trap_set_req *devlink_trap_set_req_alloc(void)
4035 return calloc(1, sizeof(struct devlink_trap_set_req));
4037 void devlink_trap_set_req_free(struct devlink_trap_set_req *req);
4040 devlink_trap_set_req_set_bus_name(struct devlink_trap_set_req *req,
4041 const char *bus_name)
4043 free(req->bus_name);
4044 req->_present.bus_name_len = strlen(bus_name);
4045 req->bus_name = malloc(req->_present.bus_name_len + 1);
4046 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
4047 req->bus_name[req->_present.bus_name_len] = 0;
4050 devlink_trap_set_req_set_dev_name(struct devlink_trap_set_req *req,
4051 const char *dev_name)
4053 free(req->dev_name);
4054 req->_present.dev_name_len = strlen(dev_name);
4055 req->dev_name = malloc(req->_present.dev_name_len + 1);
4056 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
4057 req->dev_name[req->_present.dev_name_len] = 0;
4060 devlink_trap_set_req_set_trap_name(struct devlink_trap_set_req *req,
4061 const char *trap_name)
4063 free(req->trap_name);
4064 req->_present.trap_name_len = strlen(trap_name);
4065 req->trap_name = malloc(req->_present.trap_name_len + 1);
4066 memcpy(req->trap_name, trap_name, req->_present.trap_name_len);
4067 req->trap_name[req->_present.trap_name_len] = 0;
4070 devlink_trap_set_req_set_trap_action(struct devlink_trap_set_req *req,
4071 enum devlink_trap_action trap_action)
4073 req->_present.trap_action = 1;
4074 req->trap_action = trap_action;
4078 * Set trap instances.
4080 int devlink_trap_set(struct ynl_sock *ys, struct devlink_trap_set_req *req);
4082 /* ============== DEVLINK_CMD_TRAP_GROUP_GET ============== */
4083 /* DEVLINK_CMD_TRAP_GROUP_GET - do */
4084 struct devlink_trap_group_get_req {
4088 __u32 trap_group_name_len;
4093 char *trap_group_name;
4096 static inline struct devlink_trap_group_get_req *
4097 devlink_trap_group_get_req_alloc(void)
4099 return calloc(1, sizeof(struct devlink_trap_group_get_req));
4101 void devlink_trap_group_get_req_free(struct devlink_trap_group_get_req *req);
4104 devlink_trap_group_get_req_set_bus_name(struct devlink_trap_group_get_req *req,
4105 const char *bus_name)
4107 free(req->bus_name);
4108 req->_present.bus_name_len = strlen(bus_name);
4109 req->bus_name = malloc(req->_present.bus_name_len + 1);
4110 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
4111 req->bus_name[req->_present.bus_name_len] = 0;
4114 devlink_trap_group_get_req_set_dev_name(struct devlink_trap_group_get_req *req,
4115 const char *dev_name)
4117 free(req->dev_name);
4118 req->_present.dev_name_len = strlen(dev_name);
4119 req->dev_name = malloc(req->_present.dev_name_len + 1);
4120 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
4121 req->dev_name[req->_present.dev_name_len] = 0;
4124 devlink_trap_group_get_req_set_trap_group_name(struct devlink_trap_group_get_req *req,
4125 const char *trap_group_name)
4127 free(req->trap_group_name);
4128 req->_present.trap_group_name_len = strlen(trap_group_name);
4129 req->trap_group_name = malloc(req->_present.trap_group_name_len + 1);
4130 memcpy(req->trap_group_name, trap_group_name, req->_present.trap_group_name_len);
4131 req->trap_group_name[req->_present.trap_group_name_len] = 0;
4134 struct devlink_trap_group_get_rsp {
4138 __u32 trap_group_name_len;
4143 char *trap_group_name;
4146 void devlink_trap_group_get_rsp_free(struct devlink_trap_group_get_rsp *rsp);
4149 * Get trap group instances.
4151 struct devlink_trap_group_get_rsp *
4152 devlink_trap_group_get(struct ynl_sock *ys,
4153 struct devlink_trap_group_get_req *req);
4155 /* DEVLINK_CMD_TRAP_GROUP_GET - dump */
4156 struct devlink_trap_group_get_req_dump {
4166 static inline struct devlink_trap_group_get_req_dump *
4167 devlink_trap_group_get_req_dump_alloc(void)
4169 return calloc(1, sizeof(struct devlink_trap_group_get_req_dump));
4172 devlink_trap_group_get_req_dump_free(struct devlink_trap_group_get_req_dump *req);
4175 devlink_trap_group_get_req_dump_set_bus_name(struct devlink_trap_group_get_req_dump *req,
4176 const char *bus_name)
4178 free(req->bus_name);
4179 req->_present.bus_name_len = strlen(bus_name);
4180 req->bus_name = malloc(req->_present.bus_name_len + 1);
4181 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
4182 req->bus_name[req->_present.bus_name_len] = 0;
4185 devlink_trap_group_get_req_dump_set_dev_name(struct devlink_trap_group_get_req_dump *req,
4186 const char *dev_name)
4188 free(req->dev_name);
4189 req->_present.dev_name_len = strlen(dev_name);
4190 req->dev_name = malloc(req->_present.dev_name_len + 1);
4191 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
4192 req->dev_name[req->_present.dev_name_len] = 0;
4195 struct devlink_trap_group_get_list {
4196 struct devlink_trap_group_get_list *next;
4197 struct devlink_trap_group_get_rsp obj __attribute__((aligned(8)));
4200 void devlink_trap_group_get_list_free(struct devlink_trap_group_get_list *rsp);
4202 struct devlink_trap_group_get_list *
4203 devlink_trap_group_get_dump(struct ynl_sock *ys,
4204 struct devlink_trap_group_get_req_dump *req);
4206 /* ============== DEVLINK_CMD_TRAP_GROUP_SET ============== */
4207 /* DEVLINK_CMD_TRAP_GROUP_SET - do */
4208 struct devlink_trap_group_set_req {
4212 __u32 trap_group_name_len;
4213 __u32 trap_action:1;
4214 __u32 trap_policer_id:1;
4219 char *trap_group_name;
4220 enum devlink_trap_action trap_action;
4221 __u32 trap_policer_id;
4224 static inline struct devlink_trap_group_set_req *
4225 devlink_trap_group_set_req_alloc(void)
4227 return calloc(1, sizeof(struct devlink_trap_group_set_req));
4229 void devlink_trap_group_set_req_free(struct devlink_trap_group_set_req *req);
4232 devlink_trap_group_set_req_set_bus_name(struct devlink_trap_group_set_req *req,
4233 const char *bus_name)
4235 free(req->bus_name);
4236 req->_present.bus_name_len = strlen(bus_name);
4237 req->bus_name = malloc(req->_present.bus_name_len + 1);
4238 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
4239 req->bus_name[req->_present.bus_name_len] = 0;
4242 devlink_trap_group_set_req_set_dev_name(struct devlink_trap_group_set_req *req,
4243 const char *dev_name)
4245 free(req->dev_name);
4246 req->_present.dev_name_len = strlen(dev_name);
4247 req->dev_name = malloc(req->_present.dev_name_len + 1);
4248 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
4249 req->dev_name[req->_present.dev_name_len] = 0;
4252 devlink_trap_group_set_req_set_trap_group_name(struct devlink_trap_group_set_req *req,
4253 const char *trap_group_name)
4255 free(req->trap_group_name);
4256 req->_present.trap_group_name_len = strlen(trap_group_name);
4257 req->trap_group_name = malloc(req->_present.trap_group_name_len + 1);
4258 memcpy(req->trap_group_name, trap_group_name, req->_present.trap_group_name_len);
4259 req->trap_group_name[req->_present.trap_group_name_len] = 0;
4262 devlink_trap_group_set_req_set_trap_action(struct devlink_trap_group_set_req *req,
4263 enum devlink_trap_action trap_action)
4265 req->_present.trap_action = 1;
4266 req->trap_action = trap_action;
4269 devlink_trap_group_set_req_set_trap_policer_id(struct devlink_trap_group_set_req *req,
4270 __u32 trap_policer_id)
4272 req->_present.trap_policer_id = 1;
4273 req->trap_policer_id = trap_policer_id;
4277 * Set trap group instances.
4279 int devlink_trap_group_set(struct ynl_sock *ys,
4280 struct devlink_trap_group_set_req *req);
4282 /* ============== DEVLINK_CMD_TRAP_POLICER_GET ============== */
4283 /* DEVLINK_CMD_TRAP_POLICER_GET - do */
4284 struct devlink_trap_policer_get_req {
4288 __u32 trap_policer_id:1;
4293 __u32 trap_policer_id;
4296 static inline struct devlink_trap_policer_get_req *
4297 devlink_trap_policer_get_req_alloc(void)
4299 return calloc(1, sizeof(struct devlink_trap_policer_get_req));
4302 devlink_trap_policer_get_req_free(struct devlink_trap_policer_get_req *req);
4305 devlink_trap_policer_get_req_set_bus_name(struct devlink_trap_policer_get_req *req,
4306 const char *bus_name)
4308 free(req->bus_name);
4309 req->_present.bus_name_len = strlen(bus_name);
4310 req->bus_name = malloc(req->_present.bus_name_len + 1);
4311 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
4312 req->bus_name[req->_present.bus_name_len] = 0;
4315 devlink_trap_policer_get_req_set_dev_name(struct devlink_trap_policer_get_req *req,
4316 const char *dev_name)
4318 free(req->dev_name);
4319 req->_present.dev_name_len = strlen(dev_name);
4320 req->dev_name = malloc(req->_present.dev_name_len + 1);
4321 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
4322 req->dev_name[req->_present.dev_name_len] = 0;
4325 devlink_trap_policer_get_req_set_trap_policer_id(struct devlink_trap_policer_get_req *req,
4326 __u32 trap_policer_id)
4328 req->_present.trap_policer_id = 1;
4329 req->trap_policer_id = trap_policer_id;
4332 struct devlink_trap_policer_get_rsp {
4336 __u32 trap_policer_id:1;
4341 __u32 trap_policer_id;
4345 devlink_trap_policer_get_rsp_free(struct devlink_trap_policer_get_rsp *rsp);
4348 * Get trap policer instances.
4350 struct devlink_trap_policer_get_rsp *
4351 devlink_trap_policer_get(struct ynl_sock *ys,
4352 struct devlink_trap_policer_get_req *req);
4354 /* DEVLINK_CMD_TRAP_POLICER_GET - dump */
4355 struct devlink_trap_policer_get_req_dump {
4365 static inline struct devlink_trap_policer_get_req_dump *
4366 devlink_trap_policer_get_req_dump_alloc(void)
4368 return calloc(1, sizeof(struct devlink_trap_policer_get_req_dump));
4371 devlink_trap_policer_get_req_dump_free(struct devlink_trap_policer_get_req_dump *req);
4374 devlink_trap_policer_get_req_dump_set_bus_name(struct devlink_trap_policer_get_req_dump *req,
4375 const char *bus_name)
4377 free(req->bus_name);
4378 req->_present.bus_name_len = strlen(bus_name);
4379 req->bus_name = malloc(req->_present.bus_name_len + 1);
4380 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
4381 req->bus_name[req->_present.bus_name_len] = 0;
4384 devlink_trap_policer_get_req_dump_set_dev_name(struct devlink_trap_policer_get_req_dump *req,
4385 const char *dev_name)
4387 free(req->dev_name);
4388 req->_present.dev_name_len = strlen(dev_name);
4389 req->dev_name = malloc(req->_present.dev_name_len + 1);
4390 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
4391 req->dev_name[req->_present.dev_name_len] = 0;
4394 struct devlink_trap_policer_get_list {
4395 struct devlink_trap_policer_get_list *next;
4396 struct devlink_trap_policer_get_rsp obj __attribute__((aligned(8)));
4400 devlink_trap_policer_get_list_free(struct devlink_trap_policer_get_list *rsp);
4402 struct devlink_trap_policer_get_list *
4403 devlink_trap_policer_get_dump(struct ynl_sock *ys,
4404 struct devlink_trap_policer_get_req_dump *req);
4406 /* ============== DEVLINK_CMD_TRAP_POLICER_SET ============== */
4407 /* DEVLINK_CMD_TRAP_POLICER_SET - do */
4408 struct devlink_trap_policer_set_req {
4412 __u32 trap_policer_id:1;
4413 __u32 trap_policer_rate:1;
4414 __u32 trap_policer_burst:1;
4419 __u32 trap_policer_id;
4420 __u64 trap_policer_rate;
4421 __u64 trap_policer_burst;
4424 static inline struct devlink_trap_policer_set_req *
4425 devlink_trap_policer_set_req_alloc(void)
4427 return calloc(1, sizeof(struct devlink_trap_policer_set_req));
4430 devlink_trap_policer_set_req_free(struct devlink_trap_policer_set_req *req);
4433 devlink_trap_policer_set_req_set_bus_name(struct devlink_trap_policer_set_req *req,
4434 const char *bus_name)
4436 free(req->bus_name);
4437 req->_present.bus_name_len = strlen(bus_name);
4438 req->bus_name = malloc(req->_present.bus_name_len + 1);
4439 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
4440 req->bus_name[req->_present.bus_name_len] = 0;
4443 devlink_trap_policer_set_req_set_dev_name(struct devlink_trap_policer_set_req *req,
4444 const char *dev_name)
4446 free(req->dev_name);
4447 req->_present.dev_name_len = strlen(dev_name);
4448 req->dev_name = malloc(req->_present.dev_name_len + 1);
4449 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
4450 req->dev_name[req->_present.dev_name_len] = 0;
4453 devlink_trap_policer_set_req_set_trap_policer_id(struct devlink_trap_policer_set_req *req,
4454 __u32 trap_policer_id)
4456 req->_present.trap_policer_id = 1;
4457 req->trap_policer_id = trap_policer_id;
4460 devlink_trap_policer_set_req_set_trap_policer_rate(struct devlink_trap_policer_set_req *req,
4461 __u64 trap_policer_rate)
4463 req->_present.trap_policer_rate = 1;
4464 req->trap_policer_rate = trap_policer_rate;
4467 devlink_trap_policer_set_req_set_trap_policer_burst(struct devlink_trap_policer_set_req *req,
4468 __u64 trap_policer_burst)
4470 req->_present.trap_policer_burst = 1;
4471 req->trap_policer_burst = trap_policer_burst;
4475 * Get trap policer instances.
4477 int devlink_trap_policer_set(struct ynl_sock *ys,
4478 struct devlink_trap_policer_set_req *req);
4480 /* ============== DEVLINK_CMD_HEALTH_REPORTER_TEST ============== */
4481 /* DEVLINK_CMD_HEALTH_REPORTER_TEST - do */
4482 struct devlink_health_reporter_test_req {
4487 __u32 health_reporter_name_len;
4493 char *health_reporter_name;
4496 static inline struct devlink_health_reporter_test_req *
4497 devlink_health_reporter_test_req_alloc(void)
4499 return calloc(1, sizeof(struct devlink_health_reporter_test_req));
4502 devlink_health_reporter_test_req_free(struct devlink_health_reporter_test_req *req);
4505 devlink_health_reporter_test_req_set_bus_name(struct devlink_health_reporter_test_req *req,
4506 const char *bus_name)
4508 free(req->bus_name);
4509 req->_present.bus_name_len = strlen(bus_name);
4510 req->bus_name = malloc(req->_present.bus_name_len + 1);
4511 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
4512 req->bus_name[req->_present.bus_name_len] = 0;
4515 devlink_health_reporter_test_req_set_dev_name(struct devlink_health_reporter_test_req *req,
4516 const char *dev_name)
4518 free(req->dev_name);
4519 req->_present.dev_name_len = strlen(dev_name);
4520 req->dev_name = malloc(req->_present.dev_name_len + 1);
4521 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
4522 req->dev_name[req->_present.dev_name_len] = 0;
4525 devlink_health_reporter_test_req_set_port_index(struct devlink_health_reporter_test_req *req,
4528 req->_present.port_index = 1;
4529 req->port_index = port_index;
4532 devlink_health_reporter_test_req_set_health_reporter_name(struct devlink_health_reporter_test_req *req,
4533 const char *health_reporter_name)
4535 free(req->health_reporter_name);
4536 req->_present.health_reporter_name_len = strlen(health_reporter_name);
4537 req->health_reporter_name = malloc(req->_present.health_reporter_name_len + 1);
4538 memcpy(req->health_reporter_name, health_reporter_name, req->_present.health_reporter_name_len);
4539 req->health_reporter_name[req->_present.health_reporter_name_len] = 0;
4543 * Test health reporter instances.
4545 int devlink_health_reporter_test(struct ynl_sock *ys,
4546 struct devlink_health_reporter_test_req *req);
4548 /* ============== DEVLINK_CMD_RATE_GET ============== */
4549 /* DEVLINK_CMD_RATE_GET - do */
4550 struct devlink_rate_get_req {
4555 __u32 rate_node_name_len;
4561 char *rate_node_name;
4564 static inline struct devlink_rate_get_req *devlink_rate_get_req_alloc(void)
4566 return calloc(1, sizeof(struct devlink_rate_get_req));
4568 void devlink_rate_get_req_free(struct devlink_rate_get_req *req);
4571 devlink_rate_get_req_set_bus_name(struct devlink_rate_get_req *req,
4572 const char *bus_name)
4574 free(req->bus_name);
4575 req->_present.bus_name_len = strlen(bus_name);
4576 req->bus_name = malloc(req->_present.bus_name_len + 1);
4577 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
4578 req->bus_name[req->_present.bus_name_len] = 0;
4581 devlink_rate_get_req_set_dev_name(struct devlink_rate_get_req *req,
4582 const char *dev_name)
4584 free(req->dev_name);
4585 req->_present.dev_name_len = strlen(dev_name);
4586 req->dev_name = malloc(req->_present.dev_name_len + 1);
4587 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
4588 req->dev_name[req->_present.dev_name_len] = 0;
4591 devlink_rate_get_req_set_port_index(struct devlink_rate_get_req *req,
4594 req->_present.port_index = 1;
4595 req->port_index = port_index;
4598 devlink_rate_get_req_set_rate_node_name(struct devlink_rate_get_req *req,
4599 const char *rate_node_name)
4601 free(req->rate_node_name);
4602 req->_present.rate_node_name_len = strlen(rate_node_name);
4603 req->rate_node_name = malloc(req->_present.rate_node_name_len + 1);
4604 memcpy(req->rate_node_name, rate_node_name, req->_present.rate_node_name_len);
4605 req->rate_node_name[req->_present.rate_node_name_len] = 0;
4608 struct devlink_rate_get_rsp {
4613 __u32 rate_node_name_len;
4619 char *rate_node_name;
4622 void devlink_rate_get_rsp_free(struct devlink_rate_get_rsp *rsp);
4625 * Get rate instances.
4627 struct devlink_rate_get_rsp *
4628 devlink_rate_get(struct ynl_sock *ys, struct devlink_rate_get_req *req);
4630 /* DEVLINK_CMD_RATE_GET - dump */
4631 struct devlink_rate_get_req_dump {
4641 static inline struct devlink_rate_get_req_dump *
4642 devlink_rate_get_req_dump_alloc(void)
4644 return calloc(1, sizeof(struct devlink_rate_get_req_dump));
4646 void devlink_rate_get_req_dump_free(struct devlink_rate_get_req_dump *req);
4649 devlink_rate_get_req_dump_set_bus_name(struct devlink_rate_get_req_dump *req,
4650 const char *bus_name)
4652 free(req->bus_name);
4653 req->_present.bus_name_len = strlen(bus_name);
4654 req->bus_name = malloc(req->_present.bus_name_len + 1);
4655 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
4656 req->bus_name[req->_present.bus_name_len] = 0;
4659 devlink_rate_get_req_dump_set_dev_name(struct devlink_rate_get_req_dump *req,
4660 const char *dev_name)
4662 free(req->dev_name);
4663 req->_present.dev_name_len = strlen(dev_name);
4664 req->dev_name = malloc(req->_present.dev_name_len + 1);
4665 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
4666 req->dev_name[req->_present.dev_name_len] = 0;
4669 struct devlink_rate_get_list {
4670 struct devlink_rate_get_list *next;
4671 struct devlink_rate_get_rsp obj __attribute__((aligned(8)));
4674 void devlink_rate_get_list_free(struct devlink_rate_get_list *rsp);
4676 struct devlink_rate_get_list *
4677 devlink_rate_get_dump(struct ynl_sock *ys,
4678 struct devlink_rate_get_req_dump *req);
4680 /* ============== DEVLINK_CMD_RATE_SET ============== */
4681 /* DEVLINK_CMD_RATE_SET - do */
4682 struct devlink_rate_set_req {
4686 __u32 rate_node_name_len;
4687 __u32 rate_tx_share:1;
4688 __u32 rate_tx_max:1;
4689 __u32 rate_tx_priority:1;
4690 __u32 rate_tx_weight:1;
4691 __u32 rate_parent_node_name_len;
4696 char *rate_node_name;
4697 __u64 rate_tx_share;
4699 __u32 rate_tx_priority;
4700 __u32 rate_tx_weight;
4701 char *rate_parent_node_name;
4704 static inline struct devlink_rate_set_req *devlink_rate_set_req_alloc(void)
4706 return calloc(1, sizeof(struct devlink_rate_set_req));
4708 void devlink_rate_set_req_free(struct devlink_rate_set_req *req);
4711 devlink_rate_set_req_set_bus_name(struct devlink_rate_set_req *req,
4712 const char *bus_name)
4714 free(req->bus_name);
4715 req->_present.bus_name_len = strlen(bus_name);
4716 req->bus_name = malloc(req->_present.bus_name_len + 1);
4717 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
4718 req->bus_name[req->_present.bus_name_len] = 0;
4721 devlink_rate_set_req_set_dev_name(struct devlink_rate_set_req *req,
4722 const char *dev_name)
4724 free(req->dev_name);
4725 req->_present.dev_name_len = strlen(dev_name);
4726 req->dev_name = malloc(req->_present.dev_name_len + 1);
4727 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
4728 req->dev_name[req->_present.dev_name_len] = 0;
4731 devlink_rate_set_req_set_rate_node_name(struct devlink_rate_set_req *req,
4732 const char *rate_node_name)
4734 free(req->rate_node_name);
4735 req->_present.rate_node_name_len = strlen(rate_node_name);
4736 req->rate_node_name = malloc(req->_present.rate_node_name_len + 1);
4737 memcpy(req->rate_node_name, rate_node_name, req->_present.rate_node_name_len);
4738 req->rate_node_name[req->_present.rate_node_name_len] = 0;
4741 devlink_rate_set_req_set_rate_tx_share(struct devlink_rate_set_req *req,
4742 __u64 rate_tx_share)
4744 req->_present.rate_tx_share = 1;
4745 req->rate_tx_share = rate_tx_share;
4748 devlink_rate_set_req_set_rate_tx_max(struct devlink_rate_set_req *req,
4751 req->_present.rate_tx_max = 1;
4752 req->rate_tx_max = rate_tx_max;
4755 devlink_rate_set_req_set_rate_tx_priority(struct devlink_rate_set_req *req,
4756 __u32 rate_tx_priority)
4758 req->_present.rate_tx_priority = 1;
4759 req->rate_tx_priority = rate_tx_priority;
4762 devlink_rate_set_req_set_rate_tx_weight(struct devlink_rate_set_req *req,
4763 __u32 rate_tx_weight)
4765 req->_present.rate_tx_weight = 1;
4766 req->rate_tx_weight = rate_tx_weight;
4769 devlink_rate_set_req_set_rate_parent_node_name(struct devlink_rate_set_req *req,
4770 const char *rate_parent_node_name)
4772 free(req->rate_parent_node_name);
4773 req->_present.rate_parent_node_name_len = strlen(rate_parent_node_name);
4774 req->rate_parent_node_name = malloc(req->_present.rate_parent_node_name_len + 1);
4775 memcpy(req->rate_parent_node_name, rate_parent_node_name, req->_present.rate_parent_node_name_len);
4776 req->rate_parent_node_name[req->_present.rate_parent_node_name_len] = 0;
4780 * Set rate instances.
4782 int devlink_rate_set(struct ynl_sock *ys, struct devlink_rate_set_req *req);
4784 /* ============== DEVLINK_CMD_RATE_NEW ============== */
4785 /* DEVLINK_CMD_RATE_NEW - do */
4786 struct devlink_rate_new_req {
4790 __u32 rate_node_name_len;
4791 __u32 rate_tx_share:1;
4792 __u32 rate_tx_max:1;
4793 __u32 rate_tx_priority:1;
4794 __u32 rate_tx_weight:1;
4795 __u32 rate_parent_node_name_len;
4800 char *rate_node_name;
4801 __u64 rate_tx_share;
4803 __u32 rate_tx_priority;
4804 __u32 rate_tx_weight;
4805 char *rate_parent_node_name;
4808 static inline struct devlink_rate_new_req *devlink_rate_new_req_alloc(void)
4810 return calloc(1, sizeof(struct devlink_rate_new_req));
4812 void devlink_rate_new_req_free(struct devlink_rate_new_req *req);
4815 devlink_rate_new_req_set_bus_name(struct devlink_rate_new_req *req,
4816 const char *bus_name)
4818 free(req->bus_name);
4819 req->_present.bus_name_len = strlen(bus_name);
4820 req->bus_name = malloc(req->_present.bus_name_len + 1);
4821 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
4822 req->bus_name[req->_present.bus_name_len] = 0;
4825 devlink_rate_new_req_set_dev_name(struct devlink_rate_new_req *req,
4826 const char *dev_name)
4828 free(req->dev_name);
4829 req->_present.dev_name_len = strlen(dev_name);
4830 req->dev_name = malloc(req->_present.dev_name_len + 1);
4831 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
4832 req->dev_name[req->_present.dev_name_len] = 0;
4835 devlink_rate_new_req_set_rate_node_name(struct devlink_rate_new_req *req,
4836 const char *rate_node_name)
4838 free(req->rate_node_name);
4839 req->_present.rate_node_name_len = strlen(rate_node_name);
4840 req->rate_node_name = malloc(req->_present.rate_node_name_len + 1);
4841 memcpy(req->rate_node_name, rate_node_name, req->_present.rate_node_name_len);
4842 req->rate_node_name[req->_present.rate_node_name_len] = 0;
4845 devlink_rate_new_req_set_rate_tx_share(struct devlink_rate_new_req *req,
4846 __u64 rate_tx_share)
4848 req->_present.rate_tx_share = 1;
4849 req->rate_tx_share = rate_tx_share;
4852 devlink_rate_new_req_set_rate_tx_max(struct devlink_rate_new_req *req,
4855 req->_present.rate_tx_max = 1;
4856 req->rate_tx_max = rate_tx_max;
4859 devlink_rate_new_req_set_rate_tx_priority(struct devlink_rate_new_req *req,
4860 __u32 rate_tx_priority)
4862 req->_present.rate_tx_priority = 1;
4863 req->rate_tx_priority = rate_tx_priority;
4866 devlink_rate_new_req_set_rate_tx_weight(struct devlink_rate_new_req *req,
4867 __u32 rate_tx_weight)
4869 req->_present.rate_tx_weight = 1;
4870 req->rate_tx_weight = rate_tx_weight;
4873 devlink_rate_new_req_set_rate_parent_node_name(struct devlink_rate_new_req *req,
4874 const char *rate_parent_node_name)
4876 free(req->rate_parent_node_name);
4877 req->_present.rate_parent_node_name_len = strlen(rate_parent_node_name);
4878 req->rate_parent_node_name = malloc(req->_present.rate_parent_node_name_len + 1);
4879 memcpy(req->rate_parent_node_name, rate_parent_node_name, req->_present.rate_parent_node_name_len);
4880 req->rate_parent_node_name[req->_present.rate_parent_node_name_len] = 0;
4884 * Create rate instances.
4886 int devlink_rate_new(struct ynl_sock *ys, struct devlink_rate_new_req *req);
4888 /* ============== DEVLINK_CMD_RATE_DEL ============== */
4889 /* DEVLINK_CMD_RATE_DEL - do */
4890 struct devlink_rate_del_req {
4894 __u32 rate_node_name_len;
4899 char *rate_node_name;
4902 static inline struct devlink_rate_del_req *devlink_rate_del_req_alloc(void)
4904 return calloc(1, sizeof(struct devlink_rate_del_req));
4906 void devlink_rate_del_req_free(struct devlink_rate_del_req *req);
4909 devlink_rate_del_req_set_bus_name(struct devlink_rate_del_req *req,
4910 const char *bus_name)
4912 free(req->bus_name);
4913 req->_present.bus_name_len = strlen(bus_name);
4914 req->bus_name = malloc(req->_present.bus_name_len + 1);
4915 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
4916 req->bus_name[req->_present.bus_name_len] = 0;
4919 devlink_rate_del_req_set_dev_name(struct devlink_rate_del_req *req,
4920 const char *dev_name)
4922 free(req->dev_name);
4923 req->_present.dev_name_len = strlen(dev_name);
4924 req->dev_name = malloc(req->_present.dev_name_len + 1);
4925 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
4926 req->dev_name[req->_present.dev_name_len] = 0;
4929 devlink_rate_del_req_set_rate_node_name(struct devlink_rate_del_req *req,
4930 const char *rate_node_name)
4932 free(req->rate_node_name);
4933 req->_present.rate_node_name_len = strlen(rate_node_name);
4934 req->rate_node_name = malloc(req->_present.rate_node_name_len + 1);
4935 memcpy(req->rate_node_name, rate_node_name, req->_present.rate_node_name_len);
4936 req->rate_node_name[req->_present.rate_node_name_len] = 0;
4940 * Delete rate instances.
4942 int devlink_rate_del(struct ynl_sock *ys, struct devlink_rate_del_req *req);
4944 /* ============== DEVLINK_CMD_LINECARD_GET ============== */
4945 /* DEVLINK_CMD_LINECARD_GET - do */
4946 struct devlink_linecard_get_req {
4950 __u32 linecard_index:1;
4955 __u32 linecard_index;
4958 static inline struct devlink_linecard_get_req *
4959 devlink_linecard_get_req_alloc(void)
4961 return calloc(1, sizeof(struct devlink_linecard_get_req));
4963 void devlink_linecard_get_req_free(struct devlink_linecard_get_req *req);
4966 devlink_linecard_get_req_set_bus_name(struct devlink_linecard_get_req *req,
4967 const char *bus_name)
4969 free(req->bus_name);
4970 req->_present.bus_name_len = strlen(bus_name);
4971 req->bus_name = malloc(req->_present.bus_name_len + 1);
4972 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
4973 req->bus_name[req->_present.bus_name_len] = 0;
4976 devlink_linecard_get_req_set_dev_name(struct devlink_linecard_get_req *req,
4977 const char *dev_name)
4979 free(req->dev_name);
4980 req->_present.dev_name_len = strlen(dev_name);
4981 req->dev_name = malloc(req->_present.dev_name_len + 1);
4982 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
4983 req->dev_name[req->_present.dev_name_len] = 0;
4986 devlink_linecard_get_req_set_linecard_index(struct devlink_linecard_get_req *req,
4987 __u32 linecard_index)
4989 req->_present.linecard_index = 1;
4990 req->linecard_index = linecard_index;
4993 struct devlink_linecard_get_rsp {
4997 __u32 linecard_index:1;
5002 __u32 linecard_index;
5005 void devlink_linecard_get_rsp_free(struct devlink_linecard_get_rsp *rsp);
5008 * Get line card instances.
5010 struct devlink_linecard_get_rsp *
5011 devlink_linecard_get(struct ynl_sock *ys, struct devlink_linecard_get_req *req);
5013 /* DEVLINK_CMD_LINECARD_GET - dump */
5014 struct devlink_linecard_get_req_dump {
5024 static inline struct devlink_linecard_get_req_dump *
5025 devlink_linecard_get_req_dump_alloc(void)
5027 return calloc(1, sizeof(struct devlink_linecard_get_req_dump));
5030 devlink_linecard_get_req_dump_free(struct devlink_linecard_get_req_dump *req);
5033 devlink_linecard_get_req_dump_set_bus_name(struct devlink_linecard_get_req_dump *req,
5034 const char *bus_name)
5036 free(req->bus_name);
5037 req->_present.bus_name_len = strlen(bus_name);
5038 req->bus_name = malloc(req->_present.bus_name_len + 1);
5039 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
5040 req->bus_name[req->_present.bus_name_len] = 0;
5043 devlink_linecard_get_req_dump_set_dev_name(struct devlink_linecard_get_req_dump *req,
5044 const char *dev_name)
5046 free(req->dev_name);
5047 req->_present.dev_name_len = strlen(dev_name);
5048 req->dev_name = malloc(req->_present.dev_name_len + 1);
5049 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
5050 req->dev_name[req->_present.dev_name_len] = 0;
5053 struct devlink_linecard_get_list {
5054 struct devlink_linecard_get_list *next;
5055 struct devlink_linecard_get_rsp obj __attribute__((aligned(8)));
5058 void devlink_linecard_get_list_free(struct devlink_linecard_get_list *rsp);
5060 struct devlink_linecard_get_list *
5061 devlink_linecard_get_dump(struct ynl_sock *ys,
5062 struct devlink_linecard_get_req_dump *req);
5064 /* ============== DEVLINK_CMD_LINECARD_SET ============== */
5065 /* DEVLINK_CMD_LINECARD_SET - do */
5066 struct devlink_linecard_set_req {
5070 __u32 linecard_index:1;
5071 __u32 linecard_type_len;
5076 __u32 linecard_index;
5077 char *linecard_type;
5080 static inline struct devlink_linecard_set_req *
5081 devlink_linecard_set_req_alloc(void)
5083 return calloc(1, sizeof(struct devlink_linecard_set_req));
5085 void devlink_linecard_set_req_free(struct devlink_linecard_set_req *req);
5088 devlink_linecard_set_req_set_bus_name(struct devlink_linecard_set_req *req,
5089 const char *bus_name)
5091 free(req->bus_name);
5092 req->_present.bus_name_len = strlen(bus_name);
5093 req->bus_name = malloc(req->_present.bus_name_len + 1);
5094 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
5095 req->bus_name[req->_present.bus_name_len] = 0;
5098 devlink_linecard_set_req_set_dev_name(struct devlink_linecard_set_req *req,
5099 const char *dev_name)
5101 free(req->dev_name);
5102 req->_present.dev_name_len = strlen(dev_name);
5103 req->dev_name = malloc(req->_present.dev_name_len + 1);
5104 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
5105 req->dev_name[req->_present.dev_name_len] = 0;
5108 devlink_linecard_set_req_set_linecard_index(struct devlink_linecard_set_req *req,
5109 __u32 linecard_index)
5111 req->_present.linecard_index = 1;
5112 req->linecard_index = linecard_index;
5115 devlink_linecard_set_req_set_linecard_type(struct devlink_linecard_set_req *req,
5116 const char *linecard_type)
5118 free(req->linecard_type);
5119 req->_present.linecard_type_len = strlen(linecard_type);
5120 req->linecard_type = malloc(req->_present.linecard_type_len + 1);
5121 memcpy(req->linecard_type, linecard_type, req->_present.linecard_type_len);
5122 req->linecard_type[req->_present.linecard_type_len] = 0;
5126 * Set line card instances.
5128 int devlink_linecard_set(struct ynl_sock *ys,
5129 struct devlink_linecard_set_req *req);
5131 /* ============== DEVLINK_CMD_SELFTESTS_GET ============== */
5132 /* DEVLINK_CMD_SELFTESTS_GET - do */
5133 struct devlink_selftests_get_req {
5143 static inline struct devlink_selftests_get_req *
5144 devlink_selftests_get_req_alloc(void)
5146 return calloc(1, sizeof(struct devlink_selftests_get_req));
5148 void devlink_selftests_get_req_free(struct devlink_selftests_get_req *req);
5151 devlink_selftests_get_req_set_bus_name(struct devlink_selftests_get_req *req,
5152 const char *bus_name)
5154 free(req->bus_name);
5155 req->_present.bus_name_len = strlen(bus_name);
5156 req->bus_name = malloc(req->_present.bus_name_len + 1);
5157 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
5158 req->bus_name[req->_present.bus_name_len] = 0;
5161 devlink_selftests_get_req_set_dev_name(struct devlink_selftests_get_req *req,
5162 const char *dev_name)
5164 free(req->dev_name);
5165 req->_present.dev_name_len = strlen(dev_name);
5166 req->dev_name = malloc(req->_present.dev_name_len + 1);
5167 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
5168 req->dev_name[req->_present.dev_name_len] = 0;
5171 struct devlink_selftests_get_rsp {
5181 void devlink_selftests_get_rsp_free(struct devlink_selftests_get_rsp *rsp);
5184 * Get device selftest instances.
5186 struct devlink_selftests_get_rsp *
5187 devlink_selftests_get(struct ynl_sock *ys,
5188 struct devlink_selftests_get_req *req);
5190 /* DEVLINK_CMD_SELFTESTS_GET - dump */
5191 struct devlink_selftests_get_list {
5192 struct devlink_selftests_get_list *next;
5193 struct devlink_selftests_get_rsp obj __attribute__((aligned(8)));
5196 void devlink_selftests_get_list_free(struct devlink_selftests_get_list *rsp);
5198 struct devlink_selftests_get_list *
5199 devlink_selftests_get_dump(struct ynl_sock *ys);
5201 /* ============== DEVLINK_CMD_SELFTESTS_RUN ============== */
5202 /* DEVLINK_CMD_SELFTESTS_RUN - do */
5203 struct devlink_selftests_run_req {
5212 struct devlink_dl_selftest_id selftests;
5215 static inline struct devlink_selftests_run_req *
5216 devlink_selftests_run_req_alloc(void)
5218 return calloc(1, sizeof(struct devlink_selftests_run_req));
5220 void devlink_selftests_run_req_free(struct devlink_selftests_run_req *req);
5223 devlink_selftests_run_req_set_bus_name(struct devlink_selftests_run_req *req,
5224 const char *bus_name)
5226 free(req->bus_name);
5227 req->_present.bus_name_len = strlen(bus_name);
5228 req->bus_name = malloc(req->_present.bus_name_len + 1);
5229 memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
5230 req->bus_name[req->_present.bus_name_len] = 0;
5233 devlink_selftests_run_req_set_dev_name(struct devlink_selftests_run_req *req,
5234 const char *dev_name)
5236 free(req->dev_name);
5237 req->_present.dev_name_len = strlen(dev_name);
5238 req->dev_name = malloc(req->_present.dev_name_len + 1);
5239 memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
5240 req->dev_name[req->_present.dev_name_len] = 0;
5243 devlink_selftests_run_req_set_selftests_flash(struct devlink_selftests_run_req *req)
5245 req->_present.selftests = 1;
5246 req->selftests._present.flash = 1;
5250 * Run device selftest instances.
5252 int devlink_selftests_run(struct ynl_sock *ys,
5253 struct devlink_selftests_run_req *req);
5255 #endif /* _LINUX_DEVLINK_GEN_H */