Commit f411b7ed authored by Tamir Duberstein's avatar Tamir Duberstein Committed by Miguel Ojeda
Browse files

rust: kernel: remove `fmt!`, fix clippy::uninlined-format-args 

Rather than export a macro that delegates to `core::format_args`, simply
re-export `core::format_args` as `fmt` from the prelude. This exposes
clippy warnings which were previously obscured by this macro, such as:

    warning: variables can be used directly in the `format!` string
      --> ../drivers/cpufreq/rcpufreq_dt.rs:21:43
       |
    21 |     let prop_name = CString::try_from_fmt(fmt!("{}-supply", name)).ok()?;
       |                                           ^^^^^^^^^^^^^^^^^^^^^^^
       |
       = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args


       = note: `-W clippy::uninlined-format-args` implied by `-W clippy::all`
       = help: to override `-W clippy::all` add `#[allow(clippy::uninlined_format_args)]`
    help: change this to
       |
    21 -     let prop_name = CString::try_from_fmt(fmt!("{}-supply", name)).ok()?;
    21 +     let prop_name = CString::try_from_fmt(fmt!("{name}-supply")).ok()?;
       |

Thus fix them in the same commit. This could possibly be fixed in two
stages, but the diff is small enough (outside of kernel/str.rs) that I
hope it can be taken in a single commit.

Signed-off-by: default avatarTamir Duberstein <tamird@gmail.com>
Reviewed-by: default avatarBenno Lossin <lossin@kernel.org>
Reviewed-by: default avatarAlice Ryhl <aliceryhl@google.com>
Acked-by: default avatarDanilo Krummrich <dakr@kernel.org>
Link: https://lore.kernel.org/r/20250704-core-cstr-prepare-v1-1-a91524037783@gmail.com


Signed-off-by: default avatarMiguel Ojeda <ojeda@kernel.org>
parent 2254991d

drivers/cpufreq/rcpufreq_dt.rs

+1 −2
Original line number Diff line number Diff line
@@ -9,7 +9,6 @@ 
    cpumask::CpumaskVar,

    device::{Core, Device},

    error::code::*,

    fmt,

    macros::vtable,

    module_platform_driver, of, opp, platform,

    prelude::*,
@@ -19,7 +18,7 @@ 


/// Finds exact supply name from the OF node.

