amdgpu_ctx.c 15.4 KB
Newer Older
A
Alex Deucher 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
/*
 * Copyright 2015 Advanced Micro Devices, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 *
 * Authors: monk liu <monk.liu@amd.com>
 */

25
#include <drm/drm_auth.h>
A
Alex Deucher 已提交
26
#include "amdgpu.h"
27
#include "amdgpu_sched.h"
28
#include "amdgpu_ras.h"
A
Alex Deucher 已提交
29

30 31 32 33 34 35 36 37 38 39 40 41
#define to_amdgpu_ctx_entity(e)	\
	container_of((e), struct amdgpu_ctx_entity, entity)

const unsigned int amdgpu_ctx_num_entities[AMDGPU_HW_IP_NUM] = {
	[AMDGPU_HW_IP_GFX]	=	1,
	[AMDGPU_HW_IP_COMPUTE]	=	4,
	[AMDGPU_HW_IP_DMA]	=	2,
	[AMDGPU_HW_IP_UVD]	=	1,
	[AMDGPU_HW_IP_VCE]	=	1,
	[AMDGPU_HW_IP_UVD_ENC]	=	1,
	[AMDGPU_HW_IP_VCN_DEC]	=	1,
	[AMDGPU_HW_IP_VCN_ENC]	=	1,
42
	[AMDGPU_HW_IP_VCN_JPEG]	=	1,
43 44
};

45
static int amdgpu_ctx_total_num_entities(void)
46 47 48 49 50 51 52 53
{
	unsigned i, num_entities = 0;

	for (i = 0; i < AMDGPU_HW_IP_NUM; ++i)
		num_entities += amdgpu_ctx_num_entities[i];

	return num_entities;
}
54

55
static int amdgpu_ctx_priority_permit(struct drm_file *filp,
56
				      enum drm_sched_priority priority)
57 58
{
	/* NORMAL and below are accessible by everyone */
59
	if (priority <= DRM_SCHED_PRIORITY_NORMAL)
60 61 62 63 64 65 66 67 68 69 70 71
		return 0;

	if (capable(CAP_SYS_NICE))
		return 0;

	if (drm_is_current_master(filp))
		return 0;

	return -EACCES;
}

static int amdgpu_ctx_init(struct amdgpu_device *adev,
72
			   enum drm_sched_priority priority,
73 74
			   struct drm_file *filp,
			   struct amdgpu_ctx *ctx)
