Skip to contentSkip to conversation

drm/amdkfd: support per-queue reset on gfx9

PATCH In review Jonathan Kim 2 participants 3 messages Jul 31, 2024

Subsystems (3)
lore
Share & tools
lore
#0 lore raw

PATCH 1/1 drm/amdkfd: support per-queue reset on gfx9

Support per-queue reset for GFX9. The recommendation is for the driver to target reset the HW queue via a SPI MMIO register write.

Since this requires pipe and HW queue info and MEC FW is limited to doorbell reports of hung queues after an unmap failure, scan the HW queue slots defined by SET_RESOURCES first to identify the user queue candidates to reset.

Only signal reset events to processes that have had a queue reset.

If queue reset fails, fall back to GPU reset.

v3: address nitpicks
- handle hang detect buffer ENOMEM
- warn on multiple detect hang misuse
- reset hang detect buffer to NULL on free
- update DRM_ERR on reset to drm_err app warning message

v2: move reset queue flag for house keeping to process device. split detect and reset into separate functions.
make reset call safe during power saving modes. clean up some other nitpicks.

---
 .../drm/amd/amdgpu/amdgpu_amdkfd_aldebaran.c  |   2 +
 .../drm/amd/amdgpu/amdgpu_amdkfd_arcturus.c   |   4 +-
 .../drm/amd/amdgpu/amdgpu_amdkfd_gc_9_4_3.c   |   4 +-
 .../drm/amd/amdgpu/amdgpu_amdkfd_gfx_v10.c    |  16 ++
 .../drm/amd/amdgpu/amdgpu_amdkfd_gfx_v10.h    |   9 +
 .../drm/amd/amdgpu/amdgpu_amdkfd_gfx_v10_3.c  |   4 +-
 .../drm/amd/amdgpu/amdgpu_amdkfd_gfx_v11.c    |  18 +-
 .../gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v9.c |  85 ++++++++
 .../gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v9.h |   9 +
 .../drm/amd/amdkfd/kfd_device_queue_manager.c | 184 +++++++++++++++++-
 .../drm/amd/amdkfd/kfd_device_queue_manager.h |  12 ++
 drivers/gpu/drm/amd/amdkfd/kfd_events.c       |  22 +++
 .../gpu/drm/amd/amdkfd/kfd_mqd_manager_v9.c   |   6 +-
 drivers/gpu/drm/amd/amdkfd/kfd_priv.h         |   3 +
 drivers/gpu/drm/amd/amdkfd/kfd_process.c      |   2 +
 .../gpu/drm/amd/include/kgd_kfd_interface.h   |   6 +
 16 files changed, 373 insertions(+), 13 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_aldebaran.c +2 -0
index aff08321e976..8dfdb18197c4 100644
@@ -191,4 +191,6 @@ const struct kfd2kgd_calls aldebaran_kfd2kgd = {
 	.get_iq_wait_times = kgd_gfx_v9_get_iq_wait_times,
 	.build_grace_period_packet_info = kgd_gfx_v9_build_grace_period_packet_info,
 	.program_trap_handler_settings = kgd_gfx_v9_program_trap_handler_settings,
+	.hqd_get_pq_addr = kgd_gfx_v9_hqd_get_pq_addr,
+	.hqd_reset = kgd_gfx_v9_hqd_reset,
 };
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_arcturus.c +3 -1
index 3a3f3ce09f00..017e8a3013aa 100644
@@ -418,5 +418,7 @@ const struct kfd2kgd_calls arcturus_kfd2kgd = {
 	.get_iq_wait_times = kgd_gfx_v9_get_iq_wait_times,
 	.build_grace_period_packet_info = kgd_gfx_v9_build_grace_period_packet_info,
 	.get_cu_occupancy = kgd_gfx_v9_get_cu_occupancy,
-	.program_trap_handler_settings = kgd_gfx_v9_program_trap_handler_settings
+	.program_trap_handler_settings = kgd_gfx_v9_program_trap_handler_settings,
+	.hqd_get_pq_addr = kgd_gfx_v9_hqd_get_pq_addr,
+	.hqd_reset = kgd_gfx_v9_hqd_reset
 };
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gc_9_4_3.c +3 -1
index a5c7259cf2a3..e2ae714a700f 100644
@@ -541,5 +541,7 @@ const struct kfd2kgd_calls gc_9_4_3_kfd2kgd = {
 			kgd_gfx_v9_4_3_set_wave_launch_trap_override,
 	.set_wave_launch_mode = kgd_aldebaran_set_wave_launch_mode,
 	.set_address_watch = kgd_gfx_v9_4_3_set_address_watch,
-	.clear_address_watch = kgd_gfx_v9_4_3_clear_address_watch
+	.clear_address_watch = kgd_gfx_v9_4_3_clear_address_watch,
+	.hqd_get_pq_addr = kgd_gfx_v9_hqd_get_pq_addr,
+	.hqd_reset = kgd_gfx_v9_hqd_reset
 };
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v10.c +16 -0
index 3ab6c3aa0ad1..62176d607bef 100644
@@ -1070,6 +1070,20 @@ static void program_trap_handler_settings(struct amdgpu_device *adev,
 	unlock_srbm(adev);
 }
 
