drm/amdkfd: add debug and runtime enable interface
Subsystems (3)
RE: [PATCH 27/29] drm/amdkfd: add debug queue snapshot operation
In reply to Felix Kuehling[Public]
Quoted 94 lines
-----Original Message-----
From: Kuehling, Felix <[email protected]>
Sent: November 30, 2022 6:55 PM
To: Kim, Jonathan <[email protected]>; amd- [email protected]
Subject: Re: [PATCH 27/29] drm/amdkfd: add debug queue snapshot operationQuoted 5 lines · Jonathan Kim
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,
Quoted 8 lines
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.Quoted 6 lines
Also allow the debugger to clear exceptions when doing a snapshot.
v2: change
buf_sizearg tonum_queuesfor clarity. fix minimum entry size calculation.Signed-off-by Jonathan Kim <[email protected]>Two nit-picks inline.
Quoted 3 lines
--- drivers/gpu/drm/amd/amdkfd/kfd_chardev.c | 6 +++ .../drm/amd/amdkfd/kfd_device_queue_manager.c | 41+++++++++++++++++++
Quoted 3 lines
.../drm/amd/amdkfd/kfd_device_queue_manager.h | 4 ++ drivers/gpu/drm/amd/amdkfd/kfd_priv.h | 5 +++ .../amd/amdkfd/kfd_process_queue_manager.c | 40++++++++++++++++++
Review
Quoted 3 lines
5 files changed, 96 insertions(+)(quoted diff) +0
-0
b/drivers/gpu/drm/amd/amdkfd/kfd_chardev.cdrivers/gpu/drm/amd/amdkfd/kfd_chardev.c static int kfd_ioctl_set_debug_trap(struct file
Quoted 4 lines
index
2c8f107237ee..cea393350980100644drivers/gpu/drm/amd/amdkfd/kfd_chardev.c +0
-0@@ -2961,6 +2961,12 @@ static int kfd_ioctl_set_debug_trap(struct file*filep, struct
kfd_process*p, vQuoted 13 lines
drivers/gpu/drm/amd/amdkfd/kfd_chardev.c +6
-0&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;Review
Quoted 1 line
(quoted diff) +0
-0
b/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.cdrivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c int suspend_queues(struct kfd_process *p, · line 2953
Quoted 8 lines
index
589efbefc8dc..51f8c5676c56100644drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +1
-0@@ -2950,6 +2950,47 @@ int suspend_queues(struct kfd_process *p,return total_suspended; } +static uint32_t set_queue_type_for_user(struct queue_properties
*q_props)drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c int suspend_queues(struct kfd_process *p,
Quoted 6 lines
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +6
-0+{ +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;Quoted 12 lines
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +12
-0+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 device_queue_manager *dqm, + struct queue *q,
Quoted 8 lines
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c int suspend_queues(struct kfd_process *p, · line 2973
Quoted 2 lines
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +2
-0+uint64_t exception_clear_mask, + struct kfd_queue_snapshot_entry *qss_entry)The dqm parameter is not needed. The function can get this from
q->device->dqm. It's also only needed for dqm locking. I'm not sure that's even necessary. Aren't theevent_mutexand target process mutex held by the caller enough to protect theexception_statusand other queue properties?
I can't really remember why we device locked in the experimental phase tbh but I think you're right. The process event lock should protect event status on interrupt writes.
The process lock should protect everything else (property updates/destruction etc).
Thanks,
Jon
Quoted 128 lines
Review
Quoted 30 lines
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +15
-0+{ +dqm_lock (dqm); + + 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);
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +5
-0+ q->properties.exception_status &= ~exception_clear_mask; + +dqm_unlock (dqm); +} +int debug_lock_and_unmap (struct device_queue_manager *dqm) {int r;(quoted diff) +0
-0
b/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.hReview
Quoted 15 lines
index
12643528684c..094705b932fc100644drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.h +4
-0@@ -297,6 +297,10 @@ int resume_queues(struct kfd_process *p,bool resume_all_queues, uint32_t num_queues, uint32_t *usr_queue_id_array); +void set_queue_snapshot_entry (struct device_queue_manager *dqm, +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);(quoted diff) +0
-0
b/drivers/gpu/drm/amd/amdkfd/kfd_priv.hdrivers/gpu/drm/amd/amdkfd/kfd_priv.h int pqm_get_wave_state(struct
Quoted 4 lines
index
aee4fe20e676..ebd701143981100644drivers/gpu/drm/amd/amdkfd/kfd_priv.h +0
-0@@ -1302,6 +1302,11 @@ int pqm_get_wave_state(struct
process_queue_manager*pqm,Review
Quoted 12 lines
drivers/gpu/drm/amd/amdkfd/kfd_priv.h +5
-0void __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, +struct kfd_queue_snapshot_entry __user *buf, +int *num_qss_entries, +uint32_t *entry_size); int amdkfd_fence_wait_timeout(uint64_t *fence_addr, uint64_t fence_value,(quoted diff) +0
-0
b/drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.cdrivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c int pqm_get_wave_state(struct
Quoted 4 lines
index
15db83c9a585..30df1046c30b100644drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c +0
-0@@ -569,6 +569,46 @@ int pqm_get_wave_state(struct
process_queue_manager*pqm,drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c int pqm_get_wave_state(struct process_queue_manager *pqm,
Quoted 11 lines
drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c +8
-0save_area_used_size); } +int pqm_get_queue_snapshot (struct process_queue_manager *pqm, +uint64_t exception_clear_mask, +struct kfd_queue_snapshot_entry __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;drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c int pqm_get_wave_state(struct process_queue_manager *pqm,
Quoted 7 lines
drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c +7
-0+int r; + + *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 594
Quoted 8 lines
drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c +8
-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 = {0 };It's safer to use memset here. This initialization may not initialize padding, so it doesn't guarantee that no uninitialized data leaks from kernel mode to user mode.
Regards,
Felixdrivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c int pqm_get_wave_state(struct process_queue_manager *pqm,
Quoted 3 lines
drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c +3
-0+ + set_queue_snapshot_entry(pqn->q->device->dqm, + pqn->q, exception_clear_mask,&src);
Quoted 17 lines
drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c +14
-0+ +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 28/29 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.
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 | 67 ++++++++++++++++++++++++ drivers/gpu/drm/amd/amdkfd/kfd_debug.h | 5 ++ 3 files changed, 77 insertions(+), 2 deletions(-)
drivers/gpu/drm/amd/amdkfd/kfd_chardev.c +5 -2
@@ -2968,8 +2968,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 +67 -0
79 lines not on this page · raw message
drivers/gpu/drm/amd/amdkfd/kfd_debug.h +5 -0
@@ -80,6 +80,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 28/29] drm/amdkfd: add debug device snapshot operation
Quoted 51 lines · Jonathan Kim
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.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]>--- drivers/gpu/drm/amd/amdkfd/kfd_chardev.c | 7 ++- drivers/gpu/drm/amd/amdkfd/kfd_debug.c | 67 ++++++++++++++++++++++++ drivers/gpu/drm/amd/amdkfd/kfd_debug.h | 5 ++ 3 files changed, 77 insertions(+), 2 deletions(-)drivers/gpu/drm/amd/amdkfd/kfd_chardev.c +5
-2@@ -2968,8 +2968,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 +1
-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>
drivers/gpu/drm/amd/amdkfd/kfd_debug.c int kfd_dbg_trap_query_exception_info(struct kfd_process *target, · line 898
Quoted 10 lines
drivers/gpu/drm/amd/amdkfd/kfd_debug.c +7
-0@@ -888,6 +889,72 @@ 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 = {0 };
Use memset. With that fixed, the patch is
Quoted 78 lines
drivers/gpu/drm/amd/amdkfd/kfd_debug.c +59
-0+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 ; + +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.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@@ -80,6 +80,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 29/29 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
@@ -2891,7 +2891,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 29/29] drm/amdkfd: bump kfd ioctl minor version for debug api availability
Quoted 4 lines · Jonathan Kim
Bump the minor version to declare debugging capability is now available.
Signed-off-by Jonathan Kim <[email protected]>
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@@ -2891,7 +2891,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 */
Quoted 7 lines · Jonathan Kim
Introduce the GPU debug operations interface.
For ROCm-GDB to extend the GNU Debugger's ability to inspect the AMD GPU instruction set, provide the necessary interface to allow the debugger to HW debug-mode set and query exceptions per HSA queue, process or device.
Quoted 8 lines
The
runtime_enableinterface coordinates exception handling with the HSA runtime.Usage is available in the kern docs at
uapi/linux/kfd_ioctl.h.v2: add more documentation on semantics and error returns. expand
kfd_dbg_device_info_entrywith new fields. updatedevice_snapshotsematics to match queue snapshot semantics
This looks really good. I have 3 more nit-picks inline. Other than that, this patch is
Do we have a debugger branch that uses the API yet? We should make this public in order to complete this upstream code review.
Quoted 484 lines
Signed-off-by Jonathan Kim <[email protected]>---
drivers/gpu/drm/amd/amdkfd/kfd_chardev.c| 48 ++include/uapi/linux/kfd_ioctl.h| 655 ++++++++++++++++++++++-2 files changed, 702 insertions(+), 1 deletion(-)drivers/gpu/drm/amd/amdkfd/kfd_chardev.c +42
-0@@ -2644,6 +2644,48 @@ static int kfd_ioctl_criu(struct file *filep, struct kfd_process *p, void *data) return ret; } +static int kfd_ioctl_runtime_enable (struct file *filep,struct kfd_process *p,void *data) +{ +return 0 ; +} + +static int kfd_ioctl_set_debug_trap (struct file *filep,struct kfd_process *p,void *data) +{ +struct kfd_ioctl_dbg_trap_args *args = data; +int r =0 ; + +if (sched_policy ==KFD_SCHED_POLICY_NO_HWS ) { +pr_err ("Debugging does not support sched_policy %i" , sched_policy); +return -EINVAL ; + } + +switch (args->op) { +case KFD_IOC_DBG_TRAP_ENABLE : +case KFD_IOC_DBG_TRAP_DISABLE : +case KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT : +case KFD_IOC_DBG_TRAP_SET_EXCEPTIONS_ENABLED : +case KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE : +case KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE : +case KFD_IOC_DBG_TRAP_SUSPEND_QUEUES : +case KFD_IOC_DBG_TRAP_RESUME_QUEUES : +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 : +case KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT : +case KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO : +case KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT : +case KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT : +pr_warn ("Debugging not supported yet\n" ); + r = -EACCES ; +break ; +default : +pr_err ("Invalid option: %i\n" , args->op); + r = -EINVAL ; + } + +return r; +} +#define AMDKFD_IOCTL_DEF (ioctl, _func, _flags) \[
_IOC_NR(ioctl)] = {.cmd = ioctl, .func =_func, .flags =_flags, \
.cmd_drv = 0, .name = #ioctl}drivers/gpu/drm/amd/amdkfd/kfd_chardev.c +6
-0@@ -2753,6 +2795,12 @@ static const struct amdkfd_ioctl_desc amdkfd_ioctls[] = {AMDKFD_IOCTL_DEF (AMDKFD_IOC_AVAILABLE_MEMORY , kfd_ioctl_get_available_memory,0 ), + +AMDKFD_IOCTL_DEF (AMDKFD_IOC_RUNTIME_ENABLE , + kfd_ioctl_runtime_enable,0 ), + +AMDKFD_IOCTL_DEF (AMDKFD_IOC_DBG_TRAP , + kfd_ioctl_set_debug_trap,0 ), };#define AMDKFD_CORE_IOCTL_COUNT ARRAY_SIZE(amdkfd_ioctls)include/uapi/linux/kfd_ioctl.h +155
-0@@ -109,6 +109,28 @@ struct kfd_ioctl_get_available_memory_args {__u32 pad; }; +struct kfd_dbg_device_info_entry { +__u64 exception_status; +__u64 lds_base; +__u64 lds_limit; +__u64 scratch_base; +__u64 scratch_limit; +__u64 gpuvm_base; +__u64 gpuvm_limit; +__u32 gpu_id; +__u32 location_id; +__u32 vendor_id; +__u32 device_id; +__u32 fw_version; +__u32 gfx_target_version; +__u32 simd_count; +__u32 max_waves_per_simd; +__u32 array_count; +__u32 simd_arrays_per_engine; +__u32 capability; +__u32 debug_prop; +}; +/* For kfd_ioctl_set_memory_policy_args.default_policy and alternate_policy */ #define KFD_IOC_CACHE_POLICY_COHERENT 0#define KFD_IOC_CACHE_POLICY_NONCOHERENT 1@@ -766,6 +788,631 @@ struct kfd_ioctl_set_xnack_mode_args {__s32 xnack_enabled; }; +/* Wave launch override modes */ +enum kfd_dbg_trap_override_mode { +KFD_DBG_TRAP_OVERRIDE_OR =0 , +KFD_DBG_TRAP_OVERRIDE_REPLACE =1 +}; + +/* Wave launch overrides */ +enum kfd_dbg_trap_mask { +KFD_DBG_TRAP_MASK_FP_INVALID =1 , +KFD_DBG_TRAP_MASK_FP_INPUT_DENORMAL =2 , +KFD_DBG_TRAP_MASK_FP_DIVIDE_BY_ZERO =4 , +KFD_DBG_TRAP_MASK_FP_OVERFLOW =8 , +KFD_DBG_TRAP_MASK_FP_UNDERFLOW =16 , +KFD_DBG_TRAP_MASK_FP_INEXACT =32 , +KFD_DBG_TRAP_MASK_INT_DIVIDE_BY_ZERO =64 , +KFD_DBG_TRAP_MASK_DBG_ADDRESS_WATCH =128 , +KFD_DBG_TRAP_MASK_DBG_MEMORY_VIOLATION =256 +}; + +/* Wave launch modes */ +enum kfd_dbg_trap_wave_launch_mode { +KFD_DBG_TRAP_WAVE_LAUNCH_MODE_NORMAL =0 , +KFD_DBG_TRAP_WAVE_LAUNCH_MODE_HALT =1 , +KFD_DBG_TRAP_WAVE_LAUNCH_MODE_KILL =2 , +KFD_DBG_TRAP_WAVE_LAUNCH_MODE_DEBUG =3 , +KFD_DBG_TRAP_WAVE_LAUNCH_MODE_STALL =4 +}; + +/* Address watch modes */ +enum kfd_dbg_trap_address_watch_mode { +KFD_DBG_TRAP_ADDRESS_WATCH_MODE_READ =0 , +KFD_DBG_TRAP_ADDRESS_WATCH_MODE_NONREAD =1 , +KFD_DBG_TRAP_ADDRESS_WATCH_MODE_ATOMIC =2 , +KFD_DBG_TRAP_ADDRESS_WATCH_MODE_ALL =3 +}; + +/* Additional wave settings */ +enum kfd_dbg_trap_flags { +KFD_DBG_TRAP_FLAG_SINGLE_MEM_OP =1 , +KFD_DBG_TRAP_FLAG_SINGLE_ALU_OP =2 +}; + +/* Trap exceptions */ +enum kfd_dbg_trap_exception_code { +EC_NONE =0 , +/* per queue */ +EC_QUEUE_WAVE_ABORT =1 , +EC_QUEUE_WAVE_TRAP =2 , +EC_QUEUE_WAVE_MATH_ERROR =3 , +EC_QUEUE_WAVE_ILLEGAL_INSTRUCTION =4 , +EC_QUEUE_WAVE_MEMORY_VIOLATION =5 , +EC_QUEUE_WAVE_APERTURE_VIOLATION =6 , +EC_QUEUE_PACKET_DISPATCH_DIM_INVALID =16 , +EC_QUEUE_PACKET_DISPATCH_GROUP_SEGMENT_SIZE_INVALID =17 , +EC_QUEUE_PACKET_DISPATCH_CODE_INVALID =18 , +EC_QUEUE_PACKET_RESERVED =19 , +EC_QUEUE_PACKET_UNSUPPORTED =20 , +EC_QUEUE_PACKET_DISPATCH_WORK_GROUP_SIZE_INVALID =21 , +EC_QUEUE_PACKET_DISPATCH_REGISTER_INVALID =22 , +EC_QUEUE_PACKET_VENDOR_UNSUPPORTED =23 , +EC_QUEUE_PREEMPTION_ERROR =30 , +EC_QUEUE_NEW =31 , +/* per device */ +EC_DEVICE_QUEUE_DELETE =32 , +EC_DEVICE_MEMORY_VIOLATION =33 , +EC_DEVICE_RAS_ERROR =34 , +EC_DEVICE_FATAL_HALT =35 , +EC_DEVICE_NEW =36 , +/* per process */ +EC_PROCESS_RUNTIME =48 , +EC_PROCESS_DEVICE_REMOVE =49 , +EC_MAX +}; + +/* Mask generated by ecode in kfd_dbg_trap_exception_code */ +#define KFD_EC_MASK (ecode) (1ULL << (ecode - 1)) + +/* Masks for exception code type checks below */ +#define KFD_EC_MASK_QUEUE (KFD_EC_MASK(EC_QUEUE_WAVE_ABORT) | \ + KFD_EC_MASK(EC_QUEUE_WAVE_TRAP) | \ + KFD_EC_MASK(EC_QUEUE_WAVE_MATH_ERROR) | \ + KFD_EC_MASK(EC_QUEUE_WAVE_ILLEGAL_INSTRUCTION) | \ + KFD_EC_MASK(EC_QUEUE_WAVE_MEMORY_VIOLATION) | \ + KFD_EC_MASK(EC_QUEUE_WAVE_APERTURE_VIOLATION) | \ + KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_DIM_INVALID) | \ + KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_GROUP_SEGMENT_SIZE_INVALID) | \ + KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_CODE_INVALID) | \ + KFD_EC_MASK(EC_QUEUE_PACKET_UNSUPPORTED) | \ + KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_WORK_GROUP_SIZE_INVALID) | \ + KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_REGISTER_INVALID) | \ + KFD_EC_MASK(EC_QUEUE_PACKET_VENDOR_UNSUPPORTED) | \ + KFD_EC_MASK(EC_QUEUE_PREEMPTION_ERROR) | \ + KFD_EC_MASK(EC_QUEUE_NEW)) +#define KFD_EC_MASK_DEVICE (KFD_EC_MASK(EC_DEVICE_QUEUE_DELETE) | \ + KFD_EC_MASK(EC_DEVICE_RAS_ERROR) | \ + KFD_EC_MASK(EC_DEVICE_FATAL_HALT) | \ + KFD_EC_MASK(EC_DEVICE_MEMORY_VIOLATION) | \ + KFD_EC_MASK(EC_DEVICE_NEW)) +#define KFD_EC_MASK_PROCESS (KFD_EC_MASK(EC_PROCESS_RUNTIME) | \ + KFD_EC_MASK(EC_PROCESS_DEVICE_REMOVE)) + +/* Checks for exception code types for KFD search */ +#define KFD_DBG_EC_TYPE_IS_QUEUE (ecode) \ + (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_QUEUE)) +#define KFD_DBG_EC_TYPE_IS_DEVICE (ecode) \ + (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_DEVICE)) +#define KFD_DBG_EC_TYPE_IS_PROCESS (ecode) \ + (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_PROCESS)) + + +/* Runtime enable states */ +enum kfd_dbg_runtime_state { +DEBUG_RUNTIME_STATE_DISABLED =0 , +DEBUG_RUNTIME_STATE_ENABLED =1 , +DEBUG_RUNTIME_STATE_ENABLED_BUSY =2 , +DEBUG_RUNTIME_STATE_ENABLED_ERROR =3 +}; + +/* Runtime enable status */ +struct kfd_runtime_info { +__u64 r_debug; +__u32 runtime_state; +__u32 ttmp_setup; +}; + +/* Enable modes for runtime enable */ +#define KFD_RUNTIME_ENABLE_MODE_ENABLE_MASK 1 +#define KFD_RUNTIME_ENABLE_MODE_TTMP_SAVE_MASK 2 + +/** +* kfd_ioctl_runtime_enable_args - Arguments for runtime enable +* +* Coordinates debug exception signalling and debug device enablement with runtime.
+ *
+ * @r_debug - pointer to user struct for sharing information between ROCr and the debuggger
+ * @mode_mask - mask to set mode
+ *KFD_RUNTIME_ENABLE_MODE_ENABLE_MASK- enable runtime for debugging, otherwise disable
+ *KFD_RUNTIME_ENABLE_MODE_TTMP_SAVE_MASK- enable trap temporary setup (ignore on disable)
+ *
+ * Return - 0 on SUCCESS.
+ * - EBUSY if runtime enable call already pending.
+ * - EEXIST if user queues already active prior to call.
+ * If process is debug enabled, runtime enable will enable debug devices and
+ * wait for debugger process to send runtime exceptionEC_PROCESS_RUNTIME
+ * to unblock - seekfd_ioctl_dbg_trap_args.
+ *
+ */include/uapi/linux/kfd_ioctl.h +43
-0+struct kfd_ioctl_runtime_enable_args { +__u64 r_debug; +__u32 mode_mask; +}; + +/* Queue information */ +struct kfd_queue_snapshot_entry { +__u64 exception_status; +__u64 ring_base_address; +__u64 write_pointer_address; +__u64 read_pointer_address; +__u64 ctx_save_restore_address; +__u32 queue_id; +__u32 gpu_id; +__u32 ring_size; +__u32 queue_type; +__u32 ctx_save_restore_area_size; +__u32 reserved; +}; + +/* Queue status return for suspend/resume */ +#define KFD_DBG_QUEUE_ERROR_BIT 30 +#define KFD_DBG_QUEUE_INVALID_BIT 31 +#define KFD_DBG_QUEUE_ERROR_MASK (1 << KFD_DBG_QUEUE_ERROR_BIT) +#define KFD_DBG_QUEUE_INVALID_MASK (1 << KFD_DBG_QUEUE_INVALID_BIT) + +/* Context save area header information */ +struct kfd_context_save_area_header { +__u32 control_stack_offset; +__u32 control_stack_size; +__u32 wave_state_offset; +__u32 wave_state_size; +__u32 debug_offset; +__u32 debug_size; +__u64 err_payload_addr; +__u32 err_event_id; +__u32 reserved1; +}; + +/* +* Debug operations +* +* For specifics on usage and return values, see documentation per operation
+ * below. Otherwise, generic error returns apply:
+ * - ESRCH if the process to debug does not exist.
+ *
+ * - EINVAL (withKFD_IOC_DBG_TRAP_ENABLEexempt) if operation
+ *KFD_IOC_DBG_TRAP_ENABLEhas not succeeded prior.
+ * Also returns this error if GPU hardware scheduling is not supported.
+ *
+ * - EPERM (withKFD_IOC_DBG_TRAP_DISABLEexempt) if target process is not
+ *PTRACE_ATTACHED.KFD_IOC_DBG_TRAP_DISABLEis exempt to allow
+ * clean up of debug mode as long as process is debug enabled.
+ *
+ * - EACCES if anyDBG_HW_OP(debug hardware operation) is requested when
+ *AMDKFD_IOC_RUNTIME_ENABLEhas not succeeded prior.
+ *
+ * - ENODEV if any GPU does not support debugging on aDBG_HW_OPcall.
+ *
+ * - Other errors may be returned when aDBG_HW_OPoccurs while the GPU
+ * is in a fatal state.
+ *
+ */include/uapi/linux/kfd_ioctl.h +24
-0+enum kfd_dbg_trap_operations { +KFD_IOC_DBG_TRAP_ENABLE =0 , +KFD_IOC_DBG_TRAP_DISABLE =1 , +KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT =2 , +KFD_IOC_DBG_TRAP_SET_EXCEPTIONS_ENABLED =3 , +KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE =4 ,/* DBG_HW_OP */ +KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE =5 ,/* DBG_HW_OP */ +KFD_IOC_DBG_TRAP_SUSPEND_QUEUES =6 ,/* DBG_HW_OP */ +KFD_IOC_DBG_TRAP_RESUME_QUEUES =7 ,/* DBG_HW_OP */ +KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH =8 ,/* DBG_HW_OP */ +KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH =9 ,/* DBG_HW_OP */ +KFD_IOC_DBG_TRAP_SET_FLAGS =10 , +KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT =11 , +KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO =12 , +KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT =13 , +KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT =14 +}; + +/** +* kfd_ioctl_dbg_trap_enable_args +* +* Arguments for KFD_IOC_DBG_TRAP_ENABLE. +* +* Enables debug session for target process. Call @op
KFD_IOC_DBG_TRAP_DISABLEin
+ *kfd_ioctl_dbg_trap_argsto disable debug session.
+ *
+ * @exception_mask (IN) - exceptions to raise to the debugger
+ * @rinfo_ptr (IN) - pointer to runtime info buffer (seekfd_runtime_info)
+ * @rinfo_size (IN/OUT) - size of runtime info buffer in bytes
+ * @dbg_fd (IN) - fd the KFD will nofify the debugger with of raised
+ * exceptions set inexception_mask.
+ *
+ * Generic errors apply (seekfd_dbg_trap_operations).
+ * Return - 0 on SUCCESS.
+ * Copies KFD savedkfd_runtime_infoto @rinfo_ptr on enable.
+ * Size ofkfd_runtimesaved by the KFD returned to @rinfo_size.
+ * - EBADF if KFD cannot get a reference todbg_fd.
+ * - EFAULT if KFD cannot copy runtime info torinfo_ptr.
+ * - EINVAL if target process is already debug enabled.
+ *
+ */include/uapi/linux/kfd_ioctl.h +69
-0+struct kfd_ioctl_dbg_trap_enable_args { +__u64 exception_mask; +__u64 rinfo_ptr; +__u32 rinfo_size; +__u32 dbg_fd; +}; + +/** +* kfd_ioctl_dbg_trap_send_runtime_event_args +* +* +* Arguments for KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT. +* Raises exceptions to runtime. +* +* @exception_mask (IN) - exceptions to raise to runtime +* @gpu_id (IN) - target device id +* @queue_id (IN) - target queue id +* +* Generic errors apply (see kfd_dbg_trap_operations). +* Return - 0 on SUCCESS. +* - ENODEV if gpu_id not found. +* If exception_mask contains EC_PROCESS_RUNTIME, unblocks pending +* AMDKFD_IOC_RUNTIME_ENABLE call - see kfd_ioctl_runtime_enable_args. +* All other exceptions are raised to runtime through err_payload_addr. +* See kfd_context_save_area_header. +*/ +struct kfd_ioctl_dbg_trap_send_runtime_event_args { +__u64 exception_mask; +__u32 gpu_id; +__u32 queue_id; +}; + +/** +* kfd_ioctl_dbg_trap_set_exceptions_enabled_args +* +* Arguments for KFD_IOC_SET_EXCEPTIONS_ENABLED +* Set new exceptions to be raised to the debugger. +* +* @exception_mask (IN) - new exceptions to raise the debugger +* +* Generic errors apply (see kfd_dbg_trap_operations). +* Return - 0 on SUCCESS. +*/ +struct kfd_ioctl_dbg_trap_set_exceptions_enabled_args { +__u64 exception_mask; +}; + +/** +* kfd_ioctl_dbg_trap_set_wave_launch_override_args +* +* Arguments for KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE +* Enable HW exceptions to raise trap. +* +* @override_mode (IN) - see kfd_dbg_trap_override_mode +* @enable_mask (IN/OUT) - reference kfd_dbg_trap_mask. +* IN is the override modes requested to be enabled. +* OUT is referenced in Return below. +* @support_request_mask (IN/OUT) - reference kfd_dbg_trap_mask. +* IN is the override modes requested for support check. +* OUT is referenced in Return below. +* +* Generic errors apply (see kfd_dbg_trap_operations). +* Return - 0 on SUCCESS. +* Previous enablement is returned in @enable_mask. +* Actual override support is returned in @support_request_mask. +* - EINVAL if override mode is not supported. +* - EACCES if trap support requested is not actually supported. +* i.e. enable_mask (IN) is not a subset of support_request_mask (OUT). +* Otherwise it is considered a generic error (see
kfd_dbg_trap_operations).
+ */include/uapi/linux/kfd_ioctl.h +31
-0+struct kfd_ioctl_dbg_trap_set_wave_launch_override_args { +__u32 override_mode; +__u32 enable_mask; +__u32 support_request_mask; +__u32 pad; +}; + +/** +* kfd_ioctl_dbg_trap_set_wave_launch_mode_args +* +* Arguments for KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE +* Set wave launch mode. +* +* @mode (IN) - see kfd_dbg_trap_wave_launch_mode +* +* Generic errors apply (see kfd_dbg_trap_operations). +* Return - 0 on SUCCESS. +*/ +struct kfd_ioctl_dbg_trap_set_wave_launch_mode_args { +__u32 launch_mode; +__u32 pad; +}; + +/** +* kfd_ioctl_dbg_trap_suspend_queues_args +* +* Arguments for KFD_IOC_DBG_TRAP_SUSPEND_QUEUES +* Suspend queues. +* +* @exception_mask (IN) - raised exceptions to clear +* @queue_array_ptr (IN) - pointer to array of queue ids (u32 per queue id)
+ * to suspend
+ * @num_queues (IN) - number of queues to suspend in @queue_array_ptr
+ * @grace_period (IN) - wave time allowance before preemption
+ * per 1K GPU clock cycle unit
+ *
+ * Generic errors apply (seekfd_dbg_trap_operations).
+ * Return - Number of queues suspended on SUCCESS.
+ *KFD_DBG_QUEUE_ERROR_MASKandKFD_DBG_QUEUE_INVALID_MASKmasked
+ * for each queue id in @queue_array_ptr array reports unsuccessful
+ * suspend reason.
+ *KFD_DBG_QUEUE_ERROR_MASK= HW failure.
+ *KFD_DBG_QUEUE_INVALID_MASK= queue does not exist, is new or
Quoted 8 lines
+ * is being destroyed.
+ * Destruction of a suspended queue is blocked until the queue is
+ * resumed. This allows the debugger to access queue information and
+ * the its context save area without running into a race condition on
+ * queue destruction.
+ * Automatically copies per queue context save area header information
+ * into the save area base
+ * (seekfd_queue_snapshot_entryandkfd_context_save_area_header).
The last two paragraphs would make more sens as a description above the Return statement.
Quoted 169 lines
+ */
include/uapi/linux/kfd_ioctl.h +14
-0+struct kfd_ioctl_dbg_trap_suspend_queues_args { +__u64 exception_mask; +__u64 queue_array_ptr; +__u32 num_queues; +__u32 grace_period; +}; + +/** +* kfd_ioctl_dbg_trap_resume_queues_args +* +* Arguments for KFD_IOC_DBG_TRAP_RESUME_QUEUES +* Resume queues. +* +* @queue_array_ptr (IN) - pointer to array of queue ids (u32 per queue id)
+ * to resume
+ * @num_queues (IN) - number of queues to resume in @queue_array_ptr
+ *
+ * Generic errors apply (seekfd_dbg_trap_operations).
+ * Return - Number of queues resumed on SUCCESS.
+ *KFD_DBG_QUEUE_ERROR_MASKandKFD_DBG_QUEUE_INVALID_MASKmask
+ * for each queue id in @queue_array_ptr array reports unsuccessful
+ * resume reason.
+ *KFD_DBG_QUEUE_ERROR_MASK= HW failure.
+ *KFD_DBG_QUEUE_INVALID_MASK= queue does not exist.
+ */include/uapi/linux/kfd_ioctl.h +75
-0+struct kfd_ioctl_dbg_trap_resume_queues_args { +__u64 queue_array_ptr; +__u32 num_queues; +__u32 pad; +}; + +/** +* kfd_ioctl_dbg_trap_set_node_address_watch_args +* +* Arguments for KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH +* Sets address watch for device. +* +* @address (IN) - watch address to set +* @mode (IN) - see kfd_dbg_trap_address_watch_mode +* @mask (IN) - watch address mask +* @gpu_id (IN) - target gpu to set watch point +* @id (OUT) - watch id allocated +* +* Generic errors apply (see kfd_dbg_trap_operations). +* Return - 0 on SUCCESS. +* Allocated watch ID returned to @id. +* - ENODEV if gpu_id not found. +* - ENOMEM if watch IDs can be allocated +*/ +struct kfd_ioctl_dbg_trap_set_node_address_watch_args { +__u64 address; +__u32 mode; +__u32 mask; +__u32 gpu_id; +__u32 id; +}; + +/** +* kfd_ioctl_dbg_trap_clear_node_address_watch_args +* +* Arguments for KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH +* Clear address watch for device. +* +* @gpu_id (IN) - target device to clear watch point +* @id (IN) - allocated watch id to clear +* +* Generic errors apply (see kfd_dbg_trap_operations). +* Return - 0 on SUCCESS. +* - ENODEV if gpu_id not found. +* - EINVAL if watch ID has not been allocated. +*/ +struct kfd_ioctl_dbg_trap_clear_node_address_watch_args { +__u32 gpu_id; +__u32 id; +}; + +/** +* kfd_ioctl_dbg_trap_set_flags_args +* +* Arguments for KFD_IOC_DBG_TRAP_SET_FLAGS +* Sets flags for wave behaviour. +* +* @flags (IN/OUT) - IN = flags to enable, OUT = flags previously enabled +* +* Generic errors apply (see kfd_dbg_trap_operations). +* Return - 0 on SUCCESS. +* - EACCESS if any debug device does not allow flag options. +*/ +struct kfd_ioctl_dbg_trap_set_flags_args { +__u32 flags; +__u32 pad; +}; + +/** +* kfd_ioctl_dbg_trap_query_debug_event_args +* +* Arguments for KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT +* +* Find one or more raised exceptions. This function can return multiple +* exceptions from a single queue or a single device with one call. To find
+ * all raised exceptions, this function must be called repeatedly until it
+ * returns-EAGAIN. Returned exceptions can optionally be cleared by
+ * setting the corresponding bit in the @exception_mask input parameter.
+ * However, clearing an exception prevents retrieving further information
+ * about it withKFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO.
+ *
+ * @exception_mask (IN/OUT) - exception to clear (IN) and raised (OUT)
+ * @gpu_id (OUT) - gpu id of exceptions raised
+ * @queue_id (OUT) - queue id of exceptions raised
+ *
+ * Generic errors apply (seekfd_dbg_trap_operations).
+ * Return - 0 on raised exception found
+ * Raised exceptions found are returned in @exception mask
+ * with reported source id returned in @gpu_id or @queue_id.
+ * - EAGAIN if no raised exception has been found
+ */include/uapi/linux/kfd_ioctl.h +43
-0+struct kfd_ioctl_dbg_trap_query_debug_event_args { +__u64 exception_mask; +__u32 gpu_id; +__u32 queue_id; +}; + +/** +* kfd_ioctl_dbg_trap_query_exception_info_args +* +* Arguments KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO +* Get additional info on raised exception. +* +* @info_ptr (IN) - pointer to exception info buffer to copy to +* @info_size (IN/OUT) - exception info buffer size (bytes) +* @source_id (IN) - target gpu or queue id +* @exception_code (IN) - target exception +* @clear_exception (IN) - clear raised @exception_code exception +* (0 = false, 1 = true) +* +* Generic errors apply (see kfd_dbg_trap_operations). +* Return - 0 on SUCCESS. +* If @exception_code is EC_DEVICE_MEMORY_VIOLATION, copy @info_size(OUT) +* bytes of memory exception data to @info_ptr. +* If @exception_code is EC_PROCESS_RUNTIME, copy saved +* kfd_runtime_info to @info_ptr. +* Actual required @info_ptr size (bytes) is returned in @info_size. +*/ +struct kfd_ioctl_dbg_trap_query_exception_info_args { +__u64 info_ptr; +__u32 info_size; +__u32 source_id; +__u32 exception_code; +__u32 clear_exception; +}; + +/** +* kfd_ioctl_dbg_trap_get_queue_snapshot_args +* +* Arguments KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT +* Get queue information. +* +* @exception_mask (IN) - exceptions raised to clear +* @snapshot_buf_ptr (IN) - queue snapshot entry buffer (see
kfd_queue_snapshot_entry)
+ * @num_queues (IN/OUT) - number of queue snapshot entries
+ * The debugger specifies the size of the array allocated in @num_queues.
+ * KFD returns the number of queues that actually existed. If this is
+ * larger than the size specified by the debugger, KFD will not overflow
+ * the array allocated by the debugger.
Quoted 8 lines
+ *
+ * @entry_size (IN/OUT) - size per entry in bytes
+ * The debugger specifiessizeof(struct kfd_queue_snapshot_entry)in
+ * @entry_size. KFD returns the number of bytes actually populated per
+ * entry. The debugger should use theKFD_IOCTL_MINOR_VERSIONto determine,
+ * which fields in structkfd_queue_snapshot_entryare valid. This allows
+ * growing the ABI in a backwards compatible manner.
It's worth mentioning that the @entry_size(in) is also used as stride if it is larger than the actual kfd_queue_snapshot_entry.
Quoted 28 lines
+ *
+ * Generic errors apply (seekfd_dbg_trap_operations).
+ * Return - 0 on SUCCESS.
+ * Copies @num_queues(IN) queue snapshot entries of size @entry_size(IN)
+ * into @snapshot_buf_ptr if @num_queues(IN) > 0.
+ * Otherwise return @num_queues(OUT) queue snapshot entries that exist.
+ */include/uapi/linux/kfd_ioctl.h +15
-0+struct kfd_ioctl_dbg_trap_queue_snapshot_args { +__u64 exception_mask; +__u64 snapshot_buf_ptr; +__u32 num_queues; +__u32 entry_size; +}; + +/** +* kfd_ioctl_dbg_trap_get_device_snapshot_args +* +* Arguments for KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT +* Get device information. +* +* @exception_mask (IN) - exceptions raised to clear +* @snapshot_buf_ptr (IN) - pointer to snapshot buffer (see
kfd_dbg_device_info_entry)
+ * @num_devices (IN/OUT) - number of debug devices to snapshot
+ * The debugger specifies the size of the array allocated in @num_devices.
+ * KFD returns the number of devices that actually existed. If this is
+ * larger than the size specified by the debugger, KFD will not overflow
Quoted 8 lines
+ * the array allocated by the debugger.
+ *
+ * @entry_size (IN/OUT) - size per entry in bytes
+ * The debugger specifiessizeof(struct kfd_dbg_device_info_entry)in
+ * @entry_size. KFD returns the number of bytes actually populated. The
+ * debugger should useKFD_IOCTL_MINOR_VERSIONto determine, which fields
+ * in structkfd_dbg_device_info_entryare valid. This allows growing the
+ * ABI in a backwards compatible manner.
It's worth mentioning that the @entry_size(in) is also used as stride if it is larger than the actual kfd_queue_snapshot_entry.
Regards,
Felix
Quoted 68 lines
+ *
+ * Generic errors apply (seekfd_dbg_trap_operations).
+ * Return - 0 on SUCCESS.
+ * Copies @num_devices(IN) device snapshot entries of size @entry_size(IN)
+ * into @snapshot_buf_ptr if @num_devices(IN) > 0.
+ * Otherwise return @num_devices(OUT) queue snapshot entries that exist.
+ */include/uapi/linux/kfd_ioctl.h +26
-0+struct kfd_ioctl_dbg_trap_device_snapshot_args { +__u64 exception_mask; +__u64 snapshot_buf_ptr; +__u32 num_devices; +__u32 entry_size; +}; + +/** +* kfd_ioctl_dbg_trap_args +* +* Arguments to debug target process. +* +* @pid - target process to debug +* @op - debug operation (see kfd_dbg_trap_operations) +* +* @op determines which union struct args to use. +* Refer to kern docs for each kfd_ioctl_dbg_trap_*_args struct. +*/ +struct kfd_ioctl_dbg_trap_args { +__u32 pid; +__u32 op; + +union { +struct kfd_ioctl_dbg_trap_enable_args enable; +struct kfd_ioctl_dbg_trap_send_runtime_event_args send_runtime_event; +struct kfd_ioctl_dbg_trap_set_exceptions_enabled_args
set_exceptions_enabled;
+ structkfd_ioctl_dbg_trap_set_wave_launch_override_argslaunch_override;
+ structkfd_ioctl_dbg_trap_set_wave_launch_mode_argslaunch_mode;
+ structkfd_ioctl_dbg_trap_suspend_queues_argssuspend_queues;
+ structkfd_ioctl_dbg_trap_resume_queues_argsresume_queues;
+ structkfd_ioctl_dbg_trap_set_node_address_watch_argsset_node_address_watch;
+ structkfd_ioctl_dbg_trap_clear_node_address_watch_argsclear_node_address_watch;
+ structkfd_ioctl_dbg_trap_set_flags_argsset_flags;
+ structkfd_ioctl_dbg_trap_query_debug_event_argsquery_debug_event;
+ structkfd_ioctl_dbg_trap_query_exception_info_argsquery_exception_info;
+ structkfd_ioctl_dbg_trap_queue_snapshot_argsqueue_snapshot;
+ structkfd_ioctl_dbg_trap_device_snapshot_argsdevice_snapshot;
+ };include/uapi/linux/kfd_ioctl.h +2
-0+}; +#define
AMDKFD_IOCTL_BASE'K'
#defineAMDKFD_IO(nr)_IO(AMDKFD_IOCTL_BASE, nr)#defineAMDKFD_IOR(nr, type)_IOR(AMDKFD_IOCTL_BASE, nr, type)include/uapi/linux/kfd_ioctl.h +7
-1@@ -877,7 +1524,13 @@ struct kfd_ioctl_set_xnack_mode_args {#define AMDKFD_IOC_AVAILABLE_MEMORY \ AMDKFD_IOWR(0x23, struct kfd_ioctl_get_available_memory_args) +#define AMDKFD_IOC_RUNTIME_ENABLE \ + AMDKFD_IOWR(0x24, struct kfd_ioctl_runtime_enable_args) + +#define AMDKFD_IOC_DBG_TRAP \ + AMDKFD_IOWR(0x25, struct kfd_ioctl_dbg_trap_args) +#define AMDKFD_COMMAND_START 0x01 -#define AMDKFD_COMMAND_END 0x24 +#define AMDKFD_COMMAND_END 0x26#endif
[Public]
Quoted 27 lines
-----Original Message-----
From: Kuehling, Felix <[email protected]>
Sent: November 22, 2022 6:05 PM
To: Kim, Jonathan <[email protected]>; amd- [email protected]
Subject: Re: [PATCH 01/29] drm/amdkfd: add debug and runtime enable interfaceQuoted 3 lines · Jonathan Kim
Introduce the GPU debug operations interface.
For ROCm-GDB to extend the GNU Debugger's ability to inspect the AMD
GPU
Quoted 4 lines
instruction set, provide the necessary interface to allow the debugger to HW debug-mode set and query exceptions per HSA queue, process or device.
Quoted 8 lines
The
runtime_enableinterface coordinates exception handling with the HSA runtime.Usage is available in the kern docs at
uapi/linux/kfd_ioctl.h.v2: add more documentation on semantics and error returns. expand
kfd_dbg_device_info_entrywith new fields. updatedevice_snapshotsematics to match queue snapshot semantics
Quoted 7 lines
This looks really good. I have 3 more nit-picks inline. Other than that, this patch is
Reviewed-by Felix Kuehling <[email protected]>Do we have a debugger branch that uses the API yet? We should make this public in order to complete this upstream code review.
Thanks for the review. I've given the heads up to the ROCm GDB maintainers to expect to sync with this API version soon so hopefully they can surface one shortly.
Thanks,
Jon
Quoted 830 lines
Quoted 183 lines
Signed-off-by Jonathan Kim <[email protected]>---
drivers/gpu/drm/amd/amdkfd/kfd_chardev.c| 48 ++include/uapi/linux/kfd_ioctl.h| 655 ++++++++++++++++++++++-2 files changed, 702 insertions(+), 1 deletion(-)drivers/gpu/drm/amd/amdkfd/kfd_chardev.c +42
-0@@ -2644,6 +2644,48 @@ static int kfd_ioctl_criu(struct file *filep, struct kfd_process *p, void *data) return ret; } +static int kfd_ioctl_runtime_enable (struct file *filep,struct kfd_process *p,void *data) +{ +return 0 ; +} + +static int kfd_ioctl_set_debug_trap (struct file *filep,struct kfd_process *p,void *data) +{ +struct kfd_ioctl_dbg_trap_args *args = data; +int r =0 ; + +if (sched_policy ==KFD_SCHED_POLICY_NO_HWS ) { +pr_err ("Debugging does not support sched_policy %i" , sched_policy); +return -EINVAL ; + } + +switch (args->op) { +case KFD_IOC_DBG_TRAP_ENABLE : +case KFD_IOC_DBG_TRAP_DISABLE : +case KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT : +case KFD_IOC_DBG_TRAP_SET_EXCEPTIONS_ENABLED : +case KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE : +case KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE : +case KFD_IOC_DBG_TRAP_SUSPEND_QUEUES : +case KFD_IOC_DBG_TRAP_RESUME_QUEUES : +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 : +case KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT : +case KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO : +case KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT : +case KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT : +pr_warn ("Debugging not supported yet\n" ); + r = -EACCES ; +break ; +default : +pr_err ("Invalid option: %i\n" , args->op); + r = -EINVAL ; + } + +return r; +} +#define AMDKFD_IOCTL_DEF (ioctl, _func, _flags) \[
_IOC_NR(ioctl)] = {.cmd = ioctl, .func =_func, .flags =_flags, \
.cmd_drv = 0, .name = #ioctl}drivers/gpu/drm/amd/amdkfd/kfd_chardev.c +6
-0@@ -2753,6 +2795,12 @@ static const struct amdkfd_ioctl_desc amdkfd_ioctls[] = {AMDKFD_IOCTL_DEF (AMDKFD_IOC_AVAILABLE_MEMORY , kfd_ioctl_get_available_memory,0 ), + +AMDKFD_IOCTL_DEF (AMDKFD_IOC_RUNTIME_ENABLE , + kfd_ioctl_runtime_enable,0 ), + +AMDKFD_IOCTL_DEF (AMDKFD_IOC_DBG_TRAP , + kfd_ioctl_set_debug_trap,0 ), };#define AMDKFD_CORE_IOCTL_COUNT ARRAY_SIZE(amdkfd_ioctls)include/uapi/linux/kfd_ioctl.h +22
-0@@ -109,6 +109,28 @@ struct kfd_ioctl_get_available_memory_args {__u32 pad; }; +struct kfd_dbg_device_info_entry { +__u64 exception_status; +__u64 lds_base; +__u64 lds_limit; +__u64 scratch_base; +__u64 scratch_limit; +__u64 gpuvm_base; +__u64 gpuvm_limit; +__u32 gpu_id; +__u32 location_id; +__u32 vendor_id; +__u32 device_id; +__u32 fw_version; +__u32 gfx_target_version; +__u32 simd_count; +__u32 max_waves_per_simd; +__u32 array_count; +__u32 simd_arrays_per_engine; +__u32 capability; +__u32 debug_prop; +}; +/* For kfd_ioctl_set_memory_policy_args.default_policy and
alternate_policy*/
#defineKFD_IOC_CACHE_POLICY_COHERENT0
#defineKFD_IOC_CACHE_POLICY_NONCOHERENT1include/uapi/linux/kfd_ioctl.h +69
-0@@ -766,6 +788,631 @@ struct kfd_ioctl_set_xnack_mode_args {__s32 xnack_enabled; }; +/* Wave launch override modes */ +enum kfd_dbg_trap_override_mode { +KFD_DBG_TRAP_OVERRIDE_OR =0 , +KFD_DBG_TRAP_OVERRIDE_REPLACE =1 +}; + +/* Wave launch overrides */ +enum kfd_dbg_trap_mask { +KFD_DBG_TRAP_MASK_FP_INVALID =1 , +KFD_DBG_TRAP_MASK_FP_INPUT_DENORMAL =2 , +KFD_DBG_TRAP_MASK_FP_DIVIDE_BY_ZERO =4 , +KFD_DBG_TRAP_MASK_FP_OVERFLOW =8 , +KFD_DBG_TRAP_MASK_FP_UNDERFLOW =16 , +KFD_DBG_TRAP_MASK_FP_INEXACT =32 , +KFD_DBG_TRAP_MASK_INT_DIVIDE_BY_ZERO =64 , +KFD_DBG_TRAP_MASK_DBG_ADDRESS_WATCH =128 , +KFD_DBG_TRAP_MASK_DBG_MEMORY_VIOLATION =256 +}; + +/* Wave launch modes */ +enum kfd_dbg_trap_wave_launch_mode { +KFD_DBG_TRAP_WAVE_LAUNCH_MODE_NORMAL =0 , +KFD_DBG_TRAP_WAVE_LAUNCH_MODE_HALT =1 , +KFD_DBG_TRAP_WAVE_LAUNCH_MODE_KILL =2 , +KFD_DBG_TRAP_WAVE_LAUNCH_MODE_DEBUG =3 , +KFD_DBG_TRAP_WAVE_LAUNCH_MODE_STALL =4 +}; + +/* Address watch modes */ +enum kfd_dbg_trap_address_watch_mode { +KFD_DBG_TRAP_ADDRESS_WATCH_MODE_READ =0 , +KFD_DBG_TRAP_ADDRESS_WATCH_MODE_NONREAD =1 , +KFD_DBG_TRAP_ADDRESS_WATCH_MODE_ATOMIC =2 , +KFD_DBG_TRAP_ADDRESS_WATCH_MODE_ALL =3 +}; + +/* Additional wave settings */ +enum kfd_dbg_trap_flags { +KFD_DBG_TRAP_FLAG_SINGLE_MEM_OP =1 , +KFD_DBG_TRAP_FLAG_SINGLE_ALU_OP =2 +}; + +/* Trap exceptions */ +enum kfd_dbg_trap_exception_code { +EC_NONE =0 , +/* per queue */ +EC_QUEUE_WAVE_ABORT =1 , +EC_QUEUE_WAVE_TRAP =2 , +EC_QUEUE_WAVE_MATH_ERROR =3 , +EC_QUEUE_WAVE_ILLEGAL_INSTRUCTION =4 , +EC_QUEUE_WAVE_MEMORY_VIOLATION =5 , +EC_QUEUE_WAVE_APERTURE_VIOLATION =6 , +EC_QUEUE_PACKET_DISPATCH_DIM_INVALID =16 , +EC_QUEUE_PACKET_DISPATCH_GROUP_SEGMENT_SIZE_INVALID =17 , +EC_QUEUE_PACKET_DISPATCH_CODE_INVALID =18 , +EC_QUEUE_PACKET_RESERVED =19 , +EC_QUEUE_PACKET_UNSUPPORTED =20 , +EC_QUEUE_PACKET_DISPATCH_WORK_GROUP_SIZE_INVALID =21 , +EC_QUEUE_PACKET_DISPATCH_REGISTER_INVALID =22 , +EC_QUEUE_PACKET_VENDOR_UNSUPPORTED =23 , +EC_QUEUE_PREEMPTION_ERROR =30 , +EC_QUEUE_NEW =31 , +/* per device */ +EC_DEVICE_QUEUE_DELETE =32 , +EC_DEVICE_MEMORY_VIOLATION =33 , +EC_DEVICE_RAS_ERROR =34 , +EC_DEVICE_FATAL_HALT =35 , +EC_DEVICE_NEW =36 , +/* per process */ include/uapi/linux/kfd_ioctl.h struct kfd_ioctl_set_xnack_mode_args { · line 868
Quoted 10 lines
include/uapi/linux/kfd_ioctl.h +10
-0+EC_PROCESS_RUNTIME =48 , +EC_PROCESS_DEVICE_REMOVE =49 , + EC_MAX +}; + +/* Mask generated by ecode in kfd_dbg_trap_exception_code */ +#define KFD_EC_MASK (ecode) (1ULL << (ecode - 1)) + +/* Masks for exception code type checks below */ +#define KFD_EC_MASK_QUEUE (
KFD_EC_MASK(EC_QUEUE_WAVE_ABORT)| \include/uapi/linux/kfd_ioctl.h struct kfd_ioctl_set_xnack_mode_args { · line 891
Quoted 7 lines
include/uapi/linux/kfd_ioctl.h +7
-0+KFD_EC_MASK (EC_QUEUE_WAVE_TRAP ) | \ +KFD_EC_MASK (EC_QUEUE_WAVE_MATH_ERROR ) | \ +KFD_EC_MASK (EC_QUEUE_WAVE_ILLEGAL_INSTRUCTION ) | \ +KFD_EC_MASK (EC_QUEUE_WAVE_MEMORY_VIOLATION ) | \ +KFD_EC_MASK (EC_QUEUE_WAVE_APERTURE_VIOLATION ) | \ + KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_DIM_INVALID) | \ +
KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_GROUP_SEGMENT_SIZE_IN VALID)| \include/uapi/linux/kfd_ioctl.h struct kfd_ioctl_set_xnack_mode_args { · line 891
Quoted 3 lines
include/uapi/linux/kfd_ioctl.h +3
-0+KFD_EC_MASK (EC_QUEUE_PACKET_DISPATCH_CODE_INVALID ) | \ + KFD_EC_MASK(EC_QUEUE_PACKET_UNSUPPORTED) | \ +
KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_WORK_GROUP_SIZE_INVAL ID)| \include/uapi/linux/kfd_ioctl.h struct kfd_ioctl_set_xnack_mode_args {
Quoted 5 lines
include/uapi/linux/kfd_ioctl.h +5
-0+KFD_EC_MASK (EC_QUEUE_PACKET_DISPATCH_REGISTER_INVALID ) | \ +KFD_EC_MASK (EC_QUEUE_PACKET_VENDOR_UNSUPPORTED ) | \ +KFD_EC_MASK (EC_QUEUE_PREEMPTION_ERROR ) | \ + KFD_EC_MASK(EC_QUEUE_NEW)) +#define KFD_EC_MASK_DEVICE(
KFD_EC_MASK(EC_DEVICE_QUEUE_DELETE)| \include/uapi/linux/kfd_ioctl.h struct kfd_ioctl_set_xnack_mode_args {
Quoted 5 lines
include/uapi/linux/kfd_ioctl.h +5
-0+KFD_EC_MASK (EC_DEVICE_RAS_ERROR ) | \ +KFD_EC_MASK (EC_DEVICE_FATAL_HALT ) | \ +KFD_EC_MASK (EC_DEVICE_MEMORY_VIOLATION ) | \ + KFD_EC_MASK(EC_DEVICE_NEW)) +#define KFD_EC_MASK_PROCESS(
KFD_EC_MASK(EC_PROCESS_RUNTIME)| \Quoted 34 lines
include/uapi/linux/kfd_ioctl.h +34
-0+ KFD_EC_MASK(EC_PROCESS_DEVICE_REMOVE)) + +/* Checks for exception code types for KFD search */ +#define KFD_DBG_EC_TYPE_IS_QUEUE (ecode) \ + (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_QUEUE)) +#define KFD_DBG_EC_TYPE_IS_DEVICE (ecode) \ + (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_DEVICE)) +#define KFD_DBG_EC_TYPE_IS_PROCESS (ecode) \ + (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_PROCESS)) + + +/* Runtime enable states */ +enum kfd_dbg_runtime_state { +DEBUG_RUNTIME_STATE_DISABLED =0 , +DEBUG_RUNTIME_STATE_ENABLED =1 , +DEBUG_RUNTIME_STATE_ENABLED_BUSY =2 , +DEBUG_RUNTIME_STATE_ENABLED_ERROR =3 +}; + +/* Runtime enable status */ +struct kfd_runtime_info { +__u64 r_debug; +__u32 runtime_state; +__u32 ttmp_setup; +}; + +/* Enable modes for runtime enable */ +#define KFD_RUNTIME_ENABLE_MODE_ENABLE_MASK 1 +#define KFD_RUNTIME_ENABLE_MODE_TTMP_SAVE_MASK 2 + +/** +* kfd_ioctl_runtime_enable_args - Arguments for runtime enable +* +* Coordinates debug exception signalling and debug device enablement Quoted 8 lines
with runtime.
+ *
+ * @r_debug - pointer to user struct for sharing information between ROCr and the debuggger
+ * @mode_mask - mask to set mode
+ *KFD_RUNTIME_ENABLE_MODE_ENABLE_MASK- enable runtime for debugging, otherwise disable
+ *KFD_RUNTIME_ENABLE_MODE_TTMP_SAVE_MASK- enable traptemporary
Quoted 8 lines
setup (ignore on disable)
+ *
+ * Return - 0 on SUCCESS.
+ * - EBUSY if runtime enable call already pending.
+ * - EEXIST if user queues already active prior to call.
+ * If process is debug enabled, runtime enable will enable debug devices and
+ * wait for debugger process to send runtime exception
EC_PROCESS_RUNTIMEQuoted 17 lines
+ * to unblock - see
kfd_ioctl_dbg_trap_args.
+ *
+ */include/uapi/linux/kfd_ioctl.h +14
-0+struct kfd_ioctl_runtime_enable_args { +__u64 r_debug; +__u32 mode_mask; +}; + +/* Queue information */ +struct kfd_queue_snapshot_entry { +__u64 exception_status; +__u64 ring_base_address; +__u64 write_pointer_address; +__u64 read_pointer_address; +__u64 ctx_save_restore_address; +__u32 queue_id; +__u32 gpu_id;include/uapi/linux/kfd_ioctl.h struct kfd_ioctl_set_xnack_mode_args {
Quoted 10 lines
include/uapi/linux/kfd_ioctl.h +10
-0+__u32 ring_size; +__u32 queue_type; +__u32 ctx_save_restore_area_size; +__u32 reserved; +}; + +/* Queue status return for suspend/resume */ +#define KFD_DBG_QUEUE_ERROR_BIT 30 +#define KFD_DBG_QUEUE_INVALID_BIT 31 +#define KFD_DBG_QUEUE_ERROR_MASK (1 <<
KFD_DBG_QUEUE_ERROR_BIT)Quoted 1 line
+#define
KFD_DBG_QUEUE_INVALID_MASK(1 <<
KFD_DBG_QUEUE_INVALID_BIT)Quoted 24 lines
include/uapi/linux/kfd_ioctl.h +18
-0+ +/* Context save area header information */ +struct kfd_context_save_area_header { +__u32 control_stack_offset; +__u32 control_stack_size; +__u32 wave_state_offset; +__u32 wave_state_size; +__u32 debug_offset; +__u32 debug_size; +__u64 err_payload_addr; +__u32 err_event_id; +__u32 reserved1; +}; + +/* +* Debug operations +* +* For specifics on usage and return values, see documentation per operation
+ * below. Otherwise, generic error returns apply:
+ * - ESRCH if the process to debug does not exist.
+ *
+ * - EINVAL (withKFD_IOC_DBG_TRAP_ENABLEexempt) if operation
+ *KFD_IOC_DBG_TRAP_ENABLEhas not succeeded prior.Quoted 8 lines
+ * Also returns this error if GPU hardware scheduling is not supported.
+ *
+ * - EPERM (withKFD_IOC_DBG_TRAP_DISABLEexempt) if target process is not
+ *PTRACE_ATTACHED.KFD_IOC_DBG_TRAP_DISABLEis exempt to allow
+ * clean up of debug mode as long as process is debug enabled.
+ *
+ * - EACCES if anyDBG_HW_OP(debug hardware operation) is requestedwhen
Quoted 3 lines
+ *
AMDKFD_IOC_RUNTIME_ENABLEhas not succeeded prior.
+ *
+ * - ENODEV if any GPU does not support debugging on aDBG_HW_OPcall.
Quoted 2 lines
+ *
+ * - Other errors may be returned when aDBG_HW_OPoccurs while theGPU
Quoted 9 lines
+ * is in a fatal state.
+ *
+ */
+enumkfd_dbg_trap_operations{
+KFD_IOC_DBG_TRAP_ENABLE= 0,
+KFD_IOC_DBG_TRAP_DISABLE= 1,
+KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT= 2,
+KFD_IOC_DBG_TRAP_SET_EXCEPTIONS_ENABLED= 3,
+KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE= 4, /*
DBG_HW_OP*/Quoted 1 line
+
KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE= 5, /*DBG_HW_OP*/
Quoted 3 lines
+
KFD_IOC_DBG_TRAP_SUSPEND_QUEUES= 6, /*DBG_HW_OP*/
+KFD_IOC_DBG_TRAP_RESUME_QUEUES= 7, /*DBG_HW_OP*/
+KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH= 8, /*DBG_HW_OP*/
Quoted 1 line
+
KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH= 9, /*
DBG_HW_OP*/Quoted 45 lines
+
KFD_IOC_DBG_TRAP_SET_FLAGS= 10,
+KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT= 11,
+KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO= 12,
+KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT= 13,
+KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT= 14include/uapi/linux/kfd_ioctl.h +8
-0+}; + +/** +* kfd_ioctl_dbg_trap_enable_args +* +* Arguments for KFD_IOC_DBG_TRAP_ENABLE. +* +* Enables debug session for target process. Call @op
KFD_IOC_DBG_TRAP_DISABLEin
+ *kfd_ioctl_dbg_trap_argsto disable debug session.
+ *
+ * @exception_mask (IN) - exceptions to raise to the debugger
+ * @rinfo_ptr (IN) - pointer to runtime info buffer (seekfd_runtime_info)
+ * @rinfo_size (IN/OUT) - size of runtime info buffer in bytes
+ * @dbg_fd (IN) - fd the KFD will nofify the debugger with of raised
+ * exceptions set inexception_mask.
+ *
+ * Generic errors apply (seekfd_dbg_trap_operations).
+ * Return - 0 on SUCCESS.
+ * Copies KFD savedkfd_runtime_infoto @rinfo_ptr on enable.
+ * Size ofkfd_runtimesaved by the KFD returned to @rinfo_size.
+ * - EBADF if KFD cannot get a reference todbg_fd.
+ * - EFAULT if KFD cannot copy runtime info torinfo_ptr.
+ * - EINVAL if target process is already debug enabled.
+ *
+ */include/uapi/linux/kfd_ioctl.h +13
-0+struct kfd_ioctl_dbg_trap_enable_args { +__u64 exception_mask; +__u64 rinfo_ptr; +__u32 rinfo_size; +__u32 dbg_fd; +}; + +/** +* kfd_ioctl_dbg_trap_send_runtime_event_args +* +* +* Arguments for KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT. +* Raises exceptions to runtime. include/uapi/linux/kfd_ioctl.h struct kfd_ioctl_set_xnack_mode_args {
Quoted 10 lines
include/uapi/linux/kfd_ioctl.h +10
-0+* +* @exception_mask (IN) - exceptions to raise to runtime +* @gpu_id (IN) - target device id +* @queue_id (IN) - target queue id +* +* Generic errors apply (see kfd_dbg_trap_operations). +* Return - 0 on SUCCESS. +* - ENODEV if gpu_id not found. +* If exception_mask contains EC_PROCESS_RUNTIME, unblocks pending +* AMDKFD_IOC_RUNTIME_ENABLE call - see
kfd_ioctl_runtime_enable_args.Quoted 79 lines
+ * All other exceptions are raised to runtime through
err_payload_addr.
+ * Seekfd_context_save_area_header.
+ */include/uapi/linux/kfd_ioctl.h +43
-0+struct kfd_ioctl_dbg_trap_send_runtime_event_args { +__u64 exception_mask; +__u32 gpu_id; +__u32 queue_id; +}; + +/** +* kfd_ioctl_dbg_trap_set_exceptions_enabled_args +* +* Arguments for KFD_IOC_SET_EXCEPTIONS_ENABLED +* Set new exceptions to be raised to the debugger. +* +* @exception_mask (IN) - new exceptions to raise the debugger +* +* Generic errors apply (see kfd_dbg_trap_operations). +* Return - 0 on SUCCESS. +*/ +struct kfd_ioctl_dbg_trap_set_exceptions_enabled_args { +__u64 exception_mask; +}; + +/** +* kfd_ioctl_dbg_trap_set_wave_launch_override_args +* +* Arguments for KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE +* Enable HW exceptions to raise trap. +* +* @override_mode (IN) - see kfd_dbg_trap_override_mode +* @enable_mask (IN/OUT) - reference kfd_dbg_trap_mask. +* IN is the override modes requested to be enabled. +* OUT is referenced in Return below. +* @support_request_mask (IN/OUT) - reference kfd_dbg_trap_mask. +* IN is the override modes requested for support check. +* OUT is referenced in Return below. +* +* Generic errors apply (see kfd_dbg_trap_operations). +* Return - 0 on SUCCESS. +* Previous enablement is returned in @enable_mask. +* Actual override support is returned in @support_request_mask. +* - EINVAL if override mode is not supported. +* - EACCES if trap support requested is not actually supported. +* i.e. enable_mask (IN) is not a subset of support_request_mask (OUT). +* Otherwise it is considered a generic error (see
kfd_dbg_trap_operations).
+ */include/uapi/linux/kfd_ioctl.h +31
-0+struct kfd_ioctl_dbg_trap_set_wave_launch_override_args { +__u32 override_mode; +__u32 enable_mask; +__u32 support_request_mask; +__u32 pad; +}; + +/** +* kfd_ioctl_dbg_trap_set_wave_launch_mode_args +* +* Arguments for KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE +* Set wave launch mode. +* +* @mode (IN) - see kfd_dbg_trap_wave_launch_mode +* +* Generic errors apply (see kfd_dbg_trap_operations). +* Return - 0 on SUCCESS. +*/ +struct kfd_ioctl_dbg_trap_set_wave_launch_mode_args { +__u32 launch_mode; +__u32 pad; +}; + +/** +* kfd_ioctl_dbg_trap_suspend_queues_args +* +* Arguments for KFD_IOC_DBG_TRAP_SUSPEND_QUEUES +* Suspend queues. +* +* @exception_mask (IN) - raised exceptions to clear +* @queue_array_ptr (IN) - pointer to array of queue ids (u32 per Quoted 3 lines
queue id)
+ * to suspend
+ * @num_queues (IN) - number of queues to suspend in@queue_array_ptr
Quoted 6 lines
+ * @grace_period (IN) - wave time allowance before preemption
+ * per 1K GPU clock cycle unit
+ *
+ * Generic errors apply (seekfd_dbg_trap_operations).
+ * Return - Number of queues suspended on SUCCESS.
+ *KFD_DBG_QUEUE_ERROR_MASKand
KFD_DBG_QUEUE_INVALID_MASKmaskedQuoted 4 lines
+ * for each queue id in @queue_array_ptr array reports unsuccessful
+ * suspend reason.
+ *KFD_DBG_QUEUE_ERROR_MASK= HW failure.
+ *KFD_DBG_QUEUE_INVALID_MASK= queue does not exist, is new orQuoted 8 lines
+ * is being destroyed.
+ * Destruction of a suspended queue is blocked until the queue is
+ * resumed. This allows the debugger to access queue information and
+ * the its context save area without running into a race condition on
+ * queue destruction.
+ * Automatically copies per queue context save area header information
+ * into the save area base
+ * (seekfd_queue_snapshot_entryand
kfd_context_save_area_header).The last two paragraphs would make more sens as a description above the Return statement.
Quoted 15 lines
+ */
include/uapi/linux/kfd_ioctl.h +14
-0+struct kfd_ioctl_dbg_trap_suspend_queues_args { +__u64 exception_mask; +__u64 queue_array_ptr; +__u32 num_queues; +__u32 grace_period; +}; + +/** +* kfd_ioctl_dbg_trap_resume_queues_args +* +* Arguments for KFD_IOC_DBG_TRAP_RESUME_QUEUES +* Resume queues. +* +* @queue_array_ptr (IN) - pointer to array of queue ids (u32 per Quoted 3 lines
queue id)
+ * to resume
+ * @num_queues (IN) - number of queues to resume in@queue_array_ptr
Quoted 4 lines
+ *
+ * Generic errors apply (seekfd_dbg_trap_operations).
+ * Return - Number of queues resumed on SUCCESS.
+ *KFD_DBG_QUEUE_ERROR_MASKand
KFD_DBG_QUEUE_INVALID_MASKmaskQuoted 80 lines
+ * for each queue id in @queue_array_ptr array reports unsuccessful
+ * resume reason.
+ *KFD_DBG_QUEUE_ERROR_MASK= HW failure.
+ *KFD_DBG_QUEUE_INVALID_MASK= queue does not exist.
+ */include/uapi/linux/kfd_ioctl.h +75
-0+struct kfd_ioctl_dbg_trap_resume_queues_args { +__u64 queue_array_ptr; +__u32 num_queues; +__u32 pad; +}; + +/** +* kfd_ioctl_dbg_trap_set_node_address_watch_args +* +* Arguments for KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH +* Sets address watch for device. +* +* @address (IN) - watch address to set +* @mode (IN) - see kfd_dbg_trap_address_watch_mode +* @mask (IN) - watch address mask +* @gpu_id (IN) - target gpu to set watch point +* @id (OUT) - watch id allocated +* +* Generic errors apply (see kfd_dbg_trap_operations). +* Return - 0 on SUCCESS. +* Allocated watch ID returned to @id. +* - ENODEV if gpu_id not found. +* - ENOMEM if watch IDs can be allocated +*/ +struct kfd_ioctl_dbg_trap_set_node_address_watch_args { +__u64 address; +__u32 mode; +__u32 mask; +__u32 gpu_id; +__u32 id; +}; + +/** +* kfd_ioctl_dbg_trap_clear_node_address_watch_args +* +* Arguments for KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH +* Clear address watch for device. +* +* @gpu_id (IN) - target device to clear watch point +* @id (IN) - allocated watch id to clear +* +* Generic errors apply (see kfd_dbg_trap_operations). +* Return - 0 on SUCCESS. +* - ENODEV if gpu_id not found. +* - EINVAL if watch ID has not been allocated. +*/ +struct kfd_ioctl_dbg_trap_clear_node_address_watch_args { +__u32 gpu_id; +__u32 id; +}; + +/** +* kfd_ioctl_dbg_trap_set_flags_args +* +* Arguments for KFD_IOC_DBG_TRAP_SET_FLAGS +* Sets flags for wave behaviour. +* +* @flags (IN/OUT) - IN = flags to enable, OUT = flags previously enabled +* +* Generic errors apply (see kfd_dbg_trap_operations). +* Return - 0 on SUCCESS. +* - EACCESS if any debug device does not allow flag options. +*/ +struct kfd_ioctl_dbg_trap_set_flags_args { +__u32 flags; +__u32 pad; +}; + +/** +* kfd_ioctl_dbg_trap_query_debug_event_args +* +* Arguments for KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT +* +* Find one or more raised exceptions. This function can return multiple +* exceptions from a single queue or a single device with one call. Quoted 5 lines
To find
+ * all raised exceptions, this function must be called repeatedly until it
+ * returns-EAGAIN. Returned exceptions can optionally be cleared by
+ * setting the corresponding bit in the @exception_mask inputparameter.
Quoted 25 lines
+ * However, clearing an exception prevents retrieving further information
+ * about it withKFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO.
+ *
+ * @exception_mask (IN/OUT) - exception to clear (IN) and raised (OUT)
+ * @gpu_id (OUT) - gpu id of exceptions raised
+ * @queue_id (OUT) - queue id of exceptions raised
+ *
+ * Generic errors apply (seekfd_dbg_trap_operations).
+ * Return - 0 on raised exception found
+ * Raised exceptions found are returned in @exception mask
+ * with reported source id returned in @gpu_id or @queue_id.
+ * - EAGAIN if no raised exception has been found
+ */include/uapi/linux/kfd_ioctl.h +12
-0+struct kfd_ioctl_dbg_trap_query_debug_event_args { +__u64 exception_mask; +__u32 gpu_id; +__u32 queue_id; +}; + +/** +* kfd_ioctl_dbg_trap_query_exception_info_args +* +* Arguments KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO +* Get additional info on raised exception. +* include/uapi/linux/kfd_ioctl.h struct kfd_ioctl_set_xnack_mode_args {
Quoted 10 lines
include/uapi/linux/kfd_ioctl.h +10
-0+* @info_ptr (IN) - pointer to exception info buffer to copy to +* @info_size (IN/OUT) - exception info buffer size (bytes) +* @source_id (IN) - target gpu or queue id +* @exception_code (IN) - target exception +* @clear_exception (IN) - clear raised @exception_code exception +* (0 = false, 1 = true) +* +* Generic errors apply (see kfd_dbg_trap_operations). +* Return - 0 on SUCCESS. +* If @exception_code is EC_DEVICE_MEMORY_VIOLATION, copy @info_size(OUT)
Quoted 21 lines
+ * bytes of memory exception data to @info_ptr.
+ * If @exception_code isEC_PROCESS_RUNTIME, copy saved
+ *kfd_runtime_infoto @info_ptr.
+ * Actual required @info_ptr size (bytes) is returned in @info_size.
+ */include/uapi/linux/kfd_ioctl.h +16
-0+struct kfd_ioctl_dbg_trap_query_exception_info_args { +__u64 info_ptr; +__u32 info_size; +__u32 source_id; +__u32 exception_code; +__u32 clear_exception; +}; + +/** +* kfd_ioctl_dbg_trap_get_queue_snapshot_args +* +* Arguments KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT +* Get queue information. +* +* @exception_mask (IN) - exceptions raised to clear +* @snapshot_buf_ptr (IN) - queue snapshot entry buffer (see Quoted 3 lines
kfd_queue_snapshot_entry)
+ * @num_queues (IN/OUT) - number of queue snapshot entries
+ * The debugger specifies the size of the array allocated in@num_queues.
Quoted 11 lines
+ * KFD returns the number of queues that actually existed. If this is
+ * larger than the size specified by the debugger, KFD will not overflow
+ * the array allocated by the debugger.
+ *
+ * @entry_size (IN/OUT) - size per entry in bytes
+ * The debugger specifiessizeof(struct kfd_queue_snapshot_entry)in
+ * @entry_size. KFD returns the number of bytes actually populated per
+ * entry. The debugger should use theKFD_IOCTL_MINOR_VERSIONto determine,
+ * which fields in structkfd_queue_snapshot_entryare valid. This allows
+ * growing the ABI in a backwards compatible manner.It's worth mentioning that the @entry_size(in) is also used as stride if it is larger than the actual
kfd_queue_snapshot_entry.Quoted 4 lines
+ *
+ * Generic errors apply (seekfd_dbg_trap_operations).
+ * Return - 0 on SUCCESS.
+ * Copies @num_queues(IN) queue snapshot entries of size@entry_size(IN)
Quoted 2 lines
+ * into @snapshot_buf_ptr if @num_queues(IN) > 0.
+ * Otherwise return @num_queues(OUT) queue snapshot entries thatexist.
Quoted 20 lines
+ */
include/uapi/linux/kfd_ioctl.h +15
-0+struct kfd_ioctl_dbg_trap_queue_snapshot_args { +__u64 exception_mask; +__u64 snapshot_buf_ptr; +__u32 num_queues; +__u32 entry_size; +}; + +/** +* kfd_ioctl_dbg_trap_get_device_snapshot_args +* +* Arguments for KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT +* Get device information. +* +* @exception_mask (IN) - exceptions raised to clear +* @snapshot_buf_ptr (IN) - pointer to snapshot buffer (see
kfd_dbg_device_info_entry)
+ * @num_devices (IN/OUT) - number of debug devices to snapshot
+ * The debugger specifies the size of the array allocated in @num_devices.Quoted 8 lines
+ * KFD returns the number of devices that actually existed. If this is
+ * larger than the size specified by the debugger, KFD will not overflow
+ * the array allocated by the debugger.
+ *
+ * @entry_size (IN/OUT) - size per entry in bytes
+ * The debugger specifiessizeof(struct kfd_dbg_device_info_entry)in
+ * @entry_size. KFD returns the number of bytes actually populated. The
+ * debugger should useKFD_IOCTL_MINOR_VERSIONto determine,which fields
Quoted 2 lines
+ * in struct
kfd_dbg_device_info_entryare valid. This allows growing the
+ * ABI in a backwards compatible manner.It's worth mentioning that the @entry_size(in) is also used as stride if it is larger than the actual
kfd_queue_snapshot_entry.Regards,
FelixQuoted 7 lines
+ *
+ * Generic errors apply (seekfd_dbg_trap_operations).
+ * Return - 0 on SUCCESS.
+ * Copies @num_devices(IN) device snapshot entries of size @entry_size(IN)
+ * into @snapshot_buf_ptr if @num_devices(IN) > 0.
+ * Otherwise return @num_devices(OUT) queue snapshot entries thatexist.
Quoted 16 lines
+ */
include/uapi/linux/kfd_ioctl.h +15
-0+struct kfd_ioctl_dbg_trap_device_snapshot_args { +__u64 exception_mask; +__u64 snapshot_buf_ptr; +__u32 num_devices; +__u32 entry_size; +}; + +/** +* kfd_ioctl_dbg_trap_args +* +* Arguments to debug target process. +* +* @pid - target process to debug +* @op - debug operation (see kfd_dbg_trap_operations) +* include/uapi/linux/kfd_ioctl.h struct kfd_ioctl_set_xnack_mode_args {
Quoted 10 lines
include/uapi/linux/kfd_ioctl.h +10
-0+* @op determines which union struct args to use. +* Refer to kern docs for each kfd_ioctl_dbg_trap_*_args struct. +*/ +struct kfd_ioctl_dbg_trap_args { +__u32 pid; +__u32 op; + +union { +struct kfd_ioctl_dbg_trap_enable_args enable; +struct kfd_ioctl_dbg_trap_send_runtime_event_args
send_runtime_event;Quoted 3 lines
+ struct
kfd_ioctl_dbg_trap_set_exceptions_enabled_argsset_exceptions_enabled;
+ structkfd_ioctl_dbg_trap_set_wave_launch_override_args
launch_override;Quoted 9 lines
+ struct
kfd_ioctl_dbg_trap_set_wave_launch_mode_argslaunch_mode;
+ structkfd_ioctl_dbg_trap_suspend_queues_argssuspend_queues;
+ structkfd_ioctl_dbg_trap_resume_queues_argsresume_queues;
+ structkfd_ioctl_dbg_trap_set_node_address_watch_argsset_node_address_watch;
+ structkfd_ioctl_dbg_trap_clear_node_address_watch_argsclear_node_address_watch;
+ structkfd_ioctl_dbg_trap_set_flags_argsset_flags;
+ structkfd_ioctl_dbg_trap_query_debug_event_args
query_debug_event;Quoted 23 lines
+ struct
kfd_ioctl_dbg_trap_query_exception_info_argsquery_exception_info;
+ structkfd_ioctl_dbg_trap_queue_snapshot_argsqueue_snapshot;
+ structkfd_ioctl_dbg_trap_device_snapshot_argsdevice_snapshot;
+ };include/uapi/linux/kfd_ioctl.h +2
-0+}; +#define
AMDKFD_IOCTL_BASE'K'
#defineAMDKFD_IO(nr)_IO(AMDKFD_IOCTL_BASE, nr)#defineAMDKFD_IOR(nr, type)_IOR(AMDKFD_IOCTL_BASE, nr, type)include/uapi/linux/kfd_ioctl.h +7
-1@@ -877,7 +1524,13 @@ struct kfd_ioctl_set_xnack_mode_args {#define AMDKFD_IOC_AVAILABLE_MEMORY \ AMDKFD_IOWR(0x23, struct kfd_ioctl_get_available_memory_args) +#define AMDKFD_IOC_RUNTIME_ENABLE \ + AMDKFD_IOWR(0x24, struct kfd_ioctl_runtime_enable_args) + +#define AMDKFD_IOC_DBG_TRAP \ + AMDKFD_IOWR(0x25, struct kfd_ioctl_dbg_trap_args) +#define AMDKFD_COMMAND_START 0x01 -#define AMDKFD_COMMAND_END 0x24 +#define AMDKFD_COMMAND_END 0x26#endif