diff options
| -rw-r--r-- | patches/0001-chelsio-cxgb-Replace-the-workqueue-with-threaded-int.patch | 256 | ||||
| -rw-r--r-- | patches/0002-chelsio-cxgb-Disable-the-card-on-error-in-threaded-i.patch | 200 | ||||
| -rw-r--r-- | patches/0005-workqueue-Manually-break-affinity-on-hotplug.patch | 2 | ||||
| -rw-r--r-- | patches/localversion.patch | 2 | ||||
| -rw-r--r-- | patches/lockdep-no-softirq-accounting-on-rt.patch | 4 | ||||
| -rw-r--r-- | patches/powerpc-preempt-lazy-support.patch | 9 | ||||
| -rw-r--r-- | patches/series | 4 | ||||
| -rw-r--r-- | patches/softirq-disable-softirq-stacks-for-rt.patch | 2 | ||||
| -rw-r--r-- | patches/x86-kvm-require-const-tsc-for-rt.patch | 2 |
9 files changed, 471 insertions, 10 deletions
diff --git a/patches/0001-chelsio-cxgb-Replace-the-workqueue-with-threaded-int.patch b/patches/0001-chelsio-cxgb-Replace-the-workqueue-with-threaded-int.patch new file mode 100644 index 000000000000..20c8e4962d86 --- /dev/null +++ b/patches/0001-chelsio-cxgb-Replace-the-workqueue-with-threaded-int.patch @@ -0,0 +1,256 @@ +From: Sebastian Andrzej Siewior <bigeasy@linutronix.de> +Date: Tue, 2 Feb 2021 18:01:03 +0100 +Subject: [PATCH 1/2] chelsio: cxgb: Replace the workqueue with threaded + interrupt + +The external interrupt (F_PL_INTR_EXT) needs to be handled in a process +context and this is accomplished by utilizing a workqueue. + +The process context can also be provided by a threaded interrupt instead +of a workqueue. The threaded interrupt can be used later for other +interrupt related processing which require non-atomic context without +using yet another workqueue. free_irq() also ensures that the thread is +done which is currently missing (the worker could continue after the +module has been removed). + +Save pending flags in pending_thread_intr. Use the same mechanism +to disable F_PL_INTR_EXT as interrupt source like it is used before the +worker is scheduled. Enable the interrupt again once +t1_elmer0_ext_intr_handler() is done. + +Signed-off-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de> +--- + drivers/net/ethernet/chelsio/cxgb/common.h | 5 +-- + drivers/net/ethernet/chelsio/cxgb/cxgb2.c | 44 ++--------------------------- + drivers/net/ethernet/chelsio/cxgb/sge.c | 33 +++++++++++++++++++-- + drivers/net/ethernet/chelsio/cxgb/sge.h | 1 + drivers/net/ethernet/chelsio/cxgb/subr.c | 26 +++++++++++------ + 5 files changed, 55 insertions(+), 54 deletions(-) + +--- a/drivers/net/ethernet/chelsio/cxgb/common.h ++++ b/drivers/net/ethernet/chelsio/cxgb/common.h +@@ -238,7 +238,6 @@ struct adapter { + int msg_enable; + u32 mmio_len; + +- struct work_struct ext_intr_handler_task; + struct adapter_params params; + + /* Terminator modules. */ +@@ -257,6 +256,7 @@ struct adapter { + + /* guards async operations */ + spinlock_t async_lock ____cacheline_aligned; ++ u32 pending_thread_intr; + u32 slow_intr_mask; + int t1powersave; + }; +@@ -334,8 +334,7 @@ void t1_interrupts_enable(adapter_t *ada + void t1_interrupts_disable(adapter_t *adapter); + void t1_interrupts_clear(adapter_t *adapter); + int t1_elmer0_ext_intr_handler(adapter_t *adapter); +-void t1_elmer0_ext_intr(adapter_t *adapter); +-int t1_slow_intr_handler(adapter_t *adapter); ++irqreturn_t t1_slow_intr_handler(adapter_t *adapter); + + int t1_link_start(struct cphy *phy, struct cmac *mac, struct link_config *lc); + const struct board_info *t1_get_board_info(unsigned int board_id); +--- a/drivers/net/ethernet/chelsio/cxgb/cxgb2.c ++++ b/drivers/net/ethernet/chelsio/cxgb/cxgb2.c +@@ -211,9 +211,10 @@ static int cxgb_up(struct adapter *adapt + t1_interrupts_clear(adapter); + + adapter->params.has_msi = !disable_msi && !pci_enable_msi(adapter->pdev); +- err = request_irq(adapter->pdev->irq, t1_interrupt, +- adapter->params.has_msi ? 0 : IRQF_SHARED, +- adapter->name, adapter); ++ err = request_threaded_irq(adapter->pdev->irq, t1_interrupt, ++ t1_interrupt_thread, ++ adapter->params.has_msi ? 0 : IRQF_SHARED, ++ adapter->name, adapter); + if (err) { + if (adapter->params.has_msi) + pci_disable_msi(adapter->pdev); +@@ -916,41 +917,6 @@ static void mac_stats_task(struct work_s + spin_unlock(&adapter->work_lock); + } + +-/* +- * Processes elmer0 external interrupts in process context. +- */ +-static void ext_intr_task(struct work_struct *work) +-{ +- struct adapter *adapter = +- container_of(work, struct adapter, ext_intr_handler_task); +- +- t1_elmer0_ext_intr_handler(adapter); +- +- /* Now reenable external interrupts */ +- spin_lock_irq(&adapter->async_lock); +- adapter->slow_intr_mask |= F_PL_INTR_EXT; +- writel(F_PL_INTR_EXT, adapter->regs + A_PL_CAUSE); +- writel(adapter->slow_intr_mask | F_PL_INTR_SGE_DATA, +- adapter->regs + A_PL_ENABLE); +- spin_unlock_irq(&adapter->async_lock); +-} +- +-/* +- * Interrupt-context handler for elmer0 external interrupts. +- */ +-void t1_elmer0_ext_intr(struct adapter *adapter) +-{ +- /* +- * Schedule a task to handle external interrupts as we require +- * a process context. We disable EXT interrupts in the interim +- * and let the task reenable them when it's done. +- */ +- adapter->slow_intr_mask &= ~F_PL_INTR_EXT; +- writel(adapter->slow_intr_mask | F_PL_INTR_SGE_DATA, +- adapter->regs + A_PL_ENABLE); +- schedule_work(&adapter->ext_intr_handler_task); +-} +- + void t1_fatal_err(struct adapter *adapter) + { + if (adapter->flags & FULL_INIT_DONE) { +@@ -1062,8 +1028,6 @@ static int init_one(struct pci_dev *pdev + spin_lock_init(&adapter->async_lock); + spin_lock_init(&adapter->mac_lock); + +- INIT_WORK(&adapter->ext_intr_handler_task, +- ext_intr_task); + INIT_DELAYED_WORK(&adapter->stats_update_task, + mac_stats_task); + +--- a/drivers/net/ethernet/chelsio/cxgb/sge.c ++++ b/drivers/net/ethernet/chelsio/cxgb/sge.c +@@ -1619,11 +1619,38 @@ int t1_poll(struct napi_struct *napi, in + return work_done; + } + ++irqreturn_t t1_interrupt_thread(int irq, void *data) ++{ ++ struct adapter *adapter = data; ++ u32 pending_thread_intr; ++ ++ spin_lock_irq(&adapter->async_lock); ++ pending_thread_intr = adapter->pending_thread_intr; ++ adapter->pending_thread_intr = 0; ++ spin_unlock_irq(&adapter->async_lock); ++ ++ if (!pending_thread_intr) ++ return IRQ_NONE; ++ ++ if (pending_thread_intr & F_PL_INTR_EXT) ++ t1_elmer0_ext_intr_handler(adapter); ++ ++ spin_lock_irq(&adapter->async_lock); ++ adapter->slow_intr_mask |= F_PL_INTR_EXT; ++ ++ writel(F_PL_INTR_EXT, adapter->regs + A_PL_CAUSE); ++ writel(adapter->slow_intr_mask | F_PL_INTR_SGE_DATA, ++ adapter->regs + A_PL_ENABLE); ++ spin_unlock_irq(&adapter->async_lock); ++ ++ return IRQ_HANDLED; ++} ++ + irqreturn_t t1_interrupt(int irq, void *data) + { + struct adapter *adapter = data; + struct sge *sge = adapter->sge; +- int handled; ++ irqreturn_t handled; + + if (likely(responses_pending(adapter))) { + writel(F_PL_INTR_SGE_DATA, adapter->regs + A_PL_CAUSE); +@@ -1645,10 +1672,10 @@ irqreturn_t t1_interrupt(int irq, void * + handled = t1_slow_intr_handler(adapter); + spin_unlock(&adapter->async_lock); + +- if (!handled) ++ if (handled == IRQ_NONE) + sge->stats.unhandled_irqs++; + +- return IRQ_RETVAL(handled != 0); ++ return handled; + } + + /* +--- a/drivers/net/ethernet/chelsio/cxgb/sge.h ++++ b/drivers/net/ethernet/chelsio/cxgb/sge.h +@@ -74,6 +74,7 @@ struct sge *t1_sge_create(struct adapter + int t1_sge_configure(struct sge *, struct sge_params *); + int t1_sge_set_coalesce_params(struct sge *, struct sge_params *); + void t1_sge_destroy(struct sge *); ++irqreturn_t t1_interrupt_thread(int irq, void *data); + irqreturn_t t1_interrupt(int irq, void *cookie); + int t1_poll(struct napi_struct *, int); + +--- a/drivers/net/ethernet/chelsio/cxgb/subr.c ++++ b/drivers/net/ethernet/chelsio/cxgb/subr.c +@@ -210,7 +210,7 @@ static int fpga_phy_intr_handler(adapter + /* + * Slow path interrupt handler for FPGAs. + */ +-static int fpga_slow_intr(adapter_t *adapter) ++static irqreturn_t fpga_slow_intr(adapter_t *adapter) + { + u32 cause = readl(adapter->regs + A_PL_CAUSE); + +@@ -238,7 +238,7 @@ static int fpga_slow_intr(adapter_t *ada + if (cause) + writel(cause, adapter->regs + A_PL_CAUSE); + +- return cause != 0; ++ return cause == 0 ? IRQ_NONE : IRQ_HANDLED; + } + #endif + +@@ -842,13 +842,14 @@ void t1_interrupts_clear(adapter_t* adap + /* + * Slow path interrupt handler for ASICs. + */ +-static int asic_slow_intr(adapter_t *adapter) ++static irqreturn_t asic_slow_intr(adapter_t *adapter) + { + u32 cause = readl(adapter->regs + A_PL_CAUSE); ++ irqreturn_t ret = IRQ_HANDLED; + + cause &= adapter->slow_intr_mask; + if (!cause) +- return 0; ++ return IRQ_NONE; + if (cause & F_PL_INTR_SGE_ERR) + t1_sge_intr_error_handler(adapter->sge); + if (cause & F_PL_INTR_TP) +@@ -857,16 +858,25 @@ static int asic_slow_intr(adapter_t *ada + t1_espi_intr_handler(adapter->espi); + if (cause & F_PL_INTR_PCIX) + t1_pci_intr_handler(adapter); +- if (cause & F_PL_INTR_EXT) +- t1_elmer0_ext_intr(adapter); ++ if (cause & F_PL_INTR_EXT) { ++ /* Wake the threaded interrupt to handle external interrupts as ++ * we require a process context. We disable EXT interrupts in ++ * the interim and let the thread reenable them when it's done. ++ */ ++ adapter->pending_thread_intr |= F_PL_INTR_EXT; ++ adapter->slow_intr_mask &= ~F_PL_INTR_EXT; ++ writel(adapter->slow_intr_mask | F_PL_INTR_SGE_DATA, ++ adapter->regs + A_PL_ENABLE); ++ ret = IRQ_WAKE_THREAD; ++ } + + /* Clear the interrupts just processed. */ + writel(cause, adapter->regs + A_PL_CAUSE); + readl(adapter->regs + A_PL_CAUSE); /* flush writes */ +- return 1; ++ return ret; + } + +-int t1_slow_intr_handler(adapter_t *adapter) ++irqreturn_t t1_slow_intr_handler(adapter_t *adapter) + { + #ifdef CONFIG_CHELSIO_T1_1G + if (!t1_is_asic(adapter)) diff --git a/patches/0002-chelsio-cxgb-Disable-the-card-on-error-in-threaded-i.patch b/patches/0002-chelsio-cxgb-Disable-the-card-on-error-in-threaded-i.patch new file mode 100644 index 000000000000..453d8105e50c --- /dev/null +++ b/patches/0002-chelsio-cxgb-Disable-the-card-on-error-in-threaded-i.patch @@ -0,0 +1,200 @@ +From: Sebastian Andrzej Siewior <bigeasy@linutronix.de> +Date: Tue, 2 Feb 2021 18:01:04 +0100 +Subject: [PATCH 2/2] chelsio: cxgb: Disable the card on error in threaded + interrupt + +t1_fatal_err() is invoked from the interrupt handler. The bad part is +that it invokes (via t1_sge_stop()) del_timer_sync() and tasklet_kill(). +Both functions must not be called from an interrupt because it is +possible that it will wait for the completion of the timer/tasklet it +just interrupted. + +In case of a fatal error, use t1_interrupts_disable() to disable all +interrupt sources and then wake the interrupt thread with +F_PL_INTR_SGE_ERR as pending flag. The threaded-interrupt will stop the +card via t1_sge_stop() and not re-enable the interrupts again. + +Signed-off-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de> +--- + drivers/net/ethernet/chelsio/cxgb/common.h | 1 + drivers/net/ethernet/chelsio/cxgb/cxgb2.c | 10 ------- + drivers/net/ethernet/chelsio/cxgb/sge.c | 20 ++++++++++++--- + drivers/net/ethernet/chelsio/cxgb/sge.h | 2 - + drivers/net/ethernet/chelsio/cxgb/subr.c | 38 ++++++++++++++++++++--------- + 5 files changed, 44 insertions(+), 27 deletions(-) + +--- a/drivers/net/ethernet/chelsio/cxgb/common.h ++++ b/drivers/net/ethernet/chelsio/cxgb/common.h +@@ -346,7 +346,6 @@ int t1_get_board_rev(adapter_t *adapter, + int t1_init_hw_modules(adapter_t *adapter); + int t1_init_sw_modules(adapter_t *adapter, const struct board_info *bi); + void t1_free_sw_modules(adapter_t *adapter); +-void t1_fatal_err(adapter_t *adapter); + void t1_link_changed(adapter_t *adapter, int port_id); + void t1_link_negotiated(adapter_t *adapter, int port_id, int link_stat, + int speed, int duplex, int pause); +--- a/drivers/net/ethernet/chelsio/cxgb/cxgb2.c ++++ b/drivers/net/ethernet/chelsio/cxgb/cxgb2.c +@@ -917,16 +917,6 @@ static void mac_stats_task(struct work_s + spin_unlock(&adapter->work_lock); + } + +-void t1_fatal_err(struct adapter *adapter) +-{ +- if (adapter->flags & FULL_INIT_DONE) { +- t1_sge_stop(adapter->sge); +- t1_interrupts_disable(adapter); +- } +- pr_alert("%s: encountered fatal error, operation suspended\n", +- adapter->name); +-} +- + static const struct net_device_ops cxgb_netdev_ops = { + .ndo_open = cxgb_open, + .ndo_stop = cxgb_close, +--- a/drivers/net/ethernet/chelsio/cxgb/sge.c ++++ b/drivers/net/ethernet/chelsio/cxgb/sge.c +@@ -940,10 +940,11 @@ void t1_sge_intr_clear(struct sge *sge) + /* + * SGE 'Error' interrupt handler + */ +-int t1_sge_intr_error_handler(struct sge *sge) ++bool t1_sge_intr_error_handler(struct sge *sge) + { + struct adapter *adapter = sge->adapter; + u32 cause = readl(adapter->regs + A_SG_INT_CAUSE); ++ bool wake = false; + + if (adapter->port[0].dev->hw_features & NETIF_F_TSO) + cause &= ~F_PACKET_TOO_BIG; +@@ -967,11 +968,14 @@ int t1_sge_intr_error_handler(struct sge + sge->stats.pkt_mismatch++; + pr_alert("%s: SGE packet mismatch\n", adapter->name); + } +- if (cause & SGE_INT_FATAL) +- t1_fatal_err(adapter); ++ if (cause & SGE_INT_FATAL) { ++ t1_interrupts_disable(adapter); ++ adapter->pending_thread_intr |= F_PL_INTR_SGE_ERR; ++ wake = true; ++ } + + writel(cause, adapter->regs + A_SG_INT_CAUSE); +- return 0; ++ return wake; + } + + const struct sge_intr_counts *t1_sge_get_intr_counts(const struct sge *sge) +@@ -1635,6 +1639,14 @@ irqreturn_t t1_interrupt_thread(int irq, + if (pending_thread_intr & F_PL_INTR_EXT) + t1_elmer0_ext_intr_handler(adapter); + ++ /* This error is fatal, interrupts remain off */ ++ if (pending_thread_intr & F_PL_INTR_SGE_ERR) { ++ pr_alert("%s: encountered fatal error, operation suspended\n", ++ adapter->name); ++ t1_sge_stop(adapter->sge); ++ return IRQ_HANDLED; ++ } ++ + spin_lock_irq(&adapter->async_lock); + adapter->slow_intr_mask |= F_PL_INTR_EXT; + +--- a/drivers/net/ethernet/chelsio/cxgb/sge.h ++++ b/drivers/net/ethernet/chelsio/cxgb/sge.h +@@ -82,7 +82,7 @@ netdev_tx_t t1_start_xmit(struct sk_buff + void t1_vlan_mode(struct adapter *adapter, netdev_features_t features); + void t1_sge_start(struct sge *); + void t1_sge_stop(struct sge *); +-int t1_sge_intr_error_handler(struct sge *); ++bool t1_sge_intr_error_handler(struct sge *sge); + void t1_sge_intr_enable(struct sge *); + void t1_sge_intr_disable(struct sge *); + void t1_sge_intr_clear(struct sge *); +--- a/drivers/net/ethernet/chelsio/cxgb/subr.c ++++ b/drivers/net/ethernet/chelsio/cxgb/subr.c +@@ -170,7 +170,7 @@ void t1_link_changed(adapter_t *adapter, + t1_link_negotiated(adapter, port_id, link_ok, speed, duplex, fc); + } + +-static int t1_pci_intr_handler(adapter_t *adapter) ++static bool t1_pci_intr_handler(adapter_t *adapter) + { + u32 pcix_cause; + +@@ -179,9 +179,13 @@ static int t1_pci_intr_handler(adapter_t + if (pcix_cause) { + pci_write_config_dword(adapter->pdev, A_PCICFG_INTR_CAUSE, + pcix_cause); +- t1_fatal_err(adapter); /* PCI errors are fatal */ ++ /* PCI errors are fatal */ ++ t1_interrupts_disable(adapter); ++ adapter->pending_thread_intr |= F_PL_INTR_SGE_ERR; ++ pr_alert("%s: PCI error encountered.\n", adapter->name); ++ return true; + } +- return 0; ++ return false; + } + + #ifdef CONFIG_CHELSIO_T1_1G +@@ -213,10 +217,13 @@ static int fpga_phy_intr_handler(adapter + static irqreturn_t fpga_slow_intr(adapter_t *adapter) + { + u32 cause = readl(adapter->regs + A_PL_CAUSE); ++ irqreturn_t ret = IRQ_NONE; + + cause &= ~F_PL_INTR_SGE_DATA; +- if (cause & F_PL_INTR_SGE_ERR) +- t1_sge_intr_error_handler(adapter->sge); ++ if (cause & F_PL_INTR_SGE_ERR) { ++ if (t1_sge_intr_error_handler(adapter->sge)) ++ ret = IRQ_WAKE_THREAD; ++ } + + if (cause & FPGA_PCIX_INTERRUPT_GMAC) + fpga_phy_intr_handler(adapter); +@@ -231,13 +238,18 @@ static irqreturn_t fpga_slow_intr(adapte + /* Clear TP interrupt */ + writel(tp_cause, adapter->regs + FPGA_TP_ADDR_INTERRUPT_CAUSE); + } +- if (cause & FPGA_PCIX_INTERRUPT_PCIX) +- t1_pci_intr_handler(adapter); ++ if (cause & FPGA_PCIX_INTERRUPT_PCIX) { ++ if (t1_pci_intr_handler(adapter)) ++ ret = IRQ_WAKE_THREAD; ++ } + + /* Clear the interrupts just processed. */ + if (cause) + writel(cause, adapter->regs + A_PL_CAUSE); + ++ if (ret != IRQ_NONE) ++ return ret; ++ + return cause == 0 ? IRQ_NONE : IRQ_HANDLED; + } + #endif +@@ -850,14 +862,18 @@ static irqreturn_t asic_slow_intr(adapte + cause &= adapter->slow_intr_mask; + if (!cause) + return IRQ_NONE; +- if (cause & F_PL_INTR_SGE_ERR) +- t1_sge_intr_error_handler(adapter->sge); ++ if (cause & F_PL_INTR_SGE_ERR) { ++ if (t1_sge_intr_error_handler(adapter->sge)) ++ ret = IRQ_WAKE_THREAD; ++ } + if (cause & F_PL_INTR_TP) + t1_tp_intr_handler(adapter->tp); + if (cause & F_PL_INTR_ESPI) + t1_espi_intr_handler(adapter->espi); +- if (cause & F_PL_INTR_PCIX) +- t1_pci_intr_handler(adapter); ++ if (cause & F_PL_INTR_PCIX) { ++ if (t1_pci_intr_handler(adapter)) ++ ret = IRQ_WAKE_THREAD; ++ } + if (cause & F_PL_INTR_EXT) { + /* Wake the threaded interrupt to handle external interrupts as + * we require a process context. We disable EXT interrupts in diff --git a/patches/0005-workqueue-Manually-break-affinity-on-hotplug.patch b/patches/0005-workqueue-Manually-break-affinity-on-hotplug.patch index 91eefdd54c6b..3a3b0be0492e 100644 --- a/patches/0005-workqueue-Manually-break-affinity-on-hotplug.patch +++ b/patches/0005-workqueue-Manually-break-affinity-on-hotplug.patch @@ -14,7 +14,7 @@ Signed-off-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de> --- a/kernel/workqueue.c +++ b/kernel/workqueue.c -@@ -4915,6 +4915,10 @@ static void unbind_workers(int cpu) +@@ -4912,6 +4912,10 @@ static void unbind_workers(int cpu) pool->flags |= POOL_DISASSOCIATED; raw_spin_unlock_irq(&pool->lock); diff --git a/patches/localversion.patch b/patches/localversion.patch index 71c13974cd1e..73e8e2355a04 100644 --- a/patches/localversion.patch +++ b/patches/localversion.patch @@ -10,4 +10,4 @@ Signed-off-by: Thomas Gleixner <tglx@linutronix.de> --- /dev/null +++ b/localversion-rt @@ -0,0 +1 @@ -+-rt27 ++-rt28 diff --git a/patches/lockdep-no-softirq-accounting-on-rt.patch b/patches/lockdep-no-softirq-accounting-on-rt.patch index 2a9843aa018d..8e939332ca44 100644 --- a/patches/lockdep-no-softirq-accounting-on-rt.patch +++ b/patches/lockdep-no-softirq-accounting-on-rt.patch @@ -51,7 +51,7 @@ Signed-off-by: Thomas Gleixner <tglx@linutronix.de> extern void stop_critical_timings(void); --- a/kernel/locking/lockdep.c +++ b/kernel/locking/lockdep.c -@@ -5287,6 +5287,7 @@ static void check_flags(unsigned long fl +@@ -5290,6 +5290,7 @@ static noinstr void check_flags(unsigned } } @@ -59,7 +59,7 @@ Signed-off-by: Thomas Gleixner <tglx@linutronix.de> /* * We dont accurately track softirq state in e.g. * hardirq contexts (such as on 4KSTACKS), so only -@@ -5301,6 +5302,7 @@ static void check_flags(unsigned long fl +@@ -5304,6 +5305,7 @@ static noinstr void check_flags(unsigned DEBUG_LOCKS_WARN_ON(!current->softirqs_enabled); } } diff --git a/patches/powerpc-preempt-lazy-support.patch b/patches/powerpc-preempt-lazy-support.patch index 70e2f31e35d7..8e1384aad78b 100644 --- a/patches/powerpc-preempt-lazy-support.patch +++ b/patches/powerpc-preempt-lazy-support.patch @@ -11,8 +11,8 @@ Signed-off-by: Thomas Gleixner <tglx@linutronix.de> arch/powerpc/kernel/asm-offsets.c | 1 + arch/powerpc/kernel/entry_32.S | 23 ++++++++++++++++------- arch/powerpc/kernel/exceptions-64e.S | 16 ++++++++++++---- - arch/powerpc/kernel/syscall_64.c | 9 ++++++--- - 6 files changed, 49 insertions(+), 18 deletions(-) + arch/powerpc/kernel/syscall_64.c | 10 +++++++--- + 6 files changed, 50 insertions(+), 18 deletions(-) --- a/arch/powerpc/Kconfig +++ b/arch/powerpc/Kconfig @@ -231,7 +231,7 @@ Signed-off-by: Thomas Gleixner <tglx@linutronix.de> schedule(); } else { if (ti_flags & _TIF_SIGPENDING) -@@ -361,11 +361,14 @@ notrace unsigned long interrupt_exit_ker +@@ -361,11 +361,15 @@ notrace unsigned long interrupt_exit_ker /* Returning to a kernel context with local irqs enabled. */ WARN_ON_ONCE(!(regs->msr & MSR_EE)); again: @@ -242,7 +242,8 @@ Signed-off-by: Thomas Gleixner <tglx@linutronix.de> if (preempt_count() == 0) preempt_schedule_irq(); + } else if (unlikely(*ti_flagsp & _TIF_NEED_RESCHED_LAZY)) { -+ if (current_thread_info()->preempt_lazy_count == 0) ++ if ((preempt_count() == 0) && ++ (current_thread_info()->preempt_lazy_count == 0)) + preempt_schedule_irq(); } } diff --git a/patches/series b/patches/series index e9d6c46a7df0..c1fa4a7dcaa2 100644 --- a/patches/series +++ b/patches/series @@ -220,6 +220,10 @@ tcp-Remove-superfluous-BH-disable-around-listening_h.patch 0018-atm-eni-Use-tasklet_disable_in_atomic-in-the-send-ca.patch 0019-firewire-ohci-Use-tasklet_disable_in_atomic-in-the-t.patch +# 20210202170104.1909200-1-bigeasy@linutronix.de +0001-chelsio-cxgb-Replace-the-workqueue-with-threaded-int.patch +0002-chelsio-cxgb-Disable-the-card-on-error-in-threaded-i.patch + # TIP 5f0c71278d6848b4809f83af90f28196e1505ab1 x86-fpu-Simplify-fpregs_-un-lock.patch # TIP cba08c5dc6dc1a906a0b5ddac9a9ac6c9a64f2e8 diff --git a/patches/softirq-disable-softirq-stacks-for-rt.patch b/patches/softirq-disable-softirq-stacks-for-rt.patch index 9f5580cc5f83..0707bd0e5fba 100644 --- a/patches/softirq-disable-softirq-stacks-for-rt.patch +++ b/patches/softirq-disable-softirq-stacks-for-rt.patch @@ -19,7 +19,7 @@ Signed-off-by: Thomas Gleixner <tglx@linutronix.de> --- a/arch/powerpc/kernel/irq.c +++ b/arch/powerpc/kernel/irq.c -@@ -724,10 +724,12 @@ void *mcheckirq_ctx[NR_CPUS] __read_most +@@ -728,10 +728,12 @@ void *mcheckirq_ctx[NR_CPUS] __read_most void *softirq_ctx[NR_CPUS] __read_mostly; void *hardirq_ctx[NR_CPUS] __read_mostly; diff --git a/patches/x86-kvm-require-const-tsc-for-rt.patch b/patches/x86-kvm-require-const-tsc-for-rt.patch index c7cd925d4339..a0e54f017dff 100644 --- a/patches/x86-kvm-require-const-tsc-for-rt.patch +++ b/patches/x86-kvm-require-const-tsc-for-rt.patch @@ -14,7 +14,7 @@ Signed-off-by: Thomas Gleixner <tglx@linutronix.de> --- a/arch/x86/kvm/x86.c +++ b/arch/x86/kvm/x86.c -@@ -7872,6 +7872,14 @@ int kvm_arch_init(void *opaque) +@@ -7876,6 +7876,14 @@ int kvm_arch_init(void *opaque) goto out; } |