mirror of
https://kernel.googlesource.com/pub/scm/linux/kernel/git/stable/linux-stable.git
synced 2025-09-14 11:19:08 +10:00
8577c9dca7
Back when we used Rust 1.60.0 (before Rust was merged in the kernel), we added `-Wclippy::dbg_macro` to the compilation flags. This worked great with our custom `dbg!` macro (vendored from `std`, but slightly modified to use the kernel printing facilities). However, in the very next version, 1.61.0, it stopped working [1] since the lint started to use a Rust diagnostic item rather than a path to find the `dbg!` macro [1]. This behavior remains until the current nightly (1.83.0). Therefore, currently, the `dbg_macro` is not doing anything, which explains why we can invoke `dbg!` in samples/rust/rust_print.rs`, as well as why changing the `#[allow()]`s to `#[expect()]`s in `std_vendor.rs` doctests does not work since they are not fulfilled. One possible workaround is using `rustc_attrs` like the standard library does. However, this is intended to be internal, and we just started supporting several Rust compiler versions, so it is best to avoid it. Therefore, instead, use `disallowed_macros`. It is a stable lint and is more flexible (in that we can provide different macros), although its diagnostic message(s) are not as nice as the specialized one (yet), and does not allow to set different lint levels per macro/path [2]. In turn, this requires allowing the (intentional) `dbg!` use in the sample, as one would have expected. Finally, in a single case, the `allow` is fixed to be an inner attribute, since otherwise it was not being applied. Link: https://github.com/rust-lang/rust-clippy/issues/11303 [1] Link: https://github.com/rust-lang/rust-clippy/issues/11307 [2] Tested-by: Gary Guo <gary@garyguo.net> Reviewed-by: Gary Guo <gary@garyguo.net> Link: https://lore.kernel.org/r/20240904204347.168520-13-ojeda@kernel.org Signed-off-by: Miguel Ojeda <ojeda@kernel.org>
82 lines
2.3 KiB
Rust
82 lines
2.3 KiB
Rust
// SPDX-License-Identifier: GPL-2.0
|
|
|
|
//! Rust printing macros sample.
|
|
|
|
use kernel::pr_cont;
|
|
use kernel::prelude::*;
|
|
|
|
module! {
|
|
type: RustPrint,
|
|
name: "rust_print",
|
|
author: "Rust for Linux Contributors",
|
|
description: "Rust printing macros sample",
|
|
license: "GPL",
|
|
}
|
|
|
|
struct RustPrint;
|
|
|
|
#[allow(clippy::disallowed_macros)]
|
|
fn arc_print() -> Result {
|
|
use kernel::sync::*;
|
|
|
|
let a = Arc::new(1, GFP_KERNEL)?;
|
|
let b = UniqueArc::new("hello, world", GFP_KERNEL)?;
|
|
|
|
// Prints the value of data in `a`.
|
|
pr_info!("{}", a);
|
|
|
|
// Uses ":?" to print debug fmt of `b`.
|
|
pr_info!("{:?}", b);
|
|
|
|
let a: Arc<&str> = b.into();
|
|
let c = a.clone();
|
|
|
|
// Uses `dbg` to print, will move `c` (for temporary debugging purposes).
|
|
dbg!(c);
|
|
|
|
// Pretty-prints the debug formatting with lower-case hexadecimal integers.
|
|
pr_info!("{:#x?}", a);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
impl kernel::Module for RustPrint {
|
|
fn init(_module: &'static ThisModule) -> Result<Self> {
|
|
pr_info!("Rust printing macros sample (init)\n");
|
|
|
|
pr_emerg!("Emergency message (level 0) without args\n");
|
|
pr_alert!("Alert message (level 1) without args\n");
|
|
pr_crit!("Critical message (level 2) without args\n");
|
|
pr_err!("Error message (level 3) without args\n");
|
|
pr_warn!("Warning message (level 4) without args\n");
|
|
pr_notice!("Notice message (level 5) without args\n");
|
|
pr_info!("Info message (level 6) without args\n");
|
|
|
|
pr_info!("A line that");
|
|
pr_cont!(" is continued");
|
|
pr_cont!(" without args\n");
|
|
|
|
pr_emerg!("{} message (level {}) with args\n", "Emergency", 0);
|
|
pr_alert!("{} message (level {}) with args\n", "Alert", 1);
|
|
pr_crit!("{} message (level {}) with args\n", "Critical", 2);
|
|
pr_err!("{} message (level {}) with args\n", "Error", 3);
|
|
pr_warn!("{} message (level {}) with args\n", "Warning", 4);
|
|
pr_notice!("{} message (level {}) with args\n", "Notice", 5);
|
|
pr_info!("{} message (level {}) with args\n", "Info", 6);
|
|
|
|
pr_info!("A {} that", "line");
|
|
pr_cont!(" is {}", "continued");
|
|
pr_cont!(" with {}\n", "args");
|
|
|
|
arc_print()?;
|
|
|
|
Ok(RustPrint)
|
|
}
|
|
}
|
|
|
|
impl Drop for RustPrint {
|
|
fn drop(&mut self) {
|
|
pr_info!("Rust printing macros sample (exit)\n");
|
|
}
|
|
}
|