| Message ID | 20250109-module-params-v3-v4-3-c208bcfbe11f@kernel.org (mailing list archive) |
|---|---|
| State | New |
| Headers | show |
| Series | rust: extend `module!` macro with integer parameter support | expand |
On Thu, 09 Jan 2025 11:54:58 +0100 Andreas Hindborg <a.hindborg@kernel.org> wrote: > Add the trait `ParseInt` for parsing string representations of integers > where the string representations are optionally prefixed by a radix > specifier. Implement the trait for the primitive integer types. > > Signed-off-by: Andreas Hindborg <a.hindborg@kernel.org> > --- > rust/kernel/str.rs | 118 +++++++++++++++++++++++++++++++++++++++++++++++++++++ > 1 file changed, 118 insertions(+) > > diff --git a/rust/kernel/str.rs b/rust/kernel/str.rs > index 9c446ff1ad7adba7ca09a5ae9df00fd369a32899..14da40213f9eafa07a104eba3129efe07c8343f3 100644 > --- a/rust/kernel/str.rs > +++ b/rust/kernel/str.rs > @@ -914,3 +914,121 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { > macro_rules! fmt { > ($($f:tt)*) => ( core::format_args!($($f)*) ) > } > + > +pub mod parse_int { > + //! Integer parsing functions for parsing signed and unsigned integers > + //! potentially prefixed with `0x`, `0o`, or `0b`. > + > + use crate::alloc::flags; > + use crate::prelude::*; > + use crate::str::BStr; > + > + /// Trait that allows parsing a [`&BStr`] to an integer with a radix. > + /// > + /// [`&BStr`]: kernel::str::BStr > + // This is required because the `from_str_radix` function on the primitive > + // integer types is not part of any trait. > + pub trait FromStrRadix: Sized { > + /// Parse `src` to `Self` using radix `radix`. > + fn from_str_radix(src: &BStr, radix: u32) -> Result<Self, crate::error::Error>; > + } > + > + /// Extract the radix from an integer literal optionally prefixed with > + /// one of `0x`, `0X`, `0o`, `0O`, `0b`, `0B`, `0`. > + fn strip_radix(src: &BStr) -> (u32, &BStr) { > + if let Some(n) = src.strip_prefix(b_str!("0x")) { > + (16, n) > + } else if let Some(n) = src.strip_prefix(b_str!("0X")) { > + (16, n) > + } else if let Some(n) = src.strip_prefix(b_str!("0o")) { > + (8, n) > + } else if let Some(n) = src.strip_prefix(b_str!("0O")) { > + (8, n) > + } else if let Some(n) = src.strip_prefix(b_str!("0b")) { > + (2, n) > + } else if let Some(n) = src.strip_prefix(b_str!("0B")) { > + (2, n) > + } else if let Some(n) = src.strip_prefix(b_str!("0")) { > + (8, n) > + } else { > + (10, src) > + } This can be done better with a match: match src.deref() { [b'0', b'x' | b'X', ..] => (16, &src[2..]), [b'0', b'o' | b'O', ..] => (8, &src[2..]), [b'0', b'b' | b'B', ..] => (2, &src[2..]), [b'0', ..] => (8, &src[1..]), _ => (10, src), } > + } > + > + /// Trait for parsing string representations of integers. > + /// > + /// Strings beginning with `0x`, `0o`, or `0b` are parsed as hex, octal, or > + /// binary respectively. Strings beginning with `0` otherwise are parsed as > + /// octal. Anything else is parsed as decimal. A leading `+` or `-` is also > + /// permitted. Any string parsed by [`kstrtol()`] or [`kstrtoul()`] will be > + /// successfully parsed. > + /// > + /// [`kstrtol()`]: https://www.kernel.org/doc/html/latest/core-api/kernel-api.html#c.kstrtol > + /// [`kstrtoul()`]: https://www.kernel.org/doc/html/latest/core-api/kernel-api.html#c.kstrtoul > + /// > + /// # Example > + /// ``` > + /// use kernel::str::parse_int::ParseInt; > + /// use kernel::b_str; > + /// > + /// assert_eq!(Ok(0xa2u8), u8::from_str(b_str!("0xa2"))); > + /// assert_eq!(Ok(-0xa2i32), i32::from_str(b_str!("-0xa2"))); > + /// > + /// assert_eq!(Ok(-0o57i8), i8::from_str(b_str!("-0o57"))); > + /// assert_eq!(Ok(0o57i8), i8::from_str(b_str!("057"))); > + /// > + /// assert_eq!(Ok(0b1001i16), i16::from_str(b_str!("0b1001"))); > + /// assert_eq!(Ok(-0b1001i16), i16::from_str(b_str!("-0b1001"))); > + /// > + /// assert_eq!(Ok(127), i8::from_str(b_str!("127"))); > + /// assert!(i8::from_str(b_str!("128")).is_err()); > + /// assert_eq!(Ok(-128), i8::from_str(b_str!("-128"))); > + /// assert!(i8::from_str(b_str!("-129")).is_err()); > + /// assert_eq!(Ok(255), u8::from_str(b_str!("255"))); > + /// assert!(u8::from_str(b_str!("256")).is_err()); > + /// ``` > + pub trait ParseInt: FromStrRadix { > + /// Parse a string according to the description in [`Self`]. > + fn from_str(src: &BStr) -> Result<Self> { > + match src.iter().next() { > + None => Err(EINVAL), > + Some(sign @ b'-') | Some(sign @ b'+') => { > + let (radix, digits) = strip_radix(BStr::from_bytes(&src[1..])); > + let mut n_digits: KVec<u8> = > + KVec::with_capacity(digits.len() + 1, flags::GFP_KERNEL)?; I don't think we should allocate for parsing. This can trivially be a non-allocating. Just check that the next byte is an ASCII digit (reject if so, in case people give multiple signs), and then from_str_radix and return as is or use `checked_neg`. > + n_digits.push(*sign, flags::GFP_KERNEL)?; > + n_digits.extend_from_slice(digits, flags::GFP_KERNEL)?; > + Self::from_str_radix(BStr::from_bytes(&n_digits), radix).map_err(|_| EINVAL) > + } > + Some(_) => { > + let (radix, digits) = strip_radix(src); > + Self::from_str_radix(digits, radix).map_err(|_| EINVAL) > + } > + } > + } > + } > + > + macro_rules! impl_parse_int { > + ($ty:ty) => { > + impl FromStrRadix for $ty { > + fn from_str_radix(src: &BStr, radix: u32) -> Result<Self, crate::error::Error> { > + <$ty>::from_str_radix(core::str::from_utf8(src).map_err(|_| EINVAL)?, radix) > + .map_err(|_| EINVAL) > + } > + } > + > + impl ParseInt for $ty {} > + }; > + } > + > + impl_parse_int!(i8); > + impl_parse_int!(u8); > + impl_parse_int!(i16); > + impl_parse_int!(u16); > + impl_parse_int!(i32); > + impl_parse_int!(u32); > + impl_parse_int!(i64); > + impl_parse_int!(u64); > + impl_parse_int!(isize); > + impl_parse_int!(usize); > +} >
diff --git a/rust/kernel/str.rs b/rust/kernel/str.rs index 9c446ff1ad7adba7ca09a5ae9df00fd369a32899..14da40213f9eafa07a104eba3129efe07c8343f3 100644 --- a/rust/kernel/str.rs +++ b/rust/kernel/str.rs @@ -914,3 +914,121 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { macro_rules! fmt { ($($f:tt)*) => ( core::format_args!($($f)*) ) } + +pub mod parse_int { + //! Integer parsing functions for parsing signed and unsigned integers + //! potentially prefixed with `0x`, `0o`, or `0b`. + + use crate::alloc::flags; + use crate::prelude::*; + use crate::str::BStr; + + /// Trait that allows parsing a [`&BStr`] to an integer with a radix. + /// + /// [`&BStr`]: kernel::str::BStr + // This is required because the `from_str_radix` function on the primitive + // integer types is not part of any trait. + pub trait FromStrRadix: Sized { + /// Parse `src` to `Self` using radix `radix`. + fn from_str_radix(src: &BStr, radix: u32) -> Result<Self, crate::error::Error>; + } + + /// Extract the radix from an integer literal optionally prefixed with + /// one of `0x`, `0X`, `0o`, `0O`, `0b`, `0B`, `0`. + fn strip_radix(src: &BStr) -> (u32, &BStr) { + if let Some(n) = src.strip_prefix(b_str!("0x")) { + (16, n) + } else if let Some(n) = src.strip_prefix(b_str!("0X")) { + (16, n) + } else if let Some(n) = src.strip_prefix(b_str!("0o")) { + (8, n) + } else if let Some(n) = src.strip_prefix(b_str!("0O")) { + (8, n) + } else if let Some(n) = src.strip_prefix(b_str!("0b")) { + (2, n) + } else if let Some(n) = src.strip_prefix(b_str!("0B")) { + (2, n) + } else if let Some(n) = src.strip_prefix(b_str!("0")) { + (8, n) + } else { + (10, src) + } + } + + /// Trait for parsing string representations of integers. + /// + /// Strings beginning with `0x`, `0o`, or `0b` are parsed as hex, octal, or + /// binary respectively. Strings beginning with `0` otherwise are parsed as + /// octal. Anything else is parsed as decimal. A leading `+` or `-` is also + /// permitted. Any string parsed by [`kstrtol()`] or [`kstrtoul()`] will be + /// successfully parsed. + /// + /// [`kstrtol()`]: https://www.kernel.org/doc/html/latest/core-api/kernel-api.html#c.kstrtol + /// [`kstrtoul()`]: https://www.kernel.org/doc/html/latest/core-api/kernel-api.html#c.kstrtoul + /// + /// # Example + /// ``` + /// use kernel::str::parse_int::ParseInt; + /// use kernel::b_str; + /// + /// assert_eq!(Ok(0xa2u8), u8::from_str(b_str!("0xa2"))); + /// assert_eq!(Ok(-0xa2i32), i32::from_str(b_str!("-0xa2"))); + /// + /// assert_eq!(Ok(-0o57i8), i8::from_str(b_str!("-0o57"))); + /// assert_eq!(Ok(0o57i8), i8::from_str(b_str!("057"))); + /// + /// assert_eq!(Ok(0b1001i16), i16::from_str(b_str!("0b1001"))); + /// assert_eq!(Ok(-0b1001i16), i16::from_str(b_str!("-0b1001"))); + /// + /// assert_eq!(Ok(127), i8::from_str(b_str!("127"))); + /// assert!(i8::from_str(b_str!("128")).is_err()); + /// assert_eq!(Ok(-128), i8::from_str(b_str!("-128"))); + /// assert!(i8::from_str(b_str!("-129")).is_err()); + /// assert_eq!(Ok(255), u8::from_str(b_str!("255"))); + /// assert!(u8::from_str(b_str!("256")).is_err()); + /// ``` + pub trait ParseInt: FromStrRadix { + /// Parse a string according to the description in [`Self`]. + fn from_str(src: &BStr) -> Result<Self> { + match src.iter().next() { + None => Err(EINVAL), + Some(sign @ b'-') | Some(sign @ b'+') => { + let (radix, digits) = strip_radix(BStr::from_bytes(&src[1..])); + let mut n_digits: KVec<u8> = + KVec::with_capacity(digits.len() + 1, flags::GFP_KERNEL)?; + n_digits.push(*sign, flags::GFP_KERNEL)?; + n_digits.extend_from_slice(digits, flags::GFP_KERNEL)?; + Self::from_str_radix(BStr::from_bytes(&n_digits), radix).map_err(|_| EINVAL) + } + Some(_) => { + let (radix, digits) = strip_radix(src); + Self::from_str_radix(digits, radix).map_err(|_| EINVAL) + } + } + } + } + + macro_rules! impl_parse_int { + ($ty:ty) => { + impl FromStrRadix for $ty { + fn from_str_radix(src: &BStr, radix: u32) -> Result<Self, crate::error::Error> { + <$ty>::from_str_radix(core::str::from_utf8(src).map_err(|_| EINVAL)?, radix) + .map_err(|_| EINVAL) + } + } + + impl ParseInt for $ty {} + }; + } + + impl_parse_int!(i8); + impl_parse_int!(u8); + impl_parse_int!(i16); + impl_parse_int!(u16); + impl_parse_int!(i32); + impl_parse_int!(u32); + impl_parse_int!(i64); + impl_parse_int!(u64); + impl_parse_int!(isize); + impl_parse_int!(usize); +}
Add the trait `ParseInt` for parsing string representations of integers where the string representations are optionally prefixed by a radix specifier. Implement the trait for the primitive integer types. Signed-off-by: Andreas Hindborg <a.hindborg@kernel.org> --- rust/kernel/str.rs | 118 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 118 insertions(+)