rust: driver,of: Support passing ID tables to modpost for alias generation

In order for modpost to work and correctly generate module aliases from
device ID tables, it needs those tables to exist as global symbols with
a specific name. Additionally, modpost checks the size of the symbol, so
it cannot contain trailing data.

To support this, split IdArrayIds out of IdArray. The former contains
just the IDs. Then split out the device table definition macro from the
macro that defines the device table for a given bus driver, and add
another macro to declare a device table as a module device table.
Drivers can now define their ID table once, and then specify that it
should be used for both the driver and the module:

// Generic OF Device ID table.
kernel::define_of_id_table! {ASAHI_ID_TABLE, &'static hw::HwConfig, [
    (of::DeviceId::Compatible(b"apple,agx-t8103"), Some(&hw::t8103::HWCONFIG)),
    (of::DeviceId::Compatible(b"apple,agx-t8112"), Some(&hw::t8112::HWCONFIG)),
    // ...
]}

/// Platform Driver implementation for `AsahiDriver`.
impl platform::Driver for AsahiDriver {
    /// Data associated with each hardware ID.
    type IdInfo = &'static hw::HwConfig;

    // Assign the above OF ID table to this driver.
    kernel::driver_of_id_table!(ASAHI_ID_TABLE);

    // ...
}

// Export the OF ID table as a module ID table, to make modpost/autoloading work.
kernel::module_of_id_table!(MOD_TABLE, ASAHI_ID_TABLE);

Signed-off-by: Asahi Lina <[email protected]>
(cherry picked from commit 9d4f135)
Signed-off-by: Fabien Parent <[email protected]>

Author: asahilina

rust/kernel/driver.rs

@@ -140,11 +140,20 @@ pub unsafe trait RawDeviceId {
     fn to_rawid(&self, offset: isize) -> Self::RawType;
 }
 
-/// A zero-terminated device id array, followed by context data.
+/// A zero-terminated device id array.
+#[derive(Copy, Clone)]
 #[repr(C)]
