rust, nova-core: add SizeConstants trait for SZ_* constants
Subsystems (7)
v5 cover rust, nova-core: add SizeConstants trait for SZ_* constants
Changes in v5:
* Changed the subject line of this cover letter to not use the old DeviceSize name.
* Collected Reviewed-by tags from Alexandre Courbot and Joel Fernandes, and Acked-by from Gary Guo.
* Added a new patch 3/3 with a todo.rst entry for device address type wrappers and a marker trait, as discussed with Danilo.
* Rebased onto latest drm-rust-next.
Changes in v4:
* Renamed the trait from DeviceSize to SizeConstants.
* Added backticks and trailing periods to all hex-value doc comments on the SZ_* constants.
* Removed redundant type annotations from doc-test examples.
* Used a use import for PAGE_SIZE in the module-level doc-test instead of a fully qualified path.
* Rewrote doc-test comments to clarify the distinction between module-level constants (no type qualifier) and trait associated constants (type qualifier required).
* Added Reviewed-by from Eliot Courtney.
Changes in v3:
* Dropped the Alignment::from_u64() patch.
* Reworked define_sizes! macro to accept target types as arguments (define_sizes!(u32, u64, usize)) using recursive macro arms, instead of hardcoding impls for u32 and u64. Overflow checking uses u128 casts so the same assert works for any ("reasonable") target type.
* Added usize to the DeviceSize implementations, so the trait
covers u32, u64, and usize.
* Hex values for each constant are now proper doc-comments (forwarded via macro meta), instead of inline comments.
* Rebased onto latest drm-rust-next.
Changes in v2:
* Replaced flat SZ_*_U64 constants with a DeviceSize trait that provides SZ_* as associated constants on u32 and u64.
* A define_sizes! macro generates everything from one list of names.
* Added Alignment::from_u64() so alignment values can be constructed from DeviceSize constants without falling back to usize variants.
* Rebased onto drm-rust-next. No longer depends on the Blackwell patchset.
v1 is here:
https://lore.kernel.org/[email protected]
John Hubbard (3):
rust: sizes: add SizeConstants trait for device address space
constants
gpu: nova-core: use SizeConstants trait for u64 size constants
gpu: nova-core: add task for device address type wrappers
Documentation/gpu/nova/core/todo.rst | 13 +++ drivers/gpu/nova-core/fb.rs | 21 ++-- drivers/gpu/nova-core/gsp/fw.rs | 15 ++- drivers/gpu/nova-core/regs.rs | 7 +- rust/kernel/sizes.rs | 167 ++++++++++++++++++++------- 5 files changed, 155 insertions(+), 68 deletions(-)
base-commit: 7c50d748b4a635bc39802ea3f6b120e66b1b9067
Signature · 1 line
2.53.0
PATCH v5 1/3 rust: sizes: add SizeConstants trait for device address space constants
The SZ_* constants are usize, matching the CPU pointer width. But device address spaces have their own widths (32-bit MMIO windows, 64-bit GPU framebuffers, etc.), so drivers end up casting these constants with SZ_1M as u64 or helper functions. This adds boilerplate with no safety benefit.
Add a SizeConstants trait with associated SZ_* constants, implemented for u32, u64, and usize. With the trait in scope, callers write u64::SZ_1M or u32::SZ_4K to get the constant in their device's native width. All SZ_* values fit in a u32, so every implementation is lossless. Each impl has a const assert to catch any future constant that would overflow.
A define_sizes! macro generates everything from a single internal list of names. The macro takes the target types as arguments, so adding a new target type requires changing only the call site.
--- rust/kernel/sizes.rs | 167 +++++++++++++++++++++++++++++++------------ 1 file changed, 123 insertions(+), 44 deletions(-)
rust/kernel/sizes.rs +123 -44
@@ -3,48 +3,127 @@//! Commonly used sizes. //! //! C headers: [`include/linux/sizes.h`](srctree/include/linux/sizes.h). +//! +//! The top-level `SZ_*` constants are [`usize`]-typed, for use in kernel page +//! arithmetic and similar CPU-side work. +//! +//! The [`SizeConstants`] trait provides the same constants as associated constants +//! on [`u32`], [`u64`], and [`usize`], for use in device address spaces where +//! the address width depends on the hardware. Device drivers frequently need +//! these constants as [`u64`] (or [`u32`]) rather than [`usize`], because +//! device address spaces are sized independently of the CPU pointer width. +//! +//! # Examples +//! +//! ``` +//! use kernel::page::PAGE_SIZE; +//! use kernel::sizes::{SizeConstants, SZ_1M}; +//! +//! // Module-level constants continue to work without a type qualifier. +//! let num_pages_in_1m = SZ_1M / PAGE_SIZE; +//! +//! // Trait associated constants require a type qualifier. +//! let heap_size = 14 * u64::SZ_1M; +//! let small = u32::SZ_4K; +//! ``` + +macro_rules! define_sizes { + ($($type:ty),* $(,)?) => { +define_sizes! (@internal [$($type ),*] +/// `0x0000_0400`. +SZ_1K , +/// `0x0000_0800`. +SZ_2K , +/// `0x0000_1000`. +SZ_4K , +/// `0x0000_2000`. +SZ_8K , +/// `0x0000_4000`. +SZ_16K , +/// `0x0000_8000`. +SZ_32K , +/// `0x0001_0000`. +SZ_64K , +/// `0x0002_0000`. +SZ_128K , +/// `0x0004_0000`. +SZ_256K , +/// `0x0008_0000`. +SZ_512K , +/// `0x0010_0000`. +SZ_1M , +/// `0x0020_0000`. +SZ_2M , +/// `0x0040_0000`. +SZ_4M , +/// `0x0080_0000`. +SZ_8M , +/// `0x0100_0000`. +SZ_16M , +/// `0x0200_0000`. +SZ_32M , +/// `0x0400_0000`. +SZ_64M , +/// `0x0800_0000`. +SZ_128M , +/// `0x1000_0000`. +SZ_256M , +/// `0x2000_0000`. +SZ_512M , +/// `0x4000_0000`. +SZ_1G , +/// `0x8000_0000`. +SZ_2G , + ); + }; + + (@internal [$($type:ty),*] $($names_and_metas:tt)*) => { +define_sizes! (@consts_and_trait $($names_and_metas)*); +define_sizes! (@impls [$($type ),*] $($names_and_metas)*); + }; + + (@consts_and_trait $($(#[$meta:meta])* $name:ident,)*) => { + $( + $(#[$meta] )* +pub const $name:usize = bindings::$nameas usize ; + )* + +/// Size constants for device address spaces. +/// +/// Implemented for [`u32`], [`u64`], and [`usize`] so drivers can +/// choose the width that matches their hardware. All `SZ_*` values fit +/// in a [`u32`], so all implementations are lossless. +/// +/// # Examples +/// +/// ``` +/// use kernel::sizes::SizeConstants; +/// +/// let gpu_heap = 14 * u64::SZ_1M; +/// let mmio_window = u32::SZ_16M; +/// ``` +pub trait SizeConstants { + $( + $(#[$meta] )* +const $name:Self ; + )* + } + }; + + (@impls [] $($(#[$meta:meta])* $name:ident,)*) => {}; + + (@impls [$first:ty $(, $rest:ty)*] $($(#[$meta:meta])* $name:ident,)*) => { +impl SizeConstants for $first { + $( +const $name:Self = { + assert!((self::$nameas u128 ) <= (<$first>::MAX as u128 )); + self::$nameas $first + }; + )* + } + +define_sizes! (@impls [$($rest),*] $($(#[$meta] )* $name,)*); + }; +} -/// 0x00000400 -pub const SZ_1K :usize = bindings::SZ_1K as usize ; -/// 0x00000800 -pub const SZ_2K :usize = bindings::SZ_2K as usize ; -/// 0x00001000 -pub const SZ_4K :usize = bindings::SZ_4K as usize ; -/// 0x00002000 -pub const SZ_8K :usize = bindings::SZ_8K as usize ; -/// 0x00004000 -pub const SZ_16K :usize = bindings::SZ_16K as usize ; -/// 0x00008000 -pub const SZ_32K :usize = bindings::SZ_32K as usize ; -/// 0x00010000 -pub const SZ_64K :usize = bindings::SZ_64K as usize ; -/// 0x00020000 -pub const SZ_128K :usize = bindings::SZ_128K as usize ; -/// 0x00040000 -pub const SZ_256K :usize = bindings::SZ_256K as usize ; -/// 0x00080000 -pub const SZ_512K :usize = bindings::SZ_512K as usize ; -/// 0x00100000 -pub const SZ_1M :usize = bindings::SZ_1M as usize ; -/// 0x00200000 -pub const SZ_2M :usize = bindings::SZ_2M as usize ; -/// 0x00400000 -pub const SZ_4M :usize = bindings::SZ_4M as usize ; -/// 0x00800000 -pub const SZ_8M :usize = bindings::SZ_8M as usize ; -/// 0x01000000 -pub const SZ_16M :usize = bindings::SZ_16M as usize ; -/// 0x02000000 -pub const SZ_32M :usize = bindings::SZ_32M as usize ; -/// 0x04000000 -pub const SZ_64M :usize = bindings::SZ_64M as usize ; -/// 0x08000000 -pub const SZ_128M :usize = bindings::SZ_128M as usize ; -/// 0x10000000 -pub const SZ_256M :usize = bindings::SZ_256M as usize ; -/// 0x20000000 -pub const SZ_512M :usize = bindings::SZ_512M as usize ; -/// 0x40000000 -pub const SZ_1G :usize = bindings::SZ_1G as usize ; -/// 0x80000000 -pub const SZ_2G :usize = bindings::SZ_2G as usize ; +define_sizes! (u32 ,u64 ,usize );
Signature · 1 line
2.53.0
Re: [PATCH v5 1/3] rust: sizes: add SizeConstants trait for device address space constants
Quoted 18 lines · John Hubbard
The SZ_* constants are usize, matching the CPU pointer width. But device address spaces have their own widths (32-bit MMIO windows, 64-bit GPU framebuffers, etc.), so drivers end up casting these constants with
SZ_1Mas u64 or helper functions. This adds boilerplate with no safety benefit.Add a SizeConstants trait with associated SZ_* constants, implemented for u32, u64, and usize. With the trait in scope, callers write
u64::SZ_1Moru32::SZ_4Kto get the constant in their device's native width. All SZ_* values fit in a u32, so every implementation is lossless. Each impl has a const assert to catch any future constant that would overflow.A
define_sizes! macro generates everything from a single internal list of names. The macro takes the target types as arguments, so adding a new target type requires changing only the call site.
Quoted 7 lines
Suggested-by Danilo Krummrich <[email protected]>Reviewed-by Eliot Courtney <[email protected]>Reviewed-by Alexandre Courbot <[email protected]>Acked-by Gary Guo <[email protected]>Signed-off-by John Hubbard <[email protected]>
If there are no concerns, then I will pick this one up.
Thanks!
Cheers,
Miguel
Alexandre Courbot
maintainerRe: [PATCH v5 1/3] rust: sizes: add SizeConstants trait for device address space constants
Quoted 27 lines · Miguel Ojeda
Quoted 18 lines · John Hubbard
The SZ_* constants are usize, matching the CPU pointer width. But device address spaces have their own widths (32-bit MMIO windows, 64-bit GPU framebuffers, etc.), so drivers end up casting these constants with
SZ_1Mas u64 or helper functions. This adds boilerplate with no safety benefit.Add a SizeConstants trait with associated SZ_* constants, implemented for u32, u64, and usize. With the trait in scope, callers write
u64::SZ_1Moru32::SZ_4Kto get the constant in their device's native width. All SZ_* values fit in a u32, so every implementation is lossless. Each impl has a const assert to catch any future constant that would overflow.A
define_sizes! macro generates everything from a single internal list of names. The macro takes the target types as arguments, so adding a new target type requires changing only the call site.Quoted 7 lines
Suggested-by Danilo Krummrich <[email protected]>Reviewed-by Eliot Courtney <[email protected]>Reviewed-by Alexandre Courbot <[email protected]>Acked-by Gary Guo <[email protected]>Signed-off-by John Hubbard <[email protected]>
Quoted 1 line
If there are no concerns, then I will pick this one up.
No concern from me, the user code in Nova will be scheduled for the 7.2 merge window anyway.
Re: [PATCH v5 1/3] rust: sizes: add SizeConstants trait for device address space constants
In reply to John HubbardQuoted 18 lines · John Hubbard
The SZ_* constants are usize, matching the CPU pointer width. But device address spaces have their own widths (32-bit MMIO windows, 64-bit GPU framebuffers, etc.), so drivers end up casting these constants with
SZ_1Mas u64 or helper functions. This adds boilerplate with no safety benefit.Add a SizeConstants trait with associated SZ_* constants, implemented for u32, u64, and usize. With the trait in scope, callers write
u64::SZ_1Moru32::SZ_4Kto get the constant in their device's native width. All SZ_* values fit in a u32, so every implementation is lossless. Each impl has a const assert to catch any future constant that would overflow.A
define_sizes! macro generates everything from a single internal list of names. The macro takes the target types as arguments, so adding a new target type requires changing only the call site.
Quoted 7 lines
Suggested-by Danilo Krummrich <[email protected]>Reviewed-by Eliot Courtney <[email protected]>Reviewed-by Alexandre Courbot <[email protected]>Acked-by Gary Guo <[email protected]>Signed-off-by John Hubbard <[email protected]>
Applied (just this one) to rust-next -- thanks everyone!
[ Applied the "kernel vertical" imports style. - Miguel ]
Cheers,
Miguel
PATCH v5 2/3 gpu: nova-core: use SizeConstants trait for u64 size constants
In reply to John HubbardReplace manual usize-to-u64 conversions of SZ_* constants with the SizeConstants trait's associated constants on u64. With the SizeConstants trait in scope, u64::SZ_1M replaces usize_as_u64(SZ_1M) and similar.
This removes several now-unused imports: usize_as_u64, FromSafeCast, and individual SZ_* type-level constants.
--- drivers/gpu/nova-core/fb.rs | 21 +++++++++------------ drivers/gpu/nova-core/gsp/fw.rs | 15 +++++++-------- drivers/gpu/nova-core/regs.rs | 7 +++---- 3 files changed, 19 insertions(+), 24 deletions(-)
drivers/gpu/nova-core/fb.rs +9 -12
@@ -24,11 +24,8 @@ firmware::gsp::GspFirmware, gpu::Chipset, gsp, - num::{ - usize_as_u64, - FromSafeCast, // - }, - regs, + num::FromSafeCast, + regs, // };mod hal;
@@ -127,8 +124,8 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { if f.alternate() { let size = self.len(); - if size < usize_as_u64(SZ_1M) { - let size_kib = size / usize_as_u64(SZ_1K); + if size < u64::SZ_1M { + let size_kib = size / u64::SZ_1K; f.write_fmt(fmt!( "{:#x}..{:#x} ({} KiB)", self.0.start,
@@ -136,7 +133,7 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { size_kib )) } else { - let size_mib = size / usize_as_u64(SZ_1M); + let size_mib = size / u64::SZ_1M; f.write_fmt(fmt!( "{:#x}..{:#x} ({} MiB)", self.0.start,
@@ -186,7 +183,7 @@ pub(crate) fn new(chipset: Chipset, bar: &Bar0, gsp_fw: &GspFirmware) -> Result<let vga_workspace = {let vga_base = { -const NV_PRAMIN_SIZE :u64 =usize_as_u64 (SZ_1M ); +const NV_PRAMIN_SIZE :u64 = u64::SZ_1M ;let base = fb.end -NV_PRAMIN_SIZE ;if hal.supports_display (bar) {
@@ -196,7 +193,7 @@ pub(crate) fn new(chipset: Chipset, bar: &Bar0, gsp_fw: &GspFirmware) -> Result< { Some(addr) => {if addr < base { -const VBIOS_WORKSPACE_SIZE :u64 =usize_as_u64 (SZ_128K ); +const VBIOS_WORKSPACE_SIZE :u64 = u64::SZ_128K ;// Point workspace address to end of framebuffer. fb.end -VBIOS_WORKSPACE_SIZE
@@ -216,7 +213,7 @@ pub(crate) fn new(chipset: Chipset, bar: &Bar0, gsp_fw: &GspFirmware) -> Result<let frts = {const FRTS_DOWN_ALIGN :Alignment =Alignment ::new ::<SZ_128K >(); -const FRTS_SIZE :u64 =usize_as_u64 (SZ_1M ); +const FRTS_SIZE :u64 = u64::SZ_1M ;let frts_base = vga_workspace.start.align_down (FRTS_DOWN_ALIGN ) -FRTS_SIZE ;FbRange (frts_base..frts_base +FRTS_SIZE )
@@ -256,7 +253,7 @@ pub(crate) fn new(chipset: Chipset, bar: &Bar0, gsp_fw: &GspFirmware) -> Result< };let heap = { -const HEAP_SIZE :u64 =usize_as_u64 (SZ_1M ); +const HEAP_SIZE :u64 = u64::SZ_1M ;FbRange (wpr2.start -HEAP_SIZE ..wpr2.start) };
drivers/gpu/nova-core/gsp/fw.rs +7 -8
@@ -17,8 +17,8 @@ KnownSize, // }, sizes::{ - SZ_128K, - SZ_1M, // + SizeConstants, + SZ_128K, // }, transmute::{AsBytes ,
@@ -123,7 +123,7 @@ fn client_alloc_size() -> u64 {/// Returns the amount of memory to reserve for management purposes for a framebuffer of size /// `fb_size`. fn management_overhead (fb_size:u64 ) ->u64 { -let fb_size_gb = fb_size.div_ceil (u64::from_safe_cast (kernel::sizes::SZ_1G )); +let fb_size_gb = fb_size.div_ceil (u64::SZ_1G ); u64::from (bindings::GSP_FW_HEAP_PARAM_SIZE_PER_GB_FB ) .saturating_mul (fb_size_gb)
@@ -145,9 +145,8 @@ impl LibosParams {const LIBOS2 :LibosParams =LibosParams { carveout_size: num::u32_as_u64 (bindings::GSP_FW_HEAP_PARAM_OS_SIZE_LIBOS2 ), allowed_heap_size: num::u32_as_u64 (bindings::GSP_FW_HEAP_SIZE_OVERRIDE_LIBOS2_MIN_MB ) - * num::usize_as_u64 (SZ_1M ) - ..num::u32_as_u64 (bindings::GSP_FW_HEAP_SIZE_OVERRIDE_LIBOS2_MAX_MB ) - * num::usize_as_u64 (SZ_1M ), + * u64::SZ_1M + ..num::u32_as_u64 (bindings::GSP_FW_HEAP_SIZE_OVERRIDE_LIBOS2_MAX_MB ) * u64::SZ_1M , };/// Version 3 of the GSP LIBOS (GA102+)
@@ -155,9 +154,9 @@ impl LibosParams { carveout_size: num::u32_as_u64(bindings::GSP_FW_HEAP_PARAM_OS_SIZE_LIBOS3_BAREMETAL), allowed_heap_size: num::u32_as_u64( bindings::GSP_FW_HEAP_SIZE_OVERRIDE_LIBOS3_BAREMETAL_MIN_MB , - ) * num::usize_as_u64 (SZ_1M ) + ) * u64::SZ_1M ..num::u32_as_u64 (bindings::GSP_FW_HEAP_SIZE_OVERRIDE_LIBOS3_BAREMETAL_MAX_MB ) - * num::usize_as_u64(SZ_1M), + * u64::SZ_1M, };/// Returns the libos parameters corresponding to `chipset`.
drivers/gpu/nova-core/regs.rs +3 -4
@@ -7,6 +7,7 @@ Io, // }, prelude::*, + sizes::SizeConstants, time, // };
@@ -30,7 +31,6 @@ Architecture, Chipset, // }, - num::FromSafeCast, };// PMC
@@ -150,8 +150,7 @@ fn fmt(&self, f: &mut kernel::fmt::Formatter<'_>) -> kernel::fmt::Result {impl NV_PFB_PRI_MMU_LOCAL_MEMORY_RANGE {/// Returns the usable framebuffer size, in bytes. pub (crate )fn usable_fb_size (self) ->u64 { -let size = (u64::from (self.lower_mag ()) << u64::from (self.lower_scale ())) - * u64::from_safe_cast (kernel::sizes::SZ_1M ); +let size = (u64::from (self.lower_mag ()) << u64::from (self.lower_scale ())) * u64::SZ_1M ;if self.ecc_mode_enabled () {// Remove the amount of memory reserved for ECC (one per 16 units).
@@ -241,7 +240,7 @@ pub(crate) fn completed(self) -> bool {impl NV_USABLE_FB_SIZE_IN_MB {/// Returns the usable framebuffer size, in bytes. pub (crate )fn usable_fb_size (self) ->u64 { - u64::from (self.value ()) * u64::from_safe_cast (kernel::sizes::SZ_1M ) + u64::from (self.value ()) * u64::SZ_1M } }
Signature · 1 line
2.53.0
PATCH v5 3/3 gpu: nova-core: add task for device address type wrappers
In reply to John HubbardAdd a todo.rst entry for creating newtype wrappers around integer types for device addresses and sizes, with a marker trait that generic DRM APIs can use as a bound.
--- Documentation/gpu/nova/core/todo.rst | 13 +++++++++++++ 1 file changed, 13 insertions(+)
Documentation/gpu/nova/core/todo.rst +13 -0
@@ -88,6 +88,19 @@ SR-IOV [1] is work in progress. | Complexity: Beginner | Link: https://lore.kernel.org/all/[email protected]/ [1] +Device address type wrappers +---------------------------- + +The ``SizeConstants`` trait provides ``SZ_*`` constants as associated constants +on ``u32``, ``u64``, and ``usize``. Device-centric APIs such as GPU VM +management and buddy allocators could benefit from newtype wrappers around these +integer types to represent device addresses and sizes. A separate marker trait +could then serve as a generic bound for those wrappers. + +| Complexity: Intermediate +| Link: https://lore.kernel.org/all/[email protected]/ +| Contact: Danilo Krummrich + GPU (general) =============
Signature · 1 line
2.53.0