* [PATCH v2 4/6] net/gve: add periodic NIC clock synchronization
From: Mark Blasko @ 2026-05-15 23:19 UTC (permalink / raw)
To: stephen; +Cc: dev, Mark Blasko, Joshua Washington, Jasper Tran O'Leary
In-Reply-To: <20260515231936.3296603-1-blasko@google.com>
Introduce a mechanism to periodically fetch the NIC hardware timestamp
using the GVE_ADMINQ_REPORT_NIC_TIMESTAMP AdminQ command. The
synchronization runs every 250ms using rte_alarm. If the read fails,
the alarm is still rescheduled. After 7 consecutive failures, the
timestamp is marked as stale, indicating to the RX path that
reconstructed timestamps may be unreliable.
Atomics exist because of the potential for async callers (introduced
here) and async callers (introduced later in the RX datapath) accessing
the cached state.
Signed-off-by: Mark Blasko <blasko@google.com>
Reviewed-by: Joshua Washington <joshwash@google.com>
Reviewed-by: Jasper Tran O'Leary <jtranoleary@google.com>
---
v2:
- Removed redundant void* casts.
- Handled alarm reschedule failures by marking timestamp stale.
- Added transient error logging on memzone allocation failure.
---
drivers/net/gve/gve_ethdev.c | 106 +++++++++++++++++++++++++++++++++++
drivers/net/gve/gve_ethdev.h | 9 +++
2 files changed, 115 insertions(+)
diff --git a/drivers/net/gve/gve_ethdev.c b/drivers/net/gve/gve_ethdev.c
index a9e2063dda..ee21fb3ec4 100644
--- a/drivers/net/gve/gve_ethdev.c
+++ b/drivers/net/gve/gve_ethdev.c
@@ -452,6 +452,86 @@ gve_dev_start(struct rte_eth_dev *dev)
return 0;
}
+static void
+gve_read_nic_clock(void *arg)
+{
+ struct gve_priv *priv = arg;
+ uint32_t fails;
+ uint64_t ts;
+ int err;
+
+ if (!priv || !priv->nic_ts_report_mz)
+ return;
+
+ memset(priv->nic_ts_report, 0, sizeof(struct gve_nic_ts_report));
+
+ err = gve_adminq_report_nic_timestamp(priv, priv->nic_ts_report_mz->iova);
+ if (err == 0) {
+ ts = be64_to_cpu(priv->nic_ts_report->nic_timestamp);
+ rte_atomic_store_explicit(&priv->last_read_nic_timestamp, ts,
+ rte_memory_order_relaxed);
+ PMD_DRV_LOG(DEBUG, "Fetched NIC Timestamp: %" PRIu64, ts);
+ rte_atomic_store_explicit(&priv->nic_ts_read_fails, 0,
+ rte_memory_order_relaxed);
+ rte_atomic_store_explicit(&priv->nic_ts_stale, 0,
+ rte_memory_order_release);
+ } else {
+ PMD_DRV_LOG(ERR, "Failed to read NIC clock, AQ err: %d", err);
+ fails = rte_atomic_fetch_add_explicit(&priv->nic_ts_read_fails, 1,
+ rte_memory_order_relaxed) + 1;
+ if (fails >= GVE_NIC_CLOCK_READ_MAX_FAILS) {
+ if (!rte_atomic_load_explicit(&priv->nic_ts_stale,
+ rte_memory_order_relaxed))
+ PMD_DRV_LOG(ERR,
+ "NIC timestamping marked as stale after %u consecutive failures",
+ GVE_NIC_CLOCK_READ_MAX_FAILS);
+ rte_atomic_store_explicit(&priv->nic_ts_stale, 1,
+ rte_memory_order_release);
+ }
+ }
+
+ /* Reschedule the alarm for the next interval */
+ if (priv->nic_ts_report_mz) {
+ err = rte_eal_alarm_set(GVE_NIC_CLOCK_READ_PERIOD_MS * 1000,
+ gve_read_nic_clock, priv);
+ if (err < 0) {
+ PMD_DRV_LOG(ERR, "Failed to reschedule NIC clock read alarm, ret=%d", err);
+ rte_atomic_store_explicit(&priv->nic_ts_stale, 1,
+ rte_memory_order_release);
+ }
+ }
+}
+
+static int
+gve_alloc_nic_ts_report(struct gve_priv *priv)
+{
+ char z_name[RTE_MEMZONE_NAMESIZE];
+
+ snprintf(z_name, sizeof(z_name), "gve_%s_nic_ts_report",
+ priv->pci_dev->device.name);
+ priv->nic_ts_report_mz = rte_memzone_reserve_aligned(z_name,
+ sizeof(struct gve_nic_ts_report), rte_socket_id(),
+ RTE_MEMZONE_IOVA_CONTIG, PAGE_SIZE);
+
+ if (!priv->nic_ts_report_mz) {
+ PMD_DRV_LOG(ERR, "Failed to allocate memzone for NIC TS report");
+ return -ENOMEM;
+ }
+ priv->nic_ts_report = priv->nic_ts_report_mz->addr;
+ rte_atomic_store_explicit(&priv->nic_ts_read_fails, 0, rte_memory_order_relaxed);
+ return 0;
+}
+
+static void
+gve_free_nic_ts_report(struct gve_priv *priv)
+{
+ if (priv->nic_ts_report_mz) {
+ rte_memzone_free(priv->nic_ts_report_mz);
+ priv->nic_ts_report_mz = NULL;
+ priv->nic_ts_report = NULL;
+ }
+}
+
static int
gve_dev_stop(struct rte_eth_dev *dev)
{
@@ -576,6 +656,7 @@ static void
gve_teardown_device_resources(struct gve_priv *priv)
{
int err;
+ int ret;
/* Tell device its resources are being freed */
if (gve_get_device_resources_ok(priv)) {
@@ -586,6 +667,13 @@ gve_teardown_device_resources(struct gve_priv *priv)
err);
}
+ if (priv->nic_ts_report_mz) {
+ ret = rte_eal_alarm_cancel(gve_read_nic_clock, priv);
+ if (ret < 0)
+ PMD_DRV_LOG(ERR, "Failed to cancel NIC clock sync alarm, ret=%d", ret);
+ gve_free_nic_ts_report(priv);
+ }
+
gve_free_ptype_lut_dqo(priv);
gve_free_counter_array(priv);
gve_free_irq_db(priv);
@@ -1252,6 +1340,23 @@ pci_dev_msix_vec_count(struct rte_pci_device *pdev)
return 0;
}
+static void
+gve_setup_nic_timestamp(struct gve_priv *priv)
+{
+ int err;
+
+ if (!priv->nic_timestamp_supported)
+ return;
+
+ rte_atomic_store_explicit(&priv->nic_ts_read_fails, 0, rte_memory_order_relaxed);
+ rte_atomic_store_explicit(&priv->nic_ts_stale, 1, rte_memory_order_relaxed);
+ err = gve_alloc_nic_ts_report(priv);
+ if (err == 0)
+ gve_read_nic_clock(priv);
+ else
+ PMD_DRV_LOG(ERR, "Failed to allocate memory for NIC timestamping subsystem. Please reset device to retry.");
+}
+
static int
gve_setup_device_resources(struct gve_priv *priv)
{
@@ -1307,6 +1412,7 @@ gve_setup_device_resources(struct gve_priv *priv)
goto free_ptype_lut;
}
}
+ gve_setup_nic_timestamp(priv);
gve_set_device_resources_ok(priv);
diff --git a/drivers/net/gve/gve_ethdev.h b/drivers/net/gve/gve_ethdev.h
index b67f82c263..7e6f24e910 100644
--- a/drivers/net/gve/gve_ethdev.h
+++ b/drivers/net/gve/gve_ethdev.h
@@ -12,6 +12,7 @@
#include <rte_pci.h>
#include <pthread.h>
#include <rte_bitmap.h>
+#include <rte_memzone.h>
#include "base/gve.h"
@@ -39,6 +40,9 @@
#define GVE_RSS_HASH_KEY_SIZE 40
#define GVE_RSS_INDIR_SIZE 128
+#define GVE_NIC_CLOCK_READ_PERIOD_MS 250
+#define GVE_NIC_CLOCK_READ_MAX_FAILS 7
+
#define GVE_TX_CKSUM_OFFLOAD_MASK ( \
RTE_MBUF_F_TX_L4_MASK | \
RTE_MBUF_F_TX_TCP_SEG)
@@ -359,6 +363,11 @@ struct gve_priv {
/* HW Timestamping Fields */
bool nic_timestamp_supported;
+ const struct rte_memzone *nic_ts_report_mz;
+ struct gve_nic_ts_report *nic_ts_report;
+ RTE_ATOMIC(uint64_t) last_read_nic_timestamp;
+ RTE_ATOMIC(uint32_t) nic_ts_read_fails;
+ RTE_ATOMIC(uint8_t) nic_ts_stale;
};
static inline bool
--
2.54.0.563.g4f69b47b94-goog
^ permalink raw reply related
* [PATCH v2 3/6] net/gve: add AdminQ command for NIC timestamps
From: Mark Blasko @ 2026-05-15 23:19 UTC (permalink / raw)
To: stephen; +Cc: dev, Mark Blasko, Joshua Washington, Jasper Tran O'Leary
In-Reply-To: <20260515231936.3296603-1-blasko@google.com>
Introduce the necessary definitions and functions for the
GVE_ADMINQ_REPORT_NIC_TIMESTAMP AdminQ command.
Signed-off-by: Mark Blasko <blasko@google.com>
Reviewed-by: Joshua Washington <joshwash@google.com>
Reviewed-by: Jasper Tran O'Leary <jtranoleary@google.com>
---
v2:
- Added adminq timestamp counter reset to gve_adminq_alloc.
---
drivers/net/gve/base/gve_adminq.c | 20 ++++++++++++++++++++
drivers/net/gve/base/gve_adminq.h | 20 ++++++++++++++++++++
drivers/net/gve/gve_ethdev.h | 1 +
3 files changed, 41 insertions(+)
diff --git a/drivers/net/gve/base/gve_adminq.c b/drivers/net/gve/base/gve_adminq.c
index 1ced1e442e..2b25c7f390 100644
--- a/drivers/net/gve/base/gve_adminq.c
+++ b/drivers/net/gve/base/gve_adminq.c
@@ -263,6 +263,8 @@ int gve_adminq_alloc(struct gve_priv *priv)
priv->adminq_get_ptype_map_cnt = 0;
priv->adminq_cfg_flow_rule_cnt = 0;
+ priv->adminq_report_nic_timestamp_cnt = 0;
+
pthread_mutexattr_init(&mutexattr);
pthread_mutexattr_setpshared(&mutexattr, PTHREAD_PROCESS_SHARED);
pthread_mutex_init(&priv->adminq_lock, &mutexattr);
@@ -522,6 +524,10 @@ static int gve_adminq_issue_cmd(struct gve_priv *priv,
case GVE_ADMINQ_CONFIGURE_FLOW_RULE:
priv->adminq_cfg_flow_rule_cnt++;
break;
+ case GVE_ADMINQ_REPORT_NIC_TIMESTAMP:
+ priv->adminq_report_nic_timestamp_cnt++;
+ break;
+
default:
PMD_DRV_LOG(ERR, "unknown AQ command opcode %d", opcode);
}
@@ -636,6 +642,20 @@ int gve_adminq_reset_flow_rules(struct gve_priv *priv)
return gve_adminq_configure_flow_rule(priv, &flow_rule_cmd);
}
+int gve_adminq_report_nic_timestamp(struct gve_priv *priv, dma_addr_t nic_ts_report_addr)
+{
+ union gve_adminq_command cmd;
+
+ memset(&cmd, 0, sizeof(cmd));
+ cmd.opcode = cpu_to_be32(GVE_ADMINQ_REPORT_NIC_TIMESTAMP);
+ cmd.report_nic_timestamp = (struct gve_adminq_report_nic_timestamp) {
+ .nic_ts_report_len = cpu_to_be64(sizeof(struct gve_nic_ts_report)),
+ .nic_timestamp_addr = cpu_to_be64(nic_ts_report_addr),
+ };
+
+ return gve_adminq_execute_cmd(priv, &cmd);
+}
+
/* The device specifies that the management vector can either be the first irq
* or the last irq. ntfy_blk_msix_base_idx indicates the first irq assigned to
* the ntfy blks. It if is 0 then the management vector is last, if it is 1 then
diff --git a/drivers/net/gve/base/gve_adminq.h b/drivers/net/gve/base/gve_adminq.h
index eaee5649f2..954be39fbf 100644
--- a/drivers/net/gve/base/gve_adminq.h
+++ b/drivers/net/gve/base/gve_adminq.h
@@ -26,6 +26,7 @@ enum gve_adminq_opcodes {
GVE_ADMINQ_REPORT_LINK_SPEED = 0xD,
GVE_ADMINQ_GET_PTYPE_MAP = 0xE,
GVE_ADMINQ_VERIFY_DRIVER_COMPATIBILITY = 0xF,
+ GVE_ADMINQ_REPORT_NIC_TIMESTAMP = 0x11,
/* For commands that are larger than 56 bytes */
GVE_ADMINQ_EXTENDED_COMMAND = 0xFF,
};
@@ -373,6 +374,23 @@ struct gve_stats_report {
GVE_CHECK_STRUCT_LEN(8, gve_stats_report);
+struct gve_adminq_report_nic_timestamp {
+ __be64 nic_ts_report_len;
+ __be64 nic_timestamp_addr;
+};
+
+GVE_CHECK_STRUCT_LEN(16, gve_adminq_report_nic_timestamp);
+
+struct gve_nic_ts_report {
+ __be64 nic_timestamp; /* NIC clock in nanoseconds */
+ __be64 pre_cycles; /* System cycle counter before NIC clock read */
+ __be64 post_cycles; /* System cycle counter after NIC clock read */
+ __be64 reserved3;
+ __be64 reserved4;
+};
+
+GVE_CHECK_STRUCT_LEN(40, gve_nic_ts_report);
+
/* Numbers of gve tx/rx stats in stats report. */
#define GVE_TX_STATS_REPORT_NUM 6
#define GVE_RX_STATS_REPORT_NUM 2
@@ -490,6 +508,7 @@ union gve_adminq_command {
struct gve_adminq_verify_driver_compatibility
verify_driver_compatibility;
struct gve_adminq_extended_command extended_command;
+ struct gve_adminq_report_nic_timestamp report_nic_timestamp;
};
};
u8 reserved[64];
@@ -537,5 +556,6 @@ int gve_adminq_add_flow_rule(struct gve_priv *priv,
struct gve_flow_rule_params *rule, u32 loc);
int gve_adminq_del_flow_rule(struct gve_priv *priv, u32 loc);
int gve_adminq_reset_flow_rules(struct gve_priv *priv);
+int gve_adminq_report_nic_timestamp(struct gve_priv *priv, dma_addr_t nic_ts_report_addr);
#endif /* _GVE_ADMINQ_H */
diff --git a/drivers/net/gve/gve_ethdev.h b/drivers/net/gve/gve_ethdev.h
index b9b4688367..b67f82c263 100644
--- a/drivers/net/gve/gve_ethdev.h
+++ b/drivers/net/gve/gve_ethdev.h
@@ -328,6 +328,7 @@ struct gve_priv {
uint32_t adminq_get_ptype_map_cnt;
uint32_t adminq_verify_driver_compatibility_cnt;
uint32_t adminq_cfg_flow_rule_cnt;
+ uint32_t adminq_report_nic_timestamp_cnt;
volatile uint32_t state_flags;
/* Gvnic device link speed from hypervisor. */
--
2.54.0.563.g4f69b47b94-goog
^ permalink raw reply related
* [PATCH v2 2/6] net/gve: add device option support for HW timestamps
From: Mark Blasko @ 2026-05-15 23:19 UTC (permalink / raw)
To: stephen; +Cc: dev, Mark Blasko, Joshua Washington, Jasper Tran O'Leary
In-Reply-To: <20260515231936.3296603-1-blasko@google.com>
Introduce the necessary definitions and functions for the device
option flag (GVE_DEV_OPT_ID_NIC_TIMESTAMP) to detect hardware
timestamping support in the gvnic device.
Signed-off-by: Mark Blasko <blasko@google.com>
Reviewed-by: Joshua Washington <joshwash@google.com>
Reviewed-by: Jasper Tran O'Leary <jtranoleary@google.com>
---
drivers/net/gve/base/gve_adminq.c | 41 ++++++++++++++++++++++++++-----
drivers/net/gve/base/gve_adminq.h | 9 +++++++
drivers/net/gve/gve_ethdev.h | 3 +++
3 files changed, 47 insertions(+), 6 deletions(-)
diff --git a/drivers/net/gve/base/gve_adminq.c b/drivers/net/gve/base/gve_adminq.c
index 743ab8e7ae..1ced1e442e 100644
--- a/drivers/net/gve/base/gve_adminq.c
+++ b/drivers/net/gve/base/gve_adminq.c
@@ -38,7 +38,8 @@ void gve_parse_device_option(struct gve_priv *priv,
struct gve_device_option_dqo_rda **dev_op_dqo_rda,
struct gve_device_option_flow_steering **dev_op_flow_steering,
struct gve_device_option_modify_ring **dev_op_modify_ring,
- struct gve_device_option_jumbo_frames **dev_op_jumbo_frames)
+ struct gve_device_option_jumbo_frames **dev_op_jumbo_frames,
+ struct gve_device_option_nic_timestamp **dev_op_nic_timestamp)
{
u32 req_feat_mask = be32_to_cpu(option->required_features_mask);
u16 option_length = be16_to_cpu(option->option_length);
@@ -168,6 +169,24 @@ void gve_parse_device_option(struct gve_priv *priv,
}
*dev_op_jumbo_frames = RTE_PTR_ADD(option, sizeof(*option));
break;
+ case GVE_DEV_OPT_ID_NIC_TIMESTAMP:
+ if (option_length < sizeof(**dev_op_nic_timestamp) ||
+ req_feat_mask != GVE_DEV_OPT_REQ_FEAT_MASK_NIC_TIMESTAMP) {
+ PMD_DRV_LOG(WARNING, GVE_DEVICE_OPTION_ERROR_FMT,
+ "Nic Timestamp",
+ (int)sizeof(**dev_op_nic_timestamp),
+ GVE_DEV_OPT_REQ_FEAT_MASK_NIC_TIMESTAMP,
+ option_length, req_feat_mask);
+ break;
+ }
+
+ if (option_length > sizeof(**dev_op_nic_timestamp)) {
+ PMD_DRV_LOG(WARNING,
+ GVE_DEVICE_OPTION_TOO_BIG_FMT,
+ "Nic Timestamp");
+ }
+ *dev_op_nic_timestamp = RTE_PTR_ADD(option, sizeof(*option));
+ break;
default:
/* If we don't recognize the option just continue
* without doing anything.
@@ -186,7 +205,8 @@ gve_process_device_options(struct gve_priv *priv,
struct gve_device_option_dqo_rda **dev_op_dqo_rda,
struct gve_device_option_flow_steering **dev_op_flow_steering,
struct gve_device_option_modify_ring **dev_op_modify_ring,
- struct gve_device_option_jumbo_frames **dev_op_jumbo_frames)
+ struct gve_device_option_jumbo_frames **dev_op_jumbo_frames,
+ struct gve_device_option_nic_timestamp **dev_op_nic_timestamp)
{
const int num_options = be16_to_cpu(descriptor->num_device_options);
struct gve_device_option *dev_opt;
@@ -207,7 +227,8 @@ gve_process_device_options(struct gve_priv *priv,
gve_parse_device_option(priv, dev_opt,
dev_op_gqi_rda, dev_op_gqi_qpl,
dev_op_dqo_rda, dev_op_flow_steering,
- dev_op_modify_ring, dev_op_jumbo_frames);
+ dev_op_modify_ring, dev_op_jumbo_frames,
+ dev_op_nic_timestamp);
dev_opt = next_opt;
}
@@ -920,7 +941,8 @@ static void gve_enable_supported_features(struct gve_priv *priv,
u32 supported_features_mask,
const struct gve_device_option_flow_steering *dev_op_flow_steering,
const struct gve_device_option_modify_ring *dev_op_modify_ring,
- const struct gve_device_option_jumbo_frames *dev_op_jumbo_frames)
+ const struct gve_device_option_jumbo_frames *dev_op_jumbo_frames,
+ const struct gve_device_option_nic_timestamp *dev_op_nic_timestamp)
{
if (dev_op_flow_steering &&
(supported_features_mask & GVE_SUP_FLOW_STEERING_MASK) &&
@@ -947,6 +969,11 @@ static void gve_enable_supported_features(struct gve_priv *priv,
PMD_DRV_LOG(INFO, "JUMBO FRAMES device option enabled.");
priv->max_mtu = be16_to_cpu(dev_op_jumbo_frames->max_mtu);
}
+ if (dev_op_nic_timestamp &&
+ (supported_features_mask & GVE_SUP_NIC_TIMESTAMP_MASK)) {
+ PMD_DRV_LOG(INFO, "NIC TIMESTAMP device option enabled.");
+ priv->nic_timestamp_supported = true;
+ }
}
int gve_adminq_describe_device(struct gve_priv *priv)
@@ -954,6 +981,7 @@ int gve_adminq_describe_device(struct gve_priv *priv)
struct gve_device_option_jumbo_frames *dev_op_jumbo_frames = NULL;
struct gve_device_option_modify_ring *dev_op_modify_ring = NULL;
struct gve_device_option_flow_steering *dev_op_flow_steering = NULL;
+ struct gve_device_option_nic_timestamp *dev_op_nic_timestamp = NULL;
struct gve_device_option_gqi_rda *dev_op_gqi_rda = NULL;
struct gve_device_option_gqi_qpl *dev_op_gqi_qpl = NULL;
struct gve_device_option_dqo_rda *dev_op_dqo_rda = NULL;
@@ -983,7 +1011,8 @@ int gve_adminq_describe_device(struct gve_priv *priv)
&dev_op_gqi_qpl, &dev_op_dqo_rda,
&dev_op_flow_steering,
&dev_op_modify_ring,
- &dev_op_jumbo_frames);
+ &dev_op_jumbo_frames,
+ &dev_op_nic_timestamp);
if (err)
goto free_device_descriptor;
@@ -1038,7 +1067,7 @@ int gve_adminq_describe_device(struct gve_priv *priv)
gve_enable_supported_features(priv, supported_features_mask,
dev_op_flow_steering, dev_op_modify_ring,
- dev_op_jumbo_frames);
+ dev_op_jumbo_frames, dev_op_nic_timestamp);
free_device_descriptor:
gve_free_dma_mem(&descriptor_dma_mem);
diff --git a/drivers/net/gve/base/gve_adminq.h b/drivers/net/gve/base/gve_adminq.h
index d8e5e6a352..eaee5649f2 100644
--- a/drivers/net/gve/base/gve_adminq.h
+++ b/drivers/net/gve/base/gve_adminq.h
@@ -153,6 +153,12 @@ struct gve_device_option_jumbo_frames {
GVE_CHECK_STRUCT_LEN(8, gve_device_option_jumbo_frames);
+struct gve_device_option_nic_timestamp {
+ __be32 supported_features_mask;
+};
+
+GVE_CHECK_STRUCT_LEN(4, gve_device_option_nic_timestamp);
+
/* Terminology:
*
* RDA - Raw DMA Addressing - Buffers associated with SKBs are directly DMA
@@ -169,6 +175,7 @@ enum gve_dev_opt_id {
GVE_DEV_OPT_ID_MODIFY_RING = 0x6,
GVE_DEV_OPT_ID_JUMBO_FRAMES = 0x8,
GVE_DEV_OPT_ID_FLOW_STEERING = 0xb,
+ GVE_DEV_OPT_ID_NIC_TIMESTAMP = 0xd,
};
enum gve_dev_opt_req_feat_mask {
@@ -179,12 +186,14 @@ enum gve_dev_opt_req_feat_mask {
GVE_DEV_OPT_REQ_FEAT_MASK_FLOW_STEERING = 0x0,
GVE_DEV_OPT_REQ_FEAT_MASK_MODIFY_RING = 0x0,
GVE_DEV_OPT_REQ_FEAT_MASK_JUMBO_FRAMES = 0x0,
+ GVE_DEV_OPT_REQ_FEAT_MASK_NIC_TIMESTAMP = 0x0,
};
enum gve_sup_feature_mask {
GVE_SUP_MODIFY_RING_MASK = 1 << 0,
GVE_SUP_JUMBO_FRAMES_MASK = 1 << 2,
GVE_SUP_FLOW_STEERING_MASK = 1 << 5,
+ GVE_SUP_NIC_TIMESTAMP_MASK = 1 << 8,
};
#define GVE_DEV_OPT_LEN_GQI_RAW_ADDRESSING 0x0
diff --git a/drivers/net/gve/gve_ethdev.h b/drivers/net/gve/gve_ethdev.h
index 524e48e723..b9b4688367 100644
--- a/drivers/net/gve/gve_ethdev.h
+++ b/drivers/net/gve/gve_ethdev.h
@@ -355,6 +355,9 @@ struct gve_priv {
void *avail_flow_rule_bmp_mem; /* Backing memory for the bitmap */
pthread_mutex_t flow_rule_lock; /* Lock for bitmap and tailq access */
TAILQ_HEAD(, gve_flow) active_flows;
+
+ /* HW Timestamping Fields */
+ bool nic_timestamp_supported;
};
static inline bool
--
2.54.0.563.g4f69b47b94-goog
^ permalink raw reply related
* [PATCH v2 1/6] net/gve: add thread safety to admin queue
From: Mark Blasko @ 2026-05-15 23:19 UTC (permalink / raw)
To: stephen; +Cc: dev, Mark Blasko, Joshua Washington, Jasper Tran O'Leary
In-Reply-To: <20260515231936.3296603-1-blasko@google.com>
Introduce a pthread_mutex to protect the admin queue operations.
Locking was added around gve_adminq_execute_cmd and the batch
queue creation/destruction functions.
Signed-off-by: Mark Blasko <blasko@google.com>
Reviewed-by: Joshua Washington <joshwash@google.com>
Reviewed-by: Jasper Tran O'Leary <jtranoleary@google.com>
---
v2:
- Dropped ROBUST mutex attribute.
---
.mailmap | 1 +
drivers/net/gve/base/gve_adminq.c | 67 +++++++++++++++++++++++++------
drivers/net/gve/gve_ethdev.h | 1 +
3 files changed, 56 insertions(+), 13 deletions(-)
diff --git a/.mailmap b/.mailmap
index 3ab7364668..7f7590866b 100644
--- a/.mailmap
+++ b/.mailmap
@@ -1009,6 +1009,7 @@ Mario Carrillo <mario.alfredo.c.arevalo@intel.com>
Mário Kuka <kuka@cesnet.cz>
Mariusz Drost <mariuszx.drost@intel.com>
Mark Asselstine <mark.asselstine@windriver.com>
+Mark Blasko <blasko@google.com>
Mark Bloch <mbloch@nvidia.com> <markb@mellanox.com>
Mark Gillott <mgillott@vyatta.att-mail.com>
Mark Kavanagh <mark.b.kavanagh@intel.com>
diff --git a/drivers/net/gve/base/gve_adminq.c b/drivers/net/gve/base/gve_adminq.c
index 9c5316fb00..743ab8e7ae 100644
--- a/drivers/net/gve/base/gve_adminq.c
+++ b/drivers/net/gve/base/gve_adminq.c
@@ -216,6 +216,7 @@ gve_process_device_options(struct gve_priv *priv,
int gve_adminq_alloc(struct gve_priv *priv)
{
+ pthread_mutexattr_t mutexattr;
uint8_t pci_rev_id;
priv->adminq = gve_alloc_dma_mem(&priv->adminq_dma_mem, PAGE_SIZE);
@@ -241,6 +242,11 @@ int gve_adminq_alloc(struct gve_priv *priv)
priv->adminq_get_ptype_map_cnt = 0;
priv->adminq_cfg_flow_rule_cnt = 0;
+ pthread_mutexattr_init(&mutexattr);
+ pthread_mutexattr_setpshared(&mutexattr, PTHREAD_PROCESS_SHARED);
+ pthread_mutex_init(&priv->adminq_lock, &mutexattr);
+ pthread_mutexattr_destroy(&mutexattr);
+
/* Setup Admin queue with the device */
rte_pci_read_config(priv->pci_dev, &pci_rev_id, sizeof(pci_rev_id),
RTE_PCI_REVISION_ID);
@@ -304,6 +310,7 @@ void gve_adminq_free(struct gve_priv *priv)
return;
gve_adminq_release(priv);
gve_free_dma_mem(&priv->adminq_dma_mem);
+ pthread_mutex_destroy(&priv->adminq_lock);
gve_clear_admin_queue_ok(priv);
}
@@ -418,7 +425,10 @@ static int gve_adminq_issue_cmd(struct gve_priv *priv,
(tail & priv->adminq_mask)) {
int err;
- /* Flush existing commands to make room. */
+ /* Flush existing commands to make room.
+ * Note: This kicks the doorbell for all staged commands.
+ * Any failure here means we failed after attempting to kick.
+ */
err = gve_adminq_kick_and_wait(priv);
if (err)
return err;
@@ -509,17 +519,24 @@ static int gve_adminq_execute_cmd(struct gve_priv *priv,
u32 tail, head;
int err;
+ pthread_mutex_lock(&priv->adminq_lock);
tail = ioread32be(&priv->reg_bar0->adminq_event_counter);
head = priv->adminq_prod_cnt;
- if (tail != head)
+ if (tail != head) {
/* This is not a valid path */
- return -EINVAL;
+ err = -EINVAL;
+ goto unlock_and_return;
+ }
err = gve_adminq_issue_cmd(priv, cmd_orig);
if (err)
- return err;
+ goto unlock_and_return;
- return gve_adminq_kick_and_wait(priv);
+ err = gve_adminq_kick_and_wait(priv);
+
+unlock_and_return:
+ pthread_mutex_unlock(&priv->adminq_lock);
+ return err;
}
static int gve_adminq_execute_extended_cmd(struct gve_priv *priv, u32 opcode,
@@ -693,13 +710,19 @@ int gve_adminq_create_tx_queues(struct gve_priv *priv, u32 num_queues)
int err;
u32 i;
+ pthread_mutex_lock(&priv->adminq_lock);
+
for (i = 0; i < num_queues; i++) {
err = gve_adminq_create_tx_queue(priv, i);
if (err)
- return err;
+ goto unlock_and_return;
}
- return gve_adminq_kick_and_wait(priv);
+ err = gve_adminq_kick_and_wait(priv);
+
+unlock_and_return:
+ pthread_mutex_unlock(&priv->adminq_lock);
+ return err;
}
static int gve_adminq_create_rx_queue(struct gve_priv *priv, u32 queue_index)
@@ -747,13 +770,19 @@ int gve_adminq_create_rx_queues(struct gve_priv *priv, u32 num_queues)
int err;
u32 i;
+ pthread_mutex_lock(&priv->adminq_lock);
+
for (i = 0; i < num_queues; i++) {
err = gve_adminq_create_rx_queue(priv, i);
if (err)
- return err;
+ goto unlock_and_return;
}
- return gve_adminq_kick_and_wait(priv);
+ err = gve_adminq_kick_and_wait(priv);
+
+unlock_and_return:
+ pthread_mutex_unlock(&priv->adminq_lock);
+ return err;
}
static int gve_adminq_destroy_tx_queue(struct gve_priv *priv, u32 queue_index)
@@ -779,13 +808,19 @@ int gve_adminq_destroy_tx_queues(struct gve_priv *priv, u32 num_queues)
int err;
u32 i;
+ pthread_mutex_lock(&priv->adminq_lock);
+
for (i = 0; i < num_queues; i++) {
err = gve_adminq_destroy_tx_queue(priv, i);
if (err)
- return err;
+ goto unlock_and_return;
}
- return gve_adminq_kick_and_wait(priv);
+ err = gve_adminq_kick_and_wait(priv);
+
+unlock_and_return:
+ pthread_mutex_unlock(&priv->adminq_lock);
+ return err;
}
static int gve_adminq_destroy_rx_queue(struct gve_priv *priv, u32 queue_index)
@@ -811,13 +846,19 @@ int gve_adminq_destroy_rx_queues(struct gve_priv *priv, u32 num_queues)
int err;
u32 i;
+ pthread_mutex_lock(&priv->adminq_lock);
+
for (i = 0; i < num_queues; i++) {
err = gve_adminq_destroy_rx_queue(priv, i);
if (err)
- return err;
+ goto unlock_and_return;
}
- return gve_adminq_kick_and_wait(priv);
+ err = gve_adminq_kick_and_wait(priv);
+
+unlock_and_return:
+ pthread_mutex_unlock(&priv->adminq_lock);
+ return err;
}
static int gve_set_desc_cnt(struct gve_priv *priv,
diff --git a/drivers/net/gve/gve_ethdev.h b/drivers/net/gve/gve_ethdev.h
index 0577f03974..524e48e723 100644
--- a/drivers/net/gve/gve_ethdev.h
+++ b/drivers/net/gve/gve_ethdev.h
@@ -339,6 +339,7 @@ struct gve_priv {
struct gve_tx_queue **txqs;
struct gve_rx_queue **rxqs;
+ pthread_mutex_t adminq_lock; /* Protects AdminQ command execution */
uint32_t stats_report_len;
const struct rte_memzone *stats_report_mem;
uint16_t stats_start_idx; /* start index of array of stats written by NIC */
--
2.54.0.563.g4f69b47b94-goog
^ permalink raw reply related
* [PATCH v2 0/6] net/gve: add hardware timestamping support
From: Mark Blasko @ 2026-05-15 23:19 UTC (permalink / raw)
To: stephen; +Cc: dev, Mark Blasko
In-Reply-To: <20260511224354.872997-1-blasko@google.com>
This patch series introduces support for GVE hardware timestamping on DQO
queues. To support concurrent access, a mutex lock is introduced to protect
admin queue operations. A mechanism is then added to periodically synchronize
the NIC clock via AdminQ, and support is introduced for the read_clock ethdev
operation. Finally, the RX datapath is updated to reconstruct full 64-bit
timestamps from the 32-bit values in DQO descriptors.
---
v2:
- Patch 1: Dropped ROBUST mutex attribute.
- Patch 3: Added adminq timestamp counter reset to gve_adminq_alloc.
- Patch 4:
- Removed redundant void* casts.
- Handled alarm reschedule failures by marking timestamp stale.
- Added transient error logging on memzone allocation failure.
- Patch 5: Scoped read_clock ethdev operation strictly to DQO queues.
- Patch 6:
- Scoped timestamp offload capability advertisement strictly to
DQO queues.
- Predicated capability advertisement directly on memzone
allocation.
- Initialized mbuf_timestamp_offset to -1.
- Added blank line separating release notes.
---
Mark Blasko (6):
net/gve: add thread safety to admin queue
net/gve: add device option support for HW timestamps
net/gve: add AdminQ command for NIC timestamps
net/gve: add periodic NIC clock synchronization
net/gve: support read clock ethdev op
net/gve: reconstruct HW timestamps from DQO
.mailmap | 1 +
doc/guides/nics/features/gve.ini | 1 +
doc/guides/nics/gve.rst | 20 ++++
doc/guides/rel_notes/release_26_07.rst | 4 +
drivers/net/gve/base/gve_adminq.c | 128 +++++++++++++++++----
drivers/net/gve/base/gve_adminq.h | 29 +++++
drivers/net/gve/base/gve_desc_dqo.h | 8 +-
drivers/net/gve/gve_ethdev.c | 149 ++++++++++++++++++++++++-
drivers/net/gve/gve_ethdev.h | 39 +++++++
drivers/net/gve/gve_rx_dqo.c | 26 +++++
10 files changed, 383 insertions(+), 22 deletions(-)
--
2.54.0.563.g4f69b47b94-goog
^ permalink raw reply
* Re: [PATCH 0/6] net/gve: add hardware timestamping support
From: Mark Blasko @ 2026-05-15 23:18 UTC (permalink / raw)
To: Stephen Hemminger; +Cc: dev
In-Reply-To: <20260513164114.25de780b@stephen-xps.local>
Thanks for the review, and apologies for the accidental spam
with v1! We'll address most of the initial comments exactly as
suggested in v2, but have a few follow-ups:
> [PATCH 4/6] net/gve: add periodic NIC clock synchronization
>
> gve_setup_nic_timestamp() discards the gve_alloc_nic_ts_report() error.
> If the memzone allocation fails, priv->nic_timestamp_supported (set in
> 2/6) remains true, so dev_info_get() in 6/6 will advertise
> RTE_ETH_RX_OFFLOAD_TIMESTAMP and read_clock() in 5/6 will return -EIO
> on every call. Clear priv->nic_timestamp_supported on alloc failure so
> the capability is advertised honestly.
To avoid dishonest capability advertisements and -EIO loops while
preserving hardware capability tracking, we plan to leave
priv->nic_timestamp_supported untouched (as it represents immutable
hardware state). Instead, in v2 we'll predicate capability
advertisement in gve_dev_info_get() directly on memzone allocation
(priv->nic_ts_report_mz) and add an explicit error log advising a
device reset for transient recovery.
On Wed, May 13, 2026 at 7:41 AM Stephen Hemminger
<stephen@networkplumber.org> wrote:
> Patch 5: net/gve: support read clock ethdev op
>
> Warning: gve_read_clock and the periodic alarm callback
> gve_read_nic_clock share a single DMA buffer (priv->nic_ts_report)
> for the GVE_ADMINQ_REPORT_NIC_TIMESTAMP response. The adminq_lock
> introduced in patch 1 serializes the adminq command exchange, but
> is released inside gve_adminq_execute_cmd before either caller
> reads the buffer:
>
> err = gve_adminq_report_nic_timestamp(priv,
> priv->nic_ts_report_mz->iova);
> /* lock has already been released here */
> if (err != 0)
> return err;
> ts = be64_to_cpu(priv->nic_ts_report->nic_timestamp);
>
> If the user thread (gve_read_clock) is preempted between returning
> from gve_adminq_report_nic_timestamp and the be64_to_cpu read, the
> alarm callback can run, memset() the buffer to zero, take the
> adminq lock, issue its own command, and either leave its own
> response in the buffer or be mid-DMA when the user thread reads.
> The user thread will then read zero or a different command's
> response.
>
> The simplest fix is to return the cached
> priv->last_read_nic_timestamp from gve_read_clock rather than
> issuing a fresh adminq command. The periodic sync runs every
> 250ms, so the cached value is recent; the .read_clock semantics
> do not require a brand new device read. Alternatively, use a
> separate per-caller DMA buffer or extend the critical section
> to cover the buffer read.
Before returning the cached timestamp as suggested, we wanted to
clarify the API contract:
- Is the fact that .read_clock does not require a fresh device read
documented in the DPDK specification, or is this based on typical
application use cases? If the latter, what are those typical use
cases?
^ permalink raw reply
* RE: [EXTERNAL] Re: [PATCH v2 1/7] net/netvsc: retry VF hotplug indefinitely until PCI device disappears
From: Long Li @ 2026-05-15 19:45 UTC (permalink / raw)
To: Stephen Hemminger; +Cc: dev@dpdk.org, Wei Hu, stable@dpdk.org
In-Reply-To: <20260506194948.2508fa6b@phoenix.local>
> -----Original Message-----
> From: Stephen Hemminger <stephen@networkplumber.org>
> Sent: Wednesday, May 6, 2026 7:50 PM
> To: Long Li <longli@microsoft.com>
> Cc: dev@dpdk.org; Wei Hu <weh@microsoft.com>; stable@dpdk.org
> Subject: [EXTERNAL] Re: [PATCH v2 1/7] net/netvsc: retry VF hotplug indefinitely
> until PCI device disappears
>
> On Tue, 5 May 2026 19:05:22 -0700
> Long Li <longli@microsoft.com> wrote:
>
> > After PCI rescan on Azure, the MANA kernel driver can take over 100
> > seconds to probe and create the /sys/bus/pci/devices/<dev>/net directory.
> > The previous fixed retry limit (NETVSC_MAX_HOTADD_RETRY=10, ~12
> > seconds) was insufficient, causing VF re-attach to fail with 'Failed
> > to parse PCI device' on systems with slow MANA driver initialization.
> >
> > Replace the fixed retry limit with an indefinite retry that only gives
> > up when the PCI device itself disappears from sysfs. This is safe because:
> >
> > - The retry uses rte_eal_alarm callbacks which are serialized on the EAL
> > interrupt thread, preventing races with VF remove or device close paths.
> > - Device close (eth_hn_dev_uninit) explicitly cancels all pending hotplug
> > alarms via rte_eal_alarm_cancel and frees the context.
> > - If the PCI device is removed while retrying, access() detects the
> > missing sysfs path and stops immediately.
> >
> > A periodic NOTICE log every 30 retries (~30s) provides visibility into
> > long waits without flooding the log at DEBUG level.
> >
> > Fixes: a2a23a794b3a ("net/netvsc: support VF device hot add/remove")
> > Cc: stable@dpdk.org
> > Signed-off-by: Long Li <longli@microsoft.com>
> > ---
> Better but still seeing AI review warnings.
I have sent v3.
Thanks,
Long
>
> Reviewed the v2 7-patch series against upstream drivers/net/netvsc/. Patches 1,
> 2, 3, and 5 are clean. Findings on the rest:
> Patch 4 — the new "retry loop exiting" NOTICE fires on every termination
> including the success path, producing a noise alert on every successful VF re-
> attach.
> Patch 6 — two warnings: (a) reaching directly into vf_dev->dev_ops->stats_get
> works only because eth_stats_qstats_get() already memset the buffers before
> invoking netvsc's callback, an undocumented dependency on the caller; (b) the
> else fallback to rte_eth_stats_get() is dead code — it returns -ENOTSUP for the
> same reason as the direct call.
> Patch 7 — the recovering and recovery_success callbacks acquire vf_lock directly
> from event-callback context, departing from the existing INTR_RMV pattern that
> defers work via rte_eal_alarm_set precisely to avoid cross-driver lock-order
> assumptions. The unlocked vf_attached read in recovery_failed is a benign race
> that can be simplified by dropping the guard.
^ permalink raw reply
* [PATCH v3 7/7] net/netvsc: handle VF recovery events for service reset
From: Long Li @ 2026-05-15 19:28 UTC (permalink / raw)
To: dev, Wei Hu, Stephen Hemminger; +Cc: Long Li
In-Reply-To: <20260515192843.552762-1-longli@microsoft.com>
Register callbacks for RTE_ETH_EVENT_ERR_RECOVERING,
RTE_ETH_EVENT_RECOVERY_SUCCESS, and RTE_ETH_EVENT_RECOVERY_FAILED
events on the VF port to handle MANA service resets.
- On ERR_RECOVERING: defer data path switch to synthetic via
rte_eal_alarm_set, keeping VF attached in DPDK
- On RECOVERY_SUCCESS: defer data path switch back to VF
- On RECOVERY_FAILED: do full VF removal (same as INTR_RMV)
- Unregister all recovery callbacks and cancel pending alarms
during detach, removal, and close
All recovery callbacks defer work via rte_eal_alarm_set, consistent
with the existing INTR_RMV pattern, to avoid cross-driver lock-order
assumptions in event-callback context.
This ensures that during a service reset (kernel suspend/resume
without PCI remove), netvsc keeps the VF attached and seamlessly
switches back to it after recovery, without requiring a PCI
hot-add event.
This change is compatible with the current behavior when no
service reset messages are received.
Signed-off-by: Long Li <longli@microsoft.com>
---
v3:
- Deferred recovering and recovery_success callbacks via
rte_eal_alarm_set, consistent with INTR_RMV pattern
- Dropped unlocked vf_attached guard in recovery_failed
- Cancel new deferred alarms in hn_vf_close
v2:
- Added dev_started check in recovery_success
- Added vf_attached guard in recovery_failed
- Added comment explaining direct lock acquisition
drivers/net/netvsc/hn_vf.c | 165 +++++++++++++++++++++++++++++++++++++
1 file changed, 165 insertions(+)
diff --git a/drivers/net/netvsc/hn_vf.c b/drivers/net/netvsc/hn_vf.c
index c83cc973fd..27c46ce404 100644
--- a/drivers/net/netvsc/hn_vf.c
+++ b/drivers/net/netvsc/hn_vf.c
@@ -50,6 +50,13 @@ static int hn_vf_match(const struct rte_eth_dev *dev)
}
+static int hn_eth_recovering_callback(uint16_t port_id,
+ enum rte_eth_event_type event, void *cb_arg, void *out);
+static int hn_eth_recovery_success_callback(uint16_t port_id,
+ enum rte_eth_event_type event, void *cb_arg, void *out);
+static int hn_eth_recovery_failed_callback(uint16_t port_id,
+ enum rte_eth_event_type event, void *cb_arg, void *out);
+
/*
* Attach new PCI VF device and return the port_id
*/
@@ -111,7 +118,56 @@ static int hn_vf_attach(struct rte_eth_dev *dev, struct hn_data *hv)
return ret;
}
+ /* Register recovery event callbacks for service reset handling */
+ ret = rte_eth_dev_callback_register(hv->vf_ctx.vf_port,
+ RTE_ETH_EVENT_ERR_RECOVERING,
+ hn_eth_recovering_callback, hv);
+ if (ret) {
+ PMD_DRV_LOG(ERR,
+ "Registering recovering callback failed for vf port %d ret %d",
+ port, ret);
+ goto err_recovering;
+ }
+
+ ret = rte_eth_dev_callback_register(hv->vf_ctx.vf_port,
+ RTE_ETH_EVENT_RECOVERY_SUCCESS,
+ hn_eth_recovery_success_callback, hv);
+ if (ret) {
+ PMD_DRV_LOG(ERR,
+ "Registering recovery success callback failed for vf port %d ret %d",
+ port, ret);
+ goto err_recovery_success;
+ }
+
+ ret = rte_eth_dev_callback_register(hv->vf_ctx.vf_port,
+ RTE_ETH_EVENT_RECOVERY_FAILED,
+ hn_eth_recovery_failed_callback, hv);
+ if (ret) {
+ PMD_DRV_LOG(ERR,
+ "Registering recovery failed callback failed for vf port %d ret %d",
+ port, ret);
+ goto err_recovery_failed;
+ }
+
return 0;
+
+err_recovery_failed:
+ rte_eth_dev_callback_unregister(hv->vf_ctx.vf_port,
+ RTE_ETH_EVENT_RECOVERY_SUCCESS,
+ hn_eth_recovery_success_callback, hv);
+err_recovery_success:
+ rte_eth_dev_callback_unregister(hv->vf_ctx.vf_port,
+ RTE_ETH_EVENT_ERR_RECOVERING,
+ hn_eth_recovering_callback, hv);
+err_recovering:
+ rte_eth_dev_callback_unregister(hv->vf_ctx.vf_port,
+ RTE_ETH_EVENT_INTR_RMV,
+ hn_eth_rmv_event_callback, hv);
+ hv->vf_ctx.vf_attached = false;
+ hv->vf_ctx.vf_port = 0;
+ if (rte_eth_dev_owner_unset(port, hv->owner.id) < 0)
+ PMD_DRV_LOG(ERR, "Failed to unset owner for port %d", port);
+ return ret;
}
static void hn_vf_remove_unlocked(struct hn_data *hv);
@@ -143,6 +199,12 @@ static void hn_remove_delayed(void *args)
PMD_DRV_LOG(ERR,
"rte_eth_dev_callback_unregister failed ret=%d",
ret);
+ rte_eth_dev_callback_unregister(port_id, RTE_ETH_EVENT_ERR_RECOVERING,
+ hn_eth_recovering_callback, hv);
+ rte_eth_dev_callback_unregister(port_id, RTE_ETH_EVENT_RECOVERY_SUCCESS,
+ hn_eth_recovery_success_callback, hv);
+ rte_eth_dev_callback_unregister(port_id, RTE_ETH_EVENT_RECOVERY_FAILED,
+ hn_eth_recovery_failed_callback, hv);
/* Detach and release port_id from system */
ret = rte_eth_dev_stop(port_id);
@@ -187,6 +249,89 @@ int hn_eth_rmv_event_callback(uint16_t port_id,
return 0;
}
+/*
+ * Deferred handler for VF error recovery event.
+ * Switch data path to synthetic but keep the VF attached.
+ */
+static void hn_recovering_delayed(void *args)
+{
+ struct hn_data *hv = args;
+
+ rte_rwlock_write_lock(&hv->vf_lock);
+ hn_vf_remove_unlocked(hv);
+ rte_rwlock_write_unlock(&hv->vf_lock);
+}
+
+static int
+hn_eth_recovering_callback(uint16_t port_id,
+ enum rte_eth_event_type event __rte_unused,
+ void *cb_arg, void *out __rte_unused)
+{
+ struct hn_data *hv = cb_arg;
+
+ PMD_DRV_LOG(NOTICE, "VF port %u recovering from error", port_id);
+ rte_eal_alarm_set(1, hn_recovering_delayed, hv);
+
+ return 0;
+}
+
+/*
+ * Deferred handler for VF recovery success event.
+ * Switch data path back to VF.
+ */
+static void hn_recovery_success_delayed(void *args)
+{
+ struct hn_data *hv = args;
+ struct rte_eth_dev *dev = &rte_eth_devices[hv->port_id];
+ int ret;
+
+ rte_rwlock_write_lock(&hv->vf_lock);
+ /* Only switch data path to VF if the netvsc device is started,
+ * mirroring the check in hn_vf_add_unlocked. If the device was
+ * stopped during recovery, defer to hn_vf_start().
+ */
+ if (dev->data->dev_started &&
+ hv->vf_ctx.vf_attached && !hv->vf_ctx.vf_vsc_switched) {
+ ret = hn_nvs_set_datapath(hv, NVS_DATAPATH_VF);
+ if (ret)
+ PMD_DRV_LOG(ERR,
+ "Failed to switch to VF after recovery");
+ else
+ hv->vf_ctx.vf_vsc_switched = true;
+ }
+ rte_rwlock_write_unlock(&hv->vf_lock);
+}
+
+static int
+hn_eth_recovery_success_callback(uint16_t port_id,
+ enum rte_eth_event_type event __rte_unused,
+ void *cb_arg, void *out __rte_unused)
+{
+ struct hn_data *hv = cb_arg;
+
+ PMD_DRV_LOG(NOTICE, "VF port %u recovery succeeded", port_id);
+ rte_eal_alarm_set(1, hn_recovery_success_delayed, hv);
+
+ return 0;
+}
+
+/*
+ * Handle VF recovery failure event from MANA PMD.
+ * VF is unusable, do full removal.
+ */
+static int
+hn_eth_recovery_failed_callback(uint16_t port_id,
+ enum rte_eth_event_type event __rte_unused,
+ void *cb_arg, void *out __rte_unused)
+{
+ struct hn_data *hv = cb_arg;
+
+ PMD_DRV_LOG(NOTICE, "VF port %u recovery failed, removing", port_id);
+ rte_eal_alarm_set(1, hn_remove_delayed, hv);
+
+ return 0;
+}
+
static int hn_setup_vf_queues(int port, struct rte_eth_dev *dev)
{
struct hn_rx_queue *rx_queue;
@@ -247,6 +392,12 @@ static void hn_vf_detach(struct hn_data *hv)
rte_eth_dev_callback_unregister(port, RTE_ETH_EVENT_INTR_RMV,
hn_eth_rmv_event_callback, hv);
+ rte_eth_dev_callback_unregister(port, RTE_ETH_EVENT_ERR_RECOVERING,
+ hn_eth_recovering_callback, hv);
+ rte_eth_dev_callback_unregister(port, RTE_ETH_EVENT_RECOVERY_SUCCESS,
+ hn_eth_recovery_success_callback, hv);
+ rte_eth_dev_callback_unregister(port, RTE_ETH_EVENT_RECOVERY_FAILED,
+ hn_eth_recovery_failed_callback, hv);
if (rte_eth_dev_owner_unset(port, hv->owner.id) < 0)
PMD_DRV_LOG(ERR, "Failed to unset owner for port %d", port);
@@ -630,7 +781,21 @@ int hn_vf_close(struct rte_eth_dev *dev)
RTE_ETH_EVENT_INTR_RMV,
hn_eth_rmv_event_callback,
hv);
+ rte_eth_dev_callback_unregister(hv->vf_ctx.vf_port,
+ RTE_ETH_EVENT_ERR_RECOVERING,
+ hn_eth_recovering_callback,
+ hv);
+ rte_eth_dev_callback_unregister(hv->vf_ctx.vf_port,
+ RTE_ETH_EVENT_RECOVERY_SUCCESS,
+ hn_eth_recovery_success_callback,
+ hv);
+ rte_eth_dev_callback_unregister(hv->vf_ctx.vf_port,
+ RTE_ETH_EVENT_RECOVERY_FAILED,
+ hn_eth_recovery_failed_callback,
+ hv);
rte_eal_alarm_cancel(hn_remove_delayed, hv);
+ rte_eal_alarm_cancel(hn_recovering_delayed, hv);
+ rte_eal_alarm_cancel(hn_recovery_success_delayed, hv);
ret = rte_eth_dev_close(hv->vf_ctx.vf_port);
hv->vf_ctx.vf_attached = false;
}
--
2.43.0
^ permalink raw reply related
* [PATCH v3 6/7] net/netvsc: forward per-queue stats from VF device
From: Long Li @ 2026-05-15 19:28 UTC (permalink / raw)
To: dev, Wei Hu, Stephen Hemminger; +Cc: Long Li, stable
In-Reply-To: <20260515192843.552762-1-longli@microsoft.com>
hn_vf_stats_get was ignoring the qstats parameter (__rte_unused),
calling rte_eth_stats_get which only collects aggregate stats. This
meant per-queue stats (rx_q0_good_packets, tx_q0_good_packets, etc.)
were always zero when VF datapath was active, even though the
underlying MANA driver populates them in its stats_get callback.
Call the VF device's stats_get op directly with the qstats pointer
so per-queue counters are forwarded through netvsc to the xstats
telemetry output.
Fixes: dc7680e8597c ("net/netvsc: support integrated VF")
Cc: stable@dpdk.org
Signed-off-by: Long Li <longli@microsoft.com>
---
v3:
- Removed dead -ENOTSUP fallback to rte_eth_stats_get,
replaced with direct -ENOTSUP return
- Documented caller contract for zeroed buffers
v2:
- Added comment for direct dev_ops call
- Added -ENOTSUP fallback
drivers/net/netvsc/hn_vf.c | 17 ++++++++++++++---
1 file changed, 14 insertions(+), 3 deletions(-)
diff --git a/drivers/net/netvsc/hn_vf.c b/drivers/net/netvsc/hn_vf.c
index 1fcc65a712..c83cc973fd 100644
--- a/drivers/net/netvsc/hn_vf.c
+++ b/drivers/net/netvsc/hn_vf.c
@@ -749,7 +749,7 @@ void hn_vf_rx_queue_release(struct hn_data *hv, uint16_t queue_id)
int hn_vf_stats_get(struct rte_eth_dev *dev,
struct rte_eth_stats *stats,
- struct eth_queue_stats *qstats __rte_unused)
+ struct eth_queue_stats *qstats)
{
struct hn_data *hv = dev->data->dev_private;
struct rte_eth_dev *vf_dev;
@@ -757,8 +757,19 @@ int hn_vf_stats_get(struct rte_eth_dev *dev,
rte_rwlock_read_lock(&hv->vf_lock);
vf_dev = hn_get_vf_dev(hv);
- if (vf_dev)
- ret = rte_eth_stats_get(vf_dev->data->port_id, stats);
+ if (vf_dev) {
+ /* Call dev_ops->stats_get directly instead of the public
+ * rte_eth_stats_get API because we need to forward the
+ * per-queue stats (qstats) which the public API does not
+ * support. The caller (eth_stats_qstats_get) has already
+ * zeroed stats and qstats before invoking this callback.
+ */
+ if (vf_dev->dev_ops->stats_get != NULL)
+ ret = vf_dev->dev_ops->stats_get(vf_dev, stats,
+ qstats);
+ else
+ ret = -ENOTSUP;
+ }
rte_rwlock_read_unlock(&hv->vf_lock);
return ret;
}
--
2.43.0
^ permalink raw reply related
* [PATCH v3 5/7] net/netvsc: retry when no matching MAC found in net directory
From: Long Li @ 2026-05-15 19:28 UTC (permalink / raw)
To: dev, Wei Hu, Stephen Hemminger; +Cc: Long Li, stable
In-Reply-To: <20260515192843.552762-1-longli@microsoft.com>
On multi-NIC Azure VMs, a single MANA PCI device (7870:00:00.0) hosts
multiple VF interfaces. After PCI rescan, these interfaces register
at different times — the management NIC's VF appears first, followed
by the test NIC's VF.
Previously, when netvsc_hotplug_retry scanned the net/ directory and
found interfaces with non-matching MACs, it would exit the readdir
loop and free the hotadd context, permanently giving up. The matching
VF interface had not appeared yet.
Now, when the readdir loop ends without finding a matching MAC (dir
is NULL after loop), schedule another retry instead of giving up.
This uses a separate mac_retry counter (limit 120, ~2 minutes) so
the main retry loop remains unlimited.
Fixes: a2a23a794b3a ("net/netvsc: support VF device hot add/remove")
Cc: stable@dpdk.org
Signed-off-by: Long Li <longli@microsoft.com>
---
v3: no change
v2:
- Fixed commit message (limit 120 not 30)
- Changed mac_retry log to DEBUG
- Explicit NULL comparisons
drivers/net/netvsc/hn_ethdev.c | 36 +++++++++++++++++++++++++++++++++-
drivers/net/netvsc/hn_var.h | 1 +
2 files changed, 36 insertions(+), 1 deletion(-)
diff --git a/drivers/net/netvsc/hn_ethdev.c b/drivers/net/netvsc/hn_ethdev.c
index 16fb2b344d..72743872bb 100644
--- a/drivers/net/netvsc/hn_ethdev.c
+++ b/drivers/net/netvsc/hn_ethdev.c
@@ -92,6 +92,12 @@ struct netvsc_mp_param {
/* Retry interval for hot-add VF device (microseconds) */
#define NETVSC_HOTADD_RETRY_INTERVAL 1000000
+/* Max retries when net/ directory exists but no matching MAC found.
+ * On multi-NIC PCI devices, a second VF may register later.
+ * 120 retries = ~2 minutes.
+ */
+#define NETVSC_MAX_MAC_RETRY 120
+
struct hn_xstats_name_off {
char name[RTE_ETH_XSTATS_NAME_SIZE];
unsigned int offset;
@@ -768,8 +774,36 @@ static void netvsc_hotplug_retry(void *args)
RTE_ETHER_ADDR_BYTES(dev->data->mac_addrs));
}
+ /* If we opened the net directory but didn't find a matching MAC,
+ * the VF interface may not have appeared yet (e.g. on a multi-NIC
+ * PCI device, the second VF registers later). Retry.
+ */
+ if (di != NULL) {
+ closedir(di);
+ di = NULL;
+ if (dir == NULL) {
+ /* readdir returned NULL — loop ended without match */
+ hot_ctx->mac_retry++;
+ if (hot_ctx->mac_retry < NETVSC_MAX_MAC_RETRY) {
+ PMD_DRV_LOG(DEBUG,
+ "%s: no matching MAC found in %s, "
+ "retrying in 1 second (mac_retry %d/%d)",
+ __func__, buf,
+ hot_ctx->mac_retry,
+ NETVSC_MAX_MAC_RETRY);
+ rte_eal_alarm_set(NETVSC_HOTADD_RETRY_INTERVAL,
+ netvsc_hotplug_retry,
+ hot_ctx);
+ return;
+ }
+ PMD_DRV_LOG(NOTICE,
+ "%s: no matching MAC found after %d retries, giving up",
+ __func__, hot_ctx->mac_retry);
+ }
+ }
+
free_hotadd_ctx:
- if (di)
+ if (di != NULL)
closedir(di);
PMD_DRV_LOG(DEBUG, "%s: retry loop exiting for device %s (retry %d)",
diff --git a/drivers/net/netvsc/hn_var.h b/drivers/net/netvsc/hn_var.h
index ef55dee28e..574b909c82 100644
--- a/drivers/net/netvsc/hn_var.h
+++ b/drivers/net/netvsc/hn_var.h
@@ -127,6 +127,7 @@ struct hv_hotadd_context {
struct hn_data *hv;
struct rte_devargs da;
int eal_hot_plug_retry;
+ int mac_retry;
};
struct hn_data {
--
2.43.0
^ permalink raw reply related
* [PATCH v3 4/7] net/netvsc: add debug logging for VF hotplug retry
From: Long Li @ 2026-05-15 19:28 UTC (permalink / raw)
To: dev, Wei Hu, Stephen Hemminger; +Cc: Long Li
In-Reply-To: <20260515192843.552762-1-longli@microsoft.com>
Add detailed DEBUG-level logging at every decision point in the
netvsc_hotplug_retry function to diagnose VF re-attach failures:
- Log each interface found in the net/ directory
- Log when sa_family is not ARPHRD_ETHER
- Log MAC address comparison details on mismatch using
RTE_ETHER_ADDR_PRT_FMT for consistency with the rest of DPDK
- Log when the retry loop exits (with retry count)
Per-iteration trace uses DEBUG level to avoid flooding the log on
multi-NIC VMs with indefinite retries; NOTICE is reserved for
one-shot state transitions.
These logs help correlate DPDK hotplug retry behavior with kernel
dmesg timestamps to identify timing issues during VF re-attach
after PCI rescan on Azure.
Signed-off-by: Long Li <longli@microsoft.com>
---
v3:
- Changed "retry loop exiting" log from NOTICE to DEBUG to
avoid noise on every successful VF re-attach
v2:
- Changed per-iteration logs from NOTICE to DEBUG
- Used RTE_ETHER_ADDR_PRT_FMT macros
drivers/net/netvsc/hn_ethdev.c | 22 +++++++++++++++++++++-
1 file changed, 21 insertions(+), 1 deletion(-)
diff --git a/drivers/net/netvsc/hn_ethdev.c b/drivers/net/netvsc/hn_ethdev.c
index 9e4fc33949..16fb2b344d 100644
--- a/drivers/net/netvsc/hn_ethdev.c
+++ b/drivers/net/netvsc/hn_ethdev.c
@@ -663,6 +663,11 @@ static void netvsc_hotplug_retry(void *args)
if (!strcmp(dir->d_name, ".") || !strcmp(dir->d_name, ".."))
continue;
+ PMD_DRV_LOG(DEBUG,
+ "%s: checking interface %s in %s (retry %d)",
+ __func__, dir->d_name, buf,
+ hot_ctx->eal_hot_plug_retry);
+
/* trying to get mac address if this is a network device*/
s = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
if (s == -1) {
@@ -687,8 +692,12 @@ static void netvsc_hotplug_retry(void *args)
netvsc_hotplug_retry, hot_ctx);
return;
}
- if (req.ifr_hwaddr.sa_family != ARPHRD_ETHER)
+ if (req.ifr_hwaddr.sa_family != ARPHRD_ETHER) {
+ PMD_DRV_LOG(DEBUG,
+ "%s: device %s sa_family=%d not ARPHRD_ETHER, skipping",
+ __func__, dir->d_name, req.ifr_hwaddr.sa_family);
continue;
+ }
memcpy(eth_addr.addr_bytes, req.ifr_hwaddr.sa_data,
RTE_DIM(eth_addr.addr_bytes));
@@ -749,12 +758,23 @@ static void netvsc_hotplug_retry(void *args)
PMD_DRV_LOG(ERR, "Failed to add VF: %d", ret);
break;
}
+
+ PMD_DRV_LOG(DEBUG,
+ "%s: MAC mismatch for %s: got "
+ RTE_ETHER_ADDR_PRT_FMT
+ " expected " RTE_ETHER_ADDR_PRT_FMT,
+ __func__, dir->d_name,
+ RTE_ETHER_ADDR_BYTES(ð_addr),
+ RTE_ETHER_ADDR_BYTES(dev->data->mac_addrs));
}
free_hotadd_ctx:
if (di)
closedir(di);
+ PMD_DRV_LOG(DEBUG, "%s: retry loop exiting for device %s (retry %d)",
+ __func__, d->name, hot_ctx->eal_hot_plug_retry);
+
rte_spinlock_lock(&hv->hotadd_lock);
LIST_REMOVE(hot_ctx, list);
rte_spinlock_unlock(&hv->hotadd_lock);
--
2.43.0
^ permalink raw reply related
* [PATCH v3 3/7] net/netvsc: retry full probe when IB device not ready during hotplug
From: Long Li @ 2026-05-15 19:28 UTC (permalink / raw)
To: dev, Wei Hu, Stephen Hemminger; +Cc: Long Li, stable
In-Reply-To: <20260515192843.552762-1-longli@microsoft.com>
When rte_eal_hotplug_add returns -ENODEV during VF hot-add, it means the
MANA IB/verbs device is not yet registered by the mana_ib kernel module.
This happens because the mana_ib auxiliary driver probes asynchronously
after the MANA net driver creates the network interface.
On Azure VMs, the gap between netdev registration and IB device
registration can be several seconds. Previously, netvsc would log the
error and give up after finding the matching MAC address.
Now, on -ENODEV, restart the full retry loop from the PCI device
existence check. This re-scans the net directory to pick up any
interface renames (e.g. eth1 -> ens1) and retries until the IB device
is ready.
The -EEXIST return (device already probed by another netvsc port on the
same PCI device) is handled silently, as hn_vf_add will find the
already-probed VF port.
Fixes: a2a23a794b3a ("net/netvsc: support VF device hot add/remove")
Cc: stable@dpdk.org
Signed-off-by: Long Li <longli@microsoft.com>
---
v3: no change
v2:
- Restored ERR log level for non-ENODEV/non-EEXIST failures
from rte_eal_hotplug_add
- Added comment explaining why ENODEV retry is safe
drivers/net/netvsc/hn_ethdev.c | 29 ++++++++++++++++++++++++-----
1 file changed, 24 insertions(+), 5 deletions(-)
diff --git a/drivers/net/netvsc/hn_ethdev.c b/drivers/net/netvsc/hn_ethdev.c
index 096489d66d..9e4fc33949 100644
--- a/drivers/net/netvsc/hn_ethdev.c
+++ b/drivers/net/netvsc/hn_ethdev.c
@@ -717,17 +717,36 @@ static void netvsc_hotplug_retry(void *args)
* parent device, restore its args.
*/
ret = rte_eal_hotplug_add(d->bus->name, d->name, drv_str ? drv_str : "");
- if (ret) {
- PMD_DRV_LOG(ERR,
- "Failed to add PCI device %s",
+ free(drv_str);
+
+ if (ret == -ENODEV) {
+ /* IB device not ready yet (mana_ib not probed).
+ * Restart the full retry from the PCI device
+ * check so we re-verify the device exists and
+ * get fresh interface names after any renames.
+ * This retries indefinitely — the PCI sysfs
+ * check at the top of this function ensures
+ * we stop if the device disappears.
+ */
+ PMD_DRV_LOG(NOTICE,
+ "IB device not ready for %s, "
+ "restarting probe in 1 second",
d->name);
+ closedir(di);
+ rte_eal_alarm_set(NETVSC_HOTADD_RETRY_INTERVAL,
+ netvsc_hotplug_retry,
+ hot_ctx);
+ return;
}
- free(drv_str);
+ if (ret && ret != -EEXIST)
+ PMD_DRV_LOG(ERR,
+ "Failed to add PCI device %s (ret=%d)",
+ d->name, ret);
ret = hn_vf_add(dev, hv);
if (ret)
- PMD_DRV_LOG(ERR, "Failed to add VF in hotplug retry: %d", ret);
+ PMD_DRV_LOG(ERR, "Failed to add VF: %d", ret);
break;
}
}
--
2.43.0
^ permalink raw reply related
* [PATCH v3 2/7] net/netvsc: retry on SIOCGIFHWADDR failure during VF hotplug
From: Long Li @ 2026-05-15 19:28 UTC (permalink / raw)
To: dev, Wei Hu, Stephen Hemminger; +Cc: Long Li, stable
In-Reply-To: <20260515192843.552762-1-longli@microsoft.com>
When the MANA VF net directory appears after PCI rescan, udev may rename
the interface (e.g. eth1 → ens1) before DPDK can query its MAC address
via SIOCGIFHWADDR. The ioctl fails because the interface name is stale
during the rename window.
Instead of giving up when SIOCGIFHWADDR fails, close the directory and
schedule another retry. The next attempt will re-read the directory with
the updated interface name (e.g. ens1 instead of eth1) and succeed.
This was observed on Azure VMs where the MANA kernel driver takes >30
seconds to probe after PCI rescan, and udev renames the interface
immediately after registration.
Fixes: a2a23a794b3a ("net/netvsc: support VF device hot add/remove")
Cc: stable@dpdk.org
Signed-off-by: Long Li <longli@microsoft.com>
---
v3: no change
v2:
- Changed SIOCGIFHWADDR retry log level from NOTICE to DEBUG
- Updated comment to reference PCI device check as safety bound
drivers/net/netvsc/hn_ethdev.c | 14 +++++++++++---
1 file changed, 11 insertions(+), 3 deletions(-)
diff --git a/drivers/net/netvsc/hn_ethdev.c b/drivers/net/netvsc/hn_ethdev.c
index 85e500c178..096489d66d 100644
--- a/drivers/net/netvsc/hn_ethdev.c
+++ b/drivers/net/netvsc/hn_ethdev.c
@@ -674,10 +674,18 @@ static void netvsc_hotplug_retry(void *args)
ret = ioctl(s, SIOCGIFHWADDR, &req);
close(s);
if (ret == -1) {
- PMD_DRV_LOG(ERR,
- "Failed to send SIOCGIFHWADDR for device %s",
+ /* Interface may be renamed by udev (e.g. eth1 → ens1).
+ * Retry from the top — the PCI device check above
+ * ensures we stop if the device disappears.
+ */
+ PMD_DRV_LOG(DEBUG,
+ "Failed to send SIOCGIFHWADDR for device %s, "
+ "interface may be renaming, retrying",
dir->d_name);
- break;
+ closedir(di);
+ rte_eal_alarm_set(NETVSC_HOTADD_RETRY_INTERVAL,
+ netvsc_hotplug_retry, hot_ctx);
+ return;
}
if (req.ifr_hwaddr.sa_family != ARPHRD_ETHER)
continue;
--
2.43.0
^ permalink raw reply related
* [PATCH v3 1/7] net/netvsc: retry VF hotplug indefinitely until PCI device disappears
From: Long Li @ 2026-05-15 19:28 UTC (permalink / raw)
To: dev, Wei Hu, Stephen Hemminger; +Cc: Long Li, stable
In-Reply-To: <20260515192843.552762-1-longli@microsoft.com>
After PCI rescan on Azure, the MANA kernel driver can take over 100
seconds to probe and create the /sys/bus/pci/devices/<dev>/net directory.
The previous fixed retry limit (NETVSC_MAX_HOTADD_RETRY=10, ~12 seconds)
was insufficient, causing VF re-attach to fail with 'Failed to parse PCI
device' on systems with slow MANA driver initialization.
Replace the fixed retry limit with an indefinite retry that only gives up
when the PCI device itself disappears from sysfs. This is safe because:
- The retry uses rte_eal_alarm callbacks which are serialized on the EAL
interrupt thread, preventing races with VF remove or device close paths.
- Device close (eth_hn_dev_uninit) explicitly cancels all pending hotplug
alarms via rte_eal_alarm_cancel and frees the context.
- If the PCI device is removed while retrying, access() detects the
missing sysfs path and stops immediately.
A periodic NOTICE log every 30 retries (~30s) provides visibility into
long waits without flooding the log at DEBUG level.
Fixes: a2a23a794b3a ("net/netvsc: support VF device hot add/remove")
Cc: stable@dpdk.org
Signed-off-by: Long Li <longli@microsoft.com>
---
v3:
- Wrapped rte_eal_alarm_set lines to stay within 100 columns
(checkpatch line-length warning)
v2:
- Added detailed comment explaining why indefinite retry is
safe (PCI sysfs disappearance is the termination condition)
drivers/net/netvsc/hn_ethdev.c | 41 +++++++++++++++++++++++++---------
1 file changed, 31 insertions(+), 10 deletions(-)
diff --git a/drivers/net/netvsc/hn_ethdev.c b/drivers/net/netvsc/hn_ethdev.c
index b8880edb4c..85e500c178 100644
--- a/drivers/net/netvsc/hn_ethdev.c
+++ b/drivers/net/netvsc/hn_ethdev.c
@@ -89,8 +89,8 @@ struct netvsc_mp_param {
#define NETVSC_ARG_TXBREAK "tx_copybreak"
#define NETVSC_ARG_RX_EXTMBUF_ENABLE "rx_extmbuf_enable"
-/* The max number of retry when hot adding a VF device */
-#define NETVSC_MAX_HOTADD_RETRY 10
+/* Retry interval for hot-add VF device (microseconds) */
+#define NETVSC_HOTADD_RETRY_INTERVAL 1000000
struct hn_xstats_name_off {
char name[RTE_ETH_XSTATS_NAME_SIZE];
@@ -622,19 +622,39 @@ static void netvsc_hotplug_retry(void *args)
PMD_DRV_LOG(DEBUG, "%s: retry count %d",
__func__, hot_ctx->eal_hot_plug_retry);
- if (hot_ctx->eal_hot_plug_retry++ > NETVSC_MAX_HOTADD_RETRY) {
- PMD_DRV_LOG(NOTICE, "Failed to parse PCI device retry=%d",
- hot_ctx->eal_hot_plug_retry);
+ hot_ctx->eal_hot_plug_retry++;
+
+ /* Check if PCI device still exists — if it disappeared, give up.
+ * Otherwise keep retrying indefinitely until the net directory
+ * appears. This is safe because:
+ * - MANA driver probe can take >100s after PCI rescan
+ * - The retry uses rte_eal_alarm callbacks serialized on the
+ * EAL interrupt thread, preventing races with device close
+ * - Device close cancels pending alarms and frees the context
+ * - If the PCI device is removed, the access() check below
+ * detects the missing sysfs path and stops immediately
+ */
+ snprintf(buf, sizeof(buf), "/sys/bus/pci/devices/%s", d->name);
+ if (access(buf, F_OK) != 0) {
+ PMD_DRV_LOG(NOTICE,
+ "PCI device %s no longer exists, giving up after %d retries",
+ d->name, hot_ctx->eal_hot_plug_retry);
goto free_hotadd_ctx;
}
snprintf(buf, sizeof(buf), "/sys/bus/pci/devices/%s/net", d->name);
di = opendir(buf);
if (!di) {
- PMD_DRV_LOG(DEBUG, "%s: can't open directory %s, "
- "retrying in 1 second", __func__, buf);
- /* The device is still being initialized, retry after 1 second */
- rte_eal_alarm_set(1000000, netvsc_hotplug_retry, hot_ctx);
+ if (hot_ctx->eal_hot_plug_retry % 30 == 0)
+ PMD_DRV_LOG(NOTICE,
+ "%s: waiting for %s (retry %d, %ds elapsed)",
+ __func__, buf, hot_ctx->eal_hot_plug_retry,
+ hot_ctx->eal_hot_plug_retry);
+ else
+ PMD_DRV_LOG(DEBUG, "%s: can't open directory %s, "
+ "retrying in 1 second", __func__, buf);
+ rte_eal_alarm_set(NETVSC_HOTADD_RETRY_INTERVAL,
+ netvsc_hotplug_retry, hot_ctx);
return;
}
@@ -758,7 +778,8 @@ netvsc_hotadd_callback(const char *device_name, enum rte_dev_event_type type,
rte_spinlock_lock(&hv->hotadd_lock);
LIST_INSERT_HEAD(&hv->hotadd_list, hot_ctx, list);
rte_spinlock_unlock(&hv->hotadd_lock);
- rte_eal_alarm_set(1000000, netvsc_hotplug_retry, hot_ctx);
+ rte_eal_alarm_set(NETVSC_HOTADD_RETRY_INTERVAL,
+ netvsc_hotplug_retry, hot_ctx);
return;
}
--
2.43.0
^ permalink raw reply related
* [PATCH v3 0/7] net/netvsc: fix VF hotplug and service reset handling
From: Long Li @ 2026-05-15 19:28 UTC (permalink / raw)
To: dev, Wei Hu, Stephen Hemminger; +Cc: Long Li
In-Reply-To: <20260506020529.281654-1-longli@microsoft.com>
This series fixes several issues in the netvsc PMD's VF hot-plug retry
logic and adds support for MANA service reset (suspend/resume) recovery.
Patches 1-5 fix the VF hot-add retry path to handle Azure-specific
timing issues: slow MANA driver probe (>100s), udev interface renames,
asynchronous mana_ib registration, and multi-NIC staggered VF
appearance.
Patch 6 fixes per-queue stats forwarding from VF to netvsc.
Patch 7 adds recovery event handling for MANA service resets, where
the kernel suspends/resumes the VF without PCI remove.
v3:
- Patch 1: wrapped rte_eal_alarm_set lines to fix checkpatch
line-length warning
- Patch 4: changed "retry loop exiting" log from NOTICE to DEBUG
to avoid noise on every successful VF re-attach
- Patch 6: removed dead -ENOTSUP fallback to rte_eth_stats_get,
replaced with direct -ENOTSUP return; documented caller contract
for zeroed buffers
- Patch 7: deferred all recovery callbacks via rte_eal_alarm_set
consistent with INTR_RMV pattern; dropped unlocked vf_attached
guard in recovery_failed; cancel new alarms in hn_vf_close
v2:
- Patch 1: added comment explaining why indefinite retry is safe
- Patch 2: changed SIOCGIFHWADDR retry log to DEBUG
- Patch 3: restored ERR log for non-ENODEV/EEXIST failures
- Patch 4: changed per-iteration logs from NOTICE to DEBUG;
used RTE_ETHER_ADDR_PRT_FMT macros
- Patch 5: fixed commit message (limit 120 not 30); changed
mac_retry log to DEBUG; explicit NULL comparisons
- Patch 6: added comment for direct dev_ops call; added -ENOTSUP
fallback
- Patch 7: added dev_started check in recovery_success; added
vf_attached guard in recovery_failed
Long Li (7):
net/netvsc: retry VF hotplug indefinitely until PCI device disappears
net/netvsc: retry on SIOCGIFHWADDR failure during VF hotplug
net/netvsc: retry full probe when IB device not ready during hotplug
net/netvsc: add debug logging for VF hotplug retry
net/netvsc: retry when no matching MAC found in net directory
net/netvsc: forward per-queue stats from VF device
net/netvsc: handle VF recovery events for service reset
drivers/net/netvsc/hn_ethdev.c | 142 +++++++++++++++++++++----
drivers/net/netvsc/hn_var.h | 1 +
drivers/net/netvsc/hn_vf.c | 182 ++++++++++++++++++++++++++++++++-
3 files changed, 302 insertions(+), 23 deletions(-)
--
2.43.0
^ permalink raw reply
* [PATCH v1] dts: add sleep to trex setup
From: Andrew Bailey @ 2026-05-15 17:47 UTC (permalink / raw)
To: dev, luca.vizzarro, patrickrobb1997
Cc: lylavoie, ahassick, knimoji, Andrew Bailey
Previously, there were some cases where the single core performance test
suite would report zero Mpps. Adding a sleep in between setting up the
TREX generator and sending the packets resolves this issue.
Bugzilla ID: 1946
Fixes: d77d7f04f24c ("dts: add single-core performance test suite")
Signed-off-by: Andrew Bailey <abailey@iol.unh.edu>
---
dts/framework/testbed_model/traffic_generator/trex.py | 1 +
1 file changed, 1 insertion(+)
diff --git a/dts/framework/testbed_model/traffic_generator/trex.py b/dts/framework/testbed_model/traffic_generator/trex.py
index 22cd20dea9..19a71a7dd5 100644
--- a/dts/framework/testbed_model/traffic_generator/trex.py
+++ b/dts/framework/testbed_model/traffic_generator/trex.py
@@ -184,6 +184,7 @@ def _generate_traffic(
"""
self._create_packet_stream(packet)
self._setup_trex_client()
+ time.sleep(1)
stats = self._send_traffic_and_get_stats(duration, send_mpps)
--
2.50.1
^ permalink raw reply related
* Re: 23.11.7 patches review and test
From: Kevin Traynor @ 2026-05-15 16:03 UTC (permalink / raw)
To: Luca Boccassi
Cc: Shani Peretz, stable, dev, Robin Jarry, David Marchand,
Thomas Monjalon
In-Reply-To: <CAMw=ZnSLnz8uxwPJgZThKUm4fpsge_dvb8+o4grBeNYYsmuBMw@mail.gmail.com>
On 5/15/26 1:36 PM, Luca Boccassi wrote:
> On Fri, 15 May 2026 at 11:32, Kevin Traynor <ktraynor@redhat.com> wrote:
>>
>> On 4/30/26 12:02 PM, Kevin Traynor wrote:
>>> On 4/30/26 10:58 AM, Thomas Monjalon wrote:
>>>> 30/04/2026 11:32, Kevin Traynor:
>>>>> On 4/21/26 7:46 AM, Shani Peretz wrote:
>>>>>> The planned date for the final release is 30 April 2026.
>>>>>
>>>>> As discussed on thread [0] there was a quite serious regression caused
>>>>> by "net: fix packet type for stacked VLAN"
>>>>>
>>>>> As discussion on the fix is ongoing, I would suggest to just revert this
>>>>> patch for your release.
>>>>
>>>> I agree the revert is the best option here.
>>>>
>>>>> It doesn't require a new RC and re-validation as it's an isolated issue
>>>>> (and there wasn't test cases to catch before Robin's new patch anyway)
>>>>
>>>> I suppose 24.11.5 and 25.11.1 are also impacted?
>>>>
>>>>
>>>
>>> Yes, I was hoping we would have a fix in a few days and we could add and
>>> re-release. Given that there's now discussion on the patch and what
>>> functionality is needed, it's probably best to just revert and release a
>>> new 24.11/25.11.
>>
>> Hi Luca. Are you planning to do a 24.11 release with revert for above
>> issue ? If you have a time issue, let me know and I can help out.
>
> Hi, is it strictly necessary? Could it wait for the next one?
>
It's a user visible regression from the previous release that impacts
tap device with VLAN, causing good packets to be discarded. It's also
visible to any application using the net API in a similar way. Given the
effort is low as it's just a revert and we don't need validation teams
involved, then I think it's worthwhile.
^ permalink raw reply
* Re: [PATCH] maintainers: update for compress/uadk and crypto/uadk driver
From: Thomas Monjalon @ 2026-05-15 14:04 UTC (permalink / raw)
To: ZongYu Wu, fengchengwen; +Cc: dev, fanghao11, liulongfang
In-Reply-To: <3c80e9fb-c285-4928-ade2-15a2bc1da914@huawei.com>
15/05/2026 02:06, fengchengwen:
> Acked-by: Chengwen Feng <fengchengwen@huawei.com>
>
> Please
> 1\ For commitlog, each line contain a maximum of 72 characters.
> 2\ Add you name in .mailmap
>
> On 5/14/2026 8:40 PM, ZongYu Wu wrote:
> > From: Zongyu Wu <wuzongyu1@huawei.com>
> >
> > Zongyu Wu replaces Zhangfei Gao as the maintainer of compress/uadk and crypto/uadk.
> >
> > Signed-off-by: Zongyu Wu <wuzongyu1@huawei.com>
Applied with mailmap addition, thanks.
^ permalink raw reply
* [PATCH] net/mlx5: redirect LACP traffic for legacy E-Switch
From: Dariusz Sosnowski @ 2026-05-15 12:37 UTC (permalink / raw)
To: Viacheslav Ovsiienko, Bing Zhao, Ori Kam, Suanming Mou,
Matan Azrad
Cc: dev, stable
Offending patch fixed the LACP miss rule logic for NICs where
switchdev is enabled. In this case, LACP miss rules should be inserted
if and only if started port is a main port on the embedded switch.
Side effect of that change was that LACP miss rules are not inserted
when switchdev is disabled and legacy SR-IOV switch mode is used.
This patch addresses that:
- Fix the LACP rule insertion condition.
- Move HWS table for LACP rule creation out of FDB rules,
so they can be created separately.
Fixes: 87e4384d2662 ("net/mlx5: fix condition of LACP miss flow")
Cc: stable@dpdk.org
Signed-off-by: Dariusz Sosnowski <dsosnowski@nvidia.com>
---
drivers/net/mlx5/mlx5.h | 1 +
drivers/net/mlx5/mlx5_flow.h | 40 ++++++++-
drivers/net/mlx5/mlx5_flow_hw.c | 140 ++++++++++++++++++++++++--------
drivers/net/mlx5/mlx5_trigger.c | 7 +-
4 files changed, 145 insertions(+), 43 deletions(-)
diff --git a/drivers/net/mlx5/mlx5.h b/drivers/net/mlx5/mlx5.h
index 49a0c03544..ab5c76bfc4 100644
--- a/drivers/net/mlx5/mlx5.h
+++ b/drivers/net/mlx5/mlx5.h
@@ -2040,6 +2040,7 @@ struct mlx5_priv {
rte_spinlock_t hw_ctrl_lock;
LIST_HEAD(hw_ctrl_flow, mlx5_ctrl_flow_entry) hw_ctrl_flows;
LIST_HEAD(hw_ext_ctrl_flow, mlx5_ctrl_flow_entry) hw_ext_ctrl_flows;
+ struct mlx5_flow_hw_lacp_miss *hw_lacp_miss; /* HWS LACP miss flow tables */
struct mlx5_flow_hw_ctrl_fdb *hw_ctrl_fdb; /* FDB control flow context */
struct mlx5_flow_hw_ctrl_nic *hw_ctrl_nic; /* NIC control flow context */
struct rte_flow_pattern_template *hw_tx_repr_tagging_pt;
diff --git a/drivers/net/mlx5/mlx5_flow.h b/drivers/net/mlx5/mlx5_flow.h
index c9e72a33d6..3f5ba55bf9 100644
--- a/drivers/net/mlx5/mlx5_flow.h
+++ b/drivers/net/mlx5/mlx5_flow.h
@@ -3031,6 +3031,13 @@ struct mlx5_flow_hw_ctrl_rx {
[MLX5_FLOW_HW_CTRL_RX_EXPANDED_RSS_MAX];
};
+/* Contains all templates and table required for redirecting LACP traffic with HWS. */
+struct mlx5_flow_hw_lacp_miss {
+ struct rte_flow_pattern_template *lacp_rx_items_tmpl;
+ struct rte_flow_actions_template *lacp_rx_actions_tmpl;
+ struct rte_flow_template_table *hw_lacp_rx_tbl;
+};
+
/* Contains all templates required for control flow rules in FDB with HWS. */
struct mlx5_flow_hw_ctrl_fdb {
struct rte_flow_pattern_template *esw_mgr_items_tmpl;
@@ -3042,9 +3049,6 @@ struct mlx5_flow_hw_ctrl_fdb {
struct rte_flow_pattern_template *port_items_tmpl;
struct rte_flow_actions_template *jump_one_actions_tmpl;
struct rte_flow_template_table *hw_esw_zero_tbl;
- struct rte_flow_pattern_template *lacp_rx_items_tmpl;
- struct rte_flow_actions_template *lacp_rx_actions_tmpl;
- struct rte_flow_template_table *hw_lacp_rx_tbl;
};
struct mlx5_flow_hw_ctrl_nic {
@@ -3735,6 +3739,36 @@ mlx5_indirect_list_handles_release(struct rte_eth_dev *dev);
bool mlx5_flow_is_steering_disabled(void);
+/**
+ * Returns true if Rx control rule for LACP traffic is needed.
+ *
+ * mlx5 PMD needs to create a rule matching LACP traffic and forwarding it back to kernel if:
+ *
+ * - Underlying device is a bond interface.
+ * - User did not request to handle LACP traffic in user space.
+ *
+ * Creation of this rule is also controlled by the E-Switch mode:
+ *
+ * - It must be created in legacy mode.
+ * - It must be created only on proxy port in switchdev mode.
+ *
+ * @param[in] priv
+ * Pointer to Ethernet device structure.
+ *
+ * @return
+ * True if LACP rules must be created.
+ * False otherwise.
+ */
+static inline bool
+mlx5_flow_lacp_miss_needed(struct rte_eth_dev *dev)
+{
+ struct mlx5_priv *priv = dev->data->dev_private;
+
+ return !priv->sh->config.lacp_by_user &&
+ priv->pf_bond >= 0 &&
+ (!priv->sh->esw_mode || (priv->sh->esw_mode && priv->master));
+}
+
#ifdef HAVE_MLX5_HWS_SUPPORT
#define MLX5_REPR_STC_MEMORY_LOG 11
diff --git a/drivers/net/mlx5/mlx5_flow_hw.c b/drivers/net/mlx5/mlx5_flow_hw.c
index b6bb9f12a6..c133230cb7 100644
--- a/drivers/net/mlx5/mlx5_flow_hw.c
+++ b/drivers/net/mlx5/mlx5_flow_hw.c
@@ -10820,15 +10820,6 @@ flow_hw_cleanup_ctrl_fdb_tables(struct rte_eth_dev *dev)
if (!priv->hw_ctrl_fdb)
return;
hw_ctrl_fdb = priv->hw_ctrl_fdb;
- /* Clean up templates used for LACP default miss table. */
- if (hw_ctrl_fdb->hw_lacp_rx_tbl)
- claim_zero(flow_hw_table_destroy(dev, hw_ctrl_fdb->hw_lacp_rx_tbl, NULL));
- if (hw_ctrl_fdb->lacp_rx_actions_tmpl)
- claim_zero(flow_hw_actions_template_destroy(dev, hw_ctrl_fdb->lacp_rx_actions_tmpl,
- NULL));
- if (hw_ctrl_fdb->lacp_rx_items_tmpl)
- claim_zero(flow_hw_pattern_template_destroy(dev, hw_ctrl_fdb->lacp_rx_items_tmpl,
- NULL));
/* Clean up templates used for default FDB jump rule. */
if (hw_ctrl_fdb->hw_esw_zero_tbl)
claim_zero(flow_hw_table_destroy(dev, hw_ctrl_fdb->hw_esw_zero_tbl, NULL));
@@ -10898,6 +10889,99 @@ flow_hw_create_lacp_rx_table(struct rte_eth_dev *dev,
return flow_hw_table_create(dev, &cfg, &it, 1, &at, 1, error);
}
+/*
+ * Clean up templates and table used for redirecting LACP traffic to kernel.
+ *
+ * @param dev
+ * Pointer to Ethernet device.
+ */
+static void
+flow_hw_cleanup_lacp_miss_tables(struct rte_eth_dev *dev)
+{
+ struct mlx5_priv *priv = dev->data->dev_private;
+ struct mlx5_flow_hw_lacp_miss *hw_lacp_miss;
+
+ if (priv->hw_lacp_miss == NULL)
+ return;
+
+ hw_lacp_miss = priv->hw_lacp_miss;
+
+ if (hw_lacp_miss->hw_lacp_rx_tbl)
+ claim_zero(flow_hw_table_destroy(dev, hw_lacp_miss->hw_lacp_rx_tbl, NULL));
+ if (hw_lacp_miss->lacp_rx_actions_tmpl)
+ claim_zero(flow_hw_actions_template_destroy(dev,
+ hw_lacp_miss->lacp_rx_actions_tmpl,
+ NULL));
+ if (hw_lacp_miss->lacp_rx_items_tmpl)
+ claim_zero(flow_hw_pattern_template_destroy(dev,
+ hw_lacp_miss->lacp_rx_items_tmpl,
+ NULL));
+
+ mlx5_free(hw_lacp_miss);
+ priv->hw_lacp_miss = NULL;
+}
+
+/*
+ * Create templates and table for redirecting LACP traffic to kernel.
+ *
+ * LACP traffic redirection is needed whenever LACP bond is managed by the kernel.
+ * Required rule has a following structure:
+ *
+ * - ingress rule on root table
+ * - match EtherType 0x8809
+ * - action DEFAULT_MISS
+ *
+ * @param dev
+ * Pointer to Ethernet device.
+ *
+ * @return
+ * 0 on success. Negative errno otherwise.
+ */
+static int
+flow_hw_create_lacp_miss_tables(struct rte_eth_dev *dev)
+{
+ struct mlx5_priv *priv = dev->data->dev_private;
+ struct mlx5_flow_hw_lacp_miss *hw_lacp_miss;
+
+ if (mlx5_flow_is_steering_disabled())
+ return 0;
+
+ hw_lacp_miss = mlx5_malloc(MLX5_MEM_ZERO, sizeof(*hw_lacp_miss), 0, SOCKET_ID_ANY);
+ if (!hw_lacp_miss) {
+ DRV_LOG(ERR, "port %u Failed to allocate memory for LACP miss tables",
+ dev->data->port_id);
+ return -ENOMEM;
+ }
+ priv->hw_lacp_miss = hw_lacp_miss;
+
+ hw_lacp_miss->lacp_rx_items_tmpl = flow_hw_create_lacp_rx_pattern_template(dev, NULL);
+ if (!hw_lacp_miss->lacp_rx_items_tmpl) {
+ DRV_LOG(ERR, "port %u Failed to create pattern template for LACP Rx traffic",
+ dev->data->port_id);
+ goto error;
+ }
+ hw_lacp_miss->lacp_rx_actions_tmpl = flow_hw_create_lacp_rx_actions_template(dev, NULL);
+ if (!hw_lacp_miss->lacp_rx_actions_tmpl) {
+ DRV_LOG(ERR, "port %u Failed to create actions template for LACP Rx traffic",
+ dev->data->port_id);
+ goto error;
+ }
+ hw_lacp_miss->hw_lacp_rx_tbl =
+ flow_hw_create_lacp_rx_table(dev, hw_lacp_miss->lacp_rx_items_tmpl,
+ hw_lacp_miss->lacp_rx_actions_tmpl, NULL);
+ if (!hw_lacp_miss->hw_lacp_rx_tbl) {
+ DRV_LOG(ERR, "port %u Failed to create template table for LACP Rx traffic",
+ dev->data->port_id);
+ goto error;
+ }
+
+ return 0;
+
+error:
+ flow_hw_cleanup_lacp_miss_tables(dev);
+ return -EINVAL;
+}
+
/**
* Creates a set of flow tables used to create control flows used
* when E-Switch is engaged.
@@ -11000,31 +11084,6 @@ flow_hw_create_fdb_ctrl_tables(struct rte_eth_dev *dev, struct rte_flow_error *e
goto err;
}
}
- /* Create LACP default miss table. */
- if (!priv->sh->config.lacp_by_user && priv->pf_bond >= 0 && priv->master) {
- hw_ctrl_fdb->lacp_rx_items_tmpl =
- flow_hw_create_lacp_rx_pattern_template(dev, error);
- if (!hw_ctrl_fdb->lacp_rx_items_tmpl) {
- DRV_LOG(ERR, "port %u failed to create pattern template"
- " for LACP Rx traffic", dev->data->port_id);
- goto err;
- }
- hw_ctrl_fdb->lacp_rx_actions_tmpl =
- flow_hw_create_lacp_rx_actions_template(dev, error);
- if (!hw_ctrl_fdb->lacp_rx_actions_tmpl) {
- DRV_LOG(ERR, "port %u failed to create actions template"
- " for LACP Rx traffic", dev->data->port_id);
- goto err;
- }
- hw_ctrl_fdb->hw_lacp_rx_tbl = flow_hw_create_lacp_rx_table
- (dev, hw_ctrl_fdb->lacp_rx_items_tmpl,
- hw_ctrl_fdb->lacp_rx_actions_tmpl, error);
- if (!hw_ctrl_fdb->hw_lacp_rx_tbl) {
- DRV_LOG(ERR, "port %u failed to create template table for"
- " for LACP Rx traffic", dev->data->port_id);
- goto err;
- }
- }
return 0;
err:
@@ -11754,6 +11813,7 @@ __mlx5_flow_hw_resource_release(struct rte_eth_dev *dev, bool ctx_close)
mlx5_flow_hw_rxq_flag_set(dev, false);
flow_hw_flush_all_ctrl_flows(dev);
+ flow_hw_cleanup_lacp_miss_tables(dev);
flow_hw_cleanup_ctrl_fdb_tables(dev);
flow_hw_cleanup_ctrl_nic_tables(dev);
flow_hw_cleanup_tx_repr_tagging(dev);
@@ -12160,6 +12220,14 @@ __flow_hw_configure(struct rte_eth_dev *dev,
if (ret)
goto err;
}
+ if (mlx5_flow_lacp_miss_needed(dev)) {
+ ret = flow_hw_create_lacp_miss_tables(dev);
+ if (ret) {
+ rte_flow_error_set(error, -ret, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL,
+ "Unable to create LACP miss flow tables");
+ goto err;
+ }
+ }
if (is_proxy) {
ret = flow_hw_create_vport_actions(priv);
if (ret) {
@@ -16234,10 +16302,10 @@ mlx5_flow_hw_lacp_rx_flow(struct rte_eth_dev *dev)
.type = MLX5_CTRL_FLOW_TYPE_LACP_RX,
};
- if (!priv->dr_ctx || !priv->hw_ctrl_fdb || !priv->hw_ctrl_fdb->hw_lacp_rx_tbl)
+ if (!priv->dr_ctx || !priv->hw_lacp_miss || !priv->hw_lacp_miss->hw_lacp_rx_tbl)
return 0;
return flow_hw_create_ctrl_flow(dev, dev,
- priv->hw_ctrl_fdb->hw_lacp_rx_tbl,
+ priv->hw_lacp_miss->hw_lacp_rx_tbl,
eth_lacp, 0, miss_action, 0, &flow_info, false);
}
diff --git a/drivers/net/mlx5/mlx5_trigger.c b/drivers/net/mlx5/mlx5_trigger.c
index a070aaecfd..32cd18717d 100644
--- a/drivers/net/mlx5/mlx5_trigger.c
+++ b/drivers/net/mlx5/mlx5_trigger.c
@@ -1672,9 +1672,8 @@ mlx5_traffic_enable_hws(struct rte_eth_dev *dev)
} else {
DRV_LOG(INFO, "port %u FDB default rule is disabled", dev->data->port_id);
}
- if (!priv->sh->config.lacp_by_user && priv->pf_bond >= 0 && priv->master)
- if (mlx5_flow_hw_lacp_rx_flow(dev))
- goto error;
+ if (mlx5_flow_lacp_miss_needed(dev) && mlx5_flow_hw_lacp_rx_flow(dev) != 0)
+ goto error;
if (priv->isolated)
return 0;
ret = mlx5_flow_hw_create_ctrl_rx_tables(dev);
@@ -1796,7 +1795,7 @@ mlx5_traffic_enable(struct rte_eth_dev *dev)
DRV_LOG(INFO, "port %u FDB default rule is disabled",
dev->data->port_id);
}
- if (!priv->sh->config.lacp_by_user && priv->pf_bond >= 0 && priv->master) {
+ if (mlx5_flow_lacp_miss_needed(dev)) {
ret = mlx5_flow_lacp_miss(dev);
if (ret)
DRV_LOG(INFO, "port %u LACP rule cannot be created - "
--
2.47.3
^ permalink raw reply related
* Re: 23.11.7 patches review and test
From: Luca Boccassi @ 2026-05-15 12:36 UTC (permalink / raw)
To: Kevin Traynor
Cc: Shani Peretz, stable, dev, Robin Jarry, David Marchand,
Thomas Monjalon
In-Reply-To: <91a6d5df-57c8-4045-9cc4-4ea0f5170f52@redhat.com>
On Fri, 15 May 2026 at 11:32, Kevin Traynor <ktraynor@redhat.com> wrote:
>
> On 4/30/26 12:02 PM, Kevin Traynor wrote:
> > On 4/30/26 10:58 AM, Thomas Monjalon wrote:
> >> 30/04/2026 11:32, Kevin Traynor:
> >>> On 4/21/26 7:46 AM, Shani Peretz wrote:
> >>>> The planned date for the final release is 30 April 2026.
> >>>
> >>> As discussed on thread [0] there was a quite serious regression caused
> >>> by "net: fix packet type for stacked VLAN"
> >>>
> >>> As discussion on the fix is ongoing, I would suggest to just revert this
> >>> patch for your release.
> >>
> >> I agree the revert is the best option here.
> >>
> >>> It doesn't require a new RC and re-validation as it's an isolated issue
> >>> (and there wasn't test cases to catch before Robin's new patch anyway)
> >>
> >> I suppose 24.11.5 and 25.11.1 are also impacted?
> >>
> >>
> >
> > Yes, I was hoping we would have a fix in a few days and we could add and
> > re-release. Given that there's now discussion on the patch and what
> > functionality is needed, it's probably best to just revert and release a
> > new 24.11/25.11.
>
> Hi Luca. Are you planning to do a 24.11 release with revert for above
> issue ? If you have a time issue, let me know and I can help out.
Hi, is it strictly necessary? Could it wait for the next one?
^ permalink raw reply
* [PATCH] net/mlx5: fix uninitialized skip count
From: Dariusz Sosnowski @ 2026-05-15 12:33 UTC (permalink / raw)
To: Viacheslav Ovsiienko, Bing Zhao, Ori Kam, Suanming Mou,
Matan Azrad, Alexander Kozyrev
Cc: dev, Kiran Vedere, stable
From: Kiran Vedere <kiranv@nvidia.com>
mlx5_rx_poll_len() may return MLX5_ERROR_CQE_MASK when
mlx5_rx_err_handle() reports MLX5_CQE_STATUS_HW_OWN while the Rx queue
is in IGNORE error state. In this HW_OWN case mlx5_rx_err_handle()
does not necessarily write to *skip_cnt, yet the caller (mlx5_rx_burst)
unconditionally uses skip_cnt to advance rq_ci.
This can cause rq_ci to jump by an undefined value, desynchronizing the
RQ and CQ rings and leading to persistent bad packet delivery until the
queue is reset.
Fixes: aa67ed308458 ("net/mlx5: ignore non-critical syndromes for Rx queue")
Cc: akozyrev@nvidia.com
Cc: stable@dpdk.org
Signed-off-by: Kiran Vedere <kiranv@nvidia.com>
Acked-by: Dariusz Sosnowski <dsosnowski@nvidia.com>
---
drivers/net/mlx5/mlx5_rx.c | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/drivers/net/mlx5/mlx5_rx.c b/drivers/net/mlx5/mlx5_rx.c
index 185bfd4fff..09cd3f1ffb 100644
--- a/drivers/net/mlx5/mlx5_rx.c
+++ b/drivers/net/mlx5/mlx5_rx.c
@@ -1051,7 +1051,7 @@ mlx5_rx_burst(void *dpdk_rxq, struct rte_mbuf **pkts, uint16_t pkts_n)
int len = 0; /* keep its value across iterations. */
while (pkts_n) {
- uint16_t skip_cnt;
+ uint16_t skip_cnt = 0;
unsigned int idx = rq_ci & wqe_mask;
volatile struct mlx5_wqe_data_seg *wqe =
&((volatile struct mlx5_wqe_data_seg *)rxq->wqes)[idx];
@@ -1497,7 +1497,7 @@ mlx5_rx_burst_mprq(void *dpdk_rxq, struct rte_mbuf **pkts, uint16_t pkts_n)
uint16_t strd_cnt;
uint16_t strd_idx;
uint32_t byte_cnt;
- uint16_t skip_cnt;
+ uint16_t skip_cnt = 0;
volatile struct mlx5_mini_cqe8 *mcqe = NULL;
enum mlx5_rqx_code rxq_code;
--
2.47.3
^ permalink raw reply related
* Re: [PATCH dpdk v4] net: fix VLAN packet type
From: Kevin Traynor @ 2026-05-15 11:17 UTC (permalink / raw)
To: David Marchand, Robin Jarry
Cc: dev, Gregory Etelson, stable, Thomas Monjalon, Luca Boccassi
In-Reply-To: <CAJFAV8yAhr-iXkn6JvderT_Yy4rB91LVWqYvwRqJH0DdmNkJ1g@mail.gmail.com>
On 4/25/26 10:40 AM, David Marchand wrote:
> On Thu, 23 Apr 2026 at 13:25, Robin Jarry <rjarry@redhat.com> wrote:
>> diff --git a/lib/net/rte_net.c b/lib/net/rte_net.c
>> index 458b4814a9c9..a871318b21c2 100644
>> --- a/lib/net/rte_net.c
>> +++ b/lib/net/rte_net.c
>> @@ -357,12 +357,14 @@ uint32_t rte_net_get_ptype(const struct rte_mbuf *m,
>> const struct rte_vlan_hdr *vh;
>> struct rte_vlan_hdr vh_copy;
>>
>> + if (vlan_depth == 0) {
>> + pkt_type =
>> + proto == rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN) ?
>> + RTE_PTYPE_L2_ETHER_VLAN :
>> + RTE_PTYPE_L2_ETHER_QINQ;
>> + }
>
> This code is becoming too complex.
> The original usecase with more than 2 stacked vlan is a bit strange,
> but the max depth limit seems just arbitrary (why 8?).
> We have clear boundaries, with the size of the packet (see below,
> check on vh == NULL).
>
> The offending commit also allows stacking mpls on top of vlan, without
> mentioning it.
> I think we want this behavior, but still was it intended?
>
> In the end, reverting the previous fix then just advancing off and
> breaking once proto is not a vlan/qinq type gives a much simpler fix
> when compared to v25.11.
>
> (ignoring indent changes with -w)
>
> $ git diff -w v25.11 lib/net/rte_net.c
> diff --git a/lib/net/rte_net.c b/lib/net/rte_net.c
> index c70b57fdc0..f58d699c83 100644
> --- a/lib/net/rte_net.c
> +++ b/lib/net/rte_net.c
> @@ -349,30 +349,28 @@ uint32_t rte_net_get_ptype(const struct rte_mbuf *m,
> if (proto == rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4))
> goto l3; /* fast path if packet is IPv4 */
>
> - if (proto == rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN)) {
> + if (proto == rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN) ||
> + proto == rte_cpu_to_be_16(RTE_ETHER_TYPE_QINQ)) {
> const struct rte_vlan_hdr *vh;
> struct rte_vlan_hdr vh_copy;
>
> + if (proto == rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN))
> pkt_type = RTE_PTYPE_L2_ETHER_VLAN;
> + else
> + pkt_type = RTE_PTYPE_L2_ETHER_QINQ;
> +
> + do {
> vh = rte_pktmbuf_read(m, off, sizeof(*vh), &vh_copy);
> if (unlikely(vh == NULL))
> return pkt_type;
> off += sizeof(*vh);
> hdr_lens->l2_len += sizeof(*vh);
> proto = vh->eth_proto;
> - } else if (proto == rte_cpu_to_be_16(RTE_ETHER_TYPE_QINQ)) {
> - const struct rte_vlan_hdr *vh;
> - struct rte_vlan_hdr vh_copy;
> + } while (proto == rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN) ||
> + proto == rte_cpu_to_be_16(RTE_ETHER_TYPE_QINQ));
> + }
>
> - pkt_type = RTE_PTYPE_L2_ETHER_QINQ;
> - vh = rte_pktmbuf_read(m, off + sizeof(*vh), sizeof(*vh),
> - &vh_copy);
> - if (unlikely(vh == NULL))
> - return pkt_type;
> - off += 2 * sizeof(*vh);
> - hdr_lens->l2_len += 2 * sizeof(*vh);
> - proto = vh->eth_proto;
> - } else if ((proto == rte_cpu_to_be_16(RTE_ETHER_TYPE_MPLS)) ||
> + if ((proto == rte_cpu_to_be_16(RTE_ETHER_TYPE_MPLS)) ||
> (proto == rte_cpu_to_be_16(RTE_ETHER_TYPE_MPLSM))) {
> unsigned int i;
> const struct rte_mpls_hdr *mh;
>
>
> This is untested, but what do you think?
>
>
This version LGTM. Maybe we should consider returning NULL on invalid
packets
^ permalink raw reply
* Re: 23.11.7 patches review and test
From: Kevin Traynor @ 2026-05-15 10:31 UTC (permalink / raw)
To: Luca Boccassi, Shani Peretz
Cc: stable, dev, Robin Jarry, David Marchand, Thomas Monjalon
In-Reply-To: <f27bd211-66c0-4a87-9d11-de6d83cae4c9@redhat.com>
On 4/30/26 12:02 PM, Kevin Traynor wrote:
> On 4/30/26 10:58 AM, Thomas Monjalon wrote:
>> 30/04/2026 11:32, Kevin Traynor:
>>> On 4/21/26 7:46 AM, Shani Peretz wrote:
>>>> The planned date for the final release is 30 April 2026.
>>>
>>> As discussed on thread [0] there was a quite serious regression caused
>>> by "net: fix packet type for stacked VLAN"
>>>
>>> As discussion on the fix is ongoing, I would suggest to just revert this
>>> patch for your release.
>>
>> I agree the revert is the best option here.
>>
>>> It doesn't require a new RC and re-validation as it's an isolated issue
>>> (and there wasn't test cases to catch before Robin's new patch anyway)
>>
>> I suppose 24.11.5 and 25.11.1 are also impacted?
>>
>>
>
> Yes, I was hoping we would have a fix in a few days and we could add and
> re-release. Given that there's now discussion on the patch and what
> functionality is needed, it's probably best to just revert and release a
> new 24.11/25.11.
Hi Luca. Are you planning to do a 24.11 release with revert for above
issue ? If you have a time issue, let me know and I can help out.
^ permalink raw reply
* [PATCH 0/1] crypto/zsda: update product name and maintainer
From: Chengfei Han @ 2026-05-15 8:12 UTC (permalink / raw)
To: dev; +Cc: ran.ming, Chengfei Han
[-- Attachment #1.1.1: Type: text/plain, Size: 463 bytes --]
*** BLURB HERE ***
This patch updates the ZSDA PMD driver:
- Correct product name from '1cf2' to 'Neo X510/X512' in documentation
- Update maintainer for ZTE Storage Data Accelerator (ZSDA)
Chengfei Han (1):
crypto/zsda: Update product name and maintainer
MAINTAINERS | 3 ++-
doc/guides/compressdevs/zsda.rst | 3 +--
doc/guides/cryptodevs/zsda.rst | 3 +--
3 files changed, 4 insertions(+), 5 deletions(-)
--
2.27.0
[-- Attachment #1.1.2: Type: text/html , Size: 949 bytes --]
^ permalink raw reply
* [PATCH 1/1] crypto/zsda: Update product name and maintainer
From: Chengfei Han @ 2026-05-15 8:12 UTC (permalink / raw)
To: dev; +Cc: ran.ming, Chengfei Han
In-Reply-To: <20260515081212.3565572-1-han.chengfei@zte.com.cn>
[-- Attachment #1.1.1: Type: text/plain, Size: 1826 bytes --]
Correct product name from '1cf2' to 'Neo X510/X512' in PMD documentation.
Update maintainer for ZTE Storage Data Accelerator (ZSDA)
Signed-off-by: Chengfei Han <han.chengfei@zte.com.cn>
---
MAINTAINERS | 3 ++-
doc/guides/compressdevs/zsda.rst | 3 +--
doc/guides/cryptodevs/zsda.rst | 3 +--
3 files changed, 4 insertions(+), 5 deletions(-)
diff --git a/MAINTAINERS b/MAINTAINERS
index 0f5539f851..7f30205b24 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1352,7 +1352,8 @@ F: doc/guides/compressdevs/zlib.rst
F: doc/guides/compressdevs/features/zlib.ini
ZTE Storage Data Accelerator (ZSDA)
-M: Hanxiao Li <li.hanxiao@zte.com.cn>
+M: Chengfei Han <han.chengfei@zte.com.cn>
+M: Ming Ran <ran.ming@zte.com.cn>
F: drivers/common/zsda/
F: drivers/compress/zsda/
F: doc/guides/compressdevs/zsda.rst
diff --git a/doc/guides/compressdevs/zsda.rst b/doc/guides/compressdevs/zsda.rst
index 25b7884535..5b8d4846a0 100644
--- a/doc/guides/compressdevs/zsda.rst
+++ b/doc/guides/compressdevs/zsda.rst
@@ -7,8 +7,7 @@ ZTE Storage Data Accelerator (ZSDA) Poll Mode Driver
The ZSDA compression PMD provides poll mode compression & decompression driver
support for the following hardware accelerator devices:
-* ZTE Processing accelerators 1cf2
-
+- Neo X510/X512
Features
--------
diff --git a/doc/guides/cryptodevs/zsda.rst b/doc/guides/cryptodevs/zsda.rst
index b024f537c1..8885663e9e 100644
--- a/doc/guides/cryptodevs/zsda.rst
+++ b/doc/guides/cryptodevs/zsda.rst
@@ -7,8 +7,7 @@ ZTE Storage Data Accelerator (ZSDA) Poll Mode Driver
The ZSDA crypto PMD provides poll mode Cipher and Hash driver
support for the following hardware accelerator devices:
-* ZTE Processing accelerators 1cf2
-
+- Neo X510/X512
Features
--------
--
2.27.0
[-- Attachment #1.1.2: Type: text/html , Size: 3054 bytes --]
^ permalink raw reply related
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox