From 7095caf2c98fbe85acee6b9a479e2c7ac8b635de Mon Sep 17 00:00:00 2001 From: Greg Kroah-Hartman Date: Mon, 7 Aug 2023 09:57:54 +0200 Subject: [PATCH] 6.1-stable patches added patches: bpf-cpumap-make-sure-kthread-is-running-before-map-update-returns.patch clk-imx93-propagate-correct-error-in-imx93_clocks_probe.patch file-reinstate-f_pos-locking-optimization-for-regular-files.patch --- ...is-running-before-map-update-returns.patch | 137 ++++++++++++++++++ ...-correct-error-in-imx93_clocks_probe.patch | 42 ++++++ ...cking-optimization-for-regular-files.patch | 64 ++++++++ queue-6.1/series | 3 + 4 files changed, 246 insertions(+) create mode 100644 queue-6.1/bpf-cpumap-make-sure-kthread-is-running-before-map-update-returns.patch create mode 100644 queue-6.1/clk-imx93-propagate-correct-error-in-imx93_clocks_probe.patch create mode 100644 queue-6.1/file-reinstate-f_pos-locking-optimization-for-regular-files.patch diff --git a/queue-6.1/bpf-cpumap-make-sure-kthread-is-running-before-map-update-returns.patch b/queue-6.1/bpf-cpumap-make-sure-kthread-is-running-before-map-update-returns.patch new file mode 100644 index 00000000000..37d750aa681 --- /dev/null +++ b/queue-6.1/bpf-cpumap-make-sure-kthread-is-running-before-map-update-returns.patch @@ -0,0 +1,137 @@ +From 640a604585aa30f93e39b17d4d6ba69fcb1e66c9 Mon Sep 17 00:00:00 2001 +From: Hou Tao +Date: Sat, 29 Jul 2023 17:51:06 +0800 +Subject: bpf, cpumap: Make sure kthread is running before map update returns + +From: Hou Tao + +commit 640a604585aa30f93e39b17d4d6ba69fcb1e66c9 upstream. + +The following warning was reported when running stress-mode enabled +xdp_redirect_cpu with some RT threads: + + ------------[ cut here ]------------ + WARNING: CPU: 4 PID: 65 at kernel/bpf/cpumap.c:135 + CPU: 4 PID: 65 Comm: kworker/4:1 Not tainted 6.5.0-rc2+ #1 + Hardware name: QEMU Standard PC (i440FX + PIIX, 1996) + Workqueue: events cpu_map_kthread_stop + RIP: 0010:put_cpu_map_entry+0xda/0x220 + ...... + Call Trace: + + ? show_regs+0x65/0x70 + ? __warn+0xa5/0x240 + ...... + ? put_cpu_map_entry+0xda/0x220 + cpu_map_kthread_stop+0x41/0x60 + process_one_work+0x6b0/0xb80 + worker_thread+0x96/0x720 + kthread+0x1a5/0x1f0 + ret_from_fork+0x3a/0x70 + ret_from_fork_asm+0x1b/0x30 + + +The root cause is the same as commit 436901649731 ("bpf: cpumap: Fix memory +leak in cpu_map_update_elem"). The kthread is stopped prematurely by +kthread_stop() in cpu_map_kthread_stop(), and kthread() doesn't call +cpu_map_kthread_run() at all but XDP program has already queued some +frames or skbs into ptr_ring. So when __cpu_map_ring_cleanup() checks +the ptr_ring, it will find it was not emptied and report a warning. + +An alternative fix is to use __cpu_map_ring_cleanup() to drop these +pending frames or skbs when kthread_stop() returns -EINTR, but it may +confuse the user, because these frames or skbs have been handled +correctly by XDP program. So instead of dropping these frames or skbs, +just make sure the per-cpu kthread is running before +__cpu_map_entry_alloc() returns. + +After apply the fix, the error handle for kthread_stop() will be +unnecessary because it will always return 0, so just remove it. + +Fixes: 6710e1126934 ("bpf: introduce new bpf cpu map type BPF_MAP_TYPE_CPUMAP") +Signed-off-by: Hou Tao +Reviewed-by: Pu Lehui +Acked-by: Jesper Dangaard Brouer +Link: https://lore.kernel.org/r/20230729095107.1722450-2-houtao@huaweicloud.com +Signed-off-by: Martin KaFai Lau +Signed-off-by: Greg Kroah-Hartman +--- + kernel/bpf/cpumap.c | 21 +++++++++++---------- + 1 file changed, 11 insertions(+), 10 deletions(-) + +--- a/kernel/bpf/cpumap.c ++++ b/kernel/bpf/cpumap.c +@@ -26,6 +26,7 @@ + #include + #include + #include ++#include + #include + #include + +@@ -71,6 +72,7 @@ struct bpf_cpu_map_entry { + struct rcu_head rcu; + + struct work_struct kthread_stop_wq; ++ struct completion kthread_running; + }; + + struct bpf_cpu_map { +@@ -164,7 +166,6 @@ static void put_cpu_map_entry(struct bpf + static void cpu_map_kthread_stop(struct work_struct *work) + { + struct bpf_cpu_map_entry *rcpu; +- int err; + + rcpu = container_of(work, struct bpf_cpu_map_entry, kthread_stop_wq); + +@@ -174,14 +175,7 @@ static void cpu_map_kthread_stop(struct + rcu_barrier(); + + /* kthread_stop will wake_up_process and wait for it to complete */ +- err = kthread_stop(rcpu->kthread); +- if (err) { +- /* kthread_stop may be called before cpu_map_kthread_run +- * is executed, so we need to release the memory related +- * to rcpu. +- */ +- put_cpu_map_entry(rcpu); +- } ++ kthread_stop(rcpu->kthread); + } + + static void cpu_map_bpf_prog_run_skb(struct bpf_cpu_map_entry *rcpu, +@@ -309,11 +303,11 @@ static int cpu_map_bpf_prog_run(struct b + return nframes; + } + +- + static int cpu_map_kthread_run(void *data) + { + struct bpf_cpu_map_entry *rcpu = data; + ++ complete(&rcpu->kthread_running); + set_current_state(TASK_INTERRUPTIBLE); + + /* When kthread gives stop order, then rcpu have been disconnected +@@ -478,6 +472,7 @@ __cpu_map_entry_alloc(struct bpf_map *ma + goto free_ptr_ring; + + /* Setup kthread */ ++ init_completion(&rcpu->kthread_running); + rcpu->kthread = kthread_create_on_node(cpu_map_kthread_run, rcpu, numa, + "cpumap/%d/map:%d", cpu, + map->id); +@@ -491,6 +486,12 @@ __cpu_map_entry_alloc(struct bpf_map *ma + kthread_bind(rcpu->kthread, cpu); + wake_up_process(rcpu->kthread); + ++ /* Make sure kthread has been running, so kthread_stop() will not ++ * stop the kthread prematurely and all pending frames or skbs ++ * will be handled by the kthread before kthread_stop() returns. ++ */ ++ wait_for_completion(&rcpu->kthread_running); ++ + return rcpu; + + free_prog: diff --git a/queue-6.1/clk-imx93-propagate-correct-error-in-imx93_clocks_probe.patch b/queue-6.1/clk-imx93-propagate-correct-error-in-imx93_clocks_probe.patch new file mode 100644 index 00000000000..49fb964863a --- /dev/null +++ b/queue-6.1/clk-imx93-propagate-correct-error-in-imx93_clocks_probe.patch @@ -0,0 +1,42 @@ +From a29b2fccf5f2689a9637be85ff1f51c834c6fb33 Mon Sep 17 00:00:00 2001 +From: Geert Uytterhoeven +Date: Tue, 11 Jul 2023 17:08:12 +0200 +Subject: clk: imx93: Propagate correct error in imx93_clocks_probe() + +From: Geert Uytterhoeven + +commit a29b2fccf5f2689a9637be85ff1f51c834c6fb33 upstream. + +smatch reports: + + drivers/clk/imx/clk-imx93.c:294 imx93_clocks_probe() error: uninitialized symbol 'base'. + +Indeed, in case of an error, the wrong (yet uninitialized) variable is +converted to an error code and returned. +Fix this by propagating the error code in the correct variable. + +Fixes: e02ba11b45764705 ("clk: imx93: fix memory leak and missing unwind goto in imx93_clocks_probe") +Reported-by: Dan Carpenter +Closes: https://lore.kernel.org/all/9c2acd81-3ad8-485d-819e-9e4201277831@kadam.mountain +Reported-by: kernel test robot +Closes: https://lore.kernel.org/all/202306161533.4YDmL22b-lkp@intel.com/ +Signed-off-by: Geert Uytterhoeven +Link: https://lore.kernel.org/r/20230711150812.3562221-1-geert+renesas@glider.be +Reviewed-by: Peng Fan +Signed-off-by: Stephen Boyd +Signed-off-by: Greg Kroah-Hartman +--- + drivers/clk/imx/clk-imx93.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +--- a/drivers/clk/imx/clk-imx93.c ++++ b/drivers/clk/imx/clk-imx93.c +@@ -288,7 +288,7 @@ static int imx93_clocks_probe(struct pla + anatop_base = devm_of_iomap(dev, np, 0, NULL); + of_node_put(np); + if (WARN_ON(IS_ERR(anatop_base))) { +- ret = PTR_ERR(base); ++ ret = PTR_ERR(anatop_base); + goto unregister_hws; + } + diff --git a/queue-6.1/file-reinstate-f_pos-locking-optimization-for-regular-files.patch b/queue-6.1/file-reinstate-f_pos-locking-optimization-for-regular-files.patch new file mode 100644 index 00000000000..989cb861bd5 --- /dev/null +++ b/queue-6.1/file-reinstate-f_pos-locking-optimization-for-regular-files.patch @@ -0,0 +1,64 @@ +From 797964253d358cf8d705614dda394dbe30120223 Mon Sep 17 00:00:00 2001 +From: Linus Torvalds +Date: Thu, 3 Aug 2023 11:35:53 -0700 +Subject: file: reinstate f_pos locking optimization for regular files + +From: Linus Torvalds + +commit 797964253d358cf8d705614dda394dbe30120223 upstream. + +In commit 20ea1e7d13c1 ("file: always lock position for +FMODE_ATOMIC_POS") we ended up always taking the file pos lock, because +pidfd_getfd() could get a reference to the file even when it didn't have +an elevated file count due to threading of other sharing cases. + +But Mateusz Guzik reports that the extra locking is actually measurable, +so let's re-introduce the optimization, and only force the locking for +directory traversal. + +Directories need the lock for correctness reasons, while regular files +only need it for "POSIX semantics". Since pidfd_getfd() is about +debuggers etc special things that are _way_ outside of POSIX, we can +relax the rules for that case. + +Reported-by: Mateusz Guzik +Cc: Christian Brauner +Link: https://lore.kernel.org/linux-fsdevel/20230803095311.ijpvhx3fyrbkasul@f/ +Signed-off-by: Linus Torvalds +Signed-off-by: Greg Kroah-Hartman +--- + fs/file.c | 18 +++++++++++++++++- + 1 file changed, 17 insertions(+), 1 deletion(-) + +--- a/fs/file.c ++++ b/fs/file.c +@@ -1036,12 +1036,28 @@ unsigned long __fdget_raw(unsigned int f + return __fget_light(fd, 0); + } + ++/* ++ * Try to avoid f_pos locking. We only need it if the ++ * file is marked for FMODE_ATOMIC_POS, and it can be ++ * accessed multiple ways. ++ * ++ * Always do it for directories, because pidfd_getfd() ++ * can make a file accessible even if it otherwise would ++ * not be, and for directories this is a correctness ++ * issue, not a "POSIX requirement". ++ */ ++static inline bool file_needs_f_pos_lock(struct file *file) ++{ ++ return (file->f_mode & FMODE_ATOMIC_POS) && ++ (file_count(file) > 1 || S_ISDIR(file_inode(file)->i_mode)); ++} ++ + unsigned long __fdget_pos(unsigned int fd) + { + unsigned long v = __fdget(fd); + struct file *file = (struct file *)(v & ~3); + +- if (file && (file->f_mode & FMODE_ATOMIC_POS)) { ++ if (file && file_needs_f_pos_lock(file)) { + v |= FDPUT_POS_UNLOCK; + mutex_lock(&file->f_pos_lock); + } diff --git a/queue-6.1/series b/queue-6.1/series index 9acc4f24696..efc49ce17e9 100644 --- a/queue-6.1/series +++ b/queue-6.1/series @@ -94,3 +94,6 @@ open-make-resolve_cached-correctly-test-for-o_tmpfile.patch drm-ttm-check-null-pointer-before-accessing-when-swapping.patch drm-i915-fix-premature-release-of-request-s-reusable-memory.patch drm-i915-gt-cleanup-aux-invalidation-registers.patch +clk-imx93-propagate-correct-error-in-imx93_clocks_probe.patch +bpf-cpumap-make-sure-kthread-is-running-before-map-update-returns.patch +file-reinstate-f_pos-locking-optimization-for-regular-files.patch -- 2.47.3