+uint64_t kgd_gfx_v10_hqd_get_pq_addr(struct amdgpu_device *adev,
+				     uint32_t pipe_id, uint32_t queue_id,
+				     uint32_t inst)
+{
+	return 0;
+}
+
+uint64_t kgd_gfx_v10_hqd_reset(struct amdgpu_device *adev,
+			       uint32_t pipe_id, uint32_t queue_id,
+			       uint32_t inst, unsigned int utimeout)
+{
+	return 0;
+}
+
 const struct kfd2kgd_calls gfx_v10_kfd2kgd = {
 	.program_sh_mem_settings = kgd_program_sh_mem_settings,
 	.set_pasid_vmid_mapping = kgd_set_pasid_vmid_mapping,
@@ -1097,4 +1111,6 @@ const struct kfd2kgd_calls gfx_v10_kfd2kgd = {
 	.get_iq_wait_times = kgd_gfx_v10_get_iq_wait_times,
 	.build_grace_period_packet_info = kgd_gfx_v10_build_grace_period_packet_info,
 	.program_trap_handler_settings = program_trap_handler_settings,
+	.hqd_get_pq_addr = kgd_gfx_v10_hqd_get_pq_addr,
+	.hqd_reset = kgd_gfx_v10_hqd_reset
 };
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v10.h +9 -0
index 67bcaa3d4226..9efd2dd4fdd7 100644
@@ -56,3 +56,12 @@ void kgd_gfx_v10_build_grace_period_packet_info(struct amdgpu_device *adev,
 					       uint32_t grace_period,
 					       uint32_t *reg_offset,
 					       uint32_t *reg_data);
+uint64_t kgd_gfx_v10_hqd_get_pq_addr(struct amdgpu_device *adev,
+				    uint32_t pipe_id,
+				    uint32_t queue_id,
+				    uint32_t inst);
+uint64_t kgd_gfx_v10_hqd_reset(struct amdgpu_device *adev,
+			      uint32_t pipe_id,
+			      uint32_t queue_id,
+			      uint32_t inst,
+			      unsigned int utimeout);
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v10_3.c +3 -1
index 8c8437a4383f..c718bedda0ca 100644
@@ -680,5 +680,7 @@ const struct kfd2kgd_calls gfx_v10_3_kfd2kgd = {
 	.set_wave_launch_trap_override = kgd_gfx_v10_set_wave_launch_trap_override,
 	.set_wave_launch_mode = kgd_gfx_v10_set_wave_launch_mode,
 	.set_address_watch = kgd_gfx_v10_set_address_watch,
-	.clear_address_watch = kgd_gfx_v10_clear_address_watch
+	.clear_address_watch = kgd_gfx_v10_clear_address_watch,
+	.hqd_get_pq_addr = kgd_gfx_v10_hqd_get_pq_addr,
+	.hqd_reset = kgd_gfx_v10_hqd_reset
 };
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v11.c +17 -1
index b61a32d6af4b..a4ba49cb22db 100644
@@ -786,6 +786,20 @@ static uint32_t kgd_gfx_v11_clear_address_watch(struct amdgpu_device *adev,
 	return 0;
 }
 
+static uint64_t kgd_gfx_v11_hqd_get_pq_addr(struct amdgpu_device *adev,
+					    uint32_t pipe_id, uint32_t queue_id,
+					    uint32_t inst)
+{
+	return 0;
+}
+
+static uint64_t kgd_gfx_v11_hqd_reset(struct amdgpu_device *adev,
+				      uint32_t pipe_id, uint32_t queue_id,
+				      uint32_t inst, unsigned int utimeout)
+{
+	return 0;
+}
+
 const struct kfd2kgd_calls gfx_v11_kfd2kgd = {
 	.program_sh_mem_settings = program_sh_mem_settings_v11,
 	.set_pasid_vmid_mapping = set_pasid_vmid_mapping_v11,
@@ -808,5 +822,7 @@ const struct kfd2kgd_calls gfx_v11_kfd2kgd = {
 	.set_wave_launch_trap_override = kgd_gfx_v11_set_wave_launch_trap_override,
 	.set_wave_launch_mode = kgd_gfx_v11_set_wave_launch_mode,
 	.set_address_watch = kgd_gfx_v11_set_address_watch,
-	.clear_address_watch = kgd_gfx_v11_clear_address_watch
+	.clear_address_watch = kgd_gfx_v11_clear_address_watch,
+	.hqd_get_pq_addr = kgd_gfx_v11_hqd_get_pq_addr,
+	.hqd_reset = kgd_gfx_v11_hqd_reset
 };
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v9.c +85 -0

95 lines not on this page · raw message

drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v9.h +9 -0
index ce424615f59b..988c50ac3be0 100644
@@ -101,3 +101,12 @@ void kgd_gfx_v9_build_grace_period_packet_info(struct amdgpu_device *adev,
 					       uint32_t grace_period,
 					       uint32_t *reg_offset,
 					       uint32_t *reg_data);
+uint64_t kgd_gfx_v9_hqd_get_pq_addr(struct amdgpu_device *adev,
+				    uint32_t pipe_id,
+				    uint32_t queue_id,
+				    uint32_t inst);
+uint64_t kgd_gfx_v9_hqd_reset(struct amdgpu_device *adev,
+			      uint32_t pipe_id,
+			      uint32_t queue_id,
+			      uint32_t inst,
+			      unsigned int utimeout);
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +176 -8

235 lines not on this page · raw message

drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.h +12 -0
index 3b9b8eabaacc..dfb36a246637 100644
@@ -210,6 +210,13 @@ struct device_queue_manager_asic_ops {
 				 struct kfd_node *dev);
 };
 
+struct dqm_detect_hang_info {
+	int pipe_id;
+	int queue_id;
+	int xcc_id;
+	uint64_t queue_address;
+};
+
 /**
  * struct device_queue_manager
  *
@@ -264,6 +271,11 @@ struct device_queue_manager {
 	uint32_t		wait_times;
 
 	wait_queue_head_t	destroy_wait;
+
+	/* for per-queue reset support */
+	struct dqm_detect_hang_info *detect_hang_info;
+	size_t detect_hang_info_size;
+	int detect_hang_count;
 };
 
 void device_queue_manager_init_cik(
drivers/gpu/drm/amd/amdkfd/kfd_events.c +22 -0
index 9b33d9d2c9ad..9393ddc2e828 100644
@@ -31,6 +31,7 @@
 #include <linux/memory.h>
 #include "kfd_priv.h"
 #include "kfd_events.h"
+#include "kfd_device_queue_manager.h"
 #include <linux/device.h>
 
 /*
@@ -1244,12 +1245,33 @@ void kfd_signal_reset_event(struct kfd_node *dev)
 	idx = srcu_read_lock(&kfd_processes_srcu);
 	hash_for_each_rcu(kfd_processes_table, temp, p, kfd_processes) {
 		int user_gpu_id = kfd_process_get_user_gpu_id(p, dev->id);
+		struct kfd_process_device *pdd = kfd_get_process_device_data(dev, p);
 
 		if (unlikely(user_gpu_id == -EINVAL)) {
 			WARN_ONCE(1, "Could not get user_gpu_id from dev->id:%x\n", dev->id);
 			continue;
 		}
 
+		if (unlikely(!pdd)) {
+			WARN_ONCE(1, "Could not get device data from pasid:0x%x\n", p->pasid);
+			continue;
+		}
+
+		if (dev->dqm->detect_hang_count && !pdd->has_reset_queue)
+			continue;
+
+		if (dev->dqm->detect_hang_count) {
+			struct amdgpu_task_info *ti;
+
+			ti = amdgpu_vm_get_task_info_pasid(dev->adev, p->pasid);
+			if (ti) {
+				drm_err(&dev->adev->ddev,
+					"Queues reset on process %s tid %d thread %s pid %d\n",
+					ti->process_name, ti->tgid, ti->task_name, ti->pid);
+				amdgpu_vm_put_task_info(ti);
+			}
+		}
+
 		rcu_read_lock();
 
 		id = KFD_FIRST_NONSIGNAL_EVENT_ID;
drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_v9.c +5 -1
index 66c73825c0a0..84e8ea3a8a0c 100644
@@ -321,8 +321,11 @@ static void update_mqd(struct mqd_manager *mm, void *mqd,
 static bool check_preemption_failed(struct mqd_manager *mm, void *mqd)
 {
 	struct v9_mqd *m = (struct v9_mqd *)mqd;
+	uint32_t doorbell_id = m->queue_doorbell_id0;
 
-	return kfd_check_hiq_mqd_doorbell_id(mm->dev, m->queue_doorbell_id0, 0);
+	m->queue_doorbell_id0 = 0;
+
+	return kfd_check_hiq_mqd_doorbell_id(mm->dev, doorbell_id, 0);
 }
 
 static int get_wave_state(struct mqd_manager *mm, void *mqd,
@@ -624,6 +627,7 @@ static bool check_preemption_failed_v9_4_3(struct mqd_manager *mm, void *mqd)
 		m = get_mqd(mqd + hiq_mqd_size * inst);
 		ret |= kfd_check_hiq_mqd_doorbell_id(mm->dev,
 					m->queue_doorbell_id0, inst);
+		m->queue_doorbell_id0 = 0;
 		++inst;
 	}
 
drivers/gpu/drm/amd/amdkfd/kfd_priv.h +3 -0
index b5cae48dff66..892a85408c09 100644
@@ -843,6 +843,9 @@ struct kfd_process_device {
 	void *proc_ctx_bo;
 	uint64_t proc_ctx_gpu_addr;
 	void *proc_ctx_cpu_ptr;
+
+	/* Tracks queue reset status */
+	bool has_reset_queue;
 };
 
 #define qpd_to_pdd(x) container_of(x, struct kfd_process_device, qpd)
