Skip to contentSkip to conversation

Fix i40e/ice/iavf VF bonding after netdev lock changes

PATCH Superseded Jose Ignacio Tornos Martinez 4 participants 11 messages Jun 19 – Jun 23

Subsystems (4)

v6 of 7 Superseded Latest is v7 →

lore
Share & tools
lore
#0 lore raw

v6 cover Fix i40e/ice/iavf VF bonding after netdev lock changes

This series fixes VF bonding failures introduced by commit ad7c7b2172c3 ("net: hold netdev instance lock during sysfs operations").

When adding VFs to a bond immediately after setting trust mode, MAC address changes fail with -EAGAIN, preventing bonding setup. This affects both i40e (700-series) and ice (800-series) Intel NICs.

The core issue is lock contention: iavf_set_mac() is now called with the netdev lock held and waits for MAC change completion while holding it. However, both the watchdog task that sends the request and the adminq_task that processes PF responses also need this lock, creating a deadlock where neither can run, causing timeouts.

Additionally, setting VF trust triggers an unnecessary ~10 second VF reset in i40e driver that delays bonding setup, even though filter synchronization happens naturally during normal VF operation. For ice driver, the delay is not so big, but in the same way the operation is not necessary.

This series:
1. Adds safety guard to prevent MAC changes during reset or early initialization (before VF is ready)
2. Eliminates unnecessary VF reset when setting trust in i40e (reset only if revoking trust and VF has advanced features configured).
3. Fixes lock contention by polling admin queue synchronously
4. Eliminates unnecessary VF reset when setting trust in ice, (reset only if revoking trust and VF has advanced features configured).

The key fix (patch 3/4) implements a synchronous MAC change operation similar to the approach used for ndo_change_mtu deadlock fix:
https://lore.kernel.org/intel-wired-lan/[email protected]/
Instead of scheduling work and waiting, it:

- Sends the virtchnl message directly (not via watchdog)
- Polls the admin queue hardware directly for responses
- Processes all messages inline (including non-MAC messages)
- Returns when complete or times out

This allows the operation to complete synchronously while holding netdev_lock, without relying on watchdog or adminq_task.

The function can sleep for up to 2.5 seconds polling hardware, but this is acceptable since netdev_lock is per-device and only serializes operations on the same interface.

Testing shows VF bonding now works reliably in ~5 seconds vs 15+ seconds before (i40e), without timeouts or errors (i40e and ice).

Tested on Intel 700-series (i40e) and 800-series (ice) dual-port NICs with iavf driver.

Thanks to Jan Tluka <[email protected]> and Yuying Ma <[email protected]> for reporting the issues.

Jose Ignacio Tornos Martinez (4):
iavf: return EBUSY if reset in progress or not ready during MAC change
i40e: skip unnecessary VF reset when setting trust
iavf: send MAC change request synchronously
ice: skip unnecessary VF reset when setting trust

All patches tested successfully with bonding setup.
---
v6:
- Patch 1/4 (iavf EBUSY): No changes from v5
- Patch 2/4 (i40e trust): No code changes from v5. AI review comments covered design decisions and pre-existing issues, no bugs found in new code.
- Patch 3/4 (iavf sync MAC): Address edge cases from AI review (Jakub Kicinski)
- Allocate event buffer before sending to avoid state mismatch if allocation fails after message is sent to PF
- Add loop to send all batches before polling (rare multi-batch scenario)
- Conditional rollback: only rollback on send failure (ret != -EAGAIN), not on timeout where PF will eventually respond
- Patch 4/4 (ice trust): Revert to original reset pattern based on AI review
- AI review identified issues with v5's reset-before-cleanup approach (privilege bit not cleared, LLDP cleanup loop became dead code)
- Restore proven cleanup → set trust → reset pattern from original code
- Simpler implementation, no save/restore complexity
- Maintains same goal: skip reset when VF has no advanced features
v5: https://lore.kernel.org/all/[email protected]/

 drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c |  38 ++++++++++++++++++++++++++++----------
 drivers/net/ethernet/intel/iavf/iavf.h             |  10 ++++++++--
 drivers/net/ethernet/intel/iavf/iavf_main.c        |  71 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---------
 drivers/net/ethernet/intel/iavf/iavf_virtchnl.c    | 103 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++----------
 drivers/net/ethernet/intel/ice/ice_sriov.c         |  33 +++++++++++++++++++++++++++++----
 5 files changed, 220 insertions(+), 35 deletions(-)