fn find_supply_name_exact(dev: &Device, name: &str) -> Option<CString> {

    let prop_name = CString::try_from_fmt(fmt!("{}-supply", name)).ok()?;

    let prop_name = CString::try_from_fmt(fmt!("{name}-supply")).ok()?;

    dev.property_present(&prop_name)

        .then(|| CString::try_from_fmt(fmt!("{name}")).ok())

        .flatten()

drivers/gpu/nova-core/firmware.rs

+3 −2
Original line number Diff line number Diff line
@@ -24,11 +24,12 @@ pub(crate) struct Firmware { 


impl Firmware {

    pub(crate) fn new(dev: &device::Device, chipset: Chipset, ver: &str) -> Result<Firmware> {

        let mut chip_name = CString::try_from_fmt(fmt!("{}", chipset))?;

        let mut chip_name = CString::try_from_fmt(fmt!("{chipset}"))?;

        chip_name.make_ascii_lowercase();

        let chip_name = &*chip_name;



        let request = |name_| {

            CString::try_from_fmt(fmt!("nvidia/{}/gsp/{}-{}.bin", &*chip_name, name_, ver))

            CString::try_from_fmt(fmt!("nvidia/{chip_name}/gsp/{name_}-{ver}.bin"))

                .and_then(|path| firmware::Firmware::request(&path, dev))

        };

rust/kernel/opp.rs

+1 −1
Original line number Diff line number Diff line
@@ -345,7 +345,7 @@ fn drop(&mut self) { 
/// impl ConfigOps for Driver {}

///

/// fn configure(dev: &ARef<Device>) -> Result<ConfigToken> {

///     let name = CString::try_from_fmt(fmt!("{}", "slow"))?;

///     let name = CString::try_from_fmt(fmt!("slow"))?;

///

///     // The OPP configuration is cleared once the [`ConfigToken`] goes out of scope.

///     Config::<Driver>::new()

rust/kernel/prelude.rs

+1 −1
Original line number Diff line number Diff line
@@ -31,9 +31,9 @@ 
// `super::std_vendor` is hidden, which makes the macro inline for some reason.

#[doc(no_inline)]

pub use super::dbg;

pub use super::fmt;

pub use super::{dev_alert, dev_crit, dev_dbg, dev_emerg, dev_err, dev_info, dev_notice, dev_warn};

pub use super::{pr_alert, pr_crit, pr_debug, pr_emerg, pr_err, pr_info, pr_notice, pr_warn};

pub use core::format_args as fmt;



pub use super::{try_init, try_pin_init};

rust/kernel/str.rs

+14 −20
Original line number Diff line number Diff line
@@ -54,13 +54,13 @@ impl fmt::Display for BStr { 
    /// Formats printable ASCII characters, escaping the rest.

    ///

    /// ```

    /// # use kernel::{fmt, b_str, str::{BStr, CString}};

    /// # use kernel::{prelude::fmt, b_str, str::{BStr, CString}};

    /// let ascii = b_str!("Hello, BStr!");

    /// let s = CString::try_from_fmt(fmt!("{}", ascii))?;

    /// let s = CString::try_from_fmt(fmt!("{ascii}"))?;

    /// assert_eq!(s.as_bytes(), "Hello, BStr!".as_bytes());

    ///

    /// let non_ascii = b_str!("🦀");

    /// let s = CString::try_from_fmt(fmt!("{}", non_ascii))?;

    /// let s = CString::try_from_fmt(fmt!("{non_ascii}"))?;

    /// assert_eq!(s.as_bytes(), "\\xf0\\x9f\\xa6\\x80".as_bytes());

    /// # Ok::<(), kernel::error::Error>(())

    /// ```
@@ -85,14 +85,14 @@ impl fmt::Debug for BStr { 
    /// escaping the rest.

    ///

    /// ```

    /// # use kernel::{fmt, b_str, str::{BStr, CString}};

    /// # use kernel::{prelude::fmt, b_str, str::{BStr, CString}};

    /// // Embedded double quotes are escaped.

    /// let ascii = b_str!("Hello, \"BStr\"!");

    /// let s = CString::try_from_fmt(fmt!("{:?}", ascii))?;

    /// let s = CString::try_from_fmt(fmt!("{ascii:?}"))?;

    /// assert_eq!(s.as_bytes(), "\"Hello, \\\"BStr\\\"!\"".as_bytes());

    ///

    /// let non_ascii = b_str!("😺");

    /// let s = CString::try_from_fmt(fmt!("{:?}", non_ascii))?;

    /// let s = CString::try_from_fmt(fmt!("{non_ascii:?}"))?;

    /// assert_eq!(s.as_bytes(), "\"\\xf0\\x9f\\x98\\xba\"".as_bytes());

    /// # Ok::<(), kernel::error::Error>(())

    /// ```
@@ -429,15 +429,15 @@ impl fmt::Display for CStr { 
    ///

    /// ```

    /// # use kernel::c_str;

    /// # use kernel::fmt;

    /// # use kernel::prelude::fmt;

    /// # use kernel::str::CStr;

    /// # use kernel::str::CString;

    /// let penguin = c_str!("🐧");

    /// let s = CString::try_from_fmt(fmt!("{}", penguin))?;

    /// let s = CString::try_from_fmt(fmt!("{penguin}"))?;

    /// assert_eq!(s.as_bytes_with_nul(), "\\xf0\\x9f\\x90\\xa7\0".as_bytes());

    ///

    /// let ascii = c_str!("so \"cool\"");

    /// let s = CString::try_from_fmt(fmt!("{}", ascii))?;

    /// let s = CString::try_from_fmt(fmt!("{ascii}"))?;

    /// assert_eq!(s.as_bytes_with_nul(), "so \"cool\"\0".as_bytes());

    /// # Ok::<(), kernel::error::Error>(())

    /// ```
@@ -459,16 +459,16 @@ impl fmt::Debug for CStr { 
    ///

    /// ```

    /// # use kernel::c_str;

    /// # use kernel::fmt;

    /// # use kernel::prelude::fmt;

    /// # use kernel::str::CStr;

    /// # use kernel::str::CString;

    /// let penguin = c_str!("🐧");

    /// let s = CString::try_from_fmt(fmt!("{:?}", penguin))?;

    /// let s = CString::try_from_fmt(fmt!("{penguin:?}"))?;

    /// assert_eq!(s.as_bytes_with_nul(), "\"\\xf0\\x9f\\x90\\xa7\"\0".as_bytes());

    ///

    /// // Embedded double quotes are escaped.

    /// let ascii = c_str!("so \"cool\"");

    /// let s = CString::try_from_fmt(fmt!("{:?}", ascii))?;

    /// let s = CString::try_from_fmt(fmt!("{ascii:?}"))?;

    /// assert_eq!(s.as_bytes_with_nul(), "\"so \\\"cool\\\"\"\0".as_bytes());

    /// # Ok::<(), kernel::error::Error>(())

    /// ```
@@ -578,7 +578,7 @@ mod tests { 


    macro_rules! format {

        ($($f:tt)*) => ({

            CString::try_from_fmt(::kernel::fmt!($($f)*))?.to_str()?

            CString::try_from_fmt(fmt!($($f)*))?.to_str()?

        })

    }
@@ -840,7 +840,7 @@ fn write_str(&mut self, s: &str) -> fmt::Result { 
/// # Examples

///

/// ```

/// use kernel::{str::CString, fmt};

/// use kernel::{str::CString, prelude::fmt};

///

/// let s = CString::try_from_fmt(fmt!("{}{}{}", "abc", 10, 20))?;

/// assert_eq!(s.as_bytes_with_nul(), "abc1020\0".as_bytes());
@@ -930,9 +930,3 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 
        fmt::Debug::fmt(&**self, f)

    }

}
 


/// A convenience alias for [`core::format_args`].

#[macro_export]

macro_rules! fmt {

    ($($f:tt)*) => ( ::core::format_args!($($f)*) )

}