mirror of
https://github.com/torvalds/linux.git
synced 2025-10-31 00:28:52 +02:00
a5ba9ad417
Starting with Rust 1.91.0 (expected 2025-10-30), `rustdoc` has improved
some false negatives around intra-doc links [1], and it found a broken
intra-doc link we currently have:
error: unresolved link to `include/linux/device/faux.h`
--> rust/kernel/faux.rs:7:17
|
7 | //! C header: [`include/linux/device/faux.h`]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ no item named `include/linux/device/faux.h` in scope
|
= help: to escape `[` and `]` characters, add '\' before them like `\[` or `\]`
= note: `-D rustdoc::broken-intra-doc-links` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(rustdoc::broken_intra_doc_links)]`
Our `srctree/` C header links are not intra-doc links, thus they need
the link destination.
Thus fix it.
Cc: stable <stable@kernel.org>
Link: https://github.com/rust-lang/rust/pull/132748 [1]
Fixes: 78418f300d ("rust/kernel: Add faux device bindings")
Signed-off-by: Miguel Ojeda <ojeda@kernel.org>
Reviewed-by: Benno Lossin <lossin@kernel.org>
Reviewed-by: Alice Ryhl <aliceryhl@google.com>
Link: https://lore.kernel.org/r/20250804171311.1186538-1-ojeda@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
77 lines
3 KiB
Rust
77 lines
3 KiB
Rust
// SPDX-License-Identifier: GPL-2.0-only
|
|
|
|
//! Abstractions for the faux bus.
|
|
//!
|
|
//! This module provides bindings for working with faux devices in kernel modules.
|
|
//!
|
|
//! C header: [`include/linux/device/faux.h`](srctree/include/linux/device/faux.h)
|
|
|
|
use crate::{bindings, device, error::code::*, prelude::*};
|
|
use core::ptr::{addr_of_mut, null, null_mut, NonNull};
|
|
|
|
/// The registration of a faux device.
|
|
///
|
|
/// This type represents the registration of a [`struct faux_device`]. When an instance of this type
|
|
/// is dropped, its respective faux device will be unregistered from the system.
|
|
///
|
|
/// # Invariants
|
|
///
|
|
/// `self.0` always holds a valid pointer to an initialized and registered [`struct faux_device`].
|
|
///
|
|
/// [`struct faux_device`]: srctree/include/linux/device/faux.h
|
|
pub struct Registration(NonNull<bindings::faux_device>);
|
|
|
|
impl Registration {
|
|
/// Create and register a new faux device with the given name.
|
|
#[inline]
|
|
pub fn new(name: &CStr, parent: Option<&device::Device>) -> Result<Self> {
|
|
// SAFETY:
|
|
// - `name` is copied by this function into its own storage
|
|
// - `faux_ops` is safe to leave NULL according to the C API
|
|
// - `parent` can be either NULL or a pointer to a `struct device`, and `faux_device_create`
|
|
// will take a reference to `parent` using `device_add` - ensuring that it remains valid
|
|
// for the lifetime of the faux device.
|
|
let dev = unsafe {
|
|
bindings::faux_device_create(
|
|
name.as_char_ptr(),
|
|
parent.map_or(null_mut(), |p| p.as_raw()),
|
|
null(),
|
|
)
|
|
};
|
|
|
|
// The above function will return either a valid device, or NULL on failure
|
|
// INVARIANT: The device will remain registered until faux_device_destroy() is called, which
|
|
// happens in our Drop implementation.
|
|
Ok(Self(NonNull::new(dev).ok_or(ENODEV)?))
|
|
}
|
|
|
|
fn as_raw(&self) -> *mut bindings::faux_device {
|
|
self.0.as_ptr()
|
|
}
|
|
}
|
|
|
|
impl AsRef<device::Device> for Registration {
|
|
fn as_ref(&self) -> &device::Device {
|
|
// SAFETY: The underlying `device` in `faux_device` is guaranteed by the C API to be
|
|
// a valid initialized `device`.
|
|
unsafe { device::Device::from_raw(addr_of_mut!((*self.as_raw()).dev)) }
|
|
}
|
|
}
|
|
|
|
impl Drop for Registration {
|
|
#[inline]
|
|
fn drop(&mut self) {
|
|
// SAFETY: `self.0` is a valid registered faux_device via our type invariants.
|
|
unsafe { bindings::faux_device_destroy(self.as_raw()) }
|
|
}
|
|
}
|
|
|
|
// SAFETY: The faux device API is thread-safe as guaranteed by the device core, as long as
|
|
// faux_device_destroy() is guaranteed to only be called once - which is guaranteed by our type not
|
|
// having Copy/Clone.
|
|
unsafe impl Send for Registration {}
|
|
|
|
// SAFETY: The faux device API is thread-safe as guaranteed by the device core, as long as
|
|
// faux_device_destroy() is guaranteed to only be called once - which is guaranteed by our type not
|
|
// having Copy/Clone.
|
|
unsafe impl Sync for Registration {}
|