sys/kern/subr_autoconf.c

   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()
 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(conifhk, db_show_conifhk)
 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 */