On 4/17/19 2:01 PM, Koenig, Christian wrote: > Am 17.04.19 um 19:59 schrieb Christian König: >> Am 17.04.19 um 19:53 schrieb Grodzovsky, Andrey: >>> On 4/17/19 1:17 PM, Christian König wrote: >>>> I can't review this patch, since I'm one of the authors of it, but in >>>> general your changes look good to me now. >>>> >>>> For patch #5 I think it might be cleaner if we move incrementing of >>>> the hw_rq_count while starting the scheduler again. >>> But the increment of hw_rq_count is conditional on if the guilty job >>> was signaled, moving it into drm_sched_start will also force me to pass >>> 'job_signaled' flag into drm_sched_start which is against your original >>> comment that we don't want to pass this logic around helper functions >>> and keep it all in one place which is amdgpu_device_gpu_recover. >> Well I hope that incrementing hw_rq_count is conditional for signaled >> jobs anyway, or otherwise we would seriously mess up the counter. >> >> E.g. in drm_sched_stop() we also only decrement it when we where able >> to remove the callback. > Ok, checking the code again we don't need any special handling here > since all signaled jobs are already removed from the mirror_list. > > Christian. We decrement in drm_sched_stop and then later if the guilty job is found to be signaled we are skipping drm_sched_resubmit_jobs and so will not increment back and then the count becomes 'negative' when the fence signals and i got a bug. But now i think what i need is to just move the atomic_inc(&sched->hw_rq_count) from drm_sched_resubmit_jobs into drm_sched_start and so this way i can get rid of the conditional re-incriment i am doing now. Agree ? Andrey > >> Christian. >> >>> Andrey >>> >>> >>>> Regards, >>>> Christian. >>>> >>>> Am 17.04.19 um 16:36 schrieb Grodzovsky, Andrey: >>>>> Ping on this patch and patch 5. The rest already RBed. >>>>> >>>>> Andrey >>>>> >>>>> On 4/16/19 2:23 PM, Andrey Grodzovsky wrote: >>>>>> From: Christian König <christian.koenig@xxxxxxx> >>>>>> >>>>>> We now destroy finished jobs from the worker thread to make sure that >>>>>> we never destroy a job currently in timeout processing. >>>>>> By this we avoid holding lock around ring mirror list in >>>>>> drm_sched_stop >>>>>> which should solve a deadlock reported by a user. >>>>>> >>>>>> v2: Remove unused variable. >>>>>> v4: Move guilty job free into sched code. >>>>>> >>>>>> Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=109692 >>>>>> >>>>>> Signed-off-by: Christian König <christian.koenig@xxxxxxx> >>>>>> Signed-off-by: Andrey Grodzovsky <andrey.grodzovsky@xxxxxxx> >>>>>> --- >>>>>> drivers/gpu/drm/amd/amdgpu/amdgpu_device.c | 9 +- >>>>>> drivers/gpu/drm/etnaviv/etnaviv_dump.c | 4 - >>>>>> drivers/gpu/drm/etnaviv/etnaviv_sched.c | 2 +- >>>>>> drivers/gpu/drm/lima/lima_sched.c | 2 +- >>>>>> drivers/gpu/drm/panfrost/panfrost_job.c | 2 +- >>>>>> drivers/gpu/drm/scheduler/sched_main.c | 145 >>>>>> +++++++++++++++++------------ >>>>>> drivers/gpu/drm/v3d/v3d_sched.c | 2 +- >>>>>> include/drm/gpu_scheduler.h | 6 +- >>>>>> 8 files changed, 94 insertions(+), 78 deletions(-) >>>>>> >>>>>> diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c >>>>>> b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c >>>>>> index 7cee269..a0e165c 100644 >>>>>> --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c >>>>>> +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c >>>>>> @@ -3334,7 +3334,7 @@ static int amdgpu_device_pre_asic_reset(struct >>>>>> amdgpu_device *adev, >>>>>> if (!ring || !ring->sched.thread) >>>>>> continue; >>>>>> - drm_sched_stop(&ring->sched); >>>>>> + drm_sched_stop(&ring->sched, &job->base); >>>>>> /* after all hw jobs are reset, hw fence is >>>>>> meaningless, so force_completion */ >>>>>> amdgpu_fence_driver_force_completion(ring); >>>>>> @@ -3343,8 +3343,6 @@ static int amdgpu_device_pre_asic_reset(struct >>>>>> amdgpu_device *adev, >>>>>> if(job) >>>>>> drm_sched_increase_karma(&job->base); >>>>>> - >>>>>> - >>>>>> if (!amdgpu_sriov_vf(adev)) { >>>>>> if (!need_full_reset) >>>>>> @@ -3482,8 +3480,7 @@ static int amdgpu_do_asic_reset(struct >>>>>> amdgpu_hive_info *hive, >>>>>> return r; >>>>>> } >>>>>> -static void amdgpu_device_post_asic_reset(struct amdgpu_device >>>>>> *adev, >>>>>> - struct amdgpu_job *job) >>>>>> +static void amdgpu_device_post_asic_reset(struct amdgpu_device >>>>>> *adev) >>>>>> { >>>>>> int i; >>>>>> @@ -3623,7 +3620,7 @@ int amdgpu_device_gpu_recover(struct >>>>>> amdgpu_device *adev, >>>>>> /* Post ASIC reset for all devs .*/ >>>>>> list_for_each_entry(tmp_adev, device_list_handle, >>>>>> gmc.xgmi.head) { >>>>>> - amdgpu_device_post_asic_reset(tmp_adev, tmp_adev == adev ? >>>>>> job : NULL); >>>>>> + amdgpu_device_post_asic_reset(tmp_adev); >>>>>> if (r) { >>>>>> /* bad news, how to tell it to userspace ? */ >>>>>> diff --git a/drivers/gpu/drm/etnaviv/etnaviv_dump.c >>>>>> b/drivers/gpu/drm/etnaviv/etnaviv_dump.c >>>>>> index 33854c9..5778d9c 100644 >>>>>> --- a/drivers/gpu/drm/etnaviv/etnaviv_dump.c >>>>>> +++ b/drivers/gpu/drm/etnaviv/etnaviv_dump.c >>>>>> @@ -135,13 +135,11 @@ void etnaviv_core_dump(struct etnaviv_gpu *gpu) >>>>>> mmu_size + gpu->buffer.size; >>>>>> /* Add in the active command buffers */ >>>>>> - spin_lock_irqsave(&gpu->sched.job_list_lock, flags); >>>>>> list_for_each_entry(s_job, &gpu->sched.ring_mirror_list, >>>>>> node) { >>>>>> submit = to_etnaviv_submit(s_job); >>>>>> file_size += submit->cmdbuf.size; >>>>>> n_obj++; >>>>>> } >>>>>> - spin_unlock_irqrestore(&gpu->sched.job_list_lock, flags); >>>>>> /* Add in the active buffer objects */ >>>>>> list_for_each_entry(vram, &gpu->mmu->mappings, mmu_node) { >>>>>> @@ -183,14 +181,12 @@ void etnaviv_core_dump(struct etnaviv_gpu *gpu) >>>>>> gpu->buffer.size, >>>>>> etnaviv_cmdbuf_get_va(&gpu->buffer)); >>>>>> - spin_lock_irqsave(&gpu->sched.job_list_lock, flags); >>>>>> list_for_each_entry(s_job, &gpu->sched.ring_mirror_list, >>>>>> node) { >>>>>> submit = to_etnaviv_submit(s_job); >>>>>> etnaviv_core_dump_mem(&iter, ETDUMP_BUF_CMD, >>>>>> submit->cmdbuf.vaddr, submit->cmdbuf.size, >>>>>> etnaviv_cmdbuf_get_va(&submit->cmdbuf)); >>>>>> } >>>>>> - spin_unlock_irqrestore(&gpu->sched.job_list_lock, flags); >>>>>> /* Reserve space for the bomap */ >>>>>> if (n_bomap_pages) { >>>>>> diff --git a/drivers/gpu/drm/etnaviv/etnaviv_sched.c >>>>>> b/drivers/gpu/drm/etnaviv/etnaviv_sched.c >>>>>> index 6d24fea..a813c82 100644 >>>>>> --- a/drivers/gpu/drm/etnaviv/etnaviv_sched.c >>>>>> +++ b/drivers/gpu/drm/etnaviv/etnaviv_sched.c >>>>>> @@ -109,7 +109,7 @@ static void etnaviv_sched_timedout_job(struct >>>>>> drm_sched_job *sched_job) >>>>>> } >>>>>> /* block scheduler */ >>>>>> - drm_sched_stop(&gpu->sched); >>>>>> + drm_sched_stop(&gpu->sched, sched_job); >>>>>> if(sched_job) >>>>>> drm_sched_increase_karma(sched_job); >>>>>> diff --git a/drivers/gpu/drm/lima/lima_sched.c >>>>>> b/drivers/gpu/drm/lima/lima_sched.c >>>>>> index 97bd9c1..df98931 100644 >>>>>> --- a/drivers/gpu/drm/lima/lima_sched.c >>>>>> +++ b/drivers/gpu/drm/lima/lima_sched.c >>>>>> @@ -300,7 +300,7 @@ static struct dma_fence >>>>>> *lima_sched_run_job(struct drm_sched_job *job) >>>>>> static void lima_sched_handle_error_task(struct lima_sched_pipe >>>>>> *pipe, >>>>>> struct lima_sched_task *task) >>>>>> { >>>>>> - drm_sched_stop(&pipe->base); >>>>>> + drm_sched_stop(&pipe->base, &task->base); >>>>>> if (task) >>>>>> drm_sched_increase_karma(&task->base); >>>>>> diff --git a/drivers/gpu/drm/panfrost/panfrost_job.c >>>>>> b/drivers/gpu/drm/panfrost/panfrost_job.c >>>>>> index 0a7ed04..c6336b7 100644 >>>>>> --- a/drivers/gpu/drm/panfrost/panfrost_job.c >>>>>> +++ b/drivers/gpu/drm/panfrost/panfrost_job.c >>>>>> @@ -385,7 +385,7 @@ static void panfrost_job_timedout(struct >>>>>> drm_sched_job *sched_job) >>>>>> sched_job); >>>>>> for (i = 0; i < NUM_JOB_SLOTS; i++) >>>>>> - drm_sched_stop(&pfdev->js->queue[i].sched); >>>>>> + drm_sched_stop(&pfdev->js->queue[i].sched, sched_job); >>>>>> if (sched_job) >>>>>> drm_sched_increase_karma(sched_job); >>>>>> diff --git a/drivers/gpu/drm/scheduler/sched_main.c >>>>>> b/drivers/gpu/drm/scheduler/sched_main.c >>>>>> index 19fc601..21e8734 100644 >>>>>> --- a/drivers/gpu/drm/scheduler/sched_main.c >>>>>> +++ b/drivers/gpu/drm/scheduler/sched_main.c >>>>>> @@ -265,32 +265,6 @@ void drm_sched_resume_timeout(struct >>>>>> drm_gpu_scheduler *sched, >>>>>> } >>>>>> EXPORT_SYMBOL(drm_sched_resume_timeout); >>>>>> -/* job_finish is called after hw fence signaled >>>>>> - */ >>>>>> -static void drm_sched_job_finish(struct work_struct *work) >>>>>> -{ >>>>>> - struct drm_sched_job *s_job = container_of(work, struct >>>>>> drm_sched_job, >>>>>> - finish_work); >>>>>> - struct drm_gpu_scheduler *sched = s_job->sched; >>>>>> - unsigned long flags; >>>>>> - >>>>>> - /* >>>>>> - * Canceling the timeout without removing our job from the ring >>>>>> mirror >>>>>> - * list is safe, as we will only end up in this worker if our >>>>>> jobs >>>>>> - * finished fence has been signaled. So even if some another >>>>>> worker >>>>>> - * manages to find this job as the next job in the list, the >>>>>> fence >>>>>> - * signaled check below will prevent the timeout to be >>>>>> restarted. >>>>>> - */ >>>>>> - cancel_delayed_work_sync(&sched->work_tdr); >>>>>> - >>>>>> - spin_lock_irqsave(&sched->job_list_lock, flags); >>>>>> - /* queue TDR for next job */ >>>>>> - drm_sched_start_timeout(sched); >>>>>> - spin_unlock_irqrestore(&sched->job_list_lock, flags); >>>>>> - >>>>>> - sched->ops->free_job(s_job); >>>>>> -} >>>>>> - >>>>>> static void drm_sched_job_begin(struct drm_sched_job *s_job) >>>>>> { >>>>>> struct drm_gpu_scheduler *sched = s_job->sched; >>>>>> @@ -315,6 +289,13 @@ static void drm_sched_job_timedout(struct >>>>>> work_struct *work) >>>>>> if (job) >>>>>> job->sched->ops->timedout_job(job); >>>>>> + /* >>>>>> + * Guilty job did complete and hence needs to be manually >>>>>> removed >>>>>> + * See drm_sched_stop doc. >>>>>> + */ >>>>>> + if (list_empty(&job->node)) >>>>>> + job->sched->ops->free_job(job); >>>>>> + >>>>>> spin_lock_irqsave(&sched->job_list_lock, flags); >>>>>> drm_sched_start_timeout(sched); >>>>>> spin_unlock_irqrestore(&sched->job_list_lock, flags); >>>>>> @@ -371,23 +352,26 @@ EXPORT_SYMBOL(drm_sched_increase_karma); >>>>>> * @sched: scheduler instance >>>>>> * @bad: bad scheduler job >>>>>> * >>>>>> + * Stop the scheduler and also removes and frees all completed jobs. >>>>>> + * Note: bad job will not be freed as it might be used later and so >>>>>> it's >>>>>> + * callers responsibility to release it manually if it's not part >>>>>> of the >>>>>> + * mirror list any more. >>>>>> + * >>>>>> */ >>>>>> -void drm_sched_stop(struct drm_gpu_scheduler *sched) >>>>>> +void drm_sched_stop(struct drm_gpu_scheduler *sched, struct >>>>>> drm_sched_job *bad) >>>>>> { >>>>>> - struct drm_sched_job *s_job; >>>>>> + struct drm_sched_job *s_job, *tmp; >>>>>> unsigned long flags; >>>>>> - struct dma_fence *last_fence = NULL; >>>>>> kthread_park(sched->thread); >>>>>> /* >>>>>> - * Verify all the signaled jobs in mirror list are removed from >>>>>> the ring >>>>>> - * by waiting for the latest job to enter the list. This should >>>>>> insure that >>>>>> - * also all the previous jobs that were in flight also already >>>>>> singaled >>>>>> - * and removed from the list. >>>>>> + * Iterate the job list from later to earlier one and either >>>>>> deactive >>>>>> + * their HW callbacks or remove them from mirror list if they >>>>>> already >>>>>> + * signaled. >>>>>> + * This iteration is thread safe as sched thread is stopped. >>>>>> */ >>>>>> - spin_lock_irqsave(&sched->job_list_lock, flags); >>>>>> - list_for_each_entry_reverse(s_job, &sched->ring_mirror_list, >>>>>> node) { >>>>>> + list_for_each_entry_safe_reverse(s_job, tmp, >>>>>> &sched->ring_mirror_list, node) { >>>>>> if (s_job->s_fence->parent && >>>>>> dma_fence_remove_callback(s_job->s_fence->parent, >>>>>> &s_job->cb)) { >>>>>> @@ -395,16 +379,30 @@ void drm_sched_stop(struct drm_gpu_scheduler >>>>>> *sched) >>>>>> s_job->s_fence->parent = NULL; >>>>>> atomic_dec(&sched->hw_rq_count); >>>>>> } else { >>>>>> - last_fence = dma_fence_get(&s_job->s_fence->finished); >>>>>> - break; >>>>>> + /* >>>>>> + * remove job from ring_mirror_list. >>>>>> + * Locking here is for concurrent resume timeout >>>>>> + */ >>>>>> + spin_lock_irqsave(&sched->job_list_lock, flags); >>>>>> + list_del_init(&s_job->node); >>>>>> + spin_unlock_irqrestore(&sched->job_list_lock, flags); >>>>>> + >>>>>> + /* >>>>>> + * Wait for job's HW fence callback to finish using >>>>>> s_job >>>>>> + * before releasing it. >>>>>> + * >>>>>> + * Job is still alive so fence refcount at least 1 >>>>>> + */ >>>>>> + dma_fence_wait(&s_job->s_fence->finished, false); >>>>>> + >>>>>> + /* >>>>>> + * We must keep bad job alive for later use during >>>>>> + * recovery by some of the drivers >>>>>> + */ >>>>>> + if (bad != s_job) >>>>>> + sched->ops->free_job(s_job); >>>>>> } >>>>>> } >>>>>> - spin_unlock_irqrestore(&sched->job_list_lock, flags); >>>>>> - >>>>>> - if (last_fence) { >>>>>> - dma_fence_wait(last_fence, false); >>>>>> - dma_fence_put(last_fence); >>>>>> - } >>>>>> } >>>>>> EXPORT_SYMBOL(drm_sched_stop); >>>>>> @@ -418,6 +416,7 @@ EXPORT_SYMBOL(drm_sched_stop); >>>>>> void drm_sched_start(struct drm_gpu_scheduler *sched, bool >>>>>> full_recovery) >>>>>> { >>>>>> struct drm_sched_job *s_job, *tmp; >>>>>> + unsigned long flags; >>>>>> int r; >>>>>> if (!full_recovery) >>>>>> @@ -425,9 +424,7 @@ void drm_sched_start(struct drm_gpu_scheduler >>>>>> *sched, bool full_recovery) >>>>>> /* >>>>>> * Locking the list is not required here as the sched thread >>>>>> is parked >>>>>> - * so no new jobs are being pushed in to HW and in >>>>>> drm_sched_stop we >>>>>> - * flushed all the jobs who were still in mirror list but who >>>>>> already >>>>>> - * signaled and removed them self from the list. Also concurrent >>>>>> + * so no new jobs are being inserted or removed. Also concurrent >>>>>> * GPU recovers can't run in parallel. >>>>>> */ >>>>>> list_for_each_entry_safe(s_job, tmp, >>>>>> &sched->ring_mirror_list, node) { >>>>>> @@ -445,7 +442,9 @@ void drm_sched_start(struct drm_gpu_scheduler >>>>>> *sched, bool full_recovery) >>>>>> drm_sched_process_job(NULL, &s_job->cb); >>>>>> } >>>>>> + spin_lock_irqsave(&sched->job_list_lock, flags); >>>>>> drm_sched_start_timeout(sched); >>>>>> + spin_unlock_irqrestore(&sched->job_list_lock, flags); >>>>>> unpark: >>>>>> kthread_unpark(sched->thread); >>>>>> @@ -464,7 +463,6 @@ void drm_sched_resubmit_jobs(struct >>>>>> drm_gpu_scheduler *sched) >>>>>> uint64_t guilty_context; >>>>>> bool found_guilty = false; >>>>>> - /*TODO DO we need spinlock here ? */ >>>>>> list_for_each_entry_safe(s_job, tmp, >>>>>> &sched->ring_mirror_list, node) { >>>>>> struct drm_sched_fence *s_fence = s_job->s_fence; >>>>>> @@ -514,7 +512,6 @@ int drm_sched_job_init(struct drm_sched_job >>>>>> *job, >>>>>> return -ENOMEM; >>>>>> job->id = atomic64_inc_return(&sched->job_id_count); >>>>>> - INIT_WORK(&job->finish_work, drm_sched_job_finish); >>>>>> INIT_LIST_HEAD(&job->node); >>>>>> return 0; >>>>>> @@ -597,24 +594,53 @@ static void drm_sched_process_job(struct >>>>>> dma_fence *f, struct dma_fence_cb *cb) >>>>>> struct drm_sched_job *s_job = container_of(cb, struct >>>>>> drm_sched_job, cb); >>>>>> struct drm_sched_fence *s_fence = s_job->s_fence; >>>>>> struct drm_gpu_scheduler *sched = s_fence->sched; >>>>>> - unsigned long flags; >>>>>> - >>>>>> - cancel_delayed_work(&sched->work_tdr); >>>>>> atomic_dec(&sched->hw_rq_count); >>>>>> atomic_dec(&sched->num_jobs); >>>>>> - spin_lock_irqsave(&sched->job_list_lock, flags); >>>>>> - /* remove job from ring_mirror_list */ >>>>>> - list_del_init(&s_job->node); >>>>>> - spin_unlock_irqrestore(&sched->job_list_lock, flags); >>>>>> + trace_drm_sched_process_job(s_fence); >>>>>> drm_sched_fence_finished(s_fence); >>>>>> - >>>>>> - trace_drm_sched_process_job(s_fence); >>>>>> wake_up_interruptible(&sched->wake_up_worker); >>>>>> +} >>>>>> + >>>>>> +/** >>>>>> + * drm_sched_cleanup_jobs - destroy finished jobs >>>>>> + * >>>>>> + * @sched: scheduler instance >>>>>> + * >>>>>> + * Remove all finished jobs from the mirror list and destroy them. >>>>>> + */ >>>>>> +static void drm_sched_cleanup_jobs(struct drm_gpu_scheduler *sched) >>>>>> +{ >>>>>> + unsigned long flags; >>>>>> + >>>>>> + /* Don't destroy jobs while the timeout worker is running */ >>>>>> + if (!cancel_delayed_work(&sched->work_tdr)) >>>>>> + return; >>>>>> + >>>>>> + >>>>>> + while (!list_empty(&sched->ring_mirror_list)) { >>>>>> + struct drm_sched_job *job; >>>>>> + >>>>>> + job = list_first_entry(&sched->ring_mirror_list, >>>>>> + struct drm_sched_job, node); >>>>>> + if (!dma_fence_is_signaled(&job->s_fence->finished)) >>>>>> + break; >>>>>> + >>>>>> + spin_lock_irqsave(&sched->job_list_lock, flags); >>>>>> + /* remove job from ring_mirror_list */ >>>>>> + list_del_init(&job->node); >>>>>> + spin_unlock_irqrestore(&sched->job_list_lock, flags); >>>>>> + >>>>>> + sched->ops->free_job(job); >>>>>> + } >>>>>> + >>>>>> + /* queue timeout for next job */ >>>>>> + spin_lock_irqsave(&sched->job_list_lock, flags); >>>>>> + drm_sched_start_timeout(sched); >>>>>> + spin_unlock_irqrestore(&sched->job_list_lock, flags); >>>>>> - schedule_work(&s_job->finish_work); >>>>>> } >>>>>> /** >>>>>> @@ -656,9 +682,10 @@ static int drm_sched_main(void *param) >>>>>> struct dma_fence *fence; >>>>>> wait_event_interruptible(sched->wake_up_worker, >>>>>> + (drm_sched_cleanup_jobs(sched), >>>>>> (!drm_sched_blocked(sched) && >>>>>> (entity = >>>>>> drm_sched_select_entity(sched))) || >>>>>> - kthread_should_stop()); >>>>>> + kthread_should_stop())); >>>>>> if (!entity) >>>>>> continue; >>>>>> diff --git a/drivers/gpu/drm/v3d/v3d_sched.c >>>>>> b/drivers/gpu/drm/v3d/v3d_sched.c >>>>>> index e740f3b..1a4abe7 100644 >>>>>> --- a/drivers/gpu/drm/v3d/v3d_sched.c >>>>>> +++ b/drivers/gpu/drm/v3d/v3d_sched.c >>>>>> @@ -232,7 +232,7 @@ v3d_gpu_reset_for_timeout(struct v3d_dev *v3d, >>>>>> struct drm_sched_job *sched_job) >>>>>> /* block scheduler */ >>>>>> for (q = 0; q < V3D_MAX_QUEUES; q++) >>>>>> - drm_sched_stop(&v3d->queue[q].sched); >>>>>> + drm_sched_stop(&v3d->queue[q].sched, sched_job); >>>>>> if (sched_job) >>>>>> drm_sched_increase_karma(sched_job); >>>>>> diff --git a/include/drm/gpu_scheduler.h >>>>>> b/include/drm/gpu_scheduler.h >>>>>> index 0daca4d..9ee0f27 100644 >>>>>> --- a/include/drm/gpu_scheduler.h >>>>>> +++ b/include/drm/gpu_scheduler.h >>>>>> @@ -167,9 +167,6 @@ struct drm_sched_fence >>>>>> *to_drm_sched_fence(struct dma_fence *f); >>>>>> * @sched: the scheduler instance on which this job is scheduled. >>>>>> * @s_fence: contains the fences for the scheduling of job. >>>>>> * @finish_cb: the callback for the finished fence. >>>>>> - * @finish_work: schedules the function @drm_sched_job_finish once >>>>>> the job has >>>>>> - * finished to remove the job from the >>>>>> - * @drm_gpu_scheduler.ring_mirror_list. >>>>>> * @node: used to append this struct to the >>>>>> @drm_gpu_scheduler.ring_mirror_list. >>>>>> * @id: a unique id assigned to each job scheduled on the >>>>>> scheduler. >>>>>> * @karma: increment on every hang caused by this job. If this >>>>>> exceeds the hang >>>>>> @@ -188,7 +185,6 @@ struct drm_sched_job { >>>>>> struct drm_gpu_scheduler *sched; >>>>>> struct drm_sched_fence *s_fence; >>>>>> struct dma_fence_cb finish_cb; >>>>>> - struct work_struct finish_work; >>>>>> struct list_head node; >>>>>> uint64_t id; >>>>>> atomic_t karma; >>>>>> @@ -296,7 +292,7 @@ int drm_sched_job_init(struct drm_sched_job *job, >>>>>> void *owner); >>>>>> void drm_sched_job_cleanup(struct drm_sched_job *job); >>>>>> void drm_sched_wakeup(struct drm_gpu_scheduler *sched); >>>>>> -void drm_sched_stop(struct drm_gpu_scheduler *sched); >>>>>> +void drm_sched_stop(struct drm_gpu_scheduler *sched, struct >>>>>> drm_sched_job *bad); >>>>>> void drm_sched_start(struct drm_gpu_scheduler *sched, bool >>>>>> full_recovery); >>>>>> void drm_sched_resubmit_jobs(struct drm_gpu_scheduler *sched); >>>>>> void drm_sched_increase_karma(struct drm_sched_job *bad); >>> _______________________________________________ >>> amd-gfx mailing list >>> amd-gfx@xxxxxxxxxxxxxxxxxxxxx >>> https://lists.freedesktop.org/mailman/listinfo/amd-gfx _______________________________________________ amd-gfx mailing list amd-gfx@xxxxxxxxxxxxxxxxxxxxx https://lists.freedesktop.org/mailman/listinfo/amd-gfx
