[PATCH v1 0/4] rust: Add i8/i16 atomic try_cmpxchg helpers

[PATCH v1 0/4] rust: Add i8/i16 atomic try_cmpxchg helpers

[FUJITA Tomonori]

This series adds Rust helpers for atomic try_cmpxchg on i8/i16 with
full, acquire, release, and relaxed orderings in preparation for
supporting Rust-side cmpxchg on those types.

Rust atomic cmpxchg is implemented on top of the kernel C APIs,
try_cmpxchg.

On architectures that support Rust today, the kernel already provides
try_cmpxchg implementations that work for i8/i16, using
architecture-specific instructions.

Tested on QEMU (86_64, arm64, riscv, loongarch, and armv7).

Follow-up patches will add Rust users of these helpers.

Boqun, feel free to drop the ordering-related notes from each patch.

FUJITA Tomonori (4):
  rust: helpers: Add i8/i16 atomic try_cmpxchg helpers
  rust: helpers: Add i8/i16 atomic try_cmpxchg_acquire helpers
  rust: helpers: Add i8/i16 atomic try_cmpxchg_release helpers
  rust: helpers: Add i8/i16 atomic try_cmpxchg_relaxed helpers

 rust/helpers/atomic_ext.c | 40 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)


base-commit: 30f5de001fb2ffacdb61e82c8626cae2d68b4d03
-- 
2.43.0

[PATCH v1 1/4] rust: helpers: Add i8/i16 atomic try_cmpxchg helpers

[FUJITA Tomonori]

Add i8/i16 atomic try_cmpxchg helpers that call raw_try_cmpxchg()
macro implementing atomic try_cmpxchg using architecture-specific
instructions.

x86_64 implements try_cmpxchg() with full ordering.

On other architectures, try_cmpxchg() isn't implemented; so calling
try_cmpxchg() ends up using cmpxchg() implementation.

loongarch, arm64, and riscv implement cmpxchg with full ordering.

arm v7 only supports relaxed-ordering cmpxchg; __atomic_op_fence()
macro is used to add barriers before and after the relaxed cmpxchg.

Signed-off-by: FUJITA Tomonori <fujita.tomonori@gmail.com>
---
 rust/helpers/atomic_ext.c | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/rust/helpers/atomic_ext.c b/rust/helpers/atomic_ext.c
index 089f31bc8de8..9d62f659c8d2 100644
--- a/rust/helpers/atomic_ext.c
+++ b/rust/helpers/atomic_ext.c
@@ -90,3 +90,13 @@ __rust_helper s16 rust_helper_atomic_i16_xchg_relaxed(s16 *ptr, s16 new)
 {
 	return raw_xchg_relaxed(ptr, new);
 }
+
+__rust_helper bool rust_helper_atomic_i8_try_cmpxchg(s8 *ptr, s8 *old, s8 new)
+{
+	return raw_try_cmpxchg(ptr, old, new);
+}
+
+__rust_helper bool rust_helper_atomic_i16_try_cmpxchg(s16 *ptr, s16 *old, s16 new)
+{
+	return raw_try_cmpxchg(ptr, old, new);
+}
-- 
2.43.0

[PATCH v1 2/4] rust: helpers: Add i8/i16 atomic try_cmpxchg_acquire helpers

[FUJITA Tomonori]

Add i8/i16 atomic try_cmpxchg_acquire helpers that call
raw_try_cmpxchg_acquire() macro implementing atomic
try_cmpxchg_acquire using architecture-specific instructions.

x86_64 uses full-ordering try_cmpxchg().

On other architectures, try_cmpxchg_acquire() isn't implemented; so
calling try_cmpxchg_acquire() ends up using cmpxchg_acquire()
implementation.

arm64 and riscv implement acquire-ordering cmpxchg.

loongarch uses full-ordering cmpxchg().

arm v7 only supports relaxed-ordering cmpxchg; __atomic_op_fence()
macro is used to add barriers after the relaxed cmpxchg.

