From: 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. Signed-off-by: Jose Ignacio Tornos Martinez Tested-by: Rafal Romanowski Signed-off-by: Tony Nguyen --- Notes: All the comments below fall into pre-existing issues, concerns already addressed in previous versions and comments, out-of-scope items, or extreme edge cases. No code changes are considered necessary for a new version. Details for each comment: > [Severity: Medium] > This helper writes I40E_VIRTCHNL_VF_CAP_PRIVILEGE from the ndo (rtnl) > context. i40e_alloc_vf_res() derives the same bit from an unsynchronized > read of vf->trusted. > > If that path reads vf->trusted and is preempted before the > set_bit()/clear_bit(), can i40e_ndo_set_vf_trust() update vf->trusted and > call i40e_setup_vf_trust() in between, so the stale write lands last? That > would leave vf->trusted true with the capability bit clear, or vf->trusted > false with the bit still set. > > Before this patch the ndo always followed the vf->trusted update with > i40e_vc_reset_vf(), so the bit was recomputed from the final value of > vf->trusted. With the reset skipped, is anything left that reconciles the > two? Pre-existing race. The original code writes vf->trusted before calling i40e_vc_reset_vf() without synchronization against VFLR-initiated resets from the service task. This patch does not change the synchronization model and the race window is the same order of magnitude (a few instructions). The scenario requires a guest-initiated VFLR at the exact moment of the trust change, extremely difficult to reproduce in practice. > [Severity: High] > Does this condition need to consider the MAC and VLAN filters that the VF > was only allowed to install because it was trusted? > > Trust is checked at add time only. Nothing revalidates filters that are > already installed when the privilege bit is dropped. > > Can the __I40E_MACVLAN_SYNC_PENDING work repair this instead? Looking at > i40e_correct_vf_mac_vlan_filters() it only recomputes the VLAN id of > existing entries, so no MAC filter is deleted on trust loss. > > There is also a functional side effect: mac_add_max drops back to 18 while > i40e_count_active_filters(vsi) still reflects the trusted-era filters, so > every later VIRTCHNL_OP_ADD_ETH_ADDR from that VF fails with -EPERM, > including a re-add of its primary MAC after a guest link down/up. Same concern addressed in previous comments. Over-limit filters configured while trusted remain after trust revocation, but this is acceptable because untrusted VFs can freely delete their own MAC and VLAN filters, there are no trust checks in i40e_vc_del_mac_addr_msg() or i40e_vc_remove_vlan_msg(). The VF simply cannot add more over-limit filters. The permission check uses i40e_count_active_filters(vsi) which counts live filters, deletions reduce the count immediately. The "primary MAC re-add after link down/up" scenario does not apply: existing filters remain in place across link events. A guest-initiated VF reset cleans up everything via i40e_free_vf_res(). > [Severity: Medium] > Can this sample of VF-controlled state race with the virtchnl handlers that > write it? i40e_vc_process_vf_msg() is called from > i40e_clean_adminq_subtask() in service task context without rtnl_lock() and > without taking __I40E_VIRTCHNL_OP_PENDING, so it does not exclude this ndo. > > Does that leave an untrusted VF promiscuous indefinitely? The same ordering > appears in i40e_vc_add_cloud_filter() and i40e_vc_add_qch_msg(). Same concern addressed in previous comments. This race condition exists in the original code as well, vf->trusted is set before i40e_vc_reset_vf(), creating the same window where the VF can install privileged state while the capability bit is still set. This patch does not introduce this race, it inherits the same synchronization model. Extremely difficult to reproduce in practice. Fixing this requires changing the broader synchronization between ndo callbacks and virtchnl processing, which is beyond the scope of this patch. > [Severity: Medium] > This is a pre-existing issue and not introduced by this patch, but > i40e_vc_reset_vf() is void and can return having done nothing. > > Would calling i40e_setup_vf_trust(vf, setting) unconditionally, before the > branch, make both artifacts deterministic? Pre-existing issue not introduced by this patch, as the reviewer correctly identifies. The current structure keeps the logic clear: the else branch handles the no-reset case, the if branch delegates everything to the reset path. > [Severity: Medium] > The reset releases the ADQ channel VSIs and i40e_alloc_vf_res() re-creates > them with newly assigned seids. i40e_del_all_cloud_filters() then looks > the VSI up by the recorded seid. If the seid changed, the teardown takes > the error path and the hlist_del(), kfree(cfilter) and > vf->num_cloud_filters decrement are all skipped. Does this leak the > struct i40e_cloud_filter allocations? Pre-existing issue, the same ordering (reset before cloud filter deletion) existed in the original code. This patch restructures the control flow but preserves the same sequence. .../ethernet/intel/i40e/i40e_virtchnl_pf.c | 35 +++++++++++++------ 1 file changed, 25 insertions(+), 10 deletions(-) diff --git a/drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c b/drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c index a26c3d47ec15..c6732a24b640 100644 --- a/drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c +++ b/drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c @@ -4943,6 +4943,20 @@ 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) +{ + assign_bit(I40E_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps, setting); +} + /** * i40e_ndo_set_vf_trust * @netdev: network interface device structure of the pf @@ -4987,19 +5001,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; -- 2.47.1 From: 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") cc: stable@vger.kernel.org Signed-off-by: Jose Ignacio Tornos Martinez Reviewed-by: Przemek Kitszel Tested-by: Rafal Romanowski Signed-off-by: Tony Nguyen --- Notes: All the comments below fall into pre-existing issues, concerns already addressed in previous versions and comments, out-of-scope items, or extreme edge cases. No code changes are considered necessary for a new version. Details for each comment: > [Severity: Low] > Is the "timeouts" part accurate? iavf_poll_virtchnl_response() returns > -EAGAIN on timeout, and iavf_set_mac() explicitly skips the rollback for > that value. > > So on a timeout nothing is rolled back, which is the opposite of what the > changelog describes (and matches the in-code comment). Could the changelog > be adjusted to say send errors only? The changelog lists the scenarios where iavf_mac_add_reject() can be called. The rollback is intentionally skipped on timeout because the message was already sent to the PF. The in-code comment explains this clearly. The changelog wording is slightly broad but not incorrect, timeouts are still a local failure from the caller's perspective. > [Severity: Low] > Now that iavf_add_ether_addrs() reports -EBUSY, -ENOMEM and send failures, > should the watchdog side caller consume it too? iavf_process_aq_command() > still discards it and returns 0 unconditionally. The watchdog path is fire-and-forget by design, it retries on the next cycle. Propagating errors there would require changing the watchdog state machine, which is out of scope for this fix. The return value is only meaningful for the new synchronous caller. > [Severity: Medium] > iavf_mac_change_done() ignores v_op and looks only at filter state, while > iavf_poll_virtchnl_response() calls the predicate after every message it > processes. > > Consider setting an address that already has a filter whose earlier add > succeeded. Can an unrelated message processed by the poll loop then make > this return true before the ADD_ETH_ADDR reply arrives? Same concern addressed in previous comments. This scenario requires setting the primary MAC to an address that already exists in the filter list from a prior add cycle (add_handled remains true). This is an unusual operation. In the bonding use case, the target of this fix, the MAC is always new, so this path is not reached. Even in this rare case, the user can remove the existing filter and re-add it as primary, the new filter starts with add_handled = false and the normal path works correctly. > [Severity: Medium] > Only one batch is sent here. If the just requested primary address ends up > outside the first batch, can iavf_mac_change_done() ever become true? The > poll loop has no way to send the next batch, so this would burn the full > 2500 ms and return -EAGAIN. Already discussed with Przemek Kitszel in v7 review. The multi-batch scenario requires more than 200 pending MAC filters on a VF, which is extremely rare in practice. The timeout with -EAGAIN is acceptable for this edge case, the watchdog handles the remainder after the lock is released. > [Severity: High] > Can this rollback destroy filters that belong to a different, still > outstanding request? > > iavf_mac_add_reject() walks the whole list. One way to reach it with > ret == -EBUSY is an ADD_ETH_ADDR batch the watchdog already sent and whose > reply has not been processed yet. Should the rollback be scoped to the > address that iavf_set_mac() itself queued? Same concern addressed in previous comments. This scenario only occurs when setting the primary MAC to an address that already exists as a secondary in the filter list, an extremely rare configuration. Even if the watchdog later sends the MAC to the PF, it is harmless: the MAC is already configured on the PF, so the redundant ADD_ETH_ADDR has no adverse effect. > [Severity: Medium] > Does the -EAGAIN assumption in the comment above ("the message was sent and > PF will eventually respond") hold when IAVF_FLAG_PF_COMMS_FAILED is set? > iavf_send_pf_msg() returns success without posting anything in that case. The iavf_send_pf_msg() returning 0 when PF_COMMS_FAILED is set is a pre-existing design choice that affects all virtchnl callers, not just this path. The scenario requires the PF to be unresponsive (iavf_disable_vf() has run), the VF is non-functional at that point. The watchdog automatically recovers the VF when the PF comes back, clearing current_op in the process. > [Severity: Medium] > Is this -EBUSY reachable as a hard failure from the new caller? > > iavf_set_mac() runs with the netdev instance lock held, and the only > context that clears current_op is iavf_virtchnl_completion(). Can "ip link > set dev X address ..." or bond_enslave() now fail with -EBUSY whenever the > watchdog has a command in flight? Same concern addressed in previous comments. Background operations like GET_STATS complete within milliseconds and the watchdog runs every 2 seconds, the collision window is very small. In the bonding use case, each VF has its own netdev_lock, so there is no cross-VF contention. Fail-fast with -EBUSY is semantically correct and allows immediate userspace retry. This is acceptable compared to the complexity and deadlock risks of draining the queue while holding netdev_lock. > [Severity: Medium] > Is this helper able to roll back a filter whose is_new_mac is already > cleared? > > If iavf_set_mac_sync() fails locally before the batch is built (-EBUSY > or -ENOMEM), both branches in iavf_mac_add_reject() skip that entry. > Does the PF then end up with a primary MAC that differs from > netdev->dev_addr? Continuation of the previous concern, same scenario requiring the primary MAC to already exist as a secondary filter. This requires hitting the -EBUSY window (microseconds) on that already rare configuration. Even then, the state is recoverable on retry or VF reset. > [Severity: Medium] > The kernel-doc promises "or error code", but ret is only ever -EAGAIN or 0, > and the iavf_clean_arq_element() status is dropped here. > > Should that be reported instead of spinning to the -EAGAIN timeout? The function returns 0 on success or -EAGAIN on timeout. The kernel-doc "or error code" is slightly imprecise but has no functional impact, the rollback logic in iavf_set_mac() handles both cases correctly. > [Severity: High] > What happens to this loop if a VFR/EMPR lands while it is polling? > > With the reset sentinels, 0xdeadbeef & 0x3FF is 751 and 0xffffffff & 0x3FF > is 1023, both well above hw->aq.num_arq_entries. Can this then "clean" > descriptors the hardware never produced and busy-spin on MMIO for the > remaining 2.5 s while holding the netdev instance lock? The poll loop is bounded to 2.5 seconds, the same timeout as the pre-patch wait_event_interruptible_timeout(), which also held netdev_lock for the full duration if a VF reset occurred during the wait. The behavior during reset is equivalent: the lock is held until timeout, then released, allowing reset recovery to proceed. The synchronous polling is a change in mechanism, not in behavior. > [Severity: Low] > Should this use event->buf_len rather than the hardcoded > IAVF_MAX_AQ_BUF_SIZE? The only caller allocates IAVF_MAX_AQ_BUF_SIZE, no issue today. A hypothetical future caller would need to match the allocation to the memset. Not a bug, just defensive coding for a reuse scenario that doesn't exist. drivers/net/ethernet/intel/iavf/iavf.h | 11 ++- drivers/net/ethernet/intel/iavf/iavf_main.c | 85 ++++++++++++---- .../net/ethernet/intel/iavf/iavf_virtchnl.c | 99 +++++++++++++++++-- 3 files changed, 165 insertions(+), 30 deletions(-) diff --git a/drivers/net/ethernet/intel/iavf/iavf.h b/drivers/net/ethernet/intel/iavf/iavf.h index dc31202b2a94..8c45536fd502 100644 --- a/drivers/net/ethernet/intel/iavf/iavf.h +++ b/drivers/net/ethernet/intel/iavf/iavf.h @@ -259,7 +259,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; @@ -588,8 +587,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); @@ -606,6 +606,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); diff --git a/drivers/net/ethernet/intel/iavf/iavf_main.c b/drivers/net/ethernet/intel/iavf/iavf_main.c index 29b8403a066b..2f8a80a11336 100644 --- a/drivers/net/ethernet/intel/iavf/iavf_main.c +++ b/drivers/net/ethernet/intel/iavf/iavf_main.c @@ -1029,6 +1029,60 @@ static bool iavf_is_mac_set_handled(struct net_device *netdev, return ret; } +/** + * iavf_mac_change_done - Check if MAC change completed + * @adapter: board private structure + * @data: MAC address being checked (as const void *) + * @v_op: virtchnl opcode from processed message + * + * Callback for iavf_poll_virtchnl_response() to check if MAC change completed. + * + * Return: true if MAC change completed, false otherwise + */ +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); +} + +/** + * iavf_set_mac_sync - Synchronously change MAC address + * @adapter: board private structure + * @addr: MAC address to set + * + * Send MAC change request to PF and poll admin queue for response. + * Caller must hold netdev_lock. This can sleep for up to 2.5 seconds. + * Event buffer is allocated before sending to avoid state mismatch if + * allocation fails after message is sent to PF. + * + * Return: 0 on success, negative on failure + */ +static int iavf_set_mac_sync(struct iavf_adapter *adapter, const u8 *addr) +{ + struct iavf_arq_event_info event; + int ret; + + 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; + + ret = iavf_add_ether_addrs(adapter); + if (ret) + goto out; + + ret = iavf_poll_virtchnl_response(adapter, &event, + iavf_mac_change_done, addr, 2500); + +out: + kfree(event.msg_buf); + return ret; +} + /** * iavf_set_mac - NDO callback to set port MAC address * @netdev: network interface device structure @@ -1046,25 +1100,23 @@ static int iavf_set_mac(struct net_device *netdev, void *p) return -EADDRNOTAVAIL; ret = iavf_replace_primary_mac(adapter, addr->sa_data); - if (ret) return ret; - ret = wait_event_interruptible_timeout(adapter->vc_waitqueue, - iavf_is_mac_set_handled(netdev, addr->sa_data), - msecs_to_jiffies(2500)); - - /* If ret < 0 then it means wait was interrupted. - * If ret == 0 then it means we got a timeout. - * else it means we got response for set MAC from PF, - * check if netdev MAC was updated to requested MAC, - * if yes then set MAC succeeded otherwise it failed return -EACCES - */ - if (ret < 0) + ret = iavf_set_mac_sync(adapter, addr->sa_data); + if (ret) { + /* Rollback only if send failed (message never reached PF). + * Don't rollback on timeout (-EAGAIN) because the message was + * sent and PF will eventually respond. When the response arrives, + * iavf_virtchnl_completion() will handle rollback (on PF error) + * or acceptance (on PF success) automatically. + */ + if (ret != -EAGAIN) { + iavf_mac_add_reject(adapter); + ether_addr_copy(adapter->hw.mac.addr, netdev->dev_addr); + } return ret; - - if (!ret) - return -EAGAIN; + } if (!ether_addr_equal(netdev->dev_addr, addr->sa_data)) return -EACCES; @@ -5394,9 +5446,6 @@ static int iavf_probe(struct pci_dev *pdev, const struct pci_device_id *ent) /* Setup the wait queue for indicating transition to down status */ init_waitqueue_head(&adapter->down_waitqueue); - /* Setup the wait queue for indicating virtchannel events */ - init_waitqueue_head(&adapter->vc_waitqueue); - INIT_LIST_HEAD(&adapter->ptp.aq_cmds); init_waitqueue_head(&adapter->ptp.phc_time_waitqueue); mutex_init(&adapter->ptp.aq_cmd_lock); diff --git a/drivers/net/ethernet/intel/iavf/iavf_virtchnl.c b/drivers/net/ethernet/intel/iavf/iavf_virtchnl.c index ec234cc8bd9d..e6b7e8f82c7c 100644 --- a/drivers/net/ethernet/intel/iavf/iavf_virtchnl.c +++ b/drivers/net/ethernet/intel/iavf/iavf_virtchnl.c @@ -2,6 +2,7 @@ /* Copyright(c) 2013 - 2018 Intel Corporation. */ #include +#include #include "iavf.h" #include "iavf_ptp.h" @@ -555,20 +556,23 @@ iavf_set_mac_addr_type(struct virtchnl_ether_addr *virtchnl_ether_addr, * @adapter: adapter structure * * Request that the PF add one or more addresses to our filters. - **/ -void iavf_add_ether_addrs(struct iavf_adapter *adapter) + * + * Return: 0 on success, negative on failure + */ +int iavf_add_ether_addrs(struct iavf_adapter *adapter) { struct virtchnl_ether_addr_list *veal; struct iavf_mac_filter *f; int i = 0, count = 0; bool more = false; size_t len; + int ret; if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) { /* bail because we already have a command pending */ dev_err(&adapter->pdev->dev, "Cannot add filters, command %d pending\n", adapter->current_op); - return; + return -EBUSY; } spin_lock_bh(&adapter->mac_vlan_list_lock); @@ -580,7 +584,7 @@ void iavf_add_ether_addrs(struct iavf_adapter *adapter) if (!count) { adapter->aq_required &= ~IAVF_FLAG_AQ_ADD_MAC_FILTER; spin_unlock_bh(&adapter->mac_vlan_list_lock); - return; + return 0; } adapter->current_op = VIRTCHNL_OP_ADD_ETH_ADDR; @@ -594,8 +598,9 @@ void iavf_add_ether_addrs(struct iavf_adapter *adapter) veal = kzalloc(len, GFP_ATOMIC); if (!veal) { + adapter->current_op = VIRTCHNL_OP_UNKNOWN; spin_unlock_bh(&adapter->mac_vlan_list_lock); - return; + return -ENOMEM; } veal->vsi_id = adapter->vsi_res->vsi_id; @@ -615,8 +620,15 @@ void iavf_add_ether_addrs(struct iavf_adapter *adapter) spin_unlock_bh(&adapter->mac_vlan_list_lock); - iavf_send_pf_msg(adapter, VIRTCHNL_OP_ADD_ETH_ADDR, (u8 *)veal, len); + ret = iavf_send_pf_msg(adapter, VIRTCHNL_OP_ADD_ETH_ADDR, (u8 *)veal, len); kfree(veal); + if (ret) { + dev_err(&adapter->pdev->dev, + "Unable to send ADD_ETH_ADDR message to PF, error %d\n", ret); + adapter->current_op = VIRTCHNL_OP_UNKNOWN; + } + + return ret; } /** @@ -712,8 +724,8 @@ static void iavf_mac_add_ok(struct iavf_adapter *adapter) * @adapter: adapter structure * * Remove filters from list based on PF response. - **/ -static void iavf_mac_add_reject(struct iavf_adapter *adapter) + */ +void iavf_mac_add_reject(struct iavf_adapter *adapter) { struct net_device *netdev = adapter->netdev; struct iavf_mac_filter *f, *ftmp; @@ -2364,7 +2376,6 @@ void iavf_virtchnl_completion(struct iavf_adapter *adapter, iavf_mac_add_reject(adapter); /* restore administratively set MAC address */ ether_addr_copy(adapter->hw.mac.addr, netdev->dev_addr); - wake_up(&adapter->vc_waitqueue); break; case VIRTCHNL_OP_DEL_ETH_ADDR: dev_err(&adapter->pdev->dev, "Failed to delete MAC filter, error %s\n", @@ -2555,7 +2566,6 @@ void iavf_virtchnl_completion(struct iavf_adapter *adapter, eth_hw_addr_set(netdev, adapter->hw.mac.addr); netif_addr_unlock_bh(netdev); } - wake_up(&adapter->vc_waitqueue); break; case VIRTCHNL_OP_GET_STATS: { struct iavf_eth_stats *stats = @@ -2950,3 +2960,72 @@ void iavf_virtchnl_completion(struct iavf_adapter *adapter, } /* switch v_opcode */ adapter->current_op = VIRTCHNL_OP_UNKNOWN; } + +/** + * iavf_poll_virtchnl_response - Poll admin queue for virtchnl response + * @adapter: adapter structure + * @event: pre-allocated event buffer to use for polling + * @condition: callback to check if desired response received + * @cond_data: context data passed to condition callback + * @timeout_ms: maximum time to wait in milliseconds + * + * Polls the admin queue and processes all incoming virtchnl messages. + * After processing each valid message, calls the condition callback to check + * if the expected response has been received. The callback receives the opcode + * of the processed message to identify which response was received. Continues + * polling until the callback returns true or timeout expires. + * + * Caller must allocate event buffer before sending any messages to PF to avoid + * state mismatch if allocation fails after message is sent. + * + * Caller must hold netdev_lock. This can sleep for up to timeout_ms while + * polling hardware. + * + * Return: 0 on success (condition met), -EAGAIN on timeout, or error code + */ +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) +{ + struct iavf_hw *hw = &adapter->hw; + enum virtchnl_ops received_op; + unsigned long timeout; + int ret = -EAGAIN; + u16 pending = 0; + u32 v_retval; + + netdev_assert_locked(adapter->netdev); + + timeout = jiffies + msecs_to_jiffies(timeout_ms); + do { + if (!pending) + usleep_range(50, 75); + + if (iavf_clean_arq_element(hw, event, &pending) == IAVF_SUCCESS) { + received_op = (enum virtchnl_ops)le32_to_cpu(event->desc.cookie_high); + if (received_op != VIRTCHNL_OP_UNKNOWN) { + v_retval = le32_to_cpu(event->desc.cookie_low); + + iavf_virtchnl_completion(adapter, received_op, + (enum iavf_status)v_retval, + event->msg_buf, event->msg_len); + + if (condition(adapter, cond_data, received_op)) { + ret = 0; + break; + } + } + + memset(event->msg_buf, 0, IAVF_MAX_AQ_BUF_SIZE); + + if (pending) + continue; + } + } while (time_before(jiffies, timeout)); + + return ret; +} -- 2.47.1 From: 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. Signed-off-by: Jose Ignacio Tornos Martinez Reviewed-by: Aleksandr Loktionov Tested-by: Rafal Romanowski Signed-off-by: Tony Nguyen --- Notes: All the comments below fall into pre-existing issues, concerns already addressed in previous versions and comments, out-of-scope items, or extreme edge cases. No code changes are considered necessary for a new version. Details for each comment: > [Severity: Low] > This isn't a bug, but doesn't ice_vf_lib.c already have a helper with > exactly these semantics? > > drivers/net/ethernet/intel/ice/ice_vf_lib.c: > static void ice_vf_set_host_trust_cfg(struct ice_vf *vf) > > Would it be preferable to export that one rather than carry a second copy? ice_vf_set_host_trust_cfg() derives the capability bit from vf->trusted, which must already be set before calling it. ice_setup_vf_trust() takes the setting as an explicit parameter, matching the i40e helper and the call site where vf->trusted and the capability bit are set together. Different interfaces for different purposes. Not a functional issue. > [Severity: High] > Is this predicate complete with respect to everything trust gates in ice? > Besides LLDP filters and promiscuous mode, vf->trusted also gates the MAC > and VLAN filter quotas and the administratively assigned MAC. > > Do those hardware filters then stay programmed after the log prints "VF N is > now untrusted"? > > Can vf->num_mac therefore remain above ICE_MAX_MACADDR_PER_VF after trust is > revoked, so that later legitimate MAC adds from the now-untrusted VF are > rejected until some unrelated reset happens? Same concern addressed in previous comments for both i40e and ice. Over-limit filters configured while trusted remain after trust revocation, but this is acceptable because untrusted VFs can freely delete their own MAC and VLAN filters, there are no trust checks in the deletion path (ice_vc_handle_mac_addr_msg() only checks trust when set == true). The VF simply cannot add more over-limit filters. ice_vc_handle_mac_addr_msg() decrements vf->num_mac on delete, so the counter reflects actual state after deletions. The no-reset path is only reached for VFs with no LLDP or promiscuous mode, having excess MAC/VLAN filters in this state is extremely unlikely. > [Severity: High] > What happens to the negotiated VLAN V2 capabilities when trust changes > without a reset? The advertised limit is derived from vf->trusted once, > at negotiation time, and then cached on the PF. > > If the VF negotiated VIRTCHNL_VF_OFFLOAD_VLAN_V2 while trusted, does the > else branch leave max_filters at VLAN_N_VID, allowing the now-untrusted VF > to keep programming VLAN filters well beyond ICE_MAX_VLAN_PER_VF? The VLAN_V2 caps cache invalidation is part of the reset/rebuild path by design (ice_vf_set_initialized()). This patch does not change that architecture, it only adds a conditional to skip the reset when no advanced features are configured. The cache behavior is inherited from the existing design and is beyond the scope of this fix. > [Severity: Medium] > This isn't a bug introduced by this patch, but while ice_set_vf_trust() is > being touched: the switchdev check earlier in this same function returns > without releasing the VF reference taken by ice_get_vf_by_id(). > > Would it make sense to convert that return into "goto out_put_vf;" here? Pre-existing reference leak, not introduced by this patch. drivers/net/ethernet/intel/ice/ice_sriov.c | 32 ++++++++++++++++++---- 1 file changed, 27 insertions(+), 5 deletions(-) diff --git a/drivers/net/ethernet/intel/ice/ice_sriov.c b/drivers/net/ethernet/intel/ice/ice_sriov.c index e04de0215596..f893dff39aac 100644 --- a/drivers/net/ethernet/intel/ice/ice_sriov.c +++ b/drivers/net/ethernet/intel/ice/ice_sriov.c @@ -1366,6 +1366,20 @@ 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) +{ + assign_bit(ICE_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps, setting); +} + /** * ice_set_vf_trust * @netdev: network interface device structure @@ -1401,11 +1415,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); - - vf->trusted = trusted; - ice_reset_vf(vf, ICE_VF_RESET_NOTIFY); + /* 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); + } dev_info(ice_pf_to_dev(pf), "VF %u is now %strusted\n", vf_id, trusted ? "" : "un"); -- 2.47.1