From: Greg Kroah-Hartman Date: Mon, 22 Aug 2022 15:00:18 +0000 (+0200) Subject: 4.19-stable patches X-Git-Tag: v4.9.326~32 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=5e5cc6136d45a681d8d29e9379c5f1398154a3a6;p=thirdparty%2Fkernel%2Fstable-queue.git 4.19-stable patches added patches: locking-atomic-make-test_and_-_bit-ordered-on-failure.patch --- diff --git a/queue-4.19/locking-atomic-make-test_and_-_bit-ordered-on-failure.patch b/queue-4.19/locking-atomic-make-test_and_-_bit-ordered-on-failure.patch new file mode 100644 index 00000000000..073574339fd --- /dev/null +++ b/queue-4.19/locking-atomic-make-test_and_-_bit-ordered-on-failure.patch @@ -0,0 +1,75 @@ +From 415d832497098030241605c52ea83d4e2cfa7879 Mon Sep 17 00:00:00 2001 +From: Hector Martin +Date: Tue, 16 Aug 2022 16:03:11 +0900 +Subject: locking/atomic: Make test_and_*_bit() ordered on failure + +From: Hector Martin + +commit 415d832497098030241605c52ea83d4e2cfa7879 upstream. + +These operations are documented as always ordered in +include/asm-generic/bitops/instrumented-atomic.h, and producer-consumer +type use cases where one side needs to ensure a flag is left pending +after some shared data was updated rely on this ordering, even in the +failure case. + +This is the case with the workqueue code, which currently suffers from a +reproducible ordering violation on Apple M1 platforms (which are +notoriously out-of-order) that ends up causing the TTY layer to fail to +deliver data to userspace properly under the right conditions. This +change fixes that bug. + +Change the documentation to restrict the "no order on failure" story to +the _lock() variant (for which it makes sense), and remove the +early-exit from the generic implementation, which is what causes the +missing barrier semantics in that case. Without this, the remaining +atomic op is fully ordered (including on ARM64 LSE, as of recent +versions of the architecture spec). + +Suggested-by: Linus Torvalds +Cc: stable@vger.kernel.org +Fixes: e986a0d6cb36 ("locking/atomics, asm-generic/bitops/atomic.h: Rewrite using atomic_*() APIs") +Fixes: 61e02392d3c7 ("locking/atomic/bitops: Document and clarify ordering semantics for failed test_and_{}_bit()") +Signed-off-by: Hector Martin +Acked-by: Will Deacon +Reviewed-by: Arnd Bergmann +Signed-off-by: Linus Torvalds +Signed-off-by: Greg Kroah-Hartman +--- + Documentation/atomic_bitops.txt | 2 +- + include/asm-generic/bitops/atomic.h | 6 ------ + 2 files changed, 1 insertion(+), 7 deletions(-) + +--- a/Documentation/atomic_bitops.txt ++++ b/Documentation/atomic_bitops.txt +@@ -59,7 +59,7 @@ Like with atomic_t, the rule of thumb is + - RMW operations that have a return value are fully ordered. + + - RMW operations that are conditional are unordered on FAILURE, +- otherwise the above rules apply. In the case of test_and_{}_bit() operations, ++ otherwise the above rules apply. In the case of test_and_set_bit_lock(), + if the bit in memory is unchanged by the operation then it is deemed to have + failed. + +--- a/include/asm-generic/bitops/atomic.h ++++ b/include/asm-generic/bitops/atomic.h +@@ -35,9 +35,6 @@ static inline int test_and_set_bit(unsig + unsigned long mask = BIT_MASK(nr); + + p += BIT_WORD(nr); +- if (READ_ONCE(*p) & mask) +- return 1; +- + old = atomic_long_fetch_or(mask, (atomic_long_t *)p); + return !!(old & mask); + } +@@ -48,9 +45,6 @@ static inline int test_and_clear_bit(uns + unsigned long mask = BIT_MASK(nr); + + p += BIT_WORD(nr); +- if (!(READ_ONCE(*p) & mask)) +- return 0; +- + old = atomic_long_fetch_andnot(mask, (atomic_long_t *)p); + return !!(old & mask); + } diff --git a/queue-4.19/series b/queue-4.19/series index 4a01df9f358..87e9e96f774 100644 --- a/queue-4.19/series +++ b/queue-4.19/series @@ -253,3 +253,4 @@ i40e-fix-to-stop-tx_timeout-recovery-if-globr-fails.patch fec-fix-timer-capture-timing-in-fec_ptp_enable_pps.patch igb-add-lock-to-avoid-data-race.patch gcc-plugins-undefine-latent_entropy_plugin-when-plugin-disabled-for-a-file.patch +locking-atomic-make-test_and_-_bit-ordered-on-failure.patch