From: Greg Kroah-Hartman Date: Wed, 21 Jun 2023 18:45:43 +0000 (+0200) Subject: 5.15-stable patches X-Git-Tag: v4.14.320~73 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=869b77c63ad5b3377c17158e88b1c0b61508346e;p=thirdparty%2Fkernel%2Fstable-queue.git 5.15-stable patches added patches: tpm-tpm_tis-claim-locality-in-interrupt-handler.patch tracing-add-tracing_reset_all_online_cpus_unlocked-function.patch --- diff --git a/queue-5.15/series b/queue-5.15/series index 53c1ae3f4a5..1b664578cbe 100644 --- a/queue-5.15/series +++ b/queue-5.15/series @@ -1 +1,3 @@ drm-amd-display-fix-the-system-hang-while-disable-ps.patch +tracing-add-tracing_reset_all_online_cpus_unlocked-function.patch +tpm-tpm_tis-claim-locality-in-interrupt-handler.patch diff --git a/queue-5.15/tpm-tpm_tis-claim-locality-in-interrupt-handler.patch b/queue-5.15/tpm-tpm_tis-claim-locality-in-interrupt-handler.patch new file mode 100644 index 00000000000..958bfde0828 --- /dev/null +++ b/queue-5.15/tpm-tpm_tis-claim-locality-in-interrupt-handler.patch @@ -0,0 +1,39 @@ +From 0e069265bce5a40c4eee52e2364bbbd4dabee94a Mon Sep 17 00:00:00 2001 +From: Lino Sanfilippo +Date: Thu, 24 Nov 2022 14:55:35 +0100 +Subject: tpm, tpm_tis: Claim locality in interrupt handler +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +From: Lino Sanfilippo + +commit 0e069265bce5a40c4eee52e2364bbbd4dabee94a upstream. + +Writing the TPM_INT_STATUS register in the interrupt handler to clear the +interrupts only has effect if a locality is held. Since this is not +guaranteed at the time the interrupt is fired, claim the locality +explicitly in the handler. + +Signed-off-by: Lino Sanfilippo +Tested-by: Michael Niewöhner +Tested-by: Jarkko Sakkinen +Reviewed-by: Jarkko Sakkinen +Signed-off-by: Jarkko Sakkinen +Signed-off-by: Greg Kroah-Hartman +--- + drivers/char/tpm/tpm_tis_core.c | 2 ++ + 1 file changed, 2 insertions(+) + +--- a/drivers/char/tpm/tpm_tis_core.c ++++ b/drivers/char/tpm/tpm_tis_core.c +@@ -731,7 +731,9 @@ static irqreturn_t tis_int_handler(int d + wake_up_interruptible(&priv->int_queue); + + /* Clear interrupts handled with TPM_EOI */ ++ tpm_tis_request_locality(chip, 0); + rc = tpm_tis_write32(priv, TPM_INT_STATUS(priv->locality), interrupt); ++ tpm_tis_relinquish_locality(chip, 0); + if (rc < 0) + return IRQ_NONE; + diff --git a/queue-5.15/tracing-add-tracing_reset_all_online_cpus_unlocked-function.patch b/queue-5.15/tracing-add-tracing_reset_all_online_cpus_unlocked-function.patch new file mode 100644 index 00000000000..0cc13bc6252 --- /dev/null +++ b/queue-5.15/tracing-add-tracing_reset_all_online_cpus_unlocked-function.patch @@ -0,0 +1,106 @@ +From e18eb8783ec4949adebc7d7b0fdb65f65bfeefd9 Mon Sep 17 00:00:00 2001 +From: "Steven Rostedt (Google)" +Date: Wed, 23 Nov 2022 14:25:57 -0500 +Subject: tracing: Add tracing_reset_all_online_cpus_unlocked() function + +From: Steven Rostedt (Google) + +commit e18eb8783ec4949adebc7d7b0fdb65f65bfeefd9 upstream. + +Currently the tracing_reset_all_online_cpus() requires the +trace_types_lock held. But only one caller of this function actually has +that lock held before calling it, and the other just takes the lock so +that it can call it. More users of this function is needed where the lock +is not held. + +Add a tracing_reset_all_online_cpus_unlocked() function for the one use +case that calls it without being held, and also add a lockdep_assert to +make sure it is held when called. + +Then have tracing_reset_all_online_cpus() take the lock internally, such +that callers do not need to worry about taking it. + +Link: https://lkml.kernel.org/r/20221123192741.658273220@goodmis.org + +Cc: Masami Hiramatsu +Cc: Andrew Morton +Cc: Zheng Yejian +Signed-off-by: Steven Rostedt (Google) +Signed-off-by: Zheng Yejian +Signed-off-by: Greg Kroah-Hartman +--- + kernel/trace/trace.c | 11 ++++++++++- + kernel/trace/trace.h | 1 + + kernel/trace/trace_events.c | 2 +- + kernel/trace/trace_events_synth.c | 2 -- + 4 files changed, 12 insertions(+), 4 deletions(-) + +--- a/kernel/trace/trace.c ++++ b/kernel/trace/trace.c +@@ -2175,10 +2175,12 @@ void tracing_reset_online_cpus(struct ar + } + + /* Must have trace_types_lock held */ +-void tracing_reset_all_online_cpus(void) ++void tracing_reset_all_online_cpus_unlocked(void) + { + struct trace_array *tr; + ++ lockdep_assert_held(&trace_types_lock); ++ + list_for_each_entry(tr, &ftrace_trace_arrays, list) { + if (!tr->clear_trace) + continue; +@@ -2190,6 +2192,13 @@ void tracing_reset_all_online_cpus(void) + } + } + ++void tracing_reset_all_online_cpus(void) ++{ ++ mutex_lock(&trace_types_lock); ++ tracing_reset_all_online_cpus_unlocked(); ++ mutex_unlock(&trace_types_lock); ++} ++ + /* + * The tgid_map array maps from pid to tgid; i.e. the value stored at index i + * is the tgid last observed corresponding to pid=i. +--- a/kernel/trace/trace.h ++++ b/kernel/trace/trace.h +@@ -580,6 +580,7 @@ int tracing_is_enabled(void); + void tracing_reset_online_cpus(struct array_buffer *buf); + void tracing_reset_current(int cpu); + void tracing_reset_all_online_cpus(void); ++void tracing_reset_all_online_cpus_unlocked(void); + int tracing_open_generic(struct inode *inode, struct file *filp); + int tracing_open_generic_tr(struct inode *inode, struct file *filp); + bool tracing_is_disabled(void); +--- a/kernel/trace/trace_events.c ++++ b/kernel/trace/trace_events.c +@@ -2974,7 +2974,7 @@ static void trace_module_remove_events(s + * over from this module may be passed to the new module events and + * unexpected results may occur. + */ +- tracing_reset_all_online_cpus(); ++ tracing_reset_all_online_cpus_unlocked(); + } + + static int trace_module_notify(struct notifier_block *self, +--- a/kernel/trace/trace_events_synth.c ++++ b/kernel/trace/trace_events_synth.c +@@ -1416,7 +1416,6 @@ int synth_event_delete(const char *event + mutex_unlock(&event_mutex); + + if (mod) { +- mutex_lock(&trace_types_lock); + /* + * It is safest to reset the ring buffer if the module + * being unloaded registered any events that were +@@ -1428,7 +1427,6 @@ int synth_event_delete(const char *event + * occur. + */ + tracing_reset_all_online_cpus(); +- mutex_unlock(&trace_types_lock); + } + + return ret;