Move IRQ and NAPI setup, teardown and PHYP masking into helpers that
take a queue index. The IRQ cookie is that queue's NAPI. The handler
and the process-context kicks (open, resume, pool sysfs) share
ibmveth_schedule_rx_queue(), which masks only when napi_schedule_prep()
succeeds, as the handler already did. The new queue_irq[] holds each
queue's Linux IRQ; queue 0 uses netdev->irq.

napi_enable() moves to after request_irq(), with PHYP still masked:
NAPI can run as soon as it is enabled, and poll is what unmasks.

Teardown waits for the poll tail and remasks before free_irq(),
because poll unmasks after napi_complete_done(). close() stops TX
before that teardown, and now frees the IRQ before H_FREE_LOGICAL_LAN
rather than after it; PHYP is masked by then. A failed h_vio_signal()
is logged, ratelimited, instead of WARN_ON().

Signed-off-by: Mingming Cao <[email protected]>
---
 drivers/net/ethernet/ibm/ibmveth.c | 217 ++++++++++++++++++++++-------
 drivers/net/ethernet/ibm/ibmveth.h |   1 +
 2 files changed, 169 insertions(+), 49 deletions(-)

diff --git a/drivers/net/ethernet/ibm/ibmveth.c 
b/drivers/net/ethernet/ibm/ibmveth.c
index 20273240d8fe..ab5df1794004 100644
--- a/drivers/net/ethernet/ibm/ibmveth.c
+++ b/drivers/net/ethernet/ibm/ibmveth.c
@@ -330,6 +330,150 @@ ibmveth_cleanup_rx_resources(struct ibmveth_adapter 
*adapter)
        }
 }
 