A
Alex Deucher 已提交
75
{
76
	unsigned num_entities = amdgpu_ctx_total_num_entities();
77
	unsigned i, j, k;
78
	int r;
A
Alex Deucher 已提交
79

80
	if (priority < 0 || priority >= DRM_SCHED_PRIORITY_MAX)
81 82 83 84 85 86
		return -EINVAL;

	r = amdgpu_ctx_priority_permit(filp, priority);
	if (r)
		return r;

87 88
	memset(ctx, 0, sizeof(*ctx));
	ctx->adev = adev;
89 90

	ctx->fences = kcalloc(amdgpu_sched_jobs * num_entities,
91
			      sizeof(struct dma_fence*), GFP_KERNEL);
92 93
	if (!ctx->fences)
		return -ENOMEM;
A
Alex Deucher 已提交
94

95 96 97 98 99 100 101
	ctx->entities[0] = kcalloc(num_entities,
				   sizeof(struct amdgpu_ctx_entity),
				   GFP_KERNEL);
	if (!ctx->entities[0]) {
		r = -ENOMEM;
		goto error_free_fences;
	}
102

103 104 105 106 107
	for (i = 0; i < num_entities; ++i) {
		struct amdgpu_ctx_entity *entity = &ctx->entities[0][i];

		entity->sequence = 1;
		entity->fences = &ctx->fences[amdgpu_sched_jobs * i];
108
	}
109 110 111 112 113 114 115
	for (i = 1; i < AMDGPU_HW_IP_NUM; ++i)
		ctx->entities[i] = ctx->entities[i - 1] +
			amdgpu_ctx_num_entities[i - 1];

	kref_init(&ctx->refcount);
	spin_lock_init(&ctx->ring_lock);
	mutex_init(&ctx->lock);
116 117

	ctx->reset_counter = atomic_read(&adev->gpu_reset_counter);
118
	ctx->reset_counter_query = ctx->reset_counter;
119
	ctx->vram_lost_counter = atomic_read(&adev->vram_lost_counter);
120
	ctx->init_priority = priority;
121
	ctx->override_priority = DRM_SCHED_PRIORITY_UNSET;
122

123 124 125
	for (i = 0; i < AMDGPU_HW_IP_NUM; ++i) {
		struct amdgpu_ring *rings[AMDGPU_MAX_RINGS];
		struct drm_sched_rq *rqs[AMDGPU_MAX_RINGS];
126
		unsigned num_rings = 0;
127
		unsigned num_rqs = 0;
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156

		switch (i) {
		case AMDGPU_HW_IP_GFX:
			rings[0] = &adev->gfx.gfx_ring[0];
			num_rings = 1;
			break;
		case AMDGPU_HW_IP_COMPUTE:
			for (j = 0; j < adev->gfx.num_compute_rings; ++j)
				rings[j] = &adev->gfx.compute_ring[j];
			num_rings = adev->gfx.num_compute_rings;
			break;
		case AMDGPU_HW_IP_DMA:
			for (j = 0; j < adev->sdma.num_instances; ++j)
				rings[j] = &adev->sdma.instance[j].ring;
			num_rings = adev->sdma.num_instances;
			break;
		case AMDGPU_HW_IP_UVD:
			rings[0] = &adev->uvd.inst[0].ring;
			num_rings = 1;
			break;
		case AMDGPU_HW_IP_VCE:
			rings[0] = &adev->vce.ring[0];
			num_rings = 1;
			break;
		case AMDGPU_HW_IP_UVD_ENC:
			rings[0] = &adev->uvd.inst[0].ring_enc[0];
			num_rings = 1;
			break;
		case AMDGPU_HW_IP_VCN_DEC:
157 158 159 160 161
			for (j = 0; j < adev->vcn.num_vcn_inst; ++j) {
				if (adev->vcn.harvest_config & (1 << j))
					continue;
				rings[num_rings++] = &adev->vcn.inst[j].ring_dec;
			}
162 163
			break;
		case AMDGPU_HW_IP_VCN_ENC:
164 165 166 167 168 169
			for (j = 0; j < adev->vcn.num_vcn_inst; ++j) {
				if (adev->vcn.harvest_config & (1 << j))
					continue;
				for (k = 0; k < adev->vcn.num_enc_rings; ++k)
					rings[num_rings++] = &adev->vcn.inst[j].ring_enc[k];
			}
170 171
			break;
		case AMDGPU_HW_IP_VCN_JPEG:
172 173 174 175 176
			for (j = 0; j < adev->vcn.num_vcn_inst; ++j) {
				if (adev->vcn.harvest_config & (1 << j))
					continue;
				rings[num_rings++] = &adev->vcn.inst[j].ring_jpeg;
			}
177 178
			break;
		}
M
Monk Liu 已提交
179

180 181 182 183 184 185
		for (j = 0; j < num_rings; ++j) {
			if (!rings[j]->adev)
				continue;

			rqs[num_rqs++] = &rings[j]->sched.sched_rq[priority];
		}
M
Monk Liu 已提交
186

187 188
		for (j = 0; j < amdgpu_ctx_num_entities[i]; ++j)
			r = drm_sched_entity_init(&ctx->entities[i][j].entity,
189
						  rqs, num_rqs, &ctx->guilty);
190
		if (r)
191
			goto error_cleanup_entities;
192 193
	}

A
Alex Deucher 已提交
194
	return 0;
195

196 197 198 199 200 201
error_cleanup_entities:
	for (i = 0; i < num_entities; ++i)
		drm_sched_entity_destroy(&ctx->entities[0][i].entity);
	kfree(ctx->entities[0]);

error_free_fences:
202 203 204
	kfree(ctx->fences);
	ctx->fences = NULL;
	return r;
A
Alex Deucher 已提交
205 206
}