--
2.43.0

#1 lore raw

PATCH v6 1/4 iavf: return EBUSY if reset in progress or not ready during MAC change

When a MAC address change is requested while the VF is resetting or still initializing, return -EBUSY immediately instead of attempting the operation.

Additionally, during early initialization states (before __IAVF_DOWN), the PF may be slow to respond to MAC change requests, causing long delays. Only allow MAC changes once the VF reaches __IAVF_DOWN state or later, when the watchdog is running and the VF is ready for operations.

After commit ad7c7b2172c3 ("net: hold netdev instance lock during sysfs operations"), MAC changes are called with the netdev lock held, so we should not wait with the lock held during reset or initialization. This allows the caller to retry or handle the busy state appropriately without blocking other operations.

---

 drivers/net/ethernet/intel/iavf/iavf_main.c | 3 +++
 1 file changed, 3 insertions(+)
drivers/net/ethernet/intel/iavf/iavf_main.c +3 -0
index dad001abc908..67aa14350b1b 100644
@@ -1060,6 +1060,9 @@ static int iavf_set_mac(struct net_device *netdev, void *p)
 	struct sockaddr *addr = p;
 	int ret;
 
+	if (iavf_is_reset_in_progress(adapter) || adapter->state < __IAVF_DOWN)
+		return -EBUSY;
+
 	if (!is_valid_ether_addr(addr->sa_data))
 		return -EADDRNOTAVAIL;
 
Signature · 1 line
2.53.0
#2 lore raw

PATCH v6 2/4 i40e: skip unnecessary VF reset when setting trust

In reply to Jose Ignacio Tornos Martinez

The current implementation triggers a VF reset when changing the trust setting, causing a ~10 second delay during bonding setup.

In all the cases, the reset causes a ~10 second delay during which:
- VF must reinitialize completely
- Any in-progress operations (like bonding enslave) fail with timeouts
- VF is unavailable

When granting trust, no reset is needed - we can just set the capability flag to allow privileged operations.

When revoking trust, we only need to reset (conservative approach) if the VF has actually configured advanced features that require cleanup (ADQ/cloud filters, promiscuous mode). For VFs in a clean state, we can safely change the trust setting without the disruptive reset.

When we don't reset, we manually handle capability flag via helper function, eliminating the delay.

---
v6: No changes from v5. AI review comments covered design decisions
(over-limit filter handling, synchronization model) and pre-existing issues, but found no bugs in the new code.
v5: https://lore.kernel.org/all/[email protected]/

 .../ethernet/intel/i40e/i40e_virtchnl_pf.c    | 38 ++++++++++++++-----
 1 file changed, 28 insertions(+), 10 deletions(-)
drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c +28 -10
index a26c3d47ec15..0cc434b26eb8 100644
@@ -4943,6 +4943,23 @@ int i40e_ndo_set_vf_spoofchk(struct net_device *netdev, int vf_id, bool enable)
 	return ret;
 }
 
+/**
+ * i40e_setup_vf_trust - Enable/disable VF trust mode without reset
+ * @vf: VF to configure
+ * @setting: trust setting
+ *
+ * Update VF flags when changing trust without performing a VF reset.
+ * This is only called when it's safe to skip the reset (VF has no advanced
+ * features configured that need cleanup).
+ */
+static void i40e_setup_vf_trust(struct i40e_vf *vf, bool setting)
+{
+	if (setting)
+		set_bit(I40E_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps);
+	else
+		clear_bit(I40E_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps);
+}
+
 /**
  * i40e_ndo_set_vf_trust
  * @netdev: network interface device structure of the pf
@@ -4987,19 +5004,20 @@ int i40e_ndo_set_vf_trust(struct net_device *netdev, int vf_id, bool setting)
 	set_bit(__I40E_MACVLAN_SYNC_PENDING, pf->state);
 	pf->vsi[vf->lan_vsi_idx]->flags |= I40E_VSI_FLAG_FILTER_CHANGED;
 
-	i40e_vc_reset_vf(vf, true);
+	/* Reset only if revoking trust and VF has advanced features configured */
+	if (!setting &&
+	    (vf->adq_enabled || vf->num_cloud_filters > 0 ||
+	     test_bit(I40E_VF_STATE_UC_PROMISC, &vf->vf_states) ||
+	     test_bit(I40E_VF_STATE_MC_PROMISC, &vf->vf_states))) {
+		i40e_vc_reset_vf(vf, true);
+		i40e_del_all_cloud_filters(vf);
+	} else {
+		i40e_setup_vf_trust(vf, setting);
+	}
+
 	dev_info(&pf->pdev->dev, "VF %u is now %strusted\n",
 		 vf_id, setting ? "" : "un");
 
