cregit-Linux how code gets into the kernel

Release 4.11 drivers/gpu/drm/amd/amdgpu/amdgpu_ctx.c

/*
 * 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>
 */

#include <drm/drmP.h>
#include "amdgpu.h"


static int amdgpu_ctx_init(struct amdgpu_device *adev, struct amdgpu_ctx *ctx) { unsigned i, j; int r; memset(ctx, 0, sizeof(*ctx)); ctx->adev = adev; kref_init(&ctx->refcount); spin_lock_init(&ctx->ring_lock); ctx->fences = kcalloc(amdgpu_sched_jobs * AMDGPU_MAX_RINGS, sizeof(struct dma_fence*), GFP_KERNEL); if (!ctx->fences) return -ENOMEM; for (i = 0; i < AMDGPU_MAX_RINGS; ++i) { ctx->rings[i].sequence = 1; ctx->rings[i].fences = &ctx->fences[amdgpu_sched_jobs * i]; } ctx->reset_counter = atomic_read(&adev->gpu_reset_counter); /* create context entity for each ring */ for (i = 0; i < adev->num_rings; i++) { struct amdgpu_ring *ring = adev->rings[i]; struct amd_sched_rq *rq; rq = &ring->sched.sched_rq[AMD_SCHED_PRIORITY_NORMAL]; r = amd_sched_entity_init(&ring->sched, &ctx->rings[i].entity, rq, amdgpu_sched_jobs); if (r) goto failed; } return 0; failed: for (j = 0; j < i; j++) amd_sched_entity_fini(&adev->rings[j]->sched, &ctx->rings[j].entity); kfree(ctx->fences); ctx->fences = NULL; return r; }

Contributors

PersonTokensPropCommitsCommitProp
Christian König15956.38%746.67%
Chunming Zhou8429.79%320.00%
Alex Deucher124.26%16.67%
Nicolai Hähnle124.26%16.67%
Huang Rui82.84%16.67%
Grazvydas Ignotas62.13%16.67%
Chris Wilson10.35%16.67%
Total282100.00%15100.00%


static void amdgpu_ctx_fini(struct amdgpu_ctx *ctx) { struct amdgpu_device *adev = ctx->adev; unsigned i, j; if (!adev) return; for (i = 0; i < AMDGPU_MAX_RINGS; ++i) for (j = 0; j < amdgpu_sched_jobs; ++j) dma_fence_put(ctx->rings[i].fences[j]); kfree(ctx->fences); ctx->fences = NULL; for (i = 0; i < adev->num_rings; i++) amd_sched_entity_fini(&adev->rings[i]->sched, &ctx->rings[i].entity); }

Contributors

PersonTokensPropCommitsCommitProp
Christian König6552.85%550.00%
Chunming Zhou4536.59%220.00%
Dave Airlie64.88%110.00%
Grazvydas Ignotas64.88%110.00%
Chris Wilson10.81%110.00%
Total123100.00%10100.00%


static int amdgpu_ctx_alloc(struct amdgpu_device *adev, struct amdgpu_fpriv *fpriv, uint32_t *id) { struct amdgpu_ctx_mgr *mgr = &fpriv->ctx_mgr; struct amdgpu_ctx *ctx; int r; ctx = kmalloc(sizeof(*ctx), GFP_KERNEL); if (!ctx) return -ENOMEM; mutex_lock(&mgr->lock); r = idr_alloc(&mgr->ctx_handles, ctx, 1, 0, GFP_KERNEL); if (r < 0) { mutex_unlock(&mgr->lock); kfree(ctx); return r; } *id = (uint32_t)r; r = amdgpu_ctx_init(adev, ctx); if (r) { idr_remove(&mgr->ctx_handles, *id); *id = 0; kfree(ctx); } mutex_unlock(&mgr->lock); return r; }

Contributors

PersonTokensPropCommitsCommitProp
Alex Deucher10966.06%114.29%
Chunming Zhou3722.42%342.86%
Christian König1710.30%228.57%
Marek Olšák21.21%114.29%
Total165100.00%7100.00%


static void amdgpu_ctx_do_release(struct kref *ref) { struct amdgpu_ctx *ctx; ctx = container_of(ref, struct amdgpu_ctx, refcount); amdgpu_ctx_fini(ctx); kfree(ctx); }

Contributors

PersonTokensPropCommitsCommitProp
Chunming Zhou1950.00%133.33%
Christian König1847.37%133.33%
Alex Deucher12.63%133.33%
Total38100.00%3100.00%


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); ctx = idr_remove(&mgr->ctx_handles, id); if (ctx) kref_put(&ctx->refcount, amdgpu_ctx_do_release); mutex_unlock(&mgr->lock); return ctx ? 0 : -EINVAL; }

Contributors

PersonTokensPropCommitsCommitProp
Alex Deucher5468.35%125.00%
Marek Olšák1518.99%125.00%
Christian König67.59%125.00%
Matthew Wilcox45.06%125.00%
Total79100.00%4100.00%