207
static void amdgpu_ctx_fini(struct kref *ref)
A
Alex Deucher 已提交
208
{
209
	struct amdgpu_ctx *ctx = container_of(ref, struct amdgpu_ctx, refcount);
210
	unsigned num_entities = amdgpu_ctx_total_num_entities();
211 212 213
	struct amdgpu_device *adev = ctx->adev;
	unsigned i, j;

214 215 216
	if (!adev)
		return;

217
	for (i = 0; i < num_entities; ++i)
218
		for (j = 0; j < amdgpu_sched_jobs; ++j)
219
			dma_fence_put(ctx->entities[0][i].fences[j]);
220
	kfree(ctx->fences);
221
	kfree(ctx->entities[0]);
222

223
	mutex_destroy(&ctx->lock);
224 225

	kfree(ctx);
226 227
}

228 229
int amdgpu_ctx_get_entity(struct amdgpu_ctx *ctx, u32 hw_ip, u32 instance,
			  u32 ring, struct drm_sched_entity **entity)
230
{
231 232 233 234
	if (hw_ip >= AMDGPU_HW_IP_NUM) {
		DRM_ERROR("unknown HW IP type: %d\n", hw_ip);
		return -EINVAL;
	}
235 236 237 238 239 240 241

	/* Right now all IPs have only one instance - multiple rings. */
	if (instance != 0) {
		DRM_DEBUG("invalid ip instance: %d\n", instance);
		return -EINVAL;
	}

242 243
	if (ring >= amdgpu_ctx_num_entities[hw_ip]) {
		DRM_DEBUG("invalid ring: %d %d\n", hw_ip, ring);
244 245 246
		return -EINVAL;
	}

247
	*entity = &ctx->entities[hw_ip][ring].entity;
248 249 250
	return 0;
}

251 252
static int amdgpu_ctx_alloc(struct amdgpu_device *adev,
			    struct amdgpu_fpriv *fpriv,
253
			    struct drm_file *filp,
254
			    enum drm_sched_priority priority,
255 256 257
			    uint32_t *id)
{
	struct amdgpu_ctx_mgr *mgr = &fpriv->ctx_mgr;
A
Alex Deucher 已提交
258
	struct amdgpu_ctx *ctx;
259
	int r;
A
Alex Deucher 已提交
260

261 262 263 264 265
	ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
	if (!ctx)
		return -ENOMEM;

	mutex_lock(&mgr->lock);
266
	r = idr_alloc(&mgr->ctx_handles, ctx, 1, AMDGPU_VM_MAX_NUM_CTX, GFP_KERNEL);
267
	if (r < 0) {
268
		mutex_unlock(&mgr->lock);
269 270 271
		kfree(ctx);
		return r;
	}
272

273
	*id = (uint32_t)r;
274
	r = amdgpu_ctx_init(adev, priority, filp, ctx);
275 276 277 278 279
	if (r) {
		idr_remove(&mgr->ctx_handles, *id);
		*id = 0;
		kfree(ctx);
	}
280 281 282 283 284 285 286
	mutex_unlock(&mgr->lock);
	return r;
}

static void amdgpu_ctx_do_release(struct kref *ref)
{
	struct amdgpu_ctx *ctx;
287
	unsigned num_entities;
288
	u32 i;
289 290 291

	ctx = container_of(ref, struct amdgpu_ctx, refcount);

292
	num_entities = amdgpu_ctx_total_num_entities();
293 294
	for (i = 0; i < num_entities; i++)
		drm_sched_entity_destroy(&ctx->entities[0][i].entity);
295

296
	amdgpu_ctx_fini(ref);
297 298 299 300 301 302 303 304
}

static int amdgpu_ctx_free(struct amdgpu_fpriv *fpriv, uint32_t id)
{
	struct amdgpu_ctx_mgr *mgr = &fpriv->ctx_mgr;
	struct amdgpu_ctx *ctx;

	mutex_lock(&mgr->lock);
305 306
	ctx = idr_remove(&mgr->ctx_handles, id);
	if (ctx)
307
		kref_put(&ctx->refcount, amdgpu_ctx_do_release);
308
	mutex_unlock(&mgr->lock);
309
	return ctx ? 0 : -EINVAL;
A
Alex Deucher 已提交
310 311
}

312 313 314
static int amdgpu_ctx_query(struct amdgpu_device *adev,
			    struct amdgpu_fpriv *fpriv, uint32_t id,
			    union drm_amdgpu_ctx_out *out)