-	if (vf->adq_enabled) {
-		if (!vf->trusted) {
-			dev_info(&pf->pdev->dev,
-				 "VF %u no longer Trusted, deleting all cloud filters\n",
-				 vf_id);
-			i40e_del_all_cloud_filters(vf);
-		}
-	}
-
 out:
 	clear_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state);
 	return ret;
Signature · 1 line
2.53.0
#3 lore raw

PATCH v6 3/4 iavf: send MAC change request synchronously

In reply to Jose Ignacio Tornos Martinez

After commit ad7c7b2172c3 ("net: hold netdev instance lock during sysfs operations"), iavf_set_mac() is called with the netdev instance lock already held.

The function queues a MAC address change request via iavf_replace_primary_mac() and then waits for completion. However, in the current flow, the actual virtchnl message is sent by the watchdog task, which also needs to acquire the netdev lock to run. Additionally, the adminq_task which processes virtchnl responses also needs the netdev lock.

This creates a deadlock scenario:
1. iavf_set_mac() holds netdev lock and waits for MAC change
2. Watchdog needs netdev lock to send the request -> blocked
3. Even if request is sent, adminq_task needs netdev lock to process PF response -> blocked
4. MAC change times out after 2.5 seconds
5. iavf_set_mac() returns -EAGAIN

This particularly affects VFs during bonding setup when multiple VFs are enslaved in quick succession.

Fix by implementing a synchronous MAC change operation similar to the approach used in commit fdadbf6e84c4 ("iavf: fix incorrect reset handling in callbacks").

The solution:
1. Send the virtchnl ADD_ETH_ADDR message directly (not via watchdog)
2. Poll the admin queue hardware directly for responses
3. Process all received messages (including non-MAC messages)
4. Return when MAC change completes or times out

A new generic function iavf_poll_virtchnl_response() is introduced that can be reused for any future synchronous virtchnl operations. It takes a callback to check completion, allowing flexible condition checking.

This allows the operation to complete synchronously while holding netdev_lock, without relying on watchdog or adminq_task. The function can sleep for up to 2.5 seconds polling hardware, but this is acceptable since netdev_lock is per-device and only serializes operations on the same interface.

To support this, change iavf_add_ether_addrs() to return an error code instead of void, allowing callers to detect failures. Additionally, export iavf_mac_add_reject() to enable proper rollback on local failures (timeouts, send errors) - PF rejections are already handled automatically by iavf_virtchnl_completion().

Remove vc_waitqueue entirely because iavf_set_mac was the only waiter on this waitqueue and after the changes it is not needed.

Fixes ad7c7b2172c3 ("net: hold netdev instance lock during sysfs operations")

---
v6: Address edge cases found by AI review (Jakub Kicinski):
Although unlikely in practice, v6 adds robustness for corner cases:
- Allocation failure after message sent: allocate event buffer BEFORE sending to PF (theoretical - allocation rarely fails for small buffers)
- Multi-batch scenario: add loop to send all batches when >200 MACs pending (rare - most configurations have far fewer MACs)
- Timeout rollback: only rollback on send failure (ret != -EAGAIN), not on timeout where PF response handler will sync state (transient inconsistency during timeout is acceptable and will be resolved by response)
v5: https://lore.kernel.org/all/[email protected]/

 drivers/net/ethernet/intel/iavf/iavf.h        | 11 ++-
 drivers/net/ethernet/intel/iavf/iavf_main.c   | 91 +++++++++++++----
 .../net/ethernet/intel/iavf/iavf_virtchnl.c   | 99 +++++++++++++++++--
 3 files changed, 171 insertions(+), 30 deletions(-)
