| Message ID | 20230803202010.37149-5-nnac123@linux.ibm.com (mailing list archive) |
|---|---|
| State | Superseded |
| Delegated to: | Netdev Maintainers |
| Headers | show |
| Series | [net,1/5] ibmvnic: Enforce stronger sanity checks on login response | expand |
On Thu, Aug 03, 2023 at 03:20:10PM -0500, Nick Child wrote: > If a login request fails, the recovery process should be protected > against parallel resets. It is a known issue that freeing and > registering CRQ's in quick succession can result in a failover CRQ from > the VIOS. Processing a failover during login recovery is dangerous for > two reasons: > 1. This will result in two parallel initialization processes, this can > cause serious issues during login. > 2. It is possible that the failover CRQ is received but never executed. > We get notified of a pending failover through a transport event CRQ. > The reset is not performed until a INIT CRQ request is received. > Previously, if CRQ init fails during login recovery, then the ibmvnic > irq is freed and the login process returned error. If failover_pending > is true (a transport event was received), then the ibmvnic device > would never be able to process the reset since it cannot receive the > CRQ_INIT request due to the irq being freed. This leaved the device > in a inoperable state. > > Therefore, the login failure recovery process must be hardened against > these possible issues. Possible failovers (due to quick CRQ free and > init) must be avoided and any issues during re-initialization should be > dealt with instead of being propagated up the stack. This logic is > similar to that of ibmvnic_probe(). > > Fixes: dff515a3e71d ("ibmvnic: Harden device login requests") > Signed-off-by: Nick Child <nnac123@linux.ibm.com> Reviewed-by: Simon Horman <horms@kernel.org>
On Thu, 3 Aug 2023 15:20:10 -0500 Nick Child wrote: > + do { > + reinit_init_done(adapter); > + /* Clear any failovers we got in the previous > + * pass since we are re-initializing the CRQ > + */ > + adapter->failover_pending = false; > + release_crq_queue(adapter); > + /* If we don't sleep here then we risk an > + * unnecessary failover event from the VIOS. > + * This is a known VIOS issue caused by a vnic > + * device freeing and registering a CRQ too > + * quickly. > + */ > + msleep(1500); > + /* Avoid any resets, since we are currently > + * resetting. > + */ > + spin_lock_irqsave(&adapter->rwi_lock, flags); > + flush_reset_queue(adapter); > + spin_unlock_irqrestore(&adapter->rwi_lock, > + flags); > + > + rc = init_crq_queue(adapter); > + if (rc) { > + netdev_err(netdev, "login recovery: init CRQ failed %d\n", > + rc); > + return -EIO; > + } > > - rc = ibmvnic_reset_init(adapter, false); > - if (rc) { > - netdev_err(netdev, "login recovery: Reset init failed %d\n", > - rc); > - return -EIO; > - } > + rc = ibmvnic_reset_init(adapter, false); > + if (rc) > + netdev_err(netdev, "login recovery: Reset init failed %d\n", > + rc); > + /* IBMVNIC_CRQ_INIT will return EAGAIN if it > + * fails, since ibmvnic_reset_init will free > + * irq's in failure, we won't be able to receive > + * new CRQs so we need to keep trying. probe() > + * handles this similarly. > + */ > + } while (rc == -EAGAIN); Isn't this potentially an infinite loop? Can we limit the max number of iterations here or something already makes this loop safe?
diff --git a/drivers/net/ethernet/ibm/ibmvnic.c b/drivers/net/ethernet/ibm/ibmvnic.c index 8fd9639665a0..77df62511574 100644 --- a/drivers/net/ethernet/ibm/ibmvnic.c +++ b/drivers/net/ethernet/ibm/ibmvnic.c @@ -116,6 +116,7 @@ static void ibmvnic_tx_scrq_clean_buffer(struct ibmvnic_adapter *adapter, static void free_long_term_buff(struct ibmvnic_adapter *adapter, struct ibmvnic_long_term_buff *ltb); static void ibmvnic_disable_irqs(struct ibmvnic_adapter *adapter); +static void flush_reset_queue(struct ibmvnic_adapter *adapter); struct ibmvnic_stat { char name[ETH_GSTRING_LEN]; @@ -1508,7 +1509,7 @@ static const char *adapter_state_to_string(enum vnic_state state) static int ibmvnic_login(struct net_device *netdev) { struct ibmvnic_adapter *adapter = netdev_priv(netdev); - unsigned long timeout = msecs_to_jiffies(20000); + unsigned long flags, timeout = msecs_to_jiffies(20000); int retry_count = 0; int retries = 10; bool retry; @@ -1590,27 +1591,52 @@ static int ibmvnic_login(struct net_device *netdev) adapter->init_done_rc = 0; retry_count++; release_sub_crqs(adapter, true); - reinit_init_done(adapter); - release_crq_queue(adapter); - /* If we don't sleep here then we risk an unnecessary - * failover event from the VIOS. This is a known VIOS - * issue caused by a vnic device freeing and registering - * a CRQ too quickly. + /* Much of this is similar logic as ibmvnic_probe(), + * we are essentially re-initializing communication + * with the server. We really should not run any + * resets/failovers here because this is already a form + * of reset and we do not want parallel resets occurring */ - msleep(1500); - rc = init_crq_queue(adapter); - if (rc) { - netdev_err(netdev, "login recovery: init CRQ failed %d\n", - rc); - return -EIO; - } + do { + reinit_init_done(adapter); + /* Clear any failovers we got in the previous + * pass since we are re-initializing the CRQ + */ + adapter->failover_pending = false; + release_crq_queue(adapter); + /* If we don't sleep here then we risk an + * unnecessary failover event from the VIOS. + * This is a known VIOS issue caused by a vnic + * device freeing and registering a CRQ too + * quickly. + */ + msleep(1500); + /* Avoid any resets, since we are currently + * resetting. + */ + spin_lock_irqsave(&adapter->rwi_lock, flags); + flush_reset_queue(adapter); + spin_unlock_irqrestore(&adapter->rwi_lock, + flags); + + rc = init_crq_queue(adapter); + if (rc) { + netdev_err(netdev, "login recovery: init CRQ failed %d\n", + rc); + return -EIO; + } - rc = ibmvnic_reset_init(adapter, false); - if (rc) { - netdev_err(netdev, "login recovery: Reset init failed %d\n", - rc); - return -EIO; - } + rc = ibmvnic_reset_init(adapter, false); + if (rc) + netdev_err(netdev, "login recovery: Reset init failed %d\n", + rc); + /* IBMVNIC_CRQ_INIT will return EAGAIN if it + * fails, since ibmvnic_reset_init will free + * irq's in failure, we won't be able to receive + * new CRQs so we need to keep trying. probe() + * handles this similarly. + */ + } while (rc == -EAGAIN); } } while (retry); @@ -1903,7 +1929,6 @@ static int ibmvnic_open(struct net_device *netdev) int rc; ASSERT_RTNL(); - /* If device failover is pending or we are about to reset, just set * device state and return. Device operation will be handled by reset * routine.
If a login request fails, the recovery process should be protected against parallel resets. It is a known issue that freeing and registering CRQ's in quick succession can result in a failover CRQ from the VIOS. Processing a failover during login recovery is dangerous for two reasons: 1. This will result in two parallel initialization processes, this can cause serious issues during login. 2. It is possible that the failover CRQ is received but never executed. We get notified of a pending failover through a transport event CRQ. The reset is not performed until a INIT CRQ request is received. Previously, if CRQ init fails during login recovery, then the ibmvnic irq is freed and the login process returned error. If failover_pending is true (a transport event was received), then the ibmvnic device would never be able to process the reset since it cannot receive the CRQ_INIT request due to the irq being freed. This leaved the device in a inoperable state. Therefore, the login failure recovery process must be hardened against these possible issues. Possible failovers (due to quick CRQ free and init) must be avoided and any issues during re-initialization should be dealt with instead of being propagated up the stack. This logic is similar to that of ibmvnic_probe(). Fixes: dff515a3e71d ("ibmvnic: Harden device login requests") Signed-off-by: Nick Child <nnac123@linux.ibm.com> --- drivers/net/ethernet/ibm/ibmvnic.c | 67 ++++++++++++++++++++---------- 1 file changed, 46 insertions(+), 21 deletions(-)