Move logical LAN registration and teardown out of open() and close() into ibmveth_register_rx_queues() and ibmveth_free_all_queues(). The three H_FREE_LOGICAL_LAN busy loops (kexec retry in register, pool fail before register, close) share ibmveth_free_logical_lan(). open() now allocates the buffer pools before registering, so a pool failure never has a LAN this kernel registered. A pool failure still issues one H_FREE_LOGICAL_LAN, as before, so a kexec leftover is not left registered. Signed-off-by: Mingming Cao --- drivers/net/ethernet/ibm/ibmveth.c | 154 ++++++++++++++++++++--------- 1 file changed, 105 insertions(+), 49 deletions(-) diff --git a/drivers/net/ethernet/ibm/ibmveth.c b/drivers/net/ethernet/ibm/ibmveth.c index 8f32f75f2d7f..ab8c5f6a265b 100644 --- a/drivers/net/ethernet/ibm/ibmveth.c +++ b/drivers/net/ethernet/ibm/ibmveth.c @@ -1088,10 +1088,34 @@ static void ibmveth_free_tx_resources(struct ibmveth_adapter *adapter) ibmveth_free_tx_ltb(adapter, i); } -static int ibmveth_register_logical_lan(struct ibmveth_adapter *adapter, - union ibmveth_buf_desc rxq_desc, u64 mac_address) +/** + * ibmveth_free_logical_lan - Busy-retry H_FREE_LOGICAL_LAN + * @adapter: ibmveth adapter structure + * + * Retries while PHYP returns H_BUSY or a long-busy code. + * + * Return: the last hypervisor return code + */ +static long ibmveth_free_logical_lan(struct ibmveth_adapter *adapter) { - int rc, try_again = 1; + long rc; + + do { + rc = h_free_logical_lan(adapter->vdev->unit_address); + } while (H_IS_LONG_BUSY(rc) || rc == H_BUSY); + + return rc; +} + +static long ibmveth_register_logical_lan(struct ibmveth_adapter *adapter, + union ibmveth_buf_desc rxq_desc, + u64 mac_address) +{ + long rc; + int try_again = 1; + unsigned long ua = adapter->vdev->unit_address; + unsigned long buf_dma = adapter->buffer_list_dma[0]; + unsigned long filter_dma = adapter->filter_list_dma; /* * After a kexec the adapter will still be open, so our attempt to @@ -1099,14 +1123,11 @@ static int ibmveth_register_logical_lan(struct ibmveth_adapter *adapter, * try again, but only once. */ retry: - rc = h_register_logical_lan(adapter->vdev->unit_address, - adapter->buffer_list_dma[0], rxq_desc.desc, - adapter->filter_list_dma, mac_address); + rc = h_register_logical_lan(ua, buf_dma, rxq_desc.desc, filter_dma, + mac_address); if (rc != H_SUCCESS && try_again) { - do { - rc = h_free_logical_lan(adapter->vdev->unit_address); - } while (H_IS_LONG_BUSY(rc) || (rc == H_BUSY)); + rc = ibmveth_free_logical_lan(adapter); try_again = 0; goto retry; @@ -1115,14 +1136,72 @@ static int ibmveth_register_logical_lan(struct ibmveth_adapter *adapter, return rc; } +/** + * ibmveth_free_all_queues - Free all RX queues at once + * @adapter: ibmveth adapter structure + * + * Issues one H_FREE_LOGICAL_LAN. A failure is logged; the caller still + * frees the RX memory, as close() always has. + */ +static void ibmveth_free_all_queues(struct ibmveth_adapter *adapter) +{ + long lpar_rc; + + lpar_rc = ibmveth_free_logical_lan(adapter); + if (lpar_rc != H_SUCCESS) + netdev_err(adapter->netdev, + "h_free_logical_lan failed: %ld\n", lpar_rc); +} + +/** + * ibmveth_register_rx_queues - Register RX queues with hypervisor + * @adapter: ibmveth adapter structure + * @mac_address: MAC address for device registration + * + * Registers queue 0 with H_REGISTER_LOGICAL_LAN. + * + * Return: 0 on success, -ENONET if queue 0 registration fails + */ +static int +ibmveth_register_rx_queues(struct ibmveth_adapter *adapter, u64 mac_address) +{ + struct net_device *netdev = adapter->netdev; + union ibmveth_buf_desc rxq_desc; + long lpar_rc; + int rc; + + rxq_desc.fields.flags_len = IBMVETH_BUF_VALID | + adapter->rx_queue[0].queue_len; + rxq_desc.fields.address = adapter->rx_queue[0].queue_dma; + adapter->queue_irq[0] = netdev->irq; + + rc = ibmveth_disable_irq(adapter, 0); + if (rc) + netdev_dbg(netdev, + "Failed to disable IRQ for queue 0 before registration, rc=%d\n", + rc); + + lpar_rc = ibmveth_register_logical_lan(adapter, rxq_desc, mac_address); + if (lpar_rc != H_SUCCESS) { + netdev_err(netdev, + "h_register_logical_lan failed: %ld\n", lpar_rc); + netdev_err(netdev, + "buffer TCE:0x%llx filter TCE:0x%llx rxq desc:0x%llx MAC:0x%llx\n", + adapter->buffer_list_dma[0], + adapter->filter_list_dma, + rxq_desc.desc, mac_address); + return -ENONET; + } + + return 0; +} + static int ibmveth_open(struct net_device *netdev) { struct ibmveth_adapter *adapter = netdev_priv(netdev); - u64 mac_address; + u64 mac_address = ether_addr_to_u64(netdev->dev_addr); int rxq_entries = 1; - unsigned long lpar_rc; int rc; - union ibmveth_buf_desc rxq_desc; int i; netdev_dbg(netdev, "open starting\n"); @@ -1143,33 +1222,19 @@ static int ibmveth_open(struct net_device *netdev) if (rc) goto out_free_filter_list; - mac_address = ether_addr_to_u64(netdev->dev_addr); - - rxq_desc.fields.flags_len = IBMVETH_BUF_VALID | - adapter->rx_queue[0].queue_len; - rxq_desc.fields.address = adapter->rx_queue[0].queue_dma; - - adapter->queue_irq[0] = netdev->irq; - ibmveth_disable_irq(adapter, 0); - - lpar_rc = ibmveth_register_logical_lan(adapter, rxq_desc, mac_address); - - if (lpar_rc != H_SUCCESS) { - netdev_err(netdev, "h_register_logical_lan failed with %ld\n", - lpar_rc); - netdev_err(netdev, "buffer TCE:0x%llx filter TCE:0x%llx rxq " - "desc:0x%llx MAC:0x%llx\n", - adapter->buffer_list_dma[0], - adapter->filter_list_dma, - rxq_desc.desc, - mac_address); - rc = -ENONET; + rc = ibmveth_alloc_buffer_pools(adapter); + if (rc) { + /* A kexec can leave the LAN registered by the old kernel + * (see ibmveth_register_logical_lan()); do not leave its + * buffers live in PHYP. + */ + ibmveth_free_logical_lan(adapter); goto out_free_queue_mem; } - rc = ibmveth_alloc_buffer_pools(adapter); + rc = ibmveth_register_rx_queues(adapter, mac_address); if (rc) - goto out_unregister_lan; + goto out_free_buffer_pools; /* Enables NAPI, so everything ibmveth_poll() touches must exist: * netpoll during the direct close()/open() pairs, or a direct @@ -1177,7 +1242,7 @@ static int ibmveth_open(struct net_device *netdev) */ rc = ibmveth_setup_rx_interrupts(adapter); if (rc) - goto out_unregister_lan; + goto out_free_all_queues; netdev_dbg(netdev, "initial replenish cycle\n"); ibmveth_schedule_rx_queue(adapter, 0); @@ -1200,10 +1265,9 @@ static int ibmveth_open(struct net_device *netdev) out_cleanup_rx_interrupts: ibmveth_cleanup_rx_interrupts(adapter); -out_unregister_lan: - do { - lpar_rc = h_free_logical_lan(adapter->vdev->unit_address); - } while (H_IS_LONG_BUSY(lpar_rc) || (lpar_rc == H_BUSY)); +out_free_all_queues: + ibmveth_free_all_queues(adapter); +out_free_buffer_pools: ibmveth_free_buffer_pools(adapter); out_free_queue_mem: ibmveth_cleanup_rx_resources(adapter); @@ -1216,7 +1280,6 @@ static int ibmveth_open(struct net_device *netdev) static int ibmveth_close(struct net_device *netdev) { struct ibmveth_adapter *adapter = netdev_priv(netdev); - long lpar_rc; /* change_mtu, pool sysfs, set_csum and set_tso call close() and * open() directly. If that open() fails, IFF_UP stays set and @@ -1232,14 +1295,7 @@ static int ibmveth_close(struct net_device *netdev) ibmveth_cleanup_rx_interrupts(adapter); - do { - lpar_rc = h_free_logical_lan(adapter->vdev->unit_address); - } while (H_IS_LONG_BUSY(lpar_rc) || (lpar_rc == H_BUSY)); - if (lpar_rc != H_SUCCESS) { - netdev_err(adapter->netdev, - "h_free_logical_lan failed with %lx, continuing\n", - lpar_rc); - } + ibmveth_free_all_queues(adapter); ibmveth_update_rx_no_buffer(adapter); /* netif_tx_disable() above keeps xmit off the TX LTBs. */ ibmveth_free_tx_resources(adapter); -- 2.50.1 (Apple Git-155)