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 STAILQ_HEAD(, intr_config_hook) intr_config_hook_list =
   60         STAILQ_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                 STAILQ_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(void)
  120 {
  121         static int running;
  122         struct intr_config_hook *hook_entry;
  123 
  124         TSENTER();
  125         mtx_lock(&intr_config_hook_lock);
  126 
  127         /*
  128          * If hook processing is already active, any newly
  129          * registered hooks will eventually be notified.
  130          * Let the currently running session issue these
  131          * notifications.
  132          */
  133         if (running != 0) {
  134                 mtx_unlock(&intr_config_hook_lock);
  135                 return;
  136         }
  137         running = 1;
  138 
  139         while (next_to_notify != NULL) {
  140                 hook_entry = next_to_notify;
  141                 next_to_notify = STAILQ_NEXT(hook_entry, ich_links);
  142                 hook_entry->ich_state = ICHS_RUNNING;
  143                 mtx_unlock(&intr_config_hook_lock);
  144                 (*hook_entry->ich_func)(hook_entry->ich_arg);
  145                 mtx_lock(&intr_config_hook_lock);
  146         }
  147 
  148         running = 0;
  149         mtx_unlock(&intr_config_hook_lock);
  150         TSEXIT();
  151 }
  152 
  153 static void
  154 boot_run_interrupt_driven_config_hooks(void *dummy)
  155 {
  156         int warned;
  157 
  158         run_interrupt_driven_config_hooks();
  159 
  160         /* Block boot processing until all hooks are disestablished. */
  161         TSWAIT("config hooks");
  162         mtx_lock(&intr_config_hook_lock);
  163         warned = 0;
  164         while (!STAILQ_EMPTY(&intr_config_hook_list)) {
  165                 if (msleep(&intr_config_hook_list, &intr_config_hook_lock,
  166                     0, "conifhk", WARNING_INTERVAL_SECS * hz) ==
  167                     EWOULDBLOCK) {
  168                         mtx_unlock(&intr_config_hook_lock);
  169                         warned++;
  170                         run_interrupt_driven_config_hooks_warning(warned);
  171                         mtx_lock(&intr_config_hook_lock);
  172                 }
  173         }
  174         mtx_unlock(&intr_config_hook_lock);
  175         TSUNWAIT("config hooks");
  176 }
  177 
  178 SYSINIT(intr_config_hooks, SI_SUB_INT_CONFIG_HOOKS, SI_ORDER_FIRST,
  179         boot_run_interrupt_driven_config_hooks, NULL);
  180 
  181 /*
  182  * Register a hook that will be called after "cold"
  183  * autoconfiguration is complete and interrupts can
  184  * be used to complete initialization.
  185  */
  186 int
  187 config_intrhook_establish(struct intr_config_hook *hook)
  188 {
  189         struct intr_config_hook *hook_entry;
  190 
  191         TSHOLD("config hooks");
  192         mtx_lock(&intr_config_hook_lock);
  193         STAILQ_FOREACH(hook_entry, &intr_config_hook_list, ich_links)
  194                 if (hook_entry == hook)
  195                         break;
  196         if (hook_entry != NULL) {
  197                 mtx_unlock(&intr_config_hook_lock);
  198                 printf("config_intrhook_establish: establishing an "
  199                        "already established hook.\n");
  200                 return (1);
  201         }
  202         STAILQ_INSERT_TAIL(&intr_config_hook_list, hook, ich_links);
  203         if (next_to_notify == NULL)
  204                 next_to_notify = hook;
  205         hook->ich_state = ICHS_QUEUED;
  206         mtx_unlock(&intr_config_hook_lock);
  207         if (cold == 0)
  208                 /*
  209                  * XXX Call from a task since not all drivers expect
  210                  *     to be re-entered at the time a hook is established.
  211                  */
  212                 /* XXX Sufficient for modules loaded after initial config??? */
  213                 run_interrupt_driven_config_hooks();    
  214         return (0);
  215 }
  216 
  217 /*
  218  * Register a hook function that is automatically unregistered after it runs.
  219  */
  220 void
  221 config_intrhook_oneshot(ich_func_t func, void *arg)
  222 {
  223         struct oneshot_config_hook *ohook;
  224 
  225         ohook = malloc(sizeof(*ohook), M_DEVBUF, M_WAITOK);
  226         ohook->och_func = func;
  227         ohook->och_arg  = arg;
  228         ohook->och_hook.ich_func = config_intrhook_oneshot_func;
  229         ohook->och_hook.ich_arg  = ohook;
  230         config_intrhook_establish(&ohook->och_hook);
  231 }
  232 
  233 static void
  234 config_intrhook_disestablish_locked(struct intr_config_hook *hook)
  235 {
  236         struct intr_config_hook *hook_entry;
  237 
  238         STAILQ_FOREACH(hook_entry, &intr_config_hook_list, ich_links)
  239                 if (hook_entry == hook)
  240                         break;
  241         if (hook_entry == NULL)
  242                 panic("config_intrhook_disestablish: disestablishing an "
  243                       "unestablished hook");
  244 
  245         if (next_to_notify == hook)
  246                 next_to_notify = STAILQ_NEXT(hook, ich_links);
  247         STAILQ_REMOVE(&intr_config_hook_list, hook, intr_config_hook, ich_links);
  248         TSRELEASE("config hooks");
  249 
  250         /* Wakeup anyone watching the list */
  251         hook->ich_state = ICHS_DONE;
  252         wakeup(&intr_config_hook_list);
  253 }
  254 
  255 void
  256 config_intrhook_disestablish(struct intr_config_hook *hook)
  257 {
  258         mtx_lock(&intr_config_hook_lock);
  259         config_intrhook_disestablish_locked(hook);
  260         mtx_unlock(&intr_config_hook_lock);
  261 }
  262 
  263 int
  264 config_intrhook_drain(struct intr_config_hook *hook)
  265 {
  266         mtx_lock(&intr_config_hook_lock);
  267 
  268         /*
  269          * The config hook has completed, so just return.
  270          */
  271         if (hook->ich_state == ICHS_DONE) {
  272                 mtx_unlock(&intr_config_hook_lock);
  273                 return (ICHS_DONE);
  274         }
  275 
  276         /*
  277          * The config hook hasn't started running, just call disestablish.
  278          */
  279         if (hook->ich_state == ICHS_QUEUED) {
  280                 config_intrhook_disestablish_locked(hook);
  281                 mtx_unlock(&intr_config_hook_lock);
  282                 return (ICHS_QUEUED);
  283         }
  284 
  285         /*
  286          * The config hook is running, so wait for it to complete and return.
  287          */
  288         while (hook->ich_state != ICHS_DONE) {
  289                 if (msleep(&intr_config_hook_list, &intr_config_hook_lock,
  290                     0, "confhd", hz) == EWOULDBLOCK) {
  291                         // XXX do I whine?
  292                 }
  293         }
  294         mtx_unlock(&intr_config_hook_lock);
  295         return (ICHS_RUNNING);
  296 }
  297 
  298 #ifdef DDB
  299 #include <ddb/ddb.h>
  300 
  301 DB_SHOW_COMMAND_FLAGS(conifhk, db_show_conifhk, DB_CMD_MEMSAFE)
  302 {
  303         struct intr_config_hook *hook_entry;
  304         char namebuf[64];
  305         long offset;
  306 
  307         STAILQ_FOREACH(hook_entry, &intr_config_hook_list, ich_links) {
  308                 if (linker_ddb_search_symbol_name(
  309                     (caddr_t)hook_entry->ich_func, namebuf, sizeof(namebuf),
  310                     &offset) == 0) {
  311                         db_printf("hook: %p at %s+%#lx arg: %p\n",
  312                             hook_entry->ich_func, namebuf, offset,
  313                             hook_entry->ich_arg);
  314                 } else {
  315                         db_printf("hook: %p at ??+?? arg %p\n",
  316                             hook_entry->ich_func, hook_entry->ich_arg);
  317                 }
  318         }
  319 }
  320 #endif /* DDB */
Cache object: 10c151eb1c3a04119e671b25a32e5d60
[ 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
