sys/kern/kern_environment.c

   1 /*-
   2  * Copyright (c) 1998 Michael Smith
   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  * $FreeBSD: src/sys/kern/kern_environment.c,v 1.10.2.7 2002/05/07 09:57:16 bde Exp $
  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 dynamic array
  32  * of strings later when the VM subsystem is up.
  33  * We make these available using sysctl for both in-kernel and
  34  * out-of-kernel consumers, as well as the k{get,set,unset,free,test}env()
  35  * functions for in-kernel consumers.
  36  *
  37  * Note that the current sysctl infrastructure doesn't allow
  38  * dynamic insertion or traversal through handled spaces.  Grr.
  39  *
  40  * TODO: implement a sysctl handler to provide the functionality mentioned
  41  * above.
  42  */
  43
  44 #include <sys/param.h>
  45 #include <sys/kernel.h>
  46 #include <sys/libkern.h>
  47 #include <sys/malloc.h>
  48 #include <sys/spinlock.h>
  49 #include <sys/spinlock2.h>
  50 #include <sys/systm.h>
  51 #include <sys/sysctl.h>
  52
  53 /* exported variables */
  54 char            *kern_envp;             /* <sys/systm.h> */
  55
  56 /* local variables */
  57 char            **kenv_dynp;
  58 int             kenv_isdynamic;
  59 struct spinlock kenv_dynlock;
  60
  61 /* constants */
  62 MALLOC_DEFINE(M_KENV, "kenv", "kernel environment dynamic storage");
  63 #define KENV_DYNMAXNUM  512
  64 #define KENV_MAXNAMELEN 128
  65 #define KENV_MAXVALLEN  128
  66
  67 /* local prototypes */
  68 static char     *kenv_getstring_dynamic(const char *name, int *idx);
  69 static char     *kenv_getstring_static(const char *name);
  70 static char     *kernenv_next(char *cp);
  71
  72 /*
  73  * Look up a string in the dynamic environment array. Must be called with
  74  * kenv_dynlock held.
  75  */
  76 static char *
  77 kenv_getstring_dynamic(const char *name, int *idx)
  78 {
  79         char    *cp;
  80         int     len, i;
  81
  82         len = strlen(name);
  83         /* note: kunsetenv() never leaves NULL holes in the array */
  84         for (i = 0; (cp = kenv_dynp[i]) != NULL; i++) {
  85                 if ((strncmp(cp, name, len) == 0) && (cp[len] == '=')) {
  86                         if (idx != NULL)
  87                                 *idx = i;
  88                         return(cp + len + 1);
  89                 }
  90         }
  91         return(NULL);
  92 }
  93
  94 /*
  95  * Look up a string in the static environment array.
  96  */
  97 static char *
  98 kenv_getstring_static(const char *name)
  99 {
 100         char    *cp, *ep;
 101         int     len;
 102
 103         for (cp = kern_envp; cp != NULL; cp = kernenv_next(cp)) {
 104                 for (ep = cp; (*ep != '=') && (*ep != 0); ep++)
 105                         ;
 106                 if (*ep != '=')
 107                         continue;
 108                 len = ep - cp;
 109                 ep++;
 110                 if (!strncmp(name, cp, len) && name[len] == 0)
 111                         return(ep);
 112         }
 113         return(NULL);
 114 }
 115
 116 /*
 117  * Look up an environment variable by name.
 118  */
 119 char *
 120 kgetenv(const char *name)
 121 {
 122         char    buf[KENV_MAXNAMELEN + 1 + KENV_MAXVALLEN + 1];
 123         char    *cp, *ret;
 124         int     len;
 125
 126         if (kenv_isdynamic) {
 127                 spin_lock(&kenv_dynlock);
 128                 cp = kenv_getstring_dynamic(name, NULL);
 129                 if (cp != NULL) {
 130                         strcpy(buf, cp);
 131                         spin_unlock(&kenv_dynlock);
 132                         len = strlen(buf) + 1;
 133                         ret = kmalloc(len, M_KENV, M_WAITOK);
 134                         strcpy(ret, buf);
 135                 } else {
 136                         spin_unlock(&kenv_dynlock);
 137                         ret = NULL;
 138                 }
 139         } else
 140                 ret = kenv_getstring_static(name);
 141         return(ret);
 142 }
 143
 144 /*
 145  * Set an environment variable by name.
 146  */
 147 int
 148 ksetenv(const char *name, const char *value)
 149 {
 150         char    *cp, *buf, *oldenv;
 151         int     namelen, vallen, i;
 152
 153         if (kenv_isdynamic) {
 154                 namelen = strlen(name) + 1;
 155                 vallen = strlen(value) + 1;
 156                 if ((namelen > KENV_MAXNAMELEN) || (vallen > KENV_MAXVALLEN))
 157                         return(-1);
 158                 buf = kmalloc(namelen + vallen, M_KENV, M_WAITOK);
 159                 ksprintf(buf, "%s=%s", name, value);
 160                 spin_lock(&kenv_dynlock);
 161                 cp = kenv_getstring_dynamic(name, &i);
 162                 if (cp != NULL) {
 163                         /* replace existing environment variable */
 164                         oldenv = kenv_dynp[i];
 165                         kenv_dynp[i] = buf;
 166                         spin_unlock(&kenv_dynlock);
 167                         kfree(oldenv, M_KENV);
 168                 } else {
 169                         /* append new environment variable */
 170                         for (i = 0; (cp = kenv_dynp[i]) != NULL; i++)
 171                                 ;
 172                         /* bounds checking */
 173                         if (i < 0 || i >= (KENV_DYNMAXNUM - 1)) {
 174                                 kfree(buf, M_KENV);
 175                                 spin_unlock(&kenv_dynlock);
 176                                 return(-1);
 177                         }
 178                         kenv_dynp[i] = buf;
 179                         kenv_dynp[i + 1] = NULL;
 180                         spin_unlock(&kenv_dynlock);
 181                 }
 182                 return(0);
 183         } else {
 184                 kprintf("WARNING: ksetenv: dynamic array not created yet\n");
 185                 return(-1);
 186         }
 187 }
 188
 189 /*
 190  * Unset an environment variable by name.
 191  */
 192 int
 193 kunsetenv(const char *name)
 194 {
 195         char    *cp, *oldenv;
 196         int     i, j;
 197
 198         if (kenv_isdynamic) {
 199                 spin_lock(&kenv_dynlock);
 200                 cp = kenv_getstring_dynamic(name, &i);
 201                 if (cp != NULL) {
 202                         oldenv = kenv_dynp[i];
 203                         /* move all pointers beyond the unset one down 1 step */
 204                         for (j = i + 1; kenv_dynp[j] != NULL; j++)
 205                                 kenv_dynp[i++] = kenv_dynp[j];
 206                         kenv_dynp[i] = NULL;
 207                         spin_unlock(&kenv_dynlock);
 208                         kfree(oldenv, M_KENV);
 209                         return(0);
 210                 }
 211                 spin_unlock(&kenv_dynlock);
 212                 return(-1);
 213         } else {
 214                 kprintf("WARNING: kunsetenv: dynamic array not created yet\n");
 215                 return(-1);
 216         }
 217 }
 218
 219 /*
 220  * Free an environment variable that has been copied for a consumer.
 221  */
 222 void
 223 kfreeenv(char *env)
 224 {
 225         if (kenv_isdynamic)
 226                 kfree(env, M_KENV);
 227 }
 228
 229 /*
 230  * Test if an environment variable is defined.
 231  */
 232 int
 233 ktestenv(const char *name)
 234 {
 235         char    *cp;
 236
 237         if (kenv_isdynamic) {
 238                 spin_lock(&kenv_dynlock);
 239                 cp = kenv_getstring_dynamic(name, NULL);
 240                 spin_unlock(&kenv_dynlock);
 241         } else
 242                 cp = kenv_getstring_static(name);
 243         if (cp != NULL)
 244                 return(1);
 245         return(0);
 246 }
 247
 248 /*
 249  * Return a string value from an environment variable.
 250  */
 251 int
 252 kgetenv_string(const char *name, char *data, int size)
 253 {
 254         char    *tmp;
 255
 256         tmp = kgetenv(name);
 257         if (tmp != NULL) {
 258                 strncpy(data, tmp, size);
 259                 data[size - 1] = 0;
 260                 kfreeenv(tmp);
 261                 return (1);
 262         } else
 263                 return (0);
 264 }
 265
 266 /*
 267  * Return an integer value from an environment variable.
 268  */
 269 int
 270 kgetenv_int(const char *name, int *data)
 271 {
 272         quad_t  tmp;
 273         int     rval;
 274
 275         rval = kgetenv_quad(name, &tmp);
 276         if (rval)
 277                 *data = (int) tmp;
 278         return (rval);
 279 }
 280
 281 /*
 282  * Return a long value from an environment variable.
 283  */
 284 int
 285 kgetenv_long(const char *name, long *data)
 286 {
 287         quad_t tmp;
 288         int rval;
 289
 290         rval = kgetenv_quad(name, &tmp);
 291         if (rval)
 292                 *data = (long)tmp;
 293         return (rval);
 294 }
 295
 296 /*
 297  * Return an unsigned long value from an environment variable.
 298  */
 299 int
 300 kgetenv_ulong(const char *name, unsigned long *data)
 301 {
 302         quad_t tmp;
 303         int rval;
 304
 305         rval = kgetenv_quad(name, &tmp);
 306         if (rval)
 307                 *data = (unsigned long) tmp;
 308         return (rval);
 309 }
 310
 311 /*
 312  * Return a quad_t value from an environment variable.
 313  *
 314  * A single character kmgtKMGT extension multiplies the value
 315  * by 1024, 1024*1024, etc.
 316  */
 317 int
 318 kgetenv_quad(const char *name, quad_t *data)
 319 {
 320         char*   value;
 321         char*   vtp;
 322         quad_t  iv;
 323
 324         if ((value = kgetenv(name)) == NULL)
 325                 return(0);
 326
 327         iv = strtoq(value, &vtp, 0);
 328         switch(*vtp) {
 329         case 't':
 330         case 'T':
 331                 iv <<= 10;
 332                 /* fall through */
 333         case 'g':
 334         case 'G':
 335                 iv <<= 10;
 336                 /* fall through */
 337         case 'm':
 338         case 'M':
 339                 iv <<= 10;
 340                 /* fall through */
 341         case 'k':
 342         case 'K':
 343                 iv <<= 10;
 344                 ++vtp;
 345                 break;
 346         default:
 347                 break;
 348         }
 349
 350         if ((vtp == value) || (*vtp != '\0')) {
 351                 kfreeenv(value);
 352                 return(0);
 353         }
 354
 355         *data = iv;
 356         kfreeenv(value);
 357         return(1);
 358 }
 359
 360 /*
 361  * Boottime (static) kernel environment sysctl handler.
 362  */
 363 static int
 364 sysctl_kenv_boot(SYSCTL_HANDLER_ARGS)
 365 {
 366         int     *name = (int *)arg1;
 367         u_int   namelen = arg2;
 368         char    *cp;
 369         int     i, error;
 370
 371         if (kern_envp == NULL)
 372                 return(ENOENT);
 373
 374         name++;
 375         namelen--;
 376
 377         if (namelen != 1)
 378                 return(EINVAL);
 379
 380         cp = kern_envp;
 381         for (i = 0; i < name[0]; i++) {
 382                 cp = kernenv_next(cp);
 383                 if (cp == NULL)
 384                         break;
 385         }
 386
 387         if (cp == NULL)
 388                 return(ENOENT);
 389
 390         error = SYSCTL_OUT(req, cp, strlen(cp) + 1);
 391         return (error);
 392 }
 393
 394 SYSCTL_NODE(_kern, OID_AUTO, environment, CTLFLAG_RD, sysctl_kenv_boot,
 395             "boottime (static) kernel  environment space");
 396
 397 /*
 398  * Find the next entry after the one which (cp) falls within, return a
 399  * pointer to its start or NULL if there are no more.
 400  */
 401 static char *
 402 kernenv_next(char *cp)
 403 {
 404         if (cp != NULL) {
 405                 while (*cp != 0)
 406                         cp++;
 407                 cp++;
 408                 if (*cp == 0)
 409                         cp = NULL;
 410         }
 411         return(cp);
 412 }
 413
 414 /*
 415  * TUNABLE_INT init functions.
 416  */
 417 void
 418 tunable_int_init(void *data)
 419 {
 420         struct tunable_int *d = (struct tunable_int *)data;
 421
 422         TUNABLE_INT_FETCH(d->path, d->var);
 423 }
 424
 425 void
 426 tunable_long_init(void *data)
 427 {
 428         struct tunable_long *d = (struct tunable_long *)data;
 429
 430         TUNABLE_LONG_FETCH(d->path, d->var);
 431 }
 432
 433 void
 434 tunable_ulong_init(void *data)
 435 {
 436         struct tunable_ulong *d = (struct tunable_ulong *)data;
 437
 438         TUNABLE_ULONG_FETCH(d->path, d->var);
 439 }
 440
 441 void
 442 tunable_quad_init(void *data)
 443 {
 444         struct tunable_quad *d = (struct tunable_quad *)data;
 445
 446         TUNABLE_QUAD_FETCH(d->path, d->var);
 447 }
 448
 449 void
 450 tunable_str_init(void *data)
 451 {
 452         struct tunable_str *d = (struct tunable_str *)data;
 453
 454         TUNABLE_STR_FETCH(d->path, d->var, d->size);
 455 }
 456
 457 /*
 458  * Create the dynamic environment array, and copy in the values from the static
 459  * environment as passed by the bootloader.
 460  */
 461 static void
 462 kenv_init(void *dummy)
 463 {
 464         char    *cp;
 465         int     len, i;
 466
 467         kenv_dynp = kmalloc(KENV_DYNMAXNUM * sizeof(char *), M_KENV,
 468                             M_WAITOK | M_ZERO);
 469
 470         /* copy the static environment to our dynamic environment */
 471         for (i = 0, cp = kern_envp; cp != NULL; cp = kernenv_next(cp)) {
 472                 len = strlen(cp) + 1;
 473                 if (i < (KENV_DYNMAXNUM - 1)) {
 474                         kenv_dynp[i] = kmalloc(len, M_KENV, M_WAITOK);
 475                         strcpy(kenv_dynp[i++], cp);
 476                 } else
 477                         kprintf("WARNING: kenv: exhausted dynamic storage, "
 478                                 "ignoring string %s\n", cp);
 479         }
 480         kenv_dynp[i] = NULL;
 481
 482         spin_init(&kenv_dynlock);
 483         kenv_isdynamic = 1;
 484 }
 485 SYSINIT(kenv, SI_BOOT1_POST, SI_ORDER_ANY, kenv_init, NULL);