Commit 12fb1ad7 authored by Jonathan Kim's avatar Jonathan Kim Committed by Alex Deucher
Browse files

drm/amdkfd: update process interrupt handling for debug events 



The debugger must be notified by any debugger subscribed exception
that comes from hardware interrupts.

If a debugger session exits, any exceptions it subscribed to may still
have interrupts in the interrupt ring buffer or KGD/KFD pipeline.
To prevent a new session from inheriting stale interrupts, when a new
queue is created, open an interrupt drain and allow the IH ring to drain
from a timestamped checkpoint.  Then inject a custom IV so that once
the custom IV is picked up by the KFD, it's safe to close the drain
and proceed with queue creation.

The drain must also be on debug disable as SW interrupts may still
be processed.  Drain at this time and clear all the exception status.

The debugger may also not be attached nor subscibed to certain
exceptions so forward them directly to the runtime.

GFX10 also requires its own IV processing, hence the creation of
kfd_int_process_v10.c.  This is because the IV from SQ interrupts are
packed into a new continguous format unlike GFX9. To make this clear,
a separate interrupting handling code file was created.

Signed-off-by: default avatarJonathan Kim <jonathan.kim@amd.com>
Reviewed-by: default avatarFelix Kuehling <felix.kuehling@amd.com>
Signed-off-by: default avatarAlex Deucher <alexander.deucher@amd.com>
parent a37d23f8

drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c

+16 −0
Original line number Diff line number Diff line
@@ -777,6 +777,22 @@ void amdgpu_amdkfd_ras_poison_consumption_handler(struct amdgpu_device *adev, bo 
	amdgpu_umc_poison_handler(adev, reset);

}



int amdgpu_amdkfd_send_close_event_drain_irq(struct amdgpu_device *adev,

					uint32_t *payload)

{

	int ret;



	/* Device or IH ring is not ready so bail. */

	ret = amdgpu_ih_wait_on_checkpoint_process_ts(adev, &adev->irq.ih);

	if (ret)

		return ret;



	/* Send payload to fence KFD interrupts */

	amdgpu_amdkfd_interrupt(adev, payload);



	return 0;

}



bool amdgpu_amdkfd_ras_query_utcl2_poison_status(struct amdgpu_device *adev)

