sys/kern/kern_environment.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause
   3  *
   4  * Copyright (c) 1998 Michael Smith
   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 /*
  30  * The unified bootloader passes us a pointer to a preserved copy of
  31  * bootstrap/kernel environment variables.  We convert them to a
  32  * dynamic array of strings later when the VM subsystem is up.
  33  *
  34  * We make these available through the kenv(2) syscall for userland
  35  * and through kern_getenv()/freeenv() kern_setenv() kern_unsetenv() testenv() for
  36  * the kernel.
  37  */
  38
  39 #include <sys/param.h>
  40 #include <sys/eventhandler.h>
  41 #include <sys/systm.h>
  42 #include <sys/kenv.h>
  43 #include <sys/kernel.h>
  44 #include <sys/libkern.h>
  45 #include <sys/limits.h>
  46 #include <sys/lock.h>
  47 #include <sys/malloc.h>
  48 #include <sys/mutex.h>
  49 #include <sys/priv.h>
  50 #include <sys/proc.h>
  51 #include <sys/queue.h>
  52 #include <sys/sysent.h>
  53 #include <sys/sysproto.h>
  54
  55 #include <security/mac/mac_framework.h>
  56
  57 #include <vm/uma.h>
  58
  59 static char *_getenv_dynamic_locked(const char *name, int *idx);
  60 static char *_getenv_dynamic(const char *name, int *idx);
  61
  62 static char *kenv_acquire(const char *name);
  63 static void kenv_release(const char *buf);
  64
  65 static MALLOC_DEFINE(M_KENV, "kenv", "kernel environment");
  66
  67 #define KENV_SIZE       512     /* Maximum number of environment strings */
  68
  69 static uma_zone_t kenv_zone;
  70 static int      kenv_mvallen = KENV_MVALLEN;
  71
  72 /* pointer to the config-generated static environment */
  73 char            *kern_envp;
  74
  75 /* pointer to the md-static environment */
  76 char            *md_envp;
  77 static int      md_env_len;
  78 static int      md_env_pos;
  79
  80 static char     *kernenv_next(char *);
  81
  82 /* dynamic environment variables */
  83 char            **kenvp;
  84 struct mtx      kenv_lock;
  85
  86 /*
  87  * No need to protect this with a mutex since SYSINITS are single threaded.
  88  */
  89 bool    dynamic_kenv;
  90
  91 #define KENV_CHECK      if (!dynamic_kenv) \
  92                             panic("%s: called before SI_SUB_KMEM", __func__)
  93
  94 static int
  95 kenv_dump(struct thread *td, char **envp, int what, char *value, int len)
  96 {
  97         char *buffer, *senv;
  98         size_t done, needed, buflen;
  99         int error;
 100
 101         error = 0;
 102         buffer = NULL;
 103         done = needed = 0;
 104
 105         MPASS(what == KENV_DUMP || what == KENV_DUMP_LOADER ||
 106             what == KENV_DUMP_STATIC);
 107
 108         /*
 109          * For non-dynamic kernel environment, we pass in either md_envp or
 110          * kern_envp and we must traverse with kernenv_next().  This shuffling
 111          * of pointers simplifies the below loop by only differing in how envp
 112          * is modified.
 113          */
 114         if (what != KENV_DUMP) {
 115                 senv = (char *)envp;
 116                 envp = &senv;
 117         }
 118
 119         buflen = len;
 120         if (buflen > KENV_SIZE * (KENV_MNAMELEN + kenv_mvallen + 2))
 121                 buflen = KENV_SIZE * (KENV_MNAMELEN +
 122                     kenv_mvallen + 2);
 123         if (len > 0 && value != NULL)
 124                 buffer = malloc(buflen, M_TEMP, M_WAITOK|M_ZERO);
 125
 126         /* Only take the lock for the dynamic kenv. */
 127         if (what == KENV_DUMP)
 128                 mtx_lock(&kenv_lock);
 129         while (*envp != NULL) {
 130                 len = strlen(*envp) + 1;
 131                 needed += len;
 132                 len = min(len, buflen - done);
 133                 /*
 134                  * If called with a NULL or insufficiently large
 135                  * buffer, just keep computing the required size.
 136                  */
 137                 if (value != NULL && buffer != NULL && len > 0) {
 138                         bcopy(*envp, buffer + done, len);
 139                         done += len;
 140                 }
 141
 142                 /* Advance the pointer depending on the kenv format. */
 143                 if (what == KENV_DUMP)
 144                         envp++;
 145                 else
 146                         senv = kernenv_next(senv);
 147         }
 148         if (what == KENV_DUMP)
 149                 mtx_unlock(&kenv_lock);
 150         if (buffer != NULL) {
 151                 error = copyout(buffer, value, done);
 152                 free(buffer, M_TEMP);
 153         }
 154         td->td_retval[0] = ((done == needed) ? 0 : needed);
 155         return (error);
 156 }
 157
 158 int
 159 sys_kenv(struct thread *td, struct kenv_args *uap)
 160 {
 161         char *name, *value;
 162         size_t len;
 163         int error;
 164
 165         KASSERT(dynamic_kenv, ("kenv: dynamic_kenv = false"));
 166
 167         error = 0;
 168
 169         switch (uap->what) {
 170         case KENV_DUMP:
 171 #ifdef MAC
 172                 error = mac_kenv_check_dump(td->td_ucred);
 173                 if (error)
 174                         return (error);
 175 #endif
 176                 return (kenv_dump(td, kenvp, uap->what, uap->value, uap->len));
 177         case KENV_DUMP_LOADER:
 178         case KENV_DUMP_STATIC:
 179 #ifdef MAC
 180                 error = mac_kenv_check_dump(td->td_ucred);
 181                 if (error)
 182                         return (error);
 183 #endif
 184 #ifdef PRESERVE_EARLY_KENV
 185                 return (kenv_dump(td,
 186                     uap->what == KENV_DUMP_LOADER ? (char **)md_envp :
 187                     (char **)kern_envp, uap->what, uap->value, uap->len));
 188 #else
 189                 return (ENOENT);
 190 #endif
 191         case KENV_SET:
 192                 error = priv_check(td, PRIV_KENV_SET);
 193                 if (error)
 194                         return (error);
 195                 break;
 196
 197         case KENV_UNSET:
 198                 error = priv_check(td, PRIV_KENV_UNSET);
 199                 if (error)
 200                         return (error);
 201                 break;
 202         }
 203
 204         name = malloc(KENV_MNAMELEN + 1, M_TEMP, M_WAITOK);
 205
 206         error = copyinstr(uap->name, name, KENV_MNAMELEN + 1, NULL);
 207         if (error)
 208                 goto done;
 209
 210         switch (uap->what) {
 211         case KENV_GET:
 212 #ifdef MAC
 213                 error = mac_kenv_check_get(td->td_ucred, name);
 214                 if (error)
 215                         goto done;
 216 #endif
 217                 value = kern_getenv(name);
 218                 if (value == NULL) {
 219                         error = ENOENT;
 220                         goto done;
 221                 }
 222                 len = strlen(value) + 1;
 223                 if (len > uap->len)
 224                         len = uap->len;
 225                 error = copyout(value, uap->value, len);
 226                 freeenv(value);
 227                 if (error)
 228                         goto done;
 229                 td->td_retval[0] = len;
 230                 break;
 231         case KENV_SET:
 232                 len = uap->len;
 233                 if (len < 1) {
 234                         error = EINVAL;
 235                         goto done;
 236                 }
 237                 if (len > kenv_mvallen + 1)
 238                         len = kenv_mvallen + 1;
 239                 value = malloc(len, M_TEMP, M_WAITOK);
 240                 error = copyinstr(uap->value, value, len, NULL);
 241                 if (error) {
 242                         free(value, M_TEMP);
 243                         goto done;
 244                 }
 245 #ifdef MAC
 246                 error = mac_kenv_check_set(td->td_ucred, name, value);
 247                 if (error == 0)
 248 #endif
 249                         kern_setenv(name, value);
 250                 free(value, M_TEMP);
 251                 break;
 252         case KENV_UNSET:
 253 #ifdef MAC
 254                 error = mac_kenv_check_unset(td->td_ucred, name);
 255                 if (error)
 256                         goto done;
 257 #endif
 258                 error = kern_unsetenv(name);
 259                 if (error)
 260                         error = ENOENT;
 261                 break;
 262         default:
 263                 error = EINVAL;
 264                 break;
 265         }
 266 done:
 267         free(name, M_TEMP);
 268         return (error);
 269 }
 270
 271 /*
 272  * Populate the initial kernel environment.
 273  *
 274  * This is called very early in MD startup, either to provide a copy of the
 275  * environment obtained from a boot loader, or to provide an empty buffer into
 276  * which MD code can store an initial environment using kern_setenv() calls.
 277  *
 278  * kern_envp is set to the static_env generated by config(8).  This implements
 279  * the env keyword described in config(5).
 280  *
 281  * If len is non-zero, the caller is providing an empty buffer.  The caller will
 282  * subsequently use kern_setenv() to add up to len bytes of initial environment
 283  * before the dynamic environment is available.
 284  *
 285  * If len is zero, the caller is providing a pre-loaded buffer containing
 286  * environment strings.  Additional strings cannot be added until the dynamic
 287  * environment is available.  The memory pointed to must remain stable at least
 288  * until sysinit runs init_dynamic_kenv() and preferably until after SI_SUB_KMEM
 289  * is finished so that subr_hints routines may continue to use it until the
 290  * environments have been fully merged at the end of the pass.  If no initial
 291  * environment is available from the boot loader, passing a NULL pointer allows
 292  * the static_env to be installed if it is configured.  In this case, any call
 293  * to kern_setenv() prior to the setup of the dynamic environment will result in
 294  * a panic.
 295  */
 296 void
 297 init_static_kenv(char *buf, size_t len)
 298 {
 299
 300         KASSERT(!dynamic_kenv, ("kenv: dynamic_kenv already initialized"));
 301         /*
 302          * Suitably sized means it must be able to hold at least one empty
 303          * variable, otherwise things go belly up if a kern_getenv call is
 304          * made without a prior call to kern_setenv as we have a malformed
 305          * environment.
 306          */
 307         KASSERT(len == 0 || len >= 2,
 308             ("kenv: static env must be initialized or suitably sized"));
 309         KASSERT(len == 0 || (*buf == '\0' && *(buf + 1) == '\0'),
 310             ("kenv: sized buffer must be initially empty"));
 311
 312         /*
 313          * We may be called twice, with the second call needed to relocate
 314          * md_envp after enabling paging.  md_envp is then garbage if it is
 315          * not null and the relocation will move it.  Discard it so as to
 316          * not crash using its old value in our first call to kern_getenv().
 317          *
 318          * The second call gives the same environment as the first except
 319          * in silly configurations where the static env disables itself.
 320          *
 321          * Other env calls don't handle possibly-garbage pointers, so must
 322          * not be made between enabling paging and calling here.
 323          */
 324         md_envp = NULL;
 325         md_env_len = 0;
 326         md_env_pos = 0;
 327
 328         /*
 329          * Give the static environment a chance to disable the loader(8)
 330          * environment first.  This is done with loader_env.disabled=1.
 331          *
 332          * static_env and static_hints may both be disabled, but in slightly
 333          * different ways.  For static_env, we just don't setup kern_envp and
 334          * it's as if a static env wasn't even provided.  For static_hints,
 335          * we effectively zero out the buffer to stop the rest of the kernel
 336          * from being able to use it.
 337          *
 338          * We're intentionally setting this up so that static_hints.disabled may
 339          * be specified in either the MD env or the static env. This keeps us
 340          * consistent in our new world view.
 341          *
 342          * As a warning, the static environment may not be disabled in any way
 343          * if the static environment has disabled the loader environment.
 344          */
 345         kern_envp = static_env;
 346         if (!getenv_is_true("loader_env.disabled")) {
 347                 md_envp = buf;
 348                 md_env_len = len;
 349                 md_env_pos = 0;
 350
 351                 if (getenv_is_true("static_env.disabled")) {
 352                         kern_envp[0] = '\0';
 353                         kern_envp[1] = '\0';
 354                 }
 355         }
 356         if (getenv_is_true("static_hints.disabled")) {
 357                 static_hints[0] = '\0';
 358                 static_hints[1] = '\0';
 359         }
 360 }
 361
 362 /* Maximum suffix number appended for duplicate environment variable names. */
 363 #define MAXSUFFIX 9999
 364 #define SUFFIXLEN strlen("_" __XSTRING(MAXSUFFIX))
 365
 366 static void
 367 getfreesuffix(char *cp, size_t *n)
 368 {
 369         size_t len = strlen(cp);
 370         char * ncp;
 371
 372         ncp = malloc(len + SUFFIXLEN + 1, M_KENV, M_WAITOK);
 373         memcpy(ncp, cp, len);
 374         for (*n = 1; *n <= MAXSUFFIX; (*n)++) {
 375                 sprintf(&ncp[len], "_%zu", *n);
 376                 if (!_getenv_dynamic_locked(ncp, NULL))
 377                         break;
 378         }
 379         free(ncp, M_KENV);
 380         if (*n > MAXSUFFIX)
 381                 panic("Too many duplicate kernel environment values: %s", cp);
 382 }
 383
 384 static void
 385 init_dynamic_kenv_from(char *init_env, int *curpos)
 386 {
 387         char *cp, *cpnext, *eqpos, *found;
 388         size_t len, n;
 389         int i;
 390
 391         if (init_env && *init_env != '\0') {
 392                 found = NULL;
 393                 i = *curpos;
 394                 for (cp = init_env; cp != NULL; cp = cpnext) {
 395                         cpnext = kernenv_next(cp);
 396                         len = strlen(cp) + 1;
 397                         if (i > KENV_SIZE) {
 398                                 printf(
 399                                 "WARNING: too many kenv strings, ignoring %s\n",
 400                                     cp);
 401                                 goto sanitize;
 402                         }
 403                         if (len > KENV_MNAMELEN + 1 + kenv_mvallen + 1) {
 404                                 printf(
 405                                 "WARNING: too long kenv string, ignoring %s\n",
 406                                     cp);
 407                                 goto sanitize;
 408                         }
 409                         eqpos = strchr(cp, '=');
 410                         if (eqpos == NULL) {
 411                                 printf(
 412                                 "WARNING: malformed static env value, ignoring %s\n",
 413                                     cp);
 414                                 goto sanitize;
 415                         }
 416                         *eqpos = 0;
 417                         /*
 418                          * Handle duplicates in the environment as we go; we
 419                          * add the duplicated assignments with _N suffixes.
 420                          * This ensures that (a) if a variable is set in the
 421                          * static environment and in the "loader" environment
 422                          * provided by MD code, the value from the loader will
 423                          * have the expected variable name and the value from
 424                          * the static environment will have the suffix; and (b)
 425                          * if the "loader" environment has the same variable
 426                          * set multiple times (as is possible with values being
 427                          * passed via the kernel "command line") the extra
 428                          * values are visible to code which knows where to look
 429                          * for them.
 430                          */
 431                         found = _getenv_dynamic_locked(cp, NULL);
 432                         if (found != NULL) {
 433                                 getfreesuffix(cp, &n);
 434                                 kenvp[i] = malloc(len + SUFFIXLEN,
 435                                     M_KENV, M_WAITOK);
 436                                 sprintf(kenvp[i++], "%s_%zu=%s", cp, n,
 437                                     &eqpos[1]);
 438                         } else {
 439                                 kenvp[i] = malloc(len, M_KENV, M_WAITOK);
 440                                 *eqpos = '=';
 441                                 strcpy(kenvp[i++], cp);
 442                         }
 443 sanitize:
 444 #ifdef PRESERVE_EARLY_KENV
 445                         continue;
 446 #else
 447                         explicit_bzero(cp, len - 1);
 448 #endif
 449                 }
 450                 *curpos = i;
 451         }
 452 }
 453
 454 /*
 455  * Setup the dynamic kernel environment.
 456  */
 457 static void
 458 init_dynamic_kenv(void *data __unused)
 459 {
 460         int dynamic_envpos;
 461         int size;
 462
 463         TUNABLE_INT_FETCH("kenv_mvallen", &kenv_mvallen);
 464         size = KENV_MNAMELEN + 1 + kenv_mvallen + 1;
 465
 466         kenv_zone = uma_zcreate("kenv", size, NULL, NULL, NULL, NULL,
 467             UMA_ALIGN_PTR, 0);
 468
 469         kenvp = malloc((KENV_SIZE + 1) * sizeof(char *), M_KENV,
 470                 M_WAITOK | M_ZERO);
 471
 472         dynamic_envpos = 0;
 473         init_dynamic_kenv_from(md_envp, &dynamic_envpos);
 474         init_dynamic_kenv_from(kern_envp, &dynamic_envpos);
 475         kenvp[dynamic_envpos] = NULL;
 476
 477         mtx_init(&kenv_lock, "kernel environment", NULL, MTX_DEF);
 478         dynamic_kenv = true;
 479 }
 480 SYSINIT(kenv, SI_SUB_KMEM + 1, SI_ORDER_FIRST, init_dynamic_kenv, NULL);
 481
 482 void
 483 freeenv(char *env)
 484 {
 485
 486         if (dynamic_kenv && env != NULL) {
 487                 explicit_bzero(env, strlen(env));
 488                 uma_zfree(kenv_zone, env);
 489         }
 490 }
 491
 492 /*
 493  * Internal functions for string lookup.
 494  */
 495 static char *
 496 _getenv_dynamic_locked(const char *name, int *idx)
 497 {
 498         char *cp;
 499         int len, i;
 500
 501         len = strlen(name);
 502         for (cp = kenvp[0], i = 0; cp != NULL; cp = kenvp[++i]) {
 503                 if ((strncmp(cp, name, len) == 0) &&
 504                     (cp[len] == '=')) {
 505                         if (idx != NULL)
 506                                 *idx = i;
 507                         return (cp + len + 1);
 508                 }
 509         }
 510         return (NULL);
 511 }
 512
 513 static char *
 514 _getenv_dynamic(const char *name, int *idx)
 515 {
 516
 517         mtx_assert(&kenv_lock, MA_OWNED);
 518         return (_getenv_dynamic_locked(name, idx));
 519 }
 520
 521 static char *
 522 _getenv_static_from(char *chkenv, const char *name)
 523 {
 524         char *cp, *ep;
 525         int len;
 526
 527         for (cp = chkenv; cp != NULL; cp = kernenv_next(cp)) {
 528                 for (ep = cp; (*ep != '=') && (*ep != 0); ep++)
 529                         ;
 530                 if (*ep != '=')
 531                         continue;
 532                 len = ep - cp;
 533                 ep++;
 534                 if (!strncmp(name, cp, len) && name[len] == 0)
 535                         return (ep);
 536         }
 537         return (NULL);
 538 }
 539
 540 static char *
 541 _getenv_static(const char *name)
 542 {
 543         char *val;
 544
 545         val = _getenv_static_from(md_envp, name);
 546         if (val != NULL)
 547                 return (val);
 548         val = _getenv_static_from(kern_envp, name);
 549         if (val != NULL)
 550                 return (val);
 551         return (NULL);
 552 }
 553
 554 /*
 555  * Look up an environment variable by name.
 556  * Return a pointer to the string if found.
 557  * The pointer has to be freed with freeenv()
 558  * after use.
 559  */
 560 char *
 561 kern_getenv(const char *name)
 562 {
 563         char *cp, *ret;
 564         int len;
 565
 566         if (dynamic_kenv) {
 567                 len = KENV_MNAMELEN + 1 + kenv_mvallen + 1;
 568                 ret = uma_zalloc(kenv_zone, M_WAITOK | M_ZERO);
 569                 mtx_lock(&kenv_lock);
 570                 cp = _getenv_dynamic(name, NULL);
 571                 if (cp != NULL)
 572                         strlcpy(ret, cp, len);
 573                 mtx_unlock(&kenv_lock);
 574                 if (cp == NULL) {
 575                         uma_zfree(kenv_zone, ret);
 576                         ret = NULL;
 577                 }
 578         } else
 579                 ret = _getenv_static(name);
 580
 581         return (ret);
 582 }
 583
 584 /*
 585  * Test if an environment variable is defined.
 586  */
 587 int
 588 testenv(const char *name)
 589 {
 590         char *cp;
 591
 592         cp = kenv_acquire(name);
 593         kenv_release(cp);
 594
 595         if (cp != NULL)
 596                 return (1);
 597         return (0);
 598 }
 599
 600 /*
 601  * Set an environment variable in the MD-static environment.  This cannot
 602  * feasibly be done on config(8)-generated static environments as they don't
 603  * generally include space for extra variables.
 604  */
 605 static int
 606 setenv_static(const char *name, const char *value)
 607 {
 608         int len;
 609
 610         if (md_env_pos >= md_env_len)
 611                 return (-1);
 612
 613         /* Check space for x=y and two nuls */
 614         len = strlen(name) + strlen(value);
 615         if (len + 3 < md_env_len - md_env_pos) {
 616                 len = sprintf(&md_envp[md_env_pos], "%s=%s", name, value);
 617                 md_env_pos += len+1;
 618                 md_envp[md_env_pos] = '\0';
 619                 return (0);
 620         } else
 621                 return (-1);
 622
 623 }
 624
 625 /*
 626  * Set an environment variable by name.
 627  */
 628 int
 629 kern_setenv(const char *name, const char *value)
 630 {
 631         char *buf, *cp, *oldenv;
 632         int namelen, vallen, i;
 633
 634         if (!dynamic_kenv && md_env_len > 0)
 635                 return (setenv_static(name, value));
 636
 637         KENV_CHECK;
 638
 639         namelen = strlen(name) + 1;
 640         if (namelen > KENV_MNAMELEN + 1)
 641                 return (-1);
 642         vallen = strlen(value) + 1;
 643         if (vallen > kenv_mvallen + 1)
 644                 return (-1);
 645         buf = malloc(namelen + vallen, M_KENV, M_WAITOK);
 646         sprintf(buf, "%s=%s", name, value);
 647
 648         mtx_lock(&kenv_lock);
 649         cp = _getenv_dynamic(name, &i);
 650         if (cp != NULL) {
 651                 oldenv = kenvp[i];
 652                 kenvp[i] = buf;
 653                 mtx_unlock(&kenv_lock);
 654                 free(oldenv, M_KENV);
 655         } else {
 656                 /* We add the option if it wasn't found */
 657                 for (i = 0; (cp = kenvp[i]) != NULL; i++)
 658                         ;
 659
 660                 /* Bounds checking */
 661                 if (i < 0 || i >= KENV_SIZE) {
 662                         free(buf, M_KENV);
 663                         mtx_unlock(&kenv_lock);
 664                         return (-1);
 665                 }
 666
 667                 kenvp[i] = buf;
 668                 kenvp[i + 1] = NULL;
 669                 mtx_unlock(&kenv_lock);
 670         }
 671         EVENTHANDLER_INVOKE(setenv, name);
 672         return (0);
 673 }
 674
 675 /*
 676  * Unset an environment variable string.
 677  */
 678 int
 679 kern_unsetenv(const char *name)
 680 {
 681         char *cp, *oldenv;
 682         int i, j;
 683
 684         KENV_CHECK;
 685
 686         mtx_lock(&kenv_lock);
 687         cp = _getenv_dynamic(name, &i);
 688         if (cp != NULL) {
 689                 oldenv = kenvp[i];
 690                 for (j = i + 1; kenvp[j] != NULL; j++)
 691                         kenvp[i++] = kenvp[j];
 692                 kenvp[i] = NULL;
 693                 mtx_unlock(&kenv_lock);
 694                 zfree(oldenv, M_KENV);
 695                 EVENTHANDLER_INVOKE(unsetenv, name);
 696                 return (0);
 697         }
 698         mtx_unlock(&kenv_lock);
 699         return (-1);
 700 }
 701
 702 /*
 703  * Return the internal kenv buffer for the variable name, if it exists.
 704  * If the dynamic kenv is initialized and the name is present, return
 705  * with kenv_lock held.
 706  */
 707 static char *
 708 kenv_acquire(const char *name)
 709 {
 710         char *value;
 711
 712         if (dynamic_kenv) {
 713                 mtx_lock(&kenv_lock);
 714                 value = _getenv_dynamic(name, NULL);
 715                 if (value == NULL)
 716                         mtx_unlock(&kenv_lock);
 717                 return (value);
 718         } else
 719                 return (_getenv_static(name));
 720 }
 721
 722 /*
 723  * Undo a previous kenv_acquire() operation
 724  */
 725 static void
 726 kenv_release(const char *buf)
 727 {
 728         if ((buf != NULL) && dynamic_kenv)
 729                 mtx_unlock(&kenv_lock);
 730 }
 731
 732 /*
 733  * Return a string value from an environment variable.
 734  */
 735 int
 736 getenv_string(const char *name, char *data, int size)
 737 {
 738         char *cp;
 739
 740         cp = kenv_acquire(name);
 741
 742         if (cp != NULL)
 743                 strlcpy(data, cp, size);
 744
 745         kenv_release(cp);
 746
 747         return (cp != NULL);
 748 }
 749
 750 /*
 751  * Return an array of integers at the given type size and signedness.
 752  */
 753 int
 754 getenv_array(const char *name, void *pdata, int size, int *psize,
 755     int type_size, bool allow_signed)
 756 {
 757         uint8_t shift;
 758         int64_t value;
 759         int64_t old;
 760         const char *buf;
 761         char *end;
 762         const char *ptr;
 763         int n;
 764         int rc;
 765
 766         rc = 0;                   /* assume failure */
 767
 768         buf = kenv_acquire(name);
 769         if (buf == NULL)
 770                 goto error;
 771
 772         /* get maximum number of elements */
 773         size /= type_size;
 774
 775         n = 0;
 776
 777         for (ptr = buf; *ptr != 0; ) {
 778                 value = strtoq(ptr, &end, 0);
 779
 780                 /* check if signed numbers are allowed */
 781                 if (value < 0 && !allow_signed)
 782                         goto error;
 783
 784                 /* check for invalid value */
 785                 if (ptr == end)
 786                         goto error;
 787
 788                 /* check for valid suffix */
 789                 switch (*end) {
 790                 case 't':
 791                 case 'T':
 792                         shift = 40;
 793                         end++;
 794                         break;
 795                 case 'g':
 796                 case 'G':
 797                         shift = 30;
 798                         end++;
 799                         break;
 800                 case 'm':
 801                 case 'M':
 802                         shift = 20;
 803                         end++;
 804                         break;
 805                 case 'k':
 806                 case 'K':
 807                         shift = 10;
 808                         end++;
 809                         break;
 810                 case ' ':
 811                 case '\t':
 812                 case ',':
 813                 case 0:
 814                         shift = 0;
 815                         break;
 816                 default:
 817                         /* garbage after numeric value */
 818                         goto error;
 819                 }
 820
 821                 /* skip till next value, if any */
 822                 while (*end == '\t' || *end == ',' || *end == ' ')
 823                         end++;
 824
 825                 /* update pointer */
 826                 ptr = end;
 827
 828                 /* apply shift */
 829                 old = value;
 830                 value <<= shift;
 831
 832                 /* overflow check */
 833                 if ((value >> shift) != old)
 834                         goto error;
 835
 836                 /* check for buffer overflow */
 837                 if (n >= size)
 838                         goto error;
 839
 840                 /* store value according to type size */
 841                 switch (type_size) {
 842                 case 1:
 843                         if (allow_signed) {
 844                                 if (value < SCHAR_MIN || value > SCHAR_MAX)
 845                                         goto error;
 846                         } else {
 847                                 if (value < 0 || value > UCHAR_MAX)
 848                                         goto error;
 849                         }
 850                         ((uint8_t *)pdata)[n] = (uint8_t)value;
 851                         break;
 852                 case 2:
 853                         if (allow_signed) {
 854                                 if (value < SHRT_MIN || value > SHRT_MAX)
 855                                         goto error;
 856                         } else {
 857                                 if (value < 0 || value > USHRT_MAX)
 858                                         goto error;
 859                         }
 860                         ((uint16_t *)pdata)[n] = (uint16_t)value;
 861                         break;
 862                 case 4:
 863                         if (allow_signed) {
 864                                 if (value < INT_MIN || value > INT_MAX)
 865                                         goto error;
 866                         } else {
 867                                 if (value > UINT_MAX)
 868                                         goto error;
 869                         }
 870                         ((uint32_t *)pdata)[n] = (uint32_t)value;
 871                         break;
 872                 case 8:
 873                         ((uint64_t *)pdata)[n] = (uint64_t)value;
 874                         break;
 875                 default:
 876                         goto error;
 877                 }
 878                 n++;
 879         }
 880         *psize = n * type_size;
 881
 882         if (n != 0)
 883                 rc = 1; /* success */
 884 error:
 885         kenv_release(buf);
 886         return (rc);
 887 }
 888
 889 /*
 890  * Return an integer value from an environment variable.
 891  */
 892 int
 893 getenv_int(const char *name, int *data)
 894 {
 895         quad_t tmp;
 896         int rval;
 897
 898         rval = getenv_quad(name, &tmp);
 899         if (rval)
 900                 *data = (int) tmp;
 901         return (rval);
 902 }
 903
 904 /*
 905  * Return an unsigned integer value from an environment variable.
 906  */
 907 int
 908 getenv_uint(const char *name, unsigned int *data)
 909 {
 910         quad_t tmp;
 911         int rval;
 912
 913         rval = getenv_quad(name, &tmp);
 914         if (rval)
 915                 *data = (unsigned int) tmp;
 916         return (rval);
 917 }
 918
 919 /*
 920  * Return an int64_t value from an environment variable.
 921  */
 922 int
 923 getenv_int64(const char *name, int64_t *data)
 924 {
 925         quad_t tmp;
 926         int64_t rval;
 927
 928         rval = getenv_quad(name, &tmp);
 929         if (rval)
 930                 *data = (int64_t) tmp;
 931         return (rval);
 932 }
 933
 934 /*
 935  * Return an uint64_t value from an environment variable.
 936  */
 937 int
 938 getenv_uint64(const char *name, uint64_t *data)
 939 {
 940         quad_t tmp;
 941         uint64_t rval;
 942
 943         rval = getenv_quad(name, &tmp);
 944         if (rval)
 945                 *data = (uint64_t) tmp;
 946         return (rval);
 947 }
 948
 949 /*
 950  * Return a long value from an environment variable.
 951  */
 952 int
 953 getenv_long(const char *name, long *data)
 954 {
 955         quad_t tmp;
 956         int rval;
 957
 958         rval = getenv_quad(name, &tmp);
 959         if (rval)
 960                 *data = (long) tmp;
 961         return (rval);
 962 }
 963
 964 /*
 965  * Return an unsigned long value from an environment variable.
 966  */
 967 int
 968 getenv_ulong(const char *name, unsigned long *data)
 969 {
 970         quad_t tmp;
 971         int rval;
 972
 973         rval = getenv_quad(name, &tmp);
 974         if (rval)
 975                 *data = (unsigned long) tmp;
 976         return (rval);
 977 }
 978
 979 /*
 980  * Return a quad_t value from an environment variable.
 981  */
 982 int
 983 getenv_quad(const char *name, quad_t *data)
 984 {
 985         const char      *value;
 986         char            suffix, *vtp;
 987         quad_t          iv;
 988
 989         value = kenv_acquire(name);
 990         if (value == NULL) {
 991                 goto error;
 992         }
 993         iv = strtoq(value, &vtp, 0);
 994         if (vtp == value || (vtp[0] != '\0' && vtp[1] != '\0')) {
 995                 goto error;
 996         }
 997         suffix = vtp[0];
 998         kenv_release(value);
 999         switch (suffix) {
1000         case 't': case 'T':
1001                 iv *= 1024;
1002                 /* FALLTHROUGH */
1003         case 'g': case 'G':
1004                 iv *= 1024;
1005                 /* FALLTHROUGH */
1006         case 'm': case 'M':
1007                 iv *= 1024;
1008                 /* FALLTHROUGH */
1009         case 'k': case 'K':
1010                 iv *= 1024;
1011         case '\0':
1012                 break;
1013         default:
1014                 return (0);
1015         }
1016         *data = iv;
1017         return (1);
1018 error:
1019         kenv_release(value);
1020         return (0);
1021 }
1022
1023 /*
1024  * Return a boolean value from an environment variable. This can be in
1025  * numerical or string form, i.e. "1" or "true".
1026  */
1027 int
1028 getenv_bool(const char *name, bool *data)
1029 {
1030         char *val;
1031         int ret = 0;
1032
1033         if (name == NULL)
1034                 return (0);
1035
1036         val = kern_getenv(name);
1037         if (val == NULL)
1038                 return (0);
1039
1040         if ((strcmp(val, "1") == 0) || (strcasecmp(val, "true") == 0)) {
1041                 *data = true;
1042                 ret = 1;
1043         } else if ((strcmp(val, "0") == 0) || (strcasecmp(val, "false") == 0)) {
1044                 *data = false;
1045                 ret = 1;
1046         } else {
1047                 /* Spit out a warning for malformed boolean variables. */
1048                 printf("Environment variable %s has non-boolean value \"%s\"\n",
1049                     name, val);
1050         }
1051         freeenv(val);
1052
1053         return (ret);
1054 }
1055
1056 /*
1057  * Wrapper around getenv_bool to easily check for true.
1058  */
1059 bool
1060 getenv_is_true(const char *name)
1061 {
1062         bool val;
1063
1064         if (getenv_bool(name, &val) != 0)
1065                 return (val);
1066         return (false);
1067 }
1068
1069 /*
1070  * Wrapper around getenv_bool to easily check for false.
1071  */
1072 bool
1073 getenv_is_false(const char *name)
1074 {
1075         bool val;
1076
1077         if (getenv_bool(name, &val) != 0)
1078                 return (!val);
1079         return (false);
1080 }
1081
1082 /*
1083  * Find the next entry after the one which (cp) falls within, return a
1084  * pointer to its start or NULL if there are no more.
1085  */
1086 static char *
1087 kernenv_next(char *cp)
1088 {
1089
1090         if (cp != NULL) {
1091                 while (*cp != 0)
1092                         cp++;
1093                 cp++;
1094                 if (*cp == 0)
1095                         cp = NULL;
1096         }
1097         return (cp);
1098 }
1099
1100 void
1101 tunable_int_init(void *data)
1102 {
1103         struct tunable_int *d = (struct tunable_int *)data;
1104
1105         TUNABLE_INT_FETCH(d->path, d->var);
1106 }
1107
1108 void
1109 tunable_long_init(void *data)
1110 {
1111         struct tunable_long *d = (struct tunable_long *)data;
1112
1113         TUNABLE_LONG_FETCH(d->path, d->var);
1114 }
1115
1116 void
1117 tunable_ulong_init(void *data)
1118 {
1119         struct tunable_ulong *d = (struct tunable_ulong *)data;
1120
1121         TUNABLE_ULONG_FETCH(d->path, d->var);
1122 }
1123
1124 void
1125 tunable_int64_init(void *data)
1126 {
1127         struct tunable_int64 *d = (struct tunable_int64 *)data;
1128
1129         TUNABLE_INT64_FETCH(d->path, d->var);
1130 }
1131
1132 void
1133 tunable_uint64_init(void *data)
1134 {
1135         struct tunable_uint64 *d = (struct tunable_uint64 *)data;
1136
1137         TUNABLE_UINT64_FETCH(d->path, d->var);
1138 }
1139
1140 void
1141 tunable_quad_init(void *data)
1142 {
1143         struct tunable_quad *d = (struct tunable_quad *)data;
1144
1145         TUNABLE_QUAD_FETCH(d->path, d->var);
1146 }
1147
1148 void
1149 tunable_bool_init(void *data)
1150 {
1151         struct tunable_bool *d = (struct tunable_bool *)data;
1152
1153         TUNABLE_BOOL_FETCH(d->path, d->var);
1154 }
1155
1156 void
1157 tunable_str_init(void *data)
1158 {
1159         struct tunable_str *d = (struct tunable_str *)data;
1160
1161         TUNABLE_STR_FETCH(d->path, d->var, d->size);
1162 }