drivers/net/ethernet/intel/iavf/iavf.h +9 -2
index e9fb0a0919e3..c154fe7c8ce9 100644
@@ -260,7 +260,6 @@ struct iavf_adapter {
 	struct work_struct adminq_task;
 	struct work_struct finish_config;
 	wait_queue_head_t down_waitqueue;
-	wait_queue_head_t vc_waitqueue;
 	struct iavf_q_vector *q_vectors;
 	struct list_head vlan_filter_list;
 	int num_vlan_filters;
@@ -589,8 +588,9 @@ void iavf_configure_queues(struct iavf_adapter *adapter);
 void iavf_enable_queues(struct iavf_adapter *adapter);
 void iavf_disable_queues(struct iavf_adapter *adapter);
 void iavf_map_queues(struct iavf_adapter *adapter);
-void iavf_add_ether_addrs(struct iavf_adapter *adapter);
+int iavf_add_ether_addrs(struct iavf_adapter *adapter);
 void iavf_del_ether_addrs(struct iavf_adapter *adapter);
+void iavf_mac_add_reject(struct iavf_adapter *adapter);
 void iavf_add_vlans(struct iavf_adapter *adapter);
 void iavf_del_vlans(struct iavf_adapter *adapter);
 void iavf_set_promiscuous(struct iavf_adapter *adapter);
@@ -607,6 +607,13 @@ void iavf_disable_vlan_stripping(struct iavf_adapter *adapter);
 void iavf_virtchnl_completion(struct iavf_adapter *adapter,
 			      enum virtchnl_ops v_opcode,
 			      enum iavf_status v_retval, u8 *msg, u16 msglen);
+int iavf_poll_virtchnl_response(struct iavf_adapter *adapter,
+				struct iavf_arq_event_info *event,
+				bool (*condition)(struct iavf_adapter *adapter,
+						  const void *data,
+						  enum virtchnl_ops v_op),
+				const void *cond_data,
+				unsigned int timeout_ms);
 int iavf_config_rss(struct iavf_adapter *adapter);
 void iavf_cfg_queues_bw(struct iavf_adapter *adapter);
 void iavf_cfg_queues_quanta_size(struct iavf_adapter *adapter);
drivers/net/ethernet/intel/iavf/iavf_main.c +73 -18

113 lines not on this page · raw message

drivers/net/ethernet/intel/iavf/iavf_virtchnl.c +89 -10

163 lines not on this page · raw message

Signature · 1 line
2.54.0
maintainer
#4 lore raw

Re: [PATCH net v6 3/4] iavf: send MAC change request synchronously

[-Jesse, he moved to another company a while ago]

Quoted 16 lines

v6: Address edge cases found by AI review (Jakub Kicinski):
Although unlikely in practice, v6 adds robustness for corner cases:
- Allocation failure after message sent: allocate event buffer BEFORE sending to PF (theoretical - allocation rarely fails for small buffers)
- Multi-batch scenario: add loop to send all batches when >200 MACs pending (rare - most configurations have far fewer MACs)
- Timeout rollback: only rollback on send failure (ret != -EAGAIN), not on timeout where PF response handler will sync state (transient inconsistency during timeout is acceptable and will be resolved by response)
v5: https://lore.kernel.org/all/[email protected]/

  drivers/net/ethernet/intel/iavf/iavf.h        | 11 ++-
  drivers/net/ethernet/intel/iavf/iavf_main.c   | 91 +++++++++++++----
  .../net/ethernet/intel/iavf/iavf_virtchnl.c   | 99 +++++++++++++++++--
  3 files changed, 171 insertions(+), 30 deletions(-)

[...]

Quoted 7 lines
drivers/net/ethernet/intel/iavf/iavf_main.c +7 -0
+static bool iavf_mac_change_done(struct iavf_adapter *adapter,
+				 const void *data, enum virtchnl_ops v_op)
+{
+	const u8 *addr = data;
+
+	return iavf_is_mac_set_handled(adapter->netdev, addr);
+}

[...]

Quoted 4 lines
drivers/net/ethernet/intel/iavf/iavf_main.c +4 -0
+static int iavf_set_mac_sync(struct iavf_adapter *adapter, const u8 *addr)
+{
+	struct iavf_arq_event_info event;
+	int ret;

drivers/net/ethernet/intel/iavf/iavf_main.c static bool iavf_is_mac_set_handled(struct net_device *netdev, · line 1097

Quoted 10 lines
drivers/net/ethernet/intel/iavf/iavf_main.c +10 -0
+
+	netdev_assert_locked(adapter->netdev);
+
+	event.buf_len = IAVF_MAX_AQ_BUF_SIZE;
+	event.msg_buf = kzalloc(event.buf_len, GFP_KERNEL);
+	if (!event.msg_buf)
+		return -ENOMEM;
+
+	while (adapter->aq_required & IAVF_FLAG_AQ_ADD_MAC_FILTER) {
+		ret = iavf_add_ether_addrs(adapter);

I believe that this change (made in v6) is wrong. (just an observation: AI review made this series worse vs v5).

the second step onward would fail a check:
"if (adapter->current_op != VIRTCHNL_OP_UNKNOWN)" and thus return -EBUSY

watchdog would not kick the VC/AQ queue since we hold the netdev lock here, there is need to manually ensure forward progress by calling iavf_poll_virtchnl_response() within the loop

I think it should be fine to stop when the "iavf_mac_change_done" condition is met, this will simply leave the rest of the changes for watchdog (as we do now).

Quoted 11 lines
drivers/net/ethernet/intel/iavf/iavf_main.c +11 -0
+		if (ret)
+			goto out;
+	}
+
+	ret = iavf_poll_virtchnl_response(adapter, &event,
+					  iavf_mac_change_done, addr, 2500);
+
+out:
+	kfree(event.msg_buf);
+	return ret;
+}
#5 lore raw

Re: [Intel-wired-lan] [PATCH net v6 3/4] iavf: send MAC change request synchronously

Hello,

Thank you for catching this.
You're absolutely right - the loop can't work without polling between iterations since the second call would hit the current_op check and return -EBUSY. I will remove the multi-batch loop and revert this to v5's approach.

v7 will be posted shortly with these changes.

Thanks

Best regards
José Ignacio

#6 lore raw

PATCH v6 4/4 ice: skip unnecessary VF reset when setting trust

In reply to Jose Ignacio Tornos Martinez

Similar to the i40e fix, ice_set_vf_trust() unconditionally calls ice_reset_vf() when the trust setting changes. While the delay is smaller than i40e, this reset is still unnecessary in most cases.

When granting trust, no reset is needed - we can just set the capability flag to allow privileged operations.

When revoking trust, we only need to reset (conservative approach) if the VF has actually configured advanced features that require cleanup (MAC LLDP filters, promiscuous mode). For VFs in a clean state, we can safely change the trust setting without the disruptive reset.

When we do reset, we maintain the original ice pattern that has been reliable in production: cleanup LLDP filters first, then set vf->trusted, then reset. This ensures the privilege capability bit is handled correctly during reset rebuild.

When we don't reset, we manually handle the capability flag via helper function, eliminating the delay.

---
v6: AI review identified issues with v5's reset-before-cleanup approach. Revert
to original reset procedure (cleanup before reset) which has proven reliable, just adding the conditional check to skip reset when VF has no advanced features configured.
v5: https://lore.kernel.org/all/[email protected]/

 drivers/net/ethernet/intel/ice/ice_sriov.c | 33 +++++++++++++++++++---
 1 file changed, 29 insertions(+), 4 deletions(-)
drivers/net/ethernet/intel/ice/ice_sriov.c +30 -5
index 7e00e091756d..XXXXXXXXXXXXXXXX 100644
@@ -1364,6 +1364,23 @@ int ice_set_vf_mac(struct net_device *netdev, int vf_id, u8 *mac)
 	return __ice_set_vf_mac(ice_netdev_to_pf(netdev), vf_id, mac);
 }
 
+/**
+ * ice_setup_vf_trust - Enable/disable VF trust mode without reset
+ * @vf: VF to configure
+ * @setting: trust setting
+ *
+ * Update VF flags when changing trust without performing a VF reset.
+ * This is only called when it's safe to skip the reset (VF has no advanced
+ * features configured that need cleanup).
+ */
+static void ice_setup_vf_trust(struct ice_vf *vf, bool setting)
+{
+	if (setting)
+		set_bit(ICE_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps);
+	else
+		clear_bit(ICE_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps);
+}
+
 /**
  * ice_set_vf_trust
  * @netdev: network interface device structure
@@ -1399,11 +1416,19 @@ int ice_set_vf_trust(struct net_device *netdev, int vf_id, bool trusted)
 
 	mutex_lock(&vf->cfg_lock);
 
-	while (!trusted && vf->num_mac_lldp)
-		ice_vf_update_mac_lldp_num(vf, ice_get_vf_vsi(vf), false);
-
+	/* Reset only if revoking trust and VF has advanced features configured */
+	if (!trusted &&
+	    (vf->num_mac_lldp > 0 ||
+	     test_bit(ICE_VF_STATE_UC_PROMISC, vf->vf_states) ||
+	     test_bit(ICE_VF_STATE_MC_PROMISC, vf->vf_states))) {
+		while (vf->num_mac_lldp)
+			ice_vf_update_mac_lldp_num(vf, ice_get_vf_vsi(vf), false);
+		vf->trusted = trusted;
+		ice_reset_vf(vf, ICE_VF_RESET_NOTIFY);
+	} else {
+		vf->trusted = trusted;
+		ice_setup_vf_trust(vf, trusted);
+	}
-	vf->trusted = trusted;
-	ice_reset_vf(vf, ICE_VF_RESET_NOTIFY);
 	dev_info(ice_pf_to_dev(pf), "VF %u is now %strusted\n",
 		 vf_id, trusted ? "" : "un");
 

--
2.43.0

Reviewed-by on v6 4/4
#7 lore raw

RE: [PATCH net v6 4/4] ice: skip unnecessary VF reset when setting trust

Quoted 113 lines

-----Original Message-----
From: Jose Ignacio Tornos Martinez <[email protected]>
Sent: Friday, June 19, 2026 8:13 AM
To: [email protected]
Cc: [email protected]; Kitszel, Przemyslaw <[email protected]>; Loktionov, Aleksandr <[email protected]>; Keller, Jacob E <[email protected]>; [email protected]; [email protected]; Nguyen, Anthony L <[email protected]>; [email protected]; [email protected]; [email protected]; [email protected]; Jose Ignacio Tornos Martinez <[email protected]>
Subject: [PATCH net v6 4/4] ice: skip unnecessary VF reset when setting trust

Similar to the i40e fix, ice_set_vf_trust() unconditionally calls ice_reset_vf() when the trust setting changes. While the delay is smaller than i40e, this reset is still unnecessary in most cases.

When granting trust, no reset is needed - we can just set the capability flag to allow privileged operations.

When revoking trust, we only need to reset (conservative approach) if the VF has actually configured advanced features that require cleanup (MAC LLDP filters, promiscuous mode). For VFs in a clean state, we can safely change the trust setting without the disruptive reset.

When we do reset, we maintain the original ice pattern that has been reliable in production: cleanup LLDP filters first, then set vf-

Quoted 1 line

trusted, then reset. This ensures the privilege capability bit is

handled correctly during reset rebuild.

When we don't reset, we manually handle the capability flag via helper function, eliminating the delay.

---
v6: AI review identified issues with v5's reset-before-cleanup approach. Revert
to original reset procedure (cleanup before reset) which has
proven reliable,
just adding the conditional check to skip reset when VF has no
advanced
features configured.
v5: https://lore.kernel.org/all/20260429102426.210750-5-
[email protected]/

 drivers/net/ethernet/intel/ice/ice_sriov.c | 33 +++++++++++++++++++--
(quoted diff) +0 -1
-
 1 file changed, 29 insertions(+), 4 deletions(-)
drivers/net/ethernet/intel/ice/ice_sriov.c +16 -0
index 7e00e091756d..XXXXXXXXXXXXXXXX 100644
@@ -1364,6 +1364,23 @@ int ice_set_vf_mac(struct net_device *netdev,
 int vf_id, u8 *mac)
 	return __ice_set_vf_mac(ice_netdev_to_pf(netdev), vf_id, mac);
 }
 
