xref: /dragonfly/sys/kern/kern_environment.c (revision 6693db17) 
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.7 2008/07/23 16:39:28 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 long value from an environment variable.
285  */
286 int
287 kgetenv_long(const char *name, long *data)
288 {
289 	quad_t tmp;
290 	int rval;
291 
292 	rval = kgetenv_quad(name, &tmp);
293 	if (rval)
294 		*data = (long)tmp;
295 	return (rval);
296 }
297 
298 /*
299  * Return an unsigned long value from an environment variable.
300  */
301 int
302 kgetenv_ulong(const char *name, unsigned long *data)
303 {
304 	quad_t tmp;
305 	int rval;
306 
307 	rval = kgetenv_quad(name, &tmp);
308 	if (rval)
309 		*data = (unsigned long) tmp;
310 	return (rval);
311 }
312 
313 /*
314  * Return a quad_t value from an environment variable.
315  *
316  * A single character kmgtKMGT extension multiplies the value
317  * by 1024, 1024*1024, etc.
318  */
319 int
320 kgetenv_quad(const char *name, quad_t *data)
321 {
322 	char*	value;
323 	char*	vtp;
324 	quad_t	iv;
325 
326 	if ((value = kgetenv(name)) == NULL)
327 		return(0);
328 
329 	iv = strtoq(value, &vtp, 0);
330 	switch(*vtp) {
331 	case 't':
332 	case 'T':
333 		iv <<= 10;
334 		/* fall through */
335 	case 'g':
336 	case 'G':
337 		iv <<= 10;
338 		/* fall through */
339 	case 'm':
340 	case 'M':
341 		iv <<= 10;
342 		/* fall through */
343 	case 'k':
344 	case 'K':
345 		iv <<= 10;
346 		++vtp;
347 		break;
348 	default:
349 		break;
350 	}
351 
352 	if ((vtp == value) || (*vtp != '\0')) {
353 		kfreeenv(value);
354 		return(0);
355 	}
356 
357 	*data = iv;
358 	kfreeenv(value);
359 	return(1);
360 }
361 
362 /*
363  * Boottime (static) kernel environment sysctl handler.
364  */
365 static int
366 sysctl_kenv_boot(SYSCTL_HANDLER_ARGS)
367 {
368 	int	*name = (int *)arg1;
369 	u_int	namelen = arg2;
370 	char	*cp;
371 	int	i, error;
372 
373 	if (kern_envp == NULL)
374 		return(ENOENT);
375 
376 	name++;
377 	namelen--;
378 
379 	if (namelen != 1)
380 		return(EINVAL);
381 
382 	cp = kern_envp;
383 	for (i = 0; i < name[0]; i++) {
384 		cp = kernenv_next(cp);
385 		if (cp == NULL)
386 			break;
387 	}
388 
389 	if (cp == NULL)
390 		return(ENOENT);
391 
392 	error = SYSCTL_OUT(req, cp, strlen(cp) + 1);
393 	return (error);
394 }
395 
396 SYSCTL_NODE(_kern, OID_AUTO, environment, CTLFLAG_RD, sysctl_kenv_boot,
397 	    "boottime (static) kernel  environment space");
398 
399 /*
400  * Find the next entry after the one which (cp) falls within, return a
401  * pointer to its start or NULL if there are no more.
402  */
403 static char *
404 kernenv_next(char *cp)
405 {
406 	if (cp != NULL) {
407 		while (*cp != 0)
408 			cp++;
409 		cp++;
410 		if (*cp == 0)
411 			cp = NULL;
412 	}
413 	return(cp);
414 }
415 
416 /*
417  * TUNABLE_INT init functions.
418  */
419 void
420 tunable_int_init(void *data)
421 {
422 	struct tunable_int *d = (struct tunable_int *)data;
423 
424 	TUNABLE_INT_FETCH(d->path, d->var);
425 }
426 
427 void
428 tunable_quad_init(void *data)
429 {
430 	struct tunable_quad *d = (struct tunable_quad *)data;
431 
432 	TUNABLE_QUAD_FETCH(d->path, d->var);
433 }
434 
435 void
436 tunable_str_init(void *data)
437 {
438 	struct tunable_str *d = (struct tunable_str *)data;
439 
440 	TUNABLE_STR_FETCH(d->path, d->var, d->size);
441 }
442 
443 /*
444  * Create the dynamic environment array, and copy in the values from the static
445  * environment as passed by the bootloader.
446  */
447 static void
448 kenv_init(void *dummy)
449 {
450 	char	*cp;
451 	int	len, i;
452 
453 	kenv_dynp = kmalloc(KENV_DYNMAXNUM * sizeof(char *), M_KENV,
454 			    M_WAITOK | M_ZERO);
455 
456 	/* copy the static environment to our dynamic environment */
457 	for (i = 0, cp = kern_envp; cp != NULL; cp = kernenv_next(cp)) {
458 		len = strlen(cp) + 1;
459 		if (i < (KENV_DYNMAXNUM - 1)) {
460 			kenv_dynp[i] = kmalloc(len, M_KENV, M_WAITOK);
461 			strcpy(kenv_dynp[i++], cp);
462 		} else
463 			kprintf("WARNING: kenv: exhausted dynamic storage, "
464 				"ignoring string %s\n", cp);
465 	}
466 	kenv_dynp[i] = NULL;
467 
468 	spin_init(&kenv_dynlock);
469 	kenv_isdynamic = 1;
470 }
471 SYSINIT(kenv, SI_BOOT1_POST, SI_ORDER_ANY, kenv_init, NULL);
472