diff --git a/patches.suse/iwlwifi-module-firmware-ucode-fix.patch b/patches.suse/iwlwifi-module-firmware-ucode-fix.patch deleted file mode 100644 index 42bd675..0000000 --- a/patches.suse/iwlwifi-module-firmware-ucode-fix.patch +++ /dev/null @@ -1,34 +0,0 @@ -From: Takashi Iwai -Subject: iwlwifi: Fix MODULE_FIRMWARE() for non-existing ucode version -Patch-mainline: Never, temporary workaround -References: boo#1191417 - -iwlwifi driver declares the requested firmware *-72.ucode for 22000 -series, but that version isn't found in the upstream linux-firmware -tree. As a result, the installation image (and initrd) misses the -requested firmware, which leads to the non-working WiFi. - -As a temporary fix, correct the ucode version to the existing one, -*-71. - -Signed-off-by: Takashi Iwai - ---- - drivers/net/wireless/intel/iwlwifi/cfg/22000.c | 6 +++++- - 1 file changed, 5 insertions(+), 1 deletion(-) - ---- a/drivers/net/wireless/intel/iwlwifi/cfg/22000.c -+++ b/drivers/net/wireless/intel/iwlwifi/cfg/22000.c -@@ -10,7 +10,11 @@ - #include "fw/api/txq.h" - - /* Highest firmware API version supported */ --#define IWL_22000_UCODE_API_MAX 72 -+/* FIXME: Intel never released *-72.ucode but only *-71.ucode (as of 2022 Aug). -+ * For fixing a spurious kernel error and initrd creation, -+ * set to 71 instead of non-existing 72 -+ */ -+#define IWL_22000_UCODE_API_MAX 71 - - /* Lowest firmware API version supported */ - #define IWL_22000_UCODE_API_MIN 39 diff --git a/patches.suse/locking-rwsem-Disable-preemption-at-all-down_read-an.patch b/patches.suse/locking-rwsem-Disable-preemption-at-all-down_read-an.patch deleted file mode 100644 index 66bbc67..0000000 --- a/patches.suse/locking-rwsem-Disable-preemption-at-all-down_read-an.patch +++ /dev/null @@ -1,111 +0,0 @@ -From: Waiman Long -Date: Thu, 17 Nov 2022 21:20:12 -0500 -Subject: [PATCH] locking/rwsem: Disable preemption at all down_read*() and - up_read() code paths -Patch-mainline: Not yet, testing -References: bsc#1204996 - -Commit 91d2a812dfb9 ("locking/rwsem: Make handoff writer optimistically -spin on owner") assumes that when the owner field is changed to NULL, -the lock will become free soon. Commit 48dfb5d2560d ("locking/rwsem: -Disable preemption while trying for rwsem lock") disables preemption -when acquiring rwsem for write. However, preemption has not yet been -disabled when acquiring a read lock on a rwsem. So a reader can add a -RWSEM_READER_BIAS to count without setting owner to signal a reader, -got preempted out by a RT task which then spins in the writer slowpath -as owner remains NULL leading to live lock. - -One easy way to fix this problem is to disable preemption at all the -down_read*() and up_read() code paths as implemented in this patch. - -Fixes: 91d2a812dfb9 ("locking/rwsem: Make handoff writer optimistically spin on owner") -Reported-by: Mukesh Ojha -Suggested-by: Peter Zijlstra -Signed-off-by: Waiman Long -Signed-off-by: Jiri Wiesner ---- - kernel/locking/rwsem.c | 24 ++++++++++++++++++------ - 1 file changed, 18 insertions(+), 6 deletions(-) - -diff --git a/kernel/locking/rwsem.c b/kernel/locking/rwsem.c -index 9024d957d4c8e..39bed6777d42f 100644 ---- a/kernel/locking/rwsem.c -+++ b/kernel/locking/rwsem.c -@@ -1088,7 +1088,7 @@ rwsem_down_read_slowpath(struct rw_semaphore *sem, long count, unsigned int stat - /* Ordered by sem->wait_lock against rwsem_mark_wake(). */ - break; - } -- schedule(); -+ schedule_preempt_disabled(); - lockevent_inc(rwsem_sleep_reader); - } - -@@ -1244,14 +1244,20 @@ static struct rw_semaphore *rwsem_downgrade_wake(struct rw_semaphore *sem) - */ - static inline int __down_read_common(struct rw_semaphore *sem, int state) - { -+ int ret = 0; - long count; - -+ preempt_disable(); - if (!rwsem_read_trylock(sem, &count)) { -- if (IS_ERR(rwsem_down_read_slowpath(sem, count, state))) -- return -EINTR; -+ if (IS_ERR(rwsem_down_read_slowpath(sem, count, state))) { -+ ret = -EINTR; -+ goto out; -+ } - DEBUG_RWSEMS_WARN_ON(!is_rwsem_reader_owned(sem), sem); - } -- return 0; -+out: -+ preempt_enable(); -+ return ret; - } - - static inline void __down_read(struct rw_semaphore *sem) -@@ -1271,19 +1277,23 @@ static inline int __down_read_killable(struct rw_semaphore *sem) - - static inline int __down_read_trylock(struct rw_semaphore *sem) - { -+ int ret = 0; - long tmp; - - DEBUG_RWSEMS_WARN_ON(sem->magic != sem, sem); - -+ preempt_disable(); - tmp = atomic_long_read(&sem->count); - while (!(tmp & RWSEM_READ_FAILED_MASK)) { - if (atomic_long_try_cmpxchg_acquire(&sem->count, &tmp, - tmp + RWSEM_READER_BIAS)) { - rwsem_set_reader_owned(sem); -- return 1; -+ ret = 1; -+ break; - } - } -- return 0; -+ preempt_enable(); -+ return ret; - } - - /* -@@ -1325,6 +1335,7 @@ static inline void __up_read(struct rw_semaphore *sem) - DEBUG_RWSEMS_WARN_ON(sem->magic != sem, sem); - DEBUG_RWSEMS_WARN_ON(!is_rwsem_reader_owned(sem), sem); - -+ preempt_disable(); - rwsem_clear_reader_owned(sem); - tmp = atomic_long_add_return_release(-RWSEM_READER_BIAS, &sem->count); - DEBUG_RWSEMS_WARN_ON(tmp < 0, sem); -@@ -1333,6 +1344,7 @@ static inline void __up_read(struct rw_semaphore *sem) - clear_nonspinnable(sem); - rwsem_wake(sem); - } -+ preempt_enable(); - } - - /* --- -2.35.3 - diff --git a/patches.suse/locking-rwsem-Disable-preemption-at-all-down_write-a.patch b/patches.suse/locking-rwsem-Disable-preemption-at-all-down_write-a.patch deleted file mode 100644 index 5bf0fcd..0000000 --- a/patches.suse/locking-rwsem-Disable-preemption-at-all-down_write-a.patch +++ /dev/null @@ -1,156 +0,0 @@ -From: Waiman Long -Date: Thu, 17 Nov 2022 21:20:13 -0500 -Subject: [PATCH] locking/rwsem: Disable preemption at all down_write*() and - up_write() code paths -Patch-mainline: Not yet, testing -References: bsc#1204996 - -The previous patch has disabled preemption at all the down_read() -and up_read() code paths. For symmetry, this patch extends commit -48dfb5d2560d ("locking/rwsem: Disable preemption while trying for rwsem -lock") to have preemption disabled at all the down_write() and up_write() -code path including downgrade_write(). - -Suggested-by: Peter Zijlstra -Signed-off-by: Waiman Long -Signed-off-by: Jiri Wiesner ---- - kernel/locking/rwsem.c | 38 +++++++++++++++++++------------------- - 1 file changed, 19 insertions(+), 19 deletions(-) - -diff --git a/kernel/locking/rwsem.c b/kernel/locking/rwsem.c -index 39bed6777d42f..ceab37552b50e 100644 ---- a/kernel/locking/rwsem.c -+++ b/kernel/locking/rwsem.c -@@ -255,16 +255,13 @@ static inline bool rwsem_read_trylock(struct rw_semaphore *sem, long *cntp) - static inline bool rwsem_write_trylock(struct rw_semaphore *sem) - { - long tmp = RWSEM_UNLOCKED_VALUE; -- bool ret = false; - -- preempt_disable(); - if (atomic_long_try_cmpxchg_acquire(&sem->count, &tmp, RWSEM_WRITER_LOCKED)) { - rwsem_set_owner(sem); -- ret = true; -+ return true; - } - -- preempt_enable(); -- return ret; -+ return false; - } - - /* -@@ -715,7 +712,6 @@ static inline bool rwsem_can_spin_on_owner(struct rw_semaphore *sem) - return false; - } - -- preempt_disable(); - /* - * Disable preemption is equal to the RCU read-side crital section, - * thus the task_strcut structure won't go away. -@@ -727,7 +723,6 @@ static inline bool rwsem_can_spin_on_owner(struct rw_semaphore *sem) - if ((flags & RWSEM_NONSPINNABLE) || - (owner && !(flags & RWSEM_READER_OWNED) && !owner_on_cpu(owner))) - ret = false; -- preempt_enable(); - - lockevent_cond_inc(rwsem_opt_fail, !ret); - return ret; -@@ -827,8 +822,6 @@ static bool rwsem_optimistic_spin(struct rw_semaphore *sem) - int loop = 0; - u64 rspin_threshold = 0; - -- preempt_disable(); -- - /* sem->wait_lock should not be held when doing optimistic spinning */ - if (!osq_lock(&sem->osq)) - goto done; -@@ -936,7 +929,6 @@ static bool rwsem_optimistic_spin(struct rw_semaphore *sem) - } - osq_unlock(&sem->osq); - done: -- preempt_enable(); - lockevent_cond_inc(rwsem_opt_fail, !taken); - return taken; - } -@@ -1171,15 +1163,12 @@ rwsem_down_write_slowpath(struct rw_semaphore *sem, int state) - if (waiter.handoff_set) { - enum owner_state owner_state; - -- preempt_disable(); - owner_state = rwsem_spin_on_owner(sem); -- preempt_enable(); -- - if (owner_state == OWNER_NULL) - goto trylock_again; - } - -- schedule(); -+ schedule_preempt_disabled(); - lockevent_inc(rwsem_sleep_writer); - set_current_state(state); - trylock_again: -@@ -1301,12 +1290,15 @@ static inline int __down_read_trylock(struct rw_semaphore *sem) - */ - static inline int __down_write_common(struct rw_semaphore *sem, int state) - { -+ int ret = 0; -+ -+ preempt_disable(); - if (unlikely(!rwsem_write_trylock(sem))) { - if (IS_ERR(rwsem_down_write_slowpath(sem, state))) -- return -EINTR; -+ ret = -EINTR; - } -- -- return 0; -+ preempt_enable(); -+ return ret; - } - - static inline void __down_write(struct rw_semaphore *sem) -@@ -1321,8 +1313,14 @@ static inline int __down_write_killable(struct rw_semaphore *sem) - - static inline int __down_write_trylock(struct rw_semaphore *sem) - { -+ int ret; -+ -+ preempt_disable(); - DEBUG_RWSEMS_WARN_ON(sem->magic != sem, sem); -- return rwsem_write_trylock(sem); -+ ret = rwsem_write_trylock(sem); -+ preempt_enable(); -+ -+ return ret; - } - - /* -@@ -1365,9 +1363,9 @@ static inline void __up_write(struct rw_semaphore *sem) - preempt_disable(); - rwsem_clear_owner(sem); - tmp = atomic_long_fetch_add_release(-RWSEM_WRITER_LOCKED, &sem->count); -- preempt_enable(); - if (unlikely(tmp & RWSEM_FLAG_WAITERS)) - rwsem_wake(sem); -+ preempt_enable(); - } - - /* -@@ -1385,11 +1383,13 @@ static inline void __downgrade_write(struct rw_semaphore *sem) - * write side. As such, rely on RELEASE semantics. - */ - DEBUG_RWSEMS_WARN_ON(rwsem_owner(sem) != current, sem); -+ preempt_disable(); - tmp = atomic_long_fetch_add_release( - -RWSEM_WRITER_LOCKED+RWSEM_READER_BIAS, &sem->count); - rwsem_set_reader_owned(sem); - if (tmp & RWSEM_FLAG_WAITERS) - rwsem_downgrade_wake(sem); -+ preempt_enable(); - } - - #else /* !CONFIG_PREEMPT_RT */ --- -2.35.3 - diff --git a/patches.suse/locking-rwsem-Disable-preemption-in-all-down_read-an.patch b/patches.suse/locking-rwsem-Disable-preemption-in-all-down_read-an.patch new file mode 100644 index 0000000..3d8ddbb --- /dev/null +++ b/patches.suse/locking-rwsem-Disable-preemption-in-all-down_read-an.patch @@ -0,0 +1,134 @@ +From 3f5245538a1964ae186ab7e1636020a41aa63143 Mon Sep 17 00:00:00 2001 +From: Waiman Long +Date: Wed, 25 Jan 2023 19:36:26 -0500 +Subject: [PATCH] locking/rwsem: Disable preemption in all down_read*() and + up_read() code paths +Git-commit: 3f5245538a1964ae186ab7e1636020a41aa63143 +Patch-mainline: v6.3-rc1 +References: bsc#1204996 + +Commit: + + 91d2a812dfb9 ("locking/rwsem: Make handoff writer optimistically spin on owner") + +... assumes that when the owner field is changed to NULL, the lock will +become free soon. But commit: + + 48dfb5d2560d ("locking/rwsem: Disable preemption while trying for rwsem lock") + +... disabled preemption when acquiring rwsem for write. + +However, preemption has not yet been disabled when acquiring a read lock +on a rwsem. So a reader can add a RWSEM_READER_BIAS to count without +setting owner to signal a reader, got preempted out by a RT task which +then spins in the writer slowpath as owner remains NULL leading to live lock. + +One easy way to fix this problem is to disable preemption at all the +down_read*() and up_read() code paths as implemented in this patch. + +Fixes: 91d2a812dfb9 ("locking/rwsem: Make handoff writer optimistically spin on owner") +Reported-by: Mukesh Ojha +Suggested-by: Peter Zijlstra +Signed-off-by: Waiman Long +Signed-off-by: Ingo Molnar +Link: https://lore.kernel.org/r/20230126003628.365092-3-longman@redhat.com +Signed-off-by: Jiri Wiesner +--- + kernel/locking/rwsem.c | 30 ++++++++++++++++++++++++------ + 1 file changed, 24 insertions(+), 6 deletions(-) + +diff --git a/kernel/locking/rwsem.c b/kernel/locking/rwsem.c +index be2df9ea7c30..84d5b649b95f 100644 +--- a/kernel/locking/rwsem.c ++++ b/kernel/locking/rwsem.c +@@ -1091,7 +1091,7 @@ rwsem_down_read_slowpath(struct rw_semaphore *sem, long count, unsigned int stat + /* Ordered by sem->wait_lock against rwsem_mark_wake(). */ + break; + } +- schedule(); ++ schedule_preempt_disabled(); + lockevent_inc(rwsem_sleep_reader); + } + +@@ -1253,14 +1253,20 @@ static struct rw_semaphore *rwsem_downgrade_wake(struct rw_semaphore *sem) + */ + static inline int __down_read_common(struct rw_semaphore *sem, int state) + { ++ int ret = 0; + long count; + ++ preempt_disable(); + if (!rwsem_read_trylock(sem, &count)) { +- if (IS_ERR(rwsem_down_read_slowpath(sem, count, state))) +- return -EINTR; ++ if (IS_ERR(rwsem_down_read_slowpath(sem, count, state))) { ++ ret = -EINTR; ++ goto out; ++ } + DEBUG_RWSEMS_WARN_ON(!is_rwsem_reader_owned(sem), sem); + } +- return 0; ++out: ++ preempt_enable(); ++ return ret; + } + + static inline void __down_read(struct rw_semaphore *sem) +@@ -1280,19 +1286,23 @@ static inline int __down_read_killable(struct rw_semaphore *sem) + + static inline int __down_read_trylock(struct rw_semaphore *sem) + { ++ int ret = 0; + long tmp; + + DEBUG_RWSEMS_WARN_ON(sem->magic != sem, sem); + ++ preempt_disable(); + tmp = atomic_long_read(&sem->count); + while (!(tmp & RWSEM_READ_FAILED_MASK)) { + if (atomic_long_try_cmpxchg_acquire(&sem->count, &tmp, + tmp + RWSEM_READER_BIAS)) { + rwsem_set_reader_owned(sem); +- return 1; ++ ret = 1; ++ break; + } + } +- return 0; ++ preempt_enable(); ++ return ret; + } + + /* +@@ -1334,6 +1344,7 @@ static inline void __up_read(struct rw_semaphore *sem) + DEBUG_RWSEMS_WARN_ON(sem->magic != sem, sem); + DEBUG_RWSEMS_WARN_ON(!is_rwsem_reader_owned(sem), sem); + ++ preempt_disable(); + rwsem_clear_reader_owned(sem); + tmp = atomic_long_add_return_release(-RWSEM_READER_BIAS, &sem->count); + DEBUG_RWSEMS_WARN_ON(tmp < 0, sem); +@@ -1342,6 +1353,7 @@ static inline void __up_read(struct rw_semaphore *sem) + clear_nonspinnable(sem); + rwsem_wake(sem); + } ++ preempt_enable(); + } + + /* +@@ -1661,6 +1673,12 @@ void down_read_non_owner(struct rw_semaphore *sem) + { + might_sleep(); + __down_read(sem); ++ /* ++ * The owner value for a reader-owned lock is mostly for debugging ++ * purpose only and is not critical to the correct functioning of ++ * rwsem. So it is perfectly fine to set it in a preempt-enabled ++ * context here. ++ */ + __rwsem_set_reader_owned(sem, NULL); + } + EXPORT_SYMBOL(down_read_non_owner); +-- +2.35.3 + diff --git a/patches.suse/locking-rwsem-Disable-preemption-in-all-down_write-a.patch b/patches.suse/locking-rwsem-Disable-preemption-in-all-down_write-a.patch new file mode 100644 index 0000000..5e054f5 --- /dev/null +++ b/patches.suse/locking-rwsem-Disable-preemption-in-all-down_write-a.patch @@ -0,0 +1,162 @@ +From 1d61659ced6bd8881cf2fb5cbcb28f9541fc7430 Mon Sep 17 00:00:00 2001 +From: Waiman Long +Date: Wed, 25 Jan 2023 19:36:27 -0500 +Subject: [PATCH] locking/rwsem: Disable preemption in all down_write*() and + up_write() code paths +Git-commit: 1d61659ced6bd8881cf2fb5cbcb28f9541fc7430 +Patch-mainline: v6.3-rc1 +References: bsc#1204996 + +The previous patch has disabled preemption in all the down_read() and +up_read() code paths. For symmetry, this patch extends commit: + + 48dfb5d2560d ("locking/rwsem: Disable preemption while trying for rwsem lock") + +... to have preemption disabled in all the down_write() and up_write() +code paths, including downgrade_write(). + +Suggested-by: Peter Zijlstra +Signed-off-by: Waiman Long +Signed-off-by: Ingo Molnar +Link: https://lore.kernel.org/r/20230126003628.365092-4-longman@redhat.com +Signed-off-by: Jiri Wiesner +--- + kernel/locking/rwsem.c | 38 +++++++++++++++++++------------------- + 1 file changed, 19 insertions(+), 19 deletions(-) + +diff --git a/kernel/locking/rwsem.c b/kernel/locking/rwsem.c +index 84d5b649b95f..acb5a50309a1 100644 +--- a/kernel/locking/rwsem.c ++++ b/kernel/locking/rwsem.c +@@ -256,16 +256,13 @@ static inline bool rwsem_read_trylock(struct rw_semaphore *sem, long *cntp) + static inline bool rwsem_write_trylock(struct rw_semaphore *sem) + { + long tmp = RWSEM_UNLOCKED_VALUE; +- bool ret = false; + +- preempt_disable(); + if (atomic_long_try_cmpxchg_acquire(&sem->count, &tmp, RWSEM_WRITER_LOCKED)) { + rwsem_set_owner(sem); +- ret = true; ++ return true; + } + +- preempt_enable(); +- return ret; ++ return false; + } + + /* +@@ -716,7 +713,6 @@ static inline bool rwsem_can_spin_on_owner(struct rw_semaphore *sem) + return false; + } + +- preempt_disable(); + /* + * Disable preemption is equal to the RCU read-side crital section, + * thus the task_strcut structure won't go away. +@@ -728,7 +724,6 @@ static inline bool rwsem_can_spin_on_owner(struct rw_semaphore *sem) + if ((flags & RWSEM_NONSPINNABLE) || + (owner && !(flags & RWSEM_READER_OWNED) && !owner_on_cpu(owner))) + ret = false; +- preempt_enable(); + + lockevent_cond_inc(rwsem_opt_fail, !ret); + return ret; +@@ -828,8 +823,6 @@ static bool rwsem_optimistic_spin(struct rw_semaphore *sem) + int loop = 0; + u64 rspin_threshold = 0; + +- preempt_disable(); +- + /* sem->wait_lock should not be held when doing optimistic spinning */ + if (!osq_lock(&sem->osq)) + goto done; +@@ -937,7 +930,6 @@ static bool rwsem_optimistic_spin(struct rw_semaphore *sem) + } + osq_unlock(&sem->osq); + done: +- preempt_enable(); + lockevent_cond_inc(rwsem_opt_fail, !taken); + return taken; + } +@@ -1178,15 +1170,12 @@ rwsem_down_write_slowpath(struct rw_semaphore *sem, int state) + if (waiter.handoff_set) { + enum owner_state owner_state; + +- preempt_disable(); + owner_state = rwsem_spin_on_owner(sem); +- preempt_enable(); +- + if (owner_state == OWNER_NULL) + goto trylock_again; + } + +- schedule(); ++ schedule_preempt_disabled(); + lockevent_inc(rwsem_sleep_writer); + set_current_state(state); + trylock_again: +@@ -1310,12 +1299,15 @@ static inline int __down_read_trylock(struct rw_semaphore *sem) + */ + static inline int __down_write_common(struct rw_semaphore *sem, int state) + { ++ int ret = 0; ++ ++ preempt_disable(); + if (unlikely(!rwsem_write_trylock(sem))) { + if (IS_ERR(rwsem_down_write_slowpath(sem, state))) +- return -EINTR; ++ ret = -EINTR; + } +- +- return 0; ++ preempt_enable(); ++ return ret; + } + + static inline void __down_write(struct rw_semaphore *sem) +@@ -1330,8 +1322,14 @@ static inline int __down_write_killable(struct rw_semaphore *sem) + + static inline int __down_write_trylock(struct rw_semaphore *sem) + { ++ int ret; ++ ++ preempt_disable(); + DEBUG_RWSEMS_WARN_ON(sem->magic != sem, sem); +- return rwsem_write_trylock(sem); ++ ret = rwsem_write_trylock(sem); ++ preempt_enable(); ++ ++ return ret; + } + + /* +@@ -1374,9 +1372,9 @@ static inline void __up_write(struct rw_semaphore *sem) + preempt_disable(); + rwsem_clear_owner(sem); + tmp = atomic_long_fetch_add_release(-RWSEM_WRITER_LOCKED, &sem->count); +- preempt_enable(); + if (unlikely(tmp & RWSEM_FLAG_WAITERS)) + rwsem_wake(sem); ++ preempt_enable(); + } + + /* +@@ -1394,11 +1392,13 @@ static inline void __downgrade_write(struct rw_semaphore *sem) + * write side. As such, rely on RELEASE semantics. + */ + DEBUG_RWSEMS_WARN_ON(rwsem_owner(sem) != current, sem); ++ preempt_disable(); + tmp = atomic_long_fetch_add_release( + -RWSEM_WRITER_LOCKED+RWSEM_READER_BIAS, &sem->count); + rwsem_set_reader_owned(sem); + if (tmp & RWSEM_FLAG_WAITERS) + rwsem_downgrade_wake(sem); ++ preempt_enable(); + } + + #else /* !CONFIG_PREEMPT_RT */ +-- +2.35.3 + diff --git a/patches.suse/locking-rwsem-Prevent-non-first-waiter-from-spinning.patch b/patches.suse/locking-rwsem-Prevent-non-first-waiter-from-spinning.patch index 2b40739..3ad1fc4 100644 --- a/patches.suse/locking-rwsem-Prevent-non-first-waiter-from-spinning.patch +++ b/patches.suse/locking-rwsem-Prevent-non-first-waiter-from-spinning.patch @@ -1,9 +1,11 @@ +From b613c7f31476c44316bfac1af7cac714b7d6bef9 Mon Sep 17 00:00:00 2001 From: Waiman Long -Date: Thu, 17 Nov 2022 21:20:11 -0500 +Date: Wed, 25 Jan 2023 19:36:25 -0500 Subject: [PATCH] locking/rwsem: Prevent non-first waiter from spinning in down_write() slowpath -Patch-mainline: Not yet, testing -References: bsc#1204996 +Git-commit: b613c7f31476c44316bfac1af7cac714b7d6bef9 +Patch-mainline: v6.3-rc1 +References: bsc#1204996 A non-first waiter can potentially spin in the for loop of rwsem_down_write_slowpath() without sleeping but fail to acquire the @@ -31,7 +33,7 @@ lock even if the rwsem is free if the following sequence happens: Acquire wait_lock rwsem_try_write_lock(): if (first->handoff_set && (waiter != first)) - return false; + return false; Release wait_lock A non-first waiter cannot really acquire the rwsem even if it mistakenly @@ -42,19 +44,22 @@ Fix this problem by making sure that a non-first waiter cannot spin in the slowpath loop without sleeping. Fixes: d257cc8cb8d5 ("locking/rwsem: Make handoff bit handling more consistent") -Reviewed-and-tested-by: Mukesh Ojha Signed-off-by: Waiman Long +Signed-off-by: Ingo Molnar +Tested-by: Mukesh Ojha +Reviewed-by: Mukesh Ojha Cc: stable@vger.kernel.org +Link: https://lore.kernel.org/r/20230126003628.365092-2-longman@redhat.com Signed-off-by: Jiri Wiesner --- kernel/locking/rwsem.c | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-) diff --git a/kernel/locking/rwsem.c b/kernel/locking/rwsem.c -index 6726c983b7941..9024d957d4c8e 100644 +index 44873594de03..be2df9ea7c30 100644 --- a/kernel/locking/rwsem.c +++ b/kernel/locking/rwsem.c -@@ -623,18 +623,16 @@ static inline bool rwsem_try_write_lock(struct rw_semaphore *sem, +@@ -624,18 +624,16 @@ static inline bool rwsem_try_write_lock(struct rw_semaphore *sem, */ if (first->handoff_set && (waiter != first)) return false; @@ -78,7 +83,7 @@ index 6726c983b7941..9024d957d4c8e 100644 if (has_handoff || (!rt_task(waiter->task) && !time_after(jiffies, waiter->timeout))) return false; -@@ -650,11 +648,12 @@ static inline bool rwsem_try_write_lock(struct rw_semaphore *sem, +@@ -651,11 +649,12 @@ static inline bool rwsem_try_write_lock(struct rw_semaphore *sem, } while (!atomic_long_try_cmpxchg_acquire(&sem->count, &count, new)); /* diff --git a/series.conf b/series.conf index 8bac715..ee5d8c7 100644 --- a/series.conf +++ b/series.conf @@ -36888,6 +36888,9 @@ patches.suse/net-sched-tcindex-update-imperfect-hash-filters-resp.patch patches.suse/bnxt_en-Fix-mqprio-and-XDP-ring-checking-logic.patch patches.suse/fbdev-Fix-invalid-page-access-after-closing-deferred.patch + patches.suse/locking-rwsem-Prevent-non-first-waiter-from-spinning.patch + patches.suse/locking-rwsem-Disable-preemption-in-all-down_read-an.patch + patches.suse/locking-rwsem-Disable-preemption-in-all-down_write-a.patch patches.suse/ibmvnic-Toggle-between-queue-types-in-affinity-mappi.patch patches.suse/rds-rds_rm_zerocopy_callback-correct-order-for-list_add_tail.patch patches.suse/ipmi-ssif-resend_msg-cannot-fail.patch @@ -36897,11 +36900,6 @@ patches.suse/ibmvnic-Assign-XPS-map-to-correct-queue-index.patch patches.suse/bnxt_en-Avoid-order-5-memory-allocation-for-TPA-data.patch - # out-of-tree patches - patches.suse/locking-rwsem-Prevent-non-first-waiter-from-spinning.patch - patches.suse/locking-rwsem-Disable-preemption-at-all-down_read-an.patch - patches.suse/locking-rwsem-Disable-preemption-at-all-down_write-a.patch - ######################################################## # end of sorted patches ######################################################## @@ -37284,7 +37282,6 @@ # Wireless networking drivers ######################################################## patches.suse/b43-missing-firmware-info.patch - patches.suse/iwlwifi-module-firmware-ucode-fix.patch patches.suse/0001-regulator-mt6360-Add-OF-match-table.patch patches.suse/0002-regulator-mt6358-Add-OF-match-table.patch patches.suse/0003-regulator-mt6323-Add-OF-match-table.patch