Skip to contentSkip to conversation

rust: io: always inline methods leading to build_assert

PATCH Superseded Alexandre Courbot 3 participants 5 messages Nov 27, 2025 – Nov 28, 2025

Subsystems (2)

v1 of 3 Superseded Latest is v3 →

lore
Share & tools
lore

Alexandre Courbot

author reviewer
#0 lore raw

PATCH 1/1 rust: io: always inline methods leading to build_assert

build_assert relies on the compiler to optimize out its error path, lest build fails with the dreaded error:

ERROR: modpost: "rust_build_error" [drivers/gpu/nova-core/nova_core.ko] undefined!

It has been observed that very trivial code performing I/O accesses (sometimes even using an immediate value) would seemingly randomly fail with this error whenever CLIPPY=1 was set. Removing the CLIPPY option makes the error go away, but that's obviously not a great workaround. Clippy appears to influence the way the compiler optimizes things, making it on occasion generate a method where we would need it to inline in order to satisfy a build_assert.

Fix this by instructing the compiler to always inline the methods leading to build_assert. This stronger directive is effective even when CLIPPY=1 is specified, which gets rid of this error.

---
This is the same fix as for another build error triggered by the use of build_assert [1], which signals that all callers of this macro should all be tagged with #[inline(always)], as inlining is a requirement for build_assert to perform properly anyway.

[1] https://lore.kernel.org/all/[email protected]/

---
 rust/kernel/io.rs | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)
