10ab2d753SJonathan Kim /*
20ab2d753SJonathan Kim * Copyright 2023 Advanced Micro Devices, Inc.
30ab2d753SJonathan Kim *
40ab2d753SJonathan Kim * Permission is hereby granted, free of charge, to any person obtaining a
50ab2d753SJonathan Kim * copy of this software and associated documentation files (the "Software"),
60ab2d753SJonathan Kim * to deal in the Software without restriction, including without limitation
70ab2d753SJonathan Kim * the rights to use, copy, modify, merge, publish, distribute, sublicense,
80ab2d753SJonathan Kim * and/or sell copies of the Software, and to permit persons to whom the
90ab2d753SJonathan Kim * Software is furnished to do so, subject to the following conditions:
100ab2d753SJonathan Kim *
110ab2d753SJonathan Kim * The above copyright notice and this permission notice shall be included in
120ab2d753SJonathan Kim * all copies or substantial portions of the Software.
130ab2d753SJonathan Kim *
140ab2d753SJonathan Kim * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
150ab2d753SJonathan Kim * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
160ab2d753SJonathan Kim * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
170ab2d753SJonathan Kim * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
180ab2d753SJonathan Kim * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
190ab2d753SJonathan Kim * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
200ab2d753SJonathan Kim * OTHER DEALINGS IN THE SOFTWARE.
210ab2d753SJonathan Kim */
220ab2d753SJonathan Kim
230ab2d753SJonathan Kim #include "kfd_debug.h"
2421889582SJonathan Kim #include "kfd_device_queue_manager.h"
2512976e6aSJonathan Kim #include "kfd_topology.h"
260ab2d753SJonathan Kim #include <linux/file.h>
27103d5f08SJonathan Kim #include <uapi/linux/kfd_ioctl.h>
280ab2d753SJonathan Kim
29e0f85f46SJonathan Kim #define MAX_WATCH_ADDRESSES 4
30e0f85f46SJonathan Kim
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)315bc20c22SJonathan Kim int kfd_dbg_ev_query_debug_event(struct kfd_process *process,
325bc20c22SJonathan Kim unsigned int *queue_id,
335bc20c22SJonathan Kim unsigned int *gpu_id,
345bc20c22SJonathan Kim uint64_t exception_clear_mask,
355bc20c22SJonathan Kim uint64_t *event_status)
365bc20c22SJonathan Kim {
375bc20c22SJonathan Kim struct process_queue_manager *pqm;
385bc20c22SJonathan Kim struct process_queue_node *pqn;
395bc20c22SJonathan Kim int i;
405bc20c22SJonathan Kim
415bc20c22SJonathan Kim if (!(process && process->debug_trap_enabled))
425bc20c22SJonathan Kim return -ENODATA;
435bc20c22SJonathan Kim
445bc20c22SJonathan Kim mutex_lock(&process->event_mutex);
455bc20c22SJonathan Kim *event_status = 0;
465bc20c22SJonathan Kim *queue_id = 0;
475bc20c22SJonathan Kim *gpu_id = 0;
485bc20c22SJonathan Kim
495bc20c22SJonathan Kim /* find and report queue events */
505bc20c22SJonathan Kim pqm = &process->pqm;
515bc20c22SJonathan Kim list_for_each_entry(pqn, &pqm->queues, process_queue_list) {
525bc20c22SJonathan Kim uint64_t tmp = process->exception_enable_mask;
535bc20c22SJonathan Kim
545bc20c22SJonathan Kim if (!pqn->q)
555bc20c22SJonathan Kim continue;
565bc20c22SJonathan Kim
575bc20c22SJonathan Kim tmp &= pqn->q->properties.exception_status;
585bc20c22SJonathan Kim
595bc20c22SJonathan Kim if (!tmp)
605bc20c22SJonathan Kim continue;
615bc20c22SJonathan Kim
625bc20c22SJonathan Kim *event_status = pqn->q->properties.exception_status;
635bc20c22SJonathan Kim *queue_id = pqn->q->properties.queue_id;
645bc20c22SJonathan Kim *gpu_id = pqn->q->device->id;
655bc20c22SJonathan Kim pqn->q->properties.exception_status &= ~exception_clear_mask;
665bc20c22SJonathan Kim goto out;
675bc20c22SJonathan Kim }
685bc20c22SJonathan Kim
695bc20c22SJonathan Kim /* find and report device events */
705bc20c22SJonathan Kim for (i = 0; i < process->n_pdds; i++) {
715bc20c22SJonathan Kim struct kfd_process_device *pdd = process->pdds[i];
725bc20c22SJonathan Kim uint64_t tmp = process->exception_enable_mask
735bc20c22SJonathan Kim & pdd->exception_status;
745bc20c22SJonathan Kim
755bc20c22SJonathan Kim if (!tmp)
765bc20c22SJonathan Kim continue;
775bc20c22SJonathan Kim
785bc20c22SJonathan Kim *event_status = pdd->exception_status;
795bc20c22SJonathan Kim *gpu_id = pdd->dev->id;
805bc20c22SJonathan Kim pdd->exception_status &= ~exception_clear_mask;
815bc20c22SJonathan Kim goto out;
825bc20c22SJonathan Kim }
835bc20c22SJonathan Kim
845bc20c22SJonathan Kim /* report process events */
855bc20c22SJonathan Kim if (process->exception_enable_mask & process->exception_status) {
865bc20c22SJonathan Kim *event_status = process->exception_status;
875bc20c22SJonathan Kim process->exception_status &= ~exception_clear_mask;
885bc20c22SJonathan Kim }
895bc20c22SJonathan Kim
905bc20c22SJonathan Kim out:
915bc20c22SJonathan Kim mutex_unlock(&process->event_mutex);
925bc20c22SJonathan Kim return *event_status ? 0 : -EAGAIN;
935bc20c22SJonathan Kim }
945bc20c22SJonathan Kim
debug_event_write_work_handler(struct work_struct * work)9544b87bb0SJonathan Kim void debug_event_write_work_handler(struct work_struct *work)
9644b87bb0SJonathan Kim {
9744b87bb0SJonathan Kim struct kfd_process *process;
9844b87bb0SJonathan Kim
9944b87bb0SJonathan Kim static const char write_data = '.';
10044b87bb0SJonathan Kim loff_t pos = 0;
10144b87bb0SJonathan Kim
10244b87bb0SJonathan Kim process = container_of(work,
10344b87bb0SJonathan Kim struct kfd_process,
10444b87bb0SJonathan Kim debug_event_workarea);
10544b87bb0SJonathan Kim
10644b87bb0SJonathan Kim kernel_write(process->dbg_ev_file, &write_data, 1, &pos);
10744b87bb0SJonathan Kim }
10844b87bb0SJonathan Kim
10944b87bb0SJonathan Kim /* update process/device/queue exception status, write to descriptor
11044b87bb0SJonathan Kim * only if exception_status is enabled.
11144b87bb0SJonathan Kim */
kfd_dbg_ev_raise(uint64_t event_mask,struct kfd_process * process,struct kfd_node * dev,unsigned int source_id,bool use_worker,void * exception_data,size_t exception_data_size)11244b87bb0SJonathan Kim bool kfd_dbg_ev_raise(uint64_t event_mask,
11344b87bb0SJonathan Kim struct kfd_process *process, struct kfd_node *dev,
11444b87bb0SJonathan Kim unsigned int source_id, bool use_worker,
11544b87bb0SJonathan Kim void *exception_data, size_t exception_data_size)
11644b87bb0SJonathan Kim {
11744b87bb0SJonathan Kim struct process_queue_manager *pqm;
11844b87bb0SJonathan Kim struct process_queue_node *pqn;
11944b87bb0SJonathan Kim int i;
12044b87bb0SJonathan Kim static const char write_data = '.';
12144b87bb0SJonathan Kim loff_t pos = 0;
12244b87bb0SJonathan Kim bool is_subscribed = true;
12344b87bb0SJonathan Kim
12444b87bb0SJonathan Kim if (!(process && process->debug_trap_enabled))
12544b87bb0SJonathan Kim return false;
12644b87bb0SJonathan Kim
12744b87bb0SJonathan Kim mutex_lock(&process->event_mutex);
12844b87bb0SJonathan Kim
12944b87bb0SJonathan Kim if (event_mask & KFD_EC_MASK_DEVICE) {
13044b87bb0SJonathan Kim for (i = 0; i < process->n_pdds; i++) {
13144b87bb0SJonathan Kim struct kfd_process_device *pdd = process->pdds[i];
13244b87bb0SJonathan Kim
13344b87bb0SJonathan Kim if (pdd->dev != dev)
13444b87bb0SJonathan Kim continue;
13544b87bb0SJonathan Kim
13644b87bb0SJonathan Kim pdd->exception_status |= event_mask & KFD_EC_MASK_DEVICE;
13744b87bb0SJonathan Kim
13844b87bb0SJonathan Kim if (event_mask & KFD_EC_MASK(EC_DEVICE_MEMORY_VIOLATION)) {
13944b87bb0SJonathan Kim if (!pdd->vm_fault_exc_data) {
14044b87bb0SJonathan Kim pdd->vm_fault_exc_data = kmemdup(
14144b87bb0SJonathan Kim exception_data,
14244b87bb0SJonathan Kim exception_data_size,
14344b87bb0SJonathan Kim GFP_KERNEL);
14444b87bb0SJonathan Kim if (!pdd->vm_fault_exc_data)
14544b87bb0SJonathan Kim pr_debug("Failed to allocate exception data memory");
14644b87bb0SJonathan Kim } else {
14744b87bb0SJonathan Kim pr_debug("Debugger exception data not saved\n");
14844b87bb0SJonathan Kim print_hex_dump_bytes("exception data: ",
14944b87bb0SJonathan Kim DUMP_PREFIX_OFFSET,
15044b87bb0SJonathan Kim exception_data,
15144b87bb0SJonathan Kim exception_data_size);
15244b87bb0SJonathan Kim }
15344b87bb0SJonathan Kim }
15444b87bb0SJonathan Kim break;
15544b87bb0SJonathan Kim }
15644b87bb0SJonathan Kim } else if (event_mask & KFD_EC_MASK_PROCESS) {
15744b87bb0SJonathan Kim process->exception_status |= event_mask & KFD_EC_MASK_PROCESS;
15844b87bb0SJonathan Kim } else {
15944b87bb0SJonathan Kim pqm = &process->pqm;
16044b87bb0SJonathan Kim list_for_each_entry(pqn, &pqm->queues,
16144b87bb0SJonathan Kim process_queue_list) {
16244b87bb0SJonathan Kim int target_id;
16344b87bb0SJonathan Kim
16444b87bb0SJonathan Kim if (!pqn->q)
16544b87bb0SJonathan Kim continue;
16644b87bb0SJonathan Kim
16744b87bb0SJonathan Kim target_id = event_mask & KFD_EC_MASK(EC_QUEUE_NEW) ?
16844b87bb0SJonathan Kim pqn->q->properties.queue_id :
16944b87bb0SJonathan Kim pqn->q->doorbell_id;
17044b87bb0SJonathan Kim
17144b87bb0SJonathan Kim if (pqn->q->device != dev || target_id != source_id)
17244b87bb0SJonathan Kim continue;
17344b87bb0SJonathan Kim
17444b87bb0SJonathan Kim pqn->q->properties.exception_status |= event_mask;
17544b87bb0SJonathan Kim break;
17644b87bb0SJonathan Kim }
17744b87bb0SJonathan Kim }
17844b87bb0SJonathan Kim
17944b87bb0SJonathan Kim if (process->exception_enable_mask & event_mask) {
18044b87bb0SJonathan Kim if (use_worker)
18144b87bb0SJonathan Kim schedule_work(&process->debug_event_workarea);
18244b87bb0SJonathan Kim else
18344b87bb0SJonathan Kim kernel_write(process->dbg_ev_file,
18444b87bb0SJonathan Kim &write_data,
18544b87bb0SJonathan Kim 1,
18644b87bb0SJonathan Kim &pos);
18744b87bb0SJonathan Kim } else {
18844b87bb0SJonathan Kim is_subscribed = false;
18944b87bb0SJonathan Kim }
19044b87bb0SJonathan Kim
19144b87bb0SJonathan Kim mutex_unlock(&process->event_mutex);
19244b87bb0SJonathan Kim
19344b87bb0SJonathan Kim return is_subscribed;
19444b87bb0SJonathan Kim }
19544b87bb0SJonathan Kim
19612fb1ad7SJonathan Kim /* set pending event queue entry from ring entry */
kfd_set_dbg_ev_from_interrupt(struct kfd_node * dev,unsigned int pasid,uint32_t doorbell_id,uint64_t trap_mask,void * exception_data,size_t exception_data_size)19712fb1ad7SJonathan Kim bool kfd_set_dbg_ev_from_interrupt(struct kfd_node *dev,
19812fb1ad7SJonathan Kim unsigned int pasid,
19912fb1ad7SJonathan Kim uint32_t doorbell_id,
20012fb1ad7SJonathan Kim uint64_t trap_mask,
20112fb1ad7SJonathan Kim void *exception_data,
20212fb1ad7SJonathan Kim size_t exception_data_size)
20312fb1ad7SJonathan Kim {
20412fb1ad7SJonathan Kim struct kfd_process *p;
20512fb1ad7SJonathan Kim bool signaled_to_debugger_or_runtime = false;
20612fb1ad7SJonathan Kim
20712fb1ad7SJonathan Kim p = kfd_lookup_process_by_pasid(pasid);
20812fb1ad7SJonathan Kim
20912fb1ad7SJonathan Kim if (!p)
21012fb1ad7SJonathan Kim return false;
21112fb1ad7SJonathan Kim
21212fb1ad7SJonathan Kim if (!kfd_dbg_ev_raise(trap_mask, p, dev, doorbell_id, true,
21312fb1ad7SJonathan Kim exception_data, exception_data_size)) {
21412fb1ad7SJonathan Kim struct process_queue_manager *pqm;
21512fb1ad7SJonathan Kim struct process_queue_node *pqn;
21612fb1ad7SJonathan Kim
21712fb1ad7SJonathan Kim if (!!(trap_mask & KFD_EC_MASK_QUEUE) &&
21812fb1ad7SJonathan Kim p->runtime_info.runtime_state == DEBUG_RUNTIME_STATE_ENABLED) {
21912fb1ad7SJonathan Kim mutex_lock(&p->mutex);
22012fb1ad7SJonathan Kim
22112fb1ad7SJonathan Kim pqm = &p->pqm;
22212fb1ad7SJonathan Kim list_for_each_entry(pqn, &pqm->queues,
22312fb1ad7SJonathan Kim process_queue_list) {
22412fb1ad7SJonathan Kim
22512fb1ad7SJonathan Kim if (!(pqn->q && pqn->q->device == dev &&
22612fb1ad7SJonathan Kim pqn->q->doorbell_id == doorbell_id))
22712fb1ad7SJonathan Kim continue;
22812fb1ad7SJonathan Kim
22912fb1ad7SJonathan Kim kfd_send_exception_to_runtime(p, pqn->q->properties.queue_id,
23012fb1ad7SJonathan Kim trap_mask);
23112fb1ad7SJonathan Kim
23212fb1ad7SJonathan Kim signaled_to_debugger_or_runtime = true;
23312fb1ad7SJonathan Kim
23412fb1ad7SJonathan Kim break;
23512fb1ad7SJonathan Kim }
23612fb1ad7SJonathan Kim
23712fb1ad7SJonathan Kim mutex_unlock(&p->mutex);
23812fb1ad7SJonathan Kim } else if (trap_mask & KFD_EC_MASK(EC_DEVICE_MEMORY_VIOLATION)) {
23912fb1ad7SJonathan Kim kfd_dqm_evict_pasid(dev->dqm, p->pasid);
24012fb1ad7SJonathan Kim kfd_signal_vm_fault_event(dev, p->pasid, NULL,
24112fb1ad7SJonathan Kim exception_data);
24212fb1ad7SJonathan Kim
24312fb1ad7SJonathan Kim signaled_to_debugger_or_runtime = true;
24412fb1ad7SJonathan Kim }
24512fb1ad7SJonathan Kim } else {
24612fb1ad7SJonathan Kim signaled_to_debugger_or_runtime = true;
24712fb1ad7SJonathan Kim }
24812fb1ad7SJonathan Kim
24912fb1ad7SJonathan Kim kfd_unref_process(p);
25012fb1ad7SJonathan Kim
25112fb1ad7SJonathan Kim return signaled_to_debugger_or_runtime;
25212fb1ad7SJonathan Kim }
25312fb1ad7SJonathan Kim
kfd_dbg_send_exception_to_runtime(struct kfd_process * p,unsigned int dev_id,unsigned int queue_id,uint64_t error_reason)254c2d2588cSJonathan Kim int kfd_dbg_send_exception_to_runtime(struct kfd_process *p,
255c2d2588cSJonathan Kim unsigned int dev_id,
256c2d2588cSJonathan Kim unsigned int queue_id,
257c2d2588cSJonathan Kim uint64_t error_reason)
258c2d2588cSJonathan Kim {
259c2d2588cSJonathan Kim if (error_reason & KFD_EC_MASK(EC_DEVICE_MEMORY_VIOLATION)) {
260c2d2588cSJonathan Kim struct kfd_process_device *pdd = NULL;
261c2d2588cSJonathan Kim struct kfd_hsa_memory_exception_data *data;
262c2d2588cSJonathan Kim int i;
263c2d2588cSJonathan Kim
264c2d2588cSJonathan Kim for (i = 0; i < p->n_pdds; i++) {
265c2d2588cSJonathan Kim if (p->pdds[i]->dev->id == dev_id) {
266c2d2588cSJonathan Kim pdd = p->pdds[i];
267c2d2588cSJonathan Kim break;
268c2d2588cSJonathan Kim }
269c2d2588cSJonathan Kim }
270c2d2588cSJonathan Kim
271c2d2588cSJonathan Kim if (!pdd)
272c2d2588cSJonathan Kim return -ENODEV;
273c2d2588cSJonathan Kim
274c2d2588cSJonathan Kim data = (struct kfd_hsa_memory_exception_data *)
275c2d2588cSJonathan Kim pdd->vm_fault_exc_data;
276c2d2588cSJonathan Kim
277c2d2588cSJonathan Kim kfd_dqm_evict_pasid(pdd->dev->dqm, p->pasid);
278c2d2588cSJonathan Kim kfd_signal_vm_fault_event(pdd->dev, p->pasid, NULL, data);
279c2d2588cSJonathan Kim error_reason &= ~KFD_EC_MASK(EC_DEVICE_MEMORY_VIOLATION);
280c2d2588cSJonathan Kim }
281c2d2588cSJonathan Kim
282c2d2588cSJonathan Kim if (error_reason & (KFD_EC_MASK(EC_PROCESS_RUNTIME))) {
283c2d2588cSJonathan Kim /*
284c2d2588cSJonathan Kim * block should only happen after the debugger receives runtime
285c2d2588cSJonathan Kim * enable notice.
286c2d2588cSJonathan Kim */
287c2d2588cSJonathan Kim up(&p->runtime_enable_sema);
288c2d2588cSJonathan Kim error_reason &= ~KFD_EC_MASK(EC_PROCESS_RUNTIME);
289c2d2588cSJonathan Kim }
290c2d2588cSJonathan Kim
291c2d2588cSJonathan Kim if (error_reason)
292c2d2588cSJonathan Kim return kfd_send_exception_to_runtime(p, queue_id, error_reason);
293c2d2588cSJonathan Kim
294c2d2588cSJonathan Kim return 0;
295c2d2588cSJonathan Kim }
296c2d2588cSJonathan Kim
kfd_dbg_set_queue_workaround(struct queue * q,bool enable)29769a8c3aeSJonathan Kim static int kfd_dbg_set_queue_workaround(struct queue *q, bool enable)
29869a8c3aeSJonathan Kim {
29969a8c3aeSJonathan Kim struct mqd_update_info minfo = {0};
30069a8c3aeSJonathan Kim int err;
30169a8c3aeSJonathan Kim
30269a8c3aeSJonathan Kim if (!q)
30369a8c3aeSJonathan Kim return 0;
30469a8c3aeSJonathan Kim
305cef600e1SJonathan Kim if (!kfd_dbg_has_cwsr_workaround(q->device))
30669a8c3aeSJonathan Kim return 0;
30769a8c3aeSJonathan Kim
30869a8c3aeSJonathan Kim if (enable && q->properties.is_user_cu_masked)
30969a8c3aeSJonathan Kim return -EBUSY;
31069a8c3aeSJonathan Kim
31169a8c3aeSJonathan Kim minfo.update_flag = enable ? UPDATE_FLAG_DBG_WA_ENABLE : UPDATE_FLAG_DBG_WA_DISABLE;
31269a8c3aeSJonathan Kim
31369a8c3aeSJonathan Kim q->properties.is_dbg_wa = enable;
31469a8c3aeSJonathan Kim err = q->device->dqm->ops.update_queue(q->device->dqm, q, &minfo);
31569a8c3aeSJonathan Kim if (err)
31669a8c3aeSJonathan Kim q->properties.is_dbg_wa = false;
31769a8c3aeSJonathan Kim
31869a8c3aeSJonathan Kim return err;
31969a8c3aeSJonathan Kim }
32069a8c3aeSJonathan Kim
kfd_dbg_set_workaround(struct kfd_process * target,bool enable)32169a8c3aeSJonathan Kim static int kfd_dbg_set_workaround(struct kfd_process *target, bool enable)
32269a8c3aeSJonathan Kim {
32369a8c3aeSJonathan Kim struct process_queue_manager *pqm = &target->pqm;
32469a8c3aeSJonathan Kim struct process_queue_node *pqn;
32569a8c3aeSJonathan Kim int r = 0;
32669a8c3aeSJonathan Kim
32769a8c3aeSJonathan Kim list_for_each_entry(pqn, &pqm->queues, process_queue_list) {
32869a8c3aeSJonathan Kim r = kfd_dbg_set_queue_workaround(pqn->q, enable);
32969a8c3aeSJonathan Kim if (enable && r)
33069a8c3aeSJonathan Kim goto unwind;
33169a8c3aeSJonathan Kim }
33269a8c3aeSJonathan Kim
33369a8c3aeSJonathan Kim return 0;
33469a8c3aeSJonathan Kim
33569a8c3aeSJonathan Kim unwind:
33669a8c3aeSJonathan Kim list_for_each_entry(pqn, &pqm->queues, process_queue_list)
33769a8c3aeSJonathan Kim kfd_dbg_set_queue_workaround(pqn->q, false);
33869a8c3aeSJonathan Kim
33969a8c3aeSJonathan Kim if (enable)
34069a8c3aeSJonathan Kim target->runtime_info.runtime_state = r == -EBUSY ?
34169a8c3aeSJonathan Kim DEBUG_RUNTIME_STATE_ENABLED_BUSY :
34269a8c3aeSJonathan Kim DEBUG_RUNTIME_STATE_ENABLED_ERROR;
34369a8c3aeSJonathan Kim
34469a8c3aeSJonathan Kim return r;
34569a8c3aeSJonathan Kim }
34669a8c3aeSJonathan Kim
kfd_dbg_set_mes_debug_mode(struct kfd_process_device * pdd,bool sq_trap_en)347*fc7f1d96SJonathan Kim int kfd_dbg_set_mes_debug_mode(struct kfd_process_device *pdd, bool sq_trap_en)
34821889582SJonathan Kim {
34921889582SJonathan Kim uint32_t spi_dbg_cntl = pdd->spi_dbg_override | pdd->spi_dbg_launch_mode;
35021889582SJonathan Kim uint32_t flags = pdd->process->dbg_flags;
35121889582SJonathan Kim
35221889582SJonathan Kim if (!kfd_dbg_is_per_vmid_supported(pdd->dev))
35321889582SJonathan Kim return 0;
35421889582SJonathan Kim
35521889582SJonathan Kim return amdgpu_mes_set_shader_debugger(pdd->dev->adev, pdd->proc_ctx_gpu_addr, spi_dbg_cntl,
35609d49e14SJonathan Kim pdd->watch_points, flags, sq_trap_en);
35721889582SJonathan Kim }
35821889582SJonathan Kim
359e0f85f46SJonathan Kim #define KFD_DEBUGGER_INVALID_WATCH_POINT_ID -1
kfd_dbg_get_dev_watch_id(struct kfd_process_device * pdd,int * watch_id)360e0f85f46SJonathan Kim static int kfd_dbg_get_dev_watch_id(struct kfd_process_device *pdd, int *watch_id)
361e0f85f46SJonathan Kim {
362e0f85f46SJonathan Kim int i;
363e0f85f46SJonathan Kim
364e0f85f46SJonathan Kim *watch_id = KFD_DEBUGGER_INVALID_WATCH_POINT_ID;
365e0f85f46SJonathan Kim
366e0f85f46SJonathan Kim spin_lock(&pdd->dev->kfd->watch_points_lock);
367e0f85f46SJonathan Kim
368e0f85f46SJonathan Kim for (i = 0; i < MAX_WATCH_ADDRESSES; i++) {
369e0f85f46SJonathan Kim /* device watchpoint in use so skip */
370e0f85f46SJonathan Kim if ((pdd->dev->kfd->alloc_watch_ids >> i) & 0x1)
371e0f85f46SJonathan Kim continue;
372e0f85f46SJonathan Kim
373e0f85f46SJonathan Kim pdd->alloc_watch_ids |= 0x1 << i;
374e0f85f46SJonathan Kim pdd->dev->kfd->alloc_watch_ids |= 0x1 << i;
375e0f85f46SJonathan Kim *watch_id = i;
376e0f85f46SJonathan Kim spin_unlock(&pdd->dev->kfd->watch_points_lock);
377e0f85f46SJonathan Kim return 0;
378e0f85f46SJonathan Kim }
379e0f85f46SJonathan Kim
380e0f85f46SJonathan Kim spin_unlock(&pdd->dev->kfd->watch_points_lock);
381e0f85f46SJonathan Kim
382e0f85f46SJonathan Kim return -ENOMEM;
383e0f85f46SJonathan Kim }
384e0f85f46SJonathan Kim
kfd_dbg_clear_dev_watch_id(struct kfd_process_device * pdd,int watch_id)385e0f85f46SJonathan Kim static void kfd_dbg_clear_dev_watch_id(struct kfd_process_device *pdd, int watch_id)
386e0f85f46SJonathan Kim {
387e0f85f46SJonathan Kim spin_lock(&pdd->dev->kfd->watch_points_lock);
388e0f85f46SJonathan Kim
389e0f85f46SJonathan Kim /* process owns device watch point so safe to clear */
390e0f85f46SJonathan Kim if ((pdd->alloc_watch_ids >> watch_id) & 0x1) {
391e0f85f46SJonathan Kim pdd->alloc_watch_ids &= ~(0x1 << watch_id);
392e0f85f46SJonathan Kim pdd->dev->kfd->alloc_watch_ids &= ~(0x1 << watch_id);
393e0f85f46SJonathan Kim }
394e0f85f46SJonathan Kim
395e0f85f46SJonathan Kim spin_unlock(&pdd->dev->kfd->watch_points_lock);
396e0f85f46SJonathan Kim }
397e0f85f46SJonathan Kim
kfd_dbg_owns_dev_watch_id(struct kfd_process_device * pdd,int watch_id)398e0f85f46SJonathan Kim static bool kfd_dbg_owns_dev_watch_id(struct kfd_process_device *pdd, int watch_id)
399e0f85f46SJonathan Kim {
400e0f85f46SJonathan Kim bool owns_watch_id = false;
401e0f85f46SJonathan Kim
402e0f85f46SJonathan Kim spin_lock(&pdd->dev->kfd->watch_points_lock);
403e0f85f46SJonathan Kim owns_watch_id = watch_id < MAX_WATCH_ADDRESSES &&
404e0f85f46SJonathan Kim ((pdd->alloc_watch_ids >> watch_id) & 0x1);
405e0f85f46SJonathan Kim
406e0f85f46SJonathan Kim spin_unlock(&pdd->dev->kfd->watch_points_lock);
407e0f85f46SJonathan Kim
408e0f85f46SJonathan Kim return owns_watch_id;
409e0f85f46SJonathan Kim }
410e0f85f46SJonathan Kim
kfd_dbg_trap_clear_dev_address_watch(struct kfd_process_device * pdd,uint32_t watch_id)411e0f85f46SJonathan Kim int kfd_dbg_trap_clear_dev_address_watch(struct kfd_process_device *pdd,
412e0f85f46SJonathan Kim uint32_t watch_id)
413e0f85f46SJonathan Kim {
414e0f85f46SJonathan Kim int r;
415e0f85f46SJonathan Kim
416e0f85f46SJonathan Kim if (!kfd_dbg_owns_dev_watch_id(pdd, watch_id))
417e0f85f46SJonathan Kim return -EINVAL;
418e0f85f46SJonathan Kim
419e0f85f46SJonathan Kim if (!pdd->dev->kfd->shared_resources.enable_mes) {
420e0f85f46SJonathan Kim r = debug_lock_and_unmap(pdd->dev->dqm);
421e0f85f46SJonathan Kim if (r)
422e0f85f46SJonathan Kim return r;
423e0f85f46SJonathan Kim }
424e0f85f46SJonathan Kim
425e0f85f46SJonathan Kim amdgpu_gfx_off_ctrl(pdd->dev->adev, false);
426e0f85f46SJonathan Kim pdd->watch_points[watch_id] = pdd->dev->kfd2kgd->clear_address_watch(
427e0f85f46SJonathan Kim pdd->dev->adev,
428e0f85f46SJonathan Kim watch_id);
429e0f85f46SJonathan Kim amdgpu_gfx_off_ctrl(pdd->dev->adev, true);
430e0f85f46SJonathan Kim
431e0f85f46SJonathan Kim if (!pdd->dev->kfd->shared_resources.enable_mes)
432e0f85f46SJonathan Kim r = debug_map_and_unlock(pdd->dev->dqm);
433e0f85f46SJonathan Kim else
434*fc7f1d96SJonathan Kim r = kfd_dbg_set_mes_debug_mode(pdd, true);
435e0f85f46SJonathan Kim
436e0f85f46SJonathan Kim kfd_dbg_clear_dev_watch_id(pdd, watch_id);
437e0f85f46SJonathan Kim
438e0f85f46SJonathan Kim return r;
439e0f85f46SJonathan Kim }
440e0f85f46SJonathan Kim
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)441e0f85f46SJonathan Kim int kfd_dbg_trap_set_dev_address_watch(struct kfd_process_device *pdd,
442e0f85f46SJonathan Kim uint64_t watch_address,
443e0f85f46SJonathan Kim uint32_t watch_address_mask,
444e0f85f46SJonathan Kim uint32_t *watch_id,
445e0f85f46SJonathan Kim uint32_t watch_mode)
446e0f85f46SJonathan Kim {
4477a93cc57SJonathan Kim int xcc_id, r = kfd_dbg_get_dev_watch_id(pdd, watch_id);
4487a93cc57SJonathan Kim uint32_t xcc_mask = pdd->dev->xcc_mask;
449e0f85f46SJonathan Kim
450e0f85f46SJonathan Kim if (r)
451e0f85f46SJonathan Kim return r;
452e0f85f46SJonathan Kim
453e0f85f46SJonathan Kim if (!pdd->dev->kfd->shared_resources.enable_mes) {
454e0f85f46SJonathan Kim r = debug_lock_and_unmap(pdd->dev->dqm);
455e0f85f46SJonathan Kim if (r) {
456e0f85f46SJonathan Kim kfd_dbg_clear_dev_watch_id(pdd, *watch_id);
457e0f85f46SJonathan Kim return r;
458e0f85f46SJonathan Kim }
459e0f85f46SJonathan Kim }
460e0f85f46SJonathan Kim
461e0f85f46SJonathan Kim amdgpu_gfx_off_ctrl(pdd->dev->adev, false);
4627a93cc57SJonathan Kim for_each_inst(xcc_id, xcc_mask)
463e0f85f46SJonathan Kim pdd->watch_points[*watch_id] = pdd->dev->kfd2kgd->set_address_watch(
464e0f85f46SJonathan Kim pdd->dev->adev,
465e0f85f46SJonathan Kim watch_address,
466e0f85f46SJonathan Kim watch_address_mask,
467e0f85f46SJonathan Kim *watch_id,
468e0f85f46SJonathan Kim watch_mode,
469036e348fSEric Huang pdd->dev->vm_info.last_vmid_kfd,
4707a93cc57SJonathan Kim xcc_id);
471e0f85f46SJonathan Kim amdgpu_gfx_off_ctrl(pdd->dev->adev, true);
472e0f85f46SJonathan Kim
473e0f85f46SJonathan Kim if (!pdd->dev->kfd->shared_resources.enable_mes)
474e0f85f46SJonathan Kim r = debug_map_and_unlock(pdd->dev->dqm);
475e0f85f46SJonathan Kim else
476*fc7f1d96SJonathan Kim r = kfd_dbg_set_mes_debug_mode(pdd, true);
477e0f85f46SJonathan Kim
478e0f85f46SJonathan Kim /* HWS is broken so no point in HW rollback but release the watchpoint anyways */
479e0f85f46SJonathan Kim if (r)
480e0f85f46SJonathan Kim kfd_dbg_clear_dev_watch_id(pdd, *watch_id);
481e0f85f46SJonathan Kim
482e0f85f46SJonathan Kim return 0;
483e0f85f46SJonathan Kim }
484e0f85f46SJonathan Kim
kfd_dbg_clear_process_address_watch(struct kfd_process * target)485e0f85f46SJonathan Kim static void kfd_dbg_clear_process_address_watch(struct kfd_process *target)
486e0f85f46SJonathan Kim {
487e0f85f46SJonathan Kim int i, j;
488e0f85f46SJonathan Kim
489e0f85f46SJonathan Kim for (i = 0; i < target->n_pdds; i++)
490e0f85f46SJonathan Kim for (j = 0; j < MAX_WATCH_ADDRESSES; j++)
491e0f85f46SJonathan Kim kfd_dbg_trap_clear_dev_address_watch(target->pdds[i], j);
492e0f85f46SJonathan Kim }
493e0f85f46SJonathan Kim
kfd_dbg_trap_set_flags(struct kfd_process * target,uint32_t * flags)494103d5f08SJonathan Kim int kfd_dbg_trap_set_flags(struct kfd_process *target, uint32_t *flags)
495103d5f08SJonathan Kim {
496103d5f08SJonathan Kim uint32_t prev_flags = target->dbg_flags;
497103d5f08SJonathan Kim int i, r = 0, rewind_count = 0;
498103d5f08SJonathan Kim
499103d5f08SJonathan Kim for (i = 0; i < target->n_pdds; i++) {
500103d5f08SJonathan Kim if (!kfd_dbg_is_per_vmid_supported(target->pdds[i]->dev) &&
501103d5f08SJonathan Kim (*flags & KFD_DBG_TRAP_FLAG_SINGLE_MEM_OP)) {
502103d5f08SJonathan Kim *flags = prev_flags;
503103d5f08SJonathan Kim return -EACCES;
504103d5f08SJonathan Kim }
505103d5f08SJonathan Kim }
506103d5f08SJonathan Kim
507103d5f08SJonathan Kim target->dbg_flags = *flags & KFD_DBG_TRAP_FLAG_SINGLE_MEM_OP;
508103d5f08SJonathan Kim *flags = prev_flags;
509103d5f08SJonathan Kim for (i = 0; i < target->n_pdds; i++) {
510103d5f08SJonathan Kim struct kfd_process_device *pdd = target->pdds[i];
511103d5f08SJonathan Kim
512103d5f08SJonathan Kim if (!kfd_dbg_is_per_vmid_supported(pdd->dev))
513103d5f08SJonathan Kim continue;
514103d5f08SJonathan Kim
515103d5f08SJonathan Kim if (!pdd->dev->kfd->shared_resources.enable_mes)
516103d5f08SJonathan Kim r = debug_refresh_runlist(pdd->dev->dqm);
517103d5f08SJonathan Kim else
518*fc7f1d96SJonathan Kim r = kfd_dbg_set_mes_debug_mode(pdd, true);
519103d5f08SJonathan Kim
520103d5f08SJonathan Kim if (r) {
521103d5f08SJonathan Kim target->dbg_flags = prev_flags;
522103d5f08SJonathan Kim break;
523103d5f08SJonathan Kim }
524103d5f08SJonathan Kim
525103d5f08SJonathan Kim rewind_count++;
526103d5f08SJonathan Kim }
527103d5f08SJonathan Kim
528103d5f08SJonathan Kim /* Rewind flags */
529103d5f08SJonathan Kim if (r) {
530103d5f08SJonathan Kim target->dbg_flags = prev_flags;
531103d5f08SJonathan Kim
532103d5f08SJonathan Kim for (i = 0; i < rewind_count; i++) {
533103d5f08SJonathan Kim struct kfd_process_device *pdd = target->pdds[i];
534103d5f08SJonathan Kim
535103d5f08SJonathan Kim if (!kfd_dbg_is_per_vmid_supported(pdd->dev))
536103d5f08SJonathan Kim continue;
537103d5f08SJonathan Kim
538103d5f08SJonathan Kim if (!pdd->dev->kfd->shared_resources.enable_mes)
539103d5f08SJonathan Kim debug_refresh_runlist(pdd->dev->dqm);
540103d5f08SJonathan Kim else
541*fc7f1d96SJonathan Kim kfd_dbg_set_mes_debug_mode(pdd, true);
542103d5f08SJonathan Kim }
543103d5f08SJonathan Kim }
544103d5f08SJonathan Kim
545103d5f08SJonathan Kim return r;
546103d5f08SJonathan Kim }
547e0f85f46SJonathan Kim
54821889582SJonathan Kim /* kfd_dbg_trap_deactivate:
54921889582SJonathan Kim * target: target process
55021889582SJonathan Kim * unwind: If this is unwinding a failed kfd_dbg_trap_enable()
55121889582SJonathan Kim * unwind_count:
55221889582SJonathan Kim * If unwind == true, how far down the pdd list we need
55321889582SJonathan Kim * to unwind
55421889582SJonathan Kim * else: ignored
55521889582SJonathan Kim */
kfd_dbg_trap_deactivate(struct kfd_process * target,bool unwind,int unwind_count)556455227c4SJonathan Kim void kfd_dbg_trap_deactivate(struct kfd_process *target, bool unwind, int unwind_count)
55721889582SJonathan Kim {
55821889582SJonathan Kim int i;
55921889582SJonathan Kim
560aea1b473SJonathan Kim if (!unwind) {
561103d5f08SJonathan Kim uint32_t flags = 0;
56209d49e14SJonathan Kim int resume_count = resume_queues(target, 0, NULL);
56309d49e14SJonathan Kim
56409d49e14SJonathan Kim if (resume_count)
56509d49e14SJonathan Kim pr_debug("Resumed %d queues\n", resume_count);
566103d5f08SJonathan Kim
56744b87bb0SJonathan Kim cancel_work_sync(&target->debug_event_workarea);
568e0f85f46SJonathan Kim kfd_dbg_clear_process_address_watch(target);
569aea1b473SJonathan Kim kfd_dbg_trap_set_wave_launch_mode(target, 0);
570103d5f08SJonathan Kim
571103d5f08SJonathan Kim kfd_dbg_trap_set_flags(target, &flags);
572aea1b473SJonathan Kim }
57344b87bb0SJonathan Kim
57421889582SJonathan Kim for (i = 0; i < target->n_pdds; i++) {
57521889582SJonathan Kim struct kfd_process_device *pdd = target->pdds[i];
57621889582SJonathan Kim
57721889582SJonathan Kim /* If this is an unwind, and we have unwound the required
57821889582SJonathan Kim * enable calls on the pdd list, we need to stop now
57921889582SJonathan Kim * otherwise we may mess up another debugger session.
58021889582SJonathan Kim */
58121889582SJonathan Kim if (unwind && i == unwind_count)
58221889582SJonathan Kim break;
58321889582SJonathan Kim
58450cff45eSJay Cornwall kfd_process_set_trap_debug_flag(&pdd->qpd, false);
58550cff45eSJay Cornwall
58621889582SJonathan Kim /* GFX off is already disabled by debug activate if not RLC restore supported. */
58721889582SJonathan Kim if (kfd_dbg_is_rlc_restore_supported(pdd->dev))
58821889582SJonathan Kim amdgpu_gfx_off_ctrl(pdd->dev->adev, false);
58921889582SJonathan Kim pdd->spi_dbg_override =
59021889582SJonathan Kim pdd->dev->kfd2kgd->disable_debug_trap(
59121889582SJonathan Kim pdd->dev->adev,
59221889582SJonathan Kim target->runtime_info.ttmp_setup,
59321889582SJonathan Kim pdd->dev->vm_info.last_vmid_kfd);
59421889582SJonathan Kim amdgpu_gfx_off_ctrl(pdd->dev->adev, true);
59521889582SJonathan Kim
59621889582SJonathan Kim if (!kfd_dbg_is_per_vmid_supported(pdd->dev) &&
59721889582SJonathan Kim release_debug_trap_vmid(pdd->dev->dqm, &pdd->qpd))
59821889582SJonathan Kim pr_err("Failed to release debug vmid on [%i]\n", pdd->dev->id);
59921889582SJonathan Kim
60021889582SJonathan Kim if (!pdd->dev->kfd->shared_resources.enable_mes)
60121889582SJonathan Kim debug_refresh_runlist(pdd->dev->dqm);
60221889582SJonathan Kim else
603*fc7f1d96SJonathan Kim kfd_dbg_set_mes_debug_mode(pdd, !kfd_dbg_has_cwsr_workaround(pdd->dev));
60421889582SJonathan Kim }
60569a8c3aeSJonathan Kim
60669a8c3aeSJonathan Kim kfd_dbg_set_workaround(target, false);
60721889582SJonathan Kim }
60821889582SJonathan Kim
kfd_dbg_clean_exception_status(struct kfd_process * target)60912fb1ad7SJonathan Kim static void kfd_dbg_clean_exception_status(struct kfd_process *target)
61012fb1ad7SJonathan Kim {
61112fb1ad7SJonathan Kim struct process_queue_manager *pqm;
61212fb1ad7SJonathan Kim struct process_queue_node *pqn;
61312fb1ad7SJonathan Kim int i;
61412fb1ad7SJonathan Kim
61512fb1ad7SJonathan Kim for (i = 0; i < target->n_pdds; i++) {
61612fb1ad7SJonathan Kim struct kfd_process_device *pdd = target->pdds[i];
61712fb1ad7SJonathan Kim
61812fb1ad7SJonathan Kim kfd_process_drain_interrupts(pdd);
61912fb1ad7SJonathan Kim
62012fb1ad7SJonathan Kim pdd->exception_status = 0;
62112fb1ad7SJonathan Kim }
62212fb1ad7SJonathan Kim
62312fb1ad7SJonathan Kim pqm = &target->pqm;
62412fb1ad7SJonathan Kim list_for_each_entry(pqn, &pqm->queues, process_queue_list) {
62512fb1ad7SJonathan Kim if (!pqn->q)
62612fb1ad7SJonathan Kim continue;
62712fb1ad7SJonathan Kim
62812fb1ad7SJonathan Kim pqn->q->properties.exception_status = 0;
62912fb1ad7SJonathan Kim }
63012fb1ad7SJonathan Kim
63112fb1ad7SJonathan Kim target->exception_status = 0;
63212fb1ad7SJonathan Kim }
63312fb1ad7SJonathan Kim
kfd_dbg_trap_disable(struct kfd_process * target)6340ab2d753SJonathan Kim int kfd_dbg_trap_disable(struct kfd_process *target)
6350ab2d753SJonathan Kim {
6360ab2d753SJonathan Kim if (!target->debug_trap_enabled)
6370ab2d753SJonathan Kim return 0;
6380ab2d753SJonathan Kim
63921889582SJonathan Kim /*
64021889582SJonathan Kim * Defer deactivation to runtime if runtime not enabled otherwise reset
64121889582SJonathan Kim * attached running target runtime state to enable for re-attach.
64221889582SJonathan Kim */
64321889582SJonathan Kim if (target->runtime_info.runtime_state == DEBUG_RUNTIME_STATE_ENABLED)
64421889582SJonathan Kim kfd_dbg_trap_deactivate(target, false, 0);
64521889582SJonathan Kim else if (target->runtime_info.runtime_state != DEBUG_RUNTIME_STATE_DISABLED)
64621889582SJonathan Kim target->runtime_info.runtime_state = DEBUG_RUNTIME_STATE_ENABLED;
64721889582SJonathan Kim
6480ab2d753SJonathan Kim fput(target->dbg_ev_file);
6490ab2d753SJonathan Kim target->dbg_ev_file = NULL;
6500ab2d753SJonathan Kim
6510ab2d753SJonathan Kim if (target->debugger_process) {
6520ab2d753SJonathan Kim atomic_dec(&target->debugger_process->debugged_process_count);
6530ab2d753SJonathan Kim target->debugger_process = NULL;
6540ab2d753SJonathan Kim }
6550ab2d753SJonathan Kim
6560ab2d753SJonathan Kim target->debug_trap_enabled = false;
65712fb1ad7SJonathan Kim kfd_dbg_clean_exception_status(target);
6580ab2d753SJonathan Kim kfd_unref_process(target);
6590ab2d753SJonathan Kim
6600ab2d753SJonathan Kim return 0;
6610ab2d753SJonathan Kim }
6620ab2d753SJonathan Kim
kfd_dbg_trap_activate(struct kfd_process * target)663455227c4SJonathan Kim int kfd_dbg_trap_activate(struct kfd_process *target)
66421889582SJonathan Kim {
66521889582SJonathan Kim int i, r = 0;
66621889582SJonathan Kim
66769a8c3aeSJonathan Kim r = kfd_dbg_set_workaround(target, true);
66869a8c3aeSJonathan Kim if (r)
66969a8c3aeSJonathan Kim return r;
67069a8c3aeSJonathan Kim
67121889582SJonathan Kim for (i = 0; i < target->n_pdds; i++) {
67221889582SJonathan Kim struct kfd_process_device *pdd = target->pdds[i];
67321889582SJonathan Kim
67421889582SJonathan Kim if (!kfd_dbg_is_per_vmid_supported(pdd->dev)) {
67521889582SJonathan Kim r = reserve_debug_trap_vmid(pdd->dev->dqm, &pdd->qpd);
67621889582SJonathan Kim
67721889582SJonathan Kim if (r) {
67821889582SJonathan Kim target->runtime_info.runtime_state = (r == -EBUSY) ?
67921889582SJonathan Kim DEBUG_RUNTIME_STATE_ENABLED_BUSY :
68021889582SJonathan Kim DEBUG_RUNTIME_STATE_ENABLED_ERROR;
68121889582SJonathan Kim
68221889582SJonathan Kim goto unwind_err;
68321889582SJonathan Kim }
68421889582SJonathan Kim }
68521889582SJonathan Kim
68621889582SJonathan Kim /* Disable GFX OFF to prevent garbage read/writes to debug registers.
68721889582SJonathan Kim * If RLC restore of debug registers is not supported and runtime enable
68821889582SJonathan Kim * hasn't done so already on ttmp setup request, restore the trap config registers.
68921889582SJonathan Kim *
69021889582SJonathan Kim * If RLC restore of debug registers is not supported, keep gfx off disabled for
69121889582SJonathan Kim * the debug session.
69221889582SJonathan Kim */
69321889582SJonathan Kim amdgpu_gfx_off_ctrl(pdd->dev->adev, false);
69421889582SJonathan Kim if (!(kfd_dbg_is_rlc_restore_supported(pdd->dev) ||
69521889582SJonathan Kim target->runtime_info.ttmp_setup))
69621889582SJonathan Kim pdd->dev->kfd2kgd->enable_debug_trap(pdd->dev->adev, true,
69721889582SJonathan Kim pdd->dev->vm_info.last_vmid_kfd);
69821889582SJonathan Kim
69921889582SJonathan Kim pdd->spi_dbg_override = pdd->dev->kfd2kgd->enable_debug_trap(
70021889582SJonathan Kim pdd->dev->adev,
70121889582SJonathan Kim false,
70221889582SJonathan Kim pdd->dev->vm_info.last_vmid_kfd);
70321889582SJonathan Kim
70421889582SJonathan Kim if (kfd_dbg_is_rlc_restore_supported(pdd->dev))
70521889582SJonathan Kim amdgpu_gfx_off_ctrl(pdd->dev->adev, true);
70621889582SJonathan Kim
70750cff45eSJay Cornwall /*
70850cff45eSJay Cornwall * Setting the debug flag in the trap handler requires that the TMA has been
70950cff45eSJay Cornwall * allocated, which occurs during CWSR initialization.
71050cff45eSJay Cornwall * In the event that CWSR has not been initialized at this point, setting the
71150cff45eSJay Cornwall * flag will be called again during CWSR initialization if the target process
71250cff45eSJay Cornwall * is still debug enabled.
71350cff45eSJay Cornwall */
71450cff45eSJay Cornwall kfd_process_set_trap_debug_flag(&pdd->qpd, true);
71550cff45eSJay Cornwall
71621889582SJonathan Kim if (!pdd->dev->kfd->shared_resources.enable_mes)
71721889582SJonathan Kim r = debug_refresh_runlist(pdd->dev->dqm);
71821889582SJonathan Kim else
719*fc7f1d96SJonathan Kim r = kfd_dbg_set_mes_debug_mode(pdd, true);
72021889582SJonathan Kim
72121889582SJonathan Kim if (r) {
72221889582SJonathan Kim target->runtime_info.runtime_state =
72321889582SJonathan Kim DEBUG_RUNTIME_STATE_ENABLED_ERROR;
72421889582SJonathan Kim goto unwind_err;
72521889582SJonathan Kim }
72621889582SJonathan Kim }
72721889582SJonathan Kim
72821889582SJonathan Kim return 0;
72921889582SJonathan Kim
73021889582SJonathan Kim unwind_err:
73121889582SJonathan Kim /* Enabling debug failed, we need to disable on
73221889582SJonathan Kim * all GPUs so the enable is all or nothing.
73321889582SJonathan Kim */
73421889582SJonathan Kim kfd_dbg_trap_deactivate(target, true, i);
73521889582SJonathan Kim return r;
73621889582SJonathan Kim }
73721889582SJonathan Kim
kfd_dbg_trap_enable(struct kfd_process * target,uint32_t fd,void __user * runtime_info,uint32_t * runtime_size)7380ab2d753SJonathan Kim int kfd_dbg_trap_enable(struct kfd_process *target, uint32_t fd,
7390ab2d753SJonathan Kim void __user *runtime_info, uint32_t *runtime_size)
7400ab2d753SJonathan Kim {
7410ab2d753SJonathan Kim struct file *f;
7420ab2d753SJonathan Kim uint32_t copy_size;
74321889582SJonathan Kim int i, r = 0;
7440ab2d753SJonathan Kim
7450ab2d753SJonathan Kim if (target->debug_trap_enabled)
7460ab2d753SJonathan Kim return -EALREADY;
7470ab2d753SJonathan Kim
74821889582SJonathan Kim /* Enable pre-checks */
74921889582SJonathan Kim for (i = 0; i < target->n_pdds; i++) {
75021889582SJonathan Kim struct kfd_process_device *pdd = target->pdds[i];
75121889582SJonathan Kim
75221889582SJonathan Kim if (!KFD_IS_SOC15(pdd->dev))
75321889582SJonathan Kim return -ENODEV;
75421889582SJonathan Kim
7557a1c5c67SJonathan Kim if (pdd->qpd.num_gws && (!kfd_dbg_has_gws_support(pdd->dev) ||
7567a1c5c67SJonathan Kim kfd_dbg_has_cwsr_workaround(pdd->dev)))
75721889582SJonathan Kim return -EBUSY;
75821889582SJonathan Kim }
75921889582SJonathan Kim
7600ab2d753SJonathan Kim copy_size = min((size_t)(*runtime_size), sizeof(target->runtime_info));
7610ab2d753SJonathan Kim
7620ab2d753SJonathan Kim f = fget(fd);
7630ab2d753SJonathan Kim if (!f) {
7640ab2d753SJonathan Kim pr_err("Failed to get file for (%i)\n", fd);
7650ab2d753SJonathan Kim return -EBADF;
7660ab2d753SJonathan Kim }
7670ab2d753SJonathan Kim
7680ab2d753SJonathan Kim target->dbg_ev_file = f;
7690ab2d753SJonathan Kim
77021889582SJonathan Kim /* defer activation to runtime if not runtime enabled */
77121889582SJonathan Kim if (target->runtime_info.runtime_state == DEBUG_RUNTIME_STATE_ENABLED)
77221889582SJonathan Kim kfd_dbg_trap_activate(target);
77321889582SJonathan Kim
7740ab2d753SJonathan Kim /* We already hold the process reference but hold another one for the
7750ab2d753SJonathan Kim * debug session.
7760ab2d753SJonathan Kim */
7770ab2d753SJonathan Kim kref_get(&target->ref);
7780ab2d753SJonathan Kim target->debug_trap_enabled = true;
7790ab2d753SJonathan Kim
7800ab2d753SJonathan Kim if (target->debugger_process)
7810ab2d753SJonathan Kim atomic_inc(&target->debugger_process->debugged_process_count);
7820ab2d753SJonathan Kim
78321889582SJonathan Kim if (copy_to_user(runtime_info, (void *)&target->runtime_info, copy_size)) {
78421889582SJonathan Kim kfd_dbg_trap_deactivate(target, false, 0);
7850ab2d753SJonathan Kim r = -EFAULT;
78621889582SJonathan Kim }
7870ab2d753SJonathan Kim
7880ab2d753SJonathan Kim *runtime_size = sizeof(target->runtime_info);
7890ab2d753SJonathan Kim
7900ab2d753SJonathan Kim return r;
7910ab2d753SJonathan Kim }
792e90bf919SJonathan Kim
kfd_dbg_validate_trap_override_request(struct kfd_process * p,uint32_t trap_override,uint32_t trap_mask_request,uint32_t * trap_mask_supported)793101827e1SJonathan Kim static int kfd_dbg_validate_trap_override_request(struct kfd_process *p,
794101827e1SJonathan Kim uint32_t trap_override,
795101827e1SJonathan Kim uint32_t trap_mask_request,
796101827e1SJonathan Kim uint32_t *trap_mask_supported)
797101827e1SJonathan Kim {
798101827e1SJonathan Kim int i = 0;
799101827e1SJonathan Kim
800101827e1SJonathan Kim *trap_mask_supported = 0xffffffff;
801101827e1SJonathan Kim
802101827e1SJonathan Kim for (i = 0; i < p->n_pdds; i++) {
803101827e1SJonathan Kim struct kfd_process_device *pdd = p->pdds[i];
804101827e1SJonathan Kim int err = pdd->dev->kfd2kgd->validate_trap_override_request(
805101827e1SJonathan Kim pdd->dev->adev,
806101827e1SJonathan Kim trap_override,
807101827e1SJonathan Kim trap_mask_supported);
808101827e1SJonathan Kim
809101827e1SJonathan Kim if (err)
810101827e1SJonathan Kim return err;
811101827e1SJonathan Kim }
812101827e1SJonathan Kim
813101827e1SJonathan Kim if (trap_mask_request & ~*trap_mask_supported)
814101827e1SJonathan Kim return -EACCES;
815101827e1SJonathan Kim
816101827e1SJonathan Kim return 0;
817101827e1SJonathan Kim }
818101827e1SJonathan Kim
kfd_dbg_trap_set_wave_launch_override(struct kfd_process * target,uint32_t trap_override,uint32_t trap_mask_bits,uint32_t trap_mask_request,uint32_t * trap_mask_prev,uint32_t * trap_mask_supported)819101827e1SJonathan Kim int kfd_dbg_trap_set_wave_launch_override(struct kfd_process *target,
820101827e1SJonathan Kim uint32_t trap_override,
821101827e1SJonathan Kim uint32_t trap_mask_bits,
822101827e1SJonathan Kim uint32_t trap_mask_request,
823101827e1SJonathan Kim uint32_t *trap_mask_prev,
824101827e1SJonathan Kim uint32_t *trap_mask_supported)
825101827e1SJonathan Kim {
826101827e1SJonathan Kim int r = 0, i;
827101827e1SJonathan Kim
828101827e1SJonathan Kim r = kfd_dbg_validate_trap_override_request(target,
829101827e1SJonathan Kim trap_override,
830101827e1SJonathan Kim trap_mask_request,
831101827e1SJonathan Kim trap_mask_supported);
832101827e1SJonathan Kim
833101827e1SJonathan Kim if (r)
834101827e1SJonathan Kim return r;
835101827e1SJonathan Kim
836101827e1SJonathan Kim for (i = 0; i < target->n_pdds; i++) {
837101827e1SJonathan Kim struct kfd_process_device *pdd = target->pdds[i];
838101827e1SJonathan Kim
839101827e1SJonathan Kim amdgpu_gfx_off_ctrl(pdd->dev->adev, false);
840101827e1SJonathan Kim pdd->spi_dbg_override = pdd->dev->kfd2kgd->set_wave_launch_trap_override(
841101827e1SJonathan Kim pdd->dev->adev,
842101827e1SJonathan Kim pdd->dev->vm_info.last_vmid_kfd,
843101827e1SJonathan Kim trap_override,
844101827e1SJonathan Kim trap_mask_bits,
845101827e1SJonathan Kim trap_mask_request,
846101827e1SJonathan Kim trap_mask_prev,
847101827e1SJonathan Kim pdd->spi_dbg_override);
848101827e1SJonathan Kim amdgpu_gfx_off_ctrl(pdd->dev->adev, true);
849101827e1SJonathan Kim
850101827e1SJonathan Kim if (!pdd->dev->kfd->shared_resources.enable_mes)
851101827e1SJonathan Kim r = debug_refresh_runlist(pdd->dev->dqm);
852101827e1SJonathan Kim else
853*fc7f1d96SJonathan Kim r = kfd_dbg_set_mes_debug_mode(pdd, true);
854101827e1SJonathan Kim
855101827e1SJonathan Kim if (r)
856101827e1SJonathan Kim break;
857101827e1SJonathan Kim }
858101827e1SJonathan Kim
859101827e1SJonathan Kim return r;
860101827e1SJonathan Kim }
861101827e1SJonathan Kim
kfd_dbg_trap_set_wave_launch_mode(struct kfd_process * target,uint8_t wave_launch_mode)862aea1b473SJonathan Kim int kfd_dbg_trap_set_wave_launch_mode(struct kfd_process *target,
863aea1b473SJonathan Kim uint8_t wave_launch_mode)
864aea1b473SJonathan Kim {
865aea1b473SJonathan Kim int r = 0, i;
866aea1b473SJonathan Kim
867aea1b473SJonathan Kim if (wave_launch_mode != KFD_DBG_TRAP_WAVE_LAUNCH_MODE_NORMAL &&
868aea1b473SJonathan Kim wave_launch_mode != KFD_DBG_TRAP_WAVE_LAUNCH_MODE_HALT &&
869aea1b473SJonathan Kim wave_launch_mode != KFD_DBG_TRAP_WAVE_LAUNCH_MODE_DEBUG)
870aea1b473SJonathan Kim return -EINVAL;
871aea1b473SJonathan Kim
872aea1b473SJonathan Kim for (i = 0; i < target->n_pdds; i++) {
873aea1b473SJonathan Kim struct kfd_process_device *pdd = target->pdds[i];
874aea1b473SJonathan Kim
875aea1b473SJonathan Kim amdgpu_gfx_off_ctrl(pdd->dev->adev, false);
876aea1b473SJonathan Kim pdd->spi_dbg_launch_mode = pdd->dev->kfd2kgd->set_wave_launch_mode(
877aea1b473SJonathan Kim pdd->dev->adev,
878aea1b473SJonathan Kim wave_launch_mode,
879aea1b473SJonathan Kim pdd->dev->vm_info.last_vmid_kfd);
880aea1b473SJonathan Kim amdgpu_gfx_off_ctrl(pdd->dev->adev, true);
881aea1b473SJonathan Kim
882aea1b473SJonathan Kim if (!pdd->dev->kfd->shared_resources.enable_mes)
883aea1b473SJonathan Kim r = debug_refresh_runlist(pdd->dev->dqm);
884aea1b473SJonathan Kim else
885*fc7f1d96SJonathan Kim r = kfd_dbg_set_mes_debug_mode(pdd, true);
886aea1b473SJonathan Kim
887aea1b473SJonathan Kim if (r)
888aea1b473SJonathan Kim break;
889aea1b473SJonathan Kim }
890aea1b473SJonathan Kim
891aea1b473SJonathan Kim return r;
892aea1b473SJonathan Kim }
893aea1b473SJonathan Kim
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)8942b36de97SJonathan Kim int kfd_dbg_trap_query_exception_info(struct kfd_process *target,
8952b36de97SJonathan Kim uint32_t source_id,
8962b36de97SJonathan Kim uint32_t exception_code,
8972b36de97SJonathan Kim bool clear_exception,
8982b36de97SJonathan Kim void __user *info,
8992b36de97SJonathan Kim uint32_t *info_size)
9002b36de97SJonathan Kim {
9012b36de97SJonathan Kim bool found = false;
9022b36de97SJonathan Kim int r = 0;
9032b36de97SJonathan Kim uint32_t copy_size, actual_info_size = 0;
9042b36de97SJonathan Kim uint64_t *exception_status_ptr = NULL;
9052b36de97SJonathan Kim
9062b36de97SJonathan Kim if (!target)
9072b36de97SJonathan Kim return -EINVAL;
9082b36de97SJonathan Kim
9092b36de97SJonathan Kim if (!info || !info_size)
9102b36de97SJonathan Kim return -EINVAL;
9112b36de97SJonathan Kim
9122b36de97SJonathan Kim mutex_lock(&target->event_mutex);
9132b36de97SJonathan Kim
9142b36de97SJonathan Kim if (KFD_DBG_EC_TYPE_IS_QUEUE(exception_code)) {
9152b36de97SJonathan Kim /* Per queue exceptions */
9162b36de97SJonathan Kim struct queue *queue = NULL;
9172b36de97SJonathan Kim int i;
9182b36de97SJonathan Kim
9192b36de97SJonathan Kim for (i = 0; i < target->n_pdds; i++) {
9202b36de97SJonathan Kim struct kfd_process_device *pdd = target->pdds[i];
9212b36de97SJonathan Kim struct qcm_process_device *qpd = &pdd->qpd;
9222b36de97SJonathan Kim
9232b36de97SJonathan Kim list_for_each_entry(queue, &qpd->queues_list, list) {
9242b36de97SJonathan Kim if (!found && queue->properties.queue_id == source_id) {
9252b36de97SJonathan Kim found = true;
9262b36de97SJonathan Kim break;
9272b36de97SJonathan Kim }
9282b36de97SJonathan Kim }
9292b36de97SJonathan Kim if (found)
9302b36de97SJonathan Kim break;
9312b36de97SJonathan Kim }
9322b36de97SJonathan Kim
9332b36de97SJonathan Kim if (!found) {
9342b36de97SJonathan Kim r = -EINVAL;
9352b36de97SJonathan Kim goto out;
9362b36de97SJonathan Kim }
9372b36de97SJonathan Kim
9382b36de97SJonathan Kim if (!(queue->properties.exception_status & KFD_EC_MASK(exception_code))) {
9392b36de97SJonathan Kim r = -ENODATA;
9402b36de97SJonathan Kim goto out;
9412b36de97SJonathan Kim }
9422b36de97SJonathan Kim exception_status_ptr = &queue->properties.exception_status;
9432b36de97SJonathan Kim } else if (KFD_DBG_EC_TYPE_IS_DEVICE(exception_code)) {
9442b36de97SJonathan Kim /* Per device exceptions */
9452b36de97SJonathan Kim struct kfd_process_device *pdd = NULL;
9462b36de97SJonathan Kim int i;
9472b36de97SJonathan Kim
9482b36de97SJonathan Kim for (i = 0; i < target->n_pdds; i++) {
9492b36de97SJonathan Kim pdd = target->pdds[i];
9502b36de97SJonathan Kim if (pdd->dev->id == source_id) {
9512b36de97SJonathan Kim found = true;
9522b36de97SJonathan Kim break;
9532b36de97SJonathan Kim }
9542b36de97SJonathan Kim }
9552b36de97SJonathan Kim
9562b36de97SJonathan Kim if (!found) {
9572b36de97SJonathan Kim r = -EINVAL;
9582b36de97SJonathan Kim goto out;
9592b36de97SJonathan Kim }
9602b36de97SJonathan Kim
9612b36de97SJonathan Kim if (!(pdd->exception_status & KFD_EC_MASK(exception_code))) {
9622b36de97SJonathan Kim r = -ENODATA;
9632b36de97SJonathan Kim goto out;
9642b36de97SJonathan Kim }
9652b36de97SJonathan Kim
9662b36de97SJonathan Kim if (exception_code == EC_DEVICE_MEMORY_VIOLATION) {
9672b36de97SJonathan Kim copy_size = min((size_t)(*info_size), pdd->vm_fault_exc_data_size);
9682b36de97SJonathan Kim
9692b36de97SJonathan Kim if (copy_to_user(info, pdd->vm_fault_exc_data, copy_size)) {
9702b36de97SJonathan Kim r = -EFAULT;
9712b36de97SJonathan Kim goto out;
9722b36de97SJonathan Kim }
9732b36de97SJonathan Kim actual_info_size = pdd->vm_fault_exc_data_size;
9742b36de97SJonathan Kim if (clear_exception) {
9752b36de97SJonathan Kim kfree(pdd->vm_fault_exc_data);
9762b36de97SJonathan Kim pdd->vm_fault_exc_data = NULL;
9772b36de97SJonathan Kim pdd->vm_fault_exc_data_size = 0;
9782b36de97SJonathan Kim }
9792b36de97SJonathan Kim }
9802b36de97SJonathan Kim exception_status_ptr = &pdd->exception_status;
9812b36de97SJonathan Kim } else if (KFD_DBG_EC_TYPE_IS_PROCESS(exception_code)) {
9822b36de97SJonathan Kim /* Per process exceptions */
9832b36de97SJonathan Kim if (!(target->exception_status & KFD_EC_MASK(exception_code))) {
9842b36de97SJonathan Kim r = -ENODATA;
9852b36de97SJonathan Kim goto out;
9862b36de97SJonathan Kim }
9872b36de97SJonathan Kim
9882b36de97SJonathan Kim if (exception_code == EC_PROCESS_RUNTIME) {
9892b36de97SJonathan Kim copy_size = min((size_t)(*info_size), sizeof(target->runtime_info));
9902b36de97SJonathan Kim
9912b36de97SJonathan Kim if (copy_to_user(info, (void *)&target->runtime_info, copy_size)) {
9922b36de97SJonathan Kim r = -EFAULT;
9932b36de97SJonathan Kim goto out;
9942b36de97SJonathan Kim }
9952b36de97SJonathan Kim
9962b36de97SJonathan Kim actual_info_size = sizeof(target->runtime_info);
9972b36de97SJonathan Kim }
9982b36de97SJonathan Kim
9992b36de97SJonathan Kim exception_status_ptr = &target->exception_status;
10002b36de97SJonathan Kim } else {
10012b36de97SJonathan Kim pr_debug("Bad exception type [%i]\n", exception_code);
10022b36de97SJonathan Kim r = -EINVAL;
10032b36de97SJonathan Kim goto out;
10042b36de97SJonathan Kim }
10052b36de97SJonathan Kim
10062b36de97SJonathan Kim *info_size = actual_info_size;
10072b36de97SJonathan Kim if (clear_exception)
10082b36de97SJonathan Kim *exception_status_ptr &= ~KFD_EC_MASK(exception_code);
10092b36de97SJonathan Kim out:
10102b36de97SJonathan Kim mutex_unlock(&target->event_mutex);
10112b36de97SJonathan Kim return r;
10122b36de97SJonathan Kim }
10132b36de97SJonathan Kim
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)101412976e6aSJonathan Kim int kfd_dbg_trap_device_snapshot(struct kfd_process *target,
101512976e6aSJonathan Kim uint64_t exception_clear_mask,
101612976e6aSJonathan Kim void __user *user_info,
101712976e6aSJonathan Kim uint32_t *number_of_device_infos,
101812976e6aSJonathan Kim uint32_t *entry_size)
101912976e6aSJonathan Kim {
102012976e6aSJonathan Kim struct kfd_dbg_device_info_entry device_info;
102112976e6aSJonathan Kim uint32_t tmp_entry_size = *entry_size, tmp_num_devices;
102212976e6aSJonathan Kim int i, r = 0;
102312976e6aSJonathan Kim
102412976e6aSJonathan Kim if (!(target && user_info && number_of_device_infos && entry_size))
102512976e6aSJonathan Kim return -EINVAL;
102612976e6aSJonathan Kim
102712976e6aSJonathan Kim tmp_num_devices = min_t(size_t, *number_of_device_infos, target->n_pdds);
102812976e6aSJonathan Kim *number_of_device_infos = target->n_pdds;
102912976e6aSJonathan Kim *entry_size = min_t(size_t, *entry_size, sizeof(device_info));
103012976e6aSJonathan Kim
103112976e6aSJonathan Kim if (!tmp_num_devices)
103212976e6aSJonathan Kim return 0;
103312976e6aSJonathan Kim
103412976e6aSJonathan Kim memset(&device_info, 0, sizeof(device_info));
103512976e6aSJonathan Kim
103612976e6aSJonathan Kim mutex_lock(&target->event_mutex);
103712976e6aSJonathan Kim
103812976e6aSJonathan Kim /* Run over all pdd of the process */
103912976e6aSJonathan Kim for (i = 0; i < tmp_num_devices; i++) {
104012976e6aSJonathan Kim struct kfd_process_device *pdd = target->pdds[i];
104112976e6aSJonathan Kim struct kfd_topology_device *topo_dev = kfd_topology_device_by_id(pdd->dev->id);
104212976e6aSJonathan Kim
104312976e6aSJonathan Kim device_info.gpu_id = pdd->dev->id;
104412976e6aSJonathan Kim device_info.exception_status = pdd->exception_status;
104512976e6aSJonathan Kim device_info.lds_base = pdd->lds_base;
104612976e6aSJonathan Kim device_info.lds_limit = pdd->lds_limit;
104712976e6aSJonathan Kim device_info.scratch_base = pdd->scratch_base;
104812976e6aSJonathan Kim device_info.scratch_limit = pdd->scratch_limit;
104912976e6aSJonathan Kim device_info.gpuvm_base = pdd->gpuvm_base;
105012976e6aSJonathan Kim device_info.gpuvm_limit = pdd->gpuvm_limit;
105112976e6aSJonathan Kim device_info.location_id = topo_dev->node_props.location_id;
105212976e6aSJonathan Kim device_info.vendor_id = topo_dev->node_props.vendor_id;
105312976e6aSJonathan Kim device_info.device_id = topo_dev->node_props.device_id;
105412976e6aSJonathan Kim device_info.revision_id = pdd->dev->adev->pdev->revision;
105512976e6aSJonathan Kim device_info.subsystem_vendor_id = pdd->dev->adev->pdev->subsystem_vendor;
105612976e6aSJonathan Kim device_info.subsystem_device_id = pdd->dev->adev->pdev->subsystem_device;
105712976e6aSJonathan Kim device_info.fw_version = pdd->dev->kfd->mec_fw_version;
105812976e6aSJonathan Kim device_info.gfx_target_version =
105912976e6aSJonathan Kim topo_dev->node_props.gfx_target_version;
106012976e6aSJonathan Kim device_info.simd_count = topo_dev->node_props.simd_count;
106112976e6aSJonathan Kim device_info.max_waves_per_simd =
106212976e6aSJonathan Kim topo_dev->node_props.max_waves_per_simd;
106312976e6aSJonathan Kim device_info.array_count = topo_dev->node_props.array_count;
106412976e6aSJonathan Kim device_info.simd_arrays_per_engine =
106512976e6aSJonathan Kim topo_dev->node_props.simd_arrays_per_engine;
106612976e6aSJonathan Kim device_info.num_xcc = NUM_XCC(pdd->dev->xcc_mask);
106712976e6aSJonathan Kim device_info.capability = topo_dev->node_props.capability;
106812976e6aSJonathan Kim device_info.debug_prop = topo_dev->node_props.debug_prop;
106912976e6aSJonathan Kim
107012976e6aSJonathan Kim if (exception_clear_mask)
107112976e6aSJonathan Kim pdd->exception_status &= ~exception_clear_mask;
107212976e6aSJonathan Kim
107312976e6aSJonathan Kim if (copy_to_user(user_info, &device_info, *entry_size)) {
107412976e6aSJonathan Kim r = -EFAULT;
107512976e6aSJonathan Kim break;
107612976e6aSJonathan Kim }
107712976e6aSJonathan Kim
107812976e6aSJonathan Kim user_info += tmp_entry_size;
107912976e6aSJonathan Kim }
108012976e6aSJonathan Kim
108112976e6aSJonathan Kim mutex_unlock(&target->event_mutex);
108212976e6aSJonathan Kim
108312976e6aSJonathan Kim return r;
108412976e6aSJonathan Kim }
108512976e6aSJonathan Kim
kfd_dbg_set_enabled_debug_exception_mask(struct kfd_process * target,uint64_t exception_set_mask)1086e90bf919SJonathan Kim void kfd_dbg_set_enabled_debug_exception_mask(struct kfd_process *target,
1087e90bf919SJonathan Kim uint64_t exception_set_mask)
1088e90bf919SJonathan Kim {
1089e90bf919SJonathan Kim uint64_t found_mask = 0;
1090e90bf919SJonathan Kim struct process_queue_manager *pqm;
1091e90bf919SJonathan Kim struct process_queue_node *pqn;
1092e90bf919SJonathan Kim static const char write_data = '.';
1093e90bf919SJonathan Kim loff_t pos = 0;
1094e90bf919SJonathan Kim int i;
1095e90bf919SJonathan Kim
1096e90bf919SJonathan Kim mutex_lock(&target->event_mutex);
1097e90bf919SJonathan Kim
1098e90bf919SJonathan Kim found_mask |= target->exception_status;
1099e90bf919SJonathan Kim
1100e90bf919SJonathan Kim pqm = &target->pqm;
1101e90bf919SJonathan Kim list_for_each_entry(pqn, &pqm->queues, process_queue_list) {
11028f7bd701SJonathan Kim if (!pqn->q)
1103e90bf919SJonathan Kim continue;
1104e90bf919SJonathan Kim
1105e90bf919SJonathan Kim found_mask |= pqn->q->properties.exception_status;
1106e90bf919SJonathan Kim }
1107e90bf919SJonathan Kim
1108e90bf919SJonathan Kim for (i = 0; i < target->n_pdds; i++) {
1109e90bf919SJonathan Kim struct kfd_process_device *pdd = target->pdds[i];
1110e90bf919SJonathan Kim
1111e90bf919SJonathan Kim found_mask |= pdd->exception_status;
1112e90bf919SJonathan Kim }
1113e90bf919SJonathan Kim
1114e90bf919SJonathan Kim if (exception_set_mask & found_mask)
1115e90bf919SJonathan Kim kernel_write(target->dbg_ev_file, &write_data, 1, &pos);
1116e90bf919SJonathan Kim
1117e90bf919SJonathan Kim target->exception_enable_mask = exception_set_mask;
1118e90bf919SJonathan Kim
1119e90bf919SJonathan Kim mutex_unlock(&target->event_mutex);
1120e90bf919SJonathan Kim }
1121