Upstream of kernel support for AMDGPU ISA debugging
Subsystems (3)
Felix Kuehling
maintainerRe: [PATCH 24/32] drm/amdkfd: add debug wave launch mode operation
In reply to Jonathan KimQuoted 258 lines · Jonathan Kim
Allow the debugger to set wave behaviour on to either normally operate, halt at launch, trap on every instruction, terminate immediately or stall on allocation.
v2: add gfx11 support and remove deprecated launch mode options
Signed-off-by Jonathan Kim <[email protected]>--- .../drm/amd/amdgpu/amdgpu_amdkfd_aldebaran.c | 12 +++++++ .../drm/amd/amdgpu/amdgpu_amdkfd_arcturus.c | 1 + .../drm/amd/amdgpu/amdgpu_amdkfd_gfx_v10.c | 25 +++++++++++++ .../drm/amd/amdgpu/amdgpu_amdkfd_gfx_v10.h | 3 ++ .../drm/amd/amdgpu/amdgpu_amdkfd_gfx_v10_3.c | 3 +- .../drm/amd/amdgpu/amdgpu_amdkfd_gfx_v11.c | 14 +++++++- .../gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v9.c | 25 +++++++++++++ .../gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v9.h | 3 ++ drivers/gpu/drm/amd/amdkfd/kfd_chardev.c | 3 ++ drivers/gpu/drm/amd/amdkfd/kfd_debug.c | 36 ++++++++++++++++++- drivers/gpu/drm/amd/amdkfd/kfd_debug.h | 5 ++- 11 files changed, 124 insertions(+), 6 deletions(-)drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_aldebaran.c +12
-0@@ -107,6 +107,17 @@ static uint32_t kgd_aldebaran_set_wave_launch_trap_override(struct amdgpu_devicereturn data; } +static uint32_t kgd_aldebaran_set_wave_launch_mode (struct amdgpu_device *adev, +uint8_t wave_launch_mode, +uint32_t vmid) +{ +uint32_t data =0 ; + + data =REG_SET_FIELD (data,SPI_GDBG_PER_VMID_CNTL ,LAUNCH_MODE , wave_launch_mode); + +return data; +} +const struct kfd2kgd_calls aldebaran_kfd2kgd = { .program_sh_mem_settings = kgd_gfx_v9_program_sh_mem_settings, .set_pasid_vmid_mapping = kgd_gfx_v9_set_pasid_vmid_mapping,@@ -128,6 +139,7 @@ const struct kfd2kgd_calls aldebaran_kfd2kgd = { .disable_debug_trap = kgd_aldebaran_disable_debug_trap, .validate_trap_override_request = kgd_aldebaran_validate_trap_override_request, .set_wave_launch_trap_override = kgd_aldebaran_set_wave_launch_trap_override, + .set_wave_launch_mode = kgd_aldebaran_set_wave_launch_mode, .get_iq_wait_times = kgd_gfx_v9_get_iq_wait_times, .build_grace_period_packet_info = kgd_gfx_v9_build_grace_period_packet_info, .program_trap_handler_settings = kgd_gfx_v9_program_trap_handler_settings,drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_arcturus.c +1
-0@@ -412,6 +412,7 @@ const struct kfd2kgd_calls arcturus_kfd2kgd = { .disable_debug_trap = kgd_arcturus_disable_debug_trap, .validate_trap_override_request = kgd_gfx_v9_validate_trap_override_request, .set_wave_launch_trap_override = kgd_gfx_v9_set_wave_launch_trap_override, + .set_wave_launch_mode = kgd_gfx_v9_set_wave_launch_mode, .get_iq_wait_times = kgd_gfx_v9_get_iq_wait_times, .build_grace_period_packet_info = kgd_gfx_v9_build_grace_period_packet_info, .get_cu_occupancy = kgd_gfx_v9_get_cu_occupancy,drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v10.c +25
-0@@ -854,6 +854,30 @@ uint32_t kgd_gfx_v10_set_wave_launch_trap_override(struct amdgpu_device *adev,return 0 ; } +uint32_t kgd_gfx_v10_set_wave_launch_mode (struct amdgpu_device *adev, +uint8_t wave_launch_mode, +uint32_t vmid) +{ +uint32_t data =0 ; +bool is_mode_set = !!wave_launch_mode; + +mutex_lock (&adev->grbm_idx_mutex); + +kgd_gfx_v10_set_wave_launch_stall (adev, vmid, true); + + data =REG_SET_FIELD (data,SPI_GDBG_WAVE_CNTL2 , +VMID_MASK , is_mode_set ?1 << vmid :0 ); + data =REG_SET_FIELD (data,SPI_GDBG_WAVE_CNTL2 , +MODE , is_mode_set ? wave_launch_mode :0 ); +WREG32 (SOC15_REG_OFFSET (GC ,0 , mmSPI_GDBG_WAVE_CNTL2), data); + +kgd_gfx_v10_set_wave_launch_stall (adev, vmid, false); + +mutex_unlock (&adev->grbm_idx_mutex); + +return 0 ; +} +/* kgd_gfx_v10_get_iq_wait_times: Returns the mmCP_IQ_WAIT_TIME1/2 values * The values read are: * ib_offload_wait_time -- Wait Count for Indirect Buffer Offloads. @@ -941,6 +965,7 @@ const struct kfd2kgd_calls gfx_v10_kfd2kgd = { .disable_debug_trap = kgd_gfx_v10_disable_debug_trap, .validate_trap_override_request = kgd_gfx_v10_validate_trap_override_request, .set_wave_launch_trap_override = kgd_gfx_v10_set_wave_launch_trap_override, + .set_wave_launch_mode = kgd_gfx_v10_set_wave_launch_mode, .get_iq_wait_times = kgd_gfx_v10_get_iq_wait_times, .build_grace_period_packet_info = kgd_gfx_v10_build_grace_period_packet_info, .program_trap_handler_settings = program_trap_handler_settings,drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v10.h +3
-0@@ -36,6 +36,9 @@ uint32_t kgd_gfx_v10_set_wave_launch_trap_override(struct amdgpu_device *adev,uint32_t trap_mask_request, uint32_t *trap_mask_prev, uint32_t kfd_dbg_trap_cntl_prev); +uint32_t kgd_gfx_v10_set_wave_launch_mode (struct amdgpu_device *adev, +uint8_t wave_launch_mode, +uint32_t vmid);void kgd_gfx_v10_get_iq_wait_times (struct amdgpu_device *adev,uint32_t *wait_times); void kgd_gfx_v10_build_grace_period_packet_info(struct amdgpu_device *adev, uint32_t wait_times,drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v10_3.c +2
-1@@ -675,6 +675,7 @@ const struct kfd2kgd_calls gfx_v10_3_kfd2kgd = { .enable_debug_trap = kgd_gfx_v10_enable_debug_trap, .disable_debug_trap = kgd_gfx_v10_disable_debug_trap, .validate_trap_override_request = kgd_gfx_v10_validate_trap_override_request, - .set_wave_launch_trap_override = kgd_gfx_v10_set_wave_launch_trap_override + .set_wave_launch_trap_override = kgd_gfx_v10_set_wave_launch_trap_override, + .set_wave_launch_mode = kgd_gfx_v10_set_wave_launch_mode };drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v11.c +13
-1@@ -725,6 +725,17 @@ static uint32_t kgd_gfx_v11_set_wave_launch_trap_override(struct amdgpu_device *return data; } +static uint32_t kgd_gfx_v11_set_wave_launch_mode (struct amdgpu_device *adev, +uint8_t wave_launch_mode, +uint32_t vmid) +{ +uint32_t data =0 ; + + data =REG_SET_FIELD (data,SPI_GDBG_PER_VMID_CNTL ,LAUNCH_MODE , wave_launch_mode); + +return data; +} +const struct kfd2kgd_calls gfx_v11_kfd2kgd = { .program_sh_mem_settings = program_sh_mem_settings_v11, .set_pasid_vmid_mapping = set_pasid_vmid_mapping_v11,@@ -744,5 +755,6 @@ const struct kfd2kgd_calls gfx_v11_kfd2kgd = { .enable_debug_trap = kgd_gfx_v11_enable_debug_trap, .disable_debug_trap = kgd_gfx_v11_disable_debug_trap, .validate_trap_override_request = kgd_gfx_v11_validate_trap_override_request, - .set_wave_launch_trap_override = kgd_gfx_v11_set_wave_launch_trap_override + .set_wave_launch_trap_override = kgd_gfx_v11_set_wave_launch_trap_override, + .set_wave_launch_mode = kgd_gfx_v11_set_wave_launch_mode };drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v9.c +25
-0@@ -790,6 +790,30 @@ uint32_t kgd_gfx_v9_set_wave_launch_trap_override(struct amdgpu_device *adev,return 0 ; } +uint32_t kgd_gfx_v9_set_wave_launch_mode (struct amdgpu_device *adev, +uint8_t wave_launch_mode, +uint32_t vmid) +{ +uint32_t data =0 ; +bool is_mode_set = !!wave_launch_mode; + +mutex_lock (&adev->grbm_idx_mutex); + +kgd_gfx_v9_set_wave_launch_stall (adev, vmid, true); + + data =REG_SET_FIELD (data,SPI_GDBG_WAVE_CNTL2 , +VMID_MASK , is_mode_set ?1 << vmid :0 ); + data =REG_SET_FIELD (data,SPI_GDBG_WAVE_CNTL2 , +MODE , is_mode_set ? wave_launch_mode :0 ); +WREG32 (SOC15_REG_OFFSET (GC ,0 , mmSPI_GDBG_WAVE_CNTL2), data); + +kgd_gfx_v9_set_wave_launch_stall (adev, vmid, false); + +mutex_unlock (&adev->grbm_idx_mutex); + +return 0 ; +} +/* kgd_gfx_v9_get_iq_wait_times: Returns the mmCP_IQ_WAIT_TIME1/2 values * The values read are: * ib_offload_wait_time -- Wait Count for Indirect Buffer Offloads. @@ -1060,6 +1084,7 @@ const struct kfd2kgd_calls gfx_v9_kfd2kgd = { .disable_debug_trap = kgd_gfx_v9_disable_debug_trap, .validate_trap_override_request = kgd_gfx_v9_validate_trap_override_request, .set_wave_launch_trap_override = kgd_gfx_v9_set_wave_launch_trap_override, + .set_wave_launch_mode = kgd_gfx_v9_set_wave_launch_mode, .get_iq_wait_times = kgd_gfx_v9_get_iq_wait_times, .build_grace_period_packet_info = kgd_gfx_v9_build_grace_period_packet_info, .get_cu_occupancy = kgd_gfx_v9_get_cu_occupancy,drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v9.h +3
-0@@ -67,6 +67,9 @@ uint32_t kgd_gfx_v9_disable_debug_trap(struct amdgpu_device *adev,int kgd_gfx_v9_validate_trap_override_request (struct amdgpu_device *adev,uint32_t trap_override,uint32_t *trap_mask_supported); +uint32_t kgd_gfx_v9_set_wave_launch_mode (struct amdgpu_device *adev, +uint8_t wave_launch_mode, +uint32_t vmid); uint32_t kgd_gfx_v9_set_wave_launch_trap_override(struct amdgpu_device *adev, uint32_t vmid, uint32_t trap_override,drivers/gpu/drm/amd/amdkfd/kfd_chardev.c +3
-0@@ -2904,6 +2904,9 @@ static int kfd_ioctl_set_debug_trap(struct file *filep, struct kfd_process *p, v &args->launch_override.support_request_mask);break ;case KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE : + r =kfd_dbg_trap_set_wave_launch_mode (target, + args->launch_mode.launch_mode); +break ;case KFD_IOC_DBG_TRAP_SUSPEND_QUEUES :case KFD_IOC_DBG_TRAP_RESUME_QUEUES :case KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH :drivers/gpu/drm/amd/amdkfd/kfd_debug.c +7
-1@@ -303,8 +303,10 @@ void kfd_dbg_trap_deactivate(struct kfd_process *target, bool unwind, int unwind {int i, count =0 ; -if (!unwind) +if (!unwind) {cancel_work_sync (&target->debug_event_workarea); +kfd_dbg_trap_set_wave_launch_mode (target,0 ); + }for (i =0 ; i < target->n_pdds; i++) {struct kfd_process_device *pdd = target->pdds[i];@@ -599,6 +601,38 @@ int kfd_dbg_trap_set_wave_launch_override(struct kfd_process *target,return r; } +int kfd_dbg_trap_set_wave_launch_mode (struct kfd_process *target, +uint8_t wave_launch_mode) +{ +int r =0 , i;
drivers/gpu/drm/amd/amdkfd/kfd_debug.c int kfd_dbg_trap_set_wave_launch_override(struct kfd_process *target, · line 617
Quoted 10 lines
drivers/gpu/drm/amd/amdkfd/kfd_debug.c +10
-0+ +if (wave_launch_mode !=KFD_DBG_TRAP_WAVE_LAUNCH_MODE_NORMAL && + wave_launch_mode !=KFD_DBG_TRAP_WAVE_LAUNCH_MODE_HALT && + wave_launch_mode !=KFD_DBG_TRAP_WAVE_LAUNCH_MODE_DEBUG ) +return -EINVAL ; + +for (i =0 ; i < target->n_pdds; i++) { +struct kfd_process_device *pdd = target->pdds[i]; + +amdgpu_gfx_off_ctrl (pdd->dev->adev, false);
Same comment as in the last patch. This should probably be done in the HW-specific code, only if it actually touches HW registers. Maybe in a separate patch to make sure we catch all the cases.
Quoted 26 lines
drivers/gpu/drm/amd/amdkfd/kfd_debug.c +18
-0+ pdd->spi_dbg_launch_mode = pdd->dev->kfd2kgd->set_wave_launch_mode ( + pdd->dev->adev, + wave_launch_mode, + pdd->dev->vm_info.last_vmid_kfd); +amdgpu_gfx_off_ctrl (pdd->dev->adev, true); + +if (!pdd->dev->shared_resources.enable_mes) + r =debug_refresh_runlist (pdd->dev->dqm); +else + r =kfd_dbg_set_mes_debug_mode (pdd); + +if (r) +break ; + } + +return r; +} +void kfd_dbg_set_enabled_debug_exception_mask (struct kfd_process *target,uint64_t exception_set_mask) {drivers/gpu/drm/amd/amdkfd/kfd_debug.h +0
-0
drivers/gpu/drm/amd/amdkfd/kfd_debug.h line 30
Quoted 6 lines
drivers/gpu/drm/amd/amdkfd/kfd_debug.h +0
-3@@ -25,9 +25,6 @@#include "kfd_priv.h" -void kgd_gfx_v9_set_wave_launch_stall (struct amdgpu_device *adev, -uint32_t vmid, -bool stall);
This seems unrelated to this patch.
Regards,
Felix
Quoted 12 lines
drivers/gpu/drm/amd/amdkfd/kfd_debug.h +2
-0void kfd_dbg_trap_deactivate (struct kfd_process *target,bool unwind,int unwind_count);int kfd_dbg_trap_activate (struct kfd_process *target); bool kfd_set_dbg_ev_from_interrupt(struct kfd_dev *dev,@@ -51,6 +48,8 @@ int kfd_dbg_trap_set_wave_launch_override(struct kfd_process *target,uint32_t trap_mask_request, uint32_t *trap_mask_prev, uint32_t *trap_mask_supported); +int kfd_dbg_trap_set_wave_launch_mode (struct kfd_process *target, +uint8_t wave_launch_mode); int kfd_dbg_send_exception_to_runtime(struct kfd_process *p, unsigned int dev_id,
PATCH 25/32 drm/amdkfd: add debug suspend and resume process queues operation
In reply to Jonathan KimIn order to inspect waves from the saved context at any point during a debug session, the debugger must be able to preempt queues to trigger context save by suspending them.
On queue suspend, the KFD will copy the context save header information so that the debugger can correctly crawl the appropriate size of the saved context. The debugger must then also be allowed to resume suspended queues.
A queue that is newly created cannot be suspended because queue ids are recycled after destruction so the debugger needs to know that this has occurred. Query functions will be later added that will clear a given queue of its new queue status.
A queue cannot be destroyed while it is suspended to preserve its saved context during debugger inspection. Have queue destruction block while a queue is suspended and unblocked when it is resumed. Likewise, if a queue is about to be destroyed, it cannot be suspended.
Return the number of queues successfully suspended or resumed along with a per queue status array where the upper bits per queue status show that the request was invalid (new/destroyed queue suspend request, missing queue) or an error occurred (HWS in a fatal state so it can't suspend or resume queues).
v2: add gfx11/mes support.
prevent header copy on suspend from overwriting user fields. simplify resume_queues function.
address other nit-picks
--- drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c | 5 + drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h | 1 + drivers/gpu/drm/amd/amdkfd/kfd_chardev.c | 11 + drivers/gpu/drm/amd/amdkfd/kfd_debug.c | 7 + .../drm/amd/amdkfd/kfd_device_queue_manager.c | 446 +++++++++++++++++- .../drm/amd/amdkfd/kfd_device_queue_manager.h | 10 + .../gpu/drm/amd/amdkfd/kfd_mqd_manager_v10.c | 14 + .../gpu/drm/amd/amdkfd/kfd_mqd_manager_v11.c | 11 +- .../gpu/drm/amd/amdkfd/kfd_mqd_manager_v9.c | 18 +- drivers/gpu/drm/amd/amdkfd/kfd_priv.h | 5 +- 10 files changed, 518 insertions(+), 10 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c +5 -0
@@ -758,6 +758,11 @@ bool amdgpu_amdkfd_have_atomics_support(struct amdgpu_device *adev)return adev->have_atomics_support; } +void amdgpu_amdkfd_debug_mem_fence (struct amdgpu_device *adev) +{ +amdgpu_device_flush_hdp (adev,NULL ); +} +void amdgpu_amdkfd_ras_poison_consumption_handler (struct amdgpu_device *adev,bool reset) {amdgpu_umc_poison_handler (adev, reset);
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h +1 -0
@@ -310,6 +310,7 @@ int amdgpu_amdkfd_gpuvm_import_dmabuf(struct amdgpu_device *adev, uint64_t va, void *drm_priv, struct kgd_mem **mem, uint64_t *size, uint64_t *mmap_offset); +void amdgpu_amdkfd_debug_mem_fence (struct amdgpu_device *adev);int amdgpu_amdkfd_get_tile_config (struct amdgpu_device *adev,struct tile_config *config); void amdgpu_amdkfd_ras_poison_consumption_handler(struct amdgpu_device *adev,
drivers/gpu/drm/amd/amdkfd/kfd_chardev.c +11 -0
@@ -410,6 +410,7 @@ static int kfd_ioctl_create_queue(struct file *filep, struct kfd_process *p,pr_debug ("Write ptr address == 0x%016llX\n" , args->write_pointer_address); +kfd_dbg_ev_raise (KFD_EC_MASK (EC_QUEUE_NEW ), p, dev, queue_id, false,NULL ,0 );return 0 ; err_create_queue:
@@ -2908,7 +2909,17 @@ static int kfd_ioctl_set_debug_trap(struct file *filep, struct kfd_process *p, v args->launch_mode.launch_mode);break ;case KFD_IOC_DBG_TRAP_SUSPEND_QUEUES : + r =suspend_queues (target, + args->suspend_queues.num_queues, + args->suspend_queues.grace_period, + args->suspend_queues.exception_mask, + (uint32_t *)args->suspend_queues.queue_array_ptr); + +break ;case KFD_IOC_DBG_TRAP_RESUME_QUEUES : + r =resume_queues (target, args->resume_queues.num_queues, + (uint32_t *)args->resume_queues.queue_array_ptr); +break ;case KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH :case KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH :case KFD_IOC_DBG_TRAP_SET_FLAGS :
drivers/gpu/drm/amd/amdkfd/kfd_debug.c +7 -0
@@ -344,6 +344,13 @@ void kfd_dbg_trap_deactivate(struct kfd_process *target, bool unwind, int unwind }kfd_dbg_set_workaround (target, false); + +if (!unwind) { +int resume_count =resume_queues (target,0 ,NULL ); + +if (resume_count) +pr_debug ("Resumed %d queues\n" , resume_count); + } }static void kfd_dbg_clean_exception_status (struct kfd_process *target)
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +442 -4
486 lines not on this page · raw message
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.h +10 -0
@@ -259,6 +259,8 @@ struct device_queue_manager {struct kfd_mem_obj hiq_sdma_mqd;bool sched_running;uint32_t wait_times; + +wait_queue_head_t destroy_wait; }; void device_queue_manager_init_cik(
@@ -286,6 +288,14 @@ int reserve_debug_trap_vmid(struct device_queue_manager *dqm, struct qcm_process_device *qpd);int release_debug_trap_vmid (struct device_queue_manager *dqm,struct qcm_process_device *qpd); +int suspend_queues (struct kfd_process *p, +uint32_t num_queues, +uint32_t grace_period, +uint64_t exception_clear_mask, +uint32_t *usr_queue_id_array); +int resume_queues (struct kfd_process *p, +uint32_t num_queues, +uint32_t *usr_queue_id_array);int debug_lock_and_unmap (struct device_queue_manager *dqm);int debug_map_and_unlock (struct device_queue_manager *dqm);int debug_refresh_runlist (struct device_queue_manager *dqm);
drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_v10.c +14 -0
@@ -236,6 +236,11 @@ static int get_wave_state(struct mqd_manager *mm, void *mqd, u32 *save_area_used_size) {struct v10_compute_mqd *m; +struct kfd_context_save_area_header header; +size_t header_copy_size =sizeof (header.control_stack_size) + +sizeof (header.wave_state_size) + +sizeof (header.wave_state_offset) + +sizeof (header.control_stack_offset); m =get_mqd (mqd);
@@ -254,6 +259,15 @@ static int get_wave_state(struct mqd_manager *mm, void *mqd,* accessible to user mode */ + header.control_stack_size = *ctl_stack_used_size; + header.wave_state_size = *save_area_used_size; + + header.wave_state_offset = m->cp_hqd_wg_state_offset; + header.control_stack_offset = m->cp_hqd_cntl_stack_offset; + +if (copy_to_user (ctl_stack, &header, header_copy_size)) +return -EFAULT ; +return 0 ; }
drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_v11.c +7 -4
@@ -283,7 +283,11 @@ static int get_wave_state(struct mqd_manager *mm, void *mqd, u32 *save_area_used_size) {struct v11_compute_mqd *m; -/*struct mqd_user_context_save_area_header header;*/ +struct kfd_context_save_area_header header; +size_t header_copy_size =sizeof (header.control_stack_size) + +sizeof (header.wave_state_size) + +sizeof (header.wave_state_offset) + +sizeof (header.control_stack_offset); m =get_mqd (mqd);
@@ -301,16 +305,15 @@ static int get_wave_state(struct mqd_manager *mm, void *mqd,* it's part of the context save area that is already * accessible to user mode */ -/* header.control_stack_size = *ctl_stack_used_size; header.wave_state_size = *save_area_used_size; header.wave_state_offset = m->cp_hqd_wg_state_offset; header.control_stack_offset = m->cp_hqd_cntl_stack_offset; -if (copy_to_user(ctl_stack, &header, sizeof(header))) +if (copy_to_user (ctl_stack, &header, header_copy_size))return -EFAULT ; -*/ +return 0 ; }
drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_v9.c +17 -1
@@ -288,6 +288,11 @@ static int get_wave_state(struct mqd_manager *mm, void *mqd, u32 *save_area_used_size) {struct v9_mqd *m; +struct kfd_context_save_area_header header; +size_t header_copy_size =sizeof (header.control_stack_size) + +sizeof (header.wave_state_size) + +sizeof (header.wave_state_offset) + +sizeof (header.control_stack_offset);/* Control stack is located one page after MQD. */ void *mqd_ctl_stack = (void *)((uintptr_t )mqd +PAGE_SIZE );
@@ -299,7 +304,18 @@ static int get_wave_state(struct mqd_manager *mm, void *mqd, *save_area_used_size = m->cp_hqd_wg_state_offset - m->cp_hqd_cntl_stack_size; -if (copy_to_user (ctl_stack, mqd_ctl_stack, m->cp_hqd_cntl_stack_size)) + header.control_stack_size = *ctl_stack_used_size; + header.wave_state_size = *save_area_used_size; + + header.wave_state_offset = m->cp_hqd_wg_state_offset; + header.control_stack_offset = m->cp_hqd_cntl_stack_offset; + +if (copy_to_user (ctl_stack, &header, header_copy_size)) +return -EFAULT ; + +if (copy_to_user (ctl_stack + m->cp_hqd_cntl_stack_offset, + mqd_ctl_stack + m->cp_hqd_cntl_stack_offset, + *ctl_stack_used_size))return -EFAULT ;return 0 ;
drivers/gpu/drm/amd/amdkfd/kfd_priv.h +4 -1
@@ -477,6 +477,8 @@ struct queue_properties {uint32_t doorbell_off;bool is_interop;bool is_evicted; +bool is_suspended; +bool is_being_destroyed;bool is_active;bool is_gws;bool is_dbg_wa;
@@ -501,7 +503,8 @@ struct queue_properties {#define QUEUE_IS_ACTIVE (q) ((q).queue_size > 0 && \ (q).queue_address != 0 && \ (q).queue_percent > 0 && \ - !(q).is_evicted) + !(q).is_evicted && \ + !(q).is_suspended)enum mqd_update_flag {UPDATE_FLAG_DBG_WA_ENABLE =1 ,
Signature · 1 line
2.25.1
Felix Kuehling
maintainerRe: [PATCH 25/32] drm/amdkfd: add debug suspend and resume process queues operation
Quoted 43 lines · Jonathan Kim
In order to inspect waves from the saved context at any point during a debug session, the debugger must be able to preempt queues to trigger context save by suspending them.
On queue suspend, the KFD will copy the context save header information so that the debugger can correctly crawl the appropriate size of the saved context. The debugger must then also be allowed to resume suspended queues.
A queue that is newly created cannot be suspended because queue ids are recycled after destruction so the debugger needs to know that this has occurred. Query functions will be later added that will clear a given queue of its new queue status.
A queue cannot be destroyed while it is suspended to preserve its saved context during debugger inspection. Have queue destruction block while a queue is suspended and unblocked when it is resumed. Likewise, if a queue is about to be destroyed, it cannot be suspended.
Return the number of queues successfully suspended or resumed along with a per queue status array where the upper bits per queue status show that the request was invalid (new/destroyed queue suspend request, missing queue) or an error occurred (HWS in a fatal state so it can't suspend or resume queues).
v2: add gfx11/mes support.
prevent header copy on suspend from overwriting user fields. simplifyresume_queuesfunction.
address other nit-picksSigned-off-by Jonathan Kim <[email protected]>--- drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c | 5 + drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h | 1 + drivers/gpu/drm/amd/amdkfd/kfd_chardev.c | 11 + drivers/gpu/drm/amd/amdkfd/kfd_debug.c | 7 + .../drm/amd/amdkfd/kfd_device_queue_manager.c | 446 +++++++++++++++++- .../drm/amd/amdkfd/kfd_device_queue_manager.h | 10 + .../gpu/drm/amd/amdkfd/kfd_mqd_manager_v10.c | 14 + .../gpu/drm/amd/amdkfd/kfd_mqd_manager_v11.c | 11 +- .../gpu/drm/amd/amdkfd/kfd_mqd_manager_v9.c | 18 +- drivers/gpu/drm/amd/amdkfd/kfd_priv.h | 5 +- 10 files changed, 518 insertions(+), 10 deletions(-)
[snip]
drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_v9.c static int get_wave_state(struct mqd_manager *mm, void *mqd, · line 295
Quoted 13 lines
drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_v9.c +5
-0@@ -288,6 +288,11 @@ static int get_wave_state(struct mqd_manager *mm, void *mqd, u32 *save_area_used_size) {struct v9_mqd *m; +struct kfd_context_save_area_header header; +size_t header_copy_size =sizeof (header.control_stack_size) + +sizeof (header.wave_state_size) + +sizeof (header.wave_state_offset) + +sizeof (header.control_stack_offset);
This makes assumptions about the structure layout. I'd feel better if these fields were in a sub-structure, which would make this easier and safer to handle.
struct kfd_context_save_area_header {
struct {
__u32 control_stack_offset;
__u32 control_stack_size;
__u32 wave_state_offset;
__u32 wave_state_size;
} wave_state;
...
};...
|static int get_wave_state(...) { struct kfd_context_save_area_header header; ... header.wave_state.control_stack_size = *ctl_stack_used_size; header.wave_state.wave_state_size = *save_area_used_size; header.wave_state.wave_state_offset = m->cp_hqd_wg_state_offset; header.wave_state.control_stack_offset = m->cp_hqd_cntl_stack_offset; if (copy_to_user(ctl_stack, &header.wave_state, sizeof(header.wave_state))) return -EFAULT; ... } |
This way you're sure you only copy initialized data. The only assumption this still makes is, that wave_state is at the start of the header structure.
Regards,
Felix
Quoted 46 lines
drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_v9.c +12
-1/* Control stack is located one page after MQD. */ void *mqd_ctl_stack = (void *)((uintptr_t )mqd +PAGE_SIZE );@@ -299,7 +304,18 @@ static int get_wave_state(struct mqd_manager *mm, void *mqd, *save_area_used_size = m->cp_hqd_wg_state_offset - m->cp_hqd_cntl_stack_size; -if (copy_to_user (ctl_stack, mqd_ctl_stack, m->cp_hqd_cntl_stack_size)) + header.control_stack_size = *ctl_stack_used_size; + header.wave_state_size = *save_area_used_size; + + header.wave_state_offset = m->cp_hqd_wg_state_offset; + header.control_stack_offset = m->cp_hqd_cntl_stack_offset; + +if (copy_to_user (ctl_stack, &header, header_copy_size)) +return -EFAULT ; + +if (copy_to_user (ctl_stack + m->cp_hqd_cntl_stack_offset, + mqd_ctl_stack + m->cp_hqd_cntl_stack_offset, + *ctl_stack_used_size))return -EFAULT ;return 0 ;drivers/gpu/drm/amd/amdkfd/kfd_priv.h +4
-1@@ -477,6 +477,8 @@ struct queue_properties {uint32_t doorbell_off;bool is_interop;bool is_evicted; +bool is_suspended; +bool is_being_destroyed;bool is_active;bool is_gws;bool is_dbg_wa;@@ -501,7 +503,8 @@ struct queue_properties {#define QUEUE_IS_ACTIVE (q) ((q).queue_size > 0 && \ (q).queue_address != 0 && \ (q).queue_percent > 0 && \ - !(q).is_evicted) + !(q).is_evicted && \ + !(q).is_suspended)enum mqd_update_flag {UPDATE_FLAG_DBG_WA_ENABLE =1 ,
PATCH 26/32 drm/amdkfd: add debug set and clear address watch points operation
In reply to Jonathan KimShader read, write and atomic memory operations can be alerted to the debugger as an address watch exception.
Allow the debugger to pass in a watch point to a particular memory address per device.
Note that there exists only 4 watch points per devices to date, so have the KFD keep track of what watch points are allocated or not.
v3: add gfx11 support.
cleanup gfx9 kgd calls to set and clear address watch. use per device spinlock to set watch points. fixup runlist refresh calls on set/clear address watch.
v2: change dev_id arg to gpu_id for consistency
--- .../drm/amd/amdgpu/amdgpu_amdkfd_aldebaran.c | 51 +++++++ .../drm/amd/amdgpu/amdgpu_amdkfd_arcturus.c | 2 + .../drm/amd/amdgpu/amdgpu_amdkfd_gfx_v10.c | 78 ++++++++++ .../drm/amd/amdgpu/amdgpu_amdkfd_gfx_v10.h | 8 ++ .../drm/amd/amdgpu/amdgpu_amdkfd_gfx_v10_3.c | 5 +- .../drm/amd/amdgpu/amdgpu_amdkfd_gfx_v11.c | 52 ++++++- .../gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v9.c | 77 ++++++++++ .../gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v9.h | 8 ++ drivers/gpu/drm/amd/amdkfd/kfd_chardev.c | 24 ++++ drivers/gpu/drm/amd/amdkfd/kfd_debug.c | 136 ++++++++++++++++++ drivers/gpu/drm/amd/amdkfd/kfd_debug.h | 8 +- drivers/gpu/drm/amd/amdkfd/kfd_device.c | 1 + drivers/gpu/drm/amd/amdkfd/kfd_priv.h | 6 +- 13 files changed, 451 insertions(+), 5 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_aldebaran.c +51 -0
@@ -118,6 +118,55 @@ static uint32_t kgd_aldebaran_set_wave_launch_mode(struct amdgpu_device *adev,return data; } +#define TCP_WATCH_STRIDE (regTCP_WATCH1_ADDR_H - regTCP_WATCH0_ADDR_H) +static uint32_t kgd_gfx_aldebaran_set_address_watch ( +struct amdgpu_device *adev, +uint64_t watch_address, +uint32_t watch_address_mask, +uint32_t watch_id, +uint32_t watch_mode, +uint32_t debug_vmid) +{ +uint32_t watch_address_high; +uint32_t watch_address_low; +uint32_t watch_address_cntl; + + watch_address_cntl =0 ; + watch_address_low =lower_32_bits (watch_address); + watch_address_high =upper_32_bits (watch_address) &0xffff ; + + watch_address_cntl =REG_SET_FIELD (watch_address_cntl, +TCP_WATCH0_CNTL , +MODE , + watch_mode); + + watch_address_cntl =REG_SET_FIELD (watch_address_cntl, +TCP_WATCH0_CNTL , +MASK , + watch_address_mask >>6 ); + + watch_address_cntl =REG_SET_FIELD (watch_address_cntl, +TCP_WATCH0_CNTL , +VALID , +1 ); + +WREG32_RLC ((SOC15_REG_OFFSET (GC ,0 , regTCP_WATCH0_ADDR_H) + + (watch_id *TCP_WATCH_STRIDE )), + watch_address_high); + +WREG32_RLC ((SOC15_REG_OFFSET (GC ,0 , regTCP_WATCH0_ADDR_L) + + (watch_id *TCP_WATCH_STRIDE )), + watch_address_low); + +return watch_address_cntl; +} + +uint32_t kgd_gfx_aldebaran_clear_address_watch (struct amdgpu_device *adev, +uint32_t watch_id) +{ +return 0 ; +} +const struct kfd2kgd_calls aldebaran_kfd2kgd = { .program_sh_mem_settings = kgd_gfx_v9_program_sh_mem_settings, .set_pasid_vmid_mapping = kgd_gfx_v9_set_pasid_vmid_mapping,
@@ -140,6 +189,8 @@ const struct kfd2kgd_calls aldebaran_kfd2kgd = { .validate_trap_override_request = kgd_aldebaran_validate_trap_override_request, .set_wave_launch_trap_override = kgd_aldebaran_set_wave_launch_trap_override, .set_wave_launch_mode = kgd_aldebaran_set_wave_launch_mode, + .set_address_watch = kgd_gfx_aldebaran_set_address_watch, + .clear_address_watch = kgd_gfx_aldebaran_clear_address_watch, .get_iq_wait_times = kgd_gfx_v9_get_iq_wait_times, .build_grace_period_packet_info = kgd_gfx_v9_build_grace_period_packet_info, .program_trap_handler_settings = kgd_gfx_v9_program_trap_handler_settings,
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_arcturus.c +2 -0
@@ -413,6 +413,8 @@ const struct kfd2kgd_calls arcturus_kfd2kgd = { .validate_trap_override_request = kgd_gfx_v9_validate_trap_override_request, .set_wave_launch_trap_override = kgd_gfx_v9_set_wave_launch_trap_override, .set_wave_launch_mode = kgd_gfx_v9_set_wave_launch_mode, + .set_address_watch = kgd_gfx_v9_set_address_watch, + .clear_address_watch = kgd_gfx_v9_clear_address_watch, .get_iq_wait_times = kgd_gfx_v9_get_iq_wait_times, .build_grace_period_packet_info = kgd_gfx_v9_build_grace_period_packet_info, .get_cu_occupancy = kgd_gfx_v9_get_cu_occupancy,
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v10.c +78 -0
90 lines not on this page · raw message
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v10.h +8 -0
@@ -39,6 +39,14 @@ uint32_t kgd_gfx_v10_set_wave_launch_trap_override(struct amdgpu_device *adev,uint32_t kgd_gfx_v10_set_wave_launch_mode (struct amdgpu_device *adev,uint8_t wave_launch_mode,uint32_t vmid); +uint32_t kgd_gfx_v10_set_address_watch (struct amdgpu_device *adev, +uint64_t watch_address, +uint32_t watch_address_mask, +uint32_t watch_id, +uint32_t watch_mode, +uint32_t debug_vmid); +uint32_t kgd_gfx_v10_clear_address_watch (struct amdgpu_device *adev, +uint32_t watch_id);void kgd_gfx_v10_get_iq_wait_times (struct amdgpu_device *adev,uint32_t *wait_times); void kgd_gfx_v10_build_grace_period_packet_info(struct amdgpu_device *adev, uint32_t wait_times,
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v10_3.c +3 -2
@@ -676,6 +676,7 @@ const struct kfd2kgd_calls gfx_v10_3_kfd2kgd = { .disable_debug_trap = kgd_gfx_v10_disable_debug_trap, .validate_trap_override_request = kgd_gfx_v10_validate_trap_override_request, .set_wave_launch_trap_override = kgd_gfx_v10_set_wave_launch_trap_override, - .set_wave_launch_mode = kgd_gfx_v10_set_wave_launch_mode - + .set_wave_launch_mode = kgd_gfx_v10_set_wave_launch_mode, + .set_address_watch = kgd_gfx_v10_set_address_watch, + .clear_address_watch = kgd_gfx_v10_clear_address_watch };
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v11.c +51 -1
62 lines not on this page · raw message
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v9.c +77 -0
89 lines not on this page · raw message
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v9.h +8 -0
@@ -77,6 +77,14 @@ uint32_t kgd_gfx_v9_set_wave_launch_trap_override(struct amdgpu_device *adev,uint32_t trap_mask_request, uint32_t *trap_mask_prev, uint32_t kfd_dbg_trap_cntl_prev); +uint32_t kgd_gfx_v9_set_address_watch (struct amdgpu_device *adev, +uint64_t watch_address, +uint32_t watch_address_mask, +uint32_t watch_id, +uint32_t watch_mode, +uint32_t debug_vmid); +uint32_t kgd_gfx_v9_clear_address_watch (struct amdgpu_device *adev, +uint32_t watch_id);void kgd_gfx_v9_get_iq_wait_times (struct amdgpu_device *adev,uint32_t *wait_times); void kgd_gfx_v9_build_grace_period_packet_info(struct amdgpu_device *adev, uint32_t wait_times,
drivers/gpu/drm/amd/amdkfd/kfd_chardev.c +24 -0
@@ -2802,6 +2802,7 @@ static int kfd_ioctl_set_debug_trap(struct file *filep, struct kfd_process *p, vstruct task_struct *thread =NULL ;struct pid *pid =NULL ;struct kfd_process *target =NULL ; +struct kfd_process_device *pdd =NULL ;int r =0 ;if (sched_policy ==KFD_SCHED_POLICY_NO_HWS ) {
@@ -2869,6 +2870,20 @@ static int kfd_ioctl_set_debug_trap(struct file *filep, struct kfd_process *p, v goto unlock_out; } +if (args->op ==KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH || + args->op ==KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH ) { +int user_gpu_id =kfd_process_get_user_gpu_id (target, + args->op ==KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH ? + args->set_node_address_watch.gpu_id : + args->clear_node_address_watch.gpu_id); + + pdd =kfd_process_device_data_by_id (target, user_gpu_id); +if (user_gpu_id == -EINVAL || !pdd) { + r = -ENODEV ; + goto unlock_out; + } + } +switch (args->op) {case KFD_IOC_DBG_TRAP_ENABLE :if (target != p)
@@ -2921,7 +2936,16 @@ static int kfd_ioctl_set_debug_trap(struct file *filep, struct kfd_process *p, v (uint32_t *)args->resume_queues.queue_array_ptr);break ;case KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH : + r =kfd_dbg_trap_set_dev_address_watch (pdd, + args->set_node_address_watch.address, + args->set_node_address_watch.mask, + &args->set_node_address_watch.id, + args->set_node_address_watch.mode); +break ;case KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH : + r =kfd_dbg_trap_clear_dev_address_watch (pdd, + args->clear_node_address_watch.id); +break ;case KFD_IOC_DBG_TRAP_SET_FLAGS :case KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT :case KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO :
drivers/gpu/drm/amd/amdkfd/kfd_debug.c +136 -0
154 lines not on this page · raw message
drivers/gpu/drm/amd/amdkfd/kfd_debug.h +7 -1
@@ -50,7 +50,13 @@ int kfd_dbg_trap_set_wave_launch_override(struct kfd_process *target, uint32_t *trap_mask_supported);int kfd_dbg_trap_set_wave_launch_mode (struct kfd_process *target,uint8_t wave_launch_mode); - +int kfd_dbg_trap_clear_dev_address_watch (struct kfd_process_device *pdd, +uint32_t watch_id); +int kfd_dbg_trap_set_dev_address_watch (struct kfd_process_device *pdd, +uint64_t watch_address, +uint32_t watch_address_mask, +uint32_t *watch_id, +uint32_t watch_mode); int kfd_dbg_send_exception_to_runtime(struct kfd_process *p, unsigned int dev_id, unsigned int queue_id,
drivers/gpu/drm/amd/amdkfd/kfd_device.c +1 -0
@@ -641,6 +641,7 @@ bool kgd2kfd_device_init(struct kfd_dev *kfd, }kfd_smi_init (kfd); +spin_lock_init (&kfd->watch_points_lock); kfd->init_complete = true; dev_info(kfd_device, "added device %x:%x\n", kfd->adev->pdev->vendor,
drivers/gpu/drm/amd/amdkfd/kfd_priv.h +5 -1
@@ -348,6 +348,10 @@ struct kfd_dev {/* HMM page migration MEMORY_DEVICE_PRIVATE mapping */ struct dev_pagemap pgmap; + +/* Track per device allocated watch points */ +uint32_t alloc_watch_ids; +spinlock_t watch_points_lock; };enum kfd_mempool {
@@ -799,6 +803,7 @@ struct kfd_process_device {uint32_t spi_dbg_override;uint32_t spi_dbg_launch_mode;uint32_t watch_points[4 ]; +uint32_t alloc_watch_ids;/* * If this process has been checkpointed before, then the user
@@ -955,7 +960,6 @@ struct kfd_process {struct semaphore runtime_enable_sema;bool is_runtime_retry;struct kfd_runtime_info runtime_info; - };#define KFD_PROCESS_TABLE_SIZE 5/* bits: 32 entries */
Signature · 1 line
2.25.1
Re: [PATCH 26/32] drm/amdkfd: add debug set and clear address watch points operation
Am 2023-01-25 um 14:53 schrieb Jonathan Kim:
Quoted 439 lines
Shader read, write and atomic memory operations can be alerted to the debugger as an address watch exception.
Allow the debugger to pass in a watch point to a particular memory address per device.
Note that there exists only 4 watch points per devices to date, so have the KFD keep track of what watch points are allocated or not.
v3: add gfx11 support.
cleanup gfx9 kgd calls to set and clear address watch. use per device spinlock to set watch points. fixup runlist refresh calls on set/clear address watch.v2: change
dev_idarg togpu_idfor consistencySigned-off-by Jonathan Kim <[email protected]>--- .../drm/amd/amdgpu/amdgpu_amdkfd_aldebaran.c | 51 +++++++ .../drm/amd/amdgpu/amdgpu_amdkfd_arcturus.c | 2 + .../drm/amd/amdgpu/amdgpu_amdkfd_gfx_v10.c | 78 ++++++++++ .../drm/amd/amdgpu/amdgpu_amdkfd_gfx_v10.h | 8 ++ .../drm/amd/amdgpu/amdgpu_amdkfd_gfx_v10_3.c | 5 +- .../drm/amd/amdgpu/amdgpu_amdkfd_gfx_v11.c | 52 ++++++- .../gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v9.c | 77 ++++++++++ .../gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v9.h | 8 ++ drivers/gpu/drm/amd/amdkfd/kfd_chardev.c | 24 ++++ drivers/gpu/drm/amd/amdkfd/kfd_debug.c | 136 ++++++++++++++++++ drivers/gpu/drm/amd/amdkfd/kfd_debug.h | 8 +- drivers/gpu/drm/amd/amdkfd/kfd_device.c | 1 + drivers/gpu/drm/amd/amdkfd/kfd_priv.h | 6 +- 13 files changed, 451 insertions(+), 5 deletions(-)drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_aldebaran.c +51
-0@@ -118,6 +118,55 @@ static uint32_t kgd_aldebaran_set_wave_launch_mode(struct amdgpu_device *adev,return data; } +#define TCP_WATCH_STRIDE (regTCP_WATCH1_ADDR_H - regTCP_WATCH0_ADDR_H) +static uint32_t kgd_gfx_aldebaran_set_address_watch ( +struct amdgpu_device *adev, +uint64_t watch_address, +uint32_t watch_address_mask, +uint32_t watch_id, +uint32_t watch_mode, +uint32_t debug_vmid) +{ +uint32_t watch_address_high; +uint32_t watch_address_low; +uint32_t watch_address_cntl; + + watch_address_cntl =0 ; + watch_address_low =lower_32_bits (watch_address); + watch_address_high =upper_32_bits (watch_address) &0xffff ; + + watch_address_cntl =REG_SET_FIELD (watch_address_cntl, +TCP_WATCH0_CNTL , +MODE , + watch_mode); + + watch_address_cntl =REG_SET_FIELD (watch_address_cntl, +TCP_WATCH0_CNTL , +MASK , + watch_address_mask >>6 ); + + watch_address_cntl =REG_SET_FIELD (watch_address_cntl, +TCP_WATCH0_CNTL , +VALID , +1 ); + +WREG32_RLC ((SOC15_REG_OFFSET (GC ,0 , regTCP_WATCH0_ADDR_H) + + (watch_id *TCP_WATCH_STRIDE )), + watch_address_high); + +WREG32_RLC ((SOC15_REG_OFFSET (GC ,0 , regTCP_WATCH0_ADDR_L) + + (watch_id *TCP_WATCH_STRIDE )), + watch_address_low); + +return watch_address_cntl; +} + +uint32_t kgd_gfx_aldebaran_clear_address_watch (struct amdgpu_device *adev, +uint32_t watch_id) +{ +return 0 ; +} +const struct kfd2kgd_calls aldebaran_kfd2kgd = { .program_sh_mem_settings = kgd_gfx_v9_program_sh_mem_settings, .set_pasid_vmid_mapping = kgd_gfx_v9_set_pasid_vmid_mapping,@@ -140,6 +189,8 @@ const struct kfd2kgd_calls aldebaran_kfd2kgd = { .validate_trap_override_request = kgd_aldebaran_validate_trap_override_request, .set_wave_launch_trap_override = kgd_aldebaran_set_wave_launch_trap_override, .set_wave_launch_mode = kgd_aldebaran_set_wave_launch_mode, + .set_address_watch = kgd_gfx_aldebaran_set_address_watch, + .clear_address_watch = kgd_gfx_aldebaran_clear_address_watch, .get_iq_wait_times = kgd_gfx_v9_get_iq_wait_times, .build_grace_period_packet_info = kgd_gfx_v9_build_grace_period_packet_info, .program_trap_handler_settings = kgd_gfx_v9_program_trap_handler_settings,drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_arcturus.c +2
-0@@ -413,6 +413,8 @@ const struct kfd2kgd_calls arcturus_kfd2kgd = { .validate_trap_override_request = kgd_gfx_v9_validate_trap_override_request, .set_wave_launch_trap_override = kgd_gfx_v9_set_wave_launch_trap_override, .set_wave_launch_mode = kgd_gfx_v9_set_wave_launch_mode, + .set_address_watch = kgd_gfx_v9_set_address_watch, + .clear_address_watch = kgd_gfx_v9_clear_address_watch, .get_iq_wait_times = kgd_gfx_v9_get_iq_wait_times, .build_grace_period_packet_info = kgd_gfx_v9_build_grace_period_packet_info, .get_cu_occupancy = kgd_gfx_v9_get_cu_occupancy,drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v10.c +78
-0@@ -878,6 +878,82 @@ uint32_t kgd_gfx_v10_set_wave_launch_mode(struct amdgpu_device *adev,return 0 ; } +#define TCP_WATCH_STRIDE (mmTCP_WATCH1_ADDR_H - mmTCP_WATCH0_ADDR_H) +uint32_t kgd_gfx_v10_set_address_watch (struct amdgpu_device *adev, +uint64_t watch_address, +uint32_t watch_address_mask, +uint32_t watch_id, +uint32_t watch_mode, +uint32_t debug_vmid) +{ +uint32_t watch_address_high; +uint32_t watch_address_low; +uint32_t watch_address_cntl; + + watch_address_cntl =0 ; + + watch_address_low =lower_32_bits (watch_address); + watch_address_high =upper_32_bits (watch_address) &0xffff ; + + watch_address_cntl =REG_SET_FIELD (watch_address_cntl, +TCP_WATCH0_CNTL , +VMID , + debug_vmid); + watch_address_cntl =REG_SET_FIELD (watch_address_cntl, +TCP_WATCH0_CNTL , +MODE , + watch_mode); + watch_address_cntl =REG_SET_FIELD (watch_address_cntl, +TCP_WATCH0_CNTL , +MASK , + watch_address_mask >>7 ); + +/* Turning off this watch point until we set all the registers */ + watch_address_cntl =REG_SET_FIELD (watch_address_cntl, +TCP_WATCH0_CNTL , +VALID , +0 ); + +WREG32 ((SOC15_REG_OFFSET (GC ,0 , mmTCP_WATCH0_CNTL) + + (watch_id *TCP_WATCH_STRIDE )), + watch_address_cntl); + +WREG32 ((SOC15_REG_OFFSET (GC ,0 , mmTCP_WATCH0_ADDR_H) + + (watch_id *TCP_WATCH_STRIDE )), + watch_address_high); + +WREG32 ((SOC15_REG_OFFSET (GC ,0 , mmTCP_WATCH0_ADDR_L) + + (watch_id *TCP_WATCH_STRIDE )), + watch_address_low); + +/* Enable the watch point */ + watch_address_cntl =REG_SET_FIELD (watch_address_cntl, +TCP_WATCH0_CNTL , +VALID , +1 ); + +WREG32 ((SOC15_REG_OFFSET (GC ,0 , mmTCP_WATCH0_CNTL) + + (watch_id *TCP_WATCH_STRIDE )), + watch_address_cntl); + +return 0 ; +} + +uint32_t kgd_gfx_v10_clear_address_watch (struct amdgpu_device *adev, +uint32_t watch_id) +{ +uint32_t watch_address_cntl; + + watch_address_cntl =0 ; + +WREG32 ((SOC15_REG_OFFSET (GC ,0 , mmTCP_WATCH0_CNTL) + + (watch_id *TCP_WATCH_STRIDE )), + watch_address_cntl); + +return 0 ; +} + +/* kgd_gfx_v10_get_iq_wait_times: Returns the mmCP_IQ_WAIT_TIME1/2 values * The values read are: * ib_offload_wait_time -- Wait Count for Indirect Buffer Offloads. @@ -966,6 +1042,8 @@ const struct kfd2kgd_calls gfx_v10_kfd2kgd = { .validate_trap_override_request = kgd_gfx_v10_validate_trap_override_request, .set_wave_launch_trap_override = kgd_gfx_v10_set_wave_launch_trap_override, .set_wave_launch_mode = kgd_gfx_v10_set_wave_launch_mode, + .set_address_watch = kgd_gfx_v10_set_address_watch, + .clear_address_watch = kgd_gfx_v10_clear_address_watch, .get_iq_wait_times = kgd_gfx_v10_get_iq_wait_times, .build_grace_period_packet_info = kgd_gfx_v10_build_grace_period_packet_info, .program_trap_handler_settings = program_trap_handler_settings,drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v10.h +8
-0@@ -39,6 +39,14 @@ uint32_t kgd_gfx_v10_set_wave_launch_trap_override(struct amdgpu_device *adev,uint32_t kgd_gfx_v10_set_wave_launch_mode (struct amdgpu_device *adev,uint8_t wave_launch_mode,uint32_t vmid); +uint32_t kgd_gfx_v10_set_address_watch (struct amdgpu_device *adev, +uint64_t watch_address, +uint32_t watch_address_mask, +uint32_t watch_id, +uint32_t watch_mode, +uint32_t debug_vmid); +uint32_t kgd_gfx_v10_clear_address_watch (struct amdgpu_device *adev, +uint32_t watch_id);void kgd_gfx_v10_get_iq_wait_times (struct amdgpu_device *adev,uint32_t *wait_times); void kgd_gfx_v10_build_grace_period_packet_info(struct amdgpu_device *adev, uint32_t wait_times,drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v10_3.c +3
-2@@ -676,6 +676,7 @@ const struct kfd2kgd_calls gfx_v10_3_kfd2kgd = { .disable_debug_trap = kgd_gfx_v10_disable_debug_trap, .validate_trap_override_request = kgd_gfx_v10_validate_trap_override_request, .set_wave_launch_trap_override = kgd_gfx_v10_set_wave_launch_trap_override, - .set_wave_launch_mode = kgd_gfx_v10_set_wave_launch_mode - + .set_wave_launch_mode = kgd_gfx_v10_set_wave_launch_mode, + .set_address_watch = kgd_gfx_v10_set_address_watch, + .clear_address_watch = kgd_gfx_v10_clear_address_watch };drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v11.c +51
-1@@ -736,6 +736,54 @@ static uint32_t kgd_gfx_v11_set_wave_launch_mode(struct amdgpu_device *adev,return data; } +#define TCP_WATCH_STRIDE (regTCP_WATCH1_ADDR_H - regTCP_WATCH0_ADDR_H) +static uint32_t kgd_gfx_v11_set_address_watch (struct amdgpu_device *adev, +uint64_t watch_address, +uint32_t watch_address_mask, +uint32_t watch_id, +uint32_t watch_mode, +uint32_t debug_vmid) +{ +uint32_t watch_address_high; +uint32_t watch_address_low; +uint32_t watch_address_cntl; + + watch_address_cntl =0 ; + watch_address_low =lower_32_bits (watch_address); + watch_address_high =upper_32_bits (watch_address) &0xffff ; + + watch_address_cntl =REG_SET_FIELD (watch_address_cntl, +TCP_WATCH0_CNTL , +MODE , + watch_mode); + + watch_address_cntl =REG_SET_FIELD (watch_address_cntl, +TCP_WATCH0_CNTL , +MASK , + watch_address_mask >>7 ); + + watch_address_cntl =REG_SET_FIELD (watch_address_cntl, +TCP_WATCH0_CNTL , +VALID , +1 ); + +WREG32_RLC ((SOC15_REG_OFFSET (GC ,0 , regTCP_WATCH0_ADDR_H) + + (watch_id *TCP_WATCH_STRIDE )), + watch_address_high); + +WREG32_RLC ((SOC15_REG_OFFSET (GC ,0 , regTCP_WATCH0_ADDR_L) + + (watch_id *TCP_WATCH_STRIDE )), + watch_address_low); + +return watch_address_cntl; +} + +uint32_t kgd_gfx_v11_clear_address_watch (struct amdgpu_device *adev, +uint32_t watch_id) +{ +return 0 ; +} +const struct kfd2kgd_calls gfx_v11_kfd2kgd = { .program_sh_mem_settings = program_sh_mem_settings_v11, .set_pasid_vmid_mapping = set_pasid_vmid_mapping_v11,@@ -756,5 +804,7 @@ const struct kfd2kgd_calls gfx_v11_kfd2kgd = { .disable_debug_trap = kgd_gfx_v11_disable_debug_trap, .validate_trap_override_request = kgd_gfx_v11_validate_trap_override_request, .set_wave_launch_trap_override = kgd_gfx_v11_set_wave_launch_trap_override, - .set_wave_launch_mode = kgd_gfx_v11_set_wave_launch_mode + .set_wave_launch_mode = kgd_gfx_v11_set_wave_launch_mode, + .set_address_watch = kgd_gfx_v11_set_address_watch, + .clear_address_watch = kgd_gfx_v11_clear_address_watch };drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v9.c +77
-0@@ -814,6 +814,81 @@ uint32_t kgd_gfx_v9_set_wave_launch_mode(struct amdgpu_device *adev,return 0 ; } +#define TCP_WATCH_STRIDE (mmTCP_WATCH1_ADDR_H - mmTCP_WATCH0_ADDR_H) +uint32_t kgd_gfx_v9_set_address_watch (struct amdgpu_device *adev, +uint64_t watch_address, +uint32_t watch_address_mask, +uint32_t watch_id, +uint32_t watch_mode, +uint32_t debug_vmid) +{ +uint32_t watch_address_high; +uint32_t watch_address_low; +uint32_t watch_address_cntl; + + watch_address_cntl =0 ; + + watch_address_low =lower_32_bits (watch_address); + watch_address_high =upper_32_bits (watch_address) &0xffff ; + + watch_address_cntl =REG_SET_FIELD (watch_address_cntl, +TCP_WATCH0_CNTL , +VMID , + debug_vmid); + watch_address_cntl =REG_SET_FIELD (watch_address_cntl, +TCP_WATCH0_CNTL , +MODE , + watch_mode); + watch_address_cntl =REG_SET_FIELD (watch_address_cntl, +TCP_WATCH0_CNTL , +MASK , + watch_address_mask >>6 ); + +/* Turning off this watch point until we set all the registers */ + watch_address_cntl =REG_SET_FIELD (watch_address_cntl, +TCP_WATCH0_CNTL , +VALID , +0 ); + +WREG32_RLC ((SOC15_REG_OFFSET (GC ,0 , mmTCP_WATCH0_CNTL) + + (watch_id *TCP_WATCH_STRIDE )), + watch_address_cntl); + +WREG32_RLC ((SOC15_REG_OFFSET (GC ,0 , mmTCP_WATCH0_ADDR_H) + + (watch_id *TCP_WATCH_STRIDE )), + watch_address_high); + +WREG32_RLC ((SOC15_REG_OFFSET (GC ,0 , mmTCP_WATCH0_ADDR_L) + + (watch_id *TCP_WATCH_STRIDE )), + watch_address_low); + +/* Enable the watch point */ + watch_address_cntl =REG_SET_FIELD (watch_address_cntl, +TCP_WATCH0_CNTL , +VALID , +1 ); + +WREG32_RLC ((SOC15_REG_OFFSET (GC ,0 , mmTCP_WATCH0_CNTL) + + (watch_id *TCP_WATCH_STRIDE )), + watch_address_cntl); + +return 0 ; +} + +uint32_t kgd_gfx_v9_clear_address_watch (struct amdgpu_device *adev, +uint32_t watch_id) +{ +uint32_t watch_address_cntl; + + watch_address_cntl =0 ; + +WREG32_RLC ((SOC15_REG_OFFSET (GC ,0 , mmTCP_WATCH0_CNTL) + + (watch_id *TCP_WATCH_STRIDE )), + watch_address_cntl); + +return 0 ; +} +/* kgd_gfx_v9_get_iq_wait_times: Returns the mmCP_IQ_WAIT_TIME1/2 values * The values read are: * ib_offload_wait_time -- Wait Count for Indirect Buffer Offloads. @@ -1085,6 +1160,8 @@ const struct kfd2kgd_calls gfx_v9_kfd2kgd = { .validate_trap_override_request = kgd_gfx_v9_validate_trap_override_request, .set_wave_launch_trap_override = kgd_gfx_v9_set_wave_launch_trap_override, .set_wave_launch_mode = kgd_gfx_v9_set_wave_launch_mode, + .set_address_watch = kgd_gfx_v9_set_address_watch, + .clear_address_watch = kgd_gfx_v9_clear_address_watch, .get_iq_wait_times = kgd_gfx_v9_get_iq_wait_times, .build_grace_period_packet_info = kgd_gfx_v9_build_grace_period_packet_info, .get_cu_occupancy = kgd_gfx_v9_get_cu_occupancy,drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v9.h +8
-0@@ -77,6 +77,14 @@ uint32_t kgd_gfx_v9_set_wave_launch_trap_override(struct amdgpu_device *adev,uint32_t trap_mask_request, uint32_t *trap_mask_prev, uint32_t kfd_dbg_trap_cntl_prev); +uint32_t kgd_gfx_v9_set_address_watch (struct amdgpu_device *adev, +uint64_t watch_address, +uint32_t watch_address_mask, +uint32_t watch_id, +uint32_t watch_mode, +uint32_t debug_vmid); +uint32_t kgd_gfx_v9_clear_address_watch (struct amdgpu_device *adev, +uint32_t watch_id);void kgd_gfx_v9_get_iq_wait_times (struct amdgpu_device *adev,uint32_t *wait_times); void kgd_gfx_v9_build_grace_period_packet_info(struct amdgpu_device *adev, uint32_t wait_times,drivers/gpu/drm/amd/amdkfd/kfd_chardev.c +1
-0@@ -2802,6 +2802,7 @@ static int kfd_ioctl_set_debug_trap(struct file *filep, struct kfd_process *p, vstruct task_struct *thread =NULL ;struct pid *pid =NULL ;struct kfd_process *target =NULL ; +struct kfd_process_device *pdd =NULL ;int r =0 ;if (sched_policy ==KFD_SCHED_POLICY_NO_HWS ) {
drivers/gpu/drm/amd/amdkfd/kfd_chardev.c static int kfd_ioctl_set_debug_trap(struct file *filep, struct kfd_process *p, v · line 2874
Quoted 5 lines
drivers/gpu/drm/amd/amdkfd/kfd_chardev.c +2
-0@@ -2869,6 +2870,20 @@ static int kfd_ioctl_set_debug_trap(struct file *filep, struct kfd_process *p, v goto unlock_out; } +if (args->op ==KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH || + args->op ==KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH ) {
The indentation is still messed up here. The second line should be aligned with the open parenthesis. With that fixed, the patch is
Quoted 255 lines
drivers/gpu/drm/amd/amdkfd/kfd_chardev.c +21
-0+int user_gpu_id =kfd_process_get_user_gpu_id (target, + args->op ==KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH ? + args->set_node_address_watch.gpu_id : + args->clear_node_address_watch.gpu_id); + + pdd =kfd_process_device_data_by_id (target, user_gpu_id); +if (user_gpu_id == -EINVAL || !pdd) { + r = -ENODEV ; + goto unlock_out; + } + } +switch (args->op) {case KFD_IOC_DBG_TRAP_ENABLE :if (target != p)@@ -2921,7 +2936,16 @@ static int kfd_ioctl_set_debug_trap(struct file *filep, struct kfd_process *p, v (uint32_t *)args->resume_queues.queue_array_ptr);break ;case KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH : + r =kfd_dbg_trap_set_dev_address_watch (pdd, + args->set_node_address_watch.address, + args->set_node_address_watch.mask, + &args->set_node_address_watch.id, + args->set_node_address_watch.mode); +break ;case KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH : + r =kfd_dbg_trap_clear_dev_address_watch (pdd, + args->clear_node_address_watch.id); +break ;case KFD_IOC_DBG_TRAP_SET_FLAGS :case KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT :case KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO :drivers/gpu/drm/amd/amdkfd/kfd_debug.c +136
-0@@ -24,6 +24,8 @@#include "kfd_device_queue_manager.h" #include <linux/file.h> +#define MAX_WATCH_ADDRESSES 4 +void debug_event_write_work_handler (struct work_struct *work) {struct kfd_process *process;@@ -291,6 +293,139 @@ int kfd_dbg_set_mes_debug_mode(struct kfd_process_device *pdd) pdd->watch_points, flags); } +#define KFD_DEBUGGER_INVALID_WATCH_POINT_ID -1 +static int kfd_dbg_get_dev_watch_id (struct kfd_process_device *pdd,int *watch_id) +{ +int i; + + *watch_id =KFD_DEBUGGER_INVALID_WATCH_POINT_ID ; + +spin_lock (&pdd->dev->watch_points_lock); + +for (i =0 ; i <MAX_WATCH_ADDRESSES ; i++) { +/* device watchpoint in use so skip */ +if ((pdd->dev->alloc_watch_ids >> i) &0x1 ) +continue ; + + pdd->alloc_watch_ids |=0x1 << i; + pdd->dev->alloc_watch_ids |=0x1 << i; + *watch_id = i; +spin_unlock (&pdd->dev->watch_points_lock); +return 0 ; + } + +spin_unlock (&pdd->dev->watch_points_lock); + +return -ENOMEM ; +} + +static void kfd_dbg_clear_dev_watch_id (struct kfd_process_device *pdd,int watch_id) +{ +spin_lock (&pdd->dev->watch_points_lock); + +/* process owns device watch point so safe to clear */ +if ((pdd->alloc_watch_ids >> watch_id) &0x1 ) { + pdd->alloc_watch_ids &= ~(0x1 << watch_id); + pdd->dev->alloc_watch_ids &= ~(0x1 << watch_id); + } + +spin_unlock (&pdd->dev->watch_points_lock); +} + +static bool kfd_dbg_owns_dev_watch_id (struct kfd_process_device *pdd,int watch_id) +{ +bool owns_watch_id = false; + +spin_lock (&pdd->dev->watch_points_lock); + owns_watch_id = watch_id <MAX_WATCH_ADDRESSES && + ((pdd->alloc_watch_ids >> watch_id) &0x1 ); + +spin_unlock (&pdd->dev->watch_points_lock); + +return owns_watch_id; +} + +int kfd_dbg_trap_clear_dev_address_watch (struct kfd_process_device *pdd, +uint32_t watch_id) +{ +int r; + +if (!kfd_dbg_owns_dev_watch_id (pdd, watch_id)) +return -EINVAL ; + +if (!pdd->dev->shared_resources.enable_mes) { + r =debug_lock_and_unmap (pdd->dev->dqm); +if (r) +return r; + } + +amdgpu_gfx_off_ctrl (pdd->dev->adev, false); + pdd->watch_points[watch_id] = pdd->dev->kfd2kgd->clear_address_watch ( + pdd->dev->adev, + watch_id); +amdgpu_gfx_off_ctrl (pdd->dev->adev, true); + +if (!pdd->dev->shared_resources.enable_mes) + r =debug_map_and_unlock (pdd->dev->dqm); +else + r =kfd_dbg_set_mes_debug_mode (pdd); + +kfd_dbg_clear_dev_watch_id (pdd, watch_id); + +return r; +} + +int kfd_dbg_trap_set_dev_address_watch (struct kfd_process_device *pdd, +uint64_t watch_address, +uint32_t watch_address_mask, +uint32_t *watch_id, +uint32_t watch_mode) +{ +int r =kfd_dbg_get_dev_watch_id (pdd, watch_id); + +if (r) +return r; + +if (!pdd->dev->shared_resources.enable_mes) { + r =debug_lock_and_unmap (pdd->dev->dqm); +if (r) { +kfd_dbg_clear_dev_watch_id (pdd, *watch_id); +return r; + } + } + +amdgpu_gfx_off_ctrl (pdd->dev->adev, false); + pdd->watch_points[*watch_id] = pdd->dev->kfd2kgd->set_address_watch ( + pdd->dev->adev, + watch_address, + watch_address_mask, + *watch_id, + watch_mode, + pdd->dev->vm_info.last_vmid_kfd); +amdgpu_gfx_off_ctrl (pdd->dev->adev, true); + +if (!pdd->dev->shared_resources.enable_mes) + r =debug_map_and_unlock (pdd->dev->dqm); +else + r =kfd_dbg_set_mes_debug_mode (pdd); + +/* HWS is broken so no point in HW rollback but release the watchpoint anyways */ +if (r) +kfd_dbg_clear_dev_watch_id (pdd, *watch_id); + +return 0 ; +} + +static void kfd_dbg_clear_process_address_watch (struct kfd_process *target) +{ +int i, j; + +for (i =0 ; i < target->n_pdds; i++) +for (j =0 ; j <MAX_WATCH_ADDRESSES ; j++) +kfd_dbg_trap_clear_dev_address_watch (target->pdds[i], j); +} + +/* kfd_dbg_trap_deactivate: * target: target process * unwind: If this is unwinding a failed kfd_dbg_trap_enable() @@ -305,6 +440,7 @@ void kfd_dbg_trap_deactivate(struct kfd_process *target, bool unwind, int unwindif (!unwind) {cancel_work_sync (&target->debug_event_workarea); +kfd_dbg_clear_process_address_watch (target);kfd_dbg_trap_set_wave_launch_mode (target,0 ); }drivers/gpu/drm/amd/amdkfd/kfd_debug.h +7
-1@@ -50,7 +50,13 @@ int kfd_dbg_trap_set_wave_launch_override(struct kfd_process *target, uint32_t *trap_mask_supported);int kfd_dbg_trap_set_wave_launch_mode (struct kfd_process *target,uint8_t wave_launch_mode); - +int kfd_dbg_trap_clear_dev_address_watch (struct kfd_process_device *pdd, +uint32_t watch_id); +int kfd_dbg_trap_set_dev_address_watch (struct kfd_process_device *pdd, +uint64_t watch_address, +uint32_t watch_address_mask, +uint32_t *watch_id, +uint32_t watch_mode); int kfd_dbg_send_exception_to_runtime(struct kfd_process *p, unsigned int dev_id, unsigned int queue_id,drivers/gpu/drm/amd/amdkfd/kfd_device.c +1
-0@@ -641,6 +641,7 @@ bool kgd2kfd_device_init(struct kfd_dev *kfd, }kfd_smi_init (kfd); +spin_lock_init (&kfd->watch_points_lock); kfd->init_complete = true; dev_info(kfd_device, "added device %x:%x\n", kfd->adev->pdev->vendor,drivers/gpu/drm/amd/amdkfd/kfd_priv.h +5
-1@@ -348,6 +348,10 @@ struct kfd_dev {/* HMM page migration MEMORY_DEVICE_PRIVATE mapping */ struct dev_pagemap pgmap; + +/* Track per device allocated watch points */ +uint32_t alloc_watch_ids; +spinlock_t watch_points_lock; };enum kfd_mempool {@@ -799,6 +803,7 @@ struct kfd_process_device {uint32_t spi_dbg_override;uint32_t spi_dbg_launch_mode;uint32_t watch_points[4 ]; +uint32_t alloc_watch_ids;/* * If this process has been checkpointed before, then the user @@ -955,7 +960,6 @@ struct kfd_process {struct semaphore runtime_enable_sema;bool is_runtime_retry;struct kfd_runtime_info runtime_info; - };#define KFD_PROCESS_TABLE_SIZE 5/* bits: 32 entries */
PATCH 27/32 drm/amdkfd: add debug set flags operation
In reply to Jonathan KimAllow the debugger to set single memory and single ALU operations.
Some exceptions are imprecise (memory violations, address watch) in the sense that a trap occurs only when the exception interrupt occurs and not at the non-halting faulty instruction. Trap temporaries 0 & 1 save the program counter address, which means that these values will not point to the faulty instruction address but to whenever the interrupt was raised.
Setting the Single Memory Operations flag will inject an automatic wait on every memory operation instruction forcing imprecise memory exceptions to become precise at the cost of performance. This setting is not permitted on debug devices that support only a global setting of this option.
Return the previous set flags to the debugger as well.
v3: make precise mem op the only available flag for now.
v2: add gfx11 support.
--- drivers/gpu/drm/amd/amdkfd/kfd_chardev.c | 2 ++ drivers/gpu/drm/amd/amdkfd/kfd_debug.c | 38 ++++++++++++++++++++++++ drivers/gpu/drm/amd/amdkfd/kfd_debug.h | 1 + 3 files changed, 41 insertions(+)
drivers/gpu/drm/amd/amdkfd/kfd_chardev.c +2 -0
@@ -2947,6 +2947,8 @@ static int kfd_ioctl_set_debug_trap(struct file *filep, struct kfd_process *p, v args->clear_node_address_watch.id);break ;case KFD_IOC_DBG_TRAP_SET_FLAGS : + r =kfd_dbg_trap_set_flags (target, &args->set_flags.flags); +break ;case KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT :case KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO :case KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT :
drivers/gpu/drm/amd/amdkfd/kfd_debug.c +38 -0
@@ -23,6 +23,7 @@#include "kfd_debug.h" #include "kfd_device_queue_manager.h" #include <linux/file.h> +#include <uapi/linux/kfd_ioctl.h> #define MAX_WATCH_ADDRESSES 4
@@ -425,6 +426,40 @@ static void kfd_dbg_clear_process_address_watch(struct kfd_process *target)kfd_dbg_trap_clear_dev_address_watch (target->pdds[i], j); } +int kfd_dbg_trap_set_flags (struct kfd_process *target,uint32_t *flags) +{ +uint32_t prev_flags = target->dbg_flags; +int i, r =0 ; + +for (i =0 ; i < target->n_pdds; i++) { +if (!kfd_dbg_is_per_vmid_supported (target->pdds[i]->dev) && + (*flags &KFD_DBG_TRAP_FLAG_SINGLE_MEM_OP )) { + *flags = prev_flags; +return -EACCES ; + } + } + + target->dbg_flags = *flags &KFD_DBG_TRAP_FLAG_SINGLE_MEM_OP ; + *flags = prev_flags; +for (i =0 ; i < target->n_pdds; i++) { +struct kfd_process_device *pdd = target->pdds[i]; + +if (!kfd_dbg_is_per_vmid_supported (pdd->dev)) +continue ; + +if (!pdd->dev->shared_resources.enable_mes) + r =debug_refresh_runlist (pdd->dev->dqm); +else + r =kfd_dbg_set_mes_debug_mode (pdd); + +if (r) { + target->dbg_flags = prev_flags; +break ; + } + } + +return r; +}/* kfd_dbg_trap_deactivate: * target: target process
@@ -439,9 +474,12 @@ void kfd_dbg_trap_deactivate(struct kfd_process *target, bool unwind, int unwindint i, count =0 ;if (!unwind) { +uint32_t flags =0 ;cancel_work_sync (&target->debug_event_workarea);kfd_dbg_clear_process_address_watch (target);kfd_dbg_trap_set_wave_launch_mode (target,0 ); + +kfd_dbg_trap_set_flags (target, &flags); }for (i =0 ; i < target->n_pdds; i++) {
drivers/gpu/drm/amd/amdkfd/kfd_debug.h +1 -0
@@ -57,6 +57,7 @@ int kfd_dbg_trap_set_dev_address_watch(struct kfd_process_device *pdd,uint32_t watch_address_mask, uint32_t *watch_id, uint32_t watch_mode); +int kfd_dbg_trap_set_flags (struct kfd_process *target,uint32_t *flags); int kfd_dbg_send_exception_to_runtime(struct kfd_process *p, unsigned int dev_id, unsigned int queue_id,
Signature · 1 line
2.25.1
Felix Kuehling
maintainerRe: [PATCH 27/32] drm/amdkfd: add debug set flags operation
Am 2023-01-25 um 14:53 schrieb Jonathan Kim:
Quoted 76 lines
Allow the debugger to set single memory and single ALU operations.
Some exceptions are imprecise (memory violations, address watch) in the sense that a trap occurs only when the exception interrupt occurs and not at the non-halting faulty instruction. Trap temporaries 0 & 1 save the program counter address, which means that these values will not point to the faulty instruction address but to whenever the interrupt was raised.
Setting the Single Memory Operations flag will inject an automatic wait on every memory operation instruction forcing imprecise memory exceptions to become precise at the cost of performance. This setting is not permitted on debug devices that support only a global setting of this option.
Return the previous set flags to the debugger as well.
v3: make precise mem op the only available flag for now.
v2: add gfx11 support.
Signed-off-by Jonathan Kim <[email protected]>--- drivers/gpu/drm/amd/amdkfd/kfd_chardev.c | 2 ++ drivers/gpu/drm/amd/amdkfd/kfd_debug.c | 38 ++++++++++++++++++++++++ drivers/gpu/drm/amd/amdkfd/kfd_debug.h | 1 + 3 files changed, 41 insertions(+)drivers/gpu/drm/amd/amdkfd/kfd_chardev.c +2
-0@@ -2947,6 +2947,8 @@ static int kfd_ioctl_set_debug_trap(struct file *filep, struct kfd_process *p, v args->clear_node_address_watch.id);break ;case KFD_IOC_DBG_TRAP_SET_FLAGS : + r =kfd_dbg_trap_set_flags (target, &args->set_flags.flags); +break ;case KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT :case KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO :case KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT :drivers/gpu/drm/amd/amdkfd/kfd_debug.c +20
-0@@ -23,6 +23,7 @@#include "kfd_debug.h" #include "kfd_device_queue_manager.h" #include <linux/file.h> +#include <uapi/linux/kfd_ioctl.h> #define MAX_WATCH_ADDRESSES 4@@ -425,6 +426,40 @@ static void kfd_dbg_clear_process_address_watch(struct kfd_process *target)kfd_dbg_trap_clear_dev_address_watch (target->pdds[i], j); } +int kfd_dbg_trap_set_flags (struct kfd_process *target,uint32_t *flags) +{ +uint32_t prev_flags = target->dbg_flags; +int i, r =0 ; + +for (i =0 ; i < target->n_pdds; i++) { +if (!kfd_dbg_is_per_vmid_supported (target->pdds[i]->dev) && + (*flags &KFD_DBG_TRAP_FLAG_SINGLE_MEM_OP )) { + *flags = prev_flags; +return -EACCES ; + } + } + + target->dbg_flags = *flags &KFD_DBG_TRAP_FLAG_SINGLE_MEM_OP ; + *flags = prev_flags; +for (i =0 ; i < target->n_pdds; i++) { +struct kfd_process_device *pdd = target->pdds[i]; + +if (!kfd_dbg_is_per_vmid_supported (pdd->dev))
drivers/gpu/drm/amd/amdkfd/kfd_debug.c static void kfd_dbg_clear_process_address_watch(struct kfd_process *target) · line 457
Quoted 10 lines
drivers/gpu/drm/amd/amdkfd/kfd_debug.c +10
-0+continue ; + +if (!pdd->dev->shared_resources.enable_mes) + r =debug_refresh_runlist (pdd->dev->dqm); +else + r =kfd_dbg_set_mes_debug_mode (pdd); + +if (r) { + target->dbg_flags = prev_flags; +break ;
Do we need to roll back changes on the other GPUs when this happens?
drivers/gpu/drm/amd/amdkfd/kfd_debug.c void kfd_dbg_trap_deactivate(struct kfd_process *target, bool unwind, int unwind · line 477
Quoted 13 lines
drivers/gpu/drm/amd/amdkfd/kfd_debug.c +6
-0+ } + } + +return r; +}/* kfd_dbg_trap_deactivate: * target: target process @@ -439,9 +474,12 @@ void kfd_dbg_trap_deactivate(struct kfd_process *target, bool unwind, int unwindint i, count =0 ;if (!unwind) { +uint32_t flags =0 ;
checkpatch.pl will complain without an empty line after the variable declaration.
Regards,
Felix
Quoted 20 lines
drivers/gpu/drm/amd/amdkfd/kfd_debug.c +2
-0cancel_work_sync (&target->debug_event_workarea);kfd_dbg_clear_process_address_watch (target);kfd_dbg_trap_set_wave_launch_mode (target,0 ); + +kfd_dbg_trap_set_flags (target, &flags); }for (i =0 ; i < target->n_pdds; i++) {drivers/gpu/drm/amd/amdkfd/kfd_debug.h +1
-0@@ -57,6 +57,7 @@ int kfd_dbg_trap_set_dev_address_watch(struct kfd_process_device *pdd,uint32_t watch_address_mask, uint32_t *watch_id, uint32_t watch_mode); +int kfd_dbg_trap_set_flags (struct kfd_process *target,uint32_t *flags); int kfd_dbg_send_exception_to_runtime(struct kfd_process *p, unsigned int dev_id, unsigned int queue_id,
PATCH 28/32 drm/amdkfd: add debug query event operation
In reply to Jonathan KimAllow the debugger to query a single queue, device and process exception.
The KFD should also return the GPU or Queue id of the exception. The debugger also has the option of clearing exceptions after being queried.
--- drivers/gpu/drm/amd/amdkfd/kfd_chardev.c | 6 +++ drivers/gpu/drm/amd/amdkfd/kfd_debug.c | 64 ++++++++++++++++++++++++ drivers/gpu/drm/amd/amdkfd/kfd_debug.h | 5 ++ 3 files changed, 75 insertions(+)
drivers/gpu/drm/amd/amdkfd/kfd_chardev.c +6 -0
@@ -2950,6 +2950,12 @@ static int kfd_ioctl_set_debug_trap(struct file *filep, struct kfd_process *p, v r =kfd_dbg_trap_set_flags (target, &args->set_flags.flags);break ;case KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT : + r =kfd_dbg_ev_query_debug_event (target, + &args->query_debug_event.queue_id, + &args->query_debug_event.gpu_id, + args->query_debug_event.exception_mask, + &args->query_debug_event.exception_mask); +break ;case KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO :case KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT :case KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT :
drivers/gpu/drm/amd/amdkfd/kfd_debug.c +64 -0
70 lines not on this page · raw message
drivers/gpu/drm/amd/amdkfd/kfd_debug.h +5 -0
@@ -27,6 +27,11 @@void kfd_dbg_trap_deactivate (struct kfd_process *target,bool unwind,int unwind_count);int kfd_dbg_trap_activate (struct kfd_process *target); +int kfd_dbg_ev_query_debug_event (struct kfd_process *process, +unsigned int *queue_id, +unsigned int *gpu_id, +uint64_t exception_clear_mask, +uint64_t *event_status); bool kfd_set_dbg_ev_from_interrupt(struct kfd_dev *dev, unsigned int pasid, uint32_t doorbell_id,
Signature · 1 line
2.25.1
PATCH 29/32 drm/amdkfd: add debug query exception info operation
In reply to Jonathan KimAllow the debugger to query additional info based on an exception code. For device exceptions, it's currently only memory violation information. For process exceptions, it's currently only runtime information. Queue exception only report the queue exception status.
The debugger has the option of clearing the target exception on query.
--- drivers/gpu/drm/amd/amdkfd/kfd_chardev.c | 7 ++ drivers/gpu/drm/amd/amdkfd/kfd_debug.c | 120 +++++++++++++++++++++++ drivers/gpu/drm/amd/amdkfd/kfd_debug.h | 6 ++ 3 files changed, 133 insertions(+)
drivers/gpu/drm/amd/amdkfd/kfd_chardev.c +7 -0
@@ -2957,6 +2957,13 @@ static int kfd_ioctl_set_debug_trap(struct file *filep, struct kfd_process *p, v &args->query_debug_event.exception_mask);break ;case KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO : + r =kfd_dbg_trap_query_exception_info (target, + args->query_exception_info.source_id, + args->query_exception_info.exception_code, + args->query_exception_info.clear_exception, + (void __user *)args->query_exception_info.info_ptr, + &args->query_exception_info.info_size); +break ;case KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT :case KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT :pr_warn ("Debug op %i not supported yet\n" , args->op);
drivers/gpu/drm/amd/amdkfd/kfd_debug.c +120 -0
126 lines not on this page · raw message
drivers/gpu/drm/amd/amdkfd/kfd_debug.h +6 -0
@@ -63,6 +63,12 @@ int kfd_dbg_trap_set_dev_address_watch(struct kfd_process_device *pdd,uint32_t *watch_id, uint32_t watch_mode);int kfd_dbg_trap_set_flags (struct kfd_process *target,uint32_t *flags); +int kfd_dbg_trap_query_exception_info (struct kfd_process *target, +uint32_t source_id, +uint32_t exception_code, +bool clear_exception, +void __user *info, +uint32_t *info_size); int kfd_dbg_send_exception_to_runtime(struct kfd_process *p, unsigned int dev_id, unsigned int queue_id,
Signature · 1 line
2.25.1
PATCH 30/32 drm/amdkfd: add debug queue snapshot operation
In reply to Jonathan KimAllow the debugger to get a snapshot of a specified number of queues containing various queue property information that is copied to the debugger.
Since the debugger doesn't know how many queues exist at any given time, allow the debugger to pass the requested number of snapshots as 0 to get the actual number of potential snapshots to use for a subsequent snapshot request for actual information.
To prevent future ABI breakage, pass in the requested entry_size. The KFD will return it's own entry_size in case the debugger still wants log the information in a core dump on sizing failure.
Also allow the debugger to clear exceptions when doing a snapshot.
v3: fix uninitialized return and change queue snapshot to type void for proper increment on buffer copy.
use memset 0 to init snapshot entry to clear struct padding.
v2: change buf_size arg to num_queues for clarity. fix minimum entry size calculation.
--- drivers/gpu/drm/amd/amdkfd/kfd_chardev.c | 6 +++ .../drm/amd/amdkfd/kfd_device_queue_manager.c | 36 ++++++++++++++++ .../drm/amd/amdkfd/kfd_device_queue_manager.h | 3 ++ drivers/gpu/drm/amd/amdkfd/kfd_priv.h | 5 +++ .../amd/amdkfd/kfd_process_queue_manager.c | 41 +++++++++++++++++++ 5 files changed, 91 insertions(+)
drivers/gpu/drm/amd/amdkfd/kfd_chardev.c +6 -0
@@ -2965,6 +2965,12 @@ static int kfd_ioctl_set_debug_trap(struct file *filep, struct kfd_process *p, v &args->query_exception_info.info_size);break ;case KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT : + r =pqm_get_queue_snapshot (&target->pqm, + args->queue_snapshot.exception_mask, + (void __user *)args->queue_snapshot.snapshot_buf_ptr, + &args->queue_snapshot.num_queues, + &args->queue_snapshot.entry_size); +break ;case KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT :pr_warn ("Debug op %i not supported yet\n" , args->op); r = -EACCES ;
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +36 -0
@@ -3000,6 +3000,42 @@ int suspend_queues(struct kfd_process *p,return total_suspended; } +static uint32_t set_queue_type_for_user (struct queue_properties *q_props) +{ +switch (q_props->type) { +case KFD_QUEUE_TYPE_COMPUTE : +return q_props->format ==KFD_QUEUE_FORMAT_PM4 + ?KFD_IOC_QUEUE_TYPE_COMPUTE + :KFD_IOC_QUEUE_TYPE_COMPUTE_AQL ; +case KFD_QUEUE_TYPE_SDMA : +return KFD_IOC_QUEUE_TYPE_SDMA ; +case KFD_QUEUE_TYPE_SDMA_XGMI : +return KFD_IOC_QUEUE_TYPE_SDMA_XGMI ; +default : +WARN_ONCE (true,"queue type not recognized!" ); +return 0xffffffff ; + }; +} + +void set_queue_snapshot_entry (struct queue *q, +uint64_t exception_clear_mask, +struct kfd_queue_snapshot_entry *qss_entry) +{ + qss_entry->ring_base_address = q->properties.queue_address; + qss_entry->write_pointer_address = (uint64_t )q->properties.write_ptr; + qss_entry->read_pointer_address = (uint64_t )q->properties.read_ptr; + qss_entry->ctx_save_restore_address = + q->properties.ctx_save_restore_area_address; + qss_entry->ctx_save_restore_area_size = + q->properties.ctx_save_restore_area_size; + qss_entry->exception_status = q->properties.exception_status; + qss_entry->queue_id = q->properties.queue_id; + qss_entry->gpu_id = q->device->id; + qss_entry->ring_size = (uint32_t )q->properties.queue_size; + qss_entry->queue_type =set_queue_type_for_user (&q->properties); + q->properties.exception_status &= ~exception_clear_mask; +} +int debug_lock_and_unmap (struct device_queue_manager *dqm) {int r;
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.h +3 -0
@@ -296,6 +296,9 @@ int suspend_queues(struct kfd_process *p,int resume_queues (struct kfd_process *p,uint32_t num_queues,uint32_t *usr_queue_id_array); +void set_queue_snapshot_entry (struct queue *q, +uint64_t exception_clear_mask, +struct kfd_queue_snapshot_entry *qss_entry);int debug_lock_and_unmap (struct device_queue_manager *dqm);int debug_map_and_unlock (struct device_queue_manager *dqm);int debug_refresh_runlist (struct device_queue_manager *dqm);
drivers/gpu/drm/amd/amdkfd/kfd_priv.h +5 -0
@@ -1302,6 +1302,11 @@ int pqm_get_wave_state(struct process_queue_manager *pqm,void __user *ctl_stack, u32 *ctl_stack_used_size, u32 *save_area_used_size); +int pqm_get_queue_snapshot (struct process_queue_manager *pqm, +uint64_t exception_clear_mask, +void __user *buf, +int *num_qss_entries, +uint32_t *entry_size); int amdkfd_fence_wait_timeout(uint64_t *fence_addr, uint64_t fence_value,
drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c +41 -0
47 lines not on this page · raw message
Signature · 1 line
2.25.1
Re: [PATCH 30/32] drm/amdkfd: add debug queue snapshot operation
Am 2023-01-25 um 14:53 schrieb Jonathan Kim:
Quoted 148 lines
Allow the debugger to get a snapshot of a specified number of queues containing various queue property information that is copied to the debugger.
Since the debugger doesn't know how many queues exist at any given time, allow the debugger to pass the requested number of snapshots as 0 to get the actual number of potential snapshots to use for a subsequent snapshot request for actual information.
To prevent future ABI breakage, pass in the requested
entry_size. The KFD will return it's ownentry_sizein case the debugger still wants log the information in a core dump on sizing failure.Also allow the debugger to clear exceptions when doing a snapshot.
v3: fix uninitialized return and change queue snapshot to type void for proper increment on buffer copy.
use memset 0 to init snapshot entry to clear struct padding.v2: change
buf_sizearg tonum_queuesfor clarity. fix minimum entry size calculation.Signed-off-by Jonathan Kim <[email protected]>--- drivers/gpu/drm/amd/amdkfd/kfd_chardev.c | 6 +++ .../drm/amd/amdkfd/kfd_device_queue_manager.c | 36 ++++++++++++++++ .../drm/amd/amdkfd/kfd_device_queue_manager.h | 3 ++ drivers/gpu/drm/amd/amdkfd/kfd_priv.h | 5 +++ .../amd/amdkfd/kfd_process_queue_manager.c | 41 +++++++++++++++++++ 5 files changed, 91 insertions(+)drivers/gpu/drm/amd/amdkfd/kfd_chardev.c +6
-0@@ -2965,6 +2965,12 @@ static int kfd_ioctl_set_debug_trap(struct file *filep, struct kfd_process *p, v &args->query_exception_info.info_size);break ;case KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT : + r =pqm_get_queue_snapshot (&target->pqm, + args->queue_snapshot.exception_mask, + (void __user *)args->queue_snapshot.snapshot_buf_ptr, + &args->queue_snapshot.num_queues, + &args->queue_snapshot.entry_size); +break ;case KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT :pr_warn ("Debug op %i not supported yet\n" , args->op); r = -EACCES ;drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +36
-0@@ -3000,6 +3000,42 @@ int suspend_queues(struct kfd_process *p,return total_suspended; } +static uint32_t set_queue_type_for_user (struct queue_properties *q_props) +{ +switch (q_props->type) { +case KFD_QUEUE_TYPE_COMPUTE : +return q_props->format ==KFD_QUEUE_FORMAT_PM4 + ?KFD_IOC_QUEUE_TYPE_COMPUTE + :KFD_IOC_QUEUE_TYPE_COMPUTE_AQL ; +case KFD_QUEUE_TYPE_SDMA : +return KFD_IOC_QUEUE_TYPE_SDMA ; +case KFD_QUEUE_TYPE_SDMA_XGMI : +return KFD_IOC_QUEUE_TYPE_SDMA_XGMI ; +default : +WARN_ONCE (true,"queue type not recognized!" ); +return 0xffffffff ; + }; +} + +void set_queue_snapshot_entry (struct queue *q, +uint64_t exception_clear_mask, +struct kfd_queue_snapshot_entry *qss_entry) +{ + qss_entry->ring_base_address = q->properties.queue_address; + qss_entry->write_pointer_address = (uint64_t )q->properties.write_ptr; + qss_entry->read_pointer_address = (uint64_t )q->properties.read_ptr; + qss_entry->ctx_save_restore_address = + q->properties.ctx_save_restore_area_address; + qss_entry->ctx_save_restore_area_size = + q->properties.ctx_save_restore_area_size; + qss_entry->exception_status = q->properties.exception_status; + qss_entry->queue_id = q->properties.queue_id; + qss_entry->gpu_id = q->device->id; + qss_entry->ring_size = (uint32_t )q->properties.queue_size; + qss_entry->queue_type =set_queue_type_for_user (&q->properties); + q->properties.exception_status &= ~exception_clear_mask; +} +int debug_lock_and_unmap (struct device_queue_manager *dqm) {int r;drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.h +3
-0@@ -296,6 +296,9 @@ int suspend_queues(struct kfd_process *p,int resume_queues (struct kfd_process *p,uint32_t num_queues,uint32_t *usr_queue_id_array); +void set_queue_snapshot_entry (struct queue *q, +uint64_t exception_clear_mask, +struct kfd_queue_snapshot_entry *qss_entry);int debug_lock_and_unmap (struct device_queue_manager *dqm);int debug_map_and_unlock (struct device_queue_manager *dqm);int debug_refresh_runlist (struct device_queue_manager *dqm);drivers/gpu/drm/amd/amdkfd/kfd_priv.h +5
-0@@ -1302,6 +1302,11 @@ int pqm_get_wave_state(struct process_queue_manager *pqm,void __user *ctl_stack, u32 *ctl_stack_used_size, u32 *save_area_used_size); +int pqm_get_queue_snapshot (struct process_queue_manager *pqm, +uint64_t exception_clear_mask, +void __user *buf, +int *num_qss_entries, +uint32_t *entry_size); int amdkfd_fence_wait_timeout(uint64_t *fence_addr, uint64_t fence_value,drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c +15
-0@@ -576,6 +576,47 @@ int pqm_get_wave_state(struct process_queue_manager *pqm, save_area_used_size); } +int pqm_get_queue_snapshot (struct process_queue_manager *pqm, +uint64_t exception_clear_mask, +void __user *buf, +int *num_qss_entries, +uint32_t *entry_size) +{ +struct process_queue_node *pqn; +uint32_t tmp_entry_size = *entry_size, tmp_qss_entries = *num_qss_entries; +int r =0 ; + + *num_qss_entries =0 ; +if (!(*entry_size)) +return -EINVAL ; + + *entry_size =min_t (size_t, *entry_size,sizeof (struct kfd_queue_snapshot_entry ));
drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c int pqm_get_wave_state(struct process_queue_manager *pqm, · line 603
Quoted 10 lines
drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c +10
-0+mutex_lock (&pqm->process->event_mutex); + +list_for_each_entry (pqn, &pqm->queues, process_queue_list) { +if (!pqn->q) +continue ; + +if (*num_qss_entries < tmp_qss_entries) { +struct kfd_queue_snapshot_entry src; + +memset (&src,0 ,sizeof (src));
I'd move the variable declaration up to the function scope. That way you only need to memset it once outside the loop. With that fixed, the patch is
Quoted 19 lines
drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c +16
-0+ +set_queue_snapshot_entry (pqn->q, exception_clear_mask, &src); + +if (copy_to_user (buf, &src, *entry_size)) { + r = -EFAULT ; +break ; + } + buf += tmp_entry_size; + } + *num_qss_entries +=1 ; + } + +mutex_unlock (&pqm->process->event_mutex); +return r; +} + static int get_queue_data_sizes(struct kfd_process_device *pdd, struct queue *q, uint32_t *mqd_size,
PATCH 31/32 drm/amdkfd: add debug device snapshot operation
In reply to Jonathan KimSimilar to queue snapshot, return an array of device information using an entry_size check and return.
Unlike queue snapshots, the debugger needs to pass to correct number of devices that exist. If it fails to do so, the KFD will return the number of actual devices so that the debugger can make a subsequent successful call.
v3: was reviewed but re-requesting review with new revision and subvendor information.
memset 0 device info entry to clear padding.
v2: change buf_size are to num_devices for more clarity. expand device entry new members on copy.
fix minimum entry size calculation for queue and device snapshot. change device snapshot implementation to match queue snapshot implementation.
--- drivers/gpu/drm/amd/amdkfd/kfd_chardev.c | 7 ++- drivers/gpu/drm/amd/amdkfd/kfd_debug.c | 72 ++++++++++++++++++++++++ drivers/gpu/drm/amd/amdkfd/kfd_debug.h | 5 ++ 3 files changed, 82 insertions(+), 2 deletions(-)
drivers/gpu/drm/amd/amdkfd/kfd_chardev.c +5 -2
@@ -2972,8 +2972,11 @@ static int kfd_ioctl_set_debug_trap(struct file *filep, struct kfd_process *p, v &args->queue_snapshot.entry_size);break ;case KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT : -pr_warn ("Debug op %i not supported yet\n" , args->op); - r = -EACCES ; + r =kfd_dbg_trap_device_snapshot (target, + args->device_snapshot.exception_mask, + (void __user *)args->device_snapshot.snapshot_buf_ptr, + &args->device_snapshot.num_devices, + &args->device_snapshot.entry_size);break ;default :pr_err ("Invalid option: %i\n" , args->op);
drivers/gpu/drm/amd/amdkfd/kfd_debug.c +72 -0
84 lines not on this page · raw message
drivers/gpu/drm/amd/amdkfd/kfd_debug.h +5 -0
@@ -81,6 +81,11 @@ static inline bool kfd_dbg_is_per_vmid_supported(struct kfd_dev *dev) }void debug_event_write_work_handler (struct work_struct *work); +int kfd_dbg_trap_device_snapshot (struct kfd_process *target, +uint64_t exception_clear_mask, +void __user *user_info, +uint32_t *number_of_device_infos, +uint32_t *entry_size);void kfd_dbg_set_enabled_debug_exception_mask (struct kfd_process *target,uint64_t exception_set_mask);
Signature · 1 line
2.25.1
Re: [PATCH 31/32] drm/amdkfd: add debug device snapshot operation
Am 2023-01-25 um 14:54 schrieb Jonathan Kim:
Quoted 11 lines
Similar to queue snapshot, return an array of device information using an
entry_sizecheck and return.
Unlike queue snapshots, the debugger needs to pass to correct number of devices that exist. If it fails to do so, the KFD will return the number of actual devices so that the debugger can make a subsequent successful call.v3: was reviewed but re-requesting review with new revision and subvendor information.
memset 0 device info entry to clear padding.
Quoted 7 lines
v2: change
buf_sizeare tonum_devicesfor more clarity. expand device entry new members on copy.
fix minimum entry size calculation for queue and device snapshot. change device snapshot implementation to match queue snapshot implementation.Signed-off-by Jonathan Kim <[email protected]>
Quoted 130 lines
--- drivers/gpu/drm/amd/amdkfd/kfd_chardev.c | 7 ++- drivers/gpu/drm/amd/amdkfd/kfd_debug.c | 72 ++++++++++++++++++++++++ drivers/gpu/drm/amd/amdkfd/kfd_debug.h | 5 ++ 3 files changed, 82 insertions(+), 2 deletions(-)drivers/gpu/drm/amd/amdkfd/kfd_chardev.c +5
-2@@ -2972,8 +2972,11 @@ static int kfd_ioctl_set_debug_trap(struct file *filep, struct kfd_process *p, v &args->queue_snapshot.entry_size);break ;case KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT : -pr_warn ("Debug op %i not supported yet\n" , args->op); - r = -EACCES ; + r =kfd_dbg_trap_device_snapshot (target, + args->device_snapshot.exception_mask, + (void __user *)args->device_snapshot.snapshot_buf_ptr, + &args->device_snapshot.num_devices, + &args->device_snapshot.entry_size);break ;default :pr_err ("Invalid option: %i\n" , args->op);drivers/gpu/drm/amd/amdkfd/kfd_debug.c +72
-0@@ -22,6 +22,7 @@#include "kfd_debug.h" #include "kfd_device_queue_manager.h" +#include "kfd_topology.h" #include <linux/file.h> #include <uapi/linux/kfd_ioctl.h> @@ -998,6 +999,77 @@ int kfd_dbg_trap_query_exception_info(struct kfd_process *target,return r; } +int kfd_dbg_trap_device_snapshot (struct kfd_process *target, +uint64_t exception_clear_mask, +void __user *user_info, +uint32_t *number_of_device_infos, +uint32_t *entry_size) +{ +struct kfd_dbg_device_info_entry device_info; +uint32_t tmp_entry_size = *entry_size, tmp_num_devices; +int i, r =0 ; + +if (!(target && user_info && number_of_device_infos && entry_size)) +return -EINVAL ; + + tmp_num_devices =min_t (size_t, *number_of_device_infos, target->n_pdds); + *number_of_device_infos = target->n_pdds; + *entry_size =min_t (size_t, *entry_size,sizeof (device_info)); + +if (!tmp_num_devices) +return 0 ; + +memset (&device_info,0 ,sizeof (device_info)); + +mutex_lock (&target->event_mutex); + +/* Run over all pdd of the process */ +for (i =0 ; i < tmp_num_devices; i++) { +struct kfd_process_device *pdd = target->pdds[i]; +struct kfd_topology_device *topo_dev =kfd_topology_device_by_id (pdd->dev->id); + + device_info.gpu_id = pdd->dev->id; + device_info.exception_status = pdd->exception_status; + device_info.lds_base = pdd->lds_base; + device_info.lds_limit = pdd->lds_limit; + device_info.scratch_base = pdd->scratch_base; + device_info.scratch_limit = pdd->scratch_limit; + device_info.gpuvm_base = pdd->gpuvm_base; + device_info.gpuvm_limit = pdd->gpuvm_limit; + device_info.location_id = topo_dev->node_props.location_id; + device_info.vendor_id = topo_dev->node_props.vendor_id; + device_info.device_id = topo_dev->node_props.device_id; + device_info.revision_id = pdd->dev->adev->pdev->revision; + device_info.subsystem_vendor_id = pdd->dev->adev->pdev->subsystem_vendor; + device_info.subsystem_device_id = pdd->dev->adev->pdev->subsystem_device; + device_info.fw_version = pdd->dev->mec_fw_version; + device_info.gfx_target_version = + topo_dev->node_props.gfx_target_version; + device_info.simd_count = topo_dev->node_props.simd_count; + device_info.max_waves_per_simd = + topo_dev->node_props.max_waves_per_simd; + device_info.array_count = topo_dev->node_props.array_count; + device_info.simd_arrays_per_engine = + topo_dev->node_props.simd_arrays_per_engine; + device_info.capability = topo_dev->node_props.capability; + device_info.debug_prop = topo_dev->node_props.debug_prop; + +if (exception_clear_mask) + pdd->exception_status &= ~exception_clear_mask; + +if (copy_to_user (user_info, &device_info, *entry_size)) { + r = -EFAULT ; +break ; + } + + user_info += tmp_entry_size; + } + +mutex_unlock (&target->event_mutex); + +return r; +} +void kfd_dbg_set_enabled_debug_exception_mask (struct kfd_process *target,uint64_t exception_set_mask) {drivers/gpu/drm/amd/amdkfd/kfd_debug.h +5
-0@@ -81,6 +81,11 @@ static inline bool kfd_dbg_is_per_vmid_supported(struct kfd_dev *dev) }void debug_event_write_work_handler (struct work_struct *work); +int kfd_dbg_trap_device_snapshot (struct kfd_process *target, +uint64_t exception_clear_mask, +void __user *user_info, +uint32_t *number_of_device_infos, +uint32_t *entry_size);void kfd_dbg_set_enabled_debug_exception_mask (struct kfd_process *target,uint64_t exception_set_mask);
PATCH 32/32 drm/amdkfd: bump kfd ioctl minor version for debug api availability
In reply to Jonathan KimBump the minor version to declare debugging capability is now available.
--- drivers/gpu/drm/amd/amdkfd/kfd_chardev.c | 1 - include/uapi/linux/kfd_ioctl.h | 3 ++- 2 files changed, 2 insertions(+), 2 deletions(-)
drivers/gpu/drm/amd/amdkfd/kfd_chardev.c +0 -1
@@ -2896,7 +2896,6 @@ static int kfd_ioctl_set_debug_trap(struct file *filep, struct kfd_process *p, vif (!r) target->exception_enable_mask = args->enable.exception_mask; -pr_warn ("Debug functions limited\n" );break ;case KFD_IOC_DBG_TRAP_DISABLE : r =kfd_dbg_trap_disable (target);
include/uapi/linux/kfd_ioctl.h +2 -1
@@ -37,9 +37,10 @@* - 1.9 - Add available memory ioctl * - 1.10 - Add SMI profiler event log * - 1.11 - Add unified memory for ctx save/restore area +* - 1.12 - Add debugger API */ #define KFD_IOCTL_MAJOR_VERSION 1 -#define KFD_IOCTL_MINOR_VERSION 11 +#define KFD_IOCTL_MINOR_VERSION 12struct kfd_ioctl_get_version_args {__u32 major_version;/* from KFD */
Signature · 1 line
2.25.1
Re: [PATCH 32/32] drm/amdkfd: bump kfd ioctl minor version for debug api availability
Am 2023-01-25 um 14:54 schrieb Jonathan Kim:
Quoted 5 lines
Bump the minor version to declare debugging capability is now available.
Signed-off-by Jonathan Kim <[email protected]>Reviewed-by Felix Kuehling <[email protected]>
This needs to be bumped to 1.13 once you rebase on the latest staging. With that fixed, the patch is
Quoted 33 lines
--- drivers/gpu/drm/amd/amdkfd/kfd_chardev.c | 1 - include/uapi/linux/kfd_ioctl.h | 3 ++- 2 files changed, 2 insertions(+), 2 deletions(-)drivers/gpu/drm/amd/amdkfd/kfd_chardev.c +0
-1@@ -2896,7 +2896,6 @@ static int kfd_ioctl_set_debug_trap(struct file *filep, struct kfd_process *p, vif (!r) target->exception_enable_mask = args->enable.exception_mask; -pr_warn ("Debug functions limited\n" );break ;case KFD_IOC_DBG_TRAP_DISABLE : r =kfd_dbg_trap_disable (target);include/uapi/linux/kfd_ioctl.h +2
-1@@ -37,9 +37,10 @@* - 1.9 - Add available memory ioctl * - 1.10 - Add SMI profiler event log * - 1.11 - Add unified memory for ctx save/restore area +* - 1.12 - Add debugger API */ #define KFD_IOCTL_MAJOR_VERSION 1 -#define KFD_IOCTL_MINOR_VERSION 11 +#define KFD_IOCTL_MINOR_VERSION 12struct kfd_ioctl_get_version_args {__u32 major_version;/* from KFD */