rust/kernel/io.rs +6 -3
index 98e8b84e68d1..f161ec8056ce 100644
@@ -142,7 +142,8 @@ macro_rules! define_read {
         /// Bound checks are performed on compile time, hence if the offset is not known at compile
         /// time, the build will fail.
         $(#[$attr])*
-        #[inline]
+        // Always inline so the error path of `io_addr_assert` is optimized out.
+        #[inline(always)]
         pub fn $name(&self, offset: usize) -> $type_name {
             let addr = self.io_addr_assert::<$type_name>(offset);
 
@@ -171,7 +172,8 @@ macro_rules! define_write {
         /// Bound checks are performed on compile time, hence if the offset is not known at compile
         /// time, the build will fail.
         $(#[$attr])*
-        #[inline]
+        // Always inline so the error path of `io_addr_assert` is optimized out.
+        #[inline(always)]
         pub fn $name(&self, value: $type_name, offset: usize) {
             let addr = self.io_addr_assert::<$type_name>(offset);
 
@@ -239,7 +241,8 @@ fn io_addr<U>(&self, offset: usize) -> Result<usize> {
         self.addr().checked_add(offset).ok_or(EINVAL)
     }
 
-    #[inline]
+    // Always inline so the error path of `build_assert!` is optimized out.
+    #[inline(always)]
     fn io_addr_assert<U>(&self, offset: usize) -> usize {
         build_assert!(Self::offset_valid::<U>(offset, SIZE));
 

---
base-commit: ea34511aaf755349999a1067b2984a541bee1492
change-id: 20251127-io-build-assert-3579a5bfb81c

Best regards,

Signature · 1 line
Alexandre Courbot <[email protected]>
maintainer Reviewed-by on v1 1/1
#1 lore raw
Quoted 72 lines · Alexandre Courbot

build_assert relies on the compiler to optimize out its error path, lest build fails with the dreaded error:

ERROR: modpost: "rust_build_error" [drivers/gpu/nova-core/nova_core.ko] undefined!

It has been observed that very trivial code performing I/O accesses (sometimes even using an immediate value) would seemingly randomly fail with this error whenever CLIPPY=1 was set. Removing the CLIPPY option makes the error go away, but that's obviously not a great workaround. Clippy appears to influence the way the compiler optimizes things, making it on occasion generate a method where we would need it to inline in order to satisfy a build_assert.

Fix this by instructing the compiler to always inline the methods leading to build_assert. This stronger directive is effective even when CLIPPY=1 is specified, which gets rid of this error.

---
This is the same fix as for another build error triggered by the use of build_assert [1], which signals that all callers of this macro should all be tagged with #[inline(always)], as inlining is a requirement for build_assert to perform properly anyway.

[1] https://lore.kernel.org/all/[email protected]/
---
rust/kernel/io.rs | 9 ++++++---

1 file changed, 6 insertions(+), 3 deletions(-)
rust/kernel/io.rs +6 -4
index 98e8b84e68d1..f161ec8056ce 100644
@@ -142,7 +142,8 @@ macro_rules! define_read {
        /// Bound checks are performed on compile time, hence if the offset is not known at compile
        /// time, the build will fail.
        $(#[$attr])*
-        #[inline]
+        // Always inline so the error path of `io_addr_assert` is optimized out.
+        #[inline(always)]
        pub fn $name(&self, offset: usize) -> $type_name {
            let addr = self.io_addr_assert::<$type_name>(offset);
 
@@ -171,7 +172,8 @@ macro_rules! define_write {
        /// Bound checks are performed on compile time, hence if the offset is not known at compile
        /// time, the build will fail.
        $(#[$attr])*
-        #[inline]
+        // Always inline so the error path of `io_addr_assert` is optimized out.
+        #[inline(always)]
        pub fn $name(&self, value: $type_name, offset: usize) {
            let addr = self.io_addr_assert::<$type_name>(offset);
 
@@ -239,7 +241,8 @@ fn io_addr<U>(&self, offset: usize) -> Result<usize> {
        self.addr().checked_add(offset).ok_or(EINVAL)
    }
 
-    #[inline]
+    // Always inline so the error path of `build_assert!` is optimized out.
+    #[inline(always)]
    fn io_addr_assert<U>(&self, offset: usize) -> usize {
        build_assert!(Self::offset_valid::<U>(offset, SIZE));
 
 
---

base-commit: ea34511aaf755349999a1067b2984a541bee1492
change-id: 20251127-io-build-assert-3579a5bfb81c

Quoted 5 lines

Best regards,

Signature · 1 line
Alexandre Courbot <[email protected]>

I also faced this with genmask, by the way, i.e.: using genmask with an in-bounds constant would trigger a build error. Very confusingly, this would be randomly solved by moving the genmask invocation around in the code.

I wonder if the same fix is needed for it as well?

— Daniel

#2 lore raw
Quoted 6 lines · Daniel Almeida

I also faced this with genmask, by the way, i.e.: using genmask with an in-bounds constant would trigger a build error. Very confusingly, this would be randomly solved by moving the genmask invocation around in the code.

I wonder if the same fix is needed for it as well?

If you still have the ability to reproduce it, then please do check!

Cheers,
Miguel

author reviewer
#3 lore raw
In reply to Daniel Almeida
Quoted 80 lines · Daniel Almeida
Quoted 72 lines · Alexandre Courbot

build_assert relies on the compiler to optimize out its error path, lest build fails with the dreaded error:

ERROR: modpost: "rust_build_error" [drivers/gpu/nova-core/nova_core.ko] undefined!

It has been observed that very trivial code performing I/O accesses (sometimes even using an immediate value) would seemingly randomly fail with this error whenever CLIPPY=1 was set. Removing the CLIPPY option makes the error go away, but that's obviously not a great workaround. Clippy appears to influence the way the compiler optimizes things, making it on occasion generate a method where we would need it to inline in order to satisfy a build_assert.

Fix this by instructing the compiler to always inline the methods leading to build_assert. This stronger directive is effective even when CLIPPY=1 is specified, which gets rid of this error.

---
This is the same fix as for another build error triggered by the use of build_assert [1], which signals that all callers of this macro should all be tagged with #[inline(always)], as inlining is a requirement for build_assert to perform properly anyway.

[1] https://lore.kernel.org/all/[email protected]/
---
rust/kernel/io.rs | 9 ++++++---

1 file changed, 6 insertions(+), 3 deletions(-)
rust/kernel/io.rs +6 -4
index 98e8b84e68d1..f161ec8056ce 100644
@@ -142,7 +142,8 @@ macro_rules! define_read {
        /// Bound checks are performed on compile time, hence if the offset is not known at compile
        /// time, the build will fail.
        $(#[$attr])*
-        #[inline]
+        // Always inline so the error path of `io_addr_assert` is optimized out.
+        #[inline(always)]
        pub fn $name(&self, offset: usize) -> $type_name {
            let addr = self.io_addr_assert::<$type_name>(offset);
 
@@ -171,7 +172,8 @@ macro_rules! define_write {
        /// Bound checks are performed on compile time, hence if the offset is not known at compile
        /// time, the build will fail.
        $(#[$attr])*
-        #[inline]
+        // Always inline so the error path of `io_addr_assert` is optimized out.
+        #[inline(always)]
        pub fn $name(&self, value: $type_name, offset: usize) {
            let addr = self.io_addr_assert::<$type_name>(offset);
 
@@ -239,7 +241,8 @@ fn io_addr<U>(&self, offset: usize) -> Result<usize> {
        self.addr().checked_add(offset).ok_or(EINVAL)
    }
 
-    #[inline]
+    // Always inline so the error path of `build_assert!` is optimized out.
+    #[inline(always)]
    fn io_addr_assert<U>(&self, offset: usize) -> usize {
        build_assert!(Self::offset_valid::<U>(offset, SIZE));
 
 
---

base-commit: ea34511aaf755349999a1067b2984a541bee1492
change-id: 20251127-io-build-assert-3579a5bfb81c

Quoted 5 lines

Best regards,

Signature · 1 line
Alexandre Courbot <[email protected]>
Quoted 5 lines

I also faced this with genmask, by the way, i.e.: using genmask with an in-bounds constant would trigger a build error. Very confusingly, this would be randomly solved by moving the genmask invocation around in the code.

I wonder if the same fix is needed for it as well?

What you described is exactly the symptoms I was experimenting (notably the "moving around sometimes fixes it" thing) so yeah, I think this also applies to bit_* and genmask_* (and anything that invokes build_assert, really).

author reviewer
#4 lore raw
Quoted 85 lines · Alexandre Courbot
Quoted 84 lines · Daniel Almeida
Quoted 72 lines · Alexandre Courbot

build_assert relies on the compiler to optimize out its error path, lest build fails with the dreaded error:

ERROR: modpost: "rust_build_error" [drivers/gpu/nova-core/nova_core.ko] undefined!

It has been observed that very trivial code performing I/O accesses (sometimes even using an immediate value) would seemingly randomly fail with this error whenever CLIPPY=1 was set. Removing the CLIPPY option makes the error go away, but that's obviously not a great workaround. Clippy appears to influence the way the compiler optimizes things, making it on occasion generate a method where we would need it to inline in order to satisfy a build_assert.

Fix this by instructing the compiler to always inline the methods leading to build_assert. This stronger directive is effective even when CLIPPY=1 is specified, which gets rid of this error.

---
This is the same fix as for another build error triggered by the use of build_assert [1], which signals that all callers of this macro should all be tagged with #[inline(always)], as inlining is a requirement for build_assert to perform properly anyway.

[1] https://lore.kernel.org/all/[email protected]/
---
rust/kernel/io.rs | 9 ++++++---

1 file changed, 6 insertions(+), 3 deletions(-)
rust/kernel/io.rs +6 -4
index 98e8b84e68d1..f161ec8056ce 100644
@@ -142,7 +142,8 @@ macro_rules! define_read {
        /// Bound checks are performed on compile time, hence if the offset is not known at compile
        /// time, the build will fail.
        $(#[$attr])*
-        #[inline]
+        // Always inline so the error path of `io_addr_assert` is optimized out.
+        #[inline(always)]
        pub fn $name(&self, offset: usize) -> $type_name {
            let addr = self.io_addr_assert::<$type_name>(offset);
 
@@ -171,7 +172,8 @@ macro_rules! define_write {
        /// Bound checks are performed on compile time, hence if the offset is not known at compile
        /// time, the build will fail.
        $(#[$attr])*
-        #[inline]
+        // Always inline so the error path of `io_addr_assert` is optimized out.
+        #[inline(always)]
        pub fn $name(&self, value: $type_name, offset: usize) {
            let addr = self.io_addr_assert::<$type_name>(offset);
 
@@ -239,7 +241,8 @@ fn io_addr<U>(&self, offset: usize) -> Result<usize> {
        self.addr().checked_add(offset).ok_or(EINVAL)
    }
 
-    #[inline]
+    // Always inline so the error path of `build_assert!` is optimized out.
+    #[inline(always)]
    fn io_addr_assert<U>(&self, offset: usize) -> usize {
        build_assert!(Self::offset_valid::<U>(offset, SIZE));
 
 
---

base-commit: ea34511aaf755349999a1067b2984a541bee1492
change-id: 20251127-io-build-assert-3579a5bfb81c

Quoted 5 lines

Best regards,

Signature · 1 line
Alexandre Courbot <[email protected]>

I also faced this with genmask, by the way, i.e.: using genmask with an in-bounds constant would trigger a build error. Very confusingly, this would be randomly solved by moving the genmask invocation around in the code.

Quoted 6 lines
Quoted 1 line

I wonder if the same fix is needed for it as well?

What you described is exactly the symptoms I was experimenting (notably the "moving around sometimes fixes it" thing) so yeah, I think this also applies to bit_* and genmask_* (and anything that invokes build_assert, really).

... anything that invoke builds_assert with one of its arguments as parameter, that is. There are uses in e.g. locked_by.rs that validate valid properties rather than function arguments, and they are not affected by this.