xref: /freebsd/sys/kern/kern_sysctl.c (revision 076ad2f836d5f49dc1375f1677335a48fe0d4b82)
1 /*-
2  * Copyright (c) 1982, 1986, 1989, 1993
3  *	The Regents of the University of California.  All rights reserved.
4  *
5  * This code is derived from software contributed to Berkeley by
6  * Mike Karels at Berkeley Software Design, Inc.
7  *
8  * Quite extensively rewritten by Poul-Henning Kamp of the FreeBSD
9  * project, to make these variables more userfriendly.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  * 3. Neither the name of the University nor the names of its contributors
20  *    may be used to endorse or promote products derived from this software
21  *    without specific prior written permission.
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33  * SUCH DAMAGE.
34  *
35  *	@(#)kern_sysctl.c	8.4 (Berkeley) 4/14/94
36  */
37 
38 #include <sys/cdefs.h>
39 __FBSDID("$FreeBSD$");
40 
41 #include "opt_capsicum.h"
42 #include "opt_compat.h"
43 #include "opt_ktrace.h"
44 
45 #include <sys/param.h>
46 #include <sys/fail.h>
47 #include <sys/systm.h>
48 #include <sys/capsicum.h>
49 #include <sys/kernel.h>
50 #include <sys/sysctl.h>
51 #include <sys/malloc.h>
52 #include <sys/priv.h>
53 #include <sys/proc.h>
54 #include <sys/jail.h>
55 #include <sys/lock.h>
56 #include <sys/mutex.h>
57 #include <sys/rmlock.h>
58 #include <sys/sbuf.h>
59 #include <sys/sx.h>
60 #include <sys/sysproto.h>
61 #include <sys/uio.h>
62 #ifdef KTRACE
63 #include <sys/ktrace.h>
64 #endif
65 
66 #include <net/vnet.h>
67 
68 #include <security/mac/mac_framework.h>
69 
70 #include <vm/vm.h>
71 #include <vm/vm_extern.h>
72 
73 static MALLOC_DEFINE(M_SYSCTL, "sysctl", "sysctl internal magic");
74 static MALLOC_DEFINE(M_SYSCTLOID, "sysctloid", "sysctl dynamic oids");
75 static MALLOC_DEFINE(M_SYSCTLTMP, "sysctltmp", "sysctl temp output buffer");
76 
77 /*
78  * The sysctllock protects the MIB tree.  It also protects sysctl
79  * contexts used with dynamic sysctls.  The sysctl_register_oid() and
80  * sysctl_unregister_oid() routines require the sysctllock to already
81  * be held, so the sysctl_wlock() and sysctl_wunlock() routines are
82  * provided for the few places in the kernel which need to use that
83  * API rather than using the dynamic API.  Use of the dynamic API is
84  * strongly encouraged for most code.
85  *
86  * The sysctlmemlock is used to limit the amount of user memory wired for
87  * sysctl requests.  This is implemented by serializing any userland
88  * sysctl requests larger than a single page via an exclusive lock.
89  */
90 static struct rmlock sysctllock;
91 static struct sx sysctlmemlock;
92 
93 #define	SYSCTL_WLOCK()		rm_wlock(&sysctllock)
94 #define	SYSCTL_WUNLOCK()	rm_wunlock(&sysctllock)
95 #define	SYSCTL_RLOCK(tracker)	rm_rlock(&sysctllock, (tracker))
96 #define	SYSCTL_RUNLOCK(tracker)	rm_runlock(&sysctllock, (tracker))
97 #define	SYSCTL_WLOCKED()	rm_wowned(&sysctllock)
98 #define	SYSCTL_ASSERT_LOCKED()	rm_assert(&sysctllock, RA_LOCKED)
99 #define	SYSCTL_ASSERT_WLOCKED()	rm_assert(&sysctllock, RA_WLOCKED)
100 #define	SYSCTL_ASSERT_RLOCKED()	rm_assert(&sysctllock, RA_RLOCKED)
101 #define	SYSCTL_INIT()		rm_init_flags(&sysctllock, "sysctl lock", \
102 				    RM_SLEEPABLE)
103 #define	SYSCTL_SLEEP(ch, wmesg, timo)					\
104 				rm_sleep(ch, &sysctllock, 0, wmesg, timo)
105 
106 static int sysctl_root(SYSCTL_HANDLER_ARGS);
107 
108 /* Root list */
109 struct sysctl_oid_list sysctl__children = SLIST_HEAD_INITIALIZER(&sysctl__children);
110 
111 static int	sysctl_remove_oid_locked(struct sysctl_oid *oidp, int del,
112 		    int recurse);
113 static int	sysctl_old_kernel(struct sysctl_req *, const void *, size_t);
114 static int	sysctl_new_kernel(struct sysctl_req *, void *, size_t);
115 
116 static struct sysctl_oid *
117 sysctl_find_oidname(const char *name, struct sysctl_oid_list *list)
118 {
119 	struct sysctl_oid *oidp;
120 
121 	SYSCTL_ASSERT_LOCKED();
122 	SLIST_FOREACH(oidp, list, oid_link) {
123 		if (strcmp(oidp->oid_name, name) == 0) {
124 			return (oidp);
125 		}
126 	}
127 	return (NULL);
128 }
129 
130 /*
131  * Initialization of the MIB tree.
132  *
133  * Order by number in each list.
134  */
135 void
136 sysctl_wlock(void)
137 {
138 
139 	SYSCTL_WLOCK();
140 }
141 
142 void
143 sysctl_wunlock(void)
144 {
145 
146 	SYSCTL_WUNLOCK();
147 }
148 
149 static int
150 sysctl_root_handler_locked(struct sysctl_oid *oid, void *arg1, intmax_t arg2,
151     struct sysctl_req *req, struct rm_priotracker *tracker)
152 {
153 	int error;
154 
155 	if (oid->oid_kind & CTLFLAG_DYN)
156 		atomic_add_int(&oid->oid_running, 1);
157 
158 	if (tracker != NULL)
159 		SYSCTL_RUNLOCK(tracker);
160 	else
161 		SYSCTL_WUNLOCK();
162 
163 	if (!(oid->oid_kind & CTLFLAG_MPSAFE))
164 		mtx_lock(&Giant);
165 	error = oid->oid_handler(oid, arg1, arg2, req);
166 	if (!(oid->oid_kind & CTLFLAG_MPSAFE))
167 		mtx_unlock(&Giant);
168 
169 	KFAIL_POINT_ERROR(_debug_fail_point, sysctl_running, error);
170 
171 	if (tracker != NULL)
172 		SYSCTL_RLOCK(tracker);
173 	else
174 		SYSCTL_WLOCK();
175 
176 	if (oid->oid_kind & CTLFLAG_DYN) {
177 		if (atomic_fetchadd_int(&oid->oid_running, -1) == 1 &&
178 		    (oid->oid_kind & CTLFLAG_DYING) != 0)
179 			wakeup(&oid->oid_running);
180 	}
181 
182 	return (error);
183 }
184 
185 static void
186 sysctl_load_tunable_by_oid_locked(struct sysctl_oid *oidp)
187 {
188 	struct sysctl_req req;
189 	struct sysctl_oid *curr;
190 	char *penv = NULL;
191 	char path[64];
192 	ssize_t rem = sizeof(path);
193 	ssize_t len;
194 	uint8_t val_8;
195 	uint16_t val_16;
196 	uint32_t val_32;
197 	int val_int;
198 	long val_long;
199 	int64_t val_64;
200 	quad_t val_quad;
201 	int error;
202 
203 	path[--rem] = 0;
204 
205 	for (curr = oidp; curr != NULL; curr = SYSCTL_PARENT(curr)) {
206 		len = strlen(curr->oid_name);
207 		rem -= len;
208 		if (curr != oidp)
209 			rem -= 1;
210 		if (rem < 0) {
211 			printf("OID path exceeds %d bytes\n", (int)sizeof(path));
212 			return;
213 		}
214 		memcpy(path + rem, curr->oid_name, len);
215 		if (curr != oidp)
216 			path[rem + len] = '.';
217 	}
218 
219 	memset(&req, 0, sizeof(req));
220 
221 	req.td = curthread;
222 	req.oldfunc = sysctl_old_kernel;
223 	req.newfunc = sysctl_new_kernel;
224 	req.lock = REQ_UNWIRED;
225 
226 	switch (oidp->oid_kind & CTLTYPE) {
227 	case CTLTYPE_INT:
228 		if (getenv_int(path + rem, &val_int) == 0)
229 			return;
230 		req.newlen = sizeof(val_int);
231 		req.newptr = &val_int;
232 		break;
233 	case CTLTYPE_UINT:
234 		if (getenv_uint(path + rem, (unsigned int *)&val_int) == 0)
235 			return;
236 		req.newlen = sizeof(val_int);
237 		req.newptr = &val_int;
238 		break;
239 	case CTLTYPE_LONG:
240 		if (getenv_long(path + rem, &val_long) == 0)
241 			return;
242 		req.newlen = sizeof(val_long);
243 		req.newptr = &val_long;
244 		break;
245 	case CTLTYPE_ULONG:
246 		if (getenv_ulong(path + rem, (unsigned long *)&val_long) == 0)
247 			return;
248 		req.newlen = sizeof(val_long);
249 		req.newptr = &val_long;
250 		break;
251 	case CTLTYPE_S8:
252 		if (getenv_int(path + rem, &val_int) == 0)
253 			return;
254 		val_8 = val_int;
255 		req.newlen = sizeof(val_8);
256 		req.newptr = &val_8;
257 		break;
258 	case CTLTYPE_S16:
259 		if (getenv_int(path + rem, &val_int) == 0)
260 			return;
261 		val_16 = val_int;
262 		req.newlen = sizeof(val_16);
263 		req.newptr = &val_16;
264 		break;
265 	case CTLTYPE_S32:
266 		if (getenv_long(path + rem, &val_long) == 0)
267 			return;
268 		val_32 = val_long;
269 		req.newlen = sizeof(val_32);
270 		req.newptr = &val_32;
271 		break;
272 	case CTLTYPE_S64:
273 		if (getenv_quad(path + rem, &val_quad) == 0)
274 			return;
275 		val_64 = val_quad;
276 		req.newlen = sizeof(val_64);
277 		req.newptr = &val_64;
278 		break;
279 	case CTLTYPE_U8:
280 		if (getenv_uint(path + rem, (unsigned int *)&val_int) == 0)
281 			return;
282 		val_8 = val_int;
283 		req.newlen = sizeof(val_8);
284 		req.newptr = &val_8;
285 		break;
286 	case CTLTYPE_U16:
287 		if (getenv_uint(path + rem, (unsigned int *)&val_int) == 0)
288 			return;
289 		val_16 = val_int;
290 		req.newlen = sizeof(val_16);
291 		req.newptr = &val_16;
292 		break;
293 	case CTLTYPE_U32:
294 		if (getenv_ulong(path + rem, (unsigned long *)&val_long) == 0)
295 			return;
296 		val_32 = val_long;
297 		req.newlen = sizeof(val_32);
298 		req.newptr = &val_32;
299 		break;
300 	case CTLTYPE_U64:
301 		/* XXX there is no getenv_uquad() */
302 		if (getenv_quad(path + rem, &val_quad) == 0)
303 			return;
304 		val_64 = val_quad;
305 		req.newlen = sizeof(val_64);
306 		req.newptr = &val_64;
307 		break;
308 	case CTLTYPE_STRING:
309 		penv = kern_getenv(path + rem);
310 		if (penv == NULL)
311 			return;
312 		req.newlen = strlen(penv);
313 		req.newptr = penv;
314 		break;
315 	default:
316 		return;
317 	}
318 	error = sysctl_root_handler_locked(oidp, oidp->oid_arg1,
319 	    oidp->oid_arg2, &req, NULL);
320 	if (error != 0)
321 		printf("Setting sysctl %s failed: %d\n", path + rem, error);
322 	if (penv != NULL)
323 		freeenv(penv);
324 }
325 
326 void
327 sysctl_register_oid(struct sysctl_oid *oidp)
328 {
329 	struct sysctl_oid_list *parent = oidp->oid_parent;
330 	struct sysctl_oid *p;
331 	struct sysctl_oid *q;
332 	int oid_number;
333 	int timeout = 2;
334 
335 	/*
336 	 * First check if another oid with the same name already
337 	 * exists in the parent's list.
338 	 */
339 	SYSCTL_ASSERT_WLOCKED();
340 	p = sysctl_find_oidname(oidp->oid_name, parent);
341 	if (p != NULL) {
342 		if ((p->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
343 			p->oid_refcnt++;
344 			return;
345 		} else {
346 			printf("can't re-use a leaf (%s)!\n", p->oid_name);
347 			return;
348 		}
349 	}
350 	/* get current OID number */
351 	oid_number = oidp->oid_number;
352 
353 #if (OID_AUTO >= 0)
354 #error "OID_AUTO is expected to be a negative value"
355 #endif
356 	/*
357 	 * Any negative OID number qualifies as OID_AUTO. Valid OID
358 	 * numbers should always be positive.
359 	 *
360 	 * NOTE: DO NOT change the starting value here, change it in
361 	 * <sys/sysctl.h>, and make sure it is at least 256 to
362 	 * accommodate e.g. net.inet.raw as a static sysctl node.
363 	 */
364 	if (oid_number < 0) {
365 		static int newoid;
366 
367 		/*
368 		 * By decrementing the next OID number we spend less
369 		 * time inserting the OIDs into a sorted list.
370 		 */
371 		if (--newoid < CTL_AUTO_START)
372 			newoid = 0x7fffffff;
373 
374 		oid_number = newoid;
375 	}
376 
377 	/*
378 	 * Insert the OID into the parent's list sorted by OID number.
379 	 */
380 retry:
381 	q = NULL;
382 	SLIST_FOREACH(p, parent, oid_link) {
383 		/* check if the current OID number is in use */
384 		if (oid_number == p->oid_number) {
385 			/* get the next valid OID number */
386 			if (oid_number < CTL_AUTO_START ||
387 			    oid_number == 0x7fffffff) {
388 				/* wraparound - restart */
389 				oid_number = CTL_AUTO_START;
390 				/* don't loop forever */
391 				if (!timeout--)
392 					panic("sysctl: Out of OID numbers\n");
393 				goto retry;
394 			} else {
395 				oid_number++;
396 			}
397 		} else if (oid_number < p->oid_number)
398 			break;
399 		q = p;
400 	}
401 	/* check for non-auto OID number collision */
402 	if (oidp->oid_number >= 0 && oidp->oid_number < CTL_AUTO_START &&
403 	    oid_number >= CTL_AUTO_START) {
404 		printf("sysctl: OID number(%d) is already in use for '%s'\n",
405 		    oidp->oid_number, oidp->oid_name);
406 	}
407 	/* update the OID number, if any */
408 	oidp->oid_number = oid_number;
409 	if (q != NULL)
410 		SLIST_INSERT_AFTER(q, oidp, oid_link);
411 	else
412 		SLIST_INSERT_HEAD(parent, oidp, oid_link);
413 
414 	if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE &&
415 #ifdef VIMAGE
416 	    (oidp->oid_kind & CTLFLAG_VNET) == 0 &&
417 #endif
418 	    (oidp->oid_kind & CTLFLAG_TUN) != 0 &&
419 	    (oidp->oid_kind & CTLFLAG_NOFETCH) == 0) {
420 		/* only fetch value once */
421 		oidp->oid_kind |= CTLFLAG_NOFETCH;
422 		/* try to fetch value from kernel environment */
423 		sysctl_load_tunable_by_oid_locked(oidp);
424 	}
425 }
426 
427 void
428 sysctl_unregister_oid(struct sysctl_oid *oidp)
429 {
430 	struct sysctl_oid *p;
431 	int error;
432 
433 	SYSCTL_ASSERT_WLOCKED();
434 	error = ENOENT;
435 	if (oidp->oid_number == OID_AUTO) {
436 		error = EINVAL;
437 	} else {
438 		SLIST_FOREACH(p, oidp->oid_parent, oid_link) {
439 			if (p == oidp) {
440 				SLIST_REMOVE(oidp->oid_parent, oidp,
441 				    sysctl_oid, oid_link);
442 				error = 0;
443 				break;
444 			}
445 		}
446 	}
447 
448 	/*
449 	 * This can happen when a module fails to register and is
450 	 * being unloaded afterwards.  It should not be a panic()
451 	 * for normal use.
452 	 */
453 	if (error)
454 		printf("%s: failed to unregister sysctl\n", __func__);
455 }
456 
457 /* Initialize a new context to keep track of dynamically added sysctls. */
458 int
459 sysctl_ctx_init(struct sysctl_ctx_list *c)
460 {
461 
462 	if (c == NULL) {
463 		return (EINVAL);
464 	}
465 
466 	/*
467 	 * No locking here, the caller is responsible for not adding
468 	 * new nodes to a context until after this function has
469 	 * returned.
470 	 */
471 	TAILQ_INIT(c);
472 	return (0);
473 }
474 
475 /* Free the context, and destroy all dynamic oids registered in this context */
476 int
477 sysctl_ctx_free(struct sysctl_ctx_list *clist)
478 {
479 	struct sysctl_ctx_entry *e, *e1;
480 	int error;
481 
482 	error = 0;
483 	/*
484 	 * First perform a "dry run" to check if it's ok to remove oids.
485 	 * XXX FIXME
486 	 * XXX This algorithm is a hack. But I don't know any
487 	 * XXX better solution for now...
488 	 */
489 	SYSCTL_WLOCK();
490 	TAILQ_FOREACH(e, clist, link) {
491 		error = sysctl_remove_oid_locked(e->entry, 0, 0);
492 		if (error)
493 			break;
494 	}
495 	/*
496 	 * Restore deregistered entries, either from the end,
497 	 * or from the place where error occurred.
498 	 * e contains the entry that was not unregistered
499 	 */
500 	if (error)
501 		e1 = TAILQ_PREV(e, sysctl_ctx_list, link);
502 	else
503 		e1 = TAILQ_LAST(clist, sysctl_ctx_list);
504 	while (e1 != NULL) {
505 		sysctl_register_oid(e1->entry);
506 		e1 = TAILQ_PREV(e1, sysctl_ctx_list, link);
507 	}
508 	if (error) {
509 		SYSCTL_WUNLOCK();
510 		return(EBUSY);
511 	}
512 	/* Now really delete the entries */
513 	e = TAILQ_FIRST(clist);
514 	while (e != NULL) {
515 		e1 = TAILQ_NEXT(e, link);
516 		error = sysctl_remove_oid_locked(e->entry, 1, 0);
517 		if (error)
518 			panic("sysctl_remove_oid: corrupt tree, entry: %s",
519 			    e->entry->oid_name);
520 		free(e, M_SYSCTLOID);
521 		e = e1;
522 	}
523 	SYSCTL_WUNLOCK();
524 	return (error);
525 }
526 
527 /* Add an entry to the context */
528 struct sysctl_ctx_entry *
529 sysctl_ctx_entry_add(struct sysctl_ctx_list *clist, struct sysctl_oid *oidp)
530 {
531 	struct sysctl_ctx_entry *e;
532 
533 	SYSCTL_ASSERT_WLOCKED();
534 	if (clist == NULL || oidp == NULL)
535 		return(NULL);
536 	e = malloc(sizeof(struct sysctl_ctx_entry), M_SYSCTLOID, M_WAITOK);
537 	e->entry = oidp;
538 	TAILQ_INSERT_HEAD(clist, e, link);
539 	return (e);
540 }
541 
542 /* Find an entry in the context */
543 struct sysctl_ctx_entry *
544 sysctl_ctx_entry_find(struct sysctl_ctx_list *clist, struct sysctl_oid *oidp)
545 {
546 	struct sysctl_ctx_entry *e;
547 
548 	SYSCTL_ASSERT_WLOCKED();
549 	if (clist == NULL || oidp == NULL)
550 		return(NULL);
551 	TAILQ_FOREACH(e, clist, link) {
552 		if(e->entry == oidp)
553 			return(e);
554 	}
555 	return (e);
556 }
557 
558 /*
559  * Delete an entry from the context.
560  * NOTE: this function doesn't free oidp! You have to remove it
561  * with sysctl_remove_oid().
562  */
563 int
564 sysctl_ctx_entry_del(struct sysctl_ctx_list *clist, struct sysctl_oid *oidp)
565 {
566 	struct sysctl_ctx_entry *e;
567 
568 	if (clist == NULL || oidp == NULL)
569 		return (EINVAL);
570 	SYSCTL_WLOCK();
571 	e = sysctl_ctx_entry_find(clist, oidp);
572 	if (e != NULL) {
573 		TAILQ_REMOVE(clist, e, link);
574 		SYSCTL_WUNLOCK();
575 		free(e, M_SYSCTLOID);
576 		return (0);
577 	} else {
578 		SYSCTL_WUNLOCK();
579 		return (ENOENT);
580 	}
581 }
582 
583 /*
584  * Remove dynamically created sysctl trees.
585  * oidp - top of the tree to be removed
586  * del - if 0 - just deregister, otherwise free up entries as well
587  * recurse - if != 0 traverse the subtree to be deleted
588  */
589 int
590 sysctl_remove_oid(struct sysctl_oid *oidp, int del, int recurse)
591 {
592 	int error;
593 
594 	SYSCTL_WLOCK();
595 	error = sysctl_remove_oid_locked(oidp, del, recurse);
596 	SYSCTL_WUNLOCK();
597 	return (error);
598 }
599 
600 int
601 sysctl_remove_name(struct sysctl_oid *parent, const char *name,
602     int del, int recurse)
603 {
604 	struct sysctl_oid *p, *tmp;
605 	int error;
606 
607 	error = ENOENT;
608 	SYSCTL_WLOCK();
609 	SLIST_FOREACH_SAFE(p, SYSCTL_CHILDREN(parent), oid_link, tmp) {
610 		if (strcmp(p->oid_name, name) == 0) {
611 			error = sysctl_remove_oid_locked(p, del, recurse);
612 			break;
613 		}
614 	}
615 	SYSCTL_WUNLOCK();
616 
617 	return (error);
618 }
619 
620 
621 static int
622 sysctl_remove_oid_locked(struct sysctl_oid *oidp, int del, int recurse)
623 {
624 	struct sysctl_oid *p, *tmp;
625 	int error;
626 
627 	SYSCTL_ASSERT_WLOCKED();
628 	if (oidp == NULL)
629 		return(EINVAL);
630 	if ((oidp->oid_kind & CTLFLAG_DYN) == 0) {
631 		printf("can't remove non-dynamic nodes!\n");
632 		return (EINVAL);
633 	}
634 	/*
635 	 * WARNING: normal method to do this should be through
636 	 * sysctl_ctx_free(). Use recursing as the last resort
637 	 * method to purge your sysctl tree of leftovers...
638 	 * However, if some other code still references these nodes,
639 	 * it will panic.
640 	 */
641 	if ((oidp->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
642 		if (oidp->oid_refcnt == 1) {
643 			SLIST_FOREACH_SAFE(p,
644 			    SYSCTL_CHILDREN(oidp), oid_link, tmp) {
645 				if (!recurse) {
646 					printf("Warning: failed attempt to "
647 					    "remove oid %s with child %s\n",
648 					    oidp->oid_name, p->oid_name);
649 					return (ENOTEMPTY);
650 				}
651 				error = sysctl_remove_oid_locked(p, del,
652 				    recurse);
653 				if (error)
654 					return (error);
655 			}
656 		}
657 	}
658 	if (oidp->oid_refcnt > 1 ) {
659 		oidp->oid_refcnt--;
660 	} else {
661 		if (oidp->oid_refcnt == 0) {
662 			printf("Warning: bad oid_refcnt=%u (%s)!\n",
663 				oidp->oid_refcnt, oidp->oid_name);
664 			return (EINVAL);
665 		}
666 		sysctl_unregister_oid(oidp);
667 		if (del) {
668 			/*
669 			 * Wait for all threads running the handler to drain.
670 			 * This preserves the previous behavior when the
671 			 * sysctl lock was held across a handler invocation,
672 			 * and is necessary for module unload correctness.
673 			 */
674 			while (oidp->oid_running > 0) {
675 				oidp->oid_kind |= CTLFLAG_DYING;
676 				SYSCTL_SLEEP(&oidp->oid_running, "oidrm", 0);
677 			}
678 			if (oidp->oid_descr)
679 				free(__DECONST(char *, oidp->oid_descr),
680 				    M_SYSCTLOID);
681 			if (oidp->oid_label)
682 				free(__DECONST(char *, oidp->oid_label),
683 				    M_SYSCTLOID);
684 			free(__DECONST(char *, oidp->oid_name), M_SYSCTLOID);
685 			free(oidp, M_SYSCTLOID);
686 		}
687 	}
688 	return (0);
689 }
690 /*
691  * Create new sysctls at run time.
692  * clist may point to a valid context initialized with sysctl_ctx_init().
693  */
694 struct sysctl_oid *
695 sysctl_add_oid(struct sysctl_ctx_list *clist, struct sysctl_oid_list *parent,
696 	int number, const char *name, int kind, void *arg1, intmax_t arg2,
697 	int (*handler)(SYSCTL_HANDLER_ARGS), const char *fmt, const char *descr,
698 	const char *label)
699 {
700 	struct sysctl_oid *oidp;
701 
702 	/* You have to hook up somewhere.. */
703 	if (parent == NULL)
704 		return(NULL);
705 	/* Check if the node already exists, otherwise create it */
706 	SYSCTL_WLOCK();
707 	oidp = sysctl_find_oidname(name, parent);
708 	if (oidp != NULL) {
709 		if ((oidp->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
710 			oidp->oid_refcnt++;
711 			/* Update the context */
712 			if (clist != NULL)
713 				sysctl_ctx_entry_add(clist, oidp);
714 			SYSCTL_WUNLOCK();
715 			return (oidp);
716 		} else {
717 			SYSCTL_WUNLOCK();
718 			printf("can't re-use a leaf (%s)!\n", name);
719 			return (NULL);
720 		}
721 	}
722 	oidp = malloc(sizeof(struct sysctl_oid), M_SYSCTLOID, M_WAITOK|M_ZERO);
723 	oidp->oid_parent = parent;
724 	SLIST_INIT(&oidp->oid_children);
725 	oidp->oid_number = number;
726 	oidp->oid_refcnt = 1;
727 	oidp->oid_name = strdup(name, M_SYSCTLOID);
728 	oidp->oid_handler = handler;
729 	oidp->oid_kind = CTLFLAG_DYN | kind;
730 	oidp->oid_arg1 = arg1;
731 	oidp->oid_arg2 = arg2;
732 	oidp->oid_fmt = fmt;
733 	if (descr != NULL)
734 		oidp->oid_descr = strdup(descr, M_SYSCTLOID);
735 	if (label != NULL)
736 		oidp->oid_label = strdup(label, M_SYSCTLOID);
737 	/* Update the context, if used */
738 	if (clist != NULL)
739 		sysctl_ctx_entry_add(clist, oidp);
740 	/* Register this oid */
741 	sysctl_register_oid(oidp);
742 	SYSCTL_WUNLOCK();
743 	return (oidp);
744 }
745 
746 /*
747  * Rename an existing oid.
748  */
749 void
750 sysctl_rename_oid(struct sysctl_oid *oidp, const char *name)
751 {
752 	char *newname;
753 	char *oldname;
754 
755 	newname = strdup(name, M_SYSCTLOID);
756 	SYSCTL_WLOCK();
757 	oldname = __DECONST(char *, oidp->oid_name);
758 	oidp->oid_name = newname;
759 	SYSCTL_WUNLOCK();
760 	free(oldname, M_SYSCTLOID);
761 }
762 
763 /*
764  * Reparent an existing oid.
765  */
766 int
767 sysctl_move_oid(struct sysctl_oid *oid, struct sysctl_oid_list *parent)
768 {
769 	struct sysctl_oid *oidp;
770 
771 	SYSCTL_WLOCK();
772 	if (oid->oid_parent == parent) {
773 		SYSCTL_WUNLOCK();
774 		return (0);
775 	}
776 	oidp = sysctl_find_oidname(oid->oid_name, parent);
777 	if (oidp != NULL) {
778 		SYSCTL_WUNLOCK();
779 		return (EEXIST);
780 	}
781 	sysctl_unregister_oid(oid);
782 	oid->oid_parent = parent;
783 	oid->oid_number = OID_AUTO;
784 	sysctl_register_oid(oid);
785 	SYSCTL_WUNLOCK();
786 	return (0);
787 }
788 
789 /*
790  * Register the kernel's oids on startup.
791  */
792 SET_DECLARE(sysctl_set, struct sysctl_oid);
793 
794 static void
795 sysctl_register_all(void *arg)
796 {
797 	struct sysctl_oid **oidp;
798 
799 	sx_init(&sysctlmemlock, "sysctl mem");
800 	SYSCTL_INIT();
801 	SYSCTL_WLOCK();
802 	SET_FOREACH(oidp, sysctl_set)
803 		sysctl_register_oid(*oidp);
804 	SYSCTL_WUNLOCK();
805 }
806 SYSINIT(sysctl, SI_SUB_KMEM, SI_ORDER_FIRST, sysctl_register_all, 0);
807 
808 /*
809  * "Staff-functions"
810  *
811  * These functions implement a presently undocumented interface
812  * used by the sysctl program to walk the tree, and get the type
813  * so it can print the value.
814  * This interface is under work and consideration, and should probably
815  * be killed with a big axe by the first person who can find the time.
816  * (be aware though, that the proper interface isn't as obvious as it
817  * may seem, there are various conflicting requirements.
818  *
819  * {0,0}	printf the entire MIB-tree.
820  * {0,1,...}	return the name of the "..." OID.
821  * {0,2,...}	return the next OID.
822  * {0,3}	return the OID of the name in "new"
823  * {0,4,...}	return the kind & format info for the "..." OID.
824  * {0,5,...}	return the description of the "..." OID.
825  * {0,6,...}	return the aggregation label of the "..." OID.
826  */
827 
828 #ifdef SYSCTL_DEBUG
829 static void
830 sysctl_sysctl_debug_dump_node(struct sysctl_oid_list *l, int i)
831 {
832 	int k;
833 	struct sysctl_oid *oidp;
834 
835 	SYSCTL_ASSERT_LOCKED();
836 	SLIST_FOREACH(oidp, l, oid_link) {
837 
838 		for (k=0; k<i; k++)
839 			printf(" ");
840 
841 		printf("%d %s ", oidp->oid_number, oidp->oid_name);
842 
843 		printf("%c%c",
844 			oidp->oid_kind & CTLFLAG_RD ? 'R':' ',
845 			oidp->oid_kind & CTLFLAG_WR ? 'W':' ');
846 
847 		if (oidp->oid_handler)
848 			printf(" *Handler");
849 
850 		switch (oidp->oid_kind & CTLTYPE) {
851 			case CTLTYPE_NODE:
852 				printf(" Node\n");
853 				if (!oidp->oid_handler) {
854 					sysctl_sysctl_debug_dump_node(
855 					    SYSCTL_CHILDREN(oidp), i + 2);
856 				}
857 				break;
858 			case CTLTYPE_INT:    printf(" Int\n"); break;
859 			case CTLTYPE_UINT:   printf(" u_int\n"); break;
860 			case CTLTYPE_LONG:   printf(" Long\n"); break;
861 			case CTLTYPE_ULONG:  printf(" u_long\n"); break;
862 			case CTLTYPE_STRING: printf(" String\n"); break;
863 			case CTLTYPE_S8:     printf(" int8_t\n"); break;
864 			case CTLTYPE_S16:    printf(" int16_t\n"); break;
865 			case CTLTYPE_S32:    printf(" int32_t\n"); break;
866 			case CTLTYPE_S64:    printf(" int64_t\n"); break;
867 			case CTLTYPE_U8:     printf(" uint8_t\n"); break;
868 			case CTLTYPE_U16:    printf(" uint16_t\n"); break;
869 			case CTLTYPE_U32:    printf(" uint32_t\n"); break;
870 			case CTLTYPE_U64:    printf(" uint64_t\n"); break;
871 			case CTLTYPE_OPAQUE: printf(" Opaque/struct\n"); break;
872 			default:	     printf("\n");
873 		}
874 
875 	}
876 }
877 
878 static int
879 sysctl_sysctl_debug(SYSCTL_HANDLER_ARGS)
880 {
881 	struct rm_priotracker tracker;
882 	int error;
883 
884 	error = priv_check(req->td, PRIV_SYSCTL_DEBUG);
885 	if (error)
886 		return (error);
887 	SYSCTL_RLOCK(&tracker);
888 	sysctl_sysctl_debug_dump_node(&sysctl__children, 0);
889 	SYSCTL_RUNLOCK(&tracker);
890 	return (ENOENT);
891 }
892 
893 SYSCTL_PROC(_sysctl, 0, debug, CTLTYPE_STRING|CTLFLAG_RD|CTLFLAG_MPSAFE,
894 	0, 0, sysctl_sysctl_debug, "-", "");
895 #endif
896 
897 static int
898 sysctl_sysctl_name(SYSCTL_HANDLER_ARGS)
899 {
900 	int *name = (int *) arg1;
901 	u_int namelen = arg2;
902 	int error = 0;
903 	struct sysctl_oid *oid;
904 	struct sysctl_oid_list *lsp = &sysctl__children, *lsp2;
905 	struct rm_priotracker tracker;
906 	char buf[10];
907 
908 	SYSCTL_RLOCK(&tracker);
909 	while (namelen) {
910 		if (!lsp) {
911 			snprintf(buf,sizeof(buf),"%d",*name);
912 			if (req->oldidx)
913 				error = SYSCTL_OUT(req, ".", 1);
914 			if (!error)
915 				error = SYSCTL_OUT(req, buf, strlen(buf));
916 			if (error)
917 				goto out;
918 			namelen--;
919 			name++;
920 			continue;
921 		}
922 		lsp2 = NULL;
923 		SLIST_FOREACH(oid, lsp, oid_link) {
924 			if (oid->oid_number != *name)
925 				continue;
926 
927 			if (req->oldidx)
928 				error = SYSCTL_OUT(req, ".", 1);
929 			if (!error)
930 				error = SYSCTL_OUT(req, oid->oid_name,
931 					strlen(oid->oid_name));
932 			if (error)
933 				goto out;
934 
935 			namelen--;
936 			name++;
937 
938 			if ((oid->oid_kind & CTLTYPE) != CTLTYPE_NODE)
939 				break;
940 
941 			if (oid->oid_handler)
942 				break;
943 
944 			lsp2 = SYSCTL_CHILDREN(oid);
945 			break;
946 		}
947 		lsp = lsp2;
948 	}
949 	error = SYSCTL_OUT(req, "", 1);
950  out:
951 	SYSCTL_RUNLOCK(&tracker);
952 	return (error);
953 }
954 
955 /*
956  * XXXRW/JA: Shouldn't return name data for nodes that we don't permit in
957  * capability mode.
958  */
959 static SYSCTL_NODE(_sysctl, 1, name, CTLFLAG_RD | CTLFLAG_MPSAFE | CTLFLAG_CAPRD,
960     sysctl_sysctl_name, "");
961 
962 static int
963 sysctl_sysctl_next_ls(struct sysctl_oid_list *lsp, int *name, u_int namelen,
964 	int *next, int *len, int level, struct sysctl_oid **oidpp)
965 {
966 	struct sysctl_oid *oidp;
967 
968 	SYSCTL_ASSERT_LOCKED();
969 	*len = level;
970 	SLIST_FOREACH(oidp, lsp, oid_link) {
971 		*next = oidp->oid_number;
972 		*oidpp = oidp;
973 
974 		if (oidp->oid_kind & CTLFLAG_SKIP)
975 			continue;
976 
977 		if (!namelen) {
978 			if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE)
979 				return (0);
980 			if (oidp->oid_handler)
981 				/* We really should call the handler here...*/
982 				return (0);
983 			lsp = SYSCTL_CHILDREN(oidp);
984 			if (!sysctl_sysctl_next_ls(lsp, 0, 0, next+1,
985 				len, level+1, oidpp))
986 				return (0);
987 			goto emptynode;
988 		}
989 
990 		if (oidp->oid_number < *name)
991 			continue;
992 
993 		if (oidp->oid_number > *name) {
994 			if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE)
995 				return (0);
996 			if (oidp->oid_handler)
997 				return (0);
998 			lsp = SYSCTL_CHILDREN(oidp);
999 			if (!sysctl_sysctl_next_ls(lsp, name+1, namelen-1,
1000 				next+1, len, level+1, oidpp))
1001 				return (0);
1002 			goto next;
1003 		}
1004 		if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE)
1005 			continue;
1006 
1007 		if (oidp->oid_handler)
1008 			continue;
1009 
1010 		lsp = SYSCTL_CHILDREN(oidp);
1011 		if (!sysctl_sysctl_next_ls(lsp, name+1, namelen-1, next+1,
1012 			len, level+1, oidpp))
1013 			return (0);
1014 	next:
1015 		namelen = 1;
1016 	emptynode:
1017 		*len = level;
1018 	}
1019 	return (1);
1020 }
1021 
1022 static int
1023 sysctl_sysctl_next(SYSCTL_HANDLER_ARGS)
1024 {
1025 	int *name = (int *) arg1;
1026 	u_int namelen = arg2;
1027 	int i, j, error;
1028 	struct sysctl_oid *oid;
1029 	struct sysctl_oid_list *lsp = &sysctl__children;
1030 	struct rm_priotracker tracker;
1031 	int newoid[CTL_MAXNAME];
1032 
1033 	SYSCTL_RLOCK(&tracker);
1034 	i = sysctl_sysctl_next_ls(lsp, name, namelen, newoid, &j, 1, &oid);
1035 	SYSCTL_RUNLOCK(&tracker);
1036 	if (i)
1037 		return (ENOENT);
1038 	error = SYSCTL_OUT(req, newoid, j * sizeof (int));
1039 	return (error);
1040 }
1041 
1042 /*
1043  * XXXRW/JA: Shouldn't return next data for nodes that we don't permit in
1044  * capability mode.
1045  */
1046 static SYSCTL_NODE(_sysctl, 2, next, CTLFLAG_RD | CTLFLAG_MPSAFE | CTLFLAG_CAPRD,
1047     sysctl_sysctl_next, "");
1048 
1049 static int
1050 name2oid(char *name, int *oid, int *len, struct sysctl_oid **oidpp)
1051 {
1052 	struct sysctl_oid *oidp;
1053 	struct sysctl_oid_list *lsp = &sysctl__children;
1054 	char *p;
1055 
1056 	SYSCTL_ASSERT_LOCKED();
1057 
1058 	for (*len = 0; *len < CTL_MAXNAME;) {
1059 		p = strsep(&name, ".");
1060 
1061 		oidp = SLIST_FIRST(lsp);
1062 		for (;; oidp = SLIST_NEXT(oidp, oid_link)) {
1063 			if (oidp == NULL)
1064 				return (ENOENT);
1065 			if (strcmp(p, oidp->oid_name) == 0)
1066 				break;
1067 		}
1068 		*oid++ = oidp->oid_number;
1069 		(*len)++;
1070 
1071 		if (name == NULL || *name == '\0') {
1072 			if (oidpp)
1073 				*oidpp = oidp;
1074 			return (0);
1075 		}
1076 
1077 		if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE)
1078 			break;
1079 
1080 		if (oidp->oid_handler)
1081 			break;
1082 
1083 		lsp = SYSCTL_CHILDREN(oidp);
1084 	}
1085 	return (ENOENT);
1086 }
1087 
1088 static int
1089 sysctl_sysctl_name2oid(SYSCTL_HANDLER_ARGS)
1090 {
1091 	char *p;
1092 	int error, oid[CTL_MAXNAME], len = 0;
1093 	struct sysctl_oid *op = NULL;
1094 	struct rm_priotracker tracker;
1095 
1096 	if (!req->newlen)
1097 		return (ENOENT);
1098 	if (req->newlen >= MAXPATHLEN)	/* XXX arbitrary, undocumented */
1099 		return (ENAMETOOLONG);
1100 
1101 	p = malloc(req->newlen+1, M_SYSCTL, M_WAITOK);
1102 
1103 	error = SYSCTL_IN(req, p, req->newlen);
1104 	if (error) {
1105 		free(p, M_SYSCTL);
1106 		return (error);
1107 	}
1108 
1109 	p [req->newlen] = '\0';
1110 
1111 	SYSCTL_RLOCK(&tracker);
1112 	error = name2oid(p, oid, &len, &op);
1113 	SYSCTL_RUNLOCK(&tracker);
1114 
1115 	free(p, M_SYSCTL);
1116 
1117 	if (error)
1118 		return (error);
1119 
1120 	error = SYSCTL_OUT(req, oid, len * sizeof *oid);
1121 	return (error);
1122 }
1123 
1124 /*
1125  * XXXRW/JA: Shouldn't return name2oid data for nodes that we don't permit in
1126  * capability mode.
1127  */
1128 SYSCTL_PROC(_sysctl, 3, name2oid,
1129     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_MPSAFE
1130     | CTLFLAG_CAPRW, 0, 0, sysctl_sysctl_name2oid, "I", "");
1131 
1132 static int
1133 sysctl_sysctl_oidfmt(SYSCTL_HANDLER_ARGS)
1134 {
1135 	struct sysctl_oid *oid;
1136 	struct rm_priotracker tracker;
1137 	int error;
1138 
1139 	SYSCTL_RLOCK(&tracker);
1140 	error = sysctl_find_oid(arg1, arg2, &oid, NULL, req);
1141 	if (error)
1142 		goto out;
1143 
1144 	if (oid->oid_fmt == NULL) {
1145 		error = ENOENT;
1146 		goto out;
1147 	}
1148 	error = SYSCTL_OUT(req, &oid->oid_kind, sizeof(oid->oid_kind));
1149 	if (error)
1150 		goto out;
1151 	error = SYSCTL_OUT(req, oid->oid_fmt, strlen(oid->oid_fmt) + 1);
1152  out:
1153 	SYSCTL_RUNLOCK(&tracker);
1154 	return (error);
1155 }
1156 
1157 
1158 static SYSCTL_NODE(_sysctl, 4, oidfmt, CTLFLAG_RD|CTLFLAG_MPSAFE|CTLFLAG_CAPRD,
1159     sysctl_sysctl_oidfmt, "");
1160 
1161 static int
1162 sysctl_sysctl_oiddescr(SYSCTL_HANDLER_ARGS)
1163 {
1164 	struct sysctl_oid *oid;
1165 	struct rm_priotracker tracker;
1166 	int error;
1167 
1168 	SYSCTL_RLOCK(&tracker);
1169 	error = sysctl_find_oid(arg1, arg2, &oid, NULL, req);
1170 	if (error)
1171 		goto out;
1172 
1173 	if (oid->oid_descr == NULL) {
1174 		error = ENOENT;
1175 		goto out;
1176 	}
1177 	error = SYSCTL_OUT(req, oid->oid_descr, strlen(oid->oid_descr) + 1);
1178  out:
1179 	SYSCTL_RUNLOCK(&tracker);
1180 	return (error);
1181 }
1182 
1183 static SYSCTL_NODE(_sysctl, 5, oiddescr, CTLFLAG_RD|CTLFLAG_MPSAFE|CTLFLAG_CAPRD,
1184     sysctl_sysctl_oiddescr, "");
1185 
1186 static int
1187 sysctl_sysctl_oidlabel(SYSCTL_HANDLER_ARGS)
1188 {
1189 	struct sysctl_oid *oid;
1190 	struct rm_priotracker tracker;
1191 	int error;
1192 
1193 	SYSCTL_RLOCK(&tracker);
1194 	error = sysctl_find_oid(arg1, arg2, &oid, NULL, req);
1195 	if (error)
1196 		goto out;
1197 
1198 	if (oid->oid_label == NULL) {
1199 		error = ENOENT;
1200 		goto out;
1201 	}
1202 	error = SYSCTL_OUT(req, oid->oid_label, strlen(oid->oid_label) + 1);
1203  out:
1204 	SYSCTL_RUNLOCK(&tracker);
1205 	return (error);
1206 }
1207 
1208 static SYSCTL_NODE(_sysctl, 6, oidlabel,
1209     CTLFLAG_RD | CTLFLAG_MPSAFE | CTLFLAG_CAPRD, sysctl_sysctl_oidlabel, "");
1210 
1211 /*
1212  * Default "handler" functions.
1213  */
1214 
1215 /*
1216  * Handle a bool.
1217  * Two cases:
1218  *     a variable:  point arg1 at it.
1219  *     a constant:  pass it in arg2.
1220  */
1221 
1222 int
1223 sysctl_handle_bool(SYSCTL_HANDLER_ARGS)
1224 {
1225 	uint8_t temp;
1226 	int error;
1227 
1228 	/*
1229 	 * Attempt to get a coherent snapshot by making a copy of the data.
1230 	 */
1231 	if (arg1)
1232 		temp = *(bool *)arg1 ? 1 : 0;
1233 	else
1234 		temp = arg2 ? 1 : 0;
1235 
1236 	error = SYSCTL_OUT(req, &temp, sizeof(temp));
1237 	if (error || !req->newptr)
1238 		return (error);
1239 
1240 	if (!arg1)
1241 		error = EPERM;
1242 	else {
1243 		error = SYSCTL_IN(req, &temp, sizeof(temp));
1244 		if (!error)
1245 			*(bool *)arg1 = temp ? 1 : 0;
1246 	}
1247 	return (error);
1248 }
1249 
1250 /*
1251  * Handle an int8_t, signed or unsigned.
1252  * Two cases:
1253  *     a variable:  point arg1 at it.
1254  *     a constant:  pass it in arg2.
1255  */
1256 
1257 int
1258 sysctl_handle_8(SYSCTL_HANDLER_ARGS)
1259 {
1260 	int8_t tmpout;
1261 	int error = 0;
1262 
1263 	/*
1264 	 * Attempt to get a coherent snapshot by making a copy of the data.
1265 	 */
1266 	if (arg1)
1267 		tmpout = *(int8_t *)arg1;
1268 	else
1269 		tmpout = arg2;
1270 	error = SYSCTL_OUT(req, &tmpout, sizeof(tmpout));
1271 
1272 	if (error || !req->newptr)
1273 		return (error);
1274 
1275 	if (!arg1)
1276 		error = EPERM;
1277 	else
1278 		error = SYSCTL_IN(req, arg1, sizeof(tmpout));
1279 	return (error);
1280 }
1281 
1282 /*
1283  * Handle an int16_t, signed or unsigned.
1284  * Two cases:
1285  *     a variable:  point arg1 at it.
1286  *     a constant:  pass it in arg2.
1287  */
1288 
1289 int
1290 sysctl_handle_16(SYSCTL_HANDLER_ARGS)
1291 {
1292 	int16_t tmpout;
1293 	int error = 0;
1294 
1295 	/*
1296 	 * Attempt to get a coherent snapshot by making a copy of the data.
1297 	 */
1298 	if (arg1)
1299 		tmpout = *(int16_t *)arg1;
1300 	else
1301 		tmpout = arg2;
1302 	error = SYSCTL_OUT(req, &tmpout, sizeof(tmpout));
1303 
1304 	if (error || !req->newptr)
1305 		return (error);
1306 
1307 	if (!arg1)
1308 		error = EPERM;
1309 	else
1310 		error = SYSCTL_IN(req, arg1, sizeof(tmpout));
1311 	return (error);
1312 }
1313 
1314 /*
1315  * Handle an int32_t, signed or unsigned.
1316  * Two cases:
1317  *     a variable:  point arg1 at it.
1318  *     a constant:  pass it in arg2.
1319  */
1320 
1321 int
1322 sysctl_handle_32(SYSCTL_HANDLER_ARGS)
1323 {
1324 	int32_t tmpout;
1325 	int error = 0;
1326 
1327 	/*
1328 	 * Attempt to get a coherent snapshot by making a copy of the data.
1329 	 */
1330 	if (arg1)
1331 		tmpout = *(int32_t *)arg1;
1332 	else
1333 		tmpout = arg2;
1334 	error = SYSCTL_OUT(req, &tmpout, sizeof(tmpout));
1335 
1336 	if (error || !req->newptr)
1337 		return (error);
1338 
1339 	if (!arg1)
1340 		error = EPERM;
1341 	else
1342 		error = SYSCTL_IN(req, arg1, sizeof(tmpout));
1343 	return (error);
1344 }
1345 
1346 /*
1347  * Handle an int, signed or unsigned.
1348  * Two cases:
1349  *     a variable:  point arg1 at it.
1350  *     a constant:  pass it in arg2.
1351  */
1352 
1353 int
1354 sysctl_handle_int(SYSCTL_HANDLER_ARGS)
1355 {
1356 	int tmpout, error = 0;
1357 
1358 	/*
1359 	 * Attempt to get a coherent snapshot by making a copy of the data.
1360 	 */
1361 	if (arg1)
1362 		tmpout = *(int *)arg1;
1363 	else
1364 		tmpout = arg2;
1365 	error = SYSCTL_OUT(req, &tmpout, sizeof(int));
1366 
1367 	if (error || !req->newptr)
1368 		return (error);
1369 
1370 	if (!arg1)
1371 		error = EPERM;
1372 	else
1373 		error = SYSCTL_IN(req, arg1, sizeof(int));
1374 	return (error);
1375 }
1376 
1377 /*
1378  * Based on on sysctl_handle_int() convert milliseconds into ticks.
1379  * Note: this is used by TCP.
1380  */
1381 
1382 int
1383 sysctl_msec_to_ticks(SYSCTL_HANDLER_ARGS)
1384 {
1385 	int error, s, tt;
1386 
1387 	tt = *(int *)arg1;
1388 	s = (int)((int64_t)tt * 1000 / hz);
1389 
1390 	error = sysctl_handle_int(oidp, &s, 0, req);
1391 	if (error || !req->newptr)
1392 		return (error);
1393 
1394 	tt = (int)((int64_t)s * hz / 1000);
1395 	if (tt < 1)
1396 		return (EINVAL);
1397 
1398 	*(int *)arg1 = tt;
1399 	return (0);
1400 }
1401 
1402 
1403 /*
1404  * Handle a long, signed or unsigned.
1405  * Two cases:
1406  *     a variable:  point arg1 at it.
1407  *     a constant:  pass it in arg2.
1408  */
1409 
1410 int
1411 sysctl_handle_long(SYSCTL_HANDLER_ARGS)
1412 {
1413 	int error = 0;
1414 	long tmplong;
1415 #ifdef SCTL_MASK32
1416 	int tmpint;
1417 #endif
1418 
1419 	/*
1420 	 * Attempt to get a coherent snapshot by making a copy of the data.
1421 	 */
1422 	if (arg1)
1423 		tmplong = *(long *)arg1;
1424 	else
1425 		tmplong = arg2;
1426 #ifdef SCTL_MASK32
1427 	if (req->flags & SCTL_MASK32) {
1428 		tmpint = tmplong;
1429 		error = SYSCTL_OUT(req, &tmpint, sizeof(int));
1430 	} else
1431 #endif
1432 		error = SYSCTL_OUT(req, &tmplong, sizeof(long));
1433 
1434 	if (error || !req->newptr)
1435 		return (error);
1436 
1437 	if (!arg1)
1438 		error = EPERM;
1439 #ifdef SCTL_MASK32
1440 	else if (req->flags & SCTL_MASK32) {
1441 		error = SYSCTL_IN(req, &tmpint, sizeof(int));
1442 		*(long *)arg1 = (long)tmpint;
1443 	}
1444 #endif
1445 	else
1446 		error = SYSCTL_IN(req, arg1, sizeof(long));
1447 	return (error);
1448 }
1449 
1450 /*
1451  * Handle a 64 bit int, signed or unsigned.
1452  * Two cases:
1453  *     a variable:  point arg1 at it.
1454  *     a constant:  pass it in arg2.
1455  */
1456 int
1457 sysctl_handle_64(SYSCTL_HANDLER_ARGS)
1458 {
1459 	int error = 0;
1460 	uint64_t tmpout;
1461 
1462 	/*
1463 	 * Attempt to get a coherent snapshot by making a copy of the data.
1464 	 */
1465 	if (arg1)
1466 		tmpout = *(uint64_t *)arg1;
1467 	else
1468 		tmpout = arg2;
1469 	error = SYSCTL_OUT(req, &tmpout, sizeof(uint64_t));
1470 
1471 	if (error || !req->newptr)
1472 		return (error);
1473 
1474 	if (!arg1)
1475 		error = EPERM;
1476 	else
1477 		error = SYSCTL_IN(req, arg1, sizeof(uint64_t));
1478 	return (error);
1479 }
1480 
1481 /*
1482  * Handle our generic '\0' terminated 'C' string.
1483  * Two cases:
1484  * 	a variable string:  point arg1 at it, arg2 is max length.
1485  * 	a constant string:  point arg1 at it, arg2 is zero.
1486  */
1487 
1488 int
1489 sysctl_handle_string(SYSCTL_HANDLER_ARGS)
1490 {
1491 	size_t outlen;
1492 	int error = 0, ro_string = 0;
1493 
1494 	/*
1495 	 * A zero-length buffer indicates a fixed size read-only
1496 	 * string:
1497 	 */
1498 	if (arg2 == 0) {
1499 		arg2 = strlen((char *)arg1) + 1;
1500 		ro_string = 1;
1501 	}
1502 
1503 	if (req->oldptr != NULL) {
1504 		char *tmparg;
1505 
1506 		if (ro_string) {
1507 			tmparg = arg1;
1508 		} else {
1509 			/* try to make a coherent snapshot of the string */
1510 			tmparg = malloc(arg2, M_SYSCTLTMP, M_WAITOK);
1511 			memcpy(tmparg, arg1, arg2);
1512 		}
1513 
1514 		outlen = strnlen(tmparg, arg2 - 1) + 1;
1515 		error = SYSCTL_OUT(req, tmparg, outlen);
1516 
1517 		if (!ro_string)
1518 			free(tmparg, M_SYSCTLTMP);
1519 	} else {
1520 		outlen = strnlen((char *)arg1, arg2 - 1) + 1;
1521 		error = SYSCTL_OUT(req, NULL, outlen);
1522 	}
1523 	if (error || !req->newptr)
1524 		return (error);
1525 
1526 	if ((req->newlen - req->newidx) >= arg2) {
1527 		error = EINVAL;
1528 	} else {
1529 		arg2 = (req->newlen - req->newidx);
1530 		error = SYSCTL_IN(req, arg1, arg2);
1531 		((char *)arg1)[arg2] = '\0';
1532 	}
1533 	return (error);
1534 }
1535 
1536 /*
1537  * Handle any kind of opaque data.
1538  * arg1 points to it, arg2 is the size.
1539  */
1540 
1541 int
1542 sysctl_handle_opaque(SYSCTL_HANDLER_ARGS)
1543 {
1544 	int error, tries;
1545 	u_int generation;
1546 	struct sysctl_req req2;
1547 
1548 	/*
1549 	 * Attempt to get a coherent snapshot, by using the thread
1550 	 * pre-emption counter updated from within mi_switch() to
1551 	 * determine if we were pre-empted during a bcopy() or
1552 	 * copyout(). Make 3 attempts at doing this before giving up.
1553 	 * If we encounter an error, stop immediately.
1554 	 */
1555 	tries = 0;
1556 	req2 = *req;
1557 retry:
1558 	generation = curthread->td_generation;
1559 	error = SYSCTL_OUT(req, arg1, arg2);
1560 	if (error)
1561 		return (error);
1562 	tries++;
1563 	if (generation != curthread->td_generation && tries < 3) {
1564 		*req = req2;
1565 		goto retry;
1566 	}
1567 
1568 	error = SYSCTL_IN(req, arg1, arg2);
1569 
1570 	return (error);
1571 }
1572 
1573 /*
1574  * Transfer functions to/from kernel space.
1575  * XXX: rather untested at this point
1576  */
1577 static int
1578 sysctl_old_kernel(struct sysctl_req *req, const void *p, size_t l)
1579 {
1580 	size_t i = 0;
1581 
1582 	if (req->oldptr) {
1583 		i = l;
1584 		if (req->oldlen <= req->oldidx)
1585 			i = 0;
1586 		else
1587 			if (i > req->oldlen - req->oldidx)
1588 				i = req->oldlen - req->oldidx;
1589 		if (i > 0)
1590 			bcopy(p, (char *)req->oldptr + req->oldidx, i);
1591 	}
1592 	req->oldidx += l;
1593 	if (req->oldptr && i != l)
1594 		return (ENOMEM);
1595 	return (0);
1596 }
1597 
1598 static int
1599 sysctl_new_kernel(struct sysctl_req *req, void *p, size_t l)
1600 {
1601 	if (!req->newptr)
1602 		return (0);
1603 	if (req->newlen - req->newidx < l)
1604 		return (EINVAL);
1605 	bcopy((char *)req->newptr + req->newidx, p, l);
1606 	req->newidx += l;
1607 	return (0);
1608 }
1609 
1610 int
1611 kernel_sysctl(struct thread *td, int *name, u_int namelen, void *old,
1612     size_t *oldlenp, void *new, size_t newlen, size_t *retval, int flags)
1613 {
1614 	int error = 0;
1615 	struct sysctl_req req;
1616 
1617 	bzero(&req, sizeof req);
1618 
1619 	req.td = td;
1620 	req.flags = flags;
1621 
1622 	if (oldlenp) {
1623 		req.oldlen = *oldlenp;
1624 	}
1625 	req.validlen = req.oldlen;
1626 
1627 	if (old) {
1628 		req.oldptr= old;
1629 	}
1630 
1631 	if (new != NULL) {
1632 		req.newlen = newlen;
1633 		req.newptr = new;
1634 	}
1635 
1636 	req.oldfunc = sysctl_old_kernel;
1637 	req.newfunc = sysctl_new_kernel;
1638 	req.lock = REQ_UNWIRED;
1639 
1640 	error = sysctl_root(0, name, namelen, &req);
1641 
1642 	if (req.lock == REQ_WIRED && req.validlen > 0)
1643 		vsunlock(req.oldptr, req.validlen);
1644 
1645 	if (error && error != ENOMEM)
1646 		return (error);
1647 
1648 	if (retval) {
1649 		if (req.oldptr && req.oldidx > req.validlen)
1650 			*retval = req.validlen;
1651 		else
1652 			*retval = req.oldidx;
1653 	}
1654 	return (error);
1655 }
1656 
1657 int
1658 kernel_sysctlbyname(struct thread *td, char *name, void *old, size_t *oldlenp,
1659     void *new, size_t newlen, size_t *retval, int flags)
1660 {
1661         int oid[CTL_MAXNAME];
1662         size_t oidlen, plen;
1663 	int error;
1664 
1665 	oid[0] = 0;		/* sysctl internal magic */
1666 	oid[1] = 3;		/* name2oid */
1667 	oidlen = sizeof(oid);
1668 
1669 	error = kernel_sysctl(td, oid, 2, oid, &oidlen,
1670 	    (void *)name, strlen(name), &plen, flags);
1671 	if (error)
1672 		return (error);
1673 
1674 	error = kernel_sysctl(td, oid, plen / sizeof(int), old, oldlenp,
1675 	    new, newlen, retval, flags);
1676 	return (error);
1677 }
1678 
1679 /*
1680  * Transfer function to/from user space.
1681  */
1682 static int
1683 sysctl_old_user(struct sysctl_req *req, const void *p, size_t l)
1684 {
1685 	size_t i, len, origidx;
1686 	int error;
1687 
1688 	origidx = req->oldidx;
1689 	req->oldidx += l;
1690 	if (req->oldptr == NULL)
1691 		return (0);
1692 	/*
1693 	 * If we have not wired the user supplied buffer and we are currently
1694 	 * holding locks, drop a witness warning, as it's possible that
1695 	 * write operations to the user page can sleep.
1696 	 */
1697 	if (req->lock != REQ_WIRED)
1698 		WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL,
1699 		    "sysctl_old_user()");
1700 	i = l;
1701 	len = req->validlen;
1702 	if (len <= origidx)
1703 		i = 0;
1704 	else {
1705 		if (i > len - origidx)
1706 			i = len - origidx;
1707 		if (req->lock == REQ_WIRED) {
1708 			error = copyout_nofault(p, (char *)req->oldptr +
1709 			    origidx, i);
1710 		} else
1711 			error = copyout(p, (char *)req->oldptr + origidx, i);
1712 		if (error != 0)
1713 			return (error);
1714 	}
1715 	if (i < l)
1716 		return (ENOMEM);
1717 	return (0);
1718 }
1719 
1720 static int
1721 sysctl_new_user(struct sysctl_req *req, void *p, size_t l)
1722 {
1723 	int error;
1724 
1725 	if (!req->newptr)
1726 		return (0);
1727 	if (req->newlen - req->newidx < l)
1728 		return (EINVAL);
1729 	WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL,
1730 	    "sysctl_new_user()");
1731 	error = copyin((char *)req->newptr + req->newidx, p, l);
1732 	req->newidx += l;
1733 	return (error);
1734 }
1735 
1736 /*
1737  * Wire the user space destination buffer.  If set to a value greater than
1738  * zero, the len parameter limits the maximum amount of wired memory.
1739  */
1740 int
1741 sysctl_wire_old_buffer(struct sysctl_req *req, size_t len)
1742 {
1743 	int ret;
1744 	size_t wiredlen;
1745 
1746 	wiredlen = (len > 0 && len < req->oldlen) ? len : req->oldlen;
1747 	ret = 0;
1748 	if (req->lock != REQ_WIRED && req->oldptr &&
1749 	    req->oldfunc == sysctl_old_user) {
1750 		if (wiredlen != 0) {
1751 			ret = vslock(req->oldptr, wiredlen);
1752 			if (ret != 0) {
1753 				if (ret != ENOMEM)
1754 					return (ret);
1755 				wiredlen = 0;
1756 			}
1757 		}
1758 		req->lock = REQ_WIRED;
1759 		req->validlen = wiredlen;
1760 	}
1761 	return (0);
1762 }
1763 
1764 int
1765 sysctl_find_oid(int *name, u_int namelen, struct sysctl_oid **noid,
1766     int *nindx, struct sysctl_req *req)
1767 {
1768 	struct sysctl_oid_list *lsp;
1769 	struct sysctl_oid *oid;
1770 	int indx;
1771 
1772 	SYSCTL_ASSERT_LOCKED();
1773 	lsp = &sysctl__children;
1774 	indx = 0;
1775 	while (indx < CTL_MAXNAME) {
1776 		SLIST_FOREACH(oid, lsp, oid_link) {
1777 			if (oid->oid_number == name[indx])
1778 				break;
1779 		}
1780 		if (oid == NULL)
1781 			return (ENOENT);
1782 
1783 		indx++;
1784 		if ((oid->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
1785 			if (oid->oid_handler != NULL || indx == namelen) {
1786 				*noid = oid;
1787 				if (nindx != NULL)
1788 					*nindx = indx;
1789 				KASSERT((oid->oid_kind & CTLFLAG_DYING) == 0,
1790 				    ("%s found DYING node %p", __func__, oid));
1791 				return (0);
1792 			}
1793 			lsp = SYSCTL_CHILDREN(oid);
1794 		} else if (indx == namelen) {
1795 			*noid = oid;
1796 			if (nindx != NULL)
1797 				*nindx = indx;
1798 			KASSERT((oid->oid_kind & CTLFLAG_DYING) == 0,
1799 			    ("%s found DYING node %p", __func__, oid));
1800 			return (0);
1801 		} else {
1802 			return (ENOTDIR);
1803 		}
1804 	}
1805 	return (ENOENT);
1806 }
1807 
1808 /*
1809  * Traverse our tree, and find the right node, execute whatever it points
1810  * to, and return the resulting error code.
1811  */
1812 
1813 static int
1814 sysctl_root(SYSCTL_HANDLER_ARGS)
1815 {
1816 	struct sysctl_oid *oid;
1817 	struct rm_priotracker tracker;
1818 	int error, indx, lvl;
1819 
1820 	SYSCTL_RLOCK(&tracker);
1821 
1822 	error = sysctl_find_oid(arg1, arg2, &oid, &indx, req);
1823 	if (error)
1824 		goto out;
1825 
1826 	if ((oid->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
1827 		/*
1828 		 * You can't call a sysctl when it's a node, but has
1829 		 * no handler.  Inform the user that it's a node.
1830 		 * The indx may or may not be the same as namelen.
1831 		 */
1832 		if (oid->oid_handler == NULL) {
1833 			error = EISDIR;
1834 			goto out;
1835 		}
1836 	}
1837 
1838 	/* Is this sysctl writable? */
1839 	if (req->newptr && !(oid->oid_kind & CTLFLAG_WR)) {
1840 		error = EPERM;
1841 		goto out;
1842 	}
1843 
1844 	KASSERT(req->td != NULL, ("sysctl_root(): req->td == NULL"));
1845 
1846 #ifdef CAPABILITY_MODE
1847 	/*
1848 	 * If the process is in capability mode, then don't permit reading or
1849 	 * writing unless specifically granted for the node.
1850 	 */
1851 	if (IN_CAPABILITY_MODE(req->td)) {
1852 		if ((req->oldptr && !(oid->oid_kind & CTLFLAG_CAPRD)) ||
1853 		    (req->newptr && !(oid->oid_kind & CTLFLAG_CAPWR))) {
1854 			error = EPERM;
1855 			goto out;
1856 		}
1857 	}
1858 #endif
1859 
1860 	/* Is this sysctl sensitive to securelevels? */
1861 	if (req->newptr && (oid->oid_kind & CTLFLAG_SECURE)) {
1862 		lvl = (oid->oid_kind & CTLMASK_SECURE) >> CTLSHIFT_SECURE;
1863 		error = securelevel_gt(req->td->td_ucred, lvl);
1864 		if (error)
1865 			goto out;
1866 	}
1867 
1868 	/* Is this sysctl writable by only privileged users? */
1869 	if (req->newptr && !(oid->oid_kind & CTLFLAG_ANYBODY)) {
1870 		int priv;
1871 
1872 		if (oid->oid_kind & CTLFLAG_PRISON)
1873 			priv = PRIV_SYSCTL_WRITEJAIL;
1874 #ifdef VIMAGE
1875 		else if ((oid->oid_kind & CTLFLAG_VNET) &&
1876 		     prison_owns_vnet(req->td->td_ucred))
1877 			priv = PRIV_SYSCTL_WRITEJAIL;
1878 #endif
1879 		else
1880 			priv = PRIV_SYSCTL_WRITE;
1881 		error = priv_check(req->td, priv);
1882 		if (error)
1883 			goto out;
1884 	}
1885 
1886 	if (!oid->oid_handler) {
1887 		error = EINVAL;
1888 		goto out;
1889 	}
1890 
1891 	if ((oid->oid_kind & CTLTYPE) == CTLTYPE_NODE) {
1892 		arg1 = (int *)arg1 + indx;
1893 		arg2 -= indx;
1894 	} else {
1895 		arg1 = oid->oid_arg1;
1896 		arg2 = oid->oid_arg2;
1897 	}
1898 #ifdef MAC
1899 	error = mac_system_check_sysctl(req->td->td_ucred, oid, arg1, arg2,
1900 	    req);
1901 	if (error != 0)
1902 		goto out;
1903 #endif
1904 #ifdef VIMAGE
1905 	if ((oid->oid_kind & CTLFLAG_VNET) && arg1 != NULL)
1906 		arg1 = (void *)(curvnet->vnet_data_base + (uintptr_t)arg1);
1907 #endif
1908 	error = sysctl_root_handler_locked(oid, arg1, arg2, req, &tracker);
1909 
1910 out:
1911 	SYSCTL_RUNLOCK(&tracker);
1912 	return (error);
1913 }
1914 
1915 #ifndef _SYS_SYSPROTO_H_
1916 struct sysctl_args {
1917 	int	*name;
1918 	u_int	namelen;
1919 	void	*old;
1920 	size_t	*oldlenp;
1921 	void	*new;
1922 	size_t	newlen;
1923 };
1924 #endif
1925 int
1926 sys___sysctl(struct thread *td, struct sysctl_args *uap)
1927 {
1928 	int error, i, name[CTL_MAXNAME];
1929 	size_t j;
1930 
1931 	if (uap->namelen > CTL_MAXNAME || uap->namelen < 2)
1932 		return (EINVAL);
1933 
1934  	error = copyin(uap->name, &name, uap->namelen * sizeof(int));
1935  	if (error)
1936 		return (error);
1937 
1938 	error = userland_sysctl(td, name, uap->namelen,
1939 		uap->old, uap->oldlenp, 0,
1940 		uap->new, uap->newlen, &j, 0);
1941 	if (error && error != ENOMEM)
1942 		return (error);
1943 	if (uap->oldlenp) {
1944 		i = copyout(&j, uap->oldlenp, sizeof(j));
1945 		if (i)
1946 			return (i);
1947 	}
1948 	return (error);
1949 }
1950 
1951 /*
1952  * This is used from various compatibility syscalls too.  That's why name
1953  * must be in kernel space.
1954  */
1955 int
1956 userland_sysctl(struct thread *td, int *name, u_int namelen, void *old,
1957     size_t *oldlenp, int inkernel, void *new, size_t newlen, size_t *retval,
1958     int flags)
1959 {
1960 	int error = 0, memlocked;
1961 	struct sysctl_req req;
1962 
1963 	bzero(&req, sizeof req);
1964 
1965 	req.td = td;
1966 	req.flags = flags;
1967 
1968 	if (oldlenp) {
1969 		if (inkernel) {
1970 			req.oldlen = *oldlenp;
1971 		} else {
1972 			error = copyin(oldlenp, &req.oldlen, sizeof(*oldlenp));
1973 			if (error)
1974 				return (error);
1975 		}
1976 	}
1977 	req.validlen = req.oldlen;
1978 
1979 	if (old) {
1980 		if (!useracc(old, req.oldlen, VM_PROT_WRITE))
1981 			return (EFAULT);
1982 		req.oldptr= old;
1983 	}
1984 
1985 	if (new != NULL) {
1986 		if (!useracc(new, newlen, VM_PROT_READ))
1987 			return (EFAULT);
1988 		req.newlen = newlen;
1989 		req.newptr = new;
1990 	}
1991 
1992 	req.oldfunc = sysctl_old_user;
1993 	req.newfunc = sysctl_new_user;
1994 	req.lock = REQ_UNWIRED;
1995 
1996 #ifdef KTRACE
1997 	if (KTRPOINT(curthread, KTR_SYSCTL))
1998 		ktrsysctl(name, namelen);
1999 #endif
2000 
2001 	if (req.oldptr && req.oldlen > PAGE_SIZE) {
2002 		memlocked = 1;
2003 		sx_xlock(&sysctlmemlock);
2004 	} else
2005 		memlocked = 0;
2006 	CURVNET_SET(TD_TO_VNET(td));
2007 
2008 	for (;;) {
2009 		req.oldidx = 0;
2010 		req.newidx = 0;
2011 		error = sysctl_root(0, name, namelen, &req);
2012 		if (error != EAGAIN)
2013 			break;
2014 		kern_yield(PRI_USER);
2015 	}
2016 
2017 	CURVNET_RESTORE();
2018 
2019 	if (req.lock == REQ_WIRED && req.validlen > 0)
2020 		vsunlock(req.oldptr, req.validlen);
2021 	if (memlocked)
2022 		sx_xunlock(&sysctlmemlock);
2023 
2024 	if (error && error != ENOMEM)
2025 		return (error);
2026 
2027 	if (retval) {
2028 		if (req.oldptr && req.oldidx > req.validlen)
2029 			*retval = req.validlen;
2030 		else
2031 			*retval = req.oldidx;
2032 	}
2033 	return (error);
2034 }
2035 
2036 /*
2037  * Drain into a sysctl struct.  The user buffer should be wired if a page
2038  * fault would cause issue.
2039  */
2040 static int
2041 sbuf_sysctl_drain(void *arg, const char *data, int len)
2042 {
2043 	struct sysctl_req *req = arg;
2044 	int error;
2045 
2046 	error = SYSCTL_OUT(req, data, len);
2047 	KASSERT(error >= 0, ("Got unexpected negative value %d", error));
2048 	return (error == 0 ? len : -error);
2049 }
2050 
2051 struct sbuf *
2052 sbuf_new_for_sysctl(struct sbuf *s, char *buf, int length,
2053     struct sysctl_req *req)
2054 {
2055 
2056 	/* Supply a default buffer size if none given. */
2057 	if (buf == NULL && length == 0)
2058 		length = 64;
2059 	s = sbuf_new(s, buf, length, SBUF_FIXEDLEN | SBUF_INCLUDENUL);
2060 	sbuf_set_drain(s, sbuf_sysctl_drain, req);
2061 	return (s);
2062 }
2063