sys/kern/subr_hints.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2000,2001 Peter Wemm <peter@FreeBSD.org>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <sys/param.h>
  33 #include <sys/lock.h>
  34 #include <sys/malloc.h>
  35 #include <sys/mutex.h>
  36 #include <sys/sysctl.h>
  37 #include <sys/systm.h>
  38 #include <sys/bus.h>
  39
  40 #define HINTMODE_KENV           0
  41 #define HINTMODE_STATIC         1
  42 #define HINTMODE_FALLBACK       2
  43
  44 /*
  45  * Access functions for device resources.
  46  */
  47
  48 static int checkmethod = 1;
  49 static char *hintp;
  50
  51 /*
  52  * Define kern.hintmode sysctl, which only accept value 2, that cause to
  53  * switch from Static KENV mode to Dynamic KENV. So systems that have hints
  54  * compiled into kernel will be able to see/modify KENV (and hints too).
  55  */
  56
  57 static int
  58 sysctl_hintmode(SYSCTL_HANDLER_ARGS)
  59 {
  60         const char *cp;
  61         char *line, *eq;
  62         int eqidx, error, i, value;
  63
  64         value = hintmode;
  65
  66         /* Fetch candidate for new hintmode value */
  67         error = sysctl_handle_int(oidp, &value, 0, req);
  68         if (error || req->newptr == NULL)
  69                 return (error);
  70
  71         if (value != HINTMODE_FALLBACK)
  72                 /* Only accept swithing to hintmode 2 */
  73                 return (EINVAL);
  74
  75         /*
  76          * The rest of the sysctl handler is just making sure that our
  77          * environment is consistent with the world we've already seen.
  78          * If we came from kenv at all, then we have nothing to do: static
  79          * kenv will get merged into dynamic kenv as soon as kmem becomes
  80          * available, dynamic kenv is the environment we'd be setting these
  81          * things in anyways. Therefore, we have nothing left to do unless
  82          * we came from a static hints configuration.
  83          */
  84         if (hintmode != HINTMODE_STATIC) {
  85                 hintmode = value;
  86                 return (0);
  87         }
  88
  89         cp = static_hints;
  90         while (cp && *cp != '\0') {
  91                 eq = strchr(cp, '=');
  92                 if (eq == NULL)
  93                         /* Bad hint value */
  94                         continue;
  95                 eqidx = eq - cp;
  96
  97                 i = strlen(cp);
  98                 line = malloc(i+1, M_TEMP, M_WAITOK);
  99                 strcpy(line, cp);
 100                 line[eqidx] = '\0';
 101                 kern_setenv(line, line + eqidx + 1);
 102                 free(line, M_TEMP);
 103                 cp += i + 1;
 104         }
 105
 106         hintmode = value;
 107         return (0);
 108 }
 109
 110 SYSCTL_PROC(_kern, OID_AUTO, hintmode, CTLTYPE_INT|CTLFLAG_RW,
 111     &hintmode, 0, sysctl_hintmode, "I", "Get/set current hintmode");
 112
 113 /*
 114  * Evil wildcarding resource string lookup.
 115  * This walks the supplied env string table and returns a match.
 116  * The start point can be remembered for incremental searches.
 117  */
 118 static int
 119 res_find(int *line, int *startln,
 120     const char *name, int *unit, const char *resname, const char *value,
 121     const char **ret_name, int *ret_namelen, int *ret_unit,
 122     const char **ret_resname, int *ret_resnamelen, const char **ret_value)
 123 {
 124         int n = 0, hit, i = 0;
 125         char r_name[32];
 126         int r_unit, use_kenv = (hintmode != HINTMODE_STATIC && dynamic_kenv);
 127         char r_resname[32];
 128         char r_value[128];
 129         const char *s, *cp;
 130         char *p;
 131
 132         if (checkmethod) {
 133                 hintp = NULL;
 134
 135                 switch (hintmode) {
 136                 case HINTMODE_KENV:     /* loader hints in environment only */
 137                         break;
 138                 case HINTMODE_STATIC:   /* static hints only */
 139                         hintp = static_hints;
 140                         checkmethod = 0;
 141                         break;
 142                 case HINTMODE_FALLBACK:         /* fallback mode */
 143                         if (dynamic_kenv) {
 144                                 mtx_lock(&kenv_lock);
 145                                 cp = kenvp[0];
 146                                 for (i = 0; cp != NULL; cp = kenvp[++i]) {
 147                                         if (!strncmp(cp, "hint.", 5)) {
 148                                                 use_kenv = 1;
 149                                                 checkmethod = 0;
 150                                                 break;
 151                                         }
 152                                 }
 153                                 mtx_unlock(&kenv_lock);
 154                         } else {
 155                                 cp = kern_envp;
 156                                 while (cp) {
 157                                         if (strncmp(cp, "hint.", 5) == 0) {
 158                                                 cp = NULL;
 159                                                 hintp = kern_envp;
 160                                                 break;
 161                                         }
 162                                         while (*cp != '\0')
 163                                                 cp++;
 164                                         cp++;
 165                                         if (*cp == '\0') {
 166                                                 cp = NULL;
 167                                                 hintp = static_hints;
 168                                                 break;
 169                                         }
 170                                 }
 171                         }
 172                         break;
 173                 default:
 174                         break;
 175                 }
 176                 if (hintp == NULL) {
 177                         if (dynamic_kenv) {
 178                                 use_kenv = 1;
 179                                 checkmethod = 0;
 180                         } else
 181                                 hintp = kern_envp;
 182                 }
 183         }
 184
 185         if (use_kenv) {
 186                 mtx_lock(&kenv_lock);
 187                 i = 0;
 188                 cp = kenvp[0];
 189                 if (cp == NULL) {
 190                         mtx_unlock(&kenv_lock);
 191                         return (ENOENT);
 192                 }
 193         } else
 194                 cp = hintp;
 195         while (cp) {
 196                 hit = 1;
 197                 (*line)++;
 198                 if (strncmp(cp, "hint.", 5) != 0)
 199                         hit = 0;
 200                 else
 201                         n = sscanf(cp, "hint.%32[^.].%d.%32[^=]=%127s",
 202                             r_name, &r_unit, r_resname, r_value);
 203                 if (hit && n != 4) {
 204                         printf("CONFIG: invalid hint '%s'\n", cp);
 205                         p = strchr(cp, 'h');
 206                         *p = 'H';
 207                         hit = 0;
 208                 }
 209                 if (hit && startln && *startln >= 0 && *line < *startln)
 210                         hit = 0;
 211                 if (hit && name && strcmp(name, r_name) != 0)
 212                         hit = 0;
 213                 if (hit && unit && *unit != r_unit)
 214                         hit = 0;
 215                 if (hit && resname && strcmp(resname, r_resname) != 0)
 216                         hit = 0;
 217                 if (hit && value && strcmp(value, r_value) != 0)
 218                         hit = 0;
 219                 if (hit)
 220                         break;
 221                 if (use_kenv) {
 222                         cp = kenvp[++i];
 223                         if (cp == NULL)
 224                                 break;
 225                 } else {
 226                         while (*cp != '\0')
 227                                 cp++;
 228                         cp++;
 229                         if (*cp == '\0') {
 230                                 cp = NULL;
 231                                 break;
 232                         }
 233                 }
 234         }
 235         if (use_kenv)
 236                 mtx_unlock(&kenv_lock);
 237         if (cp == NULL)
 238                 return ENOENT;
 239
 240         s = cp;
 241         /* This is a bit of a hack, but at least is reentrant */
 242         /* Note that it returns some !unterminated! strings. */
 243         s = strchr(s, '.') + 1;         /* start of device */
 244         if (ret_name)
 245                 *ret_name = s;
 246         s = strchr(s, '.') + 1;         /* start of unit */
 247         if (ret_namelen && ret_name)
 248                 *ret_namelen = s - *ret_name - 1; /* device length */
 249         if (ret_unit)
 250                 *ret_unit = r_unit;
 251         s = strchr(s, '.') + 1;         /* start of resname */
 252         if (ret_resname)
 253                 *ret_resname = s;
 254         s = strchr(s, '=') + 1;         /* start of value */
 255         if (ret_resnamelen && ret_resname)
 256                 *ret_resnamelen = s - *ret_resname - 1; /* value len */
 257         if (ret_value)
 258                 *ret_value = s;
 259         if (startln)                    /* line number for anchor */
 260                 *startln = *line + 1;
 261         return 0;
 262 }
 263
 264 /*
 265  * Search all the data sources for matches to our query.  We look for
 266  * dynamic hints first as overrides for static or fallback hints.
 267  */
 268 static int
 269 resource_find(int *line, int *startln,
 270     const char *name, int *unit, const char *resname, const char *value,
 271     const char **ret_name, int *ret_namelen, int *ret_unit,
 272     const char **ret_resname, int *ret_resnamelen, const char **ret_value)
 273 {
 274         int i;
 275         int un;
 276
 277         *line = 0;
 278
 279         /* Search for exact unit matches first */
 280         i = res_find(line, startln, name, unit, resname, value,
 281             ret_name, ret_namelen, ret_unit, ret_resname, ret_resnamelen,
 282             ret_value);
 283         if (i == 0)
 284                 return 0;
 285         if (unit == NULL)
 286                 return ENOENT;
 287         /* If we are still here, search for wildcard matches */
 288         un = -1;
 289         i = res_find(line, startln, name, &un, resname, value,
 290             ret_name, ret_namelen, ret_unit, ret_resname, ret_resnamelen,
 291             ret_value);
 292         if (i == 0)
 293                 return 0;
 294         return ENOENT;
 295 }
 296
 297 int
 298 resource_int_value(const char *name, int unit, const char *resname, int *result)
 299 {
 300         int error;
 301         const char *str;
 302         char *op;
 303         unsigned long val;
 304         int line;
 305
 306         line = 0;
 307         error = resource_find(&line, NULL, name, &unit, resname, NULL,
 308             NULL, NULL, NULL, NULL, NULL, &str);
 309         if (error)
 310                 return error;
 311         if (*str == '\0')
 312                 return EFTYPE;
 313         val = strtoul(str, &op, 0);
 314         if (*op != '\0')
 315                 return EFTYPE;
 316         *result = val;
 317         return 0;
 318 }
 319
 320 int
 321 resource_long_value(const char *name, int unit, const char *resname,
 322     long *result)
 323 {
 324         int error;
 325         const char *str;
 326         char *op;
 327         unsigned long val;
 328         int line;
 329
 330         line = 0;
 331         error = resource_find(&line, NULL, name, &unit, resname, NULL,
 332             NULL, NULL, NULL, NULL, NULL, &str);
 333         if (error)
 334                 return error;
 335         if (*str == '\0')
 336                 return EFTYPE;
 337         val = strtoul(str, &op, 0);
 338         if (*op != '\0')
 339                 return EFTYPE;
 340         *result = val;
 341         return 0;
 342 }
 343
 344 int
 345 resource_string_value(const char *name, int unit, const char *resname,
 346     const char **result)
 347 {
 348         int error;
 349         const char *str;
 350         int line;
 351
 352         line = 0;
 353         error = resource_find(&line, NULL, name, &unit, resname, NULL,
 354             NULL, NULL, NULL, NULL, NULL, &str);
 355         if (error)
 356                 return error;
 357         *result = str;
 358         return 0;
 359 }
 360
 361 /*
 362  * This is a bit nasty, but allows us to not modify the env strings.
 363  */
 364 static const char *
 365 resource_string_copy(const char *s, int len)
 366 {
 367         static char stringbuf[256];
 368         static int offset = 0;
 369         const char *ret;
 370
 371         if (len == 0)
 372                 len = strlen(s);
 373         if (len > 255)
 374                 return NULL;
 375         if ((offset + len + 1) > 255)
 376                 offset = 0;
 377         bcopy(s, &stringbuf[offset], len);
 378         stringbuf[offset + len] = '\0';
 379         ret = &stringbuf[offset];
 380         offset += len + 1;
 381         return ret;
 382 }
 383
 384 /*
 385  * err = resource_find_match(&anchor, &name, &unit, resname, value)
 386  * Iteratively fetch a list of devices wired "at" something
 387  * res and value are restrictions.  eg: "at", "scbus0".
 388  * For practical purposes, res = required, value = optional.
 389  * *name and *unit are set.
 390  * set *anchor to zero before starting.
 391  */
 392 int
 393 resource_find_match(int *anchor, const char **name, int *unit,
 394     const char *resname, const char *value)
 395 {
 396         const char *found_name;
 397         int found_namelen;
 398         int found_unit;
 399         int ret;
 400         int newln;
 401
 402         newln = *anchor;
 403         ret = resource_find(anchor, &newln, NULL, NULL, resname, value,
 404             &found_name, &found_namelen, &found_unit, NULL, NULL, NULL);
 405         if (ret == 0) {
 406                 *name = resource_string_copy(found_name, found_namelen);
 407                 *unit = found_unit;
 408         }
 409         *anchor = newln;
 410         return ret;
 411 }
 412
 413
 414 /*
 415  * err = resource_find_dev(&anchor, name, &unit, res, value);
 416  * Iterate through a list of devices, returning their unit numbers.
 417  * res and value are optional restrictions.  eg: "at", "scbus0".
 418  * *unit is set to the value.
 419  * set *anchor to zero before starting.
 420  */
 421 int
 422 resource_find_dev(int *anchor, const char *name, int *unit,
 423     const char *resname, const char *value)
 424 {
 425         int found_unit;
 426         int newln;
 427         int ret;
 428
 429         newln = *anchor;
 430         ret = resource_find(anchor, &newln, name, NULL, resname, value,
 431             NULL, NULL, &found_unit, NULL, NULL, NULL);
 432         if (ret == 0) {
 433                 *unit = found_unit;
 434         }
 435         *anchor = newln;
 436         return ret;
 437 }
 438
 439 /*
 440  * Check to see if a device is disabled via a disabled hint.
 441  */
 442 int
 443 resource_disabled(const char *name, int unit)
 444 {
 445         int error, value;
 446
 447         error = resource_int_value(name, unit, "disabled", &value);
 448         if (error)
 449                return (0);
 450         return (value);
 451 }
 452
 453 /*
 454  * Clear a value associated with a device by removing it from
 455  * the kernel environment.  This only removes a hint for an
 456  * exact unit.
 457  */
 458 int
 459 resource_unset_value(const char *name, int unit, const char *resname)
 460 {
 461         char varname[128];
 462         const char *retname, *retvalue;
 463         int error, line;
 464         size_t len;
 465
 466         line = 0;
 467         error = resource_find(&line, NULL, name, &unit, resname, NULL,
 468             &retname, NULL, NULL, NULL, NULL, &retvalue);
 469         if (error)
 470                 return (error);
 471
 472         retname -= strlen("hint.");
 473         len = retvalue - retname - 1;
 474         if (len > sizeof(varname) - 1)
 475                 return (ENAMETOOLONG);
 476         memcpy(varname, retname, len);
 477         varname[len] = '\0';
 478         return (kern_unsetenv(varname));
 479 }