+/**
+ * ice_setup_vf_trust - Enable/disable VF trust mode without reset
+ * @vf: VF to configure
+ * @setting: trust setting
+ *
+ * Update VF flags when changing trust without performing a VF reset.
+ * This is only called when it's safe to skip the reset (VF has no
+advanced
+ * features configured that need cleanup).
+ */
+static void ice_setup_vf_trust(struct ice_vf *vf, bool setting) {
+	if (setting)
+		set_bit(ICE_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps);
+	else
+		clear_bit(ICE_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps);
 }
+
 /**
  * ice_set_vf_trust
  * @netdev: network interface device structure @@ -1399,11 +1416,19

@@ int ice_set_vf_trust(struct net_device *netdev, int vf_id, bool trusted)

drivers/net/ethernet/intel/ice/ice_sriov.c +0 -2
 	mutex_lock(&vf->cfg_lock);
 
-	while (!trusted && vf->num_mac_lldp)
-		ice_vf_update_mac_lldp_num(vf, ice_get_vf_vsi(vf),

false);

drivers/net/ethernet/intel/ice/ice_sriov.c +1 -1
-
+	/* Reset only if revoking trust and VF has advanced features

configured */

drivers/net/ethernet/intel/ice/ice_sriov.c +6 -0
+	if (!trusted &&
+	    (vf->num_mac_lldp > 0 ||
+	     test_bit(ICE_VF_STATE_UC_PROMISC, vf->vf_states) ||
+	     test_bit(ICE_VF_STATE_MC_PROMISC, vf->vf_states))) {
+		while (vf->num_mac_lldp)
+			ice_vf_update_mac_lldp_num(vf,

ice_get_vf_vsi(vf), false);

drivers/net/ethernet/intel/ice/ice_sriov.c +6 -3
+		vf->trusted = trusted;
+		ice_reset_vf(vf, ICE_VF_RESET_NOTIFY);
+	} else {
+		vf->trusted = trusted;
+		ice_setup_vf_trust(vf, trusted);
+	}
-	vf->trusted = trusted;
-	ice_reset_vf(vf, ICE_VF_RESET_NOTIFY);
 	dev_info(ice_pf_to_dev(pf), "VF %u is now %strusted\n",
 		 vf_id, trusted ? "" : "un");
 