-pub struct IdArray<T: RawDeviceId, U, const N: usize> {
+pub struct IdArrayIds<T: RawDeviceId, const N: usize> {
     ids: [T::RawType; N],
     sentinel: T::RawType,
+}
+
+unsafe impl<T: RawDeviceId, const N: usize> Sync for IdArrayIds<T, N> {}
+
+/// A zero-terminated device id array, followed by context data.
+#[repr(C)]
+pub struct IdArray<T: RawDeviceId, U, const N: usize> {
+    ids: IdArrayIds<T, N>,
     id_infos: [Option<U>; N],
 }
 
@@ -155,10 +164,13 @@ impl<T: RawDeviceId, U, const N: usize> IdArray<T, U, N> {
     pub const fn new(ids: [T; N], infos: [Option<U>; N]) -> Self
     where
         T: ~const RawDeviceId + Copy,
+        T::RawType: Copy + Clone,
     {
         let mut array = Self {
-            ids: [T::ZERO; N],
-            sentinel: T::ZERO,
+            ids: IdArrayIds {
+                ids: [T::ZERO; N],
+                sentinel: T::ZERO,
+            },
             id_infos: infos,
         };
         let mut i = 0usize;
@@ -168,9 +180,9 @@ impl<T: RawDeviceId, U, const N: usize> IdArray<T, U, N> {
             // so the pointers are necessarily 1-byte aligned.
             let offset = unsafe {
                 (&array.id_infos[i] as *const _ as *const u8)
-                    .offset_from(&array.ids[i] as *const _ as _)
+                    .offset_from(&array.ids.ids[i] as *const _ as _)
             };
-            array.ids[i] = ids[i].to_rawid(offset);
+            array.ids.ids[i] = ids[i].to_rawid(offset);
             i += 1;
         }
         array
@@ -181,10 +193,23 @@ impl<T: RawDeviceId, U, const N: usize> IdArray<T, U, N> {
     /// This is used to essentially erase the array size.
     pub const fn as_table(&self) -> IdTable<'_, T, U> {
         IdTable {
-            first: &self.ids[0],
+            first: &self.ids.ids[0],
             _p: PhantomData,
         }
     }
+
+    /// Returns the number of items in the ID table.
+    pub const fn count(&self) -> usize {
+        self.ids.ids.len()
+    }
+
+    /// Returns the inner IdArrayIds array, without the context data.
+    pub const fn as_ids(&self) -> IdArrayIds<T, N>
+    where
+        T: ~const RawDeviceId + Copy,
+    {
+        self.ids
+    }
 }
 
 /// A device id table.
@@ -331,6 +356,11 @@ macro_rules! second_item {
 /// define_id_array!(A6, Id, &'static [u8], [(Id(10), None), (Id(20), Some(b"id2")), ]);
 /// define_id_array!(A7, Id, &'static [u8], [(Id(10), Some(b"id1")), (Id(20), None), ]);
 /// define_id_array!(A8, Id, &'static [u8], [(Id(10), None), (Id(20), None), ]);
+///
+/// // Within a bus driver:
+/// driver_id_table!(BUS_ID_TABLE, Id, &'static [u8], A1);
+/// // At the top level:
+/// module_id_table!(MODULE_ID_TABLE, "mybus", Id, A1);
 /// ```
 #[macro_export]
 macro_rules! define_id_array {
@@ -342,7 +372,7 @@ macro_rules! define_id_array {
     };
 }
 
-/// Defines a new constant [`IdTable`] with a concise syntax.
+/// Declares an [`IdArray`] as an [`IdTable`] for a bus driver with a concise syntax.
 ///
 /// It is meant to be used by buses and subsystems to create a similar macro with their device id
 /// type already specified, i.e., with fewer parameters to the end user.
@@ -352,36 +382,38 @@ macro_rules! define_id_array {
 // TODO: Exported but not usable by kernel modules (requires `const_trait_impl`).
 /// ```ignore
 /// #![feature(const_trait_impl)]
-/// # use kernel::{define_id_table, driver::RawDeviceId};
+/// # use kernel::{driver_id_table};
+
+/// driver_id_table!(BUS_ID_TABLE, Id, &'static [u8], MY_ID_ARRAY);
+/// ```
+#[macro_export]
+macro_rules! driver_id_table {
+    ($table_name:ident, $id_type:ty, $data_type:ty, $target:expr) => {
+        const $table_name: Option<$crate::driver::IdTable<'static, $id_type, $data_type>> =
+            Some($target.as_table());
+    };
+}
+
+/// Declares an [`IdArray`] as a module-level ID tablewith a concise syntax.
 ///
-/// #[derive(Copy, Clone)]
-/// struct Id(u32);
+/// It is meant to be used by buses and subsystems to create a similar macro with their device id
+/// type already specified, i.e., with fewer parameters to the end user.
 ///
-/// // SAFETY: `ZERO` is all zeroes and `to_rawid` stores `offset` as the second element of the raw
-/// // device id pair.
-/// unsafe impl const RawDeviceId for Id {
-///     type RawType = (u64, isize);
-///     const ZERO: Self::RawType = (0, 0);
-///     fn to_rawid(&self, offset: isize) -> Self::RawType {
-///         (self.0 as u64 + 1, offset)
-///     }
-/// }
+/// # Examples
 ///
-/// define_id_table!(T1, Id, &'static [u8], [(Id(10), None)]);
-/// define_id_table!(T2, Id, &'static [u8], [(Id(10), Some(b"id1")), ]);
-/// define_id_table!(T3, Id, &'static [u8], [(Id(10), Some(b"id1")), (Id(20), Some(b"id2"))]);
-/// define_id_table!(T4, Id, &'static [u8], [(Id(10), Some(b"id1")), (Id(20), Some(b"id2")), ]);
-/// define_id_table!(T5, Id, &'static [u8], [(Id(10), None), (Id(20), Some(b"id2")), ]);
-/// define_id_table!(T6, Id, &'static [u8], [(Id(10), Some(b"id1")), (Id(20), None), ]);
-/// define_id_table!(T7, Id, &'static [u8], [(Id(10), None), (Id(20), None), ]);
+// TODO: Exported but not usable by kernel modules (requires `const_trait_impl`).
+/// ```ignore
+/// #![feature(const_trait_impl)]
+/// # use kernel::{driver_id_table};
+
+/// driver_id_table!(BUS_ID_TABLE, Id, &'static [u8], MY_ID_ARRAY);
 /// ```
 #[macro_export]
-macro_rules! define_id_table {
-    ($table_name:ident, $id_type:ty, $data_type:ty, [ $($t:tt)* ]) => {
-        const $table_name: Option<$crate::driver::IdTable<'static, $id_type, $data_type>> = {
-            $crate::define_id_array!(ARRAY, $id_type, $data_type, [ $($t)* ]);
-            Some(ARRAY.as_table())
-        };
+macro_rules! module_id_table {
+    ($item_name:ident, $table_type:literal, $id_type:ty, $table_name:ident) => {
+        #[export_name = concat!("__mod_", $table_type, "__", stringify!($table_name), "_device_table")]
+        static $item_name: $crate::driver::IdArrayIds<$id_type, { $table_name.count() }> =
+            $table_name.as_ids();
     };
 }
 

rust/kernel/of.rs

@@ -15,24 +15,48 @@ pub enum DeviceId {
 
 /// Defines a const open firmware device id table that also carries per-entry data/context/info.
 ///
-/// The name of the const is `OF_DEVICE_ID_TABLE`, which is what buses are expected to name their
-/// open firmware tables.
-///
-/// # Examples
+/// # Example
 ///
 /// ```
-/// # use kernel::define_of_id_table;
+/// # use kernel::{define_of_id_table, module_of_id_table, driver_of_id_table};
 /// use kernel::of;
 ///
-/// define_of_id_table! {u32, [
+/// define_of_id_table! {MY_ID_TABLE, u32, [
 ///     (of::DeviceId::Compatible(b"test-device1,test-device2"), Some(0xff)),
 ///     (of::DeviceId::Compatible(b"test-device3"), None),
 /// ]};
+///
+/// module_of_id_table!(MOD_TABLE, ASAHI_ID_TABLE);
+///
+/// // Within the `Driver` implementation:
+/// driver_of_id_table!(MY_ID_TABLE);
 /// ```
 #[macro_export]
 macro_rules! define_of_id_table {
-    ($data_type:ty, $($t:tt)*) => {
-        $crate::define_id_table!(OF_DEVICE_ID_TABLE, $crate::of::DeviceId, $data_type, $($t)*);
+    ($name:ident, $data_type:ty, $($t:tt)*) => {
+        $crate::define_id_array!($name, $crate::of::DeviceId, $data_type, $($t)*);
+    };
+}
+
+/// Convenience macro to declare which device ID table to use for a bus driver.
+#[macro_export]
+macro_rules! driver_of_id_table {
+    ($name:expr) => {
+        $crate::driver_id_table!(
+            OF_DEVICE_ID_TABLE,
+            $crate::of::DeviceId,
+            Self::IdInfo,
+            $name
+        );
+    };
+}
+
+/// Declare a device ID table as a module-level table. This creates the necessary module alias
+/// entries to enable module autoloading.
+#[macro_export]
+macro_rules! module_of_id_table {
+    ($item_name:ident, $table_name:ident) => {
+        $crate::module_id_table!($item_name, "of", $crate::of::DeviceId, $table_name);
     };
 }