Re: [net-next PATCH v10 7/7] rust: net::phy sync with match_phy_device C changes

From
Benno Lossin <lossin@kernel.org>
Date
2025-05-17 08:06:20
Also in
linux-devicetree, lkml, rust-for-linux
Reply to
FUJITA Tomonori, 2025-05-17
On Sat May 17, 2025 at 8:27 AM CEST, FUJITA Tomonori wrote:
On Fri, 16 May 2025 22:16:23 +0200
"Benno Lossin" [off-list ref] wrote:
quoted
On Fri May 16, 2025 at 5:12 PM CEST, Christian Marangi wrote:
quoted
On Fri, May 16, 2025 at 04:48:53PM +0200, Benno Lossin wrote:
quoted
On Fri May 16, 2025 at 2:30 PM CEST, FUJITA Tomonori wrote:
quoted
On Thu, 15 May 2025 13:27:12 +0200
Christian Marangi [off-list ref] wrote:
quoted
@@ -574,6 +577,23 @@ pub const fn create_phy_driver<T: Driver>() -> DriverVTable {
 /// This trait is used to create a [`DriverVTable`].
 #[vtable]
 pub trait Driver {
+    /// # Safety
+    ///
+    /// For the duration of `'a`,
+    /// - the pointer must point at a valid `phy_driver`, and the caller
+    ///   must be in a context where all methods defined on this struct
+    ///   are safe to call.
+    unsafe fn from_raw<'a>(ptr: *const bindings::phy_driver) -> &'a Self
+    where
+        Self: Sized,
+    {
+        // CAST: `Self` is a `repr(transparent)` wrapper around `bindings::phy_driver`.
+        let ptr = ptr.cast::<Self>();
+        // SAFETY: by the function requirements the pointer is valid and we have unique access for
+        // the duration of `'a`.
+        unsafe { &*ptr }
+    }
We might need to update the comment. phy_driver is const so I think
that we can access to it any time.
Why is any type implementing `Driver` a transparent wrapper around
`bindings::phy_driver`?
Is this referred to a problem with using from_raw or more of a general
question on how the rust wrapper are done for phy code?
I looked at the `phy.rs` file again and now I'm pretty sure the above
code is wrong. `Self` can be implemented on any type (even types like
`Infallible` that do not have any valid bit patterns, since it's an
empty enum). The abstraction for `bindings::phy_driver` is
`DriverVTable` not an object of type `Self`, so you should cast to that
pointer instead.
Yeah.

I don't want to delay this patchset due to Rust side changes so
casting a pointer to bindings::phy_driver to DriverVTable is ok but
the following signature doesn't look useful for Rust phy drivers:

fn match_phy_device(_dev: &mut Device, _drv: &DriverVTable) -> bool

struct DriverVTable is only used to create an array of
bindings::phy_driver for C side, and it doesn't provide any
information to the Rust driver.
Yeah, but we could add accessor functions that provide that information.
Although that doesn't really make sense at the moment, see below.
In match_phy_device(), for example, a device driver accesses to
PHY_DEVICE_ID, which the Driver trait provides. I think we need to
create an instance of the device driver's own type that implements the
Driver trait and make it accessible.
I think that's wrong, nothing stops me from implementing `Driver` for an
empty enum and that can't be instantiated. The reason that one wants to
have this in C is because the same `match` function is used for
different drivers (or maybe devices? I'm not too familiar with the
terminology). In Rust, you must implement the match function for a
single PHY_DEVICE_ID only, so maybe we don't need to change the
signature at all?

---
Cheers,
Benno
Thread (28 messages) 28 messages, 4 authors, last reply 2025-05-19
Keyboard shortcuts
hback out one level
jnext message in thread / next series-diff position
kprevious message in thread / previous series-diff position
ldrill in
Escclose help / fold thread tree
?toggle this help