subr_autoconf.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  * SPDX-License-Identifier: BSD-3-Clause
    3  *
    4  * Copyright (c) 1992, 1993
    5  *      The Regents of the University of California.  All rights reserved.
    6  *
    7  * This software was developed by the Computer Systems Engineering group
    8  * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
    9  * contributed to Berkeley.
   10  *
   11  * Redistribution and use in source and binary forms, with or without
   12  * modification, are permitted provided that the following conditions
   13  * are met:
   14  * 1. Redistributions of source code must retain the above copyright
   15  *    notice, this list of conditions and the following disclaimer.
   16  * 2. Redistributions in binary form must reproduce the above copyright
   17  *    notice, this list of conditions and the following disclaimer in the
   18  *    documentation and/or other materials provided with the distribution.
   19  * 3. Neither the name of the University nor the names of its contributors
   20  *    may be used to endorse or promote products derived from this software
   21  *    without specific prior written permission.
   22  *
   23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   33  * SUCH DAMAGE.
   34  *
   35  *      @(#)subr_autoconf.c     8.1 (Berkeley) 6/10/93
   36  *
   37  */
   38 
   39 #include <sys/cdefs.h>
   40 __FBSDID("$FreeBSD$");
   41 
   42 #include "opt_ddb.h"
   43 
   44 #include <sys/param.h>
   45 #include <sys/kernel.h>
   46 #include <sys/linker.h>
   47 #include <sys/lock.h>
   48 #include <sys/malloc.h>
   49 #include <sys/mutex.h>
   50 #include <sys/systm.h>
   51 
   52 /*
   53  * Autoconfiguration subroutines.
   54  */
   55 
   56 /*
   57  * "Interrupt driven config" functions.
   58  */
   59 static TAILQ_HEAD(, intr_config_hook) intr_config_hook_list =
   60         TAILQ_HEAD_INITIALIZER(intr_config_hook_list);
   61 static struct intr_config_hook *next_to_notify;
   62 static struct mtx intr_config_hook_lock;
   63 MTX_SYSINIT(intr_config_hook, &intr_config_hook_lock, "intr config", MTX_DEF);
   64 
   65 /* ARGSUSED */
   66 static void run_interrupt_driven_config_hooks(void);
   67 
   68 /*
   69  * Private data and a shim function for implementing config_interhook_oneshot().
   70  */
   71 struct oneshot_config_hook {
   72         struct intr_config_hook 
   73                         och_hook;               /* Must be first */
   74         ich_func_t      och_func;
   75         void            *och_arg;
   76 };
   77 
   78 static void
   79 config_intrhook_oneshot_func(void *arg)
   80 {
   81         struct oneshot_config_hook *ohook;
   82 
   83         ohook = arg;
   84         ohook->och_func(ohook->och_arg);
   85         config_intrhook_disestablish(&ohook->och_hook);
   86         free(ohook, M_DEVBUF);
   87 }
   88 
   89 /*
   90  * If we wait too long for an interrupt-driven config hook to return, print
   91  * a diagnostic.
   92  */
   93 #define WARNING_INTERVAL_SECS   60
   94 static void
   95 run_interrupt_driven_config_hooks_warning(int warned)
   96 {
   97         struct intr_config_hook *hook_entry;
   98         char namebuf[64];
   99         long offset;
  100 
  101         if (warned < 6) {
  102                 printf("run_interrupt_driven_hooks: still waiting after %d "
  103                     "seconds for", warned * WARNING_INTERVAL_SECS);
  104                 TAILQ_FOREACH(hook_entry, &intr_config_hook_list, ich_links) {
  105                         if (linker_search_symbol_name(
  106                             (caddr_t)hook_entry->ich_func, namebuf,
  107                             sizeof(namebuf), &offset) == 0)
  108                                 printf(" %s", namebuf);
  109                         else
  110                                 printf(" %p", hook_entry->ich_func);
  111                 }
  112                 printf("\n");
  113         }
  114         KASSERT(warned < 6,
  115             ("run_interrupt_driven_config_hooks: waited too long"));
  116 }
  117 
  118 static void
  119 run_interrupt_driven_config_hooks()
  120 {
  121         static int running;
  122         struct intr_config_hook *hook_entry;
  123 
  124         mtx_lock(&intr_config_hook_lock);
  125 
  126         /*
  127          * If hook processing is already active, any newly
  128          * registered hooks will eventually be notified.
  129          * Let the currently running session issue these
  130          * notifications.
  131          */
  132         if (running != 0) {
  133                 mtx_unlock(&intr_config_hook_lock);
  134                 return;
  135         }
  136         running = 1;
  137 
  138         while (next_to_notify != NULL) {
  139                 hook_entry = next_to_notify;
  140                 next_to_notify = TAILQ_NEXT(hook_entry, ich_links);
  141                 mtx_unlock(&intr_config_hook_lock);
  142                 (*hook_entry->ich_func)(hook_entry->ich_arg);
  143                 mtx_lock(&intr_config_hook_lock);
  144         }
  145 
  146         running = 0;
  147         mtx_unlock(&intr_config_hook_lock);
  148 }
  149 
  150 static void
  151 boot_run_interrupt_driven_config_hooks(void *dummy)
  152 {
  153         int warned;
  154 
  155         run_interrupt_driven_config_hooks();
  156 
  157         /* Block boot processing until all hooks are disestablished. */
  158         TSWAIT("config hooks");
  159         mtx_lock(&intr_config_hook_lock);
  160         warned = 0;
  161         while (!TAILQ_EMPTY(&intr_config_hook_list)) {
  162                 if (msleep(&intr_config_hook_list, &intr_config_hook_lock,
  163                     0, "conifhk", WARNING_INTERVAL_SECS * hz) ==
  164                     EWOULDBLOCK) {
  165                         mtx_unlock(&intr_config_hook_lock);
  166                         warned++;
  167                         run_interrupt_driven_config_hooks_warning(warned);
  168                         mtx_lock(&intr_config_hook_lock);
  169                 }
  170         }
  171         mtx_unlock(&intr_config_hook_lock);
  172         TSUNWAIT("config hooks");
  173 }
  174 
  175 SYSINIT(intr_config_hooks, SI_SUB_INT_CONFIG_HOOKS, SI_ORDER_FIRST,
  176         boot_run_interrupt_driven_config_hooks, NULL);
  177 
  178 /*
  179  * Register a hook that will be called after "cold"
  180  * autoconfiguration is complete and interrupts can
  181  * be used to complete initialization.
  182  */
  183 int
  184 config_intrhook_establish(struct intr_config_hook *hook)
  185 {
  186         struct intr_config_hook *hook_entry;
  187 
  188         TSHOLD("config hooks");
  189         mtx_lock(&intr_config_hook_lock);
  190         TAILQ_FOREACH(hook_entry, &intr_config_hook_list, ich_links)
  191                 if (hook_entry == hook)
  192                         break;
  193         if (hook_entry != NULL) {
  194                 mtx_unlock(&intr_config_hook_lock);
  195                 printf("config_intrhook_establish: establishing an "
  196                        "already established hook.\n");
  197                 return (1);
  198         }
  199         TAILQ_INSERT_TAIL(&intr_config_hook_list, hook, ich_links);
  200         if (next_to_notify == NULL)
  201                 next_to_notify = hook;
  202         mtx_unlock(&intr_config_hook_lock);
  203         if (cold == 0)
  204                 /*
  205                  * XXX Call from a task since not all drivers expect
  206                  *     to be re-entered at the time a hook is established.
  207                  */
  208                 /* XXX Sufficient for modules loaded after initial config??? */
  209                 run_interrupt_driven_config_hooks();    
  210         return (0);
  211 }
  212 
  213 /*
  214  * Register a hook function that is automatically unregistered after it runs.
  215  */
  216 void
  217 config_intrhook_oneshot(ich_func_t func, void *arg)
  218 {
  219         struct oneshot_config_hook *ohook;
  220 
  221         ohook = malloc(sizeof(*ohook), M_DEVBUF, M_WAITOK);
  222         ohook->och_func = func;
  223         ohook->och_arg  = arg;
  224         ohook->och_hook.ich_func = config_intrhook_oneshot_func;
  225         ohook->och_hook.ich_arg  = ohook;
  226         config_intrhook_establish(&ohook->och_hook);
  227 }
  228 
  229 void
  230 config_intrhook_disestablish(struct intr_config_hook *hook)
  231 {
  232         struct intr_config_hook *hook_entry;
  233 
  234         mtx_lock(&intr_config_hook_lock);
  235         TAILQ_FOREACH(hook_entry, &intr_config_hook_list, ich_links)
  236                 if (hook_entry == hook)
  237                         break;
  238         if (hook_entry == NULL)
  239                 panic("config_intrhook_disestablish: disestablishing an "
  240                       "unestablished hook");
  241 
  242         if (next_to_notify == hook)
  243                 next_to_notify = TAILQ_NEXT(hook, ich_links);
  244         TAILQ_REMOVE(&intr_config_hook_list, hook, ich_links);
  245         TSRELEASE("config hooks");
  246 
  247         /* Wakeup anyone watching the list */
  248         wakeup(&intr_config_hook_list);
  249         mtx_unlock(&intr_config_hook_lock);
  250 }
  251 
  252 #ifdef DDB
  253 #include <ddb/ddb.h>
  254 
  255 DB_SHOW_COMMAND(conifhk, db_show_conifhk)
  256 {
  257         struct intr_config_hook *hook_entry;
  258         char namebuf[64];
  259         long offset;
  260 
  261         TAILQ_FOREACH(hook_entry, &intr_config_hook_list, ich_links) {
  262                 if (linker_ddb_search_symbol_name(
  263                     (caddr_t)hook_entry->ich_func, namebuf, sizeof(namebuf),
  264                     &offset) == 0) {
  265                         db_printf("hook: %p at %s+%#lx arg: %p\n",
  266                             hook_entry->ich_func, namebuf, offset,
  267                             hook_entry->ich_arg);
  268                 } else {
  269                         db_printf("hook: %p at ??+?? arg %p\n",
  270                             hook_entry->ich_func, hook_entry->ich_arg);
  271                 }
  272         }
  273 }
  274 #endif /* DDB */

Cache object: f55e67038fb49a8b623ca815a0bfd41a

[ 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.

FreeBSD/Linux Kernel Cross Reference sys/kern/subr_autoconf.c

FreeBSD/Linux Kernel Cross Reference
sys/kern/subr_autoconf.c