+/**
+ * ibmveth_toggle_irq - Mask or unmask one RX queue's interrupt in PHYP
+ * @adapter: ibmveth adapter structure
+ * @queue_index: RX queue index
+ * @enable: true to unmask, false to mask
+ *
+ * Return: 0 on success, -EIO on failure
+ */
+static int
+ibmveth_toggle_irq(struct ibmveth_adapter *adapter, int queue_index,
+                  bool enable)
+{
+       const char *action = enable ? "enable" : "disable";
+       unsigned long h_rc;
+
+       h_rc = h_vio_signal(adapter->vdev->unit_address,
+                           enable ? VIO_IRQ_ENABLE : VIO_IRQ_DISABLE);
+       if (h_rc) {
+               dev_err_ratelimited(&adapter->netdev->dev,
+                                   "Failed to %s IRQ for queue %d, rc=0x%lx\n",
+                                   action, queue_index, h_rc);
+               return -EIO;
+       }
+       return 0;
+}
+
+/**
+ * ibmveth_disable_irq - Disable interrupt for a specific queue
+ * @adapter: ibmveth adapter structure
+ * @queue_index: RX queue index
+ *
+ * Return: 0 on success, -EIO on failure
+ */
+static int
+ibmveth_disable_irq(struct ibmveth_adapter *adapter, int queue_index)
+{
+       return ibmveth_toggle_irq(adapter, queue_index, false);
+}
+
+/**
+ * ibmveth_enable_irq - Enable interrupt for a specific queue
+ * @adapter: ibmveth adapter structure
+ * @queue_index: RX queue index
+ *
+ * Return: 0 on success, -EIO on failure
+ */
+static int
+ibmveth_enable_irq(struct ibmveth_adapter *adapter, int queue_index)
+{
+       return ibmveth_toggle_irq(adapter, queue_index, true);
+}
+
+/**
+ * ibmveth_setup_rx_interrupts - Register IRQs and enable NAPI
+ * @adapter: ibmveth adapter structure
+ *
+ * Leaves the queues masked in PHYP; the caller kicks NAPI, and the first
+ * poll unmasks.
+ *
+ * Return: 0 on success, negative error code on failure
+ */
+static int
+ibmveth_setup_rx_interrupts(struct ibmveth_adapter *adapter)
+{
+       struct net_device *netdev = adapter->netdev;
+       int i, rc, num = adapter->num_rx_queues;
+
+       for (i = 0; i < num; i++) {
+               rc = request_irq(adapter->queue_irq[i], ibmveth_interrupt,
+                                0, netdev->name, &adapter->napi[i]);
+               if (rc) {
+                       netdev_err(netdev,
+                                  "request_irq() failed for irq 0x%x queue %d: 
%d\n",
+                                  adapter->queue_irq[i], i, rc);
+                       goto err_free_irqs;
+               }
+       }
+
+       for (i = 0; i < num; i++)
+               napi_enable(&adapter->napi[i]);
+
+       return 0;
+
+err_free_irqs:
+       while (--i >= 0)
+               free_irq(adapter->queue_irq[i], &adapter->napi[i]);
+       return rc;
+}
+
+/**
+ * ibmveth_cleanup_rx_interrupts - Mask PHYP IRQs, stop NAPI, and free IRQs
+ * @adapter: ibmveth adapter structure
+ *
+ * Mask, napi_disable, wait for the poll tail, remask, then free_irq.
+ * napi_disable() does not wait past napi_complete_done(), which can
+ * unmask.
+ */
+static void
+ibmveth_cleanup_rx_interrupts(struct ibmveth_adapter *adapter)
+{
+       int i;
+
+       for (i = 0; i < adapter->num_rx_queues; i++) {
+               ibmveth_disable_irq(adapter, i);
+               synchronize_irq(adapter->queue_irq[i]);
+       }
+
+       for (i = 0; i < adapter->num_rx_queues; i++)
+               napi_disable(&adapter->napi[i]);
+
+       synchronize_net();
+
+       for (i = 0; i < adapter->num_rx_queues; i++) {
+               ibmveth_disable_irq(adapter, i);
+               synchronize_irq(adapter->queue_irq[i]);
+       }
+
+       for (i = 0; i < adapter->num_rx_queues; i++)
+               free_irq(adapter->queue_irq[i], &adapter->napi[i]);
+}
+
+/**
+ * ibmveth_schedule_rx_queue - Mask PHYP IRQ and schedule NAPI for one RX queue
+ * @adapter: ibmveth adapter structure
+ * @qindex: RX queue index
+ *
+ * Shared by the IRQ handler and process-context kick sites (open, resume,
+ * pool sysfs).
+ *
+ * Does nothing if napi_schedule_prep() fails (NAPI already scheduled,
+ * or disabled because the device is closed). A failed
+ * ibmveth_disable_irq() is logged and the queue may stay unmasked.
+ */
+static void ibmveth_schedule_rx_queue(struct ibmveth_adapter *adapter,
+                                     int qindex)
+{
+       struct napi_struct *napi = &adapter->napi[qindex];
+
+       if (napi_schedule_prep(napi)) {
+               ibmveth_disable_irq(adapter, qindex);
+               __napi_schedule(napi);
+       }
+}
+
 /* setup the initial settings for a buffer pool */
 static void ibmveth_init_buffer_pool(struct ibmveth_buff_pool *pool,
                                     u32 pool_index, u32 pool_size,
@@ -964,7 +1108,8 @@ static int ibmveth_open(struct net_device *netdev)
                                        adapter->rx_queue[0].queue_len;
        rxq_desc.fields.address = adapter->rx_queue[0].queue_dma;
 
-       h_vio_signal(adapter->vdev->unit_address, VIO_IRQ_DISABLE);
+       adapter->queue_irq[0] = netdev->irq;
+       ibmveth_disable_irq(adapter, 0);
 
        lpar_rc = ibmveth_register_logical_lan(adapter, rxq_desc, mac_address);
 
@@ -985,26 +1130,16 @@ static int ibmveth_open(struct net_device *netdev)
        if (rc)
                goto out_free_buffer_pools;
 
-       /* NAPI can run as soon as it is enabled, from netpoll during the
-        * direct close()/open() pairs or from a direct ibmveth_interrupt()
-        * call, so enable it only once everything ibmveth_poll() touches
-        * exists.
+       /* Enables NAPI, so everything ibmveth_poll() touches must exist:
+        * netpoll during the direct close()/open() pairs, or a direct
+        * kick, can run it as soon as it is enabled.
         */
-       napi_enable(&adapter->napi[0]);
-
-       netdev_dbg(netdev, "registering irq 0x%x\n", netdev->irq);
-       rc = request_irq(netdev->irq, ibmveth_interrupt, 0, netdev->name,
-                        netdev);
-       if (rc != 0) {
-               napi_disable(&adapter->napi[0]);
-               synchronize_net();
-               netdev_err(netdev, "unable to request irq 0x%x, rc %d\n",
-                          netdev->irq, rc);
+       rc = ibmveth_setup_rx_interrupts(adapter);
+       if (rc)
                goto out_free_buffer_pools;
-       }
 
        netdev_dbg(netdev, "initial replenish cycle\n");
-       ibmveth_interrupt(netdev->irq, netdev);
+       ibmveth_schedule_rx_queue(adapter, 0);
 
        netif_tx_start_all_queues(netdev);
 
@@ -1044,30 +1179,19 @@ static int ibmveth_close(struct net_device *netdev)
 
        netdev_dbg(netdev, "close starting\n");
 
-       napi_disable(&adapter->napi[0]);
-       /* napi_disable() returns once ibmveth_poll() has called
-        * napi_complete_done(), but the poll still re-enables the
-        * interrupt and reads the RX queue after that.
-        */
-       synchronize_net();
-
        netif_tx_disable(netdev);
 
-       h_vio_signal(adapter->vdev->unit_address, VIO_IRQ_DISABLE);
+       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(netdev, "h_free_logical_lan failed with %lx, "
-                          "continuing with close\n", lpar_rc);
+               netdev_err(adapter->netdev,
+                          "h_free_logical_lan failed with %lx, continuing\n",
+                          lpar_rc);
        }
