Currently, the `seq_print!` macro formats output by passing a Rust
`fmt::Arguments` object to the C `seq_printf` function using the `%pA`.
This involves crossing the FFI boundary, parsing the
format string in C via `vsnprintf`, and triggering a callback back
into Rust to perform the actual buffer write.

This patch implements `core::fmt::Write` for `&SeqFile` and updates
`call_printf` to use it, routing Rust's formatting directly to
`bindings::seq_write`. This approach leverages the bounded string
slices naturally produced by the Rust formatting machinery and copies
them directly into the `seq_file` buffer.

By mapping to `seq_write`, we bypass the C string parsing state machine
and the `%pA` FFI callback, streamlining the execution path. Since
`seq_write` uses a bounded `memcpy` relying on the explicitly passed
length, it perfectly matches Rust's `&str` semantics and operates
safely without requiring null-termination.

Note that `fmt::Write` chunks the output into multiple `seq_write` calls.
If an overflow occurs during a partial write, `seq_write` sets the
overflow flag. The `seq_file` subsystem inherently handles this by
discarding the current record and retrying with a larger buffer.
Therefore, this optimization introduces no observable semantic change
to user-space.

Signed-off-by: Yifei Yao <donplat@barrensea.org>
---

Changes in v2:
- Add `#[inline]` annotation to the `write_str` trait method.
- Fix author name and signed-off name to use real name per the kernel's
  DCO policy.
- Correctly check the return value of `seq_write` and propagates errors on overflow.

 rust/kernel/seq_file.rs | 32 ++++++++++++++++++++++++--------
 1 file changed, 24 insertions(+), 8 deletions(-)

diff --git a/rust/kernel/seq_file.rs b/rust/kernel/seq_file.rs
index 518265558d6..d7dbdadde60 100644
--- a/rust/kernel/seq_file.rs
+++ b/rust/kernel/seq_file.rs
@@ -4,7 +4,7 @@
 //!
 //! C header: [`include/linux/seq_file.h`](srctree/include/linux/seq_file.h)
 
-use crate::{bindings, fmt, str::CStrExt as _, types::NotThreadSafe, types::Opaque};
+use crate::{bindings, ffi::c_void, fmt, types::NotThreadSafe, types::Opaque};
 
 /// A utility for generating the contents of a seq file.
 #[repr(transparent)]
@@ -32,13 +32,29 @@ pub unsafe fn from_raw<'a>(ptr: *mut bindings::seq_file) -> &'a SeqFile {
     /// Used by the [`seq_print`] macro.
     #[inline]
     pub fn call_printf(&self, args: fmt::Arguments<'_>) {
-        // SAFETY: Passing a void pointer to `Arguments` is valid for `%pA`.
-        unsafe {
-            bindings::seq_printf(
-                self.inner.get(),
-                c"%pA".as_char_ptr(),
-                core::ptr::from_ref(&args).cast::<crate::ffi::c_void>(),
-            );
+        let mut this = self;
+        let _ = fmt::Write::write_fmt(&mut this, args);
+    }
+}
+
+impl fmt::Write for &SeqFile {
+    #[inline]
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        // SAFETY: `self` is a valid reference, ensuring `self.inner.get()` is a valid pointer
+        // to `struct seq_file`. `s` is a valid string slice, guaranteeing `s.as_ptr()` is
+        // readable for `s.len()` bytes. `seq_write` handles bounds checking and does not
+        // require a null-terminated string.
+        //
+        // CAST: `s.as_ptr()` (a `*const u8`) is cast to `*const c_void` because `seq_write`
+        // only reads the buffer via `memcpy` and does not care about the underlying type.
+
+        let res =
+            unsafe { bindings::seq_write(self.inner.get(), s.as_ptr().cast::<c_void>(), s.len()) };
+
+        if res < 0 {
+            Err(fmt::Error)
+        } else {
+            Ok(())
         }
     }
 }
-- 
2.53.0

On Sat May 16, 2026 at 5:08 AM BST, Yifei Yao wrote:
> Currently, the `seq_print!` macro formats output by passing a Rust
> `fmt::Arguments` object to the C `seq_printf` function using the `%pA`.
> This involves crossing the FFI boundary, parsing the
> format string in C via `vsnprintf`, and triggering a callback back
> into Rust to perform the actual buffer write.
>
> This patch implements `core::fmt::Write` for `&SeqFile` and updates
> `call_printf` to use it, routing Rust's formatting directly to
> `bindings::seq_write`. This approach leverages the bounded string
> slices naturally produced by the Rust formatting machinery and copies
> them directly into the `seq_file` buffer.
>
> By mapping to `seq_write`, we bypass the C string parsing state machine
> and the `%pA` FFI callback, streamlining the execution path. Since
> `seq_write` uses a bounded `memcpy` relying on the explicitly passed
> length, it perfectly matches Rust's `&str` semantics and operates
> safely without requiring null-termination.
>
> Note that `fmt::Write` chunks the output into multiple `seq_write` calls.
> If an overflow occurs during a partial write, `seq_write` sets the
> overflow flag. The `seq_file` subsystem inherently handles this by
> discarding the current record and retrying with a larger buffer.
> Therefore, this optimization introduces no observable semantic change
> to user-space.

