diff --git a/patches.suse/0001-PCI-hv-Use-expected-affinity-when-unmasking-IRQ.patch b/patches.suse/0001-PCI-hv-Use-expected-affinity-when-unmasking-IRQ.patch index 7535846..b4df14a 100644 --- a/patches.suse/0001-PCI-hv-Use-expected-affinity-when-unmasking-IRQ.patch +++ b/patches.suse/0001-PCI-hv-Use-expected-affinity-when-unmasking-IRQ.patch @@ -3,7 +3,7 @@ From: Petr Pavlu Date: Thu, 17 Jun 2021 17:58:52 +0200 Subject: [PATCH] PCI: hv: Use expected affinity when unmasking IRQ Patch-mainline: Never, fix for use of effective affinity -References: bsc#1185973 +References: bsc#1185973, bsc#1195536 Function hv_irq_unmask() in the Hyper-V PCIe MSI driver relies on a SLE-specific implementation of irq_data_get_effective_affinity_mask() @@ -20,22 +20,27 @@ Fixing irq_data_get_effective_affinity_mask() would require bringing in more backports to implement the functionality properly. However, since the function is used only by the Hyper-V PCIe MSI driver, a minimum fix is to correct the problem there by additionally doing intersection with -the original affinity. +the original affinity. This must be done with some care still as an IRQ +can be temporarily assigned during its initialization to a CPU that is +not in its affinity, in which case the code must avoid doing the +intersection to make sure the IRQ gets unmasked on any CPU at all. Signed-off-by: Petr Pavlu --- - drivers/pci/host/pci-hyperv.c | 1 + - 1 file changed, 1 insertion(+) + drivers/pci/host/pci-hyperv.c | 3 +++ + 1 file changed, 3 insertions(+) diff --git a/drivers/pci/host/pci-hyperv.c b/drivers/pci/host/pci-hyperv.c index ccdc7d4b72a6..dd15c3f4057d 100644 --- a/drivers/pci/host/pci-hyperv.c +++ b/drivers/pci/host/pci-hyperv.c -@@ -973,6 +973,7 @@ static void hv_irq_unmask(struct irq_data *data) +@@ -973,6 +973,9 @@ static void hv_irq_unmask(struct irq_data *data) } cpumask_and(tmp, dest, cpu_online_mask); + cpumask_and(tmp, tmp, irq_data_get_affinity_mask(data)); ++ if (cpumask_empty(tmp)) ++ cpumask_and(tmp, dest, cpu_online_mask); nr_bank = cpumask_to_vpset(¶ms->int_target.vp_set, tmp); free_cpumask_var(tmp); diff --git a/patches.suse/ibmvnic-Allow-queueing-resets-during-probe.patch b/patches.suse/ibmvnic-Allow-queueing-resets-during-probe.patch new file mode 100644 index 0000000..7b0a24f --- /dev/null +++ b/patches.suse/ibmvnic-Allow-queueing-resets-during-probe.patch @@ -0,0 +1,275 @@ +From fd98693cb0721317f27341951593712c580c36a1 Mon Sep 17 00:00:00 2001 +From: Sukadev Bhattiprolu +Date: Thu, 24 Feb 2022 22:23:58 -0800 +Subject: [PATCH] ibmvnic: Allow queueing resets during probe + +References: bsc#1196516 ltc#196391 +Patch-mainline: queued +Git-repo: git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net.git +Git-commit: fd98693cb0721317f27341951593712c580c36a1 + +We currently don't allow queuing resets when adapter is in VNIC_PROBING +state - instead we throw away the reset and return EBUSY. The reasoning +is probably that during ibmvnic_probe() the ibmvnic_adapter itself is +being initialized so performing a reset during this time can lead us to +accessing fields in the ibmvnic_adapter that are not fully initialized. +A review of the code shows that all the adapter state neede to process a +reset is initialized before registering the CRQ so that should no longer +be a concern. + +Further the expectation is that if we do get a reset (transport event) +during probe, the do..while() loop in ibmvnic_probe() will handle this +by reinitializing the CRQ. + +While that is true to some extent, it is possible that the reset might +occur _after_ the CRQ is registered and CRQ_INIT message was exchanged +but _before_ the adapter state is set to VNIC_PROBED. As mentioned above, +such a reset will be thrown away. While the client assumes that the +adapter is functional, the vnic server will wait for the client to reinit +the adapter. This disconnect between the two leaves the adapter down +needing manual intervention. + +Because ibmvnic_probe() has other work to do after initializing the CRQ +(such as registering the netdev at a minimum) and because the reset event +can occur at any instant after the CRQ is initialized, there will always +be a window between initializing the CRQ and considering the adapter +ready for resets (ie state == PROBED). + +So rather than discarding resets during this window, allow queueing them +- but only process them after the adapter is fully initialized. + +To do this, introduce a new completion state ->probe_done and have the +reset worker thread wait on this before processing resets. + +This change brings up two new situations in or just after ibmvnic_probe(). +First after one or more resets were queued, we encounter an error and +decide to retry the initialization. At that point the queued resets are +no longer relevant since we could be talking to a new vnic server. So we +must purge/flush the queued resets before restarting the initialization. +As a side note, since we are still in the probing stage and we have not +registered the netdev, it will not be CHANGE_PARAM reset. + +Second this change opens up a potential race between the worker thread +in __ibmvnic_reset(), the tasklet and the ibmvnic_open() due to the +following sequence of events: + + 1. Register CRQ + 2. Get transport event before CRQ_INIT completes. + 3. Tasklet schedules reset: + a) add rwi to list + b) schedule_work() to start worker thread which runs + and waits for ->probe_done. + 4. ibmvnic_probe() decides to retry, purges rwi_list + 5. Re-register crq and this time rest of probe succeeds - register + netdev and complete(->probe_done). + 6. Worker thread resumes in __ibmvnic_reset() from 3b. + 7. Worker thread sets ->resetting bit + 8. ibmvnic_open() comes in, notices ->resetting bit, sets state + to IBMVNIC_OPEN and returns early expecting worker thread to + finish the open. + 9. Worker thread finds rwi_list empty and returns without + opening the interface. + +If this happens, the ->ndo_open() call is effectively lost and the +interface remains down. To address this, ensure that ->rwi_list is +not empty before setting the ->resetting bit. See also comments in +__ibmvnic_reset(). + +Fixes: 6a2fb0e99f9c ("ibmvnic: driver initialization for kdump/kexec") +Signed-off-by: Sukadev Bhattiprolu +Signed-off-by: David S. Miller +Acked-by: Michal Suchanek +--- + drivers/net/ethernet/ibm/ibmvnic.c | 107 ++++++++++++++++++++++++++--- + drivers/net/ethernet/ibm/ibmvnic.h | 1 + + 2 files changed, 98 insertions(+), 10 deletions(-) + +diff --git a/drivers/net/ethernet/ibm/ibmvnic.c b/drivers/net/ethernet/ibm/ibmvnic.c +index 93580c68600a..b423e94956f1 100644 +--- a/drivers/net/ethernet/ibm/ibmvnic.c ++++ b/drivers/net/ethernet/ibm/ibmvnic.c +@@ -2618,23 +2618,82 @@ static int do_passive_init(struct ibmvnic_adapter *adapter) + static void __ibmvnic_reset(struct work_struct *work) + { + struct ibmvnic_adapter *adapter; +- bool saved_state = false; ++ unsigned int timeout = 5000; + struct ibmvnic_rwi *tmprwi; ++ bool saved_state = false; + struct ibmvnic_rwi *rwi; + unsigned long flags; +- u32 reset_state; ++ struct device *dev; ++ bool need_reset; + int num_fails = 0; ++ u32 reset_state; + int rc = 0; + + adapter = container_of(work, struct ibmvnic_adapter, ibmvnic_reset); ++ dev = &adapter->vdev->dev; + +- if (test_and_set_bit_lock(0, &adapter->resetting)) { ++ /* Wait for ibmvnic_probe() to complete. If probe is taking too long ++ * or if another reset is in progress, defer work for now. If probe ++ * eventually fails it will flush and terminate our work. ++ * ++ * Three possibilities here: ++ * 1. Adpater being removed - just return ++ * 2. Timed out on probe or another reset in progress - delay the work ++ * 3. Completed probe - perform any resets in queue ++ */ ++ if (adapter->state == VNIC_PROBING && ++ !wait_for_completion_timeout(&adapter->probe_done, timeout)) { ++ dev_err(dev, "Reset thread timed out on probe"); + queue_delayed_work(system_long_wq, + &adapter->ibmvnic_delayed_reset, + IBMVNIC_RESET_DELAY); + return; + } + ++ /* adapter is done with probe (i.e state is never VNIC_PROBING now) */ ++ if (adapter->state == VNIC_REMOVING) ++ return; ++ ++ /* ->rwi_list is stable now (no one else is removing entries) */ ++ ++ /* ibmvnic_probe() may have purged the reset queue after we were ++ * scheduled to process a reset so there maybe no resets to process. ++ * Before setting the ->resetting bit though, we have to make sure ++ * that there is infact a reset to process. Otherwise we may race ++ * with ibmvnic_open() and end up leaving the vnic down: ++ * ++ * __ibmvnic_reset() ibmvnic_open() ++ * ----------------- -------------- ++ * ++ * set ->resetting bit ++ * find ->resetting bit is set ++ * set ->state to IBMVNIC_OPEN (i.e ++ * assume reset will open device) ++ * return ++ * find reset queue empty ++ * return ++ * ++ * Neither performed vnic login/open and vnic stays down ++ * ++ * If we hold the lock and conditionally set the bit, either we ++ * or ibmvnic_open() will complete the open. ++ */ ++ need_reset = false; ++ spin_lock(&adapter->rwi_lock); ++ if (!list_empty(&adapter->rwi_list)) { ++ if (test_and_set_bit_lock(0, &adapter->resetting)) { ++ queue_delayed_work(system_long_wq, ++ &adapter->ibmvnic_delayed_reset, ++ IBMVNIC_RESET_DELAY); ++ } else { ++ need_reset = true; ++ } ++ } ++ spin_unlock(&adapter->rwi_lock); ++ ++ if (!need_reset) ++ return; ++ + rwi = get_next_rwi(adapter); + while (rwi) { + spin_lock_irqsave(&adapter->state_lock, flags); +@@ -2786,13 +2845,6 @@ static int ibmvnic_reset(struct ibmvnic_adapter *adapter, + goto err; + } + +- if (adapter->state == VNIC_PROBING) { +- netdev_warn(netdev, "Adapter reset during probe\n"); +- adapter->init_done_rc = -EAGAIN; +- ret = EAGAIN; +- goto err; +- } +- + list_for_each_entry(tmp, &adapter->rwi_list, list) { + if (tmp->reset_reason == reason) { + netdev_dbg(netdev, "Skipping matching reset, reason=%s\n", +@@ -5755,6 +5807,7 @@ static int ibmvnic_probe(struct vio_dev *dev, const struct vio_device_id *id) + struct ibmvnic_adapter *adapter; + struct net_device *netdev; + unsigned char *mac_addr_p; ++ unsigned long flags; + bool init_success; + int rc; + +@@ -5799,6 +5852,7 @@ static int ibmvnic_probe(struct vio_dev *dev, const struct vio_device_id *id) + spin_lock_init(&adapter->rwi_lock); + spin_lock_init(&adapter->state_lock); + mutex_init(&adapter->fw_lock); ++ init_completion(&adapter->probe_done); + init_completion(&adapter->init_done); + init_completion(&adapter->fw_done); + init_completion(&adapter->reset_done); +@@ -5816,6 +5870,26 @@ static int ibmvnic_probe(struct vio_dev *dev, const struct vio_device_id *id) + */ + adapter->failover_pending = false; + ++ /* If we had already initialized CRQ, we may have one or ++ * more resets queued already. Discard those and release ++ * the CRQ before initializing the CRQ again. ++ */ ++ release_crq_queue(adapter); ++ ++ /* Since we are still in PROBING state, __ibmvnic_reset() ++ * will not access the ->rwi_list and since we released CRQ, ++ * we won't get _new_ transport events. But there maybe an ++ * ongoing ibmvnic_reset() call. So serialize access to ++ * rwi_list. If we win the race, ibvmnic_reset() could add ++ * a reset after we purged but thats ok - we just may end ++ * up with an extra reset (i.e similar to having two or more ++ * resets in the queue at once). ++ * CHECK. ++ */ ++ 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) { + dev_err(&dev->dev, "Couldn't initialize crq. rc=%d\n", +@@ -5867,6 +5941,8 @@ static int ibmvnic_probe(struct vio_dev *dev, const struct vio_device_id *id) + } + dev_info(&dev->dev, "ibmvnic registered\n"); + ++ complete(&adapter->probe_done); ++ + return 0; + + ibmvnic_register_fail: +@@ -5881,6 +5957,17 @@ static int ibmvnic_probe(struct vio_dev *dev, const struct vio_device_id *id) + ibmvnic_init_fail: + release_sub_crqs(adapter, 1); + release_crq_queue(adapter); ++ ++ /* cleanup worker thread after releasing CRQ so we don't get ++ * transport events (i.e new work items for the worker thread). ++ */ ++ adapter->state = VNIC_REMOVING; ++ complete(&adapter->probe_done); ++ flush_work(&adapter->ibmvnic_reset); ++ flush_delayed_work(&adapter->ibmvnic_delayed_reset); ++ ++ flush_reset_queue(adapter); ++ + mutex_destroy(&adapter->fw_lock); + free_netdev(netdev); + +diff --git a/drivers/net/ethernet/ibm/ibmvnic.h b/drivers/net/ethernet/ibm/ibmvnic.h +index 4a7a56ff74ce..fa2d607a7b1b 100644 +--- a/drivers/net/ethernet/ibm/ibmvnic.h ++++ b/drivers/net/ethernet/ibm/ibmvnic.h +@@ -930,6 +930,7 @@ struct ibmvnic_adapter { + + struct ibmvnic_tx_pool *tx_pool; + struct ibmvnic_tx_pool *tso_pool; ++ struct completion probe_done; + struct completion init_done; + int init_done_rc; + +-- +2.34.1 + diff --git a/patches.suse/ibmvnic-Update-driver-return-codes.patch b/patches.suse/ibmvnic-Update-driver-return-codes.patch new file mode 100644 index 0000000..d858971 --- /dev/null +++ b/patches.suse/ibmvnic-Update-driver-return-codes.patch @@ -0,0 +1,285 @@ +From b6ee566cf3940883d67c0d142fae8d410e975f47 Mon Sep 17 00:00:00 2001 +From: Dany Madden +Date: Tue, 14 Dec 2021 00:17:47 -0500 +Subject: [PATCH] ibmvnic: Update driver return codes + +References: bsc#1196516 ltc#196391 +Patch-mainline: v5.17-rc1 +Git-commit: b6ee566cf3940883d67c0d142fae8d410e975f47 + +Update return codes to be more informative. + +Signed-off-by: Jacob Root +Signed-off-by: Dany Madden +Signed-off-by: David S. Miller +Acked-by: Michal Suchanek +--- + drivers/net/ethernet/ibm/ibmvnic.c | 64 ++++++++++++++++-------------- + 1 file changed, 34 insertions(+), 30 deletions(-) + +diff --git a/drivers/net/ethernet/ibm/ibmvnic.c b/drivers/net/ethernet/ibm/ibmvnic.c +--- a/drivers/net/ethernet/ibm/ibmvnic.c ++++ b/drivers/net/ethernet/ibm/ibmvnic.c +@@ -264,7 +264,7 @@ static int alloc_long_term_buff(struct i + if (adapter->fw_done_rc) { + dev_err(dev, "Couldn't map long term buffer,rc = %d\n", + adapter->fw_done_rc); +- rc = -1; ++ rc = -EIO; + goto out; + } + rc = 0; +@@ -495,13 +495,15 @@ static int init_stats_token(struct ibmvn + { + struct device *dev = &adapter->vdev->dev; + dma_addr_t stok; ++ int rc; + + stok = dma_map_single(dev, &adapter->stats, + sizeof(struct ibmvnic_statistics), + DMA_FROM_DEVICE); +- if (dma_mapping_error(dev, stok)) { +- dev_err(dev, "Couldn't map stats buffer\n"); +- return -1; ++ rc = dma_mapping_error(dev, stok); ++ if (rc) { ++ dev_err(dev, "Couldn't map stats buffer, rc = %d\n", rc); ++ return rc; + } + + adapter->stats_token = stok; +@@ -517,7 +519,7 @@ static int reset_rx_pools(struct ibmvnic + int i, j, rc; + + if (!adapter->rx_pool) +- return -1; ++ return -ENOBUFS; + + buff_size = adapter->cur_rx_buf_sz; + rx_scrqs = adapter->num_active_rx_pools; +@@ -597,7 +599,7 @@ static int init_rx_pools(struct net_devi + struct ibmvnic_rx_pool *rx_pool; + int rxadd_subcrqs; + u64 buff_size; +- int i, j; ++ int i, j, rc; + + rxadd_subcrqs = adapter->num_active_rx_scrqs; + buff_size = adapter->cur_rx_buf_sz; +@@ -607,7 +609,7 @@ static int init_rx_pools(struct net_devi + GFP_KERNEL); + if (!adapter->rx_pool) { + dev_err(dev, "Failed to allocate rx pools\n"); +- return -1; ++ return -ENOMEM; + } + + adapter->num_active_rx_pools = rxadd_subcrqs; +@@ -629,7 +631,7 @@ static int init_rx_pools(struct net_devi + GFP_KERNEL); + if (!rx_pool->free_map) { + release_rx_pools(adapter); +- return -1; ++ return -ENOMEM; + } + + rx_pool->rx_buff = kcalloc(rx_pool->size, +@@ -638,13 +640,14 @@ static int init_rx_pools(struct net_devi + if (!rx_pool->rx_buff) { + dev_err(dev, "Couldn't alloc rx buffers\n"); + release_rx_pools(adapter); +- return -1; ++ return -ENOMEM; + } + +- if (alloc_long_term_buff(adapter, &rx_pool->long_term_buff, +- rx_pool->size * rx_pool->buff_size)) { ++ rc = alloc_long_term_buff(adapter, &rx_pool->long_term_buff, ++ rx_pool->size * rx_pool->buff_size); ++ if (rc) { + release_rx_pools(adapter); +- return -1; ++ return rc; + } + + for (j = 0; j < rx_pool->size; ++j) +@@ -686,7 +689,7 @@ static int reset_tx_pools(struct ibmvnic + int i, rc; + + if (!adapter->tx_pool) +- return -1; ++ return -ENOBUFS; + + tx_scrqs = adapter->num_active_tx_pools; + for (i = 0; i < tx_scrqs; i++) { +@@ -744,21 +747,22 @@ static int init_one_tx_pool(struct net_d + int num_entries, int buf_size) + { + struct ibmvnic_adapter *adapter = netdev_priv(netdev); +- int i; ++ int i, rc; + + tx_pool->tx_buff = kcalloc(num_entries, + sizeof(struct ibmvnic_tx_buff), + GFP_KERNEL); + if (!tx_pool->tx_buff) +- return -1; ++ return -ENOMEM; + +- if (alloc_long_term_buff(adapter, &tx_pool->long_term_buff, +- num_entries * buf_size)) +- return -1; ++ rc = alloc_long_term_buff(adapter, &tx_pool->long_term_buff, ++ num_entries * buf_size); ++ if (rc) ++ return rc; + + tx_pool->free_map = kcalloc(num_entries, sizeof(int), GFP_KERNEL); + if (!tx_pool->free_map) +- return -1; ++ return -ENOMEM; + + for (i = 0; i < num_entries; i++) + tx_pool->free_map[i] = i; +@@ -782,14 +786,14 @@ static int init_tx_pools(struct net_devi + adapter->tx_pool = kcalloc(tx_subcrqs, + sizeof(struct ibmvnic_tx_pool), GFP_KERNEL); + if (!adapter->tx_pool) +- return -1; ++ return -ENOMEM; + + adapter->tso_pool = kcalloc(tx_subcrqs, + sizeof(struct ibmvnic_tx_pool), GFP_KERNEL); + if (!adapter->tso_pool) { + kfree(adapter->tx_pool); + adapter->tx_pool = NULL; +- return -1; ++ return -ENOMEM; + } + + adapter->num_active_tx_pools = tx_subcrqs; +@@ -920,7 +924,7 @@ static int ibmvnic_login(struct net_devi + retry = false; + if (retry_count > retries) { + netdev_warn(netdev, "Login attempts exceeded\n"); +- return -1; ++ return -EACCES; + } + + adapter->init_done_rc = 0; +@@ -961,25 +965,26 @@ static int ibmvnic_login(struct net_devi + timeout)) { + netdev_warn(netdev, + "Capabilities query timed out\n"); +- return -1; ++ return -ETIMEDOUT; + } + + rc = init_sub_crqs(adapter); + if (rc) { + netdev_warn(netdev, + "SCRQ initialization failed\n"); +- return -1; ++ return rc; + } + + rc = init_sub_crq_irqs(adapter); + if (rc) { + netdev_warn(netdev, + "SCRQ irq initialization failed\n"); +- return -1; ++ return rc; + } + } else if (adapter->init_done_rc) { +- netdev_warn(netdev, "Adapter login failed\n"); +- return -1; ++ netdev_warn(netdev, "Adapter login failed, init_done_rc = %d\n", ++ adapter->init_done_rc); ++ return -EIO; + } + } while (retry); + +@@ -1041,7 +1046,7 @@ static int set_link_state(struct ibmvnic + if (!wait_for_completion_timeout(&adapter->init_done, + timeout)) { + netdev_err(netdev, "timeout setting link state\n"); +- return -1; ++ return -ETIMEDOUT; + } + + if (adapter->init_done_rc == PARTIALSUCCESS) { +@@ -2035,7 +2040,7 @@ static int do_reset(struct ibmvnic_adapt + /* If someone else changed the adapter state + * when we dropped the rtnl, fail the reset + */ +- rc = -1; ++ rc = -EAGAIN; + goto out; + } + adapter->state = VNIC_CLOSED; +@@ -2077,10 +2082,8 @@ static int do_reset(struct ibmvnic_adapt + } + + rc = ibmvnic_reset_init(adapter, true); +- if (rc) { +- rc = IBMVNIC_INIT_FAILED; ++ if (rc) + goto out; +- } + + /* If the adapter was in PROBE or DOWN state prior to the reset, + * exit here. +@@ -3477,7 +3480,7 @@ static int init_sub_crqs(struct ibmvnic_ + + allqueues = kcalloc(total_queues, sizeof(*allqueues), GFP_KERNEL); + if (!allqueues) +- return -1; ++ return -ENOMEM; + + for (i = 0; i < total_queues; i++) { + allqueues[i] = init_sub_crq_queue(adapter); +@@ -3546,7 +3549,7 @@ tx_failed: + for (i = 0; i < registered_queues; i++) + release_sub_crq_queue(adapter, allqueues[i], 1); + kfree(allqueues); +- return -1; ++ return -ENOMEM; + } + + static void send_request_cap(struct ibmvnic_adapter *adapter, int retry) +@@ -3937,7 +3940,7 @@ static int send_login(struct ibmvnic_ada + if (!adapter->tx_scrq || !adapter->rx_scrq) { + netdev_err(adapter->netdev, + "RX or TX queues are not allocated, device login failed\n"); +- return -1; ++ return -ENOMEM; + } + + release_login_buffer(adapter); +@@ -4057,7 +4060,7 @@ buf_map_failed: + kfree(login_buffer); + adapter->login_buf = NULL; + buf_alloc_failed: +- return -1; ++ return -ENOMEM; + } + + static int send_request_map(struct ibmvnic_adapter *adapter, dma_addr_t addr, +@@ -5376,7 +5379,7 @@ static int ibmvnic_reset_init(struct ibm + + if (!wait_for_completion_timeout(&adapter->init_done, timeout)) { + dev_err(dev, "Initialization sequence timed out\n"); +- return -1; ++ return -ETIMEDOUT; + } + + if (adapter->init_done_rc) { +@@ -5387,7 +5390,7 @@ static int ibmvnic_reset_init(struct ibm + if (adapter->from_passive_init) { + adapter->state = VNIC_OPEN; + adapter->from_passive_init = false; +- return -1; ++ return -EINVAL; + } + + if (reset && diff --git a/patches.suse/ibmvnic-clear-fop-when-retrying-probe.patch b/patches.suse/ibmvnic-clear-fop-when-retrying-probe.patch new file mode 100644 index 0000000..3c648a6 --- /dev/null +++ b/patches.suse/ibmvnic-clear-fop-when-retrying-probe.patch @@ -0,0 +1,47 @@ +From f628ad531b4f34fdba0984255b4a2850dd369513 Mon Sep 17 00:00:00 2001 +From: Sukadev Bhattiprolu +Date: Thu, 24 Feb 2022 22:23:57 -0800 +Subject: [PATCH] ibmvnic: clear fop when retrying probe + +References: bsc#1196516 ltc#196391 +Patch-mainline: queued +Git-repo: git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net.git +Git-commit: f628ad531b4f34fdba0984255b4a2850dd369513 + +Clear ->failover_pending flag that may have been set in the previous +pass of registering CRQ. If we don't clear, a subsequent ibmvnic_open() +call would be misled into thinking a failover is pending and assuming +that the reset worker thread would open the adapter. If this pass of +registering the CRQ succeeds (i.e there is no transport event), there +wouldn't be a reset worker thread. + +This would leave the adapter unconfigured and require manual intervention +to bring it up during boot. + +Fixes: 5a18e1e0c193 ("ibmvnic: Fix failover case for non-redundant configuration") +Signed-off-by: Sukadev Bhattiprolu +Signed-off-by: David S. Miller +Acked-by: Michal Suchanek +--- + drivers/net/ethernet/ibm/ibmvnic.c | 5 +++++ + 1 file changed, 5 insertions(+) + +diff --git a/drivers/net/ethernet/ibm/ibmvnic.c b/drivers/net/ethernet/ibm/ibmvnic.c +index 16a8f92adbda..93580c68600a 100644 +--- a/drivers/net/ethernet/ibm/ibmvnic.c ++++ b/drivers/net/ethernet/ibm/ibmvnic.c +@@ -5811,6 +5811,11 @@ static int ibmvnic_probe(struct vio_dev *dev, const struct vio_device_id *id) + do { + reinit_init_done(adapter); + ++ /* clear any failovers we got in the previous pass ++ * since we are reinitializing the CRQ ++ */ ++ adapter->failover_pending = false; ++ + rc = init_crq_queue(adapter); + if (rc) { + dev_err(&dev->dev, "Couldn't initialize crq. rc=%d\n", +-- +2.34.1 + diff --git a/patches.suse/ibmvnic-complete-init_done-on-transport-events.patch b/patches.suse/ibmvnic-complete-init_done-on-transport-events.patch new file mode 100644 index 0000000..02c270a --- /dev/null +++ b/patches.suse/ibmvnic-complete-init_done-on-transport-events.patch @@ -0,0 +1,43 @@ +From 36491f2df9ad2501e5a4ec25d3d95d72bafd2781 Mon Sep 17 00:00:00 2001 +From: Sukadev Bhattiprolu +Date: Thu, 24 Feb 2022 22:23:54 -0800 +Subject: [PATCH] ibmvnic: complete init_done on transport events + +References: bsc#1196516 ltc#196391 +Patch-mainline: queued +Git-repo: git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net.git +Git-commit: 36491f2df9ad2501e5a4ec25d3d95d72bafd2781 + +If we get a transport event, set the error and mark the init as +complete so the attempt to send crq-init or login fail sooner +rather than wait for the timeout. + +Fixes: bbd669a868bb ("ibmvnic: Fix completion structure initialization") +Signed-off-by: Sukadev Bhattiprolu +Signed-off-by: David S. Miller +Acked-by: Michal Suchanek +--- + drivers/net/ethernet/ibm/ibmvnic.c | 7 +++++++ + 1 file changed, 7 insertions(+) + +diff --git a/drivers/net/ethernet/ibm/ibmvnic.c b/drivers/net/ethernet/ibm/ibmvnic.c +index 42c3ac9ebb75..5913d372bc27 100644 +--- a/drivers/net/ethernet/ibm/ibmvnic.c ++++ b/drivers/net/ethernet/ibm/ibmvnic.c +@@ -5356,6 +5356,13 @@ static void ibmvnic_handle_crq(union ibmvnic_crq *crq, + adapter->fw_done_rc = -EIO; + complete(&adapter->fw_done); + } ++ ++ /* if we got here during crq-init, retry crq-init */ ++ if (!completion_done(&adapter->init_done)) { ++ adapter->init_done_rc = -EAGAIN; ++ complete(&adapter->init_done); ++ } ++ + if (!completion_done(&adapter->stats_done)) + complete(&adapter->stats_done); + if (test_bit(0, &adapter->resetting)) +-- +2.34.1 + diff --git a/patches.suse/ibmvnic-define-flush_reset_queue-helper.patch b/patches.suse/ibmvnic-define-flush_reset_queue-helper.patch new file mode 100644 index 0000000..f346780 --- /dev/null +++ b/patches.suse/ibmvnic-define-flush_reset_queue-helper.patch @@ -0,0 +1,69 @@ +From 83da53f7e4bd86dca4b2edc1e2bb324fb3c033a1 Mon Sep 17 00:00:00 2001 +From: Sukadev Bhattiprolu +Date: Thu, 24 Feb 2022 22:23:53 -0800 +Subject: [PATCH] ibmvnic: define flush_reset_queue helper + +References: bsc#1196516 ltc#196391 +Patch-mainline: queued +Git-repo: git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net.git +Git-commit: 83da53f7e4bd86dca4b2edc1e2bb324fb3c033a1 + +Define and use a helper to flush the reset queue. + +Fixes: 2770a7984db5 ("ibmvnic: Introduce hard reset recovery") +Signed-off-by: Sukadev Bhattiprolu +Signed-off-by: David S. Miller +Acked-by: Michal Suchanek +--- + drivers/net/ethernet/ibm/ibmvnic.c | 24 ++++++++++++++++-------- + 1 file changed, 16 insertions(+), 8 deletions(-) + +diff --git a/drivers/net/ethernet/ibm/ibmvnic.c b/drivers/net/ethernet/ibm/ibmvnic.c +index c73c699600a8..42c3ac9ebb75 100644 +--- a/drivers/net/ethernet/ibm/ibmvnic.c ++++ b/drivers/net/ethernet/ibm/ibmvnic.c +@@ -2735,12 +2735,23 @@ static void __ibmvnic_delayed_reset(struct work_struct *work) + __ibmvnic_reset(&adapter->ibmvnic_reset); + } + ++static void flush_reset_queue(struct ibmvnic_adapter *adapter) ++{ ++ struct list_head *entry, *tmp_entry; ++ ++ if (!list_empty(&adapter->rwi_list)) { ++ list_for_each_safe(entry, tmp_entry, &adapter->rwi_list) { ++ list_del(entry); ++ kfree(list_entry(entry, struct ibmvnic_rwi, list)); ++ } ++ } ++} ++ + static int ibmvnic_reset(struct ibmvnic_adapter *adapter, + enum ibmvnic_reset_reason reason) + { +- struct list_head *entry, *tmp_entry; +- struct ibmvnic_rwi *rwi, *tmp; + struct net_device *netdev = adapter->netdev; ++ struct ibmvnic_rwi *rwi, *tmp; + unsigned long flags; + int ret; + +@@ -2783,12 +2794,9 @@ static int ibmvnic_reset(struct ibmvnic_adapter *adapter, + /* if we just received a transport event, + * flush reset queue and process this reset + */ +- if (adapter->force_reset_recovery && !list_empty(&adapter->rwi_list)) { +- list_for_each_safe(entry, tmp_entry, &adapter->rwi_list) { +- list_del(entry); +- kfree(list_entry(entry, struct ibmvnic_rwi, list)); +- } +- } ++ if (adapter->force_reset_recovery) ++ flush_reset_queue(adapter); ++ + rwi->reset_reason = reason; + list_add_tail(&rwi->list, &adapter->rwi_list); + netdev_dbg(adapter->netdev, "Scheduling reset (reason %s)\n", +-- +2.34.1 + diff --git a/patches.suse/ibmvnic-free-reset-work-item-when-flushing.patch b/patches.suse/ibmvnic-free-reset-work-item-when-flushing.patch new file mode 100644 index 0000000..f3443be --- /dev/null +++ b/patches.suse/ibmvnic-free-reset-work-item-when-flushing.patch @@ -0,0 +1,39 @@ +From 8d0657f39f487d904fca713e0bc39c2707382553 Mon Sep 17 00:00:00 2001 +From: Sukadev Bhattiprolu +Date: Thu, 24 Feb 2022 22:23:51 -0800 +Subject: [PATCH] ibmvnic: free reset-work-item when flushing + +References: bsc#1196516 ltc#196391 +Patch-mainline: queued +Git-repo: git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net.git +Git-commit: 8d0657f39f487d904fca713e0bc39c2707382553 + +Fix a tiny memory leak when flushing the reset work queue. + +Fixes: 2770a7984db5 ("ibmvnic: Introduce hard reset recovery") +Signed-off-by: Sukadev Bhattiprolu +Signed-off-by: David S. Miller +Acked-by: Michal Suchanek +--- + drivers/net/ethernet/ibm/ibmvnic.c | 4 +++- + 1 file changed, 3 insertions(+), 1 deletion(-) + +diff --git a/drivers/net/ethernet/ibm/ibmvnic.c b/drivers/net/ethernet/ibm/ibmvnic.c +index dee05a353dbd..86d522171892 100644 +--- a/drivers/net/ethernet/ibm/ibmvnic.c ++++ b/drivers/net/ethernet/ibm/ibmvnic.c +@@ -2784,8 +2784,10 @@ static int ibmvnic_reset(struct ibmvnic_adapter *adapter, + * flush reset queue and process this reset + */ + if (adapter->force_reset_recovery && !list_empty(&adapter->rwi_list)) { +- list_for_each_safe(entry, tmp_entry, &adapter->rwi_list) ++ list_for_each_safe(entry, tmp_entry, &adapter->rwi_list) { + list_del(entry); ++ kfree(list_entry(entry, struct ibmvnic_rwi, list)); ++ } + } + rwi->reset_reason = reason; + list_add_tail(&rwi->list, &adapter->rwi_list); +-- +2.34.1 + diff --git a/patches.suse/ibmvnic-init-init_done_rc-earlier.patch b/patches.suse/ibmvnic-init-init_done_rc-earlier.patch new file mode 100644 index 0000000..37e7f8d --- /dev/null +++ b/patches.suse/ibmvnic-init-init_done_rc-earlier.patch @@ -0,0 +1,111 @@ +From ae16bf15374d8b055e040ac6f3f1147ab1c9bb7d Mon Sep 17 00:00:00 2001 +From: Sukadev Bhattiprolu +Date: Thu, 24 Feb 2022 22:23:56 -0800 +Subject: [PATCH] ibmvnic: init init_done_rc earlier + +References: bsc#1196516 ltc#196391 +Patch-mainline: queued +Git-repo: git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net.git +Git-commit: ae16bf15374d8b055e040ac6f3f1147ab1c9bb7d + +We currently initialize the ->init_done completion/return code fields +before issuing a CRQ_INIT command. But if we get a transport event soon +after registering the CRQ the taskslet may already have recorded the +completion and error code. If we initialize here, we might overwrite/ +lose that and end up issuing the CRQ_INIT only to timeout later. + +If that timeout happens during probe, we will leave the adapter in the +DOWN state rather than retrying to register/init the CRQ. + +Initialize the completion before registering the CRQ so we don't lose +the notification. + +Fixes: 032c5e82847a ("Driver for IBM System i/p VNIC protocol") +Signed-off-by: Sukadev Bhattiprolu +Signed-off-by: David S. Miller +Acked-by: Michal Suchanek +--- + drivers/net/ethernet/ibm/ibmvnic.c | 26 +++++++++++++++++++++----- + 1 file changed, 21 insertions(+), 5 deletions(-) + +diff --git a/drivers/net/ethernet/ibm/ibmvnic.c b/drivers/net/ethernet/ibm/ibmvnic.c +index a7b03ca109d8..16a8f92adbda 100644 +--- a/drivers/net/ethernet/ibm/ibmvnic.c ++++ b/drivers/net/ethernet/ibm/ibmvnic.c +@@ -2212,6 +2212,19 @@ static const char *reset_reason_to_string(enum ibmvnic_reset_reason reason) + return "UNKNOWN"; + } + ++/* ++ * Initialize the init_done completion and return code values. We ++ * can get a transport event just after registering the CRQ and the ++ * tasklet will use this to communicate the transport event. To ensure ++ * we don't miss the notification/error, initialize these _before_ ++ * regisering the CRQ. ++ */ ++static inline void reinit_init_done(struct ibmvnic_adapter *adapter) ++{ ++ reinit_completion(&adapter->init_done); ++ adapter->init_done_rc = 0; ++} ++ + /* + * do_reset returns zero if we are able to keep processing reset events, or + * non-zero if we hit a fatal error and must halt. +@@ -2318,6 +2331,8 @@ static int do_reset(struct ibmvnic_adapter *adapter, + */ + adapter->state = VNIC_PROBED; + ++ reinit_init_done(adapter); ++ + if (adapter->reset_reason == VNIC_RESET_CHANGE_PARAM) { + rc = init_crq_queue(adapter); + } else if (adapter->reset_reason == VNIC_RESET_MOBILITY) { +@@ -2461,7 +2476,8 @@ static int do_hard_reset(struct ibmvnic_adapter *adapter, + */ + adapter->state = VNIC_PROBED; + +- reinit_completion(&adapter->init_done); ++ reinit_init_done(adapter); ++ + rc = init_crq_queue(adapter); + if (rc) { + netdev_err(adapter->netdev, +@@ -5679,10 +5695,6 @@ static int ibmvnic_reset_init(struct ibmvnic_adapter *adapter, bool reset) + + adapter->from_passive_init = false; + +- if (reset) +- reinit_completion(&adapter->init_done); +- +- adapter->init_done_rc = 0; + rc = ibmvnic_send_crq_init(adapter); + if (rc) { + dev_err(dev, "Send crq init failed with error %d\n", rc); +@@ -5696,12 +5708,14 @@ static int ibmvnic_reset_init(struct ibmvnic_adapter *adapter, bool reset) + + if (adapter->init_done_rc) { + release_crq_queue(adapter); ++ dev_err(dev, "CRQ-init failed, %d\n", adapter->init_done_rc); + return adapter->init_done_rc; + } + + if (adapter->from_passive_init) { + adapter->state = VNIC_OPEN; + adapter->from_passive_init = false; ++ dev_err(dev, "CRQ-init failed, passive-init\n"); + return -EINVAL; + } + +@@ -5795,6 +5809,8 @@ static int ibmvnic_probe(struct vio_dev *dev, const struct vio_device_id *id) + + init_success = false; + do { ++ reinit_init_done(adapter); ++ + rc = init_crq_queue(adapter); + if (rc) { + dev_err(&dev->dev, "Couldn't initialize crq. rc=%d\n", +-- +2.34.1 + diff --git a/patches.suse/ibmvnic-initialize-rc-before-completing-wait.patch b/patches.suse/ibmvnic-initialize-rc-before-completing-wait.patch new file mode 100644 index 0000000..55b0137 --- /dev/null +++ b/patches.suse/ibmvnic-initialize-rc-before-completing-wait.patch @@ -0,0 +1,40 @@ +From 765559b10ce514eb1576595834f23cdc92125fee Mon Sep 17 00:00:00 2001 +From: Sukadev Bhattiprolu +Date: Thu, 24 Feb 2022 22:23:52 -0800 +Subject: [PATCH] ibmvnic: initialize rc before completing wait + +References: bsc#1196516 ltc#196391 +Patch-mainline: queued +Git-repo: git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net.git +Git-commit: 765559b10ce514eb1576595834f23cdc92125fee + +We should initialize ->init_done_rc before calling complete(). Otherwise +the waiting thread may see ->init_done_rc as 0 before we have updated it +and may assume that the CRQ was successful. + +Fixes: 6b278c0cb378 ("ibmvnic delay complete()") +Signed-off-by: Sukadev Bhattiprolu +Signed-off-by: David S. Miller +Acked-by: Michal Suchanek +--- + drivers/net/ethernet/ibm/ibmvnic.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/drivers/net/ethernet/ibm/ibmvnic.c b/drivers/net/ethernet/ibm/ibmvnic.c +index 86d522171892..c73c699600a8 100644 +--- a/drivers/net/ethernet/ibm/ibmvnic.c ++++ b/drivers/net/ethernet/ibm/ibmvnic.c +@@ -5323,9 +5323,9 @@ static void ibmvnic_handle_crq(union ibmvnic_crq *crq, + } + + if (!completion_done(&adapter->init_done)) { +- complete(&adapter->init_done); + if (!adapter->init_done_rc) + adapter->init_done_rc = -EAGAIN; ++ complete(&adapter->init_done); + } + + break; +-- +2.34.1 + diff --git a/patches.suse/ibmvnic-register-netdev-after-init-of-adapter.patch b/patches.suse/ibmvnic-register-netdev-after-init-of-adapter.patch new file mode 100644 index 0000000..1b484f0 --- /dev/null +++ b/patches.suse/ibmvnic-register-netdev-after-init-of-adapter.patch @@ -0,0 +1,56 @@ +From 570425f8c7c18b14fa8a2a58a0adb431968ad118 Mon Sep 17 00:00:00 2001 +From: Sukadev Bhattiprolu +Date: Thu, 24 Feb 2022 22:23:55 -0800 +Subject: [PATCH] ibmvnic: register netdev after init of adapter + +References: bsc#1196516 ltc#196391 +Patch-mainline: queued +Git-repo: git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net.git +Git-commit: 570425f8c7c18b14fa8a2a58a0adb431968ad118 + +Finish initializing the adapter before registering netdev so state +is consistent. + +Fixes: c26eba03e407 ("ibmvnic: Update reset infrastructure to support tunable parameters") +Signed-off-by: Sukadev Bhattiprolu +Signed-off-by: David S. Miller +Acked-by: Michal Suchanek +--- + drivers/net/ethernet/ibm/ibmvnic.c | 14 ++++++++------ + 1 file changed, 8 insertions(+), 6 deletions(-) + +diff --git a/drivers/net/ethernet/ibm/ibmvnic.c b/drivers/net/ethernet/ibm/ibmvnic.c +index 5913d372bc27..a7b03ca109d8 100644 +--- a/drivers/net/ethernet/ibm/ibmvnic.c ++++ b/drivers/net/ethernet/ibm/ibmvnic.c +@@ -5826,12 +5826,6 @@ static int ibmvnic_probe(struct vio_dev *dev, const struct vio_device_id *id) + goto ibmvnic_dev_file_err; + + netif_carrier_off(netdev); +- rc = register_netdev(netdev); +- if (rc) { +- dev_err(&dev->dev, "failed to register netdev rc=%d\n", rc); +- goto ibmvnic_register_fail; +- } +- dev_info(&dev->dev, "ibmvnic registered\n"); + + if (init_success) { + adapter->state = VNIC_PROBED; +@@ -5844,6 +5838,14 @@ static int ibmvnic_probe(struct vio_dev *dev, const struct vio_device_id *id) + + adapter->wait_for_reset = false; + adapter->last_reset_time = jiffies; ++ ++ rc = register_netdev(netdev); ++ if (rc) { ++ dev_err(&dev->dev, "failed to register netdev rc=%d\n", rc); ++ goto ibmvnic_register_fail; ++ } ++ dev_info(&dev->dev, "ibmvnic registered\n"); ++ + return 0; + + ibmvnic_register_fail: +-- +2.34.1 + diff --git a/patches.suse/lib-iov_iter-initialize-flags-in-new-pipe_buffer.patch b/patches.suse/lib-iov_iter-initialize-flags-in-new-pipe_buffer.patch new file mode 100644 index 0000000..5ef18b5 --- /dev/null +++ b/patches.suse/lib-iov_iter-initialize-flags-in-new-pipe_buffer.patch @@ -0,0 +1,52 @@ +From a162b11c975ef9a03a75027c04052906ed7710da Mon Sep 17 00:00:00 2001 +From: Max Kellermann +Date: Mon, 21 Feb 2022 11:03:13 +0100 +Subject: [PATCH] lib/iov_iter: initialize "flags" in new pipe_buffer +Git-commit: 9d2231c5d74e13b2a0546fee6737ee4446017903 +Alt-commit: a162b11c975ef9a03a75027c04052906ed7710da +Patch-mainline: v5.17-rc6 +References: bsc#1196584 + +commit 9d2231c5d74e13b2a0546fee6737ee4446017903 upstream. + +The functions copy_page_to_iter_pipe() and push_pipe() can both +allocate a new pipe_buffer, but the "flags" member initializer is +missing. + +Fixes: 241699cd72a8 ("new iov_iter flavour: pipe-backed") +To: Alexander Viro +To: linux-fsdevel@vger.kernel.org +To: linux-kernel@vger.kernel.org +Cc: stable@vger.kernel.org +Signed-off-by: Max Kellermann +Signed-off-by: Al Viro +Signed-off-by: Greg Kroah-Hartman +Acked-by: Takashi Iwai + +--- + lib/iov_iter.c | 2 ++ + 1 file changed, 2 insertions(+) + +diff --git a/lib/iov_iter.c b/lib/iov_iter.c +index 9bdc797ef257..ffa90d4c098e 100644 +--- a/lib/iov_iter.c ++++ b/lib/iov_iter.c +@@ -393,6 +393,7 @@ static size_t copy_page_to_iter_pipe(struct page *page, size_t offset, size_t by + return 0; + pipe->nrbufs++; + buf->ops = &page_cache_pipe_buf_ops; ++ buf->flags = 0; + get_page(buf->page = page); + buf->offset = offset; + buf->len = bytes; +@@ -517,6 +518,7 @@ static size_t push_pipe(struct iov_iter *i, size_t size, + break; + pipe->nrbufs++; + pipe->bufs[idx].ops = &default_pipe_buf_ops; ++ pipe->bufs[idx].flags = 0; + pipe->bufs[idx].page = page; + pipe->bufs[idx].offset = 0; + if (left <= PAGE_SIZE) { +-- +2.31.1 + diff --git a/patches.suse/tracing-Dump-stacktrace-trigger-to-the-corresponding-instance.patch b/patches.suse/tracing-Dump-stacktrace-trigger-to-the-corresponding-instance.patch new file mode 100644 index 0000000..0f09ec1 --- /dev/null +++ b/patches.suse/tracing-Dump-stacktrace-trigger-to-the-corresponding-instance.patch @@ -0,0 +1,49 @@ +From: Daniel Bristot de Oliveira +Date: Sun, 20 Feb 2022 23:49:57 +0100 +Subject: tracing: Dump stacktrace trigger to the corresponding instance +Git-commit: ce33c845b030c9cf768370c951bc699470b09fa7 +Patch-mainline: v5.17-rc6 +References: git-fixes + +The stacktrace event trigger is not dumping the stacktrace to the instance +where it was enabled, but to the global "instance." + +Use the private_data, pointing to the trigger file, to figure out the +corresponding trace instance, and use it in the trigger action, like +snapshot_trigger does. + +Link: https://lkml.kernel.org/r/afbb0b4f18ba92c276865bc97204d438473f4ebc.1645396236.git.bristot@kernel.org + +Cc: stable@vger.kernel.org +Fixes: ae63b31e4d0e2 ("tracing: Separate out trace events from global variables") +Reviewed-by: Tom Zanussi +Tested-by: Tom Zanussi +Signed-off-by: Daniel Bristot de Oliveira +Signed-off-by: Steven Rostedt (Google) +[ mb: adapted to older code base ] +Acked-by: Miroslav Benes +--- + kernel/trace/trace_events_trigger.c | 12 +++++++++++- + 1 file changed, 11 insertions(+), 1 deletion(-) + +--- a/kernel/trace/trace_events_trigger.c ++++ b/kernel/trace/trace_events_trigger.c +@@ -1162,7 +1162,17 @@ static __init int register_trigger_snaps + static void + stacktrace_trigger(struct event_trigger_data *data, void *rec) + { +- trace_dump_stack(STACK_SKIP); ++ struct trace_event_file *file = data->private_data; ++ unsigned long flags; ++ int pc; ++ ++ if (file) { ++ local_save_flags(flags); ++ pc = preempt_count(); ++ __trace_stack(file->tr, flags, STACK_SKIP, pc); ++ } else { ++ trace_dump_stack(STACK_SKIP); ++ } + } + + static void diff --git a/patches.suse/tracing-Have-traceon-and-traceoff-trigger-honor-the-instance.patch b/patches.suse/tracing-Have-traceon-and-traceoff-trigger-honor-the-instance.patch new file mode 100644 index 0000000..55d3d74 --- /dev/null +++ b/patches.suse/tracing-Have-traceon-and-traceoff-trigger-honor-the-instance.patch @@ -0,0 +1,117 @@ +From: "Steven Rostedt (Google)" +Date: Wed, 23 Feb 2022 22:38:37 -0500 +Subject: tracing: Have traceon and traceoff trigger honor the instance +Git-commit: 302e9edd54985f584cfc180098f3554774126969 +Patch-mainline: v5.17-rc6 +References: git-fixes + +If a trigger is set on an event to disable or enable tracing within an +instance, then tracing should be disabled or enabled in the instance and +not at the top level, which is confusing to users. + +Link: https://lkml.kernel.org/r/20220223223837.14f94ec3@rorschach.local.home + +Cc: stable@vger.kernel.org +Fixes: ae63b31e4d0e2 ("tracing: Separate out trace events from global variables") +Tested-by: Daniel Bristot de Oliveira +Reviewed-by: Tom Zanussi +Signed-off-by: Steven Rostedt (Google) +Acked-by: Miroslav Benes +--- + kernel/trace/trace_events_trigger.c | 52 +++++++++++++++++++++++++++++++----- + 1 file changed, 46 insertions(+), 6 deletions(-) + +--- a/kernel/trace/trace_events_trigger.c ++++ b/kernel/trace/trace_events_trigger.c +@@ -929,6 +929,16 @@ void set_named_trigger_data(struct event + static void + traceon_trigger(struct event_trigger_data *data, void *rec) + { ++ struct trace_event_file *file = data->private_data; ++ ++ if (file) { ++ if (tracer_tracing_is_on(file->tr)) ++ return; ++ ++ tracer_tracing_on(file->tr); ++ return; ++ } ++ + if (tracing_is_on()) + return; + +@@ -938,8 +948,15 @@ traceon_trigger(struct event_trigger_dat + static void + traceon_count_trigger(struct event_trigger_data *data, void *rec) + { +- if (tracing_is_on()) +- return; ++ struct trace_event_file *file = data->private_data; ++ ++ if (file) { ++ if (tracer_tracing_is_on(file->tr)) ++ return; ++ } else { ++ if (tracing_is_on()) ++ return; ++ } + + if (!data->count) + return; +@@ -947,12 +964,25 @@ traceon_count_trigger(struct event_trigg + if (data->count != -1) + (data->count)--; + +- tracing_on(); ++ if (file) ++ tracer_tracing_on(file->tr); ++ else ++ tracing_on(); + } + + static void + traceoff_trigger(struct event_trigger_data *data, void *rec) + { ++ struct trace_event_file *file = data->private_data; ++ ++ if (file) { ++ if (!tracer_tracing_is_on(file->tr)) ++ return; ++ ++ tracer_tracing_off(file->tr); ++ return; ++ } ++ + if (!tracing_is_on()) + return; + +@@ -962,8 +992,15 @@ traceoff_trigger(struct event_trigger_da + static void + traceoff_count_trigger(struct event_trigger_data *data, void *rec) + { +- if (!tracing_is_on()) +- return; ++ struct trace_event_file *file = data->private_data; ++ ++ if (file) { ++ if (!tracer_tracing_is_on(file->tr)) ++ return; ++ } else { ++ if (!tracing_is_on()) ++ return; ++ } + + if (!data->count) + return; +@@ -971,7 +1008,10 @@ traceoff_count_trigger(struct event_trig + if (data->count != -1) + (data->count)--; + +- tracing_off(); ++ if (file) ++ tracer_tracing_off(file->tr); ++ else ++ tracing_off(); + } + + static int diff --git a/series.conf b/series.conf index 592b314..3cfc245 100644 --- a/series.conf +++ b/series.conf @@ -60623,6 +60623,7 @@ patches.suse/cgroup-Use-open-time-credentials-for-process-migraton-perm-checks.patch patches.suse/Bluetooth-bfusb-fix-division-by-zero-in-send-path.patch patches.suse/msft-hv-2486-net-mana-Add-XDP-support.patch + patches.suse/ibmvnic-Update-driver-return-codes.patch patches.suse/gve-Correct-order-of-processing-device-options.patch patches.suse/gve-Move-the-irq-db-indexes-out-of-the-ntfy-block-st.patch patches.suse/gve-Update-gve_free_queue_page_list-signature.patch @@ -60687,9 +60688,20 @@ patches.suse/ixgbevf-Require-large-buffers-for-build_skb-on-82599.patch patches.suse/gve-Recording-rx-queue-before-sending-to-napi.patch patches.suse/scsi-lpfc-Fix-pt2pt-NVMe-PRLI-reject-LOGO-loop.patch + patches.suse/lib-iov_iter-initialize-flags-in-new-pipe_buffer.patch + patches.suse/tracing-Dump-stacktrace-trigger-to-the-corresponding-instance.patch + patches.suse/tracing-Have-traceon-and-traceoff-trigger-honor-the-instance.patch # netdev/net patches.suse/ibmvnic-schedule-failover-only-if-vioctl-fails.patch + patches.suse/ibmvnic-free-reset-work-item-when-flushing.patch + patches.suse/ibmvnic-initialize-rc-before-completing-wait.patch + patches.suse/ibmvnic-define-flush_reset_queue-helper.patch + patches.suse/ibmvnic-complete-init_done-on-transport-events.patch + patches.suse/ibmvnic-register-netdev-after-init-of-adapter.patch + patches.suse/ibmvnic-init-init_done_rc-earlier.patch + patches.suse/ibmvnic-clear-fop-when-retrying-probe.patch + patches.suse/ibmvnic-Allow-queueing-resets-during-probe.patch # netdev/net-next patches.suse/net-ibmvnic-Cleanup-workaround-doing-an-EOI-after-pa.patch