{

	if (adev->gfx.ras && adev->gfx.ras->query_utcl2_poison_status)

drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h

+2 −0
Original line number Diff line number Diff line
@@ -250,6 +250,8 @@ int amdgpu_amdkfd_get_xgmi_bandwidth_mbytes(struct amdgpu_device *dst, 
					    struct amdgpu_device *src,

					    bool is_min);

int amdgpu_amdkfd_get_pcie_bandwidth_mbytes(struct amdgpu_device *adev, bool is_min);

int amdgpu_amdkfd_send_close_event_drain_irq(struct amdgpu_device *adev,

					uint32_t *payload);



/* Read user wptr from a specified user address space with page fault

 * disabled. The memory must be pinned and mapped to the hardware when

drivers/gpu/drm/amd/amdkfd/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -53,6 +53,7 @@ AMDKFD_FILES := $(AMDKFD_PATH)/kfd_module.o \ 
		$(AMDKFD_PATH)/kfd_events.o \

		$(AMDKFD_PATH)/cik_event_interrupt.o \

		$(AMDKFD_PATH)/kfd_int_process_v9.o \

		$(AMDKFD_PATH)/kfd_int_process_v10.o \

		$(AMDKFD_PATH)/kfd_int_process_v11.o \

		$(AMDKFD_PATH)/kfd_smi_events.o \

		$(AMDKFD_PATH)/kfd_crat.o \

drivers/gpu/drm/amd/amdkfd/kfd_debug.c

+84 −0
Original line number Diff line number Diff line
@@ -125,6 +125,64 @@ bool kfd_dbg_ev_raise(uint64_t event_mask, 
	return is_subscribed;

}



/* set pending event queue entry from ring entry  */

bool kfd_set_dbg_ev_from_interrupt(struct kfd_node *dev,

				   unsigned int pasid,

				   uint32_t doorbell_id,

				   uint64_t trap_mask,

				   void *exception_data,

				   size_t exception_data_size)

{

	struct kfd_process *p;

	bool signaled_to_debugger_or_runtime = false;



	p = kfd_lookup_process_by_pasid(pasid);



	if (!p)

		return false;



	if (!kfd_dbg_ev_raise(trap_mask, p, dev, doorbell_id, true,

			      exception_data, exception_data_size)) {

		struct process_queue_manager *pqm;

		struct process_queue_node *pqn;



		if (!!(trap_mask & KFD_EC_MASK_QUEUE) &&

		       p->runtime_info.runtime_state == DEBUG_RUNTIME_STATE_ENABLED) {

			mutex_lock(&p->mutex);



			pqm = &p->pqm;

			list_for_each_entry(pqn, &pqm->queues,

							process_queue_list) {



				if (!(pqn->q && pqn->q->device == dev &&

				      pqn->q->doorbell_id == doorbell_id))

					continue;



				kfd_send_exception_to_runtime(p, pqn->q->properties.queue_id,

							      trap_mask);



				signaled_to_debugger_or_runtime = true;



				break;

			}



			mutex_unlock(&p->mutex);

		} else if (trap_mask & KFD_EC_MASK(EC_DEVICE_MEMORY_VIOLATION)) {

			kfd_dqm_evict_pasid(dev->dqm, p->pasid);

			kfd_signal_vm_fault_event(dev, p->pasid, NULL,

							exception_data);



			signaled_to_debugger_or_runtime = true;

		}

	} else {

		signaled_to_debugger_or_runtime = true;

	}



	kfd_unref_process(p);



	return signaled_to_debugger_or_runtime;

}



int kfd_dbg_send_exception_to_runtime(struct kfd_process *p,

					unsigned int dev_id,

					unsigned int queue_id,
@@ -281,6 +339,31 @@ void kfd_dbg_trap_deactivate(struct kfd_process *target, bool unwind, int unwind 
	kfd_dbg_set_workaround(target, false);

}



static void kfd_dbg_clean_exception_status(struct kfd_process *target)

{

	struct process_queue_manager *pqm;

	struct process_queue_node *pqn;

	int i;



	for (i = 0; i < target->n_pdds; i++) {

		struct kfd_process_device *pdd = target->pdds[i];



		kfd_process_drain_interrupts(pdd);



		pdd->exception_status = 0;

	}



	pqm = &target->pqm;

	list_for_each_entry(pqn, &pqm->queues, process_queue_list) {

		if (!pqn->q)

			continue;



		pqn->q->properties.exception_status = 0;

	}



	target->exception_status = 0;

}



int kfd_dbg_trap_disable(struct kfd_process *target)

{

	if (!target->debug_trap_enabled)
@@ -304,6 +387,7 @@ int kfd_dbg_trap_disable(struct kfd_process *target) 
	}



	target->debug_trap_enabled = false;

	kfd_dbg_clean_exception_status(target);

	kfd_unref_process(target);



	return 0;

drivers/gpu/drm/amd/amdkfd/kfd_debug.h

+6 −0
Original line number Diff line number Diff line
@@ -27,6 +27,12 @@ 


void kfd_dbg_trap_deactivate(struct kfd_process *target, bool unwind, int unwind_count);

int kfd_dbg_trap_activate(struct kfd_process *target);

bool kfd_set_dbg_ev_from_interrupt(struct kfd_node *dev,

				   unsigned int pasid,

				   uint32_t doorbell_id,

				   uint64_t trap_mask,

				   void *exception_data,

				   size_t exception_data_size);

bool kfd_dbg_ev_raise(uint64_t event_mask,

			struct kfd_process *process, struct kfd_node *dev,

			unsigned int source_id, bool use_worker,