sys/kern/usched_bsd4.c

   1 /*
   2  * Copyright (c) 1999 Peter Wemm <peter@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  * $DragonFly: src/sys/kern/usched_bsd4.c,v 1.26 2008/11/01 23:31:19 dillon Exp $
  27  */
  28
  29 #include <sys/param.h>
  30 #include <sys/systm.h>
  31 #include <sys/kernel.h>
  32 #include <sys/lock.h>
  33 #include <sys/queue.h>
  34 #include <sys/proc.h>
  35 #include <sys/rtprio.h>
  36 #include <sys/uio.h>
  37 #include <sys/sysctl.h>
  38 #include <sys/resourcevar.h>
  39 #include <sys/spinlock.h>
  40 #include <machine/cpu.h>
  41 #include <machine/smp.h>
  42
  43 #include <sys/thread2.h>
  44 #include <sys/spinlock2.h>
  45 #include <sys/mplock2.h>
  46
  47 /*
  48  * Priorities.  Note that with 32 run queues per scheduler each queue
  49  * represents four priority levels.
  50  */
  51
  52 #define MAXPRI                  128
  53 #define PRIMASK                 (MAXPRI - 1)
  54 #define PRIBASE_REALTIME        0
  55 #define PRIBASE_NORMAL          MAXPRI
  56 #define PRIBASE_IDLE            (MAXPRI * 2)
  57 #define PRIBASE_THREAD          (MAXPRI * 3)
  58 #define PRIBASE_NULL            (MAXPRI * 4)
  59
  60 #define NQS     32                      /* 32 run queues. */
  61 #define PPQ     (MAXPRI / NQS)          /* priorities per queue */
  62 #define PPQMASK (PPQ - 1)
  63
  64 /*
  65  * NICEPPQ      - number of nice units per priority queue
  66  * ESTCPURAMP   - number of scheduler ticks for estcpu to switch queues
  67  *
  68  * ESTCPUPPQ    - number of estcpu units per priority queue
  69  * ESTCPUMAX    - number of estcpu units
  70  * ESTCPUINCR   - amount we have to increment p_estcpu per scheduling tick at
  71  *                100% cpu.
  72  */
  73 #define NICEPPQ         2
  74 #define ESTCPURAMP      4
  75 #define ESTCPUPPQ       512
  76 #define ESTCPUMAX       (ESTCPUPPQ * NQS)
  77 #define ESTCPUINCR      (ESTCPUPPQ / ESTCPURAMP)
  78 #define PRIO_RANGE      (PRIO_MAX - PRIO_MIN + 1)
  79
  80 #define ESTCPULIM(v)    min((v), ESTCPUMAX)
  81
  82 TAILQ_HEAD(rq, lwp);
  83
  84 #define lwp_priority    lwp_usdata.bsd4.priority
  85 #define lwp_rqindex     lwp_usdata.bsd4.rqindex
  86 #define lwp_origcpu     lwp_usdata.bsd4.origcpu
  87 #define lwp_estcpu      lwp_usdata.bsd4.estcpu
  88 #define lwp_rqtype      lwp_usdata.bsd4.rqtype
  89
  90 static void bsd4_acquire_curproc(struct lwp *lp);
  91 static void bsd4_release_curproc(struct lwp *lp);
  92 static void bsd4_select_curproc(globaldata_t gd);
  93 static void bsd4_setrunqueue(struct lwp *lp);
  94 static void bsd4_schedulerclock(struct lwp *lp, sysclock_t period,
  95                                 sysclock_t cpstamp);
  96 static void bsd4_recalculate_estcpu(struct lwp *lp);
  97 static void bsd4_resetpriority(struct lwp *lp);
  98 static void bsd4_forking(struct lwp *plp, struct lwp *lp);
  99 static void bsd4_exiting(struct lwp *plp, struct lwp *lp);
 100 static void bsd4_yield(struct lwp *lp);
 101
 102 #ifdef SMP
 103 static void need_user_resched_remote(void *dummy);
 104 #endif
 105 static struct lwp *chooseproc_locked(struct lwp *chklp);
 106 static void bsd4_remrunqueue_locked(struct lwp *lp);
 107 static void bsd4_setrunqueue_locked(struct lwp *lp);
 108
 109 struct usched usched_bsd4 = {
 110         { NULL },
 111         "bsd4", "Original DragonFly Scheduler",
 112         NULL,                   /* default registration */
 113         NULL,                   /* default deregistration */
 114         bsd4_acquire_curproc,
 115         bsd4_release_curproc,
 116         bsd4_setrunqueue,
 117         bsd4_schedulerclock,
 118         bsd4_recalculate_estcpu,
 119         bsd4_resetpriority,
 120         bsd4_forking,
 121         bsd4_exiting,
 122         NULL,                   /* setcpumask not supported */
 123         bsd4_yield
 124 };
 125
 126 struct usched_bsd4_pcpu {
 127         struct thread helper_thread;
 128         short   rrcount;
 129         short   upri;
 130         struct lwp *uschedcp;
 131 };
 132
 133 typedef struct usched_bsd4_pcpu *bsd4_pcpu_t;
 134
 135 /*
 136  * We have NQS (32) run queues per scheduling class.  For the normal
 137  * class, there are 128 priorities scaled onto these 32 queues.  New
 138  * processes are added to the last entry in each queue, and processes
 139  * are selected for running by taking them from the head and maintaining
 140  * a simple FIFO arrangement.  Realtime and Idle priority processes have
 141  * and explicit 0-31 priority which maps directly onto their class queue
 142  * index.  When a queue has something in it, the corresponding bit is
 143  * set in the queuebits variable, allowing a single read to determine
 144  * the state of all 32 queues and then a ffs() to find the first busy
 145  * queue.
 146  */
 147 static struct rq bsd4_queues[NQS];
 148 static struct rq bsd4_rtqueues[NQS];
 149 static struct rq bsd4_idqueues[NQS];
 150 static u_int32_t bsd4_queuebits;
 151 static u_int32_t bsd4_rtqueuebits;
 152 static u_int32_t bsd4_idqueuebits;
 153 static cpumask_t bsd4_curprocmask = -1; /* currently running a user process */
 154 static cpumask_t bsd4_rdyprocmask;      /* ready to accept a user process */
 155 static int       bsd4_runqcount;
 156 #ifdef SMP
 157 static volatile int bsd4_scancpu;
 158 #endif
 159 static struct spinlock bsd4_spin;
 160 static struct usched_bsd4_pcpu bsd4_pcpu[MAXCPU];
 161
 162 SYSCTL_INT(_debug, OID_AUTO, bsd4_runqcount, CTLFLAG_RD, &bsd4_runqcount, 0,
 163     "Number of run queues");
 164 #ifdef INVARIANTS
 165 static int usched_nonoptimal;
 166 SYSCTL_INT(_debug, OID_AUTO, usched_nonoptimal, CTLFLAG_RW,
 167         &usched_nonoptimal, 0, "acquire_curproc() was not optimal");
 168 static int usched_optimal;
 169 SYSCTL_INT(_debug, OID_AUTO, usched_optimal, CTLFLAG_RW,
 170         &usched_optimal, 0, "acquire_curproc() was optimal");
 171 #endif
 172 static int usched_debug = -1;
 173 SYSCTL_INT(_debug, OID_AUTO, scdebug, CTLFLAG_RW, &usched_debug, 0,
 174     "Print debug information for this pid");
 175 #ifdef SMP
 176 static int remote_resched_nonaffinity;
 177 static int remote_resched_affinity;
 178 static int choose_affinity;
 179 SYSCTL_INT(_debug, OID_AUTO, remote_resched_nonaffinity, CTLFLAG_RD,
 180         &remote_resched_nonaffinity, 0, "Number of remote rescheds");
 181 SYSCTL_INT(_debug, OID_AUTO, remote_resched_affinity, CTLFLAG_RD,
 182         &remote_resched_affinity, 0, "Number of remote rescheds");
 183 SYSCTL_INT(_debug, OID_AUTO, choose_affinity, CTLFLAG_RD,
 184         &choose_affinity, 0, "chooseproc() was smart");
 185 #endif
 186
 187 static int usched_bsd4_rrinterval = (ESTCPUFREQ + 9) / 10;
 188 SYSCTL_INT(_kern, OID_AUTO, usched_bsd4_rrinterval, CTLFLAG_RW,
 189         &usched_bsd4_rrinterval, 0, "");
 190 static int usched_bsd4_decay = ESTCPUINCR / 2;
 191 SYSCTL_INT(_kern, OID_AUTO, usched_bsd4_decay, CTLFLAG_RW,
 192         &usched_bsd4_decay, 0, "");
 193
 194 /*
 195  * Initialize the run queues at boot time.
 196  */
 197 static void
 198 rqinit(void *dummy)
 199 {
 200         int i;
 201
 202         spin_init(&bsd4_spin);
 203         for (i = 0; i < NQS; i++) {
 204                 TAILQ_INIT(&bsd4_queues[i]);
 205                 TAILQ_INIT(&bsd4_rtqueues[i]);
 206                 TAILQ_INIT(&bsd4_idqueues[i]);
 207         }
 208         atomic_clear_cpumask(&bsd4_curprocmask, 1);
 209 }
 210 SYSINIT(runqueue, SI_BOOT2_USCHED, SI_ORDER_FIRST, rqinit, NULL)
 211
 212 /*
 213  * BSD4_ACQUIRE_CURPROC
 214  *
 215  * This function is called when the kernel intends to return to userland.
 216  * It is responsible for making the thread the current designated userland
 217  * thread for this cpu, blocking if necessary.
 218  *
 219  * The kernel has already depressed our LWKT priority so we must not switch
 220  * until we have either assigned or disposed of the thread.
 221  *
 222  * WARNING! THIS FUNCTION IS ALLOWED TO CAUSE THE CURRENT THREAD TO MIGRATE
 223  * TO ANOTHER CPU!  Because most of the kernel assumes that no migration will
 224  * occur, this function is called only under very controlled circumstances.
 225  *
 226  * MPSAFE
 227  */
 228 static void
 229 bsd4_acquire_curproc(struct lwp *lp)
 230 {
 231         globaldata_t gd;
 232         bsd4_pcpu_t dd;
 233         struct lwp *olp;
 234
 235         crit_enter();
 236         bsd4_recalculate_estcpu(lp);
 237
 238         /*
 239          * If a reschedule was requested give another thread the
 240          * driver's seat.
 241          */
 242         if (user_resched_wanted()) {
 243                 clear_user_resched();
 244                 bsd4_release_curproc(lp);
 245         }
 246
 247         /*
 248          * Loop until we are the current user thread
 249          */
 250         do {
 251                 /*
 252                  * Reload after a switch or setrunqueue/switch possibly
 253                  * moved us to another cpu.
 254                  */
 255                 /*clear_lwkt_resched();*/
 256                 gd = mycpu;
 257                 dd = &bsd4_pcpu[gd->gd_cpuid];
 258
 259                 /*
 260                  * Become the currently scheduled user thread for this cpu
 261                  * if we can do so trivially.
 262                  *
 263                  * We can steal another thread's current thread designation
 264                  * on this cpu since if we are running that other thread
 265                  * must not be, so we can safely deschedule it.
 266                  */
 267                 if (dd->uschedcp == lp) {
 268                         /*
 269                          * We are already the current lwp (hot path).
 270                          */
 271                         dd->upri = lp->lwp_priority;
 272                 } else if (dd->uschedcp == NULL) {
 273                         /*
 274                          * We can trivially become the current lwp.
 275                          */
 276                         atomic_set_cpumask(&bsd4_curprocmask, gd->gd_cpumask);
 277                         dd->uschedcp = lp;
 278                         dd->upri = lp->lwp_priority;
 279                 } else if (dd->upri > lp->lwp_priority) {
 280                         /*
 281                          * We can steal the current lwp designation from the
 282                          * olp that was previously assigned to this cpu.
 283                          */
 284                         olp = dd->uschedcp;
 285                         dd->uschedcp = lp;
 286                         dd->upri = lp->lwp_priority;
 287                         lwkt_deschedule(olp->lwp_thread);
 288                         bsd4_setrunqueue(olp);
 289                 } else {
 290                         /*
 291                          * We cannot become the current lwp, place the lp
 292                          * on the bsd4 run-queue and deschedule ourselves.
 293                          */
 294                         lwkt_deschedule(lp->lwp_thread);
 295                         bsd4_setrunqueue(lp);
 296                         lwkt_switch();
 297                 }
 298
 299                 /*
 300                  * Other threads at our current user priority have already
 301                  * put in their bids, but we must run any kernel threads
 302                  * at higher priorities, and we could lose our bid to
 303                  * another thread trying to return to user mode in the
 304                  * process.
 305                  *
 306                  * If we lose our bid we will be descheduled and put on
 307                  * the run queue.  When we are reactivated we will have
 308                  * another chance.
 309                  */
 310                 if (lwkt_resched_wanted() ||
 311                     lp->lwp_thread->td_fairq_accum < 0) {
 312                         lwkt_switch();
 313                 }
 314         } while (dd->uschedcp != lp);
 315
 316         crit_exit();
 317         KKASSERT((lp->lwp_flag & LWP_ONRUNQ) == 0);
 318 }
 319
 320 /*
 321  * BSD4_RELEASE_CURPROC
 322  *
 323  * This routine detaches the current thread from the userland scheduler,
 324  * usually because the thread needs to run or block in the kernel (at
 325  * kernel priority) for a while.
 326  *
 327  * This routine is also responsible for selecting a new thread to
 328  * make the current thread.
 329  *
 330  * NOTE: This implementation differs from the dummy example in that
 331  * bsd4_select_curproc() is able to select the current process, whereas
 332  * dummy_select_curproc() is not able to select the current process.
 333  * This means we have to NULL out uschedcp.
 334  *
 335  * Additionally, note that we may already be on a run queue if releasing
 336  * via the lwkt_switch() in bsd4_setrunqueue().
 337  *
 338  * MPSAFE
 339  */
 340 static void
 341 bsd4_release_curproc(struct lwp *lp)
 342 {
 343         globaldata_t gd = mycpu;
 344         bsd4_pcpu_t dd = &bsd4_pcpu[gd->gd_cpuid];
 345
 346         if (dd->uschedcp == lp) {
 347                 crit_enter();
 348                 KKASSERT((lp->lwp_flag & LWP_ONRUNQ) == 0);
 349                 dd->uschedcp = NULL;    /* don't let lp be selected */
 350                 dd->upri = PRIBASE_NULL;
 351                 atomic_clear_cpumask(&bsd4_curprocmask, gd->gd_cpumask);
 352                 bsd4_select_curproc(gd);
 353                 crit_exit();
 354         }
 355 }
 356
 357 /*
 358  * BSD4_SELECT_CURPROC
 359  *
 360  * Select a new current process for this cpu and clear any pending user
 361  * reschedule request.  The cpu currently has no current process.
 362  *
 363  * This routine is also responsible for equal-priority round-robining,
 364  * typically triggered from bsd4_schedulerclock().  In our dummy example
 365  * all the 'user' threads are LWKT scheduled all at once and we just
 366  * call lwkt_switch().
 367  *
 368  * The calling process is not on the queue and cannot be selected.
 369  *
 370  * MPSAFE
 371  */
 372 static
 373 void
 374 bsd4_select_curproc(globaldata_t gd)
 375 {
 376         bsd4_pcpu_t dd = &bsd4_pcpu[gd->gd_cpuid];
 377         struct lwp *nlp;
 378         int cpuid = gd->gd_cpuid;
 379
 380         crit_enter_gd(gd);
 381
 382         spin_lock(&bsd4_spin);
 383         if ((nlp = chooseproc_locked(dd->uschedcp)) != NULL) {
 384                 atomic_set_cpumask(&bsd4_curprocmask, CPUMASK(cpuid));
 385                 dd->upri = nlp->lwp_priority;
 386                 dd->uschedcp = nlp;
 387                 spin_unlock(&bsd4_spin);
 388 #ifdef SMP
 389                 lwkt_acquire(nlp->lwp_thread);
 390 #endif
 391                 lwkt_schedule(nlp->lwp_thread);
 392         } else {
 393                 spin_unlock(&bsd4_spin);
 394         }
 395 #if 0
 396         } else if (bsd4_runqcount && (bsd4_rdyprocmask & CPUMASK(cpuid))) {
 397                 atomic_clear_cpumask(&bsd4_rdyprocmask, CPUMASK(cpuid));
 398                 spin_unlock(&bsd4_spin);
 399                 lwkt_schedule(&dd->helper_thread);
 400         } else {
 401                 spin_unlock(&bsd4_spin);
 402         }
 403 #endif
 404         crit_exit_gd(gd);
 405 }
 406
 407 /*
 408  * BSD4_SETRUNQUEUE
 409  *
 410  * Place the specified lwp on the user scheduler's run queue.  This routine
 411  * must be called with the thread descheduled.  The lwp must be runnable.
 412  *
 413  * The thread may be the current thread as a special case.
 414  *
 415  * MPSAFE
 416  */
 417 static void
 418 bsd4_setrunqueue(struct lwp *lp)
 419 {
 420         globaldata_t gd;
 421         bsd4_pcpu_t dd;
 422 #ifdef SMP
 423         int cpuid;
 424         cpumask_t mask;
 425         cpumask_t tmpmask;
 426 #endif
 427
 428         /*
 429          * First validate the process state relative to the current cpu.
 430          * We don't need the spinlock for this, just a critical section.
 431          * We are in control of the process.
 432          */
 433         crit_enter();
 434         KASSERT(lp->lwp_stat == LSRUN, ("setrunqueue: lwp not LSRUN"));
 435         KASSERT((lp->lwp_flag & LWP_ONRUNQ) == 0,
 436             ("lwp %d/%d already on runq! flag %08x/%08x", lp->lwp_proc->p_pid,
 437              lp->lwp_tid, lp->lwp_proc->p_flag, lp->lwp_flag));
 438         KKASSERT((lp->lwp_thread->td_flags & TDF_RUNQ) == 0);
 439
 440         /*
 441          * Note: gd and dd are relative to the target thread's last cpu,
 442          * NOT our current cpu.
 443          */
 444         gd = lp->lwp_thread->td_gd;
 445         dd = &bsd4_pcpu[gd->gd_cpuid];
 446
 447         /*
 448          * This process is not supposed to be scheduled anywhere or assigned
 449          * as the current process anywhere.  Assert the condition.
 450          */
 451         KKASSERT(dd->uschedcp != lp);
 452
 453 #ifndef SMP
 454         /*
 455          * If we are not SMP we do not have a scheduler helper to kick
 456          * and must directly activate the process if none are scheduled.
 457          *
 458          * This is really only an issue when bootstrapping init since
 459          * the caller in all other cases will be a user process, and
 460          * even if released (dd->uschedcp == NULL), that process will
 461          * kickstart the scheduler when it returns to user mode from
 462          * the kernel.
 463          */
 464         if (dd->uschedcp == NULL) {
 465                 atomic_set_cpumask(&bsd4_curprocmask, gd->gd_cpumask);
 466                 dd->uschedcp = lp;
 467                 dd->upri = lp->lwp_priority;
 468                 lwkt_schedule(lp->lwp_thread);
 469                 crit_exit();
 470                 return;
 471         }
 472 #endif
 473
 474 #ifdef SMP
 475         /*
 476          * XXX fixme.  Could be part of a remrunqueue/setrunqueue
 477          * operation when the priority is recalculated, so TDF_MIGRATING
 478          * may already be set.
 479          */
 480         if ((lp->lwp_thread->td_flags & TDF_MIGRATING) == 0)
 481                 lwkt_giveaway(lp->lwp_thread);
 482 #endif
 483
 484         /*
 485          * We lose control of lp the moment we release the spinlock after
 486          * having placed lp on the queue.  i.e. another cpu could pick it
 487          * up and it could exit, or its priority could be further adjusted,
 488          * or something like that.
 489          */
 490         spin_lock(&bsd4_spin);
 491         bsd4_setrunqueue_locked(lp);
 492
 493 #ifdef SMP
 494         /*
 495          * Kick the scheduler helper on one of the other cpu's
 496          * and request a reschedule if appropriate.
 497          *
 498          * NOTE: We check all cpus whos rdyprocmask is set.  First we
 499          *       look for cpus without designated lps, then we look for
 500          *       cpus with designated lps with a worse priority than our
 501          *       process.
 502          */
 503         ++bsd4_scancpu;
 504         cpuid = (bsd4_scancpu & 0xFFFF) % ncpus;
 505         mask = ~bsd4_curprocmask & bsd4_rdyprocmask & lp->lwp_cpumask &
 506                smp_active_mask;
 507
 508         while (mask) {
 509                 tmpmask = ~(CPUMASK(cpuid) - 1);
 510                 if (mask & tmpmask)
 511                         cpuid = BSFCPUMASK(mask & tmpmask);
 512                 else
 513                         cpuid = BSFCPUMASK(mask);
 514                 gd = globaldata_find(cpuid);
 515                 dd = &bsd4_pcpu[cpuid];
 516
 517                 if ((dd->upri & ~PPQMASK) >= (lp->lwp_priority & ~PPQMASK))
 518                         goto found;
 519                 mask &= ~CPUMASK(cpuid);
 520         }
 521
 522         /*
 523          * Then cpus which might have a currently running lp
 524          */
 525         mask = bsd4_curprocmask & bsd4_rdyprocmask &
 526                lp->lwp_cpumask & smp_active_mask;
 527
 528         while (mask) {
 529                 tmpmask = ~(CPUMASK(cpuid) - 1);
 530                 if (mask & tmpmask)
 531                         cpuid = BSFCPUMASK(mask & tmpmask);
 532                 else
 533                         cpuid = BSFCPUMASK(mask);
 534                 gd = globaldata_find(cpuid);
 535                 dd = &bsd4_pcpu[cpuid];
 536
 537                 if ((dd->upri & ~PPQMASK) > (lp->lwp_priority & ~PPQMASK))
 538                         goto found;
 539                 mask &= ~CPUMASK(cpuid);
 540         }
 541
 542         /*
 543          * If we cannot find a suitable cpu we reload from bsd4_scancpu
 544          * and round-robin.  Other cpus will pickup as they release their
 545          * current lwps or become ready.
 546          *
 547          * We only kick the target helper thread in this case, we do not
 548          * set the user resched flag because
 549          */
 550         cpuid = (bsd4_scancpu & 0xFFFF) % ncpus;
 551         gd = globaldata_find(cpuid);
 552         dd = &bsd4_pcpu[cpuid];
 553 found:
 554         if (gd == mycpu) {
 555                 spin_unlock(&bsd4_spin);
 556                 if ((dd->upri & ~PPQMASK) > (lp->lwp_priority & ~PPQMASK))
 557                         need_user_resched();
 558         } else {
 559                 atomic_clear_cpumask(&bsd4_rdyprocmask, CPUMASK(cpuid));
 560                 spin_unlock(&bsd4_spin);
 561                 if ((dd->upri & ~PPQMASK) > (lp->lwp_priority & ~PPQMASK))
 562                         lwkt_send_ipiq(gd, need_user_resched_remote, NULL);
 563                 else
 564                         lwkt_schedule(&dd->helper_thread);
 565         }
 566 #else
 567         /*
 568          * Request a reschedule if appropriate.
 569          */
 570         spin_unlock(&bsd4_spin);
 571         if ((dd->upri & ~PPQMASK) > (lp->lwp_priority & ~PPQMASK)) {
 572                 need_user_resched();
 573         }
 574 #endif
 575         crit_exit();
 576 }
 577
 578 /*
 579  * This routine is called from a systimer IPI.  It MUST be MP-safe and
 580  * the BGL IS NOT HELD ON ENTRY.  This routine is called at ESTCPUFREQ on
 581  * each cpu.
 582  *
 583  * MPSAFE
 584  */
 585 static
 586 void
 587 bsd4_schedulerclock(struct lwp *lp, sysclock_t period, sysclock_t cpstamp)
 588 {
 589         globaldata_t gd = mycpu;
 590         bsd4_pcpu_t dd = &bsd4_pcpu[gd->gd_cpuid];
 591
 592         /*
 593          * Do we need to round-robin?  We round-robin 10 times a second.
 594          * This should only occur for cpu-bound batch processes.
 595          */
 596         if (++dd->rrcount >= usched_bsd4_rrinterval) {
 597                 dd->rrcount = 0;
 598                 need_user_resched();
 599         }
 600
 601         /*
 602          * As the process accumulates cpu time p_estcpu is bumped and may
 603          * push the process into another scheduling queue.  It typically
 604          * takes 4 ticks to bump the queue.
 605          */
 606         lp->lwp_estcpu = ESTCPULIM(lp->lwp_estcpu + ESTCPUINCR);
 607
 608         /*
 609          * Reducing p_origcpu over time causes more of our estcpu to be
 610          * returned to the parent when we exit.  This is a small tweak
 611          * for the batch detection heuristic.
 612          */
 613         if (lp->lwp_origcpu)
 614                 --lp->lwp_origcpu;
 615
 616         /*
 617          * Spinlocks also hold a critical section so there should not be
 618          * any active.
 619          */
 620         KKASSERT(gd->gd_spinlocks_wr == 0);
 621
 622         bsd4_resetpriority(lp);
 623 #if 0
 624         /*
 625         * if we can't call bsd4_resetpriority for some reason we must call
 626          * need user_resched().
 627          */
 628         need_user_resched();
 629 #endif
 630 }
 631
 632 /*
 633  * Called from acquire and from kern_synch's one-second timer (one of the
 634  * callout helper threads) with a critical section held.
 635  *
 636  * Decay p_estcpu based on the number of ticks we haven't been running
 637  * and our p_nice.  As the load increases each process observes a larger
 638  * number of idle ticks (because other processes are running in them).
 639  * This observation leads to a larger correction which tends to make the
 640  * system more 'batchy'.
 641  *
 642  * Note that no recalculation occurs for a process which sleeps and wakes
 643  * up in the same tick.  That is, a system doing thousands of context
 644  * switches per second will still only do serious estcpu calculations
 645  * ESTCPUFREQ times per second.
 646  *
 647  * MPSAFE
 648  */
 649 static
 650 void
 651 bsd4_recalculate_estcpu(struct lwp *lp)
 652 {
 653         globaldata_t gd = mycpu;
 654         sysclock_t cpbase;
 655         int loadfac;
 656         int ndecay;
 657         int nticks;
 658         int nleft;
 659
 660         /*
 661          * We have to subtract periodic to get the last schedclock
 662          * timeout time, otherwise we would get the upcoming timeout.
 663          * Keep in mind that a process can migrate between cpus and
 664          * while the scheduler clock should be very close, boundary
 665          * conditions could lead to a small negative delta.
 666          */
 667         cpbase = gd->gd_schedclock.time - gd->gd_schedclock.periodic;
 668
 669         if (lp->lwp_slptime > 1) {
 670                 /*
 671                  * Too much time has passed, do a coarse correction.
 672                  */
 673                 lp->lwp_estcpu = lp->lwp_estcpu >> 1;
 674                 bsd4_resetpriority(lp);
 675                 lp->lwp_cpbase = cpbase;
 676                 lp->lwp_cpticks = 0;
 677         } else if (lp->lwp_cpbase != cpbase) {
 678                 /*
 679                  * Adjust estcpu if we are in a different tick.  Don't waste
 680                  * time if we are in the same tick.
 681                  *
 682                  * First calculate the number of ticks in the measurement
 683                  * interval.  The nticks calculation can wind up 0 due to
 684                  * a bug in the handling of lwp_slptime  (as yet not found),
 685                  * so make sure we do not get a divide by 0 panic.
 686                  */
 687                 nticks = (cpbase - lp->lwp_cpbase) / gd->gd_schedclock.periodic;
 688                 if (nticks <= 0)
 689                         nticks = 1;
 690                 updatepcpu(lp, lp->lwp_cpticks, nticks);
 691
 692                 if ((nleft = nticks - lp->lwp_cpticks) < 0)
 693                         nleft = 0;
 694                 if (usched_debug == lp->lwp_proc->p_pid) {
 695                         kprintf("pid %d tid %d estcpu %d cpticks %d nticks %d nleft %d",
 696                                 lp->lwp_proc->p_pid, lp->lwp_tid, lp->lwp_estcpu,
 697                                 lp->lwp_cpticks, nticks, nleft);
 698                 }
 699
 700                 /*
 701                  * Calculate a decay value based on ticks remaining scaled
 702                  * down by the instantanious load and p_nice.
 703                  */
 704                 if ((loadfac = bsd4_runqcount) < 2)
 705                         loadfac = 2;
 706                 ndecay = nleft * usched_bsd4_decay * 2 *
 707                         (PRIO_MAX * 2 - lp->lwp_proc->p_nice) / (loadfac * PRIO_MAX * 2);
 708
 709                 /*
 710                  * Adjust p_estcpu.  Handle a border case where batch jobs
 711                  * can get stalled long enough to decay to zero when they
 712                  * shouldn't.
 713                  */
 714                 if (lp->lwp_estcpu > ndecay * 2)
 715                         lp->lwp_estcpu -= ndecay;
 716                 else
 717                         lp->lwp_estcpu >>= 1;
 718
 719                 if (usched_debug == lp->lwp_proc->p_pid)
 720                         kprintf(" ndecay %d estcpu %d\n", ndecay, lp->lwp_estcpu);
 721                 bsd4_resetpriority(lp);
 722                 lp->lwp_cpbase = cpbase;
 723                 lp->lwp_cpticks = 0;
 724         }
 725 }
 726
 727 /*
 728  * Compute the priority of a process when running in user mode.
 729  * Arrange to reschedule if the resulting priority is better
 730  * than that of the current process.
 731  *
 732  * This routine may be called with any process.
 733  *
 734  * This routine is called by fork1() for initial setup with the process
 735  * of the run queue, and also may be called normally with the process on or
 736  * off the run queue.
 737  *
 738  * MPSAFE
 739  */
 740 static void
 741 bsd4_resetpriority(struct lwp *lp)
 742 {
 743         bsd4_pcpu_t dd;
 744         int newpriority;
 745         u_short newrqtype;
 746         int reschedcpu;
 747
 748         /*
 749          * Calculate the new priority and queue type
 750          */
 751         crit_enter();
 752         spin_lock(&bsd4_spin);
 753
 754         newrqtype = lp->lwp_rtprio.type;
 755
 756         switch(newrqtype) {
 757         case RTP_PRIO_REALTIME:
 758         case RTP_PRIO_FIFO:
 759                 newpriority = PRIBASE_REALTIME +
 760                              (lp->lwp_rtprio.prio & PRIMASK);
 761                 break;
 762         case RTP_PRIO_NORMAL:
 763                 newpriority = (lp->lwp_proc->p_nice - PRIO_MIN) * PPQ / NICEPPQ;
 764                 newpriority += lp->lwp_estcpu * PPQ / ESTCPUPPQ;
 765                 newpriority = newpriority * MAXPRI / (PRIO_RANGE * PPQ /
 766                               NICEPPQ + ESTCPUMAX * PPQ / ESTCPUPPQ);
 767                 newpriority = PRIBASE_NORMAL + (newpriority & PRIMASK);
 768                 break;
 769         case RTP_PRIO_IDLE:
 770                 newpriority = PRIBASE_IDLE + (lp->lwp_rtprio.prio & PRIMASK);
 771                 break;
 772         case RTP_PRIO_THREAD:
 773                 newpriority = PRIBASE_THREAD + (lp->lwp_rtprio.prio & PRIMASK);
 774                 break;
 775         default:
 776                 panic("Bad RTP_PRIO %d", newrqtype);
 777                 /* NOT REACHED */
 778         }
 779
 780         /*
 781          * The newpriority incorporates the queue type so do a simple masked
 782          * check to determine if the process has moved to another queue.  If
 783          * it has, and it is currently on a run queue, then move it.
 784          */
 785         if ((lp->lwp_priority ^ newpriority) & ~PPQMASK) {
 786                 lp->lwp_priority = newpriority;
 787                 if (lp->lwp_flag & LWP_ONRUNQ) {
 788                         bsd4_remrunqueue_locked(lp);
 789                         lp->lwp_rqtype = newrqtype;
 790                         lp->lwp_rqindex = (newpriority & PRIMASK) / PPQ;
 791                         bsd4_setrunqueue_locked(lp);
 792                         reschedcpu = lp->lwp_thread->td_gd->gd_cpuid;
 793                 } else {
 794                         lp->lwp_rqtype = newrqtype;
 795                         lp->lwp_rqindex = (newpriority & PRIMASK) / PPQ;
 796                         reschedcpu = -1;
 797                 }
 798         } else {
 799                 lp->lwp_priority = newpriority;
 800                 reschedcpu = -1;
 801         }
 802
 803         /*
 804          * Determine if we need to reschedule the target cpu.  This only
 805          * occurs if the LWP is already on a scheduler queue, which means
 806          * that idle cpu notification has already occured.  At most we
 807          * need only issue a need_user_resched() on the appropriate cpu.
 808          *
 809          * The LWP may be owned by a CPU different from the current one,
 810          * in which case dd->uschedcp may be modified without an MP lock
 811          * or a spinlock held.  The worst that happens is that the code
 812          * below causes a spurious need_user_resched() on the target CPU
 813          * and dd->pri to be wrong for a short period of time, both of
 814          * which are harmless.
 815          */
 816         if (reschedcpu >= 0) {
 817                 dd = &bsd4_pcpu[reschedcpu];
 818                 if ((bsd4_rdyprocmask & CPUMASK(reschedcpu)) &&
 819                     (dd->upri & ~PRIMASK) > (lp->lwp_priority & ~PRIMASK)) {
 820 #ifdef SMP
 821                         if (reschedcpu == mycpu->gd_cpuid) {
 822                                 spin_unlock(&bsd4_spin);
 823                                 need_user_resched();
 824                         } else {
 825                                 spin_unlock(&bsd4_spin);
 826                                 atomic_clear_cpumask(&bsd4_rdyprocmask,
 827                                                      CPUMASK(reschedcpu));
 828                                 lwkt_send_ipiq(lp->lwp_thread->td_gd,
 829                                                need_user_resched_remote, NULL);
 830                         }
 831 #else
 832                         spin_unlock(&bsd4_spin);
 833                         need_user_resched();
 834 #endif
 835                 } else {
 836                         spin_unlock(&bsd4_spin);
 837                 }
 838         } else {
 839                 spin_unlock(&bsd4_spin);
 840         }
 841         crit_exit();
 842 }
 843
 844 /*
 845  * MPSAFE
 846  */
 847 static
 848 void
 849 bsd4_yield(struct lwp *lp)
 850 {
 851 #if 0
 852         /* FUTURE (or something similar) */
 853         switch(lp->lwp_rqtype) {
 854         case RTP_PRIO_NORMAL:
 855                 lp->lwp_estcpu = ESTCPULIM(lp->lwp_estcpu + ESTCPUINCR);
 856                 break;
 857         default:
 858                 break;
 859         }
 860 #endif
 861         need_user_resched();
 862 }
 863
 864 /*
 865  * Called from fork1() when a new child process is being created.
 866  *
 867  * Give the child process an initial estcpu that is more batch then
 868  * its parent and dock the parent for the fork (but do not
 869  * reschedule the parent).   This comprises the main part of our batch
 870  * detection heuristic for both parallel forking and sequential execs.
 871  *
 872  * Interactive processes will decay the boosted estcpu quickly while batch
 873  * processes will tend to compound it.
 874  * XXX lwp should be "spawning" instead of "forking"
 875  *
 876  * MPSAFE
 877  */
 878 static void
 879 bsd4_forking(struct lwp *plp, struct lwp *lp)
 880 {
 881         lp->lwp_estcpu = ESTCPULIM(plp->lwp_estcpu + ESTCPUPPQ);
 882         lp->lwp_origcpu = lp->lwp_estcpu;
 883         plp->lwp_estcpu = ESTCPULIM(plp->lwp_estcpu + ESTCPUPPQ);
 884 }
 885
 886 /*
 887  * Called when the parent reaps a child.   Propogate cpu use by the child
 888  * back to the parent.
 889  *
 890  * MPSAFE
 891  */
 892 static void
 893 bsd4_exiting(struct lwp *plp, struct lwp *lp)
 894 {
 895         int delta;
 896
 897         if (plp->lwp_proc->p_pid != 1) {
 898                 delta = lp->lwp_estcpu - lp->lwp_origcpu;
 899                 if (delta > 0)
 900                         plp->lwp_estcpu = ESTCPULIM(plp->lwp_estcpu + delta);
 901         }
 902 }
 903
 904
 905 /*
 906  * chooseproc() is called when a cpu needs a user process to LWKT schedule,
 907  * it selects a user process and returns it.  If chklp is non-NULL and chklp
 908  * has a better or equal priority then the process that would otherwise be
 909  * chosen, NULL is returned.
 910  *
 911  * Until we fix the RUNQ code the chklp test has to be strict or we may
 912  * bounce between processes trying to acquire the current process designation.
 913  *
 914  * MPSAFE - must be called with bsd4_spin exclusive held.  The spinlock is
 915  *          left intact through the entire routine.
 916  */
 917 static
 918 struct lwp *
 919 chooseproc_locked(struct lwp *chklp)
 920 {
 921         struct lwp *lp;
 922         struct rq *q;
 923         u_int32_t *which, *which2;
 924         u_int32_t pri;
 925         u_int32_t rtqbits;
 926         u_int32_t tsqbits;
 927         u_int32_t idqbits;
 928         cpumask_t cpumask;
 929
 930         rtqbits = bsd4_rtqueuebits;
 931         tsqbits = bsd4_queuebits;
 932         idqbits = bsd4_idqueuebits;
 933         cpumask = mycpu->gd_cpumask;
 934
 935 #ifdef SMP
 936 again:
 937 #endif
 938         if (rtqbits) {
 939                 pri = bsfl(rtqbits);
 940                 q = &bsd4_rtqueues[pri];
 941                 which = &bsd4_rtqueuebits;
 942                 which2 = &rtqbits;
 943         } else if (tsqbits) {
 944                 pri = bsfl(tsqbits);
 945                 q = &bsd4_queues[pri];
 946                 which = &bsd4_queuebits;
 947                 which2 = &tsqbits;
 948         } else if (idqbits) {
 949                 pri = bsfl(idqbits);
 950                 q = &bsd4_idqueues[pri];
 951                 which = &bsd4_idqueuebits;
 952                 which2 = &idqbits;
 953         } else {
 954                 return NULL;
 955         }
 956         lp = TAILQ_FIRST(q);
 957         KASSERT(lp, ("chooseproc: no lwp on busy queue"));
 958
 959 #ifdef SMP
 960         while ((lp->lwp_cpumask & cpumask) == 0) {
 961                 lp = TAILQ_NEXT(lp, lwp_procq);
 962                 if (lp == NULL) {
 963                         *which2 &= ~(1 << pri);
 964                         goto again;
 965                 }
 966         }
 967 #endif
 968
 969         /*
 970          * If the passed lwp <chklp> is reasonably close to the selected
 971          * lwp <lp>, return NULL (indicating that <chklp> should be kept).
 972          *
 973          * Note that we must error on the side of <chklp> to avoid bouncing
 974          * between threads in the acquire code.
 975          */
 976         if (chklp) {
 977                 if (chklp->lwp_priority < lp->lwp_priority + PPQ)
 978                         return(NULL);
 979         }
 980
 981 #ifdef SMP
 982         /*
 983          * If the chosen lwp does not reside on this cpu spend a few
 984          * cycles looking for a better candidate at the same priority level.
 985          * This is a fallback check, setrunqueue() tries to wakeup the
 986          * correct cpu and is our front-line affinity.
 987          */
 988         if (lp->lwp_thread->td_gd != mycpu &&
 989             (chklp = TAILQ_NEXT(lp, lwp_procq)) != NULL
 990         ) {
 991                 if (chklp->lwp_thread->td_gd == mycpu) {
 992                         ++choose_affinity;
 993                         lp = chklp;
 994                 }
 995         }
 996 #endif
 997
 998         TAILQ_REMOVE(q, lp, lwp_procq);
 999         --bsd4_runqcount;
1000         if (TAILQ_EMPTY(q))
1001                 *which &= ~(1 << pri);
1002         KASSERT((lp->lwp_flag & LWP_ONRUNQ) != 0, ("not on runq6!"));
1003         lp->lwp_flag &= ~LWP_ONRUNQ;
1004         return lp;
1005 }
1006
1007 #ifdef SMP
1008
1009 static
1010 void
1011 need_user_resched_remote(void *dummy)
1012 {
1013         globaldata_t gd = mycpu;
1014         bsd4_pcpu_t  dd = &bsd4_pcpu[gd->gd_cpuid];
1015
1016         need_user_resched();
1017         lwkt_schedule(&dd->helper_thread);
1018 }
1019
1020 #endif
1021
1022 /*
1023  * bsd4_remrunqueue_locked() removes a given process from the run queue
1024  * that it is on, clearing the queue busy bit if it becomes empty.
1025  *
1026  * Note that user process scheduler is different from the LWKT schedule.
1027  * The user process scheduler only manages user processes but it uses LWKT
1028  * underneath, and a user process operating in the kernel will often be
1029  * 'released' from our management.
1030  *
1031  * MPSAFE - bsd4_spin must be held exclusively on call
1032  */
1033 static void
1034 bsd4_remrunqueue_locked(struct lwp *lp)
1035 {
1036         struct rq *q;
1037         u_int32_t *which;
1038         u_int8_t pri;
1039
1040         KKASSERT(lp->lwp_flag & LWP_ONRUNQ);
1041         lp->lwp_flag &= ~LWP_ONRUNQ;
1042         --bsd4_runqcount;
1043         KKASSERT(bsd4_runqcount >= 0);
1044
1045         pri = lp->lwp_rqindex;
1046         switch(lp->lwp_rqtype) {
1047         case RTP_PRIO_NORMAL:
1048                 q = &bsd4_queues[pri];
1049                 which = &bsd4_queuebits;
1050                 break;
1051         case RTP_PRIO_REALTIME:
1052         case RTP_PRIO_FIFO:
1053                 q = &bsd4_rtqueues[pri];
1054                 which = &bsd4_rtqueuebits;
1055                 break;
1056         case RTP_PRIO_IDLE:
1057                 q = &bsd4_idqueues[pri];
1058                 which = &bsd4_idqueuebits;
1059                 break;
1060         default:
1061                 panic("remrunqueue: invalid rtprio type");
1062                 /* NOT REACHED */
1063         }
1064         TAILQ_REMOVE(q, lp, lwp_procq);
1065         if (TAILQ_EMPTY(q)) {
1066                 KASSERT((*which & (1 << pri)) != 0,
1067                         ("remrunqueue: remove from empty queue"));
1068                 *which &= ~(1 << pri);
1069         }
1070 }
1071
1072 /*
1073  * bsd4_setrunqueue_locked()
1074  *
1075  * Add a process whos rqtype and rqindex had previously been calculated
1076  * onto the appropriate run queue.   Determine if the addition requires
1077  * a reschedule on a cpu and return the cpuid or -1.
1078  *
1079  * NOTE: Lower priorities are better priorities.
1080  *
1081  * MPSAFE - bsd4_spin must be held exclusively on call
1082  */
1083 static void
1084 bsd4_setrunqueue_locked(struct lwp *lp)
1085 {
1086         struct rq *q;
1087         u_int32_t *which;
1088         int pri;
1089
1090         KKASSERT((lp->lwp_flag & LWP_ONRUNQ) == 0);
1091         lp->lwp_flag |= LWP_ONRUNQ;
1092         ++bsd4_runqcount;
1093
1094         pri = lp->lwp_rqindex;
1095
1096         switch(lp->lwp_rqtype) {
1097         case RTP_PRIO_NORMAL:
1098                 q = &bsd4_queues[pri];
1099                 which = &bsd4_queuebits;
1100                 break;
1101         case RTP_PRIO_REALTIME:
1102         case RTP_PRIO_FIFO:
1103                 q = &bsd4_rtqueues[pri];
1104                 which = &bsd4_rtqueuebits;
1105                 break;
1106         case RTP_PRIO_IDLE:
1107                 q = &bsd4_idqueues[pri];
1108                 which = &bsd4_idqueuebits;
1109                 break;
1110         default:
1111                 panic("remrunqueue: invalid rtprio type");
1112                 /* NOT REACHED */
1113         }
1114
1115         /*
1116          * Add to the correct queue and set the appropriate bit.  If no
1117          * lower priority (i.e. better) processes are in the queue then
1118          * we want a reschedule, calculate the best cpu for the job.
1119          *
1120          * Always run reschedules on the LWPs original cpu.
1121          */
1122         TAILQ_INSERT_TAIL(q, lp, lwp_procq);
1123         *which |= 1 << pri;
1124 }
1125
1126 #ifdef SMP
1127
1128 /*
1129  * For SMP systems a user scheduler helper thread is created for each
1130  * cpu and is used to allow one cpu to wakeup another for the purposes of
1131  * scheduling userland threads from setrunqueue().
1132  *
1133  * UP systems do not need the helper since there is only one cpu.
1134  *
1135  * We can't use the idle thread for this because we might block.
1136  * Additionally, doing things this way allows us to HLT idle cpus
1137  * on MP systems.
1138  *
1139  * MPSAFE
1140  */
1141 static void
1142 sched_thread(void *dummy)
1143 {
1144     globaldata_t gd;
1145     bsd4_pcpu_t  dd;
1146     struct lwp *nlp;
1147     cpumask_t mask;
1148     int cpuid;
1149 #ifdef SMP
1150     cpumask_t tmpmask;
1151     int tmpid;
1152 #endif
1153
1154     gd = mycpu;
1155     cpuid = gd->gd_cpuid;       /* doesn't change */
1156     mask = gd->gd_cpumask;      /* doesn't change */
1157     dd = &bsd4_pcpu[cpuid];
1158
1159     /*
1160      * Since we are woken up only when no user processes are scheduled
1161      * on a cpu, we can run at an ultra low priority.
1162      */
1163     lwkt_setpri_self(TDPRI_USER_SCHEDULER);
1164
1165     for (;;) {
1166         /*
1167          * We use the LWKT deschedule-interlock trick to avoid racing
1168          * bsd4_rdyprocmask.  This means we cannot block through to the
1169          * manual lwkt_switch() call we make below.
1170          */
1171         crit_enter_gd(gd);
1172         lwkt_deschedule_self(gd->gd_curthread);
1173         spin_lock(&bsd4_spin);
1174         atomic_set_cpumask(&bsd4_rdyprocmask, mask);
1175
1176         clear_user_resched();   /* This satisfied the reschedule request */
1177         dd->rrcount = 0;        /* Reset the round-robin counter */
1178
1179         if ((bsd4_curprocmask & mask) == 0) {
1180                 /*
1181                  * No thread is currently scheduled.
1182                  */
1183                 KKASSERT(dd->uschedcp == NULL);
1184                 if ((nlp = chooseproc_locked(NULL)) != NULL) {
1185                         atomic_set_cpumask(&bsd4_curprocmask, mask);
1186                         dd->upri = nlp->lwp_priority;
1187                         dd->uschedcp = nlp;
1188                         spin_unlock(&bsd4_spin);
1189                         lwkt_acquire(nlp->lwp_thread);
1190                         lwkt_schedule(nlp->lwp_thread);
1191                 } else {
1192                         spin_unlock(&bsd4_spin);
1193                 }
1194         } else if (bsd4_runqcount) {
1195                 if ((nlp = chooseproc_locked(dd->uschedcp)) != NULL) {
1196                         dd->upri = nlp->lwp_priority;
1197                         dd->uschedcp = nlp;
1198                         spin_unlock(&bsd4_spin);
1199                         lwkt_acquire(nlp->lwp_thread);
1200                         lwkt_schedule(nlp->lwp_thread);
1201                 } else {
1202                         /*
1203                          * CHAINING CONDITION TRAIN
1204                          *
1205                          * We could not deal with the scheduler wakeup
1206                          * request on this cpu, locate a ready scheduler
1207                          * with no current lp assignment and chain to it.
1208                          *
1209                          * This ensures that a wakeup race which fails due
1210                          * to priority test does not leave other unscheduled
1211                          * cpus idle when the runqueue is not empty.
1212                          */
1213                         tmpmask = ~bsd4_curprocmask & bsd4_rdyprocmask &
1214                                   smp_active_mask;
1215                         if (tmpmask) {
1216                                 tmpid = BSFCPUMASK(tmpmask);
1217                                 gd = globaldata_find(cpuid);
1218                                 dd = &bsd4_pcpu[cpuid];
1219                                 atomic_clear_cpumask(&bsd4_rdyprocmask,
1220                                                      CPUMASK(tmpid));
1221                                 spin_unlock(&bsd4_spin);
1222                                 lwkt_schedule(&dd->helper_thread);
1223                         } else {
1224                                 spin_unlock(&bsd4_spin);
1225                         }
1226                 }
1227         } else {
1228                 /*
1229                  * The runq is empty.
1230                  */
1231                 spin_unlock(&bsd4_spin);
1232         }
1233         crit_exit_gd(gd);
1234         lwkt_switch();
1235     }
1236 }
1237
1238 /*
1239  * Setup our scheduler helpers.  Note that curprocmask bit 0 has already
1240  * been cleared by rqinit() and we should not mess with it further.
1241  */
1242 static void
1243 sched_thread_cpu_init(void)
1244 {
1245     int i;
1246
1247     if (bootverbose)
1248         kprintf("start scheduler helpers on cpus:");
1249
1250     for (i = 0; i < ncpus; ++i) {
1251         bsd4_pcpu_t dd = &bsd4_pcpu[i];
1252         cpumask_t mask = CPUMASK(i);
1253
1254         if ((mask & smp_active_mask) == 0)
1255             continue;
1256
1257         if (bootverbose)
1258             kprintf(" %d", i);
1259
1260         lwkt_create(sched_thread, NULL, NULL, &dd->helper_thread,
1261                     TDF_STOPREQ, i, "usched %d", i);
1262
1263         /*
1264          * Allow user scheduling on the target cpu.  cpu #0 has already
1265          * been enabled in rqinit().
1266          */
1267         if (i)
1268             atomic_clear_cpumask(&bsd4_curprocmask, mask);
1269         atomic_set_cpumask(&bsd4_rdyprocmask, mask);
1270         dd->upri = PRIBASE_NULL;
1271     }
1272     if (bootverbose)
1273         kprintf("\n");
1274 }
1275 SYSINIT(uschedtd, SI_BOOT2_USCHED, SI_ORDER_SECOND,
1276         sched_thread_cpu_init, NULL)
1277
1278 #endif
1279