[ 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  -  FREEBSD10  -  FREEBSD9  -  FREEBSD92  -  FREEBSD91  -  FREEBSD90  -  FREEBSD8  -  FREEBSD82  -  FREEBSD81  -  FREEBSD80  -  FREEBSD7  -  FREEBSD74  -  FREEBSD73  -  FREEBSD72  -  FREEBSD71  -  FREEBSD70  -  FREEBSD6  -  FREEBSD64  -  FREEBSD63  -  FREEBSD62  -  FREEBSD61  -  FREEBSD60  -  FREEBSD5  -  FREEBSD55  -  FREEBSD54  -  FREEBSD53  -  FREEBSD52  -  FREEBSD51  -  FREEBSD50  -  FREEBSD4  -  FREEBSD3  -  FREEBSD22  -  cheribsd  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1  -  FREEBSD-LIBC  -  FREEBSD8-LIBC  -  FREEBSD7-LIBC  -  FREEBSD6-LIBC  -  GLIBC27 
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$");
   29 
   30 #include <sys/param.h>
   31 #include <sys/lock.h>
   32 #include <sys/mutex.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                 hintp = NULL;
   65 
   66                 switch (hintmode) {
   67                 case 0:         /* loader hints in environment only */
   68                         break;
   69                 case 1:         /* static hints only */
   70                         hintp = static_hints;
   71                         checkmethod = 0;
   72                         break;
   73                 case 2:         /* fallback mode */
   74                         if (dynamic_kenv) {
   75                                 mtx_lock(&kenv_lock);
   76                                 cp = kenvp[0];
   77                                 for (i = 0; cp != NULL; cp = kenvp[++i]) {
   78                                         if (!strncmp(cp, "hint.", 5)) {
   79                                                 use_kenv = 1;
   80                                                 checkmethod = 0;
   81                                                 break;
   82                                         }
   83                                 }
   84                                 mtx_unlock(&kenv_lock);
   85                         } else {
   86                                 cp = kern_envp;
   87                                 while (cp) {
   88                                         if (strncmp(cp, "hint.", 5) == 0) {
   89                                                 cp = NULL;
   90                                                 hintp = kern_envp;
   91                                                 break;
   92                                         }
   93                                         while (*cp != '\0')
   94                                                 cp++;
   95                                         cp++;
   96                                         if (*cp == '\0') {
   97                                                 cp = NULL;
   98                                                 hintp = static_hints;
   99                                                 break;
  100                                         }
  101                                 }
  102                         }
  103                         break;
  104                 default:
  105                         break;
  106                 }
  107                 if (hintp == NULL) {
  108                         if (dynamic_kenv) {
  109                                 use_kenv = 1;
  110                                 checkmethod = 0;
  111                         } else
  112                                 hintp = kern_envp;
  113                 }
  114         }
  115 
  116         if (use_kenv) {
  117                 mtx_lock(&kenv_lock);
  118                 i = 0;
  119                 cp = kenvp[0];
  120                 if (cp == NULL) {
  121                         mtx_unlock(&kenv_lock);
  122                         return (ENOENT);
  123                 }
  124         } else
  125                 cp = hintp;
  126         while (cp) {
  127                 hit = 1;
  128                 (*line)++;
  129                 if (strncmp(cp, "hint.", 5) != 0)
  130                         hit = 0;
  131                 else
  132                         n = sscanf(cp, "hint.%32[^.].%d.%32[^=]=%128s",
  133                             r_name, &r_unit, r_resname, r_value);
  134                 if (hit && n != 4) {
  135                         printf("CONFIG: invalid hint '%s'\n", cp);
  136                         /* XXX: abuse bogus index() declaration */
  137                         p = index(cp, 'h');
  138                         *p = 'H';
  139                         hit = 0;
  140                 }
  141                 if (hit && startln && *startln >= 0 && *line < *startln)
  142                         hit = 0;
  143                 if (hit && name && strcmp(name, r_name) != 0)
  144                         hit = 0;
  145                 if (hit && unit && *unit != r_unit)
  146                         hit = 0;
  147                 if (hit && resname && strcmp(resname, r_resname) != 0)
  148                         hit = 0;
  149                 if (hit && value && strcmp(value, r_value) != 0)
  150                         hit = 0;
  151                 if (hit)
  152                         break;
  153                 if (use_kenv) {
  154                         cp = kenvp[++i];
  155                         if (cp == NULL)
  156                                 break;
  157                 } else {
  158                         while (*cp != '\0')
  159                                 cp++;
  160                         cp++;
  161                         if (*cp == '\0') {
  162                                 cp = NULL;
  163                                 break;
  164                         }
  165                 }
  166         }
  167         if (use_kenv)
  168                 mtx_unlock(&kenv_lock);
  169         if (cp == NULL)
  170                 return ENOENT;
  171 
  172         s = cp;
  173         /* This is a bit of a hack, but at least is reentrant */
  174         /* Note that it returns some !unterminated! strings. */
  175         s = index(s, '.') + 1;          /* start of device */
  176         if (ret_name)
  177                 *ret_name = s;
  178         s = index(s, '.') + 1;          /* start of unit */
  179         if (ret_namelen && ret_name)
  180                 *ret_namelen = s - *ret_name - 1; /* device length */
  181         if (ret_unit)
  182                 *ret_unit = r_unit;
  183         s = index(s, '.') + 1;          /* start of resname */
  184         if (ret_resname)
  185                 *ret_resname = s;
  186         s = index(s, '=') + 1;          /* start of value */
  187         if (ret_resnamelen && ret_resname)
  188                 *ret_resnamelen = s - *ret_resname - 1; /* value len */
  189         if (ret_value)
  190                 *ret_value = s;
  191         if (startln)                    /* line number for anchor */
  192                 *startln = *line + 1;
  193         return 0;
  194 }
  195 
  196 /*
  197  * Search all the data sources for matches to our query.  We look for
  198  * dynamic hints first as overrides for static or fallback hints.
  199  */
  200 static int
  201 resource_find(int *line, int *startln,
  202     const char *name, int *unit, const char *resname, const char *value,
  203     const char **ret_name, int *ret_namelen, int *ret_unit,
  204     const char **ret_resname, int *ret_resnamelen, const char **ret_value)
  205 {
  206         int i;
  207         int un;
  208 
  209         *line = 0;
  210 
  211         /* Search for exact unit matches first */
  212         i = res_find(line, startln, name, unit, resname, value,
  213             ret_name, ret_namelen, ret_unit, ret_resname, ret_resnamelen,
  214             ret_value);
  215         if (i == 0)
  216                 return 0;
  217         if (unit == NULL)
  218                 return ENOENT;
  219         /* If we are still here, search for wildcard matches */
  220         un = -1;
  221         i = res_find(line, startln, name, &un, resname, value,
  222             ret_name, ret_namelen, ret_unit, ret_resname, ret_resnamelen,
  223             ret_value);
  224         if (i == 0)
  225                 return 0;
  226         return ENOENT;
  227 }
  228 
  229 int
  230 resource_int_value(const char *name, int unit, const char *resname, int *result)
  231 {
  232         int error;
  233         const char *str;
  234         char *op;
  235         unsigned long val;
  236         int line;
  237 
  238         line = 0;
  239         error = resource_find(&line, NULL, name, &unit, resname, NULL,
  240             NULL, NULL, NULL, NULL, NULL, &str);
  241         if (error)
  242                 return error;
  243         if (*str == '\0') 
  244                 return EFTYPE;
  245         val = strtoul(str, &op, 0);
  246         if (*op != '\0') 
  247                 return EFTYPE;
  248         *result = val;
  249         return 0;
  250 }
  251 
  252 int
  253 resource_long_value(const char *name, int unit, const char *resname,
  254     long *result)
  255 {
  256         int error;
  257         const char *str;
  258         char *op;
  259         unsigned long val;
  260         int line;
  261 
  262         line = 0;
  263         error = resource_find(&line, NULL, name, &unit, resname, NULL,
  264             NULL, NULL, NULL, NULL, NULL, &str);
  265         if (error)
  266                 return error;
  267         if (*str == '\0') 
  268                 return EFTYPE;
  269         val = strtoul(str, &op, 0);
  270         if (*op != '\0') 
  271                 return EFTYPE;
  272         *result = val;
  273         return 0;
  274 }
  275 
  276 int
  277 resource_string_value(const char *name, int unit, const char *resname,
  278     const char **result)
  279 {
  280         int error;
  281         const char *str;
  282         int line;
  283 
  284         line = 0;
  285         error = resource_find(&line, NULL, name, &unit, resname, NULL,
  286             NULL, NULL, NULL, NULL, NULL, &str);
  287         if (error)
  288                 return error;
  289         *result = str;
  290         return 0;
  291 }
  292 
  293 /*
  294  * This is a bit nasty, but allows us to not modify the env strings.
  295  */
  296 static const char *
  297 resource_string_copy(const char *s, int len)
  298 {
  299         static char stringbuf[256];
  300         static int offset = 0;
  301         const char *ret;
  302 
  303         if (len == 0)
  304                 len = strlen(s);
  305         if (len > 255)
  306                 return NULL;
  307         if ((offset + len + 1) > 255)
  308                 offset = 0;
  309         bcopy(s, &stringbuf[offset], len);
  310         stringbuf[offset + len] = '\0';
  311         ret = &stringbuf[offset];
  312         offset += len + 1;
  313         return ret;
  314 }
  315 
  316 /*
  317  * err = resource_find_match(&anchor, &name, &unit, resname, value)
  318  * Iteratively fetch a list of devices wired "at" something
  319  * res and value are restrictions.  eg: "at", "scbus0".
  320  * For practical purposes, res = required, value = optional.
  321  * *name and *unit are set.
  322  * set *anchor to zero before starting.
  323  */
  324 int
  325 resource_find_match(int *anchor, const char **name, int *unit,
  326     const char *resname, const char *value)
  327 {
  328         const char *found_name;
  329         int found_namelen;
  330         int found_unit;
  331         int ret;
  332         int newln;
  333 
  334         newln = *anchor;
  335         ret = resource_find(anchor, &newln, NULL, NULL, resname, value,
  336             &found_name, &found_namelen, &found_unit, NULL, NULL, NULL);
  337         if (ret == 0) {
  338                 *name = resource_string_copy(found_name, found_namelen);
  339                 *unit = found_unit;
  340         }
  341         *anchor = newln;
  342         return ret;
  343 }
  344 
  345 
  346 /*
  347  * err = resource_find_dev(&anchor, name, &unit, res, value);
  348  * Iterate through a list of devices, returning their unit numbers.
  349  * res and value are optional restrictions.  eg: "at", "scbus0".
  350  * *unit is set to the value.
  351  * set *anchor to zero before starting.
  352  */
  353 int
  354 resource_find_dev(int *anchor, const char *name, int *unit,
  355     const char *resname, const char *value)
  356 {
  357         int found_unit;
  358         int newln;
  359         int ret;
  360 
  361         newln = *anchor;
  362         ret = resource_find(anchor, &newln, name, NULL, resname, value,
  363             NULL, NULL, &found_unit, NULL, NULL, NULL);
  364         if (ret == 0) {
  365                 *unit = found_unit;
  366         }
  367         *anchor = newln;
  368         return ret;
  369 }
  370 
  371 /*
  372  * Check to see if a device is disabled via a disabled hint.
  373  */
  374 int
  375 resource_disabled(const char *name, int unit)
  376 {
  377         int error, value;
  378 
  379         error = resource_int_value(name, unit, "disabled", &value);
  380         if (error)
  381                return (0);
  382         return (value);
  383 }

Cache object: 4fce8a16f4ff99bc2eb366e7c2640418


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