kern_environment.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) 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);
Cache object: de0377a9d7ae3021df999129c5208f79
[ 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.
FreeBSD/Linux Kernel Cross Reference sys/kern/kern_environment.c

FreeBSD/Linux Kernel Cross Reference
sys/kern/kern_environment.c