--
Quoted 1 line

2.43.0

Reviewed-by on v6 4/4
#8 lore raw

RE: [PATCH net v6 4/4] ice: skip unnecessary VF reset when setting trust

In reply to Jose Ignacio Tornos Martinez
Quoted 113 lines

-----Original Message-----
From: Jose Ignacio Tornos Martinez <[email protected]>
Sent: Friday, June 19, 2026 8:13 AM
To: [email protected]
Cc: [email protected]; Kitszel, Przemyslaw <[email protected]>; Loktionov, Aleksandr <[email protected]>; Keller, Jacob E <[email protected]>; [email protected]; [email protected]; Nguyen, Anthony L <[email protected]>; [email protected]; [email protected]; [email protected]; [email protected]; Jose Ignacio Tornos Martinez <[email protected]>
Subject: [PATCH net v6 4/4] ice: skip unnecessary VF reset when setting trust

Similar to the i40e fix, ice_set_vf_trust() unconditionally calls ice_reset_vf() when the trust setting changes. While the delay is smaller than i40e, this reset is still unnecessary in most cases.

When granting trust, no reset is needed - we can just set the capability flag to allow privileged operations.

When revoking trust, we only need to reset (conservative approach) if the VF has actually configured advanced features that require cleanup (MAC LLDP filters, promiscuous mode). For VFs in a clean state, we can safely change the trust setting without the disruptive reset.