A
Alex Deucher 已提交
315 316
{
	struct amdgpu_ctx *ctx;
317
	struct amdgpu_ctx_mgr *mgr;
318
	unsigned reset_counter;
A
Alex Deucher 已提交
319

320 321 322 323
	if (!fpriv)
		return -EINVAL;

	mgr = &fpriv->ctx_mgr;
324
	mutex_lock(&mgr->lock);
A
Alex Deucher 已提交
325
	ctx = idr_find(&mgr->ctx_handles, id);
326
	if (!ctx) {
327
		mutex_unlock(&mgr->lock);
328
		return -EINVAL;
A
Alex Deucher 已提交
329
	}
330 331

	/* TODO: these two are always zero */
332 333
	out->state.flags = 0x0;
	out->state.hangs = 0x0;
334 335 336 337

	/* determine if a GPU reset has occured since the last call */
	reset_counter = atomic_read(&adev->gpu_reset_counter);
	/* TODO: this should ideally return NO, GUILTY, or INNOCENT. */
338
	if (ctx->reset_counter_query == reset_counter)
339 340 341
		out->state.reset_status = AMDGPU_CTX_NO_RESET;
	else
		out->state.reset_status = AMDGPU_CTX_UNKNOWN_RESET;
342
	ctx->reset_counter_query = reset_counter;
343

344
	mutex_unlock(&mgr->lock);
345
	return 0;
A
Alex Deucher 已提交
346 347
}

M
Monk Liu 已提交
348 349 350 351 352 353
static int amdgpu_ctx_query2(struct amdgpu_device *adev,
	struct amdgpu_fpriv *fpriv, uint32_t id,
	union drm_amdgpu_ctx_out *out)
{
	struct amdgpu_ctx *ctx;
	struct amdgpu_ctx_mgr *mgr;
354
	unsigned long ras_counter;
M
Monk Liu 已提交
355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378

	if (!fpriv)
		return -EINVAL;

	mgr = &fpriv->ctx_mgr;
	mutex_lock(&mgr->lock);
	ctx = idr_find(&mgr->ctx_handles, id);
	if (!ctx) {
		mutex_unlock(&mgr->lock);
		return -EINVAL;
	}

	out->state.flags = 0x0;
	out->state.hangs = 0x0;

	if (ctx->reset_counter != atomic_read(&adev->gpu_reset_counter))
		out->state.flags |= AMDGPU_CTX_QUERY2_FLAGS_RESET;

	if (ctx->vram_lost_counter != atomic_read(&adev->vram_lost_counter))
		out->state.flags |= AMDGPU_CTX_QUERY2_FLAGS_VRAMLOST;

	if (atomic_read(&ctx->guilty))
		out->state.flags |= AMDGPU_CTX_QUERY2_FLAGS_GUILTY;

379 380 381 382 383 384 385 386 387 388 389 390 391 392 393
	/*query ue count*/
	ras_counter = amdgpu_ras_query_error_count(adev, false);
	/*ras counter is monotonic increasing*/
	if (ras_counter != ctx->ras_counter_ue) {
		out->state.flags |= AMDGPU_CTX_QUERY2_FLAGS_RAS_UE;
		ctx->ras_counter_ue = ras_counter;
	}

	/*query ce count*/
	ras_counter = amdgpu_ras_query_error_count(adev, true);
	if (ras_counter != ctx->ras_counter_ce) {
		out->state.flags |= AMDGPU_CTX_QUERY2_FLAGS_RAS_CE;
		ctx->ras_counter_ce = ras_counter;
	}

M
Monk Liu 已提交
394 395 396 397
	mutex_unlock(&mgr->lock);
	return 0;
}

A
Alex Deucher 已提交
398
int amdgpu_ctx_ioctl(struct drm_device *dev, void *data,
399
		     struct drm_file *filp)
