drm/amdgpu: add user queue reset source
Subsystems (2)
PATCH v3 1/9 drm/amdgpu: add user queue reset source
From: Alex Deucher <[email protected]>
Track resets from user queues.
--- drivers/gpu/drm/amd/amdgpu/amdgpu_reset.c | 3 +++ drivers/gpu/drm/amd/amdgpu/amdgpu_reset.h | 1 + 2 files changed, 4 insertions(+)
drivers/gpu/drm/amd/amdgpu/amdgpu_reset.c +3 -0
@@ -340,6 +340,9 @@ void amdgpu_reset_get_desc(struct amdgpu_reset_context *rst_ctxt, char *buf,case AMDGPU_RESET_SRC_USER :strscpy (buf,"user trigger" , len);break ; +case AMDGPU_RESET_SRC_USERQ : +strscpy (buf,"user queue trigger" , len); +break ;default :strscpy (buf,"unknown" , len); }
drivers/gpu/drm/amd/amdgpu/amdgpu_reset.h +1 -0
@@ -43,6 +43,7 @@ enum AMDGPU_RESET_SRCS {AMDGPU_RESET_SRC_MES ,AMDGPU_RESET_SRC_HWS ,AMDGPU_RESET_SRC_USER , + AMDGPU_RESET_SRC_USERQ, }; struct amdgpu_reset_context {
Signature · 1 line
2.49.0
PATCH v3 2/9 drm/amdgpu/mes: add front end for detect and reset hung queue
From: Alex Deucher <[email protected]>
Helper function to detect and reset hung queues. MES will return an array of doorbell indices of which queues are hung and were optionally reset.
--- drivers/gpu/drm/amd/amdgpu/amdgpu_mes.c | 62 +++++++++++++++++++++++++ drivers/gpu/drm/amd/amdgpu/amdgpu_mes.h | 19 ++++++++ 2 files changed, 81 insertions(+)
drivers/gpu/drm/amd/amdgpu/amdgpu_mes.c +62 -0
@@ -191,6 +191,20 @@ int amdgpu_mes_init(struct amdgpu_device *adev)if (r) goto error_doorbell; +if (adev->mes.hung_queue_db_array_size) { + r =amdgpu_bo_create_kernel (adev, + adev->mes.hung_queue_db_array_size *sizeof (u32), +PAGE_SIZE , +AMDGPU_GEM_DOMAIN_GTT , + &adev->mes.hung_queue_db_array_gpu_obj, + &adev->mes.hung_queue_db_array_gpu_addr, + &adev->mes.hung_queue_db_array_cpu_addr); +if (r) { +dev_warn (adev->dev,"failed to create MES hung db array buffer (%d)" , r); + goto error_doorbell; + } + } +return 0 ; error_doorbell:
@@ -216,6 +230,10 @@ void amdgpu_mes_fini(struct amdgpu_device *adev) {int i; +amdgpu_bo_free_kernel (&adev->mes.hung_queue_db_array_gpu_obj, + &adev->mes.hung_queue_db_array_gpu_addr, + &adev->mes.hung_queue_db_array_cpu_addr); +amdgpu_bo_free_kernel (&adev->mes.event_log_gpu_obj, &adev->mes.event_log_gpu_addr, &adev->mes.event_log_cpu_addr);
@@ -366,6 +384,50 @@ int amdgpu_mes_reset_legacy_queue(struct amdgpu_device *adev,return r; } +int amdgpu_mes_get_hung_queue_db_array_size (struct amdgpu_device *adev) +{ +return adev->mes.hung_queue_db_array_size; +} + +int amdgpu_mes_detect_and_reset_hung_queues (struct amdgpu_device *adev, +int queue_type, +bool detect_only, +unsigned int *hung_db_num, +u32 *hung_db_array) + +{ +struct mes_detect_and_reset_queue_input input; +u32 *db_array = adev->mes.hung_queue_db_array_cpu_addr; +int r, i; + +if (!hung_db_num || !hung_db_array) +return -EINVAL ; + +if ((queue_type !=AMDGPU_RING_TYPE_GFX ) && + (queue_type !=AMDGPU_RING_TYPE_COMPUTE ) && + (queue_type !=AMDGPU_RING_TYPE_SDMA )) +return -EINVAL ; + + input.queue_type = queue_type; + input.detect_only = detect_only; + + r = adev->mes.funcs->detect_and_reset_hung_queues (&adev->mes, + &input); +if (r) { +dev_err (adev->dev,"failed to detect and reset\n" ); + }else { + *hung_db_num =0 ; +for (i =0 ; i < adev->mes.hung_queue_db_array_size; i++) { +if (db_array[i] !=AMDGPU_MES_INVALID_DB_OFFSET ) { + hung_db_array[i] = db_array[i]; + *hung_db_num +=1 ; + } + } + } + +return r; +} +uint32_t amdgpu_mes_rreg (struct amdgpu_device *adev,uint32_t reg) {struct mes_misc_op_input op_input;
drivers/gpu/drm/amd/amdgpu/amdgpu_mes.h +19 -0
@@ -41,6 +41,7 @@#define AMDGPU_MES_API_VERSION_MASK 0x00fff000#define AMDGPU_MES_FEAT_VERSION_MASK 0xff000000#define AMDGPU_MES_MSCRATCH_SIZE 0x40000 +#define AMDGPU_MES_INVALID_DB_OFFSET 0xffffffffenum amdgpu_mes_priority_level {AMDGPU_MES_PRIORITY_LEVEL_LOW =0 ,
@@ -147,6 +148,10 @@ struct amdgpu_mes {uint64_t resource_1_gpu_addr[AMDGPU_MAX_MES_PIPES ];void *resource_1_addr[AMDGPU_MAX_MES_PIPES ]; +int hung_queue_db_array_size; +struct amdgpu_bo *hung_queue_db_array_gpu_obj; +uint64_t hung_queue_db_array_gpu_addr; +void *hung_queue_db_array_cpu_addr; };struct amdgpu_mes_gang {
@@ -280,6 +285,11 @@ struct mes_reset_queue_input {bool is_kq; }; +struct mes_detect_and_reset_queue_input { +uint32_t queue_type; +bool detect_only; +}; +enum mes_misc_opcode {MES_MISC_OP_WRITE_REG ,MES_MISC_OP_READ_REG ,
@@ -367,6 +377,8 @@ struct amdgpu_mes_funcs {int (*reset_hw_queue)(struct amdgpu_mes *mes,struct mes_reset_queue_input *input); +int (*detect_and_reset_hung_queues)(struct amdgpu_mes *mes, +struct mes_detect_and_reset_queue_input *input); };#define amdgpu_mes_kiq_hw_init (adev) (adev)->mes.kiq_hw_init((adev))
@@ -390,6 +402,13 @@ int amdgpu_mes_reset_legacy_queue(struct amdgpu_device *adev,unsigned int vmid, bool use_mmio); +int amdgpu_mes_get_hung_queue_db_array_size (struct amdgpu_device *adev); +int amdgpu_mes_detect_and_reset_hung_queues (struct amdgpu_device *adev, +int queue_type, +bool detect_only, +unsigned int *hung_db_num, +u32 *hung_db_array); +uint32_t amdgpu_mes_rreg (struct amdgpu_device *adev,uint32_t reg);int amdgpu_mes_wreg (struct amdgpu_device *adev,uint32_t reg,uint32_t val);
Signature · 1 line
2.49.0
PATCH v3 3/9 drm/amdgpu/mes11: implement detect and reset callback
In reply to Jesse.ZhangFrom: Alex Deucher <[email protected]>
Implement support for the hung queue detect and reset functionality.
--- drivers/gpu/drm/amd/amdgpu/mes_v11_0.c | 31 ++++++++++++++++++++++++++ 1 file changed, 31 insertions(+)
drivers/gpu/drm/amd/amdgpu/mes_v11_0.c +31 -0
@@ -66,6 +66,8 @@ static int mes_v11_0_kiq_hw_fini(struct amdgpu_device *adev);#define GFX_MES_DRAM_SIZE 0x80000#define MES11_HW_RESOURCE_1_SIZE (128 * AMDGPU_GPU_PAGE_SIZE) +#define MES11_HUNG_DB_OFFSET_ARRAY_SIZE 4 +static void mes_v11_0_ring_set_wptr (struct amdgpu_ring *ring) {struct amdgpu_device *adev = ring->adev;
@@ -783,6 +785,32 @@ static int mes_v11_0_reset_hw_queue(struct amdgpu_mes *mes, offsetof(union MESAPI__RESET, api_status)); } +static int mes_v11_0_detect_and_reset_hung_queues (struct amdgpu_mes *mes, +struct mes_detect_and_reset_queue_input *input) +{ +union MESAPI__RESET mes_reset_queue_pkt; + +memset (&mes_reset_queue_pkt,0 ,sizeof (mes_reset_queue_pkt)); + + mes_reset_queue_pkt.header.type =MES_API_TYPE_SCHEDULER ; + mes_reset_queue_pkt.header.opcode =MES_SCH_API_RESET ; + mes_reset_queue_pkt.header.dwsize =API_FRAME_SIZE_IN_DWORDS ; + + mes_reset_queue_pkt.queue_type = +convert_to_mes_queue_type (input->queue_type); + mes_reset_queue_pkt.doorbell_offset_addr = + mes->hung_queue_db_array_gpu_addr; + +if (input->detect_only) + mes_reset_queue_pkt.hang_detect_only =1 ; +else + mes_reset_queue_pkt.hang_detect_then_reset =1 ; + +return mes_v11_0_submit_pkt_and_poll_completion (mes, + &mes_reset_queue_pkt,sizeof (mes_reset_queue_pkt), + offsetof(union MESAPI__RESET , api_status)); +} +static const struct amdgpu_mes_funcs mes_v11_0_funcs = { .add_hw_queue = mes_v11_0_add_hw_queue, .remove_hw_queue = mes_v11_0_remove_hw_queue,
@@ -792,6 +820,7 @@ static const struct amdgpu_mes_funcs mes_v11_0_funcs = { .resume_gang = mes_v11_0_resume_gang, .misc_op = mes_v11_0_misc_op, .reset_hw_queue = mes_v11_0_reset_hw_queue, + .detect_and_reset_hung_queues = mes_v11_0_detect_and_reset_hung_queues, }; static int mes_v11_0_allocate_ucode_buffer(struct amdgpu_device *adev,
@@ -1682,6 +1711,8 @@ static int mes_v11_0_early_init(struct amdgpu_ip_block *ip_block)struct amdgpu_device *adev = ip_block->adev;int pipe, r; + adev->mes.hung_queue_db_array_size = +MES11_HUNG_DB_OFFSET_ARRAY_SIZE ;for (pipe =0 ; pipe <AMDGPU_MAX_MES_PIPES ; pipe++) {if (!adev->enable_mes_kiq && pipe ==AMDGPU_MES_KIQ_PIPE )continue ;
Signature · 1 line
2.49.0
PATCH v3 4/9 drm/amdgpu: Implement active VMID detection in MES11 queue reset for GFX
In reply to Jesse.ZhangMES queue reset functionality for GFX queues. The changes include:
1. Added detection of active VMIDs by reading CP_CNTX_STAT and CP_VMID registers to properly identify contexts that need resetting
2. Implemented fallback to HPD status method when no active VMIDs are found, checking both pipe 0 and pipe 1 queues
3. Extended the MES reset packet with:
- active_vmids bitmap
- connected_queue_index for pipe 0
- connected_queue_index_p1 for pipe 1
--- drivers/gpu/drm/amd/amdgpu/mes_v11_0.c | 51 +++++++++++++++++++ drivers/gpu/drm/amd/include/mes_v11_api_def.h | 13 ++++- 2 files changed, 63 insertions(+), 1 deletion(-)
drivers/gpu/drm/amd/amdgpu/mes_v11_0.c +51 -0
@@ -789,6 +789,12 @@ static int mes_v11_0_detect_and_reset_hung_queues(struct amdgpu_mes *mes, struct mes_detect_and_reset_queue_input *input) {union MESAPI__RESET mes_reset_queue_pkt; +struct amdgpu_device *adev = mes->adev; +uint32_t active_vmids =0 ; +uint32_t connected_queue_index =0 ; +uint32_t queue_status =0 ; +uint32_t connected_queue_index_p1 =0 ; +uint32_t queue_status_p1 =0 ;memset (&mes_reset_queue_pkt,0 ,sizeof (mes_reset_queue_pkt));
@@ -801,6 +807,51 @@ static int mes_v11_0_detect_and_reset_hung_queues(struct amdgpu_mes *mes, mes_reset_queue_pkt.doorbell_offset_addr = mes->hung_queue_db_array_gpu_addr; +/* Add VMID detection for GFX queues */ +if (input->queue_type ==AMDGPU_RING_TYPE_GFX ) { +uint32_t cp_cntx_stat =RREG32_SOC15 (GC ,0 , regCP_CNTX_STAT); +uint32_t cp_vmid, grbm_gfx_cntl; + +/* Check active contexts in CP_CNTX_STAT */ +for (uint32_t i =0 ; i <8 ; i++) { +if ((cp_cntx_stat >> (0x14 + i)) &0x1 ) { + grbm_gfx_cntl = (i <<11 ); +WREG32_SOC15 (GC ,0 , regGRBM_GFX_CNTL, grbm_gfx_cntl); + cp_vmid =RREG32_SOC15 (GC ,0 , regCP_VMID); + active_vmids |= (1 << cp_vmid); + } + } + +/* Fallback to HPD status if no active VMIDs found */ +if (active_vmids ==0 ) { +uint32_t hpd_status; + +/* Pipe 0 */ +WREG32_SOC15 (GC ,0 , regGRBM_GFX_CNTL,0 ); + hpd_status =RREG32_SOC15 (GC ,0 , regCP_GFX_HPD_STATUS0); + queue_status = hpd_status &0x1F ; + connected_queue_index = (hpd_status &0xE0 ) >>5 ; + +/* Pipe 1 */ +WREG32_SOC15 (GC ,0 , regGRBM_GFX_CNTL, (1 <<6 )); + hpd_status =RREG32_SOC15 (GC ,0 , regCP_GFX_HPD_STATUS0); + queue_status_p1 = hpd_status &0x1F ; + connected_queue_index_p1 = (hpd_status &0xE0 ) >>5 ; + } + + mes_reset_queue_pkt.active_vmids = active_vmids; +if (active_vmids ==0 ) { +if (queue_status !=0 ) { + mes_reset_queue_pkt.use_connected_queue_index =1 ; + mes_reset_queue_pkt.connected_queue_index = connected_queue_index; + } +if (queue_status_p1 !=0 ) { + mes_reset_queue_pkt.use_connected_queue_index_p1 =1 ; + mes_reset_queue_pkt.connected_queue_index_p1 = connected_queue_index_p1; + } + } + } +if (input->detect_only) mes_reset_queue_pkt.hang_detect_only =1 ;else
drivers/gpu/drm/amd/include/mes_v11_api_def.h +12 -1
@@ -460,7 +460,11 @@ union MESAPI__RESET { uint32_t hang_detect_only : 1;/* Rest HP and LP kernel queues not managed by MES */ uint32_t reset_legacy_gfx : 1; - uint32_t reserved : 28; +/* Fallback to use conneceted queue index when CP_CNTX_STAT method fails (gfx pipe 0) */ + uint32_t use_connected_queue_index : 1; +/* For gfx pipe 1 */ + uint32_t use_connected_queue_index_p1 : 1; + uint32_t reserved : 26; };uint64_t gang_context_addr;
@@ -488,6 +492,13 @@ union MESAPI__RESET {uint64_t wptr_addr_hp;struct MES_API_STATUS api_status; +uint32_t active_vmids; +uint64_t timestamp; + +uint32_t gang_context_array_index; + +uint32_t connected_queue_index; +uint32_t connected_queue_index_p1; };uint32_t max_dwords_in_api[API_FRAME_SIZE_IN_DWORDS ];
Signature · 1 line
2.49.0
PATCH v3 5/9 drm/amdgpu/mes12: implement detect and reset callback
In reply to Jesse.ZhangFrom: Alex Deucher <[email protected]>
Implement support for the hung queue detect and reset functionality.
--- drivers/gpu/drm/amd/amdgpu/mes_v12_0.c | 37 ++++++++++++++++++++++++++ 1 file changed, 37 insertions(+)
drivers/gpu/drm/amd/amdgpu/mes_v12_0.c +37 -0
@@ -47,6 +47,8 @@ static int mes_v12_0_kiq_hw_fini(struct amdgpu_device *adev);#define MES_EOP_SIZE 2048 +#define MES12_HUNG_DB_OFFSET_ARRAY_SIZE 4 +static void mes_v12_0_ring_set_wptr (struct amdgpu_ring *ring) {struct amdgpu_device *adev = ring->adev;
@@ -879,6 +881,38 @@ static int mes_v12_0_reset_hw_queue(struct amdgpu_mes *mes, offsetof(union MESAPI__RESET, api_status)); } +static int mes_v12_0_detect_and_reset_hung_queues (struct amdgpu_mes *mes, +struct mes_detect_and_reset_queue_input *input) +{ +union MESAPI__RESET mes_reset_queue_pkt; +int pipe; + +memset (&mes_reset_queue_pkt,0 ,sizeof (mes_reset_queue_pkt)); + + mes_reset_queue_pkt.header.type =MES_API_TYPE_SCHEDULER ; + mes_reset_queue_pkt.header.opcode =MES_SCH_API_RESET ; + mes_reset_queue_pkt.header.dwsize =API_FRAME_SIZE_IN_DWORDS ; + + mes_reset_queue_pkt.queue_type = +convert_to_mes_queue_type (input->queue_type); + mes_reset_queue_pkt.doorbell_offset_addr = + mes->hung_queue_db_array_gpu_addr; + +if (input->detect_only) + mes_reset_queue_pkt.hang_detect_only =1 ; +else + mes_reset_queue_pkt.hang_detect_then_reset =1 ; + +if (mes->adev->enable_uni_mes) + pipe =AMDGPU_MES_KIQ_PIPE ; +else + pipe =AMDGPU_MES_SCHED_PIPE ; + +return mes_v12_0_submit_pkt_and_poll_completion (mes, pipe, + &mes_reset_queue_pkt,sizeof (mes_reset_queue_pkt), + offsetof(union MESAPI__RESET , api_status)); +} +static const struct amdgpu_mes_funcs mes_v12_0_funcs = { .add_hw_queue = mes_v12_0_add_hw_queue, .remove_hw_queue = mes_v12_0_remove_hw_queue,
@@ -888,6 +922,7 @@ static const struct amdgpu_mes_funcs mes_v12_0_funcs = { .resume_gang = mes_v12_0_resume_gang, .misc_op = mes_v12_0_misc_op, .reset_hw_queue = mes_v12_0_reset_hw_queue, + .detect_and_reset_hung_queues = mes_v12_0_detect_and_reset_hung_queues, }; static int mes_v12_0_allocate_ucode_buffer(struct amdgpu_device *adev,
@@ -1792,6 +1827,8 @@ static int mes_v12_0_early_init(struct amdgpu_ip_block *ip_block)struct amdgpu_device *adev = ip_block->adev;int pipe, r; + adev->mes.hung_queue_db_array_size = +MES12_HUNG_DB_OFFSET_ARRAY_SIZE ;for (pipe =0 ; pipe <AMDGPU_MAX_MES_PIPES ; pipe++) { r =amdgpu_mes_init_microcode (adev, pipe);if (r)
Signature · 1 line
2.49.0
PATCH v3 6/9 drm/amdgpu: Implement active VMID detection in MES12 queue reset for GFX
In reply to Jesse.ZhangMES queue reset functionality for GFX queues. The changes include:
1. Added detection of active VMIDs by reading CP_CNTX_STAT and CP_VMID registers to properly identify contexts that need resetting
2. Implemented fallback to HPD status method when no active VMIDs are found, checking both pipe 0 and pipe 1 queues
3. Extended the MES reset packet with:
- active_vmids bitmap
- connected_queue_index for pipe 0
- connected_queue_index_p1 for pipe 1
--- drivers/gpu/drm/amd/amdgpu/mes_v12_0.c | 51 ++++++++++++++++++++++++++ 1 file changed, 51 insertions(+)
drivers/gpu/drm/amd/amdgpu/mes_v12_0.c +51 -0
@@ -885,6 +885,12 @@ static int mes_v12_0_detect_and_reset_hung_queues(struct amdgpu_mes *mes, struct mes_detect_and_reset_queue_input *input) {union MESAPI__RESET mes_reset_queue_pkt; +struct amdgpu_device *adev = mes->adev; +uint32_t active_vmids =0 ; +uint32_t connected_queue_index =0 ; +uint32_t queue_status =0 ; +uint32_t connected_queue_index_p1 =0 ; +uint32_t queue_status_p1 =0 ;int pipe;memset (&mes_reset_queue_pkt,0 ,sizeof (mes_reset_queue_pkt));
@@ -898,6 +904,51 @@ static int mes_v12_0_detect_and_reset_hung_queues(struct amdgpu_mes *mes, mes_reset_queue_pkt.doorbell_offset_addr = mes->hung_queue_db_array_gpu_addr; +/* Add VMID detection for GFX queues */ +if (input->queue_type ==AMDGPU_RING_TYPE_GFX ) { +uint32_t cp_cntx_stat =RREG32_SOC15 (GC ,0 , regCP_CNTX_STAT); +uint32_t cp_vmid, grbm_gfx_cntl; + +/* Check active contexts in CP_CNTX_STAT */ +for (uint32_t i =0 ; i <8 ; i++) { +if ((cp_cntx_stat >> (0x14 + i)) &0x1 ) { + grbm_gfx_cntl = (i <<11 ); +WREG32_SOC15 (GC ,0 , regGRBM_GFX_CNTL, grbm_gfx_cntl); + cp_vmid =RREG32_SOC15 (GC ,0 , regCP_CP_VMID); + active_vmids |= (1 << cp_vmid); + } + } + +/* Fallback to HPD status if no active VMIDs found */ +if (active_vmids ==0 ) { +uint32_t hpd_status; + +/* Pipe 0 */ +WREG32_SOC15 (GC ,0 , regGRBM_GFX_CNTL,0 ); + hpd_status =RREG32_SOC15 (GC ,0 , regCP_GFX_HPD_STATUS0); + queue_status = hpd_status &0x1F ; + connected_queue_index = (hpd_status &0xE0 ) >>5 ; + +/* Pipe 1 */ +WREG32_SOC15 (GC ,0 , regGRBM_GFX_CNTL, (1 <<6 )); + hpd_status =RREG32_SOC15 (GC ,0 , regCP_GFX_HPD_STATUS0); + queue_status_p1 = hpd_status &0x1F ; + connected_queue_index_p1 = (hpd_status &0xE0 ) >>5 ; + } + + mes_reset_queue_pkt.active_vmids = active_vmids; +if (active_vmids ==0 ) { +if (queue_status !=0 ) { + mes_reset_queue_pkt.use_connected_queue_index =1 ; + mes_reset_queue_pkt.connected_queue_index = connected_queue_index; + } +if (queue_status_p1 !=0 ) { + mes_reset_queue_pkt.use_connected_queue_index_p1 =1 ; + mes_reset_queue_pkt.connected_queue_index_p1 = connected_queue_index_p1; + } + } + } +if (input->detect_only) mes_reset_queue_pkt.hang_detect_only =1 ;else
Signature · 1 line
2.49.0
PATCH v3 7/9 drm/amdgpu/userq: add force completion helpers
In reply to Jesse.ZhangFrom: Alex Deucher <[email protected]>
Add support for forcing completion of userq fences. This is needed for userq resets and asic resets so that we can set the error on the fence and force completion.
--- .../gpu/drm/amd/amdgpu/amdgpu_userq_fence.c | 42 +++++++++++++++++++ .../gpu/drm/amd/amdgpu/amdgpu_userq_fence.h | 1 + 2 files changed, 43 insertions(+)
drivers/gpu/drm/amd/amdgpu/amdgpu_userq_fence.c +42 -0
@@ -67,6 +67,14 @@ static u64 amdgpu_userq_fence_read(struct amdgpu_userq_fence_driver *fence_drv)return le64_to_cpu (*fence_drv->cpu_addr); } +static void +amdgpu_userq_fence_write (struct amdgpu_userq_fence_driver *fence_drv, +u64 seq) +{ +if (fence_drv->cpu_addr) + *fence_drv->cpu_addr =cpu_to_le64 (seq); +} +int amdgpu_userq_fence_driver_alloc (struct amdgpu_device *adev,struct amdgpu_usermode_queue *userq) {
@@ -409,6 +417,40 @@ static void amdgpu_userq_fence_cleanup(struct dma_fence *fence)dma_fence_put (fence); } +static void +amdgpu_userq_fence_driver_set_error (struct amdgpu_userq_fence *fence, +int error) +{ +struct amdgpu_userq_fence_driver *fence_drv = fence->fence_drv; +unsigned long flags; +struct dma_fence *f; + +spin_lock_irqsave (&fence_drv->fence_list_lock, flags); + + f =rcu_dereference_protected (&fence->base, +lockdep_is_held (&fence_drv->fence_list_lock)); +if (f && !dma_fence_is_signaled_locked (f)) +dma_fence_set_error (f, error); +spin_unlock_irqrestore (&fence_drv->fence_list_lock, flags); +} + +void +amdgpu_userq_fence_driver_force_completion (struct amdgpu_usermode_queue *userq) +{ +struct dma_fence *f = userq->last_fence; + +if (f) { +struct amdgpu_userq_fence *fence =to_amdgpu_userq_fence (f); +struct amdgpu_userq_fence_driver *fence_drv = fence->fence_drv; +u64 wptr = fence->base.seqno; + +amdgpu_userq_fence_driver_set_error (fence, -ECANCELED ); +amdgpu_userq_fence_write (fence_drv, wptr); +amdgpu_userq_fence_driver_process (fence_drv); + + } +} +int amdgpu_userq_signal_ioctl (struct drm_device *dev,void *data,struct drm_file *filp) {
drivers/gpu/drm/amd/amdgpu/amdgpu_userq_fence.h +1 -0
@@ -67,6 +67,7 @@ int amdgpu_userq_fence_driver_alloc(struct amdgpu_device *adev, struct amdgpu_usermode_queue *userq);void amdgpu_userq_fence_driver_free (struct amdgpu_usermode_queue *userq);void amdgpu_userq_fence_driver_process (struct amdgpu_userq_fence_driver *fence_drv); +void amdgpu_userq_fence_driver_force_completion (struct amdgpu_usermode_queue *userq);void amdgpu_userq_fence_driver_destroy (struct kref *ref);int amdgpu_userq_signal_ioctl (struct drm_device *dev,void *data,struct drm_file *filp);
Signature · 1 line
2.49.0
PATCH v3 8/9 drm/amdgpu/userq: add a detect and reset callback
In reply to Jesse.ZhangFrom: Alex Deucher <[email protected]>
Add a detect and reset callback and add the implementation for mes. The callback will detect all hung queues of a particular ip type (e.g., GFX or compute or SDMA) and reset them.
v2: increase reset counter and set fence force completion (Jesse)
--- drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h | 3 ++ drivers/gpu/drm/amd/amdgpu/mes_userqueue.c | 51 ++++++++++++++++++++++ 2 files changed, 54 insertions(+)
drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h +3 -0
@@ -77,6 +77,9 @@ struct amdgpu_userq_funcs { struct amdgpu_usermode_queue *queue);int (*map)(struct amdgpu_userq_mgr *uq_mgr,struct amdgpu_usermode_queue *queue); +int (*detect_and_reset)(struct amdgpu_device *adev, +int queue_type); + };/* Usermode queues for gfx */
drivers/gpu/drm/amd/amdgpu/mes_userqueue.c +51 -0
67 lines not on this page · raw message
Signature · 1 line
2.49.0
Re: [v3 8/9] drm/amdgpu/userq: add a detect and reset callback
Quoted 70 lines · Jesse.Zhang
From: Alex Deucher <[email protected]>
Add a detect and reset callback and add the implementation for mes. The callback will detect all hung queues of a particular ip type (e.g., GFX or compute or SDMA) and reset them.
v2: increase reset counter and set fence force completion (Jesse)
Signed-off-by Alex Deucher <[email protected]>--- drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h | 3 ++ drivers/gpu/drm/amd/amdgpu/mes_userqueue.c | 51 ++++++++++++++++++++++ 2 files changed, 54 insertions(+)drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h +3
-0@@ -77,6 +77,9 @@ struct amdgpu_userq_funcs { struct amdgpu_usermode_queue *queue);int (*map)(struct amdgpu_userq_mgr *uq_mgr,struct amdgpu_usermode_queue *queue); +int (*detect_and_reset)(struct amdgpu_device *adev, +int queue_type); + };/* Usermode queues for gfx */ drivers/gpu/drm/amd/amdgpu/mes_userqueue.c +26
-0@@ -21,6 +21,7 @@* OTHER DEALINGS IN THE SOFTWARE. * */ +#include <drm/drm_drv.h> #include "amdgpu.h" #include "amdgpu_gfx.h" #include "mes_userqueue.h" @@ -198,6 +199,55 @@ static int mes_userq_create_ctx_space(struct amdgpu_userq_mgr *uq_mgr,return 0 ; } +static int mes_userq_detect_and_reset (struct amdgpu_device *adev, +int queue_type) +{ +int db_array_size =amdgpu_mes_get_hung_queue_db_array_size (adev); +struct mes_detect_and_reset_queue_input input; +struct amdgpu_usermode_queue *queue; +struct amdgpu_userq_mgr *uqm, *tmp; +unsigned int hung_db_num =0 ; +int queue_id, r, i; +u32 db_array[4 ]; + +if (db_array_size >4 ) { +dev_err (adev->dev,"DB array size (%d vs 4) too small\n" , + db_array_size); +return -EINVAL ; + } + +memset (&input,0x0 ,sizeof (struct mes_detect_and_reset_queue_input )); + + input.queue_type = queue_type; + +amdgpu_mes_lock (&adev->mes); + r =amdgpu_mes_detect_and_reset_hung_queues (adev, queue_type, false, + &hung_db_num, db_array); +amdgpu_mes_unlock (&adev->mes);
drivers/gpu/drm/amd/amdgpu/mes_userqueue.c static int mes_userq_create_ctx_space(struct amdgpu_userq_mgr *uq_mgr, · line 236
Quoted 10 lines
drivers/gpu/drm/amd/amdgpu/mes_userqueue.c +10
-0+if (r) { +dev_err (adev->dev,"Failed to detect and reset queues, err (%d)\n" , r); + }else if (hung_db_num) { +mutex_lock (&adev->userq_mutex); +list_for_each_entry_safe (uqm, tmp, &adev->userq_mgr_list, list) { +idr_for_each_entry (&uqm->userq_idr, queue, queue_id) { +if (queue->queue_type == queue_type) { +for (i =0 ; i < hung_db_num; i++) { +if (queue->doorbell_index == db_array[i]) { + queue->state =AMDGPU_USERQ_STATE_HUNG ;
After a reset and force completion of work, why is the queue state maintained as hung? Does that mean no more work can be submitted even after reset? Where is this state checked?
Thanks,
Lijo
Quoted 23 lines
drivers/gpu/drm/amd/amdgpu/mes_userqueue.c +15
-0+atomic_inc (&adev->gpu_reset_counter); +amdgpu_userq_fence_driver_force_completion (queue); +drm_dev_wedged_event (adev_to_drm (adev),DRM_WEDGE_RECOVERY_NONE ); + } + } + } + } + } +mutex_unlock (&adev->userq_mutex); + } + +return r; +} +static int mes_userq_mqd_create (struct amdgpu_userq_mgr *uq_mgr,struct drm_amdgpu_userq_in *args_in,struct amdgpu_usermode_queue *queue)@@ -352,4 +402,5 @@ const struct amdgpu_userq_funcs userq_mes_funcs = { .mqd_destroy = mes_userq_mqd_destroy, .unmap = mes_userq_unmap, .map = mes_userq_map, + .detect_and_reset = mes_userq_detect_and_reset, };
RE: [v3 8/9] drm/amdgpu/userq: add a detect and reset callback
[AMD Official Use Only - AMD Internal Distribution Only]
-----Original Message-----
From: Lazar, Lijo <[email protected]>
Sent: Tuesday, June 17, 2025 5:57 PM
To: Zhang, Jesse(Jie) <[email protected]>; [email protected]
Cc: Deucher, Alexander <[email protected]>; Koenig, Christian <[email protected]>
Subject: Re: [v3 8/9] drm/amdgpu/userq: add a detect and reset callback
Quoted 72 lines · Jesse.Zhang
From: Alex Deucher <[email protected]>
Add a detect and reset callback and add the implementation for mes. The callback will detect all hung queues of a particular ip type (e.g., GFX or compute or SDMA) and reset them.
v2: increase reset counter and set fence force completion (Jesse)
Signed-off-by Alex Deucher <[email protected]>--- drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h | 3 ++ drivers/gpu/drm/amd/amdgpu/mes_userqueue.c | 51 ++++++++++++++++++++++ 2 files changed, 54 insertions(+)drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h +3
-0@@ -77,6 +77,9 @@ struct amdgpu_userq_funcs { struct amdgpu_usermode_queue *queue);int (*map)(struct amdgpu_userq_mgr *uq_mgr,struct amdgpu_usermode_queue *queue); +int (*detect_and_reset)(struct amdgpu_device *adev, +int queue_type); + };/* Usermode queues for gfx */ drivers/gpu/drm/amd/amdgpu/mes_userqueue.c +27
-0@@ -21,6 +21,7 @@* OTHER DEALINGS IN THE SOFTWARE. * */ +#include <drm/drm_drv.h> #include "amdgpu.h" #include "amdgpu_gfx.h" #include "mes_userqueue.h" @@ -198,6 +199,55 @@ static int mes_userq_create_ctx_space(struct amdgpu_userq_mgr *uq_mgr,return 0 ; } +static int mes_userq_detect_and_reset (struct amdgpu_device *adev, +int queue_type) +{ +int db_array_size =amdgpu_mes_get_hung_queue_db_array_size (adev); +struct mes_detect_and_reset_queue_input input; +struct amdgpu_usermode_queue *queue; +struct amdgpu_userq_mgr *uqm, *tmp; +unsigned int hung_db_num =0 ; +int queue_id, r, i; +u32 db_array[4 ]; + +if (db_array_size >4 ) { +dev_err (adev->dev,"DB array size (%d vs 4) too small\n" , + db_array_size); +return -EINVAL ; + } + +memset (&input,0x0 ,sizeof (struct +mes_detect_and_reset_queue_input )); + + input.queue_type = queue_type; + +amdgpu_mes_lock (&adev->mes); + r =amdgpu_mes_detect_and_reset_hung_queues (adev, queue_type, false, + &hung_db_num, db_array); +amdgpu_mes_unlock (&adev->mes);
drivers/gpu/drm/amd/amdgpu/mes_userqueue.c static int mes_userq_create_ctx_space(struct amdgpu_userq_mgr *uq_mgr, · line 237
Quoted 10 lines
drivers/gpu/drm/amd/amdgpu/mes_userqueue.c +10
-0+if (r) { +dev_err (adev->dev,"Failed to detect and reset queues, err (%d)\n" , r); + }else if (hung_db_num) { +mutex_lock (&adev->userq_mutex); +list_for_each_entry_safe (uqm, tmp, &adev->userq_mgr_list, list) { +idr_for_each_entry (&uqm->userq_idr, queue, queue_id) { +if (queue->queue_type == queue_type) { +for (i =0 ; i < hung_db_num; i++) { +if (queue->doorbell_index == db_array[i]) { + queue->state =AMDGPU_USERQ_STATE_HUNG ;
After a reset and force completion of work, why is the queue state maintained as hung? Does that mean no more work can be submitted even after reset? Where is this state checked?
Detect and reset will be called at umap, and if the queue is hung, umap will be skipped.
Thanks
Jesse
Thanks,
Lijo
Quoted 23 lines
drivers/gpu/drm/amd/amdgpu/mes_userqueue.c +14
-0+atomic_inc (&adev->gpu_reset_counter); +amdgpu_userq_fence_driver_force_completion (queue); +drm_dev_wedged_event (adev_to_drm (adev),DRM_WEDGE_RECOVERY_NONE ); + } + } + } + } + } +mutex_unlock (&adev->userq_mutex); + } + +return r; +} +static int mes_userq_mqd_create (struct amdgpu_userq_mgr *uq_mgr,struct drm_amdgpu_userq_in *args_in, struct amdgpu_usermode_queue *queue) @@ -352,4 +402,5 @@ conststruct
amdgpu_userq_funcsuserq_mes_funcs= {
.mqd_destroy =mes_userq_mqd_destroy,
.unmap =mes_userq_unmap,
.map =mes_userq_map,
+ .detect_and_reset =mes_userq_detect_and_reset,
};
Re: [v3 8/9] drm/amdgpu/userq: add a detect and reset callback
Quoted 89 lines · Jesse(Jie)
[AMD Official Use Only - AMD Internal Distribution Only]
-----Original Message-----
From: Lazar, Lijo <[email protected]>
Sent: Tuesday, June 17, 2025 5:57 PM
To: Zhang, Jesse(Jie) <[email protected]>; [email protected]
Cc: Deucher, Alexander <[email protected]>; Koenig, Christian <[email protected]>
Subject: Re: [v3 8/9] drm/amdgpu/userq: add a detect and reset callbackQuoted 77 lines · Jesse.Zhang
From: Alex Deucher <[email protected]>
Add a detect and reset callback and add the implementation for mes. The callback will detect all hung queues of a particular ip type (e.g., GFX or compute or SDMA) and reset them.
v2: increase reset counter and set fence force completion (Jesse)
Signed-off-by Alex Deucher <[email protected]>--- drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h | 3 ++ drivers/gpu/drm/amd/amdgpu/mes_userqueue.c | 51 ++++++++++++++++++++++ 2 files changed, 54 insertions(+)drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h +3
-0@@ -77,6 +77,9 @@ struct amdgpu_userq_funcs { struct amdgpu_usermode_queue *queue);int (*map)(struct amdgpu_userq_mgr *uq_mgr,struct amdgpu_usermode_queue *queue); +int (*detect_and_reset)(struct amdgpu_device *adev, +int queue_type); + };/* Usermode queues for gfx */ drivers/gpu/drm/amd/amdgpu/mes_userqueue.c +32
-0@@ -21,6 +21,7 @@* OTHER DEALINGS IN THE SOFTWARE. * */ +#include <drm/drm_drv.h> #include "amdgpu.h" #include "amdgpu_gfx.h" #include "mes_userqueue.h" @@ -198,6 +199,55 @@ static int mes_userq_create_ctx_space(struct amdgpu_userq_mgr *uq_mgr,return 0 ; } +static int mes_userq_detect_and_reset (struct amdgpu_device *adev, +int queue_type) +{ +int db_array_size =amdgpu_mes_get_hung_queue_db_array_size (adev); +struct mes_detect_and_reset_queue_input input; +struct amdgpu_usermode_queue *queue; +struct amdgpu_userq_mgr *uqm, *tmp; +unsigned int hung_db_num =0 ; +int queue_id, r, i; +u32 db_array[4 ]; + +if (db_array_size >4 ) { +dev_err (adev->dev,"DB array size (%d vs 4) too small\n" , + db_array_size); +return -EINVAL ; + } + +memset (&input,0x0 ,sizeof (struct +mes_detect_and_reset_queue_input )); + + input.queue_type = queue_type; + +amdgpu_mes_lock (&adev->mes); + r =amdgpu_mes_detect_and_reset_hung_queues (adev, queue_type, false, + &hung_db_num, db_array); +amdgpu_mes_unlock (&adev->mes); +if (r) { +dev_err (adev->dev,"Failed to detect and reset queues, err (%d)\n" , r); + }else if (hung_db_num) { +mutex_lock (&adev->userq_mutex); +list_for_each_entry_safe (uqm, tmp, &adev->userq_mgr_list, list) {
Quoted 8 lines
drivers/gpu/drm/amd/amdgpu/mes_userqueue.c static int mes_userq_create_ctx_space(struct amdgpu_userq_mgr *uq_mgr, · line 236
Quoted 5 lines
drivers/gpu/drm/amd/amdgpu/mes_userqueue.c +5
-0+idr_for_each_entry (&uqm->userq_idr, queue, queue_id) { +if (queue->queue_type == queue_type) { +for (i =0 ; i < hung_db_num; i++) { +if (queue->doorbell_index == db_array[i]) { + queue->state =AMDGPU_USERQ_STATE_HUNG ;After a reset and force completion of work, why is the queue state maintained as hung? Does that mean no more work can be submitted even after reset? Where is this state checked?
Detect and reset will be called at umap, and if the queue is hung, umap will be skipped.
Ok, this doesn't match with the inferred meaning of amdgpu_mes_detect_and_*reset_hung_queues*. The API name gives the impression that queue is reset and now it can be used to submit other work. If the queue is not useful after a reset, why not remove it from the list of active queues?
Thanks,
Lijo
Quoted 30 lines
Thanks
JesseThanks,
LijoQuoted 23 lines
drivers/gpu/drm/amd/amdgpu/mes_userqueue.c +14
-0+atomic_inc (&adev->gpu_reset_counter); +amdgpu_userq_fence_driver_force_completion (queue); +drm_dev_wedged_event (adev_to_drm (adev),DRM_WEDGE_RECOVERY_NONE ); + } + } + } + } + } +mutex_unlock (&adev->userq_mutex); + } + +return r; +} +static int mes_userq_mqd_create (struct amdgpu_userq_mgr *uq_mgr,struct drm_amdgpu_userq_in *args_in, struct amdgpu_usermode_queue *queue) @@ -352,4 +402,5 @@ conststruct
amdgpu_userq_funcsuserq_mes_funcs= {
.mqd_destroy =mes_userq_mqd_destroy,
.unmap =mes_userq_unmap,
.map =mes_userq_map,
+ .detect_and_reset =mes_userq_detect_and_reset,
};
RE: [v3 8/9] drm/amdgpu/userq: add a detect and reset callback
[AMD Official Use Only - AMD Internal Distribution Only]
-----Original Message-----
From: Lazar, Lijo <[email protected]>
Sent: Wednesday, June 18, 2025 12:14 PM
To: Zhang, Jesse(Jie) <[email protected]>; [email protected]
Cc: Deucher, Alexander <[email protected]>; Koenig, Christian <[email protected]>
Subject: Re: [v3 8/9] drm/amdgpu/userq: add a detect and reset callback
Quoted 93 lines · Jesse(Jie)
[AMD Official Use Only - AMD Internal Distribution Only]
-----Original Message-----
From: Lazar, Lijo <[email protected]>
Sent: Tuesday, June 17, 2025 5:57 PM
To: Zhang, Jesse(Jie) <[email protected]>; [email protected]
Cc: Deucher, Alexander <[email protected]>; Koenig, Christian <[email protected]>
Subject: Re: [v3 8/9] drm/amdgpu/userq: add a detect and reset callbackQuoted 78 lines · Jesse.Zhang
From: Alex Deucher <[email protected]>
Add a detect and reset callback and add the implementation for mes. The callback will detect all hung queues of a particular ip type (e.g., GFX or compute or SDMA) and reset them.
v2: increase reset counter and set fence force completion (Jesse)
Signed-off-by Alex Deucher <[email protected]>--- drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h | 3 ++ drivers/gpu/drm/amd/amdgpu/mes_userqueue.c | 51 ++++++++++++++++++++++ 2 files changed, 54 insertions(+)drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h +3
-0@@ -77,6 +77,9 @@ struct amdgpu_userq_funcs { struct amdgpu_usermode_queue *queue);int (*map)(struct amdgpu_userq_mgr *uq_mgr,struct amdgpu_usermode_queue *queue); +int (*detect_and_reset)(struct amdgpu_device *adev, +int queue_type); + };/* Usermode queues for gfx */ drivers/gpu/drm/amd/amdgpu/mes_userqueue.c +32
-0@@ -21,6 +21,7 @@* OTHER DEALINGS IN THE SOFTWARE. * */ +#include <drm/drm_drv.h> #include "amdgpu.h" #include "amdgpu_gfx.h" #include "mes_userqueue.h" @@ -198,6 +199,55 @@ static int mes_userq_create_ctx_space(struct amdgpu_userq_mgr *uq_mgr,return 0 ; } +static int mes_userq_detect_and_reset (struct amdgpu_device *adev, +int queue_type) { +int db_array_size =amdgpu_mes_get_hung_queue_db_array_size (adev); +struct mes_detect_and_reset_queue_input input; +struct amdgpu_usermode_queue *queue; +struct amdgpu_userq_mgr *uqm, *tmp; +unsigned int hung_db_num =0 ; +int queue_id, r, i; +u32 db_array[4 ]; + +if (db_array_size >4 ) { +dev_err (adev->dev,"DB array size (%d vs 4) too small\n" , + db_array_size); +return -EINVAL ; + } + +memset (&input,0x0 ,sizeof (struct +mes_detect_and_reset_queue_input )); + + input.queue_type = queue_type; + +amdgpu_mes_lock (&adev->mes); + r =amdgpu_mes_detect_and_reset_hung_queues (adev, queue_type, false, + &hung_db_num, db_array); +amdgpu_mes_unlock (&adev->mes); +if (r) { +dev_err (adev->dev,"Failed to detect and reset queues, err (%d)\n" , r); + }else if (hung_db_num) { +mutex_lock (&adev->userq_mutex); +list_for_each_entry_safe (uqm, tmp, &adev->userq_mgr_list, list) { +idr_for_each_entry (&uqm->userq_idr, queue, queue_id) {
Quoted 8 lines
drivers/gpu/drm/amd/amdgpu/mes_userqueue.c static int mes_userq_create_ctx_space(struct amdgpu_userq_mgr *uq_mgr,
Quoted 5 lines
drivers/gpu/drm/amd/amdgpu/mes_userqueue.c +5
-0+if (queue->queue_type == queue_type) { +for (i =0 ; i < hung_db_num; i++) { +if (queue->doorbell_index == db_array[i]) { + queue->state = +AMDGPU_USERQ_STATE_HUNG ;After a reset and force completion of work, why is the queue state maintained as hung? Does that mean no more work can be submitted even after reset? Where is this state checked?
Detect and reset will be called at umap, and if the queue is hung, umap will be skipped.
Ok, this doesn't match with the inferred meaning of amdgpu_mes_detect_and_*reset_hung_queues*. The API name gives the impression that queue is reset and now it can be used to submit other work. If the queue is not useful after a reset, why not remove it from the list of active queues?
This API detects the hang queues and resets them, and returns the detected hang queues. Queue removal is done when the user calls AMDGPU_USERQ_OP_FREE.
Thanks
Jesse
Thanks,
Lijo
Quoted 30 lines
Thanks
JesseThanks,
LijoQuoted 23 lines
drivers/gpu/drm/amd/amdgpu/mes_userqueue.c +15
-1+atomic_inc (&adev->gpu_reset_counter); +amdgpu_userq_fence_driver_force_completion (queue); +drm_dev_wedged_event (adev_to_drm (adev),DRM_WEDGE_RECOVERY_NONE ); + } + } + } + } + } +mutex_unlock (&adev->userq_mutex); + } + +return r; +} +static int mes_userq_mqd_create (struct amdgpu_userq_mgr *uq_mgr,struct drm_amdgpu_userq_in *args_in, struct amdgpu_usermode_queue *queue) @@ -352,4 +402,5 @@ const struct amdgpu_userq_funcs userq_mes_funcs = { .mqd_destroy = mes_userq_mqd_destroy, .unmap = mes_userq_unmap, .map = mes_userq_map, + .detect_and_reset = mes_userq_detect_and_reset, };
Re: [v3 8/9] drm/amdgpu/userq: add a detect and reset callback
Quoted 114 lines · Jesse(Jie)
[AMD Official Use Only - AMD Internal Distribution Only]
-----Original Message-----
From: Lazar, Lijo <[email protected]>
Sent: Wednesday, June 18, 2025 12:14 PM
To: Zhang, Jesse(Jie) <[email protected]>; [email protected]
Cc: Deucher, Alexander <[email protected]>; Koenig, Christian <[email protected]>
Subject: Re: [v3 8/9] drm/amdgpu/userq: add a detect and reset callbackQuoted 93 lines · Jesse(Jie)
[AMD Official Use Only - AMD Internal Distribution Only]
-----Original Message-----
From: Lazar, Lijo <[email protected]>
Sent: Tuesday, June 17, 2025 5:57 PM
To: Zhang, Jesse(Jie) <[email protected]>; [email protected]
Cc: Deucher, Alexander <[email protected]>; Koenig, Christian <[email protected]>
Subject: Re: [v3 8/9] drm/amdgpu/userq: add a detect and reset callbackQuoted 78 lines · Jesse.Zhang
From: Alex Deucher <[email protected]>
Add a detect and reset callback and add the implementation for mes. The callback will detect all hung queues of a particular ip type (e.g., GFX or compute or SDMA) and reset them.
v2: increase reset counter and set fence force completion (Jesse)
Signed-off-by Alex Deucher <[email protected]>--- drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h | 3 ++ drivers/gpu/drm/amd/amdgpu/mes_userqueue.c | 51 ++++++++++++++++++++++ 2 files changed, 54 insertions(+)drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h +3
-0@@ -77,6 +77,9 @@ struct amdgpu_userq_funcs { struct amdgpu_usermode_queue *queue);int (*map)(struct amdgpu_userq_mgr *uq_mgr,struct amdgpu_usermode_queue *queue); +int (*detect_and_reset)(struct amdgpu_device *adev, +int queue_type); + };/* Usermode queues for gfx */ drivers/gpu/drm/amd/amdgpu/mes_userqueue.c +32
-0@@ -21,6 +21,7 @@* OTHER DEALINGS IN THE SOFTWARE. * */ +#include <drm/drm_drv.h> #include "amdgpu.h" #include "amdgpu_gfx.h" #include "mes_userqueue.h" @@ -198,6 +199,55 @@ static int mes_userq_create_ctx_space(struct amdgpu_userq_mgr *uq_mgr,return 0 ; } +static int mes_userq_detect_and_reset (struct amdgpu_device *adev, +int queue_type) { +int db_array_size =amdgpu_mes_get_hung_queue_db_array_size (adev); +struct mes_detect_and_reset_queue_input input; +struct amdgpu_usermode_queue *queue; +struct amdgpu_userq_mgr *uqm, *tmp; +unsigned int hung_db_num =0 ; +int queue_id, r, i; +u32 db_array[4 ]; + +if (db_array_size >4 ) { +dev_err (adev->dev,"DB array size (%d vs 4) too small\n" , + db_array_size); +return -EINVAL ; + } + +memset (&input,0x0 ,sizeof (struct +mes_detect_and_reset_queue_input )); + + input.queue_type = queue_type; + +amdgpu_mes_lock (&adev->mes); + r =amdgpu_mes_detect_and_reset_hung_queues (adev, queue_type, false, + &hung_db_num, db_array); +amdgpu_mes_unlock (&adev->mes); +if (r) { +dev_err (adev->dev,"Failed to detect and reset queues, err (%d)\n" , r); + }else if (hung_db_num) { +mutex_lock (&adev->userq_mutex); +list_for_each_entry_safe (uqm, tmp, &adev->userq_mgr_list, list) { +idr_for_each_entry (&uqm->userq_idr, queue, queue_id) {Quoted 8 lines
drivers/gpu/drm/amd/amdgpu/mes_userqueue.c static int mes_userq_create_ctx_space(struct amdgpu_userq_mgr *uq_mgr,
Quoted 5 lines
drivers/gpu/drm/amd/amdgpu/mes_userqueue.c +5
-0+if (queue->queue_type == queue_type) { +for (i =0 ; i < hung_db_num; i++) { +if (queue->doorbell_index == db_array[i]) { + queue->state = +AMDGPU_USERQ_STATE_HUNG ;After a reset and force completion of work, why is the queue state maintained as hung? Does that mean no more work can be submitted even after reset? Where is this state checked?
Detect and reset will be called at umap, and if the queue is hung, umap will be skipped.
Quoted 3 lines
Ok, this doesn't match with the inferred meaning of amdgpu_mes_detect_and_*reset_hung_queues*. The API name gives the impression that queue is reset and now it can be used to submit other work. If the queue is not useful after a reset, why not remove it from the list of active queues?
This API detects the hang queues and resets them,
To clarify my question -
After reset, are the queues usable? If the queues are usable, then a
user can continue to submit jobs and later submit a free to unmap. But the above code marks the queue as hung. If so, what is the purpose of reset? I see a detect only mode also which indicates detection of hung queues (without any reset).
I believe unmap is not the only case where this API is called.
Quoted 1 line
and returns the detected hang queues.
Is it like FW detects (X + Y) hung queues of which X queues could be reset and Y queues could not be reset. Hence it returns the details of Y queues?
Quoted 1 line
Queue removal is done when the user calls
AMDGPU_USERQ_OP_FREE.
Thanks,
Lijo
Quoted 37 lines
Thanks
JesseThanks,
LijoQuoted 30 lines
Thanks
JesseThanks,
LijoQuoted 23 lines
drivers/gpu/drm/amd/amdgpu/mes_userqueue.c +15
-1+atomic_inc (&adev->gpu_reset_counter); +amdgpu_userq_fence_driver_force_completion (queue); +drm_dev_wedged_event (adev_to_drm (adev),DRM_WEDGE_RECOVERY_NONE ); + } + } + } + } + } +mutex_unlock (&adev->userq_mutex); + } + +return r; +} +static int mes_userq_mqd_create (struct amdgpu_userq_mgr *uq_mgr,struct drm_amdgpu_userq_in *args_in, struct amdgpu_usermode_queue *queue) @@ -352,4 +402,5 @@ const struct amdgpu_userq_funcs userq_mes_funcs = { .mqd_destroy = mes_userq_mqd_destroy, .unmap = mes_userq_unmap, .map = mes_userq_map, + .detect_and_reset = mes_userq_detect_and_reset, };
RE: [v3 8/9] drm/amdgpu/userq: add a detect and reset callback
[AMD Official Use Only - AMD Internal Distribution Only]
-----Original Message-----
From: Lazar, Lijo <[email protected]>
Sent: Wednesday, June 18, 2025 5:56 PM
To: Zhang, Jesse(Jie) <[email protected]>; [email protected]
Cc: Deucher, Alexander <[email protected]>; Koenig, Christian <[email protected]>
Subject: Re: [v3 8/9] drm/amdgpu/userq: add a detect and reset callback
Quoted 117 lines · Jesse(Jie)
[AMD Official Use Only - AMD Internal Distribution Only]
-----Original Message-----
From: Lazar, Lijo <[email protected]>
Sent: Wednesday, June 18, 2025 12:14 PM
To: Zhang, Jesse(Jie) <[email protected]>; [email protected]
Cc: Deucher, Alexander <[email protected]>; Koenig, Christian <[email protected]>
Subject: Re: [v3 8/9] drm/amdgpu/userq: add a detect and reset callbackQuoted 93 lines · Jesse(Jie)
[AMD Official Use Only - AMD Internal Distribution Only]
-----Original Message-----
From: Lazar, Lijo <[email protected]>
Sent: Tuesday, June 17, 2025 5:57 PM
To: Zhang, Jesse(Jie) <[email protected]>; [email protected]
Cc: Deucher, Alexander <[email protected]>; Koenig, Christian <[email protected]>
Subject: Re: [v3 8/9] drm/amdgpu/userq: add a detect and reset callbackQuoted 78 lines · Jesse.Zhang
From: Alex Deucher <[email protected]>
Add a detect and reset callback and add the implementation for mes. The callback will detect all hung queues of a particular ip type (e.g., GFX or compute or SDMA) and reset them.
v2: increase reset counter and set fence force completion (Jesse)
Signed-off-by Alex Deucher <[email protected]>--- drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h | 3 ++ drivers/gpu/drm/amd/amdgpu/mes_userqueue.c | 51 ++++++++++++++++++++++ 2 files changed, 54 insertions(+)drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h +3
-0@@ -77,6 +77,9 @@ struct amdgpu_userq_funcs { struct amdgpu_usermode_queue *queue);int (*map)(struct amdgpu_userq_mgr *uq_mgr,struct amdgpu_usermode_queue *queue); +int (*detect_and_reset)(struct amdgpu_device *adev, +int queue_type); + };/* Usermode queues for gfx */ drivers/gpu/drm/amd/amdgpu/mes_userqueue.c +32
-0@@ -21,6 +21,7 @@* OTHER DEALINGS IN THE SOFTWARE. * */ +#include <drm/drm_drv.h> #include "amdgpu.h" #include "amdgpu_gfx.h" #include "mes_userqueue.h" @@ -198,6 +199,55 @@ static int mes_userq_create_ctx_space(struct amdgpu_userq_mgr *uq_mgr,return 0 ; } +static int mes_userq_detect_and_reset (struct amdgpu_device *adev, +int queue_type) { +int db_array_size =amdgpu_mes_get_hung_queue_db_array_size (adev); +struct mes_detect_and_reset_queue_input input; +struct amdgpu_usermode_queue *queue; +struct amdgpu_userq_mgr *uqm, *tmp; +unsigned int hung_db_num =0 ; +int queue_id, r, i; +u32 db_array[4 ]; + +if (db_array_size >4 ) { +dev_err (adev->dev,"DB array size (%d vs 4) too small\n" , + db_array_size); +return -EINVAL ; + } + +memset (&input,0x0 ,sizeof (struct +mes_detect_and_reset_queue_input )); + + input.queue_type = queue_type; + +amdgpu_mes_lock (&adev->mes); + r =amdgpu_mes_detect_and_reset_hung_queues (adev, queue_type, false, + &hung_db_num, db_array); +amdgpu_mes_unlock (&adev->mes); +if (r) { +dev_err (adev->dev,"Failed to detect and reset queues, err (%d)\n" , r); + }else if (hung_db_num) { +mutex_lock (&adev->userq_mutex); +list_for_each_entry_safe (uqm, tmp, &adev->userq_mgr_list, list) { +idr_for_each_entry (&uqm->userq_idr, queue, queue_id) {Quoted 8 lines
drivers/gpu/drm/amd/amdgpu/mes_userqueue.c static int mes_userq_create_ctx_space(struct amdgpu_userq_mgr *uq_mgr,
Quoted 5 lines
drivers/gpu/drm/amd/amdgpu/mes_userqueue.c +5
-0+if (queue->queue_type == queue_type) { +for (i =0 ; i < hung_db_num; i++) { +if (queue->doorbell_index == db_array[i]) { + queue->state = +AMDGPU_USERQ_STATE_HUNG ;After a reset and force completion of work, why is the queue state maintained as hung? Does that mean no more work can be submitted even after reset? Where is this state checked?
Detect and reset will be called at umap, and if the queue is hung, umap will be skipped.
Quoted 3 lines
Ok, this doesn't match with the inferred meaning of amdgpu_mes_detect_and_*reset_hung_queues*. The API name gives the impression that queue is reset and now it can be used to submit other work. If the queue is not useful after a reset, why not remove it from the list of active queues?
This API detects the hang queues and resets them,
To clarify my question -
After reset, are the queues usable? If the queues are usable, then a user can continue to submit jobs and later submit a free to unmap. But the above code marks the queue as hung. If so, what is the purpose of reset? I see a detect only mode also which indicates detection of hung queues (without any reset).
Mask its state as hang to let the user space know which queue hanged. Otherwise, the user space does not know which queue is hanged. (got this from Alex)
I believe unmap is not the only case where this API is called.
Quoted 1 line
and returns the detected hang queues.
Is it like FW detects (X + Y) hung queues of which X queues could be reset and Y queues could not be reset. Hence it returns the details of Y queues?
Right.
Thanks
Jesse
Quoted 1 line
Queue removal is done when the user calls
AMDGPU_USERQ_OP_FREE.
Thanks,
Lijo
Quoted 38 lines
Thanks
JesseThanks,
LijoQuoted 31 lines
Thanks
JesseThanks,
LijoQuoted 24 lines
drivers/gpu/drm/amd/amdgpu/mes_userqueue.c +14
-0+atomic_inc (&adev->gpu_reset_counter); +amdgpu_userq_fence_driver_force_completion (queue); +drm_dev_wedged_event (adev_to_drm (adev),DRM_WEDGE_RECOVERY_NONE ); + } + } + } + } + } +mutex_unlock (&adev->userq_mutex); + } + +return r; +} +static int mes_userq_mqd_create (struct amdgpu_userq_mgr *uq_mgr,struct drm_amdgpu_userq_in *args_in,struct amdgpu_usermode_queue *queue)@@
-352,4 +402,5 @@ const structamdgpu_userq_funcsuserq_mes_funcs= {
.mqd_destroy =mes_userq_mqd_destroy,
.unmap =mes_userq_unmap,
.map =mes_userq_map,
+ .detect_and_reset =mes_userq_detect_and_reset,
};
PATCH v3 9/9 drm/amdgpu: implements detect and reset
In reply to Jesse.ZhangFrom: Alex Deucher <[email protected]>
If map or unmap fails, or a user fence times out schedule a GPU reset directly.
v2: drop detect and reset, call GPU reset directly (Alex)
--- drivers/gpu/drm/amd/amdgpu/amdgpu.h | 1 + drivers/gpu/drm/amd/amdgpu/amdgpu_device.c | 8 ++ drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c | 128 +++++++++++++++++++-- drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h | 5 + 4 files changed, 131 insertions(+), 11 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu.h +1 -0
@@ -1304,6 +1304,7 @@ struct amdgpu_device {struct list_head userq_mgr_list;struct mutex userq_mutex;bool userq_halt_for_enforce_isolation; +struct work_struct userq_reset_work; }; static inline uint32_t amdgpu_ip_version(const struct amdgpu_device *adev,
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +8 -0
@@ -4432,6 +4432,7 @@ int amdgpu_device_init(struct amdgpu_device *adev, }INIT_WORK (&adev->xgmi_reset_work, amdgpu_device_xgmi_reset_func); +INIT_WORK (&adev->userq_reset_work, amdgpu_userq_reset_work); adev->gfx.gfx_off_req_count =1 ; adev->gfx.gfx_off_residency =0 ;
@@ -5828,6 +5829,10 @@ int amdgpu_device_reinit_after_reset(struct amdgpu_reset_context *reset_context)if (r) goto out; + r =amdgpu_userq_post_reset (tmp_adev, vram_lost); +if (r) + goto out; +drm_client_dev_resume (adev_to_drm (tmp_adev), false);/*
@@ -6050,6 +6055,7 @@ static inline void amdgpu_device_stop_pending_resets(struct amdgpu_device *adev)if (!amdgpu_sriov_vf (adev))cancel_work (&adev->reset_work);#endif +cancel_work (&adev->userq_reset_work);if (adev->kfd.dev)cancel_work (&adev->kfd.reset_work);
@@ -6160,6 +6166,8 @@ static int amdgpu_device_halt_activities(struct amdgpu_device *adev, amdgpu_device_ip_need_full_reset(tmp_adev))amdgpu_ras_suspend (tmp_adev); +amdgpu_userq_pre_reset (tmp_adev); +for (i =0 ; i <AMDGPU_MAX_RINGS ; ++i) {struct amdgpu_ring *ring = tmp_adev->rings[i];
drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c +117 -11
222 lines not on this page · raw message
drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h +5 -0
@@ -135,4 +135,9 @@ int amdgpu_userq_stop_sched_for_enforce_isolation(struct amdgpu_device *adev,int amdgpu_userq_start_sched_for_enforce_isolation (struct amdgpu_device *adev,u32 idx); +void amdgpu_userq_reset_work (struct work_struct *work); + +void amdgpu_userq_pre_reset (struct amdgpu_device *adev); +int amdgpu_userq_post_reset (struct amdgpu_device *adev,bool vram_lost); +#endif
Signature · 1 line
2.49.0
Re: [v3 9/9] drm/amdgpu: implements detect and reset
Quoted 171 lines · Jesse.Zhang
From: Alex Deucher <[email protected]>
If map or unmap fails, or a user fence times out schedule a GPU reset directly.
v2: drop detect and reset, call GPU reset directly (Alex)
Signed-off-by Alex Deucher <[email protected]>Signed-off-by Jesse Zhang <[email protected]>--- drivers/gpu/drm/amd/amdgpu/amdgpu.h | 1 + drivers/gpu/drm/amd/amdgpu/amdgpu_device.c | 8 ++ drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c | 128 +++++++++++++++++++-- drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h | 5 + 4 files changed, 131 insertions(+), 11 deletions(-)drivers/gpu/drm/amd/amdgpu/amdgpu.h +1
-0@@ -1304,6 +1304,7 @@ struct amdgpu_device {struct list_head userq_mgr_list;struct mutex userq_mutex;bool userq_halt_for_enforce_isolation; +struct work_struct userq_reset_work; }; static inline uint32_t amdgpu_ip_version(const struct amdgpu_device *adev,drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +8
-0@@ -4432,6 +4432,7 @@ int amdgpu_device_init(struct amdgpu_device *adev, }INIT_WORK (&adev->xgmi_reset_work, amdgpu_device_xgmi_reset_func); +INIT_WORK (&adev->userq_reset_work, amdgpu_userq_reset_work); adev->gfx.gfx_off_req_count =1 ; adev->gfx.gfx_off_residency =0 ;@@ -5828,6 +5829,10 @@ int amdgpu_device_reinit_after_reset(struct amdgpu_reset_context *reset_context)if (r) goto out; + r =amdgpu_userq_post_reset (tmp_adev, vram_lost); +if (r) + goto out; +drm_client_dev_resume (adev_to_drm (tmp_adev), false);/* @@ -6050,6 +6055,7 @@ static inline void amdgpu_device_stop_pending_resets(struct amdgpu_device *adev)if (!amdgpu_sriov_vf (adev))cancel_work (&adev->reset_work);#endif +cancel_work (&adev->userq_reset_work);if (adev->kfd.dev)cancel_work (&adev->kfd.reset_work);@@ -6160,6 +6166,8 @@ static int amdgpu_device_halt_activities(struct amdgpu_device *adev, amdgpu_device_ip_need_full_reset(tmp_adev))amdgpu_ras_suspend (tmp_adev); +amdgpu_userq_pre_reset (tmp_adev); +for (i =0 ; i <AMDGPU_MAX_RINGS ; ++i) {struct amdgpu_ring *ring = tmp_adev->rings[i];drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c +51
-2@@ -26,7 +26,10 @@#include <drm/drm_exec.h> #include <linux/pm_runtime.h> +#include <drm/drm_drv.h> +#include "amdgpu.h" +#include "amdgpu_reset.h" #include "amdgpu_vm.h" #include "amdgpu_userq.h" #include "amdgpu_userq_fence.h" @@ -44,6 +47,39 @@ u32 amdgpu_userq_get_supported_ip_mask(struct amdgpu_device *adev)return userq_ip_mask; } +static void amdgpu_userq_gpu_reset (struct amdgpu_device *adev) +{ + +if (amdgpu_device_should_recover_gpu (adev)) +amdgpu_reset_domain_schedule (adev->reset_domain, + &adev->userq_reset_work); +} + +static bool +amdgpu_userq_detect_and_reset_queues (struct amdgpu_userq_mgr *uq_mgr) +{ +struct amdgpu_device *adev = uq_mgr->adev; +const struct amdgpu_userq_funcs *userq_gfx_funcs = + adev->userq_funcs[AMDGPU_RING_TYPE_GFX ]; + +if (!!idr_is_empty (&uq_mgr->userq_idr)) +return false; + +if (unlikely (adev->debug_disable_gpu_ring_reset)) { +dev_err (adev->dev,"userq reset disabled by debug mask\n" ); + }else if (amdgpu_gpu_recovery) { +if (userq_gfx_funcs->detect_and_reset) { +if (userq_gfx_funcs->detect_and_reset (adev,AMDGPU_RING_TYPE_GFX )) { +amdgpu_userq_gpu_reset (adev); +return true; + } + } +//TODO: support compute user queue detect and reset. + } + +return false; +} +static int amdgpu_userq_unmap_helper (struct amdgpu_userq_mgr *uq_mgr,struct amdgpu_usermode_queue *queue)@@ -51,15 +87,22 @@ amdgpu_userq_unmap_helper(struct amdgpu_userq_mgr *uq_mgr,struct amdgpu_device *adev = uq_mgr->adev;const struct amdgpu_userq_funcs *userq_funcs = adev->userq_funcs[queue->queue_type]; +bool gpu_reset = false;int r =0 ;if (queue->state ==AMDGPU_USERQ_STATE_MAPPED ) { r = userq_funcs->unmap (uq_mgr, queue); -if (r) +if (r) { queue->state =AMDGPU_USERQ_STATE_HUNG ; -else + gpu_reset = true; + }else { queue->state =AMDGPU_USERQ_STATE_UNMAPPED ; + } } + +if (gpu_reset) +amdgpu_userq_gpu_reset (adev); +return r; }@@ -70,16 +113,22 @@ amdgpu_userq_map_helper(struct amdgpu_userq_mgr *uq_mgr,struct amdgpu_device *adev = uq_mgr->adev;const struct amdgpu_userq_funcs *userq_funcs = adev->userq_funcs[queue->queue_type]; +bool gpu_reset = false;int r =0 ;if (queue->state ==AMDGPU_USERQ_STATE_UNMAPPED ) { r = userq_funcs->map (uq_mgr, queue);if (r) { queue->state =AMDGPU_USERQ_STATE_HUNG ; + gpu_reset = true; }else { queue->state =AMDGPU_USERQ_STATE_MAPPED ; } } + +if (gpu_reset) +amdgpu_userq_gpu_reset (adev); +return r; }
drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c amdgpu_userq_destroy(struct drm_file *filp, int queue_id) · line 370
Quoted 4 lines
drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c +1
-0@@ -318,6 +367,7 @@ amdgpu_userq_destroy(struct drm_file *filp, int queue_id)amdgpu_bo_unreserve (queue->db_obj.obj); }amdgpu_bo_unref (&queue->db_obj.obj); +amdgpu_userq_detect_and_reset_queues (uq_mgr);
Is this the intended place to call this? Or, try unmap and if it fails try user queue reset/ or fall back to device reset.
Also, amdgpu_userq_gpu_reset() could be scheduling a device reset. From what I see, here and at all other places caller proceeds without checking the return/waiting for the device reset to be complete. Is that also intentional?
Thanks,
Lijo
Quoted 144 lines
drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c +65
-9r =amdgpu_userq_unmap_helper (uq_mgr, queue);amdgpu_userq_cleanup (uq_mgr, queue, queue_id);mutex_unlock (&uq_mgr->userq_mutex);@@ -691,6 +741,7 @@ amdgpu_userq_evict_all(struct amdgpu_userq_mgr *uq_mgr)int queue_id;int ret =0 , r; +amdgpu_userq_detect_and_reset_queues (uq_mgr);/* Try to unmap all the queues in this process ctx */ idr_for_each_entry (&uq_mgr->userq_idr, queue, queue_id) { r =amdgpu_userq_unmap_helper (uq_mgr, queue);@@ -703,6 +754,23 @@ amdgpu_userq_evict_all(struct amdgpu_userq_mgr *uq_mgr)return ret; } +void amdgpu_userq_reset_work (struct work_struct *work) +{ + struct amdgpu_device *adev = container_of(work, struct amdgpu_device, + userq_reset_work); +struct amdgpu_reset_context reset_context; + +memset (&reset_context,0 ,sizeof (reset_context)); + + reset_context.method =AMD_RESET_METHOD_NONE ; + reset_context.reset_req_dev = adev; + reset_context.src =AMDGPU_RESET_SRC_USERQ ; +set_bit (AMDGPU_NEED_FULL_RESET , &reset_context.flags); +/*set_bit(AMDGPU_SKIP_COREDUMP, &reset_context.flags);*/ + +amdgpu_device_gpu_recover (adev,NULL , &reset_context); +} +static int amdgpu_userq_wait_for_signal (struct amdgpu_userq_mgr *uq_mgr) {@@ -729,22 +797,19 @@ void amdgpu_userq_evict(struct amdgpu_userq_mgr *uq_mgr, struct amdgpu_eviction_fence *ev_fence) { - int ret; struct amdgpu_fpriv *fpriv = uq_mgr_to_fpriv(uq_mgr);struct amdgpu_eviction_fence_mgr *evf_mgr = &fpriv->evf_mgr; +struct amdgpu_device *adev = uq_mgr->adev; +int ret;/* Wait for any pending userqueue fence work to finish */ ret =amdgpu_userq_wait_for_signal (uq_mgr); -if (ret) { -drm_file_err (uq_mgr->file,"Not evicting userqueue, timeout waiting for work\n" ); -return ; - } +if (ret) +dev_err (adev->dev,"Not evicting userqueue, timeout waiting for work\n" ); ret =amdgpu_userq_evict_all (uq_mgr); -if (ret) { -drm_file_err (uq_mgr->file,"Failed to evict userqueue\n" ); -return ; - } +if (ret) +dev_err (adev->dev,"Failed to evict userqueue\n" );/* Signal current eviction fence */ amdgpu_eviction_fence_signal (evf_mgr, ev_fence);@@ -785,6 +850,7 @@ void amdgpu_userq_mgr_fini(struct amdgpu_userq_mgr *userq_mgr)mutex_lock (&adev->userq_mutex);mutex_lock (&userq_mgr->userq_mutex); +amdgpu_userq_detect_and_reset_queues (userq_mgr);idr_for_each_entry (&userq_mgr->userq_idr, queue, queue_id) {amdgpu_userq_wait_for_last_fence (userq_mgr, queue);amdgpu_userq_unmap_helper (userq_mgr, queue);@@ -818,6 +884,7 @@ int amdgpu_userq_suspend(struct amdgpu_device *adev)list_for_each_entry_safe (uqm, tmp, &adev->userq_mgr_list, list) {cancel_delayed_work_sync (&uqm->resume_work);mutex_lock (&uqm->userq_mutex); +amdgpu_userq_detect_and_reset_queues (uqm);idr_for_each_entry (&uqm->userq_idr, queue, queue_id) { r =amdgpu_userq_unmap_helper (uqm, queue);if (r)@@ -874,6 +941,7 @@ int amdgpu_userq_stop_sched_for_enforce_isolation(struct amdgpu_device *adev,list_for_each_entry_safe (uqm, tmp, &adev->userq_mgr_list, list) {cancel_delayed_work_sync (&uqm->resume_work);mutex_lock (&uqm->userq_mutex); +amdgpu_userq_detect_and_reset_queues (uqm);idr_for_each_entry (&uqm->userq_idr, queue, queue_id) { if (((queue->queue_type == AMDGPU_HW_IP_GFX) || (queue->queue_type == AMDGPU_HW_IP_COMPUTE)) &&@@ -922,3 +990,41 @@ int amdgpu_userq_start_sched_for_enforce_isolation(struct amdgpu_device *adev,mutex_unlock (&adev->userq_mutex);return ret; } + +void amdgpu_userq_pre_reset (struct amdgpu_device *adev) +{ +const struct amdgpu_userq_funcs *userq_funcs; +struct amdgpu_usermode_queue *queue; +struct amdgpu_userq_mgr *uqm, *tmp; +int queue_id; + +mutex_lock (&adev->userq_mutex); +list_for_each_entry_safe (uqm, tmp, &adev->userq_mgr_list, list) { +cancel_delayed_work_sync (&uqm->resume_work); +mutex_lock (&uqm->userq_mutex); +idr_for_each_entry (&uqm->userq_idr, queue, queue_id) { +if (queue->state ==AMDGPU_USERQ_STATE_MAPPED ) { +amdgpu_userq_wait_for_last_fence (uqm, queue); + userq_funcs = adev->userq_funcs[queue->queue_type]; + userq_funcs->unmap (uqm, queue); +/* just mark all queues as hung at this point. +* if unmap succeeds, we could map again +* in amdgpu_userq_post_reset() if vram is not lost +*/ + queue->state =AMDGPU_USERQ_STATE_HUNG ; +amdgpu_userq_fence_driver_force_completion (queue); + } + } +mutex_unlock (&uqm->userq_mutex); + } +mutex_unlock (&adev->userq_mutex); +} + +int amdgpu_userq_post_reset (struct amdgpu_device *adev,bool vram_lost) +{ +/* if any queue state is AMDGPU_USERQ_STATE_UNMAPPED +* at this point, we should be able to map it again +* and continue if vram is not lost. +*/ +return 0 ; +}drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h +5
-0@@ -135,4 +135,9 @@ int amdgpu_userq_stop_sched_for_enforce_isolation(struct amdgpu_device *adev,int amdgpu_userq_start_sched_for_enforce_isolation (struct amdgpu_device *adev,u32 idx); +void amdgpu_userq_reset_work (struct work_struct *work); + +void amdgpu_userq_pre_reset (struct amdgpu_device *adev); +int amdgpu_userq_post_reset (struct amdgpu_device *adev,bool vram_lost); +#endif
Re: [v3 9/9] drm/amdgpu: implements detect and reset
In reply to Jesse.ZhangQuoted 171 lines · Jesse.Zhang
From: Alex Deucher <[email protected]>
If map or unmap fails, or a user fence times out schedule a GPU reset directly.
v2: drop detect and reset, call GPU reset directly (Alex)
Signed-off-by Alex Deucher <[email protected]>Signed-off-by Jesse Zhang <[email protected]>--- drivers/gpu/drm/amd/amdgpu/amdgpu.h | 1 + drivers/gpu/drm/amd/amdgpu/amdgpu_device.c | 8 ++ drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c | 128 +++++++++++++++++++-- drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h | 5 + 4 files changed, 131 insertions(+), 11 deletions(-)drivers/gpu/drm/amd/amdgpu/amdgpu.h +1
-0@@ -1304,6 +1304,7 @@ struct amdgpu_device {struct list_head userq_mgr_list;struct mutex userq_mutex;bool userq_halt_for_enforce_isolation; +struct work_struct userq_reset_work; }; static inline uint32_t amdgpu_ip_version(const struct amdgpu_device *adev,drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +8
-0@@ -4432,6 +4432,7 @@ int amdgpu_device_init(struct amdgpu_device *adev, }INIT_WORK (&adev->xgmi_reset_work, amdgpu_device_xgmi_reset_func); +INIT_WORK (&adev->userq_reset_work, amdgpu_userq_reset_work); adev->gfx.gfx_off_req_count =1 ; adev->gfx.gfx_off_residency =0 ;@@ -5828,6 +5829,10 @@ int amdgpu_device_reinit_after_reset(struct amdgpu_reset_context *reset_context)if (r) goto out; + r =amdgpu_userq_post_reset (tmp_adev, vram_lost); +if (r) + goto out; +drm_client_dev_resume (adev_to_drm (tmp_adev), false);/* @@ -6050,6 +6055,7 @@ static inline void amdgpu_device_stop_pending_resets(struct amdgpu_device *adev)if (!amdgpu_sriov_vf (adev))cancel_work (&adev->reset_work);#endif +cancel_work (&adev->userq_reset_work);if (adev->kfd.dev)cancel_work (&adev->kfd.reset_work);@@ -6160,6 +6166,8 @@ static int amdgpu_device_halt_activities(struct amdgpu_device *adev, amdgpu_device_ip_need_full_reset(tmp_adev))amdgpu_ras_suspend (tmp_adev); +amdgpu_userq_pre_reset (tmp_adev); +for (i =0 ; i <AMDGPU_MAX_RINGS ; ++i) {struct amdgpu_ring *ring = tmp_adev->rings[i];drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c +51
-2@@ -26,7 +26,10 @@#include <drm/drm_exec.h> #include <linux/pm_runtime.h> +#include <drm/drm_drv.h> +#include "amdgpu.h" +#include "amdgpu_reset.h" #include "amdgpu_vm.h" #include "amdgpu_userq.h" #include "amdgpu_userq_fence.h" @@ -44,6 +47,39 @@ u32 amdgpu_userq_get_supported_ip_mask(struct amdgpu_device *adev)return userq_ip_mask; } +static void amdgpu_userq_gpu_reset (struct amdgpu_device *adev) +{ + +if (amdgpu_device_should_recover_gpu (adev)) +amdgpu_reset_domain_schedule (adev->reset_domain, + &adev->userq_reset_work); +} + +static bool +amdgpu_userq_detect_and_reset_queues (struct amdgpu_userq_mgr *uq_mgr) +{ +struct amdgpu_device *adev = uq_mgr->adev; +const struct amdgpu_userq_funcs *userq_gfx_funcs = + adev->userq_funcs[AMDGPU_RING_TYPE_GFX ]; + +if (!!idr_is_empty (&uq_mgr->userq_idr)) +return false; + +if (unlikely (adev->debug_disable_gpu_ring_reset)) { +dev_err (adev->dev,"userq reset disabled by debug mask\n" ); + }else if (amdgpu_gpu_recovery) { +if (userq_gfx_funcs->detect_and_reset) { +if (userq_gfx_funcs->detect_and_reset (adev,AMDGPU_RING_TYPE_GFX )) { +amdgpu_userq_gpu_reset (adev); +return true; + } + } +//TODO: support compute user queue detect and reset. + } + +return false; +} +static int amdgpu_userq_unmap_helper (struct amdgpu_userq_mgr *uq_mgr,struct amdgpu_usermode_queue *queue)@@ -51,15 +87,22 @@ amdgpu_userq_unmap_helper(struct amdgpu_userq_mgr *uq_mgr,struct amdgpu_device *adev = uq_mgr->adev;const struct amdgpu_userq_funcs *userq_funcs = adev->userq_funcs[queue->queue_type]; +bool gpu_reset = false;int r =0 ;if (queue->state ==AMDGPU_USERQ_STATE_MAPPED ) { r = userq_funcs->unmap (uq_mgr, queue); -if (r) +if (r) { queue->state =AMDGPU_USERQ_STATE_HUNG ; -else + gpu_reset = true; + }else { queue->state =AMDGPU_USERQ_STATE_UNMAPPED ; + } } + +if (gpu_reset) +amdgpu_userq_gpu_reset (adev); +return r; }@@ -70,16 +113,22 @@ amdgpu_userq_map_helper(struct amdgpu_userq_mgr *uq_mgr,struct amdgpu_device *adev = uq_mgr->adev;const struct amdgpu_userq_funcs *userq_funcs = adev->userq_funcs[queue->queue_type]; +bool gpu_reset = false;int r =0 ;if (queue->state ==AMDGPU_USERQ_STATE_UNMAPPED ) { r = userq_funcs->map (uq_mgr, queue);if (r) { queue->state =AMDGPU_USERQ_STATE_HUNG ; + gpu_reset = true; }else { queue->state =AMDGPU_USERQ_STATE_MAPPED ; } } + +if (gpu_reset) +amdgpu_userq_gpu_reset (adev); +return r; }
drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c amdgpu_userq_destroy(struct drm_file *filp, int queue_id) · line 370
Quoted 4 lines
drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c +1
-0@@ -318,6 +367,7 @@ amdgpu_userq_destroy(struct drm_file *filp, int queue_id)amdgpu_bo_unreserve (queue->db_obj.obj); }amdgpu_bo_unref (&queue->db_obj.obj); +amdgpu_userq_detect_and_reset_queues (uq_mgr);
Is this the intended place to call this? Or, try unmap and if it fails try user queue reset/ or fall back to device reset.
Also, amdgpu_userq_detect_and_reset_queues() could be scheduling a device reset. From what I see, here and at all other places caller proceeds without checking the return/waiting for the device reset to be complete. Is that also intentional?
Thanks,
Lijo
Quoted 144 lines
drivers/gpu/drm/amd/amdgpu/amdgpu_userq.c +65
-9r =amdgpu_userq_unmap_helper (uq_mgr, queue);amdgpu_userq_cleanup (uq_mgr, queue, queue_id);mutex_unlock (&uq_mgr->userq_mutex);@@ -691,6 +741,7 @@ amdgpu_userq_evict_all(struct amdgpu_userq_mgr *uq_mgr)int queue_id;int ret =0 , r; +amdgpu_userq_detect_and_reset_queues (uq_mgr);/* Try to unmap all the queues in this process ctx */ idr_for_each_entry (&uq_mgr->userq_idr, queue, queue_id) { r =amdgpu_userq_unmap_helper (uq_mgr, queue);@@ -703,6 +754,23 @@ amdgpu_userq_evict_all(struct amdgpu_userq_mgr *uq_mgr)return ret; } +void amdgpu_userq_reset_work (struct work_struct *work) +{ + struct amdgpu_device *adev = container_of(work, struct amdgpu_device, + userq_reset_work); +struct amdgpu_reset_context reset_context; + +memset (&reset_context,0 ,sizeof (reset_context)); + + reset_context.method =AMD_RESET_METHOD_NONE ; + reset_context.reset_req_dev = adev; + reset_context.src =AMDGPU_RESET_SRC_USERQ ; +set_bit (AMDGPU_NEED_FULL_RESET , &reset_context.flags); +/*set_bit(AMDGPU_SKIP_COREDUMP, &reset_context.flags);*/ + +amdgpu_device_gpu_recover (adev,NULL , &reset_context); +} +static int amdgpu_userq_wait_for_signal (struct amdgpu_userq_mgr *uq_mgr) {@@ -729,22 +797,19 @@ void amdgpu_userq_evict(struct amdgpu_userq_mgr *uq_mgr, struct amdgpu_eviction_fence *ev_fence) { - int ret; struct amdgpu_fpriv *fpriv = uq_mgr_to_fpriv(uq_mgr);struct amdgpu_eviction_fence_mgr *evf_mgr = &fpriv->evf_mgr; +struct amdgpu_device *adev = uq_mgr->adev; +int ret;/* Wait for any pending userqueue fence work to finish */ ret =amdgpu_userq_wait_for_signal (uq_mgr); -if (ret) { -drm_file_err (uq_mgr->file,"Not evicting userqueue, timeout waiting for work\n" ); -return ; - } +if (ret) +dev_err (adev->dev,"Not evicting userqueue, timeout waiting for work\n" ); ret =amdgpu_userq_evict_all (uq_mgr); -if (ret) { -drm_file_err (uq_mgr->file,"Failed to evict userqueue\n" ); -return ; - } +if (ret) +dev_err (adev->dev,"Failed to evict userqueue\n" );/* Signal current eviction fence */ amdgpu_eviction_fence_signal (evf_mgr, ev_fence);@@ -785,6 +850,7 @@ void amdgpu_userq_mgr_fini(struct amdgpu_userq_mgr *userq_mgr)mutex_lock (&adev->userq_mutex);mutex_lock (&userq_mgr->userq_mutex); +amdgpu_userq_detect_and_reset_queues (userq_mgr);idr_for_each_entry (&userq_mgr->userq_idr, queue, queue_id) {amdgpu_userq_wait_for_last_fence (userq_mgr, queue);amdgpu_userq_unmap_helper (userq_mgr, queue);@@ -818,6 +884,7 @@ int amdgpu_userq_suspend(struct amdgpu_device *adev)list_for_each_entry_safe (uqm, tmp, &adev->userq_mgr_list, list) {cancel_delayed_work_sync (&uqm->resume_work);mutex_lock (&uqm->userq_mutex); +amdgpu_userq_detect_and_reset_queues (uqm);idr_for_each_entry (&uqm->userq_idr, queue, queue_id) { r =amdgpu_userq_unmap_helper (uqm, queue);if (r)@@ -874,6 +941,7 @@ int amdgpu_userq_stop_sched_for_enforce_isolation(struct amdgpu_device *adev,list_for_each_entry_safe (uqm, tmp, &adev->userq_mgr_list, list) {cancel_delayed_work_sync (&uqm->resume_work);mutex_lock (&uqm->userq_mutex); +amdgpu_userq_detect_and_reset_queues (uqm);idr_for_each_entry (&uqm->userq_idr, queue, queue_id) { if (((queue->queue_type == AMDGPU_HW_IP_GFX) || (queue->queue_type == AMDGPU_HW_IP_COMPUTE)) &&@@ -922,3 +990,41 @@ int amdgpu_userq_start_sched_for_enforce_isolation(struct amdgpu_device *adev,mutex_unlock (&adev->userq_mutex);return ret; } + +void amdgpu_userq_pre_reset (struct amdgpu_device *adev) +{ +const struct amdgpu_userq_funcs *userq_funcs; +struct amdgpu_usermode_queue *queue; +struct amdgpu_userq_mgr *uqm, *tmp; +int queue_id; + +mutex_lock (&adev->userq_mutex); +list_for_each_entry_safe (uqm, tmp, &adev->userq_mgr_list, list) { +cancel_delayed_work_sync (&uqm->resume_work); +mutex_lock (&uqm->userq_mutex); +idr_for_each_entry (&uqm->userq_idr, queue, queue_id) { +if (queue->state ==AMDGPU_USERQ_STATE_MAPPED ) { +amdgpu_userq_wait_for_last_fence (uqm, queue); + userq_funcs = adev->userq_funcs[queue->queue_type]; + userq_funcs->unmap (uqm, queue); +/* just mark all queues as hung at this point. +* if unmap succeeds, we could map again +* in amdgpu_userq_post_reset() if vram is not lost +*/ + queue->state =AMDGPU_USERQ_STATE_HUNG ; +amdgpu_userq_fence_driver_force_completion (queue); + } + } +mutex_unlock (&uqm->userq_mutex); + } +mutex_unlock (&adev->userq_mutex); +} + +int amdgpu_userq_post_reset (struct amdgpu_device *adev,bool vram_lost) +{ +/* if any queue state is AMDGPU_USERQ_STATE_UNMAPPED +* at this point, we should be able to map it again +* and continue if vram is not lost. +*/ +return 0 ; +}drivers/gpu/drm/amd/amdgpu/amdgpu_userq.h +5
-0@@ -135,4 +135,9 @@ int amdgpu_userq_stop_sched_for_enforce_isolation(struct amdgpu_device *adev,int amdgpu_userq_start_sched_for_enforce_isolation (struct amdgpu_device *adev,u32 idx); +void amdgpu_userq_reset_work (struct work_struct *work); + +void amdgpu_userq_pre_reset (struct amdgpu_device *adev); +int amdgpu_userq_post_reset (struct amdgpu_device *adev,bool vram_lost); +#endif