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/subr_hints.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) 2000,2001 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 
   27 #include <sys/cdefs.h>
   28 __FBSDID("$FreeBSD: releng/5.4/sys/kern/subr_hints.c 145335 2005-04-20 19:11:07Z cvs2svn $");
   29 
   30 #include <sys/param.h>
   31 #include <sys/lock.h>
   32 #include <sys/sx.h>
   33 #include <sys/systm.h>
   34 #include <sys/bus.h>
   35 
   36 /*
   37  * Access functions for device resources.
   38  */
   39 
   40 static int checkmethod = 1;
   41 static int use_kenv;
   42 static char *hintp;
   43 
   44 /*
   45  * Evil wildcarding resource string lookup.
   46  * This walks the supplied env string table and returns a match.
   47  * The start point can be remembered for incremental searches.
   48  */
   49 static int
   50 res_find(int *line, int *startln,
   51     const char *name, int *unit, const char *resname, const char *value,
   52     const char **ret_name, int *ret_namelen, int *ret_unit,
   53     const char **ret_resname, int *ret_resnamelen, const char **ret_value)
   54 {
   55         int n = 0, hit, i = 0;
   56         char r_name[32];
   57         int r_unit;
   58         char r_resname[32];
   59         char r_value[128];
   60         const char *s, *cp;
   61         char *p;
   62 
   63         if (checkmethod) {
   64                 switch (hintmode) {
   65                 case 0:         /* loader hints in environment only */
   66                         break;
   67                 case 1:         /* static hints only */
   68                         hintp = static_hints;
   69                         checkmethod = 0;
   70                         break;
   71                 case 2:         /* fallback mode */
   72                         if (dynamic_kenv) {
   73                                 sx_slock(&kenv_lock);
   74                                 cp = kenvp[0];
   75                                 for (i = 0; cp != NULL; cp = kenvp[++i]) {
   76                                         if (!strncmp(cp, "hint.", 5)) {
   77                                                 use_kenv = 1;
   78                                                 checkmethod = 0;
   79                                                 break;
   80                                         }
   81                                 }
   82                                 sx_sunlock(&kenv_lock);
   83                         } else {
   84                                 cp = kern_envp;
   85                                 while (cp) {
   86                                         if (strncmp(cp, "hint.", 5) == 0) {
   87                                                 cp = NULL;
   88                                                 hintp = kern_envp;
   89                                                 break;
   90                                         }
   91                                         while (*cp != '\0')
   92                                                 cp++;
   93                                         cp++;
   94                                         if (*cp == '\0') {
   95                                                 cp = NULL;
   96                                                 hintp = static_hints;
   97                                                 break;
   98                                         }
   99                                 }
  100                         }
  101                         break;
  102                 default:
  103                         break;
  104                 }
  105                 if (hintp == NULL) {
  106                         if (dynamic_kenv) {
  107                                 use_kenv = 1;
  108                                 checkmethod = 0;
  109                         } else
  110                                 hintp = kern_envp;
  111                 }
  112         }
  113 
  114         if (use_kenv) {
  115                 sx_slock(&kenv_lock);
  116                 i = 0;
  117                 cp = kenvp[0];
  118                 if (cp == NULL) {
  119                         sx_sunlock(&kenv_lock);
  120                         return (ENOENT);
  121                 }
  122         } else
  123                 cp = hintp;
  124         while (cp) {
  125                 hit = 1;
  126                 (*line)++;
  127                 if (strncmp(cp, "hint.", 5) != 0)
  128                         hit = 0;
  129                 else
  130                         n = sscanf(cp, "hint.%32[^.].%d.%32[^=]=%128s",
  131                             r_name, &r_unit, r_resname, r_value);
  132                 if (hit && n != 4) {
  133                         printf("CONFIG: invalid hint '%s'\n", cp);
  134                         /* XXX: abuse bogus index() declaration */
  135                         p = index(cp, 'h');
  136                         *p = 'H';
  137                         hit = 0;
  138                 }
  139                 if (hit && startln && *startln >= 0 && *line < *startln)
  140                         hit = 0;
  141                 if (hit && name && strcmp(name, r_name) != 0)
  142                         hit = 0;
  143                 if (hit && unit && *unit != r_unit)
  144                         hit = 0;
  145                 if (hit && resname && strcmp(resname, r_resname) != 0)
  146                         hit = 0;
  147                 if (hit && value && strcmp(value, r_value) != 0)
  148                         hit = 0;
  149                 if (hit)
  150                         break;
  151                 if (use_kenv) {
  152                         cp = kenvp[++i];
  153                         if (cp == NULL)
  154                                 break;
  155                 } else {
  156                         while (*cp != '\0')
  157                                 cp++;
  158                         cp++;
  159                         if (*cp == '\0') {
  160                                 cp = NULL;
  161                                 break;
  162                         }
  163                 }
  164         }
  165         if (use_kenv)
  166                 sx_sunlock(&kenv_lock);
  167         if (cp == NULL)
  168                 return ENOENT;
  169 
  170         s = cp;
  171         /* This is a bit of a hack, but at least is reentrant */
  172         /* Note that it returns some !unterminated! strings. */
  173         s = index(s, '.') + 1;          /* start of device */
  174         if (ret_name)
  175                 *ret_name = s;
  176         s = index(s, '.') + 1;          /* start of unit */
  177         if (ret_namelen)
  178                 *ret_namelen = s - *ret_name - 1; /* device length */
  179         if (ret_unit)
  180                 *ret_unit = r_unit;
  181         s = index(s, '.') + 1;          /* start of resname */
  182         if (ret_resname)
  183                 *ret_resname = s;
  184         s = index(s, '=') + 1;          /* start of value */
  185         if (ret_resnamelen)
  186                 *ret_resnamelen = s - *ret_resname - 1; /* value len */
  187         if (ret_value)
  188                 *ret_value = s;
  189         if (startln)                    /* line number for anchor */
  190                 *startln = *line + 1;
  191         return 0;
  192 }
  193 
  194 /*
  195  * Search all the data sources for matches to our query.  We look for
  196  * dynamic hints first as overrides for static or fallback hints.
  197  */
  198 static int
  199 resource_find(int *line, int *startln,
  200     const char *name, int *unit, const char *resname, const char *value,
  201     const char **ret_name, int *ret_namelen, int *ret_unit,
  202     const char **ret_resname, int *ret_resnamelen, const char **ret_value)
  203 {
  204         int i;
  205         int un;
  206 
  207         *line = 0;
  208 
  209         /* Search for exact unit matches first */
  210         i = res_find(line, startln, name, unit, resname, value,
  211             ret_name, ret_namelen, ret_unit, ret_resname, ret_resnamelen,
  212             ret_value);
  213         if (i == 0)
  214                 return 0;
  215         if (unit == NULL)
  216                 return ENOENT;
  217         /* If we are still here, search for wildcard matches */
  218         un = -1;
  219         i = res_find(line, startln, name, &un, resname, value,
  220             ret_name, ret_namelen, ret_unit, ret_resname, ret_resnamelen,
  221             ret_value);
  222         if (i == 0)
  223                 return 0;
  224         return ENOENT;
  225 }
  226 
  227 int
  228 resource_int_value(const char *name, int unit, const char *resname, int *result)
  229 {
  230         int error;
  231         const char *str;
  232         char *op;
  233         unsigned long val;
  234         int line;
  235 
  236         line = 0;
  237         error = resource_find(&line, NULL, name, &unit, resname, NULL,
  238             NULL, NULL, NULL, NULL, NULL, &str);
  239         if (error)
  240                 return error;
  241         if (*str == '\0') 
  242                 return EFTYPE;
  243         val = strtoul(str, &op, 0);
  244         if (*op != '\0') 
  245                 return EFTYPE;
  246         *result = val;
  247         return 0;
  248 }
  249 
  250 int
  251 resource_long_value(const char *name, int unit, const char *resname,
  252     long *result)
  253 {
  254         int error;
  255         const char *str;
  256         char *op;
  257         unsigned long val;
  258         int line;
  259 
  260         line = 0;
  261         error = resource_find(&line, NULL, name, &unit, resname, NULL,
  262             NULL, NULL, NULL, NULL, NULL, &str);
  263         if (error)
  264                 return error;
  265         if (*str == '\0') 
  266                 return EFTYPE;
  267         val = strtoul(str, &op, 0);
  268         if (*op != '\0') 
  269                 return EFTYPE;
  270         *result = val;
  271         return 0;
  272 }
  273 
  274 int
  275 resource_string_value(const char *name, int unit, const char *resname,
  276     const char **result)
  277 {
  278         int error;
  279         const char *str;
  280         int line;
  281 
  282         line = 0;
  283         error = resource_find(&line, NULL, name, &unit, resname, NULL,
  284             NULL, NULL, NULL, NULL, NULL, &str);
  285         if (error)
  286                 return error;
  287         *result = str;
  288         return 0;
  289 }
  290 
  291 /*
  292  * This is a bit nasty, but allows us to not modify the env strings.
  293  */
  294 static const char *
  295 resource_string_copy(const char *s, int len)
  296 {
  297         static char stringbuf[256];
  298         static int offset = 0;
  299         const char *ret;
  300 
  301         if (len == 0)
  302                 len = strlen(s);
  303         if (len > 255)
  304                 return NULL;
  305         if ((offset + len + 1) > 255)
  306                 offset = 0;
  307         bcopy(s, &stringbuf[offset], len);
  308         stringbuf[offset + len] = '\0';
  309         ret = &stringbuf[offset];
  310         offset += len + 1;
  311         return ret;
  312 }
  313 
  314 /*
  315  * err = resource_find_match(&anchor, &name, &unit, resname, value)
  316  * Iteratively fetch a list of devices wired "at" something
  317  * res and value are restrictions.  eg: "at", "scbus0".
  318  * For practical purposes, res = required, value = optional.
  319  * *name and *unit are set.
  320  * set *anchor to zero before starting.
  321  */
  322 int
  323 resource_find_match(int *anchor, const char **name, int *unit,
  324     const char *resname, const char *value)
  325 {
  326         const char *found_name;
  327         int found_namelen;
  328         int found_unit;
  329         int ret;
  330         int newln;
  331 
  332         newln = *anchor;
  333         ret = resource_find(anchor, &newln, NULL, NULL, resname, value,
  334             &found_name, &found_namelen, &found_unit, NULL, NULL, NULL);
  335         if (ret == 0) {
  336                 *name = resource_string_copy(found_name, found_namelen);
  337                 *unit = found_unit;
  338         }
  339         *anchor = newln;
  340         return ret;
  341 }
  342 
  343 
  344 /*
  345  * err = resource_find_dev(&anchor, name, &unit, res, value);
  346  * Iterate through a list of devices, returning their unit numbers.
  347  * res and value are optional restrictions.  eg: "at", "scbus0".
  348  * *unit is set to the value.
  349  * set *anchor to zero before starting.
  350  */
  351 int
  352 resource_find_dev(int *anchor, const char *name, int *unit,
  353     const char *resname, const char *value)
  354 {
  355         int found_unit;
  356         int newln;
  357         int ret;
  358 
  359         newln = *anchor;
  360         ret = resource_find(anchor, &newln, name, NULL, resname, value,
  361             NULL, NULL, &found_unit, NULL, NULL, NULL);
  362         if (ret == 0) {
  363                 *unit = found_unit;
  364         }
  365         *anchor = newln;
  366         return ret;
  367 }
  368 
  369 /*
  370  * Check to see if a device is disabled via a disabled hint.
  371  */
  372 int
  373 resource_disabled(const char *name, int unit)
  374 {
  375         int error, value;
  376 
  377         error = resource_int_value(name, unit, "disabled", &value);
  378         if (error)
  379                return (0);
  380         return (value);
  381 }

Cache object: 88f63e24dd584a6eef69faf32aa3f1a2


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