drivers/gpu/drm/amd/scheduler/gpu_scheduler.c

   1 /*
   2  * Copyright 2015 Advanced Micro Devices, Inc.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20  * OTHER DEALINGS IN THE SOFTWARE.
  21  *
  22  *
  23  */
  24 #include <linux/kthread.h>
  25 #include <linux/wait.h>
  26 #include <linux/sched.h>
  27 #include <uapi/linux/sched/types.h>
  28 #include <drm/drmP.h>
  29 #include "gpu_scheduler.h"
  30
  31 #define CREATE_TRACE_POINTS
  32 #include "gpu_sched_trace.h"
  33
  34 static bool amd_sched_entity_is_ready(struct amd_sched_entity *entity);
  35 static void amd_sched_wakeup(struct amd_gpu_scheduler *sched);
  36 static void amd_sched_process_job(struct dma_fence *f, struct dma_fence_cb *cb);
  37
  38 /* Initialize a given run queue struct */
  39 static void amd_sched_rq_init(struct amd_sched_rq *rq)
  40 {
  41         spin_lock_init(&rq->lock);
  42         INIT_LIST_HEAD(&rq->entities);
  43         rq->current_entity = NULL;
  44 }
  45
  46 static void amd_sched_rq_add_entity(struct amd_sched_rq *rq,
  47                                     struct amd_sched_entity *entity)
  48 {
  49         if (!list_empty(&entity->list))
  50                 return;
  51         spin_lock(&rq->lock);
  52         list_add_tail(&entity->list, &rq->entities);
  53         spin_unlock(&rq->lock);
  54 }
  55
  56 static void amd_sched_rq_remove_entity(struct amd_sched_rq *rq,
  57                                        struct amd_sched_entity *entity)
  58 {
  59         if (list_empty(&entity->list))
  60                 return;
  61         spin_lock(&rq->lock);
  62         list_del_init(&entity->list);
  63         if (rq->current_entity == entity)
  64                 rq->current_entity = NULL;
  65         spin_unlock(&rq->lock);
  66 }
  67
  68 /**
  69  * Select an entity which could provide a job to run
  70  *
  71  * @rq          The run queue to check.
  72  *
  73  * Try to find a ready entity, returns NULL if none found.
  74  */
  75 static struct amd_sched_entity *
  76 amd_sched_rq_select_entity(struct amd_sched_rq *rq)
  77 {
  78         struct amd_sched_entity *entity;
  79
  80         spin_lock(&rq->lock);
  81
  82         entity = rq->current_entity;
  83         if (entity) {
  84                 list_for_each_entry_continue(entity, &rq->entities, list) {
  85                         if (amd_sched_entity_is_ready(entity)) {
  86                                 rq->current_entity = entity;
  87                                 spin_unlock(&rq->lock);
  88                                 return entity;
  89                         }
  90                 }
  91         }
  92
  93         list_for_each_entry(entity, &rq->entities, list) {
  94
  95                 if (amd_sched_entity_is_ready(entity)) {
  96                         rq->current_entity = entity;
  97                         spin_unlock(&rq->lock);
  98                         return entity;
  99                 }
 100
 101                 if (entity == rq->current_entity)
 102                         break;
 103         }
 104
 105         spin_unlock(&rq->lock);
 106
 107         return NULL;
 108 }
 109
 110 /**
 111  * Init a context entity used by scheduler when submit to HW ring.
 112  *
 113  * @sched       The pointer to the scheduler
 114  * @entity      The pointer to a valid amd_sched_entity
 115  * @rq          The run queue this entity belongs
 116  * @kernel      If this is an entity for the kernel
 117  * @jobs        The max number of jobs in the job queue
 118  *
 119  * return 0 if succeed. negative error code on failure
 120 */
 121 int amd_sched_entity_init(struct amd_gpu_scheduler *sched,
 122                           struct amd_sched_entity *entity,
 123                           struct amd_sched_rq *rq,
 124                           uint32_t jobs)
 125 {
 126         int r;
 127
 128         if (!(sched && entity && rq))
 129                 return -EINVAL;
 130
 131         memset(entity, 0, sizeof(struct amd_sched_entity));
 132         INIT_LIST_HEAD(&entity->list);
 133         entity->rq = rq;
 134         entity->sched = sched;
 135
 136         spin_lock_init(&entity->queue_lock);
 137         r = kfifo_alloc(&entity->job_queue, jobs * sizeof(void *), GFP_KERNEL);
 138         if (r)
 139                 return r;
 140
 141         atomic_set(&entity->fence_seq, 0);
 142         entity->fence_context = dma_fence_context_alloc(2);
 143
 144         return 0;
 145 }
 146
 147 /**
 148  * Query if entity is initialized
 149  *
 150  * @sched       Pointer to scheduler instance
 151  * @entity      The pointer to a valid scheduler entity
 152  *
 153  * return true if entity is initialized, false otherwise
 154 */
 155 static bool amd_sched_entity_is_initialized(struct amd_gpu_scheduler *sched,
 156                                             struct amd_sched_entity *entity)
 157 {
 158         return entity->sched == sched &&
 159                 entity->rq != NULL;
 160 }
 161
 162 /**
 163  * Check if entity is idle
 164  *
 165  * @entity      The pointer to a valid scheduler entity
 166  *
 167  * Return true if entity don't has any unscheduled jobs.
 168  */
 169 static bool amd_sched_entity_is_idle(struct amd_sched_entity *entity)
 170 {
 171         rmb();
 172         if (kfifo_is_empty(&entity->job_queue))
 173                 return true;
 174
 175         return false;
 176 }
 177
 178 /**
 179  * Check if entity is ready
 180  *
 181  * @entity      The pointer to a valid scheduler entity
 182  *
 183  * Return true if entity could provide a job.
 184  */
 185 static bool amd_sched_entity_is_ready(struct amd_sched_entity *entity)
 186 {
 187         if (kfifo_is_empty(&entity->job_queue))
 188                 return false;
 189
 190         if (ACCESS_ONCE(entity->dependency))
 191                 return false;
 192
 193         return true;
 194 }
 195
 196 /**
 197  * Destroy a context entity
 198  *
 199  * @sched       Pointer to scheduler instance
 200  * @entity      The pointer to a valid scheduler entity
 201  *
 202  * Cleanup and free the allocated resources.
 203  */
 204 void amd_sched_entity_fini(struct amd_gpu_scheduler *sched,
 205                            struct amd_sched_entity *entity)
 206 {
 207         struct amd_sched_rq *rq = entity->rq;
 208
 209         if (!amd_sched_entity_is_initialized(sched, entity))
 210                 return;
 211
 212         /**
 213          * The client will not queue more IBs during this fini, consume existing
 214          * queued IBs
 215         */
 216         wait_event(sched->job_scheduled, amd_sched_entity_is_idle(entity));
 217
 218         amd_sched_rq_remove_entity(rq, entity);
 219         kfifo_free(&entity->job_queue);
 220 }
 221
 222 static void amd_sched_entity_wakeup(struct dma_fence *f, struct dma_fence_cb *cb)
 223 {
 224         struct amd_sched_entity *entity =
 225                 container_of(cb, struct amd_sched_entity, cb);
 226         entity->dependency = NULL;
 227         dma_fence_put(f);
 228         amd_sched_wakeup(entity->sched);
 229 }
 230
 231 static void amd_sched_entity_clear_dep(struct dma_fence *f, struct dma_fence_cb *cb)
 232 {
 233         struct amd_sched_entity *entity =
 234                 container_of(cb, struct amd_sched_entity, cb);
 235         entity->dependency = NULL;
 236         dma_fence_put(f);
 237 }
 238
 239 bool amd_sched_dependency_optimized(struct dma_fence* fence,
 240                                     struct amd_sched_entity *entity)
 241 {
 242         struct amd_gpu_scheduler *sched = entity->sched;
 243         struct amd_sched_fence *s_fence;
 244
 245         if (!fence || dma_fence_is_signaled(fence))
 246                 return false;
 247         if (fence->context == entity->fence_context)
 248                 return true;
 249         s_fence = to_amd_sched_fence(fence);
 250         if (s_fence && s_fence->sched == sched)
 251                 return true;
 252
 253         return false;
 254 }
 255
 256 static bool amd_sched_entity_add_dependency_cb(struct amd_sched_entity *entity)
 257 {
 258         struct amd_gpu_scheduler *sched = entity->sched;
 259         struct dma_fence * fence = entity->dependency;
 260         struct amd_sched_fence *s_fence;
 261
 262         if (fence->context == entity->fence_context) {
 263                 /* We can ignore fences from ourself */
 264                 dma_fence_put(entity->dependency);
 265                 return false;
 266         }
 267
 268         s_fence = to_amd_sched_fence(fence);
 269         if (s_fence && s_fence->sched == sched) {
 270
 271                 /*
 272                  * Fence is from the same scheduler, only need to wait for
 273                  * it to be scheduled
 274                  */
 275                 fence = dma_fence_get(&s_fence->scheduled);
 276                 dma_fence_put(entity->dependency);
 277                 entity->dependency = fence;
 278                 if (!dma_fence_add_callback(fence, &entity->cb,
 279                                             amd_sched_entity_clear_dep))
 280                         return true;
 281
 282                 /* Ignore it when it is already scheduled */
 283                 dma_fence_put(fence);
 284                 return false;
 285         }
 286
 287         if (!dma_fence_add_callback(entity->dependency, &entity->cb,
 288                                     amd_sched_entity_wakeup))
 289                 return true;
 290
 291         dma_fence_put(entity->dependency);
 292         return false;
 293 }
 294
 295 static struct amd_sched_job *
 296 amd_sched_entity_pop_job(struct amd_sched_entity *entity)
 297 {
 298         struct amd_gpu_scheduler *sched = entity->sched;
 299         struct amd_sched_job *sched_job;
 300
 301         if (!kfifo_out_peek(&entity->job_queue, &sched_job, sizeof(sched_job)))
 302                 return NULL;
 303
 304         while ((entity->dependency = sched->ops->dependency(sched_job)))
 305                 if (amd_sched_entity_add_dependency_cb(entity))
 306                         return NULL;
 307
 308         return sched_job;
 309 }
 310
 311 /**
 312  * Helper to submit a job to the job queue
 313  *
 314  * @sched_job           The pointer to job required to submit
 315  *
 316  * Returns true if we could submit the job.
 317  */
 318 static bool amd_sched_entity_in(struct amd_sched_job *sched_job)
 319 {
 320         struct amd_gpu_scheduler *sched = sched_job->sched;
 321         struct amd_sched_entity *entity = sched_job->s_entity;
 322         bool added, first = false;
 323
 324         spin_lock(&entity->queue_lock);
 325         added = kfifo_in(&entity->job_queue, &sched_job,
 326                         sizeof(sched_job)) == sizeof(sched_job);
 327
 328         if (added && kfifo_len(&entity->job_queue) == sizeof(sched_job))
 329                 first = true;
 330
 331         spin_unlock(&entity->queue_lock);
 332
 333         /* first job wakes up scheduler */
 334         if (first) {
 335                 /* Add the entity to the run queue */
 336                 amd_sched_rq_add_entity(entity->rq, entity);
 337                 amd_sched_wakeup(sched);
 338         }
 339         return added;
 340 }
 341
 342 /* job_finish is called after hw fence signaled, and
 343  * the job had already been deleted from ring_mirror_list
 344  */
 345 static void amd_sched_job_finish(struct work_struct *work)
 346 {
 347         struct amd_sched_job *s_job = container_of(work, struct amd_sched_job,
 348                                                    finish_work);
 349         struct amd_gpu_scheduler *sched = s_job->sched;
 350
 351         /* remove job from ring_mirror_list */
 352         spin_lock(&sched->job_list_lock);
 353         list_del_init(&s_job->node);
 354         if (sched->timeout != MAX_SCHEDULE_TIMEOUT) {
 355                 struct amd_sched_job *next;
 356
 357                 spin_unlock(&sched->job_list_lock);
 358                 cancel_delayed_work_sync(&s_job->work_tdr);
 359                 spin_lock(&sched->job_list_lock);
 360
 361                 /* queue TDR for next job */
 362                 next = list_first_entry_or_null(&sched->ring_mirror_list,
 363                                                 struct amd_sched_job, node);
 364
 365                 if (next)
 366                         schedule_delayed_work(&next->work_tdr, sched->timeout);
 367         }
 368         spin_unlock(&sched->job_list_lock);
 369         sched->ops->free_job(s_job);
 370 }
 371
 372 static void amd_sched_job_finish_cb(struct dma_fence *f,
 373                                     struct dma_fence_cb *cb)
 374 {
 375         struct amd_sched_job *job = container_of(cb, struct amd_sched_job,
 376                                                  finish_cb);
 377         schedule_work(&job->finish_work);
 378 }
 379
 380 static void amd_sched_job_begin(struct amd_sched_job *s_job)
 381 {
 382         struct amd_gpu_scheduler *sched = s_job->sched;
 383
 384         spin_lock(&sched->job_list_lock);
 385         list_add_tail(&s_job->node, &sched->ring_mirror_list);
 386         if (sched->timeout != MAX_SCHEDULE_TIMEOUT &&
 387             list_first_entry_or_null(&sched->ring_mirror_list,
 388                                      struct amd_sched_job, node) == s_job)
 389                 schedule_delayed_work(&s_job->work_tdr, sched->timeout);
 390         spin_unlock(&sched->job_list_lock);
 391 }
 392
 393 static void amd_sched_job_timedout(struct work_struct *work)
 394 {
 395         struct amd_sched_job *job = container_of(work, struct amd_sched_job,
 396                                                  work_tdr.work);
 397
 398         job->sched->ops->timedout_job(job);
 399 }
 400
 401 void amd_sched_hw_job_reset(struct amd_gpu_scheduler *sched)
 402 {
 403         struct amd_sched_job *s_job;
 404
 405         spin_lock(&sched->job_list_lock);
 406         list_for_each_entry_reverse(s_job, &sched->ring_mirror_list, node) {
 407                 if (s_job->s_fence->parent &&
 408                     dma_fence_remove_callback(s_job->s_fence->parent,
 409                                               &s_job->s_fence->cb)) {
 410                         dma_fence_put(s_job->s_fence->parent);
 411                         s_job->s_fence->parent = NULL;
 412                 }
 413         }
 414         atomic_set(&sched->hw_rq_count, 0);
 415         spin_unlock(&sched->job_list_lock);
 416 }
 417
 418 void amd_sched_job_recovery(struct amd_gpu_scheduler *sched)
 419 {
 420         struct amd_sched_job *s_job, *tmp;
 421         int r;
 422
 423         spin_lock(&sched->job_list_lock);
 424         s_job = list_first_entry_or_null(&sched->ring_mirror_list,
 425                                          struct amd_sched_job, node);
 426         if (s_job && sched->timeout != MAX_SCHEDULE_TIMEOUT)
 427                 schedule_delayed_work(&s_job->work_tdr, sched->timeout);
 428
 429         list_for_each_entry_safe(s_job, tmp, &sched->ring_mirror_list, node) {
 430                 struct amd_sched_fence *s_fence = s_job->s_fence;
 431                 struct dma_fence *fence;
 432
 433                 spin_unlock(&sched->job_list_lock);
 434                 fence = sched->ops->run_job(s_job);
 435                 atomic_inc(&sched->hw_rq_count);
 436                 if (fence) {
 437                         s_fence->parent = dma_fence_get(fence);
 438                         r = dma_fence_add_callback(fence, &s_fence->cb,
 439                                                    amd_sched_process_job);
 440                         if (r == -ENOENT)
 441                                 amd_sched_process_job(fence, &s_fence->cb);
 442                         else if (r)
 443                                 DRM_ERROR("fence add callback failed (%d)\n",
 444                                           r);
 445                         dma_fence_put(fence);
 446                 } else {
 447                         DRM_ERROR("Failed to run job!\n");
 448                         amd_sched_process_job(NULL, &s_fence->cb);
 449                 }
 450                 spin_lock(&sched->job_list_lock);
 451         }
 452         spin_unlock(&sched->job_list_lock);
 453 }
 454
 455 /**
 456  * Submit a job to the job queue
 457  *
 458  * @sched_job           The pointer to job required to submit
 459  *
 460  * Returns 0 for success, negative error code otherwise.
 461  */
 462 void amd_sched_entity_push_job(struct amd_sched_job *sched_job)
 463 {
 464         struct amd_sched_entity *entity = sched_job->s_entity;
 465
 466         trace_amd_sched_job(sched_job);
 467         dma_fence_add_callback(&sched_job->s_fence->finished, &sched_job->finish_cb,
 468                                amd_sched_job_finish_cb);
 469         wait_event(entity->sched->job_scheduled,
 470                    amd_sched_entity_in(sched_job));
 471 }
 472
 473 /* init a sched_job with basic field */
 474 int amd_sched_job_init(struct amd_sched_job *job,
 475                        struct amd_gpu_scheduler *sched,
 476                        struct amd_sched_entity *entity,
 477                        void *owner)
 478 {
 479         job->sched = sched;
 480         job->s_entity = entity;
 481         job->s_fence = amd_sched_fence_create(entity, owner);
 482         if (!job->s_fence)
 483                 return -ENOMEM;
 484         job->id = atomic64_inc_return(&sched->job_id_count);
 485
 486         INIT_WORK(&job->finish_work, amd_sched_job_finish);
 487         INIT_LIST_HEAD(&job->node);
 488         INIT_DELAYED_WORK(&job->work_tdr, amd_sched_job_timedout);
 489
 490         return 0;
 491 }
 492
 493 /**
 494  * Return ture if we can push more jobs to the hw.
 495  */
 496 static bool amd_sched_ready(struct amd_gpu_scheduler *sched)
 497 {
 498         return atomic_read(&sched->hw_rq_count) <
 499                 sched->hw_submission_limit;
 500 }
 501
 502 /**
 503  * Wake up the scheduler when it is ready
 504  */
 505 static void amd_sched_wakeup(struct amd_gpu_scheduler *sched)
 506 {
 507         if (amd_sched_ready(sched))
 508                 wake_up_interruptible(&sched->wake_up_worker);
 509 }
 510
 511 /**
 512  * Select next entity to process
 513 */
 514 static struct amd_sched_entity *
 515 amd_sched_select_entity(struct amd_gpu_scheduler *sched)
 516 {
 517         struct amd_sched_entity *entity;
 518         int i;
 519
 520         if (!amd_sched_ready(sched))
 521                 return NULL;
 522
 523         /* Kernel run queue has higher priority than normal run queue*/
 524         for (i = AMD_SCHED_PRIORITY_MAX - 1; i >= AMD_SCHED_PRIORITY_MIN; i--) {
 525                 entity = amd_sched_rq_select_entity(&sched->sched_rq[i]);
 526                 if (entity)
 527                         break;
 528         }
 529
 530         return entity;
 531 }
 532
 533 static void amd_sched_process_job(struct dma_fence *f, struct dma_fence_cb *cb)
 534 {
 535         struct amd_sched_fence *s_fence =
 536                 container_of(cb, struct amd_sched_fence, cb);
 537         struct amd_gpu_scheduler *sched = s_fence->sched;
 538
 539         atomic_dec(&sched->hw_rq_count);
 540         amd_sched_fence_finished(s_fence);
 541
 542         trace_amd_sched_process_job(s_fence);
 543         dma_fence_put(&s_fence->finished);
 544         wake_up_interruptible(&sched->wake_up_worker);
 545 }
 546
 547 static bool amd_sched_blocked(struct amd_gpu_scheduler *sched)
 548 {
 549         if (kthread_should_park()) {
 550                 kthread_parkme();
 551                 return true;
 552         }
 553
 554         return false;
 555 }
 556
 557 static int amd_sched_main(void *param)
 558 {
 559         struct sched_param sparam = {.sched_priority = 1};
 560         struct amd_gpu_scheduler *sched = (struct amd_gpu_scheduler *)param;
 561         int r, count;
 562
 563         sched_setscheduler(current, SCHED_FIFO, &sparam);
 564
 565         while (!kthread_should_stop()) {
 566                 struct amd_sched_entity *entity = NULL;
 567                 struct amd_sched_fence *s_fence;
 568                 struct amd_sched_job *sched_job;
 569                 struct dma_fence *fence;
 570
 571                 wait_event_interruptible(sched->wake_up_worker,
 572                                          (!amd_sched_blocked(sched) &&
 573                                           (entity = amd_sched_select_entity(sched))) ||
 574                                          kthread_should_stop());
 575
 576                 if (!entity)
 577                         continue;
 578
 579                 sched_job = amd_sched_entity_pop_job(entity);
 580                 if (!sched_job)
 581                         continue;
 582
 583                 s_fence = sched_job->s_fence;
 584
 585                 atomic_inc(&sched->hw_rq_count);
 586                 amd_sched_job_begin(sched_job);
 587
 588                 fence = sched->ops->run_job(sched_job);
 589                 amd_sched_fence_scheduled(s_fence);
 590                 if (fence) {
 591                         s_fence->parent = dma_fence_get(fence);
 592                         r = dma_fence_add_callback(fence, &s_fence->cb,
 593                                                    amd_sched_process_job);
 594                         if (r == -ENOENT)
 595                                 amd_sched_process_job(fence, &s_fence->cb);
 596                         else if (r)
 597                                 DRM_ERROR("fence add callback failed (%d)\n",
 598                                           r);
 599                         dma_fence_put(fence);
 600                 } else {
 601                         DRM_ERROR("Failed to run job!\n");
 602                         amd_sched_process_job(NULL, &s_fence->cb);
 603                 }
 604
 605                 count = kfifo_out(&entity->job_queue, &sched_job,
 606                                 sizeof(sched_job));
 607                 WARN_ON(count != sizeof(sched_job));
 608                 wake_up(&sched->job_scheduled);
 609         }
 610         return 0;
 611 }
 612
 613 /**
 614  * Init a gpu scheduler instance
 615  *
 616  * @sched               The pointer to the scheduler
 617  * @ops                 The backend operations for this scheduler.
 618  * @hw_submissions      Number of hw submissions to do.
 619  * @name                Name used for debugging
 620  *
 621  * Return 0 on success, otherwise error code.
 622 */
 623 int amd_sched_init(struct amd_gpu_scheduler *sched,
 624                    const struct amd_sched_backend_ops *ops,
 625                    unsigned hw_submission, long timeout, const char *name)
 626 {
 627         int i;
 628         sched->ops = ops;
 629         sched->hw_submission_limit = hw_submission;
 630         sched->name = name;
 631         sched->timeout = timeout;
 632         for (i = AMD_SCHED_PRIORITY_MIN; i < AMD_SCHED_PRIORITY_MAX; i++)
 633                 amd_sched_rq_init(&sched->sched_rq[i]);
 634
 635         init_waitqueue_head(&sched->wake_up_worker);
 636         init_waitqueue_head(&sched->job_scheduled);
 637         INIT_LIST_HEAD(&sched->ring_mirror_list);
 638         spin_lock_init(&sched->job_list_lock);
 639         atomic_set(&sched->hw_rq_count, 0);
 640         atomic64_set(&sched->job_id_count, 0);
 641
 642         /* Each scheduler will run on a seperate kernel thread */
 643         sched->thread = kthread_run(amd_sched_main, sched, sched->name);
 644         if (IS_ERR(sched->thread)) {
 645                 DRM_ERROR("Failed to create scheduler for %s.\n", name);
 646                 return PTR_ERR(sched->thread);
 647         }
 648
 649         return 0;
 650 }
 651
 652 /**
 653  * Destroy a gpu scheduler
 654  *
 655  * @sched       The pointer to the scheduler
 656  */
 657 void amd_sched_fini(struct amd_gpu_scheduler *sched)
 658 {
 659         if (sched->thread)
 660                 kthread_stop(sched->thread);
 661 }