* [PATCH RFC v5 0/6] nova-core: Memory management initial patches
@ 2025-12-19 20:37 ` Joel Fernandes
0 siblings, 0 replies; 23+ messages in thread
From: Joel Fernandes @ 2025-12-19 20:37 UTC (permalink / raw)
To: Maarten Lankhorst, Maxime Ripard, Thomas Zimmermann, David Airlie,
Simona Vetter, Jonathan Corbet, Alex Deucher,
Christian König, Jani Nikula, Joonas Lahtinen, Rodrigo Vivi,
Tvrtko Ursulin, Huang Rui, Matthew Auld, Matthew Brost,
Lucas De Marchi, Thomas Hellström, Helge Deller
Cc: Danilo Krummrich, Alice Ryhl, Miguel Ojeda, Alex Gaynor,
Boqun Feng, Gary Guo, Björn Roy Baron, Benno Lossin,
Andreas Hindborg, Trevor Gross, John Hubbard, Alistair Popple,
Timur Tabi, Edwin Peer, Alexandre Courbot, Andrea Righi,
Philipp Stanner, Elle Rhumsaa, Daniel Almeida, joel, nouveau,
dri-devel, rust-for-linux, linux-kernel, linux-doc, amd-gfx,
intel-gfx, intel-xe, linux-fbdev, Joel Fernandes
This series is based on the latest drm-rust-next tree and provides initial memory management infrastructure for the nova-core
GPU driver. It combines and builds upon several previous series and provides a foundation for nova GPU memory management.
The RFC series includes:
- A Rust module (CList) to interface with C circular linked lists, required
for iterating over buddy allocator block lists.
- Movement of the DRM buddy allocator up to drivers/gpu/ level, renamed to GPU
buddy, making it available for GPU drivers with non-DRM use cases (e.g., vGPU).
- Rust bindings for the GPU buddy allocator.
- PRAMIN aperture support for direct VRAM access before page tables are initialized.
- Documentation for the PRAMIN mechanism.
- VRAM read/write self-tests for PRAMIN (disabled by default via Kconfig).
The series combines various previous series since all the patches are related.
Moving forward I will only send one coherent series with the mm patches.
Next steps:
Page table types and page table mapping support will be added on top of this
foundation extracted from the original PRAMIN series. I need to make several
changes there such as to support multiple page table formats, as well as
updating it to use the new PRAMIN and buddy APIs.
Changes from v4 to v5:
- Added PRAMIN aperture support for bootstrapping memory management.
- Added documentation for the PRAMIN aperture mechanism.
- Added PRAMIN self-tests for VRAM read/write verification (disabled by default).
- Improved buddy allocator bindings a bit (fewer lines of code).
The patches on based on drm-rust-next commit:
97cf6bc0abd3 ("rust: drm: use `pin_init::zeroed()` for file operations initialization")
Previous series that are combined:
- v4 (clist + buddy): https://lore.kernel.org/all/20251204215129.2357292-1-joelagnelf@nvidia.com/
- v3 (clist only): https://lore.kernel.org/all/20251129213056.4021375-1-joelagnelf@nvidia.com/
- v2 (clist only): https://lore.kernel.org/all/20251111171315.2196103-4-joelagnelf@nvidia.com/
- clist RFC (original with buddy): https://lore.kernel.org/all/20251030190613.1224287-1-joelagnelf@nvidia.com/
- DRM buddy move: https://lore.kernel.org/all/20251124234432.1988476-1-joelagnelf@nvidia.com/
- PRAMIN series: https://lore.kernel.org/all/20251020185539.49986-1-joelagnelf@nvidia.com/
Joel Fernandes (6):
rust: clist: Add support to interface with C linked lists
gpu: Move DRM buddy allocator one level up
rust: gpu: Add GPU buddy allocator bindings
nova-core: mm: Add support to use PRAMIN windows to write to VRAM
docs: gpu: nova-core: Document the PRAMIN aperture mechanism
nova-core: Add PRAMIN aperture self-tests
Documentation/gpu/drm-mm.rst | 10 +-
Documentation/gpu/nova/core/pramin.rst | 125 ++
Documentation/gpu/nova/index.rst | 1 +
MAINTAINERS | 7 +
drivers/gpu/Kconfig | 13 +
drivers/gpu/Makefile | 2 +
drivers/gpu/buddy.c | 1310 +++++++++++++++++
drivers/gpu/drm/Kconfig | 1 +
drivers/gpu/drm/Kconfig.debug | 4 +-
drivers/gpu/drm/amd/amdgpu/Kconfig | 1 +
drivers/gpu/drm/amd/amdgpu/amdgpu_ras.c | 2 +-
.../gpu/drm/amd/amdgpu/amdgpu_res_cursor.h | 12 +-
drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c | 80 +-
drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.h | 20 +-
drivers/gpu/drm/drm_buddy.c | 1287 +---------------
drivers/gpu/drm/i915/Kconfig | 1 +
drivers/gpu/drm/i915/i915_scatterlist.c | 10 +-
drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 55 +-
drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 6 +-
.../drm/i915/selftests/intel_memory_region.c | 20 +-
drivers/gpu/drm/tests/Makefile | 1 -
.../gpu/drm/ttm/tests/ttm_bo_validate_test.c | 5 +-
drivers/gpu/drm/ttm/tests/ttm_mock_manager.c | 18 +-
drivers/gpu/drm/ttm/tests/ttm_mock_manager.h | 4 +-
drivers/gpu/drm/xe/Kconfig | 1 +
drivers/gpu/drm/xe/xe_res_cursor.h | 34 +-
drivers/gpu/drm/xe/xe_svm.c | 12 +-
drivers/gpu/drm/xe/xe_ttm_vram_mgr.c | 73 +-
drivers/gpu/drm/xe/xe_ttm_vram_mgr_types.h | 4 +-
drivers/gpu/nova-core/Kconfig | 11 +
drivers/gpu/nova-core/gsp/boot.rs | 4 +
drivers/gpu/nova-core/mm/mod.rs | 5 +
drivers/gpu/nova-core/mm/pramin.rs | 298 ++++
drivers/gpu/nova-core/nova_core.rs | 1 +
drivers/gpu/nova-core/regs.rs | 5 +
drivers/gpu/tests/Makefile | 3 +
.../gpu_buddy_test.c} | 390 ++---
drivers/gpu/tests/gpu_random.c | 48 +
drivers/gpu/tests/gpu_random.h | 28 +
drivers/video/Kconfig | 2 +
include/drm/drm_buddy.h | 163 +-
include/linux/gpu_buddy.h | 177 +++
rust/bindings/bindings_helper.h | 11 +
rust/helpers/gpu.c | 23 +
rust/helpers/helpers.c | 2 +
rust/helpers/list.c | 12 +
rust/kernel/clist.rs | 357 +++++
rust/kernel/gpu/buddy.rs | 518 +++++++
rust/kernel/gpu/mod.rs | 5 +
rust/kernel/lib.rs | 3 +
50 files changed, 3385 insertions(+), 1800 deletions(-)
create mode 100644 Documentation/gpu/nova/core/pramin.rst
create mode 100644 drivers/gpu/Kconfig
create mode 100644 drivers/gpu/buddy.c
create mode 100644 drivers/gpu/nova-core/mm/mod.rs
create mode 100644 drivers/gpu/nova-core/mm/pramin.rs
create mode 100644 drivers/gpu/tests/Makefile
rename drivers/gpu/{drm/tests/drm_buddy_test.c => tests/gpu_buddy_test.c} (68%)
create mode 100644 drivers/gpu/tests/gpu_random.c
create mode 100644 drivers/gpu/tests/gpu_random.h
create mode 100644 include/linux/gpu_buddy.h
create mode 100644 rust/helpers/gpu.c
create mode 100644 rust/helpers/list.c
create mode 100644 rust/kernel/clist.rs
create mode 100644 rust/kernel/gpu/buddy.rs
create mode 100644 rust/kernel/gpu/mod.rs
--
2.34.1
^ permalink raw reply [flat|nested] 23+ messages in thread* [PATCH RFC v5 0/6] nova-core: Memory management initial patches @ 2025-12-19 20:37 ` Joel Fernandes 0 siblings, 0 replies; 23+ messages in thread From: Joel Fernandes @ 2025-12-19 20:37 UTC (permalink / raw) To: Maarten Lankhorst, Maxime Ripard, Thomas Zimmermann, David Airlie, Simona Vetter, Jonathan Corbet, Alex Deucher, Christian König, Jani Nikula, Joonas Lahtinen, Rodrigo Vivi, Tvrtko Ursulin, Huang Rui, Matthew Auld, Matthew Brost, Lucas De Marchi, Thomas Hellström, Helge Deller Cc: Danilo Krummrich, Alice Ryhl, Miguel Ojeda, Alex Gaynor, Boqun Feng, Gary Guo, Björn Roy Baron, Benno Lossin, Andreas Hindborg, Trevor Gross, Alistair Popple, Alexandre Courbot, Andrea Righi, Philipp Stanner, Elle Rhumsaa, Daniel Almeida, joel, nouveau, dri-devel, rust-for-linux, linux-kernel, linux-doc, amd-gfx, intel-gfx, intel-xe, linux-fbdev, Joel Fernandes This series is based on the latest drm-rust-next tree and provides initial memory management infrastructure for the nova-core GPU driver. It combines and builds upon several previous series and provides a foundation for nova GPU memory management. The RFC series includes: - A Rust module (CList) to interface with C circular linked lists, required for iterating over buddy allocator block lists. - Movement of the DRM buddy allocator up to drivers/gpu/ level, renamed to GPU buddy, making it available for GPU drivers with non-DRM use cases (e.g., vGPU). - Rust bindings for the GPU buddy allocator. - PRAMIN aperture support for direct VRAM access before page tables are initialized. - Documentation for the PRAMIN mechanism. - VRAM read/write self-tests for PRAMIN (disabled by default via Kconfig). The series combines various previous series since all the patches are related. Moving forward I will only send one coherent series with the mm patches. Next steps: Page table types and page table mapping support will be added on top of this foundation extracted from the original PRAMIN series. I need to make several changes there such as to support multiple page table formats, as well as updating it to use the new PRAMIN and buddy APIs. Changes from v4 to v5: - Added PRAMIN aperture support for bootstrapping memory management. - Added documentation for the PRAMIN aperture mechanism. - Added PRAMIN self-tests for VRAM read/write verification (disabled by default). - Improved buddy allocator bindings a bit (fewer lines of code). The patches on based on drm-rust-next commit: 97cf6bc0abd3 ("rust: drm: use `pin_init::zeroed()` for file operations initialization") Previous series that are combined: - v4 (clist + buddy): https://lore.kernel.org/all/20251204215129.2357292-1-joelagnelf@nvidia.com/ - v3 (clist only): https://lore.kernel.org/all/20251129213056.4021375-1-joelagnelf@nvidia.com/ - v2 (clist only): https://lore.kernel.org/all/20251111171315.2196103-4-joelagnelf@nvidia.com/ - clist RFC (original with buddy): https://lore.kernel.org/all/20251030190613.1224287-1-joelagnelf@nvidia.com/ - DRM buddy move: https://lore.kernel.org/all/20251124234432.1988476-1-joelagnelf@nvidia.com/ - PRAMIN series: https://lore.kernel.org/all/20251020185539.49986-1-joelagnelf@nvidia.com/ Joel Fernandes (6): rust: clist: Add support to interface with C linked lists gpu: Move DRM buddy allocator one level up rust: gpu: Add GPU buddy allocator bindings nova-core: mm: Add support to use PRAMIN windows to write to VRAM docs: gpu: nova-core: Document the PRAMIN aperture mechanism nova-core: Add PRAMIN aperture self-tests Documentation/gpu/drm-mm.rst | 10 +- Documentation/gpu/nova/core/pramin.rst | 125 ++ Documentation/gpu/nova/index.rst | 1 + MAINTAINERS | 7 + drivers/gpu/Kconfig | 13 + drivers/gpu/Makefile | 2 + drivers/gpu/buddy.c | 1310 +++++++++++++++++ drivers/gpu/drm/Kconfig | 1 + drivers/gpu/drm/Kconfig.debug | 4 +- drivers/gpu/drm/amd/amdgpu/Kconfig | 1 + drivers/gpu/drm/amd/amdgpu/amdgpu_ras.c | 2 +- .../gpu/drm/amd/amdgpu/amdgpu_res_cursor.h | 12 +- drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c | 80 +- drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.h | 20 +- drivers/gpu/drm/drm_buddy.c | 1287 +--------------- drivers/gpu/drm/i915/Kconfig | 1 + drivers/gpu/drm/i915/i915_scatterlist.c | 10 +- drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 55 +- drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 6 +- .../drm/i915/selftests/intel_memory_region.c | 20 +- drivers/gpu/drm/tests/Makefile | 1 - .../gpu/drm/ttm/tests/ttm_bo_validate_test.c | 5 +- drivers/gpu/drm/ttm/tests/ttm_mock_manager.c | 18 +- drivers/gpu/drm/ttm/tests/ttm_mock_manager.h | 4 +- drivers/gpu/drm/xe/Kconfig | 1 + drivers/gpu/drm/xe/xe_res_cursor.h | 34 +- drivers/gpu/drm/xe/xe_svm.c | 12 +- drivers/gpu/drm/xe/xe_ttm_vram_mgr.c | 73 +- drivers/gpu/drm/xe/xe_ttm_vram_mgr_types.h | 4 +- drivers/gpu/nova-core/Kconfig | 11 + drivers/gpu/nova-core/gsp/boot.rs | 4 + drivers/gpu/nova-core/mm/mod.rs | 5 + drivers/gpu/nova-core/mm/pramin.rs | 298 ++++ drivers/gpu/nova-core/nova_core.rs | 1 + drivers/gpu/nova-core/regs.rs | 5 + drivers/gpu/tests/Makefile | 3 + .../gpu_buddy_test.c} | 390 ++--- drivers/gpu/tests/gpu_random.c | 48 + drivers/gpu/tests/gpu_random.h | 28 + drivers/video/Kconfig | 2 + include/drm/drm_buddy.h | 163 +- include/linux/gpu_buddy.h | 177 +++ rust/bindings/bindings_helper.h | 11 + rust/helpers/gpu.c | 23 + rust/helpers/helpers.c | 2 + rust/helpers/list.c | 12 + rust/kernel/clist.rs | 357 +++++ rust/kernel/gpu/buddy.rs | 518 +++++++ rust/kernel/gpu/mod.rs | 5 + rust/kernel/lib.rs | 3 + 50 files changed, 3385 insertions(+), 1800 deletions(-) create mode 100644 Documentation/gpu/nova/core/pramin.rst create mode 100644 drivers/gpu/Kconfig create mode 100644 drivers/gpu/buddy.c create mode 100644 drivers/gpu/nova-core/mm/mod.rs create mode 100644 drivers/gpu/nova-core/mm/pramin.rs create mode 100644 drivers/gpu/tests/Makefile rename drivers/gpu/{drm/tests/drm_buddy_test.c => tests/gpu_buddy_test.c} (68%) create mode 100644 drivers/gpu/tests/gpu_random.c create mode 100644 drivers/gpu/tests/gpu_random.h create mode 100644 include/linux/gpu_buddy.h create mode 100644 rust/helpers/gpu.c create mode 100644 rust/helpers/list.c create mode 100644 rust/kernel/clist.rs create mode 100644 rust/kernel/gpu/buddy.rs create mode 100644 rust/kernel/gpu/mod.rs -- 2.34.1 ^ permalink raw reply [flat|nested] 23+ messages in thread
* [PATCH RFC v5 1/6] rust: clist: Add support to interface with C linked lists 2025-12-19 20:37 ` Joel Fernandes @ 2025-12-19 20:38 ` Joel Fernandes -1 siblings, 0 replies; 23+ messages in thread From: Joel Fernandes @ 2025-12-19 20:38 UTC (permalink / raw) To: Maarten Lankhorst, Maxime Ripard, Thomas Zimmermann, David Airlie, Simona Vetter, Jonathan Corbet, Alex Deucher, Christian König, Jani Nikula, Joonas Lahtinen, Rodrigo Vivi, Tvrtko Ursulin, Huang Rui, Matthew Auld, Matthew Brost, Lucas De Marchi, Thomas Hellström, Helge Deller Cc: Danilo Krummrich, Alice Ryhl, Miguel Ojeda, Alex Gaynor, Boqun Feng, Gary Guo, Björn Roy Baron, Benno Lossin, Andreas Hindborg, Trevor Gross, John Hubbard, Alistair Popple, Timur Tabi, Edwin Peer, Alexandre Courbot, Andrea Righi, Philipp Stanner, Elle Rhumsaa, Daniel Almeida, joel, nouveau, dri-devel, rust-for-linux, linux-kernel, linux-doc, amd-gfx, intel-gfx, intel-xe, linux-fbdev, Joel Fernandes Add a new module `clist` for working with C's doubly circular linked lists. Provide low-level iteration over list nodes. Typed iteration over actual items is provided with a `clist_create` macro to assist in creation of the `Clist` type. Signed-off-by: Joel Fernandes <joelagnelf@nvidia.com> --- MAINTAINERS | 7 + rust/helpers/helpers.c | 1 + rust/helpers/list.c | 12 ++ rust/kernel/clist.rs | 357 +++++++++++++++++++++++++++++++++++++++++ rust/kernel/lib.rs | 1 + 5 files changed, 378 insertions(+) create mode 100644 rust/helpers/list.c create mode 100644 rust/kernel/clist.rs diff --git a/MAINTAINERS b/MAINTAINERS index 5b11839cba9d..1b72e539ab34 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -22928,6 +22928,13 @@ F: rust/kernel/init.rs F: rust/pin-init/ K: \bpin-init\b|pin_init\b|PinInit +RUST TO C LIST INTERFACES +M: Joel Fernandes <joelagnelf@nvidia.com> +M: Alexandre Courbot <acourbot@nvidia.com> +L: rust-for-linux@vger.kernel.org +S: Maintained +F: rust/kernel/clist.rs + RXRPC SOCKETS (AF_RXRPC) M: David Howells <dhowells@redhat.com> M: Marc Dionne <marc.dionne@auristor.com> diff --git a/rust/helpers/helpers.c b/rust/helpers/helpers.c index 79c72762ad9c..634fa2386bbb 100644 --- a/rust/helpers/helpers.c +++ b/rust/helpers/helpers.c @@ -32,6 +32,7 @@ #include "io.c" #include "jump_label.c" #include "kunit.c" +#include "list.c" #include "maple_tree.c" #include "mm.c" #include "mutex.c" diff --git a/rust/helpers/list.c b/rust/helpers/list.c new file mode 100644 index 000000000000..6044979c7a2e --- /dev/null +++ b/rust/helpers/list.c @@ -0,0 +1,12 @@ +// SPDX-License-Identifier: GPL-2.0 + +/* + * Helpers for C Circular doubly linked list implementation. + */ + +#include <linux/list.h> + +void rust_helper_list_add_tail(struct list_head *new, struct list_head *head) +{ + list_add_tail(new, head); +} diff --git a/rust/kernel/clist.rs b/rust/kernel/clist.rs new file mode 100644 index 000000000000..b4ee3149903a --- /dev/null +++ b/rust/kernel/clist.rs @@ -0,0 +1,357 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! A C doubly circular intrusive linked list interface for rust code. +//! +//! # Examples +//! +//! ``` +//! use kernel::{ +//! bindings, +//! clist::init_list_head, +//! clist_create, +//! types::Opaque, // +//! }; +//! # // Create test list with values (0, 10, 20) - normally done by C code but it is +//! # // emulated here for doctests using the C bindings. +//! # use core::mem::MaybeUninit; +//! # +//! # /// C struct with embedded `list_head` (typically will be allocated by C code). +//! # #[repr(C)] +//! # pub(crate) struct SampleItemC { +//! # pub value: i32, +//! # pub link: bindings::list_head, +//! # } +//! # +//! # let mut head = MaybeUninit::<bindings::list_head>::uninit(); +//! # +//! # let head = head.as_mut_ptr(); +//! # // SAFETY: head and all the items are test objects allocated in this scope. +//! # unsafe { init_list_head(head) }; +//! # +//! # let mut items = [ +//! # MaybeUninit::<SampleItemC>::uninit(), +//! # MaybeUninit::<SampleItemC>::uninit(), +//! # MaybeUninit::<SampleItemC>::uninit(), +//! # ]; +//! # +//! # for (i, item) in items.iter_mut().enumerate() { +//! # let ptr = item.as_mut_ptr(); +//! # // SAFETY: pointers are to allocated test objects with a list_head field. +//! # unsafe { +//! # (*ptr).value = i as i32 * 10; +//! # // addr_of_mut!() computes address of link directly as link is uninitialized. +//! # init_list_head(core::ptr::addr_of_mut!((*ptr).link)); +//! # bindings::list_add_tail(&mut (*ptr).link, head); +//! # } +//! # } +//! +//! // Rust wrapper for the C struct. +//! // The list item struct in this example is defined in C code as: +//! // struct SampleItemC { +//! // int value; +//! // struct list_head link; +//! // }; +//! // +//! #[repr(transparent)] +//! pub(crate) struct Item(Opaque<SampleItemC>); +//! +//! impl Item { +//! pub(crate) fn value(&self) -> i32 { +//! // SAFETY: [`Item`] has same layout as [`SampleItemC`]. +//! unsafe { (*self.0.get()).value } +//! } +//! } +//! +//! // Create typed [`CList`] from sentinel head. +//! // SAFETY: head is valid, items are [`SampleItemC`] with embedded `link` field. +//! let list = unsafe { clist_create!(head, Item, SampleItemC, link) }; +//! +//! // Iterate directly over typed items. +//! let mut found_0 = false; +//! let mut found_10 = false; +//! let mut found_20 = false; +//! +//! for item in list.iter() { +//! let val = item.value(); +//! if val == 0 { found_0 = true; } +//! if val == 10 { found_10 = true; } +//! if val == 20 { found_20 = true; } +//! } +//! +//! assert!(found_0 && found_10 && found_20); +//! ``` + +use core::{ + iter::FusedIterator, + marker::PhantomData, // +}; + +use crate::{ + bindings, + types::Opaque, // +}; + +use pin_init::PinInit; + +/// Initialize a `list_head` object to point to itself. +/// +/// # Safety +/// +/// `list` must be a valid pointer to a `list_head` object. +#[inline] +pub unsafe fn init_list_head(list: *mut bindings::list_head) { + // SAFETY: Caller guarantees `list` is a valid pointer to a `list_head`. + unsafe { + (*list).next = list; + (*list).prev = list; + } +} + +/// Wraps a `list_head` object for use in intrusive linked lists. +/// +/// # Invariants +/// +/// - [`CListHead`] represents an allocated and valid `list_head` structure. +/// - Once a ClistHead is created in Rust, it will not be modified by non-Rust code. +/// - All `list_head` for individual items are not modified for the lifetime of [`CListHead`]. +#[repr(transparent)] +pub struct CListHead(Opaque<bindings::list_head>); + +impl CListHead { + /// Create a `&CListHead` reference from a raw `list_head` pointer. + /// + /// # Safety + /// + /// - `ptr` must be a valid pointer to an allocated and initialized `list_head` structure. + /// - `ptr` must remain valid and unmodified for the lifetime `'a`. + #[inline] + pub unsafe fn from_raw<'a>(ptr: *mut bindings::list_head) -> &'a Self { + // SAFETY: + // - [`CListHead`] has same layout as `list_head`. + // - `ptr` is valid and unmodified for 'a. + unsafe { &*ptr.cast() } + } + + /// Get the raw `list_head` pointer. + #[inline] + pub fn as_raw(&self) -> *mut bindings::list_head { + self.0.get() + } + + /// Get the next [`CListHead`] in the list. + #[inline] + pub fn next(&self) -> &Self { + let raw = self.as_raw(); + // SAFETY: + // - `self.as_raw()` is valid per type invariants. + // - The `next` pointer is guaranteed to be non-NULL. + unsafe { Self::from_raw((*raw).next) } + } + + /// Get the previous [`CListHead`] in the list. + #[inline] + pub fn prev(&self) -> &Self { + let raw = self.as_raw(); + // SAFETY: + // - self.as_raw() is valid per type invariants. + // - The `prev` pointer is guaranteed to be non-NULL. + unsafe { Self::from_raw((*raw).prev) } + } + + /// Check if this node is linked in a list (not isolated). + #[inline] + pub fn is_linked(&self) -> bool { + let raw = self.as_raw(); + // SAFETY: self.as_raw() is valid per type invariants. + unsafe { (*raw).next != raw && (*raw).prev != raw } + } + + /// Fallible pin-initializer that initializes and then calls user closure. + /// + /// Initializes the list head first, then passes `&CListHead` to the closure. + /// This hides the raw FFI pointer from the user. + pub fn try_init<E>( + init_func: impl FnOnce(&CListHead) -> Result<(), E>, + ) -> impl PinInit<Self, E> { + // SAFETY: init_list_head initializes the list_head to point to itself. + // After initialization, we create a reference to pass to the closure. + unsafe { + pin_init::pin_init_from_closure(move |slot: *mut Self| { + init_list_head(slot.cast()); + // SAFETY: slot is now initialized, safe to create reference. + init_func(&*slot) + }) + } + } +} + +// SAFETY: [`CListHead`] can be sent to any thread. +unsafe impl Send for CListHead {} + +// SAFETY: [`CListHead`] can be shared among threads as it is not modified +// by non-Rust code per type invariants. +unsafe impl Sync for CListHead {} + +impl PartialEq for CListHead { + fn eq(&self, other: &Self) -> bool { + self.as_raw() == other.as_raw() + } +} + +impl Eq for CListHead {} + +/// Low-level iterator over `list_head` nodes. +/// +/// An iterator used to iterate over a C intrusive linked list (`list_head`). Caller has to +/// perform conversion of returned [`CListHead`] to an item (using `container_of` macro or similar). +/// +/// # Invariants +/// +/// [`CListHeadIter`] is iterating over an allocated, initialized and valid list. +struct CListHeadIter<'a> { + current_head: &'a CListHead, + list_head: &'a CListHead, +} + +impl<'a> Iterator for CListHeadIter<'a> { + type Item = &'a CListHead; + + #[inline] + fn next(&mut self) -> Option<Self::Item> { + // Advance to next node. + let next = self.current_head.next(); + + // Check if we've circled back to the sentinel head. + if next == self.list_head { + None + } else { + self.current_head = next; + Some(self.current_head) + } + } +} + +impl<'a> FusedIterator for CListHeadIter<'a> {} + +/// A typed C linked list with a sentinel head. +/// +/// A sentinel head represents the entire linked list and can be used for +/// iteration over items of type `T`, it is not associated with a specific item. +/// +/// The const generic `OFFSET` specifies the byte offset of the `list_head` field within +/// the struct that `T` wraps. +/// +/// # Invariants +/// +/// - `head` is an allocated and valid C `list_head` structure that is the list's sentinel. +/// - `OFFSET` is the byte offset of the `list_head` field within the struct that `T` wraps. +/// - All the list's `list_head` nodes are allocated and have valid next/prev pointers. +/// - The underlying `list_head` (and entire list) is not modified for the lifetime `'a`. +pub struct CList<'a, T, const OFFSET: usize> { + head: &'a CListHead, + _phantom: PhantomData<&'a T>, +} + +impl<'a, T, const OFFSET: usize> CList<'a, T, OFFSET> { + /// Create a typed [`CList`] from a raw sentinel `list_head` pointer. + /// + /// # Safety + /// + /// - `ptr` must be a valid pointer to an allocated and initialized `list_head` structure + /// representing a list sentinel. + /// - `ptr` must remain valid and unmodified for the lifetime `'a`. + /// - The list must contain items where the `list_head` field is at byte offset `OFFSET`. + /// - `T` must be `#[repr(transparent)]` over the C struct. + #[inline] + pub unsafe fn from_raw(ptr: *mut bindings::list_head) -> Self { + Self { + // SAFETY: Caller guarantees `ptr` is a valid, sentinel `list_head` object. + head: unsafe { CListHead::from_raw(ptr) }, + _phantom: PhantomData, + } + } + + /// Get the raw sentinel `list_head` pointer. + #[inline] + pub fn as_raw(&self) -> *mut bindings::list_head { + self.head.as_raw() + } + + /// Check if the list is empty. + #[inline] + pub fn is_empty(&self) -> bool { + let raw = self.as_raw(); + // SAFETY: self.as_raw() is valid per type invariants. + unsafe { (*raw).next == raw } + } + + /// Create an iterator over typed items. + #[inline] + pub fn iter(&self) -> CListIter<'a, T, OFFSET> { + CListIter { + head_iter: CListHeadIter { + current_head: self.head, + list_head: self.head, + }, + _phantom: PhantomData, + } + } +} + +/// High-level iterator over typed list items. +pub struct CListIter<'a, T, const OFFSET: usize> { + head_iter: CListHeadIter<'a>, + _phantom: PhantomData<&'a T>, +} + +impl<'a, T, const OFFSET: usize> Iterator for CListIter<'a, T, OFFSET> { + type Item = &'a T; + + fn next(&mut self) -> Option<Self::Item> { + let head = self.head_iter.next()?; + + // Convert to item using OFFSET. + // SAFETY: `item_ptr` calculation from `OFFSET` (calculated using offset_of!) + // is valid per invariants. + Some(unsafe { &*head.as_raw().byte_sub(OFFSET).cast::<T>() }) + } +} + +impl<'a, T, const OFFSET: usize> FusedIterator for CListIter<'a, T, OFFSET> {} + +/// Create a C doubly-circular linked list interface [`CList`] from a raw `list_head` pointer. +/// +/// This macro creates a [`CList<T, OFFSET>`] that can iterate over items of type `$rust_type` +/// linked via the `$field` field in the underlying C struct `$c_type`. +/// +/// # Arguments +/// +/// - `$head`: Raw pointer to the sentinel `list_head` object (`*mut bindings::list_head`). +/// - `$rust_type`: Each item's rust wrapper type. +/// - `$c_type`: Each item's C struct type that contains the embedded `list_head`. +/// - `$field`: The name of the `list_head` field within the C struct. +/// +/// # Safety +/// +/// The caller must ensure: +/// - `$head` is a valid, initialized sentinel `list_head` pointing to a list that remains +/// unmodified for the lifetime of the rust [`CList`]. +/// - The list contains items of type `$c_type` linked via an embedded `$field`. +/// - `$rust_type` is `#[repr(transparent)]` over `$c_type` or has compatible layout. +/// - The macro is called from an unsafe block. +/// +/// # Examples +/// +/// Refer to the examples in the [`crate::clist`] module documentation. +#[macro_export] +macro_rules! clist_create { + ($head:expr, $rust_type:ty, $c_type:ty, $($field:tt).+) => {{ + // Compile-time check that field path is a list_head. + let _: fn(*const $c_type) -> *const $crate::bindings::list_head = + |p| ::core::ptr::addr_of!((*p).$($field).+); + + // Calculate offset and create `CList`. + const OFFSET: usize = ::core::mem::offset_of!($c_type, $($field).+); + $crate::clist::CList::<$rust_type, OFFSET>::from_raw($head) + }}; +} diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs index f812cf120042..cd7e6a1055b0 100644 --- a/rust/kernel/lib.rs +++ b/rust/kernel/lib.rs @@ -75,6 +75,7 @@ pub mod bug; #[doc(hidden)] pub mod build_assert; +pub mod clist; pub mod clk; #[cfg(CONFIG_CONFIGFS_FS)] pub mod configfs; -- 2.34.1 ^ permalink raw reply related [flat|nested] 23+ messages in thread
* [PATCH RFC v5 1/6] rust: clist: Add support to interface with C linked lists @ 2025-12-19 20:38 ` Joel Fernandes 0 siblings, 0 replies; 23+ messages in thread From: Joel Fernandes @ 2025-12-19 20:38 UTC (permalink / raw) To: Maarten Lankhorst, Maxime Ripard, Thomas Zimmermann, David Airlie, Simona Vetter, Jonathan Corbet, Alex Deucher, Christian König, Jani Nikula, Joonas Lahtinen, Rodrigo Vivi, Tvrtko Ursulin, Huang Rui, Matthew Auld, Matthew Brost, Lucas De Marchi, Thomas Hellström, Helge Deller Cc: Danilo Krummrich, Alice Ryhl, Miguel Ojeda, Alex Gaynor, Boqun Feng, Gary Guo, Björn Roy Baron, Benno Lossin, Andreas Hindborg, Trevor Gross, Alistair Popple, Alexandre Courbot, Andrea Righi, Philipp Stanner, Elle Rhumsaa, Daniel Almeida, joel, nouveau, dri-devel, rust-for-linux, linux-kernel, linux-doc, amd-gfx, intel-gfx, intel-xe, linux-fbdev, Joel Fernandes Add a new module `clist` for working with C's doubly circular linked lists. Provide low-level iteration over list nodes. Typed iteration over actual items is provided with a `clist_create` macro to assist in creation of the `Clist` type. Signed-off-by: Joel Fernandes <joelagnelf@nvidia.com> --- MAINTAINERS | 7 + rust/helpers/helpers.c | 1 + rust/helpers/list.c | 12 ++ rust/kernel/clist.rs | 357 +++++++++++++++++++++++++++++++++++++++++ rust/kernel/lib.rs | 1 + 5 files changed, 378 insertions(+) create mode 100644 rust/helpers/list.c create mode 100644 rust/kernel/clist.rs diff --git a/MAINTAINERS b/MAINTAINERS index 5b11839cba9d..1b72e539ab34 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -22928,6 +22928,13 @@ F: rust/kernel/init.rs F: rust/pin-init/ K: \bpin-init\b|pin_init\b|PinInit +RUST TO C LIST INTERFACES +M: Joel Fernandes <joelagnelf@nvidia.com> +M: Alexandre Courbot <acourbot@nvidia.com> +L: rust-for-linux@vger.kernel.org +S: Maintained +F: rust/kernel/clist.rs + RXRPC SOCKETS (AF_RXRPC) M: David Howells <dhowells@redhat.com> M: Marc Dionne <marc.dionne@auristor.com> diff --git a/rust/helpers/helpers.c b/rust/helpers/helpers.c index 79c72762ad9c..634fa2386bbb 100644 --- a/rust/helpers/helpers.c +++ b/rust/helpers/helpers.c @@ -32,6 +32,7 @@ #include "io.c" #include "jump_label.c" #include "kunit.c" +#include "list.c" #include "maple_tree.c" #include "mm.c" #include "mutex.c" diff --git a/rust/helpers/list.c b/rust/helpers/list.c new file mode 100644 index 000000000000..6044979c7a2e --- /dev/null +++ b/rust/helpers/list.c @@ -0,0 +1,12 @@ +// SPDX-License-Identifier: GPL-2.0 + +/* + * Helpers for C Circular doubly linked list implementation. + */ + +#include <linux/list.h> + +void rust_helper_list_add_tail(struct list_head *new, struct list_head *head) +{ + list_add_tail(new, head); +} diff --git a/rust/kernel/clist.rs b/rust/kernel/clist.rs new file mode 100644 index 000000000000..b4ee3149903a --- /dev/null +++ b/rust/kernel/clist.rs @@ -0,0 +1,357 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! A C doubly circular intrusive linked list interface for rust code. +//! +//! # Examples +//! +//! ``` +//! use kernel::{ +//! bindings, +//! clist::init_list_head, +//! clist_create, +//! types::Opaque, // +//! }; +//! # // Create test list with values (0, 10, 20) - normally done by C code but it is +//! # // emulated here for doctests using the C bindings. +//! # use core::mem::MaybeUninit; +//! # +//! # /// C struct with embedded `list_head` (typically will be allocated by C code). +//! # #[repr(C)] +//! # pub(crate) struct SampleItemC { +//! # pub value: i32, +//! # pub link: bindings::list_head, +//! # } +//! # +//! # let mut head = MaybeUninit::<bindings::list_head>::uninit(); +//! # +//! # let head = head.as_mut_ptr(); +//! # // SAFETY: head and all the items are test objects allocated in this scope. +//! # unsafe { init_list_head(head) }; +//! # +//! # let mut items = [ +//! # MaybeUninit::<SampleItemC>::uninit(), +//! # MaybeUninit::<SampleItemC>::uninit(), +//! # MaybeUninit::<SampleItemC>::uninit(), +//! # ]; +//! # +//! # for (i, item) in items.iter_mut().enumerate() { +//! # let ptr = item.as_mut_ptr(); +//! # // SAFETY: pointers are to allocated test objects with a list_head field. +//! # unsafe { +//! # (*ptr).value = i as i32 * 10; +//! # // addr_of_mut!() computes address of link directly as link is uninitialized. +//! # init_list_head(core::ptr::addr_of_mut!((*ptr).link)); +//! # bindings::list_add_tail(&mut (*ptr).link, head); +//! # } +//! # } +//! +//! // Rust wrapper for the C struct. +//! // The list item struct in this example is defined in C code as: +//! // struct SampleItemC { +//! // int value; +//! // struct list_head link; +//! // }; +//! // +//! #[repr(transparent)] +//! pub(crate) struct Item(Opaque<SampleItemC>); +//! +//! impl Item { +//! pub(crate) fn value(&self) -> i32 { +//! // SAFETY: [`Item`] has same layout as [`SampleItemC`]. +//! unsafe { (*self.0.get()).value } +//! } +//! } +//! +//! // Create typed [`CList`] from sentinel head. +//! // SAFETY: head is valid, items are [`SampleItemC`] with embedded `link` field. +//! let list = unsafe { clist_create!(head, Item, SampleItemC, link) }; +//! +//! // Iterate directly over typed items. +//! let mut found_0 = false; +//! let mut found_10 = false; +//! let mut found_20 = false; +//! +//! for item in list.iter() { +//! let val = item.value(); +//! if val == 0 { found_0 = true; } +//! if val == 10 { found_10 = true; } +//! if val == 20 { found_20 = true; } +//! } +//! +//! assert!(found_0 && found_10 && found_20); +//! ``` + +use core::{ + iter::FusedIterator, + marker::PhantomData, // +}; + +use crate::{ + bindings, + types::Opaque, // +}; + +use pin_init::PinInit; + +/// Initialize a `list_head` object to point to itself. +/// +/// # Safety +/// +/// `list` must be a valid pointer to a `list_head` object. +#[inline] +pub unsafe fn init_list_head(list: *mut bindings::list_head) { + // SAFETY: Caller guarantees `list` is a valid pointer to a `list_head`. + unsafe { + (*list).next = list; + (*list).prev = list; + } +} + +/// Wraps a `list_head` object for use in intrusive linked lists. +/// +/// # Invariants +/// +/// - [`CListHead`] represents an allocated and valid `list_head` structure. +/// - Once a ClistHead is created in Rust, it will not be modified by non-Rust code. +/// - All `list_head` for individual items are not modified for the lifetime of [`CListHead`]. +#[repr(transparent)] +pub struct CListHead(Opaque<bindings::list_head>); + +impl CListHead { + /// Create a `&CListHead` reference from a raw `list_head` pointer. + /// + /// # Safety + /// + /// - `ptr` must be a valid pointer to an allocated and initialized `list_head` structure. + /// - `ptr` must remain valid and unmodified for the lifetime `'a`. + #[inline] + pub unsafe fn from_raw<'a>(ptr: *mut bindings::list_head) -> &'a Self { + // SAFETY: + // - [`CListHead`] has same layout as `list_head`. + // - `ptr` is valid and unmodified for 'a. + unsafe { &*ptr.cast() } + } + + /// Get the raw `list_head` pointer. + #[inline] + pub fn as_raw(&self) -> *mut bindings::list_head { + self.0.get() + } + + /// Get the next [`CListHead`] in the list. + #[inline] + pub fn next(&self) -> &Self { + let raw = self.as_raw(); + // SAFETY: + // - `self.as_raw()` is valid per type invariants. + // - The `next` pointer is guaranteed to be non-NULL. + unsafe { Self::from_raw((*raw).next) } + } + + /// Get the previous [`CListHead`] in the list. + #[inline] + pub fn prev(&self) -> &Self { + let raw = self.as_raw(); + // SAFETY: + // - self.as_raw() is valid per type invariants. + // - The `prev` pointer is guaranteed to be non-NULL. + unsafe { Self::from_raw((*raw).prev) } + } + + /// Check if this node is linked in a list (not isolated). + #[inline] + pub fn is_linked(&self) -> bool { + let raw = self.as_raw(); + // SAFETY: self.as_raw() is valid per type invariants. + unsafe { (*raw).next != raw && (*raw).prev != raw } + } + + /// Fallible pin-initializer that initializes and then calls user closure. + /// + /// Initializes the list head first, then passes `&CListHead` to the closure. + /// This hides the raw FFI pointer from the user. + pub fn try_init<E>( + init_func: impl FnOnce(&CListHead) -> Result<(), E>, + ) -> impl PinInit<Self, E> { + // SAFETY: init_list_head initializes the list_head to point to itself. + // After initialization, we create a reference to pass to the closure. + unsafe { + pin_init::pin_init_from_closure(move |slot: *mut Self| { + init_list_head(slot.cast()); + // SAFETY: slot is now initialized, safe to create reference. + init_func(&*slot) + }) + } + } +} + +// SAFETY: [`CListHead`] can be sent to any thread. +unsafe impl Send for CListHead {} + +// SAFETY: [`CListHead`] can be shared among threads as it is not modified +// by non-Rust code per type invariants. +unsafe impl Sync for CListHead {} + +impl PartialEq for CListHead { + fn eq(&self, other: &Self) -> bool { + self.as_raw() == other.as_raw() + } +} + +impl Eq for CListHead {} + +/// Low-level iterator over `list_head` nodes. +/// +/// An iterator used to iterate over a C intrusive linked list (`list_head`). Caller has to +/// perform conversion of returned [`CListHead`] to an item (using `container_of` macro or similar). +/// +/// # Invariants +/// +/// [`CListHeadIter`] is iterating over an allocated, initialized and valid list. +struct CListHeadIter<'a> { + current_head: &'a CListHead, + list_head: &'a CListHead, +} + +impl<'a> Iterator for CListHeadIter<'a> { + type Item = &'a CListHead; + + #[inline] + fn next(&mut self) -> Option<Self::Item> { + // Advance to next node. + let next = self.current_head.next(); + + // Check if we've circled back to the sentinel head. + if next == self.list_head { + None + } else { + self.current_head = next; + Some(self.current_head) + } + } +} + +impl<'a> FusedIterator for CListHeadIter<'a> {} + +/// A typed C linked list with a sentinel head. +/// +/// A sentinel head represents the entire linked list and can be used for +/// iteration over items of type `T`, it is not associated with a specific item. +/// +/// The const generic `OFFSET` specifies the byte offset of the `list_head` field within +/// the struct that `T` wraps. +/// +/// # Invariants +/// +/// - `head` is an allocated and valid C `list_head` structure that is the list's sentinel. +/// - `OFFSET` is the byte offset of the `list_head` field within the struct that `T` wraps. +/// - All the list's `list_head` nodes are allocated and have valid next/prev pointers. +/// - The underlying `list_head` (and entire list) is not modified for the lifetime `'a`. +pub struct CList<'a, T, const OFFSET: usize> { + head: &'a CListHead, + _phantom: PhantomData<&'a T>, +} + +impl<'a, T, const OFFSET: usize> CList<'a, T, OFFSET> { + /// Create a typed [`CList`] from a raw sentinel `list_head` pointer. + /// + /// # Safety + /// + /// - `ptr` must be a valid pointer to an allocated and initialized `list_head` structure + /// representing a list sentinel. + /// - `ptr` must remain valid and unmodified for the lifetime `'a`. + /// - The list must contain items where the `list_head` field is at byte offset `OFFSET`. + /// - `T` must be `#[repr(transparent)]` over the C struct. + #[inline] + pub unsafe fn from_raw(ptr: *mut bindings::list_head) -> Self { + Self { + // SAFETY: Caller guarantees `ptr` is a valid, sentinel `list_head` object. + head: unsafe { CListHead::from_raw(ptr) }, + _phantom: PhantomData, + } + } + + /// Get the raw sentinel `list_head` pointer. + #[inline] + pub fn as_raw(&self) -> *mut bindings::list_head { + self.head.as_raw() + } + + /// Check if the list is empty. + #[inline] + pub fn is_empty(&self) -> bool { + let raw = self.as_raw(); + // SAFETY: self.as_raw() is valid per type invariants. + unsafe { (*raw).next == raw } + } + + /// Create an iterator over typed items. + #[inline] + pub fn iter(&self) -> CListIter<'a, T, OFFSET> { + CListIter { + head_iter: CListHeadIter { + current_head: self.head, + list_head: self.head, + }, + _phantom: PhantomData, + } + } +} + +/// High-level iterator over typed list items. +pub struct CListIter<'a, T, const OFFSET: usize> { + head_iter: CListHeadIter<'a>, + _phantom: PhantomData<&'a T>, +} + +impl<'a, T, const OFFSET: usize> Iterator for CListIter<'a, T, OFFSET> { + type Item = &'a T; + + fn next(&mut self) -> Option<Self::Item> { + let head = self.head_iter.next()?; + + // Convert to item using OFFSET. + // SAFETY: `item_ptr` calculation from `OFFSET` (calculated using offset_of!) + // is valid per invariants. + Some(unsafe { &*head.as_raw().byte_sub(OFFSET).cast::<T>() }) + } +} + +impl<'a, T, const OFFSET: usize> FusedIterator for CListIter<'a, T, OFFSET> {} + +/// Create a C doubly-circular linked list interface [`CList`] from a raw `list_head` pointer. +/// +/// This macro creates a [`CList<T, OFFSET>`] that can iterate over items of type `$rust_type` +/// linked via the `$field` field in the underlying C struct `$c_type`. +/// +/// # Arguments +/// +/// - `$head`: Raw pointer to the sentinel `list_head` object (`*mut bindings::list_head`). +/// - `$rust_type`: Each item's rust wrapper type. +/// - `$c_type`: Each item's C struct type that contains the embedded `list_head`. +/// - `$field`: The name of the `list_head` field within the C struct. +/// +/// # Safety +/// +/// The caller must ensure: +/// - `$head` is a valid, initialized sentinel `list_head` pointing to a list that remains +/// unmodified for the lifetime of the rust [`CList`]. +/// - The list contains items of type `$c_type` linked via an embedded `$field`. +/// - `$rust_type` is `#[repr(transparent)]` over `$c_type` or has compatible layout. +/// - The macro is called from an unsafe block. +/// +/// # Examples +/// +/// Refer to the examples in the [`crate::clist`] module documentation. +#[macro_export] +macro_rules! clist_create { + ($head:expr, $rust_type:ty, $c_type:ty, $($field:tt).+) => {{ + // Compile-time check that field path is a list_head. + let _: fn(*const $c_type) -> *const $crate::bindings::list_head = + |p| ::core::ptr::addr_of!((*p).$($field).+); + + // Calculate offset and create `CList`. + const OFFSET: usize = ::core::mem::offset_of!($c_type, $($field).+); + $crate::clist::CList::<$rust_type, OFFSET>::from_raw($head) + }}; +} diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs index f812cf120042..cd7e6a1055b0 100644 --- a/rust/kernel/lib.rs +++ b/rust/kernel/lib.rs @@ -75,6 +75,7 @@ pub mod bug; #[doc(hidden)] pub mod build_assert; +pub mod clist; pub mod clk; #[cfg(CONFIG_CONFIGFS_FS)] pub mod configfs; -- 2.34.1 ^ permalink raw reply related [flat|nested] 23+ messages in thread
* [PATCH RFC v5 2/6] gpu: Move DRM buddy allocator one level up 2025-12-19 20:37 ` Joel Fernandes @ 2025-12-19 20:38 ` Joel Fernandes -1 siblings, 0 replies; 23+ messages in thread From: Joel Fernandes @ 2025-12-19 20:38 UTC (permalink / raw) To: Maarten Lankhorst, Maxime Ripard, Thomas Zimmermann, David Airlie, Simona Vetter, Jonathan Corbet, Alex Deucher, Christian König, Jani Nikula, Joonas Lahtinen, Rodrigo Vivi, Tvrtko Ursulin, Huang Rui, Matthew Auld, Matthew Brost, Lucas De Marchi, Thomas Hellström, Helge Deller Cc: Danilo Krummrich, Alice Ryhl, Miguel Ojeda, Alex Gaynor, Boqun Feng, Gary Guo, Björn Roy Baron, Benno Lossin, Andreas Hindborg, Trevor Gross, John Hubbard, Alistair Popple, Timur Tabi, Edwin Peer, Alexandre Courbot, Andrea Righi, Philipp Stanner, Elle Rhumsaa, Daniel Almeida, joel, nouveau, dri-devel, rust-for-linux, linux-kernel, linux-doc, amd-gfx, intel-gfx, intel-xe, linux-fbdev, Joel Fernandes Move the DRM buddy allocator one level up so that it can be used by GPU drivers (example, nova-core) that have usecases other than DRM (such as VFIO vGPU support). Modify the API, structures and Kconfigs to use "gpu_buddy" terminology. Adapt the drivers and tests to use the new API. The commit cannot be split due to bissectability, however no functional change is intended. Verified by running K-UNIT tests and build tested various configurations. Signed-off-by: Joel Fernandes <joelagnelf@nvidia.com> --- Documentation/gpu/drm-mm.rst | 10 +- drivers/gpu/Kconfig | 13 + drivers/gpu/Makefile | 2 + drivers/gpu/buddy.c | 1310 +++++++++++++++++ drivers/gpu/drm/Kconfig | 1 + drivers/gpu/drm/Kconfig.debug | 4 +- drivers/gpu/drm/amd/amdgpu/Kconfig | 1 + drivers/gpu/drm/amd/amdgpu/amdgpu_ras.c | 2 +- .../gpu/drm/amd/amdgpu/amdgpu_res_cursor.h | 12 +- drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c | 80 +- drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.h | 20 +- drivers/gpu/drm/drm_buddy.c | 1287 +--------------- drivers/gpu/drm/i915/Kconfig | 1 + drivers/gpu/drm/i915/i915_scatterlist.c | 10 +- drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 55 +- drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 6 +- .../drm/i915/selftests/intel_memory_region.c | 20 +- drivers/gpu/drm/tests/Makefile | 1 - .../gpu/drm/ttm/tests/ttm_bo_validate_test.c | 5 +- drivers/gpu/drm/ttm/tests/ttm_mock_manager.c | 18 +- drivers/gpu/drm/ttm/tests/ttm_mock_manager.h | 4 +- drivers/gpu/drm/xe/Kconfig | 1 + drivers/gpu/drm/xe/xe_res_cursor.h | 34 +- drivers/gpu/drm/xe/xe_svm.c | 12 +- drivers/gpu/drm/xe/xe_ttm_vram_mgr.c | 73 +- drivers/gpu/drm/xe/xe_ttm_vram_mgr_types.h | 4 +- drivers/gpu/tests/Makefile | 3 + .../gpu_buddy_test.c} | 390 ++--- drivers/gpu/tests/gpu_random.c | 48 + drivers/gpu/tests/gpu_random.h | 28 + drivers/video/Kconfig | 2 + include/drm/drm_buddy.h | 163 +- include/linux/gpu_buddy.h | 177 +++ 33 files changed, 1997 insertions(+), 1800 deletions(-) create mode 100644 drivers/gpu/Kconfig create mode 100644 drivers/gpu/buddy.c create mode 100644 drivers/gpu/tests/Makefile rename drivers/gpu/{drm/tests/drm_buddy_test.c => tests/gpu_buddy_test.c} (68%) create mode 100644 drivers/gpu/tests/gpu_random.c create mode 100644 drivers/gpu/tests/gpu_random.h create mode 100644 include/linux/gpu_buddy.h diff --git a/Documentation/gpu/drm-mm.rst b/Documentation/gpu/drm-mm.rst index d55751cad67c..8e0d31230b29 100644 --- a/Documentation/gpu/drm-mm.rst +++ b/Documentation/gpu/drm-mm.rst @@ -509,8 +509,14 @@ DRM GPUVM Function References DRM Buddy Allocator =================== -DRM Buddy Function References ------------------------------ +Buddy Allocator Function References (GPU buddy) +----------------------------------------------- + +.. kernel-doc:: drivers/gpu/buddy.c + :export: + +DRM Buddy Specific Logging Function References +---------------------------------------------- .. kernel-doc:: drivers/gpu/drm/drm_buddy.c :export: diff --git a/drivers/gpu/Kconfig b/drivers/gpu/Kconfig new file mode 100644 index 000000000000..59bac03b0df6 --- /dev/null +++ b/drivers/gpu/Kconfig @@ -0,0 +1,13 @@ +# SPDX-License-Identifier: GPL-2.0 + +config GPU_BUDDY + tristate + help + A page based buddy allocator for GPU memory. + +config GPU_BUDDY_KUNIT_TEST + tristate "KUnit tests for GPU buddy allocator" if !KUNIT_ALL_TESTS + depends on GPU_BUDDY && KUNIT + default KUNIT_ALL_TESTS + help + KUnit tests for the GPU buddy allocator. diff --git a/drivers/gpu/Makefile b/drivers/gpu/Makefile index 36a54d456630..5063caccabdf 100644 --- a/drivers/gpu/Makefile +++ b/drivers/gpu/Makefile @@ -6,3 +6,5 @@ obj-y += host1x/ drm/ vga/ obj-$(CONFIG_IMX_IPUV3_CORE) += ipu-v3/ obj-$(CONFIG_TRACE_GPU_MEM) += trace/ obj-$(CONFIG_NOVA_CORE) += nova-core/ +obj-$(CONFIG_GPU_BUDDY) += buddy.o +obj-y += tests/ diff --git a/drivers/gpu/buddy.c b/drivers/gpu/buddy.c new file mode 100644 index 000000000000..1347c0436617 --- /dev/null +++ b/drivers/gpu/buddy.c @@ -0,0 +1,1310 @@ +// SPDX-License-Identifier: MIT +/* + * Copyright © 2021 Intel Corporation + */ + +#include <kunit/test-bug.h> + +#include <linux/export.h> +#include <linux/gpu_buddy.h> +#include <linux/kmemleak.h> +#include <linux/module.h> +#include <linux/sizes.h> + +static struct kmem_cache *slab_blocks; + +static struct gpu_buddy_block *gpu_block_alloc(struct gpu_buddy *mm, + struct gpu_buddy_block *parent, + unsigned int order, + u64 offset) +{ + struct gpu_buddy_block *block; + + BUG_ON(order > GPU_BUDDY_MAX_ORDER); + + block = kmem_cache_zalloc(slab_blocks, GFP_KERNEL); + if (!block) + return NULL; + + block->header = offset; + block->header |= order; + block->parent = parent; + + RB_CLEAR_NODE(&block->rb); + + BUG_ON(block->header & GPU_BUDDY_HEADER_UNUSED); + return block; +} + +static void gpu_block_free(struct gpu_buddy *mm, + struct gpu_buddy_block *block) +{ + kmem_cache_free(slab_blocks, block); +} + +static enum gpu_buddy_free_tree +get_block_tree(struct gpu_buddy_block *block) +{ + return gpu_buddy_block_is_clear(block) ? + GPU_BUDDY_CLEAR_TREE : GPU_BUDDY_DIRTY_TREE; +} + +static struct gpu_buddy_block * +rbtree_get_free_block(const struct rb_node *node) +{ + return node ? rb_entry(node, struct gpu_buddy_block, rb) : NULL; +} + +static struct gpu_buddy_block * +rbtree_last_free_block(struct rb_root *root) +{ + return rbtree_get_free_block(rb_last(root)); +} + +static bool rbtree_is_empty(struct rb_root *root) +{ + return RB_EMPTY_ROOT(root); +} + +static bool gpu_buddy_block_offset_less(const struct gpu_buddy_block *block, + const struct gpu_buddy_block *node) +{ + return gpu_buddy_block_offset(block) < gpu_buddy_block_offset(node); +} + +static bool rbtree_block_offset_less(struct rb_node *block, + const struct rb_node *node) +{ + return gpu_buddy_block_offset_less(rbtree_get_free_block(block), + rbtree_get_free_block(node)); +} + +static void rbtree_insert(struct gpu_buddy *mm, + struct gpu_buddy_block *block, + enum gpu_buddy_free_tree tree) +{ + rb_add(&block->rb, + &mm->free_trees[tree][gpu_buddy_block_order(block)], + rbtree_block_offset_less); +} + +static void rbtree_remove(struct gpu_buddy *mm, + struct gpu_buddy_block *block) +{ + unsigned int order = gpu_buddy_block_order(block); + enum gpu_buddy_free_tree tree; + struct rb_root *root; + + tree = get_block_tree(block); + root = &mm->free_trees[tree][order]; + + rb_erase(&block->rb, root); + RB_CLEAR_NODE(&block->rb); +} + +static void clear_reset(struct gpu_buddy_block *block) +{ + block->header &= ~GPU_BUDDY_HEADER_CLEAR; +} + +static void mark_cleared(struct gpu_buddy_block *block) +{ + block->header |= GPU_BUDDY_HEADER_CLEAR; +} + +static void mark_allocated(struct gpu_buddy *mm, + struct gpu_buddy_block *block) +{ + block->header &= ~GPU_BUDDY_HEADER_STATE; + block->header |= GPU_BUDDY_ALLOCATED; + + rbtree_remove(mm, block); +} + +static void mark_free(struct gpu_buddy *mm, + struct gpu_buddy_block *block) +{ + enum gpu_buddy_free_tree tree; + + block->header &= ~GPU_BUDDY_HEADER_STATE; + block->header |= GPU_BUDDY_FREE; + + tree = get_block_tree(block); + rbtree_insert(mm, block, tree); +} + +static void mark_split(struct gpu_buddy *mm, + struct gpu_buddy_block *block) +{ + block->header &= ~GPU_BUDDY_HEADER_STATE; + block->header |= GPU_BUDDY_SPLIT; + + rbtree_remove(mm, block); +} + +static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2) +{ + return s1 <= e2 && e1 >= s2; +} + +static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2) +{ + return s1 <= s2 && e1 >= e2; +} + +static struct gpu_buddy_block * +__get_buddy(struct gpu_buddy_block *block) +{ + struct gpu_buddy_block *parent; + + parent = block->parent; + if (!parent) + return NULL; + + if (parent->left == block) + return parent->right; + + return parent->left; +} + +static unsigned int __gpu_buddy_free(struct gpu_buddy *mm, + struct gpu_buddy_block *block, + bool force_merge) +{ + struct gpu_buddy_block *parent; + unsigned int order; + + while ((parent = block->parent)) { + struct gpu_buddy_block *buddy; + + buddy = __get_buddy(block); + + if (!gpu_buddy_block_is_free(buddy)) + break; + + if (!force_merge) { + /* + * Check the block and its buddy clear state and exit + * the loop if they both have the dissimilar state. + */ + if (gpu_buddy_block_is_clear(block) != + gpu_buddy_block_is_clear(buddy)) + break; + + if (gpu_buddy_block_is_clear(block)) + mark_cleared(parent); + } + + rbtree_remove(mm, buddy); + if (force_merge && gpu_buddy_block_is_clear(buddy)) + mm->clear_avail -= gpu_buddy_block_size(mm, buddy); + + gpu_block_free(mm, block); + gpu_block_free(mm, buddy); + + block = parent; + } + + order = gpu_buddy_block_order(block); + mark_free(mm, block); + + return order; +} + +static int __force_merge(struct gpu_buddy *mm, + u64 start, + u64 end, + unsigned int min_order) +{ + unsigned int tree, order; + int i; + + if (!min_order) + return -ENOMEM; + + if (min_order > mm->max_order) + return -EINVAL; + + for_each_free_tree(tree) { + for (i = min_order - 1; i >= 0; i--) { + struct rb_node *iter = rb_last(&mm->free_trees[tree][i]); + + while (iter) { + struct gpu_buddy_block *block, *buddy; + u64 block_start, block_end; + + block = rbtree_get_free_block(iter); + iter = rb_prev(iter); + + if (!block || !block->parent) + continue; + + block_start = gpu_buddy_block_offset(block); + block_end = block_start + gpu_buddy_block_size(mm, block) - 1; + + if (!contains(start, end, block_start, block_end)) + continue; + + buddy = __get_buddy(block); + if (!gpu_buddy_block_is_free(buddy)) + continue; + + WARN_ON(gpu_buddy_block_is_clear(block) == + gpu_buddy_block_is_clear(buddy)); + + /* + * Advance to the next node when the current node is the buddy, + * as freeing the block will also remove its buddy from the tree. + */ + if (iter == &buddy->rb) + iter = rb_prev(iter); + + rbtree_remove(mm, block); + if (gpu_buddy_block_is_clear(block)) + mm->clear_avail -= gpu_buddy_block_size(mm, block); + + order = __gpu_buddy_free(mm, block, true); + if (order >= min_order) + return 0; + } + } + } + + return -ENOMEM; +} + +/** + * gpu_buddy_init - init memory manager + * + * @mm: GPU buddy manager to initialize + * @size: size in bytes to manage + * @chunk_size: minimum page size in bytes for our allocations + * + * Initializes the memory manager and its resources. + * + * Returns: + * 0 on success, error code on failure. + */ +int gpu_buddy_init(struct gpu_buddy *mm, u64 size, u64 chunk_size) +{ + unsigned int i, j, root_count = 0; + u64 offset = 0; + + if (size < chunk_size) + return -EINVAL; + + if (chunk_size < SZ_4K) + return -EINVAL; + + if (!is_power_of_2(chunk_size)) + return -EINVAL; + + size = round_down(size, chunk_size); + + mm->size = size; + mm->avail = size; + mm->clear_avail = 0; + mm->chunk_size = chunk_size; + mm->max_order = ilog2(size) - ilog2(chunk_size); + + BUG_ON(mm->max_order > GPU_BUDDY_MAX_ORDER); + + mm->free_trees = kmalloc_array(GPU_BUDDY_MAX_FREE_TREES, + sizeof(*mm->free_trees), + GFP_KERNEL); + if (!mm->free_trees) + return -ENOMEM; + + for_each_free_tree(i) { + mm->free_trees[i] = kmalloc_array(mm->max_order + 1, + sizeof(struct rb_root), + GFP_KERNEL); + if (!mm->free_trees[i]) + goto out_free_tree; + + for (j = 0; j <= mm->max_order; ++j) + mm->free_trees[i][j] = RB_ROOT; + } + + mm->n_roots = hweight64(size); + + mm->roots = kmalloc_array(mm->n_roots, + sizeof(struct gpu_buddy_block *), + GFP_KERNEL); + if (!mm->roots) + goto out_free_tree; + + /* + * Split into power-of-two blocks, in case we are given a size that is + * not itself a power-of-two. + */ + do { + struct gpu_buddy_block *root; + unsigned int order; + u64 root_size; + + order = ilog2(size) - ilog2(chunk_size); + root_size = chunk_size << order; + + root = gpu_block_alloc(mm, NULL, order, offset); + if (!root) + goto out_free_roots; + + mark_free(mm, root); + + BUG_ON(root_count > mm->max_order); + BUG_ON(gpu_buddy_block_size(mm, root) < chunk_size); + + mm->roots[root_count] = root; + + offset += root_size; + size -= root_size; + root_count++; + } while (size); + + return 0; + +out_free_roots: + while (root_count--) + gpu_block_free(mm, mm->roots[root_count]); + kfree(mm->roots); +out_free_tree: + while (i--) + kfree(mm->free_trees[i]); + kfree(mm->free_trees); + return -ENOMEM; +} +EXPORT_SYMBOL(gpu_buddy_init); + +/** + * gpu_buddy_fini - tear down the memory manager + * + * @mm: GPU buddy manager to free + * + * Cleanup memory manager resources and the freetree + */ +void gpu_buddy_fini(struct gpu_buddy *mm) +{ + u64 root_size, size, start; + unsigned int order; + int i; + + size = mm->size; + + for (i = 0; i < mm->n_roots; ++i) { + order = ilog2(size) - ilog2(mm->chunk_size); + start = gpu_buddy_block_offset(mm->roots[i]); + __force_merge(mm, start, start + size, order); + + if (WARN_ON(!gpu_buddy_block_is_free(mm->roots[i]))) + kunit_fail_current_test("buddy_fini() root"); + + gpu_block_free(mm, mm->roots[i]); + + root_size = mm->chunk_size << order; + size -= root_size; + } + + WARN_ON(mm->avail != mm->size); + + for_each_free_tree(i) + kfree(mm->free_trees[i]); + kfree(mm->roots); +} +EXPORT_SYMBOL(gpu_buddy_fini); + +static int split_block(struct gpu_buddy *mm, + struct gpu_buddy_block *block) +{ + unsigned int block_order = gpu_buddy_block_order(block) - 1; + u64 offset = gpu_buddy_block_offset(block); + + BUG_ON(!gpu_buddy_block_is_free(block)); + BUG_ON(!gpu_buddy_block_order(block)); + + block->left = gpu_block_alloc(mm, block, block_order, offset); + if (!block->left) + return -ENOMEM; + + block->right = gpu_block_alloc(mm, block, block_order, + offset + (mm->chunk_size << block_order)); + if (!block->right) { + gpu_block_free(mm, block->left); + return -ENOMEM; + } + + mark_split(mm, block); + + if (gpu_buddy_block_is_clear(block)) { + mark_cleared(block->left); + mark_cleared(block->right); + clear_reset(block); + } + + mark_free(mm, block->left); + mark_free(mm, block->right); + + return 0; +} + +/** + * gpu_get_buddy - get buddy address + * + * @block: GPU buddy block + * + * Returns the corresponding buddy block for @block, or NULL + * if this is a root block and can't be merged further. + * Requires some kind of locking to protect against + * any concurrent allocate and free operations. + */ +struct gpu_buddy_block * +gpu_get_buddy(struct gpu_buddy_block *block) +{ + return __get_buddy(block); +} +EXPORT_SYMBOL(gpu_get_buddy); + +/** + * gpu_buddy_reset_clear - reset blocks clear state + * + * @mm: GPU buddy manager + * @is_clear: blocks clear state + * + * Reset the clear state based on @is_clear value for each block + * in the freetree. + */ +void gpu_buddy_reset_clear(struct gpu_buddy *mm, bool is_clear) +{ + enum gpu_buddy_free_tree src_tree, dst_tree; + u64 root_size, size, start; + unsigned int order; + int i; + + size = mm->size; + for (i = 0; i < mm->n_roots; ++i) { + order = ilog2(size) - ilog2(mm->chunk_size); + start = gpu_buddy_block_offset(mm->roots[i]); + __force_merge(mm, start, start + size, order); + + root_size = mm->chunk_size << order; + size -= root_size; + } + + src_tree = is_clear ? GPU_BUDDY_DIRTY_TREE : GPU_BUDDY_CLEAR_TREE; + dst_tree = is_clear ? GPU_BUDDY_CLEAR_TREE : GPU_BUDDY_DIRTY_TREE; + + for (i = 0; i <= mm->max_order; ++i) { + struct rb_root *root = &mm->free_trees[src_tree][i]; + struct gpu_buddy_block *block, *tmp; + + rbtree_postorder_for_each_entry_safe(block, tmp, root, rb) { + rbtree_remove(mm, block); + if (is_clear) { + mark_cleared(block); + mm->clear_avail += gpu_buddy_block_size(mm, block); + } else { + clear_reset(block); + mm->clear_avail -= gpu_buddy_block_size(mm, block); + } + + rbtree_insert(mm, block, dst_tree); + } + } +} +EXPORT_SYMBOL(gpu_buddy_reset_clear); + +/** + * gpu_buddy_free_block - free a block + * + * @mm: GPU buddy manager + * @block: block to be freed + */ +void gpu_buddy_free_block(struct gpu_buddy *mm, + struct gpu_buddy_block *block) +{ + BUG_ON(!gpu_buddy_block_is_allocated(block)); + mm->avail += gpu_buddy_block_size(mm, block); + if (gpu_buddy_block_is_clear(block)) + mm->clear_avail += gpu_buddy_block_size(mm, block); + + __gpu_buddy_free(mm, block, false); +} +EXPORT_SYMBOL(gpu_buddy_free_block); + +static void __gpu_buddy_free_list(struct gpu_buddy *mm, + struct list_head *objects, + bool mark_clear, + bool mark_dirty) +{ + struct gpu_buddy_block *block, *on; + + WARN_ON(mark_dirty && mark_clear); + + list_for_each_entry_safe(block, on, objects, link) { + if (mark_clear) + mark_cleared(block); + else if (mark_dirty) + clear_reset(block); + gpu_buddy_free_block(mm, block); + cond_resched(); + } + INIT_LIST_HEAD(objects); +} + +static void gpu_buddy_free_list_internal(struct gpu_buddy *mm, + struct list_head *objects) +{ + /* + * Don't touch the clear/dirty bit, since allocation is still internal + * at this point. For example we might have just failed part of the + * allocation. + */ + __gpu_buddy_free_list(mm, objects, false, false); +} + +/** + * gpu_buddy_free_list - free blocks + * + * @mm: GPU buddy manager + * @objects: input list head to free blocks + * @flags: optional flags like GPU_BUDDY_CLEARED + */ +void gpu_buddy_free_list(struct gpu_buddy *mm, + struct list_head *objects, + unsigned int flags) +{ + bool mark_clear = flags & GPU_BUDDY_CLEARED; + + __gpu_buddy_free_list(mm, objects, mark_clear, !mark_clear); +} +EXPORT_SYMBOL(gpu_buddy_free_list); + +static bool block_incompatible(struct gpu_buddy_block *block, unsigned int flags) +{ + bool needs_clear = flags & GPU_BUDDY_CLEAR_ALLOCATION; + + return needs_clear != gpu_buddy_block_is_clear(block); +} + +static struct gpu_buddy_block * +__alloc_range_bias(struct gpu_buddy *mm, + u64 start, u64 end, + unsigned int order, + unsigned long flags, + bool fallback) +{ + u64 req_size = mm->chunk_size << order; + struct gpu_buddy_block *block; + struct gpu_buddy_block *buddy; + LIST_HEAD(dfs); + int err; + int i; + + end = end - 1; + + for (i = 0; i < mm->n_roots; ++i) + list_add_tail(&mm->roots[i]->tmp_link, &dfs); + + do { + u64 block_start; + u64 block_end; + + block = list_first_entry_or_null(&dfs, + struct gpu_buddy_block, + tmp_link); + if (!block) + break; + + list_del(&block->tmp_link); + + if (gpu_buddy_block_order(block) < order) + continue; + + block_start = gpu_buddy_block_offset(block); + block_end = block_start + gpu_buddy_block_size(mm, block) - 1; + + if (!overlaps(start, end, block_start, block_end)) + continue; + + if (gpu_buddy_block_is_allocated(block)) + continue; + + if (block_start < start || block_end > end) { + u64 adjusted_start = max(block_start, start); + u64 adjusted_end = min(block_end, end); + + if (round_down(adjusted_end + 1, req_size) <= + round_up(adjusted_start, req_size)) + continue; + } + + if (!fallback && block_incompatible(block, flags)) + continue; + + if (contains(start, end, block_start, block_end) && + order == gpu_buddy_block_order(block)) { + /* + * Find the free block within the range. + */ + if (gpu_buddy_block_is_free(block)) + return block; + + continue; + } + + if (!gpu_buddy_block_is_split(block)) { + err = split_block(mm, block); + if (unlikely(err)) + goto err_undo; + } + + list_add(&block->right->tmp_link, &dfs); + list_add(&block->left->tmp_link, &dfs); + } while (1); + + return ERR_PTR(-ENOSPC); + +err_undo: + /* + * We really don't want to leave around a bunch of split blocks, since + * bigger is better, so make sure we merge everything back before we + * free the allocated blocks. + */ + buddy = __get_buddy(block); + if (buddy && + (gpu_buddy_block_is_free(block) && + gpu_buddy_block_is_free(buddy))) + __gpu_buddy_free(mm, block, false); + return ERR_PTR(err); +} + +static struct gpu_buddy_block * +__gpu_buddy_alloc_range_bias(struct gpu_buddy *mm, + u64 start, u64 end, + unsigned int order, + unsigned long flags) +{ + struct gpu_buddy_block *block; + bool fallback = false; + + block = __alloc_range_bias(mm, start, end, order, + flags, fallback); + if (IS_ERR(block)) + return __alloc_range_bias(mm, start, end, order, + flags, !fallback); + + return block; +} + +static struct gpu_buddy_block * +get_maxblock(struct gpu_buddy *mm, + unsigned int order, + enum gpu_buddy_free_tree tree) +{ + struct gpu_buddy_block *max_block = NULL, *block = NULL; + struct rb_root *root; + unsigned int i; + + for (i = order; i <= mm->max_order; ++i) { + root = &mm->free_trees[tree][i]; + block = rbtree_last_free_block(root); + if (!block) + continue; + + if (!max_block) { + max_block = block; + continue; + } + + if (gpu_buddy_block_offset(block) > + gpu_buddy_block_offset(max_block)) { + max_block = block; + } + } + + return max_block; +} + +static struct gpu_buddy_block * +alloc_from_freetree(struct gpu_buddy *mm, + unsigned int order, + unsigned long flags) +{ + struct gpu_buddy_block *block = NULL; + struct rb_root *root; + enum gpu_buddy_free_tree tree; + unsigned int tmp; + int err; + + tree = (flags & GPU_BUDDY_CLEAR_ALLOCATION) ? + GPU_BUDDY_CLEAR_TREE : GPU_BUDDY_DIRTY_TREE; + + if (flags & GPU_BUDDY_TOPDOWN_ALLOCATION) { + block = get_maxblock(mm, order, tree); + if (block) + /* Store the obtained block order */ + tmp = gpu_buddy_block_order(block); + } else { + for (tmp = order; tmp <= mm->max_order; ++tmp) { + /* Get RB tree root for this order and tree */ + root = &mm->free_trees[tree][tmp]; + block = rbtree_last_free_block(root); + if (block) + break; + } + } + + if (!block) { + /* Try allocating from the other tree */ + tree = (tree == GPU_BUDDY_CLEAR_TREE) ? + GPU_BUDDY_DIRTY_TREE : GPU_BUDDY_CLEAR_TREE; + + for (tmp = order; tmp <= mm->max_order; ++tmp) { + root = &mm->free_trees[tree][tmp]; + block = rbtree_last_free_block(root); + if (block) + break; + } + + if (!block) + return ERR_PTR(-ENOSPC); + } + + BUG_ON(!gpu_buddy_block_is_free(block)); + + while (tmp != order) { + err = split_block(mm, block); + if (unlikely(err)) + goto err_undo; + + block = block->right; + tmp--; + } + return block; + +err_undo: + if (tmp != order) + __gpu_buddy_free(mm, block, false); + return ERR_PTR(err); +} + +static int __alloc_range(struct gpu_buddy *mm, + struct list_head *dfs, + u64 start, u64 size, + struct list_head *blocks, + u64 *total_allocated_on_err) +{ + struct gpu_buddy_block *block; + struct gpu_buddy_block *buddy; + u64 total_allocated = 0; + LIST_HEAD(allocated); + u64 end; + int err; + + end = start + size - 1; + + do { + u64 block_start; + u64 block_end; + + block = list_first_entry_or_null(dfs, + struct gpu_buddy_block, + tmp_link); + if (!block) + break; + + list_del(&block->tmp_link); + + block_start = gpu_buddy_block_offset(block); + block_end = block_start + gpu_buddy_block_size(mm, block) - 1; + + if (!overlaps(start, end, block_start, block_end)) + continue; + + if (gpu_buddy_block_is_allocated(block)) { + err = -ENOSPC; + goto err_free; + } + + if (contains(start, end, block_start, block_end)) { + if (gpu_buddy_block_is_free(block)) { + mark_allocated(mm, block); + total_allocated += gpu_buddy_block_size(mm, block); + mm->avail -= gpu_buddy_block_size(mm, block); + if (gpu_buddy_block_is_clear(block)) + mm->clear_avail -= gpu_buddy_block_size(mm, block); + list_add_tail(&block->link, &allocated); + continue; + } else if (!mm->clear_avail) { + err = -ENOSPC; + goto err_free; + } + } + + if (!gpu_buddy_block_is_split(block)) { + err = split_block(mm, block); + if (unlikely(err)) + goto err_undo; + } + + list_add(&block->right->tmp_link, dfs); + list_add(&block->left->tmp_link, dfs); + } while (1); + + if (total_allocated < size) { + err = -ENOSPC; + goto err_free; + } + + list_splice_tail(&allocated, blocks); + + return 0; + +err_undo: + /* + * We really don't want to leave around a bunch of split blocks, since + * bigger is better, so make sure we merge everything back before we + * free the allocated blocks. + */ + buddy = __get_buddy(block); + if (buddy && + (gpu_buddy_block_is_free(block) && + gpu_buddy_block_is_free(buddy))) + __gpu_buddy_free(mm, block, false); + +err_free: + if (err == -ENOSPC && total_allocated_on_err) { + list_splice_tail(&allocated, blocks); + *total_allocated_on_err = total_allocated; + } else { + gpu_buddy_free_list_internal(mm, &allocated); + } + + return err; +} + +static int __gpu_buddy_alloc_range(struct gpu_buddy *mm, + u64 start, + u64 size, + u64 *total_allocated_on_err, + struct list_head *blocks) +{ + LIST_HEAD(dfs); + int i; + + for (i = 0; i < mm->n_roots; ++i) + list_add_tail(&mm->roots[i]->tmp_link, &dfs); + + return __alloc_range(mm, &dfs, start, size, + blocks, total_allocated_on_err); +} + +static int __alloc_contig_try_harder(struct gpu_buddy *mm, + u64 size, + u64 min_block_size, + struct list_head *blocks) +{ + u64 rhs_offset, lhs_offset, lhs_size, filled; + struct gpu_buddy_block *block; + unsigned int tree, order; + LIST_HEAD(blocks_lhs); + unsigned long pages; + u64 modify_size; + int err; + + modify_size = rounddown_pow_of_two(size); + pages = modify_size >> ilog2(mm->chunk_size); + order = fls(pages) - 1; + if (order == 0) + return -ENOSPC; + + for_each_free_tree(tree) { + struct rb_root *root; + struct rb_node *iter; + + root = &mm->free_trees[tree][order]; + if (rbtree_is_empty(root)) + continue; + + iter = rb_last(root); + while (iter) { + block = rbtree_get_free_block(iter); + + /* Allocate blocks traversing RHS */ + rhs_offset = gpu_buddy_block_offset(block); + err = __gpu_buddy_alloc_range(mm, rhs_offset, size, + &filled, blocks); + if (!err || err != -ENOSPC) + return err; + + lhs_size = max((size - filled), min_block_size); + if (!IS_ALIGNED(lhs_size, min_block_size)) + lhs_size = round_up(lhs_size, min_block_size); + + /* Allocate blocks traversing LHS */ + lhs_offset = gpu_buddy_block_offset(block) - lhs_size; + err = __gpu_buddy_alloc_range(mm, lhs_offset, lhs_size, + NULL, &blocks_lhs); + if (!err) { + list_splice(&blocks_lhs, blocks); + return 0; + } else if (err != -ENOSPC) { + gpu_buddy_free_list_internal(mm, blocks); + return err; + } + /* Free blocks for the next iteration */ + gpu_buddy_free_list_internal(mm, blocks); + + iter = rb_prev(iter); + } + } + + return -ENOSPC; +} + +/** + * gpu_buddy_block_trim - free unused pages + * + * @mm: GPU buddy manager + * @start: start address to begin the trimming. + * @new_size: original size requested + * @blocks: Input and output list of allocated blocks. + * MUST contain single block as input to be trimmed. + * On success will contain the newly allocated blocks + * making up the @new_size. Blocks always appear in + * ascending order + * + * For contiguous allocation, we round up the size to the nearest + * power of two value, drivers consume *actual* size, so remaining + * portions are unused and can be optionally freed with this function + * + * Returns: + * 0 on success, error code on failure. + */ +int gpu_buddy_block_trim(struct gpu_buddy *mm, + u64 *start, + u64 new_size, + struct list_head *blocks) +{ + struct gpu_buddy_block *parent; + struct gpu_buddy_block *block; + u64 block_start, block_end; + LIST_HEAD(dfs); + u64 new_start; + int err; + + if (!list_is_singular(blocks)) + return -EINVAL; + + block = list_first_entry(blocks, + struct gpu_buddy_block, + link); + + block_start = gpu_buddy_block_offset(block); + block_end = block_start + gpu_buddy_block_size(mm, block); + + if (WARN_ON(!gpu_buddy_block_is_allocated(block))) + return -EINVAL; + + if (new_size > gpu_buddy_block_size(mm, block)) + return -EINVAL; + + if (!new_size || !IS_ALIGNED(new_size, mm->chunk_size)) + return -EINVAL; + + if (new_size == gpu_buddy_block_size(mm, block)) + return 0; + + new_start = block_start; + if (start) { + new_start = *start; + + if (new_start < block_start) + return -EINVAL; + + if (!IS_ALIGNED(new_start, mm->chunk_size)) + return -EINVAL; + + if (range_overflows(new_start, new_size, block_end)) + return -EINVAL; + } + + list_del(&block->link); + mark_free(mm, block); + mm->avail += gpu_buddy_block_size(mm, block); + if (gpu_buddy_block_is_clear(block)) + mm->clear_avail += gpu_buddy_block_size(mm, block); + + /* Prevent recursively freeing this node */ + parent = block->parent; + block->parent = NULL; + + list_add(&block->tmp_link, &dfs); + err = __alloc_range(mm, &dfs, new_start, new_size, blocks, NULL); + if (err) { + mark_allocated(mm, block); + mm->avail -= gpu_buddy_block_size(mm, block); + if (gpu_buddy_block_is_clear(block)) + mm->clear_avail -= gpu_buddy_block_size(mm, block); + list_add(&block->link, blocks); + } + + block->parent = parent; + return err; +} +EXPORT_SYMBOL(gpu_buddy_block_trim); + +static struct gpu_buddy_block * +__gpu_buddy_alloc_blocks(struct gpu_buddy *mm, + u64 start, u64 end, + unsigned int order, + unsigned long flags) +{ + if (flags & GPU_BUDDY_RANGE_ALLOCATION) + /* Allocate traversing within the range */ + return __gpu_buddy_alloc_range_bias(mm, start, end, + order, flags); + else + /* Allocate from freetree */ + return alloc_from_freetree(mm, order, flags); +} + +/** + * gpu_buddy_alloc_blocks - allocate power-of-two blocks + * + * @mm: GPU buddy manager to allocate from + * @start: start of the allowed range for this block + * @end: end of the allowed range for this block + * @size: size of the allocation in bytes + * @min_block_size: alignment of the allocation + * @blocks: output list head to add allocated blocks + * @flags: GPU_BUDDY_*_ALLOCATION flags + * + * alloc_range_bias() called on range limitations, which traverses + * the tree and returns the desired block. + * + * alloc_from_freetree() called when *no* range restrictions + * are enforced, which picks the block from the freetree. + * + * Returns: + * 0 on success, error code on failure. + */ +int gpu_buddy_alloc_blocks(struct gpu_buddy *mm, + u64 start, u64 end, u64 size, + u64 min_block_size, + struct list_head *blocks, + unsigned long flags) +{ + struct gpu_buddy_block *block = NULL; + u64 original_size, original_min_size; + unsigned int min_order, order; + LIST_HEAD(allocated); + unsigned long pages; + int err; + + if (size < mm->chunk_size) + return -EINVAL; + + if (min_block_size < mm->chunk_size) + return -EINVAL; + + if (!is_power_of_2(min_block_size)) + return -EINVAL; + + if (!IS_ALIGNED(start | end | size, mm->chunk_size)) + return -EINVAL; + + if (end > mm->size) + return -EINVAL; + + if (range_overflows(start, size, mm->size)) + return -EINVAL; + + /* Actual range allocation */ + if (start + size == end) { + if (!IS_ALIGNED(start | end, min_block_size)) + return -EINVAL; + + return __gpu_buddy_alloc_range(mm, start, size, NULL, blocks); + } + + original_size = size; + original_min_size = min_block_size; + + /* Roundup the size to power of 2 */ + if (flags & GPU_BUDDY_CONTIGUOUS_ALLOCATION) { + size = roundup_pow_of_two(size); + min_block_size = size; + /* Align size value to min_block_size */ + } else if (!IS_ALIGNED(size, min_block_size)) { + size = round_up(size, min_block_size); + } + + pages = size >> ilog2(mm->chunk_size); + order = fls(pages) - 1; + min_order = ilog2(min_block_size) - ilog2(mm->chunk_size); + + do { + order = min(order, (unsigned int)fls(pages) - 1); + BUG_ON(order > mm->max_order); + BUG_ON(order < min_order); + + do { + block = __gpu_buddy_alloc_blocks(mm, start, + end, + order, + flags); + if (!IS_ERR(block)) + break; + + if (order-- == min_order) { + /* Try allocation through force merge method */ + if (mm->clear_avail && + !__force_merge(mm, start, end, min_order)) { + block = __gpu_buddy_alloc_blocks(mm, start, + end, + min_order, + flags); + if (!IS_ERR(block)) { + order = min_order; + break; + } + } + + /* + * Try contiguous block allocation through + * try harder method. + */ + if (flags & GPU_BUDDY_CONTIGUOUS_ALLOCATION && + !(flags & GPU_BUDDY_RANGE_ALLOCATION)) + return __alloc_contig_try_harder(mm, + original_size, + original_min_size, + blocks); + err = -ENOSPC; + goto err_free; + } + } while (1); + + mark_allocated(mm, block); + mm->avail -= gpu_buddy_block_size(mm, block); + if (gpu_buddy_block_is_clear(block)) + mm->clear_avail -= gpu_buddy_block_size(mm, block); + kmemleak_update_trace(block); + list_add_tail(&block->link, &allocated); + + pages -= BIT(order); + + if (!pages) + break; + } while (1); + + /* Trim the allocated block to the required size */ + if (!(flags & GPU_BUDDY_TRIM_DISABLE) && + original_size != size) { + struct list_head *trim_list; + LIST_HEAD(temp); + u64 trim_size; + + trim_list = &allocated; + trim_size = original_size; + + if (!list_is_singular(&allocated)) { + block = list_last_entry(&allocated, typeof(*block), link); + list_move(&block->link, &temp); + trim_list = &temp; + trim_size = gpu_buddy_block_size(mm, block) - + (size - original_size); + } + + gpu_buddy_block_trim(mm, + NULL, + trim_size, + trim_list); + + if (!list_empty(&temp)) + list_splice_tail(trim_list, &allocated); + } + + list_splice_tail(&allocated, blocks); + return 0; + +err_free: + gpu_buddy_free_list_internal(mm, &allocated); + return err; +} +EXPORT_SYMBOL(gpu_buddy_alloc_blocks); + +/** + * gpu_buddy_block_print - print block information + * + * @mm: GPU buddy manager + * @block: GPU buddy block + */ +void gpu_buddy_block_print(struct gpu_buddy *mm, + struct gpu_buddy_block *block) +{ + u64 start = gpu_buddy_block_offset(block); + u64 size = gpu_buddy_block_size(mm, block); + + pr_info("%#018llx-%#018llx: %llu\n", start, start + size, size); +} +EXPORT_SYMBOL(gpu_buddy_block_print); + +/** + * gpu_buddy_print - print allocator state + * + * @mm: GPU buddy manager + */ +void gpu_buddy_print(struct gpu_buddy *mm) +{ + int order; + + pr_info("chunk_size: %lluKiB, total: %lluMiB, free: %lluMiB, clear_free: %lluMiB\n", + mm->chunk_size >> 10, mm->size >> 20, mm->avail >> 20, mm->clear_avail >> 20); + + for (order = mm->max_order; order >= 0; order--) { + struct gpu_buddy_block *block, *tmp; + struct rb_root *root; + u64 count = 0, free; + unsigned int tree; + + for_each_free_tree(tree) { + root = &mm->free_trees[tree][order]; + + rbtree_postorder_for_each_entry_safe(block, tmp, root, rb) { + BUG_ON(!gpu_buddy_block_is_free(block)); + count++; + } + } + + free = count * (mm->chunk_size << order); + if (free < SZ_1M) + pr_info("order-%2d free: %8llu KiB, blocks: %llu\n", + order, free >> 10, count); + else + pr_info("order-%2d free: %8llu MiB, blocks: %llu\n", + order, free >> 20, count); + } +} +EXPORT_SYMBOL(gpu_buddy_print); + +static void gpu_buddy_module_exit(void) +{ + kmem_cache_destroy(slab_blocks); +} + +static int __init gpu_buddy_module_init(void) +{ + slab_blocks = KMEM_CACHE(gpu_buddy_block, 0); + if (!slab_blocks) + return -ENOMEM; + + return 0; +} + +module_init(gpu_buddy_module_init); +module_exit(gpu_buddy_module_exit); + +MODULE_DESCRIPTION("GPU Buddy Allocator"); +MODULE_LICENSE("Dual MIT/GPL"); diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig index 7e6bc0b3a589..0475defb37f0 100644 --- a/drivers/gpu/drm/Kconfig +++ b/drivers/gpu/drm/Kconfig @@ -220,6 +220,7 @@ config DRM_GPUSVM config DRM_BUDDY tristate depends on DRM + select GPU_BUDDY help A page based buddy allocator diff --git a/drivers/gpu/drm/Kconfig.debug b/drivers/gpu/drm/Kconfig.debug index 05dc43c0b8c5..1f4c408c7920 100644 --- a/drivers/gpu/drm/Kconfig.debug +++ b/drivers/gpu/drm/Kconfig.debug @@ -71,6 +71,7 @@ config DRM_KUNIT_TEST select DRM_KUNIT_TEST_HELPERS select DRM_LIB_RANDOM select DRM_SYSFB_HELPER + select GPU_BUDDY select PRIME_NUMBERS default KUNIT_ALL_TESTS help @@ -88,10 +89,11 @@ config DRM_TTM_KUNIT_TEST tristate "KUnit tests for TTM" if !KUNIT_ALL_TESTS default n depends on DRM && KUNIT && MMU && (UML || COMPILE_TEST) - select DRM_TTM select DRM_BUDDY + select DRM_TTM select DRM_EXPORT_FOR_TESTS if m select DRM_KUNIT_TEST_HELPERS + select GPU_BUDDY default KUNIT_ALL_TESTS help Enables unit tests for TTM, a GPU memory manager subsystem used diff --git a/drivers/gpu/drm/amd/amdgpu/Kconfig b/drivers/gpu/drm/amd/amdgpu/Kconfig index 7f515be5185d..bb131543e1d9 100644 --- a/drivers/gpu/drm/amd/amdgpu/Kconfig +++ b/drivers/gpu/drm/amd/amdgpu/Kconfig @@ -23,6 +23,7 @@ config DRM_AMDGPU select CRC16 select BACKLIGHT_CLASS_DEVICE select INTERVAL_TREE + select GPU_BUDDY select DRM_BUDDY select DRM_SUBALLOC_HELPER select DRM_EXEC diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ras.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_ras.c index 2a6cf7963dde..e0bd8a68877f 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ras.c +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ras.c @@ -5654,7 +5654,7 @@ int amdgpu_ras_add_critical_region(struct amdgpu_device *adev, struct amdgpu_ras *con = amdgpu_ras_get_context(adev); struct amdgpu_vram_mgr_resource *vres; struct ras_critical_region *region; - struct drm_buddy_block *block; + struct gpu_buddy_block *block; int ret = 0; if (!bo || !bo->tbo.resource) diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_res_cursor.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_res_cursor.h index be2e56ce1355..8908d9e08a30 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_res_cursor.h +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_res_cursor.h @@ -55,7 +55,7 @@ static inline void amdgpu_res_first(struct ttm_resource *res, uint64_t start, uint64_t size, struct amdgpu_res_cursor *cur) { - struct drm_buddy_block *block; + struct gpu_buddy_block *block; struct list_head *head, *next; struct drm_mm_node *node; @@ -71,7 +71,7 @@ static inline void amdgpu_res_first(struct ttm_resource *res, head = &to_amdgpu_vram_mgr_resource(res)->blocks; block = list_first_entry_or_null(head, - struct drm_buddy_block, + struct gpu_buddy_block, link); if (!block) goto fallback; @@ -81,7 +81,7 @@ static inline void amdgpu_res_first(struct ttm_resource *res, next = block->link.next; if (next != head) - block = list_entry(next, struct drm_buddy_block, link); + block = list_entry(next, struct gpu_buddy_block, link); } cur->start = amdgpu_vram_mgr_block_start(block) + start; @@ -125,7 +125,7 @@ static inline void amdgpu_res_first(struct ttm_resource *res, */ static inline void amdgpu_res_next(struct amdgpu_res_cursor *cur, uint64_t size) { - struct drm_buddy_block *block; + struct gpu_buddy_block *block; struct drm_mm_node *node; struct list_head *next; @@ -146,7 +146,7 @@ static inline void amdgpu_res_next(struct amdgpu_res_cursor *cur, uint64_t size) block = cur->node; next = block->link.next; - block = list_entry(next, struct drm_buddy_block, link); + block = list_entry(next, struct gpu_buddy_block, link); cur->node = block; cur->start = amdgpu_vram_mgr_block_start(block); @@ -175,7 +175,7 @@ static inline void amdgpu_res_next(struct amdgpu_res_cursor *cur, uint64_t size) */ static inline bool amdgpu_res_cleared(struct amdgpu_res_cursor *cur) { - struct drm_buddy_block *block; + struct gpu_buddy_block *block; switch (cur->mem_type) { case TTM_PL_VRAM: diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c index 9d934c07fa6b..6c06a9c9b13f 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c @@ -23,6 +23,8 @@ */ #include <linux/dma-mapping.h> + +#include <drm/drm_buddy.h> #include <drm/ttm/ttm_range_manager.h> #include <drm/drm_drv.h> @@ -52,15 +54,15 @@ to_amdgpu_device(struct amdgpu_vram_mgr *mgr) return container_of(mgr, struct amdgpu_device, mman.vram_mgr); } -static inline struct drm_buddy_block * +static inline struct gpu_buddy_block * amdgpu_vram_mgr_first_block(struct list_head *list) { - return list_first_entry_or_null(list, struct drm_buddy_block, link); + return list_first_entry_or_null(list, struct gpu_buddy_block, link); } static inline bool amdgpu_is_vram_mgr_blocks_contiguous(struct list_head *head) { - struct drm_buddy_block *block; + struct gpu_buddy_block *block; u64 start, size; block = amdgpu_vram_mgr_first_block(head); @@ -71,7 +73,7 @@ static inline bool amdgpu_is_vram_mgr_blocks_contiguous(struct list_head *head) start = amdgpu_vram_mgr_block_start(block); size = amdgpu_vram_mgr_block_size(block); - block = list_entry(block->link.next, struct drm_buddy_block, link); + block = list_entry(block->link.next, struct gpu_buddy_block, link); if (start + size != amdgpu_vram_mgr_block_start(block)) return false; } @@ -81,7 +83,7 @@ static inline bool amdgpu_is_vram_mgr_blocks_contiguous(struct list_head *head) static inline u64 amdgpu_vram_mgr_blocks_size(struct list_head *head) { - struct drm_buddy_block *block; + struct gpu_buddy_block *block; u64 size = 0; list_for_each_entry(block, head, link) @@ -254,7 +256,7 @@ const struct attribute_group amdgpu_vram_mgr_attr_group = { * Calculate how many bytes of the DRM BUDDY block are inside visible VRAM */ static u64 amdgpu_vram_mgr_vis_size(struct amdgpu_device *adev, - struct drm_buddy_block *block) + struct gpu_buddy_block *block) { u64 start = amdgpu_vram_mgr_block_start(block); u64 end = start + amdgpu_vram_mgr_block_size(block); @@ -279,7 +281,7 @@ u64 amdgpu_vram_mgr_bo_visible_size(struct amdgpu_bo *bo) struct amdgpu_device *adev = amdgpu_ttm_adev(bo->tbo.bdev); struct ttm_resource *res = bo->tbo.resource; struct amdgpu_vram_mgr_resource *vres = to_amdgpu_vram_mgr_resource(res); - struct drm_buddy_block *block; + struct gpu_buddy_block *block; u64 usage = 0; if (amdgpu_gmc_vram_full_visible(&adev->gmc)) @@ -299,15 +301,15 @@ static void amdgpu_vram_mgr_do_reserve(struct ttm_resource_manager *man) { struct amdgpu_vram_mgr *mgr = to_vram_mgr(man); struct amdgpu_device *adev = to_amdgpu_device(mgr); - struct drm_buddy *mm = &mgr->mm; + struct gpu_buddy *mm = &mgr->mm; struct amdgpu_vram_reservation *rsv, *temp; - struct drm_buddy_block *block; + struct gpu_buddy_block *block; uint64_t vis_usage; list_for_each_entry_safe(rsv, temp, &mgr->reservations_pending, blocks) { - if (drm_buddy_alloc_blocks(mm, rsv->start, rsv->start + rsv->size, + if (gpu_buddy_alloc_blocks(mm, rsv->start, rsv->start + rsv->size, rsv->size, mm->chunk_size, &rsv->allocated, - DRM_BUDDY_RANGE_ALLOCATION)) + GPU_BUDDY_RANGE_ALLOCATION)) continue; block = amdgpu_vram_mgr_first_block(&rsv->allocated); @@ -403,7 +405,7 @@ int amdgpu_vram_mgr_query_address_block_info(struct amdgpu_vram_mgr *mgr, uint64_t address, struct amdgpu_vram_block_info *info) { struct amdgpu_vram_mgr_resource *vres; - struct drm_buddy_block *block; + struct gpu_buddy_block *block; u64 start, size; int ret = -ENOENT; @@ -450,8 +452,8 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man, struct amdgpu_vram_mgr_resource *vres; u64 size, remaining_size, lpfn, fpfn; unsigned int adjust_dcc_size = 0; - struct drm_buddy *mm = &mgr->mm; - struct drm_buddy_block *block; + struct gpu_buddy *mm = &mgr->mm; + struct gpu_buddy_block *block; unsigned long pages_per_block; int r; @@ -493,17 +495,17 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man, INIT_LIST_HEAD(&vres->blocks); if (place->flags & TTM_PL_FLAG_TOPDOWN) - vres->flags |= DRM_BUDDY_TOPDOWN_ALLOCATION; + vres->flags |= GPU_BUDDY_TOPDOWN_ALLOCATION; if (bo->flags & AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS) - vres->flags |= DRM_BUDDY_CONTIGUOUS_ALLOCATION; + vres->flags |= GPU_BUDDY_CONTIGUOUS_ALLOCATION; if (bo->flags & AMDGPU_GEM_CREATE_VRAM_CLEARED) - vres->flags |= DRM_BUDDY_CLEAR_ALLOCATION; + vres->flags |= GPU_BUDDY_CLEAR_ALLOCATION; if (fpfn || lpfn != mgr->mm.size) /* Allocate blocks in desired range */ - vres->flags |= DRM_BUDDY_RANGE_ALLOCATION; + vres->flags |= GPU_BUDDY_RANGE_ALLOCATION; if (bo->flags & AMDGPU_GEM_CREATE_GFX12_DCC && adev->gmc.gmc_funcs->get_dcc_alignment) @@ -516,7 +518,7 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man, dcc_size = roundup_pow_of_two(vres->base.size + adjust_dcc_size); remaining_size = (u64)dcc_size; - vres->flags |= DRM_BUDDY_TRIM_DISABLE; + vres->flags |= GPU_BUDDY_TRIM_DISABLE; } mutex_lock(&mgr->lock); @@ -536,7 +538,7 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man, BUG_ON(min_block_size < mm->chunk_size); - r = drm_buddy_alloc_blocks(mm, fpfn, + r = gpu_buddy_alloc_blocks(mm, fpfn, lpfn, size, min_block_size, @@ -545,7 +547,7 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man, if (unlikely(r == -ENOSPC) && pages_per_block == ~0ul && !(place->flags & TTM_PL_FLAG_CONTIGUOUS)) { - vres->flags &= ~DRM_BUDDY_CONTIGUOUS_ALLOCATION; + vres->flags &= ~GPU_BUDDY_CONTIGUOUS_ALLOCATION; pages_per_block = max_t(u32, 2UL << (20UL - PAGE_SHIFT), tbo->page_alignment); @@ -566,7 +568,7 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man, list_add_tail(&vres->vres_node, &mgr->allocated_vres_list); if (bo->flags & AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS && adjust_dcc_size) { - struct drm_buddy_block *dcc_block; + struct gpu_buddy_block *dcc_block; unsigned long dcc_start; u64 trim_start; @@ -576,7 +578,7 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man, roundup((unsigned long)amdgpu_vram_mgr_block_start(dcc_block), adjust_dcc_size); trim_start = (u64)dcc_start; - drm_buddy_block_trim(mm, &trim_start, + gpu_buddy_block_trim(mm, &trim_start, (u64)vres->base.size, &vres->blocks); } @@ -614,7 +616,7 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man, return 0; error_free_blocks: - drm_buddy_free_list(mm, &vres->blocks, 0); + gpu_buddy_free_list(mm, &vres->blocks, 0); mutex_unlock(&mgr->lock); error_fini: ttm_resource_fini(man, &vres->base); @@ -637,8 +639,8 @@ static void amdgpu_vram_mgr_del(struct ttm_resource_manager *man, struct amdgpu_vram_mgr_resource *vres = to_amdgpu_vram_mgr_resource(res); struct amdgpu_vram_mgr *mgr = to_vram_mgr(man); struct amdgpu_device *adev = to_amdgpu_device(mgr); - struct drm_buddy *mm = &mgr->mm; - struct drm_buddy_block *block; + struct gpu_buddy *mm = &mgr->mm; + struct gpu_buddy_block *block; uint64_t vis_usage = 0; mutex_lock(&mgr->lock); @@ -649,7 +651,7 @@ static void amdgpu_vram_mgr_del(struct ttm_resource_manager *man, list_for_each_entry(block, &vres->blocks, link) vis_usage += amdgpu_vram_mgr_vis_size(adev, block); - drm_buddy_free_list(mm, &vres->blocks, vres->flags); + gpu_buddy_free_list(mm, &vres->blocks, vres->flags); amdgpu_vram_mgr_do_reserve(man); mutex_unlock(&mgr->lock); @@ -688,7 +690,7 @@ int amdgpu_vram_mgr_alloc_sgt(struct amdgpu_device *adev, if (!*sgt) return -ENOMEM; - /* Determine the number of DRM_BUDDY blocks to export */ + /* Determine the number of GPU_BUDDY blocks to export */ amdgpu_res_first(res, offset, length, &cursor); while (cursor.remaining) { num_entries++; @@ -704,10 +706,10 @@ int amdgpu_vram_mgr_alloc_sgt(struct amdgpu_device *adev, sg->length = 0; /* - * Walk down DRM_BUDDY blocks to populate scatterlist nodes - * @note: Use iterator api to get first the DRM_BUDDY block + * Walk down GPU_BUDDY blocks to populate scatterlist nodes + * @note: Use iterator api to get first the GPU_BUDDY block * and the number of bytes from it. Access the following - * DRM_BUDDY block(s) if more buffer needs to exported + * GPU_BUDDY block(s) if more buffer needs to exported */ amdgpu_res_first(res, offset, length, &cursor); for_each_sgtable_sg((*sgt), sg, i) { @@ -792,10 +794,10 @@ uint64_t amdgpu_vram_mgr_vis_usage(struct amdgpu_vram_mgr *mgr) void amdgpu_vram_mgr_clear_reset_blocks(struct amdgpu_device *adev) { struct amdgpu_vram_mgr *mgr = &adev->mman.vram_mgr; - struct drm_buddy *mm = &mgr->mm; + struct gpu_buddy *mm = &mgr->mm; mutex_lock(&mgr->lock); - drm_buddy_reset_clear(mm, false); + gpu_buddy_reset_clear(mm, false); mutex_unlock(&mgr->lock); } @@ -815,7 +817,7 @@ static bool amdgpu_vram_mgr_intersects(struct ttm_resource_manager *man, size_t size) { struct amdgpu_vram_mgr_resource *mgr = to_amdgpu_vram_mgr_resource(res); - struct drm_buddy_block *block; + struct gpu_buddy_block *block; /* Check each drm buddy block individually */ list_for_each_entry(block, &mgr->blocks, link) { @@ -848,7 +850,7 @@ static bool amdgpu_vram_mgr_compatible(struct ttm_resource_manager *man, size_t size) { struct amdgpu_vram_mgr_resource *mgr = to_amdgpu_vram_mgr_resource(res); - struct drm_buddy_block *block; + struct gpu_buddy_block *block; /* Check each drm buddy block individually */ list_for_each_entry(block, &mgr->blocks, link) { @@ -877,7 +879,7 @@ static void amdgpu_vram_mgr_debug(struct ttm_resource_manager *man, struct drm_printer *printer) { struct amdgpu_vram_mgr *mgr = to_vram_mgr(man); - struct drm_buddy *mm = &mgr->mm; + struct gpu_buddy *mm = &mgr->mm; struct amdgpu_vram_reservation *rsv; drm_printf(printer, " vis usage:%llu\n", @@ -930,7 +932,7 @@ int amdgpu_vram_mgr_init(struct amdgpu_device *adev) mgr->default_page_size = PAGE_SIZE; man->func = &amdgpu_vram_mgr_func; - err = drm_buddy_init(&mgr->mm, man->size, PAGE_SIZE); + err = gpu_buddy_init(&mgr->mm, man->size, PAGE_SIZE); if (err) return err; @@ -965,11 +967,11 @@ void amdgpu_vram_mgr_fini(struct amdgpu_device *adev) kfree(rsv); list_for_each_entry_safe(rsv, temp, &mgr->reserved_pages, blocks) { - drm_buddy_free_list(&mgr->mm, &rsv->allocated, 0); + gpu_buddy_free_list(&mgr->mm, &rsv->allocated, 0); kfree(rsv); } if (!adev->gmc.is_app_apu) - drm_buddy_fini(&mgr->mm); + gpu_buddy_fini(&mgr->mm); mutex_unlock(&mgr->lock); ttm_resource_manager_cleanup(man); diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.h index 5f5fd9a911c2..429a21a2e9b2 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.h +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.h @@ -24,11 +24,11 @@ #ifndef __AMDGPU_VRAM_MGR_H__ #define __AMDGPU_VRAM_MGR_H__ -#include <drm/drm_buddy.h> +#include <linux/gpu_buddy.h> struct amdgpu_vram_mgr { struct ttm_resource_manager manager; - struct drm_buddy mm; + struct gpu_buddy mm; /* protects access to buffer objects */ struct mutex lock; struct list_head reservations_pending; @@ -57,19 +57,19 @@ struct amdgpu_vram_mgr_resource { struct amdgpu_vres_task task; }; -static inline u64 amdgpu_vram_mgr_block_start(struct drm_buddy_block *block) +static inline u64 amdgpu_vram_mgr_block_start(struct gpu_buddy_block *block) { - return drm_buddy_block_offset(block); + return gpu_buddy_block_offset(block); } -static inline u64 amdgpu_vram_mgr_block_size(struct drm_buddy_block *block) +static inline u64 amdgpu_vram_mgr_block_size(struct gpu_buddy_block *block) { - return (u64)PAGE_SIZE << drm_buddy_block_order(block); + return (u64)PAGE_SIZE << gpu_buddy_block_order(block); } -static inline bool amdgpu_vram_mgr_is_cleared(struct drm_buddy_block *block) +static inline bool amdgpu_vram_mgr_is_cleared(struct gpu_buddy_block *block) { - return drm_buddy_block_is_clear(block); + return gpu_buddy_block_is_clear(block); } static inline struct amdgpu_vram_mgr_resource * @@ -82,8 +82,8 @@ static inline void amdgpu_vram_mgr_set_cleared(struct ttm_resource *res) { struct amdgpu_vram_mgr_resource *ares = to_amdgpu_vram_mgr_resource(res); - WARN_ON(ares->flags & DRM_BUDDY_CLEARED); - ares->flags |= DRM_BUDDY_CLEARED; + WARN_ON(ares->flags & GPU_BUDDY_CLEARED); + ares->flags |= GPU_BUDDY_CLEARED; } int amdgpu_vram_mgr_query_address_block_info(struct amdgpu_vram_mgr *mgr, diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c index 2f279b46bd2c..056514801caf 100644 --- a/drivers/gpu/drm/drm_buddy.c +++ b/drivers/gpu/drm/drm_buddy.c @@ -3,1262 +3,25 @@ * Copyright © 2021 Intel Corporation */ -#include <kunit/test-bug.h> - #include <linux/export.h> -#include <linux/kmemleak.h> #include <linux/module.h> #include <linux/sizes.h> #include <drm/drm_buddy.h> #include <drm/drm_print.h> -enum drm_buddy_free_tree { - DRM_BUDDY_CLEAR_TREE = 0, - DRM_BUDDY_DIRTY_TREE, - DRM_BUDDY_MAX_FREE_TREES, -}; - -static struct kmem_cache *slab_blocks; - -#define for_each_free_tree(tree) \ - for ((tree) = 0; (tree) < DRM_BUDDY_MAX_FREE_TREES; (tree)++) - -static struct drm_buddy_block *drm_block_alloc(struct drm_buddy *mm, - struct drm_buddy_block *parent, - unsigned int order, - u64 offset) -{ - struct drm_buddy_block *block; - - BUG_ON(order > DRM_BUDDY_MAX_ORDER); - - block = kmem_cache_zalloc(slab_blocks, GFP_KERNEL); - if (!block) - return NULL; - - block->header = offset; - block->header |= order; - block->parent = parent; - - RB_CLEAR_NODE(&block->rb); - - BUG_ON(block->header & DRM_BUDDY_HEADER_UNUSED); - return block; -} - -static void drm_block_free(struct drm_buddy *mm, - struct drm_buddy_block *block) -{ - kmem_cache_free(slab_blocks, block); -} - -static enum drm_buddy_free_tree -get_block_tree(struct drm_buddy_block *block) -{ - return drm_buddy_block_is_clear(block) ? - DRM_BUDDY_CLEAR_TREE : DRM_BUDDY_DIRTY_TREE; -} - -static struct drm_buddy_block * -rbtree_get_free_block(const struct rb_node *node) -{ - return node ? rb_entry(node, struct drm_buddy_block, rb) : NULL; -} - -static struct drm_buddy_block * -rbtree_last_free_block(struct rb_root *root) -{ - return rbtree_get_free_block(rb_last(root)); -} - -static bool rbtree_is_empty(struct rb_root *root) -{ - return RB_EMPTY_ROOT(root); -} - -static bool drm_buddy_block_offset_less(const struct drm_buddy_block *block, - const struct drm_buddy_block *node) -{ - return drm_buddy_block_offset(block) < drm_buddy_block_offset(node); -} - -static bool rbtree_block_offset_less(struct rb_node *block, - const struct rb_node *node) -{ - return drm_buddy_block_offset_less(rbtree_get_free_block(block), - rbtree_get_free_block(node)); -} - -static void rbtree_insert(struct drm_buddy *mm, - struct drm_buddy_block *block, - enum drm_buddy_free_tree tree) -{ - rb_add(&block->rb, - &mm->free_trees[tree][drm_buddy_block_order(block)], - rbtree_block_offset_less); -} - -static void rbtree_remove(struct drm_buddy *mm, - struct drm_buddy_block *block) -{ - unsigned int order = drm_buddy_block_order(block); - enum drm_buddy_free_tree tree; - struct rb_root *root; - - tree = get_block_tree(block); - root = &mm->free_trees[tree][order]; - - rb_erase(&block->rb, root); - RB_CLEAR_NODE(&block->rb); -} - -static void clear_reset(struct drm_buddy_block *block) -{ - block->header &= ~DRM_BUDDY_HEADER_CLEAR; -} - -static void mark_cleared(struct drm_buddy_block *block) -{ - block->header |= DRM_BUDDY_HEADER_CLEAR; -} - -static void mark_allocated(struct drm_buddy *mm, - struct drm_buddy_block *block) -{ - block->header &= ~DRM_BUDDY_HEADER_STATE; - block->header |= DRM_BUDDY_ALLOCATED; - - rbtree_remove(mm, block); -} - -static void mark_free(struct drm_buddy *mm, - struct drm_buddy_block *block) -{ - enum drm_buddy_free_tree tree; - - block->header &= ~DRM_BUDDY_HEADER_STATE; - block->header |= DRM_BUDDY_FREE; - - tree = get_block_tree(block); - rbtree_insert(mm, block, tree); -} - -static void mark_split(struct drm_buddy *mm, - struct drm_buddy_block *block) -{ - block->header &= ~DRM_BUDDY_HEADER_STATE; - block->header |= DRM_BUDDY_SPLIT; - - rbtree_remove(mm, block); -} - -static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2) -{ - return s1 <= e2 && e1 >= s2; -} - -static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2) -{ - return s1 <= s2 && e1 >= e2; -} - -static struct drm_buddy_block * -__get_buddy(struct drm_buddy_block *block) -{ - struct drm_buddy_block *parent; - - parent = block->parent; - if (!parent) - return NULL; - - if (parent->left == block) - return parent->right; - - return parent->left; -} - -static unsigned int __drm_buddy_free(struct drm_buddy *mm, - struct drm_buddy_block *block, - bool force_merge) -{ - struct drm_buddy_block *parent; - unsigned int order; - - while ((parent = block->parent)) { - struct drm_buddy_block *buddy; - - buddy = __get_buddy(block); - - if (!drm_buddy_block_is_free(buddy)) - break; - - if (!force_merge) { - /* - * Check the block and its buddy clear state and exit - * the loop if they both have the dissimilar state. - */ - if (drm_buddy_block_is_clear(block) != - drm_buddy_block_is_clear(buddy)) - break; - - if (drm_buddy_block_is_clear(block)) - mark_cleared(parent); - } - - rbtree_remove(mm, buddy); - if (force_merge && drm_buddy_block_is_clear(buddy)) - mm->clear_avail -= drm_buddy_block_size(mm, buddy); - - drm_block_free(mm, block); - drm_block_free(mm, buddy); - - block = parent; - } - - order = drm_buddy_block_order(block); - mark_free(mm, block); - - return order; -} - -static int __force_merge(struct drm_buddy *mm, - u64 start, - u64 end, - unsigned int min_order) -{ - unsigned int tree, order; - int i; - - if (!min_order) - return -ENOMEM; - - if (min_order > mm->max_order) - return -EINVAL; - - for_each_free_tree(tree) { - for (i = min_order - 1; i >= 0; i--) { - struct rb_node *iter = rb_last(&mm->free_trees[tree][i]); - - while (iter) { - struct drm_buddy_block *block, *buddy; - u64 block_start, block_end; - - block = rbtree_get_free_block(iter); - iter = rb_prev(iter); - - if (!block || !block->parent) - continue; - - block_start = drm_buddy_block_offset(block); - block_end = block_start + drm_buddy_block_size(mm, block) - 1; - - if (!contains(start, end, block_start, block_end)) - continue; - - buddy = __get_buddy(block); - if (!drm_buddy_block_is_free(buddy)) - continue; - - WARN_ON(drm_buddy_block_is_clear(block) == - drm_buddy_block_is_clear(buddy)); - - /* - * Advance to the next node when the current node is the buddy, - * as freeing the block will also remove its buddy from the tree. - */ - if (iter == &buddy->rb) - iter = rb_prev(iter); - - rbtree_remove(mm, block); - if (drm_buddy_block_is_clear(block)) - mm->clear_avail -= drm_buddy_block_size(mm, block); - - order = __drm_buddy_free(mm, block, true); - if (order >= min_order) - return 0; - } - } - } - - return -ENOMEM; -} - -/** - * drm_buddy_init - init memory manager - * - * @mm: DRM buddy manager to initialize - * @size: size in bytes to manage - * @chunk_size: minimum page size in bytes for our allocations - * - * Initializes the memory manager and its resources. - * - * Returns: - * 0 on success, error code on failure. - */ -int drm_buddy_init(struct drm_buddy *mm, u64 size, u64 chunk_size) -{ - unsigned int i, j, root_count = 0; - u64 offset = 0; - - if (size < chunk_size) - return -EINVAL; - - if (chunk_size < SZ_4K) - return -EINVAL; - - if (!is_power_of_2(chunk_size)) - return -EINVAL; - - size = round_down(size, chunk_size); - - mm->size = size; - mm->avail = size; - mm->clear_avail = 0; - mm->chunk_size = chunk_size; - mm->max_order = ilog2(size) - ilog2(chunk_size); - - BUG_ON(mm->max_order > DRM_BUDDY_MAX_ORDER); - - mm->free_trees = kmalloc_array(DRM_BUDDY_MAX_FREE_TREES, - sizeof(*mm->free_trees), - GFP_KERNEL); - if (!mm->free_trees) - return -ENOMEM; - - for_each_free_tree(i) { - mm->free_trees[i] = kmalloc_array(mm->max_order + 1, - sizeof(struct rb_root), - GFP_KERNEL); - if (!mm->free_trees[i]) - goto out_free_tree; - - for (j = 0; j <= mm->max_order; ++j) - mm->free_trees[i][j] = RB_ROOT; - } - - mm->n_roots = hweight64(size); - - mm->roots = kmalloc_array(mm->n_roots, - sizeof(struct drm_buddy_block *), - GFP_KERNEL); - if (!mm->roots) - goto out_free_tree; - - /* - * Split into power-of-two blocks, in case we are given a size that is - * not itself a power-of-two. - */ - do { - struct drm_buddy_block *root; - unsigned int order; - u64 root_size; - - order = ilog2(size) - ilog2(chunk_size); - root_size = chunk_size << order; - - root = drm_block_alloc(mm, NULL, order, offset); - if (!root) - goto out_free_roots; - - mark_free(mm, root); - - BUG_ON(root_count > mm->max_order); - BUG_ON(drm_buddy_block_size(mm, root) < chunk_size); - - mm->roots[root_count] = root; - - offset += root_size; - size -= root_size; - root_count++; - } while (size); - - return 0; - -out_free_roots: - while (root_count--) - drm_block_free(mm, mm->roots[root_count]); - kfree(mm->roots); -out_free_tree: - while (i--) - kfree(mm->free_trees[i]); - kfree(mm->free_trees); - return -ENOMEM; -} -EXPORT_SYMBOL(drm_buddy_init); - -/** - * drm_buddy_fini - tear down the memory manager - * - * @mm: DRM buddy manager to free - * - * Cleanup memory manager resources and the freetree - */ -void drm_buddy_fini(struct drm_buddy *mm) -{ - u64 root_size, size, start; - unsigned int order; - int i; - - size = mm->size; - - for (i = 0; i < mm->n_roots; ++i) { - order = ilog2(size) - ilog2(mm->chunk_size); - start = drm_buddy_block_offset(mm->roots[i]); - __force_merge(mm, start, start + size, order); - - if (WARN_ON(!drm_buddy_block_is_free(mm->roots[i]))) - kunit_fail_current_test("buddy_fini() root"); - - drm_block_free(mm, mm->roots[i]); - - root_size = mm->chunk_size << order; - size -= root_size; - } - - WARN_ON(mm->avail != mm->size); - - for_each_free_tree(i) - kfree(mm->free_trees[i]); - kfree(mm->roots); -} -EXPORT_SYMBOL(drm_buddy_fini); - -static int split_block(struct drm_buddy *mm, - struct drm_buddy_block *block) -{ - unsigned int block_order = drm_buddy_block_order(block) - 1; - u64 offset = drm_buddy_block_offset(block); - - BUG_ON(!drm_buddy_block_is_free(block)); - BUG_ON(!drm_buddy_block_order(block)); - - block->left = drm_block_alloc(mm, block, block_order, offset); - if (!block->left) - return -ENOMEM; - - block->right = drm_block_alloc(mm, block, block_order, - offset + (mm->chunk_size << block_order)); - if (!block->right) { - drm_block_free(mm, block->left); - return -ENOMEM; - } - - mark_split(mm, block); - - if (drm_buddy_block_is_clear(block)) { - mark_cleared(block->left); - mark_cleared(block->right); - clear_reset(block); - } - - mark_free(mm, block->left); - mark_free(mm, block->right); - - return 0; -} - -/** - * drm_get_buddy - get buddy address - * - * @block: DRM buddy block - * - * Returns the corresponding buddy block for @block, or NULL - * if this is a root block and can't be merged further. - * Requires some kind of locking to protect against - * any concurrent allocate and free operations. - */ -struct drm_buddy_block * -drm_get_buddy(struct drm_buddy_block *block) -{ - return __get_buddy(block); -} -EXPORT_SYMBOL(drm_get_buddy); - -/** - * drm_buddy_reset_clear - reset blocks clear state - * - * @mm: DRM buddy manager - * @is_clear: blocks clear state - * - * Reset the clear state based on @is_clear value for each block - * in the freetree. - */ -void drm_buddy_reset_clear(struct drm_buddy *mm, bool is_clear) -{ - enum drm_buddy_free_tree src_tree, dst_tree; - u64 root_size, size, start; - unsigned int order; - int i; - - size = mm->size; - for (i = 0; i < mm->n_roots; ++i) { - order = ilog2(size) - ilog2(mm->chunk_size); - start = drm_buddy_block_offset(mm->roots[i]); - __force_merge(mm, start, start + size, order); - - root_size = mm->chunk_size << order; - size -= root_size; - } - - src_tree = is_clear ? DRM_BUDDY_DIRTY_TREE : DRM_BUDDY_CLEAR_TREE; - dst_tree = is_clear ? DRM_BUDDY_CLEAR_TREE : DRM_BUDDY_DIRTY_TREE; - - for (i = 0; i <= mm->max_order; ++i) { - struct rb_root *root = &mm->free_trees[src_tree][i]; - struct drm_buddy_block *block, *tmp; - - rbtree_postorder_for_each_entry_safe(block, tmp, root, rb) { - rbtree_remove(mm, block); - if (is_clear) { - mark_cleared(block); - mm->clear_avail += drm_buddy_block_size(mm, block); - } else { - clear_reset(block); - mm->clear_avail -= drm_buddy_block_size(mm, block); - } - - rbtree_insert(mm, block, dst_tree); - } - } -} -EXPORT_SYMBOL(drm_buddy_reset_clear); - -/** - * drm_buddy_free_block - free a block - * - * @mm: DRM buddy manager - * @block: block to be freed - */ -void drm_buddy_free_block(struct drm_buddy *mm, - struct drm_buddy_block *block) -{ - BUG_ON(!drm_buddy_block_is_allocated(block)); - mm->avail += drm_buddy_block_size(mm, block); - if (drm_buddy_block_is_clear(block)) - mm->clear_avail += drm_buddy_block_size(mm, block); - - __drm_buddy_free(mm, block, false); -} -EXPORT_SYMBOL(drm_buddy_free_block); - -static void __drm_buddy_free_list(struct drm_buddy *mm, - struct list_head *objects, - bool mark_clear, - bool mark_dirty) -{ - struct drm_buddy_block *block, *on; - - WARN_ON(mark_dirty && mark_clear); - - list_for_each_entry_safe(block, on, objects, link) { - if (mark_clear) - mark_cleared(block); - else if (mark_dirty) - clear_reset(block); - drm_buddy_free_block(mm, block); - cond_resched(); - } - INIT_LIST_HEAD(objects); -} - -static void drm_buddy_free_list_internal(struct drm_buddy *mm, - struct list_head *objects) -{ - /* - * Don't touch the clear/dirty bit, since allocation is still internal - * at this point. For example we might have just failed part of the - * allocation. - */ - __drm_buddy_free_list(mm, objects, false, false); -} - -/** - * drm_buddy_free_list - free blocks - * - * @mm: DRM buddy manager - * @objects: input list head to free blocks - * @flags: optional flags like DRM_BUDDY_CLEARED - */ -void drm_buddy_free_list(struct drm_buddy *mm, - struct list_head *objects, - unsigned int flags) -{ - bool mark_clear = flags & DRM_BUDDY_CLEARED; - - __drm_buddy_free_list(mm, objects, mark_clear, !mark_clear); -} -EXPORT_SYMBOL(drm_buddy_free_list); - -static bool block_incompatible(struct drm_buddy_block *block, unsigned int flags) -{ - bool needs_clear = flags & DRM_BUDDY_CLEAR_ALLOCATION; - - return needs_clear != drm_buddy_block_is_clear(block); -} - -static struct drm_buddy_block * -__alloc_range_bias(struct drm_buddy *mm, - u64 start, u64 end, - unsigned int order, - unsigned long flags, - bool fallback) -{ - u64 req_size = mm->chunk_size << order; - struct drm_buddy_block *block; - struct drm_buddy_block *buddy; - LIST_HEAD(dfs); - int err; - int i; - - end = end - 1; - - for (i = 0; i < mm->n_roots; ++i) - list_add_tail(&mm->roots[i]->tmp_link, &dfs); - - do { - u64 block_start; - u64 block_end; - - block = list_first_entry_or_null(&dfs, - struct drm_buddy_block, - tmp_link); - if (!block) - break; - - list_del(&block->tmp_link); - - if (drm_buddy_block_order(block) < order) - continue; - - block_start = drm_buddy_block_offset(block); - block_end = block_start + drm_buddy_block_size(mm, block) - 1; - - if (!overlaps(start, end, block_start, block_end)) - continue; - - if (drm_buddy_block_is_allocated(block)) - continue; - - if (block_start < start || block_end > end) { - u64 adjusted_start = max(block_start, start); - u64 adjusted_end = min(block_end, end); - - if (round_down(adjusted_end + 1, req_size) <= - round_up(adjusted_start, req_size)) - continue; - } - - if (!fallback && block_incompatible(block, flags)) - continue; - - if (contains(start, end, block_start, block_end) && - order == drm_buddy_block_order(block)) { - /* - * Find the free block within the range. - */ - if (drm_buddy_block_is_free(block)) - return block; - - continue; - } - - if (!drm_buddy_block_is_split(block)) { - err = split_block(mm, block); - if (unlikely(err)) - goto err_undo; - } - - list_add(&block->right->tmp_link, &dfs); - list_add(&block->left->tmp_link, &dfs); - } while (1); - - return ERR_PTR(-ENOSPC); - -err_undo: - /* - * We really don't want to leave around a bunch of split blocks, since - * bigger is better, so make sure we merge everything back before we - * free the allocated blocks. - */ - buddy = __get_buddy(block); - if (buddy && - (drm_buddy_block_is_free(block) && - drm_buddy_block_is_free(buddy))) - __drm_buddy_free(mm, block, false); - return ERR_PTR(err); -} - -static struct drm_buddy_block * -__drm_buddy_alloc_range_bias(struct drm_buddy *mm, - u64 start, u64 end, - unsigned int order, - unsigned long flags) -{ - struct drm_buddy_block *block; - bool fallback = false; - - block = __alloc_range_bias(mm, start, end, order, - flags, fallback); - if (IS_ERR(block)) - return __alloc_range_bias(mm, start, end, order, - flags, !fallback); - - return block; -} - -static struct drm_buddy_block * -get_maxblock(struct drm_buddy *mm, - unsigned int order, - enum drm_buddy_free_tree tree) -{ - struct drm_buddy_block *max_block = NULL, *block = NULL; - struct rb_root *root; - unsigned int i; - - for (i = order; i <= mm->max_order; ++i) { - root = &mm->free_trees[tree][i]; - block = rbtree_last_free_block(root); - if (!block) - continue; - - if (!max_block) { - max_block = block; - continue; - } - - if (drm_buddy_block_offset(block) > - drm_buddy_block_offset(max_block)) { - max_block = block; - } - } - - return max_block; -} - -static struct drm_buddy_block * -alloc_from_freetree(struct drm_buddy *mm, - unsigned int order, - unsigned long flags) -{ - struct drm_buddy_block *block = NULL; - struct rb_root *root; - enum drm_buddy_free_tree tree; - unsigned int tmp; - int err; - - tree = (flags & DRM_BUDDY_CLEAR_ALLOCATION) ? - DRM_BUDDY_CLEAR_TREE : DRM_BUDDY_DIRTY_TREE; - - if (flags & DRM_BUDDY_TOPDOWN_ALLOCATION) { - block = get_maxblock(mm, order, tree); - if (block) - /* Store the obtained block order */ - tmp = drm_buddy_block_order(block); - } else { - for (tmp = order; tmp <= mm->max_order; ++tmp) { - /* Get RB tree root for this order and tree */ - root = &mm->free_trees[tree][tmp]; - block = rbtree_last_free_block(root); - if (block) - break; - } - } - - if (!block) { - /* Try allocating from the other tree */ - tree = (tree == DRM_BUDDY_CLEAR_TREE) ? - DRM_BUDDY_DIRTY_TREE : DRM_BUDDY_CLEAR_TREE; - - for (tmp = order; tmp <= mm->max_order; ++tmp) { - root = &mm->free_trees[tree][tmp]; - block = rbtree_last_free_block(root); - if (block) - break; - } - - if (!block) - return ERR_PTR(-ENOSPC); - } - - BUG_ON(!drm_buddy_block_is_free(block)); - - while (tmp != order) { - err = split_block(mm, block); - if (unlikely(err)) - goto err_undo; - - block = block->right; - tmp--; - } - return block; - -err_undo: - if (tmp != order) - __drm_buddy_free(mm, block, false); - return ERR_PTR(err); -} - -static int __alloc_range(struct drm_buddy *mm, - struct list_head *dfs, - u64 start, u64 size, - struct list_head *blocks, - u64 *total_allocated_on_err) -{ - struct drm_buddy_block *block; - struct drm_buddy_block *buddy; - u64 total_allocated = 0; - LIST_HEAD(allocated); - u64 end; - int err; - - end = start + size - 1; - - do { - u64 block_start; - u64 block_end; - - block = list_first_entry_or_null(dfs, - struct drm_buddy_block, - tmp_link); - if (!block) - break; - - list_del(&block->tmp_link); - - block_start = drm_buddy_block_offset(block); - block_end = block_start + drm_buddy_block_size(mm, block) - 1; - - if (!overlaps(start, end, block_start, block_end)) - continue; - - if (drm_buddy_block_is_allocated(block)) { - err = -ENOSPC; - goto err_free; - } - - if (contains(start, end, block_start, block_end)) { - if (drm_buddy_block_is_free(block)) { - mark_allocated(mm, block); - total_allocated += drm_buddy_block_size(mm, block); - mm->avail -= drm_buddy_block_size(mm, block); - if (drm_buddy_block_is_clear(block)) - mm->clear_avail -= drm_buddy_block_size(mm, block); - list_add_tail(&block->link, &allocated); - continue; - } else if (!mm->clear_avail) { - err = -ENOSPC; - goto err_free; - } - } - - if (!drm_buddy_block_is_split(block)) { - err = split_block(mm, block); - if (unlikely(err)) - goto err_undo; - } - - list_add(&block->right->tmp_link, dfs); - list_add(&block->left->tmp_link, dfs); - } while (1); - - if (total_allocated < size) { - err = -ENOSPC; - goto err_free; - } - - list_splice_tail(&allocated, blocks); - - return 0; - -err_undo: - /* - * We really don't want to leave around a bunch of split blocks, since - * bigger is better, so make sure we merge everything back before we - * free the allocated blocks. - */ - buddy = __get_buddy(block); - if (buddy && - (drm_buddy_block_is_free(block) && - drm_buddy_block_is_free(buddy))) - __drm_buddy_free(mm, block, false); - -err_free: - if (err == -ENOSPC && total_allocated_on_err) { - list_splice_tail(&allocated, blocks); - *total_allocated_on_err = total_allocated; - } else { - drm_buddy_free_list_internal(mm, &allocated); - } - - return err; -} - -static int __drm_buddy_alloc_range(struct drm_buddy *mm, - u64 start, - u64 size, - u64 *total_allocated_on_err, - struct list_head *blocks) -{ - LIST_HEAD(dfs); - int i; - - for (i = 0; i < mm->n_roots; ++i) - list_add_tail(&mm->roots[i]->tmp_link, &dfs); - - return __alloc_range(mm, &dfs, start, size, - blocks, total_allocated_on_err); -} - -static int __alloc_contig_try_harder(struct drm_buddy *mm, - u64 size, - u64 min_block_size, - struct list_head *blocks) -{ - u64 rhs_offset, lhs_offset, lhs_size, filled; - struct drm_buddy_block *block; - unsigned int tree, order; - LIST_HEAD(blocks_lhs); - unsigned long pages; - u64 modify_size; - int err; - - modify_size = rounddown_pow_of_two(size); - pages = modify_size >> ilog2(mm->chunk_size); - order = fls(pages) - 1; - if (order == 0) - return -ENOSPC; - - for_each_free_tree(tree) { - struct rb_root *root; - struct rb_node *iter; - - root = &mm->free_trees[tree][order]; - if (rbtree_is_empty(root)) - continue; - - iter = rb_last(root); - while (iter) { - block = rbtree_get_free_block(iter); - - /* Allocate blocks traversing RHS */ - rhs_offset = drm_buddy_block_offset(block); - err = __drm_buddy_alloc_range(mm, rhs_offset, size, - &filled, blocks); - if (!err || err != -ENOSPC) - return err; - - lhs_size = max((size - filled), min_block_size); - if (!IS_ALIGNED(lhs_size, min_block_size)) - lhs_size = round_up(lhs_size, min_block_size); - - /* Allocate blocks traversing LHS */ - lhs_offset = drm_buddy_block_offset(block) - lhs_size; - err = __drm_buddy_alloc_range(mm, lhs_offset, lhs_size, - NULL, &blocks_lhs); - if (!err) { - list_splice(&blocks_lhs, blocks); - return 0; - } else if (err != -ENOSPC) { - drm_buddy_free_list_internal(mm, blocks); - return err; - } - /* Free blocks for the next iteration */ - drm_buddy_free_list_internal(mm, blocks); - - iter = rb_prev(iter); - } - } - - return -ENOSPC; -} - -/** - * drm_buddy_block_trim - free unused pages - * - * @mm: DRM buddy manager - * @start: start address to begin the trimming. - * @new_size: original size requested - * @blocks: Input and output list of allocated blocks. - * MUST contain single block as input to be trimmed. - * On success will contain the newly allocated blocks - * making up the @new_size. Blocks always appear in - * ascending order - * - * For contiguous allocation, we round up the size to the nearest - * power of two value, drivers consume *actual* size, so remaining - * portions are unused and can be optionally freed with this function - * - * Returns: - * 0 on success, error code on failure. - */ -int drm_buddy_block_trim(struct drm_buddy *mm, - u64 *start, - u64 new_size, - struct list_head *blocks) -{ - struct drm_buddy_block *parent; - struct drm_buddy_block *block; - u64 block_start, block_end; - LIST_HEAD(dfs); - u64 new_start; - int err; - - if (!list_is_singular(blocks)) - return -EINVAL; - - block = list_first_entry(blocks, - struct drm_buddy_block, - link); - - block_start = drm_buddy_block_offset(block); - block_end = block_start + drm_buddy_block_size(mm, block); - - if (WARN_ON(!drm_buddy_block_is_allocated(block))) - return -EINVAL; - - if (new_size > drm_buddy_block_size(mm, block)) - return -EINVAL; - - if (!new_size || !IS_ALIGNED(new_size, mm->chunk_size)) - return -EINVAL; - - if (new_size == drm_buddy_block_size(mm, block)) - return 0; - - new_start = block_start; - if (start) { - new_start = *start; - - if (new_start < block_start) - return -EINVAL; - - if (!IS_ALIGNED(new_start, mm->chunk_size)) - return -EINVAL; - - if (range_overflows(new_start, new_size, block_end)) - return -EINVAL; - } - - list_del(&block->link); - mark_free(mm, block); - mm->avail += drm_buddy_block_size(mm, block); - if (drm_buddy_block_is_clear(block)) - mm->clear_avail += drm_buddy_block_size(mm, block); - - /* Prevent recursively freeing this node */ - parent = block->parent; - block->parent = NULL; - - list_add(&block->tmp_link, &dfs); - err = __alloc_range(mm, &dfs, new_start, new_size, blocks, NULL); - if (err) { - mark_allocated(mm, block); - mm->avail -= drm_buddy_block_size(mm, block); - if (drm_buddy_block_is_clear(block)) - mm->clear_avail -= drm_buddy_block_size(mm, block); - list_add(&block->link, blocks); - } - - block->parent = parent; - return err; -} -EXPORT_SYMBOL(drm_buddy_block_trim); - -static struct drm_buddy_block * -__drm_buddy_alloc_blocks(struct drm_buddy *mm, - u64 start, u64 end, - unsigned int order, - unsigned long flags) -{ - if (flags & DRM_BUDDY_RANGE_ALLOCATION) - /* Allocate traversing within the range */ - return __drm_buddy_alloc_range_bias(mm, start, end, - order, flags); - else - /* Allocate from freetree */ - return alloc_from_freetree(mm, order, flags); -} - -/** - * drm_buddy_alloc_blocks - allocate power-of-two blocks - * - * @mm: DRM buddy manager to allocate from - * @start: start of the allowed range for this block - * @end: end of the allowed range for this block - * @size: size of the allocation in bytes - * @min_block_size: alignment of the allocation - * @blocks: output list head to add allocated blocks - * @flags: DRM_BUDDY_*_ALLOCATION flags - * - * alloc_range_bias() called on range limitations, which traverses - * the tree and returns the desired block. - * - * alloc_from_freetree() called when *no* range restrictions - * are enforced, which picks the block from the freetree. - * - * Returns: - * 0 on success, error code on failure. - */ -int drm_buddy_alloc_blocks(struct drm_buddy *mm, - u64 start, u64 end, u64 size, - u64 min_block_size, - struct list_head *blocks, - unsigned long flags) -{ - struct drm_buddy_block *block = NULL; - u64 original_size, original_min_size; - unsigned int min_order, order; - LIST_HEAD(allocated); - unsigned long pages; - int err; - - if (size < mm->chunk_size) - return -EINVAL; - - if (min_block_size < mm->chunk_size) - return -EINVAL; - - if (!is_power_of_2(min_block_size)) - return -EINVAL; - - if (!IS_ALIGNED(start | end | size, mm->chunk_size)) - return -EINVAL; - - if (end > mm->size) - return -EINVAL; - - if (range_overflows(start, size, mm->size)) - return -EINVAL; - - /* Actual range allocation */ - if (start + size == end) { - if (!IS_ALIGNED(start | end, min_block_size)) - return -EINVAL; - - return __drm_buddy_alloc_range(mm, start, size, NULL, blocks); - } - - original_size = size; - original_min_size = min_block_size; - - /* Roundup the size to power of 2 */ - if (flags & DRM_BUDDY_CONTIGUOUS_ALLOCATION) { - size = roundup_pow_of_two(size); - min_block_size = size; - /* Align size value to min_block_size */ - } else if (!IS_ALIGNED(size, min_block_size)) { - size = round_up(size, min_block_size); - } - - pages = size >> ilog2(mm->chunk_size); - order = fls(pages) - 1; - min_order = ilog2(min_block_size) - ilog2(mm->chunk_size); - - do { - order = min(order, (unsigned int)fls(pages) - 1); - BUG_ON(order > mm->max_order); - BUG_ON(order < min_order); - - do { - block = __drm_buddy_alloc_blocks(mm, start, - end, - order, - flags); - if (!IS_ERR(block)) - break; - - if (order-- == min_order) { - /* Try allocation through force merge method */ - if (mm->clear_avail && - !__force_merge(mm, start, end, min_order)) { - block = __drm_buddy_alloc_blocks(mm, start, - end, - min_order, - flags); - if (!IS_ERR(block)) { - order = min_order; - break; - } - } - - /* - * Try contiguous block allocation through - * try harder method. - */ - if (flags & DRM_BUDDY_CONTIGUOUS_ALLOCATION && - !(flags & DRM_BUDDY_RANGE_ALLOCATION)) - return __alloc_contig_try_harder(mm, - original_size, - original_min_size, - blocks); - err = -ENOSPC; - goto err_free; - } - } while (1); - - mark_allocated(mm, block); - mm->avail -= drm_buddy_block_size(mm, block); - if (drm_buddy_block_is_clear(block)) - mm->clear_avail -= drm_buddy_block_size(mm, block); - kmemleak_update_trace(block); - list_add_tail(&block->link, &allocated); - - pages -= BIT(order); - - if (!pages) - break; - } while (1); - - /* Trim the allocated block to the required size */ - if (!(flags & DRM_BUDDY_TRIM_DISABLE) && - original_size != size) { - struct list_head *trim_list; - LIST_HEAD(temp); - u64 trim_size; - - trim_list = &allocated; - trim_size = original_size; - - if (!list_is_singular(&allocated)) { - block = list_last_entry(&allocated, typeof(*block), link); - list_move(&block->link, &temp); - trim_list = &temp; - trim_size = drm_buddy_block_size(mm, block) - - (size - original_size); - } - - drm_buddy_block_trim(mm, - NULL, - trim_size, - trim_list); - - if (!list_empty(&temp)) - list_splice_tail(trim_list, &allocated); - } - - list_splice_tail(&allocated, blocks); - return 0; - -err_free: - drm_buddy_free_list_internal(mm, &allocated); - return err; -} -EXPORT_SYMBOL(drm_buddy_alloc_blocks); - /** * drm_buddy_block_print - print block information * - * @mm: DRM buddy manager - * @block: DRM buddy block + * @mm: GPU buddy manager + * @block: GPU buddy block * @p: DRM printer to use */ -void drm_buddy_block_print(struct drm_buddy *mm, - struct drm_buddy_block *block, +void drm_buddy_block_print(struct gpu_buddy *mm, struct gpu_buddy_block *block, struct drm_printer *p) { - u64 start = drm_buddy_block_offset(block); - u64 size = drm_buddy_block_size(mm, block); + u64 start = gpu_buddy_block_offset(block); + u64 size = gpu_buddy_block_size(mm, block); drm_printf(p, "%#018llx-%#018llx: %llu\n", start, start + size, size); } @@ -1267,27 +30,32 @@ EXPORT_SYMBOL(drm_buddy_block_print); /** * drm_buddy_print - print allocator state * - * @mm: DRM buddy manager + * @mm: GPU buddy manager * @p: DRM printer to use */ -void drm_buddy_print(struct drm_buddy *mm, struct drm_printer *p) +void drm_buddy_print(struct gpu_buddy *mm, struct drm_printer *p) { int order; - drm_printf(p, "chunk_size: %lluKiB, total: %lluMiB, free: %lluMiB, clear_free: %lluMiB\n", - mm->chunk_size >> 10, mm->size >> 20, mm->avail >> 20, mm->clear_avail >> 20); + drm_printf( + p, + "chunk_size: %lluKiB, total: %lluMiB, free: %lluMiB, clear_free: %lluMiB\n", + mm->chunk_size >> 10, mm->size >> 20, mm->avail >> 20, + mm->clear_avail >> 20); for (order = mm->max_order; order >= 0; order--) { - struct drm_buddy_block *block, *tmp; + struct gpu_buddy_block *block, *tmp; struct rb_root *root; u64 count = 0, free; unsigned int tree; - for_each_free_tree(tree) { + for_each_free_tree(tree) + { root = &mm->free_trees[tree][order]; - rbtree_postorder_for_each_entry_safe(block, tmp, root, rb) { - BUG_ON(!drm_buddy_block_is_free(block)); + rbtree_postorder_for_each_entry_safe(block, tmp, root, + rb) { + BUG_ON(!gpu_buddy_block_is_free(block)); count++; } } @@ -1305,22 +73,5 @@ void drm_buddy_print(struct drm_buddy *mm, struct drm_printer *p) } EXPORT_SYMBOL(drm_buddy_print); -static void drm_buddy_module_exit(void) -{ - kmem_cache_destroy(slab_blocks); -} - -static int __init drm_buddy_module_init(void) -{ - slab_blocks = KMEM_CACHE(drm_buddy_block, 0); - if (!slab_blocks) - return -ENOMEM; - - return 0; -} - -module_init(drm_buddy_module_init); -module_exit(drm_buddy_module_exit); - -MODULE_DESCRIPTION("DRM Buddy Allocator"); +MODULE_DESCRIPTION("DRM-specific GPU Buddy Allocator Print Helpers"); MODULE_LICENSE("Dual MIT/GPL"); diff --git a/drivers/gpu/drm/i915/Kconfig b/drivers/gpu/drm/i915/Kconfig index 5e939004b646..859aeca87c19 100644 --- a/drivers/gpu/drm/i915/Kconfig +++ b/drivers/gpu/drm/i915/Kconfig @@ -38,6 +38,7 @@ config DRM_I915 select CEC_CORE if CEC_NOTIFIER select VMAP_PFN select DRM_TTM + select GPU_BUDDY select DRM_BUDDY select AUXILIARY_BUS help diff --git a/drivers/gpu/drm/i915/i915_scatterlist.c b/drivers/gpu/drm/i915/i915_scatterlist.c index 4d830740946d..6a34dae13769 100644 --- a/drivers/gpu/drm/i915/i915_scatterlist.c +++ b/drivers/gpu/drm/i915/i915_scatterlist.c @@ -7,7 +7,7 @@ #include "i915_scatterlist.h" #include "i915_ttm_buddy_manager.h" -#include <drm/drm_buddy.h> +#include <linux/gpu_buddy.h> #include <drm/drm_mm.h> #include <linux/slab.h> @@ -167,9 +167,9 @@ struct i915_refct_sgt *i915_rsgt_from_buddy_resource(struct ttm_resource *res, struct i915_ttm_buddy_resource *bman_res = to_ttm_buddy_resource(res); const u64 size = res->size; const u32 max_segment = round_down(UINT_MAX, page_alignment); - struct drm_buddy *mm = bman_res->mm; + struct gpu_buddy *mm = bman_res->mm; struct list_head *blocks = &bman_res->blocks; - struct drm_buddy_block *block; + struct gpu_buddy_block *block; struct i915_refct_sgt *rsgt; struct scatterlist *sg; struct sg_table *st; @@ -202,8 +202,8 @@ struct i915_refct_sgt *i915_rsgt_from_buddy_resource(struct ttm_resource *res, list_for_each_entry(block, blocks, link) { u64 block_size, offset; - block_size = min_t(u64, size, drm_buddy_block_size(mm, block)); - offset = drm_buddy_block_offset(block); + block_size = min_t(u64, size, gpu_buddy_block_size(mm, block)); + offset = gpu_buddy_block_offset(block); while (block_size) { u64 len; diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c index d5c6e6605086..f43d7f2771ad 100644 --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c @@ -4,6 +4,7 @@ */ #include <linux/slab.h> +#include <linux/gpu_buddy.h> #include <drm/drm_buddy.h> #include <drm/drm_print.h> @@ -16,7 +17,7 @@ struct i915_ttm_buddy_manager { struct ttm_resource_manager manager; - struct drm_buddy mm; + struct gpu_buddy mm; struct list_head reserved; struct mutex lock; unsigned long visible_size; @@ -38,7 +39,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man, { struct i915_ttm_buddy_manager *bman = to_buddy_manager(man); struct i915_ttm_buddy_resource *bman_res; - struct drm_buddy *mm = &bman->mm; + struct gpu_buddy *mm = &bman->mm; unsigned long n_pages, lpfn; u64 min_page_size; u64 size; @@ -57,13 +58,13 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man, bman_res->mm = mm; if (place->flags & TTM_PL_FLAG_TOPDOWN) - bman_res->flags |= DRM_BUDDY_TOPDOWN_ALLOCATION; + bman_res->flags |= GPU_BUDDY_TOPDOWN_ALLOCATION; if (place->flags & TTM_PL_FLAG_CONTIGUOUS) - bman_res->flags |= DRM_BUDDY_CONTIGUOUS_ALLOCATION; + bman_res->flags |= GPU_BUDDY_CONTIGUOUS_ALLOCATION; if (place->fpfn || lpfn != man->size) - bman_res->flags |= DRM_BUDDY_RANGE_ALLOCATION; + bman_res->flags |= GPU_BUDDY_RANGE_ALLOCATION; GEM_BUG_ON(!bman_res->base.size); size = bman_res->base.size; @@ -89,7 +90,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man, goto err_free_res; } - err = drm_buddy_alloc_blocks(mm, (u64)place->fpfn << PAGE_SHIFT, + err = gpu_buddy_alloc_blocks(mm, (u64)place->fpfn << PAGE_SHIFT, (u64)lpfn << PAGE_SHIFT, (u64)n_pages << PAGE_SHIFT, min_page_size, @@ -101,15 +102,15 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man, if (lpfn <= bman->visible_size) { bman_res->used_visible_size = PFN_UP(bman_res->base.size); } else { - struct drm_buddy_block *block; + struct gpu_buddy_block *block; list_for_each_entry(block, &bman_res->blocks, link) { unsigned long start = - drm_buddy_block_offset(block) >> PAGE_SHIFT; + gpu_buddy_block_offset(block) >> PAGE_SHIFT; if (start < bman->visible_size) { unsigned long end = start + - (drm_buddy_block_size(mm, block) >> PAGE_SHIFT); + (gpu_buddy_block_size(mm, block) >> PAGE_SHIFT); bman_res->used_visible_size += min(end, bman->visible_size) - start; @@ -126,7 +127,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man, return 0; err_free_blocks: - drm_buddy_free_list(mm, &bman_res->blocks, 0); + gpu_buddy_free_list(mm, &bman_res->blocks, 0); mutex_unlock(&bman->lock); err_free_res: ttm_resource_fini(man, &bman_res->base); @@ -141,7 +142,7 @@ static void i915_ttm_buddy_man_free(struct ttm_resource_manager *man, struct i915_ttm_buddy_manager *bman = to_buddy_manager(man); mutex_lock(&bman->lock); - drm_buddy_free_list(&bman->mm, &bman_res->blocks, 0); + gpu_buddy_free_list(&bman->mm, &bman_res->blocks, 0); bman->visible_avail += bman_res->used_visible_size; mutex_unlock(&bman->lock); @@ -156,8 +157,8 @@ static bool i915_ttm_buddy_man_intersects(struct ttm_resource_manager *man, { struct i915_ttm_buddy_resource *bman_res = to_ttm_buddy_resource(res); struct i915_ttm_buddy_manager *bman = to_buddy_manager(man); - struct drm_buddy *mm = &bman->mm; - struct drm_buddy_block *block; + struct gpu_buddy *mm = &bman->mm; + struct gpu_buddy_block *block; if (!place->fpfn && !place->lpfn) return true; @@ -176,9 +177,9 @@ static bool i915_ttm_buddy_man_intersects(struct ttm_resource_manager *man, /* Check each drm buddy block individually */ list_for_each_entry(block, &bman_res->blocks, link) { unsigned long fpfn = - drm_buddy_block_offset(block) >> PAGE_SHIFT; + gpu_buddy_block_offset(block) >> PAGE_SHIFT; unsigned long lpfn = fpfn + - (drm_buddy_block_size(mm, block) >> PAGE_SHIFT); + (gpu_buddy_block_size(mm, block) >> PAGE_SHIFT); if (place->fpfn < lpfn && place->lpfn > fpfn) return true; @@ -194,8 +195,8 @@ static bool i915_ttm_buddy_man_compatible(struct ttm_resource_manager *man, { struct i915_ttm_buddy_resource *bman_res = to_ttm_buddy_resource(res); struct i915_ttm_buddy_manager *bman = to_buddy_manager(man); - struct drm_buddy *mm = &bman->mm; - struct drm_buddy_block *block; + struct gpu_buddy *mm = &bman->mm; + struct gpu_buddy_block *block; if (!place->fpfn && !place->lpfn) return true; @@ -209,9 +210,9 @@ static bool i915_ttm_buddy_man_compatible(struct ttm_resource_manager *man, /* Check each drm buddy block individually */ list_for_each_entry(block, &bman_res->blocks, link) { unsigned long fpfn = - drm_buddy_block_offset(block) >> PAGE_SHIFT; + gpu_buddy_block_offset(block) >> PAGE_SHIFT; unsigned long lpfn = fpfn + - (drm_buddy_block_size(mm, block) >> PAGE_SHIFT); + (gpu_buddy_block_size(mm, block) >> PAGE_SHIFT); if (fpfn < place->fpfn || lpfn > place->lpfn) return false; @@ -224,7 +225,7 @@ static void i915_ttm_buddy_man_debug(struct ttm_resource_manager *man, struct drm_printer *printer) { struct i915_ttm_buddy_manager *bman = to_buddy_manager(man); - struct drm_buddy_block *block; + struct gpu_buddy_block *block; mutex_lock(&bman->lock); drm_printf(printer, "default_page_size: %lluKiB\n", @@ -293,7 +294,7 @@ int i915_ttm_buddy_man_init(struct ttm_device *bdev, if (!bman) return -ENOMEM; - err = drm_buddy_init(&bman->mm, size, chunk_size); + err = gpu_buddy_init(&bman->mm, size, chunk_size); if (err) goto err_free_bman; @@ -333,7 +334,7 @@ int i915_ttm_buddy_man_fini(struct ttm_device *bdev, unsigned int type) { struct ttm_resource_manager *man = ttm_manager_type(bdev, type); struct i915_ttm_buddy_manager *bman = to_buddy_manager(man); - struct drm_buddy *mm = &bman->mm; + struct gpu_buddy *mm = &bman->mm; int ret; ttm_resource_manager_set_used(man, false); @@ -345,8 +346,8 @@ int i915_ttm_buddy_man_fini(struct ttm_device *bdev, unsigned int type) ttm_set_driver_manager(bdev, type, NULL); mutex_lock(&bman->lock); - drm_buddy_free_list(mm, &bman->reserved, 0); - drm_buddy_fini(mm); + gpu_buddy_free_list(mm, &bman->reserved, 0); + gpu_buddy_fini(mm); bman->visible_avail += bman->visible_reserved; WARN_ON_ONCE(bman->visible_avail != bman->visible_size); mutex_unlock(&bman->lock); @@ -371,15 +372,15 @@ int i915_ttm_buddy_man_reserve(struct ttm_resource_manager *man, u64 start, u64 size) { struct i915_ttm_buddy_manager *bman = to_buddy_manager(man); - struct drm_buddy *mm = &bman->mm; + struct gpu_buddy *mm = &bman->mm; unsigned long fpfn = start >> PAGE_SHIFT; unsigned long flags = 0; int ret; - flags |= DRM_BUDDY_RANGE_ALLOCATION; + flags |= GPU_BUDDY_RANGE_ALLOCATION; mutex_lock(&bman->lock); - ret = drm_buddy_alloc_blocks(mm, start, + ret = gpu_buddy_alloc_blocks(mm, start, start + size, size, mm->chunk_size, &bman->reserved, diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h index d64620712830..4a92dcf09766 100644 --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h @@ -13,14 +13,14 @@ struct ttm_device; struct ttm_resource_manager; -struct drm_buddy; +struct gpu_buddy; /** * struct i915_ttm_buddy_resource * * @base: struct ttm_resource base class we extend * @blocks: the list of struct i915_buddy_block for this resource/allocation - * @flags: DRM_BUDDY_*_ALLOCATION flags + * @flags: GPU_BUDDY_*_ALLOCATION flags * @used_visible_size: How much of this resource, if any, uses the CPU visible * portion, in pages. * @mm: the struct i915_buddy_mm for this resource @@ -33,7 +33,7 @@ struct i915_ttm_buddy_resource { struct list_head blocks; unsigned long flags; unsigned long used_visible_size; - struct drm_buddy *mm; + struct gpu_buddy *mm; }; /** diff --git a/drivers/gpu/drm/i915/selftests/intel_memory_region.c b/drivers/gpu/drm/i915/selftests/intel_memory_region.c index 7b856b5090f9..8307390943a2 100644 --- a/drivers/gpu/drm/i915/selftests/intel_memory_region.c +++ b/drivers/gpu/drm/i915/selftests/intel_memory_region.c @@ -6,7 +6,7 @@ #include <linux/prime_numbers.h> #include <linux/sort.h> -#include <drm/drm_buddy.h> +#include <linux/gpu_buddy.h> #include "../i915_selftest.h" @@ -371,7 +371,7 @@ static int igt_mock_splintered_region(void *arg) struct drm_i915_private *i915 = mem->i915; struct i915_ttm_buddy_resource *res; struct drm_i915_gem_object *obj; - struct drm_buddy *mm; + struct gpu_buddy *mm; unsigned int expected_order; LIST_HEAD(objects); u64 size; @@ -447,8 +447,8 @@ static int igt_mock_max_segment(void *arg) struct drm_i915_private *i915 = mem->i915; struct i915_ttm_buddy_resource *res; struct drm_i915_gem_object *obj; - struct drm_buddy_block *block; - struct drm_buddy *mm; + struct gpu_buddy_block *block; + struct gpu_buddy *mm; struct list_head *blocks; struct scatterlist *sg; I915_RND_STATE(prng); @@ -487,8 +487,8 @@ static int igt_mock_max_segment(void *arg) mm = res->mm; size = 0; list_for_each_entry(block, blocks, link) { - if (drm_buddy_block_size(mm, block) > size) - size = drm_buddy_block_size(mm, block); + if (gpu_buddy_block_size(mm, block) > size) + size = gpu_buddy_block_size(mm, block); } if (size < max_segment) { pr_err("%s: Failed to create a huge contiguous block [> %u], largest block %lld\n", @@ -527,14 +527,14 @@ static u64 igt_object_mappable_total(struct drm_i915_gem_object *obj) struct intel_memory_region *mr = obj->mm.region; struct i915_ttm_buddy_resource *bman_res = to_ttm_buddy_resource(obj->mm.res); - struct drm_buddy *mm = bman_res->mm; - struct drm_buddy_block *block; + struct gpu_buddy *mm = bman_res->mm; + struct gpu_buddy_block *block; u64 total; total = 0; list_for_each_entry(block, &bman_res->blocks, link) { - u64 start = drm_buddy_block_offset(block); - u64 end = start + drm_buddy_block_size(mm, block); + u64 start = gpu_buddy_block_offset(block); + u64 end = start + gpu_buddy_block_size(mm, block); if (start < resource_size(&mr->io)) total += min_t(u64, end, resource_size(&mr->io)) - start; diff --git a/drivers/gpu/drm/tests/Makefile b/drivers/gpu/drm/tests/Makefile index 87d5d5f9332a..d2e2e3d8349a 100644 --- a/drivers/gpu/drm/tests/Makefile +++ b/drivers/gpu/drm/tests/Makefile @@ -7,7 +7,6 @@ obj-$(CONFIG_DRM_KUNIT_TEST) += \ drm_atomic_test.o \ drm_atomic_state_test.o \ drm_bridge_test.o \ - drm_buddy_test.o \ drm_cmdline_parser_test.o \ drm_connector_test.o \ drm_damage_helper_test.o \ diff --git a/drivers/gpu/drm/ttm/tests/ttm_bo_validate_test.c b/drivers/gpu/drm/ttm/tests/ttm_bo_validate_test.c index 2eda87882e65..ffa12473077c 100644 --- a/drivers/gpu/drm/ttm/tests/ttm_bo_validate_test.c +++ b/drivers/gpu/drm/ttm/tests/ttm_bo_validate_test.c @@ -3,6 +3,7 @@ * Copyright © 2023 Intel Corporation */ #include <linux/delay.h> +#include <linux/gpu_buddy.h> #include <linux/kthread.h> #include <drm/ttm/ttm_resource.h> @@ -251,7 +252,7 @@ static void ttm_bo_validate_basic(struct kunit *test) NULL, &dummy_ttm_bo_destroy); KUNIT_EXPECT_EQ(test, err, 0); - snd_place = ttm_place_kunit_init(test, snd_mem, DRM_BUDDY_TOPDOWN_ALLOCATION); + snd_place = ttm_place_kunit_init(test, snd_mem, GPU_BUDDY_TOPDOWN_ALLOCATION); snd_placement = ttm_placement_kunit_init(test, snd_place, 1); err = ttm_bo_validate(bo, snd_placement, &ctx_val); @@ -263,7 +264,7 @@ static void ttm_bo_validate_basic(struct kunit *test) KUNIT_EXPECT_TRUE(test, ttm_tt_is_populated(bo->ttm)); KUNIT_EXPECT_EQ(test, bo->resource->mem_type, snd_mem); KUNIT_EXPECT_EQ(test, bo->resource->placement, - DRM_BUDDY_TOPDOWN_ALLOCATION); + GPU_BUDDY_TOPDOWN_ALLOCATION); ttm_bo_fini(bo); ttm_mock_manager_fini(priv->ttm_dev, snd_mem); diff --git a/drivers/gpu/drm/ttm/tests/ttm_mock_manager.c b/drivers/gpu/drm/ttm/tests/ttm_mock_manager.c index dd395229e388..294d56d9067e 100644 --- a/drivers/gpu/drm/ttm/tests/ttm_mock_manager.c +++ b/drivers/gpu/drm/ttm/tests/ttm_mock_manager.c @@ -31,7 +31,7 @@ static int ttm_mock_manager_alloc(struct ttm_resource_manager *man, { struct ttm_mock_manager *manager = to_mock_mgr(man); struct ttm_mock_resource *mock_res; - struct drm_buddy *mm = &manager->mm; + struct gpu_buddy *mm = &manager->mm; u64 lpfn, fpfn, alloc_size; int err; @@ -47,14 +47,14 @@ static int ttm_mock_manager_alloc(struct ttm_resource_manager *man, INIT_LIST_HEAD(&mock_res->blocks); if (place->flags & TTM_PL_FLAG_TOPDOWN) - mock_res->flags |= DRM_BUDDY_TOPDOWN_ALLOCATION; + mock_res->flags |= GPU_BUDDY_TOPDOWN_ALLOCATION; if (place->flags & TTM_PL_FLAG_CONTIGUOUS) - mock_res->flags |= DRM_BUDDY_CONTIGUOUS_ALLOCATION; + mock_res->flags |= GPU_BUDDY_CONTIGUOUS_ALLOCATION; alloc_size = (uint64_t)mock_res->base.size; mutex_lock(&manager->lock); - err = drm_buddy_alloc_blocks(mm, fpfn, lpfn, alloc_size, + err = gpu_buddy_alloc_blocks(mm, fpfn, lpfn, alloc_size, manager->default_page_size, &mock_res->blocks, mock_res->flags); @@ -67,7 +67,7 @@ static int ttm_mock_manager_alloc(struct ttm_resource_manager *man, return 0; error_free_blocks: - drm_buddy_free_list(mm, &mock_res->blocks, 0); + gpu_buddy_free_list(mm, &mock_res->blocks, 0); ttm_resource_fini(man, &mock_res->base); mutex_unlock(&manager->lock); @@ -79,10 +79,10 @@ static void ttm_mock_manager_free(struct ttm_resource_manager *man, { struct ttm_mock_manager *manager = to_mock_mgr(man); struct ttm_mock_resource *mock_res = to_mock_mgr_resource(res); - struct drm_buddy *mm = &manager->mm; + struct gpu_buddy *mm = &manager->mm; mutex_lock(&manager->lock); - drm_buddy_free_list(mm, &mock_res->blocks, 0); + gpu_buddy_free_list(mm, &mock_res->blocks, 0); mutex_unlock(&manager->lock); ttm_resource_fini(man, res); @@ -106,7 +106,7 @@ int ttm_mock_manager_init(struct ttm_device *bdev, u32 mem_type, u32 size) mutex_init(&manager->lock); - err = drm_buddy_init(&manager->mm, size, PAGE_SIZE); + err = gpu_buddy_init(&manager->mm, size, PAGE_SIZE); if (err) { kfree(manager); @@ -142,7 +142,7 @@ void ttm_mock_manager_fini(struct ttm_device *bdev, u32 mem_type) ttm_resource_manager_set_used(man, false); mutex_lock(&mock_man->lock); - drm_buddy_fini(&mock_man->mm); + gpu_buddy_fini(&mock_man->mm); mutex_unlock(&mock_man->lock); ttm_set_driver_manager(bdev, mem_type, NULL); diff --git a/drivers/gpu/drm/ttm/tests/ttm_mock_manager.h b/drivers/gpu/drm/ttm/tests/ttm_mock_manager.h index e4c95f86a467..08710756fd8e 100644 --- a/drivers/gpu/drm/ttm/tests/ttm_mock_manager.h +++ b/drivers/gpu/drm/ttm/tests/ttm_mock_manager.h @@ -5,11 +5,11 @@ #ifndef TTM_MOCK_MANAGER_H #define TTM_MOCK_MANAGER_H -#include <drm/drm_buddy.h> +#include <linux/gpu_buddy.h> struct ttm_mock_manager { struct ttm_resource_manager man; - struct drm_buddy mm; + struct gpu_buddy mm; u64 default_page_size; /* protects allocations of mock buffer objects */ struct mutex lock; diff --git a/drivers/gpu/drm/xe/Kconfig b/drivers/gpu/drm/xe/Kconfig index 4b288eb3f5b0..982ef754742e 100644 --- a/drivers/gpu/drm/xe/Kconfig +++ b/drivers/gpu/drm/xe/Kconfig @@ -11,6 +11,7 @@ config DRM_XE # the shmem_readpage() which depends upon tmpfs select SHMEM select TMPFS + select GPU_BUDDY select DRM_BUDDY select DRM_CLIENT_SELECTION select DRM_KMS_HELPER diff --git a/drivers/gpu/drm/xe/xe_res_cursor.h b/drivers/gpu/drm/xe/xe_res_cursor.h index 4e00008b7081..5f4ab08c0686 100644 --- a/drivers/gpu/drm/xe/xe_res_cursor.h +++ b/drivers/gpu/drm/xe/xe_res_cursor.h @@ -58,7 +58,7 @@ struct xe_res_cursor { /** @dma_addr: Current element in a struct drm_pagemap_addr array */ const struct drm_pagemap_addr *dma_addr; /** @mm: Buddy allocator for VRAM cursor */ - struct drm_buddy *mm; + struct gpu_buddy *mm; /** * @dma_start: DMA start address for the current segment. * This may be different to @dma_addr.addr since elements in @@ -69,7 +69,7 @@ struct xe_res_cursor { u64 dma_seg_size; }; -static struct drm_buddy *xe_res_get_buddy(struct ttm_resource *res) +static struct gpu_buddy *xe_res_get_buddy(struct ttm_resource *res) { struct ttm_resource_manager *mgr; @@ -104,30 +104,30 @@ static inline void xe_res_first(struct ttm_resource *res, case XE_PL_STOLEN: case XE_PL_VRAM0: case XE_PL_VRAM1: { - struct drm_buddy_block *block; + struct gpu_buddy_block *block; struct list_head *head, *next; - struct drm_buddy *mm = xe_res_get_buddy(res); + struct gpu_buddy *mm = xe_res_get_buddy(res); head = &to_xe_ttm_vram_mgr_resource(res)->blocks; block = list_first_entry_or_null(head, - struct drm_buddy_block, + struct gpu_buddy_block, link); if (!block) goto fallback; - while (start >= drm_buddy_block_size(mm, block)) { - start -= drm_buddy_block_size(mm, block); + while (start >= gpu_buddy_block_size(mm, block)) { + start -= gpu_buddy_block_size(mm, block); next = block->link.next; if (next != head) - block = list_entry(next, struct drm_buddy_block, + block = list_entry(next, struct gpu_buddy_block, link); } cur->mm = mm; - cur->start = drm_buddy_block_offset(block) + start; - cur->size = min(drm_buddy_block_size(mm, block) - start, + cur->start = gpu_buddy_block_offset(block) + start; + cur->size = min(gpu_buddy_block_size(mm, block) - start, size); cur->remaining = size; cur->node = block; @@ -259,7 +259,7 @@ static inline void xe_res_first_dma(const struct drm_pagemap_addr *dma_addr, */ static inline void xe_res_next(struct xe_res_cursor *cur, u64 size) { - struct drm_buddy_block *block; + struct gpu_buddy_block *block; struct list_head *next; u64 start; @@ -295,18 +295,18 @@ static inline void xe_res_next(struct xe_res_cursor *cur, u64 size) block = cur->node; next = block->link.next; - block = list_entry(next, struct drm_buddy_block, link); + block = list_entry(next, struct gpu_buddy_block, link); - while (start >= drm_buddy_block_size(cur->mm, block)) { - start -= drm_buddy_block_size(cur->mm, block); + while (start >= gpu_buddy_block_size(cur->mm, block)) { + start -= gpu_buddy_block_size(cur->mm, block); next = block->link.next; - block = list_entry(next, struct drm_buddy_block, link); + block = list_entry(next, struct gpu_buddy_block, link); } - cur->start = drm_buddy_block_offset(block) + start; - cur->size = min(drm_buddy_block_size(cur->mm, block) - start, + cur->start = gpu_buddy_block_offset(block) + start; + cur->size = min(gpu_buddy_block_size(cur->mm, block) - start, cur->remaining); cur->node = block; break; diff --git a/drivers/gpu/drm/xe/xe_svm.c b/drivers/gpu/drm/xe/xe_svm.c index 55c5a0eb82e1..26b59898d4f4 100644 --- a/drivers/gpu/drm/xe/xe_svm.c +++ b/drivers/gpu/drm/xe/xe_svm.c @@ -676,7 +676,7 @@ static u64 block_offset_to_pfn(struct xe_vram_region *vr, u64 offset) return PHYS_PFN(offset + vr->hpa_base); } -static struct drm_buddy *vram_to_buddy(struct xe_vram_region *vram) +static struct gpu_buddy *vram_to_buddy(struct xe_vram_region *vram) { return &vram->ttm.mm; } @@ -687,16 +687,16 @@ static int xe_svm_populate_devmem_pfn(struct drm_pagemap_devmem *devmem_allocati struct xe_bo *bo = to_xe_bo(devmem_allocation); struct ttm_resource *res = bo->ttm.resource; struct list_head *blocks = &to_xe_ttm_vram_mgr_resource(res)->blocks; - struct drm_buddy_block *block; + struct gpu_buddy_block *block; int j = 0; list_for_each_entry(block, blocks, link) { struct xe_vram_region *vr = block->private; - struct drm_buddy *buddy = vram_to_buddy(vr); - u64 block_pfn = block_offset_to_pfn(vr, drm_buddy_block_offset(block)); + struct gpu_buddy *buddy = vram_to_buddy(vr); + u64 block_pfn = block_offset_to_pfn(vr, gpu_buddy_block_offset(block)); int i; - for (i = 0; i < drm_buddy_block_size(buddy, block) >> PAGE_SHIFT; ++i) + for (i = 0; i < gpu_buddy_block_size(buddy, block) >> PAGE_SHIFT; ++i) pfn[j++] = block_pfn + i; } @@ -863,7 +863,7 @@ static int xe_drm_pagemap_populate_mm(struct drm_pagemap *dpagemap, struct xe_vram_region *vr = container_of(dpagemap, typeof(*vr), dpagemap); struct xe_device *xe = vr->xe; struct device *dev = xe->drm.dev; - struct drm_buddy_block *block; + struct gpu_buddy_block *block; struct xe_validation_ctx vctx; struct list_head *blocks; struct drm_exec exec; diff --git a/drivers/gpu/drm/xe/xe_ttm_vram_mgr.c b/drivers/gpu/drm/xe/xe_ttm_vram_mgr.c index 9f70802fce92..8192957261e8 100644 --- a/drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +++ b/drivers/gpu/drm/xe/xe_ttm_vram_mgr.c @@ -4,8 +4,9 @@ * Copyright (C) 2021-2022 Red Hat */ -#include <drm/drm_managed.h> +#include <drm/drm_buddy.h> #include <drm/drm_drv.h> +#include <drm/drm_managed.h> #include <drm/ttm/ttm_placement.h> #include <drm/ttm/ttm_range_manager.h> @@ -17,16 +18,16 @@ #include "xe_ttm_vram_mgr.h" #include "xe_vram_types.h" -static inline struct drm_buddy_block * +static inline struct gpu_buddy_block * xe_ttm_vram_mgr_first_block(struct list_head *list) { - return list_first_entry_or_null(list, struct drm_buddy_block, link); + return list_first_entry_or_null(list, struct gpu_buddy_block, link); } -static inline bool xe_is_vram_mgr_blocks_contiguous(struct drm_buddy *mm, +static inline bool xe_is_vram_mgr_blocks_contiguous(struct gpu_buddy *mm, struct list_head *head) { - struct drm_buddy_block *block; + struct gpu_buddy_block *block; u64 start, size; block = xe_ttm_vram_mgr_first_block(head); @@ -34,12 +35,12 @@ static inline bool xe_is_vram_mgr_blocks_contiguous(struct drm_buddy *mm, return false; while (head != block->link.next) { - start = drm_buddy_block_offset(block); - size = drm_buddy_block_size(mm, block); + start = gpu_buddy_block_offset(block); + size = gpu_buddy_block_size(mm, block); - block = list_entry(block->link.next, struct drm_buddy_block, + block = list_entry(block->link.next, struct gpu_buddy_block, link); - if (start + size != drm_buddy_block_offset(block)) + if (start + size != gpu_buddy_block_offset(block)) return false; } @@ -53,7 +54,7 @@ static int xe_ttm_vram_mgr_new(struct ttm_resource_manager *man, { struct xe_ttm_vram_mgr *mgr = to_xe_ttm_vram_mgr(man); struct xe_ttm_vram_mgr_resource *vres; - struct drm_buddy *mm = &mgr->mm; + struct gpu_buddy *mm = &mgr->mm; u64 size, min_page_size; unsigned long lpfn; int err; @@ -80,10 +81,10 @@ static int xe_ttm_vram_mgr_new(struct ttm_resource_manager *man, INIT_LIST_HEAD(&vres->blocks); if (place->flags & TTM_PL_FLAG_TOPDOWN) - vres->flags |= DRM_BUDDY_TOPDOWN_ALLOCATION; + vres->flags |= GPU_BUDDY_TOPDOWN_ALLOCATION; if (place->fpfn || lpfn != man->size >> PAGE_SHIFT) - vres->flags |= DRM_BUDDY_RANGE_ALLOCATION; + vres->flags |= GPU_BUDDY_RANGE_ALLOCATION; if (WARN_ON(!vres->base.size)) { err = -EINVAL; @@ -119,27 +120,27 @@ static int xe_ttm_vram_mgr_new(struct ttm_resource_manager *man, lpfn = max_t(unsigned long, place->fpfn + (size >> PAGE_SHIFT), lpfn); } - err = drm_buddy_alloc_blocks(mm, (u64)place->fpfn << PAGE_SHIFT, + err = gpu_buddy_alloc_blocks(mm, (u64)place->fpfn << PAGE_SHIFT, (u64)lpfn << PAGE_SHIFT, size, min_page_size, &vres->blocks, vres->flags); if (err) goto error_unlock; if (place->flags & TTM_PL_FLAG_CONTIGUOUS) { - if (!drm_buddy_block_trim(mm, NULL, vres->base.size, &vres->blocks)) + if (!gpu_buddy_block_trim(mm, NULL, vres->base.size, &vres->blocks)) size = vres->base.size; } if (lpfn <= mgr->visible_size >> PAGE_SHIFT) { vres->used_visible_size = size; } else { - struct drm_buddy_block *block; + struct gpu_buddy_block *block; list_for_each_entry(block, &vres->blocks, link) { - u64 start = drm_buddy_block_offset(block); + u64 start = gpu_buddy_block_offset(block); if (start < mgr->visible_size) { - u64 end = start + drm_buddy_block_size(mm, block); + u64 end = start + gpu_buddy_block_size(mm, block); vres->used_visible_size += min(end, mgr->visible_size) - start; @@ -159,11 +160,11 @@ static int xe_ttm_vram_mgr_new(struct ttm_resource_manager *man, * the object. */ if (vres->base.placement & TTM_PL_FLAG_CONTIGUOUS) { - struct drm_buddy_block *block = list_first_entry(&vres->blocks, + struct gpu_buddy_block *block = list_first_entry(&vres->blocks, typeof(*block), link); - vres->base.start = drm_buddy_block_offset(block) >> PAGE_SHIFT; + vres->base.start = gpu_buddy_block_offset(block) >> PAGE_SHIFT; } else { vres->base.start = XE_BO_INVALID_OFFSET; } @@ -185,10 +186,10 @@ static void xe_ttm_vram_mgr_del(struct ttm_resource_manager *man, struct xe_ttm_vram_mgr_resource *vres = to_xe_ttm_vram_mgr_resource(res); struct xe_ttm_vram_mgr *mgr = to_xe_ttm_vram_mgr(man); - struct drm_buddy *mm = &mgr->mm; + struct gpu_buddy *mm = &mgr->mm; mutex_lock(&mgr->lock); - drm_buddy_free_list(mm, &vres->blocks, 0); + gpu_buddy_free_list(mm, &vres->blocks, 0); mgr->visible_avail += vres->used_visible_size; mutex_unlock(&mgr->lock); @@ -201,7 +202,7 @@ static void xe_ttm_vram_mgr_debug(struct ttm_resource_manager *man, struct drm_printer *printer) { struct xe_ttm_vram_mgr *mgr = to_xe_ttm_vram_mgr(man); - struct drm_buddy *mm = &mgr->mm; + struct gpu_buddy *mm = &mgr->mm; mutex_lock(&mgr->lock); drm_printf(printer, "default_page_size: %lluKiB\n", @@ -224,8 +225,8 @@ static bool xe_ttm_vram_mgr_intersects(struct ttm_resource_manager *man, struct xe_ttm_vram_mgr *mgr = to_xe_ttm_vram_mgr(man); struct xe_ttm_vram_mgr_resource *vres = to_xe_ttm_vram_mgr_resource(res); - struct drm_buddy *mm = &mgr->mm; - struct drm_buddy_block *block; + struct gpu_buddy *mm = &mgr->mm; + struct gpu_buddy_block *block; if (!place->fpfn && !place->lpfn) return true; @@ -235,9 +236,9 @@ static bool xe_ttm_vram_mgr_intersects(struct ttm_resource_manager *man, list_for_each_entry(block, &vres->blocks, link) { unsigned long fpfn = - drm_buddy_block_offset(block) >> PAGE_SHIFT; + gpu_buddy_block_offset(block) >> PAGE_SHIFT; unsigned long lpfn = fpfn + - (drm_buddy_block_size(mm, block) >> PAGE_SHIFT); + (gpu_buddy_block_size(mm, block) >> PAGE_SHIFT); if (place->fpfn < lpfn && place->lpfn > fpfn) return true; @@ -254,8 +255,8 @@ static bool xe_ttm_vram_mgr_compatible(struct ttm_resource_manager *man, struct xe_ttm_vram_mgr *mgr = to_xe_ttm_vram_mgr(man); struct xe_ttm_vram_mgr_resource *vres = to_xe_ttm_vram_mgr_resource(res); - struct drm_buddy *mm = &mgr->mm; - struct drm_buddy_block *block; + struct gpu_buddy *mm = &mgr->mm; + struct gpu_buddy_block *block; if (!place->fpfn && !place->lpfn) return true; @@ -265,9 +266,9 @@ static bool xe_ttm_vram_mgr_compatible(struct ttm_resource_manager *man, list_for_each_entry(block, &vres->blocks, link) { unsigned long fpfn = - drm_buddy_block_offset(block) >> PAGE_SHIFT; + gpu_buddy_block_offset(block) >> PAGE_SHIFT; unsigned long lpfn = fpfn + - (drm_buddy_block_size(mm, block) >> PAGE_SHIFT); + (gpu_buddy_block_size(mm, block) >> PAGE_SHIFT); if (fpfn < place->fpfn || lpfn > place->lpfn) return false; @@ -297,7 +298,7 @@ static void xe_ttm_vram_mgr_fini(struct drm_device *dev, void *arg) WARN_ON_ONCE(mgr->visible_avail != mgr->visible_size); - drm_buddy_fini(&mgr->mm); + gpu_buddy_fini(&mgr->mm); ttm_resource_manager_cleanup(&mgr->manager); @@ -328,7 +329,7 @@ int __xe_ttm_vram_mgr_init(struct xe_device *xe, struct xe_ttm_vram_mgr *mgr, mgr->visible_avail = io_size; ttm_resource_manager_init(man, &xe->ttm, size); - err = drm_buddy_init(&mgr->mm, man->size, default_page_size); + err = gpu_buddy_init(&mgr->mm, man->size, default_page_size); if (err) return err; @@ -376,7 +377,7 @@ int xe_ttm_vram_mgr_alloc_sgt(struct xe_device *xe, if (!*sgt) return -ENOMEM; - /* Determine the number of DRM_BUDDY blocks to export */ + /* Determine the number of GPU_BUDDY blocks to export */ xe_res_first(res, offset, length, &cursor); while (cursor.remaining) { num_entries++; @@ -393,10 +394,10 @@ int xe_ttm_vram_mgr_alloc_sgt(struct xe_device *xe, sg->length = 0; /* - * Walk down DRM_BUDDY blocks to populate scatterlist nodes - * @note: Use iterator api to get first the DRM_BUDDY block + * Walk down GPU_BUDDY blocks to populate scatterlist nodes + * @note: Use iterator api to get first the GPU_BUDDY block * and the number of bytes from it. Access the following - * DRM_BUDDY block(s) if more buffer needs to exported + * GPU_BUDDY block(s) if more buffer needs to exported */ xe_res_first(res, offset, length, &cursor); for_each_sgtable_sg((*sgt), sg, i) { diff --git a/drivers/gpu/drm/xe/xe_ttm_vram_mgr_types.h b/drivers/gpu/drm/xe/xe_ttm_vram_mgr_types.h index a71e14818ec2..9106da056b49 100644 --- a/drivers/gpu/drm/xe/xe_ttm_vram_mgr_types.h +++ b/drivers/gpu/drm/xe/xe_ttm_vram_mgr_types.h @@ -6,7 +6,7 @@ #ifndef _XE_TTM_VRAM_MGR_TYPES_H_ #define _XE_TTM_VRAM_MGR_TYPES_H_ -#include <drm/drm_buddy.h> +#include <linux/gpu_buddy.h> #include <drm/ttm/ttm_device.h> /** @@ -18,7 +18,7 @@ struct xe_ttm_vram_mgr { /** @manager: Base TTM resource manager */ struct ttm_resource_manager manager; /** @mm: DRM buddy allocator which manages the VRAM */ - struct drm_buddy mm; + struct gpu_buddy mm; /** @visible_size: Proped size of the CPU visible portion */ u64 visible_size; /** @visible_avail: CPU visible portion still unallocated */ diff --git a/drivers/gpu/tests/Makefile b/drivers/gpu/tests/Makefile new file mode 100644 index 000000000000..31a5ff44cb4e --- /dev/null +++ b/drivers/gpu/tests/Makefile @@ -0,0 +1,3 @@ +# SPDX-License-Identifier: GPL-2.0 + +obj-$(CONFIG_GPU_BUDDY_KUNIT_TEST) += gpu_buddy_test.o gpu_random.o diff --git a/drivers/gpu/drm/tests/drm_buddy_test.c b/drivers/gpu/tests/gpu_buddy_test.c similarity index 68% rename from drivers/gpu/drm/tests/drm_buddy_test.c rename to drivers/gpu/tests/gpu_buddy_test.c index 5f40b5343bd8..dcd4741a905d 100644 --- a/drivers/gpu/drm/tests/drm_buddy_test.c +++ b/drivers/gpu/tests/gpu_buddy_test.c @@ -10,9 +10,9 @@ #include <linux/sched/signal.h> #include <linux/sizes.h> -#include <drm/drm_buddy.h> +#include <linux/gpu_buddy.h> -#include "../lib/drm_random.h" +#include "gpu_random.h" static unsigned int random_seed; @@ -21,9 +21,9 @@ static inline u64 get_size(int order, u64 chunk_size) return (1 << order) * chunk_size; } -static void drm_test_buddy_fragmentation_performance(struct kunit *test) +static void gpu_test_buddy_fragmentation_performance(struct kunit *test) { - struct drm_buddy_block *block, *tmp; + struct gpu_buddy_block *block, *tmp; int num_blocks, i, ret, count = 0; LIST_HEAD(allocated_blocks); unsigned long elapsed_ms; @@ -32,7 +32,7 @@ static void drm_test_buddy_fragmentation_performance(struct kunit *test) LIST_HEAD(clear_list); LIST_HEAD(dirty_list); LIST_HEAD(free_list); - struct drm_buddy mm; + struct gpu_buddy mm; u64 mm_size = SZ_4G; ktime_t start, end; @@ -47,7 +47,7 @@ static void drm_test_buddy_fragmentation_performance(struct kunit *test) * quickly the allocator can satisfy larger, aligned requests from a pool of * highly fragmented space. */ - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_init(&mm, mm_size, SZ_4K), + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_init(&mm, mm_size, SZ_4K), "buddy_init failed\n"); num_blocks = mm_size / SZ_64K; @@ -55,7 +55,7 @@ static void drm_test_buddy_fragmentation_performance(struct kunit *test) start = ktime_get(); /* Allocate with maximum fragmentation - 8K blocks with 64K alignment */ for (i = 0; i < num_blocks; i++) - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size, SZ_8K, SZ_64K, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, mm_size, SZ_8K, SZ_64K, &allocated_blocks, 0), "buddy_alloc hit an error size=%u\n", SZ_8K); @@ -68,21 +68,21 @@ static void drm_test_buddy_fragmentation_performance(struct kunit *test) } /* Free with different flags to ensure no coalescing */ - drm_buddy_free_list(&mm, &clear_list, DRM_BUDDY_CLEARED); - drm_buddy_free_list(&mm, &dirty_list, 0); + gpu_buddy_free_list(&mm, &clear_list, GPU_BUDDY_CLEARED); + gpu_buddy_free_list(&mm, &dirty_list, 0); for (i = 0; i < num_blocks; i++) - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size, SZ_64K, SZ_64K, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, mm_size, SZ_64K, SZ_64K, &test_blocks, 0), "buddy_alloc hit an error size=%u\n", SZ_64K); - drm_buddy_free_list(&mm, &test_blocks, 0); + gpu_buddy_free_list(&mm, &test_blocks, 0); end = ktime_get(); elapsed_ms = ktime_to_ms(ktime_sub(end, start)); kunit_info(test, "Fragmented allocation took %lu ms\n", elapsed_ms); - drm_buddy_fini(&mm); + gpu_buddy_fini(&mm); /* * Reverse free order under fragmentation @@ -96,13 +96,13 @@ static void drm_test_buddy_fragmentation_performance(struct kunit *test) * deallocation occurs in the opposite order of allocation, exposing the * cost difference between a linear freelist scan and an ordered tree lookup. */ - ret = drm_buddy_init(&mm, mm_size, SZ_4K); + ret = gpu_buddy_init(&mm, mm_size, SZ_4K); KUNIT_ASSERT_EQ(test, ret, 0); start = ktime_get(); /* Allocate maximum fragmentation */ for (i = 0; i < num_blocks; i++) - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size, SZ_8K, SZ_64K, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, mm_size, SZ_8K, SZ_64K, &allocated_blocks, 0), "buddy_alloc hit an error size=%u\n", SZ_8K); @@ -111,28 +111,28 @@ static void drm_test_buddy_fragmentation_performance(struct kunit *test) list_move_tail(&block->link, &free_list); count++; } - drm_buddy_free_list(&mm, &free_list, DRM_BUDDY_CLEARED); + gpu_buddy_free_list(&mm, &free_list, GPU_BUDDY_CLEARED); list_for_each_entry_safe_reverse(block, tmp, &allocated_blocks, link) list_move(&block->link, &reverse_list); - drm_buddy_free_list(&mm, &reverse_list, DRM_BUDDY_CLEARED); + gpu_buddy_free_list(&mm, &reverse_list, GPU_BUDDY_CLEARED); end = ktime_get(); elapsed_ms = ktime_to_ms(ktime_sub(end, start)); kunit_info(test, "Reverse-ordered free took %lu ms\n", elapsed_ms); - drm_buddy_fini(&mm); + gpu_buddy_fini(&mm); } -static void drm_test_buddy_alloc_range_bias(struct kunit *test) +static void gpu_test_buddy_alloc_range_bias(struct kunit *test) { u32 mm_size, size, ps, bias_size, bias_start, bias_end, bias_rem; - DRM_RND_STATE(prng, random_seed); + GPU_RND_STATE(prng, random_seed); unsigned int i, count, *order; - struct drm_buddy_block *block; + struct gpu_buddy_block *block; unsigned long flags; - struct drm_buddy mm; + struct gpu_buddy mm; LIST_HEAD(allocated); bias_size = SZ_1M; @@ -142,11 +142,11 @@ static void drm_test_buddy_alloc_range_bias(struct kunit *test) kunit_info(test, "mm_size=%u, ps=%u\n", mm_size, ps); - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_init(&mm, mm_size, ps), + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_init(&mm, mm_size, ps), "buddy_init failed\n"); count = mm_size / bias_size; - order = drm_random_order(count, &prng); + order = gpu_random_order(count, &prng); KUNIT_EXPECT_TRUE(test, order); /* @@ -166,79 +166,79 @@ static void drm_test_buddy_alloc_range_bias(struct kunit *test) /* internal round_up too big */ KUNIT_ASSERT_TRUE_MSG(test, - drm_buddy_alloc_blocks(&mm, bias_start, + gpu_buddy_alloc_blocks(&mm, bias_start, bias_end, bias_size + ps, bias_size, &allocated, - DRM_BUDDY_RANGE_ALLOCATION), + GPU_BUDDY_RANGE_ALLOCATION), "buddy_alloc failed with bias(%x-%x), size=%u, ps=%u\n", bias_start, bias_end, bias_size, bias_size); /* size too big */ KUNIT_ASSERT_TRUE_MSG(test, - drm_buddy_alloc_blocks(&mm, bias_start, + gpu_buddy_alloc_blocks(&mm, bias_start, bias_end, bias_size + ps, ps, &allocated, - DRM_BUDDY_RANGE_ALLOCATION), + GPU_BUDDY_RANGE_ALLOCATION), "buddy_alloc didn't fail with bias(%x-%x), size=%u, ps=%u\n", bias_start, bias_end, bias_size + ps, ps); /* bias range too small for size */ KUNIT_ASSERT_TRUE_MSG(test, - drm_buddy_alloc_blocks(&mm, bias_start + ps, + gpu_buddy_alloc_blocks(&mm, bias_start + ps, bias_end, bias_size, ps, &allocated, - DRM_BUDDY_RANGE_ALLOCATION), + GPU_BUDDY_RANGE_ALLOCATION), "buddy_alloc didn't fail with bias(%x-%x), size=%u, ps=%u\n", bias_start + ps, bias_end, bias_size, ps); /* bias misaligned */ KUNIT_ASSERT_TRUE_MSG(test, - drm_buddy_alloc_blocks(&mm, bias_start + ps, + gpu_buddy_alloc_blocks(&mm, bias_start + ps, bias_end - ps, bias_size >> 1, bias_size >> 1, &allocated, - DRM_BUDDY_RANGE_ALLOCATION), + GPU_BUDDY_RANGE_ALLOCATION), "buddy_alloc h didn't fail with bias(%x-%x), size=%u, ps=%u\n", bias_start + ps, bias_end - ps, bias_size >> 1, bias_size >> 1); /* single big page */ KUNIT_ASSERT_FALSE_MSG(test, - drm_buddy_alloc_blocks(&mm, bias_start, + gpu_buddy_alloc_blocks(&mm, bias_start, bias_end, bias_size, bias_size, &tmp, - DRM_BUDDY_RANGE_ALLOCATION), + GPU_BUDDY_RANGE_ALLOCATION), "buddy_alloc i failed with bias(%x-%x), size=%u, ps=%u\n", bias_start, bias_end, bias_size, bias_size); - drm_buddy_free_list(&mm, &tmp, 0); + gpu_buddy_free_list(&mm, &tmp, 0); /* single page with internal round_up */ KUNIT_ASSERT_FALSE_MSG(test, - drm_buddy_alloc_blocks(&mm, bias_start, + gpu_buddy_alloc_blocks(&mm, bias_start, bias_end, ps, bias_size, &tmp, - DRM_BUDDY_RANGE_ALLOCATION), + GPU_BUDDY_RANGE_ALLOCATION), "buddy_alloc failed with bias(%x-%x), size=%u, ps=%u\n", bias_start, bias_end, ps, bias_size); - drm_buddy_free_list(&mm, &tmp, 0); + gpu_buddy_free_list(&mm, &tmp, 0); /* random size within */ size = max(round_up(prandom_u32_state(&prng) % bias_rem, ps), ps); if (size) KUNIT_ASSERT_FALSE_MSG(test, - drm_buddy_alloc_blocks(&mm, bias_start, + gpu_buddy_alloc_blocks(&mm, bias_start, bias_end, size, ps, &tmp, - DRM_BUDDY_RANGE_ALLOCATION), + GPU_BUDDY_RANGE_ALLOCATION), "buddy_alloc failed with bias(%x-%x), size=%u, ps=%u\n", bias_start, bias_end, size, ps); bias_rem -= size; /* too big for current avail */ KUNIT_ASSERT_TRUE_MSG(test, - drm_buddy_alloc_blocks(&mm, bias_start, + gpu_buddy_alloc_blocks(&mm, bias_start, bias_end, bias_rem + ps, ps, &allocated, - DRM_BUDDY_RANGE_ALLOCATION), + GPU_BUDDY_RANGE_ALLOCATION), "buddy_alloc didn't fail with bias(%x-%x), size=%u, ps=%u\n", bias_start, bias_end, bias_rem + ps, ps); @@ -248,10 +248,10 @@ static void drm_test_buddy_alloc_range_bias(struct kunit *test) size = max(size, ps); KUNIT_ASSERT_FALSE_MSG(test, - drm_buddy_alloc_blocks(&mm, bias_start, + gpu_buddy_alloc_blocks(&mm, bias_start, bias_end, size, ps, &allocated, - DRM_BUDDY_RANGE_ALLOCATION), + GPU_BUDDY_RANGE_ALLOCATION), "buddy_alloc failed with bias(%x-%x), size=%u, ps=%u\n", bias_start, bias_end, size, ps); /* @@ -259,15 +259,15 @@ static void drm_test_buddy_alloc_range_bias(struct kunit *test) * unallocated, and ideally not always on the bias * boundaries. */ - drm_buddy_free_list(&mm, &tmp, 0); + gpu_buddy_free_list(&mm, &tmp, 0); } else { list_splice_tail(&tmp, &allocated); } } kfree(order); - drm_buddy_free_list(&mm, &allocated, 0); - drm_buddy_fini(&mm); + gpu_buddy_free_list(&mm, &allocated, 0); + gpu_buddy_fini(&mm); /* * Something more free-form. Idea is to pick a random starting bias @@ -278,7 +278,7 @@ static void drm_test_buddy_alloc_range_bias(struct kunit *test) * allocated nodes in the middle of the address space. */ - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_init(&mm, mm_size, ps), + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_init(&mm, mm_size, ps), "buddy_init failed\n"); bias_start = round_up(prandom_u32_state(&prng) % (mm_size - ps), ps); @@ -290,10 +290,10 @@ static void drm_test_buddy_alloc_range_bias(struct kunit *test) u32 size = max(round_up(prandom_u32_state(&prng) % bias_rem, ps), ps); KUNIT_ASSERT_FALSE_MSG(test, - drm_buddy_alloc_blocks(&mm, bias_start, + gpu_buddy_alloc_blocks(&mm, bias_start, bias_end, size, ps, &allocated, - DRM_BUDDY_RANGE_ALLOCATION), + GPU_BUDDY_RANGE_ALLOCATION), "buddy_alloc failed with bias(%x-%x), size=%u, ps=%u\n", bias_start, bias_end, size, ps); bias_rem -= size; @@ -319,24 +319,24 @@ static void drm_test_buddy_alloc_range_bias(struct kunit *test) KUNIT_ASSERT_EQ(test, bias_start, 0); KUNIT_ASSERT_EQ(test, bias_end, mm_size); KUNIT_ASSERT_TRUE_MSG(test, - drm_buddy_alloc_blocks(&mm, bias_start, bias_end, + gpu_buddy_alloc_blocks(&mm, bias_start, bias_end, ps, ps, &allocated, - DRM_BUDDY_RANGE_ALLOCATION), + GPU_BUDDY_RANGE_ALLOCATION), "buddy_alloc passed with bias(%x-%x), size=%u\n", bias_start, bias_end, ps); - drm_buddy_free_list(&mm, &allocated, 0); - drm_buddy_fini(&mm); + gpu_buddy_free_list(&mm, &allocated, 0); + gpu_buddy_fini(&mm); /* - * Allocate cleared blocks in the bias range when the DRM buddy's clear avail is + * Allocate cleared blocks in the bias range when the GPU buddy's clear avail is * zero. This will validate the bias range allocation in scenarios like system boot * when no cleared blocks are available and exercise the fallback path too. The resulting * blocks should always be dirty. */ - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_init(&mm, mm_size, ps), + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_init(&mm, mm_size, ps), "buddy_init failed\n"); bias_start = round_up(prandom_u32_state(&prng) % (mm_size - ps), ps); @@ -344,11 +344,11 @@ static void drm_test_buddy_alloc_range_bias(struct kunit *test) bias_end = max(bias_end, bias_start + ps); bias_rem = bias_end - bias_start; - flags = DRM_BUDDY_CLEAR_ALLOCATION | DRM_BUDDY_RANGE_ALLOCATION; + flags = GPU_BUDDY_CLEAR_ALLOCATION | GPU_BUDDY_RANGE_ALLOCATION; size = max(round_up(prandom_u32_state(&prng) % bias_rem, ps), ps); KUNIT_ASSERT_FALSE_MSG(test, - drm_buddy_alloc_blocks(&mm, bias_start, + gpu_buddy_alloc_blocks(&mm, bias_start, bias_end, size, ps, &allocated, flags), @@ -356,27 +356,27 @@ static void drm_test_buddy_alloc_range_bias(struct kunit *test) bias_start, bias_end, size, ps); list_for_each_entry(block, &allocated, link) - KUNIT_EXPECT_EQ(test, drm_buddy_block_is_clear(block), false); + KUNIT_EXPECT_EQ(test, gpu_buddy_block_is_clear(block), false); - drm_buddy_free_list(&mm, &allocated, 0); - drm_buddy_fini(&mm); + gpu_buddy_free_list(&mm, &allocated, 0); + gpu_buddy_fini(&mm); } -static void drm_test_buddy_alloc_clear(struct kunit *test) +static void gpu_test_buddy_alloc_clear(struct kunit *test) { unsigned long n_pages, total, i = 0; const unsigned long ps = SZ_4K; - struct drm_buddy_block *block; + struct gpu_buddy_block *block; const int max_order = 12; LIST_HEAD(allocated); - struct drm_buddy mm; + struct gpu_buddy mm; unsigned int order; u32 mm_size, size; LIST_HEAD(dirty); LIST_HEAD(clean); mm_size = SZ_4K << max_order; - KUNIT_EXPECT_FALSE(test, drm_buddy_init(&mm, mm_size, ps)); + KUNIT_EXPECT_FALSE(test, gpu_buddy_init(&mm, mm_size, ps)); KUNIT_EXPECT_EQ(test, mm.max_order, max_order); @@ -389,11 +389,11 @@ static void drm_test_buddy_alloc_clear(struct kunit *test) * is indeed all dirty pages and vice versa. Free it all again, * keeping the dirty/clear status. */ - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, mm_size, 5 * ps, ps, &allocated, - DRM_BUDDY_TOPDOWN_ALLOCATION), + GPU_BUDDY_TOPDOWN_ALLOCATION), "buddy_alloc hit an error size=%lu\n", 5 * ps); - drm_buddy_free_list(&mm, &allocated, DRM_BUDDY_CLEARED); + gpu_buddy_free_list(&mm, &allocated, GPU_BUDDY_CLEARED); n_pages = 10; do { @@ -406,37 +406,37 @@ static void drm_test_buddy_alloc_clear(struct kunit *test) flags = 0; } else { list = &clean; - flags = DRM_BUDDY_CLEAR_ALLOCATION; + flags = GPU_BUDDY_CLEAR_ALLOCATION; } - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, mm_size, ps, ps, list, flags), "buddy_alloc hit an error size=%lu\n", ps); } while (++i < n_pages); list_for_each_entry(block, &clean, link) - KUNIT_EXPECT_EQ(test, drm_buddy_block_is_clear(block), true); + KUNIT_EXPECT_EQ(test, gpu_buddy_block_is_clear(block), true); list_for_each_entry(block, &dirty, link) - KUNIT_EXPECT_EQ(test, drm_buddy_block_is_clear(block), false); + KUNIT_EXPECT_EQ(test, gpu_buddy_block_is_clear(block), false); - drm_buddy_free_list(&mm, &clean, DRM_BUDDY_CLEARED); + gpu_buddy_free_list(&mm, &clean, GPU_BUDDY_CLEARED); /* * Trying to go over the clear limit for some allocation. * The allocation should never fail with reasonable page-size. */ - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, mm_size, 10 * ps, ps, &clean, - DRM_BUDDY_CLEAR_ALLOCATION), + GPU_BUDDY_CLEAR_ALLOCATION), "buddy_alloc hit an error size=%lu\n", 10 * ps); - drm_buddy_free_list(&mm, &clean, DRM_BUDDY_CLEARED); - drm_buddy_free_list(&mm, &dirty, 0); - drm_buddy_fini(&mm); + gpu_buddy_free_list(&mm, &clean, GPU_BUDDY_CLEARED); + gpu_buddy_free_list(&mm, &dirty, 0); + gpu_buddy_fini(&mm); - KUNIT_EXPECT_FALSE(test, drm_buddy_init(&mm, mm_size, ps)); + KUNIT_EXPECT_FALSE(test, gpu_buddy_init(&mm, mm_size, ps)); /* * Create a new mm. Intentionally fragment the address space by creating @@ -458,34 +458,34 @@ static void drm_test_buddy_alloc_clear(struct kunit *test) else list = &clean; - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, mm_size, ps, ps, list, 0), "buddy_alloc hit an error size=%lu\n", ps); } while (++i < n_pages); - drm_buddy_free_list(&mm, &clean, DRM_BUDDY_CLEARED); - drm_buddy_free_list(&mm, &dirty, 0); + gpu_buddy_free_list(&mm, &clean, GPU_BUDDY_CLEARED); + gpu_buddy_free_list(&mm, &dirty, 0); order = 1; do { size = SZ_4K << order; - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, mm_size, size, size, &allocated, - DRM_BUDDY_CLEAR_ALLOCATION), + GPU_BUDDY_CLEAR_ALLOCATION), "buddy_alloc hit an error size=%u\n", size); total = 0; list_for_each_entry(block, &allocated, link) { if (size != mm_size) - KUNIT_EXPECT_EQ(test, drm_buddy_block_is_clear(block), false); - total += drm_buddy_block_size(&mm, block); + KUNIT_EXPECT_EQ(test, gpu_buddy_block_is_clear(block), false); + total += gpu_buddy_block_size(&mm, block); } KUNIT_EXPECT_EQ(test, total, size); - drm_buddy_free_list(&mm, &allocated, 0); + gpu_buddy_free_list(&mm, &allocated, 0); } while (++order <= max_order); - drm_buddy_fini(&mm); + gpu_buddy_fini(&mm); /* * Create a new mm with a non power-of-two size. Allocate a random size from each @@ -494,44 +494,44 @@ static void drm_test_buddy_alloc_clear(struct kunit *test) */ mm_size = (SZ_4K << max_order) + (SZ_4K << (max_order - 2)); - KUNIT_EXPECT_FALSE(test, drm_buddy_init(&mm, mm_size, ps)); + KUNIT_EXPECT_FALSE(test, gpu_buddy_init(&mm, mm_size, ps)); KUNIT_EXPECT_EQ(test, mm.max_order, max_order); - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, SZ_4K << max_order, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, SZ_4K << max_order, 4 * ps, ps, &allocated, - DRM_BUDDY_RANGE_ALLOCATION), + GPU_BUDDY_RANGE_ALLOCATION), "buddy_alloc hit an error size=%lu\n", 4 * ps); - drm_buddy_free_list(&mm, &allocated, DRM_BUDDY_CLEARED); - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, SZ_4K << max_order, + gpu_buddy_free_list(&mm, &allocated, GPU_BUDDY_CLEARED); + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, SZ_4K << max_order, 2 * ps, ps, &allocated, - DRM_BUDDY_CLEAR_ALLOCATION), + GPU_BUDDY_CLEAR_ALLOCATION), "buddy_alloc hit an error size=%lu\n", 2 * ps); - drm_buddy_free_list(&mm, &allocated, DRM_BUDDY_CLEARED); - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, SZ_4K << max_order, mm_size, + gpu_buddy_free_list(&mm, &allocated, GPU_BUDDY_CLEARED); + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, SZ_4K << max_order, mm_size, ps, ps, &allocated, - DRM_BUDDY_RANGE_ALLOCATION), + GPU_BUDDY_RANGE_ALLOCATION), "buddy_alloc hit an error size=%lu\n", ps); - drm_buddy_free_list(&mm, &allocated, DRM_BUDDY_CLEARED); - drm_buddy_fini(&mm); + gpu_buddy_free_list(&mm, &allocated, GPU_BUDDY_CLEARED); + gpu_buddy_fini(&mm); } -static void drm_test_buddy_alloc_contiguous(struct kunit *test) +static void gpu_test_buddy_alloc_contiguous(struct kunit *test) { const unsigned long ps = SZ_4K, mm_size = 16 * 3 * SZ_4K; unsigned long i, n_pages, total; - struct drm_buddy_block *block; - struct drm_buddy mm; + struct gpu_buddy_block *block; + struct gpu_buddy mm; LIST_HEAD(left); LIST_HEAD(middle); LIST_HEAD(right); LIST_HEAD(allocated); - KUNIT_EXPECT_FALSE(test, drm_buddy_init(&mm, mm_size, ps)); + KUNIT_EXPECT_FALSE(test, gpu_buddy_init(&mm, mm_size, ps)); /* * Idea is to fragment the address space by alternating block * allocations between three different lists; one for left, middle and * right. We can then free a list to simulate fragmentation. In - * particular we want to exercise the DRM_BUDDY_CONTIGUOUS_ALLOCATION, + * particular we want to exercise the GPU_BUDDY_CONTIGUOUS_ALLOCATION, * including the try_harder path. */ @@ -548,66 +548,66 @@ static void drm_test_buddy_alloc_contiguous(struct kunit *test) else list = &right; KUNIT_ASSERT_FALSE_MSG(test, - drm_buddy_alloc_blocks(&mm, 0, mm_size, + gpu_buddy_alloc_blocks(&mm, 0, mm_size, ps, ps, list, 0), "buddy_alloc hit an error size=%lu\n", ps); } while (++i < n_pages); - KUNIT_ASSERT_TRUE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size, + KUNIT_ASSERT_TRUE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, mm_size, 3 * ps, ps, &allocated, - DRM_BUDDY_CONTIGUOUS_ALLOCATION), + GPU_BUDDY_CONTIGUOUS_ALLOCATION), "buddy_alloc didn't error size=%lu\n", 3 * ps); - drm_buddy_free_list(&mm, &middle, 0); - KUNIT_ASSERT_TRUE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size, + gpu_buddy_free_list(&mm, &middle, 0); + KUNIT_ASSERT_TRUE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, mm_size, 3 * ps, ps, &allocated, - DRM_BUDDY_CONTIGUOUS_ALLOCATION), + GPU_BUDDY_CONTIGUOUS_ALLOCATION), "buddy_alloc didn't error size=%lu\n", 3 * ps); - KUNIT_ASSERT_TRUE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size, + KUNIT_ASSERT_TRUE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, mm_size, 2 * ps, ps, &allocated, - DRM_BUDDY_CONTIGUOUS_ALLOCATION), + GPU_BUDDY_CONTIGUOUS_ALLOCATION), "buddy_alloc didn't error size=%lu\n", 2 * ps); - drm_buddy_free_list(&mm, &right, 0); - KUNIT_ASSERT_TRUE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size, + gpu_buddy_free_list(&mm, &right, 0); + KUNIT_ASSERT_TRUE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, mm_size, 3 * ps, ps, &allocated, - DRM_BUDDY_CONTIGUOUS_ALLOCATION), + GPU_BUDDY_CONTIGUOUS_ALLOCATION), "buddy_alloc didn't error size=%lu\n", 3 * ps); /* * At this point we should have enough contiguous space for 2 blocks, * however they are never buddies (since we freed middle and right) so * will require the try_harder logic to find them. */ - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, mm_size, 2 * ps, ps, &allocated, - DRM_BUDDY_CONTIGUOUS_ALLOCATION), + GPU_BUDDY_CONTIGUOUS_ALLOCATION), "buddy_alloc hit an error size=%lu\n", 2 * ps); - drm_buddy_free_list(&mm, &left, 0); - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size, + gpu_buddy_free_list(&mm, &left, 0); + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, mm_size, 3 * ps, ps, &allocated, - DRM_BUDDY_CONTIGUOUS_ALLOCATION), + GPU_BUDDY_CONTIGUOUS_ALLOCATION), "buddy_alloc hit an error size=%lu\n", 3 * ps); total = 0; list_for_each_entry(block, &allocated, link) - total += drm_buddy_block_size(&mm, block); + total += gpu_buddy_block_size(&mm, block); KUNIT_ASSERT_EQ(test, total, ps * 2 + ps * 3); - drm_buddy_free_list(&mm, &allocated, 0); - drm_buddy_fini(&mm); + gpu_buddy_free_list(&mm, &allocated, 0); + gpu_buddy_fini(&mm); } -static void drm_test_buddy_alloc_pathological(struct kunit *test) +static void gpu_test_buddy_alloc_pathological(struct kunit *test) { u64 mm_size, size, start = 0; - struct drm_buddy_block *block; + struct gpu_buddy_block *block; const int max_order = 3; unsigned long flags = 0; int order, top; - struct drm_buddy mm; + struct gpu_buddy mm; LIST_HEAD(blocks); LIST_HEAD(holes); LIST_HEAD(tmp); @@ -620,7 +620,7 @@ static void drm_test_buddy_alloc_pathological(struct kunit *test) */ mm_size = SZ_4K << max_order; - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_init(&mm, mm_size, SZ_4K), + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_init(&mm, mm_size, SZ_4K), "buddy_init failed\n"); KUNIT_EXPECT_EQ(test, mm.max_order, max_order); @@ -630,18 +630,18 @@ static void drm_test_buddy_alloc_pathological(struct kunit *test) block = list_first_entry_or_null(&blocks, typeof(*block), link); if (block) { list_del(&block->link); - drm_buddy_free_block(&mm, block); + gpu_buddy_free_block(&mm, block); } for (order = top; order--;) { size = get_size(order, mm.chunk_size); - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, start, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, start, mm_size, size, size, &tmp, flags), "buddy_alloc hit -ENOMEM with order=%d, top=%d\n", order, top); - block = list_first_entry_or_null(&tmp, struct drm_buddy_block, link); + block = list_first_entry_or_null(&tmp, struct gpu_buddy_block, link); KUNIT_ASSERT_TRUE_MSG(test, block, "alloc_blocks has no blocks\n"); list_move_tail(&block->link, &blocks); @@ -649,45 +649,45 @@ static void drm_test_buddy_alloc_pathological(struct kunit *test) /* There should be one final page for this sub-allocation */ size = get_size(0, mm.chunk_size); - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, start, mm_size, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, start, mm_size, size, size, &tmp, flags), "buddy_alloc hit -ENOMEM for hole\n"); - block = list_first_entry_or_null(&tmp, struct drm_buddy_block, link); + block = list_first_entry_or_null(&tmp, struct gpu_buddy_block, link); KUNIT_ASSERT_TRUE_MSG(test, block, "alloc_blocks has no blocks\n"); list_move_tail(&block->link, &holes); size = get_size(top, mm.chunk_size); - KUNIT_ASSERT_TRUE_MSG(test, drm_buddy_alloc_blocks(&mm, start, mm_size, + KUNIT_ASSERT_TRUE_MSG(test, gpu_buddy_alloc_blocks(&mm, start, mm_size, size, size, &tmp, flags), "buddy_alloc unexpectedly succeeded at top-order %d/%d, it should be full!", top, max_order); } - drm_buddy_free_list(&mm, &holes, 0); + gpu_buddy_free_list(&mm, &holes, 0); /* Nothing larger than blocks of chunk_size now available */ for (order = 1; order <= max_order; order++) { size = get_size(order, mm.chunk_size); - KUNIT_ASSERT_TRUE_MSG(test, drm_buddy_alloc_blocks(&mm, start, mm_size, + KUNIT_ASSERT_TRUE_MSG(test, gpu_buddy_alloc_blocks(&mm, start, mm_size, size, size, &tmp, flags), "buddy_alloc unexpectedly succeeded at order %d, it should be full!", order); } list_splice_tail(&holes, &blocks); - drm_buddy_free_list(&mm, &blocks, 0); - drm_buddy_fini(&mm); + gpu_buddy_free_list(&mm, &blocks, 0); + gpu_buddy_fini(&mm); } -static void drm_test_buddy_alloc_pessimistic(struct kunit *test) +static void gpu_test_buddy_alloc_pessimistic(struct kunit *test) { u64 mm_size, size, start = 0; - struct drm_buddy_block *block, *bn; + struct gpu_buddy_block *block, *bn; const unsigned int max_order = 16; unsigned long flags = 0; - struct drm_buddy mm; + struct gpu_buddy mm; unsigned int order; LIST_HEAD(blocks); LIST_HEAD(tmp); @@ -699,19 +699,19 @@ static void drm_test_buddy_alloc_pessimistic(struct kunit *test) */ mm_size = SZ_4K << max_order; - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_init(&mm, mm_size, SZ_4K), + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_init(&mm, mm_size, SZ_4K), "buddy_init failed\n"); KUNIT_EXPECT_EQ(test, mm.max_order, max_order); for (order = 0; order < max_order; order++) { size = get_size(order, mm.chunk_size); - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, start, mm_size, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, start, mm_size, size, size, &tmp, flags), "buddy_alloc hit -ENOMEM with order=%d\n", order); - block = list_first_entry_or_null(&tmp, struct drm_buddy_block, link); + block = list_first_entry_or_null(&tmp, struct gpu_buddy_block, link); KUNIT_ASSERT_TRUE_MSG(test, block, "alloc_blocks has no blocks\n"); list_move_tail(&block->link, &blocks); @@ -719,11 +719,11 @@ static void drm_test_buddy_alloc_pessimistic(struct kunit *test) /* And now the last remaining block available */ size = get_size(0, mm.chunk_size); - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, start, mm_size, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, start, mm_size, size, size, &tmp, flags), "buddy_alloc hit -ENOMEM on final alloc\n"); - block = list_first_entry_or_null(&tmp, struct drm_buddy_block, link); + block = list_first_entry_or_null(&tmp, struct gpu_buddy_block, link); KUNIT_ASSERT_TRUE_MSG(test, block, "alloc_blocks has no blocks\n"); list_move_tail(&block->link, &blocks); @@ -731,58 +731,58 @@ static void drm_test_buddy_alloc_pessimistic(struct kunit *test) /* Should be completely full! */ for (order = max_order; order--;) { size = get_size(order, mm.chunk_size); - KUNIT_ASSERT_TRUE_MSG(test, drm_buddy_alloc_blocks(&mm, start, mm_size, + KUNIT_ASSERT_TRUE_MSG(test, gpu_buddy_alloc_blocks(&mm, start, mm_size, size, size, &tmp, flags), "buddy_alloc unexpectedly succeeded, it should be full!"); } block = list_last_entry(&blocks, typeof(*block), link); list_del(&block->link); - drm_buddy_free_block(&mm, block); + gpu_buddy_free_block(&mm, block); /* As we free in increasing size, we make available larger blocks */ order = 1; list_for_each_entry_safe(block, bn, &blocks, link) { list_del(&block->link); - drm_buddy_free_block(&mm, block); + gpu_buddy_free_block(&mm, block); size = get_size(order, mm.chunk_size); - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, start, mm_size, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, start, mm_size, size, size, &tmp, flags), "buddy_alloc hit -ENOMEM with order=%d\n", order); - block = list_first_entry_or_null(&tmp, struct drm_buddy_block, link); + block = list_first_entry_or_null(&tmp, struct gpu_buddy_block, link); KUNIT_ASSERT_TRUE_MSG(test, block, "alloc_blocks has no blocks\n"); list_del(&block->link); - drm_buddy_free_block(&mm, block); + gpu_buddy_free_block(&mm, block); order++; } /* To confirm, now the whole mm should be available */ size = get_size(max_order, mm.chunk_size); - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, start, mm_size, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, start, mm_size, size, size, &tmp, flags), "buddy_alloc (realloc) hit -ENOMEM with order=%d\n", max_order); - block = list_first_entry_or_null(&tmp, struct drm_buddy_block, link); + block = list_first_entry_or_null(&tmp, struct gpu_buddy_block, link); KUNIT_ASSERT_TRUE_MSG(test, block, "alloc_blocks has no blocks\n"); list_del(&block->link); - drm_buddy_free_block(&mm, block); - drm_buddy_free_list(&mm, &blocks, 0); - drm_buddy_fini(&mm); + gpu_buddy_free_block(&mm, block); + gpu_buddy_free_list(&mm, &blocks, 0); + gpu_buddy_fini(&mm); } -static void drm_test_buddy_alloc_optimistic(struct kunit *test) +static void gpu_test_buddy_alloc_optimistic(struct kunit *test) { u64 mm_size, size, start = 0; - struct drm_buddy_block *block; + struct gpu_buddy_block *block; unsigned long flags = 0; const int max_order = 16; - struct drm_buddy mm; + struct gpu_buddy mm; LIST_HEAD(blocks); LIST_HEAD(tmp); int order; @@ -794,19 +794,19 @@ static void drm_test_buddy_alloc_optimistic(struct kunit *test) mm_size = SZ_4K * ((1 << (max_order + 1)) - 1); - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_init(&mm, mm_size, SZ_4K), + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_init(&mm, mm_size, SZ_4K), "buddy_init failed\n"); KUNIT_EXPECT_EQ(test, mm.max_order, max_order); for (order = 0; order <= max_order; order++) { size = get_size(order, mm.chunk_size); - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, start, mm_size, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, start, mm_size, size, size, &tmp, flags), "buddy_alloc hit -ENOMEM with order=%d\n", order); - block = list_first_entry_or_null(&tmp, struct drm_buddy_block, link); + block = list_first_entry_or_null(&tmp, struct gpu_buddy_block, link); KUNIT_ASSERT_TRUE_MSG(test, block, "alloc_blocks has no blocks\n"); list_move_tail(&block->link, &blocks); @@ -814,80 +814,80 @@ static void drm_test_buddy_alloc_optimistic(struct kunit *test) /* Should be completely full! */ size = get_size(0, mm.chunk_size); - KUNIT_ASSERT_TRUE_MSG(test, drm_buddy_alloc_blocks(&mm, start, mm_size, + KUNIT_ASSERT_TRUE_MSG(test, gpu_buddy_alloc_blocks(&mm, start, mm_size, size, size, &tmp, flags), "buddy_alloc unexpectedly succeeded, it should be full!"); - drm_buddy_free_list(&mm, &blocks, 0); - drm_buddy_fini(&mm); + gpu_buddy_free_list(&mm, &blocks, 0); + gpu_buddy_fini(&mm); } -static void drm_test_buddy_alloc_limit(struct kunit *test) +static void gpu_test_buddy_alloc_limit(struct kunit *test) { u64 size = U64_MAX, start = 0; - struct drm_buddy_block *block; + struct gpu_buddy_block *block; unsigned long flags = 0; LIST_HEAD(allocated); - struct drm_buddy mm; + struct gpu_buddy mm; - KUNIT_EXPECT_FALSE(test, drm_buddy_init(&mm, size, SZ_4K)); + KUNIT_EXPECT_FALSE(test, gpu_buddy_init(&mm, size, SZ_4K)); - KUNIT_EXPECT_EQ_MSG(test, mm.max_order, DRM_BUDDY_MAX_ORDER, + KUNIT_EXPECT_EQ_MSG(test, mm.max_order, GPU_BUDDY_MAX_ORDER, "mm.max_order(%d) != %d\n", mm.max_order, - DRM_BUDDY_MAX_ORDER); + GPU_BUDDY_MAX_ORDER); size = mm.chunk_size << mm.max_order; - KUNIT_EXPECT_FALSE(test, drm_buddy_alloc_blocks(&mm, start, size, size, + KUNIT_EXPECT_FALSE(test, gpu_buddy_alloc_blocks(&mm, start, size, size, mm.chunk_size, &allocated, flags)); - block = list_first_entry_or_null(&allocated, struct drm_buddy_block, link); + block = list_first_entry_or_null(&allocated, struct gpu_buddy_block, link); KUNIT_EXPECT_TRUE(test, block); - KUNIT_EXPECT_EQ_MSG(test, drm_buddy_block_order(block), mm.max_order, + KUNIT_EXPECT_EQ_MSG(test, gpu_buddy_block_order(block), mm.max_order, "block order(%d) != %d\n", - drm_buddy_block_order(block), mm.max_order); + gpu_buddy_block_order(block), mm.max_order); - KUNIT_EXPECT_EQ_MSG(test, drm_buddy_block_size(&mm, block), + KUNIT_EXPECT_EQ_MSG(test, gpu_buddy_block_size(&mm, block), BIT_ULL(mm.max_order) * mm.chunk_size, "block size(%llu) != %llu\n", - drm_buddy_block_size(&mm, block), + gpu_buddy_block_size(&mm, block), BIT_ULL(mm.max_order) * mm.chunk_size); - drm_buddy_free_list(&mm, &allocated, 0); - drm_buddy_fini(&mm); + gpu_buddy_free_list(&mm, &allocated, 0); + gpu_buddy_fini(&mm); } -static int drm_buddy_suite_init(struct kunit_suite *suite) +static int gpu_buddy_suite_init(struct kunit_suite *suite) { while (!random_seed) random_seed = get_random_u32(); - kunit_info(suite, "Testing DRM buddy manager, with random_seed=0x%x\n", + kunit_info(suite, "Testing GPU buddy manager, with random_seed=0x%x\n", random_seed); return 0; } -static struct kunit_case drm_buddy_tests[] = { - KUNIT_CASE(drm_test_buddy_alloc_limit), - KUNIT_CASE(drm_test_buddy_alloc_optimistic), - KUNIT_CASE(drm_test_buddy_alloc_pessimistic), - KUNIT_CASE(drm_test_buddy_alloc_pathological), - KUNIT_CASE(drm_test_buddy_alloc_contiguous), - KUNIT_CASE(drm_test_buddy_alloc_clear), - KUNIT_CASE(drm_test_buddy_alloc_range_bias), - KUNIT_CASE(drm_test_buddy_fragmentation_performance), +static struct kunit_case gpu_buddy_tests[] = { + KUNIT_CASE(gpu_test_buddy_alloc_limit), + KUNIT_CASE(gpu_test_buddy_alloc_optimistic), + KUNIT_CASE(gpu_test_buddy_alloc_pessimistic), + KUNIT_CASE(gpu_test_buddy_alloc_pathological), + KUNIT_CASE(gpu_test_buddy_alloc_contiguous), + KUNIT_CASE(gpu_test_buddy_alloc_clear), + KUNIT_CASE(gpu_test_buddy_alloc_range_bias), + KUNIT_CASE(gpu_test_buddy_fragmentation_performance), {} }; -static struct kunit_suite drm_buddy_test_suite = { - .name = "drm_buddy", - .suite_init = drm_buddy_suite_init, - .test_cases = drm_buddy_tests, +static struct kunit_suite gpu_buddy_test_suite = { + .name = "gpu_buddy", + .suite_init = gpu_buddy_suite_init, + .test_cases = gpu_buddy_tests, }; -kunit_test_suite(drm_buddy_test_suite); +kunit_test_suite(gpu_buddy_test_suite); MODULE_AUTHOR("Intel Corporation"); -MODULE_DESCRIPTION("Kunit test for drm_buddy functions"); +MODULE_DESCRIPTION("Kunit test for gpu_buddy functions"); MODULE_LICENSE("GPL"); diff --git a/drivers/gpu/tests/gpu_random.c b/drivers/gpu/tests/gpu_random.c new file mode 100644 index 000000000000..54f1f6a3a6c1 --- /dev/null +++ b/drivers/gpu/tests/gpu_random.c @@ -0,0 +1,48 @@ +// SPDX-License-Identifier: GPL-2.0 +#include <linux/bitops.h> +#include <linux/export.h> +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/random.h> +#include <linux/slab.h> +#include <linux/types.h> + +#include "gpu_random.h" + +u32 gpu_prandom_u32_max_state(u32 ep_ro, struct rnd_state *state) +{ + return upper_32_bits((u64)prandom_u32_state(state) * ep_ro); +} +EXPORT_SYMBOL(gpu_prandom_u32_max_state); + +void gpu_random_reorder(unsigned int *order, unsigned int count, + struct rnd_state *state) +{ + unsigned int i, j; + + for (i = 0; i < count; ++i) { + BUILD_BUG_ON(sizeof(unsigned int) > sizeof(u32)); + j = gpu_prandom_u32_max_state(count, state); + swap(order[i], order[j]); + } +} +EXPORT_SYMBOL(gpu_random_reorder); + +unsigned int *gpu_random_order(unsigned int count, struct rnd_state *state) +{ + unsigned int *order, i; + + order = kmalloc_array(count, sizeof(*order), GFP_KERNEL); + if (!order) + return order; + + for (i = 0; i < count; i++) + order[i] = i; + + gpu_random_reorder(order, count, state); + return order; +} +EXPORT_SYMBOL(gpu_random_order); + +MODULE_DESCRIPTION("GPU Randomization Utilities"); +MODULE_LICENSE("Dual MIT/GPL"); diff --git a/drivers/gpu/tests/gpu_random.h b/drivers/gpu/tests/gpu_random.h new file mode 100644 index 000000000000..b68cf3448264 --- /dev/null +++ b/drivers/gpu/tests/gpu_random.h @@ -0,0 +1,28 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef __GPU_RANDOM_H__ +#define __GPU_RANDOM_H__ + +/* This is a temporary home for a couple of utility functions that should + * be transposed to lib/ at the earliest convenience. + */ + +#include <linux/prandom.h> + +#define GPU_RND_STATE_INITIALIZER(seed__) ({ \ + struct rnd_state state__; \ + prandom_seed_state(&state__, (seed__)); \ + state__; \ +}) + +#define GPU_RND_STATE(name__, seed__) \ + struct rnd_state name__ = GPU_RND_STATE_INITIALIZER(seed__) + +unsigned int *gpu_random_order(unsigned int count, + struct rnd_state *state); +void gpu_random_reorder(unsigned int *order, + unsigned int count, + struct rnd_state *state); +u32 gpu_prandom_u32_max_state(u32 ep_ro, + struct rnd_state *state); + +#endif /* !__GPU_RANDOM_H__ */ diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig index d51777df12d1..6ae1383b0e2e 100644 --- a/drivers/video/Kconfig +++ b/drivers/video/Kconfig @@ -37,6 +37,8 @@ source "drivers/char/agp/Kconfig" source "drivers/gpu/vga/Kconfig" +source "drivers/gpu/Kconfig" + source "drivers/gpu/host1x/Kconfig" source "drivers/gpu/ipu-v3/Kconfig" source "drivers/gpu/nova-core/Kconfig" diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h index b909fa8f810a..3054369bebff 100644 --- a/include/drm/drm_buddy.h +++ b/include/drm/drm_buddy.h @@ -6,166 +6,13 @@ #ifndef __DRM_BUDDY_H__ #define __DRM_BUDDY_H__ -#include <linux/bitops.h> -#include <linux/list.h> -#include <linux/slab.h> -#include <linux/sched.h> -#include <linux/rbtree.h> +#include <linux/gpu_buddy.h> struct drm_printer; -#define DRM_BUDDY_RANGE_ALLOCATION BIT(0) -#define DRM_BUDDY_TOPDOWN_ALLOCATION BIT(1) -#define DRM_BUDDY_CONTIGUOUS_ALLOCATION BIT(2) -#define DRM_BUDDY_CLEAR_ALLOCATION BIT(3) -#define DRM_BUDDY_CLEARED BIT(4) -#define DRM_BUDDY_TRIM_DISABLE BIT(5) - -struct drm_buddy_block { -#define DRM_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12) -#define DRM_BUDDY_HEADER_STATE GENMASK_ULL(11, 10) -#define DRM_BUDDY_ALLOCATED (1 << 10) -#define DRM_BUDDY_FREE (2 << 10) -#define DRM_BUDDY_SPLIT (3 << 10) -#define DRM_BUDDY_HEADER_CLEAR GENMASK_ULL(9, 9) -/* Free to be used, if needed in the future */ -#define DRM_BUDDY_HEADER_UNUSED GENMASK_ULL(8, 6) -#define DRM_BUDDY_HEADER_ORDER GENMASK_ULL(5, 0) - u64 header; - - struct drm_buddy_block *left; - struct drm_buddy_block *right; - struct drm_buddy_block *parent; - - void *private; /* owned by creator */ - - /* - * While the block is allocated by the user through drm_buddy_alloc*, - * the user has ownership of the link, for example to maintain within - * a list, if so desired. As soon as the block is freed with - * drm_buddy_free* ownership is given back to the mm. - */ - union { - struct rb_node rb; - struct list_head link; - }; - - struct list_head tmp_link; -}; - -/* Order-zero must be at least SZ_4K */ -#define DRM_BUDDY_MAX_ORDER (63 - 12) - -/* - * Binary Buddy System. - * - * Locking should be handled by the user, a simple mutex around - * drm_buddy_alloc* and drm_buddy_free* should suffice. - */ -struct drm_buddy { - /* Maintain a free list for each order. */ - struct rb_root **free_trees; - - /* - * Maintain explicit binary tree(s) to track the allocation of the - * address space. This gives us a simple way of finding a buddy block - * and performing the potentially recursive merge step when freeing a - * block. Nodes are either allocated or free, in which case they will - * also exist on the respective free list. - */ - struct drm_buddy_block **roots; - - /* - * Anything from here is public, and remains static for the lifetime of - * the mm. Everything above is considered do-not-touch. - */ - unsigned int n_roots; - unsigned int max_order; - - /* Must be at least SZ_4K */ - u64 chunk_size; - u64 size; - u64 avail; - u64 clear_avail; -}; - -static inline u64 -drm_buddy_block_offset(const struct drm_buddy_block *block) -{ - return block->header & DRM_BUDDY_HEADER_OFFSET; -} - -static inline unsigned int -drm_buddy_block_order(struct drm_buddy_block *block) -{ - return block->header & DRM_BUDDY_HEADER_ORDER; -} - -static inline unsigned int -drm_buddy_block_state(struct drm_buddy_block *block) -{ - return block->header & DRM_BUDDY_HEADER_STATE; -} - -static inline bool -drm_buddy_block_is_allocated(struct drm_buddy_block *block) -{ - return drm_buddy_block_state(block) == DRM_BUDDY_ALLOCATED; -} - -static inline bool -drm_buddy_block_is_clear(struct drm_buddy_block *block) -{ - return block->header & DRM_BUDDY_HEADER_CLEAR; -} - -static inline bool -drm_buddy_block_is_free(struct drm_buddy_block *block) -{ - return drm_buddy_block_state(block) == DRM_BUDDY_FREE; -} - -static inline bool -drm_buddy_block_is_split(struct drm_buddy_block *block) -{ - return drm_buddy_block_state(block) == DRM_BUDDY_SPLIT; -} - -static inline u64 -drm_buddy_block_size(struct drm_buddy *mm, - struct drm_buddy_block *block) -{ - return mm->chunk_size << drm_buddy_block_order(block); -} - -int drm_buddy_init(struct drm_buddy *mm, u64 size, u64 chunk_size); - -void drm_buddy_fini(struct drm_buddy *mm); - -struct drm_buddy_block * -drm_get_buddy(struct drm_buddy_block *block); - -int drm_buddy_alloc_blocks(struct drm_buddy *mm, - u64 start, u64 end, u64 size, - u64 min_page_size, - struct list_head *blocks, - unsigned long flags); - -int drm_buddy_block_trim(struct drm_buddy *mm, - u64 *start, - u64 new_size, - struct list_head *blocks); - -void drm_buddy_reset_clear(struct drm_buddy *mm, bool is_clear); - -void drm_buddy_free_block(struct drm_buddy *mm, struct drm_buddy_block *block); - -void drm_buddy_free_list(struct drm_buddy *mm, - struct list_head *objects, - unsigned int flags); - -void drm_buddy_print(struct drm_buddy *mm, struct drm_printer *p); -void drm_buddy_block_print(struct drm_buddy *mm, - struct drm_buddy_block *block, +/* DRM-specific GPU Buddy Allocator print helpers */ +void drm_buddy_print(struct gpu_buddy *mm, struct drm_printer *p); +void drm_buddy_block_print(struct gpu_buddy *mm, + struct gpu_buddy_block *block, struct drm_printer *p); #endif diff --git a/include/linux/gpu_buddy.h b/include/linux/gpu_buddy.h new file mode 100644 index 000000000000..3e4bd11ccb71 --- /dev/null +++ b/include/linux/gpu_buddy.h @@ -0,0 +1,177 @@ +/* SPDX-License-Identifier: MIT */ +/* + * Copyright © 2021 Intel Corporation + */ + +#ifndef __GPU_BUDDY_H__ +#define __GPU_BUDDY_H__ + +#include <linux/bitops.h> +#include <linux/list.h> +#include <linux/rbtree.h> +#include <linux/slab.h> +#include <linux/sched.h> + +#define GPU_BUDDY_RANGE_ALLOCATION BIT(0) +#define GPU_BUDDY_TOPDOWN_ALLOCATION BIT(1) +#define GPU_BUDDY_CONTIGUOUS_ALLOCATION BIT(2) +#define GPU_BUDDY_CLEAR_ALLOCATION BIT(3) +#define GPU_BUDDY_CLEARED BIT(4) +#define GPU_BUDDY_TRIM_DISABLE BIT(5) + +enum gpu_buddy_free_tree { + GPU_BUDDY_CLEAR_TREE = 0, + GPU_BUDDY_DIRTY_TREE, + GPU_BUDDY_MAX_FREE_TREES, +}; + +#define for_each_free_tree(tree) \ + for ((tree) = 0; (tree) < GPU_BUDDY_MAX_FREE_TREES; (tree)++) + +struct gpu_buddy_block { +#define GPU_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12) +#define GPU_BUDDY_HEADER_STATE GENMASK_ULL(11, 10) +#define GPU_BUDDY_ALLOCATED (1 << 10) +#define GPU_BUDDY_FREE (2 << 10) +#define GPU_BUDDY_SPLIT (3 << 10) +#define GPU_BUDDY_HEADER_CLEAR GENMASK_ULL(9, 9) +/* Free to be used, if needed in the future */ +#define GPU_BUDDY_HEADER_UNUSED GENMASK_ULL(8, 6) +#define GPU_BUDDY_HEADER_ORDER GENMASK_ULL(5, 0) + u64 header; + + struct gpu_buddy_block *left; + struct gpu_buddy_block *right; + struct gpu_buddy_block *parent; + + void *private; /* owned by creator */ + + /* + * While the block is allocated by the user through gpu_buddy_alloc*, + * the user has ownership of the link, for example to maintain within + * a list, if so desired. As soon as the block is freed with + * gpu_buddy_free* ownership is given back to the mm. + */ + union { + struct rb_node rb; + struct list_head link; + }; + + struct list_head tmp_link; +}; + +/* Order-zero must be at least SZ_4K */ +#define GPU_BUDDY_MAX_ORDER (63 - 12) + +/* + * Binary Buddy System. + * + * Locking should be handled by the user, a simple mutex around + * gpu_buddy_alloc* and gpu_buddy_free* should suffice. + */ +struct gpu_buddy { + /* Maintain a free list for each order. */ + struct rb_root **free_trees; + + /* + * Maintain explicit binary tree(s) to track the allocation of the + * address space. This gives us a simple way of finding a buddy block + * and performing the potentially recursive merge step when freeing a + * block. Nodes are either allocated or free, in which case they will + * also exist on the respective free list. + */ + struct gpu_buddy_block **roots; + + /* + * Anything from here is public, and remains static for the lifetime of + * the mm. Everything above is considered do-not-touch. + */ + unsigned int n_roots; + unsigned int max_order; + + /* Must be at least SZ_4K */ + u64 chunk_size; + u64 size; + u64 avail; + u64 clear_avail; +}; + +static inline u64 +gpu_buddy_block_offset(const struct gpu_buddy_block *block) +{ + return block->header & GPU_BUDDY_HEADER_OFFSET; +} + +static inline unsigned int +gpu_buddy_block_order(struct gpu_buddy_block *block) +{ + return block->header & GPU_BUDDY_HEADER_ORDER; +} + +static inline unsigned int +gpu_buddy_block_state(struct gpu_buddy_block *block) +{ + return block->header & GPU_BUDDY_HEADER_STATE; +} + +static inline bool +gpu_buddy_block_is_allocated(struct gpu_buddy_block *block) +{ + return gpu_buddy_block_state(block) == GPU_BUDDY_ALLOCATED; +} + +static inline bool +gpu_buddy_block_is_clear(struct gpu_buddy_block *block) +{ + return block->header & GPU_BUDDY_HEADER_CLEAR; +} + +static inline bool +gpu_buddy_block_is_free(struct gpu_buddy_block *block) +{ + return gpu_buddy_block_state(block) == GPU_BUDDY_FREE; +} + +static inline bool +gpu_buddy_block_is_split(struct gpu_buddy_block *block) +{ + return gpu_buddy_block_state(block) == GPU_BUDDY_SPLIT; +} + +static inline u64 +gpu_buddy_block_size(struct gpu_buddy *mm, + struct gpu_buddy_block *block) +{ + return mm->chunk_size << gpu_buddy_block_order(block); +} + +int gpu_buddy_init(struct gpu_buddy *mm, u64 size, u64 chunk_size); + +void gpu_buddy_fini(struct gpu_buddy *mm); + +struct gpu_buddy_block * +gpu_get_buddy(struct gpu_buddy_block *block); + +int gpu_buddy_alloc_blocks(struct gpu_buddy *mm, + u64 start, u64 end, u64 size, + u64 min_page_size, + struct list_head *blocks, + unsigned long flags); + +int gpu_buddy_block_trim(struct gpu_buddy *mm, + u64 *start, + u64 new_size, + struct list_head *blocks); + +void gpu_buddy_reset_clear(struct gpu_buddy *mm, bool is_clear); + +void gpu_buddy_free_block(struct gpu_buddy *mm, struct gpu_buddy_block *block); + +void gpu_buddy_free_list(struct gpu_buddy *mm, + struct list_head *objects, + unsigned int flags); + +void gpu_buddy_print(struct gpu_buddy *mm); +void gpu_buddy_block_print(struct gpu_buddy *mm, + struct gpu_buddy_block *block); +#endif -- 2.34.1 ^ permalink raw reply related [flat|nested] 23+ messages in thread
* [PATCH RFC v5 2/6] gpu: Move DRM buddy allocator one level up @ 2025-12-19 20:38 ` Joel Fernandes 0 siblings, 0 replies; 23+ messages in thread From: Joel Fernandes @ 2025-12-19 20:38 UTC (permalink / raw) To: Maarten Lankhorst, Maxime Ripard, Thomas Zimmermann, David Airlie, Simona Vetter, Jonathan Corbet, Alex Deucher, Christian König, Jani Nikula, Joonas Lahtinen, Rodrigo Vivi, Tvrtko Ursulin, Huang Rui, Matthew Auld, Matthew Brost, Lucas De Marchi, Thomas Hellström, Helge Deller Cc: Danilo Krummrich, Alice Ryhl, Miguel Ojeda, Alex Gaynor, Boqun Feng, Gary Guo, Björn Roy Baron, Benno Lossin, Andreas Hindborg, Trevor Gross, Alistair Popple, Alexandre Courbot, Andrea Righi, Philipp Stanner, Elle Rhumsaa, Daniel Almeida, joel, nouveau, dri-devel, rust-for-linux, linux-kernel, linux-doc, amd-gfx, intel-gfx, intel-xe, linux-fbdev, Joel Fernandes Move the DRM buddy allocator one level up so that it can be used by GPU drivers (example, nova-core) that have usecases other than DRM (such as VFIO vGPU support). Modify the API, structures and Kconfigs to use "gpu_buddy" terminology. Adapt the drivers and tests to use the new API. The commit cannot be split due to bissectability, however no functional change is intended. Verified by running K-UNIT tests and build tested various configurations. Signed-off-by: Joel Fernandes <joelagnelf@nvidia.com> --- Documentation/gpu/drm-mm.rst | 10 +- drivers/gpu/Kconfig | 13 + drivers/gpu/Makefile | 2 + drivers/gpu/buddy.c | 1310 +++++++++++++++++ drivers/gpu/drm/Kconfig | 1 + drivers/gpu/drm/Kconfig.debug | 4 +- drivers/gpu/drm/amd/amdgpu/Kconfig | 1 + drivers/gpu/drm/amd/amdgpu/amdgpu_ras.c | 2 +- .../gpu/drm/amd/amdgpu/amdgpu_res_cursor.h | 12 +- drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c | 80 +- drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.h | 20 +- drivers/gpu/drm/drm_buddy.c | 1287 +--------------- drivers/gpu/drm/i915/Kconfig | 1 + drivers/gpu/drm/i915/i915_scatterlist.c | 10 +- drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 55 +- drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 6 +- .../drm/i915/selftests/intel_memory_region.c | 20 +- drivers/gpu/drm/tests/Makefile | 1 - .../gpu/drm/ttm/tests/ttm_bo_validate_test.c | 5 +- drivers/gpu/drm/ttm/tests/ttm_mock_manager.c | 18 +- drivers/gpu/drm/ttm/tests/ttm_mock_manager.h | 4 +- drivers/gpu/drm/xe/Kconfig | 1 + drivers/gpu/drm/xe/xe_res_cursor.h | 34 +- drivers/gpu/drm/xe/xe_svm.c | 12 +- drivers/gpu/drm/xe/xe_ttm_vram_mgr.c | 73 +- drivers/gpu/drm/xe/xe_ttm_vram_mgr_types.h | 4 +- drivers/gpu/tests/Makefile | 3 + .../gpu_buddy_test.c} | 390 ++--- drivers/gpu/tests/gpu_random.c | 48 + drivers/gpu/tests/gpu_random.h | 28 + drivers/video/Kconfig | 2 + include/drm/drm_buddy.h | 163 +- include/linux/gpu_buddy.h | 177 +++ 33 files changed, 1997 insertions(+), 1800 deletions(-) create mode 100644 drivers/gpu/Kconfig create mode 100644 drivers/gpu/buddy.c create mode 100644 drivers/gpu/tests/Makefile rename drivers/gpu/{drm/tests/drm_buddy_test.c => tests/gpu_buddy_test.c} (68%) create mode 100644 drivers/gpu/tests/gpu_random.c create mode 100644 drivers/gpu/tests/gpu_random.h create mode 100644 include/linux/gpu_buddy.h diff --git a/Documentation/gpu/drm-mm.rst b/Documentation/gpu/drm-mm.rst index d55751cad67c..8e0d31230b29 100644 --- a/Documentation/gpu/drm-mm.rst +++ b/Documentation/gpu/drm-mm.rst @@ -509,8 +509,14 @@ DRM GPUVM Function References DRM Buddy Allocator =================== -DRM Buddy Function References ------------------------------ +Buddy Allocator Function References (GPU buddy) +----------------------------------------------- + +.. kernel-doc:: drivers/gpu/buddy.c + :export: + +DRM Buddy Specific Logging Function References +---------------------------------------------- .. kernel-doc:: drivers/gpu/drm/drm_buddy.c :export: diff --git a/drivers/gpu/Kconfig b/drivers/gpu/Kconfig new file mode 100644 index 000000000000..59bac03b0df6 --- /dev/null +++ b/drivers/gpu/Kconfig @@ -0,0 +1,13 @@ +# SPDX-License-Identifier: GPL-2.0 + +config GPU_BUDDY + tristate + help + A page based buddy allocator for GPU memory. + +config GPU_BUDDY_KUNIT_TEST + tristate "KUnit tests for GPU buddy allocator" if !KUNIT_ALL_TESTS + depends on GPU_BUDDY && KUNIT + default KUNIT_ALL_TESTS + help + KUnit tests for the GPU buddy allocator. diff --git a/drivers/gpu/Makefile b/drivers/gpu/Makefile index 36a54d456630..5063caccabdf 100644 --- a/drivers/gpu/Makefile +++ b/drivers/gpu/Makefile @@ -6,3 +6,5 @@ obj-y += host1x/ drm/ vga/ obj-$(CONFIG_IMX_IPUV3_CORE) += ipu-v3/ obj-$(CONFIG_TRACE_GPU_MEM) += trace/ obj-$(CONFIG_NOVA_CORE) += nova-core/ +obj-$(CONFIG_GPU_BUDDY) += buddy.o +obj-y += tests/ diff --git a/drivers/gpu/buddy.c b/drivers/gpu/buddy.c new file mode 100644 index 000000000000..1347c0436617 --- /dev/null +++ b/drivers/gpu/buddy.c @@ -0,0 +1,1310 @@ +// SPDX-License-Identifier: MIT +/* + * Copyright © 2021 Intel Corporation + */ + +#include <kunit/test-bug.h> + +#include <linux/export.h> +#include <linux/gpu_buddy.h> +#include <linux/kmemleak.h> +#include <linux/module.h> +#include <linux/sizes.h> + +static struct kmem_cache *slab_blocks; + +static struct gpu_buddy_block *gpu_block_alloc(struct gpu_buddy *mm, + struct gpu_buddy_block *parent, + unsigned int order, + u64 offset) +{ + struct gpu_buddy_block *block; + + BUG_ON(order > GPU_BUDDY_MAX_ORDER); + + block = kmem_cache_zalloc(slab_blocks, GFP_KERNEL); + if (!block) + return NULL; + + block->header = offset; + block->header |= order; + block->parent = parent; + + RB_CLEAR_NODE(&block->rb); + + BUG_ON(block->header & GPU_BUDDY_HEADER_UNUSED); + return block; +} + +static void gpu_block_free(struct gpu_buddy *mm, + struct gpu_buddy_block *block) +{ + kmem_cache_free(slab_blocks, block); +} + +static enum gpu_buddy_free_tree +get_block_tree(struct gpu_buddy_block *block) +{ + return gpu_buddy_block_is_clear(block) ? + GPU_BUDDY_CLEAR_TREE : GPU_BUDDY_DIRTY_TREE; +} + +static struct gpu_buddy_block * +rbtree_get_free_block(const struct rb_node *node) +{ + return node ? rb_entry(node, struct gpu_buddy_block, rb) : NULL; +} + +static struct gpu_buddy_block * +rbtree_last_free_block(struct rb_root *root) +{ + return rbtree_get_free_block(rb_last(root)); +} + +static bool rbtree_is_empty(struct rb_root *root) +{ + return RB_EMPTY_ROOT(root); +} + +static bool gpu_buddy_block_offset_less(const struct gpu_buddy_block *block, + const struct gpu_buddy_block *node) +{ + return gpu_buddy_block_offset(block) < gpu_buddy_block_offset(node); +} + +static bool rbtree_block_offset_less(struct rb_node *block, + const struct rb_node *node) +{ + return gpu_buddy_block_offset_less(rbtree_get_free_block(block), + rbtree_get_free_block(node)); +} + +static void rbtree_insert(struct gpu_buddy *mm, + struct gpu_buddy_block *block, + enum gpu_buddy_free_tree tree) +{ + rb_add(&block->rb, + &mm->free_trees[tree][gpu_buddy_block_order(block)], + rbtree_block_offset_less); +} + +static void rbtree_remove(struct gpu_buddy *mm, + struct gpu_buddy_block *block) +{ + unsigned int order = gpu_buddy_block_order(block); + enum gpu_buddy_free_tree tree; + struct rb_root *root; + + tree = get_block_tree(block); + root = &mm->free_trees[tree][order]; + + rb_erase(&block->rb, root); + RB_CLEAR_NODE(&block->rb); +} + +static void clear_reset(struct gpu_buddy_block *block) +{ + block->header &= ~GPU_BUDDY_HEADER_CLEAR; +} + +static void mark_cleared(struct gpu_buddy_block *block) +{ + block->header |= GPU_BUDDY_HEADER_CLEAR; +} + +static void mark_allocated(struct gpu_buddy *mm, + struct gpu_buddy_block *block) +{ + block->header &= ~GPU_BUDDY_HEADER_STATE; + block->header |= GPU_BUDDY_ALLOCATED; + + rbtree_remove(mm, block); +} + +static void mark_free(struct gpu_buddy *mm, + struct gpu_buddy_block *block) +{ + enum gpu_buddy_free_tree tree; + + block->header &= ~GPU_BUDDY_HEADER_STATE; + block->header |= GPU_BUDDY_FREE; + + tree = get_block_tree(block); + rbtree_insert(mm, block, tree); +} + +static void mark_split(struct gpu_buddy *mm, + struct gpu_buddy_block *block) +{ + block->header &= ~GPU_BUDDY_HEADER_STATE; + block->header |= GPU_BUDDY_SPLIT; + + rbtree_remove(mm, block); +} + +static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2) +{ + return s1 <= e2 && e1 >= s2; +} + +static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2) +{ + return s1 <= s2 && e1 >= e2; +} + +static struct gpu_buddy_block * +__get_buddy(struct gpu_buddy_block *block) +{ + struct gpu_buddy_block *parent; + + parent = block->parent; + if (!parent) + return NULL; + + if (parent->left == block) + return parent->right; + + return parent->left; +} + +static unsigned int __gpu_buddy_free(struct gpu_buddy *mm, + struct gpu_buddy_block *block, + bool force_merge) +{ + struct gpu_buddy_block *parent; + unsigned int order; + + while ((parent = block->parent)) { + struct gpu_buddy_block *buddy; + + buddy = __get_buddy(block); + + if (!gpu_buddy_block_is_free(buddy)) + break; + + if (!force_merge) { + /* + * Check the block and its buddy clear state and exit + * the loop if they both have the dissimilar state. + */ + if (gpu_buddy_block_is_clear(block) != + gpu_buddy_block_is_clear(buddy)) + break; + + if (gpu_buddy_block_is_clear(block)) + mark_cleared(parent); + } + + rbtree_remove(mm, buddy); + if (force_merge && gpu_buddy_block_is_clear(buddy)) + mm->clear_avail -= gpu_buddy_block_size(mm, buddy); + + gpu_block_free(mm, block); + gpu_block_free(mm, buddy); + + block = parent; + } + + order = gpu_buddy_block_order(block); + mark_free(mm, block); + + return order; +} + +static int __force_merge(struct gpu_buddy *mm, + u64 start, + u64 end, + unsigned int min_order) +{ + unsigned int tree, order; + int i; + + if (!min_order) + return -ENOMEM; + + if (min_order > mm->max_order) + return -EINVAL; + + for_each_free_tree(tree) { + for (i = min_order - 1; i >= 0; i--) { + struct rb_node *iter = rb_last(&mm->free_trees[tree][i]); + + while (iter) { + struct gpu_buddy_block *block, *buddy; + u64 block_start, block_end; + + block = rbtree_get_free_block(iter); + iter = rb_prev(iter); + + if (!block || !block->parent) + continue; + + block_start = gpu_buddy_block_offset(block); + block_end = block_start + gpu_buddy_block_size(mm, block) - 1; + + if (!contains(start, end, block_start, block_end)) + continue; + + buddy = __get_buddy(block); + if (!gpu_buddy_block_is_free(buddy)) + continue; + + WARN_ON(gpu_buddy_block_is_clear(block) == + gpu_buddy_block_is_clear(buddy)); + + /* + * Advance to the next node when the current node is the buddy, + * as freeing the block will also remove its buddy from the tree. + */ + if (iter == &buddy->rb) + iter = rb_prev(iter); + + rbtree_remove(mm, block); + if (gpu_buddy_block_is_clear(block)) + mm->clear_avail -= gpu_buddy_block_size(mm, block); + + order = __gpu_buddy_free(mm, block, true); + if (order >= min_order) + return 0; + } + } + } + + return -ENOMEM; +} + +/** + * gpu_buddy_init - init memory manager + * + * @mm: GPU buddy manager to initialize + * @size: size in bytes to manage + * @chunk_size: minimum page size in bytes for our allocations + * + * Initializes the memory manager and its resources. + * + * Returns: + * 0 on success, error code on failure. + */ +int gpu_buddy_init(struct gpu_buddy *mm, u64 size, u64 chunk_size) +{ + unsigned int i, j, root_count = 0; + u64 offset = 0; + + if (size < chunk_size) + return -EINVAL; + + if (chunk_size < SZ_4K) + return -EINVAL; + + if (!is_power_of_2(chunk_size)) + return -EINVAL; + + size = round_down(size, chunk_size); + + mm->size = size; + mm->avail = size; + mm->clear_avail = 0; + mm->chunk_size = chunk_size; + mm->max_order = ilog2(size) - ilog2(chunk_size); + + BUG_ON(mm->max_order > GPU_BUDDY_MAX_ORDER); + + mm->free_trees = kmalloc_array(GPU_BUDDY_MAX_FREE_TREES, + sizeof(*mm->free_trees), + GFP_KERNEL); + if (!mm->free_trees) + return -ENOMEM; + + for_each_free_tree(i) { + mm->free_trees[i] = kmalloc_array(mm->max_order + 1, + sizeof(struct rb_root), + GFP_KERNEL); + if (!mm->free_trees[i]) + goto out_free_tree; + + for (j = 0; j <= mm->max_order; ++j) + mm->free_trees[i][j] = RB_ROOT; + } + + mm->n_roots = hweight64(size); + + mm->roots = kmalloc_array(mm->n_roots, + sizeof(struct gpu_buddy_block *), + GFP_KERNEL); + if (!mm->roots) + goto out_free_tree; + + /* + * Split into power-of-two blocks, in case we are given a size that is + * not itself a power-of-two. + */ + do { + struct gpu_buddy_block *root; + unsigned int order; + u64 root_size; + + order = ilog2(size) - ilog2(chunk_size); + root_size = chunk_size << order; + + root = gpu_block_alloc(mm, NULL, order, offset); + if (!root) + goto out_free_roots; + + mark_free(mm, root); + + BUG_ON(root_count > mm->max_order); + BUG_ON(gpu_buddy_block_size(mm, root) < chunk_size); + + mm->roots[root_count] = root; + + offset += root_size; + size -= root_size; + root_count++; + } while (size); + + return 0; + +out_free_roots: + while (root_count--) + gpu_block_free(mm, mm->roots[root_count]); + kfree(mm->roots); +out_free_tree: + while (i--) + kfree(mm->free_trees[i]); + kfree(mm->free_trees); + return -ENOMEM; +} +EXPORT_SYMBOL(gpu_buddy_init); + +/** + * gpu_buddy_fini - tear down the memory manager + * + * @mm: GPU buddy manager to free + * + * Cleanup memory manager resources and the freetree + */ +void gpu_buddy_fini(struct gpu_buddy *mm) +{ + u64 root_size, size, start; + unsigned int order; + int i; + + size = mm->size; + + for (i = 0; i < mm->n_roots; ++i) { + order = ilog2(size) - ilog2(mm->chunk_size); + start = gpu_buddy_block_offset(mm->roots[i]); + __force_merge(mm, start, start + size, order); + + if (WARN_ON(!gpu_buddy_block_is_free(mm->roots[i]))) + kunit_fail_current_test("buddy_fini() root"); + + gpu_block_free(mm, mm->roots[i]); + + root_size = mm->chunk_size << order; + size -= root_size; + } + + WARN_ON(mm->avail != mm->size); + + for_each_free_tree(i) + kfree(mm->free_trees[i]); + kfree(mm->roots); +} +EXPORT_SYMBOL(gpu_buddy_fini); + +static int split_block(struct gpu_buddy *mm, + struct gpu_buddy_block *block) +{ + unsigned int block_order = gpu_buddy_block_order(block) - 1; + u64 offset = gpu_buddy_block_offset(block); + + BUG_ON(!gpu_buddy_block_is_free(block)); + BUG_ON(!gpu_buddy_block_order(block)); + + block->left = gpu_block_alloc(mm, block, block_order, offset); + if (!block->left) + return -ENOMEM; + + block->right = gpu_block_alloc(mm, block, block_order, + offset + (mm->chunk_size << block_order)); + if (!block->right) { + gpu_block_free(mm, block->left); + return -ENOMEM; + } + + mark_split(mm, block); + + if (gpu_buddy_block_is_clear(block)) { + mark_cleared(block->left); + mark_cleared(block->right); + clear_reset(block); + } + + mark_free(mm, block->left); + mark_free(mm, block->right); + + return 0; +} + +/** + * gpu_get_buddy - get buddy address + * + * @block: GPU buddy block + * + * Returns the corresponding buddy block for @block, or NULL + * if this is a root block and can't be merged further. + * Requires some kind of locking to protect against + * any concurrent allocate and free operations. + */ +struct gpu_buddy_block * +gpu_get_buddy(struct gpu_buddy_block *block) +{ + return __get_buddy(block); +} +EXPORT_SYMBOL(gpu_get_buddy); + +/** + * gpu_buddy_reset_clear - reset blocks clear state + * + * @mm: GPU buddy manager + * @is_clear: blocks clear state + * + * Reset the clear state based on @is_clear value for each block + * in the freetree. + */ +void gpu_buddy_reset_clear(struct gpu_buddy *mm, bool is_clear) +{ + enum gpu_buddy_free_tree src_tree, dst_tree; + u64 root_size, size, start; + unsigned int order; + int i; + + size = mm->size; + for (i = 0; i < mm->n_roots; ++i) { + order = ilog2(size) - ilog2(mm->chunk_size); + start = gpu_buddy_block_offset(mm->roots[i]); + __force_merge(mm, start, start + size, order); + + root_size = mm->chunk_size << order; + size -= root_size; + } + + src_tree = is_clear ? GPU_BUDDY_DIRTY_TREE : GPU_BUDDY_CLEAR_TREE; + dst_tree = is_clear ? GPU_BUDDY_CLEAR_TREE : GPU_BUDDY_DIRTY_TREE; + + for (i = 0; i <= mm->max_order; ++i) { + struct rb_root *root = &mm->free_trees[src_tree][i]; + struct gpu_buddy_block *block, *tmp; + + rbtree_postorder_for_each_entry_safe(block, tmp, root, rb) { + rbtree_remove(mm, block); + if (is_clear) { + mark_cleared(block); + mm->clear_avail += gpu_buddy_block_size(mm, block); + } else { + clear_reset(block); + mm->clear_avail -= gpu_buddy_block_size(mm, block); + } + + rbtree_insert(mm, block, dst_tree); + } + } +} +EXPORT_SYMBOL(gpu_buddy_reset_clear); + +/** + * gpu_buddy_free_block - free a block + * + * @mm: GPU buddy manager + * @block: block to be freed + */ +void gpu_buddy_free_block(struct gpu_buddy *mm, + struct gpu_buddy_block *block) +{ + BUG_ON(!gpu_buddy_block_is_allocated(block)); + mm->avail += gpu_buddy_block_size(mm, block); + if (gpu_buddy_block_is_clear(block)) + mm->clear_avail += gpu_buddy_block_size(mm, block); + + __gpu_buddy_free(mm, block, false); +} +EXPORT_SYMBOL(gpu_buddy_free_block); + +static void __gpu_buddy_free_list(struct gpu_buddy *mm, + struct list_head *objects, + bool mark_clear, + bool mark_dirty) +{ + struct gpu_buddy_block *block, *on; + + WARN_ON(mark_dirty && mark_clear); + + list_for_each_entry_safe(block, on, objects, link) { + if (mark_clear) + mark_cleared(block); + else if (mark_dirty) + clear_reset(block); + gpu_buddy_free_block(mm, block); + cond_resched(); + } + INIT_LIST_HEAD(objects); +} + +static void gpu_buddy_free_list_internal(struct gpu_buddy *mm, + struct list_head *objects) +{ + /* + * Don't touch the clear/dirty bit, since allocation is still internal + * at this point. For example we might have just failed part of the + * allocation. + */ + __gpu_buddy_free_list(mm, objects, false, false); +} + +/** + * gpu_buddy_free_list - free blocks + * + * @mm: GPU buddy manager + * @objects: input list head to free blocks + * @flags: optional flags like GPU_BUDDY_CLEARED + */ +void gpu_buddy_free_list(struct gpu_buddy *mm, + struct list_head *objects, + unsigned int flags) +{ + bool mark_clear = flags & GPU_BUDDY_CLEARED; + + __gpu_buddy_free_list(mm, objects, mark_clear, !mark_clear); +} +EXPORT_SYMBOL(gpu_buddy_free_list); + +static bool block_incompatible(struct gpu_buddy_block *block, unsigned int flags) +{ + bool needs_clear = flags & GPU_BUDDY_CLEAR_ALLOCATION; + + return needs_clear != gpu_buddy_block_is_clear(block); +} + +static struct gpu_buddy_block * +__alloc_range_bias(struct gpu_buddy *mm, + u64 start, u64 end, + unsigned int order, + unsigned long flags, + bool fallback) +{ + u64 req_size = mm->chunk_size << order; + struct gpu_buddy_block *block; + struct gpu_buddy_block *buddy; + LIST_HEAD(dfs); + int err; + int i; + + end = end - 1; + + for (i = 0; i < mm->n_roots; ++i) + list_add_tail(&mm->roots[i]->tmp_link, &dfs); + + do { + u64 block_start; + u64 block_end; + + block = list_first_entry_or_null(&dfs, + struct gpu_buddy_block, + tmp_link); + if (!block) + break; + + list_del(&block->tmp_link); + + if (gpu_buddy_block_order(block) < order) + continue; + + block_start = gpu_buddy_block_offset(block); + block_end = block_start + gpu_buddy_block_size(mm, block) - 1; + + if (!overlaps(start, end, block_start, block_end)) + continue; + + if (gpu_buddy_block_is_allocated(block)) + continue; + + if (block_start < start || block_end > end) { + u64 adjusted_start = max(block_start, start); + u64 adjusted_end = min(block_end, end); + + if (round_down(adjusted_end + 1, req_size) <= + round_up(adjusted_start, req_size)) + continue; + } + + if (!fallback && block_incompatible(block, flags)) + continue; + + if (contains(start, end, block_start, block_end) && + order == gpu_buddy_block_order(block)) { + /* + * Find the free block within the range. + */ + if (gpu_buddy_block_is_free(block)) + return block; + + continue; + } + + if (!gpu_buddy_block_is_split(block)) { + err = split_block(mm, block); + if (unlikely(err)) + goto err_undo; + } + + list_add(&block->right->tmp_link, &dfs); + list_add(&block->left->tmp_link, &dfs); + } while (1); + + return ERR_PTR(-ENOSPC); + +err_undo: + /* + * We really don't want to leave around a bunch of split blocks, since + * bigger is better, so make sure we merge everything back before we + * free the allocated blocks. + */ + buddy = __get_buddy(block); + if (buddy && + (gpu_buddy_block_is_free(block) && + gpu_buddy_block_is_free(buddy))) + __gpu_buddy_free(mm, block, false); + return ERR_PTR(err); +} + +static struct gpu_buddy_block * +__gpu_buddy_alloc_range_bias(struct gpu_buddy *mm, + u64 start, u64 end, + unsigned int order, + unsigned long flags) +{ + struct gpu_buddy_block *block; + bool fallback = false; + + block = __alloc_range_bias(mm, start, end, order, + flags, fallback); + if (IS_ERR(block)) + return __alloc_range_bias(mm, start, end, order, + flags, !fallback); + + return block; +} + +static struct gpu_buddy_block * +get_maxblock(struct gpu_buddy *mm, + unsigned int order, + enum gpu_buddy_free_tree tree) +{ + struct gpu_buddy_block *max_block = NULL, *block = NULL; + struct rb_root *root; + unsigned int i; + + for (i = order; i <= mm->max_order; ++i) { + root = &mm->free_trees[tree][i]; + block = rbtree_last_free_block(root); + if (!block) + continue; + + if (!max_block) { + max_block = block; + continue; + } + + if (gpu_buddy_block_offset(block) > + gpu_buddy_block_offset(max_block)) { + max_block = block; + } + } + + return max_block; +} + +static struct gpu_buddy_block * +alloc_from_freetree(struct gpu_buddy *mm, + unsigned int order, + unsigned long flags) +{ + struct gpu_buddy_block *block = NULL; + struct rb_root *root; + enum gpu_buddy_free_tree tree; + unsigned int tmp; + int err; + + tree = (flags & GPU_BUDDY_CLEAR_ALLOCATION) ? + GPU_BUDDY_CLEAR_TREE : GPU_BUDDY_DIRTY_TREE; + + if (flags & GPU_BUDDY_TOPDOWN_ALLOCATION) { + block = get_maxblock(mm, order, tree); + if (block) + /* Store the obtained block order */ + tmp = gpu_buddy_block_order(block); + } else { + for (tmp = order; tmp <= mm->max_order; ++tmp) { + /* Get RB tree root for this order and tree */ + root = &mm->free_trees[tree][tmp]; + block = rbtree_last_free_block(root); + if (block) + break; + } + } + + if (!block) { + /* Try allocating from the other tree */ + tree = (tree == GPU_BUDDY_CLEAR_TREE) ? + GPU_BUDDY_DIRTY_TREE : GPU_BUDDY_CLEAR_TREE; + + for (tmp = order; tmp <= mm->max_order; ++tmp) { + root = &mm->free_trees[tree][tmp]; + block = rbtree_last_free_block(root); + if (block) + break; + } + + if (!block) + return ERR_PTR(-ENOSPC); + } + + BUG_ON(!gpu_buddy_block_is_free(block)); + + while (tmp != order) { + err = split_block(mm, block); + if (unlikely(err)) + goto err_undo; + + block = block->right; + tmp--; + } + return block; + +err_undo: + if (tmp != order) + __gpu_buddy_free(mm, block, false); + return ERR_PTR(err); +} + +static int __alloc_range(struct gpu_buddy *mm, + struct list_head *dfs, + u64 start, u64 size, + struct list_head *blocks, + u64 *total_allocated_on_err) +{ + struct gpu_buddy_block *block; + struct gpu_buddy_block *buddy; + u64 total_allocated = 0; + LIST_HEAD(allocated); + u64 end; + int err; + + end = start + size - 1; + + do { + u64 block_start; + u64 block_end; + + block = list_first_entry_or_null(dfs, + struct gpu_buddy_block, + tmp_link); + if (!block) + break; + + list_del(&block->tmp_link); + + block_start = gpu_buddy_block_offset(block); + block_end = block_start + gpu_buddy_block_size(mm, block) - 1; + + if (!overlaps(start, end, block_start, block_end)) + continue; + + if (gpu_buddy_block_is_allocated(block)) { + err = -ENOSPC; + goto err_free; + } + + if (contains(start, end, block_start, block_end)) { + if (gpu_buddy_block_is_free(block)) { + mark_allocated(mm, block); + total_allocated += gpu_buddy_block_size(mm, block); + mm->avail -= gpu_buddy_block_size(mm, block); + if (gpu_buddy_block_is_clear(block)) + mm->clear_avail -= gpu_buddy_block_size(mm, block); + list_add_tail(&block->link, &allocated); + continue; + } else if (!mm->clear_avail) { + err = -ENOSPC; + goto err_free; + } + } + + if (!gpu_buddy_block_is_split(block)) { + err = split_block(mm, block); + if (unlikely(err)) + goto err_undo; + } + + list_add(&block->right->tmp_link, dfs); + list_add(&block->left->tmp_link, dfs); + } while (1); + + if (total_allocated < size) { + err = -ENOSPC; + goto err_free; + } + + list_splice_tail(&allocated, blocks); + + return 0; + +err_undo: + /* + * We really don't want to leave around a bunch of split blocks, since + * bigger is better, so make sure we merge everything back before we + * free the allocated blocks. + */ + buddy = __get_buddy(block); + if (buddy && + (gpu_buddy_block_is_free(block) && + gpu_buddy_block_is_free(buddy))) + __gpu_buddy_free(mm, block, false); + +err_free: + if (err == -ENOSPC && total_allocated_on_err) { + list_splice_tail(&allocated, blocks); + *total_allocated_on_err = total_allocated; + } else { + gpu_buddy_free_list_internal(mm, &allocated); + } + + return err; +} + +static int __gpu_buddy_alloc_range(struct gpu_buddy *mm, + u64 start, + u64 size, + u64 *total_allocated_on_err, + struct list_head *blocks) +{ + LIST_HEAD(dfs); + int i; + + for (i = 0; i < mm->n_roots; ++i) + list_add_tail(&mm->roots[i]->tmp_link, &dfs); + + return __alloc_range(mm, &dfs, start, size, + blocks, total_allocated_on_err); +} + +static int __alloc_contig_try_harder(struct gpu_buddy *mm, + u64 size, + u64 min_block_size, + struct list_head *blocks) +{ + u64 rhs_offset, lhs_offset, lhs_size, filled; + struct gpu_buddy_block *block; + unsigned int tree, order; + LIST_HEAD(blocks_lhs); + unsigned long pages; + u64 modify_size; + int err; + + modify_size = rounddown_pow_of_two(size); + pages = modify_size >> ilog2(mm->chunk_size); + order = fls(pages) - 1; + if (order == 0) + return -ENOSPC; + + for_each_free_tree(tree) { + struct rb_root *root; + struct rb_node *iter; + + root = &mm->free_trees[tree][order]; + if (rbtree_is_empty(root)) + continue; + + iter = rb_last(root); + while (iter) { + block = rbtree_get_free_block(iter); + + /* Allocate blocks traversing RHS */ + rhs_offset = gpu_buddy_block_offset(block); + err = __gpu_buddy_alloc_range(mm, rhs_offset, size, + &filled, blocks); + if (!err || err != -ENOSPC) + return err; + + lhs_size = max((size - filled), min_block_size); + if (!IS_ALIGNED(lhs_size, min_block_size)) + lhs_size = round_up(lhs_size, min_block_size); + + /* Allocate blocks traversing LHS */ + lhs_offset = gpu_buddy_block_offset(block) - lhs_size; + err = __gpu_buddy_alloc_range(mm, lhs_offset, lhs_size, + NULL, &blocks_lhs); + if (!err) { + list_splice(&blocks_lhs, blocks); + return 0; + } else if (err != -ENOSPC) { + gpu_buddy_free_list_internal(mm, blocks); + return err; + } + /* Free blocks for the next iteration */ + gpu_buddy_free_list_internal(mm, blocks); + + iter = rb_prev(iter); + } + } + + return -ENOSPC; +} + +/** + * gpu_buddy_block_trim - free unused pages + * + * @mm: GPU buddy manager + * @start: start address to begin the trimming. + * @new_size: original size requested + * @blocks: Input and output list of allocated blocks. + * MUST contain single block as input to be trimmed. + * On success will contain the newly allocated blocks + * making up the @new_size. Blocks always appear in + * ascending order + * + * For contiguous allocation, we round up the size to the nearest + * power of two value, drivers consume *actual* size, so remaining + * portions are unused and can be optionally freed with this function + * + * Returns: + * 0 on success, error code on failure. + */ +int gpu_buddy_block_trim(struct gpu_buddy *mm, + u64 *start, + u64 new_size, + struct list_head *blocks) +{ + struct gpu_buddy_block *parent; + struct gpu_buddy_block *block; + u64 block_start, block_end; + LIST_HEAD(dfs); + u64 new_start; + int err; + + if (!list_is_singular(blocks)) + return -EINVAL; + + block = list_first_entry(blocks, + struct gpu_buddy_block, + link); + + block_start = gpu_buddy_block_offset(block); + block_end = block_start + gpu_buddy_block_size(mm, block); + + if (WARN_ON(!gpu_buddy_block_is_allocated(block))) + return -EINVAL; + + if (new_size > gpu_buddy_block_size(mm, block)) + return -EINVAL; + + if (!new_size || !IS_ALIGNED(new_size, mm->chunk_size)) + return -EINVAL; + + if (new_size == gpu_buddy_block_size(mm, block)) + return 0; + + new_start = block_start; + if (start) { + new_start = *start; + + if (new_start < block_start) + return -EINVAL; + + if (!IS_ALIGNED(new_start, mm->chunk_size)) + return -EINVAL; + + if (range_overflows(new_start, new_size, block_end)) + return -EINVAL; + } + + list_del(&block->link); + mark_free(mm, block); + mm->avail += gpu_buddy_block_size(mm, block); + if (gpu_buddy_block_is_clear(block)) + mm->clear_avail += gpu_buddy_block_size(mm, block); + + /* Prevent recursively freeing this node */ + parent = block->parent; + block->parent = NULL; + + list_add(&block->tmp_link, &dfs); + err = __alloc_range(mm, &dfs, new_start, new_size, blocks, NULL); + if (err) { + mark_allocated(mm, block); + mm->avail -= gpu_buddy_block_size(mm, block); + if (gpu_buddy_block_is_clear(block)) + mm->clear_avail -= gpu_buddy_block_size(mm, block); + list_add(&block->link, blocks); + } + + block->parent = parent; + return err; +} +EXPORT_SYMBOL(gpu_buddy_block_trim); + +static struct gpu_buddy_block * +__gpu_buddy_alloc_blocks(struct gpu_buddy *mm, + u64 start, u64 end, + unsigned int order, + unsigned long flags) +{ + if (flags & GPU_BUDDY_RANGE_ALLOCATION) + /* Allocate traversing within the range */ + return __gpu_buddy_alloc_range_bias(mm, start, end, + order, flags); + else + /* Allocate from freetree */ + return alloc_from_freetree(mm, order, flags); +} + +/** + * gpu_buddy_alloc_blocks - allocate power-of-two blocks + * + * @mm: GPU buddy manager to allocate from + * @start: start of the allowed range for this block + * @end: end of the allowed range for this block + * @size: size of the allocation in bytes + * @min_block_size: alignment of the allocation + * @blocks: output list head to add allocated blocks + * @flags: GPU_BUDDY_*_ALLOCATION flags + * + * alloc_range_bias() called on range limitations, which traverses + * the tree and returns the desired block. + * + * alloc_from_freetree() called when *no* range restrictions + * are enforced, which picks the block from the freetree. + * + * Returns: + * 0 on success, error code on failure. + */ +int gpu_buddy_alloc_blocks(struct gpu_buddy *mm, + u64 start, u64 end, u64 size, + u64 min_block_size, + struct list_head *blocks, + unsigned long flags) +{ + struct gpu_buddy_block *block = NULL; + u64 original_size, original_min_size; + unsigned int min_order, order; + LIST_HEAD(allocated); + unsigned long pages; + int err; + + if (size < mm->chunk_size) + return -EINVAL; + + if (min_block_size < mm->chunk_size) + return -EINVAL; + + if (!is_power_of_2(min_block_size)) + return -EINVAL; + + if (!IS_ALIGNED(start | end | size, mm->chunk_size)) + return -EINVAL; + + if (end > mm->size) + return -EINVAL; + + if (range_overflows(start, size, mm->size)) + return -EINVAL; + + /* Actual range allocation */ + if (start + size == end) { + if (!IS_ALIGNED(start | end, min_block_size)) + return -EINVAL; + + return __gpu_buddy_alloc_range(mm, start, size, NULL, blocks); + } + + original_size = size; + original_min_size = min_block_size; + + /* Roundup the size to power of 2 */ + if (flags & GPU_BUDDY_CONTIGUOUS_ALLOCATION) { + size = roundup_pow_of_two(size); + min_block_size = size; + /* Align size value to min_block_size */ + } else if (!IS_ALIGNED(size, min_block_size)) { + size = round_up(size, min_block_size); + } + + pages = size >> ilog2(mm->chunk_size); + order = fls(pages) - 1; + min_order = ilog2(min_block_size) - ilog2(mm->chunk_size); + + do { + order = min(order, (unsigned int)fls(pages) - 1); + BUG_ON(order > mm->max_order); + BUG_ON(order < min_order); + + do { + block = __gpu_buddy_alloc_blocks(mm, start, + end, + order, + flags); + if (!IS_ERR(block)) + break; + + if (order-- == min_order) { + /* Try allocation through force merge method */ + if (mm->clear_avail && + !__force_merge(mm, start, end, min_order)) { + block = __gpu_buddy_alloc_blocks(mm, start, + end, + min_order, + flags); + if (!IS_ERR(block)) { + order = min_order; + break; + } + } + + /* + * Try contiguous block allocation through + * try harder method. + */ + if (flags & GPU_BUDDY_CONTIGUOUS_ALLOCATION && + !(flags & GPU_BUDDY_RANGE_ALLOCATION)) + return __alloc_contig_try_harder(mm, + original_size, + original_min_size, + blocks); + err = -ENOSPC; + goto err_free; + } + } while (1); + + mark_allocated(mm, block); + mm->avail -= gpu_buddy_block_size(mm, block); + if (gpu_buddy_block_is_clear(block)) + mm->clear_avail -= gpu_buddy_block_size(mm, block); + kmemleak_update_trace(block); + list_add_tail(&block->link, &allocated); + + pages -= BIT(order); + + if (!pages) + break; + } while (1); + + /* Trim the allocated block to the required size */ + if (!(flags & GPU_BUDDY_TRIM_DISABLE) && + original_size != size) { + struct list_head *trim_list; + LIST_HEAD(temp); + u64 trim_size; + + trim_list = &allocated; + trim_size = original_size; + + if (!list_is_singular(&allocated)) { + block = list_last_entry(&allocated, typeof(*block), link); + list_move(&block->link, &temp); + trim_list = &temp; + trim_size = gpu_buddy_block_size(mm, block) - + (size - original_size); + } + + gpu_buddy_block_trim(mm, + NULL, + trim_size, + trim_list); + + if (!list_empty(&temp)) + list_splice_tail(trim_list, &allocated); + } + + list_splice_tail(&allocated, blocks); + return 0; + +err_free: + gpu_buddy_free_list_internal(mm, &allocated); + return err; +} +EXPORT_SYMBOL(gpu_buddy_alloc_blocks); + +/** + * gpu_buddy_block_print - print block information + * + * @mm: GPU buddy manager + * @block: GPU buddy block + */ +void gpu_buddy_block_print(struct gpu_buddy *mm, + struct gpu_buddy_block *block) +{ + u64 start = gpu_buddy_block_offset(block); + u64 size = gpu_buddy_block_size(mm, block); + + pr_info("%#018llx-%#018llx: %llu\n", start, start + size, size); +} +EXPORT_SYMBOL(gpu_buddy_block_print); + +/** + * gpu_buddy_print - print allocator state + * + * @mm: GPU buddy manager + */ +void gpu_buddy_print(struct gpu_buddy *mm) +{ + int order; + + pr_info("chunk_size: %lluKiB, total: %lluMiB, free: %lluMiB, clear_free: %lluMiB\n", + mm->chunk_size >> 10, mm->size >> 20, mm->avail >> 20, mm->clear_avail >> 20); + + for (order = mm->max_order; order >= 0; order--) { + struct gpu_buddy_block *block, *tmp; + struct rb_root *root; + u64 count = 0, free; + unsigned int tree; + + for_each_free_tree(tree) { + root = &mm->free_trees[tree][order]; + + rbtree_postorder_for_each_entry_safe(block, tmp, root, rb) { + BUG_ON(!gpu_buddy_block_is_free(block)); + count++; + } + } + + free = count * (mm->chunk_size << order); + if (free < SZ_1M) + pr_info("order-%2d free: %8llu KiB, blocks: %llu\n", + order, free >> 10, count); + else + pr_info("order-%2d free: %8llu MiB, blocks: %llu\n", + order, free >> 20, count); + } +} +EXPORT_SYMBOL(gpu_buddy_print); + +static void gpu_buddy_module_exit(void) +{ + kmem_cache_destroy(slab_blocks); +} + +static int __init gpu_buddy_module_init(void) +{ + slab_blocks = KMEM_CACHE(gpu_buddy_block, 0); + if (!slab_blocks) + return -ENOMEM; + + return 0; +} + +module_init(gpu_buddy_module_init); +module_exit(gpu_buddy_module_exit); + +MODULE_DESCRIPTION("GPU Buddy Allocator"); +MODULE_LICENSE("Dual MIT/GPL"); diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig index 7e6bc0b3a589..0475defb37f0 100644 --- a/drivers/gpu/drm/Kconfig +++ b/drivers/gpu/drm/Kconfig @@ -220,6 +220,7 @@ config DRM_GPUSVM config DRM_BUDDY tristate depends on DRM + select GPU_BUDDY help A page based buddy allocator diff --git a/drivers/gpu/drm/Kconfig.debug b/drivers/gpu/drm/Kconfig.debug index 05dc43c0b8c5..1f4c408c7920 100644 --- a/drivers/gpu/drm/Kconfig.debug +++ b/drivers/gpu/drm/Kconfig.debug @@ -71,6 +71,7 @@ config DRM_KUNIT_TEST select DRM_KUNIT_TEST_HELPERS select DRM_LIB_RANDOM select DRM_SYSFB_HELPER + select GPU_BUDDY select PRIME_NUMBERS default KUNIT_ALL_TESTS help @@ -88,10 +89,11 @@ config DRM_TTM_KUNIT_TEST tristate "KUnit tests for TTM" if !KUNIT_ALL_TESTS default n depends on DRM && KUNIT && MMU && (UML || COMPILE_TEST) - select DRM_TTM select DRM_BUDDY + select DRM_TTM select DRM_EXPORT_FOR_TESTS if m select DRM_KUNIT_TEST_HELPERS + select GPU_BUDDY default KUNIT_ALL_TESTS help Enables unit tests for TTM, a GPU memory manager subsystem used diff --git a/drivers/gpu/drm/amd/amdgpu/Kconfig b/drivers/gpu/drm/amd/amdgpu/Kconfig index 7f515be5185d..bb131543e1d9 100644 --- a/drivers/gpu/drm/amd/amdgpu/Kconfig +++ b/drivers/gpu/drm/amd/amdgpu/Kconfig @@ -23,6 +23,7 @@ config DRM_AMDGPU select CRC16 select BACKLIGHT_CLASS_DEVICE select INTERVAL_TREE + select GPU_BUDDY select DRM_BUDDY select DRM_SUBALLOC_HELPER select DRM_EXEC diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ras.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_ras.c index 2a6cf7963dde..e0bd8a68877f 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ras.c +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ras.c @@ -5654,7 +5654,7 @@ int amdgpu_ras_add_critical_region(struct amdgpu_device *adev, struct amdgpu_ras *con = amdgpu_ras_get_context(adev); struct amdgpu_vram_mgr_resource *vres; struct ras_critical_region *region; - struct drm_buddy_block *block; + struct gpu_buddy_block *block; int ret = 0; if (!bo || !bo->tbo.resource) diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_res_cursor.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_res_cursor.h index be2e56ce1355..8908d9e08a30 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_res_cursor.h +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_res_cursor.h @@ -55,7 +55,7 @@ static inline void amdgpu_res_first(struct ttm_resource *res, uint64_t start, uint64_t size, struct amdgpu_res_cursor *cur) { - struct drm_buddy_block *block; + struct gpu_buddy_block *block; struct list_head *head, *next; struct drm_mm_node *node; @@ -71,7 +71,7 @@ static inline void amdgpu_res_first(struct ttm_resource *res, head = &to_amdgpu_vram_mgr_resource(res)->blocks; block = list_first_entry_or_null(head, - struct drm_buddy_block, + struct gpu_buddy_block, link); if (!block) goto fallback; @@ -81,7 +81,7 @@ static inline void amdgpu_res_first(struct ttm_resource *res, next = block->link.next; if (next != head) - block = list_entry(next, struct drm_buddy_block, link); + block = list_entry(next, struct gpu_buddy_block, link); } cur->start = amdgpu_vram_mgr_block_start(block) + start; @@ -125,7 +125,7 @@ static inline void amdgpu_res_first(struct ttm_resource *res, */ static inline void amdgpu_res_next(struct amdgpu_res_cursor *cur, uint64_t size) { - struct drm_buddy_block *block; + struct gpu_buddy_block *block; struct drm_mm_node *node; struct list_head *next; @@ -146,7 +146,7 @@ static inline void amdgpu_res_next(struct amdgpu_res_cursor *cur, uint64_t size) block = cur->node; next = block->link.next; - block = list_entry(next, struct drm_buddy_block, link); + block = list_entry(next, struct gpu_buddy_block, link); cur->node = block; cur->start = amdgpu_vram_mgr_block_start(block); @@ -175,7 +175,7 @@ static inline void amdgpu_res_next(struct amdgpu_res_cursor *cur, uint64_t size) */ static inline bool amdgpu_res_cleared(struct amdgpu_res_cursor *cur) { - struct drm_buddy_block *block; + struct gpu_buddy_block *block; switch (cur->mem_type) { case TTM_PL_VRAM: diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c index 9d934c07fa6b..6c06a9c9b13f 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c @@ -23,6 +23,8 @@ */ #include <linux/dma-mapping.h> + +#include <drm/drm_buddy.h> #include <drm/ttm/ttm_range_manager.h> #include <drm/drm_drv.h> @@ -52,15 +54,15 @@ to_amdgpu_device(struct amdgpu_vram_mgr *mgr) return container_of(mgr, struct amdgpu_device, mman.vram_mgr); } -static inline struct drm_buddy_block * +static inline struct gpu_buddy_block * amdgpu_vram_mgr_first_block(struct list_head *list) { - return list_first_entry_or_null(list, struct drm_buddy_block, link); + return list_first_entry_or_null(list, struct gpu_buddy_block, link); } static inline bool amdgpu_is_vram_mgr_blocks_contiguous(struct list_head *head) { - struct drm_buddy_block *block; + struct gpu_buddy_block *block; u64 start, size; block = amdgpu_vram_mgr_first_block(head); @@ -71,7 +73,7 @@ static inline bool amdgpu_is_vram_mgr_blocks_contiguous(struct list_head *head) start = amdgpu_vram_mgr_block_start(block); size = amdgpu_vram_mgr_block_size(block); - block = list_entry(block->link.next, struct drm_buddy_block, link); + block = list_entry(block->link.next, struct gpu_buddy_block, link); if (start + size != amdgpu_vram_mgr_block_start(block)) return false; } @@ -81,7 +83,7 @@ static inline bool amdgpu_is_vram_mgr_blocks_contiguous(struct list_head *head) static inline u64 amdgpu_vram_mgr_blocks_size(struct list_head *head) { - struct drm_buddy_block *block; + struct gpu_buddy_block *block; u64 size = 0; list_for_each_entry(block, head, link) @@ -254,7 +256,7 @@ const struct attribute_group amdgpu_vram_mgr_attr_group = { * Calculate how many bytes of the DRM BUDDY block are inside visible VRAM */ static u64 amdgpu_vram_mgr_vis_size(struct amdgpu_device *adev, - struct drm_buddy_block *block) + struct gpu_buddy_block *block) { u64 start = amdgpu_vram_mgr_block_start(block); u64 end = start + amdgpu_vram_mgr_block_size(block); @@ -279,7 +281,7 @@ u64 amdgpu_vram_mgr_bo_visible_size(struct amdgpu_bo *bo) struct amdgpu_device *adev = amdgpu_ttm_adev(bo->tbo.bdev); struct ttm_resource *res = bo->tbo.resource; struct amdgpu_vram_mgr_resource *vres = to_amdgpu_vram_mgr_resource(res); - struct drm_buddy_block *block; + struct gpu_buddy_block *block; u64 usage = 0; if (amdgpu_gmc_vram_full_visible(&adev->gmc)) @@ -299,15 +301,15 @@ static void amdgpu_vram_mgr_do_reserve(struct ttm_resource_manager *man) { struct amdgpu_vram_mgr *mgr = to_vram_mgr(man); struct amdgpu_device *adev = to_amdgpu_device(mgr); - struct drm_buddy *mm = &mgr->mm; + struct gpu_buddy *mm = &mgr->mm; struct amdgpu_vram_reservation *rsv, *temp; - struct drm_buddy_block *block; + struct gpu_buddy_block *block; uint64_t vis_usage; list_for_each_entry_safe(rsv, temp, &mgr->reservations_pending, blocks) { - if (drm_buddy_alloc_blocks(mm, rsv->start, rsv->start + rsv->size, + if (gpu_buddy_alloc_blocks(mm, rsv->start, rsv->start + rsv->size, rsv->size, mm->chunk_size, &rsv->allocated, - DRM_BUDDY_RANGE_ALLOCATION)) + GPU_BUDDY_RANGE_ALLOCATION)) continue; block = amdgpu_vram_mgr_first_block(&rsv->allocated); @@ -403,7 +405,7 @@ int amdgpu_vram_mgr_query_address_block_info(struct amdgpu_vram_mgr *mgr, uint64_t address, struct amdgpu_vram_block_info *info) { struct amdgpu_vram_mgr_resource *vres; - struct drm_buddy_block *block; + struct gpu_buddy_block *block; u64 start, size; int ret = -ENOENT; @@ -450,8 +452,8 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man, struct amdgpu_vram_mgr_resource *vres; u64 size, remaining_size, lpfn, fpfn; unsigned int adjust_dcc_size = 0; - struct drm_buddy *mm = &mgr->mm; - struct drm_buddy_block *block; + struct gpu_buddy *mm = &mgr->mm; + struct gpu_buddy_block *block; unsigned long pages_per_block; int r; @@ -493,17 +495,17 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man, INIT_LIST_HEAD(&vres->blocks); if (place->flags & TTM_PL_FLAG_TOPDOWN) - vres->flags |= DRM_BUDDY_TOPDOWN_ALLOCATION; + vres->flags |= GPU_BUDDY_TOPDOWN_ALLOCATION; if (bo->flags & AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS) - vres->flags |= DRM_BUDDY_CONTIGUOUS_ALLOCATION; + vres->flags |= GPU_BUDDY_CONTIGUOUS_ALLOCATION; if (bo->flags & AMDGPU_GEM_CREATE_VRAM_CLEARED) - vres->flags |= DRM_BUDDY_CLEAR_ALLOCATION; + vres->flags |= GPU_BUDDY_CLEAR_ALLOCATION; if (fpfn || lpfn != mgr->mm.size) /* Allocate blocks in desired range */ - vres->flags |= DRM_BUDDY_RANGE_ALLOCATION; + vres->flags |= GPU_BUDDY_RANGE_ALLOCATION; if (bo->flags & AMDGPU_GEM_CREATE_GFX12_DCC && adev->gmc.gmc_funcs->get_dcc_alignment) @@ -516,7 +518,7 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man, dcc_size = roundup_pow_of_two(vres->base.size + adjust_dcc_size); remaining_size = (u64)dcc_size; - vres->flags |= DRM_BUDDY_TRIM_DISABLE; + vres->flags |= GPU_BUDDY_TRIM_DISABLE; } mutex_lock(&mgr->lock); @@ -536,7 +538,7 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man, BUG_ON(min_block_size < mm->chunk_size); - r = drm_buddy_alloc_blocks(mm, fpfn, + r = gpu_buddy_alloc_blocks(mm, fpfn, lpfn, size, min_block_size, @@ -545,7 +547,7 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man, if (unlikely(r == -ENOSPC) && pages_per_block == ~0ul && !(place->flags & TTM_PL_FLAG_CONTIGUOUS)) { - vres->flags &= ~DRM_BUDDY_CONTIGUOUS_ALLOCATION; + vres->flags &= ~GPU_BUDDY_CONTIGUOUS_ALLOCATION; pages_per_block = max_t(u32, 2UL << (20UL - PAGE_SHIFT), tbo->page_alignment); @@ -566,7 +568,7 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man, list_add_tail(&vres->vres_node, &mgr->allocated_vres_list); if (bo->flags & AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS && adjust_dcc_size) { - struct drm_buddy_block *dcc_block; + struct gpu_buddy_block *dcc_block; unsigned long dcc_start; u64 trim_start; @@ -576,7 +578,7 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man, roundup((unsigned long)amdgpu_vram_mgr_block_start(dcc_block), adjust_dcc_size); trim_start = (u64)dcc_start; - drm_buddy_block_trim(mm, &trim_start, + gpu_buddy_block_trim(mm, &trim_start, (u64)vres->base.size, &vres->blocks); } @@ -614,7 +616,7 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man, return 0; error_free_blocks: - drm_buddy_free_list(mm, &vres->blocks, 0); + gpu_buddy_free_list(mm, &vres->blocks, 0); mutex_unlock(&mgr->lock); error_fini: ttm_resource_fini(man, &vres->base); @@ -637,8 +639,8 @@ static void amdgpu_vram_mgr_del(struct ttm_resource_manager *man, struct amdgpu_vram_mgr_resource *vres = to_amdgpu_vram_mgr_resource(res); struct amdgpu_vram_mgr *mgr = to_vram_mgr(man); struct amdgpu_device *adev = to_amdgpu_device(mgr); - struct drm_buddy *mm = &mgr->mm; - struct drm_buddy_block *block; + struct gpu_buddy *mm = &mgr->mm; + struct gpu_buddy_block *block; uint64_t vis_usage = 0; mutex_lock(&mgr->lock); @@ -649,7 +651,7 @@ static void amdgpu_vram_mgr_del(struct ttm_resource_manager *man, list_for_each_entry(block, &vres->blocks, link) vis_usage += amdgpu_vram_mgr_vis_size(adev, block); - drm_buddy_free_list(mm, &vres->blocks, vres->flags); + gpu_buddy_free_list(mm, &vres->blocks, vres->flags); amdgpu_vram_mgr_do_reserve(man); mutex_unlock(&mgr->lock); @@ -688,7 +690,7 @@ int amdgpu_vram_mgr_alloc_sgt(struct amdgpu_device *adev, if (!*sgt) return -ENOMEM; - /* Determine the number of DRM_BUDDY blocks to export */ + /* Determine the number of GPU_BUDDY blocks to export */ amdgpu_res_first(res, offset, length, &cursor); while (cursor.remaining) { num_entries++; @@ -704,10 +706,10 @@ int amdgpu_vram_mgr_alloc_sgt(struct amdgpu_device *adev, sg->length = 0; /* - * Walk down DRM_BUDDY blocks to populate scatterlist nodes - * @note: Use iterator api to get first the DRM_BUDDY block + * Walk down GPU_BUDDY blocks to populate scatterlist nodes + * @note: Use iterator api to get first the GPU_BUDDY block * and the number of bytes from it. Access the following - * DRM_BUDDY block(s) if more buffer needs to exported + * GPU_BUDDY block(s) if more buffer needs to exported */ amdgpu_res_first(res, offset, length, &cursor); for_each_sgtable_sg((*sgt), sg, i) { @@ -792,10 +794,10 @@ uint64_t amdgpu_vram_mgr_vis_usage(struct amdgpu_vram_mgr *mgr) void amdgpu_vram_mgr_clear_reset_blocks(struct amdgpu_device *adev) { struct amdgpu_vram_mgr *mgr = &adev->mman.vram_mgr; - struct drm_buddy *mm = &mgr->mm; + struct gpu_buddy *mm = &mgr->mm; mutex_lock(&mgr->lock); - drm_buddy_reset_clear(mm, false); + gpu_buddy_reset_clear(mm, false); mutex_unlock(&mgr->lock); } @@ -815,7 +817,7 @@ static bool amdgpu_vram_mgr_intersects(struct ttm_resource_manager *man, size_t size) { struct amdgpu_vram_mgr_resource *mgr = to_amdgpu_vram_mgr_resource(res); - struct drm_buddy_block *block; + struct gpu_buddy_block *block; /* Check each drm buddy block individually */ list_for_each_entry(block, &mgr->blocks, link) { @@ -848,7 +850,7 @@ static bool amdgpu_vram_mgr_compatible(struct ttm_resource_manager *man, size_t size) { struct amdgpu_vram_mgr_resource *mgr = to_amdgpu_vram_mgr_resource(res); - struct drm_buddy_block *block; + struct gpu_buddy_block *block; /* Check each drm buddy block individually */ list_for_each_entry(block, &mgr->blocks, link) { @@ -877,7 +879,7 @@ static void amdgpu_vram_mgr_debug(struct ttm_resource_manager *man, struct drm_printer *printer) { struct amdgpu_vram_mgr *mgr = to_vram_mgr(man); - struct drm_buddy *mm = &mgr->mm; + struct gpu_buddy *mm = &mgr->mm; struct amdgpu_vram_reservation *rsv; drm_printf(printer, " vis usage:%llu\n", @@ -930,7 +932,7 @@ int amdgpu_vram_mgr_init(struct amdgpu_device *adev) mgr->default_page_size = PAGE_SIZE; man->func = &amdgpu_vram_mgr_func; - err = drm_buddy_init(&mgr->mm, man->size, PAGE_SIZE); + err = gpu_buddy_init(&mgr->mm, man->size, PAGE_SIZE); if (err) return err; @@ -965,11 +967,11 @@ void amdgpu_vram_mgr_fini(struct amdgpu_device *adev) kfree(rsv); list_for_each_entry_safe(rsv, temp, &mgr->reserved_pages, blocks) { - drm_buddy_free_list(&mgr->mm, &rsv->allocated, 0); + gpu_buddy_free_list(&mgr->mm, &rsv->allocated, 0); kfree(rsv); } if (!adev->gmc.is_app_apu) - drm_buddy_fini(&mgr->mm); + gpu_buddy_fini(&mgr->mm); mutex_unlock(&mgr->lock); ttm_resource_manager_cleanup(man); diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.h index 5f5fd9a911c2..429a21a2e9b2 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.h +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.h @@ -24,11 +24,11 @@ #ifndef __AMDGPU_VRAM_MGR_H__ #define __AMDGPU_VRAM_MGR_H__ -#include <drm/drm_buddy.h> +#include <linux/gpu_buddy.h> struct amdgpu_vram_mgr { struct ttm_resource_manager manager; - struct drm_buddy mm; + struct gpu_buddy mm; /* protects access to buffer objects */ struct mutex lock; struct list_head reservations_pending; @@ -57,19 +57,19 @@ struct amdgpu_vram_mgr_resource { struct amdgpu_vres_task task; }; -static inline u64 amdgpu_vram_mgr_block_start(struct drm_buddy_block *block) +static inline u64 amdgpu_vram_mgr_block_start(struct gpu_buddy_block *block) { - return drm_buddy_block_offset(block); + return gpu_buddy_block_offset(block); } -static inline u64 amdgpu_vram_mgr_block_size(struct drm_buddy_block *block) +static inline u64 amdgpu_vram_mgr_block_size(struct gpu_buddy_block *block) { - return (u64)PAGE_SIZE << drm_buddy_block_order(block); + return (u64)PAGE_SIZE << gpu_buddy_block_order(block); } -static inline bool amdgpu_vram_mgr_is_cleared(struct drm_buddy_block *block) +static inline bool amdgpu_vram_mgr_is_cleared(struct gpu_buddy_block *block) { - return drm_buddy_block_is_clear(block); + return gpu_buddy_block_is_clear(block); } static inline struct amdgpu_vram_mgr_resource * @@ -82,8 +82,8 @@ static inline void amdgpu_vram_mgr_set_cleared(struct ttm_resource *res) { struct amdgpu_vram_mgr_resource *ares = to_amdgpu_vram_mgr_resource(res); - WARN_ON(ares->flags & DRM_BUDDY_CLEARED); - ares->flags |= DRM_BUDDY_CLEARED; + WARN_ON(ares->flags & GPU_BUDDY_CLEARED); + ares->flags |= GPU_BUDDY_CLEARED; } int amdgpu_vram_mgr_query_address_block_info(struct amdgpu_vram_mgr *mgr, diff --git a/drivers/gpu/drm/drm_buddy.c b/drivers/gpu/drm/drm_buddy.c index 2f279b46bd2c..056514801caf 100644 --- a/drivers/gpu/drm/drm_buddy.c +++ b/drivers/gpu/drm/drm_buddy.c @@ -3,1262 +3,25 @@ * Copyright © 2021 Intel Corporation */ -#include <kunit/test-bug.h> - #include <linux/export.h> -#include <linux/kmemleak.h> #include <linux/module.h> #include <linux/sizes.h> #include <drm/drm_buddy.h> #include <drm/drm_print.h> -enum drm_buddy_free_tree { - DRM_BUDDY_CLEAR_TREE = 0, - DRM_BUDDY_DIRTY_TREE, - DRM_BUDDY_MAX_FREE_TREES, -}; - -static struct kmem_cache *slab_blocks; - -#define for_each_free_tree(tree) \ - for ((tree) = 0; (tree) < DRM_BUDDY_MAX_FREE_TREES; (tree)++) - -static struct drm_buddy_block *drm_block_alloc(struct drm_buddy *mm, - struct drm_buddy_block *parent, - unsigned int order, - u64 offset) -{ - struct drm_buddy_block *block; - - BUG_ON(order > DRM_BUDDY_MAX_ORDER); - - block = kmem_cache_zalloc(slab_blocks, GFP_KERNEL); - if (!block) - return NULL; - - block->header = offset; - block->header |= order; - block->parent = parent; - - RB_CLEAR_NODE(&block->rb); - - BUG_ON(block->header & DRM_BUDDY_HEADER_UNUSED); - return block; -} - -static void drm_block_free(struct drm_buddy *mm, - struct drm_buddy_block *block) -{ - kmem_cache_free(slab_blocks, block); -} - -static enum drm_buddy_free_tree -get_block_tree(struct drm_buddy_block *block) -{ - return drm_buddy_block_is_clear(block) ? - DRM_BUDDY_CLEAR_TREE : DRM_BUDDY_DIRTY_TREE; -} - -static struct drm_buddy_block * -rbtree_get_free_block(const struct rb_node *node) -{ - return node ? rb_entry(node, struct drm_buddy_block, rb) : NULL; -} - -static struct drm_buddy_block * -rbtree_last_free_block(struct rb_root *root) -{ - return rbtree_get_free_block(rb_last(root)); -} - -static bool rbtree_is_empty(struct rb_root *root) -{ - return RB_EMPTY_ROOT(root); -} - -static bool drm_buddy_block_offset_less(const struct drm_buddy_block *block, - const struct drm_buddy_block *node) -{ - return drm_buddy_block_offset(block) < drm_buddy_block_offset(node); -} - -static bool rbtree_block_offset_less(struct rb_node *block, - const struct rb_node *node) -{ - return drm_buddy_block_offset_less(rbtree_get_free_block(block), - rbtree_get_free_block(node)); -} - -static void rbtree_insert(struct drm_buddy *mm, - struct drm_buddy_block *block, - enum drm_buddy_free_tree tree) -{ - rb_add(&block->rb, - &mm->free_trees[tree][drm_buddy_block_order(block)], - rbtree_block_offset_less); -} - -static void rbtree_remove(struct drm_buddy *mm, - struct drm_buddy_block *block) -{ - unsigned int order = drm_buddy_block_order(block); - enum drm_buddy_free_tree tree; - struct rb_root *root; - - tree = get_block_tree(block); - root = &mm->free_trees[tree][order]; - - rb_erase(&block->rb, root); - RB_CLEAR_NODE(&block->rb); -} - -static void clear_reset(struct drm_buddy_block *block) -{ - block->header &= ~DRM_BUDDY_HEADER_CLEAR; -} - -static void mark_cleared(struct drm_buddy_block *block) -{ - block->header |= DRM_BUDDY_HEADER_CLEAR; -} - -static void mark_allocated(struct drm_buddy *mm, - struct drm_buddy_block *block) -{ - block->header &= ~DRM_BUDDY_HEADER_STATE; - block->header |= DRM_BUDDY_ALLOCATED; - - rbtree_remove(mm, block); -} - -static void mark_free(struct drm_buddy *mm, - struct drm_buddy_block *block) -{ - enum drm_buddy_free_tree tree; - - block->header &= ~DRM_BUDDY_HEADER_STATE; - block->header |= DRM_BUDDY_FREE; - - tree = get_block_tree(block); - rbtree_insert(mm, block, tree); -} - -static void mark_split(struct drm_buddy *mm, - struct drm_buddy_block *block) -{ - block->header &= ~DRM_BUDDY_HEADER_STATE; - block->header |= DRM_BUDDY_SPLIT; - - rbtree_remove(mm, block); -} - -static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2) -{ - return s1 <= e2 && e1 >= s2; -} - -static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2) -{ - return s1 <= s2 && e1 >= e2; -} - -static struct drm_buddy_block * -__get_buddy(struct drm_buddy_block *block) -{ - struct drm_buddy_block *parent; - - parent = block->parent; - if (!parent) - return NULL; - - if (parent->left == block) - return parent->right; - - return parent->left; -} - -static unsigned int __drm_buddy_free(struct drm_buddy *mm, - struct drm_buddy_block *block, - bool force_merge) -{ - struct drm_buddy_block *parent; - unsigned int order; - - while ((parent = block->parent)) { - struct drm_buddy_block *buddy; - - buddy = __get_buddy(block); - - if (!drm_buddy_block_is_free(buddy)) - break; - - if (!force_merge) { - /* - * Check the block and its buddy clear state and exit - * the loop if they both have the dissimilar state. - */ - if (drm_buddy_block_is_clear(block) != - drm_buddy_block_is_clear(buddy)) - break; - - if (drm_buddy_block_is_clear(block)) - mark_cleared(parent); - } - - rbtree_remove(mm, buddy); - if (force_merge && drm_buddy_block_is_clear(buddy)) - mm->clear_avail -= drm_buddy_block_size(mm, buddy); - - drm_block_free(mm, block); - drm_block_free(mm, buddy); - - block = parent; - } - - order = drm_buddy_block_order(block); - mark_free(mm, block); - - return order; -} - -static int __force_merge(struct drm_buddy *mm, - u64 start, - u64 end, - unsigned int min_order) -{ - unsigned int tree, order; - int i; - - if (!min_order) - return -ENOMEM; - - if (min_order > mm->max_order) - return -EINVAL; - - for_each_free_tree(tree) { - for (i = min_order - 1; i >= 0; i--) { - struct rb_node *iter = rb_last(&mm->free_trees[tree][i]); - - while (iter) { - struct drm_buddy_block *block, *buddy; - u64 block_start, block_end; - - block = rbtree_get_free_block(iter); - iter = rb_prev(iter); - - if (!block || !block->parent) - continue; - - block_start = drm_buddy_block_offset(block); - block_end = block_start + drm_buddy_block_size(mm, block) - 1; - - if (!contains(start, end, block_start, block_end)) - continue; - - buddy = __get_buddy(block); - if (!drm_buddy_block_is_free(buddy)) - continue; - - WARN_ON(drm_buddy_block_is_clear(block) == - drm_buddy_block_is_clear(buddy)); - - /* - * Advance to the next node when the current node is the buddy, - * as freeing the block will also remove its buddy from the tree. - */ - if (iter == &buddy->rb) - iter = rb_prev(iter); - - rbtree_remove(mm, block); - if (drm_buddy_block_is_clear(block)) - mm->clear_avail -= drm_buddy_block_size(mm, block); - - order = __drm_buddy_free(mm, block, true); - if (order >= min_order) - return 0; - } - } - } - - return -ENOMEM; -} - -/** - * drm_buddy_init - init memory manager - * - * @mm: DRM buddy manager to initialize - * @size: size in bytes to manage - * @chunk_size: minimum page size in bytes for our allocations - * - * Initializes the memory manager and its resources. - * - * Returns: - * 0 on success, error code on failure. - */ -int drm_buddy_init(struct drm_buddy *mm, u64 size, u64 chunk_size) -{ - unsigned int i, j, root_count = 0; - u64 offset = 0; - - if (size < chunk_size) - return -EINVAL; - - if (chunk_size < SZ_4K) - return -EINVAL; - - if (!is_power_of_2(chunk_size)) - return -EINVAL; - - size = round_down(size, chunk_size); - - mm->size = size; - mm->avail = size; - mm->clear_avail = 0; - mm->chunk_size = chunk_size; - mm->max_order = ilog2(size) - ilog2(chunk_size); - - BUG_ON(mm->max_order > DRM_BUDDY_MAX_ORDER); - - mm->free_trees = kmalloc_array(DRM_BUDDY_MAX_FREE_TREES, - sizeof(*mm->free_trees), - GFP_KERNEL); - if (!mm->free_trees) - return -ENOMEM; - - for_each_free_tree(i) { - mm->free_trees[i] = kmalloc_array(mm->max_order + 1, - sizeof(struct rb_root), - GFP_KERNEL); - if (!mm->free_trees[i]) - goto out_free_tree; - - for (j = 0; j <= mm->max_order; ++j) - mm->free_trees[i][j] = RB_ROOT; - } - - mm->n_roots = hweight64(size); - - mm->roots = kmalloc_array(mm->n_roots, - sizeof(struct drm_buddy_block *), - GFP_KERNEL); - if (!mm->roots) - goto out_free_tree; - - /* - * Split into power-of-two blocks, in case we are given a size that is - * not itself a power-of-two. - */ - do { - struct drm_buddy_block *root; - unsigned int order; - u64 root_size; - - order = ilog2(size) - ilog2(chunk_size); - root_size = chunk_size << order; - - root = drm_block_alloc(mm, NULL, order, offset); - if (!root) - goto out_free_roots; - - mark_free(mm, root); - - BUG_ON(root_count > mm->max_order); - BUG_ON(drm_buddy_block_size(mm, root) < chunk_size); - - mm->roots[root_count] = root; - - offset += root_size; - size -= root_size; - root_count++; - } while (size); - - return 0; - -out_free_roots: - while (root_count--) - drm_block_free(mm, mm->roots[root_count]); - kfree(mm->roots); -out_free_tree: - while (i--) - kfree(mm->free_trees[i]); - kfree(mm->free_trees); - return -ENOMEM; -} -EXPORT_SYMBOL(drm_buddy_init); - -/** - * drm_buddy_fini - tear down the memory manager - * - * @mm: DRM buddy manager to free - * - * Cleanup memory manager resources and the freetree - */ -void drm_buddy_fini(struct drm_buddy *mm) -{ - u64 root_size, size, start; - unsigned int order; - int i; - - size = mm->size; - - for (i = 0; i < mm->n_roots; ++i) { - order = ilog2(size) - ilog2(mm->chunk_size); - start = drm_buddy_block_offset(mm->roots[i]); - __force_merge(mm, start, start + size, order); - - if (WARN_ON(!drm_buddy_block_is_free(mm->roots[i]))) - kunit_fail_current_test("buddy_fini() root"); - - drm_block_free(mm, mm->roots[i]); - - root_size = mm->chunk_size << order; - size -= root_size; - } - - WARN_ON(mm->avail != mm->size); - - for_each_free_tree(i) - kfree(mm->free_trees[i]); - kfree(mm->roots); -} -EXPORT_SYMBOL(drm_buddy_fini); - -static int split_block(struct drm_buddy *mm, - struct drm_buddy_block *block) -{ - unsigned int block_order = drm_buddy_block_order(block) - 1; - u64 offset = drm_buddy_block_offset(block); - - BUG_ON(!drm_buddy_block_is_free(block)); - BUG_ON(!drm_buddy_block_order(block)); - - block->left = drm_block_alloc(mm, block, block_order, offset); - if (!block->left) - return -ENOMEM; - - block->right = drm_block_alloc(mm, block, block_order, - offset + (mm->chunk_size << block_order)); - if (!block->right) { - drm_block_free(mm, block->left); - return -ENOMEM; - } - - mark_split(mm, block); - - if (drm_buddy_block_is_clear(block)) { - mark_cleared(block->left); - mark_cleared(block->right); - clear_reset(block); - } - - mark_free(mm, block->left); - mark_free(mm, block->right); - - return 0; -} - -/** - * drm_get_buddy - get buddy address - * - * @block: DRM buddy block - * - * Returns the corresponding buddy block for @block, or NULL - * if this is a root block and can't be merged further. - * Requires some kind of locking to protect against - * any concurrent allocate and free operations. - */ -struct drm_buddy_block * -drm_get_buddy(struct drm_buddy_block *block) -{ - return __get_buddy(block); -} -EXPORT_SYMBOL(drm_get_buddy); - -/** - * drm_buddy_reset_clear - reset blocks clear state - * - * @mm: DRM buddy manager - * @is_clear: blocks clear state - * - * Reset the clear state based on @is_clear value for each block - * in the freetree. - */ -void drm_buddy_reset_clear(struct drm_buddy *mm, bool is_clear) -{ - enum drm_buddy_free_tree src_tree, dst_tree; - u64 root_size, size, start; - unsigned int order; - int i; - - size = mm->size; - for (i = 0; i < mm->n_roots; ++i) { - order = ilog2(size) - ilog2(mm->chunk_size); - start = drm_buddy_block_offset(mm->roots[i]); - __force_merge(mm, start, start + size, order); - - root_size = mm->chunk_size << order; - size -= root_size; - } - - src_tree = is_clear ? DRM_BUDDY_DIRTY_TREE : DRM_BUDDY_CLEAR_TREE; - dst_tree = is_clear ? DRM_BUDDY_CLEAR_TREE : DRM_BUDDY_DIRTY_TREE; - - for (i = 0; i <= mm->max_order; ++i) { - struct rb_root *root = &mm->free_trees[src_tree][i]; - struct drm_buddy_block *block, *tmp; - - rbtree_postorder_for_each_entry_safe(block, tmp, root, rb) { - rbtree_remove(mm, block); - if (is_clear) { - mark_cleared(block); - mm->clear_avail += drm_buddy_block_size(mm, block); - } else { - clear_reset(block); - mm->clear_avail -= drm_buddy_block_size(mm, block); - } - - rbtree_insert(mm, block, dst_tree); - } - } -} -EXPORT_SYMBOL(drm_buddy_reset_clear); - -/** - * drm_buddy_free_block - free a block - * - * @mm: DRM buddy manager - * @block: block to be freed - */ -void drm_buddy_free_block(struct drm_buddy *mm, - struct drm_buddy_block *block) -{ - BUG_ON(!drm_buddy_block_is_allocated(block)); - mm->avail += drm_buddy_block_size(mm, block); - if (drm_buddy_block_is_clear(block)) - mm->clear_avail += drm_buddy_block_size(mm, block); - - __drm_buddy_free(mm, block, false); -} -EXPORT_SYMBOL(drm_buddy_free_block); - -static void __drm_buddy_free_list(struct drm_buddy *mm, - struct list_head *objects, - bool mark_clear, - bool mark_dirty) -{ - struct drm_buddy_block *block, *on; - - WARN_ON(mark_dirty && mark_clear); - - list_for_each_entry_safe(block, on, objects, link) { - if (mark_clear) - mark_cleared(block); - else if (mark_dirty) - clear_reset(block); - drm_buddy_free_block(mm, block); - cond_resched(); - } - INIT_LIST_HEAD(objects); -} - -static void drm_buddy_free_list_internal(struct drm_buddy *mm, - struct list_head *objects) -{ - /* - * Don't touch the clear/dirty bit, since allocation is still internal - * at this point. For example we might have just failed part of the - * allocation. - */ - __drm_buddy_free_list(mm, objects, false, false); -} - -/** - * drm_buddy_free_list - free blocks - * - * @mm: DRM buddy manager - * @objects: input list head to free blocks - * @flags: optional flags like DRM_BUDDY_CLEARED - */ -void drm_buddy_free_list(struct drm_buddy *mm, - struct list_head *objects, - unsigned int flags) -{ - bool mark_clear = flags & DRM_BUDDY_CLEARED; - - __drm_buddy_free_list(mm, objects, mark_clear, !mark_clear); -} -EXPORT_SYMBOL(drm_buddy_free_list); - -static bool block_incompatible(struct drm_buddy_block *block, unsigned int flags) -{ - bool needs_clear = flags & DRM_BUDDY_CLEAR_ALLOCATION; - - return needs_clear != drm_buddy_block_is_clear(block); -} - -static struct drm_buddy_block * -__alloc_range_bias(struct drm_buddy *mm, - u64 start, u64 end, - unsigned int order, - unsigned long flags, - bool fallback) -{ - u64 req_size = mm->chunk_size << order; - struct drm_buddy_block *block; - struct drm_buddy_block *buddy; - LIST_HEAD(dfs); - int err; - int i; - - end = end - 1; - - for (i = 0; i < mm->n_roots; ++i) - list_add_tail(&mm->roots[i]->tmp_link, &dfs); - - do { - u64 block_start; - u64 block_end; - - block = list_first_entry_or_null(&dfs, - struct drm_buddy_block, - tmp_link); - if (!block) - break; - - list_del(&block->tmp_link); - - if (drm_buddy_block_order(block) < order) - continue; - - block_start = drm_buddy_block_offset(block); - block_end = block_start + drm_buddy_block_size(mm, block) - 1; - - if (!overlaps(start, end, block_start, block_end)) - continue; - - if (drm_buddy_block_is_allocated(block)) - continue; - - if (block_start < start || block_end > end) { - u64 adjusted_start = max(block_start, start); - u64 adjusted_end = min(block_end, end); - - if (round_down(adjusted_end + 1, req_size) <= - round_up(adjusted_start, req_size)) - continue; - } - - if (!fallback && block_incompatible(block, flags)) - continue; - - if (contains(start, end, block_start, block_end) && - order == drm_buddy_block_order(block)) { - /* - * Find the free block within the range. - */ - if (drm_buddy_block_is_free(block)) - return block; - - continue; - } - - if (!drm_buddy_block_is_split(block)) { - err = split_block(mm, block); - if (unlikely(err)) - goto err_undo; - } - - list_add(&block->right->tmp_link, &dfs); - list_add(&block->left->tmp_link, &dfs); - } while (1); - - return ERR_PTR(-ENOSPC); - -err_undo: - /* - * We really don't want to leave around a bunch of split blocks, since - * bigger is better, so make sure we merge everything back before we - * free the allocated blocks. - */ - buddy = __get_buddy(block); - if (buddy && - (drm_buddy_block_is_free(block) && - drm_buddy_block_is_free(buddy))) - __drm_buddy_free(mm, block, false); - return ERR_PTR(err); -} - -static struct drm_buddy_block * -__drm_buddy_alloc_range_bias(struct drm_buddy *mm, - u64 start, u64 end, - unsigned int order, - unsigned long flags) -{ - struct drm_buddy_block *block; - bool fallback = false; - - block = __alloc_range_bias(mm, start, end, order, - flags, fallback); - if (IS_ERR(block)) - return __alloc_range_bias(mm, start, end, order, - flags, !fallback); - - return block; -} - -static struct drm_buddy_block * -get_maxblock(struct drm_buddy *mm, - unsigned int order, - enum drm_buddy_free_tree tree) -{ - struct drm_buddy_block *max_block = NULL, *block = NULL; - struct rb_root *root; - unsigned int i; - - for (i = order; i <= mm->max_order; ++i) { - root = &mm->free_trees[tree][i]; - block = rbtree_last_free_block(root); - if (!block) - continue; - - if (!max_block) { - max_block = block; - continue; - } - - if (drm_buddy_block_offset(block) > - drm_buddy_block_offset(max_block)) { - max_block = block; - } - } - - return max_block; -} - -static struct drm_buddy_block * -alloc_from_freetree(struct drm_buddy *mm, - unsigned int order, - unsigned long flags) -{ - struct drm_buddy_block *block = NULL; - struct rb_root *root; - enum drm_buddy_free_tree tree; - unsigned int tmp; - int err; - - tree = (flags & DRM_BUDDY_CLEAR_ALLOCATION) ? - DRM_BUDDY_CLEAR_TREE : DRM_BUDDY_DIRTY_TREE; - - if (flags & DRM_BUDDY_TOPDOWN_ALLOCATION) { - block = get_maxblock(mm, order, tree); - if (block) - /* Store the obtained block order */ - tmp = drm_buddy_block_order(block); - } else { - for (tmp = order; tmp <= mm->max_order; ++tmp) { - /* Get RB tree root for this order and tree */ - root = &mm->free_trees[tree][tmp]; - block = rbtree_last_free_block(root); - if (block) - break; - } - } - - if (!block) { - /* Try allocating from the other tree */ - tree = (tree == DRM_BUDDY_CLEAR_TREE) ? - DRM_BUDDY_DIRTY_TREE : DRM_BUDDY_CLEAR_TREE; - - for (tmp = order; tmp <= mm->max_order; ++tmp) { - root = &mm->free_trees[tree][tmp]; - block = rbtree_last_free_block(root); - if (block) - break; - } - - if (!block) - return ERR_PTR(-ENOSPC); - } - - BUG_ON(!drm_buddy_block_is_free(block)); - - while (tmp != order) { - err = split_block(mm, block); - if (unlikely(err)) - goto err_undo; - - block = block->right; - tmp--; - } - return block; - -err_undo: - if (tmp != order) - __drm_buddy_free(mm, block, false); - return ERR_PTR(err); -} - -static int __alloc_range(struct drm_buddy *mm, - struct list_head *dfs, - u64 start, u64 size, - struct list_head *blocks, - u64 *total_allocated_on_err) -{ - struct drm_buddy_block *block; - struct drm_buddy_block *buddy; - u64 total_allocated = 0; - LIST_HEAD(allocated); - u64 end; - int err; - - end = start + size - 1; - - do { - u64 block_start; - u64 block_end; - - block = list_first_entry_or_null(dfs, - struct drm_buddy_block, - tmp_link); - if (!block) - break; - - list_del(&block->tmp_link); - - block_start = drm_buddy_block_offset(block); - block_end = block_start + drm_buddy_block_size(mm, block) - 1; - - if (!overlaps(start, end, block_start, block_end)) - continue; - - if (drm_buddy_block_is_allocated(block)) { - err = -ENOSPC; - goto err_free; - } - - if (contains(start, end, block_start, block_end)) { - if (drm_buddy_block_is_free(block)) { - mark_allocated(mm, block); - total_allocated += drm_buddy_block_size(mm, block); - mm->avail -= drm_buddy_block_size(mm, block); - if (drm_buddy_block_is_clear(block)) - mm->clear_avail -= drm_buddy_block_size(mm, block); - list_add_tail(&block->link, &allocated); - continue; - } else if (!mm->clear_avail) { - err = -ENOSPC; - goto err_free; - } - } - - if (!drm_buddy_block_is_split(block)) { - err = split_block(mm, block); - if (unlikely(err)) - goto err_undo; - } - - list_add(&block->right->tmp_link, dfs); - list_add(&block->left->tmp_link, dfs); - } while (1); - - if (total_allocated < size) { - err = -ENOSPC; - goto err_free; - } - - list_splice_tail(&allocated, blocks); - - return 0; - -err_undo: - /* - * We really don't want to leave around a bunch of split blocks, since - * bigger is better, so make sure we merge everything back before we - * free the allocated blocks. - */ - buddy = __get_buddy(block); - if (buddy && - (drm_buddy_block_is_free(block) && - drm_buddy_block_is_free(buddy))) - __drm_buddy_free(mm, block, false); - -err_free: - if (err == -ENOSPC && total_allocated_on_err) { - list_splice_tail(&allocated, blocks); - *total_allocated_on_err = total_allocated; - } else { - drm_buddy_free_list_internal(mm, &allocated); - } - - return err; -} - -static int __drm_buddy_alloc_range(struct drm_buddy *mm, - u64 start, - u64 size, - u64 *total_allocated_on_err, - struct list_head *blocks) -{ - LIST_HEAD(dfs); - int i; - - for (i = 0; i < mm->n_roots; ++i) - list_add_tail(&mm->roots[i]->tmp_link, &dfs); - - return __alloc_range(mm, &dfs, start, size, - blocks, total_allocated_on_err); -} - -static int __alloc_contig_try_harder(struct drm_buddy *mm, - u64 size, - u64 min_block_size, - struct list_head *blocks) -{ - u64 rhs_offset, lhs_offset, lhs_size, filled; - struct drm_buddy_block *block; - unsigned int tree, order; - LIST_HEAD(blocks_lhs); - unsigned long pages; - u64 modify_size; - int err; - - modify_size = rounddown_pow_of_two(size); - pages = modify_size >> ilog2(mm->chunk_size); - order = fls(pages) - 1; - if (order == 0) - return -ENOSPC; - - for_each_free_tree(tree) { - struct rb_root *root; - struct rb_node *iter; - - root = &mm->free_trees[tree][order]; - if (rbtree_is_empty(root)) - continue; - - iter = rb_last(root); - while (iter) { - block = rbtree_get_free_block(iter); - - /* Allocate blocks traversing RHS */ - rhs_offset = drm_buddy_block_offset(block); - err = __drm_buddy_alloc_range(mm, rhs_offset, size, - &filled, blocks); - if (!err || err != -ENOSPC) - return err; - - lhs_size = max((size - filled), min_block_size); - if (!IS_ALIGNED(lhs_size, min_block_size)) - lhs_size = round_up(lhs_size, min_block_size); - - /* Allocate blocks traversing LHS */ - lhs_offset = drm_buddy_block_offset(block) - lhs_size; - err = __drm_buddy_alloc_range(mm, lhs_offset, lhs_size, - NULL, &blocks_lhs); - if (!err) { - list_splice(&blocks_lhs, blocks); - return 0; - } else if (err != -ENOSPC) { - drm_buddy_free_list_internal(mm, blocks); - return err; - } - /* Free blocks for the next iteration */ - drm_buddy_free_list_internal(mm, blocks); - - iter = rb_prev(iter); - } - } - - return -ENOSPC; -} - -/** - * drm_buddy_block_trim - free unused pages - * - * @mm: DRM buddy manager - * @start: start address to begin the trimming. - * @new_size: original size requested - * @blocks: Input and output list of allocated blocks. - * MUST contain single block as input to be trimmed. - * On success will contain the newly allocated blocks - * making up the @new_size. Blocks always appear in - * ascending order - * - * For contiguous allocation, we round up the size to the nearest - * power of two value, drivers consume *actual* size, so remaining - * portions are unused and can be optionally freed with this function - * - * Returns: - * 0 on success, error code on failure. - */ -int drm_buddy_block_trim(struct drm_buddy *mm, - u64 *start, - u64 new_size, - struct list_head *blocks) -{ - struct drm_buddy_block *parent; - struct drm_buddy_block *block; - u64 block_start, block_end; - LIST_HEAD(dfs); - u64 new_start; - int err; - - if (!list_is_singular(blocks)) - return -EINVAL; - - block = list_first_entry(blocks, - struct drm_buddy_block, - link); - - block_start = drm_buddy_block_offset(block); - block_end = block_start + drm_buddy_block_size(mm, block); - - if (WARN_ON(!drm_buddy_block_is_allocated(block))) - return -EINVAL; - - if (new_size > drm_buddy_block_size(mm, block)) - return -EINVAL; - - if (!new_size || !IS_ALIGNED(new_size, mm->chunk_size)) - return -EINVAL; - - if (new_size == drm_buddy_block_size(mm, block)) - return 0; - - new_start = block_start; - if (start) { - new_start = *start; - - if (new_start < block_start) - return -EINVAL; - - if (!IS_ALIGNED(new_start, mm->chunk_size)) - return -EINVAL; - - if (range_overflows(new_start, new_size, block_end)) - return -EINVAL; - } - - list_del(&block->link); - mark_free(mm, block); - mm->avail += drm_buddy_block_size(mm, block); - if (drm_buddy_block_is_clear(block)) - mm->clear_avail += drm_buddy_block_size(mm, block); - - /* Prevent recursively freeing this node */ - parent = block->parent; - block->parent = NULL; - - list_add(&block->tmp_link, &dfs); - err = __alloc_range(mm, &dfs, new_start, new_size, blocks, NULL); - if (err) { - mark_allocated(mm, block); - mm->avail -= drm_buddy_block_size(mm, block); - if (drm_buddy_block_is_clear(block)) - mm->clear_avail -= drm_buddy_block_size(mm, block); - list_add(&block->link, blocks); - } - - block->parent = parent; - return err; -} -EXPORT_SYMBOL(drm_buddy_block_trim); - -static struct drm_buddy_block * -__drm_buddy_alloc_blocks(struct drm_buddy *mm, - u64 start, u64 end, - unsigned int order, - unsigned long flags) -{ - if (flags & DRM_BUDDY_RANGE_ALLOCATION) - /* Allocate traversing within the range */ - return __drm_buddy_alloc_range_bias(mm, start, end, - order, flags); - else - /* Allocate from freetree */ - return alloc_from_freetree(mm, order, flags); -} - -/** - * drm_buddy_alloc_blocks - allocate power-of-two blocks - * - * @mm: DRM buddy manager to allocate from - * @start: start of the allowed range for this block - * @end: end of the allowed range for this block - * @size: size of the allocation in bytes - * @min_block_size: alignment of the allocation - * @blocks: output list head to add allocated blocks - * @flags: DRM_BUDDY_*_ALLOCATION flags - * - * alloc_range_bias() called on range limitations, which traverses - * the tree and returns the desired block. - * - * alloc_from_freetree() called when *no* range restrictions - * are enforced, which picks the block from the freetree. - * - * Returns: - * 0 on success, error code on failure. - */ -int drm_buddy_alloc_blocks(struct drm_buddy *mm, - u64 start, u64 end, u64 size, - u64 min_block_size, - struct list_head *blocks, - unsigned long flags) -{ - struct drm_buddy_block *block = NULL; - u64 original_size, original_min_size; - unsigned int min_order, order; - LIST_HEAD(allocated); - unsigned long pages; - int err; - - if (size < mm->chunk_size) - return -EINVAL; - - if (min_block_size < mm->chunk_size) - return -EINVAL; - - if (!is_power_of_2(min_block_size)) - return -EINVAL; - - if (!IS_ALIGNED(start | end | size, mm->chunk_size)) - return -EINVAL; - - if (end > mm->size) - return -EINVAL; - - if (range_overflows(start, size, mm->size)) - return -EINVAL; - - /* Actual range allocation */ - if (start + size == end) { - if (!IS_ALIGNED(start | end, min_block_size)) - return -EINVAL; - - return __drm_buddy_alloc_range(mm, start, size, NULL, blocks); - } - - original_size = size; - original_min_size = min_block_size; - - /* Roundup the size to power of 2 */ - if (flags & DRM_BUDDY_CONTIGUOUS_ALLOCATION) { - size = roundup_pow_of_two(size); - min_block_size = size; - /* Align size value to min_block_size */ - } else if (!IS_ALIGNED(size, min_block_size)) { - size = round_up(size, min_block_size); - } - - pages = size >> ilog2(mm->chunk_size); - order = fls(pages) - 1; - min_order = ilog2(min_block_size) - ilog2(mm->chunk_size); - - do { - order = min(order, (unsigned int)fls(pages) - 1); - BUG_ON(order > mm->max_order); - BUG_ON(order < min_order); - - do { - block = __drm_buddy_alloc_blocks(mm, start, - end, - order, - flags); - if (!IS_ERR(block)) - break; - - if (order-- == min_order) { - /* Try allocation through force merge method */ - if (mm->clear_avail && - !__force_merge(mm, start, end, min_order)) { - block = __drm_buddy_alloc_blocks(mm, start, - end, - min_order, - flags); - if (!IS_ERR(block)) { - order = min_order; - break; - } - } - - /* - * Try contiguous block allocation through - * try harder method. - */ - if (flags & DRM_BUDDY_CONTIGUOUS_ALLOCATION && - !(flags & DRM_BUDDY_RANGE_ALLOCATION)) - return __alloc_contig_try_harder(mm, - original_size, - original_min_size, - blocks); - err = -ENOSPC; - goto err_free; - } - } while (1); - - mark_allocated(mm, block); - mm->avail -= drm_buddy_block_size(mm, block); - if (drm_buddy_block_is_clear(block)) - mm->clear_avail -= drm_buddy_block_size(mm, block); - kmemleak_update_trace(block); - list_add_tail(&block->link, &allocated); - - pages -= BIT(order); - - if (!pages) - break; - } while (1); - - /* Trim the allocated block to the required size */ - if (!(flags & DRM_BUDDY_TRIM_DISABLE) && - original_size != size) { - struct list_head *trim_list; - LIST_HEAD(temp); - u64 trim_size; - - trim_list = &allocated; - trim_size = original_size; - - if (!list_is_singular(&allocated)) { - block = list_last_entry(&allocated, typeof(*block), link); - list_move(&block->link, &temp); - trim_list = &temp; - trim_size = drm_buddy_block_size(mm, block) - - (size - original_size); - } - - drm_buddy_block_trim(mm, - NULL, - trim_size, - trim_list); - - if (!list_empty(&temp)) - list_splice_tail(trim_list, &allocated); - } - - list_splice_tail(&allocated, blocks); - return 0; - -err_free: - drm_buddy_free_list_internal(mm, &allocated); - return err; -} -EXPORT_SYMBOL(drm_buddy_alloc_blocks); - /** * drm_buddy_block_print - print block information * - * @mm: DRM buddy manager - * @block: DRM buddy block + * @mm: GPU buddy manager + * @block: GPU buddy block * @p: DRM printer to use */ -void drm_buddy_block_print(struct drm_buddy *mm, - struct drm_buddy_block *block, +void drm_buddy_block_print(struct gpu_buddy *mm, struct gpu_buddy_block *block, struct drm_printer *p) { - u64 start = drm_buddy_block_offset(block); - u64 size = drm_buddy_block_size(mm, block); + u64 start = gpu_buddy_block_offset(block); + u64 size = gpu_buddy_block_size(mm, block); drm_printf(p, "%#018llx-%#018llx: %llu\n", start, start + size, size); } @@ -1267,27 +30,32 @@ EXPORT_SYMBOL(drm_buddy_block_print); /** * drm_buddy_print - print allocator state * - * @mm: DRM buddy manager + * @mm: GPU buddy manager * @p: DRM printer to use */ -void drm_buddy_print(struct drm_buddy *mm, struct drm_printer *p) +void drm_buddy_print(struct gpu_buddy *mm, struct drm_printer *p) { int order; - drm_printf(p, "chunk_size: %lluKiB, total: %lluMiB, free: %lluMiB, clear_free: %lluMiB\n", - mm->chunk_size >> 10, mm->size >> 20, mm->avail >> 20, mm->clear_avail >> 20); + drm_printf( + p, + "chunk_size: %lluKiB, total: %lluMiB, free: %lluMiB, clear_free: %lluMiB\n", + mm->chunk_size >> 10, mm->size >> 20, mm->avail >> 20, + mm->clear_avail >> 20); for (order = mm->max_order; order >= 0; order--) { - struct drm_buddy_block *block, *tmp; + struct gpu_buddy_block *block, *tmp; struct rb_root *root; u64 count = 0, free; unsigned int tree; - for_each_free_tree(tree) { + for_each_free_tree(tree) + { root = &mm->free_trees[tree][order]; - rbtree_postorder_for_each_entry_safe(block, tmp, root, rb) { - BUG_ON(!drm_buddy_block_is_free(block)); + rbtree_postorder_for_each_entry_safe(block, tmp, root, + rb) { + BUG_ON(!gpu_buddy_block_is_free(block)); count++; } } @@ -1305,22 +73,5 @@ void drm_buddy_print(struct drm_buddy *mm, struct drm_printer *p) } EXPORT_SYMBOL(drm_buddy_print); -static void drm_buddy_module_exit(void) -{ - kmem_cache_destroy(slab_blocks); -} - -static int __init drm_buddy_module_init(void) -{ - slab_blocks = KMEM_CACHE(drm_buddy_block, 0); - if (!slab_blocks) - return -ENOMEM; - - return 0; -} - -module_init(drm_buddy_module_init); -module_exit(drm_buddy_module_exit); - -MODULE_DESCRIPTION("DRM Buddy Allocator"); +MODULE_DESCRIPTION("DRM-specific GPU Buddy Allocator Print Helpers"); MODULE_LICENSE("Dual MIT/GPL"); diff --git a/drivers/gpu/drm/i915/Kconfig b/drivers/gpu/drm/i915/Kconfig index 5e939004b646..859aeca87c19 100644 --- a/drivers/gpu/drm/i915/Kconfig +++ b/drivers/gpu/drm/i915/Kconfig @@ -38,6 +38,7 @@ config DRM_I915 select CEC_CORE if CEC_NOTIFIER select VMAP_PFN select DRM_TTM + select GPU_BUDDY select DRM_BUDDY select AUXILIARY_BUS help diff --git a/drivers/gpu/drm/i915/i915_scatterlist.c b/drivers/gpu/drm/i915/i915_scatterlist.c index 4d830740946d..6a34dae13769 100644 --- a/drivers/gpu/drm/i915/i915_scatterlist.c +++ b/drivers/gpu/drm/i915/i915_scatterlist.c @@ -7,7 +7,7 @@ #include "i915_scatterlist.h" #include "i915_ttm_buddy_manager.h" -#include <drm/drm_buddy.h> +#include <linux/gpu_buddy.h> #include <drm/drm_mm.h> #include <linux/slab.h> @@ -167,9 +167,9 @@ struct i915_refct_sgt *i915_rsgt_from_buddy_resource(struct ttm_resource *res, struct i915_ttm_buddy_resource *bman_res = to_ttm_buddy_resource(res); const u64 size = res->size; const u32 max_segment = round_down(UINT_MAX, page_alignment); - struct drm_buddy *mm = bman_res->mm; + struct gpu_buddy *mm = bman_res->mm; struct list_head *blocks = &bman_res->blocks; - struct drm_buddy_block *block; + struct gpu_buddy_block *block; struct i915_refct_sgt *rsgt; struct scatterlist *sg; struct sg_table *st; @@ -202,8 +202,8 @@ struct i915_refct_sgt *i915_rsgt_from_buddy_resource(struct ttm_resource *res, list_for_each_entry(block, blocks, link) { u64 block_size, offset; - block_size = min_t(u64, size, drm_buddy_block_size(mm, block)); - offset = drm_buddy_block_offset(block); + block_size = min_t(u64, size, gpu_buddy_block_size(mm, block)); + offset = gpu_buddy_block_offset(block); while (block_size) { u64 len; diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c index d5c6e6605086..f43d7f2771ad 100644 --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c @@ -4,6 +4,7 @@ */ #include <linux/slab.h> +#include <linux/gpu_buddy.h> #include <drm/drm_buddy.h> #include <drm/drm_print.h> @@ -16,7 +17,7 @@ struct i915_ttm_buddy_manager { struct ttm_resource_manager manager; - struct drm_buddy mm; + struct gpu_buddy mm; struct list_head reserved; struct mutex lock; unsigned long visible_size; @@ -38,7 +39,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man, { struct i915_ttm_buddy_manager *bman = to_buddy_manager(man); struct i915_ttm_buddy_resource *bman_res; - struct drm_buddy *mm = &bman->mm; + struct gpu_buddy *mm = &bman->mm; unsigned long n_pages, lpfn; u64 min_page_size; u64 size; @@ -57,13 +58,13 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man, bman_res->mm = mm; if (place->flags & TTM_PL_FLAG_TOPDOWN) - bman_res->flags |= DRM_BUDDY_TOPDOWN_ALLOCATION; + bman_res->flags |= GPU_BUDDY_TOPDOWN_ALLOCATION; if (place->flags & TTM_PL_FLAG_CONTIGUOUS) - bman_res->flags |= DRM_BUDDY_CONTIGUOUS_ALLOCATION; + bman_res->flags |= GPU_BUDDY_CONTIGUOUS_ALLOCATION; if (place->fpfn || lpfn != man->size) - bman_res->flags |= DRM_BUDDY_RANGE_ALLOCATION; + bman_res->flags |= GPU_BUDDY_RANGE_ALLOCATION; GEM_BUG_ON(!bman_res->base.size); size = bman_res->base.size; @@ -89,7 +90,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man, goto err_free_res; } - err = drm_buddy_alloc_blocks(mm, (u64)place->fpfn << PAGE_SHIFT, + err = gpu_buddy_alloc_blocks(mm, (u64)place->fpfn << PAGE_SHIFT, (u64)lpfn << PAGE_SHIFT, (u64)n_pages << PAGE_SHIFT, min_page_size, @@ -101,15 +102,15 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man, if (lpfn <= bman->visible_size) { bman_res->used_visible_size = PFN_UP(bman_res->base.size); } else { - struct drm_buddy_block *block; + struct gpu_buddy_block *block; list_for_each_entry(block, &bman_res->blocks, link) { unsigned long start = - drm_buddy_block_offset(block) >> PAGE_SHIFT; + gpu_buddy_block_offset(block) >> PAGE_SHIFT; if (start < bman->visible_size) { unsigned long end = start + - (drm_buddy_block_size(mm, block) >> PAGE_SHIFT); + (gpu_buddy_block_size(mm, block) >> PAGE_SHIFT); bman_res->used_visible_size += min(end, bman->visible_size) - start; @@ -126,7 +127,7 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man, return 0; err_free_blocks: - drm_buddy_free_list(mm, &bman_res->blocks, 0); + gpu_buddy_free_list(mm, &bman_res->blocks, 0); mutex_unlock(&bman->lock); err_free_res: ttm_resource_fini(man, &bman_res->base); @@ -141,7 +142,7 @@ static void i915_ttm_buddy_man_free(struct ttm_resource_manager *man, struct i915_ttm_buddy_manager *bman = to_buddy_manager(man); mutex_lock(&bman->lock); - drm_buddy_free_list(&bman->mm, &bman_res->blocks, 0); + gpu_buddy_free_list(&bman->mm, &bman_res->blocks, 0); bman->visible_avail += bman_res->used_visible_size; mutex_unlock(&bman->lock); @@ -156,8 +157,8 @@ static bool i915_ttm_buddy_man_intersects(struct ttm_resource_manager *man, { struct i915_ttm_buddy_resource *bman_res = to_ttm_buddy_resource(res); struct i915_ttm_buddy_manager *bman = to_buddy_manager(man); - struct drm_buddy *mm = &bman->mm; - struct drm_buddy_block *block; + struct gpu_buddy *mm = &bman->mm; + struct gpu_buddy_block *block; if (!place->fpfn && !place->lpfn) return true; @@ -176,9 +177,9 @@ static bool i915_ttm_buddy_man_intersects(struct ttm_resource_manager *man, /* Check each drm buddy block individually */ list_for_each_entry(block, &bman_res->blocks, link) { unsigned long fpfn = - drm_buddy_block_offset(block) >> PAGE_SHIFT; + gpu_buddy_block_offset(block) >> PAGE_SHIFT; unsigned long lpfn = fpfn + - (drm_buddy_block_size(mm, block) >> PAGE_SHIFT); + (gpu_buddy_block_size(mm, block) >> PAGE_SHIFT); if (place->fpfn < lpfn && place->lpfn > fpfn) return true; @@ -194,8 +195,8 @@ static bool i915_ttm_buddy_man_compatible(struct ttm_resource_manager *man, { struct i915_ttm_buddy_resource *bman_res = to_ttm_buddy_resource(res); struct i915_ttm_buddy_manager *bman = to_buddy_manager(man); - struct drm_buddy *mm = &bman->mm; - struct drm_buddy_block *block; + struct gpu_buddy *mm = &bman->mm; + struct gpu_buddy_block *block; if (!place->fpfn && !place->lpfn) return true; @@ -209,9 +210,9 @@ static bool i915_ttm_buddy_man_compatible(struct ttm_resource_manager *man, /* Check each drm buddy block individually */ list_for_each_entry(block, &bman_res->blocks, link) { unsigned long fpfn = - drm_buddy_block_offset(block) >> PAGE_SHIFT; + gpu_buddy_block_offset(block) >> PAGE_SHIFT; unsigned long lpfn = fpfn + - (drm_buddy_block_size(mm, block) >> PAGE_SHIFT); + (gpu_buddy_block_size(mm, block) >> PAGE_SHIFT); if (fpfn < place->fpfn || lpfn > place->lpfn) return false; @@ -224,7 +225,7 @@ static void i915_ttm_buddy_man_debug(struct ttm_resource_manager *man, struct drm_printer *printer) { struct i915_ttm_buddy_manager *bman = to_buddy_manager(man); - struct drm_buddy_block *block; + struct gpu_buddy_block *block; mutex_lock(&bman->lock); drm_printf(printer, "default_page_size: %lluKiB\n", @@ -293,7 +294,7 @@ int i915_ttm_buddy_man_init(struct ttm_device *bdev, if (!bman) return -ENOMEM; - err = drm_buddy_init(&bman->mm, size, chunk_size); + err = gpu_buddy_init(&bman->mm, size, chunk_size); if (err) goto err_free_bman; @@ -333,7 +334,7 @@ int i915_ttm_buddy_man_fini(struct ttm_device *bdev, unsigned int type) { struct ttm_resource_manager *man = ttm_manager_type(bdev, type); struct i915_ttm_buddy_manager *bman = to_buddy_manager(man); - struct drm_buddy *mm = &bman->mm; + struct gpu_buddy *mm = &bman->mm; int ret; ttm_resource_manager_set_used(man, false); @@ -345,8 +346,8 @@ int i915_ttm_buddy_man_fini(struct ttm_device *bdev, unsigned int type) ttm_set_driver_manager(bdev, type, NULL); mutex_lock(&bman->lock); - drm_buddy_free_list(mm, &bman->reserved, 0); - drm_buddy_fini(mm); + gpu_buddy_free_list(mm, &bman->reserved, 0); + gpu_buddy_fini(mm); bman->visible_avail += bman->visible_reserved; WARN_ON_ONCE(bman->visible_avail != bman->visible_size); mutex_unlock(&bman->lock); @@ -371,15 +372,15 @@ int i915_ttm_buddy_man_reserve(struct ttm_resource_manager *man, u64 start, u64 size) { struct i915_ttm_buddy_manager *bman = to_buddy_manager(man); - struct drm_buddy *mm = &bman->mm; + struct gpu_buddy *mm = &bman->mm; unsigned long fpfn = start >> PAGE_SHIFT; unsigned long flags = 0; int ret; - flags |= DRM_BUDDY_RANGE_ALLOCATION; + flags |= GPU_BUDDY_RANGE_ALLOCATION; mutex_lock(&bman->lock); - ret = drm_buddy_alloc_blocks(mm, start, + ret = gpu_buddy_alloc_blocks(mm, start, start + size, size, mm->chunk_size, &bman->reserved, diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h index d64620712830..4a92dcf09766 100644 --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h @@ -13,14 +13,14 @@ struct ttm_device; struct ttm_resource_manager; -struct drm_buddy; +struct gpu_buddy; /** * struct i915_ttm_buddy_resource * * @base: struct ttm_resource base class we extend * @blocks: the list of struct i915_buddy_block for this resource/allocation - * @flags: DRM_BUDDY_*_ALLOCATION flags + * @flags: GPU_BUDDY_*_ALLOCATION flags * @used_visible_size: How much of this resource, if any, uses the CPU visible * portion, in pages. * @mm: the struct i915_buddy_mm for this resource @@ -33,7 +33,7 @@ struct i915_ttm_buddy_resource { struct list_head blocks; unsigned long flags; unsigned long used_visible_size; - struct drm_buddy *mm; + struct gpu_buddy *mm; }; /** diff --git a/drivers/gpu/drm/i915/selftests/intel_memory_region.c b/drivers/gpu/drm/i915/selftests/intel_memory_region.c index 7b856b5090f9..8307390943a2 100644 --- a/drivers/gpu/drm/i915/selftests/intel_memory_region.c +++ b/drivers/gpu/drm/i915/selftests/intel_memory_region.c @@ -6,7 +6,7 @@ #include <linux/prime_numbers.h> #include <linux/sort.h> -#include <drm/drm_buddy.h> +#include <linux/gpu_buddy.h> #include "../i915_selftest.h" @@ -371,7 +371,7 @@ static int igt_mock_splintered_region(void *arg) struct drm_i915_private *i915 = mem->i915; struct i915_ttm_buddy_resource *res; struct drm_i915_gem_object *obj; - struct drm_buddy *mm; + struct gpu_buddy *mm; unsigned int expected_order; LIST_HEAD(objects); u64 size; @@ -447,8 +447,8 @@ static int igt_mock_max_segment(void *arg) struct drm_i915_private *i915 = mem->i915; struct i915_ttm_buddy_resource *res; struct drm_i915_gem_object *obj; - struct drm_buddy_block *block; - struct drm_buddy *mm; + struct gpu_buddy_block *block; + struct gpu_buddy *mm; struct list_head *blocks; struct scatterlist *sg; I915_RND_STATE(prng); @@ -487,8 +487,8 @@ static int igt_mock_max_segment(void *arg) mm = res->mm; size = 0; list_for_each_entry(block, blocks, link) { - if (drm_buddy_block_size(mm, block) > size) - size = drm_buddy_block_size(mm, block); + if (gpu_buddy_block_size(mm, block) > size) + size = gpu_buddy_block_size(mm, block); } if (size < max_segment) { pr_err("%s: Failed to create a huge contiguous block [> %u], largest block %lld\n", @@ -527,14 +527,14 @@ static u64 igt_object_mappable_total(struct drm_i915_gem_object *obj) struct intel_memory_region *mr = obj->mm.region; struct i915_ttm_buddy_resource *bman_res = to_ttm_buddy_resource(obj->mm.res); - struct drm_buddy *mm = bman_res->mm; - struct drm_buddy_block *block; + struct gpu_buddy *mm = bman_res->mm; + struct gpu_buddy_block *block; u64 total; total = 0; list_for_each_entry(block, &bman_res->blocks, link) { - u64 start = drm_buddy_block_offset(block); - u64 end = start + drm_buddy_block_size(mm, block); + u64 start = gpu_buddy_block_offset(block); + u64 end = start + gpu_buddy_block_size(mm, block); if (start < resource_size(&mr->io)) total += min_t(u64, end, resource_size(&mr->io)) - start; diff --git a/drivers/gpu/drm/tests/Makefile b/drivers/gpu/drm/tests/Makefile index 87d5d5f9332a..d2e2e3d8349a 100644 --- a/drivers/gpu/drm/tests/Makefile +++ b/drivers/gpu/drm/tests/Makefile @@ -7,7 +7,6 @@ obj-$(CONFIG_DRM_KUNIT_TEST) += \ drm_atomic_test.o \ drm_atomic_state_test.o \ drm_bridge_test.o \ - drm_buddy_test.o \ drm_cmdline_parser_test.o \ drm_connector_test.o \ drm_damage_helper_test.o \ diff --git a/drivers/gpu/drm/ttm/tests/ttm_bo_validate_test.c b/drivers/gpu/drm/ttm/tests/ttm_bo_validate_test.c index 2eda87882e65..ffa12473077c 100644 --- a/drivers/gpu/drm/ttm/tests/ttm_bo_validate_test.c +++ b/drivers/gpu/drm/ttm/tests/ttm_bo_validate_test.c @@ -3,6 +3,7 @@ * Copyright © 2023 Intel Corporation */ #include <linux/delay.h> +#include <linux/gpu_buddy.h> #include <linux/kthread.h> #include <drm/ttm/ttm_resource.h> @@ -251,7 +252,7 @@ static void ttm_bo_validate_basic(struct kunit *test) NULL, &dummy_ttm_bo_destroy); KUNIT_EXPECT_EQ(test, err, 0); - snd_place = ttm_place_kunit_init(test, snd_mem, DRM_BUDDY_TOPDOWN_ALLOCATION); + snd_place = ttm_place_kunit_init(test, snd_mem, GPU_BUDDY_TOPDOWN_ALLOCATION); snd_placement = ttm_placement_kunit_init(test, snd_place, 1); err = ttm_bo_validate(bo, snd_placement, &ctx_val); @@ -263,7 +264,7 @@ static void ttm_bo_validate_basic(struct kunit *test) KUNIT_EXPECT_TRUE(test, ttm_tt_is_populated(bo->ttm)); KUNIT_EXPECT_EQ(test, bo->resource->mem_type, snd_mem); KUNIT_EXPECT_EQ(test, bo->resource->placement, - DRM_BUDDY_TOPDOWN_ALLOCATION); + GPU_BUDDY_TOPDOWN_ALLOCATION); ttm_bo_fini(bo); ttm_mock_manager_fini(priv->ttm_dev, snd_mem); diff --git a/drivers/gpu/drm/ttm/tests/ttm_mock_manager.c b/drivers/gpu/drm/ttm/tests/ttm_mock_manager.c index dd395229e388..294d56d9067e 100644 --- a/drivers/gpu/drm/ttm/tests/ttm_mock_manager.c +++ b/drivers/gpu/drm/ttm/tests/ttm_mock_manager.c @@ -31,7 +31,7 @@ static int ttm_mock_manager_alloc(struct ttm_resource_manager *man, { struct ttm_mock_manager *manager = to_mock_mgr(man); struct ttm_mock_resource *mock_res; - struct drm_buddy *mm = &manager->mm; + struct gpu_buddy *mm = &manager->mm; u64 lpfn, fpfn, alloc_size; int err; @@ -47,14 +47,14 @@ static int ttm_mock_manager_alloc(struct ttm_resource_manager *man, INIT_LIST_HEAD(&mock_res->blocks); if (place->flags & TTM_PL_FLAG_TOPDOWN) - mock_res->flags |= DRM_BUDDY_TOPDOWN_ALLOCATION; + mock_res->flags |= GPU_BUDDY_TOPDOWN_ALLOCATION; if (place->flags & TTM_PL_FLAG_CONTIGUOUS) - mock_res->flags |= DRM_BUDDY_CONTIGUOUS_ALLOCATION; + mock_res->flags |= GPU_BUDDY_CONTIGUOUS_ALLOCATION; alloc_size = (uint64_t)mock_res->base.size; mutex_lock(&manager->lock); - err = drm_buddy_alloc_blocks(mm, fpfn, lpfn, alloc_size, + err = gpu_buddy_alloc_blocks(mm, fpfn, lpfn, alloc_size, manager->default_page_size, &mock_res->blocks, mock_res->flags); @@ -67,7 +67,7 @@ static int ttm_mock_manager_alloc(struct ttm_resource_manager *man, return 0; error_free_blocks: - drm_buddy_free_list(mm, &mock_res->blocks, 0); + gpu_buddy_free_list(mm, &mock_res->blocks, 0); ttm_resource_fini(man, &mock_res->base); mutex_unlock(&manager->lock); @@ -79,10 +79,10 @@ static void ttm_mock_manager_free(struct ttm_resource_manager *man, { struct ttm_mock_manager *manager = to_mock_mgr(man); struct ttm_mock_resource *mock_res = to_mock_mgr_resource(res); - struct drm_buddy *mm = &manager->mm; + struct gpu_buddy *mm = &manager->mm; mutex_lock(&manager->lock); - drm_buddy_free_list(mm, &mock_res->blocks, 0); + gpu_buddy_free_list(mm, &mock_res->blocks, 0); mutex_unlock(&manager->lock); ttm_resource_fini(man, res); @@ -106,7 +106,7 @@ int ttm_mock_manager_init(struct ttm_device *bdev, u32 mem_type, u32 size) mutex_init(&manager->lock); - err = drm_buddy_init(&manager->mm, size, PAGE_SIZE); + err = gpu_buddy_init(&manager->mm, size, PAGE_SIZE); if (err) { kfree(manager); @@ -142,7 +142,7 @@ void ttm_mock_manager_fini(struct ttm_device *bdev, u32 mem_type) ttm_resource_manager_set_used(man, false); mutex_lock(&mock_man->lock); - drm_buddy_fini(&mock_man->mm); + gpu_buddy_fini(&mock_man->mm); mutex_unlock(&mock_man->lock); ttm_set_driver_manager(bdev, mem_type, NULL); diff --git a/drivers/gpu/drm/ttm/tests/ttm_mock_manager.h b/drivers/gpu/drm/ttm/tests/ttm_mock_manager.h index e4c95f86a467..08710756fd8e 100644 --- a/drivers/gpu/drm/ttm/tests/ttm_mock_manager.h +++ b/drivers/gpu/drm/ttm/tests/ttm_mock_manager.h @@ -5,11 +5,11 @@ #ifndef TTM_MOCK_MANAGER_H #define TTM_MOCK_MANAGER_H -#include <drm/drm_buddy.h> +#include <linux/gpu_buddy.h> struct ttm_mock_manager { struct ttm_resource_manager man; - struct drm_buddy mm; + struct gpu_buddy mm; u64 default_page_size; /* protects allocations of mock buffer objects */ struct mutex lock; diff --git a/drivers/gpu/drm/xe/Kconfig b/drivers/gpu/drm/xe/Kconfig index 4b288eb3f5b0..982ef754742e 100644 --- a/drivers/gpu/drm/xe/Kconfig +++ b/drivers/gpu/drm/xe/Kconfig @@ -11,6 +11,7 @@ config DRM_XE # the shmem_readpage() which depends upon tmpfs select SHMEM select TMPFS + select GPU_BUDDY select DRM_BUDDY select DRM_CLIENT_SELECTION select DRM_KMS_HELPER diff --git a/drivers/gpu/drm/xe/xe_res_cursor.h b/drivers/gpu/drm/xe/xe_res_cursor.h index 4e00008b7081..5f4ab08c0686 100644 --- a/drivers/gpu/drm/xe/xe_res_cursor.h +++ b/drivers/gpu/drm/xe/xe_res_cursor.h @@ -58,7 +58,7 @@ struct xe_res_cursor { /** @dma_addr: Current element in a struct drm_pagemap_addr array */ const struct drm_pagemap_addr *dma_addr; /** @mm: Buddy allocator for VRAM cursor */ - struct drm_buddy *mm; + struct gpu_buddy *mm; /** * @dma_start: DMA start address for the current segment. * This may be different to @dma_addr.addr since elements in @@ -69,7 +69,7 @@ struct xe_res_cursor { u64 dma_seg_size; }; -static struct drm_buddy *xe_res_get_buddy(struct ttm_resource *res) +static struct gpu_buddy *xe_res_get_buddy(struct ttm_resource *res) { struct ttm_resource_manager *mgr; @@ -104,30 +104,30 @@ static inline void xe_res_first(struct ttm_resource *res, case XE_PL_STOLEN: case XE_PL_VRAM0: case XE_PL_VRAM1: { - struct drm_buddy_block *block; + struct gpu_buddy_block *block; struct list_head *head, *next; - struct drm_buddy *mm = xe_res_get_buddy(res); + struct gpu_buddy *mm = xe_res_get_buddy(res); head = &to_xe_ttm_vram_mgr_resource(res)->blocks; block = list_first_entry_or_null(head, - struct drm_buddy_block, + struct gpu_buddy_block, link); if (!block) goto fallback; - while (start >= drm_buddy_block_size(mm, block)) { - start -= drm_buddy_block_size(mm, block); + while (start >= gpu_buddy_block_size(mm, block)) { + start -= gpu_buddy_block_size(mm, block); next = block->link.next; if (next != head) - block = list_entry(next, struct drm_buddy_block, + block = list_entry(next, struct gpu_buddy_block, link); } cur->mm = mm; - cur->start = drm_buddy_block_offset(block) + start; - cur->size = min(drm_buddy_block_size(mm, block) - start, + cur->start = gpu_buddy_block_offset(block) + start; + cur->size = min(gpu_buddy_block_size(mm, block) - start, size); cur->remaining = size; cur->node = block; @@ -259,7 +259,7 @@ static inline void xe_res_first_dma(const struct drm_pagemap_addr *dma_addr, */ static inline void xe_res_next(struct xe_res_cursor *cur, u64 size) { - struct drm_buddy_block *block; + struct gpu_buddy_block *block; struct list_head *next; u64 start; @@ -295,18 +295,18 @@ static inline void xe_res_next(struct xe_res_cursor *cur, u64 size) block = cur->node; next = block->link.next; - block = list_entry(next, struct drm_buddy_block, link); + block = list_entry(next, struct gpu_buddy_block, link); - while (start >= drm_buddy_block_size(cur->mm, block)) { - start -= drm_buddy_block_size(cur->mm, block); + while (start >= gpu_buddy_block_size(cur->mm, block)) { + start -= gpu_buddy_block_size(cur->mm, block); next = block->link.next; - block = list_entry(next, struct drm_buddy_block, link); + block = list_entry(next, struct gpu_buddy_block, link); } - cur->start = drm_buddy_block_offset(block) + start; - cur->size = min(drm_buddy_block_size(cur->mm, block) - start, + cur->start = gpu_buddy_block_offset(block) + start; + cur->size = min(gpu_buddy_block_size(cur->mm, block) - start, cur->remaining); cur->node = block; break; diff --git a/drivers/gpu/drm/xe/xe_svm.c b/drivers/gpu/drm/xe/xe_svm.c index 55c5a0eb82e1..26b59898d4f4 100644 --- a/drivers/gpu/drm/xe/xe_svm.c +++ b/drivers/gpu/drm/xe/xe_svm.c @@ -676,7 +676,7 @@ static u64 block_offset_to_pfn(struct xe_vram_region *vr, u64 offset) return PHYS_PFN(offset + vr->hpa_base); } -static struct drm_buddy *vram_to_buddy(struct xe_vram_region *vram) +static struct gpu_buddy *vram_to_buddy(struct xe_vram_region *vram) { return &vram->ttm.mm; } @@ -687,16 +687,16 @@ static int xe_svm_populate_devmem_pfn(struct drm_pagemap_devmem *devmem_allocati struct xe_bo *bo = to_xe_bo(devmem_allocation); struct ttm_resource *res = bo->ttm.resource; struct list_head *blocks = &to_xe_ttm_vram_mgr_resource(res)->blocks; - struct drm_buddy_block *block; + struct gpu_buddy_block *block; int j = 0; list_for_each_entry(block, blocks, link) { struct xe_vram_region *vr = block->private; - struct drm_buddy *buddy = vram_to_buddy(vr); - u64 block_pfn = block_offset_to_pfn(vr, drm_buddy_block_offset(block)); + struct gpu_buddy *buddy = vram_to_buddy(vr); + u64 block_pfn = block_offset_to_pfn(vr, gpu_buddy_block_offset(block)); int i; - for (i = 0; i < drm_buddy_block_size(buddy, block) >> PAGE_SHIFT; ++i) + for (i = 0; i < gpu_buddy_block_size(buddy, block) >> PAGE_SHIFT; ++i) pfn[j++] = block_pfn + i; } @@ -863,7 +863,7 @@ static int xe_drm_pagemap_populate_mm(struct drm_pagemap *dpagemap, struct xe_vram_region *vr = container_of(dpagemap, typeof(*vr), dpagemap); struct xe_device *xe = vr->xe; struct device *dev = xe->drm.dev; - struct drm_buddy_block *block; + struct gpu_buddy_block *block; struct xe_validation_ctx vctx; struct list_head *blocks; struct drm_exec exec; diff --git a/drivers/gpu/drm/xe/xe_ttm_vram_mgr.c b/drivers/gpu/drm/xe/xe_ttm_vram_mgr.c index 9f70802fce92..8192957261e8 100644 --- a/drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +++ b/drivers/gpu/drm/xe/xe_ttm_vram_mgr.c @@ -4,8 +4,9 @@ * Copyright (C) 2021-2022 Red Hat */ -#include <drm/drm_managed.h> +#include <drm/drm_buddy.h> #include <drm/drm_drv.h> +#include <drm/drm_managed.h> #include <drm/ttm/ttm_placement.h> #include <drm/ttm/ttm_range_manager.h> @@ -17,16 +18,16 @@ #include "xe_ttm_vram_mgr.h" #include "xe_vram_types.h" -static inline struct drm_buddy_block * +static inline struct gpu_buddy_block * xe_ttm_vram_mgr_first_block(struct list_head *list) { - return list_first_entry_or_null(list, struct drm_buddy_block, link); + return list_first_entry_or_null(list, struct gpu_buddy_block, link); } -static inline bool xe_is_vram_mgr_blocks_contiguous(struct drm_buddy *mm, +static inline bool xe_is_vram_mgr_blocks_contiguous(struct gpu_buddy *mm, struct list_head *head) { - struct drm_buddy_block *block; + struct gpu_buddy_block *block; u64 start, size; block = xe_ttm_vram_mgr_first_block(head); @@ -34,12 +35,12 @@ static inline bool xe_is_vram_mgr_blocks_contiguous(struct drm_buddy *mm, return false; while (head != block->link.next) { - start = drm_buddy_block_offset(block); - size = drm_buddy_block_size(mm, block); + start = gpu_buddy_block_offset(block); + size = gpu_buddy_block_size(mm, block); - block = list_entry(block->link.next, struct drm_buddy_block, + block = list_entry(block->link.next, struct gpu_buddy_block, link); - if (start + size != drm_buddy_block_offset(block)) + if (start + size != gpu_buddy_block_offset(block)) return false; } @@ -53,7 +54,7 @@ static int xe_ttm_vram_mgr_new(struct ttm_resource_manager *man, { struct xe_ttm_vram_mgr *mgr = to_xe_ttm_vram_mgr(man); struct xe_ttm_vram_mgr_resource *vres; - struct drm_buddy *mm = &mgr->mm; + struct gpu_buddy *mm = &mgr->mm; u64 size, min_page_size; unsigned long lpfn; int err; @@ -80,10 +81,10 @@ static int xe_ttm_vram_mgr_new(struct ttm_resource_manager *man, INIT_LIST_HEAD(&vres->blocks); if (place->flags & TTM_PL_FLAG_TOPDOWN) - vres->flags |= DRM_BUDDY_TOPDOWN_ALLOCATION; + vres->flags |= GPU_BUDDY_TOPDOWN_ALLOCATION; if (place->fpfn || lpfn != man->size >> PAGE_SHIFT) - vres->flags |= DRM_BUDDY_RANGE_ALLOCATION; + vres->flags |= GPU_BUDDY_RANGE_ALLOCATION; if (WARN_ON(!vres->base.size)) { err = -EINVAL; @@ -119,27 +120,27 @@ static int xe_ttm_vram_mgr_new(struct ttm_resource_manager *man, lpfn = max_t(unsigned long, place->fpfn + (size >> PAGE_SHIFT), lpfn); } - err = drm_buddy_alloc_blocks(mm, (u64)place->fpfn << PAGE_SHIFT, + err = gpu_buddy_alloc_blocks(mm, (u64)place->fpfn << PAGE_SHIFT, (u64)lpfn << PAGE_SHIFT, size, min_page_size, &vres->blocks, vres->flags); if (err) goto error_unlock; if (place->flags & TTM_PL_FLAG_CONTIGUOUS) { - if (!drm_buddy_block_trim(mm, NULL, vres->base.size, &vres->blocks)) + if (!gpu_buddy_block_trim(mm, NULL, vres->base.size, &vres->blocks)) size = vres->base.size; } if (lpfn <= mgr->visible_size >> PAGE_SHIFT) { vres->used_visible_size = size; } else { - struct drm_buddy_block *block; + struct gpu_buddy_block *block; list_for_each_entry(block, &vres->blocks, link) { - u64 start = drm_buddy_block_offset(block); + u64 start = gpu_buddy_block_offset(block); if (start < mgr->visible_size) { - u64 end = start + drm_buddy_block_size(mm, block); + u64 end = start + gpu_buddy_block_size(mm, block); vres->used_visible_size += min(end, mgr->visible_size) - start; @@ -159,11 +160,11 @@ static int xe_ttm_vram_mgr_new(struct ttm_resource_manager *man, * the object. */ if (vres->base.placement & TTM_PL_FLAG_CONTIGUOUS) { - struct drm_buddy_block *block = list_first_entry(&vres->blocks, + struct gpu_buddy_block *block = list_first_entry(&vres->blocks, typeof(*block), link); - vres->base.start = drm_buddy_block_offset(block) >> PAGE_SHIFT; + vres->base.start = gpu_buddy_block_offset(block) >> PAGE_SHIFT; } else { vres->base.start = XE_BO_INVALID_OFFSET; } @@ -185,10 +186,10 @@ static void xe_ttm_vram_mgr_del(struct ttm_resource_manager *man, struct xe_ttm_vram_mgr_resource *vres = to_xe_ttm_vram_mgr_resource(res); struct xe_ttm_vram_mgr *mgr = to_xe_ttm_vram_mgr(man); - struct drm_buddy *mm = &mgr->mm; + struct gpu_buddy *mm = &mgr->mm; mutex_lock(&mgr->lock); - drm_buddy_free_list(mm, &vres->blocks, 0); + gpu_buddy_free_list(mm, &vres->blocks, 0); mgr->visible_avail += vres->used_visible_size; mutex_unlock(&mgr->lock); @@ -201,7 +202,7 @@ static void xe_ttm_vram_mgr_debug(struct ttm_resource_manager *man, struct drm_printer *printer) { struct xe_ttm_vram_mgr *mgr = to_xe_ttm_vram_mgr(man); - struct drm_buddy *mm = &mgr->mm; + struct gpu_buddy *mm = &mgr->mm; mutex_lock(&mgr->lock); drm_printf(printer, "default_page_size: %lluKiB\n", @@ -224,8 +225,8 @@ static bool xe_ttm_vram_mgr_intersects(struct ttm_resource_manager *man, struct xe_ttm_vram_mgr *mgr = to_xe_ttm_vram_mgr(man); struct xe_ttm_vram_mgr_resource *vres = to_xe_ttm_vram_mgr_resource(res); - struct drm_buddy *mm = &mgr->mm; - struct drm_buddy_block *block; + struct gpu_buddy *mm = &mgr->mm; + struct gpu_buddy_block *block; if (!place->fpfn && !place->lpfn) return true; @@ -235,9 +236,9 @@ static bool xe_ttm_vram_mgr_intersects(struct ttm_resource_manager *man, list_for_each_entry(block, &vres->blocks, link) { unsigned long fpfn = - drm_buddy_block_offset(block) >> PAGE_SHIFT; + gpu_buddy_block_offset(block) >> PAGE_SHIFT; unsigned long lpfn = fpfn + - (drm_buddy_block_size(mm, block) >> PAGE_SHIFT); + (gpu_buddy_block_size(mm, block) >> PAGE_SHIFT); if (place->fpfn < lpfn && place->lpfn > fpfn) return true; @@ -254,8 +255,8 @@ static bool xe_ttm_vram_mgr_compatible(struct ttm_resource_manager *man, struct xe_ttm_vram_mgr *mgr = to_xe_ttm_vram_mgr(man); struct xe_ttm_vram_mgr_resource *vres = to_xe_ttm_vram_mgr_resource(res); - struct drm_buddy *mm = &mgr->mm; - struct drm_buddy_block *block; + struct gpu_buddy *mm = &mgr->mm; + struct gpu_buddy_block *block; if (!place->fpfn && !place->lpfn) return true; @@ -265,9 +266,9 @@ static bool xe_ttm_vram_mgr_compatible(struct ttm_resource_manager *man, list_for_each_entry(block, &vres->blocks, link) { unsigned long fpfn = - drm_buddy_block_offset(block) >> PAGE_SHIFT; + gpu_buddy_block_offset(block) >> PAGE_SHIFT; unsigned long lpfn = fpfn + - (drm_buddy_block_size(mm, block) >> PAGE_SHIFT); + (gpu_buddy_block_size(mm, block) >> PAGE_SHIFT); if (fpfn < place->fpfn || lpfn > place->lpfn) return false; @@ -297,7 +298,7 @@ static void xe_ttm_vram_mgr_fini(struct drm_device *dev, void *arg) WARN_ON_ONCE(mgr->visible_avail != mgr->visible_size); - drm_buddy_fini(&mgr->mm); + gpu_buddy_fini(&mgr->mm); ttm_resource_manager_cleanup(&mgr->manager); @@ -328,7 +329,7 @@ int __xe_ttm_vram_mgr_init(struct xe_device *xe, struct xe_ttm_vram_mgr *mgr, mgr->visible_avail = io_size; ttm_resource_manager_init(man, &xe->ttm, size); - err = drm_buddy_init(&mgr->mm, man->size, default_page_size); + err = gpu_buddy_init(&mgr->mm, man->size, default_page_size); if (err) return err; @@ -376,7 +377,7 @@ int xe_ttm_vram_mgr_alloc_sgt(struct xe_device *xe, if (!*sgt) return -ENOMEM; - /* Determine the number of DRM_BUDDY blocks to export */ + /* Determine the number of GPU_BUDDY blocks to export */ xe_res_first(res, offset, length, &cursor); while (cursor.remaining) { num_entries++; @@ -393,10 +394,10 @@ int xe_ttm_vram_mgr_alloc_sgt(struct xe_device *xe, sg->length = 0; /* - * Walk down DRM_BUDDY blocks to populate scatterlist nodes - * @note: Use iterator api to get first the DRM_BUDDY block + * Walk down GPU_BUDDY blocks to populate scatterlist nodes + * @note: Use iterator api to get first the GPU_BUDDY block * and the number of bytes from it. Access the following - * DRM_BUDDY block(s) if more buffer needs to exported + * GPU_BUDDY block(s) if more buffer needs to exported */ xe_res_first(res, offset, length, &cursor); for_each_sgtable_sg((*sgt), sg, i) { diff --git a/drivers/gpu/drm/xe/xe_ttm_vram_mgr_types.h b/drivers/gpu/drm/xe/xe_ttm_vram_mgr_types.h index a71e14818ec2..9106da056b49 100644 --- a/drivers/gpu/drm/xe/xe_ttm_vram_mgr_types.h +++ b/drivers/gpu/drm/xe/xe_ttm_vram_mgr_types.h @@ -6,7 +6,7 @@ #ifndef _XE_TTM_VRAM_MGR_TYPES_H_ #define _XE_TTM_VRAM_MGR_TYPES_H_ -#include <drm/drm_buddy.h> +#include <linux/gpu_buddy.h> #include <drm/ttm/ttm_device.h> /** @@ -18,7 +18,7 @@ struct xe_ttm_vram_mgr { /** @manager: Base TTM resource manager */ struct ttm_resource_manager manager; /** @mm: DRM buddy allocator which manages the VRAM */ - struct drm_buddy mm; + struct gpu_buddy mm; /** @visible_size: Proped size of the CPU visible portion */ u64 visible_size; /** @visible_avail: CPU visible portion still unallocated */ diff --git a/drivers/gpu/tests/Makefile b/drivers/gpu/tests/Makefile new file mode 100644 index 000000000000..31a5ff44cb4e --- /dev/null +++ b/drivers/gpu/tests/Makefile @@ -0,0 +1,3 @@ +# SPDX-License-Identifier: GPL-2.0 + +obj-$(CONFIG_GPU_BUDDY_KUNIT_TEST) += gpu_buddy_test.o gpu_random.o diff --git a/drivers/gpu/drm/tests/drm_buddy_test.c b/drivers/gpu/tests/gpu_buddy_test.c similarity index 68% rename from drivers/gpu/drm/tests/drm_buddy_test.c rename to drivers/gpu/tests/gpu_buddy_test.c index 5f40b5343bd8..dcd4741a905d 100644 --- a/drivers/gpu/drm/tests/drm_buddy_test.c +++ b/drivers/gpu/tests/gpu_buddy_test.c @@ -10,9 +10,9 @@ #include <linux/sched/signal.h> #include <linux/sizes.h> -#include <drm/drm_buddy.h> +#include <linux/gpu_buddy.h> -#include "../lib/drm_random.h" +#include "gpu_random.h" static unsigned int random_seed; @@ -21,9 +21,9 @@ static inline u64 get_size(int order, u64 chunk_size) return (1 << order) * chunk_size; } -static void drm_test_buddy_fragmentation_performance(struct kunit *test) +static void gpu_test_buddy_fragmentation_performance(struct kunit *test) { - struct drm_buddy_block *block, *tmp; + struct gpu_buddy_block *block, *tmp; int num_blocks, i, ret, count = 0; LIST_HEAD(allocated_blocks); unsigned long elapsed_ms; @@ -32,7 +32,7 @@ static void drm_test_buddy_fragmentation_performance(struct kunit *test) LIST_HEAD(clear_list); LIST_HEAD(dirty_list); LIST_HEAD(free_list); - struct drm_buddy mm; + struct gpu_buddy mm; u64 mm_size = SZ_4G; ktime_t start, end; @@ -47,7 +47,7 @@ static void drm_test_buddy_fragmentation_performance(struct kunit *test) * quickly the allocator can satisfy larger, aligned requests from a pool of * highly fragmented space. */ - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_init(&mm, mm_size, SZ_4K), + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_init(&mm, mm_size, SZ_4K), "buddy_init failed\n"); num_blocks = mm_size / SZ_64K; @@ -55,7 +55,7 @@ static void drm_test_buddy_fragmentation_performance(struct kunit *test) start = ktime_get(); /* Allocate with maximum fragmentation - 8K blocks with 64K alignment */ for (i = 0; i < num_blocks; i++) - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size, SZ_8K, SZ_64K, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, mm_size, SZ_8K, SZ_64K, &allocated_blocks, 0), "buddy_alloc hit an error size=%u\n", SZ_8K); @@ -68,21 +68,21 @@ static void drm_test_buddy_fragmentation_performance(struct kunit *test) } /* Free with different flags to ensure no coalescing */ - drm_buddy_free_list(&mm, &clear_list, DRM_BUDDY_CLEARED); - drm_buddy_free_list(&mm, &dirty_list, 0); + gpu_buddy_free_list(&mm, &clear_list, GPU_BUDDY_CLEARED); + gpu_buddy_free_list(&mm, &dirty_list, 0); for (i = 0; i < num_blocks; i++) - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size, SZ_64K, SZ_64K, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, mm_size, SZ_64K, SZ_64K, &test_blocks, 0), "buddy_alloc hit an error size=%u\n", SZ_64K); - drm_buddy_free_list(&mm, &test_blocks, 0); + gpu_buddy_free_list(&mm, &test_blocks, 0); end = ktime_get(); elapsed_ms = ktime_to_ms(ktime_sub(end, start)); kunit_info(test, "Fragmented allocation took %lu ms\n", elapsed_ms); - drm_buddy_fini(&mm); + gpu_buddy_fini(&mm); /* * Reverse free order under fragmentation @@ -96,13 +96,13 @@ static void drm_test_buddy_fragmentation_performance(struct kunit *test) * deallocation occurs in the opposite order of allocation, exposing the * cost difference between a linear freelist scan and an ordered tree lookup. */ - ret = drm_buddy_init(&mm, mm_size, SZ_4K); + ret = gpu_buddy_init(&mm, mm_size, SZ_4K); KUNIT_ASSERT_EQ(test, ret, 0); start = ktime_get(); /* Allocate maximum fragmentation */ for (i = 0; i < num_blocks; i++) - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size, SZ_8K, SZ_64K, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, mm_size, SZ_8K, SZ_64K, &allocated_blocks, 0), "buddy_alloc hit an error size=%u\n", SZ_8K); @@ -111,28 +111,28 @@ static void drm_test_buddy_fragmentation_performance(struct kunit *test) list_move_tail(&block->link, &free_list); count++; } - drm_buddy_free_list(&mm, &free_list, DRM_BUDDY_CLEARED); + gpu_buddy_free_list(&mm, &free_list, GPU_BUDDY_CLEARED); list_for_each_entry_safe_reverse(block, tmp, &allocated_blocks, link) list_move(&block->link, &reverse_list); - drm_buddy_free_list(&mm, &reverse_list, DRM_BUDDY_CLEARED); + gpu_buddy_free_list(&mm, &reverse_list, GPU_BUDDY_CLEARED); end = ktime_get(); elapsed_ms = ktime_to_ms(ktime_sub(end, start)); kunit_info(test, "Reverse-ordered free took %lu ms\n", elapsed_ms); - drm_buddy_fini(&mm); + gpu_buddy_fini(&mm); } -static void drm_test_buddy_alloc_range_bias(struct kunit *test) +static void gpu_test_buddy_alloc_range_bias(struct kunit *test) { u32 mm_size, size, ps, bias_size, bias_start, bias_end, bias_rem; - DRM_RND_STATE(prng, random_seed); + GPU_RND_STATE(prng, random_seed); unsigned int i, count, *order; - struct drm_buddy_block *block; + struct gpu_buddy_block *block; unsigned long flags; - struct drm_buddy mm; + struct gpu_buddy mm; LIST_HEAD(allocated); bias_size = SZ_1M; @@ -142,11 +142,11 @@ static void drm_test_buddy_alloc_range_bias(struct kunit *test) kunit_info(test, "mm_size=%u, ps=%u\n", mm_size, ps); - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_init(&mm, mm_size, ps), + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_init(&mm, mm_size, ps), "buddy_init failed\n"); count = mm_size / bias_size; - order = drm_random_order(count, &prng); + order = gpu_random_order(count, &prng); KUNIT_EXPECT_TRUE(test, order); /* @@ -166,79 +166,79 @@ static void drm_test_buddy_alloc_range_bias(struct kunit *test) /* internal round_up too big */ KUNIT_ASSERT_TRUE_MSG(test, - drm_buddy_alloc_blocks(&mm, bias_start, + gpu_buddy_alloc_blocks(&mm, bias_start, bias_end, bias_size + ps, bias_size, &allocated, - DRM_BUDDY_RANGE_ALLOCATION), + GPU_BUDDY_RANGE_ALLOCATION), "buddy_alloc failed with bias(%x-%x), size=%u, ps=%u\n", bias_start, bias_end, bias_size, bias_size); /* size too big */ KUNIT_ASSERT_TRUE_MSG(test, - drm_buddy_alloc_blocks(&mm, bias_start, + gpu_buddy_alloc_blocks(&mm, bias_start, bias_end, bias_size + ps, ps, &allocated, - DRM_BUDDY_RANGE_ALLOCATION), + GPU_BUDDY_RANGE_ALLOCATION), "buddy_alloc didn't fail with bias(%x-%x), size=%u, ps=%u\n", bias_start, bias_end, bias_size + ps, ps); /* bias range too small for size */ KUNIT_ASSERT_TRUE_MSG(test, - drm_buddy_alloc_blocks(&mm, bias_start + ps, + gpu_buddy_alloc_blocks(&mm, bias_start + ps, bias_end, bias_size, ps, &allocated, - DRM_BUDDY_RANGE_ALLOCATION), + GPU_BUDDY_RANGE_ALLOCATION), "buddy_alloc didn't fail with bias(%x-%x), size=%u, ps=%u\n", bias_start + ps, bias_end, bias_size, ps); /* bias misaligned */ KUNIT_ASSERT_TRUE_MSG(test, - drm_buddy_alloc_blocks(&mm, bias_start + ps, + gpu_buddy_alloc_blocks(&mm, bias_start + ps, bias_end - ps, bias_size >> 1, bias_size >> 1, &allocated, - DRM_BUDDY_RANGE_ALLOCATION), + GPU_BUDDY_RANGE_ALLOCATION), "buddy_alloc h didn't fail with bias(%x-%x), size=%u, ps=%u\n", bias_start + ps, bias_end - ps, bias_size >> 1, bias_size >> 1); /* single big page */ KUNIT_ASSERT_FALSE_MSG(test, - drm_buddy_alloc_blocks(&mm, bias_start, + gpu_buddy_alloc_blocks(&mm, bias_start, bias_end, bias_size, bias_size, &tmp, - DRM_BUDDY_RANGE_ALLOCATION), + GPU_BUDDY_RANGE_ALLOCATION), "buddy_alloc i failed with bias(%x-%x), size=%u, ps=%u\n", bias_start, bias_end, bias_size, bias_size); - drm_buddy_free_list(&mm, &tmp, 0); + gpu_buddy_free_list(&mm, &tmp, 0); /* single page with internal round_up */ KUNIT_ASSERT_FALSE_MSG(test, - drm_buddy_alloc_blocks(&mm, bias_start, + gpu_buddy_alloc_blocks(&mm, bias_start, bias_end, ps, bias_size, &tmp, - DRM_BUDDY_RANGE_ALLOCATION), + GPU_BUDDY_RANGE_ALLOCATION), "buddy_alloc failed with bias(%x-%x), size=%u, ps=%u\n", bias_start, bias_end, ps, bias_size); - drm_buddy_free_list(&mm, &tmp, 0); + gpu_buddy_free_list(&mm, &tmp, 0); /* random size within */ size = max(round_up(prandom_u32_state(&prng) % bias_rem, ps), ps); if (size) KUNIT_ASSERT_FALSE_MSG(test, - drm_buddy_alloc_blocks(&mm, bias_start, + gpu_buddy_alloc_blocks(&mm, bias_start, bias_end, size, ps, &tmp, - DRM_BUDDY_RANGE_ALLOCATION), + GPU_BUDDY_RANGE_ALLOCATION), "buddy_alloc failed with bias(%x-%x), size=%u, ps=%u\n", bias_start, bias_end, size, ps); bias_rem -= size; /* too big for current avail */ KUNIT_ASSERT_TRUE_MSG(test, - drm_buddy_alloc_blocks(&mm, bias_start, + gpu_buddy_alloc_blocks(&mm, bias_start, bias_end, bias_rem + ps, ps, &allocated, - DRM_BUDDY_RANGE_ALLOCATION), + GPU_BUDDY_RANGE_ALLOCATION), "buddy_alloc didn't fail with bias(%x-%x), size=%u, ps=%u\n", bias_start, bias_end, bias_rem + ps, ps); @@ -248,10 +248,10 @@ static void drm_test_buddy_alloc_range_bias(struct kunit *test) size = max(size, ps); KUNIT_ASSERT_FALSE_MSG(test, - drm_buddy_alloc_blocks(&mm, bias_start, + gpu_buddy_alloc_blocks(&mm, bias_start, bias_end, size, ps, &allocated, - DRM_BUDDY_RANGE_ALLOCATION), + GPU_BUDDY_RANGE_ALLOCATION), "buddy_alloc failed with bias(%x-%x), size=%u, ps=%u\n", bias_start, bias_end, size, ps); /* @@ -259,15 +259,15 @@ static void drm_test_buddy_alloc_range_bias(struct kunit *test) * unallocated, and ideally not always on the bias * boundaries. */ - drm_buddy_free_list(&mm, &tmp, 0); + gpu_buddy_free_list(&mm, &tmp, 0); } else { list_splice_tail(&tmp, &allocated); } } kfree(order); - drm_buddy_free_list(&mm, &allocated, 0); - drm_buddy_fini(&mm); + gpu_buddy_free_list(&mm, &allocated, 0); + gpu_buddy_fini(&mm); /* * Something more free-form. Idea is to pick a random starting bias @@ -278,7 +278,7 @@ static void drm_test_buddy_alloc_range_bias(struct kunit *test) * allocated nodes in the middle of the address space. */ - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_init(&mm, mm_size, ps), + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_init(&mm, mm_size, ps), "buddy_init failed\n"); bias_start = round_up(prandom_u32_state(&prng) % (mm_size - ps), ps); @@ -290,10 +290,10 @@ static void drm_test_buddy_alloc_range_bias(struct kunit *test) u32 size = max(round_up(prandom_u32_state(&prng) % bias_rem, ps), ps); KUNIT_ASSERT_FALSE_MSG(test, - drm_buddy_alloc_blocks(&mm, bias_start, + gpu_buddy_alloc_blocks(&mm, bias_start, bias_end, size, ps, &allocated, - DRM_BUDDY_RANGE_ALLOCATION), + GPU_BUDDY_RANGE_ALLOCATION), "buddy_alloc failed with bias(%x-%x), size=%u, ps=%u\n", bias_start, bias_end, size, ps); bias_rem -= size; @@ -319,24 +319,24 @@ static void drm_test_buddy_alloc_range_bias(struct kunit *test) KUNIT_ASSERT_EQ(test, bias_start, 0); KUNIT_ASSERT_EQ(test, bias_end, mm_size); KUNIT_ASSERT_TRUE_MSG(test, - drm_buddy_alloc_blocks(&mm, bias_start, bias_end, + gpu_buddy_alloc_blocks(&mm, bias_start, bias_end, ps, ps, &allocated, - DRM_BUDDY_RANGE_ALLOCATION), + GPU_BUDDY_RANGE_ALLOCATION), "buddy_alloc passed with bias(%x-%x), size=%u\n", bias_start, bias_end, ps); - drm_buddy_free_list(&mm, &allocated, 0); - drm_buddy_fini(&mm); + gpu_buddy_free_list(&mm, &allocated, 0); + gpu_buddy_fini(&mm); /* - * Allocate cleared blocks in the bias range when the DRM buddy's clear avail is + * Allocate cleared blocks in the bias range when the GPU buddy's clear avail is * zero. This will validate the bias range allocation in scenarios like system boot * when no cleared blocks are available and exercise the fallback path too. The resulting * blocks should always be dirty. */ - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_init(&mm, mm_size, ps), + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_init(&mm, mm_size, ps), "buddy_init failed\n"); bias_start = round_up(prandom_u32_state(&prng) % (mm_size - ps), ps); @@ -344,11 +344,11 @@ static void drm_test_buddy_alloc_range_bias(struct kunit *test) bias_end = max(bias_end, bias_start + ps); bias_rem = bias_end - bias_start; - flags = DRM_BUDDY_CLEAR_ALLOCATION | DRM_BUDDY_RANGE_ALLOCATION; + flags = GPU_BUDDY_CLEAR_ALLOCATION | GPU_BUDDY_RANGE_ALLOCATION; size = max(round_up(prandom_u32_state(&prng) % bias_rem, ps), ps); KUNIT_ASSERT_FALSE_MSG(test, - drm_buddy_alloc_blocks(&mm, bias_start, + gpu_buddy_alloc_blocks(&mm, bias_start, bias_end, size, ps, &allocated, flags), @@ -356,27 +356,27 @@ static void drm_test_buddy_alloc_range_bias(struct kunit *test) bias_start, bias_end, size, ps); list_for_each_entry(block, &allocated, link) - KUNIT_EXPECT_EQ(test, drm_buddy_block_is_clear(block), false); + KUNIT_EXPECT_EQ(test, gpu_buddy_block_is_clear(block), false); - drm_buddy_free_list(&mm, &allocated, 0); - drm_buddy_fini(&mm); + gpu_buddy_free_list(&mm, &allocated, 0); + gpu_buddy_fini(&mm); } -static void drm_test_buddy_alloc_clear(struct kunit *test) +static void gpu_test_buddy_alloc_clear(struct kunit *test) { unsigned long n_pages, total, i = 0; const unsigned long ps = SZ_4K; - struct drm_buddy_block *block; + struct gpu_buddy_block *block; const int max_order = 12; LIST_HEAD(allocated); - struct drm_buddy mm; + struct gpu_buddy mm; unsigned int order; u32 mm_size, size; LIST_HEAD(dirty); LIST_HEAD(clean); mm_size = SZ_4K << max_order; - KUNIT_EXPECT_FALSE(test, drm_buddy_init(&mm, mm_size, ps)); + KUNIT_EXPECT_FALSE(test, gpu_buddy_init(&mm, mm_size, ps)); KUNIT_EXPECT_EQ(test, mm.max_order, max_order); @@ -389,11 +389,11 @@ static void drm_test_buddy_alloc_clear(struct kunit *test) * is indeed all dirty pages and vice versa. Free it all again, * keeping the dirty/clear status. */ - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, mm_size, 5 * ps, ps, &allocated, - DRM_BUDDY_TOPDOWN_ALLOCATION), + GPU_BUDDY_TOPDOWN_ALLOCATION), "buddy_alloc hit an error size=%lu\n", 5 * ps); - drm_buddy_free_list(&mm, &allocated, DRM_BUDDY_CLEARED); + gpu_buddy_free_list(&mm, &allocated, GPU_BUDDY_CLEARED); n_pages = 10; do { @@ -406,37 +406,37 @@ static void drm_test_buddy_alloc_clear(struct kunit *test) flags = 0; } else { list = &clean; - flags = DRM_BUDDY_CLEAR_ALLOCATION; + flags = GPU_BUDDY_CLEAR_ALLOCATION; } - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, mm_size, ps, ps, list, flags), "buddy_alloc hit an error size=%lu\n", ps); } while (++i < n_pages); list_for_each_entry(block, &clean, link) - KUNIT_EXPECT_EQ(test, drm_buddy_block_is_clear(block), true); + KUNIT_EXPECT_EQ(test, gpu_buddy_block_is_clear(block), true); list_for_each_entry(block, &dirty, link) - KUNIT_EXPECT_EQ(test, drm_buddy_block_is_clear(block), false); + KUNIT_EXPECT_EQ(test, gpu_buddy_block_is_clear(block), false); - drm_buddy_free_list(&mm, &clean, DRM_BUDDY_CLEARED); + gpu_buddy_free_list(&mm, &clean, GPU_BUDDY_CLEARED); /* * Trying to go over the clear limit for some allocation. * The allocation should never fail with reasonable page-size. */ - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, mm_size, 10 * ps, ps, &clean, - DRM_BUDDY_CLEAR_ALLOCATION), + GPU_BUDDY_CLEAR_ALLOCATION), "buddy_alloc hit an error size=%lu\n", 10 * ps); - drm_buddy_free_list(&mm, &clean, DRM_BUDDY_CLEARED); - drm_buddy_free_list(&mm, &dirty, 0); - drm_buddy_fini(&mm); + gpu_buddy_free_list(&mm, &clean, GPU_BUDDY_CLEARED); + gpu_buddy_free_list(&mm, &dirty, 0); + gpu_buddy_fini(&mm); - KUNIT_EXPECT_FALSE(test, drm_buddy_init(&mm, mm_size, ps)); + KUNIT_EXPECT_FALSE(test, gpu_buddy_init(&mm, mm_size, ps)); /* * Create a new mm. Intentionally fragment the address space by creating @@ -458,34 +458,34 @@ static void drm_test_buddy_alloc_clear(struct kunit *test) else list = &clean; - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, mm_size, ps, ps, list, 0), "buddy_alloc hit an error size=%lu\n", ps); } while (++i < n_pages); - drm_buddy_free_list(&mm, &clean, DRM_BUDDY_CLEARED); - drm_buddy_free_list(&mm, &dirty, 0); + gpu_buddy_free_list(&mm, &clean, GPU_BUDDY_CLEARED); + gpu_buddy_free_list(&mm, &dirty, 0); order = 1; do { size = SZ_4K << order; - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, mm_size, size, size, &allocated, - DRM_BUDDY_CLEAR_ALLOCATION), + GPU_BUDDY_CLEAR_ALLOCATION), "buddy_alloc hit an error size=%u\n", size); total = 0; list_for_each_entry(block, &allocated, link) { if (size != mm_size) - KUNIT_EXPECT_EQ(test, drm_buddy_block_is_clear(block), false); - total += drm_buddy_block_size(&mm, block); + KUNIT_EXPECT_EQ(test, gpu_buddy_block_is_clear(block), false); + total += gpu_buddy_block_size(&mm, block); } KUNIT_EXPECT_EQ(test, total, size); - drm_buddy_free_list(&mm, &allocated, 0); + gpu_buddy_free_list(&mm, &allocated, 0); } while (++order <= max_order); - drm_buddy_fini(&mm); + gpu_buddy_fini(&mm); /* * Create a new mm with a non power-of-two size. Allocate a random size from each @@ -494,44 +494,44 @@ static void drm_test_buddy_alloc_clear(struct kunit *test) */ mm_size = (SZ_4K << max_order) + (SZ_4K << (max_order - 2)); - KUNIT_EXPECT_FALSE(test, drm_buddy_init(&mm, mm_size, ps)); + KUNIT_EXPECT_FALSE(test, gpu_buddy_init(&mm, mm_size, ps)); KUNIT_EXPECT_EQ(test, mm.max_order, max_order); - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, SZ_4K << max_order, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, SZ_4K << max_order, 4 * ps, ps, &allocated, - DRM_BUDDY_RANGE_ALLOCATION), + GPU_BUDDY_RANGE_ALLOCATION), "buddy_alloc hit an error size=%lu\n", 4 * ps); - drm_buddy_free_list(&mm, &allocated, DRM_BUDDY_CLEARED); - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, SZ_4K << max_order, + gpu_buddy_free_list(&mm, &allocated, GPU_BUDDY_CLEARED); + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, SZ_4K << max_order, 2 * ps, ps, &allocated, - DRM_BUDDY_CLEAR_ALLOCATION), + GPU_BUDDY_CLEAR_ALLOCATION), "buddy_alloc hit an error size=%lu\n", 2 * ps); - drm_buddy_free_list(&mm, &allocated, DRM_BUDDY_CLEARED); - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, SZ_4K << max_order, mm_size, + gpu_buddy_free_list(&mm, &allocated, GPU_BUDDY_CLEARED); + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, SZ_4K << max_order, mm_size, ps, ps, &allocated, - DRM_BUDDY_RANGE_ALLOCATION), + GPU_BUDDY_RANGE_ALLOCATION), "buddy_alloc hit an error size=%lu\n", ps); - drm_buddy_free_list(&mm, &allocated, DRM_BUDDY_CLEARED); - drm_buddy_fini(&mm); + gpu_buddy_free_list(&mm, &allocated, GPU_BUDDY_CLEARED); + gpu_buddy_fini(&mm); } -static void drm_test_buddy_alloc_contiguous(struct kunit *test) +static void gpu_test_buddy_alloc_contiguous(struct kunit *test) { const unsigned long ps = SZ_4K, mm_size = 16 * 3 * SZ_4K; unsigned long i, n_pages, total; - struct drm_buddy_block *block; - struct drm_buddy mm; + struct gpu_buddy_block *block; + struct gpu_buddy mm; LIST_HEAD(left); LIST_HEAD(middle); LIST_HEAD(right); LIST_HEAD(allocated); - KUNIT_EXPECT_FALSE(test, drm_buddy_init(&mm, mm_size, ps)); + KUNIT_EXPECT_FALSE(test, gpu_buddy_init(&mm, mm_size, ps)); /* * Idea is to fragment the address space by alternating block * allocations between three different lists; one for left, middle and * right. We can then free a list to simulate fragmentation. In - * particular we want to exercise the DRM_BUDDY_CONTIGUOUS_ALLOCATION, + * particular we want to exercise the GPU_BUDDY_CONTIGUOUS_ALLOCATION, * including the try_harder path. */ @@ -548,66 +548,66 @@ static void drm_test_buddy_alloc_contiguous(struct kunit *test) else list = &right; KUNIT_ASSERT_FALSE_MSG(test, - drm_buddy_alloc_blocks(&mm, 0, mm_size, + gpu_buddy_alloc_blocks(&mm, 0, mm_size, ps, ps, list, 0), "buddy_alloc hit an error size=%lu\n", ps); } while (++i < n_pages); - KUNIT_ASSERT_TRUE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size, + KUNIT_ASSERT_TRUE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, mm_size, 3 * ps, ps, &allocated, - DRM_BUDDY_CONTIGUOUS_ALLOCATION), + GPU_BUDDY_CONTIGUOUS_ALLOCATION), "buddy_alloc didn't error size=%lu\n", 3 * ps); - drm_buddy_free_list(&mm, &middle, 0); - KUNIT_ASSERT_TRUE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size, + gpu_buddy_free_list(&mm, &middle, 0); + KUNIT_ASSERT_TRUE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, mm_size, 3 * ps, ps, &allocated, - DRM_BUDDY_CONTIGUOUS_ALLOCATION), + GPU_BUDDY_CONTIGUOUS_ALLOCATION), "buddy_alloc didn't error size=%lu\n", 3 * ps); - KUNIT_ASSERT_TRUE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size, + KUNIT_ASSERT_TRUE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, mm_size, 2 * ps, ps, &allocated, - DRM_BUDDY_CONTIGUOUS_ALLOCATION), + GPU_BUDDY_CONTIGUOUS_ALLOCATION), "buddy_alloc didn't error size=%lu\n", 2 * ps); - drm_buddy_free_list(&mm, &right, 0); - KUNIT_ASSERT_TRUE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size, + gpu_buddy_free_list(&mm, &right, 0); + KUNIT_ASSERT_TRUE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, mm_size, 3 * ps, ps, &allocated, - DRM_BUDDY_CONTIGUOUS_ALLOCATION), + GPU_BUDDY_CONTIGUOUS_ALLOCATION), "buddy_alloc didn't error size=%lu\n", 3 * ps); /* * At this point we should have enough contiguous space for 2 blocks, * however they are never buddies (since we freed middle and right) so * will require the try_harder logic to find them. */ - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, mm_size, 2 * ps, ps, &allocated, - DRM_BUDDY_CONTIGUOUS_ALLOCATION), + GPU_BUDDY_CONTIGUOUS_ALLOCATION), "buddy_alloc hit an error size=%lu\n", 2 * ps); - drm_buddy_free_list(&mm, &left, 0); - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size, + gpu_buddy_free_list(&mm, &left, 0); + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, 0, mm_size, 3 * ps, ps, &allocated, - DRM_BUDDY_CONTIGUOUS_ALLOCATION), + GPU_BUDDY_CONTIGUOUS_ALLOCATION), "buddy_alloc hit an error size=%lu\n", 3 * ps); total = 0; list_for_each_entry(block, &allocated, link) - total += drm_buddy_block_size(&mm, block); + total += gpu_buddy_block_size(&mm, block); KUNIT_ASSERT_EQ(test, total, ps * 2 + ps * 3); - drm_buddy_free_list(&mm, &allocated, 0); - drm_buddy_fini(&mm); + gpu_buddy_free_list(&mm, &allocated, 0); + gpu_buddy_fini(&mm); } -static void drm_test_buddy_alloc_pathological(struct kunit *test) +static void gpu_test_buddy_alloc_pathological(struct kunit *test) { u64 mm_size, size, start = 0; - struct drm_buddy_block *block; + struct gpu_buddy_block *block; const int max_order = 3; unsigned long flags = 0; int order, top; - struct drm_buddy mm; + struct gpu_buddy mm; LIST_HEAD(blocks); LIST_HEAD(holes); LIST_HEAD(tmp); @@ -620,7 +620,7 @@ static void drm_test_buddy_alloc_pathological(struct kunit *test) */ mm_size = SZ_4K << max_order; - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_init(&mm, mm_size, SZ_4K), + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_init(&mm, mm_size, SZ_4K), "buddy_init failed\n"); KUNIT_EXPECT_EQ(test, mm.max_order, max_order); @@ -630,18 +630,18 @@ static void drm_test_buddy_alloc_pathological(struct kunit *test) block = list_first_entry_or_null(&blocks, typeof(*block), link); if (block) { list_del(&block->link); - drm_buddy_free_block(&mm, block); + gpu_buddy_free_block(&mm, block); } for (order = top; order--;) { size = get_size(order, mm.chunk_size); - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, start, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, start, mm_size, size, size, &tmp, flags), "buddy_alloc hit -ENOMEM with order=%d, top=%d\n", order, top); - block = list_first_entry_or_null(&tmp, struct drm_buddy_block, link); + block = list_first_entry_or_null(&tmp, struct gpu_buddy_block, link); KUNIT_ASSERT_TRUE_MSG(test, block, "alloc_blocks has no blocks\n"); list_move_tail(&block->link, &blocks); @@ -649,45 +649,45 @@ static void drm_test_buddy_alloc_pathological(struct kunit *test) /* There should be one final page for this sub-allocation */ size = get_size(0, mm.chunk_size); - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, start, mm_size, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, start, mm_size, size, size, &tmp, flags), "buddy_alloc hit -ENOMEM for hole\n"); - block = list_first_entry_or_null(&tmp, struct drm_buddy_block, link); + block = list_first_entry_or_null(&tmp, struct gpu_buddy_block, link); KUNIT_ASSERT_TRUE_MSG(test, block, "alloc_blocks has no blocks\n"); list_move_tail(&block->link, &holes); size = get_size(top, mm.chunk_size); - KUNIT_ASSERT_TRUE_MSG(test, drm_buddy_alloc_blocks(&mm, start, mm_size, + KUNIT_ASSERT_TRUE_MSG(test, gpu_buddy_alloc_blocks(&mm, start, mm_size, size, size, &tmp, flags), "buddy_alloc unexpectedly succeeded at top-order %d/%d, it should be full!", top, max_order); } - drm_buddy_free_list(&mm, &holes, 0); + gpu_buddy_free_list(&mm, &holes, 0); /* Nothing larger than blocks of chunk_size now available */ for (order = 1; order <= max_order; order++) { size = get_size(order, mm.chunk_size); - KUNIT_ASSERT_TRUE_MSG(test, drm_buddy_alloc_blocks(&mm, start, mm_size, + KUNIT_ASSERT_TRUE_MSG(test, gpu_buddy_alloc_blocks(&mm, start, mm_size, size, size, &tmp, flags), "buddy_alloc unexpectedly succeeded at order %d, it should be full!", order); } list_splice_tail(&holes, &blocks); - drm_buddy_free_list(&mm, &blocks, 0); - drm_buddy_fini(&mm); + gpu_buddy_free_list(&mm, &blocks, 0); + gpu_buddy_fini(&mm); } -static void drm_test_buddy_alloc_pessimistic(struct kunit *test) +static void gpu_test_buddy_alloc_pessimistic(struct kunit *test) { u64 mm_size, size, start = 0; - struct drm_buddy_block *block, *bn; + struct gpu_buddy_block *block, *bn; const unsigned int max_order = 16; unsigned long flags = 0; - struct drm_buddy mm; + struct gpu_buddy mm; unsigned int order; LIST_HEAD(blocks); LIST_HEAD(tmp); @@ -699,19 +699,19 @@ static void drm_test_buddy_alloc_pessimistic(struct kunit *test) */ mm_size = SZ_4K << max_order; - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_init(&mm, mm_size, SZ_4K), + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_init(&mm, mm_size, SZ_4K), "buddy_init failed\n"); KUNIT_EXPECT_EQ(test, mm.max_order, max_order); for (order = 0; order < max_order; order++) { size = get_size(order, mm.chunk_size); - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, start, mm_size, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, start, mm_size, size, size, &tmp, flags), "buddy_alloc hit -ENOMEM with order=%d\n", order); - block = list_first_entry_or_null(&tmp, struct drm_buddy_block, link); + block = list_first_entry_or_null(&tmp, struct gpu_buddy_block, link); KUNIT_ASSERT_TRUE_MSG(test, block, "alloc_blocks has no blocks\n"); list_move_tail(&block->link, &blocks); @@ -719,11 +719,11 @@ static void drm_test_buddy_alloc_pessimistic(struct kunit *test) /* And now the last remaining block available */ size = get_size(0, mm.chunk_size); - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, start, mm_size, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, start, mm_size, size, size, &tmp, flags), "buddy_alloc hit -ENOMEM on final alloc\n"); - block = list_first_entry_or_null(&tmp, struct drm_buddy_block, link); + block = list_first_entry_or_null(&tmp, struct gpu_buddy_block, link); KUNIT_ASSERT_TRUE_MSG(test, block, "alloc_blocks has no blocks\n"); list_move_tail(&block->link, &blocks); @@ -731,58 +731,58 @@ static void drm_test_buddy_alloc_pessimistic(struct kunit *test) /* Should be completely full! */ for (order = max_order; order--;) { size = get_size(order, mm.chunk_size); - KUNIT_ASSERT_TRUE_MSG(test, drm_buddy_alloc_blocks(&mm, start, mm_size, + KUNIT_ASSERT_TRUE_MSG(test, gpu_buddy_alloc_blocks(&mm, start, mm_size, size, size, &tmp, flags), "buddy_alloc unexpectedly succeeded, it should be full!"); } block = list_last_entry(&blocks, typeof(*block), link); list_del(&block->link); - drm_buddy_free_block(&mm, block); + gpu_buddy_free_block(&mm, block); /* As we free in increasing size, we make available larger blocks */ order = 1; list_for_each_entry_safe(block, bn, &blocks, link) { list_del(&block->link); - drm_buddy_free_block(&mm, block); + gpu_buddy_free_block(&mm, block); size = get_size(order, mm.chunk_size); - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, start, mm_size, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, start, mm_size, size, size, &tmp, flags), "buddy_alloc hit -ENOMEM with order=%d\n", order); - block = list_first_entry_or_null(&tmp, struct drm_buddy_block, link); + block = list_first_entry_or_null(&tmp, struct gpu_buddy_block, link); KUNIT_ASSERT_TRUE_MSG(test, block, "alloc_blocks has no blocks\n"); list_del(&block->link); - drm_buddy_free_block(&mm, block); + gpu_buddy_free_block(&mm, block); order++; } /* To confirm, now the whole mm should be available */ size = get_size(max_order, mm.chunk_size); - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, start, mm_size, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, start, mm_size, size, size, &tmp, flags), "buddy_alloc (realloc) hit -ENOMEM with order=%d\n", max_order); - block = list_first_entry_or_null(&tmp, struct drm_buddy_block, link); + block = list_first_entry_or_null(&tmp, struct gpu_buddy_block, link); KUNIT_ASSERT_TRUE_MSG(test, block, "alloc_blocks has no blocks\n"); list_del(&block->link); - drm_buddy_free_block(&mm, block); - drm_buddy_free_list(&mm, &blocks, 0); - drm_buddy_fini(&mm); + gpu_buddy_free_block(&mm, block); + gpu_buddy_free_list(&mm, &blocks, 0); + gpu_buddy_fini(&mm); } -static void drm_test_buddy_alloc_optimistic(struct kunit *test) +static void gpu_test_buddy_alloc_optimistic(struct kunit *test) { u64 mm_size, size, start = 0; - struct drm_buddy_block *block; + struct gpu_buddy_block *block; unsigned long flags = 0; const int max_order = 16; - struct drm_buddy mm; + struct gpu_buddy mm; LIST_HEAD(blocks); LIST_HEAD(tmp); int order; @@ -794,19 +794,19 @@ static void drm_test_buddy_alloc_optimistic(struct kunit *test) mm_size = SZ_4K * ((1 << (max_order + 1)) - 1); - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_init(&mm, mm_size, SZ_4K), + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_init(&mm, mm_size, SZ_4K), "buddy_init failed\n"); KUNIT_EXPECT_EQ(test, mm.max_order, max_order); for (order = 0; order <= max_order; order++) { size = get_size(order, mm.chunk_size); - KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, start, mm_size, + KUNIT_ASSERT_FALSE_MSG(test, gpu_buddy_alloc_blocks(&mm, start, mm_size, size, size, &tmp, flags), "buddy_alloc hit -ENOMEM with order=%d\n", order); - block = list_first_entry_or_null(&tmp, struct drm_buddy_block, link); + block = list_first_entry_or_null(&tmp, struct gpu_buddy_block, link); KUNIT_ASSERT_TRUE_MSG(test, block, "alloc_blocks has no blocks\n"); list_move_tail(&block->link, &blocks); @@ -814,80 +814,80 @@ static void drm_test_buddy_alloc_optimistic(struct kunit *test) /* Should be completely full! */ size = get_size(0, mm.chunk_size); - KUNIT_ASSERT_TRUE_MSG(test, drm_buddy_alloc_blocks(&mm, start, mm_size, + KUNIT_ASSERT_TRUE_MSG(test, gpu_buddy_alloc_blocks(&mm, start, mm_size, size, size, &tmp, flags), "buddy_alloc unexpectedly succeeded, it should be full!"); - drm_buddy_free_list(&mm, &blocks, 0); - drm_buddy_fini(&mm); + gpu_buddy_free_list(&mm, &blocks, 0); + gpu_buddy_fini(&mm); } -static void drm_test_buddy_alloc_limit(struct kunit *test) +static void gpu_test_buddy_alloc_limit(struct kunit *test) { u64 size = U64_MAX, start = 0; - struct drm_buddy_block *block; + struct gpu_buddy_block *block; unsigned long flags = 0; LIST_HEAD(allocated); - struct drm_buddy mm; + struct gpu_buddy mm; - KUNIT_EXPECT_FALSE(test, drm_buddy_init(&mm, size, SZ_4K)); + KUNIT_EXPECT_FALSE(test, gpu_buddy_init(&mm, size, SZ_4K)); - KUNIT_EXPECT_EQ_MSG(test, mm.max_order, DRM_BUDDY_MAX_ORDER, + KUNIT_EXPECT_EQ_MSG(test, mm.max_order, GPU_BUDDY_MAX_ORDER, "mm.max_order(%d) != %d\n", mm.max_order, - DRM_BUDDY_MAX_ORDER); + GPU_BUDDY_MAX_ORDER); size = mm.chunk_size << mm.max_order; - KUNIT_EXPECT_FALSE(test, drm_buddy_alloc_blocks(&mm, start, size, size, + KUNIT_EXPECT_FALSE(test, gpu_buddy_alloc_blocks(&mm, start, size, size, mm.chunk_size, &allocated, flags)); - block = list_first_entry_or_null(&allocated, struct drm_buddy_block, link); + block = list_first_entry_or_null(&allocated, struct gpu_buddy_block, link); KUNIT_EXPECT_TRUE(test, block); - KUNIT_EXPECT_EQ_MSG(test, drm_buddy_block_order(block), mm.max_order, + KUNIT_EXPECT_EQ_MSG(test, gpu_buddy_block_order(block), mm.max_order, "block order(%d) != %d\n", - drm_buddy_block_order(block), mm.max_order); + gpu_buddy_block_order(block), mm.max_order); - KUNIT_EXPECT_EQ_MSG(test, drm_buddy_block_size(&mm, block), + KUNIT_EXPECT_EQ_MSG(test, gpu_buddy_block_size(&mm, block), BIT_ULL(mm.max_order) * mm.chunk_size, "block size(%llu) != %llu\n", - drm_buddy_block_size(&mm, block), + gpu_buddy_block_size(&mm, block), BIT_ULL(mm.max_order) * mm.chunk_size); - drm_buddy_free_list(&mm, &allocated, 0); - drm_buddy_fini(&mm); + gpu_buddy_free_list(&mm, &allocated, 0); + gpu_buddy_fini(&mm); } -static int drm_buddy_suite_init(struct kunit_suite *suite) +static int gpu_buddy_suite_init(struct kunit_suite *suite) { while (!random_seed) random_seed = get_random_u32(); - kunit_info(suite, "Testing DRM buddy manager, with random_seed=0x%x\n", + kunit_info(suite, "Testing GPU buddy manager, with random_seed=0x%x\n", random_seed); return 0; } -static struct kunit_case drm_buddy_tests[] = { - KUNIT_CASE(drm_test_buddy_alloc_limit), - KUNIT_CASE(drm_test_buddy_alloc_optimistic), - KUNIT_CASE(drm_test_buddy_alloc_pessimistic), - KUNIT_CASE(drm_test_buddy_alloc_pathological), - KUNIT_CASE(drm_test_buddy_alloc_contiguous), - KUNIT_CASE(drm_test_buddy_alloc_clear), - KUNIT_CASE(drm_test_buddy_alloc_range_bias), - KUNIT_CASE(drm_test_buddy_fragmentation_performance), +static struct kunit_case gpu_buddy_tests[] = { + KUNIT_CASE(gpu_test_buddy_alloc_limit), + KUNIT_CASE(gpu_test_buddy_alloc_optimistic), + KUNIT_CASE(gpu_test_buddy_alloc_pessimistic), + KUNIT_CASE(gpu_test_buddy_alloc_pathological), + KUNIT_CASE(gpu_test_buddy_alloc_contiguous), + KUNIT_CASE(gpu_test_buddy_alloc_clear), + KUNIT_CASE(gpu_test_buddy_alloc_range_bias), + KUNIT_CASE(gpu_test_buddy_fragmentation_performance), {} }; -static struct kunit_suite drm_buddy_test_suite = { - .name = "drm_buddy", - .suite_init = drm_buddy_suite_init, - .test_cases = drm_buddy_tests, +static struct kunit_suite gpu_buddy_test_suite = { + .name = "gpu_buddy", + .suite_init = gpu_buddy_suite_init, + .test_cases = gpu_buddy_tests, }; -kunit_test_suite(drm_buddy_test_suite); +kunit_test_suite(gpu_buddy_test_suite); MODULE_AUTHOR("Intel Corporation"); -MODULE_DESCRIPTION("Kunit test for drm_buddy functions"); +MODULE_DESCRIPTION("Kunit test for gpu_buddy functions"); MODULE_LICENSE("GPL"); diff --git a/drivers/gpu/tests/gpu_random.c b/drivers/gpu/tests/gpu_random.c new file mode 100644 index 000000000000..54f1f6a3a6c1 --- /dev/null +++ b/drivers/gpu/tests/gpu_random.c @@ -0,0 +1,48 @@ +// SPDX-License-Identifier: GPL-2.0 +#include <linux/bitops.h> +#include <linux/export.h> +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/random.h> +#include <linux/slab.h> +#include <linux/types.h> + +#include "gpu_random.h" + +u32 gpu_prandom_u32_max_state(u32 ep_ro, struct rnd_state *state) +{ + return upper_32_bits((u64)prandom_u32_state(state) * ep_ro); +} +EXPORT_SYMBOL(gpu_prandom_u32_max_state); + +void gpu_random_reorder(unsigned int *order, unsigned int count, + struct rnd_state *state) +{ + unsigned int i, j; + + for (i = 0; i < count; ++i) { + BUILD_BUG_ON(sizeof(unsigned int) > sizeof(u32)); + j = gpu_prandom_u32_max_state(count, state); + swap(order[i], order[j]); + } +} +EXPORT_SYMBOL(gpu_random_reorder); + +unsigned int *gpu_random_order(unsigned int count, struct rnd_state *state) +{ + unsigned int *order, i; + + order = kmalloc_array(count, sizeof(*order), GFP_KERNEL); + if (!order) + return order; + + for (i = 0; i < count; i++) + order[i] = i; + + gpu_random_reorder(order, count, state); + return order; +} +EXPORT_SYMBOL(gpu_random_order); + +MODULE_DESCRIPTION("GPU Randomization Utilities"); +MODULE_LICENSE("Dual MIT/GPL"); diff --git a/drivers/gpu/tests/gpu_random.h b/drivers/gpu/tests/gpu_random.h new file mode 100644 index 000000000000..b68cf3448264 --- /dev/null +++ b/drivers/gpu/tests/gpu_random.h @@ -0,0 +1,28 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef __GPU_RANDOM_H__ +#define __GPU_RANDOM_H__ + +/* This is a temporary home for a couple of utility functions that should + * be transposed to lib/ at the earliest convenience. + */ + +#include <linux/prandom.h> + +#define GPU_RND_STATE_INITIALIZER(seed__) ({ \ + struct rnd_state state__; \ + prandom_seed_state(&state__, (seed__)); \ + state__; \ +}) + +#define GPU_RND_STATE(name__, seed__) \ + struct rnd_state name__ = GPU_RND_STATE_INITIALIZER(seed__) + +unsigned int *gpu_random_order(unsigned int count, + struct rnd_state *state); +void gpu_random_reorder(unsigned int *order, + unsigned int count, + struct rnd_state *state); +u32 gpu_prandom_u32_max_state(u32 ep_ro, + struct rnd_state *state); + +#endif /* !__GPU_RANDOM_H__ */ diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig index d51777df12d1..6ae1383b0e2e 100644 --- a/drivers/video/Kconfig +++ b/drivers/video/Kconfig @@ -37,6 +37,8 @@ source "drivers/char/agp/Kconfig" source "drivers/gpu/vga/Kconfig" +source "drivers/gpu/Kconfig" + source "drivers/gpu/host1x/Kconfig" source "drivers/gpu/ipu-v3/Kconfig" source "drivers/gpu/nova-core/Kconfig" diff --git a/include/drm/drm_buddy.h b/include/drm/drm_buddy.h index b909fa8f810a..3054369bebff 100644 --- a/include/drm/drm_buddy.h +++ b/include/drm/drm_buddy.h @@ -6,166 +6,13 @@ #ifndef __DRM_BUDDY_H__ #define __DRM_BUDDY_H__ -#include <linux/bitops.h> -#include <linux/list.h> -#include <linux/slab.h> -#include <linux/sched.h> -#include <linux/rbtree.h> +#include <linux/gpu_buddy.h> struct drm_printer; -#define DRM_BUDDY_RANGE_ALLOCATION BIT(0) -#define DRM_BUDDY_TOPDOWN_ALLOCATION BIT(1) -#define DRM_BUDDY_CONTIGUOUS_ALLOCATION BIT(2) -#define DRM_BUDDY_CLEAR_ALLOCATION BIT(3) -#define DRM_BUDDY_CLEARED BIT(4) -#define DRM_BUDDY_TRIM_DISABLE BIT(5) - -struct drm_buddy_block { -#define DRM_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12) -#define DRM_BUDDY_HEADER_STATE GENMASK_ULL(11, 10) -#define DRM_BUDDY_ALLOCATED (1 << 10) -#define DRM_BUDDY_FREE (2 << 10) -#define DRM_BUDDY_SPLIT (3 << 10) -#define DRM_BUDDY_HEADER_CLEAR GENMASK_ULL(9, 9) -/* Free to be used, if needed in the future */ -#define DRM_BUDDY_HEADER_UNUSED GENMASK_ULL(8, 6) -#define DRM_BUDDY_HEADER_ORDER GENMASK_ULL(5, 0) - u64 header; - - struct drm_buddy_block *left; - struct drm_buddy_block *right; - struct drm_buddy_block *parent; - - void *private; /* owned by creator */ - - /* - * While the block is allocated by the user through drm_buddy_alloc*, - * the user has ownership of the link, for example to maintain within - * a list, if so desired. As soon as the block is freed with - * drm_buddy_free* ownership is given back to the mm. - */ - union { - struct rb_node rb; - struct list_head link; - }; - - struct list_head tmp_link; -}; - -/* Order-zero must be at least SZ_4K */ -#define DRM_BUDDY_MAX_ORDER (63 - 12) - -/* - * Binary Buddy System. - * - * Locking should be handled by the user, a simple mutex around - * drm_buddy_alloc* and drm_buddy_free* should suffice. - */ -struct drm_buddy { - /* Maintain a free list for each order. */ - struct rb_root **free_trees; - - /* - * Maintain explicit binary tree(s) to track the allocation of the - * address space. This gives us a simple way of finding a buddy block - * and performing the potentially recursive merge step when freeing a - * block. Nodes are either allocated or free, in which case they will - * also exist on the respective free list. - */ - struct drm_buddy_block **roots; - - /* - * Anything from here is public, and remains static for the lifetime of - * the mm. Everything above is considered do-not-touch. - */ - unsigned int n_roots; - unsigned int max_order; - - /* Must be at least SZ_4K */ - u64 chunk_size; - u64 size; - u64 avail; - u64 clear_avail; -}; - -static inline u64 -drm_buddy_block_offset(const struct drm_buddy_block *block) -{ - return block->header & DRM_BUDDY_HEADER_OFFSET; -} - -static inline unsigned int -drm_buddy_block_order(struct drm_buddy_block *block) -{ - return block->header & DRM_BUDDY_HEADER_ORDER; -} - -static inline unsigned int -drm_buddy_block_state(struct drm_buddy_block *block) -{ - return block->header & DRM_BUDDY_HEADER_STATE; -} - -static inline bool -drm_buddy_block_is_allocated(struct drm_buddy_block *block) -{ - return drm_buddy_block_state(block) == DRM_BUDDY_ALLOCATED; -} - -static inline bool -drm_buddy_block_is_clear(struct drm_buddy_block *block) -{ - return block->header & DRM_BUDDY_HEADER_CLEAR; -} - -static inline bool -drm_buddy_block_is_free(struct drm_buddy_block *block) -{ - return drm_buddy_block_state(block) == DRM_BUDDY_FREE; -} - -static inline bool -drm_buddy_block_is_split(struct drm_buddy_block *block) -{ - return drm_buddy_block_state(block) == DRM_BUDDY_SPLIT; -} - -static inline u64 -drm_buddy_block_size(struct drm_buddy *mm, - struct drm_buddy_block *block) -{ - return mm->chunk_size << drm_buddy_block_order(block); -} - -int drm_buddy_init(struct drm_buddy *mm, u64 size, u64 chunk_size); - -void drm_buddy_fini(struct drm_buddy *mm); - -struct drm_buddy_block * -drm_get_buddy(struct drm_buddy_block *block); - -int drm_buddy_alloc_blocks(struct drm_buddy *mm, - u64 start, u64 end, u64 size, - u64 min_page_size, - struct list_head *blocks, - unsigned long flags); - -int drm_buddy_block_trim(struct drm_buddy *mm, - u64 *start, - u64 new_size, - struct list_head *blocks); - -void drm_buddy_reset_clear(struct drm_buddy *mm, bool is_clear); - -void drm_buddy_free_block(struct drm_buddy *mm, struct drm_buddy_block *block); - -void drm_buddy_free_list(struct drm_buddy *mm, - struct list_head *objects, - unsigned int flags); - -void drm_buddy_print(struct drm_buddy *mm, struct drm_printer *p); -void drm_buddy_block_print(struct drm_buddy *mm, - struct drm_buddy_block *block, +/* DRM-specific GPU Buddy Allocator print helpers */ +void drm_buddy_print(struct gpu_buddy *mm, struct drm_printer *p); +void drm_buddy_block_print(struct gpu_buddy *mm, + struct gpu_buddy_block *block, struct drm_printer *p); #endif diff --git a/include/linux/gpu_buddy.h b/include/linux/gpu_buddy.h new file mode 100644 index 000000000000..3e4bd11ccb71 --- /dev/null +++ b/include/linux/gpu_buddy.h @@ -0,0 +1,177 @@ +/* SPDX-License-Identifier: MIT */ +/* + * Copyright © 2021 Intel Corporation + */ + +#ifndef __GPU_BUDDY_H__ +#define __GPU_BUDDY_H__ + +#include <linux/bitops.h> +#include <linux/list.h> +#include <linux/rbtree.h> +#include <linux/slab.h> +#include <linux/sched.h> + +#define GPU_BUDDY_RANGE_ALLOCATION BIT(0) +#define GPU_BUDDY_TOPDOWN_ALLOCATION BIT(1) +#define GPU_BUDDY_CONTIGUOUS_ALLOCATION BIT(2) +#define GPU_BUDDY_CLEAR_ALLOCATION BIT(3) +#define GPU_BUDDY_CLEARED BIT(4) +#define GPU_BUDDY_TRIM_DISABLE BIT(5) + +enum gpu_buddy_free_tree { + GPU_BUDDY_CLEAR_TREE = 0, + GPU_BUDDY_DIRTY_TREE, + GPU_BUDDY_MAX_FREE_TREES, +}; + +#define for_each_free_tree(tree) \ + for ((tree) = 0; (tree) < GPU_BUDDY_MAX_FREE_TREES; (tree)++) + +struct gpu_buddy_block { +#define GPU_BUDDY_HEADER_OFFSET GENMASK_ULL(63, 12) +#define GPU_BUDDY_HEADER_STATE GENMASK_ULL(11, 10) +#define GPU_BUDDY_ALLOCATED (1 << 10) +#define GPU_BUDDY_FREE (2 << 10) +#define GPU_BUDDY_SPLIT (3 << 10) +#define GPU_BUDDY_HEADER_CLEAR GENMASK_ULL(9, 9) +/* Free to be used, if needed in the future */ +#define GPU_BUDDY_HEADER_UNUSED GENMASK_ULL(8, 6) +#define GPU_BUDDY_HEADER_ORDER GENMASK_ULL(5, 0) + u64 header; + + struct gpu_buddy_block *left; + struct gpu_buddy_block *right; + struct gpu_buddy_block *parent; + + void *private; /* owned by creator */ + + /* + * While the block is allocated by the user through gpu_buddy_alloc*, + * the user has ownership of the link, for example to maintain within + * a list, if so desired. As soon as the block is freed with + * gpu_buddy_free* ownership is given back to the mm. + */ + union { + struct rb_node rb; + struct list_head link; + }; + + struct list_head tmp_link; +}; + +/* Order-zero must be at least SZ_4K */ +#define GPU_BUDDY_MAX_ORDER (63 - 12) + +/* + * Binary Buddy System. + * + * Locking should be handled by the user, a simple mutex around + * gpu_buddy_alloc* and gpu_buddy_free* should suffice. + */ +struct gpu_buddy { + /* Maintain a free list for each order. */ + struct rb_root **free_trees; + + /* + * Maintain explicit binary tree(s) to track the allocation of the + * address space. This gives us a simple way of finding a buddy block + * and performing the potentially recursive merge step when freeing a + * block. Nodes are either allocated or free, in which case they will + * also exist on the respective free list. + */ + struct gpu_buddy_block **roots; + + /* + * Anything from here is public, and remains static for the lifetime of + * the mm. Everything above is considered do-not-touch. + */ + unsigned int n_roots; + unsigned int max_order; + + /* Must be at least SZ_4K */ + u64 chunk_size; + u64 size; + u64 avail; + u64 clear_avail; +}; + +static inline u64 +gpu_buddy_block_offset(const struct gpu_buddy_block *block) +{ + return block->header & GPU_BUDDY_HEADER_OFFSET; +} + +static inline unsigned int +gpu_buddy_block_order(struct gpu_buddy_block *block) +{ + return block->header & GPU_BUDDY_HEADER_ORDER; +} + +static inline unsigned int +gpu_buddy_block_state(struct gpu_buddy_block *block) +{ + return block->header & GPU_BUDDY_HEADER_STATE; +} + +static inline bool +gpu_buddy_block_is_allocated(struct gpu_buddy_block *block) +{ + return gpu_buddy_block_state(block) == GPU_BUDDY_ALLOCATED; +} + +static inline bool +gpu_buddy_block_is_clear(struct gpu_buddy_block *block) +{ + return block->header & GPU_BUDDY_HEADER_CLEAR; +} + +static inline bool +gpu_buddy_block_is_free(struct gpu_buddy_block *block) +{ + return gpu_buddy_block_state(block) == GPU_BUDDY_FREE; +} + +static inline bool +gpu_buddy_block_is_split(struct gpu_buddy_block *block) +{ + return gpu_buddy_block_state(block) == GPU_BUDDY_SPLIT; +} + +static inline u64 +gpu_buddy_block_size(struct gpu_buddy *mm, + struct gpu_buddy_block *block) +{ + return mm->chunk_size << gpu_buddy_block_order(block); +} + +int gpu_buddy_init(struct gpu_buddy *mm, u64 size, u64 chunk_size); + +void gpu_buddy_fini(struct gpu_buddy *mm); + +struct gpu_buddy_block * +gpu_get_buddy(struct gpu_buddy_block *block); + +int gpu_buddy_alloc_blocks(struct gpu_buddy *mm, + u64 start, u64 end, u64 size, + u64 min_page_size, + struct list_head *blocks, + unsigned long flags); + +int gpu_buddy_block_trim(struct gpu_buddy *mm, + u64 *start, + u64 new_size, + struct list_head *blocks); + +void gpu_buddy_reset_clear(struct gpu_buddy *mm, bool is_clear); + +void gpu_buddy_free_block(struct gpu_buddy *mm, struct gpu_buddy_block *block); + +void gpu_buddy_free_list(struct gpu_buddy *mm, + struct list_head *objects, + unsigned int flags); + +void gpu_buddy_print(struct gpu_buddy *mm); +void gpu_buddy_block_print(struct gpu_buddy *mm, + struct gpu_buddy_block *block); +#endif -- 2.34.1 ^ permalink raw reply related [flat|nested] 23+ messages in thread
* [PATCH RFC v5 3/6] rust: gpu: Add GPU buddy allocator bindings 2025-12-19 20:37 ` Joel Fernandes @ 2025-12-19 20:38 ` Joel Fernandes -1 siblings, 0 replies; 23+ messages in thread From: Joel Fernandes @ 2025-12-19 20:38 UTC (permalink / raw) To: Maarten Lankhorst, Maxime Ripard, Thomas Zimmermann, David Airlie, Simona Vetter, Jonathan Corbet, Alex Deucher, Christian König, Jani Nikula, Joonas Lahtinen, Rodrigo Vivi, Tvrtko Ursulin, Huang Rui, Matthew Auld, Matthew Brost, Lucas De Marchi, Thomas Hellström, Helge Deller Cc: Danilo Krummrich, Alice Ryhl, Miguel Ojeda, Alex Gaynor, Boqun Feng, Gary Guo, Björn Roy Baron, Benno Lossin, Andreas Hindborg, Trevor Gross, John Hubbard, Alistair Popple, Timur Tabi, Edwin Peer, Alexandre Courbot, Andrea Righi, Philipp Stanner, Elle Rhumsaa, Daniel Almeida, joel, nouveau, dri-devel, rust-for-linux, linux-kernel, linux-doc, amd-gfx, intel-gfx, intel-xe, linux-fbdev, Joel Fernandes Add safe Rust abstractions over the Linux kernel's GPU buddy allocator for physical memory management. The GPU buddy allocator implements a binary buddy system for useful for GPU physical memory allocation. nova-core will use it for physical memory allocation. Signed-off-by: Joel Fernandes <joelagnelf@nvidia.com> --- rust/bindings/bindings_helper.h | 11 + rust/helpers/gpu.c | 23 ++ rust/helpers/helpers.c | 1 + rust/kernel/gpu/buddy.rs | 518 ++++++++++++++++++++++++++++++++ rust/kernel/gpu/mod.rs | 5 + rust/kernel/lib.rs | 2 + 6 files changed, 560 insertions(+) create mode 100644 rust/helpers/gpu.c create mode 100644 rust/kernel/gpu/buddy.rs create mode 100644 rust/kernel/gpu/mod.rs diff --git a/rust/bindings/bindings_helper.h b/rust/bindings/bindings_helper.h index a067038b4b42..940b854a1f93 100644 --- a/rust/bindings/bindings_helper.h +++ b/rust/bindings/bindings_helper.h @@ -29,6 +29,7 @@ #include <linux/hrtimer_types.h> #include <linux/acpi.h> +#include <linux/gpu_buddy.h> #include <drm/drm_device.h> #include <drm/drm_drv.h> #include <drm/drm_file.h> @@ -144,6 +145,16 @@ const vm_flags_t RUST_CONST_HELPER_VM_MIXEDMAP = VM_MIXEDMAP; const vm_flags_t RUST_CONST_HELPER_VM_HUGEPAGE = VM_HUGEPAGE; const vm_flags_t RUST_CONST_HELPER_VM_NOHUGEPAGE = VM_NOHUGEPAGE; +#if IS_ENABLED(CONFIG_GPU_BUDDY) +const unsigned long RUST_CONST_HELPER_GPU_BUDDY_RANGE_ALLOCATION = GPU_BUDDY_RANGE_ALLOCATION; +const unsigned long RUST_CONST_HELPER_GPU_BUDDY_TOPDOWN_ALLOCATION = GPU_BUDDY_TOPDOWN_ALLOCATION; +const unsigned long RUST_CONST_HELPER_GPU_BUDDY_CONTIGUOUS_ALLOCATION = + GPU_BUDDY_CONTIGUOUS_ALLOCATION; +const unsigned long RUST_CONST_HELPER_GPU_BUDDY_CLEAR_ALLOCATION = GPU_BUDDY_CLEAR_ALLOCATION; +const unsigned long RUST_CONST_HELPER_GPU_BUDDY_CLEARED = GPU_BUDDY_CLEARED; +const unsigned long RUST_CONST_HELPER_GPU_BUDDY_TRIM_DISABLE = GPU_BUDDY_TRIM_DISABLE; +#endif + #if IS_ENABLED(CONFIG_ANDROID_BINDER_IPC_RUST) #include "../../drivers/android/binder/rust_binder.h" #include "../../drivers/android/binder/rust_binder_events.h" diff --git a/rust/helpers/gpu.c b/rust/helpers/gpu.c new file mode 100644 index 000000000000..415836b86abf --- /dev/null +++ b/rust/helpers/gpu.c @@ -0,0 +1,23 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include <linux/gpu_buddy.h> + +#ifdef CONFIG_GPU_BUDDY + +u64 rust_helper_gpu_buddy_block_offset(const struct gpu_buddy_block *block) +{ + return gpu_buddy_block_offset(block); +} + +unsigned int rust_helper_gpu_buddy_block_order(struct gpu_buddy_block *block) +{ + return gpu_buddy_block_order(block); +} + +u64 rust_helper_gpu_buddy_block_size(struct gpu_buddy *mm, + struct gpu_buddy_block *block) +{ + return gpu_buddy_block_size(mm, block); +} + +#endif /* CONFIG_GPU_BUDDY */ diff --git a/rust/helpers/helpers.c b/rust/helpers/helpers.c index 634fa2386bbb..6db7c4c25afa 100644 --- a/rust/helpers/helpers.c +++ b/rust/helpers/helpers.c @@ -29,6 +29,7 @@ #include "err.c" #include "irq.c" #include "fs.c" +#include "gpu.c" #include "io.c" #include "jump_label.c" #include "kunit.c" diff --git a/rust/kernel/gpu/buddy.rs b/rust/kernel/gpu/buddy.rs new file mode 100644 index 000000000000..d75303baf4ec --- /dev/null +++ b/rust/kernel/gpu/buddy.rs @@ -0,0 +1,518 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! GPU buddy allocator bindings. +//! +//! C header: [`include/linux/gpu_buddy.h`](srctree/include/linux/gpu_buddy.h) +//! +//! This module provides Rust abstractions over the Linux kernel's GPU buddy +//! allocator, which implements a binary buddy memory allocator. +//! +//! The buddy allocator manages a contiguous address space and allocates blocks +//! in power-of-two sizes, useful for GPU physical memory management. +//! +//! # Examples +//! +//! ``` +//! use kernel::{ +//! gpu::buddy::{BuddyFlags, GpuBuddy, GpuBuddyAllocParams, GpuBuddyParams}, +//! prelude::*, +//! sizes::*, // +//! }; +//! +//! // Create a 1GB buddy allocator with 4KB minimum chunk size. +//! let mut buddy = GpuBuddy::new(GpuBuddyParams { +//! physical_memory_size_bytes: SZ_1G as u64, +//! chunk_size_bytes: SZ_4K as u64, +//! })?; +//! +//! // Verify initial state. +//! assert_eq!(buddy.size(), SZ_1G as u64); +//! assert_eq!(buddy.chunk_size(), SZ_4K as u64); +//! let initial_free = buddy.free_memory_bytes(); +//! +//! // Base allocation params - reused across tests with field overrides. +//! let params = GpuBuddyAllocParams { +//! start_range_address: 0, +//! end_range_address: 0, // Entire range. +//! size_bytes: SZ_16M as u64, +//! min_block_size_bytes: SZ_16M as u64, +//! buddy_flags: BuddyFlags::try_new(BuddyFlags::RANGE_ALLOCATION)?, +//! }; +//! +//! // Test top-down allocation (allocates from highest addresses). +//! let topdown = buddy.alloc_blocks(GpuBuddyAllocParams { +//! buddy_flags: BuddyFlags::try_new(BuddyFlags::TOPDOWN_ALLOCATION)?, +//! ..params +//! })?; +//! assert_eq!(buddy.free_memory_bytes(), initial_free - SZ_16M as u64); +//! +//! for block in topdown.iter() { +//! assert_eq!(block.offset(), (SZ_1G - SZ_16M) as u64); +//! assert_eq!(block.order(), 12); // 2^12 pages +//! assert_eq!(block.size(), SZ_16M as u64); +//! } +//! drop(topdown); +//! assert_eq!(buddy.free_memory_bytes(), initial_free); +//! +//! // Allocate 16MB - should result in a single 16MB block at offset 0. +//! let allocated = buddy.alloc_blocks(params)?; +//! assert_eq!(buddy.free_memory_bytes(), initial_free - SZ_16M as u64); +//! +//! for block in allocated.iter() { +//! assert_eq!(block.offset(), 0); +//! assert_eq!(block.order(), 12); // 2^12 pages +//! assert_eq!(block.size(), SZ_16M as u64); +//! } +//! drop(allocated); +//! assert_eq!(buddy.free_memory_bytes(), initial_free); +//! +//! // Test non-contiguous allocation with fragmented memory. +//! // Create fragmentation by allocating 4MB blocks at [0,4M) and [8M,12M). +//! let params_4m = GpuBuddyAllocParams { +//! end_range_address: SZ_4M as u64, +//! size_bytes: SZ_4M as u64, +//! min_block_size_bytes: SZ_4M as u64, +//! ..params +//! }; +//! let frag1 = buddy.alloc_blocks(params_4m)?; +//! assert_eq!(buddy.free_memory_bytes(), initial_free - SZ_4M as u64); +//! +//! let frag2 = buddy.alloc_blocks(GpuBuddyAllocParams { +//! start_range_address: SZ_8M as u64, +//! end_range_address: (SZ_8M + SZ_4M) as u64, +//! ..params_4m +//! })?; +//! assert_eq!(buddy.free_memory_bytes(), initial_free - SZ_8M as u64); +//! +//! // Allocate 8MB without CONTIGUOUS - should return 2 blocks from the holes. +//! let fragmented = buddy.alloc_blocks(GpuBuddyAllocParams { +//! end_range_address: SZ_16M as u64, +//! size_bytes: SZ_8M as u64, +//! min_block_size_bytes: SZ_4M as u64, +//! ..params +//! })?; +//! assert_eq!(buddy.free_memory_bytes(), initial_free - (SZ_16M) as u64); +//! +//! let (mut count, mut total) = (0u32, 0u64); +//! for block in fragmented.iter() { +//! // The 8MB allocation should return 2 blocks, each 4MB. +//! assert_eq!(block.size(), SZ_4M as u64); +//! total += block.size(); +//! count += 1; +//! } +//! assert_eq!(total, SZ_8M as u64); +//! assert_eq!(count, 2); +//! drop(fragmented); +//! drop(frag2); +//! drop(frag1); +//! assert_eq!(buddy.free_memory_bytes(), initial_free); +//! +//! // Test CONTIGUOUS failure when only fragmented space available. +//! // Create a small buddy allocator with only 16MB of memory. +//! let mut small = GpuBuddy::new(GpuBuddyParams { +//! physical_memory_size_bytes: SZ_16M as u64, +//! chunk_size_bytes: SZ_4K as u64, +//! })?; +//! +//! // Allocate 4MB blocks at [0,4M) and [8M,12M) to create fragmented memory. +//! let hole1 = small.alloc_blocks(params_4m)?; +//! let hole2 = small.alloc_blocks(GpuBuddyAllocParams { +//! start_range_address: SZ_8M as u64, +//! end_range_address: (SZ_8M + SZ_4M) as u64, +//! ..params_4m +//! })?; +//! +//! // 8MB contiguous should fail - only two non-contiguous 4MB holes exist. +//! let result = small.alloc_blocks(GpuBuddyAllocParams { +//! size_bytes: SZ_8M as u64, +//! min_block_size_bytes: SZ_4M as u64, +//! buddy_flags: BuddyFlags::try_new(BuddyFlags::CONTIGUOUS_ALLOCATION)?, +//! ..params +//! }); +//! assert!(result.is_err()); +//! drop(hole2); +//! drop(hole1); +//! +//! # Ok::<(), Error>(()) +//! ``` + +use crate::{ + bindings, + clist::CListHead, + clist_create, + error::to_result, + new_mutex, + prelude::*, + sync::{ + lock::mutex::MutexGuard, + Arc, + Mutex, // + }, + types::Opaque, +}; + +/// Flags for GPU buddy allocator operations. +/// +/// These flags control the allocation behavior of the buddy allocator. +#[derive(Clone, Copy, Default, PartialEq, Eq)] +pub struct BuddyFlags(usize); + +impl BuddyFlags { + /// Range-based allocation from start to end addresses. + pub const RANGE_ALLOCATION: usize = bindings::GPU_BUDDY_RANGE_ALLOCATION; + + /// Allocate from top of address space downward. + pub const TOPDOWN_ALLOCATION: usize = bindings::GPU_BUDDY_TOPDOWN_ALLOCATION; + + /// Allocate physically contiguous blocks. + pub const CONTIGUOUS_ALLOCATION: usize = bindings::GPU_BUDDY_CONTIGUOUS_ALLOCATION; + + /// Request allocation from the cleared (zeroed) memory. The zero'ing is not + /// done by the allocator, but by the caller before freeing old blocks. + pub const CLEAR_ALLOCATION: usize = bindings::GPU_BUDDY_CLEAR_ALLOCATION; + + /// Disable trimming of partially used blocks. + pub const TRIM_DISABLE: usize = bindings::GPU_BUDDY_TRIM_DISABLE; + + /// Mark blocks as cleared (zeroed) when freeing. When set during free, + /// indicates that the caller has already zeroed the memory. + pub const CLEARED: usize = bindings::GPU_BUDDY_CLEARED; + + /// Create [`BuddyFlags`] from a raw value with validation. + /// + /// Use `|` operator to combine flags if needed, before calling this method. + pub fn try_new(flags: usize) -> Result<Self> { + // Flags must not exceed u32::MAX to satisfy the GPU buddy allocator C API. + if flags > u32::MAX as usize { + return Err(EINVAL); + } + + // `TOPDOWN_ALLOCATION` only works without `RANGE_ALLOCATION`. When both are + // set, `TOPDOWN_ALLOCATION` is silently ignored by the allocator. Reject this. + if (flags & Self::RANGE_ALLOCATION) != 0 && (flags & Self::TOPDOWN_ALLOCATION) != 0 { + return Err(EINVAL); + } + + Ok(Self(flags)) + } + + /// Get raw value of the flags. + pub(crate) fn as_raw(self) -> usize { + self.0 + } +} + +/// Parameters for creating a GPU buddy allocator. +#[derive(Clone, Copy)] +pub struct GpuBuddyParams { + /// Total physical memory size managed by the allocator in bytes. + pub physical_memory_size_bytes: u64, + /// Minimum allocation unit / chunk size in bytes, must be >= 4KB. + pub chunk_size_bytes: u64, +} + +/// Parameters for allocating blocks from a GPU buddy allocator. +#[derive(Clone, Copy)] +pub struct GpuBuddyAllocParams { + /// Start of allocation range in bytes. Use 0 for beginning. + pub start_range_address: u64, + /// End of allocation range in bytes. Use 0 for entire range. + pub end_range_address: u64, + /// Total size to allocate in bytes. + pub size_bytes: u64, + /// Minimum block size for fragmented allocations in bytes. + pub min_block_size_bytes: u64, + /// Buddy allocator behavior flags. + pub buddy_flags: BuddyFlags, +} + +/// Inner structure holding the actual buddy allocator. +/// +/// # Synchronization +/// +/// The C `gpu_buddy` API requires synchronization (see `include/linux/gpu_buddy.h`). +/// The internal [`GpuBuddyGuard`] ensures that the lock is held for all +/// allocator and free operations, preventing races between concurrent allocations +/// and the freeing that occurs when [`AllocatedBlocks`] is dropped. +/// +/// # Invariants +/// +/// The inner [`Opaque`] contains a valid, initialized buddy allocator. +#[pin_data(PinnedDrop)] +struct GpuBuddyInner { + #[pin] + inner: Opaque<bindings::gpu_buddy>, + #[pin] + lock: Mutex<()>, + /// Cached chunk size (does not change after init). + chunk_size: u64, + /// Cached total size (does not change after init). + size: u64, +} + +impl GpuBuddyInner { + /// Create a pin-initializer for the buddy allocator. + fn new(params: &GpuBuddyParams) -> impl PinInit<Self, Error> { + let size = params.physical_memory_size_bytes; + let chunk_size = params.chunk_size_bytes; + + try_pin_init!(Self { + inner <- Opaque::try_ffi_init(|ptr| { + // SAFETY: ptr points to valid uninitialized memory from the pin-init + // infrastructure. gpu_buddy_init will initialize the structure. + to_result(unsafe { bindings::gpu_buddy_init(ptr, size, chunk_size) }) + }), + lock <- new_mutex!(()), + chunk_size: chunk_size, + size: size, + }) + } + + /// Lock the mutex and return a guard for accessing the allocator. + fn lock(&self) -> GpuBuddyGuard<'_> { + GpuBuddyGuard { + inner: self, + _guard: self.lock.lock(), + } + } +} + +#[pinned_drop] +impl PinnedDrop for GpuBuddyInner { + fn drop(self: Pin<&mut Self>) { + let guard = self.lock(); + + // SAFETY: guard provides exclusive access to the allocator. + unsafe { + bindings::gpu_buddy_fini(guard.as_raw()); + } + } +} + +// SAFETY: [`GpuBuddyInner`] can be sent between threads. +unsafe impl Send for GpuBuddyInner {} + +// SAFETY: [`GpuBuddyInner`] is `Sync` because the internal [`GpuBuddyGuard`] +// serializes all access to the C allocator, preventing data races. +unsafe impl Sync for GpuBuddyInner {} + +/// Guard that proves the lock is held, enabling access to the allocator. +/// +/// # Invariants +/// +/// The inner `_guard` holds the lock for the duration of this guard's lifetime. +pub(crate) struct GpuBuddyGuard<'a> { + inner: &'a GpuBuddyInner, + _guard: MutexGuard<'a, ()>, +} + +impl GpuBuddyGuard<'_> { + /// Get a raw pointer to the underlying C `gpu_buddy` structure. + fn as_raw(&self) -> *mut bindings::gpu_buddy { + self.inner.inner.get() + } +} + +/// GPU buddy allocator instance. +/// +/// This structure wraps the C `gpu_buddy` allocator using reference counting. +/// The allocator is automatically cleaned up when all references are dropped. +/// +/// # Invariants +/// +/// The inner [`Arc`] points to a valid, initialized GPU buddy allocator. +pub struct GpuBuddy(Arc<GpuBuddyInner>); + +impl GpuBuddy { + /// Create a new buddy allocator. + /// + /// Creates a buddy allocator that manages a contiguous address space of the given + /// size, with the specified minimum allocation unit (chunk_size must be at least 4KB). + pub fn new(params: GpuBuddyParams) -> Result<Self> { + Ok(Self(Arc::pin_init( + GpuBuddyInner::new(¶ms), + GFP_KERNEL, + )?)) + } + + /// Get the chunk size (minimum allocation unit). + pub fn chunk_size(&self) -> u64 { + self.0.chunk_size + } + + /// Get the total managed size. + pub fn size(&self) -> u64 { + self.0.size + } + + /// Get the available (free) memory in bytes. + pub fn free_memory_bytes(&self) -> u64 { + let guard = self.0.lock(); + // SAFETY: guard provides exclusive access to the allocator. + unsafe { (*guard.as_raw()).avail } + } + + /// Allocate blocks from the buddy allocator. + /// + /// Returns an [`Arc<AllocatedBlocks>`] structure that owns the allocated blocks + /// and automatically frees them when all references are dropped. + pub fn alloc_blocks(&mut self, params: GpuBuddyAllocParams) -> Result<Arc<AllocatedBlocks>> { + let buddy_arc = Arc::clone(&self.0); + + // Create pin-initializer that initializes list and allocates blocks. + let init = try_pin_init!(AllocatedBlocks { + list <- CListHead::try_init(|list| { + // Lock while allocating to serialize with concurrent frees. + let guard = buddy_arc.lock(); + + // SAFETY: guard provides exclusive access, list is initialized. + to_result(unsafe { + bindings::gpu_buddy_alloc_blocks( + guard.as_raw(), + params.start_range_address, + params.end_range_address, + params.size_bytes, + params.min_block_size_bytes, + list.as_raw(), + params.buddy_flags.as_raw(), + ) + }) + }), + buddy: Arc::clone(&buddy_arc), + flags: params.buddy_flags, + }); + + Arc::pin_init(init, GFP_KERNEL) + } +} + +/// Allocated blocks from the buddy allocator with automatic cleanup. +/// +/// This structure owns a list of allocated blocks and ensures they are +/// automatically freed when dropped. Use `iter()` to iterate over all +/// allocated [`Block`] structures. +/// +/// # Invariants +/// +/// - `list` is an initialized, valid list head containing allocated blocks. +/// - `buddy` references a valid [`GpuBuddyInner`]. +#[pin_data(PinnedDrop)] +pub struct AllocatedBlocks { + #[pin] + list: CListHead, + buddy: Arc<GpuBuddyInner>, + flags: BuddyFlags, +} + +impl AllocatedBlocks { + /// Check if the block list is empty. + pub fn is_empty(&self) -> bool { + // An empty list head points to itself. + !self.list.is_linked() + } + + /// Iterate over allocated blocks. + /// + /// Returns an iterator yielding [`AllocatedBlock`] references. The blocks + /// are only valid for the duration of the borrow of `self`. + pub fn iter(&self) -> impl Iterator<Item = AllocatedBlock<'_>> + '_ { + // SAFETY: list contains gpu_buddy_block items linked via __bindgen_anon_1.link. + let clist = unsafe { + clist_create!( + self.list.as_raw(), + Block, + bindings::gpu_buddy_block, + __bindgen_anon_1.link + ) + }; + + clist + .iter() + .map(|block| AllocatedBlock { block, alloc: self }) + } +} + +#[pinned_drop] +impl PinnedDrop for AllocatedBlocks { + fn drop(self: Pin<&mut Self>) { + let guard = self.buddy.lock(); + + // SAFETY: + // - list is valid per the type's invariants. + // - guard provides exclusive access to the allocator. + // CAST: BuddyFlags were validated to fit in u32 at construction. + unsafe { + bindings::gpu_buddy_free_list( + guard.as_raw(), + self.list.as_raw(), + self.flags.as_raw() as u32, + ); + } + } +} + +/// A GPU buddy block. +/// +/// Transparent wrapper over C `gpu_buddy_block` structure. This type is returned +/// as references from [`CListIter`] during iteration over [`AllocatedBlocks`]. +/// +/// # Invariants +/// +/// The inner [`Opaque`] contains a valid, allocated `gpu_buddy_block`. +#[repr(transparent)] +pub struct Block(Opaque<bindings::gpu_buddy_block>); + +impl Block { + /// Get a raw pointer to the underlying C block. + fn as_raw(&self) -> *mut bindings::gpu_buddy_block { + self.0.get() + } + + /// Get the block's offset in the address space. + pub(crate) fn offset(&self) -> u64 { + // SAFETY: self.as_raw() is valid per the type's invariants. + unsafe { bindings::gpu_buddy_block_offset(self.as_raw()) } + } + + /// Get the block order. + pub(crate) fn order(&self) -> u32 { + // SAFETY: self.as_raw() is valid per the type's invariants. + unsafe { bindings::gpu_buddy_block_order(self.as_raw()) } + } +} + +// SAFETY: `Block` is a transparent wrapper over `gpu_buddy_block` which is not +// modified after allocation. It can be safely sent between threads. +unsafe impl Send for Block {} + +// SAFETY: `Block` is a transparent wrapper over `gpu_buddy_block` which is not +// modified after allocation. It can be safely shared among threads. +unsafe impl Sync for Block {} + +/// An allocated block with access to the allocation list. +/// +/// # Invariants +/// +/// - `block` is a valid reference to an allocated [`Block`]. +/// - `alloc` is a valid reference to the [`AllocatedBlocks`] that owns this block. +pub struct AllocatedBlock<'a> { + block: &'a Block, + alloc: &'a AllocatedBlocks, +} + +impl AllocatedBlock<'_> { + /// Get the block's offset in the address space. + pub fn offset(&self) -> u64 { + self.block.offset() + } + + /// Get the block order (size = chunk_size << order). + pub fn order(&self) -> u32 { + self.block.order() + } + + /// Get the block's size in bytes. + pub fn size(&self) -> u64 { + self.alloc.buddy.chunk_size << self.block.order() + } +} diff --git a/rust/kernel/gpu/mod.rs b/rust/kernel/gpu/mod.rs new file mode 100644 index 000000000000..8f25e6367edc --- /dev/null +++ b/rust/kernel/gpu/mod.rs @@ -0,0 +1,5 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! GPU subsystem abstractions. + +pub mod buddy; diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs index cd7e6a1055b0..d754d777f8ff 100644 --- a/rust/kernel/lib.rs +++ b/rust/kernel/lib.rs @@ -98,6 +98,8 @@ pub mod firmware; pub mod fmt; pub mod fs; +#[cfg(CONFIG_GPU_BUDDY)] +pub mod gpu; #[cfg(CONFIG_I2C = "y")] pub mod i2c; pub mod id_pool; -- 2.34.1 ^ permalink raw reply related [flat|nested] 23+ messages in thread
* [PATCH RFC v5 3/6] rust: gpu: Add GPU buddy allocator bindings @ 2025-12-19 20:38 ` Joel Fernandes 0 siblings, 0 replies; 23+ messages in thread From: Joel Fernandes @ 2025-12-19 20:38 UTC (permalink / raw) To: Maarten Lankhorst, Maxime Ripard, Thomas Zimmermann, David Airlie, Simona Vetter, Jonathan Corbet, Alex Deucher, Christian König, Jani Nikula, Joonas Lahtinen, Rodrigo Vivi, Tvrtko Ursulin, Huang Rui, Matthew Auld, Matthew Brost, Lucas De Marchi, Thomas Hellström, Helge Deller Cc: Danilo Krummrich, Alice Ryhl, Miguel Ojeda, Alex Gaynor, Boqun Feng, Gary Guo, Björn Roy Baron, Benno Lossin, Andreas Hindborg, Trevor Gross, Alistair Popple, Alexandre Courbot, Andrea Righi, Philipp Stanner, Elle Rhumsaa, Daniel Almeida, joel, nouveau, dri-devel, rust-for-linux, linux-kernel, linux-doc, amd-gfx, intel-gfx, intel-xe, linux-fbdev, Joel Fernandes Add safe Rust abstractions over the Linux kernel's GPU buddy allocator for physical memory management. The GPU buddy allocator implements a binary buddy system for useful for GPU physical memory allocation. nova-core will use it for physical memory allocation. Signed-off-by: Joel Fernandes <joelagnelf@nvidia.com> --- rust/bindings/bindings_helper.h | 11 + rust/helpers/gpu.c | 23 ++ rust/helpers/helpers.c | 1 + rust/kernel/gpu/buddy.rs | 518 ++++++++++++++++++++++++++++++++ rust/kernel/gpu/mod.rs | 5 + rust/kernel/lib.rs | 2 + 6 files changed, 560 insertions(+) create mode 100644 rust/helpers/gpu.c create mode 100644 rust/kernel/gpu/buddy.rs create mode 100644 rust/kernel/gpu/mod.rs diff --git a/rust/bindings/bindings_helper.h b/rust/bindings/bindings_helper.h index a067038b4b42..940b854a1f93 100644 --- a/rust/bindings/bindings_helper.h +++ b/rust/bindings/bindings_helper.h @@ -29,6 +29,7 @@ #include <linux/hrtimer_types.h> #include <linux/acpi.h> +#include <linux/gpu_buddy.h> #include <drm/drm_device.h> #include <drm/drm_drv.h> #include <drm/drm_file.h> @@ -144,6 +145,16 @@ const vm_flags_t RUST_CONST_HELPER_VM_MIXEDMAP = VM_MIXEDMAP; const vm_flags_t RUST_CONST_HELPER_VM_HUGEPAGE = VM_HUGEPAGE; const vm_flags_t RUST_CONST_HELPER_VM_NOHUGEPAGE = VM_NOHUGEPAGE; +#if IS_ENABLED(CONFIG_GPU_BUDDY) +const unsigned long RUST_CONST_HELPER_GPU_BUDDY_RANGE_ALLOCATION = GPU_BUDDY_RANGE_ALLOCATION; +const unsigned long RUST_CONST_HELPER_GPU_BUDDY_TOPDOWN_ALLOCATION = GPU_BUDDY_TOPDOWN_ALLOCATION; +const unsigned long RUST_CONST_HELPER_GPU_BUDDY_CONTIGUOUS_ALLOCATION = + GPU_BUDDY_CONTIGUOUS_ALLOCATION; +const unsigned long RUST_CONST_HELPER_GPU_BUDDY_CLEAR_ALLOCATION = GPU_BUDDY_CLEAR_ALLOCATION; +const unsigned long RUST_CONST_HELPER_GPU_BUDDY_CLEARED = GPU_BUDDY_CLEARED; +const unsigned long RUST_CONST_HELPER_GPU_BUDDY_TRIM_DISABLE = GPU_BUDDY_TRIM_DISABLE; +#endif + #if IS_ENABLED(CONFIG_ANDROID_BINDER_IPC_RUST) #include "../../drivers/android/binder/rust_binder.h" #include "../../drivers/android/binder/rust_binder_events.h" diff --git a/rust/helpers/gpu.c b/rust/helpers/gpu.c new file mode 100644 index 000000000000..415836b86abf --- /dev/null +++ b/rust/helpers/gpu.c @@ -0,0 +1,23 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include <linux/gpu_buddy.h> + +#ifdef CONFIG_GPU_BUDDY + +u64 rust_helper_gpu_buddy_block_offset(const struct gpu_buddy_block *block) +{ + return gpu_buddy_block_offset(block); +} + +unsigned int rust_helper_gpu_buddy_block_order(struct gpu_buddy_block *block) +{ + return gpu_buddy_block_order(block); +} + +u64 rust_helper_gpu_buddy_block_size(struct gpu_buddy *mm, + struct gpu_buddy_block *block) +{ + return gpu_buddy_block_size(mm, block); +} + +#endif /* CONFIG_GPU_BUDDY */ diff --git a/rust/helpers/helpers.c b/rust/helpers/helpers.c index 634fa2386bbb..6db7c4c25afa 100644 --- a/rust/helpers/helpers.c +++ b/rust/helpers/helpers.c @@ -29,6 +29,7 @@ #include "err.c" #include "irq.c" #include "fs.c" +#include "gpu.c" #include "io.c" #include "jump_label.c" #include "kunit.c" diff --git a/rust/kernel/gpu/buddy.rs b/rust/kernel/gpu/buddy.rs new file mode 100644 index 000000000000..d75303baf4ec --- /dev/null +++ b/rust/kernel/gpu/buddy.rs @@ -0,0 +1,518 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! GPU buddy allocator bindings. +//! +//! C header: [`include/linux/gpu_buddy.h`](srctree/include/linux/gpu_buddy.h) +//! +//! This module provides Rust abstractions over the Linux kernel's GPU buddy +//! allocator, which implements a binary buddy memory allocator. +//! +//! The buddy allocator manages a contiguous address space and allocates blocks +//! in power-of-two sizes, useful for GPU physical memory management. +//! +//! # Examples +//! +//! ``` +//! use kernel::{ +//! gpu::buddy::{BuddyFlags, GpuBuddy, GpuBuddyAllocParams, GpuBuddyParams}, +//! prelude::*, +//! sizes::*, // +//! }; +//! +//! // Create a 1GB buddy allocator with 4KB minimum chunk size. +//! let mut buddy = GpuBuddy::new(GpuBuddyParams { +//! physical_memory_size_bytes: SZ_1G as u64, +//! chunk_size_bytes: SZ_4K as u64, +//! })?; +//! +//! // Verify initial state. +//! assert_eq!(buddy.size(), SZ_1G as u64); +//! assert_eq!(buddy.chunk_size(), SZ_4K as u64); +//! let initial_free = buddy.free_memory_bytes(); +//! +//! // Base allocation params - reused across tests with field overrides. +//! let params = GpuBuddyAllocParams { +//! start_range_address: 0, +//! end_range_address: 0, // Entire range. +//! size_bytes: SZ_16M as u64, +//! min_block_size_bytes: SZ_16M as u64, +//! buddy_flags: BuddyFlags::try_new(BuddyFlags::RANGE_ALLOCATION)?, +//! }; +//! +//! // Test top-down allocation (allocates from highest addresses). +//! let topdown = buddy.alloc_blocks(GpuBuddyAllocParams { +//! buddy_flags: BuddyFlags::try_new(BuddyFlags::TOPDOWN_ALLOCATION)?, +//! ..params +//! })?; +//! assert_eq!(buddy.free_memory_bytes(), initial_free - SZ_16M as u64); +//! +//! for block in topdown.iter() { +//! assert_eq!(block.offset(), (SZ_1G - SZ_16M) as u64); +//! assert_eq!(block.order(), 12); // 2^12 pages +//! assert_eq!(block.size(), SZ_16M as u64); +//! } +//! drop(topdown); +//! assert_eq!(buddy.free_memory_bytes(), initial_free); +//! +//! // Allocate 16MB - should result in a single 16MB block at offset 0. +//! let allocated = buddy.alloc_blocks(params)?; +//! assert_eq!(buddy.free_memory_bytes(), initial_free - SZ_16M as u64); +//! +//! for block in allocated.iter() { +//! assert_eq!(block.offset(), 0); +//! assert_eq!(block.order(), 12); // 2^12 pages +//! assert_eq!(block.size(), SZ_16M as u64); +//! } +//! drop(allocated); +//! assert_eq!(buddy.free_memory_bytes(), initial_free); +//! +//! // Test non-contiguous allocation with fragmented memory. +//! // Create fragmentation by allocating 4MB blocks at [0,4M) and [8M,12M). +//! let params_4m = GpuBuddyAllocParams { +//! end_range_address: SZ_4M as u64, +//! size_bytes: SZ_4M as u64, +//! min_block_size_bytes: SZ_4M as u64, +//! ..params +//! }; +//! let frag1 = buddy.alloc_blocks(params_4m)?; +//! assert_eq!(buddy.free_memory_bytes(), initial_free - SZ_4M as u64); +//! +//! let frag2 = buddy.alloc_blocks(GpuBuddyAllocParams { +//! start_range_address: SZ_8M as u64, +//! end_range_address: (SZ_8M + SZ_4M) as u64, +//! ..params_4m +//! })?; +//! assert_eq!(buddy.free_memory_bytes(), initial_free - SZ_8M as u64); +//! +//! // Allocate 8MB without CONTIGUOUS - should return 2 blocks from the holes. +//! let fragmented = buddy.alloc_blocks(GpuBuddyAllocParams { +//! end_range_address: SZ_16M as u64, +//! size_bytes: SZ_8M as u64, +//! min_block_size_bytes: SZ_4M as u64, +//! ..params +//! })?; +//! assert_eq!(buddy.free_memory_bytes(), initial_free - (SZ_16M) as u64); +//! +//! let (mut count, mut total) = (0u32, 0u64); +//! for block in fragmented.iter() { +//! // The 8MB allocation should return 2 blocks, each 4MB. +//! assert_eq!(block.size(), SZ_4M as u64); +//! total += block.size(); +//! count += 1; +//! } +//! assert_eq!(total, SZ_8M as u64); +//! assert_eq!(count, 2); +//! drop(fragmented); +//! drop(frag2); +//! drop(frag1); +//! assert_eq!(buddy.free_memory_bytes(), initial_free); +//! +//! // Test CONTIGUOUS failure when only fragmented space available. +//! // Create a small buddy allocator with only 16MB of memory. +//! let mut small = GpuBuddy::new(GpuBuddyParams { +//! physical_memory_size_bytes: SZ_16M as u64, +//! chunk_size_bytes: SZ_4K as u64, +//! })?; +//! +//! // Allocate 4MB blocks at [0,4M) and [8M,12M) to create fragmented memory. +//! let hole1 = small.alloc_blocks(params_4m)?; +//! let hole2 = small.alloc_blocks(GpuBuddyAllocParams { +//! start_range_address: SZ_8M as u64, +//! end_range_address: (SZ_8M + SZ_4M) as u64, +//! ..params_4m +//! })?; +//! +//! // 8MB contiguous should fail - only two non-contiguous 4MB holes exist. +//! let result = small.alloc_blocks(GpuBuddyAllocParams { +//! size_bytes: SZ_8M as u64, +//! min_block_size_bytes: SZ_4M as u64, +//! buddy_flags: BuddyFlags::try_new(BuddyFlags::CONTIGUOUS_ALLOCATION)?, +//! ..params +//! }); +//! assert!(result.is_err()); +//! drop(hole2); +//! drop(hole1); +//! +//! # Ok::<(), Error>(()) +//! ``` + +use crate::{ + bindings, + clist::CListHead, + clist_create, + error::to_result, + new_mutex, + prelude::*, + sync::{ + lock::mutex::MutexGuard, + Arc, + Mutex, // + }, + types::Opaque, +}; + +/// Flags for GPU buddy allocator operations. +/// +/// These flags control the allocation behavior of the buddy allocator. +#[derive(Clone, Copy, Default, PartialEq, Eq)] +pub struct BuddyFlags(usize); + +impl BuddyFlags { + /// Range-based allocation from start to end addresses. + pub const RANGE_ALLOCATION: usize = bindings::GPU_BUDDY_RANGE_ALLOCATION; + + /// Allocate from top of address space downward. + pub const TOPDOWN_ALLOCATION: usize = bindings::GPU_BUDDY_TOPDOWN_ALLOCATION; + + /// Allocate physically contiguous blocks. + pub const CONTIGUOUS_ALLOCATION: usize = bindings::GPU_BUDDY_CONTIGUOUS_ALLOCATION; + + /// Request allocation from the cleared (zeroed) memory. The zero'ing is not + /// done by the allocator, but by the caller before freeing old blocks. + pub const CLEAR_ALLOCATION: usize = bindings::GPU_BUDDY_CLEAR_ALLOCATION; + + /// Disable trimming of partially used blocks. + pub const TRIM_DISABLE: usize = bindings::GPU_BUDDY_TRIM_DISABLE; + + /// Mark blocks as cleared (zeroed) when freeing. When set during free, + /// indicates that the caller has already zeroed the memory. + pub const CLEARED: usize = bindings::GPU_BUDDY_CLEARED; + + /// Create [`BuddyFlags`] from a raw value with validation. + /// + /// Use `|` operator to combine flags if needed, before calling this method. + pub fn try_new(flags: usize) -> Result<Self> { + // Flags must not exceed u32::MAX to satisfy the GPU buddy allocator C API. + if flags > u32::MAX as usize { + return Err(EINVAL); + } + + // `TOPDOWN_ALLOCATION` only works without `RANGE_ALLOCATION`. When both are + // set, `TOPDOWN_ALLOCATION` is silently ignored by the allocator. Reject this. + if (flags & Self::RANGE_ALLOCATION) != 0 && (flags & Self::TOPDOWN_ALLOCATION) != 0 { + return Err(EINVAL); + } + + Ok(Self(flags)) + } + + /// Get raw value of the flags. + pub(crate) fn as_raw(self) -> usize { + self.0 + } +} + +/// Parameters for creating a GPU buddy allocator. +#[derive(Clone, Copy)] +pub struct GpuBuddyParams { + /// Total physical memory size managed by the allocator in bytes. + pub physical_memory_size_bytes: u64, + /// Minimum allocation unit / chunk size in bytes, must be >= 4KB. + pub chunk_size_bytes: u64, +} + +/// Parameters for allocating blocks from a GPU buddy allocator. +#[derive(Clone, Copy)] +pub struct GpuBuddyAllocParams { + /// Start of allocation range in bytes. Use 0 for beginning. + pub start_range_address: u64, + /// End of allocation range in bytes. Use 0 for entire range. + pub end_range_address: u64, + /// Total size to allocate in bytes. + pub size_bytes: u64, + /// Minimum block size for fragmented allocations in bytes. + pub min_block_size_bytes: u64, + /// Buddy allocator behavior flags. + pub buddy_flags: BuddyFlags, +} + +/// Inner structure holding the actual buddy allocator. +/// +/// # Synchronization +/// +/// The C `gpu_buddy` API requires synchronization (see `include/linux/gpu_buddy.h`). +/// The internal [`GpuBuddyGuard`] ensures that the lock is held for all +/// allocator and free operations, preventing races between concurrent allocations +/// and the freeing that occurs when [`AllocatedBlocks`] is dropped. +/// +/// # Invariants +/// +/// The inner [`Opaque`] contains a valid, initialized buddy allocator. +#[pin_data(PinnedDrop)] +struct GpuBuddyInner { + #[pin] + inner: Opaque<bindings::gpu_buddy>, + #[pin] + lock: Mutex<()>, + /// Cached chunk size (does not change after init). + chunk_size: u64, + /// Cached total size (does not change after init). + size: u64, +} + +impl GpuBuddyInner { + /// Create a pin-initializer for the buddy allocator. + fn new(params: &GpuBuddyParams) -> impl PinInit<Self, Error> { + let size = params.physical_memory_size_bytes; + let chunk_size = params.chunk_size_bytes; + + try_pin_init!(Self { + inner <- Opaque::try_ffi_init(|ptr| { + // SAFETY: ptr points to valid uninitialized memory from the pin-init + // infrastructure. gpu_buddy_init will initialize the structure. + to_result(unsafe { bindings::gpu_buddy_init(ptr, size, chunk_size) }) + }), + lock <- new_mutex!(()), + chunk_size: chunk_size, + size: size, + }) + } + + /// Lock the mutex and return a guard for accessing the allocator. + fn lock(&self) -> GpuBuddyGuard<'_> { + GpuBuddyGuard { + inner: self, + _guard: self.lock.lock(), + } + } +} + +#[pinned_drop] +impl PinnedDrop for GpuBuddyInner { + fn drop(self: Pin<&mut Self>) { + let guard = self.lock(); + + // SAFETY: guard provides exclusive access to the allocator. + unsafe { + bindings::gpu_buddy_fini(guard.as_raw()); + } + } +} + +// SAFETY: [`GpuBuddyInner`] can be sent between threads. +unsafe impl Send for GpuBuddyInner {} + +// SAFETY: [`GpuBuddyInner`] is `Sync` because the internal [`GpuBuddyGuard`] +// serializes all access to the C allocator, preventing data races. +unsafe impl Sync for GpuBuddyInner {} + +/// Guard that proves the lock is held, enabling access to the allocator. +/// +/// # Invariants +/// +/// The inner `_guard` holds the lock for the duration of this guard's lifetime. +pub(crate) struct GpuBuddyGuard<'a> { + inner: &'a GpuBuddyInner, + _guard: MutexGuard<'a, ()>, +} + +impl GpuBuddyGuard<'_> { + /// Get a raw pointer to the underlying C `gpu_buddy` structure. + fn as_raw(&self) -> *mut bindings::gpu_buddy { + self.inner.inner.get() + } +} + +/// GPU buddy allocator instance. +/// +/// This structure wraps the C `gpu_buddy` allocator using reference counting. +/// The allocator is automatically cleaned up when all references are dropped. +/// +/// # Invariants +/// +/// The inner [`Arc`] points to a valid, initialized GPU buddy allocator. +pub struct GpuBuddy(Arc<GpuBuddyInner>); + +impl GpuBuddy { + /// Create a new buddy allocator. + /// + /// Creates a buddy allocator that manages a contiguous address space of the given + /// size, with the specified minimum allocation unit (chunk_size must be at least 4KB). + pub fn new(params: GpuBuddyParams) -> Result<Self> { + Ok(Self(Arc::pin_init( + GpuBuddyInner::new(¶ms), + GFP_KERNEL, + )?)) + } + + /// Get the chunk size (minimum allocation unit). + pub fn chunk_size(&self) -> u64 { + self.0.chunk_size + } + + /// Get the total managed size. + pub fn size(&self) -> u64 { + self.0.size + } + + /// Get the available (free) memory in bytes. + pub fn free_memory_bytes(&self) -> u64 { + let guard = self.0.lock(); + // SAFETY: guard provides exclusive access to the allocator. + unsafe { (*guard.as_raw()).avail } + } + + /// Allocate blocks from the buddy allocator. + /// + /// Returns an [`Arc<AllocatedBlocks>`] structure that owns the allocated blocks + /// and automatically frees them when all references are dropped. + pub fn alloc_blocks(&mut self, params: GpuBuddyAllocParams) -> Result<Arc<AllocatedBlocks>> { + let buddy_arc = Arc::clone(&self.0); + + // Create pin-initializer that initializes list and allocates blocks. + let init = try_pin_init!(AllocatedBlocks { + list <- CListHead::try_init(|list| { + // Lock while allocating to serialize with concurrent frees. + let guard = buddy_arc.lock(); + + // SAFETY: guard provides exclusive access, list is initialized. + to_result(unsafe { + bindings::gpu_buddy_alloc_blocks( + guard.as_raw(), + params.start_range_address, + params.end_range_address, + params.size_bytes, + params.min_block_size_bytes, + list.as_raw(), + params.buddy_flags.as_raw(), + ) + }) + }), + buddy: Arc::clone(&buddy_arc), + flags: params.buddy_flags, + }); + + Arc::pin_init(init, GFP_KERNEL) + } +} + +/// Allocated blocks from the buddy allocator with automatic cleanup. +/// +/// This structure owns a list of allocated blocks and ensures they are +/// automatically freed when dropped. Use `iter()` to iterate over all +/// allocated [`Block`] structures. +/// +/// # Invariants +/// +/// - `list` is an initialized, valid list head containing allocated blocks. +/// - `buddy` references a valid [`GpuBuddyInner`]. +#[pin_data(PinnedDrop)] +pub struct AllocatedBlocks { + #[pin] + list: CListHead, + buddy: Arc<GpuBuddyInner>, + flags: BuddyFlags, +} + +impl AllocatedBlocks { + /// Check if the block list is empty. + pub fn is_empty(&self) -> bool { + // An empty list head points to itself. + !self.list.is_linked() + } + + /// Iterate over allocated blocks. + /// + /// Returns an iterator yielding [`AllocatedBlock`] references. The blocks + /// are only valid for the duration of the borrow of `self`. + pub fn iter(&self) -> impl Iterator<Item = AllocatedBlock<'_>> + '_ { + // SAFETY: list contains gpu_buddy_block items linked via __bindgen_anon_1.link. + let clist = unsafe { + clist_create!( + self.list.as_raw(), + Block, + bindings::gpu_buddy_block, + __bindgen_anon_1.link + ) + }; + + clist + .iter() + .map(|block| AllocatedBlock { block, alloc: self }) + } +} + +#[pinned_drop] +impl PinnedDrop for AllocatedBlocks { + fn drop(self: Pin<&mut Self>) { + let guard = self.buddy.lock(); + + // SAFETY: + // - list is valid per the type's invariants. + // - guard provides exclusive access to the allocator. + // CAST: BuddyFlags were validated to fit in u32 at construction. + unsafe { + bindings::gpu_buddy_free_list( + guard.as_raw(), + self.list.as_raw(), + self.flags.as_raw() as u32, + ); + } + } +} + +/// A GPU buddy block. +/// +/// Transparent wrapper over C `gpu_buddy_block` structure. This type is returned +/// as references from [`CListIter`] during iteration over [`AllocatedBlocks`]. +/// +/// # Invariants +/// +/// The inner [`Opaque`] contains a valid, allocated `gpu_buddy_block`. +#[repr(transparent)] +pub struct Block(Opaque<bindings::gpu_buddy_block>); + +impl Block { + /// Get a raw pointer to the underlying C block. + fn as_raw(&self) -> *mut bindings::gpu_buddy_block { + self.0.get() + } + + /// Get the block's offset in the address space. + pub(crate) fn offset(&self) -> u64 { + // SAFETY: self.as_raw() is valid per the type's invariants. + unsafe { bindings::gpu_buddy_block_offset(self.as_raw()) } + } + + /// Get the block order. + pub(crate) fn order(&self) -> u32 { + // SAFETY: self.as_raw() is valid per the type's invariants. + unsafe { bindings::gpu_buddy_block_order(self.as_raw()) } + } +} + +// SAFETY: `Block` is a transparent wrapper over `gpu_buddy_block` which is not +// modified after allocation. It can be safely sent between threads. +unsafe impl Send for Block {} + +// SAFETY: `Block` is a transparent wrapper over `gpu_buddy_block` which is not +// modified after allocation. It can be safely shared among threads. +unsafe impl Sync for Block {} + +/// An allocated block with access to the allocation list. +/// +/// # Invariants +/// +/// - `block` is a valid reference to an allocated [`Block`]. +/// - `alloc` is a valid reference to the [`AllocatedBlocks`] that owns this block. +pub struct AllocatedBlock<'a> { + block: &'a Block, + alloc: &'a AllocatedBlocks, +} + +impl AllocatedBlock<'_> { + /// Get the block's offset in the address space. + pub fn offset(&self) -> u64 { + self.block.offset() + } + + /// Get the block order (size = chunk_size << order). + pub fn order(&self) -> u32 { + self.block.order() + } + + /// Get the block's size in bytes. + pub fn size(&self) -> u64 { + self.alloc.buddy.chunk_size << self.block.order() + } +} diff --git a/rust/kernel/gpu/mod.rs b/rust/kernel/gpu/mod.rs new file mode 100644 index 000000000000..8f25e6367edc --- /dev/null +++ b/rust/kernel/gpu/mod.rs @@ -0,0 +1,5 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! GPU subsystem abstractions. + +pub mod buddy; diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs index cd7e6a1055b0..d754d777f8ff 100644 --- a/rust/kernel/lib.rs +++ b/rust/kernel/lib.rs @@ -98,6 +98,8 @@ pub mod firmware; pub mod fmt; pub mod fs; +#[cfg(CONFIG_GPU_BUDDY)] +pub mod gpu; #[cfg(CONFIG_I2C = "y")] pub mod i2c; pub mod id_pool; -- 2.34.1 ^ permalink raw reply related [flat|nested] 23+ messages in thread
* Re: [PATCH RFC v5 3/6] rust: gpu: Add GPU buddy allocator bindings 2025-12-19 20:38 ` Joel Fernandes (?) @ 2025-12-20 20:39 ` kernel test robot -1 siblings, 0 replies; 23+ messages in thread From: kernel test robot @ 2025-12-20 20:39 UTC (permalink / raw) To: Joel Fernandes; +Cc: oe-kbuild-all Hi Joel, [This is a private test report for your RFC patch.] kernel test robot noticed the following build errors: [auto build test ERROR on drm-misc/drm-misc-next] [also build test ERROR on linus/master v6.19-rc1 next-20251219] [cannot apply to rust/rust-next drm-nova/nova-next] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in https://git-scm.com/docs/git-format-patch#_base_tree_information] url: https://github.com/intel-lab-lkp/linux/commits/Joel-Fernandes/rust-clist-Add-support-to-interface-with-C-linked-lists/20251220-044108 base: https://gitlab.freedesktop.org/drm/misc/kernel.git drm-misc-next patch link: https://lore.kernel.org/r/20251219203805.1246586-4-joelagnelf%40nvidia.com patch subject: [PATCH RFC v5 3/6] rust: gpu: Add GPU buddy allocator bindings config: x86_64-rhel-9.4-rust (https://download.01.org/0day-ci/archive/20251220/202512202138.XipsbgYo-lkp@intel.com/config) compiler: clang version 20.1.8 (https://github.com/llvm/llvm-project 87f0227cb60147a26a1eeb4fb06e3b505e9c7261) rustc: rustc 1.88.0 (6b00bc388 2025-06-23) reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20251220/202512202138.XipsbgYo-lkp@intel.com/reproduce) If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags | Reported-by: kernel test robot <lkp@intel.com> | Closes: https://lore.kernel.org/oe-kbuild-all/202512202138.XipsbgYo-lkp@intel.com/ All errors (new ones prefixed by >>): >> error[E0425]: cannot find function `gpu_buddy_block_offset` in crate `bindings` --> rust/kernel/gpu/buddy.rs:474:28 | 474 | unsafe { bindings::gpu_buddy_block_offset(self.as_raw()) } | ^^^^^^^^^^^^^^^^^^^^^^ help: a function with a similar name exists: `gpu_buddy_block_print` | ::: rust/bindings/bindings_generated.rs:61566:5 | 61566 | pub fn gpu_buddy_block_print(mm: *mut gpu_buddy, block: *mut gpu_buddy_block); | ------------------------------------------------------------------------------ similarly named function `gpu_buddy_block_print` defined here -- >> error[E0425]: cannot find function `gpu_buddy_block_order` in crate `bindings` --> rust/kernel/gpu/buddy.rs:480:28 | 480 | unsafe { bindings::gpu_buddy_block_order(self.as_raw()) } | ^^^^^^^^^^^^^^^^^^^^^ help: a function with a similar name exists: `gpu_buddy_block_print` | ::: rust/bindings/bindings_generated.rs:61566:5 | 61566 | pub fn gpu_buddy_block_print(mm: *mut gpu_buddy, block: *mut gpu_buddy_block); | ------------------------------------------------------------------------------ similarly named function `gpu_buddy_block_print` defined here -- 0-DAY CI Kernel Test Service https://github.com/intel/lkp-tests/wiki ^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH RFC v5 3/6] rust: gpu: Add GPU buddy allocator bindings 2025-12-19 20:38 ` Joel Fernandes (?) (?) @ 2025-12-23 7:45 ` kernel test robot -1 siblings, 0 replies; 23+ messages in thread From: kernel test robot @ 2025-12-23 7:45 UTC (permalink / raw) To: Joel Fernandes; +Cc: llvm, oe-kbuild-all Hi Joel, [This is a private test report for your RFC patch.] kernel test robot noticed the following build errors: [auto build test ERROR on drm-misc/drm-misc-next] [also build test ERROR on linus/master v6.19-rc2 next-20251219] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in https://git-scm.com/docs/git-format-patch#_base_tree_information] url: https://github.com/intel-lab-lkp/linux/commits/Joel-Fernandes/rust-clist-Add-support-to-interface-with-C-linked-lists/20251220-044108 base: https://gitlab.freedesktop.org/drm/misc/kernel.git drm-misc-next patch link: https://lore.kernel.org/r/20251219203805.1246586-4-joelagnelf%40nvidia.com patch subject: [PATCH RFC v5 3/6] rust: gpu: Add GPU buddy allocator bindings config: x86_64-rhel-9.4-rust (https://download.01.org/0day-ci/archive/20251223/202512232015.WVmaP40F-lkp@intel.com/config) compiler: clang version 20.1.8 (https://github.com/llvm/llvm-project 87f0227cb60147a26a1eeb4fb06e3b505e9c7261) rustc: rustc 1.88.0 (6b00bc388 2025-06-23) reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20251223/202512232015.WVmaP40F-lkp@intel.com/reproduce) If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags | Reported-by: kernel test robot <lkp@intel.com> | Closes: https://lore.kernel.org/oe-kbuild-all/202512232015.WVmaP40F-lkp@intel.com/ All errors (new ones prefixed by >>): >> error[E0425]: cannot find function `gpu_buddy_block_offset` in crate `bindings` --> rust/kernel/gpu/buddy.rs:474:28 | 474 | unsafe { bindings::gpu_buddy_block_offset(self.as_raw()) } | ^^^^^^^^^^^^^^^^^^^^^^ help: a function with a similar name exists: `gpu_buddy_block_print` | ::: rust/bindings/bindings_generated.rs:61566:5 | 61566 | pub fn gpu_buddy_block_print(mm: *mut gpu_buddy, block: *mut gpu_buddy_block); | ------------------------------------------------------------------------------ similarly named function `gpu_buddy_block_print` defined here -- >> error[E0425]: cannot find function `gpu_buddy_block_order` in crate `bindings` --> rust/kernel/gpu/buddy.rs:480:28 | 480 | unsafe { bindings::gpu_buddy_block_order(self.as_raw()) } | ^^^^^^^^^^^^^^^^^^^^^ help: a function with a similar name exists: `gpu_buddy_block_print` | ::: rust/bindings/bindings_generated.rs:61566:5 | 61566 | pub fn gpu_buddy_block_print(mm: *mut gpu_buddy, block: *mut gpu_buddy_block); | ------------------------------------------------------------------------------ similarly named function `gpu_buddy_block_print` defined here -- 0-DAY CI Kernel Test Service https://github.com/intel/lkp-tests/wiki ^ permalink raw reply [flat|nested] 23+ messages in thread
* [PATCH RFC v5 4/6] nova-core: mm: Add support to use PRAMIN windows to write to VRAM 2025-12-19 20:37 ` Joel Fernandes @ 2025-12-19 20:38 ` Joel Fernandes -1 siblings, 0 replies; 23+ messages in thread From: Joel Fernandes @ 2025-12-19 20:38 UTC (permalink / raw) To: Maarten Lankhorst, Maxime Ripard, Thomas Zimmermann, David Airlie, Simona Vetter, Jonathan Corbet, Alex Deucher, Christian König, Jani Nikula, Joonas Lahtinen, Rodrigo Vivi, Tvrtko Ursulin, Huang Rui, Matthew Auld, Matthew Brost, Lucas De Marchi, Thomas Hellström, Helge Deller Cc: Danilo Krummrich, Alice Ryhl, Miguel Ojeda, Alex Gaynor, Boqun Feng, Gary Guo, Björn Roy Baron, Benno Lossin, Andreas Hindborg, Trevor Gross, John Hubbard, Alistair Popple, Timur Tabi, Edwin Peer, Alexandre Courbot, Andrea Righi, Philipp Stanner, Elle Rhumsaa, Daniel Almeida, joel, nouveau, dri-devel, rust-for-linux, linux-kernel, linux-doc, amd-gfx, intel-gfx, intel-xe, linux-fbdev, Joel Fernandes PRAMIN apertures are a crucial mechanism to direct read/write to VRAM. Add support for the same. Signed-off-by: Joel Fernandes <joelagnelf@nvidia.com> --- drivers/gpu/nova-core/mm/mod.rs | 5 + drivers/gpu/nova-core/mm/pramin.rs | 200 +++++++++++++++++++++++++++++ drivers/gpu/nova-core/nova_core.rs | 1 + drivers/gpu/nova-core/regs.rs | 5 + 4 files changed, 211 insertions(+) create mode 100644 drivers/gpu/nova-core/mm/mod.rs create mode 100644 drivers/gpu/nova-core/mm/pramin.rs diff --git a/drivers/gpu/nova-core/mm/mod.rs b/drivers/gpu/nova-core/mm/mod.rs new file mode 100644 index 000000000000..7a5dd4220c67 --- /dev/null +++ b/drivers/gpu/nova-core/mm/mod.rs @@ -0,0 +1,5 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! Memory management subsystems for nova-core. + +pub(crate) mod pramin; diff --git a/drivers/gpu/nova-core/mm/pramin.rs b/drivers/gpu/nova-core/mm/pramin.rs new file mode 100644 index 000000000000..5878a3f80b9c --- /dev/null +++ b/drivers/gpu/nova-core/mm/pramin.rs @@ -0,0 +1,200 @@ +// SPDX-License-Identifier: GPL-2.0 + +#![expect(unused)] + +//! Direct VRAM access through the PRAMIN aperture. +//! +//! PRAMIN provides a 1MB sliding window into VRAM through BAR0, allowing the CPU to access +//! video memory directly. The [`Window`] type automatically repositions the window when +//! accessing different VRAM regions and restores the original position on drop. This allows +//! to reuse the same window for multiple accesses in the same window. +//! +//! The PRAMIN aperture is a 1MB region at BAR0 + 0x700000 for all GPUs. The window base is +//! controlled by the `NV_PBUS_BAR0_WINDOW` register and must be 64KB aligned. +//! +//! # Examples +//! +//! ## Basic read/write +//! +//! ```no_run +//! use crate::driver::Bar0; +//! use crate::mm::pramin; +//! +//! fn example(bar: &Bar0) -> Result<()> { +//! let mut pram_win = pramin::Window::new(bar); +//! +//! // Write and read back. +//! pram_win.try_write32(0x100, 0xDEADBEEF)?; +//! let val = pram_win.try_read32(0x100)?; +//! assert_eq!(val, 0xDEADBEEF); +//! +//! Ok(()) +//! // Original window position restored on drop. +//! } +//! ``` +//! +//! ## Auto-repositioning across VRAM regions +//! +//! ```no_run +//! use crate::driver::Bar0; +//! use crate::mm::pramin; +//! +//! fn example(bar: &Bar0) -> Result<()> { +//! let mut pram_win = pramin::Window::new(bar); +//! +//! // Access first 1MB region. +//! pram_win.try_write32(0x100, 0x11111111)?; +//! +//! // Access at 2MB - window auto-repositions. +//! pram_win.try_write32(0x200000, 0x22222222)?; +//! +//! // Back to first region - window repositions again. +//! let val = pram_win.try_read32(0x100)?; +//! assert_eq!(val, 0x11111111); +//! +//! Ok(()) +//! } +//! ``` + +use crate::{ + driver::Bar0, + regs, // +}; + +use kernel::bits::genmask_u64; +use kernel::prelude::*; +use kernel::ptr::{Alignable, Alignment}; +use kernel::sizes::{SZ_1M, SZ_64K}; + +/// PRAMIN aperture base offset in BAR0. +const PRAMIN_BASE: usize = 0x700000; + +/// PRAMIN aperture size (1MB). +const PRAMIN_SIZE: usize = SZ_1M; + +/// 64KB alignment for window base. +const WINDOW_ALIGN: Alignment = Alignment::new::<SZ_64K>(); + +/// Maximum addressable VRAM offset (40-bit address space). +/// +/// The `NV_PBUS_BAR0_WINDOW` register has a 24-bit `window_base` field (bits 23:0) that stores +/// bits [39:16] of the target VRAM address. This limits the addressable space to 2^40 bytes. +const MAX_VRAM_OFFSET: usize = genmask_u64(0..=39) as usize; + +/// Generate a PRAMIN read accessor. +macro_rules! define_pramin_read { + ($name:ident, $ty:ty) => { + #[doc = concat!("Read a `", stringify!($ty), "` from VRAM at the given offset.")] + pub(crate) fn $name(&mut self, vram_offset: usize) -> Result<$ty> { + let bar_offset = self.ensure_window(vram_offset, ::core::mem::size_of::<$ty>())?; + self.bar.$name(bar_offset) + } + }; +} + +/// Generate a PRAMIN write accessor. +macro_rules! define_pramin_write { + ($name:ident, $ty:ty) => { + #[doc = concat!("Write a `", stringify!($ty), "` to VRAM at the given offset.")] + pub(crate) fn $name(&mut self, vram_offset: usize, value: $ty) -> Result { + let bar_offset = self.ensure_window(vram_offset, ::core::mem::size_of::<$ty>())?; + self.bar.$name(value, bar_offset) + } + }; +} + +/// PRAMIN window for direct VRAM access. +/// +/// The window auto-repositions when accessing VRAM offsets outside the current 1MB range. +/// Original window position is saved on creation and restored on drop. +pub(crate) struct Window<'a> { + bar: &'a Bar0, + saved_base: usize, + current_base: usize, +} + +impl<'a> Window<'a> { + /// Create a new PRAMIN window accessor. + /// + /// Saves the current window position for restoration on drop. + pub(crate) fn new(bar: &'a Bar0) -> Self { + let saved_base = Self::read_window_base(bar); + + Self { + bar, + saved_base, + current_base: saved_base, + } + } + + /// Read the current window base from the BAR0_WINDOW register. + fn read_window_base(bar: &Bar0) -> usize { + let reg = regs::NV_PBUS_BAR0_WINDOW::read(bar); + // CAST: u32 to usize is lossless. + (reg.window_base() as usize) << 16 + } + + /// Write a new window base to the BAR0_WINDOW register. + fn write_window_base(bar: &Bar0, base: usize) { + // CAST: + // - We have guaranteed that the base is within the addressable range (40-bits). + // - After >> 16, a 40-bit aligned base becomes 24 bits, which fits in u32. + regs::NV_PBUS_BAR0_WINDOW::default() + .set_window_base((base >> 16) as u32) + .write(bar); + } + + /// Ensure the window covers the given VRAM offset returning the BAR0 offset to use. + fn ensure_window(&mut self, vram_offset: usize, access_size: usize) -> Result<usize> { + // Validate VRAM offset is within addressable range (40-bit address space). + let end_offset = vram_offset.checked_add(access_size).ok_or(EINVAL)?; + if end_offset > MAX_VRAM_OFFSET + 1 { + return Err(EINVAL); + } + + // Calculate which 64KB-aligned base we need. + let needed_base = vram_offset.align_down(WINDOW_ALIGN); + + // Calculate offset within the window. + let offset_in_window = vram_offset - needed_base; + + // Check if access fits in 1MB window from this base. + if offset_in_window + access_size > PRAMIN_SIZE { + return Err(EINVAL); + } + + // Reposition window if needed. + if self.current_base != needed_base { + Self::write_window_base(self.bar, needed_base); + self.current_base = needed_base; + } + + // Return BAR0 offset to access. + Ok(PRAMIN_BASE + offset_in_window) + } + + define_pramin_read!(try_read8, u8); + define_pramin_read!(try_read16, u16); + define_pramin_read!(try_read32, u32); + define_pramin_read!(try_read64, u64); + + define_pramin_write!(try_write8, u8); + define_pramin_write!(try_write16, u16); + define_pramin_write!(try_write32, u32); + define_pramin_write!(try_write64, u64); +} + +impl Drop for Window<'_> { + fn drop(&mut self) { + // Restore the original window base if it changed. + if self.current_base != self.saved_base { + Self::write_window_base(self.bar, self.saved_base); + } + } +} + +// SAFETY: `Window` requires `&mut self` for all accessors. +unsafe impl Send for Window<'_> {} + +// SAFETY: `Window` requires `&mut self` for all accessors. +unsafe impl Sync for Window<'_> {} diff --git a/drivers/gpu/nova-core/nova_core.rs b/drivers/gpu/nova-core/nova_core.rs index b98a1c03f13d..3104fea04128 100644 --- a/drivers/gpu/nova-core/nova_core.rs +++ b/drivers/gpu/nova-core/nova_core.rs @@ -13,6 +13,7 @@ mod gfw; mod gpu; mod gsp; +mod mm; mod num; mod regs; mod sbuffer; diff --git a/drivers/gpu/nova-core/regs.rs b/drivers/gpu/nova-core/regs.rs index 82cc6c0790e5..c8b8fbdcf608 100644 --- a/drivers/gpu/nova-core/regs.rs +++ b/drivers/gpu/nova-core/regs.rs @@ -96,6 +96,11 @@ fn fmt(&self, f: &mut kernel::fmt::Formatter<'_>) -> kernel::fmt::Result { 31:16 frts_err_code as u16; }); +register!(NV_PBUS_BAR0_WINDOW @ 0x00001700, "BAR0 window control for PRAMIN access" { + 25:24 target as u8, "Target memory (0=VRAM, 1=SYS_MEM_COH, 2=SYS_MEM_NONCOH)"; + 23:0 window_base as u32, "Window base address (bits 39:16 of FB addr)"; +}); + // PFB // The following two registers together hold the physical system memory address that is used by the -- 2.34.1 ^ permalink raw reply related [flat|nested] 23+ messages in thread
* [PATCH RFC v5 4/6] nova-core: mm: Add support to use PRAMIN windows to write to VRAM @ 2025-12-19 20:38 ` Joel Fernandes 0 siblings, 0 replies; 23+ messages in thread From: Joel Fernandes @ 2025-12-19 20:38 UTC (permalink / raw) To: Maarten Lankhorst, Maxime Ripard, Thomas Zimmermann, David Airlie, Simona Vetter, Jonathan Corbet, Alex Deucher, Christian König, Jani Nikula, Joonas Lahtinen, Rodrigo Vivi, Tvrtko Ursulin, Huang Rui, Matthew Auld, Matthew Brost, Lucas De Marchi, Thomas Hellström, Helge Deller Cc: Danilo Krummrich, Alice Ryhl, Miguel Ojeda, Alex Gaynor, Boqun Feng, Gary Guo, Björn Roy Baron, Benno Lossin, Andreas Hindborg, Trevor Gross, Alistair Popple, Alexandre Courbot, Andrea Righi, Philipp Stanner, Elle Rhumsaa, Daniel Almeida, joel, nouveau, dri-devel, rust-for-linux, linux-kernel, linux-doc, amd-gfx, intel-gfx, intel-xe, linux-fbdev, Joel Fernandes PRAMIN apertures are a crucial mechanism to direct read/write to VRAM. Add support for the same. Signed-off-by: Joel Fernandes <joelagnelf@nvidia.com> --- drivers/gpu/nova-core/mm/mod.rs | 5 + drivers/gpu/nova-core/mm/pramin.rs | 200 +++++++++++++++++++++++++++++ drivers/gpu/nova-core/nova_core.rs | 1 + drivers/gpu/nova-core/regs.rs | 5 + 4 files changed, 211 insertions(+) create mode 100644 drivers/gpu/nova-core/mm/mod.rs create mode 100644 drivers/gpu/nova-core/mm/pramin.rs diff --git a/drivers/gpu/nova-core/mm/mod.rs b/drivers/gpu/nova-core/mm/mod.rs new file mode 100644 index 000000000000..7a5dd4220c67 --- /dev/null +++ b/drivers/gpu/nova-core/mm/mod.rs @@ -0,0 +1,5 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! Memory management subsystems for nova-core. + +pub(crate) mod pramin; diff --git a/drivers/gpu/nova-core/mm/pramin.rs b/drivers/gpu/nova-core/mm/pramin.rs new file mode 100644 index 000000000000..5878a3f80b9c --- /dev/null +++ b/drivers/gpu/nova-core/mm/pramin.rs @@ -0,0 +1,200 @@ +// SPDX-License-Identifier: GPL-2.0 + +#![expect(unused)] + +//! Direct VRAM access through the PRAMIN aperture. +//! +//! PRAMIN provides a 1MB sliding window into VRAM through BAR0, allowing the CPU to access +//! video memory directly. The [`Window`] type automatically repositions the window when +//! accessing different VRAM regions and restores the original position on drop. This allows +//! to reuse the same window for multiple accesses in the same window. +//! +//! The PRAMIN aperture is a 1MB region at BAR0 + 0x700000 for all GPUs. The window base is +//! controlled by the `NV_PBUS_BAR0_WINDOW` register and must be 64KB aligned. +//! +//! # Examples +//! +//! ## Basic read/write +//! +//! ```no_run +//! use crate::driver::Bar0; +//! use crate::mm::pramin; +//! +//! fn example(bar: &Bar0) -> Result<()> { +//! let mut pram_win = pramin::Window::new(bar); +//! +//! // Write and read back. +//! pram_win.try_write32(0x100, 0xDEADBEEF)?; +//! let val = pram_win.try_read32(0x100)?; +//! assert_eq!(val, 0xDEADBEEF); +//! +//! Ok(()) +//! // Original window position restored on drop. +//! } +//! ``` +//! +//! ## Auto-repositioning across VRAM regions +//! +//! ```no_run +//! use crate::driver::Bar0; +//! use crate::mm::pramin; +//! +//! fn example(bar: &Bar0) -> Result<()> { +//! let mut pram_win = pramin::Window::new(bar); +//! +//! // Access first 1MB region. +//! pram_win.try_write32(0x100, 0x11111111)?; +//! +//! // Access at 2MB - window auto-repositions. +//! pram_win.try_write32(0x200000, 0x22222222)?; +//! +//! // Back to first region - window repositions again. +//! let val = pram_win.try_read32(0x100)?; +//! assert_eq!(val, 0x11111111); +//! +//! Ok(()) +//! } +//! ``` + +use crate::{ + driver::Bar0, + regs, // +}; + +use kernel::bits::genmask_u64; +use kernel::prelude::*; +use kernel::ptr::{Alignable, Alignment}; +use kernel::sizes::{SZ_1M, SZ_64K}; + +/// PRAMIN aperture base offset in BAR0. +const PRAMIN_BASE: usize = 0x700000; + +/// PRAMIN aperture size (1MB). +const PRAMIN_SIZE: usize = SZ_1M; + +/// 64KB alignment for window base. +const WINDOW_ALIGN: Alignment = Alignment::new::<SZ_64K>(); + +/// Maximum addressable VRAM offset (40-bit address space). +/// +/// The `NV_PBUS_BAR0_WINDOW` register has a 24-bit `window_base` field (bits 23:0) that stores +/// bits [39:16] of the target VRAM address. This limits the addressable space to 2^40 bytes. +const MAX_VRAM_OFFSET: usize = genmask_u64(0..=39) as usize; + +/// Generate a PRAMIN read accessor. +macro_rules! define_pramin_read { + ($name:ident, $ty:ty) => { + #[doc = concat!("Read a `", stringify!($ty), "` from VRAM at the given offset.")] + pub(crate) fn $name(&mut self, vram_offset: usize) -> Result<$ty> { + let bar_offset = self.ensure_window(vram_offset, ::core::mem::size_of::<$ty>())?; + self.bar.$name(bar_offset) + } + }; +} + +/// Generate a PRAMIN write accessor. +macro_rules! define_pramin_write { + ($name:ident, $ty:ty) => { + #[doc = concat!("Write a `", stringify!($ty), "` to VRAM at the given offset.")] + pub(crate) fn $name(&mut self, vram_offset: usize, value: $ty) -> Result { + let bar_offset = self.ensure_window(vram_offset, ::core::mem::size_of::<$ty>())?; + self.bar.$name(value, bar_offset) + } + }; +} + +/// PRAMIN window for direct VRAM access. +/// +/// The window auto-repositions when accessing VRAM offsets outside the current 1MB range. +/// Original window position is saved on creation and restored on drop. +pub(crate) struct Window<'a> { + bar: &'a Bar0, + saved_base: usize, + current_base: usize, +} + +impl<'a> Window<'a> { + /// Create a new PRAMIN window accessor. + /// + /// Saves the current window position for restoration on drop. + pub(crate) fn new(bar: &'a Bar0) -> Self { + let saved_base = Self::read_window_base(bar); + + Self { + bar, + saved_base, + current_base: saved_base, + } + } + + /// Read the current window base from the BAR0_WINDOW register. + fn read_window_base(bar: &Bar0) -> usize { + let reg = regs::NV_PBUS_BAR0_WINDOW::read(bar); + // CAST: u32 to usize is lossless. + (reg.window_base() as usize) << 16 + } + + /// Write a new window base to the BAR0_WINDOW register. + fn write_window_base(bar: &Bar0, base: usize) { + // CAST: + // - We have guaranteed that the base is within the addressable range (40-bits). + // - After >> 16, a 40-bit aligned base becomes 24 bits, which fits in u32. + regs::NV_PBUS_BAR0_WINDOW::default() + .set_window_base((base >> 16) as u32) + .write(bar); + } + + /// Ensure the window covers the given VRAM offset returning the BAR0 offset to use. + fn ensure_window(&mut self, vram_offset: usize, access_size: usize) -> Result<usize> { + // Validate VRAM offset is within addressable range (40-bit address space). + let end_offset = vram_offset.checked_add(access_size).ok_or(EINVAL)?; + if end_offset > MAX_VRAM_OFFSET + 1 { + return Err(EINVAL); + } + + // Calculate which 64KB-aligned base we need. + let needed_base = vram_offset.align_down(WINDOW_ALIGN); + + // Calculate offset within the window. + let offset_in_window = vram_offset - needed_base; + + // Check if access fits in 1MB window from this base. + if offset_in_window + access_size > PRAMIN_SIZE { + return Err(EINVAL); + } + + // Reposition window if needed. + if self.current_base != needed_base { + Self::write_window_base(self.bar, needed_base); + self.current_base = needed_base; + } + + // Return BAR0 offset to access. + Ok(PRAMIN_BASE + offset_in_window) + } + + define_pramin_read!(try_read8, u8); + define_pramin_read!(try_read16, u16); + define_pramin_read!(try_read32, u32); + define_pramin_read!(try_read64, u64); + + define_pramin_write!(try_write8, u8); + define_pramin_write!(try_write16, u16); + define_pramin_write!(try_write32, u32); + define_pramin_write!(try_write64, u64); +} + +impl Drop for Window<'_> { + fn drop(&mut self) { + // Restore the original window base if it changed. + if self.current_base != self.saved_base { + Self::write_window_base(self.bar, self.saved_base); + } + } +} + +// SAFETY: `Window` requires `&mut self` for all accessors. +unsafe impl Send for Window<'_> {} + +// SAFETY: `Window` requires `&mut self` for all accessors. +unsafe impl Sync for Window<'_> {} diff --git a/drivers/gpu/nova-core/nova_core.rs b/drivers/gpu/nova-core/nova_core.rs index b98a1c03f13d..3104fea04128 100644 --- a/drivers/gpu/nova-core/nova_core.rs +++ b/drivers/gpu/nova-core/nova_core.rs @@ -13,6 +13,7 @@ mod gfw; mod gpu; mod gsp; +mod mm; mod num; mod regs; mod sbuffer; diff --git a/drivers/gpu/nova-core/regs.rs b/drivers/gpu/nova-core/regs.rs index 82cc6c0790e5..c8b8fbdcf608 100644 --- a/drivers/gpu/nova-core/regs.rs +++ b/drivers/gpu/nova-core/regs.rs @@ -96,6 +96,11 @@ fn fmt(&self, f: &mut kernel::fmt::Formatter<'_>) -> kernel::fmt::Result { 31:16 frts_err_code as u16; }); +register!(NV_PBUS_BAR0_WINDOW @ 0x00001700, "BAR0 window control for PRAMIN access" { + 25:24 target as u8, "Target memory (0=VRAM, 1=SYS_MEM_COH, 2=SYS_MEM_NONCOH)"; + 23:0 window_base as u32, "Window base address (bits 39:16 of FB addr)"; +}); + // PFB // The following two registers together hold the physical system memory address that is used by the -- 2.34.1 ^ permalink raw reply related [flat|nested] 23+ messages in thread
* [PATCH RFC v5 5/6] docs: gpu: nova-core: Document the PRAMIN aperture mechanism 2025-12-19 20:37 ` Joel Fernandes @ 2025-12-19 20:38 ` Joel Fernandes -1 siblings, 0 replies; 23+ messages in thread From: Joel Fernandes @ 2025-12-19 20:38 UTC (permalink / raw) To: Maarten Lankhorst, Maxime Ripard, Thomas Zimmermann, David Airlie, Simona Vetter, Jonathan Corbet, Alex Deucher, Christian König, Jani Nikula, Joonas Lahtinen, Rodrigo Vivi, Tvrtko Ursulin, Huang Rui, Matthew Auld, Matthew Brost, Lucas De Marchi, Thomas Hellström, Helge Deller Cc: Danilo Krummrich, Alice Ryhl, Miguel Ojeda, Alex Gaynor, Boqun Feng, Gary Guo, Björn Roy Baron, Benno Lossin, Andreas Hindborg, Trevor Gross, John Hubbard, Alistair Popple, Timur Tabi, Edwin Peer, Alexandre Courbot, Andrea Righi, Philipp Stanner, Elle Rhumsaa, Daniel Almeida, joel, nouveau, dri-devel, rust-for-linux, linux-kernel, linux-doc, amd-gfx, intel-gfx, intel-xe, linux-fbdev, Joel Fernandes Add documentation for the PRAMIN aperture mechanism used by nova-core for direct VRAM access. Nova only uses TARGET=VID_MEM for VRAM access. The SYS_MEM target values are documented for completeness but not used by the driver. Signed-off-by: Joel Fernandes <joelagnelf@nvidia.com> --- Documentation/gpu/nova/core/pramin.rst | 125 +++++++++++++++++++++++++ Documentation/gpu/nova/index.rst | 1 + 2 files changed, 126 insertions(+) create mode 100644 Documentation/gpu/nova/core/pramin.rst diff --git a/Documentation/gpu/nova/core/pramin.rst b/Documentation/gpu/nova/core/pramin.rst new file mode 100644 index 000000000000..55ec9d920629 --- /dev/null +++ b/Documentation/gpu/nova/core/pramin.rst @@ -0,0 +1,125 @@ +.. SPDX-License-Identifier: GPL-2.0 + +========================= +PRAMIN aperture mechanism +========================= + +.. note:: + The following description is approximate and current as of the Ampere family. + It may change for future generations and is intended to assist in understanding + the driver code. + +Introduction +============ + +PRAMIN is a hardware aperture mechanism that provides CPU access to GPU Video RAM (VRAM) before +the GPU's Memory Management Unit (MMU) and page tables are initialized. This 1MB sliding window, +located at a fixed offset within BAR0, is essential for setting up page tables and other critical +GPU data structures without relying on the GPU's MMU. + +Architecture Overview +===================== + +The PRAMIN aperture mechanism is logically implemented by the GPU's PBUS (PCIe Bus Controller Unit) +and provides a CPU-accessible window into VRAM through the PCIe interface:: + + +-----------------+ PCIe +------------------------------+ + | CPU |<----------->| GPU | + +-----------------+ | | + | +----------------------+ | + | | PBUS | | + | | (Bus Controller) | | + | | | | + | | +--------------+<------------ (window starts at + | | | PRAMIN | | | BAR0 + 0x700000) + | | | Window | | | + | | | (1MB) | | | + | | +--------------+ | | + | | | | | + | +---------|------------+ | + | | | + | v | + | +----------------------+<------------ (Program PRAMIN to any + | | VRAM | | 64KB-aligned VRAM boundary) + | | (Several GBs) | | + | | | | + | | FB[0x000000000000] | | + | | ... | | + | | FB[0x7FFFFFFFFFF] | | + | +----------------------+ | + +------------------------------+ + +PBUS (PCIe Bus Controller) is responsible for, among other things, handling MMIO +accesses to the BAR registers. + +PRAMIN Window Operation +======================= + +The PRAMIN window provides a 1MB sliding aperture that can be repositioned over +the entire VRAM address space using the ``NV_PBUS_BAR0_WINDOW`` register. + +Window Control Mechanism +------------------------- + +The window position is controlled via the PBUS ``BAR0_WINDOW`` register:: + + NV_PBUS_BAR0_WINDOW Register (0x1700): + +-------+--------+--------------------------------------+ + | 31:26 | 25:24 | 23:0 | + | RSVD | TARGET | BASE_ADDR | + | | | (bits 39:16 of VRAM address) | + +-------+--------+--------------------------------------+ + + BASE_ADDR field (bits 23:0): + - Contains bits [39:16] of the target VRAM address + - Provides 40-bit (1TB) address space coverage + - Must be programmed with 64KB-aligned addresses + + TARGET field (bits 25:24): + - 0x0: VRAM (Video Memory) + - 0x1: SYS_MEM_COH (Coherent System Memory) + - 0x2: SYS_MEM_NONCOH (Non-coherent System Memory) + - 0x3: Reserved + + .. note:: + Nova only uses TARGET=VRAM (0x0) for video memory access. The SYS_MEM + target values are documented here for hardware completeness but are + not used by the driver. + +64KB Alignment Requirement +--------------------------- + +The PRAMIN window must be aligned to 64KB boundaries in VRAM. This is enforced +by the ``BASE_ADDR`` field representing bits [39:16] of the target address:: + + VRAM Address Calculation: + actual_vram_addr = (BASE_ADDR << 16) + pramin_offset + Where: + - BASE_ADDR: 24-bit value from NV_PBUS_BAR0_WINDOW[23:0] + - pramin_offset: 20-bit offset within the PRAMIN window [0x00000-0xFFFFF] + + Example Window Positioning: + +---------------------------------------------------------+ + | VRAM Space | + | | + | 0x000000000 +-----------------+ <-- 64KB aligned | + | | PRAMIN Window | | + | | (1MB) | | + | 0x0000FFFFF +-----------------+ | + | | + | | ^ | + | | | Window can slide | + | v | to any 64KB-aligned boundary | + | | + | 0x123400000 +-----------------+ <-- 64KB aligned | + | | PRAMIN Window | | + | | (1MB) | | + | 0x1234FFFFF +-----------------+ | + | | + | ... | + | | + | 0x7FFFF0000 +-----------------+ <-- 64KB aligned | + | | PRAMIN Window | | + | | (1MB) | | + | 0x7FFFFFFFF +-----------------+ | + +---------------------------------------------------------+ diff --git a/Documentation/gpu/nova/index.rst b/Documentation/gpu/nova/index.rst index e39cb3163581..b8254b1ffe2a 100644 --- a/Documentation/gpu/nova/index.rst +++ b/Documentation/gpu/nova/index.rst @@ -32,3 +32,4 @@ vGPU manager VFIO driver and the nova-drm driver. core/devinit core/fwsec core/falcon + core/pramin -- 2.34.1 ^ permalink raw reply related [flat|nested] 23+ messages in thread
* [PATCH RFC v5 5/6] docs: gpu: nova-core: Document the PRAMIN aperture mechanism @ 2025-12-19 20:38 ` Joel Fernandes 0 siblings, 0 replies; 23+ messages in thread From: Joel Fernandes @ 2025-12-19 20:38 UTC (permalink / raw) To: Maarten Lankhorst, Maxime Ripard, Thomas Zimmermann, David Airlie, Simona Vetter, Jonathan Corbet, Alex Deucher, Christian König, Jani Nikula, Joonas Lahtinen, Rodrigo Vivi, Tvrtko Ursulin, Huang Rui, Matthew Auld, Matthew Brost, Lucas De Marchi, Thomas Hellström, Helge Deller Cc: Danilo Krummrich, Alice Ryhl, Miguel Ojeda, Alex Gaynor, Boqun Feng, Gary Guo, Björn Roy Baron, Benno Lossin, Andreas Hindborg, Trevor Gross, Alistair Popple, Alexandre Courbot, Andrea Righi, Philipp Stanner, Elle Rhumsaa, Daniel Almeida, joel, nouveau, dri-devel, rust-for-linux, linux-kernel, linux-doc, amd-gfx, intel-gfx, intel-xe, linux-fbdev, Joel Fernandes Add documentation for the PRAMIN aperture mechanism used by nova-core for direct VRAM access. Nova only uses TARGET=VID_MEM for VRAM access. The SYS_MEM target values are documented for completeness but not used by the driver. Signed-off-by: Joel Fernandes <joelagnelf@nvidia.com> --- Documentation/gpu/nova/core/pramin.rst | 125 +++++++++++++++++++++++++ Documentation/gpu/nova/index.rst | 1 + 2 files changed, 126 insertions(+) create mode 100644 Documentation/gpu/nova/core/pramin.rst diff --git a/Documentation/gpu/nova/core/pramin.rst b/Documentation/gpu/nova/core/pramin.rst new file mode 100644 index 000000000000..55ec9d920629 --- /dev/null +++ b/Documentation/gpu/nova/core/pramin.rst @@ -0,0 +1,125 @@ +.. SPDX-License-Identifier: GPL-2.0 + +========================= +PRAMIN aperture mechanism +========================= + +.. note:: + The following description is approximate and current as of the Ampere family. + It may change for future generations and is intended to assist in understanding + the driver code. + +Introduction +============ + +PRAMIN is a hardware aperture mechanism that provides CPU access to GPU Video RAM (VRAM) before +the GPU's Memory Management Unit (MMU) and page tables are initialized. This 1MB sliding window, +located at a fixed offset within BAR0, is essential for setting up page tables and other critical +GPU data structures without relying on the GPU's MMU. + +Architecture Overview +===================== + +The PRAMIN aperture mechanism is logically implemented by the GPU's PBUS (PCIe Bus Controller Unit) +and provides a CPU-accessible window into VRAM through the PCIe interface:: + + +-----------------+ PCIe +------------------------------+ + | CPU |<----------->| GPU | + +-----------------+ | | + | +----------------------+ | + | | PBUS | | + | | (Bus Controller) | | + | | | | + | | +--------------+<------------ (window starts at + | | | PRAMIN | | | BAR0 + 0x700000) + | | | Window | | | + | | | (1MB) | | | + | | +--------------+ | | + | | | | | + | +---------|------------+ | + | | | + | v | + | +----------------------+<------------ (Program PRAMIN to any + | | VRAM | | 64KB-aligned VRAM boundary) + | | (Several GBs) | | + | | | | + | | FB[0x000000000000] | | + | | ... | | + | | FB[0x7FFFFFFFFFF] | | + | +----------------------+ | + +------------------------------+ + +PBUS (PCIe Bus Controller) is responsible for, among other things, handling MMIO +accesses to the BAR registers. + +PRAMIN Window Operation +======================= + +The PRAMIN window provides a 1MB sliding aperture that can be repositioned over +the entire VRAM address space using the ``NV_PBUS_BAR0_WINDOW`` register. + +Window Control Mechanism +------------------------- + +The window position is controlled via the PBUS ``BAR0_WINDOW`` register:: + + NV_PBUS_BAR0_WINDOW Register (0x1700): + +-------+--------+--------------------------------------+ + | 31:26 | 25:24 | 23:0 | + | RSVD | TARGET | BASE_ADDR | + | | | (bits 39:16 of VRAM address) | + +-------+--------+--------------------------------------+ + + BASE_ADDR field (bits 23:0): + - Contains bits [39:16] of the target VRAM address + - Provides 40-bit (1TB) address space coverage + - Must be programmed with 64KB-aligned addresses + + TARGET field (bits 25:24): + - 0x0: VRAM (Video Memory) + - 0x1: SYS_MEM_COH (Coherent System Memory) + - 0x2: SYS_MEM_NONCOH (Non-coherent System Memory) + - 0x3: Reserved + + .. note:: + Nova only uses TARGET=VRAM (0x0) for video memory access. The SYS_MEM + target values are documented here for hardware completeness but are + not used by the driver. + +64KB Alignment Requirement +--------------------------- + +The PRAMIN window must be aligned to 64KB boundaries in VRAM. This is enforced +by the ``BASE_ADDR`` field representing bits [39:16] of the target address:: + + VRAM Address Calculation: + actual_vram_addr = (BASE_ADDR << 16) + pramin_offset + Where: + - BASE_ADDR: 24-bit value from NV_PBUS_BAR0_WINDOW[23:0] + - pramin_offset: 20-bit offset within the PRAMIN window [0x00000-0xFFFFF] + + Example Window Positioning: + +---------------------------------------------------------+ + | VRAM Space | + | | + | 0x000000000 +-----------------+ <-- 64KB aligned | + | | PRAMIN Window | | + | | (1MB) | | + | 0x0000FFFFF +-----------------+ | + | | + | | ^ | + | | | Window can slide | + | v | to any 64KB-aligned boundary | + | | + | 0x123400000 +-----------------+ <-- 64KB aligned | + | | PRAMIN Window | | + | | (1MB) | | + | 0x1234FFFFF +-----------------+ | + | | + | ... | + | | + | 0x7FFFF0000 +-----------------+ <-- 64KB aligned | + | | PRAMIN Window | | + | | (1MB) | | + | 0x7FFFFFFFF +-----------------+ | + +---------------------------------------------------------+ diff --git a/Documentation/gpu/nova/index.rst b/Documentation/gpu/nova/index.rst index e39cb3163581..b8254b1ffe2a 100644 --- a/Documentation/gpu/nova/index.rst +++ b/Documentation/gpu/nova/index.rst @@ -32,3 +32,4 @@ vGPU manager VFIO driver and the nova-drm driver. core/devinit core/fwsec core/falcon + core/pramin -- 2.34.1 ^ permalink raw reply related [flat|nested] 23+ messages in thread
* [PATCH RFC v5 6/6] nova-core: Add PRAMIN aperture self-tests 2025-12-19 20:37 ` Joel Fernandes @ 2025-12-19 20:38 ` Joel Fernandes -1 siblings, 0 replies; 23+ messages in thread From: Joel Fernandes @ 2025-12-19 20:38 UTC (permalink / raw) To: Maarten Lankhorst, Maxime Ripard, Thomas Zimmermann, David Airlie, Simona Vetter, Jonathan Corbet, Alex Deucher, Christian König, Jani Nikula, Joonas Lahtinen, Rodrigo Vivi, Tvrtko Ursulin, Huang Rui, Matthew Auld, Matthew Brost, Lucas De Marchi, Thomas Hellström, Helge Deller Cc: Danilo Krummrich, Alice Ryhl, Miguel Ojeda, Alex Gaynor, Boqun Feng, Gary Guo, Björn Roy Baron, Benno Lossin, Andreas Hindborg, Trevor Gross, John Hubbard, Alistair Popple, Timur Tabi, Edwin Peer, Alexandre Courbot, Andrea Righi, Philipp Stanner, Elle Rhumsaa, Daniel Almeida, joel, nouveau, dri-devel, rust-for-linux, linux-kernel, linux-doc, amd-gfx, intel-gfx, intel-xe, linux-fbdev, Joel Fernandes Add self-tests for the PRAMIN aperture mechanism to verify correct operation during GPU probe. The tests validate: - Byte-level read/write at odd-aligned locations - Word write followed by byte-level readback (endianness verification) - Window repositioning across 1MB boundaries The tests are gated behind CONFIG_NOVA_PRAMIN_SELFTESTS which is disabled by default. When enabled, tests run after GSP boot during probe. Also remove the unused lint suppression at the module level since the PRAMIN code is now being actively used. Signed-off-by: Joel Fernandes <joelagnelf@nvidia.com> --- drivers/gpu/nova-core/Kconfig | 11 ++++ drivers/gpu/nova-core/gsp/boot.rs | 4 ++ drivers/gpu/nova-core/mm/pramin.rs | 102 ++++++++++++++++++++++++++++- 3 files changed, 115 insertions(+), 2 deletions(-) diff --git a/drivers/gpu/nova-core/Kconfig b/drivers/gpu/nova-core/Kconfig index 20d3e6d0d796..a37335e3381c 100644 --- a/drivers/gpu/nova-core/Kconfig +++ b/drivers/gpu/nova-core/Kconfig @@ -14,3 +14,14 @@ config NOVA_CORE This driver is work in progress and may not be functional. If M is selected, the module will be called nova_core. + +config NOVA_PRAMIN_SELFTESTS + bool "PRAMIN self-tests" + depends on NOVA_CORE + default n + help + Enable self-tests for the PRAMIN aperture mechanism. When enabled, + basic tests are run during GPU probe after GSP boot to + verify PRAMIN functionality. + + This is a testing option and should normally be disabled. diff --git a/drivers/gpu/nova-core/gsp/boot.rs b/drivers/gpu/nova-core/gsp/boot.rs index 54937606b5b0..b9750c86b6ed 100644 --- a/drivers/gpu/nova-core/gsp/boot.rs +++ b/drivers/gpu/nova-core/gsp/boot.rs @@ -239,6 +239,10 @@ pub(crate) fn boot( // Wait until GSP is fully initialized. commands::wait_gsp_init_done(&mut self.cmdq)?; + // Run PRAMIN aperture self-tests (disabled by default). + #[cfg(CONFIG_NOVA_PRAMIN_SELFTESTS)] + crate::mm::pramin::run_self_test(pdev.as_ref(), bar)?; + // Obtain and display basic GPU information. let info = commands::get_gsp_info(&mut self.cmdq, bar)?; dev_info!( diff --git a/drivers/gpu/nova-core/mm/pramin.rs b/drivers/gpu/nova-core/mm/pramin.rs index 5878a3f80b9c..483832b8f87e 100644 --- a/drivers/gpu/nova-core/mm/pramin.rs +++ b/drivers/gpu/nova-core/mm/pramin.rs @@ -1,7 +1,5 @@ // SPDX-License-Identifier: GPL-2.0 -#![expect(unused)] - //! Direct VRAM access through the PRAMIN aperture. //! //! PRAMIN provides a 1MB sliding window into VRAM through BAR0, allowing the CPU to access @@ -56,6 +54,8 @@ //! } //! ``` +#![allow(unused)] + use crate::{ driver::Bar0, regs, // @@ -198,3 +198,101 @@ unsafe impl Send for Window<'_> {} // SAFETY: `Window` requires `&mut self` for all accessors. unsafe impl Sync for Window<'_> {} + +/// Run PRAMIN self-tests during probe. +#[cfg(CONFIG_NOVA_PRAMIN_SELFTESTS)] +pub(crate) fn run_self_test(dev: &kernel::device::Device, bar: &Bar0) -> Result { + dev_info!(dev, "PRAMIN: Starting self-test...\n"); + + let mut win = Window::new(bar); + + // Use offset 0x1000 as test area. + let base: usize = 0x1000; + + // Test 1: Read/write at odd-aligned locations. + dev_info!(dev, "PRAMIN: Test 1 - Odd-aligned u8 read/write\n"); + for i in 0u8..4 { + let offset = base + 1 + i as usize; // Offsets 0x1001, 0x1002, 0x1003, 0x1004 + let val = 0xA0 + i; + win.try_write8(offset, val)?; + let read_val = win.try_read8(offset)?; + if read_val != val { + dev_err!( + dev, + "PRAMIN: FAIL - offset {:#x}: wrote {:#x}, read {:#x}\n", + offset, + val, + read_val + ); + return Err(EIO); + } + } + dev_info!(dev, "PRAMIN: Test 1 PASSED\n"); + + // Test 2: Write u32 and read back as u8s. + dev_info!(dev, "PRAMIN: Test 2 - Write u32, read as u8s\n"); + let test2_offset = base + 0x10; + let test2_val: u32 = 0xDEADBEEF; + win.try_write32(test2_offset, test2_val)?; + + // Read back as individual bytes (little-endian: EF BE AD DE). + let expected_bytes: [u8; 4] = [0xEF, 0xBE, 0xAD, 0xDE]; + for (i, &expected) in expected_bytes.iter().enumerate() { + let read_val = win.try_read8(test2_offset + i)?; + if read_val != expected { + dev_err!( + dev, + "PRAMIN: FAIL - offset {:#x}: expected {:#x}, read {:#x}\n", + test2_offset + i, + expected, + read_val + ); + return Err(EIO); + } + } + dev_info!(dev, "PRAMIN: Test 2 PASSED\n"); + + // Test 3: Window repositioning across 1MB boundaries. + // Write to offset > 1MB to trigger window slide, then verify. + dev_info!(dev, "PRAMIN: Test 4 - Window repositioning\n"); + let test4_offset_a = base; // First 1MB region + let test4_offset_b = 0x200000 + base; // 2MB + base (different 1MB region) + let val_a: u32 = 0x11111111; + let val_b: u32 = 0x22222222; + + // Write to first region. + win.try_write32(test4_offset_a, val_a)?; + + // Write to second region (triggers window reposition). + win.try_write32(test4_offset_b, val_b)?; + + // Read back from second region. + let read_b = win.try_read32(test4_offset_b)?; + if read_b != val_b { + dev_err!( + dev, + "PRAMIN: FAIL - offset {:#x}: expected {:#x}, read {:#x}\n", + test4_offset_b, + val_b, + read_b + ); + return Err(EIO); + } + + // Read back from first region (triggers window reposition again). + let read_a = win.try_read32(test4_offset_a)?; + if read_a != val_a { + dev_err!( + dev, + "PRAMIN: FAIL - offset {:#x}: expected {:#x}, read {:#x}\n", + test4_offset_a, + val_a, + read_a + ); + return Err(EIO); + } + dev_info!(dev, "PRAMIN: Test 3 PASSED\n"); + + dev_info!(dev, "PRAMIN: All self-tests PASSED\n"); + Ok(()) +} -- 2.34.1 ^ permalink raw reply related [flat|nested] 23+ messages in thread
* [PATCH RFC v5 6/6] nova-core: Add PRAMIN aperture self-tests @ 2025-12-19 20:38 ` Joel Fernandes 0 siblings, 0 replies; 23+ messages in thread From: Joel Fernandes @ 2025-12-19 20:38 UTC (permalink / raw) To: Maarten Lankhorst, Maxime Ripard, Thomas Zimmermann, David Airlie, Simona Vetter, Jonathan Corbet, Alex Deucher, Christian König, Jani Nikula, Joonas Lahtinen, Rodrigo Vivi, Tvrtko Ursulin, Huang Rui, Matthew Auld, Matthew Brost, Lucas De Marchi, Thomas Hellström, Helge Deller Cc: Danilo Krummrich, Alice Ryhl, Miguel Ojeda, Alex Gaynor, Boqun Feng, Gary Guo, Björn Roy Baron, Benno Lossin, Andreas Hindborg, Trevor Gross, Alistair Popple, Alexandre Courbot, Andrea Righi, Philipp Stanner, Elle Rhumsaa, Daniel Almeida, joel, nouveau, dri-devel, rust-for-linux, linux-kernel, linux-doc, amd-gfx, intel-gfx, intel-xe, linux-fbdev, Joel Fernandes Add self-tests for the PRAMIN aperture mechanism to verify correct operation during GPU probe. The tests validate: - Byte-level read/write at odd-aligned locations - Word write followed by byte-level readback (endianness verification) - Window repositioning across 1MB boundaries The tests are gated behind CONFIG_NOVA_PRAMIN_SELFTESTS which is disabled by default. When enabled, tests run after GSP boot during probe. Also remove the unused lint suppression at the module level since the PRAMIN code is now being actively used. Signed-off-by: Joel Fernandes <joelagnelf@nvidia.com> --- drivers/gpu/nova-core/Kconfig | 11 ++++ drivers/gpu/nova-core/gsp/boot.rs | 4 ++ drivers/gpu/nova-core/mm/pramin.rs | 102 ++++++++++++++++++++++++++++- 3 files changed, 115 insertions(+), 2 deletions(-) diff --git a/drivers/gpu/nova-core/Kconfig b/drivers/gpu/nova-core/Kconfig index 20d3e6d0d796..a37335e3381c 100644 --- a/drivers/gpu/nova-core/Kconfig +++ b/drivers/gpu/nova-core/Kconfig @@ -14,3 +14,14 @@ config NOVA_CORE This driver is work in progress and may not be functional. If M is selected, the module will be called nova_core. + +config NOVA_PRAMIN_SELFTESTS + bool "PRAMIN self-tests" + depends on NOVA_CORE + default n + help + Enable self-tests for the PRAMIN aperture mechanism. When enabled, + basic tests are run during GPU probe after GSP boot to + verify PRAMIN functionality. + + This is a testing option and should normally be disabled. diff --git a/drivers/gpu/nova-core/gsp/boot.rs b/drivers/gpu/nova-core/gsp/boot.rs index 54937606b5b0..b9750c86b6ed 100644 --- a/drivers/gpu/nova-core/gsp/boot.rs +++ b/drivers/gpu/nova-core/gsp/boot.rs @@ -239,6 +239,10 @@ pub(crate) fn boot( // Wait until GSP is fully initialized. commands::wait_gsp_init_done(&mut self.cmdq)?; + // Run PRAMIN aperture self-tests (disabled by default). + #[cfg(CONFIG_NOVA_PRAMIN_SELFTESTS)] + crate::mm::pramin::run_self_test(pdev.as_ref(), bar)?; + // Obtain and display basic GPU information. let info = commands::get_gsp_info(&mut self.cmdq, bar)?; dev_info!( diff --git a/drivers/gpu/nova-core/mm/pramin.rs b/drivers/gpu/nova-core/mm/pramin.rs index 5878a3f80b9c..483832b8f87e 100644 --- a/drivers/gpu/nova-core/mm/pramin.rs +++ b/drivers/gpu/nova-core/mm/pramin.rs @@ -1,7 +1,5 @@ // SPDX-License-Identifier: GPL-2.0 -#![expect(unused)] - //! Direct VRAM access through the PRAMIN aperture. //! //! PRAMIN provides a 1MB sliding window into VRAM through BAR0, allowing the CPU to access @@ -56,6 +54,8 @@ //! } //! ``` +#![allow(unused)] + use crate::{ driver::Bar0, regs, // @@ -198,3 +198,101 @@ unsafe impl Send for Window<'_> {} // SAFETY: `Window` requires `&mut self` for all accessors. unsafe impl Sync for Window<'_> {} + +/// Run PRAMIN self-tests during probe. +#[cfg(CONFIG_NOVA_PRAMIN_SELFTESTS)] +pub(crate) fn run_self_test(dev: &kernel::device::Device, bar: &Bar0) -> Result { + dev_info!(dev, "PRAMIN: Starting self-test...\n"); + + let mut win = Window::new(bar); + + // Use offset 0x1000 as test area. + let base: usize = 0x1000; + + // Test 1: Read/write at odd-aligned locations. + dev_info!(dev, "PRAMIN: Test 1 - Odd-aligned u8 read/write\n"); + for i in 0u8..4 { + let offset = base + 1 + i as usize; // Offsets 0x1001, 0x1002, 0x1003, 0x1004 + let val = 0xA0 + i; + win.try_write8(offset, val)?; + let read_val = win.try_read8(offset)?; + if read_val != val { + dev_err!( + dev, + "PRAMIN: FAIL - offset {:#x}: wrote {:#x}, read {:#x}\n", + offset, + val, + read_val + ); + return Err(EIO); + } + } + dev_info!(dev, "PRAMIN: Test 1 PASSED\n"); + + // Test 2: Write u32 and read back as u8s. + dev_info!(dev, "PRAMIN: Test 2 - Write u32, read as u8s\n"); + let test2_offset = base + 0x10; + let test2_val: u32 = 0xDEADBEEF; + win.try_write32(test2_offset, test2_val)?; + + // Read back as individual bytes (little-endian: EF BE AD DE). + let expected_bytes: [u8; 4] = [0xEF, 0xBE, 0xAD, 0xDE]; + for (i, &expected) in expected_bytes.iter().enumerate() { + let read_val = win.try_read8(test2_offset + i)?; + if read_val != expected { + dev_err!( + dev, + "PRAMIN: FAIL - offset {:#x}: expected {:#x}, read {:#x}\n", + test2_offset + i, + expected, + read_val + ); + return Err(EIO); + } + } + dev_info!(dev, "PRAMIN: Test 2 PASSED\n"); + + // Test 3: Window repositioning across 1MB boundaries. + // Write to offset > 1MB to trigger window slide, then verify. + dev_info!(dev, "PRAMIN: Test 4 - Window repositioning\n"); + let test4_offset_a = base; // First 1MB region + let test4_offset_b = 0x200000 + base; // 2MB + base (different 1MB region) + let val_a: u32 = 0x11111111; + let val_b: u32 = 0x22222222; + + // Write to first region. + win.try_write32(test4_offset_a, val_a)?; + + // Write to second region (triggers window reposition). + win.try_write32(test4_offset_b, val_b)?; + + // Read back from second region. + let read_b = win.try_read32(test4_offset_b)?; + if read_b != val_b { + dev_err!( + dev, + "PRAMIN: FAIL - offset {:#x}: expected {:#x}, read {:#x}\n", + test4_offset_b, + val_b, + read_b + ); + return Err(EIO); + } + + // Read back from first region (triggers window reposition again). + let read_a = win.try_read32(test4_offset_a)?; + if read_a != val_a { + dev_err!( + dev, + "PRAMIN: FAIL - offset {:#x}: expected {:#x}, read {:#x}\n", + test4_offset_a, + val_a, + read_a + ); + return Err(EIO); + } + dev_info!(dev, "PRAMIN: Test 3 PASSED\n"); + + dev_info!(dev, "PRAMIN: All self-tests PASSED\n"); + Ok(()) +} -- 2.34.1 ^ permalink raw reply related [flat|nested] 23+ messages in thread
* ✓ i915.CI.BAT: success for nova-core: Memory management initial patches 2025-12-19 20:37 ` Joel Fernandes ` (6 preceding siblings ...) (?) @ 2025-12-19 22:39 ` Patchwork -1 siblings, 0 replies; 23+ messages in thread From: Patchwork @ 2025-12-19 22:39 UTC (permalink / raw) To: Joel Fernandes; +Cc: intel-gfx [-- Attachment #1: Type: text/plain, Size: 2374 bytes --] == Series Details == Series: nova-core: Memory management initial patches URL : https://patchwork.freedesktop.org/series/159315/ State : success == Summary == CI Bug Log - changes from CI_DRM_17721 -> Patchwork_159315v1 ==================================================== Summary ------- **SUCCESS** No regressions found. External URL: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/index.html Participating hosts (43 -> 41) ------------------------------ Missing (2): bat-dg2-13 fi-snb-2520m Known issues ------------ Here are the changes found in Patchwork_159315v1 that come from known issues: ### IGT changes ### #### Issues hit #### * igt@i915_selftest@live@workarounds: - bat-arlh-3: [PASS][1] -> [DMESG-FAIL][2] ([i915#12061]) +1 other test dmesg-fail [1]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/bat-arlh-3/igt@i915_selftest@live@workarounds.html [2]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/bat-arlh-3/igt@i915_selftest@live@workarounds.html #### Possible fixes #### * igt@i915_selftest@live: - bat-mtlp-8: [DMESG-FAIL][3] ([i915#12061]) -> [PASS][4] +1 other test pass [3]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/bat-mtlp-8/igt@i915_selftest@live.html [4]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/bat-mtlp-8/igt@i915_selftest@live.html * igt@i915_selftest@live@workarounds: - bat-arls-5: [DMESG-FAIL][5] ([i915#12061]) -> [PASS][6] +1 other test pass [5]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/bat-arls-5/igt@i915_selftest@live@workarounds.html [6]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/bat-arls-5/igt@i915_selftest@live@workarounds.html [i915#12061]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/12061 Build changes ------------- * Linux: CI_DRM_17721 -> Patchwork_159315v1 CI-20190529: 20190529 CI_DRM_17721: 66200de68e2db77f251879ede0a001f64abcd60d @ git://anongit.freedesktop.org/gfx-ci/linux IGT_8674: f38f4d8e9c65aff45ac807e646d06e38bc3193a2 @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git Patchwork_159315v1: 66200de68e2db77f251879ede0a001f64abcd60d @ git://anongit.freedesktop.org/gfx-ci/linux == Logs == For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/index.html [-- Attachment #2: Type: text/html, Size: 3177 bytes --] ^ permalink raw reply [flat|nested] 23+ messages in thread
* ✗ CI.checkpatch: warning for nova-core: Memory management initial patches 2025-12-19 20:37 ` Joel Fernandes ` (7 preceding siblings ...) (?) @ 2025-12-22 14:15 ` Patchwork -1 siblings, 0 replies; 23+ messages in thread From: Patchwork @ 2025-12-22 14:15 UTC (permalink / raw) To: Joel Fernandes; +Cc: intel-xe == Series Details == Series: nova-core: Memory management initial patches URL : https://patchwork.freedesktop.org/series/159316/ State : warning == Summary == + KERNEL=/kernel + git clone https://gitlab.freedesktop.org/drm/maintainer-tools mt Cloning into 'mt'... warning: redirecting to https://gitlab.freedesktop.org/drm/maintainer-tools.git/ + git -C mt rev-list -n1 origin/master 99339247d1ae4378b24366da182e712bdc623311 + cd /kernel + git config --global --add safe.directory /kernel + git log -n1 commit 161a78dd1d28c025c39662c58e75cc60f0f21bd6 Author: Joel Fernandes <joelagnelf@nvidia.com> Date: Fri Dec 19 15:38:05 2025 -0500 nova-core: Add PRAMIN aperture self-tests Add self-tests for the PRAMIN aperture mechanism to verify correct operation during GPU probe. The tests validate: - Byte-level read/write at odd-aligned locations - Word write followed by byte-level readback (endianness verification) - Window repositioning across 1MB boundaries The tests are gated behind CONFIG_NOVA_PRAMIN_SELFTESTS which is disabled by default. When enabled, tests run after GSP boot during probe. Also remove the unused lint suppression at the module level since the PRAMIN code is now being actively used. Signed-off-by: Joel Fernandes <joelagnelf@nvidia.com> + /mt/dim checkpatch 373a53bd0fb5466451d376c4d54409d271ff26f2 drm-intel 270cb832d54a rust: clist: Add support to interface with C linked lists -:45: WARNING:FILE_PATH_CHANGES: added, moved or deleted file(s), does MAINTAINERS need updating? #45: new file mode 100644 total: 0 errors, 1 warnings, 0 checks, 396 lines checked a74e4961da6e gpu: Move DRM buddy allocator one level up -:39: WARNING:FILE_PATH_CHANGES: added, moved or deleted file(s), does MAINTAINERS need updating? #39: new file mode 100644 -:51: WARNING:CONFIG_DESCRIPTION: please write a help paragraph that fully describes the config symbol with at least 4 lines #51: FILE: drivers/gpu/Kconfig:8: +config GPU_BUDDY_KUNIT_TEST + tristate "KUnit tests for GPU buddy allocator" if !KUNIT_ALL_TESTS + depends on GPU_BUDDY && KUNIT + default KUNIT_ALL_TESTS + help + KUnit tests for the GPU buddy allocator. -:95: WARNING:AVOID_BUG: Do not crash the kernel unless it is absolutely unavoidable--use WARN_ON_ONCE() plus recovery code (if feasible) instead of BUG() or variants #95: FILE: drivers/gpu/buddy.c:23: + BUG_ON(order > GPU_BUDDY_MAX_ORDER); -:107: WARNING:AVOID_BUG: Do not crash the kernel unless it is absolutely unavoidable--use WARN_ON_ONCE() plus recovery code (if feasible) instead of BUG() or variants #107: FILE: drivers/gpu/buddy.c:35: + BUG_ON(block->header & GPU_BUDDY_HEADER_UNUSED); -:382: WARNING:AVOID_BUG: Do not crash the kernel unless it is absolutely unavoidable--use WARN_ON_ONCE() plus recovery code (if feasible) instead of BUG() or variants #382: FILE: drivers/gpu/buddy.c:310: + BUG_ON(mm->max_order > GPU_BUDDY_MAX_ORDER); -:427: WARNING:AVOID_BUG: Do not crash the kernel unless it is absolutely unavoidable--use WARN_ON_ONCE() plus recovery code (if feasible) instead of BUG() or variants #427: FILE: drivers/gpu/buddy.c:355: + BUG_ON(root_count > mm->max_order); -:428: WARNING:AVOID_BUG: Do not crash the kernel unless it is absolutely unavoidable--use WARN_ON_ONCE() plus recovery code (if feasible) instead of BUG() or variants #428: FILE: drivers/gpu/buddy.c:356: + BUG_ON(gpu_buddy_block_size(mm, root) < chunk_size); -:494: WARNING:AVOID_BUG: Do not crash the kernel unless it is absolutely unavoidable--use WARN_ON_ONCE() plus recovery code (if feasible) instead of BUG() or variants #494: FILE: drivers/gpu/buddy.c:422: + BUG_ON(!gpu_buddy_block_is_free(block)); -:495: WARNING:AVOID_BUG: Do not crash the kernel unless it is absolutely unavoidable--use WARN_ON_ONCE() plus recovery code (if feasible) instead of BUG() or variants #495: FILE: drivers/gpu/buddy.c:423: + BUG_ON(!gpu_buddy_block_order(block)); -:597: WARNING:AVOID_BUG: Do not crash the kernel unless it is absolutely unavoidable--use WARN_ON_ONCE() plus recovery code (if feasible) instead of BUG() or variants #597: FILE: drivers/gpu/buddy.c:525: + BUG_ON(!gpu_buddy_block_is_allocated(block)); -:845: WARNING:AVOID_BUG: Do not crash the kernel unless it is absolutely unavoidable--use WARN_ON_ONCE() plus recovery code (if feasible) instead of BUG() or variants #845: FILE: drivers/gpu/buddy.c:773: + BUG_ON(!gpu_buddy_block_is_free(block)); -:1221: WARNING:AVOID_BUG: Do not crash the kernel unless it is absolutely unavoidable--use WARN_ON_ONCE() plus recovery code (if feasible) instead of BUG() or variants #1221: FILE: drivers/gpu/buddy.c:1149: + BUG_ON(order > mm->max_order); -:1222: WARNING:AVOID_BUG: Do not crash the kernel unless it is absolutely unavoidable--use WARN_ON_ONCE() plus recovery code (if feasible) instead of BUG() or variants #1222: FILE: drivers/gpu/buddy.c:1150: + BUG_ON(order < min_order); -:1348: WARNING:AVOID_BUG: Do not crash the kernel unless it is absolutely unavoidable--use WARN_ON_ONCE() plus recovery code (if feasible) instead of BUG() or variants #1348: FILE: drivers/gpu/buddy.c:1276: + BUG_ON(!gpu_buddy_block_is_free(block)); -:3135: CHECK:OPEN_ENDED_LINE: Lines should not end with a '(' #3135: FILE: drivers/gpu/drm/drm_buddy.c:40: + drm_printf( -:3149: ERROR:OPEN_BRACE: that open brace { should be on the previous line #3149: FILE: drivers/gpu/drm/drm_buddy.c:52: + for_each_free_tree(tree) + { -:3157: WARNING:AVOID_BUG: Do not crash the kernel unless it is absolutely unavoidable--use WARN_ON_ONCE() plus recovery code (if feasible) instead of BUG() or variants #3157: FILE: drivers/gpu/drm/drm_buddy.c:58: + BUG_ON(!gpu_buddy_block_is_free(block)); -:5351: CHECK:MACRO_ARG_REUSE: Macro argument reuse 'tree' - possible side-effects? #5351: FILE: include/linux/gpu_buddy.h:28: +#define for_each_free_tree(tree) \ + for ((tree) = 0; (tree) < GPU_BUDDY_MAX_FREE_TREES; (tree)++) total: 1 errors, 15 warnings, 2 checks, 5193 lines checked 33ca9f4b178d rust: gpu: Add GPU buddy allocator bindings -:43: WARNING:FILE_PATH_CHANGES: added, moved or deleted file(s), does MAINTAINERS need updating? #43: new file mode 100644 total: 0 errors, 1 warnings, 0 checks, 584 lines checked ecf92b9dca15 nova-core: mm: Add support to use PRAMIN windows to write to VRAM -:13: WARNING:FILE_PATH_CHANGES: added, moved or deleted file(s), does MAINTAINERS need updating? #13: new file mode 100644 total: 0 errors, 1 warnings, 0 checks, 223 lines checked c2d8aa39aa72 docs: gpu: nova-core: Document the PRAMIN aperture mechanism -:15: WARNING:FILE_PATH_CHANGES: added, moved or deleted file(s), does MAINTAINERS need updating? #15: new file mode 100644 total: 0 errors, 1 warnings, 0 checks, 129 lines checked 161a78dd1d28 nova-core: Add PRAMIN aperture self-tests ^ permalink raw reply [flat|nested] 23+ messages in thread
* ✓ CI.KUnit: success for nova-core: Memory management initial patches 2025-12-19 20:37 ` Joel Fernandes ` (8 preceding siblings ...) (?) @ 2025-12-22 14:17 ` Patchwork -1 siblings, 0 replies; 23+ messages in thread From: Patchwork @ 2025-12-22 14:17 UTC (permalink / raw) To: Joel Fernandes; +Cc: intel-xe == Series Details == Series: nova-core: Memory management initial patches URL : https://patchwork.freedesktop.org/series/159316/ State : success == Summary == + trap cleanup EXIT + /kernel/tools/testing/kunit/kunit.py run --kunitconfig /kernel/drivers/gpu/drm/xe/.kunitconfig [14:15:53] Configuring KUnit Kernel ... Generating .config ... Populating config with: $ make ARCH=um O=.kunit olddefconfig [14:15:57] Building KUnit Kernel ... Populating config with: $ make ARCH=um O=.kunit olddefconfig Building with: $ make all compile_commands.json scripts_gdb ARCH=um O=.kunit --jobs=48 [14:16:29] Starting KUnit Kernel (1/1)... [14:16:29] ============================================================ Running tests with: $ .kunit/linux kunit.enable=1 mem=1G console=tty kunit_shutdown=halt [14:16:29] ================== guc_buf (11 subtests) =================== [14:16:29] [PASSED] test_smallest [14:16:29] [PASSED] test_largest [14:16:29] [PASSED] test_granular [14:16:29] [PASSED] test_unique [14:16:29] [PASSED] test_overlap [14:16:29] [PASSED] test_reusable [14:16:29] [PASSED] test_too_big [14:16:29] [PASSED] test_flush [14:16:29] [PASSED] test_lookup [14:16:29] [PASSED] test_data [14:16:29] [PASSED] test_class [14:16:29] ===================== [PASSED] guc_buf ===================== [14:16:29] =================== guc_dbm (7 subtests) =================== [14:16:29] [PASSED] test_empty [14:16:29] [PASSED] test_default [14:16:29] ======================== test_size ======================== [14:16:29] [PASSED] 4 [14:16:29] [PASSED] 8 [14:16:29] [PASSED] 32 [14:16:29] [PASSED] 256 [14:16:29] ==================== [PASSED] test_size ==================== [14:16:29] ======================= test_reuse ======================== [14:16:29] [PASSED] 4 [14:16:29] [PASSED] 8 [14:16:29] [PASSED] 32 [14:16:29] [PASSED] 256 [14:16:29] =================== [PASSED] test_reuse ==================== [14:16:29] =================== test_range_overlap ==================== [14:16:29] [PASSED] 4 [14:16:29] [PASSED] 8 [14:16:29] [PASSED] 32 [14:16:29] [PASSED] 256 [14:16:29] =============== [PASSED] test_range_overlap ================ [14:16:29] =================== test_range_compact ==================== [14:16:29] [PASSED] 4 [14:16:29] [PASSED] 8 [14:16:29] [PASSED] 32 [14:16:29] [PASSED] 256 [14:16:29] =============== [PASSED] test_range_compact ================ [14:16:29] ==================== test_range_spare ===================== [14:16:29] [PASSED] 4 [14:16:29] [PASSED] 8 [14:16:29] [PASSED] 32 [14:16:29] [PASSED] 256 [14:16:29] ================ [PASSED] test_range_spare ================= [14:16:29] ===================== [PASSED] guc_dbm ===================== [14:16:29] =================== guc_idm (6 subtests) =================== [14:16:29] [PASSED] bad_init [14:16:29] [PASSED] no_init [14:16:29] [PASSED] init_fini [14:16:29] [PASSED] check_used [14:16:29] [PASSED] check_quota [14:16:29] [PASSED] check_all [14:16:29] ===================== [PASSED] guc_idm ===================== [14:16:29] ================== no_relay (3 subtests) =================== [14:16:29] [PASSED] xe_drops_guc2pf_if_not_ready [14:16:29] [PASSED] xe_drops_guc2vf_if_not_ready [14:16:29] [PASSED] xe_rejects_send_if_not_ready [14:16:29] ==================== [PASSED] no_relay ===================== [14:16:29] ================== pf_relay (14 subtests) ================== [14:16:29] [PASSED] pf_rejects_guc2pf_too_short [14:16:29] [PASSED] pf_rejects_guc2pf_too_long [14:16:29] [PASSED] pf_rejects_guc2pf_no_payload [14:16:29] [PASSED] pf_fails_no_payload [14:16:29] [PASSED] pf_fails_bad_origin [14:16:29] [PASSED] pf_fails_bad_type [14:16:29] [PASSED] pf_txn_reports_error [14:16:29] [PASSED] pf_txn_sends_pf2guc [14:16:29] [PASSED] pf_sends_pf2guc [14:16:29] [SKIPPED] pf_loopback_nop [14:16:29] [SKIPPED] pf_loopback_echo [14:16:29] [SKIPPED] pf_loopback_fail [14:16:29] [SKIPPED] pf_loopback_busy [14:16:29] [SKIPPED] pf_loopback_retry [14:16:29] ==================== [PASSED] pf_relay ===================== [14:16:29] ================== vf_relay (3 subtests) =================== [14:16:29] [PASSED] vf_rejects_guc2vf_too_short [14:16:29] [PASSED] vf_rejects_guc2vf_too_long [14:16:29] [PASSED] vf_rejects_guc2vf_no_payload [14:16:29] ==================== [PASSED] vf_relay ===================== [14:16:29] ================ pf_gt_config (6 subtests) ================= [14:16:29] [PASSED] fair_contexts_1vf [14:16:29] [PASSED] fair_doorbells_1vf [14:16:29] [PASSED] fair_ggtt_1vf [14:16:29] ====================== fair_contexts ====================== [14:16:29] [PASSED] 1 VF [14:16:29] [PASSED] 2 VFs [14:16:29] [PASSED] 3 VFs [14:16:29] [PASSED] 4 VFs [14:16:29] [PASSED] 5 VFs [14:16:29] [PASSED] 6 VFs [14:16:29] [PASSED] 7 VFs [14:16:29] [PASSED] 8 VFs [14:16:29] [PASSED] 9 VFs [14:16:29] [PASSED] 10 VFs [14:16:29] [PASSED] 11 VFs [14:16:29] [PASSED] 12 VFs [14:16:29] [PASSED] 13 VFs [14:16:29] [PASSED] 14 VFs [14:16:29] [PASSED] 15 VFs [14:16:29] [PASSED] 16 VFs [14:16:29] [PASSED] 17 VFs [14:16:29] [PASSED] 18 VFs [14:16:29] [PASSED] 19 VFs [14:16:29] [PASSED] 20 VFs [14:16:29] [PASSED] 21 VFs [14:16:29] [PASSED] 22 VFs [14:16:29] [PASSED] 23 VFs [14:16:29] [PASSED] 24 VFs [14:16:29] [PASSED] 25 VFs [14:16:29] [PASSED] 26 VFs [14:16:29] [PASSED] 27 VFs [14:16:29] [PASSED] 28 VFs [14:16:29] [PASSED] 29 VFs [14:16:29] [PASSED] 30 VFs [14:16:29] [PASSED] 31 VFs [14:16:29] [PASSED] 32 VFs [14:16:29] [PASSED] 33 VFs [14:16:29] [PASSED] 34 VFs [14:16:29] [PASSED] 35 VFs [14:16:29] [PASSED] 36 VFs [14:16:29] [PASSED] 37 VFs [14:16:29] [PASSED] 38 VFs [14:16:29] [PASSED] 39 VFs [14:16:29] [PASSED] 40 VFs [14:16:29] [PASSED] 41 VFs [14:16:29] [PASSED] 42 VFs [14:16:29] [PASSED] 43 VFs [14:16:29] [PASSED] 44 VFs [14:16:29] [PASSED] 45 VFs [14:16:29] [PASSED] 46 VFs [14:16:29] [PASSED] 47 VFs [14:16:29] [PASSED] 48 VFs [14:16:29] [PASSED] 49 VFs [14:16:29] [PASSED] 50 VFs [14:16:29] [PASSED] 51 VFs [14:16:29] [PASSED] 52 VFs [14:16:29] [PASSED] 53 VFs [14:16:29] [PASSED] 54 VFs [14:16:29] [PASSED] 55 VFs [14:16:29] [PASSED] 56 VFs [14:16:29] [PASSED] 57 VFs [14:16:29] [PASSED] 58 VFs [14:16:29] [PASSED] 59 VFs [14:16:29] [PASSED] 60 VFs [14:16:29] [PASSED] 61 VFs [14:16:29] [PASSED] 62 VFs [14:16:29] [PASSED] 63 VFs [14:16:29] ================== [PASSED] fair_contexts ================== [14:16:29] ===================== fair_doorbells ====================== [14:16:29] [PASSED] 1 VF [14:16:29] [PASSED] 2 VFs [14:16:29] [PASSED] 3 VFs [14:16:29] [PASSED] 4 VFs [14:16:29] [PASSED] 5 VFs [14:16:29] [PASSED] 6 VFs [14:16:29] [PASSED] 7 VFs [14:16:29] [PASSED] 8 VFs [14:16:29] [PASSED] 9 VFs [14:16:29] [PASSED] 10 VFs [14:16:29] [PASSED] 11 VFs [14:16:29] [PASSED] 12 VFs [14:16:29] [PASSED] 13 VFs [14:16:29] [PASSED] 14 VFs [14:16:29] [PASSED] 15 VFs [14:16:29] [PASSED] 16 VFs [14:16:29] [PASSED] 17 VFs [14:16:29] [PASSED] 18 VFs [14:16:29] [PASSED] 19 VFs [14:16:29] [PASSED] 20 VFs [14:16:29] [PASSED] 21 VFs [14:16:29] [PASSED] 22 VFs [14:16:29] [PASSED] 23 VFs [14:16:29] [PASSED] 24 VFs [14:16:29] [PASSED] 25 VFs [14:16:29] [PASSED] 26 VFs [14:16:29] [PASSED] 27 VFs [14:16:29] [PASSED] 28 VFs [14:16:29] [PASSED] 29 VFs [14:16:29] [PASSED] 30 VFs [14:16:29] [PASSED] 31 VFs [14:16:29] [PASSED] 32 VFs [14:16:29] [PASSED] 33 VFs [14:16:29] [PASSED] 34 VFs [14:16:29] [PASSED] 35 VFs [14:16:29] [PASSED] 36 VFs [14:16:29] [PASSED] 37 VFs [14:16:29] [PASSED] 38 VFs [14:16:29] [PASSED] 39 VFs [14:16:29] [PASSED] 40 VFs [14:16:29] [PASSED] 41 VFs [14:16:29] [PASSED] 42 VFs [14:16:29] [PASSED] 43 VFs [14:16:29] [PASSED] 44 VFs [14:16:29] [PASSED] 45 VFs [14:16:29] [PASSED] 46 VFs [14:16:29] [PASSED] 47 VFs [14:16:29] [PASSED] 48 VFs [14:16:29] [PASSED] 49 VFs [14:16:29] [PASSED] 50 VFs [14:16:29] [PASSED] 51 VFs [14:16:29] [PASSED] 52 VFs [14:16:29] [PASSED] 53 VFs [14:16:29] [PASSED] 54 VFs [14:16:29] [PASSED] 55 VFs [14:16:29] [PASSED] 56 VFs [14:16:29] [PASSED] 57 VFs [14:16:29] [PASSED] 58 VFs [14:16:29] [PASSED] 59 VFs [14:16:29] [PASSED] 60 VFs [14:16:29] [PASSED] 61 VFs [14:16:29] [PASSED] 62 VFs [14:16:29] [PASSED] 63 VFs [14:16:29] ================= [PASSED] fair_doorbells ================== [14:16:29] ======================== fair_ggtt ======================== [14:16:29] [PASSED] 1 VF [14:16:29] [PASSED] 2 VFs [14:16:29] [PASSED] 3 VFs [14:16:29] [PASSED] 4 VFs [14:16:29] [PASSED] 5 VFs [14:16:29] [PASSED] 6 VFs [14:16:29] [PASSED] 7 VFs [14:16:29] [PASSED] 8 VFs [14:16:29] [PASSED] 9 VFs [14:16:29] [PASSED] 10 VFs [14:16:29] [PASSED] 11 VFs [14:16:29] [PASSED] 12 VFs [14:16:29] [PASSED] 13 VFs [14:16:29] [PASSED] 14 VFs [14:16:29] [PASSED] 15 VFs [14:16:29] [PASSED] 16 VFs [14:16:29] [PASSED] 17 VFs [14:16:29] [PASSED] 18 VFs [14:16:29] [PASSED] 19 VFs [14:16:29] [PASSED] 20 VFs [14:16:29] [PASSED] 21 VFs [14:16:29] [PASSED] 22 VFs [14:16:29] [PASSED] 23 VFs [14:16:29] [PASSED] 24 VFs [14:16:29] [PASSED] 25 VFs [14:16:29] [PASSED] 26 VFs [14:16:29] [PASSED] 27 VFs [14:16:29] [PASSED] 28 VFs [14:16:29] [PASSED] 29 VFs [14:16:29] [PASSED] 30 VFs [14:16:29] [PASSED] 31 VFs [14:16:29] [PASSED] 32 VFs [14:16:29] [PASSED] 33 VFs [14:16:29] [PASSED] 34 VFs [14:16:29] [PASSED] 35 VFs [14:16:29] [PASSED] 36 VFs [14:16:29] [PASSED] 37 VFs [14:16:29] [PASSED] 38 VFs [14:16:29] [PASSED] 39 VFs [14:16:29] [PASSED] 40 VFs [14:16:29] [PASSED] 41 VFs [14:16:29] [PASSED] 42 VFs [14:16:29] [PASSED] 43 VFs [14:16:29] [PASSED] 44 VFs [14:16:29] [PASSED] 45 VFs [14:16:29] [PASSED] 46 VFs [14:16:29] [PASSED] 47 VFs [14:16:29] [PASSED] 48 VFs [14:16:29] [PASSED] 49 VFs [14:16:29] [PASSED] 50 VFs [14:16:29] [PASSED] 51 VFs [14:16:29] [PASSED] 52 VFs [14:16:29] [PASSED] 53 VFs [14:16:29] [PASSED] 54 VFs [14:16:29] [PASSED] 55 VFs [14:16:29] [PASSED] 56 VFs [14:16:29] [PASSED] 57 VFs [14:16:29] [PASSED] 58 VFs [14:16:29] [PASSED] 59 VFs [14:16:29] [PASSED] 60 VFs [14:16:29] [PASSED] 61 VFs [14:16:29] [PASSED] 62 VFs [14:16:29] [PASSED] 63 VFs [14:16:29] ==================== [PASSED] fair_ggtt ==================== [14:16:29] ================== [PASSED] pf_gt_config =================== [14:16:29] ===================== lmtt (1 subtest) ===================== [14:16:29] ======================== test_ops ========================= [14:16:29] [PASSED] 2-level [14:16:29] [PASSED] multi-level [14:16:29] ==================== [PASSED] test_ops ===================== [14:16:29] ====================== [PASSED] lmtt ======================= [14:16:29] ================= pf_service (11 subtests) ================= [14:16:29] [PASSED] pf_negotiate_any [14:16:29] [PASSED] pf_negotiate_base_match [14:16:29] [PASSED] pf_negotiate_base_newer [14:16:29] [PASSED] pf_negotiate_base_next [14:16:29] [SKIPPED] pf_negotiate_base_older [14:16:29] [PASSED] pf_negotiate_base_prev [14:16:29] [PASSED] pf_negotiate_latest_match [14:16:29] [PASSED] pf_negotiate_latest_newer [14:16:29] [PASSED] pf_negotiate_latest_next [14:16:29] [SKIPPED] pf_negotiate_latest_older [14:16:29] [SKIPPED] pf_negotiate_latest_prev [14:16:29] =================== [PASSED] pf_service ==================== [14:16:29] ================= xe_guc_g2g (2 subtests) ================== [14:16:29] ============== xe_live_guc_g2g_kunit_default ============== [14:16:29] ========= [SKIPPED] xe_live_guc_g2g_kunit_default ========== [14:16:29] ============== xe_live_guc_g2g_kunit_allmem =============== [14:16:29] ========== [SKIPPED] xe_live_guc_g2g_kunit_allmem ========== [14:16:29] =================== [SKIPPED] xe_guc_g2g =================== [14:16:29] =================== xe_mocs (2 subtests) =================== [14:16:29] ================ xe_live_mocs_kernel_kunit ================ [14:16:29] =========== [SKIPPED] xe_live_mocs_kernel_kunit ============ [14:16:29] ================ xe_live_mocs_reset_kunit ================= [14:16:29] ============ [SKIPPED] xe_live_mocs_reset_kunit ============ [14:16:29] ==================== [SKIPPED] xe_mocs ===================== [14:16:29] ================= xe_migrate (2 subtests) ================== [14:16:29] ================= xe_migrate_sanity_kunit ================= [14:16:29] ============ [SKIPPED] xe_migrate_sanity_kunit ============= [14:16:29] ================== xe_validate_ccs_kunit ================== [14:16:29] ============= [SKIPPED] xe_validate_ccs_kunit ============== [14:16:29] =================== [SKIPPED] xe_migrate =================== [14:16:29] ================== xe_dma_buf (1 subtest) ================== [14:16:29] ==================== xe_dma_buf_kunit ===================== [14:16:29] ================ [SKIPPED] xe_dma_buf_kunit ================ [14:16:29] =================== [SKIPPED] xe_dma_buf =================== [14:16:29] ================= xe_bo_shrink (1 subtest) ================= [14:16:29] =================== xe_bo_shrink_kunit ==================== [14:16:29] =============== [SKIPPED] xe_bo_shrink_kunit =============== [14:16:29] ================== [SKIPPED] xe_bo_shrink ================== [14:16:29] ==================== xe_bo (2 subtests) ==================== [14:16:29] ================== xe_ccs_migrate_kunit =================== [14:16:29] ============== [SKIPPED] xe_ccs_migrate_kunit ============== [14:16:29] ==================== xe_bo_evict_kunit ==================== [14:16:29] =============== [SKIPPED] xe_bo_evict_kunit ================ [14:16:29] ===================== [SKIPPED] xe_bo ====================== [14:16:29] ==================== args (13 subtests) ==================== [14:16:29] [PASSED] count_args_test [14:16:29] [PASSED] call_args_example [14:16:29] [PASSED] call_args_test [14:16:29] [PASSED] drop_first_arg_example [14:16:29] [PASSED] drop_first_arg_test [14:16:29] [PASSED] first_arg_example [14:16:29] [PASSED] first_arg_test [14:16:29] [PASSED] last_arg_example [14:16:29] [PASSED] last_arg_test [14:16:29] [PASSED] pick_arg_example [14:16:29] [PASSED] if_args_example [14:16:29] [PASSED] if_args_test [14:16:29] [PASSED] sep_comma_example [14:16:29] ====================== [PASSED] args ======================= [14:16:29] =================== xe_pci (3 subtests) ==================== [14:16:29] ==================== check_graphics_ip ==================== [14:16:29] [PASSED] 12.00 Xe_LP [14:16:29] [PASSED] 12.10 Xe_LP+ [14:16:29] [PASSED] 12.55 Xe_HPG [14:16:29] [PASSED] 12.60 Xe_HPC [14:16:29] [PASSED] 12.70 Xe_LPG [14:16:29] [PASSED] 12.71 Xe_LPG [14:16:29] [PASSED] 12.74 Xe_LPG+ [14:16:29] [PASSED] 20.01 Xe2_HPG [14:16:29] [PASSED] 20.02 Xe2_HPG [14:16:29] [PASSED] 20.04 Xe2_LPG [14:16:29] [PASSED] 30.00 Xe3_LPG [14:16:29] [PASSED] 30.01 Xe3_LPG [14:16:29] [PASSED] 30.03 Xe3_LPG [14:16:29] [PASSED] 30.04 Xe3_LPG [14:16:29] [PASSED] 30.05 Xe3_LPG [14:16:29] [PASSED] 35.11 Xe3p_XPC [14:16:29] ================ [PASSED] check_graphics_ip ================ [14:16:29] ===================== check_media_ip ====================== [14:16:29] [PASSED] 12.00 Xe_M [14:16:29] [PASSED] 12.55 Xe_HPM [14:16:29] [PASSED] 13.00 Xe_LPM+ [14:16:29] [PASSED] 13.01 Xe2_HPM [14:16:29] [PASSED] 20.00 Xe2_LPM [14:16:29] [PASSED] 30.00 Xe3_LPM [14:16:29] [PASSED] 30.02 Xe3_LPM [14:16:29] [PASSED] 35.00 Xe3p_LPM [14:16:29] [PASSED] 35.03 Xe3p_HPM [14:16:29] ================= [PASSED] check_media_ip ================== [14:16:29] =================== check_platform_desc =================== [14:16:29] [PASSED] 0x9A60 (TIGERLAKE) [14:16:29] [PASSED] 0x9A68 (TIGERLAKE) [14:16:29] [PASSED] 0x9A70 (TIGERLAKE) [14:16:29] [PASSED] 0x9A40 (TIGERLAKE) [14:16:29] [PASSED] 0x9A49 (TIGERLAKE) [14:16:29] [PASSED] 0x9A59 (TIGERLAKE) [14:16:29] [PASSED] 0x9A78 (TIGERLAKE) [14:16:29] [PASSED] 0x9AC0 (TIGERLAKE) [14:16:29] [PASSED] 0x9AC9 (TIGERLAKE) [14:16:29] [PASSED] 0x9AD9 (TIGERLAKE) [14:16:29] [PASSED] 0x9AF8 (TIGERLAKE) [14:16:29] [PASSED] 0x4C80 (ROCKETLAKE) [14:16:29] [PASSED] 0x4C8A (ROCKETLAKE) [14:16:29] [PASSED] 0x4C8B (ROCKETLAKE) [14:16:29] [PASSED] 0x4C8C (ROCKETLAKE) [14:16:29] [PASSED] 0x4C90 (ROCKETLAKE) [14:16:29] [PASSED] 0x4C9A (ROCKETLAKE) [14:16:29] [PASSED] 0x4680 (ALDERLAKE_S) [14:16:29] [PASSED] 0x4682 (ALDERLAKE_S) [14:16:29] [PASSED] 0x4688 (ALDERLAKE_S) [14:16:29] [PASSED] 0x468A (ALDERLAKE_S) [14:16:29] [PASSED] 0x468B (ALDERLAKE_S) [14:16:29] [PASSED] 0x4690 (ALDERLAKE_S) [14:16:29] [PASSED] 0x4692 (ALDERLAKE_S) [14:16:29] [PASSED] 0x4693 (ALDERLAKE_S) [14:16:29] [PASSED] 0x46A0 (ALDERLAKE_P) [14:16:29] [PASSED] 0x46A1 (ALDERLAKE_P) [14:16:29] [PASSED] 0x46A2 (ALDERLAKE_P) [14:16:29] [PASSED] 0x46A3 (ALDERLAKE_P) [14:16:29] [PASSED] 0x46A6 (ALDERLAKE_P) [14:16:29] [PASSED] 0x46A8 (ALDERLAKE_P) [14:16:29] [PASSED] 0x46AA (ALDERLAKE_P) [14:16:29] [PASSED] 0x462A (ALDERLAKE_P) [14:16:29] [PASSED] 0x4626 (ALDERLAKE_P) [14:16:29] [PASSED] 0x4628 (ALDERLAKE_P) stty: 'standard input': Inappropriate ioctl for device [14:16:29] [PASSED] 0x46B0 (ALDERLAKE_P) [14:16:29] [PASSED] 0x46B1 (ALDERLAKE_P) [14:16:29] [PASSED] 0x46B2 (ALDERLAKE_P) [14:16:29] [PASSED] 0x46B3 (ALDERLAKE_P) [14:16:29] [PASSED] 0x46C0 (ALDERLAKE_P) [14:16:29] [PASSED] 0x46C1 (ALDERLAKE_P) [14:16:29] [PASSED] 0x46C2 (ALDERLAKE_P) [14:16:29] [PASSED] 0x46C3 (ALDERLAKE_P) [14:16:29] [PASSED] 0x46D0 (ALDERLAKE_N) [14:16:29] [PASSED] 0x46D1 (ALDERLAKE_N) [14:16:29] [PASSED] 0x46D2 (ALDERLAKE_N) [14:16:29] [PASSED] 0x46D3 (ALDERLAKE_N) [14:16:29] [PASSED] 0x46D4 (ALDERLAKE_N) [14:16:29] [PASSED] 0xA721 (ALDERLAKE_P) [14:16:29] [PASSED] 0xA7A1 (ALDERLAKE_P) [14:16:29] [PASSED] 0xA7A9 (ALDERLAKE_P) [14:16:29] [PASSED] 0xA7AC (ALDERLAKE_P) [14:16:29] [PASSED] 0xA7AD (ALDERLAKE_P) [14:16:29] [PASSED] 0xA720 (ALDERLAKE_P) [14:16:29] [PASSED] 0xA7A0 (ALDERLAKE_P) [14:16:29] [PASSED] 0xA7A8 (ALDERLAKE_P) [14:16:29] [PASSED] 0xA7AA (ALDERLAKE_P) [14:16:29] [PASSED] 0xA7AB (ALDERLAKE_P) [14:16:29] [PASSED] 0xA780 (ALDERLAKE_S) [14:16:29] [PASSED] 0xA781 (ALDERLAKE_S) [14:16:29] [PASSED] 0xA782 (ALDERLAKE_S) [14:16:29] [PASSED] 0xA783 (ALDERLAKE_S) [14:16:29] [PASSED] 0xA788 (ALDERLAKE_S) [14:16:29] [PASSED] 0xA789 (ALDERLAKE_S) [14:16:29] [PASSED] 0xA78A (ALDERLAKE_S) [14:16:29] [PASSED] 0xA78B (ALDERLAKE_S) [14:16:29] [PASSED] 0x4905 (DG1) [14:16:29] [PASSED] 0x4906 (DG1) [14:16:29] [PASSED] 0x4907 (DG1) [14:16:29] [PASSED] 0x4908 (DG1) [14:16:29] [PASSED] 0x4909 (DG1) [14:16:29] [PASSED] 0x56C0 (DG2) [14:16:29] [PASSED] 0x56C2 (DG2) [14:16:29] [PASSED] 0x56C1 (DG2) [14:16:29] [PASSED] 0x7D51 (METEORLAKE) [14:16:29] [PASSED] 0x7DD1 (METEORLAKE) [14:16:29] [PASSED] 0x7D41 (METEORLAKE) [14:16:29] [PASSED] 0x7D67 (METEORLAKE) [14:16:29] [PASSED] 0xB640 (METEORLAKE) [14:16:29] [PASSED] 0x56A0 (DG2) [14:16:29] [PASSED] 0x56A1 (DG2) [14:16:29] [PASSED] 0x56A2 (DG2) [14:16:29] [PASSED] 0x56BE (DG2) [14:16:29] [PASSED] 0x56BF (DG2) [14:16:29] [PASSED] 0x5690 (DG2) [14:16:29] [PASSED] 0x5691 (DG2) [14:16:29] [PASSED] 0x5692 (DG2) [14:16:29] [PASSED] 0x56A5 (DG2) [14:16:29] [PASSED] 0x56A6 (DG2) [14:16:29] [PASSED] 0x56B0 (DG2) [14:16:29] [PASSED] 0x56B1 (DG2) [14:16:29] [PASSED] 0x56BA (DG2) [14:16:29] [PASSED] 0x56BB (DG2) [14:16:29] [PASSED] 0x56BC (DG2) [14:16:29] [PASSED] 0x56BD (DG2) [14:16:29] [PASSED] 0x5693 (DG2) [14:16:29] [PASSED] 0x5694 (DG2) [14:16:29] [PASSED] 0x5695 (DG2) [14:16:29] [PASSED] 0x56A3 (DG2) [14:16:29] [PASSED] 0x56A4 (DG2) [14:16:29] [PASSED] 0x56B2 (DG2) [14:16:29] [PASSED] 0x56B3 (DG2) [14:16:29] [PASSED] 0x5696 (DG2) [14:16:29] [PASSED] 0x5697 (DG2) [14:16:29] [PASSED] 0xB69 (PVC) [14:16:29] [PASSED] 0xB6E (PVC) [14:16:29] [PASSED] 0xBD4 (PVC) [14:16:29] [PASSED] 0xBD5 (PVC) [14:16:29] [PASSED] 0xBD6 (PVC) [14:16:29] [PASSED] 0xBD7 (PVC) [14:16:29] [PASSED] 0xBD8 (PVC) [14:16:29] [PASSED] 0xBD9 (PVC) [14:16:29] [PASSED] 0xBDA (PVC) [14:16:29] [PASSED] 0xBDB (PVC) [14:16:29] [PASSED] 0xBE0 (PVC) [14:16:29] [PASSED] 0xBE1 (PVC) [14:16:29] [PASSED] 0xBE5 (PVC) [14:16:29] [PASSED] 0x7D40 (METEORLAKE) [14:16:29] [PASSED] 0x7D45 (METEORLAKE) [14:16:29] [PASSED] 0x7D55 (METEORLAKE) [14:16:29] [PASSED] 0x7D60 (METEORLAKE) [14:16:29] [PASSED] 0x7DD5 (METEORLAKE) [14:16:29] [PASSED] 0x6420 (LUNARLAKE) [14:16:29] [PASSED] 0x64A0 (LUNARLAKE) [14:16:29] [PASSED] 0x64B0 (LUNARLAKE) [14:16:29] [PASSED] 0xE202 (BATTLEMAGE) [14:16:29] [PASSED] 0xE209 (BATTLEMAGE) [14:16:29] [PASSED] 0xE20B (BATTLEMAGE) [14:16:29] [PASSED] 0xE20C (BATTLEMAGE) [14:16:29] [PASSED] 0xE20D (BATTLEMAGE) [14:16:29] [PASSED] 0xE210 (BATTLEMAGE) [14:16:29] [PASSED] 0xE211 (BATTLEMAGE) [14:16:29] [PASSED] 0xE212 (BATTLEMAGE) [14:16:29] [PASSED] 0xE216 (BATTLEMAGE) [14:16:29] [PASSED] 0xE220 (BATTLEMAGE) [14:16:29] [PASSED] 0xE221 (BATTLEMAGE) [14:16:29] [PASSED] 0xE222 (BATTLEMAGE) [14:16:29] [PASSED] 0xE223 (BATTLEMAGE) [14:16:29] [PASSED] 0xB080 (PANTHERLAKE) [14:16:29] [PASSED] 0xB081 (PANTHERLAKE) [14:16:29] [PASSED] 0xB082 (PANTHERLAKE) [14:16:29] [PASSED] 0xB083 (PANTHERLAKE) [14:16:29] [PASSED] 0xB084 (PANTHERLAKE) [14:16:29] [PASSED] 0xB085 (PANTHERLAKE) [14:16:29] [PASSED] 0xB086 (PANTHERLAKE) [14:16:29] [PASSED] 0xB087 (PANTHERLAKE) [14:16:29] [PASSED] 0xB08F (PANTHERLAKE) [14:16:29] [PASSED] 0xB090 (PANTHERLAKE) [14:16:29] [PASSED] 0xB0A0 (PANTHERLAKE) [14:16:29] [PASSED] 0xB0B0 (PANTHERLAKE) [14:16:29] [PASSED] 0xFD80 (PANTHERLAKE) [14:16:29] [PASSED] 0xFD81 (PANTHERLAKE) [14:16:29] [PASSED] 0xD740 (NOVALAKE_S) [14:16:29] [PASSED] 0xD741 (NOVALAKE_S) [14:16:29] [PASSED] 0xD742 (NOVALAKE_S) [14:16:29] [PASSED] 0xD743 (NOVALAKE_S) [14:16:29] [PASSED] 0xD744 (NOVALAKE_S) [14:16:29] [PASSED] 0xD745 (NOVALAKE_S) [14:16:29] [PASSED] 0x674C (CRESCENTISLAND) [14:16:29] =============== [PASSED] check_platform_desc =============== [14:16:29] ===================== [PASSED] xe_pci ====================== [14:16:29] =================== xe_rtp (2 subtests) ==================== [14:16:29] =============== xe_rtp_process_to_sr_tests ================ [14:16:29] [PASSED] coalesce-same-reg [14:16:29] [PASSED] no-match-no-add [14:16:29] [PASSED] match-or [14:16:29] [PASSED] match-or-xfail [14:16:29] [PASSED] no-match-no-add-multiple-rules [14:16:29] [PASSED] two-regs-two-entries [14:16:29] [PASSED] clr-one-set-other [14:16:29] [PASSED] set-field [14:16:29] [PASSED] conflict-duplicate [14:16:29] [PASSED] conflict-not-disjoint [14:16:29] [PASSED] conflict-reg-type [14:16:29] =========== [PASSED] xe_rtp_process_to_sr_tests ============ [14:16:29] ================== xe_rtp_process_tests =================== [14:16:29] [PASSED] active1 [14:16:29] [PASSED] active2 [14:16:29] [PASSED] active-inactive [14:16:29] [PASSED] inactive-active [14:16:29] [PASSED] inactive-1st_or_active-inactive [14:16:29] [PASSED] inactive-2nd_or_active-inactive [14:16:29] [PASSED] inactive-last_or_active-inactive [14:16:29] [PASSED] inactive-no_or_active-inactive [14:16:29] ============== [PASSED] xe_rtp_process_tests =============== [14:16:29] ===================== [PASSED] xe_rtp ====================== [14:16:29] ==================== xe_wa (1 subtest) ===================== [14:16:29] ======================== xe_wa_gt ========================= [14:16:29] [PASSED] TIGERLAKE B0 [14:16:29] [PASSED] DG1 A0 [14:16:29] [PASSED] DG1 B0 [14:16:29] [PASSED] ALDERLAKE_S A0 [14:16:29] [PASSED] ALDERLAKE_S B0 [14:16:29] [PASSED] ALDERLAKE_S C0 [14:16:29] [PASSED] ALDERLAKE_S D0 [14:16:29] [PASSED] ALDERLAKE_P A0 [14:16:29] [PASSED] ALDERLAKE_P B0 [14:16:29] [PASSED] ALDERLAKE_P C0 [14:16:29] [PASSED] ALDERLAKE_S RPLS D0 [14:16:29] [PASSED] ALDERLAKE_P RPLU E0 [14:16:29] [PASSED] DG2 G10 C0 [14:16:29] [PASSED] DG2 G11 B1 [14:16:29] [PASSED] DG2 G12 A1 [14:16:29] [PASSED] METEORLAKE 12.70(Xe_LPG) A0 13.00(Xe_LPM+) A0 [14:16:29] [PASSED] METEORLAKE 12.71(Xe_LPG) A0 13.00(Xe_LPM+) A0 [14:16:29] [PASSED] METEORLAKE 12.74(Xe_LPG+) A0 13.00(Xe_LPM+) A0 [14:16:29] [PASSED] LUNARLAKE 20.04(Xe2_LPG) A0 20.00(Xe2_LPM) A0 [14:16:29] [PASSED] LUNARLAKE 20.04(Xe2_LPG) B0 20.00(Xe2_LPM) A0 [14:16:29] [PASSED] BATTLEMAGE 20.01(Xe2_HPG) A0 13.01(Xe2_HPM) A1 [14:16:29] [PASSED] PANTHERLAKE 30.00(Xe3_LPG) A0 30.00(Xe3_LPM) A0 [14:16:29] ==================== [PASSED] xe_wa_gt ===================== [14:16:29] ====================== [PASSED] xe_wa ====================== [14:16:29] ============================================================ [14:16:29] Testing complete. Ran 512 tests: passed: 494, skipped: 18 [14:16:29] Elapsed time: 36.193s total, 4.173s configuring, 31.553s building, 0.460s running + /kernel/tools/testing/kunit/kunit.py run --kunitconfig /kernel/drivers/gpu/drm/tests/.kunitconfig [14:16:29] Configuring KUnit Kernel ... Regenerating .config ... Populating config with: $ make ARCH=um O=.kunit olddefconfig [14:16:31] Building KUnit Kernel ... Populating config with: $ make ARCH=um O=.kunit olddefconfig Building with: $ make all compile_commands.json scripts_gdb ARCH=um O=.kunit --jobs=48 [14:16:56] Starting KUnit Kernel (1/1)... [14:16:56] ============================================================ Running tests with: $ .kunit/linux kunit.enable=1 mem=1G console=tty kunit_shutdown=halt [14:16:56] ============ drm_test_pick_cmdline (2 subtests) ============ [14:16:56] [PASSED] drm_test_pick_cmdline_res_1920_1080_60 [14:16:56] =============== drm_test_pick_cmdline_named =============== [14:16:56] [PASSED] NTSC [14:16:56] [PASSED] NTSC-J [14:16:56] [PASSED] PAL [14:16:56] [PASSED] PAL-M [14:16:56] =========== [PASSED] drm_test_pick_cmdline_named =========== [14:16:56] ============== [PASSED] drm_test_pick_cmdline ============== [14:16:56] == drm_test_atomic_get_connector_for_encoder (1 subtest) === [14:16:56] [PASSED] drm_test_drm_atomic_get_connector_for_encoder [14:16:56] ==== [PASSED] drm_test_atomic_get_connector_for_encoder ==== [14:16:56] =========== drm_validate_clone_mode (2 subtests) =========== [14:16:56] ============== drm_test_check_in_clone_mode =============== [14:16:56] [PASSED] in_clone_mode [14:16:56] [PASSED] not_in_clone_mode [14:16:56] ========== [PASSED] drm_test_check_in_clone_mode =========== [14:16:56] =============== drm_test_check_valid_clones =============== [14:16:56] [PASSED] not_in_clone_mode [14:16:56] [PASSED] valid_clone [14:16:56] [PASSED] invalid_clone [14:16:56] =========== [PASSED] drm_test_check_valid_clones =========== [14:16:56] ============= [PASSED] drm_validate_clone_mode ============= [14:16:56] ============= drm_validate_modeset (1 subtest) ============= [14:16:56] [PASSED] drm_test_check_connector_changed_modeset [14:16:56] ============== [PASSED] drm_validate_modeset =============== [14:16:56] ====== drm_test_bridge_get_current_state (2 subtests) ====== [14:16:56] [PASSED] drm_test_drm_bridge_get_current_state_atomic [14:16:56] [PASSED] drm_test_drm_bridge_get_current_state_legacy [14:16:56] ======== [PASSED] drm_test_bridge_get_current_state ======== [14:16:56] ====== drm_test_bridge_helper_reset_crtc (3 subtests) ====== [14:16:56] [PASSED] drm_test_drm_bridge_helper_reset_crtc_atomic [14:16:56] [PASSED] drm_test_drm_bridge_helper_reset_crtc_atomic_disabled [14:16:56] [PASSED] drm_test_drm_bridge_helper_reset_crtc_legacy [14:16:56] ======== [PASSED] drm_test_bridge_helper_reset_crtc ======== [14:16:56] ============== drm_bridge_alloc (2 subtests) =============== [14:16:56] [PASSED] drm_test_drm_bridge_alloc_basic [14:16:56] [PASSED] drm_test_drm_bridge_alloc_get_put [14:16:56] ================ [PASSED] drm_bridge_alloc ================= [14:16:56] ============= drm_cmdline_parser (40 subtests) ============= [14:16:56] [PASSED] drm_test_cmdline_force_d_only [14:16:56] [PASSED] drm_test_cmdline_force_D_only_dvi [14:16:56] [PASSED] drm_test_cmdline_force_D_only_hdmi [14:16:56] [PASSED] drm_test_cmdline_force_D_only_not_digital [14:16:56] [PASSED] drm_test_cmdline_force_e_only [14:16:56] [PASSED] drm_test_cmdline_res [14:16:56] [PASSED] drm_test_cmdline_res_vesa [14:16:56] [PASSED] drm_test_cmdline_res_vesa_rblank [14:16:56] [PASSED] drm_test_cmdline_res_rblank [14:16:56] [PASSED] drm_test_cmdline_res_bpp [14:16:56] [PASSED] drm_test_cmdline_res_refresh [14:16:56] [PASSED] drm_test_cmdline_res_bpp_refresh [14:16:56] [PASSED] drm_test_cmdline_res_bpp_refresh_interlaced [14:16:56] [PASSED] drm_test_cmdline_res_bpp_refresh_margins [14:16:56] [PASSED] drm_test_cmdline_res_bpp_refresh_force_off [14:16:56] [PASSED] drm_test_cmdline_res_bpp_refresh_force_on [14:16:56] [PASSED] drm_test_cmdline_res_bpp_refresh_force_on_analog [14:16:56] [PASSED] drm_test_cmdline_res_bpp_refresh_force_on_digital [14:16:56] [PASSED] drm_test_cmdline_res_bpp_refresh_interlaced_margins_force_on [14:16:56] [PASSED] drm_test_cmdline_res_margins_force_on [14:16:56] [PASSED] drm_test_cmdline_res_vesa_margins [14:16:56] [PASSED] drm_test_cmdline_name [14:16:56] [PASSED] drm_test_cmdline_name_bpp [14:16:56] [PASSED] drm_test_cmdline_name_option [14:16:56] [PASSED] drm_test_cmdline_name_bpp_option [14:16:56] [PASSED] drm_test_cmdline_rotate_0 [14:16:56] [PASSED] drm_test_cmdline_rotate_90 [14:16:56] [PASSED] drm_test_cmdline_rotate_180 [14:16:56] [PASSED] drm_test_cmdline_rotate_270 [14:16:56] [PASSED] drm_test_cmdline_hmirror [14:16:56] [PASSED] drm_test_cmdline_vmirror [14:16:56] [PASSED] drm_test_cmdline_margin_options [14:16:56] [PASSED] drm_test_cmdline_multiple_options [14:16:56] [PASSED] drm_test_cmdline_bpp_extra_and_option [14:16:56] [PASSED] drm_test_cmdline_extra_and_option [14:16:56] [PASSED] drm_test_cmdline_freestanding_options [14:16:56] [PASSED] drm_test_cmdline_freestanding_force_e_and_options [14:16:56] [PASSED] drm_test_cmdline_panel_orientation [14:16:56] ================ drm_test_cmdline_invalid ================= [14:16:56] [PASSED] margin_only [14:16:56] [PASSED] interlace_only [14:16:56] [PASSED] res_missing_x [14:16:56] [PASSED] res_missing_y [14:16:56] [PASSED] res_bad_y [14:16:56] [PASSED] res_missing_y_bpp [14:16:56] [PASSED] res_bad_bpp [14:16:56] [PASSED] res_bad_refresh [14:16:56] [PASSED] res_bpp_refresh_force_on_off [14:16:56] [PASSED] res_invalid_mode [14:16:56] [PASSED] res_bpp_wrong_place_mode [14:16:56] [PASSED] name_bpp_refresh [14:16:56] [PASSED] name_refresh [14:16:56] [PASSED] name_refresh_wrong_mode [14:16:56] [PASSED] name_refresh_invalid_mode [14:16:56] [PASSED] rotate_multiple [14:16:56] [PASSED] rotate_invalid_val [14:16:56] [PASSED] rotate_truncated [14:16:56] [PASSED] invalid_option [14:16:56] [PASSED] invalid_tv_option [14:16:56] [PASSED] truncated_tv_option [14:16:56] ============ [PASSED] drm_test_cmdline_invalid ============= [14:16:56] =============== drm_test_cmdline_tv_options =============== [14:16:56] [PASSED] NTSC [14:16:56] [PASSED] NTSC_443 [14:16:56] [PASSED] NTSC_J [14:16:56] [PASSED] PAL [14:16:56] [PASSED] PAL_M [14:16:56] [PASSED] PAL_N [14:16:56] [PASSED] SECAM [14:16:56] [PASSED] MONO_525 [14:16:56] [PASSED] MONO_625 [14:16:56] =========== [PASSED] drm_test_cmdline_tv_options =========== [14:16:56] =============== [PASSED] drm_cmdline_parser ================ [14:16:56] ========== drmm_connector_hdmi_init (20 subtests) ========== [14:16:56] [PASSED] drm_test_connector_hdmi_init_valid [14:16:56] [PASSED] drm_test_connector_hdmi_init_bpc_8 [14:16:56] [PASSED] drm_test_connector_hdmi_init_bpc_10 [14:16:56] [PASSED] drm_test_connector_hdmi_init_bpc_12 [14:16:56] [PASSED] drm_test_connector_hdmi_init_bpc_invalid [14:16:56] [PASSED] drm_test_connector_hdmi_init_bpc_null [14:16:56] [PASSED] drm_test_connector_hdmi_init_formats_empty [14:16:56] [PASSED] drm_test_connector_hdmi_init_formats_no_rgb [14:16:56] === drm_test_connector_hdmi_init_formats_yuv420_allowed === [14:16:56] [PASSED] supported_formats=0x9 yuv420_allowed=1 [14:16:56] [PASSED] supported_formats=0x9 yuv420_allowed=0 [14:16:56] [PASSED] supported_formats=0x3 yuv420_allowed=1 [14:16:56] [PASSED] supported_formats=0x3 yuv420_allowed=0 [14:16:56] === [PASSED] drm_test_connector_hdmi_init_formats_yuv420_allowed === [14:16:56] [PASSED] drm_test_connector_hdmi_init_null_ddc [14:16:56] [PASSED] drm_test_connector_hdmi_init_null_product [14:16:56] [PASSED] drm_test_connector_hdmi_init_null_vendor [14:16:56] [PASSED] drm_test_connector_hdmi_init_product_length_exact [14:16:56] [PASSED] drm_test_connector_hdmi_init_product_length_too_long [14:16:56] [PASSED] drm_test_connector_hdmi_init_product_valid [14:16:56] [PASSED] drm_test_connector_hdmi_init_vendor_length_exact [14:16:56] [PASSED] drm_test_connector_hdmi_init_vendor_length_too_long [14:16:56] [PASSED] drm_test_connector_hdmi_init_vendor_valid [14:16:56] ========= drm_test_connector_hdmi_init_type_valid ========= [14:16:56] [PASSED] HDMI-A [14:16:56] [PASSED] HDMI-B [14:16:56] ===== [PASSED] drm_test_connector_hdmi_init_type_valid ===== [14:16:56] ======== drm_test_connector_hdmi_init_type_invalid ======== [14:16:56] [PASSED] Unknown [14:16:56] [PASSED] VGA [14:16:56] [PASSED] DVI-I [14:16:56] [PASSED] DVI-D [14:16:56] [PASSED] DVI-A [14:16:56] [PASSED] Composite [14:16:56] [PASSED] SVIDEO [14:16:56] [PASSED] LVDS [14:16:56] [PASSED] Component [14:16:56] [PASSED] DIN [14:16:56] [PASSED] DP [14:16:56] [PASSED] TV [14:16:56] [PASSED] eDP [14:16:56] [PASSED] Virtual [14:16:56] [PASSED] DSI [14:16:56] [PASSED] DPI [14:16:56] [PASSED] Writeback [14:16:56] [PASSED] SPI [14:16:56] [PASSED] USB [14:16:56] ==== [PASSED] drm_test_connector_hdmi_init_type_invalid ==== [14:16:56] ============ [PASSED] drmm_connector_hdmi_init ============= [14:16:56] ============= drmm_connector_init (3 subtests) ============= [14:16:56] [PASSED] drm_test_drmm_connector_init [14:16:56] [PASSED] drm_test_drmm_connector_init_null_ddc [14:16:56] ========= drm_test_drmm_connector_init_type_valid ========= [14:16:56] [PASSED] Unknown [14:16:56] [PASSED] VGA [14:16:56] [PASSED] DVI-I [14:16:56] [PASSED] DVI-D [14:16:56] [PASSED] DVI-A [14:16:56] [PASSED] Composite [14:16:56] [PASSED] SVIDEO [14:16:56] [PASSED] LVDS [14:16:56] [PASSED] Component [14:16:56] [PASSED] DIN [14:16:56] [PASSED] DP [14:16:56] [PASSED] HDMI-A [14:16:56] [PASSED] HDMI-B [14:16:56] [PASSED] TV [14:16:56] [PASSED] eDP [14:16:56] [PASSED] Virtual [14:16:56] [PASSED] DSI [14:16:56] [PASSED] DPI [14:16:56] [PASSED] Writeback [14:16:56] [PASSED] SPI [14:16:56] [PASSED] USB [14:16:56] ===== [PASSED] drm_test_drmm_connector_init_type_valid ===== [14:16:56] =============== [PASSED] drmm_connector_init =============== [14:16:56] ========= drm_connector_dynamic_init (6 subtests) ========== [14:16:56] [PASSED] drm_test_drm_connector_dynamic_init [14:16:56] [PASSED] drm_test_drm_connector_dynamic_init_null_ddc [14:16:56] [PASSED] drm_test_drm_connector_dynamic_init_not_added [14:16:56] [PASSED] drm_test_drm_connector_dynamic_init_properties [14:16:56] ===== drm_test_drm_connector_dynamic_init_type_valid ====== [14:16:56] [PASSED] Unknown [14:16:56] [PASSED] VGA [14:16:56] [PASSED] DVI-I [14:16:56] [PASSED] DVI-D [14:16:56] [PASSED] DVI-A [14:16:56] [PASSED] Composite [14:16:56] [PASSED] SVIDEO [14:16:56] [PASSED] LVDS [14:16:56] [PASSED] Component [14:16:56] [PASSED] DIN [14:16:56] [PASSED] DP [14:16:56] [PASSED] HDMI-A [14:16:56] [PASSED] HDMI-B [14:16:56] [PASSED] TV [14:16:56] [PASSED] eDP [14:16:56] [PASSED] Virtual [14:16:56] [PASSED] DSI [14:16:56] [PASSED] DPI [14:16:56] [PASSED] Writeback [14:16:56] [PASSED] SPI [14:16:56] [PASSED] USB [14:16:56] = [PASSED] drm_test_drm_connector_dynamic_init_type_valid == [14:16:56] ======== drm_test_drm_connector_dynamic_init_name ========= [14:16:56] [PASSED] Unknown [14:16:56] [PASSED] VGA [14:16:56] [PASSED] DVI-I [14:16:56] [PASSED] DVI-D [14:16:56] [PASSED] DVI-A [14:16:56] [PASSED] Composite [14:16:56] [PASSED] SVIDEO [14:16:56] [PASSED] LVDS [14:16:56] [PASSED] Component [14:16:56] [PASSED] DIN [14:16:56] [PASSED] DP [14:16:56] [PASSED] HDMI-A [14:16:56] [PASSED] HDMI-B [14:16:56] [PASSED] TV [14:16:56] [PASSED] eDP [14:16:56] [PASSED] Virtual [14:16:56] [PASSED] DSI [14:16:56] [PASSED] DPI [14:16:56] [PASSED] Writeback [14:16:56] [PASSED] SPI [14:16:56] [PASSED] USB [14:16:56] ==== [PASSED] drm_test_drm_connector_dynamic_init_name ===== [14:16:56] =========== [PASSED] drm_connector_dynamic_init ============ [14:16:56] ==== drm_connector_dynamic_register_early (4 subtests) ===== [14:16:56] [PASSED] drm_test_drm_connector_dynamic_register_early_on_list [14:16:56] [PASSED] drm_test_drm_connector_dynamic_register_early_defer [14:16:56] [PASSED] drm_test_drm_connector_dynamic_register_early_no_init [14:16:56] [PASSED] drm_test_drm_connector_dynamic_register_early_no_mode_object [14:16:56] ====== [PASSED] drm_connector_dynamic_register_early ======= [14:16:56] ======= drm_connector_dynamic_register (7 subtests) ======== [14:16:56] [PASSED] drm_test_drm_connector_dynamic_register_on_list [14:16:56] [PASSED] drm_test_drm_connector_dynamic_register_no_defer [14:16:56] [PASSED] drm_test_drm_connector_dynamic_register_no_init [14:16:56] [PASSED] drm_test_drm_connector_dynamic_register_mode_object [14:16:56] [PASSED] drm_test_drm_connector_dynamic_register_sysfs [14:16:56] [PASSED] drm_test_drm_connector_dynamic_register_sysfs_name [14:16:56] [PASSED] drm_test_drm_connector_dynamic_register_debugfs [14:16:56] ========= [PASSED] drm_connector_dynamic_register ========== [14:16:56] = drm_connector_attach_broadcast_rgb_property (2 subtests) = [14:16:56] [PASSED] drm_test_drm_connector_attach_broadcast_rgb_property [14:16:56] [PASSED] drm_test_drm_connector_attach_broadcast_rgb_property_hdmi_connector [14:16:56] === [PASSED] drm_connector_attach_broadcast_rgb_property === [14:16:56] ========== drm_get_tv_mode_from_name (2 subtests) ========== [14:16:56] ========== drm_test_get_tv_mode_from_name_valid =========== [14:16:56] [PASSED] NTSC [14:16:56] [PASSED] NTSC-443 [14:16:56] [PASSED] NTSC-J [14:16:56] [PASSED] PAL [14:16:56] [PASSED] PAL-M [14:16:56] [PASSED] PAL-N [14:16:56] [PASSED] SECAM [14:16:56] [PASSED] Mono [14:16:56] ====== [PASSED] drm_test_get_tv_mode_from_name_valid ======= [14:16:56] [PASSED] drm_test_get_tv_mode_from_name_truncated [14:16:56] ============ [PASSED] drm_get_tv_mode_from_name ============ [14:16:56] = drm_test_connector_hdmi_compute_mode_clock (12 subtests) = [14:16:56] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb [14:16:56] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb_10bpc [14:16:56] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb_10bpc_vic_1 [14:16:56] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb_12bpc [14:16:56] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb_12bpc_vic_1 [14:16:56] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb_double [14:16:56] = drm_test_connector_hdmi_compute_mode_clock_yuv420_valid = [14:16:56] [PASSED] VIC 96 [14:16:56] [PASSED] VIC 97 [14:16:56] [PASSED] VIC 101 [14:16:56] [PASSED] VIC 102 [14:16:56] [PASSED] VIC 106 [14:16:56] [PASSED] VIC 107 [14:16:56] === [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv420_valid === [14:16:56] [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv420_10_bpc [14:16:56] [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv420_12_bpc [14:16:56] [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv422_8_bpc [14:16:56] [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv422_10_bpc [14:16:56] [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv422_12_bpc [14:16:56] === [PASSED] drm_test_connector_hdmi_compute_mode_clock ==== [14:16:56] == drm_hdmi_connector_get_broadcast_rgb_name (2 subtests) == [14:16:56] === drm_test_drm_hdmi_connector_get_broadcast_rgb_name ==== [14:16:56] [PASSED] Automatic [14:16:56] [PASSED] Full [14:16:56] [PASSED] Limited 16:235 [14:16:56] === [PASSED] drm_test_drm_hdmi_connector_get_broadcast_rgb_name === [14:16:56] [PASSED] drm_test_drm_hdmi_connector_get_broadcast_rgb_name_invalid [14:16:56] ==== [PASSED] drm_hdmi_connector_get_broadcast_rgb_name ==== [14:16:56] == drm_hdmi_connector_get_output_format_name (2 subtests) == [14:16:56] === drm_test_drm_hdmi_connector_get_output_format_name ==== [14:16:56] [PASSED] RGB [14:16:56] [PASSED] YUV 4:2:0 [14:16:56] [PASSED] YUV 4:2:2 [14:16:56] [PASSED] YUV 4:4:4 [14:16:56] === [PASSED] drm_test_drm_hdmi_connector_get_output_format_name === [14:16:56] [PASSED] drm_test_drm_hdmi_connector_get_output_format_name_invalid [14:16:56] ==== [PASSED] drm_hdmi_connector_get_output_format_name ==== [14:16:56] ============= drm_damage_helper (21 subtests) ============== [14:16:56] [PASSED] drm_test_damage_iter_no_damage [14:16:56] [PASSED] drm_test_damage_iter_no_damage_fractional_src [14:16:56] [PASSED] drm_test_damage_iter_no_damage_src_moved [14:16:56] [PASSED] drm_test_damage_iter_no_damage_fractional_src_moved [14:16:56] [PASSED] drm_test_damage_iter_no_damage_not_visible [14:16:56] [PASSED] drm_test_damage_iter_no_damage_no_crtc [14:16:56] [PASSED] drm_test_damage_iter_no_damage_no_fb [14:16:56] [PASSED] drm_test_damage_iter_simple_damage [14:16:56] [PASSED] drm_test_damage_iter_single_damage [14:16:56] [PASSED] drm_test_damage_iter_single_damage_intersect_src [14:16:56] [PASSED] drm_test_damage_iter_single_damage_outside_src [14:16:56] [PASSED] drm_test_damage_iter_single_damage_fractional_src [14:16:56] [PASSED] drm_test_damage_iter_single_damage_intersect_fractional_src [14:16:56] [PASSED] drm_test_damage_iter_single_damage_outside_fractional_src [14:16:56] [PASSED] drm_test_damage_iter_single_damage_src_moved [14:16:56] [PASSED] drm_test_damage_iter_single_damage_fractional_src_moved [14:16:56] [PASSED] drm_test_damage_iter_damage [14:16:56] [PASSED] drm_test_damage_iter_damage_one_intersect [14:16:56] [PASSED] drm_test_damage_iter_damage_one_outside [14:16:56] [PASSED] drm_test_damage_iter_damage_src_moved [14:16:56] [PASSED] drm_test_damage_iter_damage_not_visible [14:16:56] ================ [PASSED] drm_damage_helper ================ [14:16:56] ============== drm_dp_mst_helper (3 subtests) ============== [14:16:56] ============== drm_test_dp_mst_calc_pbn_mode ============== [14:16:56] [PASSED] Clock 154000 BPP 30 DSC disabled [14:16:56] [PASSED] Clock 234000 BPP 30 DSC disabled [14:16:56] [PASSED] Clock 297000 BPP 24 DSC disabled [14:16:56] [PASSED] Clock 332880 BPP 24 DSC enabled [14:16:56] [PASSED] Clock 324540 BPP 24 DSC enabled [14:16:56] ========== [PASSED] drm_test_dp_mst_calc_pbn_mode ========== [14:16:56] ============== drm_test_dp_mst_calc_pbn_div =============== [14:16:56] [PASSED] Link rate 2000000 lane count 4 [14:16:56] [PASSED] Link rate 2000000 lane count 2 [14:16:56] [PASSED] Link rate 2000000 lane count 1 [14:16:56] [PASSED] Link rate 1350000 lane count 4 [14:16:56] [PASSED] Link rate 1350000 lane count 2 [14:16:56] [PASSED] Link rate 1350000 lane count 1 [14:16:56] [PASSED] Link rate 1000000 lane count 4 [14:16:56] [PASSED] Link rate 1000000 lane count 2 [14:16:56] [PASSED] Link rate 1000000 lane count 1 [14:16:56] [PASSED] Link rate 810000 lane count 4 [14:16:56] [PASSED] Link rate 810000 lane count 2 [14:16:56] [PASSED] Link rate 810000 lane count 1 [14:16:56] [PASSED] Link rate 540000 lane count 4 [14:16:56] [PASSED] Link rate 540000 lane count 2 [14:16:56] [PASSED] Link rate 540000 lane count 1 [14:16:56] [PASSED] Link rate 270000 lane count 4 [14:16:56] [PASSED] Link rate 270000 lane count 2 [14:16:56] [PASSED] Link rate 270000 lane count 1 [14:16:56] [PASSED] Link rate 162000 lane count 4 [14:16:56] [PASSED] Link rate 162000 lane count 2 [14:16:56] [PASSED] Link rate 162000 lane count 1 [14:16:56] ========== [PASSED] drm_test_dp_mst_calc_pbn_div =========== [14:16:56] ========= drm_test_dp_mst_sideband_msg_req_decode ========= [14:16:56] [PASSED] DP_ENUM_PATH_RESOURCES with port number [14:16:56] [PASSED] DP_POWER_UP_PHY with port number [14:16:56] [PASSED] DP_POWER_DOWN_PHY with port number [14:16:56] [PASSED] DP_ALLOCATE_PAYLOAD with SDP stream sinks [14:16:56] [PASSED] DP_ALLOCATE_PAYLOAD with port number [14:16:56] [PASSED] DP_ALLOCATE_PAYLOAD with VCPI [14:16:56] [PASSED] DP_ALLOCATE_PAYLOAD with PBN [14:16:56] [PASSED] DP_QUERY_PAYLOAD with port number [14:16:56] [PASSED] DP_QUERY_PAYLOAD with VCPI [14:16:56] [PASSED] DP_REMOTE_DPCD_READ with port number [14:16:56] [PASSED] DP_REMOTE_DPCD_READ with DPCD address [14:16:56] [PASSED] DP_REMOTE_DPCD_READ with max number of bytes [14:16:56] [PASSED] DP_REMOTE_DPCD_WRITE with port number [14:16:56] [PASSED] DP_REMOTE_DPCD_WRITE with DPCD address [14:16:56] [PASSED] DP_REMOTE_DPCD_WRITE with data array [14:16:56] [PASSED] DP_REMOTE_I2C_READ with port number [14:16:56] [PASSED] DP_REMOTE_I2C_READ with I2C device ID [14:16:56] [PASSED] DP_REMOTE_I2C_READ with transactions array [14:16:56] [PASSED] DP_REMOTE_I2C_WRITE with port number [14:16:56] [PASSED] DP_REMOTE_I2C_WRITE with I2C device ID [14:16:56] [PASSED] DP_REMOTE_I2C_WRITE with data array [14:16:56] [PASSED] DP_QUERY_STREAM_ENC_STATUS with stream ID [14:16:56] [PASSED] DP_QUERY_STREAM_ENC_STATUS with client ID [14:16:56] [PASSED] DP_QUERY_STREAM_ENC_STATUS with stream event [14:16:56] [PASSED] DP_QUERY_STREAM_ENC_STATUS with valid stream event [14:16:56] [PASSED] DP_QUERY_STREAM_ENC_STATUS with stream behavior [14:16:56] [PASSED] DP_QUERY_STREAM_ENC_STATUS with a valid stream behavior [14:16:56] ===== [PASSED] drm_test_dp_mst_sideband_msg_req_decode ===== [14:16:56] ================ [PASSED] drm_dp_mst_helper ================ [14:16:56] ================== drm_exec (7 subtests) =================== [14:16:56] [PASSED] sanitycheck [14:16:56] [PASSED] test_lock [14:16:56] [PASSED] test_lock_unlock [14:16:56] [PASSED] test_duplicates [14:16:56] [PASSED] test_prepare [14:16:56] [PASSED] test_prepare_array [14:16:56] [PASSED] test_multiple_loops [14:16:56] ==================== [PASSED] drm_exec ===================== [14:16:56] =========== drm_format_helper_test (17 subtests) =========== [14:16:56] ============== drm_test_fb_xrgb8888_to_gray8 ============== [14:16:56] [PASSED] single_pixel_source_buffer [14:16:56] [PASSED] single_pixel_clip_rectangle [14:16:56] [PASSED] well_known_colors [14:16:56] [PASSED] destination_pitch [14:16:56] ========== [PASSED] drm_test_fb_xrgb8888_to_gray8 ========== [14:16:56] ============= drm_test_fb_xrgb8888_to_rgb332 ============== [14:16:56] [PASSED] single_pixel_source_buffer [14:16:56] [PASSED] single_pixel_clip_rectangle [14:16:56] [PASSED] well_known_colors [14:16:56] [PASSED] destination_pitch [14:16:56] ========= [PASSED] drm_test_fb_xrgb8888_to_rgb332 ========== [14:16:56] ============= drm_test_fb_xrgb8888_to_rgb565 ============== [14:16:56] [PASSED] single_pixel_source_buffer [14:16:56] [PASSED] single_pixel_clip_rectangle [14:16:56] [PASSED] well_known_colors [14:16:56] [PASSED] destination_pitch [14:16:56] ========= [PASSED] drm_test_fb_xrgb8888_to_rgb565 ========== [14:16:56] ============ drm_test_fb_xrgb8888_to_xrgb1555 ============= [14:16:56] [PASSED] single_pixel_source_buffer [14:16:56] [PASSED] single_pixel_clip_rectangle [14:16:56] [PASSED] well_known_colors [14:16:56] [PASSED] destination_pitch [14:16:56] ======== [PASSED] drm_test_fb_xrgb8888_to_xrgb1555 ========= [14:16:56] ============ drm_test_fb_xrgb8888_to_argb1555 ============= [14:16:56] [PASSED] single_pixel_source_buffer [14:16:56] [PASSED] single_pixel_clip_rectangle [14:16:56] [PASSED] well_known_colors [14:16:56] [PASSED] destination_pitch [14:16:56] ======== [PASSED] drm_test_fb_xrgb8888_to_argb1555 ========= [14:16:56] ============ drm_test_fb_xrgb8888_to_rgba5551 ============= [14:16:56] [PASSED] single_pixel_source_buffer [14:16:56] [PASSED] single_pixel_clip_rectangle [14:16:56] [PASSED] well_known_colors [14:16:56] [PASSED] destination_pitch [14:16:56] ======== [PASSED] drm_test_fb_xrgb8888_to_rgba5551 ========= [14:16:56] ============= drm_test_fb_xrgb8888_to_rgb888 ============== [14:16:56] [PASSED] single_pixel_source_buffer [14:16:56] [PASSED] single_pixel_clip_rectangle [14:16:56] [PASSED] well_known_colors [14:16:56] [PASSED] destination_pitch [14:16:56] ========= [PASSED] drm_test_fb_xrgb8888_to_rgb888 ========== [14:16:56] ============= drm_test_fb_xrgb8888_to_bgr888 ============== [14:16:56] [PASSED] single_pixel_source_buffer [14:16:56] [PASSED] single_pixel_clip_rectangle [14:16:56] [PASSED] well_known_colors [14:16:56] [PASSED] destination_pitch [14:16:56] ========= [PASSED] drm_test_fb_xrgb8888_to_bgr888 ========== [14:16:56] ============ drm_test_fb_xrgb8888_to_argb8888 ============= [14:16:56] [PASSED] single_pixel_source_buffer [14:16:56] [PASSED] single_pixel_clip_rectangle [14:16:56] [PASSED] well_known_colors [14:16:56] [PASSED] destination_pitch [14:16:56] ======== [PASSED] drm_test_fb_xrgb8888_to_argb8888 ========= [14:16:56] =========== drm_test_fb_xrgb8888_to_xrgb2101010 =========== [14:16:56] [PASSED] single_pixel_source_buffer [14:16:56] [PASSED] single_pixel_clip_rectangle [14:16:56] [PASSED] well_known_colors [14:16:56] [PASSED] destination_pitch [14:16:56] ======= [PASSED] drm_test_fb_xrgb8888_to_xrgb2101010 ======= [14:16:56] =========== drm_test_fb_xrgb8888_to_argb2101010 =========== [14:16:56] [PASSED] single_pixel_source_buffer [14:16:56] [PASSED] single_pixel_clip_rectangle [14:16:56] [PASSED] well_known_colors [14:16:56] [PASSED] destination_pitch [14:16:56] ======= [PASSED] drm_test_fb_xrgb8888_to_argb2101010 ======= [14:16:56] ============== drm_test_fb_xrgb8888_to_mono =============== [14:16:56] [PASSED] single_pixel_source_buffer [14:16:56] [PASSED] single_pixel_clip_rectangle [14:16:56] [PASSED] well_known_colors [14:16:56] [PASSED] destination_pitch [14:16:56] ========== [PASSED] drm_test_fb_xrgb8888_to_mono =========== [14:16:56] ==================== drm_test_fb_swab ===================== [14:16:56] [PASSED] single_pixel_source_buffer [14:16:56] [PASSED] single_pixel_clip_rectangle [14:16:56] [PASSED] well_known_colors [14:16:56] [PASSED] destination_pitch [14:16:56] ================ [PASSED] drm_test_fb_swab ================= [14:16:56] ============ drm_test_fb_xrgb8888_to_xbgr8888 ============= [14:16:56] [PASSED] single_pixel_source_buffer [14:16:56] [PASSED] single_pixel_clip_rectangle [14:16:56] [PASSED] well_known_colors [14:16:56] [PASSED] destination_pitch [14:16:56] ======== [PASSED] drm_test_fb_xrgb8888_to_xbgr8888 ========= [14:16:56] ============ drm_test_fb_xrgb8888_to_abgr8888 ============= [14:16:56] [PASSED] single_pixel_source_buffer [14:16:56] [PASSED] single_pixel_clip_rectangle [14:16:56] [PASSED] well_known_colors [14:16:56] [PASSED] destination_pitch [14:16:56] ======== [PASSED] drm_test_fb_xrgb8888_to_abgr8888 ========= [14:16:56] ================= drm_test_fb_clip_offset ================= [14:16:56] [PASSED] pass through [14:16:56] [PASSED] horizontal offset [14:16:56] [PASSED] vertical offset [14:16:56] [PASSED] horizontal and vertical offset [14:16:56] [PASSED] horizontal offset (custom pitch) [14:16:56] [PASSED] vertical offset (custom pitch) [14:16:56] [PASSED] horizontal and vertical offset (custom pitch) [14:16:56] ============= [PASSED] drm_test_fb_clip_offset ============= [14:16:56] =================== drm_test_fb_memcpy ==================== [14:16:56] [PASSED] single_pixel_source_buffer: XR24 little-endian (0x34325258) [14:16:56] [PASSED] single_pixel_source_buffer: XRA8 little-endian (0x38415258) [14:16:56] [PASSED] single_pixel_source_buffer: YU24 little-endian (0x34325559) [14:16:56] [PASSED] single_pixel_clip_rectangle: XB24 little-endian (0x34324258) [14:16:56] [PASSED] single_pixel_clip_rectangle: XRA8 little-endian (0x38415258) [14:16:56] [PASSED] single_pixel_clip_rectangle: YU24 little-endian (0x34325559) [14:16:56] [PASSED] well_known_colors: XB24 little-endian (0x34324258) [14:16:56] [PASSED] well_known_colors: XRA8 little-endian (0x38415258) [14:16:56] [PASSED] well_known_colors: YU24 little-endian (0x34325559) [14:16:56] [PASSED] destination_pitch: XB24 little-endian (0x34324258) [14:16:56] [PASSED] destination_pitch: XRA8 little-endian (0x38415258) [14:16:56] [PASSED] destination_pitch: YU24 little-endian (0x34325559) [14:16:56] =============== [PASSED] drm_test_fb_memcpy ================ [14:16:56] ============= [PASSED] drm_format_helper_test ============== [14:16:56] ================= drm_format (18 subtests) ================= [14:16:56] [PASSED] drm_test_format_block_width_invalid [14:16:56] [PASSED] drm_test_format_block_width_one_plane [14:16:56] [PASSED] drm_test_format_block_width_two_plane [14:16:56] [PASSED] drm_test_format_block_width_three_plane [14:16:56] [PASSED] drm_test_format_block_width_tiled [14:16:56] [PASSED] drm_test_format_block_height_invalid [14:16:56] [PASSED] drm_test_format_block_height_one_plane [14:16:56] [PASSED] drm_test_format_block_height_two_plane [14:16:56] [PASSED] drm_test_format_block_height_three_plane [14:16:56] [PASSED] drm_test_format_block_height_tiled [14:16:56] [PASSED] drm_test_format_min_pitch_invalid [14:16:56] [PASSED] drm_test_format_min_pitch_one_plane_8bpp [14:16:56] [PASSED] drm_test_format_min_pitch_one_plane_16bpp [14:16:56] [PASSED] drm_test_format_min_pitch_one_plane_24bpp [14:16:56] [PASSED] drm_test_format_min_pitch_one_plane_32bpp [14:16:56] [PASSED] drm_test_format_min_pitch_two_plane [14:16:56] [PASSED] drm_test_format_min_pitch_three_plane_8bpp [14:16:56] [PASSED] drm_test_format_min_pitch_tiled [14:16:56] =================== [PASSED] drm_format ==================== [14:16:56] ============== drm_framebuffer (10 subtests) =============== [14:16:56] ========== drm_test_framebuffer_check_src_coords ========== [14:16:56] [PASSED] Success: source fits into fb [14:16:56] [PASSED] Fail: overflowing fb with x-axis coordinate [14:16:56] [PASSED] Fail: overflowing fb with y-axis coordinate [14:16:56] [PASSED] Fail: overflowing fb with source width [14:16:56] [PASSED] Fail: overflowing fb with source height [14:16:56] ====== [PASSED] drm_test_framebuffer_check_src_coords ====== [14:16:56] [PASSED] drm_test_framebuffer_cleanup [14:16:56] =============== drm_test_framebuffer_create =============== [14:16:56] [PASSED] ABGR8888 normal sizes [14:16:56] [PASSED] ABGR8888 max sizes [14:16:56] [PASSED] ABGR8888 pitch greater than min required [14:16:56] [PASSED] ABGR8888 pitch less than min required [14:16:56] [PASSED] ABGR8888 Invalid width [14:16:56] [PASSED] ABGR8888 Invalid buffer handle [14:16:56] [PASSED] No pixel format [14:16:56] [PASSED] ABGR8888 Width 0 [14:16:56] [PASSED] ABGR8888 Height 0 [14:16:56] [PASSED] ABGR8888 Out of bound height * pitch combination [14:16:56] [PASSED] ABGR8888 Large buffer offset [14:16:56] [PASSED] ABGR8888 Buffer offset for inexistent plane [14:16:56] [PASSED] ABGR8888 Invalid flag [14:16:56] [PASSED] ABGR8888 Set DRM_MODE_FB_MODIFIERS without modifiers [14:16:56] [PASSED] ABGR8888 Valid buffer modifier [14:16:56] [PASSED] ABGR8888 Invalid buffer modifier(DRM_FORMAT_MOD_SAMSUNG_64_32_TILE) [14:16:56] [PASSED] ABGR8888 Extra pitches without DRM_MODE_FB_MODIFIERS [14:16:56] [PASSED] ABGR8888 Extra pitches with DRM_MODE_FB_MODIFIERS [14:16:56] [PASSED] NV12 Normal sizes [14:16:56] [PASSED] NV12 Max sizes [14:16:56] [PASSED] NV12 Invalid pitch [14:16:56] [PASSED] NV12 Invalid modifier/missing DRM_MODE_FB_MODIFIERS flag [14:16:56] [PASSED] NV12 different modifier per-plane [14:16:56] [PASSED] NV12 with DRM_FORMAT_MOD_SAMSUNG_64_32_TILE [14:16:56] [PASSED] NV12 Valid modifiers without DRM_MODE_FB_MODIFIERS [14:16:56] [PASSED] NV12 Modifier for inexistent plane [14:16:56] [PASSED] NV12 Handle for inexistent plane [14:16:56] [PASSED] NV12 Handle for inexistent plane without DRM_MODE_FB_MODIFIERS [14:16:56] [PASSED] YVU420 DRM_MODE_FB_MODIFIERS set without modifier [14:16:56] [PASSED] YVU420 Normal sizes [14:16:56] [PASSED] YVU420 Max sizes [14:16:56] [PASSED] YVU420 Invalid pitch [14:16:56] [PASSED] YVU420 Different pitches [14:16:56] [PASSED] YVU420 Different buffer offsets/pitches [14:16:56] [PASSED] YVU420 Modifier set just for plane 0, without DRM_MODE_FB_MODIFIERS [14:16:56] [PASSED] YVU420 Modifier set just for planes 0, 1, without DRM_MODE_FB_MODIFIERS [14:16:56] [PASSED] YVU420 Modifier set just for plane 0, 1, with DRM_MODE_FB_MODIFIERS [14:16:56] [PASSED] YVU420 Valid modifier [14:16:56] [PASSED] YVU420 Different modifiers per plane [14:16:56] [PASSED] YVU420 Modifier for inexistent plane [14:16:56] [PASSED] YUV420_10BIT Invalid modifier(DRM_FORMAT_MOD_LINEAR) [14:16:56] [PASSED] X0L2 Normal sizes [14:16:56] [PASSED] X0L2 Max sizes [14:16:56] [PASSED] X0L2 Invalid pitch [14:16:56] [PASSED] X0L2 Pitch greater than minimum required [14:16:56] [PASSED] X0L2 Handle for inexistent plane [14:16:56] [PASSED] X0L2 Offset for inexistent plane, without DRM_MODE_FB_MODIFIERS set [14:16:56] [PASSED] X0L2 Modifier without DRM_MODE_FB_MODIFIERS set [14:16:56] [PASSED] X0L2 Valid modifier [14:16:56] [PASSED] X0L2 Modifier for inexistent plane [14:16:56] =========== [PASSED] drm_test_framebuffer_create =========== [14:16:56] [PASSED] drm_test_framebuffer_free [14:16:56] [PASSED] drm_test_framebuffer_init [14:16:56] [PASSED] drm_test_framebuffer_init_bad_format [14:16:56] [PASSED] drm_test_framebuffer_init_dev_mismatch [14:16:56] [PASSED] drm_test_framebuffer_lookup [14:16:56] [PASSED] drm_test_framebuffer_lookup_inexistent [14:16:56] [PASSED] drm_test_framebuffer_modifiers_not_supported [14:16:56] ================= [PASSED] drm_framebuffer ================= [14:16:56] ================ drm_gem_shmem (8 subtests) ================ [14:16:56] [PASSED] drm_gem_shmem_test_obj_create [14:16:56] [PASSED] drm_gem_shmem_test_obj_create_private [14:16:56] [PASSED] drm_gem_shmem_test_pin_pages [14:16:56] [PASSED] drm_gem_shmem_test_vmap [14:16:56] [PASSED] drm_gem_shmem_test_get_sg_table [14:16:56] [PASSED] drm_gem_shmem_test_get_pages_sgt [14:16:56] [PASSED] drm_gem_shmem_test_madvise [14:16:56] [PASSED] drm_gem_shmem_test_purge [14:16:56] ================== [PASSED] drm_gem_shmem ================== [14:16:56] === drm_atomic_helper_connector_hdmi_check (27 subtests) === [14:16:56] [PASSED] drm_test_check_broadcast_rgb_auto_cea_mode [14:16:56] [PASSED] drm_test_check_broadcast_rgb_auto_cea_mode_vic_1 [14:16:56] [PASSED] drm_test_check_broadcast_rgb_full_cea_mode [14:16:56] [PASSED] drm_test_check_broadcast_rgb_full_cea_mode_vic_1 [14:16:56] [PASSED] drm_test_check_broadcast_rgb_limited_cea_mode [14:16:56] [PASSED] drm_test_check_broadcast_rgb_limited_cea_mode_vic_1 [14:16:56] ====== drm_test_check_broadcast_rgb_cea_mode_yuv420 ======= [14:16:56] [PASSED] Automatic [14:16:56] [PASSED] Full [14:16:56] [PASSED] Limited 16:235 [14:16:56] == [PASSED] drm_test_check_broadcast_rgb_cea_mode_yuv420 === [14:16:56] [PASSED] drm_test_check_broadcast_rgb_crtc_mode_changed [14:16:56] [PASSED] drm_test_check_broadcast_rgb_crtc_mode_not_changed [14:16:56] [PASSED] drm_test_check_disable_connector [14:16:56] [PASSED] drm_test_check_hdmi_funcs_reject_rate [14:16:56] [PASSED] drm_test_check_max_tmds_rate_bpc_fallback_rgb [14:16:56] [PASSED] drm_test_check_max_tmds_rate_bpc_fallback_yuv420 [14:16:56] [PASSED] drm_test_check_max_tmds_rate_bpc_fallback_ignore_yuv422 [14:16:56] [PASSED] drm_test_check_max_tmds_rate_bpc_fallback_ignore_yuv420 [14:16:56] [PASSED] drm_test_check_driver_unsupported_fallback_yuv420 [14:16:56] [PASSED] drm_test_check_output_bpc_crtc_mode_changed [14:16:56] [PASSED] drm_test_check_output_bpc_crtc_mode_not_changed [14:16:56] [PASSED] drm_test_check_output_bpc_dvi [14:16:56] [PASSED] drm_test_check_output_bpc_format_vic_1 [14:16:56] [PASSED] drm_test_check_output_bpc_format_display_8bpc_only [14:16:56] [PASSED] drm_test_check_output_bpc_format_display_rgb_only [14:16:56] [PASSED] drm_test_check_output_bpc_format_driver_8bpc_only [14:16:56] [PASSED] drm_test_check_output_bpc_format_driver_rgb_only [14:16:56] [PASSED] drm_test_check_tmds_char_rate_rgb_8bpc [14:16:56] [PASSED] drm_test_check_tmds_char_rate_rgb_10bpc [14:16:56] [PASSED] drm_test_check_tmds_char_rate_rgb_12bpc [14:16:56] ===== [PASSED] drm_atomic_helper_connector_hdmi_check ====== [14:16:56] === drm_atomic_helper_connector_hdmi_reset (6 subtests) ==== [14:16:56] [PASSED] drm_test_check_broadcast_rgb_value [14:16:56] [PASSED] drm_test_check_bpc_8_value [14:16:56] [PASSED] drm_test_check_bpc_10_value [14:16:56] [PASSED] drm_test_check_bpc_12_value [14:16:56] [PASSED] drm_test_check_format_value [14:16:56] [PASSED] drm_test_check_tmds_char_value [14:16:56] ===== [PASSED] drm_atomic_helper_connector_hdmi_reset ====== [14:16:56] = drm_atomic_helper_connector_hdmi_mode_valid (4 subtests) = [14:16:56] [PASSED] drm_test_check_mode_valid [14:16:56] [PASSED] drm_test_check_mode_valid_reject [14:16:56] [PASSED] drm_test_check_mode_valid_reject_rate [14:16:56] [PASSED] drm_test_check_mode_valid_reject_max_clock [14:16:56] === [PASSED] drm_atomic_helper_connector_hdmi_mode_valid === [14:16:56] ================= drm_managed (2 subtests) ================= [14:16:56] [PASSED] drm_test_managed_release_action [14:16:56] [PASSED] drm_test_managed_run_action [14:16:56] =================== [PASSED] drm_managed =================== [14:16:56] =================== drm_mm (6 subtests) ==================== [14:16:56] [PASSED] drm_test_mm_init [14:16:56] [PASSED] drm_test_mm_debug [14:16:56] [PASSED] drm_test_mm_align32 [14:16:56] [PASSED] drm_test_mm_align64 [14:16:56] [PASSED] drm_test_mm_lowest [14:16:56] [PASSED] drm_test_mm_highest [14:16:56] ===================== [PASSED] drm_mm ====================== [14:16:56] ============= drm_modes_analog_tv (5 subtests) ============= [14:16:56] [PASSED] drm_test_modes_analog_tv_mono_576i [14:16:56] [PASSED] drm_test_modes_analog_tv_ntsc_480i [14:16:56] [PASSED] drm_test_modes_analog_tv_ntsc_480i_inlined [14:16:56] [PASSED] drm_test_modes_analog_tv_pal_576i [14:16:56] [PASSED] drm_test_modes_analog_tv_pal_576i_inlined [14:16:56] =============== [PASSED] drm_modes_analog_tv =============== [14:16:56] ============== drm_plane_helper (2 subtests) =============== [14:16:56] =============== drm_test_check_plane_state ================ [14:16:56] [PASSED] clipping_simple [14:16:56] [PASSED] clipping_rotate_reflect [14:16:56] [PASSED] positioning_simple [14:16:56] [PASSED] upscaling [14:16:56] [PASSED] downscaling [14:16:56] [PASSED] rounding1 [14:16:56] [PASSED] rounding2 [14:16:56] [PASSED] rounding3 [14:16:56] [PASSED] rounding4 [14:16:56] =========== [PASSED] drm_test_check_plane_state ============ [14:16:56] =========== drm_test_check_invalid_plane_state ============ [14:16:56] [PASSED] positioning_invalid [14:16:56] [PASSED] upscaling_invalid [14:16:56] [PASSED] downscaling_invalid [14:16:56] ======= [PASSED] drm_test_check_invalid_plane_state ======== [14:16:56] ================ [PASSED] drm_plane_helper ================= [14:16:56] ====== drm_connector_helper_tv_get_modes (1 subtest) ======= [14:16:56] ====== drm_test_connector_helper_tv_get_modes_check ======= [14:16:56] [PASSED] None [14:16:56] [PASSED] PAL [14:16:56] [PASSED] NTSC [14:16:56] [PASSED] Both, NTSC Default [14:16:56] [PASSED] Both, PAL Default [14:16:56] [PASSED] Both, NTSC Default, with PAL on command-line [14:16:56] [PASSED] Both, PAL Default, with NTSC on command-line [14:16:56] == [PASSED] drm_test_connector_helper_tv_get_modes_check === [14:16:56] ======== [PASSED] drm_connector_helper_tv_get_modes ======== [14:16:56] ================== drm_rect (9 subtests) =================== [14:16:56] [PASSED] drm_test_rect_clip_scaled_div_by_zero [14:16:56] [PASSED] drm_test_rect_clip_scaled_not_clipped [14:16:56] [PASSED] drm_test_rect_clip_scaled_clipped [14:16:56] [PASSED] drm_test_rect_clip_scaled_signed_vs_unsigned [14:16:56] ================= drm_test_rect_intersect ================= [14:16:56] [PASSED] top-left x bottom-right: 2x2+1+1 x 2x2+0+0 [14:16:56] [PASSED] top-right x bottom-left: 2x2+0+0 x 2x2+1-1 [14:16:56] [PASSED] bottom-left x top-right: 2x2+1-1 x 2x2+0+0 [14:16:56] [PASSED] bottom-right x top-left: 2x2+0+0 x 2x2+1+1 [14:16:56] [PASSED] right x left: 2x1+0+0 x 3x1+1+0 [14:16:56] [PASSED] left x right: 3x1+1+0 x 2x1+0+0 [14:16:56] [PASSED] up x bottom: 1x2+0+0 x 1x3+0-1 [14:16:56] [PASSED] bottom x up: 1x3+0-1 x 1x2+0+0 [14:16:56] [PASSED] touching corner: 1x1+0+0 x 2x2+1+1 [14:16:56] [PASSED] touching side: 1x1+0+0 x 1x1+1+0 [14:16:56] [PASSED] equal rects: 2x2+0+0 x 2x2+0+0 [14:16:56] [PASSED] inside another: 2x2+0+0 x 1x1+1+1 [14:16:56] [PASSED] far away: 1x1+0+0 x 1x1+3+6 [14:16:56] [PASSED] points intersecting: 0x0+5+10 x 0x0+5+10 [14:16:56] [PASSED] points not intersecting: 0x0+0+0 x 0x0+5+10 [14:16:56] ============= [PASSED] drm_test_rect_intersect ============= [14:16:56] ================ drm_test_rect_calc_hscale ================ [14:16:56] [PASSED] normal use [14:16:56] [PASSED] out of max range [14:16:56] [PASSED] out of min range [14:16:56] [PASSED] zero dst [14:16:56] [PASSED] negative src [14:16:56] [PASSED] negative dst [14:16:56] ============ [PASSED] drm_test_rect_calc_hscale ============ [14:16:56] ================ drm_test_rect_calc_vscale ================ [14:16:56] [PASSED] normal use [14:16:56] [PASSED] out of max range [14:16:56] [PASSED] out of min range [14:16:56] [PASSED] zero dst [14:16:56] [PASSED] negative src [14:16:56] [PASSED] negative dst [14:16:56] ============ [PASSED] drm_test_rect_calc_vscale ============ [14:16:56] ================== drm_test_rect_rotate =================== [14:16:56] [PASSED] reflect-x [14:16:56] [PASSED] reflect-y [14:16:56] [PASSED] rotate-0 [14:16:56] [PASSED] rotate-90 [14:16:56] [PASSED] rotate-180 [14:16:56] [PASSED] rotate-270 [14:16:56] ============== [PASSED] drm_test_rect_rotate =============== stty: 'standard input': Inappropriate ioctl for device [14:16:56] ================ drm_test_rect_rotate_inv ================= [14:16:56] [PASSED] reflect-x [14:16:56] [PASSED] reflect-y [14:16:56] [PASSED] rotate-0 [14:16:56] [PASSED] rotate-90 [14:16:56] [PASSED] rotate-180 [14:16:56] [PASSED] rotate-270 [14:16:56] ============ [PASSED] drm_test_rect_rotate_inv ============= [14:16:56] ==================== [PASSED] drm_rect ===================== [14:16:56] ============ drm_sysfb_modeset_test (1 subtest) ============ [14:16:56] ============ drm_test_sysfb_build_fourcc_list ============= [14:16:56] [PASSED] no native formats [14:16:56] [PASSED] XRGB8888 as native format [14:16:56] [PASSED] remove duplicates [14:16:56] [PASSED] convert alpha formats [14:16:56] [PASSED] random formats [14:16:56] ======== [PASSED] drm_test_sysfb_build_fourcc_list ========= [14:16:56] ============= [PASSED] drm_sysfb_modeset_test ============== [14:16:56] ================== drm_fixp (2 subtests) =================== [14:16:56] [PASSED] drm_test_int2fixp [14:16:56] [PASSED] drm_test_sm2fixp [14:16:56] ==================== [PASSED] drm_fixp ===================== [14:16:56] ============================================================ [14:16:56] Testing complete. Ran 616 tests: passed: 616 [14:16:56] Elapsed time: 26.813s total, 1.637s configuring, 24.999s building, 0.175s running + /kernel/tools/testing/kunit/kunit.py run --kunitconfig /kernel/drivers/gpu/drm/ttm/tests/.kunitconfig [14:16:56] Configuring KUnit Kernel ... Regenerating .config ... Populating config with: $ make ARCH=um O=.kunit olddefconfig [14:16:58] Building KUnit Kernel ... Populating config with: $ make ARCH=um O=.kunit olddefconfig Building with: $ make all compile_commands.json scripts_gdb ARCH=um O=.kunit --jobs=48 [14:17:07] Starting KUnit Kernel (1/1)... [14:17:07] ============================================================ Running tests with: $ .kunit/linux kunit.enable=1 mem=1G console=tty kunit_shutdown=halt [14:17:07] ================= ttm_device (5 subtests) ================== [14:17:07] [PASSED] ttm_device_init_basic [14:17:07] [PASSED] ttm_device_init_multiple [14:17:07] [PASSED] ttm_device_fini_basic [14:17:07] [PASSED] ttm_device_init_no_vma_man [14:17:07] ================== ttm_device_init_pools ================== [14:17:07] [PASSED] No DMA allocations, no DMA32 required [14:17:07] [PASSED] DMA allocations, DMA32 required [14:17:07] [PASSED] No DMA allocations, DMA32 required [14:17:07] [PASSED] DMA allocations, no DMA32 required [14:17:07] ============== [PASSED] ttm_device_init_pools ============== [14:17:07] =================== [PASSED] ttm_device ==================== [14:17:07] ================== ttm_pool (8 subtests) =================== [14:17:07] ================== ttm_pool_alloc_basic =================== [14:17:07] [PASSED] One page [14:17:07] [PASSED] More than one page [14:17:07] [PASSED] Above the allocation limit [14:17:07] [PASSED] One page, with coherent DMA mappings enabled [14:17:07] [PASSED] Above the allocation limit, with coherent DMA mappings enabled [14:17:07] ============== [PASSED] ttm_pool_alloc_basic =============== [14:17:07] ============== ttm_pool_alloc_basic_dma_addr ============== [14:17:07] [PASSED] One page [14:17:07] [PASSED] More than one page [14:17:07] [PASSED] Above the allocation limit [14:17:07] [PASSED] One page, with coherent DMA mappings enabled [14:17:07] [PASSED] Above the allocation limit, with coherent DMA mappings enabled [14:17:07] ========== [PASSED] ttm_pool_alloc_basic_dma_addr ========== [14:17:07] [PASSED] ttm_pool_alloc_order_caching_match [14:17:07] [PASSED] ttm_pool_alloc_caching_mismatch [14:17:07] [PASSED] ttm_pool_alloc_order_mismatch [14:17:07] [PASSED] ttm_pool_free_dma_alloc [14:17:07] [PASSED] ttm_pool_free_no_dma_alloc [14:17:07] [PASSED] ttm_pool_fini_basic [14:17:07] ==================== [PASSED] ttm_pool ===================== [14:17:07] ================ ttm_resource (8 subtests) ================= [14:17:07] ================= ttm_resource_init_basic ================= [14:17:07] [PASSED] Init resource in TTM_PL_SYSTEM [14:17:07] [PASSED] Init resource in TTM_PL_VRAM [14:17:07] [PASSED] Init resource in a private placement [14:17:07] [PASSED] Init resource in TTM_PL_SYSTEM, set placement flags [14:17:07] ============= [PASSED] ttm_resource_init_basic ============= [14:17:07] [PASSED] ttm_resource_init_pinned [14:17:07] [PASSED] ttm_resource_fini_basic [14:17:07] [PASSED] ttm_resource_manager_init_basic [14:17:07] [PASSED] ttm_resource_manager_usage_basic [14:17:07] [PASSED] ttm_resource_manager_set_used_basic [14:17:07] [PASSED] ttm_sys_man_alloc_basic [14:17:07] [PASSED] ttm_sys_man_free_basic [14:17:07] ================== [PASSED] ttm_resource =================== [14:17:07] =================== ttm_tt (15 subtests) =================== [14:17:07] ==================== ttm_tt_init_basic ==================== [14:17:07] [PASSED] Page-aligned size [14:17:07] [PASSED] Extra pages requested [14:17:07] ================ [PASSED] ttm_tt_init_basic ================ [14:17:07] [PASSED] ttm_tt_init_misaligned [14:17:07] [PASSED] ttm_tt_fini_basic [14:17:07] [PASSED] ttm_tt_fini_sg [14:17:07] [PASSED] ttm_tt_fini_shmem [14:17:07] [PASSED] ttm_tt_create_basic [14:17:07] [PASSED] ttm_tt_create_invalid_bo_type [14:17:07] [PASSED] ttm_tt_create_ttm_exists [14:17:07] [PASSED] ttm_tt_create_failed [14:17:07] [PASSED] ttm_tt_destroy_basic [14:17:07] [PASSED] ttm_tt_populate_null_ttm [14:17:07] [PASSED] ttm_tt_populate_populated_ttm [14:17:07] [PASSED] ttm_tt_unpopulate_basic [14:17:07] [PASSED] ttm_tt_unpopulate_empty_ttm [14:17:07] [PASSED] ttm_tt_swapin_basic [14:17:07] ===================== [PASSED] ttm_tt ====================== [14:17:07] =================== ttm_bo (14 subtests) =================== [14:17:07] =========== ttm_bo_reserve_optimistic_no_ticket =========== [14:17:07] [PASSED] Cannot be interrupted and sleeps [14:17:07] [PASSED] Cannot be interrupted, locks straight away [14:17:07] [PASSED] Can be interrupted, sleeps [14:17:07] ======= [PASSED] ttm_bo_reserve_optimistic_no_ticket ======= [14:17:07] [PASSED] ttm_bo_reserve_locked_no_sleep [14:17:07] [PASSED] ttm_bo_reserve_no_wait_ticket [14:17:07] [PASSED] ttm_bo_reserve_double_resv [14:17:07] [PASSED] ttm_bo_reserve_interrupted [14:17:07] [PASSED] ttm_bo_reserve_deadlock [14:17:07] [PASSED] ttm_bo_unreserve_basic [14:17:07] [PASSED] ttm_bo_unreserve_pinned [14:17:07] [PASSED] ttm_bo_unreserve_bulk [14:17:07] [PASSED] ttm_bo_fini_basic [14:17:07] [PASSED] ttm_bo_fini_shared_resv [14:17:07] [PASSED] ttm_bo_pin_basic [14:17:07] [PASSED] ttm_bo_pin_unpin_resource [14:17:07] [PASSED] ttm_bo_multiple_pin_one_unpin [14:17:07] ===================== [PASSED] ttm_bo ====================== [14:17:07] ============== ttm_bo_validate (21 subtests) =============== [14:17:07] ============== ttm_bo_init_reserved_sys_man =============== [14:17:07] [PASSED] Buffer object for userspace [14:17:07] [PASSED] Kernel buffer object [14:17:07] [PASSED] Shared buffer object [14:17:07] ========== [PASSED] ttm_bo_init_reserved_sys_man =========== [14:17:07] ============== ttm_bo_init_reserved_mock_man ============== [14:17:07] [PASSED] Buffer object for userspace [14:17:07] [PASSED] Kernel buffer object [14:17:07] [PASSED] Shared buffer object [14:17:07] ========== [PASSED] ttm_bo_init_reserved_mock_man ========== [14:17:07] [PASSED] ttm_bo_init_reserved_resv [14:17:07] ================== ttm_bo_validate_basic ================== [14:17:07] [PASSED] Buffer object for userspace [14:17:07] [PASSED] Kernel buffer object [14:17:07] [PASSED] Shared buffer object [14:17:07] ============== [PASSED] ttm_bo_validate_basic ============== [14:17:07] [PASSED] ttm_bo_validate_invalid_placement [14:17:07] ============= ttm_bo_validate_same_placement ============== [14:17:07] [PASSED] System manager [14:17:07] [PASSED] VRAM manager [14:17:07] ========= [PASSED] ttm_bo_validate_same_placement ========== [14:17:07] [PASSED] ttm_bo_validate_failed_alloc [14:17:07] [PASSED] ttm_bo_validate_pinned [14:17:07] [PASSED] ttm_bo_validate_busy_placement [14:17:07] ================ ttm_bo_validate_multihop ================= [14:17:07] [PASSED] Buffer object for userspace [14:17:07] [PASSED] Kernel buffer object [14:17:07] [PASSED] Shared buffer object [14:17:07] ============ [PASSED] ttm_bo_validate_multihop ============= [14:17:07] ========== ttm_bo_validate_no_placement_signaled ========== [14:17:07] [PASSED] Buffer object in system domain, no page vector [14:17:07] [PASSED] Buffer object in system domain with an existing page vector [14:17:07] ====== [PASSED] ttm_bo_validate_no_placement_signaled ====== [14:17:07] ======== ttm_bo_validate_no_placement_not_signaled ======== [14:17:07] [PASSED] Buffer object for userspace [14:17:07] [PASSED] Kernel buffer object [14:17:07] [PASSED] Shared buffer object [14:17:07] ==== [PASSED] ttm_bo_validate_no_placement_not_signaled ==== [14:17:07] [PASSED] ttm_bo_validate_move_fence_signaled [14:17:08] ========= ttm_bo_validate_move_fence_not_signaled ========= [14:17:08] [PASSED] Waits for GPU [14:17:08] [PASSED] Tries to lock straight away [14:17:08] ===== [PASSED] ttm_bo_validate_move_fence_not_signaled ===== [14:17:08] [PASSED] ttm_bo_validate_happy_evict [14:17:08] [PASSED] ttm_bo_validate_all_pinned_evict [14:17:08] [PASSED] ttm_bo_validate_allowed_only_evict [14:17:08] [PASSED] ttm_bo_validate_deleted_evict [14:17:08] [PASSED] ttm_bo_validate_busy_domain_evict [14:17:08] [PASSED] ttm_bo_validate_evict_gutting [14:17:08] [PASSED] ttm_bo_validate_recrusive_evict stty: 'standard input': Inappropriate ioctl for device [14:17:08] ================= [PASSED] ttm_bo_validate ================= [14:17:08] ============================================================ [14:17:08] Testing complete. Ran 101 tests: passed: 101 [14:17:08] Elapsed time: 11.229s total, 1.602s configuring, 9.411s building, 0.181s running + cleanup ++ stat -c %u:%g /kernel + chown -R 1003:1003 /kernel ^ permalink raw reply [flat|nested] 23+ messages in thread
* ✗ CI.checksparse: warning for nova-core: Memory management initial patches 2025-12-19 20:37 ` Joel Fernandes ` (9 preceding siblings ...) (?) @ 2025-12-22 14:32 ` Patchwork -1 siblings, 0 replies; 23+ messages in thread From: Patchwork @ 2025-12-22 14:32 UTC (permalink / raw) To: Joel Fernandes; +Cc: intel-xe == Series Details == Series: nova-core: Memory management initial patches URL : https://patchwork.freedesktop.org/series/159316/ State : warning == Summary == + trap cleanup EXIT + KERNEL=/kernel + MT=/root/linux/maintainer-tools + git clone https://gitlab.freedesktop.org/drm/maintainer-tools /root/linux/maintainer-tools Cloning into '/root/linux/maintainer-tools'... warning: redirecting to https://gitlab.freedesktop.org/drm/maintainer-tools.git/ + make -C /root/linux/maintainer-tools make: Entering directory '/root/linux/maintainer-tools' cc -O2 -g -Wextra -o remap-log remap-log.c make: Leaving directory '/root/linux/maintainer-tools' + cd /kernel + git config --global --add safe.directory /kernel + /root/linux/maintainer-tools/dim sparse --fast 373a53bd0fb5466451d376c4d54409d271ff26f2 Sparse version: 0.6.4 (Ubuntu: 0.6.4-4ubuntu3) Fast mode used, each commit won't be checked separately. - +drivers/gpu/drm/drm_buddy.c:76:1: error: bad constant expression +drivers/gpu/drm/drm_buddy.c:77:1: error: bad constant expression +drivers/gpu/drm/drm_buddy.c:77:1: error: bad constant expression + cleanup ++ stat -c %u:%g /kernel + chown -R 1003:1003 /kernel ^ permalink raw reply [flat|nested] 23+ messages in thread
* ✗ Xe.CI.BAT: failure for nova-core: Memory management initial patches 2025-12-19 20:37 ` Joel Fernandes ` (10 preceding siblings ...) (?) @ 2025-12-22 14:53 ` Patchwork -1 siblings, 0 replies; 23+ messages in thread From: Patchwork @ 2025-12-22 14:53 UTC (permalink / raw) To: Joel Fernandes; +Cc: intel-xe [-- Attachment #1: Type: text/plain, Size: 3194 bytes --] == Series Details == Series: nova-core: Memory management initial patches URL : https://patchwork.freedesktop.org/series/159316/ State : failure == Summary == CI Bug Log - changes from xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7_BAT -> xe-pw-159316v1_BAT ==================================================== Summary ------- **WARNING** Minor unknown changes coming with xe-pw-159316v1_BAT need to be verified manually. If you think the reported changes have nothing to do with the changes introduced in xe-pw-159316v1_BAT, please notify your bug team (I915-ci-infra@lists.freedesktop.org) to allow them to document this new failure mode, which will reduce false positives in CI. Participating hosts (11 -> 12) ------------------------------ Additional (1): bat-bmg-3 Possible new issues ------------------- Here are the unknown changes that may have been introduced in xe-pw-159316v1_BAT: ### IGT changes ### #### Warnings #### * igt@xe_module_load@load: - bat-bmg-1: [ABORT][1] ([Intel XE#6818]) -> [ABORT][2] [1]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/bat-bmg-1/igt@xe_module_load@load.html [2]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/bat-bmg-1/igt@xe_module_load@load.html Known issues ------------ Here are the changes found in xe-pw-159316v1_BAT that come from known issues: ### IGT changes ### #### Issues hit #### * igt@xe_peer2peer@read@read-gpua-vram01-gpub-vram01-p2p: - bat-bmg-3: NOTRUN -> [SKIP][3] ([Intel XE#6566]) +3 other tests skip [3]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/bat-bmg-3/igt@xe_peer2peer@read@read-gpua-vram01-gpub-vram01-p2p.html * igt@xe_waitfence@abstime: - bat-dg2-oem2: [PASS][4] -> [TIMEOUT][5] ([Intel XE#6506]) [4]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/bat-dg2-oem2/igt@xe_waitfence@abstime.html [5]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/bat-dg2-oem2/igt@xe_waitfence@abstime.html * igt@xe_waitfence@reltime: - bat-dg2-oem2: [PASS][6] -> [FAIL][7] ([Intel XE#6520]) [6]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/bat-dg2-oem2/igt@xe_waitfence@reltime.html [7]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/bat-dg2-oem2/igt@xe_waitfence@reltime.html [Intel XE#6506]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6506 [Intel XE#6520]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6520 [Intel XE#6566]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6566 [Intel XE#6818]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6818 Build changes ------------- * Linux: xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7 -> xe-pw-159316v1 IGT_8674: f38f4d8e9c65aff45ac807e646d06e38bc3193a2 @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7: 5f136224303e8b3130c6e2297fe52b44a77702c7 xe-pw-159316v1: 159316v1 == Logs == For more details see: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/index.html [-- Attachment #2: Type: text/html, Size: 3851 bytes --] ^ permalink raw reply [flat|nested] 23+ messages in thread
* ✓ Xe.CI.Full: success for nova-core: Memory management initial patches 2025-12-19 20:37 ` Joel Fernandes ` (11 preceding siblings ...) (?) @ 2025-12-22 15:50 ` Patchwork -1 siblings, 0 replies; 23+ messages in thread From: Patchwork @ 2025-12-22 15:50 UTC (permalink / raw) To: Joel Fernandes; +Cc: intel-xe [-- Attachment #1: Type: text/plain, Size: 57388 bytes --] == Series Details == Series: nova-core: Memory management initial patches URL : https://patchwork.freedesktop.org/series/159316/ State : success == Summary == CI Bug Log - changes from xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7_FULL -> xe-pw-159316v1_FULL ==================================================== Summary ------- **SUCCESS** No regressions found. Participating hosts (2 -> 2) ------------------------------ No changes in participating hosts Known issues ------------ Here are the changes found in xe-pw-159316v1_FULL that come from known issues: ### IGT changes ### #### Issues hit #### * igt@core_hotunplug@unplug-rescan: - shard-bmg: [PASS][1] -> [SKIP][2] ([Intel XE#6779]) [1]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-10/igt@core_hotunplug@unplug-rescan.html [2]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@core_hotunplug@unplug-rescan.html * igt@core_setmaster@master-drop-set-shared-fd: - shard-bmg: [PASS][3] -> [SKIP][4] ([Intel XE#6914]) [3]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-10/igt@core_setmaster@master-drop-set-shared-fd.html [4]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@core_setmaster@master-drop-set-shared-fd.html * igt@fbdev@unaligned-read: - shard-bmg: [PASS][5] -> [SKIP][6] ([Intel XE#2134]) +1 other test skip [5]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-2/igt@fbdev@unaligned-read.html [6]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@fbdev@unaligned-read.html * igt@kms_big_fb@4-tiled-max-hw-stride-32bpp-rotate-180-async-flip: - shard-bmg: NOTRUN -> [SKIP][7] ([Intel XE#6703]) +86 other tests skip [7]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_big_fb@4-tiled-max-hw-stride-32bpp-rotate-180-async-flip.html * igt@kms_cursor_crc@cursor-alpha-opaque: - shard-bmg: [PASS][8] -> [DMESG-FAIL][9] ([Intel XE#5545]) +1 other test dmesg-fail [8]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-1/igt@kms_cursor_crc@cursor-alpha-opaque.html [9]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-2/igt@kms_cursor_crc@cursor-alpha-opaque.html * igt@kms_cursor_legacy@2x-long-cursor-vs-flip-atomic: - shard-bmg: [PASS][10] -> [SKIP][11] ([Intel XE#2291]) [10]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-9/igt@kms_cursor_legacy@2x-long-cursor-vs-flip-atomic.html [11]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-4/igt@kms_cursor_legacy@2x-long-cursor-vs-flip-atomic.html * igt@kms_flip@2x-flip-vs-dpms-off-vs-modeset-interruptible: - shard-bmg: [PASS][12] -> [SKIP][13] ([Intel XE#2316]) +2 other tests skip [12]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-9/igt@kms_flip@2x-flip-vs-dpms-off-vs-modeset-interruptible.html [13]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-4/igt@kms_flip@2x-flip-vs-dpms-off-vs-modeset-interruptible.html * igt@kms_flip@flip-vs-expired-vblank-interruptible@b-edp1: - shard-lnl: [PASS][14] -> [FAIL][15] ([Intel XE#301]) +4 other tests fail [14]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-lnl-3/igt@kms_flip@flip-vs-expired-vblank-interruptible@b-edp1.html [15]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-lnl-4/igt@kms_flip@flip-vs-expired-vblank-interruptible@b-edp1.html * igt@kms_flip_scaled_crc@flip-64bpp-yftile-to-32bpp-yftile-upscaling@pipe-a-valid-mode: - shard-bmg: NOTRUN -> [SKIP][16] ([Intel XE#2293]) [16]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-3/igt@kms_flip_scaled_crc@flip-64bpp-yftile-to-32bpp-yftile-upscaling@pipe-a-valid-mode.html * igt@kms_frontbuffer_tracking@psr-2p-scndscrn-cur-indfb-draw-mmap-wc: - shard-bmg: NOTRUN -> [SKIP][17] ([Intel XE#2313]) [17]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-9/igt@kms_frontbuffer_tracking@psr-2p-scndscrn-cur-indfb-draw-mmap-wc.html * igt@kms_hdr@invalid-hdr@pipe-a-hdmi-a-3: - shard-bmg: NOTRUN -> [ABORT][18] ([Intel XE#6740]) [18]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-7/igt@kms_hdr@invalid-hdr@pipe-a-hdmi-a-3.html * igt@kms_hdr@invalid-metadata-sizes: - shard-bmg: [PASS][19] -> [ABORT][20] ([Intel XE#6740]) +3 other tests abort [19]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-3/igt@kms_hdr@invalid-metadata-sizes.html [20]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-9/igt@kms_hdr@invalid-metadata-sizes.html * igt@kms_joiner@invalid-modeset-force-ultra-joiner: - shard-bmg: NOTRUN -> [SKIP][21] ([Intel XE#6911]) [21]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-9/igt@kms_joiner@invalid-modeset-force-ultra-joiner.html * igt@kms_pm_rpm@basic-pci-d3-state: - shard-bmg: NOTRUN -> [SKIP][22] ([Intel XE#6693]) [22]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_pm_rpm@basic-pci-d3-state.html * igt@kms_pm_rpm@modeset-stress-extra-wait: - shard-bmg: [PASS][23] -> [SKIP][24] ([Intel XE#6693]) [23]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-2/igt@kms_pm_rpm@modeset-stress-extra-wait.html [24]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_pm_rpm@modeset-stress-extra-wait.html * igt@kms_psr@psr2-sprite-plane-onoff: - shard-bmg: NOTRUN -> [SKIP][25] ([Intel XE#1406] / [Intel XE#6703]) +3 other tests skip [25]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_psr@psr2-sprite-plane-onoff.html * igt@kms_setmode@invalid-clone-single-crtc-stealing: - shard-bmg: [PASS][26] -> [SKIP][27] ([Intel XE#1435]) [26]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-9/igt@kms_setmode@invalid-clone-single-crtc-stealing.html [27]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-4/igt@kms_setmode@invalid-clone-single-crtc-stealing.html * igt@xe_evict@evict-mixed-many-threads-small: - shard-bmg: [PASS][28] -> [INCOMPLETE][29] ([Intel XE#6321]) [28]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-9/igt@xe_evict@evict-mixed-many-threads-small.html [29]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-4/igt@xe_evict@evict-mixed-many-threads-small.html * igt@xe_exec_system_allocator@process-many-stride-mmap-new-huge: - shard-bmg: NOTRUN -> [SKIP][30] ([Intel XE#4943]) [30]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-9/igt@xe_exec_system_allocator@process-many-stride-mmap-new-huge.html * igt@xe_exec_system_allocator@threads-many-execqueues-new-nomemset: - shard-bmg: [PASS][31] -> [SKIP][32] ([Intel XE#6557] / [Intel XE#6703]) +5 other tests skip [31]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-2/igt@xe_exec_system_allocator@threads-many-execqueues-new-nomemset.html [32]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@xe_exec_system_allocator@threads-many-execqueues-new-nomemset.html * igt@xe_exec_system_allocator@threads-many-stride-mmap-remap-madvise: - shard-bmg: [PASS][33] -> [INCOMPLETE][34] ([Intel XE#6480]) [33]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-7/igt@xe_exec_system_allocator@threads-many-stride-mmap-remap-madvise.html [34]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-1/igt@xe_exec_system_allocator@threads-many-stride-mmap-remap-madvise.html * igt@xe_pmu@engine-activity-accuracy-90@engine-drm_xe_engine_class_copy0: - shard-lnl: [PASS][35] -> [FAIL][36] ([Intel XE#6251]) [35]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-lnl-4/igt@xe_pmu@engine-activity-accuracy-90@engine-drm_xe_engine_class_copy0.html [36]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-lnl-3/igt@xe_pmu@engine-activity-accuracy-90@engine-drm_xe_engine_class_copy0.html * igt@xe_query@multigpu-query-cs-cycles: - shard-bmg: NOTRUN -> [SKIP][37] ([Intel XE#944]) [37]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-9/igt@xe_query@multigpu-query-cs-cycles.html * igt@xe_sysfs_preempt_timeout@preempt_timeout_us-timeout: - shard-bmg: [PASS][38] -> [SKIP][39] ([Intel XE#6703]) +359 other tests skip [38]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-2/igt@xe_sysfs_preempt_timeout@preempt_timeout_us-timeout.html [39]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@xe_sysfs_preempt_timeout@preempt_timeout_us-timeout.html * igt@xe_vm@large-split-binds-536870912: - shard-bmg: NOTRUN -> [SKIP][40] ([Intel XE#6557] / [Intel XE#6703]) [40]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@xe_vm@large-split-binds-536870912.html #### Possible fixes #### * igt@core_hotunplug@hotrebind-lateclose: - shard-bmg: [SKIP][41] ([Intel XE#6779]) -> [PASS][42] +1 other test pass [41]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@core_hotunplug@hotrebind-lateclose.html [42]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-10/igt@core_hotunplug@hotrebind-lateclose.html * igt@kms_cursor_legacy@cursora-vs-flipb-atomic-transitions: - shard-bmg: [SKIP][43] ([Intel XE#2291]) -> [PASS][44] +1 other test pass [43]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-4/igt@kms_cursor_legacy@cursora-vs-flipb-atomic-transitions.html [44]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-2/igt@kms_cursor_legacy@cursora-vs-flipb-atomic-transitions.html * igt@kms_cursor_legacy@flip-vs-cursor-atomic: - shard-bmg: [FAIL][45] ([Intel XE#6715]) -> [PASS][46] [45]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-9/igt@kms_cursor_legacy@flip-vs-cursor-atomic.html [46]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-4/igt@kms_cursor_legacy@flip-vs-cursor-atomic.html * igt@kms_flip@2x-flip-vs-dpms-on-nop-interruptible: - shard-bmg: [SKIP][47] ([Intel XE#2316]) -> [PASS][48] +2 other tests pass [47]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-4/igt@kms_flip@2x-flip-vs-dpms-on-nop-interruptible.html [48]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-2/igt@kms_flip@2x-flip-vs-dpms-on-nop-interruptible.html * igt@kms_plane_multiple@2x-tiling-none: - shard-bmg: [SKIP][49] ([Intel XE#4596]) -> [PASS][50] [49]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-4/igt@kms_plane_multiple@2x-tiling-none.html [50]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-2/igt@kms_plane_multiple@2x-tiling-none.html * igt@kms_pm_rpm@legacy-planes: - shard-bmg: [SKIP][51] ([Intel XE#6693]) -> [PASS][52] [51]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@kms_pm_rpm@legacy-planes.html [52]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-3/igt@kms_pm_rpm@legacy-planes.html * igt@xe_evict@evict-beng-mixed-many-threads-small: - shard-bmg: [INCOMPLETE][53] ([Intel XE#6321]) -> [PASS][54] [53]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-3/igt@xe_evict@evict-beng-mixed-many-threads-small.html [54]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-9/igt@xe_evict@evict-beng-mixed-many-threads-small.html * igt@xe_exec_balancer@many-execqueues-cm-virtual-rebind: - shard-bmg: [SKIP][55] ([Intel XE#6557] / [Intel XE#6703]) -> [PASS][56] +1 other test pass [55]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@xe_exec_balancer@many-execqueues-cm-virtual-rebind.html [56]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-3/igt@xe_exec_balancer@many-execqueues-cm-virtual-rebind.html * igt@xe_fault_injection@inject-fault-probe-function-wait_for_lmem_ready: - shard-bmg: [SKIP][57] ([Intel XE#6703]) -> [PASS][58] +272 other tests pass [57]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@xe_fault_injection@inject-fault-probe-function-wait_for_lmem_ready.html [58]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-3/igt@xe_fault_injection@inject-fault-probe-function-wait_for_lmem_ready.html * igt@xe_pmu@engine-activity-accuracy-90@engine-drm_xe_engine_class_compute0: - shard-lnl: [FAIL][59] ([Intel XE#6251]) -> [PASS][60] [59]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-lnl-4/igt@xe_pmu@engine-activity-accuracy-90@engine-drm_xe_engine_class_compute0.html [60]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-lnl-3/igt@xe_pmu@engine-activity-accuracy-90@engine-drm_xe_engine_class_compute0.html #### Warnings #### * igt@kms_atomic_transition@plane-all-modeset-transition-internal-panels: - shard-bmg: [SKIP][61] ([Intel XE#2370]) -> [SKIP][62] ([Intel XE#6703]) [61]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-10/igt@kms_atomic_transition@plane-all-modeset-transition-internal-panels.html [62]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_atomic_transition@plane-all-modeset-transition-internal-panels.html * igt@kms_big_fb@4-tiled-32bpp-rotate-90: - shard-bmg: [SKIP][63] ([Intel XE#2327]) -> [SKIP][64] ([Intel XE#6703]) +1 other test skip [63]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-4/igt@kms_big_fb@4-tiled-32bpp-rotate-90.html [64]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_big_fb@4-tiled-32bpp-rotate-90.html * igt@kms_big_fb@yf-tiled-32bpp-rotate-0: - shard-bmg: [SKIP][65] ([Intel XE#1124]) -> [SKIP][66] ([Intel XE#6703]) +6 other tests skip [65]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-2/igt@kms_big_fb@yf-tiled-32bpp-rotate-0.html [66]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_big_fb@yf-tiled-32bpp-rotate-0.html * igt@kms_big_fb@yf-tiled-8bpp-rotate-90: - shard-bmg: [SKIP][67] ([Intel XE#6703]) -> [SKIP][68] ([Intel XE#1124]) +6 other tests skip [67]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@kms_big_fb@yf-tiled-8bpp-rotate-90.html [68]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-7/igt@kms_big_fb@yf-tiled-8bpp-rotate-90.html * igt@kms_bw@connected-linear-tiling-3-displays-2560x1440p: - shard-bmg: [SKIP][69] ([Intel XE#2314] / [Intel XE#2894]) -> [SKIP][70] ([Intel XE#6703]) +1 other test skip [69]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-10/igt@kms_bw@connected-linear-tiling-3-displays-2560x1440p.html [70]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_bw@connected-linear-tiling-3-displays-2560x1440p.html * igt@kms_bw@linear-tiling-2-displays-2560x1440p: - shard-bmg: [SKIP][71] ([Intel XE#6703]) -> [SKIP][72] ([Intel XE#367]) +1 other test skip [71]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@kms_bw@linear-tiling-2-displays-2560x1440p.html [72]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-10/igt@kms_bw@linear-tiling-2-displays-2560x1440p.html * igt@kms_bw@linear-tiling-4-displays-2160x1440p: - shard-bmg: [SKIP][73] ([Intel XE#367]) -> [SKIP][74] ([Intel XE#6703]) [73]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-4/igt@kms_bw@linear-tiling-4-displays-2160x1440p.html [74]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_bw@linear-tiling-4-displays-2160x1440p.html * igt@kms_ccs@bad-pixel-format-4-tiled-dg2-mc-ccs: - shard-bmg: [SKIP][75] ([Intel XE#2887]) -> [SKIP][76] ([Intel XE#6703]) +11 other tests skip [75]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-4/igt@kms_ccs@bad-pixel-format-4-tiled-dg2-mc-ccs.html [76]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_ccs@bad-pixel-format-4-tiled-dg2-mc-ccs.html * igt@kms_ccs@bad-rotation-90-4-tiled-lnl-ccs: - shard-bmg: [SKIP][77] ([Intel XE#2652] / [Intel XE#787]) -> [SKIP][78] ([Intel XE#6703]) [77]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-10/igt@kms_ccs@bad-rotation-90-4-tiled-lnl-ccs.html [78]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_ccs@bad-rotation-90-4-tiled-lnl-ccs.html * igt@kms_ccs@bad-rotation-90-y-tiled-ccs: - shard-bmg: [SKIP][79] ([Intel XE#6703]) -> [SKIP][80] ([Intel XE#2887]) +7 other tests skip [79]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@kms_ccs@bad-rotation-90-y-tiled-ccs.html [80]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-10/igt@kms_ccs@bad-rotation-90-y-tiled-ccs.html * igt@kms_ccs@crc-primary-suspend-4-tiled-dg2-mc-ccs: - shard-bmg: [SKIP][81] ([Intel XE#6703]) -> [SKIP][82] ([Intel XE#3432]) +1 other test skip [81]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@kms_ccs@crc-primary-suspend-4-tiled-dg2-mc-ccs.html [82]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-3/igt@kms_ccs@crc-primary-suspend-4-tiled-dg2-mc-ccs.html * igt@kms_chamelium_color@ctm-max: - shard-bmg: [SKIP][83] ([Intel XE#2325]) -> [SKIP][84] ([Intel XE#6703]) +2 other tests skip [83]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-10/igt@kms_chamelium_color@ctm-max.html [84]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_chamelium_color@ctm-max.html * igt@kms_chamelium_hpd@dp-hpd-storm: - shard-bmg: [SKIP][85] ([Intel XE#2252]) -> [SKIP][86] ([Intel XE#6703]) +4 other tests skip [85]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-2/igt@kms_chamelium_hpd@dp-hpd-storm.html [86]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_chamelium_hpd@dp-hpd-storm.html * igt@kms_chamelium_hpd@dp-hpd-with-enabled-mode: - shard-bmg: [SKIP][87] ([Intel XE#6703]) -> [SKIP][88] ([Intel XE#2252]) +4 other tests skip [87]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@kms_chamelium_hpd@dp-hpd-with-enabled-mode.html [88]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-3/igt@kms_chamelium_hpd@dp-hpd-with-enabled-mode.html * igt@kms_content_protection@atomic-dpms@pipe-a-dp-2: - shard-bmg: [DMESG-FAIL][89] -> [FAIL][90] ([Intel XE#1178]) +1 other test fail [89]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-1/igt@kms_content_protection@atomic-dpms@pipe-a-dp-2.html [90]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-3/igt@kms_content_protection@atomic-dpms@pipe-a-dp-2.html * igt@kms_content_protection@dp-mst-lic-type-0: - shard-bmg: [SKIP][91] ([Intel XE#6703]) -> [SKIP][92] ([Intel XE#2390]) [91]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@kms_content_protection@dp-mst-lic-type-0.html [92]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-10/igt@kms_content_protection@dp-mst-lic-type-0.html * igt@kms_content_protection@type1: - shard-bmg: [SKIP][93] ([Intel XE#2341]) -> [SKIP][94] ([Intel XE#6703]) [93]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-4/igt@kms_content_protection@type1.html [94]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_content_protection@type1.html * igt@kms_cursor_crc@cursor-offscreen-32x32: - shard-bmg: [SKIP][95] ([Intel XE#2320]) -> [SKIP][96] ([Intel XE#6703]) +2 other tests skip [95]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-4/igt@kms_cursor_crc@cursor-offscreen-32x32.html [96]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_cursor_crc@cursor-offscreen-32x32.html * igt@kms_cursor_crc@cursor-random-64x21: - shard-bmg: [SKIP][97] ([Intel XE#6703]) -> [SKIP][98] ([Intel XE#2320]) [97]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@kms_cursor_crc@cursor-random-64x21.html [98]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-10/igt@kms_cursor_crc@cursor-random-64x21.html * igt@kms_cursor_crc@cursor-sliding-512x170: - shard-bmg: [SKIP][99] ([Intel XE#6703]) -> [SKIP][100] ([Intel XE#2321]) +1 other test skip [99]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@kms_cursor_crc@cursor-sliding-512x170.html [100]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-10/igt@kms_cursor_crc@cursor-sliding-512x170.html * igt@kms_cursor_legacy@cursorb-vs-flipb-toggle: - shard-bmg: [SKIP][101] ([Intel XE#2291]) -> [SKIP][102] ([Intel XE#6703]) [101]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-4/igt@kms_cursor_legacy@cursorb-vs-flipb-toggle.html [102]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_cursor_legacy@cursorb-vs-flipb-toggle.html * igt@kms_dsc@dsc-with-bpc-formats: - shard-bmg: [SKIP][103] ([Intel XE#2244]) -> [SKIP][104] ([Intel XE#6703]) [103]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-4/igt@kms_dsc@dsc-with-bpc-formats.html [104]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_dsc@dsc-with-bpc-formats.html * igt@kms_fbcon_fbt@fbc: - shard-bmg: [SKIP][105] ([Intel XE#4156]) -> [SKIP][106] ([Intel XE#6703]) [105]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-2/igt@kms_fbcon_fbt@fbc.html [106]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_fbcon_fbt@fbc.html * igt@kms_feature_discovery@dp-mst: - shard-bmg: [SKIP][107] ([Intel XE#6703]) -> [SKIP][108] ([Intel XE#2375]) [107]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@kms_feature_discovery@dp-mst.html [108]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-3/igt@kms_feature_discovery@dp-mst.html * igt@kms_flip@2x-modeset-vs-vblank-race-interruptible: - shard-bmg: [SKIP][109] ([Intel XE#2316]) -> [SKIP][110] ([Intel XE#6703]) +1 other test skip [109]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-4/igt@kms_flip@2x-modeset-vs-vblank-race-interruptible.html [110]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_flip@2x-modeset-vs-vblank-race-interruptible.html * igt@kms_flip_scaled_crc@flip-64bpp-yftile-to-32bpp-yftile-upscaling: - shard-bmg: [SKIP][111] ([Intel XE#6703]) -> [SKIP][112] ([Intel XE#2293] / [Intel XE#2380]) [111]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@kms_flip_scaled_crc@flip-64bpp-yftile-to-32bpp-yftile-upscaling.html [112]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-3/igt@kms_flip_scaled_crc@flip-64bpp-yftile-to-32bpp-yftile-upscaling.html * igt@kms_flip_scaled_crc@flip-64bpp-ytile-to-32bpp-ytile-upscaling: - shard-bmg: [SKIP][113] ([Intel XE#2293] / [Intel XE#2380]) -> [SKIP][114] ([Intel XE#6703]) +3 other tests skip [113]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-2/igt@kms_flip_scaled_crc@flip-64bpp-ytile-to-32bpp-ytile-upscaling.html [114]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_flip_scaled_crc@flip-64bpp-ytile-to-32bpp-ytile-upscaling.html * igt@kms_frontbuffer_tracking@drrs-2p-primscrn-pri-indfb-draw-mmap-wc: - shard-bmg: [SKIP][115] ([Intel XE#2311]) -> [SKIP][116] ([Intel XE#6703]) +13 other tests skip [115]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-2/igt@kms_frontbuffer_tracking@drrs-2p-primscrn-pri-indfb-draw-mmap-wc.html [116]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_frontbuffer_tracking@drrs-2p-primscrn-pri-indfb-draw-mmap-wc.html * igt@kms_frontbuffer_tracking@drrs-2p-scndscrn-spr-indfb-draw-blt: - shard-bmg: [SKIP][117] ([Intel XE#2312]) -> [SKIP][118] ([Intel XE#6703]) +9 other tests skip [117]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-4/igt@kms_frontbuffer_tracking@drrs-2p-scndscrn-spr-indfb-draw-blt.html [118]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_frontbuffer_tracking@drrs-2p-scndscrn-spr-indfb-draw-blt.html * igt@kms_frontbuffer_tracking@fbc-1p-primscrn-indfb-pgflip-blt: - shard-bmg: [SKIP][119] ([Intel XE#4141]) -> [SKIP][120] ([Intel XE#6703]) +9 other tests skip [119]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-2/igt@kms_frontbuffer_tracking@fbc-1p-primscrn-indfb-pgflip-blt.html [120]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_frontbuffer_tracking@fbc-1p-primscrn-indfb-pgflip-blt.html * igt@kms_frontbuffer_tracking@fbc-1p-primscrn-spr-indfb-draw-mmap-wc: - shard-bmg: [SKIP][121] ([Intel XE#6703]) -> [SKIP][122] ([Intel XE#4141]) +4 other tests skip [121]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@kms_frontbuffer_tracking@fbc-1p-primscrn-spr-indfb-draw-mmap-wc.html [122]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-10/igt@kms_frontbuffer_tracking@fbc-1p-primscrn-spr-indfb-draw-mmap-wc.html * igt@kms_frontbuffer_tracking@fbc-2p-primscrn-pri-shrfb-draw-mmap-wc: - shard-bmg: [SKIP][123] ([Intel XE#2312]) -> [SKIP][124] ([Intel XE#4141]) +1 other test skip [123]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-4/igt@kms_frontbuffer_tracking@fbc-2p-primscrn-pri-shrfb-draw-mmap-wc.html [124]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-2/igt@kms_frontbuffer_tracking@fbc-2p-primscrn-pri-shrfb-draw-mmap-wc.html * igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-cur-indfb-draw-blt: - shard-bmg: [SKIP][125] ([Intel XE#4141]) -> [SKIP][126] ([Intel XE#2312]) +4 other tests skip [125]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-9/igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-cur-indfb-draw-blt.html [126]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-4/igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-cur-indfb-draw-blt.html * igt@kms_frontbuffer_tracking@fbcdrrs-1p-primscrn-cur-indfb-draw-mmap-wc: - shard-bmg: [SKIP][127] ([Intel XE#6703]) -> [SKIP][128] ([Intel XE#2311]) +9 other tests skip [127]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@kms_frontbuffer_tracking@fbcdrrs-1p-primscrn-cur-indfb-draw-mmap-wc.html [128]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-10/igt@kms_frontbuffer_tracking@fbcdrrs-1p-primscrn-cur-indfb-draw-mmap-wc.html * igt@kms_frontbuffer_tracking@fbcdrrs-2p-scndscrn-cur-indfb-onoff: - shard-bmg: [SKIP][129] ([Intel XE#2312]) -> [SKIP][130] ([Intel XE#2311]) +6 other tests skip [129]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-4/igt@kms_frontbuffer_tracking@fbcdrrs-2p-scndscrn-cur-indfb-onoff.html [130]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-2/igt@kms_frontbuffer_tracking@fbcdrrs-2p-scndscrn-cur-indfb-onoff.html * igt@kms_frontbuffer_tracking@fbcdrrs-2p-scndscrn-shrfb-msflip-blt: - shard-bmg: [SKIP][131] ([Intel XE#2311]) -> [SKIP][132] ([Intel XE#2312]) +5 other tests skip [131]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-9/igt@kms_frontbuffer_tracking@fbcdrrs-2p-scndscrn-shrfb-msflip-blt.html [132]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-4/igt@kms_frontbuffer_tracking@fbcdrrs-2p-scndscrn-shrfb-msflip-blt.html * igt@kms_frontbuffer_tracking@fbcpsr-2p-rte: - shard-bmg: [SKIP][133] ([Intel XE#2313]) -> [SKIP][134] ([Intel XE#2312]) +8 other tests skip [133]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-9/igt@kms_frontbuffer_tracking@fbcpsr-2p-rte.html [134]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-4/igt@kms_frontbuffer_tracking@fbcpsr-2p-rte.html * igt@kms_frontbuffer_tracking@fbcpsr-2p-scndscrn-pri-indfb-draw-mmap-wc: - shard-bmg: [SKIP][135] ([Intel XE#2312]) -> [SKIP][136] ([Intel XE#2313]) +5 other tests skip [135]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-4/igt@kms_frontbuffer_tracking@fbcpsr-2p-scndscrn-pri-indfb-draw-mmap-wc.html [136]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-2/igt@kms_frontbuffer_tracking@fbcpsr-2p-scndscrn-pri-indfb-draw-mmap-wc.html * igt@kms_frontbuffer_tracking@fbcpsr-rgb101010-draw-render: - shard-bmg: [SKIP][137] ([Intel XE#2313]) -> [SKIP][138] ([Intel XE#6703]) +12 other tests skip [137]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-2/igt@kms_frontbuffer_tracking@fbcpsr-rgb101010-draw-render.html [138]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_frontbuffer_tracking@fbcpsr-rgb101010-draw-render.html * igt@kms_frontbuffer_tracking@fbcpsr-tiling-y: - shard-bmg: [SKIP][139] ([Intel XE#2352]) -> [SKIP][140] ([Intel XE#6703]) [139]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-4/igt@kms_frontbuffer_tracking@fbcpsr-tiling-y.html [140]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_frontbuffer_tracking@fbcpsr-tiling-y.html * igt@kms_frontbuffer_tracking@plane-fbc-rte: - shard-bmg: [SKIP][141] ([Intel XE#6703]) -> [SKIP][142] ([Intel XE#2350]) [141]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@kms_frontbuffer_tracking@plane-fbc-rte.html [142]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-10/igt@kms_frontbuffer_tracking@plane-fbc-rte.html * igt@kms_frontbuffer_tracking@psr-2p-scndscrn-shrfb-pgflip-blt: - shard-bmg: [SKIP][143] ([Intel XE#6703]) -> [SKIP][144] ([Intel XE#2313]) +12 other tests skip [143]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@kms_frontbuffer_tracking@psr-2p-scndscrn-shrfb-pgflip-blt.html [144]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-10/igt@kms_frontbuffer_tracking@psr-2p-scndscrn-shrfb-pgflip-blt.html * igt@kms_hdr@invalid-hdr: - shard-bmg: [SKIP][145] ([Intel XE#6703]) -> [ABORT][146] ([Intel XE#6740]) [145]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@kms_hdr@invalid-hdr.html [146]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-7/igt@kms_hdr@invalid-hdr.html * igt@kms_plane_multiple@2x-tiling-y: - shard-bmg: [SKIP][147] ([Intel XE#6703]) -> [SKIP][148] ([Intel XE#5021]) [147]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@kms_plane_multiple@2x-tiling-y.html [148]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-10/igt@kms_plane_multiple@2x-tiling-y.html * igt@kms_plane_multiple@2x-tiling-yf: - shard-bmg: [SKIP][149] ([Intel XE#4596]) -> [SKIP][150] ([Intel XE#6703]) [149]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-4/igt@kms_plane_multiple@2x-tiling-yf.html [150]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_plane_multiple@2x-tiling-yf.html * igt@kms_pm_backlight@basic-brightness: - shard-bmg: [SKIP][151] ([Intel XE#870]) -> [SKIP][152] ([Intel XE#6703]) [151]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-10/igt@kms_pm_backlight@basic-brightness.html [152]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_pm_backlight@basic-brightness.html * igt@kms_pm_dc@dc5-psr: - shard-bmg: [SKIP][153] ([Intel XE#6703]) -> [SKIP][154] ([Intel XE#2392]) [153]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@kms_pm_dc@dc5-psr.html [154]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-10/igt@kms_pm_dc@dc5-psr.html * igt@kms_pm_dc@dc5-retention-flops: - shard-bmg: [SKIP][155] ([Intel XE#3309]) -> [SKIP][156] ([Intel XE#6703]) [155]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-2/igt@kms_pm_dc@dc5-retention-flops.html [156]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_pm_dc@dc5-retention-flops.html * igt@kms_pm_rpm@modeset-lpsp-stress-no-wait: - shard-bmg: [SKIP][157] ([Intel XE#1439] / [Intel XE#3141] / [Intel XE#836]) -> [SKIP][158] ([Intel XE#6693]) [157]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-4/igt@kms_pm_rpm@modeset-lpsp-stress-no-wait.html [158]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_pm_rpm@modeset-lpsp-stress-no-wait.html * igt@kms_psr2_sf@psr2-overlay-plane-move-continuous-exceed-fully-sf: - shard-bmg: [SKIP][159] ([Intel XE#1406] / [Intel XE#6703]) -> [SKIP][160] ([Intel XE#1406] / [Intel XE#1489]) +2 other tests skip [159]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@kms_psr2_sf@psr2-overlay-plane-move-continuous-exceed-fully-sf.html [160]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-7/igt@kms_psr2_sf@psr2-overlay-plane-move-continuous-exceed-fully-sf.html * igt@kms_psr2_sf@psr2-overlay-plane-move-continuous-sf: - shard-bmg: [SKIP][161] ([Intel XE#1406] / [Intel XE#1489]) -> [SKIP][162] ([Intel XE#1406] / [Intel XE#6703]) +6 other tests skip [161]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-10/igt@kms_psr2_sf@psr2-overlay-plane-move-continuous-sf.html [162]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_psr2_sf@psr2-overlay-plane-move-continuous-sf.html * igt@kms_psr@pr-suspend: - shard-bmg: [SKIP][163] ([Intel XE#1406] / [Intel XE#2234] / [Intel XE#2850]) -> [SKIP][164] ([Intel XE#1406] / [Intel XE#6703]) +4 other tests skip [163]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-2/igt@kms_psr@pr-suspend.html [164]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_psr@pr-suspend.html * igt@kms_psr@psr2-no-drrs: - shard-bmg: [SKIP][165] ([Intel XE#1406] / [Intel XE#6703]) -> [SKIP][166] ([Intel XE#1406] / [Intel XE#2234] / [Intel XE#2850]) +4 other tests skip [165]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@kms_psr@psr2-no-drrs.html [166]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-3/igt@kms_psr@psr2-no-drrs.html * igt@kms_psr_stress_test@invalidate-primary-flip-overlay: - shard-bmg: [SKIP][167] ([Intel XE#1406] / [Intel XE#2414]) -> [SKIP][168] ([Intel XE#1406] / [Intel XE#6703]) [167]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-2/igt@kms_psr_stress_test@invalidate-primary-flip-overlay.html [168]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_psr_stress_test@invalidate-primary-flip-overlay.html * igt@kms_rotation_crc@primary-y-tiled-reflect-x-0: - shard-bmg: [SKIP][169] ([Intel XE#2330]) -> [SKIP][170] ([Intel XE#6703]) [169]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-4/igt@kms_rotation_crc@primary-y-tiled-reflect-x-0.html [170]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_rotation_crc@primary-y-tiled-reflect-x-0.html * igt@kms_rotation_crc@sprite-rotation-90: - shard-bmg: [SKIP][171] ([Intel XE#3414] / [Intel XE#3904]) -> [SKIP][172] ([Intel XE#6703]) [171]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-4/igt@kms_rotation_crc@sprite-rotation-90.html [172]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_rotation_crc@sprite-rotation-90.html * igt@kms_sharpness_filter@filter-formats: - shard-bmg: [SKIP][173] ([Intel XE#6503]) -> [SKIP][174] ([Intel XE#6703]) [173]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-2/igt@kms_sharpness_filter@filter-formats.html [174]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_sharpness_filter@filter-formats.html * igt@kms_sharpness_filter@invalid-filter-with-scaler: - shard-bmg: [SKIP][175] ([Intel XE#6703]) -> [SKIP][176] ([Intel XE#6503]) [175]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@kms_sharpness_filter@invalid-filter-with-scaler.html [176]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-3/igt@kms_sharpness_filter@invalid-filter-with-scaler.html * igt@kms_tv_load_detect@load-detect: - shard-bmg: [SKIP][177] ([Intel XE#2450]) -> [SKIP][178] ([Intel XE#6557] / [Intel XE#6703]) [177]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-2/igt@kms_tv_load_detect@load-detect.html [178]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@kms_tv_load_detect@load-detect.html * igt@kms_vrr@max-min: - shard-bmg: [SKIP][179] ([Intel XE#6703]) -> [SKIP][180] ([Intel XE#1499]) [179]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@kms_vrr@max-min.html [180]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-3/igt@kms_vrr@max-min.html * igt@xe_eudebug@basic-client: - shard-bmg: [SKIP][181] ([Intel XE#4837]) -> [SKIP][182] ([Intel XE#6703]) +4 other tests skip [181]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-10/igt@xe_eudebug@basic-client.html [182]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@xe_eudebug@basic-client.html * igt@xe_eudebug@basic-vm-access-parameters: - shard-bmg: [SKIP][183] ([Intel XE#6703]) -> [SKIP][184] ([Intel XE#4837]) +2 other tests skip [183]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@xe_eudebug@basic-vm-access-parameters.html [184]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-3/igt@xe_eudebug@basic-vm-access-parameters.html * igt@xe_eudebug@basic-vm-bind-ufence-reconnect: - shard-bmg: [SKIP][185] ([Intel XE#4837]) -> [SKIP][186] ([Intel XE#6557] / [Intel XE#6703]) [185]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-4/igt@xe_eudebug@basic-vm-bind-ufence-reconnect.html [186]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@xe_eudebug@basic-vm-bind-ufence-reconnect.html * igt@xe_eudebug_online@set-breakpoint-faultable: - shard-bmg: [SKIP][187] ([Intel XE#4837] / [Intel XE#6665]) -> [SKIP][188] ([Intel XE#6703]) +3 other tests skip [187]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-4/igt@xe_eudebug_online@set-breakpoint-faultable.html [188]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@xe_eudebug_online@set-breakpoint-faultable.html * igt@xe_eudebug_online@set-breakpoint-sigint-debugger: - shard-bmg: [SKIP][189] ([Intel XE#6703]) -> [SKIP][190] ([Intel XE#4837] / [Intel XE#6665]) +3 other tests skip [189]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@xe_eudebug_online@set-breakpoint-sigint-debugger.html [190]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-3/igt@xe_eudebug_online@set-breakpoint-sigint-debugger.html * igt@xe_eudebug_sriov@deny-eudebug: - shard-bmg: [SKIP][191] ([Intel XE#5793]) -> [SKIP][192] ([Intel XE#6703]) [191]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-2/igt@xe_eudebug_sriov@deny-eudebug.html [192]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@xe_eudebug_sriov@deny-eudebug.html * igt@xe_exec_basic@multigpu-many-execqueues-many-vm-rebind: - shard-bmg: [SKIP][193] ([Intel XE#6703]) -> [SKIP][194] ([Intel XE#2322]) +3 other tests skip [193]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@xe_exec_basic@multigpu-many-execqueues-many-vm-rebind.html [194]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-10/igt@xe_exec_basic@multigpu-many-execqueues-many-vm-rebind.html * igt@xe_exec_basic@multigpu-once-null-rebind: - shard-bmg: [SKIP][195] ([Intel XE#2322]) -> [SKIP][196] ([Intel XE#6703]) +5 other tests skip [195]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-4/igt@xe_exec_basic@multigpu-once-null-rebind.html [196]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@xe_exec_basic@multigpu-once-null-rebind.html * igt@xe_exec_multi_queue@many-execs-preempt-mode-fault-userptr-invalidate: - shard-bmg: [SKIP][197] ([Intel XE#6874]) -> [SKIP][198] ([Intel XE#6703]) +20 other tests skip [197]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-10/igt@xe_exec_multi_queue@many-execs-preempt-mode-fault-userptr-invalidate.html [198]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@xe_exec_multi_queue@many-execs-preempt-mode-fault-userptr-invalidate.html * igt@xe_exec_multi_queue@max-queues-preempt-mode-basic: - shard-bmg: [SKIP][199] ([Intel XE#6703]) -> [SKIP][200] ([Intel XE#6874]) +14 other tests skip [199]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@xe_exec_multi_queue@max-queues-preempt-mode-basic.html [200]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-10/igt@xe_exec_multi_queue@max-queues-preempt-mode-basic.html * igt@xe_exec_system_allocator@threads-many-mmap-new-huge-nomemset: - shard-bmg: [SKIP][201] ([Intel XE#6703]) -> [SKIP][202] ([Intel XE#4943]) +7 other tests skip [201]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@xe_exec_system_allocator@threads-many-mmap-new-huge-nomemset.html [202]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-3/igt@xe_exec_system_allocator@threads-many-mmap-new-huge-nomemset.html * igt@xe_exec_system_allocator@threads-shared-vm-many-large-execqueues-mmap-free-huge-nomemset: - shard-bmg: [SKIP][203] ([Intel XE#4943]) -> [SKIP][204] ([Intel XE#6703]) +15 other tests skip [203]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-2/igt@xe_exec_system_allocator@threads-shared-vm-many-large-execqueues-mmap-free-huge-nomemset.html [204]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@xe_exec_system_allocator@threads-shared-vm-many-large-execqueues-mmap-free-huge-nomemset.html * igt@xe_fault_injection@vm-bind-fail-vm_bind_ioctl_ops_execute: - shard-bmg: [ABORT][205] -> [SKIP][206] ([Intel XE#6703]) [205]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-10/igt@xe_fault_injection@vm-bind-fail-vm_bind_ioctl_ops_execute.html [206]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@xe_fault_injection@vm-bind-fail-vm_bind_ioctl_ops_execute.html * igt@xe_pat@pat-index-xelp: - shard-bmg: [SKIP][207] ([Intel XE#6703]) -> [SKIP][208] ([Intel XE#2245]) [207]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@xe_pat@pat-index-xelp.html [208]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-3/igt@xe_pat@pat-index-xelp.html * igt@xe_pm@d3cold-basic: - shard-bmg: [SKIP][209] ([Intel XE#6703]) -> [SKIP][210] ([Intel XE#2284]) [209]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@xe_pm@d3cold-basic.html [210]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-7/igt@xe_pm@d3cold-basic.html * igt@xe_pm@d3cold-i2c: - shard-bmg: [SKIP][211] ([Intel XE#5694]) -> [SKIP][212] ([Intel XE#6703]) [211]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-4/igt@xe_pm@d3cold-i2c.html [212]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@xe_pm@d3cold-i2c.html * igt@xe_pm@s3-d3cold-basic-exec: - shard-bmg: [SKIP][213] ([Intel XE#2284]) -> [SKIP][214] ([Intel XE#6703]) [213]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-2/igt@xe_pm@s3-d3cold-basic-exec.html [214]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@xe_pm@s3-d3cold-basic-exec.html * igt@xe_pm@vram-d3cold-threshold: - shard-bmg: [SKIP][215] ([Intel XE#579]) -> [SKIP][216] ([Intel XE#6703]) [215]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-2/igt@xe_pm@vram-d3cold-threshold.html [216]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@xe_pm@vram-d3cold-threshold.html * igt@xe_pxp@display-black-pxp-fb: - shard-bmg: [SKIP][217] ([Intel XE#4733]) -> [SKIP][218] ([Intel XE#6703]) [217]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-4/igt@xe_pxp@display-black-pxp-fb.html [218]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@xe_pxp@display-black-pxp-fb.html * igt@xe_pxp@pxp-optout: - shard-bmg: [SKIP][219] ([Intel XE#6703]) -> [SKIP][220] ([Intel XE#4733]) [219]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@xe_pxp@pxp-optout.html [220]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-10/igt@xe_pxp@pxp-optout.html * igt@xe_query@multigpu-query-engines: - shard-bmg: [SKIP][221] ([Intel XE#944]) -> [SKIP][222] ([Intel XE#6703]) +3 other tests skip [221]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-2/igt@xe_query@multigpu-query-engines.html [222]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-5/igt@xe_query@multigpu-query-engines.html * igt@xe_query@multigpu-query-invalid-cs-cycles: - shard-bmg: [SKIP][223] ([Intel XE#6703]) -> [SKIP][224] ([Intel XE#944]) [223]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7/shard-bmg-5/igt@xe_query@multigpu-query-invalid-cs-cycles.html [224]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/shard-bmg-3/igt@xe_query@multigpu-query-invalid-cs-cycles.html [Intel XE#1124]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1124 [Intel XE#1178]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1178 [Intel XE#1406]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1406 [Intel XE#1435]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1435 [Intel XE#1439]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1439 [Intel XE#1489]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1489 [Intel XE#1499]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1499 [Intel XE#2134]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2134 [Intel XE#2234]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2234 [Intel XE#2244]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2244 [Intel XE#2245]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2245 [Intel XE#2252]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2252 [Intel XE#2284]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2284 [Intel XE#2291]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2291 [Intel XE#2293]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2293 [Intel XE#2311]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2311 [Intel XE#2312]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2312 [Intel XE#2313]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2313 [Intel XE#2314]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2314 [Intel XE#2316]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2316 [Intel XE#2320]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2320 [Intel XE#2321]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2321 [Intel XE#2322]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2322 [Intel XE#2325]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2325 [Intel XE#2327]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2327 [Intel XE#2330]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2330 [Intel XE#2341]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2341 [Intel XE#2350]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2350 [Intel XE#2352]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2352 [Intel XE#2370]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2370 [Intel XE#2375]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2375 [Intel XE#2380]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2380 [Intel XE#2390]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2390 [Intel XE#2392]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2392 [Intel XE#2414]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2414 [Intel XE#2450]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2450 [Intel XE#2652]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2652 [Intel XE#2850]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2850 [Intel XE#2887]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2887 [Intel XE#2894]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2894 [Intel XE#301]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/301 [Intel XE#3141]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3141 [Intel XE#3309]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3309 [Intel XE#3414]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3414 [Intel XE#3432]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3432 [Intel XE#367]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/367 [Intel XE#3904]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3904 [Intel XE#4141]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4141 [Intel XE#4156]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4156 [Intel XE#4596]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4596 [Intel XE#4733]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4733 [Intel XE#4837]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4837 [Intel XE#4943]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4943 [Intel XE#5021]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5021 [Intel XE#5545]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5545 [Intel XE#5694]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5694 [Intel XE#579]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/579 [Intel XE#5793]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5793 [Intel XE#6251]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6251 [Intel XE#6321]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6321 [Intel XE#6480]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6480 [Intel XE#6503]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6503 [Intel XE#6557]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6557 [Intel XE#6665]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6665 [Intel XE#6693]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6693 [Intel XE#6703]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6703 [Intel XE#6715]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6715 [Intel XE#6740]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6740 [Intel XE#6779]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6779 [Intel XE#6874]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6874 [Intel XE#6911]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6911 [Intel XE#6914]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6914 [Intel XE#787]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/787 [Intel XE#836]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/836 [Intel XE#870]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/870 [Intel XE#944]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/944 Build changes ------------- * Linux: xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7 -> xe-pw-159316v1 IGT_8674: f38f4d8e9c65aff45ac807e646d06e38bc3193a2 @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git xe-4290-5f136224303e8b3130c6e2297fe52b44a77702c7: 5f136224303e8b3130c6e2297fe52b44a77702c7 xe-pw-159316v1: 159316v1 == Logs == For more details see: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-159316v1/index.html [-- Attachment #2: Type: text/html, Size: 70687 bytes --] ^ permalink raw reply [flat|nested] 23+ messages in thread
* ✗ i915.CI.Full: failure for nova-core: Memory management initial patches 2025-12-19 20:37 ` Joel Fernandes ` (12 preceding siblings ...) (?) @ 2025-12-23 5:47 ` Patchwork -1 siblings, 0 replies; 23+ messages in thread From: Patchwork @ 2025-12-23 5:47 UTC (permalink / raw) To: Joel Fernandes; +Cc: intel-gfx [-- Attachment #1: Type: text/plain, Size: 112008 bytes --] == Series Details == Series: nova-core: Memory management initial patches URL : https://patchwork.freedesktop.org/series/159315/ State : failure == Summary == CI Bug Log - changes from CI_DRM_17721_full -> Patchwork_159315v1_full ==================================================== Summary ------- **FAILURE** Serious unknown changes coming with Patchwork_159315v1_full absolutely need to be verified manually. If you think the reported changes have nothing to do with the changes introduced in Patchwork_159315v1_full, please notify your bug team (I915-ci-infra@lists.freedesktop.org) to allow them to document this new failure mode, which will reduce false positives in CI. Participating hosts (9 -> 9) ------------------------------ No changes in participating hosts Possible new issues ------------------- Here are the unknown changes that may have been introduced in Patchwork_159315v1_full: ### IGT changes ### #### Possible regressions #### * igt@kms_cursor_legacy@flip-vs-cursor-busy-crc-atomic: - shard-dg2: [PASS][1] -> [SKIP][2] +4 other tests skip [1]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg2-3/igt@kms_cursor_legacy@flip-vs-cursor-busy-crc-atomic.html [2]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@kms_cursor_legacy@flip-vs-cursor-busy-crc-atomic.html #### Warnings #### * igt@drm_buddy@drm_buddy: - shard-rkl: [DMESG-WARN][3] ([i915#15095]) -> [SKIP][4] [3]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-4/igt@drm_buddy@drm_buddy.html [4]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-2/igt@drm_buddy@drm_buddy.html - shard-dg1: [DMESG-WARN][5] ([i915#15095]) -> [SKIP][6] [5]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg1-16/igt@drm_buddy@drm_buddy.html [6]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg1-13/igt@drm_buddy@drm_buddy.html - shard-tglu: [DMESG-WARN][7] ([i915#15095]) -> [SKIP][8] [7]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-tglu-8/igt@drm_buddy@drm_buddy.html [8]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-7/igt@drm_buddy@drm_buddy.html - shard-mtlp: [DMESG-WARN][9] ([i915#15095]) -> [SKIP][10] [9]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-mtlp-3/igt@drm_buddy@drm_buddy.html [10]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-mtlp-6/igt@drm_buddy@drm_buddy.html - shard-dg2: [DMESG-WARN][11] ([i915#15095]) -> [SKIP][12] [11]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg2-7/igt@drm_buddy@drm_buddy.html [12]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-1/igt@drm_buddy@drm_buddy.html * igt@gem_lmem_swapping@verify: - shard-dg2: [FAIL][13] -> [WARN][14] [13]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg2-3/igt@gem_lmem_swapping@verify.html [14]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@gem_lmem_swapping@verify.html * igt@gem_lmem_swapping@verify@lmem0: - shard-dg2: [FAIL][15] -> [CRASH][16] [15]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg2-3/igt@gem_lmem_swapping@verify@lmem0.html [16]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@gem_lmem_swapping@verify@lmem0.html * igt@gem_pwrite@basic-exhaustion: - shard-snb: [WARN][17] ([i915#2658]) -> [WARN][18] [17]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-snb5/igt@gem_pwrite@basic-exhaustion.html [18]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-snb1/igt@gem_pwrite@basic-exhaustion.html * igt@kms_cursor_legacy@cursorb-vs-flipa-varying-size: - shard-dg2: [SKIP][19] ([i915#13046] / [i915#5354]) -> [SKIP][20] [19]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg2-3/igt@kms_cursor_legacy@cursorb-vs-flipa-varying-size.html [20]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@kms_cursor_legacy@cursorb-vs-flipa-varying-size.html * igt@kms_cursor_legacy@short-busy-flip-before-cursor-toggle: - shard-dg2: [SKIP][21] ([i915#4103] / [i915#4213]) -> [SKIP][22] [21]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg2-3/igt@kms_cursor_legacy@short-busy-flip-before-cursor-toggle.html [22]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@kms_cursor_legacy@short-busy-flip-before-cursor-toggle.html Known issues ------------ Here are the changes found in Patchwork_159315v1_full that come from known issues: ### IGT changes ### #### Issues hit #### * igt@api_intel_bb@blit-reloc-keep-cache: - shard-dg2: NOTRUN -> [SKIP][23] ([i915#8411]) [23]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-6/igt@api_intel_bb@blit-reloc-keep-cache.html * igt@api_intel_bb@crc32: - shard-rkl: NOTRUN -> [SKIP][24] ([i915#6230]) [24]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-5/igt@api_intel_bb@crc32.html * igt@device_reset@cold-reset-bound: - shard-dg2: NOTRUN -> [SKIP][25] ([i915#11078]) [25]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@device_reset@cold-reset-bound.html - shard-rkl: NOTRUN -> [SKIP][26] ([i915#11078]) [26]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-4/igt@device_reset@cold-reset-bound.html * igt@gem_ccs@block-multicopy-compressed: - shard-rkl: NOTRUN -> [SKIP][27] ([i915#9323]) [27]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-4/igt@gem_ccs@block-multicopy-compressed.html * igt@gem_ccs@block-multicopy-inplace: - shard-tglu-1: NOTRUN -> [SKIP][28] ([i915#3555] / [i915#9323]) [28]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@gem_ccs@block-multicopy-inplace.html * igt@gem_close_race@multigpu-basic-process: - shard-rkl: NOTRUN -> [SKIP][29] ([i915#7697]) [29]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-5/igt@gem_close_race@multigpu-basic-process.html * igt@gem_ctx_persistence@file: - shard-snb: NOTRUN -> [SKIP][30] ([i915#1099]) [30]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-snb5/igt@gem_ctx_persistence@file.html * igt@gem_ctx_persistence@heartbeat-close: - shard-dg2: NOTRUN -> [SKIP][31] ([i915#8555]) [31]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@gem_ctx_persistence@heartbeat-close.html * igt@gem_ctx_sseu@engines: - shard-rkl: NOTRUN -> [SKIP][32] ([i915#280]) +1 other test skip [32]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-4/igt@gem_ctx_sseu@engines.html - shard-dg2: NOTRUN -> [SKIP][33] ([i915#280]) [33]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@gem_ctx_sseu@engines.html * igt@gem_ctx_sseu@invalid-args: - shard-tglu-1: NOTRUN -> [SKIP][34] ([i915#280]) [34]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@gem_ctx_sseu@invalid-args.html * igt@gem_exec_balancer@parallel-balancer: - shard-rkl: NOTRUN -> [SKIP][35] ([i915#4525]) +1 other test skip [35]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-4/igt@gem_exec_balancer@parallel-balancer.html * igt@gem_exec_balancer@parallel-bb-first: - shard-tglu: NOTRUN -> [SKIP][36] ([i915#4525]) [36]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-3/igt@gem_exec_balancer@parallel-bb-first.html * igt@gem_exec_balancer@parallel-out-fence: - shard-tglu-1: NOTRUN -> [SKIP][37] ([i915#4525]) +1 other test skip [37]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@gem_exec_balancer@parallel-out-fence.html * igt@gem_exec_flush@basic-wb-ro-before-default: - shard-dg2: NOTRUN -> [SKIP][38] ([i915#3539] / [i915#4852]) [38]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@gem_exec_flush@basic-wb-ro-before-default.html * igt@gem_exec_reloc@basic-gtt-noreloc: - shard-dg2: NOTRUN -> [SKIP][39] ([i915#3281]) +1 other test skip [39]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@gem_exec_reloc@basic-gtt-noreloc.html * igt@gem_exec_reloc@basic-gtt-wc-noreloc: - shard-rkl: NOTRUN -> [SKIP][40] ([i915#3281]) +5 other tests skip [40]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-4/igt@gem_exec_reloc@basic-gtt-wc-noreloc.html * igt@gem_exec_reloc@basic-write-wc-noreloc: - shard-dg1: NOTRUN -> [SKIP][41] ([i915#3281]) [41]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg1-18/igt@gem_exec_reloc@basic-write-wc-noreloc.html * igt@gem_exec_schedule@semaphore-noskip: - shard-dg2: [PASS][42] -> [SKIP][43] ([i915#2575]) +2 other tests skip [42]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg2-3/igt@gem_exec_schedule@semaphore-noskip.html [43]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@gem_exec_schedule@semaphore-noskip.html * igt@gem_fence_thrash@bo-write-verify-y: - shard-dg2: NOTRUN -> [SKIP][44] ([i915#4860]) [44]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@gem_fence_thrash@bo-write-verify-y.html * igt@gem_lmem_swapping@heavy-random: - shard-glk: NOTRUN -> [SKIP][45] ([i915#4613]) +5 other tests skip [45]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-glk1/igt@gem_lmem_swapping@heavy-random.html * igt@gem_lmem_swapping@heavy-verify-random-ccs: - shard-tglu-1: NOTRUN -> [SKIP][46] ([i915#4613]) [46]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@gem_lmem_swapping@heavy-verify-random-ccs.html * igt@gem_lmem_swapping@random-engines: - shard-rkl: NOTRUN -> [SKIP][47] ([i915#4613]) +2 other tests skip [47]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-5/igt@gem_lmem_swapping@random-engines.html * igt@gem_lmem_swapping@verify-random: - shard-tglu: NOTRUN -> [SKIP][48] ([i915#4613]) +1 other test skip [48]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-3/igt@gem_lmem_swapping@verify-random.html * igt@gem_mmap@pf-nonblock: - shard-dg2: NOTRUN -> [SKIP][49] ([i915#4083]) +1 other test skip [49]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@gem_mmap@pf-nonblock.html * igt@gem_mmap_gtt@zero-extend: - shard-dg2: NOTRUN -> [SKIP][50] ([i915#4077]) +2 other tests skip [50]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@gem_mmap_gtt@zero-extend.html * igt@gem_mmap_offset@clear-via-pagefault: - shard-mtlp: [PASS][51] -> [ABORT][52] ([i915#14809]) +1 other test abort [51]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-mtlp-3/igt@gem_mmap_offset@clear-via-pagefault.html [52]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-mtlp-6/igt@gem_mmap_offset@clear-via-pagefault.html * igt@gem_mmap_wc@write-read-distinct: - shard-dg1: NOTRUN -> [SKIP][53] ([i915#4083]) [53]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg1-18/igt@gem_mmap_wc@write-read-distinct.html * igt@gem_partial_pwrite_pread@reads-display: - shard-dg2: NOTRUN -> [SKIP][54] ([i915#3282]) [54]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-6/igt@gem_partial_pwrite_pread@reads-display.html * igt@gem_partial_pwrite_pread@write: - shard-rkl: NOTRUN -> [SKIP][55] ([i915#3282]) +2 other tests skip [55]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-5/igt@gem_partial_pwrite_pread@write.html * igt@gem_pwrite@basic-exhaustion: - shard-glk: NOTRUN -> [WARN][56] ([i915#14702] / [i915#2658]) [56]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-glk5/igt@gem_pwrite@basic-exhaustion.html * igt@gem_pxp@create-protected-buffer: - shard-dg2: NOTRUN -> [SKIP][57] ([i915#4270]) [57]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-6/igt@gem_pxp@create-protected-buffer.html * igt@gem_pxp@hw-rejects-pxp-context: - shard-tglu-1: NOTRUN -> [SKIP][58] ([i915#13398]) [58]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@gem_pxp@hw-rejects-pxp-context.html * igt@gem_render_copy@y-tiled-ccs-to-y-tiled-mc-ccs: - shard-glk: NOTRUN -> [SKIP][59] +301 other tests skip [59]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-glk1/igt@gem_render_copy@y-tiled-ccs-to-y-tiled-mc-ccs.html * igt@gem_render_copy@yf-tiled-to-vebox-x-tiled: - shard-dg2: NOTRUN -> [SKIP][60] ([i915#5190] / [i915#8428]) +2 other tests skip [60]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@gem_render_copy@yf-tiled-to-vebox-x-tiled.html * igt@gem_set_tiling_vs_blt@tiled-to-tiled: - shard-rkl: NOTRUN -> [SKIP][61] ([i915#8411]) [61]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-5/igt@gem_set_tiling_vs_blt@tiled-to-tiled.html * igt@gem_tiled_partial_pwrite_pread@writes: - shard-dg1: NOTRUN -> [SKIP][62] ([i915#4077]) [62]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg1-18/igt@gem_tiled_partial_pwrite_pread@writes.html * igt@gem_userptr_blits@unsync-overlap: - shard-tglu: NOTRUN -> [SKIP][63] ([i915#3297]) [63]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-3/igt@gem_userptr_blits@unsync-overlap.html * igt@gem_workarounds@suspend-resume-context: - shard-rkl: [PASS][64] -> [INCOMPLETE][65] ([i915#13356]) [64]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-7/igt@gem_workarounds@suspend-resume-context.html [65]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-3/igt@gem_workarounds@suspend-resume-context.html * igt@gen3_render_tiledx_blits: - shard-dg2: NOTRUN -> [SKIP][66] +7 other tests skip [66]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@gen3_render_tiledx_blits.html * igt@gen7_exec_parse@chained-batch: - shard-rkl: NOTRUN -> [SKIP][67] +16 other tests skip [67]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-4/igt@gen7_exec_parse@chained-batch.html * igt@gen9_exec_parse@allowed-all: - shard-tglu-1: NOTRUN -> [SKIP][68] ([i915#2527] / [i915#2856]) [68]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@gen9_exec_parse@allowed-all.html * igt@gen9_exec_parse@bb-start-cmd: - shard-tglu: NOTRUN -> [SKIP][69] ([i915#2527] / [i915#2856]) [69]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-3/igt@gen9_exec_parse@bb-start-cmd.html * igt@gen9_exec_parse@shadow-peek: - shard-rkl: NOTRUN -> [SKIP][70] ([i915#2527]) +2 other tests skip [70]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-5/igt@gen9_exec_parse@shadow-peek.html * igt@gen9_exec_parse@valid-registers: - shard-dg1: NOTRUN -> [SKIP][71] ([i915#2527]) [71]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg1-18/igt@gen9_exec_parse@valid-registers.html * igt@i915_drm_fdinfo@most-busy-idle-check-all@vecs1: - shard-dg2: NOTRUN -> [SKIP][72] ([i915#14073]) +7 other tests skip [72]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@i915_drm_fdinfo@most-busy-idle-check-all@vecs1.html * igt@i915_drm_fdinfo@virtual-busy-hang-all: - shard-dg1: NOTRUN -> [SKIP][73] ([i915#14118]) [73]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg1-18/igt@i915_drm_fdinfo@virtual-busy-hang-all.html * igt@i915_module_load@fault-injection: - shard-tglu: NOTRUN -> [ABORT][74] ([i915#15342] / [i915#15481]) [74]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-3/igt@i915_module_load@fault-injection.html * igt@i915_module_load@fault-injection@i915_driver_hw_probe: - shard-tglu: NOTRUN -> [ABORT][75] ([i915#15481]) [75]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-3/igt@i915_module_load@fault-injection@i915_driver_hw_probe.html * igt@i915_module_load@fault-injection@intel_connector_register: - shard-tglu: NOTRUN -> [DMESG-WARN][76] ([i915#15342]) [76]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-3/igt@i915_module_load@fault-injection@intel_connector_register.html * igt@i915_module_load@fault-injection@uc_fw_rsa_data_create: - shard-tglu: NOTRUN -> [SKIP][77] ([i915#15479]) +4 other tests skip [77]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-3/igt@i915_module_load@fault-injection@uc_fw_rsa_data_create.html * igt@i915_pm_freq_api@freq-reset-multiple: - shard-rkl: NOTRUN -> [SKIP][78] ([i915#8399]) [78]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-5/igt@i915_pm_freq_api@freq-reset-multiple.html * igt@i915_pm_rpm@system-suspend-execbuf: - shard-glk: NOTRUN -> [INCOMPLETE][79] ([i915#13356] / [i915#15172]) [79]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-glk9/igt@i915_pm_rpm@system-suspend-execbuf.html * igt@i915_pm_sseu@full-enable: - shard-rkl: NOTRUN -> [SKIP][80] ([i915#4387]) [80]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-5/igt@i915_pm_sseu@full-enable.html * igt@i915_selftest@live@workarounds: - shard-dg2: [PASS][81] -> [DMESG-FAIL][82] ([i915#12061]) +1 other test dmesg-fail [81]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg2-4/igt@i915_selftest@live@workarounds.html [82]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-11/igt@i915_selftest@live@workarounds.html * igt@i915_suspend@basic-s3-without-i915: - shard-rkl: [PASS][83] -> [ABORT][84] ([i915#15131]) [83]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-3/igt@i915_suspend@basic-s3-without-i915.html [84]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-1/igt@i915_suspend@basic-s3-without-i915.html - shard-tglu: NOTRUN -> [INCOMPLETE][85] ([i915#4817] / [i915#7443]) [85]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-3/igt@i915_suspend@basic-s3-without-i915.html * igt@intel_hwmon@hwmon-write: - shard-rkl: NOTRUN -> [SKIP][86] ([i915#7707]) +1 other test skip [86]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-5/igt@intel_hwmon@hwmon-write.html * igt@kms_addfb_basic@basic-y-tiled-legacy: - shard-dg2: NOTRUN -> [SKIP][87] ([i915#4215] / [i915#5190]) [87]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@kms_addfb_basic@basic-y-tiled-legacy.html * igt@kms_atomic@plane-primary-overlay-mutable-zpos: - shard-rkl: NOTRUN -> [SKIP][88] ([i915#9531]) [88]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-5/igt@kms_atomic@plane-primary-overlay-mutable-zpos.html * igt@kms_big_fb@4-tiled-64bpp-rotate-0: - shard-rkl: NOTRUN -> [SKIP][89] ([i915#5286]) +3 other tests skip [89]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-4/igt@kms_big_fb@4-tiled-64bpp-rotate-0.html * igt@kms_big_fb@4-tiled-8bpp-rotate-0: - shard-tglu: NOTRUN -> [SKIP][90] ([i915#5286]) +2 other tests skip [90]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-3/igt@kms_big_fb@4-tiled-8bpp-rotate-0.html * igt@kms_big_fb@4-tiled-max-hw-stride-32bpp-rotate-0-async-flip: - shard-dg1: NOTRUN -> [SKIP][91] ([i915#4538] / [i915#5286]) [91]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg1-18/igt@kms_big_fb@4-tiled-max-hw-stride-32bpp-rotate-0-async-flip.html * igt@kms_big_fb@4-tiled-max-hw-stride-32bpp-rotate-0-hflip: - shard-tglu-1: NOTRUN -> [SKIP][92] ([i915#5286]) +2 other tests skip [92]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@kms_big_fb@4-tiled-max-hw-stride-32bpp-rotate-0-hflip.html * igt@kms_big_fb@4-tiled-max-hw-stride-64bpp-rotate-0-hflip: - shard-mtlp: [PASS][93] -> [FAIL][94] ([i915#5138]) [93]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-mtlp-2/igt@kms_big_fb@4-tiled-max-hw-stride-64bpp-rotate-0-hflip.html [94]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-mtlp-2/igt@kms_big_fb@4-tiled-max-hw-stride-64bpp-rotate-0-hflip.html * igt@kms_big_fb@x-tiled-8bpp-rotate-270: - shard-rkl: NOTRUN -> [SKIP][95] ([i915#3638]) +2 other tests skip [95]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-5/igt@kms_big_fb@x-tiled-8bpp-rotate-270.html * igt@kms_big_fb@y-tiled-max-hw-stride-32bpp-rotate-180: - shard-dg2: NOTRUN -> [SKIP][96] ([i915#4538] / [i915#5190]) +3 other tests skip [96]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@kms_big_fb@y-tiled-max-hw-stride-32bpp-rotate-180.html * igt@kms_big_fb@yf-tiled-16bpp-rotate-0: - shard-tglu: NOTRUN -> [SKIP][97] +16 other tests skip [97]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-3/igt@kms_big_fb@yf-tiled-16bpp-rotate-0.html * igt@kms_ccs@bad-pixel-format-y-tiled-ccs@pipe-c-dp-3: - shard-dg2: NOTRUN -> [SKIP][98] ([i915#10307] / [i915#6095]) +152 other tests skip [98]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-11/igt@kms_ccs@bad-pixel-format-y-tiled-ccs@pipe-c-dp-3.html * igt@kms_ccs@bad-rotation-90-4-tiled-bmg-ccs: - shard-rkl: NOTRUN -> [SKIP][99] ([i915#12313]) [99]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-7/igt@kms_ccs@bad-rotation-90-4-tiled-bmg-ccs.html * igt@kms_ccs@bad-rotation-90-4-tiled-dg2-mc-ccs@pipe-c-hdmi-a-2: - shard-rkl: NOTRUN -> [SKIP][100] ([i915#14098] / [i915#14544] / [i915#6095]) +5 other tests skip [100]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_ccs@bad-rotation-90-4-tiled-dg2-mc-ccs@pipe-c-hdmi-a-2.html * igt@kms_ccs@bad-rotation-90-4-tiled-mtl-mc-ccs: - shard-rkl: NOTRUN -> [SKIP][101] ([i915#14098] / [i915#6095]) +37 other tests skip [101]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-5/igt@kms_ccs@bad-rotation-90-4-tiled-mtl-mc-ccs.html * igt@kms_ccs@crc-primary-rotation-180-4-tiled-bmg-ccs: - shard-tglu-1: NOTRUN -> [SKIP][102] ([i915#12313]) [102]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@kms_ccs@crc-primary-rotation-180-4-tiled-bmg-ccs.html * igt@kms_ccs@crc-primary-rotation-180-4-tiled-dg2-mc-ccs@pipe-a-hdmi-a-3: - shard-dg2: NOTRUN -> [SKIP][103] ([i915#6095]) +40 other tests skip [103]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-6/igt@kms_ccs@crc-primary-rotation-180-4-tiled-dg2-mc-ccs@pipe-a-hdmi-a-3.html * igt@kms_ccs@crc-primary-suspend-4-tiled-dg2-mc-ccs@pipe-b-hdmi-a-2: - shard-rkl: NOTRUN -> [SKIP][104] ([i915#6095]) +62 other tests skip [104]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-3/igt@kms_ccs@crc-primary-suspend-4-tiled-dg2-mc-ccs@pipe-b-hdmi-a-2.html * igt@kms_ccs@crc-primary-suspend-4-tiled-lnl-ccs: - shard-rkl: NOTRUN -> [SKIP][105] ([i915#12805]) +1 other test skip [105]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-5/igt@kms_ccs@crc-primary-suspend-4-tiled-lnl-ccs.html * igt@kms_ccs@crc-primary-suspend-4-tiled-mtl-mc-ccs@pipe-d-hdmi-a-1: - shard-tglu: NOTRUN -> [SKIP][106] ([i915#6095]) +34 other tests skip [106]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-3/igt@kms_ccs@crc-primary-suspend-4-tiled-mtl-mc-ccs@pipe-d-hdmi-a-1.html * igt@kms_ccs@crc-primary-suspend-4-tiled-mtl-rc-ccs-cc@pipe-d-hdmi-a-3: - shard-dg1: NOTRUN -> [SKIP][107] ([i915#6095]) +128 other tests skip [107]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg1-12/igt@kms_ccs@crc-primary-suspend-4-tiled-mtl-rc-ccs-cc@pipe-d-hdmi-a-3.html * igt@kms_ccs@crc-sprite-planes-basic-4-tiled-dg2-mc-ccs@pipe-b-hdmi-a-1: - shard-tglu-1: NOTRUN -> [SKIP][108] ([i915#6095]) +34 other tests skip [108]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@kms_ccs@crc-sprite-planes-basic-4-tiled-dg2-mc-ccs@pipe-b-hdmi-a-1.html * igt@kms_ccs@crc-sprite-planes-basic-4-tiled-dg2-rc-ccs-cc@pipe-c-hdmi-a-2: - shard-glk10: NOTRUN -> [SKIP][109] +65 other tests skip [109]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-glk10/igt@kms_ccs@crc-sprite-planes-basic-4-tiled-dg2-rc-ccs-cc@pipe-c-hdmi-a-2.html * igt@kms_ccs@crc-sprite-planes-basic-4-tiled-mtl-rc-ccs@pipe-a-hdmi-a-2: - shard-rkl: NOTRUN -> [SKIP][110] ([i915#14544] / [i915#6095]) +10 other tests skip [110]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_ccs@crc-sprite-planes-basic-4-tiled-mtl-rc-ccs@pipe-a-hdmi-a-2.html * igt@kms_cdclk@mode-transition-all-outputs: - shard-tglu-1: NOTRUN -> [SKIP][111] ([i915#3742]) [111]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@kms_cdclk@mode-transition-all-outputs.html * igt@kms_cdclk@plane-scaling: - shard-rkl: NOTRUN -> [SKIP][112] ([i915#3742]) [112]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-7/igt@kms_cdclk@plane-scaling.html * igt@kms_chamelium_audio@dp-audio-edid: - shard-dg1: NOTRUN -> [SKIP][113] ([i915#11151] / [i915#7828]) [113]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg1-18/igt@kms_chamelium_audio@dp-audio-edid.html * igt@kms_chamelium_edid@hdmi-edid-stress-resolution-non-4k: - shard-dg2: NOTRUN -> [SKIP][114] ([i915#11151] / [i915#7828]) +3 other tests skip [114]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-6/igt@kms_chamelium_edid@hdmi-edid-stress-resolution-non-4k.html * igt@kms_chamelium_frames@dp-crc-single: - shard-tglu-1: NOTRUN -> [SKIP][115] ([i915#11151] / [i915#7828]) +3 other tests skip [115]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@kms_chamelium_frames@dp-crc-single.html * igt@kms_chamelium_hpd@dp-hpd-enable-disable-mode: - shard-rkl: NOTRUN -> [SKIP][116] ([i915#11151] / [i915#7828]) +3 other tests skip [116]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-4/igt@kms_chamelium_hpd@dp-hpd-enable-disable-mode.html * igt@kms_chamelium_hpd@vga-hpd-fast: - shard-tglu: NOTRUN -> [SKIP][117] ([i915#11151] / [i915#7828]) +1 other test skip [117]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-3/igt@kms_chamelium_hpd@vga-hpd-fast.html * igt@kms_content_protection@atomic-dpms: - shard-rkl: NOTRUN -> [SKIP][118] ([i915#6944] / [i915#7118] / [i915#9424]) [118]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-5/igt@kms_content_protection@atomic-dpms.html * igt@kms_content_protection@dp-mst-lic-type-0: - shard-tglu-1: NOTRUN -> [SKIP][119] ([i915#3116] / [i915#3299]) [119]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@kms_content_protection@dp-mst-lic-type-0.html * igt@kms_content_protection@legacy@pipe-a-dp-3: - shard-dg2: NOTRUN -> [FAIL][120] ([i915#7173]) [120]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-11/igt@kms_content_protection@legacy@pipe-a-dp-3.html * igt@kms_cursor_crc@cursor-offscreen-max-size: - shard-tglu: NOTRUN -> [SKIP][121] ([i915#3555]) [121]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-3/igt@kms_cursor_crc@cursor-offscreen-max-size.html * igt@kms_cursor_crc@cursor-onscreen-512x170: - shard-tglu-1: NOTRUN -> [SKIP][122] ([i915#13049]) [122]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@kms_cursor_crc@cursor-onscreen-512x170.html * igt@kms_cursor_crc@cursor-random-128x42@pipe-a-hdmi-a-2: - shard-rkl: NOTRUN -> [FAIL][123] ([i915#13566]) +2 other tests fail [123]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_cursor_crc@cursor-random-128x42@pipe-a-hdmi-a-2.html * igt@kms_cursor_crc@cursor-random-512x512: - shard-rkl: NOTRUN -> [SKIP][124] ([i915#13049]) [124]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-5/igt@kms_cursor_crc@cursor-random-512x512.html * igt@kms_cursor_crc@cursor-rapid-movement-512x512: - shard-tglu: NOTRUN -> [SKIP][125] ([i915#13049]) +1 other test skip [125]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-3/igt@kms_cursor_crc@cursor-rapid-movement-512x512.html * igt@kms_cursor_crc@cursor-sliding-512x170: - shard-dg2: NOTRUN -> [SKIP][126] ([i915#13049]) [126]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-11/igt@kms_cursor_crc@cursor-sliding-512x170.html * igt@kms_cursor_crc@cursor-suspend: - shard-glk: NOTRUN -> [INCOMPLETE][127] ([i915#12358] / [i915#14152] / [i915#7882]) [127]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-glk1/igt@kms_cursor_crc@cursor-suspend.html * igt@kms_cursor_crc@cursor-suspend@pipe-a-hdmi-a-1: - shard-glk: NOTRUN -> [INCOMPLETE][128] ([i915#12358] / [i915#14152]) [128]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-glk1/igt@kms_cursor_crc@cursor-suspend@pipe-a-hdmi-a-1.html * igt@kms_cursor_legacy@2x-long-flip-vs-cursor-atomic: - shard-dg2: NOTRUN -> [SKIP][129] ([i915#13046] / [i915#5354]) +1 other test skip [129]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@kms_cursor_legacy@2x-long-flip-vs-cursor-atomic.html * igt@kms_cursor_legacy@basic-busy-flip-before-cursor-legacy: - shard-tglu-1: NOTRUN -> [SKIP][130] ([i915#4103]) +1 other test skip [130]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@kms_cursor_legacy@basic-busy-flip-before-cursor-legacy.html * igt@kms_cursor_legacy@flip-vs-cursor-atomic-transitions-varying-size: - shard-glk: NOTRUN -> [FAIL][131] ([i915#2346]) [131]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-glk9/igt@kms_cursor_legacy@flip-vs-cursor-atomic-transitions-varying-size.html * igt@kms_cursor_legacy@forked-move: - shard-dg1: [PASS][132] -> [DMESG-WARN][133] ([i915#4423]) [132]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg1-14/igt@kms_cursor_legacy@forked-move.html [133]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg1-14/igt@kms_cursor_legacy@forked-move.html * igt@kms_dirtyfb@drrs-dirtyfb-ioctl: - shard-rkl: NOTRUN -> [SKIP][134] ([i915#9723]) [134]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-5/igt@kms_dirtyfb@drrs-dirtyfb-ioctl.html * igt@kms_dp_aux_dev: - shard-tglu-1: NOTRUN -> [SKIP][135] ([i915#1257]) [135]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@kms_dp_aux_dev.html * igt@kms_dp_link_training@non-uhbr-mst: - shard-tglu-1: NOTRUN -> [SKIP][136] ([i915#13749]) [136]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@kms_dp_link_training@non-uhbr-mst.html * igt@kms_dp_linktrain_fallback@dp-fallback: - shard-rkl: NOTRUN -> [SKIP][137] ([i915#13707]) [137]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-7/igt@kms_dp_linktrain_fallback@dp-fallback.html * igt@kms_dsc@dsc-with-bpc: - shard-tglu: NOTRUN -> [SKIP][138] ([i915#3555] / [i915#3840]) [138]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-3/igt@kms_dsc@dsc-with-bpc.html * igt@kms_dsc@dsc-with-bpc-formats: - shard-rkl: NOTRUN -> [SKIP][139] ([i915#3555] / [i915#3840]) [139]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-5/igt@kms_dsc@dsc-with-bpc-formats.html * igt@kms_dsc@dsc-with-output-formats: - shard-dg2: NOTRUN -> [SKIP][140] ([i915#3555] / [i915#3840]) [140]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-6/igt@kms_dsc@dsc-with-output-formats.html * igt@kms_fb_coherency@memset-crc: - shard-dg2: NOTRUN -> [CRASH][141] ([i915#15351]) +1 other test crash [141]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@kms_fb_coherency@memset-crc.html * igt@kms_fb_coherency@memset-crc@mmap-gtt: - shard-glk: NOTRUN -> [CRASH][142] ([i915#15351]) +1 other test crash [142]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-glk5/igt@kms_fb_coherency@memset-crc@mmap-gtt.html * igt@kms_feature_discovery@chamelium: - shard-tglu-1: NOTRUN -> [SKIP][143] ([i915#2065] / [i915#4854]) [143]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@kms_feature_discovery@chamelium.html * igt@kms_feature_discovery@display-2x: - shard-rkl: NOTRUN -> [SKIP][144] ([i915#1839]) [144]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-5/igt@kms_feature_discovery@display-2x.html * igt@kms_feature_discovery@dp-mst: - shard-dg2: NOTRUN -> [SKIP][145] ([i915#9337]) [145]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-6/igt@kms_feature_discovery@dp-mst.html * igt@kms_flip@2x-busy-flip: - shard-dg2: NOTRUN -> [SKIP][146] ([i915#9934]) [146]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@kms_flip@2x-busy-flip.html * igt@kms_flip@2x-flip-vs-absolute-wf_vblank-interruptible: - shard-tglu-1: NOTRUN -> [SKIP][147] ([i915#3637] / [i915#9934]) +1 other test skip [147]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@kms_flip@2x-flip-vs-absolute-wf_vblank-interruptible.html * igt@kms_flip@2x-flip-vs-dpms-on-nop-interruptible: - shard-tglu: NOTRUN -> [SKIP][148] ([i915#9934]) [148]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-3/igt@kms_flip@2x-flip-vs-dpms-on-nop-interruptible.html * igt@kms_flip@2x-flip-vs-expired-vblank-interruptible@ab-hdmi-a1-hdmi-a2: - shard-glk: NOTRUN -> [FAIL][149] ([i915#13027]) +1 other test fail [149]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-glk6/igt@kms_flip@2x-flip-vs-expired-vblank-interruptible@ab-hdmi-a1-hdmi-a2.html * igt@kms_flip@2x-flip-vs-suspend-interruptible: - shard-glk10: NOTRUN -> [INCOMPLETE][150] ([i915#12745] / [i915#4839]) +1 other test incomplete [150]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-glk10/igt@kms_flip@2x-flip-vs-suspend-interruptible.html * igt@kms_flip@2x-flip-vs-suspend@ab-hdmi-a1-hdmi-a2: - shard-glk10: NOTRUN -> [INCOMPLETE][151] ([i915#4839]) +1 other test incomplete [151]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-glk10/igt@kms_flip@2x-flip-vs-suspend@ab-hdmi-a1-hdmi-a2.html * igt@kms_flip@2x-plain-flip-interruptible: - shard-tglu: NOTRUN -> [SKIP][152] ([i915#3637] / [i915#9934]) +3 other tests skip [152]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-3/igt@kms_flip@2x-plain-flip-interruptible.html * igt@kms_flip@2x-single-buffer-flip-vs-dpms-off-vs-modeset-interruptible: - shard-dg1: NOTRUN -> [SKIP][153] ([i915#9934]) [153]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg1-18/igt@kms_flip@2x-single-buffer-flip-vs-dpms-off-vs-modeset-interruptible.html * igt@kms_flip@2x-wf_vblank-ts-check-interruptible: - shard-rkl: NOTRUN -> [SKIP][154] ([i915#9934]) +2 other tests skip [154]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-7/igt@kms_flip@2x-wf_vblank-ts-check-interruptible.html * igt@kms_flip@flip-vs-suspend: - shard-glk: NOTRUN -> [INCOMPLETE][155] ([i915#12745] / [i915#4839]) [155]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-glk9/igt@kms_flip@flip-vs-suspend.html * igt@kms_flip@flip-vs-suspend-interruptible: - shard-rkl: [PASS][156] -> [INCOMPLETE][157] ([i915#6113]) [156]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-5/igt@kms_flip@flip-vs-suspend-interruptible.html [157]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-4/igt@kms_flip@flip-vs-suspend-interruptible.html * igt@kms_flip@flip-vs-suspend-interruptible@a-hdmi-a2: - shard-rkl: NOTRUN -> [INCOMPLETE][158] ([i915#6113]) [158]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-4/igt@kms_flip@flip-vs-suspend-interruptible@a-hdmi-a2.html * igt@kms_flip@flip-vs-suspend@a-hdmi-a1: - shard-glk: NOTRUN -> [INCOMPLETE][159] ([i915#12745]) [159]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-glk9/igt@kms_flip@flip-vs-suspend@a-hdmi-a1.html * igt@kms_flip_scaled_crc@flip-32bpp-yftile-to-32bpp-yftileccs-downscaling: - shard-dg2: NOTRUN -> [SKIP][160] ([i915#2672] / [i915#3555]) +1 other test skip [160]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@kms_flip_scaled_crc@flip-32bpp-yftile-to-32bpp-yftileccs-downscaling.html * igt@kms_flip_scaled_crc@flip-32bpp-yftile-to-32bpp-yftileccs-downscaling@pipe-a-valid-mode: - shard-dg2: NOTRUN -> [SKIP][161] ([i915#2672]) +3 other tests skip [161]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@kms_flip_scaled_crc@flip-32bpp-yftile-to-32bpp-yftileccs-downscaling@pipe-a-valid-mode.html * igt@kms_flip_scaled_crc@flip-32bpp-yftile-to-32bpp-yftileccs-upscaling@pipe-a-valid-mode: - shard-tglu-1: NOTRUN -> [SKIP][162] ([i915#2587] / [i915#2672]) +1 other test skip [162]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@kms_flip_scaled_crc@flip-32bpp-yftile-to-32bpp-yftileccs-upscaling@pipe-a-valid-mode.html * igt@kms_flip_scaled_crc@flip-32bpp-ytileccs-to-64bpp-ytile-upscaling: - shard-dg2: NOTRUN -> [SKIP][163] ([i915#2672] / [i915#3555] / [i915#5190]) +1 other test skip [163]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-6/igt@kms_flip_scaled_crc@flip-32bpp-ytileccs-to-64bpp-ytile-upscaling.html * igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-32bpp-4tiledg2rcccs-upscaling@pipe-a-valid-mode: - shard-rkl: NOTRUN -> [SKIP][164] ([i915#2672]) +2 other tests skip [164]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-5/igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-32bpp-4tiledg2rcccs-upscaling@pipe-a-valid-mode.html * igt@kms_flip_scaled_crc@flip-64bpp-yftile-to-16bpp-yftile-upscaling: - shard-tglu-1: NOTRUN -> [SKIP][165] ([i915#2672] / [i915#3555]) +1 other test skip [165]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@kms_flip_scaled_crc@flip-64bpp-yftile-to-16bpp-yftile-upscaling.html * igt@kms_flip_scaled_crc@flip-64bpp-yftile-to-32bpp-yftile-downscaling: - shard-rkl: NOTRUN -> [SKIP][166] ([i915#2672] / [i915#3555]) +2 other tests skip [166]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-4/igt@kms_flip_scaled_crc@flip-64bpp-yftile-to-32bpp-yftile-downscaling.html * igt@kms_frontbuffer_tracking@fbc-2p-primscrn-cur-indfb-draw-mmap-wc: - shard-dg2: NOTRUN -> [SKIP][167] ([i915#8708]) +8 other tests skip [167]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-6/igt@kms_frontbuffer_tracking@fbc-2p-primscrn-cur-indfb-draw-mmap-wc.html * igt@kms_frontbuffer_tracking@fbc-2p-rte: - shard-dg2: NOTRUN -> [SKIP][168] ([i915#5354]) +13 other tests skip [168]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-6/igt@kms_frontbuffer_tracking@fbc-2p-rte.html * igt@kms_frontbuffer_tracking@fbc-modesetfrombusy: - shard-dg2: [PASS][169] -> [SKIP][170] +2 other tests skip [169]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg2-3/igt@kms_frontbuffer_tracking@fbc-modesetfrombusy.html [170]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@kms_frontbuffer_tracking@fbc-modesetfrombusy.html * igt@kms_frontbuffer_tracking@fbc-tiling-4: - shard-rkl: NOTRUN -> [SKIP][171] ([i915#5439]) [171]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-7/igt@kms_frontbuffer_tracking@fbc-tiling-4.html * igt@kms_frontbuffer_tracking@fbc-tiling-y: - shard-dg2: NOTRUN -> [SKIP][172] ([i915#10055]) [172]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-6/igt@kms_frontbuffer_tracking@fbc-tiling-y.html * igt@kms_frontbuffer_tracking@fbcpsr-1p-offscreen-pri-indfb-draw-mmap-gtt: - shard-dg2: NOTRUN -> [SKIP][173] ([i915#15104]) [173]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-6/igt@kms_frontbuffer_tracking@fbcpsr-1p-offscreen-pri-indfb-draw-mmap-gtt.html * igt@kms_frontbuffer_tracking@fbcpsr-1p-offscreen-pri-shrfb-draw-mmap-cpu: - shard-tglu: NOTRUN -> [SKIP][174] ([i915#15102]) +9 other tests skip [174]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-3/igt@kms_frontbuffer_tracking@fbcpsr-1p-offscreen-pri-shrfb-draw-mmap-cpu.html * igt@kms_frontbuffer_tracking@fbcpsr-1p-offscreen-pri-shrfb-draw-mmap-wc: - shard-snb: NOTRUN -> [SKIP][175] +26 other tests skip [175]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-snb5/igt@kms_frontbuffer_tracking@fbcpsr-1p-offscreen-pri-shrfb-draw-mmap-wc.html * igt@kms_frontbuffer_tracking@fbcpsr-1p-offscreen-pri-shrfb-draw-pwrite: - shard-dg2: NOTRUN -> [SKIP][176] ([i915#15102]) +1 other test skip [176]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-11/igt@kms_frontbuffer_tracking@fbcpsr-1p-offscreen-pri-shrfb-draw-pwrite.html * igt@kms_frontbuffer_tracking@fbcpsr-2p-scndscrn-shrfb-pgflip-blt: - shard-tglu-1: NOTRUN -> [SKIP][177] +26 other tests skip [177]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@kms_frontbuffer_tracking@fbcpsr-2p-scndscrn-shrfb-pgflip-blt.html * igt@kms_frontbuffer_tracking@pipe-fbc-rte: - shard-tglu: NOTRUN -> [SKIP][178] ([i915#9766]) [178]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-3/igt@kms_frontbuffer_tracking@pipe-fbc-rte.html * igt@kms_frontbuffer_tracking@psr-1p-offscreen-pri-indfb-draw-pwrite: - shard-rkl: NOTRUN -> [SKIP][179] ([i915#15102]) +1 other test skip [179]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-5/igt@kms_frontbuffer_tracking@psr-1p-offscreen-pri-indfb-draw-pwrite.html * igt@kms_frontbuffer_tracking@psr-1p-offscreen-pri-shrfb-draw-mmap-gtt: - shard-tglu-1: NOTRUN -> [SKIP][180] ([i915#15102]) +12 other tests skip [180]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@kms_frontbuffer_tracking@psr-1p-offscreen-pri-shrfb-draw-mmap-gtt.html * igt@kms_frontbuffer_tracking@psr-1p-primscrn-shrfb-msflip-blt: - shard-rkl: NOTRUN -> [SKIP][181] ([i915#15102] / [i915#3023]) +7 other tests skip [181]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-5/igt@kms_frontbuffer_tracking@psr-1p-primscrn-shrfb-msflip-blt.html * igt@kms_frontbuffer_tracking@psr-2p-primscrn-cur-indfb-draw-mmap-wc: - shard-dg1: NOTRUN -> [SKIP][182] ([i915#8708]) [182]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg1-18/igt@kms_frontbuffer_tracking@psr-2p-primscrn-cur-indfb-draw-mmap-wc.html * igt@kms_frontbuffer_tracking@psr-2p-scndscrn-indfb-msflip-blt: - shard-rkl: NOTRUN -> [SKIP][183] ([i915#1825]) +24 other tests skip [183]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-7/igt@kms_frontbuffer_tracking@psr-2p-scndscrn-indfb-msflip-blt.html * igt@kms_frontbuffer_tracking@psr-rgb101010-draw-render: - shard-dg2: NOTRUN -> [SKIP][184] ([i915#15102] / [i915#3458]) +4 other tests skip [184]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@kms_frontbuffer_tracking@psr-rgb101010-draw-render.html * igt@kms_frontbuffer_tracking@psr-suspend: - shard-dg1: NOTRUN -> [SKIP][185] ([i915#15102] / [i915#3458]) [185]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg1-18/igt@kms_frontbuffer_tracking@psr-suspend.html * igt@kms_hdr@static-toggle: - shard-dg2: NOTRUN -> [SKIP][186] ([i915#3555] / [i915#8228]) [186]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@kms_hdr@static-toggle.html - shard-rkl: NOTRUN -> [SKIP][187] ([i915#3555] / [i915#8228]) [187]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-4/igt@kms_hdr@static-toggle.html * igt@kms_hdr@static-toggle-suspend: - shard-dg2: [PASS][188] -> [SKIP][189] ([i915#3555] / [i915#8228]) [188]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg2-11/igt@kms_hdr@static-toggle-suspend.html [189]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-6/igt@kms_hdr@static-toggle-suspend.html - shard-tglu-1: NOTRUN -> [SKIP][190] ([i915#3555] / [i915#8228]) [190]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@kms_hdr@static-toggle-suspend.html * igt@kms_joiner@invalid-modeset-big-joiner: - shard-tglu: NOTRUN -> [SKIP][191] ([i915#15460]) [191]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-3/igt@kms_joiner@invalid-modeset-big-joiner.html * igt@kms_joiner@invalid-modeset-force-ultra-joiner: - shard-dg2: NOTRUN -> [SKIP][192] ([i915#15458]) [192]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-6/igt@kms_joiner@invalid-modeset-force-ultra-joiner.html * igt@kms_joiner@switch-modeset-ultra-joiner-big-joiner: - shard-tglu-1: NOTRUN -> [SKIP][193] ([i915#13522]) [193]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@kms_joiner@switch-modeset-ultra-joiner-big-joiner.html * igt@kms_multipipe_modeset@basic-max-pipe-crc-check: - shard-tglu: NOTRUN -> [SKIP][194] ([i915#1839]) [194]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-3/igt@kms_multipipe_modeset@basic-max-pipe-crc-check.html * igt@kms_pipe_stress@stress-xrgb8888-4tiled: - shard-rkl: NOTRUN -> [SKIP][195] ([i915#14712]) [195]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-5/igt@kms_pipe_stress@stress-xrgb8888-4tiled.html * igt@kms_pipe_stress@stress-xrgb8888-yftiled: - shard-tglu-1: NOTRUN -> [SKIP][196] ([i915#14712]) [196]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@kms_pipe_stress@stress-xrgb8888-yftiled.html * igt@kms_plane_alpha_blend@alpha-opaque-fb: - shard-glk: NOTRUN -> [FAIL][197] ([i915#10647] / [i915#12169]) [197]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-glk6/igt@kms_plane_alpha_blend@alpha-opaque-fb.html * igt@kms_plane_alpha_blend@alpha-opaque-fb@pipe-a-hdmi-a-1: - shard-glk: NOTRUN -> [FAIL][198] ([i915#10647]) +1 other test fail [198]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-glk6/igt@kms_plane_alpha_blend@alpha-opaque-fb@pipe-a-hdmi-a-1.html * igt@kms_plane_lowres@tiling-yf: - shard-tglu-1: NOTRUN -> [SKIP][199] ([i915#3555]) +1 other test skip [199]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@kms_plane_lowres@tiling-yf.html * igt@kms_plane_multiple@2x-tiling-none: - shard-dg1: NOTRUN -> [SKIP][200] ([i915#13958]) [200]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg1-18/igt@kms_plane_multiple@2x-tiling-none.html * igt@kms_plane_multiple@tiling-4: - shard-tglu: NOTRUN -> [SKIP][201] ([i915#14259]) [201]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-3/igt@kms_plane_multiple@tiling-4.html * igt@kms_plane_scaling@plane-scaler-with-clipping-clamping-rotation: - shard-tglu-1: NOTRUN -> [SKIP][202] ([i915#15329] / [i915#3555]) [202]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@kms_plane_scaling@plane-scaler-with-clipping-clamping-rotation.html * igt@kms_plane_scaling@plane-scaler-with-clipping-clamping-rotation@pipe-b: - shard-tglu-1: NOTRUN -> [SKIP][203] ([i915#15329]) +8 other tests skip [203]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@kms_plane_scaling@plane-scaler-with-clipping-clamping-rotation@pipe-b.html * igt@kms_pm_backlight@brightness-with-dpms: - shard-dg2: NOTRUN -> [SKIP][204] ([i915#12343]) [204]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@kms_pm_backlight@brightness-with-dpms.html * igt@kms_pm_backlight@fade-with-dpms: - shard-rkl: NOTRUN -> [SKIP][205] ([i915#5354]) [205]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-5/igt@kms_pm_backlight@fade-with-dpms.html * igt@kms_pm_dc@dc3co-vpb-simulation: - shard-dg2: NOTRUN -> [SKIP][206] ([i915#9685]) [206]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@kms_pm_dc@dc3co-vpb-simulation.html - shard-rkl: NOTRUN -> [SKIP][207] ([i915#9685]) [207]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-4/igt@kms_pm_dc@dc3co-vpb-simulation.html * igt@kms_pm_dc@dc6-dpms: - shard-tglu-1: NOTRUN -> [FAIL][208] ([i915#9295]) [208]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@kms_pm_dc@dc6-dpms.html * igt@kms_pm_lpsp@kms-lpsp: - shard-rkl: NOTRUN -> [SKIP][209] ([i915#3828]) [209]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-5/igt@kms_pm_lpsp@kms-lpsp.html * igt@kms_pm_rpm@modeset-lpsp: - shard-rkl: [PASS][210] -> [SKIP][211] ([i915#15073]) [210]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-8/igt@kms_pm_rpm@modeset-lpsp.html [211]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-3/igt@kms_pm_rpm@modeset-lpsp.html * igt@kms_pm_rpm@modeset-lpsp-stress-no-wait: - shard-dg2: NOTRUN -> [SKIP][212] ([i915#15073]) [212]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@kms_pm_rpm@modeset-lpsp-stress-no-wait.html - shard-rkl: NOTRUN -> [SKIP][213] ([i915#15073]) [213]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-4/igt@kms_pm_rpm@modeset-lpsp-stress-no-wait.html * igt@kms_pm_rpm@modeset-non-lpsp-stress: - shard-tglu-1: NOTRUN -> [SKIP][214] ([i915#15073]) [214]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@kms_pm_rpm@modeset-non-lpsp-stress.html * igt@kms_pm_rpm@modeset-non-lpsp-stress-no-wait: - shard-dg2: [PASS][215] -> [SKIP][216] ([i915#15073]) [215]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg2-8/igt@kms_pm_rpm@modeset-non-lpsp-stress-no-wait.html [216]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-4/igt@kms_pm_rpm@modeset-non-lpsp-stress-no-wait.html * igt@kms_prime@d3hot: - shard-tglu: NOTRUN -> [SKIP][217] ([i915#6524]) [217]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-3/igt@kms_prime@d3hot.html * igt@kms_psr2_sf@fbc-pr-overlay-plane-move-continuous-sf: - shard-tglu: NOTRUN -> [SKIP][218] ([i915#11520]) +5 other tests skip [218]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-3/igt@kms_psr2_sf@fbc-pr-overlay-plane-move-continuous-sf.html * igt@kms_psr2_sf@fbc-pr-overlay-plane-update-continuous-sf: - shard-dg2: NOTRUN -> [SKIP][219] ([i915#11520]) +3 other tests skip [219]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-6/igt@kms_psr2_sf@fbc-pr-overlay-plane-update-continuous-sf.html * igt@kms_psr2_sf@fbc-pr-overlay-primary-update-sf-dmg-area: - shard-rkl: NOTRUN -> [SKIP][220] ([i915#11520]) +5 other tests skip [220]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-7/igt@kms_psr2_sf@fbc-pr-overlay-primary-update-sf-dmg-area.html * igt@kms_psr2_sf@fbc-psr2-overlay-plane-update-continuous-sf: - shard-glk10: NOTRUN -> [SKIP][221] ([i915#11520]) [221]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-glk10/igt@kms_psr2_sf@fbc-psr2-overlay-plane-update-continuous-sf.html * igt@kms_psr2_sf@psr2-cursor-plane-move-continuous-exceed-sf: - shard-tglu-1: NOTRUN -> [SKIP][222] ([i915#11520]) +2 other tests skip [222]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@kms_psr2_sf@psr2-cursor-plane-move-continuous-exceed-sf.html * igt@kms_psr2_sf@psr2-overlay-plane-move-continuous-exceed-fully-sf: - shard-glk: NOTRUN -> [SKIP][223] ([i915#11520]) +7 other tests skip [223]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-glk1/igt@kms_psr2_sf@psr2-overlay-plane-move-continuous-exceed-fully-sf.html * igt@kms_psr2_su@page_flip-xrgb8888: - shard-dg2: NOTRUN -> [SKIP][224] ([i915#9683]) [224]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-6/igt@kms_psr2_su@page_flip-xrgb8888.html * igt@kms_psr@pr-cursor-plane-onoff: - shard-rkl: NOTRUN -> [SKIP][225] ([i915#1072] / [i915#9732]) +16 other tests skip [225]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-4/igt@kms_psr@pr-cursor-plane-onoff.html * igt@kms_psr@psr2-cursor-mmap-gtt: - shard-tglu-1: NOTRUN -> [SKIP][226] ([i915#9732]) +9 other tests skip [226]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@kms_psr@psr2-cursor-mmap-gtt.html * igt@kms_psr@psr2-cursor-render: - shard-tglu: NOTRUN -> [SKIP][227] ([i915#9732]) +4 other tests skip [227]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-3/igt@kms_psr@psr2-cursor-render.html * igt@kms_psr@psr2-primary-blt: - shard-dg2: NOTRUN -> [SKIP][228] ([i915#1072] / [i915#9732]) +6 other tests skip [228]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-6/igt@kms_psr@psr2-primary-blt.html * igt@kms_psr_stress_test@flip-primary-invalidate-overlay: - shard-tglu-1: NOTRUN -> [SKIP][229] ([i915#9685]) [229]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-1/igt@kms_psr_stress_test@flip-primary-invalidate-overlay.html * igt@kms_rotation_crc@bad-tiling: - shard-dg2: NOTRUN -> [SKIP][230] ([i915#12755]) [230]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-6/igt@kms_rotation_crc@bad-tiling.html * igt@kms_rotation_crc@primary-yf-tiled-reflect-x-0: - shard-rkl: NOTRUN -> [SKIP][231] ([i915#5289]) [231]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-5/igt@kms_rotation_crc@primary-yf-tiled-reflect-x-0.html * igt@kms_scaling_modes@scaling-mode-none: - shard-dg2: NOTRUN -> [SKIP][232] ([i915#3555]) +3 other tests skip [232]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@kms_scaling_modes@scaling-mode-none.html - shard-rkl: NOTRUN -> [SKIP][233] ([i915#3555]) +3 other tests skip [233]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-4/igt@kms_scaling_modes@scaling-mode-none.html * igt@kms_vblank@ts-continuation-dpms-suspend@pipe-a-hdmi-a-1: - shard-glk: NOTRUN -> [INCOMPLETE][234] ([i915#12276]) +1 other test incomplete [234]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-glk5/igt@kms_vblank@ts-continuation-dpms-suspend@pipe-a-hdmi-a-1.html * igt@kms_vrr@flip-basic-fastset: - shard-dg2: NOTRUN -> [SKIP][235] ([i915#9906]) +1 other test skip [235]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-6/igt@kms_vrr@flip-basic-fastset.html * igt@kms_vrr@flipline: - shard-rkl: NOTRUN -> [SKIP][236] ([i915#15243] / [i915#3555]) [236]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-7/igt@kms_vrr@flipline.html * igt@kms_vrr@lobf: - shard-rkl: NOTRUN -> [SKIP][237] ([i915#11920]) [237]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-5/igt@kms_vrr@lobf.html * igt@kms_vrr@seamless-rr-switch-vrr: - shard-tglu: NOTRUN -> [SKIP][238] ([i915#9906]) [238]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-3/igt@kms_vrr@seamless-rr-switch-vrr.html * igt@perf_pmu@busy-double-start@vecs0: - shard-dg1: [PASS][239] -> [FAIL][240] ([i915#4349]) +1 other test fail [239]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg1-13/igt@perf_pmu@busy-double-start@vecs0.html [240]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg1-17/igt@perf_pmu@busy-double-start@vecs0.html - shard-mtlp: [PASS][241] -> [FAIL][242] ([i915#4349]) [241]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-mtlp-8/igt@perf_pmu@busy-double-start@vecs0.html [242]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-mtlp-3/igt@perf_pmu@busy-double-start@vecs0.html * igt@perf_pmu@busy-double-start@vecs1: - shard-dg2: [PASS][243] -> [FAIL][244] ([i915#4349]) +5 other tests fail [243]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg2-6/igt@perf_pmu@busy-double-start@vecs1.html [244]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-5/igt@perf_pmu@busy-double-start@vecs1.html * igt@perf_pmu@rc6@other-idle-gt0: - shard-tglu: NOTRUN -> [SKIP][245] ([i915#8516]) [245]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-tglu-3/igt@perf_pmu@rc6@other-idle-gt0.html * igt@prime_vgem@basic-fence-flip: - shard-dg1: NOTRUN -> [SKIP][246] ([i915#3708]) [246]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg1-18/igt@prime_vgem@basic-fence-flip.html * igt@prime_vgem@fence-read-hang: - shard-rkl: NOTRUN -> [SKIP][247] ([i915#3708]) [247]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-5/igt@prime_vgem@fence-read-hang.html #### Possible fixes #### * igt@gem_ccs@suspend-resume: - shard-dg2: [INCOMPLETE][248] ([i915#13356]) -> [PASS][249] [248]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg2-1/igt@gem_ccs@suspend-resume.html [249]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-6/igt@gem_ccs@suspend-resume.html * igt@gem_ccs@suspend-resume@tile4-compressed-compfmt0-smem-lmem0: - shard-dg2: [INCOMPLETE][250] ([i915#12392] / [i915#13356]) -> [PASS][251] [250]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg2-1/igt@gem_ccs@suspend-resume@tile4-compressed-compfmt0-smem-lmem0.html [251]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-6/igt@gem_ccs@suspend-resume@tile4-compressed-compfmt0-smem-lmem0.html * igt@gem_exec_suspend@basic-s0@smem: - shard-rkl: [ABORT][252] ([i915#15131]) -> [PASS][253] +1 other test pass [252]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-1/igt@gem_exec_suspend@basic-s0@smem.html [253]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-5/igt@gem_exec_suspend@basic-s0@smem.html * igt@i915_suspend@forcewake: - shard-rkl: [INCOMPLETE][254] ([i915#4817]) -> [PASS][255] [254]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-6/igt@i915_suspend@forcewake.html [255]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-7/igt@i915_suspend@forcewake.html * igt@kms_cursor_crc@cursor-size-change@pipe-a-edp-1: - shard-mtlp: [FAIL][256] ([i915#13566]) -> [PASS][257] +1 other test pass [256]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-mtlp-7/igt@kms_cursor_crc@cursor-size-change@pipe-a-edp-1.html [257]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-mtlp-8/igt@kms_cursor_crc@cursor-size-change@pipe-a-edp-1.html * igt@kms_draw_crc@draw-method-blt: - shard-dg1: [DMESG-WARN][258] ([i915#4423]) -> [PASS][259] +1 other test pass [258]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg1-13/igt@kms_draw_crc@draw-method-blt.html [259]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg1-17/igt@kms_draw_crc@draw-method-blt.html * igt@kms_flip@plain-flip-fb-recreate-interruptible@a-vga1: - shard-snb: [FAIL][260] ([i915#10826]) -> [PASS][261] +1 other test pass [260]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-snb5/igt@kms_flip@plain-flip-fb-recreate-interruptible@a-vga1.html [261]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-snb7/igt@kms_flip@plain-flip-fb-recreate-interruptible@a-vga1.html * igt@kms_hdr@bpc-switch-dpms: - shard-rkl: [SKIP][262] ([i915#3555] / [i915#8228]) -> [PASS][263] [262]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-8/igt@kms_hdr@bpc-switch-dpms.html [263]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_hdr@bpc-switch-dpms.html * igt@kms_hdr@bpc-switch-suspend: - shard-dg2: [SKIP][264] ([i915#3555] / [i915#8228]) -> [PASS][265] +1 other test pass [264]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg2-8/igt@kms_hdr@bpc-switch-suspend.html [265]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-11/igt@kms_hdr@bpc-switch-suspend.html * igt@kms_plane@plane-panning-bottom-right-suspend@pipe-b: - shard-rkl: [INCOMPLETE][266] ([i915#14412]) -> [PASS][267] +1 other test pass [266]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-6/igt@kms_plane@plane-panning-bottom-right-suspend@pipe-b.html [267]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-5/igt@kms_plane@plane-panning-bottom-right-suspend@pipe-b.html * igt@kms_plane_scaling@intel-max-src-size: - shard-dg2: [SKIP][268] ([i915#6953] / [i915#9423]) -> [PASS][269] [268]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg2-8/igt@kms_plane_scaling@intel-max-src-size.html [269]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-11/igt@kms_plane_scaling@intel-max-src-size.html * igt@kms_pm_lpsp@kms-lpsp: - shard-dg2: [SKIP][270] ([i915#9340]) -> [PASS][271] [270]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg2-11/igt@kms_pm_lpsp@kms-lpsp.html [271]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-4/igt@kms_pm_lpsp@kms-lpsp.html * igt@kms_pm_rpm@dpms-lpsp: - shard-rkl: [SKIP][272] ([i915#15073]) -> [PASS][273] +3 other tests pass [272]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-4/igt@kms_pm_rpm@dpms-lpsp.html [273]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-2/igt@kms_pm_rpm@dpms-lpsp.html * igt@kms_vblank@ts-continuation-dpms-suspend: - shard-rkl: [INCOMPLETE][274] ([i915#12276]) -> [PASS][275] +1 other test pass [274]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-6/igt@kms_vblank@ts-continuation-dpms-suspend.html [275]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-4/igt@kms_vblank@ts-continuation-dpms-suspend.html #### Warnings #### * igt@drm_buddy@drm_buddy: - shard-snb: [DMESG-WARN][276] ([i915#15095]) -> [SKIP][277] [276]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-snb1/igt@drm_buddy@drm_buddy.html [277]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-snb7/igt@drm_buddy@drm_buddy.html * igt@gem_create@create-ext-set-pat: - shard-rkl: [SKIP][278] ([i915#8562]) -> [SKIP][279] ([i915#14544] / [i915#8562]) [278]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-5/igt@gem_create@create-ext-set-pat.html [279]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@gem_create@create-ext-set-pat.html * igt@gem_exec_reloc@basic-active: - shard-rkl: [SKIP][280] ([i915#3281]) -> [SKIP][281] ([i915#14544] / [i915#3281]) +5 other tests skip [280]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-8/igt@gem_exec_reloc@basic-active.html [281]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@gem_exec_reloc@basic-active.html * igt@gem_exec_reloc@basic-cpu-read-active: - shard-dg2: [SKIP][282] ([i915#3281]) -> [SKIP][283] ([i915#2575]) [282]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg2-3/igt@gem_exec_reloc@basic-cpu-read-active.html [283]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@gem_exec_reloc@basic-cpu-read-active.html * igt@gem_exec_reloc@basic-wc-read-noreloc: - shard-rkl: [SKIP][284] ([i915#14544] / [i915#3281]) -> [SKIP][285] ([i915#3281]) +4 other tests skip [284]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-6/igt@gem_exec_reloc@basic-wc-read-noreloc.html [285]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-7/igt@gem_exec_reloc@basic-wc-read-noreloc.html * igt@gem_lmem_swapping@heavy-verify-multi: - shard-rkl: [SKIP][286] ([i915#4613]) -> [SKIP][287] ([i915#14544] / [i915#4613]) +1 other test skip [286]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-8/igt@gem_lmem_swapping@heavy-verify-multi.html [287]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@gem_lmem_swapping@heavy-verify-multi.html * igt@gem_lmem_swapping@parallel-random: - shard-rkl: [SKIP][288] ([i915#14544] / [i915#4613]) -> [SKIP][289] ([i915#4613]) [288]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-6/igt@gem_lmem_swapping@parallel-random.html [289]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-4/igt@gem_lmem_swapping@parallel-random.html * igt@gem_partial_pwrite_pread@write-uncached: - shard-rkl: [SKIP][290] ([i915#14544] / [i915#3282]) -> [SKIP][291] ([i915#3282]) [290]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-6/igt@gem_partial_pwrite_pread@write-uncached.html [291]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-7/igt@gem_partial_pwrite_pread@write-uncached.html * igt@gem_pxp@reject-modify-context-protection-off-1: - shard-dg2: [SKIP][292] ([i915#4270]) -> [SKIP][293] ([i915#2575]) [292]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg2-3/igt@gem_pxp@reject-modify-context-protection-off-1.html [293]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@gem_pxp@reject-modify-context-protection-off-1.html * igt@gem_readwrite@read-bad-handle: - shard-rkl: [SKIP][294] ([i915#3282]) -> [SKIP][295] ([i915#14544] / [i915#3282]) +2 other tests skip [294]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-5/igt@gem_readwrite@read-bad-handle.html [295]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@gem_readwrite@read-bad-handle.html * igt@gen9_exec_parse@basic-rejected-ctx-param: - shard-rkl: [SKIP][296] ([i915#14544] / [i915#2527]) -> [SKIP][297] ([i915#2527]) [296]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-6/igt@gen9_exec_parse@basic-rejected-ctx-param.html [297]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-7/igt@gen9_exec_parse@basic-rejected-ctx-param.html * igt@gen9_exec_parse@bb-start-far: - shard-rkl: [SKIP][298] ([i915#2527]) -> [SKIP][299] ([i915#14544] / [i915#2527]) +1 other test skip [298]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-8/igt@gen9_exec_parse@bb-start-far.html [299]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@gen9_exec_parse@bb-start-far.html * igt@gen9_exec_parse@unaligned-access: - shard-dg2: [SKIP][300] ([i915#2856]) -> [SKIP][301] ([i915#2575]) [300]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg2-3/igt@gen9_exec_parse@unaligned-access.html [301]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@gen9_exec_parse@unaligned-access.html * igt@i915_query@test-query-geometry-subslices: - shard-rkl: [SKIP][302] ([i915#5723]) -> [SKIP][303] ([i915#14544] / [i915#5723]) [302]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-8/igt@i915_query@test-query-geometry-subslices.html [303]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@i915_query@test-query-geometry-subslices.html * igt@kms_big_fb@4-tiled-8bpp-rotate-90: - shard-rkl: [SKIP][304] ([i915#14544] / [i915#5286]) -> [SKIP][305] ([i915#5286]) [304]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-6/igt@kms_big_fb@4-tiled-8bpp-rotate-90.html [305]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-7/igt@kms_big_fb@4-tiled-8bpp-rotate-90.html * igt@kms_big_fb@4-tiled-max-hw-stride-64bpp-rotate-0-async-flip: - shard-rkl: [SKIP][306] ([i915#5286]) -> [SKIP][307] ([i915#14544] / [i915#5286]) +2 other tests skip [306]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-8/igt@kms_big_fb@4-tiled-max-hw-stride-64bpp-rotate-0-async-flip.html [307]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_big_fb@4-tiled-max-hw-stride-64bpp-rotate-0-async-flip.html * igt@kms_big_fb@linear-8bpp-rotate-90: - shard-rkl: [SKIP][308] ([i915#14544] / [i915#3638]) -> [SKIP][309] ([i915#3638]) +1 other test skip [308]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-6/igt@kms_big_fb@linear-8bpp-rotate-90.html [309]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-7/igt@kms_big_fb@linear-8bpp-rotate-90.html * igt@kms_big_fb@y-tiled-64bpp-rotate-270: - shard-rkl: [SKIP][310] ([i915#3638]) -> [SKIP][311] ([i915#14544] / [i915#3638]) +1 other test skip [310]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-5/igt@kms_big_fb@y-tiled-64bpp-rotate-270.html [311]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_big_fb@y-tiled-64bpp-rotate-270.html * igt@kms_ccs@ccs-on-another-bo-yf-tiled-ccs@pipe-a-hdmi-a-2: - shard-rkl: [SKIP][312] ([i915#14544] / [i915#6095]) -> [SKIP][313] ([i915#6095]) +10 other tests skip [312]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-6/igt@kms_ccs@ccs-on-another-bo-yf-tiled-ccs@pipe-a-hdmi-a-2.html [313]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-4/igt@kms_ccs@ccs-on-another-bo-yf-tiled-ccs@pipe-a-hdmi-a-2.html * igt@kms_ccs@crc-primary-basic-4-tiled-lnl-ccs: - shard-rkl: [SKIP][314] ([i915#12313]) -> [SKIP][315] ([i915#12313] / [i915#14544]) [314]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-5/igt@kms_ccs@crc-primary-basic-4-tiled-lnl-ccs.html [315]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_ccs@crc-primary-basic-4-tiled-lnl-ccs.html * igt@kms_ccs@crc-primary-rotation-180-yf-tiled-ccs@pipe-c-hdmi-a-2: - shard-rkl: [SKIP][316] ([i915#14098] / [i915#14544] / [i915#6095]) -> [SKIP][317] ([i915#14098] / [i915#6095]) +11 other tests skip [316]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-6/igt@kms_ccs@crc-primary-rotation-180-yf-tiled-ccs@pipe-c-hdmi-a-2.html [317]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-4/igt@kms_ccs@crc-primary-rotation-180-yf-tiled-ccs@pipe-c-hdmi-a-2.html * igt@kms_ccs@missing-ccs-buffer-y-tiled-ccs: - shard-rkl: [SKIP][318] ([i915#14098] / [i915#6095]) -> [SKIP][319] ([i915#14098] / [i915#14544] / [i915#6095]) +5 other tests skip [318]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-5/igt@kms_ccs@missing-ccs-buffer-y-tiled-ccs.html [319]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_ccs@missing-ccs-buffer-y-tiled-ccs.html * igt@kms_ccs@random-ccs-data-yf-tiled-ccs: - shard-dg1: [SKIP][320] ([i915#4423] / [i915#6095]) -> [SKIP][321] ([i915#6095]) +1 other test skip [320]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg1-13/igt@kms_ccs@random-ccs-data-yf-tiled-ccs.html [321]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg1-17/igt@kms_ccs@random-ccs-data-yf-tiled-ccs.html * igt@kms_chamelium_edid@hdmi-edid-change-during-suspend: - shard-rkl: [SKIP][322] ([i915#11151] / [i915#7828]) -> [SKIP][323] ([i915#11151] / [i915#14544] / [i915#7828]) +4 other tests skip [322]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-5/igt@kms_chamelium_edid@hdmi-edid-change-during-suspend.html [323]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_chamelium_edid@hdmi-edid-change-during-suspend.html * igt@kms_chamelium_hpd@dp-hpd-for-each-pipe: - shard-rkl: [SKIP][324] ([i915#11151] / [i915#14544] / [i915#7828]) -> [SKIP][325] ([i915#11151] / [i915#7828]) +1 other test skip [324]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-6/igt@kms_chamelium_hpd@dp-hpd-for-each-pipe.html [325]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-7/igt@kms_chamelium_hpd@dp-hpd-for-each-pipe.html * igt@kms_content_protection@atomic-dpms: - shard-dg2: [FAIL][326] ([i915#7173]) -> [SKIP][327] ([i915#6944] / [i915#7118] / [i915#9424]) [326]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg2-11/igt@kms_content_protection@atomic-dpms.html [327]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-4/igt@kms_content_protection@atomic-dpms.html * igt@kms_content_protection@dp-mst-suspend-resume: - shard-rkl: [SKIP][328] ([i915#14544] / [i915#15330]) -> [SKIP][329] ([i915#15330]) [328]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-6/igt@kms_content_protection@dp-mst-suspend-resume.html [329]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-7/igt@kms_content_protection@dp-mst-suspend-resume.html * igt@kms_content_protection@dp-mst-type-0: - shard-rkl: [SKIP][330] ([i915#3116]) -> [SKIP][331] ([i915#14544] / [i915#3116]) [330]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-5/igt@kms_content_protection@dp-mst-type-0.html [331]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_content_protection@dp-mst-type-0.html * igt@kms_content_protection@legacy: - shard-dg2: [SKIP][332] ([i915#6944] / [i915#7118] / [i915#9424]) -> [FAIL][333] ([i915#7173]) [332]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg2-8/igt@kms_content_protection@legacy.html [333]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-11/igt@kms_content_protection@legacy.html * igt@kms_content_protection@type1: - shard-dg2: [SKIP][334] ([i915#6944] / [i915#7118] / [i915#9424]) -> [SKIP][335] ([i915#6944] / [i915#7118] / [i915#7162] / [i915#9424]) [334]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg2-4/igt@kms_content_protection@type1.html [335]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-11/igt@kms_content_protection@type1.html * igt@kms_content_protection@uevent: - shard-rkl: [SKIP][336] ([i915#6944] / [i915#7118] / [i915#9424]) -> [SKIP][337] ([i915#14544] / [i915#6944] / [i915#7118] / [i915#9424]) [336]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-5/igt@kms_content_protection@uevent.html [337]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_content_protection@uevent.html * igt@kms_cursor_crc@cursor-onscreen-max-size: - shard-rkl: [SKIP][338] ([i915#14544] / [i915#3555]) -> [SKIP][339] ([i915#3555]) +3 other tests skip [338]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-6/igt@kms_cursor_crc@cursor-onscreen-max-size.html [339]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-7/igt@kms_cursor_crc@cursor-onscreen-max-size.html * igt@kms_cursor_crc@cursor-rapid-movement-32x10: - shard-rkl: [SKIP][340] ([i915#3555]) -> [SKIP][341] ([i915#14544] / [i915#3555]) [340]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-8/igt@kms_cursor_crc@cursor-rapid-movement-32x10.html [341]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_cursor_crc@cursor-rapid-movement-32x10.html * igt@kms_cursor_legacy@2x-flip-vs-cursor-legacy: - shard-rkl: [SKIP][342] -> [SKIP][343] ([i915#14544]) +11 other tests skip [342]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-5/igt@kms_cursor_legacy@2x-flip-vs-cursor-legacy.html [343]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_cursor_legacy@2x-flip-vs-cursor-legacy.html * igt@kms_cursor_legacy@2x-long-flip-vs-cursor-atomic: - shard-rkl: [SKIP][344] ([i915#14544]) -> [SKIP][345] +2 other tests skip [344]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-6/igt@kms_cursor_legacy@2x-long-flip-vs-cursor-atomic.html [345]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-4/igt@kms_cursor_legacy@2x-long-flip-vs-cursor-atomic.html * igt@kms_display_modes@extended-mode-basic: - shard-rkl: [SKIP][346] ([i915#13691]) -> [SKIP][347] ([i915#13691] / [i915#14544]) [346]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-8/igt@kms_display_modes@extended-mode-basic.html [347]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_display_modes@extended-mode-basic.html * igt@kms_dp_link_training@uhbr-mst: - shard-rkl: [SKIP][348] ([i915#13748]) -> [SKIP][349] ([i915#13748] / [i915#14544]) [348]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-5/igt@kms_dp_link_training@uhbr-mst.html [349]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_dp_link_training@uhbr-mst.html * igt@kms_dsc@dsc-basic: - shard-rkl: [SKIP][350] ([i915#3555] / [i915#3840]) -> [SKIP][351] ([i915#14544] / [i915#3555] / [i915#3840]) [350]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-8/igt@kms_dsc@dsc-basic.html [351]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_dsc@dsc-basic.html * igt@kms_dsc@dsc-with-bpc: - shard-dg1: [SKIP][352] ([i915#3555] / [i915#3840]) -> [SKIP][353] ([i915#3555] / [i915#3840] / [i915#4423]) [352]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg1-18/igt@kms_dsc@dsc-with-bpc.html [353]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg1-18/igt@kms_dsc@dsc-with-bpc.html * igt@kms_feature_discovery@display-4x: - shard-rkl: [SKIP][354] ([i915#1839]) -> [SKIP][355] ([i915#14544] / [i915#1839]) [354]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-5/igt@kms_feature_discovery@display-4x.html [355]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_feature_discovery@display-4x.html * igt@kms_flip@2x-absolute-wf_vblank: - shard-rkl: [SKIP][356] ([i915#9934]) -> [SKIP][357] ([i915#14544] / [i915#9934]) +2 other tests skip [356]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-8/igt@kms_flip@2x-absolute-wf_vblank.html [357]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_flip@2x-absolute-wf_vblank.html * igt@kms_flip@2x-flip-vs-dpms-on-nop: - shard-rkl: [SKIP][358] ([i915#14544] / [i915#9934]) -> [SKIP][359] ([i915#9934]) [358]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-6/igt@kms_flip@2x-flip-vs-dpms-on-nop.html [359]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-7/igt@kms_flip@2x-flip-vs-dpms-on-nop.html * igt@kms_flip_scaled_crc@flip-32bpp-yftile-to-32bpp-yftileccs-downscaling: - shard-rkl: [SKIP][360] ([i915#14544] / [i915#2672] / [i915#3555]) -> [SKIP][361] ([i915#2672] / [i915#3555]) +2 other tests skip [360]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-6/igt@kms_flip_scaled_crc@flip-32bpp-yftile-to-32bpp-yftileccs-downscaling.html [361]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-4/igt@kms_flip_scaled_crc@flip-32bpp-yftile-to-32bpp-yftileccs-downscaling.html * igt@kms_flip_scaled_crc@flip-32bpp-ytile-to-32bpp-ytileccs-upscaling@pipe-a-valid-mode: - shard-rkl: [SKIP][362] ([i915#14544] / [i915#2672]) -> [SKIP][363] ([i915#2672]) +2 other tests skip [362]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-6/igt@kms_flip_scaled_crc@flip-32bpp-ytile-to-32bpp-ytileccs-upscaling@pipe-a-valid-mode.html [363]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-7/igt@kms_flip_scaled_crc@flip-32bpp-ytile-to-32bpp-ytileccs-upscaling@pipe-a-valid-mode.html * igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-32bpp-4tile-upscaling: - shard-rkl: [SKIP][364] ([i915#2672] / [i915#3555]) -> [SKIP][365] ([i915#14544] / [i915#2672] / [i915#3555]) +1 other test skip [364]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-8/igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-32bpp-4tile-upscaling.html [365]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-32bpp-4tile-upscaling.html * igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-32bpp-4tiledg2rcccs-downscaling@pipe-a-valid-mode: - shard-rkl: [SKIP][366] ([i915#2672]) -> [SKIP][367] ([i915#14544] / [i915#2672]) +1 other test skip [366]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-5/igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-32bpp-4tiledg2rcccs-downscaling@pipe-a-valid-mode.html [367]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-32bpp-4tiledg2rcccs-downscaling@pipe-a-valid-mode.html * igt@kms_frontbuffer_tracking@fbc-2p-primscrn-pri-indfb-draw-mmap-wc: - shard-rkl: [SKIP][368] ([i915#1825]) -> [SKIP][369] ([i915#14544] / [i915#1825]) +16 other tests skip [368]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-5/igt@kms_frontbuffer_tracking@fbc-2p-primscrn-pri-indfb-draw-mmap-wc.html [369]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_frontbuffer_tracking@fbc-2p-primscrn-pri-indfb-draw-mmap-wc.html * igt@kms_frontbuffer_tracking@fbcpsr-1p-offscreen-pri-indfb-draw-blt: - shard-rkl: [SKIP][370] ([i915#14544] / [i915#15102]) -> [SKIP][371] ([i915#15102]) [370]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-6/igt@kms_frontbuffer_tracking@fbcpsr-1p-offscreen-pri-indfb-draw-blt.html [371]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-4/igt@kms_frontbuffer_tracking@fbcpsr-1p-offscreen-pri-indfb-draw-blt.html * igt@kms_frontbuffer_tracking@fbcpsr-1p-offscreen-pri-indfb-draw-render: - shard-rkl: [SKIP][372] ([i915#15102]) -> [SKIP][373] ([i915#14544] / [i915#15102]) [372]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-8/igt@kms_frontbuffer_tracking@fbcpsr-1p-offscreen-pri-indfb-draw-render.html [373]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_frontbuffer_tracking@fbcpsr-1p-offscreen-pri-indfb-draw-render.html * igt@kms_frontbuffer_tracking@fbcpsr-1p-primscrn-pri-indfb-draw-pwrite: - shard-rkl: [SKIP][374] ([i915#14544] / [i915#15102] / [i915#3023]) -> [SKIP][375] ([i915#15102] / [i915#3023]) +4 other tests skip [374]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-6/igt@kms_frontbuffer_tracking@fbcpsr-1p-primscrn-pri-indfb-draw-pwrite.html [375]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-4/igt@kms_frontbuffer_tracking@fbcpsr-1p-primscrn-pri-indfb-draw-pwrite.html * igt@kms_frontbuffer_tracking@fbcpsr-2p-primscrn-cur-indfb-move: - shard-rkl: [SKIP][376] ([i915#14544] / [i915#1825]) -> [SKIP][377] ([i915#1825]) +6 other tests skip [376]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-6/igt@kms_frontbuffer_tracking@fbcpsr-2p-primscrn-cur-indfb-move.html [377]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-7/igt@kms_frontbuffer_tracking@fbcpsr-2p-primscrn-cur-indfb-move.html * igt@kms_frontbuffer_tracking@fbcpsr-rgb101010-draw-pwrite: - shard-dg2: [SKIP][378] ([i915#10433] / [i915#15102] / [i915#3458]) -> [SKIP][379] ([i915#15102] / [i915#3458]) [378]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg2-4/igt@kms_frontbuffer_tracking@fbcpsr-rgb101010-draw-pwrite.html [379]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-11/igt@kms_frontbuffer_tracking@fbcpsr-rgb101010-draw-pwrite.html * igt@kms_frontbuffer_tracking@fbcpsr-suspend: - shard-dg2: [SKIP][380] ([i915#15102] / [i915#3458]) -> [SKIP][381] ([i915#10433] / [i915#15102] / [i915#3458]) +2 other tests skip [380]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg2-11/igt@kms_frontbuffer_tracking@fbcpsr-suspend.html [381]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-4/igt@kms_frontbuffer_tracking@fbcpsr-suspend.html * igt@kms_frontbuffer_tracking@fbcpsr-tiling-y: - shard-dg2: [SKIP][382] ([i915#10055]) -> [SKIP][383] [382]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg2-3/igt@kms_frontbuffer_tracking@fbcpsr-tiling-y.html [383]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@kms_frontbuffer_tracking@fbcpsr-tiling-y.html * igt@kms_frontbuffer_tracking@psr-1p-primscrn-cur-indfb-move: - shard-rkl: [SKIP][384] ([i915#15102] / [i915#3023]) -> [SKIP][385] ([i915#14544] / [i915#15102] / [i915#3023]) +7 other tests skip [384]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-5/igt@kms_frontbuffer_tracking@psr-1p-primscrn-cur-indfb-move.html [385]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_frontbuffer_tracking@psr-1p-primscrn-cur-indfb-move.html * igt@kms_frontbuffer_tracking@psr-rgb565-draw-mmap-cpu: - shard-dg2: [SKIP][386] ([i915#15102] / [i915#3458]) -> [SKIP][387] [386]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg2-3/igt@kms_frontbuffer_tracking@psr-rgb565-draw-mmap-cpu.html [387]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@kms_frontbuffer_tracking@psr-rgb565-draw-mmap-cpu.html * igt@kms_hdr@brightness-with-hdr: - shard-dg2: [SKIP][388] ([i915#12713]) -> [SKIP][389] ([i915#13331]) [388]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg2-4/igt@kms_hdr@brightness-with-hdr.html [389]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-11/igt@kms_hdr@brightness-with-hdr.html - shard-rkl: [SKIP][390] ([i915#13331]) -> [SKIP][391] ([i915#12713]) [390]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-1/igt@kms_hdr@brightness-with-hdr.html [391]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-8/igt@kms_hdr@brightness-with-hdr.html * igt@kms_joiner@invalid-modeset-force-big-joiner: - shard-rkl: [SKIP][392] ([i915#15459]) -> [SKIP][393] ([i915#14544] / [i915#15459]) [392]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-5/igt@kms_joiner@invalid-modeset-force-big-joiner.html [393]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_joiner@invalid-modeset-force-big-joiner.html * igt@kms_joiner@invalid-modeset-ultra-joiner: - shard-rkl: [SKIP][394] ([i915#15458]) -> [SKIP][395] ([i915#14544] / [i915#15458]) [394]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-8/igt@kms_joiner@invalid-modeset-ultra-joiner.html [395]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_joiner@invalid-modeset-ultra-joiner.html * igt@kms_plane_multiple@2x-tiling-x: - shard-rkl: [SKIP][396] ([i915#13958]) -> [SKIP][397] ([i915#13958] / [i915#14544]) [396]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-8/igt@kms_plane_multiple@2x-tiling-x.html [397]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_plane_multiple@2x-tiling-x.html * igt@kms_plane_multiple@tiling-yf: - shard-rkl: [SKIP][398] ([i915#14259]) -> [SKIP][399] ([i915#14259] / [i915#14544]) [398]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-5/igt@kms_plane_multiple@tiling-yf.html [399]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_plane_multiple@tiling-yf.html * igt@kms_plane_scaling@plane-upscale-factor-0-25-with-rotation@pipe-c: - shard-rkl: [SKIP][400] ([i915#15329]) -> [SKIP][401] ([i915#14544] / [i915#15329]) +3 other tests skip [400]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-8/igt@kms_plane_scaling@plane-upscale-factor-0-25-with-rotation@pipe-c.html [401]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_plane_scaling@plane-upscale-factor-0-25-with-rotation@pipe-c.html * igt@kms_pm_backlight@basic-brightness: - shard-rkl: [SKIP][402] ([i915#5354]) -> [SKIP][403] ([i915#14544] / [i915#5354]) [402]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-5/igt@kms_pm_backlight@basic-brightness.html [403]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_pm_backlight@basic-brightness.html * igt@kms_pm_backlight@brightness-with-dpms: - shard-rkl: [SKIP][404] ([i915#12343] / [i915#14544]) -> [SKIP][405] ([i915#12343]) [404]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-6/igt@kms_pm_backlight@brightness-with-dpms.html [405]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-4/igt@kms_pm_backlight@brightness-with-dpms.html * igt@kms_pm_backlight@fade-with-suspend: - shard-dg2: [SKIP][406] ([i915#5354]) -> [SKIP][407] +1 other test skip [406]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg2-3/igt@kms_pm_backlight@fade-with-suspend.html [407]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@kms_pm_backlight@fade-with-suspend.html * igt@kms_pm_dc@dc5-retention-flops: - shard-rkl: [SKIP][408] ([i915#3828]) -> [SKIP][409] ([i915#14544] / [i915#3828]) [408]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-8/igt@kms_pm_dc@dc5-retention-flops.html [409]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_pm_dc@dc5-retention-flops.html * igt@kms_prime@basic-modeset-hybrid: - shard-rkl: [SKIP][410] ([i915#6524]) -> [SKIP][411] ([i915#14544] / [i915#6524]) [410]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-8/igt@kms_prime@basic-modeset-hybrid.html [411]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_prime@basic-modeset-hybrid.html * igt@kms_psr2_sf@fbc-psr2-overlay-plane-update-sf-dmg-area: - shard-rkl: [SKIP][412] ([i915#11520]) -> [SKIP][413] ([i915#11520] / [i915#14544]) +2 other tests skip [412]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-5/igt@kms_psr2_sf@fbc-psr2-overlay-plane-update-sf-dmg-area.html [413]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_psr2_sf@fbc-psr2-overlay-plane-update-sf-dmg-area.html * igt@kms_psr2_sf@psr2-primary-plane-update-sf-dmg-area: - shard-rkl: [SKIP][414] ([i915#11520] / [i915#14544]) -> [SKIP][415] ([i915#11520]) +1 other test skip [414]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-6/igt@kms_psr2_sf@psr2-primary-plane-update-sf-dmg-area.html [415]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-4/igt@kms_psr2_sf@psr2-primary-plane-update-sf-dmg-area.html * igt@kms_psr2_su@frontbuffer-xrgb8888: - shard-rkl: [SKIP][416] ([i915#9683]) -> [SKIP][417] ([i915#14544] / [i915#9683]) [416]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-5/igt@kms_psr2_su@frontbuffer-xrgb8888.html [417]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_psr2_su@frontbuffer-xrgb8888.html * igt@kms_psr@fbc-pr-cursor-blt: - shard-dg2: [SKIP][418] ([i915#1072] / [i915#9732]) -> [SKIP][419] [418]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg2-3/igt@kms_psr@fbc-pr-cursor-blt.html [419]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg2-8/igt@kms_psr@fbc-pr-cursor-blt.html * igt@kms_psr@fbc-psr2-primary-render: - shard-rkl: [SKIP][420] ([i915#1072] / [i915#14544] / [i915#9732]) -> [SKIP][421] ([i915#1072] / [i915#9732]) +2 other tests skip [420]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-6/igt@kms_psr@fbc-psr2-primary-render.html [421]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-7/igt@kms_psr@fbc-psr2-primary-render.html * igt@kms_psr@pr-sprite-blt: - shard-dg1: [SKIP][422] ([i915#1072] / [i915#4423] / [i915#9732]) -> [SKIP][423] ([i915#1072] / [i915#9732]) [422]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg1-17/igt@kms_psr@pr-sprite-blt.html [423]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg1-19/igt@kms_psr@pr-sprite-blt.html * igt@kms_psr@psr2-sprite-plane-onoff: - shard-dg1: [SKIP][424] ([i915#1072] / [i915#9732]) -> [SKIP][425] ([i915#1072] / [i915#4423] / [i915#9732]) [424]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg1-13/igt@kms_psr@psr2-sprite-plane-onoff.html [425]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg1-17/igt@kms_psr@psr2-sprite-plane-onoff.html * igt@kms_psr@psr2-suspend: - shard-rkl: [SKIP][426] ([i915#1072] / [i915#9732]) -> [SKIP][427] ([i915#1072] / [i915#14544] / [i915#9732]) +8 other tests skip [426]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-5/igt@kms_psr@psr2-suspend.html [427]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@kms_psr@psr2-suspend.html * igt@kms_rotation_crc@primary-4-tiled-reflect-x-0: - shard-dg1: [SKIP][428] ([i915#4423] / [i915#5289]) -> [SKIP][429] ([i915#5289]) [428]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-dg1-13/igt@kms_rotation_crc@primary-4-tiled-reflect-x-0.html [429]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-dg1-17/igt@kms_rotation_crc@primary-4-tiled-reflect-x-0.html * igt@kms_tiled_display@basic-test-pattern: - shard-rkl: [SKIP][430] ([i915#14544] / [i915#8623]) -> [SKIP][431] ([i915#8623]) [430]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-6/igt@kms_tiled_display@basic-test-pattern.html [431]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-7/igt@kms_tiled_display@basic-test-pattern.html * igt@kms_vrr@seamless-rr-switch-drrs: - shard-rkl: [SKIP][432] ([i915#14544] / [i915#9906]) -> [SKIP][433] ([i915#9906]) [432]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-6/igt@kms_vrr@seamless-rr-switch-drrs.html [433]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-4/igt@kms_vrr@seamless-rr-switch-drrs.html * igt@prime_vgem@basic-write: - shard-rkl: [SKIP][434] ([i915#3291] / [i915#3708]) -> [SKIP][435] ([i915#14544] / [i915#3291] / [i915#3708]) [434]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-5/igt@prime_vgem@basic-write.html [435]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@prime_vgem@basic-write.html * igt@prime_vgem@coherency-gtt: - shard-rkl: [SKIP][436] ([i915#14544] / [i915#3708]) -> [SKIP][437] ([i915#3708]) [436]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-6/igt@prime_vgem@coherency-gtt.html [437]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-7/igt@prime_vgem@coherency-gtt.html * igt@sriov_basic@bind-unbind-vf: - shard-rkl: [SKIP][438] ([i915#9917]) -> [SKIP][439] ([i915#14544] / [i915#9917]) [438]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_17721/shard-rkl-8/igt@sriov_basic@bind-unbind-vf.html [439]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/shard-rkl-6/igt@sriov_basic@bind-unbind-vf.html [i915#10055]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/10055 [i915#10307]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/10307 [i915#10433]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/10433 [i915#10647]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/10647 [i915#1072]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/1072 [i915#10826]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/10826 [i915#1099]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/1099 [i915#11078]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/11078 [i915#11151]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/11151 [i915#11520]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/11520 [i915#11920]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/11920 [i915#12061]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/12061 [i915#12169]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/12169 [i915#12276]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/12276 [i915#12313]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/12313 [i915#12343]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/12343 [i915#12358]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/12358 [i915#12392]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/12392 [i915#1257]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/1257 [i915#12713]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/12713 [i915#12745]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/12745 [i915#12755]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/12755 [i915#12805]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/12805 [i915#13027]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/13027 [i915#13046]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/13046 [i915#13049]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/13049 [i915#13331]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/13331 [i915#13356]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/13356 [i915#13398]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/13398 [i915#13522]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/13522 [i915#13566]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/13566 [i915#13691]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/13691 [i915#13707]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/13707 [i915#13748]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/13748 [i915#13749]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/13749 [i915#13958]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/13958 [i915#14073]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/14073 [i915#14098]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/14098 [i915#14118]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/14118 [i915#14152]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/14152 [i915#14259]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/14259 [i915#14412]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/14412 [i915#14544]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/14544 [i915#14702]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/14702 [i915#14712]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/14712 [i915#14809]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/14809 [i915#15073]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15073 [i915#15095]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15095 [i915#15102]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15102 [i915#15104]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15104 [i915#15131]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15131 [i915#15172]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15172 [i915#15243]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15243 [i915#15329]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15329 [i915#15330]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15330 [i915#15342]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15342 [i915#15351]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15351 [i915#15458]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15458 [i915#15459]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15459 [i915#15460]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15460 [i915#15479]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15479 [i915#15481]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15481 [i915#1825]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/1825 [i915#1839]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/1839 [i915#2065]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/2065 [i915#2346]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/2346 [i915#2527]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/2527 [i915#2575]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/2575 [i915#2587]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/2587 [i915#2658]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/2658 [i915#2672]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/2672 [i915#280]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/280 [i915#2856]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/2856 [i915#3023]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3023 [i915#3116]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3116 [i915#3281]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3281 [i915#3282]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3282 [i915#3291]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3291 [i915#3297]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3297 [i915#3299]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3299 [i915#3458]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3458 [i915#3539]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3539 [i915#3555]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3555 [i915#3637]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3637 [i915#3638]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3638 [i915#3708]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3708 [i915#3742]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3742 [i915#3828]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3828 [i915#3840]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3840 [i915#4077]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4077 [i915#4083]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4083 [i915#4103]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4103 [i915#4213]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4213 [i915#4215]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4215 [i915#4270]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4270 [i915#4349]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4349 [i915#4387]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4387 [i915#4423]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4423 [i915#4525]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4525 [i915#4538]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4538 [i915#4613]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4613 [i915#4817]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4817 [i915#4839]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4839 [i915#4852]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4852 [i915#4854]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4854 [i915#4860]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4860 [i915#5138]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/5138 [i915#5190]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/5190 [i915#5286]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/5286 [i915#5289]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/5289 [i915#5354]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/5354 [i915#5439]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/5439 [i915#5723]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/5723 [i915#6095]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/6095 [i915#6113]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/6113 [i915#6230]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/6230 [i915#6524]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/6524 [i915#6944]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/6944 [i915#6953]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/6953 [i915#7118]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/7118 [i915#7162]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/7162 [i915#7173]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/7173 [i915#7443]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/7443 [i915#7697]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/7697 [i915#7707]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/7707 [i915#7828]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/7828 [i915#7882]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/7882 [i915#8228]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8228 [i915#8399]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8399 [i915#8411]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8411 [i915#8428]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8428 [i915#8516]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8516 [i915#8555]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8555 [i915#8562]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8562 [i915#8623]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8623 [i915#8708]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8708 [i915#9295]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9295 [i915#9323]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9323 [i915#9337]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9337 [i915#9340]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9340 [i915#9423]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9423 [i915#9424]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9424 [i915#9531]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9531 [i915#9683]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9683 [i915#9685]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9685 [i915#9723]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9723 [i915#9732]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9732 [i915#9766]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9766 [i915#9906]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9906 [i915#9917]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9917 [i915#9934]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9934 Build changes ------------- * Linux: CI_DRM_17721 -> Patchwork_159315v1 CI-20190529: 20190529 CI_DRM_17721: 66200de68e2db77f251879ede0a001f64abcd60d @ git://anongit.freedesktop.org/gfx-ci/linux IGT_8674: f38f4d8e9c65aff45ac807e646d06e38bc3193a2 @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git Patchwork_159315v1: 66200de68e2db77f251879ede0a001f64abcd60d @ git://anongit.freedesktop.org/gfx-ci/linux piglit_4509: fdc5a4ca11124ab8413c7988896eec4c97336694 @ git://anongit.freedesktop.org/piglit == Logs == For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_159315v1/index.html [-- Attachment #2: Type: text/html, Size: 150026 bytes --] ^ permalink raw reply [flat|nested] 23+ messages in thread
end of thread, other threads:[~2025-12-23 7:46 UTC | newest] Thread overview: 23+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2025-12-19 20:37 [PATCH RFC v5 0/6] nova-core: Memory management initial patches Joel Fernandes 2025-12-19 20:37 ` Joel Fernandes 2025-12-19 20:38 ` [PATCH RFC v5 1/6] rust: clist: Add support to interface with C linked lists Joel Fernandes 2025-12-19 20:38 ` Joel Fernandes 2025-12-19 20:38 ` [PATCH RFC v5 2/6] gpu: Move DRM buddy allocator one level up Joel Fernandes 2025-12-19 20:38 ` Joel Fernandes 2025-12-19 20:38 ` [PATCH RFC v5 3/6] rust: gpu: Add GPU buddy allocator bindings Joel Fernandes 2025-12-19 20:38 ` Joel Fernandes 2025-12-20 20:39 ` kernel test robot 2025-12-23 7:45 ` kernel test robot 2025-12-19 20:38 ` [PATCH RFC v5 4/6] nova-core: mm: Add support to use PRAMIN windows to write to VRAM Joel Fernandes 2025-12-19 20:38 ` Joel Fernandes 2025-12-19 20:38 ` [PATCH RFC v5 5/6] docs: gpu: nova-core: Document the PRAMIN aperture mechanism Joel Fernandes 2025-12-19 20:38 ` Joel Fernandes 2025-12-19 20:38 ` [PATCH RFC v5 6/6] nova-core: Add PRAMIN aperture self-tests Joel Fernandes 2025-12-19 20:38 ` Joel Fernandes 2025-12-19 22:39 ` ✓ i915.CI.BAT: success for nova-core: Memory management initial patches Patchwork 2025-12-22 14:15 ` ✗ CI.checkpatch: warning " Patchwork 2025-12-22 14:17 ` ✓ CI.KUnit: success " Patchwork 2025-12-22 14:32 ` ✗ CI.checksparse: warning " Patchwork 2025-12-22 14:53 ` ✗ Xe.CI.BAT: failure " Patchwork 2025-12-22 15:50 ` ✓ Xe.CI.Full: success " Patchwork 2025-12-23 5:47 ` ✗ i915.CI.Full: failure " Patchwork
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.