drivers/gpu/drm/amd/amdkfd/kfd_process.c +2 -0
index 9e29b92eb523..a902950cc060 100644
@@ -1851,6 +1851,8 @@ int kfd_process_evict_queues(struct kfd_process *p, uint32_t trigger)
 			goto fail;
 		}
 		n_evicted++;
+
+		pdd->dev->dqm->is_hws_hang = false;
 	}
 
 	return r;
drivers/gpu/drm/amd/include/kgd_kfd_interface.h +6 -0
index 6d094cf3587d..7744ca3ef4b1 100644
@@ -318,6 +318,12 @@ struct kfd2kgd_calls {
 	void (*program_trap_handler_settings)(struct amdgpu_device *adev,
 			uint32_t vmid, uint64_t tba_addr, uint64_t tma_addr,
 			uint32_t inst);
+	uint64_t (*hqd_get_pq_addr)(struct amdgpu_device *adev,
+				    uint32_t pipe_id, uint32_t queue_id,
+				    uint32_t inst);
+	uint64_t (*hqd_reset)(struct amdgpu_device *adev,
+			      uint32_t pipe_id, uint32_t queue_id,
+			      uint32_t inst, unsigned int utimeout);
 };
 
 #endif	/* KGD_KFD_INTERFACE_H_INCLUDED */
Signature · 1 line
2.34.1
maintainer Reviewed-by on v1 1/1
#1 lore raw
Quoted 10 lines · Jonathan Kim

Support per-queue reset for GFX9. The recommendation is for the driver to target reset the HW queue via a SPI MMIO register write.

Since this requires pipe and HW queue info and MEC FW is limited to doorbell reports of hung queues after an unmap failure, scan the HW queue slots defined by SET_RESOURCES first to identify the user queue candidates to reset.

Only signal reset events to processes that have had a queue reset.

Quoted 7 lines

If queue reset fails, fall back to GPU reset.

v3: address nitpicks
- handle hang detect buffer ENOMEM
- warn on multiple detect hang misuse
- reset hang detect buffer to NULL on free
- update DRM_ERR on reset to drm_err app warning message

I meant dev_err here to make sure we print the device identifier. That's what we mostly use in KFD. If drm_err does the same, that's fine, too. Looking at the definitions in drm_print.h, the only thing that drm_err adds is a "[drm]" tag in the message.

See one more comment inline.

Quoted 7 lines

v2: move reset queue flag for house keeping to process device. split detect and reset into separate functions.
make reset call safe during power saving modes. clean up some other nitpicks.

[snip]

@@ -1929,6 +1966,135 @@ static int map_queues_cpsch(struct device_queue_manager *dqm)

drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c static int map_queues_cpsch(struct device_queue_manager *dqm) · line 1975