Signed-off-by: FUJITA Tomonori <fujita.tomonori@gmail.com>
---
 rust/helpers/atomic_ext.c | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/rust/helpers/atomic_ext.c b/rust/helpers/atomic_ext.c
index 9d62f659c8d2..69a258ebbfa0 100644
--- a/rust/helpers/atomic_ext.c
+++ b/rust/helpers/atomic_ext.c
@@ -100,3 +100,13 @@ __rust_helper bool rust_helper_atomic_i16_try_cmpxchg(s16 *ptr, s16 *old, s16 ne
 {
 	return raw_try_cmpxchg(ptr, old, new);
 }
+
+__rust_helper bool rust_helper_atomic_i8_try_cmpxchg_acquire(s8 *ptr, s8 *old, s8 new)
+{
+	return raw_try_cmpxchg_acquire(ptr, old, new);
+}
+
+__rust_helper bool rust_helper_atomic_i16_try_cmpxchg_acquire(s16 *ptr, s16 *old, s16 new)
+{
+	return raw_try_cmpxchg_acquire(ptr, old, new);
+}
-- 
2.43.0

[PATCH v1 3/4] rust: helpers: Add i8/i16 atomic try_cmpxchg_release helpers

[FUJITA Tomonori]

Add i8/i16 atomic try_cmpxchg_release helpers that call
raw_try_cmpxchg_release() macro implementing atomic
try_cmpxchg_release using architecture-specific instructions.

x86_64 uses full-ordering try_cmpxchg().

On other architectures, try_cmpxchg_release() isn't implemented; so
calling try_cmpxchg_release() ends up using cmpxchg_release()
implementation.

arm64 and riscv implement release-ordering cmpxchg.

loongarch uses full-ordering cmpxchg().

arm v7 only supports relaxed-ordering cmpxchg; __atomic_op_fence()
macro is used to add barriers before the relaxed cmpxchg.

Signed-off-by: FUJITA Tomonori <fujita.tomonori@gmail.com>
---
 rust/helpers/atomic_ext.c | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/rust/helpers/atomic_ext.c b/rust/helpers/atomic_ext.c
index 69a258ebbfa0..589c070f589b 100644
--- a/rust/helpers/atomic_ext.c
+++ b/rust/helpers/atomic_ext.c
@@ -110,3 +110,13 @@ __rust_helper bool rust_helper_atomic_i16_try_cmpxchg_acquire(s16 *ptr, s16 *old
 {
 	return raw_try_cmpxchg_acquire(ptr, old, new);
 }
+
+__rust_helper bool rust_helper_atomic_i8_try_cmpxchg_release(s8 *ptr, s8 *old, s8 new)
+{
+	return raw_try_cmpxchg_release(ptr, old, new);
+}
+
+__rust_helper bool rust_helper_atomic_i16_try_cmpxchg_release(s16 *ptr, s16 *old, s16 new)
+{
+	return raw_try_cmpxchg_release(ptr, old, new);
+}
-- 
2.43.0

[PATCH v1 4/4] rust: helpers: Add i8/i16 atomic try_cmpxchg_relaxed helpers

[FUJITA Tomonori]

Add i8/i16 atomic try_cmpxchg_relaxed helpers that call
raw_try_cmpxchg_relaxed() macro implementing atomic
try_cmpxchg_relaxed using architecture-specific instructions.

x86_64 uses full-ordering try_cmpxchg().

On other architectures, try_cmpxchg_relaxed() isn't implemented; so
calling try_cmpxchg_relaxed() ends up using cmpxchg_relaxed()
implementation.

arm64, riscv, and arm v7 implement relaxed-ordering cmpxchg.

loongarch uses full-ordering cmpxchg().

Signed-off-by: FUJITA Tomonori <fujita.tomonori@gmail.com>
---
 rust/helpers/atomic_ext.c | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/rust/helpers/atomic_ext.c b/rust/helpers/atomic_ext.c
index 589c070f589b..3a5ef6bb2776 100644
--- a/rust/helpers/atomic_ext.c
+++ b/rust/helpers/atomic_ext.c
@@ -120,3 +120,13 @@ __rust_helper bool rust_helper_atomic_i16_try_cmpxchg_release(s16 *ptr, s16 *old
 {
 	return raw_try_cmpxchg_release(ptr, old, new);
 }
+
+__rust_helper bool rust_helper_atomic_i8_try_cmpxchg_relaxed(s8 *ptr, s8 *old, s8 new)
+{
+	return raw_try_cmpxchg_relaxed(ptr, old, new);
+}
+
+__rust_helper bool rust_helper_atomic_i16_try_cmpxchg_relaxed(s16 *ptr, s16 *old, s16 new)
+{
+	return raw_try_cmpxchg_relaxed(ptr, old, new);
+}
-- 
2.43.0

Re: [PATCH v1 0/4] rust: Add i8/i16 atomic try_cmpxchg helpers

[Boqun Feng]

On Sat, Dec 27, 2025 at 08:59:47PM +0900, FUJITA Tomonori wrote:
> This series adds Rust helpers for atomic try_cmpxchg on i8/i16 with
> full, acquire, release, and relaxed orderings in preparation for
> supporting Rust-side cmpxchg on those types.
> 
> Rust atomic cmpxchg is implemented on top of the kernel C APIs,
> try_cmpxchg.
> 
> On architectures that support Rust today, the kernel already provides
> try_cmpxchg implementations that work for i8/i16, using
> architecture-specific instructions.
> 
> Tested on QEMU (86_64, arm64, riscv, loongarch, and armv7).
> 
> Follow-up patches will add Rust users of these helpers.
> 
> Boqun, feel free to drop the ordering-related notes from each patch.
> 

Queued, thanks!

Regards,
Boqun

> FUJITA Tomonori (4):
>   rust: helpers: Add i8/i16 atomic try_cmpxchg helpers
>   rust: helpers: Add i8/i16 atomic try_cmpxchg_acquire helpers
>   rust: helpers: Add i8/i16 atomic try_cmpxchg_release helpers
>   rust: helpers: Add i8/i16 atomic try_cmpxchg_relaxed helpers
> 
>  rust/helpers/atomic_ext.c | 40 +++++++++++++++++++++++++++++++++++++++
>  1 file changed, 40 insertions(+)
> 
> 
> base-commit: 30f5de001fb2ffacdb61e82c8626cae2d68b4d03
> -- 
> 2.43.0
> 

Re: [PATCH v1 1/4] rust: helpers: Add i8/i16 atomic try_cmpxchg helpers

[Boqun Feng]

On Sat, Dec 27, 2025 at 08:59:48PM +0900, FUJITA Tomonori wrote:
> Add i8/i16 atomic try_cmpxchg helpers that call raw_try_cmpxchg()
> macro implementing atomic try_cmpxchg using architecture-specific
> instructions.
> 
> x86_64 implements try_cmpxchg() with full ordering.
> 
> On other architectures, try_cmpxchg() isn't implemented; so calling
> try_cmpxchg() ends up using cmpxchg() implementation.
> 
> loongarch, arm64, and riscv implement cmpxchg with full ordering.
> 
> arm v7 only supports relaxed-ordering cmpxchg; __atomic_op_fence()
> macro is used to add barriers before and after the relaxed cmpxchg.
> 
> Signed-off-by: FUJITA Tomonori <fujita.tomonori@gmail.com>
> ---

One more thing, we should add this to comments in atomic_ext.c as well:

diff --git a/rust/helpers/atomic_ext.c b/rust/helpers/atomic_ext.c
index 10733bb4a75e..5ef81d2b47cf 100644
--- a/rust/helpers/atomic_ext.c
+++ b/rust/helpers/atomic_ext.c
@@ -91,6 +91,13 @@ __rust_helper s16 rust_helper_atomic_i16_xchg_relaxed(s16 *ptr, s16 new)
        return raw_xchg_relaxed(ptr, new);
 }

+/*
+ * try_cmpxchg helpers depend on ARCH_SUPPORTS_ATOMIC_RMW and on the
+ * architecture provding try_cmpxchg() support for i8 and i16.
+ *
+ * The architectures that currently support Rust (x86_64, armv7,
+ * arm64, riscv, and loongarch) satisfy these requirements.
+ */
 __rust_helper bool rust_helper_atomic_i8_try_cmpxchg(s8 *ptr, s8 *old, s8 new)
 {
        return raw_try_cmpxchg(ptr, old, new);

I can add it myself if it works for you.

Regards,
Boqun

>  rust/helpers/atomic_ext.c | 10 ++++++++++
>  1 file changed, 10 insertions(+)
> 
> diff --git a/rust/helpers/atomic_ext.c b/rust/helpers/atomic_ext.c
> index 089f31bc8de8..9d62f659c8d2 100644
> --- a/rust/helpers/atomic_ext.c
> +++ b/rust/helpers/atomic_ext.c
> @@ -90,3 +90,13 @@ __rust_helper s16 rust_helper_atomic_i16_xchg_relaxed(s16 *ptr, s16 new)
>  {
>  	return raw_xchg_relaxed(ptr, new);
>  }
> +
> +__rust_helper bool rust_helper_atomic_i8_try_cmpxchg(s8 *ptr, s8 *old, s8 new)
> +{
> +	return raw_try_cmpxchg(ptr, old, new);
> +}
> +
> +__rust_helper bool rust_helper_atomic_i16_try_cmpxchg(s16 *ptr, s16 *old, s16 new)
> +{
> +	return raw_try_cmpxchg(ptr, old, new);
> +}
> -- 
> 2.43.0
> 

Re: [PATCH v1 1/4] rust: helpers: Add i8/i16 atomic try_cmpxchg helpers

[FUJITA Tomonori]

On Mon, 29 Dec 2025 20:06:25 +0800
Boqun Feng <boqun.feng@gmail.com> wrote:

> On Sat, Dec 27, 2025 at 08:59:48PM +0900, FUJITA Tomonori wrote:
>> Add i8/i16 atomic try_cmpxchg helpers that call raw_try_cmpxchg()
>> macro implementing atomic try_cmpxchg using architecture-specific
>> instructions.
>> 
>> x86_64 implements try_cmpxchg() with full ordering.
>> 
>> On other architectures, try_cmpxchg() isn't implemented; so calling
>> try_cmpxchg() ends up using cmpxchg() implementation.
>> 
>> loongarch, arm64, and riscv implement cmpxchg with full ordering.
>> 
>> arm v7 only supports relaxed-ordering cmpxchg; __atomic_op_fence()
>> macro is used to add barriers before and after the relaxed cmpxchg.
>> 
>> Signed-off-by: FUJITA Tomonori <fujita.tomonori@gmail.com>
>> ---
> 
> One more thing, we should add this to comments in atomic_ext.c as well:
> 
> diff --git a/rust/helpers/atomic_ext.c b/rust/helpers/atomic_ext.c
> index 10733bb4a75e..5ef81d2b47cf 100644
> --- a/rust/helpers/atomic_ext.c
> +++ b/rust/helpers/atomic_ext.c
> @@ -91,6 +91,13 @@ __rust_helper s16 rust_helper_atomic_i16_xchg_relaxed(s16 *ptr, s16 new)
>         return raw_xchg_relaxed(ptr, new);
>  }
> 
> +/*
> + * try_cmpxchg helpers depend on ARCH_SUPPORTS_ATOMIC_RMW and on the
> + * architecture provding try_cmpxchg() support for i8 and i16.
> + *
> + * The architectures that currently support Rust (x86_64, armv7,
> + * arm64, riscv, and loongarch) satisfy these requirements.
> + */
>  __rust_helper bool rust_helper_atomic_i8_try_cmpxchg(s8 *ptr, s8 *old, s8 new)
>  {
>         return raw_try_cmpxchg(ptr, old, new);
> 
> I can add it myself if it works for you.

Thanks, please add it.