A
Alex Deucher 已提交
400 401 402
{
	int r;
	uint32_t id;
403
	enum drm_sched_priority priority;
A
Alex Deucher 已提交
404 405 406 407 408 409 410

	union drm_amdgpu_ctx *args = data;
	struct amdgpu_device *adev = dev->dev_private;
	struct amdgpu_fpriv *fpriv = filp->driver_priv;

	r = 0;
	id = args->in.ctx_id;
411 412
	priority = amdgpu_to_sched_priority(args->in.priority);

413 414
	/* For backwards compatibility reasons, we need to accept
	 * ioctls with garbage in the priority field */
415 416
	if (priority == DRM_SCHED_PRIORITY_INVALID)
		priority = DRM_SCHED_PRIORITY_NORMAL;
A
Alex Deucher 已提交
417 418

	switch (args->in.op) {
419
	case AMDGPU_CTX_OP_ALLOC_CTX:
420
		r = amdgpu_ctx_alloc(adev, fpriv, filp, priority, &id);
421 422 423 424 425 426 427 428
		args->out.alloc.ctx_id = id;
		break;
	case AMDGPU_CTX_OP_FREE_CTX:
		r = amdgpu_ctx_free(fpriv, id);
		break;
	case AMDGPU_CTX_OP_QUERY_STATE:
		r = amdgpu_ctx_query(adev, fpriv, id, &args->out);
		break;
M
Monk Liu 已提交
429 430 431
	case AMDGPU_CTX_OP_QUERY_STATE2:
		r = amdgpu_ctx_query2(adev, fpriv, id, &args->out);
		break;
432 433
	default:
		return -EINVAL;
A
Alex Deucher 已提交
434 435 436 437
	}

	return r;
}
438 439 440 441

struct amdgpu_ctx *amdgpu_ctx_get(struct amdgpu_fpriv *fpriv, uint32_t id)
{
	struct amdgpu_ctx *ctx;
442 443 444 445 446 447
	struct amdgpu_ctx_mgr *mgr;

	if (!fpriv)
		return NULL;

	mgr = &fpriv->ctx_mgr;
448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464

	mutex_lock(&mgr->lock);
	ctx = idr_find(&mgr->ctx_handles, id);
	if (ctx)
		kref_get(&ctx->refcount);
	mutex_unlock(&mgr->lock);
	return ctx;
}

int amdgpu_ctx_put(struct amdgpu_ctx *ctx)
{
	if (ctx == NULL)
		return -EINVAL;

	kref_put(&ctx->refcount, amdgpu_ctx_do_release);
	return 0;
}
465

466 467 468
void amdgpu_ctx_add_fence(struct amdgpu_ctx *ctx,
			  struct drm_sched_entity *entity,
			  struct dma_fence *fence, uint64_t* handle)
469
{
470 471
	struct amdgpu_ctx_entity *centity = to_amdgpu_ctx_entity(entity);
	uint64_t seq = centity->sequence;
472
	struct dma_fence *other = NULL;
473
	unsigned idx = 0;
474

475
	idx = seq & (amdgpu_sched_jobs - 1);
476
	other = centity->fences[idx];
477 478
	if (other)
		BUG_ON(!dma_fence_is_signaled(other));
479

480
	dma_fence_get(fence);
481 482

	spin_lock(&ctx->ring_lock);
483 484
	centity->fences[idx] = fence;
	centity->sequence++;
485 486
	spin_unlock(&ctx->ring_lock);

487
	dma_fence_put(other);
488 489
	if (handle)
		*handle = seq;
490 491
}

492
struct dma_fence *amdgpu_ctx_get_fence(struct amdgpu_ctx *ctx,
493 494
				       struct drm_sched_entity *entity,
				       uint64_t seq)
495
{
496
	struct amdgpu_ctx_entity *centity = to_amdgpu_ctx_entity(entity);
497
	struct dma_fence *fence;
498 499

	spin_lock(&ctx->ring_lock);
500

M
Monk Liu 已提交
501
	if (seq == ~0ull)
502
		seq = centity->sequence - 1;
M
Monk Liu 已提交
503

504
	if (seq >= centity->sequence) {
505 506 507 508
		spin_unlock(&ctx->ring_lock);
		return ERR_PTR(-EINVAL);
	}

509

510
	if (seq + amdgpu_sched_jobs < centity->sequence) {
511 512 513 514
		spin_unlock(&ctx->ring_lock);
		return NULL;
	}

515
	fence = dma_fence_get(centity->fences[seq & (amdgpu_sched_jobs - 1)]);
516 517 518 519
	spin_unlock(&ctx->ring_lock);

	return fence;
}
520

521
void amdgpu_ctx_priority_override(struct amdgpu_ctx *ctx,
522
				  enum drm_sched_priority priority)
