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 <[email protected]>
---
 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)


Reply via email to