Quoted 10 lines
  	return retval;
  }
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +7 -0
+static void set_queue_as_reset(struct device_queue_manager *dqm, struct queue *q,
+			       struct qcm_process_device *qpd)
+{
+	struct kfd_process_device *pdd = qpd_to_pdd(qpd);
+
+	pr_err("queue id 0x%0x at pasid 0x%0x is reset\n",
+	       q->properties.queue_id, q->process->pasid);

This could also be a dev_err(dqm->dev->adev->dev, ...) or drm_err(dqm->dev->adev->ddev, ...). With that fixed, the patch is

Quoted 300 lines
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +131 -7
+
+	pdd->has_reset_queue = true;
+	if (q->properties.is_active) {
+		q->properties.is_active = false;
+		decrement_queue_count(dqm, qpd, q);
+	}
+}
+
+static int detect_queue_hang(struct device_queue_manager *dqm)
+{
+	int i;
+
+	/* detect should be used only in dqm locked queue reset */
+	if (WARN_ON(dqm->detect_hang_count > 0))
+		return 0;
+
+	memset(dqm->detect_hang_info, 0, dqm->detect_hang_info_size);
+
+	for (i = 0; i < AMDGPU_MAX_QUEUES; ++i) {
+		uint32_t mec, pipe, queue;
+		int xcc_id;
+
+		mec = (i / dqm->dev->kfd->shared_resources.num_queue_per_pipe)
+			/ dqm->dev->kfd->shared_resources.num_pipe_per_mec;
+
+		if (mec || !test_bit(i, dqm->dev->kfd->shared_resources.cp_queue_bitmap))
+			continue;
+
+		amdgpu_queue_mask_bit_to_mec_queue(dqm->dev->adev, i, &mec, &pipe, &queue);
+
+		for_each_inst(xcc_id, dqm->dev->xcc_mask) {
+			uint64_t queue_addr = dqm->dev->kfd2kgd->hqd_get_pq_addr(
+						dqm->dev->adev, pipe, queue, xcc_id);
+			struct dqm_detect_hang_info hang_info;
+
+			if (!queue_addr)
+				continue;
+
+			hang_info.pipe_id = pipe;
+			hang_info.queue_id = queue;
+			hang_info.xcc_id = xcc_id;
+			hang_info.queue_address = queue_addr;
+
+			dqm->detect_hang_info[dqm->detect_hang_count] = hang_info;
+			dqm->detect_hang_count++;
+		}
+	}
+
+	return dqm->detect_hang_count;
+}
+
+static struct queue *find_queue_by_address(struct device_queue_manager *dqm, uint64_t queue_address)
+{
+	struct device_process_node *cur;
+	struct qcm_process_device *qpd;
+	struct queue *q;
+
+	list_for_each_entry(cur, &dqm->queues, list) {
+		qpd = cur->qpd;
+		list_for_each_entry(q, &qpd->queues_list, list) {
+			if (queue_address == q->properties.queue_address)
+				return q;
+		}
+	}
+
+	return NULL;
+}
+
+/* only for compute queue */
+static int reset_queues_on_hws_hang(struct device_queue_manager *dqm)
+{
+	int r = 0, reset_count = 0, i;
+
+	if (!dqm->detect_hang_info || dqm->is_hws_hang)
+		return -EIO;
+
+	/* assume dqm locked. */
+	if (!detect_queue_hang(dqm))
+		return -ENOTRECOVERABLE;
+
+	for (i = 0; i < dqm->detect_hang_count; i++) {
+		struct dqm_detect_hang_info hang_info = dqm->detect_hang_info[i];
+		struct queue *q = find_queue_by_address(dqm, hang_info.queue_address);
+		struct kfd_process_device *pdd;
+		uint64_t queue_addr = 0;
+
+		if (!q) {
+			r = -ENOTRECOVERABLE;
+			goto reset_fail;
+		}
+
+		pdd = kfd_get_process_device_data(dqm->dev, q->process);
+		if (!pdd) {
+			r = -ENOTRECOVERABLE;
+			goto reset_fail;
+		}
+
+		queue_addr = dqm->dev->kfd2kgd->hqd_reset(dqm->dev->adev,
+				hang_info.pipe_id, hang_info.queue_id, hang_info.xcc_id,
+				KFD_UNMAP_LATENCY_MS);
+
+		/* either reset failed or we reset an unexpected queue. */
+		if (queue_addr != q->properties.queue_address) {
+			r = -ENOTRECOVERABLE;
+			goto reset_fail;
+		}
+
+		set_queue_as_reset(dqm, q, &pdd->qpd);
+		reset_count++;
+	}
+
+	if (reset_count == dqm->detect_hang_count)
+		kfd_signal_reset_event(dqm->dev);
+	else
+		r = -ENOTRECOVERABLE;
+
+reset_fail:
+	dqm->detect_hang_count = 0;
+
+	return r;
+}
+
  /* dqm->lock mutex has to be locked before calling this function */
  static int unmap_queues_cpsch(struct device_queue_manager *dqm,
  				enum kfd_unmap_queues_filter filter,
@@ -1979,11 +2145,14 @@ static int unmap_queues_cpsch(struct device_queue_manager *dqm,
  	 */
  	mqd_mgr = dqm->mqd_mgrs[KFD_MQD_TYPE_HIQ];
  	if (mqd_mgr->check_preemption_failed(mqd_mgr, dqm->packet_mgr.priv_queue->queue->mqd)) {
-		while (halt_if_hws_hang)
-			schedule();
-		kfd_hws_hang(dqm);
-		retval = -ETIME;
-		goto out;
+		if (reset_queues_on_hws_hang(dqm)) {
+			while (halt_if_hws_hang)
+				schedule();
+			dqm->is_hws_hang = true;
+			kfd_hws_hang(dqm);
+			retval = -ETIME;
+			goto out;
+		}
  	}
 
  	/* We need to reset the grace period value for this device */
@@ -2002,8 +2171,7 @@ static int unmap_queues_cpsch(struct device_queue_manager *dqm,
  }
 
  /* only for compute queue */
-static int reset_queues_cpsch(struct device_queue_manager *dqm,
-			uint16_t pasid)
+static int reset_queues_cpsch(struct device_queue_manager *dqm, uint16_t pasid)
  {
  	int retval;
 
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.h +12 -0
index 3b9b8eabaacc..dfb36a246637 100644
@@ -210,6 +210,13 @@ struct device_queue_manager_asic_ops {
  				 struct kfd_node *dev);
  };
 
+struct dqm_detect_hang_info {
+	int pipe_id;
+	int queue_id;
+	int xcc_id;
+	uint64_t queue_address;
+};
+
  /**
   * struct device_queue_manager
   *
@@ -264,6 +271,11 @@ struct device_queue_manager {
  	uint32_t		wait_times;
 
  	wait_queue_head_t	destroy_wait;
+
+	/* for per-queue reset support */
+	struct dqm_detect_hang_info *detect_hang_info;
+	size_t detect_hang_info_size;
+	int detect_hang_count;
  };
 
  void device_queue_manager_init_cik(
drivers/gpu/drm/amd/amdkfd/kfd_events.c +22 -0
index 9b33d9d2c9ad..9393ddc2e828 100644
@@ -31,6 +31,7 @@
  #include <linux/memory.h>
  #include "kfd_priv.h"
  #include "kfd_events.h"
+#include "kfd_device_queue_manager.h"
  #include <linux/device.h>
 
  /*
@@ -1244,12 +1245,33 @@ void kfd_signal_reset_event(struct kfd_node *dev)
  	idx = srcu_read_lock(&kfd_processes_srcu);
  	hash_for_each_rcu(kfd_processes_table, temp, p, kfd_processes) {
  		int user_gpu_id = kfd_process_get_user_gpu_id(p, dev->id);
+		struct kfd_process_device *pdd = kfd_get_process_device_data(dev, p);
 
  		if (unlikely(user_gpu_id == -EINVAL)) {
  			WARN_ONCE(1, "Could not get user_gpu_id from dev->id:%x\n", dev->id);
  			continue;
  		}
 
+		if (unlikely(!pdd)) {
+			WARN_ONCE(1, "Could not get device data from pasid:0x%x\n", p->pasid);
+			continue;
+		}
+
+		if (dev->dqm->detect_hang_count && !pdd->has_reset_queue)
+			continue;
+
+		if (dev->dqm->detect_hang_count) {
+			struct amdgpu_task_info *ti;
+
+			ti = amdgpu_vm_get_task_info_pasid(dev->adev, p->pasid);
+			if (ti) {
+				drm_err(&dev->adev->ddev,
+					"Queues reset on process %s tid %d thread %s pid %d\n",
+					ti->process_name, ti->tgid, ti->task_name, ti->pid);
+				amdgpu_vm_put_task_info(ti);
+			}
+		}
+
  		rcu_read_lock();
 
  		id = KFD_FIRST_NONSIGNAL_EVENT_ID;
drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_v9.c +5 -1
index 66c73825c0a0..84e8ea3a8a0c 100644
@@ -321,8 +321,11 @@ static void update_mqd(struct mqd_manager *mm, void *mqd,
  static bool check_preemption_failed(struct mqd_manager *mm, void *mqd)
  {
  	struct v9_mqd *m = (struct v9_mqd *)mqd;
+	uint32_t doorbell_id = m->queue_doorbell_id0;
 
-	return kfd_check_hiq_mqd_doorbell_id(mm->dev, m->queue_doorbell_id0, 0);
+	m->queue_doorbell_id0 = 0;
+
+	return kfd_check_hiq_mqd_doorbell_id(mm->dev, doorbell_id, 0);
  }
 
  static int get_wave_state(struct mqd_manager *mm, void *mqd,
@@ -624,6 +627,7 @@ static bool check_preemption_failed_v9_4_3(struct mqd_manager *mm, void *mqd)
  		m = get_mqd(mqd + hiq_mqd_size * inst);
  		ret |= kfd_check_hiq_mqd_doorbell_id(mm->dev,
  					m->queue_doorbell_id0, inst);
+		m->queue_doorbell_id0 = 0;
  		++inst;
  	}
 
drivers/gpu/drm/amd/amdkfd/kfd_priv.h +3 -0
index b5cae48dff66..892a85408c09 100644
@@ -843,6 +843,9 @@ struct kfd_process_device {
  	void *proc_ctx_bo;
  	uint64_t proc_ctx_gpu_addr;
  	void *proc_ctx_cpu_ptr;
+
+	/* Tracks queue reset status */
+	bool has_reset_queue;
  };
 
  #define qpd_to_pdd(x) container_of(x, struct kfd_process_device, qpd)
drivers/gpu/drm/amd/amdkfd/kfd_process.c +2 -0
index 9e29b92eb523..a902950cc060 100644
@@ -1851,6 +1851,8 @@ int kfd_process_evict_queues(struct kfd_process *p, uint32_t trigger)
  			goto fail;
  		}
  		n_evicted++;
