From: Sasha Levin Date: Fri, 6 Oct 2023 13:29:53 +0000 (-0400) Subject: Fixes for 5.15 X-Git-Tag: v4.14.327~89 X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=e09e7714e5f8224d108a568592747cca63558c57;p=thirdparty%2Fkernel%2Fstable-queue.git Fixes for 5.15 Signed-off-by: Sasha Levin --- diff --git a/queue-5.15/arm64-avoid-repeated-aa64mmfr1_el1-register-read-on-.patch b/queue-5.15/arm64-avoid-repeated-aa64mmfr1_el1-register-read-on-.patch new file mode 100644 index 00000000000..5dec6c6c502 --- /dev/null +++ b/queue-5.15/arm64-avoid-repeated-aa64mmfr1_el1-register-read-on-.patch @@ -0,0 +1,60 @@ +From 229a13d0c19009b40995527efac3919205d27e67 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Mon, 9 Jan 2023 12:19:55 -0300 +Subject: arm64: Avoid repeated AA64MMFR1_EL1 register read on pagefault path + +From: Gabriel Krisman Bertazi + +[ Upstream commit a89c6bcdac22bec1bfbe6e64060b4cf5838d4f47 ] + +Accessing AA64MMFR1_EL1 is expensive in KVM guests, since it is emulated +in the hypervisor. In fact, ARM documentation mentions some feature +registers are not supposed to be accessed frequently by the OS, and +therefore should be emulated for guests [1]. + +Commit 0388f9c74330 ("arm64: mm: Implement +arch_wants_old_prefaulted_pte()") introduced a read of this register in +the page fault path. But, even when the feature of setting faultaround +pages with the old flag is disabled for a given cpu, we are still paying +the cost of checking the register on every pagefault. This results in an +explosion of vmexit events in KVM guests, which directly impacts the +performance of virtualized workloads. For instance, running kernbench +yields a 15% increase in system time solely due to the increased vmexit +cycles. + +This patch avoids the extra cost by using the sanitized cached value. +It should be safe to do so, since this register mustn't change for a +given cpu. + +[1] https://developer.arm.com/-/media/Arm%20Developer%20Community/PDF/Learn%20the%20Architecture/Armv8-A%20virtualization.pdf?revision=a765a7df-1a00-434d-b241-357bfda2dd31 + +Signed-off-by: Gabriel Krisman Bertazi +Acked-by: Will Deacon +Reviewed-by: Anshuman Khandual +Link: https://lore.kernel.org/r/20230109151955.8292-1-krisman@suse.de +Signed-off-by: Catalin Marinas +Signed-off-by: Sasha Levin +--- + arch/arm64/include/asm/cpufeature.h | 6 +++++- + 1 file changed, 5 insertions(+), 1 deletion(-) + +diff --git a/arch/arm64/include/asm/cpufeature.h b/arch/arm64/include/asm/cpufeature.h +index a77b5f49b3a6c..135f4b0bf3967 100644 +--- a/arch/arm64/include/asm/cpufeature.h ++++ b/arch/arm64/include/asm/cpufeature.h +@@ -839,7 +839,11 @@ static inline bool cpu_has_hw_af(void) + if (!IS_ENABLED(CONFIG_ARM64_HW_AFDBM)) + return false; + +- mmfr1 = read_cpuid(ID_AA64MMFR1_EL1); ++ /* ++ * Use cached version to avoid emulated msr operation on KVM ++ * guests. ++ */ ++ mmfr1 = read_sanitised_ftr_reg(SYS_ID_AA64MMFR1_EL1); + return cpuid_feature_extract_unsigned_field(mmfr1, + ID_AA64MMFR1_HADBS_SHIFT); + } +-- +2.40.1 + diff --git a/queue-5.15/asoc-soc-utils-export-snd_soc_dai_is_dummy-symbol.patch b/queue-5.15/asoc-soc-utils-export-snd_soc_dai_is_dummy-symbol.patch new file mode 100644 index 00000000000..3a03b1375cf --- /dev/null +++ b/queue-5.15/asoc-soc-utils-export-snd_soc_dai_is_dummy-symbol.patch @@ -0,0 +1,35 @@ +From dad1fe1a68113da96f714b10a630e9dc88d9ca1e Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Thu, 7 Sep 2023 20:32:24 +0530 +Subject: ASoC: soc-utils: Export snd_soc_dai_is_dummy() symbol + +From: Sameer Pujar + +[ Upstream commit f101583fa9f8c3f372d4feb61d67da0ccbf4d9a5 ] + +Export symbol snd_soc_dai_is_dummy() for usage outside core driver +modules. This is required by Tegra ASoC machine driver. + +Signed-off-by: Sameer Pujar +Link: https://lore.kernel.org/r/1694098945-32760-2-git-send-email-spujar@nvidia.com +Signed-off-by: Mark Brown +Signed-off-by: Sasha Levin +--- + sound/soc/soc-utils.c | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/sound/soc/soc-utils.c b/sound/soc/soc-utils.c +index f2c9d97c19c74..5512a2dd2af94 100644 +--- a/sound/soc/soc-utils.c ++++ b/sound/soc/soc-utils.c +@@ -159,6 +159,7 @@ int snd_soc_dai_is_dummy(struct snd_soc_dai *dai) + return 1; + return 0; + } ++EXPORT_SYMBOL_GPL(snd_soc_dai_is_dummy); + + int snd_soc_component_is_dummy(struct snd_soc_component *component) + { +-- +2.40.1 + diff --git a/queue-5.15/asoc-tegra-fix-redundant-plla-and-plla_out0-updates.patch b/queue-5.15/asoc-tegra-fix-redundant-plla-and-plla_out0-updates.patch new file mode 100644 index 00000000000..5fc471e7c9f --- /dev/null +++ b/queue-5.15/asoc-tegra-fix-redundant-plla-and-plla_out0-updates.patch @@ -0,0 +1,90 @@ +From fab169c0d1785800d4bac591c2515143eaf5cce4 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Thu, 7 Sep 2023 20:32:25 +0530 +Subject: ASoC: tegra: Fix redundant PLLA and PLLA_OUT0 updates + +From: Sameer Pujar + +[ Upstream commit e765886249c533e1bb5cbc3cd741bad677417312 ] + +Tegra audio graph card has many DAI links which connects internal +AHUB modules and external audio codecs. Since these are DPCM links, +hw_params() call in the machine driver happens for each connected +BE link and PLLA is updated every time. This is not really needed +for all links as only I/O link DAIs derive respective clocks from +PLLA_OUT0 and thus from PLLA. Hence add checks to limit the clock +updates to DAIs over I/O links. + +This found to be fixing a DMIC clock discrepancy which is suspected +to happen because of back to back quick PLLA and PLLA_OUT0 rate +updates. This was observed on Jetson TX2 platform where DMIC clock +ended up with unexpected value. + +Fixes: 202e2f774543 ("ASoC: tegra: Add audio graph based card driver") +Cc: stable@vger.kernel.org +Signed-off-by: Sameer Pujar +Link: https://lore.kernel.org/r/1694098945-32760-3-git-send-email-spujar@nvidia.com +Signed-off-by: Mark Brown +Signed-off-by: Sasha Levin +--- + sound/soc/tegra/tegra_audio_graph_card.c | 30 ++++++++++++++---------- + 1 file changed, 17 insertions(+), 13 deletions(-) + +diff --git a/sound/soc/tegra/tegra_audio_graph_card.c b/sound/soc/tegra/tegra_audio_graph_card.c +index 1f2c5018bf5ac..4737e776d3837 100644 +--- a/sound/soc/tegra/tegra_audio_graph_card.c ++++ b/sound/soc/tegra/tegra_audio_graph_card.c +@@ -10,6 +10,7 @@ + #include + #include + #include ++#include + + #define MAX_PLLA_OUT0_DIV 128 + +@@ -44,6 +45,21 @@ struct tegra_audio_cdata { + unsigned int plla_out0_rates[NUM_RATE_TYPE]; + }; + ++static bool need_clk_update(struct snd_soc_dai *dai) ++{ ++ if (snd_soc_dai_is_dummy(dai) || ++ !dai->driver->ops || ++ !dai->driver->name) ++ return false; ++ ++ if (strstr(dai->driver->name, "I2S") || ++ strstr(dai->driver->name, "DMIC") || ++ strstr(dai->driver->name, "DSPK")) ++ return true; ++ ++ return false; ++} ++ + /* Setup PLL clock as per the given sample rate */ + static int tegra_audio_graph_update_pll(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params) +@@ -140,19 +156,7 @@ static int tegra_audio_graph_hw_params(struct snd_pcm_substream *substream, + struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0); + int err; + +- /* +- * This gets called for each DAI link (FE or BE) when DPCM is used. +- * We may not want to update PLLA rate for each call. So PLLA update +- * must be restricted to external I/O links (I2S, DMIC or DSPK) since +- * they actually depend on it. I/O modules update their clocks in +- * hw_param() of their respective component driver and PLLA rate +- * update here helps them to derive appropriate rates. +- * +- * TODO: When more HW accelerators get added (like sample rate +- * converter, volume gain controller etc., which don't really +- * depend on PLLA) we need a better way to filter here. +- */ +- if (cpu_dai->driver->ops && rtd->dai_link->no_pcm) { ++ if (need_clk_update(cpu_dai)) { + err = tegra_audio_graph_update_pll(substream, params); + if (err) + return err; +-- +2.40.1 + diff --git a/queue-5.15/nfs-cleanup-unused-rpc_clnt-variable.patch b/queue-5.15/nfs-cleanup-unused-rpc_clnt-variable.patch new file mode 100644 index 00000000000..303333883d8 --- /dev/null +++ b/queue-5.15/nfs-cleanup-unused-rpc_clnt-variable.patch @@ -0,0 +1,39 @@ +From 51783a501fcc978d2d903f4d2d3249ce794a6dbb Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Thu, 20 Apr 2023 12:17:35 -0400 +Subject: NFS: Cleanup unused rpc_clnt variable + +From: Benjamin Coddington + +[ Upstream commit e025f0a73f6acb920d86549b2177a5883535421d ] + +The root rpc_clnt is not used here, clean it up. + +Fixes: 4dc73c679114 ("NFSv4: keep state manager thread active if swap is enabled") +Signed-off-by: Benjamin Coddington +Reviewed-by: NeilBrown +Signed-off-by: Anna Schumaker +Stable-dep-of: 956fd46f97d2 ("NFSv4: Fix a state manager thread deadlock regression") +Signed-off-by: Sasha Levin +--- + fs/nfs/nfs4state.c | 4 ---- + 1 file changed, 4 deletions(-) + +diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c +index 15ba6ad1c571f..d0183a7b01a49 100644 +--- a/fs/nfs/nfs4state.c ++++ b/fs/nfs/nfs4state.c +@@ -1213,10 +1213,6 @@ void nfs4_schedule_state_manager(struct nfs_client *clp) + { + struct task_struct *task; + char buf[INET6_ADDRSTRLEN + sizeof("-manager") + 1]; +- struct rpc_clnt *cl = clp->cl_rpcclient; +- +- while (cl != cl->cl_parent) +- cl = cl->cl_parent; + + set_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state); + if (test_and_set_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state) != 0) { +-- +2.40.1 + diff --git a/queue-5.15/nfs-rename-nfs_client_kset-to-nfs_kset.patch b/queue-5.15/nfs-rename-nfs_client_kset-to-nfs_kset.patch new file mode 100644 index 00000000000..34c5376d872 --- /dev/null +++ b/queue-5.15/nfs-rename-nfs_client_kset-to-nfs_kset.patch @@ -0,0 +1,73 @@ +From 807543fea5494a76bf87956a56d9481a767930e1 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Thu, 15 Jun 2023 14:07:22 -0400 +Subject: NFS: rename nfs_client_kset to nfs_kset + +From: Benjamin Coddington + +[ Upstream commit 8b18a2edecc0741b0eecf8b18fdb356a0f8682de ] + +Be brief and match the subsystem name. There's no need to distinguish this +kset variable from the server. + +Signed-off-by: Benjamin Coddington +Signed-off-by: Trond Myklebust +Stable-dep-of: 956fd46f97d2 ("NFSv4: Fix a state manager thread deadlock regression") +Signed-off-by: Sasha Levin +--- + fs/nfs/sysfs.c | 16 ++++++++-------- + 1 file changed, 8 insertions(+), 8 deletions(-) + +diff --git a/fs/nfs/sysfs.c b/fs/nfs/sysfs.c +index 8cb70755e3c9e..f7f778e3e5ca7 100644 +--- a/fs/nfs/sysfs.c ++++ b/fs/nfs/sysfs.c +@@ -18,7 +18,7 @@ + #include "sysfs.h" + + struct kobject *nfs_client_kobj; +-static struct kset *nfs_client_kset; ++static struct kset *nfs_kset; + + static void nfs_netns_object_release(struct kobject *kobj) + { +@@ -55,13 +55,13 @@ static struct kobject *nfs_netns_object_alloc(const char *name, + + int nfs_sysfs_init(void) + { +- nfs_client_kset = kset_create_and_add("nfs", NULL, fs_kobj); +- if (!nfs_client_kset) ++ nfs_kset = kset_create_and_add("nfs", NULL, fs_kobj); ++ if (!nfs_kset) + return -ENOMEM; +- nfs_client_kobj = nfs_netns_object_alloc("net", nfs_client_kset, NULL); ++ nfs_client_kobj = nfs_netns_object_alloc("net", nfs_kset, NULL); + if (!nfs_client_kobj) { +- kset_unregister(nfs_client_kset); +- nfs_client_kset = NULL; ++ kset_unregister(nfs_kset); ++ nfs_kset = NULL; + return -ENOMEM; + } + return 0; +@@ -70,7 +70,7 @@ int nfs_sysfs_init(void) + void nfs_sysfs_exit(void) + { + kobject_put(nfs_client_kobj); +- kset_unregister(nfs_client_kset); ++ kset_unregister(nfs_kset); + } + + static ssize_t nfs_netns_identifier_show(struct kobject *kobj, +@@ -158,7 +158,7 @@ static struct nfs_netns_client *nfs_netns_client_alloc(struct kobject *parent, + p = kzalloc(sizeof(*p), GFP_KERNEL); + if (p) { + p->net = net; +- p->kobject.kset = nfs_client_kset; ++ p->kobject.kset = nfs_kset; + if (kobject_init_and_add(&p->kobject, &nfs_netns_client_type, + parent, "nfs_client") == 0) + return p; +-- +2.40.1 + diff --git a/queue-5.15/nfsv4-fix-a-state-manager-thread-deadlock-regression.patch b/queue-5.15/nfsv4-fix-a-state-manager-thread-deadlock-regression.patch new file mode 100644 index 00000000000..212f2b5a98b --- /dev/null +++ b/queue-5.15/nfsv4-fix-a-state-manager-thread-deadlock-regression.patch @@ -0,0 +1,117 @@ +From 9199870259a0d567af29164eefafdb7a96037abf Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Sun, 24 Sep 2023 13:14:15 -0400 +Subject: NFSv4: Fix a state manager thread deadlock regression + +From: Trond Myklebust + +[ Upstream commit 956fd46f97d238032cb5fa4771cdaccc6e760f9a ] + +Commit 4dc73c679114 reintroduces the deadlock that was fixed by commit +aeabb3c96186 ("NFSv4: Fix a NFSv4 state manager deadlock") because it +prevents the setup of new threads to handle reboot recovery, while the +older recovery thread is stuck returning delegations. + +Fixes: 4dc73c679114 ("NFSv4: keep state manager thread active if swap is enabled") +Cc: stable@vger.kernel.org +Signed-off-by: Trond Myklebust +Signed-off-by: Anna Schumaker +Signed-off-by: Sasha Levin +--- + fs/nfs/nfs4proc.c | 4 +++- + fs/nfs/nfs4state.c | 36 +++++++++++++++++++++++++----------- + 2 files changed, 28 insertions(+), 12 deletions(-) + +diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c +index 32204c0b3d098..3275763b78bc8 100644 +--- a/fs/nfs/nfs4proc.c ++++ b/fs/nfs/nfs4proc.c +@@ -10557,7 +10557,9 @@ static void nfs4_disable_swap(struct inode *inode) + */ + struct nfs_client *clp = NFS_SERVER(inode)->nfs_client; + +- nfs4_schedule_state_manager(clp); ++ set_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state); ++ clear_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state); ++ wake_up_var(&clp->cl_state); + } + + static const struct inode_operations nfs4_dir_inode_operations = { +diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c +index d0183a7b01a49..7590d059eb78e 100644 +--- a/fs/nfs/nfs4state.c ++++ b/fs/nfs/nfs4state.c +@@ -1213,13 +1213,23 @@ void nfs4_schedule_state_manager(struct nfs_client *clp) + { + struct task_struct *task; + char buf[INET6_ADDRSTRLEN + sizeof("-manager") + 1]; ++ struct rpc_clnt *clnt = clp->cl_rpcclient; ++ bool swapon = false; + + set_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state); +- if (test_and_set_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state) != 0) { +- wake_up_var(&clp->cl_state); +- return; ++ ++ if (atomic_read(&clnt->cl_swapper)) { ++ swapon = !test_and_set_bit(NFS4CLNT_MANAGER_AVAILABLE, ++ &clp->cl_state); ++ if (!swapon) { ++ wake_up_var(&clp->cl_state); ++ return; ++ } + } +- set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state); ++ ++ if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0) ++ return; ++ + __module_get(THIS_MODULE); + refcount_inc(&clp->cl_count); + +@@ -1236,8 +1246,9 @@ void nfs4_schedule_state_manager(struct nfs_client *clp) + __func__, PTR_ERR(task)); + if (!nfs_client_init_is_complete(clp)) + nfs_mark_client_ready(clp, PTR_ERR(task)); ++ if (swapon) ++ clear_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state); + nfs4_clear_state_manager_bit(clp); +- clear_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state); + nfs_put_client(clp); + module_put(THIS_MODULE); + } +@@ -2726,22 +2737,25 @@ static int nfs4_run_state_manager(void *ptr) + + allow_signal(SIGKILL); + again: +- set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state); + nfs4_state_manager(clp); +- if (atomic_read(&cl->cl_swapper)) { ++ ++ if (test_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state) && ++ !test_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state)) { + wait_var_event_interruptible(&clp->cl_state, + test_bit(NFS4CLNT_RUN_MANAGER, + &clp->cl_state)); +- if (atomic_read(&cl->cl_swapper) && +- test_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state)) ++ if (!atomic_read(&cl->cl_swapper)) ++ clear_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state); ++ if (refcount_read(&clp->cl_count) > 1 && !signalled() && ++ !test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state)) + goto again; + /* Either no longer a swapper, or were signalled */ ++ clear_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state); + } +- clear_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state); + + if (refcount_read(&clp->cl_count) > 1 && !signalled() && + test_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state) && +- !test_and_set_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state)) ++ !test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state)) + goto again; + + nfs_put_client(clp); +-- +2.40.1 + diff --git a/queue-5.15/ring-buffer-fix-bytes-info-in-per_cpu-buffer-stats.patch b/queue-5.15/ring-buffer-fix-bytes-info-in-per_cpu-buffer-stats.patch new file mode 100644 index 00000000000..bef7952305e --- /dev/null +++ b/queue-5.15/ring-buffer-fix-bytes-info-in-per_cpu-buffer-stats.patch @@ -0,0 +1,149 @@ +From ee10bb894fad7ffcfae39e6333a993949f3f85be Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Thu, 21 Sep 2023 20:54:25 +0800 +Subject: ring-buffer: Fix bytes info in per_cpu buffer stats + +From: Zheng Yejian + +[ Upstream commit 45d99ea451d0c30bfd4864f0fe485d7dac014902 ] + +The 'bytes' info in file 'per_cpu/cpu/stats' means the number of +bytes in cpu buffer that have not been consumed. However, currently +after consuming data by reading file 'trace_pipe', the 'bytes' info +was not changed as expected. + + # cat per_cpu/cpu0/stats + entries: 0 + overrun: 0 + commit overrun: 0 + bytes: 568 <--- 'bytes' is problematical !!! + oldest event ts: 8651.371479 + now ts: 8653.912224 + dropped events: 0 + read events: 8 + +The root cause is incorrect stat on cpu_buffer->read_bytes. To fix it: + 1. When stat 'read_bytes', account consumed event in rb_advance_reader(); + 2. When stat 'entries_bytes', exclude the discarded padding event which + is smaller than minimum size because it is invisible to reader. Then + use rb_page_commit() instead of BUF_PAGE_SIZE at where accounting for + page-based read/remove/overrun. + +Also correct the comments of ring_buffer_bytes_cpu() in this patch. + +Link: https://lore.kernel.org/linux-trace-kernel/20230921125425.1708423-1-zhengyejian1@huawei.com + +Cc: stable@vger.kernel.org +Fixes: c64e148a3be3 ("trace: Add ring buffer stats to measure rate of events") +Signed-off-by: Zheng Yejian +Signed-off-by: Steven Rostedt (Google) +Signed-off-by: Sasha Levin +--- + kernel/trace/ring_buffer.c | 28 +++++++++++++++------------- + 1 file changed, 15 insertions(+), 13 deletions(-) + +diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c +index 352a7de4fc458..e5dc7b5a261c6 100644 +--- a/kernel/trace/ring_buffer.c ++++ b/kernel/trace/ring_buffer.c +@@ -346,6 +346,11 @@ static void rb_init_page(struct buffer_data_page *bpage) + local_set(&bpage->commit, 0); + } + ++static __always_inline unsigned int rb_page_commit(struct buffer_page *bpage) ++{ ++ return local_read(&bpage->page->commit); ++} ++ + static void free_buffer_page(struct buffer_page *bpage) + { + free_page((unsigned long)bpage->page); +@@ -1984,7 +1989,7 @@ rb_remove_pages(struct ring_buffer_per_cpu *cpu_buffer, unsigned long nr_pages) + * Increment overrun to account for the lost events. + */ + local_add(page_entries, &cpu_buffer->overrun); +- local_sub(BUF_PAGE_SIZE, &cpu_buffer->entries_bytes); ++ local_sub(rb_page_commit(to_remove_page), &cpu_buffer->entries_bytes); + local_inc(&cpu_buffer->pages_lost); + } + +@@ -2328,11 +2333,6 @@ rb_reader_event(struct ring_buffer_per_cpu *cpu_buffer) + cpu_buffer->reader_page->read); + } + +-static __always_inline unsigned rb_page_commit(struct buffer_page *bpage) +-{ +- return local_read(&bpage->page->commit); +-} +- + static struct ring_buffer_event * + rb_iter_head_event(struct ring_buffer_iter *iter) + { +@@ -2478,7 +2478,7 @@ rb_handle_head_page(struct ring_buffer_per_cpu *cpu_buffer, + * the counters. + */ + local_add(entries, &cpu_buffer->overrun); +- local_sub(BUF_PAGE_SIZE, &cpu_buffer->entries_bytes); ++ local_sub(rb_page_commit(next_page), &cpu_buffer->entries_bytes); + local_inc(&cpu_buffer->pages_lost); + + /* +@@ -2621,9 +2621,6 @@ rb_reset_tail(struct ring_buffer_per_cpu *cpu_buffer, + + event = __rb_page_index(tail_page, tail); + +- /* account for padding bytes */ +- local_add(BUF_PAGE_SIZE - tail, &cpu_buffer->entries_bytes); +- + /* + * Save the original length to the meta data. + * This will be used by the reader to add lost event +@@ -2637,7 +2634,8 @@ rb_reset_tail(struct ring_buffer_per_cpu *cpu_buffer, + * write counter enough to allow another writer to slip + * in on this page. + * We put in a discarded commit instead, to make sure +- * that this space is not used again. ++ * that this space is not used again, and this space will ++ * not be accounted into 'entries_bytes'. + * + * If we are less than the minimum size, we don't need to + * worry about it. +@@ -2662,6 +2660,9 @@ rb_reset_tail(struct ring_buffer_per_cpu *cpu_buffer, + /* time delta must be non zero */ + event->time_delta = 1; + ++ /* account for padding bytes */ ++ local_add(BUF_PAGE_SIZE - tail, &cpu_buffer->entries_bytes); ++ + /* Make sure the padding is visible before the tail_page->write update */ + smp_wmb(); + +@@ -4177,7 +4178,7 @@ u64 ring_buffer_oldest_event_ts(struct trace_buffer *buffer, int cpu) + EXPORT_SYMBOL_GPL(ring_buffer_oldest_event_ts); + + /** +- * ring_buffer_bytes_cpu - get the number of bytes consumed in a cpu buffer ++ * ring_buffer_bytes_cpu - get the number of bytes unconsumed in a cpu buffer + * @buffer: The ring buffer + * @cpu: The per CPU buffer to read from. + */ +@@ -4685,6 +4686,7 @@ static void rb_advance_reader(struct ring_buffer_per_cpu *cpu_buffer) + + length = rb_event_length(event); + cpu_buffer->reader_page->read += length; ++ cpu_buffer->read_bytes += length; + } + + static void rb_advance_iter(struct ring_buffer_iter *iter) +@@ -5778,7 +5780,7 @@ int ring_buffer_read_page(struct trace_buffer *buffer, + } else { + /* update the entry counter */ + cpu_buffer->read += rb_page_entries(reader); +- cpu_buffer->read_bytes += BUF_PAGE_SIZE; ++ cpu_buffer->read_bytes += rb_page_commit(reader); + + /* swap the pages */ + rb_init_page(bpage); +-- +2.40.1 + diff --git a/queue-5.15/ring-buffer-remove-obsolete-comment-for-free_buffer_.patch b/queue-5.15/ring-buffer-remove-obsolete-comment-for-free_buffer_.patch new file mode 100644 index 00000000000..0bd366f5a28 --- /dev/null +++ b/queue-5.15/ring-buffer-remove-obsolete-comment-for-free_buffer_.patch @@ -0,0 +1,50 @@ +From a32e914f0a360ae18434a68beefb8c040ccccb9f Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Wed, 15 Mar 2023 15:24:46 +0100 +Subject: ring-buffer: remove obsolete comment for free_buffer_page() + +From: Vlastimil Babka + +[ Upstream commit a98151ad53b53f010ee364ec2fd06445b328578b ] + +The comment refers to mm/slob.c which is being removed. It comes from +commit ed56829cb319 ("ring_buffer: reset buffer page when freeing") and +according to Steven the borrowed code was a page mapcount and mapping +reset, which was later removed by commit e4c2ce82ca27 ("ring_buffer: +allocate buffer page pointer"). Thus the comment is not accurate anyway, +remove it. + +Link: https://lore.kernel.org/linux-trace-kernel/20230315142446.27040-1-vbabka@suse.cz + +Cc: Masami Hiramatsu +Cc: Ingo Molnar +Reported-by: Mike Rapoport +Suggested-by: Steven Rostedt (Google) +Fixes: e4c2ce82ca27 ("ring_buffer: allocate buffer page pointer") +Signed-off-by: Vlastimil Babka +Reviewed-by: Mukesh Ojha +Signed-off-by: Steven Rostedt (Google) +Stable-dep-of: 45d99ea451d0 ("ring-buffer: Fix bytes info in per_cpu buffer stats") +Signed-off-by: Sasha Levin +--- + kernel/trace/ring_buffer.c | 4 ---- + 1 file changed, 4 deletions(-) + +diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c +index 2e5f3de7bfb09..352a7de4fc458 100644 +--- a/kernel/trace/ring_buffer.c ++++ b/kernel/trace/ring_buffer.c +@@ -346,10 +346,6 @@ static void rb_init_page(struct buffer_data_page *bpage) + local_set(&bpage->commit, 0); + } + +-/* +- * Also stolen from mm/slob.c. Thanks to Mathieu Desnoyers for pointing +- * this issue out. +- */ + static void free_buffer_page(struct buffer_page *bpage) + { + free_page((unsigned long)bpage->page); +-- +2.40.1 + diff --git a/queue-5.15/series b/queue-5.15/series new file mode 100644 index 00000000000..360433e59ab --- /dev/null +++ b/queue-5.15/series @@ -0,0 +1,10 @@ +spi-zynqmp-gqspi-convert-to-platform-remove-callback.patch +spi-zynqmp-gqspi-fix-clock-imbalance-on-probe-failur.patch +asoc-soc-utils-export-snd_soc_dai_is_dummy-symbol.patch +asoc-tegra-fix-redundant-plla-and-plla_out0-updates.patch +nfs-cleanup-unused-rpc_clnt-variable.patch +nfs-rename-nfs_client_kset-to-nfs_kset.patch +nfsv4-fix-a-state-manager-thread-deadlock-regression.patch +ring-buffer-remove-obsolete-comment-for-free_buffer_.patch +ring-buffer-fix-bytes-info-in-per_cpu-buffer-stats.patch +arm64-avoid-repeated-aa64mmfr1_el1-register-read-on-.patch diff --git a/queue-5.15/spi-zynqmp-gqspi-convert-to-platform-remove-callback.patch b/queue-5.15/spi-zynqmp-gqspi-convert-to-platform-remove-callback.patch new file mode 100644 index 00000000000..b0afe9c3473 --- /dev/null +++ b/queue-5.15/spi-zynqmp-gqspi-convert-to-platform-remove-callback.patch @@ -0,0 +1,66 @@ +From 577eaa5f16fffeafbe7888c81ed193a9425dd6dd Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Fri, 3 Mar 2023 18:20:41 +0100 +Subject: spi: zynqmp-gqspi: Convert to platform remove callback returning void +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +From: Uwe Kleine-König + +[ Upstream commit 3ffefa1d9c9eba60c7f8b4a9ce2df3e4c7f4a88e ] + +The .remove() callback for a platform driver returns an int which makes +many driver authors wrongly assume it's possible to do error handling by +returning an error code. However the value returned is (mostly) ignored +and this typically results in resource leaks. To improve here there is a +quest to make the remove callback return void. In the first step of this +quest all drivers are converted to .remove_new() which already returns +void. + +Trivially convert this driver from always returning zero in the remove +callback to the void returning variant. + +Signed-off-by: Uwe Kleine-König +Link: https://lore.kernel.org/r/20230303172041.2103336-88-u.kleine-koenig@pengutronix.de +Signed-off-by: Mark Brown +Stable-dep-of: 1527b076ae2c ("spi: zynqmp-gqspi: fix clock imbalance on probe failure") +Signed-off-by: Sasha Levin +--- + drivers/spi/spi-zynqmp-gqspi.c | 6 ++---- + 1 file changed, 2 insertions(+), 4 deletions(-) + +diff --git a/drivers/spi/spi-zynqmp-gqspi.c b/drivers/spi/spi-zynqmp-gqspi.c +index 2b5afae8ff7fc..b0c2855093cc9 100644 +--- a/drivers/spi/spi-zynqmp-gqspi.c ++++ b/drivers/spi/spi-zynqmp-gqspi.c +@@ -1221,7 +1221,7 @@ static int zynqmp_qspi_probe(struct platform_device *pdev) + * + * Return: 0 Always + */ +-static int zynqmp_qspi_remove(struct platform_device *pdev) ++static void zynqmp_qspi_remove(struct platform_device *pdev) + { + struct zynqmp_qspi *xqspi = platform_get_drvdata(pdev); + +@@ -1230,8 +1230,6 @@ static int zynqmp_qspi_remove(struct platform_device *pdev) + clk_disable_unprepare(xqspi->pclk); + pm_runtime_set_suspended(&pdev->dev); + pm_runtime_disable(&pdev->dev); +- +- return 0; + } + + static const struct of_device_id zynqmp_qspi_of_match[] = { +@@ -1243,7 +1241,7 @@ MODULE_DEVICE_TABLE(of, zynqmp_qspi_of_match); + + static struct platform_driver zynqmp_qspi_driver = { + .probe = zynqmp_qspi_probe, +- .remove = zynqmp_qspi_remove, ++ .remove_new = zynqmp_qspi_remove, + .driver = { + .name = "zynqmp-qspi", + .of_match_table = zynqmp_qspi_of_match, +-- +2.40.1 + diff --git a/queue-5.15/spi-zynqmp-gqspi-fix-clock-imbalance-on-probe-failur.patch b/queue-5.15/spi-zynqmp-gqspi-fix-clock-imbalance-on-probe-failur.patch new file mode 100644 index 00000000000..9d6c87ae62a --- /dev/null +++ b/queue-5.15/spi-zynqmp-gqspi-fix-clock-imbalance-on-probe-failur.patch @@ -0,0 +1,62 @@ +From 26b19b49784089aa2050f915a3426b387c9b2130 Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Thu, 22 Jun 2023 10:24:35 +0200 +Subject: spi: zynqmp-gqspi: fix clock imbalance on probe failure + +From: Johan Hovold + +[ Upstream commit 1527b076ae2cb6a9c590a02725ed39399fcad1cf ] + +Make sure that the device is not runtime suspended before explicitly +disabling the clocks on probe failure and on driver unbind to avoid a +clock enable-count imbalance. + +Fixes: 9e3a000362ae ("spi: zynqmp: Add pm runtime support") +Cc: stable@vger.kernel.org # 4.19 +Cc: Naga Sureshkumar Relli +Cc: Shubhrajyoti Datta +Signed-off-by: Johan Hovold +Link: https://lore.kernel.org/r/Message-Id: <20230622082435.7873-1-johan+linaro@kernel.org> +Signed-off-by: Mark Brown +Signed-off-by: Sasha Levin +--- + drivers/spi/spi-zynqmp-gqspi.c | 12 ++++++++---- + 1 file changed, 8 insertions(+), 4 deletions(-) + +diff --git a/drivers/spi/spi-zynqmp-gqspi.c b/drivers/spi/spi-zynqmp-gqspi.c +index b0c2855093cc9..237979daf9e67 100644 +--- a/drivers/spi/spi-zynqmp-gqspi.c ++++ b/drivers/spi/spi-zynqmp-gqspi.c +@@ -1199,9 +1199,9 @@ static int zynqmp_qspi_probe(struct platform_device *pdev) + return 0; + + clk_dis_all: +- pm_runtime_put_sync(&pdev->dev); +- pm_runtime_set_suspended(&pdev->dev); + pm_runtime_disable(&pdev->dev); ++ pm_runtime_put_noidle(&pdev->dev); ++ pm_runtime_set_suspended(&pdev->dev); + clk_disable_unprepare(xqspi->refclk); + clk_dis_pclk: + clk_disable_unprepare(xqspi->pclk); +@@ -1225,11 +1225,15 @@ static void zynqmp_qspi_remove(struct platform_device *pdev) + { + struct zynqmp_qspi *xqspi = platform_get_drvdata(pdev); + ++ pm_runtime_get_sync(&pdev->dev); ++ + zynqmp_gqspi_write(xqspi, GQSPI_EN_OFST, 0x0); ++ ++ pm_runtime_disable(&pdev->dev); ++ pm_runtime_put_noidle(&pdev->dev); ++ pm_runtime_set_suspended(&pdev->dev); + clk_disable_unprepare(xqspi->refclk); + clk_disable_unprepare(xqspi->pclk); +- pm_runtime_set_suspended(&pdev->dev); +- pm_runtime_disable(&pdev->dev); + } + + static const struct of_device_id zynqmp_qspi_of_match[] = { +-- +2.40.1 +