summary |
shortlog |
log |
commit | commitdiff |
tree
raw |
patch |
inline | side by side (from parent 1:
d0ac7bb)
There is a common macro __rte_unused, avoiding warnings,
which is now used where appropriate for consistency.
Signed-off-by: Thomas Monjalon <thomas@monjalon.net>
105 files changed:
-search_ip5tuples(__attribute__((unused)) void *arg)
+search_ip5tuples(__rte_unused void *arg)
{
uint64_t pkt, start, tm;
uint32_t i, lcore;
{
uint64_t pkt, start, tm;
uint32_t i, lcore;
#include <ctype.h>
#include <sys/queue.h>
#include <ctype.h>
#include <sys/queue.h>
+#include <rte_common.h>
+
#include <cmdline_rdline.h>
#include <cmdline_parse.h>
#include <cmdline_socket.h>
#include <cmdline_rdline.h>
#include <cmdline_parse.h>
#include <cmdline_socket.h>
#include "cmdline_test.h"
int
#include "cmdline_test.h"
int
-main(int __attribute__((unused)) argc, char __attribute__((unused)) ** argv)
+main(int __rte_unused argc, char __rte_unused ** argv)
#include <termios.h>
#include <inttypes.h>
#include <termios.h>
#include <inttypes.h>
+#include <rte_common.h>
+
#include <cmdline_rdline.h>
#include <cmdline_parse.h>
#include <cmdline_parse_string.h>
#include <cmdline_rdline.h>
#include <cmdline_parse.h>
#include <cmdline_parse_string.h>
-cmd_quit_parsed(__attribute__((unused)) void *parsed_result,
+cmd_quit_parsed(__rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
-cmd_single_parsed(__attribute__((unused)) void *parsed_result,
+cmd_single_parsed(__rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
cmdline_printf(cl, "Single word command parsed!\n");
}
{
cmdline_printf(cl, "Single word command parsed!\n");
}
-cmd_single_long_parsed(__attribute__((unused)) void *parsed_result,
+cmd_single_long_parsed(__rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
cmdline_printf(cl, "Single long word command parsed!\n");
}
{
cmdline_printf(cl, "Single long word command parsed!\n");
}
-cmd_autocomplete_1_parsed(__attribute__((unused)) void *parsed_result,
+cmd_autocomplete_1_parsed(__rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
cmdline_printf(cl, "Autocomplete command 1 parsed!\n");
}
{
cmdline_printf(cl, "Autocomplete command 1 parsed!\n");
}
-cmd_autocomplete_2_parsed(__attribute__((unused)) void *parsed_result,
+cmd_autocomplete_2_parsed(__rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
cmdline_printf(cl, "Autocomplete command 2 parsed!\n");
}
{
cmdline_printf(cl, "Autocomplete command 2 parsed!\n");
}
static void
cmd_num_parsed(void *parsed_result,
struct cmdline *cl,
static void
cmd_num_parsed(void *parsed_result,
struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
unsigned result = ((struct cmd_num_result*)parsed_result)->num;
cmdline_printf(cl, "%u\n", result);
{
unsigned result = ((struct cmd_num_result*)parsed_result)->num;
cmdline_printf(cl, "%u\n", result);
-cmd_ambig_1_parsed(__attribute__((unused)) void *parsed_result,
+cmd_ambig_1_parsed(__rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
cmdline_printf(cl, "Command 1 parsed!\n");
}
{
cmdline_printf(cl, "Command 1 parsed!\n");
}
-cmd_ambig_2_parsed(__attribute__((unused)) void *parsed_result,
+cmd_ambig_2_parsed(__rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
cmdline_printf(cl, "Command 2 parsed!\n");
}
{
cmdline_printf(cl, "Command 2 parsed!\n");
}
-cmd_get_history_bufsize_parsed(__attribute__((unused)) void *parsed_result,
+cmd_get_history_bufsize_parsed(__rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
cmdline_printf(cl, "History buffer size: %zu\n",
sizeof(cl->rdl.history_buf));
{
cmdline_printf(cl, "History buffer size: %zu\n",
sizeof(cl->rdl.history_buf));
-cmd_clear_history_parsed(__attribute__((unused)) void *parsed_result,
+cmd_clear_history_parsed(__rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
rdline_clear_history(&cl->rdl);
}
{
rdline_clear_history(&cl->rdl);
}
mempool_obj_init(struct rte_mempool *mp,
void *opaque_arg,
void *obj,
mempool_obj_init(struct rte_mempool *mp,
void *opaque_arg,
void *obj,
- __attribute__((unused)) unsigned int i)
+ __rte_unused unsigned int i)
{
struct obj_params *params = opaque_arg;
struct rte_crypto_op *op = obj;
{
struct obj_params *params = opaque_arg;
struct rte_crypto_op *op = obj;
-app_lcore_main_loop(__attribute__((unused)) void *arg)
+app_lcore_main_loop(__rte_unused void *arg)
uint64_t test_hash(
void *key,
uint64_t test_hash(
void *key,
- __attribute__((unused)) void *key_mask,
- __attribute__((unused)) uint32_t key_size,
- __attribute__((unused)) uint64_t seed)
+ __rte_unused void *key_mask,
+ __rte_unused uint32_t key_size,
+ __rte_unused uint64_t seed)
{
uint32_t *k32 = key;
uint32_t ip_dst = rte_be_to_cpu_32(k32[0]);
{
uint32_t *k32 = key;
uint32_t ip_dst = rte_be_to_cpu_32(k32[0]);
uint32_t test_hash_cuckoo(
const void *key,
uint32_t test_hash_cuckoo(
const void *key,
- __attribute__((unused)) uint32_t key_size,
- __attribute__((unused)) uint32_t seed)
+ __rte_unused uint32_t key_size,
+ __rte_unused uint32_t seed)
{
const uint32_t *k32 = key;
uint32_t ip_dst = rte_be_to_cpu_32(k32[0]);
{
const uint32_t *k32 = key;
uint32_t ip_dst = rte_be_to_cpu_32(k32[0]);
}
static void cmd_operate_bpf_ld_parsed(void *parsed_result,
}
static void cmd_operate_bpf_ld_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
int32_t rc;
uint32_t flags;
{
int32_t rc;
uint32_t flags;
};
static void cmd_operate_bpf_unld_parsed(void *parsed_result,
};
static void cmd_operate_bpf_unld_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_bpf_unld_result *res;
{
struct cmd_bpf_unld_result *res;
cmdline_fixed_string_t help;
};
cmdline_fixed_string_t help;
};
-static void cmd_help_brief_parsed(__attribute__((unused)) void *parsed_result,
+static void cmd_help_brief_parsed(__rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
static void cmd_help_long_parsed(void *parsed_result,
struct cmdline *cl,
static void cmd_help_long_parsed(void *parsed_result,
struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
int show_all = 0;
struct cmd_help_long_result *res = parsed_result;
{
int show_all = 0;
struct cmd_help_long_result *res = parsed_result;
};
static void cmd_operate_port_parsed(void *parsed_result,
};
static void cmd_operate_port_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_operate_port_result *res = parsed_result;
{
struct cmd_operate_port_result *res = parsed_result;
};
static void cmd_operate_specific_port_parsed(void *parsed_result,
};
static void cmd_operate_specific_port_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_operate_specific_port_result *res = parsed_result;
{
struct cmd_operate_specific_port_result *res = parsed_result;
};
static void cmd_set_port_setup_on_parsed(void *parsed_result,
};
static void cmd_set_port_setup_on_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_port_setup_on_result *res = parsed_result;
{
struct cmd_set_port_setup_on_result *res = parsed_result;
};
static void cmd_operate_attach_port_parsed(void *parsed_result,
};
static void cmd_operate_attach_port_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_operate_attach_port_result *res = parsed_result;
{
struct cmd_operate_attach_port_result *res = parsed_result;
};
static void cmd_operate_detach_port_parsed(void *parsed_result,
};
static void cmd_operate_detach_port_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_operate_detach_port_result *res = parsed_result;
{
struct cmd_operate_detach_port_result *res = parsed_result;
};
static void cmd_operate_detach_device_parsed(void *parsed_result,
};
static void cmd_operate_detach_device_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_operate_detach_device_result *res = parsed_result;
{
struct cmd_operate_detach_device_result *res = parsed_result;
static void
cmd_config_speed_all_parsed(void *parsed_result,
static void
cmd_config_speed_all_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_speed_all *res = parsed_result;
uint32_t link_speed;
{
struct cmd_config_speed_all *res = parsed_result;
uint32_t link_speed;
static void
cmd_config_speed_specific_parsed(void *parsed_result,
static void
cmd_config_speed_specific_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_speed_specific *res = parsed_result;
uint32_t link_speed;
{
struct cmd_config_speed_specific *res = parsed_result;
uint32_t link_speed;
static void
cmd_config_loopback_all_parsed(void *parsed_result,
static void
cmd_config_loopback_all_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_loopback_all *res = parsed_result;
portid_t pid;
{
struct cmd_config_loopback_all *res = parsed_result;
portid_t pid;
static void
cmd_config_loopback_specific_parsed(void *parsed_result,
static void
cmd_config_loopback_specific_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_loopback_specific *res = parsed_result;
{
struct cmd_config_loopback_specific *res = parsed_result;
static void
cmd_config_rx_tx_parsed(void *parsed_result,
static void
cmd_config_rx_tx_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_rx_tx *res = parsed_result;
{
struct cmd_config_rx_tx *res = parsed_result;
static void
cmd_config_max_pkt_len_parsed(void *parsed_result,
static void
cmd_config_max_pkt_len_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_max_pkt_len_result *res = parsed_result;
portid_t pid;
{
struct cmd_config_max_pkt_len_result *res = parsed_result;
portid_t pid;
static void
cmd_config_max_lro_pkt_size_parsed(void *parsed_result,
static void
cmd_config_max_lro_pkt_size_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_max_lro_pkt_size_result *res = parsed_result;
portid_t pid;
{
struct cmd_config_max_lro_pkt_size_result *res = parsed_result;
portid_t pid;
static void
cmd_config_mtu_parsed(void *parsed_result,
static void
cmd_config_mtu_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_mtu_result *res = parsed_result;
{
struct cmd_config_mtu_result *res = parsed_result;
static void
cmd_config_rx_mode_flag_parsed(void *parsed_result,
static void
cmd_config_rx_mode_flag_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_rx_mode_flag *res = parsed_result;
{
struct cmd_config_rx_mode_flag *res = parsed_result;
static void
cmd_config_rss_parsed(void *parsed_result,
static void
cmd_config_rss_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_rss *res = parsed_result;
struct rte_eth_rss_conf rss_conf = { .rss_key_len = 0, };
{
struct cmd_config_rss *res = parsed_result;
struct rte_eth_rss_conf rss_conf = { .rss_key_len = 0, };
static void
cmd_config_rss_hash_key_parsed(void *parsed_result,
static void
cmd_config_rss_hash_key_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_rss_hash_key *res = parsed_result;
uint8_t hash_key[RSS_HASH_KEY_LENGTH];
{
struct cmd_config_rss_hash_key *res = parsed_result;
uint8_t hash_key[RSS_HASH_KEY_LENGTH];
static void
cmd_config_rxtx_ring_size_parsed(void *parsed_result,
static void
cmd_config_rxtx_ring_size_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_rxtx_ring_size *res = parsed_result;
struct rte_port *port;
{
struct cmd_config_rxtx_ring_size *res = parsed_result;
struct rte_port *port;
static void
cmd_config_rxtx_queue_parsed(void *parsed_result,
static void
cmd_config_rxtx_queue_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_rxtx_queue *res = parsed_result;
uint8_t isrx;
{
struct cmd_config_rxtx_queue *res = parsed_result;
uint8_t isrx;
static void
cmd_config_deferred_start_rxtx_queue_parsed(void *parsed_result,
static void
cmd_config_deferred_start_rxtx_queue_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_deferred_start_rxtx_queue *res = parsed_result;
struct rte_port *port;
{
struct cmd_config_deferred_start_rxtx_queue *res = parsed_result;
struct rte_port *port;
static void
cmd_setup_rxtx_queue_parsed(
void *parsed_result,
static void
cmd_setup_rxtx_queue_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_setup_rxtx_queue *res = parsed_result;
struct rte_port *port;
{
struct cmd_setup_rxtx_queue *res = parsed_result;
struct rte_port *port;
static void
cmd_set_rss_reta_parsed(void *parsed_result,
static void
cmd_set_rss_reta_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
int ret;
struct rte_eth_dev_info dev_info;
{
int ret;
struct rte_eth_dev_info dev_info;
static void
cmd_showport_reta_parsed(void *parsed_result,
static void
cmd_showport_reta_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_showport_reta *res = parsed_result;
struct rte_eth_rss_reta_entry64 reta_conf[8];
{
struct cmd_showport_reta *res = parsed_result;
struct rte_eth_rss_reta_entry64 reta_conf[8];
};
static void cmd_showport_rss_hash_parsed(void *parsed_result,
};
static void cmd_showport_rss_hash_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
+ __rte_unused struct cmdline *cl,
void *show_rss_key)
{
struct cmd_showport_rss_hash *res = parsed_result;
void *show_rss_key)
{
struct cmd_showport_rss_hash *res = parsed_result;
static void
cmd_config_dcb_parsed(void *parsed_result,
static void
cmd_config_dcb_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_dcb *res = parsed_result;
portid_t port_id = res->port_id;
{
struct cmd_config_dcb *res = parsed_result;
portid_t port_id = res->port_id;
static void
cmd_config_burst_parsed(void *parsed_result,
static void
cmd_config_burst_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_burst *res = parsed_result;
struct rte_eth_dev_info dev_info;
{
struct cmd_config_burst *res = parsed_result;
struct rte_eth_dev_info dev_info;
static void
cmd_config_thresh_parsed(void *parsed_result,
static void
cmd_config_thresh_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_thresh *res = parsed_result;
{
struct cmd_config_thresh *res = parsed_result;
static void
cmd_config_threshold_parsed(void *parsed_result,
static void
cmd_config_threshold_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_threshold *res = parsed_result;
{
struct cmd_config_threshold *res = parsed_result;
cmdline_fixed_string_t stop;
};
cmdline_fixed_string_t stop;
};
-static void cmd_stop_parsed(__attribute__((unused)) void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+static void cmd_stop_parsed(__rte_unused void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
stop_packet_forwarding();
}
{
stop_packet_forwarding();
}
};
static void cmd_set_list_parsed(void *parsed_result,
};
static void cmd_set_list_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_list_result *res;
union {
{
struct cmd_set_list_result *res;
union {
};
static void cmd_set_mask_parsed(void *parsed_result,
};
static void cmd_set_mask_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_setmask_result *res = parsed_result;
{
struct cmd_setmask_result *res = parsed_result;
};
static void cmd_set_parsed(void *parsed_result,
};
static void cmd_set_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_result *res = parsed_result;
if (!strcmp(res->what, "nbport")) {
{
struct cmd_set_result *res = parsed_result;
if (!strcmp(res->what, "nbport")) {
static void
cmd_set_log_parsed(void *parsed_result,
static void
cmd_set_log_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_log_result *res;
int ret;
{
struct cmd_set_log_result *res;
int ret;
static void
cmd_set_txpkts_parsed(void *parsed_result,
static void
cmd_set_txpkts_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_txpkts_result *res;
unsigned seg_lengths[RTE_MAX_SEGS_PER_PKT];
{
struct cmd_set_txpkts_result *res;
unsigned seg_lengths[RTE_MAX_SEGS_PER_PKT];
static void
cmd_set_txsplit_parsed(void *parsed_result,
static void
cmd_set_txsplit_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_txsplit_result *res;
{
struct cmd_set_txsplit_result *res;
static void
cmd_rx_vlan_filter_all_parsed(void *parsed_result,
static void
cmd_rx_vlan_filter_all_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_rx_vlan_filter_all_result *res = parsed_result;
{
struct cmd_rx_vlan_filter_all_result *res = parsed_result;
static void
cmd_vlan_offload_parsed(void *parsed_result,
static void
cmd_vlan_offload_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
int on;
struct cmd_vlan_offload_result *res = parsed_result;
{
int on;
struct cmd_vlan_offload_result *res = parsed_result;
static void
cmd_vlan_tpid_parsed(void *parsed_result,
static void
cmd_vlan_tpid_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vlan_tpid_result *res = parsed_result;
enum rte_vlan_type vlan_type;
{
struct cmd_vlan_tpid_result *res = parsed_result;
enum rte_vlan_type vlan_type;
static void
cmd_rx_vlan_filter_parsed(void *parsed_result,
static void
cmd_rx_vlan_filter_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_rx_vlan_filter_result *res = parsed_result;
{
struct cmd_rx_vlan_filter_result *res = parsed_result;
static void
cmd_tx_vlan_set_parsed(void *parsed_result,
static void
cmd_tx_vlan_set_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_tx_vlan_set_result *res = parsed_result;
{
struct cmd_tx_vlan_set_result *res = parsed_result;
static void
cmd_tx_vlan_set_qinq_parsed(void *parsed_result,
static void
cmd_tx_vlan_set_qinq_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_tx_vlan_set_qinq_result *res = parsed_result;
{
struct cmd_tx_vlan_set_qinq_result *res = parsed_result;
static void
cmd_tx_vlan_set_pvid_parsed(void *parsed_result,
static void
cmd_tx_vlan_set_pvid_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_tx_vlan_set_pvid_result *res = parsed_result;
{
struct cmd_tx_vlan_set_pvid_result *res = parsed_result;
static void
cmd_tx_vlan_reset_parsed(void *parsed_result,
static void
cmd_tx_vlan_reset_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_tx_vlan_reset_result *res = parsed_result;
{
struct cmd_tx_vlan_reset_result *res = parsed_result;
static void
cmd_csum_parsed(void *parsed_result,
static void
cmd_csum_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_csum_result *res = parsed_result;
int hw = 0;
{
struct cmd_csum_result *res = parsed_result;
int hw = 0;
static void
cmd_csum_tunnel_parsed(void *parsed_result,
static void
cmd_csum_tunnel_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_csum_tunnel_result *res = parsed_result;
{
struct cmd_csum_tunnel_result *res = parsed_result;
static void
cmd_tso_set_parsed(void *parsed_result,
static void
cmd_tso_set_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_tso_set_result *res = parsed_result;
struct rte_eth_dev_info dev_info;
{
struct cmd_tso_set_result *res = parsed_result;
struct rte_eth_dev_info dev_info;
static void
cmd_tunnel_tso_set_parsed(void *parsed_result,
static void
cmd_tunnel_tso_set_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_tunnel_tso_set_result *res = parsed_result;
struct rte_eth_dev_info dev_info;
{
struct cmd_tunnel_tso_set_result *res = parsed_result;
struct rte_eth_dev_info dev_info;
static void
cmd_gro_enable_parsed(void *parsed_result,
static void
cmd_gro_enable_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_gro_enable_result *res;
{
struct cmd_gro_enable_result *res;
static void
cmd_gro_show_parsed(void *parsed_result,
static void
cmd_gro_show_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_gro_show_result *res;
{
struct cmd_gro_show_result *res;
static void
cmd_gro_flush_parsed(void *parsed_result,
static void
cmd_gro_flush_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_gro_flush_result *res;
{
struct cmd_gro_flush_result *res;
static void
cmd_gso_enable_parsed(void *parsed_result,
static void
cmd_gso_enable_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_gso_enable_result *res;
{
struct cmd_gso_enable_result *res;
static void
cmd_gso_size_parsed(void *parsed_result,
static void
cmd_gso_size_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_gso_size_result *res = parsed_result;
{
struct cmd_gso_size_result *res = parsed_result;
static void
cmd_gso_show_parsed(void *parsed_result,
static void
cmd_gso_show_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_gso_show_result *res = parsed_result;
{
struct cmd_gso_show_result *res = parsed_result;
static void
cmd_set_flush_rx_parsed(void *parsed_result,
static void
cmd_set_flush_rx_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_flush_rx *res = parsed_result;
no_flush_rx = (uint8_t)((strcmp(res->mode, "on") == 0) ? 0 : 1);
{
struct cmd_set_flush_rx *res = parsed_result;
no_flush_rx = (uint8_t)((strcmp(res->mode, "on") == 0) ? 0 : 1);
static void
cmd_set_link_check_parsed(void *parsed_result,
static void
cmd_set_link_check_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_link_check *res = parsed_result;
no_link_check = (uint8_t)((strcmp(res->mode, "on") == 0) ? 0 : 1);
{
struct cmd_set_link_check *res = parsed_result;
no_link_check = (uint8_t)((strcmp(res->mode, "on") == 0) ? 0 : 1);
static void
cmd_set_bypass_mode_parsed(void *parsed_result,
static void
cmd_set_bypass_mode_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_bypass_mode_result *res = parsed_result;
portid_t port_id = res->port_id;
{
struct cmd_set_bypass_mode_result *res = parsed_result;
portid_t port_id = res->port_id;
static void
cmd_set_bypass_event_parsed(void *parsed_result,
static void
cmd_set_bypass_event_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
int32_t rc = -EINVAL;
struct cmd_set_bypass_event_result *res = parsed_result;
{
int32_t rc = -EINVAL;
struct cmd_set_bypass_event_result *res = parsed_result;
static void
cmd_set_bypass_timeout_parsed(void *parsed_result,
static void
cmd_set_bypass_timeout_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
__rte_unused struct cmd_set_bypass_timeout_result *res = parsed_result;
{
__rte_unused struct cmd_set_bypass_timeout_result *res = parsed_result;
static void
cmd_show_bypass_config_parsed(void *parsed_result,
static void
cmd_show_bypass_config_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_show_bypass_config_result *res = parsed_result;
portid_t port_id = res->port_id;
{
struct cmd_show_bypass_config_result *res = parsed_result;
portid_t port_id = res->port_id;
};
static void cmd_set_bonding_mode_parsed(void *parsed_result,
};
static void cmd_set_bonding_mode_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_bonding_mode_result *res = parsed_result;
portid_t port_id = res->port_id;
{
struct cmd_set_bonding_mode_result *res = parsed_result;
portid_t port_id = res->port_id;
};
static void cmd_set_bonding_lacp_dedicated_queues_parsed(void *parsed_result,
};
static void cmd_set_bonding_lacp_dedicated_queues_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_bonding_lacp_dedicated_queues_result *res = parsed_result;
portid_t port_id = res->port_id;
{
struct cmd_set_bonding_lacp_dedicated_queues_result *res = parsed_result;
portid_t port_id = res->port_id;
};
static void cmd_set_bonding_balance_xmit_policy_parsed(void *parsed_result,
};
static void cmd_set_bonding_balance_xmit_policy_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_bonding_balance_xmit_policy_result *res = parsed_result;
portid_t port_id = res->port_id;
{
struct cmd_set_bonding_balance_xmit_policy_result *res = parsed_result;
portid_t port_id = res->port_id;
};
static void cmd_show_bonding_config_parsed(void *parsed_result,
};
static void cmd_show_bonding_config_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_show_bonding_config_result *res = parsed_result;
int bonding_mode, agg_mode;
{
struct cmd_show_bonding_config_result *res = parsed_result;
int bonding_mode, agg_mode;
};
static void cmd_set_bonding_primary_parsed(void *parsed_result,
};
static void cmd_set_bonding_primary_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_bonding_primary_result *res = parsed_result;
portid_t master_port_id = res->port_id;
{
struct cmd_set_bonding_primary_result *res = parsed_result;
portid_t master_port_id = res->port_id;
};
static void cmd_add_bonding_slave_parsed(void *parsed_result,
};
static void cmd_add_bonding_slave_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_add_bonding_slave_result *res = parsed_result;
portid_t master_port_id = res->port_id;
{
struct cmd_add_bonding_slave_result *res = parsed_result;
portid_t master_port_id = res->port_id;
};
static void cmd_remove_bonding_slave_parsed(void *parsed_result,
};
static void cmd_remove_bonding_slave_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_remove_bonding_slave_result *res = parsed_result;
portid_t master_port_id = res->port_id;
{
struct cmd_remove_bonding_slave_result *res = parsed_result;
portid_t master_port_id = res->port_id;
static int bond_dev_num = 0;
static void cmd_create_bonded_device_parsed(void *parsed_result,
static int bond_dev_num = 0;
static void cmd_create_bonded_device_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_create_bonded_device_result *res = parsed_result;
char ethdev_name[RTE_ETH_NAME_MAX_LEN];
{
struct cmd_create_bonded_device_result *res = parsed_result;
char ethdev_name[RTE_ETH_NAME_MAX_LEN];
};
static void cmd_set_bond_mac_addr_parsed(void *parsed_result,
};
static void cmd_set_bond_mac_addr_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_bond_mac_addr_result *res = parsed_result;
int ret;
{
struct cmd_set_bond_mac_addr_result *res = parsed_result;
int ret;
};
static void cmd_set_bond_mon_period_parsed(void *parsed_result,
};
static void cmd_set_bond_mon_period_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_bond_mon_period_result *res = parsed_result;
int ret;
{
struct cmd_set_bond_mon_period_result *res = parsed_result;
int ret;
static void
cmd_set_bonding_agg_mode(void *parsed_result,
static void
cmd_set_bonding_agg_mode(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_bonding_agg_mode_policy_result *res = parsed_result;
uint8_t policy = AGG_BANDWIDTH;
{
struct cmd_set_bonding_agg_mode_policy_result *res = parsed_result;
uint8_t policy = AGG_BANDWIDTH;
};
static void cmd_set_fwd_mode_parsed(void *parsed_result,
};
static void cmd_set_fwd_mode_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_fwd_mode_result *res = parsed_result;
{
struct cmd_set_fwd_mode_result *res = parsed_result;
};
static void cmd_set_fwd_retry_mode_parsed(void *parsed_result,
};
static void cmd_set_fwd_retry_mode_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_fwd_retry_mode_result *res = parsed_result;
{
struct cmd_set_fwd_retry_mode_result *res = parsed_result;
};
static void cmd_set_burst_tx_retry_parsed(void *parsed_result,
};
static void cmd_set_burst_tx_retry_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_burst_tx_retry_result *res = parsed_result;
{
struct cmd_set_burst_tx_retry_result *res = parsed_result;
};
static void cmd_set_promisc_mode_parsed(void *parsed_result,
};
static void cmd_set_promisc_mode_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
+ __rte_unused struct cmdline *cl,
void *allports)
{
struct cmd_set_promisc_mode_result *res = parsed_result;
void *allports)
{
struct cmd_set_promisc_mode_result *res = parsed_result;
};
static void cmd_set_allmulti_mode_parsed(void *parsed_result,
};
static void cmd_set_allmulti_mode_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
+ __rte_unused struct cmdline *cl,
void *allports)
{
struct cmd_set_allmulti_mode_result *res = parsed_result;
void *allports)
{
struct cmd_set_allmulti_mode_result *res = parsed_result;
static void
cmd_link_flow_ctrl_set_parsed(void *parsed_result,
static void
cmd_link_flow_ctrl_set_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
+ __rte_unused struct cmdline *cl,
void *data)
{
struct cmd_link_flow_ctrl_set_result *res = parsed_result;
void *data)
{
struct cmd_link_flow_ctrl_set_result *res = parsed_result;
static void
cmd_priority_flow_ctrl_set_parsed(void *parsed_result,
static void
cmd_priority_flow_ctrl_set_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_priority_flow_ctrl_set_result *res = parsed_result;
struct rte_eth_pfc_conf pfc_conf;
{
struct cmd_priority_flow_ctrl_set_result *res = parsed_result;
struct rte_eth_pfc_conf pfc_conf;
cmdline_fixed_string_t def;
};
cmdline_fixed_string_t def;
};
-static void cmd_reset_parsed(__attribute__((unused)) void *parsed_result,
+static void cmd_reset_parsed(__rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
cmdline_printf(cl, "Reset to default forwarding configuration...\n");
set_def_fwd_config();
{
cmdline_printf(cl, "Reset to default forwarding configuration...\n");
set_def_fwd_config();
cmdline_parse_token_string_t cmd_start_start =
TOKEN_STRING_INITIALIZER(struct cmd_start_result, start, "start");
cmdline_parse_token_string_t cmd_start_start =
TOKEN_STRING_INITIALIZER(struct cmd_start_result, start, "start");
-static void cmd_start_parsed(__attribute__((unused)) void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+static void cmd_start_parsed(__rte_unused void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
start_packet_forwarding(0);
}
{
start_packet_forwarding(0);
}
-cmd_start_tx_first_parsed(__attribute__((unused)) void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+cmd_start_tx_first_parsed(__rte_unused void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
start_packet_forwarding(1);
}
{
start_packet_forwarding(1);
}
static void
cmd_start_tx_first_n_parsed(void *parsed_result,
static void
cmd_start_tx_first_n_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_start_tx_first_n_result *res = parsed_result;
{
struct cmd_start_tx_first_n_result *res = parsed_result;
cmdline_parse_token_num_t cmd_set_link_up_port_id =
TOKEN_NUM_INITIALIZER(struct cmd_set_link_up_result, port_id, UINT16);
cmdline_parse_token_num_t cmd_set_link_up_port_id =
TOKEN_NUM_INITIALIZER(struct cmd_set_link_up_result, port_id, UINT16);
-static void cmd_set_link_up_parsed(__attribute__((unused)) void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+static void cmd_set_link_up_parsed(__rte_unused void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_link_up_result *res = parsed_result;
dev_set_link_up(res->port_id);
{
struct cmd_set_link_up_result *res = parsed_result;
dev_set_link_up(res->port_id);
TOKEN_NUM_INITIALIZER(struct cmd_set_link_down_result, port_id, UINT16);
static void cmd_set_link_down_parsed(
TOKEN_NUM_INITIALIZER(struct cmd_set_link_down_result, port_id, UINT16);
static void cmd_set_link_down_parsed(
- __attribute__((unused)) void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_link_down_result *res = parsed_result;
dev_set_link_down(res->port_id);
{
struct cmd_set_link_down_result *res = parsed_result;
dev_set_link_down(res->port_id);
};
static void cmd_showcfg_parsed(void *parsed_result,
};
static void cmd_showcfg_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_showcfg_result *res = parsed_result;
if (!strcmp(res->what, "rxtx"))
{
struct cmd_showcfg_result *res = parsed_result;
if (!strcmp(res->what, "rxtx"))
};
static void cmd_showportall_parsed(void *parsed_result,
};
static void cmd_showportall_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
};
static void cmd_showport_parsed(void *parsed_result,
};
static void cmd_showport_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_showport_result *res = parsed_result;
if (!strcmp(res->show, "clear")) {
{
struct cmd_showport_result *res = parsed_result;
if (!strcmp(res->show, "clear")) {
};
static void cmd_showdevice_parsed(void *parsed_result,
};
static void cmd_showdevice_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_showdevice_result *res = parsed_result;
if (!strcmp(res->what, "info")) {
{
struct cmd_showdevice_result *res = parsed_result;
if (!strcmp(res->what, "info")) {
static void
cmd_showqueue_parsed(void *parsed_result,
static void
cmd_showqueue_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_showqueue_result *res = parsed_result;
{
struct cmd_showqueue_result *res = parsed_result;
static void
cmd_read_reg_parsed(void *parsed_result,
static void
cmd_read_reg_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_read_reg_result *res = parsed_result;
port_reg_display(res->port_id, res->reg_off);
{
struct cmd_read_reg_result *res = parsed_result;
port_reg_display(res->port_id, res->reg_off);
static void
cmd_read_reg_bit_field_parsed(void *parsed_result,
static void
cmd_read_reg_bit_field_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_read_reg_bit_field_result *res = parsed_result;
port_reg_bit_field_display(res->port_id, res->reg_off,
{
struct cmd_read_reg_bit_field_result *res = parsed_result;
port_reg_bit_field_display(res->port_id, res->reg_off,
static void
cmd_read_reg_bit_parsed(void *parsed_result,
static void
cmd_read_reg_bit_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_read_reg_bit_result *res = parsed_result;
port_reg_bit_display(res->port_id, res->reg_off, res->bit_pos);
{
struct cmd_read_reg_bit_result *res = parsed_result;
port_reg_bit_display(res->port_id, res->reg_off, res->bit_pos);
static void
cmd_write_reg_parsed(void *parsed_result,
static void
cmd_write_reg_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_write_reg_result *res = parsed_result;
port_reg_set(res->port_id, res->reg_off, res->value);
{
struct cmd_write_reg_result *res = parsed_result;
port_reg_set(res->port_id, res->reg_off, res->value);
static void
cmd_write_reg_bit_field_parsed(void *parsed_result,
static void
cmd_write_reg_bit_field_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_write_reg_bit_field_result *res = parsed_result;
port_reg_bit_field_set(res->port_id, res->reg_off,
{
struct cmd_write_reg_bit_field_result *res = parsed_result;
port_reg_bit_field_set(res->port_id, res->reg_off,
static void
cmd_write_reg_bit_parsed(void *parsed_result,
static void
cmd_write_reg_bit_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_write_reg_bit_result *res = parsed_result;
port_reg_bit_set(res->port_id, res->reg_off, res->bit_pos, res->value);
{
struct cmd_write_reg_bit_result *res = parsed_result;
port_reg_bit_set(res->port_id, res->reg_off, res->bit_pos, res->value);
static void
cmd_read_rxd_txd_parsed(void *parsed_result,
static void
cmd_read_rxd_txd_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_read_rxd_txd_result *res = parsed_result;
{
struct cmd_read_rxd_txd_result *res = parsed_result;
cmdline_fixed_string_t quit;
};
cmdline_fixed_string_t quit;
};
-static void cmd_quit_parsed(__attribute__((unused)) void *parsed_result,
+static void cmd_quit_parsed(__rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
};
static void cmd_mac_addr_parsed(void *parsed_result,
};
static void cmd_mac_addr_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_mac_addr_result *res = parsed_result;
int ret;
{
struct cmd_mac_addr_result *res = parsed_result;
int ret;
};
static void cmd_set_eth_peer_parsed(void *parsed_result,
};
static void cmd_set_eth_peer_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_eth_peer_result *res = parsed_result;
{
struct cmd_eth_peer_result *res = parsed_result;
static void
cmd_set_qmap_parsed(void *parsed_result,
static void
cmd_set_qmap_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_qmap_result *res = parsed_result;
int is_rx = (strcmp(res->what, "tx") == 0) ? 0 : 1;
{
struct cmd_set_qmap_result *res = parsed_result;
int is_rx = (strcmp(res->what, "tx") == 0) ? 0 : 1;
static void
cmd_set_xstats_hide_zero_parsed(void *parsed_result,
static void
cmd_set_xstats_hide_zero_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_xstats_hide_zero_result *res;
uint16_t on_off = 0;
{
struct cmd_set_xstats_hide_zero_result *res;
uint16_t on_off = 0;
static void
cmd_set_uc_hash_parsed(void *parsed_result,
static void
cmd_set_uc_hash_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
int ret=0;
struct cmd_set_uc_hash_table *res = parsed_result;
{
int ret=0;
struct cmd_set_uc_hash_table *res = parsed_result;
static void
cmd_set_uc_all_hash_parsed(void *parsed_result,
static void
cmd_set_uc_all_hash_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
int ret=0;
struct cmd_set_uc_all_hash_table *res = parsed_result;
{
int ret=0;
struct cmd_set_uc_all_hash_table *res = parsed_result;
static void
cmd_set_vf_macvlan_parsed(void *parsed_result,
static void
cmd_set_vf_macvlan_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
int is_on, ret = 0;
struct cmd_set_vf_macvlan_filter *res = parsed_result;
{
int is_on, ret = 0;
struct cmd_set_vf_macvlan_filter *res = parsed_result;
static void
cmd_set_vf_traffic_parsed(void *parsed_result,
static void
cmd_set_vf_traffic_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_vf_traffic *res = parsed_result;
int is_rx = (strcmp(res->what, "rx") == 0) ? 1 : 0;
{
struct cmd_set_vf_traffic *res = parsed_result;
int is_rx = (strcmp(res->what, "rx") == 0) ? 1 : 0;
static void
cmd_set_vf_rxmode_parsed(void *parsed_result,
static void
cmd_set_vf_rxmode_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
int ret = -ENOTSUP;
uint16_t vf_rxmode = 0;
{
int ret = -ENOTSUP;
uint16_t vf_rxmode = 0;
};
static void cmd_vf_mac_addr_parsed(void *parsed_result,
};
static void cmd_vf_mac_addr_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vf_mac_addr_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_vf_mac_addr_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_vf_rx_vlan_filter_parsed(void *parsed_result,
static void
cmd_vf_rx_vlan_filter_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vf_rx_vlan_filter *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_vf_rx_vlan_filter *res = parsed_result;
int ret = -ENOTSUP;
};
static void cmd_queue_rate_limit_parsed(void *parsed_result,
};
static void cmd_queue_rate_limit_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_queue_rate_limit_result *res = parsed_result;
int ret = 0;
{
struct cmd_queue_rate_limit_result *res = parsed_result;
int ret = 0;
};
static void cmd_vf_rate_limit_parsed(void *parsed_result,
};
static void cmd_vf_rate_limit_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vf_rate_limit_result *res = parsed_result;
int ret = 0;
{
struct cmd_vf_rate_limit_result *res = parsed_result;
int ret = 0;
static void
cmd_tunnel_filter_parsed(void *parsed_result,
static void
cmd_tunnel_filter_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_tunnel_filter_result *res = parsed_result;
struct rte_eth_tunnel_filter_conf tunnel_filter_conf;
{
struct cmd_tunnel_filter_result *res = parsed_result;
struct rte_eth_tunnel_filter_conf tunnel_filter_conf;
static void
cmd_tunnel_udp_config_parsed(void *parsed_result,
static void
cmd_tunnel_udp_config_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_tunnel_udp_config *res = parsed_result;
struct rte_eth_udp_tunnel tunnel_udp;
{
struct cmd_tunnel_udp_config *res = parsed_result;
struct rte_eth_udp_tunnel tunnel_udp;
static void
cmd_cfg_tunnel_udp_port_parsed(void *parsed_result,
static void
cmd_cfg_tunnel_udp_port_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_tunnel_udp_port *res = parsed_result;
struct rte_eth_udp_tunnel tunnel_udp;
{
struct cmd_config_tunnel_udp_port *res = parsed_result;
struct rte_eth_udp_tunnel tunnel_udp;
static void
cmd_global_config_parsed(void *parsed_result,
static void
cmd_global_config_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_global_config_result *res = parsed_result;
struct rte_eth_global_cfg conf;
{
struct cmd_global_config_result *res = parsed_result;
struct rte_eth_global_cfg conf;
static void
cmd_set_mirror_mask_parsed(void *parsed_result,
static void
cmd_set_mirror_mask_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
int ret,nb_item,i;
struct cmd_set_mirror_mask_result *res = parsed_result;
{
int ret,nb_item,i;
struct cmd_set_mirror_mask_result *res = parsed_result;
static void
cmd_set_mirror_link_parsed(void *parsed_result,
static void
cmd_set_mirror_link_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
int ret;
struct cmd_set_mirror_link_result *res = parsed_result;
{
int ret;
struct cmd_set_mirror_link_result *res = parsed_result;
static void
cmd_reset_mirror_rule_parsed(void *parsed_result,
static void
cmd_reset_mirror_rule_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
int ret;
struct cmd_set_mirror_link_result *res = parsed_result;
{
int ret;
struct cmd_set_mirror_link_result *res = parsed_result;
}
static void cmd_dump_parsed(void *parsed_result,
}
static void cmd_dump_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_dump_result *res = parsed_result;
{
struct cmd_dump_result *res = parsed_result;
};
static void cmd_dump_one_parsed(void *parsed_result, struct cmdline *cl,
};
static void cmd_dump_one_parsed(void *parsed_result, struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
struct cmd_dump_one_result *res = parsed_result;
{
struct cmd_dump_one_result *res = parsed_result;
static void
cmd_syn_filter_parsed(void *parsed_result,
static void
cmd_syn_filter_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_syn_filter_result *res = parsed_result;
struct rte_eth_syn_filter syn_filter;
{
struct cmd_syn_filter_result *res = parsed_result;
struct rte_eth_syn_filter syn_filter;
static void
cmd_queue_region_parsed(void *parsed_result,
static void
cmd_queue_region_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_queue_region_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_queue_region_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_region_flowtype_parsed(void *parsed_result,
static void
cmd_region_flowtype_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_region_flowtype_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_region_flowtype_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_user_priority_region_parsed(void *parsed_result,
static void
cmd_user_priority_region_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_user_priority_region_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_user_priority_region_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_flush_queue_region_parsed(void *parsed_result,
static void
cmd_flush_queue_region_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_flush_queue_region_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_flush_queue_region_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_show_queue_region_info_parsed(void *parsed_result,
static void
cmd_show_queue_region_info_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_show_queue_region_info *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_show_queue_region_info *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_2tuple_filter_parsed(void *parsed_result,
static void
cmd_2tuple_filter_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct rte_eth_ntuple_filter filter;
struct cmd_2tuple_filter_result *res = parsed_result;
{
struct rte_eth_ntuple_filter filter;
struct cmd_2tuple_filter_result *res = parsed_result;
static void
cmd_5tuple_filter_parsed(void *parsed_result,
static void
cmd_5tuple_filter_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct rte_eth_ntuple_filter filter;
struct cmd_5tuple_filter_result *res = parsed_result;
{
struct rte_eth_ntuple_filter filter;
struct cmd_5tuple_filter_result *res = parsed_result;
static void
cmd_flex_filter_parsed(void *parsed_result,
static void
cmd_flex_filter_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
int ret = 0;
struct rte_eth_flex_filter filter;
{
int ret = 0;
struct rte_eth_flex_filter filter;
static void
cmd_ethertype_filter_parsed(void *parsed_result,
static void
cmd_ethertype_filter_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_ethertype_filter_result *res = parsed_result;
struct rte_eth_ethertype_filter filter;
{
struct cmd_ethertype_filter_result *res = parsed_result;
struct rte_eth_ethertype_filter filter;
static void
cmd_flow_director_filter_parsed(void *parsed_result,
static void
cmd_flow_director_filter_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_flow_director_result *res = parsed_result;
struct rte_eth_fdir_filter entry;
{
struct cmd_flow_director_result *res = parsed_result;
struct rte_eth_fdir_filter entry;
static void
cmd_flush_flow_director_parsed(void *parsed_result,
static void
cmd_flush_flow_director_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_flow_director_result *res = parsed_result;
int ret = 0;
{
struct cmd_flow_director_result *res = parsed_result;
int ret = 0;
static void
cmd_flow_director_mask_parsed(void *parsed_result,
static void
cmd_flow_director_mask_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_flow_director_mask_result *res = parsed_result;
struct rte_eth_fdir_masks *mask;
{
struct cmd_flow_director_mask_result *res = parsed_result;
struct rte_eth_fdir_masks *mask;
static void
cmd_flow_director_flex_mask_parsed(void *parsed_result,
static void
cmd_flow_director_flex_mask_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_flow_director_flex_mask_result *res = parsed_result;
struct rte_eth_fdir_info fdir_info;
{
struct cmd_flow_director_flex_mask_result *res = parsed_result;
struct rte_eth_fdir_info fdir_info;
static void
cmd_flow_director_flxpld_parsed(void *parsed_result,
static void
cmd_flow_director_flxpld_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_flow_director_flexpayload_result *res = parsed_result;
struct rte_eth_flex_payload_cfg flex_cfg;
{
struct cmd_flow_director_flexpayload_result *res = parsed_result;
struct rte_eth_flex_payload_cfg flex_cfg;
};
static void cmd_mcast_addr_parsed(void *parsed_result,
};
static void cmd_mcast_addr_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_mcast_addr_result *res = parsed_result;
{
struct cmd_mcast_addr_result *res = parsed_result;
static void
cmd_config_l2_tunnel_eth_type_all_parsed
(void *parsed_result,
static void
cmd_config_l2_tunnel_eth_type_all_parsed
(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_l2_tunnel_eth_type_result *res = parsed_result;
struct rte_eth_l2_tunnel_conf entry;
{
struct cmd_config_l2_tunnel_eth_type_result *res = parsed_result;
struct rte_eth_l2_tunnel_conf entry;
static void
cmd_config_l2_tunnel_eth_type_specific_parsed(
void *parsed_result,
static void
cmd_config_l2_tunnel_eth_type_specific_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_l2_tunnel_eth_type_result *res =
parsed_result;
{
struct cmd_config_l2_tunnel_eth_type_result *res =
parsed_result;
static void
cmd_config_l2_tunnel_en_dis_all_parsed(
void *parsed_result,
static void
cmd_config_l2_tunnel_en_dis_all_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_l2_tunnel_en_dis_result *res = parsed_result;
struct rte_eth_l2_tunnel_conf entry;
{
struct cmd_config_l2_tunnel_en_dis_result *res = parsed_result;
struct rte_eth_l2_tunnel_conf entry;
static void
cmd_config_l2_tunnel_en_dis_specific_parsed(
void *parsed_result,
static void
cmd_config_l2_tunnel_en_dis_specific_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_l2_tunnel_en_dis_result *res =
parsed_result;
{
struct cmd_config_l2_tunnel_en_dis_result *res =
parsed_result;
static void
cmd_config_e_tag_insertion_en_parsed(
void *parsed_result,
static void
cmd_config_e_tag_insertion_en_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_e_tag_result *res =
parsed_result;
{
struct cmd_config_e_tag_result *res =
parsed_result;
static void
cmd_config_e_tag_insertion_dis_parsed(
void *parsed_result,
static void
cmd_config_e_tag_insertion_dis_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_e_tag_result *res =
parsed_result;
{
struct cmd_config_e_tag_result *res =
parsed_result;
static void
cmd_config_e_tag_stripping_parsed(
void *parsed_result,
static void
cmd_config_e_tag_stripping_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_e_tag_result *res =
parsed_result;
{
struct cmd_config_e_tag_result *res =
parsed_result;
static void
cmd_config_e_tag_forwarding_parsed(
void *parsed_result,
static void
cmd_config_e_tag_forwarding_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_e_tag_result *res = parsed_result;
struct rte_eth_l2_tunnel_conf entry;
{
struct cmd_config_e_tag_result *res = parsed_result;
struct rte_eth_l2_tunnel_conf entry;
static void
cmd_config_e_tag_filter_add_parsed(
void *parsed_result,
static void
cmd_config_e_tag_filter_add_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_e_tag_result *res = parsed_result;
struct rte_eth_l2_tunnel_conf entry;
{
struct cmd_config_e_tag_result *res = parsed_result;
struct rte_eth_l2_tunnel_conf entry;
static void
cmd_config_e_tag_filter_del_parsed(
void *parsed_result,
static void
cmd_config_e_tag_filter_del_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_e_tag_result *res = parsed_result;
struct rte_eth_l2_tunnel_conf entry;
{
struct cmd_config_e_tag_result *res = parsed_result;
struct rte_eth_l2_tunnel_conf entry;
static void
cmd_set_vf_vlan_anti_spoof_parsed(
void *parsed_result,
static void
cmd_set_vf_vlan_anti_spoof_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vf_vlan_anti_spoof_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_vf_vlan_anti_spoof_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_set_vf_mac_anti_spoof_parsed(
void *parsed_result,
static void
cmd_set_vf_mac_anti_spoof_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vf_mac_anti_spoof_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_vf_mac_anti_spoof_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_set_vf_vlan_stripq_parsed(
void *parsed_result,
static void
cmd_set_vf_vlan_stripq_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vf_vlan_stripq_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_vf_vlan_stripq_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_set_vf_vlan_insert_parsed(
void *parsed_result,
static void
cmd_set_vf_vlan_insert_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vf_vlan_insert_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_vf_vlan_insert_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_set_tx_loopback_parsed(
void *parsed_result,
static void
cmd_set_tx_loopback_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_tx_loopback_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_tx_loopback_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_set_all_queues_drop_en_parsed(
void *parsed_result,
static void
cmd_set_all_queues_drop_en_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_all_queues_drop_en_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_all_queues_drop_en_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_set_vf_split_drop_en_parsed(
void *parsed_result,
static void
cmd_set_vf_split_drop_en_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vf_split_drop_en_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_vf_split_drop_en_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_set_vf_mac_addr_parsed(
void *parsed_result,
static void
cmd_set_vf_mac_addr_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_vf_mac_addr_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_set_vf_mac_addr_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_set_macsec_offload_on_parsed(
void *parsed_result,
static void
cmd_set_macsec_offload_on_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_macsec_offload_on_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_macsec_offload_on_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_set_macsec_offload_off_parsed(
void *parsed_result,
static void
cmd_set_macsec_offload_off_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_macsec_offload_off_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_macsec_offload_off_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_set_macsec_sc_parsed(
void *parsed_result,
static void
cmd_set_macsec_sc_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_macsec_sc_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_macsec_sc_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_set_macsec_sa_parsed(
void *parsed_result,
static void
cmd_set_macsec_sa_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_macsec_sa_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_macsec_sa_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_set_vf_promisc_parsed(
void *parsed_result,
static void
cmd_set_vf_promisc_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vf_promisc_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_vf_promisc_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_set_vf_allmulti_parsed(
void *parsed_result,
static void
cmd_set_vf_allmulti_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vf_allmulti_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_vf_allmulti_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_set_vf_broadcast_parsed(
void *parsed_result,
static void
cmd_set_vf_broadcast_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_vf_broadcast_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_set_vf_broadcast_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_set_vf_vlan_tag_parsed(
void *parsed_result,
static void
cmd_set_vf_vlan_tag_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_vf_vlan_tag_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_set_vf_vlan_tag_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_vf_max_bw_parsed(
void *parsed_result,
static void
cmd_vf_max_bw_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vf_tc_bw_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_vf_tc_bw_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_vf_tc_min_bw_parsed(
void *parsed_result,
static void
cmd_vf_tc_min_bw_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vf_tc_bw_result *res = parsed_result;
uint8_t tc_num;
{
struct cmd_vf_tc_bw_result *res = parsed_result;
uint8_t tc_num;
static void
cmd_tc_min_bw_parsed(
void *parsed_result,
static void
cmd_tc_min_bw_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vf_tc_bw_result *res = parsed_result;
struct rte_port *port;
{
struct cmd_vf_tc_bw_result *res = parsed_result;
struct rte_port *port;
static void
cmd_vf_tc_max_bw_parsed(
void *parsed_result,
static void
cmd_vf_tc_max_bw_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vf_tc_bw_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_vf_tc_bw_result *res = parsed_result;
int ret = -ENOTSUP;
port_id, UINT16);
static void cmd_set_port_tm_hierarchy_default_parsed(void *parsed_result,
port_id, UINT16);
static void cmd_set_port_tm_hierarchy_default_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_port_tm_hierarchy_default_result *res = parsed_result;
struct rte_port *p;
{
struct cmd_set_port_tm_hierarchy_default_result *res = parsed_result;
struct rte_port *p;
TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_vxlan_result, eth_dst);
static void cmd_set_vxlan_parsed(void *parsed_result,
TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_vxlan_result, eth_dst);
static void cmd_set_vxlan_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_vxlan_result *res = parsed_result;
union {
{
struct cmd_set_vxlan_result *res = parsed_result;
union {
TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_nvgre_result, eth_dst);
static void cmd_set_nvgre_parsed(void *parsed_result,
TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_nvgre_result, eth_dst);
static void cmd_set_nvgre_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_nvgre_result *res = parsed_result;
union {
{
struct cmd_set_nvgre_result *res = parsed_result;
union {
TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_l2_encap_result, eth_dst);
static void cmd_set_l2_encap_parsed(void *parsed_result,
TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_l2_encap_result, eth_dst);
static void cmd_set_l2_encap_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_l2_encap_result *res = parsed_result;
{
struct cmd_set_l2_encap_result *res = parsed_result;
"l2_decap-with-vlan");
static void cmd_set_l2_decap_parsed(void *parsed_result,
"l2_decap-with-vlan");
static void cmd_set_l2_decap_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_l2_decap_result *res = parsed_result;
{
struct cmd_set_l2_decap_result *res = parsed_result;
eth_dst);
static void cmd_set_mplsogre_encap_parsed(void *parsed_result,
eth_dst);
static void cmd_set_mplsogre_encap_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_mplsogre_encap_result *res = parsed_result;
union {
{
struct cmd_set_mplsogre_encap_result *res = parsed_result;
union {
ip_version, "ipv4#ipv6");
static void cmd_set_mplsogre_decap_parsed(void *parsed_result,
ip_version, "ipv4#ipv6");
static void cmd_set_mplsogre_decap_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_mplsogre_decap_result *res = parsed_result;
{
struct cmd_set_mplsogre_decap_result *res = parsed_result;
eth_dst);
static void cmd_set_mplsoudp_encap_parsed(void *parsed_result,
eth_dst);
static void cmd_set_mplsoudp_encap_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_mplsoudp_encap_result *res = parsed_result;
union {
{
struct cmd_set_mplsoudp_encap_result *res = parsed_result;
union {
ip_version, "ipv4#ipv6");
static void cmd_set_mplsoudp_decap_parsed(void *parsed_result,
ip_version, "ipv4#ipv6");
static void cmd_set_mplsoudp_decap_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_mplsoudp_decap_result *res = parsed_result;
{
struct cmd_set_mplsoudp_decap_result *res = parsed_result;
static void
cmd_strict_link_prio_parsed(
void *parsed_result,
static void
cmd_strict_link_prio_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vf_tc_bw_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_vf_tc_bw_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_ddp_add_parsed(
void *parsed_result,
static void
cmd_ddp_add_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_ddp_add_result *res = parsed_result;
uint8_t *buff;
{
struct cmd_ddp_add_result *res = parsed_result;
uint8_t *buff;
static void
cmd_ddp_del_parsed(
void *parsed_result,
static void
cmd_ddp_del_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_ddp_del_result *res = parsed_result;
uint8_t *buff;
{
struct cmd_ddp_del_result *res = parsed_result;
uint8_t *buff;
static void
cmd_ddp_info_parsed(
void *parsed_result,
static void
cmd_ddp_info_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_ddp_info_result *res = parsed_result;
uint8_t *pkg;
{
struct cmd_ddp_info_result *res = parsed_result;
uint8_t *pkg;
static void
cmd_ddp_get_list_parsed(
static void
cmd_ddp_get_list_parsed(
- __attribute__((unused)) void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
#ifdef RTE_LIBRTE_I40E_PMD
struct cmd_ddp_get_list_result *res = parsed_result;
{
#ifdef RTE_LIBRTE_I40E_PMD
struct cmd_ddp_get_list_result *res = parsed_result;
static void
cmd_cfg_input_set_parsed(
static void
cmd_cfg_input_set_parsed(
- __attribute__((unused)) void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
#ifdef RTE_LIBRTE_I40E_PMD
struct cmd_cfg_input_set_result *res = parsed_result;
{
#ifdef RTE_LIBRTE_I40E_PMD
struct cmd_cfg_input_set_result *res = parsed_result;
static void
cmd_clear_input_set_parsed(
static void
cmd_clear_input_set_parsed(
- __attribute__((unused)) void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
#ifdef RTE_LIBRTE_I40E_PMD
struct cmd_clear_input_set_result *res = parsed_result;
{
#ifdef RTE_LIBRTE_I40E_PMD
struct cmd_clear_input_set_result *res = parsed_result;
static void
cmd_show_vf_stats_parsed(
void *parsed_result,
static void
cmd_show_vf_stats_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_show_vf_stats_result *res = parsed_result;
struct rte_eth_stats stats;
{
struct cmd_show_vf_stats_result *res = parsed_result;
struct rte_eth_stats stats;
static void
cmd_clear_vf_stats_parsed(
void *parsed_result,
static void
cmd_clear_vf_stats_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_clear_vf_stats_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_clear_vf_stats_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_pctype_mapping_reset_parsed(
void *parsed_result,
static void
cmd_pctype_mapping_reset_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_pctype_mapping_reset_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_pctype_mapping_reset_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_pctype_mapping_get_parsed(
void *parsed_result,
static void
cmd_pctype_mapping_get_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_pctype_mapping_get_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_pctype_mapping_get_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_pctype_mapping_update_parsed(
void *parsed_result,
static void
cmd_pctype_mapping_update_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_pctype_mapping_update_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_pctype_mapping_update_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_ptype_mapping_get_parsed(
void *parsed_result,
static void
cmd_ptype_mapping_get_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_ptype_mapping_get_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_ptype_mapping_get_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_ptype_mapping_replace_parsed(
void *parsed_result,
static void
cmd_ptype_mapping_replace_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_ptype_mapping_replace_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_ptype_mapping_replace_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_ptype_mapping_reset_parsed(
void *parsed_result,
static void
cmd_ptype_mapping_reset_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_ptype_mapping_reset_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_ptype_mapping_reset_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_ptype_mapping_update_parsed(
void *parsed_result,
static void
cmd_ptype_mapping_update_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_ptype_mapping_update_result *res = parsed_result;
int ret = -ENOTSUP;
{
struct cmd_ptype_mapping_update_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_load_from_file_parsed(
void *parsed_result,
static void
cmd_load_from_file_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_cmdfile_result *res = parsed_result;
{
struct cmd_cmdfile_result *res = parsed_result;
static void
cmd_rx_offload_get_capa_parsed(
void *parsed_result,
static void
cmd_rx_offload_get_capa_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_rx_offload_get_capa_result *res = parsed_result;
struct rte_eth_dev_info dev_info;
{
struct cmd_rx_offload_get_capa_result *res = parsed_result;
struct rte_eth_dev_info dev_info;
static void
cmd_rx_offload_get_configuration_parsed(
void *parsed_result,
static void
cmd_rx_offload_get_configuration_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_rx_offload_get_configuration_result *res = parsed_result;
struct rte_eth_dev_info dev_info;
{
struct cmd_rx_offload_get_configuration_result *res = parsed_result;
struct rte_eth_dev_info dev_info;
static void
cmd_config_per_port_rx_offload_parsed(void *parsed_result,
static void
cmd_config_per_port_rx_offload_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_per_port_rx_offload_result *res = parsed_result;
portid_t port_id = res->port_id;
{
struct cmd_config_per_port_rx_offload_result *res = parsed_result;
portid_t port_id = res->port_id;
static void
cmd_config_per_queue_rx_offload_parsed(void *parsed_result,
static void
cmd_config_per_queue_rx_offload_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_per_queue_rx_offload_result *res = parsed_result;
struct rte_eth_dev_info dev_info;
{
struct cmd_config_per_queue_rx_offload_result *res = parsed_result;
struct rte_eth_dev_info dev_info;
static void
cmd_tx_offload_get_capa_parsed(
void *parsed_result,
static void
cmd_tx_offload_get_capa_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_tx_offload_get_capa_result *res = parsed_result;
struct rte_eth_dev_info dev_info;
{
struct cmd_tx_offload_get_capa_result *res = parsed_result;
struct rte_eth_dev_info dev_info;
static void
cmd_tx_offload_get_configuration_parsed(
void *parsed_result,
static void
cmd_tx_offload_get_configuration_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_tx_offload_get_configuration_result *res = parsed_result;
struct rte_eth_dev_info dev_info;
{
struct cmd_tx_offload_get_configuration_result *res = parsed_result;
struct rte_eth_dev_info dev_info;
static void
cmd_config_per_port_tx_offload_parsed(void *parsed_result,
static void
cmd_config_per_port_tx_offload_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_per_port_tx_offload_result *res = parsed_result;
portid_t port_id = res->port_id;
{
struct cmd_config_per_port_tx_offload_result *res = parsed_result;
portid_t port_id = res->port_id;
static void
cmd_config_per_queue_tx_offload_parsed(void *parsed_result,
static void
cmd_config_per_queue_tx_offload_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_per_queue_tx_offload_result *res = parsed_result;
struct rte_eth_dev_info dev_info;
{
struct cmd_config_per_queue_tx_offload_result *res = parsed_result;
struct rte_eth_dev_info dev_info;
static void
cmd_config_tx_metadata_specific_parsed(void *parsed_result,
static void
cmd_config_tx_metadata_specific_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_tx_metadata_specific_result *res = parsed_result;
{
struct cmd_config_tx_metadata_specific_result *res = parsed_result;
static void
cmd_config_dynf_specific_parsed(void *parsed_result,
static void
cmd_config_dynf_specific_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_tx_dynf_specific_result *res = parsed_result;
struct rte_mbuf_dynflag desc_flag;
{
struct cmd_config_tx_dynf_specific_result *res = parsed_result;
struct rte_mbuf_dynflag desc_flag;
static void
cmd_show_tx_metadata_parsed(void *parsed_result,
static void
cmd_show_tx_metadata_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_show_tx_metadata_result *res = parsed_result;
{
struct cmd_show_tx_metadata_result *res = parsed_result;
static void
cmd_show_port_supported_ptypes_parsed(
void *parsed_result,
static void
cmd_show_port_supported_ptypes_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
#define RSVD_PTYPE_MASK 0xf0000000
#define MAX_PTYPES_PER_LAYER 16
{
#define RSVD_PTYPE_MASK 0xf0000000
#define MAX_PTYPES_PER_LAYER 16
static void
cmd_show_rx_tx_desc_status_parsed(void *parsed_result,
static void
cmd_show_rx_tx_desc_status_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_show_rx_tx_desc_status_result *res = parsed_result;
int rc;
{
struct cmd_show_rx_tx_desc_status_result *res = parsed_result;
int rc;
static void
cmd_set_port_ptypes_parsed(
void *parsed_result,
static void
cmd_set_port_ptypes_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_port_ptypes_result *res = parsed_result;
#define PTYPE_NAMESIZE 256
{
struct cmd_set_port_ptypes_result *res = parsed_result;
#define PTYPE_NAMESIZE 256
static void
cmd_showport_macs_parsed(void *parsed_result,
static void
cmd_showport_macs_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_showport_macs_result *res = parsed_result;
{
struct cmd_showport_macs_result *res = parsed_result;
struct cmd_show_port_meter_cap_result, port_id, UINT16);
static void cmd_show_port_meter_cap_parsed(void *parsed_result,
struct cmd_show_port_meter_cap_result, port_id, UINT16);
static void cmd_show_port_meter_cap_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_show_port_meter_cap_result *res = parsed_result;
struct rte_mtr_capabilities cap;
{
struct cmd_show_port_meter_cap_result *res = parsed_result;
struct rte_mtr_capabilities cap;
ebs, UINT64);
static void cmd_add_port_meter_profile_srtcm_parsed(void *parsed_result,
ebs, UINT64);
static void cmd_add_port_meter_profile_srtcm_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_add_port_meter_profile_srtcm_result *res = parsed_result;
struct rte_mtr_meter_profile mp;
{
struct cmd_add_port_meter_profile_srtcm_result *res = parsed_result;
struct rte_mtr_meter_profile mp;
pbs, UINT64);
static void cmd_add_port_meter_profile_trtcm_parsed(void *parsed_result,
pbs, UINT64);
static void cmd_add_port_meter_profile_trtcm_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_add_port_meter_profile_trtcm_result *res = parsed_result;
struct rte_mtr_meter_profile mp;
{
struct cmd_add_port_meter_profile_trtcm_result *res = parsed_result;
struct rte_mtr_meter_profile mp;
static void cmd_add_port_meter_profile_trtcm_rfc4115_parsed(
void *parsed_result,
static void cmd_add_port_meter_profile_trtcm_rfc4115_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_add_port_meter_profile_trtcm_rfc4115_result *res =
parsed_result;
{
struct cmd_add_port_meter_profile_trtcm_rfc4115_result *res =
parsed_result;
profile_id, UINT32);
static void cmd_del_port_meter_profile_parsed(void *parsed_result,
profile_id, UINT32);
static void cmd_del_port_meter_profile_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_del_port_meter_profile_result *res = parsed_result;
struct rte_mtr_error error;
{
struct cmd_del_port_meter_profile_result *res = parsed_result;
struct rte_mtr_error error;
meter_input_color, TOKEN_STRING_MULTI);
static void cmd_create_port_meter_parsed(void *parsed_result,
meter_input_color, TOKEN_STRING_MULTI);
static void cmd_create_port_meter_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_create_port_meter_result *res = parsed_result;
struct rte_mtr_error error;
{
struct cmd_create_port_meter_result *res = parsed_result;
struct rte_mtr_error error;
struct cmd_enable_port_meter_result, mtr_id, UINT32);
static void cmd_enable_port_meter_parsed(void *parsed_result,
struct cmd_enable_port_meter_result, mtr_id, UINT32);
static void cmd_enable_port_meter_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_enable_port_meter_result *res = parsed_result;
struct rte_mtr_error error;
{
struct cmd_enable_port_meter_result *res = parsed_result;
struct rte_mtr_error error;
struct cmd_disable_port_meter_result, mtr_id, UINT32);
static void cmd_disable_port_meter_parsed(void *parsed_result,
struct cmd_disable_port_meter_result, mtr_id, UINT32);
static void cmd_disable_port_meter_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_disable_port_meter_result *res = parsed_result;
struct rte_mtr_error error;
{
struct cmd_disable_port_meter_result *res = parsed_result;
struct rte_mtr_error error;
struct cmd_del_port_meter_result, mtr_id, UINT32);
static void cmd_del_port_meter_parsed(void *parsed_result,
struct cmd_del_port_meter_result, mtr_id, UINT32);
static void cmd_del_port_meter_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_del_port_meter_result *res = parsed_result;
struct rte_mtr_error error;
{
struct cmd_del_port_meter_result *res = parsed_result;
struct rte_mtr_error error;
struct cmd_set_port_meter_profile_result, profile_id, UINT32);
static void cmd_set_port_meter_profile_parsed(void *parsed_result,
struct cmd_set_port_meter_profile_result, profile_id, UINT32);
static void cmd_set_port_meter_profile_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_port_meter_profile_result *res = parsed_result;
struct rte_mtr_error error;
{
struct cmd_set_port_meter_profile_result *res = parsed_result;
struct rte_mtr_error error;
token_string, TOKEN_STRING_MULTI);
static void cmd_set_port_meter_dscp_table_parsed(void *parsed_result,
token_string, TOKEN_STRING_MULTI);
static void cmd_set_port_meter_dscp_table_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_port_meter_dscp_table_result *res = parsed_result;
struct rte_mtr_error error;
{
struct cmd_set_port_meter_dscp_table_result *res = parsed_result;
struct rte_mtr_error error;
policer_action, TOKEN_STRING_MULTI);
static void cmd_set_port_meter_policer_action_parsed(void *parsed_result,
policer_action, TOKEN_STRING_MULTI);
static void cmd_set_port_meter_policer_action_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_port_meter_policer_action_result *res = parsed_result;
enum rte_mtr_policer_action *actions;
{
struct cmd_set_port_meter_policer_action_result *res = parsed_result;
enum rte_mtr_policer_action *actions;
UINT64);
static void cmd_set_port_meter_stats_mask_parsed(void *parsed_result,
UINT64);
static void cmd_set_port_meter_stats_mask_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_port_meter_stats_mask_result *res = parsed_result;
struct rte_mtr_error error;
{
struct cmd_set_port_meter_stats_mask_result *res = parsed_result;
struct rte_mtr_error error;
struct cmd_show_port_meter_stats_result, clear, "yes#no");
static void cmd_show_port_meter_stats_parsed(void *parsed_result,
struct cmd_show_port_meter_stats_result, clear, "yes#no");
static void cmd_show_port_meter_stats_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_show_port_meter_stats_result *res = parsed_result;
struct rte_mtr_stats stats;
{
struct cmd_show_port_meter_stats_result *res = parsed_result;
struct rte_mtr_stats stats;
port_id, UINT16);
static void cmd_show_port_tm_cap_parsed(void *parsed_result,
port_id, UINT16);
static void cmd_show_port_tm_cap_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_show_port_tm_cap_result *res = parsed_result;
struct rte_tm_capabilities cap;
{
struct cmd_show_port_tm_cap_result *res = parsed_result;
struct rte_tm_capabilities cap;
static void cmd_show_port_tm_level_cap_parsed(void *parsed_result,
static void cmd_show_port_tm_level_cap_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_show_port_tm_level_cap_result *res = parsed_result;
struct rte_tm_level_capabilities lcap;
{
struct cmd_show_port_tm_level_cap_result *res = parsed_result;
struct rte_tm_level_capabilities lcap;
node_id, UINT32);
static void cmd_show_port_tm_node_cap_parsed(void *parsed_result,
node_id, UINT32);
static void cmd_show_port_tm_node_cap_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_show_port_tm_node_cap_result *res = parsed_result;
struct rte_tm_node_capabilities ncap;
{
struct cmd_show_port_tm_node_cap_result *res = parsed_result;
struct rte_tm_node_capabilities ncap;
struct cmd_show_port_tm_node_stats_result, clear, UINT32);
static void cmd_show_port_tm_node_stats_parsed(void *parsed_result,
struct cmd_show_port_tm_node_stats_result, clear, UINT32);
static void cmd_show_port_tm_node_stats_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_show_port_tm_node_stats_result *res = parsed_result;
struct rte_tm_node_stats stats;
{
struct cmd_show_port_tm_node_stats_result *res = parsed_result;
struct rte_tm_node_stats stats;
node_id, UINT32);
static void cmd_show_port_tm_node_type_parsed(void *parsed_result,
node_id, UINT32);
static void cmd_show_port_tm_node_type_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_show_port_tm_node_type_result *res = parsed_result;
struct rte_tm_error error;
{
struct cmd_show_port_tm_node_type_result *res = parsed_result;
struct rte_tm_error error;
pktlen_adjust, UINT32);
static void cmd_add_port_tm_node_shaper_profile_parsed(void *parsed_result,
pktlen_adjust, UINT32);
static void cmd_add_port_tm_node_shaper_profile_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_add_port_tm_node_shaper_profile_result *res = parsed_result;
struct rte_tm_shaper_params sp;
{
struct cmd_add_port_tm_node_shaper_profile_result *res = parsed_result;
struct rte_tm_shaper_params sp;
shaper_id, UINT32);
static void cmd_del_port_tm_node_shaper_profile_parsed(void *parsed_result,
shaper_id, UINT32);
static void cmd_del_port_tm_node_shaper_profile_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_del_port_tm_node_shaper_profile_result *res = parsed_result;
struct rte_tm_error error;
{
struct cmd_del_port_tm_node_shaper_profile_result *res = parsed_result;
struct rte_tm_error error;
shaper_profile_id, UINT32);
static void cmd_add_port_tm_node_shared_shaper_parsed(void *parsed_result,
shaper_profile_id, UINT32);
static void cmd_add_port_tm_node_shared_shaper_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_add_port_tm_node_shared_shaper_result *res = parsed_result;
struct rte_tm_error error;
{
struct cmd_add_port_tm_node_shared_shaper_result *res = parsed_result;
struct rte_tm_error error;
shared_shaper_id, UINT32);
static void cmd_del_port_tm_node_shared_shaper_parsed(void *parsed_result,
shared_shaper_id, UINT32);
static void cmd_del_port_tm_node_shared_shaper_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_del_port_tm_node_shared_shaper_result *res = parsed_result;
struct rte_tm_error error;
{
struct cmd_del_port_tm_node_shared_shaper_result *res = parsed_result;
struct rte_tm_error error;
static void cmd_add_port_tm_node_wred_profile_parsed(void *parsed_result,
static void cmd_add_port_tm_node_wred_profile_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_add_port_tm_node_wred_profile_result *res = parsed_result;
struct rte_tm_wred_params wp;
{
struct cmd_add_port_tm_node_wred_profile_result *res = parsed_result;
struct rte_tm_wred_params wp;
wred_profile_id, UINT32);
static void cmd_del_port_tm_node_wred_profile_parsed(void *parsed_result,
wred_profile_id, UINT32);
static void cmd_del_port_tm_node_wred_profile_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_del_port_tm_node_wred_profile_result *res = parsed_result;
struct rte_tm_error error;
{
struct cmd_del_port_tm_node_wred_profile_result *res = parsed_result;
struct rte_tm_error error;
shaper_profile_id, UINT32);
static void cmd_set_port_tm_node_shaper_profile_parsed(void *parsed_result,
shaper_profile_id, UINT32);
static void cmd_set_port_tm_node_shaper_profile_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_port_tm_node_shaper_profile_result *res = parsed_result;
struct rte_tm_error error;
{
struct cmd_set_port_tm_node_shaper_profile_result *res = parsed_result;
struct rte_tm_error error;
multi_shared_shaper_id, TOKEN_STRING_MULTI);
static void cmd_add_port_tm_nonleaf_node_parsed(void *parsed_result,
multi_shared_shaper_id, TOKEN_STRING_MULTI);
static void cmd_add_port_tm_nonleaf_node_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_add_port_tm_nonleaf_node_result *res = parsed_result;
struct rte_tm_error error;
{
struct cmd_add_port_tm_nonleaf_node_result *res = parsed_result;
struct rte_tm_error error;
multi_shared_shaper_id, TOKEN_STRING_MULTI);
static void cmd_add_port_tm_leaf_node_parsed(void *parsed_result,
multi_shared_shaper_id, TOKEN_STRING_MULTI);
static void cmd_add_port_tm_leaf_node_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_add_port_tm_leaf_node_result *res = parsed_result;
struct rte_tm_error error;
{
struct cmd_add_port_tm_leaf_node_result *res = parsed_result;
struct rte_tm_error error;
node_id, UINT32);
static void cmd_del_port_tm_node_parsed(void *parsed_result,
node_id, UINT32);
static void cmd_del_port_tm_node_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_del_port_tm_node_result *res = parsed_result;
struct rte_tm_error error;
{
struct cmd_del_port_tm_node_result *res = parsed_result;
struct rte_tm_error error;
weight, UINT32);
static void cmd_set_port_tm_node_parent_parsed(void *parsed_result,
weight, UINT32);
static void cmd_set_port_tm_node_parent_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_port_tm_node_parent_result *res = parsed_result;
struct rte_tm_error error;
{
struct cmd_set_port_tm_node_parent_result *res = parsed_result;
struct rte_tm_error error;
struct cmd_suspend_port_tm_node_result, node_id, UINT32);
static void cmd_suspend_port_tm_node_parsed(void *parsed_result,
struct cmd_suspend_port_tm_node_result, node_id, UINT32);
static void cmd_suspend_port_tm_node_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_suspend_port_tm_node_result *res = parsed_result;
struct rte_tm_error error;
{
struct cmd_suspend_port_tm_node_result *res = parsed_result;
struct rte_tm_error error;
struct cmd_resume_port_tm_node_result, node_id, UINT32);
static void cmd_resume_port_tm_node_parsed(void *parsed_result,
struct cmd_resume_port_tm_node_result, node_id, UINT32);
static void cmd_resume_port_tm_node_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_resume_port_tm_node_result *res = parsed_result;
struct rte_tm_error error;
{
struct cmd_resume_port_tm_node_result *res = parsed_result;
struct rte_tm_error error;
clean_on_fail, "yes#no");
static void cmd_port_tm_hierarchy_commit_parsed(void *parsed_result,
clean_on_fail, "yes#no");
static void cmd_port_tm_hierarchy_commit_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_port_tm_hierarchy_commit_result *res = parsed_result;
struct rte_tm_error error;
{
struct cmd_port_tm_hierarchy_commit_result *res = parsed_result;
struct rte_tm_error error;
red, UINT16);
static void cmd_port_tm_mark_ip_ecn_parsed(void *parsed_result,
red, UINT16);
static void cmd_port_tm_mark_ip_ecn_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_port_tm_mark_ip_ecn_result *res = parsed_result;
struct rte_tm_error error;
{
struct cmd_port_tm_mark_ip_ecn_result *res = parsed_result;
struct rte_tm_error error;
red, UINT16);
static void cmd_port_tm_mark_ip_dscp_parsed(void *parsed_result,
red, UINT16);
static void cmd_port_tm_mark_ip_dscp_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_port_tm_mark_ip_dscp_result *res = parsed_result;
struct rte_tm_error error;
{
struct cmd_port_tm_mark_ip_dscp_result *res = parsed_result;
struct rte_tm_error error;
red, UINT16);
static void cmd_port_tm_mark_vlan_dei_parsed(void *parsed_result,
red, UINT16);
static void cmd_port_tm_mark_vlan_dei_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_port_tm_mark_vlan_dei_result *res = parsed_result;
struct rte_tm_error error;
{
struct cmd_port_tm_mark_vlan_dei_result *res = parsed_result;
struct rte_tm_error error;
-tx_only_begin(__attribute__((unused)) portid_t pi)
+tx_only_begin(__rte_unused portid_t pi)
};
static void cmd_autotest_parsed(void *parsed_result,
};
static void cmd_autotest_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct test_command *t;
struct cmd_autotest_result *res = parsed_result;
{
struct test_command *t;
struct cmd_autotest_result *res = parsed_result;
}
static void cmd_dump_parsed(void *parsed_result,
}
static void cmd_dump_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_dump_result *res = parsed_result;
{
struct cmd_dump_result *res = parsed_result;
};
static void cmd_dump_one_parsed(void *parsed_result, struct cmdline *cl,
};
static void cmd_dump_one_parsed(void *parsed_result, struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
struct cmd_dump_one_result *res = parsed_result;
{
struct cmd_dump_one_result *res = parsed_result;
-cmd_quit_parsed(__attribute__((unused)) void *parsed_result,
+cmd_quit_parsed(__rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
};
static void cmd_set_rxtx_parsed(void *parsed_result, struct cmdline *cl,
};
static void cmd_set_rxtx_parsed(void *parsed_result, struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
struct cmd_set_rxtx_result *res = parsed_result;
if (test_set_rxtx_conf(res->mode) < 0)
{
struct cmd_set_rxtx_result *res = parsed_result;
if (test_set_rxtx_conf(res->mode) < 0)
static void
cmd_set_rxtx_anchor_parsed(void *parsed_result,
struct cmdline *cl,
static void
cmd_set_rxtx_anchor_parsed(void *parsed_result,
struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
struct cmd_set_rxtx_anchor *res = parsed_result;
if (test_set_rxtx_anchor(res->type) < 0)
{
struct cmd_set_rxtx_anchor *res = parsed_result;
if (test_set_rxtx_anchor(res->type) < 0)
static void
cmd_set_rxtx_sc_parsed(void *parsed_result,
struct cmdline *cl,
static void
cmd_set_rxtx_sc_parsed(void *parsed_result,
struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
struct cmd_set_rxtx_sc *res = parsed_result;
if (test_set_rxtx_sc(res->type) < 0)
{
struct cmd_set_rxtx_sc *res = parsed_result;
if (test_set_rxtx_sc(res->type) < 0)
static rte_atomic32_t synchro;
static int
static rte_atomic32_t synchro;
static int
-test_atomic_usual(__attribute__((unused)) void *arg)
+test_atomic_usual(__rte_unused void *arg)
-test_atomic_tas(__attribute__((unused)) void *arg)
+test_atomic_tas(__rte_unused void *arg)
{
while (rte_atomic32_read(&synchro) == 0)
;
{
while (rte_atomic32_read(&synchro) == 0)
;
-test_atomic_addsub_and_return(__attribute__((unused)) void *arg)
+test_atomic_addsub_and_return(__rte_unused void *arg)
{
uint32_t tmp16;
uint32_t tmp32;
{
uint32_t tmp16;
uint32_t tmp32;
-test_atomic_inc_and_test(__attribute__((unused)) void *arg)
+test_atomic_inc_and_test(__rte_unused void *arg)
{
while (rte_atomic32_read(&synchro) == 0)
;
{
while (rte_atomic32_read(&synchro) == 0)
;
* be checked as the result later.
*/
static int
* be checked as the result later.
*/
static int
-test_atomic_dec_and_test(__attribute__((unused)) void *arg)
+test_atomic_dec_and_test(__rte_unused void *arg)
{
while (rte_atomic32_read(&synchro) == 0)
;
{
while (rte_atomic32_read(&synchro) == 0)
;
* iteration it runs compare and swap operation with different memory models.
*/
static int
* iteration it runs compare and swap operation with different memory models.
*/
static int
-test_atomic128_cmp_exchange(__attribute__((unused)) void *arg)
+test_atomic128_cmp_exchange(__rte_unused void *arg)
{
rte_int128_t expected;
int success;
{
rte_int128_t expected;
int success;
* +------------+------------+
*/
static int
* +------------+------------+
*/
static int
-test_atomic_exchange(__attribute__((unused)) void *arg)
+test_atomic_exchange(__rte_unused void *arg)
{
int i;
test16_t nt16, ot16; /* new token, old token */
{
int i;
test16_t nt16, ot16; /* new token, old token */
#include <ctype.h>
#include <sys/queue.h>
#include <ctype.h>
#include <sys/queue.h>
+#include <rte_common.h>
+
#include <cmdline_vt100.h>
#include <cmdline_rdline.h>
#include <cmdline_parse.h>
#include <cmdline_vt100.h>
#include <cmdline_rdline.h>
#include <cmdline_parse.h>
/****************************************************************/
/* static functions required for some tests */
static void
/****************************************************************/
/* static functions required for some tests */
static void
-valid_buffer(__attribute__((unused))struct rdline *rdl,
- __attribute__((unused))const char *buf,
- __attribute__((unused)) unsigned int size)
+valid_buffer(__rte_unused struct rdline *rdl,
+ __rte_unused const char *buf,
+ __rte_unused unsigned int size)
-complete_buffer(__attribute__((unused)) struct rdline *rdl,
- __attribute__((unused)) const char *buf,
- __attribute__((unused)) char *dstbuf,
- __attribute__((unused)) unsigned int dstsize,
- __attribute__((unused)) int *state)
+complete_buffer(__rte_unused struct rdline *rdl,
+ __rte_unused const char *buf,
+ __rte_unused char *dstbuf,
+ __rte_unused unsigned int dstsize,
+ __rte_unused int *state)
* rte_eal_init only init once
*/
static int
* rte_eal_init only init once
*/
static int
-test_eal_init_once(__attribute__((unused)) void *arg)
+test_eal_init_once(__rte_unused void *arg)
{
unsigned lcore_self = rte_lcore_id();
{
unsigned lcore_self = rte_lcore_id();
-ring_create_lookup(__attribute__((unused)) void *arg)
+ring_create_lookup(__rte_unused void *arg)
{
unsigned lcore_self = rte_lcore_id();
struct rte_ring * rp;
{
unsigned lcore_self = rte_lcore_id();
struct rte_ring * rp;
-my_obj_init(struct rte_mempool *mp, __attribute__((unused)) void *arg,
+my_obj_init(struct rte_mempool *mp, __rte_unused void *arg,
void *obj, unsigned i)
{
uint32_t *objnum = obj;
void *obj, unsigned i)
{
uint32_t *objnum = obj;
-mempool_create_lookup(__attribute__((unused)) void *arg)
+mempool_create_lookup(__rte_unused void *arg)
{
unsigned lcore_self = rte_lcore_id();
struct rte_mempool * mp;
{
unsigned lcore_self = rte_lcore_id();
struct rte_mempool * mp;
-hash_create_free(__attribute__((unused)) void *arg)
+hash_create_free(__rte_unused void *arg)
{
unsigned lcore_self = rte_lcore_id();
struct rte_hash *handle;
{
unsigned lcore_self = rte_lcore_id();
struct rte_hash *handle;
-fbk_create_free(__attribute__((unused)) void *arg)
+fbk_create_free(__rte_unused void *arg)
{
unsigned lcore_self = rte_lcore_id();
struct rte_fbk_hash_table *handle;
{
unsigned lcore_self = rte_lcore_id();
struct rte_fbk_hash_table *handle;
-lpm_create_free(__attribute__((unused)) void *arg)
+lpm_create_free(__rte_unused void *arg)
{
unsigned lcore_self = rte_lcore_id();
struct rte_lpm *lpm;
{
unsigned lcore_self = rte_lcore_id();
struct rte_lpm *lpm;
* Hash function that always returns the same value, to easily test what
* happens when a bucket is full.
*/
* Hash function that always returns the same value, to easily test what
* happens when a bucket is full.
*/
-static uint32_t pseudo_hash(__attribute__((unused)) const void *keys,
- __attribute__((unused)) uint32_t key_len,
- __attribute__((unused)) uint32_t init_val)
+static uint32_t pseudo_hash(__rte_unused const void *keys,
+ __rte_unused uint32_t key_len,
+ __rte_unused uint32_t init_val)
static rte_atomic64_t gwrites;
static int
static rte_atomic64_t gwrites;
static int
-test_hash_readwrite_worker(__attribute__((unused)) void *arg)
+test_hash_readwrite_worker(__rte_unused void *arg)
{
uint64_t i, offset;
uint32_t lcore_id = rte_lcore_id();
{
uint64_t i, offset;
uint32_t lcore_id = rte_lcore_id();
-get_prim_bucket_index(__attribute__((unused)) const struct rte_hash *h,
+get_prim_bucket_index(__rte_unused const struct rte_hash *h,
const hash_sig_t hash)
{
uint32_t num_buckets;
const hash_sig_t hash)
{
uint32_t num_buckets;
-get_alt_bucket_index(__attribute__((unused)) const struct rte_hash *h,
+get_alt_bucket_index(__rte_unused const struct rte_hash *h,
uint32_t cur_bkt_idx, uint16_t sig)
{
uint32_t num_buckets;
uint32_t cur_bkt_idx, uint16_t sig)
{
uint32_t num_buckets;
-test_rwc_reader(__attribute__((unused)) void *arg)
+test_rwc_reader(__rte_unused void *arg)
{
uint32_t i, j;
int ret;
{
uint32_t i, j;
int ret;
-test_rwc_multi_writer(__attribute__((unused)) void *arg)
+test_rwc_multi_writer(__rte_unused void *arg)
{
uint32_t i, offset;
uint32_t pos_core = (uint32_t)((uintptr_t)arg);
{
uint32_t i, offset;
uint32_t pos_core = (uint32_t)((uintptr_t)arg);
-test_align_overlap_per_lcore(__attribute__((unused)) void *arg)
+test_align_overlap_per_lcore(__rte_unused void *arg)
{
const unsigned align1 = 8,
align2 = 64,
{
const unsigned align1 = 8,
align2 = 64,
-test_reordered_free_per_lcore(__attribute__((unused)) void *arg)
+test_reordered_free_per_lcore(__rte_unused void *arg)
{
const unsigned align1 = 8,
align2 = 64,
{
const unsigned align1 = 8,
align2 = 64,
-test_random_alloc_free(void *_ __attribute__((unused)))
+test_random_alloc_free(void *_ __rte_unused)
{
struct mem_list {
struct mem_list *next;
{
struct mem_list {
struct mem_list *next;
static rte_atomic32_t synchro;
static int
static rte_atomic32_t synchro;
static int
-test_mcslock_per_core(__attribute__((unused)) void *arg)
+test_mcslock_per_core(__rte_unused void *arg)
{
/* Per core me node. */
rte_mcslock_t ml_me = RTE_PER_LCORE(_ml_me);
{
/* Per core me node. */
rte_mcslock_t ml_me = RTE_PER_LCORE(_ml_me);
* return immediately.
*/
static int
* return immediately.
*/
static int
-test_mcslock_try(__attribute__((unused)) void *arg)
+test_mcslock_try(__rte_unused void *arg)
{
/**< Per core me node. */
rte_mcslock_t ml_me = RTE_PER_LCORE(_ml_me);
{
/**< Per core me node. */
rte_mcslock_t ml_me = RTE_PER_LCORE(_ml_me);
* other bytes are set to 0.
*/
static void
* other bytes are set to 0.
*/
static void
-my_obj_init(struct rte_mempool *mp, __attribute__((unused)) void *arg,
+my_obj_init(struct rte_mempool *mp, __rte_unused void *arg,
void *obj, unsigned i)
{
uint32_t *objnum = obj;
void *obj, unsigned i)
{
uint32_t *objnum = obj;
* can run on one lcore only
*/
static int
* can run on one lcore only
*/
static int
-test_mempool_launch_single_consumer(__attribute__((unused)) void *arg)
+test_mempool_launch_single_consumer(__rte_unused void *arg)
{
return test_mempool_single_consumer();
}
static void
{
return test_mempool_single_consumer();
}
static void
-my_mp_init(struct rte_mempool *mp, __attribute__((unused)) void *arg)
+my_mp_init(struct rte_mempool *mp, __rte_unused void *arg)
{
printf("mempool name is %s\n", mp->name);
/* nothing to be implemented here*/
{
printf("mempool name is %s\n", mp->name);
/* nothing to be implemented here*/
* other bytes are set to 0.
*/
static void
* other bytes are set to 0.
*/
static void
-my_obj_init(struct rte_mempool *mp, __attribute__((unused)) void *arg,
+my_obj_init(struct rte_mempool *mp, __rte_unused void *arg,
void *obj, unsigned i)
{
uint32_t *objnum = obj;
void *obj, unsigned i)
{
uint32_t *objnum = obj;
static RTE_DEFINE_PER_LCORE(unsigned, test) = 0x12345678;
static int
static RTE_DEFINE_PER_LCORE(unsigned, test) = 0x12345678;
static int
-assign_vars(__attribute__((unused)) void *arg)
+assign_vars(__rte_unused void *arg)
{
if (RTE_PER_LCORE(test) != 0x12345678)
return -1;
{
if (RTE_PER_LCORE(test) != 0x12345678)
return -1;
-display_vars(__attribute__((unused)) void *arg)
+display_vars(__rte_unused void *arg)
{
unsigned lcore_id = rte_lcore_id();
unsigned var = RTE_PER_LCORE(test);
{
unsigned lcore_id = rte_lcore_id();
unsigned var = RTE_PER_LCORE(test);
-test_per_lcore_delay(__attribute__((unused)) void *arg)
+test_per_lcore_delay(__rte_unused void *arg)
{
rte_delay_ms(100);
printf("wait 100ms on lcore %u\n", rte_lcore_id());
{
rte_delay_ms(100);
printf("wait 100ms on lcore %u\n", rte_lcore_id());
static struct try_rwlock_lcore try_lcore_data[RTE_MAX_LCORE];
static int
static struct try_rwlock_lcore try_lcore_data[RTE_MAX_LCORE];
static int
-test_rwlock_per_core(__attribute__((unused)) void *arg)
+test_rwlock_per_core(__rte_unused void *arg)
{
rte_rwlock_write_lock(&sl);
printf("Global write lock taken on core %u\n", rte_lcore_id());
{
rte_rwlock_write_lock(&sl);
printf("Global write lock taken on core %u\n", rte_lcore_id());
#define TEST_RWLOCK_DEBUG 0
static int
#define TEST_RWLOCK_DEBUG 0
static int
-load_loop_fn(__attribute__((unused)) void *arg)
+load_loop_fn(__rte_unused void *arg)
{
uint64_t time_diff = 0, begin;
uint64_t hz = rte_get_timer_hz();
{
uint64_t time_diff = 0, begin;
uint64_t hz = rte_get_timer_hz();
static rte_atomic32_t synchro;
static int
static rte_atomic32_t synchro;
static int
-test_spinlock_per_core(__attribute__((unused)) void *arg)
+test_spinlock_per_core(__rte_unused void *arg)
{
rte_spinlock_lock(&sl);
printf("Global lock taken on core %u\n", rte_lcore_id());
{
rte_spinlock_lock(&sl);
printf("Global lock taken on core %u\n", rte_lcore_id());
-test_spinlock_recursive_per_core(__attribute__((unused)) void *arg)
+test_spinlock_recursive_per_core(__rte_unused void *arg)
{
unsigned id = rte_lcore_id();
{
unsigned id = rte_lcore_id();
* checked as the result later.
*/
static int
* checked as the result later.
*/
static int
-test_spinlock_try(__attribute__((unused)) void *arg)
+test_spinlock_try(__rte_unused void *arg)
{
if (rte_spinlock_trylock(&sl_try) == 0) {
rte_spinlock_lock(&sl);
{
if (rte_spinlock_trylock(&sl_try) == 0) {
rte_spinlock_lock(&sl);
static void app_init_mbuf_pools(void);
uint64_t pipeline_test_hash(void *key,
static void app_init_mbuf_pools(void);
uint64_t pipeline_test_hash(void *key,
- __attribute__((unused)) void *key_mask,
- __attribute__((unused)) uint32_t key_size,
- __attribute__((unused)) uint64_t seed)
+ __rte_unused void *key_mask,
+ __rte_unused uint32_t key_size,
+ __rte_unused uint64_t seed)
{
uint32_t *k32 = key;
uint32_t ip_dst = rte_be_to_cpu_32(k32[0]);
{
uint32_t *k32 = key;
uint32_t ip_dst = rte_be_to_cpu_32(k32[0]);
}
uint32_t pipeline_test_hash_cuckoo(const void *key,
}
uint32_t pipeline_test_hash_cuckoo(const void *key,
- __attribute__((unused)) uint32_t key_size,
- __attribute__((unused)) uint32_t seed)
+ __rte_unused uint32_t key_size,
+ __rte_unused uint32_t seed)
{
const uint32_t *k32 = key;
uint32_t ip_dst = rte_be_to_cpu_32(k32[0]);
{
const uint32_t *k32 = key;
uint32_t ip_dst = rte_be_to_cpu_32(k32[0]);
/* Function definitions */
uint64_t pipeline_test_hash(
void *key,
/* Function definitions */
uint64_t pipeline_test_hash(
void *key,
- __attribute__((unused)) void *key_mask,
- __attribute__((unused)) uint32_t key_size,
- __attribute__((unused)) uint64_t seed);
+ __rte_unused void *key_mask,
+ __rte_unused uint32_t key_size,
+ __rte_unused uint64_t seed);
uint32_t pipeline_test_hash_cuckoo(
const void *key,
uint32_t pipeline_test_hash_cuckoo(
const void *key,
- __attribute__((unused)) uint32_t key_size,
- __attribute__((unused)) uint32_t seed);
+ __rte_unused uint32_t key_size,
+ __rte_unused uint32_t seed);
/* Extern variables */
extern struct rte_pipeline *p;
/* Extern variables */
extern struct rte_pipeline *p;
uint64_t pkts_mask, struct rte_pipeline_table_entry *entry, void *arg);
rte_pipeline_table_action_handler_hit
uint64_t pkts_mask, struct rte_pipeline_table_entry *entry, void *arg);
rte_pipeline_table_action_handler_hit
-table_action_0x00(__attribute__((unused)) struct rte_pipeline *p,
- __attribute__((unused)) struct rte_mbuf **pkts,
+table_action_0x00(__rte_unused struct rte_pipeline *p,
+ __rte_unused struct rte_mbuf **pkts,
- __attribute__((unused)) struct rte_pipeline_table_entry **entry,
- __attribute__((unused)) void *arg)
+ __rte_unused struct rte_pipeline_table_entry **entry,
+ __rte_unused void *arg)
{
printf("Table Action, setting pkts_mask to 0x00\n");
pkts_mask = ~0x00;
{
printf("Table Action, setting pkts_mask to 0x00\n");
pkts_mask = ~0x00;
}
rte_pipeline_table_action_handler_hit
}
rte_pipeline_table_action_handler_hit
-table_action_stub_hit(__attribute__((unused)) struct rte_pipeline *p,
- __attribute__((unused)) struct rte_mbuf **pkts,
+table_action_stub_hit(__rte_unused struct rte_pipeline *p,
+ __rte_unused struct rte_mbuf **pkts,
- __attribute__((unused)) struct rte_pipeline_table_entry **entry,
- __attribute__((unused)) void *arg)
+ __rte_unused struct rte_pipeline_table_entry **entry,
+ __rte_unused void *arg)
{
printf("STUB Table Action Hit - doing nothing\n");
printf("STUB Table Action Hit - setting mask to 0x%"PRIx64"\n",
{
printf("STUB Table Action Hit - doing nothing\n");
printf("STUB Table Action Hit - setting mask to 0x%"PRIx64"\n",
static int
table_action_stub_miss(struct rte_pipeline *p,
static int
table_action_stub_miss(struct rte_pipeline *p,
- __attribute__((unused)) struct rte_mbuf **pkts,
+ __rte_unused struct rte_mbuf **pkts,
- __attribute__((unused)) struct rte_pipeline_table_entry *entry,
- __attribute__((unused)) void *arg)
+ __rte_unused struct rte_pipeline_table_entry *entry,
+ __rte_unused void *arg)
{
printf("STUB Table Action Miss - setting mask to 0x%"PRIx64"\n",
override_miss_mask);
{
printf("STUB Table Action Miss - setting mask to 0x%"PRIx64"\n",
override_miss_mask);
static rte_atomic32_t synchro;
static int
static rte_atomic32_t synchro;
static int
-test_ticketlock_per_core(__attribute__((unused)) void *arg)
+test_ticketlock_per_core(__rte_unused void *arg)
{
rte_ticketlock_lock(&tl);
printf("Global lock taken on core %u\n", rte_lcore_id());
{
rte_ticketlock_lock(&tl);
printf("Global lock taken on core %u\n", rte_lcore_id());
-test_ticketlock_recursive_per_core(__attribute__((unused)) void *arg)
+test_ticketlock_recursive_per_core(__rte_unused void *arg)
{
unsigned int id = rte_lcore_id();
{
unsigned int id = rte_lcore_id();
* checked as the result later.
*/
static int
* checked as the result later.
*/
static int
-test_ticketlock_try(__attribute__((unused)) void *arg)
+test_ticketlock_try(__rte_unused void *arg)
{
if (rte_ticketlock_trylock(&tl_try) == 0) {
rte_ticketlock_lock(&tl);
{
if (rte_ticketlock_trylock(&tl_try) == 0) {
rte_ticketlock_lock(&tl);
/* timer callback for stress tests */
static void
/* timer callback for stress tests */
static void
-timer_stress_cb(__attribute__((unused)) struct rte_timer *tim,
- __attribute__((unused)) void *arg)
+timer_stress_cb(__rte_unused struct rte_timer *tim,
+ __rte_unused void *arg)
{
long r;
unsigned lcore_id = rte_lcore_id();
{
long r;
unsigned lcore_id = rte_lcore_id();
-timer_stress_main_loop(__attribute__((unused)) void *arg)
+timer_stress_main_loop(__rte_unused void *arg)
{
uint64_t hz = rte_get_timer_hz();
unsigned lcore_id = rte_lcore_id();
{
uint64_t hz = rte_get_timer_hz();
unsigned lcore_id = rte_lcore_id();
#define NB_STRESS2_TIMERS 8192
static int
#define NB_STRESS2_TIMERS 8192
static int
-timer_stress2_main_loop(__attribute__((unused)) void *arg)
+timer_stress2_main_loop(__rte_unused void *arg)
{
static struct rte_timer *timers;
int i, ret;
{
static struct rte_timer *timers;
int i, ret;
-timer_basic_main_loop(__attribute__((unused)) void *arg)
+timer_basic_main_loop(__rte_unused void *arg)
{
uint64_t hz = rte_get_timer_hz();
unsigned lcore_id = rte_lcore_id();
{
uint64_t hz = rte_get_timer_hz();
unsigned lcore_id = rte_lcore_id();
-slave_main_loop(__attribute__((unused)) void *arg)
+slave_main_loop(__rte_unused void *arg)
{
unsigned lcore_id = rte_lcore_id();
unsigned i;
{
unsigned lcore_id = rte_lcore_id();
unsigned i;
- static void cmd_obj_del_show_parsed(void *parsed_result, struct cmdline *cl, attribute ((unused)) void *data)
+ static void cmd_obj_del_show_parsed(void *parsed_result, struct cmdline *cl, __rte_unused void *data)
.. code-block:: c
static int
.. code-block:: c
static int
- lcore_hello( attribute ((unused)) void *arg)
+ lcore_hello(__rte_unused void *arg)
- attribute ((noreturn)) int main_loop( attribute ((unused)) void *dummy)
+ attribute ((noreturn)) int main_loop(__rte_unused void *dummy)
/* timer0 callback */
static void
/* timer0 callback */
static void
- timer0_cb( attribute ((unused)) struct rte_timer *tim, __attribute ((unused)) void *arg)
+ timer0_cb(__rte_unused struct rte_timer *tim, __rte_unused void *arg)
{
static unsigned counter = 0;
{
static unsigned counter = 0;
/* timer1 callback */
static void
/* timer1 callback */
static void
- timer1_cb( attribute ((unused)) struct rte_timer *tim, _attribute ((unused)) void *arg)
+ timer1_cb(__rte_unused struct rte_timer *tim, __rte_unused void *arg)
{
unsigned lcore_id = rte_lcore_id();
uint64_t hz;
{
unsigned lcore_id = rte_lcore_id();
uint64_t hz;
#ifdef RTE_LIBRTE_DPAA2_USE_PHYS_IOVA
extern uint8_t dpaa2_virt_mode;
#ifdef RTE_LIBRTE_DPAA2_USE_PHYS_IOVA
extern uint8_t dpaa2_virt_mode;
-static void *dpaa2_mem_ptov(phys_addr_t paddr) __attribute__((unused));
+static void *dpaa2_mem_ptov(phys_addr_t paddr) __rte_unused;
static void *dpaa2_mem_ptov(phys_addr_t paddr)
{
static void *dpaa2_mem_ptov(phys_addr_t paddr)
{
-static phys_addr_t dpaa2_mem_vtop(uint64_t vaddr) __attribute__((unused));
+static phys_addr_t dpaa2_mem_vtop(uint64_t vaddr) __rte_unused;
static phys_addr_t dpaa2_mem_vtop(uint64_t vaddr)
{
static phys_addr_t dpaa2_mem_vtop(uint64_t vaddr)
{
#endif
#ifndef __always_unused
#endif
#ifndef __always_unused
-#define __always_unused __attribute__((unused))
+#define __always_unused __rte_unused
#endif
#ifndef __maybe_unused
#endif
#ifndef __maybe_unused
-#define __maybe_unused __attribute__((unused))
+#define __maybe_unused __rte_unused
#endif
#if defined(__GLIBC__) && !defined(pr_debug)
#endif
#if defined(__GLIBC__) && !defined(pr_debug)
qbman_swp_dqrr_consume(swp, dq);
}
static void
qbman_swp_dqrr_consume(swp, dq);
}
static void
-dpaa2_sec_process_atomic_event(struct qbman_swp *swp __attribute__((unused)),
+dpaa2_sec_process_atomic_event(struct qbman_swp *swp __rte_unused,
const struct qbman_fd *fd,
const struct qbman_result *dq,
struct dpaa2_queue *rxq,
const struct qbman_fd *fd,
const struct qbman_result *dq,
struct dpaa2_queue *rxq,
-mode6_debug(const char __attribute__((unused)) *info,
+mode6_debug(const char __rte_unused *info,
struct rte_ether_hdr *eth_h, uint16_t port,
struct rte_ether_hdr *eth_h, uint16_t port,
- uint32_t __attribute__((unused)) *burstnumber)
+ uint32_t __rte_unused *burstnumber)
{
struct rte_ipv4_hdr *ipv4_h;
#ifdef RTE_LIBRTE_BOND_DEBUG_ALB
{
struct rte_ipv4_hdr *ipv4_h;
#ifdef RTE_LIBRTE_BOND_DEBUG_ALB
uint16_t dummy_dev_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts);
void dpaa2_dev_free_eqresp_buf(uint16_t eqresp_ci);
void dpaa2_flow_clean(struct rte_eth_dev *dev);
uint16_t dummy_dev_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts);
void dpaa2_dev_free_eqresp_buf(uint16_t eqresp_ci);
void dpaa2_flow_clean(struct rte_eth_dev *dev);
-uint16_t dpaa2_dev_tx_conf(void *queue) __attribute__((unused));
+uint16_t dpaa2_dev_tx_conf(void *queue) __rte_unused;
#if defined(RTE_LIBRTE_IEEE1588)
int dpaa2_timesync_enable(struct rte_eth_dev *dev);
#if defined(RTE_LIBRTE_IEEE1588)
int dpaa2_timesync_enable(struct rte_eth_dev *dev);
dpaa2_dev_rx_parse_slow(struct rte_mbuf *mbuf,
struct dpaa2_annot_hdr *annotation);
dpaa2_dev_rx_parse_slow(struct rte_mbuf *mbuf,
struct dpaa2_annot_hdr *annotation);
-static void enable_tx_tstamp(struct qbman_fd *fd) __attribute__((unused));
+static void enable_tx_tstamp(struct qbman_fd *fd) __rte_unused;
#define DPAA2_MBUF_TO_CONTIG_FD(_mbuf, _fd, _bpid) do { \
DPAA2_SET_FD_ADDR(_fd, DPAA2_MBUF_VADDR_TO_IOVA(_mbuf)); \
#define DPAA2_MBUF_TO_CONTIG_FD(_mbuf, _fd, _bpid) do { \
DPAA2_SET_FD_ADDR(_fd, DPAA2_MBUF_VADDR_TO_IOVA(_mbuf)); \
static void
eth_mbuf_to_fd(struct rte_mbuf *mbuf,
static void
eth_mbuf_to_fd(struct rte_mbuf *mbuf,
- struct qbman_fd *fd, uint16_t bpid) __attribute__((unused));
+ struct qbman_fd *fd, uint16_t bpid) __rte_unused;
static void __rte_noinline __attribute__((hot))
eth_mbuf_to_fd(struct rte_mbuf *mbuf,
static void __rte_noinline __attribute__((hot))
eth_mbuf_to_fd(struct rte_mbuf *mbuf,
}
void __attribute__((hot))
}
void __attribute__((hot))
-dpaa2_dev_process_atomic_event(struct qbman_swp *swp __attribute__((unused)),
+dpaa2_dev_process_atomic_event(struct qbman_swp *swp __rte_unused,
const struct qbman_fd *fd,
const struct qbman_result *dq,
struct dpaa2_queue *rxq,
const struct qbman_fd *fd,
const struct qbman_result *dq,
struct dpaa2_queue *rxq,
int vnic_dev_alloc_desc_ring(struct vnic_dev *vdev,
struct vnic_dev_ring *ring,
unsigned int desc_count, unsigned int desc_size,
int vnic_dev_alloc_desc_ring(struct vnic_dev *vdev,
struct vnic_dev_ring *ring,
unsigned int desc_count, unsigned int desc_size,
- __attribute__((unused)) unsigned int socket_id,
+ __rte_unused unsigned int socket_id,
char *z_name)
{
void *alloc_addr;
char *z_name)
{
void *alloc_addr;
-void vnic_dev_free_desc_ring(__attribute__((unused)) struct vnic_dev *vdev,
+void vnic_dev_free_desc_ring(__rte_unused struct vnic_dev *vdev,
struct vnic_dev_ring *ring)
{
if (ring->descs) {
struct vnic_dev_ring *ring)
{
if (ring->descs) {
}
static int hinic_rss_init(struct hinic_nic_dev *nic_dev,
}
static int hinic_rss_init(struct hinic_nic_dev *nic_dev,
- __attribute__((unused)) u8 *rq2iq_map,
+ __rte_unused u8 *rq2iq_map,
struct rte_eth_rss_conf *rss_conf)
{
u32 indir_tbl[HINIC_RSS_INDIR_SIZE] = {0};
struct rte_eth_rss_conf *rss_conf)
{
u32 indir_tbl[HINIC_RSS_INDIR_SIZE] = {0};
static int
hns3_add_mac_addr(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr,
static int
hns3_add_mac_addr(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr,
- uint32_t idx, __attribute__ ((unused)) uint32_t pool)
+ uint32_t idx, __rte_unused uint32_t pool)
{
struct hns3_hw *hw = HNS3_DEV_PRIVATE_TO_HW(dev->data->dev_private);
char mac_str[RTE_ETHER_ADDR_FMT_SIZE];
{
struct hns3_hw *hw = HNS3_DEV_PRIVATE_TO_HW(dev->data->dev_private);
char mac_str[RTE_ETHER_ADDR_FMT_SIZE];
static int
hns3vf_add_mac_addr(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr,
static int
hns3vf_add_mac_addr(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr,
- __attribute__ ((unused)) uint32_t idx,
- __attribute__ ((unused)) uint32_t pool)
+ __rte_unused uint32_t idx,
+ __rte_unused uint32_t pool)
{
struct hns3_hw *hw = HNS3_DEV_PRIVATE_TO_HW(dev->data->dev_private);
char mac_str[RTE_ETHER_ADDR_FMT_SIZE];
{
struct hns3_hw *hw = HNS3_DEV_PRIVATE_TO_HW(dev->data->dev_private);
char mac_str[RTE_ETHER_ADDR_FMT_SIZE];
* @alignment: what to align the allocation to
**/
enum i40e_status_code
* @alignment: what to align the allocation to
**/
enum i40e_status_code
-i40e_allocate_dma_mem_d(__attribute__((unused)) struct i40e_hw *hw,
+i40e_allocate_dma_mem_d(__rte_unused struct i40e_hw *hw,
struct i40e_dma_mem *mem,
u64 size,
u32 alignment)
struct i40e_dma_mem *mem,
u64 size,
u32 alignment)
* @mem: ptr to mem struct to free
**/
enum i40e_status_code
* @mem: ptr to mem struct to free
**/
enum i40e_status_code
-i40e_free_dma_mem_d(__attribute__((unused)) struct i40e_hw *hw,
+i40e_free_dma_mem_d(__rte_unused struct i40e_hw *hw,
struct i40e_dma_mem *mem)
{
if (!mem)
struct i40e_dma_mem *mem)
{
if (!mem)
* @size: size of memory requested
**/
enum i40e_status_code
* @size: size of memory requested
**/
enum i40e_status_code
-i40e_allocate_virt_mem_d(__attribute__((unused)) struct i40e_hw *hw,
+i40e_allocate_virt_mem_d(__rte_unused struct i40e_hw *hw,
struct i40e_virt_mem *mem,
u32 size)
{
struct i40e_virt_mem *mem,
u32 size)
{
* @mem: pointer to mem struct to free
**/
enum i40e_status_code
* @mem: pointer to mem struct to free
**/
enum i40e_status_code
-i40e_free_virt_mem_d(__attribute__((unused)) struct i40e_hw *hw,
+i40e_free_virt_mem_d(__rte_unused struct i40e_hw *hw,
struct i40e_virt_mem *mem)
{
if (!mem)
struct i40e_virt_mem *mem)
{
if (!mem)
-i40e_destroy_spinlock_d(__attribute__((unused)) struct i40e_spinlock *sp)
+i40e_destroy_spinlock_d(__rte_unused struct i40e_spinlock *sp)
#endif /* __INTEL_NET_BASE_OSDEP__ */
#ifndef __always_unused
#endif /* __INTEL_NET_BASE_OSDEP__ */
#ifndef __always_unused
-#define __always_unused __attribute__((unused))
+#define __always_unused __rte_unused
#endif
#ifndef __maybe_unused
#endif
#ifndef __maybe_unused
-#define __maybe_unused __attribute__((unused))
+#define __maybe_unused __rte_unused
#endif
#ifndef __packed
#define __packed __rte_packed
#endif
#ifndef __packed
#define __packed __rte_packed
-ice_destroy_lock(__attribute__((unused)) struct ice_lock *sp)
+ice_destroy_lock(__rte_unused struct ice_lock *sp)
{
}
struct ice_hw;
static inline void *
{
}
struct ice_hw;
static inline void *
-ice_alloc_dma_mem(__attribute__((unused)) struct ice_hw *hw,
+ice_alloc_dma_mem(__rte_unused struct ice_hw *hw,
struct ice_dma_mem *mem, u64 size)
{
const struct rte_memzone *mz = NULL;
struct ice_dma_mem *mem, u64 size)
{
const struct rte_memzone *mz = NULL;
-ice_free_dma_mem(__attribute__((unused)) struct ice_hw *hw,
+ice_free_dma_mem(__rte_unused struct ice_hw *hw,
struct ice_dma_mem *mem)
{
PMD_DRV_LOG(DEBUG, "memzone %s to be freed with physical address: "
struct ice_dma_mem *mem)
{
PMD_DRV_LOG(DEBUG, "memzone %s to be freed with physical address: "
static int
ixgbevf_add_mac_addr(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr,
static int
ixgbevf_add_mac_addr(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr,
- __attribute__((unused)) uint32_t index,
- __attribute__((unused)) uint32_t pool)
+ __rte_unused uint32_t index,
+ __rte_unused uint32_t pool)
{
struct ixgbe_hw *hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
int diag;
{
struct ixgbe_hw *hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
int diag;
-ixgbe_dev_addr_list_itr(__attribute__((unused)) struct ixgbe_hw *hw,
+ixgbe_dev_addr_list_itr(__rte_unused struct ixgbe_hw *hw,
u8 **mc_addr_ptr, u32 *vmdq)
{
u8 *mc_addr;
u8 **mc_addr_ptr, u32 *vmdq)
{
u8 *mc_addr;
return rte_mem_iova2virt(paddr);
}
return rte_mem_iova2virt(paddr);
}
-static phys_addr_t pfe_mem_vtop(uint64_t vaddr) __attribute__((unused));
+static phys_addr_t pfe_mem_vtop(uint64_t vaddr) __rte_unused;
static inline phys_addr_t pfe_mem_vtop(uint64_t vaddr)
{
static inline phys_addr_t pfe_mem_vtop(uint64_t vaddr)
{
#define OSAL_PAGE_SIZE 4096
#define OSAL_CACHE_LINE_SIZE RTE_CACHE_LINE_SIZE
#define OSAL_IOMEM volatile
#define OSAL_PAGE_SIZE 4096
#define OSAL_CACHE_LINE_SIZE RTE_CACHE_LINE_SIZE
#define OSAL_IOMEM volatile
-#define OSAL_UNUSED __attribute__((unused))
+#define OSAL_UNUSED __rte_unused
#define OSAL_UNLIKELY(x) __builtin_expect(!!(x), 0)
#define OSAL_MIN_T(type, __min1, __min2) \
((type)(__min1) < (type)(__min2) ? (type)(__min1) : (type)(__min2))
#define OSAL_UNLIKELY(x) __builtin_expect(!!(x), 0)
#define OSAL_MIN_T(type, __min1, __min2) \
((type)(__min1) < (type)(__min2) ? (type)(__min1) : (type)(__min2))
static int
_qede_tunn_filter_config(struct rte_eth_dev *eth_dev,
const struct rte_eth_tunnel_filter_conf *conf,
static int
_qede_tunn_filter_config(struct rte_eth_dev *eth_dev,
const struct rte_eth_tunnel_filter_conf *conf,
- __attribute__((unused)) enum rte_filter_op filter_op,
+ __rte_unused enum rte_filter_op filter_op,
enum ecore_tunn_clss *clss,
bool add)
{
enum ecore_tunn_clss *clss,
bool add)
{
-qede_flow_validate_attr(__attribute__((unused))struct rte_eth_dev *dev,
+qede_flow_validate_attr(__rte_unused struct rte_eth_dev *dev,
const struct rte_flow_attr *attr,
struct rte_flow_error *error)
{
const struct rte_flow_attr *attr,
struct rte_flow_error *error)
{
-qede_flow_parse_pattern(__attribute__((unused))struct rte_eth_dev *dev,
+qede_flow_parse_pattern(__rte_unused struct rte_eth_dev *dev,
const struct rte_flow_item pattern[],
struct rte_flow_error *error,
struct rte_flow *flow)
const struct rte_flow_item pattern[],
struct rte_flow_error *error,
struct rte_flow *flow)
[NIC_MBOX_MSG_SHUTDOWN] = "NIC_MBOX_MSG_SHUTDOWN",
};
[NIC_MBOX_MSG_SHUTDOWN] = "NIC_MBOX_MSG_SHUTDOWN",
};
-static inline const char * __attribute__((unused))
+static inline const char * __rte_unused
nicvf_mbox_msg_str(int msg)
{
assert(msg >= 0 && msg < NIC_MBOX_MSG_MAX);
nicvf_mbox_msg_str(int msg)
{
assert(msg >= 0 && msg < NIC_MBOX_MSG_MAX);
-#define __maybe_unused __attribute__((__unused__))
+#define __maybe_unused __rte_unused
#define UNUSED(x) (void)(x)
#define UNUSED(x) (void)(x)
* Main thread that does the work, reading from INPUT_PORT
* and writing to OUTPUT_PORT
*/
* Main thread that does the work, reading from INPUT_PORT
* and writing to OUTPUT_PORT
*/
-static int lcore_main(__attribute__((unused)) void *arg1)
+static int lcore_main(__rte_unused void *arg1)
{
struct rte_mbuf *pkts[MAX_PKT_BURST] __rte_cache_aligned;
struct rte_ether_addr d_addr;
{
struct rte_mbuf *pkts[MAX_PKT_BURST] __rte_cache_aligned;
struct rte_ether_addr d_addr;
);
}
static void cmd_obj_send_parsed(void *parsed_result,
);
}
static void cmd_obj_send_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_obj_send_result *res = parsed_result;
{
struct cmd_obj_send_result *res = parsed_result;
cmdline_fixed_string_t start;
};
cmdline_fixed_string_t start;
};
-static void cmd_start_parsed(__attribute__((unused)) void *parsed_result,
+static void cmd_start_parsed(__rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
int slave_core_id = rte_lcore_id();
{
int slave_core_id = rte_lcore_id();
cmdline_fixed_string_t help;
};
cmdline_fixed_string_t help;
};
-static void cmd_help_parsed(__attribute__((unused)) void *parsed_result,
+static void cmd_help_parsed(__rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
cmdline_printf(cl,
"ALB - link bonding mode 6 example\n"
{
cmdline_printf(cl,
"ALB - link bonding mode 6 example\n"
cmdline_fixed_string_t stop;
};
cmdline_fixed_string_t stop;
};
-static void cmd_stop_parsed(__attribute__((unused)) void *parsed_result,
+static void cmd_stop_parsed(__rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
rte_spinlock_trylock(&global_flag_stru_p->lock);
if (global_flag_stru_p->LcoreMainIsRunning == 0) {
{
rte_spinlock_trylock(&global_flag_stru_p->lock);
if (global_flag_stru_p->LcoreMainIsRunning == 0) {
cmdline_fixed_string_t quit;
};
cmdline_fixed_string_t quit;
};
-static void cmd_quit_parsed(__attribute__((unused)) void *parsed_result,
+static void cmd_quit_parsed(__rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
rte_spinlock_trylock(&global_flag_stru_p->lock);
if (global_flag_stru_p->LcoreMainIsRunning == 0) {
{
rte_spinlock_trylock(&global_flag_stru_p->lock);
if (global_flag_stru_p->LcoreMainIsRunning == 0) {
cmdline_fixed_string_t show;
};
cmdline_fixed_string_t show;
};
-static void cmd_show_parsed(__attribute__((unused)) void *parsed_result,
+static void cmd_show_parsed(__rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
uint16_t slaves[16] = {0};
uint8_t len = 16;
{
uint16_t slaves[16] = {0};
uint8_t len = 16;
};
/* prompt function, called from main on MASTER lcore */
};
/* prompt function, called from main on MASTER lcore */
-static void prompt(__attribute__((unused)) void *arg1)
+static void prompt(__rte_unused void *arg1)
static void cmd_obj_del_show_parsed(void *parsed_result,
struct cmdline *cl,
static void cmd_obj_del_show_parsed(void *parsed_result,
struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
struct cmd_obj_del_show_result *res = parsed_result;
char ip_str[INET6_ADDRSTRLEN];
{
struct cmd_obj_del_show_result *res = parsed_result;
char ip_str[INET6_ADDRSTRLEN];
static void cmd_obj_add_parsed(void *parsed_result,
struct cmdline *cl,
static void cmd_obj_add_parsed(void *parsed_result,
struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
struct cmd_obj_add_result *res = parsed_result;
struct object *o;
{
struct cmd_obj_add_result *res = parsed_result;
struct object *o;
cmdline_fixed_string_t help;
};
cmdline_fixed_string_t help;
};
-static void cmd_help_parsed(__attribute__((unused)) void *parsed_result,
+static void cmd_help_parsed(__rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
cmdline_printf(cl,
"Demo example of command line interface in RTE\n\n"
{
cmdline_printf(cl,
"Demo example of command line interface in RTE\n\n"
-int get_help_obj_list(__attribute__((unused)) cmdline_parse_token_hdr_t *tk,
+int get_help_obj_list(__rte_unused cmdline_parse_token_hdr_t *tk,
char *dstbuf, unsigned int size)
{
snprintf(dstbuf, size, "Obj-List");
char *dstbuf, unsigned int size)
{
snprintf(dstbuf, size, "Obj-List");
rte_ether_addr_copy(&ptr_port->mac_addr, &ptr_mac_hdr->s_addr);
}
rte_ether_addr_copy(&ptr_port->mac_addr, &ptr_mac_hdr->s_addr);
}
-static int slave_main(__attribute__((unused)) void *ptr_data)
+static int slave_main(__rte_unused void *ptr_data)
{
struct app_port *ptr_port;
struct rte_mbuf *ptr_frame;
{
struct app_port *ptr_port;
struct rte_mbuf *ptr_frame;
static int
parse_interim_enc_dec(const char *key,
static int
parse_interim_enc_dec(const char *key,
- __attribute__((__unused__)) char *text,
- __attribute__((__unused__)) struct fips_val *val)
+ __rte_unused char *text,
+ __rte_unused struct fips_val *val)
{
if (strcmp(key, OP_ENC_STR) == 0)
info.op = FIPS_TEST_ENC_AUTH_GEN;
{
if (strcmp(key, OP_ENC_STR) == 0)
info.op = FIPS_TEST_ENC_AUTH_GEN;
-parse_interim_algo(__attribute__((__unused__)) const char *key,
+parse_interim_algo(__rte_unused const char *key,
- __attribute__((__unused__)) struct fips_val *val)
+ __rte_unused struct fips_val *val)
-parse_interim_algo(__attribute__((__unused__)) const char *key,
+parse_interim_algo(__rte_unused const char *key,
- __attribute__((__unused__)) struct fips_val *val)
+ __rte_unused struct fips_val *val)
static int
parse_tdes_interim(const char *key,
static int
parse_tdes_interim(const char *key,
- __attribute__((__unused__)) char *text,
+ __rte_unused char *text,
struct fips_val *val);
struct fips_test_callback tdes_tests_vectors[] = {
struct fips_val *val);
struct fips_test_callback tdes_tests_vectors[] = {
static int
parse_tdes_interim(const char *key,
static int
parse_tdes_interim(const char *key,
- __attribute__((__unused__)) char *text,
- __attribute__((__unused__)) struct fips_val *val)
+ __rte_unused char *text,
+ __rte_unused struct fips_val *val)
{
if (strstr(key, ENC_STR))
info.op = FIPS_TEST_ENC_AUTH_GEN;
{
if (strstr(key, ENC_STR))
info.op = FIPS_TEST_ENC_AUTH_GEN;
#include <rte_debug.h>
static int
#include <rte_debug.h>
static int
-lcore_hello(__attribute__((unused)) void *arg)
+lcore_hello(__rte_unused void *arg)
{
unsigned lcore_id;
lcore_id = rte_lcore_id();
{
unsigned lcore_id;
lcore_id = rte_lcore_id();
/* main processing loop */
static int
/* main processing loop */
static int
-main_loop(__attribute__((unused)) void *dummy)
+main_loop(__rte_unused void *dummy)
{
struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
unsigned lcore_id;
{
struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
unsigned lcore_id;
/* main processing loop */
static int
/* main processing loop */
static int
-main_loop(__attribute__((unused)) void *dummy)
+main_loop(__rte_unused void *dummy)
{
struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
unsigned lcore_id;
{
struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
unsigned lcore_id;
-l2fwd_launch_one_lcore(__attribute__((unused)) void *dummy)
+l2fwd_launch_one_lcore(__rte_unused void *dummy)
{
l2fwd_main_loop();
return 0;
{
l2fwd_main_loop();
return 0;
/* Print out statistics on packets dropped */
static void
/* Print out statistics on packets dropped */
static void
-print_stats(__attribute__((unused)) struct rte_timer *ptr_timer,
- __attribute__((unused)) void *ptr_data)
+print_stats(__rte_unused struct rte_timer *ptr_timer,
+ __rte_unused void *ptr_data)
{
uint64_t total_packets_dropped, total_packets_tx, total_packets_rx;
uint16_t portid;
{
uint64_t total_packets_dropped, total_packets_tx, total_packets_rx;
uint16_t portid;
-l2fwd_launch_one_lcore(__attribute__((unused)) void *dummy)
+l2fwd_launch_one_lcore(__rte_unused void *dummy)
{
l2fwd_main_loop();
return 0;
{
l2fwd_main_loop();
return 0;
-l2fwd_launch_one_lcore(__attribute__((unused)) void *dummy)
+l2fwd_launch_one_lcore(__rte_unused void *dummy)
{
l2fwd_main_loop();
return 0;
{
l2fwd_main_loop();
return 0;
/* main processing loop */
static int
/* main processing loop */
static int
-main_loop(__attribute__((unused)) void *dummy)
+main_loop(__rte_unused void *dummy)
{
struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
unsigned lcore_id;
{
struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
unsigned lcore_id;
/* Freqency scale down timer callback */
static void
/* Freqency scale down timer callback */
static void
-power_timer_cb(__attribute__((unused)) struct rte_timer *tim,
- __attribute__((unused)) void *arg)
+power_timer_cb(__rte_unused struct rte_timer *tim,
+ __rte_unused void *arg)
{
uint64_t hz;
float sleep_time_ratio;
{
uint64_t hz;
float sleep_time_ratio;
}
/* main processing loop */
static int
}
/* main processing loop */
static int
-main_telemetry_loop(__attribute__((unused)) void *dummy)
+main_telemetry_loop(__rte_unused void *dummy)
{
struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
unsigned int lcore_id;
{
struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
unsigned int lcore_id;
}
/* main processing loop */
static int
}
/* main processing loop */
static int
-main_empty_poll_loop(__attribute__((unused)) void *dummy)
+main_empty_poll_loop(__rte_unused void *dummy)
{
struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
unsigned int lcore_id;
{
struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
unsigned int lcore_id;
}
/* main processing loop */
static int
}
/* main processing loop */
static int
-main_loop(__attribute__((unused)) void *dummy)
+main_loop(__rte_unused void *dummy)
{
struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
unsigned lcore_id;
{
struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
unsigned lcore_id;
return ret;
}
static void
return ret;
}
static void
-update_telemetry(__attribute__((unused)) struct rte_timer *tim,
- __attribute__((unused)) void *arg)
+update_telemetry(__rte_unused struct rte_timer *tim,
+ __rte_unused void *arg)
{
unsigned int lcore_id = rte_lcore_id();
struct lcore_conf *qconf;
{
unsigned int lcore_id = rte_lcore_id();
struct lcore_conf *qconf;
uint16_t nb_pkts, uint16_t max_pkts, void *user_param);
int
uint16_t nb_pkts, uint16_t max_pkts, void *user_param);
int
-em_main_loop(__attribute__((unused)) void *dummy);
+em_main_loop(__rte_unused void *dummy);
-lpm_main_loop(__attribute__((unused)) void *dummy);
+lpm_main_loop(__rte_unused void *dummy);
-lpm_event_main_loop_tx_d(__attribute__((unused)) void *dummy);
+lpm_event_main_loop_tx_d(__rte_unused void *dummy);
-lpm_event_main_loop_tx_d_burst(__attribute__((unused)) void *dummy);
+lpm_event_main_loop_tx_d_burst(__rte_unused void *dummy);
-lpm_event_main_loop_tx_q(__attribute__((unused)) void *dummy);
+lpm_event_main_loop_tx_q(__rte_unused void *dummy);
-lpm_event_main_loop_tx_q_burst(__attribute__((unused)) void *dummy);
+lpm_event_main_loop_tx_q_burst(__rte_unused void *dummy);
-em_event_main_loop_tx_d(__attribute__((unused)) void *dummy);
+em_event_main_loop_tx_d(__rte_unused void *dummy);
-em_event_main_loop_tx_d_burst(__attribute__((unused)) void *dummy);
+em_event_main_loop_tx_d_burst(__rte_unused void *dummy);
-em_event_main_loop_tx_q(__attribute__((unused)) void *dummy);
+em_event_main_loop_tx_q(__rte_unused void *dummy);
-em_event_main_loop_tx_q_burst(__attribute__((unused)) void *dummy);
+em_event_main_loop_tx_q_burst(__rte_unused void *dummy);
/* Return ipv4/ipv6 fwd lookup struct for LPM or EM. */
/* Return ipv4/ipv6 fwd lookup struct for LPM or EM. */
/* main processing loop */
int
/* main processing loop */
int
-em_main_loop(__attribute__((unused)) void *dummy)
+em_main_loop(__rte_unused void *dummy)
{
struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
unsigned lcore_id;
{
struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
unsigned lcore_id;
-em_event_main_loop_tx_d(__attribute__((unused)) void *dummy)
+em_event_main_loop_tx_d(__rte_unused void *dummy)
{
struct l3fwd_event_resources *evt_rsrc =
l3fwd_get_eventdev_rsrc();
{
struct l3fwd_event_resources *evt_rsrc =
l3fwd_get_eventdev_rsrc();
-em_event_main_loop_tx_d_burst(__attribute__((unused)) void *dummy)
+em_event_main_loop_tx_d_burst(__rte_unused void *dummy)
{
struct l3fwd_event_resources *evt_rsrc =
l3fwd_get_eventdev_rsrc();
{
struct l3fwd_event_resources *evt_rsrc =
l3fwd_get_eventdev_rsrc();
-em_event_main_loop_tx_q(__attribute__((unused)) void *dummy)
+em_event_main_loop_tx_q(__rte_unused void *dummy)
{
struct l3fwd_event_resources *evt_rsrc =
l3fwd_get_eventdev_rsrc();
{
struct l3fwd_event_resources *evt_rsrc =
l3fwd_get_eventdev_rsrc();
-em_event_main_loop_tx_q_burst(__attribute__((unused)) void *dummy)
+em_event_main_loop_tx_q_burst(__rte_unused void *dummy)
{
struct l3fwd_event_resources *evt_rsrc =
l3fwd_get_eventdev_rsrc();
{
struct l3fwd_event_resources *evt_rsrc =
l3fwd_get_eventdev_rsrc();
/* main processing loop */
int
/* main processing loop */
int
-lpm_main_loop(__attribute__((unused)) void *dummy)
+lpm_main_loop(__rte_unused void *dummy)
{
struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
unsigned lcore_id;
{
struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
unsigned lcore_id;
-lpm_event_main_loop_tx_d(__attribute__((unused)) void *dummy)
+lpm_event_main_loop_tx_d(__rte_unused void *dummy)
{
struct l3fwd_event_resources *evt_rsrc =
l3fwd_get_eventdev_rsrc();
{
struct l3fwd_event_resources *evt_rsrc =
l3fwd_get_eventdev_rsrc();
-lpm_event_main_loop_tx_d_burst(__attribute__((unused)) void *dummy)
+lpm_event_main_loop_tx_d_burst(__rte_unused void *dummy)
{
struct l3fwd_event_resources *evt_rsrc =
l3fwd_get_eventdev_rsrc();
{
struct l3fwd_event_resources *evt_rsrc =
l3fwd_get_eventdev_rsrc();
-lpm_event_main_loop_tx_q(__attribute__((unused)) void *dummy)
+lpm_event_main_loop_tx_q(__rte_unused void *dummy)
{
struct l3fwd_event_resources *evt_rsrc =
l3fwd_get_eventdev_rsrc();
{
struct l3fwd_event_resources *evt_rsrc =
l3fwd_get_eventdev_rsrc();
-lpm_event_main_loop_tx_q_burst(__attribute__((unused)) void *dummy)
+lpm_event_main_loop_tx_q_burst(__rte_unused void *dummy)
{
struct l3fwd_event_resources *evt_rsrc =
l3fwd_get_eventdev_rsrc();
{
struct l3fwd_event_resources *evt_rsrc =
l3fwd_get_eventdev_rsrc();
-lsi_launch_one_lcore(__attribute__((unused)) void *dummy)
+lsi_launch_one_lcore(__rte_unused void *dummy)
{
lsi_main_loop();
return 0;
{
lsi_main_loop();
return 0;
* repeatedly sleeps.
*/
static int
* repeatedly sleeps.
*/
static int
-sleep_lcore(__attribute__((unused)) void *dummy)
+sleep_lcore(__rte_unused void *dummy)
{
/* Used to pick a display thread - static, so zero-initialised */
static rte_atomic32_t display_stats;
{
/* Used to pick a display thread - static, so zero-initialised */
static rte_atomic32_t display_stats;
cmdline_fixed_string_t help;
};
cmdline_fixed_string_t help;
};
-static void cmd_help_parsed(__attribute__((unused)) void *parsed_result,
+static void cmd_help_parsed(__rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
cmdline_printf(cl,
"commands:\n"
{
cmdline_printf(cl,
"commands:\n"
cmdline_fixed_string_t quit;
};
cmdline_fixed_string_t quit;
};
-static void cmd_quit_parsed(__attribute__((unused)) void *parsed_result,
+static void cmd_quit_parsed(__rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
cmdline_fixed_string_t list;
};
cmdline_fixed_string_t list;
};
-static void cmd_list_parsed(__attribute__((unused)) void *parsed_result,
+static void cmd_list_parsed(__rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
uint16_t port_id;
char dev_name[RTE_DEV_NAME_MAX_LEN];
{
uint16_t port_id;
char dev_name[RTE_DEV_NAME_MAX_LEN];
static void cmd_dev_attach_parsed(void *parsed_result,
struct cmdline *cl,
static void cmd_dev_attach_parsed(void *parsed_result,
struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
struct cmd_dev_attach_result *res = parsed_result;
struct rte_devargs da;
{
struct cmd_dev_attach_result *res = parsed_result;
struct rte_devargs da;
static void cmd_dev_detach_parsed(void *parsed_result,
struct cmdline *cl,
static void cmd_dev_detach_parsed(void *parsed_result,
struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
struct cmd_dev_detach_result *res = parsed_result;
struct rte_devargs da;
{
struct cmd_dev_detach_result *res = parsed_result;
struct rte_devargs da;
volatile int quit = 0;
static int
volatile int quit = 0;
static int
-lcore_recv(__attribute__((unused)) void *arg)
+lcore_recv(__rte_unused void *arg)
{
unsigned lcore_id = rte_lcore_id();
{
unsigned lcore_id = rte_lcore_id();
};
static void cmd_send_parsed(void *parsed_result,
};
static void cmd_send_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
void *msg = NULL;
struct cmd_send_result *res = parsed_result;
{
void *msg = NULL;
struct cmd_send_result *res = parsed_result;
cmdline_fixed_string_t quit;
};
cmdline_fixed_string_t quit;
};
-static void cmd_quit_parsed(__attribute__((unused)) void *parsed_result,
+static void cmd_quit_parsed(__rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
quit = 1;
cmdline_quit(cl);
{
quit = 1;
cmdline_quit(cl);
cmdline_fixed_string_t help;
};
cmdline_fixed_string_t help;
};
-static void cmd_help_parsed(__attribute__((unused)) void *parsed_result,
+static void cmd_help_parsed(__rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
cmdline_printf(cl, "Simple demo example of multi-process in RTE\n\n"
"This is a readline-like interface that can be used to\n"
{
cmdline_printf(cl, "Simple demo example of multi-process in RTE\n\n"
"This is a readline-like interface that can be used to\n"
-cmd_help_parsed(__attribute__((unused)) void *parsed_result,
+cmd_help_parsed(__rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
-cmd_quit_parsed(__attribute__((unused)) void *parsed_result,
+cmd_quit_parsed(__rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
struct ntb_fwd_lcore_conf *conf;
uint32_t lcore_id;
{
struct ntb_fwd_lcore_conf *conf;
uint32_t lcore_id;
static void
cmd_sendfile_parsed(void *parsed_result,
static void
cmd_sendfile_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_sendfile_result *res = parsed_result;
struct rte_rawdev_buf *pkts_send[NTB_MAX_PKT_BURST];
{
struct cmd_sendfile_result *res = parsed_result;
struct rte_rawdev_buf *pkts_send[NTB_MAX_PKT_BURST];
-cmd_start_parsed(__attribute__((unused)) void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+cmd_start_parsed(__rte_unused void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
-cmd_stop_parsed(__attribute__((unused)) void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+cmd_stop_parsed(__rte_unused void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct ntb_fwd_lcore_conf *conf;
uint32_t lcore_id;
{
struct ntb_fwd_lcore_conf *conf;
uint32_t lcore_id;
static void
cmd_stats_parsed(void *parsed_result,
static void
cmd_stats_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_stats_result *res = parsed_result;
if (!strcmp(res->show, "clear"))
{
struct cmd_stats_result *res = parsed_result;
if (!strcmp(res->show, "clear"))
-cmd_set_fwd_mode_parsed(__attribute__((unused)) void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+cmd_set_fwd_mode_parsed(__rte_unused void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_fwd_mode_result *res = parsed_result;
int i;
{
struct cmd_set_fwd_mode_result *res = parsed_result;
int i;
#endif
static inline void l3fwd_simple_forward(struct rte_mbuf *m, uint16_t portid)
#endif
static inline void l3fwd_simple_forward(struct rte_mbuf *m, uint16_t portid)
- __attribute__((unused));
#if ((APP_LOOKUP_METHOD == APP_LOOKUP_EXACT_MATCH) && \
(ENABLE_MULTI_BUFFER_OPTIMIZE == 1))
#if ((APP_LOOKUP_METHOD == APP_LOOKUP_EXACT_MATCH) && \
(ENABLE_MULTI_BUFFER_OPTIMIZE == 1))
struct rte_ether_hdr *eth_hdr[8];
union ipv6_5tuple_host key[8];
struct rte_ether_hdr *eth_hdr[8];
union ipv6_5tuple_host key[8];
- __attribute__((unused)) struct rte_ipv6_hdr *ipv6_hdr[8];
+ __rte_unused struct rte_ipv6_hdr *ipv6_hdr[8];
eth_hdr[0] = rte_pktmbuf_mtod(m[0], struct rte_ether_hdr *);
eth_hdr[1] = rte_pktmbuf_mtod(m[1], struct rte_ether_hdr *);
eth_hdr[0] = rte_pktmbuf_mtod(m[0], struct rte_ether_hdr *);
eth_hdr[1] = rte_pktmbuf_mtod(m[1], struct rte_ether_hdr *);
*/
__thread pthread_t tid[HELLOW_WORLD_MAX_LTHREADS];
*/
__thread pthread_t tid[HELLOW_WORLD_MAX_LTHREADS];
-static void *initial_lthread(void *args __attribute__((unused)))
+static void *initial_lthread(void *args __rte_unused)
{
int lcore = (int) rte_lcore_id();
/*
{
int lcore = (int) rte_lcore_id();
/*
* in the core mask
*/
static int
* in the core mask
*/
static int
-lthread_scheduler(void *args __attribute__((unused)))
+lthread_scheduler(void *args __rte_unused)
{
/* create initial thread */
struct lthread *lt;
{
/* create initial thread */
struct lthread *lt;
static __attribute__((noreturn)) int
static __attribute__((noreturn)) int
-main_loop(__attribute__((unused)) void *dummy)
+main_loop(__rte_unused void *dummy)
{
uint64_t current_time, last_time = rte_rdtsc();
uint32_t lcore_id = rte_lcore_id();
{
uint64_t current_time, last_time = rte_rdtsc();
uint32_t lcore_id = rte_lcore_id();
cmdline_fixed_string_t help;
};
cmdline_fixed_string_t help;
};
-static void cmd_help_parsed(__attribute__((unused)) void *parsed_result,
+static void cmd_help_parsed(__rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
cmdline_fixed_string_t quit;
};
cmdline_fixed_string_t quit;
};
-static void cmd_quit_parsed(__attribute__((unused)) void *parsed_result,
+static void cmd_quit_parsed(__rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
};
static void cmd_setqavg_parsed(void *parsed_result,
};
static void cmd_setqavg_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_setqavg_result *res = parsed_result;
{
struct cmd_setqavg_result *res = parsed_result;
cmdline_fixed_string_t app_string;
};
cmdline_fixed_string_t app_string;
};
-static void cmd_appstats_parsed(__attribute__((unused)) void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+static void cmd_appstats_parsed(__rte_unused void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
};
static void cmd_subportstats_parsed(void *parsed_result,
};
static void cmd_subportstats_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_subportstats_result *res = parsed_result;
{
struct cmd_subportstats_result *res = parsed_result;
};
static void cmd_pipestats_parsed(void *parsed_result,
};
static void cmd_pipestats_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_pipestats_result *res = parsed_result;
{
struct cmd_pipestats_result *res = parsed_result;
};
static void cmd_avg_q_parsed(void *parsed_result,
};
static void cmd_avg_q_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_avg_q_result *res = parsed_result;
{
struct cmd_avg_q_result *res = parsed_result;
};
static void cmd_avg_tcpipe_parsed(void *parsed_result,
};
static void cmd_avg_tcpipe_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_avg_tcpipe_result *res = parsed_result;
{
struct cmd_avg_tcpipe_result *res = parsed_result;
};
static void cmd_avg_pipe_parsed(void *parsed_result,
};
static void cmd_avg_pipe_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_avg_pipe_result *res = parsed_result;
{
struct cmd_avg_pipe_result *res = parsed_result;
};
static void cmd_avg_tcsubport_parsed(void *parsed_result,
};
static void cmd_avg_tcsubport_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_avg_tcsubport_result *res = parsed_result;
{
struct cmd_avg_tcsubport_result *res = parsed_result;
};
static void cmd_avg_subport_parsed(void *parsed_result,
};
static void cmd_avg_subport_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_avg_subport_result *res = parsed_result;
{
struct cmd_avg_subport_result *res = parsed_result;
/* main processing loop */
static int
/* main processing loop */
static int
-app_main_loop(__attribute__((unused))void *dummy)
+app_main_loop(__rte_unused void *dummy)
{
uint32_t lcore_id;
uint32_t i, mode;
{
uint32_t lcore_id;
uint32_t i, mode;
* repeatedly sleeps.
*/
static int
* repeatedly sleeps.
*/
static int
-sleep_lcore(__attribute__((unused)) void *dummy)
+sleep_lcore(__rte_unused void *dummy)
{
/* Used to pick a display thread - static, so zero-initialised */
static rte_atomic32_t display_stats;
{
/* Used to pick a display thread - static, so zero-initialised */
static rte_atomic32_t display_stats;
/* timer0 callback */
static void
/* timer0 callback */
static void
-timer0_cb(__attribute__((unused)) struct rte_timer *tim,
- __attribute__((unused)) void *arg)
+timer0_cb(__rte_unused struct rte_timer *tim,
+ __rte_unused void *arg)
{
static unsigned counter = 0;
unsigned lcore_id = rte_lcore_id();
{
static unsigned counter = 0;
unsigned lcore_id = rte_lcore_id();
/* timer1 callback */
static void
/* timer1 callback */
static void
-timer1_cb(__attribute__((unused)) struct rte_timer *tim,
- __attribute__((unused)) void *arg)
+timer1_cb(__rte_unused struct rte_timer *tim,
+ __rte_unused void *arg)
{
unsigned lcore_id = rte_lcore_id();
uint64_t hz;
{
unsigned lcore_id = rte_lcore_id();
uint64_t hz;
}
static __attribute__((noreturn)) int
}
static __attribute__((noreturn)) int
-lcore_mainloop(__attribute__((unused)) void *arg)
+lcore_mainloop(__rte_unused void *arg)
{
uint64_t prev_tsc = 0, cur_tsc, diff_tsc;
unsigned lcore_id;
{
uint64_t prev_tsc = 0, cur_tsc, diff_tsc;
unsigned lcore_id;
cmdline_fixed_string_t help;
};
cmdline_fixed_string_t help;
};
-static void cmd_help_parsed(__attribute__((unused)) void *parsed_result,
+static void cmd_help_parsed(__rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
};
static void cmd_list_vdpa_devices_parsed(
};
static void cmd_list_vdpa_devices_parsed(
- __attribute__((unused)) void *parsed_result,
+ __rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
int did;
uint32_t queue_num;
{
int did;
uint32_t queue_num;
static void cmd_create_vdpa_port_parsed(void *parsed_result,
struct cmdline *cl,
static void cmd_create_vdpa_port_parsed(void *parsed_result,
struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
int did;
struct cmd_create_result *res = parsed_result;
{
int did;
struct cmd_create_result *res = parsed_result;
cmdline_fixed_string_t quit;
};
cmdline_fixed_string_t quit;
};
-static void cmd_quit_parsed(__attribute__((unused)) void *parsed_result,
+static void cmd_quit_parsed(__rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
vdpa_sample_quit();
cmdline_quit(cl);
{
vdpa_sample_quit();
cmdline_quit(cl);
int set_policy_defaults(struct channel_packet *pkt);
int set_policy_defaults(struct channel_packet *pkt);
-void run_cli(__attribute__((unused)) void *arg);
+void run_cli(__rte_unused void *arg);
-run_monitor(__attribute__((unused)) void *arg)
+run_monitor(__rte_unused void *arg)
{
if (channel_monitor_init() < 0) {
printf("Unable to initialize channel monitor\n");
{
if (channel_monitor_init() < 0) {
printf("Unable to initialize channel monitor\n");
-run_core_monitor(__attribute__((unused)) void *arg)
+run_core_monitor(__rte_unused void *arg)
{
if (branch_monitor_init() < 0) {
printf("Unable to initialize core monitor\n");
{
if (branch_monitor_init() < 0) {
printf("Unable to initialize core monitor\n");
-__attribute__((unused)) static float
-apply_policy(__attribute__((unused)) int core)
+__rte_unused static float
+apply_policy(__rte_unused int core)
-add_core_to_monitor(__attribute__((unused)) int core)
+add_core_to_monitor(__rte_unused int core)
-remove_core_from_monitor(__attribute__((unused)) int core)
+remove_core_from_monitor(__rte_unused int core)
cmdline_fixed_string_t quit;
};
cmdline_fixed_string_t quit;
};
-static void cmd_quit_parsed(__attribute__((unused)) void *parsed_result,
+static void cmd_quit_parsed(__rte_unused void *parsed_result,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
channel_monitor_exit();
channel_manager_exit();
{
channel_monitor_exit();
channel_manager_exit();
static void
cmd_show_vm_parsed(void *parsed_result, struct cmdline *cl,
static void
cmd_show_vm_parsed(void *parsed_result, struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
struct cmd_show_vm_result *res = parsed_result;
struct vm_info info;
{
struct cmd_show_vm_result *res = parsed_result;
struct vm_info info;
static void
cmd_set_pcpu_parsed(void *parsed_result, struct cmdline *cl,
static void
cmd_set_pcpu_parsed(void *parsed_result, struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
struct cmd_set_pcpu_result *res = parsed_result;
{
struct cmd_set_pcpu_result *res = parsed_result;
static void
cmd_vm_op_parsed(void *parsed_result, struct cmdline *cl,
static void
cmd_vm_op_parsed(void *parsed_result, struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
struct cmd_vm_op_result *res = parsed_result;
{
struct cmd_vm_op_result *res = parsed_result;
};
static void
cmd_channels_op_parsed(void *parsed_result, struct cmdline *cl,
};
static void
cmd_channels_op_parsed(void *parsed_result, struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
unsigned num_channels = 0, channel_num, i;
int channels_added;
{
unsigned num_channels = 0, channel_num, i;
int channels_added;
static void
cmd_channels_status_op_parsed(void *parsed_result, struct cmdline *cl,
static void
cmd_channels_status_op_parsed(void *parsed_result, struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
unsigned num_channels = 0, channel_num;
int changed;
{
unsigned num_channels = 0, channel_num;
int changed;
static void
cmd_show_cpu_freq_parsed(void *parsed_result, struct cmdline *cl,
static void
cmd_show_cpu_freq_parsed(void *parsed_result, struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
struct cmd_show_cpu_freq_result *res = parsed_result;
uint32_t curr_freq = power_manager_get_current_frequency(res->core_num);
{
struct cmd_show_cpu_freq_result *res = parsed_result;
uint32_t curr_freq = power_manager_get_current_frequency(res->core_num);
static void
cmd_set_cpu_freq_parsed(void *parsed_result, struct cmdline *cl,
static void
cmd_set_cpu_freq_parsed(void *parsed_result, struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
int ret = -1;
struct cmd_set_cpu_freq_result *res = parsed_result;
{
int ret = -1;
struct cmd_set_cpu_freq_result *res = parsed_result;
-run_cli(__attribute__((unused)) void *arg)
+run_cli(__rte_unused void *arg)
-void run_cli(__attribute__((unused)) void *arg);
+void run_cli(void *arg);
* and writing to OUTPUT_PORT
*/
static int
* and writing to OUTPUT_PORT
*/
static int
-lcore_main(__attribute__((__unused__)) void *dummy)
+lcore_main(__rte_unused void *dummy)
{
const uint16_t lcore_id = (uint16_t)rte_lcore_id();
const uint16_t num_cores = (uint16_t)rte_lcore_count();
{
const uint16_t lcore_id = (uint16_t)rte_lcore_id();
const uint16_t num_cores = (uint16_t)rte_lcore_count();
static void
cmdline_valid_buffer(struct rdline *rdl, const char *buf,
static void
cmdline_valid_buffer(struct rdline *rdl, const char *buf,
- __attribute__((unused)) unsigned int size)
+ __rte_unused unsigned int size)
{
struct cmdline *cl = rdl->opaque;
int ret;
{
struct cmdline *cl = rdl->opaque;
int ret;
-cmdline_parse_etheraddr(__attribute__((unused)) cmdline_parse_token_hdr_t *tk,
+cmdline_parse_etheraddr(__rte_unused cmdline_parse_token_hdr_t *tk,
const char *buf, void *res, unsigned ressize)
{
unsigned int token_len = 0;
const char *buf, void *res, unsigned ressize)
{
unsigned int token_len = 0;
-cmdline_get_help_etheraddr(__attribute__((unused)) cmdline_parse_token_hdr_t *tk,
+cmdline_get_help_etheraddr(__rte_unused cmdline_parse_token_hdr_t *tk,
char *dstbuf, unsigned int size)
{
int ret;
char *dstbuf, unsigned int size)
{
int ret;
-cmdline_parse_portlist(__attribute__((unused)) cmdline_parse_token_hdr_t *tk,
+cmdline_parse_portlist(__rte_unused cmdline_parse_token_hdr_t *tk,
const char *buf, void *res, unsigned ressize)
{
unsigned int token_len = 0;
const char *buf, void *res, unsigned ressize)
{
unsigned int token_len = 0;
-cmdline_get_help_portlist(__attribute__((unused)) cmdline_parse_token_hdr_t *tk,
+cmdline_get_help_portlist(__rte_unused cmdline_parse_token_hdr_t *tk,
char *dstbuf, unsigned int size)
{
int ret;
char *dstbuf, unsigned int size)
{
int ret;
-sync_func(__attribute__((unused)) void *arg)
+sync_func(__rte_unused void *arg)
/* main loop of threads */
__attribute__((noreturn)) void *
/* main loop of threads */
__attribute__((noreturn)) void *
-eal_thread_loop(__attribute__((unused)) void *arg)
+eal_thread_loop(__rte_unused void *arg)
#ifndef container_of
#define container_of(ptr, type, member) __extension__ ({ \
const typeof(((type *)0)->member) *_ptr = (ptr); \
#ifndef container_of
#define container_of(ptr, type, member) __extension__ ({ \
const typeof(((type *)0)->member) *_ptr = (ptr); \
- __attribute__((unused)) type *_target_ptr = \
+ __rte_unused type *_target_ptr = \
(type *)(ptr); \
(type *)(((uintptr_t)_ptr) - offsetof(type, member)); \
})
(type *)(ptr); \
(type *)(((uintptr_t)_ptr) - offsetof(type, member)); \
})
-sync_func(__attribute__((unused)) void *arg)
+sync_func(__rte_unused void *arg)
* default log function
*/
static ssize_t
* default log function
*/
static ssize_t
-console_log_write(__attribute__((unused)) void *c, const char *buf, size_t size)
+console_log_write(__rte_unused void *c, const char *buf, size_t size)
/* main loop of threads */
__attribute__((noreturn)) void *
/* main loop of threads */
__attribute__((noreturn)) void *
-eal_thread_loop(__attribute__((unused)) void *arg)
+eal_thread_loop(__rte_unused void *arg)
* this because hpet is 32 bits by default under linux).
*/
static void *
* this because hpet is 32 bits by default under linux).
*/
static void *
-hpet_msb_inc(__attribute__((unused)) void *arg)
+hpet_msb_inc(__rte_unused void *arg)
-pthread_join(pthread_t thread __attribute__((__unused__)),
- void **value_ptr __attribute__((__unused__)))
+pthread_join(__rte_unused pthread_t thread,
+ __rte_unused void **value_ptr)
*/
void
rte_pktmbuf_init(struct rte_mempool *mp,
*/
void
rte_pktmbuf_init(struct rte_mempool *mp,
- __attribute__((unused)) void *opaque_arg,
+ __rte_unused void *opaque_arg,
- __attribute__((unused)) unsigned i)
+ __rte_unused unsigned i)
{
struct rte_mbuf *m = _m;
uint32_t mbuf_size, buf_len, priv_size;
{
struct rte_mbuf *m = _m;
uint32_t mbuf_size, buf_len, priv_size;
__rte_pktmbuf_init_extmem(struct rte_mempool *mp,
void *opaque_arg,
void *_m,
__rte_pktmbuf_init_extmem(struct rte_mempool *mp,
void *opaque_arg,
void *_m,
- __attribute__((unused)) unsigned int i)
+ __rte_unused unsigned int i)
{
struct rte_mbuf *m = _m;
struct rte_pktmbuf_extmem_init_ctx *ctx = opaque_arg;
{
struct rte_mbuf *m = _m;
struct rte_pktmbuf_extmem_init_ctx *ctx = opaque_arg;
-power_kvm_vm_freqs(__attribute__((unused)) unsigned int lcore_id,
- __attribute__((unused)) uint32_t *freqs,
- __attribute__((unused)) uint32_t num)
+power_kvm_vm_freqs(__rte_unused unsigned int lcore_id,
+ __rte_unused uint32_t *freqs,
+ __rte_unused uint32_t num)
{
RTE_LOG(ERR, POWER, "rte_power_freqs is not implemented "
"for Virtual Machine Power Management\n");
{
RTE_LOG(ERR, POWER, "rte_power_freqs is not implemented "
"for Virtual Machine Power Management\n");
-power_kvm_vm_get_freq(__attribute__((unused)) unsigned int lcore_id)
+power_kvm_vm_get_freq(__rte_unused unsigned int lcore_id)
{
RTE_LOG(ERR, POWER, "rte_power_get_freq is not implemented "
"for Virtual Machine Power Management\n");
{
RTE_LOG(ERR, POWER, "rte_power_get_freq is not implemented "
"for Virtual Machine Power Management\n");
-power_kvm_vm_set_freq(__attribute__((unused)) unsigned int lcore_id,
- __attribute__((unused)) uint32_t index)
+power_kvm_vm_set_freq(__rte_unused unsigned int lcore_id,
+ __rte_unused uint32_t index)
{
RTE_LOG(ERR, POWER, "rte_power_set_freq is not implemented "
"for Virtual Machine Power Management\n");
{
RTE_LOG(ERR, POWER, "rte_power_set_freq is not implemented "
"for Virtual Machine Power Management\n");
-power_kvm_vm_turbo_status(__attribute__((unused)) unsigned int lcore_id)
+power_kvm_vm_turbo_status(__rte_unused unsigned int lcore_id)
{
RTE_LOG(ERR, POWER, "rte_power_turbo_status is not implemented for Virtual Machine Power Management\n");
return -ENOTSUP;
{
RTE_LOG(ERR, POWER, "rte_power_turbo_status is not implemented for Virtual Machine Power Management\n");
return -ENOTSUP;