+
+		pdd->dev->dqm->is_hws_hang = false;
  	}
 
  	return r;
drivers/gpu/drm/amd/include/kgd_kfd_interface.h +6 -0
index 6d094cf3587d..7744ca3ef4b1 100644
@@ -318,6 +318,12 @@ struct kfd2kgd_calls {
  	void (*program_trap_handler_settings)(struct amdgpu_device *adev,
  			uint32_t vmid, uint64_t tba_addr, uint64_t tma_addr,
  			uint32_t inst);
+	uint64_t (*hqd_get_pq_addr)(struct amdgpu_device *adev,
+				    uint32_t pipe_id, uint32_t queue_id,
+				    uint32_t inst);
+	uint64_t (*hqd_reset)(struct amdgpu_device *adev,
+			      uint32_t pipe_id, uint32_t queue_id,
+			      uint32_t inst, unsigned int utimeout);
  };
 
  #endif	/* KGD_KFD_INTERFACE_H_INCLUDED */
#2 lore raw

[Public]

Quoted 62 lines

-----Original Message-----
From: Kuehling, Felix <[email protected]>
Sent: Wednesday, July 31, 2024 11:45 AM
To: Kim, Jonathan <[email protected]>; [email protected]
Cc: Deucher, Alexander <[email protected]>
Subject: Re: [PATCH] drm/amdkfd: support per-queue reset on gfx9

