| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-ID: <20250819-qcom-socinfo-v1-1-e8d32cc81270@google.com>
Date: Tue, 19 Aug 2025 23:12:32 +0000
From: Matthew Maurer <mmaurer@...gle.com>
To: Miguel Ojeda <ojeda@...nel.org>, Alex Gaynor <alex.gaynor@...il.com>,
Boqun Feng <boqun.feng@...il.com>, Gary Guo <gary@...yguo.net>,
"Björn Roy Baron" <bjorn3_gh@...tonmail.com>, Andreas Hindborg <a.hindborg@...nel.org>,
Alice Ryhl <aliceryhl@...gle.com>, Trevor Gross <tmgross@...ch.edu>,
Danilo Krummrich <dakr@...nel.org>, Greg Kroah-Hartman <gregkh@...uxfoundation.org>,
"Rafael J. Wysocki" <rafael@...nel.org>, Sami Tolvanen <samitolvanen@...gle.com>,
Timur Tabi <ttabi@...dia.com>, Benno Lossin <lossin@...nel.org>,
Dirk Beheme <dirk.behme@...bosch.com>
Cc: linux-kernel@...r.kernel.org, rust-for-linux@...r.kernel.org,
Matthew Maurer <mmaurer@...gle.com>
Subject: [PATCH WIP 1/5] rust: Add soc_device support
Adds the ability to register SoC devices.
(This will be sent upstream in a separate request, it's uploaded now as
a dependency of the example driver.)
Signed-off-by: Matthew Maurer <mmaurer@...gle.com>
---
MAINTAINERS | 1 +
rust/bindings/bindings_helper.h | 1 +
rust/kernel/lib.rs | 2 +
rust/kernel/soc.rs | 137 ++++++++++++++++++++++++++++++++++++++++
4 files changed, 141 insertions(+)
diff --git a/MAINTAINERS b/MAINTAINERS
index 2cbe890085dbb6a652623b38dd0eadeeaa127a94..e0ff2731f1c2ae4bb01d361e99c1f4517fbd45d5 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -7481,6 +7481,7 @@ F: rust/kernel/devres.rs
F: rust/kernel/driver.rs
F: rust/kernel/faux.rs
F: rust/kernel/platform.rs
+F: rust/kernel/soc.rs
F: samples/rust/rust_debugfs.rs
F: samples/rust/rust_scoped_debugfs.rs
F: samples/rust/rust_driver_platform.rs
diff --git a/rust/bindings/bindings_helper.h b/rust/bindings/bindings_helper.h
index e847820dc807fdda2d682d496a3c6361bb944c10..140e2f4e60c0b745ac5d5c7456d60af28e21f55a 100644
--- a/rust/bindings/bindings_helper.h
+++ b/rust/bindings/bindings_helper.h
@@ -72,6 +72,7 @@
#include <linux/sched.h>
#include <linux/security.h>
#include <linux/slab.h>
+#include <linux/sys_soc.h>
#include <linux/tracepoint.h>
#include <linux/wait.h>
#include <linux/workqueue.h>
diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs
index 828620c8441566a638f31d03633fc1bf4c1bda85..045f1088938cf646519edea2102439402fb27660 100644
--- a/rust/kernel/lib.rs
+++ b/rust/kernel/lib.rs
@@ -117,6 +117,8 @@
pub mod security;
pub mod seq_file;
pub mod sizes;
+#[cfg(CONFIG_SOC_BUS)]
+pub mod soc;
mod static_assert;
#[doc(hidden)]
pub mod std_vendor;
diff --git a/rust/kernel/soc.rs b/rust/kernel/soc.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b8412751a5ca8839e588cf5bd52f2e6a7f33d457
--- /dev/null
+++ b/rust/kernel/soc.rs
@@ -0,0 +1,137 @@
+// SPDX-License-Identifier: GPL-2.0
+
+// Copyright (C) 2025 Google LLC.
+
+//! SoC Driver Abstraction
+//!
+//! C header: [`include/linux/sys_soc.h`](srctree/include/linux/sys_soc.h)
+
+use crate::bindings;
+use crate::error;
+use crate::prelude::*;
+use crate::str::CString;
+use core::marker::PhantomPinned;
+use core::ptr::addr_of;
+
+/// Attributes for a SoC device
+pub struct DeviceAttribute {
+ /// Machine
+ pub machine: Option<CString>,
+ /// Family
+ pub family: Option<CString>,
+ /// Revision
+ pub revision: Option<CString>,
+ /// Serial Number
+ pub serial_number: Option<CString>,
+ /// SoC ID
+ pub soc_id: Option<CString>,
+}
+
+// SAFETY: We provide no operations through `&BuiltDeviceAttribute`
+unsafe impl Sync for BuiltDeviceAttribute {}
+
+// SAFETY: All pointers are normal allocations, not thread-specific
+unsafe impl Send for BuiltDeviceAttribute {}
+
+#[pin_data]
+struct BuiltDeviceAttribute {
+ #[pin]
+ backing: DeviceAttribute,
+ inner: bindings::soc_device_attribute,
+ // Since `inner` has pointers to `backing`, we are !Unpin
+ #[pin]
+ _pin: PhantomPinned,
+}
+
+fn cstring_to_c(mcs: &Option<CString>) -> *const kernel::ffi::c_char {
+ mcs.as_ref()
+ .map(|cs| cs.as_char_ptr())
+ .unwrap_or(core::ptr::null())
+}
+
+impl BuiltDeviceAttribute {
+ fn as_mut_ptr(&self) -> *mut bindings::soc_device_attribute {
+ core::ptr::from_ref(&self.inner).cast_mut()
+ }
+}
+
+impl DeviceAttribute {
+ fn build(self) -> impl PinInit<BuiltDeviceAttribute> {
+ pin_init!(BuiltDeviceAttribute {
+ inner: bindings::soc_device_attribute {
+ machine: cstring_to_c(&self.machine),
+ family: cstring_to_c(&self.family),
+ revision: cstring_to_c(&self.revision),
+ serial_number: cstring_to_c(&self.serial_number),
+ soc_id: cstring_to_c(&self.soc_id),
+ data: core::ptr::null(),
+ custom_attr_group: core::ptr::null(),
+ },
+ backing: self,
+ _pin: PhantomPinned,
+ })
+ }
+}
+
+// SAFETY: We provide no operations through &Device
+unsafe impl Sync for Device {}
+
+// SAFETY: Device holds a pointer to a `soc_device`, which may be sent to any thread.
+unsafe impl Send for Device {}
+
+/// A registered soc device
+#[repr(transparent)]
+pub struct Device(*mut bindings::soc_device);
+
+impl Device {
+ /// # Safety
+ /// * `attr` must be pinned
+ /// * `attr` must be valid for reads during the function call
+ /// * If a device is returned (e.g. no error), `attr` must remain valid for reads until the
+ /// returned `Device` is dropped.
+ unsafe fn register(attr: *const BuiltDeviceAttribute) -> Result<Device> {
+ let raw_soc =
+ // SAFETY: The struct provided through attr is backed by pinned data next to it, so as
+ // long as attr lives, the strings pointed to by the struct will too. By caller
+ // invariant, `attr` is pinned, so the pinned data won't move. By caller invariant,
+ // `attr` is valid during this call. If it returns a device, and so others may try to
+ // read this data, by caller invariant, `attr` won't be released until the device is.
+ error::from_err_ptr(unsafe { bindings::soc_device_register((*attr).as_mut_ptr()) })?;
+ Ok(Device(raw_soc))
+ }
+}
+
+#[pin_data(PinnedDrop)]
+/// Registration handle for your soc_dev. If you let it go out of scope, your soc_dev will be
+/// unregistered.
+pub struct DeviceRegistration {
+ #[pin]
+ attr: BuiltDeviceAttribute,
+ soc_dev: Device,
+ // Since Device transitively points to the contents of attr, we are !Unpin
+ #[pin]
+ _pin: PhantomPinned,
+}
+
+#[pinned_drop]
+impl PinnedDrop for DeviceRegistration {
+ fn drop(self: Pin<&mut Self>) {
+ // SAFETY: Device always contains a live pointer to a soc_device that can be unregistered
+ unsafe { bindings::soc_device_unregister(self.soc_dev.0) }
+ }
+}
+
+impl DeviceRegistration {
+ /// Register a new SoC device
+ pub fn register(attr: DeviceAttribute) -> impl PinInit<Self, Error> {
+ try_pin_init!(&this in Self {
+ attr <- attr.build(),
+ // SAFETY: We have already initialized attr, and we are inside PinInit and Self
+ // is !Unpin, so attr won't be moved and is valid. If it returns success, attr
+ // will not be dropped until after our `PinnedDrop` implementation runs, so the
+ // device will be unregistered first.
+ soc_dev: unsafe { Device::register(addr_of!((*this.as_ptr()).attr))? },
+ _pin: PhantomPinned,
+ }? Error)
+ }
+}
--
2.51.0.rc1.167.g924127e9c0-goog
Powered by blists - more mailing lists