" Set the queue priority flow control parameter on a"
" given Rx and Tx queues of a port.\n\n"
+ "set port (port_id) rxq (queue_id) avail_thresh (0..99)>\n "
+ " set available descriptors threshold for Rx queue\n\n"
+
"set stat_qmap (tx|rx) (port_id) (queue_id) (qmapping)\n"
" Set statistics mapping (qmapping 0..15) for RX/TX"
" queue on port.\n"
},
};
+/* *** set available descriptors threshold for an RxQ of a port *** */
+struct cmd_set_rxq_avail_thresh_result {
+ cmdline_fixed_string_t set;
+ cmdline_fixed_string_t port;
+ uint16_t port_num;
+ cmdline_fixed_string_t rxq;
+ uint16_t rxq_num;
+ cmdline_fixed_string_t avail_thresh;
+ uint8_t avail_thresh_num;
+};
+
+static void cmd_set_rxq_avail_thresh_parsed(void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
+{
+ struct cmd_set_rxq_avail_thresh_result *res = parsed_result;
+ int ret = 0;
+
+ if ((strcmp(res->set, "set") == 0) && (strcmp(res->port, "port") == 0)
+ && (strcmp(res->rxq, "rxq") == 0)
+ && (strcmp(res->avail_thresh, "avail_thresh") == 0))
+ ret = set_rxq_avail_thresh(res->port_num, res->rxq_num,
+ res->avail_thresh_num);
+ if (ret < 0)
+ printf("rxq_avail_thresh_cmd error: (%s)\n", strerror(-ret));
+
+}
+
+static cmdline_parse_token_string_t cmd_set_rxq_avail_thresh_set =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_rxq_avail_thresh_result,
+ set, "set");
+static cmdline_parse_token_string_t cmd_set_rxq_avail_thresh_port =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_rxq_avail_thresh_result,
+ port, "port");
+static cmdline_parse_token_num_t cmd_set_rxq_avail_thresh_portnum =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_rxq_avail_thresh_result,
+ port_num, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_rxq_avail_thresh_rxq =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_rxq_avail_thresh_result,
+ rxq, "rxq");
+static cmdline_parse_token_num_t cmd_set_rxq_avail_thresh_rxqnum =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_rxq_avail_thresh_result,
+ rxq_num, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_rxq_avail_thresh_avail_thresh =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_rxq_avail_thresh_result,
+ avail_thresh, "avail_thresh");
+static cmdline_parse_token_num_t cmd_set_rxq_avail_thresh_avail_threshnum =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_rxq_avail_thresh_result,
+ avail_thresh_num, RTE_UINT8);
+
+static cmdline_parse_inst_t cmd_set_rxq_avail_thresh = {
+ .f = cmd_set_rxq_avail_thresh_parsed,
+ .data = (void *)0,
+ .help_str =
+ "set port <port_id> rxq <queue_id> avail_thresh <0..99>: "
+ "Set available descriptors threshold for Rx queue",
+ .tokens = {
+ (void *)&cmd_set_rxq_avail_thresh_set,
+ (void *)&cmd_set_rxq_avail_thresh_port,
+ (void *)&cmd_set_rxq_avail_thresh_portnum,
+ (void *)&cmd_set_rxq_avail_thresh_rxq,
+ (void *)&cmd_set_rxq_avail_thresh_rxqnum,
+ (void *)&cmd_set_rxq_avail_thresh_avail_thresh,
+ (void *)&cmd_set_rxq_avail_thresh_avail_threshnum,
+ NULL,
+ },
+};
+
/* show port supported ptypes */
/* Common result structure for show port ptypes */
(cmdline_parse_inst_t *)&cmd_config_tx_dynf_specific,
(cmdline_parse_inst_t *)&cmd_show_fec_mode,
(cmdline_parse_inst_t *)&cmd_set_fec_mode,
+ (cmdline_parse_inst_t *)&cmd_set_rxq_avail_thresh,
(cmdline_parse_inst_t *)&cmd_show_capability,
(cmdline_parse_inst_t *)&cmd_set_flex_is_pattern,
(cmdline_parse_inst_t *)&cmd_set_flex_spec_pattern,
return diag;
}
+int
+set_rxq_avail_thresh(portid_t port_id, uint16_t queue_id, uint8_t avail_thresh)
+{
+ if (port_id_is_invalid(port_id, ENABLED_WARN))
+ return -EINVAL;
+
+ return rte_eth_rx_avail_thresh_set(port_id, queue_id, avail_thresh);
+}
+
/*
* Functions to manage the set of filtered Multicast MAC addresses.
*
[RTE_ETH_EVENT_NEW] = "device probed",
[RTE_ETH_EVENT_DESTROY] = "device released",
[RTE_ETH_EVENT_FLOW_AGED] = "flow aged",
+ [RTE_ETH_EVENT_RX_AVAIL_THRESH] = "RxQ available descriptors threshold reached",
[RTE_ETH_EVENT_MAX] = NULL,
};
ports[port_id].port_status = RTE_PORT_CLOSED;
printf("Port %u is closed\n", port_id);
break;
+ case RTE_ETH_EVENT_RX_AVAIL_THRESH: {
+ uint16_t rxq_id;
+ int ret;
+
+ /* avail_thresh query API rewinds rxq_id, no need to check max RxQ num */
+ for (rxq_id = 0; ; rxq_id++) {
+ ret = rte_eth_rx_avail_thresh_query(port_id, &rxq_id,
+ NULL);
+ if (ret <= 0)
+ break;
+ printf("Received avail_thresh event, port: %u, rxq_id: %u\n",
+ port_id, rxq_id);
+ }
+ break;
+ }
default:
break;
}
int set_vf_rate_limit(portid_t port_id, uint16_t vf, uint16_t rate,
uint64_t q_msk);
+int set_rxq_avail_thresh(portid_t port_id, uint16_t queue_id,
+ uint8_t avail_thresh);
+
void port_rss_hash_conf_show(portid_t port_id, int show_rss_key);
void port_rss_hash_key_update(portid_t port_id, char rss_type[],
uint8_t *hash_key, uint8_t hash_key_len);
; Temporary exceptions till next major ABI version ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; Ignore ethdev event enum update
+; because new event cannot be received if not registered
+[suppress_type]
+ type_kind = enum
+ changed_enumerators = RTE_ETH_EVENT_MAX
+
+; Ignore fields inserted in cacheline boundary of rte_eth_rxq_info
+; because the struct size is unchanged
+[suppress_type]
+ name = rte_eth_rxq_info
+ has_data_member_inserted_between = {offset_of(rx_buf_size), end}
+
; Ignore fields inserted in place of reserved_opts of rte_security_ipsec_sa_options
[suppress_type]
name = rte_security_ipsec_sa_options
and updated ``struct rte_mtr_params`` and ``struct rte_mtr_capabilities`` to
support protocol based input color selection for meter.
+* **Added Rx queue available descriptors threshold and event.**
+
+ Added ethdev API and corresponding driver operations to set Rx queue
+ available descriptors threshold and query for queues with reached
+ threshold when a new event ``RTE_ETH_EVENT_RX_AVAIL_THRESH`` is received.
+
* **Added telemetry for module EEPROM.**
Added telemetry command to dump module EEPROM.
* ``pause_time`` (integer): Pause quanta filled in the PFC frame for which
interval, remote Tx will be paused. Valid only if Tx pause is on.
+Set Rx queue available descriptors threshold
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Set available descriptors threshold for a specific Rx queue of port::
+
+ testpmd> set port (port_id) rxq (queue_id) avail_thresh (0..99)
+
+Use 0 value to disable the threshold and corresponding event.
+
set stat_qmap
~~~~~~~~~~~~~
*/
typedef int (*eth_dev_priv_dump_t)(struct rte_eth_dev *dev, FILE *file);
+/**
+ * @internal Set Rx queue available descriptors threshold.
+ * @see rte_eth_rx_avail_thresh_set()
+ *
+ * Driver should round down number of descriptors on conversion from
+ * percentage.
+ */
+typedef int (*eth_rx_queue_avail_thresh_set_t)(struct rte_eth_dev *dev,
+ uint16_t rx_queue_id,
+ uint8_t avail_thresh);
+
+/**
+ * @internal Query Rx queue available descriptors threshold event.
+ * @see rte_eth_rx_avail_thresh_query()
+ */
+
+typedef int (*eth_rx_queue_avail_thresh_query_t)(struct rte_eth_dev *dev,
+ uint16_t *rx_queue_id,
+ uint8_t *avail_thresh);
+
/**
* @internal A structure containing the functions exported by an Ethernet driver.
*/
/** Dump private info from device */
eth_dev_priv_dump_t eth_dev_priv_dump;
+
+ /** Set Rx queue available descriptors threshold */
+ eth_rx_queue_avail_thresh_set_t rx_queue_avail_thresh_set;
+ /** Query Rx queue available descriptors threshold event */
+ eth_rx_queue_avail_thresh_query_t rx_queue_avail_thresh_query;
};
/**
queue_idx, tx_rate));
}
+int rte_eth_rx_avail_thresh_set(uint16_t port_id, uint16_t queue_id,
+ uint8_t avail_thresh)
+{
+ struct rte_eth_dev *dev;
+
+ RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
+ dev = &rte_eth_devices[port_id];
+
+ if (queue_id > dev->data->nb_rx_queues) {
+ RTE_ETHDEV_LOG(ERR,
+ "Set queue avail thresh: port %u: invalid queue ID=%u.\n",
+ port_id, queue_id);
+ return -EINVAL;
+ }
+
+ if (avail_thresh > 99) {
+ RTE_ETHDEV_LOG(ERR,
+ "Set queue avail thresh: port %u: threshold should be <= 99.\n",
+ port_id);
+ return -EINVAL;
+ }
+ RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->rx_queue_avail_thresh_set, -ENOTSUP);
+ return eth_err(port_id, (*dev->dev_ops->rx_queue_avail_thresh_set)(dev,
+ queue_id, avail_thresh));
+}
+
+int rte_eth_rx_avail_thresh_query(uint16_t port_id, uint16_t *queue_id,
+ uint8_t *avail_thresh)
+{
+ struct rte_eth_dev *dev;
+
+ RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
+ dev = &rte_eth_devices[port_id];
+
+ if (queue_id == NULL)
+ return -EINVAL;
+ if (*queue_id >= dev->data->nb_rx_queues)
+ *queue_id = 0;
+
+ RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->rx_queue_avail_thresh_query, -ENOTSUP);
+ return eth_err(port_id, (*dev->dev_ops->rx_queue_avail_thresh_query)(dev,
+ queue_id, avail_thresh));
+}
+
RTE_INIT(eth_dev_init_fp_ops)
{
uint32_t i;
uint8_t queue_state; /**< one of RTE_ETH_QUEUE_STATE_*. */
uint16_t nb_desc; /**< configured number of RXDs. */
uint16_t rx_buf_size; /**< hardware receive buffer size. */
+ /**
+ * Available Rx descriptors threshold defined as percentage
+ * of Rx queue size. If number of available descriptors is lower,
+ * the event RTE_ETH_EVENT_RX_AVAIL_THESH is generated.
+ * Value 0 means that the threshold monitoring is disabled.
+ */
+ uint8_t avail_thresh;
} __rte_cache_min_aligned;
/**
*/
int rte_eth_dev_set_vlan_pvid(uint16_t port_id, uint16_t pvid, int on);
+/**
+ * @warning
+ * @b EXPERIMENTAL: this API may change without prior notice.
+ *
+ * Set Rx queue available descriptors threshold.
+ *
+ * @param port_id
+ * The port identifier of the Ethernet device.
+ * @param queue_id
+ * The index of the receive queue.
+ * @param avail_thresh
+ * The available descriptors threshold is percentage of Rx queue size
+ * which describes the availability of Rx queue for hardware.
+ * If the Rx queue availability is below it,
+ * the event RTE_ETH_EVENT_RX_AVAIL_THRESH is triggered.
+ * [1-99] to set a new available descriptors threshold.
+ * 0 to disable threshold monitoring.
+ *
+ * @return
+ * - 0 if successful.
+ * - (-ENODEV) if @p port_id is invalid.
+ * - (-EINVAL) if bad parameter.
+ * - (-ENOTSUP) if available Rx descriptors threshold is not supported.
+ * - (-EIO) if device is removed.
+ */
+__rte_experimental
+int rte_eth_rx_avail_thresh_set(uint16_t port_id, uint16_t queue_id,
+ uint8_t avail_thresh);
+
+/**
+ * @warning
+ * @b EXPERIMENTAL: this API may change without prior notice.
+ *
+ * Find Rx queue with RTE_ETH_EVENT_RX_AVAIL_THRESH event pending.
+ *
+ * @param port_id
+ * The port identifier of the Ethernet device.
+ * @param[inout] queue_id
+ * On input starting Rx queue index to search from.
+ * If the queue_id is bigger than maximum queue ID of the port,
+ * search is started from 0. So that application can keep calling
+ * this function to handle all pending events with a simple increment
+ * of queue_id on the next call.
+ * On output if return value is 1, Rx queue index with the event pending.
+ * @param[out] avail_thresh
+ * Location for available descriptors threshold of the found Rx queue.
+ *
+ * @return
+ * - 1 if an Rx queue with pending event is found.
+ * - 0 if no Rx queue with pending event is found.
+ * - (-ENODEV) if @p port_id is invalid.
+ * - (-EINVAL) if bad parameter (e.g. @p queue_id is NULL).
+ * - (-ENOTSUP) if operation is not supported.
+ * - (-EIO) if device is removed.
+ */
+__rte_experimental
+int rte_eth_rx_avail_thresh_query(uint16_t port_id, uint16_t *queue_id,
+ uint8_t *avail_thresh);
+
typedef void (*buffer_tx_error_fn)(struct rte_mbuf **unsent, uint16_t count,
void *userdata);
RTE_ETH_EVENT_DESTROY, /**< port is released */
RTE_ETH_EVENT_IPSEC, /**< IPsec offload related event */
RTE_ETH_EVENT_FLOW_AGED,/**< New aged-out flows is detected */
+ /**
+ * Number of available Rx descriptors is smaller than the threshold.
+ * @see rte_eth_rx_avail_thresh_set()
+ */
+ RTE_ETH_EVENT_RX_AVAIL_THRESH,
RTE_ETH_EVENT_MAX /**< max value of this enum */
};
rte_flow_async_action_handle_update;
# added in 22.07
+ rte_eth_rx_avail_thresh_query;
+ rte_eth_rx_avail_thresh_set;
rte_mtr_color_in_protocol_get;
rte_mtr_color_in_protocol_priority_get;
rte_mtr_color_in_protocol_set;
git.droids-corp.org / dpdk.git / commitdiff