Skip to contentSkip to conversation

rust, nova-core: add SizeConstants trait for SZ_* constants

PATCH Applied John Hubbard 3 participants 6 messages Apr 11 – Apr 28

Subsystems (7)
lore
Share & tools
lore
#0 lore raw

v6 cover rust, nova-core: add SizeConstants trait for SZ_* constants

Changes in v6:

* Rebased onto Alex Courbot's drm-rust-next-staging branch[1], which now includes the prerequisites, so this is only 2 patches instead of 3.

Sending this because it makes the upcoming Blackwell v10 posting cleaner.

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.

[1] https://github.com/Gnurou/linux/commits/drm-rust-next-staging/

v1 is here:

    https://lore.kernel.org/[email protected]

John Hubbard (2):
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 | 14 ++++++++++++++
 drivers/gpu/nova-core/fb.rs          | 21 +++++++++------------
 drivers/gpu/nova-core/gsp/fw.rs      | 15 +++++++--------
 drivers/gpu/nova-core/regs.rs        |  7 +++----
 4 files changed, 33 insertions(+), 24 deletions(-)

base-commit: 8884dbc1fd174315b406027375bb7a4b211a8fae

Signature · 1 line
2.53.0
#1 lore raw

PATCH v6 1/2 gpu: nova-core: use SizeConstants trait for u64 size constants

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.

---
 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
index f357fb28b22c..35899e9b2560 100644
@@ -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
index 5e109eb90164..3245793bbe42 100644
@@ -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) -> Result<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)
             .checked_mul(fb_size_gb)
@@ -146,9 +146,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+)
@@ -156,9 +155,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
index 2f171a4ff9ba..6faeed73901d 100644
@@ -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
#2 lore raw

PATCH v6 2/2 gpu: nova-core: add task for device address type wrappers

In reply to 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.

---
 Documentation/gpu/nova/core/todo.rst | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
Documentation/gpu/nova/core/todo.rst +14 -0
index d5130b2b08fb..595a94e9ee2e 100644
@@ -88,6 +88,20 @@ 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
#3 lore raw

Re: [PATCH v6 2/2] gpu: nova-core: add task for device address type wrappers

Quoted 20 lines · 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.

---
 Documentation/gpu/nova/core/todo.rst | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
Documentation/gpu/nova/core/todo.rst +2 -0
index d5130b2b08fb..595a94e9ee2e 100644
@@ -88,6 +88,20 @@ SR-IOV [1] is work in progress.
 | Complexity: Beginner
 | Link: https://lore.kernel.org/all/[email protected]/ [1]
 
+Device address type wrappers
+----------------------------

Documentation/gpu/nova/core/todo.rst SR-IOV [1] is work in progress. · line 102

Quoted 10 lines
Documentation/gpu/nova/core/todo.rst +10 -0
+
+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

Danilo, do you ack being the contact for this?

Do we actually want an TODO entry for this even though we don't have a concrete use-case for this? Nova is 64-bit only and will likely not use this feature, so it looks out-of-place to list it here imho.

maintainer
#4 lore raw

Re: [PATCH v6 2/2] gpu: nova-core: add task for device address type wrappers

In reply to John Hubbard

Documentation/gpu/nova/core/todo.rst

Quoted 14 lines · 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.

---
 Documentation/gpu/nova/core/todo.rst | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
Documentation/gpu/nova/core/todo.rst +0 -0
index d5130b2b08fb..595a94e9ee2e 100644

I think this fits better in Documentation/gpu/todo.rst and the Rust for Linux issue tracker.

Quoted 23 lines
Documentation/gpu/nova/core/todo.rst +14 -0
@@ -88,6 +88,20 @@ 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
maintainer Applied
#5 lore raw

Re: (subset) [PATCH v6 0/2] rust, nova-core: add SizeConstants trait for SZ_* constants

In reply to John Hubbard
Quoted 1 line · John Hubbard

[PATCH v6 0/2] rust, nova-core: add SizeConstants trait for SZ_* constants

Applied, thanks!

Branch: drm-rust-next
Tree: https://gitlab.freedesktop.org/drm/rust/kernel.git

[1/2] gpu: nova-core: use SizeConstants trait for u64 size constants

      commit: 98e508e5b016

The patch will appear in the next linux-next integration (typically within 24 hours on weekdays).

The patch is queued up for the upcoming merge window for the next major kernel release.