Seems that this description is AI-generated. If you used them this must be
disclosed per kernel policy:
https://docs.kernel.org/process/coding-assistants.html.

What's the benefit of this change? Given a single "%pA" string vsnprintf doesn't
do much before passing it back to the Rust formatting machinery. `seq_printf`
just formats directly into its internal buffer, so it's not like there's any
additional copy being optimized out with this change.

This also changes the behaviour when write does overflow, where the previous
code would write as much as possible to the buffer and the new one would not
write anything if the last chunk being written would cause overflow.

Best,
Gary

On Sat, 16 May 2026 12:08:12 +0800
Yifei Yao <donplat@barrensea.org> wrote:

> Currently, the `seq_print!` macro formats output by passing a Rust
> `fmt::Arguments` object to the C `seq_printf` function using the `%pA`.
> This involves crossing the FFI boundary, parsing the
> format string in C via `vsnprintf`, and triggering a callback back
> into Rust to perform the actual buffer write.
> 
> This patch implements `core::fmt::Write` for `&SeqFile` and updates
> `call_printf` to use it, routing Rust's formatting directly to
> `bindings::seq_write`. This approach leverages the bounded string
> slices naturally produced by the Rust formatting machinery and copies
> them directly into the `seq_file` buffer.
> 
> By mapping to `seq_write`, we bypass the C string parsing state machine
> and the `%pA` FFI callback, streamlining the execution path. Since
> `seq_write` uses a bounded `memcpy` relying on the explicitly passed
> length, it perfectly matches Rust's `&str` semantics and operates
> safely without requiring null-termination.
> 
> Note that `fmt::Write` chunks the output into multiple `seq_write` calls.
> If an overflow occurs during a partial write, `seq_write` sets the
> overflow flag. The `seq_file` subsystem inherently handles this by
> discarding the current record and retrying with a larger buffer.
> Therefore, this optimization introduces no observable semantic change
> to user-space.
> 
> Signed-off-by: Yifei Yao <donplat@barrensea.org>
> ---
> 
> Changes in v2:
> - Add `#[inline]` annotation to the `write_str` trait method.
> - Fix author name and signed-off name to use real name per the kernel's
>   DCO policy.
> - Correctly check the return value of `seq_write` and propagates errors on overflow.
> 
>  rust/kernel/seq_file.rs | 32 ++++++++++++++++++++++++--------
>  1 file changed, 24 insertions(+), 8 deletions(-)
> 
> diff --git a/rust/kernel/seq_file.rs b/rust/kernel/seq_file.rs
> index 518265558d6..d7dbdadde60 100644
> --- a/rust/kernel/seq_file.rs
> +++ b/rust/kernel/seq_file.rs
> @@ -4,7 +4,7 @@
>  //!
>  //! C header: [`include/linux/seq_file.h`](srctree/include/linux/seq_file.h)
>  
> -use crate::{bindings, fmt, str::CStrExt as _, types::NotThreadSafe, types::Opaque};
> +use crate::{bindings, ffi::c_void, fmt, types::NotThreadSafe, types::Opaque};
>  
>  /// A utility for generating the contents of a seq file.
>  #[repr(transparent)]
> @@ -32,13 +32,29 @@ pub unsafe fn from_raw<'a>(ptr: *mut bindings::seq_file) -> &'a SeqFile {
>      /// Used by the [`seq_print`] macro.
>      #[inline]
>      pub fn call_printf(&self, args: fmt::Arguments<'_>) {
> -        // SAFETY: Passing a void pointer to `Arguments` is valid for `%pA`.
> -        unsafe {
> -            bindings::seq_printf(
> -                self.inner.get(),
> -                c"%pA".as_char_ptr(),
> -                core::ptr::from_ref(&args).cast::<crate::ffi::c_void>(),
> -            );
> +        let mut this = self;
> +        let _ = fmt::Write::write_fmt(&mut this, args);
> +    }
> +}
> +
> +impl fmt::Write for &SeqFile {
> +    #[inline]
> +    fn write_str(&mut self, s: &str) -> fmt::Result {
> +        // SAFETY: `self` is a valid reference, ensuring `self.inner.get()` is a valid pointer
> +        // to `struct seq_file`. `s` is a valid string slice, guaranteeing `s.as_ptr()` is
> +        // readable for `s.len()` bytes. `seq_write` handles bounds checking and does not
> +        // require a null-terminated string.
> +        //
> +        // CAST: `s.as_ptr()` (a `*const u8`) is cast to `*const c_void` because `seq_write`
> +        // only reads the buffer via `memcpy` and does not care about the underlying type.
> +
> +        let res =
> +            unsafe { bindings::seq_write(self.inner.get(), s.as_ptr().cast::<c_void>(), s.len()) };
> +
> +        if res < 0 {
> +            Err(fmt::Error)
> +        } else {
> +            Ok(())
>          }
>      }
>  }
> -- 
> 2.53.0
> 

FYI new versions are usually sent separately.

Onur

Thanks for the reminder.Got it. I'll make sure to send future versions 
as completely separate threads.

在 2026/5/16 15:57, Onur Özkan 写道:
> On Sat, 16 May 2026 12:08:12 +0800
> Yifei Yao <donplat@barrensea.org> wrote:
>
>> Currently, the `seq_print!` macro formats output by passing a Rust
>> `fmt::Arguments` object to the C `seq_printf` function using the `%pA`.
>> This involves crossing the FFI boundary, parsing the
>> format string in C via `vsnprintf`, and triggering a callback back
>> into Rust to perform the actual buffer write.
>>
>> This patch implements `core::fmt::Write` for `&SeqFile` and updates
>> `call_printf` to use it, routing Rust's formatting directly to
>> `bindings::seq_write`. This approach leverages the bounded string
>> slices naturally produced by the Rust formatting machinery and copies
>> them directly into the `seq_file` buffer.
>>
>> By mapping to `seq_write`, we bypass the C string parsing state machine
>> and the `%pA` FFI callback, streamlining the execution path. Since
>> `seq_write` uses a bounded `memcpy` relying on the explicitly passed
>> length, it perfectly matches Rust's `&str` semantics and operates
>> safely without requiring null-termination.
>>
>> Note that `fmt::Write` chunks the output into multiple `seq_write` calls.
>> If an overflow occurs during a partial write, `seq_write` sets the
>> overflow flag. The `seq_file` subsystem inherently handles this by
>> discarding the current record and retrying with a larger buffer.
>> Therefore, this optimization introduces no observable semantic change
>> to user-space.
>>
>> Signed-off-by: Yifei Yao <donplat@barrensea.org>
>> ---
>>
>> Changes in v2:
>> - Add `#[inline]` annotation to the `write_str` trait method.
>> - Fix author name and signed-off name to use real name per the kernel's
>>    DCO policy.
>> - Correctly check the return value of `seq_write` and propagates errors on overflow.
>>
>>   rust/kernel/seq_file.rs | 32 ++++++++++++++++++++++++--------
>>   1 file changed, 24 insertions(+), 8 deletions(-)
>>
>> diff --git a/rust/kernel/seq_file.rs b/rust/kernel/seq_file.rs
>> index 518265558d6..d7dbdadde60 100644
>> --- a/rust/kernel/seq_file.rs
>> +++ b/rust/kernel/seq_file.rs
>> @@ -4,7 +4,7 @@
>>   //!
>>   //! C header: [`include/linux/seq_file.h`](srctree/include/linux/seq_file.h)
>>   
>> -use crate::{bindings, fmt, str::CStrExt as _, types::NotThreadSafe, types::Opaque};
>> +use crate::{bindings, ffi::c_void, fmt, types::NotThreadSafe, types::Opaque};
>>   
>>   /// A utility for generating the contents of a seq file.
>>   #[repr(transparent)]
>> @@ -32,13 +32,29 @@ pub unsafe fn from_raw<'a>(ptr: *mut bindings::seq_file) -> &'a SeqFile {
>>       /// Used by the [`seq_print`] macro.
>>       #[inline]
>>       pub fn call_printf(&self, args: fmt::Arguments<'_>) {
>> -        // SAFETY: Passing a void pointer to `Arguments` is valid for `%pA`.
>> -        unsafe {
>> -            bindings::seq_printf(
>> -                self.inner.get(),
>> -                c"%pA".as_char_ptr(),
>> -                core::ptr::from_ref(&args).cast::<crate::ffi::c_void>(),
>> -            );
>> +        let mut this = self;
>> +        let _ = fmt::Write::write_fmt(&mut this, args);
>> +    }
>> +}
>> +
>> +impl fmt::Write for &SeqFile {
>> +    #[inline]
>> +    fn write_str(&mut self, s: &str) -> fmt::Result {
>> +        // SAFETY: `self` is a valid reference, ensuring `self.inner.get()` is a valid pointer
>> +        // to `struct seq_file`. `s` is a valid string slice, guaranteeing `s.as_ptr()` is
>> +        // readable for `s.len()` bytes. `seq_write` handles bounds checking and does not
>> +        // require a null-terminated string.
>> +        //
>> +        // CAST: `s.as_ptr()` (a `*const u8`) is cast to `*const c_void` because `seq_write`
>> +        // only reads the buffer via `memcpy` and does not care about the underlying type.
>> +
>> +        let res =
>> +            unsafe { bindings::seq_write(self.inner.get(), s.as_ptr().cast::<c_void>(), s.len()) };
>> +
>> +        if res < 0 {
>> +            Err(fmt::Error)
>> +        } else {
>> +            Ok(())
>>           }
>>       }
>>   }
>> -- 
>> 2.53.0
>>
> FYI new versions are usually sent separately.
>
> Onur