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 --- 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)