The Design and Implementation of the FreeBSD Operating System, Second Edition
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_synch.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 

    1 /*-
    2  * Copyright (c) 1982, 1986, 1990, 1991, 1993
    3  *      The Regents of the University of California.  All rights reserved.
    4  * (c) UNIX System Laboratories, Inc.
    5  * All or some portions of this file are derived from material licensed
    6  * to the University of California by American Telephone and Telegraph
    7  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
    8  * the permission of UNIX System Laboratories, Inc.
    9  *
   10  * Redistribution and use in source and binary forms, with or without
   11  * modification, are permitted provided that the following conditions
   12  * are met:
   13  * 1. Redistributions of source code must retain the above copyright
   14  *    notice, this list of conditions and the following disclaimer.
   15  * 2. Redistributions in binary form must reproduce the above copyright
   16  *    notice, this list of conditions and the following disclaimer in the
   17  *    documentation and/or other materials provided with the distribution.
   18  * 4. Neither the name of the University nor the names of its contributors
   19  *    may be used to endorse or promote products derived from this software
   20  *    without specific prior written permission.
   21  *
   22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   32  * SUCH DAMAGE.
   33  *
   34  *      @(#)kern_synch.c        8.9 (Berkeley) 5/19/95
   35  */
   36 
   37 #include <sys/cdefs.h>
   38 __FBSDID("$FreeBSD: releng/7.3/sys/kern/kern_synch.c 188730 2009-02-17 21:02:35Z jhb $");
   39 
   40 #include "opt_ktrace.h"
   41 
   42 #include <sys/param.h>
   43 #include <sys/systm.h>
   44 #include <sys/condvar.h>
   45 #include <sys/kdb.h>
   46 #include <sys/kernel.h>
   47 #include <sys/ktr.h>
   48 #include <sys/lock.h>
   49 #include <sys/mutex.h>
   50 #include <sys/proc.h>
   51 #include <sys/resourcevar.h>
   52 #include <sys/sched.h>
   53 #include <sys/signalvar.h>
   54 #include <sys/sleepqueue.h>
   55 #include <sys/smp.h>
   56 #include <sys/sx.h>
   57 #include <sys/sysctl.h>
   58 #include <sys/sysproto.h>
   59 #include <sys/vmmeter.h>
   60 #ifdef KTRACE
   61 #include <sys/uio.h>
   62 #include <sys/ktrace.h>
   63 #endif
   64 
   65 #include <machine/cpu.h>
   66 
   67 static void synch_setup(void *dummy);
   68 SYSINIT(synch_setup, SI_SUB_KICK_SCHEDULER, SI_ORDER_FIRST, synch_setup,
   69     NULL);
   70 
   71 int     hogticks;
   72 int     lbolt;
   73 static int pause_wchan;
   74 
   75 static struct callout loadav_callout;
   76 static struct callout lbolt_callout;
   77 
   78 struct loadavg averunnable =
   79         { {0, 0, 0}, FSCALE };  /* load average, of runnable procs */
   80 /*
   81  * Constants for averages over 1, 5, and 15 minutes
   82  * when sampling at 5 second intervals.
   83  */
   84 static fixpt_t cexp[3] = {
   85         0.9200444146293232 * FSCALE,    /* exp(-1/12) */
   86         0.9834714538216174 * FSCALE,    /* exp(-1/60) */
   87         0.9944598480048967 * FSCALE,    /* exp(-1/180) */
   88 };
   89 
   90 /* kernel uses `FSCALE', userland (SHOULD) use kern.fscale */
   91 static int      fscale __unused = FSCALE;
   92 SYSCTL_INT(_kern, OID_AUTO, fscale, CTLFLAG_RD, 0, FSCALE, "");
   93 
   94 static void     loadav(void *arg);
   95 static void     lboltcb(void *arg);
   96 
   97 void
   98 sleepinit(void)
   99 {
  100 
  101         hogticks = (hz / 10) * 2;       /* Default only. */
  102         init_sleepqueues();
  103 }
  104 
  105 /*
  106  * General sleep call.  Suspends the current thread until a wakeup is
  107  * performed on the specified identifier.  The thread will then be made
  108  * runnable with the specified priority.  Sleeps at most timo/hz seconds
  109  * (0 means no timeout).  If pri includes PCATCH flag, signals are checked
  110  * before and after sleeping, else signals are not checked.  Returns 0 if
  111  * awakened, EWOULDBLOCK if the timeout expires.  If PCATCH is set and a
  112  * signal needs to be delivered, ERESTART is returned if the current system
  113  * call should be restarted if possible, and EINTR is returned if the system
  114  * call should be interrupted by the signal (return EINTR).
  115  *
  116  * The lock argument is unlocked before the caller is suspended, and
  117  * re-locked before _sleep() returns.  If priority includes the PDROP
  118  * flag the lock is not re-locked before returning.
  119  */
  120 int
  121 _sleep(void *ident, struct lock_object *lock, int priority,
  122     const char *wmesg, int timo)
  123 {
  124         struct thread *td;
  125         struct proc *p;
  126         struct lock_class *class;
  127         int catch, flags, lock_state, pri, rval;
  128         WITNESS_SAVE_DECL(lock_witness);
  129 
  130         td = curthread;
  131         p = td->td_proc;
  132 #ifdef KTRACE
  133         if (KTRPOINT(td, KTR_CSW))
  134                 ktrcsw(1, 0);
  135 #endif
  136         WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, lock,
  137             "Sleeping on \"%s\"", wmesg);
  138         KASSERT(timo != 0 || mtx_owned(&Giant) || lock != NULL ||
  139             ident == &lbolt, ("sleeping without a lock"));
  140         KASSERT(p != NULL, ("msleep1"));
  141         KASSERT(ident != NULL && TD_IS_RUNNING(td), ("msleep"));
  142         if (priority & PDROP)
  143                 KASSERT(lock != NULL && lock != &Giant.lock_object,
  144                     ("PDROP requires a non-Giant lock"));
  145         if (lock != NULL)
  146                 class = LOCK_CLASS(lock);
  147         else
  148                 class = NULL;
  149 
  150         if (cold) {
  151                 /*
  152                  * During autoconfiguration, just return;
  153                  * don't run any other threads or panic below,
  154                  * in case this is the idle thread and already asleep.
  155                  * XXX: this used to do "s = splhigh(); splx(safepri);
  156                  * splx(s);" to give interrupts a chance, but there is
  157                  * no way to give interrupts a chance now.
  158                  */
  159                 if (lock != NULL && priority & PDROP)
  160                         class->lc_unlock(lock);
  161                 return (0);
  162         }
  163         catch = priority & PCATCH;
  164         rval = 0;
  165 
  166         /*
  167          * If we are already on a sleep queue, then remove us from that
  168          * sleep queue first.  We have to do this to handle recursive
  169          * sleeps.
  170          */
  171         if (TD_ON_SLEEPQ(td))
  172                 sleepq_remove(td, td->td_wchan);
  173 
  174         if (ident == &pause_wchan)
  175                 flags = SLEEPQ_PAUSE;
  176         else
  177                 flags = SLEEPQ_SLEEP;
  178         if (catch)
  179                 flags |= SLEEPQ_INTERRUPTIBLE;
  180 
  181         sleepq_lock(ident);
  182         CTR5(KTR_PROC, "sleep: thread %ld (pid %ld, %s) on %s (%p)",
  183             td->td_tid, p->p_pid, p->p_comm, wmesg, ident);
  184 
  185         DROP_GIANT();
  186         if (lock != NULL && lock != &Giant.lock_object &&
  187             !(class->lc_flags & LC_SLEEPABLE)) {
  188                 WITNESS_SAVE(lock, lock_witness);
  189                 lock_state = class->lc_unlock(lock);
  190         } else
  191                 /* GCC needs to follow the Yellow Brick Road */
  192                 lock_state = -1;
  193 
  194         /*
  195          * We put ourselves on the sleep queue and start our timeout
  196          * before calling thread_suspend_check, as we could stop there,
  197          * and a wakeup or a SIGCONT (or both) could occur while we were
  198          * stopped without resuming us.  Thus, we must be ready for sleep
  199          * when cursig() is called.  If the wakeup happens while we're
  200          * stopped, then td will no longer be on a sleep queue upon
  201          * return from cursig().
  202          */
  203         sleepq_add(ident, ident == &lbolt ? NULL : lock, wmesg, flags, 0);
  204         if (timo)
  205                 sleepq_set_timeout(ident, timo);
  206         if (lock != NULL && class->lc_flags & LC_SLEEPABLE) {
  207                 sleepq_release(ident);
  208                 WITNESS_SAVE(lock, lock_witness);
  209                 lock_state = class->lc_unlock(lock);
  210                 sleepq_lock(ident);
  211         }
  212 
  213         /*
  214          * Adjust this thread's priority, if necessary.
  215          */
  216         pri = priority & PRIMASK;
  217         if (pri != 0 && pri != td->td_priority) {
  218                 thread_lock(td);
  219                 sched_prio(td, pri);
  220                 thread_unlock(td);
  221         }
  222 
  223         if (timo && catch)
  224                 rval = sleepq_timedwait_sig(ident);
  225         else if (timo)
  226                 rval = sleepq_timedwait(ident);
  227         else if (catch)
  228                 rval = sleepq_wait_sig(ident);
  229         else {
  230                 sleepq_wait(ident);
  231                 rval = 0;
  232         }
  233 #ifdef KTRACE
  234         if (KTRPOINT(td, KTR_CSW))
  235                 ktrcsw(0, 0);
  236 #endif
  237         PICKUP_GIANT();
  238         if (lock != NULL && lock != &Giant.lock_object && !(priority & PDROP)) {
  239                 class->lc_lock(lock, lock_state);
  240                 WITNESS_RESTORE(lock, lock_witness);
  241         }
  242         return (rval);
  243 }
  244 
  245 int
  246 msleep_spin(void *ident, struct mtx *mtx, const char *wmesg, int timo)
  247 {
  248         struct thread *td;
  249         struct proc *p;
  250         int rval;
  251         WITNESS_SAVE_DECL(mtx);
  252 
  253         td = curthread;
  254         p = td->td_proc;
  255         KASSERT(mtx != NULL, ("sleeping without a mutex"));
  256         KASSERT(p != NULL, ("msleep1"));
  257         KASSERT(ident != NULL && TD_IS_RUNNING(td), ("msleep"));
  258 
  259         if (cold) {
  260                 /*
  261                  * During autoconfiguration, just return;
  262                  * don't run any other threads or panic below,
  263                  * in case this is the idle thread and already asleep.
  264                  * XXX: this used to do "s = splhigh(); splx(safepri);
  265                  * splx(s);" to give interrupts a chance, but there is
  266                  * no way to give interrupts a chance now.
  267                  */
  268                 return (0);
  269         }
  270 
  271         sleepq_lock(ident);
  272         CTR5(KTR_PROC, "msleep_spin: thread %ld (pid %ld, %s) on %s (%p)",
  273             td->td_tid, p->p_pid, p->p_comm, wmesg, ident);
  274 
  275         DROP_GIANT();
  276         mtx_assert(mtx, MA_OWNED | MA_NOTRECURSED);
  277         WITNESS_SAVE(&mtx->lock_object, mtx);
  278         mtx_unlock_spin(mtx);
  279 
  280         /*
  281          * We put ourselves on the sleep queue and start our timeout.
  282          */
  283         sleepq_add(ident, &mtx->lock_object, wmesg, SLEEPQ_SLEEP, 0);
  284         if (timo)
  285                 sleepq_set_timeout(ident, timo);
  286 
  287         /*
  288          * Can't call ktrace with any spin locks held so it can lock the
  289          * ktrace_mtx lock, and WITNESS_WARN considers it an error to hold
  290          * any spin lock.  Thus, we have to drop the sleepq spin lock while
  291          * we handle those requests.  This is safe since we have placed our
  292          * thread on the sleep queue already.
  293          */
  294 #ifdef KTRACE
  295         if (KTRPOINT(td, KTR_CSW)) {
  296                 sleepq_release(ident);
  297                 ktrcsw(1, 0);
  298                 sleepq_lock(ident);
  299         }
  300 #endif
  301 #ifdef WITNESS
  302         sleepq_release(ident);
  303         WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL, "Sleeping on \"%s\"",
  304             wmesg);
  305         sleepq_lock(ident);
  306 #endif
  307         if (timo)
  308                 rval = sleepq_timedwait(ident);
  309         else {
  310                 sleepq_wait(ident);
  311                 rval = 0;
  312         }
  313 #ifdef KTRACE
  314         if (KTRPOINT(td, KTR_CSW))
  315                 ktrcsw(0, 0);
  316 #endif
  317         PICKUP_GIANT();
  318         mtx_lock_spin(mtx);
  319         WITNESS_RESTORE(&mtx->lock_object, mtx);
  320         return (rval);
  321 }
  322 
  323 /*
  324  * pause() is like tsleep() except that the intention is to not be
  325  * explicitly woken up by another thread.  Instead, the current thread
  326  * simply wishes to sleep until the timeout expires.  It is
  327  * implemented using a dummy wait channel.
  328  */
  329 int
  330 pause(const char *wmesg, int timo)
  331 {
  332 
  333         KASSERT(timo != 0, ("pause: timeout required"));
  334         return (tsleep(&pause_wchan, 0, wmesg, timo));
  335 }
  336 
  337 /*
  338  * Make all threads sleeping on the specified identifier runnable.
  339  */
  340 void
  341 wakeup(void *ident)
  342 {
  343         int wakeup_swapper;
  344 
  345         sleepq_lock(ident);
  346         wakeup_swapper = sleepq_broadcast(ident, SLEEPQ_SLEEP, -1, 0);
  347         if (wakeup_swapper)
  348                 kick_proc0();
  349 }
  350 
  351 /*
  352  * Make a thread sleeping on the specified identifier runnable.
  353  * May wake more than one thread if a target thread is currently
  354  * swapped out.
  355  */
  356 void
  357 wakeup_one(void *ident)
  358 {
  359         int wakeup_swapper;
  360 
  361         sleepq_lock(ident);
  362         wakeup_swapper = sleepq_signal(ident, SLEEPQ_SLEEP, -1, 0);
  363         sleepq_release(ident);
  364         if (wakeup_swapper)
  365                 kick_proc0();
  366 }
  367 
  368 /*
  369  * The machine independent parts of context switching.
  370  */
  371 void
  372 mi_switch(int flags, struct thread *newtd)
  373 {
  374         uint64_t runtime, new_switchtime;
  375         struct thread *td;
  376         struct proc *p;
  377 
  378         td = curthread;                 /* XXX */
  379         THREAD_LOCK_ASSERT(td, MA_OWNED | MA_NOTRECURSED);
  380         p = td->td_proc;                /* XXX */
  381         KASSERT(!TD_ON_RUNQ(td), ("mi_switch: called by old code"));
  382 #ifdef INVARIANTS
  383         if (!TD_ON_LOCK(td) && !TD_IS_RUNNING(td))
  384                 mtx_assert(&Giant, MA_NOTOWNED);
  385 #endif
  386         KASSERT(td->td_critnest == 1 || (td->td_critnest == 2 &&
  387             (td->td_owepreempt) && (flags & SW_INVOL) != 0 &&
  388             newtd == NULL) || panicstr,
  389             ("mi_switch: switch in a critical section"));
  390         KASSERT((flags & (SW_INVOL | SW_VOL)) != 0,
  391             ("mi_switch: switch must be voluntary or involuntary"));
  392         KASSERT(newtd != curthread, ("mi_switch: preempting back to ourself"));
  393 
  394         /*
  395          * Don't perform context switches from the debugger.
  396          */
  397         if (kdb_active) {
  398                 thread_unlock(td);
  399                 kdb_backtrace();
  400                 kdb_reenter();
  401                 panic("%s: did not reenter debugger", __func__);
  402         }
  403         if (flags & SW_VOL)
  404                 td->td_ru.ru_nvcsw++;
  405         else
  406                 td->td_ru.ru_nivcsw++;
  407         /*
  408          * Compute the amount of time during which the current
  409          * thread was running, and add that to its total so far.
  410          */
  411         new_switchtime = cpu_ticks();
  412         runtime = new_switchtime - PCPU_GET(switchtime);
  413         td->td_runtime += runtime;
  414         td->td_incruntime += runtime;
  415         PCPU_SET(switchtime, new_switchtime);
  416         td->td_generation++;    /* bump preempt-detect counter */
  417         PCPU_INC(cnt.v_swtch);
  418         PCPU_SET(switchticks, ticks);
  419         CTR4(KTR_PROC, "mi_switch: old thread %ld (kse %p, pid %ld, %s)",
  420             td->td_tid, td->td_sched, p->p_pid, p->p_comm);
  421 #if (KTR_COMPILE & KTR_SCHED) != 0
  422         if (TD_IS_IDLETHREAD(td))
  423                 CTR3(KTR_SCHED, "mi_switch: %p(%s) prio %d idle",
  424                     td, td->td_proc->p_comm, td->td_priority);
  425         else if (newtd != NULL)
  426                 CTR5(KTR_SCHED,
  427                     "mi_switch: %p(%s) prio %d preempted by %p(%s)",
  428                     td, td->td_proc->p_comm, td->td_priority, newtd,
  429                     newtd->td_proc->p_comm);
  430         else
  431                 CTR6(KTR_SCHED,
  432                     "mi_switch: %p(%s) prio %d inhibit %d wmesg %s lock %s",
  433                     td, td->td_proc->p_comm, td->td_priority,
  434                     td->td_inhibitors, td->td_wmesg, td->td_lockname);
  435 #endif
  436         /*
  437          * We call thread_switchout after the KTR_SCHED prints above so kse
  438          * selecting a new thread to run does not show up as a preemption.
  439          */
  440 #ifdef KSE
  441         if ((flags & SW_VOL) && (td->td_proc->p_flag & P_SA))
  442                 newtd = thread_switchout(td, flags, newtd);
  443 #endif
  444         sched_switch(td, newtd, flags);
  445         CTR3(KTR_SCHED, "mi_switch: running %p(%s) prio %d",
  446             td, td->td_proc->p_comm, td->td_priority);
  447 
  448         CTR4(KTR_PROC, "mi_switch: new thread %ld (kse %p, pid %ld, %s)",
  449             td->td_tid, td->td_sched, p->p_pid, p->p_comm);
  450 
  451         /* 
  452          * If the last thread was exiting, finish cleaning it up.
  453          */
  454         if ((td = PCPU_GET(deadthread))) {
  455                 PCPU_SET(deadthread, NULL);
  456                 thread_stash(td);
  457         }
  458 }
  459 
  460 /*
  461  * Change thread state to be runnable, placing it on the run queue if
  462  * it is in memory.  If it is swapped out, return true so our caller
  463  * will know to awaken the swapper.
  464  */
  465 int
  466 setrunnable(struct thread *td)
  467 {
  468 
  469         THREAD_LOCK_ASSERT(td, MA_OWNED);
  470         KASSERT(td->td_proc->p_state != PRS_ZOMBIE,
  471             ("setrunnable: pid %d is a zombie", td->td_proc->p_pid));
  472         switch (td->td_state) {
  473         case TDS_RUNNING:
  474         case TDS_RUNQ:
  475                 return (0);
  476         case TDS_INHIBITED:
  477                 /*
  478                  * If we are only inhibited because we are swapped out
  479                  * then arange to swap in this process. Otherwise just return.
  480                  */
  481                 if (td->td_inhibitors != TDI_SWAPPED)
  482                         return (0);
  483                 /* FALLTHROUGH */
  484         case TDS_CAN_RUN:
  485                 break;
  486         default:
  487                 printf("state is 0x%x", td->td_state);
  488                 panic("setrunnable(2)");
  489         }
  490         if ((td->td_flags & TDF_INMEM) == 0) {
  491                 if ((td->td_flags & TDF_SWAPINREQ) == 0) {
  492                         td->td_flags |= TDF_SWAPINREQ;
  493                         return (1);
  494                 }
  495         } else
  496                 sched_wakeup(td);
  497         return (0);
  498 }
  499 
  500 /*
  501  * Compute a tenex style load average of a quantity on
  502  * 1, 5 and 15 minute intervals.
  503  * XXXKSE   Needs complete rewrite when correct info is available.
  504  * Completely Bogus.. only works with 1:1 (but compiles ok now :-)
  505  */
  506 static void
  507 loadav(void *arg)
  508 {
  509         int i, nrun;
  510         struct loadavg *avg;
  511 
  512         nrun = sched_load();
  513         avg = &averunnable;
  514 
  515         for (i = 0; i < 3; i++)
  516                 avg->ldavg[i] = (cexp[i] * avg->ldavg[i] +
  517                     nrun * FSCALE * (FSCALE - cexp[i])) >> FSHIFT;
  518 
  519         /*
  520          * Schedule the next update to occur after 5 seconds, but add a
  521          * random variation to avoid synchronisation with processes that
  522          * run at regular intervals.
  523          */
  524         callout_reset(&loadav_callout, hz * 4 + (int)(random() % (hz * 2 + 1)),
  525             loadav, NULL);
  526 }
  527 
  528 static void
  529 lboltcb(void *arg)
  530 {
  531         wakeup(&lbolt);
  532         callout_reset(&lbolt_callout, hz, lboltcb, NULL);
  533 }
  534 
  535 /* ARGSUSED */
  536 static void
  537 synch_setup(void *dummy)
  538 {
  539         callout_init(&loadav_callout, CALLOUT_MPSAFE);
  540         callout_init(&lbolt_callout, CALLOUT_MPSAFE);
  541 
  542         /* Kick off timeout driven events by calling first time. */
  543         loadav(NULL);
  544         lboltcb(NULL);
  545 }
  546 
  547 /*
  548  * General purpose yield system call.
  549  */
  550 int
  551 yield(struct thread *td, struct yield_args *uap)
  552 {
  553 
  554         thread_lock(td);
  555         sched_prio(td, PRI_MAX_TIMESHARE);
  556         mi_switch(SW_VOL, NULL);
  557         thread_unlock(td);
  558         td->td_retval[0] = 0;
  559         return (0);
  560 }

Cache object: bd7beb532e0d7adcc2a8c48e15a1834a


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.