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