static int amdgpu_ctx_query(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; unsigned reset_counter; 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; } /* TODO: these two are always zero */ out->state.flags = 0x0; out->state.hangs = 0x0; /* 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. */ if (ctx->reset_counter == reset_counter) out->state.reset_status = AMDGPU_CTX_NO_RESET; else out->state.reset_status = AMDGPU_CTX_UNKNOWN_RESET; ctx->reset_counter = reset_counter; mutex_unlock(&mgr->lock); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Marek Olšák9256.44%240.00%
Alex Deucher5533.74%240.00%
Chunming Zhou169.82%120.00%
Total163100.00%5100.00%


int amdgpu_ctx_ioctl(struct drm_device *dev, void *data, struct drm_file *filp) { int r; uint32_t id; 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; switch (args->in.op) { case AMDGPU_CTX_OP_ALLOC_CTX: r = amdgpu_ctx_alloc(adev, fpriv, &id); 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; default: return -EINVAL; } return r; }

Contributors

PersonTokensPropCommitsCommitProp
Alex Deucher13899.28%150.00%
Marek Olšák10.72%150.00%
Total139100.00%2100.00%


struct amdgpu_ctx *amdgpu_ctx_get(struct amdgpu_fpriv *fpriv, uint32_t id) { struct amdgpu_ctx *ctx; struct amdgpu_ctx_mgr *mgr; if (!fpriv) return NULL; mgr = &fpriv->ctx_mgr; mutex_lock(&mgr->lock); ctx = idr_find(&mgr->ctx_handles, id); if (ctx) kref_get(&ctx->refcount); mutex_unlock(&mgr->lock); return ctx; }

Contributors

PersonTokensPropCommitsCommitProp
Jammy Zhou7185.54%150.00%
Chunming Zhou1214.46%150.00%
Total83100.00%2100.00%


int amdgpu_ctx_put(struct amdgpu_ctx *ctx) { if (ctx == NULL) return -EINVAL; kref_put(&ctx->refcount, amdgpu_ctx_do_release); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Jammy Zhou33100.00%1100.00%
Total33100.00%1100.00%


uint64_t amdgpu_ctx_add_fence(struct amdgpu_ctx *ctx, struct amdgpu_ring *ring, struct dma_fence *fence) { struct amdgpu_ctx_ring *cring = & ctx->rings[ring->idx]; uint64_t seq = cring->sequence; unsigned idx = 0; struct dma_fence *other = NULL; idx = seq & (amdgpu_sched_jobs - 1); other = cring->fences[idx]; if (other) { signed long r; r = dma_fence_wait_timeout(other, false, MAX_SCHEDULE_TIMEOUT); if (r < 0) DRM_ERROR("Error (%ld) waiting for fence!\n", r); } dma_fence_get(fence); spin_lock(&ctx->ring_lock); cring->fences[idx] = fence; cring->sequence++; spin_unlock(&ctx->ring_lock); dma_fence_put(other); return seq; }

Contributors

PersonTokensPropCommitsCommitProp
Christian König12986.00%233.33%
Chunming Zhou1610.67%350.00%
Chris Wilson53.33%116.67%
Total150100.00%6100.00%


struct dma_fence *amdgpu_ctx_get_fence(struct amdgpu_ctx *ctx, struct amdgpu_ring *ring, uint64_t seq) { struct amdgpu_ctx_ring *cring = & ctx->rings[ring->idx]; struct dma_fence *fence; spin_lock(&ctx->ring_lock); if (seq >= cring->sequence) { spin_unlock(&ctx->ring_lock); return ERR_PTR(-EINVAL); } if (seq + amdgpu_sched_jobs < cring->sequence) { spin_unlock(&ctx->ring_lock); return NULL; } fence = dma_fence_get(cring->fences[seq & (amdgpu_sched_jobs - 1)]); spin_unlock(&ctx->ring_lock); return fence; }

Contributors

PersonTokensPropCommitsCommitProp
Christian König11592.00%350.00%
Chunming Zhou75.60%233.33%
Chris Wilson32.40%116.67%
Total125100.00%6100.00%


void amdgpu_ctx_mgr_init(struct amdgpu_ctx_mgr *mgr) { mutex_init(&mgr->lock); idr_init(&mgr->ctx_handles); }

Contributors

PersonTokensPropCommitsCommitProp
Christian König26100.00%1100.00%
Total26100.00%1100.00%


void amdgpu_ctx_mgr_fini(struct amdgpu_ctx_mgr *mgr) { struct amdgpu_ctx *ctx; struct idr *idp; uint32_t id; idp = &mgr->ctx_handles; idr_for_each_entry(idp, ctx, id) { if (kref_put(&ctx->refcount, amdgpu_ctx_do_release) != 1) DRM_ERROR("ctx %p is still alive\n", ctx); } idr_destroy(&mgr->ctx_handles); mutex_destroy(&mgr->lock); }

Contributors

PersonTokensPropCommitsCommitProp
Christian König77100.00%1100.00%
Total77100.00%1100.00%


Overall Contributors

PersonTokensPropCommitsCommitProp
Christian König61241.07%1035.71%
Alex Deucher37625.23%27.14%
Chunming Zhou23615.84%725.00%
Marek Olšák1107.38%27.14%
Jammy Zhou1046.98%13.57%
Grazvydas Ignotas120.81%13.57%
Nicolai Hähnle120.81%13.57%
Chris Wilson100.67%13.57%
Huang Rui80.54%13.57%
Dave Airlie60.40%13.57%
Matthew Wilcox40.27%13.57%
Total1490100.00%28100.00%
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.