Quoted 10 lines · Jonathan Kim

Support per-queue reset for GFX9. The recommendation is for the driver to target reset the HW queue via a SPI MMIO register write.

Since this requires pipe and HW queue info and MEC FW is limited to doorbell reports of hung queues after an unmap failure, scan the HW queue slots defined by SET_RESOURCES first to identify the user queue candidates to reset.

Only signal reset events to processes that have had a queue reset.

Quoted 7 lines

If queue reset fails, fall back to GPU reset.

v3: address nitpicks
- handle hang detect buffer ENOMEM
- warn on multiple detect hang misuse
- reset hang detect buffer to NULL on free
- update DRM_ERR on reset to drm_err app warning message

I meant dev_err here to make sure we print the device identifier. That's what we mostly use in KFD. If drm_err does the same, that's fine, too. Looking at the definitions in drm_print.h, the only thing that drm_err adds is a "[drm]" tag in the message.

See one more comment inline.

Quoted 7 lines

v2: move reset queue flag for house keeping to process device. split detect and reset into separate functions.
make reset call safe during power saving modes. clean up some other nitpicks.

[snip]

(quoted diff) +0 -0
@@ -1929,6 +1966,135 @@ static int map_queues_cpsch(struct
 device_queue_manager *dqm)
 >     return retval;
 >   }
Quoted 2 lines

+static void set_queue_as_reset(struct device_queue_manager *dqm, struct

queue *q,

drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c static int map_queues_cpsch(struct device_queue_manager *dqm) · line 1975

Quoted 6 lines
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +6 -0
+                          struct qcm_process_device *qpd)
+{
+   struct kfd_process_device *pdd = qpd_to_pdd(qpd);
+
+   pr_err("queue id 0x%0x at pasid 0x%0x is reset\n",
+          q->properties.queue_id, q->process->pasid);

This could also be a dev_err(dqm->dev->adev->dev, ...) or drm_err(dqm->dev->adev->ddev, ...). With that fixed, the patch is

Quoted 1 line

Done. Changed both to dev_err. Thanks for the review.

Jon

Quoted 338 lines
Quoted 31 lines
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +23 -0
+
+   pdd->has_reset_queue = true;
+   if (q->properties.is_active) {
+           q->properties.is_active = false;
+           decrement_queue_count(dqm, qpd, q);
+   }
+}
+
+static int detect_queue_hang(struct device_queue_manager *dqm)
+{
+   int i;
+
+   /* detect should be used only in dqm locked queue reset */
+   if (WARN_ON(dqm->detect_hang_count > 0))
+           return 0;
+
+   memset(dqm->detect_hang_info, 0, dqm->detect_hang_info_size);
+
+   for (i = 0; i < AMDGPU_MAX_QUEUES; ++i) {
+           uint32_t mec, pipe, queue;
+           int xcc_id;
+
+           mec = (i / dqm->dev->kfd-

shared_resources.num_queue_per_pipe)
+ / dqm->dev->kfd-
shared_resources.num_pipe_per_mec;

(quoted diff) +2 -0
+
+           if (mec || !test_bit(i, dqm->dev->kfd-

shared_resources.cp_queue_bitmap))

drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c static int map_queues_cpsch(struct device_queue_manager *dqm)

Quoted 3 lines
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +3 -0
+                   continue;
+
+           amdgpu_queue_mask_bit_to_mec_queue(dqm->dev->adev,

i, &mec, &pipe, &queue);

Quoted 5 lines
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +3 -0
+
+           for_each_inst(xcc_id, dqm->dev->xcc_mask) {
+                   uint64_t queue_addr = dqm->dev->kfd2kgd-

hqd_get_pq_addr(
+ dqm->dev->adev, pipe,

queue, xcc_id);

drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c static int map_queues_cpsch(struct device_queue_manager *dqm)

Quoted 11 lines
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +11 -0
+                   struct dqm_detect_hang_info hang_info;
+
+                   if (!queue_addr)
+                           continue;
+
+                   hang_info.pipe_id = pipe;
+                   hang_info.queue_id = queue;
+                   hang_info.xcc_id = xcc_id;
+                   hang_info.queue_address = queue_addr;
+
+                   dqm->detect_hang_info[dqm->detect_hang_count] =

hang_info;

drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c static int map_queues_cpsch(struct device_queue_manager *dqm)

Quoted 8 lines
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +8 -0
+                   dqm->detect_hang_count++;
+           }
+   }
+
+   return dqm->detect_hang_count;
+}
+
+static struct queue *find_queue_by_address(struct device_queue_manager

*dqm, uint64_t queue_address)

Quoted 8 lines
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +8 -0
+{
+   struct device_process_node *cur;
+   struct qcm_process_device *qpd;
+   struct queue *q;
+
+   list_for_each_entry(cur, &dqm->queues, list) {
+           qpd = cur->qpd;
+           list_for_each_entry(q, &qpd->queues_list, list) {

drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c static int map_queues_cpsch(struct device_queue_manager *dqm)

Quoted 10 lines
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +10 -0
+                   if (queue_address == q->properties.queue_address)
+                           return q;
+           }
+   }
+
+   return NULL;
+}
+
+/* only for compute queue */
+static int reset_queues_on_hws_hang(struct device_queue_manager

*dqm)

