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" 25*12976e6aSJonathan 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 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 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 */ 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 */ 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 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 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 30569a8c3aeSJonathan Kim if (KFD_GC_VERSION(q->device) < IP_VERSION(11, 0, 0) || 30669a8c3aeSJonathan Kim KFD_GC_VERSION(q->device) >= IP_VERSION(12, 0, 0)) 30769a8c3aeSJonathan Kim return 0; 30869a8c3aeSJonathan Kim 30969a8c3aeSJonathan Kim if (enable && q->properties.is_user_cu_masked) 31069a8c3aeSJonathan Kim return -EBUSY; 31169a8c3aeSJonathan Kim 31269a8c3aeSJonathan Kim minfo.update_flag = enable ? UPDATE_FLAG_DBG_WA_ENABLE : UPDATE_FLAG_DBG_WA_DISABLE; 31369a8c3aeSJonathan Kim 31469a8c3aeSJonathan Kim q->properties.is_dbg_wa = enable; 31569a8c3aeSJonathan Kim err = q->device->dqm->ops.update_queue(q->device->dqm, q, &minfo); 31669a8c3aeSJonathan Kim if (err) 31769a8c3aeSJonathan Kim q->properties.is_dbg_wa = false; 31869a8c3aeSJonathan Kim 31969a8c3aeSJonathan Kim return err; 32069a8c3aeSJonathan Kim } 32169a8c3aeSJonathan Kim 32269a8c3aeSJonathan Kim static int kfd_dbg_set_workaround(struct kfd_process *target, bool enable) 32369a8c3aeSJonathan Kim { 32469a8c3aeSJonathan Kim struct process_queue_manager *pqm = &target->pqm; 32569a8c3aeSJonathan Kim struct process_queue_node *pqn; 32669a8c3aeSJonathan Kim int r = 0; 32769a8c3aeSJonathan Kim 32869a8c3aeSJonathan Kim list_for_each_entry(pqn, &pqm->queues, process_queue_list) { 32969a8c3aeSJonathan Kim r = kfd_dbg_set_queue_workaround(pqn->q, enable); 33069a8c3aeSJonathan Kim if (enable && r) 33169a8c3aeSJonathan Kim goto unwind; 33269a8c3aeSJonathan Kim } 33369a8c3aeSJonathan Kim 33469a8c3aeSJonathan Kim return 0; 33569a8c3aeSJonathan Kim 33669a8c3aeSJonathan Kim unwind: 33769a8c3aeSJonathan Kim list_for_each_entry(pqn, &pqm->queues, process_queue_list) 33869a8c3aeSJonathan Kim kfd_dbg_set_queue_workaround(pqn->q, false); 33969a8c3aeSJonathan Kim 34069a8c3aeSJonathan Kim if (enable) 34169a8c3aeSJonathan Kim target->runtime_info.runtime_state = r == -EBUSY ? 34269a8c3aeSJonathan Kim DEBUG_RUNTIME_STATE_ENABLED_BUSY : 34369a8c3aeSJonathan Kim DEBUG_RUNTIME_STATE_ENABLED_ERROR; 34469a8c3aeSJonathan Kim 34569a8c3aeSJonathan Kim return r; 34669a8c3aeSJonathan Kim } 34769a8c3aeSJonathan Kim 348455227c4SJonathan Kim int kfd_dbg_set_mes_debug_mode(struct kfd_process_device *pdd) 34921889582SJonathan Kim { 35021889582SJonathan Kim uint32_t spi_dbg_cntl = pdd->spi_dbg_override | pdd->spi_dbg_launch_mode; 35121889582SJonathan Kim uint32_t flags = pdd->process->dbg_flags; 35221889582SJonathan Kim 35321889582SJonathan Kim if (!kfd_dbg_is_per_vmid_supported(pdd->dev)) 35421889582SJonathan Kim return 0; 35521889582SJonathan Kim 35621889582SJonathan Kim return amdgpu_mes_set_shader_debugger(pdd->dev->adev, pdd->proc_ctx_gpu_addr, spi_dbg_cntl, 35721889582SJonathan Kim pdd->watch_points, flags); 35821889582SJonathan Kim } 35921889582SJonathan Kim 360e0f85f46SJonathan Kim #define KFD_DEBUGGER_INVALID_WATCH_POINT_ID -1 361e0f85f46SJonathan Kim static int kfd_dbg_get_dev_watch_id(struct kfd_process_device *pdd, int *watch_id) 362e0f85f46SJonathan Kim { 363e0f85f46SJonathan Kim int i; 364e0f85f46SJonathan Kim 365e0f85f46SJonathan Kim *watch_id = KFD_DEBUGGER_INVALID_WATCH_POINT_ID; 366e0f85f46SJonathan Kim 367e0f85f46SJonathan Kim spin_lock(&pdd->dev->kfd->watch_points_lock); 368e0f85f46SJonathan Kim 369e0f85f46SJonathan Kim for (i = 0; i < MAX_WATCH_ADDRESSES; i++) { 370e0f85f46SJonathan Kim /* device watchpoint in use so skip */ 371e0f85f46SJonathan Kim if ((pdd->dev->kfd->alloc_watch_ids >> i) & 0x1) 372e0f85f46SJonathan Kim continue; 373e0f85f46SJonathan Kim 374e0f85f46SJonathan Kim pdd->alloc_watch_ids |= 0x1 << i; 375e0f85f46SJonathan Kim pdd->dev->kfd->alloc_watch_ids |= 0x1 << i; 376e0f85f46SJonathan Kim *watch_id = i; 377e0f85f46SJonathan Kim spin_unlock(&pdd->dev->kfd->watch_points_lock); 378e0f85f46SJonathan Kim return 0; 379e0f85f46SJonathan Kim } 380e0f85f46SJonathan Kim 381e0f85f46SJonathan Kim spin_unlock(&pdd->dev->kfd->watch_points_lock); 382e0f85f46SJonathan Kim 383e0f85f46SJonathan Kim return -ENOMEM; 384e0f85f46SJonathan Kim } 385e0f85f46SJonathan Kim 386e0f85f46SJonathan Kim static void kfd_dbg_clear_dev_watch_id(struct kfd_process_device *pdd, int watch_id) 387e0f85f46SJonathan Kim { 388e0f85f46SJonathan Kim spin_lock(&pdd->dev->kfd->watch_points_lock); 389e0f85f46SJonathan Kim 390e0f85f46SJonathan Kim /* process owns device watch point so safe to clear */ 391e0f85f46SJonathan Kim if ((pdd->alloc_watch_ids >> watch_id) & 0x1) { 392e0f85f46SJonathan Kim pdd->alloc_watch_ids &= ~(0x1 << watch_id); 393e0f85f46SJonathan Kim pdd->dev->kfd->alloc_watch_ids &= ~(0x1 << watch_id); 394e0f85f46SJonathan Kim } 395e0f85f46SJonathan Kim 396e0f85f46SJonathan Kim spin_unlock(&pdd->dev->kfd->watch_points_lock); 397e0f85f46SJonathan Kim } 398e0f85f46SJonathan Kim 399e0f85f46SJonathan Kim static bool kfd_dbg_owns_dev_watch_id(struct kfd_process_device *pdd, int watch_id) 400e0f85f46SJonathan Kim { 401e0f85f46SJonathan Kim bool owns_watch_id = false; 402e0f85f46SJonathan Kim 403e0f85f46SJonathan Kim spin_lock(&pdd->dev->kfd->watch_points_lock); 404e0f85f46SJonathan Kim owns_watch_id = watch_id < MAX_WATCH_ADDRESSES && 405e0f85f46SJonathan Kim ((pdd->alloc_watch_ids >> watch_id) & 0x1); 406e0f85f46SJonathan Kim 407e0f85f46SJonathan Kim spin_unlock(&pdd->dev->kfd->watch_points_lock); 408e0f85f46SJonathan Kim 409e0f85f46SJonathan Kim return owns_watch_id; 410e0f85f46SJonathan Kim } 411e0f85f46SJonathan Kim 412e0f85f46SJonathan Kim int kfd_dbg_trap_clear_dev_address_watch(struct kfd_process_device *pdd, 413e0f85f46SJonathan Kim uint32_t watch_id) 414e0f85f46SJonathan Kim { 415e0f85f46SJonathan Kim int r; 416e0f85f46SJonathan Kim 417e0f85f46SJonathan Kim if (!kfd_dbg_owns_dev_watch_id(pdd, watch_id)) 418e0f85f46SJonathan Kim return -EINVAL; 419e0f85f46SJonathan Kim 420e0f85f46SJonathan Kim if (!pdd->dev->kfd->shared_resources.enable_mes) { 421e0f85f46SJonathan Kim r = debug_lock_and_unmap(pdd->dev->dqm); 422e0f85f46SJonathan Kim if (r) 423e0f85f46SJonathan Kim return r; 424e0f85f46SJonathan Kim } 425e0f85f46SJonathan Kim 426e0f85f46SJonathan Kim amdgpu_gfx_off_ctrl(pdd->dev->adev, false); 427e0f85f46SJonathan Kim pdd->watch_points[watch_id] = pdd->dev->kfd2kgd->clear_address_watch( 428e0f85f46SJonathan Kim pdd->dev->adev, 429e0f85f46SJonathan Kim watch_id); 430e0f85f46SJonathan Kim amdgpu_gfx_off_ctrl(pdd->dev->adev, true); 431e0f85f46SJonathan Kim 432e0f85f46SJonathan Kim if (!pdd->dev->kfd->shared_resources.enable_mes) 433e0f85f46SJonathan Kim r = debug_map_and_unlock(pdd->dev->dqm); 434e0f85f46SJonathan Kim else 435e0f85f46SJonathan Kim r = kfd_dbg_set_mes_debug_mode(pdd); 436e0f85f46SJonathan Kim 437e0f85f46SJonathan Kim kfd_dbg_clear_dev_watch_id(pdd, watch_id); 438e0f85f46SJonathan Kim 439e0f85f46SJonathan Kim return r; 440e0f85f46SJonathan Kim } 441e0f85f46SJonathan Kim 442e0f85f46SJonathan Kim int kfd_dbg_trap_set_dev_address_watch(struct kfd_process_device *pdd, 443e0f85f46SJonathan Kim uint64_t watch_address, 444e0f85f46SJonathan Kim uint32_t watch_address_mask, 445e0f85f46SJonathan Kim uint32_t *watch_id, 446e0f85f46SJonathan Kim uint32_t watch_mode) 447e0f85f46SJonathan Kim { 448e0f85f46SJonathan Kim int r = kfd_dbg_get_dev_watch_id(pdd, watch_id); 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); 462e0f85f46SJonathan Kim pdd->watch_points[*watch_id] = pdd->dev->kfd2kgd->set_address_watch( 463e0f85f46SJonathan Kim pdd->dev->adev, 464e0f85f46SJonathan Kim watch_address, 465e0f85f46SJonathan Kim watch_address_mask, 466e0f85f46SJonathan Kim *watch_id, 467e0f85f46SJonathan Kim watch_mode, 468e0f85f46SJonathan Kim pdd->dev->vm_info.last_vmid_kfd); 469e0f85f46SJonathan Kim amdgpu_gfx_off_ctrl(pdd->dev->adev, true); 470e0f85f46SJonathan Kim 471e0f85f46SJonathan Kim if (!pdd->dev->kfd->shared_resources.enable_mes) 472e0f85f46SJonathan Kim r = debug_map_and_unlock(pdd->dev->dqm); 473e0f85f46SJonathan Kim else 474e0f85f46SJonathan Kim r = kfd_dbg_set_mes_debug_mode(pdd); 475e0f85f46SJonathan Kim 476e0f85f46SJonathan Kim /* HWS is broken so no point in HW rollback but release the watchpoint anyways */ 477e0f85f46SJonathan Kim if (r) 478e0f85f46SJonathan Kim kfd_dbg_clear_dev_watch_id(pdd, *watch_id); 479e0f85f46SJonathan Kim 480e0f85f46SJonathan Kim return 0; 481e0f85f46SJonathan Kim } 482e0f85f46SJonathan Kim 483e0f85f46SJonathan Kim static void kfd_dbg_clear_process_address_watch(struct kfd_process *target) 484e0f85f46SJonathan Kim { 485e0f85f46SJonathan Kim int i, j; 486e0f85f46SJonathan Kim 487e0f85f46SJonathan Kim for (i = 0; i < target->n_pdds; i++) 488e0f85f46SJonathan Kim for (j = 0; j < MAX_WATCH_ADDRESSES; j++) 489e0f85f46SJonathan Kim kfd_dbg_trap_clear_dev_address_watch(target->pdds[i], j); 490e0f85f46SJonathan Kim } 491e0f85f46SJonathan Kim 492103d5f08SJonathan Kim int kfd_dbg_trap_set_flags(struct kfd_process *target, uint32_t *flags) 493103d5f08SJonathan Kim { 494103d5f08SJonathan Kim uint32_t prev_flags = target->dbg_flags; 495103d5f08SJonathan Kim int i, r = 0, rewind_count = 0; 496103d5f08SJonathan Kim 497103d5f08SJonathan Kim for (i = 0; i < target->n_pdds; i++) { 498103d5f08SJonathan Kim if (!kfd_dbg_is_per_vmid_supported(target->pdds[i]->dev) && 499103d5f08SJonathan Kim (*flags & KFD_DBG_TRAP_FLAG_SINGLE_MEM_OP)) { 500103d5f08SJonathan Kim *flags = prev_flags; 501103d5f08SJonathan Kim return -EACCES; 502103d5f08SJonathan Kim } 503103d5f08SJonathan Kim } 504103d5f08SJonathan Kim 505103d5f08SJonathan Kim target->dbg_flags = *flags & KFD_DBG_TRAP_FLAG_SINGLE_MEM_OP; 506103d5f08SJonathan Kim *flags = prev_flags; 507103d5f08SJonathan Kim for (i = 0; i < target->n_pdds; i++) { 508103d5f08SJonathan Kim struct kfd_process_device *pdd = target->pdds[i]; 509103d5f08SJonathan Kim 510103d5f08SJonathan Kim if (!kfd_dbg_is_per_vmid_supported(pdd->dev)) 511103d5f08SJonathan Kim continue; 512103d5f08SJonathan Kim 513103d5f08SJonathan Kim if (!pdd->dev->kfd->shared_resources.enable_mes) 514103d5f08SJonathan Kim r = debug_refresh_runlist(pdd->dev->dqm); 515103d5f08SJonathan Kim else 516103d5f08SJonathan Kim r = kfd_dbg_set_mes_debug_mode(pdd); 517103d5f08SJonathan Kim 518103d5f08SJonathan Kim if (r) { 519103d5f08SJonathan Kim target->dbg_flags = prev_flags; 520103d5f08SJonathan Kim break; 521103d5f08SJonathan Kim } 522103d5f08SJonathan Kim 523103d5f08SJonathan Kim rewind_count++; 524103d5f08SJonathan Kim } 525103d5f08SJonathan Kim 526103d5f08SJonathan Kim /* Rewind flags */ 527103d5f08SJonathan Kim if (r) { 528103d5f08SJonathan Kim target->dbg_flags = prev_flags; 529103d5f08SJonathan Kim 530103d5f08SJonathan Kim for (i = 0; i < rewind_count; i++) { 531103d5f08SJonathan Kim struct kfd_process_device *pdd = target->pdds[i]; 532103d5f08SJonathan Kim 533103d5f08SJonathan Kim if (!kfd_dbg_is_per_vmid_supported(pdd->dev)) 534103d5f08SJonathan Kim continue; 535103d5f08SJonathan Kim 536103d5f08SJonathan Kim if (!pdd->dev->kfd->shared_resources.enable_mes) 537103d5f08SJonathan Kim debug_refresh_runlist(pdd->dev->dqm); 538103d5f08SJonathan Kim else 539103d5f08SJonathan Kim kfd_dbg_set_mes_debug_mode(pdd); 540103d5f08SJonathan Kim } 541103d5f08SJonathan Kim } 542103d5f08SJonathan Kim 543103d5f08SJonathan Kim return r; 544103d5f08SJonathan Kim } 545e0f85f46SJonathan Kim 54621889582SJonathan Kim /* kfd_dbg_trap_deactivate: 54721889582SJonathan Kim * target: target process 54821889582SJonathan Kim * unwind: If this is unwinding a failed kfd_dbg_trap_enable() 54921889582SJonathan Kim * unwind_count: 55021889582SJonathan Kim * If unwind == true, how far down the pdd list we need 55121889582SJonathan Kim * to unwind 55221889582SJonathan Kim * else: ignored 55321889582SJonathan Kim */ 554455227c4SJonathan Kim void kfd_dbg_trap_deactivate(struct kfd_process *target, bool unwind, int unwind_count) 55521889582SJonathan Kim { 55621889582SJonathan Kim int i; 55721889582SJonathan Kim 558aea1b473SJonathan Kim if (!unwind) { 559103d5f08SJonathan Kim uint32_t flags = 0; 560103d5f08SJonathan Kim 56144b87bb0SJonathan Kim cancel_work_sync(&target->debug_event_workarea); 562e0f85f46SJonathan Kim kfd_dbg_clear_process_address_watch(target); 563aea1b473SJonathan Kim kfd_dbg_trap_set_wave_launch_mode(target, 0); 564103d5f08SJonathan Kim 565103d5f08SJonathan Kim kfd_dbg_trap_set_flags(target, &flags); 566aea1b473SJonathan Kim } 56744b87bb0SJonathan Kim 56821889582SJonathan Kim for (i = 0; i < target->n_pdds; i++) { 56921889582SJonathan Kim struct kfd_process_device *pdd = target->pdds[i]; 57021889582SJonathan Kim 57121889582SJonathan Kim /* If this is an unwind, and we have unwound the required 57221889582SJonathan Kim * enable calls on the pdd list, we need to stop now 57321889582SJonathan Kim * otherwise we may mess up another debugger session. 57421889582SJonathan Kim */ 57521889582SJonathan Kim if (unwind && i == unwind_count) 57621889582SJonathan Kim break; 57721889582SJonathan Kim 57850cff45eSJay Cornwall kfd_process_set_trap_debug_flag(&pdd->qpd, false); 57950cff45eSJay Cornwall 58021889582SJonathan Kim /* GFX off is already disabled by debug activate if not RLC restore supported. */ 58121889582SJonathan Kim if (kfd_dbg_is_rlc_restore_supported(pdd->dev)) 58221889582SJonathan Kim amdgpu_gfx_off_ctrl(pdd->dev->adev, false); 58321889582SJonathan Kim pdd->spi_dbg_override = 58421889582SJonathan Kim pdd->dev->kfd2kgd->disable_debug_trap( 58521889582SJonathan Kim pdd->dev->adev, 58621889582SJonathan Kim target->runtime_info.ttmp_setup, 58721889582SJonathan Kim pdd->dev->vm_info.last_vmid_kfd); 58821889582SJonathan Kim amdgpu_gfx_off_ctrl(pdd->dev->adev, true); 58921889582SJonathan Kim 59021889582SJonathan Kim if (!kfd_dbg_is_per_vmid_supported(pdd->dev) && 59121889582SJonathan Kim release_debug_trap_vmid(pdd->dev->dqm, &pdd->qpd)) 59221889582SJonathan Kim pr_err("Failed to release debug vmid on [%i]\n", pdd->dev->id); 59321889582SJonathan Kim 59421889582SJonathan Kim if (!pdd->dev->kfd->shared_resources.enable_mes) 59521889582SJonathan Kim debug_refresh_runlist(pdd->dev->dqm); 59621889582SJonathan Kim else 59721889582SJonathan Kim kfd_dbg_set_mes_debug_mode(pdd); 59821889582SJonathan Kim } 59969a8c3aeSJonathan Kim 60069a8c3aeSJonathan Kim kfd_dbg_set_workaround(target, false); 601a70a93faSJonathan Kim 602a70a93faSJonathan Kim if (!unwind) { 603a70a93faSJonathan Kim int resume_count = resume_queues(target, 0, NULL); 604a70a93faSJonathan Kim 605a70a93faSJonathan Kim if (resume_count) 606a70a93faSJonathan Kim pr_debug("Resumed %d queues\n", resume_count); 607a70a93faSJonathan Kim } 60821889582SJonathan Kim } 60921889582SJonathan Kim 61012fb1ad7SJonathan Kim static void kfd_dbg_clean_exception_status(struct kfd_process *target) 61112fb1ad7SJonathan Kim { 61212fb1ad7SJonathan Kim struct process_queue_manager *pqm; 61312fb1ad7SJonathan Kim struct process_queue_node *pqn; 61412fb1ad7SJonathan Kim int i; 61512fb1ad7SJonathan Kim 61612fb1ad7SJonathan Kim for (i = 0; i < target->n_pdds; i++) { 61712fb1ad7SJonathan Kim struct kfd_process_device *pdd = target->pdds[i]; 61812fb1ad7SJonathan Kim 61912fb1ad7SJonathan Kim kfd_process_drain_interrupts(pdd); 62012fb1ad7SJonathan Kim 62112fb1ad7SJonathan Kim pdd->exception_status = 0; 62212fb1ad7SJonathan Kim } 62312fb1ad7SJonathan Kim 62412fb1ad7SJonathan Kim pqm = &target->pqm; 62512fb1ad7SJonathan Kim list_for_each_entry(pqn, &pqm->queues, process_queue_list) { 62612fb1ad7SJonathan Kim if (!pqn->q) 62712fb1ad7SJonathan Kim continue; 62812fb1ad7SJonathan Kim 62912fb1ad7SJonathan Kim pqn->q->properties.exception_status = 0; 63012fb1ad7SJonathan Kim } 63112fb1ad7SJonathan Kim 63212fb1ad7SJonathan Kim target->exception_status = 0; 63312fb1ad7SJonathan Kim } 63412fb1ad7SJonathan Kim 6350ab2d753SJonathan Kim int kfd_dbg_trap_disable(struct kfd_process *target) 6360ab2d753SJonathan Kim { 6370ab2d753SJonathan Kim if (!target->debug_trap_enabled) 6380ab2d753SJonathan Kim return 0; 6390ab2d753SJonathan Kim 64021889582SJonathan Kim /* 64121889582SJonathan Kim * Defer deactivation to runtime if runtime not enabled otherwise reset 64221889582SJonathan Kim * attached running target runtime state to enable for re-attach. 64321889582SJonathan Kim */ 64421889582SJonathan Kim if (target->runtime_info.runtime_state == DEBUG_RUNTIME_STATE_ENABLED) 64521889582SJonathan Kim kfd_dbg_trap_deactivate(target, false, 0); 64621889582SJonathan Kim else if (target->runtime_info.runtime_state != DEBUG_RUNTIME_STATE_DISABLED) 64721889582SJonathan Kim target->runtime_info.runtime_state = DEBUG_RUNTIME_STATE_ENABLED; 64821889582SJonathan Kim 6490ab2d753SJonathan Kim fput(target->dbg_ev_file); 6500ab2d753SJonathan Kim target->dbg_ev_file = NULL; 6510ab2d753SJonathan Kim 6520ab2d753SJonathan Kim if (target->debugger_process) { 6530ab2d753SJonathan Kim atomic_dec(&target->debugger_process->debugged_process_count); 6540ab2d753SJonathan Kim target->debugger_process = NULL; 6550ab2d753SJonathan Kim } 6560ab2d753SJonathan Kim 6570ab2d753SJonathan Kim target->debug_trap_enabled = false; 65812fb1ad7SJonathan Kim kfd_dbg_clean_exception_status(target); 6590ab2d753SJonathan Kim kfd_unref_process(target); 6600ab2d753SJonathan Kim 6610ab2d753SJonathan Kim return 0; 6620ab2d753SJonathan Kim } 6630ab2d753SJonathan Kim 664455227c4SJonathan Kim int kfd_dbg_trap_activate(struct kfd_process *target) 66521889582SJonathan Kim { 66621889582SJonathan Kim int i, r = 0; 66721889582SJonathan Kim 66869a8c3aeSJonathan Kim r = kfd_dbg_set_workaround(target, true); 66969a8c3aeSJonathan Kim if (r) 67069a8c3aeSJonathan Kim return r; 67169a8c3aeSJonathan Kim 67221889582SJonathan Kim for (i = 0; i < target->n_pdds; i++) { 67321889582SJonathan Kim struct kfd_process_device *pdd = target->pdds[i]; 67421889582SJonathan Kim 67521889582SJonathan Kim if (!kfd_dbg_is_per_vmid_supported(pdd->dev)) { 67621889582SJonathan Kim r = reserve_debug_trap_vmid(pdd->dev->dqm, &pdd->qpd); 67721889582SJonathan Kim 67821889582SJonathan Kim if (r) { 67921889582SJonathan Kim target->runtime_info.runtime_state = (r == -EBUSY) ? 68021889582SJonathan Kim DEBUG_RUNTIME_STATE_ENABLED_BUSY : 68121889582SJonathan Kim DEBUG_RUNTIME_STATE_ENABLED_ERROR; 68221889582SJonathan Kim 68321889582SJonathan Kim goto unwind_err; 68421889582SJonathan Kim } 68521889582SJonathan Kim } 68621889582SJonathan Kim 68721889582SJonathan Kim /* Disable GFX OFF to prevent garbage read/writes to debug registers. 68821889582SJonathan Kim * If RLC restore of debug registers is not supported and runtime enable 68921889582SJonathan Kim * hasn't done so already on ttmp setup request, restore the trap config registers. 69021889582SJonathan Kim * 69121889582SJonathan Kim * If RLC restore of debug registers is not supported, keep gfx off disabled for 69221889582SJonathan Kim * the debug session. 69321889582SJonathan Kim */ 69421889582SJonathan Kim amdgpu_gfx_off_ctrl(pdd->dev->adev, false); 69521889582SJonathan Kim if (!(kfd_dbg_is_rlc_restore_supported(pdd->dev) || 69621889582SJonathan Kim target->runtime_info.ttmp_setup)) 69721889582SJonathan Kim pdd->dev->kfd2kgd->enable_debug_trap(pdd->dev->adev, true, 69821889582SJonathan Kim pdd->dev->vm_info.last_vmid_kfd); 69921889582SJonathan Kim 70021889582SJonathan Kim pdd->spi_dbg_override = pdd->dev->kfd2kgd->enable_debug_trap( 70121889582SJonathan Kim pdd->dev->adev, 70221889582SJonathan Kim false, 70321889582SJonathan Kim pdd->dev->vm_info.last_vmid_kfd); 70421889582SJonathan Kim 70521889582SJonathan Kim if (kfd_dbg_is_rlc_restore_supported(pdd->dev)) 70621889582SJonathan Kim amdgpu_gfx_off_ctrl(pdd->dev->adev, true); 70721889582SJonathan Kim 70850cff45eSJay Cornwall /* 70950cff45eSJay Cornwall * Setting the debug flag in the trap handler requires that the TMA has been 71050cff45eSJay Cornwall * allocated, which occurs during CWSR initialization. 71150cff45eSJay Cornwall * In the event that CWSR has not been initialized at this point, setting the 71250cff45eSJay Cornwall * flag will be called again during CWSR initialization if the target process 71350cff45eSJay Cornwall * is still debug enabled. 71450cff45eSJay Cornwall */ 71550cff45eSJay Cornwall kfd_process_set_trap_debug_flag(&pdd->qpd, true); 71650cff45eSJay Cornwall 71721889582SJonathan Kim if (!pdd->dev->kfd->shared_resources.enable_mes) 71821889582SJonathan Kim r = debug_refresh_runlist(pdd->dev->dqm); 71921889582SJonathan Kim else 72021889582SJonathan Kim r = kfd_dbg_set_mes_debug_mode(pdd); 72121889582SJonathan Kim 72221889582SJonathan Kim if (r) { 72321889582SJonathan Kim target->runtime_info.runtime_state = 72421889582SJonathan Kim DEBUG_RUNTIME_STATE_ENABLED_ERROR; 72521889582SJonathan Kim goto unwind_err; 72621889582SJonathan Kim } 72721889582SJonathan Kim } 72821889582SJonathan Kim 72921889582SJonathan Kim return 0; 73021889582SJonathan Kim 73121889582SJonathan Kim unwind_err: 73221889582SJonathan Kim /* Enabling debug failed, we need to disable on 73321889582SJonathan Kim * all GPUs so the enable is all or nothing. 73421889582SJonathan Kim */ 73521889582SJonathan Kim kfd_dbg_trap_deactivate(target, true, i); 73621889582SJonathan Kim return r; 73721889582SJonathan Kim } 73821889582SJonathan Kim 7390ab2d753SJonathan Kim int kfd_dbg_trap_enable(struct kfd_process *target, uint32_t fd, 7400ab2d753SJonathan Kim void __user *runtime_info, uint32_t *runtime_size) 7410ab2d753SJonathan Kim { 7420ab2d753SJonathan Kim struct file *f; 7430ab2d753SJonathan Kim uint32_t copy_size; 74421889582SJonathan Kim int i, r = 0; 7450ab2d753SJonathan Kim 7460ab2d753SJonathan Kim if (target->debug_trap_enabled) 7470ab2d753SJonathan Kim return -EALREADY; 7480ab2d753SJonathan Kim 74921889582SJonathan Kim /* Enable pre-checks */ 75021889582SJonathan Kim for (i = 0; i < target->n_pdds; i++) { 75121889582SJonathan Kim struct kfd_process_device *pdd = target->pdds[i]; 75221889582SJonathan Kim 75321889582SJonathan Kim if (!KFD_IS_SOC15(pdd->dev)) 75421889582SJonathan Kim return -ENODEV; 75521889582SJonathan Kim 75621889582SJonathan Kim if (!kfd_dbg_has_gws_support(pdd->dev) && pdd->qpd.num_gws) 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 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 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 853101827e1SJonathan Kim r = kfd_dbg_set_mes_debug_mode(pdd); 854101827e1SJonathan Kim 855101827e1SJonathan Kim if (r) 856101827e1SJonathan Kim break; 857101827e1SJonathan Kim } 858101827e1SJonathan Kim 859101827e1SJonathan Kim return r; 860101827e1SJonathan Kim } 861101827e1SJonathan Kim 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 885aea1b473SJonathan Kim r = kfd_dbg_set_mes_debug_mode(pdd); 886aea1b473SJonathan Kim 887aea1b473SJonathan Kim if (r) 888aea1b473SJonathan Kim break; 889aea1b473SJonathan Kim } 890aea1b473SJonathan Kim 891aea1b473SJonathan Kim return r; 892aea1b473SJonathan Kim } 893aea1b473SJonathan Kim 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 1014*12976e6aSJonathan Kim int kfd_dbg_trap_device_snapshot(struct kfd_process *target, 1015*12976e6aSJonathan Kim uint64_t exception_clear_mask, 1016*12976e6aSJonathan Kim void __user *user_info, 1017*12976e6aSJonathan Kim uint32_t *number_of_device_infos, 1018*12976e6aSJonathan Kim uint32_t *entry_size) 1019*12976e6aSJonathan Kim { 1020*12976e6aSJonathan Kim struct kfd_dbg_device_info_entry device_info; 1021*12976e6aSJonathan Kim uint32_t tmp_entry_size = *entry_size, tmp_num_devices; 1022*12976e6aSJonathan Kim int i, r = 0; 1023*12976e6aSJonathan Kim 1024*12976e6aSJonathan Kim if (!(target && user_info && number_of_device_infos && entry_size)) 1025*12976e6aSJonathan Kim return -EINVAL; 1026*12976e6aSJonathan Kim 1027*12976e6aSJonathan Kim tmp_num_devices = min_t(size_t, *number_of_device_infos, target->n_pdds); 1028*12976e6aSJonathan Kim *number_of_device_infos = target->n_pdds; 1029*12976e6aSJonathan Kim *entry_size = min_t(size_t, *entry_size, sizeof(device_info)); 1030*12976e6aSJonathan Kim 1031*12976e6aSJonathan Kim if (!tmp_num_devices) 1032*12976e6aSJonathan Kim return 0; 1033*12976e6aSJonathan Kim 1034*12976e6aSJonathan Kim memset(&device_info, 0, sizeof(device_info)); 1035*12976e6aSJonathan Kim 1036*12976e6aSJonathan Kim mutex_lock(&target->event_mutex); 1037*12976e6aSJonathan Kim 1038*12976e6aSJonathan Kim /* Run over all pdd of the process */ 1039*12976e6aSJonathan Kim for (i = 0; i < tmp_num_devices; i++) { 1040*12976e6aSJonathan Kim struct kfd_process_device *pdd = target->pdds[i]; 1041*12976e6aSJonathan Kim struct kfd_topology_device *topo_dev = kfd_topology_device_by_id(pdd->dev->id); 1042*12976e6aSJonathan Kim 1043*12976e6aSJonathan Kim device_info.gpu_id = pdd->dev->id; 1044*12976e6aSJonathan Kim device_info.exception_status = pdd->exception_status; 1045*12976e6aSJonathan Kim device_info.lds_base = pdd->lds_base; 1046*12976e6aSJonathan Kim device_info.lds_limit = pdd->lds_limit; 1047*12976e6aSJonathan Kim device_info.scratch_base = pdd->scratch_base; 1048*12976e6aSJonathan Kim device_info.scratch_limit = pdd->scratch_limit; 1049*12976e6aSJonathan Kim device_info.gpuvm_base = pdd->gpuvm_base; 1050*12976e6aSJonathan Kim device_info.gpuvm_limit = pdd->gpuvm_limit; 1051*12976e6aSJonathan Kim device_info.location_id = topo_dev->node_props.location_id; 1052*12976e6aSJonathan Kim device_info.vendor_id = topo_dev->node_props.vendor_id; 1053*12976e6aSJonathan Kim device_info.device_id = topo_dev->node_props.device_id; 1054*12976e6aSJonathan Kim device_info.revision_id = pdd->dev->adev->pdev->revision; 1055*12976e6aSJonathan Kim device_info.subsystem_vendor_id = pdd->dev->adev->pdev->subsystem_vendor; 1056*12976e6aSJonathan Kim device_info.subsystem_device_id = pdd->dev->adev->pdev->subsystem_device; 1057*12976e6aSJonathan Kim device_info.fw_version = pdd->dev->kfd->mec_fw_version; 1058*12976e6aSJonathan Kim device_info.gfx_target_version = 1059*12976e6aSJonathan Kim topo_dev->node_props.gfx_target_version; 1060*12976e6aSJonathan Kim device_info.simd_count = topo_dev->node_props.simd_count; 1061*12976e6aSJonathan Kim device_info.max_waves_per_simd = 1062*12976e6aSJonathan Kim topo_dev->node_props.max_waves_per_simd; 1063*12976e6aSJonathan Kim device_info.array_count = topo_dev->node_props.array_count; 1064*12976e6aSJonathan Kim device_info.simd_arrays_per_engine = 1065*12976e6aSJonathan Kim topo_dev->node_props.simd_arrays_per_engine; 1066*12976e6aSJonathan Kim device_info.num_xcc = NUM_XCC(pdd->dev->xcc_mask); 1067*12976e6aSJonathan Kim device_info.capability = topo_dev->node_props.capability; 1068*12976e6aSJonathan Kim device_info.debug_prop = topo_dev->node_props.debug_prop; 1069*12976e6aSJonathan Kim 1070*12976e6aSJonathan Kim if (exception_clear_mask) 1071*12976e6aSJonathan Kim pdd->exception_status &= ~exception_clear_mask; 1072*12976e6aSJonathan Kim 1073*12976e6aSJonathan Kim if (copy_to_user(user_info, &device_info, *entry_size)) { 1074*12976e6aSJonathan Kim r = -EFAULT; 1075*12976e6aSJonathan Kim break; 1076*12976e6aSJonathan Kim } 1077*12976e6aSJonathan Kim 1078*12976e6aSJonathan Kim user_info += tmp_entry_size; 1079*12976e6aSJonathan Kim } 1080*12976e6aSJonathan Kim 1081*12976e6aSJonathan Kim mutex_unlock(&target->event_mutex); 1082*12976e6aSJonathan Kim 1083*12976e6aSJonathan Kim return r; 1084*12976e6aSJonathan Kim } 1085*12976e6aSJonathan Kim 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) { 1102e90bf919SJonathan Kim if (!pqn) 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