1 /*- 2 * Copyright (c) 2001 Jake Burkholder <jake@FreeBSD.org> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 /*** 28 Here is the logic.. 29 30 If there are N processors, then there are at most N KSEs (kernel 31 schedulable entities) working to process threads that belong to a 32 KSEGROUP (kg). If there are X of these KSEs actually running at the 33 moment in question, then there are at most M (N-X) of these KSEs on 34 the run queue, as running KSEs are not on the queue. 35 36 Runnable threads are queued off the KSEGROUP in priority order. 37 If there are M or more threads runnable, the top M threads 38 (by priority) are 'preassigned' to the M KSEs not running. The KSEs take 39 their priority from those threads and are put on the run queue. 40 41 The last thread that had a priority high enough to have a KSE associated 42 with it, AND IS ON THE RUN QUEUE is pointed to by 43 kg->kg_last_assigned. If no threads queued off the KSEGROUP have KSEs 44 assigned as all the available KSEs are activly running, or because there 45 are no threads queued, that pointer is NULL. 46 47 When a KSE is removed from the run queue to become runnable, we know 48 it was associated with the highest priority thread in the queue (at the head 49 of the queue). If it is also the last assigned we know M was 1 and must 50 now be 0. Since the thread is no longer queued that pointer must be 51 removed from it. Since we know there were no more KSEs available, 52 (M was 1 and is now 0) and since we are not FREEING our KSE 53 but using it, we know there are STILL no more KSEs available, we can prove 54 that the next thread in the ksegrp list will not have a KSE to assign to 55 it, so we can show that the pointer must be made 'invalid' (NULL). 56 57 The pointer exists so that when a new thread is made runnable, it can 58 have its priority compared with the last assigned thread to see if 59 it should 'steal' its KSE or not.. i.e. is it 'earlier' 60 on the list than that thread or later.. If it's earlier, then the KSE is 61 removed from the last assigned (which is now not assigned a KSE) 62 and reassigned to the new thread, which is placed earlier in the list. 63 The pointer is then backed up to the previous thread (which may or may not 64 be the new thread). 65 66 When a thread sleeps or is removed, the KSE becomes available and if there 67 are queued threads that are not assigned KSEs, the highest priority one of 68 them is assigned the KSE, which is then placed back on the run queue at 69 the approipriate place, and the kg->kg_last_assigned pointer is adjusted down 70 to point to it. 71 72 The following diagram shows 2 KSEs and 3 threads from a single process. 73 74 RUNQ: --->KSE---KSE--... (KSEs queued at priorities from threads) 75 \ \____ 76 \ \ 77 KSEGROUP---thread--thread--thread (queued in priority order) 78 \ / 79 \_______________/ 80 (last_assigned) 81 82 The result of this scheme is that the M available KSEs are always 83 queued at the priorities they have inherrited from the M highest priority 84 threads for that KSEGROUP. If this situation changes, the KSEs are 85 reassigned to keep this true. 86 ***/ 87 88 #include <sys/cdefs.h> 89 __FBSDID("$FreeBSD$"); 90 91 #include "opt_sched.h" 92 93 #ifndef KERN_SWITCH_INCLUDE 94 #include <sys/param.h> 95 #include <sys/systm.h> 96 #include <sys/kdb.h> 97 #include <sys/kernel.h> 98 #include <sys/ktr.h> 99 #include <sys/lock.h> 100 #include <sys/mutex.h> 101 #include <sys/proc.h> 102 #include <sys/queue.h> 103 #include <sys/sched.h> 104 #else /* KERN_SWITCH_INCLUDE */ 105 #if defined(SMP) && (defined(__i386__) || defined(__amd64__)) 106 #include <sys/smp.h> 107 #endif 108 #if defined(SMP) && defined(SCHED_4BSD) 109 #include <sys/sysctl.h> 110 #endif 111 112 #ifdef FULL_PREEMPTION 113 #ifndef PREEMPTION 114 #error "The FULL_PREEMPTION option requires the PREEMPTION option" 115 #endif 116 #endif 117 118 CTASSERT((RQB_BPW * RQB_LEN) == RQ_NQS); 119 120 #define td_kse td_sched 121 122 /* 123 * kern.sched.preemption allows user space to determine if preemption support 124 * is compiled in or not. It is not currently a boot or runtime flag that 125 * can be changed. 126 */ 127 #ifdef PREEMPTION 128 static int kern_sched_preemption = 1; 129 #else 130 static int kern_sched_preemption = 0; 131 #endif 132 SYSCTL_INT(_kern_sched, OID_AUTO, preemption, CTLFLAG_RD, 133 &kern_sched_preemption, 0, "Kernel preemption enabled"); 134 135 /************************************************************************ 136 * Functions that manipulate runnability from a thread perspective. * 137 ************************************************************************/ 138 /* 139 * Select the KSE that will be run next. From that find the thread, and 140 * remove it from the KSEGRP's run queue. If there is thread clustering, 141 * this will be what does it. 142 */ 143 struct thread * 144 choosethread(void) 145 { 146 struct kse *ke; 147 struct thread *td; 148 struct ksegrp *kg; 149 150 #if defined(SMP) && (defined(__i386__) || defined(__amd64__)) 151 if (smp_active == 0 && PCPU_GET(cpuid) != 0) { 152 /* Shutting down, run idlethread on AP's */ 153 td = PCPU_GET(idlethread); 154 ke = td->td_kse; 155 CTR1(KTR_RUNQ, "choosethread: td=%p (idle)", td); 156 ke->ke_flags |= KEF_DIDRUN; 157 TD_SET_RUNNING(td); 158 return (td); 159 } 160 #endif 161 162 retry: 163 ke = sched_choose(); 164 if (ke) { 165 td = ke->ke_thread; 166 KASSERT((td->td_kse == ke), ("kse/thread mismatch")); 167 kg = ke->ke_ksegrp; 168 if (td->td_proc->p_flag & P_HADTHREADS) { 169 if (kg->kg_last_assigned == td) { 170 kg->kg_last_assigned = TAILQ_PREV(td, 171 threadqueue, td_runq); 172 } 173 TAILQ_REMOVE(&kg->kg_runq, td, td_runq); 174 } 175 CTR2(KTR_RUNQ, "choosethread: td=%p pri=%d", 176 td, td->td_priority); 177 } else { 178 /* Simulate runq_choose() having returned the idle thread */ 179 td = PCPU_GET(idlethread); 180 ke = td->td_kse; 181 CTR1(KTR_RUNQ, "choosethread: td=%p (idle)", td); 182 } 183 ke->ke_flags |= KEF_DIDRUN; 184 185 /* 186 * If we are in panic, only allow system threads, 187 * plus the one we are running in, to be run. 188 */ 189 if (panicstr && ((td->td_proc->p_flag & P_SYSTEM) == 0 && 190 (td->td_flags & TDF_INPANIC) == 0)) { 191 /* note that it is no longer on the run queue */ 192 TD_SET_CAN_RUN(td); 193 goto retry; 194 } 195 196 TD_SET_RUNNING(td); 197 return (td); 198 } 199 200 /* 201 * Given a surplus system slot, try assign a new runnable thread to it. 202 * Called from: 203 * sched_thread_exit() (local) 204 * sched_switch() (local) 205 * sched_thread_exit() (local) 206 * remrunqueue() (local) (not at the moment) 207 */ 208 static void 209 slot_fill(struct ksegrp *kg) 210 { 211 struct thread *td; 212 213 mtx_assert(&sched_lock, MA_OWNED); 214 while (kg->kg_avail_opennings > 0) { 215 /* 216 * Find the first unassigned thread 217 */ 218 if ((td = kg->kg_last_assigned) != NULL) 219 td = TAILQ_NEXT(td, td_runq); 220 else 221 td = TAILQ_FIRST(&kg->kg_runq); 222 223 /* 224 * If we found one, send it to the system scheduler. 225 */ 226 if (td) { 227 kg->kg_last_assigned = td; 228 sched_add(td, SRQ_YIELDING); 229 CTR2(KTR_RUNQ, "slot_fill: td%p -> kg%p", td, kg); 230 } else { 231 /* no threads to use up the slots. quit now */ 232 break; 233 } 234 } 235 } 236 237 #ifdef SCHED_4BSD 238 /* 239 * Remove a thread from its KSEGRP's run queue. 240 * This in turn may remove it from a KSE if it was already assigned 241 * to one, possibly causing a new thread to be assigned to the KSE 242 * and the KSE getting a new priority. 243 */ 244 static void 245 remrunqueue(struct thread *td) 246 { 247 struct thread *td2, *td3; 248 struct ksegrp *kg; 249 struct kse *ke; 250 251 mtx_assert(&sched_lock, MA_OWNED); 252 KASSERT((TD_ON_RUNQ(td)), ("remrunqueue: Bad state on run queue")); 253 kg = td->td_ksegrp; 254 ke = td->td_kse; 255 CTR1(KTR_RUNQ, "remrunqueue: td%p", td); 256 TD_SET_CAN_RUN(td); 257 /* 258 * If it is not a threaded process, take the shortcut. 259 */ 260 if ((td->td_proc->p_flag & P_HADTHREADS) == 0) { 261 /* remve from sys run queue and free up a slot */ 262 sched_rem(td); 263 ke->ke_state = KES_THREAD; 264 return; 265 } 266 td3 = TAILQ_PREV(td, threadqueue, td_runq); 267 TAILQ_REMOVE(&kg->kg_runq, td, td_runq); 268 if (ke->ke_state == KES_ONRUNQ) { 269 /* 270 * This thread has been assigned to the system run queue. 271 * We need to dissociate it and try assign the 272 * KSE to the next available thread. Then, we should 273 * see if we need to move the KSE in the run queues. 274 */ 275 sched_rem(td); 276 ke->ke_state = KES_THREAD; 277 td2 = kg->kg_last_assigned; 278 KASSERT((td2 != NULL), ("last assigned has wrong value")); 279 if (td2 == td) 280 kg->kg_last_assigned = td3; 281 /* slot_fill(kg); */ /* will replace it with another */ 282 } 283 } 284 #endif 285 286 /* 287 * Change the priority of a thread that is on the run queue. 288 */ 289 void 290 adjustrunqueue( struct thread *td, int newpri) 291 { 292 struct ksegrp *kg; 293 struct kse *ke; 294 295 mtx_assert(&sched_lock, MA_OWNED); 296 KASSERT((TD_ON_RUNQ(td)), ("adjustrunqueue: Bad state on run queue")); 297 298 ke = td->td_kse; 299 CTR1(KTR_RUNQ, "adjustrunqueue: td%p", td); 300 /* 301 * If it is not a threaded process, take the shortcut. 302 */ 303 if ((td->td_proc->p_flag & P_HADTHREADS) == 0) { 304 /* We only care about the kse in the run queue. */ 305 td->td_priority = newpri; 306 if (ke->ke_rqindex != (newpri / RQ_PPQ)) { 307 sched_rem(td); 308 sched_add(td, SRQ_BORING); 309 } 310 return; 311 } 312 313 /* It is a threaded process */ 314 kg = td->td_ksegrp; 315 if (ke->ke_state == KES_ONRUNQ) { 316 if (kg->kg_last_assigned == td) { 317 kg->kg_last_assigned = 318 TAILQ_PREV(td, threadqueue, td_runq); 319 } 320 sched_rem(td); 321 } 322 TAILQ_REMOVE(&kg->kg_runq, td, td_runq); 323 TD_SET_CAN_RUN(td); 324 td->td_priority = newpri; 325 setrunqueue(td, SRQ_BORING); 326 } 327 328 /* 329 * This function is called when a thread is about to be put on a 330 * ksegrp run queue because it has been made runnable or its 331 * priority has been adjusted and the ksegrp does not have a 332 * free kse slot. It determines if a thread from the same ksegrp 333 * should be preempted. If so, it tries to switch threads 334 * if the thread is on the same cpu or notifies another cpu that 335 * it should switch threads. 336 */ 337 338 static void 339 maybe_preempt_in_ksegrp(struct thread *td) 340 #if !defined(SMP) 341 { 342 struct thread *running_thread; 343 344 #ifndef FULL_PREEMPTION 345 int pri; 346 pri = td->td_priority; 347 if (!(pri >= PRI_MIN_ITHD && pri <= PRI_MAX_ITHD)) 348 return; 349 #endif 350 mtx_assert(&sched_lock, MA_OWNED); 351 running_thread = curthread; 352 353 if (running_thread->td_ksegrp != td->td_ksegrp) 354 return; 355 356 if (td->td_priority > running_thread->td_priority) 357 return; 358 #ifdef PREEMPTION 359 if (running_thread->td_critnest > 1) 360 running_thread->td_pflags |= TDP_OWEPREEMPT; 361 else 362 mi_switch(SW_INVOL, NULL); 363 364 #else 365 running_thread->td_flags |= TDF_NEEDRESCHED; 366 #endif 367 return; 368 } 369 370 #else /* SMP */ 371 { 372 struct thread *running_thread; 373 int worst_pri; 374 struct ksegrp *kg; 375 cpumask_t cpumask,dontuse; 376 struct pcpu *pc; 377 struct pcpu *best_pcpu; 378 struct thread *cputhread; 379 380 #ifndef FULL_PREEMPTION 381 int pri; 382 pri = td->td_priority; 383 if (!(pri >= PRI_MIN_ITHD && pri <= PRI_MAX_ITHD)) 384 return; 385 #endif 386 387 mtx_assert(&sched_lock, MA_OWNED); 388 389 running_thread = curthread; 390 391 #if !defined(KSEG_PEEMPT_BEST_CPU) 392 if (running_thread->td_ksegrp != td->td_ksegrp) { 393 #endif 394 kg = td->td_ksegrp; 395 396 /* if someone is ahead of this thread, wait our turn */ 397 if (td != TAILQ_FIRST(&kg->kg_runq)) 398 return; 399 400 worst_pri = td->td_priority; 401 best_pcpu = NULL; 402 dontuse = stopped_cpus | idle_cpus_mask; 403 404 /* 405 * Find a cpu with the worst priority that runs at thread from 406 * the same ksegrp - if multiple exist give first the last run 407 * cpu and then the current cpu priority 408 */ 409 410 SLIST_FOREACH(pc, &cpuhead, pc_allcpu) { 411 cpumask = pc->pc_cpumask; 412 cputhread = pc->pc_curthread; 413 414 if ((cpumask & dontuse) || 415 cputhread->td_ksegrp != kg) 416 continue; 417 418 if (cputhread->td_priority > worst_pri) { 419 worst_pri = cputhread->td_priority; 420 best_pcpu = pc; 421 continue; 422 } 423 424 if (cputhread->td_priority == worst_pri && 425 best_pcpu != NULL && 426 (td->td_lastcpu == pc->pc_cpuid || 427 (PCPU_GET(cpumask) == cpumask && 428 td->td_lastcpu != best_pcpu->pc_cpuid))) 429 best_pcpu = pc; 430 } 431 432 /* Check if we need to preempt someone */ 433 if (best_pcpu == NULL) 434 return; 435 436 if (PCPU_GET(cpuid) != best_pcpu->pc_cpuid) { 437 best_pcpu->pc_curthread->td_flags |= TDF_NEEDRESCHED; 438 ipi_selected(best_pcpu->pc_cpumask, IPI_AST); 439 return; 440 } 441 #if !defined(KSEG_PEEMPT_BEST_CPU) 442 } 443 #endif 444 445 if (td->td_priority > running_thread->td_priority) 446 return; 447 #ifdef PREEMPTION 448 if (running_thread->td_critnest > 1) 449 running_thread->td_pflags |= TDP_OWEPREEMPT; 450 else 451 mi_switch(SW_INVOL, NULL); 452 453 #else 454 running_thread->td_flags |= TDF_NEEDRESCHED; 455 #endif 456 return; 457 } 458 #endif /* !SMP */ 459 460 461 int limitcount; 462 void 463 setrunqueue(struct thread *td, int flags) 464 { 465 struct ksegrp *kg; 466 struct thread *td2; 467 struct thread *tda; 468 469 CTR3(KTR_RUNQ, "setrunqueue: td:%p kg:%p pid:%d", 470 td, td->td_ksegrp, td->td_proc->p_pid); 471 CTR5(KTR_SCHED, "setrunqueue: %p(%s) prio %d by %p(%s)", 472 td, td->td_proc->p_comm, td->td_priority, curthread, 473 curthread->td_proc->p_comm); 474 mtx_assert(&sched_lock, MA_OWNED); 475 KASSERT((td->td_inhibitors == 0), 476 ("setrunqueue: trying to run inhibitted thread")); 477 KASSERT((TD_CAN_RUN(td) || TD_IS_RUNNING(td)), 478 ("setrunqueue: bad thread state")); 479 TD_SET_RUNQ(td); 480 kg = td->td_ksegrp; 481 if ((td->td_proc->p_flag & P_HADTHREADS) == 0) { 482 /* 483 * Common path optimisation: Only one of everything 484 * and the KSE is always already attached. 485 * Totally ignore the ksegrp run queue. 486 */ 487 if (kg->kg_avail_opennings != 1) { 488 if (limitcount < 1) { 489 limitcount++; 490 printf("pid %d: corrected slot count (%d->1)\n", 491 td->td_proc->p_pid, kg->kg_avail_opennings); 492 493 } 494 kg->kg_avail_opennings = 1; 495 } 496 sched_add(td, flags); 497 return; 498 } 499 500 /* 501 * If the concurrency has reduced, and we would go in the 502 * assigned section, then keep removing entries from the 503 * system run queue, until we are not in that section 504 * or there is room for us to be put in that section. 505 * What we MUST avoid is the case where there are threads of less 506 * priority than the new one scheduled, but it can not 507 * be scheduled itself. That would lead to a non contiguous set 508 * of scheduled threads, and everything would break. 509 */ 510 tda = kg->kg_last_assigned; 511 while ((kg->kg_avail_opennings <= 0) && 512 (tda && (tda->td_priority > td->td_priority))) { 513 /* 514 * None free, but there is one we can commandeer. 515 */ 516 CTR2(KTR_RUNQ, 517 "setrunqueue: kg:%p: take slot from td: %p", kg, tda); 518 sched_rem(tda); 519 tda = kg->kg_last_assigned = 520 TAILQ_PREV(tda, threadqueue, td_runq); 521 } 522 523 /* 524 * Add the thread to the ksegrp's run queue at 525 * the appropriate place. 526 */ 527 TAILQ_FOREACH(td2, &kg->kg_runq, td_runq) { 528 if (td2->td_priority > td->td_priority) { 529 TAILQ_INSERT_BEFORE(td2, td, td_runq); 530 break; 531 } 532 } 533 if (td2 == NULL) { 534 /* We ran off the end of the TAILQ or it was empty. */ 535 TAILQ_INSERT_TAIL(&kg->kg_runq, td, td_runq); 536 } 537 538 /* 539 * If we have a slot to use, then put the thread on the system 540 * run queue and if needed, readjust the last_assigned pointer. 541 * it may be that we need to schedule something anyhow 542 * even if the availabel slots are -ve so that 543 * all the items < last_assigned are scheduled. 544 */ 545 if (kg->kg_avail_opennings > 0) { 546 if (tda == NULL) { 547 /* 548 * No pre-existing last assigned so whoever is first 549 * gets the slot.. (maybe us) 550 */ 551 td2 = TAILQ_FIRST(&kg->kg_runq); 552 kg->kg_last_assigned = td2; 553 } else if (tda->td_priority > td->td_priority) { 554 td2 = td; 555 } else { 556 /* 557 * We are past last_assigned, so 558 * give the next slot to whatever is next, 559 * which may or may not be us. 560 */ 561 td2 = TAILQ_NEXT(tda, td_runq); 562 kg->kg_last_assigned = td2; 563 } 564 sched_add(td2, flags); 565 } else { 566 CTR3(KTR_RUNQ, "setrunqueue: held: td%p kg%p pid%d", 567 td, td->td_ksegrp, td->td_proc->p_pid); 568 if ((flags & SRQ_YIELDING) == 0) 569 maybe_preempt_in_ksegrp(td); 570 } 571 } 572 573 /* 574 * Kernel thread preemption implementation. Critical sections mark 575 * regions of code in which preemptions are not allowed. 576 */ 577 void 578 critical_enter(void) 579 { 580 struct thread *td; 581 582 td = curthread; 583 td->td_critnest++; 584 CTR4(KTR_CRITICAL, "critical_enter by thread %p (%ld, %s) to %d", td, 585 (long)td->td_proc->p_pid, td->td_proc->p_comm, td->td_critnest); 586 } 587 588 void 589 critical_exit(void) 590 { 591 struct thread *td; 592 593 td = curthread; 594 KASSERT(td->td_critnest != 0, 595 ("critical_exit: td_critnest == 0")); 596 if (td->td_critnest == 1) { 597 if (td->td_pflags & TDP_WAKEPROC0) { 598 td->td_pflags &= ~TDP_WAKEPROC0; 599 wakeup(&proc0); 600 } 601 #ifdef PREEMPTION 602 mtx_assert(&sched_lock, MA_NOTOWNED); 603 if (td->td_pflags & TDP_OWEPREEMPT) { 604 mtx_lock_spin(&sched_lock); 605 mi_switch(SW_INVOL, NULL); 606 mtx_unlock_spin(&sched_lock); 607 } 608 #endif 609 td->td_critnest = 0; 610 } else { 611 td->td_critnest--; 612 } 613 CTR4(KTR_CRITICAL, "critical_exit by thread %p (%ld, %s) to %d", td, 614 (long)td->td_proc->p_pid, td->td_proc->p_comm, td->td_critnest); 615 } 616 617 /* 618 * This function is called when a thread is about to be put on run queue 619 * because it has been made runnable or its priority has been adjusted. It 620 * determines if the new thread should be immediately preempted to. If so, 621 * it switches to it and eventually returns true. If not, it returns false 622 * so that the caller may place the thread on an appropriate run queue. 623 */ 624 int 625 maybe_preempt(struct thread *td) 626 { 627 #ifdef PREEMPTION 628 struct thread *ctd; 629 int cpri, pri; 630 #endif 631 632 mtx_assert(&sched_lock, MA_OWNED); 633 #ifdef PREEMPTION 634 /* 635 * The new thread should not preempt the current thread if any of the 636 * following conditions are true: 637 * 638 * - The kernel is in the throes of crashing (panicstr). 639 * - The current thread has a higher (numerically lower) or 640 * equivalent priority. Note that this prevents curthread from 641 * trying to preempt to itself. 642 * - It is too early in the boot for context switches (cold is set). 643 * - The current thread has an inhibitor set or is in the process of 644 * exiting. In this case, the current thread is about to switch 645 * out anyways, so there's no point in preempting. If we did, 646 * the current thread would not be properly resumed as well, so 647 * just avoid that whole landmine. 648 * - If the new thread's priority is not a realtime priority and 649 * the current thread's priority is not an idle priority and 650 * FULL_PREEMPTION is disabled. 651 * 652 * If all of these conditions are false, but the current thread is in 653 * a nested critical section, then we have to defer the preemption 654 * until we exit the critical section. Otherwise, switch immediately 655 * to the new thread. 656 */ 657 ctd = curthread; 658 KASSERT ((ctd->td_kse != NULL && ctd->td_kse->ke_thread == ctd), 659 ("thread has no (or wrong) sched-private part.")); 660 KASSERT((td->td_inhibitors == 0), 661 ("maybe_preempt: trying to run inhibitted thread")); 662 pri = td->td_priority; 663 cpri = ctd->td_priority; 664 if (panicstr != NULL || pri >= cpri || cold /* || dumping */ || 665 TD_IS_INHIBITED(ctd) || td->td_kse->ke_state != KES_THREAD) 666 return (0); 667 #ifndef FULL_PREEMPTION 668 if (!(pri >= PRI_MIN_ITHD && pri <= PRI_MAX_ITHD) && 669 !(cpri >= PRI_MIN_IDLE)) 670 return (0); 671 #endif 672 if (ctd->td_critnest > 1) { 673 CTR1(KTR_PROC, "maybe_preempt: in critical section %d", 674 ctd->td_critnest); 675 ctd->td_pflags |= TDP_OWEPREEMPT; 676 return (0); 677 } 678 679 /* 680 * Thread is runnable but not yet put on system run queue. 681 */ 682 MPASS(TD_ON_RUNQ(td)); 683 MPASS(td->td_sched->ke_state != KES_ONRUNQ); 684 if (td->td_proc->p_flag & P_HADTHREADS) { 685 /* 686 * If this is a threaded process we actually ARE on the 687 * ksegrp run queue so take it off that first. 688 * Also undo any damage done to the last_assigned pointer. 689 * XXX Fix setrunqueue so this isn't needed 690 */ 691 struct ksegrp *kg; 692 693 kg = td->td_ksegrp; 694 if (kg->kg_last_assigned == td) 695 kg->kg_last_assigned = 696 TAILQ_PREV(td, threadqueue, td_runq); 697 TAILQ_REMOVE(&kg->kg_runq, td, td_runq); 698 } 699 700 TD_SET_RUNNING(td); 701 CTR3(KTR_PROC, "preempting to thread %p (pid %d, %s)\n", td, 702 td->td_proc->p_pid, td->td_proc->p_comm); 703 mi_switch(SW_INVOL|SW_PREEMPT, td); 704 return (1); 705 #else 706 return (0); 707 #endif 708 } 709 710 #if 0 711 #ifndef PREEMPTION 712 /* XXX: There should be a non-static version of this. */ 713 static void 714 printf_caddr_t(void *data) 715 { 716 printf("%s", (char *)data); 717 } 718 static char preempt_warning[] = 719 "WARNING: Kernel preemption is disabled, expect reduced performance.\n"; 720 SYSINIT(preempt_warning, SI_SUB_COPYRIGHT, SI_ORDER_ANY, printf_caddr_t, 721 preempt_warning) 722 #endif 723 #endif 724 725 /************************************************************************ 726 * SYSTEM RUN QUEUE manipulations and tests * 727 ************************************************************************/ 728 /* 729 * Initialize a run structure. 730 */ 731 void 732 runq_init(struct runq *rq) 733 { 734 int i; 735 736 bzero(rq, sizeof *rq); 737 for (i = 0; i < RQ_NQS; i++) 738 TAILQ_INIT(&rq->rq_queues[i]); 739 } 740 741 /* 742 * Clear the status bit of the queue corresponding to priority level pri, 743 * indicating that it is empty. 744 */ 745 static __inline void 746 runq_clrbit(struct runq *rq, int pri) 747 { 748 struct rqbits *rqb; 749 750 rqb = &rq->rq_status; 751 CTR4(KTR_RUNQ, "runq_clrbit: bits=%#x %#x bit=%#x word=%d", 752 rqb->rqb_bits[RQB_WORD(pri)], 753 rqb->rqb_bits[RQB_WORD(pri)] & ~RQB_BIT(pri), 754 RQB_BIT(pri), RQB_WORD(pri)); 755 rqb->rqb_bits[RQB_WORD(pri)] &= ~RQB_BIT(pri); 756 } 757 758 /* 759 * Find the index of the first non-empty run queue. This is done by 760 * scanning the status bits, a set bit indicates a non-empty queue. 761 */ 762 static __inline int 763 runq_findbit(struct runq *rq) 764 { 765 struct rqbits *rqb; 766 int pri; 767 int i; 768 769 rqb = &rq->rq_status; 770 for (i = 0; i < RQB_LEN; i++) 771 if (rqb->rqb_bits[i]) { 772 pri = RQB_FFS(rqb->rqb_bits[i]) + (i << RQB_L2BPW); 773 CTR3(KTR_RUNQ, "runq_findbit: bits=%#x i=%d pri=%d", 774 rqb->rqb_bits[i], i, pri); 775 return (pri); 776 } 777 778 return (-1); 779 } 780 781 /* 782 * Set the status bit of the queue corresponding to priority level pri, 783 * indicating that it is non-empty. 784 */ 785 static __inline void 786 runq_setbit(struct runq *rq, int pri) 787 { 788 struct rqbits *rqb; 789 790 rqb = &rq->rq_status; 791 CTR4(KTR_RUNQ, "runq_setbit: bits=%#x %#x bit=%#x word=%d", 792 rqb->rqb_bits[RQB_WORD(pri)], 793 rqb->rqb_bits[RQB_WORD(pri)] | RQB_BIT(pri), 794 RQB_BIT(pri), RQB_WORD(pri)); 795 rqb->rqb_bits[RQB_WORD(pri)] |= RQB_BIT(pri); 796 } 797 798 /* 799 * Add the KSE to the queue specified by its priority, and set the 800 * corresponding status bit. 801 */ 802 void 803 runq_add(struct runq *rq, struct kse *ke, int flags) 804 { 805 struct rqhead *rqh; 806 int pri; 807 808 pri = ke->ke_thread->td_priority / RQ_PPQ; 809 ke->ke_rqindex = pri; 810 runq_setbit(rq, pri); 811 rqh = &rq->rq_queues[pri]; 812 CTR5(KTR_RUNQ, "runq_add: td=%p ke=%p pri=%d %d rqh=%p", 813 ke->ke_thread, ke, ke->ke_thread->td_priority, pri, rqh); 814 if (flags & SRQ_PREEMPTED) { 815 TAILQ_INSERT_HEAD(rqh, ke, ke_procq); 816 } else { 817 TAILQ_INSERT_TAIL(rqh, ke, ke_procq); 818 } 819 } 820 821 /* 822 * Return true if there are runnable processes of any priority on the run 823 * queue, false otherwise. Has no side effects, does not modify the run 824 * queue structure. 825 */ 826 int 827 runq_check(struct runq *rq) 828 { 829 struct rqbits *rqb; 830 int i; 831 832 rqb = &rq->rq_status; 833 for (i = 0; i < RQB_LEN; i++) 834 if (rqb->rqb_bits[i]) { 835 CTR2(KTR_RUNQ, "runq_check: bits=%#x i=%d", 836 rqb->rqb_bits[i], i); 837 return (1); 838 } 839 CTR0(KTR_RUNQ, "runq_check: empty"); 840 841 return (0); 842 } 843 844 #if defined(SMP) && defined(SCHED_4BSD) 845 int runq_fuzz = 1; 846 SYSCTL_INT(_kern_sched, OID_AUTO, runq_fuzz, CTLFLAG_RW, &runq_fuzz, 0, ""); 847 #endif 848 849 /* 850 * Find the highest priority process on the run queue. 851 */ 852 struct kse * 853 runq_choose(struct runq *rq) 854 { 855 struct rqhead *rqh; 856 struct kse *ke; 857 int pri; 858 859 mtx_assert(&sched_lock, MA_OWNED); 860 while ((pri = runq_findbit(rq)) != -1) { 861 rqh = &rq->rq_queues[pri]; 862 #if defined(SMP) && defined(SCHED_4BSD) 863 /* fuzz == 1 is normal.. 0 or less are ignored */ 864 if (runq_fuzz > 1) { 865 /* 866 * In the first couple of entries, check if 867 * there is one for our CPU as a preference. 868 */ 869 int count = runq_fuzz; 870 int cpu = PCPU_GET(cpuid); 871 struct kse *ke2; 872 ke2 = ke = TAILQ_FIRST(rqh); 873 874 while (count-- && ke2) { 875 if (ke->ke_thread->td_lastcpu == cpu) { 876 ke = ke2; 877 break; 878 } 879 ke2 = TAILQ_NEXT(ke2, ke_procq); 880 } 881 } else 882 #endif 883 ke = TAILQ_FIRST(rqh); 884 KASSERT(ke != NULL, ("runq_choose: no proc on busy queue")); 885 CTR3(KTR_RUNQ, 886 "runq_choose: pri=%d kse=%p rqh=%p", pri, ke, rqh); 887 return (ke); 888 } 889 CTR1(KTR_RUNQ, "runq_choose: idleproc pri=%d", pri); 890 891 return (NULL); 892 } 893 894 /* 895 * Remove the KSE from the queue specified by its priority, and clear the 896 * corresponding status bit if the queue becomes empty. 897 * Caller must set ke->ke_state afterwards. 898 */ 899 void 900 runq_remove(struct runq *rq, struct kse *ke) 901 { 902 struct rqhead *rqh; 903 int pri; 904 905 KASSERT(ke->ke_proc->p_sflag & PS_INMEM, 906 ("runq_remove: process swapped out")); 907 pri = ke->ke_rqindex; 908 rqh = &rq->rq_queues[pri]; 909 CTR5(KTR_RUNQ, "runq_remove: td=%p, ke=%p pri=%d %d rqh=%p", 910 ke->ke_thread, ke, ke->ke_thread->td_priority, pri, rqh); 911 KASSERT(ke != NULL, ("runq_remove: no proc on busy queue")); 912 TAILQ_REMOVE(rqh, ke, ke_procq); 913 if (TAILQ_EMPTY(rqh)) { 914 CTR0(KTR_RUNQ, "runq_remove: empty"); 915 runq_clrbit(rq, pri); 916 } 917 } 918 919 /****** functions that are temporarily here ***********/ 920 #include <vm/uma.h> 921 extern struct mtx kse_zombie_lock; 922 923 /* 924 * Allocate scheduler specific per-process resources. 925 * The thread and ksegrp have already been linked in. 926 * In this case just set the default concurrency value. 927 * 928 * Called from: 929 * proc_init() (UMA init method) 930 */ 931 void 932 sched_newproc(struct proc *p, struct ksegrp *kg, struct thread *td) 933 { 934 935 /* This can go in sched_fork */ 936 sched_init_concurrency(kg); 937 } 938 939 /* 940 * thread is being either created or recycled. 941 * Fix up the per-scheduler resources associated with it. 942 * Called from: 943 * sched_fork_thread() 944 * thread_dtor() (*may go away) 945 * thread_init() (*may go away) 946 */ 947 void 948 sched_newthread(struct thread *td) 949 { 950 struct td_sched *ke; 951 952 ke = (struct td_sched *) (td + 1); 953 bzero(ke, sizeof(*ke)); 954 td->td_sched = ke; 955 ke->ke_thread = td; 956 ke->ke_state = KES_THREAD; 957 } 958 959 /* 960 * Set up an initial concurrency of 1 961 * and set the given thread (if given) to be using that 962 * concurrency slot. 963 * May be used "offline"..before the ksegrp is attached to the world 964 * and thus wouldn't need schedlock in that case. 965 * Called from: 966 * thr_create() 967 * proc_init() (UMA) via sched_newproc() 968 */ 969 void 970 sched_init_concurrency(struct ksegrp *kg) 971 { 972 973 CTR1(KTR_RUNQ,"kg %p init slots and concurrency to 1", kg); 974 kg->kg_concurrency = 1; 975 kg->kg_avail_opennings = 1; 976 } 977 978 /* 979 * Change the concurrency of an existing ksegrp to N 980 * Called from: 981 * kse_create() 982 * kse_exit() 983 * thread_exit() 984 * thread_single() 985 */ 986 void 987 sched_set_concurrency(struct ksegrp *kg, int concurrency) 988 { 989 990 CTR4(KTR_RUNQ,"kg %p set concurrency to %d, slots %d -> %d", 991 kg, 992 concurrency, 993 kg->kg_avail_opennings, 994 kg->kg_avail_opennings + (concurrency - kg->kg_concurrency)); 995 kg->kg_avail_opennings += (concurrency - kg->kg_concurrency); 996 kg->kg_concurrency = concurrency; 997 } 998 999 /* 1000 * Called from thread_exit() for all exiting thread 1001 * 1002 * Not to be confused with sched_exit_thread() 1003 * that is only called from thread_exit() for threads exiting 1004 * without the rest of the process exiting because it is also called from 1005 * sched_exit() and we wouldn't want to call it twice. 1006 * XXX This can probably be fixed. 1007 */ 1008 void 1009 sched_thread_exit(struct thread *td) 1010 { 1011 1012 SLOT_RELEASE(td->td_ksegrp); 1013 slot_fill(td->td_ksegrp); 1014 } 1015 1016 #endif /* KERN_SWITCH_INCLUDE */ 1017