* [PATCH v5 0/3] rust, nova-core: add SizeConstants trait for SZ_* constants
@ 2026-04-04 2:12 John Hubbard
2026-04-04 2:12 ` [PATCH v5 1/3] rust: sizes: add SizeConstants trait for device address space constants John Hubbard
` (2 more replies)
0 siblings, 3 replies; 6+ messages in thread
From: John Hubbard @ 2026-04-04 2:12 UTC (permalink / raw)
To: Danilo Krummrich, Alexandre Courbot
Cc: Joel Fernandes, Timur Tabi, Alistair Popple, Eliot Courtney,
Shashank Sharma, Zhi Wang, David Airlie, Simona Vetter,
Bjorn Helgaas, Miguel Ojeda, Alex Gaynor, Boqun Feng, Gary Guo,
Björn Roy Baron, Benno Lossin, Andreas Hindborg, Alice Ryhl,
Trevor Gross, rust-for-linux, LKML, John Hubbard
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/20260310023145.120037-1-jhubbard@nvidia.com
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
--
2.53.0
^ permalink raw reply [flat|nested] 6+ messages in thread
* [PATCH v5 1/3] rust: sizes: add SizeConstants trait for device address space constants
2026-04-04 2:12 [PATCH v5 0/3] rust, nova-core: add SizeConstants trait for SZ_* constants John Hubbard
@ 2026-04-04 2:12 ` John Hubbard
2026-04-04 2:33 ` Miguel Ojeda
2026-04-04 2:12 ` [PATCH v5 2/3] gpu: nova-core: use SizeConstants trait for u64 size constants John Hubbard
2026-04-04 2:12 ` [PATCH v5 3/3] gpu: nova-core: add task for device address type wrappers John Hubbard
2 siblings, 1 reply; 6+ messages in thread
From: John Hubbard @ 2026-04-04 2:12 UTC (permalink / raw)
To: Danilo Krummrich, Alexandre Courbot
Cc: Joel Fernandes, Timur Tabi, Alistair Popple, Eliot Courtney,
Shashank Sharma, Zhi Wang, David Airlie, Simona Vetter,
Bjorn Helgaas, Miguel Ojeda, Alex Gaynor, Boqun Feng, Gary Guo,
Björn Roy Baron, Benno Lossin, Andreas Hindborg, Alice Ryhl,
Trevor Gross, rust-for-linux, LKML, 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_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.
Suggested-by: Danilo Krummrich <dakr@kernel.org>
Link: https://lore.kernel.org/all/DGB9G697GSWO.3VBFGU5MKFPMR@kernel.org/
Link: https://lore.kernel.org/all/DGHI8WRKBQS9.38910L6FIIZTE@kernel.org/
Reviewed-by: Eliot Courtney <ecourtney@nvidia.com>
Reviewed-by: Alexandre Courbot <acourbot@nvidia.com>
Acked-by: Gary Guo <gary@garyguo.net>
Signed-off-by: John Hubbard <jhubbard@nvidia.com>
---
rust/kernel/sizes.rs | 167 +++++++++++++++++++++++++++++++------------
1 file changed, 123 insertions(+), 44 deletions(-)
diff --git a/rust/kernel/sizes.rs b/rust/kernel/sizes.rs
index 661e680d9330..837404a2042b 100644
--- a/rust/kernel/sizes.rs
+++ b/rust/kernel/sizes.rs
@@ -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::$name as 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::$name as u128) <= (<$first>::MAX as u128));
+ self::$name as $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);
--
2.53.0
^ permalink raw reply related [flat|nested] 6+ messages in thread
* [PATCH v5 2/3] gpu: nova-core: use SizeConstants trait for u64 size constants
2026-04-04 2:12 [PATCH v5 0/3] rust, nova-core: add SizeConstants trait for SZ_* constants John Hubbard
2026-04-04 2:12 ` [PATCH v5 1/3] rust: sizes: add SizeConstants trait for device address space constants John Hubbard
@ 2026-04-04 2:12 ` John Hubbard
2026-04-04 2:12 ` [PATCH v5 3/3] gpu: nova-core: add task for device address type wrappers John Hubbard
2 siblings, 0 replies; 6+ messages in thread
From: John Hubbard @ 2026-04-04 2:12 UTC (permalink / raw)
To: Danilo Krummrich, Alexandre Courbot
Cc: Joel Fernandes, Timur Tabi, Alistair Popple, Eliot Courtney,
Shashank Sharma, Zhi Wang, David Airlie, Simona Vetter,
Bjorn Helgaas, Miguel Ojeda, Alex Gaynor, Boqun Feng, Gary Guo,
Björn Roy Baron, Benno Lossin, Andreas Hindborg, Alice Ryhl,
Trevor Gross, rust-for-linux, LKML, John Hubbard
Replace 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.
Reviewed-by: Eliot Courtney <ecourtney@nvidia.com>
Reviewed-by: Joel Fernandes <joelagnelf@nvidia.com>
Acked-by: Gary Guo <gary@garyguo.net>
Signed-off-by: John Hubbard <jhubbard@nvidia.com>
---
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(-)
diff --git a/drivers/gpu/nova-core/fb.rs b/drivers/gpu/nova-core/fb.rs
index bdd5eed760e1..5c304fc03467 100644
--- a/drivers/gpu/nova-core/fb.rs
+++ b/drivers/gpu/nova-core/fb.rs
@@ -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)
};
diff --git a/drivers/gpu/nova-core/gsp/fw.rs b/drivers/gpu/nova-core/gsp/fw.rs
index 0c8a74f0e8ac..9dac3288f3a3 100644
--- a/drivers/gpu/nova-core/gsp/fw.rs
+++ b/drivers/gpu/nova-core/gsp/fw.rs
@@ -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`.
diff --git a/drivers/gpu/nova-core/regs.rs b/drivers/gpu/nova-core/regs.rs
index 2f171a4ff9ba..6faeed73901d 100644
--- a/drivers/gpu/nova-core/regs.rs
+++ b/drivers/gpu/nova-core/regs.rs
@@ -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
}
}
--
2.53.0
^ permalink raw reply related [flat|nested] 6+ messages in thread
* [PATCH v5 3/3] gpu: nova-core: add task for device address type wrappers
2026-04-04 2:12 [PATCH v5 0/3] rust, nova-core: add SizeConstants trait for SZ_* constants John Hubbard
2026-04-04 2:12 ` [PATCH v5 1/3] rust: sizes: add SizeConstants trait for device address space constants John Hubbard
2026-04-04 2:12 ` [PATCH v5 2/3] gpu: nova-core: use SizeConstants trait for u64 size constants John Hubbard
@ 2026-04-04 2:12 ` John Hubbard
2 siblings, 0 replies; 6+ messages in thread
From: John Hubbard @ 2026-04-04 2:12 UTC (permalink / raw)
To: Danilo Krummrich, Alexandre Courbot
Cc: Joel Fernandes, Timur Tabi, Alistair Popple, Eliot Courtney,
Shashank Sharma, Zhi Wang, David Airlie, Simona Vetter,
Bjorn Helgaas, Miguel Ojeda, Alex Gaynor, Boqun Feng, Gary Guo,
Björn Roy Baron, Benno Lossin, Andreas Hindborg, Alice Ryhl,
Trevor Gross, rust-for-linux, LKML, John Hubbard
Add 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.
Suggested-by: Danilo Krummrich <dakr@kernel.org>
Signed-off-by: John Hubbard <jhubbard@nvidia.com>
---
Documentation/gpu/nova/core/todo.rst | 13 +++++++++++++
1 file changed, 13 insertions(+)
diff --git a/Documentation/gpu/nova/core/todo.rst b/Documentation/gpu/nova/core/todo.rst
index d5130b2b08fb..c06f274ed1b4 100644
--- a/Documentation/gpu/nova/core/todo.rst
+++ b/Documentation/gpu/nova/core/todo.rst
@@ -88,6 +88,19 @@ SR-IOV [1] is work in progress.
| Complexity: Beginner
| Link: https://lore.kernel.org/all/20251119-rust-pci-sriov-v1-0-883a94599a97@redhat.com/ [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/DHJJJNP5T5FZ.2HWBMOEEKH9ZR@kernel.org/
+| Contact: Danilo Krummrich
+
GPU (general)
=============
--
2.53.0
^ permalink raw reply related [flat|nested] 6+ messages in thread
* Re: [PATCH v5 1/3] rust: sizes: add SizeConstants trait for device address space constants
2026-04-04 2:12 ` [PATCH v5 1/3] rust: sizes: add SizeConstants trait for device address space constants John Hubbard
@ 2026-04-04 2:33 ` Miguel Ojeda
2026-04-04 4:20 ` Alexandre Courbot
0 siblings, 1 reply; 6+ messages in thread
From: Miguel Ojeda @ 2026-04-04 2:33 UTC (permalink / raw)
To: John Hubbard
Cc: Danilo Krummrich, Alexandre Courbot, Joel Fernandes, Timur Tabi,
Alistair Popple, Eliot Courtney, Shashank Sharma, Zhi Wang,
David Airlie, Simona Vetter, Bjorn Helgaas, Miguel Ojeda,
Alex Gaynor, Boqun Feng, Gary Guo, Björn Roy Baron,
Benno Lossin, Andreas Hindborg, Alice Ryhl, Trevor Gross,
rust-for-linux, LKML
On Sat, Apr 4, 2026 at 4:12 AM John Hubbard <jhubbard@nvidia.com> wrote:
>
> 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.
>
> Suggested-by: Danilo Krummrich <dakr@kernel.org>
> Link: https://lore.kernel.org/all/DGB9G697GSWO.3VBFGU5MKFPMR@kernel.org/
> Link: https://lore.kernel.org/all/DGHI8WRKBQS9.38910L6FIIZTE@kernel.org/
> Reviewed-by: Eliot Courtney <ecourtney@nvidia.com>
> Reviewed-by: Alexandre Courbot <acourbot@nvidia.com>
> Acked-by: Gary Guo <gary@garyguo.net>
> Signed-off-by: John Hubbard <jhubbard@nvidia.com>
If there are no concerns, then I will pick this one up.
Thanks!
Cheers,
Miguel
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH v5 1/3] rust: sizes: add SizeConstants trait for device address space constants
2026-04-04 2:33 ` Miguel Ojeda
@ 2026-04-04 4:20 ` Alexandre Courbot
0 siblings, 0 replies; 6+ messages in thread
From: Alexandre Courbot @ 2026-04-04 4:20 UTC (permalink / raw)
To: Miguel Ojeda
Cc: John Hubbard, Danilo Krummrich, Joel Fernandes, Timur Tabi,
Alistair Popple, Eliot Courtney, Shashank Sharma, Zhi Wang,
David Airlie, Simona Vetter, Bjorn Helgaas, Miguel Ojeda,
Alex Gaynor, Boqun Feng, Gary Guo, Björn Roy Baron,
Benno Lossin, Andreas Hindborg, Alice Ryhl, Trevor Gross,
rust-for-linux, LKML
On Sat Apr 4, 2026 at 11:33 AM JST, Miguel Ojeda wrote:
> On Sat, Apr 4, 2026 at 4:12 AM John Hubbard <jhubbard@nvidia.com> wrote:
>>
>> 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.
>>
>> Suggested-by: Danilo Krummrich <dakr@kernel.org>
>> Link: https://lore.kernel.org/all/DGB9G697GSWO.3VBFGU5MKFPMR@kernel.org/
>> Link: https://lore.kernel.org/all/DGHI8WRKBQS9.38910L6FIIZTE@kernel.org/
>> Reviewed-by: Eliot Courtney <ecourtney@nvidia.com>
>> Reviewed-by: Alexandre Courbot <acourbot@nvidia.com>
>> Acked-by: Gary Guo <gary@garyguo.net>
>> Signed-off-by: John Hubbard <jhubbard@nvidia.com>
>
> 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.
^ permalink raw reply [flat|nested] 6+ messages in thread
end of thread, other threads:[~2026-04-04 4:20 UTC | newest]
Thread overview: 6+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-04-04 2:12 [PATCH v5 0/3] rust, nova-core: add SizeConstants trait for SZ_* constants John Hubbard
2026-04-04 2:12 ` [PATCH v5 1/3] rust: sizes: add SizeConstants trait for device address space constants John Hubbard
2026-04-04 2:33 ` Miguel Ojeda
2026-04-04 4:20 ` Alexandre Courbot
2026-04-04 2:12 ` [PATCH v5 2/3] gpu: nova-core: use SizeConstants trait for u64 size constants John Hubbard
2026-04-04 2:12 ` [PATCH v5 3/3] gpu: nova-core: add task for device address type wrappers John Hubbard
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox