strncpy_from_user for Rust
Alice Ryhl
reviewerv3 cover strncpy_from_user for Rust
There is currently no easy way to read NUL-terminated strings from userspace. Trying to use the ordinary read function on an array of the maximum length doesn't work because it could fail with EFAULT when the C string is shorter than the maximum length. In this case, strncpy_from_user is better because it doesn't return EFAULT even if it encounters a page fault on bytes that are after the NUL-terminator but before the maximum length.
---
Changes in v3:
- Remove pub from raw_strncpy_from_user.
- Mention that some data may have been copied on EFAULT.
- Add more comments to strcpy_into_buf about tricky cases.
- Rewrite documentation of strcpy_into_buf.
- Pick up Reviewed-by tags.
- Link to v2: https://lore.kernel.org/r/[email protected]
Changes in v2:
- Rename the raw wrapper around strncpy_from_user to raw_strncpy_from_user.
- Add a more convenient helper on top that adds the missing
NUL-terminator when necessary.
- Link to v1: https://lore.kernel.org/r/[email protected]
---
Alice Ryhl (2):
uaccess: rust: add strncpy_from_user
uaccess: rust: add UserSliceReader::strcpy_into_buf
rust/kernel/uaccess.rs | 86 +++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 85 insertions(+), 1 deletion(-)
---
base-commit: 9c32cda43eb78f78c73aee4aa344b777714e259b
change-id: 20250424-strncpy-from-user-1f2d06b0cdde
Best regards,
Signature · 1 line
Alice Ryhl <[email protected]>
Alice Ryhl
reviewerPATCH v3 1/2 uaccess: rust: add strncpy_from_user
This patch adds a direct wrapper around the C function of the same name. It's not really intended for direct use by Rust code since strncpy_from_user has a somewhat unfortunate API where it only nul-terminates the buffer if there's space for the nul-terminator. This means that a direct Rust wrapper around it could not return a &CStr since the buffer may not be a cstring. However, we still add the method to build more convenient APIs on top of it, which will happen in subsequent patches.
--- rust/kernel/uaccess.rs | 35 ++++++++++++++++++++++++++++++++++- 1 file changed, 34 insertions(+), 1 deletion(-)
rust/kernel/uaccess.rs +34 -1
@@ -8,7 +8,7 @@ alloc::{Allocator, Flags}, bindings, error::Result, - ffi::c_void, + ffi::{c_char, c_void}, prelude::*, transmute::{AsBytes, FromBytes}, };
@@ -369,3 +369,36 @@ pub fn write<T: AsBytes>(&mut self, value: &T) -> Result {Ok (()) } } + +/// Reads a nul-terminated string into `buf` and returns the length. +/// +/// This reads from userspace until a NUL byte is encountered, or until `buf.len()` bytes have been +/// read. Fails with [`EFAULT`] if a read happens on a bad address (some data may have been +/// copied). When the end of the buffer is encountered, no NUL byte is added, so the string is +/// *not* guaranteed to be NUL-terminated when `Ok(buf.len())` is returned. +/// +/// # Guarantees +/// +/// When this function returns `Ok(len)`, it is guaranteed that the first `len` of `buf` bytes are +/// initialized and non-zero. Furthermore, if `len < buf.len()`, then `buf[len]` is a NUL byte. +/// Unsafe code may rely on these guarantees. +#[inline] +#[expect(dead_code)] +fn raw_strncpy_from_user (ptr:UserPtr , buf: &mut [MaybeUninit <u8 >]) ->Result <usize > { +// CAST: Slice lengths are guaranteed to be `<= isize::MAX`. +let len = buf.len ()as isize ; + +// SAFETY: `buf` is valid for writing `buf.len()` bytes. +let res =unsafe { + bindings::strncpy_from_user (buf.as_mut_ptr ().cast ::<c_char >(), ptras *const c_char , len) + }; + +if res <0 { +return Err (Error ::from_errno (resas i32 )); + } + +#[cfg( CONFIG_RUST_OVERFLOW_CHECKS )] +assert! (res <= len); + +Ok (resas usize ) +}
Signature · 1 line
2.49.0.967.g6a0df3ecc3-goog
Re: [PATCH v3 1/2] uaccess: rust: add strncpy_from_user
Quoted 40 lines · Alice Ryhl
This patch adds a direct wrapper around the C function of the same name. It's not really intended for direct use by Rust code since
strncpy_from_userhas a somewhat unfortunate API where it only nul-terminates the buffer if there's space for the nul-terminator. This means that a direct Rust wrapper around it could not return a &CStr since the buffer may not be a cstring. However, we still add the method to build more convenient APIs on top of it, which will happen in subsequent patches.Reviewed-by Danilo Krummrich <[email protected]>Reviewed-by Greg Kroah-Hartman <[email protected]>Reviewed-by Boqun Feng <[email protected]>Signed-off-by Alice Ryhl <[email protected]>--- rust/kernel/uaccess.rs | 35 ++++++++++++++++++++++++++++++++++- 1 file changed, 34 insertions(+), 1 deletion(-)rust/kernel/uaccess.rs +7
-1@@ -8,7 +8,7 @@ alloc::{Allocator, Flags}, bindings, error::Result, - ffi::c_void, + ffi::{c_char, c_void}, prelude::*, transmute::{AsBytes, FromBytes}, };@@ -369,3 +369,36 @@ pub fn write<T: AsBytes>(&mut self, value: &T) -> Result {Ok (()) } } + +/// Reads a nul-terminated string into `buf` and returns the length. +/// +/// This reads from userspace until a NUL byte is encountered, or until `buf.len()` bytes have been +/// read. Fails with [`EFAULT`] if a read happens on a bad address (some data may have been +/// copied). When the end of the buffer is encountered, no NUL byte is added, so the string is
rust/kernel/uaccess.rs pub fn write<T: AsBytes>(&mut self, value: &T) -> Result { · line 387
Quoted 10 lines
rust/kernel/uaccess.rs +10
-0+/// *not* guaranteed to be NUL-terminated when `Ok(buf.len())` is returned. +/// +/// # Guarantees +/// +/// When this function returns `Ok(len)`, it is guaranteed that the first `len` of `buf` bytes are +/// initialized and non-zero. Furthermore, if `len < buf.len()`, then `buf[len]` is a NUL byte. +/// Unsafe code may rely on these guarantees. +#[inline] +#[expect(dead_code)] +fn raw_strncpy_from_user (ptr:UserPtr , buf: &mut [MaybeUninit <u8 >]) ->Result <usize > {
Nit, the parameters here are backwards from the C version of strncpy_from_user(), which is going to cause us no end of grief when reviewing code between the two languages :(
Also, it's not your fault, but we don't have any type of __user tag for data coming from userspace yet to track this type of thing? The compiler (well sparse) can catch this type of thing in C, any hints on what we could do in Rust for the same type of guarantee (i.e. don't touch user data before it's been copied, and then we need to treat it as "unverified" but that's a different patch series...)
thanks,
greg k-h
Re: [PATCH v3 1/2] uaccess: rust: add strncpy_from_user
On Mon, May 05, 2025 at 04:30:05PM +0200, Greg Kroah-Hartman wrote:
[...]
Quoted 17 lines
Quoted 16 lines
rust/kernel/uaccess.rs +16
-0+ +/// Reads a nul-terminated string into `buf` and returns the length. +/// +/// This reads from userspace until a NUL byte is encountered, or until `buf.len()` bytes have been +/// read. Fails with [`EFAULT`] if a read happens on a bad address (some data may have been +/// copied). When the end of the buffer is encountered, no NUL byte is added, so the string is +/// *not* guaranteed to be NUL-terminated when `Ok(buf.len())` is returned. +/// +/// # Guarantees +/// +/// When this function returns `Ok(len)`, it is guaranteed that the first `len` of `buf` bytes are +/// initialized and non-zero. Furthermore, if `len < buf.len()`, then `buf[len]` is a NUL byte. +/// Unsafe code may rely on these guarantees. +#[inline] +#[expect(dead_code)] +fn raw_strncpy_from_user (ptr:UserPtr , buf: &mut [MaybeUninit <u8 >]) ->Result <usize > {
[...]
Quoted 2 lines
Also, it's not your fault, but we don't have any type of
__usertag for data coming from userspace yet to track this type of thing? The
I think the type UserPtr is supposed to track this information, i.e. Rust can only get a UserPtr from an input from userspace, and of course Rust code cannot treat UserPtr as a normal pointer. For example, the following would fall because of this:
pub fn foo(ptr: *mut u8, ...) {
raw_strncpy_from_user(ptr, ...);
}Regards,
Boqun
Quoted 8 lines
compiler (well sparse) can catch this type of thing in C, any hints on what we could do in Rust for the same type of guarantee (i.e. don't touch user data before it's been copied, and then we need to treat it as "unverified" but that's a different patch series...)
thanks,
greg k-h
Alice Ryhl
reviewerRe: [PATCH v3 1/2] uaccess: rust: add strncpy_from_user
In reply to Greg Kroah-HartmanQuoted 47 lines · Greg Kroah-Hartman
Quoted 46 lines · Alice Ryhl
This patch adds a direct wrapper around the C function of the same name. It's not really intended for direct use by Rust code since
strncpy_from_userhas a somewhat unfortunate API where it only nul-terminates the buffer if there's space for the nul-terminator. This means that a direct Rust wrapper around it could not return a &CStr since the buffer may not be a cstring. However, we still add the method to build more convenient APIs on top of it, which will happen in subsequent patches.Reviewed-by Danilo Krummrich <[email protected]>Reviewed-by Greg Kroah-Hartman <[email protected]>Reviewed-by Boqun Feng <[email protected]>Signed-off-by Alice Ryhl <[email protected]>--- rust/kernel/uaccess.rs | 35 ++++++++++++++++++++++++++++++++++- 1 file changed, 34 insertions(+), 1 deletion(-)rust/kernel/uaccess.rs +13
-1@@ -8,7 +8,7 @@ alloc::{Allocator, Flags}, bindings, error::Result, - ffi::c_void, + ffi::{c_char, c_void}, prelude::*, transmute::{AsBytes, FromBytes}, };@@ -369,3 +369,36 @@ pub fn write<T: AsBytes>(&mut self, value: &T) -> Result {Ok (()) } } + +/// Reads a nul-terminated string into `buf` and returns the length. +/// +/// This reads from userspace until a NUL byte is encountered, or until `buf.len()` bytes have been +/// read. Fails with [`EFAULT`] if a read happens on a bad address (some data may have been +/// copied). When the end of the buffer is encountered, no NUL byte is added, so the string is +/// *not* guaranteed to be NUL-terminated when `Ok(buf.len())` is returned. +/// +/// # Guarantees +/// +/// When this function returns `Ok(len)`, it is guaranteed that the first `len` of `buf` bytes are +/// initialized and non-zero. Furthermore, if `len < buf.len()`, then `buf[len]` is a NUL byte.
Quoted 8 lines
rust/kernel/uaccess.rs pub fn write<T: AsBytes>(&mut self, value: &T) -> Result { · line 387
Quoted 4 lines
rust/kernel/uaccess.rs +4
-0+/// Unsafe code may rely on these guarantees. +#[inline] +#[expect(dead_code)] +fn raw_strncpy_from_user (ptr:UserPtr , buf: &mut [MaybeUninit <u8 >]) ->Result <usize > {Nit, the parameters here are backwards from the C version of
strncpy_from_user(), which is going to cause us no end of grief when reviewing code between the two languages :(
I'll swap them.
fn raw_strncpy_from_user(dst: &mut [MaybeUninit<u8>], src: UserPtr) -> Result<usize> {
Quoted 6 lines
Also, it's not your fault, but we don't have any type of
__usertag for data coming from userspace yet to track this type of thing? The compiler (well sparse) can catch this type of thing in C, any hints on what we could do in Rust for the same type of guarantee (i.e. don't touch user data before it's been copied, and then we need to treat it as "unverified" but that's a different patch series...)
The UserPtr typedef is intended to do that, but since it's only a typedef to usize, the compiler won't detect it if you mix up a user pointer with a length. (It will detect mix-ups with pointers since we use an integer type for UserPtr.)
What we can do is replace the typedef with
#[repr(transparent)]
struct UserPtr(pub usize);
That way, it becomes it's own separate type (this is called the newtype pattern [1]) so that it can't be mixed up with anything else.
The #[repr(transparent)] annotation makes the compiler treat it like a bare long for ABI-purposes. I'm not sure if any function ABIs actually treat a long differently from a struct that just contains a long, but if such ABIs exist, then the annotation ensures that the long ABI is used rather than the struct-containing-long ABI.
Alice
[1]: https://doc.rust-lang.org/rust-by-example/generics/new_types.html
Re: [PATCH v3 1/2] uaccess: rust: add strncpy_from_user
Quoted 68 lines · Alice Ryhl
Quoted 47 lines · Greg Kroah-Hartman
Quoted 46 lines · Alice Ryhl
This patch adds a direct wrapper around the C function of the same name. It's not really intended for direct use by Rust code since
strncpy_from_userhas a somewhat unfortunate API where it only nul-terminates the buffer if there's space for the nul-terminator. This means that a direct Rust wrapper around it could not return a &CStr since the buffer may not be a cstring. However, we still add the method to build more convenient APIs on top of it, which will happen in subsequent patches.Reviewed-by Danilo Krummrich <[email protected]>Reviewed-by Greg Kroah-Hartman <[email protected]>Reviewed-by Boqun Feng <[email protected]>Signed-off-by Alice Ryhl <[email protected]>--- rust/kernel/uaccess.rs | 35 ++++++++++++++++++++++++++++++++++- 1 file changed, 34 insertions(+), 1 deletion(-)rust/kernel/uaccess.rs +13
-1@@ -8,7 +8,7 @@ alloc::{Allocator, Flags}, bindings, error::Result, - ffi::c_void, + ffi::{c_char, c_void}, prelude::*, transmute::{AsBytes, FromBytes}, };@@ -369,3 +369,36 @@ pub fn write<T: AsBytes>(&mut self, value: &T) -> Result {Ok (()) } } + +/// Reads a nul-terminated string into `buf` and returns the length. +/// +/// This reads from userspace until a NUL byte is encountered, or until `buf.len()` bytes have been +/// read. Fails with [`EFAULT`] if a read happens on a bad address (some data may have been +/// copied). When the end of the buffer is encountered, no NUL byte is added, so the string is +/// *not* guaranteed to be NUL-terminated when `Ok(buf.len())` is returned. +/// +/// # Guarantees +/// +/// When this function returns `Ok(len)`, it is guaranteed that the first `len` of `buf` bytes are +/// initialized and non-zero. Furthermore, if `len < buf.len()`, then `buf[len]` is a NUL byte. Quoted 8 lines
rust/kernel/uaccess.rs pub fn write<T: AsBytes>(&mut self, value: &T) -> Result { · line 387
Quoted 4 lines
rust/kernel/uaccess.rs +4
-0+/// Unsafe code may rely on these guarantees. +#[inline] +#[expect(dead_code)] +fn raw_strncpy_from_user (ptr:UserPtr , buf: &mut [MaybeUninit <u8 >]) ->Result <usize > {Nit, the parameters here are backwards from the C version of
strncpy_from_user(), which is going to cause us no end of grief when reviewing code between the two languages :(I'll swap them.
fn
raw_strncpy_from_user(dst: &mut [MaybeUninit<u8>], src: UserPtr)-> Result<usize> {Quoted 6 lines
Also, it's not your fault, but we don't have any type of
__usertag for data coming from userspace yet to track this type of thing? The compiler (well sparse) can catch this type of thing in C, any hints on what we could do in Rust for the same type of guarantee (i.e. don't touch user data before it's been copied, and then we need to treat it as "unverified" but that's a different patch series...)
Quoted 4 lines
The UserPtr typedef is intended to do that, but since it's only a typedef to usize, the compiler won't detect it if you mix up a user pointer with a length. (It will detect mix-ups with pointers since we use an integer type for UserPtr.)
Sorry, I missed the "UserPtr" for some reason. But having an integer type for UserPtr feels like it's going to cause problems in the long-run.
Quoted 7 lines
What we can do is replace the typedef with
#[repr(transparent)]
struct UserPtr(pub usize);That way, it becomes it's own separate type (this is called the newtype pattern [1]) so that it can't be mixed up with anything else.
Why not use a real pointer like:
struct UserPtr(pub *const u8)
Quoted 5 lines
The #[repr(transparent)] annotation makes the compiler treat it like a bare long for ABI-purposes. I'm not sure if any function ABIs actually treat a long differently from a struct that just contains a long, but if such ABIs exist, then the annotation ensures that the long ABI is used rather than the struct-containing-long ABI.
In the kernel, "unsigned long" is guaranteed to hold a pointer. Which is why many of the old allocation functions return that type.
thanks,
greg k-h
Alice Ryhl
reviewerRe: [PATCH v3 1/2] uaccess: rust: add strncpy_from_user
Quoted 90 lines · Greg Kroah-Hartman
Quoted 68 lines · Alice Ryhl
Quoted 47 lines · Greg Kroah-Hartman
Quoted 46 lines · Alice Ryhl
This patch adds a direct wrapper around the C function of the same name. It's not really intended for direct use by Rust code since
strncpy_from_userhas a somewhat unfortunate API where it only nul-terminates the buffer if there's space for the nul-terminator. This means that a direct Rust wrapper around it could not return a &CStr since the buffer may not be a cstring. However, we still add the method to build more convenient APIs on top of it, which will happen in subsequent patches.Reviewed-by Danilo Krummrich <[email protected]>Reviewed-by Greg Kroah-Hartman <[email protected]>Reviewed-by Boqun Feng <[email protected]>Signed-off-by Alice Ryhl <[email protected]>--- rust/kernel/uaccess.rs | 35 ++++++++++++++++++++++++++++++++++- 1 file changed, 34 insertions(+), 1 deletion(-)rust/kernel/uaccess.rs +13
-1@@ -8,7 +8,7 @@ alloc::{Allocator, Flags}, bindings, error::Result, - ffi::c_void, + ffi::{c_char, c_void}, prelude::*, transmute::{AsBytes, FromBytes}, };@@ -369,3 +369,36 @@ pub fn write<T: AsBytes>(&mut self, value: &T) -> Result {Ok (()) } } + +/// Reads a nul-terminated string into `buf` and returns the length. +/// +/// This reads from userspace until a NUL byte is encountered, or until `buf.len()` bytes have been +/// read. Fails with [`EFAULT`] if a read happens on a bad address (some data may have been +/// copied). When the end of the buffer is encountered, no NUL byte is added, so the string is +/// *not* guaranteed to be NUL-terminated when `Ok(buf.len())` is returned. +/// +/// # Guarantees +/// +/// When this function returns `Ok(len)`, it is guaranteed that the first `len` of `buf` bytes are +/// initialized and non-zero. Furthermore, if `len < buf.len()`, then `buf[len]` is a NUL byte. Quoted 8 lines
rust/kernel/uaccess.rs pub fn write<T: AsBytes>(&mut self, value: &T) -> Result { · line 387
Quoted 4 lines
rust/kernel/uaccess.rs +4
-0+/// Unsafe code may rely on these guarantees. +#[inline] +#[expect(dead_code)] +fn raw_strncpy_from_user (ptr:UserPtr , buf: &mut [MaybeUninit <u8 >]) ->Result <usize > {Nit, the parameters here are backwards from the C version of
strncpy_from_user(), which is going to cause us no end of grief when reviewing code between the two languages :(I'll swap them.
fn
raw_strncpy_from_user(dst: &mut [MaybeUninit<u8>], src: UserPtr)-> Result<usize> {Quoted 6 lines
Also, it's not your fault, but we don't have any type of
__usertag for data coming from userspace yet to track this type of thing? The compiler (well sparse) can catch this type of thing in C, any hints on what we could do in Rust for the same type of guarantee (i.e. don't touch user data before it's been copied, and then we need to treat it as "unverified" but that's a different patch series...)Quoted 4 lines
The UserPtr typedef is intended to do that, but since it's only a typedef to usize, the compiler won't detect it if you mix up a user pointer with a length. (It will detect mix-ups with pointers since we use an integer type for UserPtr.)
Sorry, I missed the "UserPtr" for some reason. But having an integer type for UserPtr feels like it's going to cause problems in the long-run.
Quoted 7 lines
What we can do is replace the typedef with
#[repr(transparent)]
struct UserPtr(pub usize);That way, it becomes it's own separate type (this is called the newtype pattern [1]) so that it can't be mixed up with anything else.
Why not use a real pointer like:
structUserPtr(pub *const u8)
Quoted 8 lines
Quoted 5 lines
The #[repr(transparent)] annotation makes the compiler treat it like a bare long for ABI-purposes. I'm not sure if any function ABIs actually treat a long differently from a struct that just contains a long, but if such ABIs exist, then the annotation ensures that the long ABI is used rather than the struct-containing-long ABI.
In the kernel, "unsigned long" is guaranteed to hold a pointer. Which is why many of the old allocation functions return that type.
Let's continue this discussion on the patch I just sent to make it a real struct:
https://lore.kernel.org/r/[email protected]
I don't fully recall the reason, but it was changed from a raw pointer to usize in version 6 of the patch set that added it.
Alice
Alice Ryhl
reviewerPATCH v3 2/2 uaccess: rust: add UserSliceReader::strcpy_into_buf
In reply to Alice RyhlThis patch adds a more convenient method for reading C strings from userspace. Logic is added to NUL-terminate the buffer when necessary so that a &CStr can be returned.
Note that we treat attempts to read past self.length as a fault, so this returns EFAULT if that limit is exceeded before buf.len() is reached.
--- rust/kernel/uaccess.rs | 53 +++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 52 insertions(+), 1 deletion(-)
rust/kernel/uaccess.rs +52 -1
@@ -293,6 +293,58 @@ pub fn read_all<A: Allocator>(mut self, buf: &mut Vec<u8, A>, flags: Flags) -> Runsafe { buf.set_len (buf.len () + len) };Ok (()) } + +/// Read a NUL-terminated string from userspace and return it. +/// +/// The string is read into `buf` and a NUL-terminator is added if the end of `buf` is reached. +/// Since there must be space to add a NUL-terminator, the buffer must not be empty. The +/// returned `&CStr` points into `buf`. +/// +/// Fails with [`EFAULT`] if the read happens on a bad address (some data may have been +/// copied). +#[doc(alias = "strncpy_from_user" )] +pub fn strcpy_into_buf <'buf>(self, buf: &'bufmut [u8 ]) ->Result <&'bufCStr > { +if buf.is_empty () { +return Err (EINVAL ); + } + +// SAFETY: The types are compatible and `strncpy_from_user` doesn't write uninitialized +// bytes to `buf`. +let mut dst =unsafe { &mut *(bufas *mut [u8 ]as *mut [MaybeUninit <u8 >]) }; + +// We never read more than `self.length` bytes. +if dst.len () > self.length { + dst = &mut dst[..self.length]; + } + +let mut len =raw_strncpy_from_user (self.ptr, dst)?; +if len < dst.len () { +// Add one to include the NUL-terminator. + len +=1 ; + }else if len < buf.len () { +// This implies that len == dst.len() < buf.len(). +// +// This means that we could not fill the entire buffer, but we had to stop reading +// because we hit the `self.length` limit of this `UserSliceReader`. Since we did not +// fill the buffer, we treat this case as if we tried to read past the `self.length` +// limit and received a page fault, which is consistent with other `UserSliceReader` +// methods that also return page faults when you exceed `self.length`. +return Err (EFAULT ); + }else { +// This implies that len == buf.len(). +// +// This means that we filled the buffer exactly. In this case, we add a NUL-terminator +// and return it. Unlike the `len < dst.len()` branch, don't modify `len` because it +// already represents the length including the NUL-terminator. +// +// SAFETY: Due to the check at the beginning, the buffer is not empty. +unsafe { *buf.last_mut ().unwrap_unchecked () =0 }; + } + +// SAFETY: `raw_strncpy_from_user` guarantees that this range of bytes represents a +// NUL-terminated string with the only NUL byte being at the end. +Ok (unsafe {CStr ::from_bytes_with_nul_unchecked (&buf[..len]) }) + } }/// A writer for [`UserSlice`].
@@ -383,7 +435,6 @@ pub fn write<T: AsBytes>(&mut self, value: &T) -> Result {/// initialized and non-zero. Furthermore, if `len < buf.len()`, then `buf[len]` is a NUL byte. /// Unsafe code may rely on these guarantees. #[inline] -#[expect(dead_code)] fn raw_strncpy_from_user (ptr:UserPtr , buf: &mut [MaybeUninit <u8 >]) ->Result <usize > {// CAST: Slice lengths are guaranteed to be `<= isize::MAX`. let len = buf.len ()as isize ;
Signature · 1 line
2.49.0.967.g6a0df3ecc3-goog
Re: [PATCH v3 2/2] uaccess: rust: add UserSliceReader::strcpy_into_buf
Quoted 39 lines · Alice Ryhl
rust/kernel/uaccess.rs +39
-0+/// Read a NUL-terminated string from userspace and return it. +/// +/// The string is read into `buf` and a NUL-terminator is added if the end of `buf` is reached. +/// Since there must be space to add a NUL-terminator, the buffer must not be empty. The +/// returned `&CStr` points into `buf`. +/// +/// Fails with [`EFAULT`] if the read happens on a bad address (some data may have been +/// copied). +#[doc(alias = "strncpy_from_user" )] +pub fn strcpy_into_buf <'buf>(self, buf: &'bufmut [u8 ]) ->Result <&'bufCStr > { +if buf.is_empty () { +return Err (EINVAL ); + } + +// SAFETY: The types are compatible and `strncpy_from_user` doesn't write uninitialized +// bytes to `buf`. +let mut dst =unsafe { &mut *(bufas *mut [u8 ]as *mut [MaybeUninit <u8 >]) }; + +// We never read more than `self.length` bytes. +if dst.len () > self.length { + dst = &mut dst[..self.length]; + } + +let mut len =raw_strncpy_from_user (self.ptr, dst)?; +if len < dst.len () { +// Add one to include the NUL-terminator. + len +=1 ; + }else if len < buf.len () { +// This implies that len == dst.len() < buf.len(). +// +// This means that we could not fill the entire buffer, but we had to stop reading +// because we hit the `self.length` limit of this `UserSliceReader`. Since we did not +// fill the buffer, we treat this case as if we tried to read past the `self.length` +// limit and received a page fault, which is consistent with other `UserSliceReader` +// methods that also return page faults when you exceed `self.length`. +return Err (EFAULT ); + }else { +// This implies that len == buf.len(). +//
rust/kernel/uaccess.rs pub fn read_all<A: Allocator>(mut self, buf: &mut Vec<u8, A>, flags: Flags) -> R · line 345
Quoted 10 lines
rust/kernel/uaccess.rs +10
-0+// This means that we filled the buffer exactly. In this case, we add a NUL-terminator +// and return it. Unlike the `len < dst.len()` branch, don't modify `len` because it +// already represents the length including the NUL-terminator. +// +// SAFETY: Due to the check at the beginning, the buffer is not empty. +unsafe { *buf.last_mut ().unwrap_unchecked () =0 }; + } + +// SAFETY: `raw_strncpy_from_user` guarantees that this range of bytes represents a +// NUL-terminated string with the only NUL byte being at the end.
This isn't true if we hit the else case above, no?
With that fixed,
Alice Ryhl
reviewerRe: [PATCH v3 2/2] uaccess: rust: add UserSliceReader::strcpy_into_buf
Quoted 53 lines · Danilo Krummrich
Quoted 39 lines · Alice Ryhl
rust/kernel/uaccess.rs +39
-0+/// Read a NUL-terminated string from userspace and return it. +/// +/// The string is read into `buf` and a NUL-terminator is added if the end of `buf` is reached. +/// Since there must be space to add a NUL-terminator, the buffer must not be empty. The +/// returned `&CStr` points into `buf`. +/// +/// Fails with [`EFAULT`] if the read happens on a bad address (some data may have been +/// copied). +#[doc(alias = "strncpy_from_user" )] +pub fn strcpy_into_buf <'buf>(self, buf: &'bufmut [u8 ]) ->Result <&'bufCStr > { +if buf.is_empty () { +return Err (EINVAL ); + } + +// SAFETY: The types are compatible and `strncpy_from_user` doesn't write uninitialized +// bytes to `buf`. +let mut dst =unsafe { &mut *(bufas *mut [u8 ]as *mut [MaybeUninit <u8 >]) }; + +// We never read more than `self.length` bytes. +if dst.len () > self.length { + dst = &mut dst[..self.length]; + } + +let mut len =raw_strncpy_from_user (self.ptr, dst)?; +if len < dst.len () { +// Add one to include the NUL-terminator. + len +=1 ; + }else if len < buf.len () { +// This implies that len == dst.len() < buf.len(). +// +// This means that we could not fill the entire buffer, but we had to stop reading +// because we hit the `self.length` limit of this `UserSliceReader`. Since we did not +// fill the buffer, we treat this case as if we tried to read past the `self.length` +// limit and received a page fault, which is consistent with other `UserSliceReader` +// methods that also return page faults when you exceed `self.length`. +return Err (EFAULT ); + }else { +// This implies that len == buf.len(). +// rust/kernel/uaccess.rs pub fn read_all<A: Allocator>(mut self, buf: &mut Vec<u8, A>, flags: Flags) -> R · line 345
Quoted 10 lines
rust/kernel/uaccess.rs +10
-0+// This means that we filled the buffer exactly. In this case, we add a NUL-terminator +// and return it. Unlike the `len < dst.len()` branch, don't modify `len` because it +// already represents the length including the NUL-terminator. +// +// SAFETY: Due to the check at the beginning, the buffer is not empty. +unsafe { *buf.last_mut ().unwrap_unchecked () =0 }; + } + +// SAFETY: `raw_strncpy_from_user` guarantees that this range of bytes represents a +// NUL-terminated string with the only NUL byte being at the end. This isn't true if we hit the else case above, no?
Quoted 3 lines
With that fixed,
Reviewed-by Danilo Krummrich <[email protected]>
I guess the wording is a bit off. I will update to this:
// SAFETY: There are two cases:
// * If we hit the len < dst.len() case, then raw_strncpy_from_user
// guarantees that this slice contains exactly one NUL byte at the end
// of the string.
// * Otherwise, raw_strncpy_from_user guarantees that the string
// contained no NUL bytes, and we have since added a NUL byte at the
// end.
Alice
Alice Ryhl
reviewerQuoted 10 lines · Alice Ryhl
There is currently no easy way to read NUL-terminated strings from userspace. Trying to use the ordinary read function on an array of the maximum length doesn't work because it could fail with EFAULT when the C string is shorter than the maximum length. In this case,
strncpy_from_useris better because it doesn't return EFAULT even if it encounters a page fault on bytes that are after the NUL-terminator but before the maximum length.Signed-off-by Alice Ryhl <[email protected]>
Quoted 8 lines
---
Changes in v3:
- Remove pub fromraw_strncpy_from_user.
- Mention that some data may have been copied on EFAULT.
- Add more comments tostrcpy_into_bufabout tricky cases.
- Rewrite documentation ofstrcpy_into_buf.
- Pick up Reviewed-by tags.
- Link to v2: https://lore.kernel.org/r/[email protected]
Oh I forgot to mention that I added a documentation alias so that searching for strncpy_from_user using the search box on
https://rust.docs.kernel.org/ will show this function in the search results.
Alice