When we do reset, we maintain the original ice pattern that has been reliable in production: cleanup LLDP filters first, then set vf-

Quoted 1 line

trusted, then reset. This ensures the privilege capability bit is

handled correctly during reset rebuild.

When we don't reset, we manually handle the capability flag via helper function, eliminating the delay.

---
v6: AI review identified issues with v5's reset-before-cleanup approach. Revert
to original reset procedure (cleanup before reset) which has
proven reliable,
just adding the conditional check to skip reset when VF has no
advanced
features configured.
v5: https://lore.kernel.org/all/20260429102426.210750-5-
[email protected]/

 drivers/net/ethernet/intel/ice/ice_sriov.c | 33 +++++++++++++++++++--
(quoted diff) +0 -1
-
 1 file changed, 29 insertions(+), 4 deletions(-)
drivers/net/ethernet/intel/ice/ice_sriov.c +16 -0
index 7e00e091756d..XXXXXXXXXXXXXXXX 100644
@@ -1364,6 +1364,23 @@ int ice_set_vf_mac(struct net_device *netdev,
 int vf_id, u8 *mac)
 	return __ice_set_vf_mac(ice_netdev_to_pf(netdev), vf_id, mac);
 }
 
+/**
+ * ice_setup_vf_trust - Enable/disable VF trust mode without reset
+ * @vf: VF to configure
+ * @setting: trust setting
+ *
+ * Update VF flags when changing trust without performing a VF reset.
+ * This is only called when it's safe to skip the reset (VF has no
+advanced
+ * features configured that need cleanup).
+ */
+static void ice_setup_vf_trust(struct ice_vf *vf, bool setting) {
+	if (setting)
+		set_bit(ICE_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps);
+	else
+		clear_bit(ICE_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps);
 }
