From: Greg Kroah-Hartman Date: Thu, 30 Apr 2020 09:26:52 +0000 (+0200) Subject: 5.6-stable patches X-Git-Tag: v5.4.37~54 X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=bd1b68bdab999a065a58c5d6ec9991da4ad2f388;p=thirdparty%2Fkernel%2Fstable-queue.git 5.6-stable patches added patches: asoc-stm32-sai-fix-sai-probe.patch printk-queue-wake_up_klogd-irq_work-only-if-per-cpu-areas-are-ready.patch --- diff --git a/queue-5.6/asoc-stm32-sai-fix-sai-probe.patch b/queue-5.6/asoc-stm32-sai-fix-sai-probe.patch new file mode 100644 index 00000000000..c35e0c577f5 --- /dev/null +++ b/queue-5.6/asoc-stm32-sai-fix-sai-probe.patch @@ -0,0 +1,53 @@ +From e2bcb65782f91390952e849e21b82ed7cb05697f Mon Sep 17 00:00:00 2001 +From: Olivier Moysan +Date: Fri, 17 Apr 2020 16:21:22 +0200 +Subject: ASoC: stm32: sai: fix sai probe + +From: Olivier Moysan + +commit e2bcb65782f91390952e849e21b82ed7cb05697f upstream. + +pcm config must be set before snd_dmaengine_pcm_register() call. + +Fixes: 0d6defc7e0e4 ("ASoC: stm32: sai: manage rebind issue") + +Signed-off-by: Olivier Moysan +Link: https://lore.kernel.org/r/20200417142122.10212-1-olivier.moysan@st.com +Signed-off-by: Mark Brown +Cc: Guenter Roeck +Signed-off-by: Greg Kroah-Hartman + +--- + sound/soc/stm/stm32_sai_sub.c | 12 +++++------- + 1 file changed, 5 insertions(+), 7 deletions(-) + +--- a/sound/soc/stm/stm32_sai_sub.c ++++ b/sound/soc/stm/stm32_sai_sub.c +@@ -1543,6 +1543,9 @@ static int stm32_sai_sub_probe(struct pl + return ret; + } + ++ if (STM_SAI_PROTOCOL_IS_SPDIF(sai)) ++ conf = &stm32_sai_pcm_config_spdif; ++ + ret = snd_dmaengine_pcm_register(&pdev->dev, conf, 0); + if (ret) { + dev_err(&pdev->dev, "Could not register pcm dma\n"); +@@ -1551,15 +1554,10 @@ static int stm32_sai_sub_probe(struct pl + + ret = snd_soc_register_component(&pdev->dev, &stm32_component, + &sai->cpu_dai_drv, 1); +- if (ret) { ++ if (ret) + snd_dmaengine_pcm_unregister(&pdev->dev); +- return ret; +- } +- +- if (STM_SAI_PROTOCOL_IS_SPDIF(sai)) +- conf = &stm32_sai_pcm_config_spdif; + +- return 0; ++ return ret; + } + + static int stm32_sai_sub_remove(struct platform_device *pdev) diff --git a/queue-5.6/printk-queue-wake_up_klogd-irq_work-only-if-per-cpu-areas-are-ready.patch b/queue-5.6/printk-queue-wake_up_klogd-irq_work-only-if-per-cpu-areas-are-ready.patch new file mode 100644 index 00000000000..d0d78481d7c --- /dev/null +++ b/queue-5.6/printk-queue-wake_up_klogd-irq_work-only-if-per-cpu-areas-are-ready.patch @@ -0,0 +1,209 @@ +From ab6f762f0f53162d41497708b33c9a3236d3609e Mon Sep 17 00:00:00 2001 +From: Sergey Senozhatsky +Date: Tue, 3 Mar 2020 20:30:02 +0900 +Subject: printk: queue wake_up_klogd irq_work only if per-CPU areas are ready + +From: Sergey Senozhatsky + +commit ab6f762f0f53162d41497708b33c9a3236d3609e upstream. + +printk_deferred(), similarly to printk_safe/printk_nmi, does not +immediately attempt to print a new message on the consoles, avoiding +calls into non-reentrant kernel paths, e.g. scheduler or timekeeping, +which potentially can deadlock the system. + +Those printk() flavors, instead, rely on per-CPU flush irq_work to print +messages from safer contexts. For same reasons (recursive scheduler or +timekeeping calls) printk() uses per-CPU irq_work in order to wake up +user space syslog/kmsg readers. + +However, only printk_safe/printk_nmi do make sure that per-CPU areas +have been initialised and that it's safe to modify per-CPU irq_work. +This means that, for instance, should printk_deferred() be invoked "too +early", that is before per-CPU areas are initialised, printk_deferred() +will perform illegal per-CPU access. + +Lech Perczak [0] reports that after commit 1b710b1b10ef ("char/random: +silence a lockdep splat with printk()") user-space syslog/kmsg readers +are not able to read new kernel messages. + +The reason is printk_deferred() being called too early (as was pointed +out by Petr and John). + +Fix printk_deferred() and do not queue per-CPU irq_work before per-CPU +areas are initialized. + +Link: https://lore.kernel.org/lkml/aa0732c6-5c4e-8a8b-a1c1-75ebe3dca05b@camlintechnologies.com/ +Reported-by: Lech Perczak +Signed-off-by: Sergey Senozhatsky +Tested-by: Jann Horn +Reviewed-by: Petr Mladek +Cc: Greg Kroah-Hartman +Cc: Theodore Ts'o +Cc: John Ogness +Signed-off-by: Linus Torvalds +Cc: Guenter Roeck +Signed-off-by: Greg Kroah-Hartman + +--- + include/linux/printk.h | 5 ----- + init/main.c | 1 - + kernel/printk/internal.h | 5 +++++ + kernel/printk/printk.c | 34 ++++++++++++++++++++++++++++++++++ + kernel/printk/printk_safe.c | 11 +---------- + 5 files changed, 40 insertions(+), 16 deletions(-) + +--- a/include/linux/printk.h ++++ b/include/linux/printk.h +@@ -202,7 +202,6 @@ __printf(1, 2) void dump_stack_set_arch_ + void dump_stack_print_info(const char *log_lvl); + void show_regs_print_info(const char *log_lvl); + extern asmlinkage void dump_stack(void) __cold; +-extern void printk_safe_init(void); + extern void printk_safe_flush(void); + extern void printk_safe_flush_on_panic(void); + #else +@@ -269,10 +268,6 @@ static inline void dump_stack(void) + { + } + +-static inline void printk_safe_init(void) +-{ +-} +- + static inline void printk_safe_flush(void) + { + } +--- a/init/main.c ++++ b/init/main.c +@@ -907,7 +907,6 @@ asmlinkage __visible void __init start_k + boot_init_stack_canary(); + + time_init(); +- printk_safe_init(); + perf_event_init(); + profile_init(); + call_function_init(); +--- a/kernel/printk/internal.h ++++ b/kernel/printk/internal.h +@@ -23,6 +23,9 @@ __printf(1, 0) int vprintk_func(const ch + void __printk_safe_enter(void); + void __printk_safe_exit(void); + ++void printk_safe_init(void); ++bool printk_percpu_data_ready(void); ++ + #define printk_safe_enter_irqsave(flags) \ + do { \ + local_irq_save(flags); \ +@@ -64,4 +67,6 @@ __printf(1, 0) int vprintk_func(const ch + #define printk_safe_enter_irq() local_irq_disable() + #define printk_safe_exit_irq() local_irq_enable() + ++static inline void printk_safe_init(void) { } ++static inline bool printk_percpu_data_ready(void) { return false; } + #endif /* CONFIG_PRINTK */ +--- a/kernel/printk/printk.c ++++ b/kernel/printk/printk.c +@@ -460,6 +460,18 @@ static char __log_buf[__LOG_BUF_LEN] __a + static char *log_buf = __log_buf; + static u32 log_buf_len = __LOG_BUF_LEN; + ++/* ++ * We cannot access per-CPU data (e.g. per-CPU flush irq_work) before ++ * per_cpu_areas are initialised. This variable is set to true when ++ * it's safe to access per-CPU data. ++ */ ++static bool __printk_percpu_data_ready __read_mostly; ++ ++bool printk_percpu_data_ready(void) ++{ ++ return __printk_percpu_data_ready; ++} ++ + /* Return log buffer address */ + char *log_buf_addr_get(void) + { +@@ -1146,12 +1158,28 @@ static void __init log_buf_add_cpu(void) + static inline void log_buf_add_cpu(void) {} + #endif /* CONFIG_SMP */ + ++static void __init set_percpu_data_ready(void) ++{ ++ printk_safe_init(); ++ /* Make sure we set this flag only after printk_safe() init is done */ ++ barrier(); ++ __printk_percpu_data_ready = true; ++} ++ + void __init setup_log_buf(int early) + { + unsigned long flags; + char *new_log_buf; + unsigned int free; + ++ /* ++ * Some archs call setup_log_buf() multiple times - first is very ++ * early, e.g. from setup_arch(), and second - when percpu_areas ++ * are initialised. ++ */ ++ if (!early) ++ set_percpu_data_ready(); ++ + if (log_buf != __log_buf) + return; + +@@ -2966,6 +2994,9 @@ static DEFINE_PER_CPU(struct irq_work, w + + void wake_up_klogd(void) + { ++ if (!printk_percpu_data_ready()) ++ return; ++ + preempt_disable(); + if (waitqueue_active(&log_wait)) { + this_cpu_or(printk_pending, PRINTK_PENDING_WAKEUP); +@@ -2976,6 +3007,9 @@ void wake_up_klogd(void) + + void defer_console_output(void) + { ++ if (!printk_percpu_data_ready()) ++ return; ++ + preempt_disable(); + __this_cpu_or(printk_pending, PRINTK_PENDING_OUTPUT); + irq_work_queue(this_cpu_ptr(&wake_up_klogd_work)); +--- a/kernel/printk/printk_safe.c ++++ b/kernel/printk/printk_safe.c +@@ -27,7 +27,6 @@ + * There are situations when we want to make sure that all buffers + * were handled or when IRQs are blocked. + */ +-static int printk_safe_irq_ready __read_mostly; + + #define SAFE_LOG_BUF_LEN ((1 << CONFIG_PRINTK_SAFE_LOG_BUF_SHIFT) - \ + sizeof(atomic_t) - \ +@@ -51,7 +50,7 @@ static DEFINE_PER_CPU(struct printk_safe + /* Get flushed in a more safe context. */ + static void queue_flush_work(struct printk_safe_seq_buf *s) + { +- if (printk_safe_irq_ready) ++ if (printk_percpu_data_ready()) + irq_work_queue(&s->work); + } + +@@ -402,14 +401,6 @@ void __init printk_safe_init(void) + #endif + } + +- /* +- * In the highly unlikely event that a NMI were to trigger at +- * this moment. Make sure IRQ work is set up before this +- * variable is set. +- */ +- barrier(); +- printk_safe_irq_ready = 1; +- + /* Flush pending messages that did not have scheduled IRQ works. */ + printk_safe_flush(); + } diff --git a/queue-5.6/series b/queue-5.6/series index 45114f3a998..82ce1951a29 100644 --- a/queue-5.6/series +++ b/queue-5.6/series @@ -1 +1,3 @@ ubifs-fix-ubifs_tnc_lookup-usage-in-do_kill_orphans.patch +printk-queue-wake_up_klogd-irq_work-only-if-per-cpu-areas-are-ready.patch +asoc-stm32-sai-fix-sai-probe.patch