FAILED: patch "[PATCH] drm/xe/vm: Fix BO prefetch with CONSULT_MEM_ADVISE_PREF_LOC" failed to apply to 6.18-stable tree
Subsystems (3)
[email protected]
maintainerThe patch below does not apply to the 6.18-stable tree.
If someone wants it applied there, or to any other stable or longterm tree, then please email the backport, including the original git commit id to <[email protected]>.
To reproduce the conflict and resubmit, you may use the following commands:
git fetch https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/ linux-6.18.y
git checkout FETCH_HEAD
git cherry-pick -x 7bc597ce74bab4153b2009c92eccf889e9d74044
# <resolve conflicts, build, test, etc.>
git commit -s
git send-email --to '<[email protected]>' --in-reply-to '2026072936-hummus-emblem-55be@gregkh' --subject-prefix 'PATCH 6.18.y' 'HEAD^..'
Possible dependencies:
thanks,
greg k-h
------------------ original commit in Linus's tree ------------------
From 7bc597ce74bab4153b2009c92eccf889e9d74044 Mon Sep 17 00:00:00 2001
From: Himal Prasad Ghimiray <[email protected]>
Date: Wed, 24 Jun 2026 23:19:44 +0530
Subject: [PATCH] drm/xe/vm: Fix BO prefetch with CONSULT_MEM_ADVISE_PREF_LOC
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
When prefetch region is DRM_XE_CONSULT_MEM_ADVISE_PREF_LOC for a BO VMA, the code used it as an index into region_to_mem_type[], causing an out-of-bounds access since the value is -1.
Resolve the preferred location for BO VMAs directly: local VRAM on dGFX (using the BO's tile placement) or system memory on iGPU.
Discovered using AI-assisted static analysis confirmed by Intel Product Security.
v2:
-Fix null dereference
drivers/gpu/drm/xe/xe_vm.c +20 -5
@@ -3255,11 +3255,26 @@ static int op_lock_and_prep(struct drm_exec *exec, struct xe_vm *vm, .request_decompress = false, .check_purged = true, }); -if (!err && !xe_vma_has_no_bo (vma)) - err =xe_bo_migrate (xe_vma_bo (vma), - region_to_mem_type[region], -NULL , - exec); +if (!err && !xe_vma_has_no_bo (vma)) { +struct xe_bo *bo =xe_vma_bo (vma); +u32 mem_type; + +if (region ==DRM_XE_CONSULT_MEM_ADVISE_PREF_LOC ) { +unsigned int i; + + mem_type =XE_PL_TT ; +for (i =0 ; i < bo->placement.num_placement; i++) { +if (mem_type_is_vram (bo->placements[i].mem_type)) { + mem_type = bo->placements[i].mem_type; +break ; + } + } + }else { + mem_type = region_to_mem_type[region]; + } + + err =xe_bo_migrate (bo, mem_type,NULL , exec); + }break ; }default :
Sasha Levin
maintainerPATCH 1/5 drm/xe/pat: Add helper to query compression enable status
From: Xin Wang <[email protected]>
[ Upstream commit b2bce0e551e89af37cfcb1b1158d80f369eeea3f ]
Add xe_pat_index_get_comp_en() helper function to check whether compression is enabled for a given PAT index by extracting the XE2_COMP_EN bit from the PAT table entry.
There are no current users, however there are multiple in-flight series which will all use this helper.
Stable-dep-of: 7bc597ce74ba ("drm/xe/vm: Fix BO prefetch with CONSULT_MEM_ADVISE_PREF_LOC")
--- drivers/gpu/drm/xe/xe_pat.c | 6 ++++++ drivers/gpu/drm/xe/xe_pat.h | 10 ++++++++++ 2 files changed, 16 insertions(+)
drivers/gpu/drm/xe/xe_pat.c +6 -0
@@ -160,6 +160,12 @@ u16 xe_pat_index_get_coh_mode(struct xe_device *xe, u16 pat_index)return xe->pat.table[pat_index].coh_mode; } +bool xe_pat_index_get_comp_en (struct xe_device *xe,u16 pat_index) +{ +WARN_ON (pat_index >= xe->pat.n_entries); +return !!(xe->pat.table[pat_index].value &XE2_COMP_EN ); +} +static void program_pat (struct xe_gt *gt,const struct xe_pat_table_entry table[],int n_entries) {
drivers/gpu/drm/xe/xe_pat.h +10 -0
@@ -58,4 +58,14 @@ void xe_pat_dump(struct xe_gt *gt, struct drm_printer *p);*/ u16 xe_pat_index_get_coh_mode (struct xe_device *xe,u16 pat_index); +/** +* xe_pat_index_get_comp_en - Extract the compression enable flag for +* the given pat_index. +* @xe: xe device +* @pat_index: The pat_index to query +* +* Return: true if compression is enabled for this pat_index, false otherwise. +*/ +bool xe_pat_index_get_comp_en (struct xe_device *xe,u16 pat_index); +#endif
Signature · 1 line
2.53.0
Sasha Levin
maintainerPATCH 2/5 drm/xe: add xe_migrate_resolve wrapper and is_vram_resolve support
From: Nitin Gote <[email protected]>
[ Upstream commit be97fd06458d66a53aefb6d9429db0df734c81c0 ]
Introduce an internal __xe_migrate_copy(..., is_vram_resolve) path and expose a small wrapper xe_migrate_resolve() that calls it with is_vram_resolve=true.
For resolve/decompression operations we must ensure the copy code uses the compression PAT index when appropriate; this change centralizes that behavior and allows callers to schedule a resolve (decompress) operation via the migrate API.
v3: Fix kernel-doc warnings
v2: (Matt)
- Simplify xe_migrate_resolve(), use single BO/resource; remove copy_only_ccs argument as it's always false.
Stable-dep-of: 7bc597ce74ba ("drm/xe/vm: Fix BO prefetch with CONSULT_MEM_ADVISE_PREF_LOC")
--- drivers/gpu/drm/xe/xe_migrate.c | 90 +++++++++++++++++++++++---------- drivers/gpu/drm/xe/xe_migrate.h | 4 ++ 2 files changed, 67 insertions(+), 27 deletions(-)
drivers/gpu/drm/xe/xe_migrate.c +63 -27
@@ -764,31 +764,13 @@ static u32 xe_migrate_ccs_copy(struct xe_migrate *m,return flush_flags; } -/** -* xe_migrate_copy() - Copy content of TTM resources. -* @m: The migration context. -* @src_bo: The buffer object @src is currently bound to. -* @dst_bo: If copying between resources created for the same bo, set this to -* the same value as @src_bo. If copying between buffer objects, set it to -* the buffer object @dst is currently bound to. -* @src: The source TTM resource. -* @dst: The dst TTM resource. -* @copy_only_ccs: If true copy only CCS metadata -* -* Copies the contents of @src to @dst: On flat CCS devices, -* the CCS metadata is copied as well if needed, or if not present, -* the CCS metadata of @dst is cleared for security reasons. -* -* Return: Pointer to a dma_fence representing the last copy batch, or -* an error pointer on failure. If there is a failure, any copy operation -* started by the function call has been synced. -*/ -struct dma_fence *xe_migrate_copy (struct xe_migrate *m, -struct xe_bo *src_bo, -struct xe_bo *dst_bo, -struct ttm_resource *src, -struct ttm_resource *dst, -bool copy_only_ccs) +static struct dma_fence *__xe_migrate_copy (struct xe_migrate *m, +struct xe_bo *src_bo, +struct xe_bo *dst_bo, +struct ttm_resource *src, +struct ttm_resource *dst, +bool copy_only_ccs, +bool is_vram_resolve) {struct xe_gt *gt = m->tile->primary_gt;struct xe_device *xe =gt_to_xe (gt);
@@ -809,8 +791,15 @@ struct dma_fence *xe_migrate_copy(struct xe_migrate *m,bool copy_ccs =xe_device_has_flat_ccs (xe) &&xe_bo_needs_ccs_pages (src_bo) &&xe_bo_needs_ccs_pages (dst_bo);bool copy_system_ccs = copy_ccs && (!src_is_vram || !dst_is_vram); -bool use_comp_pat = type_device &&xe_device_has_flat_ccs (xe) && -GRAPHICS_VER (xe) >=20 && src_is_vram && !dst_is_vram; + +/* +* For decompression operation, always use the compression PAT index. +* Otherwise, only use the compression PAT index for device memory +* when copying from VRAM to system memory. +*/ +bool use_comp_pat = is_vram_resolve || (type_device && +xe_device_has_flat_ccs (xe) && +GRAPHICS_VER (xe) >=20 && src_is_vram && !dst_is_vram);/* Copying CCS between two different BOs is not supported yet. */ if (XE_WARN_ON (copy_ccs && src_bo != dst_bo))
@@ -969,6 +958,53 @@ struct dma_fence *xe_migrate_copy(struct xe_migrate *m,return fence; } +/** +* xe_migrate_copy() - Copy content of TTM resources. +* @m: The migration context. +* @src_bo: The buffer object @src is currently bound to. +* @dst_bo: If copying between resources created for the same bo, set this to +* the same value as @src_bo. If copying between buffer objects, set it to +* the buffer object @dst is currently bound to. +* @src: The source TTM resource. +* @dst: The dst TTM resource. +* @copy_only_ccs: If true copy only CCS metadata +* +* Copies the contents of @src to @dst: On flat CCS devices, +* the CCS metadata is copied as well if needed, or if not present, +* the CCS metadata of @dst is cleared for security reasons. +* +* Return: Pointer to a dma_fence representing the last copy batch, or +* an error pointer on failure. If there is a failure, any copy operation +* started by the function call has been synced. +*/ +struct dma_fence *xe_migrate_copy (struct xe_migrate *m, +struct xe_bo *src_bo, +struct xe_bo *dst_bo, +struct ttm_resource *src, +struct ttm_resource *dst, +bool copy_only_ccs) +{ +return __xe_migrate_copy (m, src_bo, dst_bo, src, dst, copy_only_ccs, false); +} + +/** +* xe_migrate_resolve() - Resolve and decompress a buffer object if required. +* @m: The migrate context +* @bo: The buffer object to resolve +* @res: The reservation object +* +* Wrapper around __xe_migrate_copy() with is_vram_resolve set to true +* to trigger decompression if needed. +* +* Return: A dma_fence that signals on completion, or an ERR_PTR on failure. +*/ +struct dma_fence *xe_migrate_resolve (struct xe_migrate *m, +struct xe_bo *bo, +struct ttm_resource *res) +{ +return __xe_migrate_copy (m, bo, bo, res, res, false, true); +} +/** * xe_migrate_lrc() - Get the LRC from migrate context. * @migrate: Migrate context.
drivers/gpu/drm/xe/xe_migrate.h +4 -0
@@ -127,6 +127,10 @@ struct dma_fence *xe_migrate_copy(struct xe_migrate *m,struct ttm_resource *dst, bool copy_only_ccs); +struct dma_fence *xe_migrate_resolve (struct xe_migrate *m, +struct xe_bo *bo, +struct ttm_resource *res); +int xe_migrate_ccs_rw_copy (struct xe_tile *tile,struct xe_exec_queue *q,struct xe_bo *src_bo,enum xe_sriov_vf_ccs_rw_ctxs read_write);
Signature · 1 line
2.53.0
Sasha Levin
maintainerPATCH 3/5 drm/xe/bo: Add purgeable bo state tracking and field madv to xe_bo
In reply to Sasha LevinFrom: Arvind Yadav <[email protected]>
[ Upstream commit b67427f939ccf038a658badb02dd948c7b516248 ]
Add infrastructure for tracking purgeable state of buffer objects. This includes:
Introduce enum xe_madv_purgeable_state with three states:
- XE_MADV_PURGEABLE_WILLNEED (0): BO is needed and should not be purged. This is the default state for all BOs.
- XE_MADV_PURGEABLE_DONTNEED (1): BO is not currently needed and can be purged by the kernel under memory pressure to reclaim resources. Only non-shared BOs can be marked as DONTNEED.
- XE_MADV_PURGEABLE_PURGED (2): BO has been purged by the kernel. Accessing a purged BO results in error. Follows i915 semantics where once purged, the BO remains permanently invalid ("once purged, always purged").
Add madv_purgeable field to struct xe_bo for state tracking
of purgeable state across concurrent access paths
Stable-dep-of: 7bc597ce74ba ("drm/xe/vm: Fix BO prefetch with CONSULT_MEM_ADVISE_PREF_LOC")
--- drivers/gpu/drm/xe/xe_bo.h | 56 ++++++++++++++++++++++++++++++++ drivers/gpu/drm/xe/xe_bo_types.h | 6 ++++ 2 files changed, 62 insertions(+)
drivers/gpu/drm/xe/xe_bo.h +56 -0
@@ -84,6 +84,28 @@#define XE_PCI_BARRIER_MMAP_OFFSET (0x50 << XE_PTE_SHIFT) +/** +* enum xe_madv_purgeable_state - Buffer object purgeable state enumeration +* +* This enum defines the possible purgeable states for a buffer object, +* allowing userspace to provide memory usage hints to the kernel for +* better memory management under pressure. +* +* @XE_MADV_PURGEABLE_WILLNEED: The buffer object is needed and should not be purged. +* This is the default state. +* @XE_MADV_PURGEABLE_DONTNEED: The buffer object is not currently needed and can be +* purged by the kernel under memory pressure. +* @XE_MADV_PURGEABLE_PURGED: The buffer object has been purged by the kernel. +* +* Accessing a purged buffer will result in an error. Per i915 semantics, +* once purged, a BO remains permanently invalid and must be destroyed and recreated. +*/ +enum xe_madv_purgeable_state { +XE_MADV_PURGEABLE_WILLNEED , +XE_MADV_PURGEABLE_DONTNEED , +XE_MADV_PURGEABLE_PURGED , +}; +struct sg_table ;struct xe_bo *xe_bo_alloc (void );
@@ -212,6 +234,40 @@ static inline bool xe_bo_is_protected(const struct xe_bo *bo)return bo->pxp_key_instance; } +/** +* xe_bo_is_purged() - Check if buffer object has been purged +* @bo: The buffer object to check +* +* Checks if the buffer object's backing store has been discarded by the +* kernel due to memory pressure after being marked as purgeable (DONTNEED). +* Once purged, the BO cannot be restored and any attempt to use it will fail. +* +* Context: Caller must hold the BO's dma-resv lock +* Return: true if the BO has been purged, false otherwise +*/ +static inline bool xe_bo_is_purged (struct xe_bo *bo) +{ +xe_bo_assert_held (bo); +return bo->madv_purgeable ==XE_MADV_PURGEABLE_PURGED ; +} + +/** +* xe_bo_madv_is_dontneed() - Check if BO is marked as DONTNEED +* @bo: The buffer object to check +* +* Checks if userspace has marked this BO as DONTNEED (i.e., its contents +* are not currently needed and can be discarded under memory pressure). +* This is used internally to decide whether a BO is eligible for purging. +* +* Context: Caller must hold the BO's dma-resv lock +* Return: true if the BO is marked DONTNEED, false otherwise +*/ +static inline bool xe_bo_madv_is_dontneed (struct xe_bo *bo) +{ +xe_bo_assert_held (bo); +return bo->madv_purgeable ==XE_MADV_PURGEABLE_DONTNEED ; +} +static inline void xe_bo_unpin_map_no_vm (struct xe_bo *bo) {if (likely (bo)) {
drivers/gpu/drm/xe/xe_bo_types.h +6 -0
@@ -108,6 +108,12 @@ struct xe_bo {* from default */ u64 min_align; + +/** +* @madv_purgeable: user space advise on BO purgeability, protected +* by BO's dma-resv lock. +*/ + u32 madv_purgeable; };#endif
Signature · 1 line
2.53.0
Sasha Levin
maintainerPATCH 4/5 drm/xe/vm: Prevent binding of purged buffer objects
In reply to Sasha LevinFrom: Arvind Yadav <[email protected]>
[ Upstream commit 4f44961eab8474a47de419113e1d46095f9b44e0 ]
Add purge checking to vma_lock_and_validate() to block new mapping operations on purged BOs while allowing cleanup operations to proceed.
Purged BOs have their backing pages freed by the kernel. New mapping operations (MAP, PREFETCH, REMAP) must be rejected with -EINVAL to prevent GPU access to invalid memory. Cleanup operations (UNMAP) must be allowed so applications can release resources after detecting purge via the retained field.
REMAP operations require mixed handling - reject new prev/next VMAs if the BO is purged, but allow the unmap portion to proceed for cleanup.
The check_purged flag in struct xe_vma_lock_and_validate_flags distinguishes between these cases: true for new mappings (must reject), false for cleanup (allow).
Stable-dep-of: 7bc597ce74ba ("drm/xe/vm: Fix BO prefetch with CONSULT_MEM_ADVISE_PREF_LOC")
--- drivers/gpu/drm/xe/xe_vm.c | 79 ++++++++++++++++++++++++++++++++------ 1 file changed, 68 insertions(+), 11 deletions(-)
drivers/gpu/drm/xe/xe_vm.c +68 -11
@@ -2834,8 +2834,22 @@ static void vm_bind_ioctl_ops_unwind(struct xe_vm *vm, } } +/** +* struct xe_vma_lock_and_validate_flags - Flags for vma_lock_and_validate() +* @res_evict: Allow evicting resources during validation +* @validate: Perform BO validation +* @request_decompress: Request BO decompression +* @check_purged: Reject operation if BO is purged +*/ +struct xe_vma_lock_and_validate_flags { +u32 res_evict :1 ; +u32 validate :1 ; +u32 request_decompress :1 ; +u32 check_purged :1 ; +}; +static int vma_lock_and_validate (struct drm_exec *exec,struct xe_vma *vma, -bool res_evict,bool validate) +struct xe_vma_lock_and_validate_flags flags) {struct xe_bo *bo =xe_vma_bo (vma);struct xe_vm *vm =xe_vma_vm (vma);
@@ -2844,10 +2858,19 @@ static int vma_lock_and_validate(struct drm_exec *exec, struct xe_vma *vma,if (bo) {if (!bo->vm) err =drm_exec_lock_obj (exec, &bo->ttm.base); -if (!err && validate) + +/* Reject new mappings to DONTNEED/purged BOs; allow cleanup operations */ +if (!err && flags.check_purged) { +if (xe_bo_madv_is_dontneed (bo)) + err = -EBUSY ;/* BO marked purgeable */ +else if (xe_bo_is_purged (bo)) + err = -EINVAL ;/* BO already purged */ + } + +if (!err && flags.validate) err =xe_bo_validate (bo, vm, !xe_vm_in_preempt_fence_mode (vm) && - res_evict, exec); + flags.res_evict, exec); }return err;
@@ -2933,9 +2956,13 @@ static int op_lock_and_prep(struct drm_exec *exec, struct xe_vm *vm,case DRM_GPUVA_OP_MAP :if (!op->map.invalidate_on_bind) err =vma_lock_and_validate (exec, op->map.vma, - res_evict, - !xe_vm_in_fault_mode (vm) || - op->map.immediate); + (struct xe_vma_lock_and_validate_flags ) { + .res_evict = res_evict, + .validate = !xe_vm_in_fault_mode (vm) || + op->map.immediate, + .request_decompress = false, + .check_purged = true, + });break ;case DRM_GPUVA_OP_REMAP : err =check_ufence (gpuva_to_vma (op->base.remap.unmap->va));
@@ -2944,13 +2971,28 @@ static int op_lock_and_prep(struct drm_exec *exec, struct xe_vm *vm, err =vma_lock_and_validate (exec,gpuva_to_vma (op->base.remap.unmap->va), - res_evict, false); + (struct xe_vma_lock_and_validate_flags ) { + .res_evict = res_evict, + .validate = false, + .request_decompress = false, + .check_purged = false, + });if (!err && op->remap.prev) err =vma_lock_and_validate (exec, op->remap.prev, - res_evict, true); + (struct xe_vma_lock_and_validate_flags ) { + .res_evict = res_evict, + .validate = true, + .request_decompress = false, + .check_purged = true, + });if (!err && op->remap.next) err =vma_lock_and_validate (exec, op->remap.next, - res_evict, true); + (struct xe_vma_lock_and_validate_flags ) { + .res_evict = res_evict, + .validate = true, + .request_decompress = false, + .check_purged = true, + });break ;case DRM_GPUVA_OP_UNMAP : err =check_ufence (gpuva_to_vma (op->base.unmap.va));
@@ -2959,7 +3001,12 @@ static int op_lock_and_prep(struct drm_exec *exec, struct xe_vm *vm, err =vma_lock_and_validate (exec,gpuva_to_vma (op->base.unmap.va), - res_evict, false); + (struct xe_vma_lock_and_validate_flags ) { + .res_evict = res_evict, + .validate = false, + .request_decompress = false, + .check_purged = false, + });break ;case DRM_GPUVA_OP_PREFETCH : {
@@ -2972,9 +3019,19 @@ static int op_lock_and_prep(struct drm_exec *exec, struct xe_vm *vm, region <= ARRAY_SIZE(region_to_mem_type)); } +/* +* Prefetch attempts to migrate BO's backing store without +* repopulating it first. Purged BOs have no backing store +* to migrate, so reject the operation. +*/ err =vma_lock_and_validate (exec,gpuva_to_vma (op->base.prefetch.va), - res_evict, false); + (struct xe_vma_lock_and_validate_flags ) { + .res_evict = res_evict, + .validate = false, + .request_decompress = false, + .check_purged = true, + });if (!err && !xe_vma_has_no_bo (vma)) err = xe_bo_migrate(xe_vma_bo(vma), region_to_mem_type[region],
Signature · 1 line
2.53.0
Sasha Levin
maintainerPATCH 5/5 drm/xe/vm: Fix BO prefetch with CONSULT_MEM_ADVISE_PREF_LOC
In reply to Sasha LevinFrom: Himal Prasad Ghimiray <[email protected]>
[ Upstream commit 7bc597ce74bab4153b2009c92eccf889e9d74044 ]
When prefetch region is DRM_XE_CONSULT_MEM_ADVISE_PREF_LOC for a BO VMA, the code used it as an index into region_to_mem_type[], causing an out-of-bounds access since the value is -1.
Resolve the preferred location for BO VMAs directly: local VRAM on dGFX (using the BO's tile placement) or system memory on iGPU.
Discovered using AI-assisted static analysis confirmed by Intel Product Security.
v2:
-Fix null dereference
--- drivers/gpu/drm/xe/xe_vm.c | 25 ++++++++++++++++++++----- 1 file changed, 20 insertions(+), 5 deletions(-)
drivers/gpu/drm/xe/xe_vm.c +20 -5
@@ -3032,11 +3032,26 @@ static int op_lock_and_prep(struct drm_exec *exec, struct xe_vm *vm, .request_decompress = false, .check_purged = true, }); -if (!err && !xe_vma_has_no_bo (vma)) - err =xe_bo_migrate (xe_vma_bo (vma), - region_to_mem_type[region], -NULL , - exec); +if (!err && !xe_vma_has_no_bo (vma)) { +struct xe_bo *bo =xe_vma_bo (vma); +u32 mem_type; + +if (region ==DRM_XE_CONSULT_MEM_ADVISE_PREF_LOC ) { +unsigned int i; + + mem_type =XE_PL_TT ; +for (i =0 ; i < bo->placement.num_placement; i++) { +if (mem_type_is_vram (bo->placements[i].mem_type)) { + mem_type = bo->placements[i].mem_type; +break ; + } + } + }else { + mem_type = region_to_mem_type[region]; + } + + err =xe_bo_migrate (bo, mem_type,NULL , exec); + }break ; }default :
Signature · 1 line
2.53.0