+
 /**
  * ice_set_vf_trust
  * @netdev: network interface device structure @@ -1399,11 +1416,19

@@ int ice_set_vf_trust(struct net_device *netdev, int vf_id, bool trusted)

drivers/net/ethernet/intel/ice/ice_sriov.c +0 -2
 	mutex_lock(&vf->cfg_lock);
 
-	while (!trusted && vf->num_mac_lldp)
-		ice_vf_update_mac_lldp_num(vf, ice_get_vf_vsi(vf),

false);

drivers/net/ethernet/intel/ice/ice_sriov.c +1 -1
-
+	/* Reset only if revoking trust and VF has advanced features

configured */

drivers/net/ethernet/intel/ice/ice_sriov.c +6 -0
+	if (!trusted &&
+	    (vf->num_mac_lldp > 0 ||
+	     test_bit(ICE_VF_STATE_UC_PROMISC, vf->vf_states) ||
+	     test_bit(ICE_VF_STATE_MC_PROMISC, vf->vf_states))) {
+		while (vf->num_mac_lldp)
+			ice_vf_update_mac_lldp_num(vf,

ice_get_vf_vsi(vf), false);

drivers/net/ethernet/intel/ice/ice_sriov.c +6 -3
+		vf->trusted = trusted;
+		ice_reset_vf(vf, ICE_VF_RESET_NOTIFY);
+	} else {
+		vf->trusted = trusted;
+		ice_setup_vf_trust(vf, trusted);
+	}
-	vf->trusted = trusted;
-	ice_reset_vf(vf, ICE_VF_RESET_NOTIFY);
 	dev_info(ice_pf_to_dev(pf), "VF %u is now %strusted\n",
 		 vf_id, trusted ? "" : "un");
 
--
Quoted 1 line

2.43.0

reviewer
#9 lore raw
In reply to Jose Ignacio Tornos Martinez
Quoted 2 lines · Jose Ignacio Tornos Martinez

This series fixes VF bonding failures introduced by commit ad7c7b2172c3 ("net: hold netdev instance lock during sysfs operations").

...

Hi Jose,

Unfortunately the Netdev CI was unable to apply this series cleanly against net. Would you be able to rebase and repost?

Signature · 1 line
pw-bot: changes-requested
#10 lore raw

Hello Simon,

Quoted 2 lines

Unfortunately the Netdev CI was unable to apply this series cleanly against net. Would you be able to rebase and repost?

Sure, I'll rebase on current net and send v7 shortly.

Thanks

Best regards
José Ignacio