Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/kern/kern_switch.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
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: releng/6.0/sys/kern/kern_switch.c 148775 2005-08-06 03:06:25Z davidxu $"); 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 #ifdef SCHED_ULE 317 || ((ke->ke_flags & KEF_ASSIGNED) != 0 && 318 (ke->ke_flags & KEF_REMOVED) == 0) 319 #endif 320 ) { 321 if (kg->kg_last_assigned == td) { 322 kg->kg_last_assigned = 323 TAILQ_PREV(td, threadqueue, td_runq); 324 } 325 sched_rem(td); 326 } 327 TAILQ_REMOVE(&kg->kg_runq, td, td_runq); 328 TD_SET_CAN_RUN(td); 329 td->td_priority = newpri; 330 setrunqueue(td, SRQ_BORING); 331 } 332 333 /* 334 * This function is called when a thread is about to be put on a 335 * ksegrp run queue because it has been made runnable or its 336 * priority has been adjusted and the ksegrp does not have a 337 * free kse slot. It determines if a thread from the same ksegrp 338 * should be preempted. If so, it tries to switch threads 339 * if the thread is on the same cpu or notifies another cpu that 340 * it should switch threads. 341 */ 342 343 static void 344 maybe_preempt_in_ksegrp(struct thread *td) 345 #if !defined(SMP) 346 { 347 struct thread *running_thread; 348 349 mtx_assert(&sched_lock, MA_OWNED); 350 running_thread = curthread; 351 352 if (running_thread->td_ksegrp != td->td_ksegrp) 353 return; 354 355 if (td->td_priority >= running_thread->td_priority) 356 return; 357 #ifdef PREEMPTION 358 #ifndef FULL_PREEMPTION 359 if (td->td_priority > PRI_MAX_ITHD) { 360 running_thread->td_flags |= TDF_NEEDRESCHED; 361 return; 362 } 363 #endif /* FULL_PREEMPTION */ 364 365 if (running_thread->td_critnest > 1) 366 running_thread->td_owepreempt = 1; 367 else 368 mi_switch(SW_INVOL, NULL); 369 370 #else /* PREEMPTION */ 371 running_thread->td_flags |= TDF_NEEDRESCHED; 372 #endif /* PREEMPTION */ 373 return; 374 } 375 376 #else /* SMP */ 377 { 378 struct thread *running_thread; 379 int worst_pri; 380 struct ksegrp *kg; 381 cpumask_t cpumask,dontuse; 382 struct pcpu *pc; 383 struct pcpu *best_pcpu; 384 struct thread *cputhread; 385 386 mtx_assert(&sched_lock, MA_OWNED); 387 388 running_thread = curthread; 389 390 #if !defined(KSEG_PEEMPT_BEST_CPU) 391 if (running_thread->td_ksegrp != td->td_ksegrp) { 392 #endif 393 kg = td->td_ksegrp; 394 395 /* if someone is ahead of this thread, wait our turn */ 396 if (td != TAILQ_FIRST(&kg->kg_runq)) 397 return; 398 399 worst_pri = td->td_priority; 400 best_pcpu = NULL; 401 dontuse = stopped_cpus | idle_cpus_mask; 402 403 /* 404 * Find a cpu with the worst priority that runs at thread from 405 * the same ksegrp - if multiple exist give first the last run 406 * cpu and then the current cpu priority 407 */ 408 409 SLIST_FOREACH(pc, &cpuhead, pc_allcpu) { 410 cpumask = pc->pc_cpumask; 411 cputhread = pc->pc_curthread; 412 413 if ((cpumask & dontuse) || 414 cputhread->td_ksegrp != kg) 415 continue; 416 417 if (cputhread->td_priority > worst_pri) { 418 worst_pri = cputhread->td_priority; 419 best_pcpu = pc; 420 continue; 421 } 422 423 if (cputhread->td_priority == worst_pri && 424 best_pcpu != NULL && 425 (td->td_lastcpu == pc->pc_cpuid || 426 (PCPU_GET(cpumask) == cpumask && 427 td->td_lastcpu != best_pcpu->pc_cpuid))) 428 best_pcpu = pc; 429 } 430 431 /* Check if we need to preempt someone */ 432 if (best_pcpu == NULL) 433 return; 434 435 #if defined(IPI_PREEMPTION) && defined(PREEMPTION) 436 #if !defined(FULL_PREEMPTION) 437 if (td->td_priority <= PRI_MAX_ITHD) 438 #endif /* ! FULL_PREEMPTION */ 439 { 440 ipi_selected(best_pcpu->pc_cpumask, IPI_PREEMPT); 441 return; 442 } 443 #endif /* defined(IPI_PREEMPTION) && defined(PREEMPTION) */ 444 445 if (PCPU_GET(cpuid) != best_pcpu->pc_cpuid) { 446 best_pcpu->pc_curthread->td_flags |= TDF_NEEDRESCHED; 447 ipi_selected(best_pcpu->pc_cpumask, IPI_AST); 448 return; 449 } 450 #if !defined(KSEG_PEEMPT_BEST_CPU) 451 } 452 #endif 453 454 if (td->td_priority >= running_thread->td_priority) 455 return; 456 #ifdef PREEMPTION 457 458 #if !defined(FULL_PREEMPTION) 459 if (td->td_priority > PRI_MAX_ITHD) { 460 running_thread->td_flags |= TDF_NEEDRESCHED; 461 } 462 #endif /* ! FULL_PREEMPTION */ 463 464 if (running_thread->td_critnest > 1) 465 running_thread->td_owepreempt = 1; 466 else 467 mi_switch(SW_INVOL, NULL); 468 469 #else /* PREEMPTION */ 470 running_thread->td_flags |= TDF_NEEDRESCHED; 471 #endif /* PREEMPTION */ 472 return; 473 } 474 #endif /* !SMP */ 475 476 477 int limitcount; 478 void 479 setrunqueue(struct thread *td, int flags) 480 { 481 struct ksegrp *kg; 482 struct thread *td2; 483 struct thread *tda; 484 485 CTR3(KTR_RUNQ, "setrunqueue: td:%p kg:%p pid:%d", 486 td, td->td_ksegrp, td->td_proc->p_pid); 487 CTR5(KTR_SCHED, "setrunqueue: %p(%s) prio %d by %p(%s)", 488 td, td->td_proc->p_comm, td->td_priority, curthread, 489 curthread->td_proc->p_comm); 490 mtx_assert(&sched_lock, MA_OWNED); 491 KASSERT((td->td_inhibitors == 0), 492 ("setrunqueue: trying to run inhibitted thread")); 493 KASSERT((TD_CAN_RUN(td) || TD_IS_RUNNING(td)), 494 ("setrunqueue: bad thread state")); 495 TD_SET_RUNQ(td); 496 kg = td->td_ksegrp; 497 if ((td->td_proc->p_flag & P_HADTHREADS) == 0) { 498 /* 499 * Common path optimisation: Only one of everything 500 * and the KSE is always already attached. 501 * Totally ignore the ksegrp run queue. 502 */ 503 if (kg->kg_avail_opennings != 1) { 504 if (limitcount < 1) { 505 limitcount++; 506 printf("pid %d: corrected slot count (%d->1)\n", 507 td->td_proc->p_pid, kg->kg_avail_opennings); 508 509 } 510 kg->kg_avail_opennings = 1; 511 } 512 sched_add(td, flags); 513 return; 514 } 515 516 /* 517 * If the concurrency has reduced, and we would go in the 518 * assigned section, then keep removing entries from the 519 * system run queue, until we are not in that section 520 * or there is room for us to be put in that section. 521 * What we MUST avoid is the case where there are threads of less 522 * priority than the new one scheduled, but it can not 523 * be scheduled itself. That would lead to a non contiguous set 524 * of scheduled threads, and everything would break. 525 */ 526 tda = kg->kg_last_assigned; 527 while ((kg->kg_avail_opennings <= 0) && 528 (tda && (tda->td_priority > td->td_priority))) { 529 /* 530 * None free, but there is one we can commandeer. 531 */ 532 CTR2(KTR_RUNQ, 533 "setrunqueue: kg:%p: take slot from td: %p", kg, tda); 534 sched_rem(tda); 535 tda = kg->kg_last_assigned = 536 TAILQ_PREV(tda, threadqueue, td_runq); 537 } 538 539 /* 540 * Add the thread to the ksegrp's run queue at 541 * the appropriate place. 542 */ 543 TAILQ_FOREACH(td2, &kg->kg_runq, td_runq) { 544 if (td2->td_priority > td->td_priority) { 545 TAILQ_INSERT_BEFORE(td2, td, td_runq); 546 break; 547 } 548 } 549 if (td2 == NULL) { 550 /* We ran off the end of the TAILQ or it was empty. */ 551 TAILQ_INSERT_TAIL(&kg->kg_runq, td, td_runq); 552 } 553 554 /* 555 * If we have a slot to use, then put the thread on the system 556 * run queue and if needed, readjust the last_assigned pointer. 557 * it may be that we need to schedule something anyhow 558 * even if the availabel slots are -ve so that 559 * all the items < last_assigned are scheduled. 560 */ 561 if (kg->kg_avail_opennings > 0) { 562 if (tda == NULL) { 563 /* 564 * No pre-existing last assigned so whoever is first 565 * gets the slot.. (maybe us) 566 */ 567 td2 = TAILQ_FIRST(&kg->kg_runq); 568 kg->kg_last_assigned = td2; 569 } else if (tda->td_priority > td->td_priority) { 570 td2 = td; 571 } else { 572 /* 573 * We are past last_assigned, so 574 * give the next slot to whatever is next, 575 * which may or may not be us. 576 */ 577 td2 = TAILQ_NEXT(tda, td_runq); 578 kg->kg_last_assigned = td2; 579 } 580 sched_add(td2, flags); 581 } else { 582 CTR3(KTR_RUNQ, "setrunqueue: held: td%p kg%p pid%d", 583 td, td->td_ksegrp, td->td_proc->p_pid); 584 if ((flags & SRQ_YIELDING) == 0) 585 maybe_preempt_in_ksegrp(td); 586 } 587 } 588 589 /* 590 * Kernel thread preemption implementation. Critical sections mark 591 * regions of code in which preemptions are not allowed. 592 */ 593 void 594 critical_enter(void) 595 { 596 struct thread *td; 597 598 td = curthread; 599 td->td_critnest++; 600 CTR4(KTR_CRITICAL, "critical_enter by thread %p (%ld, %s) to %d", td, 601 (long)td->td_proc->p_pid, td->td_proc->p_comm, td->td_critnest); 602 } 603 604 void 605 critical_exit(void) 606 { 607 struct thread *td; 608 609 td = curthread; 610 KASSERT(td->td_critnest != 0, 611 ("critical_exit: td_critnest == 0")); 612 #ifdef PREEMPTION 613 if (td->td_critnest == 1) { 614 td->td_critnest = 0; 615 mtx_assert(&sched_lock, MA_NOTOWNED); 616 if (td->td_owepreempt) { 617 td->td_critnest = 1; 618 mtx_lock_spin(&sched_lock); 619 td->td_critnest--; 620 mi_switch(SW_INVOL, NULL); 621 mtx_unlock_spin(&sched_lock); 622 } 623 } else 624 #endif 625 td->td_critnest--; 626 627 628 CTR4(KTR_CRITICAL, "critical_exit by thread %p (%ld, %s) to %d", td, 629 (long)td->td_proc->p_pid, td->td_proc->p_comm, td->td_critnest); 630 } 631 632 /* 633 * This function is called when a thread is about to be put on run queue 634 * because it has been made runnable or its priority has been adjusted. It 635 * determines if the new thread should be immediately preempted to. If so, 636 * it switches to it and eventually returns true. If not, it returns false 637 * so that the caller may place the thread on an appropriate run queue. 638 */ 639 int 640 maybe_preempt(struct thread *td) 641 { 642 #ifdef PREEMPTION 643 struct thread *ctd; 644 int cpri, pri; 645 #endif 646 647 mtx_assert(&sched_lock, MA_OWNED); 648 #ifdef PREEMPTION 649 /* 650 * The new thread should not preempt the current thread if any of the 651 * following conditions are true: 652 * 653 * - The kernel is in the throes of crashing (panicstr). 654 * - The current thread has a higher (numerically lower) or 655 * equivalent priority. Note that this prevents curthread from 656 * trying to preempt to itself. 657 * - It is too early in the boot for context switches (cold is set). 658 * - The current thread has an inhibitor set or is in the process of 659 * exiting. In this case, the current thread is about to switch 660 * out anyways, so there's no point in preempting. If we did, 661 * the current thread would not be properly resumed as well, so 662 * just avoid that whole landmine. 663 * - If the new thread's priority is not a realtime priority and 664 * the current thread's priority is not an idle priority and 665 * FULL_PREEMPTION is disabled. 666 * 667 * If all of these conditions are false, but the current thread is in 668 * a nested critical section, then we have to defer the preemption 669 * until we exit the critical section. Otherwise, switch immediately 670 * to the new thread. 671 */ 672 ctd = curthread; 673 KASSERT ((ctd->td_kse != NULL && ctd->td_kse->ke_thread == ctd), 674 ("thread has no (or wrong) sched-private part.")); 675 KASSERT((td->td_inhibitors == 0), 676 ("maybe_preempt: trying to run inhibitted thread")); 677 pri = td->td_priority; 678 cpri = ctd->td_priority; 679 if (panicstr != NULL || pri >= cpri || cold /* || dumping */ || 680 TD_IS_INHIBITED(ctd) || td->td_kse->ke_state != KES_THREAD) 681 return (0); 682 #ifndef FULL_PREEMPTION 683 if (pri > PRI_MAX_ITHD && cpri < PRI_MIN_IDLE) 684 return (0); 685 #endif 686 687 if (ctd->td_critnest > 1) { 688 CTR1(KTR_PROC, "maybe_preempt: in critical section %d", 689 ctd->td_critnest); 690 ctd->td_owepreempt = 1; 691 return (0); 692 } 693 694 /* 695 * Thread is runnable but not yet put on system run queue. 696 */ 697 MPASS(TD_ON_RUNQ(td)); 698 MPASS(td->td_sched->ke_state != KES_ONRUNQ); 699 if (td->td_proc->p_flag & P_HADTHREADS) { 700 /* 701 * If this is a threaded process we actually ARE on the 702 * ksegrp run queue so take it off that first. 703 * Also undo any damage done to the last_assigned pointer. 704 * XXX Fix setrunqueue so this isn't needed 705 */ 706 struct ksegrp *kg; 707 708 kg = td->td_ksegrp; 709 if (kg->kg_last_assigned == td) 710 kg->kg_last_assigned = 711 TAILQ_PREV(td, threadqueue, td_runq); 712 TAILQ_REMOVE(&kg->kg_runq, td, td_runq); 713 } 714 715 TD_SET_RUNNING(td); 716 CTR3(KTR_PROC, "preempting to thread %p (pid %d, %s)\n", td, 717 td->td_proc->p_pid, td->td_proc->p_comm); 718 mi_switch(SW_INVOL|SW_PREEMPT, td); 719 return (1); 720 #else 721 return (0); 722 #endif 723 } 724 725 #if 0 726 #ifndef PREEMPTION 727 /* XXX: There should be a non-static version of this. */ 728 static void 729 printf_caddr_t(void *data) 730 { 731 printf("%s", (char *)data); 732 } 733 static char preempt_warning[] = 734 "WARNING: Kernel preemption is disabled, expect reduced performance.\n"; 735 SYSINIT(preempt_warning, SI_SUB_COPYRIGHT, SI_ORDER_ANY, printf_caddr_t, 736 preempt_warning) 737 #endif 738 #endif 739 740 /************************************************************************ 741 * SYSTEM RUN QUEUE manipulations and tests * 742 ************************************************************************/ 743 /* 744 * Initialize a run structure. 745 */ 746 void 747 runq_init(struct runq *rq) 748 { 749 int i; 750 751 bzero(rq, sizeof *rq); 752 for (i = 0; i < RQ_NQS; i++) 753 TAILQ_INIT(&rq->rq_queues[i]); 754 } 755 756 /* 757 * Clear the status bit of the queue corresponding to priority level pri, 758 * indicating that it is empty. 759 */ 760 static __inline void 761 runq_clrbit(struct runq *rq, int pri) 762 { 763 struct rqbits *rqb; 764 765 rqb = &rq->rq_status; 766 CTR4(KTR_RUNQ, "runq_clrbit: bits=%#x %#x bit=%#x word=%d", 767 rqb->rqb_bits[RQB_WORD(pri)], 768 rqb->rqb_bits[RQB_WORD(pri)] & ~RQB_BIT(pri), 769 RQB_BIT(pri), RQB_WORD(pri)); 770 rqb->rqb_bits[RQB_WORD(pri)] &= ~RQB_BIT(pri); 771 } 772 773 /* 774 * Find the index of the first non-empty run queue. This is done by 775 * scanning the status bits, a set bit indicates a non-empty queue. 776 */ 777 static __inline int 778 runq_findbit(struct runq *rq) 779 { 780 struct rqbits *rqb; 781 int pri; 782 int i; 783 784 rqb = &rq->rq_status; 785 for (i = 0; i < RQB_LEN; i++) 786 if (rqb->rqb_bits[i]) { 787 pri = RQB_FFS(rqb->rqb_bits[i]) + (i << RQB_L2BPW); 788 CTR3(KTR_RUNQ, "runq_findbit: bits=%#x i=%d pri=%d", 789 rqb->rqb_bits[i], i, pri); 790 return (pri); 791 } 792 793 return (-1); 794 } 795 796 /* 797 * Set the status bit of the queue corresponding to priority level pri, 798 * indicating that it is non-empty. 799 */ 800 static __inline void 801 runq_setbit(struct runq *rq, int pri) 802 { 803 struct rqbits *rqb; 804 805 rqb = &rq->rq_status; 806 CTR4(KTR_RUNQ, "runq_setbit: bits=%#x %#x bit=%#x word=%d", 807 rqb->rqb_bits[RQB_WORD(pri)], 808 rqb->rqb_bits[RQB_WORD(pri)] | RQB_BIT(pri), 809 RQB_BIT(pri), RQB_WORD(pri)); 810 rqb->rqb_bits[RQB_WORD(pri)] |= RQB_BIT(pri); 811 } 812 813 /* 814 * Add the KSE to the queue specified by its priority, and set the 815 * corresponding status bit. 816 */ 817 void 818 runq_add(struct runq *rq, struct kse *ke, int flags) 819 { 820 struct rqhead *rqh; 821 int pri; 822 823 pri = ke->ke_thread->td_priority / RQ_PPQ; 824 ke->ke_rqindex = pri; 825 runq_setbit(rq, pri); 826 rqh = &rq->rq_queues[pri]; 827 CTR5(KTR_RUNQ, "runq_add: td=%p ke=%p pri=%d %d rqh=%p", 828 ke->ke_thread, ke, ke->ke_thread->td_priority, pri, rqh); 829 if (flags & SRQ_PREEMPTED) { 830 TAILQ_INSERT_HEAD(rqh, ke, ke_procq); 831 } else { 832 TAILQ_INSERT_TAIL(rqh, ke, ke_procq); 833 } 834 } 835 836 /* 837 * Return true if there are runnable processes of any priority on the run 838 * queue, false otherwise. Has no side effects, does not modify the run 839 * queue structure. 840 */ 841 int 842 runq_check(struct runq *rq) 843 { 844 struct rqbits *rqb; 845 int i; 846 847 rqb = &rq->rq_status; 848 for (i = 0; i < RQB_LEN; i++) 849 if (rqb->rqb_bits[i]) { 850 CTR2(KTR_RUNQ, "runq_check: bits=%#x i=%d", 851 rqb->rqb_bits[i], i); 852 return (1); 853 } 854 CTR0(KTR_RUNQ, "runq_check: empty"); 855 856 return (0); 857 } 858 859 #if defined(SMP) && defined(SCHED_4BSD) 860 int runq_fuzz = 1; 861 SYSCTL_INT(_kern_sched, OID_AUTO, runq_fuzz, CTLFLAG_RW, &runq_fuzz, 0, ""); 862 #endif 863 864 /* 865 * Find the highest priority process on the run queue. 866 */ 867 struct kse * 868 runq_choose(struct runq *rq) 869 { 870 struct rqhead *rqh; 871 struct kse *ke; 872 int pri; 873 874 mtx_assert(&sched_lock, MA_OWNED); 875 while ((pri = runq_findbit(rq)) != -1) { 876 rqh = &rq->rq_queues[pri]; 877 #if defined(SMP) && defined(SCHED_4BSD) 878 /* fuzz == 1 is normal.. 0 or less are ignored */ 879 if (runq_fuzz > 1) { 880 /* 881 * In the first couple of entries, check if 882 * there is one for our CPU as a preference. 883 */ 884 int count = runq_fuzz; 885 int cpu = PCPU_GET(cpuid); 886 struct kse *ke2; 887 ke2 = ke = TAILQ_FIRST(rqh); 888 889 while (count-- && ke2) { 890 if (ke->ke_thread->td_lastcpu == cpu) { 891 ke = ke2; 892 break; 893 } 894 ke2 = TAILQ_NEXT(ke2, ke_procq); 895 } 896 } else 897 #endif 898 ke = TAILQ_FIRST(rqh); 899 KASSERT(ke != NULL, ("runq_choose: no proc on busy queue")); 900 CTR3(KTR_RUNQ, 901 "runq_choose: pri=%d kse=%p rqh=%p", pri, ke, rqh); 902 return (ke); 903 } 904 CTR1(KTR_RUNQ, "runq_choose: idleproc pri=%d", pri); 905 906 return (NULL); 907 } 908 909 /* 910 * Remove the KSE from the queue specified by its priority, and clear the 911 * corresponding status bit if the queue becomes empty. 912 * Caller must set ke->ke_state afterwards. 913 */ 914 void 915 runq_remove(struct runq *rq, struct kse *ke) 916 { 917 struct rqhead *rqh; 918 int pri; 919 920 KASSERT(ke->ke_proc->p_sflag & PS_INMEM, 921 ("runq_remove: process swapped out")); 922 pri = ke->ke_rqindex; 923 rqh = &rq->rq_queues[pri]; 924 CTR5(KTR_RUNQ, "runq_remove: td=%p, ke=%p pri=%d %d rqh=%p", 925 ke->ke_thread, ke, ke->ke_thread->td_priority, pri, rqh); 926 KASSERT(ke != NULL, ("runq_remove: no proc on busy queue")); 927 TAILQ_REMOVE(rqh, ke, ke_procq); 928 if (TAILQ_EMPTY(rqh)) { 929 CTR0(KTR_RUNQ, "runq_remove: empty"); 930 runq_clrbit(rq, pri); 931 } 932 } 933 934 /****** functions that are temporarily here ***********/ 935 #include <vm/uma.h> 936 extern struct mtx kse_zombie_lock; 937 938 /* 939 * Allocate scheduler specific per-process resources. 940 * The thread and ksegrp have already been linked in. 941 * In this case just set the default concurrency value. 942 * 943 * Called from: 944 * proc_init() (UMA init method) 945 */ 946 void 947 sched_newproc(struct proc *p, struct ksegrp *kg, struct thread *td) 948 { 949 950 /* This can go in sched_fork */ 951 sched_init_concurrency(kg); 952 } 953 954 /* 955 * thread is being either created or recycled. 956 * Fix up the per-scheduler resources associated with it. 957 * Called from: 958 * sched_fork_thread() 959 * thread_dtor() (*may go away) 960 * thread_init() (*may go away) 961 */ 962 void 963 sched_newthread(struct thread *td) 964 { 965 struct td_sched *ke; 966 967 ke = (struct td_sched *) (td + 1); 968 bzero(ke, sizeof(*ke)); 969 td->td_sched = ke; 970 ke->ke_thread = td; 971 ke->ke_state = KES_THREAD; 972 } 973 974 /* 975 * Set up an initial concurrency of 1 976 * and set the given thread (if given) to be using that 977 * concurrency slot. 978 * May be used "offline"..before the ksegrp is attached to the world 979 * and thus wouldn't need schedlock in that case. 980 * Called from: 981 * thr_create() 982 * proc_init() (UMA) via sched_newproc() 983 */ 984 void 985 sched_init_concurrency(struct ksegrp *kg) 986 { 987 988 CTR1(KTR_RUNQ,"kg %p init slots and concurrency to 1", kg); 989 kg->kg_concurrency = 1; 990 kg->kg_avail_opennings = 1; 991 } 992 993 /* 994 * Change the concurrency of an existing ksegrp to N 995 * Called from: 996 * kse_create() 997 * kse_exit() 998 * thread_exit() 999 * thread_single() 1000 */ 1001 void 1002 sched_set_concurrency(struct ksegrp *kg, int concurrency) 1003 { 1004 1005 CTR4(KTR_RUNQ,"kg %p set concurrency to %d, slots %d -> %d", 1006 kg, 1007 concurrency, 1008 kg->kg_avail_opennings, 1009 kg->kg_avail_opennings + (concurrency - kg->kg_concurrency)); 1010 kg->kg_avail_opennings += (concurrency - kg->kg_concurrency); 1011 kg->kg_concurrency = concurrency; 1012 } 1013 1014 /* 1015 * Called from thread_exit() for all exiting thread 1016 * 1017 * Not to be confused with sched_exit_thread() 1018 * that is only called from thread_exit() for threads exiting 1019 * without the rest of the process exiting because it is also called from 1020 * sched_exit() and we wouldn't want to call it twice. 1021 * XXX This can probably be fixed. 1022 */ 1023 void 1024 sched_thread_exit(struct thread *td) 1025 { 1026 1027 SLOT_RELEASE(td->td_ksegrp); 1028 slot_fill(td->td_ksegrp); 1029 } 1030 1031 #endif /* KERN_SWITCH_INCLUDE */
Cache object: 061fcd459d72a8993e0b16c60993b5b7
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]