523
{
524
	unsigned num_entities = amdgpu_ctx_total_num_entities();
525
	enum drm_sched_priority ctx_prio;
526
	unsigned i;
527 528 529

	ctx->override_priority = priority;

530
	ctx_prio = (ctx->override_priority == DRM_SCHED_PRIORITY_UNSET) ?
531 532
			ctx->init_priority : ctx->override_priority;

533 534
	for (i = 0; i < num_entities; i++) {
		struct drm_sched_entity *entity = &ctx->entities[0][i].entity;
535

536
		drm_sched_entity_set_priority(entity, ctx_prio);
537 538 539
	}
}

540 541
int amdgpu_ctx_wait_prev_fence(struct amdgpu_ctx *ctx,
			       struct drm_sched_entity *entity)
542
{
543
	struct amdgpu_ctx_entity *centity = to_amdgpu_ctx_entity(entity);
544 545 546
	struct dma_fence *other;
	unsigned idx;
	long r;
547

548 549 550 551
	spin_lock(&ctx->ring_lock);
	idx = centity->sequence & (amdgpu_sched_jobs - 1);
	other = dma_fence_get(centity->fences[idx]);
	spin_unlock(&ctx->ring_lock);
552

553 554
	if (!other)
		return 0;
555

556 557 558 559 560 561
	r = dma_fence_wait(other, true);
	if (r < 0 && r != -ERESTARTSYS)
		DRM_ERROR("Error (%ld) waiting for fence!\n", r);

	dma_fence_put(other);
	return r;
562 563
}

564 565 566 567 568 569
void amdgpu_ctx_mgr_init(struct amdgpu_ctx_mgr *mgr)
{
	mutex_init(&mgr->lock);
	idr_init(&mgr->ctx_handles);
}

570
long amdgpu_ctx_mgr_entity_flush(struct amdgpu_ctx_mgr *mgr, long timeout)
571
{
572
	unsigned num_entities = amdgpu_ctx_total_num_entities();
573 574 575 576 577 578
	struct amdgpu_ctx *ctx;
	struct idr *idp;
	uint32_t id, i;

	idp = &mgr->ctx_handles;

579
	mutex_lock(&mgr->lock);
580
	idr_for_each_entry(idp, ctx, id) {
581 582
		for (i = 0; i < num_entities; i++) {
			struct drm_sched_entity *entity;
583

584
			entity = &ctx->entities[0][i].entity;
585
			timeout = drm_sched_entity_flush(entity, timeout);
586
		}
587
	}
588
	mutex_unlock(&mgr->lock);
589
	return timeout;
590 591
}

592
void amdgpu_ctx_mgr_entity_fini(struct amdgpu_ctx_mgr *mgr)
593
{
594
	unsigned num_entities = amdgpu_ctx_total_num_entities();
595 596 597 598 599 600 601
	struct amdgpu_ctx *ctx;
	struct idr *idp;
	uint32_t id, i;

	idp = &mgr->ctx_handles;

	idr_for_each_entry(idp, ctx, id) {
602 603 604
		if (kref_read(&ctx->refcount) != 1) {
			DRM_ERROR("ctx %p is still alive\n", ctx);
			continue;
605
		}
606

607 608
		for (i = 0; i < num_entities; i++) {
			mutex_lock(&ctx->adev->lock_reset);
609
			drm_sched_entity_fini(&ctx->entities[0][i].entity);
610 611
			mutex_unlock(&ctx->adev->lock_reset);
		}
612 613 614
	}
}

615 616 617 618 619 620
void amdgpu_ctx_mgr_fini(struct amdgpu_ctx_mgr *mgr)
{
	struct amdgpu_ctx *ctx;
	struct idr *idp;
	uint32_t id;

621
	amdgpu_ctx_mgr_entity_fini(mgr);
622

623 624 625
	idp = &mgr->ctx_handles;

	idr_for_each_entry(idp, ctx, id) {
626
		if (kref_put(&ctx->refcount, amdgpu_ctx_fini) != 1)
627 628 629 630 631 632
			DRM_ERROR("ctx %p is still alive\n", ctx);
	}

	idr_destroy(&mgr->ctx_handles);
	mutex_destroy(&mgr->lock);
}