-
-       free_irq(netdev->irq, netdev);
-
        ibmveth_update_rx_no_buffer(adapter);
-
        ibmveth_free_buffer_pools(adapter);
        ibmveth_cleanup_rx_resources(adapter);
        ibmveth_free_filter_list(adapter);
@@ -1754,7 +1878,6 @@ static int ibmveth_poll(struct napi_struct *napi, int 
budget)
                        container_of(napi, struct ibmveth_adapter, napi[0]);
        struct net_device *netdev = adapter->netdev;
        int frames_processed = 0;
-       unsigned long lpar_rc;
        u64 correlator;
        u16 mss = 0;
        int rc;
@@ -1902,18 +2025,17 @@ static int ibmveth_poll(struct napi_struct *napi, int 
budget)
        /* We think we are done - reenable interrupts,
         * then check once more to make sure we are done.
         */
-       lpar_rc = h_vio_signal(adapter->vdev->unit_address, VIO_IRQ_ENABLE);
-       if (WARN_ON(lpar_rc != H_SUCCESS)) {
+       rc = ibmveth_enable_irq(adapter, 0);
+       if (rc) {
                schedule_work(&adapter->work);
                goto out;
        }
 
-       /* Mask before queueing, as ibmveth_interrupt() does: a threaded
+       /* Mask before queueing, as schedule_rx_queue() does: a threaded
         * NAPI can start polling, and unmask, as soon as it is queued.
         */
        if (ibmveth_rxq_pending_buffer(adapter) && napi_schedule_prep(napi)) {
-               lpar_rc = h_vio_signal(adapter->vdev->unit_address,
-                                      VIO_IRQ_DISABLE);
+               ibmveth_disable_irq(adapter, 0);
                __napi_schedule(napi);
        }
 
@@ -1923,16 +2045,11 @@ static int ibmveth_poll(struct napi_struct *napi, int 
budget)
 
 static irqreturn_t ibmveth_interrupt(int irq, void *dev_instance)
 {
-       struct net_device *netdev = dev_instance;
+       struct napi_struct *napi = dev_instance;
+       struct net_device *netdev = napi->dev;
        struct ibmveth_adapter *adapter = netdev_priv(netdev);
-       unsigned long lpar_rc;
 
-       if (napi_schedule_prep(&adapter->napi[0])) {
-               lpar_rc = h_vio_signal(adapter->vdev->unit_address,
-                                      VIO_IRQ_DISABLE);
-               WARN_ON(lpar_rc != H_SUCCESS);
-               __napi_schedule(&adapter->napi[0]);
-       }
+       ibmveth_schedule_rx_queue(adapter, napi - adapter->napi);
        return IRQ_HANDLED;
 }
 
@@ -2474,8 +2591,8 @@ static ssize_t veth_pool_store(struct kobject *kobj, 
struct attribute *attr,
        }
        rtnl_unlock();
 
-       /* kick the interrupt handler to allocate/deallocate pools */
-       ibmveth_interrupt(netdev->irq, netdev);
+       /* kick RX processing to allocate/deallocate pools */
+       ibmveth_schedule_rx_queue(adapter, 0);
        return count;
 
 unlock_err:
@@ -2515,7 +2632,9 @@ static struct kobj_type ktype_veth_pool = {
 static int ibmveth_resume(struct device *dev)
 {
        struct net_device *netdev = dev_get_drvdata(dev);
-       ibmveth_interrupt(netdev->irq, netdev);
+       struct ibmveth_adapter *adapter = netdev_priv(netdev);
+
+       ibmveth_schedule_rx_queue(adapter, 0);
        return 0;
 }
 
diff --git a/drivers/net/ethernet/ibm/ibmveth.h 
b/drivers/net/ethernet/ibm/ibmveth.h
index 4c74bd39d4e0..60a94f1d23bc 100644
--- a/drivers/net/ethernet/ibm/ibmveth.h
+++ b/drivers/net/ethernet/ibm/ibmveth.h
@@ -175,6 +175,7 @@ struct ibmveth_adapter {
        struct ibmveth_buff_pool
                rx_buff_pool[IBMVETH_MAX_RX_QUEUES][IBMVETH_NUM_BUFF_POOLS];
        struct ibmveth_rx_q rx_queue[IBMVETH_MAX_RX_QUEUES];
+       unsigned int queue_irq[IBMVETH_MAX_RX_QUEUES];
        unsigned int num_rx_queues;
        int rx_csum;
        int large_send;
-- 
2.50.1 (Apple Git-155)


Reply via email to