mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
synced 2025-12-27 12:21:22 -05:00
f74cf399e0
Rust native atomics are not allowed to use in kernel due to the mismatch of memory model with Linux kernel memory model, hence remove the usage of Rust native atomics in debufs. Reviewed-by: Matthew Maurer <mmaurer@google.com> Acked-by: Danilo Krummrich <dakr@kernel.org> Tested-by: David Gow <davidgow@google.com> Acked-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> Signed-off-by: Boqun Feng <boqun.feng@gmail.com> Link: https://patch.msgid.link/20251022035324.70785-4-boqun.feng@gmail.com
84 lines
2.7 KiB
Rust
84 lines
2.7 KiB
Rust
// SPDX-License-Identifier: GPL-2.0
|
|
// Copyright (C) 2025 Google LLC.
|
|
|
|
//! Traits for rendering or updating values exported to DebugFS.
|
|
|
|
use crate::prelude::*;
|
|
use crate::sync::atomic::{Atomic, AtomicBasicOps, AtomicType, Relaxed};
|
|
use crate::sync::Mutex;
|
|
use crate::uaccess::UserSliceReader;
|
|
use core::fmt::{self, Debug, Formatter};
|
|
use core::str::FromStr;
|
|
|
|
/// A trait for types that can be written into a string.
|
|
///
|
|
/// This works very similarly to `Debug`, and is automatically implemented if `Debug` is
|
|
/// implemented for a type. It is also implemented for any writable type inside a `Mutex`.
|
|
///
|
|
/// The derived implementation of `Debug` [may
|
|
/// change](https://doc.rust-lang.org/std/fmt/trait.Debug.html#stability)
|
|
/// between Rust versions, so if stability is key for your use case, please implement `Writer`
|
|
/// explicitly instead.
|
|
pub trait Writer {
|
|
/// Formats the value using the given formatter.
|
|
fn write(&self, f: &mut Formatter<'_>) -> fmt::Result;
|
|
}
|
|
|
|
impl<T: Writer> Writer for Mutex<T> {
|
|
fn write(&self, f: &mut Formatter<'_>) -> fmt::Result {
|
|
self.lock().write(f)
|
|
}
|
|
}
|
|
|
|
impl<T: Debug> Writer for T {
|
|
fn write(&self, f: &mut Formatter<'_>) -> fmt::Result {
|
|
writeln!(f, "{self:?}")
|
|
}
|
|
}
|
|
|
|
/// A trait for types that can be updated from a user slice.
|
|
///
|
|
/// This works similarly to `FromStr`, but operates on a `UserSliceReader` rather than a &str.
|
|
///
|
|
/// It is automatically implemented for all atomic integers, or any type that implements `FromStr`
|
|
/// wrapped in a `Mutex`.
|
|
pub trait Reader {
|
|
/// Updates the value from the given user slice.
|
|
fn read_from_slice(&self, reader: &mut UserSliceReader) -> Result;
|
|
}
|
|
|
|
impl<T: FromStr + Unpin> Reader for Mutex<T> {
|
|
fn read_from_slice(&self, reader: &mut UserSliceReader) -> Result {
|
|
let mut buf = [0u8; 128];
|
|
if reader.len() > buf.len() {
|
|
return Err(EINVAL);
|
|
}
|
|
let n = reader.len();
|
|
reader.read_slice(&mut buf[..n])?;
|
|
|
|
let s = core::str::from_utf8(&buf[..n]).map_err(|_| EINVAL)?;
|
|
let val = s.trim().parse::<T>().map_err(|_| EINVAL)?;
|
|
*self.lock() = val;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl<T: AtomicType + FromStr> Reader for Atomic<T>
|
|
where
|
|
T::Repr: AtomicBasicOps,
|
|
{
|
|
fn read_from_slice(&self, reader: &mut UserSliceReader) -> Result {
|
|
let mut buf = [0u8; 21]; // Enough for a 64-bit number.
|
|
if reader.len() > buf.len() {
|
|
return Err(EINVAL);
|
|
}
|
|
let n = reader.len();
|
|
reader.read_slice(&mut buf[..n])?;
|
|
|
|
let s = core::str::from_utf8(&buf[..n]).map_err(|_| EINVAL)?;
|
|
let val = s.trim().parse::<T>().map_err(|_| EINVAL)?;
|
|
self.store(val, Relaxed);
|
|
Ok(())
|
|
}
|
|
}
|