FAILED: patch "[PATCH] drm/amdgpu: Allocate coredump ring buffers per ring" failed to apply to 7.1-stable tree
Subsystems (3)
[email protected]
maintainerThe patch below does not apply to the 7.1-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-7.1.y
git checkout FETCH_HEAD
git cherry-pick -x e40ff9840fa8a633d149f0242df10cae5e518062
# <resolve conflicts, build, test, etc.>
git commit -s
git send-email --to '<[email protected]>' --in-reply-to '2026082041-sporty-underdone-82eb@gregkh' --subject-prefix 'PATCH 7.1.y' 'HEAD^..'
Possible dependencies:
thanks,
greg k-h
------------------ original commit in Linus's tree ------------------
From e40ff9840fa8a633d149f0242df10cae5e518062 Mon Sep 17 00:00:00 2001
From: Lijo Lazar <[email protected]>
Date: Wed, 29 Jul 2026 16:23:58 +0530
Subject: [PATCH] drm/amdgpu: Allocate coredump ring buffers per ring
Allocate each ring buffer separately. A single allocation summing all ring sizes can exceed the page allocator's MAX_ORDER limit and fail; per-ring buffers stay small enough to satisfy. The existing allocation style doesn't capture any ring data if the huge allocation fails. Splitting into multiple allocations helps to capture as much data as possible for the core dump.
A failed ring is left with a NULL buffer and skipped when formatting.
drivers/gpu/drm/amd/amdgpu/amdgpu_dev_coredump.c +26 -24
@@ -342,7 +342,7 @@ amdgpu_devcoredump_format(char *buffer, size_t count, struct amdgpu_coredump_infstruct amdgpu_ip_block *ip_block;struct amdgpu_ring *ring;int ver, i, j; -u32 ring_idx, off; +u32 ring_idx;bool sizing_pass; sizing_pass = buffer ==NULL ;
@@ -442,7 +442,6 @@ amdgpu_devcoredump_format(char *buffer, size_t count, struct amdgpu_coredump_inffor (i =0 ; i < coredump->num_rings; i++) { ring_idx = coredump->rings[i].ring_index; ring = coredump->adev->rings[ring_idx]; - off = coredump->rings[i].offset;drm_printf (&p,"ring name: %s\n" , ring->name); drm_printf(&p, "Rptr: 0x%llx Wptr: 0x%llx RB mask: %x\n",
@@ -451,12 +450,18 @@ amdgpu_devcoredump_format(char *buffer, size_t count, struct amdgpu_coredump_inf ring->buf_mask);drm_printf (&p,"Ring size in dwords: %d\n" , ring->ring_size /4 ); + +if (!coredump->rings[i].ring_dw) { +drm_printf (&p,"Ring contents unavailable\n" ); +continue ; + } +drm_printf (&p,"Ring contents\n" );drm_printf (&p,"Offset \t Value\n" );for (j =0 ; j < ring->ring_size; j +=4 )drm_printf (&p,"0x%x \t 0x%x\n" , j, - coredump->rings_dw[off + j /4 ]); + coredump->rings[i].ring_dw[j /4 ]); } }
@@ -497,10 +502,12 @@ amdgpu_devcoredump_read(char *buffer, loff_t offset, size_t count,static void amdgpu_devcoredump_free (void *data) {struct amdgpu_coredump_info *coredump = data; +u32 i;kvfree (coredump->formatted); +for (i =0 ; i < coredump->num_rings; i++) +kvfree (coredump->rings[i].ring_dw);kvfree (coredump->rings); -kvfree (coredump->rings_dw);kvfree (data); }
@@ -542,9 +549,9 @@ void amdgpu_coredump(struct amdgpu_device *adev, bool skip_vram_check,struct amdgpu_coredump_info *coredump;size_t size =sizeof (*coredump);struct drm_sched_job *s_job; -u64 total_ring_size, ring_count; +u64 ring_count;struct amdgpu_ring *ring; -int i, off, idx; +int i, idx;/* No need to generate a new coredump if there's one in progress already. */ if (work_busy (&adev->coredump_work))
@@ -584,7 +591,6 @@ void amdgpu_coredump(struct amdgpu_device *adev, bool skip_vram_check,/* Dump ring content if memory allocation succeeds. */ ring_count =0 ; - total_ring_size =0 ;for (i =0 ; i < adev->num_rings; i++) { ring = adev->rings[i];
@@ -593,38 +599,34 @@ void amdgpu_coredump(struct amdgpu_device *adev, bool skip_vram_check, coredump->ring != ring)continue ; - total_ring_size += ring->ring_size; ring_count++; } -if (ring_count) { - coredump->rings_dw =kvzalloc (total_ring_size,GFP_NOWAIT ); +if (ring_count) coredump->rings =kvcalloc (ring_count,sizeof (struct amdgpu_coredump_ring ),GFP_NOWAIT ); - } -if (coredump->rings && coredump->rings_dw) { -for (i =0 , off =0 , idx =0 ; i < adev->num_rings && idx < ring_count; i++) { +if (coredump->rings) { +for (i =0 , idx =0 ; i < adev->num_rings && idx < ring_count; i++) { +struct amdgpu_coredump_ring *cdump_ring; + ring = adev->rings[i];if (atomic_read (&ring->fence_drv.last_seq) == ring->fence_drv.sync_seq && coredump->ring != ring)continue ; - coredump->rings[idx].ring_index = ring->idx; - coredump->rings[idx].rptr =amdgpu_ring_get_rptr (ring); - coredump->rings[idx].wptr =amdgpu_ring_get_wptr (ring); - coredump->rings[idx].offset = off; + cdump_ring = &coredump->rings[idx]; -memcpy (&coredump->rings_dw[off], ring->ring, ring->ring_size); - off += ring->ring_size /4 ; + cdump_ring->ring_dw =kvzalloc (ring->ring_size,GFP_NOWAIT ); +if (cdump_ring->ring_dw) +memcpy (cdump_ring->ring_dw, ring->ring, ring->ring_size); + + cdump_ring->ring_index = ring->idx; + cdump_ring->rptr =amdgpu_ring_get_rptr (ring); + cdump_ring->wptr =amdgpu_ring_get_wptr (ring); idx++; } coredump->num_rings = idx; - }else { -kvfree (coredump->rings_dw); -kvfree (coredump->rings); - coredump->rings_dw =NULL ; - coredump->rings =NULL ; } coredump->adev = adev;
drivers/gpu/drm/amd/amdgpu/amdgpu_dev_coredump.h +1 -2
@@ -34,8 +34,8 @@struct amdgpu_coredump_ring {u64 rptr;u64 wptr; +u32 *ring_dw;u32 ring_index; -u32 offset; };struct amdgpu_coredump_ib_info {
@@ -53,7 +53,6 @@ struct amdgpu_coredump_info {struct amdgpu_ring *ring;struct amdgpu_coredump_ring *rings; -u32 *rings_dw;u32 num_rings;/* Readable form of coredevdump, generate once to speed up
Sasha Levin
maintainerPATCH 1/2 drm/amdgpu: fix recursive ww_mutex acquire in amdgpu_devcoredump_format
From: Mikhail Gavrilov <[email protected]>
[ Upstream commit 7152b248dc3c8d5fa8629e99ed5655dd41b51562 ]
When dumping IB contents from a hung job, amdgpu_devcoredump_format() acquired the VM root PD's reservation via amdgpu_vm_lock_by_pasid() and then, for each IB, called amdgpu_bo_reserve() on the BO backing the IB. Both reservations are reservation_ww_class_mutex objects and neither used a ww_acquire_ctx, which trips lockdep:
WARNING: possible recursive locking detected
--------------------------------------------
kworker/u128:0 is trying to acquire lock:
ffff88838b16e1f0 (reservation_ww_class_mutex){+.+.}-{4:4},
at: amdgpu_devcoredump_format+0x1594/0x23f0 [amdgpu]
but task is already holding lock:
ffff8882f82681f0 (reservation_ww_class_mutex){+.+.}-{4:4},
at: amdgpu_devcoredump_format+0x1594/0x23f0 [amdgpu]
Possible unsafe locking scenario:
CPU0
----
lock(reservation_ww_class_mutex);
lock(reservation_ww_class_mutex); *** DEADLOCK ***
May be due to missing lock nesting notation
Workqueue: events_unbound amdgpu_devcoredump_deferred_work [amdgpu] Call Trace: __ww_mutex_lock.constprop.0 ww_mutex_lock amdgpu_bo_reserve amdgpu_devcoredump_format+0x1594 [amdgpu] amdgpu_devcoredump_deferred_work+0xea [amdgpu]
The two reservations are on different BOs in the captured trace, so the splat is a lockdep-correctness warning, not an observed deadlock. It becomes a real self-deadlock whenever the IB BO shares its dma_resv with the root PD (the always-valid case, see amdgpu_vm_is_bo_always_valid()):amdgpu_bo_reserve(abo) re-acquires the same ww_mutex without a ticket and blocks forever. With amdgpu.gpu_recovery=0 the timeout handler refires every ~2 s and each invocation produces this splat, drowning the kernel ring buffer.
Now that amdgpu_vm_lock_by_pasid() takes a drm_exec context, move the IB dumping into a separate helper that locks the root PD and every IB BO together in a single drm_exec ticket. DRM_EXEC_IGNORE_DUPLICATES handles IB BOs that share a dma_resv (e.g. always-valid BOs, or two IBs backed by the same BO). Every lock is now a top-level acquire under one ww_acquire_ctx, so the recursive ww_mutex condition is gone, and the per-IB amdgpu_bo_reserve()/amdgpu_bo_unref() dance -- including a BO refcount leak on the amdgpu_bo_reserve() failure path -- is removed.
Stable-dep-of: e40ff9840fa8 ("drm/amdgpu: Allocate coredump ring buffers per ring")
--- .../gpu/drm/amd/amdgpu/amdgpu_dev_coredump.c | 215 ++++++++++-------- drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c | 91 +++++--- drivers/gpu/drm/amd/amdgpu/amdgpu_vm.h | 2 +- 3 files changed, 184 insertions(+), 124 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_dev_coredump.c +126 -89
@@ -24,6 +24,7 @@#include <generated/utsrelease.h> #include <linux/devcoredump.h> +#include <drm/drm_exec.h> #include "amdgpu_dev_coredump.h" #include "atom.h"
@@ -207,23 +208,137 @@ static void amdgpu_devcoredump_fw_info(struct amdgpu_device *adev, } } +static void +amdgpu_devcoredump_print_ibs (struct drm_printer *p, +struct amdgpu_coredump_info *coredump, +bool sizing_pass) +{ +struct amdgpu_device *adev = coredump->adev; +struct amdgpu_bo_va_mapping *mapping; +struct amdgpu_bo *abo; +struct drm_exec exec; +struct amdgpu_vm *vm; +u32 *ib_content; +u64 va_start, offset; +u8 *kptr; +u32 off; +int r; + +/* +* On the sizing pass there is no VM to look up and no BO to lock; the +* size estimate doesn't depend on whether the IB BOs are reachable. +* Just emit the per-IB headers (the content is not written anywhere). +*/ +if (sizing_pass) { +for (int i =0 ; i < coredump->num_ibs; i++) { +drm_printf (p,"\nIB #%d 0x%llx %d dw\n" , i, + coredump->ibs[i].gpu_addr, + coredump->ibs[i].ib_size_dw); + } +return ; + } + +/* +* Lock the VM root PD and every IB BO together in a single drm_exec +* ticket. Reserving the IB BOs one by one while the root PD is held +* would be a recursive reservation_ww_class_mutex acquire without a +* ww_acquire_ctx, which trips lockdep and self-deadlocks for IB BOs +* that share their dma_resv with the root PD (always-valid BOs). +*/ +drm_exec_init (&exec,DRM_EXEC_IGNORE_DUPLICATES ,1 + coredump->num_ibs); + drm_exec_until_all_locked(&exec) { + vm =amdgpu_vm_lock_by_pasid (adev, coredump->pasid, &exec); +if (!vm) + goto unlock; + +for (int i =0 ; i < coredump->num_ibs; i++) { +u64 pfn = (coredump->ibs[i].gpu_addr & +AMDGPU_GMC_HOLE_MASK ) /AMDGPU_GPU_PAGE_SIZE ; + + mapping =amdgpu_vm_bo_lookup_mapping (vm, pfn); +if (!mapping) +continue ; + + abo = mapping->bo_va->base.bo; + r =drm_exec_lock_obj (&exec, &abo->tbo.base); +drm_exec_retry_on_contention (&exec); +if (r) + goto unlock; + } + } + +for (int i =0 ; i < coredump->num_ibs; i++) { +bool emit_content = false; + + ib_content =kvmalloc_array (coredump->ibs[i].ib_size_dw,4 , +GFP_KERNEL ); +if (!ib_content) +continue ; + + va_start = coredump->ibs[i].gpu_addr &AMDGPU_GMC_HOLE_MASK ; + mapping =amdgpu_vm_bo_lookup_mapping (vm, + va_start /AMDGPU_GPU_PAGE_SIZE ); +if (!mapping) + goto output_ib_content; + + abo = mapping->bo_va->base.bo; + offset = va_start - mapping->start *AMDGPU_GPU_PAGE_SIZE ; + +if (abo->flags &AMDGPU_GEM_CREATE_NO_CPU_ACCESS ) { +struct amdgpu_res_cursor cursor; + + off =0 ; + +if (abo->tbo.resource->mem_type !=TTM_PL_VRAM ) + goto output_ib_content; + +amdgpu_res_first (abo->tbo.resource, offset, + coredump->ibs[i].ib_size_dw *4 , &cursor); +while (cursor.remaining) { +amdgpu_device_mm_access (adev, cursor.start /4 , + &ib_content[off], cursor.size /4 , + false); + off += cursor.size; +amdgpu_res_next (&cursor, cursor.size); + } + emit_content = true; + }else { + r =ttm_bo_kmap (&abo->tbo,0 ,PFN_UP (abo->tbo.base.size), + &abo->kmap); +if (r) + goto output_ib_content; + + kptr =amdgpu_bo_kptr (abo); + kptr += offset; +memcpy (ib_content, kptr, coredump->ibs[i].ib_size_dw *4 ); + +amdgpu_bo_kunmap (abo); + emit_content = true; + } + +output_ib_content: +drm_printf (p,"\nIB #%d 0x%llx %d dw\n" , i, + coredump->ibs[i].gpu_addr, coredump->ibs[i].ib_size_dw); +if (emit_content) { +for (int j =0 ; j < coredump->ibs[i].ib_size_dw; j++) +drm_printf (p,"0x%08x\n" , ib_content[j]); + } +kvfree (ib_content); + } + +unlock: +drm_exec_fini (&exec); +} +static ssize_t amdgpu_devcoredump_format (char *buffer,size_t count,struct amdgpu_coredump_info *coredump) { -struct amdgpu_device *adev = coredump->adev;struct drm_printer p;struct drm_print_iterator iter;struct amdgpu_vm_fault_info *fault_info; -struct amdgpu_bo_va_mapping *mapping;struct amdgpu_ip_block *ip_block; -struct amdgpu_res_cursor cursor; -struct amdgpu_bo *abo, *root; -uint64_t va_start, offset;struct amdgpu_ring *ring; -struct amdgpu_vm *vm; -u32 *ib_content; -uint8_t *kptr; -int ver, i, j, r; +int ver, i, j;u32 ring_idx, off;bool sizing_pass;
@@ -347,86 +462,8 @@ amdgpu_devcoredump_format(char *buffer, size_t count, struct amdgpu_coredump_infelse if (coredump->reset_vram_lost)drm_printf (&p,"VRAM is lost due to GPU reset!\n" ); -if (coredump->num_ibs) { -/* Don't try to lookup the VM or map the BOs when calculating the -* size required to store the devcoredump. -*/ -if (sizing_pass) - vm =NULL ; -else - vm =amdgpu_vm_lock_by_pasid (adev, &root, coredump->pasid); - -for (int i =0 ; i < coredump->num_ibs && (sizing_pass || vm); i++) { - ib_content =kvmalloc_array (coredump->ibs[i].ib_size_dw,4 , -GFP_KERNEL ); -if (!ib_content) -continue ; - -/* vm=NULL can only happen when 'sizing_pass' is true. Skip to the -* drm_printf() calls (ib_content doesn't need to be initialized -* as its content won't be written anywhere). -*/ -if (!vm) - goto output_ib_content; - - va_start = coredump->ibs[i].gpu_addr &AMDGPU_GMC_HOLE_MASK ; - mapping =amdgpu_vm_bo_lookup_mapping (vm, va_start /AMDGPU_GPU_PAGE_SIZE ); -if (!mapping) - goto free_ib_content; - - offset = va_start - (mapping->start *AMDGPU_GPU_PAGE_SIZE ); - abo =amdgpu_bo_ref (mapping->bo_va->base.bo); - r =amdgpu_bo_reserve (abo, false); -if (r) - goto free_ib_content; - -if (abo->flags &AMDGPU_GEM_CREATE_NO_CPU_ACCESS ) { - off =0 ; - -if (abo->tbo.resource->mem_type !=TTM_PL_VRAM ) - goto unreserve_abo; - -amdgpu_res_first (abo->tbo.resource, offset, - coredump->ibs[i].ib_size_dw *4 , - &cursor); -while (cursor.remaining) { -amdgpu_device_mm_access (adev, cursor.start /4 , - &ib_content[off], cursor.size /4 , - false); - off += cursor.size; -amdgpu_res_next (&cursor, cursor.size); - } - }else { - r =ttm_bo_kmap (&abo->tbo,0 , -PFN_UP (abo->tbo.base.size), - &abo->kmap); -if (r) - goto unreserve_abo; - - kptr =amdgpu_bo_kptr (abo); - kptr += offset; -memcpy (ib_content, kptr, - coredump->ibs[i].ib_size_dw *4 ); - -amdgpu_bo_kunmap (abo); - } - -output_ib_content: -drm_printf (&p,"\nIB #%d 0x%llx %d dw\n" , - i, coredump->ibs[i].gpu_addr, coredump->ibs[i].ib_size_dw); -for (int j =0 ; j < coredump->ibs[i].ib_size_dw; j++) -drm_printf (&p,"0x%08x\n" , ib_content[j]); -unreserve_abo: -if (vm) -amdgpu_bo_unreserve (abo); -free_ib_content: -kvfree (ib_content); - } -if (vm) { -amdgpu_bo_unreserve (root); -amdgpu_bo_unref (&root); - } - } +if (coredump->num_ibs) +amdgpu_devcoredump_print_ibs (&p, coredump, sizing_pass);return count - iter.remain; }
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +57 -34
156 lines not on this page · raw message
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.h +1 -1
@@ -593,7 +593,7 @@ bool amdgpu_vm_handle_fault(struct amdgpu_device *adev, u32 pasid, bool write_fault);struct amdgpu_vm *amdgpu_vm_lock_by_pasid (struct amdgpu_device *adev, -struct amdgpu_bo **root,u32 pasid); +u32 pasid,struct drm_exec *exec);void amdgpu_vm_set_task_info (struct amdgpu_vm *vm);
Signature · 1 line
2.53.0
Sasha Levin
maintainerPATCH 2/2 drm/amdgpu: Allocate coredump ring buffers per ring
From: Lijo Lazar <[email protected]>
[ Upstream commit e40ff9840fa8a633d149f0242df10cae5e518062 ]
Allocate each ring buffer separately. A single allocation summing all ring sizes can exceed the page allocator's MAX_ORDER limit and fail; per-ring buffers stay small enough to satisfy. The existing allocation style doesn't capture any ring data if the huge allocation fails. Splitting into multiple allocations helps to capture as much data as possible for the core dump.
A failed ring is left with a NULL buffer and skipped when formatting.
--- .../gpu/drm/amd/amdgpu/amdgpu_dev_coredump.c | 50 ++++++++++--------- .../gpu/drm/amd/amdgpu/amdgpu_dev_coredump.h | 3 +- 2 files changed, 27 insertions(+), 26 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_dev_coredump.c +26 -24
@@ -339,7 +339,7 @@ amdgpu_devcoredump_format(char *buffer, size_t count, struct amdgpu_coredump_infstruct amdgpu_ip_block *ip_block;struct amdgpu_ring *ring;int ver, i, j; -u32 ring_idx, off; +u32 ring_idx;bool sizing_pass; sizing_pass = buffer ==NULL ;
@@ -439,7 +439,6 @@ amdgpu_devcoredump_format(char *buffer, size_t count, struct amdgpu_coredump_inffor (i =0 ; i < coredump->num_rings; i++) { ring_idx = coredump->rings[i].ring_index; ring = coredump->adev->rings[ring_idx]; - off = coredump->rings[i].offset;drm_printf (&p,"ring name: %s\n" , ring->name); drm_printf(&p, "Rptr: 0x%llx Wptr: 0x%llx RB mask: %x\n",
@@ -448,12 +447,18 @@ amdgpu_devcoredump_format(char *buffer, size_t count, struct amdgpu_coredump_inf ring->buf_mask);drm_printf (&p,"Ring size in dwords: %d\n" , ring->ring_size /4 ); + +if (!coredump->rings[i].ring_dw) { +drm_printf (&p,"Ring contents unavailable\n" ); +continue ; + } +drm_printf (&p,"Ring contents\n" );drm_printf (&p,"Offset \t Value\n" );for (j =0 ; j < ring->ring_size; j +=4 )drm_printf (&p,"0x%x \t 0x%x\n" , j, - coredump->rings_dw[off + j /4 ]); + coredump->rings[i].ring_dw[j /4 ]); } }
@@ -494,10 +499,12 @@ amdgpu_devcoredump_read(char *buffer, loff_t offset, size_t count,static void amdgpu_devcoredump_free (void *data) {struct amdgpu_coredump_info *coredump = data; +u32 i;kvfree (coredump->formatted); +for (i =0 ; i < coredump->num_rings; i++) +kvfree (coredump->rings[i].ring_dw);kvfree (coredump->rings); -kvfree (coredump->rings_dw);kvfree (data); }
@@ -539,9 +546,9 @@ void amdgpu_coredump(struct amdgpu_device *adev, bool skip_vram_check,struct amdgpu_coredump_info *coredump;size_t size =sizeof (*coredump);struct drm_sched_job *s_job; -u64 total_ring_size, ring_count; +u64 ring_count;struct amdgpu_ring *ring; -int i, off, idx; +int i, idx;/* No need to generate a new coredump if there's one in progress already. */ if (work_busy (&adev->coredump_work))
@@ -581,7 +588,6 @@ void amdgpu_coredump(struct amdgpu_device *adev, bool skip_vram_check,/* Dump ring content if memory allocation succeeds. */ ring_count =0 ; - total_ring_size =0 ;for (i =0 ; i < adev->num_rings; i++) { ring = adev->rings[i];
@@ -590,38 +596,34 @@ void amdgpu_coredump(struct amdgpu_device *adev, bool skip_vram_check, coredump->ring != ring)continue ; - total_ring_size += ring->ring_size; ring_count++; } -if (ring_count) { - coredump->rings_dw =kvzalloc (total_ring_size,GFP_NOWAIT ); +if (ring_count) coredump->rings =kvcalloc (ring_count,sizeof (struct amdgpu_coredump_ring ),GFP_NOWAIT ); - } -if (coredump->rings && coredump->rings_dw) { -for (i =0 , off =0 , idx =0 ; i < adev->num_rings && idx < ring_count; i++) { +if (coredump->rings) { +for (i =0 , idx =0 ; i < adev->num_rings && idx < ring_count; i++) { +struct amdgpu_coredump_ring *cdump_ring; + ring = adev->rings[i];if (atomic_read (&ring->fence_drv.last_seq) == ring->fence_drv.sync_seq && coredump->ring != ring)continue ; - coredump->rings[idx].ring_index = ring->idx; - coredump->rings[idx].rptr =amdgpu_ring_get_rptr (ring); - coredump->rings[idx].wptr =amdgpu_ring_get_wptr (ring); - coredump->rings[idx].offset = off; + cdump_ring = &coredump->rings[idx]; + + cdump_ring->ring_dw =kvzalloc (ring->ring_size,GFP_NOWAIT ); +if (cdump_ring->ring_dw) +memcpy (cdump_ring->ring_dw, ring->ring, ring->ring_size); -memcpy (&coredump->rings_dw[off], ring->ring, ring->ring_size); - off += ring->ring_size /4 ; + cdump_ring->ring_index = ring->idx; + cdump_ring->rptr =amdgpu_ring_get_rptr (ring); + cdump_ring->wptr =amdgpu_ring_get_wptr (ring); idx++; } coredump->num_rings = idx; - }else { -kvfree (coredump->rings_dw); -kvfree (coredump->rings); - coredump->rings_dw =NULL ; - coredump->rings =NULL ; } coredump->adev = adev;
drivers/gpu/drm/amd/amdgpu/amdgpu_dev_coredump.h +1 -2
@@ -34,8 +34,8 @@struct amdgpu_coredump_ring {u64 rptr;u64 wptr; +u32 *ring_dw;u32 ring_index; -u32 offset; };struct amdgpu_coredump_ib_info {
@@ -53,7 +53,6 @@ struct amdgpu_coredump_info {struct amdgpu_ring *ring;struct amdgpu_coredump_ring *rings; -u32 *rings_dw;u32 num_rings;/* Readable form of coredevdump, generate once to speed up
Signature · 1 line
2.53.0