drm/amdgpu: remove old lockup detection infrastructure (b7e4dad3) · Commits · 戴 / test

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

+0 −7

Original line number	Diff line number	Diff line
		@@ -345,7 +345,6 @@ struct amdgpu_ring_funcs {
		/* testing functions */
		int (test_ring)(struct amdgpu_ring ring);
		int (test_ib)(struct amdgpu_ring ring);
		bool (is_lockup)(struct amdgpu_ring ring);
		/* insert NOP packets */
		void (insert_nop)(struct amdgpu_ring ring, uint32_t count);
		};
		@@ -907,8 +906,6 @@ struct amdgpu_ring {
		unsigned ring_size;
		unsigned ring_free_dw;
		int count_dw;
		atomic_t last_rptr;
		atomic64_t last_activity;
		uint64_t gpu_addr;
		uint32_t align_mask;
		uint32_t ptr_mask;
		@@ -1230,8 +1227,6 @@ void amdgpu_ring_commit(struct amdgpu_ring *ring);
		void amdgpu_ring_unlock_commit(struct amdgpu_ring *ring);
		void amdgpu_ring_undo(struct amdgpu_ring *ring);
		void amdgpu_ring_unlock_undo(struct amdgpu_ring *ring);
		void amdgpu_ring_lockup_update(struct amdgpu_ring *ring);
		bool amdgpu_ring_test_lockup(struct amdgpu_ring *ring);
		unsigned amdgpu_ring_backup(struct amdgpu_ring *ring,
		uint32_t **data);
		int amdgpu_ring_restore(struct amdgpu_ring *ring,
		@@ -1974,7 +1969,6 @@ struct amdgpu_device {
		bool suspend;
		bool need_dma32;
		bool accel_working;
		bool needs_reset;
		struct work_struct reset_work;
		struct notifier_block acpi_nb;
		struct amdgpu_i2c_chan *i2c_bus[AMDGPU_MAX_I2C_BUS];
		@@ -2253,7 +2247,6 @@ amdgpu_get_sdma_instance(struct amdgpu_ring *ring)
		#define amdgpu_ring_parse_cs(r, p, ib) ((r)->funcs->parse_cs((p), (ib)))
		#define amdgpu_ring_test_ring(r) (r)->funcs->test_ring((r))
		#define amdgpu_ring_test_ib(r) (r)->funcs->test_ib((r))
		#define amdgpu_ring_is_lockup(r) (r)->funcs->is_lockup((r))
		#define amdgpu_ring_get_rptr(r) (r)->funcs->get_rptr((r))
		#define amdgpu_ring_get_wptr(r) (r)->funcs->get_wptr((r))
		#define amdgpu_ring_set_wptr(r) (r)->funcs->set_wptr((r))

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

+0 −6

Original line number	Diff line number	Diff line
		@@ -1816,12 +1816,6 @@ int amdgpu_gpu_reset(struct amdgpu_device *adev)

		down_write(&adev->exclusive_lock);

		if (!adev->needs_reset) {
		up_write(&adev->exclusive_lock);
		return 0;
		}

		adev->needs_reset = false;
		atomic_inc(&adev->gpu_reset_counter);

		/* block TTM */

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

+1 −19

Original line number	Diff line number	Diff line
		@@ -269,17 +269,6 @@ static void amdgpu_fence_check_lockup(struct work_struct *work)
		if (amdgpu_fence_activity(ring)) {
		wake_up_all(&ring->fence_drv.fence_queue);
		}
		else if (amdgpu_ring_is_lockup(ring)) {
		/* good news we believe it's a lockup */
		dev_warn(ring->adev->dev, "GPU lockup (current fence id "
		"0x%016llx last fence id 0x%016llx on ring %d)\n",
		(uint64_t)atomic64_read(&fence_drv->last_seq),
		fence_drv->sync_seq[ring->idx], ring->idx);

		/* remember that we need an reset */
		ring->adev->needs_reset = true;
		wake_up_all(&ring->fence_drv.fence_queue);
		}
		up_read(&ring->adev->exclusive_lock);
		}

		@@ -380,7 +369,6 @@ static bool amdgpu_fence_enable_signaling(struct fence *f)
		*/
		static int amdgpu_fence_ring_wait_seq(struct amdgpu_ring *ring, uint64_t seq)
		{
		struct amdgpu_device *adev = ring->adev;
		bool signaled = false;

		BUG_ON(!ring);
		@@ -391,8 +379,7 @@ static int amdgpu_fence_ring_wait_seq(struct amdgpu_ring *ring, uint64_t seq)
		return 0;

		wait_event(ring->fence_drv.fence_queue, (
		(signaled = amdgpu_fence_seq_signaled(ring, seq))
		\|\| adev->needs_reset));
		(signaled = amdgpu_fence_seq_signaled(ring, seq))));

		if (signaled)
		return 0;
		@@ -939,11 +926,6 @@ signed long amdgpu_fence_wait_any(struct amdgpu_device *adev,
		if (amdgpu_test_signaled_any(array, count))
		break;

		if (adev->needs_reset) {
		t = -EDEADLK;
		break;
		}

		t = schedule_timeout(t);

		if (t > 0 && intr && signal_pending(current))

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

+0 −1

Original line number	Diff line number	Diff line
		@@ -298,7 +298,6 @@ int amdgpu_ib_ring_tests(struct amdgpu_device *adev)
		r = amdgpu_ring_test_ib(ring);
		if (r) {
		ring->ready = false;
		adev->needs_reset = false;

		if (ring == &adev->gfx.gfx_ring[0]) {
		/* oh, oh, that's really bad */

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

+0 −43

Original line number	Diff line number	Diff line
		@@ -67,8 +67,6 @@ void amdgpu_ring_free_size(struct amdgpu_ring *ring)
		if (!ring->ring_free_dw) {
		/* this is an empty ring */
		ring->ring_free_dw = ring->ring_size / 4;
		/* update lockup info to avoid false positive */
		amdgpu_ring_lockup_update(ring);
		}
		}

		@@ -208,46 +206,6 @@ void amdgpu_ring_unlock_undo(struct amdgpu_ring *ring)
		mutex_unlock(ring->ring_lock);
		}

		/**
		* amdgpu_ring_lockup_update - update lockup variables
		*
		* @ring: amdgpu_ring structure holding ring information
		*
		* Update the last rptr value and timestamp (all asics).
		*/
		void amdgpu_ring_lockup_update(struct amdgpu_ring *ring)
		{
		atomic_set(&ring->last_rptr, amdgpu_ring_get_rptr(ring));
		atomic64_set(&ring->last_activity, jiffies_64);
		}

		/**
		* amdgpu_ring_test_lockup() - check if ring is lockedup by recording information
		* @ring: amdgpu_ring structure holding ring information
		*
		*/
		bool amdgpu_ring_test_lockup(struct amdgpu_ring *ring)
		{
		uint32_t rptr = amdgpu_ring_get_rptr(ring);
		uint64_t last = atomic64_read(&ring->last_activity);
		uint64_t elapsed;

		if (rptr != atomic_read(&ring->last_rptr)) {
		/* ring is still working, no lockup */
		amdgpu_ring_lockup_update(ring);
		return false;
		}

		elapsed = jiffies_to_msecs(jiffies_64 - last);
		if (amdgpu_lockup_timeout && elapsed >= amdgpu_lockup_timeout) {
		dev_err(ring->adev->dev, "ring %d stalled for more than %llumsec\n",
		ring->idx, elapsed);
		return true;
		}
		/* give a chance to the GPU ... */
		return false;
		}

		/**
		* amdgpu_ring_backup - Back up the content of a ring
		*
		@@ -436,7 +394,6 @@ int amdgpu_ring_init(struct amdgpu_device adev, struct amdgpu_ring ring,
		if (amdgpu_debugfs_ring_init(adev, ring)) {
		DRM_ERROR("Failed to register debugfs file for rings !\n");
		}
		amdgpu_ring_lockup_update(ring);
		return 0;
		}

Admin message