Quoted 12 lines
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +12 -0
+{
+   int r = 0, reset_count = 0, i;
+
+   if (!dqm->detect_hang_info || dqm->is_hws_hang)
+           return -EIO;
+
+   /* assume dqm locked. */
+   if (!detect_queue_hang(dqm))
+           return -ENOTRECOVERABLE;
+
+   for (i = 0; i < dqm->detect_hang_count; i++) {
+           struct dqm_detect_hang_info hang_info = dqm-
Quoted 2 lines

detect_hang_info[i];
+ struct queue *q = find_queue_by_address(dqm,

hang_info.queue_address);

Quoted 15 lines
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +15 -0
+           struct kfd_process_device *pdd;
+           uint64_t queue_addr = 0;
+
+           if (!q) {
+                   r = -ENOTRECOVERABLE;
+                   goto reset_fail;
+           }
+
+           pdd = kfd_get_process_device_data(dqm->dev, q->process);
+           if (!pdd) {
+                   r = -ENOTRECOVERABLE;
+                   goto reset_fail;
+           }
+
+           queue_addr = dqm->dev->kfd2kgd->hqd_reset(dqm->dev-
Quoted 2 lines

adev,
+ hang_info.pipe_id, hang_info.queue_id,

hang_info.xcc_id,

drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c static int unmap_queues_cpsch(struct

Quoted 27 lines
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +23 -0
+                           KFD_UNMAP_LATENCY_MS);
+
+           /* either reset failed or we reset an unexpected queue. */
+           if (queue_addr != q->properties.queue_address) {
+                   r = -ENOTRECOVERABLE;
+                   goto reset_fail;
+           }
+
+           set_queue_as_reset(dqm, q, &pdd->qpd);
+           reset_count++;
+   }
+
+   if (reset_count == dqm->detect_hang_count)
+           kfd_signal_reset_event(dqm->dev);
+   else
+           r = -ENOTRECOVERABLE;
+
+reset_fail:
+   dqm->detect_hang_count = 0;
+
+   return r;
+}
+
  /* dqm->lock mutex has to be locked before calling this function */
  static int unmap_queues_cpsch(struct device_queue_manager *dqm,
                            enum kfd_unmap_queues_filter filter,
@@ -1979,11 +2145,14 @@ static int unmap_queues_cpsch(struct

device_queue_manager *dqm,

Review static int unmap_queues_cpsch(struct

Quoted 21 lines
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +8 -5
     */
    mqd_mgr = dqm->mqd_mgrs[KFD_MQD_TYPE_HIQ];
    if (mqd_mgr->check_preemption_failed(mqd_mgr, dqm-
 packet_mgr.priv_queue->queue->mqd)) {
-           while (halt_if_hws_hang)
-                   schedule();
-           kfd_hws_hang(dqm);
-           retval = -ETIME;
-           goto out;
+           if (reset_queues_on_hws_hang(dqm)) {
+                   while (halt_if_hws_hang)
+                           schedule();
+                   dqm->is_hws_hang = true;
+                   kfd_hws_hang(dqm);
+                   retval = -ETIME;
+                   goto out;
+           }
    }
 
    /* We need to reset the grace period value for this device */
(quoted diff) +0 -0
@@ -2002,8 +2171,7 @@ static int unmap_queues_cpsch(struct

device_queue_manager *dqm,

drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c static int unmap_queues_cpsch(struct device_queue_manager *dqm,

Quoted 6 lines
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +1 -2
  }
 
  /* only for compute queue */
-static int reset_queues_cpsch(struct device_queue_manager *dqm,
-                   uint16_t pasid)
+static int reset_queues_cpsch(struct device_queue_manager *dqm,

uint16_t pasid)

Review

Quoted 4 lines
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +0 -0
  {
    int retval;
 
(quoted diff) +0 -0

b/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.h

Review

Quoted 30 lines

index 3b9b8eabaacc..dfb36a246637 100644

drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.h +12 -0
@@ -210,6 +210,13 @@ struct device_queue_manager_asic_ops {
                             struct kfd_node *dev);
  };
 
+struct dqm_detect_hang_info {
+   int pipe_id;
+   int queue_id;
+   int xcc_id;
+   uint64_t queue_address;
+};
+
  /**
   * struct device_queue_manager
   *
@@ -264,6 +271,11 @@ struct device_queue_manager {
    uint32_t                wait_times;
 
    wait_queue_head_t       destroy_wait;
+
+   /* for per-queue reset support */
+   struct dqm_detect_hang_info *detect_hang_info;
+   size_t detect_hang_info_size;
+   int detect_hang_count;
  };
 
  void device_queue_manager_init_cik(
(quoted diff) +0 -0

b/drivers/gpu/drm/amd/amdkfd/kfd_events.c

drivers/gpu/drm/amd/amdkfd/kfd_events.c void kfd_signal_reset_event(struct kfd_node

Quoted 12 lines

index 9b33d9d2c9ad..9393ddc2e828 100644

drivers/gpu/drm/amd/amdkfd/kfd_events.c +1 -0
@@ -31,6 +31,7 @@
  #include <linux/memory.h>
  #include "kfd_priv.h"
  #include "kfd_events.h"
+#include "kfd_device_queue_manager.h"
  #include <linux/device.h>
 
  /*
@@ -1244,12 +1245,33 @@ void kfd_signal_reset_event(struct kfd_node

*dev)

drivers/gpu/drm/amd/amdkfd/kfd_events.c void kfd_signal_reset_event(struct kfd_node *dev)

Quoted 4 lines
drivers/gpu/drm/amd/amdkfd/kfd_events.c +1 -0
    idx = srcu_read_lock(&kfd_processes_srcu);
    hash_for_each_rcu(kfd_processes_table, temp, p, kfd_processes) {
            int user_gpu_id = kfd_process_get_user_gpu_id(p, dev->id);
+           struct kfd_process_device *pdd =

kfd_get_process_device_data(dev, p);

drivers/gpu/drm/amd/amdkfd/kfd_events.c void kfd_signal_reset_event(struct kfd_node · line 1250

Quoted 3 lines
drivers/gpu/drm/amd/amdkfd/kfd_events.c +0 -0
            if (unlikely(user_gpu_id == -EINVAL)) {
                    WARN_ONCE(1, "Could not get user_gpu_id from

dev->id:%x\n", dev->id);

drivers/gpu/drm/amd/amdkfd/kfd_events.c void kfd_signal_reset_event(struct kfd_node *dev)

Quoted 5 lines
drivers/gpu/drm/amd/amdkfd/kfd_events.c +2 -0
                    continue;
            }
 
+           if (unlikely(!pdd)) {
+                   WARN_ONCE(1, "Could not get device data from

pasid:0x%x\n", p->pasid);

Quoted 5 lines
drivers/gpu/drm/amd/amdkfd/kfd_events.c +4 -0
+                   continue;
+           }
+
+           if (dev->dqm->detect_hang_count && !pdd-
 has_reset_queue)

drivers/gpu/drm/amd/amdkfd/kfd_events.c void kfd_signal_reset_event(struct kfd_node *dev)

Quoted 10 lines
drivers/gpu/drm/amd/amdkfd/kfd_events.c +9 -0
+                   continue;
+
+           if (dev->dqm->detect_hang_count) {
+                   struct amdgpu_task_info *ti;
+
+                   ti = amdgpu_vm_get_task_info_pasid(dev->adev, p-
 pasid);
+                   if (ti) {
+                           drm_err(&dev->adev->ddev,
+                                   "Queues reset on process %s tid %d

thread %s pid %d\n",

Review

Quoted 10 lines
drivers/gpu/drm/amd/amdkfd/kfd_events.c +5 -0
+                                   ti->process_name, ti->tgid, ti-
 task_name, ti->pid);
+                           amdgpu_vm_put_task_info(ti);
+                   }
+           }
+
            rcu_read_lock();
            id = KFD_FIRST_NONSIGNAL_EVENT_ID;
(quoted diff) +0 -0

b/drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_v9.c

drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_v9.c static void update_mqd(struct mqd_manager

Quoted 4 lines

index 66c73825c0a0..84e8ea3a8a0c 100644

drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_v9.c +0 -0
@@ -321,8 +321,11 @@ static void update_mqd(struct mqd_manager

*mm, void *mqd,

drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_v9.c static void update_mqd(struct mqd_manager · line 321

Quoted 1 line
drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_v9.c +0 -0
  static bool check_preemption_failed(struct mqd_manager *mm, void

*mqd)

drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_v9.c static bool check_preemption_failed_v9_4_3(struct

Quoted 13 lines
drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_v9.c +4 -1
  {
    struct v9_mqd *m = (struct v9_mqd *)mqd;
+   uint32_t doorbell_id = m->queue_doorbell_id0;
 
-   return kfd_check_hiq_mqd_doorbell_id(mm->dev, m-
 queue_doorbell_id0, 0);
+   m->queue_doorbell_id0 = 0;
+
+   return kfd_check_hiq_mqd_doorbell_id(mm->dev, doorbell_id, 0);
  }
 

static int get_wave_state(struct mqd_manager *mm, void *mqd,

drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_v9.c +0 -0
@@ -624,6 +627,7 @@ static bool check_preemption_failed_v9_4_3(struct

mqd_manager *mm, void *mqd)

Review

Quoted 8 lines
drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_v9.c +1 -0
            m = get_mqd(mqd + hiq_mqd_size * inst);
            ret |= kfd_check_hiq_mqd_doorbell_id(mm->dev,
                                    m->queue_doorbell_id0, inst);
+           m->queue_doorbell_id0 = 0;
            ++inst;
    }
 
(quoted diff) +0 -0

b/drivers/gpu/drm/amd/amdkfd/kfd_priv.h

Review

Quoted 14 lines

index b5cae48dff66..892a85408c09 100644

drivers/gpu/drm/amd/amdkfd/kfd_priv.h +3 -0
@@ -843,6 +843,9 @@ struct kfd_process_device {
    void *proc_ctx_bo;
    uint64_t proc_ctx_gpu_addr;
    void *proc_ctx_cpu_ptr;
+
+   /* Tracks queue reset status */
+   bool has_reset_queue;
  };
 
  #define qpd_to_pdd(x) container_of(x, struct kfd_process_device, qpd)
(quoted diff) +0 -0

b/drivers/gpu/drm/amd/amdkfd/kfd_process.c

drivers/gpu/drm/amd/amdkfd/kfd_process.c int kfd_process_evict_queues(struct kfd_process

Quoted 4 lines

index 9e29b92eb523..a902950cc060 100644

drivers/gpu/drm/amd/amdkfd/kfd_process.c +0 -0
@@ -1851,6 +1851,8 @@ int kfd_process_evict_queues(struct kfd_process

*p, uint32_t trigger)

Review

Quoted 9 lines
drivers/gpu/drm/amd/amdkfd/kfd_process.c +2 -0
                    goto fail;
            }
            n_evicted++;
+
+           pdd->dev->dqm->is_hws_hang = false;
    }
 
    return r;
(quoted diff) +0 -0

b/drivers/gpu/drm/amd/include/kgd_kfd_interface.h

Quoted 16 lines

index 6d094cf3587d..7744ca3ef4b1 100644

drivers/gpu/drm/amd/include/kgd_kfd_interface.h +6 -0
@@ -318,6 +318,12 @@ struct kfd2kgd_calls {
    void (*program_trap_handler_settings)(struct amdgpu_device *adev,
                    uint32_t vmid, uint64_t tba_addr, uint64_t tma_addr,
                    uint32_t inst);
+   uint64_t (*hqd_get_pq_addr)(struct amdgpu_device *adev,
+                               uint32_t pipe_id, uint32_t queue_id,
+                               uint32_t inst);
+   uint64_t (*hqd_reset)(struct amdgpu_device *adev,
+                         uint32_t pipe_id, uint32_t queue_id,
+                         uint32_t inst, unsigned int utimeout);
  };
 
  #endif    /* KGD_KFD_INTERFACE_H_INCLUDED */